![[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 [Net/2] / Net2 / netiso|
Return to clnp_input.c CVS log | Up to [Net/2] / Net2 / netiso |
1.1 root 1: /*-
2: * Copyright (c) 1991 The Regents of the University of California.
3: * All rights reserved.
4: *
5: * Redistribution and use in source and binary forms, with or without
6: * modification, are permitted provided that the following conditions
7: * are met:
8: * 1. Redistributions of source code must retain the above copyright
9: * notice, this list of conditions and the following disclaimer.
10: * 2. Redistributions in binary form must reproduce the above copyright
11: * notice, this list of conditions and the following disclaimer in the
12: * documentation and/or other materials provided with the distribution.
13: * 3. All advertising materials mentioning features or use of this software
14: * must display the following acknowledgement:
15: * This product includes software developed by the University of
16: * California, Berkeley and its contributors.
17: * 4. Neither the name of the University nor the names of its contributors
18: * may be used to endorse or promote products derived from this software
19: * without specific prior written permission.
20: *
21: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
22: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
23: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
24: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
25: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
26: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
27: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
28: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
30: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31: * SUCH DAMAGE.
32: *
33: * @(#)clnp_input.c 7.13 (Berkeley) 5/6/91
34: */
35:
36: /***********************************************************
37: Copyright IBM Corporation 1987
38:
39: All Rights Reserved
40:
41: Permission to use, copy, modify, and distribute this software and its
42: documentation for any purpose and without fee is hereby granted,
43: provided that the above copyright notice appear in all copies and that
44: both that copyright notice and this permission notice appear in
45: supporting documentation, and that the name of IBM not be
46: used in advertising or publicity pertaining to distribution of the
47: software without specific, written prior permission.
48:
49: IBM DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
50: ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
51: IBM BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
52: ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
53: WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
54: ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
55: SOFTWARE.
56:
57: ******************************************************************/
58:
59: /*
60: * ARGO Project, Computer Sciences Dept., University of Wisconsin - Madison
61: */
62: /* $Header: /var/src/sys/netiso/RCS/clnp_input.c,v 5.1 89/02/09 16:20:32 hagens Exp $ */
63: /* $Source: /var/src/sys/netiso/RCS/clnp_input.c,v $ */
64:
65: #include "types.h"
66: #include "param.h"
67: #include "mbuf.h"
68: #include "domain.h"
69: #include "protosw.h"
70: #include "socket.h"
71: #include "socketvar.h"
72: #include "errno.h"
73: #include "time.h"
74:
75: #include "../net/if.h"
76: #include "../net/if_types.h"
77: #include "../net/route.h"
78:
79: #include "iso.h"
80: #include "iso_var.h"
81: #include "iso_snpac.h"
82: #include "clnp.h"
83: #include "clnl.h"
84: #include "esis.h"
85: #include "../netinet/in_systm.h"
86: #include "../netinet/ip.h"
87: #include "../netinet/if_ether.h"
88: #include "eonvar.h"
89: #include "clnp_stat.h"
90: #include "argo_debug.h"
91:
92: #ifdef ISO
93: u_char clnp_protox[ISOPROTO_MAX];
94: struct clnl_protosw clnl_protox[256];
95: int clnpqmaxlen = IFQ_MAXLEN; /* RAH? why is this a variable */
96: struct mbuf *clnp_data_ck();
97:
98: int clnp_input();
99:
100: int esis_input();
101:
102: #ifdef ISO_X25ESIS
103: int x25esis_input();
104: #endif ISO_X25ESIS
105:
106: /*
107: * FUNCTION: clnp_init
108: *
109: * PURPOSE: clnp initialization. Fill in clnp switch tables.
110: *
111: * RETURNS: none
112: *
113: * SIDE EFFECTS: fills in clnp_protox table with correct offsets into
114: * the isosw table.
115: *
116: * NOTES:
117: */
118: clnp_init()
119: {
120: register struct protosw *pr;
121:
122: /*
123: * CLNP protox initialization
124: */
125: if ((pr = pffindproto(PF_ISO, ISOPROTO_RAW, SOCK_RAW)) == 0)
126: printf("clnl_init: no raw CLNP\n");
127: else
128: clnp_protox[ISOPROTO_RAW] = pr - isosw;
129:
130: if ((pr = pffindproto(PF_ISO, ISOPROTO_TP, SOCK_SEQPACKET)) == 0)
131: printf("clnl_init: no tp/clnp\n");
132: else
133: clnp_protox[ISOPROTO_TP] = pr - isosw;
134:
135: /*
136: * CLNL protox initialization
137: */
138: clnl_protox[ISO8473_CLNP].clnl_input = clnp_input;
139:
140: clnlintrq.ifq_maxlen = clnpqmaxlen;
141: }
142:
143: /*
144: * FUNCTION: clnlintr
145: *
146: * PURPOSE: Process a packet on the clnl input queue
147: *
148: * RETURNS: nothing.
149: *
150: * SIDE EFFECTS:
151: *
152: * NOTES:
153: */
154: clnlintr()
155: {
156: register struct mbuf *m; /* ptr to first mbuf of pkt */
157: register struct clnl_fixed *clnl; /* ptr to fixed part of clnl hdr */
158: int s; /* save and restore priority */
159: struct clnl_protosw *clnlsw;/* ptr to protocol switch */
160: struct snpa_hdr sh; /* subnetwork hdr */
161:
162: /*
163: * Get next datagram off clnl input queue
164: */
165: next:
166: s = splimp();
167: /* IF_DEQUEUESNPAHDR(&clnlintrq, m, sh);*/
168: IF_DEQUEUE(&clnlintrq, m);
169: splx(s);
170:
171:
172: if (m == 0) /* nothing to do */
173: return;
174: if ((m->m_flags & M_PKTHDR) == 0 || m->m_pkthdr.rcvif == 0) {
175: m_freem(m);
176: goto next;
177: } else {
178: register struct ifaddr *ifa;
179: for (ifa = m->m_pkthdr.rcvif->if_addrlist; ifa; ifa = ifa->ifa_next)
180: if (ifa->ifa_addr->sa_family == AF_ISO)
181: break;
182: if (ifa == 0) {
183: m_freem(m);
184: goto next;
185: }
186: }
187: bzero((caddr_t)&sh, sizeof(sh));
188: sh.snh_flags = m->m_flags & (M_MCAST|M_BCAST);
189: switch((sh.snh_ifp = m->m_pkthdr.rcvif)->if_type) {
190: extern int ether_output();
191: case IFT_EON:
192: bcopy(mtod(m, caddr_t), (caddr_t)sh.snh_dhost, sizeof(u_long));
193: bcopy(sizeof(u_long) + mtod(m, caddr_t),
194: (caddr_t)sh.snh_shost, sizeof(u_long));
195: sh.snh_dhost[4] = mtod(m, u_char *)[sizeof(struct ip) +
196: _offsetof(struct eon_hdr, eonh_class)];
197: m->m_data += EONIPLEN;
198: m->m_len -= EONIPLEN;
199: m->m_pkthdr.len -= EONIPLEN;
200: break;
201:
202: default:
203: if (sh.snh_ifp->if_output == ether_output) {
204: bcopy((caddr_t)(mtod(m, struct ether_header *)->ether_dhost),
205: (caddr_t)sh.snh_dhost, 2*sizeof(sh.snh_dhost));
206: m->m_data += sizeof (struct ether_header);
207: m->m_len -= sizeof (struct ether_header);
208: m->m_pkthdr.len -= sizeof (struct ether_header);
209: }
210: }
211: IFDEBUG(D_INPUT)
212: int i;
213: printf("clnlintr: src:");
214: for (i=0; i<6; i++)
215: printf("%x%c", sh.snh_shost[i] & 0xff, (i<5) ? ':' : ' ');
216: printf(" dst:");
217: for (i=0; i<6; i++)
218: printf("%x%c", sh.snh_dhost[i] & 0xff, (i<5) ? ':' : ' ');
219: printf("\n");
220: ENDDEBUG
221:
222: /*
223: * Get the fixed part of the clnl header into the first mbuf.
224: * Drop the packet if this fails.
225: * Do not call m_pullup if we have a cluster mbuf or the
226: * data is not there.
227: */
228: if ((IS_CLUSTER(m) || (m->m_len < sizeof(struct clnl_fixed))) &&
229: ((m = m_pullup(m, sizeof(struct clnl_fixed))) == 0)) {
230: INCSTAT(cns_toosmall); /* TODO: use clnl stats */
231: goto next; /* m_pullup discards mbuf */
232: }
233:
234: clnl = mtod(m, struct clnl_fixed *);
235:
236: /*
237: * Drop packet if the length of the header is not reasonable.
238: */
239: if ((clnl->cnf_hdr_len < CLNP_HDR_MIN) ||
240: (clnl->cnf_hdr_len > CLNP_HDR_MAX)) {
241: INCSTAT(cns_badhlen); /* TODO: use clnl stats */
242: m_freem(m);
243: goto next;
244: }
245:
246: /*
247: * If the header is not contained in this mbuf, make it so.
248: * Drop packet if this fails.
249: * Note: m_pullup will allocate a cluster mbuf if necessary
250: */
251: if (clnl->cnf_hdr_len > m->m_len) {
252: if ((m = m_pullup(m, (int)clnl->cnf_hdr_len)) == 0) {
253: INCSTAT(cns_badhlen); /* TODO: use clnl stats */
254: goto next; /* m_pullup discards mbuf */
255: }
256: clnl = mtod(m, struct clnl_fixed *);
257: }
258:
259: clnlsw = &clnl_protox[clnl->cnf_proto_id];
260:
261:
262: if (clnlsw->clnl_input)
263: (*clnlsw->clnl_input) (m, &sh);
264: else
265: m_freem(m);
266:
267: goto next;
268: }
269:
270: /*
271: * FUNCTION: clnp_input
272: *
273: * PURPOSE: process an incoming clnp packet
274: *
275: * RETURNS: nothing
276: *
277: * SIDE EFFECTS: increments fields of clnp_stat structure.
278: *
279: * NOTES:
280: * TODO: I would like to make seg_part a pointer into the mbuf, but
281: * will it be correctly aligned?
282: */
283: clnp_input(m, shp)
284: struct mbuf *m; /* ptr to first mbuf of pkt */
285: struct snpa_hdr *shp; /* subnetwork header */
286: {
287: register struct clnp_fixed *clnp; /* ptr to fixed part of header */
288: struct sockaddr_iso source; /* source address of pkt */
289: struct sockaddr_iso target; /* destination address of pkt */
290: #define src source.siso_addr
291: #define dst target.siso_addr
292: caddr_t hoff; /* current offset in packet */
293: caddr_t hend; /* address of end of header info */
294: struct clnp_segment seg_part; /* segment part of hdr */
295: int seg_off=0; /* offset of segment part of hdr */
296: int seg_len;/* length of packet data&hdr in bytes */
297: struct clnp_optidx oidx, *oidxp = NULL; /* option index */
298: extern int iso_systype; /* used by ESIS config resp */
299: extern struct sockaddr_iso blank_siso; /* used for initializing */
300: int need_afrin = 0;
301: /* true if congestion experienced */
302: /* which means you need afrin nose */
303: /* spray. How clever! */
304:
305: IFDEBUG(D_INPUT)
306: printf(
307: "clnp_input: proccessing dg; First mbuf m_len %d, m_type x%x, %s\n",
308: m->m_len, m->m_type, IS_CLUSTER(m) ? "cluster" : "normal");
309: ENDDEBUG
310: need_afrin = 0;
311:
312: /*
313: * If no iso addresses have been set, there is nothing
314: * to do with the packet.
315: */
316: if (iso_ifaddr == NULL) {
317: clnp_discard(m, ADDR_DESTUNREACH);
318: return;
319: }
320:
321: INCSTAT(cns_total);
322: clnp = mtod(m, struct clnp_fixed *);
323:
324: IFDEBUG(D_DUMPIN)
325: struct mbuf *mhead;
326: int total_len = 0;
327: printf("clnp_input: clnp header:\n");
328: dump_buf(mtod(m, caddr_t), clnp->cnf_hdr_len);
329: printf("clnp_input: mbuf chain:\n");
330: for (mhead = m; mhead != NULL; mhead=mhead->m_next) {
331: printf("m x%x, len %d\n", mhead, mhead->m_len);
332: total_len += mhead->m_len;
333: }
334: printf("clnp_input: total length of mbuf chain %d:\n", total_len);
335: ENDDEBUG
336:
337: /*
338: * Compute checksum (if necessary) and drop packet if
339: * checksum does not match
340: */
341: if (CKSUM_REQUIRED(clnp) && iso_check_csum(m, (int)clnp->cnf_hdr_len)) {
342: INCSTAT(cns_badcsum);
343: clnp_discard(m, GEN_BADCSUM);
344: return;
345: }
346:
347: if (clnp->cnf_vers != ISO8473_V1) {
348: INCSTAT(cns_badvers);
349: clnp_discard(m, DISC_UNSUPPVERS);
350: return;
351: }
352:
353:
354: /* check mbuf data length: clnp_data_ck will free mbuf upon error */
355: CTOH(clnp->cnf_seglen_msb, clnp->cnf_seglen_lsb, seg_len);
356: if ((m = clnp_data_ck(m, seg_len)) == 0)
357: return;
358:
359: clnp = mtod(m, struct clnp_fixed *);
360: hend = (caddr_t)clnp + clnp->cnf_hdr_len;
361:
362: /*
363: * extract the source and destination address
364: * drop packet on failure
365: */
366: source = target = blank_siso;
367:
368: hoff = (caddr_t)clnp + sizeof(struct clnp_fixed);
369: CLNP_EXTRACT_ADDR(dst, hoff, hend);
370: if (hoff == (caddr_t)0) {
371: INCSTAT(cns_badaddr);
372: clnp_discard(m, GEN_INCOMPLETE);
373: return;
374: }
375: CLNP_EXTRACT_ADDR(src, hoff, hend);
376: if (hoff == (caddr_t)0) {
377: INCSTAT(cns_badaddr);
378: clnp_discard(m, GEN_INCOMPLETE);
379: return;
380: }
381:
382: IFDEBUG(D_INPUT)
383: printf("clnp_input: from %s", clnp_iso_addrp(&src));
384: printf(" to %s\n", clnp_iso_addrp(&dst));
385: ENDDEBUG
386:
387: /*
388: * extract the segmentation information, if it is present.
389: * drop packet on failure
390: */
391: if (((clnp->cnf_type & CNF_TYPE) != CLNP_ER) &&
392: (clnp->cnf_type & CNF_SEG_OK)) {
393: if (hoff + sizeof(struct clnp_segment) > hend) {
394: INCSTAT(cns_noseg);
395: clnp_discard(m, GEN_INCOMPLETE);
396: return;
397: } else {
398: (void) bcopy(hoff, (caddr_t)&seg_part, sizeof(struct clnp_segment));
399: /* make sure segmentation fields are in host order */
400: seg_part.cng_id = ntohs(seg_part.cng_id);
401: seg_part.cng_off = ntohs(seg_part.cng_off);
402: seg_part.cng_tot_len = ntohs(seg_part.cng_tot_len);
403: seg_off = hoff - (caddr_t)clnp;
404: hoff += sizeof(struct clnp_segment);
405: }
406: }
407:
408: /*
409: * process options if present. If clnp_opt_sanity returns
410: * false (indicating an error was found in the options) or
411: * an unsupported option was found
412: * then drop packet and emit an ER.
413: */
414: if (hoff < hend) {
415: int errcode;
416:
417: oidxp = &oidx;
418: errcode = clnp_opt_sanity(m, hoff, hend-hoff, oidxp);
419:
420: /* we do not support security */
421: if ((errcode == 0) && (oidxp->cni_securep))
422: errcode = DISC_UNSUPPSECURE;
423:
424: /* the er option is valid with ER pdus only */
425: if ((errcode == 0) && (oidxp->cni_er_reason != ER_INVALREAS) &&
426: ((clnp->cnf_type & CNF_TYPE) != CLNP_ER))
427: errcode = DISC_UNSUPPOPT;
428:
429: #ifdef DECBIT
430: /* check if the congestion experienced bit is set */
431: if (oidxp->cni_qos_formatp) {
432: caddr_t qosp = CLNP_OFFTOOPT(m, oidxp->cni_qos_formatp);
433: u_char qos = *qosp;
434:
435: need_afrin = ((qos & (CLNPOVAL_GLOBAL|CLNPOVAL_CONGESTED)) ==
436: (CLNPOVAL_GLOBAL|CLNPOVAL_CONGESTED));
437: if (need_afrin)
438: INCSTAT(cns_congest_rcvd);
439: }
440: #endif DECBIT
441:
442: if (errcode != 0) {
443: clnp_discard(m, (char)errcode);
444: IFDEBUG(D_INPUT)
445: printf("clnp_input: dropped (err x%x) due to bad options\n",
446: errcode);
447: ENDDEBUG
448: return;
449: }
450: }
451:
452: /*
453: * check if this packet is for us. if not, then forward
454: */
455: if (clnp_ours(&dst) == 0) {
456: IFDEBUG(D_INPUT)
457: printf("clnp_input: forwarding packet not for us\n");
458: ENDDEBUG
459: clnp_forward(m, seg_len, &dst, oidxp, seg_off, shp);
460: return;
461: }
462:
463: /*
464: * ESIS Configuration Response Function
465: *
466: * If the packet received was sent to the multicast address
467: * all end systems, then send an esh to the source
468: */
469: if ((shp->snh_flags & M_MCAST) && (iso_systype == SNPA_ES)) {
470: extern short esis_holding_time;
471:
472: esis_shoutput(shp->snh_ifp, ESIS_ESH, esis_holding_time,
473: shp->snh_shost, 6, &dst);
474: }
475:
476: /*
477: * If this is a fragment, then try to reassemble it. If clnp_reass
478: * returns non NULL, the packet has been reassembled, and should
479: * be give to TP. Otherwise the fragment has been delt with
480: * by the reassembly code (either stored or deleted). In either case
481: * we should have nothing more to do with it.
482: */
483: if (((clnp->cnf_type & CNF_TYPE) != CLNP_ER) &&
484: (clnp->cnf_type & CNF_SEG_OK) &&
485: (seg_len != seg_part.cng_tot_len)) {
486: struct mbuf *m0;
487:
488: if ((m0 = clnp_reass(m, &src, &dst, &seg_part)) != NULL) {
489: m = m0;
490: clnp = mtod(m, struct clnp_fixed *);
491: INCSTAT(cns_reassembled);
492: } else {
493: return;
494: }
495: }
496:
497: /*
498: * give the packet to the higher layer
499: *
500: * Note: the total length of packet
501: * is the total length field of the segmentation part,
502: * or, if absent, the segment length field of the
503: * header.
504: */
505: INCSTAT(cns_delivered);
506: switch (clnp->cnf_type & CNF_TYPE) {
507: case CLNP_ER:
508: /*
509: * This ER must have the er option.
510: * If the option is not present, discard datagram.
511: */
512: if (oidxp == NULL || oidxp->cni_er_reason == ER_INVALREAS) {
513: clnp_discard(m, GEN_HDRSYNTAX);
514: } else {
515: clnp_er_input(m, &src, oidxp->cni_er_reason);
516: }
517: break;
518:
519: case CLNP_DT:
520: (*isosw[clnp_protox[ISOPROTO_TP]].pr_input)(m, &source, &target,
521: clnp->cnf_hdr_len, need_afrin);
522: break;
523:
524: case CLNP_RAW:
525: case CLNP_ECR:
526: IFDEBUG(D_INPUT)
527: printf("clnp_input: raw input of %d bytes\n",
528: clnp->cnf_type & CNF_SEG_OK ? seg_part.cng_tot_len : seg_len);
529: ENDDEBUG
530: (*isosw[clnp_protox[ISOPROTO_RAW]].pr_input)(m, &source, &target,
531: clnp->cnf_hdr_len);
532: break;
533:
534: case CLNP_EC:
535: IFDEBUG(D_INPUT)
536: printf("clnp_input: echoing packet\n");
537: ENDDEBUG
538: /*
539: * Switch the source and destination address,
540: */
541: hoff = (caddr_t)clnp + sizeof(struct clnp_fixed);
542: CLNP_INSERT_ADDR(hoff, src);
543: CLNP_INSERT_ADDR(hoff, dst);
544: clnp->cnf_type &= ~CNF_TYPE;
545: clnp->cnf_type |= CLNP_ECR;
546:
547: /*
548: * Forward back to sender
549: */
550: clnp_forward(m, (int)
551: (clnp->cnf_type & CNF_SEG_OK ? seg_part.cng_tot_len : seg_len),
552: &src, oidxp, seg_off, 0);
553: break;
554:
555: default:
556: printf("clnp_input: unknown clnp pkt type %d\n",
557: clnp->cnf_type & CNF_TYPE);
558: clnp_stat.cns_delivered--;
559: clnp_stat.cns_noproto++;
560: clnp_discard(m, GEN_HDRSYNTAX);
561: break;
562: }
563: }
564: #endif ISO
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.