wpa_supplicant/driver_i.h

   1 /*
   2  * wpa_supplicant - Internal driver interface wrappers
   3  * Copyright (c) 2003-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
  20 /* driver_ops */
  21 static inline void * wpa_drv_init(struct wpa_supplicant *wpa_s,
  22                                   const char *ifname)
  23 {
  24         if (wpa_s->driver->init2)
  25                 return wpa_s->driver->init2(wpa_s, ifname,
  26                                             wpa_s->global_drv_priv);
  27         if (wpa_s->driver->init) {
  28                 return wpa_s->driver->init(wpa_s, ifname);
  29         }
  30         return NULL;
  31 }
  32
  33 static inline void wpa_drv_deinit(struct wpa_supplicant *wpa_s)
  34 {
  35         if (wpa_s->driver->deinit)
  36                 wpa_s->driver->deinit(wpa_s->drv_priv);
  37 }
  38
  39 static inline int wpa_drv_set_param(struct wpa_supplicant *wpa_s,
  40                                     const char *param)
  41 {
  42         if (wpa_s->driver->set_param)
  43                 return wpa_s->driver->set_param(wpa_s->drv_priv, param);
  44         return 0;
  45 }
  46
  47 static inline int wpa_drv_set_countermeasures(struct wpa_supplicant *wpa_s,
  48                                               int enabled)
  49 {
  50         if (wpa_s->driver->set_countermeasures) {
  51                 return wpa_s->driver->set_countermeasures(wpa_s->drv_priv,
  52                                                           enabled);
  53         }
  54         return -1;
  55 }
  56
  57 static inline int wpa_drv_authenticate(struct wpa_supplicant *wpa_s,
  58                                        struct wpa_driver_auth_params *params)
  59 {
  60         if (wpa_s->driver->authenticate)
  61                 return wpa_s->driver->authenticate(wpa_s->drv_priv, params);
  62         return -1;
  63 }
  64
  65 static inline int wpa_drv_associate(struct wpa_supplicant *wpa_s,
  66                                     struct wpa_driver_associate_params *params)
  67 {
  68         if (wpa_s->driver->associate) {
  69                 return wpa_s->driver->associate(wpa_s->drv_priv, params);
  70         }
  71         return -1;
  72 }
  73
  74 static inline int wpa_drv_scan(struct wpa_supplicant *wpa_s,
  75                                struct wpa_driver_scan_params *params)
  76 {
  77         if (wpa_s->driver->scan2)
  78                 return wpa_s->driver->scan2(wpa_s->drv_priv, params);
  79         return -1;
  80 }
  81
  82 static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
  83         struct wpa_supplicant *wpa_s)
  84 {
  85         if (wpa_s->driver->get_scan_results2)
  86                 return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
  87         return NULL;
  88 }
  89
  90 static inline int wpa_drv_get_bssid(struct wpa_supplicant *wpa_s, u8 *bssid)
  91 {
  92         if (wpa_s->driver->get_bssid) {
  93                 return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
  94         }
  95         return -1;
  96 }
  97
  98 static inline int wpa_drv_get_ssid(struct wpa_supplicant *wpa_s, u8 *ssid)
  99 {
 100         if (wpa_s->driver->get_ssid) {
 101                 return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
 102         }
 103         return -1;
 104 }
 105
 106 static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s,
 107                                   enum wpa_alg alg, const u8 *addr,
 108                                   int key_idx, int set_tx,
 109                                    const u8 *seq, size_t seq_len,
 110                                    const u8 *key, size_t key_len)
 111 {
 112         if (wpa_s->driver->set_key) {
 113                 wpa_s->keys_cleared = 0;
 114                 return wpa_s->driver->set_key(wpa_s->ifname, wpa_s->drv_priv,
 115                                               alg, addr, key_idx, set_tx,
 116                                               seq, seq_len, key, key_len);
 117         }
 118         return -1;
 119 }
 120
 121 static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
 122                                          const u8 *addr, int reason_code)
 123 {
 124         if (wpa_s->driver->deauthenticate) {
 125                 return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
 126                                                      reason_code);
 127         }
 128         return -1;
 129 }
 130
 131 static inline int wpa_drv_disassociate(struct wpa_supplicant *wpa_s,
 132                                        const u8 *addr, int reason_code)
 133 {
 134         if (wpa_s->driver->disassociate) {
 135                 return wpa_s->driver->disassociate(wpa_s->drv_priv, addr,
 136                                                    reason_code);
 137         }
 138         return -1;
 139 }
 140
 141 static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
 142                                     const u8 *bssid, const u8 *pmkid)
 143 {
 144         if (wpa_s->driver->add_pmkid) {
 145                 return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
 146         }
 147         return -1;
 148 }
 149
 150 static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
 151                                        const u8 *bssid, const u8 *pmkid)
 152 {
 153         if (wpa_s->driver->remove_pmkid) {
 154                 return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
 155                                                    pmkid);
 156         }
 157         return -1;
 158 }
 159
 160 static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
 161 {
 162         if (wpa_s->driver->flush_pmkid) {
 163                 return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
 164         }
 165         return -1;
 166 }
 167
 168 static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
 169                                    struct wpa_driver_capa *capa)
 170 {
 171         if (wpa_s->driver->get_capa) {
 172                 return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
 173         }
 174         return -1;
 175 }
 176
 177 static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
 178 {
 179         if (wpa_s->driver->poll) {
 180                 wpa_s->driver->poll(wpa_s->drv_priv);
 181         }
 182 }
 183
 184 static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
 185 {
 186         if (wpa_s->driver->get_ifname) {
 187                 return wpa_s->driver->get_ifname(wpa_s->drv_priv);
 188         }
 189         return NULL;
 190 }
 191
 192 static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
 193 {
 194         if (wpa_s->driver->get_mac_addr) {
 195                 return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
 196         }
 197         return NULL;
 198 }
 199
 200 static inline int wpa_drv_send_eapol(struct wpa_supplicant *wpa_s,
 201                                      const u8 *dst, u16 proto,
 202                                      const u8 *data, size_t data_len)
 203 {
 204         if (wpa_s->driver->send_eapol)
 205                 return wpa_s->driver->send_eapol(wpa_s->drv_priv, dst, proto,
 206                                                  data, data_len);
 207         return -1;
 208 }
 209
 210 static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
 211                                         int state)
 212 {
 213         if (wpa_s->driver->set_operstate)
 214                 return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
 215         return 0;
 216 }
 217
 218 static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
 219                                              const u8 *addr, int protect_type,
 220                                              int key_type)
 221 {
 222         if (wpa_s->driver->mlme_setprotection)
 223                 return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
 224                                                          protect_type,
 225                                                          key_type);
 226         return 0;
 227 }
 228
 229 static inline struct hostapd_hw_modes *
 230 wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
 231                             u16 *flags)
 232 {
 233         if (wpa_s->driver->get_hw_feature_data)
 234                 return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
 235                                                           num_modes, flags);
 236         return NULL;
 237 }
 238
 239 static inline int wpa_drv_set_channel(struct wpa_supplicant *wpa_s,
 240                                       enum hostapd_hw_mode phymode, int chan,
 241                                       int freq)
 242 {
 243         if (wpa_s->driver->set_channel)
 244                 return wpa_s->driver->set_channel(wpa_s->drv_priv, phymode,
 245                                                   chan, freq);
 246         return -1;
 247 }
 248
 249 static inline int wpa_drv_set_ssid(struct wpa_supplicant *wpa_s,
 250                                    const u8 *ssid, size_t ssid_len)
 251 {
 252         if (wpa_s->driver->set_ssid) {
 253                 return wpa_s->driver->set_ssid(wpa_s->drv_priv, ssid,
 254                                                ssid_len);
 255         }
 256         return -1;
 257 }
 258
 259 static inline int wpa_drv_set_bssid(struct wpa_supplicant *wpa_s,
 260                                     const u8 *bssid)
 261 {
 262         if (wpa_s->driver->set_bssid) {
 263                 return wpa_s->driver->set_bssid(wpa_s->drv_priv, bssid);
 264         }
 265         return -1;
 266 }
 267
 268 static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
 269                                       const char *alpha2)
 270 {
 271         if (wpa_s->driver->set_country)
 272                 return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
 273         return 0;
 274 }
 275
 276 static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
 277                                     const u8 *data, size_t data_len)
 278 {
 279         if (wpa_s->driver->send_mlme)
 280                 return wpa_s->driver->send_mlme(wpa_s->drv_priv,
 281                                                 data, data_len);
 282         return -1;
 283 }
 284
 285 static inline int wpa_drv_mlme_add_sta(struct wpa_supplicant *wpa_s,
 286                                        const u8 *addr, const u8 *supp_rates,
 287                                        size_t supp_rates_len)
 288 {
 289         if (wpa_s->driver->mlme_add_sta)
 290                 return wpa_s->driver->mlme_add_sta(wpa_s->drv_priv, addr,
 291                                                    supp_rates, supp_rates_len);
 292         return -1;
 293 }
 294
 295 static inline int wpa_drv_mlme_remove_sta(struct wpa_supplicant *wpa_s,
 296                                           const u8 *addr)
 297 {
 298         if (wpa_s->driver->mlme_remove_sta)
 299                 return wpa_s->driver->mlme_remove_sta(wpa_s->drv_priv, addr);
 300         return -1;
 301 }
 302
 303 static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
 304                                         const u8 *md,
 305                                         const u8 *ies, size_t ies_len)
 306 {
 307         if (wpa_s->driver->update_ft_ies)
 308                 return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
 309                                                     ies, ies_len);
 310         return -1;
 311 }
 312
 313 static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s,
 314                                          u8 action, const u8 *target_ap,
 315                                          const u8 *ies, size_t ies_len)
 316 {
 317         if (wpa_s->driver->send_ft_action)
 318                 return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action,
 319                                                      target_ap, ies, ies_len);
 320         return -1;
 321 }
 322
 323 static inline int wpa_drv_set_beacon(struct wpa_supplicant *wpa_s,
 324                                      const u8 *head, size_t head_len,
 325                                      const u8 *tail, size_t tail_len,
 326                                      int dtim_period, int beacon_int)
 327 {
 328         if (wpa_s->driver->set_beacon)
 329                 return wpa_s->driver->set_beacon(wpa_s->drv_priv, head,
 330                                                  head_len, tail, tail_len,
 331                                                  dtim_period, beacon_int);
 332         return -1;
 333 }
 334
 335 static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
 336                                   struct hostapd_sta_add_params *params)
 337 {
 338         if (wpa_s->driver->sta_add)
 339                 return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
 340         return -1;
 341 }
 342
 343 static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
 344                                      const u8 *addr)
 345 {
 346         if (wpa_s->driver->sta_remove)
 347                 return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
 348         return -1;
 349 }
 350
 351 static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
 352                                           const u8 *addr, const u8 *data,
 353                                           size_t data_len, int encrypt,
 354                                           const u8 *own_addr)
 355 {
 356         if (wpa_s->driver->hapd_send_eapol)
 357                 return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
 358                                                       data, data_len, encrypt,
 359                                                       own_addr);
 360         return -1;
 361 }
 362
 363 static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
 364                                         const u8 *addr, int total_flags,
 365                                         int flags_or, int flags_and)
 366 {
 367         if (wpa_s->driver->sta_set_flags)
 368                 return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
 369                                                     total_flags, flags_or,
 370                                                     flags_and);
 371         return -1;
 372 }
 373
 374 static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
 375                                         int authorized)
 376 {
 377         if (wpa_s->driver->set_supp_port) {
 378                 return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
 379                                                     authorized);
 380         }
 381         return 0;
 382 }
 383
 384 static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
 385                                       unsigned int freq,
 386                                       const u8 *dst, const u8 *src,
 387                                       const u8 *bssid,
 388                                       const u8 *data, size_t data_len)
 389 {
 390         if (wpa_s->driver->send_action)
 391                 return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
 392                                                   dst, src, bssid, data,
 393                                                   data_len);
 394         return -1;
 395 }
 396
 397 static inline int wpa_drv_set_freq(struct wpa_supplicant *wpa_s,
 398                                    struct hostapd_freq_params *freq)
 399 {
 400         if (wpa_s->driver->set_freq)
 401                 return wpa_s->driver->set_freq(wpa_s->drv_priv, freq);
 402         return -1;
 403 }
 404
 405 static inline int wpa_drv_if_add(struct wpa_supplicant *wpa_s,
 406                                  enum wpa_driver_if_type type,
 407                                  const char *ifname, const u8 *addr,
 408                                  void *bss_ctx, char *force_ifname,
 409                                  u8 *if_addr)
 410 {
 411         if (wpa_s->driver->if_add)
 412                 return wpa_s->driver->if_add(wpa_s->drv_priv, type, ifname,
 413                                              addr, bss_ctx, NULL, force_ifname,
 414                                              if_addr);
 415         return -1;
 416 }
 417
 418 static inline int wpa_drv_if_remove(struct wpa_supplicant *wpa_s,
 419                                     enum wpa_driver_if_type type,
 420                                     const char *ifname)
 421 {
 422         if (wpa_s->driver->if_remove)
 423                 return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
 424         return -1;
 425 }
 426
 427 static inline int wpa_drv_set_intra_bss(struct wpa_supplicant *wpa_s,
 428                                         int enabled)
 429 {
 430         if (wpa_s->driver->set_intra_bss)
 431                 return wpa_s->driver->set_intra_bss(wpa_s->drv_priv, enabled);
 432         return -1;
 433 }
 434
 435 static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
 436                                             unsigned int freq,
 437                                             unsigned int duration)
 438 {
 439         if (wpa_s->driver->remain_on_channel)
 440                 return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
 441                                                         duration);
 442         return -1;
 443 }
 444
 445 static inline int wpa_drv_cancel_remain_on_channel(
 446         struct wpa_supplicant *wpa_s)
 447 {
 448         if (wpa_s->driver->cancel_remain_on_channel)
 449                 return wpa_s->driver->cancel_remain_on_channel(
 450                         wpa_s->drv_priv);
 451         return -1;
 452 }
 453
 454 static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
 455                                            int report)
 456 {
 457         if (wpa_s->driver->probe_req_report)
 458                 return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
 459                                                        report);
 460         return -1;
 461 }
 462
 463 static inline int wpa_drv_disable_11b_rates(struct wpa_supplicant *wpa_s,
 464                                             int disabled)
 465 {
 466         if (wpa_s->driver->disable_11b_rates)
 467                 return wpa_s->driver->disable_11b_rates(wpa_s->drv_priv,
 468                                                         disabled);
 469         return -1;
 470 }
 471
 472 static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
 473 {
 474         if (wpa_s->driver->deinit_ap)
 475                 return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
 476         return 0;
 477 }
 478
 479 static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
 480 {
 481         if (wpa_s->driver->suspend)
 482                 wpa_s->driver->suspend(wpa_s->drv_priv);
 483 }
 484
 485 static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
 486 {
 487         if (wpa_s->driver->resume)
 488                 wpa_s->driver->resume(wpa_s->drv_priv);
 489 }
 490
 491 static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
 492                                          int threshold, int hysteresis)
 493 {
 494         if (wpa_s->driver->signal_monitor)
 495                 return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
 496                                                      threshold, hysteresis);
 497         return -1;
 498 }
 499
 500 static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
 501                                         const struct wpabuf *beacon,
 502                                         const struct wpabuf *proberesp,
 503                                         const struct wpabuf *assocresp)
 504 {
 505         if (!wpa_s->driver->set_ap_wps_ie)
 506                 return -1;
 507         return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
 508                                             proberesp, assocresp);
 509 }
 510
 511 static inline int wpa_drv_shared_freq(struct wpa_supplicant *wpa_s)
 512 {
 513         if (!wpa_s->driver->shared_freq)
 514                 return -1;
 515         return wpa_s->driver->shared_freq(wpa_s->drv_priv);
 516 }
 517
 518 static inline int wpa_drv_get_noa(struct wpa_supplicant *wpa_s,
 519                                   u8 *buf, size_t buf_len)
 520 {
 521         if (!wpa_s->driver->get_noa)
 522                 return -1;
 523         return wpa_s->driver->get_noa(wpa_s->drv_priv, buf, buf_len);
 524 }
 525
 526 static inline int wpa_drv_set_p2p_powersave(struct wpa_supplicant *wpa_s,
 527                                             int legacy_ps, int opp_ps,
 528                                             int ctwindow)
 529 {
 530         if (!wpa_s->driver->set_p2p_powersave)
 531                 return -1;
 532         return wpa_s->driver->set_p2p_powersave(wpa_s->drv_priv, legacy_ps,
 533                                                 opp_ps, ctwindow);
 534 }
 535
 536 static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
 537 {
 538         if (!wpa_s->driver->ampdu)
 539                 return -1;
 540         return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
 541 }
 542
 543 #endif /* DRIVER_I_H */