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