changes thought to be required for new pseudo-header, not tested

SCCS-vsn: sys/netiso/tuba_table.c 7.7
SCCS-vsn: sys/netiso/tuba_table.h 7.7
SCCS-vsn: sys/netiso/tuba_subr.c 7.9

diff --git a/usr/src/sys/netiso/tuba_subr.c b/usr/src/sys/netiso/tuba_subr.c
index 3a43881..e4a0b63 100644 (file)
--- a/usr/src/sys/netiso/tuba_subr.c
+++ b/usr/src/sys/netiso/tuba_subr.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

- *     @(#)tuba_subr.c 7.8 (Berkeley) %G%
+ *     @(#)tuba_subr.c 7.9 (Berkeley) %G%

  */
 
 #include <sys/param.h>
  */
 
 #include <sys/param.h>


@@ -66,10 +66,15 @@ tuba_init()
                panic("tuba_init");
 }
 
                panic("tuba_init");
 }
 

+struct addr_arg {
+       int     error;
+       int     offset;
+       u_long  sum;
+};
+

 static void
 static void

-tuba_getaddr(error, sum, siso, index)
-       int *error;
-       register u_long *sum;
+tuba_getaddr(arg, siso, index)
+       register struct addr_arg *arg;

        struct sockaddr_iso **siso;
        u_long index;
 {
        struct sockaddr_iso **siso;
        u_long index;
 {


@@ -77,50 +82,48 @@ tuba_getaddr(error, sum, siso, index)
        if (index <= tuba_table_size && (tc = tuba_table[index])) {
                if (siso)
                        *siso = &tc->tc_siso;
        if (index <= tuba_table_size && (tc = tuba_table[index])) {
                if (siso)
                        *siso = &tc->tc_siso;

-               REDUCE(*sum, *sum + tc->tc_sum_out);
+               arg->sum += (arg->offset & 1 ? tc->tc_ssum_d : tc->tc_sum_d);
+               arg->offset += tc->tc_siso.siso_nlen + 1;

        } else
        } else

-               *error = 1;
+               arg->error = 1;

 }
 
 tuba_output(m, tp)
        register struct mbuf *m;
        struct tcpcb *tp;
 {
 }
 
 tuba_output(m, tp)
        register struct mbuf *m;
        struct tcpcb *tp;
 {

-       struct isopcb *isop;

        register struct tcpiphdr *n;
        register struct tcpiphdr *n;

-       u_long sum, i;
+       struct  isopcb *isop;
+       struct  addr_arg arg;

 
        if (tp == 0 || (n = tp->t_template) == 0 || 
            (isop = (struct isopcb *)tp->t_tuba_pcb) == 0) {
                isop = &tuba_isopcb;
                n = mtod(m, struct tcpiphdr *);
 
        if (tp == 0 || (n = tp->t_template) == 0 || 
            (isop = (struct isopcb *)tp->t_tuba_pcb) == 0) {
                isop = &tuba_isopcb;
                n = mtod(m, struct tcpiphdr *);

-               i = sum = 0;
-               tuba_getaddr(&i, &sum, &tuba_isopcb.isop_faddr,
-                               n->ti_dst.s_addr);
-               tuba_getaddr(&i, &sum, &tuba_isopcb.isop_laddr,
-                               n->ti_src.s_addr);
+               arg.error = arg.sum = arg.offset = 0;
+               tuba_getaddr(&arg, &tuba_isopcb.isop_faddr, n->ti_dst.s_addr);
+               tuba_getaddr(&arg, &tuba_isopcb.isop_laddr, n->ti_src.s_addr);
+               REDUCE(arg.sum, arg.sum);

                goto adjust;
        }
        if (n->ti_sum == 0) {
                goto adjust;
        }
        if (n->ti_sum == 0) {

-               i = sum = 0;
-               tuba_getaddr(&i, &sum, (struct sockaddr_iso **)0,
-                               n->ti_dst.s_addr);
-               tuba_getaddr(&i, &sum, (struct sockaddr_iso **)0,
-                               n->ti_src.s_addr);
-               n->ti_sum = sum;
+               arg.error = arg.sum = arg.offset = 0;
+               tuba_getaddr(&arg, (struct sockaddr_iso **)0, n->ti_dst.s_addr);
+               tuba_getaddr(&arg, (struct sockaddr_iso **)0, n->ti_src.s_addr);
+               REDUCE(arg.sum, arg.sum);
+               n->ti_sum = arg.sum;

                n = mtod(m, struct tcpiphdr *);
        adjust:
                n = mtod(m, struct tcpiphdr *);
        adjust:

-               if (i) {
+               if (arg.error) {

                        m_freem(m);
                        return (EADDRNOTAVAIL);
                }
                        m_freem(m);
                        return (EADDRNOTAVAIL);
                }

-               REDUCE(n->ti_sum, n->ti_sum + (0xffff ^ sum));
+               REDUCE(n->ti_sum, n->ti_sum + (0xffff ^ arg.sum));

        }
        m->m_len -= sizeof (struct ip);
        m->m_pkthdr.len -= sizeof (struct ip);
        m->m_data += sizeof (struct ip);
        }
        m->m_len -= sizeof (struct ip);
        m->m_pkthdr.len -= sizeof (struct ip);
        m->m_data += sizeof (struct ip);

-       i = clnp_output(m, isop, m->m_pkthdr.len, 0);
-       return (i);
+       return (clnp_output(m, isop, m->m_pkthdr.len, 0));

 }
 
 tuba_refcnt(isop, delta)
 }
 
 tuba_refcnt(isop, delta)


