pppd/plugins/rp-pppoe/plugin.c

   1 /***********************************************************************
   2 *
   3 * plugin.c
   4 *
   5 * pppd plugin for kernel-mode PPPoE on Linux
   6 *
   7 * Copyright (C) 2001 by Roaring Penguin Software Inc., Michal Ostrowski
   8 * and Jamal Hadi Salim.
   9 *
  10 * Much code and many ideas derived from pppoe plugin by Michal
  11 * Ostrowski and Jamal Hadi Salim, which carries this copyright:
  12 *
  13 * Copyright 2000 Michal Ostrowski <mostrows@styx.uwaterloo.ca>,
  14 *                Jamal Hadi Salim <hadi@cyberus.ca>
  15 * Borrows heavily from the PPPoATM plugin by Mitchell Blank Jr.,
  16 * which is based in part on work from Jens Axboe and Paul Mackerras.
  17 *
  18 * This program is free software; you can redistribute it and/or
  19 * modify it under the terms of the GNU General Public License
  20 * as published by the Free Software Foundation; either version
  21 * 2 of the License, or (at your option) any later version.
  22 *
  23 ***********************************************************************/
  24
  25 static char const RCSID[] =
  26 "$Id: plugin.c,v 1.17 2008/06/15 04:35:50 paulus Exp $";
  27
  28 #define _GNU_SOURCE 1
  29 #include "pppoe.h"
  30
  31 #include "pppd/pppd.h"
  32 #include "pppd/fsm.h"
  33 #include "pppd/lcp.h"
  34 #include "pppd/ipcp.h"
  35 #include "pppd/ccp.h"
  36 /* #include "pppd/pathnames.h" */
  37
  38 #include <linux/types.h>
  39 #include <sys/ioctl.h>
  40 #include <sys/types.h>
  41 #include <sys/socket.h>
  42 #include <sys/stat.h>
  43 #include <string.h>
  44 #include <stdlib.h>
  45 #include <errno.h>
  46 #include <unistd.h>
  47 #include <fcntl.h>
  48 #include <signal.h>
  49 #include <net/if_arp.h>
  50 #include <linux/ppp_defs.h>
  51 #include <linux/if_pppox.h>
  52
  53 #ifndef _ROOT_PATH
  54 #define _ROOT_PATH ""
  55 #endif
  56
  57 #define _PATH_ETHOPT         _ROOT_PATH "/etc/ppp/options."
  58
  59 char pppd_version[] = VERSION;
  60
  61 /* From sys-linux.c in pppd -- MUST FIX THIS! */
  62 extern int new_style_driver;
  63
  64 char *pppd_pppoe_service = NULL;
  65 static char *acName = NULL;
  66 static char *existingSession = NULL;
  67 static int printACNames = 0;
  68 static char *pppoe_reqd_mac = NULL;
  69 unsigned char pppoe_reqd_mac_addr[6];
  70 static char *host_uniq;
  71 static int pppoe_padi_timeout = PADI_TIMEOUT;
  72 static int pppoe_padi_attempts = MAX_PADI_ATTEMPTS;
  73
  74 static int PPPoEDevnameHook(char *cmd, char **argv, int doit);
  75 static option_t Options[] = {
  76     { "device name", o_wild, (void *) &PPPoEDevnameHook,
  77       "PPPoE device name",
  78       OPT_DEVNAM | OPT_PRIVFIX | OPT_NOARG  | OPT_A2STRVAL | OPT_STATIC,
  79       devnam},
  80     { "rp_pppoe_service", o_string, &pppd_pppoe_service,
  81       "Desired PPPoE service name" },
  82     { "rp_pppoe_ac",      o_string, &acName,
  83       "Desired PPPoE access concentrator name" },
  84     { "rp_pppoe_sess",    o_string, &existingSession,
  85       "Attach to existing session (sessid:macaddr)" },
  86     { "rp_pppoe_verbose", o_int, &printACNames,
  87       "Be verbose about discovered access concentrators"},
  88     { "pppoe-mac", o_string, &pppoe_reqd_mac,
  89       "Only connect to specified MAC address" },
  90     { "host-uniq", o_string, &host_uniq,
  91       "Set the Host-Uniq to the supplied hex string" },
  92     { "pppoe-padi-timeout", o_int, &pppoe_padi_timeout,
  93       "Initial timeout for discovery packets in seconds" },
  94     { "pppoe-padi-attempts", o_int, &pppoe_padi_attempts,
  95       "Number of discovery attempts" },
  96     { NULL }
  97 };
  98 int (*OldDevnameHook)(char *cmd, char **argv, int doit) = NULL;
  99 static PPPoEConnection *conn = NULL;
 100
 101 /**********************************************************************
 102  * %FUNCTION: PPPOEInitDevice
 103  * %ARGUMENTS:
 104  * None
 105  * %RETURNS:
 106  *
 107  * %DESCRIPTION:
 108  * Initializes PPPoE device.
 109  ***********************************************************************/
 110 static int
 111 PPPOEInitDevice(void)
 112 {
 113     conn = malloc(sizeof(PPPoEConnection));
 114     if (!conn) {
 115         novm("PPPoE session data");
 116     }
 117     memset(conn, 0, sizeof(PPPoEConnection));
 118     conn->ifName = devnam;
 119     conn->discoverySocket = -1;
 120     conn->sessionSocket = -1;
 121     conn->printACNames = printACNames;
 122     conn->discoveryTimeout = pppoe_padi_timeout;
 123     conn->discoveryAttempts = pppoe_padi_attempts;
 124     return 1;
 125 }
 126
 127 /**********************************************************************
 128  * %FUNCTION: PPPOEConnectDevice
 129  * %ARGUMENTS:
 130  * None
 131  * %RETURNS:
 132  * Non-negative if all goes well; -1 otherwise
 133  * %DESCRIPTION:
 134  * Connects PPPoE device.
 135  ***********************************************************************/
 136 static int
 137 PPPOEConnectDevice(void)
 138 {
 139     struct sockaddr_pppox sp;
 140     struct ifreq ifr;
 141     int s;
 142
 143     /* Open session socket before discovery phase, to avoid losing session */
 144     /* packets sent by peer just after PADS packet (noted on some Cisco    */
 145     /* server equipment).                                                  */
 146     /* Opening this socket just before waitForPADS in the discovery()      */
 147     /* function would be more appropriate, but it would mess-up the code   */
 148     conn->sessionSocket = socket(AF_PPPOX, SOCK_STREAM, PX_PROTO_OE);
 149     if (conn->sessionSocket < 0) {
 150         error("Failed to create PPPoE socket: %m");
 151         return -1;
 152     }
 153
 154     /* Restore configuration */
 155     lcp_allowoptions[0].mru = conn->mtu;
 156     lcp_wantoptions[0].mru = conn->mru;
 157
 158     /* Update maximum MRU */
 159     s = socket(AF_INET, SOCK_DGRAM, 0);
 160     if (s < 0) {
 161         error("Can't get MTU for %s: %m", conn->ifName);
 162         goto errout;
 163     }
 164     strlcpy(ifr.ifr_name, conn->ifName, sizeof(ifr.ifr_name));
 165     if (ioctl(s, SIOCGIFMTU, &ifr) < 0) {
 166         error("Can't get MTU for %s: %m", conn->ifName);
 167         close(s);
 168         goto errout;
 169     }
 170     close(s);
 171
 172     if (lcp_allowoptions[0].mru > ifr.ifr_mtu - TOTAL_OVERHEAD)
 173         lcp_allowoptions[0].mru = ifr.ifr_mtu - TOTAL_OVERHEAD;
 174     if (lcp_wantoptions[0].mru > ifr.ifr_mtu - TOTAL_OVERHEAD)
 175         lcp_wantoptions[0].mru = ifr.ifr_mtu - TOTAL_OVERHEAD;
 176
 177     if (host_uniq) {
 178         if (!parseHostUniq(host_uniq, &conn->hostUniq))
 179             fatal("Illegal value for host-uniq option");
 180     } else {
 181         /* if a custom host-uniq is not supplied, use our PID */
 182         pid_t pid = getpid();
 183         conn->hostUniq.type = htons(TAG_HOST_UNIQ);
 184         conn->hostUniq.length = htons(sizeof(pid));
 185         memcpy(conn->hostUniq.payload, &pid, sizeof(pid));
 186     }
 187
 188     conn->acName = acName;
 189     conn->serviceName = pppd_pppoe_service;
 190     strlcpy(ppp_devnam, devnam, sizeof(ppp_devnam));
 191     if (existingSession) {
 192         unsigned int mac[ETH_ALEN];
 193         int i, ses;
 194         if (sscanf(existingSession, "%d:%x:%x:%x:%x:%x:%x",
 195                    &ses, &mac[0], &mac[1], &mac[2],
 196                    &mac[3], &mac[4], &mac[5]) != 7) {
 197             fatal("Illegal value for rp_pppoe_sess option");
 198         }
 199         conn->session = htons(ses);
 200         for (i=0; i<ETH_ALEN; i++) {
 201             conn->peerEth[i] = (unsigned char) mac[i];
 202         }
 203     } else {
 204         conn->discoverySocket =
 205             openInterface(conn->ifName, Eth_PPPOE_Discovery, conn->myEth);
 206         discovery(conn);
 207         if (conn->discoveryState != STATE_SESSION) {
 208             error("Unable to complete PPPoE Discovery");
 209             goto errout;
 210         }
 211     }
 212
 213     /* Set PPPoE session-number for further consumption */
 214     ppp_session_number = ntohs(conn->session);
 215
 216     sp.sa_family = AF_PPPOX;
 217     sp.sa_protocol = PX_PROTO_OE;
 218     sp.sa_addr.pppoe.sid = conn->session;
 219     memcpy(sp.sa_addr.pppoe.dev, conn->ifName, IFNAMSIZ);
 220     memcpy(sp.sa_addr.pppoe.remote, conn->peerEth, ETH_ALEN);
 221
 222     /* Set remote_number for ServPoET */
 223     sprintf(remote_number, "%02X:%02X:%02X:%02X:%02X:%02X",
 224             (unsigned) conn->peerEth[0],
 225             (unsigned) conn->peerEth[1],
 226             (unsigned) conn->peerEth[2],
 227             (unsigned) conn->peerEth[3],
 228             (unsigned) conn->peerEth[4],
 229             (unsigned) conn->peerEth[5]);
 230
 231     warn("Connected to %02X:%02X:%02X:%02X:%02X:%02X via interface %s",
 232          (unsigned) conn->peerEth[0],
 233          (unsigned) conn->peerEth[1],
 234          (unsigned) conn->peerEth[2],
 235          (unsigned) conn->peerEth[3],
 236          (unsigned) conn->peerEth[4],
 237          (unsigned) conn->peerEth[5],
 238          conn->ifName);
 239
 240     script_setenv("MACREMOTE", remote_number, 0);
 241
 242     if (connect(conn->sessionSocket, (struct sockaddr *) &sp,
 243                 sizeof(struct sockaddr_pppox)) < 0) {
 244         error("Failed to connect PPPoE socket: %d %m", errno);
 245         goto errout;
 246     }
 247
 248     return conn->sessionSocket;
 249
 250  errout:
 251     if (conn->discoverySocket >= 0) {
 252         sendPADT(conn, NULL);
 253         close(conn->discoverySocket);
 254         conn->discoverySocket = -1;
 255     }
 256     close(conn->sessionSocket);
 257     return -1;
 258 }
 259
 260 static void
 261 PPPOERecvConfig(int mru,
 262                 u_int32_t asyncmap,
 263                 int pcomp,
 264                 int accomp)
 265 {
 266 #if 0 /* broken protocol, but no point harrassing the users I guess... */
 267     if (mru > MAX_PPPOE_MTU)
 268         warn("Couldn't increase MRU to %d", mru);
 269 #endif
 270 }
 271
 272 /**********************************************************************
 273  * %FUNCTION: PPPOEDisconnectDevice
 274  * %ARGUMENTS:
 275  * None
 276  * %RETURNS:
 277  * Nothing
 278  * %DESCRIPTION:
 279  * Disconnects PPPoE device
 280  ***********************************************************************/
 281 static void
 282 PPPOEDisconnectDevice(void)
 283 {
 284     struct sockaddr_pppox sp;
 285
 286     sp.sa_family = AF_PPPOX;
 287     sp.sa_protocol = PX_PROTO_OE;
 288     sp.sa_addr.pppoe.sid = 0;
 289     memcpy(sp.sa_addr.pppoe.dev, conn->ifName, IFNAMSIZ);
 290     memcpy(sp.sa_addr.pppoe.remote, conn->peerEth, ETH_ALEN);
 291     if (connect(conn->sessionSocket, (struct sockaddr *) &sp,
 292                 sizeof(struct sockaddr_pppox)) < 0 && errno != EALREADY)
 293         error("Failed to disconnect PPPoE socket: %d %m", errno);
 294     close(conn->sessionSocket);
 295     if (conn->discoverySocket >= 0) {
 296         sendPADT(conn, NULL);
 297         close(conn->discoverySocket);
 298     }
 299 }
 300
 301 static void
 302 PPPOEDeviceOptions(void)
 303 {
 304     char buf[MAXPATHLEN];
 305
 306     strlcpy(buf, _PATH_ETHOPT, MAXPATHLEN);
 307     strlcat(buf, devnam, MAXPATHLEN);
 308     if (!options_from_file(buf, 0, 0, 1))
 309         exit(EXIT_OPTION_ERROR);
 310
 311 }
 312
 313 struct channel pppoe_channel;
 314
 315 /**********************************************************************
 316  * %FUNCTION: PPPoEDevnameHook
 317  * %ARGUMENTS:
 318  * cmd -- the command (actually, the device name
 319  * argv -- argument vector
 320  * doit -- if non-zero, set device name.  Otherwise, just check if possible
 321  * %RETURNS:
 322  * 1 if we will handle this device; 0 otherwise.
 323  * %DESCRIPTION:
 324  * Checks if name is a valid interface name; if so, returns 1.  Also
 325  * sets up devnam (string representation of device).
 326  ***********************************************************************/
 327 static int
 328 PPPoEDevnameHook(char *cmd, char **argv, int doit)
 329 {
 330     int r = 1;
 331     int fd;
 332     struct ifreq ifr;
 333
 334     /*
 335      * Take any otherwise-unrecognized option as a possible device name,
 336      * and test if it is the name of a network interface with a
 337      * hardware address whose sa_family is ARPHRD_ETHER.
 338      */
 339     if (strlen(cmd) > 4 && !strncmp(cmd, "nic-", 4)) {
 340         /* Strip off "nic-" */
 341         cmd += 4;
 342     }
 343
 344     /* Open a socket */
 345     if ((fd = socket(PF_PACKET, SOCK_RAW, 0)) < 0) {
 346         r = 0;
 347     }
 348
 349     /* Try getting interface index */
 350     if (r) {
 351         strlcpy(ifr.ifr_name, cmd, sizeof(ifr.ifr_name));
 352         if (ioctl(fd, SIOCGIFINDEX, &ifr) < 0) {
 353             r = 0;
 354         } else {
 355             if (ioctl(fd, SIOCGIFHWADDR, &ifr) < 0) {
 356                 r = 0;
 357             } else {
 358                 if (ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER) {
 359                     if (doit)
 360                         error("Interface %s not Ethernet", cmd);
 361                     r = 0;
 362                 }
 363             }
 364         }
 365     }
 366
 367     /* Close socket */
 368     close(fd);
 369     if (r && doit) {
 370         strlcpy(devnam, cmd, sizeof(devnam));
 371         if (the_channel != &pppoe_channel) {
 372
 373             the_channel = &pppoe_channel;
 374             modem = 0;
 375
 376             PPPOEInitDevice();
 377         }
 378         return 1;
 379     }
 380
 381     return r;
 382 }
 383
 384 /**********************************************************************
 385  * %FUNCTION: plugin_init
 386  * %ARGUMENTS:
 387  * None
 388  * %RETURNS:
 389  * Nothing
 390  * %DESCRIPTION:
 391  * Initializes hooks for pppd plugin
 392  ***********************************************************************/
 393 void
 394 plugin_init(void)
 395 {
 396     if (!ppp_available() && !new_style_driver) {
 397         fatal("Linux kernel does not support PPPoE -- are you running 2.4.x?");
 398     }
 399
 400     add_options(Options);
 401
 402     info("RP-PPPoE plugin version %s compiled against pppd %s",
 403          RP_VERSION, VERSION);
 404 }
 405
 406 void pppoe_check_options(void)
 407 {
 408     unsigned int mac[6];
 409     int i;
 410
 411     if (pppoe_reqd_mac != NULL) {
 412         if (sscanf(pppoe_reqd_mac, "%x:%x:%x:%x:%x:%x",
 413                    &mac[0], &mac[1], &mac[2], &mac[3],
 414                    &mac[4], &mac[5]) != 6) {
 415             option_error("cannot parse pppoe-mac option value");
 416             exit(EXIT_OPTION_ERROR);
 417         }
 418         for (i = 0; i < 6; ++i)
 419             conn->req_peer_mac[i] = mac[i];
 420         conn->req_peer = 1;
 421     }
 422
 423     lcp_allowoptions[0].neg_accompression = 0;
 424     lcp_wantoptions[0].neg_accompression = 0;
 425
 426     lcp_allowoptions[0].neg_asyncmap = 0;
 427     lcp_wantoptions[0].neg_asyncmap = 0;
 428
 429     lcp_allowoptions[0].neg_pcompression = 0;
 430     lcp_wantoptions[0].neg_pcompression = 0;
 431
 432     if (lcp_allowoptions[0].mru > MAX_PPPOE_MTU)
 433         lcp_allowoptions[0].mru = MAX_PPPOE_MTU;
 434     if (lcp_wantoptions[0].mru > MAX_PPPOE_MTU)
 435         lcp_wantoptions[0].mru = MAX_PPPOE_MTU;
 436
 437     /* Save configuration */
 438     conn->mtu = lcp_allowoptions[0].mru;
 439     conn->mru = lcp_wantoptions[0].mru;
 440
 441     ccp_allowoptions[0].deflate = 0;
 442     ccp_wantoptions[0].deflate = 0;
 443
 444     ipcp_allowoptions[0].neg_vj = 0;
 445     ipcp_wantoptions[0].neg_vj = 0;
 446
 447     ccp_allowoptions[0].bsd_compress = 0;
 448     ccp_wantoptions[0].bsd_compress = 0;
 449 }
 450
 451 struct channel pppoe_channel = {
 452     .options = Options,
 453     .process_extra_options = &PPPOEDeviceOptions,
 454     .check_options = pppoe_check_options,
 455     .connect = &PPPOEConnectDevice,
 456     .disconnect = &PPPOEDisconnectDevice,
 457     .establish_ppp = &generic_establish_ppp,
 458     .disestablish_ppp = &generic_disestablish_ppp,
 459     .send_config = NULL,
 460     .recv_config = &PPPOERecvConfig,
 461     .close = NULL,
 462     .cleanup = NULL
 463 };