Annotation of embedaddon/libpdel/ppp/ppp_fsm_option.c, revision 1.1.1.1
1.1 misho 1:
2: /*
3: * Copyright (c) 2001-2002 Packet Design, LLC.
4: * All rights reserved.
5: *
6: * Subject to the following obligations and disclaimer of warranty,
7: * use and redistribution of this software, in source or object code
8: * forms, with or without modifications are expressly permitted by
9: * Packet Design; provided, however, that:
10: *
11: * (i) Any and all reproductions of the source or object code
12: * must include the copyright notice above and the following
13: * disclaimer of warranties; and
14: * (ii) No rights are granted, in any manner or form, to use
15: * Packet Design trademarks, including the mark "PACKET DESIGN"
16: * on advertising, endorsements, or otherwise except as such
17: * appears in the above copyright notice or in the software.
18: *
19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
36: * THE POSSIBILITY OF SUCH DAMAGE.
37: *
38: * Author: Archie Cobbs <archie@freebsd.org>
39: */
40:
41: #include "ppp/ppp_defs.h"
42: #include "ppp/ppp_log.h"
43: #include "ppp/ppp_fsm_option.h"
44:
45: #define FSM_OPTION_MTYPE "ppp_fsm_option"
46:
47: /***********************************************************************
48: PUBLIC FUNCTIONS
49: ***********************************************************************/
50:
51: /*
52: * Create new options array.
53: */
54: struct ppp_fsm_options *
55: ppp_fsm_option_create(void)
56: {
57: struct ppp_fsm_options *opt;
58:
59: if ((opt = MALLOC(FSM_OPTION_MTYPE, sizeof(*opt))) == NULL)
60: return (NULL);
61: memset(opt, 0, sizeof(*opt));
62: return (opt);
63: }
64:
65: /*
66: * Destroy options array.
67: */
68: void
69: ppp_fsm_option_destroy(struct ppp_fsm_options **optsp)
70: {
71: struct ppp_fsm_options *const opts = *optsp;
72: int i;
73:
74: if (opts == NULL)
75: return;
76: *optsp = NULL;
77: for (i = 0; i < opts->num; i++)
78: FREE(FSM_OPTION_MTYPE, opts->opts[i].data);
79: FREE(FSM_OPTION_MTYPE, opts->opts);
80: FREE(FSM_OPTION_MTYPE, opts);
81: }
82:
83: /*
84: * Add an option to an options array.
85: */
86: int
87: ppp_fsm_option_add(struct ppp_fsm_options *opts,
88: u_char type, u_char len, const void *data)
89: {
90: struct ppp_fsm_option *opt;
91: void *buf = NULL;
92: void *mem;
93:
94: /* Copy option data into buffer */
95: if (len > 0) {
96: if ((buf = MALLOC(FSM_OPTION_MTYPE, len)) == NULL)
97: return (-1);
98: memcpy(buf, data, len);
99: }
100:
101: /* Extend options array by one */
102: if ((mem = REALLOC(FSM_OPTION_MTYPE, opts->opts,
103: (opts->num + 1) * sizeof(*opts->opts))) == NULL) {
104: FREE(FSM_OPTION_MTYPE, buf);
105: return (-1);
106: }
107: opts->opts = mem;
108: opt = &opts->opts[opts->num++];
109:
110: /* Fill in option info */
111: opt->type = type;
112: opt->len = len;
113: opt->data = buf;
114:
115: /* Done */
116: return (0);
117: }
118:
119: /*
120: * Remove an option from an options array.
121: */
122: int
123: ppp_fsm_option_del(struct ppp_fsm_options *opts, u_int index)
124: {
125: struct ppp_fsm_option *const opt = opts->opts + index;
126:
127: if (index >= opts->num) {
128: errno = EDOM;
129: return (-1);
130: }
131: FREE(FSM_OPTION_MTYPE, opt->data);
132: memmove(opts->opts + index, opts->opts + index + 1,
133: (--opts->num - index) * sizeof(*opts->opts));
134: return (0);
135: }
136:
137: /*
138: * Reset an options array to empty.
139: */
140: void
141: ppp_fsm_option_zero(struct ppp_fsm_options *opts)
142: {
143: while (opts->num > 0)
144: ppp_fsm_option_del(opts, 0);
145: FREE(FSM_OPTION_MTYPE, opts->opts);
146: opts->opts = NULL;
147: }
148:
149: /*
150: * Copy an options array.
151: */
152: struct ppp_fsm_options *
153: ppp_fsm_option_copy(struct ppp_fsm_options *opts)
154: {
155: struct ppp_fsm_options *copy;
156: int i;
157:
158: if ((copy = ppp_fsm_option_create()) == NULL)
159: return (NULL);
160: for (i = 0; i < opts->num; i++) {
161: const struct ppp_fsm_option *const opt = &opts->opts[i];
162:
163: if (ppp_fsm_option_add(copy,
164: opt->type, opt->len, opt->data) == -1) {
165: ppp_fsm_option_destroy(©);
166: return (NULL);
167: }
168: }
169: return (copy);
170: }
171:
172: /*
173: * Compare two options arrays for equality.
174: *
175: * If "i1" or "i2" is equal to -1 then we compare all options.
176: * Otherwise we just compare option "i1" of "o1" to option "i2" of "o2".
177: */
178: int
179: ppp_fsm_option_equal(const struct ppp_fsm_options *o1,
180: int i1, const struct ppp_fsm_options *o2, int i2)
181: {
182: int i;
183:
184: /* Compare all options? */
185: if (i1 == -1 && i2 == -1) {
186: if (o1->num != o2->num)
187: return (0);
188: for (i = 0; i < o1->num; i++) {
189: if (!ppp_fsm_option_equal(o1, i, o2, i))
190: return (0);
191: }
192: return (1);
193: }
194:
195: /* Sanity check indicies */
196: if (i1 < 0 || i2 < 0 || i1 >= o1->num || i2 >= o2->num) {
197: errno = EINVAL;
198: return (-1);
199: }
200:
201: /* Compare two options */
202: if (o1->opts[i1].type != o2->opts[i2].type)
203: return (0);
204: if (o1->opts[i1].len != o2->opts[i2].len)
205: return (0);
206: if (memcmp(o1->opts[i1].data, o2->opts[i2].data, o1->opts[i1].len) != 0)
207: return (0);
208: return (1);
209: }
210:
211: /*
212: * Print out options into the log.
213: */
214: void
215: ppp_fsm_options_decode(const struct ppp_fsm_optdesc *optlist,
216: const u_char *data, u_int len, char *buf, size_t bmax)
217: {
218: struct ppp_fsm_options *opts;
219: int i;
220:
221: /* Decode options */
222: if ((opts = ppp_fsm_option_unpack(data, len)) == NULL)
223: return;
224:
225: /* Special case for empty */
226: if (opts->num == 0) {
227: strlcpy(buf, "(no options)", bmax);
228: goto done;
229: }
230:
231: /* Print options into buffer */
232: strlcpy(buf, "", bmax);
233: for (i = 0; i < opts->num; i++) {
234: const struct ppp_fsm_option *const opt = &opts->opts[i];
235: const struct ppp_fsm_optdesc *const desc
236: = ppp_fsm_option_desc(optlist, opt);
237:
238: if (i > 0)
239: strlcat(buf, " ", bmax); /* separator */
240: strlcat(buf, "[", bmax);
241: if (desc == NULL) {
242: snprintf(buf + strlen(buf), bmax - strlen(buf),
243: "?%u (len=%u)", opt->type, opt->len);
244: } else {
245: strlcat(buf, desc->name, bmax);
246: if (desc->print != NULL) {
247: strlcat(buf, " ", bmax);
248: (*desc->print)(desc, opt,
249: buf + strlen(buf), bmax - strlen(buf));
250: }
251: }
252: strlcat(buf, "]", bmax);
253: }
254:
255: done:
256: /* Clean up */
257: ppp_fsm_option_destroy(&opts);
258: }
259:
260: /*
261: * Find option descriptor in a table.
262: */
263: const struct ppp_fsm_optdesc *
264: ppp_fsm_option_desc(const struct ppp_fsm_optdesc *optlist,
265: const struct ppp_fsm_option *opt)
266: {
267: const struct ppp_fsm_optdesc *desc;
268:
269: for (desc = optlist; desc->name != NULL; desc++) {
270: if (opt->type == desc->type)
271: return (desc);
272: }
273: return (NULL);
274: }
275:
276: /***********************************************************************
277: PACKING/UNPACKING OPTIONS
278: ***********************************************************************/
279:
280: /*
281: * Extract encoded options, stopping at the first malformed option.
282: *
283: * Returns NULL if there was a system error.
284: */
285: struct ppp_fsm_options *
286: ppp_fsm_option_unpack(const u_char *data, u_int len)
287: {
288: struct ppp_fsm_options *opts;
289:
290: if ((opts = ppp_fsm_option_create()) == NULL)
291: return (NULL);
292: while (len >= 2) {
293: const u_char type = data[0];
294: const u_char olen = data[1];
295:
296: if (olen < 2 || olen > len)
297: break;
298: if (ppp_fsm_option_add(opts, type, olen - 2, data + 2) == -1) {
299: ppp_fsm_option_destroy(&opts);
300: return (NULL);
301: }
302: data += olen;
303: len -= olen;
304: }
305: return (opts);
306: }
307:
308: /*
309: * Compute length of packed options.
310: */
311: u_int
312: ppp_fsm_option_packlen(struct ppp_fsm_options *opts)
313: {
314: u_int len;
315: int i;
316:
317: for (len = i = 0; i < opts->num; i++)
318: len += 2 + opts->opts[i].len;
319: return (len);
320: }
321:
322: /*
323: * Pack options into buffer.
324: */
325: void
326: ppp_fsm_option_pack(struct ppp_fsm_options *opts, u_char *buf)
327: {
328: int i;
329:
330: for (i = 0; i < opts->num; i++) {
331: struct ppp_fsm_option *const opt = &opts->opts[i];
332:
333: *buf++ = opt->type;
334: *buf++ = 2 + opt->len;
335: memcpy(buf, opt->data, opt->len);
336: buf += opt->len;
337: }
338: }
339:
340: /***********************************************************************
341: BUILT-IN OPTIONS PRINTER FUNCTIONS
342: ***********************************************************************/
343:
344: #define MAX_BINARY 16
345:
346: /*
347: * Print option as binary data.
348: */
349: void
350: ppp_fsm_pr_binary(const struct ppp_fsm_optdesc *desc,
351: const struct ppp_fsm_option *opt, char *buf, size_t bmax)
352: {
353: int i;
354:
355: for (i = 0; i < opt->len; i++) {
356: if (i >= MAX_BINARY) {
357: snprintf(buf + strlen(buf), bmax - strlen(buf),
358: "...");
359: break;
360: }
361: if (i == 0)
362: snprintf(buf, bmax, "%02x", opt->data[0]);
363: else
364: snprintf(buf + strlen(buf), bmax - strlen(buf),
365: " %02x", opt->data[i]);
366: }
367: }
368:
369: /*
370: * Print option as 32 bit hex value.
371: */
372: void
373: ppp_fsm_pr_hex32(const struct ppp_fsm_optdesc *desc,
374: const struct ppp_fsm_option *opt, char *buf, size_t bmax)
375: {
376: u_int32_t val;
377:
378: if (opt->len < 4) {
379: snprintf(buf, bmax, "<truncated>");
380: return;
381: }
382: memcpy(&val, opt->data, 4);
383: val = ntohl(val);
384: snprintf(buf, bmax, "0x%08x", val);
385: }
386:
387: /*
388: * Print option as a 16 bit hex value.
389: */
390: void
391: ppp_fsm_pr_int16(const struct ppp_fsm_optdesc *desc,
392: const struct ppp_fsm_option *opt, char *buf, size_t bmax)
393: {
394: u_int16_t val;
395:
396: if (opt->len < 2) {
397: snprintf(buf, bmax, "<truncated>");
398: return;
399: }
400: memcpy(&val, opt->data, 2);
401: val = ntohs(val);
402: snprintf(buf, bmax, "%u", val);
403: }
404:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to ppp_fsm_option.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / ppp