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