hostapd/driver_i.h

   1 /*
   2  * hostapd - internal driver interface wrappers
   3  * Copyright (c) 2002-2009, Jouni Malinen <j@w1.fi>
   4  * Copyright (c) 2007-2008, Intel Corporation
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * Alternatively, this software may be distributed under the terms of BSD
  11  * license.
  12  *
  13  * See README and COPYING for more details.
  14  */
  15
  16 #ifndef DRIVER_I_H
  17 #define DRIVER_I_H
  18
  19 #include "driver.h"
  20 #include "config.h"
  21
  22 static inline void *
  23 hostapd_driver_init(struct hostapd_data *hapd)
  24 {
  25         if (hapd->driver == NULL || hapd->driver->init == NULL)
  26                 return NULL;
  27         return hapd->driver->init(hapd);
  28 }
  29
  30 static inline void *
  31 hostapd_driver_init_bssid(struct hostapd_data *hapd, const u8 *bssid)
  32 {
  33         if (hapd->driver == NULL || hapd->driver->init_bssid == NULL)
  34                 return NULL;
  35         return hapd->driver->init_bssid(hapd, bssid);
  36 }
  37
  38 static inline void
  39 hostapd_driver_deinit(struct hostapd_data *hapd)
  40 {
  41         if (hapd->driver == NULL || hapd->driver->deinit == NULL)
  42                 return;
  43         hapd->driver->deinit(hapd->drv_priv);
  44 }
  45
  46 static inline int
  47 hostapd_wireless_event_init(struct hostapd_data *hapd)
  48 {
  49         if (hapd->driver == NULL ||
  50             hapd->driver->wireless_event_init == NULL)
  51                 return 0;
  52         return hapd->driver->wireless_event_init(hapd->drv_priv);
  53 }
  54
  55 static inline void
  56 hostapd_wireless_event_deinit(struct hostapd_data *hapd)
  57 {
  58         if (hapd->driver == NULL ||
  59             hapd->driver->wireless_event_deinit == NULL)
  60                 return;
  61         hapd->driver->wireless_event_deinit(hapd->drv_priv);
  62 }
  63
  64 static inline int
  65 hostapd_set_ieee8021x(const char *ifname, struct hostapd_data *hapd,
  66                       int enabled)
  67 {
  68         if (hapd->driver == NULL || hapd->driver->set_ieee8021x == NULL)
  69                 return 0;
  70         return hapd->driver->set_ieee8021x(ifname, hapd->drv_priv, enabled);
  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_set_key(const char *ifname, struct hostapd_data *hapd,
  84                 wpa_alg alg, const u8 *addr, int key_idx,
  85                 int set_tx, const u8 *seq, size_t seq_len,
  86                 const u8 *key, size_t key_len)
  87 {
  88         if (hapd->driver == NULL || hapd->driver->set_key == NULL)
  89                 return 0;
  90         return hapd->driver->set_key(ifname, hapd->drv_priv, alg, addr,
  91                                      key_idx, set_tx, seq, seq_len, key,
  92                                      key_len);
  93 }
  94
  95 static inline int
  96 hostapd_get_seqnum(const char *ifname, struct hostapd_data *hapd,
  97                    const u8 *addr, int idx, u8 *seq)
  98 {
  99         if (hapd->driver == NULL || hapd->driver->get_seqnum == NULL)
 100                 return 0;
 101         return hapd->driver->get_seqnum(ifname, hapd->drv_priv, addr, idx,
 102                                         seq);
 103 }
 104
 105 static inline int
 106 hostapd_get_seqnum_igtk(const char *ifname, struct hostapd_data *hapd,
 107                         const u8 *addr, int idx, u8 *seq)
 108 {
 109         if (hapd->driver == NULL || hapd->driver->get_seqnum_igtk == NULL)
 110                 return -1;
 111         return hapd->driver->get_seqnum_igtk(ifname, hapd->drv_priv, addr, idx,
 112                                              seq);
 113 }
 114
 115 static inline int
 116 hostapd_flush(struct hostapd_data *hapd)
 117 {
 118         if (hapd->driver == NULL || hapd->driver->flush == NULL)
 119                 return 0;
 120         return hapd->driver->flush(hapd->drv_priv);
 121 }
 122
 123 static inline int
 124 hostapd_set_generic_elem(struct hostapd_data *hapd, const u8 *elem,
 125                          size_t elem_len)
 126 {
 127         if (hapd->driver == NULL || hapd->driver->set_generic_elem == NULL)
 128                 return 0;
 129         return hapd->driver->set_generic_elem(hapd->conf->iface,
 130                                               hapd->drv_priv, elem, elem_len);
 131 }
 132
 133 static inline int
 134 hostapd_read_sta_data(struct hostapd_data *hapd,
 135                       struct hostap_sta_driver_data *data, const u8 *addr)
 136 {
 137         if (hapd->driver == NULL || hapd->driver->read_sta_data == NULL)
 138                 return -1;
 139         return hapd->driver->read_sta_data(hapd->drv_priv, data, addr);
 140 }
 141
 142 static inline int
 143 hostapd_send_eapol(struct hostapd_data *hapd, const u8 *addr, const u8 *data,
 144                    size_t data_len, int encrypt)
 145 {
 146         if (hapd->driver == NULL || hapd->driver->send_eapol == NULL)
 147                 return 0;
 148         return hapd->driver->send_eapol(hapd->drv_priv, addr, data, data_len,
 149                                         encrypt, hapd->own_addr);
 150 }
 151
 152 static inline int
 153 hostapd_sta_deauth(struct hostapd_data *hapd, const u8 *addr, int reason)
 154 {
 155         if (hapd->driver == NULL || hapd->driver->sta_deauth == NULL)
 156                 return 0;
 157         return hapd->driver->sta_deauth(hapd->drv_priv, addr, reason);
 158 }
 159
 160 static inline int
 161 hostapd_sta_disassoc(struct hostapd_data *hapd, const u8 *addr, int reason)
 162 {
 163         if (hapd->driver == NULL || hapd->driver->sta_disassoc == NULL)
 164                 return 0;
 165         return hapd->driver->sta_disassoc(hapd->drv_priv, addr, reason);
 166 }
 167
 168 static inline int
 169 hostapd_sta_remove(struct hostapd_data *hapd, const u8 *addr)
 170 {
 171         if (hapd->driver == NULL || hapd->driver->sta_remove == NULL)
 172                 return 0;
 173         return hapd->driver->sta_remove(hapd->drv_priv, addr);
 174 }
 175
 176 static inline int
 177 hostapd_get_ssid(struct hostapd_data *hapd, u8 *buf, size_t len)
 178 {
 179         if (hapd->driver == NULL || hapd->driver->get_ssid == NULL)
 180                 return 0;
 181         return hapd->driver->get_ssid(hapd->conf->iface, hapd->drv_priv, buf,
 182                                       len);
 183 }
 184
 185 static inline int
 186 hostapd_set_ssid(struct hostapd_data *hapd, const u8 *buf, size_t len)
 187 {
 188         if (hapd->driver == NULL || hapd->driver->set_ssid == NULL)
 189                 return 0;
 190         return hapd->driver->set_ssid(hapd->conf->iface, hapd->drv_priv, buf,
 191                                       len);
 192 }
 193
 194 static inline int
 195 hostapd_send_mgmt_frame(struct hostapd_data *hapd, const void *msg, size_t len,
 196                         int flags)
 197 {
 198         if (hapd->driver == NULL || hapd->driver->send_mgmt_frame == NULL)
 199                 return 0;
 200         return hapd->driver->send_mgmt_frame(hapd->drv_priv, msg, len, flags);
 201 }
 202
 203 static inline int
 204 hostapd_set_countermeasures(struct hostapd_data *hapd, int enabled)
 205 {
 206         if (hapd->driver == NULL || hapd->driver->set_countermeasures == NULL)
 207                 return 0;
 208         return hapd->driver->set_countermeasures(hapd->drv_priv, enabled);
 209 }
 210
 211 static inline int
 212 hostapd_sta_add(const char *ifname, struct hostapd_data *hapd, const u8 *addr,
 213                 u16 aid, u16 capability, const u8 *supp_rates,
 214                 size_t supp_rates_len, int flags, u16 listen_interval,
 215                 const struct ht_cap_ie *ht_capabilities)
 216 {
 217         struct hostapd_sta_add_params params;
 218
 219         if (hapd->driver == NULL)
 220                 return 0;
 221         if (hapd->driver->sta_add == NULL)
 222                 return 0;
 223
 224         os_memset(&params, 0, sizeof(params));
 225         params.addr = addr;
 226         params.aid = aid;
 227         params.capability = capability;
 228         params.supp_rates = supp_rates;
 229         params.supp_rates_len = supp_rates_len;
 230         params.flags = flags;
 231         params.listen_interval = listen_interval;
 232         params.ht_capabilities = ht_capabilities;
 233         return hapd->driver->sta_add(ifname, hapd->drv_priv, &params);
 234 }
 235
 236 static inline int
 237 hostapd_get_inact_sec(struct hostapd_data *hapd, const u8 *addr)
 238 {
 239         if (hapd->driver == NULL || hapd->driver->get_inact_sec == NULL)
 240                 return 0;
 241         return hapd->driver->get_inact_sec(hapd->drv_priv, addr);
 242 }
 243
 244 static inline int
 245 hostapd_set_freq(struct hostapd_data *hapd, int mode, int freq, int ht_enabled,
 246                  int sec_channel_offset)
 247 {
 248         struct hostapd_freq_params data;
 249         if (hapd->driver == NULL)
 250                 return 0;
 251         if (hapd->driver->set_freq == NULL)
 252                 return 0;
 253         os_memset(&data, 0, sizeof(data));
 254         data.mode = mode;
 255         data.freq = freq;
 256         data.ht_enabled = ht_enabled;
 257         data.sec_channel_offset = sec_channel_offset;
 258         return hapd->driver->set_freq(hapd->drv_priv, &data);
 259 }
 260
 261 static inline int
 262 hostapd_set_rts(struct hostapd_data *hapd, int rts)
 263 {
 264         if (hapd->driver == NULL || hapd->driver->set_rts == NULL)
 265                 return 0;
 266         return hapd->driver->set_rts(hapd->drv_priv, rts);
 267 }
 268
 269 static inline int
 270 hostapd_get_rts(struct hostapd_data *hapd, int *rts)
 271 {
 272         if (hapd->driver == NULL || hapd->driver->get_rts == NULL)
 273                 return 0;
 274         return hapd->driver->get_rts(hapd->drv_priv, rts);
 275 }
 276
 277 static inline int
 278 hostapd_set_frag(struct hostapd_data *hapd, int frag)
 279 {
 280         if (hapd->driver == NULL || hapd->driver->set_frag == NULL)
 281                 return 0;
 282         return hapd->driver->set_frag(hapd->drv_priv, frag);
 283 }
 284
 285 static inline int
 286 hostapd_get_frag(struct hostapd_data *hapd, int *frag)
 287 {
 288         if (hapd->driver == NULL || hapd->driver->get_frag == NULL)
 289                 return 0;
 290         return hapd->driver->get_frag(hapd->drv_priv, frag);
 291 }
 292
 293 static inline int
 294 hostapd_set_retry(struct hostapd_data *hapd, int short_retry, int long_retry)
 295 {
 296         if (hapd->driver == NULL || hapd->driver->set_retry == NULL)
 297                 return 0;
 298         return hapd->driver->set_retry(hapd->drv_priv, short_retry,
 299                                        long_retry);
 300 }
 301
 302 static inline int
 303 hostapd_get_retry(struct hostapd_data *hapd, int *short_retry, int *long_retry)
 304 {
 305         if (hapd->driver == NULL || hapd->driver->get_retry == NULL)
 306                 return 0;
 307         return hapd->driver->get_retry(hapd->drv_priv, short_retry,
 308                                        long_retry);
 309 }
 310
 311 static inline int
 312 hostapd_sta_set_flags(struct hostapd_data *hapd, u8 *addr,
 313                       int total_flags, int flags_or, int flags_and)
 314 {
 315         if (hapd->driver == NULL || hapd->driver->sta_set_flags == NULL)
 316                 return 0;
 317         return hapd->driver->sta_set_flags(hapd->drv_priv, addr, total_flags,
 318                                            flags_or, flags_and);
 319 }
 320
 321 static inline int
 322 hostapd_set_rate_sets(struct hostapd_data *hapd, int *supp_rates,
 323                       int *basic_rates, int mode)
 324 {
 325         if (hapd->driver == NULL || hapd->driver->set_rate_sets == NULL)
 326                 return 0;
 327         return hapd->driver->set_rate_sets(hapd->drv_priv, supp_rates,
 328                                            basic_rates, mode);
 329 }
 330
 331 static inline int
 332 hostapd_set_country(struct hostapd_data *hapd, const char *country)
 333 {
 334         if (hapd->driver == NULL ||
 335             hapd->driver->set_country == NULL)
 336                 return 0;
 337         return hapd->driver->set_country(hapd->drv_priv, country);
 338 }
 339
 340 static inline int
 341 hostapd_set_ieee80211d(struct hostapd_data *hapd, int enabled)
 342 {
 343         if (hapd->driver == NULL ||
 344             hapd->driver->set_ieee80211d == NULL)
 345                 return 0;
 346         return hapd->driver->set_ieee80211d(hapd->drv_priv, enabled);
 347 }
 348
 349 static inline int
 350 hostapd_sta_clear_stats(struct hostapd_data *hapd, const u8 *addr)
 351 {
 352         if (hapd->driver == NULL || hapd->driver->sta_clear_stats == NULL)
 353                 return 0;
 354         return hapd->driver->sta_clear_stats(hapd->drv_priv, addr);
 355 }
 356
 357 static inline int
 358 hostapd_set_beacon(const char *ifname, struct hostapd_data *hapd,
 359                    u8 *head, size_t head_len,
 360                    u8 *tail, size_t tail_len)
 361 {
 362         if (hapd->driver == NULL || hapd->driver->set_beacon == NULL)
 363                 return 0;
 364         return hapd->driver->set_beacon(ifname, hapd->drv_priv, head, head_len,
 365                                         tail, tail_len);
 366 }
 367
 368 static inline int
 369 hostapd_set_internal_bridge(struct hostapd_data *hapd, int value)
 370 {
 371         if (hapd->driver == NULL || hapd->driver->set_internal_bridge == NULL)
 372                 return 0;
 373         return hapd->driver->set_internal_bridge(hapd->drv_priv, value);
 374 }
 375
 376 static inline int
 377 hostapd_set_beacon_int(struct hostapd_data *hapd, int value)
 378 {
 379         if (hapd->driver == NULL || hapd->driver->set_beacon_int == NULL)
 380                 return 0;
 381         return hapd->driver->set_beacon_int(hapd->drv_priv, value);
 382 }
 383
 384 static inline int
 385 hostapd_set_dtim_period(struct hostapd_data *hapd, int value)
 386 {
 387         if (hapd->driver == NULL || hapd->driver->set_dtim_period == NULL)
 388                 return 0;
 389         return hapd->driver->set_dtim_period(hapd->conf->iface, hapd->drv_priv,
 390                                              value);
 391 }
 392
 393 static inline int
 394 hostapd_set_broadcast_ssid(struct hostapd_data *hapd, int value)
 395 {
 396         if (hapd->driver == NULL || hapd->driver->set_broadcast_ssid == NULL)
 397                 return 0;
 398         return hapd->driver->set_broadcast_ssid(hapd->drv_priv, value);
 399 }
 400
 401 static inline int
 402 hostapd_set_cts_protect(struct hostapd_data *hapd, int value)
 403 {
 404         if (hapd->driver == NULL || hapd->driver->set_cts_protect == NULL)
 405                 return 0;
 406         return hapd->driver->set_cts_protect(hapd->drv_priv, value);
 407 }
 408
 409 static inline int
 410 hostapd_set_key_tx_rx_threshold(struct hostapd_data *hapd, int value)
 411 {
 412         if (hapd->driver == NULL ||
 413             hapd->driver->set_key_tx_rx_threshold == NULL)
 414                 return 0;
 415         return hapd->driver->set_key_tx_rx_threshold(hapd->drv_priv, value);
 416 }
 417
 418 static inline int
 419 hostapd_set_preamble(struct hostapd_data *hapd, int value)
 420 {
 421         if (hapd->driver == NULL || hapd->driver->set_preamble == NULL)
 422                 return 0;
 423         return hapd->driver->set_preamble(hapd->drv_priv, value);
 424 }
 425
 426 static inline int
 427 hostapd_set_short_slot_time(struct hostapd_data *hapd, int value)
 428 {
 429         if (hapd->driver == NULL || hapd->driver->set_short_slot_time == NULL)
 430                 return 0;
 431         return hapd->driver->set_short_slot_time(hapd->drv_priv, value);
 432 }
 433
 434 static inline int
 435 hostapd_set_tx_queue_params(struct hostapd_data *hapd, int queue, int aifs,
 436                             int cw_min, int cw_max, int burst_time)
 437 {
 438         if (hapd->driver == NULL || hapd->driver->set_tx_queue_params == NULL)
 439                 return 0;
 440         return hapd->driver->set_tx_queue_params(hapd->drv_priv, queue, aifs,
 441                                                  cw_min, cw_max, burst_time);
 442 }
 443
 444 static inline int
 445 hostapd_bss_add(struct hostapd_data *hapd, const char *ifname, const u8 *bssid)
 446 {
 447         if (hapd->driver == NULL || hapd->driver->bss_add == NULL)
 448                 return 0;
 449         return hapd->driver->bss_add(hapd->drv_priv, ifname, bssid);
 450 }
 451
 452 static inline int
 453 hostapd_bss_remove(struct hostapd_data *hapd, const char *ifname)
 454 {
 455         if (hapd->driver == NULL || hapd->driver->bss_remove == NULL)
 456                 return 0;
 457         return hapd->driver->bss_remove(hapd->drv_priv, ifname);
 458 }
 459
 460 static inline int
 461 hostapd_valid_bss_mask(struct hostapd_data *hapd, const u8 *addr,
 462                        const u8 *mask)
 463 {
 464         if (hapd->driver == NULL || hapd->driver->valid_bss_mask == NULL)
 465                 return 1;
 466         return hapd->driver->valid_bss_mask(hapd->drv_priv, addr, mask);
 467 }
 468
 469 static inline int
 470 hostapd_if_add(struct hostapd_data *hapd, enum hostapd_driver_if_type type,
 471                char *ifname, const u8 *addr)
 472 {
 473         if (hapd->driver == NULL || hapd->driver->if_add == NULL)
 474                 return -1;
 475         return hapd->driver->if_add(hapd->conf->iface, hapd->drv_priv, type,
 476                                     ifname, addr);
 477 }
 478
 479 static inline int
 480 hostapd_if_update(struct hostapd_data *hapd, enum hostapd_driver_if_type type,
 481                   char *ifname, const u8 *addr)
 482 {
 483         if (hapd->driver == NULL || hapd->driver->if_update == NULL)
 484                 return -1;
 485         return hapd->driver->if_update(hapd->drv_priv, type, ifname, addr);
 486 }
 487
 488 static inline int
 489 hostapd_if_remove(struct hostapd_data *hapd, enum hostapd_driver_if_type type,
 490                   char *ifname, const u8 *addr)
 491 {
 492         if (hapd->driver == NULL || hapd->driver->if_remove == NULL)
 493                 return -1;
 494         return hapd->driver->if_remove(hapd->drv_priv, type, ifname, addr);
 495 }
 496
 497 static inline int
 498 hostapd_passive_scan(struct hostapd_data *hapd, int now, int our_mode_only,
 499                      int interval, int _listen, int *channel,
 500                      int *last_rx)
 501 {
 502         if (hapd->driver == NULL || hapd->driver->passive_scan == NULL)
 503                 return -1;
 504         return hapd->driver->passive_scan(hapd->drv_priv, now, our_mode_only,
 505                                           interval, _listen, channel, last_rx);
 506 }
 507
 508 static inline struct hostapd_hw_modes *
 509 hostapd_get_hw_feature_data(struct hostapd_data *hapd, u16 *num_modes,
 510                             u16 *flags)
 511 {
 512         if (hapd->driver == NULL || hapd->driver->get_hw_feature_data == NULL)
 513                 return NULL;
 514         return hapd->driver->get_hw_feature_data(hapd->drv_priv, num_modes,
 515                                                  flags);
 516 }
 517
 518 static inline int
 519 hostapd_set_sta_vlan(const char *ifname, struct hostapd_data *hapd,
 520                      const u8 *addr, int vlan_id)
 521 {
 522         if (hapd->driver == NULL || hapd->driver->set_sta_vlan == NULL)
 523                 return 0;
 524         return hapd->driver->set_sta_vlan(hapd->drv_priv, addr, ifname, vlan_id);
 525 }
 526
 527 static inline int
 528 hostapd_driver_commit(struct hostapd_data *hapd)
 529 {
 530         if (hapd->driver == NULL || hapd->driver->commit == NULL)
 531                 return 0;
 532         return hapd->driver->commit(hapd->drv_priv);
 533 }
 534
 535 static inline int
 536 hostapd_set_radius_acl_auth(struct hostapd_data *hapd, const u8 *mac,
 537                             int accepted, u32 session_timeout)
 538 {
 539         if (hapd->driver == NULL || hapd->driver->set_radius_acl_auth == NULL)
 540                 return 0;
 541         return hapd->driver->set_radius_acl_auth(hapd->drv_priv, mac, accepted,
 542                                                  session_timeout);
 543 }
 544
 545 static inline int
 546 hostapd_set_radius_acl_expire(struct hostapd_data *hapd, const u8 *mac)
 547 {
 548         if (hapd->driver == NULL ||
 549             hapd->driver->set_radius_acl_expire == NULL)
 550                 return 0;
 551         return hapd->driver->set_radius_acl_expire(hapd->drv_priv, mac);
 552 }
 553
 554 #ifdef CONFIG_IEEE80211N
 555 static inline int
 556 hostapd_set_ht_params(const char *ifname, struct hostapd_data *hapd,
 557                       const u8 *ht_capab, size_t ht_capab_len,
 558                       const u8 *ht_oper, size_t ht_oper_len)
 559 {
 560         if (hapd->driver == NULL || hapd->driver->set_ht_params == NULL ||
 561             ht_capab == NULL || ht_oper == NULL)
 562                 return 0;
 563         return hapd->driver->set_ht_params(
 564                 ifname, hapd->drv_priv, ht_capab, ht_capab_len,
 565                 ht_oper, ht_oper_len);
 566 }
 567 #endif /* CONFIG_IEEE80211N */
 568
 569 static inline int
 570 hostapd_drv_none(struct hostapd_data *hapd)
 571 {
 572         return hapd->driver && os_strcmp(hapd->driver->name, "none") == 0;
 573 }
 574
 575 static inline int
 576 hostapd_set_wps_beacon_ie(struct hostapd_data *hapd, const u8 *ie, size_t len)
 577 {
 578         if (hapd->driver == NULL || hapd->driver->set_wps_beacon_ie == NULL)
 579                 return 0;
 580         return hapd->driver->set_wps_beacon_ie(hapd->conf->iface,
 581                                                hapd->drv_priv, ie, len);
 582 }
 583
 584 static inline int
 585 hostapd_set_wps_probe_resp_ie(struct hostapd_data *hapd, const u8 *ie,
 586                               size_t len)
 587 {
 588         if (hapd->driver == NULL ||
 589             hapd->driver->set_wps_probe_resp_ie == NULL)
 590                 return 0;
 591         return hapd->driver->set_wps_probe_resp_ie(hapd->conf->iface,
 592                                                    hapd->drv_priv, ie, len);
 593 }
 594
 595 static inline const struct hostapd_neighbor_bss *
 596 hostapd_driver_get_neighbor_bss(struct hostapd_data *hapd, size_t *num)
 597 {
 598         if (hapd->driver == NULL || hapd->driver->get_neighbor_bss == NULL)
 599                 return NULL;
 600         return hapd->driver->get_neighbor_bss(hapd->drv_priv, num);
 601 }
 602
 603 #endif /* DRIVER_I_H */