workbench/network/WirelessManager/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_associd(struct wpa_supplicant *wpa_s,
 269                                       u16 aid)
 270 {
 271         if (wpa_s->driver->set_associd) {
 272                 return wpa_s->driver->set_associd(wpa_s->drv_priv, aid);
 273         }
 274         return -1;
 275 }
 276
 277 static inline int wpa_drv_set_capabilities(struct wpa_supplicant *wpa_s,
 278                                            u16 capab)
 279 {
 280         if (wpa_s->driver->set_capabilities) {
 281                 return wpa_s->driver->set_capabilities(wpa_s->drv_priv, capab);
 282         }
 283         return -1;
 284 }
 285
 286 static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
 287                                       const char *alpha2)
 288 {
 289         if (wpa_s->driver->set_country)
 290                 return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
 291         return 0;
 292 }
 293
 294 static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
 295                                     const u8 *data, size_t data_len)
 296 {
 297         if (wpa_s->driver->send_mlme)
 298                 return wpa_s->driver->send_mlme(wpa_s->drv_priv,
 299                                                 data, data_len);
 300         return -1;
 301 }
 302
 303 static inline int wpa_drv_mlme_add_sta(struct wpa_supplicant *wpa_s,
 304                                        const u8 *addr, const u8 *supp_rates,
 305                                        size_t supp_rates_len)
 306 {
 307         if (wpa_s->driver->mlme_add_sta)
 308                 return wpa_s->driver->mlme_add_sta(wpa_s->drv_priv, addr,
 309                                                    supp_rates, supp_rates_len);
 310         return -1;
 311 }
 312
 313 static inline int wpa_drv_mlme_remove_sta(struct wpa_supplicant *wpa_s,
 314                                           const u8 *addr)
 315 {
 316         if (wpa_s->driver->mlme_remove_sta)
 317                 return wpa_s->driver->mlme_remove_sta(wpa_s->drv_priv, addr);
 318         return -1;
 319 }
 320
 321 static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
 322                                         const u8 *md,
 323                                         const u8 *ies, size_t ies_len)
 324 {
 325         if (wpa_s->driver->update_ft_ies)
 326                 return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
 327                                                     ies, ies_len);
 328         return -1;
 329 }
 330
 331 static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s,
 332                                          u8 action, const u8 *target_ap,
 333                                          const u8 *ies, size_t ies_len)
 334 {
 335         if (wpa_s->driver->send_ft_action)
 336                 return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action,
 337                                                      target_ap, ies, ies_len);
 338         return -1;
 339 }
 340
 341 static inline int wpa_drv_set_beacon(struct wpa_supplicant *wpa_s,
 342                                      const u8 *head, size_t head_len,
 343                                      const u8 *tail, size_t tail_len,
 344                                      int dtim_period, int beacon_int)
 345 {
 346         if (wpa_s->driver->set_beacon)
 347                 return wpa_s->driver->set_beacon(wpa_s->drv_priv, head,
 348                                                  head_len, tail, tail_len,
 349                                                  dtim_period, beacon_int);
 350         return -1;
 351 }
 352
 353 static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
 354                                   struct hostapd_sta_add_params *params)
 355 {
 356         if (wpa_s->driver->sta_add)
 357                 return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
 358         return -1;
 359 }
 360
 361 static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
 362                                      const u8 *addr)
 363 {
 364         if (wpa_s->driver->sta_remove)
 365                 return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
 366         return -1;
 367 }
 368
 369 static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
 370                                           const u8 *addr, const u8 *data,
 371                                           size_t data_len, int encrypt,
 372                                           const u8 *own_addr)
 373 {
 374         if (wpa_s->driver->hapd_send_eapol)
 375                 return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
 376                                                       data, data_len, encrypt,
 377                                                       own_addr);
 378         return -1;
 379 }
 380
 381 static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
 382                                         const u8 *addr, int total_flags,
 383                                         int flags_or, int flags_and)
 384 {
 385         if (wpa_s->driver->sta_set_flags)
 386                 return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
 387                                                     total_flags, flags_or,
 388                                                     flags_and);
 389         return -1;
 390 }
 391
 392 static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
 393                                         int authorized)
 394 {
 395         if (wpa_s->driver->set_supp_port) {
 396                 return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
 397                                                     authorized);
 398         }
 399         return 0;
 400 }
 401
 402 static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
 403                                       unsigned int freq,
 404                                       const u8 *dst, const u8 *src,
 405                                       const u8 *bssid,
 406                                       const u8 *data, size_t data_len)
 407 {
 408         if (wpa_s->driver->send_action)
 409                 return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
 410                                                   dst, src, bssid, data,
 411                                                   data_len);
 412         return -1;
 413 }
 414
 415 static inline int wpa_drv_if_add(struct wpa_supplicant *wpa_s,
 416                                  enum wpa_driver_if_type type,
 417                                  const char *ifname, const u8 *addr,
 418                                  void *bss_ctx, char *force_ifname,
 419                                  u8 *if_addr)
 420 {
 421         if (wpa_s->driver->if_add)
 422                 return wpa_s->driver->if_add(wpa_s->drv_priv, type, ifname,
 423                                              addr, bss_ctx, NULL, force_ifname,
 424                                              if_addr);
 425         return -1;
 426 }
 427
 428 static inline int wpa_drv_if_remove(struct wpa_supplicant *wpa_s,
 429                                     enum wpa_driver_if_type type,
 430                                     const char *ifname)
 431 {
 432         if (wpa_s->driver->if_remove)
 433                 return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
 434         return -1;
 435 }
 436
 437 static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
 438                                             unsigned int freq,
 439                                             unsigned int duration)
 440 {
 441         if (wpa_s->driver->remain_on_channel)
 442                 return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
 443                                                         duration);
 444         return -1;
 445 }
 446
 447 static inline int wpa_drv_cancel_remain_on_channel(
 448         struct wpa_supplicant *wpa_s)
 449 {
 450         if (wpa_s->driver->cancel_remain_on_channel)
 451                 return wpa_s->driver->cancel_remain_on_channel(
 452                         wpa_s->drv_priv);
 453         return -1;
 454 }
 455
 456 static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
 457                                            int report)
 458 {
 459         if (wpa_s->driver->probe_req_report)
 460                 return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
 461                                                        report);
 462         return -1;
 463 }
 464
 465 static inline int wpa_drv_disable_11b_rates(struct wpa_supplicant *wpa_s,
 466                                             int disabled)
 467 {
 468         if (wpa_s->driver->disable_11b_rates)
 469                 return wpa_s->driver->disable_11b_rates(wpa_s->drv_priv,
 470                                                         disabled);
 471         return -1;
 472 }
 473
 474 static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
 475 {
 476         if (wpa_s->driver->deinit_ap)
 477                 return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
 478         return 0;
 479 }
 480
 481 static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
 482 {
 483         if (wpa_s->driver->suspend)
 484                 wpa_s->driver->suspend(wpa_s->drv_priv);
 485 }
 486
 487 static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
 488 {
 489         if (wpa_s->driver->resume)
 490                 wpa_s->driver->resume(wpa_s->drv_priv);
 491 }
 492
 493 static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
 494                                          int threshold, int hysteresis)
 495 {
 496         if (wpa_s->driver->signal_monitor)
 497                 return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
 498                                                      threshold, hysteresis);
 499         return -1;
 500 }
 501
 502 static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
 503                                         const struct wpabuf *beacon,
 504                                         const struct wpabuf *proberesp)
 505 {
 506         if (!wpa_s->driver->set_ap_wps_ie)
 507                 return -1;
 508         return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
 509                                             proberesp);
 510 }
 511
 512 #endif /* DRIVER_I_H */