vcs.maemo.org Git - wpasupplicant/blob - hostapd/driver.h

   1 /*
   2  * hostapd - driver interface definition
   3  * Copyright (c) 2002-2007, 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_H
  17 #define DRIVER_H
  18
  19 struct hostapd_sta_add_params {
  20         const u8 *addr;
  21         u16 aid;
  22         u16 capability;
  23         const u8 *supp_rates;
  24         size_t supp_rates_len;
  25         int flags;
  26         u16 listen_interval;
  27         const struct ht_cap_ie *ht_capabilities;
  28 };
  29
  30 enum hostapd_driver_if_type {
  31         HOSTAPD_IF_VLAN, HOSTAPD_IF_WDS
  32 };
  33
  34 struct wpa_driver_ops {
  35         const char *name;               /* as appears in the config file */
  36
  37         void * (*init)(struct hostapd_data *hapd);
  38         void * (*init_bssid)(struct hostapd_data *hapd, const u8 *bssid);
  39         void (*deinit)(void *priv);
  40
  41         int (*wireless_event_init)(void *priv);
  42         void (*wireless_event_deinit)(void *priv);
  43
  44         /**
  45          * set_8021x - enable/disable IEEE 802.1X support
  46          * @ifname: Interface name (for multi-SSID/VLAN support)
  47          * @priv: driver private data
  48          * @enabled: 1 = enable, 0 = disable
  49          *
  50          * Returns: 0 on success, -1 on failure
  51          *
  52          * Configure the kernel driver to enable/disable 802.1X support.
  53          * This may be an empty function if 802.1X support is always enabled.
  54          */
  55         int (*set_ieee8021x)(const char *ifname, void *priv, int enabled);
  56
  57         /**
  58          * set_privacy - enable/disable privacy
  59          * @priv: driver private data
  60          * @enabled: 1 = privacy enabled, 0 = disabled
  61          *
  62          * Return: 0 on success, -1 on failure
  63          *
  64          * Configure privacy.
  65          */
  66         int (*set_privacy)(const char *ifname, void *priv, int enabled);
  67
  68         int (*set_encryption)(const char *ifname, void *priv, const char *alg,
  69                               const u8 *addr, int idx,
  70                               const u8 *key, size_t key_len, int txkey);
  71         int (*get_seqnum)(const char *ifname, void *priv, const u8 *addr,
  72                           int idx, u8 *seq);
  73         int (*get_seqnum_igtk)(const char *ifname, void *priv, const u8 *addr,
  74                                int idx, u8 *seq);
  75         int (*flush)(void *priv);
  76         int (*set_generic_elem)(const char *ifname, void *priv, const u8 *elem,
  77                                 size_t elem_len);
  78
  79         int (*read_sta_data)(void *priv, struct hostap_sta_driver_data *data,
  80                              const u8 *addr);
  81         int (*send_eapol)(void *priv, const u8 *addr, const u8 *data,
  82                           size_t data_len, int encrypt, const u8 *own_addr);
  83         int (*sta_deauth)(void *priv, const u8 *addr, int reason);
  84         int (*sta_disassoc)(void *priv, const u8 *addr, int reason);
  85         int (*sta_remove)(void *priv, const u8 *addr);
  86         int (*get_ssid)(const char *ifname, void *priv, u8 *buf, int len);
  87         int (*set_ssid)(const char *ifname, void *priv, const u8 *buf,
  88                         int len);
  89         int (*set_countermeasures)(void *priv, int enabled);
  90         int (*send_mgmt_frame)(void *priv, const void *msg, size_t len,
  91                                int flags);
  92         int (*set_assoc_ap)(void *priv, const u8 *addr);
  93         /* note: sta_add() is deprecated; use sta_add2() instead */
  94         int (*sta_add)(const char *ifname, void *priv, const u8 *addr, u16 aid,
  95                        u16 capability, u8 *supp_rates, size_t supp_rates_len,
  96                        int flags, u16 listen_interval);
  97         int (*sta_add2)(const char *ifname, void *priv,
  98                         struct hostapd_sta_add_params *params);
  99         int (*get_inact_sec)(void *priv, const u8 *addr);
 100         int (*sta_clear_stats)(void *priv, const u8 *addr);
 101
 102         int (*set_freq)(void *priv, int mode, int freq);
 103         int (*set_rts)(void *priv, int rts);
 104         int (*get_rts)(void *priv, int *rts);
 105         int (*set_frag)(void *priv, int frag);
 106         int (*get_frag)(void *priv, int *frag);
 107         int (*set_retry)(void *priv, int short_retry, int long_retry);
 108         int (*get_retry)(void *priv, int *short_retry, int *long_retry);
 109
 110         int (*sta_set_flags)(void *priv, const u8 *addr,
 111                              int total_flags, int flags_or, int flags_and);
 112         int (*set_rate_sets)(void *priv, int *supp_rates, int *basic_rates,
 113                              int mode);
 114         int (*set_regulatory_domain)(void *priv, unsigned int rd);
 115         int (*set_country)(void *priv, const char *country);
 116         int (*set_ieee80211d)(void *priv, int enabled);
 117         int (*set_beacon)(const char *ifname, void *priv,
 118                           u8 *head, size_t head_len,
 119                           u8 *tail, size_t tail_len);
 120
 121         /* Configure internal bridge:
 122          * 0 = disabled, i.e., client separation is enabled (no bridging of
 123          *     packets between associated STAs
 124          * 1 = enabled, i.e., bridge packets between associated STAs (default)
 125          */
 126         int (*set_internal_bridge)(void *priv, int value);
 127         int (*set_beacon_int)(void *priv, int value);
 128         int (*set_dtim_period)(const char *ifname, void *priv, int value);
 129         /* Configure broadcast SSID mode:
 130          * 0 = include SSID in Beacon frames and reply to Probe Request frames
 131          *     that use broadcast SSID
 132          * 1 = hide SSID from Beacon frames and ignore Probe Request frames for
 133          *     broadcast SSID
 134          */
 135         int (*set_broadcast_ssid)(void *priv, int value);
 136         int (*set_cts_protect)(void *priv, int value);
 137         int (*set_key_tx_rx_threshold)(void *priv, int value);
 138         int (*set_preamble)(void *priv, int value);
 139         int (*set_short_slot_time)(void *priv, int value);
 140         int (*set_tx_queue_params)(void *priv, int queue, int aifs, int cw_min,
 141                                    int cw_max, int burst_time);
 142         int (*bss_add)(void *priv, const char *ifname, const u8 *bssid);
 143         int (*bss_remove)(void *priv, const char *ifname);
 144         int (*valid_bss_mask)(void *priv, const u8 *addr, const u8 *mask);
 145         int (*passive_scan)(void *priv, int now, int our_mode_only,
 146                             int interval, int _listen, int *channel,
 147                             int *last_rx);
 148         struct hostapd_hw_modes * (*get_hw_feature_data)(void *priv,
 149                                                          u16 *num_modes,
 150                                                          u16 *flags);
 151         int (*if_add)(const char *iface, void *priv,
 152                       enum hostapd_driver_if_type type, char *ifname,
 153                       const u8 *addr);
 154         int (*if_update)(void *priv, enum hostapd_driver_if_type type,
 155                          char *ifname, const u8 *addr);
 156         int (*if_remove)(void *priv, enum hostapd_driver_if_type type,
 157                          const char *ifname, const u8 *addr);
 158         int (*set_sta_vlan)(void *priv, const u8 *addr, const char *ifname,
 159                             int vlan_id);
 160         /**
 161          * commit - Optional commit changes handler
 162          * @priv: driver private data
 163          * Returns: 0 on success, -1 on failure
 164          *
 165          * This optional handler function can be registered if the driver
 166          * interface implementation needs to commit changes (e.g., by setting
 167          * network interface up) at the end of initial configuration. If set,
 168          * this handler will be called after initial setup has been completed.
 169          */
 170         int (*commit)(void *priv);
 171
 172         int (*send_ether)(void *priv, const u8 *dst, const u8 *src, u16 proto,
 173                           const u8 *data, size_t data_len);
 174
 175         int (*set_radius_acl_auth)(void *priv, const u8 *mac, int accepted,
 176                                    u32 session_timeout);
 177         int (*set_radius_acl_expire)(void *priv, const u8 *mac);
 178
 179         int (*set_ht_capability)(const char *ifname, void *priv,
 180                                  const u8 *data, size_t data_len);
 181         int (*set_ht_operation)(const char *ifname, void *priv,
 182                                 const u8 *data, size_t data_len);
 183
 184         int (*set_wps_beacon_ie)(const char *ifname, void *priv,
 185                                  const u8 *ie, size_t len);
 186         int (*set_wps_probe_resp_ie)(const char *ifname, void *priv,
 187                                      const u8 *ie, size_t len);
 188 };
 189
 190 static inline void *
 191 hostapd_driver_init(struct hostapd_data *hapd)
 192 {
 193         if (hapd->driver == NULL || hapd->driver->init == NULL)
 194                 return NULL;
 195         return hapd->driver->init(hapd);
 196 }
 197
 198 static inline void *
 199 hostapd_driver_init_bssid(struct hostapd_data *hapd, const u8 *bssid)
 200 {
 201         if (hapd->driver == NULL || hapd->driver->init_bssid == NULL)
 202                 return NULL;
 203         return hapd->driver->init_bssid(hapd, bssid);
 204 }
 205
 206 static inline void
 207 hostapd_driver_deinit(struct hostapd_data *hapd)
 208 {
 209         if (hapd->driver == NULL || hapd->driver->deinit == NULL)
 210                 return;
 211         hapd->driver->deinit(hapd->drv_priv);
 212 }
 213
 214 static inline int
 215 hostapd_wireless_event_init(struct hostapd_data *hapd)
 216 {
 217         if (hapd->driver == NULL ||
 218             hapd->driver->wireless_event_init == NULL)
 219                 return 0;
 220         return hapd->driver->wireless_event_init(hapd->drv_priv);
 221 }
 222
 223 static inline void
 224 hostapd_wireless_event_deinit(struct hostapd_data *hapd)
 225 {
 226         if (hapd->driver == NULL ||
 227             hapd->driver->wireless_event_deinit == NULL)
 228                 return;
 229         hapd->driver->wireless_event_deinit(hapd->drv_priv);
 230 }
 231
 232 static inline int
 233 hostapd_set_ieee8021x(const char *ifname, struct hostapd_data *hapd,
 234                       int enabled)
 235 {
 236         if (hapd->driver == NULL || hapd->driver->set_ieee8021x == NULL)
 237                 return 0;
 238         return hapd->driver->set_ieee8021x(ifname, hapd->drv_priv, enabled);
 239 }
 240
 241 static inline int
 242 hostapd_set_privacy(struct hostapd_data *hapd, int enabled)
 243 {
 244         if (hapd->driver == NULL || hapd->driver->set_privacy == NULL)
 245                 return 0;
 246         return hapd->driver->set_privacy(hapd->conf->iface, hapd->drv_priv,
 247                                          enabled);
 248 }
 249
 250 static inline int
 251 hostapd_set_encryption(const char *ifname, struct hostapd_data *hapd,
 252                        const char *alg, const u8 *addr, int idx,
 253                        u8 *key, size_t key_len, int txkey)
 254 {
 255         if (hapd->driver == NULL || hapd->driver->set_encryption == NULL)
 256                 return 0;
 257         return hapd->driver->set_encryption(ifname, hapd->drv_priv, alg, addr,
 258                                             idx, key, key_len, txkey);
 259 }
 260
 261 static inline int
 262 hostapd_get_seqnum(const char *ifname, struct hostapd_data *hapd,
 263                    const u8 *addr, int idx, u8 *seq)
 264 {
 265         if (hapd->driver == NULL || hapd->driver->get_seqnum == NULL)
 266                 return 0;
 267         return hapd->driver->get_seqnum(ifname, hapd->drv_priv, addr, idx,
 268                                         seq);
 269 }
 270
 271 static inline int
 272 hostapd_get_seqnum_igtk(const char *ifname, struct hostapd_data *hapd,
 273                         const u8 *addr, int idx, u8 *seq)
 274 {
 275         if (hapd->driver == NULL || hapd->driver->get_seqnum_igtk == NULL)
 276                 return -1;
 277         return hapd->driver->get_seqnum_igtk(ifname, hapd->drv_priv, addr, idx,
 278                                              seq);
 279 }
 280
 281 static inline int
 282 hostapd_flush(struct hostapd_data *hapd)
 283 {
 284         if (hapd->driver == NULL || hapd->driver->flush == NULL)
 285                 return 0;
 286         return hapd->driver->flush(hapd->drv_priv);
 287 }
 288
 289 static inline int
 290 hostapd_set_generic_elem(struct hostapd_data *hapd, const u8 *elem,
 291                          size_t elem_len)
 292 {
 293         if (hapd->driver == NULL || hapd->driver->set_generic_elem == NULL)
 294                 return 0;
 295         return hapd->driver->set_generic_elem(hapd->conf->iface,
 296                                               hapd->drv_priv, elem, elem_len);
 297 }
 298
 299 static inline int
 300 hostapd_read_sta_data(struct hostapd_data *hapd,
 301                       struct hostap_sta_driver_data *data, const u8 *addr)
 302 {
 303         if (hapd->driver == NULL || hapd->driver->read_sta_data == NULL)
 304                 return -1;
 305         return hapd->driver->read_sta_data(hapd->drv_priv, data, addr);
 306 }
 307
 308 static inline int
 309 hostapd_send_eapol(struct hostapd_data *hapd, const u8 *addr, const u8 *data,
 310                    size_t data_len, int encrypt)
 311 {
 312         if (hapd->driver == NULL || hapd->driver->send_eapol == NULL)
 313                 return 0;
 314         return hapd->driver->send_eapol(hapd->drv_priv, addr, data, data_len,
 315                                         encrypt, hapd->own_addr);
 316 }
 317
 318 static inline int
 319 hostapd_sta_deauth(struct hostapd_data *hapd, const u8 *addr, int reason)
 320 {
 321         if (hapd->driver == NULL || hapd->driver->sta_deauth == NULL)
 322                 return 0;
 323         return hapd->driver->sta_deauth(hapd->drv_priv, addr, reason);
 324 }
 325
 326 static inline int
 327 hostapd_sta_disassoc(struct hostapd_data *hapd, const u8 *addr, int reason)
 328 {
 329         if (hapd->driver == NULL || hapd->driver->sta_disassoc == NULL)
 330                 return 0;
 331         return hapd->driver->sta_disassoc(hapd->drv_priv, addr, reason);
 332 }
 333
 334 static inline int
 335 hostapd_sta_remove(struct hostapd_data *hapd, const u8 *addr)
 336 {
 337         if (hapd->driver == NULL || hapd->driver->sta_remove == NULL)
 338                 return 0;
 339         return hapd->driver->sta_remove(hapd->drv_priv, addr);
 340 }
 341
 342 static inline int
 343 hostapd_get_ssid(struct hostapd_data *hapd, u8 *buf, size_t len)
 344 {
 345         if (hapd->driver == NULL || hapd->driver->get_ssid == NULL)
 346                 return 0;
 347         return hapd->driver->get_ssid(hapd->conf->iface, hapd->drv_priv, buf,
 348                                       len);
 349 }
 350
 351 static inline int
 352 hostapd_set_ssid(struct hostapd_data *hapd, const u8 *buf, size_t len)
 353 {
 354         if (hapd->driver == NULL || hapd->driver->set_ssid == NULL)
 355                 return 0;
 356         return hapd->driver->set_ssid(hapd->conf->iface, hapd->drv_priv, buf,
 357                                       len);
 358 }
 359
 360 static inline int
 361 hostapd_send_mgmt_frame(struct hostapd_data *hapd, const void *msg, size_t len,
 362                         int flags)
 363 {
 364         if (hapd->driver == NULL || hapd->driver->send_mgmt_frame == NULL)
 365                 return 0;
 366         return hapd->driver->send_mgmt_frame(hapd->drv_priv, msg, len, flags);
 367 }
 368
 369 static inline int
 370 hostapd_set_assoc_ap(struct hostapd_data *hapd, const u8 *addr)
 371 {
 372         if (hapd->driver == NULL || hapd->driver->set_assoc_ap == NULL)
 373                 return 0;
 374         return hapd->driver->set_assoc_ap(hapd->drv_priv, addr);
 375 }
 376
 377 static inline int
 378 hostapd_set_countermeasures(struct hostapd_data *hapd, int enabled)
 379 {
 380         if (hapd->driver == NULL || hapd->driver->set_countermeasures == NULL)
 381                 return 0;
 382         return hapd->driver->set_countermeasures(hapd->drv_priv, enabled);
 383 }
 384
 385 static inline int
 386 hostapd_sta_add(const char *ifname, struct hostapd_data *hapd, const u8 *addr,
 387                 u16 aid, u16 capability, const u8 *supp_rates,
 388                 size_t supp_rates_len, int flags, u16 listen_interval,
 389                 const struct ht_cap_ie *ht_capabilities)
 390 {
 391         if (hapd->driver == NULL)
 392                 return 0;
 393
 394         if (hapd->driver->sta_add2) {
 395                 struct hostapd_sta_add_params params;
 396                 os_memset(&params, 0, sizeof(params));
 397                 params.addr = addr;
 398                 params.aid = aid;
 399                 params.capability = capability;
 400                 params.supp_rates = supp_rates;
 401                 params.supp_rates_len = supp_rates_len;
 402                 params.flags = flags;
 403                 params.listen_interval = listen_interval;
 404                 params.ht_capabilities = ht_capabilities;
 405                 return hapd->driver->sta_add2(ifname, hapd->drv_priv, &params);
 406         }
 407
 408         if (hapd->driver->sta_add == NULL)
 409                 return 0;
 410         return hapd->driver->sta_add(ifname, hapd->drv_priv, addr, aid,
 411                                      capability, (u8 *) supp_rates,
 412                                      supp_rates_len,
 413                                      flags, listen_interval);
 414 }
 415
 416 static inline int
 417 hostapd_get_inact_sec(struct hostapd_data *hapd, const u8 *addr)
 418 {
 419         if (hapd->driver == NULL || hapd->driver->get_inact_sec == NULL)
 420                 return 0;
 421         return hapd->driver->get_inact_sec(hapd->drv_priv, addr);
 422 }
 423
 424 static inline int
 425 hostapd_set_freq(struct hostapd_data *hapd, int mode, int freq)
 426 {
 427         if (hapd->driver == NULL || hapd->driver->set_freq == NULL)
 428                 return 0;
 429         return hapd->driver->set_freq(hapd->drv_priv, mode, freq);
 430 }
 431
 432 static inline int
 433 hostapd_set_rts(struct hostapd_data *hapd, int rts)
 434 {
 435         if (hapd->driver == NULL || hapd->driver->set_rts == NULL)
 436                 return 0;
 437         return hapd->driver->set_rts(hapd->drv_priv, rts);
 438 }
 439
 440 static inline int
 441 hostapd_get_rts(struct hostapd_data *hapd, int *rts)
 442 {
 443         if (hapd->driver == NULL || hapd->driver->get_rts == NULL)
 444                 return 0;
 445         return hapd->driver->get_rts(hapd->drv_priv, rts);
 446 }
 447
 448 static inline int
 449 hostapd_set_frag(struct hostapd_data *hapd, int frag)
 450 {
 451         if (hapd->driver == NULL || hapd->driver->set_frag == NULL)
 452                 return 0;
 453         return hapd->driver->set_frag(hapd->drv_priv, frag);
 454 }
 455
 456 static inline int
 457 hostapd_get_frag(struct hostapd_data *hapd, int *frag)
 458 {
 459         if (hapd->driver == NULL || hapd->driver->get_frag == NULL)
 460                 return 0;
 461         return hapd->driver->get_frag(hapd->drv_priv, frag);
 462 }
 463
 464 static inline int
 465 hostapd_set_retry(struct hostapd_data *hapd, int short_retry, int long_retry)
 466 {
 467         if (hapd->driver == NULL || hapd->driver->set_retry == NULL)
 468                 return 0;
 469         return hapd->driver->set_retry(hapd->drv_priv, short_retry,
 470                                        long_retry);
 471 }
 472
 473 static inline int
 474 hostapd_get_retry(struct hostapd_data *hapd, int *short_retry, int *long_retry)
 475 {
 476         if (hapd->driver == NULL || hapd->driver->get_retry == NULL)
 477                 return 0;
 478         return hapd->driver->get_retry(hapd->drv_priv, short_retry,
 479                                        long_retry);
 480 }
 481
 482 static inline int
 483 hostapd_sta_set_flags(struct hostapd_data *hapd, u8 *addr,
 484                       int total_flags, int flags_or, int flags_and)
 485 {
 486         if (hapd->driver == NULL || hapd->driver->sta_set_flags == NULL)
 487                 return 0;
 488         return hapd->driver->sta_set_flags(hapd->drv_priv, addr, total_flags,
 489                                            flags_or, flags_and);
 490 }
 491
 492 static inline int
 493 hostapd_set_rate_sets(struct hostapd_data *hapd, int *supp_rates,
 494                       int *basic_rates, int mode)
 495 {
 496         if (hapd->driver == NULL || hapd->driver->set_rate_sets == NULL)
 497                 return 0;
 498         return hapd->driver->set_rate_sets(hapd->drv_priv, supp_rates,
 499                                            basic_rates, mode);
 500 }
 501
 502 static inline int
 503 hostapd_set_regulatory_domain(struct hostapd_data *hapd, unsigned int rd)
 504 {
 505         if (hapd->driver == NULL ||
 506             hapd->driver->set_regulatory_domain == NULL)
 507                 return 0;
 508         return hapd->driver->set_regulatory_domain(hapd->drv_priv, rd);
 509 }
 510
 511 static inline int
 512 hostapd_set_country(struct hostapd_data *hapd, const char *country)
 513 {
 514         if (hapd->driver == NULL ||
 515             hapd->driver->set_country == NULL)
 516                 return 0;
 517         return hapd->driver->set_country(hapd->drv_priv, country);
 518 }
 519
 520 static inline int
 521 hostapd_set_ieee80211d(struct hostapd_data *hapd, int enabled)
 522 {
 523         if (hapd->driver == NULL ||
 524             hapd->driver->set_ieee80211d == NULL)
 525                 return 0;
 526         return hapd->driver->set_ieee80211d(hapd->drv_priv, enabled);
 527 }
 528
 529 static inline int
 530 hostapd_sta_clear_stats(struct hostapd_data *hapd, const u8 *addr)
 531 {
 532         if (hapd->driver == NULL || hapd->driver->sta_clear_stats == NULL)
 533                 return 0;
 534         return hapd->driver->sta_clear_stats(hapd->drv_priv, addr);
 535 }
 536
 537 static inline int
 538 hostapd_set_beacon(const char *ifname, struct hostapd_data *hapd,
 539                    u8 *head, size_t head_len,
 540                    u8 *tail, size_t tail_len)
 541 {
 542         if (hapd->driver == NULL || hapd->driver->set_beacon == NULL)
 543                 return 0;
 544         return hapd->driver->set_beacon(ifname, hapd->drv_priv, head, head_len,
 545                                         tail, tail_len);
 546 }
 547
 548 static inline int
 549 hostapd_set_internal_bridge(struct hostapd_data *hapd, int value)
 550 {
 551         if (hapd->driver == NULL || hapd->driver->set_internal_bridge == NULL)
 552                 return 0;
 553         return hapd->driver->set_internal_bridge(hapd->drv_priv, value);
 554 }
 555
 556 static inline int
 557 hostapd_set_beacon_int(struct hostapd_data *hapd, int value)
 558 {
 559         if (hapd->driver == NULL || hapd->driver->set_beacon_int == NULL)
 560                 return 0;
 561         return hapd->driver->set_beacon_int(hapd->drv_priv, value);
 562 }
 563
 564 static inline int
 565 hostapd_set_dtim_period(struct hostapd_data *hapd, int value)
 566 {
 567         if (hapd->driver == NULL || hapd->driver->set_dtim_period == NULL)
 568                 return 0;
 569         return hapd->driver->set_dtim_period(hapd->conf->iface, hapd->drv_priv,
 570                                              value);
 571 }
 572
 573 static inline int
 574 hostapd_set_broadcast_ssid(struct hostapd_data *hapd, int value)
 575 {
 576         if (hapd->driver == NULL || hapd->driver->set_broadcast_ssid == NULL)
 577                 return 0;
 578         return hapd->driver->set_broadcast_ssid(hapd->drv_priv, value);
 579 }
 580
 581 static inline int
 582 hostapd_set_cts_protect(struct hostapd_data *hapd, int value)
 583 {
 584         if (hapd->driver == NULL || hapd->driver->set_cts_protect == NULL)
 585                 return 0;
 586         return hapd->driver->set_cts_protect(hapd->drv_priv, value);
 587 }
 588
 589 static inline int
 590 hostapd_set_key_tx_rx_threshold(struct hostapd_data *hapd, int value)
 591 {
 592         if (hapd->driver == NULL ||
 593             hapd->driver->set_key_tx_rx_threshold == NULL)
 594                 return 0;
 595         return hapd->driver->set_key_tx_rx_threshold(hapd->drv_priv, value);
 596 }
 597
 598 static inline int
 599 hostapd_set_preamble(struct hostapd_data *hapd, int value)
 600 {
 601         if (hapd->driver == NULL || hapd->driver->set_preamble == NULL)
 602                 return 0;
 603         return hapd->driver->set_preamble(hapd->drv_priv, value);
 604 }
 605
 606 static inline int
 607 hostapd_set_short_slot_time(struct hostapd_data *hapd, int value)
 608 {
 609         if (hapd->driver == NULL || hapd->driver->set_short_slot_time == NULL)
 610                 return 0;
 611         return hapd->driver->set_short_slot_time(hapd->drv_priv, value);
 612 }
 613
 614 static inline int
 615 hostapd_set_tx_queue_params(struct hostapd_data *hapd, int queue, int aifs,
 616                             int cw_min, int cw_max, int burst_time)
 617 {
 618         if (hapd->driver == NULL || hapd->driver->set_tx_queue_params == NULL)
 619                 return 0;
 620         return hapd->driver->set_tx_queue_params(hapd->drv_priv, queue, aifs,
 621                                                  cw_min, cw_max, burst_time);
 622 }
 623
 624 static inline int
 625 hostapd_bss_add(struct hostapd_data *hapd, const char *ifname, const u8 *bssid)
 626 {
 627         if (hapd->driver == NULL || hapd->driver->bss_add == NULL)
 628                 return 0;
 629         return hapd->driver->bss_add(hapd->drv_priv, ifname, bssid);
 630 }
 631
 632 static inline int
 633 hostapd_bss_remove(struct hostapd_data *hapd, const char *ifname)
 634 {
 635         if (hapd->driver == NULL || hapd->driver->bss_remove == NULL)
 636                 return 0;
 637         return hapd->driver->bss_remove(hapd->drv_priv, ifname);
 638 }
 639
 640 static inline int
 641 hostapd_valid_bss_mask(struct hostapd_data *hapd, const u8 *addr,
 642                        const u8 *mask)
 643 {
 644         if (hapd->driver == NULL || hapd->driver->valid_bss_mask == NULL)
 645                 return 1;
 646         return hapd->driver->valid_bss_mask(hapd->drv_priv, addr, mask);
 647 }
 648
 649 static inline int
 650 hostapd_if_add(struct hostapd_data *hapd, enum hostapd_driver_if_type type,
 651                char *ifname, const u8 *addr)
 652 {
 653         if (hapd->driver == NULL || hapd->driver->if_add == NULL)
 654                 return -1;
 655         return hapd->driver->if_add(hapd->conf->iface, hapd->drv_priv, type,
 656                                     ifname, addr);
 657 }
 658
 659 static inline int
 660 hostapd_if_update(struct hostapd_data *hapd, enum hostapd_driver_if_type type,
 661                   char *ifname, const u8 *addr)
 662 {
 663         if (hapd->driver == NULL || hapd->driver->if_update == NULL)
 664                 return -1;
 665         return hapd->driver->if_update(hapd->drv_priv, type, ifname, addr);
 666 }
 667
 668 static inline int
 669 hostapd_if_remove(struct hostapd_data *hapd, enum hostapd_driver_if_type type,
 670                   char *ifname, const u8 *addr)
 671 {
 672         if (hapd->driver == NULL || hapd->driver->if_remove == NULL)
 673                 return -1;
 674         return hapd->driver->if_remove(hapd->drv_priv, type, ifname, addr);
 675 }
 676
 677 static inline int
 678 hostapd_passive_scan(struct hostapd_data *hapd, int now, int our_mode_only,
 679                      int interval, int _listen, int *channel,
 680                      int *last_rx)
 681 {
 682         if (hapd->driver == NULL || hapd->driver->passive_scan == NULL)
 683                 return -1;
 684         return hapd->driver->passive_scan(hapd->drv_priv, now, our_mode_only,
 685                                           interval, _listen, channel, last_rx);
 686 }
 687
 688 static inline struct hostapd_hw_modes *
 689 hostapd_get_hw_feature_data(struct hostapd_data *hapd, u16 *num_modes,
 690                             u16 *flags)
 691 {
 692         if (hapd->driver == NULL || hapd->driver->get_hw_feature_data == NULL)
 693                 return NULL;
 694         return hapd->driver->get_hw_feature_data(hapd->drv_priv, num_modes,
 695                                                  flags);
 696 }
 697
 698 static inline int
 699 hostapd_set_sta_vlan(const char *ifname, struct hostapd_data *hapd,
 700                      const u8 *addr, int vlan_id)
 701 {
 702         if (hapd->driver == NULL || hapd->driver->set_sta_vlan == NULL)
 703                 return 0;
 704         return hapd->driver->set_sta_vlan(hapd->drv_priv, addr, ifname, vlan_id);
 705 }
 706
 707 static inline int
 708 hostapd_driver_commit(struct hostapd_data *hapd)
 709 {
 710         if (hapd->driver == NULL || hapd->driver->commit == NULL)
 711                 return 0;
 712         return hapd->driver->commit(hapd->drv_priv);
 713 }
 714
 715 static inline int
 716 hostapd_set_radius_acl_auth(struct hostapd_data *hapd, const u8 *mac,
 717                             int accepted, u32 session_timeout)
 718 {
 719         if (hapd->driver == NULL || hapd->driver->set_radius_acl_auth == NULL)
 720                 return 0;
 721         return hapd->driver->set_radius_acl_auth(hapd->drv_priv, mac, accepted,
 722                                                  session_timeout);
 723 }
 724
 725 static inline int
 726 hostapd_set_radius_acl_expire(struct hostapd_data *hapd, const u8 *mac)
 727 {
 728         if (hapd->driver == NULL ||
 729             hapd->driver->set_radius_acl_expire == NULL)
 730                 return 0;
 731         return hapd->driver->set_radius_acl_expire(hapd->drv_priv, mac);
 732 }
 733
 734 #ifdef CONFIG_IEEE80211N
 735 static inline int
 736 hostapd_set_ht_capability(const char *ifname, struct hostapd_data *hapd,
 737                           const u8 *ht_cap)
 738 {
 739         if (hapd->driver == NULL || hapd->driver->set_ht_capability == NULL ||
 740             ht_cap == NULL)
 741                 return 0;
 742         return hapd->driver->set_ht_capability(
 743                 ifname, hapd->drv_priv, ht_cap,
 744                 sizeof(struct ieee80211_ht_capability));
 745 }
 746
 747 static inline int
 748 hostapd_set_ht_operation(const char *ifname, struct hostapd_data *hapd,
 749                          const u8 *ht_operation)
 750 {
 751         if (hapd->driver == NULL || hapd->driver->set_ht_operation == NULL ||
 752             ht_operation == NULL)
 753                 return 0;
 754         return hapd->driver->set_ht_operation(
 755                 ifname, hapd->drv_priv, ht_operation,
 756                 sizeof(struct ieee80211_ht_operation));
 757 }
 758 #endif /* CONFIG_IEEE80211N */
 759
 760 static inline int
 761 hostapd_drv_none(struct hostapd_data *hapd)
 762 {
 763         return hapd->driver && os_strcmp(hapd->driver->name, "none") == 0;
 764 }
 765
 766 static inline int
 767 hostapd_set_wps_beacon_ie(struct hostapd_data *hapd, const u8 *ie, size_t len)
 768 {
 769         if (hapd->driver == NULL || hapd->driver->set_wps_beacon_ie == NULL)
 770                 return 0;
 771         return hapd->driver->set_wps_beacon_ie(hapd->conf->iface,
 772                                                hapd->drv_priv, ie, len);
 773 }
 774
 775 static inline int
 776 hostapd_set_wps_probe_resp_ie(struct hostapd_data *hapd, const u8 *ie,
 777                               size_t len)
 778 {
 779         if (hapd->driver == NULL ||
 780             hapd->driver->set_wps_probe_resp_ie == NULL)
 781                 return 0;
 782         return hapd->driver->set_wps_probe_resp_ie(hapd->conf->iface,
 783                                                    hapd->drv_priv, ie, len);
 784 }
 785
 786 #endif /* DRIVER_H */