00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00017
00018
00019 #include <sys/ioctl.h>
00020 #include <sys/stat.h>
00021 #include <linux/if_tun.h>
00022 #include <errno.h>
00023 #include <fcntl.h>
00024 #include <stdio.h>
00025 #include <stdlib.h>
00026 #include <string.h>
00027 #include <unistd.h>
00028 #include "iw_compat.h"
00029 #include "vif.h"
00030
00031
00032
00033
00034
00035 extern int vif_config_load(void);
00036 extern int vif_config_create(void);
00037 extern int vif_config_list(int, char[MAX_NUM_VIF][IFNAMSIZ + 1]);
00038 extern vif_info *vif_config_vif_info(int, const char *);
00039 extern int vif_config_add(int, const char *);
00040 extern int vif_config_delete(int, const char *);
00041 extern void vif_config_print(int);
00042
00043
00044 extern int vif_notify_ioctl(int, const char *);
00045
00046
00047
00048
00050 int vif_list_id = -1;
00051
00052
00053
00054
00056 int
00057 ignore_debug(const char* text, ...)
00058 {
00059 return 0;
00060 }
00061
00064 int (*vif_debug)(const char *format, ...) = &ignore_debug;
00065
00068 int (*vif_error)(const char *format, ...) = &printf;
00069
00070
00071
00072
00078 int
00079 tun_create(const char* dev_name)
00080 {
00081 struct ifreq ifr;
00082 int tap_fd = -1;
00083 int rtrn = -1;
00084 char *file = "/dev/net/tun";
00085 uid_t owner = geteuid();
00086 gid_t group = getegid();
00087
00088 if ((tap_fd = open(file, O_RDWR)) < 0)
00089 {
00090 vif_error("Failed to open %s (%s)\n", file, strerror(errno));
00091 vif_error("Is 'tun' kernel module loaded?\n");
00092 return -1;
00093 }
00094
00095 memset(&ifr, 0, sizeof(ifr));
00096 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
00097 strncpy(ifr.ifr_name, dev_name, sizeof(ifr.ifr_name) - 1);
00098
00099 if ((rtrn = ioctl(tap_fd, TUNSETIFF, (void *) &ifr)) < 0)
00100 {
00101 switch (errno)
00102 {
00103 case EPERM:
00104 vif_error("No permission to create TUN interface\n");
00105 break;
00106 case EINVAL:
00107 vif_error("Invalid device name %s\n", dev_name);
00108 break;
00109 default:
00110 vif_error("tun_create(): TUNSETIFF");
00111 break;
00112 }
00113 goto finish;
00114 }
00115 if ((rtrn = ioctl(tap_fd, TUNSETOWNER, owner)) < 0)
00116 {
00117 vif_error("tun_create(): TUNSETOWNER");
00118 goto finish;
00119 }
00120 if ((rtrn = ioctl(tap_fd, TUNSETGROUP, group)) < 0)
00121 {
00122 vif_error("tun_create(): TUNSETGROUP");
00123 goto finish;
00124 }
00125 if ((rtrn = ioctl(tap_fd, TUNSETPERSIST, 1)) < 0)
00126 {
00127 vif_error("tun_create(): enabling TUNSETPERSIST");
00128 goto finish;
00129 }
00130
00131 finish:
00132 close(tap_fd);
00133 return rtrn;
00134 }
00135
00137 int
00138 tun_remove(const char* dev_name)
00139 {
00140 struct ifreq ifr;
00141 int tap_fd = -1;
00142 int rtrn = -1;
00143 char *file = "/dev/net/tun";
00144
00145 if ((tap_fd = open(file, O_RDWR)) < 0)
00146 return -1;
00147
00148 memset(&ifr, 0, sizeof(ifr));
00149 ifr.ifr_flags = IFF_TAP | IFF_NO_PI;
00150 strncpy(ifr.ifr_name, dev_name, sizeof(ifr.ifr_name) - 1);
00151
00152 if ((rtrn = ioctl(tap_fd, TUNSETIFF, (void *) &ifr)) == 0)
00153 {
00154 if ((rtrn = ioctl(tap_fd, TUNSETPERSIST, 0)) < 0)
00155 {
00156 vif_error("Warning: Couldn't remove %s (%s)",
00157 dev_name, strerror(errno));
00158 vif_error("Notice: Manually delete device with `tunctl -d %s`\n",
00159 dev_name);
00160 }
00161 }
00162
00163 close(tap_fd);
00164 return rtrn;
00165 }
00166
00167
00168
00169
00171 wireless_info *
00172 get_wireless_info(const char *dev_name)
00173 {
00174 vif_info *vif_entry = vif_config_vif_info(vif_list_id, dev_name);
00175
00176
00177
00178 return &vif_entry->vif_wlaninfo;
00179 }
00180
00181
00182
00183
00184 int
00185 vif_siocsifhwaddr(const char *dev_name)
00186 {
00187 int skfd = -1;
00188 struct ifreq ifr;
00189 vif_info *vif_entry = NULL;
00190
00191 if ((skfd = socket(PF_INET, SOCK_DGRAM, 0)) == -1)
00192 {
00193 vif_error("Cannot open socket (%s)", strerror(errno));
00194 return -1;
00195 }
00196 strncpy(ifr.ifr_name, dev_name, IFNAMSIZ);
00197 if (ioctl(skfd, SIOCGIFHWADDR, &ifr) != 0)
00198 {
00199 vif_error("Failed to get MAC address of %s (%s)\n",
00200 dev_name, strerror(errno));
00201 close(skfd);
00202 return -1;
00203 }
00204 close(skfd);
00205
00206 if ((vif_entry = vif_config_vif_info(vif_list_id, dev_name)) == NULL)
00207 return -1;
00208 memmove(vif_entry->vif_mac, ifr.ifr_hwaddr.sa_data, ETH_ALEN);
00209
00210 return 0;
00211 }
00212
00213 int
00214 vif_siocgiwname(struct iwreq *request)
00215 {
00216 struct wireless_info *vif_config =
00217 get_wireless_info(request->ifr_ifrn.ifrn_name);
00218 if (vif_config == NULL)
00219 return IWERR_GET_EXT;
00220
00221 memmove(request->u.name, vif_config->b.name, IFNAMSIZ);
00222
00223 vif_debug("SIGCGIWNAME : %s\n", request->u.name);
00224 return 0;
00225 }
00226
00227 int
00228 vif_siocgiwnid(struct iwreq *request)
00229 {
00230 struct wireless_info *vif_config =
00231 get_wireless_info(request->ifr_ifrn.ifrn_name);
00232 if (vif_config == NULL)
00233 return IWERR_GET_EXT;
00234
00235 if (vif_config->b.has_nwid == 0)
00236 {
00237 vif_debug("SIOCGIWNWID : off\n");
00238 return IWERR_GET_EXT;
00239 }
00240 memmove(&(request->u.nwid), &vif_config->b.nwid, sizeof(struct iw_param));
00241 vif_config->b.has_nwid = iw_get_param_state(&(vif_config->b.nwid));
00242
00243 vif_debug("SIOCGIWNWID : %c\n", request->u.nwid.value);
00244 return 0;
00245 }
00246
00248 int
00249 vif_siocsiwfreq(struct iwreq *request)
00250 {
00251 struct wireless_info *vif_config =
00252 get_wireless_info(request->ifr_ifrn.ifrn_name);
00253 if (vif_config == NULL)
00254 return IWERR_SET_EXT;
00255
00256 vif_config->b.freq_flags = request->u.freq.flags;
00257 if (vif_config->b.freq_flags == IW_FREQ_AUTO)
00258 {
00259 vif_config->b.has_freq = 0;
00260 vif_config->b.freq = channel_frequency[0] * MEGA;
00261 } else {
00262 vif_config->b.has_freq = 1;
00263 float freq = iw_freq2float(&(request->u.freq));
00264
00265
00266 if (freq < MEGA)
00267 {
00268 int channel = (int) freq;
00269 if (channel > vif_config->range.num_channels - 1)
00270 return IWERR_ARG_SIZE;
00271 vif_config->b.freq = channel_frequency[channel] * MEGA;
00272 } else {
00273 vif_config->b.freq = freq;
00274 }
00275 }
00276
00277 if (vif_config->b.freq > 1000)
00278 {
00279 vif_debug("SIOCSIWFREQ : %.3e GHz\n", vif_config->b.freq / GIGA);
00280 } else {
00281 vif_debug("SIOCSIWFREQ : Channel %.0f\n", vif_config->b.freq);
00282 }
00283 return 0;
00284 }
00285
00286 int
00287 vif_siocgiwfreq(struct iwreq *request)
00288 {
00289 struct wireless_info *vif_config =
00290 get_wireless_info(request->ifr_ifrn.ifrn_name);
00291 if (vif_config == NULL)
00292 return IWERR_GET_EXT;
00293
00294 iw_float2freq(vif_config->b.freq, &(request->u.freq));
00295
00296 if (vif_config->b.freq > 1000)
00297 {
00298 vif_debug("SIOCGIWFREQ : %.3e GHz\n", vif_config->b.freq / GIGA);
00299 } else {
00300 vif_debug("SIOCGIWFREQ : Channel %.0f\n", vif_config->b.freq);
00301 }
00302 return 0;
00303 }
00304
00305 int
00306 vif_siocsiwmode(struct iwreq *request)
00307 {
00308 struct wireless_info *vif_config =
00309 get_wireless_info(request->ifr_ifrn.ifrn_name);
00310 if (vif_config == NULL)
00311 return IWERR_SET_EXT;
00312
00313 vif_config->b.has_mode = 1;
00314 vif_config->b.mode = request->u.mode;
00315
00316 vif_debug("SIOCSIWMODE : %i\n", vif_config->b.mode);
00317 return 0;
00318 }
00319
00320 int
00321 vif_siocgiwmode(struct iwreq *request)
00322 {
00323 struct wireless_info *vif_config =
00324 get_wireless_info(request->ifr_ifrn.ifrn_name);
00325 if (vif_config == NULL)
00326 return IWERR_GET_EXT;
00327
00328 if (vif_config->b.has_mode == 1)
00329 {
00330 request->u.mode = vif_config->b.mode;
00331 } else {
00332 request->u.mode = IW_MODE_AUTO;
00333 }
00334
00335 vif_debug("SIOCGIWMODE : %i\n", request->u.mode);
00336 return 0;
00337 }
00338
00339 int
00340 vif_siocsiwsens(struct iwreq *request)
00341 {
00342 struct wireless_info *vif_config =
00343 get_wireless_info(request->ifr_ifrn.ifrn_name);
00344 if (vif_config == NULL)
00345 return IWERR_SET_EXT;
00346
00347 memmove(&(vif_config->sens), &(request->u.sens), sizeof(struct iw_param));
00348 vif_config->has_sens = iw_get_param_state(&(vif_config->sens));
00349
00350 if (vif_config->sens.value < 0)
00351 vif_debug("SIOCSIWSENS : %i dB\n", vif_config->sens.value);
00352 else
00353 vif_debug("SIOCSIWSENS : %i\n", vif_config->sens.value);
00354 return 0;
00355 }
00356
00357 int
00358 vif_siocgiwsens(struct iwreq *request)
00359 {
00360 struct wireless_info *vif_config =
00361 get_wireless_info(request->ifr_ifrn.ifrn_name);
00362 if (vif_config == NULL)
00363 return IWERR_GET_EXT;
00364
00365 memmove(&(request->u.sens), &(vif_config->sens), sizeof(struct iw_param));
00366
00367 if (vif_config->sens.value < 0)
00368 vif_debug("SIOCGIWSENS : %i dB\n", vif_config->sens.value);
00369 else
00370 vif_debug("SIOCGIWSENS : %i\n", vif_config->sens.value);
00371 return 0;
00372 }
00373
00374 int
00375 vif_siocgiwrange(struct iwreq *request)
00376 {
00377
00378 struct wireless_info *vif_config =
00379 get_wireless_info(request->ifr_ifrn.ifrn_name);
00380 if (vif_config == NULL)
00381 return IWERR_GET_EXT;
00382
00383 memmove(request->u.data.pointer, &(vif_config->range), sizeof(struct iw_range));
00384 request->u.data.length = sizeof(struct iw_range);
00385
00386 vif_debug("SIOCGIWRANGE : we_version_compiled = %i\n",
00387 ((struct iw_range *) request->u.data.pointer)->we_version_compiled);
00388 return 0;
00389 }
00390
00391 int
00392 vif_siocgiwpriv(struct iwreq *request)
00393 {
00394 int i = -1;
00395 struct iw_priv_args *priv = request->u.data.pointer;
00396
00397 if (VIF_IW_NUM_IOCTL_PRIV > request->u.data.length)
00398 {
00399
00400 request->u.data.length = VIF_IW_NUM_IOCTL_PRIV;
00401 return IWERR_ARG_SIZE;
00402 }
00403
00404 for (i = 0; i < VIF_IW_NUM_IOCTL_PRIV; i++)
00405 memmove(&priv[i], &vif_private_args[i], sizeof(struct iw_priv_args));
00406 request->u.data.length = VIF_IW_NUM_IOCTL_PRIV;
00407
00408 vif_debug("SIOCGIWPRIV : %i ioctls:\n", VIF_IW_NUM_IOCTL_PRIV);
00409 for (i = 0; i < VIF_IW_NUM_IOCTL_PRIV; i++)
00410 {
00411 vif_debug(" (%p) cmd: %.4X\n", &(priv[i].cmd), priv[i].cmd);
00412 vif_debug(" (%p) name: %s\n", priv[i].name, priv[i].name);
00413 }
00414 return 0;
00415 }
00416
00417 int
00418 vif_siocgiwap(struct iwreq *request)
00419 {
00420 char buffer[sizeof(struct sockaddr)];
00421 struct wireless_info *vif_config =
00422 get_wireless_info(request->ifr_ifrn.ifrn_name);
00423 if (vif_config == NULL)
00424 return IWERR_GET_EXT;
00425
00426 memmove(&(request->u.ap_addr.sa_data), &(vif_config->ap_addr.sa_data),
00427 ETH_ALEN);
00428
00429 vif_debug("SIGCGIWAP : %s\n", iw_sawap_ntop(&(request->u.ap_addr), buffer));
00430 return 0;
00431 }
00432
00433 int
00434 vif_siocsiwessid(struct iwreq *request)
00435 {
00436
00437 struct wireless_info *vif_config =
00438 get_wireless_info(request->ifr_ifrn.ifrn_name);
00439 if (vif_config == NULL)
00440 return IWERR_SET_EXT;
00441
00442 memset(vif_config->b.essid, 0, IW_ESSID_MAX_SIZE + 1);
00443 strncpy(vif_config->b.essid, request->u.essid.pointer, request->u.essid.length);
00444 vif_config->b.essid_on = request->u.essid.flags;
00445 vif_config->b.has_essid = request->u.essid.flags;
00446
00447 vif_debug("SIOCSIWESSID : \"%s\"\n", (char *) vif_config->b.essid);
00448 return 0;
00449 }
00450
00451 int
00452 vif_siocgiwessid(struct iwreq *request)
00453 {
00454
00455 struct wireless_info *vif_config =
00456 get_wireless_info(request->ifr_ifrn.ifrn_name);
00457 if (vif_config == NULL)
00458 return IWERR_GET_EXT;
00459
00460 strncpy(request->u.essid.pointer, vif_config->b.essid, IW_ESSID_MAX_SIZE + 1);
00461 request->u.essid.length = strlen(vif_config->b.essid) + 1;
00462 request->u.essid.flags = vif_config->b.essid_on;
00463
00464 vif_debug("SIOCGIWESSID : \"%s\", u.data.length = %i\n",
00465 request->u.essid.pointer, request->u.essid.length);
00466 return 0;
00467 }
00468
00469 int
00470 vif_siocgiwnickn(struct iwreq *request)
00471 {
00472 struct wireless_info *vif_config =
00473 get_wireless_info(request->ifr_ifrn.ifrn_name);
00474 if (vif_config == NULL)
00475 return IWERR_GET_EXT;
00476
00477
00478 strncpy(request->u.data.pointer, vif_config->nickname, IW_ESSID_MAX_SIZE + 1);
00479 request->u.data.length = strlen(vif_config->nickname) + 1;
00480
00481 vif_debug("SIOCGIWNICKN : \"%s\"\n", request->u.data.pointer);
00482 return 0;
00483 }
00484
00485 int
00486 vif_siocsiwrate(struct iwreq *request)
00487 {
00488 struct wireless_info *vif_config =
00489 get_wireless_info(request->ifr_ifrn.ifrn_name);
00490 if (vif_config == NULL)
00491 return IWERR_SET_EXT;
00492
00493 memmove(&(vif_config->bitrate), &(request->u.bitrate),
00494 sizeof(struct iw_param));
00495 vif_config->has_bitrate = iw_get_param_state(&(vif_config->bitrate));
00496
00497 vif_debug("SIOCSIWRATE : %.1f Mbit/s\n", vif_config->bitrate.value / MEGA);
00498 return 0;
00499 }
00500
00501 int
00502 vif_siocgiwrate(struct iwreq *request)
00503 {
00504 struct wireless_info *vif_config =
00505 get_wireless_info(request->ifr_ifrn.ifrn_name);
00506 if (vif_config == NULL)
00507 return IWERR_GET_EXT;
00508
00509 memmove(&(request->u.bitrate), &(vif_config->bitrate),
00510 sizeof(struct iw_param));
00511
00512 vif_debug("SIOCGIWRATE : %.1f Mbit/s\n", request->u.bitrate.value / MEGA);
00513 return 0;
00514 }
00515
00516 int
00517 vif_siocsiwrts(struct iwreq *request)
00518 {
00519 struct wireless_info *vif_config =
00520 get_wireless_info(request->ifr_ifrn.ifrn_name);
00521 if (vif_config == NULL)
00522 return IWERR_SET_EXT;
00523
00524 if (request->u.rts.value > VIF_MAX_RTS)
00525 return IWERR_ARG_SIZE;
00526 if (request->u.rts.value < 0)
00527 return IWERR_ARG_SIZE;
00528
00529 memmove(&(vif_config->rts), &(request->u.rts), sizeof(struct iw_param));
00530 vif_config->has_rts = iw_get_param_state(&(vif_config->rts));
00531
00532 if (vif_config->has_rts == 1)
00533 vif_debug("SIOCSIWRTS : %i Bytes\n", request->u.rts.value);
00534 else
00535 vif_debug("SIOCSIWRTS : off\n");
00536 return 0;
00537 }
00538
00539 int
00540 vif_siocgiwrts(struct iwreq *request)
00541 {
00542 struct wireless_info *vif_config =
00543 get_wireless_info(request->ifr_ifrn.ifrn_name);
00544 if (vif_config == NULL)
00545 return IWERR_GET_EXT;
00546
00547 memmove(&(request->u.rts), &(vif_config->rts), sizeof(struct iw_param));
00548
00549 if (vif_config->has_rts == 1)
00550 {
00551 vif_debug("SIOCGIWRTS : %i Bytes\n", request->u.rts.value);
00552 } else {
00553 vif_debug("SIOCGIWRTS : off\n");
00554 }
00555 return 0;
00556 }
00557
00558 int
00559 vif_siocsiwfrag(struct iwreq *request)
00560 {
00561 struct wireless_info *vif_config =
00562 get_wireless_info(request->ifr_ifrn.ifrn_name);
00563 if (vif_config == NULL)
00564 return IWERR_SET_EXT;
00565
00566
00567
00568
00569
00570
00571
00572
00573
00574 if (request->u.frag.value < 256 && request->u.frag.value > -1)
00575 return IWERR_ARG_SIZE;
00576 if (request->u.frag.value > 2346)
00577 return IWERR_ARG_SIZE;
00578
00579 memmove(&(vif_config->frag), &(request->u.frag), sizeof(struct iw_param));
00580 vif_config->has_frag = iw_get_param_state(&(vif_config->frag));
00581
00582 if (vif_config->has_frag == 1)
00583 {
00584 vif_debug("SIOCSIWFRAG : %i Bytes\n", request->u.frag.value);
00585 } else {
00586 vif_debug("SIOCSIWFRAG : off\n");
00587 }
00588 return 0;
00589 }
00590
00591 int
00592 vif_siocgiwfrag(struct iwreq *request)
00593 {
00594 struct wireless_info *vif_config =
00595 get_wireless_info(request->ifr_ifrn.ifrn_name);
00596 if (vif_config == NULL)
00597 return IWERR_GET_EXT;
00598
00599 memmove(&(request->u.frag), &(vif_config->frag), sizeof(struct iw_param));
00600
00601 if (vif_config->has_frag == 1)
00602 {
00603 vif_debug("SIOCGIWFRAG : %i Bytes\n", request->u.frag.value);
00604 } else {
00605 vif_debug("SIOCGIWFRAG : off\n");
00606 }
00607 return 0;
00608 }
00609
00610 int
00611 vif_siocsiwtxpow(struct iwreq *request)
00612 {
00613
00614 struct wireless_info *vif_config =
00615 get_wireless_info(request->ifr_ifrn.ifrn_name);
00616 if (vif_config == NULL)
00617 return IWERR_SET_EXT;
00618
00619
00620 if ((request->u.txpower.flags == IW_TXPOW_DBM) && (request->u.txpower.value > 20))
00621 return IWERR_ARG_SIZE;
00622
00623 if ((request->u.txpower.flags == IW_TXPOW_MWATT) && (request->u.txpower.value > 100))
00624 return IWERR_ARG_SIZE;
00625
00626 memmove(&(vif_config->txpower), &(request->u.txpower),
00627 sizeof(struct iw_param));
00628
00629
00630 if (vif_config->txpower.value == -1)
00631 vif_config->txpower.value = VIF_DEFAULT_TXPWR;
00632
00633 vif_config->has_txpower = iw_get_param_state(&(vif_config->txpower));
00634
00635 if (vif_config->txpower.flags == IW_TXPOW_DBM)
00636 vif_debug("SIOCSIWTXPOW : %d dBm\n", vif_config->txpower.value);
00637 else
00638 vif_debug("SIOCSIWTXPOW : %d mW\n", vif_config->txpower.value);
00639 return 0;
00640 }
00641
00642 int
00643 vif_siocgiwtxpow(struct iwreq *request)
00644 {
00645
00646 struct wireless_info *vif_config =
00647 get_wireless_info(request->ifr_ifrn.ifrn_name);
00648 if (vif_config == NULL)
00649 return IWERR_GET_EXT;
00650
00651 memmove(&(request->u.txpower), &(vif_config->txpower),
00652 sizeof(struct iw_param));
00653
00654 if (vif_config->txpower.flags == IW_TXPOW_DBM)
00655 vif_debug("SIOCGIWTXPOW : %d dBm\n", vif_config->txpower.value);
00656 else
00657 vif_debug("SIOCGIWTXPOW : %d mW\n", vif_config->txpower.value);
00658 return 0;
00659 }
00660
00661 int
00662 vif_siocsiwretry(struct iwreq *request)
00663 {
00664 struct wireless_info *vif_config =
00665 get_wireless_info(request->ifr_ifrn.ifrn_name);
00666
00667 if (request->u.retry.value > VIF_MAX_RETRY)
00668 return IWERR_ARG_SIZE;
00669 if (request->u.retry.value < 0)
00670 return IWERR_ARG_SIZE;
00671
00672 memmove(&(vif_config->retry), &(request->u.retry),
00673 sizeof(struct iw_param));
00674 if (vif_config->retry.value == 0);
00675 vif_config->retry.disabled = 1;
00676 vif_config->has_retry = iw_get_param_state(&(vif_config->retry));
00677
00678 vif_debug("SIOCSIWRETRY : %.1d\n", request->u.retry.value);
00679 return 0;
00680 }
00681
00682 int
00683 vif_siocgiwretry(struct iwreq *request)
00684 {
00685 struct wireless_info *vif_config =
00686 get_wireless_info(request->ifr_ifrn.ifrn_name);
00687
00688 if (vif_config == NULL)
00689 return IWERR_GET_EXT;
00690
00691 memmove(&(request->u.retry), &(vif_config->retry), sizeof(struct iw_param));
00692
00693 vif_debug("SIOCGIWRETRY : %.1d\n", request->u.retry.value);
00694 return 0;
00695 }
00696
00697 int
00698 vif_siocsiwencode(struct iwreq *request)
00699 {
00700 struct wireless_info *vif_config =
00701 get_wireless_info(request->ifr_ifrn.ifrn_name);
00702 if (vif_config == NULL)
00703 return IWERR_SET_EXT;
00704
00705 vif_config->b.key_flags = request->u.encoding.flags;
00706 vif_config->b.key_size = request->u.encoding.length;
00707 if (request->u.encoding.flags != IW_ENCODE_DISABLED)
00708 {
00709 memmove(vif_config->b.key, request->u.encoding.pointer,
00710 IW_ENCODING_TOKEN_MAX);
00711 vif_config->b.has_key = 1;
00712
00713 vif_debug("SIOCSIWENCODE : %s, size = %i\n", vif_config->b.key,
00714 vif_config->b.key_size);
00715 } else {
00716 memset(vif_config->b.key, 0, IW_ENCODING_TOKEN_MAX);
00717 vif_config->b.has_key = 0;
00718
00719 vif_debug("SIOCSIWENCODE : off\n");
00720 }
00721 return 0;
00722 }
00723
00724 int
00725 vif_siocgiwencode(struct iwreq *request)
00726 {
00727 struct wireless_info *vif_config =
00728 get_wireless_info(request->ifr_ifrn.ifrn_name);
00729 if (vif_config == NULL)
00730 return IWERR_GET_EXT;
00731
00732 if (vif_config->b.has_key == 1)
00733 {
00734 memmove(request->u.encoding.pointer, vif_config->b.key,
00735 IW_ENCODING_TOKEN_MAX);
00736 request->u.encoding.length = vif_config->b.key_size;
00737 request->u.encoding.flags = vif_config->b.key_flags;
00738
00739 vif_debug("SIOCGIWENCODE : %s, size = %i\n",
00740 request->u.encoding.pointer, request->u.encoding.length);
00741 } else {
00742 request->u.encoding.flags = IW_ENCODE_DISABLED;
00743 request->u.encoding.length = 0;
00744
00745 vif_debug("SIOCGIWENCODE : off\n");
00746 }
00747 return 0;
00748 }
00749
00750 int
00751 vif_siocgiwpower(struct iwreq *request)
00752 {
00753 struct wireless_info *vif_config =
00754 get_wireless_info(request->ifr_ifrn.ifrn_name);
00755
00756 memmove(&(request->u.power), &(vif_config->power), sizeof(struct iw_param));
00757 if (vif_config->has_power == 1)
00758 {
00759 vif_debug("SIGCGIWPOWER : enabled\n");
00760 } else {
00761 vif_debug("SIGCGIWPOWER : disabled'\n");
00762 }
00763
00764 return 0;
00765 }
00766
00767
00768
00769
00770 void
00771 vif_set_debug_function(int (*debug)(const char *format, ...))
00772 {
00773 vif_debug = debug;
00774 }
00775
00776 void
00777 vif_set_error_function(int (*error)(const char *format, ...))
00778 {
00779 vif_error = error;
00780 }
00781
00782 ssize_t
00783 vif_init()
00784 {
00785 ssize_t num_vif = 0;
00786 vif_list_id = vif_config_load();
00787
00788 if (vif_list_id < 0)
00789 return 0;
00790 else
00791 num_vif = vif_config_list(vif_list_id, NULL);
00792
00793 vif_debug("vif_init(): num_vif = %i\n", num_vif);
00794 if (num_vif < 0)
00795 return 0;
00796 else
00797 return num_vif;
00798 }
00799
00800 int
00801 vif_create(const char *vif_name)
00802 {
00803 int i = 0;
00804 int num_vif = 0;
00805 char vif_names[MAX_NUM_VIF][IFNAMSIZ + 1];
00806
00807 if (vif_list_id < 0)
00808 if ((vif_list_id = vif_config_create()) < 0)
00809 return -1;
00810
00811 memset(vif_names, 0, MAX_NUM_VIF);
00812 num_vif = vif_config_list(vif_list_id, vif_names);
00813
00814 if (num_vif == MAX_NUM_VIF)
00815 {
00816 vif_error("Failed to create interface %s. Only %i virtual interfaces supported\n",
00817 vif_name, MAX_NUM_VIF);
00818 return -1;
00819 }
00820
00821 if (tun_create(vif_name) != 0)
00822 return -1;
00823
00824 for (i = 0; i < num_vif; i++)
00825 {
00826 if (strncmp(vif_name, vif_names[i], IFNAMSIZ) == 0)
00827 {
00828 vif_error("Device %s already exists\n", vif_name);
00829 return -1;
00830 }
00831 }
00832 if (vif_config_add(vif_list_id, vif_name) < 0)
00833 return -1;
00834
00835 vif_siocsifhwaddr(vif_name);
00836
00837 return 0;
00838 }
00839
00840 int
00841 vif_delete(const char *dev_name)
00842 {
00843 int rtrn = 0;
00844
00845 rtrn = vif_config_delete(vif_list_id, dev_name);
00846 if (rtrn == 0)
00847 rtrn = tun_remove(dev_name);
00848
00849 return rtrn;
00850 }
00851
00852 int
00853 vif_ioctl(int request, struct iwreq *pwrq)
00854 {
00855 int i = 0, rtrn = -1;
00856 vif_info *vif_entry = NULL;
00857
00858 if (vif_list_id < 0)
00859 vif_list_id = vif_config_load();
00860
00861 vif_entry = vif_config_vif_info(vif_list_id, pwrq->ifr_name);
00862 if (vif_entry == NULL)
00863 {
00864 vif_debug("No such device (%s)\n", pwrq->ifr_name);
00865 if (IW_IS_GET(request))
00866 return IWERR_GET_EXT;
00867 else
00868 return IWERR_SET_EXT;
00869 }
00870
00871 for (i = 0; i < VIF_NUM_IOCTL; i++)
00872 {
00873 if (ioctl_handler_list[i].ioctl_num == request)
00874 {
00875
00876 rtrn = (*ioctl_handler_list[i].iw_handler)(pwrq);
00877 if (rtrn < 0)
00878 return rtrn;
00879 if (IW_IS_SET(request))
00880 vif_notify_ioctl(request, pwrq->ifr_name);
00881 return 0;
00882 }
00883 }
00884
00885
00886 vif_debug("vif_ioctl(): requested ioctl not found\n");
00887 if (IW_IS_GET(request))
00888 return IWERR_GET_EXT;
00889 else
00890 return IWERR_SET_EXT;
00891 }
00892
00893 int
00894 vif_get_names(char vif_names[MAX_NUM_VIF][IFNAMSIZ + 1])
00895 {
00896 if (vif_list_id < 0)
00897 vif_list_id = vif_config_load();
00898
00899 if (vif_list_id < 0)
00900 {
00901 vif_error("Couldn't load virtual interface(s) configuration\n");
00902 return -1;
00903 } else {
00904 return vif_config_list(vif_list_id, vif_names);
00905 }
00906 }
00907
00908 void
00909 vif_print(void)
00910 {
00911 if (vif_list_id < 0)
00912 vif_list_id = vif_config_load();
00913
00914 vif_config_print(vif_list_id);
00915 }
00916
00917 int
00918 vif_get_mac(unsigned char *mac, const char *dev_name)
00919 {
00920 vif_info *vif_entry = vif_config_vif_info(vif_list_id, dev_name);
00921 if (vif_entry == NULL)
00922 return -1;
00923 else
00924 memmove(mac, vif_entry->vif_mac, ETH_ALEN);
00925
00926 return 0;
00927 }
00928
00929 double
00930 vif_get_frequency(const char *dev_name)
00931 {
00932
00933 wireless_info *wlaninfo = get_wireless_info(dev_name);
00934 if (wlaninfo != NULL)
00935 return wlaninfo->b.freq;
00936 else
00937 return 0;
00938 }
00939
00940 uint16_t
00941 vif_get_channel(const char *dev_name)
00942 {
00943
00944 int i = 0;
00945 uint16_t channel = 0;
00946 int freq = vif_get_frequency(dev_name) / MEGA;
00947 if (freq > 0)
00948 {
00949 wireless_info *wlaninfo = get_wireless_info(dev_name);
00950 if (wlaninfo != NULL)
00951 {
00952 for (i = 0; i < VIF_NUM_CHANNEL; i++)
00953 {
00954 int channel_freq = iw_freq2float(&(wlaninfo->range.freq[i])) / MEGA;
00955 if (freq == channel_freq)
00956 {
00957 channel = i;
00958 break;
00959 }
00960 }
00961 }
00962 }
00963 return channel;
00964 }
00965
00966 int16_t
00967 vif_get_sensitivity(const char *dev_name)
00968 {
00969
00970 wireless_info *wlaninfo = get_wireless_info(dev_name);
00971 if (wlaninfo != NULL)
00972
00973
00974
00975 return wlaninfo->sens.value;
00976 else
00977 return 0;
00978 }
00979
00980 int16_t
00981 vif_get_rts(const char *dev_name)
00982 {
00983
00984 wireless_info *wlaninfo = get_wireless_info(dev_name);
00985 if (wlaninfo != NULL)
00986 return wlaninfo->rts.value;
00987 else
00988 return 0;
00989 }
00990
00991 int16_t
00992 vif_get_frag(const char *dev_name)
00993 {
00994 wireless_info *wlaninfo = get_wireless_info(dev_name);
00995 if (wlaninfo != NULL)
00996 return wlaninfo->frag.value;
00997 else
00998 return 0;
00999 }
01000
01001 int16_t
01002 vif_get_txpower(const char *dev_name)
01003 {
01004 wireless_info *wlaninfo = get_wireless_info(dev_name);
01005 if (wlaninfo != NULL)
01006 {
01007 struct iw_param *txpwr = &(wlaninfo->txpower);
01008 if (txpwr->flags)
01009
01010 return txpwr->value;
01011 else
01012
01013 return dbm2mw(txpwr->value);
01014 } else
01015 return 0;
01016 }
01017
01018 int16_t
01019 vif_get_retry(const char *dev_name)
01020 {
01021 wireless_info *wlaninfo = get_wireless_info(dev_name);
01022 if (wlaninfo != NULL)
01023 return wlaninfo->retry.value;
01024 else
01025 return 0;
01026 }