![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to clnp_options.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_options.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_options.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: #if ISO
88:
89: #include <sys/param.h>
90: #include <sys/mbuf.h>
91: #include <sys/domain.h>
92: #include <sys/protosw.h>
93: #include <sys/socket.h>
94: #include <sys/socketvar.h>
95: #include <sys/errno.h>
96:
97: #include <net/if.h>
98: #include <net/route.h>
99:
100: #include <netiso/iso.h>
101: #include <netiso/clnp.h>
102: #include <netiso/clnp_stat.h>
103: #include <netiso/argo_debug.h>
104:
105: /*
106: * FUNCTION: clnp_update_srcrt
107: *
108: * PURPOSE: Process src rt option accompanying a clnp datagram.
109: * - bump src route ptr if src routing and
110: * we appear current in src route list.
111: *
112: * RETURNS: none
113: *
114: * SIDE EFFECTS:
115: *
116: * NOTES: If source routing has been terminated, do nothing.
117: */
118: clnp_update_srcrt(options, oidx)
119: struct mbuf *options; /* ptr to options mbuf */
120: struct clnp_optidx *oidx; /* ptr to option index */
121: {
122: u_char len; /* length of current address */
123: struct iso_addr isoa; /* copy current address into here */
124:
125: if (CLNPSRCRT_TERM(oidx, options)) {
126: IFDEBUG(D_OPTIONS)
127: printf("clnp_update_srcrt: src rt terminated\n");
128: ENDDEBUG
129: return;
130: }
131:
132: len = CLNPSRCRT_CLEN(oidx, options);
133: bcopy(CLNPSRCRT_CADDR(oidx, options), (caddr_t)&isoa, len);
134: isoa.isoa_len = len;
135:
136: IFDEBUG(D_OPTIONS)
137: printf("clnp_update_srcrt: current src rt: %s\n",
138: clnp_iso_addrp(&isoa));
139: ENDDEBUG
140:
141: if (clnp_ours(&isoa)) {
142: IFDEBUG(D_OPTIONS)
143: printf("clnp_update_srcrt: updating src rt\n");
144: ENDDEBUG
145:
146: /* update pointer to next src route */
147: len++; /* count length byte too! */
148: CLNPSRCRT_OFF(oidx, options) += len;
149: }
150: }
151:
152: /*
153: * FUNCTION: clnp_dooptions
154: *
155: * PURPOSE: Process options accompanying a clnp datagram.
156: * Processing includes
157: * - log our address if recording route
158: *
159: * RETURNS: none
160: *
161: * SIDE EFFECTS:
162: *
163: * NOTES:
164: */
165: clnp_dooptions(options, oidx, ifp, isoa)
166: struct mbuf *options; /* ptr to options mbuf */
167: struct clnp_optidx *oidx; /* ptr to option index */
168: struct ifnet *ifp; /* ptr to interface pkt is leaving on */
169: struct iso_addr *isoa; /* ptr to our address for this ifp */
170: {
171: /*
172: * If record route is specified, move all
173: * existing records over, and insert the address of
174: * interface passed
175: */
176: if (oidx->cni_recrtp) {
177: char *opt; /* ptr to beginning of recrt option */
178: u_char off; /* offset from opt of first free byte */
179: char *rec_start; /* beginning of new rt recorded */
180:
181: opt = CLNP_OFFTOOPT(options, oidx->cni_recrtp);
182: off = *(opt + 1);
183: rec_start = opt + off - 1;
184:
185: IFDEBUG(D_OPTIONS)
186: printf("clnp_dooptions: record route: option x%x for %d bytes\n",
187: opt, oidx->cni_recrt_len);
188: printf("\tfree slot offset x%x\n", off);
189: printf("clnp_dooptions: recording %s\n", clnp_iso_addrp(isoa));
190: printf("clnp_dooptions: option dump:\n");
191: dump_buf(opt, oidx->cni_recrt_len);
192: ENDDEBUG
193:
194: /* proceed only if recording has not been terminated */
195: if (off != 0xff) {
196: int new_addrlen = isoa->isoa_len + 1;
197: /*
198: * if there is insufficient room to store the next address,
199: * then terminate recording. Plus 1 on isoa_len is for the
200: * length byte itself
201: */
202: if (oidx->cni_recrt_len - (off - 1) < new_addrlen) {
203: *(opt + 1) = 0xff; /* terminate recording */
204: } else {
205: IFDEBUG(D_OPTIONS)
206: printf("clnp_dooptions: new addr at x%x for %d\n",
207: rec_start, new_addrlen);
208: ENDDEBUG
209:
210: bcopy((caddr_t)isoa, rec_start, new_addrlen);
211:
212: /* update offset field */
213: *(opt + 1) += new_addrlen;
214:
215: IFDEBUG(D_OPTIONS)
216: printf("clnp_dooptions: new option dump:\n");
217: dump_buf(opt, oidx->cni_recrt_len);
218: ENDDEBUG
219: }
220: }
221: }
222: }
223:
224: /*
225: * FUNCTION: clnp_set_opts
226: *
227: * PURPOSE: Check the data mbuf passed for option sanity. If it is
228: * ok, then set the options ptr to address the data mbuf.
229: * If an options mbuf exists, free it. This implies that
230: * any old options will be lost. If data is NULL, simply
231: * free any old options.
232: *
233: * RETURNS: unix error code
234: *
235: * SIDE EFFECTS:
236: *
237: * NOTES:
238: */
239: clnp_set_opts(options, data)
240: struct mbuf **options; /* target for option information */
241: struct mbuf **data; /* source of option information */
242: {
243: int error = 0; /* error return value */
244: struct clnp_optidx dummy; /* dummy index - not used */
245:
246: /*
247: * remove any existing options
248: */
249: if (*options != NULL) {
250: m_freem(*options);
251: *options = NULL;
252: }
253:
254: if (*data != NULL) {
255: /*
256: * Insure that the options are reasonable.
257: *
258: * Also, we do not support security, priority,
259: * nor do we allow one to send an ER option
260: *
261: * The QOS parameter is checked for the DECBIT.
262: */
263: if ((clnp_opt_sanity(*data, mtod(*data, caddr_t), (*data)->m_len,
264: &dummy) != 0) ||
265: (dummy.cni_securep) ||
266: (dummy.cni_priorp) ||
267: (dummy.cni_er_reason != ER_INVALREAS)) {
268: error = EINVAL;
269: } else {
270: *options = *data;
271: *data = NULL; /* so caller won't free mbuf @ *data */
272: }
273: }
274: return error;
275: }
276:
277: /*
278: * FUNCTION: clnp_opt_sanity
279: *
280: * PURPOSE: Check the options (beginning at opts for len bytes) for
281: * sanity. In addition, fill in the option index structure
282: * in with information about each option discovered.
283: *
284: * RETURNS: success (options check out) - 0
285: * failure - an ER pdu error code describing failure
286: *
287: * SIDE EFFECTS:
288: *
289: * NOTES: Each pointer field of the option index is filled in with
290: * the offset from the beginning of the mbuf data, not the
291: * actual address.
292: */
293: clnp_opt_sanity(m, opts, len, oidx)
294: struct mbuf *m; /* mbuf options reside in */
295: caddr_t opts; /* ptr to buffer containing options */
296: int len; /* length of buffer */
297: struct clnp_optidx *oidx; /* RETURN: filled in with option idx info */
298: {
299: u_char opcode; /* code of particular option */
300: u_char oplen; /* length of a particular option */
301: caddr_t opts_end; /* ptr to end of options */
302: u_char pad = 0, secure = 0, srcrt = 0, recrt = 0, qos = 0, prior = 0;
303: /* flags for catching duplicate options */
304:
305: IFDEBUG(D_OPTIONS)
306: printf("clnp_opt_sanity: checking %d bytes of data:\n", len);
307: dump_buf(opts, len);
308: ENDDEBUG
309:
310: /* clear option index field if passed */
311: bzero((caddr_t)oidx, sizeof(struct clnp_optidx));
312:
313: /*
314: * We need to indicate whether the ER option is present. This is done
315: * by overloading the er_reason field to also indicate presense of
316: * the option along with the option value. I would like ER_INVALREAS
317: * to have value 0, but alas, 0 is a valid er reason...
318: */
319: oidx->cni_er_reason = ER_INVALREAS;
320:
321: opts_end = opts + len;
322: while (opts < opts_end) {
323: /* must have at least 2 bytes per option (opcode and len) */
324: if (opts + 2 > opts_end)
325: return(GEN_INCOMPLETE);
326:
327: opcode = *opts++;
328: oplen = *opts++;
329: IFDEBUG(D_OPTIONS)
330: printf("clnp_opt_sanity: opcode is %x and oplen %d\n",
331: opcode, oplen);
332: printf("clnp_opt_sanity: clnpoval_SRCRT is %x\n", CLNPOVAL_SRCRT);
333:
334: switch (opcode) {
335: case CLNPOVAL_PAD: {
336: printf("CLNPOVAL_PAD\n");
337: } break;
338: case CLNPOVAL_SECURE: {
339: printf("CLNPOVAL_SECURE\n");
340: } break;
341: case CLNPOVAL_SRCRT: {
342: printf("CLNPOVAL_SRCRT\n");
343: } break;
344: case CLNPOVAL_RECRT: {
345: printf("CLNPOVAL_RECRT\n");
346: } break;
347: case CLNPOVAL_QOS: {
348: printf("CLNPOVAL_QOS\n");
349: } break;
350: case CLNPOVAL_PRIOR: {
351: printf("CLNPOVAL_PRIOR\n");
352: } break;
353: case CLNPOVAL_ERREAS: {
354: printf("CLNPOVAL_ERREAS\n");
355: } break;
356: default:
357: printf("UKNOWN option %x\n", opcode);
358: }
359: ENDDEBUG
360:
361: /* don't allow crazy length values */
362: if (opts + oplen > opts_end)
363: return(GEN_INCOMPLETE);
364:
365: switch (opcode) {
366: case CLNPOVAL_PAD:
367: /*
368: * Padding: increment pointer by length of padding
369: */
370: if (pad++) /* duplicate ? */
371: return(GEN_DUPOPT);
372: opts += oplen;
373: break;
374:
375: case CLNPOVAL_SECURE: {
376: u_char format = *opts;
377:
378: if (secure++) /* duplicate ? */
379: return(GEN_DUPOPT);
380: /*
381: * Security: high 2 bits of first octet indicate format
382: * (00 in high bits is reserved).
383: * Remaining bits must be 0. Remaining octets indicate
384: * actual security
385: */
386: if (((format & 0x3f) > 0) || /* low 6 bits set ? */
387: ((format & 0xc0) == 0)) /* high 2 bits zero ? */
388: return(GEN_HDRSYNTAX);
389:
390: oidx->cni_securep = CLNP_OPTTOOFF(m, opts);
391: oidx->cni_secure_len = oplen;
392: opts += oplen;
393: } break;
394:
395: case CLNPOVAL_SRCRT: {
396: u_char type, offset; /* type of rt, offset of start */
397: caddr_t route_end; /* address of end of route option */
398:
399: IFDEBUG(D_OPTIONS)
400: printf("clnp_opt_sanity: SRC RT\n");
401: ENDDEBUG
402:
403: if (srcrt++) /* duplicate ? */
404: return(GEN_DUPOPT);
405: /*
406: * source route: There must be 2 bytes following the length
407: * field: type and offset. The type must be either
408: * partial route or complete route. The offset field must
409: * be within the option. A single exception is made, however.
410: * The offset may be 1 greater than the length. This case
411: * occurs when the last source route record is consumed.
412: * In this case, we ignore the source route option.
413: * RAH? You should be able to set offset to 'ff' like in record
414: * route!
415: * Following this is a series of address fields.
416: * Each address field is composed of a (length, address) pair.
417: * Insure that the offset and each address length is reasonable
418: */
419: route_end = opts + oplen;
420:
421: if (opts + 2 > route_end)
422: return(SRCRT_SYNTAX);
423:
424: type = *opts;
425: offset = *(opts+1);
426:
427:
428: /* type must be partial or complete */
429: if (!((type == CLNPOVAL_PARTRT) || (type == CLNPOVAL_COMPRT)))
430: return(SRCRT_SYNTAX);
431:
432: oidx->cni_srcrt_s = CLNP_OPTTOOFF(m, opts);
433: oidx->cni_srcrt_len = oplen;
434:
435: opts += offset-1; /*set opts to first addr in rt */
436:
437: /*
438: * Offset must be reasonable:
439: * less than end of options, or equal to end of options
440: */
441: if (opts >= route_end) {
442: if (opts == route_end) {
443: IFDEBUG(D_OPTIONS)
444: printf("clnp_opt_sanity: end of src route info\n");
445: ENDDEBUG
446: break;
447: } else
448: return(SRCRT_SYNTAX);
449: }
450:
451: while (opts < route_end) {
452: u_char addrlen = *opts++;
453: if (opts + addrlen > route_end)
454: return(SRCRT_SYNTAX);
455: opts += addrlen;
456: }
457: } break;
458: case CLNPOVAL_RECRT: {
459: u_char type, offset; /* type of rt, offset of start */
460: caddr_t record_end; /* address of end of record option */
461:
462: if (recrt++) /* duplicate ? */
463: return(GEN_DUPOPT);
464: /*
465: * record route: after the length field, expect a
466: * type and offset. Type must be partial or complete.
467: * Offset indicates where to start recording. Insure it
468: * is within the option. All ones for offset means
469: * recording is terminated.
470: */
471: record_end = opts + oplen;
472:
473: oidx->cni_recrtp = CLNP_OPTTOOFF(m, opts);
474: oidx->cni_recrt_len = oplen;
475:
476: if (opts + 2 > record_end)
477: return(GEN_INCOMPLETE);
478:
479: type = *opts;
480: offset = *(opts+1);
481:
482: /* type must be partial or complete */
483: if (!((type == CLNPOVAL_PARTRT) || (type == CLNPOVAL_COMPRT)))
484: return(GEN_HDRSYNTAX);
485:
486: /* offset must be reasonable */
487: if ((offset < 0xff) && (opts + offset > record_end))
488: return(GEN_HDRSYNTAX);
489: opts += oplen;
490: } break;
491: case CLNPOVAL_QOS: {
492: u_char format = *opts;
493:
494: if (qos++) /* duplicate ? */
495: return(GEN_DUPOPT);
496: /*
497: * qos: high 2 bits of first octet indicate format
498: * (00 in high bits is reserved).
499: * Remaining bits must be 0 (unless format indicates
500: * globally unique qos, in which case remaining bits indicate
501: * qos (except bit 6 which is reserved)). Otherwise,
502: * remaining octets indicate actual qos.
503: */
504: if (((format & 0xc0) == 0) || /* high 2 bits zero ? */
505: (((format & 0xc0) != CLNPOVAL_GLOBAL) &&
506: ((format & 0x3f) > 0))) /* not global,low bits used ? */
507: return(GEN_HDRSYNTAX);
508:
509: oidx->cni_qos_formatp = CLNP_OPTTOOFF(m, opts);
510: oidx->cni_qos_len = oplen;
511:
512: opts += oplen;
513: } break;
514:
515: case CLNPOVAL_PRIOR: {
516: if (prior++) /* duplicate ? */
517: return(GEN_DUPOPT);
518: /*
519: * priority: value must be one byte long
520: */
521: if (oplen != 1)
522: return(GEN_HDRSYNTAX);
523:
524: oidx->cni_priorp = CLNP_OPTTOOFF(m, opts);
525:
526: opts += oplen;
527: } break;
528:
529: case CLNPOVAL_ERREAS: {
530: /*
531: * er reason: value must be two bytes long
532: */
533: if (oplen != 2)
534: return(GEN_HDRSYNTAX);
535:
536: oidx->cni_er_reason = *opts;
537:
538: opts += oplen;
539: } break;
540:
541: default: {
542: IFDEBUG(D_OPTIONS)
543: printf("clnp_opt_sanity: UNKNOWN OPTION 0x%x\n", opcode);
544: ENDDEBUG
545: return(DISC_UNSUPPOPT);
546: }
547: }
548: }
549: IFDEBUG(D_OPTIONS)
550: printf("clnp_opt_sanity: return(0)\n", opcode);
551: ENDDEBUG
552: return(0);
553: }
554: #endif /* ISO */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.