get rid of dtom's in kernel

[unix-history] / usr / src / sys / netccitt / if_x25subr.c

diff --git a/usr/src/sys/netccitt/if_x25subr.c b/usr/src/sys/netccitt/if_x25subr.c
index 50ba6c3..fab0f90 100644 (file)
--- a/usr/src/sys/netccitt/if_x25subr.c
+++ b/usr/src/sys/netccitt/if_x25subr.c
@@ -1,20 +1,10 @@
 /*
 /*

- * Copyright (c) 1989 Regents of the University of California.
+ * Copyright (c) 1990 The Regents of the University of California.

  * All rights reserved.
  *
  * All rights reserved.
  *

- * Redistribution and use in source and binary forms are permitted
- * provided that the above copyright notice and this paragraph are
- * duplicated in all such forms and that any documentation,
- * advertising materials, and other materials related to such
- * distribution and use acknowledge that the software was developed
- * by the University of California, Berkeley.  The name of the
- * University may not be used to endorse or promote products derived
- * from this software without specific prior written permission.
- * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
- * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
- * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ * %sccs.include.redist.c%

  *
  *

- *     @(#)if_x25subr.c        0.1 (Berkeley) 9/20/89
+ *     @(#)if_x25subr.c        7.7 (Berkeley) %G%

  */
 
 #include "param.h"
  */
 
 #include "param.h"


@@ -23,16 +13,21 @@
 #include "mbuf.h"
 #include "protosw.h"
 #include "socket.h"
 #include "mbuf.h"
 #include "protosw.h"
 #include "socket.h"

+#include "socketvar.h"

 #include "ioctl.h"
 #include "errno.h"
 #include "syslog.h"
 
 #include "ioctl.h"
 #include "errno.h"
 #include "syslog.h"
 

-#include "if.h"
-#include "netisr.h"
-#include "route.h"
+#include "../net/if.h"
+#include "../net/if_types.h"
+#include "../net/netisr.h"
+#include "../net/route.h"
+
+#include "x25.h"
+#include "x25err.h"
+#include "pk.h"
+#include "pk_var.h"

 
 

-#include "x25_var.h"
-#include "x25_pk.h"

 #include "machine/mtpr.h"
 
 #ifdef INET
 #include "machine/mtpr.h"
 
 #ifdef INET


@@ -53,112 +48,121 @@
 
 extern struct ifnet loif;
 
 
 extern struct ifnet loif;
 

+union imp_addr {
+       struct in_addr  ip;
+       struct imp {
+               u_char          s_net;
+               u_char          s_host;
+               u_char          s_lh;
+               u_char          s_impno;
+       }                   imp;
+};
+

 #define senderr(x) {error = x; goto bad;}
 /*
  * X.25 output routine.
  */
 #define senderr(x) {error = x; goto bad;}
 /*
  * X.25 output routine.
  */

