![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ip_ld.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10dc / lsys / inet|
Return to ip_ld.c CVS log | Up to [Research Unix] / researchv10dc / lsys / inet |
1.1 root 1: /*
2: * ip line discipline, to be pushed on an ethernet controller.
3: * collects data till a delim, passes it to ip_input().
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: #include "sys/inet/ethernet.h"
12:
13: extern struct ipif ipif[];
14: extern struct ipif *ipifsort[];
15: extern int ipcnt; /* number of ip's */
16: extern int arpcnt;
17:
18: int ipiput(), ipisrv(), ipclose();
19: long ipopen();
20: int iposrv();
21: static struct qinit iprinit = { ipiput, ipisrv, ipopen, ipclose, IP_MSG_LIMIT, 64};
22: static struct qinit ipwinit = { putq, iposrv, ipopen, ipclose, 2*IP_MSG_LIMIT, 64 };
23: struct streamtab ipstream = { &iprinit, &ipwinit };
24:
25: long
26: ipopen(q, dev)
27: register struct queue *q;
28: {
29: static int timing;
30: register struct ipif *fp, *ifend;
31:
32: if (q->ptr)
33: return(1);
34: if(!timing){
35: timing = 1;
36: ip_slowtimo();
37: }
38: ifend = &ipif[ipcnt];
39: for (fp = ipif; fp < ifend; fp++)
40: if (fp->queue == NULL)
41: break;
42: if (fp >= ifend)
43: return(0);
44: fp->queue = q; /* that's the RD q */
45: fp->flags = IFF_UP;
46: fp->that = fp->thishost = 0;
47: fp->ipackets = fp->opackets = fp->ierrors = fp->oerrors = 0;
48: fp->mtu = 1500;
49: fp->arp = -1;
50: fp->dev = dev;
51: q->flag |= QDELIM;
52: WR(q)->flag |= QDELIM;
53: q->ptr = (caddr_t)fp;
54: WR(q)->ptr = (caddr_t)fp;
55: q->flag |= QNOENB; /* ipiput calls qenable() */
56: return(1);
57: }
58:
59: ipclose(q)
60: struct queue *q;
61: {
62: register struct ipif *ifp;
63:
64: ifp = (struct ipif *)q->ptr;
65: ip_ifremove(ifp);
66: ifp->queue = 0;
67: ifp->flags = 0;
68: }
69:
70: ipisrv(q)
71: register struct queue *q;
72: {
73: register struct block *bp, *head, *tail;
74: register struct ipif *ifp;
75:
76: /* there is now a whole packet waiting
77: * on this queue; strip it off and pass to ip_input().
78: * things other than data or delims are forwarded directly
79: * by ipiput().
80: */
81: head = tail = (struct block *) 0;
82: ifp = (struct ipif *)q->ptr;
83: while(bp = getq(q)){
84: if (bp->type != M_DATA)
85: panic("ipisrv");
86: bp->next = NULL;
87: if (head == NULL)
88: head = bp;
89: else
90: tail->next = bp;
91: tail = bp;
92: if (bp->class&S_DELIM) {
93: bp->class &=~ S_DELIM;
94: MCHECK(head);
95: if((ifp->flags & IFF_ARP)
96: && (head->wptr-head->rptr) >= sizeof(struct etherpup)){
97: /* strip off ether header */
98: head->rptr += sizeof(struct etherpup);
99: }
100: ip_input(head);
101: ifp->ipackets++;
102: head = tail = NULL;
103: }
104: }
105: if(head)
106: bp_putback(q, head);
107: }
108:
109:
110: ipiput(q, bp)
111: register struct queue *q;
112: register struct block *bp;
113: {
114: switch(bp->type){
115: case M_DATA:
116: putq(q, bp);
117: if (bp->class&S_DELIM)
118: qenable(q);
119: break;
120: default:
121: (*q->next->qinfo->putp)(q->next, bp);
122: break;
123: }
124:
125: }
126:
127: iposrv(q)
128: register struct queue *q;
129: {
130: struct x{
131: unsigned int in;
132: unsigned char en[6];
133: } *xp;
134: register struct block *bp;
135: register struct ipif *ifp;
136: register long *intp;
137:
138: ifp = (struct ipif *)q->ptr;
139: while(bp = getq(q)){
140: switch (bp->type) {
141: case M_IOCTL:
142: switch(stiocom(bp)){
143: case IPIOARP:
144: ifp->flags |= IFF_ARP;
145: bp->type = M_IOCACK;
146: bp->wptr = bp->rptr;
147: qreply(q, bp);
148: break;
149: case IPIORESOLVE:
150: xp = (struct x *)(stiodata(bp));
151: if (arpcnt > 0)
152: arp_install(xp->in, xp->en);
153: bp->wptr = bp->rptr;
154: bp->type = M_IOCACK;
155: qreply(q, bp);
156: break;
157: case IPIOHOST:
158: intp = (long *)(stiodata(bp));
159: ifp->that = *intp;
160: ifp->flags |= IFF_HOST;
161: ifp->mask = 0xffffffff;
162: ifp->broadcast = 0;
163: ip_ifinsert(ifp);
164: bp->type = M_IOCACK;
165: qreply(q, bp);
166: ip_doroute(ifp->that, 0);
167: break;
168: case IPIOMTU:
169: intp = (long *)(stiodata(bp));
170: ifp->mtu = *intp;
171: bp->type = M_IOCACK;
172: qreply(q, bp);
173: break;
174: case IPIONET:
175: intp = (long *)(stiodata(bp));
176: ifp->that = *intp;
177: ifp->mask = IN_CLASS_NMASK(ifp->that);
178: ifp->broadcast = ifp->that|~ifp->mask;
179: ip_ifinsert(ifp);
180: ifp->flags &= (~IFF_HOST);
181: bp->type = M_IOCACK;
182: qreply(q, bp);
183: ip_doroute(ifp->that, 0);
184: break;
185: case IPIOMASK:
186: intp = (long *)(stiodata(bp));
187: /*
188: * the mask has to be a superset of the class mask
189: */
190: if((*intp&ifp->mask)==ifp->mask)
191: ifp->mask = *intp;
192: ifp->broadcast = ifp->that|~ifp->mask;
193: ip_ifinsert(ifp);
194: bp->type = M_IOCACK;
195: qreply(q, bp);
196: break;
197: case IPIOLOCAL:
198: intp = (long *)(stiodata(bp));
199: ifp->thishost = *intp;
200: bp->type = M_IOCACK;
201: qreply(q, bp);
202: break;
203: default:
204: (*q->next->qinfo->putp)(q->next, bp);
205: break;
206: }
207: continue;
208:
209: default:
210: if (q->next->flag & QFULL) {
211: putbq(q, bp);
212: return;
213: }
214: if(bp->class&S_DELIM)
215: ifp->opackets++;
216: (*q->next->qinfo->putp)(q->next, bp);
217: continue;
218: }
219: }
220: }
221:
222: /*
223: * Insert an entry into ipifsort. Entries are sorted by mask length,
224: * longest first.
225: */
226: ip_ifinsert(ifp)
227: struct ipif *ifp;
228: {
229: int s = spl6();
230: register int i, j;
231:
232: /*
233: * First try to remove it. This may be a reordering.
234: */
235: ip_ifremove(ifp);
236:
237: /*
238: * Now (re)insert it in the correct place
239: */
240: for(i=0; i<ipcnt; i++){
241: if(ipifsort[i]==ifp)
242: panic("ip_ifinsert duplcate");
243: if(ipifsort[i]==0 || (ifp->mask & ipifsort[i]->mask)!=ifp->mask)
244: break;
245: }
246: if(i>=ipcnt)
247: panic("ip_ifinsert no room");
248: for(j=ipcnt-1; j>i; j--)
249: ipifsort[j] = ipifsort[j-1];
250: ipifsort[i] = ifp;
251: splx(s);
252: }
253:
254: /*
255: * Remove an entry from ipifsort. Compress list to fill gap.
256: * It may not already be there.
257: */
258: ip_ifremove(ifp)
259: struct ipif *ifp;
260: {
261: int s = spl6();
262: register int i;
263:
264: for(i=0; i<ipcnt; i++)
265: if(ipifsort[i]==ifp)
266: break;
267: if(i<ipcnt){
268: for(; i<ipcnt-1; i++)
269: ipifsort[i] = ipifsort[i+1];
270: ipifsort[i] = 0;
271: }
272: splx(s);
273: }
274:
275: /*
276: * Find the interface to use for sending messages to `dst'.
277: * ipifsort is sorted into priority order;
278: * first match found is best.
279: */
280: struct ipif *
281: ip_ifonnetof(dst)
282: register unsigned long dst;
283: {
284: extern ipprintfs;
285: register struct ipif *ifp;
286: register int i;
287: register int Ipcnt = ipcnt; /* optimization */
288:
289: /*
290: * first look for a match against addresses
291: */
292: for(i=0; i < Ipcnt; i++){
293: if((ifp = ipifsort[i])==0)
294: break;
295: if(ifp->flags & IFF_UP)
296: if((dst & ifp->mask) == ifp->that)
297: return(ifp);
298: }
299:
300: /*
301: * now try to match against the local host's addresses
302: */
303: ifp = ip_ifwithaddr(dst);
304: if(ifp)
305: return(ifp);
306:
307: /*
308: * no match
309: */
310: if(ipprintfs)
311: printf("ifonnetof %x?\n", dst);
312: return(0);
313: }
314:
315: /*
316: * return the interface for which addr is a local address. if non
317: * such exists, return 0.
318: *
319: * This routine assumes that ipifsort is sorted in priority order
320: * so that the first match found is the best match.
321: */
322: struct ipif *
323: ip_ifwithaddr(addr)
324: register u_long addr;
325: {
326: register int i;
327: register u_long net, mask;
328: register struct ipif *ifp;
329: register int Ipcnt = ipcnt; /* optimization */
330:
331: net = in_netof(addr);
332: for(i=0; i < Ipcnt; i++){
333: if((ifp = ipifsort[i])==0)
334: break;
335: if(ifp->flags & IFF_UP) {
336:
337: /* address of this host */
338: if(addr == ifp->thishost)
339: return(ifp);
340:
341: /* standard IP broadcast address */
342: if(addr == ifp->broadcast)
343: return(ifp);
344:
345: /* old style BSD IP broadcast address */
346: if(addr == in_netof(ifp->thishost))
347: return(ifp);
348:
349: /* address on a network simulated by this node */
350: if(net == ifp->thishost)
351: return(ifp);
352:
353: /* finally, try unsubnetted broadcast addresses */
354: mask = IN_CLASS_NMASK(ifp->thishost);
355: if((mask&ifp->thishost | ~mask) == addr)
356: return(ifp);
357:
358: /* finally, try unsubnetted broadcast addresses */
359: if((mask&ifp->thishost) == addr)
360: return(ifp);
361: }
362: }
363: return(0);
364: }
365:
366: /*
367: * output list bp onto interface ifp
368: * for better buffering, put it on ip's queue first;
369: * iposrv will dribble it out as there's room
370: */
371: ip_ldout(bp, dst, ifp)
372: register struct block *bp;
373: unsigned long dst; /* host byte order */
374: register struct ipif *ifp;
375: {
376: extern struct block *arp_resolve();
377: register struct block *bp1;
378: register struct queue *q;
379:
380: if(ifp->queue == 0){
381: printf("ifp but no queue in ip_ldout\n");
382: bp_free(bp);
383: return(0);
384: }
385: q = WR(ifp->queue);
386: if(q->flag & QFULL){
387: bp_free(bp);
388: ifp->oerrors++;
389: return(1);
390: }
391: if(arpcnt > 0 && (ifp->flags & IFF_ARP)){
392: bp = arp_resolve(ifp->queue, bp, dst);
393: if(bp == 0)
394: return(1);
395: }
396: MCHECK(bp);
397: while(bp){
398: bp1 = bp->next;
399: if (bp1==NULL)
400: bp->class |= S_DELIM;
401: (*q->qinfo->putp)(q, bp);
402: bp = bp1;
403: }
404: return(0);
405: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.