get ipaux.c to build.
authorRonald G. Minnich <rminnich@google.com>
Fri, 17 Jan 2014 05:07:06 +0000 (21:07 -0800)
committerRonald G. Minnich <rminnich@google.com>
Fri, 17 Jan 2014 05:07:06 +0000 (21:07 -0800)
We'll hold off on icmp6.c for a bit.

Signed-off-by: Ronald G. Minnich <rminnich@google.com>
kern/include/ip.h
kern/src/net/Kbuild
kern/src/net/icmp6.c
kern/src/net/ipaux.c
scripts/spatch/typedef.cocci

index a3c4e52..5b92e2e 100644 (file)
@@ -238,7 +238,7 @@ enum
 };
 struct Iphash
 {
-       struct iphash   *next;
+       struct Iphash   *next;
        struct conv     *c;
        int     match;
 };
index 7d8cdac..905ab71 100644 (file)
@@ -2,6 +2,8 @@ obj-y                                           += arp.o
 #obj-y                                         += compress.o
 obj-y                                          += devip.o
 obj-y                                          += ethermedium.o
+#obj-y                                         += icmp6.o
+obj-y                                          += ipaux.o
 obj-y                                          += ipifc.o
 obj-y                                          += loopbackmedium.o
 obj-y                                          += netdevmedium.o
index bca78a3..a141bc8 100644 (file)
@@ -1,11 +1,17 @@
-#include "u.h"
-#include "../port/lib.h"
-#include "mem.h"
-#include "dat.h"
-#include "fns.h"
-#include "../port/error.h"
-#include "ip.h"
-#include "ipv6.h"
+// INFERNO
+#include <vfs.h>
+#include <kfs.h>
+#include <slab.h>
+#include <kmalloc.h>
+#include <kref.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <error.h>
+#include <cpio.h>
+#include <pmap.h>
+#include <smp.h>
+#include <ip.h>
 
 typedef struct ICMPpkt ICMPpkt;
 typedef struct IPICMP IPICMP;