@@ -223,7 +226,7 @@ tuba_tcpinput(m, src, dst, clnp_len, ce_bit)
         */
        tcpstat.tcps_rcvtotal++;
        lindex = tuba_lookup(&dst->siso_addr, M_DONTWAIT);
         */
        tcpstat.tcps_rcvtotal++;
        lindex = tuba_lookup(&dst->siso_addr, M_DONTWAIT);

-       findex = tuba_lookup(&dst->siso_addr, M_DONTWAIT);
+       findex = tuba_lookup(&src->siso_addr, M_DONTWAIT);

        if (lindex == 0 || findex == 0)
                goto drop;
        /*
        if (lindex == 0 || findex == 0)
                goto drop;
        /*


@@ -277,8 +280,11 @@ tuba_tcpinput(m, src, dst, clnp_len, ce_bit)
                m = m0;
        }
        ti = mtod(m, struct tcpiphdr *);
                m = m0;
        }
        ti = mtod(m, struct tcpiphdr *);

-       ti->ti_src.s_addr = tuba_table[findex]->tc_sum_in;
-       ti->ti_dst.s_addr = tuba_table[lindex]->tc_sum_in;
+       ti->ti_dst.s_addr = tuba_table[lindex]->tc_sum;
+       if (dst->siso_nlen & 1)
+               ti->ti_src.s_addr = tuba_table[findex]->tc_sum;
+       else
+               ti->ti_src.s_addr = tuba_table[findex]->tc_ssum;

        ti->ti_prev = ti->ti_next = 0;
        ti->ti_x1 = 0; ti->ti_pr = ISOPROTO_TCP;
        ti->ti_len = htons((u_short)tlen);
        ti->ti_prev = ti->ti_next = 0;
        ti->ti_x1 = 0; ti->ti_pr = ISOPROTO_TCP;
        ti->ti_len = htons((u_short)tlen);

diff --git a/usr/src/sys/netiso/tuba_table.c b/usr/src/sys/netiso/tuba_table.c
index 9fe1ed9..66a8e79 100644 (file)
--- a/usr/src/sys/netiso/tuba_table.c
+++ b/usr/src/sys/netiso/tuba_table.c
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

- *     @(#)tuba_table.c        7.6 (Berkeley) %G%
+ *     @(#)tuba_table.c        7.7 (Berkeley) %G%

  */
 #include <sys/param.h>
 #include <sys/systm.h>
  */
 #include <sys/param.h>
 #include <sys/systm.h>


@@ -43,7 +43,7 @@ tuba_timer()
                if ((tc = tuba_table[i]) && (tc->tc_refcnt == 0) &&
                    (tc->tc_time < timelimit)) {
                        tuba_table[i] = 0;
                if ((tc = tuba_table[i]) && (tc->tc_refcnt == 0) &&
                    (tc->tc_time < timelimit)) {
                        tuba_table[i] = 0;

-                       rn_delete((caddr_t)&tc->tc_EID, (caddr_t)0,
+                       rn_delete((caddr_t)&tc->tc_siso.siso_addr, (caddr_t)0,

                                        tuba_tree->rnh_treetop);
                        free((caddr_t)tc, M_RTABLE);
                }
                                        tuba_tree->rnh_treetop);
                        free((caddr_t)tc, M_RTABLE);
                }


@@ -64,12 +64,8 @@ tuba_lookup(isoa, wait)
        register struct tuba_cache *tc;
        struct tuba_cache **new;
        int dupentry = 0, sum_a = 0, sum_b = 0, old_size, i;
        register struct tuba_cache *tc;
        struct tuba_cache **new;
        int dupentry = 0, sum_a = 0, sum_b = 0, old_size, i;

-       char EID[7];

 
 

-       if (isoa->isoa_len < 7)
-               return (0);
-       bcopy(isoa->isoa_genaddr + isoa->isoa_len - 7, EID + 1, EID[0] = 6);
-       if ((rn = rn_match((caddr_t)EID, tuba_tree->rnh_treetop)) &&
+       if ((rn = rn_match((caddr_t)isoa, tuba_tree->rnh_treetop)) &&

            ((rn->rn_flags & RNF_ROOT) == 0)) {
                tc = (struct tuba_cache *)rn;
                tc->tc_time = time.tv_sec;
            ((rn->rn_flags & RNF_ROOT) == 0)) {
                tc = (struct tuba_cache *)rn;
                tc->tc_time = time.tv_sec;


@@ -79,28 +75,23 @@ tuba_lookup(isoa, wait)
                == NULL)
                return (0);
        bzero((caddr_t)tc, sizeof (*tc));
                == NULL)
                return (0);
        bzero((caddr_t)tc, sizeof (*tc));

-       bcopy((caddr_t)EID, (caddr_t)&tc->tc_EID, sizeof(EID));
-       rn_insert(tc->tc_EID, tuba_tree->rnh_treetop, &dupentry, tc->tc_nodes);
-       if (dupentry)
-               panic("tuba_lookup 1");

        bcopy((caddr_t)isoa, (caddr_t)&tc->tc_siso.siso_addr,
                1 + isoa->isoa_len);
        bcopy((caddr_t)isoa, (caddr_t)&tc->tc_siso.siso_addr,
                1 + isoa->isoa_len);

+       rn_insert((caddr_t)&tc->tc_siso.siso_addr,
+                 tuba_tree->rnh_treetop, &dupentry, tc->tc_nodes);
+       if (dupentry)
+               panic("tuba_lookup 1");

        tc->tc_siso.siso_family = AF_ISO;
        tc->tc_siso.siso_len = sizeof(tc->tc_siso);
        tc->tc_time = time.tv_sec;
        tc->tc_siso.siso_family = AF_ISO;
        tc->tc_siso.siso_len = sizeof(tc->tc_siso);
        tc->tc_time = time.tv_sec;

-       for (i = EID[0]; i > 0; i--)
-               (i & 1 ? sum_a : sum_b) += EID[i];
-       REDUCE(tc->tc_sum_in, (sum_a << 8) + sum_b);
-       HTONS(tc->tc_sum_in);
+       for (i = sum_a = isoa->isoa_len; --i >= 0; )
+               (i & 1 ? sum_a : sum_b) += tc->tc_siso.siso_data[i];
+       REDUCE(tc->tc_sum, (sum_a << 8) + sum_b);
+       HTONS(tc->tc_sum);
+       tc->tc_ssum = swab(tc->tc_sum);

        for (i = tuba_table_size; i > 0; i--)
                if (tuba_table[i] == 0)
        for (i = tuba_table_size; i > 0; i--)
                if (tuba_table[i] == 0)

-                       break;
-       if (i) {
-               tc->tc_index = i;
-               REDUCE(tc->tc_sum_out, tc->tc_sum_in + (0xffff ^ tc->tc_index));
-               tuba_table[i] = tc;
-               return (i);
-       }
+                       goto fixup;

        old_size = tuba_table_size;
        if (tuba_table_size == 0)
                tuba_table_size = 15;
        old_size = tuba_table_size;
        if (tuba_table_size == 0)
                tuba_table_size = 15;


