![[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] / researchv9 / sys / inet|
Return to ip_ld.c CVS log | Up to [Research Unix] / researchv9 / sys / 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 "inet.h"
7: #include "arp.h"
8: #include "uarp.h"
9: #include "../h/param.h"
10: #include "../h/systm.h"
11: #include "../h/stream.h"
12: #include "../h/ioctl.h"
13: #include "../h/ttyld.h"
14: #include "../h/map.h"
15: #include "../h/buf.h"
16: /*#include "../h/ubavar.h"*/
17: #include "../h/conf.h"
18: #include "../h/inet/in.h"
19: #include "../h/inet/ip_var.h"
20: #include "../h/inet/mbuf.h"
21: #include "../h/ethernet.h"
22:
23: struct ipif ipif[NINET];
24: int Ninet = NINET; /* let netstat find the number of interfaces */
25:
26: int ipopen(), ipiput(), ipisrv(), ipclose();
27: int iposrv();
28: static struct qinit iprinit = { ipiput, ipisrv, ipopen, ipclose, IP_MSG_LIMIT, 64};
29: static struct qinit ipwinit = { putq, iposrv, ipopen, ipclose, 1024, 64 };
30: struct streamtab ipinfo = { &iprinit, &ipwinit };
31:
32: ipopen(q, dev)
33: register struct queue *q;
34: {
35: static int timing;
36: register i;
37: register struct ipif *fp;
38:
39: if (q->ptr)
40: return(1);
41: if(!timing){
42: timing = 1;
43: ip_slowtimo();
44: }
45: for (i=0; ipif[i].queue!=0 && i<NINET; i++)
46: ;
47: if (i >= NINET)
48: return(0);
49: fp = &ipif[i];
50: fp->queue = q; /* that's the RD q */
51: fp->flags = IFF_UP;
52: fp->that = fp->thishost = 0;
53: fp->ipackets = fp->opackets = fp->ierrors = fp->oerrors = 0;
54: fp->mtu = 1500;
55: fp->arp = -1;
56: fp->dev = dev;
57: q->flag |= QDELIM;
58: WR(q)->flag |= QDELIM;
59: q->ptr = (caddr_t)fp;
60: WR(q)->ptr = (caddr_t)fp;
61: q->flag |= QNOENB; /* ipiput calls qenable() */
62: return(1);
63: }
64:
65: ipclose(q)
66: register struct queue *q;
67: {
68: register struct ipif *ifp;
69:
70: ifp = (struct ipif *)q->ptr;
71: #if NARP > 0
72: if (ifp->arp >= 0)
73: arp_disable(ifp->arp);
74: #endif
75: ifp->queue = 0;
76: ifp->flags = 0;
77: }
78:
79: ipisrv(q)
80: register struct queue *q;
81: {
82: register struct block *bp, *head, *tail;
83: register struct ipif *ifp;
84:
85: /* there is now a whole packet waiting
86: * on this queue; strip it off and pass to ip_input().
87: * things other than data or delims are forwarded directly
88: * by ipiput().
89: */
90: head = tail = (struct block *) 0;
91: ifp = (struct ipif *)q->ptr;
92: while(bp = getq(q)){
93: if(bp->type == M_DELIM){
94: freeb(bp);
95: if(head){
96: MCHECK(head);
97: if((ifp->flags & IFF_ARP)
98: && (head->wptr - head->rptr) >= sizeof(struct etherpup)){
99: /* blow away ether header */
100: head->rptr += sizeof(struct etherpup);
101: }
102: ip_input(head);
103: ifp->ipackets++;
104: } else {
105: printf("ipisrv: no data\n");
106: ifp->ierrors++;
107: }
108: head = tail = (struct block *) 0;
109: } else if(bp->type == M_DATA){
110: bp->next = (struct block *) 0;
111: if(head == (struct block *) 0){
112: head = bp;
113: } else {
114: tail->next = bp;
115: }
116: tail = bp;
117: } else {
118: printf("ipisrv: weird type %d\n", bp->type);
119: (*q->next->qinfo->putp)(q->next, bp);
120: }
121: }
122: if(head)
123: bp_putback(q, head);
124: }
125:
126:
127: ipiput(q, bp)
128: register struct queue *q;
129: register struct block *bp;
130: {
131: switch(bp->type){
132: case M_DATA:
133: putq(q, bp); /* putq does compression into blocks */
134: break;
135: case M_DELIM:
136: putq(q, bp);
137: qenable(q);
138: break;
139: default:
140: (*q->next->qinfo->putp)(q->next, bp);
141: break;
142: }
143:
144: }
145:
146: iposrv(q)
147: register struct queue *q;
148: {
149: struct x{
150: unsigned int in;
151: unsigned char en[6];
152: } *xp;
153: register union stmsg *sp;
154: register struct block *bp;
155: register struct ipif *ifp;
156: register int *intp;
157:
158: ifp = (struct ipif *)q->ptr;
159: while(bp = getq(q)){
160: if(bp->type == M_IOCTL){
161: sp = (union stmsg *)bp->rptr;
162: switch(sp->ioc0.com){
163: case IPIOARP:
164: #if NARP > 0
165: if (ifp->arp >= 0)
166: printf("IP: already arping\n");
167: else {
168: ifp->arp = arp_enable(ifp->dev,
169: ETHERPUP_IPTYPE,
170: sizeof(u_long), 1,
171: &ifp->thishost);
172: if (ifp->arp == -1) {
173: bp->type = M_IOCNAK;
174: qreply(q, bp);
175: break;
176: }
177: }
178: #endif
179: ifp->flags |= IFF_ARP;
180: bp->type = M_IOCACK;
181: bp->wptr = bp->rptr;
182: qreply(q, bp);
183: break;
184: case IPIORESOLVE:
185: xp = (struct x *)(sp->iocx.xxx);
186: #if NUARP > 0
187: arp_install(xp->in, xp->en);
188: #endif
189: bp->wptr = bp->rptr;
190: bp->type = M_IOCACK;
191: qreply(q, bp);
192: break;
193: case IPIOHOST:
194: intp = (int *)(sp->iocx.xxx);
195: ifp->that = *intp;
196: ifp->flags |= IFF_HOST;
197: bp->type = M_IOCACK;
198: qreply(q, bp);
199: ip_doroute(ifp->that, 0);
200: break;
201: case IPIOMTU:
202: intp = (int *)(sp->iocx.xxx);
203: ifp->that = *intp;
204: ifp->mtu = *intp;
205: bp->type = M_IOCACK;
206: qreply(q, bp);
207: break;
208: case IPIONET:
209: intp = (long *)(sp->iocx.xxx);
210: ifp->that = *intp;
211: ifp->mask = 0;
212: ifp->flags &= (~IFF_HOST);
213: bp->type = M_IOCACK;
214: qreply(q, bp);
215: ip_doroute(ifp->that, 0);
216: break;
217: case IPIOMASK:
218: intp = (long *)(sp->iocx.xxx);
219: ifp->mask = *intp;
220: bp->type = M_IOCACK;
221: qreply(q, bp);
222: ip_doroute(ifp->that, 0);
223: break;
224: case IPIOLOCAL:
225: intp = (int *)(sp->iocx.xxx);
226: ifp->thishost = *intp;
227: bp->type = M_IOCACK;
228: qreply(q, bp);
229: break;
230: default:
231: (*q->next->qinfo->putp)(q->next, bp);
232: break;
233: }
234: } else {
235: (*q->next->qinfo->putp)(q->next, bp);
236: if(bp->type == M_DELIM)
237: ifp->opackets++;
238: }
239: }
240: }
241:
242: struct ipif *
243: ip_ifonnetof(dst)
244: unsigned long dst;
245: {
246: extern ipprintfs;
247: struct ipif *ifp;
248:
249: /* point-to-point links first */
250: for(ifp = &ipif[0]; ifp < &ipif[NINET]; ifp++){
251: if((ifp->flags & IFF_UP) && (ifp->flags & IFF_HOST)){
252: if(dst == ifp->that)
253: return(ifp);
254: }
255: }
256: /* now normal nets */
257: for(ifp = &ipif[0]; ifp < &ipif[NINET]; ifp++){
258: if((ifp->flags & (IFF_UP|IFF_HOST)) == IFF_UP){
259: if(in_netof(dst) == ifp->that)
260: return(ifp);
261: }
262: }
263: if(ipprintfs)
264: printf("ifonnetof %x?\n", dst);
265: return(0);
266: }
267:
268: struct ipif *
269: ip_ifwithaddr(addr)
270: unsigned long addr;
271: {
272: struct ipif *ifp;
273: unsigned long net;
274:
275: net = in_netof(addr);
276: for(ifp = &ipif[0]; ifp < &ipif[NINET]; ifp++){
277: if(ifp->flags & IFF_UP){
278: /* address of this host */
279: if(addr == ifp->thishost)
280: return(ifp);
281: /* address of this host's network */
282: if(addr == in_netof(ifp->thishost))
283: return(ifp);
284: /* address on a network simulated by this node */
285: if(net == ifp->thishost)
286: return(ifp);
287: }
288: }
289: return(0);
290: }
291:
292: ip_ldout(bp, dst, ifp)
293: register struct block *bp;
294: unsigned long dst; /* host byte order */
295: register struct ipif *ifp;
296: {
297: #if NARP > 0 || NUARP > 0
298: extern struct block *arp_resolve();
299: #endif
300: register struct block *bp1;
301: register struct queue *q;
302:
303: if(ifp->queue == 0){
304: printf("ifp but no queue in ip_ldout\n");
305: bp_free(bp);
306: return(0);
307: }
308: q = WR(ifp->queue);
309: if(q->next->flag & QFULL){
310: bp_free(bp);
311: ifp->oerrors++;
312: return(1);
313: }
314: #if NARP > 0
315: if(ifp->flags & IFF_ARP){
316: bp = arp_resolve(ifp->arp, bp, &dst);
317: if(bp == 0)
318: return(1);
319: }
320: #endif
321: #if NUARP > 0
322: if(ifp->flags & IFF_ARP){
323: bp = arp_resolve(ifp->queue, bp, dst);
324: if(bp == 0)
325: return(1);
326: }
327: #endif
328: MCHECK(bp);
329: while(bp){
330: bp1 = bp->next;
331: (*q->next->qinfo->putp)(q->next, bp);
332: bp = bp1;
333: }
334: bp1 = allocb(0);
335: if(bp1){
336: bp1->type = M_DELIM;
337: (*q->next->qinfo->putp)(q->next, bp1);
338: ifp->opackets++;
339: } else {
340: printf("ip_ldout: no allocb for delim\n");
341: ifp->oerrors++;
342: }
343: return(0);
344: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.