libeap/src/ap/dhcp_snoop.c

   1 /*
   2  * DHCP snooping for Proxy ARP
   3  * Copyright (c) 2014, Qualcomm Atheros, Inc.
   4  *
   5  * This software may be distributed under the terms of the BSD license.
   6  * See README for more details.
   7  */
   8
   9 #include "utils/includes.h"
  10 #include <netinet/ip.h>
  11 #include <netinet/udp.h>
  12
  13 #include "utils/common.h"
  14 #include "l2_packet/l2_packet.h"
  15 #include "hostapd.h"
  16 #include "sta_info.h"
  17 #include "ap_drv_ops.h"
  18 #include "x_snoop.h"
  19 #include "dhcp_snoop.h"
  20
  21 struct bootp_pkt {
  22         struct iphdr iph;
  23         struct udphdr udph;
  24         u8 op;
  25         u8 htype;
  26         u8 hlen;
  27         u8 hops;
  28         be32 xid;
  29         be16 secs;
  30         be16 flags;
  31         be32 client_ip;
  32         be32 your_ip;
  33         be32 server_ip;
  34         be32 relay_ip;
  35         u8 hw_addr[16];
  36         u8 serv_name[64];
  37         u8 boot_file[128];
  38         u8 exten[312];
  39 } STRUCT_PACKED;
  40
  41 #define DHCPACK 5
  42 static const u8 ic_bootp_cookie[] = { 99, 130, 83, 99 };
  43
  44
  45 static const char * ipaddr_str(u32 addr)
  46 {
  47         static char buf[17];
  48
  49         os_snprintf(buf, sizeof(buf), "%u.%u.%u.%u",
  50                     (addr >> 24) & 0xff, (addr >> 16) & 0xff,
  51                     (addr >> 8) & 0xff, addr & 0xff);
  52         return buf;
  53 }
  54
  55
  56 static void handle_dhcp(void *ctx, const u8 *src_addr, const u8 *buf,
  57                         size_t len)
  58 {
  59         struct hostapd_data *hapd = ctx;
  60         const struct bootp_pkt *b;
  61         struct sta_info *sta;
  62         int exten_len;
  63         const u8 *end, *pos;
  64         int res, msgtype = 0, prefixlen = 32;
  65         u32 subnet_mask = 0;
  66         u16 tot_len;
  67
  68         exten_len = len - ETH_HLEN - (sizeof(*b) - sizeof(b->exten));
  69         if (exten_len < 4)
  70                 return;
  71
  72         b = (const struct bootp_pkt *) &buf[ETH_HLEN];
  73         tot_len = ntohs(b->iph.tot_len);
  74         if (tot_len > (unsigned int) (len - ETH_HLEN))
  75                 return;
  76
  77         if (os_memcmp(b->exten, ic_bootp_cookie, ARRAY_SIZE(ic_bootp_cookie)))
  78                 return;
  79
  80         /* Parse DHCP options */
  81         end = (const u8 *) b + tot_len;
  82         pos = &b->exten[4];
  83         while (pos < end && *pos != 0xff) {
  84                 const u8 *opt = pos++;
  85
  86                 if (*opt == 0) /* padding */
  87                         continue;
  88
  89                 pos += *pos + 1;
  90                 if (pos >= end)
  91                         break;
  92
  93                 switch (*opt) {
  94                 case 1:  /* subnet mask */
  95                         if (opt[1] == 4)
  96                                 subnet_mask = WPA_GET_BE32(&opt[2]);
  97                         if (subnet_mask == 0)
  98                                 return;
  99                         while (!(subnet_mask & 0x1)) {
 100                                 subnet_mask >>= 1;
 101                                 prefixlen--;
 102                         }
 103                         break;
 104                 case 53: /* message type */
 105                         if (opt[1])
 106                                 msgtype = opt[2];
 107                         break;
 108                 default:
 109                         break;
 110                 }
 111         }
 112
 113         if (msgtype == DHCPACK) {
 114                 if (b->your_ip == 0)
 115                         return;
 116
 117                 /* DHCPACK for DHCPREQUEST */
 118                 sta = ap_get_sta(hapd, b->hw_addr);
 119                 if (!sta)
 120                         return;
 121
 122                 wpa_printf(MSG_DEBUG, "dhcp_snoop: Found DHCPACK for " MACSTR
 123                            " @ IPv4 address %s/%d",
 124                            MAC2STR(sta->addr),
 125                            ipaddr_str(be_to_host32(b->your_ip)),
 126                            prefixlen);
 127
 128                 if (sta->ipaddr == b->your_ip)
 129                         return;
 130
 131                 if (sta->ipaddr != 0) {
 132                         wpa_printf(MSG_DEBUG,
 133                                    "dhcp_snoop: Removing IPv4 address %s from the ip neigh table",
 134                                    ipaddr_str(be_to_host32(sta->ipaddr)));
 135                         hostapd_drv_br_delete_ip_neigh(hapd, 4,
 136                                                        (u8 *) &sta->ipaddr);
 137                 }
 138
 139                 res = hostapd_drv_br_add_ip_neigh(hapd, 4, (u8 *) &b->your_ip,
 140                                                   prefixlen, sta->addr);
 141                 if (res) {
 142                         wpa_printf(MSG_DEBUG,
 143                                    "dhcp_snoop: Adding ip neigh table failed: %d",
 144                                    res);
 145                         return;
 146                 }
 147                 sta->ipaddr = b->your_ip;
 148         }
 149
 150         if (hapd->conf->disable_dgaf && is_broadcast_ether_addr(buf)) {
 151                 for (sta = hapd->sta_list; sta; sta = sta->next) {
 152                         if (!(sta->flags & WLAN_STA_AUTHORIZED))
 153                                 continue;
 154                         x_snoop_mcast_to_ucast_convert_send(hapd, sta,
 155                                                             (u8 *) buf, len);
 156                 }
 157         }
 158 }
 159
 160
 161 int dhcp_snoop_init(struct hostapd_data *hapd)
 162 {
 163         hapd->sock_dhcp = x_snoop_get_l2_packet(hapd, handle_dhcp,
 164                                                 L2_PACKET_FILTER_DHCP);
 165         if (hapd->sock_dhcp == NULL) {
 166                 wpa_printf(MSG_DEBUG,
 167                            "dhcp_snoop: Failed to initialize L2 packet processing for DHCP packet: %s",
 168                            strerror(errno));
 169                 return -1;
 170         }
 171
 172         return 0;
 173 }
 174
 175
 176 void dhcp_snoop_deinit(struct hostapd_data *hapd)
 177 {
 178         l2_packet_deinit(hapd->sock_dhcp);
 179 }