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