![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ip_subr.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_subr.c CVS log | Up to [Research Unix] / researchv9 / sys / inet |
1.1 root 1: #include "inet.h"
2: #if NINET > 0
3:
4: #include "../h/param.h"
5: #include "../h/stream.h"
6: #include "../h/conf.h"
7: #include "../h/inet/in.h"
8: #include "../h/inet/ip.h"
9: #include "../h/inet/ip_var.h"
10: #include "../h/inet/mbuf.h"
11: #include "sparam.h"
12:
13: extern long time;
14:
15: struct block *
16: bp_get()
17: {
18: register struct block *bp;
19:
20: bp = allocb(64);
21: if(bp)
22: bp->next = 0;
23: return(bp);
24: }
25:
26: bp_check(bp)
27: register struct block *bp;
28: {
29: while(bp){
30: BLOCKCHK(bp);
31: bp = bp->next;
32: }
33: }
34:
35: /* given a char *, come up with the block that holds it. yuk. */
36: int dtom_hits, dtom_misses;
37: static u_char *xfirst16, *xfirst64, *xfirst1024, *xp;
38: struct block *xbp;
39:
40: struct block *
41: bp_dtom(p)
42: u_char *p;
43: {
44: extern struct block cblock[];
45: extern u_char blkdata[];
46: register u_char *first16, *first64, *first1024;
47: register struct block *bp;
48:
49: /* guess. the order of things in blkdata is NBLK4, NBLK16, ... */
50: #ifdef CHKBLK
51: first16 = &blkdata[5 * NBLK4];
52: first64 = &first16[17 * NBLK16];
53: first1024 = &first64[65 * NBLK64];
54: if(p < first16){
55: bp = &cblock[(p - blkdata) / 5];
56: } else if(p < first64){
57: bp = &cblock[NBLK4 + (p - first16) / 17];
58: } else if(p < first1024){
59: bp = &cblock[NBLK4 + NBLK16 + (p - first64) / 65];
60: } else {
61: bp = &cblock[NBLK4 + NBLK16 + NBLK64 + (p - first1024) / 1025];
62: }
63: #else
64: first16 = &blkdata[4 * NBLK4];
65: first64 = &first16[16 * NBLK16];
66: first1024 = &first64[64 * NBLK64];
67: if(p < first16){
68: bp = &cblock[(p - blkdata) / 4];
69: } else if(p < first64){
70: bp = &cblock[NBLK4 + (p - first16) / 16];
71: } else if(p < first1024){
72: bp = &cblock[NBLK4 + NBLK16 + (p - first64) / 64];
73: } else {
74: bp = &cblock[NBLK4 + NBLK16 + NBLK64 + (p - first1024) / 1024];
75: }
76: #endif CHKBLK
77: if(bp->base && bp->lim && bp->rptr && bp->wptr
78: && (p >= bp->base) && (p < bp->lim)){
79: BLOCKCHK(bp);
80: dtom_hits++;
81: return(bp);
82: }
83: xfirst16 = first16;
84: xfirst64 = first64;
85: xfirst1024 = first1024;
86: xp = p;
87: xbp = bp;
88: dtom_misses++;
89: for(bp = &cblock[NBLOCK-1]; bp >= &cblock[0]; --bp){
90: if(bp->base == 0 || bp->lim == 0 || bp->rptr == 0 || bp->wptr == 0)
91: continue;
92: if((p >= bp->base) && (p < bp->lim)){
93: return(bp);
94: }
95: }
96: panic("bp_dtom");
97: /* NOTREACHED */
98: }
99:
100: /* bp_pullup: make the first block have at least len bytes */
101: struct block *
102: bp_pullup(bp, len)
103: register struct block *bp;
104: {
105: register struct block *m, *n, *nn;
106: int count;
107:
108: n = bp;
109: if(len > MAXBLEN)
110: goto bad;
111: m = allocb(MAXBLEN);
112: if(m == 0)
113: goto bad;
114: do{
115: count = len;
116: if (m->lim - m->wptr < count)
117: count = m->lim - m->wptr;
118: if (BLEN(n) < count)
119: count = BLEN(n);
120: bcopy(n->rptr, m->wptr, (unsigned)count);
121: len -= count;
122: m->wptr += count;
123: n->rptr += count;
124: if(BLEN(n))
125: break;
126: nn = n->next;
127: freeb(n);
128: n = nn;
129: } while(n);
130: if(len){
131: freeb(m);
132: goto bad;
133: }
134: m->next = n;
135: MCHECK(m);
136: return(m);
137: bad:
138: printf("m_pullup bad\n");
139: bp_free(n);
140: return(0);
141: }
142:
143: bp_free(bp)
144: register struct block *bp;
145: {
146: register struct block *p;
147:
148: while(bp){
149: p = bp->next;
150: BLOCKCHK(bp);
151: freeb(bp);
152: bp = p;
153: }
154: }
155:
156: struct block *
157: bp_copy(m, off, len)
158: register struct block *m;
159: int off;
160: register int len;
161: {
162: register struct block *n, **np;
163: struct block *top;
164: register int clen;
165:
166: MCHECK(m);
167: if(len == 0)
168: return(0);
169: if(off < 0 || len < 0)
170: panic("m_copy");
171: while(off > 0){
172: if(m == 0)
173: panic("m_copy 1");
174: if(off < BLEN(m))
175: break;
176: off -= BLEN(m);
177: m = m->next;
178: }
179: np = ⊤
180: top = 0;
181: while(len > 0){
182: if(m == 0)
183: panic("m_copy 2");
184: n = allocb(len);
185: *np = n;
186: if(n == 0)
187: goto nospace;
188: n->next = 0;
189: np = &n->next;
190: do {
191: clen = len;
192: if (BLEN(m) - off < clen)
193: clen = BLEN(m) - off;
194: if (n->lim - n->wptr < clen)
195: clen = n->lim - n->wptr;
196: bcopy((caddr_t)m->rptr+off, (caddr_t)n->wptr, clen);
197: n->wptr += clen;
198: len -= clen;
199: if (len <= 0) {
200: MCHECK(top);
201: return (top);
202: }
203: if (m->rptr + off + clen < m->wptr)
204: off += clen;
205: else {
206: off = 0;
207: m = m->next;
208: }
209: } while (n->wptr < n->lim);
210: }
211: MCHECK(top);
212: return(top);
213: nospace:
214: bp_free(top);
215: return(0);
216: }
217:
218: bp_adj(m, len)
219: register struct block *m;
220: register int len;
221: {
222:
223: if (m == NULL)
224: return;
225: MCHECK(m);
226: if (len > 0) {
227: while(m && len > 0){
228: if(BLEN(m) <= len){
229: len -= BLEN(m);
230: m->wptr = m->rptr;
231: m = m->next;
232: } else {
233: m->rptr += len;
234: break;
235: }
236: }
237: }
238: else if (len < 0) {
239: len = bp_len(m) + len;
240: if (len <= 0) {
241: if (m->next)
242: bp_free(m->next);
243: m->next = 0;
244: m->wptr = m->rptr;
245: return;
246: }
247: while ((len -= BLEN(m)) > 0) {
248: if ((m = m->next) == NULL)
249: return;
250: }
251: m->wptr += len; /* len is <= 0 */
252: bp_free(m->next);
253: m->next = 0;
254: }
255: MCHECK(m);
256: }
257:
258: m_cat(m, n)
259: register struct block *m, *n;
260: {
261: struct mbuf *xn;
262:
263: MCHECK(m); MCHECK(n);
264: while(m->next)
265: m = m->next;
266: while(n){
267: if((m->wptr + BLEN(n)) >= m->lim){
268: /* just join the two chains */
269: m->next = n;
270: break;
271: }
272: /* splat the data from one into the other */
273: bcopy(n->rptr, m->wptr, BLEN(n));
274: m->wptr += BLEN(n);
275: xn = n->next;
276: freeb(n);
277: n = xn;
278: }
279: MCHECK(m);
280: }
281:
282: /* C version of 4.2bsd's Internet checksum routine */
283: /* This version assumes that no message exceeds 2^16 words */
284: in_cksum(m, len)
285: register struct mbuf *m;
286: register int len;
287: {
288: register u_short *w;
289: register u_long sum = 0;
290: register int mlen = 0;
291:
292: MCHECK(m);
293: for (; len!=0; m=m->m_next) {
294: if (m == NULL) {
295: printf("cksum: out of data\n");
296: break;
297: }
298: w = mtod(m, u_short *);
299: if (mlen == -1) {
300: /* last block ended on an odd numbered byte */
301: sum += *(u_char *)w << 8;
302: w = (u_short *)((char *)w + 1);
303: mlen = BLEN(m) - 1;
304: len--;
305: } else
306: mlen = BLEN(m);
307: if (len < mlen)
308: mlen = len;
309: len -= mlen;
310: /* vecadd returns a 16-bit checksum of the block + sum */
311: sum = vecadd(w, mlen, sum);
312: }
313: /* return complement of sum */
314: return sum^0xffff;
315: }
316:
317: in_addr
318: in_netof(x)
319: in_addr x;
320: {
321: in_addr netmask;
322: struct ipif *ifp;
323:
324: if(IN_CLASSC(x))
325: netmask = IN_CLASSC_NET;
326: else if(IN_CLASSB(x))
327: netmask = IN_CLASSB_NET;
328: else
329: netmask = IN_CLASSA_NET;
330:
331: /* look for an interface for this network and use its subnet mask */
332: for(ifp = &ipif[0]; ifp < &ipif[NINET]; ifp++){
333: if(ifp->flags & IFF_UP){
334: if(netmask&x == netmask&ifp->that)
335: if (ifp->mask==0)
336: return(x&netmask);
337: else
338: return(x&ifp->mask);
339: }
340: }
341:
342: /* no interface for this network, assume no subnetting */
343: return x&netmask;
344: }
345:
346: /*
347: * Hash table for route entries. Collision resolution is linear search until
348: * encountering a hole. Replacement is LRU.
349: */
350: #define NROUTES 128
351: struct ip_route ip_routes[NROUTES];
352: int Nip_route = NROUTES; /* let netstat know number of routes */
353: #define HASH(x) (((x)+((x)>>8))%NROUTES)
354: struct ip_route ip_default_route;
355:
356: ip_doroute(dst, gate)
357: in_addr dst, gate;
358: {
359: register struct ip_route *rp, *sp, *op;
360: register struct ipif *ifp;
361:
362: /* default is a special case */
363: if (dst == 0){
364: ip_default_route.gate = gate;
365: return(0);
366: }
367:
368: /* look for what should be a noop */
369: if(gate){
370: /* don't accept an indirect route, if we have a direct one */
371: for(ifp = ipif; ifp < &ipif[NINET]; ifp++){
372: if((ifp->flags&IFF_UP) && ifp->that==dst)
373: return(0);
374: }
375: } else
376: gate = dst;
377:
378: /* look through existing routes */
379: op = sp = rp = &ip_routes[HASH(dst)];
380: do {
381: if (rp->dst==0 || rp->dst==dst) {
382: op = rp;
383: break;
384: }
385: if (rp->time<op->time)
386: op = rp;
387: if (++rp==&ip_routes[NROUTES])
388: rp = ip_routes;
389: } while (rp != sp);
390:
391: /* add a new route */
392: op->dst = dst;
393: op->gate = gate;
394: op->time = time;
395: return(0);
396: }
397:
398: /* Look for a route on the circular list. If the route is found, move
399: * it to the beginning of the list.
400: */
401: struct ip_route_info
402: ip_route(dst)
403: in_addr dst;
404: {
405: register struct ip_route *rp, *sp;
406: extern unsigned long in_netof();
407: unsigned long netof_dst;
408: struct ip_route_info info;
409:
410: /* try a network to which we are directly connected */
411: info.addr = dst;
412: info.ifp = ip_ifonnetof(dst);
413: if (info.ifp)
414: return info;
415:
416: /* look for host routes */
417: sp = rp = &ip_routes[HASH(dst)];
418: do {
419: if (dst==rp->dst && rp->dst!=rp->gate) {
420: info.addr = rp->gate;
421: info.ifp = ip_ifonnetof(info.addr);
422: rp->time = time;
423: return(info);
424: }
425: if (rp->dst==0)
426: break;
427: if (++rp==&ip_routes[NROUTES])
428: rp = ip_routes;
429: } while (rp != sp);
430:
431: /* now try nets */
432: netof_dst = in_netof(dst);
433: sp = rp = &ip_routes[HASH(netof_dst)];
434: do {
435: if (netof_dst==rp->dst && rp->dst!=rp->gate) {
436: info.addr = rp->gate;
437: info.ifp = ip_ifonnetof(info.addr);
438: rp->time = time;
439: return(info);
440: }
441: if (rp->dst==0)
442: break;
443: if (++rp==&ip_routes[NROUTES])
444: rp = ip_routes;
445: } while (rp != sp);
446:
447: /* if all else fails, use default route */
448: /* N.B. If the gate is a network, don't change the destination
449: * address. This allows multiple networks on one wire by
450: * making that wire the default.
451: */
452: if (ip_default_route.gate!=in_netof(ip_default_route.gate))
453: info.addr = ip_default_route.gate;
454: else
455: info.addr = dst;
456: info.ifp = ip_ifonnetof(ip_default_route.gate);
457: return(info);
458: }
459:
460: bp_len(bp)
461: register struct block *bp;
462: {
463: register int n;
464:
465: n = 0;
466: while(bp){
467: n += BLEN(bp);
468: bp = bp->next;
469: }
470: return(n);
471: }
472:
473: bp_putback(q, list)
474: struct queue *q;
475: struct block *list;
476: {
477: register struct block *bp;
478: register struct block *prev, *next;
479:
480: /*
481: * reverse the list, to keep data in order
482: */
483: prev = next = NULL;
484: for (bp = list; bp; bp = next) {
485: next = bp->next;
486: bp->next = prev;
487: prev = bp;
488: }
489: for (bp = prev; bp; bp = next) {
490: next = bp->next;
491: putbq(q, bp);
492: }
493: }
494:
495: in_addr
496: ip_hoston(dst)
497: in_addr dst;
498: {
499: struct ip_route_info info;
500:
501: info = ip_route(dst);
502: if(info.ifp == 0)
503: return(0);
504: return(info.ifp->thishost);
505: }
506:
507: in_lnaof(i)
508: register u_long i;
509: {
510:
511: if(IN_CLASSA(i))
512: return((i)&IN_CLASSA_HOST);
513: else if(IN_CLASSB(i))
514: return((i)&IN_CLASSB_HOST);
515: else
516: return((i)&IN_CLASSC_HOST);
517: }
518: #endif NINET
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.