#include <u.h>
#include <libc.h>
#include <ip.h>
#include "dat.h"
#include "protos.h"

typedef struct Hdr      Hdr;
struct Hdr
{
       uchar   vcf[4];                 /* Version and header length */
       uchar   length[2];              /* packet length */
       uchar   proto;                  /* Protocol */
       uchar   ttl;                    /* Time to live */
       uchar   src[IPaddrlen];         /* IP source */
       uchar   dst[IPaddrlen];         /* IP destination */
};

enum
{
       IP6HDR          = 40,           /* sizeof(Iphdr) */
       IP_VER          = 0x60,         /* Using IP version 4 */
       HBH_HDR         = 0,
       ROUT_HDR        = 43,
       FRAG_HDR        = 44,
       FRAG_HSZ        = 8,            /* in bytes */
       DEST_HDR        = 60,
};

static Mux p_mux[] =
{
       { "igmp", 2, },
       { "ggp", 3, },
       { "ip", 4, },
       { "st", 5, },
       { "tcp", 6, },
       { "ucl", 7, },
       { "egp", 8, },
       { "igp", 9, },
       { "bbn-rcc-mon", 10, },
       { "nvp-ii", 11, },
       { "pup", 12, },
       { "argus", 13, },
       { "emcon", 14, },
       { "xnet", 15, },
       { "chaos", 16, },
       { "udp", 17, },
       { "mux", 18, },
       { "dcn-meas", 19, },
       { "hmp", 20, },
       { "prm", 21, },
       { "xns-idp", 22, },
       { "trunk-1", 23, },
       { "trunk-2", 24, },
       { "leaf-1", 25, },
       { "leaf-2", 26, },
       { "rdp", 27, },
       { "irtp", 28, },
       { "iso-tp4", 29, },
       { "netblt", 30, },
       { "mfe-nsp", 31, },
       { "merit-inp", 32, },
       { "sep", 33, },
       { "3pc", 34, },
       { "idpr", 35, },
       { "xtp", 36, },
       { "ddp", 37, },
       { "idpr-cmtp", 38, },
       { "tp++", 39, },
       { "il", 40, },
       { "sip", 41, },
       { "sdrp", 42, },
       { "idrp", 45, },
       { "rsvp", 46, },
       { "gre", 47, },
       { "mhrp", 48, },
       { "bna", 49, },
       { "sipp-esp", 50, },
       { "sipp-ah", 51, },
       { "i-nlsp", 52, },
       { "swipe", 53, },
       { "nhrp", 54, },
       { "icmp6", 58, },
       { "any", 61, },
       { "cftp", 62, },
       { "any", 63, },
       { "sat-expak", 64, },
       { "kryptolan", 65, },
       { "rvd", 66, },
       { "ippc", 67, },
       { "any", 68, },
       { "sat-mon", 69, },
       { "visa", 70, },
       { "ipcv", 71, },
       { "cpnx", 72, },
       { "cphb", 73, },
       { "wsn", 74, },
       { "pvp", 75, },
       { "br-sat-mon", 76, },
       { "sun-nd", 77, },
       { "wb-mon", 78, },
       { "wb-expak", 79, },
       { "iso-ip", 80, },
       { "vmtp", 81, },
       { "secure-vmtp", 82, },
       { "vines", 83, },
       { "ttp", 84, },
       { "nsfnet-igp", 85, },
       { "dgp", 86, },
       { "tcf", 87, },
       { "igrp", 88, },
       { "ospf", 89, },
       { "sprite-rpc", 90, },
       { "larp", 91, },
       { "mtp", 92, },
       { "ax.25", 93, },
       { "ipip", 94, },
       { "micp", 95, },
       { "scc-sp", 96, },
       { "etherip", 97, },
       { "encap", 98, },
       { "any", 99, },
       { "gmtp", 100, },
       { "rudp", 254, },
       { 0 }
};

enum
{
       Os,     /* source */
       Od,     /* destination */
       Osd,    /* source or destination */
       Ot,     /* type */
};

static Field p_fields[] =
{
       {"s",   Fv6ip,  Os,     "source address",       } ,
       {"d",   Fv6ip,  Od,     "destination address",  } ,
       {"a",   Fv6ip,  Osd,    "source|destination address",} ,
       {"t",   Fnum,   Ot,     "sub protocol number",  } ,
       {0}
};

