Fix: inverted delete/add routes in cluster mode
[l2tpns.git] / pppoe.c
1 /*
2 * Fernando ALVES 2013
3 * Add functionality "server pppoe" to l2tpns.
4 * inspiration pppoe.c of accel-ppp
5 * GPL licenced
6 */
7
8 #include <unistd.h>
9 #include <assert.h>
10 #include <stdlib.h>
11 #include <stdio.h>
12 #include <stdarg.h>
13 #include <errno.h>
14 #include <string.h>
15 #include <pthread.h>
16 #include <fcntl.h>
17 #include <sys/socket.h>
18 #include <sys/ioctl.h>
19 #include <net/if.h>
20 #include <net/ethernet.h>
21 #include <netpacket/packet.h>
22 #include <arpa/inet.h>
23 #include <linux/if_pppox.h>
24
25 #include "l2tpns.h"
26 #include "cluster.h"
27 #include "constants.h"
28 #include "md5.h"
29 #include "util.h"
30
31 int pppoediscfd = -1;
32 int pppoesessfd = -1;
33
34 static uint8_t bc_addr[ETH_ALEN] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
35
36 /* PPPoE codes */
37 #define CODE_PADI 0x09
38 #define CODE_PADO 0x07
39 #define CODE_PADR 0x19
40 #define CODE_PADS 0x65
41 #define CODE_PADT 0xA7
42 #define CODE_SESS 0x00
43
44 /* PPPoE Tags */
45 #define TAG_END_OF_LIST 0x0000
46 #define TAG_SERVICE_NAME 0x0101
47 #define TAG_AC_NAME 0x0102
48 #define TAG_HOST_UNIQ 0x0103
49 #define TAG_AC_COOKIE 0x0104
50 #define TAG_VENDOR_SPECIFIC 0x0105
51 #define TAG_RELAY_SESSION_ID 0x0110
52 #define TAG_SERVICE_NAME_ERROR 0x0201
53 #define TAG_AC_SYSTEM_ERROR 0x0202
54 #define TAG_GENERIC_ERROR 0x0203
55
56 static char *code_pad[] = {
57 "PADI",
58 "PADO",
59 "PADR",
60 "PADS",
61 "PADT",
62 "SESS",
63 NULL
64 };
65
66 enum
67 {
68 INDEX_PADI = 0,
69 INDEX_PADO,
70 INDEX_PADR,
71 INDEX_PADS,
72 INDEX_PADT,
73 INDEX_SESS
74 };
75
76 // set up pppoe discovery socket
77 static void init_pppoe_disc(void)
78 {
79 int on = 1;
80 struct ifreq ifr;
81 struct sockaddr_ll sa;
82
83 memset(&ifr, 0, sizeof(ifr));
84 memset(&sa, 0, sizeof(sa));
85
86 pppoediscfd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_PPP_DISC));
87 if (pppoediscfd < 0)
88 {
89 LOG(0, 0, 0, "Error pppoe: socket: %s\n", strerror(errno));
90 exit(1);
91 }
92
93 fcntl(pppoediscfd, F_SETFD, fcntl(pppoediscfd, F_GETFD) | FD_CLOEXEC);
94
95 if (setsockopt(pppoediscfd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)))
96 {
97 LOG(0, 0, 0, "Error pppoe: setsockopt(SO_BROADCAST): %s\n", strerror(errno));
98 exit(1);
99 }
100
101 assert(strlen(ifr.ifr_name) < sizeof(config->pppoe_if_to_bind) - 1);
102 if (*config->pppoe_if_to_bind)
103 strncpy(ifr.ifr_name, config->pppoe_if_to_bind, IFNAMSIZ);
104
105 if (ioctl(pppoediscfd, SIOCGIFHWADDR, &ifr))
106 {
107 LOG(0, 0, 0, "Error pppoe: ioctl(SIOCGIFHWADDR): %s\n", strerror(errno));
108 exit(1);
109 }
110
111 if ((ifr.ifr_hwaddr.sa_data[0] & 1) != 0)
112 {
113 LOG(0, 0, 0, "Error pppoe: interface %s has not unicast address\n", config->pppoe_if_to_bind);
114 exit(1);
115 }
116
117 memcpy(config->pppoe_hwaddr, ifr.ifr_hwaddr.sa_data, ETH_ALEN);
118
119 if (ioctl(pppoediscfd, SIOCGIFMTU, &ifr))
120 {
121 LOG(0, 0, 0, "Error pppoe: ioctl(SIOCGIFMTU): %s\n", strerror(errno));
122 exit(1);
123 }
124
125 if (ifr.ifr_mtu < ETH_DATA_LEN)
126 LOG(0, 0, 0, "Error pppoe: interface %s has MTU of %i, should be %i\n", config->pppoe_if_to_bind, ifr.ifr_mtu, ETH_DATA_LEN);
127
128 if (ioctl(pppoediscfd, SIOCGIFINDEX, &ifr))
129 {
130 LOG(0, 0, 0, "Error pppoe: ioctl(SIOCGIFINDEX): %s\n", strerror(errno));
131 exit(1);
132 }
133
134 memset(&sa, 0, sizeof(sa));
135 sa.sll_family = AF_PACKET;
136 sa.sll_protocol = htons(ETH_P_PPP_DISC);
137 sa.sll_ifindex = ifr.ifr_ifindex;
138
139 if (bind(pppoediscfd, (struct sockaddr *)&sa, sizeof(sa)))
140 {
141 LOG(0, 0, 0, "Error pppoe: bind: %s\n", strerror(errno));
142 exit(1);
143 }
144
145 if (fcntl(pppoediscfd, F_SETFL, O_NONBLOCK))
146 {
147 LOG(0, 0, 0, "Error pppoe: failed to set nonblocking mode: %s\n", strerror(errno));
148 exit(1);
149 }
150
151 }
152
153 // set up pppoe session socket
154 static void init_pppoe_sess(void)
155 {
156 int on = 1;
157 struct ifreq ifr;
158 struct sockaddr_ll sa;
159
160 memset(&ifr, 0, sizeof(ifr));
161 memset(&sa, 0, sizeof(sa));
162
163 pppoesessfd = socket(PF_PACKET, SOCK_RAW, htons(ETH_P_PPP_SES));
164 if (pppoesessfd < 0)
165 {
166 LOG(0, 0, 0, "Error pppoe: socket: %s\n", strerror(errno));
167 exit(1);
168 }
169
170 fcntl(pppoesessfd, F_SETFD, fcntl(pppoesessfd, F_GETFD) | FD_CLOEXEC);
171
172 if (setsockopt(pppoesessfd, SOL_SOCKET, SO_BROADCAST, &on, sizeof(on)))
173 {
174 LOG(0, 0, 0, "Error pppoe: setsockopt(SO_BROADCAST): %s\n", strerror(errno));
175 exit(1);
176 }
177
178 assert(strlen(ifr.ifr_name) < sizeof(config->pppoe_if_to_bind) - 1);
179 if (*config->pppoe_if_to_bind)
180 strncpy(ifr.ifr_name, config->pppoe_if_to_bind, IFNAMSIZ);
181
182 if (ioctl(pppoesessfd, SIOCGIFHWADDR, &ifr))
183 {
184 LOG(0, 0, 0, "Error pppoe: ioctl(SIOCGIFHWADDR): %s\n", strerror(errno));
185 exit(1);
186 }
187
188 if ((ifr.ifr_hwaddr.sa_data[0] & 1) != 0)
189 {
190 LOG(0, 0, 0, "Error pppoe: interface %s has not unicast address\n", config->pppoe_if_to_bind);
191 exit(1);
192 }
193
194 memcpy(config->pppoe_hwaddr, ifr.ifr_hwaddr.sa_data, ETH_ALEN);
195
196 if (ioctl(pppoesessfd, SIOCGIFMTU, &ifr))
197 {
198 LOG(0, 0, 0, "Error pppoe: ioctl(SIOCGIFMTU): %s\n", strerror(errno));
199 exit(1);
200 }
201
202 if (ifr.ifr_mtu < ETH_DATA_LEN)
203 LOG(0, 0, 0, "Error pppoe: interface %s has MTU of %i, should be %i\n", config->pppoe_if_to_bind, ifr.ifr_mtu, ETH_DATA_LEN);
204
205 if (ioctl(pppoesessfd, SIOCGIFINDEX, &ifr))
206 {
207 LOG(0, 0, 0, "Error pppoe: ioctl(SIOCGIFINDEX): %s\n", strerror(errno));
208 exit(1);
209 }
210
211 memset(&sa, 0, sizeof(sa));
212 sa.sll_family = AF_PACKET;
213 sa.sll_protocol = htons(ETH_P_PPP_SES);
214 sa.sll_ifindex = ifr.ifr_ifindex;
215
216 if (bind(pppoesessfd, (struct sockaddr *)&sa, sizeof(sa)))
217 {
218 LOG(0, 0, 0, "Error pppoe: bind: %s\n", strerror(errno));
219 exit(1);
220 }
221
222 if (fcntl(pppoesessfd, F_SETFL, O_NONBLOCK))
223 {
224 LOG(0, 0, 0, "Error pppoe: failed to set nonblocking mode: %s\n", strerror(errno));
225 exit(1);
226 }
227 }
228
229 // set up pppoe discovery/session socket
230 void init_pppoe(void)
231 {
232 tunnelidt t = TUNNEL_ID_PPPOE;
233
234 init_pppoe_disc();
235 init_pppoe_sess();
236
237 // Reserve the a pseudo tunnel for pppoe server
238 if (t > config->cluster_highest_tunnelid)
239 config->cluster_highest_tunnelid = t;
240
241 memset(&tunnel[t], 0, sizeof(tunnel[t]));
242 tunnel[t].state = TUNNELOPEN;
243 STAT(tunnel_created);
244 }
245
246 char * get_string_codepad(uint8_t codepad)
247 {
248 char * ptrch = NULL;
249 switch(codepad)
250 {
251 case CODE_PADI:
252 ptrch = code_pad[INDEX_PADI];
253 break;
254
255 case CODE_PADO:
256 ptrch = code_pad[INDEX_PADO];
257 break;
258
259 case CODE_PADR:
260 ptrch = code_pad[INDEX_PADR];
261 break;
262
263 case CODE_PADS:
264 ptrch = code_pad[INDEX_PADS];
265 break;
266
267 case CODE_PADT:
268 ptrch = code_pad[INDEX_PADT];
269 break;
270
271 case CODE_SESS:
272 ptrch = code_pad[INDEX_SESS];
273 break;
274 }
275
276 return ptrch;
277 }
278
279 static uint8_t * setup_header(uint8_t *pack, const uint8_t *src, const uint8_t *dst, int code, uint16_t sid, uint16_t h_proto)
280 {
281 uint8_t * p;
282
283 // 14 bytes ethernet Header + 6 bytes header pppoe
284 struct ethhdr *ethhdr = (struct ethhdr *)pack;
285 struct pppoe_hdr *hdr = (struct pppoe_hdr *)(pack + ETH_HLEN);
286
287 memcpy(ethhdr->h_source, src, ETH_ALEN);
288 memcpy(ethhdr->h_dest, dst, ETH_ALEN);
289 ethhdr->h_proto = htons(h_proto);
290
291 hdr->ver = 1;
292 hdr->type = 1;
293 hdr->code = code;
294 hdr->sid = htons(sid);
295 hdr->length = 0;
296
297 p = (uint8_t *)(pack + ETH_HLEN + sizeof(*hdr));
298
299 return p;
300 }
301
302 static void add_tag(uint8_t *pack, int type, const uint8_t *data, int len)
303 {
304 struct pppoe_hdr *hdr = (struct pppoe_hdr *)(pack + ETH_HLEN);
305 struct pppoe_tag *tag = (struct pppoe_tag *)(pack + ETH_HLEN + sizeof(*hdr) + ntohs(hdr->length));
306
307 tag->tag_type = htons(type);
308 tag->tag_len = htons(len);
309 memcpy(tag->tag_data, data, len);
310
311 hdr->length = htons(ntohs(hdr->length) + sizeof(*tag) + len);
312 }
313
314 static void add_tag2(uint8_t *pack, const struct pppoe_tag *t)
315 {
316 struct pppoe_hdr *hdr = (struct pppoe_hdr *)(pack + ETH_HLEN);
317 struct pppoe_tag *tag = (struct pppoe_tag *)(pack + ETH_HLEN + sizeof(*hdr) + ntohs(hdr->length));
318
319 memcpy(tag, t, sizeof(*t) + ntohs(t->tag_len));
320
321 hdr->length = htons(ntohs(hdr->length) + sizeof(*tag) + ntohs(t->tag_len));
322 }
323
324 static void pppoe_disc_send(const uint8_t *pack)
325 {
326 struct ethhdr *ethhdr = (struct ethhdr *)pack;
327 struct pppoe_hdr *hdr = (struct pppoe_hdr *)(pack + ETH_HLEN);
328 int n, s;
329
330 s = ETH_HLEN + sizeof(*hdr) + ntohs(hdr->length);
331
332 LOG(3, 0, 0, "SENT pppoe_disc: Code %s to %s\n", get_string_codepad(hdr->code), fmtMacAddr(ethhdr->h_dest));
333 LOG_HEX(5, "pppoe_disc_send", pack, s);
334
335 n = write(pppoediscfd, pack, s);
336 if (n < 0 )
337 LOG(0, 0, 0, "pppoe: write: %s\n", strerror(errno));
338 else if (n != s) {
339 LOG(0, 0, 0, "pppoe: short write %i/%i\n", n,s);
340 }
341 }
342
343 void pppoe_sess_send(const uint8_t *pack, uint16_t l, tunnelidt t)
344 {
345 struct pppoe_hdr *hdr = (struct pppoe_hdr *)(pack + ETH_HLEN);
346 int n;
347 uint16_t sizeppp;
348 sessionidt s;
349
350 if (t != TUNNEL_ID_PPPOE)
351 {
352 LOG(3, 0, t, "ERROR pppoe_sess_send: Tunnel %d is not a tunnel pppoe\n", t);
353 return;
354 }
355
356 s = ntohs(hdr->sid);
357 if (session[s].tunnel != t)
358 {
359 LOG(3, s, t, "ERROR pppoe_sess_send: Session is not a session pppoe\n");
360 return;
361 }
362
363 if (l < (ETH_HLEN + sizeof(*hdr) + 3))
364 {
365 LOG(0, s, t, "ERROR pppoe_sess_send: packet too small for pppoe sent (size=%d)\n", l);
366 return;
367 }
368
369 // recalculate the ppp frame length
370 sizeppp = l - (ETH_HLEN + sizeof(*hdr));
371 hdr->length = htons(sizeppp);
372
373 LOG_HEX(5, "pppoe_sess_send", pack, l);
374
375 n = write(pppoesessfd, pack, l);
376 if (n < 0 )
377 LOG(0, s, t, "pppoe_sess_send: write: %s\n", strerror(errno));
378 else if (n != l)
379 LOG(0, s, t, "pppoe_sess_send: short write %i/%i\n", n,l);
380 }
381
382 static void pppoe_send_err(const uint8_t *addr, const struct pppoe_tag *host_uniq, const struct pppoe_tag *relay_sid, int code, int tag_type)
383 {
384 uint8_t pack[ETHER_MAX_LEN];
385
386 setup_header(pack, config->pppoe_hwaddr, addr, code, 0, ETH_P_PPP_DISC);
387
388 add_tag(pack, TAG_AC_NAME, (uint8_t *)config->pppoe_ac_name, strlen(config->pppoe_ac_name));
389 add_tag(pack, tag_type, NULL, 0);
390
391 if (host_uniq)
392 add_tag2(pack, host_uniq);
393
394 if (relay_sid)
395 add_tag2(pack, relay_sid);
396
397 pppoe_disc_send(pack);
398 }
399
400 // generate cookie
401 static void pppoe_gen_cookie(const uint8_t *serv_hwaddr, const uint8_t *client_hwaddr, uint8_t *out)
402 {
403 MD5_CTX ctx;
404
405 MD5_Init(&ctx);
406 MD5_Update(&ctx, config->l2tp_secret, strlen(config->l2tp_secret));
407 MD5_Update(&ctx, (void *) serv_hwaddr, ETH_ALEN);
408 MD5_Update(&ctx, (void *) client_hwaddr, ETH_ALEN);
409 MD5_Final(out, &ctx);
410 }
411
412 // check cookie
413 static int pppoe_check_cookie(const uint8_t *serv_hwaddr, const uint8_t *client_hwaddr, uint8_t *cookie)
414 {
415 hasht hash;
416
417 pppoe_gen_cookie(serv_hwaddr, client_hwaddr, hash);
418
419 return memcmp(hash, cookie, 16);
420 }
421
422 static void pppoe_send_PADO(const uint8_t *addr, const struct pppoe_tag *host_uniq, const struct pppoe_tag *relay_sid, const struct pppoe_tag *service_name)
423 {
424 uint8_t pack[ETHER_MAX_LEN];
425 hasht hash;
426
427 setup_header(pack, config->pppoe_hwaddr, addr, CODE_PADO, 0, ETH_P_PPP_DISC);
428
429 add_tag(pack, TAG_AC_NAME, (uint8_t *)config->pppoe_ac_name, strlen(config->pppoe_ac_name));
430
431 if (service_name)
432 add_tag2(pack, service_name);
433
434 pppoe_gen_cookie(config->pppoe_hwaddr, addr, hash);
435 add_tag(pack, TAG_AC_COOKIE, hash, 16);
436
437 if (host_uniq)
438 add_tag2(pack, host_uniq);
439
440 if (relay_sid)
441 add_tag2(pack, relay_sid);
442
443 pppoe_disc_send(pack);
444 }
445
446 static void pppoe_send_PADS(uint16_t sid, const uint8_t *addr, const struct pppoe_tag *host_uniq, const struct pppoe_tag *relay_sid, const struct pppoe_tag *service_name)
447 {
448 uint8_t pack[ETHER_MAX_LEN];
449
450 setup_header(pack, config->pppoe_hwaddr, addr, CODE_PADS, sid, ETH_P_PPP_DISC);
451
452 add_tag(pack, TAG_AC_NAME, (uint8_t *)config->pppoe_ac_name, strlen(config->pppoe_ac_name));
453
454 add_tag2(pack, service_name);
455
456 if (host_uniq)
457 add_tag2(pack, host_uniq);
458
459 if (relay_sid)
460 add_tag2(pack, relay_sid);
461
462 pppoe_disc_send(pack);
463 }
464
465 static void pppoe_send_PADT(uint16_t sid)
466 {
467 uint8_t pack[ETHER_MAX_LEN];
468
469 setup_header(pack, config->pppoe_hwaddr, session[sid].src_hwaddr, CODE_PADT, sid, ETH_P_PPP_DISC);
470
471 add_tag(pack, TAG_AC_NAME, (uint8_t *)config->pppoe_ac_name, strlen(config->pppoe_ac_name));
472
473 LOG(3, sid, session[sid].tunnel, "pppoe: Sent PADT\n");
474
475 pppoe_disc_send(pack);
476 }
477
478 void pppoe_shutdown_session(sessionidt s)
479 {
480
481 if (session[s].tunnel != TUNNEL_ID_PPPOE)
482 {
483 LOG(3, s, session[s].tunnel, "ERROR pppoe_shutdown_session: Session is not a session pppoe\n");
484 return;
485 }
486
487 pppoe_send_PADT(s);
488 }
489
490 static void pppoe_recv_PADI(uint8_t *pack, int size)
491 {
492 struct ethhdr *ethhdr = (struct ethhdr *)pack;
493 struct pppoe_hdr *hdr = (struct pppoe_hdr *)(pack + ETH_HLEN);
494 struct pppoe_tag *tag;
495 struct pppoe_tag *host_uniq_tag = NULL;
496 struct pppoe_tag *relay_sid_tag = NULL;
497 struct pppoe_tag *service_name_tag = NULL;
498 int n, service_match = 0;
499 int len;
500
501 if (hdr->sid)
502 return;
503
504 len = ntohs(hdr->length);
505 for (n = 0; n < len; n += sizeof(*tag) + ntohs(tag->tag_len)) {
506 tag = (struct pppoe_tag *)(pack + ETH_HLEN + sizeof(*hdr) + n);
507 if (n + sizeof(*tag) + ntohs(tag->tag_len) > len)
508 return;
509 switch (ntohs(tag->tag_type)) {
510 case TAG_END_OF_LIST:
511 break;
512 case TAG_SERVICE_NAME:
513 if (*config->pppoe_service_name && tag->tag_len)
514 {
515 if (ntohs(tag->tag_len) != strlen(config->pppoe_service_name))
516 break;
517 if (memcmp(tag->tag_data, config->pppoe_service_name, ntohs(tag->tag_len)))
518 break;
519 service_match = 1;
520 }
521 else
522 {
523 service_name_tag = tag;
524 service_match = 1;
525 }
526 break;
527 case TAG_HOST_UNIQ:
528 host_uniq_tag = tag;
529 break;
530 case TAG_RELAY_SESSION_ID:
531 relay_sid_tag = tag;
532 break;
533 }
534 }
535
536 if (!service_match)
537 {
538 LOG(3, 0, 0, "pppoe: discarding PADI packet (Service-Name mismatch)\n");
539 return;
540 }
541
542 pppoe_send_PADO(ethhdr->h_source, host_uniq_tag, relay_sid_tag, service_name_tag);
543 }
544
545 static void pppoe_recv_PADR(uint8_t *pack, int size)
546 {
547 struct ethhdr *ethhdr = (struct ethhdr *)pack;
548 struct pppoe_hdr *hdr = (struct pppoe_hdr *)(pack + ETH_HLEN);
549 struct pppoe_tag *tag;
550 struct pppoe_tag *host_uniq_tag = NULL;
551 struct pppoe_tag *relay_sid_tag = NULL;
552 struct pppoe_tag *ac_cookie_tag = NULL;
553 struct pppoe_tag *service_name_tag = NULL;
554 int n, service_match = 0;
555 uint16_t sid;
556
557 if (!memcmp(ethhdr->h_dest, bc_addr, ETH_ALEN))
558 {
559 LOG(1, 0, 0, "Rcv pppoe: discard PADR (destination address is broadcast)\n");
560 return;
561 }
562
563 if (hdr->sid)
564 {
565 LOG(1, 0, 0, "Rcv pppoe: discarding PADR packet (sid is not zero)\n");
566 return;
567 }
568
569 for (n = 0; n < ntohs(hdr->length); n += sizeof(*tag) + ntohs(tag->tag_len))
570 {
571 tag = (struct pppoe_tag *)(pack + ETH_HLEN + sizeof(*hdr) + n);
572 switch (ntohs(tag->tag_type))
573 {
574 case TAG_END_OF_LIST:
575 break;
576 case TAG_SERVICE_NAME:
577 service_name_tag = tag;
578 if (tag->tag_len == 0)
579 service_match = 1;
580 else if (*config->pppoe_service_name)
581 {
582 if (ntohs(tag->tag_len) != strlen(config->pppoe_service_name))
583 break;
584 if (memcmp(tag->tag_data, config->pppoe_service_name, ntohs(tag->tag_len)))
585 break;
586 service_match = 1;
587 }
588 else
589 {
590 service_match = 1;
591 }
592 break;
593 case TAG_HOST_UNIQ:
594 host_uniq_tag = tag;
595 break;
596 case TAG_AC_COOKIE:
597 ac_cookie_tag = tag;
598 break;
599 case TAG_RELAY_SESSION_ID:
600 relay_sid_tag = tag;
601 break;
602 }
603 }
604
605 if (!service_match)
606 {
607 LOG(3, 0, 0, "pppoe: Service-Name mismatch\n");
608 pppoe_send_err(ethhdr->h_source, host_uniq_tag, relay_sid_tag, CODE_PADS, TAG_SERVICE_NAME_ERROR);
609 return;
610 }
611
612 if (!ac_cookie_tag)
613 {
614 LOG(3, 0, 0, "pppoe: discard PADR packet (no AC-Cookie tag present)\n");
615 return;
616 }
617
618 if (ntohs(ac_cookie_tag->tag_len) != 16)
619 {
620 LOG(3, 0, 0, "pppoe: discard PADR packet (incorrect AC-Cookie tag length)\n");
621 return;
622 }
623
624 if (pppoe_check_cookie(ethhdr->h_dest, ethhdr->h_source, (uint8_t *) ac_cookie_tag->tag_data))
625 {
626 LOG(3, 0, 0, "pppoe: discard PADR packet (incorrect AC-Cookie)\n");
627 return;
628 }
629
630 sid = sessionfree;
631 sessionfree = session[sid].next;
632 memset(&session[sid], 0, sizeof(session[0]));
633
634 if (sid > config->cluster_highest_sessionid)
635 config->cluster_highest_sessionid = sid;
636
637 session[sid].opened = time_now;
638 session[sid].tunnel = TUNNEL_ID_PPPOE;
639 session[sid].last_packet = session[sid].last_data = time_now;
640
641 //strncpy(session[sid].called, called, sizeof(session[sid].called) - 1);
642 //strncpy(session[sid].calling, calling, sizeof(session[sid].calling) - 1);
643
644 session[sid].ppp.phase = Establish;
645 session[sid].ppp.lcp = Starting;
646
647 session[sid].magic = time_now; // set magic number
648 session[sid].mru = PPPoE_MRU; // default
649
650 // start LCP
651 sess_local[sid].lcp_authtype = config->radius_authprefer;
652 sess_local[sid].ppp_mru = MRU;
653
654 // Set multilink options before sending initial LCP packet
655 sess_local[sid].mp_mrru = 1614;
656 sess_local[sid].mp_epdis = ntohl(config->iftun_address ? config->iftun_address : my_address);
657
658 memcpy(session[sid].src_hwaddr, ethhdr->h_source, ETH_ALEN);
659 pppoe_send_PADS(sid, ethhdr->h_source, host_uniq_tag, relay_sid_tag, service_name_tag);
660
661 sendlcp(sid, session[sid].tunnel);
662 change_state(sid, lcp, RequestSent);
663
664 }
665
666 static void pppoe_recv_PADT(uint8_t *pack)
667 {
668 struct ethhdr *ethhdr = (struct ethhdr *)pack;
669 struct pppoe_hdr *hdr = (struct pppoe_hdr *)(pack + ETH_HLEN);
670
671 if (!memcmp(ethhdr->h_dest, bc_addr, ETH_ALEN))
672 {
673 LOG(3, 0, 0, "pppoe: discard PADT (destination address is broadcast)\n");
674 return;
675 }
676
677 if (hdr->sid)
678 {
679 if ((hdr->sid < MAXSESSION) && (session[hdr->sid].tunnel == TUNNEL_ID_PPPOE))
680 sessionshutdown(hdr->sid, "Client shutdown", CDN_ADMIN_DISC, 0);
681 }
682 }
683
684 // fill in a PPPOE message with a PPP frame,
685 // returns start of PPP frame
686 uint8_t *pppoe_makeppp(uint8_t *b, int size, uint8_t *p, int l, sessionidt s, tunnelidt t,
687 uint16_t mtype, uint8_t prio, bundleidt bid, uint8_t mp_bits)
688 {
689 uint16_t type = mtype;
690 uint8_t *start = b;
691 struct pppoe_hdr *hdr = (struct pppoe_hdr *)(b + ETH_HLEN);
692
693 if (t != TUNNEL_ID_PPPOE)
694 return NULL;
695
696 if (size < 28) // Need more space than this!!
697 {
698 LOG(0, s, t, "pppoe_makeppp buffer too small for pppoe header (size=%d)\n", size);
699 return NULL;
700 }
701
702 // 14 bytes ethernet Header + 6 bytes header pppoe
703 b = setup_header(b, config->pppoe_hwaddr, session[s].src_hwaddr, CODE_SESS, s, ETH_P_PPP_SES);
704
705 // Check whether this session is part of multilink
706 if (bid)
707 {
708 if (bundle[bid].num_of_links > 1)
709 type = PPPMP; // Change PPP message type to the PPPMP
710 else
711 bid = 0;
712 }
713
714 *(uint16_t *) b = htons(type);
715 b += 2;
716 hdr->length += 2;
717
718 if (bid)
719 {
720 // Set the sequence number and (B)egin (E)nd flags
721 if (session[s].mssf)
722 {
723 // Set the multilink bits
724 uint16_t bits_send = mp_bits;
725 *(uint16_t *) b = htons((bundle[bid].seq_num_t & 0x0FFF)|bits_send);
726 b += 2;
727 hdr->length += 2;
728 }
729 else
730 {
731 *(uint32_t *) b = htonl(bundle[bid].seq_num_t);
732 // Set the multilink bits
733 *b = mp_bits;
734 b += 4;
735 hdr->length += 4;
736 }
737
738 bundle[bid].seq_num_t++;
739
740 // Add the message type if this fragment has the begin bit set
741 if (mp_bits & MP_BEGIN)
742 {
743 //*b++ = mtype; // The next two lines are instead of this
744 *(uint16_t *) b = htons(mtype); // Message type
745 b += 2;
746 hdr->length += 2;
747 }
748 }
749
750 if ((b - start) + l > size)
751 {
752 LOG(0, s, t, "pppoe_makeppp would overflow buffer (size=%d, header+payload=%td)\n", size, (b - start) + l);
753 return NULL;
754 }
755
756 // Copy the payload
757 if (p && l)
758 {
759 memcpy(b, p, l);
760 hdr->length += l;
761 }
762
763 return b;
764 }
765
766 // pppoe discovery recv data
767 void process_pppoe_disc(uint8_t *pack, int size)
768 {
769 struct ethhdr *ethhdr = (struct ethhdr *)pack;
770 struct pppoe_hdr *hdr = (struct pppoe_hdr *)(pack + ETH_HLEN);
771
772 LOG(3, 0, 0, "RCV pppoe_disc: Code %s from %s\n", get_string_codepad(hdr->code), fmtMacAddr(ethhdr->h_source));
773 LOG_HEX(5, "PPPOE Disc", pack, size);
774
775 if (!config->cluster_iam_master)
776 {
777 if (hdr->code == CODE_PADI)
778 return; // Discard because the PADI is received by all (PADI is a broadcast diffusion)
779
780 master_forward_pppoe_packet(pack, size, hdr->code);
781 return;
782 }
783
784 if (size < (ETH_HLEN + sizeof(*hdr)))
785 {
786 LOG(1, 0, 0, "Error pppoe_disc: short packet received (%i)\n", size);
787 return;
788 }
789
790 if (memcmp(ethhdr->h_dest, bc_addr, ETH_ALEN) && memcmp(ethhdr->h_dest, config->pppoe_hwaddr, ETH_ALEN))
791 {
792 LOG(1, 0, 0, "Error pppoe_disc: h_dest != bc_addr and h_dest != config->pppoe_hwaddr\n");
793 return;
794 }
795
796 if (!memcmp(ethhdr->h_source, bc_addr, ETH_ALEN))
797 {
798 LOG(1, 0, 0, "Error pppoe_disc: discarding packet (source address is broadcast)\n");
799 return;
800 }
801
802 if ((ethhdr->h_source[0] & 1) != 0)
803 {
804 LOG(1, 0, 0, "Error pppoe_disc: discarding packet (host address is not unicast)\n");
805 return;
806 }
807
808 if (size < ETH_HLEN + sizeof(*hdr) + ntohs(hdr->length))
809 {
810 LOG(1, 0, 0, "Error pppoe_disc: short packet received\n");
811 return;
812 }
813
814 if (hdr->ver != 1)
815 {
816 LOG(1, 0, 0, "Error pppoe_disc: discarding packet (unsupported version %i)\n", hdr->ver);
817 return;
818 }
819
820 if (hdr->type != 1)
821 {
822 LOG(1, 0, 0, "Error pppoe_disc: discarding packet (unsupported type %i)\n", hdr->type);
823 return;
824 }
825
826 switch (hdr->code) {
827 case CODE_PADI:
828 pppoe_recv_PADI(pack, size);
829 break;
830 case CODE_PADR:
831 pppoe_recv_PADR(pack, size);
832 break;
833 case CODE_PADT:
834 pppoe_recv_PADT(pack);
835 break;
836 }
837 }
838
839 #ifdef LAC
840 // Forward from pppoe to l2tp remote LNS
841 static void pppoe_forwardto_session_rmlns(uint8_t *pack, int size, sessionidt sess, uint16_t proto)
842 {
843 struct pppoe_hdr *hdr = (struct pppoe_hdr *)(pack + ETH_HLEN);
844 uint16_t lppp = ntohs(hdr->length);
845 uint16_t ll2tp = lppp + 6;
846 uint8_t *pppdata = (uint8_t *) hdr->tag;
847 uint8_t *pl2tp = pppdata - 6;
848 uint8_t *p = pl2tp;
849 uint16_t t = 0, s = 0;
850
851 s = session[sess].forwardtosession;
852 if (session[s].forwardtosession != sess)
853 {
854 LOG(3, sess, session[sess].tunnel, "pppoe: Link Session (%u) broken\n", s);
855 return;
856 }
857
858 t = session[s].tunnel;
859 if (t >= MAXTUNNEL)
860 {
861 LOG(1, s, t, "pppoe: Session with invalid tunnel ID\n");
862 return;
863 }
864
865 if (!tunnel[t].isremotelns)
866 {
867 LOG(3, sess, session[sess].tunnel, "pppoe: Link Tunnel/Session (%u/%u) broken\n", s, t);
868 return;
869 }
870
871 // First word L2TP options (with no options)
872 *(uint16_t *) p = htons(0x0002);
873 p += 2;
874 *(uint16_t *) p = htons(tunnel[t].far); // tunnel
875 p += 2;
876 *(uint16_t *) p = htons(session[s].far); // session
877 p += 2;
878
879 if ((proto == PPPIP) || (proto == PPPMP) ||(proto == PPPIPV6 && config->ipv6_prefix.s6_addr[0]))
880 {
881 session[sess].last_packet = session[sess].last_data = time_now;
882 // Update STAT IN
883 increment_counter(&session[sess].cin, &session[sess].cin_wrap, ll2tp);
884 session[sess].cin_delta += ll2tp;
885 session[sess].pin++;
886 sess_local[sess].cin += ll2tp;
887 sess_local[sess].pin++;
888
889 session[s].last_data = time_now;
890 // Update STAT OUT
891 increment_counter(&session[s].cout, &session[s].cout_wrap, ll2tp); // byte count
892 session[s].cout_delta += ll2tp;
893 session[s].pout++;
894 sess_local[s].cout += ll2tp;
895 sess_local[s].pout++;
896 }
897 else
898 session[sess].last_packet = time_now;
899
900 tunnelsend(pl2tp, ll2tp, t); // send it...
901 }
902
903 // Forward from l2tp to pppoe
904 // (note: THIS ROUTINE WRITES TO pack[-20]).
905 void pppoe_forwardto_session_pppoe(uint8_t *pack, int size, sessionidt sess, uint16_t proto)
906 {
907 uint16_t t = 0, s = 0;
908 uint16_t lpppoe = size - 2;
909 uint8_t *p = pack + 2; // First word L2TP options
910
911 LOG(5, sess, session[sess].tunnel, "Forwarding data session to pppoe session %u\n", session[sess].forwardtosession);
912
913 s = session[sess].forwardtosession;
914 t = session[s].tunnel;
915
916 if (*pack & 0x40)
917 { // length
918 p += 2;
919 lpppoe -= 2;
920 }
921
922 *(uint16_t *) p = htons(tunnel[t].far); // tunnel
923 p += 2;
924 *(uint16_t *) p = htons(session[s].far); // session
925 p += 2;
926 lpppoe -= 4;
927
928 if (*pack & 0x08)
929 { // ns/nr
930 *(uint16_t *) p = htons(tunnel[t].ns); // sequence
931 p += 2;
932 *(uint16_t *) p = htons(tunnel[t].nr); // sequence
933 p += 2;
934 lpppoe -= 4;
935 }
936
937 if (lpppoe > 2 && p[0] == 0xFF && p[1] == 0x03)
938 {
939 // HDLC address header, discard in pppoe
940 p += 2;
941 lpppoe -= 2;
942 }
943
944 lpppoe += (ETH_HLEN + sizeof(struct pppoe_hdr));
945 p -= (ETH_HLEN + sizeof(struct pppoe_hdr));
946
947 // 14 bytes ethernet Header + 6 bytes header pppoe
948 setup_header(p, config->pppoe_hwaddr, session[s].src_hwaddr, CODE_SESS, s, ETH_P_PPP_SES);
949
950 if ((proto == PPPIP) || (proto == PPPMP) ||(proto == PPPIPV6 && config->ipv6_prefix.s6_addr[0]))
951 {
952 session[sess].last_packet = session[sess].last_data = time_now;
953 // Update STAT IN
954 increment_counter(&session[sess].cin, &session[sess].cin_wrap, lpppoe);
955 session[sess].cin_delta += lpppoe;
956 session[sess].pin++;
957 sess_local[sess].cin += lpppoe;
958 sess_local[sess].pin++;
959
960 session[s].last_data = time_now;
961 // Update STAT OUT
962 increment_counter(&session[s].cout, &session[s].cout_wrap, lpppoe); // byte count
963 session[s].cout_delta += lpppoe;
964 session[s].pout++;
965 sess_local[s].cout += lpppoe;
966 sess_local[s].pout++;
967 }
968 else
969 session[sess].last_packet = time_now;
970
971 tunnelsend(p, lpppoe, t); // send it....
972 }
973 #endif
974
975 void process_pppoe_sess(uint8_t *pack, int size)
976 {
977 //struct ethhdr *ethhdr = (struct ethhdr *)pack;
978 struct pppoe_hdr *hdr = (struct pppoe_hdr *)(pack + ETH_HLEN);
979 uint16_t lppp = ntohs(hdr->length);
980 uint8_t *pppdata = (uint8_t *) hdr->tag;
981 uint16_t proto, sid, t;
982
983 sid = ntohs(hdr->sid);
984 t = TUNNEL_ID_PPPOE;
985
986 LOG_HEX(5, "RCV PPPOE Sess", pack, size);
987
988 if (sid >= MAXSESSION)
989 {
990 LOG(0, sid, t, "Received pppoe packet with invalid session ID\n");
991 STAT(tunnel_rx_errors);
992 return;
993 }
994
995 if (session[sid].tunnel != t)
996 {
997 if (!config->cluster_iam_master) { master_forward_pppoe_packet(pack, size, hdr->code); return; }
998
999 LOG(1, sid, t, "ERROR process_pppoe_sess: Session is not a session pppoe\n");
1000 return;
1001 }
1002
1003 if (hdr->ver != 1)
1004 {
1005 LOG(3, sid, t, "Error process_pppoe_sess: discarding packet (unsupported version %i)\n", hdr->ver);
1006 return;
1007 }
1008
1009 if (hdr->type != 1)
1010 {
1011 LOG(3, sid, t, "Error process_pppoe_sess: discarding packet (unsupported type %i)\n", hdr->type);
1012 return;
1013 }
1014
1015 if (lppp > 2 && pppdata[0] == 0xFF && pppdata[1] == 0x03)
1016 { // HDLC address header, discard
1017 LOG(5, sid, t, "pppoe_sess: HDLC address header, discard\n");
1018 pppdata += 2;
1019 lppp -= 2;
1020 }
1021 if (lppp < 2)
1022 {
1023 LOG(3, sid, t, "Error process_pppoe_sess: Short ppp length %d\n", lppp);
1024 return;
1025 }
1026 if (*pppdata & 1)
1027 {
1028 proto = *pppdata++;
1029 lppp--;
1030 }
1031 else
1032 {
1033 proto = ntohs(*(uint16_t *) pppdata);
1034 pppdata += 2;
1035 lppp -= 2;
1036 }
1037
1038 #ifdef LAC
1039 if (session[sid].forwardtosession)
1040 { // Must be forwaded to a remote lns tunnel l2tp
1041 pppoe_forwardto_session_rmlns(pack, size, sid, proto);
1042 return;
1043 }
1044 #endif
1045
1046 if (proto == PPPPAP)
1047 {
1048 session[sid].last_packet = time_now;
1049 if (!config->cluster_iam_master) { master_forward_pppoe_packet(pack, size, hdr->code); return; }
1050 processpap(sid, t, pppdata, lppp);
1051 }
1052 else if (proto == PPPCHAP)
1053 {
1054 session[sid].last_packet = time_now;
1055 if (!config->cluster_iam_master) { master_forward_pppoe_packet(pack, size, hdr->code); return; }
1056 processchap(sid, t, pppdata, lppp);
1057 }
1058 else if (proto == PPPLCP)
1059 {
1060 session[sid].last_packet = time_now;
1061 if (!config->cluster_iam_master) { master_forward_pppoe_packet(pack, size, hdr->code); return; }
1062 processlcp(sid, t, pppdata, lppp);
1063 }
1064 else if (proto == PPPIPCP)
1065 {
1066 session[sid].last_packet = time_now;
1067 if (!config->cluster_iam_master) { master_forward_pppoe_packet(pack, size, hdr->code); return; }
1068 processipcp(sid, t, pppdata, lppp);
1069 }
1070 else if (proto == PPPIPV6CP && config->ipv6_prefix.s6_addr[0])
1071 {
1072 session[sid].last_packet = time_now;
1073 if (!config->cluster_iam_master) { master_forward_pppoe_packet(pack, size, hdr->code); return; }
1074 processipv6cp(sid, t, pppdata, lppp);
1075 }
1076 else if (proto == PPPCCP)
1077 {
1078 session[sid].last_packet = time_now;
1079 if (!config->cluster_iam_master) { master_forward_pppoe_packet(pack, size, hdr->code); return; }
1080 processccp(sid, t, pppdata, lppp);
1081 }
1082 else if (proto == PPPIP)
1083 {
1084 session[sid].last_packet = session[sid].last_data = time_now;
1085 if (session[sid].walled_garden && !config->cluster_iam_master) { master_forward_pppoe_packet(pack, size, hdr->code); return; }
1086 processipin(sid, t, pppdata, lppp);
1087 }
1088 else if (proto == PPPMP)
1089 {
1090 session[sid].last_packet = session[sid].last_data = time_now;
1091 if (!config->cluster_iam_master) { master_forward_pppoe_packet(pack, size, hdr->code); return; }
1092 processmpin(sid, t, pppdata, lppp);
1093 }
1094 else if (proto == PPPIPV6 && config->ipv6_prefix.s6_addr[0])
1095 {
1096 session[sid].last_packet = session[sid].last_data = time_now;
1097 if (session[sid].walled_garden && !config->cluster_iam_master) { master_forward_pppoe_packet(pack, size, hdr->code); return; }
1098 processipv6in(sid, t, pppdata, lppp);
1099 }
1100 else if (session[sid].ppp.lcp == Opened)
1101 {
1102 session[sid].last_packet = time_now;
1103 if (!config->cluster_iam_master) { master_forward_pppoe_packet(pack, size, hdr->code); return; }
1104 protoreject(sid, t, pppdata, lppp, proto);
1105 }
1106 else
1107 {
1108 LOG(3, sid, t, "process_pppoe_sess: Unknown PPP protocol 0x%04X received in LCP %s state\n",
1109 proto, ppp_state(session[sid].ppp.lcp));
1110 }
1111 }
1112
1113 void pppoe_send_garp()
1114 {
1115 int s;
1116 struct ifreq ifr;
1117 uint8_t mac[6];
1118
1119 if (!*config->pppoe_if_to_bind)
1120 return;
1121
1122 s = socket(PF_INET, SOCK_DGRAM, 0);
1123 if (s < 0)
1124 {
1125 LOG(0, 0, 0, "Error creating socket for GARP: %s\n", strerror(errno));
1126 return;
1127 }
1128 memset(&ifr, 0, sizeof(ifr));
1129 strncpy(ifr.ifr_name, config->pppoe_if_to_bind, sizeof(ifr.ifr_name) - 1);
1130 if (ioctl(s, SIOCGIFHWADDR, &ifr) < 0)
1131 {
1132 LOG(0, 0, 0, "Error getting eth0 hardware address for GARP: %s\n", strerror(errno));
1133 close(s);
1134 return;
1135 }
1136 memcpy(mac, &ifr.ifr_hwaddr.sa_data, 6*sizeof(char));
1137 if (ioctl(s, SIOCGIFINDEX, &ifr) < 0)
1138 {
1139 LOG(0, 0, 0, "Error getting eth0 interface index for GARP: %s\n", strerror(errno));
1140 close(s);
1141 return;
1142 }
1143 close(s);
1144
1145 sendarp(ifr.ifr_ifindex, mac, config->iftun_address);
1146 }
1147
1148 // rcv pppoe data from slave
1149 void pppoe_process_forward(uint8_t *pack, int size, in_addr_t addr)
1150 {
1151 struct ethhdr *ethhdr = (struct ethhdr *)pack;
1152
1153 if (ethhdr->h_proto == htons(ETH_P_PPP_DISC))
1154 process_pppoe_disc(pack, size);
1155 else if (ethhdr->h_proto == htons(ETH_P_PPP_SES))
1156 process_pppoe_sess(pack, size);
1157 else
1158 LOG(0, 0, 0, "pppoe_process_forward: I got a C_PPPOE_FORWARD from %s, but not a PPPOE data?\n", fmtaddr(addr, 0));
1159 }