-x25_ifoutput(xc, m0, dst, rt)
-struct x25com *xc;
+x25_ifoutput(ifp, m0, dst, rt)
+struct ifnet *ifp;

 struct mbuf *m0;
 struct sockaddr *dst;
 register struct        rtentry *rt;
 {
 struct mbuf *m0;
 struct sockaddr *dst;
 register struct        rtentry *rt;
 {

-       register struct mbuf *m = m0;
-       register struct x25lcb *xl;
-       register struct xq *oq;
-       register struct x25lcb **xlp;
+       register struct mbuf *m;
+       register struct llinfo_x25 *lx;
+       register struct pq *pq;
+       struct pklcd *lcp;
+       struct x25_ifaddr *ia;

        struct mbuf    *prev;
        struct mbuf    *prev;

-       int             s, error = 0, flags = 0;
+       int             s, error = 0, flags = 0, af;

        union imp_addr  imp_addr;
        union imp_addr  imp_addr;

-       int flags = 0;

 
 

-       if ((xc->xc_if.if_flags & IFF_UP) == 0)
+       if ((ifp->if_flags & IFF_UP) == 0)

                return (ENETDOWN);
        if (rt == 0 ||
            ((rt->rt_flags & RTF_GATEWAY) && (dst = rt->rt_gateway))) {
                if ((rt = rtalloc1(dst, 1)) == 0)
                        return (EHOSTUNREACH);
                rt->rt_refcnt++;
                return (ENETDOWN);
        if (rt == 0 ||
            ((rt->rt_flags & RTF_GATEWAY) && (dst = rt->rt_gateway))) {
                if ((rt = rtalloc1(dst, 1)) == 0)
                        return (EHOSTUNREACH);
                rt->rt_refcnt++;

-               flags = XL_RTHELD;
+               flags = LXF_RTHELD;

        }
        /*
         * Sanity checks.
         */
        }
        /*
         * Sanity checks.
         */

-       if ((rt->rt_ifp != (struct ifnet *)xc) ||
+       if ((rt->rt_ifp != ifp) ||

            (rt->rt_flags & (RTF_CLONING | RTF_GATEWAY)) ||
            (rt->rt_flags & (RTF_CLONING | RTF_GATEWAY)) ||

-           ((xl = (struct x25lcb *)rt->rt_llinfo) == 0)) {
+           ((lx = (struct llinfo_x25 *)rt->rt_llinfo) == 0)) {

                printf("Inconsistent call to x25_output, should panic\n");
                senderr(ENETUNREACH);
        }
                printf("Inconsistent call to x25_output, should panic\n");
                senderr(ENETUNREACH);
        }

-       xq = &xl->xl_downq;
-       switch (xl->xl_state) {
+    {
+       register struct ifaddr *ifa;
+       for (ifa = ifp->if_addrlist; ; ifa = ifa->ifa_next) {
+               if (ifa == 0)
+                       senderr(ENETDOWN);
+               if (ifa->ifa_addr->sa_family == AF_CCITT)
+                       break;
+       }
+       ia = (struct x25_ifaddr *)ifa;
+    }
+       if (lx->lx_lcd == 0) {
+               int x25_ifinput();

 
 

-       case XLS_CONNECTED:
-               xl->xl_timer = xc->xc_dg_idletimo;
+               lcp = pk_attach((struct socket *)0);
+               if (lcp == 0)
+                       senderr(ENOBUFS);
+               lx->lx_lcd = lcp;
+               lx->lx_rt = rt;
+               lx->lx_ia = ia;
+               lx->lx_family = dst->sa_family;
+               lcp->lcd_upnext = (caddr_t)lx;
+               lcp->lcd_upper = x25_ifinput;
+               lcp->lcd_packetsize = ia->ia_xc.xc_psize; /* XXX pk_fragment */
+       }
+       switch (lx->lx_state) {
+
+       case LXS_CONNECTED:
+               lcp->lcd_dg_timer = ia->ia_xc.xc_dg_idletimo;

                /* FALLTHROUGH */
                /* FALLTHROUGH */

-       case XLS_CONNECTING:
-               if (xq->xq_space < 0)
+       case LXS_CONNECTING:
+               if (sbspace(&lcp->lcd_sb) < 0)

                        senderr(ENOBUFS);
                        senderr(ENOBUFS);

-               xq->xq_put(xq, m);
+               lcp->lcd_send(lcp, m);

                break;
 
                break;
 

-       case XLS_NEWBORN:
-               xq = &xl->xl_upq;
-               xq->xq_next = (caddr_t)rt;
-               xq->xq_put = x25_ifinput;
+       case LXS_NEWBORN:

                if (dst->sa_family == AF_INET &&
                if (dst->sa_family == AF_INET &&

-                   xc->xc_if.if_type == IFT_DDN &&
+                   ia->ia_ifp->if_type == IFT_X25DDN &&

                    rt->rt_gateway->sa_family != AF_CCITT)
                        x25_ddnip_to_ccitt(dst, rt->rt_gateway);
                    rt->rt_gateway->sa_family != AF_CCITT)
                        x25_ddnip_to_ccitt(dst, rt->rt_gateway);

-               xl->xl_xc = xc;
-               xq = &xl->xl_downq;
-               xq->xq_space = 2048;  /* XXX: bogus xq before if_start called */
-               xl->xl_flags |= XL_DGRAM;
-               xl->xl_state = XLS_FREE;
+               lcp->lcd_flags |= X25_DG_CIRCUIT;
+               lx->lx_state = LXS_FREE;

                if (rt->rt_gateway->sa_family != AF_CCITT) {
                        /*
                         * Need external resolution of dst
                         */
                        if ((rt->rt_flags & RTF_XRESOLVE) == 0)
                                senderr(ENETUNREACH);
                if (rt->rt_gateway->sa_family != AF_CCITT) {
                        /*
                         * Need external resolution of dst
                         */
                        if ((rt->rt_flags & RTF_XRESOLVE) == 0)
                                senderr(ENETUNREACH);

-                       xl->xl_flags |= flags;
-                       xl->xl_timer = xc->xc_rslvtimo;
+                       lx->lx_flags |= flags;

                        flags = 0;
                        rt_missmsg(RTM_RESOLVE, dst,
                            (struct sockaddr *)0, (struct sockaddr *)0,
                            (struct sockaddr *)0, 0, 0);
                        flags = 0;
                        rt_missmsg(RTM_RESOLVE, dst,
                            (struct sockaddr *)0, (struct sockaddr *)0,
                            (struct sockaddr *)0, 0, 0);

-                       xl->xl_state = XLS_RESOLVING;
+                       lx->lx_state = LXS_RESOLVING;

                        /* FALLTHROUGH */
                        /* FALLTHROUGH */

-       case XLS_RESOLVING:
-                       if (xq->xq_space < 0)
+       case LXS_RESOLVING:
+                       if (sbspace(&lcp->lcd_sb) < 0)

                                senderr(ENOBUFS);
                                senderr(ENOBUFS);

-                       xq->xq_space -= m->m_pkthdr.len;
-                       if (xq->xq_data == 0)
-                               xq->xq_data = m;
-                       else {
-                               for (m = xq->xq_data; m->m_nextpkt; )
-                                       m = m->m_nextpkt;
-                               m->m_nextpkt = m0;
-                       }
+                       pk_fragment(lcp, m, 0, 0, 0);

                        break;
                }
                /* FALLTHROUGH */
                        break;
                }
                /* FALLTHROUGH */

-       case XLS_FREE:
-               xlp = xc->xc_lcbvec + xc->xc_nchan;
-               s = splimp(); /* need to block out incoming requests */
-               if (xc->xc_nactive < xc->xc_nchan) {
-                       while (--xlp > xc->xc_lcbvec && *xlp)
-                               ;
-                       if (xlp > xc->xc_lcbvec) {
-                               xc->xc_nactive++;
-                               *xlp = xl;
-                               xl->xl_index = xlp - xc->xc_lcbvec;
-                               x25_ifstart(xl, m, rt->rt_gateway, dst);
-                               splx(s);
-                               break;
-                       }
-               }
-               splx(s);
+       case LXS_FREE:
+               lcp->lcd_pkp = &(lx->lx_ia->ia_pkcb);
+               pk_fragment(lcp, m, 0, 0, 0);
+               pk_connect(lcp, (struct mbuf *)0,
+                               (struct sockaddr_x25 *)rt->rt_gateway);
+               break;

                /* FALLTHROUGH */
        default:
                /*
                /* FALLTHROUGH */
        default:
                /*


@@ -180,45 +184,88 @@ register struct   rtentry *rt;
                        m_freem(m);
        }
 out:
                        m_freem(m);
        }
 out:

-       if (flags & XL_RTHELD)
+       if (flags & LXF_RTHELD)

                RTFREE(rt);
        return (error);
 }
 
 /*
                RTFREE(rt);
        return (error);
 }
 
 /*

- * Simpleminded timer for very smart devices.
+ * Simpleminded timer routine.

  */
  */

-x25_iftimeout(xc)
-register struct x25com *xc;
+x25_iftimeout(ifp)
+struct ifnet *ifp;

 {
 {

-       register struct x25lcb **xlp = xc->xc_lcbvec + xc->xc_nchan;
-       register struct x25lcb *xl;
+       register struct pkcb *pkcb = 0;
+       register struct ifaddr *ifa;
+       register struct pklcd **lcpp, *lcp;

        int s = splimp();
 
        int s = splimp();
 

-       if (xc->xc_disconnect)
-           while (--xlp > xc->xc_lcbvec)
-               if ((xl = *xlp) && xl->xl_state == XLS_CONECTED &&
-                   (xl->xl_flags & XL_DGRAM) && --(xl->xl_timer) <= 0)
-                       xc->xc_disconnect(xl);
+       for (ifa = ifp->if_addrlist; ; ifa = ifa->ifa_next) {
+               if (ifa->ifa_addr->sa_family == AF_CCITT)
+                       break;
+       }
+       if (ifa)
+               pkcb = &((struct x25_ifaddr *)ifa)->ia_pkcb;
+       if (pkcb)
+               for (lcpp = pkcb->pk_chan + pkcb->pk_maxlcn;
+                    --lcpp >= pkcb->pk_chan;)
+                       if ((lcp = *lcpp) &&
+                           lcp->lcd_state == DATA_TRANSFER &&
+                           (lcp->lcd_flags & X25_DG_CIRCUIT) &&
+                           (--(lcp->lcd_dg_timer) <= 0)) {
+                               register struct llinfo_x25 *lx;
+                               pk_disconnect(lcp);
+                               lx = (struct llinfo_x25 *)
+                                               lcp->lcd_upnext;
+                               if (lx)
+                                       lx->lx_state = LXS_DISCONNECTING;
+                           }

        splx(s);
 }
 
 /*
  * Process a x25 packet as datagram;
  */
        splx(s);
 }
 
 /*
  * Process a x25 packet as datagram;
  */

-x25_ifinput(xq, m)
-struct xq *xq;
-struct mbuf *m;
+x25_ifinput(lcp, m)
+struct pklcd *lcp;
+register struct mbuf *m;

 {
 {

-       struct rtentry *rt = (struct rtentry *)xq->xq_next;
-       struct x25lcb *xl = (struct x25lcb *)rt->rt_llinfo;
-       register struct ifnet *ifp = &xl->xl_xc.xc_if;
-       register struct llc *l;
-       int s;
+       struct llinfo_x25 *lx = (struct llinfo_x25 *)lcp->lcd_upnext;
+       struct rtentry *rt = lx->lx_rt;
+       register struct ifnet *ifp = rt->rt_ifp;
+       struct ifqueue *inq;
+       extern struct timeval time;
+       struct x25_packet *xp = mtod(m, struct x25_packet *);
+       struct mbuf **mp = &lcp->lcd_ifrag;
+       int s, len;

 
        ifp->if_lastchange = time;
 
        ifp->if_lastchange = time;

+       switch (m->m_type) {
+       case MT_CONTROL:
+       case MT_OOBDATA:
+               m_freem(m);
+               return;
+
+       case MT_DATA:
+       case MT_HEADER:
+               m->m_len -= PKHEADERLN;
+               m->m_data += PKHEADERLN;
+               m->m_pkthdr.len -= PKHEADERLN;
+               while (*mp)
+                       mp = &((*mp)->m_next);
+               *mp = m;
+               if (MBIT(xp))
+                       return;
+       }
+       m = lcp->lcd_ifrag;
+       if (m->m_flags & M_PKTHDR) {
+               for (len = 0; m; m = m->m_next)
+                       len += m->m_len;
+               m = lcp->lcd_ifrag;
+               m->m_pkthdr.len = len;
+       }

 
 

-       switch (rt_dst(rt)->sa_family) {
+       switch (lx->lx_family) {

 #ifdef INET
        case AF_INET:
                schednetisr(NETISR_IP);
 #ifdef INET
        case AF_INET:
                schednetisr(NETISR_IP);


@@ -256,16 +303,6 @@ struct mbuf *m;
        }
        splx(s);
 }
        }
        splx(s);
 }

-
-union imp_addr {
-       struct in_addr  ip;
-       struct imp {
-               u_char          s_net;
-               u_char          s_host;
-               u_char          s_lh;
-               u_char          s_impno;
-       }                   imp;
-};

 static struct sockaddr_x25 blank_x25 = {sizeof blank_x25, AF_CCITT};
 /*
  * IP to X25 address routine copyright ACC, used by permission.
 static struct sockaddr_x25 blank_x25 = {sizeof blank_x25, AF_CCITT};
 /*
  * IP to X25 address routine copyright ACC, used by permission.


@@ -275,11 +312,11 @@ struct sockaddr_in *src;
 register struct sockaddr_x25 *dst;
 {
        union imp_addr imp_addr;
 register struct sockaddr_x25 *dst;
 {
        union imp_addr imp_addr;

-       int             imp_no, imp_port;
-       char *x25addr = dst->x25_x25addr;
+       int             imp_no, imp_port, temp;
+       char *x25addr = dst->x25_addr;

 
 
 
 

-       imp_addr.ip = src->sin_addr.s_addr;
+       imp_addr.ip = src->sin_addr;

        *dst = blank_x25;
        if ((imp_addr.imp.s_net & 0x80) == 0x00) {      /* class A */
            imp_no = imp_addr.imp.s_impno;
        *dst = blank_x25;
        if ((imp_addr.imp.s_net & 0x80) == 0x00) {      /* class A */
            imp_no = imp_addr.imp.s_impno;


@@ -329,73 +366,83 @@ x25_ifrtchange(cmd, rt, dst)
 register struct rtentry *rt;
 struct sockaddr *dst;
 {
 register struct rtentry *rt;
 struct sockaddr *dst;
 {

-       register struct x25lcb *xl = (struct x25lcb *)rt->rt_llinfo;
-       register struct x25com *xc;
+       register struct llinfo_x25 *lx = (struct llinfo_x25 *)rt->rt_llinfo;

        register struct sockaddr_x25 *sa =(struct sockaddr_x25 *)rt->rt_gateway;
        register struct sockaddr_x25 *sa =(struct sockaddr_x25 *)rt->rt_gateway;

+       register struct pklcd *lcp;
+       register struct x25_ifaddr *ia;

        register struct sockaddr *sa2;
        struct mbuf *m, *mold;
        register struct sockaddr *sa2;
        struct mbuf *m, *mold;

+       int x25_ifrtfree();

 
 

-       if (xl == 0)
+       if (lx == 0)

                return;
                return;

-       xc = xl->xl_xc;
-       switch (caseof(xl->xl_state, cmd)) {
-       case caseof(XLS_CONNECTED, RTM_DELETE):
-       case caseof(XLS_CONNECTED, RTM_CHANGE):
-       case caseof(XLS_CONNECTING, RTM_DELETE):
-       case caseof(XLS_CONNECTING, RTM_CHANGE):
-               xc->xc_disconnect(xl);
+       ia = lx->lx_ia;
+       lcp = lx->lx_lcd;
+
+       switch (caseof(lx->lx_state, cmd)) {
+
+       case caseof(LXS_CONNECTED, RTM_DELETE):
+       case caseof(LXS_CONNECTED, RTM_CHANGE):
+       case caseof(LXS_CONNECTING, RTM_DELETE):
+       case caseof(LXS_CONNECTING, RTM_CHANGE):
+               pk_disconnect(lcp);
+               /*lcp->lcd_upper = x25_ifrtfree; */
+               rt->rt_refcnt++;

                break;
 
                break;
 

-       case caseof(XLS_CONNECTED, RTM_ADD):
-       case caseof(XLS_CONNECTING, RTM_ADD):
-       case caseof(XLS_RESOLVING, RTM_ADD):
+       case caseof(LXS_CONNECTED, RTM_ADD):
+       case caseof(LXS_CONNECTING, RTM_ADD):
+       case caseof(LXS_RESOLVING, RTM_ADD):

                printf("ifrtchange: impossible transition, should panic\n");
                break;
 
                printf("ifrtchange: impossible transition, should panic\n");
                break;
 

-       case caseof(XLS_RESOLVING, RTM_DELETE):
-               for (m = xl->xl_downq.xq_data; m;) {
-                       mold = m;
-                       m = m->m_nextpkt;
-                       m_freem(mold);
-               }
+       case caseof(LXS_RESOLVING, RTM_DELETE):
+               sbflush(&(lx->lx_lcd->lcd_sb));
+               free((caddr_t)lx->lx_lcd, M_PCB);
+               lx->lx_lcd = 0;

                break;
 
                break;
 

-       case caseof(XLS_RESOLVING, RTM_CHANGE):
-               xc->xc_if.if_start(xl, 0, dst);
+       case caseof(LXS_RESOLVING, RTM_CHANGE):
+               lcp->lcd_pkp = &(ia->ia_pkcb);
+               pk_connect(lcp, (struct mbuf *)0, sa);

                break;
        }
                break;
        }

-       if (xc->xc_if.if_type == IFT_DDN)
-               return;  /* reverse name table not necessary */
-       sa2 = SA(rt->rt_key);
+       if (rt->rt_ifp->if_type == IFT_X25DDN)
+               return;
+       sa2 = rt_key(rt);

        if (cmd == RTM_CHANGE) {
        if (cmd == RTM_CHANGE) {

-               if (sa->sa_family == AF_CCITT) {
-                       sa->sa_rfamily = sa2->sa_family;
+               if (sa->x25_family == AF_CCITT) {
+                       sa->x25_opts.op_speed = sa2->sa_family;

                        (void) rtrequest(RTM_DELETE, SA(sa), sa2,
                               SA(0), RTF_HOST, (struct rtentry **)0);
                }
                sa = (struct sockaddr_x25 *)dst;
                cmd = RTM_ADD;
        }
                        (void) rtrequest(RTM_DELETE, SA(sa), sa2,
                               SA(0), RTF_HOST, (struct rtentry **)0);
                }
                sa = (struct sockaddr_x25 *)dst;
                cmd = RTM_ADD;
        }

-       if (sa->sa_family == AF_CCITT) {
-               sa->sa_rfamily = sa2->sa_family;
+       if (sa->x25_family == AF_CCITT) {
+               sa->x25_opts.op_speed = sa2->sa_family;

                (void) rtrequest(cmd, SA(sa), sa2, SA(0), RTF_HOST,
                                                        (struct rtentry **)0);
                (void) rtrequest(cmd, SA(sa), sa2, SA(0), RTF_HOST,
                                                        (struct rtentry **)0);

-               sa->sa_rfamily = 0;
+               sa->x25_opts.op_speed = 0;

        }
 }
        }
 }

-static struct sockaddr sin = {sizeof(sin), AF_INET};
+
+static struct sockaddr_in sin = {sizeof(sin), AF_INET};

 /*
  * This is a utility routine to be called by x25 devices when a
  * call request is honored with the intent of starting datagram forwarding.
  */
 /*
  * This is a utility routine to be called by x25 devices when a
  * call request is honored with the intent of starting datagram forwarding.
  */

-x25_dg_rtinit(dst, xc, af)
+x25_dg_rtinit(dst, ia, af)

 struct sockaddr_x25 *dst;
 struct sockaddr_x25 *dst;

-register struct x25com *xc;
+register struct x25_ifaddr *ia;

 {
        struct sockaddr *sa = 0;
 {
        struct sockaddr *sa = 0;

-       if (xc->xc_if.if_type == IFT_DDN && af == AF_INET) {
+       struct rtentry *rt;
+       struct in_addr my_addr;
+
+       if (ia->ia_ifp->if_type == IFT_X25DDN && af == AF_INET) {

        /*
        /*

-        * Inverse X25 to IPP mapping copyright and courtesy ACC.
+        * Inverse X25 to IP mapping copyright and courtesy ACC.

         */
                int             imp_no, imp_port, temp;
                union imp_addr imp_addr;
         */
                int             imp_no, imp_port, temp;
                union imp_addr imp_addr;


@@ -403,11 +450,12 @@ register struct x25com *xc;
                /*
                 * First determine our IP addr for network
                 */
                /*
                 * First determine our IP addr for network
                 */

-               register struct in_ifaddr *ia;
+               register struct in_ifaddr *ina;

                extern struct in_ifaddr *in_ifaddr;
                extern struct in_ifaddr *in_ifaddr;

-               for (ia = in_ifaddr; ia; ia = ia->ia_next)
-                       if (ia->ia_ifp == &xc->xc_if) {
-                               imp_addr.ip = ia->ia_addr.sin_addr;
+
+               for (ina = in_ifaddr; ina; ina = ina->ia_next)
+                       if (ina->ia_ifp == ia->ia_ifp) {
+                               my_addr = ina->ia_addr.sin_addr;

                                break;
                        }
            }
                                break;
                        }
            }


@@ -440,7 +488,7 @@ register struct x25com *xc;
                  default:
                    return (0L);
                }
                  default:
                    return (0L);
                }

-               imp_addr.ip.s_addr = my_addr;
+               imp_addr.ip = my_addr;

                if ((imp_addr.imp.s_net & 0x80) == 0x00) {
                /* class A */
                    imp_addr.imp.s_host = imp_port;
                if ((imp_addr.imp.s_net & 0x80) == 0x00) {
                /* class A */
                    imp_addr.imp.s_host = imp_port;


@@ -462,18 +510,29 @@ register struct x25com *xc;
                 * This uses the X25 routing table to do inverse
                 * lookup of x25 address to sockaddr.
                 */
                 * This uses the X25 routing table to do inverse
                 * lookup of x25 address to sockaddr.
                 */

-               dst->sa_rfamily = af;
+               dst->x25_opts.op_speed = af;

                if (rt = rtalloc1(dst, 0)) {
                        sa = rt->rt_gateway;
                        rt->rt_refcnt--;
                }
                if (rt = rtalloc1(dst, 0)) {
                        sa = rt->rt_gateway;
                        rt->rt_refcnt--;
                }

-               dst->sa_rfamily = 0;
+               dst->x25_opts.op_speed = 0;

        }
        /* 
         * Call to rtalloc1 will create rtentry for reverse path
         * to callee by virtue of cloning magic and will allocate
         * space for local control block.
         */
        }
        /* 
         * Call to rtalloc1 will create rtentry for reverse path
         * to callee by virtue of cloning magic and will allocate
         * space for local control block.
         */

-       if (sa && rt = rtalloc1(sa, 1))
+       if (sa && (rt = rtalloc1(sa, 1)))

                rt->rt_refcnt--;
 }
                rt->rt_refcnt--;
 }

+
+struct radix_tree_head *x25_rnhead;
+
+pk_init()
+{
+       /*
+        * warning, sizeof (struct sockaddr_x25) > 32,
+        * but contains no data of interest beyond 32
+        */
+       rn_inithead(&x25_rnhead, 16, AF_CCITT);
+}