![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to l2tp_avp.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src|
Return to l2tp_avp.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mpd / src |
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.h"
42: #include "log.h"
43: #include "l2tp_avp.h"
44: #include "util.h"
45: #include <openssl/md5.h>
46:
47: /* Memory types */
48: #define AVP_MTYPE "ppp_l2tp_avp"
49: #define AVP_LIST_MTYPE "ppp_l2tp_avp_list"
50: #define AVP_PTRS_MTYPE "ppp_l2tp_avp_ptrs"
51:
52: /***********************************************************************
53: AVP STRUCTURE METHODS
54: ***********************************************************************/
55:
56: /*
57: * Create a new AVP structure.
58: */
59: struct ppp_l2tp_avp *
60: ppp_l2tp_avp_create(int mandatory, u_int16_t vendor,
61: u_int16_t type, const void *value, size_t vlen)
62: {
63: struct ppp_l2tp_avp *avp;
64:
65: avp = Malloc(AVP_MTYPE, sizeof(*avp));
66: avp->mandatory = !!mandatory;
67: avp->vendor = vendor;
68: avp->type = type;
69: if (vlen > 0)
70: avp->value = Mdup(AVP_MTYPE, value, vlen);
71: avp->vlen = vlen;
72: return (avp);
73: }
74:
75: /*
76: * Copy an AVP struture.
77: */
78: struct ppp_l2tp_avp *
79: ppp_l2tp_avp_copy(const struct ppp_l2tp_avp *avp)
80: {
81: return (ppp_l2tp_avp_create(avp->mandatory, avp->vendor,
82: avp->type, avp->value, avp->vlen));
83: }
84:
85: /*
86: * Destroy an AVP structure.
87: */
88: void
89: ppp_l2tp_avp_destroy(struct ppp_l2tp_avp **avpp)
90: {
91: struct ppp_l2tp_avp *const avp = *avpp;
92:
93: if (avp == NULL)
94: return;
95: *avpp = NULL;
96: Freee(avp->value);
97: Freee(avp);
98: }
99:
100: /***********************************************************************
101: AVP LIST METHODS
102: ***********************************************************************/
103:
104: /*
105: * Create a new AVP list.
106: */
107: struct ppp_l2tp_avp_list *
108: ppp_l2tp_avp_list_create(void)
109: {
110: return (Malloc(AVP_LIST_MTYPE, sizeof(struct ppp_l2tp_avp_list)));
111: }
112:
113: /*
114: * Insert an AVP into a list.
115: */
116: int
117: ppp_l2tp_avp_list_insert(struct ppp_l2tp_avp_list *list,
118: struct ppp_l2tp_avp **avpp, int index)
119: {
120: struct ppp_l2tp_avp *const avp = *avpp;
121: void *mem;
122:
123: if (avp == NULL || index < 0 || index > list->length) {
124: errno = EINVAL;
125: return (-1);
126: }
127: /* REALLOC */
128: mem = Malloc(AVP_LIST_MTYPE, (list->length + 1) * sizeof(*list->avps));
129: memcpy(mem, list->avps, list->length * sizeof(*list->avps));
130: Freee(list->avps);
131: list->avps = mem;
132: /* insert */
133: memmove(list->avps + index + 1, list->avps + index,
134: (list->length++ - index) * sizeof(*list->avps));
135: list->avps[index] = *avp;
136: Freee(avp);
137: *avpp = NULL;
138: return (0);
139: }
140:
141: /*
142: * Create a new AVP and add it to the end of the given list.
143: */
144: int
145: ppp_l2tp_avp_list_append(struct ppp_l2tp_avp_list *list, int mandatory,
146: u_int16_t vendor, u_int16_t type, const void *value, size_t vlen)
147: {
148: struct ppp_l2tp_avp *avp;
149:
150: avp = ppp_l2tp_avp_create(mandatory, vendor, type, value, vlen);
151: if (ppp_l2tp_avp_list_insert(list, &avp, list->length) == -1) {
152: ppp_l2tp_avp_destroy(&avp);
153: return (-1);
154: }
155: return (0);
156: }
157:
158: /*
159: * Extract an AVP from a list.
160: */
161: struct ppp_l2tp_avp *
162: ppp_l2tp_avp_list_extract(struct ppp_l2tp_avp_list *list, u_int index)
163: {
164: struct ppp_l2tp_avp *elem;
165: struct ppp_l2tp_avp *avp;
166:
167: if (index >= list->length) {
168: errno = EINVAL;
169: return (NULL);
170: }
171: elem = &list->avps[index];
172: avp = ppp_l2tp_avp_create(elem->mandatory, elem->vendor,
173: elem->type, elem->value, elem->vlen);
174: memmove(list->avps + index, list->avps + index + 1,
175: (--list->length - index) * sizeof(*list->avps));
176: return (avp);
177: }
178:
179: /*
180: * Remove and destroy an AVP from a list.
181: */
182: int
183: ppp_l2tp_avp_list_remove(struct ppp_l2tp_avp_list *list, u_int index)
184: {
185: if (index >= list->length) {
186: errno = EINVAL;
187: return (-1);
188: }
189: Freee(list->avps[index].value);
190: memmove(list->avps + index, list->avps + index + 1,
191: (--list->length - index) * sizeof(*list->avps));
192: return (0);
193: }
194:
195: /*
196: * Find an AVP in a list.
197: */
198: int
199: ppp_l2tp_avp_list_find(const struct ppp_l2tp_avp_list *list,
200: u_int16_t vendor, u_int16_t type)
201: {
202: int i;
203:
204: for (i = 0; i < list->length; i++) {
205: const struct ppp_l2tp_avp *const avp = &list->avps[i];
206:
207: if (avp->vendor == vendor && avp->type == type)
208: return (i);
209: }
210: return (-1);
211: }
212:
213: /*
214: * Copy an AVP list.
215: */
216: struct ppp_l2tp_avp_list *
217: ppp_l2tp_avp_list_copy(const struct ppp_l2tp_avp_list *orig)
218: {
219: struct ppp_l2tp_avp_list *list;
220: int i;
221:
222: list = ppp_l2tp_avp_list_create();
223: for (i = 0; i < orig->length; i++) {
224: const struct ppp_l2tp_avp *const avp = &orig->avps[i];
225:
226: if (ppp_l2tp_avp_list_append(list, avp->mandatory,
227: avp->vendor, avp->type, avp->value, avp->vlen) == -1) {
228: ppp_l2tp_avp_list_destroy(&list);
229: return (NULL);
230: }
231: }
232: return (list);
233: }
234:
235: /*
236: * Destroy an AVP list.
237: */
238: void
239: ppp_l2tp_avp_list_destroy(struct ppp_l2tp_avp_list **listp)
240: {
241: struct ppp_l2tp_avp_list *const list = *listp;
242: int i;
243:
244: if (list == NULL)
245: return;
246: *listp = NULL;
247: for (i = 0; i < list->length; i++) {
248: const struct ppp_l2tp_avp *const avp = &list->avps[i];
249:
250: Freee(avp->value);
251: }
252: Freee(list->avps);
253: Freee(list);
254: }
255:
256: /*
257: * Encode a list of AVP's into a single buffer, preserving the order
258: * of the AVP's. If a shared secret is supplied, and any of the AVP's
259: * are hidden, then any required random vector AVP's are created and
260: * inserted automatically.
261: */
262: int
263: ppp_l2tp_avp_pack(const struct ppp_l2tp_avp_info *info,
264: const struct ppp_l2tp_avp_list *list, const u_char *secret,
265: size_t slen, u_char *buf)
266: {
267: uint32_t randvec;
268: int randsent = 0;
269: int len;
270: int i;
271:
272: /* Pack AVP's */
273: for (len = i = 0; i < list->length; i++) {
274: const struct ppp_l2tp_avp *const avp = &list->avps[i];
275: const struct ppp_l2tp_avp_info *desc;
276: u_int16_t hdr[3];
277: int hide = 0;
278: int pad = 0;
279: int j;
280:
281: /* Find descriptor */
282: for (desc = info; desc->name != NULL
283: && (desc->vendor != avp->vendor || desc->type != avp->type);
284: desc++);
285: if (desc->name == NULL) {
286: errno = EILSEQ;
287: return (-1);
288: }
289:
290: /* Sanity check AVP */
291: if (avp->vlen < desc->min_length
292: || avp->vlen > desc->max_length
293: || avp->vlen > AVP_MAX_VLEN) {
294: errno = EILSEQ;
295: return (-1);
296: }
297:
298: /* Add random vector first time */
299: if (secret != NULL && desc->hidden_ok && randsent == 0) {
300: if (buf != NULL) {
301: memset(&hdr, 0, sizeof(hdr));
302: hdr[0] = AVP_MANDATORY | (sizeof(randvec) + 6);
303: hdr[1] = 0;
304: hdr[2] = AVP_RANDOM_VECTOR;
305: for (j = 0; j < 3; j++)
306: hdr[j] = htons(hdr[j]);
307: memcpy(buf + len, &hdr, 6);
308: randvec = random();
309: memcpy(buf + len + 6, &randvec, sizeof(randvec));
310: }
311: len += 6 + sizeof(randvec);
312: randsent = 1;
313: }
314:
315: /* Set header stuff for this AVP */
316: memset(&hdr, 0, sizeof(hdr));
317: if (avp->mandatory)
318: hdr[0] |= AVP_MANDATORY;
319: if (secret != NULL && desc->hidden_ok) {
320: hdr[0] |= AVP_HIDDEN;
321: hide = 1;
322: pad = 7 - (avp->vlen & 0x7);
323: }
324: hdr[0] |= (6 + (hide?2:0) + avp->vlen + pad);
325: hdr[1] = avp->vendor;
326: hdr[2] = avp->type;
327: for (j = 0; j < 3; j++)
328: hdr[j] = htons(hdr[j]);
329: if (buf != NULL)
330: memcpy(buf + len, &hdr, 6);
331: len += 6;
332:
333: /* Copy AVP value, optionally hiding it */
334: if (hide) {
335: if (buf != NULL) {
336: MD5_CTX md5ctx;
337: u_char hash[MD5_DIGEST_LENGTH];
338: int k, l;
339: uint16_t t;
340:
341: /* Add original length */
342: buf[len] = (avp->vlen >> 8);
343: buf[len + 1] = (avp->vlen & 0xff);
344:
345: /* Add value */
346: memcpy(buf + len + 2, avp->value, avp->vlen);
347:
348: /* Encrypt value */
349: MD5_Init(&md5ctx);
350: t = htons(avp->type);
351: MD5_Update(&md5ctx, &t, 2);
352: MD5_Update(&md5ctx, secret, slen);
353: MD5_Update(&md5ctx, &randvec, sizeof(randvec));
354: MD5_Final(hash, &md5ctx);
355: for (l = 0; l <= (2 + avp->vlen - 1)/MD5_DIGEST_LENGTH; l++) {
356: if (l > 0) {
357: MD5_Init(&md5ctx);
358: MD5_Update(&md5ctx, secret, slen);
359: MD5_Update(&md5ctx, buf + len + (l-1)*MD5_DIGEST_LENGTH, MD5_DIGEST_LENGTH);
360: MD5_Final(hash, &md5ctx);
361: }
362: for (k = 0;
363: k < MD5_DIGEST_LENGTH &&
364: (l*MD5_DIGEST_LENGTH+k) < (2 + avp->vlen);
365: k++) {
366: buf[len + l*MD5_DIGEST_LENGTH + k] ^=
367: hash[k];
368: }
369: }
370: }
371: len += 2 + avp->vlen + pad;
372: } else {
373: if (buf != NULL)
374: memcpy(buf + len, avp->value, avp->vlen);
375: len += avp->vlen;
376: }
377: }
378:
379: /* Done */
380: return (len);
381: }
382:
383: /*
384: * Decode a packet into an array of unpacked AVP structures, preserving
385: * the order of the AVP's. Random vector AVP's are automatically removed.
386: */
387: struct ppp_l2tp_avp_list *
388: ppp_l2tp_avp_unpack(const struct ppp_l2tp_avp_info *info,
389: u_char *data, size_t dlen, const u_char *secret, size_t slen)
390: {
391: struct ppp_l2tp_avp_list *list;
392: const u_char *randvec = NULL;
393: u_int16_t hdr[3];
394: int randvec_len = 0;
395: int i;
396:
397: /* Create list */
398: list = ppp_l2tp_avp_list_create();
399:
400: /* Unpack AVP's */
401: while (dlen > 0) {
402: const struct ppp_l2tp_avp_info *desc;
403: u_int16_t alen;
404: /* Get header */
405: if (dlen < 6)
406: goto bogus;
407: memcpy(&hdr, data, 6);
408: for (i = 0; i < 3; i++)
409: hdr[i] = ntohs(hdr[i]);
410: alen = hdr[0] & AVP_LENGTH_MASK;
411: if (alen < 6 || alen > dlen)
412: goto bogus;
413:
414: /* Check reserved bits */
415: if ((hdr[0] & AVP_RESERVED) != 0)
416: goto unknown;
417:
418: /* Find descriptor for this AVP */
419: for (desc = info; desc->name != NULL
420: && (desc->vendor != hdr[1] || desc->type != hdr[2]);
421: desc++);
422: if (desc->name == NULL) {
423: unknown: if ((hdr[0] & AVP_MANDATORY) != 0) {
424: errno = ENOSYS;
425: goto fail;
426: }
427: goto skip;
428: }
429:
430: /* Remember random vector AVP's as we see them */
431: if (hdr[1] == 0 && hdr[2] == AVP_RANDOM_VECTOR) {
432: randvec = data + 6;
433: randvec_len = alen - 6;
434: data += alen;
435: dlen -= alen;
436: continue;
437: }
438:
439: /* Un-hide AVP if hidden */
440: if ((hdr[0] & AVP_HIDDEN) != 0) {
441: MD5_CTX md5ctx;
442: u_char hash[MD5_DIGEST_LENGTH];
443: u_char nhash[MD5_DIGEST_LENGTH];
444: int k, l;
445: u_int16_t olen;
446: uint16_t t;
447:
448: if (randvec == NULL)
449: goto bogus;
450: if (secret == NULL) {
451: errno = EAUTH;
452: goto fail;
453: }
454:
455: /* Encrypt value */
456: MD5_Init(&md5ctx);
457: t = htons(hdr[2]);
458: MD5_Update(&md5ctx, &t, 2);
459: MD5_Update(&md5ctx, secret, slen);
460: MD5_Update(&md5ctx, randvec, randvec_len);
461: MD5_Final(hash, &md5ctx);
462: for (l = 0; l <= (2 + alen - 1)/MD5_DIGEST_LENGTH; l++) {
463: MD5_Init(&md5ctx);
464: MD5_Update(&md5ctx, secret, slen);
465: MD5_Update(&md5ctx, data + 6 + l*MD5_DIGEST_LENGTH, MD5_DIGEST_LENGTH);
466: MD5_Final(nhash, &md5ctx);
467: for (k = 0;
468: k < MD5_DIGEST_LENGTH &&
469: (l*MD5_DIGEST_LENGTH+k) < (alen - 6);
470: k++) {
471: data[6 + l*MD5_DIGEST_LENGTH + k] ^=
472: hash[k];
473: }
474: memcpy(hash, nhash, sizeof(hash));
475: }
476: olen = (data[6] << 8) + data[7] + 6;
477: if ((olen < 6) || (olen > (alen - 2)))
478: goto bogus;
479:
480: if (ppp_l2tp_avp_list_append(list,
481: (hdr[0] & AVP_MANDATORY) != 0, hdr[1], hdr[2],
482: data + 6 + 2, olen - 6) == -1)
483: goto fail;
484: } else {
485: if (ppp_l2tp_avp_list_append(list,
486: (hdr[0] & AVP_MANDATORY) != 0, hdr[1], hdr[2],
487: data + 6, alen - 6) == -1)
488: goto fail;
489: }
490:
491: skip:
492: /* Continue with next AVP */
493: data += alen;
494: dlen -= alen;
495: }
496:
497: /* Done */
498: return (list);
499:
500: bogus:
501: /* Invalid data */
502: errno = EILSEQ;
503: fail:
504: ppp_l2tp_avp_list_destroy(&list);
505: return (NULL);
506: }
507:
508: /***********************************************************************
509: AVP POINTERS METHODS
510: ***********************************************************************/
511:
512: /*
513: * Create an AVP pointers structure from an AVP list.
514: */
515: struct ppp_l2tp_avp_ptrs *
516: ppp_l2tp_avp_list2ptrs(const struct ppp_l2tp_avp_list *list)
517: {
518: struct ppp_l2tp_avp_ptrs *ptrs;
519: int i;
520:
521: /* Macro to allocate one pointer structure */
522: #define AVP_ALLOC(field) \
523: do { \
524: size_t _size = sizeof(*ptrs->field); \
525: \
526: if (_size < avp->vlen) \
527: _size = avp->vlen; \
528: _size += 16; \
529: Freee(ptrs->field); \
530: ptrs->field = Malloc(AVP_PTRS_MTYPE, _size); \
531: } while (0)
532:
533: /* Create new pointers structure */
534: ptrs = Malloc(AVP_PTRS_MTYPE, sizeof(*ptrs));
535:
536: /* Add recognized AVP's */
537: for (i = 0; i < list->length; i++) {
538: const struct ppp_l2tp_avp *const avp = &list->avps[i];
539: const u_char *const ptr8 = (u_char *)avp->value;
540: const u_int16_t *const ptr16 = (u_int16_t *)avp->value;
541: const u_int32_t *const ptr32 = (u_int32_t *)avp->value;
542:
543: if (avp->vendor != 0)
544: continue;
545: switch (avp->type) {
546: case AVP_MESSAGE_TYPE:
547: AVP_ALLOC(message);
548: ptrs->message->mesgtype = ntohs(ptr16[0]);
549: break;
550: case AVP_RESULT_CODE:
551: AVP_ALLOC(errresultcode);
552: ptrs->errresultcode->result = ntohs(ptr16[0]);
553: if (avp->vlen > 2)
554: ptrs->errresultcode->error = ntohs(ptr16[1]);
555: if (avp->vlen > 4) {
556: memcpy(ptrs->errresultcode->errmsg,
557: (char *)avp->value + 4, avp->vlen - 4);
558: }
559: break;
560: case AVP_PROTOCOL_VERSION:
561: AVP_ALLOC(protocol);
562: ptrs->protocol->version = ptr8[0];
563: ptrs->protocol->revision = ptr8[1];
564: break;
565: case AVP_FRAMING_CAPABILITIES:
566: AVP_ALLOC(framingcap);
567: ptrs->framingcap->sync =
568: (ntohl(ptr32[0]) & L2TP_FRAMING_SYNC) != 0;
569: ptrs->framingcap->async =
570: (ntohl(ptr32[0]) & L2TP_FRAMING_ASYNC) != 0;
571: break;
572: case AVP_BEARER_CAPABILITIES:
573: AVP_ALLOC(bearercap);
574: ptrs->bearercap->digital =
575: (ntohl(ptr32[0]) & L2TP_BEARER_DIGITAL) != 0;
576: ptrs->bearercap->analog =
577: (ntohl(ptr32[0]) & L2TP_BEARER_ANALOG) != 0;
578: break;
579: case AVP_TIE_BREAKER:
580: AVP_ALLOC(tiebreaker);
581: memcpy(ptrs->tiebreaker->value, avp->value, 8);
582: break;
583: case AVP_FIRMWARE_REVISION:
584: AVP_ALLOC(firmware);
585: ptrs->firmware->revision = ntohs(ptr16[0]);
586: break;
587: case AVP_HOST_NAME:
588: AVP_ALLOC(hostname);
589: memcpy(ptrs->hostname->hostname, avp->value, avp->vlen);
590: break;
591: case AVP_VENDOR_NAME:
592: AVP_ALLOC(vendor);
593: memcpy(ptrs->vendor->vendorname, avp->value, avp->vlen);
594: break;
595: case AVP_ASSIGNED_TUNNEL_ID:
596: AVP_ALLOC(tunnelid);
597: ptrs->tunnelid->id = ntohs(ptr16[0]);
598: break;
599: case AVP_RECEIVE_WINDOW_SIZE:
600: AVP_ALLOC(winsize);
601: ptrs->winsize->size = ntohs(ptr16[0]);
602: break;
603: case AVP_CHALLENGE:
604: AVP_ALLOC(challenge);
605: ptrs->challenge->length = avp->vlen;
606: memcpy(ptrs->challenge->value, avp->value, avp->vlen);
607: break;
608: case AVP_CAUSE_CODE:
609: AVP_ALLOC(causecode);
610: ptrs->causecode->causecode = ntohs(ptr16[0]);
611: ptrs->causecode->causemsg = ptr8[3];
612: memcpy(ptrs->causecode->message,
613: (char *)avp->value + 3, avp->vlen - 3);
614: break;
615: case AVP_CHALLENGE_RESPONSE:
616: AVP_ALLOC(challengresp);
617: memcpy(ptrs->challengresp->value,
618: avp->value, avp->vlen);
619: break;
620: case AVP_ASSIGNED_SESSION_ID:
621: AVP_ALLOC(sessionid);
622: ptrs->sessionid->id = ntohs(ptr16[0]);
623: break;
624: case AVP_CALL_SERIAL_NUMBER:
625: AVP_ALLOC(serialnum);
626: ptrs->serialnum->serialnum = ntohl(ptr32[0]);
627: break;
628: case AVP_MINIMUM_BPS:
629: AVP_ALLOC(minbps);
630: ptrs->minbps->minbps = ntohl(ptr32[0]);
631: break;
632: case AVP_MAXIMUM_BPS:
633: AVP_ALLOC(maxbps);
634: ptrs->maxbps->maxbps = ntohl(ptr32[0]);
635: break;
636: case AVP_BEARER_TYPE:
637: AVP_ALLOC(bearer);
638: ptrs->bearer->digital =
639: (ntohl(ptr32[0]) & L2TP_BEARER_DIGITAL) != 0;
640: ptrs->bearer->analog =
641: (ntohl(ptr32[0]) & L2TP_BEARER_ANALOG) != 0;
642: break;
643: case AVP_FRAMING_TYPE:
644: AVP_ALLOC(framing);
645: ptrs->framing->sync =
646: (ntohl(ptr32[0]) & L2TP_FRAMING_SYNC) != 0;
647: ptrs->framing->async =
648: (ntohl(ptr32[0]) & L2TP_FRAMING_ASYNC) != 0;
649: break;
650: case AVP_CALLED_NUMBER:
651: AVP_ALLOC(callednum);
652: memcpy(ptrs->callednum->number, avp->value, avp->vlen);
653: break;
654: case AVP_CALLING_NUMBER:
655: AVP_ALLOC(callingnum);
656: memcpy(ptrs->callingnum->number, avp->value, avp->vlen);
657: break;
658: case AVP_SUB_ADDRESS:
659: AVP_ALLOC(subaddress);
660: memcpy(ptrs->subaddress->number, avp->value, avp->vlen);
661: break;
662: case AVP_TX_CONNECT_SPEED:
663: AVP_ALLOC(txconnect);
664: ptrs->txconnect->bps = ntohl(ptr32[0]);
665: break;
666: case AVP_PHYSICAL_CHANNEL_ID:
667: AVP_ALLOC(channelid);
668: ptrs->channelid->channel = ntohl(ptr32[0]);
669: break;
670: case AVP_INITIAL_RECV_CONFREQ:
671: AVP_ALLOC(recvlcp);
672: ptrs->recvlcp->length = avp->vlen;
673: memcpy(ptrs->recvlcp->data, avp->value, avp->vlen);
674: break;
675: case AVP_LAST_SENT_CONFREQ:
676: AVP_ALLOC(lastsendlcp);
677: ptrs->lastsendlcp->length = avp->vlen;
678: memcpy(ptrs->lastsendlcp->data, avp->value, avp->vlen);
679: break;
680: case AVP_LAST_RECV_CONFREQ:
681: AVP_ALLOC(lastrecvlcp);
682: ptrs->lastrecvlcp->length = avp->vlen;
683: memcpy(ptrs->lastrecvlcp->data, avp->value, avp->vlen);
684: break;
685: case AVP_PROXY_AUTHEN_TYPE:
686: AVP_ALLOC(proxyauth);
687: ptrs->proxyauth->type = ntohs(ptr16[0]);
688: break;
689: case AVP_PROXY_AUTHEN_NAME:
690: AVP_ALLOC(proxyname);
691: ptrs->proxyname->length = avp->vlen;
692: memcpy(ptrs->proxyname->data, avp->value, avp->vlen);
693: break;
694: case AVP_PROXY_AUTHEN_CHALLENGE:
695: AVP_ALLOC(proxychallenge);
696: ptrs->proxychallenge->length = avp->vlen;
697: memcpy(ptrs->proxychallenge->data,
698: avp->value, avp->vlen);
699: break;
700: case AVP_PROXY_AUTHEN_ID:
701: AVP_ALLOC(proxyid);
702: ptrs->proxyid->id = ntohs(ptr16[0]);
703: break;
704: case AVP_PROXY_AUTHEN_RESPONSE:
705: AVP_ALLOC(proxyres);
706: ptrs->proxyres->length = avp->vlen;
707: memcpy(ptrs->proxyres->data, avp->value, avp->vlen);
708: break;
709: case AVP_CALL_ERRORS:
710: {
711: u_int32_t vals[6];
712:
713: memcpy(&vals, &ptr16[1], sizeof(vals));
714: AVP_ALLOC(callerror);
715: ptrs->callerror->crc = ntohl(vals[0]);
716: ptrs->callerror->frame = ntohl(vals[1]);
717: ptrs->callerror->overrun = ntohl(vals[2]);
718: ptrs->callerror->buffer = ntohl(vals[3]);
719: ptrs->callerror->timeout = ntohl(vals[4]);
720: ptrs->callerror->alignment = ntohl(vals[5]);
721: break;
722: }
723: case AVP_ACCM:
724: {
725: u_int32_t vals[2];
726:
727: memcpy(&vals, &ptr16[1], sizeof(vals));
728: AVP_ALLOC(accm);
729: ptrs->accm->xmit = ntohl(vals[0]);
730: ptrs->accm->recv = ntohl(vals[1]);
731: break;
732: }
733: case AVP_PRIVATE_GROUP_ID:
734: AVP_ALLOC(groupid);
735: ptrs->groupid->length = avp->vlen;
736: memcpy(ptrs->groupid->data, avp->value, avp->vlen);
737: break;
738: case AVP_RX_CONNECT_SPEED:
739: AVP_ALLOC(rxconnect);
740: ptrs->rxconnect->bps = ntohl(ptr32[0]);
741: break;
742: case AVP_SEQUENCING_REQUIRED:
743: AVP_ALLOC(seqrequired);
744: break;
745: default:
746: break;
747: }
748: }
749:
750: /* Done */
751: return (ptrs);
752: }
753:
754: /*
755: * Destroy an AVP pointers structure.
756: */
757: void
758: ppp_l2tp_avp_ptrs_destroy(struct ppp_l2tp_avp_ptrs **ptrsp)
759: {
760: struct ppp_l2tp_avp_ptrs *const ptrs = *ptrsp;
761:
762: if (ptrs == NULL)
763: return;
764: Freee(ptrs->message);
765: Freee(ptrs->errresultcode);
766: Freee(ptrs->protocol);
767: Freee(ptrs->framingcap);
768: Freee(ptrs->bearercap);
769: Freee(ptrs->tiebreaker);
770: Freee(ptrs->firmware);
771: Freee(ptrs->hostname);
772: Freee(ptrs->vendor);
773: Freee(ptrs->tunnelid);
774: Freee(ptrs->sessionid);
775: Freee(ptrs->winsize);
776: Freee(ptrs->challenge);
777: Freee(ptrs->challengresp);
778: Freee(ptrs->causecode);
779: Freee(ptrs->serialnum);
780: Freee(ptrs->minbps);
781: Freee(ptrs->maxbps);
782: Freee(ptrs->bearer);
783: Freee(ptrs->framing);
784: Freee(ptrs->callednum);
785: Freee(ptrs->callingnum);
786: Freee(ptrs->subaddress);
787: Freee(ptrs->txconnect);
788: Freee(ptrs->rxconnect);
789: Freee(ptrs->channelid);
790: Freee(ptrs->groupid);
791: Freee(ptrs->recvlcp);
792: Freee(ptrs->lastsendlcp);
793: Freee(ptrs->lastrecvlcp);
794: Freee(ptrs->proxyauth);
795: Freee(ptrs->proxyname);
796: Freee(ptrs->proxychallenge);
797: Freee(ptrs->proxyid);
798: Freee(ptrs->proxyres);
799: Freee(ptrs->callerror);
800: Freee(ptrs->accm);
801: Freee(ptrs->seqrequired);
802: Freee(ptrs);
803: *ptrsp = NULL;
804: }
805:
806: /***********************************************************************
807: AVP DECODERS
808: ***********************************************************************/
809:
810: #define DECODE_INITIAL(t) \
811: void \
812: ppp_l2tp_avp_decode_ ## t(const struct ppp_l2tp_avp_info *info, \
813: const struct ppp_l2tp_avp *avp, char *buf, size_t bmax) \
814: { \
815: const struct ppp_l2tp_avp_list list \
816: = { 1, (struct ppp_l2tp_avp *)avp }; \
817: struct ppp_l2tp_avp_ptrs *ptrs; \
818: \
819: if ((ptrs = ppp_l2tp_avp_list2ptrs(&list)) == NULL) { \
820: snprintf(buf, bmax, \
821: "decode failed: %s", strerror(errno)); \
822: goto done; \
823: } \
824: strlcpy(buf, "", bmax);
825:
826: #define DECODE_FINAL \
827: done: \
828: ppp_l2tp_avp_ptrs_destroy(&ptrs); \
829: }
830:
831: #define DECODE_BYTES(p, len) \
832: do { \
833: int _i; \
834: \
835: for (_i = 0; _i < len; _i++) { \
836: snprintf(buf + strlen(buf), \
837: bmax - strlen(buf), "%02x", \
838: ((u_char *)p)[_i]); \
839: } \
840: } while (0);
841:
842: DECODE_INITIAL(MESSAGE_TYPE)
843: {
844: static const char *names[] = {
845: "?0?", "SCCRQ", "SCCRP", "SCCCN", "StopCCN", "?5?",
846: "HELLO", "OCRQ", "OCRP", "OCCN", "ICRQ", "ICRP",
847: "ICCN", "?13?", "CDN", "WEN", "SLI",
848: };
849:
850: if (ptrs->message->mesgtype > sizeof(names) / sizeof(*names)) {
851: snprintf(buf, bmax, "?%u?", ptrs->message->mesgtype);
852: goto done;
853: }
854: strlcpy(buf, names[ptrs->message->mesgtype], bmax);
855: }
856: DECODE_FINAL
857:
858: DECODE_INITIAL(RESULT_CODE)
859: snprintf(buf, bmax, "result=%u error=%u errmsg=\"",
860: ptrs->errresultcode->result, ptrs->errresultcode->error);
861: ppp_util_ascify(buf + strlen(buf), bmax - strlen(buf),
862: ptrs->errresultcode->errmsg, strlen(ptrs->errresultcode->errmsg));
863: strlcat(buf, "\"", bmax);
864: DECODE_FINAL
865:
866: DECODE_INITIAL(PROTOCOL_VERSION)
867: snprintf(buf, bmax, "%u.%u",
868: ptrs->protocol->version, ptrs->protocol->revision);
869: DECODE_FINAL
870:
871: DECODE_INITIAL(FRAMING_CAPABILITIES)
872: snprintf(buf, bmax, "sync=%u async=%u",
873: ptrs->framingcap->sync, ptrs->framingcap->async);
874: DECODE_FINAL
875:
876: DECODE_INITIAL(BEARER_CAPABILITIES)
877: snprintf(buf, bmax, "digital=%u analog=%u",
878: ptrs->bearercap->digital, ptrs->bearercap->analog);
879: DECODE_FINAL
880:
881: DECODE_INITIAL(TIE_BREAKER)
882: snprintf(buf, bmax, "%02x%02x%02x%02x%02x%02x%02x%02x",
883: ((u_char *)ptrs->tiebreaker->value)[0],
884: ((u_char *)ptrs->tiebreaker->value)[1],
885: ((u_char *)ptrs->tiebreaker->value)[2],
886: ((u_char *)ptrs->tiebreaker->value)[3],
887: ((u_char *)ptrs->tiebreaker->value)[4],
888: ((u_char *)ptrs->tiebreaker->value)[5],
889: ((u_char *)ptrs->tiebreaker->value)[6],
890: ((u_char *)ptrs->tiebreaker->value)[7]);
891: DECODE_FINAL
892:
893: DECODE_INITIAL(FIRMWARE_REVISION)
894: snprintf(buf, bmax, "0x%04x", ptrs->firmware->revision);
895: DECODE_FINAL
896:
897: DECODE_INITIAL(HOST_NAME)
898: strlcpy(buf, "\"", bmax);
899: ppp_util_ascify(buf + strlen(buf), bmax - strlen(buf),
900: ptrs->hostname->hostname, strlen(ptrs->hostname->hostname));
901: strlcat(buf, "\"", bmax);
902: DECODE_FINAL
903:
904: DECODE_INITIAL(VENDOR_NAME)
905: strlcpy(buf, "\"", bmax);
906: ppp_util_ascify(buf + strlen(buf), bmax - strlen(buf),
907: ptrs->vendor->vendorname, strlen(ptrs->vendor->vendorname));
908: strlcat(buf, "\"", bmax);
909: DECODE_FINAL
910:
911: DECODE_INITIAL(ASSIGNED_TUNNEL_ID)
912: snprintf(buf, bmax, "0x%04x", ptrs->tunnelid->id);
913: DECODE_FINAL
914:
915: DECODE_INITIAL(RECEIVE_WINDOW_SIZE)
916: snprintf(buf, bmax, "%u", ptrs->winsize->size);
917: DECODE_FINAL
918:
919: DECODE_INITIAL(CHALLENGE)
920: DECODE_BYTES(ptrs->challenge->value, ptrs->challenge->length)
921: DECODE_FINAL
922:
923: DECODE_INITIAL(CAUSE_CODE)
924: snprintf(buf, bmax, "causecode=0x%04x causemsg=0x%02x msg=\"",
925: ptrs->causecode->causecode, ptrs->causecode->causemsg);
926: ppp_util_ascify(buf + strlen(buf), bmax - strlen(buf),
927: ptrs->causecode->message, strlen(ptrs->causecode->message));
928: strlcat(buf, "\"", bmax);
929: DECODE_FINAL
930:
931: DECODE_INITIAL(CHALLENGE_RESPONSE)
932: DECODE_BYTES(ptrs->challengresp->value, 16)
933: DECODE_FINAL
934:
935: DECODE_INITIAL(ASSIGNED_SESSION_ID)
936: snprintf(buf, bmax, "0x%04x", ptrs->sessionid->id);
937: DECODE_FINAL
938:
939: DECODE_INITIAL(CALL_SERIAL_NUMBER)
940: snprintf(buf, bmax, "%u", ptrs->serialnum->serialnum);
941: DECODE_FINAL
942:
943: DECODE_INITIAL(MINIMUM_BPS)
944: snprintf(buf, bmax, "%u", ptrs->minbps->minbps);
945: DECODE_FINAL
946:
947: DECODE_INITIAL(MAXIMUM_BPS)
948: snprintf(buf, bmax, "%u", ptrs->maxbps->maxbps);
949: DECODE_FINAL
950:
951: DECODE_INITIAL(BEARER_TYPE)
952: snprintf(buf, bmax, "digital=%u analog=%u",
953: ptrs->bearer->digital, ptrs->bearer->analog);
954: DECODE_FINAL
955:
956: DECODE_INITIAL(FRAMING_TYPE)
957: snprintf(buf, bmax, "sync=%u async=%u",
958: ptrs->framing->sync, ptrs->framing->async);
959: DECODE_FINAL
960:
961: DECODE_INITIAL(CALLED_NUMBER)
962: strlcpy(buf, "\"", bmax);
963: ppp_util_ascify(buf + strlen(buf), bmax - strlen(buf),
964: ptrs->callednum->number, strlen(ptrs->callednum->number));
965: strlcat(buf, "\"", bmax);
966: DECODE_FINAL
967:
968: DECODE_INITIAL(CALLING_NUMBER)
969: strlcpy(buf, "\"", bmax);
970: ppp_util_ascify(buf + strlen(buf), bmax - strlen(buf),
971: ptrs->callingnum->number, strlen(ptrs->callingnum->number));
972: strlcat(buf, "\"", bmax);
973: DECODE_FINAL
974:
975: DECODE_INITIAL(SUB_ADDRESS)
976: strlcpy(buf, "\"", bmax);
977: ppp_util_ascify(buf + strlen(buf), bmax - strlen(buf),
978: ptrs->subaddress->number, strlen(ptrs->subaddress->number));
979: strlcat(buf, "\"", bmax);
980: DECODE_FINAL
981:
982: DECODE_INITIAL(TX_CONNECT_SPEED)
983: snprintf(buf, bmax, "%u", ptrs->txconnect->bps);
984: DECODE_FINAL
985:
986: DECODE_INITIAL(PHYSICAL_CHANNEL_ID)
987: snprintf(buf, bmax, "0x%08x", ptrs->channelid->channel);
988: DECODE_FINAL
989:
990: DECODE_INITIAL(INITIAL_RECV_CONFREQ)
991: // ppp_fsm_options_decode(lcp_opt_desc,
992: // ptrs->recvlcp->data, ptrs->recvlcp->length, buf, bmax);
993: DECODE_FINAL
994:
995: DECODE_INITIAL(LAST_SENT_CONFREQ)
996: // ppp_fsm_options_decode(lcp_opt_desc,
997: // ptrs->lastsendlcp->data, ptrs->lastsendlcp->length, buf, bmax);
998: DECODE_FINAL
999:
1000: DECODE_INITIAL(LAST_RECV_CONFREQ)
1001: // ppp_fsm_options_decode(lcp_opt_desc,
1002: // ptrs->lastrecvlcp->data, ptrs->lastrecvlcp->length, buf, bmax);
1003: DECODE_FINAL
1004:
1005: DECODE_INITIAL(PROXY_AUTHEN_TYPE)
1006: snprintf(buf, bmax, "%u", ptrs->proxyauth->type);
1007: DECODE_FINAL
1008:
1009: DECODE_INITIAL(PROXY_AUTHEN_NAME)
1010: strlcpy(buf, "\"", bmax);
1011: ppp_util_ascify(buf + strlen(buf), bmax - strlen(buf),
1012: ptrs->proxyname->data, strlen(ptrs->proxyname->data));
1013: strlcat(buf, "\"", bmax);
1014: DECODE_FINAL
1015:
1016: DECODE_INITIAL(PROXY_AUTHEN_CHALLENGE)
1017: DECODE_BYTES(ptrs->proxychallenge->data, ptrs->proxychallenge->length)
1018: DECODE_FINAL
1019:
1020: DECODE_INITIAL(PROXY_AUTHEN_ID)
1021: snprintf(buf, bmax, "%u", ptrs->proxyid->id);
1022: DECODE_FINAL
1023:
1024: DECODE_INITIAL(PROXY_AUTHEN_RESPONSE)
1025: DECODE_BYTES(ptrs->proxyres->data, ptrs->proxyres->length)
1026: DECODE_FINAL
1027:
1028: DECODE_INITIAL(CALL_ERRORS)
1029: snprintf(buf, bmax, "crc=%u frame=%u overrun=%u"
1030: "buffer=%u timeout=%u alignment=%u",
1031: ptrs->callerror->crc, ptrs->callerror->frame,
1032: ptrs->callerror->overrun, ptrs->callerror->buffer,
1033: ptrs->callerror->timeout, ptrs->callerror->alignment);
1034: DECODE_FINAL
1035:
1036: DECODE_INITIAL(ACCM)
1037: snprintf(buf, bmax, "xmit=0x%08x recv=0x%08x",
1038: ptrs->accm->xmit, ptrs->accm->recv);
1039: DECODE_FINAL
1040:
1041: DECODE_INITIAL(RANDOM_VECTOR)
1042: DECODE_BYTES(avp->value, avp->vlen)
1043: DECODE_FINAL
1044:
1045: DECODE_INITIAL(PRIVATE_GROUP_ID)
1046: DECODE_BYTES(ptrs->groupid->data, ptrs->groupid->length)
1047: DECODE_FINAL
1048:
1049: DECODE_INITIAL(RX_CONNECT_SPEED)
1050: snprintf(buf, bmax, "%u", ptrs->rxconnect->bps);
1051: DECODE_FINAL
1052:
1053: DECODE_INITIAL(SEQUENCING_REQUIRED)
1054: DECODE_FINAL
1055:
1056: