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