networking/udhcp/dhcprelay.c

   1 /* vi: set sw=4 ts=4: */
   2 /* Port to Busybox Copyright (C) 2006 Jesse Dutton <jessedutton@gmail.com>
   3  *
   4  * Licensed under GPL v2, see file LICENSE in this tarball for details.
   5  *
   6  * DHCP Relay for 'DHCPv4 Configuration of IPSec Tunnel Mode' support
   7  * Copyright (C) 2002 Mario Strasser <mast@gmx.net>,
   8  *                   Zuercher Hochschule Winterthur,
   9  *                   Netbeat AG
  10  * Upstream has GPL v2 or later
  11  */
  12
  13 #include "common.h"
  14
  15 #define SERVER_PORT      67
  16 #define SELECT_TIMEOUT    5 /* select timeout in sec. */
  17 #define MAX_LIFETIME   2*60 /* lifetime of an xid entry in sec. */
  18
  19 /* This list holds information about clients. The xid_* functions manipulate this list. */
  20 struct xid_item {
  21         unsigned timestamp;
  22         int client;
  23         uint32_t xid;
  24         struct sockaddr_in ip;
  25         struct xid_item *next;
  26 };
  27
  28 #define dhcprelay_xid_list (*(struct xid_item*)&bb_common_bufsiz1)
  29
  30 static struct xid_item *xid_add(uint32_t xid, struct sockaddr_in *ip, int client)
  31 {
  32         struct xid_item *item;
  33
  34         /* create new xid entry */
  35         item = xmalloc(sizeof(struct xid_item));
  36
  37         /* add xid entry */
  38         item->ip = *ip;
  39         item->xid = xid;
  40         item->client = client;
  41         item->timestamp = monotonic_sec();
  42         item->next = dhcprelay_xid_list.next;
  43         dhcprelay_xid_list.next = item;
  44
  45         return item;
  46 }
  47
  48 static void xid_expire(void)
  49 {
  50         struct xid_item *item = dhcprelay_xid_list.next;
  51         struct xid_item *last = &dhcprelay_xid_list;
  52         unsigned current_time = monotonic_sec();
  53
  54         while (item != NULL) {
  55                 if ((current_time - item->timestamp) > MAX_LIFETIME) {
  56                         last->next = item->next;
  57                         free(item);
  58                         item = last->next;
  59                 } else {
  60                         last = item;
  61                         item = item->next;
  62                 }
  63         }
  64 }
  65
  66 static struct xid_item *xid_find(uint32_t xid)
  67 {
  68         struct xid_item *item = dhcprelay_xid_list.next;
  69         while (item != NULL) {
  70                 if (item->xid == xid) {
  71                         return item;
  72                 }
  73                 item = item->next;
  74         }
  75         return NULL;
  76 }
  77
  78 static void xid_del(uint32_t xid)
  79 {
  80         struct xid_item *item = dhcprelay_xid_list.next;
  81         struct xid_item *last = &dhcprelay_xid_list;
  82         while (item != NULL) {
  83                 if (item->xid == xid) {
  84                         last->next = item->next;
  85                         free(item);
  86                         item = last->next;
  87                 } else {
  88                         last = item;
  89                         item = item->next;
  90                 }
  91         }
  92 }
  93
  94 /**
  95  * get_dhcp_packet_type - gets the message type of a dhcp packet
  96  * p - pointer to the dhcp packet
  97  * returns the message type on success, -1 otherwise
  98  */
  99 static int get_dhcp_packet_type(struct dhcp_packet *p)
 100 {
 101         uint8_t *op;
 102
 103         /* it must be either a BOOTREQUEST or a BOOTREPLY */
 104         if (p->op != BOOTREQUEST && p->op != BOOTREPLY)
 105                 return -1;
 106         /* get message type option */
 107         op = udhcp_get_option(p, DHCP_MESSAGE_TYPE);
 108         if (op != NULL)
 109                 return op[0];
 110         return -1;
 111 }
 112
 113 /**
 114  * get_client_devices - parses the devices list
 115  * dev_list - comma separated list of devices
 116  * returns array
 117  */
 118 static char **get_client_devices(char *dev_list, int *client_number)
 119 {
 120         char *s, **client_dev;
 121         int i, cn;
 122
 123         /* copy list */
 124         dev_list = xstrdup(dev_list);
 125
 126         /* get number of items, replace ',' with NULs */
 127         s = dev_list;
 128         cn = 1;
 129         while (*s) {
 130                 if (*s == ',') {
 131                         *s = '\0';
 132                         cn++;
 133                 }
 134                 s++;
 135         }
 136         *client_number = cn;
 137
 138         /* create vector of pointers */
 139         client_dev = xzalloc(cn * sizeof(*client_dev));
 140         client_dev[0] = dev_list;
 141         i = 1;
 142         while (i != cn) {
 143                 client_dev[i] = client_dev[i - 1] + strlen(client_dev[i - 1]) + 1;
 144                 i++;
 145         }
 146         return client_dev;
 147 }
 148
 149
 150 /* Creates listen sockets (in fds) bound to client and server ifaces,
 151  * and returns numerically max fd.
 152  */
 153 static int init_sockets(char **client_ifaces, int num_clients,
 154                         char *server_iface, int *fds)
 155 {
 156         int i, n;
 157
 158         /* talk to real server on bootps */
 159         fds[0] = udhcp_listen_socket(/*INADDR_ANY,*/ SERVER_PORT, server_iface);
 160         n = fds[0];
 161
 162         for (i = 1; i < num_clients; i++) {
 163                 /* listen for clients on bootps */
 164                 fds[i] = udhcp_listen_socket(/*INADDR_ANY,*/ SERVER_PORT, client_ifaces[i-1]);
 165                 if (fds[i] > n)
 166                         n = fds[i];
 167         }
 168         return n;
 169 }
 170
 171
 172 /**
 173  * pass_to_server() - forwards dhcp packets from client to server
 174  * p - packet to send
 175  * client - number of the client
 176  */
 177 static void pass_to_server(struct dhcp_packet *p, int packet_len, int client, int *fds,
 178                         struct sockaddr_in *client_addr, struct sockaddr_in *server_addr)
 179 {
 180         int res, type;
 181         struct xid_item *item;
 182
 183         /* check packet_type */
 184         type = get_dhcp_packet_type(p);
 185         if (type != DHCPDISCOVER && type != DHCPREQUEST
 186          && type != DHCPDECLINE && type != DHCPRELEASE
 187          && type != DHCPINFORM
 188         ) {
 189                 return;
 190         }
 191
 192         /* create new xid entry */
 193         item = xid_add(p->xid, client_addr, client);
 194
 195         /* forward request to LAN (server) */
 196         errno = 0;
 197         res = sendto(fds[0], p, packet_len, 0, (struct sockaddr*)server_addr,
 198                         sizeof(struct sockaddr_in));
 199         if (res != packet_len) {
 200                 bb_perror_msg("sendto");
 201         }
 202 }
 203
 204 /**
 205  * pass_to_client() - forwards dhcp packets from server to client
 206  * p - packet to send
 207  */
 208 static void pass_to_client(struct dhcp_packet *p, int packet_len, int *fds)
 209 {
 210         int res, type;
 211         struct xid_item *item;
 212
 213         /* check xid */
 214         item = xid_find(p->xid);
 215         if (!item) {
 216                 return;
 217         }
 218
 219         /* check packet type */
 220         type = get_dhcp_packet_type(p);
 221         if (type != DHCPOFFER && type != DHCPACK && type != DHCPNAK) {
 222                 return;
 223         }
 224
 225         if (item->ip.sin_addr.s_addr == htonl(INADDR_ANY))
 226                 item->ip.sin_addr.s_addr = htonl(INADDR_BROADCAST);
 227         errno = 0;
 228         res = sendto(fds[item->client], p, packet_len, 0, (struct sockaddr*) &(item->ip),
 229                         sizeof(item->ip));
 230         if (res != packet_len) {
 231                 bb_perror_msg("sendto");
 232                 return;
 233         }
 234
 235         /* remove xid entry */
 236         xid_del(p->xid);
 237 }
 238
 239 int dhcprelay_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
 240 int dhcprelay_main(int argc, char **argv)
 241 {
 242         struct dhcp_packet dhcp_msg;
 243         struct sockaddr_in server_addr;
 244         struct sockaddr_in client_addr;
 245         fd_set rfds;
 246         char **client_ifaces;
 247         int *fds;
 248         int num_sockets, max_socket;
 249         uint32_t our_nip;
 250
 251         server_addr.sin_family = AF_INET;
 252         server_addr.sin_port = htons(SERVER_PORT);
 253
 254         /* dhcprelay client_iface1,client_iface2,... server_iface [server_IP] */
 255         if (argc == 4) {
 256                 if (!inet_aton(argv[3], &server_addr.sin_addr))
 257                         bb_perror_msg_and_die("bad server IP");
 258         } else if (argc == 3) {
 259                 server_addr.sin_addr.s_addr = htonl(INADDR_BROADCAST);
 260         } else {
 261                 bb_show_usage();
 262         }
 263
 264         /* Produce list of client ifaces */
 265         client_ifaces = get_client_devices(argv[1], &num_sockets);
 266
 267         num_sockets++; /* for server socket at fds[0] */
 268         fds = xmalloc(num_sockets * sizeof(fds[0]));
 269
 270         /* Create sockets and bind one to every iface */
 271         max_socket = init_sockets(client_ifaces, num_sockets, argv[2], fds);
 272
 273         /* Get our IP on server_iface */
 274         if (udhcp_read_interface(argv[2], NULL, &our_nip, NULL))
 275                 return 1;
 276
 277         /* Main loop */
 278         while (1) {
 279 //reinit stuff from time to time? go back to get_client_devices
 280 //every N minutes?
 281                 struct timeval tv;
 282                 size_t packlen;
 283                 socklen_t addr_size;
 284                 int i;
 285
 286                 FD_ZERO(&rfds);
 287                 for (i = 0; i < num_sockets; i++)
 288                         FD_SET(fds[i], &rfds);
 289                 tv.tv_sec = SELECT_TIMEOUT;
 290                 tv.tv_usec = 0;
 291                 if (select(max_socket + 1, &rfds, NULL, NULL, &tv) > 0) {
 292                         /* server */
 293                         if (FD_ISSET(fds[0], &rfds)) {
 294                                 packlen = udhcp_recv_kernel_packet(&dhcp_msg, fds[0]);
 295                                 if (packlen > 0) {
 296                                         pass_to_client(&dhcp_msg, packlen, fds);
 297                                 }
 298                         }
 299                         /* clients */
 300                         for (i = 1; i < num_sockets; i++) {
 301                                 if (!FD_ISSET(fds[i], &rfds))
 302                                         continue;
 303                                 addr_size = sizeof(struct sockaddr_in);
 304                                 packlen = recvfrom(fds[i], &dhcp_msg, sizeof(dhcp_msg), 0,
 305                                                 (struct sockaddr *)(&client_addr), &addr_size);
 306                                 if (packlen <= 0)
 307                                         continue;
 308
 309                                 /* Get our IP on corresponding client_iface */
 310 //why? what if server can't route such IP?
 311                                 if (udhcp_read_interface(client_ifaces[i-1], NULL, &dhcp_msg.gateway_nip, NULL)) {
 312                                         /* Fall back to our server_iface's IP */
 313 //this makes more sense!
 314                                         dhcp_msg.gateway_nip = our_nip;
 315                                 }
 316 //maybe set dhcp_msg.flags |= BROADCAST_FLAG too?
 317                                 pass_to_server(&dhcp_msg, packlen, i, fds, &client_addr, &server_addr);
 318                         }
 319                 }
 320                 xid_expire();
 321         } /* while (1) */
 322
 323         /* return 0; - not reached */
 324 }