![[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 [Apple XNU] / XNU / bsd / netiso|
Return to clnp_subr.c CVS log | Up to [Apple XNU] / XNU / bsd / netiso |
1.1 root 1: /*
2: * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * The contents of this file constitute Original Code as defined in and
7: * are subject to the Apple Public Source License Version 1.1 (the
8: * "License"). You may not use this file except in compliance with the
9: * License. Please obtain a copy of the License at
10: * http://www.apple.com/publicsource and read it before using this file.
11: *
12: * This Original Code and all software distributed under the License are
13: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
14: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
15: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
16: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
17: * License for the specific language governing rights and limitations
18: * under the License.
19: *
20: * @APPLE_LICENSE_HEADER_END@
21: */
22: /*-
23: * Copyright (c) 1991, 1993
24: * The Regents of the University of California. All rights reserved.
25: *
26: * Redistribution and use in source and binary forms, with or without
27: * modification, are permitted provided that the following conditions
28: * are met:
29: * 1. Redistributions of source code must retain the above copyright
30: * notice, this list of conditions and the following disclaimer.
31: * 2. Redistributions in binary form must reproduce the above copyright
32: * notice, this list of conditions and the following disclaimer in the
33: * documentation and/or other materials provided with the distribution.
34: * 3. All advertising materials mentioning features or use of this software
35: * must display the following acknowledgement:
36: * This product includes software developed by the University of
37: * California, Berkeley and its contributors.
38: * 4. Neither the name of the University nor the names of its contributors
39: * may be used to endorse or promote products derived from this software
40: * without specific prior written permission.
41: *
42: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
43: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
44: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
45: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
46: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
47: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
48: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
49: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
50: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
51: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
52: * SUCH DAMAGE.
53: *
54: * @(#)clnp_subr.c 8.1 (Berkeley) 6/10/93
55: */
56:
57: /***********************************************************
58: Copyright IBM Corporation 1987
59:
60: All Rights Reserved
61:
62: Permission to use, copy, modify, and distribute this software and its
63: documentation for any purpose and without fee is hereby granted,
64: provided that the above copyright notice appear in all copies and that
65: both that copyright notice and this permission notice appear in
66: supporting documentation, and that the name of IBM not be
67: used in advertising or publicity pertaining to distribution of the
68: software without specific, written prior permission.
69:
70: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
71: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
72: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
73: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
74: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
75: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
76: SOFTWARE.
77:
78: ******************************************************************/
79:
80: /*
81: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
82: */
83:
84: #if ISO
85:
86: #include <sys/param.h>
87: #include <sys/mbuf.h>
88: #include <sys/domain.h>
89: #include <sys/protosw.h>
90: #include <sys/socket.h>
91: #include <sys/socketvar.h>
92: #include <sys/errno.h>
93: #include <sys/time.h>
94:
95: #include <net/if.h>
96: #include <net/route.h>
97: #include <net/if_dl.h>
98:
99: #include <netiso/iso.h>
100: #include <netiso/iso_var.h>
101: #include <netiso/iso_pcb.h>
102: #include <netiso/iso_snpac.h>
103: #include <netiso/clnp.h>
104: #include <netiso/clnp_stat.h>
105: #include <netiso/argo_debug.h>
106:
107: /*
108: * FUNCTION: clnp_data_ck
109: *
110: * PURPOSE: Check that the amount of data in the mbuf chain is
111: * at least as much as the clnp header would have us
112: * expect. Trim mbufs if longer than expected, drop
113: * packet if shorter than expected.
114: *
115: * RETURNS: success - ptr to mbuf chain
116: * failure - 0
117: *
118: * SIDE EFFECTS:
119: *
120: * NOTES:
121: */
122: struct mbuf *
123: clnp_data_ck(m, length)
124: register struct mbuf *m; /* ptr to mbuf chain containing hdr & data */
125: int length; /* length (in bytes) of packet */
126: {
127: register int len; /* length of data */
128: register struct mbuf *mhead; /* ptr to head of chain */
129:
130: len = -length;
131: mhead = m;
132: for (;;) {
133: len += m->m_len;
134: if (m->m_next == 0)
135: break;
136: m = m->m_next;
137: }
138: if (len != 0) {
139: if (len < 0) {
140: INCSTAT(cns_toosmall);
141: clnp_discard(mhead, GEN_INCOMPLETE);
142: return 0;
143: }
144: if (len <= m->m_len)
145: m->m_len -= len;
146: else
147: m_adj(mhead, -len);
148: }
149: return mhead;
150: }
151:
152: #ifdef notdef
153: /*
154: * FUNCTION: clnp_extract_addr
155: *
156: * PURPOSE: Extract the source and destination address from the
157: * supplied buffer. Place them in the supplied address buffers.
158: * If insufficient data is supplied, then fail.
159: *
160: * RETURNS: success - Address of first byte in the packet past
161: * the address part.
162: * failure - 0
163: *
164: * SIDE EFFECTS:
165: *
166: * NOTES:
167: */
168: caddr_t
169: clnp_extract_addr(bufp, buflen, srcp, destp)
170: caddr_t bufp; /* ptr to buffer containing addresses */
171: int buflen; /* length of buffer */
172: register struct iso_addr *srcp; /* ptr to source address buffer */
173: register struct iso_addr *destp; /* ptr to destination address buffer */
174: {
175: int len; /* argument to bcopy */
176:
177: /*
178: * check that we have enough data. Plus1 is for length octet
179: */
180: if ((u_char)*bufp + 1 > buflen) {
181: return((caddr_t)0);
182: }
183: len = destp->isoa_len = (u_char)*bufp++;
184: (void) bcopy(bufp, (caddr_t)destp, len);
185: buflen -= len;
186: bufp += len;
187:
188: /*
189: * check that we have enough data. Plus1 is for length octet
190: */
191: if ((u_char)*bufp + 1 > buflen) {
192: return((caddr_t)0);
193: }
194: len = srcp->isoa_len = (u_char)* bufp++;
195: (void) bcopy(bufp, (caddr_t)srcp, len);
196: bufp += len;
197:
198: /*
199: * Insure that the addresses make sense
200: */
201: if (iso_ck_addr(srcp) && iso_ck_addr(destp))
202: return bufp;
203: else
204: return (caddr_t) 0;
205: }
206: #endif /* notdef */
207:
208: /*
209: * FUNCTION: clnp_ours
210: *
211: * PURPOSE: Decide whether the supplied packet is destined for
212: * us, or that it should be forwarded on.
213: *
214: * RETURNS: packet is for us - 1
215: * packet is not for us - 0
216: *
217: * SIDE EFFECTS:
218: *
219: * NOTES:
220: */
221: clnp_ours(dst)
222: register struct iso_addr *dst; /* ptr to destination address */
223: {
224: register struct iso_ifaddr *ia; /* scan through interface addresses */
225:
226: for (ia = iso_ifaddr; ia; ia = ia->ia_next) {
227: IFDEBUG(D_ROUTE)
228: printf("clnp_ours: ia_sis x%x, dst x%x\n", &ia->ia_addr,
229: dst);
230: ENDDEBUG
231: /*
232: * XXX Warning:
233: * We are overloading siso_tlen in the if's address, as an nsel length.
234: */
235: if (dst->isoa_len == ia->ia_addr.siso_nlen &&
236: bcmp((caddr_t)ia->ia_addr.siso_addr.isoa_genaddr,
237: (caddr_t)dst->isoa_genaddr,
238: ia->ia_addr.siso_nlen - ia->ia_addr.siso_tlen) == 0)
239: return 1;
240: }
241: return 0;
242: }
243:
244: /* Dec bit set if ifp qlen is greater than congest_threshold */
245: int congest_threshold = 0;
246:
247: /*
248: * FUNCTION: clnp_forward
249: *
250: * PURPOSE: Forward the datagram passed
251: * clnpintr guarantees that the header will be
252: * contigious (a cluster mbuf will be used if necessary).
253: *
254: * If oidx is NULL, no options are present.
255: *
256: * RETURNS: nothing
257: *
258: * SIDE EFFECTS:
259: *
260: * NOTES:
261: */
262: clnp_forward(m, len, dst, oidx, seg_off, inbound_shp)
263: struct mbuf *m; /* pkt to forward */
264: int len; /* length of pkt */
265: struct iso_addr *dst; /* destination address */
266: struct clnp_optidx *oidx; /* option index */
267: int seg_off;/* offset of segmentation part */
268: struct snpa_hdr *inbound_shp; /* subnetwork header of inbound packet */
269: {
270: struct clnp_fixed *clnp; /* ptr to fixed part of header */
271: int error; /* return value of route function */
272: struct sockaddr *next_hop; /* next hop for dgram */
273: struct ifnet *ifp; /* ptr to outgoing interface */
274: struct iso_ifaddr *ia = 0;/* ptr to iso name for ifp */
275: struct route_iso route; /* filled in by clnp_route */
276: extern int iso_systype;
277:
278: clnp = mtod(m, struct clnp_fixed *);
279: bzero((caddr_t)&route, sizeof(route)); /* MUST be done before "bad:" */
280:
281: /*
282: * Don't forward multicast or broadcast packets
283: */
284: if ((inbound_shp) && (IS_MULTICAST(inbound_shp->snh_dhost))) {
285: IFDEBUG(D_FORWARD)
286: printf("clnp_forward: dropping multicast packet\n");
287: ENDDEBUG
288: clnp->cnf_type &= ~CNF_ERR_OK; /* so we don't generate an ER */
289: clnp_discard(m, 0);
290: INCSTAT(cns_cantforward);
291: goto done;
292: }
293:
294: IFDEBUG(D_FORWARD)
295: printf("clnp_forward: %d bytes, to %s, options x%x\n", len,
296: clnp_iso_addrp(dst), oidx);
297: ENDDEBUG
298:
299: /*
300: * Decrement ttl, and if zero drop datagram
301: * Can't compare ttl as less than zero 'cause its a unsigned
302: */
303: if ((clnp->cnf_ttl == 0) || (--clnp->cnf_ttl == 0)) {
304: IFDEBUG(D_FORWARD)
305: printf("clnp_forward: discarding datagram because ttl is zero\n");
306: ENDDEBUG
307: INCSTAT(cns_ttlexpired);
308: clnp_discard(m, TTL_EXPTRANSIT);
309: goto done;
310: }
311: /*
312: * Route packet; special case for source rt
313: */
314: if CLNPSRCRT_VALID(oidx) {
315: /*
316: * Update src route first
317: */
318: clnp_update_srcrt(m, oidx);
319: error = clnp_srcroute(m, oidx, &route, &next_hop, &ia, dst);
320: } else {
321: error = clnp_route(dst, &route, 0, &next_hop, &ia);
322: }
323: if (error || ia == 0) {
324: IFDEBUG(D_FORWARD)
325: printf("clnp_forward: can't route packet (errno %d)\n", error);
326: ENDDEBUG
327: clnp_discard(m, ADDR_DESTUNREACH);
328: INCSTAT(cns_cantforward);
329: goto done;
330: }
331: ifp = ia->ia_ifp;
332:
333: IFDEBUG(D_FORWARD)
334: printf("clnp_forward: packet routed to %s\n",
335: clnp_iso_addrp(&((struct sockaddr_iso *)next_hop)->siso_addr));
336: ENDDEBUG
337:
338: INCSTAT(cns_forward);
339:
340: /*
341: * If we are an intermediate system and
342: * we are routing outbound on the same ifp that the packet
343: * arrived upon, and we know the next hop snpa,
344: * then generate a redirect request
345: */
346: if ((iso_systype & SNPA_IS) && (inbound_shp) &&
347: (ifp == inbound_shp->snh_ifp))
348: esis_rdoutput(inbound_shp, m, oidx, dst, route.ro_rt);
349: /*
350: * If options are present, update them
351: */
352: if (oidx) {
353: struct iso_addr *mysrc = &ia->ia_addr.siso_addr;
354: if (mysrc == NULL) {
355: clnp_discard(m, ADDR_DESTUNREACH);
356: INCSTAT(cns_cantforward);
357: clnp_stat.cns_forward--;
358: goto done;
359: } else {
360: (void) clnp_dooptions(m, oidx, ifp, mysrc);
361: }
362: }
363:
364: #ifdef DECBIT
365: if (ifp->if_snd.ifq_len > congest_threshold) {
366: /*
367: * Congestion! Set the Dec Bit and thank Dave Oran
368: */
369: IFDEBUG(D_FORWARD)
370: printf("clnp_forward: congestion experienced\n");
371: ENDDEBUG
372: if ((oidx) && (oidx->cni_qos_formatp)) {
373: caddr_t qosp = CLNP_OFFTOOPT(m, oidx->cni_qos_formatp);
374: u_char qos = *qosp;
375: IFDEBUG(D_FORWARD)
376: printf("clnp_forward: setting congestion bit (qos x%x)\n", qos);
377: ENDDEBUG
378: if ((qos & CLNPOVAL_GLOBAL) == CLNPOVAL_GLOBAL) {
379: qos |= CLNPOVAL_CONGESTED;
380: INCSTAT(cns_congest_set);
381: *qosp = qos;
382: }
383: }
384: }
385: #endif /* DECBIT */
386:
387: /*
388: * Dispatch the datagram if it is small enough, otherwise fragment
389: */
390: if (len <= SN_MTU(ifp, route.ro_rt)) {
391: iso_gen_csum(m, CLNP_CKSUM_OFF, (int)clnp->cnf_hdr_len);
392: (void) (*ifp->if_output)(ifp, m, next_hop, route.ro_rt);
393: } else {
394: (void) clnp_fragment(ifp, m, next_hop, len, seg_off, /* flags */0, route.ro_rt);
395: }
396:
397: done:
398: /*
399: * Free route
400: */
401: if (route.ro_rt != NULL) {
402: RTFREE(route.ro_rt);
403: }
404: }
405:
406: #ifdef notdef
407: /*
408: * FUNCTION: clnp_insert_addr
409: *
410: * PURPOSE: Insert the address part into a clnp datagram.
411: *
412: * RETURNS: Address of first byte after address part in datagram.
413: *
414: * SIDE EFFECTS:
415: *
416: * NOTES: Assume that there is enough space for the address part.
417: */
418: caddr_t
419: clnp_insert_addr(bufp, srcp, dstp)
420: caddr_t bufp; /* address of where addr part goes */
421: register struct iso_addr *srcp; /* ptr to src addr */
422: register struct iso_addr *dstp; /* ptr to dst addr */
423: {
424: *bufp++ = dstp->isoa_len;
425: (void) bcopy((caddr_t)dstp, bufp, dstp->isoa_len);
426: bufp += dstp->isoa_len;
427:
428: *bufp++ = srcp->isoa_len;
429: (void) bcopy((caddr_t)srcp, bufp, srcp->isoa_len);
430: bufp += srcp->isoa_len;
431:
432: return bufp;
433: }
434:
435: #endif /* notdef */
436:
437: /*
438: * FUNCTION: clnp_route
439: *
440: * PURPOSE: Route a clnp datagram to the first hop toward its
441: * destination. In many cases, the first hop will be
442: * the destination. The address of a route
443: * is specified. If a routing entry is present in
444: * that route, and it is still up to the same destination,
445: * then no further action is necessary. Otherwise, a
446: * new routing entry will be allocated.
447: *
448: * RETURNS: route found - 0
449: * unix error code
450: *
451: * SIDE EFFECTS:
452: *
453: * NOTES: It is up to the caller to free the routing entry
454: * allocated in route.
455: */
456: clnp_route(dst, ro, flags, first_hop, ifa)
457: struct iso_addr *dst; /* ptr to datagram destination */
458: register struct route_iso *ro; /* existing route structure */
459: int flags; /* flags for routing */
460: struct sockaddr **first_hop; /* result: fill in with ptr to firsthop */
461: struct iso_ifaddr **ifa; /* result: fill in with ptr to interface */
462: {
463: if (flags & SO_DONTROUTE) {
464: struct iso_ifaddr *ia;
465:
466: if (ro->ro_rt) {
467: RTFREE(ro->ro_rt);
468: ro->ro_rt = 0;
469: }
470: bzero((caddr_t)&ro->ro_dst, sizeof(ro->ro_dst));
471: bcopy((caddr_t)dst, (caddr_t)&ro->ro_dst.siso_addr,
472: 1 + (unsigned)dst->isoa_len);
473: ro->ro_dst.siso_family = AF_ISO;
474: ro->ro_dst.siso_len = sizeof(ro->ro_dst);
475: ia = iso_localifa(&ro->ro_dst);
476: if (ia == 0)
477: return EADDRNOTAVAIL;
478: if (ifa)
479: *ifa = ia;
480: if (first_hop)
481: *first_hop = (struct sockaddr *)&ro->ro_dst;
482: return 0;
483: }
484: /*
485: * If there is a cached route, check that it is still up and to
486: * the same destination. If not, free it and try again.
487: */
488: if (ro->ro_rt && ((ro->ro_rt->rt_flags & RTF_UP) == 0 ||
489: (Bcmp(ro->ro_dst.siso_data, dst->isoa_genaddr, dst->isoa_len)))) {
490: IFDEBUG(D_ROUTE)
491: printf("clnp_route: freeing old route: ro->ro_rt 0x%x\n",
492: ro->ro_rt);
493: printf("clnp_route: old route refcnt: 0x%x\n",
494: ro->ro_rt->rt_refcnt);
495: ENDDEBUG
496:
497: /* free old route entry */
498: RTFREE(ro->ro_rt);
499: ro->ro_rt = (struct rtentry *)0;
500: } else {
501: IFDEBUG(D_ROUTE)
502: printf("clnp_route: OK route exists\n");
503: ENDDEBUG
504: }
505:
506: if (ro->ro_rt == 0) {
507: /* set up new route structure */
508: bzero((caddr_t)&ro->ro_dst, sizeof(ro->ro_dst));
509: ro->ro_dst.siso_len = sizeof(ro->ro_dst);
510: ro->ro_dst.siso_family = AF_ISO;
511: Bcopy(dst, &ro->ro_dst.siso_addr, 1 + dst->isoa_len);
512: /* allocate new route */
513: IFDEBUG(D_ROUTE)
514: printf("clnp_route: allocating new route to %s\n",
515: clnp_iso_addrp(dst));
516: ENDDEBUG
517: rtalloc((struct route *)ro);
518: }
519: if (ro->ro_rt == 0)
520: return(ENETUNREACH); /* rtalloc failed */
521: ro->ro_rt->rt_use++;
522: if (ifa)
523: if ((*ifa = (struct iso_ifaddr *)ro->ro_rt->rt_ifa) == 0)
524: panic("clnp_route");
525: if (first_hop) {
526: if (ro->ro_rt->rt_flags & RTF_GATEWAY)
527: *first_hop = ro->ro_rt->rt_gateway;
528: else
529: *first_hop = (struct sockaddr *)&ro->ro_dst;
530: }
531: return(0);
532: }
533:
534: /*
535: * FUNCTION: clnp_srcroute
536: *
537: * PURPOSE: Source route the datagram. If complete source
538: * routing is specified but not possible, then
539: * return an error. If src routing is terminated, then
540: * try routing on destination.
541: * Usage of first_hop,
542: * ifp, and error return is identical to clnp_route.
543: *
544: * RETURNS: 0 or unix error code
545: *
546: * SIDE EFFECTS:
547: *
548: * NOTES: Remember that option index pointers are really
549: * offsets from the beginning of the mbuf.
550: */
551: clnp_srcroute(options, oidx, ro, first_hop, ifa, final_dst)
552: struct mbuf *options; /* ptr to options */
553: struct clnp_optidx *oidx; /* index to options */
554: struct route_iso *ro; /* route structure */
555: struct sockaddr **first_hop; /* RETURN: fill in with ptr to firsthop */
556: struct iso_ifaddr **ifa; /* RETURN: fill in with ptr to interface */
557: struct iso_addr *final_dst; /* final destination */
558: {
559: struct iso_addr dst; /* first hop specified by src rt */
560: int error = 0; /* return code */
561:
562: /*
563: * Check if we have run out of routes
564: * If so, then try to route on destination.
565: */
566: if CLNPSRCRT_TERM(oidx, options) {
567: dst.isoa_len = final_dst->isoa_len;
568: bcopy(final_dst->isoa_genaddr, dst.isoa_genaddr, dst.isoa_len);
569: } else {
570: /*
571: * setup dst based on src rt specified
572: */
573: dst.isoa_len = CLNPSRCRT_CLEN(oidx, options);
574: bcopy(CLNPSRCRT_CADDR(oidx, options), dst.isoa_genaddr, dst.isoa_len);
575: }
576:
577: /*
578: * try to route it
579: */
580: error = clnp_route(&dst, ro, 0, first_hop, ifa);
581: if (error != 0)
582: return error;
583:
584: /*
585: * If complete src rt, first hop must be equal to dst
586: */
587: if ((CLNPSRCRT_TYPE(oidx, options) == CLNPOVAL_COMPRT) &&
588: (!iso_addrmatch1(&(*(struct sockaddr_iso **)first_hop)->siso_addr,&dst))){
589: IFDEBUG(D_OPTIONS)
590: printf("clnp_srcroute: complete src route failed\n");
591: ENDDEBUG
592: return EHOSTUNREACH; /* RAH? would like ESRCRTFAILED */
593: }
594:
595: return error;
596: }
597:
598: /*
599: * FUNCTION: clnp_echoreply
600: *
601: * PURPOSE: generate an echo reply packet and transmit
602: *
603: * RETURNS: result of clnp_output
604: *
605: * SIDE EFFECTS:
606: */
607: clnp_echoreply(ec_m, ec_len, ec_src, ec_dst, ec_oidxp)
608: struct mbuf *ec_m; /* echo request */
609: int ec_len; /* length of ec */
610: struct sockaddr_iso *ec_src; /* src of ec */
611: struct sockaddr_iso *ec_dst; /* destination of ec (i.e., us) */
612: struct clnp_optidx *ec_oidxp; /* options index to ec packet */
613: {
614: struct isopcb isopcb;
615: int flags = CLNP_NOCACHE|CLNP_ECHOR;
616: int ret;
617:
618: /* fill in fake isopcb to pass to output function */
619: bzero(&isopcb, sizeof(isopcb));
620: isopcb.isop_laddr = ec_dst;
621: isopcb.isop_faddr = ec_src;
622:
623: /* forget copying the options for now. If implemented, need only
624: * copy record route option, but it must be reset to zero length */
625:
626: ret = clnp_output(ec_m, &isopcb, ec_len, flags);
627:
628: IFDEBUG(D_OUTPUT)
629: printf("clnp_echoreply: output returns %d\n", ret);
630: ENDDEBUG
631: return ret;
632: }
633:
634: /*
635: * FUNCTION: clnp_badmtu
636: *
637: * PURPOSE: print notice of route with mtu not initialized.
638: *
639: * RETURNS: mtu of ifp.
640: *
641: * SIDE EFFECTS: prints notice, slows down system.
642: */
643: clnp_badmtu(ifp, rt, line, file)
644: struct ifnet *ifp; /* outgoing interface */
645: struct rtentry *rt; /* dst route */
646: int line; /* where the dirty deed occured */
647: char *file; /* where the dirty deed occured */
648: {
649: printf("sending on route 0x%x with no mtu, line %d of file %s\n",
650: rt, line, file);
651: #ifdef ARGO_DEBUG
652: printf("route dst is ");
653: dump_isoaddr(rt_key(rt));
654: #endif
655: return ifp->if_mtu;
656: }
657:
658: /*
659: * FUNCTION: clnp_ypocb - backwards bcopy
660: *
661: * PURPOSE: bcopy starting at end of src rather than beginning.
662: *
663: * RETURNS: none
664: *
665: * SIDE EFFECTS:
666: *
667: * NOTES: No attempt has been made to make this efficient
668: */
669: clnp_ypocb(from, to, len)
670: caddr_t from; /* src buffer */
671: caddr_t to; /* dst buffer */
672: u_int len; /* number of bytes */
673: {
674: while (len--)
675: *(to + len) = *(from + len);
676: }
677: #endif /* ISO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.