![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clnp_input.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_input.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_input.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/if_types.h>
98: #include <net/route.h>
99:
100: #include <netiso/iso.h>
101: #include <netiso/iso_var.h>
102: #include <netiso/iso_snpac.h>
103: #include <netiso/clnp.h>
104: #include <netiso/clnl.h>
105: #include <netiso/esis.h>
106: #include <netinet/in_systm.h>
107: #include <netinet/ip.h>
108: #include <netinet/if_ether.h>
109: #include <netiso/eonvar.h>
110: #include <netiso/clnp_stat.h>
111: #include <netiso/argo_debug.h>
112:
113: #if ISO
114: u_char clnp_protox[ISOPROTO_MAX];
115: struct clnl_protosw clnl_protox[256];
116: int clnpqmaxlen = IFQ_MAXLEN; /* RAH? why is this a variable */
117: struct mbuf *clnp_data_ck();
118:
119: int clnp_input();
120:
121: int esis_input();
122:
123: #ifdef ISO_X25ESIS
124: int x25esis_input();
125: #endif /* ISO_X25ESIS */
126:
127: /*
128: * FUNCTION: clnp_init
129: *
130: * PURPOSE: clnp initialization. Fill in clnp switch tables.
131: *
132: * RETURNS: none
133: *
134: * SIDE EFFECTS: fills in clnp_protox table with correct offsets into
135: * the isosw table.
136: *
137: * NOTES:
138: */
139: clnp_init()
140: {
141: register struct protosw *pr;
142:
143: /*
144: * CLNP protox initialization
145: */
146: if ((pr = pffindproto(PF_ISO, ISOPROTO_RAW, SOCK_RAW)) == 0)
147: printf("clnl_init: no raw CLNP\n");
148: else
149: clnp_protox[ISOPROTO_RAW] = pr - isosw;
150:
151: if ((pr = pffindproto(PF_ISO, ISOPROTO_TP, SOCK_SEQPACKET)) == 0)
152: printf("clnl_init: no tp/clnp\n");
153: else
154: clnp_protox[ISOPROTO_TP] = pr - isosw;
155:
156: /*
157: * CLNL protox initialization
158: */
159: clnl_protox[ISO8473_CLNP].clnl_input = clnp_input;
160:
161: clnlintrq.ifq_maxlen = clnpqmaxlen;
162: }
163:
164: /*
165: * FUNCTION: clnlintr
166: *
167: * PURPOSE: Process a packet on the clnl input queue
168: *
169: * RETURNS: nothing.
170: *
171: * SIDE EFFECTS:
172: *
173: * NOTES:
174: */
175: clnlintr()
176: {
177: register struct mbuf *m; /* ptr to first mbuf of pkt */
178: register struct clnl_fixed *clnl; /* ptr to fixed part of clnl hdr */
179: int s; /* save and restore priority */
180: struct clnl_protosw *clnlsw;/* ptr to protocol switch */
181: struct snpa_hdr sh; /* subnetwork hdr */
182:
183: /*
184: * Get next datagram off clnl input queue
185: */
186: next:
187: s = splimp();
188: /* IF_DEQUEUESNPAHDR(&clnlintrq, m, sh);*/
189: IF_DEQUEUE(&clnlintrq, m);
190: splx(s);
191:
192:
193: if (m == 0) /* nothing to do */
194: return;
195: if ((m->m_flags & M_PKTHDR) == 0 || m->m_pkthdr.rcvif == 0) {
196: m_freem(m);
197: goto next;
198: } else {
199: register struct ifaddr *ifa;
200: for (ifa = m->m_pkthdr.rcvif->if_addrlist; ifa; ifa = ifa->ifa_next)
201: if (ifa->ifa_addr->sa_family == AF_ISO)
202: break;
203: if (ifa == 0) {
204: m_freem(m);
205: goto next;
206: }
207: }
208: bzero((caddr_t)&sh, sizeof(sh));
209: sh.snh_flags = m->m_flags & (M_MCAST|M_BCAST);
210: switch((sh.snh_ifp = m->m_pkthdr.rcvif)->if_type) {
211: extern int ether_output();
212: case IFT_EON:
213: bcopy(mtod(m, caddr_t), (caddr_t)sh.snh_dhost, sizeof(u_long));
214: bcopy(sizeof(u_long) + mtod(m, caddr_t),
215: (caddr_t)sh.snh_shost, sizeof(u_long));
216: sh.snh_dhost[4] = mtod(m, u_char *)[sizeof(struct ip) +
217: _offsetof(struct eon_hdr, eonh_class)];
218: m->m_data += EONIPLEN;
219: m->m_len -= EONIPLEN;
220: m->m_pkthdr.len -= EONIPLEN;
221: break;
222:
223: default:
224: if (sh.snh_ifp->if_output == ether_output) {
225: bcopy((caddr_t)(mtod(m, struct ether_header *)->ether_dhost),
226: (caddr_t)sh.snh_dhost, 2*sizeof(sh.snh_dhost));
227: m->m_data += sizeof (struct ether_header);
228: m->m_len -= sizeof (struct ether_header);
229: m->m_pkthdr.len -= sizeof (struct ether_header);
230: }
231: }
232: IFDEBUG(D_INPUT)
233: int i;
234: printf("clnlintr: src:");
235: for (i=0; i<6; i++)
236: printf("%x%c", sh.snh_shost[i] & 0xff, (i<5) ? ':' : ' ');
237: printf(" dst:");
238: for (i=0; i<6; i++)
239: printf("%x%c", sh.snh_dhost[i] & 0xff, (i<5) ? ':' : ' ');
240: printf("\n");
241: ENDDEBUG
242:
243: /*
244: * Get the fixed part of the clnl header into the first mbuf.
245: * Drop the packet if this fails.
246: * Do not call m_pullup if we have a cluster mbuf or the
247: * data is not there.
248: */
249: if ((IS_CLUSTER(m) || (m->m_len < sizeof(struct clnl_fixed))) &&
250: ((m = m_pullup(m, sizeof(struct clnl_fixed))) == 0)) {
251: INCSTAT(cns_toosmall); /* TODO: use clnl stats */
252: goto next; /* m_pullup discards mbuf */
253: }
254:
255: clnl = mtod(m, struct clnl_fixed *);
256:
257: /*
258: * Drop packet if the length of the header is not reasonable.
259: */
260: if ((clnl->cnf_hdr_len < CLNP_HDR_MIN) ||
261: (clnl->cnf_hdr_len > CLNP_HDR_MAX)) {
262: INCSTAT(cns_badhlen); /* TODO: use clnl stats */
263: m_freem(m);
264: goto next;
265: }
266:
267: /*
268: * If the header is not contained in this mbuf, make it so.
269: * Drop packet if this fails.
270: * Note: m_pullup will allocate a cluster mbuf if necessary
271: */
272: if (clnl->cnf_hdr_len > m->m_len) {
273: if ((m = m_pullup(m, (int)clnl->cnf_hdr_len)) == 0) {
274: INCSTAT(cns_badhlen); /* TODO: use clnl stats */
275: goto next; /* m_pullup discards mbuf */
276: }
277: clnl = mtod(m, struct clnl_fixed *);
278: }
279:
280: clnlsw = &clnl_protox[clnl->cnf_proto_id];
281:
282:
283: if (clnlsw->clnl_input)
284: (*clnlsw->clnl_input) (m, &sh);
285: else
286: m_freem(m);
287:
288: goto next;
289: }
290:
291: /*
292: * FUNCTION: clnp_input
293: *
294: * PURPOSE: process an incoming clnp packet
295: *
296: * RETURNS: nothing
297: *
298: * SIDE EFFECTS: increments fields of clnp_stat structure.
299: *
300: * NOTES:
301: * TODO: I would like to make seg_part a pointer into the mbuf, but
302: * will it be correctly aligned?
303: */
304: clnp_input(m, shp)
305: struct mbuf *m; /* ptr to first mbuf of pkt */
306: struct snpa_hdr *shp; /* subnetwork header */
307: {
308: register struct clnp_fixed *clnp; /* ptr to fixed part of header */
309: struct sockaddr_iso source; /* source address of pkt */
310: struct sockaddr_iso target; /* destination address of pkt */
311: #define src source.siso_addr
312: #define dst target.siso_addr
313: caddr_t hoff; /* current offset in packet */
314: caddr_t hend; /* address of end of header info */
315: struct clnp_segment seg_part; /* segment part of hdr */
316: int seg_off=0; /* offset of segment part of hdr */
317: int seg_len;/* length of packet data&hdr in bytes */
318: struct clnp_optidx oidx, *oidxp = NULL; /* option index */
319: extern int iso_systype; /* used by ESIS config resp */
320: extern struct sockaddr_iso blank_siso; /* used for initializing */
321: int need_afrin = 0;
322: /* true if congestion experienced */
323: /* which means you need afrin nose */
324: /* spray. How clever! */
325:
326: IFDEBUG(D_INPUT)
327: printf(
328: "clnp_input: proccessing dg; First mbuf m_len %d, m_type x%x, %s\n",
329: m->m_len, m->m_type, IS_CLUSTER(m) ? "cluster" : "normal");
330: ENDDEBUG
331: need_afrin = 0;
332:
333: /*
334: * If no iso addresses have been set, there is nothing
335: * to do with the packet.
336: */
337: if (iso_ifaddr == NULL) {
338: clnp_discard(m, ADDR_DESTUNREACH);
339: return;
340: }
341:
342: INCSTAT(cns_total);
343: clnp = mtod(m, struct clnp_fixed *);
344:
345: IFDEBUG(D_DUMPIN)
346: struct mbuf *mhead;
347: int total_len = 0;
348: printf("clnp_input: clnp header:\n");
349: dump_buf(mtod(m, caddr_t), clnp->cnf_hdr_len);
350: printf("clnp_input: mbuf chain:\n");
351: for (mhead = m; mhead != NULL; mhead=mhead->m_next) {
352: printf("m x%x, len %d\n", mhead, mhead->m_len);
353: total_len += mhead->m_len;
354: }
355: printf("clnp_input: total length of mbuf chain %d:\n", total_len);
356: ENDDEBUG
357:
358: /*
359: * Compute checksum (if necessary) and drop packet if
360: * checksum does not match
361: */
362: if (CKSUM_REQUIRED(clnp) && iso_check_csum(m, (int)clnp->cnf_hdr_len)) {
363: INCSTAT(cns_badcsum);
364: clnp_discard(m, GEN_BADCSUM);
365: return;
366: }
367:
368: if (clnp->cnf_vers != ISO8473_V1) {
369: INCSTAT(cns_badvers);
370: clnp_discard(m, DISC_UNSUPPVERS);
371: return;
372: }
373:
374:
375: /* check mbuf data length: clnp_data_ck will free mbuf upon error */
376: CTOH(clnp->cnf_seglen_msb, clnp->cnf_seglen_lsb, seg_len);
377: if ((m = clnp_data_ck(m, seg_len)) == 0)
378: return;
379:
380: clnp = mtod(m, struct clnp_fixed *);
381: hend = (caddr_t)clnp + clnp->cnf_hdr_len;
382:
383: /*
384: * extract the source and destination address
385: * drop packet on failure
386: */
387: source = target = blank_siso;
388:
389: hoff = (caddr_t)clnp + sizeof(struct clnp_fixed);
390: CLNP_EXTRACT_ADDR(dst, hoff, hend);
391: if (hoff == (caddr_t)0) {
392: INCSTAT(cns_badaddr);
393: clnp_discard(m, GEN_INCOMPLETE);
394: return;
395: }
396: CLNP_EXTRACT_ADDR(src, hoff, hend);
397: if (hoff == (caddr_t)0) {
398: INCSTAT(cns_badaddr);
399: clnp_discard(m, GEN_INCOMPLETE);
400: return;
401: }
402:
403: IFDEBUG(D_INPUT)
404: printf("clnp_input: from %s", clnp_iso_addrp(&src));
405: printf(" to %s\n", clnp_iso_addrp(&dst));
406: ENDDEBUG
407:
408: /*
409: * extract the segmentation information, if it is present.
410: * drop packet on failure
411: */
412: if (((clnp->cnf_type & CNF_TYPE) != CLNP_ER) &&
413: (clnp->cnf_type & CNF_SEG_OK)) {
414: if (hoff + sizeof(struct clnp_segment) > hend) {
415: INCSTAT(cns_noseg);
416: clnp_discard(m, GEN_INCOMPLETE);
417: return;
418: } else {
419: (void) bcopy(hoff, (caddr_t)&seg_part, sizeof(struct clnp_segment));
420: /* make sure segmentation fields are in host order */
421: seg_part.cng_id = ntohs(seg_part.cng_id);
422: seg_part.cng_off = ntohs(seg_part.cng_off);
423: seg_part.cng_tot_len = ntohs(seg_part.cng_tot_len);
424: seg_off = hoff - (caddr_t)clnp;
425: hoff += sizeof(struct clnp_segment);
426: }
427: }
428:
429: /*
430: * process options if present. If clnp_opt_sanity returns
431: * false (indicating an error was found in the options) or
432: * an unsupported option was found
433: * then drop packet and emit an ER.
434: */
435: if (hoff < hend) {
436: int errcode;
437:
438: oidxp = &oidx;
439: errcode = clnp_opt_sanity(m, hoff, hend-hoff, oidxp);
440:
441: /* we do not support security */
442: if ((errcode == 0) && (oidxp->cni_securep))
443: errcode = DISC_UNSUPPSECURE;
444:
445: /* the er option is valid with ER pdus only */
446: if ((errcode == 0) && (oidxp->cni_er_reason != ER_INVALREAS) &&
447: ((clnp->cnf_type & CNF_TYPE) != CLNP_ER))
448: errcode = DISC_UNSUPPOPT;
449:
450: #ifdef DECBIT
451: /* check if the congestion experienced bit is set */
452: if (oidxp->cni_qos_formatp) {
453: caddr_t qosp = CLNP_OFFTOOPT(m, oidxp->cni_qos_formatp);
454: u_char qos = *qosp;
455:
456: need_afrin = ((qos & (CLNPOVAL_GLOBAL|CLNPOVAL_CONGESTED)) ==
457: (CLNPOVAL_GLOBAL|CLNPOVAL_CONGESTED));
458: if (need_afrin)
459: INCSTAT(cns_congest_rcvd);
460: }
461: #endif /* DECBIT */
462:
463: if (errcode != 0) {
464: clnp_discard(m, (char)errcode);
465: IFDEBUG(D_INPUT)
466: printf("clnp_input: dropped (err x%x) due to bad options\n",
467: errcode);
468: ENDDEBUG
469: return;
470: }
471: }
472:
473: /*
474: * check if this packet is for us. if not, then forward
475: */
476: if (clnp_ours(&dst) == 0) {
477: IFDEBUG(D_INPUT)
478: printf("clnp_input: forwarding packet not for us\n");
479: ENDDEBUG
480: clnp_forward(m, seg_len, &dst, oidxp, seg_off, shp);
481: return;
482: }
483:
484: /*
485: * ESIS Configuration Response Function
486: *
487: * If the packet received was sent to the multicast address
488: * all end systems, then send an esh to the source
489: */
490: if ((shp->snh_flags & M_MCAST) && (iso_systype == SNPA_ES)) {
491: extern short esis_holding_time;
492:
493: esis_shoutput(shp->snh_ifp, ESIS_ESH, esis_holding_time,
494: shp->snh_shost, 6, &dst);
495: }
496:
497: /*
498: * If this is a fragment, then try to reassemble it. If clnp_reass
499: * returns non NULL, the packet has been reassembled, and should
500: * be give to TP. Otherwise the fragment has been delt with
501: * by the reassembly code (either stored or deleted). In either case
502: * we should have nothing more to do with it.
503: */
504: if (((clnp->cnf_type & CNF_TYPE) != CLNP_ER) &&
505: (clnp->cnf_type & CNF_SEG_OK) &&
506: (seg_len != seg_part.cng_tot_len)) {
507: struct mbuf *m0;
508:
509: if ((m0 = clnp_reass(m, &src, &dst, &seg_part)) != NULL) {
510: m = m0;
511: clnp = mtod(m, struct clnp_fixed *);
512: INCSTAT(cns_reassembled);
513: } else {
514: return;
515: }
516: }
517:
518: /*
519: * give the packet to the higher layer
520: *
521: * Note: the total length of packet
522: * is the total length field of the segmentation part,
523: * or, if absent, the segment length field of the
524: * header.
525: */
526: INCSTAT(cns_delivered);
527: switch (clnp->cnf_type & CNF_TYPE) {
528: case CLNP_ER:
529: /*
530: * This ER must have the er option.
531: * If the option is not present, discard datagram.
532: */
533: if (oidxp == NULL || oidxp->cni_er_reason == ER_INVALREAS) {
534: clnp_discard(m, GEN_HDRSYNTAX);
535: } else {
536: clnp_er_input(m, &src, oidxp->cni_er_reason);
537: }
538: break;
539:
540: case CLNP_DT:
541: (*isosw[clnp_protox[ISOPROTO_TP]].pr_input)(m, &source, &target,
542: clnp->cnf_hdr_len, need_afrin);
543: break;
544:
545: case CLNP_RAW:
546: case CLNP_ECR:
547: IFDEBUG(D_INPUT)
548: printf("clnp_input: raw input of %d bytes\n",
549: clnp->cnf_type & CNF_SEG_OK ? seg_part.cng_tot_len : seg_len);
550: ENDDEBUG
551: (*isosw[clnp_protox[ISOPROTO_RAW]].pr_input)(m, &source, &target,
552: clnp->cnf_hdr_len);
553: break;
554:
555: case CLNP_EC:
556: IFDEBUG(D_INPUT)
557: printf("clnp_input: echoing packet\n");
558: ENDDEBUG
559: (void)clnp_echoreply(m,
560: (clnp->cnf_type & CNF_SEG_OK ? (int)seg_part.cng_tot_len : seg_len),
561: &source, &target, oidxp);
562: break;
563:
564: default:
565: printf("clnp_input: unknown clnp pkt type %d\n",
566: clnp->cnf_type & CNF_TYPE);
567: clnp_stat.cns_delivered--;
568: clnp_stat.cns_noproto++;
569: clnp_discard(m, GEN_HDRSYNTAX);
570: break;
571: }
572: }
573: #endif /* ISO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.