/*
* Check if interface support the right MAC address type...
*/
int
iw_check_mac_addr_type(int skfd,
const char * ifname)
{
struct ifreq ifr;
/* Get the type of hardware address */
strncpy(ifr.ifr_name, ifname, IFNAMSIZ);
if((ioctl(skfd, SIOCGIFHWADDR, &ifr) < 0) ||
((ifr.ifr_hwaddr.sa_family != ARPHRD_ETHER)
&& (ifr.ifr_hwaddr.sa_family != ARPHRD_IEEE80211)))
{
/* Deep trouble... */
fprintf(stderr, "Interface %s doesn't support MAC addresses\n",
ifname);
return(-1);
}
#ifdef DEBUG
{
char buf[20];
printf("Hardware : %d - %s\n", ifr.ifr_hwaddr.sa_family,
iw_saether_ntop(&ifr.ifr_hwaddr, buf));
}
#endif
return(0);
}
int main(int argc, char** argv)
{
int devsock;
struct ifreq ifbuffer;
char buf[20];
if ((argc != 2) || (argv[1][0] == '-'))
{
printf("Usage: macaddr interface\n");
exit(1);
}
devsock = socket(AF_INET, SOCK_STREAM, 0);
if (devsock == -1)
{
perror("Failed opening socket");
exit (1);
}
memset(&ifbuffer, 0, sizeof(ifbuffer));
strncpy(ifbuffer.ifr_name, argv[1], sizeof(ifbuffer.ifr_name));
if (ioctl(devsock, SIOCGIFHWADDR, &ifbuffer) == -1)
{
fprintf(stderr, "There is no MACADDR for %s\n", argv[1]);
exit(1);
}
close(devsock);
puts(iw_saether_ntop(&ifbuffer.ifr_ifru.ifru_hwaddr, buf));
exit(0);
}
/*
* Execute a private command on the interface
*/
static int
set_private_cmd(int skfd, /* Socket */
char * args[], /* Command line args */
int count, /* Args count */
char * ifname, /* Dev name */
char * cmdname, /* Command name */
iwprivargs * priv, /* Private ioctl description */
int priv_num) /* Number of descriptions */
{
struct iwreq wrq;
u_char buffer[8192]; /* Only that big in v25 and later */
int i = 0; /* Start with first command arg */
int k; /* Index in private description table */
int temp;
int subcmd = 0; /* sub-ioctl index */
int offset = 0; /* Space for sub-ioctl index */
/* Check if we have a token index.
* Do it now so that sub-ioctl takes precedence, and so that we
* don't have to bother with it later on... */
if((count >= 1) && (sscanf(args[0], "[%i]", &temp) == 1))
{
subcmd = temp;
args++;
count--;
}
/* Search the correct ioctl */
k = -1;
while((++k < priv_num) && strcmp(priv[k].name, cmdname));
/* If not found... */
if(k == priv_num)
{
fprintf(stderr, "Invalid command : %s\n", cmdname);
return(-1);
}
/* Watch out for sub-ioctls ! */
if(priv[k].cmd < SIOCDEVPRIVATE)
{
int j = -1;
/* Find the matching *real* ioctl */
while((++j < priv_num) && ((priv[j].name[0] != '\0') ||
(priv[j].set_args != priv[k].set_args) ||
(priv[j].get_args != priv[k].get_args)));
/* If not found... */
if(j == priv_num)
{
fprintf(stderr, "Invalid private ioctl definition for : %s\n",
cmdname);
return(-1);
}
/* Save sub-ioctl number */
subcmd = priv[k].cmd;
/* Reserve one int (simplify alignment issues) */
offset = sizeof(__u32);
/* Use real ioctl definition from now on */
k = j;
#if 0
printf("<mapping sub-ioctl %s to cmd 0x%X-%d>\n", cmdname,
priv[k].cmd, subcmd);
#endif
}
/* If we have to set some data */
if((priv[k].set_args & IW_PRIV_TYPE_MASK) &&
(priv[k].set_args & IW_PRIV_SIZE_MASK))
{
switch(priv[k].set_args & IW_PRIV_TYPE_MASK)
{
case IW_PRIV_TYPE_BYTE:
/* Number of args to fetch */
wrq.u.data.length = count;
if(wrq.u.data.length > (priv[k].set_args & IW_PRIV_SIZE_MASK))
wrq.u.data.length = priv[k].set_args & IW_PRIV_SIZE_MASK;
/* Fetch args */
for(; i < wrq.u.data.length; i++) {
sscanf(args[i], "%i", &temp);
buffer[i] = (char) temp;
}
break;
case IW_PRIV_TYPE_INT:
/* Number of args to fetch */
wrq.u.data.length = count;
if(wrq.u.data.length > (priv[k].set_args & IW_PRIV_SIZE_MASK))
wrq.u.data.length = priv[k].set_args & IW_PRIV_SIZE_MASK;
/* Fetch args */
for(; i < wrq.u.data.length; i++) {
sscanf(args[i], "%i", &temp);
((__s32 *) buffer)[i] = (__s32) temp;
}
break;
case IW_PRIV_TYPE_CHAR:
if(i < count)
{
/* Size of the string to fetch */
wrq.u.data.length = strlen(args[i]) + 1;
if(wrq.u.data.length > (priv[k].set_args & IW_PRIV_SIZE_MASK))
wrq.u.data.length = priv[k].set_args & IW_PRIV_SIZE_MASK;
/* Fetch string */
memcpy(buffer, args[i], wrq.u.data.length);
buffer[sizeof(buffer) - 1] = '\0';
i++;
}
else
{
wrq.u.data.length = 1;
buffer[0] = '\0';
}
break;
case IW_PRIV_TYPE_FLOAT:
/* Number of args to fetch */
wrq.u.data.length = count;
if(wrq.u.data.length > (priv[k].set_args & IW_PRIV_SIZE_MASK))
wrq.u.data.length = priv[k].set_args & IW_PRIV_SIZE_MASK;
/* Fetch args */
for(; i < wrq.u.data.length; i++) {
double freq;
if(sscanf(args[i], "%lg", &(freq)) != 1)
{
printf("Invalid float [%s]...\n", args[i]);
return(-1);
}
if(strchr(args[i], 'G')) freq *= GIGA;
if(strchr(args[i], 'M')) freq *= MEGA;
if(strchr(args[i], 'k')) freq *= KILO;
sscanf(args[i], "%i", &temp);
iw_float2freq(freq, ((struct iw_freq *) buffer) + i);
}
break;
case IW_PRIV_TYPE_ADDR:
/* Number of args to fetch */
wrq.u.data.length = count;
if(wrq.u.data.length > (priv[k].set_args & IW_PRIV_SIZE_MASK))
wrq.u.data.length = priv[k].set_args & IW_PRIV_SIZE_MASK;
/* Fetch args */
for(; i < wrq.u.data.length; i++) {
if(iw_in_addr(skfd, ifname, args[i],
((struct sockaddr *) buffer) + i) < 0)
{
printf("Invalid address [%s]...\n", args[i]);
return(-1);
}
}
break;
default:
fprintf(stderr, "Not implemented...\n");
return(-1);
}
if((priv[k].set_args & IW_PRIV_SIZE_FIXED) &&
(wrq.u.data.length != (priv[k].set_args & IW_PRIV_SIZE_MASK)))
{
printf("The command %s needs exactly %d argument(s)...\n",
cmdname, priv[k].set_args & IW_PRIV_SIZE_MASK);
return(-1);
}
} /* if args to set */
else
{
wrq.u.data.length = 0L;
}
strncpy(wrq.ifr_name, ifname, IFNAMSIZ);
/* Those two tests are important. They define how the driver
* will have to handle the data */
if((priv[k].set_args & IW_PRIV_SIZE_FIXED) &&
((iw_get_priv_size(priv[k].set_args) + offset) <= IFNAMSIZ))
{
/* First case : all SET args fit within wrq */
if(offset)
wrq.u.mode = subcmd;
memcpy(wrq.u.name + offset, buffer, IFNAMSIZ - offset);
}
else
{
if((priv[k].set_args == 0) &&
(priv[k].get_args & IW_PRIV_SIZE_FIXED) &&
(iw_get_priv_size(priv[k].get_args) <= IFNAMSIZ))
{
/* Second case : no SET args, GET args fit within wrq */
if(offset)
wrq.u.mode = subcmd;
}
else
{
/* Third case : args won't fit in wrq, or variable number of args */
wrq.u.data.pointer = (caddr_t) buffer;
wrq.u.data.flags = subcmd;
}
}
#if 1
if((priv[k].cmd == 0x8BED) && (wrq.u.data.pointer == (caddr_t) buffer))
wrq.u.data.length = sizeof(buffer);
#endif
/* Perform the private ioctl */
if(ioctl(skfd, priv[k].cmd, &wrq) < 0)
{
fprintf(stderr, "Interface doesn't accept private ioctl...\n");
fprintf(stderr, "%s (%X): %s\n", cmdname, priv[k].cmd, strerror(errno));
return(-1);
}
/* If we have to get some data */
if((priv[k].get_args & IW_PRIV_TYPE_MASK) &&
(priv[k].get_args & IW_PRIV_SIZE_MASK))
{
int j;
int n = 0; /* number of args */
printf("%-8.16s %s:", ifname, cmdname);
/* Check where is the returned data */
if((priv[k].get_args & IW_PRIV_SIZE_FIXED) &&
(iw_get_priv_size(priv[k].get_args) <= IFNAMSIZ))
{
memcpy(buffer, wrq.u.name, IFNAMSIZ);
n = priv[k].get_args & IW_PRIV_SIZE_MASK;
}
else
n = wrq.u.data.length;
switch(priv[k].get_args & IW_PRIV_TYPE_MASK)
{
case IW_PRIV_TYPE_BYTE:
/* Display args */
for(j = 0; j < n; j++)
printf("%d ", buffer[j]);
printf("\n");
break;
case IW_PRIV_TYPE_INT:
/* Display args */
for(j = 0; j < n; j++)
printf("%d ", ((__s32 *) buffer)[j]);
printf("\n");
break;
case IW_PRIV_TYPE_CHAR:
/* Display args */
buffer[n] = '\0';
printf("%s\n", buffer);
break;
case IW_PRIV_TYPE_FLOAT:
{
double freq;
/* Display args */
for(j = 0; j < n; j++)
{
freq = iw_freq2float(((struct iw_freq *) buffer) + j);
if(freq >= GIGA)
printf("%gG ", freq / GIGA);
else
if(freq >= MEGA)
printf("%gM ", freq / MEGA);
else
printf("%gk ", freq / KILO);
}
printf("\n");
}
break;
case IW_PRIV_TYPE_ADDR:
{
char scratch[128];
struct sockaddr * hwa;
/* Display args */
for(j = 0; j < n; j++)
{
hwa = ((struct sockaddr *) buffer) + j;
if(j)
printf(" %.*s",
(int) strlen(cmdname), " ");
printf("%s\n", iw_saether_ntop(hwa, scratch));
}
}
break;
default:
fprintf(stderr, "Not yet implemented...\n");
return(-1);
}
} /* if args to set */
return(0);
}
ap_info *
wireless_parse_scanning_event(struct iw_event *event, ap_info *oldinfo)
{
ap_info *info;
/* found a new AP */
if (event->cmd==SIOCGIWAP) {
char buf[128];
info = g_new0(ap_info, 1);
info->apaddr = g_strdup(iw_saether_ntop(&event->u.ap_addr, buf));
info->en_method = NS_WIRELESS_AUTH_OFF;
info->haskey = FALSE;
info->key_mgmt = NS_IW_IE_KEY_MGMT_NONE;
info->group = NS_IW_IE_CIPHER_TKIP;
info->pairwise = NS_IW_IE_CIPHER_TKIP;
} else {
info = oldinfo;
}
switch (event->cmd) {
case SIOCGIWESSID: /* ESSID */
if (!event->u.essid.flags
|| event->u.essid.length==0
|| strlen(event->u.essid.pointer)==0) {
info->essid = NULL;
} else {
info->essid = g_strndup(event->u.essid.pointer, event->u.essid.length);
}
break;
case IWEVQUAL: /* Signal Quality */
info->quality = (int)rint((log (event->u.qual.qual) / log (92)) * 100.0);
break;
case SIOCGIWENCODE: /* Encryption */
if (!event->u.data.pointer)
event->u.data.flags |= IW_ENCODE_NOKEY;
if (!(event->u.data.flags & IW_ENCODE_DISABLED)) {
info->haskey = TRUE;
/* assume WEP */
info->en_method = NS_WIRELESS_AUTH_WEP;
} else {
info->haskey = FALSE;
info->en_method = NS_WIRELESS_AUTH_OFF;
}
break;
case IWEVGENIE: /* Extra information */
{
int offset = 0;
int ielen = event->u.data.length;
unsigned char *iebuf;
while(offset <= (ielen - 2)) {
iebuf = (event->u.data.pointer + offset);
/* check IE type */
switch(iebuf[offset]) {
case 0xdd: /* WPA or else */
case 0x30: /* IEEE 802.11i/WPA2 */
wireless_gen_ie(info, iebuf, ielen);
break;
}
offset += iebuf[offset+1] + 2;
}
}
break;
}
return info;
}
/*
* Input an address and convert to binary.
*/
int
iw_in_addr(int skfd,
const char * ifname,
char * bufp,
struct sockaddr *sap)
{
/* Check if it is a hardware or IP address */
if(index(bufp, ':') == NULL)
{
struct sockaddr if_address;
struct arpreq arp_query;
/* Check if we have valid interface address type */
if(iw_check_if_addr_type(skfd, ifname) < 0)
{
fprintf(stderr, "%-8.16s Interface doesn't support IP addresses\n", ifname);
return(-1);
}
/* Read interface address */
if(iw_in_inet(bufp, &if_address) < 0)
{
fprintf(stderr, "Invalid interface address %s\n", bufp);
return(-1);
}
/* Translate IP addresses to MAC addresses */
memcpy((char *) &(arp_query.arp_pa),
(char *) &if_address,
sizeof(struct sockaddr));
arp_query.arp_ha.sa_family = 0;
arp_query.arp_flags = 0;
/* The following restrict the search to the interface only */
/* For old kernels which complain, just comment it... */
strncpy(arp_query.arp_dev, ifname, IFNAMSIZ);
if((ioctl(skfd, SIOCGARP, &arp_query) < 0) ||
!(arp_query.arp_flags & ATF_COM))
{
fprintf(stderr, "Arp failed for %s on %s... (%d)\nTry to ping the address before setting it.\n",
bufp, ifname, errno);
return(-1);
}
/* Store new MAC address */
memcpy((char *) sap,
(char *) &(arp_query.arp_ha),
sizeof(struct sockaddr));
#ifdef DEBUG
{
char buf[20];
printf("IP Address %s => Hw Address = %s\n",
bufp, iw_saether_ntop(sap, buf));
}
#endif
}
else /* If it's an hardware address */
{
/* Check if we have valid mac address type */
if(iw_check_mac_addr_type(skfd, ifname) < 0)
{
fprintf(stderr, "%-8.16s Interface doesn't support MAC addresses\n", ifname);
return(-1);
}
/* Get the hardware address */
if(iw_saether_aton(bufp, sap) == 0)
{
fprintf(stderr, "Invalid hardware address %s\n", bufp);
return(-1);
}
}
#ifdef DEBUG
{
char buf[20];
printf("Hw Address = %s\n", iw_saether_ntop(sap, buf));
}
#endif
return(0);
}
/*
* Print one element from the scanning results
*/
static inline int
print_event_token(struct iw_event * event, /* Extracted token */
struct iw_range * iw_range, /* Range info */
int has_range)
{
char buffer[128]; /* Temporary buffer */
char buffer2[30]; /* Temporary buffer */
char * prefix = (IW_IS_GET(event->cmd) ? "New" : "Set");
/* Now, let's decode the event */
switch(event->cmd)
{
/* ----- set events ----- */
/* Events that result from a "SET XXX" operation by the user */
case SIOCSIWNWID:
if(event->u.nwid.disabled)
printf("Set NWID:off/any\n");
else
printf("Set NWID:%X\n", event->u.nwid.value);
break;
case SIOCSIWFREQ:
case SIOCGIWFREQ:
{
double freq; /* Frequency/channel */
int channel = -1; /* Converted to channel */
freq = iw_freq2float(&(event->u.freq));
if(has_range)
{
if(freq < KILO)
/* Convert channel to frequency if possible */
channel = iw_channel_to_freq((int) freq, &freq, iw_range);
else
/* Convert frequency to channel if possible */
channel = iw_freq_to_channel(freq, iw_range);
}
iw_print_freq(buffer, sizeof(buffer),
freq, channel, event->u.freq.flags);
printf("%s %s\n", prefix, buffer);
}
break;
case SIOCSIWMODE:
printf("Set Mode:%s\n",
iw_operation_mode[event->u.mode]);
break;
case SIOCSIWESSID:
case SIOCGIWESSID:
{
char essid[IW_ESSID_MAX_SIZE+1];
memset(essid, '\0', sizeof(essid));
if((event->u.essid.pointer) && (event->u.essid.length))
memcpy(essid, event->u.essid.pointer, event->u.essid.length);
if(event->u.essid.flags)
{
/* Does it have an ESSID index ? */
if((event->u.essid.flags & IW_ENCODE_INDEX) > 1)
printf("%s ESSID:\"%s\" [%d]\n", prefix, essid,
(event->u.essid.flags & IW_ENCODE_INDEX));
else
printf("%s ESSID:\"%s\"\n", prefix, essid);
}
else
printf("%s ESSID:off/any\n", prefix);
}
break;
case SIOCSIWENCODE:
{
unsigned char key[IW_ENCODING_TOKEN_MAX];
if(event->u.data.pointer)
memcpy(key, event->u.data.pointer, event->u.data.length);
else
event->u.data.flags |= IW_ENCODE_NOKEY;
printf("Set Encryption key:");
if(event->u.data.flags & IW_ENCODE_DISABLED)
printf("off\n");
else
{
/* Display the key */
iw_print_key(buffer, sizeof(buffer), key, event->u.data.length,
event->u.data.flags);
printf("%s", buffer);
/* Other info... */
if((event->u.data.flags & IW_ENCODE_INDEX) > 1)
printf(" [%d]", event->u.data.flags & IW_ENCODE_INDEX);
if(event->u.data.flags & IW_ENCODE_RESTRICTED)
printf(" Security mode:restricted");
if(event->u.data.flags & IW_ENCODE_OPEN)
printf(" Security mode:open");
printf("\n");
}
}
break;
/* ----- driver events ----- */
/* Events generated by the driver when something important happens */
case SIOCGIWAP:
printf("New Access Point/Cell address:%s\n",
iw_sawap_ntop(&event->u.ap_addr, buffer));
break;
case SIOCGIWSCAN:
printf("Scan request completed\n");
break;
case IWEVTXDROP:
printf("Tx packet dropped:%s\n",
iw_saether_ntop(&event->u.addr, buffer));
break;
case IWEVCUSTOM:
{
char custom[IW_CUSTOM_MAX+1];
memset(custom, '\0', sizeof(custom));
if((event->u.data.pointer) && (event->u.data.length))
memcpy(custom, event->u.data.pointer, event->u.data.length);
printf("Custom driver event:%s\n", custom);
}
break;
case IWEVREGISTERED:
printf("Registered node:%s\n",
iw_saether_ntop(&event->u.addr, buffer));
break;
case IWEVEXPIRED:
printf("Expired node:%s\n",
iw_saether_ntop(&event->u.addr, buffer));
break;
case SIOCGIWTHRSPY:
{
struct iw_thrspy threshold;
if((event->u.data.pointer) && (event->u.data.length))
{
memcpy(&threshold, event->u.data.pointer,
sizeof(struct iw_thrspy));
printf("Spy threshold crossed on address:%s\n",
iw_saether_ntop(&threshold.addr, buffer));
iw_print_stats(buffer, sizeof(buffer),
&threshold.qual, iw_range, has_range);
printf(" Link %s\n", buffer);
}
else
printf("Invalid Spy Threshold event\n");
}
break;
/* ----- driver WPA events ----- */
/* Events generated by the driver, used for WPA operation */
case IWEVMICHAELMICFAILURE:
if(event->u.data.length >= sizeof(struct iw_michaelmicfailure))
{
struct iw_michaelmicfailure mf;
memcpy(&mf, event->u.data.pointer, sizeof(mf));
printf("Michael MIC failure flags:0x%X src_addr:%s tsc:%s\n",
mf.flags,
iw_saether_ntop(&mf.src_addr, buffer2),
iw_hexdump(buffer, sizeof(buffer),
mf.tsc, IW_ENCODE_SEQ_MAX_SIZE));
}
break;
case IWEVASSOCREQIE:
printf("Association Request IEs:%s\n",
iw_hexdump(buffer, sizeof(buffer),
event->u.data.pointer, event->u.data.length));
break;
case IWEVASSOCRESPIE:
printf("Association Response IEs:%s\n",
iw_hexdump(buffer, sizeof(buffer),
event->u.data.pointer, event->u.data.length));
break;
case IWEVPMKIDCAND:
if(event->u.data.length >= sizeof(struct iw_pmkid_cand))
{
struct iw_pmkid_cand cand;
memcpy(&cand, event->u.data.pointer, sizeof(cand));
printf("PMKID candidate flags:0x%X index:%d bssid:%s\n",
cand.flags, cand.index,
iw_saether_ntop(&cand.bssid, buffer));
}
break;
/* ----- junk ----- */
/* other junk not currently in use */
case SIOCGIWRATE:
iw_print_bitrate(buffer, sizeof(buffer), event->u.bitrate.value);
printf("New Bit Rate:%s\n", buffer);
break;
case SIOCGIWNAME:
printf("Protocol:%-1.16s\n", event->u.name);
break;
case IWEVQUAL:
{
event->u.qual.updated = 0x0; /* Not that reliable, disable */
iw_print_stats(buffer, sizeof(buffer),
&event->u.qual, iw_range, has_range);
printf("Link %s\n", buffer);
break;
}
default:
printf("(Unknown Wireless event 0x%04X)\n", event->cmd);
} /* switch(event->cmd) */
return(0);
}
/*
* Display the spy list of addresses and the associated stats
*/
static int
print_spy_info(int skfd,
char * ifname,
char * args[],
int count)
{
struct iwreq wrq;
char buffer[(sizeof(struct iw_quality) +
sizeof(struct sockaddr)) * IW_MAX_SPY];
char temp[128];
struct sockaddr * hwa;
struct iw_quality * qual;
iwrange range;
int has_range = 0;
int n;
int i;
/* Avoid "Unused parameter" warning */
args = args; count = count;
/* Collect stats */
wrq.u.data.pointer = (caddr_t) buffer;
wrq.u.data.length = IW_MAX_SPY;
wrq.u.data.flags = 0;
if(iw_get_ext(skfd, ifname, SIOCGIWSPY, &wrq) < 0)
{
fprintf(stderr, "%-8.16s Interface doesn't support wireless statistic collection\n\n", ifname);
return(-1);
}
/* Number of addresses */
n = wrq.u.data.length;
/* Check if we have valid mac address type */
if(iw_check_mac_addr_type(skfd, ifname) < 0)
{
fprintf(stderr, "%-8.16s Interface doesn't support MAC addresses\n\n", ifname);
return(-2);
}
/* Get range info if we can */
if(iw_get_range_info(skfd, ifname, &(range)) >= 0)
has_range = 1;
/* Display it */
if(n == 0)
printf("%-8.16s No statistics to collect\n", ifname);
else
printf("%-8.16s Statistics collected:\n", ifname);
/* The two lists */
hwa = (struct sockaddr *) buffer;
qual = (struct iw_quality *) (buffer + (sizeof(struct sockaddr) * n));
for(i = 0; i < n; i++)
{
/* Print stats for each address */
printf(" %s : ", iw_saether_ntop(&hwa[i], temp));
iw_print_stats(temp, sizeof(temp), &qual[i], &range, has_range);
printf("%s\n", temp);
}
if((n > 0) && (has_range) && (range.we_version_compiled > 11))
{
iwstats stats;
/* Get /proc/net/wireless */
if(iw_get_stats(skfd, ifname, &stats, &range, has_range) >= 0)
{
iw_print_stats(temp, sizeof(temp), &stats.qual, &range, has_range);
printf(" Link/Cell/AP : %s\n", temp);
/* Display the static data */
iw_print_stats(temp, sizeof(temp),
&range.avg_qual, &range, has_range);
printf(" Typical/Reference : %s\n", temp);
}
}
printf("\n");
return(0);
}
/*
* Print one element from the scanning results
*/
static inline void
print_scanning_token(struct stream_descr * stream, /* Stream of events */
struct iw_event * event, /* Extracted token */
struct iwscan_state * state,
struct iw_range * iw_range, /* Range info */
int has_range)
{
char buffer[128]; /* Temporary buffer */
/* Now, let's decode the event */
switch(event->cmd)
{
case SIOCGIWAP:
printf(" Cell %02d - Address: %s\n", state->ap_num,
iw_saether_ntop(&event->u.ap_addr, buffer));
state->ap_num++;
break;
case SIOCGIWNWID:
if(event->u.nwid.disabled)
printf(" NWID:off/any\n");
else
printf(" NWID:%X\n", event->u.nwid.value);
break;
case SIOCGIWFREQ:
{
double freq; /* Frequency/channel */
int channel = -1; /* Converted to channel */
freq = iw_freq2float(&(event->u.freq));
/* Convert to channel if possible */
if(has_range)
channel = iw_freq_to_channel(freq, iw_range);
iw_print_freq(buffer, sizeof(buffer),
freq, channel, event->u.freq.flags);
printf(" %s\n", buffer);
}
break;
case SIOCGIWMODE:
printf(" Mode:%s\n",
iw_operation_mode[event->u.mode]);
break;
case SIOCGIWNAME:
printf(" Protocol:%-1.16s\n", event->u.name);
break;
case SIOCGIWESSID:
{
char essid[IW_ESSID_MAX_SIZE+1];
memset(essid, '\0', sizeof(essid));
if((event->u.essid.pointer) && (event->u.essid.length))
memcpy(essid, event->u.essid.pointer, event->u.essid.length);
if(event->u.essid.flags)
{
/* Does it have an ESSID index ? */
if((event->u.essid.flags & IW_ENCODE_INDEX) > 1)
printf(" ESSID:\"%s\" [%d]\n", essid,
(event->u.essid.flags & IW_ENCODE_INDEX));
else
printf(" ESSID:\"%s\"\n", essid);
}
else
printf(" ESSID:off/any/hidden\n");
}
break;
case SIOCGIWENCODE:
{
unsigned char key[IW_ENCODING_TOKEN_MAX];
if(event->u.data.pointer)
memcpy(key, event->u.data.pointer, event->u.data.length);
else
event->u.data.flags |= IW_ENCODE_NOKEY;
printf(" Encryption key:");
if(event->u.data.flags & IW_ENCODE_DISABLED)
printf("off\n");
else
{
/* Display the key */
iw_print_key(buffer, sizeof(buffer), key, event->u.data.length,
event->u.data.flags);
printf("%s", buffer);
/* Other info... */
if((event->u.data.flags & IW_ENCODE_INDEX) > 1)
printf(" [%d]", event->u.data.flags & IW_ENCODE_INDEX);
if(event->u.data.flags & IW_ENCODE_RESTRICTED)
printf(" Security mode:restricted");
if(event->u.data.flags & IW_ENCODE_OPEN)
printf(" Security mode:open");
printf("\n");
}
}
break;
case SIOCGIWRATE:
if(state->val_index == 0)
printf(" Bit Rates:");
else
if((state->val_index % 5) == 0)
printf("\n ");
else
printf("; ");
iw_print_bitrate(buffer, sizeof(buffer), event->u.bitrate.value);
printf("%s", buffer);
/* Check for termination */
if(stream->value == NULL)
{
printf("\n");
state->val_index = 0;
}
else
state->val_index++;
break;
case IWEVQUAL:
{
iw_print_stats(buffer, sizeof(buffer),
&event->u.qual, iw_range, has_range);
printf(" %s\n", buffer);
break;
}
case IWEVGENIE:
/* Informations Elements are complex, let's do only some of them */
iw_print_gen_ie(event->u.data.pointer, event->u.data.length);
break;
case IWEVCUSTOM:
{
char custom[IW_CUSTOM_MAX+1];
if((event->u.data.pointer) && (event->u.data.length))
memcpy(custom, event->u.data.pointer, event->u.data.length);
custom[event->u.data.length] = '\0';
printf(" Extra:%s\n", custom);
}
break;
default:
printf(" (Unknown Wireless Token 0x%04X)\n",
event->cmd);
} /* switch(event->cmd) */
}
/*
* Display the list of ap addresses and the associated stats
* Exacly the same as the spy list, only with different IOCTL and messages
*/
static int
print_ap_info(int skfd,
char * ifname,
char * args[], /* Command line args */
int count) /* Args count */
{
struct iwreq wrq;
char buffer[(sizeof(struct iw_quality) +
sizeof(struct sockaddr)) * IW_MAX_AP];
char temp[128];
struct sockaddr * hwa;
struct iw_quality * qual;
iwrange range;
int has_range = 0;
int has_qual = 0;
int n;
int i;
/* Avoid "Unused parameter" warning */
args = args; count = count;
/* Collect stats */
wrq.u.data.pointer = (caddr_t) buffer;
wrq.u.data.length = IW_MAX_AP;
wrq.u.data.flags = 0;
if(iw_get_ext(skfd, ifname, SIOCGIWAPLIST, &wrq) < 0)
{
fprintf(stderr, "%-8.16s Interface doesn't have a list of Peers/Access-Points\n\n", ifname);
return(-1);
}
/* Number of addresses */
n = wrq.u.data.length;
has_qual = wrq.u.data.flags;
/* The two lists */
hwa = (struct sockaddr *) buffer;
qual = (struct iw_quality *) (buffer + (sizeof(struct sockaddr) * n));
/* Check if we have valid mac address type */
if(iw_check_mac_addr_type(skfd, ifname) < 0)
{
fprintf(stderr, "%-8.16s Interface doesn't support MAC addresses\n\n", ifname);
return(-2);
}
/* Get range info if we can */
if(iw_get_range_info(skfd, ifname, &(range)) >= 0)
has_range = 1;
/* Display it */
if(n == 0)
printf("%-8.16s No Peers/Access-Point in range\n", ifname);
else
printf("%-8.16s Peers/Access-Points in range:\n", ifname);
for(i = 0; i < n; i++)
{
if(has_qual)
{
/* Print stats for this address */
printf(" %s : ", iw_saether_ntop(&hwa[i], temp));
iw_print_stats(temp, sizeof(buffer), &qual[i], &range, has_range);
printf("%s\n", temp);
}
else
/* Only print the address */
printf(" %s\n", iw_saether_ntop(&hwa[i], temp));
}
printf("\n");
return(0);
}
