Return to ip_device.c CVS log

Up to [Research Unix] / researchv10no / sys / inet

Annotation of researchv10no/sys/inet/ip_device.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * ip device driver; each minor device is one protocol.
                      3:  * so tcp would be placed on top of ip minor device #6.
                      4:  */
                      5: 
                      6: #include "sys/param.h"
                      7: #include "sys/stream.h"
                      8: #include "sys/conf.h"
                      9: #include "sys/inet/in.h"
                     10: #include "sys/inet/ip_var.h"
                     11: 
                     12: extern int ipcnt;              /* number of ip devices */
                     13: long   ipdopen();
                     14: int    ipdclose(), ipdput(), ipdosrv();
                     15: static struct qinit ipdrinit = { noput, NULL, ipdopen, ipdclose, 0, 0 };
                     16:        struct qinit ipdwinit = { ipdput, ipdosrv, ipdopen, ipdclose,
                     17:                                  IP_BODY_LIMIT, 129 };
                     18: struct streamtab ipdinfo = { &ipdrinit, &ipdwinit };
                     19: 
                     20: struct cdevsw ipcdev = cstrinit(&ipdinfo);
                     21: 
                     22: struct queue *ipdstate[256];
                     23: int ipprintfs;
                     24: 
                     25: long
                     26: ipdopen(q, dev)
                     27: register struct queue *q;
                     28: dev_t dev;
                     29: {
                     30:        dev = minor(dev);
                     31:        if(ipdstate[dev])
                     32:                return(0);
                     33:        ipdstate[dev] = q;
                     34:        q->ptr = (caddr_t)dev;
                     35:        q->flag |= QDELIM;
                     36:        WR(q)->ptr = (caddr_t)dev;
                     37:        WR(q)->flag |= QNOENB;
                     38:        return(1);
                     39: }
                     40: 
                     41: ipdclose(q)
                     42: register struct queue *q;
                     43: {
                     44:        ipdstate[(int)q->ptr] = 0;
                     45: }
                     46: 
                     47: ipdput(q, bp)
                     48: register struct queue *q;
                     49: register struct block *bp;
                     50: {
                     51:        struct foo{
                     52:                u_long dst;
                     53:                u_long gate;
                     54:        } foo;
                     55:        int i;
                     56:        struct block *bp1;
                     57: 
                     58:        switch(bp->type){
                     59:        case M_DATA:
                     60:                putq(q, bp);
                     61:                if (bp->class&S_DELIM)
                     62:                        qenable(q);
                     63:                return;
                     64: 
                     65:        case M_IOCTL:
                     66:                bp->type = M_IOCACK;
                     67:                switch(stiocom(bp)){
                     68:                case IPIOROUTE:
                     69:                        bcopy(stiodata(bp), &foo, sizeof(struct foo));
                     70:                        if(ip_doroute(foo.dst, foo.gate))
                     71:                                bp->type = M_IOCNAK;
                     72:                        break;
                     73:                case IPIOGETIFS:
                     74:                        i = *(int *)(stiodata(bp));
                     75:                        if(i>=ipcnt) {
                     76:                                bp->type = M_IOCNAK;
                     77:                                break;
                     78:                        }
                     79:                        bp1 = allocb(sizeof(struct ipif));
                     80:                        if (bp1 == 0) {
                     81:                                bp->type = M_IOCNAK;
                     82:                                break;
                     83:                        }
                     84:                        freeb(bp);
                     85:                        bp = bp1;
                     86:                        bp->type = M_IOCACK;
                     87:                        bp->wptr = (u_char *)stiodata(bp);
                     88:                        *(struct ipif *)(bp->wptr) = ipif[i];
                     89:                        bp->wptr += sizeof(struct ipif);
                     90:                        break;
                     91:                default:
                     92:                        bp->type = M_IOCNAK;
                     93:                        break;
                     94:                }
                     95:                qreply(q, bp);
                     96:                return;
                     97: 
                     98:        default:
                     99:                freeb(bp);
                    100:                return;
                    101:        }
                    102: }
                    103: 
                    104: ipdrint(bp, dev)
                    105: register struct block *bp;
                    106: unsigned dev;
                    107: {
                    108:        register struct block *bp1;
                    109:        register struct queue *nq;
                    110: 
                    111:        if ((nq = ipdstate[dev]) == NULL) {
                    112:                bp_free(bp);
                    113:                return;
                    114:        }
                    115:        nq = nq->next;  /* optimization */
                    116:        if(nq->flag&QFULL){
                    117:                bp_free(bp);
                    118:                if(ipprintfs)
                    119:                        printf("ipdrint: QFULL\n");
                    120:                ipstat.ips_qfull++;
                    121:                return;
                    122:        }
                    123:        while(bp){
                    124:                bp1 = bp->next;
                    125:                if (bp1==NULL)
                    126:                        bp->class |= S_DELIM;
                    127:                else
                    128:                        bp->class &=~ S_DELIM;
                    129:                (*nq->qinfo->putp)(nq, bp);
                    130:                bp = bp1;
                    131:        }
                    132: }
                    133: 
                    134: ipdosrv(q)
                    135: struct queue *q;
                    136: {
                    137:        register struct block *bp, *tail, *head;
                    138: 
                    139:        head = tail = NULL;
                    140:        while(bp = getq(q)){
                    141:                if (bp->type != M_DATA)
                    142:                        panic("ipdosrv");
                    143:                bp->next = NULL;
                    144:                if (head == NULL)
                    145:                        head = bp;
                    146:                else
                    147:                        tail->next = bp;
                    148:                tail = bp;
                    149:                if (bp->class&S_DELIM) {
                    150:                        ip_output(head, (struct block *)0, 0);
                    151:                        head = tail = NULL;
                    152:                }
                    153:        }
                    154:        if (head)
                    155:                bp_putback(q, head);
                    156: }

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