@@ -13,11 +19,11 @@ typedef struct Ndpkt Ndpkt;
 typedef struct NdiscC NdiscC;
 
 struct ICMPpkt {
-       uchar   type;
-       uchar   code;
-       uchar   cksum[2];
-       uchar   icmpid[2];
-       uchar   seq[2];
+       uint8_t type;
+       uint8_t code;
+       uint8_t cksum[2];
+       uint8_t icmpid[2];
+       uint8_t seq[2];
 };
 
 struct IPICMP {
@@ -28,16 +34,16 @@ struct IPICMP {
 struct NdiscC
 {
        IPICMP;
-       uchar target[IPaddrlen];
+       uint8_t target[IPaddrlen];
 };
 
 struct Ndpkt
 {
        NdiscC;
-       uchar otype;
-       uchar olen;     // length in units of 8 octets(incl type, code),
+       uint8_t otype;
+       uint8_t olen;   // length in units of 8 octets(incl type, code),
                                // 1 for IEEE 802 addresses
-       uchar lnaddr[6];        // link-layer address
+       uint8_t lnaddr[6];      // link-layer address
 };
 
 enum { 
@@ -131,17 +137,17 @@ static char *statnames6[Nstats6] =
 
 typedef struct Icmppriv6
 {
-       ulong   stats[Nstats6];
+       uint32_t        stats[Nstats6];
 
        /* message counts */
-       ulong   in[Maxtype6+1];
-       ulong   out[Maxtype6+1];
+       uint32_t        in[Maxtype6+1];
+       uint32_t        out[Maxtype6+1];
 } Icmppriv6;
 
 typedef struct Icmpcb6 
 {
-       QLock;
-       uchar headers;
+       qlock_t qlock;
+       uint8_t headers;
 } Icmpcb6;
 
 static char *unreachcode[] =
@@ -172,17 +178,17 @@ enum {
        mtuopt  = 5,
 };
 
-static void icmpkick6(void *x, Block *bp);
+static void icmpkick6(void *x, struct block *bp);
 
 static void
-icmpcreate6(Conv *c)
+icmpcreate6(struct conv *c)
 {
        c->rq = qopen(64*1024, Qmsg, 0, c);
        c->wq = qbypass(icmpkick6, c);
 }
 
 static void
-set_cksum(Block *bp)
+set_cksum(struct block *bp)
 {
        IPICMP *p = (IPICMP *)(bp->rp);
 
@@ -195,10 +201,10 @@ set_cksum(Block *bp)
        p->proto = ICMPv6;
 }
 
-static Block *
+static struct block *
 newIPICMP(int packetlen)
 {
-       Block   *nbp;
+       struct block    *nbp;
        nbp = allocb(packetlen);
        nbp->wp += packetlen;
        memset(nbp->rp, 0, packetlen);
@@ -206,11 +212,11 @@ newIPICMP(int packetlen)
 }
 
 void
-icmpadvise6(Proto *icmp, Block *bp, char *msg)
+icmpadvise6(struct Proto *icmp, struct block *bp, char *msg)
 {
-       Conv    **c, *s;
+       struct conv     **c, *s;
        IPICMP  *p;
-       ushort  recid;
+       uint16_t        recid;
 
        p = (IPICMP *) bp->rp;
        recid = nhgets(p->icmpid);
@@ -228,28 +234,28 @@ icmpadvise6(Proto *icmp, Block *bp, char *msg)
 }
 
 static void
-icmpkick6(void *x, Block *bp)
+icmpkick6(void *x, struct block *bp)
 {
-       Conv *c = x;
+       struct conv *c = x;
        IPICMP *p;
-       uchar laddr[IPaddrlen], raddr[IPaddrlen];
+       uint8_t laddr[IPaddrlen], raddr[IPaddrlen];
        Icmppriv6 *ipriv = c->p->priv;
        Icmpcb6 *icb = (Icmpcb6*)c->ptcl;
 
-       if(bp == nil)
+       if(bp == NULL)
                return;
 
        if(icb->headers==6) {
                /* get user specified addresses */
                bp = pullupblock(bp, ICMP_USEAD6);
-               if(bp == nil)
+               if(bp == NULL)
                        return;
                bp->rp += 8;
                ipmove(laddr, bp->rp);
                bp->rp += IPaddrlen;
                ipmove(raddr, bp->rp);
                bp->rp += IPaddrlen;
-               bp = padblock(bp, sizeof(Ip6hdr));
+               bp = padblock(bp, sizeof(struct ip6hdr));
        }
 
        if(blocklen(bp) < sizeof(IPICMP)){
@@ -270,11 +276,11 @@ icmpkick6(void *x, Block *bp)
        p->vcf[0] = 0x06 << 4;
        if(p->type <= Maxtype6) 
                ipriv->out[p->type]++;
-       ipoput6(c->p->f, bp, 0, c->ttl, c->tos, nil);
+       ipoput6(c->p->f, bp, 0, c->ttl, c->tos, NULL);
 }
 
 char*
-icmpctl6(Conv *c, char **argv, int argc)
+icmpctl6(struct conv *c, char **argv, int argc)
 {
        Icmpcb6 *icb;
 
@@ -283,19 +289,19 @@ icmpctl6(Conv *c, char **argv, int argc)
        if(argc==1) {
                if(strcmp(argv[0], "headers")==0) {
                        icb->headers = 6;
-                       return nil;
+                       return NULL;
                }
        }
        return "unknown control request";
 }
 
 static void
-goticmpkt6(Proto *icmp, Block *bp, int muxkey)
+goticmpkt6(struct Proto *icmp, struct block *bp, int muxkey)
 {
-       Conv    **c, *s;
+       struct conv     **c, *s;
        IPICMP  *p = (IPICMP *)bp->rp;
-       ushort  recid; 
-       uchar   *addr;
+       uint16_t        recid; 
+       uint8_t         *addr;
 
        if(muxkey == 0) {
                recid = nhgets(p->icmpid);
@@ -310,7 +316,7 @@ goticmpkt6(Proto *icmp, Block *bp, int muxkey)
                s = *c;
                if(s->lport == recid && ipcmp(s->raddr, addr) == 0){
                        bp = concatblock(bp);
-                       if(bp != nil)
+                       if(bp != NULL)
                                qpass(s->rq, bp);
                        return;
                }
@@ -319,11 +325,11 @@ goticmpkt6(Proto *icmp, Block *bp, int muxkey)
        freeblist(bp);
 }
 
-static Block *
-mkechoreply6(Block *bp)
+static struct block *
+mkechoreply6(struct block *bp)
 {
        IPICMP *p = (IPICMP *)(bp->rp);
-       uchar   addr[IPaddrlen];
+       uint8_t addr[IPaddrlen];
 
        ipmove(addr, p->src);
        ipmove(p->src, p->dst);
@@ -341,11 +347,11 @@ mkechoreply6(Block *bp)
  */
 
 extern void
-icmpns(Fs *f, uchar* src, int suni, uchar* targ, int tuni, uchar* mac)
+icmpns(struct Fs *f, uint8_t* src, int suni, uint8_t* targ, int tuni, uint8_t* mac)
 {
-       Block   *nbp;
+       struct block    *nbp;
        Ndpkt *np;
-       Proto *icmp = f->t2p[ICMPv6];
+       struct Proto *icmp = f->t2p[ICMPv6];
        Icmppriv6 *ipriv = icmp->priv;
 
 
@@ -382,18 +388,19 @@ icmpns(Fs *f, uchar* src, int suni, uchar* targ, int tuni, uchar* mac)
        np->vcf[0] = 0x06 << 4;
        ipriv->out[NbrSolicit]++;
        netlog(f, Logicmp, "sending neighbor solicitation %I\n", targ);
-       ipoput6(f, nbp, 0, MAXTTL, DFLTTOS, nil);
+       ipoput6(f, nbp, 0, MAXTTL, DFLTTOS, NULL);
 }
 
 /*
  * sends out an ICMPv6 neighbor advertisement. pktflags == RSO flags.
  */
 extern void
-icmpna(Fs *f, uchar* src, uchar* dst, uchar* targ, uchar* mac, uchar flags)
+icmpna(struct Fs *f, uint8_t* src, uint8_t* dst, uint8_t* targ, uint8_t* mac,
+       uint8_t flags)
 {
-       Block   *nbp;
+       struct block    *nbp;
        Ndpkt *np;
-       Proto *icmp = f->t2p[ICMPv6];
+       struct Proto *icmp = f->t2p[ICMPv6];
        Icmppriv6 *ipriv = icmp->priv;
 
        nbp = newIPICMP(sizeof(Ndpkt));
@@ -417,21 +424,22 @@ icmpna(Fs *f, uchar* src, uchar* dst, uchar* targ, uchar* mac, uchar flags)
        np->vcf[0] = 0x06 << 4;
        ipriv->out[NbrAdvert]++;
        netlog(f, Logicmp, "sending neighbor advertisement %I\n", src);
-       ipoput6(f, nbp, 0, MAXTTL, DFLTTOS, nil);
+       ipoput6(f, nbp, 0, MAXTTL, DFLTTOS, NULL);
 }
 
 extern void
-icmphostunr(Fs *f, Ipifc *ifc, Block *bp, int code, int free)
+icmphostunr(struct Fs *f, struct Ipifc *ifc,
+           struct block *bp, int code, int free)
 {
-       Block *nbp;
+       struct block *nbp;
        IPICMP *np;
-       Ip6hdr  *p;
+       struct ip6hdr   *p;
        int osz = BLEN(bp);
        int sz = MIN(sizeof(IPICMP) + osz, v6MINTU);
-       Proto   *icmp = f->t2p[ICMPv6];
+       struct Proto    *icmp = f->t2p[ICMPv6];
        Icmppriv6 *ipriv = icmp->priv;
 
-       p = (Ip6hdr *) bp->rp;
+       p = (struct ip6hdr *) bp->rp;
 
        if(isv6mcast(p->src)) 
                goto clean;
@@ -439,7 +447,7 @@ icmphostunr(Fs *f, Ipifc *ifc, Block *bp, int code, int free)
        nbp = newIPICMP(sz);
        np = (IPICMP *) nbp->rp;
 
-       rlock(ifc);
+       rlock(&ifc->rwlock);
        if(ipv6anylocal(ifc, np->src)) {
                netlog(f, Logicmp, "send icmphostunr -> s%I d%I\n", p->src, p->dst);
        }
@@ -464,27 +472,27 @@ icmphostunr(Fs *f, Ipifc *ifc, Block *bp, int code, int free)
        if(free)
                ipiput6(f, ifc, nbp);
        else {
-               ipoput6(f, nbp, 0, MAXTTL, DFLTTOS, nil);
+               ipoput6(f, nbp, 0, MAXTTL, DFLTTOS, NULL);
                return;
        }
 
 clean:
-       runlock(ifc);
+       runlock(&ifc->rwlock);
        freeblist(bp);
 }
 
 extern void
-icmpttlexceeded6(Fs *f, Ipifc *ifc, Block *bp)
+icmpttlexceeded6(struct Fs *f, struct Ipifc *ifc, struct block *bp)
 {
-       Block *nbp;
+       struct block *nbp;
        IPICMP *np;
-       Ip6hdr  *p;
+       struct ip6hdr   *p;
        int osz = BLEN(bp);
        int sz = MIN(sizeof(IPICMP) + osz, v6MINTU);
-       Proto   *icmp = f->t2p[ICMPv6];
+       struct Proto    *icmp = f->t2p[ICMPv6];
        Icmppriv6 *ipriv = icmp->priv;
 
-       p = (Ip6hdr *) bp->rp;
+       p = (struct ip6hdr *) bp->rp;
 
        if(isv6mcast(p->src)) 
                return;
@@ -508,21 +516,21 @@ icmpttlexceeded6(Fs *f, Ipifc *ifc, Block *bp)
        np->ttl = HOP_LIMIT;
        np->vcf[0] = 0x06 << 4;
        ipriv->out[TimeExceedV6]++;
-       ipoput6(f, nbp, 0, MAXTTL, DFLTTOS, nil);
+       ipoput6(f, nbp, 0, MAXTTL, DFLTTOS, NULL);
 }
 
 extern void
-icmppkttoobig6(Fs *f, Ipifc *ifc, Block *bp)
+icmppkttoobig6(struct Fs *f, struct Ipifc *ifc, struct block *bp)
 {
-       Block *nbp;
+       struct block *nbp;
        IPICMP *np;
-       Ip6hdr  *p;
+       struct ip6hdr   *p;
        int osz = BLEN(bp);
        int sz = MIN(sizeof(IPICMP) + osz, v6MINTU);
-       Proto   *icmp = f->t2p[ICMPv6];
+       struct Proto    *icmp = f->t2p[ICMPv6];
        Icmppriv6 *ipriv = icmp->priv;
 
-       p = (Ip6hdr *) bp->rp;
+       p = (struct ip6hdr *) bp->rp;
 
        if(isv6mcast(p->src)) 
                return;
@@ -547,21 +555,21 @@ icmppkttoobig6(Fs *f, Ipifc *ifc, Block *bp)
        np->ttl = HOP_LIMIT;
        np->vcf[0] = 0x06 << 4;
        ipriv->out[PacketTooBigV6]++;
-       ipoput6(f, nbp, 0, MAXTTL, DFLTTOS, nil);
+       ipoput6(f, nbp, 0, MAXTTL, DFLTTOS, NULL);
 }
 
 /*
  * RFC 2461, pages 39-40, pages 57-58.
  */
 static int
-valid(Proto *icmp, Ipifc *ifc, Block *bp, Icmppriv6 *ipriv) {
+valid(struct Proto *icmp, struct Ipifc *ifc,
+      struct block *bp, Icmppriv6 *ipriv) {
        int     sz, osz, unsp, n, ttl, iplen;
        int     pktsz = BLEN(bp);
-       uchar   *packet = bp->rp;
+       uint8_t *packet = bp->rp;
        IPICMP  *p = (IPICMP *) packet;
        Ndpkt   *np;
 
-       USED(ifc);
        n = blocklen(bp);
        if(n < sizeof(IPICMP)) {
                ipriv->stats[HlenErrs6]++;
@@ -641,7 +649,7 @@ valid(Proto *icmp, Ipifc *ifc, Block *bp, Icmppriv6 *ipriv) {
                        break;
        
                case RouterAdvert:
-                       if(pktsz - sizeof(Ip6hdr) < 16) {
+                       if(pktsz - sizeof(struct ip6hdr) < 16) {
                                ipriv->stats[HlenErrs6]++; 
                                goto err; 
                        }
@@ -661,7 +669,7 @@ valid(Proto *icmp, Ipifc *ifc, Block *bp, Icmppriv6 *ipriv) {
                        break;
        
                case RouterSolicit:
-                       if(pktsz - sizeof(Ip6hdr) < 8) {
+                       if(pktsz - sizeof(struct ip6hdr) < 8) {
                                ipriv->stats[HlenErrs6]++; 
                                goto err; 
                        }
@@ -695,43 +703,43 @@ err:
 }
 
 static int
-targettype(Fs *f, Ipifc *ifc, uchar *target)
+targettype(struct Fs *f, struct Ipifc *ifc, uint8_t *target)
 {
-       Iplifc *lifc;
+       struct Iplifc *lifc;
        int t;
 
-       rlock(ifc);
+       rlock(&ifc->rwlock);
        if(ipproxyifc(f, ifc, target)) {
-               runlock(ifc);
+               runlock(&ifc->rwlock);
                return t_uniproxy;
        }
 
        for(lifc = ifc->lifc; lifc; lifc = lifc->next) {
                if(ipcmp(lifc->local, target) == 0) {
                        t = (lifc->tentative) ? t_unitent : t_unirany; 
-                       runlock(ifc);
+                       runlock(&ifc->rwlock);
                        return t;
                }
        }
 
-       runlock(ifc);
+       runlock(&ifc->rwlock);
        return 0;
 }
 
 static void
-icmpiput6(Proto *icmp, Ipifc *ipifc, Block *bp)
+icmpiput6(struct Proto *icmp, struct Ipifc *ipifc, struct block *bp)
 {
-       uchar   *packet = bp->rp;
+       uint8_t *packet = bp->rp;
        IPICMP  *p = (IPICMP *)packet;
        Icmppriv6 *ipriv = icmp->priv;
-       Block   *r;
-       Proto   *pr;
+       struct block    *r;
+       struct Proto    *pr;
        char    *msg, m2[128];
        Ndpkt* np;
-       uchar pktflags;
-       uchar lsrc[IPaddrlen];
+       uint8_t pktflags;
+       uint8_t lsrc[IPaddrlen];
        int refresh = 1;
-       Iplifc *lifc;
+       struct Iplifc *lifc;
 
        if(!valid(icmp, ipifc, bp, ipriv)) 
                goto raise;
@@ -745,7 +753,7 @@ icmpiput6(Proto *icmp, Ipifc *ipifc, Block *bp)
        case EchoRequestV6:
                r = mkechoreply6(bp);
                ipriv->out[EchoReply]++;
-               ipoput6(icmp->f, r, 0, MAXTTL, DFLTTOS, nil);
+               ipoput6(icmp->f, r, 0, MAXTTL, DFLTTOS, NULL);
                break;
 
        case UnreachableV6:
@@ -761,7 +769,7 @@ icmpiput6(Proto *icmp, Ipifc *ipifc, Block *bp)
                }
                p = (IPICMP *)bp->rp;
                pr = Fsrcvpcolx(icmp->f, p->proto);
-               if(pr != nil && pr->advise != nil) {
+               if(pr != NULL && pr->advise != NULL) {
                        (*pr->advise)(pr, bp, msg);
                        return;
                }
@@ -781,7 +789,7 @@ icmpiput6(Proto *icmp, Ipifc *ipifc, Block *bp)
                        }
                        p = (IPICMP *)bp->rp;
                        pr = Fsrcvpcolx(icmp->f, p->proto);
-                       if(pr != nil && pr->advise != nil) {
+                       if(pr != NULL && pr->advise != NULL) {
                                (*pr->advise)(pr, bp, m2);
                                return;
                        }
@@ -863,7 +871,7 @@ raise:
 }
 
 int
-icmpstats6(Proto *icmp6, char *buf, int len)
+icmpstats6(struct Proto *icmp6, char *buf, int len)
 {
        Icmppriv6 *priv;
        char *p, *e;
@@ -873,12 +881,12 @@ icmpstats6(Proto *icmp6, char *buf, int len)
        p = buf;
        e = p+len;
        for(i = 0; i < Nstats6; i++)
-               p = seprint(p, e, "%s: %lud\n", statnames6[i], priv->stats[i]);
+               p = seprintf(p, e, "%s: %lud\n", statnames6[i], priv->stats[i]);
        for(i = 0; i <= Maxtype6; i++){
                if(icmpnames6[i])
-                       p = seprint(p, e, "%s: %lud %lud\n", icmpnames6[i], priv->in[i], priv->out[i]);
+                       p = seprintf(p, e, "%s: %lud %lud\n", icmpnames6[i], priv->in[i], priv->out[i]);
 /*             else
-                       p = seprint(p, e, "%d: %lud %lud\n", i, priv->in[i], priv->out[i]);
+                       p = seprintf(p, e, "%d: %lud %lud\n", i, priv->in[i], priv->out[i]);
 */
        }
        return p - buf;
@@ -886,17 +894,17 @@ icmpstats6(Proto *icmp6, char *buf, int len)
 
 
 // need to import from icmp.c
-extern int     icmpstate(Conv *c, char *state, int n);
-extern char*   icmpannounce(Conv *c, char **argv, int argc);
-extern char*   icmpconnect(Conv *c, char **argv, int argc);
-extern void    icmpclose(Conv *c);
+extern int     icmpstate(struct conv *c, char *state, int n);
+extern char*   icmpannounce(struct conv *c, char **argv, int argc);
+extern char*   icmpconnect(struct conv *c, char **argv, int argc);
+extern void    icmpclose(struct conv *c);
 
 void
-icmp6init(Fs *fs)
+icmp6init(struct Fs *fs)
 {
-       Proto *icmp6 = smalloc(sizeof(Proto));
+       struct Proto *icmp6 = kzmalloc(sizeof(struct Proto), 0);
 
-       icmp6->priv = smalloc(sizeof(Icmppriv6));
+       icmp6->priv = kzmalloc(sizeof(Icmppriv6), 0);
        icmp6->name = "icmpv6";
        icmp6->connect = icmpconnect;
        icmp6->announce = icmpannounce;
@@ -907,7 +915,7 @@ icmp6init(Fs *fs)
        icmp6->stats = icmpstats6;
        icmp6->ctl = icmpctl6;
        icmp6->advise = icmpadvise6;
-       icmp6->gc = nil;
+       icmp6->gc = NULL;
        icmp6->ipproto = ICMPv6;
        icmp6->nc = 16;
        icmp6->ptclsize = sizeof(Icmpcb6);
index 2ddae04..97c8923 100644 (file)
@@ -1,46 +1,52 @@
-#include       "u.h"
-#include       "../port/lib.h"
-#include       "mem.h"
-#include       "dat.h"
-#include       "fns.h"
-#include       "../port/error.h"
-#include       "ip.h"
-#include  "ipv6.h"
+// INFERNO
+#include <vfs.h>
+#include <kfs.h>
+#include <slab.h>
+#include <kmalloc.h>
+#include <kref.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <error.h>
+#include <cpio.h>
+#include <pmap.h>
+#include <smp.h>
+#include <ip.h>
 
 /*
  *  well known IP addresses
  */
-uchar IPv4bcast[IPaddrlen] = {
+uint8_t IPv4bcast[IPaddrlen] = {
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff
 };
-uchar IPv4allsys[IPaddrlen] = {
+uint8_t IPv4allsys[IPaddrlen] = {
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0xff, 0xff,
        0xe0, 0, 0, 0x01
 };
-uchar IPv4allrouter[IPaddrlen] = {
+uint8_t IPv4allrouter[IPaddrlen] = {
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0xff, 0xff,
        0xe0, 0, 0, 0x02
 };
-uchar IPallbits[IPaddrlen] = {
+uint8_t IPallbits[IPaddrlen] = {
        0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff
 };
 
-uchar IPnoaddr[IPaddrlen];
+uint8_t IPnoaddr[IPaddrlen];
 
 /*
  *  prefix of all v4 addresses
  */
-uchar v4prefix[IPaddrlen] = {
+uint8_t v4prefix[IPaddrlen] = {
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0xff, 0xff,
@@ -75,114 +81,114 @@ char *v6hdrtypes[Maxhdrtype] =
 /*
  *  well known IPv6 addresses
  */
-uchar v6Unspecified[IPaddrlen] = {
+uint8_t v6Unspecified[IPaddrlen] = {
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0
 };
-uchar v6loopback[IPaddrlen] = {
+uint8_t v6loopback[IPaddrlen] = {
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0x01
 };
-uchar v6linklocal[IPaddrlen] = {
+uint8_t v6linklocal[IPaddrlen] = {
        0xfe, 0x80, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0
 };
-uchar v6linklocalmask[IPaddrlen] = {
+uint8_t v6linklocalmask[IPaddrlen] = {
        0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff,
        0, 0, 0, 0,
        0, 0, 0, 0
 };
 int v6llpreflen = 8;   // link-local prefix length
-uchar v6sitelocal[IPaddrlen] = {
+uint8_t v6sitelocal[IPaddrlen] = {
        0xfe, 0xc0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0
 };
-uchar v6sitelocalmask[IPaddrlen] = {
+uint8_t v6sitelocalmask[IPaddrlen] = {
        0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff,
        0, 0, 0, 0,
        0, 0, 0, 0
 };
 int v6slpreflen = 6;   // site-local prefix length
-uchar v6glunicast[IPaddrlen] = {
+uint8_t v6glunicast[IPaddrlen] = {
        0x08, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0
 };
-uchar v6multicast[IPaddrlen] = {
+uint8_t v6multicast[IPaddrlen] = {
        0xff, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0
 };
-uchar v6multicastmask[IPaddrlen] = {
+uint8_t v6multicastmask[IPaddrlen] = {
        0xff, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0
 };
 int v6mcpreflen = 1;   // multicast prefix length
-uchar v6allnodesN[IPaddrlen] = {
+uint8_t v6allnodesN[IPaddrlen] = {
        0xff, 0x01, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0x01
 };
-uchar v6allnodesNmask[IPaddrlen] = {
+uint8_t v6allnodesNmask[IPaddrlen] = {
        0xff, 0xff, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0
 };
 int v6aNpreflen = 2;   // all nodes (N) prefix
-uchar v6allnodesL[IPaddrlen] = {
+uint8_t v6allnodesL[IPaddrlen] = {
        0xff, 0x02, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0x01
 };
-uchar v6allnodesLmask[IPaddrlen] = {
+uint8_t v6allnodesLmask[IPaddrlen] = {
        0xff, 0xff, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0
 };
 int v6aLpreflen = 2;   // all nodes (L) prefix
-uchar v6allroutersN[IPaddrlen] = {
+uint8_t v6allroutersN[IPaddrlen] = {
        0xff, 0x01, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0x02
 };
-uchar v6allroutersL[IPaddrlen] = {
+uint8_t v6allroutersL[IPaddrlen] = {
        0xff, 0x02, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0x02
 };
-uchar v6allroutersS[IPaddrlen] = {
+uint8_t v6allroutersS[IPaddrlen] = {
        0xff, 0x05, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0x02
 };
-uchar v6solicitednode[IPaddrlen] = {
+uint8_t v6solicitednode[IPaddrlen] = {
        0xff, 0x02, 0, 0,
        0, 0, 0, 0,
        0, 0, 0, 0x01,
        0xff, 0, 0, 0
 };
-uchar v6solicitednodemask[IPaddrlen] = {
+uint8_t v6solicitednodemask[IPaddrlen] = {
        0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff,
        0xff, 0xff, 0xff, 0xff,
@@ -193,26 +199,26 @@ int v6snpreflen = 13;
 
 
 
-ushort
-ptclcsum(Block *bp, int offset, int len)
+uint16_t
+ptclcsum(struct block *bp, int offset, int len)
 {
-       uchar *addr;
-       ulong losum, hisum;
-       ushort csum;
+       uint8_t *addr;
+       uint32_t losum, hisum;
+       uint16_t csum;
        int odd, blocklen, x;
 
        /* Correct to front of data area */
-       while(bp != nil && offset && offset >= BLEN(bp)) {
+       while(bp != NULL && offset && offset >= BLEN(bp)) {
                offset -= BLEN(bp);
                bp = bp->next;
        }
-       if(bp == nil)
+       if(bp == NULL)
                return 0;
 
        addr = bp->rp + offset;
        blocklen = BLEN(bp) - offset;
 
-       if(bp->next == nil) {
+       if(bp->next == NULL) {
                if(blocklen < len)
                        len = blocklen;
                return ~ptclbsum(addr, len) & 0xffff;
@@ -236,7 +242,7 @@ ptclcsum(Block *bp, int offset, int len)
                len -= x;
 
                bp = bp->next;
-               if(bp == nil)
+               if(bp == NULL)
                        break;
                blocklen = BLEN(bp);
                addr = bp->rp;
@@ -255,7 +261,7 @@ enum
        Isprefix= 16,
 };
 
-static uchar prefixvals[256] =
+static uint8_t prefixvals[256] =
 {
 [0x00] 0 | Isprefix,
 [0x80] 1 | Isprefix,
@@ -268,25 +274,29 @@ static uchar prefixvals[256] =
 [0xFF] 8 | Isprefix,
 };
 
+#warning "what did we do about eipfmt?"
+
 int
-eipfmt(Fmt *f)
+eipfmt(void)
 {
+       return 0;
+#if 0
        char buf[5*8];
        static char *efmt = "%.2lux%.2lux%.2lux%.2lux%.2lux%.2lux";
        static char *ifmt = "%d.%d.%d.%d";
-       uchar *p, ip[16];
-       ulong *lp;
-       ushort s;
+       uint8_t *p, ip[16];
+       uint32_t *lp;
+       uint16_t s;
        int i, j, n, eln, eli;
 
        switch(f->r) {
        case 'E':               /* Ethernet address */
-               p = va_arg(f->args, uchar*);
+               p = va_arg(f->args, uint8_t *unused_uint8_p_t);
                return fmtprint(f, efmt, p[0], p[1], p[2], p[3], p[4], p[5]);
-               return fmtstrcpy(f, buf);
+               return fmtstrncpy(f,  buf, sizeof(f));
 
        case 'I':               /* Ip address */
-               p = va_arg(f->args, uchar*);
+               p = va_arg(f->args, uint8_t *unused_uint8_p_t);
 common:
                if(memcmp(p, v4prefix, 12) == 0)
                        return fmtprint(f, ifmt, p[12], p[13], p[14], p[15]);
@@ -316,21 +326,21 @@ common:
                        s = (p[i]<<8) + p[i+1];
                        n += sprint(buf+n, "%ux", s);
                }
-               return fmtstrcpy(f, buf);
+               return fmtstrncpy(f,  buf, sizeof(f));
 
        case 'i':               /* v6 address as 4 longs */
-               lp = va_arg(f->args, ulong*);
+               lp = va_arg(f->args, uint32_t*);
                for(i = 0; i < 4; i++)
                        hnputl(ip+4*i, *lp++);
                p = ip;
                goto common;
 
        case 'V':               /* v4 ip address */
-               p = va_arg(f->args, uchar*);
+               p = va_arg(f->args, uint8_t *unused_uint8_p_t);
                return fmtprint(f, ifmt, p[0], p[1], p[2], p[3]);
 
        case 'M':               /* ip mask */
-               p = va_arg(f->args, uchar*);
+               p = va_arg(f->args, uint8_t *unused_uint8_p_t);
 
                /* look for a prefix mask */
                for(i = 0; i < 16; i++)
@@ -349,13 +359,14 @@ common:
                /* got one, use /xx format */
                return fmtprint(f, "/%d", n);
        }
-       return fmtstrcpy(f, "(eipfmt)");
+       return fmtstrncpy(f,  "(eipfmt)", sizeof(f));
+#endif
 }
 
-#define CLASS(p) ((*(uchar*)(p))>>6)
+#define CLASS(p) ((*( uint8_t *)(p))>>6)
 
 extern char*
-v4parseip(uchar *to, char *from)
+v4parseip(uint8_t *to, char *from)
 {
        int i;
        char *p;
@@ -367,7 +378,7 @@ v4parseip(uchar *to, char *from)
                        p++;
        }
        switch(CLASS(to)){
-       case 0: /* class A - 1 uchar net */
+       case 0: /* class A - 1 uint8_t net */
        case 1:
                if(i == 3){
                        to[3] = to[2];
@@ -378,7 +389,7 @@ v4parseip(uchar *to, char *from)
                        to[1] = 0;
                }
                break;
-       case 2: /* class B - 2 uchar net */
+       case 2: /* class B - 2 uint8_t net */
                if(i == 3){
                        to[3] = to[2];
                        to[2] = 0;
@@ -389,7 +400,7 @@ v4parseip(uchar *to, char *from)
 }
 
 int
-isv4(uchar *ip)
+isv4(uint8_t *ip)
 {
        return memcmp(ip, v4prefix, IPv4off) == 0;
 }
@@ -400,7 +411,7 @@ isv4(uchar *ip)
  *  up the usual case
  */
 void
-v4tov6(uchar *v6, uchar *v4)
+v4tov6(uint8_t *v6, uint8_t *v4)
 {
        v6[0] = 0;
        v6[1] = 0;
@@ -421,7 +432,7 @@ v4tov6(uchar *v6, uchar *v4)
 }
 
 int
-v6tov4(uchar *v4, uchar *v6)
+v6tov4(uint8_t *v4, uint8_t *v6)
 {
        if(v6[0] == 0
        && v6[1] == 0
@@ -447,11 +458,11 @@ v6tov4(uchar *v4, uchar *v6)
        }
 }
 
-ulong
-parseip(uchar *to, char *from)
+uint32_t
+parseip(uint8_t *to, char *from)
 {
        int i, elipsis = 0, v4 = 1;
-       ulong x;
+       uint32_t x;
        char *p, *op;
 
        memset(to, 0, IPaddrlen);
@@ -490,12 +501,12 @@ parseip(uchar *to, char *from)
  *  hack to allow ip v4 masks to be entered in the old
  *  style
  */
-ulong
-parseipmask(uchar *to, char *from)
+uint32_t
+parseipmask(uint8_t *to, char *from)
 {
-       ulong x;
+       uint32_t x;
        int i;
-       uchar *p;
+       uint8_t *p;
 
        if(*from == '/'){
                /* as a number of prefix bits */
@@ -520,7 +531,7 @@ parseipmask(uchar *to, char *from)
 }
 
 void
-maskip(uchar *from, uchar *mask, uchar *to)
+maskip(uint8_t *from, uint8_t *mask, uint8_t *to)
 {
        int i;
 
@@ -528,15 +539,16 @@ maskip(uchar *from, uchar *mask, uchar *to)
                to[i] = from[i] & mask[i];
 }
 
-uchar classmask[4][16] = {
-       0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0x00,0x00,0x00,
-       0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0x00,0x00,0x00,
-       0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0xff,0x00,0x00,
-       0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0x00,
+uint8_t classmask[4][16] = {
+       {0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0x00,0x00,0x00},
+       {0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0x00,0x00,0x00},
+       {0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0xff,0x00,0x00},
+       
+       {0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0xff,  0xff,0xff,0xff,0x00},
 };
 
-uchar*
-defmask(uchar *ip)
+uint8_t*
+defmask(uint8_t *ip)
 {
        if(isv4(ip))
                return classmask[ip[IPv4off]>>6];
@@ -556,7 +568,7 @@ defmask(uchar *ip)
 }
 
 void
-ipv62smcast(uchar *smcast, uchar *a)
+ipv62smcast(uint8_t *smcast, uint8_t *a)
 {
        assert(IPaddrlen == 16);
        memmove(smcast, v6solicitednode, IPaddrlen);
@@ -570,7 +582,7 @@ ipv62smcast(uchar *smcast, uchar *a)
  *  parse a hex mac address
  */
 int
-parsemac(uchar *to, char *from, int len)
+parsemac(uint8_t *to, char *from, int len)
 {
        char nip[4];
        char *p;
@@ -597,20 +609,20 @@ parsemac(uchar *to, char *from, int len)
 /*
  *  hashing tcp, udp, ... connections
  */
-ulong
-iphash(uchar *sa, ushort sp, uchar *da, ushort dp)
+uint32_t
+iphash(uint8_t *sa, uint16_t sp, uint8_t *da, uint16_t dp)
 {
        return ((sa[IPaddrlen-1]<<24) ^ (sp << 16) ^ (da[IPaddrlen-1]<<8) ^ dp ) % Nhash;
 }
 
 void
-iphtadd(Ipht *ht, Conv *c)
+iphtadd(struct Ipht *ht, struct conv *c)
 {
-       ulong hv;
-       Iphash *h;
+       uint32_t hv;
+       struct Iphash *h;
 
        hv = iphash(c->raddr, c->rport, c->laddr, c->lport);
-       h = smalloc(sizeof(*h));
+       h = kzmalloc(sizeof(*h), 0);
        if(ipcmp(c->raddr, IPnoaddr) != 0)
                h->match = IPmatchexact;
        else {
@@ -628,28 +640,28 @@ iphtadd(Ipht *ht, Conv *c)
        }
        h->c = c;
 
-       lock(ht);
+       spin_lock(&ht->lock);
        h->next = ht->tab[hv];
        ht->tab[hv] = h;
-       unlock(ht);
+       spin_unlock(&ht->lock);
 }
 
 void
-iphtrem(Ipht *ht, Conv *c)
+iphtrem(struct Ipht *ht, struct conv *c)
 {
-       ulong hv;
-       Iphash **l, *h;
+       uint32_t hv;
+       struct Iphash **l, *h;
 
        hv = iphash(c->raddr, c->rport, c->laddr, c->lport);
-       lock(ht);
-       for(l = &ht->tab[hv]; (*l) != nil; l = &(*l)->next)
+       spin_lock(&ht->lock);
+       for(l = &ht->tab[hv]; (*l) != NULL; l = &(*l)->next)
                if((*l)->c == c){
                        h = *l;
                        (*l) = h->next;
-                       free(h);
+                       kfree(h);
                        break;
                }
-       unlock(ht);
+       spin_unlock(&ht->lock);
 }
 
 /* look for a matching conversation with the following precedence
@@ -659,72 +671,72 @@ iphtrem(Ipht *ht, Conv *c)
  *     announced && laddr,*
  *     announced && *,*
  */
-Conv*
-iphtlook(Ipht *ht, uchar *sa, ushort sp, uchar *da, ushort dp)
+struct conv*
+iphtlook(struct Ipht *ht, uint8_t *sa, uint16_t sp, uint8_t *da, uint16_t dp)
 {
-       ulong hv;
-       Iphash *h;
-       Conv *c;
+       uint32_t hv;
+       struct Iphash *h;
+       struct conv *c;
 
        /* exact 4 pair match (connection) */
        hv = iphash(sa, sp, da, dp);
-       lock(ht);
-       for(h = ht->tab[hv]; h != nil; h = h->next){
+       spin_lock(&ht->lock);
+       for(h = ht->tab[hv]; h != NULL; h = h->next){
                if(h->match != IPmatchexact)
                        continue;
                c = h->c;
                if(sp == c->rport && dp == c->lport
                && ipcmp(sa, c->raddr) == 0 && ipcmp(da, c->laddr) == 0){
-                       unlock(ht);
+                       spin_unlock(&ht->lock);
                        return c;
                }
        }
        
        /* match local address and port */
        hv = iphash(IPnoaddr, 0, da, dp);
-       for(h = ht->tab[hv]; h != nil; h = h->next){
+       for(h = ht->tab[hv]; h != NULL; h = h->next){
                if(h->match != IPmatchpa)
                        continue;
                c = h->c;
                if(dp == c->lport && ipcmp(da, c->laddr) == 0){
-                       unlock(ht);
+                       spin_unlock(&ht->lock);
                        return c;
                }
        }
        
        /* match just port */
        hv = iphash(IPnoaddr, 0, IPnoaddr, dp);
-       for(h = ht->tab[hv]; h != nil; h = h->next){
+       for(h = ht->tab[hv]; h != NULL; h = h->next){
                if(h->match != IPmatchport)
                        continue;
                c = h->c;
                if(dp == c->lport){
-                       unlock(ht);
+                       spin_unlock(&ht->lock);
                        return c;
                }
        }
        
        /* match local address */
        hv = iphash(IPnoaddr, 0, da, 0);
-       for(h = ht->tab[hv]; h != nil; h = h->next){
+       for(h = ht->tab[hv]; h != NULL; h = h->next){
                if(h->match != IPmatchaddr)
                        continue;
                c = h->c;
                if(ipcmp(da, c->laddr) == 0){
-                       unlock(ht);
+                       spin_unlock(&ht->lock);
                        return c;
                }
        }
        
        /* look for something that matches anything */
        hv = iphash(IPnoaddr, 0, IPnoaddr, 0);
-       for(h = ht->tab[hv]; h != nil; h = h->next){
+       for(h = ht->tab[hv]; h != NULL; h = h->next){
                if(h->match != IPmatchany)
                        continue;
                c = h->c;
-               unlock(ht);
+               spin_unlock(&ht->lock);
                return c;
        }
-       unlock(ht);
-       return nil;
+       spin_unlock(&ht->lock);
+       return NULL;
 }
index aed5db4..6b2c532 100644 (file)
@@ -134,7 +134,7 @@ typedef Ipmulti;
 typedef Iphash;
 @@
 -Iphash
-+struct iphash
++struct Iphash
 
 @@
 typedef Ipht;