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