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, wpa_alg alg,
 107                                    const u8 *addr, int key_idx, int set_tx,
 108                                    const u8 *seq, size_t seq_len,
 109                                    const u8 *key, size_t key_len)
 110 {
 111         if (wpa_s->driver->set_key) {
 112                 wpa_s->keys_cleared = 0;
 113                 return wpa_s->driver->set_key(wpa_s->ifname, wpa_s->drv_priv,
 114                                               alg, addr, key_idx, set_tx,
 115                                               seq, seq_len, key, key_len);
 116         }
 117         return -1;
 118 }
 119
 120 static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
 121                                          const u8 *addr, int reason_code)
 122 {
 123         if (wpa_s->driver->deauthenticate) {
 124                 return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
 125                                                      reason_code);
 126         }
 127         return -1;
 128 }
 129
 130 static inline int wpa_drv_disassociate(struct wpa_supplicant *wpa_s,
 131                                        const u8 *addr, int reason_code)
 132 {
 133         if (wpa_s->driver->disassociate) {
 134                 return wpa_s->driver->disassociate(wpa_s->drv_priv, addr,
 135                                                    reason_code);
 136         }
 137         return -1;
 138 }
 139
 140 static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
 141                                     const u8 *bssid, const u8 *pmkid)
 142 {
 143         if (wpa_s->driver->add_pmkid) {
 144                 return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
 145         }
 146         return -1;
 147 }
 148
 149 static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
 150                                        const u8 *bssid, const u8 *pmkid)
 151 {
 152         if (wpa_s->driver->remove_pmkid) {
 153                 return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
 154                                                    pmkid);
 155         }
 156         return -1;
 157 }
 158
 159 static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
 160 {
 161         if (wpa_s->driver->flush_pmkid) {
 162                 return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
 163         }
 164         return -1;
 165 }
 166
 167 static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
 168                                    struct wpa_driver_capa *capa)
 169 {
 170         if (wpa_s->driver->get_capa) {
 171                 return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
 172         }
 173         return -1;
 174 }
 175
 176 static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
 177 {
 178         if (wpa_s->driver->poll) {
 179                 wpa_s->driver->poll(wpa_s->drv_priv);
 180         }
 181 }
 182
 183 static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
 184 {
 185         if (wpa_s->driver->get_ifname) {
 186                 return wpa_s->driver->get_ifname(wpa_s->drv_priv);
 187         }
 188         return NULL;
 189 }
 190
 191 static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
 192 {
 193         if (wpa_s->driver->get_mac_addr) {
 194                 return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
 195         }
 196         return NULL;
 197 }
 198
 199 static inline int wpa_drv_send_eapol(struct wpa_supplicant *wpa_s,
 200                                      const u8 *dst, u16 proto,
 201                                      const u8 *data, size_t data_len)
 202 {
 203         if (wpa_s->driver->send_eapol)
 204                 return wpa_s->driver->send_eapol(wpa_s->drv_priv, dst, proto,
 205                                                  data, data_len);
 206         return -1;
 207 }
 208
 209 static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
 210                                         int state)
 211 {
 212         if (wpa_s->driver->set_operstate)
 213                 return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
 214         return 0;
 215 }
 216
 217 static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
 218                                              const u8 *addr, int protect_type,
 219                                              int key_type)
 220 {
 221         if (wpa_s->driver->mlme_setprotection)
 222                 return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
 223                                                          protect_type,
 224                                                          key_type);
 225         return 0;
 226 }
 227
 228 static inline struct hostapd_hw_modes *
 229 wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
 230                             u16 *flags)
 231 {
 232         if (wpa_s->driver->get_hw_feature_data)
 233                 return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
 234                                                           num_modes, flags);
 235         return NULL;
 236 }
 237
 238 static inline int wpa_drv_set_channel(struct wpa_supplicant *wpa_s,
 239                                       hostapd_hw_mode phymode, int chan,
 240                                       int freq)
 241 {
 242         if (wpa_s->driver->set_channel)
 243                 return wpa_s->driver->set_channel(wpa_s->drv_priv, phymode,
 244                                                   chan, freq);
 245         return -1;
 246 }
 247
 248 static inline int wpa_drv_set_ssid(struct wpa_supplicant *wpa_s,
 249                                    const u8 *ssid, size_t ssid_len)
 250 {
 251         if (wpa_s->driver->set_ssid) {
 252                 return wpa_s->driver->set_ssid(wpa_s->drv_priv, ssid,
 253                                                ssid_len);
 254         }
 255         return -1;
 256 }
 257
 258 static inline int wpa_drv_set_bssid(struct wpa_supplicant *wpa_s,
 259                                     const u8 *bssid)
 260 {
 261         if (wpa_s->driver->set_bssid) {
 262                 return wpa_s->driver->set_bssid(wpa_s->drv_priv, bssid);
 263         }
 264         return -1;
 265 }
 266
 267 static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
 268                                       const char *alpha2)
 269 {
 270         if (wpa_s->driver->set_country)
 271                 return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
 272         return 0;
 273 }
 274
 275 static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
 276                                     const u8 *data, size_t data_len)
 277 {
 278         if (wpa_s->driver->send_mlme)
 279                 return wpa_s->driver->send_mlme(wpa_s->drv_priv,
 280                                                 data, data_len);
 281         return -1;
 282 }
 283
 284 static inline int wpa_drv_mlme_add_sta(struct wpa_supplicant *wpa_s,
 285                                        const u8 *addr, const u8 *supp_rates,
 286                                        size_t supp_rates_len)
 287 {
 288         if (wpa_s->driver->mlme_add_sta)
 289                 return wpa_s->driver->mlme_add_sta(wpa_s->drv_priv, addr,
 290                                                    supp_rates, supp_rates_len);
 291         return -1;
 292 }
 293
 294 static inline int wpa_drv_mlme_remove_sta(struct wpa_supplicant *wpa_s,
 295                                           const u8 *addr)
 296 {
 297         if (wpa_s->driver->mlme_remove_sta)
 298                 return wpa_s->driver->mlme_remove_sta(wpa_s->drv_priv, addr);
 299         return -1;
 300 }
 301
 302 static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
 303                                         const u8 *md,
 304                                         const u8 *ies, size_t ies_len)
 305 {
 306         if (wpa_s->driver->update_ft_ies)
 307                 return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
 308                                                     ies, ies_len);
 309         return -1;
 310 }
 311
 312 static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s,
 313                                          u8 action, const u8 *target_ap,
 314                                          const u8 *ies, size_t ies_len)
 315 {
 316         if (wpa_s->driver->send_ft_action)
 317                 return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action,
 318                                                      target_ap, ies, ies_len);
 319         return -1;
 320 }
 321
 322 static inline int wpa_drv_set_beacon(struct wpa_supplicant *wpa_s,
 323                                      const u8 *head, size_t head_len,
 324                                      const u8 *tail, size_t tail_len,
 325                                      int dtim_period, int beacon_int)
 326 {
 327         if (wpa_s->driver->set_beacon)
 328                 return wpa_s->driver->set_beacon(wpa_s->ifname,
 329                                                  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->ifname, wpa_s->drv_priv,
 340                                               params);
 341         return -1;
 342 }
 343
 344 static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
 345                                      const u8 *addr)
 346 {
 347         if (wpa_s->driver->sta_remove)
 348                 return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
 349         return -1;
 350 }
 351
 352 static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
 353                                           const u8 *addr, const u8 *data,
 354                                           size_t data_len, int encrypt,
 355                                           const u8 *own_addr)
 356 {
 357         if (wpa_s->driver->hapd_send_eapol)
 358                 return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
 359                                                       data, data_len, encrypt,
 360                                                       own_addr);
 361         return -1;
 362 }
 363
 364 static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
 365                                         const u8 *addr, int total_flags,
 366                                         int flags_or, int flags_and)
 367 {
 368         if (wpa_s->driver->sta_set_flags)
 369                 return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
 370                                                     total_flags, flags_or,
 371                                                     flags_and);
 372         return -1;
 373 }
 374
 375 static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
 376                                         int authorized)
 377 {
 378         if (wpa_s->driver->set_supp_port) {
 379                 return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
 380                                                     authorized);
 381         }
 382         return 0;
 383 }
 384
 385 #endif /* DRIVER_I_H */