mac80211.c

   1 /*
   2  * netsniff-ng - the packet sniffing beast
   3  * Copyright 2012 Daniel Borkmann.
   4  * Subject to the GPL, version 2.
   5  * Parts derived from iw, subject to ISC license.
   6  * Copyright 2007, 2008 Johannes Berg
   7  * Copyright 2007 Andy Lutomirski
   8  * Copyright 2007 Mike Kershaw
   9  * Copyright 2008-2009 Luis R. Rodriguez
  10  */
  11
  12 #define _GNU_SOURCE
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <errno.h>
  16 #include <string.h>
  17 #include <limits.h>
  18 #include <sys/socket.h>
  19 #include <linux/if.h>
  20 #include <linux/nl80211.h>
  21 #include <netlink/genl/genl.h>
  22 #include <netlink/genl/family.h>
  23 #include <netlink/genl/ctrl.h>
  24 #include <netlink/msg.h>
  25 #include <netlink/attr.h>
  26
  27 #include "die.h"
  28 #include "str.h"
  29 #include "dev.h"
  30 #include "mac80211.h"
  31 #include "xmalloc.h"
  32 #include "built_in.h"
  33
  34 struct nl80211_state {
  35         struct nl_sock *nl_sock;
  36         struct nl_cache *nl_cache;
  37         struct genl_family *nl80211;
  38 };
  39
  40 static void get_mac80211_phydev(const char *device, char *phydev_path,
  41                                 size_t phydev_len)
  42 {
  43         int ret;
  44         char *pathstr;
  45         ssize_t num;
  46
  47         ret = asprintf(&pathstr, "/sys/class/net/%s/phy80211", device);
  48         if (ret < 0)
  49                 panic("Can't generate path name string for /sys/class/net device");
  50
  51         num = readlink(pathstr, phydev_path, phydev_len);
  52         if (num < 0) {
  53                 if (errno == ENOENT || errno == EINVAL)
  54                         panic("It's probably not a mac80211 device!\n");
  55                 panic("Can't readlink %s: %s!\n", pathstr, strerror(errno));
  56         }
  57
  58         xfree(pathstr);
  59         phydev_path[min_t(size_t, num, phydev_len - 1)] = 0;
  60 }
  61
  62 static inline struct nl_msg *nl80211_nlmsg_xalloc(void)
  63 {
  64         struct nl_msg *ret = nlmsg_alloc();
  65         if (!ret)
  66                 panic("Cannot allocate nlmsg memory!\n");
  67         return ret;
  68 }
  69
  70 static inline struct nl_sock *nl80211_nl_socket_xalloc(void)
  71 {
  72         struct nl_sock *ret = nl_socket_alloc();
  73         if (!ret)
  74                 panic("Cannot allocate nl socket memory!\n");
  75         return ret;
  76 }
  77
  78 static void nl80211_init(struct nl80211_state *state)
  79 {
  80         int ret;
  81
  82         state->nl_sock = nl80211_nl_socket_xalloc();
  83
  84         ret = genl_connect(state->nl_sock);
  85         if (ret)
  86                 panic("Cannot connect generic netlink!\n");
  87
  88         ret = genl_ctrl_alloc_cache(state->nl_sock, &state->nl_cache);
  89         if (ret < 0)
  90                 panic("Failed to allocate generic netlink cache: %s!",
  91                       nl_geterror(-ret));
  92
  93         state->nl80211 = genl_ctrl_search_by_name(state->nl_cache, "nl80211");
  94         if (!state->nl80211)
  95                 panic("nl80211 not found in netlink cache!\n");
  96 }
  97
  98 static void nl80211_cleanup(struct nl80211_state *state)
  99 {
 100         genl_family_put(state->nl80211);
 101
 102         nl_cache_free(state->nl_cache);
 103         nl_socket_free(state->nl_sock);
 104 }
 105
 106 static int nl80211_wait_handler(struct nl_msg *msg __maybe_unused, void *arg)
 107 {
 108         int *finished = arg;
 109
 110         *finished = 1;
 111
 112         return NL_STOP;
 113 }
 114
 115 static int nl80211_error_handler(struct sockaddr_nl *nla __maybe_unused,
 116                                  struct nlmsgerr *err,
 117                                  void *arg __maybe_unused)
 118 {
 119         panic("nl80211 returned with error (%d): %s\n", err->error,
 120               nl_geterror(err->error));
 121 }
 122
 123 static int nl80211_add_mon_if(struct nl80211_state *state, const char *device,
 124                               const char *mondevice)
 125 {
 126         int ifindex, ret;
 127         struct nl_msg *msg;
 128         struct nl_cb *cb = NULL;
 129         int finished = 0;
 130
 131         ifindex = device_ifindex(device);
 132
 133         msg = nl80211_nlmsg_xalloc();
 134
 135         genlmsg_put(msg, 0, 0, genl_family_get_id(state->nl80211), 0,
 136                     0, NL80211_CMD_NEW_INTERFACE, 0);
 137
 138         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, ifindex);
 139         NLA_PUT_STRING(msg, NL80211_ATTR_IFNAME, mondevice);
 140         NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, NL80211_IFTYPE_MONITOR);
 141
 142         ret = nl_send_auto_complete(state->nl_sock, msg);
 143         if (ret < 0) {
 144                 if (ret == -ENFILE) {
 145                         nlmsg_free(msg);
 146                         return -EBUSY;
 147                 }
 148
 149                 panic("Cannot send_auto_complete!\n");
 150         }
 151
 152         cb = nl_cb_alloc(NL_CB_CUSTOM);
 153         if (!cb)
 154                 panic("Cannot alloc nl_cb!\n");
 155
 156         nl_cb_set(cb, NL_CB_ACK, NL_CB_CUSTOM, nl80211_wait_handler, &finished);
 157         nl_cb_err(cb, NL_CB_CUSTOM, nl80211_error_handler, NULL);
 158
 159         nl_recvmsgs(state->nl_sock, cb);
 160
 161         if (!finished) {
 162                 ret = nl_wait_for_ack(state->nl_sock);
 163                 if (ret < 0) {
 164                         if (ret == -ENFILE) {
 165                                 nlmsg_free(msg);
 166                                 return -EBUSY;
 167                         }
 168
 169                         panic("Waiting for netlink ack failed!\n");
 170                 }
 171         }
 172
 173         nl_cb_put(cb);
 174         nlmsg_free(msg);
 175         return 0;
 176
 177 nla_put_failure:
 178         panic("nla put failure!\n");
 179         return -EIO; /* dummy */
 180 }
 181
 182 static int nl80211_del_mon_if(struct nl80211_state *state,
 183                               const char *mondevice)
 184 {
 185         int ifindex, ret;
 186         struct nl_msg *msg;
 187
 188         ifindex = device_ifindex(mondevice);
 189
 190         msg = nl80211_nlmsg_xalloc();
 191
 192         genlmsg_put(msg, 0, 0, genl_family_get_id(state->nl80211), 0,
 193                     0, NL80211_CMD_DEL_INTERFACE, 0);
 194
 195         NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, ifindex);
 196
 197         ret = nl_send_auto_complete(state->nl_sock, msg);
 198         if (ret < 0)
 199                 panic("Cannot send_auto_complete!\n");
 200
 201         ret = nl_wait_for_ack(state->nl_sock);
 202         if (ret < 0)
 203                 panic("Waiting for netlink ack failed!\n");
 204
 205         nlmsg_free(msg);
 206         return 0;
 207
 208 nla_put_failure:
 209         panic("nla put failure!\n");
 210         return -EIO; /* dummy */
 211 }
 212
 213 void enter_rfmon_mac80211(const char *device, char **mondev)
 214 {
 215         int ret;
 216         short flags;
 217         uint32_t n;
 218         char phydev_path[256];
 219         struct nl80211_state nlstate;
 220
 221         /* XXX: is this already a monN device? */
 222         get_mac80211_phydev(device, phydev_path, sizeof(phydev_path));
 223         nl80211_init(&nlstate);
 224
 225         for (n = 0; n < UINT_MAX; n++) {
 226                 char mondevice[32];
 227
 228                 slprintf(mondevice, sizeof(mondevice), "mon%u", n);
 229
 230                 if (__device_ifindex(mondevice) > 0)
 231                         continue;
 232
 233                 ret = nl80211_add_mon_if(&nlstate, device, mondevice);
 234                 if (ret == 0) {
 235                         *mondev = xstrdup(mondevice);
 236
 237                         flags = device_get_flags(*mondev);
 238                         flags |= IFF_UP | IFF_RUNNING;
 239                         device_set_flags(*mondev, flags);
 240
 241                         nl80211_cleanup(&nlstate);
 242                         return;
 243                 }
 244         }
 245
 246         panic("No free monN interfaces!\n");
 247 }
 248
 249 void leave_rfmon_mac80211(const char *mondev)
 250 {
 251         short flags;
 252         struct nl80211_state nlstate;
 253
 254         flags = device_get_flags(mondev);
 255         flags &= ~(IFF_UP | IFF_RUNNING);
 256         device_set_flags(mondev, flags);
 257
 258         nl80211_init(&nlstate);
 259         nl80211_del_mon_if(&nlstate, mondev);
 260         nl80211_cleanup(&nlstate);
 261 }