projects / openwrt.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
add wrt54g(s) image support to mtd (required for webif firmware update rewrite)
[openwrt.git] / package / l2tpd / patches / 01-debian-2.patch
1 --- l2tpd-0.70-pre20031121.orig/Makefile
2 +++ l2tpd-0.70-pre20031121/Makefile
3 @@ -28,7 +28,8 @@
4 # become runtime options) debugging flags
5 #
6 #DFLAGS= -g -O2 -DDEBUG_PPPD
7 -DFLAGS= -g -O2 -DDEBUG_PPPD -DDEBUG_CONTROL -DDEBUG_ENTROPY
8 +#DFLAGS= -g -O2 -Wall -DDEBUG_PPPD -DDEBUG_CONTROL -DDEBUG_ENTROPY
9 +DFLAGS= -ggdb -Wall -DDEBUG_PPPD -DDEBUG_CONTROL -DDEBUG_ENTROPY
10 #
11 # Uncomment the next line for Linux
12 #
13 @@ -58,7 +59,7 @@
14
15 FFLAGS= -DIP_ALLOCATION
16
17 -CFLAGS= $(DFLAGS) -Wall -DSANITY $(OSFLAGS) $(FFLAGS)
18 +CFLAGS= $(DFLAGS) -Wall -DSANITY $(OSFLAGS) $(FFLAGS)
19 HDRS=l2tp.h avp.h misc.h control.h call.h scheduler.h file.h aaa.h md5.h
20 OBJS=l2tpd.o pty.o misc.o control.o avp.o call.o network.o avpsend.o scheduler.o file.o aaa.o md5.o
21 LIBS= $(OSLIB) # -lefence # efence for malloc checking
22 --- l2tpd-0.70-pre20031121.orig/control.c
23 +++ l2tpd-0.70-pre20031121/control.c
24 @@ -227,7 +227,7 @@
25 add_bearer_caps_avp (buf, t->ourbc);
26 /* FIXME: Tie breaker */
27 add_firmware_avp (buf);
28 - add_hostname_avp (buf);
29 + add_hostname_avp (buf, t);
30 add_vendor_avp (buf);
31 add_tunnelid_avp (buf, t->ourtid);
32 if (t->ourrws >= 0)
33 @@ -346,7 +346,6 @@
34 "%s: Peer did not specify assigned tunnel ID. Closing.\n",
35 __FUNCTION__);
36 set_error (c, VENDOR_ERROR, "Specify your assigned tunnel ID");
37 - c->needclose = -1;
38 return -EINVAL;
39 }
40 if (!(t->lns = get_lns (t)))
41 @@ -356,7 +355,6 @@
42 "%s: Denied connection to unauthorized peer %s\n",
43 __FUNCTION__, IPADDY (t->peer.sin_addr));
44 set_error (c, VENDOR_ERROR, "No Authorization");
45 - c->needclose = -1;
46 return -EINVAL;
47 }
48 t->ourrws = t->lns->tun_rws;
49 @@ -368,7 +366,6 @@
50 "%s: Peer did not specify framing capability. Closing.\n",
51 __FUNCTION__);
52 set_error (c, VENDOR_ERROR, "Specify framing capability");
53 - c->needclose = -1;
54 return -EINVAL;
55 }
56 /* FIXME: Do we need to be sure they specified a version number?
57 @@ -380,7 +377,6 @@
58 if (DEBUG) log(LOG_DEBUG,
59 "%s: Peer did not specify bearer capability. Closing.\n",__FUNCTION__);
60 set_error(c, VENDOR_ERROR, "Specify bearer capability");
61 - c->needclose = -1;
62 return -EINVAL;
63 } */
64 if ((!strlen (t->hostname)) && ((t->chal_us.state) || ((t->lns->challenge))))
65 @@ -390,7 +386,6 @@
66 "%s: Peer did not specify hostname. Closing.\n",
67 __FUNCTION__);
68 set_error (c, VENDOR_ERROR, "Specify your hostname");
69 - c->needclose = -1;
70 return -EINVAL;
71 }
72 y = tunnels.head;
73 @@ -427,7 +422,7 @@
74 add_frame_caps_avp (buf, t->ourfc);
75 add_bearer_caps_avp (buf, t->ourbc);
76 add_firmware_avp (buf);
77 - add_hostname_avp (buf);
78 + add_hostname_avp (buf, t);
79 add_vendor_avp (buf);
80 add_tunnelid_avp (buf, t->ourtid);
81 if (t->ourrws >= 0)
82 @@ -481,7 +476,6 @@
83 "%s: Peer did not specify framing capability. Closing.\n",
84 __FUNCTION__);
85 set_error (c, VENDOR_ERROR, "Specify framing capability");
86 - c->needclose = -1;
87 return -EINVAL;
88 }
89 /* FIXME: Do we need to be sure they specified a version number?
90 @@ -493,7 +487,6 @@
91 if (DEBUG) log(LOG_DEBUG,
92 "%s: Peer did not specify bearer capability. Closing.\n",__FUNCTION__);
93 set_error(c, VENDOR_ERROR, "Specify bearer capability");
94 - c->needclose = -1;
95 return -EINVAL;
96 } */
97 if ((!strlen (t->hostname)) && ((t->chal_them.state) || ((t->chal_us.state))))
98 @@ -503,7 +496,6 @@
99 "%s: Peer did not specify hostname. Closing.\n",
100 __FUNCTION__);
101 set_error (c, VENDOR_ERROR, "Specify your hostname");
102 - c->needclose = -1;
103 return -EINVAL;
104 }
105 if (t->tid <= 0)
106 @@ -513,7 +505,6 @@
107 "%s: Peer did not specify assigned tunnel ID. Closing.\n",
108 __FUNCTION__);
109 set_error (c, VENDOR_ERROR, "Specify your assigned tunnel ID");
110 - c->needclose = -1;
111 return -EINVAL;
112 }
113 if (t->chal_them.state)
114 @@ -524,7 +515,6 @@
115 set_error (c, VENDOR_ERROR, "No secret key on our side");
116 log (LOG_WARN, "%s: No secret key for authenticating '%s'\n",
117 __FUNCTION__, t->hostname);
118 - c->needclose = -1;
119 return -EINVAL;
120 }
121 if (memcmp
122 @@ -534,7 +524,6 @@
123 "Invalid challenge authentication");
124 log (LOG_DEBUG, "%s: Invalid authentication for host '%s'\n",
125 __FUNCTION__, t->hostname);
126 - c->needclose = -1;
127 return -EINVAL;
128 }
129 }
130 @@ -546,7 +535,6 @@
131 log (LOG_WARN, "%s: No secret for authenticating to '%s'\n",
132 __FUNCTION__, t->hostname);
133 set_error (c, VENDOR_ERROR, "No secret key on our end");
134 - c->needclose = -1;
135 return -EINVAL;
136 };
137 }
138 @@ -606,7 +594,6 @@
139 "Invalid challenge authentication");
140 log (LOG_DEBUG, "%s: Invalid authentication for host '%s'\n",
141 __FUNCTION__, t->hostname);
142 - c->needclose = -1;
143 return -EINVAL;
144 }
145 }
146 @@ -1584,6 +1571,14 @@
147 wbuf[pos++] = e;
148 for (x = 0; x < buf->len; x++)
149 {
150 + // we must at least still have 4 bytes left in the worst case scenario:
151 + // 1 for a possible escape, 1 for the value and 1 to end the PPP stream.
152 + if(pos >= (sizeof(wbuf) - 4)) {
153 + if(DEBUG)
154 + log(LOG_CRIT, "%s: rx packet is too big after PPP encoding (size %u, max is %u)\n",
155 + __FUNCTION__, buf->len, MAX_RECV_SIZE);
156 + return -EINVAL;
157 + }
158 e = *((char *) buf->start + x);
159 if ((e < 0x20) || (e == PPP_ESCAPE) || (e == PPP_FLAG))
160 {
161 @@ -1592,7 +1587,6 @@
162 wbuf[pos++] = PPP_ESCAPE;
163 }
164 wbuf[pos++] = e;
165 -
166 }
167 wbuf[pos++] = PPP_FLAG;
168 x = write (c->fd, wbuf, pos);
169 --- l2tpd-0.70-pre20031121.orig/misc.h
170 +++ l2tpd-0.70-pre20031121/misc.h
171 @@ -80,4 +80,11 @@
172 extern void safe_copy (char *, char *, int);
173 extern void opt_destroy (struct ppp_opts *);
174 extern struct ppp_opts *add_opt (struct ppp_opts *, char *, ...);
175 +extern u_int16_t get16(u_int8_t *);
176 +extern u_int32_t get32(u_int8_t *);
177 +extern u_int64_t get64(u_int8_t *);
178 +extern void set16(u_int8_t *, u_int16_t);
179 +extern void set32(u_int8_t *, u_int32_t);
180 +extern void set64(u_int8_t *, u_int64_t);
181 +
182 #endif
183 --- l2tpd-0.70-pre20031121.orig/avp.h
184 +++ l2tpd-0.70-pre20031121/avp.h
185 @@ -19,22 +19,35 @@
186
187 struct avp_hdr
188 {
189 - _u16 length;
190 - _u16 vendorid;
191 - _u16 attr;
192 + u_int16_t length;
193 + u_int16_t vendorid;
194 + u_int16_t attr;
195 };
196
197 +#define AVP_F_MANDATORY 0x1
198 +#define AVP_F_FIXLEN 0x2
199 +#define AVP_F_ASCII 0x4
200 +
201 struct avp
202 {
203 - int num; /* Number of AVP */
204 - int m; /* Set M? */
205 - int (*handler) (struct tunnel *, struct call *, void *, int);
206 - /* This should handle the AVP
207 - taking a tunnel, call, the data,
208 - and the length of the AVP as
209 - parameters. Should return 0
210 - upon success */
211 - char *description; /* A name, for debugging */
212 + u_int32_t num; /* Number of AVP */
213 + u_int32_t flags;
214 + u_int32_t sz; /* expected avp payload size as
215 + * (AVP_F_FIXLEN) ? (==) : (!>=)
216 + * note: size checked is performed
217 + * after unhiding */
218 + u_int8_t allowed_states[8]; /* List of allowed message types for
219 + * a particular avp. Fixed len for
220 + * alignement issues. */
221 +
222 + /* This should handle the AVP taking a tunnel, call,
223 + * the data, and the length of the AVP as parameters.
224 + * Should return 0 upon success */
225 + int (*handle) (struct tunnel *, struct call *, void *, int);
226 +
227 + /* This should handle avp specifics sanity checks */
228 + int (*validate) (int, struct tunnel *, struct call *, void *, int);
229 + char *description; /* A name, for debugging */
230 };
231
232 extern int handle_avps (struct buffer *buf, struct tunnel *t, struct call *c);
233 @@ -84,8 +97,56 @@
234 #define RESULT_CLEAR 1
235 #define RESULT_ERROR 2
236 #define RESULT_EXISTS 3
237 +
238 +/* avp id's */
239 +#define MESSAGE_TYPE_AVP 0
240 +#define RESULT_CODE_AVP 1
241 +#define PROTOCOL_VERSION_AVP 2
242 +#define FRAMING_CAP_AVP 3
243 +#define BEARER_CAP_AVP 4
244 +#define TIE_BREAKER_AVP 5
245 +#define FIRMWARE_REV_AVP 6
246 +#define HOSTNAME_AVP 7
247 +#define VENDOR_NAME_AVP 8
248 +#define ASSIGNED_TUN_ID_AVP 9
249 +#define RX_WIN_SIZE_AVP 10
250 +#define CHALLENGE_AVP 11
251 +#define CHALLENGE_RESP_AVP 12
252 +#define CAUSE_ERROR_AVP 13
253 +#define ASSIGNED_SES_ID_AVP 14
254 +#define SERIAL_NUMBER_AVP 15
255 +#define MIN_BPS_AVP 16
256 +#define MAX_BPS_AVP 17
257 +#define BEARER_TYPE_AVP 18
258 +#define FRAMING_TYPE_AVP 19
259 +#define PACKET_DELAY_AVP 20
260 +#define CALLED_NUMBER_AVP 21
261 +#define CALLING_NUMBER_AVP 22
262 +#define SUB_ADDRESS_AVP 23
263 +#define TX_CONNECT_SPEED_AVP 24
264 +#define PHYS_CHAN_ID_AVP 25
265 +#define INIT_RX_LCP_AVP 26
266 +#define LAST_TX_LCP_AVP 27
267 +#define LAST_RX_LCP_AVP 28
268 +#define PROXY_AUTH_TYPE_AVP 29
269 +#define PROXY_AUTH_NAME_AVP 30
270 +#define PROXY_AUTH_CHAL_AVP 31
271 +#define PROXY_AUTH_ID_AVP 32
272 +#define PROXY_AUTH_CHAL_RESP_AVP 33
273 +#define CALL_ERROR_AVP 34
274 +#define ACCM_AVP 35
275 +#define RANDOM_VECTOR_AVP 36
276 +#define PRIV_GROUP_ID_AVP 37
277 +#define RX_CONNECT_SPEED_AVP 38
278 +#define SEQ_REQUIRED_AVP 39
279 +#define AVP_MAX SEQ_REQUIRED_AVP
280 +
281 +extern int validate_msgtype_avp(int, struct tunnel *, struct call *, void *, int);
282 +extern int validate_gen_avp(int, struct tunnel *, struct call *, void *, int);
283 +
284 extern void encrypt_avp (struct buffer *, _u16, struct tunnel *);
285 extern int decrypt_avp (char *, struct tunnel *);
286 +
287 extern int message_type_avp (struct tunnel *, struct call *, void *, int);
288 extern int protocol_version_avp (struct tunnel *, struct call *, void *, int);
289 extern int framing_caps_avp (struct tunnel *, struct call *, void *, int);
290 @@ -97,12 +158,12 @@
291 extern int receive_window_size_avp (struct tunnel *, struct call *, void *,
292 int);
293 extern int result_code_avp (struct tunnel *, struct call *, void *, int);
294 -extern int assigned_call_avp (struct tunnel *, struct call *, void *, int);
295 +extern int assigned_session_avp (struct tunnel *, struct call *, void *, int);
296 extern int call_serno_avp (struct tunnel *, struct call *, void *, int);
297 extern int bearer_type_avp (struct tunnel *, struct call *, void *, int);
298 extern int call_physchan_avp (struct tunnel *, struct call *, void *, int);
299 -extern int dialed_number_avp (struct tunnel *, struct call *, void *, int);
300 -extern int dialing_number_avp (struct tunnel *, struct call *, void *, int);
301 +extern int called_number_avp (struct tunnel *, struct call *, void *, int);
302 +extern int calling_number_avp (struct tunnel *, struct call *, void *, int);
303 extern int sub_address_avp (struct tunnel *, struct call *, void *, int);
304 extern int frame_type_avp (struct tunnel *, struct call *, void *, int);
305 extern int rx_speed_avp (struct tunnel *, struct call *, void *, int);
306 @@ -118,7 +179,7 @@
307 extern int add_avp_rws (struct buffer *, _u16);
308 extern int add_tunnelid_avp (struct buffer *, _u16);
309 extern int add_vendor_avp (struct buffer *);
310 -extern int add_hostname_avp (struct buffer *);
311 +extern int add_hostname_avp (struct buffer *, struct tunnel*);
312 extern int add_firmware_avp (struct buffer *);
313 extern int add_bearer_caps_avp (struct buffer *buf, _u16 caps);
314 extern int add_frame_caps_avp (struct buffer *buf, _u16 caps);
315 --- l2tpd-0.70-pre20031121.orig/network.c
316 +++ l2tpd-0.70-pre20031121/network.c
317 @@ -214,6 +214,8 @@
318 t->self->needclose = -1;
319 }
320 }
321 + free(buf->rstart);
322 + free(buf);
323 }
324 else
325 {
326 @@ -371,7 +373,9 @@
327 if (debug_network)
328 {
329 log (LOG_DEBUG, "%s: recv packet from %s, size = %d," \
330 -"tunnel = %d, call = %d\n", __FUNCTION__, inet_ntoa (from.sin_addr), recvsize, tunnel, call);
331 + "tunnel = %d, call = %d\n", __func__,
332 + inet_ntoa (from.sin_addr), recvsize,
333 + tunnel, call);
334 }
335 if (packet_dump)
336 {
337 --- l2tpd-0.70-pre20031121.orig/aaa.c
338 +++ l2tpd-0.70-pre20031121/aaa.c
339 @@ -209,9 +209,11 @@
340 __FUNCTION__, u, t, s);
341 #endif
342 strncpy (secret, s, size);
343 + fclose(f);
344 return -1;
345 }
346 }
347 + fclose(f);
348 return 0;
349 }
350
351 --- l2tpd-0.70-pre20031121.orig/l2tpd.c
352 +++ l2tpd-0.70-pre20031121/l2tpd.c
353 @@ -266,6 +266,9 @@
354 /* erase pid file */
355 unlink (gconfig.pidfile);
356
357 + /* erase control pipe */
358 + unlink(CONTROL_PIPE);
359 +
360 exit (1);
361 }
362
363 @@ -333,13 +336,17 @@
364 tcgetattr (c->fd, &ptyconf);
365 *(c->oldptyconf) = ptyconf;
366 ptyconf.c_cflag &= ~(ICANON | ECHO);
367 - ptyconf.c_lflag &= ~ECHO;
368 + ptyconf.c_lflag &= ~ECHO;
369 tcsetattr (c->fd, TCSANOW, &ptyconf);
370
371 snprintf (tty, sizeof (tty), "/dev/tty%c%c", a, b);
372 fd2 = open (tty, O_RDWR);
373 - stropt[pos++] = strdup(tty);
374 - stropt[pos] = NULL;
375 + if(!fd2)
376 + log(LOG_WARN, "unable to open tty %s", tty);
377 +
378 + /* XXX JEF: CHECK ME */
379 + stropt[pos++] = strdup(tty);
380 + stropt[pos] = NULL;
381
382 #ifdef USE_KERNEL
383 }
384 @@ -623,7 +630,13 @@
385 {
386 struct lac *lac;
387 lac = (struct lac *) data;
388 - if (!lac->active)
389 +
390 + if (!lac)
391 + {
392 + log (LOG_WARN, "%s : called on NULL lac!\n", __FUNCTION__);
393 + return;
394 + }
395 + if (!lac->active)
396 {
397 log (LOG_DEBUG, "%s: LAC %s not active", __FUNCTION__, lac->entname);
398 return;
399 @@ -635,11 +648,6 @@
400 log (LOG_LOG, "%s: maximum retries exceeded.\n", __FUNCTION__);
401 return;
402 }
403 - if (!lac)
404 - {
405 - log (LOG_WARN, "%s : called on NULL lac!\n", __FUNCTION__);
406 - return;
407 - }
408 if (!lac->t)
409 {
410 #ifdef DEGUG_MAGIC
411 @@ -774,12 +782,7 @@
412 void do_control ()
413 {
414 char buf[1024];
415 - char *host;
416 - char *tunstr;
417 - char *callstr;
418 -
419 - char *sub_str; /* jz: use by the strtok function */
420 - char *tmp_ptr; /* jz: use by the strtok function */
421 + char *host, *tunstr, *callstr, *tmpstr;
422 struct lac *lac;
423 int call;
424 int tunl;
425 @@ -792,24 +795,39 @@
426 if (buf[cnt - 1] == '\n')
427 buf[--cnt] = 0;
428 #ifdef DEBUG_CONTROL
429 - log (LOG_DEBUG, "%s: Got message %s (%d bytes long)\n",
430 + log (LOG_DEBUG, "%s: Got message \"%s\" (%d bytes long)\n",
431 __FUNCTION__, buf, cnt);
432 #endif
433 switch (buf[0])
434 {
435 case 't':
436 - host = strchr (buf, ' ') + 1;
437 + host = strchr (buf, ' ');
438 + if(!host)
439 + goto out;
440 + host++;
441 #ifdef DEBUG_CONTROL
442 log (LOG_DEBUG, "%s: Attempting to tunnel to %s\n",
443 __FUNCTION__, host);
444 #endif
445 l2tp_call (host, UDP_LISTEN_PORT, NULL, NULL);
446 break;
447 - case 'c':
448 -
449 - switch_io = 1; /* jz: Switch for Incoming - Outgoing Calls */
450 -
451 - tunstr = strchr (buf, ' ') + 1;
452 + case 'c': /* option 'c' for incoming call */
453 + case 'o': /* option 'o' for outgoing call */
454 + tunstr = strchr (buf, ' ');
455 + if(!tunstr)
456 + goto out;
457 + tunstr++;
458 +
459 + if(buf[0] == 'c')
460 + switch_io = 1; /* Switch for Incoming Calls */
461 + else {
462 + switch_io = 0; /* Switch for Outgoing Calls */
463 + tmpstr = strchr(tunstr, ' ');
464 + if(!tmpstr)
465 + goto out;
466 + strncpy(dial_no_tmp,tmpstr, sizeof(*dial_no_tmp));
467 + }
468 +
469 lac = laclist;
470 while (lac)
471 {
472 @@ -842,52 +860,12 @@
473 #endif
474 lac_call (tunl, NULL, NULL);
475 break;
476 -
477 - case 'o': /* jz: option 'o' for doing a outgoing call */
478 -
479 - switch_io = 0; /* jz: Switch for incoming - outgoing Calls */
480 -
481 - sub_str = strchr (buf, ' ') + 1;
482 -
483 - tunstr = strtok (sub_str, " "); /* jz: using strtok function to get */
484 - tmp_ptr = strtok (NULL, " "); /* params out of the pipe */
485 - strcpy (dial_no_tmp, tmp_ptr);
486 -
487 - lac = laclist;
488 - while (lac)
489 - {
490 - if (!strcasecmp (lac->entname, tunstr))
491 - {
492 - lac->active = -1;
493 - lac->rtries = 0;
494 - if (!lac->c)
495 - magic_lac_dial (lac);
496 - else
497 - log (LOG_DEBUG,
498 - "%s: Session '%s' already active!\n",
499 - __FUNCTION__, lac->entname);
500 - break;
501 - }
502 - lac = lac->next;
503 - }
504 - if (lac)
505 - break;
506 - tunl = atoi (tunstr);
507 - if (!tunl)
508 - {
509 - log (LOG_DEBUG, "%s: No such tunnel '%s'\n", __FUNCTION__,
510 - tunstr);
511 - break;
512 - }
513 -#ifdef DEBUG_CONTROL
514 - log (LOG_DEBUG, "%s: Attempting to call on tunnel %d\n",
515 - __FUNCTION__, tunl);
516 -#endif
517 - lac_call (tunl, NULL, NULL);
518 - break;
519 -
520 case 'h':
521 - callstr = strchr (buf, ' ') + 1;
522 + callstr = strchr (buf, ' ');
523 + if(!callstr)
524 + goto out;
525 + callstr++;
526 +
527 call = atoi (callstr);
528 #ifdef DEBUG_CONTROL
529 log (LOG_DEBUG, "%s: Attempting to call %d\n", __FUNCTION__,
530 @@ -896,7 +874,11 @@
531 lac_hangup (call);
532 break;
533 case 'd':
534 - tunstr = strchr (buf, ' ') + 1;
535 + tunstr = strchr (buf, ' ');
536 + if(!tunstr)
537 + goto out;
538 + tunstr++;
539 +
540 lac = laclist;
541 while (lac)
542 {
543 @@ -937,6 +919,8 @@
544 }
545 }
546 }
547 +
548 +out:
549 /* Otherwise select goes nuts */
550 close (control_fd);
551 control_fd = open (CONTROL_PIPE, O_RDONLY | O_NONBLOCK, 0600);
552 @@ -1002,7 +986,6 @@
553 int pid=0;
554 int i,l;
555 char buf[STRLEN];
556 - int pidfilewritten=0;
557
558 if((pid = fork()) < 0) {
559 log(LOG_LOG, "%s: Unable to fork ()\n",__FUNCTION__);
560 @@ -1012,56 +995,52 @@
561 else if (pid)
562 exit(0);
563
564 - close(0);
565 - close(1);
566 - close(2);
567 +
568 + close(0);
569 + close(1);
570 + close(2);
571 + dup2(open("/dev/null", O_RDONLY), 0);
572 + dup2(open("/dev/null", O_RDONLY), 1);
573 + dup2(open("/dev/null", O_RDONLY), 2);
574
575 /* Read previous pid file. */
576 - if ((i = open(gconfig.pidfile,O_RDONLY)) > 0) {
577 - l=read(i,buf,sizeof(buf)-1);
578 - if (i < 0) {
579 - log(LOG_LOG, "%s: Unable to read pid file [%s]\n",
580 - __FUNCTION__, gconfig.pidfile);
581 - }
582 - buf[i] = '\0';
583 - pid = atoi(buf);
584 -
585 - /* If the previous server process is not still running,
586 - write a new pid file immediately. */
587 - if (pid && (pid == getpid () || kill (pid, 0) < 0)) {
588 - unlink (gconfig.pidfile);
589 - if ((i = open (gconfig.pidfile, O_WRONLY | O_CREAT, 0640)) >= 0)
590 - {
591 - snprintf (buf, sizeof(buf), "%d\n", (int)getpid());
592 - write (i, buf, strlen(buf));
593 - close (i);
594 - pidfilewritten = 1;
595 - }
596 + if((i = open(gconfig.pidfile,O_RDONLY)) > 0) {
597 + l=read(i,buf,sizeof(buf)-1);
598 + if (l >= 0) {
599 + buf[l] = '\0';
600 + pid = atoi(buf);
601 }
602 - else
603 - {
604 + close(i);
605 +
606 + /* if pid is read and process exist exit */
607 + if(pid && !kill(pid, 0)) {
608 log(LOG_LOG, "%s: There's already a l2tpd server running.\n",
609 __FUNCTION__);
610 close(server_socket);
611 exit(1);
612 }
613 +
614 + /* remove stalled pid file */
615 + unlink(gconfig.pidfile);
616 }
617
618 pid = setsid();
619
620 - if(! pidfilewritten) {
621 - unlink(gconfig.pidfile);
622 - if ((i = open (gconfig.pidfile, O_WRONLY | O_CREAT, 0640)) >= 0) {
623 - snprintf (buf, strlen(buf), "%d\n", (int)getpid());
624 - write (i, buf, strlen(buf));
625 - close (i);
626 - pidfilewritten = 1;
627 - }
628 - }
629 + /* create new pid file */
630 + if ((i = open (gconfig.pidfile, O_WRONLY | O_CREAT, 0644)) >= 0) {
631 + snprintf (buf, sizeof(buf), "%d", (int)getpid());
632 + write (i, buf, strlen(buf));
633 + close (i);
634 + }
635 + else {
636 + log(LOG_LOG, "%s: could not write pid file %s error %d",
637 + __FUNCTION__, gconfig.pidfile, i);
638 + close(server_socket);
639 + exit(1);
640 + }
641 }
642
643
644 -
645 void init (int argc,char *argv[])
646 {
647 struct lac *lac;
648 @@ -1103,10 +1082,6 @@
649 }
650 log (LOG_LOG, "l2tpd version " SERVER_VERSION " started on %s PID:%d\n",
651 hostname, getpid ());
652 - log (LOG_LOG,
653 - "Written by Mark Spencer, Copyright (C) 1998, Adtran, Inc.\n");
654 - log (LOG_LOG, "Forked by Scott Balmos and David Stipp, (C) 2001\n");
655 - log (LOG_LOG, "Inherited by Jeff McAdams, (C) 2002\n");
656 listenaddr.s_addr = gconfig.listenaddr;
657 log (LOG_LOG, "%s version %s on a %s, listening on IP address %s, port %d\n", uts.sysname,
658 uts.release, uts.machine, inet_ntoa(listenaddr), gconfig.port);
659 --- l2tpd-0.70-pre20031121.orig/misc.c
660 +++ l2tpd-0.70-pre20031121/misc.c
661 @@ -301,3 +301,42 @@
662 return -1;
663 }
664 }
665 +
666 +u_int16_t get16(u_int8_t *p) {
667 + return p[0] << 8 | p[1];
668 +}
669 +
670 +u_int32_t get32(u_int8_t *p) {
671 + return p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3];
672 +}
673 +
674 +u_int64_t get64(u_int8_t *p) {
675 + return (u_int64_t)p[0] << 56 | (u_int64_t)p[1] << 48 |
676 + (u_int64_t)p[2] << 40 | (u_int64_t)p[3] << 32 |
677 + (u_int64_t)p[4] << 24 | (u_int64_t)p[5] << 16 |
678 + (u_int64_t)p[6] << 8 | (u_int64_t)p[7];
679 +}
680 +
681 +void set16(u_int8_t *cp, u_int16_t x) {
682 + *cp++ = x >> 8;
683 + *cp = x & 0xff;
684 +}
685 +
686 +void set32(u_int8_t *cp, u_int32_t x) {
687 + *cp++ = x >> 24;
688 + *cp++ = (x >> 16) & 0xff;
689 + *cp++ = (x >> 8) & 0xff;
690 + *cp = x & 0xff;
691 +}
692 +
693 +void set64(u_int8_t *cp, u_int64_t x) {
694 + *cp++ = x >> 56;
695 + *cp++ = (x >> 48) & 0xff;
696 + *cp++ = (x >> 40) & 0xff;
697 + *cp++ = (x >> 32) & 0xff;
698 + *cp++ = (x >> 24) & 0xff;
699 + *cp++ = (x >> 16) & 0xff;
700 + *cp++ = (x >> 8) & 0xff;
701 + *cp = x & 0xff;
702 +}
703 +
704 --- l2tpd-0.70-pre20031121.orig/avp.c
705 +++ l2tpd-0.70-pre20031121/avp.c
706 @@ -4,9 +4,12 @@
707 * Layer Two Tunnelling Protocol Daemon
708 * Copyright (C) 1998 Adtran, Inc.
709 * Copyright (C) 2002 Jeff McAdams
710 + * Copyright (C) 2003 Jean-Francois Dive
711 *
712 * Mark Spencer
713 *
714 + * 12/2003 parsing sanitization, Jean-Francois Dive
715 + *
716 * This software is distributed under the terms
717 * of the GPL, which you should have received
718 * along with this source.
719 @@ -20,50 +23,53 @@
720 #include <netinet/in.h>
721 #include "l2tp.h"
722
723 -#define AVP_MAX 39
724 +/* TODO:
725 + * - Tie breaker.
726 + * - Clean Proxy Authentication solution.
727 + */
728
729 +/*****************************************************************************/
730 struct avp avps[] = {
731 -
732 - {0, 1, &message_type_avp, "Message Type"},
733 - {1, 1, &result_code_avp, "Result Code"},
734 - {2, 1, &protocol_version_avp, "Protocol Version"},
735 - {3, 1, &framing_caps_avp, "Framing Capabilities"},
736 - {4, 1, &bearer_caps_avp, "Bearer Capabilities"},
737 - {5, 0, NULL, "Tie Breaker"},
738 - {6, 0, &firmware_rev_avp, "Firmware Revision"},
739 - {7, 0, &hostname_avp, "Host Name"},
740 - {8, 1, &vendor_avp, "Vendor Name"},
741 - {9, 1, &assigned_tunnel_avp, "Assigned Tunnel ID"},
742 - {10, 1, &receive_window_size_avp, "Receive Window Size"},
743 - {11, 1, &challenge_avp, "Challenge"},
744 - {12, 0, NULL, "Q.931 Cause Code"},
745 - {13, 1, &chalresp_avp, "Challenge Response"},
746 - {14, 1, &assigned_call_avp, "Assigned Call ID"},
747 - {15, 1, &call_serno_avp, "Call Serial Number"},
748 - {16, 1, NULL, "Minimum BPS"},
749 - {17, 1, NULL, "Maximum BPS"},
750 - {18, 1, &bearer_type_avp, "Bearer Type"},
751 - {19, 1, &frame_type_avp, "Framing Type"},
752 - {20, 1, &packet_delay_avp, "Packet Processing Delay"},
753 - {21, 1, &dialed_number_avp, "Dialed Number"},
754 - {22, 1, &dialing_number_avp, "Dialing Number"},
755 - {23, 1, &sub_address_avp, "Sub-Address"},
756 - {24, 1, &tx_speed_avp, "Transmit Connect Speed"},
757 - {25, 1, &call_physchan_avp, "Physical channel ID"},
758 - {26, 0, NULL, "Initial Received LCP Confreq"},
759 - {27, 0, NULL, "Last Sent LCP Confreq"},
760 - {28, 0, NULL, "Last Received LCP Confreq"},
761 - {29, 1, &ignore_avp, "Proxy Authen Type"},
762 - {30, 0, &ignore_avp, "Proxy Authen Name"},
763 - {31, 0, &ignore_avp, "Proxy Authen Challenge"},
764 - {32, 0, &ignore_avp, "Proxy Authen ID"},
765 - {33, 1, &ignore_avp, "Proxy Authen Response"},
766 - {34, 1, NULL, "Call Errors"},
767 - {35, 1, &ignore_avp, "ACCM"},
768 - {36, 1, &rand_vector_avp, "Random Vector"},
769 - {37, 1, NULL, "Private Group ID"},
770 - {38, 0, &rx_speed_avp, "Receive Connect Speed"},
771 - {39, 1, &seq_reqd_avp, "Sequencing Required"}
772 + {0, AVP_F_MANDATORY|AVP_F_FIXLEN, 2, {0}, &message_type_avp, &validate_msgtype_avp, "Message Type"},
773 + {1, AVP_F_MANDATORY, MAXSTRLEN, {CDN, StopCCN}, &result_code_avp, &validate_gen_avp, "Result Code"},
774 + {2, AVP_F_MANDATORY|AVP_F_FIXLEN, 2, {SCCRP, SCCRQ}, &protocol_version_avp, &validate_gen_avp, "Protocol Version"},
775 + {3, AVP_F_MANDATORY|AVP_F_FIXLEN, 4, {SCCRP, SCCRQ}, &framing_caps_avp, &validate_gen_avp, "Framing Capabilities"},
776 + {4, AVP_F_MANDATORY|AVP_F_FIXLEN, 4, {SCCRP, SCCRQ}, &bearer_caps_avp, &validate_gen_avp, "Bearer Capabilities"},
777 + {5, 0, 0, {0}, NULL, NULL, "Tie Breaker"},
778 + {6, AVP_F_FIXLEN, 2, {SCCRP, SCCRQ}, &firmware_rev_avp, &validate_gen_avp, "Firmware Revision"},
779 + {7, AVP_F_ASCII, MAXSTRLEN, {SCCRP, SCCRQ}, &hostname_avp, &validate_gen_avp, "Host Name"},
780 + {8, AVP_F_MANDATORY|AVP_F_ASCII, MAXSTRLEN, {SCCRP, SCCRQ}, &vendor_avp, &validate_gen_avp, "Vendor Name"},
781 + {9, AVP_F_MANDATORY|AVP_F_FIXLEN, 2, {SCCRP, SCCRQ, StopCCN}, &assigned_tunnel_avp, &validate_gen_avp, "Assigned Tunnel ID"},
782 + {10, AVP_F_MANDATORY|AVP_F_FIXLEN, 2,{SCCRP, SCCRQ, OCRP, OCCN, StopCCN}, &receive_window_size_avp, &validate_gen_avp, "Receive Window Size"},
783 + {11, AVP_F_MANDATORY, 128, {SCCRP, SCCRQ}, &challenge_avp, &validate_gen_avp, "Challenge"},
784 + {12, 0, 0, {0}, NULL, NULL, "Q.931 Cause Code"},
785 + {13, AVP_F_MANDATORY, MD_SIG_SIZE, {SCCRP, SCCCN}, &chalresp_avp, &validate_gen_avp, "Challenge Response"},
786 + {14, AVP_F_MANDATORY|AVP_F_FIXLEN, 2, {CDN, ICRP, ICRQ, OCRP, OCRQ}, &assigned_session_avp, &validate_gen_avp, "Assigned Session ID"},
787 + {15, AVP_F_MANDATORY|AVP_F_FIXLEN, 4, {ICRQ, OCRQ}, &call_serno_avp, &validate_gen_avp, "Call Serial Number"},
788 + {16, AVP_F_MANDATORY|AVP_F_FIXLEN, 4, {0}, NULL, NULL, "Minimum BPS"},
789 + {17, AVP_F_MANDATORY|AVP_F_FIXLEN, 4, {0}, NULL, NULL, "Maximum BPS"},
790 + {18, AVP_F_MANDATORY|AVP_F_FIXLEN, 4, {ICRQ, OCRQ}, &bearer_type_avp, &validate_gen_avp, "Bearer Type"},
791 + {19, AVP_F_MANDATORY|AVP_F_FIXLEN, 4, {ICCN, OCRQ, OCCN}, &frame_type_avp, &validate_gen_avp, "Framing Type"},
792 + {20, AVP_F_MANDATORY|AVP_F_FIXLEN, 2, {ICRP, OCRQ, ICCN, OCRP, OCCN}, &packet_delay_avp, &validate_gen_avp, "Packet Processing Delay"},
793 + {21, AVP_F_MANDATORY|AVP_F_ASCII, MAXSTRLEN, {ICRQ, OCRQ}, &called_number_avp, &validate_gen_avp, "Called Number"},
794 + {22, AVP_F_MANDATORY|AVP_F_ASCII, MAXSTRLEN, {ICRQ}, &calling_number_avp, &validate_gen_avp, "Calling Number"},
795 + {23, AVP_F_MANDATORY|AVP_F_ASCII, MAXSTRLEN, {OCRP, ICRQ}, &sub_address_avp, &validate_gen_avp, "Sub-Address"},
796 + {24, AVP_F_MANDATORY|AVP_F_FIXLEN, 4, {ICCN, OCCN, OCRP}, &tx_speed_avp, &validate_gen_avp, "Transmit Connect Speed"},
797 + {25, AVP_F_MANDATORY|AVP_F_FIXLEN, 4, {ICRQ, OCRQ, OCRP, OCCN}, &call_physchan_avp, &validate_gen_avp, "Physical channel ID"},
798 + {26, 0, 0, {0}, NULL, NULL, "Initial Received LCP Confreq"},
799 + {27, 0, 0, {0}, NULL, NULL, "Last Sent LCP Confreq"},
800 + {28, 0, 0, {0}, NULL, NULL, "Last Received LCP Confreq"},
801 + {29, AVP_F_MANDATORY, 0, {0}, &ignore_avp, NULL, "Proxy Authen Type"},
802 + {30, 0, 0, {0}, &ignore_avp, NULL, "Proxy Authen Name"},
803 + {31, 0, 0, {0}, &ignore_avp, NULL, "Proxy Authen Challenge"},
804 + {32, 0, 0, {0}, &ignore_avp, NULL, "Proxy Authen ID"},
805 + {33, AVP_F_MANDATORY, 0, {0}, &ignore_avp, NULL, "Proxy Authen Response"},
806 + {34, AVP_F_MANDATORY|AVP_F_FIXLEN, 26, {0}, NULL, NULL, "Call Errors"},
807 + {35, AVP_F_MANDATORY|AVP_F_FIXLEN, 10, {0}, &ignore_avp, NULL, "ACCM"},
808 + {36, AVP_F_MANDATORY, 1024, {0}, &rand_vector_avp, &validate_gen_avp, "Random Vector"},
809 + {37, AVP_F_MANDATORY, 0, {0}, NULL, NULL, "Private Group ID"},
810 + {38, AVP_F_FIXLEN, 4, {ICCN, OCCN, OCRP}, &rx_speed_avp, &validate_gen_avp, "Receive Connect Speed"},
811 + {39, AVP_F_MANDATORY, 0, {ICCN, OCCN, OCRP}, &seq_reqd_avp, &validate_gen_avp, "Sequencing Required"}
812 };
813
814 char *msgtypes[] = {
815 @@ -111,6 +117,7 @@
816 "Call was connected but no appropriate framing was detect"
817 };
818
819 +/*****************************************************************************/
820 void wrong_length (struct call *c, char *field, int expected, int found,
821 int min)
822 {
823 @@ -126,12 +133,9 @@
824 c->needclose = -1;
825 }
826
827 -/*
828 - * t, c, data, and datalen may be assumed to be defined for all avp's
829 - */
830 -
831 -int message_type_avp (struct tunnel *t, struct call *c, void *data,
832 - int datalen)
833 +/*****************************************************************************/
834 +int validate_msgtype_avp(int attr, struct tunnel *t, struct call *c,
835 + void *data, int datalen)
836 {
837 /*
838 * This will be with every control message. It is critical that this
839 @@ -139,28 +143,9 @@
840 * (assuming sanity check)
841 */
842
843 - _u16 *raw = data;
844 - c->msgtype = ntohs (raw[3]);
845 - if (datalen != 8)
846 - {
847 - if (DEBUG)
848 - log (LOG_DEBUG, "%s: wrong size (%d != 8)\n", __FUNCTION__,
849 - datalen);
850 - wrong_length (c, "Message Type", 8, datalen, 0);
851 - return -EINVAL;
852 - }
853 - if ((c->msgtype > MAX_MSG) || (!msgtypes[c->msgtype]))
854 - {
855 - if (DEBUG)
856 - log (LOG_DEBUG, "%s: unknown message type %d\n", __FUNCTION__,
857 - c->msgtype);
858 - return -EINVAL;
859 - }
860 - if (debug_avp)
861 - if (DEBUG)
862 - log (LOG_DEBUG, "%s: message type %d (%s)\n", __FUNCTION__,
863 - c->msgtype, msgtypes[c->msgtype]);
864 -#ifdef SANITY
865 + u_int8_t *p = data + sizeof(struct avp_hdr);
866 + c->msgtype = get16(p);
867 +
868 if (t->sanity)
869 {
870 /*
871 @@ -172,11 +157,11 @@
872 if (DEBUG)
873 log (LOG_DEBUG,
874 "%s: attempting to negotiate tunnel inside a call!\n",
875 - __FUNCTION__);
876 + __func__);
877 return -EINVAL;
878 }
879
880 - switch (c->msgtype)
881 + switch (get16(p))
882 {
883 case SCCRQ:
884 if ((t->state != 0) && (t->state != SCCRQ))
885 @@ -189,7 +174,7 @@
886 if (DEBUG)
887 log (LOG_DEBUG,
888 "%s: attempting to negotiate SCCRQ with state != 0\n",
889 - __FUNCTION__);
890 + __func__);
891 return -EINVAL;
892 }
893 break;
894 @@ -199,7 +184,7 @@
895 if (DEBUG)
896 log (LOG_DEBUG,
897 "%s: attempting to negotiate SCCRP with state != SCCRQ!\n",
898 - __FUNCTION__);
899 + __func__);
900 return -EINVAL;
901 }
902 break;
903 @@ -209,7 +194,7 @@
904 if (DEBUG)
905 log (LOG_DEBUG,
906 "%s: attempting to negotiate SCCCN with state != SCCRP!\n",
907 - __FUNCTION__);
908 + __func__);
909 return -EINVAL;
910 }
911 break;
912 @@ -219,7 +204,7 @@
913 if (DEBUG)
914 log (LOG_DEBUG,
915 "%s: attempting to negotiate ICRQ when state != SCCCN\n",
916 - __FUNCTION__);
917 + __func__);
918 return -EINVAL;
919 }
920 if (c != t->self)
921 @@ -227,7 +212,7 @@
922 if (DEBUG)
923 log (LOG_DEBUG,
924 "%s: attempting to negotiate ICRQ on a call!\n",
925 - __FUNCTION__);
926 + __func__);
927 return -EINVAL;
928 }
929 break;
930 @@ -237,7 +222,7 @@
931 if (DEBUG)
932 log (LOG_DEBUG,
933 "%s: attempting to negotiate ICRP on tunnel!=SCCCN\n",
934 - __FUNCTION__);
935 + __func__);
936 return -EINVAL;
937 }
938 if (c->state != ICRQ)
939 @@ -245,7 +230,7 @@
940 if (DEBUG)
941 log (LOG_DEBUG,
942 "%s: attempting to negotiate ICRP when state != ICRQ\n",
943 - __FUNCTION__);
944 + __func__);
945 return -EINVAL;
946 }
947 break;
948 @@ -255,7 +240,7 @@
949 if (DEBUG)
950 log (LOG_DEBUG,
951 "%s: attempting to negotiate ICCN when state != ICRP\n",
952 - __FUNCTION__);
953 + __func__);
954 return -EINVAL;
955 }
956 break;
957 @@ -265,7 +250,7 @@
958 if (DEBUG)
959 log (LOG_DEBUG,
960 "%s: attempting to negotiate SLI when state != ICCN\n",
961 - __FUNCTION__);
962 + __func__);
963 return -EINVAL;
964 }
965 break;
966 @@ -275,7 +260,7 @@
967 if (DEBUG)
968 log (LOG_DEBUG,
969 "%s: attempting to negotiate OCRP on tunnel!=SCCCN\n",
970 - __FUNCTION__);
971 + __func__);
972 return -EINVAL;
973 }
974 if (c->state != OCRQ)
975 @@ -283,7 +268,7 @@
976 if (DEBUG)
977 log (LOG_DEBUG,
978 "%s: attempting to negotiate OCRP when state != OCRQ\n",
979 - __FUNCTION__);
980 + __func__);
981 return -EINVAL;
982 }
983 break;
984 @@ -294,7 +279,7 @@
985 if (DEBUG)
986 log (LOG_DEBUG,
987 "%s: attempting to negotiate OCCN when state != OCRQ\n",
988 - __FUNCTION__);
989 + __func__);
990 return -EINVAL;
991 }
992 break;
993 @@ -303,72 +288,33 @@
994 case Hello:
995 break;
996 default:
997 - log (LOG_WARN, "%s: i don't know how to handle %s messages\n",
998 - __FUNCTION__, msgtypes[c->msgtype]);
999 - return -EINVAL;
1000 - }
1001 - }
1002 -#endif
1003 - if (c->msgtype == ICRQ)
1004 - {
1005 - struct call *tmp;
1006 - if (debug_avp)
1007 - {
1008 - if (DEBUG)
1009 - log (LOG_DEBUG, "%s: new incoming call\n", __FUNCTION__);
1010 - }
1011 - tmp = new_call (t);
1012 - if (!tmp)
1013 - {
1014 - log (LOG_WARN, "%s: unable to create new call\n", __FUNCTION__);
1015 + log (LOG_WARN, "%s: unknown messages type %d\n",
1016 + __func__, get16(p));
1017 return -EINVAL;
1018 }
1019 - tmp->next = t->call_head;
1020 - t->call_head = tmp;
1021 - t->count++;
1022 - /*
1023 - * Is this still safe to assume that the head will always
1024 - * be the most recent call being negotiated?
1025 - * Probably... FIXME anyway...
1026 - */
1027 -
1028 }
1029 - return 0;
1030 + return 0;
1031 }
1032
1033 -int rand_vector_avp (struct tunnel *t, struct call *c, void *data,
1034 - int datalen)
1035 -{
1036 - int size;
1037 - _u16 *raw = (_u16 *) data;
1038 - size = (raw[0] & 0x0FFF) - 6;
1039 - if (t->sanity)
1040 - {
1041 - if (size < 0)
1042 - {
1043 - if (DEBUG)
1044 - log (LOG_DEBUG, "%s: Random vector too small (%d < 0)\n",
1045 - __FUNCTION__, size);
1046 - wrong_length (c, "Random Vector", 6, datalen, 1);
1047 - return -EINVAL;
1048 - }
1049 - if (size > MAX_VECTOR_SIZE)
1050 - {
1051 - if (DEBUG)
1052 - log (LOG_DEBUG, "%s: Random vector too large (%d > %d)\n",
1053 - __FUNCTION__, datalen, MAX_VECTOR_SIZE);
1054 - wrong_length (c, "Random Vector", 6, datalen, 1);
1055 - return -EINVAL;
1056 - }
1057 - }
1058 - if (debug_avp)
1059 - log (LOG_DEBUG, "%s: Random Vector of %d octets\n", __FUNCTION__,
1060 - size);
1061 - t->chal_us.vector = (unsigned char *) &raw[3];
1062 - t->chal_us.vector_len = size;
1063 - return 0;
1064 +/*****************************************************************************/
1065 +int validate_gen_avp(int attr, struct tunnel *t, struct call *c,
1066 + void *data, int datalen) {
1067 + (void)data; (void)datalen;
1068 + int i = 0, found = 0;
1069 +
1070 + if(t->sanity) {
1071 + for(i = 0; i < 8; i++) {
1072 + if(c->msgtype == avps[attr].allowed_states[i])
1073 + found++;
1074 + }
1075 + if(!found)
1076 + return -EINVAL;
1077 + }
1078 + return 0;
1079 }
1080
1081 +/* t, c, data, and datalen may be assumed to be defined for all avp's */
1082 +/*****************************************************************************/
1083 int ignore_avp (struct tunnel *t, struct call *c, void *data, int datalen)
1084 {
1085 /*
1086 @@ -383,94 +329,88 @@
1087 *
1088 */
1089 if (debug_avp)
1090 - {
1091 - if (DEBUG)
1092 - log (LOG_DEBUG, "%s : Ignoring AVP\n", __FUNCTION__);
1093 - }
1094 + log (LOG_DEBUG, "%s : Ignoring AVP\n", __func__);
1095 return 0;
1096 }
1097
1098 -int seq_reqd_avp (struct tunnel *t, struct call *c, void *data, int datalen)
1099 +/*****************************************************************************/
1100 +int message_type_avp (struct tunnel *t, struct call *c, void *data,
1101 + int avplen)
1102 {
1103 -#ifdef SANITY
1104 - if (t->sanity)
1105 + u_int8_t *p = data + sizeof(struct avp_hdr);
1106 +
1107 + if(!c->msgtype)
1108 + c->msgtype = get16(p);
1109 +
1110 + if ((c->msgtype > MAX_MSG) || (!msgtypes[c->msgtype]))
1111 {
1112 - if (datalen != 6)
1113 - {
1114 - if (DEBUG)
1115 - log (LOG_DEBUG,
1116 - "%s: avp is incorrect size. %d != 6\n", __FUNCTION__,
1117 - datalen);
1118 - wrong_length (c, "Sequencing Required", 6, datalen, 1);
1119 - return -EINVAL;
1120 - }
1121 - switch (c->msgtype)
1122 + log (LOG_DEBUG, "%s: unknown message type %d\n", __func__,
1123 + c->msgtype);
1124 + return -EINVAL;
1125 + }
1126 + if (debug_avp)
1127 + log (LOG_DEBUG, "%s: message type %d (%s)\n", __func__,
1128 + c->msgtype, msgtypes[c->msgtype]);
1129 + if (c->msgtype == ICRQ)
1130 + {
1131 + struct call *tmp;
1132 + if (debug_avp)
1133 + log (LOG_DEBUG, "%s: new incoming call\n", __func__);
1134 + tmp = new_call (t);
1135 + if (!tmp)
1136 {
1137 - case ICCN:
1138 - break;
1139 - default:
1140 - if (DEBUG)
1141 - log (LOG_DEBUG,
1142 - "%s: sequencing required not appropriate for %s!\n",
1143 - __FUNCTION__, msgtypes[c->msgtype]);
1144 + log (LOG_WARN, "%s: unable to create new call\n", __func__);
1145 return -EINVAL;
1146 }
1147 + tmp->next = t->call_head;
1148 + t->call_head = tmp;
1149 + t->count++;
1150 + /*
1151 + * Is this still safe to assume that the head will always
1152 + * be the most recent call being negotiated?
1153 + * Probably... FIXME anyway...
1154 + */
1155 }
1156 -#endif
1157 + return 0;
1158 +}
1159 +
1160 +/*****************************************************************************/
1161 +int rand_vector_avp (struct tunnel *t, struct call *c, void *data,
1162 + int avplen)
1163 +{
1164 + u_int8_t *p = data + sizeof(struct avp_hdr);
1165 + int datalen = avplen - sizeof(struct avp_hdr);
1166 if (debug_avp)
1167 - {
1168 - if (DEBUG)
1169 - log (LOG_DEBUG, "%s: peer requires sequencing.\n", __FUNCTION__);
1170 - }
1171 + log (LOG_DEBUG, "%s: random vector len %d\n", __func__, datalen);
1172 + t->chal_us.vector = (unsigned char *)p;
1173 + t->chal_us.vector_len = datalen;
1174 + return 0;
1175 +}
1176 +
1177 +/*****************************************************************************/
1178 +int seq_reqd_avp (struct tunnel *t, struct call *c, void *data, int datalen)
1179 +{
1180 + if (debug_avp)
1181 + log (LOG_DEBUG, "%s: peer requires sequencing.\n", __func__);
1182 c->seq_reqd = -1;
1183 return 0;
1184 }
1185
1186 +/*****************************************************************************/
1187 int result_code_avp (struct tunnel *t, struct call *c, void *data,
1188 - int datalen)
1189 + int avplen)
1190 {
1191 - /*
1192 - * Find out what version of l2tp the other side is using.
1193 - * I'm not sure what we're supposed to do with this but whatever..
1194 - */
1195 + u_int8_t *p = data + sizeof(struct avp_hdr);
1196 + int datalen = avplen - sizeof(struct avp_hdr);
1197 + u_int16_t result = get16(p);
1198 + u_int16_t error = get16(p + 2);
1199
1200 - int error;
1201 - int result;
1202 - _u16 *raw = data;
1203 -#ifdef SANITY
1204 - if (t->sanity)
1205 - {
1206 - if (datalen < 10)
1207 - {
1208 - if (DEBUG)
1209 - log (LOG_DEBUG,
1210 - "%s: avp is incorrect size. %d < 10\n", __FUNCTION__,
1211 - datalen);
1212 - wrong_length (c, "Result Code", 10, datalen, 1);
1213 - return -EINVAL;
1214 - }
1215 - switch (c->msgtype)
1216 - {
1217 - case CDN:
1218 - case StopCCN:
1219 - break;
1220 - default:
1221 - if (DEBUG)
1222 - log (LOG_DEBUG,
1223 - "%s: result code not appropriate for %s. Ignoring.\n",
1224 - __FUNCTION__, msgtypes[c->msgtype]);
1225 - return 0;
1226 - }
1227 - }
1228 -#endif
1229 - result = ntohs (raw[3]);
1230 - error = ntohs (raw[4]);
1231 if ((c->msgtype == StopCCN) && ((result > 7) || (result < 1)))
1232 {
1233 if (DEBUG)
1234 log (LOG_DEBUG,
1235 - "%s: result code out of range (%d %d %d). Ignoring.\n",
1236 - __FUNCTION__, result, error, datalen);
1237 + "%s: (StopCCN) result code out of range ! (1 < %d < 7)\n",
1238 + __func__, result);
1239 return 0;
1240 }
1241
1242 @@ -478,1112 +418,348 @@
1243 {
1244 if (DEBUG)
1245 log (LOG_DEBUG,
1246 - "%s: result code out of range (%d %d %d). Ignoring.\n",
1247 - __FUNCTION__, result, error, datalen);
1248 + "%s: (CDN) result code out of range !(1 < %d < 11)\n",
1249 + __func__, result);
1250 return 0;
1251 }
1252
1253 c->error = error;
1254 c->result = result;
1255 - safe_copy (c->errormsg, (char *) &raw[5], datalen - 10);
1256 + memcpy(c->errormsg, (char*)p + 4, datalen - 4);
1257 + c->errormsg[datalen - 4] = '\0';
1258 +
1259 if (debug_avp)
1260 {
1261 - if (DEBUG && (c->msgtype == StopCCN))
1262 + if(c->msgtype == StopCCN)
1263 {
1264 log (LOG_DEBUG,
1265 "%s: peer closing for reason %d (%s), error = %d (%s)\n",
1266 - __FUNCTION__, result, stopccn_result_codes[result], error,
1267 + __func__, result, stopccn_result_codes[result], error,
1268 c->errormsg);
1269 }
1270 else
1271 {
1272 log (LOG_DEBUG,
1273 "%s: peer closing for reason %d (%s), error = %d (%s)\n",
1274 - __FUNCTION__, result, cdn_result_codes[result], error,
1275 + __func__, result, cdn_result_codes[result], error,
1276 c->errormsg);
1277 }
1278 }
1279 return 0;
1280 }
1281
1282 +/*****************************************************************************/
1283 int protocol_version_avp (struct tunnel *t, struct call *c, void *data,
1284 - int datalen)
1285 + int avplen)
1286 {
1287 - /*
1288 - * Find out what version of l2tp the other side is using.
1289 - * I'm not sure what we're supposed to do with this but whatever..
1290 - */
1291 + u_int8_t *p = data + sizeof(struct avp_hdr);
1292
1293 - int ver;
1294 - _u16 *raw = data;
1295 -#ifdef SANITY
1296 - if (t->sanity)
1297 - {
1298 - if (datalen != 8)
1299 - {
1300 - if (DEBUG)
1301 - log (LOG_DEBUG,
1302 - "%s: avp is incorrect size. %d != 8\n", __FUNCTION__,
1303 - datalen);
1304 - wrong_length (c, "Protocol Version", 8, datalen, 1);
1305 - return -EINVAL;
1306 - }
1307 - switch (c->msgtype)
1308 - {
1309 - case SCCRP:
1310 - case SCCRQ:
1311 - break;
1312 - default:
1313 - if (DEBUG)
1314 - log (LOG_DEBUG,
1315 - "%s: protocol version not appropriate for %s. Ignoring.\n",
1316 - __FUNCTION__, msgtypes[c->msgtype]);
1317 - return 0;
1318 - }
1319 - }
1320 -#endif
1321 - ver = ntohs (raw[3]);
1322 if (debug_avp)
1323 - {
1324 - if (DEBUG)
1325 - log (LOG_DEBUG,
1326 - "%s: peer is using version %d, revision %d.\n", __FUNCTION__,
1327 - (ver >> 8), ver & 0xFF);
1328 - }
1329 + log (LOG_DEBUG, "%s: peer is using version %d, revision %d.\n",
1330 + __func__,*p, *(p+1));
1331 return 0;
1332 }
1333
1334 +/*****************************************************************************/
1335 int framing_caps_avp (struct tunnel *t, struct call *c, void *data,
1336 - int datalen)
1337 + int avplen)
1338 {
1339 - /*
1340 - * Retrieve the framing capabilities
1341 - * from the peer
1342 - */
1343 -
1344 - int caps;
1345 - _u16 *raw = data;
1346 + u_int8_t *p = data + sizeof(struct avp_hdr);
1347 + u_int16_t caps = get16(p + 2);
1348
1349 -#ifdef SANITY
1350 - if (t->sanity)
1351 - {
1352 - switch (c->msgtype)
1353 - {
1354 - case SCCRP:
1355 - case SCCRQ:
1356 - break;
1357 - default:
1358 - if (DEBUG)
1359 - log (LOG_DEBUG,
1360 - "%s: framing capabilities not appropriate for %s. Ignoring.\n",
1361 - __FUNCTION__, msgtypes[c->msgtype]);
1362 - return 0;
1363 - }
1364 - if (datalen != 10)
1365 - {
1366 - if (DEBUG)
1367 - log (LOG_DEBUG,
1368 - "%s: avp is incorrect size. %d != 10\n", __FUNCTION__,
1369 - datalen);
1370 - wrong_length (c, "Framming Capabilities", 10, datalen, 0);
1371 - return -EINVAL;
1372 - }
1373 - }
1374 -#endif
1375 - caps = ntohs (raw[4]);
1376 if (debug_avp)
1377 - if (DEBUG)
1378 - log (LOG_DEBUG,
1379 - "%s: supported peer frames:%s%s\n", __FUNCTION__,
1380 - caps & ASYNC_FRAMING ? " async" : "",
1381 - caps & SYNC_FRAMING ? " sync" : "");
1382 + log (LOG_DEBUG, "%s: supported peer frames:%s %s\n", __func__,
1383 + caps & ASYNC_FRAMING ? "async" : "",
1384 + caps & SYNC_FRAMING ? "sync" : "");
1385 +
1386 t->fc = caps & (ASYNC_FRAMING | SYNC_FRAMING);
1387 return 0;
1388 }
1389
1390 +/*****************************************************************************/
1391 int bearer_caps_avp (struct tunnel *t, struct call *c, void *data,
1392 - int datalen)
1393 + int avplen)
1394 {
1395 - /*
1396 - * What kind of bearer channels does our peer support?
1397 - */
1398 - int caps;
1399 - _u16 *raw = data;
1400 + u_int8_t *p = data + sizeof(struct avp_hdr);
1401 + u_int16_t caps = get16(p + 2);
1402
1403 -#ifdef SANITY
1404 - if (t->sanity)
1405 - {
1406 - switch (c->msgtype)
1407 - {
1408 - case SCCRP:
1409 - case SCCRQ:
1410 - break;
1411 - default:
1412 - if (DEBUG)
1413 - log (LOG_DEBUG,
1414 - "%s: bearer capabilities not appropriate for message %s. Ignoring.\n",
1415 - __FUNCTION__, msgtypes[c->msgtype]);
1416 - return 0;
1417 - }
1418 - if (datalen != 10)
1419 - {
1420 - if (DEBUG)
1421 - log (LOG_DEBUG,
1422 - "%s: avp is incorrect size. %d != 10\n", __FUNCTION__,
1423 - datalen);
1424 - wrong_length (c, "Bearer Capabilities", 10, datalen, 0);
1425 - return -EINVAL;
1426 - }
1427 - }
1428 -#endif
1429 - caps = ntohs (raw[4]);
1430 if (debug_avp)
1431 - {
1432 - if (DEBUG)
1433 - {
1434 - log (LOG_DEBUG,
1435 - "%s: supported peer bearers:%s%s\n",
1436 - __FUNCTION__,
1437 - caps & ANALOG_BEARER ? " analog" : "",
1438 - caps & DIGITAL_BEARER ? " digital" : "");
1439 - }
1440 + log (LOG_DEBUG, "%s: supported peer bearers:%s %s\n",
1441 + __func__,
1442 + caps & ANALOG_BEARER ? "analog" : "",
1443 + caps & DIGITAL_BEARER ? "digital" : "");
1444
1445 - }
1446 t->bc = caps & (ANALOG_BEARER | DIGITAL_BEARER);
1447 return 0;
1448 }
1449
1450 -
1451 -/* FIXME: I need to handle tie breakers eventually */
1452 -
1453 +/*****************************************************************************/
1454 int firmware_rev_avp (struct tunnel *t, struct call *c, void *data,
1455 - int datalen)
1456 + int avplen)
1457 {
1458 - /*
1459 - * Report and record remote firmware version
1460 - */
1461 - int ver;
1462 - _u16 *raw = data;
1463 + u_int8_t *p = data + sizeof(struct avp_hdr);
1464
1465 -#ifdef SANITY
1466 - if (t->sanity)
1467 - {
1468 - switch (c->msgtype)
1469 - {
1470 - case SCCRP:
1471 - case SCCRQ:
1472 - break;
1473 - default:
1474 - if (DEBUG)
1475 - log (LOG_DEBUG,
1476 - "%s: firmware revision not appropriate for message %s. Ignoring.\n",
1477 - __FUNCTION__, msgtypes[c->msgtype]);
1478 - return 0;
1479 - }
1480 - if (datalen != 8)
1481 - {
1482 - if (DEBUG)
1483 - log (LOG_DEBUG,
1484 - "%s: avp is incorrect size. %d != 8\n", __FUNCTION__,
1485 - datalen);
1486 - wrong_length (c, "Firmware Revision", 8, datalen, 0);
1487 - return -EINVAL;
1488 - }
1489 - }
1490 -#endif
1491 - ver = ntohs (raw[3]);
1492 + t->firmware = get16(p);
1493 if (debug_avp)
1494 - {
1495 - if (DEBUG)
1496 - log (LOG_DEBUG,
1497 - "%s: peer reports firmware version %d (0x%.4x)\n",
1498 - __FUNCTION__, ver, ver);
1499 - }
1500 - t->firmware = ver;
1501 + log (LOG_DEBUG, "%s: peer reports firmware version %d (0x%.4X)\n",
1502 + __func__, t->firmware, t->firmware);
1503 return 0;
1504 }
1505
1506 +/*****************************************************************************/
1507 int bearer_type_avp (struct tunnel *t, struct call *c, void *data,
1508 - int datalen)
1509 + int avplen)
1510 {
1511 - /*
1512 - * What kind of bearer channel is the call on?
1513 - */
1514 - int b;
1515 - _u16 *raw = data;
1516 + u_int8_t *p = data + sizeof(struct avp_hdr);
1517
1518 -#ifdef SANITY
1519 - if (t->sanity)
1520 - {
1521 - switch (c->msgtype)
1522 - {
1523 - case ICRQ:
1524 - case OCRQ:
1525 - break;
1526 - default:
1527 - if (DEBUG)
1528 - log (LOG_DEBUG,
1529 - "%s: bearer type not appropriate for message %s. Ignoring.\n",
1530 - __FUNCTION__, msgtypes[c->msgtype]);
1531 - return 0;
1532 - }
1533 - if (datalen != 10)
1534 - {
1535 - if (DEBUG)
1536 - log (LOG_DEBUG,
1537 - "%s: avp is incorrect size. %d != 10\n", __FUNCTION__,
1538 - datalen);
1539 - wrong_length (c, "Bearer Type", 10, datalen, 0);
1540 - return -EINVAL;
1541 - }
1542 - }
1543 -#endif
1544 - b = ntohs (raw[4]);
1545 + t->call_head->bearer = get16(p + 2);
1546 if (debug_avp)
1547 - {
1548 - if (DEBUG)
1549 - log (LOG_DEBUG,
1550 - "%s: peer bears:%s\n", __FUNCTION__,
1551 - b & ANALOG_BEARER ? " analog" : "digital");
1552 - }
1553 - t->call_head->bearer = b;
1554 + log (LOG_DEBUG, "%s: peer bears: %s\n", __func__,
1555 + (t->call_head->bearer & ANALOG_BEARER) ? "analog" : "digital");
1556 return 0;
1557 }
1558
1559 -int frame_type_avp (struct tunnel *t, struct call *c, void *data, int datalen)
1560 +/*****************************************************************************/
1561 +int frame_type_avp (struct tunnel *t, struct call *c, void *data, int avplen)
1562 {
1563 - /*
1564 - * What kind of frame channel is the call on?
1565 - */
1566 - int b;
1567 - _u16 *raw = data;
1568 + u_int8_t *p = data + sizeof(struct avp_hdr);
1569
1570 -#ifdef SANITY
1571 - if (t->sanity)
1572 - {
1573 - switch (c->msgtype)
1574 - {
1575 - case ICCN:
1576 - case OCRQ:
1577 - case OCCN:
1578 - break;
1579 - default:
1580 - if (DEBUG)
1581 - log (LOG_DEBUG,
1582 - "%s: frame type not appropriate for message %s. Ignoring.\n",
1583 - __FUNCTION__, msgtypes[c->msgtype]);
1584 - return 0;
1585 - }
1586 - if (datalen != 10)
1587 - {
1588 - if (DEBUG)
1589 - log (LOG_DEBUG,
1590 - "%s: avp is incorrect size. %d != 10\n", __FUNCTION__,
1591 - datalen);
1592 - wrong_length (c, "Frame Type", 10, datalen, 0);
1593 - return -EINVAL;
1594 - }
1595 - }
1596 -#endif
1597 - b = ntohs (raw[4]);
1598 + c->frame = get16(p + 2);
1599 if (debug_avp)
1600 - {
1601 - if (DEBUG)
1602 - log (LOG_DEBUG,
1603 - "%s: peer uses:%s frames\n", __FUNCTION__,
1604 - b & ASYNC_FRAMING ? " async" : "sync");
1605 - }
1606 - c->frame = b;
1607 + log (LOG_DEBUG, "%s: peer uses:%s frames\n", __func__,
1608 + (c->frame & ASYNC_FRAMING) ? "async" : "sync");
1609 return 0;
1610 }
1611
1612 -int hostname_avp (struct tunnel *t, struct call *c, void *data, int datalen)
1613 +/*****************************************************************************/
1614 +int hostname_avp (struct tunnel *t, struct call *c, void *data, int avplen)
1615 {
1616 - /*
1617 - * What is the peer's name?
1618 - */
1619 - int size;
1620 - _u16 *raw = data;
1621 + u_int8_t *p = data + sizeof(struct avp_hdr);
1622 + int datalen = avplen - sizeof(struct avp_hdr);
1623 +
1624 + memcpy(t->hostname, p, datalen);
1625 + t->hostname[datalen] = '\0';
1626
1627 -#ifdef SANITY
1628 - if (t->sanity)
1629 - {
1630 - switch (c->msgtype)
1631 - {
1632 - case SCCRP:
1633 - case SCCRQ:
1634 - break;
1635 - default:
1636 - if (DEBUG)
1637 - log (LOG_DEBUG,
1638 - "%s: hostname not appropriate for message %s. Ignoring.\n",
1639 - __FUNCTION__, msgtypes[c->msgtype]);
1640 - return 0;
1641 - }
1642 - if (datalen < 6)
1643 - {
1644 - if (DEBUG)
1645 - log (LOG_DEBUG,
1646 - "%s: avp is too small. %d < 6\n", __FUNCTION__,
1647 - datalen);
1648 - wrong_length (c, "Hostname", 6, datalen, 1);
1649 - return -EINVAL;
1650 - }
1651 - }
1652 -#endif
1653 - size = raw[0] & 0x0FFF;
1654 - if (size > MAXSTRLEN - 1)
1655 - {
1656 - if (DEBUG)
1657 - log (LOG_DEBUG, "%s: truncating reported hostname (size is %d)\n",
1658 - __FUNCTION__, size);
1659 - size = MAXSTRLEN - 1;
1660 - }
1661 - safe_copy (t->hostname, (char *) &raw[3], size - 6);
1662 if (debug_avp)
1663 - {
1664 - if (DEBUG)
1665 - log (LOG_DEBUG,
1666 - "%s: peer reports hostname '%s'\n", __FUNCTION__,
1667 - t->hostname);
1668 - }
1669 + log (LOG_DEBUG, "%s: peer reports hostname '%s'\n", __func__,
1670 + t->hostname);
1671 +
1672 return 0;
1673 }
1674
1675 -int dialing_number_avp (struct tunnel *t, struct call *c, void *data,
1676 - int datalen)
1677 +/*****************************************************************************/
1678 +int calling_number_avp (struct tunnel *t, struct call *c, void *data,
1679 + int avplen)
1680 {
1681 - /*
1682 - * What is the peer's name?
1683 - */
1684 - int size;
1685 - _u16 *raw = data;
1686 + u_int8_t *p = data + sizeof(struct avp_hdr);
1687 + int datalen = avplen - sizeof(struct avp_hdr);
1688 +
1689 + memcpy(t->call_head->dialing, p, datalen);
1690 + t->call_head->dialing[datalen] = '\0';
1691
1692 -#ifdef SANITY
1693 - if (t->sanity)
1694 - {
1695 - switch (c->msgtype)
1696 - {
1697 - case ICRQ:
1698 - break;
1699 - default:
1700 - if (DEBUG)
1701 - log (LOG_DEBUG,
1702 - "%s: dialing number not appropriate for message %s. Ignoring.\n",
1703 - __FUNCTION__, msgtypes[c->msgtype]);
1704 - return 0;
1705 - }
1706 - if (datalen < 6)
1707 - {
1708 - if (DEBUG)
1709 - log (LOG_DEBUG,
1710 - "%s: avp is too small. %d < 6\n", __FUNCTION__,
1711 - datalen);
1712 - wrong_length (c, "Dialing Number", 6, datalen, 1);
1713 - return -EINVAL;
1714 - }
1715 - }
1716 -#endif
1717 - size = raw[0] & 0x0FFF;
1718 - if (size > MAXSTRLEN - 1)
1719 - {
1720 - if (DEBUG)
1721 - log (LOG_DEBUG,
1722 - "%s: truncating reported dialing number (size is %d)\n",
1723 - __FUNCTION__, size);
1724 - size = MAXSTRLEN - 1;
1725 - }
1726 - safe_copy (t->call_head->dialing, (char *) &raw[3], size);
1727 if (debug_avp)
1728 - {
1729 - if (DEBUG)
1730 - log (LOG_DEBUG,
1731 - "%s: peer reports dialing number '%s'\n", __FUNCTION__,
1732 - t->call_head->dialing);
1733 - }
1734 + log (LOG_DEBUG, "%s: peer reports dialing number '%s'\n", __func__,
1735 + t->call_head->dialing);
1736 +
1737 return 0;
1738 }
1739
1740 -int dialed_number_avp (struct tunnel *t, struct call *c, void *data,
1741 - int datalen)
1742 +/*****************************************************************************/
1743 +int called_number_avp (struct tunnel *t, struct call *c, void *data,
1744 + int avplen)
1745 {
1746 - /*
1747 - * What is the peer's name?
1748 - */
1749 - int size;
1750 - _u16 *raw = data;
1751 + u_int8_t *p = data + sizeof(struct avp_hdr);
1752 + int datalen = avplen - sizeof(struct avp_hdr);
1753 +
1754 + memcpy(t->call_head->dialed, p, datalen);
1755 + t->call_head->dialed[datalen] = '\0';
1756
1757 -#ifdef SANITY
1758 - if (t->sanity)
1759 - {
1760 - switch (c->msgtype)
1761 - {
1762 - case OCRQ:
1763 - case ICRQ:
1764 - break;
1765 - default:
1766 - if (DEBUG)
1767 - log (LOG_DEBUG,
1768 - "%s: dialed number not appropriate for message %s. Ignoring.\n",
1769 - __FUNCTION__, msgtypes[c->msgtype]);
1770 - return 0;
1771 - }
1772 - if (datalen < 6)
1773 - {
1774 - if (DEBUG)
1775 - log (LOG_DEBUG,
1776 - "%s: avp is too small. %d < 6\n", __FUNCTION__,
1777 - datalen);
1778 - wrong_length (c, "Dialed Number", 6, datalen, 1);
1779 - return -EINVAL;
1780 - }
1781 - }
1782 -#endif
1783 - size = raw[0] & 0x0FFF;
1784 - if (size > MAXSTRLEN - 1)
1785 - {
1786 - if (DEBUG)
1787 - log (LOG_DEBUG,
1788 - "%s: truncating reported dialed number (size is %d)\n",
1789 - __FUNCTION__, size);
1790 - size = MAXSTRLEN - 1;
1791 - }
1792 - safe_copy (t->call_head->dialed, (char *) &raw[3], size);
1793 if (debug_avp)
1794 - {
1795 - if (DEBUG)
1796 - log (LOG_DEBUG,
1797 - "%s: peer reports dialed number '%s'\n", __FUNCTION__,
1798 - t->call_head->dialed);
1799 - }
1800 + log (LOG_DEBUG, "%s: peer reports dialed number '%s'\n", __func__,
1801 + t->call_head->dialed);
1802 +
1803 return 0;
1804 }
1805
1806 +/*****************************************************************************/
1807 int sub_address_avp (struct tunnel *t, struct call *c, void *data,
1808 - int datalen)
1809 + int avplen)
1810 {
1811 - /*
1812 - * What is the peer's name?
1813 - */
1814 - int size;
1815 - _u16 *raw = data;
1816 + u_int8_t *p = data + sizeof(struct avp_hdr);
1817 + int datalen = avplen - sizeof(struct avp_hdr);
1818 +
1819 + memcpy(t->call_head->subaddy, p, datalen);
1820 + t->call_head->subaddy[datalen] = '\0';
1821
1822 -#ifdef SANITY
1823 - if (t->sanity)
1824 - {
1825 - switch (c->msgtype)
1826 - {
1827 - case OCRP:
1828 - case ICRQ:
1829 - break;
1830 - default:
1831 - if (DEBUG)
1832 - log (LOG_DEBUG,
1833 - "%s: sub_address not appropriate for message %s. Ignoring.\n",
1834 - __FUNCTION__, msgtypes[c->msgtype]);
1835 - return 0;
1836 - }
1837 - if (datalen < 6)
1838 - {
1839 - if (DEBUG)
1840 - log (LOG_DEBUG,
1841 - "%s: avp is too small. %d < 6\n", __FUNCTION__,
1842 - datalen);
1843 - wrong_length (c, "Sub-address", 6, datalen, 1);
1844 - return -EINVAL;
1845 - }
1846 - }
1847 -#endif
1848 - size = raw[0] & 0x0FFF;
1849 - if (size > MAXSTRLEN - 1)
1850 - {
1851 - if (DEBUG)
1852 - log (LOG_DEBUG,
1853 - "%s: truncating reported sub address (size is %d)\n",
1854 - __FUNCTION__, size);
1855 - size = MAXSTRLEN - 1;
1856 - }
1857 - safe_copy (t->call_head->subaddy, (char *) &raw[3], size);
1858 if (debug_avp)
1859 - {
1860 - if (DEBUG)
1861 - log (LOG_DEBUG,
1862 - "%s: peer reports subaddress '%s'\n", __FUNCTION__,
1863 - t->call_head->subaddy);
1864 - }
1865 + log (LOG_DEBUG, "%s: peer reports subaddress '%s'\n", __func__,
1866 + t->call_head->subaddy);
1867 return 0;
1868 }
1869
1870 -int vendor_avp (struct tunnel *t, struct call *c, void *data, int datalen)
1871 +/*****************************************************************************/
1872 +int vendor_avp (struct tunnel *t, struct call *c, void *data, int avplen)
1873 {
1874 - /*
1875 - * What vendor makes the other end?
1876 - */
1877 - int size;
1878 - _u16 *raw = data;
1879 + u_int8_t *p = data + sizeof(struct avp_hdr);
1880 + int datalen = avplen - sizeof(struct avp_hdr);
1881 +
1882 + memcpy(t->vendor, p, datalen);
1883 + t->vendor[datalen] = '\0';
1884
1885 -#ifdef SANITY
1886 - if (t->sanity)
1887 - {
1888 - switch (c->msgtype)
1889 - {
1890 - case SCCRP:
1891 - case SCCRQ:
1892 - break;
1893 - default:
1894 - if (DEBUG)
1895 - log (LOG_DEBUG,
1896 - "%s: vendor not appropriate for message %s. Ignoring.\n",
1897 - __FUNCTION__, msgtypes[c->msgtype]);
1898 - return 0;
1899 - }
1900 - if (datalen < 6)
1901 - {
1902 - if (DEBUG)
1903 - log (LOG_DEBUG,
1904 - "%s: avp is too small. %d < 6\n", __FUNCTION__,
1905 - datalen);
1906 - wrong_length (c, "Vendor", 6, datalen, 1);
1907 - return -EINVAL;
1908 - }
1909 - }
1910 -#endif
1911 - size = raw[0] & 0x0FFF;
1912 - if (size > MAXSTRLEN - 1)
1913 - {
1914 - if (DEBUG)
1915 - log (LOG_DEBUG, "%s: truncating reported vendor (size is %d)\n",
1916 - __FUNCTION__, size);
1917 - size = MAXSTRLEN - 1;
1918 - }
1919 - safe_copy (t->vendor, (char *) &raw[3], size);
1920 if (debug_avp)
1921 - {
1922 - if (DEBUG)
1923 - log (LOG_DEBUG,
1924 - "%s: peer reports vendor '%s'\n", __FUNCTION__, t->vendor);
1925 - }
1926 + log (LOG_DEBUG, "%s: peer reports vendor '%s'\n", __func__, t->vendor);
1927 return 0;
1928 }
1929
1930 -int challenge_avp (struct tunnel *t, struct call *c, void *data, int datalen)
1931 +/*****************************************************************************/
1932 +int challenge_avp (struct tunnel *t, struct call *c, void *data, int avplen)
1933 {
1934 - /*
1935 - * We are sent a challenge
1936 - */
1937 - _u16 *raw = data;
1938 - int size;
1939 -#ifdef SANITY
1940 - if (t->sanity)
1941 - {
1942 - switch (c->msgtype)
1943 - {
1944 - case SCCRP:
1945 - case SCCRQ:
1946 - break;
1947 - default:
1948 - if (DEBUG)
1949 - log (LOG_DEBUG,
1950 - "%s: challenge not appropriate for message %s. Ignoring.\n",
1951 - __FUNCTION__, msgtypes[c->msgtype]);
1952 - return 0;
1953 - }
1954 - if (datalen < 6)
1955 - {
1956 - if (DEBUG)
1957 - log (LOG_DEBUG,
1958 - "%s: avp is too small. %d < 6\n", __FUNCTION__,
1959 - datalen);
1960 - wrong_length (c, "challenge", 6, datalen, 1);
1961 - return -EINVAL;
1962 - }
1963 - }
1964 -#endif
1965 - /* size = raw[0] & 0x0FFF; */
1966 - /* length field of AVP's is only 10 bits long, not 12 */
1967 - size = raw[0] & 0x03FF;
1968 - size -= sizeof (struct avp_hdr);
1969 - /* if (size != MD_SIG_SIZE)
1970 - {
1971 - log (LOG_DEBUG, "%s: Challenge is not the right length (%d != %d)\n",
1972 - __FUNCTION__, size, MD_SIG_SIZE);
1973 - return -EINVAL;
1974 - } */
1975 - t->chal_us.challenge = malloc(size+1);
1976 - if (t->chal_us.challenge == NULL)
1977 - {
1978 + u_int8_t *p = data + sizeof(struct avp_hdr);
1979 + int datalen = avplen - sizeof(struct avp_hdr);
1980 +
1981 + t->chal_us.challenge = calloc(datalen, 1);
1982 + if (!t->chal_us.challenge)
1983 return -ENOMEM;
1984 - }
1985 - memset(t->chal_us.challenge, 0, size+1);
1986 - bcopy (&raw[3], (t->chal_us.challenge), size);
1987 + memcpy(t->chal_us.challenge, p, datalen);
1988 t->chal_us.state = STATE_CHALLENGED;
1989 +
1990 if (debug_avp)
1991 - {
1992 - log (LOG_DEBUG, "%s: challenge avp found\n", __FUNCTION__);
1993 - }
1994 + log (LOG_DEBUG, "%s: challenge avp found\n", __func__);
1995 +
1996 return 0;
1997 }
1998
1999 -int chalresp_avp (struct tunnel *t, struct call *c, void *data, int datalen)
2000 +/*****************************************************************************/
2001 +int chalresp_avp (struct tunnel *t, struct call *c, void *data, int avplen)
2002 {
2003 - /*
2004 - * We are sent a challenge
2005 - */
2006 - _u16 *raw = data;
2007 - int size;
2008 -#ifdef SANITY
2009 - if (t->sanity)
2010 - {
2011 - switch (c->msgtype)
2012 - {
2013 - case SCCRP:
2014 - case SCCCN:
2015 - break;
2016 - default:
2017 - if (DEBUG)
2018 - log (LOG_DEBUG,
2019 - "%s: challenge response not appropriate for message %s. Ignoring.\n",
2020 - __FUNCTION__, msgtypes[c->msgtype]);
2021 - return 0;
2022 - }
2023 - if (datalen < 6)
2024 - {
2025 - if (DEBUG)
2026 - log (LOG_DEBUG,
2027 - "%s: avp is too small. %d < 6\n", __FUNCTION__,
2028 - datalen);
2029 - wrong_length (c, "challenge", 6, datalen, 1);
2030 - return -EINVAL;
2031 - }
2032 - }
2033 -#endif
2034 - size = raw[0] & 0x0FFF;
2035 - size -= sizeof (struct avp_hdr);
2036 - if (size != MD_SIG_SIZE)
2037 - {
2038 - log (LOG_DEBUG, "%s: Challenge is not the right length (%d != %d)\n",
2039 - __FUNCTION__, size, MD_SIG_SIZE);
2040 - return -EINVAL;
2041 - }
2042 + u_int8_t *p = data + sizeof(struct avp_hdr);
2043
2044 - bcopy (&raw[3], t->chal_them.reply, MD_SIG_SIZE);
2045 - if (debug_avp)
2046 - {
2047 - log (LOG_DEBUG, "%s: Challenge reply found\n", __FUNCTION__);
2048 - }
2049 + memcpy(t->chal_them.reply, p, MD_SIG_SIZE);
2050 + if(debug_avp)
2051 + log(LOG_DEBUG, "%s: Challenge reply found\n", __func__);
2052 return 0;
2053 }
2054
2055 +/*****************************************************************************/
2056 int assigned_tunnel_avp (struct tunnel *t, struct call *c, void *data,
2057 - int datalen)
2058 + int avplen)
2059 {
2060 - /*
2061 - * What is their TID that we must use from now on?
2062 - */
2063 - _u16 *raw = data;
2064 + u_int8_t *p = data + sizeof(struct avp_hdr);
2065 + u_int16_t id = get16(p);
2066
2067 -#ifdef SANITY
2068 - if (t->sanity)
2069 - {
2070 - switch (c->msgtype)
2071 - {
2072 - case SCCRP:
2073 - case SCCRQ:
2074 - case StopCCN:
2075 - break;
2076 - default:
2077 - if (DEBUG)
2078 - log (LOG_DEBUG,
2079 - "%s: tunnel ID not appropriate for message %s. Ignoring.\n",
2080 - __FUNCTION__, msgtypes[c->msgtype]);
2081 - return 0;
2082 - }
2083 - if (datalen != 8)
2084 - {
2085 - if (DEBUG)
2086 - log (LOG_DEBUG,
2087 - "%s: avp is wrong size. %d != 8\n", __FUNCTION__,
2088 - datalen);
2089 - wrong_length (c, "Assigned Tunnel ID", 8, datalen, 0);
2090 - return -EINVAL;
2091 - }
2092 - }
2093 -#endif
2094 if (c->msgtype == StopCCN)
2095 - {
2096 - t->qtid = ntohs (raw[3]);
2097 - }
2098 + t->qtid = id;
2099 else
2100 - {
2101 - t->tid = ntohs (raw[3]);
2102 - }
2103 + t->tid = id;
2104 if (debug_avp)
2105 - {
2106 - if (DEBUG)
2107 - log (LOG_DEBUG,
2108 - "%s: using peer's tunnel %d\n", __FUNCTION__,
2109 - ntohs (raw[3]));
2110 - }
2111 + log (LOG_DEBUG, "%s: using peer's tunnel %d\n", __func__, id);
2112 return 0;
2113 }
2114
2115 -int assigned_call_avp (struct tunnel *t, struct call *c, void *data,
2116 - int datalen)
2117 +/*****************************************************************************/
2118 +int assigned_session_avp (struct tunnel *t, struct call *c, void *data,
2119 + int avplen)
2120 {
2121 - /*
2122 - * What is their CID that we must use from now on?
2123 - */
2124 - _u16 *raw = data;
2125 + u_int8_t *p = data + sizeof(struct avp_hdr);
2126 + u_int16_t id = get16(p);
2127 +
2128 + switch(c->msgtype) {
2129 + case CDN:
2130 + case ICRP:
2131 + case OCRP:
2132 + c->cid = id;
2133 + break;
2134 + case ICRQ:
2135 + t->call_head->cid = id;
2136 + break;
2137 + };
2138
2139 -#ifdef SANITY
2140 - if (t->sanity)
2141 - {
2142 - switch (c->msgtype)
2143 - {
2144 - case CDN:
2145 - case ICRP:
2146 - case ICRQ:
2147 - case OCRP: /* jz: deleting the debug message */
2148 - break;
2149 - case OCRQ:
2150 - default:
2151 - if (DEBUG)
2152 - log (LOG_DEBUG,
2153 - "%s: call ID not appropriate for message %s. Ignoring.\n",
2154 - __FUNCTION__, msgtypes[c->msgtype]);
2155 - return 0;
2156 - }
2157 - if (datalen != 8)
2158 - {
2159 - if (DEBUG)
2160 - log (LOG_DEBUG,
2161 - "%s: avp is wrong size. %d != 8\n", __FUNCTION__,
2162 - datalen);
2163 - wrong_length (c, "Assigned Call ID", 8, datalen, 0);
2164 - return -EINVAL;
2165 - }
2166 - }
2167 -#endif
2168 - if (c->msgtype == CDN)
2169 - {
2170 - c->qcid = ntohs (raw[3]);
2171 - }
2172 - else if (c->msgtype == ICRQ)
2173 - {
2174 - t->call_head->cid = ntohs (raw[3]);
2175 - }
2176 - else if (c->msgtype == ICRP)
2177 - {
2178 - c->cid = ntohs (raw[3]);
2179 - }
2180 - else if (c->msgtype == OCRP)
2181 - { /* jz: copy callid to c->cid */
2182 - c->cid = ntohs (raw[3]);
2183 - }
2184 - else
2185 - {
2186 - log (LOG_DEBUG, "%s: Dunno what to do when it's state %s!\n",
2187 - __FUNCTION__, msgtypes[c->msgtype]);
2188 - }
2189 if (debug_avp)
2190 - {
2191 - if (DEBUG)
2192 - log (LOG_DEBUG,
2193 - "%s: using peer's call %d\n", __FUNCTION__, ntohs (raw[3]));
2194 - }
2195 + log (LOG_DEBUG, "%s: assigned session id: %d\n", __func__, id);
2196 return 0;
2197 }
2198
2199 +/*****************************************************************************/
2200 int packet_delay_avp (struct tunnel *t, struct call *c, void *data,
2201 - int datalen)
2202 + int avplen)
2203 {
2204 - /*
2205 - * What is their CID that we must use from now on?
2206 - */
2207 - _u16 *raw = data;
2208 + u_int8_t *p = data + sizeof(struct avp_hdr);
2209
2210 -#ifdef SANITY
2211 - if (t->sanity)
2212 - {
2213 - switch (c->msgtype)
2214 - {
2215 - case ICRP:
2216 - case OCRQ:
2217 - case ICCN:
2218 - case OCRP:
2219 - case OCCN:
2220 - break;
2221 - default:
2222 - if (DEBUG)
2223 - log (LOG_DEBUG,
2224 - "%s: packet delay not appropriate for message %s. Ignoring.\n",
2225 - __FUNCTION__, msgtypes[c->msgtype]);
2226 - return 0;
2227 - }
2228 - if (datalen != 8)
2229 - {
2230 - if (DEBUG)
2231 - log (LOG_DEBUG,
2232 - "%s: avp is wrong size. %d != 8\n", __FUNCTION__,
2233 - datalen);
2234 - wrong_length (c, "Assigned Call ID", 8, datalen, 0);
2235 - return -EINVAL;
2236 - }
2237 - }
2238 -#endif
2239 - c->ppd = ntohs (raw[3]);
2240 + c->ppd = get16(p);
2241 if (debug_avp)
2242 - {
2243 - if (DEBUG)
2244 - log (LOG_DEBUG,
2245 - "%s: peer's delay is %d 1/10's of a second\n", __FUNCTION__,
2246 - ntohs (raw[3]));
2247 - }
2248 + log (LOG_DEBUG, "%s: peer's delay is %d 1/10's of a second\n", __func__,
2249 + c->ppd);
2250 return 0;
2251 }
2252
2253 -int call_serno_avp (struct tunnel *t, struct call *c, void *data, int datalen)
2254 +/*****************************************************************************/
2255 +int call_serno_avp (struct tunnel *t, struct call *c, void *data, int avplen)
2256 {
2257 /*
2258 * What is the serial number of the call?
2259 */
2260 - _u16 *raw = data;
2261 -
2262 -#ifdef SANITY
2263 - if (t->sanity)
2264 - {
2265 - switch (c->msgtype)
2266 - {
2267 - case ICRQ:
2268 - case OCRQ:
2269 - break;
2270 - default:
2271 - if (DEBUG)
2272 - log (LOG_DEBUG,
2273 - "%s: call ID not appropriate for message %s. Ignoring.\n",
2274 - __FUNCTION__, msgtypes[c->msgtype]);
2275 - return 0;
2276 - }
2277 - if (datalen != 10)
2278 - {
2279 -#ifdef STRICT
2280 - if (DEBUG)
2281 - log (LOG_DEBUG,
2282 - "%s: avp is wrong size. %d != 10\n", __FUNCTION__,
2283 - datalen);
2284 - wrong_length (c, "Serial Number", 10, datalen, 0);
2285 - return -EINVAL;
2286 -#else
2287 - log (LOG_DEBUG,
2288 - "%s: peer is using old style serial number. Will be invalid.\n",
2289 - __FUNCTION__);
2290 -#endif
2291 + u_int8_t *p = data + sizeof(struct avp_hdr);
2292
2293 - }
2294 - }
2295 -#endif
2296 - t->call_head->serno = (((unsigned int) ntohs (raw[3])) << 16) |
2297 - ((unsigned int) ntohs (raw[4]));
2298 + t->call_head->serno = get32(p);
2299 if (debug_avp)
2300 - {
2301 - if (DEBUG)
2302 - log (LOG_DEBUG,
2303 - "%s: serial number is %d\n", __FUNCTION__,
2304 - t->call_head->serno);
2305 - }
2306 + log (LOG_DEBUG, "%s: serial number is %d\n", __func__,
2307 + t->call_head->serno);
2308 return 0;
2309 }
2310
2311 -int rx_speed_avp (struct tunnel *t, struct call *c, void *data, int datalen)
2312 +/*****************************************************************************/
2313 +int rx_speed_avp (struct tunnel *t, struct call *c, void *data, int avplen)
2314 {
2315 - /*
2316 - * What is the received baud rate of the call?
2317 - */
2318 - _u16 *raw = data;
2319 + u_int8_t *p = data + sizeof(struct avp_hdr);
2320
2321 -#ifdef SANITY
2322 - if (t->sanity)
2323 - {
2324 - switch (c->msgtype)
2325 - {
2326 - case ICCN:
2327 - case OCCN:
2328 - case OCRP:
2329 - break;
2330 - default:
2331 - if (DEBUG)
2332 - log (LOG_DEBUG,
2333 - "%s: rx connect speed not appropriate for message %s. Ignoring.\n",
2334 - __FUNCTION__, msgtypes[c->msgtype]);
2335 - return 0;
2336 - }
2337 - if (datalen != 10)
2338 - {
2339 - if (DEBUG)
2340 - log (LOG_DEBUG,
2341 - "%s: avp is wrong size. %d != 10\n", __FUNCTION__,
2342 - datalen);
2343 - wrong_length (c, "Connect Speed (RX)", 10, datalen, 0);
2344 - return -EINVAL;
2345 - }
2346 - }
2347 -#endif
2348 - c->rxspeed = (((unsigned int) ntohs (raw[3])) << 16) |
2349 - ((unsigned int) ntohs (raw[4]));
2350 - if (debug_avp)
2351 - {
2352 - if (DEBUG)
2353 - log (LOG_DEBUG,
2354 - "%s: receive baud rate is %d\n", __FUNCTION__, c->rxspeed);
2355 - }
2356 + c->rxspeed = get32(p);
2357 + if(debug_avp)
2358 + log(LOG_DEBUG, "%s: receive baud rate is %d\n", __func__, c->rxspeed);
2359 return 0;
2360 }
2361
2362 -int tx_speed_avp (struct tunnel *t, struct call *c, void *data, int datalen)
2363 +/*****************************************************************************/
2364 +int tx_speed_avp (struct tunnel *t, struct call *c, void *data, int avplen)
2365 {
2366 - /*
2367 - * What is the tranmsit baud rate of the call?
2368 - */
2369 - _u16 *raw = data;
2370 + u_int8_t *p = data + sizeof(struct avp_hdr);
2371
2372 -#ifdef SANITY
2373 - if (t->sanity)
2374 - {
2375 - switch (c->msgtype)
2376 - {
2377 - case ICCN:
2378 - case OCCN:
2379 - case OCRP:
2380 - break;
2381 - default:
2382 - if (DEBUG)
2383 - log (LOG_DEBUG,
2384 - "%s: tx connect speed not appropriate for message %s. Ignoring.\n",
2385 - __FUNCTION__, msgtypes[c->msgtype]);
2386 - return 0;
2387 - }
2388 - if (datalen != 10)
2389 - {
2390 - if (DEBUG)
2391 - log (LOG_DEBUG,
2392 - "%s: avp is wrong size. %d != 10\n", __FUNCTION__,
2393 - datalen);
2394 - wrong_length (c, "Connect Speed (tx)", 10, datalen, 0);
2395 - return -EINVAL;
2396 - }
2397 - }
2398 -#endif
2399 - c->txspeed = (((unsigned int) ntohs (raw[3])) << 16) |
2400 - ((unsigned int) ntohs (raw[4]));
2401 + c->txspeed = get32(p);
2402 if (debug_avp)
2403 - {
2404 - if (DEBUG)
2405 - log (LOG_DEBUG,
2406 - "%s: transmit baud rate is %d\n", __FUNCTION__, c->txspeed);
2407 - }
2408 + log (LOG_DEBUG, "%s: transmit baud rate is %d\n",
2409 + __func__, c->txspeed);
2410 return 0;
2411 }
2412 +
2413 +/*****************************************************************************/
2414 int call_physchan_avp (struct tunnel *t, struct call *c, void *data,
2415 - int datalen)
2416 + int avplen)
2417 {
2418 - /*
2419 - * What is the physical channel?
2420 - */
2421 - _u16 *raw = data;
2422 + u_int8_t *p = data + sizeof(struct avp_hdr);
2423
2424 -#ifdef SANITY
2425 - if (t->sanity)
2426 - {
2427 - switch (c->msgtype)
2428 - {
2429 - case ICRQ:
2430 - case OCRQ:
2431 - case OCRP:
2432 - case OCCN:
2433 - break;
2434 - default:
2435 - if (DEBUG)
2436 - log (LOG_DEBUG,
2437 - "%s: physical channel not appropriate for message %s. Ignoring.\n",
2438 - __FUNCTION__, msgtypes[c->msgtype]);
2439 - return 0;
2440 - }
2441 - if (datalen != 10)
2442 - {
2443 - if (DEBUG)
2444 - log (LOG_DEBUG,
2445 - "%s: avp is wrong size. %d != 10\n", __FUNCTION__,
2446 - datalen);
2447 - wrong_length (c, "Physical Channel", 10, datalen, 0);
2448 - return -EINVAL;
2449 - }
2450 - }
2451 -#endif
2452 - t->call_head->physchan = (((unsigned int) ntohs (raw[3])) << 16) |
2453 - ((unsigned int) ntohs (raw[4]));
2454 + t->call_head->physchan = get32(p);
2455 if (debug_avp)
2456 - {
2457 - if (DEBUG)
2458 - log (LOG_DEBUG,
2459 - "%s: physical channel is %d\n", __FUNCTION__,
2460 - t->call_head->physchan);
2461 - }
2462 + log(LOG_DEBUG, "%s: physical channel is %d\n", __func__,
2463 + t->call_head->physchan);
2464 return 0;
2465 }
2466
2467 +/*****************************************************************************/
2468 int receive_window_size_avp (struct tunnel *t, struct call *c, void *data,
2469 - int datalen)
2470 + int avplen)
2471 {
2472 - /*
2473 - * What is their RWS?
2474 - */
2475 - _u16 *raw = data;
2476 + u_int8_t *p = data + sizeof(struct avp_hdr);
2477
2478 -#ifdef SANITY
2479 - if (t->sanity)
2480 - {
2481 - switch (c->msgtype)
2482 - {
2483 - case SCCRP:
2484 - case SCCRQ:
2485 - case OCRP: /* jz */
2486 - case OCCN: /* jz */
2487 - case StopCCN:
2488 -/* case ICRP:
2489 - case ICCN: */
2490 - break;
2491 - default:
2492 - if (DEBUG)
2493 - log (LOG_DEBUG,
2494 - "%s: RWS not appropriate for message %s. Ignoring.\n",
2495 - __FUNCTION__, msgtypes[c->msgtype]);
2496 - return 0;
2497 - }
2498 - if (datalen != 8)
2499 - {
2500 - if (DEBUG)
2501 - log (LOG_DEBUG,
2502 - "%s: avp is wrong size. %d != 8\n", __FUNCTION__,
2503 - datalen);
2504 - wrong_length (c, "Receive Window Size", 8, datalen, 0);
2505 - return -EINVAL;
2506 - }
2507 - }
2508 -#endif
2509 - t->rws = ntohs (raw[3]);
2510 + t->rws = get16(p);
2511 /* if (c->rws >= 0)
2512 c->fbit = FBIT; */
2513 if (debug_avp)
2514 - {
2515 - if (DEBUG)
2516 - log (LOG_DEBUG,
2517 - "%s: peer wants RWS of %d. Will use flow control.\n",
2518 - __FUNCTION__, t->rws);
2519 - }
2520 + log (LOG_DEBUG, "%s: peer wants RWS of %d. Will use flow control.\n",
2521 + __func__, t->rws);
2522 return 0;
2523 }
2524
2525
2526 +/*****************************************************************************/
2527 int handle_avps (struct buffer *buf, struct tunnel *t, struct call *c)
2528 {
2529 /*
2530 @@ -1594,82 +770,100 @@
2531
2532 struct avp_hdr *avp;
2533 int len = buf->len - sizeof (struct control_hdr);
2534 + u_int16_t rlen = 0;
2535 + u_int16_t attr = 0;
2536 int firstavp = -1;
2537 - int hidlen;
2538 + int hidlen = 0;
2539 char *data = buf->start + sizeof (struct control_hdr);
2540 avp = (struct avp_hdr *) data;
2541 +
2542 if (debug_avp)
2543 log (LOG_DEBUG, "%s: handling avp's for tunnel %d, call %d\n",
2544 - __FUNCTION__, t->ourtid, c->ourcid);
2545 + __func__, t->ourtid, c->ourcid);
2546 +
2547 + if(len < 6) {
2548 + log (LOG_WARN, "%s: packet too small\n", __func__);
2549 + set_error(c, ERROR_LENGTH, "Invalid message length");
2550 + return -EINVAL;
2551 + }
2552 +
2553 while (len > 0)
2554 {
2555 - /* Go ahead and byte-swap the header */
2556 - swaps (avp, sizeof (struct avp_hdr));
2557 - if (avp->attr > AVP_MAX)
2558 + rlen = get16((u_int8_t*)&avp->length);
2559 + attr = get16((u_int8_t*)&avp->attr);
2560 +
2561 + /* AVP header checks */
2562 + if (attr > AVP_MAX)
2563 {
2564 - if (AMBIT (avp->length))
2565 + if (AMBIT(rlen))
2566 {
2567 log (LOG_WARN,
2568 - "%s: dont know how to handle mandatory attribute %d. Closing %s.\n"
2569 - __FUNCTION__, avp->attr,
2570 - (c != t->self) ? "call" : "tunnel");
2571 - set_error (c, VENDOR_ERROR,
2572 - "mandatory attribute %d cannot be handled",
2573 - avp->attr);
2574 - c->needclose = -1;
2575 + "%s: unhandeled mandatory attribute %d. Closing %s.\n",
2576 + __func__, attr, (c != t->self) ? "call" : "tunnel");
2577 + set_error (c, VENDOR_ERROR,
2578 + "mandatory attribute %d cannot be handled", attr);
2579 return -EINVAL;
2580 }
2581 else
2582 {
2583 if (DEBUG)
2584 log (LOG_WARN,
2585 - "%s: dont know how to handle atribute %d.\n",
2586 - __FUNCTION__, avp->attr);
2587 + "%s: handeled attribute %d.\n",
2588 + __func__, attr);
2589 goto next;
2590 }
2591 }
2592 - if (ALENGTH (avp->length) > len)
2593 + if (ALENGTH (rlen) > len)
2594 {
2595 log (LOG_WARN,
2596 - "%s: AVP received with length > remaining packet length!\n",
2597 - __FUNCTION__);
2598 + "%s: AVP reported length > remaining packet length\n",
2599 + __func__);
2600 set_error (c, ERROR_LENGTH, "Invalid AVP length");
2601 - c->needclose = -1;
2602 return -EINVAL;
2603 }
2604 - if (avp->attr && firstavp)
2605 + if (ALENGTH (rlen) < sizeof (struct avp_hdr))
2606 {
2607 - log (LOG_WARN, "%s: First AVP was not message type.\n",
2608 - __FUNCTION__);
2609 - set_error (c, VENDOR_ERROR, "First AVP must be message type");
2610 - c->needclose = -1;
2611 + log (LOG_WARN, "%s: AVP reported length too small (%d).\n",
2612 + __func__, ALENGTH (rlen));
2613 + set_error (c, ERROR_LENGTH, "AVP too small");
2614 return -EINVAL;
2615 }
2616 - if (ALENGTH (avp->length) < sizeof (struct avp_hdr))
2617 + if (avps[attr].sz) {
2618 + if((avps[attr].flags & AVP_F_FIXLEN) ?
2619 + (ALENGTH(rlen) - sizeof(struct avp_hdr)) != avps[attr].sz :
2620 + (ALENGTH(rlen) - sizeof(struct avp_hdr)) > avps[attr].sz) {
2621 + log (LOG_DEBUG, "%s: %s avp size mismatch (%d %s %d)\n",
2622 + __func__,
2623 + avps[attr].description,
2624 + (avps[attr].flags & AVP_F_FIXLEN) ? "!=" : "<",
2625 + ALENGTH(rlen), avps[attr].sz);
2626 + set_error (c, ERROR_LENGTH, "AVP size check failed");
2627 + return -EINVAL;
2628 + }
2629 + }
2630 + if (attr && firstavp)
2631 {
2632 - log (LOG_WARN, "%s: AVP with too small of size (%d).\n",
2633 - __FUNCTION__, ALENGTH (avp->length));
2634 - set_error (c, ERROR_LENGTH, "AVP too small");
2635 - c->needclose = -1;
2636 + log (LOG_WARN, "%s: First AVP was not message type.\n",
2637 + __func__);
2638 + set_error (c, VENDOR_ERROR, "First AVP must be message type");
2639 return -EINVAL;
2640 }
2641 - if (AZBITS (avp->length))
2642 + if (AZBITS (rlen))
2643 {
2644 - log (LOG_WARN, "%s: %sAVP has reserved bits set.\n", __FUNCTION__,
2645 - AMBIT (avp->length) ? "Mandatory " : "");
2646 - if (AMBIT (avp->length))
2647 + log (LOG_WARN, "%s: %sAVP has reserved bits set.\n", __func__,
2648 + AMBIT (rlen) ? "Mandatory " : "");
2649 + if (AMBIT (rlen))
2650 {
2651 set_error (c, ERROR_RESERVED, "reserved bits set in AVP");
2652 - c->needclose = -1;
2653 return -EINVAL;
2654 }
2655 goto next;
2656 }
2657 - if (AHBIT (avp->length))
2658 +
2659 + /* decryption */
2660 + if (AHBIT (rlen))
2661 {
2662 -#ifdef DEBUG_HIDDEN
2663 - log (LOG_DEBUG, "%s: Hidden bit set on AVP.\n", __FUNCTION__);
2664 -#endif
2665 + log (LOG_DEBUG, "%s: Hidden bit set on AVP.\n", __func__);
2666 /* We want to rewrite the AVP as an unhidden AVP
2667 and then pass it along as normal. Remeber how
2668 long the AVP was in the first place though! */
2669 @@ -1678,12 +872,11 @@
2670 {
2671 if (debug_avp)
2672 log (LOG_WARN, "%s: Unable to handle hidden %sAVP\n:",
2673 - __FUNCTION__,
2674 - (AMBIT (avp->length) ? "mandatory " : ""));
2675 - if (AMBIT (avp->length))
2676 + __func__,
2677 + (AMBIT (rlen) ? "mandatory " : ""));
2678 + if (AMBIT (rlen))
2679 {
2680 set_error (c, VENDOR_ERROR, "Invalid Hidden AVP");
2681 - c->needclose = -1;
2682 return -EINVAL;
2683 }
2684 goto next;
2685 @@ -1696,17 +889,43 @@
2686 }
2687 else
2688 hidlen = 0;
2689 - if (avps[avp->attr].handler)
2690 +
2691 + /* validate */
2692 + if (avps[attr].validate)
2693 + {
2694 + if(avps[attr].validate(attr, t, c, avp, ALENGTH (rlen))) {
2695 + if (AMBIT (rlen))
2696 + {
2697 + log (LOG_WARN,
2698 + "%s: verification of AVP %d (%s) failed.\n",
2699 + __func__, attr,
2700 + avps[attr].description);
2701 + set_error (c, VENDOR_ERROR, "processing failed on mandatory AVP");
2702 + return -EINVAL;
2703 + }
2704 + else
2705 + {
2706 + if (DEBUG)
2707 + log (LOG_DEBUG,
2708 + "%s: Bad exit status handling attribute %d (%s).\n",
2709 + __func__, attr,
2710 + avps[attr].description);
2711 + }
2712 + }
2713 + }
2714 +
2715 + /* handling */
2716 + if (avps[attr].handle)
2717 {
2718 - if (avps[avp->attr].handler (t, c, avp, ALENGTH (avp->length)))
2719 + if (avps[attr].handle(t, c, avp, ALENGTH (rlen)))
2720 {
2721 - if (AMBIT (avp->length))
2722 + if (AMBIT (rlen))
2723 {
2724 log (LOG_WARN,
2725 - "%s: Bad exit status handling attribute %d (%s) on mandatory packet.\n",
2726 - __FUNCTION__, avp->attr,
2727 - avps[avp->attr].description);
2728 - c->needclose = -1;
2729 + "%s: Bad exit status handling mandatory attribute %d (%s).\n",
2730 + __func__, attr,
2731 + avps[attr].description);
2732 + set_error (c, VENDOR_ERROR, "processing failed on mandatory AVP");
2733 return -EINVAL;
2734 }
2735 else
2736 @@ -1714,29 +933,31 @@
2737 if (DEBUG)
2738 log (LOG_DEBUG,
2739 "%s: Bad exit status handling attribute %d (%s).\n",
2740 - __FUNCTION__, avp->attr,
2741 - avps[avp->attr].description);
2742 + __func__, attr,
2743 + avps[attr].description);
2744 }
2745 }
2746 }
2747 else
2748 {
2749 - if (AMBIT (avp->length))
2750 + if (AMBIT (rlen))
2751 {
2752 log (LOG_WARN,
2753 "%s: No handler for mandatory attribute %d (%s). Closing %s.\n",
2754 - __FUNCTION__, avp->attr, avps[avp->attr].description,
2755 + __func__, attr,
2756 + avps[attr].description,
2757 (c != t->self) ? "call" : "tunnel");
2758 set_error (c, VENDOR_ERROR, "No handler for attr %d (%s)\n",
2759 - avp->attr, avps[avp->attr].description);
2760 + attr,
2761 + avps[attr].description);
2762 return -EINVAL;
2763 }
2764 else
2765 {
2766 if (DEBUG)
2767 log (LOG_WARN, "%s: no handler for atribute %d (%s).\n",
2768 - __FUNCTION__, avp->attr,
2769 - avps[avp->attr].description);
2770 + __func__, attr,
2771 + avps[attr].description);
2772 }
2773 }
2774 next:
2775 @@ -1748,16 +969,17 @@
2776 }
2777 else
2778 {
2779 - len -= ALENGTH (avp->length);
2780 - data += ALENGTH (avp->length); /* Next AVP, please */
2781 + len -= ALENGTH (rlen);
2782 + data += ALENGTH (rlen); /* Next AVP, please */
2783 }
2784 avp = (struct avp_hdr *) data;
2785 firstavp = 0;
2786 }
2787 if (len != 0)
2788 {
2789 - log (LOG_WARN, "%s: negative overall packet length\n", __FUNCTION__);
2790 + log (LOG_WARN, "%s: negative overall packet length\n", __func__);
2791 return -EINVAL;
2792 }
2793 +
2794 return 0;
2795 }
2796 --- l2tpd-0.70-pre20031121.orig/avpsend.c
2797 +++ l2tpd-0.70-pre20031121/avpsend.c
2798 @@ -1,11 +1,5 @@
2799 /*
2800 - * $Id$
2801 - *
2802 - * Layer Two Tunnelling Protocol Daemon
2803 - * Copyright (C) 1998 Adtran, Inc.
2804 - * Copyright (C) 2002 Jeff McAdams
2805 - *
2806 - * Mark Spencer
2807 + * Copyright (C) 2004 Jean-Francois Dive
2808 *
2809 * This software is distributed under the terms
2810 * of the GPL, which you should have received
2811 @@ -14,337 +8,288 @@
2812 * Attribute Value Pair creating routines
2813 */
2814
2815 +/* TODO: Handle Tie break */
2816 +/* TODO: Get real hostname / config */
2817 +/* TODO: There should be an overflow check on
2818 + * the buffer size. (safe for now as
2819 + * packet size = 4k
2820 + */
2821 +
2822 #include <stdlib.h>
2823 #include <string.h>
2824 -#include <netinet/in.h>
2825 +#include <unistd.h>
2826 #include "l2tp.h"
2827
2828 -/*
2829 - * These routines should add avp's to a buffer
2830 - * to be sent
2831 - */
2832 +extern struct avp avps[];
2833
2834 +/* We could add here padding support which would allow
2835 + * to keep alignemnt straight <jdive> */
2836 +static int add_avp(struct buffer *buf, u_int32_t avpid, unsigned char *v,
2837 + u_int32_t sz, u_int8_t setpayload) {
2838 + u_int8_t *p = buf->start + buf->len;
2839 +
2840 + if(avpid > AVP_MAX || !avps[avpid].flags) {
2841 + log(LOG_DEBUG, "%s: invalid avp id %d\n", __func__, avpid);
2842 + return 1;
2843 + }
2844 +
2845 + set16(p, (sz + 6) | (avps[avpid].flags & AVP_F_MANDATORY ? MBIT : 0));
2846 + set16(p + 2, VENDOR_ID);
2847 + set16(p + 4, avpid);
2848 + if(setpayload)
2849 + memcpy(p + 6, v, sz);
2850
2851 -/* FIXME: If SANITY is on, we should check for buffer overruns */
2852 + buf->len += (sz + 6);
2853 + return 0;
2854 +}
2855
2856 -/* FIXME: Can't this be condensed alot? */
2857 +/*****************************************************************************/
2858 +int add_message_type_avp(struct buffer *buf, _u16 type) {
2859 + u_int8_t t[2];
2860 + set16(t, type);
2861 + if(add_avp(buf, MESSAGE_TYPE_AVP, t, 2, 1))
2862 + return 1;
2863 + return 0;
2864 +}
2865
2866 -int add_message_type_avp (struct buffer *buf, _u16 type)
2867 -{
2868 - _u16 *raw = (_u16 *) (buf->start + buf->len);
2869 - raw[0] = htons (0x8 | MBIT);
2870 - raw[1] = htons (VENDOR_ID);
2871 - raw[2] = 0;
2872 - raw[3] = htons (type);
2873 - buf->len += 8;
2874 +/*****************************************************************************/
2875 +int add_protocol_avp(struct buffer *buf) {
2876 + u_int8_t t[2];
2877 + set16(t, OUR_L2TP_VERSION);
2878 + if(add_avp(buf, PROTOCOL_VERSION_AVP, t, 2, 1))
2879 + return 1;
2880 return 0;
2881 }
2882
2883 -int add_protocol_avp (struct buffer *buf)
2884 -{
2885 - _u16 *raw = (_u16 *) (buf->start + buf->len);
2886 - raw[0] = htons (0x8 | MBIT); /* Length and M bit */
2887 - raw[1] = htons (VENDOR_ID);
2888 - raw[2] = htons (0x2); /* Value of our AVP */
2889 - raw[3] = htons (OUR_L2TP_VERSION);
2890 - buf->len += 8;
2891 +/*****************************************************************************/
2892 +int add_frame_caps_avp(struct buffer *buf, _u16 caps) {
2893 + u_int8_t t[4];
2894 + t[0] = 0;
2895 + t[1] = 0;
2896 + set16(&t[2], caps);
2897 + if(add_avp(buf, FRAMING_CAP_AVP, t, 4, 1))
2898 + return 1;
2899 return 0;
2900 }
2901
2902 -int add_frame_caps_avp (struct buffer *buf, _u16 caps)
2903 -{
2904 - _u16 *raw = (_u16 *) (buf->start + buf->len);
2905 - raw[0] = htons (0xA | MBIT);
2906 - raw[1] = htons (VENDOR_ID);
2907 - raw[2] = htons (0x3);
2908 - raw[3] = 0;
2909 - raw[4] = htons (caps);
2910 - buf->len += 10;
2911 +/*****************************************************************************/
2912 +int add_bearer_caps_avp(struct buffer *buf, _u16 caps) {
2913 + u_int8_t t[4];
2914 + t[0] = 0;
2915 + t[1] = 0;
2916 + set16(&t[2], caps);
2917 + if(add_avp(buf, BEARER_CAP_AVP, t, 4, 1))
2918 + return 1;
2919 return 0;
2920 }
2921
2922 -int add_bearer_caps_avp (struct buffer *buf, _u16 caps)
2923 -{
2924 - _u16 *raw = (_u16 *) (buf->start + buf->len);
2925 - raw[0] = htons (0xA | MBIT);
2926 - raw[1] = htons (VENDOR_ID);
2927 - raw[2] = htons (0x4);
2928 - raw[3] = 0;
2929 - raw[4] = htons (caps);
2930 - buf->len += 10;
2931 +/*****************************************************************************/
2932 +int add_firmware_avp(struct buffer *buf) {
2933 + u_int8_t t[2];
2934 + set16(t, OUR_L2TP_VERSION);
2935 + if(add_avp(buf, FIRMWARE_REV_AVP, t, 2, 1))
2936 + return 1;
2937 return 0;
2938 }
2939
2940 -/* FIXME: I need to send tie breaker AVP's */
2941 -
2942 -int add_firmware_avp (struct buffer *buf)
2943 -{
2944 - _u16 *raw = (_u16 *) (buf->start + buf->len);
2945 - raw[0] = htons (0x8);
2946 - raw[1] = htons (VENDOR_ID);
2947 - raw[2] = htons (0x6);
2948 - raw[3] = htons (FIRMWARE_REV);
2949 - buf->len += 8;
2950 +/*****************************************************************************/
2951 +int add_hostname_avp(struct buffer *buf, struct tunnel *t) {
2952 + char n[STRLEN];
2953 + int sz = 0;
2954 + if(t->lac && t->lac->hostname[0]) {
2955 + strncpy(n,t->lac->hostname, sizeof(n));
2956 + sz = strnlen(t->lac->hostname, sizeof(t->lac->hostname));
2957 + }
2958 + else if(t->lns && t->lns->hostname[0]) {
2959 + strncpy(n,t->lns->hostname, sizeof(n));
2960 + sz = strnlen(t->lns->hostname, sizeof(t->lns->hostname));
2961 + }
2962 + else {
2963 + if(gethostname(n, STRLEN)) {
2964 + strcpy(n,"eriwan");
2965 + sz = 6;
2966 + }
2967 + else
2968 + sz = strnlen(n, sizeof(n));
2969 + }
2970 + if(add_avp(buf, HOSTNAME_AVP, n, sz, 1))
2971 + return 1;
2972 return 0;
2973 }
2974
2975 -/*
2976 -int add_hostname_avp(struct buffer *buf) {
2977 - _u16 *raw = (_u16 *)(buf->start + buf->len);
2978 - raw[0] = htons((0x6 + strlen(hostname)) | MBIT);
2979 - raw[1] = htons(VENDOR_ID);
2980 - raw[2] = htons(0x7);
2981 - strcpy((char *)(&raw[3]), hostname);
2982 - buf->len += 6 + strlen(hostname);
2983 - return 0;
2984 +/*****************************************************************************/
2985 +int add_vendor_avp(struct buffer *buf) {
2986 + if(add_avp(buf, VENDOR_NAME_AVP, VENDOR_NAME, strlen(VENDOR_NAME), 1))
2987 + return 1;
2988 + return 0;
2989 }
2990 -*/
2991
2992 -int add_hostname_avp (struct buffer *buf)
2993 -{
2994 - char names[6] = "eriwan";
2995 - _u16 *raw = (_u16 *) (buf->start + buf->len);
2996 - raw[0] = htons (0xC | MBIT);
2997 - raw[1] = htons (VENDOR_ID);
2998 - raw[2] = htons (0x7);
2999 - strcpy ((char *) (&raw[3]), names);
3000 - buf->len += 12;
3001 - return 0;
3002 -}
3003 -
3004 -int add_vendor_avp (struct buffer *buf)
3005 -{
3006 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3007 - raw[0] = htons (0x6 + strlen (VENDOR_NAME));
3008 - raw[1] = htons (VENDOR_ID);
3009 - raw[2] = htons (0x8);
3010 - strcpy ((char *) (&raw[3]), VENDOR_NAME);
3011 - buf->len += 6 + strlen (VENDOR_NAME);
3012 - return 0;
3013 -}
3014 -
3015 -int add_tunnelid_avp (struct buffer *buf, _u16 tid)
3016 -{
3017 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3018 - raw[0] = htons (0x8 | MBIT);
3019 - raw[1] = htons (VENDOR_ID);
3020 - raw[2] = htons (0x9);
3021 - raw[3] = htons (tid);
3022 - buf->len += 8;
3023 - return 0;
3024 -}
3025 -
3026 -int add_avp_rws (struct buffer *buf, _u16 rws)
3027 -{
3028 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3029 - raw[0] = htons (0x8 | MBIT);
3030 - raw[1] = htons (VENDOR_ID);
3031 - raw[2] = htons (0xA);
3032 - raw[3] = htons (rws);
3033 - buf->len += 8;
3034 - return 0;
3035 -}
3036 -
3037 -int add_challenge_avp (struct buffer *buf, char *c, int len)
3038 -{
3039 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3040 - raw[0] = htons ((0x6 + len) | MBIT);
3041 - raw[1] = htons (VENDOR_ID);
3042 - raw[2] = htons (0xB);
3043 - bcopy (c, (char *) (&raw[3]), len);
3044 - buf->len += 6 + len;
3045 - return 0;
3046 -}
3047 -
3048 -int add_chalresp_avp (struct buffer *buf, char *c, int len)
3049 -{
3050 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3051 - raw[0] = htons ((0x6 + len) | MBIT);
3052 - raw[1] = htons (VENDOR_ID);
3053 - raw[2] = htons (0xD);
3054 - bcopy (c, (char *) (&raw[3]), len);
3055 - buf->len += 6 + len;
3056 - return 0;
3057 -}
3058 -
3059 -int add_randvect_avp (struct buffer *buf, char *c, int len)
3060 -{
3061 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3062 - raw[0] = htons ((0x6 + len) | MBIT);
3063 - raw[1] = htons (VENDOR_ID);
3064 - raw[2] = htons (0x24);
3065 - bcopy (c, (char *) (&raw[3]), len);
3066 - buf->len += 6 + len;
3067 - return 0;
3068 -}
3069 -
3070 -int add_result_code_avp (struct buffer *buf, _u16 result, _u16 error,
3071 - char *msg, int len)
3072 -{
3073 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3074 - raw[0] = htons ((0xA + len) | MBIT);
3075 - raw[1] = htons (VENDOR_ID);
3076 - raw[2] = htons (0x1);
3077 - raw[3] = htons (result);
3078 - raw[4] = htons (error);
3079 - bcopy (msg, (char *) &raw[5], len);
3080 - buf->len += (10 + len);
3081 +/*****************************************************************************/
3082 +int add_tunnelid_avp(struct buffer *buf, _u16 tid) {
3083 + u_int8_t t[2];
3084 + set16(t, tid);
3085 + if(add_avp(buf, ASSIGNED_TUN_ID_AVP, t, 2, 1))
3086 + return 1;
3087 return 0;
3088 }
3089
3090 +/*****************************************************************************/
3091 +int add_avp_rws(struct buffer *buf, _u16 rws) {
3092 + u_int8_t t[2];
3093 + set16(t, rws);
3094 + if(add_avp(buf, RX_WIN_SIZE_AVP, t, 2, 1))
3095 + return 1;
3096 + return 0;
3097 +}
3098 +
3099 +/*****************************************************************************/
3100 +int add_challenge_avp(struct buffer *buf, char *c, int len) {
3101 + if(add_avp(buf, CHALLENGE_AVP, c, len, 1))
3102 + return 1;
3103 + return 0;
3104 +}
3105 +
3106 +/*****************************************************************************/
3107 +int add_chalresp_avp(struct buffer *buf, char *c, int len) {
3108 + if(add_avp(buf, CHALLENGE_RESP_AVP, c, len, 1))
3109 + return 1;
3110 + return 0;
3111 +}
3112 +
3113 +/*****************************************************************************/
3114 +int add_randvect_avp(struct buffer *buf, char *c, int len) {
3115 + if(add_avp(buf, RANDOM_VECTOR_AVP, c, len, 1))
3116 + return 1;
3117 + return 0;
3118 +}
3119 +
3120 +/*****************************************************************************/
3121 +int add_result_code_avp(struct buffer *buf, _u16 result, _u16 error,
3122 + char *msg, int len) {
3123 + u_int8_t t[4];
3124 + set16(t, result);
3125 + set16(&t[2], error);
3126 + memcpy((u_int8_t*)(buf->start + buf->len + 10), msg, len);
3127 + memcpy((u_int8_t*)(buf->start + buf->len + 6), t, 4);
3128 + if(add_avp(buf, RESULT_CODE_AVP, 0, 4 + len, 0))
3129 + return 1;
3130 + return 0;
3131 +}
3132 +
3133 +/*****************************************************************************/
3134 #ifdef TEST_HIDDEN
3135 -int add_callid_avp (struct buffer *buf, _u16 callid, struct tunnel *t)
3136 -{
3137 -#else
3138 -int add_callid_avp (struct buffer *buf, _u16 callid)
3139 -{
3140 -#endif
3141 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3142 -#ifdef TEST_HIDDEN
3143 +int add_callid_avp(struct buffer *buf, _u16 callid, struct tunnel *t) {
3144 + u_int8_t t[2];
3145 if (t->hbit)
3146 raw++;
3147 -#endif
3148 - raw[0] = htons (0x8 | MBIT);
3149 - raw[1] = htons (VENDOR_ID);
3150 - raw[2] = htons (0xE);
3151 - raw[3] = htons (callid);
3152 - buf->len += 8;
3153 -#ifdef TEST_HIDDEN
3154 + set16(t, callid);
3155 + if(add_avp(buf, ASSIGNED_SES_ID_AVP, t, 2, 1))
3156 + return 1;
3157 if (t->hbit)
3158 encrypt_avp (buf, 8, t);
3159 + return 0;
3160 +}
3161 +#else
3162 +int add_callid_avp(struct buffer *buf, _u16 callid) {
3163 + u_int8_t t[2];
3164 + set16(t, callid);
3165 + if(add_avp(buf, ASSIGNED_SES_ID_AVP, t, 2, 1))
3166 + return 1;
3167 + return 0;
3168 +}
3169 #endif
3170 +
3171 +/*****************************************************************************/
3172 +int add_serno_avp(struct buffer *buf, unsigned int serno) {
3173 + u_int8_t t[4];
3174 + set32(t, serno);
3175 + if(add_avp(buf, SERIAL_NUMBER_AVP, t, 4, 1))
3176 + return 1;
3177 + return 0;
3178 +}
3179 +
3180 +/*****************************************************************************/
3181 +int add_bearer_avp(struct buffer *buf, int bearer) {
3182 + u_int8_t t[4];
3183 + set32(t, bearer);
3184 + if(add_avp(buf, BEARER_TYPE_AVP, t, 4, 1))
3185 + return 1;
3186 + return 0;
3187 +}
3188 +
3189 +/*****************************************************************************/
3190 +int add_frame_avp(struct buffer *buf, int frame) {
3191 + u_int8_t t[4];
3192 + set32(t, frame);
3193 + if(add_avp(buf, FRAMING_TYPE_AVP, t, 4, 1))
3194 + return 1;
3195 + return 0;
3196 +}
3197 +
3198 +/*****************************************************************************/
3199 +int add_txspeed_avp(struct buffer *buf, int speed) {
3200 + u_int8_t t[4];
3201 + set32(t, speed);
3202 + if(add_avp(buf, TX_CONNECT_SPEED_AVP, t, 4, 1))
3203 + return 1;
3204 + return 0;
3205 +}
3206 +
3207 +/*****************************************************************************/
3208 +int add_rxspeed_avp(struct buffer *buf, int speed) {
3209 + u_int8_t t[4];
3210 + set32(t, speed);
3211 + if(add_avp(buf, RX_CONNECT_SPEED_AVP, t, 4, 1))
3212 + return 1;
3213 + return 0;
3214 +}
3215 +
3216 +/*****************************************************************************/
3217 +int add_physchan_avp(struct buffer *buf, unsigned int physchan) {
3218 + u_int8_t t[4];
3219 + set32(t, physchan);
3220 + if(add_avp(buf, PHYS_CHAN_ID_AVP, t, 4, 1))
3221 + return 1;
3222 + return 0;
3223 +}
3224 +
3225 +/*****************************************************************************/
3226 +int add_ppd_avp(struct buffer *buf, _u16 ppd) {
3227 + u_int8_t t[2];
3228 + set16(t, ppd);
3229 + if(add_avp(buf, PACKET_DELAY_AVP, t, 2, 1))
3230 + return 1;
3231 + return 0;
3232 +}
3233 +
3234 +/*****************************************************************************/
3235 +int add_seqreqd_avp(struct buffer *buf) {
3236 + if(add_avp(buf, SEQ_REQUIRED_AVP, 0, 0, 0))
3237 + return 1;
3238 + return 0;
3239 +}
3240 +
3241 +/*****************************************************************************/
3242 +int add_minbps_avp(struct buffer *buf, int speed) {
3243 + u_int8_t t[4];
3244 + set32(t, speed);
3245 + if(add_avp(buf, MIN_BPS_AVP, t, 4, 1))
3246 + return 1;
3247 return 0;
3248 }
3249
3250 -int add_serno_avp (struct buffer *buf, unsigned int serno)
3251 -{
3252 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3253 - raw[0] = htons (0xA | MBIT);
3254 - raw[1] = htons (VENDOR_ID);
3255 - raw[2] = htons (0xF);
3256 - raw[3] = htons ((serno >> 16) & 0xFFFF);
3257 - raw[4] = htons (serno & 0xFFFF);
3258 - buf->len += 10;
3259 - return 0;
3260 -}
3261 -
3262 -int add_bearer_avp (struct buffer *buf, int bearer)
3263 -{
3264 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3265 - raw[0] = htons (0xA | MBIT);
3266 - raw[1] = htons (VENDOR_ID);
3267 - raw[2] = htons (0x12);
3268 - raw[3] = htons ((bearer >> 16) & 0xFFFF);
3269 - raw[4] = htons (bearer & 0xFFFF);
3270 - buf->len += 10;
3271 - return 0;
3272 -}
3273 -
3274 -int add_frame_avp (struct buffer *buf, int frame)
3275 -{
3276 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3277 - raw[0] = htons (0xA | MBIT);
3278 - raw[1] = htons (VENDOR_ID);
3279 - raw[2] = htons (0x13);
3280 - raw[3] = htons ((frame >> 16) & 0xFFFF);
3281 - raw[4] = htons (frame & 0xFFFF);
3282 - buf->len += 10;
3283 - return 0;
3284 -}
3285 -
3286 -int add_txspeed_avp (struct buffer *buf, int speed)
3287 -{
3288 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3289 - raw[0] = htons (0xA | MBIT);
3290 - raw[1] = htons (VENDOR_ID);
3291 - raw[2] = htons (0x18);
3292 - raw[3] = htons ((speed >> 16) & 0xFFFF);
3293 - raw[4] = htons (speed & 0xFFFF);
3294 - buf->len += 10;
3295 - return 0;
3296 -}
3297 -
3298 -int add_rxspeed_avp (struct buffer *buf, int speed)
3299 -{
3300 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3301 - raw[0] = htons (0xA | MBIT);
3302 - raw[1] = htons (VENDOR_ID);
3303 - raw[2] = htons (0x26);
3304 - raw[3] = htons ((speed >> 16) & 0xFFFF);
3305 - raw[4] = htons (speed & 0xFFFF);
3306 - buf->len += 10;
3307 - return 0;
3308 -}
3309 -
3310 -int add_physchan_avp (struct buffer *buf, unsigned int physchan)
3311 -{
3312 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3313 - raw[0] = htons (0x8 | MBIT);
3314 - raw[1] = htons (VENDOR_ID);
3315 - raw[2] = htons (0x19);
3316 - raw[3] = htons ((physchan >> 16) & 0xFFFF);
3317 - raw[4] = htons (physchan & 0xFFFF);
3318 - buf->len += 10;
3319 - return 0;
3320 -}
3321 -
3322 -int add_ppd_avp (struct buffer *buf, _u16 ppd)
3323 -{
3324 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3325 - raw[0] = htons (0x8 | MBIT);
3326 - raw[1] = htons (VENDOR_ID);
3327 - raw[2] = htons (0x14);
3328 - raw[3] = htons (ppd);
3329 - buf->len += 8;
3330 - return 0;
3331 -}
3332 -
3333 -int add_seqreqd_avp (struct buffer *buf)
3334 -{
3335 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3336 - raw[0] = htons (0x6 | MBIT);
3337 - raw[1] = htons (VENDOR_ID);
3338 - raw[2] = htons (0x27);
3339 - buf->len += 6;
3340 - return 0;
3341 -}
3342 -
3343 -/* jz: options dor the outgoing call */
3344 -
3345 -/* jz: Minimum BPS - 16 */
3346 -int add_minbps_avp (struct buffer *buf, int speed)
3347 -{
3348 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3349 - raw[0] = htons (0xA | MBIT);
3350 - raw[1] = htons (VENDOR_ID);
3351 - raw[2] = htons (0x10);
3352 - raw[3] = htons ((speed >> 16) & 0xFFFF);
3353 - raw[4] = htons (speed & 0xFFFF);
3354 - buf->len += 10;
3355 - return 0;
3356 -}
3357 -
3358 -/* jz: Maximum BPS - 17 */
3359 -int add_maxbps_avp (struct buffer *buf, int speed)
3360 -{
3361 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3362 - raw[0] = htons (0xA | MBIT);
3363 - raw[1] = htons (VENDOR_ID);
3364 - raw[2] = htons (0x11);
3365 - raw[3] = htons ((speed >> 16) & 0xFFFF);
3366 - raw[4] = htons (speed & 0xFFFF);
3367 - buf->len += 10;
3368 - return 0;
3369 -}
3370 -
3371 -/* jz: Dialed Number 21 */
3372 -int add_number_avp (struct buffer *buf, char *no)
3373 -{
3374 - _u16 *raw = (_u16 *) (buf->start + buf->len);
3375 - raw[0] = htons ((0x6 + strlen (no)) | MBIT);
3376 - raw[1] = htons (VENDOR_ID);
3377 - raw[2] = htons (0x15);
3378 - strncpy ((char *) (&(raw[3])), no, strlen (no));
3379 - buf->len += 6 + strlen (no);
3380 +/*****************************************************************************/
3381 +int add_maxbps_avp(struct buffer *buf, int speed) {
3382 + u_int8_t t[4];
3383 + set32(t, speed);
3384 + if(add_avp(buf, MAX_BPS_AVP, t, 4, 1))
3385 + return 1;
3386 return 0;
3387 }
3388 +
3389 +/*****************************************************************************/
3390 +int add_number_avp(struct buffer *buf, char *no) {
3391 + if(add_avp(buf, CALLED_NUMBER_AVP, no, strlen(no), 1))
3392 + return 1;
3393 + return 0;
3394 +}
Personal OpenWRT clone
This page took 0.205837 seconds and 5 git commands to generate.