Return to devicmp.c CVS log

Up to [Plan 9 NeXT] / lucent / sys / src / 9 / port

Annotation of lucent/sys/src/9/port/devicmp.c, revision 1.1

1.1     ! root        1: #include       "u.h"
        !             2: #include       "../port/lib.h"
        !             3: #include       "mem.h"
        !             4: #include       "dat.h"
        !             5: #include       "fns.h"
        !             6: #include       "../port/error.h"
        !             7: #include       "arp.h"
        !             8: #include       "../port/ipdat.h"
        !             9: 
        !            10: #include       "devtab.h"
        !            11: 
        !            12: static Streamput       icmpoput;
        !            13: static Streamopen      icmpstopen;
        !            14: static Streamclose     icmpstclose;
        !            15: static void            icmprcvmsg(Ipifc*, Block*);
        !            16: 
        !            17: Qinfo icmpinfo  = { 0,    icmpoput,    icmpstopen,    icmpstclose,    "icmp"  };
        !            18: 
        !            19: static struct {
        !            20:        QLock;
        !            21:        Queue   *rq;
        !            22:        Ipifc   *ifc;
        !            23: } icmp;
        !            24: 
        !            25: Ipifc  *ipifc[];
        !            26: 
        !            27: /*
        !            28:  *  device interface
        !            29:  */
        !            30: Dirtab icmptab[]={
        !            31:        "icmp",         {Sdataqid},             0,      0666,
        !            32: };
        !            33: #define Nicmptab (sizeof(icmptab)/sizeof(Dirtab))
        !            34: 
        !            35: void
        !            36: icmpreset(void)
        !            37: {
        !            38: }
        !            39: 
        !            40: void
        !            41: icmpinit(void)
        !            42: {
        !            43:        Ipifc **p;
        !            44: 
        !            45:        /* add into protocol list */
        !            46:        for(p = ipifc; *p; p++)
        !            47:                ;
        !            48:        icmp.ifc = *p = xalloc(sizeof(Ipifc));
        !            49:        icmp.ifc->name = "icmp";
        !            50: }
        !            51: 
        !            52: Chan *
        !            53: icmpattach(char *spec)
        !            54: {
        !            55:        return devattach('Q', spec);
        !            56: }
        !            57: 
        !            58: Chan *
        !            59: icmpclone(Chan *c, Chan *nc)
        !            60: {
        !            61:        return devclone(c, nc);
        !            62: }
        !            63: 
        !            64: int
        !            65: icmpwalk(Chan *c, char *name)
        !            66: {
        !            67:        return devwalk(c, name, icmptab, (long)Nicmptab, devgen);
        !            68: }
        !            69: 
        !            70: void
        !            71: icmpstat(Chan *c, char *db)
        !            72: {
        !            73:        devstat(c, db, icmptab, (long)Nicmptab, devgen);
        !            74: }
        !            75: 
        !            76: Chan *
        !            77: icmpopen(Chan *c, int omode)
        !            78: {
        !            79:        if(c->qid.path == CHDIR){
        !            80:                if(omode != OREAD)
        !            81:                        error(Eperm);
        !            82:        } else
        !            83:                streamopen(c, &icmpinfo);
        !            84:        c->mode = openmode(omode);
        !            85:        c->flag |= COPEN;
        !            86:        c->offset = 0;
        !            87:        return c;
        !            88: }
        !            89: 
        !            90: void
        !            91: icmpcreate(Chan *c, char *name, int omode, ulong perm)
        !            92: {
        !            93:        USED(c, name, omode, perm);
        !            94:        error(Eperm);
        !            95: }
        !            96: 
        !            97: void
        !            98: icmpremove(Chan *c)
        !            99: {
        !           100:        USED(c);
        !           101:        error(Eperm);
        !           102: }
        !           103: 
        !           104: void
        !           105: icmpwstat(Chan *c, char *dp)
        !           106: {
        !           107:        USED(c, dp);
        !           108:        error(Eperm);
        !           109: }
        !           110: 
        !           111: void
        !           112: icmpclose(Chan *c)
        !           113: {
        !           114:        if((c->qid.path&CHDIR) == 0)
        !           115:                streamclose(c);
        !           116: }
        !           117: 
        !           118: long
        !           119: icmpread(Chan *c, void *a, long n, ulong offset)
        !           120: {
        !           121:        USED(offset);
        !           122: 
        !           123:        if(c->qid.path&CHDIR)
        !           124:                return devdirread(c, a, n, icmptab, Nicmptab, devgen);
        !           125:        return streamread(c, a, n);
        !           126: }
        !           127: 
        !           128: long
        !           129: icmpwrite(Chan *c, char *a, long n, ulong offset)
        !           130: {
        !           131:        USED(offset);
        !           132: 
        !           133:        return streamwrite(c, a, n, 1);
        !           134: }
        !           135: 
        !           136: static void
        !           137: icmpstclose(Queue *q)
        !           138: {
        !           139:        USED(q);
        !           140:        qlock(&icmp);
        !           141:        icmp.rq = 0;
        !           142:        qunlock(&icmp);
        !           143: }
        !           144: 
        !           145: static void
        !           146: icmpstopen(Queue *q, Stream *s)
        !           147: {
        !           148:        USED(s);
        !           149:        initipifc(icmp.ifc, IP_ICMPPROTO, icmprcvmsg);
        !           150:        icmp.rq = q;
        !           151: }
        !           152: 
        !           153: static void
        !           154: icmprcvmsg(Ipifc *ifc, Block *bp)
        !           155: {
        !           156:        USED(ifc);
        !           157: 
        !           158:        qlock(&icmp);
        !           159:        if(icmp.rq == 0 || QFULL(icmp.rq->next))
        !           160:                freeb(bp);
        !           161:        else
        !           162:                PUTNEXT(icmp.rq, bp);
        !           163:        qunlock(&icmp);
        !           164: }
        !           165: 
        !           166: static void
        !           167: icmpoput(Queue *q, Block *bp)
        !           168: {
        !           169:        USED(q);
        !           170:        ipmuxoput(0, bp);
        !           171: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.