static int scan_wifi(int skfd, char* ifname, char* args[], int count)
{
nsCOMArray<nsWifiAccessPoint>* accessPoints = (nsCOMArray<nsWifiAccessPoint>*) args[0];
iw_stats_t iw_stats = (iw_stats_t) args[1];
struct iwreq wrq;
int result = iw_get_ext(skfd, ifname, SIOCGIWMODE, &wrq);
if (result < 0)
return 0;
// We only cared about "Managed" mode. 2 is the magic number. There isn't a #define for this.
if (wrq.u.mode != 2)
return 0;
nsWifiAccessPoint* ap = new nsWifiAccessPoint();
if (!ap)
return 0;
char buffer[128];
wrq.u.essid.pointer = buffer;
wrq.u.essid.length = 128;
wrq.u.essid.flags = 0;
result = iw_get_ext(skfd, ifname, SIOCGIWESSID, &wrq);
if (result < 0) {
delete ap;
return 0;
}
ap->setSSID(buffer, wrq.u.essid.length);
result = iw_get_ext(skfd, ifname, SIOCGIWAP, &wrq);
if (result < 0) {
delete ap;
return 0;
}
ap->setMac( (const uint8*) wrq.u.ap_addr.sa_data );
iwrange range;
iwstats stats;
result = (*iw_stats)(skfd, ifname, &stats, &range, 1);
if (result < 0) {
delete ap;
return 0;
}
if(stats.qual.level > range.max_qual.level)
ap->setSignal(stats.qual.level - 0x100);
else
ap->setSignal(0);
accessPoints->AppendObject(ap);
return 0;
}
static double
get_keyid(void *arg)
{
unsigned char key[IW_ENCODING_TOKEN_MAX];
int key_size, key_flags;
wrq.u.data.pointer = (caddr_t) key;
wrq.u.data.length = IW_ENCODING_TOKEN_MAX;
wrq.u.data.flags = 0;
if (iw_get_ext(skfd, arg, SIOCGIWENCODE, &wrq) < 0) {
xsg_debug("get_keyid: UNKNOWN");
return DNAN;
}
key_size = wrq.u.data.length;
key_flags = wrq.u.data.flags;
if ((key_flags & IW_ENCODE_DISABLED) || (key_size == 0)) {
xsg_debug("get_keyid: UNKNOWN");
return DNAN;
}
xsg_debug("get_keyid: %f", (double) (key_flags & IW_ENCODE_INDEX));
return (double) (key_flags & IW_ENCODE_INDEX);
}
static int
get_channel(int skfd, char *ifname)
{
struct iwreq wrq;
struct iw_range range;
double freq;
int channel;
/* Get list of frequencies / channels */
if(iw_get_range_info(skfd, ifname, &range) < 0) {
return -1;
}
else {
/* Get current frequency / channel and display it */
if(iw_get_ext(skfd, ifname, SIOCGIWFREQ, &wrq) >= 0) {
freq = iw_freq2float(&(wrq.u.freq));
channel = iw_freq_to_channel(freq, &range);
return channel;
}
else {
return -2;
}
}
return -3;
}
/*
* Display the mode if possible
*/
static int
print_mode(int skfd,
const char * ifname,
int format)
{
struct iwreq wrq;
/* Get frequency / channel */
if(iw_get_ext(skfd, ifname, SIOCGIWMODE, &wrq) < 0)
return(-1);
if(wrq.u.mode >= IW_NUM_OPER_MODE)
return(-2);
/* Print */
switch(format)
{
case FORMAT_SCHEME:
/* Strip all white space and stuff */
if(wrq.u.mode == IW_MODE_ADHOC)
printf("AdHoc\n");
else
printf("%s\n", iw_operation_mode[wrq.u.mode]);
break;
case FORMAT_RAW:
printf("%d\n", wrq.u.mode);
break;
default:
printf("%-8.16s Mode:%s\n", ifname, iw_operation_mode[wrq.u.mode]);
break;
}
return(0);
}
/*
* Display the AP Address if possible
*/
static int
print_ap(int skfd,
const char * ifname,
int format)
{
struct iwreq wrq;
char buffer[64];
/* Get AP Address */
if(iw_get_ext(skfd, ifname, SIOCGIWAP, &wrq) < 0)
return(-1);
/* Print */
iw_ether_ntop((const struct ether_addr *) wrq.u.ap_addr.sa_data, buffer);
switch(format)
{
case FORMAT_SCHEME:
/* I think ':' are not problematic, because Pcmcia scripts
* seem to handle them properly... */
case FORMAT_RAW:
printf("%s\n", buffer);
break;
default:
printf("%-8.16s Access Point/Cell: %s\n", ifname, buffer);
break;
}
return(0);
}
/*
* Display the frequency (or channel) if possible
*/
static int
print_freq(int skfd,
const char * ifname,
int format)
{
struct iwreq wrq;
double freq;
char buffer[64];
/* Get frequency / channel */
if(iw_get_ext(skfd, ifname, SIOCGIWFREQ, &wrq) < 0)
return(-1);
/* Print */
freq = iw_freq2float(&(wrq.u.freq));
switch(format)
{
case FORMAT_SCHEME:
/* Prefix with freq to avoid name space collisions */
printf("freq%g\n", freq);
break;
case FORMAT_RAW:
printf("%g\n", freq);
break;
default:
iw_print_freq(buffer, sizeof(buffer), freq, -1, wrq.u.freq.flags);
printf("%-8.16s %s\n", ifname, buffer);
break;
}
return(0);
}
static PyObject *
wifi_get_ap(PyObject *self, PyObject *args)
{
const char *iface;
int max_quality;
int fd, err;
struct iwreq wrq;
char buffer[32];
if (!PyArg_ParseTuple(args, "s", &iface))
return NULL;
fd = socket (PF_INET, SOCK_DGRAM, 0);
if (fd < 0) {
fprintf (stderr, "couldn't open socket\n");
return NULL;
}
/* Get AP address */
err = iw_get_ext(fd, iface, SIOCGIWAP, &wrq);
close (fd);
if (err < 0) {
PyErr_SetFromErrno(PyExc_IOError);
return NULL;
}
return Py_BuildValue("s", iw_sawap_ntop(&wrq.u.ap_addr, buffer));
}
/*
* Display the NWID if possible
*/
static int
print_nwid(int skfd,
const char * ifname,
int format)
{
struct iwreq wrq;
/* Get network ID */
if(iw_get_ext(skfd, ifname, SIOCGIWNWID, &wrq) < 0)
return(-1);
switch(format)
{
case FORMAT_SCHEME:
/* Prefix with nwid to avoid name space collisions */
printf("nwid%X\n", wrq.u.nwid.value);
break;
case FORMAT_RAW:
printf("%X\n", wrq.u.nwid.value);
break;
default:
printf("%-8.16s NWID:%X\n", ifname, wrq.u.nwid.value);
break;
}
return(0);
}
/* ------------------------------------------------------------------- WirelessInterface_refresh */
static void WirelessInterface_refresh(wiface* self)
{
iwreq wrq;
iw_get_basic_config(self->sock, self->ifname, &(self->info.b));
iw_get_range_info(self->sock, self->ifname, &(self->info.range));
iw_get_ext(self->sock, self->ifname, SIOCGIWRATE, &wrq);
memcpy(&(self->info.bitrate), &wrq.u.bitrate, sizeof(iwparam));
iw_get_ext(self->sock, self->ifname, SIOCGIWAP, &wrq);
memcpy(&(self->info.ap_addr), &wrq.u.ap_addr, sizeof(sockaddr));
iw_get_stats(self->sock, self->ifname, &(self->info.stats),
&(self->info.range), self->info.has_range);
}
static const char *
get_key(void *arg)
{
unsigned char key[IW_ENCODING_TOKEN_MAX];
int key_size, key_flags;
wrq.u.data.pointer = (caddr_t) key;
wrq.u.data.length = IW_ENCODING_TOKEN_MAX;
wrq.u.data.flags = 0;
if (iw_get_ext(skfd, arg, SIOCGIWENCODE, &wrq) < 0) {
xsg_debug("get_key: UNKNOWN");
return NULL;
}
key_size = wrq.u.data.length;
key_flags = wrq.u.data.flags;
if ((key_flags & IW_ENCODE_DISABLED) || (key_size == 0)) {
xsg_debug("get_key: \"off\"");
return "off";
}
iw_print_key(buffer, sizeof(buffer), key, key_size, key_flags);
xsg_debug("get_key: \"%s\"", buffer);
return buffer;
}
static const char *
get_essid(void *arg)
{
static char essid[IW_ESSID_MAX_SIZE + 1];
int essid_on;
wrq.u.essid.pointer = (caddr_t) essid;
wrq.u.essid.length = IW_ESSID_MAX_SIZE + 1;
wrq.u.essid.flags = 0;
if (iw_get_ext(skfd, arg, SIOCGIWESSID, &wrq) < 0) {
xsg_debug("get_essid: UNKNOWN");
return NULL;
}
essid_on = wrq.u.data.flags;
if (essid_on) {
xsg_debug("get_essid: \"%s\"", essid);
return essid;
} else {
xsg_debug("get_essid: off/any");
return "off/any";
}
}
/*
* Set RTS Threshold
*/
static int
set_rts_info(int skfd,
char * ifname,
char * args[], /* Command line args */
int count) /* Args count */
{
struct iwreq wrq;
/* Avoid "Unused parameter" warning */
count = count;
wrq.u.rts.value = -1;
wrq.u.rts.fixed = 1;
wrq.u.rts.disabled = 0;
if(!strcasecmp(args[0], "off"))
wrq.u.rts.disabled = 1; /* i.e. max size */
else
if(!strcasecmp(args[0], "auto"))
wrq.u.rts.fixed = 0;
else
{
if(!strcasecmp(args[0], "fixed"))
{
/* Get old RTS threshold */
if(iw_get_ext(skfd, ifname, SIOCGIWRTS, &wrq) < 0)
return(IWERR_GET_EXT);
wrq.u.rts.fixed = 1;
}
else
{ /* Should be a numeric value */
long temp;
if(sscanf(args[0], "%li", (unsigned long *) &(temp)) != 1)
{
errarg = 0;
return(IWERR_ARG_TYPE);
}
wrq.u.rts.value = temp;
/*Begin: Modified by zhanghu to support minimum rts to 100 in iwconfig ath0 rts 100 2013-01-29*/
if(wrq.u.rts.value < 100) { //deleted by zhanghu if(wrq.u.rts.value < 256) {
/*End: Modified by zhanghu to support minimum rts to 100 in iwconfig ath0 rts 100 2013-01-29*/
fprintf(stderr, "Minimum RTS Threshold should be 100 bytes\n");
errarg = 0;
return(IWERR_ARG_TYPE);
}
}
}
if(iw_set_ext(skfd, ifname, SIOCSIWRTS, &wrq) < 0)
return(IWERR_SET_EXT);
/* 1 arg */
return(1);
}
/*
* Set frequency/channel
*/
static int
set_channel(int skfd,
char * ifname,
char * args[], /* Command line args */
int count) /* Args count */
{
struct iwreq wrq;
int i = 1;
if(!strcasecmp(args[0], "auto")) {
wrq.u.freq.m = -1;
wrq.u.freq.e = 0;
wrq.u.freq.flags = 0;
}
else {
if(!strcasecmp(args[0], "fixed")) {
/* Get old frequency */
if(iw_get_ext(skfd, ifname, SIOCGIWFREQ, &wrq) < 0)
return(IWERR_GET_EXT);
wrq.u.freq.flags = IW_FREQ_FIXED;
}
else { /* Should be a numeric value */
double freq;
char * unit;
freq = strtod(args[0], &unit);
if(unit == args[0]) {
errarg = 0;
return(IWERR_ARG_TYPE);
}
if(unit != NULL) {
if(unit[0] == 'G') freq *= GIGA;
if(unit[0] == 'M') freq *= MEGA;
if(unit[0] == 'k') freq *= KILO;
}
iw_float2freq(freq, &(wrq.u.freq));
wrq.u.freq.flags = IW_FREQ_FIXED;
/* Check for an additional argument */
if((i < count) && (!strcasecmp(args[i], "auto"))) {
wrq.u.freq.flags = 0;
++i;
}
if((i < count) && (!strcasecmp(args[i], "fixed"))) {
wrq.u.freq.flags = IW_FREQ_FIXED;
++i;
}
}
}
if(iw_set_ext(skfd, ifname, SIOCSIWFREQ, &wrq) < 0)
return(IWERR_SET_EXT);
/* Var args */
return(i);
}
/*
* Print the number of channels and available frequency for the device
*/
static int
print_freq_info(int skfd,
char * ifname,
char * args[], /* Command line args */
int count) /* Args count */
{
struct iwreq wrq;
struct iw_range range;
double freq;
int k;
int channel;
char buffer[128]; /* Temporary buffer */
/* Avoid "Unused parameter" warning */
args = args; count = count;
/* Get list of frequencies / channels */
if(iw_get_range_info(skfd, ifname, &range) < 0)
fprintf(stderr, "%-8.16s no frequency information.\n\n",
ifname);
else
{
if(range.num_frequency > 0)
{
printf("%-8.16s %d channels in total; available frequencies :\n",
ifname, range.num_channels);
/* Print them all */
for(k = 0; k < range.num_frequency; k++)
{
freq = iw_freq2float(&(range.freq[k]));
iw_print_freq_value(buffer, sizeof(buffer), freq);
printf(" Channel %.2d : %s\n",
range.freq[k].i, buffer);
}
}
else
printf("%-8.16s %d channels\n",
ifname, range.num_channels);
/* Get current frequency / channel and display it */
if(iw_get_ext(skfd, ifname, SIOCGIWFREQ, &wrq) >= 0)
{
freq = iw_freq2float(&(wrq.u.freq));
channel = iw_freq_to_channel(freq, &range);
iw_print_freq(buffer, sizeof(buffer),
freq, channel, wrq.u.freq.flags);
printf(" Current %s\n\n", buffer);
}
}
sprintf(cmd, "nvram set %s_channel=%d",ifname, channel);
//printf("cmd %s\n", cmd);
system(cmd);
return(0);
}
static double
get_nwid(void *arg)
{
if (iw_get_ext(skfd, arg, SIOCGIWNWID, &wrq) < 0) {
xsg_debug("get_nwid: UNKNOWN");
return DNAN;
}
xsg_debug("get_nwid: %f", (double) wrq.u.nwid.value);
return (double) wrq.u.nwid.value;
}
static double
get_sens(void *arg)
{
if (iw_get_ext(skfd, arg, SIOCGIWSENS, &wrq) < 0) {
xsg_debug("get_sens: UNKNOWN");
return DNAN;
}
xsg_debug("get_sens: %f", (double) wrq.u.sens.value);
return (double) wrq.u.sens.value;
}
static int
handle_iw(int fd, char *ifname, char *args[], int count)
{
/* if no wireless name: no wireless extensions */
if (iw_get_ext(fd, ifname, SIOCGIWNAME, &wrq) >= 0) {
device_list = xsg_list_append(device_list,
(void *) xsg_strdup(ifname));
}
return 0;
}
static double
get_bitrate_number(void *arg)
{
if (iw_get_ext(skfd, arg, SIOCGIWRATE, &wrq) < 0) {
xsg_debug("get_bitrate_number: UNKNOWN");
return DNAN;
}
xsg_debug("get_bitrate_number: %f", (double) wrq.u.bitrate.value);
return (double) wrq.u.bitrate.value;
}
static const char *
get_bitrate_string(void *arg)
{
if (iw_get_ext(skfd, arg, SIOCGIWRATE, &wrq) < 0) {
xsg_debug("get_bitrate_string: UNKNOWN");
return NULL;
}
iw_print_bitrate(buffer, sizeof(buffer), wrq.u.bitrate.value);
xsg_debug("get_bitrate_string: \"%s\"", buffer);
return buffer;
}
static const char *
get_ap(void *arg)
{
if (iw_get_ext(skfd, arg, SIOCGIWAP, &wrq) < 0) {
xsg_debug("get_ap: UNKNOWN");
return NULL;
}
iw_sawap_ntop(&(wrq.u.ap_addr), buffer);
xsg_debug("get_ap: \"%s\"", buffer);
return buffer;
}
static int iwscan_ifname_hasiwname(char* ifname)
{
int ret = 0;
int skfd;
iwreq wrq;
if ((skfd = iw_sockets_open()) >= 0) {
if (iw_get_ext(skfd, ifname, SIOCGIWNAME, &wrq) >= 0)
ret++;
iw_sockets_close(skfd);
}
return ret;
}
/*
* Set Fragmentation Threshold
*/
static int
set_frag_info(int skfd,
char * ifname,
char * args[], /* Command line args */
int count) /* Args count */
{
struct iwreq wrq;
/* Avoid "Unused parameter" warning */
count = count;
wrq.u.frag.value = -1;
wrq.u.frag.fixed = 1;
wrq.u.frag.disabled = 0;
if(!strcasecmp(args[0], "off"))
wrq.u.frag.disabled = 1; /* i.e. max size */
else
if(!strcasecmp(args[0], "auto"))
wrq.u.frag.fixed = 0;
else
{
if(!strcasecmp(args[0], "fixed"))
{
/* Get old fragmentation threshold */
if(iw_get_ext(skfd, ifname, SIOCGIWFRAG, &wrq) < 0)
return(IWERR_GET_EXT);
wrq.u.frag.fixed = 1;
}
else
{ /* Should be a numeric value */
long temp;
if(sscanf(args[0], "%li", &(temp))
!= 1)
{
errarg = 0;
return(IWERR_ARG_TYPE);
}
wrq.u.frag.value = temp;
}
}
if(iw_set_ext(skfd, ifname, SIOCSIWFRAG, &wrq) < 0)
return(IWERR_SET_EXT);
/* 1 arg */
return(1);
}
static const char *
get_name(void *arg)
{
static char name[IFNAMSIZ + 1];
if (iw_get_ext(skfd, arg, SIOCGIWNAME, &wrq) < 0) {
xsg_debug("get_name: UNKNOWN");
return NULL;
}
strncpy(name, wrq.u.name, IFNAMSIZ);
name[IFNAMSIZ] = '\0';
xsg_debug("get_name: \"%s\"", name);
return name;
}
static double
get_frag_number(void *arg)
{
if (iw_get_ext(skfd, arg, SIOCGIWFRAG, &wrq) < 0) {
xsg_debug("get_frag_number: UNKNOWN");
return DNAN;
}
if (wrq.u.frag.disabled) {
xsg_debug("get_frag_number: UNKNOWN");
return DNAN;
}
xsg_debug("get_frag_number: %f", (double) wrq.u.frag.value);
return (double) wrq.u.frag.value;
}
static double
get_mode_number(void *arg)
{
if (iw_get_ext(skfd, arg, SIOCGIWMODE, &wrq) < 0) {
xsg_debug("get_mode_number: UNKNOWN");
return DNAN;
}
if (wrq.u.mode < IW_NUM_OPER_MODE) {
xsg_debug("get_mode_number: %f", (double) wrq.u.mode);
return (double) wrq.u.mode;
} else {
xsg_debug("get_mode_number: %f", (double) IW_NUM_OPER_MODE);
return (double) IW_NUM_OPER_MODE;
}
}
/**
* @brief Gets the signal quality property of the wifi device
* @return An updated wifi_signal type
*/
wifi_signal getSignal()
{
if (iw_get_stats(wifi_skfd, wifi_dev, &(wifi_info->stats), &wifi_info->range, wifi_info->has_range) >= 0)
wifi_info->has_stats = 1;
int quality = wifi_info->stats.qual.qual;
// Get bit rate
if (iw_get_ext(wifi_skfd, wifi_dev, SIOCGIWRATE, &wifi_wrq) >= 0)
{
wifi_info->has_bitrate = 1;
memcpy(&(wifi_info->bitrate), &(wifi_wrq.u.bitrate), sizeof(wifi_info->bitrate));
}
wifi_sig.link_quality = quality;
return wifi_sig;
}
static const char *
get_retry(void *arg)
{
if (iw_get_range_info(skfd, arg, &range) < 0) {
xsg_debug("get_retry: UNKNOWN");
return NULL;
}
if (range.we_version_compiled <= 10) {
xsg_debug("get_retry: UNKNOWN");
return NULL;
}
if (iw_get_ext(skfd, arg, SIOCGIWRETRY, &wrq) < 0) {
xsg_debug("get_retry: UNKNOWN");
return NULL;
}
if (wrq.u.retry.disabled) {
xsg_debug("get_retry: \"off\"");
return "off";
}
if (wrq.u.retry.flags == IW_RETRY_ON) {
xsg_debug("get_retry: \"on\"");
return "on";
}
if (wrq.u.retry.flags & IW_RETRY_TYPE) {
iw_print_retry_value(buffer, sizeof(buffer),
wrq.u.retry.value, wrq.u.retry.flags,
range.we_version_compiled);
if (buffer[0] == ' ') {
xsg_debug("get_retry: \"%s\"", buffer + 1);
return buffer + 1;
} else {
xsg_debug("get_retry: \"%s\"", buffer);
return buffer;
}
}
xsg_debug("get_retry: UNKNOWN");
return NULL;
}
/*
* Print the number of available bitrates for the device
*/
static int
print_bitrate_info(int skfd,
char * ifname,
char * args[], /* Command line args */
int count) /* Args count */
{
struct iwreq wrq;
struct iw_range range;
int k;
char buffer[128];
/* Avoid "Unused parameter" warning */
args = args; count = count;
/* Extract range info */
if(iw_get_range_info(skfd, ifname, &range) < 0)
fprintf(stderr, "%-8.16s no bit-rate information.\n\n",
ifname);
else
{
if((range.num_bitrates > 0) && (range.num_bitrates <= IW_MAX_BITRATES))
{
printf("%-8.16s %d available bit-rates :\n",
ifname, range.num_bitrates);
/* Print them all */
for(k = 0; k < range.num_bitrates; k++)
{
iw_print_bitrate(buffer, sizeof(buffer), range.bitrate[k]);
/* Maybe this should be %10s */
printf("\t %s\n", buffer);
}
}
else
printf("%-8.16s unknown bit-rate information.\n", ifname);
/* Get current bit rate */
if(iw_get_ext(skfd, ifname, SIOCGIWRATE, &wrq) >= 0)
{
iw_print_bitrate(buffer, sizeof(buffer), wrq.u.bitrate.value);
printf(" Current Bit Rate%c%s\n\n",
(wrq.u.bitrate.fixed ? '=' : ':'), buffer);
}
}
return(0);
}
static const char *
get_frag_string(void *arg)
{
if (iw_get_ext(skfd, arg, SIOCGIWFRAG, &wrq) < 0) {
xsg_debug("get_frag_string: UNKNOWN");
return NULL;
}
if (wrq.u.frag.disabled) {
xsg_debug("get_frag_string: \"off\"");
return "off";
}
snprintf(buffer, sizeof(buffer), "%d B", wrq.u.frag.value);
xsg_debug("get_frag_string: \"%s\"", buffer);
return buffer;
}
/*
* Set commit
*/
static int
set_nwid_info(int skfd,
char * ifname,
char * args[], /* Command line args */
int count) /* Args count */
{
struct iwreq wrq;
unsigned long temp;
/* Avoid "Unused parameter" warning */
count = count;
if((!strcasecmp(args[0], "off")) ||
(!strcasecmp(args[0], "any")))
wrq.u.nwid.disabled = 1;
else
if(!strcasecmp(args[0], "on"))
{
/* Get old nwid */
if(iw_get_ext(skfd, ifname, SIOCGIWNWID, &wrq) < 0)
return(IWERR_GET_EXT);
wrq.u.nwid.disabled = 0;
}
else
if(sscanf(args[0], "%lX", &(temp)) != 1)
{
errarg = 0;
return(IWERR_ARG_TYPE);
}
else
{
wrq.u.nwid.value = temp;
wrq.u.nwid.disabled = 0;
}
wrq.u.nwid.fixed = 1;
/* Set new nwid */
if(iw_set_ext(skfd, ifname, SIOCSIWNWID, &wrq) < 0)
return(IWERR_SET_EXT);
/* 1 arg */
return(1);
}
