vcs.maemo.org Git - wpasupplicant/blob - hostapd/driver_i.h

   1 /*
   2  * hostapd - internal driver interface wrappers
   3  * Copyright (c) 2002-2009, Jouni Malinen <j@w1.fi>
   4  * Copyright (c) 2007-2008, Intel Corporation
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 as
   8  * published by the Free Software Foundation.
   9  *
  10  * Alternatively, this software may be distributed under the terms of BSD
  11  * license.
  12  *
  13  * See README and COPYING for more details.
  14  */
  15
  16 #ifndef DRIVER_I_H
  17 #define DRIVER_I_H
  18
  19 #include "drivers/driver.h"
  20 #include "config.h"
  21
  22 static inline void *
  23 hostapd_driver_init(struct hostapd_data *hapd, const u8 *bssid)
  24 {
  25         struct wpa_init_params params;
  26         void *ret;
  27         size_t i;
  28
  29         if (hapd->driver == NULL || hapd->driver->hapd_init == NULL)
  30                 return NULL;
  31
  32         os_memset(&params, 0, sizeof(params));
  33         params.bssid = bssid;
  34         params.ifname = hapd->conf->iface;
  35         params.ssid = (const u8 *) hapd->conf->ssid.ssid;
  36         params.ssid_len = hapd->conf->ssid.ssid_len;
  37         params.test_socket = hapd->conf->test_socket;
  38         params.use_pae_group_addr = hapd->conf->use_pae_group_addr;
  39
  40         params.num_bridge = hapd->iface->num_bss;
  41         params.bridge = os_zalloc(hapd->iface->num_bss * sizeof(char *));
  42         if (params.bridge == NULL)
  43                 return NULL;
  44         for (i = 0; i < hapd->iface->num_bss; i++) {
  45                 struct hostapd_data *bss = hapd->iface->bss[i];
  46                 if (bss->conf->bridge[0])
  47                         params.bridge[i] = bss->conf->bridge;
  48         }
  49
  50         params.own_addr = hapd->own_addr;
  51
  52         ret = hapd->driver->hapd_init(hapd, &params);
  53         os_free(params.bridge);
  54
  55         return ret;
  56 }
  57
  58 static inline void
  59 hostapd_driver_deinit(struct hostapd_data *hapd)
  60 {
  61         if (hapd->driver == NULL || hapd->driver->hapd_deinit == NULL)
  62                 return;
  63         hapd->driver->hapd_deinit(hapd->drv_priv);
  64 }
  65
  66 static inline int
  67 hostapd_set_ieee8021x(const char *ifname, struct hostapd_data *hapd,
  68                       int enabled)
  69 {
  70         if (hapd->driver == NULL || hapd->driver->set_ieee8021x == NULL)
  71                 return 0;
  72         return hapd->driver->set_ieee8021x(ifname, hapd->drv_priv, enabled);
  73 }
  74
  75 static inline int
  76 hostapd_set_privacy(struct hostapd_data *hapd, int enabled)
  77 {
  78         if (hapd->driver == NULL || hapd->driver->set_privacy == NULL)
  79                 return 0;
  80         return hapd->driver->set_privacy(hapd->conf->iface, hapd->drv_priv,
  81                                          enabled);
  82 }
  83
  84 static inline int
  85 hostapd_set_key(const char *ifname, struct hostapd_data *hapd,
  86                 wpa_alg alg, const u8 *addr, int key_idx,
  87                 int set_tx, const u8 *seq, size_t seq_len,
  88                 const u8 *key, size_t key_len)
  89 {
  90         if (hapd->driver == NULL || hapd->driver->hapd_set_key == NULL)
  91                 return 0;
  92         return hapd->driver->hapd_set_key(ifname, hapd->drv_priv, alg, addr,
  93                                           key_idx, set_tx, seq, seq_len, key,
  94                                           key_len);
  95 }
  96
  97 static inline int
  98 hostapd_get_seqnum(const char *ifname, struct hostapd_data *hapd,
  99                    const u8 *addr, int idx, u8 *seq)
 100 {
 101         if (hapd->driver == NULL || hapd->driver->get_seqnum == NULL)
 102                 return 0;
 103         return hapd->driver->get_seqnum(ifname, hapd->drv_priv, addr, idx,
 104                                         seq);
 105 }
 106
 107 static inline int
 108 hostapd_get_seqnum_igtk(const char *ifname, struct hostapd_data *hapd,
 109                         const u8 *addr, int idx, u8 *seq)
 110 {
 111         if (hapd->driver == NULL || hapd->driver->get_seqnum_igtk == NULL)
 112                 return -1;
 113         return hapd->driver->get_seqnum_igtk(ifname, hapd->drv_priv, addr, idx,
 114                                              seq);
 115 }
 116
 117 static inline int
 118 hostapd_flush(struct hostapd_data *hapd)
 119 {
 120         if (hapd->driver == NULL || hapd->driver->flush == NULL)
 121                 return 0;
 122         return hapd->driver->flush(hapd->drv_priv);
 123 }
 124
 125 static inline int
 126 hostapd_set_generic_elem(struct hostapd_data *hapd, const u8 *elem,
 127                          size_t elem_len)
 128 {
 129         if (hapd->driver == NULL || hapd->driver->set_generic_elem == NULL)
 130                 return 0;
 131         return hapd->driver->set_generic_elem(hapd->conf->iface,
 132                                               hapd->drv_priv, elem, elem_len);
 133 }
 134
 135 static inline int
 136 hostapd_read_sta_data(struct hostapd_data *hapd,
 137                       struct hostap_sta_driver_data *data, const u8 *addr)
 138 {
 139         if (hapd->driver == NULL || hapd->driver->read_sta_data == NULL)
 140                 return -1;
 141         return hapd->driver->read_sta_data(hapd->drv_priv, data, addr);
 142 }
 143
 144 static inline int
 145 hostapd_send_eapol(struct hostapd_data *hapd, const u8 *addr, const u8 *data,
 146                    size_t data_len, int encrypt)
 147 {
 148         if (hapd->driver == NULL || hapd->driver->hapd_send_eapol == NULL)
 149                 return 0;
 150         return hapd->driver->hapd_send_eapol(hapd->drv_priv, addr, data,
 151                                              data_len, encrypt,
 152                                              hapd->own_addr);
 153 }
 154
 155 static inline int
 156 hostapd_sta_deauth(struct hostapd_data *hapd, const u8 *addr, int reason)
 157 {
 158         if (hapd->driver == NULL || hapd->driver->sta_deauth == NULL)
 159                 return 0;
 160         return hapd->driver->sta_deauth(hapd->drv_priv, hapd->own_addr, addr,
 161                                         reason);
 162 }
 163
 164 static inline int
 165 hostapd_sta_disassoc(struct hostapd_data *hapd, const u8 *addr, int reason)
 166 {
 167         if (hapd->driver == NULL || hapd->driver->sta_disassoc == NULL)
 168                 return 0;
 169         return hapd->driver->sta_disassoc(hapd->drv_priv, hapd->own_addr, addr,
 170                                           reason);
 171 }
 172
 173 static inline int
 174 hostapd_sta_remove(struct hostapd_data *hapd, const u8 *addr)
 175 {
 176         if (hapd->driver == NULL || hapd->driver->sta_remove == NULL)
 177                 return 0;
 178         return hapd->driver->sta_remove(hapd->drv_priv, addr);
 179 }
 180
 181 static inline int
 182 hostapd_get_ssid(struct hostapd_data *hapd, u8 *buf, size_t len)
 183 {
 184         if (hapd->driver == NULL || hapd->driver->hapd_get_ssid == NULL)
 185                 return 0;
 186         return hapd->driver->hapd_get_ssid(hapd->conf->iface, hapd->drv_priv,
 187                                            buf, len);
 188 }
 189
 190 static inline int
 191 hostapd_set_ssid(struct hostapd_data *hapd, const u8 *buf, size_t len)
 192 {
 193         if (hapd->driver == NULL || hapd->driver->hapd_set_ssid == NULL)
 194                 return 0;
 195         return hapd->driver->hapd_set_ssid(hapd->conf->iface, hapd->drv_priv,
 196                                            buf, len);
 197 }
 198
 199 static inline int
 200 hostapd_send_mgmt_frame(struct hostapd_data *hapd, const void *msg, size_t len)
 201 {
 202         if (hapd->driver == NULL || hapd->driver->send_mlme == NULL)
 203                 return 0;
 204         return hapd->driver->send_mlme(hapd->drv_priv, msg, len);
 205 }
 206
 207 static inline int
 208 hostapd_set_countermeasures(struct hostapd_data *hapd, int enabled)
 209 {
 210         if (hapd->driver == NULL ||
 211             hapd->driver->hapd_set_countermeasures == NULL)
 212                 return 0;
 213         return hapd->driver->hapd_set_countermeasures(hapd->drv_priv, enabled);
 214 }
 215
 216 static inline int
 217 hostapd_sta_add(const char *ifname, struct hostapd_data *hapd, const u8 *addr,
 218                 u16 aid, u16 capability, const u8 *supp_rates,
 219                 size_t supp_rates_len, int flags, u16 listen_interval,
 220                 const struct ht_cap_ie *ht_capabilities)
 221 {
 222         struct hostapd_sta_add_params params;
 223
 224         if (hapd->driver == NULL)
 225                 return 0;
 226         if (hapd->driver->sta_add == NULL)
 227                 return 0;
 228
 229         os_memset(&params, 0, sizeof(params));
 230         params.addr = addr;
 231         params.aid = aid;
 232         params.capability = capability;
 233         params.supp_rates = supp_rates;
 234         params.supp_rates_len = supp_rates_len;
 235         params.flags = flags;
 236         params.listen_interval = listen_interval;
 237         params.ht_capabilities = ht_capabilities;
 238         return hapd->driver->sta_add(ifname, hapd->drv_priv, &params);
 239 }
 240
 241 static inline int
 242 hostapd_get_inact_sec(struct hostapd_data *hapd, const u8 *addr)
 243 {
 244         if (hapd->driver == NULL || hapd->driver->get_inact_sec == NULL)
 245                 return 0;
 246         return hapd->driver->get_inact_sec(hapd->drv_priv, addr);
 247 }
 248
 249 static inline int
 250 hostapd_set_freq(struct hostapd_data *hapd, int mode, int freq, int channel,
 251                  int ht_enabled, int sec_channel_offset)
 252 {
 253         struct hostapd_freq_params data;
 254         if (hapd->driver == NULL)
 255                 return 0;
 256         if (hapd->driver->set_freq == NULL)
 257                 return 0;
 258         os_memset(&data, 0, sizeof(data));
 259         data.mode = mode;
 260         data.freq = freq;
 261         data.channel = channel;
 262         data.ht_enabled = ht_enabled;
 263         data.sec_channel_offset = sec_channel_offset;
 264         return hapd->driver->set_freq(hapd->drv_priv, &data);
 265 }
 266
 267 static inline int
 268 hostapd_set_rts(struct hostapd_data *hapd, int rts)
 269 {
 270         if (hapd->driver == NULL || hapd->driver->set_rts == NULL)
 271                 return 0;
 272         return hapd->driver->set_rts(hapd->drv_priv, rts);
 273 }
 274
 275 static inline int
 276 hostapd_set_frag(struct hostapd_data *hapd, int frag)
 277 {
 278         if (hapd->driver == NULL || hapd->driver->set_frag == NULL)
 279                 return 0;
 280         return hapd->driver->set_frag(hapd->drv_priv, frag);
 281 }
 282
 283 static inline int
 284 hostapd_sta_set_flags(struct hostapd_data *hapd, u8 *addr,
 285                       int total_flags, int flags_or, int flags_and)
 286 {
 287         if (hapd->driver == NULL || hapd->driver->sta_set_flags == NULL)
 288                 return 0;
 289         return hapd->driver->sta_set_flags(hapd->drv_priv, addr, total_flags,
 290                                            flags_or, flags_and);
 291 }
 292
 293 static inline int
 294 hostapd_set_rate_sets(struct hostapd_data *hapd, int *supp_rates,
 295                       int *basic_rates, int mode)
 296 {
 297         if (hapd->driver == NULL || hapd->driver->set_rate_sets == NULL)
 298                 return 0;
 299         return hapd->driver->set_rate_sets(hapd->drv_priv, supp_rates,
 300                                            basic_rates, mode);
 301 }
 302
 303 static inline int
 304 hostapd_set_country(struct hostapd_data *hapd, const char *country)
 305 {
 306         if (hapd->driver == NULL ||
 307             hapd->driver->set_country == NULL)
 308                 return 0;
 309         return hapd->driver->set_country(hapd->drv_priv, country);
 310 }
 311
 312 static inline int
 313 hostapd_sta_clear_stats(struct hostapd_data *hapd, const u8 *addr)
 314 {
 315         if (hapd->driver == NULL || hapd->driver->sta_clear_stats == NULL)
 316                 return 0;
 317         return hapd->driver->sta_clear_stats(hapd->drv_priv, addr);
 318 }
 319
 320 static inline int
 321 hostapd_set_beacon(const char *ifname, struct hostapd_data *hapd,
 322                    const u8 *head, size_t head_len,
 323                    const u8 *tail, size_t tail_len, int dtim_period)
 324 {
 325         if (hapd->driver == NULL || hapd->driver->hapd_set_beacon == NULL)
 326                 return 0;
 327         return hapd->driver->hapd_set_beacon(ifname, hapd->drv_priv,
 328                                              head, head_len,
 329                                              tail, tail_len, dtim_period);
 330 }
 331
 332 static inline int
 333 hostapd_set_internal_bridge(struct hostapd_data *hapd, int value)
 334 {
 335         if (hapd->driver == NULL || hapd->driver->set_internal_bridge == NULL)
 336                 return 0;
 337         return hapd->driver->set_internal_bridge(hapd->drv_priv, value);
 338 }
 339
 340 static inline int
 341 hostapd_set_beacon_int(struct hostapd_data *hapd, int value)
 342 {
 343         if (hapd->driver == NULL || hapd->driver->set_beacon_int == NULL)
 344                 return 0;
 345         return hapd->driver->set_beacon_int(hapd->drv_priv, value);
 346 }
 347
 348 static inline int
 349 hostapd_set_cts_protect(struct hostapd_data *hapd, int value)
 350 {
 351         if (hapd->driver == NULL || hapd->driver->set_cts_protect == NULL)
 352                 return 0;
 353         return hapd->driver->set_cts_protect(hapd->drv_priv, value);
 354 }
 355
 356 static inline int
 357 hostapd_set_preamble(struct hostapd_data *hapd, int value)
 358 {
 359         if (hapd->driver == NULL || hapd->driver->set_preamble == NULL)
 360                 return 0;
 361         return hapd->driver->set_preamble(hapd->drv_priv, value);
 362 }
 363
 364 static inline int
 365 hostapd_set_short_slot_time(struct hostapd_data *hapd, int value)
 366 {
 367         if (hapd->driver == NULL || hapd->driver->set_short_slot_time == NULL)
 368                 return 0;
 369         return hapd->driver->set_short_slot_time(hapd->drv_priv, value);
 370 }
 371
 372 static inline int
 373 hostapd_set_tx_queue_params(struct hostapd_data *hapd, int queue, int aifs,
 374                             int cw_min, int cw_max, int burst_time)
 375 {
 376         if (hapd->driver == NULL || hapd->driver->set_tx_queue_params == NULL)
 377                 return 0;
 378         return hapd->driver->set_tx_queue_params(hapd->drv_priv, queue, aifs,
 379                                                  cw_min, cw_max, burst_time);
 380 }
 381
 382 static inline int
 383 hostapd_bss_add(struct hostapd_data *hapd, const char *ifname, const u8 *bssid)
 384 {
 385         if (hapd->driver == NULL || hapd->driver->bss_add == NULL)
 386                 return 0;
 387         return hapd->driver->bss_add(hapd->drv_priv, ifname, bssid);
 388 }
 389
 390 static inline int
 391 hostapd_bss_remove(struct hostapd_data *hapd, const char *ifname)
 392 {
 393         if (hapd->driver == NULL || hapd->driver->bss_remove == NULL)
 394                 return 0;
 395         return hapd->driver->bss_remove(hapd->drv_priv, ifname);
 396 }
 397
 398 static inline int
 399 hostapd_valid_bss_mask(struct hostapd_data *hapd, const u8 *addr,
 400                        const u8 *mask)
 401 {
 402         if (hapd->driver == NULL || hapd->driver->valid_bss_mask == NULL)
 403                 return 1;
 404         return hapd->driver->valid_bss_mask(hapd->drv_priv, addr, mask);
 405 }
 406
 407 static inline int
 408 hostapd_if_add(struct hostapd_data *hapd, enum hostapd_driver_if_type type,
 409                char *ifname, const u8 *addr)
 410 {
 411         if (hapd->driver == NULL || hapd->driver->if_add == NULL)
 412                 return -1;
 413         return hapd->driver->if_add(hapd->conf->iface, hapd->drv_priv, type,
 414                                     ifname, addr);
 415 }
 416
 417 static inline int
 418 hostapd_if_update(struct hostapd_data *hapd, enum hostapd_driver_if_type type,
 419                   char *ifname, const u8 *addr)
 420 {
 421         if (hapd->driver == NULL || hapd->driver->if_update == NULL)
 422                 return -1;
 423         return hapd->driver->if_update(hapd->drv_priv, type, ifname, addr);
 424 }
 425
 426 static inline int
 427 hostapd_if_remove(struct hostapd_data *hapd, enum hostapd_driver_if_type type,
 428                   char *ifname, const u8 *addr)
 429 {
 430         if (hapd->driver == NULL || hapd->driver->if_remove == NULL)
 431                 return -1;
 432         return hapd->driver->if_remove(hapd->drv_priv, type, ifname, addr);
 433 }
 434
 435 static inline struct hostapd_hw_modes *
 436 hostapd_get_hw_feature_data(struct hostapd_data *hapd, u16 *num_modes,
 437                             u16 *flags)
 438 {
 439         if (hapd->driver == NULL ||
 440             hapd->driver->get_hw_feature_data == NULL)
 441                 return NULL;
 442         return hapd->driver->get_hw_feature_data(hapd->drv_priv, num_modes,
 443                                                  flags);
 444 }
 445
 446 static inline int
 447 hostapd_set_sta_vlan(const char *ifname, struct hostapd_data *hapd,
 448                      const u8 *addr, int vlan_id)
 449 {
 450         if (hapd->driver == NULL || hapd->driver->set_sta_vlan == NULL)
 451                 return 0;
 452         return hapd->driver->set_sta_vlan(hapd->drv_priv, addr, ifname, vlan_id);
 453 }
 454
 455 static inline int
 456 hostapd_driver_commit(struct hostapd_data *hapd)
 457 {
 458         if (hapd->driver == NULL || hapd->driver->commit == NULL)
 459                 return 0;
 460         return hapd->driver->commit(hapd->drv_priv);
 461 }
 462
 463 static inline int
 464 hostapd_set_radius_acl_auth(struct hostapd_data *hapd, const u8 *mac,
 465                             int accepted, u32 session_timeout)
 466 {
 467         if (hapd->driver == NULL || hapd->driver->set_radius_acl_auth == NULL)
 468                 return 0;
 469         return hapd->driver->set_radius_acl_auth(hapd->drv_priv, mac, accepted,
 470                                                  session_timeout);
 471 }
 472
 473 static inline int
 474 hostapd_set_radius_acl_expire(struct hostapd_data *hapd, const u8 *mac)
 475 {
 476         if (hapd->driver == NULL ||
 477             hapd->driver->set_radius_acl_expire == NULL)
 478                 return 0;
 479         return hapd->driver->set_radius_acl_expire(hapd->drv_priv, mac);
 480 }
 481
 482 #ifdef CONFIG_IEEE80211N
 483 static inline int
 484 hostapd_set_ht_params(const char *ifname, struct hostapd_data *hapd,
 485                       const u8 *ht_capab, size_t ht_capab_len,
 486                       const u8 *ht_oper, size_t ht_oper_len)
 487 {
 488         if (hapd->driver == NULL || hapd->driver->set_ht_params == NULL ||
 489             ht_capab == NULL || ht_oper == NULL)
 490                 return 0;
 491         return hapd->driver->set_ht_params(
 492                 ifname, hapd->drv_priv, ht_capab, ht_capab_len,
 493                 ht_oper, ht_oper_len);
 494 }
 495 #endif /* CONFIG_IEEE80211N */
 496
 497 static inline int
 498 hostapd_drv_none(struct hostapd_data *hapd)
 499 {
 500         return hapd->driver && os_strcmp(hapd->driver->name, "none") == 0;
 501 }
 502
 503 static inline int
 504 hostapd_set_wps_beacon_ie(struct hostapd_data *hapd, const u8 *ie, size_t len)
 505 {
 506         if (hapd->driver == NULL || hapd->driver->set_wps_beacon_ie == NULL)
 507                 return 0;
 508         return hapd->driver->set_wps_beacon_ie(hapd->conf->iface,
 509                                                hapd->drv_priv, ie, len);
 510 }
 511
 512 static inline int
 513 hostapd_set_wps_probe_resp_ie(struct hostapd_data *hapd, const u8 *ie,
 514                               size_t len)
 515 {
 516         if (hapd->driver == NULL ||
 517             hapd->driver->set_wps_probe_resp_ie == NULL)
 518                 return 0;
 519         return hapd->driver->set_wps_probe_resp_ie(hapd->conf->iface,
 520                                                    hapd->drv_priv, ie, len);
 521 }
 522
 523 static inline int hostapd_driver_set_mode(struct hostapd_data *hapd, int mode)
 524 {
 525         if (hapd->driver == NULL || hapd->driver->set_mode == NULL)
 526                 return 0;
 527         return hapd->driver->set_mode(hapd->drv_priv, mode);
 528 }
 529
 530 static inline int hostapd_driver_scan(struct hostapd_data *hapd,
 531                                       struct wpa_driver_scan_params *params)
 532 {
 533         if (hapd->driver && hapd->driver->scan2)
 534                 return hapd->driver->scan2(hapd->drv_priv, params);
 535         return -1;
 536 }
 537
 538 static inline struct wpa_scan_results * hostapd_driver_get_scan_results(
 539         struct hostapd_data *hapd)
 540 {
 541         if (hapd->driver && hapd->driver->get_scan_results2)
 542                 return hapd->driver->get_scan_results2(hapd->drv_priv);
 543         return NULL;
 544 }
 545
 546 #endif /* DRIVER_I_H */