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 }