static void
p_compile(Filter *f)
{
       Mux *m;

       if(f->op == '='){
               compile_cmp(ip6.name, f, p_fields);
               return;
       }
       for(m = p_mux; m->name != nil; m++)
               if(strcmp(f->s, m->name) == 0){
                       f->pr = m->pr;
                       f->ulv = m->val;
                       f->subop = Ot;
                       return;
               }
       sysfatal("unknown ip6 field or protocol: %s", f->s);
}

static int
v6hdrlen(Hdr *h)
{
       int plen, len = IP6HDR;
       int pktlen = IP6HDR + NetS(h->length);
       uchar nexthdr = h->proto;
       uchar *pkt = (uchar*) h;

       pkt += len;
       plen = len;

       while (nexthdr == HBH_HDR || nexthdr == ROUT_HDR ||
           nexthdr == FRAG_HDR || nexthdr == DEST_HDR) {
               if (nexthdr == FRAG_HDR)
                       len = FRAG_HSZ;
               else
                       len = ((int)*(pkt+1) + 1) * 8;

               if (plen + len > pktlen)
                       return -1;

               pkt += len;
               nexthdr = *pkt;
               plen += len;
       }
       return plen;
}

static int
p_filter(Filter *f, Msg *m)
{
       Hdr *h;
       int hlen;

       if(m->pe - m->ps < IP6HDR)
               return 0;

       h = (Hdr*)m->ps;

       if ((hlen = v6hdrlen(h)) < 0)
               return 0;
       else
               m->ps += hlen;
       switch(f->subop){
       case Os:
               return memcmp(h->src, f->a, IPaddrlen) == 0;
       case Od:
               return memcmp(h->dst, f->a, IPaddrlen) == 0;
       case Osd:
               return memcmp(h->src, f->a, IPaddrlen) == 0 ||
                       memcmp(h->dst, f->a, IPaddrlen) == 0;
       case Ot:
               return h->proto == f->ulv;
       }
       return 0;
}

static int
v6hdr_seprint(Msg *m)
{
       int plen, len = IP6HDR;
       uchar *pkt = m->ps;
       Hdr *h = (Hdr *)pkt;
       int pktlen = IP6HDR + NetS(h->length);
       uchar nexthdr = h->proto;

       pkt += len;
       plen = len;

       while (nexthdr == HBH_HDR || nexthdr == ROUT_HDR ||
           nexthdr == FRAG_HDR || nexthdr == DEST_HDR) {
               switch (nexthdr) {
               case FRAG_HDR:
                       m->p = seprint(m->p, m->e, "\n    xthdr=frag id=%d "
                               "offset=%d pr=%d more=%d res1=%d res2=%d",
                               NetL(pkt+4), NetS(pkt+2) & ~7, (int)*pkt,
                               (int)(*(pkt+3) & 0x1), (int)*(pkt+1),
                               (int)(*(pkt+3) & 0x6));
                       len = FRAG_HSZ;
                       break;

               case HBH_HDR:
               case ROUT_HDR:
               case DEST_HDR:
                       len = ((int)*(pkt+1) + 1) * 8;
                       break;
               }

               if (plen + len > pktlen) {
                       m->p = seprint(m->p, m->e, "bad pkt");
                       m->pr = &dump;
                       return -1;
               }
               plen += len;
               pkt += len;
               nexthdr = *pkt;
       }

       m->ps = pkt;
       return 1;
}

static int
p_seprint(Msg *m)
{
       int len;
       Hdr *h;

       if(m->pe - m->ps < IP6HDR)
               return -1;
       h = (Hdr*)m->ps;

       demux(p_mux, h->proto, h->proto, m, &dump);

       /* truncate the message if there's extra */
       len = NetS(h->length) + IP6HDR;
       if(len < m->pe - m->ps)
               m->pe = m->ps + len;

       m->p = seprint(m->p, m->e, "s=%I d=%I ttl=%3d pr=%d ln=%d",
               h->src, h->dst, h->ttl, h->proto, NetS(h->length));
       v6hdr_seprint(m);
       return 0;
}

Proto ip6 =
{
       "ip6",
       p_compile,
       p_filter,
       p_seprint,
       p_mux,
       "%lud",
       p_fields,
       defaultframer,
};

You are viewing proxied material from sdf.org. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.