![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clnp_output.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netiso|
Return to clnp_output.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netiso |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: /*-
26: * Copyright (c) 1991, 1993
27: * The Regents of the University of California. All rights reserved.
28: *
29: * Redistribution and use in source and binary forms, with or without
30: * modification, are permitted provided that the following conditions
31: * are met:
32: * 1. Redistributions of source code must retain the above copyright
33: * notice, this list of conditions and the following disclaimer.
34: * 2. Redistributions in binary form must reproduce the above copyright
35: * notice, this list of conditions and the following disclaimer in the
36: * documentation and/or other materials provided with the distribution.
37: * 3. All advertising materials mentioning features or use of this software
38: * must display the following acknowledgement:
39: * This product includes software developed by the University of
40: * California, Berkeley and its contributors.
41: * 4. Neither the name of the University nor the names of its contributors
42: * may be used to endorse or promote products derived from this software
43: * without specific prior written permission.
44: *
45: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
46: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
47: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
48: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
49: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
50: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
51: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
52: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
53: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
54: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
55: * SUCH DAMAGE.
56: *
57: * @(#)clnp_output.c 8.1 (Berkeley) 6/10/93
58: */
59:
60: /***********************************************************
61: Copyright IBM Corporation 1987
62:
63: All Rights Reserved
64:
65: Permission to use, copy, modify, and distribute this software and its
66: documentation for any purpose and without fee is hereby granted,
67: provided that the above copyright notice appear in all copies and that
68: both that copyright notice and this permission notice appear in
69: supporting documentation, and that the name of IBM not be
70: used in advertising or publicity pertaining to distribution of the
71: software without specific, written prior permission.
72:
73: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
74: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
75: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
76: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
77: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
78: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
79: SOFTWARE.
80:
81: ******************************************************************/
82:
83: /*
84: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
85: */
86:
87: #include <sys/param.h>
88: #include <sys/mbuf.h>
89: #include <sys/domain.h>
90: #include <sys/protosw.h>
91: #include <sys/socket.h>
92: #include <sys/socketvar.h>
93: #include <sys/errno.h>
94: #include <sys/time.h>
95:
96: #include <net/if.h>
97: #include <net/route.h>
98:
99: #include <netiso/iso.h>
100: #include <netiso/iso_var.h>
101: #include <netiso/iso_pcb.h>
102: #include <netiso/clnp.h>
103: #include <netiso/clnp_stat.h>
104: #include <netiso/argo_debug.h>
105:
106: static struct clnp_fixed dt_template = {
107: ISO8473_CLNP, /* network identifier */
108: 0, /* length */
109: ISO8473_V1, /* version */
110: CLNP_TTL, /* ttl */
111: CLNP_DT|CNF_SEG_OK|CNF_ERR_OK, /* type */
112: 0, /* segment length */
113: 0 /* checksum */
114: };
115:
116: static struct clnp_fixed raw_template = {
117: ISO8473_CLNP, /* network identifier */
118: 0, /* length */
119: ISO8473_V1, /* version */
120: CLNP_TTL, /* ttl */
121: CLNP_RAW|CNF_SEG_OK|CNF_ERR_OK, /* type */
122: 0, /* segment length */
123: 0 /* checksum */
124: };
125:
126: static struct clnp_fixed echo_template = {
127: ISO8473_CLNP, /* network identifier */
128: 0, /* length */
129: ISO8473_V1, /* version */
130: CLNP_TTL, /* ttl */
131: CLNP_EC|CNF_SEG_OK|CNF_ERR_OK, /* type */
132: 0, /* segment length */
133: 0 /* checksum */
134: };
135:
136: static struct clnp_fixed echor_template = {
137: ISO8473_CLNP, /* network identifier */
138: 0, /* length */
139: ISO8473_V1, /* version */
140: CLNP_TTL, /* ttl */
141: CLNP_ECR|CNF_SEG_OK|CNF_ERR_OK, /* type */
142: 0, /* segment length */
143: 0 /* checksum */
144: };
145:
146: #ifdef DECBIT
147: u_char qos_option[] = {CLNPOVAL_QOS, 1,
148: CLNPOVAL_GLOBAL|CLNPOVAL_SEQUENCING|CLNPOVAL_LOWDELAY};
149: #endif /* DECBIT */
150:
151: int clnp_id = 0; /* id for segmented dgrams */
152:
153: /*
154: * FUNCTION: clnp_output
155: *
156: * PURPOSE: output the data in the mbuf as a clnp datagram
157: *
158: * The data specified by m0 is sent as a clnp datagram.
159: * The mbuf chain m0 will be freed when this routine has
160: * returned.
161: *
162: * If options is non-null, it points to an mbuf which contains
163: * options to be sent with the datagram. The options must
164: * be formatted in the mbuf according to clnp rules. Options
165: * will not be freed.
166: *
167: * Datalen specifies the length of the data in m0.
168: *
169: * Src and dst are the addresses for the packet.
170: *
171: * If route is non-null, it is used as the route for
172: * the packet.
173: *
174: * By default, a DT is sent. However, if flags & CNLP_SEND_ER
175: * then an ER will be sent. If flags & CLNP_SEND_RAW, then
176: * the packet will be send as raw clnp.
177: *
178: * RETURNS: 0 success
179: * appropriate error code
180: *
181: * SIDE EFFECTS: none
182: *
183: * NOTES:
184: * Flags are interpretated as follows:
185: * CLNP_NO_SEG - do not allow this pkt to be segmented.
186: * CLNP_NO_ER - have pkt request ER suppression.
187: * CLNP_SEND_RAW - send pkt as RAW DT rather than TP DT
188: * CLNP_NO_CKSUM - don't compute clnp checksum
189: * CLNP_ECHO - send as ECHO packet
190: *
191: * When checking for a cached packet, clnp checks
192: * that the route taken is still up. It does not
193: * check that the route is still to the same destination.
194: * This means that any entity that alters an existing
195: * route for an isopcb (such as when a redirect arrives)
196: * must invalidate the clnp cache. It might be perferable
197: * to have clnp check that the route has the same dest, but
198: * by avoiding this check, we save a call to iso_addrmatch1.
199: */
200: clnp_output(m0, isop, datalen, flags)
201: struct mbuf *m0; /* data for the packet */
202: struct isopcb *isop; /* iso pcb */
203: int datalen; /* number of bytes of data in m0 */
204: int flags; /* flags */
205: {
206: int error = 0; /* return value of function */
207: register struct mbuf *m = m0; /* mbuf for clnp header chain */
208: register struct clnp_fixed *clnp; /* ptr to fixed part of hdr */
209: register caddr_t hoff; /* offset into header */
210: int total_len; /* total length of packet */
211: struct iso_addr *src; /* ptr to source address */
212: struct iso_addr *dst; /* ptr to destination address */
213: struct clnp_cache clc; /* storage for cache information */
214: struct clnp_cache *clcp = NULL; /* ptr to clc */
215: int hdrlen = 0;
216:
217: dst = &isop->isop_faddr->siso_addr;
218: if (isop->isop_laddr == 0) {
219: struct iso_ifaddr *ia = 0;
220: clnp_route(dst, &isop->isop_route, flags, 0, &ia);
221: if (ia == 0 || ia->ia_ifa.ifa_addr->sa_family != AF_ISO)
222: return (ENETUNREACH);
223: src = &ia->ia_addr.siso_addr;
224: } else
225: src = &isop->isop_laddr->siso_addr;
226:
227: IFDEBUG(D_OUTPUT)
228: printf("clnp_output: to %s", clnp_iso_addrp(dst));
229: printf(" from %s of %d bytes\n", clnp_iso_addrp(src), datalen);
230: printf("\toptions x%x, flags x%x, isop_clnpcache x%x\n",
231: isop->isop_options, flags, isop->isop_clnpcache);
232: ENDDEBUG
233:
234: if (isop->isop_clnpcache != NULL) {
235: clcp = mtod(isop->isop_clnpcache, struct clnp_cache *);
236: }
237:
238: /*
239: * Check if cache is valid ...
240: */
241: IFDEBUG(D_OUTPUT)
242: printf("clnp_output: ck cache: clcp %x\n", clcp);
243: if (clcp != NULL) {
244: printf("\tclc_dst %s\n", clnp_iso_addrp(&clcp->clc_dst));
245: printf("\tisop_opts x%x, clc_opts x%x\n", isop->isop_options,
246: clcp->clc_options);
247: if (isop->isop_route.ro_rt)
248: printf("\tro_rt x%x, rt_flags x%x\n",
249: isop->isop_route.ro_rt, isop->isop_route.ro_rt->rt_flags);
250: printf("\tflags x%x, clc_flags x%x\n", flags, clcp->clc_flags);
251: printf("\tclc_hdr x%x\n", clcp->clc_hdr);
252: }
253: ENDDEBUG
254: if ((clcp != NULL) && /* cache exists */
255: (isop->isop_options == clcp->clc_options) && /* same options */
256: (iso_addrmatch1(dst, &clcp->clc_dst)) && /* dst still same */
257: (isop->isop_route.ro_rt != NULL) && /* route exists */
258: (isop->isop_route.ro_rt == clcp->clc_rt) && /* and is cached */
259: (isop->isop_route.ro_rt->rt_flags & RTF_UP) && /* route still up */
260: (flags == clcp->clc_flags) && /* same flags */
261: (clcp->clc_hdr != NULL)) { /* hdr mbuf exists */
262: /*
263: * The cache is valid
264: */
265:
266: IFDEBUG(D_OUTPUT)
267: printf("clnp_output: using cache\n");
268: ENDDEBUG
269:
270: m = m_copy(clcp->clc_hdr, 0, (int)M_COPYALL);
271: if (m == NULL) {
272: /*
273: * No buffers left to copy cached packet header. Use
274: * the cached packet header this time, and
275: * mark the hdr as vacant
276: */
277: m = clcp->clc_hdr;
278: clcp->clc_hdr = NULL;
279: }
280: m->m_next = m0; /* ASSUMES pkt hdr is 1 mbuf long */
281: clnp = mtod(m, struct clnp_fixed *);
282: } else {
283: struct clnp_optidx *oidx = NULL; /* index to clnp options */
284:
285: /*
286: * The cache is not valid. Allocate an mbuf (if necessary)
287: * to hold cached info. If one is not available, then
288: * don't bother with the cache
289: */
290: INCSTAT(cns_cachemiss);
291: if (flags & CLNP_NOCACHE) {
292: clcp = &clc;
293: } else {
294: if (isop->isop_clnpcache == NULL) {
295: /*
296: * There is no clnpcache. Allocate an mbuf to hold one
297: */
298: if ((isop->isop_clnpcache = m_get(M_DONTWAIT, MT_HEADER))
299: == NULL) {
300: /*
301: * No mbufs available. Pretend that we don't want
302: * caching this time.
303: */
304: IFDEBUG(D_OUTPUT)
305: printf("clnp_output: no mbufs to allocate to cache\n");
306: ENDDEBUG
307: flags |= CLNP_NOCACHE;
308: clcp = &clc;
309: } else {
310: clcp = mtod(isop->isop_clnpcache, struct clnp_cache *);
311: }
312: } else {
313: /*
314: * A clnpcache mbuf exists. If the clc_hdr is not null,
315: * we must free it, as a new one is about to be created.
316: */
317: clcp = mtod(isop->isop_clnpcache, struct clnp_cache *);
318: if (clcp->clc_hdr != NULL) {
319: /*
320: * The clc_hdr is not null but a clnpcache mbuf exists.
321: * This means that there was a cache, but the existing
322: * copy of the hdr is no longer valid. Free it now
323: * before we lose the pointer to it.
324: */
325: IFDEBUG(D_OUTPUT)
326: printf("clnp_output: freeing old clc_hdr 0x%x\n",
327: clcp->clc_hdr);
328: ENDDEBUG
329: m_free(clcp->clc_hdr);
330: IFDEBUG(D_OUTPUT)
331: printf("clnp_output: freed old clc_hdr (done)\n");
332: ENDDEBUG
333: }
334: }
335: }
336: IFDEBUG(D_OUTPUT)
337: printf("clnp_output: NEW clcp x%x\n",clcp);
338: ENDDEBUG
339: bzero((caddr_t)clcp, sizeof(struct clnp_cache));
340:
341: if (isop->isop_optindex)
342: oidx = mtod(isop->isop_optindex, struct clnp_optidx *);
343:
344: /*
345: * Don't allow packets with security, quality of service,
346: * priority, or error report options to be sent.
347: */
348: if ((isop->isop_options) && (oidx)) {
349: if ((oidx->cni_securep) ||
350: (oidx->cni_priorp) ||
351: (oidx->cni_qos_formatp) ||
352: (oidx->cni_er_reason != ER_INVALREAS)) {
353: IFDEBUG(D_OUTPUT)
354: printf("clnp_output: pkt dropped - option unsupported\n");
355: ENDDEBUG
356: m_freem(m0);
357: return(EINVAL);
358: }
359: }
360:
361: /*
362: * Don't allow any invalid flags to be set
363: */
364: if ((flags & (CLNP_VFLAGS)) != flags) {
365: IFDEBUG(D_OUTPUT)
366: printf("clnp_output: packet dropped - flags unsupported\n");
367: ENDDEBUG
368: INCSTAT(cns_odropped);
369: m_freem(m0);
370: return(EINVAL);
371: }
372:
373: /*
374: * Don't allow funny lengths on dst; src may be zero in which
375: * case we insert the source address based upon the interface
376: */
377: if ((src->isoa_len > sizeof(struct iso_addr)) ||
378: (dst->isoa_len == 0) ||
379: (dst->isoa_len > sizeof(struct iso_addr))) {
380: m_freem(m0);
381: INCSTAT(cns_odropped);
382: return(ENAMETOOLONG);
383: }
384:
385: /*
386: * Grab mbuf to contain header
387: */
388: MGETHDR(m, M_DONTWAIT, MT_HEADER);
389: if (m == 0) {
390: m_freem(m0);
391: INCSTAT(cns_odropped);
392: return(ENOBUFS);
393: }
394: INCSTAT(cns_sent);
395: m->m_next = m0;
396: clnp = mtod(m, struct clnp_fixed *);
397: clcp->clc_segoff = 0;
398:
399: /*
400: * Fill in all of fixed hdr except lengths and checksum
401: */
402: if (flags & CLNP_SEND_RAW) {
403: *clnp = raw_template;
404: } else if (flags & CLNP_ECHO) {
405: *clnp = echo_template;
406: } else if (flags & CLNP_ECHOR) {
407: *clnp = echor_template;
408: } else {
409: *clnp = dt_template;
410: }
411: if (flags & CLNP_NO_SEG)
412: clnp->cnf_type &= ~CNF_SEG_OK;
413: if (flags & CLNP_NO_ER)
414: clnp->cnf_type &= ~CNF_ERR_OK;
415:
416: /*
417: * Route packet; special case for source rt
418: */
419: if ((isop->isop_options) && CLNPSRCRT_VALID(oidx)) {
420: IFDEBUG(D_OUTPUT)
421: printf("clnp_output: calling clnp_srcroute\n");
422: ENDDEBUG
423: error = clnp_srcroute(isop->isop_options, oidx, &isop->isop_route,
424: &clcp->clc_firsthop, &clcp->clc_ifa, dst);
425: } else {
426: IFDEBUG(D_OUTPUT)
427: ENDDEBUG
428: error = clnp_route(dst, &isop->isop_route, flags,
429: &clcp->clc_firsthop, &clcp->clc_ifa);
430: }
431: if (error || (clcp->clc_ifa == 0)) {
432: IFDEBUG(D_OUTPUT)
433: printf("clnp_output: route failed, errno %d\n", error);
434: printf("@clcp:\n");
435: dump_buf(clcp, sizeof (struct clnp_cache));
436: ENDDEBUG
437: goto bad;
438: }
439: clcp->clc_rt = isop->isop_route.ro_rt; /* XXX */
440: clcp->clc_ifp = clcp->clc_ifa->ia_ifp; /* XXX */
441:
442: IFDEBUG(D_OUTPUT)
443: printf("clnp_output: packet routed to %s\n",
444: clnp_iso_addrp(
445: &((struct sockaddr_iso *)clcp->clc_firsthop)->siso_addr));
446: ENDDEBUG
447:
448: /*
449: * If src address is not yet specified, use address of
450: * interface. NOTE: this will now update the laddr field in
451: * the isopcb. Is this desirable? RAH?
452: */
453: if (src->isoa_len == 0) {
454: src = &(clcp->clc_ifa->ia_addr.siso_addr);
455: IFDEBUG(D_OUTPUT)
456: printf("clnp_output: new src %s\n", clnp_iso_addrp(src));
457: ENDDEBUG
458: }
459:
460: /*
461: * Insert the source and destination address,
462: */
463: hoff = (caddr_t)clnp + sizeof(struct clnp_fixed);
464: CLNP_INSERT_ADDR(hoff, *dst);
465: CLNP_INSERT_ADDR(hoff, *src);
466:
467: /*
468: * Leave room for the segment part, if segmenting is selected
469: */
470: if (clnp->cnf_type & CNF_SEG_OK) {
471: clcp->clc_segoff = hoff - (caddr_t)clnp;
472: hoff += sizeof(struct clnp_segment);
473: }
474:
475: clnp->cnf_hdr_len = m->m_len = (u_char)(hoff - (caddr_t)clnp);
476: hdrlen = clnp->cnf_hdr_len;
477:
478: #ifdef DECBIT
479: /*
480: * Add the globally unique QOS (with room for congestion experienced
481: * bit). I can safely assume that this option is not in the options
482: * mbuf below because I checked that the option was not specified
483: * previously
484: */
485: if ((m->m_len + sizeof(qos_option)) < MLEN) {
486: bcopy((caddr_t)qos_option, hoff, sizeof(qos_option));
487: clnp->cnf_hdr_len += sizeof(qos_option);
488: hdrlen += sizeof(qos_option);
489: m->m_len += sizeof(qos_option);
490: }
491: #endif /* DECBIT */
492:
493: /*
494: * If an options mbuf is present, concatenate a copy to the hdr mbuf.
495: */
496: if (isop->isop_options) {
497: struct mbuf *opt_copy = m_copy(isop->isop_options, 0, (int)M_COPYALL);
498: if (opt_copy == NULL) {
499: error = ENOBUFS;
500: goto bad;
501: }
502: /* Link in place */
503: opt_copy->m_next = m->m_next;
504: m->m_next = opt_copy;
505:
506: /* update size of header */
507: clnp->cnf_hdr_len += opt_copy->m_len;
508: hdrlen += opt_copy->m_len;
509: }
510:
511: if (hdrlen > CLNP_HDR_MAX) {
512: error = EMSGSIZE;
513: goto bad;
514: }
515:
516: /*
517: * Now set up the cache entry in the pcb
518: */
519: if ((flags & CLNP_NOCACHE) == 0) {
520: if (clcp->clc_hdr = m_copy(m, 0, (int)clnp->cnf_hdr_len)) {
521: clcp->clc_dst = *dst;
522: clcp->clc_flags = flags;
523: clcp->clc_options = isop->isop_options;
524: }
525: }
526: }
527: /*
528: * If small enough for interface, send directly
529: * Fill in segmentation part of hdr if using the full protocol
530: */
531: total_len = clnp->cnf_hdr_len + datalen;
532: if (clnp->cnf_type & CNF_SEG_OK) {
533: struct clnp_segment seg_part; /* segment part of hdr */
534: seg_part.cng_id = htons(clnp_id++);
535: seg_part.cng_off = htons(0);
536: seg_part.cng_tot_len = htons(total_len);
537: (void) bcopy((caddr_t)&seg_part, (caddr_t) clnp + clcp->clc_segoff,
538: sizeof(seg_part));
539: }
540: if (total_len <= SN_MTU(clcp->clc_ifp, clcp->clc_rt)) {
541: HTOC(clnp->cnf_seglen_msb, clnp->cnf_seglen_lsb, total_len);
542: m->m_pkthdr.len = total_len;
543: /*
544: * Compute clnp checksum (on header only)
545: */
546: if (flags & CLNP_NO_CKSUM) {
547: HTOC(clnp->cnf_cksum_msb, clnp->cnf_cksum_lsb, 0);
548: } else {
549: iso_gen_csum(m, CLNP_CKSUM_OFF, (int)clnp->cnf_hdr_len);
550: }
551:
552: IFDEBUG(D_DUMPOUT)
553: struct mbuf *mdump = m;
554: printf("clnp_output: sending dg:\n");
555: while (mdump != NULL) {
556: dump_buf(mtod(mdump, caddr_t), mdump->m_len);
557: mdump = mdump->m_next;
558: }
559: ENDDEBUG
560:
561: error = SN_OUTPUT(clcp, m);
562: goto done;
563: } else {
564: /*
565: * Too large for interface; fragment if possible.
566: */
567: error = clnp_fragment(clcp->clc_ifp, m, clcp->clc_firsthop,
568: total_len, clcp->clc_segoff, flags, clcp->clc_rt);
569: goto done;
570: }
571: bad:
572: m_freem(m);
573: done:
574: if (error) {
575: clnp_stat.cns_sent--;
576: clnp_stat.cns_odropped++;
577: }
578: return (error);
579: }
580:
581: int clnp_ctloutput()
582: {
583: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.