@@ -111,7 +102,8 @@ tuba_lookup(isoa, wait)
        new = (struct tuba_cache **)malloc((unsigned)i, M_RTABLE, wait);
        if (new == 0) {
                tuba_table_size = old_size;
        new = (struct tuba_cache **)malloc((unsigned)i, M_RTABLE, wait);
        if (new == 0) {
                tuba_table_size = old_size;

-               rn_delete((caddr_t)&tc->tc_EID, (caddr_t)0, tuba_tree);
+               rn_delete((caddr_t)&tc->tc_siso.siso_addr,
+                         (caddr_t)0, tuba_tree);

                free((caddr_t)tc, M_RTABLE);
                return (0);
        }
                free((caddr_t)tc, M_RTABLE);
                return (0);
        }


@@ -121,7 +113,12 @@ tuba_lookup(isoa, wait)
                free((caddr_t)tuba_table, M_RTABLE);
        }
        tuba_table = new;
                free((caddr_t)tuba_table, M_RTABLE);
        }
        tuba_table = new;

-       tuba_table[tc->tc_index = tuba_table_size] = tc;
-       REDUCE(tc->tc_sum_out, tc->tc_sum_in + (0xffff ^ tc->tc_index));
+       i = tuba_table_size;
+fixup:
+       tuba_table[i] = tc;
+       tc->tc_index = i;
+       i ^= 0xffff;
+       REDUCE(tc->tc_sum_d, tc->tc_sum + i);
+       REDUCE(tc->tc_ssum_d, tc->tc_ssum + i);

        return (tc->tc_index);
 }
        return (tc->tc_index);
 }

diff --git a/usr/src/sys/netiso/tuba_table.h b/usr/src/sys/netiso/tuba_table.h
index dbb87e6..b38ca94 100644 (file)
--- a/usr/src/sys/netiso/tuba_table.h
+++ b/usr/src/sys/netiso/tuba_table.h
@@ -4,7 +4,7 @@
  *
  * %sccs.include.redist.c%
  *
  *
  * %sccs.include.redist.c%
  *

- *     @(#)tuba_table.h        7.6 (Berkeley) %G%
+ *     @(#)tuba_table.h        7.7 (Berkeley) %G%

  */
 
 struct tuba_cache {
  */
 
 struct tuba_cache {


@@ -14,15 +14,17 @@ struct tuba_cache {
        int     tc_flags;
 #define TCF_PERM       1
        int     tc_index;
        int     tc_flags;
 #define TCF_PERM       1
        int     tc_index;

-       u_short tc_sum_in;                      /* for inbound cksum */
-       u_short tc_sum_out;                     /* for outbound cksum */
+       u_short tc_sum;                         /* cksum of nsap inc. length */
+       u_short tc_ssum;                        /* swab(tc_sum) */
+       u_short tc_sum_d;                       /* o.c. diff sum - index */
+       u_short tc_ssum_d;                      /* o.c. diff ssum - index */

        struct  sockaddr_iso tc_siso;           /* for responding */
        struct  sockaddr_iso tc_siso;           /* for responding */

-       char    tc_EID[7];                      /* what counts for lookups */

 };
 
 #define ADDCARRY(x)  (x >= 65535 ? x -= 65535 : x)
 #define REDUCE(a, b) { union { u_short s[2]; long l;} l_util; long x; \
 };
 
 #define ADDCARRY(x)  (x >= 65535 ? x -= 65535 : x)
 #define REDUCE(a, b) { union { u_short s[2]; long l;} l_util; long x; \

-       l_util.l = (b); x = l_util.s[0] + l_util.s[1]; ADDCARRY(x); a = x;}
+       l_util.l = (b); x = l_util.s[0] + l_util.s[1]; ADDCARRY(x); \
+       if (x == 0) x = 0xffff; a = x;}

 
 #ifdef KERNEL
 extern int     tuba_table_size;
 
 #ifdef KERNEL
 extern int     tuba_table_size;