hostapd/driver_i.h

   1 /*
   2  * hostapd - internal driver interface wrappers
   3  * Copyright (c) 2002-2009, Jouni Malinen <j@w1.fi>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2 as
   7  * published by the Free Software Foundation.
   8  *
   9  * Alternatively, this software may be distributed under the terms of BSD
  10  * license.
  11  *
  12  * See README and COPYING for more details.
  13  */
  14
  15 #ifndef DRIVER_I_H
  16 #define DRIVER_I_H
  17
  18 #include "drivers/driver.h"
  19 #include "config.h"
  20
  21 static inline void *
  22 hostapd_driver_init(struct hostapd_data *hapd, const u8 *bssid)
  23 {
  24         struct wpa_init_params params;
  25         void *ret;
  26         size_t i;
  27
  28         if (hapd->driver == NULL || hapd->driver->hapd_init == NULL)
  29                 return NULL;
  30
  31         os_memset(&params, 0, sizeof(params));
  32         params.bssid = bssid;
  33         params.ifname = hapd->conf->iface;
  34         params.ssid = (const u8 *) hapd->conf->ssid.ssid;
  35         params.ssid_len = hapd->conf->ssid.ssid_len;
  36         params.test_socket = hapd->conf->test_socket;
  37         params.use_pae_group_addr = hapd->conf->use_pae_group_addr;
  38
  39         params.num_bridge = hapd->iface->num_bss;
  40         params.bridge = os_zalloc(hapd->iface->num_bss * sizeof(char *));
  41         if (params.bridge == NULL)
  42                 return NULL;
  43         for (i = 0; i < hapd->iface->num_bss; i++) {
  44                 struct hostapd_data *bss = hapd->iface->bss[i];
  45                 if (bss->conf->bridge[0])
  46                         params.bridge[i] = bss->conf->bridge;
  47         }
  48
  49         params.own_addr = hapd->own_addr;
  50
  51         ret = hapd->driver->hapd_init(hapd, &params);
  52         os_free(params.bridge);
  53
  54         return ret;
  55 }
  56
  57 static inline void
  58 hostapd_driver_deinit(struct hostapd_data *hapd)
  59 {
  60         if (hapd->driver == NULL || hapd->driver->hapd_deinit == NULL)
  61                 return;
  62         hapd->driver->hapd_deinit(hapd->drv_priv);
  63 }
  64
  65 static inline int
  66 hostapd_set_ieee8021x(struct hostapd_data *hapd, struct wpa_bss_params *params)
  67 {
  68         if (hapd->driver == NULL || hapd->driver->set_ieee8021x == NULL)
  69                 return 0;
  70         return hapd->driver->set_ieee8021x(hapd->drv_priv, params);
  71 }
  72
  73 static inline int
  74 hostapd_set_privacy(struct hostapd_data *hapd, int enabled)
  75 {
  76         if (hapd->driver == NULL || hapd->driver->set_privacy == NULL)
  77                 return 0;
  78         return hapd->driver->set_privacy(hapd->conf->iface, hapd->drv_priv,
  79                                          enabled);
  80 }
  81
  82 static inline int
  83 hostapd_get_seqnum(const char *ifname, struct hostapd_data *hapd,
  84                    const u8 *addr, int idx, u8 *seq)
  85 {
  86         if (hapd->driver == NULL || hapd->driver->get_seqnum == NULL)
  87                 return 0;
  88         return hapd->driver->get_seqnum(ifname, hapd->drv_priv, addr, idx,
  89                                         seq);
  90 }
  91
  92 static inline int
  93 hostapd_flush(struct hostapd_data *hapd)
  94 {
  95         if (hapd->driver == NULL || hapd->driver->flush == NULL)
  96                 return 0;
  97         return hapd->driver->flush(hapd->drv_priv);
  98 }
  99
 100 static inline int
 101 hostapd_set_generic_elem(struct hostapd_data *hapd, const u8 *elem,
 102                          size_t elem_len)
 103 {
 104         if (hapd->driver == NULL || hapd->driver->set_generic_elem == NULL)
 105                 return 0;
 106         return hapd->driver->set_generic_elem(hapd->conf->iface,
 107                                               hapd->drv_priv, elem, elem_len);
 108 }
 109
 110 static inline int
 111 hostapd_get_ssid(struct hostapd_data *hapd, u8 *buf, size_t len)
 112 {
 113         if (hapd->driver == NULL || hapd->driver->hapd_get_ssid == NULL)
 114                 return 0;
 115         return hapd->driver->hapd_get_ssid(hapd->conf->iface, hapd->drv_priv,
 116                                            buf, len);
 117 }
 118
 119 static inline int
 120 hostapd_set_ssid(struct hostapd_data *hapd, const u8 *buf, size_t len)
 121 {
 122         if (hapd->driver == NULL || hapd->driver->hapd_set_ssid == NULL)
 123                 return 0;
 124         return hapd->driver->hapd_set_ssid(hapd->conf->iface, hapd->drv_priv,
 125                                            buf, len);
 126 }
 127
 128 static inline int
 129 hostapd_set_countermeasures(struct hostapd_data *hapd, int enabled)
 130 {
 131         if (hapd->driver == NULL ||
 132             hapd->driver->hapd_set_countermeasures == NULL)
 133                 return 0;
 134         return hapd->driver->hapd_set_countermeasures(hapd->drv_priv, enabled);
 135 }
 136
 137 static inline int
 138 hostapd_sta_add(const char *ifname, struct hostapd_data *hapd, const u8 *addr,
 139                 u16 aid, u16 capability, const u8 *supp_rates,
 140                 size_t supp_rates_len, u16 listen_interval,
 141                 const struct ieee80211_ht_capabilities *ht_capabilities)
 142 {
 143         struct hostapd_sta_add_params params;
 144
 145         if (hapd->driver == NULL)
 146                 return 0;
 147         if (hapd->driver->sta_add == NULL)
 148                 return 0;
 149
 150         os_memset(&params, 0, sizeof(params));
 151         params.addr = addr;
 152         params.aid = aid;
 153         params.capability = capability;
 154         params.supp_rates = supp_rates;
 155         params.supp_rates_len = supp_rates_len;
 156         params.listen_interval = listen_interval;
 157         params.ht_capabilities = ht_capabilities;
 158         return hapd->driver->sta_add(ifname, hapd->drv_priv, &params);
 159 }
 160
 161 static inline int
 162 hostapd_set_freq(struct hostapd_data *hapd, int mode, int freq, int channel,
 163                  int ht_enabled, int sec_channel_offset)
 164 {
 165         struct hostapd_freq_params data;
 166         if (hapd->driver == NULL)
 167                 return 0;
 168         if (hapd->driver->set_freq == NULL)
 169                 return 0;
 170         os_memset(&data, 0, sizeof(data));
 171         data.mode = mode;
 172         data.freq = freq;
 173         data.channel = channel;
 174         data.ht_enabled = ht_enabled;
 175         data.sec_channel_offset = sec_channel_offset;
 176         return hapd->driver->set_freq(hapd->drv_priv, &data);
 177 }
 178
 179 static inline int
 180 hostapd_set_rts(struct hostapd_data *hapd, int rts)
 181 {
 182         if (hapd->driver == NULL || hapd->driver->set_rts == NULL)
 183                 return 0;
 184         return hapd->driver->set_rts(hapd->drv_priv, rts);
 185 }
 186
 187 static inline int
 188 hostapd_set_frag(struct hostapd_data *hapd, int frag)
 189 {
 190         if (hapd->driver == NULL || hapd->driver->set_frag == NULL)
 191                 return 0;
 192         return hapd->driver->set_frag(hapd->drv_priv, frag);
 193 }
 194
 195 static inline int
 196 hostapd_sta_set_flags(struct hostapd_data *hapd, u8 *addr,
 197                       int total_flags, int flags_or, int flags_and)
 198 {
 199         if (hapd->driver == NULL || hapd->driver->sta_set_flags == NULL)
 200                 return 0;
 201         return hapd->driver->sta_set_flags(hapd->drv_priv, addr, total_flags,
 202                                            flags_or, flags_and);
 203 }
 204
 205 static inline int
 206 hostapd_set_rate_sets(struct hostapd_data *hapd, int *supp_rates,
 207                       int *basic_rates, int mode)
 208 {
 209         if (hapd->driver == NULL || hapd->driver->set_rate_sets == NULL)
 210                 return 0;
 211         return hapd->driver->set_rate_sets(hapd->drv_priv, supp_rates,
 212                                            basic_rates, mode);
 213 }
 214
 215 static inline int
 216 hostapd_set_country(struct hostapd_data *hapd, const char *country)
 217 {
 218         if (hapd->driver == NULL ||
 219             hapd->driver->set_country == NULL)
 220                 return 0;
 221         return hapd->driver->set_country(hapd->drv_priv, country);
 222 }
 223
 224 static inline int
 225 hostapd_set_cts_protect(struct hostapd_data *hapd, int value)
 226 {
 227         if (hapd->driver == NULL || hapd->driver->set_cts_protect == NULL)
 228                 return 0;
 229         return hapd->driver->set_cts_protect(hapd->drv_priv, value);
 230 }
 231
 232 static inline int
 233 hostapd_set_preamble(struct hostapd_data *hapd, int value)
 234 {
 235         if (hapd->driver == NULL || hapd->driver->set_preamble == NULL)
 236                 return 0;
 237         return hapd->driver->set_preamble(hapd->drv_priv, value);
 238 }
 239
 240 static inline int
 241 hostapd_set_short_slot_time(struct hostapd_data *hapd, int value)
 242 {
 243         if (hapd->driver == NULL || hapd->driver->set_short_slot_time == NULL)
 244                 return 0;
 245         return hapd->driver->set_short_slot_time(hapd->drv_priv, value);
 246 }
 247
 248 static inline int
 249 hostapd_set_tx_queue_params(struct hostapd_data *hapd, int queue, int aifs,
 250                             int cw_min, int cw_max, int burst_time)
 251 {
 252         if (hapd->driver == NULL || hapd->driver->set_tx_queue_params == NULL)
 253                 return 0;
 254         return hapd->driver->set_tx_queue_params(hapd->drv_priv, queue, aifs,
 255                                                  cw_min, cw_max, burst_time);
 256 }
 257
 258 static inline int
 259 hostapd_valid_bss_mask(struct hostapd_data *hapd, const u8 *addr,
 260                        const u8 *mask)
 261 {
 262         if (hapd->driver == NULL || hapd->driver->valid_bss_mask == NULL)
 263                 return 1;
 264         return hapd->driver->valid_bss_mask(hapd->drv_priv, addr, mask);
 265 }
 266
 267 static inline int
 268 hostapd_if_add(struct hostapd_data *hapd, enum wpa_driver_if_type type,
 269                const char *ifname, const u8 *addr, void *bss_ctx)
 270 {
 271         if (hapd->driver == NULL || hapd->driver->if_add == NULL)
 272                 return -1;
 273         return hapd->driver->if_add(hapd->conf->iface, hapd->drv_priv, type,
 274                                     ifname, addr, bss_ctx);
 275 }
 276
 277 static inline int
 278 hostapd_if_remove(struct hostapd_data *hapd, enum wpa_driver_if_type type,
 279                   const char *ifname)
 280 {
 281         if (hapd->driver == NULL || hapd->driver->if_remove == NULL)
 282                 return -1;
 283         return hapd->driver->if_remove(hapd->drv_priv, type, ifname);
 284 }
 285
 286 static inline struct hostapd_hw_modes *
 287 hostapd_get_hw_feature_data(struct hostapd_data *hapd, u16 *num_modes,
 288                             u16 *flags)
 289 {
 290         if (hapd->driver == NULL ||
 291             hapd->driver->get_hw_feature_data == NULL)
 292                 return NULL;
 293         return hapd->driver->get_hw_feature_data(hapd->drv_priv, num_modes,
 294                                                  flags);
 295 }
 296
 297 static inline int
 298 hostapd_driver_commit(struct hostapd_data *hapd)
 299 {
 300         if (hapd->driver == NULL || hapd->driver->commit == NULL)
 301                 return 0;
 302         return hapd->driver->commit(hapd->drv_priv);
 303 }
 304
 305 static inline int
 306 hostapd_set_ht_params(const char *ifname, struct hostapd_data *hapd,
 307                       const u8 *ht_capab, size_t ht_capab_len,
 308                       const u8 *ht_oper, size_t ht_oper_len)
 309 {
 310         if (hapd->driver == NULL || hapd->driver->set_ht_params == NULL ||
 311             ht_capab == NULL || ht_oper == NULL)
 312                 return 0;
 313         return hapd->driver->set_ht_params(
 314                 ifname, hapd->drv_priv, ht_capab, ht_capab_len,
 315                 ht_oper, ht_oper_len);
 316 }
 317
 318 static inline int
 319 hostapd_drv_none(struct hostapd_data *hapd)
 320 {
 321         return hapd->driver && os_strcmp(hapd->driver->name, "none") == 0;
 322 }
 323
 324 static inline int hostapd_driver_scan(struct hostapd_data *hapd,
 325                                       struct wpa_driver_scan_params *params)
 326 {
 327         if (hapd->driver && hapd->driver->scan2)
 328                 return hapd->driver->scan2(hapd->drv_priv, params);
 329         return -1;
 330 }
 331
 332 static inline struct wpa_scan_results * hostapd_driver_get_scan_results(
 333         struct hostapd_data *hapd)
 334 {
 335         if (hapd->driver && hapd->driver->get_scan_results2)
 336                 return hapd->driver->get_scan_results2(hapd->drv_priv);
 337         return NULL;
 338 }
 339
 340 #endif /* DRIVER_I_H */