git.maemo.org Git - wpasupplicant/blob - 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, wpa_s->global);
  26         if (wpa_s->driver->init) {
  27                 return wpa_s->driver->init(wpa_s, ifname);
  28         }
  29         return NULL;
  30 }
  31
  32 static inline void wpa_drv_deinit(struct wpa_supplicant *wpa_s)
  33 {
  34         if (wpa_s->driver->deinit)
  35                 wpa_s->driver->deinit(wpa_s->drv_priv);
  36 }
  37
  38 static inline int wpa_drv_set_param(struct wpa_supplicant *wpa_s,
  39                                     const char *param)
  40 {
  41         if (wpa_s->driver->set_param)
  42                 return wpa_s->driver->set_param(wpa_s->drv_priv, param);
  43         return 0;
  44 }
  45
  46 static inline int wpa_drv_set_drop_unencrypted(struct wpa_supplicant *wpa_s,
  47                                                int enabled)
  48 {
  49         if (wpa_s->driver->set_drop_unencrypted) {
  50                 return wpa_s->driver->set_drop_unencrypted(wpa_s->drv_priv,
  51                                                            enabled);
  52         }
  53         return -1;
  54 }
  55
  56 static inline int wpa_drv_set_countermeasures(struct wpa_supplicant *wpa_s,
  57                                               int enabled)
  58 {
  59         if (wpa_s->driver->set_countermeasures) {
  60                 return wpa_s->driver->set_countermeasures(wpa_s->drv_priv,
  61                                                           enabled);
  62         }
  63         return -1;
  64 }
  65
  66 static inline int wpa_drv_set_auth_alg(struct wpa_supplicant *wpa_s,
  67                                        int auth_alg)
  68 {
  69         if (wpa_s->driver->set_auth_alg) {
  70                 return wpa_s->driver->set_auth_alg(wpa_s->drv_priv,
  71                                                    auth_alg);
  72         }
  73         return -1;
  74 }
  75
  76 static inline int wpa_drv_set_wpa(struct wpa_supplicant *wpa_s, int enabled)
  77 {
  78         if (wpa_s->driver->set_wpa) {
  79                 return wpa_s->driver->set_wpa(wpa_s->drv_priv, enabled);
  80         }
  81         return 0;
  82 }
  83
  84 static inline int wpa_drv_set_mode(struct wpa_supplicant *wpa_s, int mode)
  85 {
  86         if (wpa_s->driver->set_mode) {
  87                 return wpa_s->driver->set_mode(wpa_s->drv_priv, mode);
  88         }
  89         return 0;
  90 }
  91
  92 static inline int wpa_drv_authenticate(struct wpa_supplicant *wpa_s,
  93                                        struct wpa_driver_auth_params *params)
  94 {
  95         if (wpa_s->driver->authenticate)
  96                 return wpa_s->driver->authenticate(wpa_s->drv_priv, params);
  97         return -1;
  98 }
  99
 100 static inline int wpa_drv_associate(struct wpa_supplicant *wpa_s,
 101                                     struct wpa_driver_associate_params *params)
 102 {
 103         if (wpa_s->driver->associate) {
 104                 return wpa_s->driver->associate(wpa_s->drv_priv, params);
 105         }
 106         return -1;
 107 }
 108
 109 static inline int wpa_drv_scan(struct wpa_supplicant *wpa_s,
 110                                struct wpa_driver_scan_params *params)
 111 {
 112         if (wpa_s->driver->scan2)
 113                 return wpa_s->driver->scan2(wpa_s->drv_priv, params);
 114         if (wpa_s->driver->scan)
 115                 return wpa_s->driver->scan(wpa_s->drv_priv,
 116                                            params->ssids[0].ssid,
 117                                            params->ssids[0].ssid_len);
 118         return -1;
 119 }
 120
 121 static inline int wpa_drv_get_scan_results(struct wpa_supplicant *wpa_s,
 122                                            struct wpa_scan_result *results,
 123                                            size_t max_size)
 124 {
 125         if (wpa_s->driver->get_scan_results) {
 126                 return wpa_s->driver->get_scan_results(wpa_s->drv_priv,
 127                                                        results, max_size);
 128         }
 129         return -1;
 130 }
 131
 132 static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
 133         struct wpa_supplicant *wpa_s)
 134 {
 135         if (wpa_s->driver->get_scan_results2)
 136                 return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
 137         return NULL;
 138 }
 139
 140 static inline int wpa_drv_get_bssid(struct wpa_supplicant *wpa_s, u8 *bssid)
 141 {
 142         if (wpa_s->driver->get_bssid) {
 143                 return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
 144         }
 145         return -1;
 146 }
 147
 148 static inline int wpa_drv_get_ssid(struct wpa_supplicant *wpa_s, u8 *ssid)
 149 {
 150         if (wpa_s->driver->get_ssid) {
 151                 return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
 152         }
 153         return -1;
 154 }
 155
 156 static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s, wpa_alg alg,
 157                                    const u8 *addr, int key_idx, int set_tx,
 158                                    const u8 *seq, size_t seq_len,
 159                                    const u8 *key, size_t key_len)
 160 {
 161         if (wpa_s->driver->set_key) {
 162                 wpa_s->keys_cleared = 0;
 163                 return wpa_s->driver->set_key(wpa_s->drv_priv, alg, addr,
 164                                               key_idx, set_tx, seq, seq_len,
 165                                               key, key_len);
 166         }
 167         return -1;
 168 }
 169
 170 static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
 171                                          const u8 *addr, int reason_code)
 172 {
 173         if (wpa_s->driver->deauthenticate) {
 174                 return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
 175                                                      reason_code);
 176         }
 177         return -1;
 178 }
 179
 180 static inline int wpa_drv_disassociate(struct wpa_supplicant *wpa_s,
 181                                        const u8 *addr, int reason_code)
 182 {
 183         if (wpa_s->driver->disassociate) {
 184                 return wpa_s->driver->disassociate(wpa_s->drv_priv, addr,
 185                                                    reason_code);
 186         }
 187         return -1;
 188 }
 189
 190 static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
 191                                     const u8 *bssid, const u8 *pmkid)
 192 {
 193         if (wpa_s->driver->add_pmkid) {
 194                 return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
 195         }
 196         return -1;
 197 }
 198
 199 static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
 200                                        const u8 *bssid, const u8 *pmkid)
 201 {
 202         if (wpa_s->driver->remove_pmkid) {
 203                 return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
 204                                                    pmkid);
 205         }
 206         return -1;
 207 }
 208
 209 static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
 210 {
 211         if (wpa_s->driver->flush_pmkid) {
 212                 return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
 213         }
 214         return -1;
 215 }
 216
 217 static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
 218                                    struct wpa_driver_capa *capa)
 219 {
 220         if (wpa_s->driver->get_capa) {
 221                 return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
 222         }
 223         return -1;
 224 }
 225
 226 static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
 227 {
 228         if (wpa_s->driver->poll) {
 229                 wpa_s->driver->poll(wpa_s->drv_priv);
 230         }
 231 }
 232
 233 static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
 234 {
 235         if (wpa_s->driver->get_ifname) {
 236                 return wpa_s->driver->get_ifname(wpa_s->drv_priv);
 237         }
 238         return NULL;
 239 }
 240
 241 static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
 242 {
 243         if (wpa_s->driver->get_mac_addr) {
 244                 return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
 245         }
 246         return NULL;
 247 }
 248
 249 static inline int wpa_drv_send_eapol(struct wpa_supplicant *wpa_s,
 250                                      const u8 *dst, u16 proto,
 251                                      const u8 *data, size_t data_len)
 252 {
 253         if (wpa_s->driver->send_eapol)
 254                 return wpa_s->driver->send_eapol(wpa_s->drv_priv, dst, proto,
 255                                                  data, data_len);
 256         return -1;
 257 }
 258
 259 static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
 260                                         int state)
 261 {
 262         if (wpa_s->driver->set_operstate)
 263                 return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
 264         return 0;
 265 }
 266
 267 static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
 268                                              const u8 *addr, int protect_type,
 269                                              int key_type)
 270 {
 271         if (wpa_s->driver->mlme_setprotection)
 272                 return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
 273                                                          protect_type,
 274                                                          key_type);
 275         return 0;
 276 }
 277
 278 static inline struct hostapd_hw_modes *
 279 wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
 280                             u16 *flags)
 281 {
 282         if (wpa_s->driver->get_hw_feature_data)
 283                 return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
 284                                                           num_modes, flags);
 285         return NULL;
 286 }
 287
 288 static inline int wpa_drv_set_channel(struct wpa_supplicant *wpa_s,
 289                                       hostapd_hw_mode phymode, int chan,
 290                                       int freq)
 291 {
 292         if (wpa_s->driver->set_channel)
 293                 return wpa_s->driver->set_channel(wpa_s->drv_priv, phymode,
 294                                                   chan, freq);
 295         return -1;
 296 }
 297
 298 static inline int wpa_drv_set_ssid(struct wpa_supplicant *wpa_s,
 299                                    const u8 *ssid, size_t ssid_len)
 300 {
 301         if (wpa_s->driver->set_ssid) {
 302                 return wpa_s->driver->set_ssid(wpa_s->drv_priv, ssid,
 303                                                ssid_len);
 304         }
 305         return -1;
 306 }
 307
 308 static inline int wpa_drv_set_bssid(struct wpa_supplicant *wpa_s,
 309                                     const u8 *bssid)
 310 {
 311         if (wpa_s->driver->set_bssid) {
 312                 return wpa_s->driver->set_bssid(wpa_s->drv_priv, bssid);
 313         }
 314         return -1;
 315 }
 316
 317 static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
 318                                       const char *alpha2)
 319 {
 320         if (wpa_s->driver->set_country)
 321                 return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
 322         return 0;
 323 }
 324
 325 static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
 326                                     const u8 *data, size_t data_len)
 327 {
 328         if (wpa_s->driver->send_mlme)
 329                 return wpa_s->driver->send_mlme(wpa_s->drv_priv,
 330                                                 data, data_len);
 331         return -1;
 332 }
 333
 334 static inline int wpa_drv_mlme_add_sta(struct wpa_supplicant *wpa_s,
 335                                        const u8 *addr, const u8 *supp_rates,
 336                                        size_t supp_rates_len)
 337 {
 338         if (wpa_s->driver->mlme_add_sta)
 339                 return wpa_s->driver->mlme_add_sta(wpa_s->drv_priv, addr,
 340                                                    supp_rates, supp_rates_len);
 341         return -1;
 342 }
 343
 344 static inline int wpa_drv_mlme_remove_sta(struct wpa_supplicant *wpa_s,
 345                                           const u8 *addr)
 346 {
 347         if (wpa_s->driver->mlme_remove_sta)
 348                 return wpa_s->driver->mlme_remove_sta(wpa_s->drv_priv, addr);
 349         return -1;
 350 }
 351
 352 static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
 353                                         const u8 *md,
 354                                         const u8 *ies, size_t ies_len)
 355 {
 356         if (wpa_s->driver->update_ft_ies)
 357                 return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
 358                                                     ies, ies_len);
 359         return -1;
 360 }
 361
 362 static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s,
 363                                          u8 action, const u8 *target_ap,
 364                                          const u8 *ies, size_t ies_len)
 365 {
 366         if (wpa_s->driver->send_ft_action)
 367                 return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action,
 368                                                      target_ap, ies, ies_len);
 369         return -1;
 370 }
 371
 372 static inline int wpa_drv_set_probe_req_ie(struct wpa_supplicant *wpa_s,
 373                                            const u8 *ies, size_t ies_len)
 374 {
 375         if (wpa_s->driver->set_probe_req_ie)
 376                 return wpa_s->driver->set_probe_req_ie(wpa_s->drv_priv, ies,
 377                                                        ies_len);
 378         return -1;
 379 }
 380
 381 static inline int wpa_drv_set_beacon(struct wpa_supplicant *wpa_s,
 382                                      const u8 *head, size_t head_len,
 383                                      const u8 *tail, size_t tail_len,
 384                                      int dtim_period)
 385 {
 386         if (wpa_s->driver->set_beacon)
 387                 return wpa_s->driver->set_beacon(wpa_s->drv_priv, head,
 388                                                  head_len, tail, tail_len,
 389                                                  dtim_period);
 390         return -1;
 391 }
 392
 393 static inline int wpa_drv_set_beacon_int(struct wpa_supplicant *wpa_s,
 394                                          int value)
 395 {
 396         if (wpa_s->driver->set_beacon_int)
 397                 return wpa_s->driver->set_beacon_int(wpa_s->drv_priv, value);
 398         return -1;
 399 }
 400
 401 static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
 402                                   struct hostapd_sta_add_params *params)
 403 {
 404         if (wpa_s->driver->sta_add)
 405                 return wpa_s->driver->sta_add(wpa_s->ifname, wpa_s->drv_priv,
 406                                               params);
 407         return -1;
 408 }
 409
 410 static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
 411                                      const u8 *addr)
 412 {
 413         if (wpa_s->driver->sta_remove)
 414                 return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
 415         return -1;
 416 }
 417
 418 static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
 419                                           const u8 *addr, const u8 *data,
 420                                           size_t data_len, int encrypt,
 421                                           const u8 *own_addr)
 422 {
 423         if (wpa_s->driver->hapd_send_eapol)
 424                 return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
 425                                                       data, data_len, encrypt,
 426                                                       own_addr);
 427         return -1;
 428 }
 429
 430 #endif /* DRIVER_I_H */