![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clnp_subr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso|
Return to clnp_subr.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / sys / netiso |
1.1 root 1: /***********************************************************
2: Copyright IBM Corporation 1987
3:
4: All Rights Reserved
5:
6: Permission to use, copy, modify, and distribute this software and its
7: documentation for any purpose and without fee is hereby granted,
8: provided that the above copyright notice appear in all copies and that
9: both that copyright notice and this permission notice appear in
10: supporting documentation, and that the name of IBM not be
11: used in advertising or publicity pertaining to distribution of the
12: software without specific, written prior permission.
13:
14: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
15: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
16: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
17: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
18: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
19: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
20: SOFTWARE.
21:
22: ******************************************************************/
23:
24: /*
25: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
26: */
27: /* $Header: /var/src/sys/netiso/RCS/clnp_subr.c,v 5.1 89/02/09 16:20:46 hagens Exp $ */
28: /* $Source: /var/src/sys/netiso/RCS/clnp_subr.c,v $ */
29: /* @(#)clnp_subr.c 7.11 (Berkeley) 6/20/90 */
30:
31: #ifndef lint
32: static char *rcsid = "$Header: /var/src/sys/netiso/RCS/clnp_subr.c,v 5.1 89/02/09 16:20:46 hagens Exp $";
33: #endif lint
34:
35: #ifdef ISO
36:
37: #include "types.h"
38: #include "param.h"
39: #include "mbuf.h"
40: #include "domain.h"
41: #include "protosw.h"
42: #include "socket.h"
43: #include "socketvar.h"
44: #include "errno.h"
45: #include "time.h"
46:
47: #include "../net/if.h"
48: #include "../net/route.h"
49: #include "../net/if_dl.h"
50:
51: #include "iso.h"
52: #include "iso_var.h"
53: #include "iso_pcb.h"
54: #include "iso_snpac.h"
55: #include "clnp.h"
56: #include "clnp_stat.h"
57: #include "argo_debug.h"
58:
59: /*
60: * FUNCTION: clnp_data_ck
61: *
62: * PURPOSE: Check that the amount of data in the mbuf chain is
63: * at least as much as the clnp header would have us
64: * expect. Trim mbufs if longer than expected, drop
65: * packet if shorter than expected.
66: *
67: * RETURNS: success - ptr to mbuf chain
68: * failure - 0
69: *
70: * SIDE EFFECTS:
71: *
72: * NOTES:
73: */
74: struct mbuf *
75: clnp_data_ck(m, length)
76: register struct mbuf *m; /* ptr to mbuf chain containing hdr & data */
77: int length; /* length (in bytes) of packet */
78: {
79: register int len; /* length of data */
80: register struct mbuf *mhead; /* ptr to head of chain */
81:
82: len = -length;
83: mhead = m;
84: for (;;) {
85: len += m->m_len;
86: if (m->m_next == 0)
87: break;
88: m = m->m_next;
89: }
90: if (len != 0) {
91: if (len < 0) {
92: INCSTAT(cns_toosmall);
93: clnp_discard(mhead, GEN_INCOMPLETE);
94: return 0;
95: }
96: if (len <= m->m_len)
97: m->m_len -= len;
98: else
99: m_adj(mhead, -len);
100: }
101: return mhead;
102: }
103:
104: #ifdef ndef
105: /*
106: * FUNCTION: clnp_extract_addr
107: *
108: * PURPOSE: Extract the source and destination address from the
109: * supplied buffer. Place them in the supplied address buffers.
110: * If insufficient data is supplied, then fail.
111: *
112: * RETURNS: success - Address of first byte in the packet past
113: * the address part.
114: * failure - 0
115: *
116: * SIDE EFFECTS:
117: *
118: * NOTES:
119: */
120: caddr_t
121: clnp_extract_addr(bufp, buflen, srcp, destp)
122: caddr_t bufp; /* ptr to buffer containing addresses */
123: int buflen; /* length of buffer */
124: register struct iso_addr *srcp; /* ptr to source address buffer */
125: register struct iso_addr *destp; /* ptr to destination address buffer */
126: {
127: int len; /* argument to bcopy */
128:
129: /*
130: * check that we have enough data. Plus1 is for length octet
131: */
132: if ((u_char)*bufp + 1 > buflen) {
133: return((caddr_t)0);
134: }
135: len = destp->isoa_len = (u_char)*bufp++;
136: (void) bcopy(bufp, (caddr_t)destp, len);
137: buflen -= len;
138: bufp += len;
139:
140: /*
141: * check that we have enough data. Plus1 is for length octet
142: */
143: if ((u_char)*bufp + 1 > buflen) {
144: return((caddr_t)0);
145: }
146: len = srcp->isoa_len = (u_char)* bufp++;
147: (void) bcopy(bufp, (caddr_t)srcp, len);
148: bufp += len;
149:
150: /*
151: * Insure that the addresses make sense
152: */
153: if (iso_ck_addr(srcp) && iso_ck_addr(destp))
154: return bufp;
155: else
156: return (caddr_t) 0;
157: }
158: #endif ndef
159:
160: /*
161: * FUNCTION: clnp_ours
162: *
163: * PURPOSE: Decide whether the supplied packet is destined for
164: * us, or that it should be forwarded on.
165: *
166: * RETURNS: packet is for us - 1
167: * packet is not for us - 0
168: *
169: * SIDE EFFECTS:
170: *
171: * NOTES:
172: */
173: clnp_ours(dst)
174: register struct iso_addr *dst; /* ptr to destination address */
175: {
176: register struct iso_ifaddr *ia; /* scan through interface addresses */
177:
178: for (ia = iso_ifaddr; ia; ia = ia->ia_next) {
179: IFDEBUG(D_ROUTE)
180: printf("clnp_ours: ia_sis x%x, dst x%x\n", &ia->ia_addr,
181: dst);
182: ENDDEBUG
183: /*
184: * XXX Warning:
185: * We are overloading siso_tlen in the if's address, as an nsel length.
186: */
187: if (dst->isoa_len == ia->ia_addr.siso_nlen &&
188: bcmp((caddr_t)ia->ia_addr.siso_addr.isoa_genaddr,
189: (caddr_t)dst->isoa_genaddr,
190: ia->ia_addr.siso_nlen - ia->ia_addr.siso_tlen) == 0)
191: return 1;
192: }
193: return 0;
194: }
195:
196: /* Dec bit set if ifp qlen is greater than congest_threshold */
197: int congest_threshold = 0;
198:
199: /*
200: * FUNCTION: clnp_forward
201: *
202: * PURPOSE: Forward the datagram passed
203: * clnpintr guarantees that the header will be
204: * contigious (a cluster mbuf will be used if necessary).
205: *
206: * If oidx is NULL, no options are present.
207: *
208: * RETURNS: nothing
209: *
210: * SIDE EFFECTS:
211: *
212: * NOTES:
213: */
214: clnp_forward(m, len, dst, oidx, seg_off, inbound_shp)
215: struct mbuf *m; /* pkt to forward */
216: int len; /* length of pkt */
217: struct iso_addr *dst; /* destination address */
218: struct clnp_optidx *oidx; /* option index */
219: int seg_off;/* offset of segmentation part */
220: struct snpa_hdr *inbound_shp; /* subnetwork header of inbound packet */
221: {
222: struct clnp_fixed *clnp; /* ptr to fixed part of header */
223: int error; /* return value of route function */
224: struct sockaddr *next_hop; /* next hop for dgram */
225: struct ifnet *ifp; /* ptr to outgoing interface */
226: struct iso_ifaddr *ia = 0;/* ptr to iso name for ifp */
227: struct route_iso route; /* filled in by clnp_route */
228: extern int iso_systype;
229:
230: clnp = mtod(m, struct clnp_fixed *);
231: bzero((caddr_t)&route, sizeof(route)); /* MUST be done before "bad:" */
232:
233: /*
234: * Don't forward multicast or broadcast packets
235: */
236: if ((inbound_shp) && (IS_MULTICAST(inbound_shp->snh_dhost))) {
237: IFDEBUG(D_FORWARD)
238: printf("clnp_forward: dropping multicast packet\n");
239: ENDDEBUG
240: clnp->cnf_type &= ~CNF_ERR_OK; /* so we don't generate an ER */
241: clnp_discard(m, 0);
242: INCSTAT(cns_cantforward);
243: goto done;
244: }
245:
246: IFDEBUG(D_FORWARD)
247: printf("clnp_forward: %d bytes, to %s, options x%x\n", len,
248: clnp_iso_addrp(dst), oidx);
249: ENDDEBUG
250:
251: /*
252: * Decrement ttl, and if zero drop datagram
253: * Can't compare ttl as less than zero 'cause its a unsigned
254: */
255: if ((clnp->cnf_ttl == 0) || (--clnp->cnf_ttl == 0)) {
256: IFDEBUG(D_FORWARD)
257: printf("clnp_forward: discarding datagram because ttl is zero\n");
258: ENDDEBUG
259: INCSTAT(cns_ttlexpired);
260: clnp_discard(m, TTL_EXPTRANSIT);
261: goto done;
262: }
263: /*
264: * Route packet; special case for source rt
265: */
266: if CLNPSRCRT_VALID(oidx) {
267: /*
268: * Update src route first
269: */
270: clnp_update_srcrt(m, oidx);
271: error = clnp_srcroute(m, oidx, &route, &next_hop, &ia, dst);
272: } else {
273: error = clnp_route(dst, &route, 0, &next_hop, &ia);
274: }
275: if (error || ia == 0) {
276: IFDEBUG(D_FORWARD)
277: printf("clnp_forward: can't route packet (errno %d)\n", error);
278: ENDDEBUG
279: clnp_discard(m, ADDR_DESTUNREACH);
280: INCSTAT(cns_cantforward);
281: goto done;
282: }
283: ifp = ia->ia_ifp;
284:
285: IFDEBUG(D_FORWARD)
286: printf("clnp_forward: packet routed to %s\n",
287: clnp_iso_addrp(&((struct sockaddr_iso *)next_hop)->siso_addr));
288: ENDDEBUG
289:
290: INCSTAT(cns_forward);
291:
292: /*
293: * If we are an intermediate system and
294: * we are routing outbound on the same ifp that the packet
295: * arrived upon, and we know the next hop snpa,
296: * then generate a redirect request
297: */
298: if ((iso_systype & SNPA_IS) && (inbound_shp) &&
299: (ifp == inbound_shp->snh_ifp))
300: esis_rdoutput(inbound_shp, m, oidx, dst, route.ro_rt);
301: /*
302: * If options are present, update them
303: */
304: if (oidx) {
305: struct iso_addr *mysrc = &ia->ia_addr.siso_addr;
306: if (mysrc == NULL) {
307: clnp_discard(m, ADDR_DESTUNREACH);
308: INCSTAT(cns_cantforward);
309: clnp_stat.cns_forward--;
310: goto done;
311: } else {
312: (void) clnp_dooptions(m, oidx, ifp, mysrc);
313: }
314: }
315:
316: #ifdef DECBIT
317: if (ifp->if_snd.ifq_len > congest_threshold) {
318: /*
319: * Congestion! Set the Dec Bit and thank Dave Oran
320: */
321: IFDEBUG(D_FORWARD)
322: printf("clnp_forward: congestion experienced\n");
323: ENDDEBUG
324: if ((oidx) && (oidx->cni_qos_formatp)) {
325: caddr_t qosp = CLNP_OFFTOOPT(m, oidx->cni_qos_formatp);
326: u_char qos = *qosp;
327: IFDEBUG(D_FORWARD)
328: printf("clnp_forward: setting congestion bit (qos x%x)\n", qos);
329: ENDDEBUG
330: if ((qos & CLNPOVAL_GLOBAL) == CLNPOVAL_GLOBAL) {
331: qos |= CLNPOVAL_CONGESTED;
332: INCSTAT(cns_congest_set);
333: *qosp = qos;
334: }
335: }
336: }
337: #endif DECBIT
338:
339: /*
340: * Dispatch the datagram if it is small enough, otherwise fragment
341: */
342: if (len <= SN_MTU(ifp)) {
343: iso_gen_csum(m, CLNP_CKSUM_OFF, (int)clnp->cnf_hdr_len);
344: (void) (*ifp->if_output)(ifp, m, next_hop, route.ro_rt);
345: } else {
346: (void) clnp_fragment(ifp, m, next_hop, len, seg_off, /* flags */0, route.ro_rt);
347: }
348:
349: done:
350: /*
351: * Free route
352: */
353: if (route.ro_rt != NULL) {
354: RTFREE(route.ro_rt);
355: }
356: }
357:
358: #ifdef ndef
359: /*
360: * FUNCTION: clnp_insert_addr
361: *
362: * PURPOSE: Insert the address part into a clnp datagram.
363: *
364: * RETURNS: Address of first byte after address part in datagram.
365: *
366: * SIDE EFFECTS:
367: *
368: * NOTES: Assume that there is enough space for the address part.
369: */
370: caddr_t
371: clnp_insert_addr(bufp, srcp, dstp)
372: caddr_t bufp; /* address of where addr part goes */
373: register struct iso_addr *srcp; /* ptr to src addr */
374: register struct iso_addr *dstp; /* ptr to dst addr */
375: {
376: *bufp++ = dstp->isoa_len;
377: (void) bcopy((caddr_t)dstp, bufp, dstp->isoa_len);
378: bufp += dstp->isoa_len;
379:
380: *bufp++ = srcp->isoa_len;
381: (void) bcopy((caddr_t)srcp, bufp, srcp->isoa_len);
382: bufp += srcp->isoa_len;
383:
384: return bufp;
385: }
386:
387: #endif ndef
388:
389: /*
390: * FUNCTION: clnp_route
391: *
392: * PURPOSE: Route a clnp datagram to the first hop toward its
393: * destination. In many cases, the first hop will be
394: * the destination. The address of a route
395: * is specified. If a routing entry is present in
396: * that route, and it is still up to the same destination,
397: * then no further action is necessary. Otherwise, a
398: * new routing entry will be allocated.
399: *
400: * RETURNS: route found - 0
401: * unix error code
402: *
403: * SIDE EFFECTS:
404: *
405: * NOTES: It is up to the caller to free the routing entry
406: * allocated in route.
407: */
408: clnp_route(dst, ro, flags, first_hop, ifa)
409: struct iso_addr *dst; /* ptr to datagram destination */
410: register struct route_iso *ro; /* existing route structure */
411: int flags; /* flags for routing */
412: struct sockaddr **first_hop; /* result: fill in with ptr to firsthop */
413: struct iso_ifaddr **ifa; /* result: fill in with ptr to interface */
414: {
415: if (flags & SO_DONTROUTE) {
416: struct iso_ifaddr *ia;
417:
418: if (ro->ro_rt) {
419: RTFREE(ro->ro_rt);
420: ro->ro_rt = 0;
421: }
422: bzero((caddr_t)&ro->ro_dst, sizeof(ro->ro_dst));
423: bcopy((caddr_t)dst, (caddr_t)&ro->ro_dst.siso_addr,
424: 1 + (unsigned)dst->isoa_len);
425: ro->ro_dst.siso_family = AF_ISO;
426: ro->ro_dst.siso_len = sizeof(ro->ro_dst);
427: ia = iso_localifa(&ro->ro_dst);
428: if (ia == 0)
429: return EADDRNOTAVAIL;
430: if (ifa)
431: *ifa = ia;
432: if (first_hop)
433: *first_hop = (struct sockaddr *)&ro->ro_dst;
434: return 0;
435: }
436: /*
437: * If there is a cached route, check that it is still up and to
438: * the same destination. If not, free it and try again.
439: */
440: if (ro->ro_rt && ((ro->ro_rt->rt_flags & RTF_UP) == 0 ||
441: (Bcmp(ro->ro_dst.siso_data, dst->isoa_genaddr, dst->isoa_len)))) {
442: IFDEBUG(D_ROUTE)
443: printf("clnp_route: freeing old route: ro->ro_rt 0x%x\n",
444: ro->ro_rt);
445: printf("clnp_route: old route refcnt: 0x%x\n",
446: ro->ro_rt->rt_refcnt);
447: ENDDEBUG
448:
449: /* free old route entry */
450: RTFREE(ro->ro_rt);
451: ro->ro_rt = (struct rtentry *)0;
452: } else {
453: IFDEBUG(D_ROUTE)
454: printf("clnp_route: OK route exists\n");
455: ENDDEBUG
456: }
457:
458: if (ro->ro_rt == 0) {
459: /* set up new route structure */
460: bzero((caddr_t)&ro->ro_dst, sizeof(ro->ro_dst));
461: ro->ro_dst.siso_len = sizeof(ro->ro_dst);
462: ro->ro_dst.siso_family = AF_ISO;
463: Bcopy(dst, &ro->ro_dst.siso_addr, 1 + dst->isoa_len);
464: /* allocate new route */
465: IFDEBUG(D_ROUTE)
466: printf("clnp_route: allocating new route to %s\n",
467: clnp_iso_addrp(dst));
468: ENDDEBUG
469: rtalloc((struct route *)ro);
470: }
471: if (ro->ro_rt == 0)
472: return(ENETUNREACH); /* rtalloc failed */
473: ro->ro_rt->rt_use++;
474: if (ifa)
475: if ((*ifa = (struct iso_ifaddr *)ro->ro_rt->rt_ifa) == 0)
476: panic("clnp_route");
477: if (first_hop) {
478: if (ro->ro_rt->rt_flags & RTF_GATEWAY)
479: *first_hop = ro->ro_rt->rt_gateway;
480: else
481: *first_hop = (struct sockaddr *)&ro->ro_dst;
482: }
483: return(0);
484: }
485:
486: /*
487: * FUNCTION: clnp_srcroute
488: *
489: * PURPOSE: Source route the datagram. If complete source
490: * routing is specified but not possible, then
491: * return an error. If src routing is terminated, then
492: * try routing on destination.
493: * Usage of first_hop,
494: * ifp, and error return is identical to clnp_route.
495: *
496: * RETURNS: 0 or unix error code
497: *
498: * SIDE EFFECTS:
499: *
500: * NOTES: Remember that option index pointers are really
501: * offsets from the beginning of the mbuf.
502: */
503: clnp_srcroute(options, oidx, ro, first_hop, ifa, final_dst)
504: struct mbuf *options; /* ptr to options */
505: struct clnp_optidx *oidx; /* index to options */
506: struct route_iso *ro; /* route structure */
507: struct sockaddr **first_hop; /* RETURN: fill in with ptr to firsthop */
508: struct iso_ifaddr **ifa; /* RETURN: fill in with ptr to interface */
509: struct iso_addr *final_dst; /* final destination */
510: {
511: struct iso_addr dst; /* first hop specified by src rt */
512: int error = 0; /* return code */
513:
514: /*
515: * Check if we have run out of routes
516: * If so, then try to route on destination.
517: */
518: if CLNPSRCRT_TERM(oidx, options) {
519: dst.isoa_len = final_dst->isoa_len;
520: bcopy(final_dst->isoa_genaddr, dst.isoa_genaddr, dst.isoa_len);
521: } else {
522: /*
523: * setup dst based on src rt specified
524: */
525: dst.isoa_len = CLNPSRCRT_CLEN(oidx, options);
526: bcopy(CLNPSRCRT_CADDR(oidx, options), dst.isoa_genaddr, dst.isoa_len);
527: }
528:
529: /*
530: * try to route it
531: */
532: error = clnp_route(&dst, ro, 0, first_hop, ifa);
533: if (error != 0)
534: return error;
535:
536: /*
537: * If complete src rt, first hop must be equal to dst
538: */
539: if ((CLNPSRCRT_TYPE(oidx, options) == CLNPOVAL_COMPRT) &&
540: (!iso_addrmatch1(&(*(struct sockaddr_iso **)first_hop)->siso_addr,&dst))){
541: IFDEBUG(D_OPTIONS)
542: printf("clnp_srcroute: complete src route failed\n");
543: ENDDEBUG
544: return EHOSTUNREACH; /* RAH? would like ESRCRTFAILED */
545: }
546:
547: return error;
548: }
549:
550: /*
551: * FUNCTION: clnp_ypocb - backwards bcopy
552: *
553: * PURPOSE: bcopy starting at end of src rather than beginning.
554: *
555: * RETURNS: none
556: *
557: * SIDE EFFECTS:
558: *
559: * NOTES: No attempt has been made to make this efficient
560: */
561: clnp_ypocb(from, to, len)
562: caddr_t from; /* src buffer */
563: caddr_t to; /* dst buffer */
564: u_int len; /* number of bytes */
565: {
566: while (len--)
567: *(to + len) = *(from + len);
568: }
569:
570: /*
571: * FUNCTION: clnp_hdrsize
572: *
573: * PURPOSE: Return the size of a typical clnp hdr.
574: *
575: * RETURNS: Size of hdr in bytes.
576: *
577: * SIDE EFFECTS:
578: *
579: * NOTES: Assumes segmenting subset. If addrlen is
580: * zero, default to largest nsap address size.
581: */
582: clnp_hdrsize(addrlen)
583: u_char addrlen; /* length of nsap address */
584: {
585: if (addrlen == 0)
586: addrlen = 20;
587:
588: addrlen++; /* length of address byte */
589: addrlen *= 2; /* src and dst addresses */
590: addrlen += sizeof(struct clnp_fixed) + sizeof(struct clnp_segment);
591:
592: return(addrlen);
593: }
594: #endif ISO
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.