int connect_wifi()
{
struct iwreq wrq;
char essid[IW_ESSID_MAX_SIZE + 1];
unsigned char key[IW_ENCODING_TOKEN_MAX];
int32_t keylen = 0;
int wlsock = iw_sockets_open();
const char *itfName = "wlan0";
const char *networkName = "linksys";
const char *com_key = "9F1C3EE11CBA230B27BF1C1B6F";
if(wlsock < 0)
return -1;
memset(&wrq,0,sizeof(struct iwreq));
keylen = iw_in_key_full(wlsock, itfName, com_key, key, &wrq.u.data.flags);
if(keylen <= 0)
return -1;
wrq.u.data.length = keylen;
wrq.u.data.pointer = (caddr_t) key;
wrq.u.data.flags |= IW_ENCODE_RESTRICTED;
if(iw_set_ext(wlsock, itfName, SIOCSIWENCODE, &wrq) < 0)
return -1;
memset(&wrq,0,sizeof(struct iwreq));
wrq.u.mode = IW_MODE_INFRA;
if(iw_set_ext( wlsock, itfName, SIOCSIWMODE, &wrq) < 0)
return -1;
if(strlen(networkName) > IW_ESSID_MAX_SIZE)
return -1;
memset(essid,0,IW_ESSID_MAX_SIZE + 1);
memset(&wrq,0,sizeof(struct iwreq));
strncpy(essid,networkName,strlen(networkName));
wrq.u.essid.flags = 1;
wrq.u.essid.pointer = (caddr_t) essid;
wrq.u.essid.length = strlen(essid) + 1;
if(iw_set_ext( wlsock, itfName, SIOCSIWESSID, &wrq) < 0)
return -1;
iw_sockets_close(wlsock);
return 0;
}
/*
* Set encryption
*/
static int
set_enc_info(int skfd,
char * ifname,
char * args[], /* Command line args */
int count) /* Args count */
{
struct iwreq wrq;
int i = 1;
unsigned char key[IW_ENCODING_TOKEN_MAX];
if(!strcasecmp(args[0], "on"))
{
/* Get old encryption information */
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, ifname, SIOCGIWENCODE, &wrq) < 0)
return(IWERR_GET_EXT);
wrq.u.data.flags &= ~IW_ENCODE_DISABLED; /* Enable */
}
else
{
int gotone = 0;
int oldone;
int keylen;
int temp;
wrq.u.data.pointer = (caddr_t) NULL;
wrq.u.data.flags = 0;
wrq.u.data.length = 0;
i = 0;
/* Allow arguments in any order (it's safe) */
do
{
oldone = gotone;
/* -- Check for the key -- */
if(i < count)
{
keylen = iw_in_key_full(skfd, ifname,
args[i], key, &wrq.u.data.flags);
if(keylen > 0)
{
wrq.u.data.length = keylen;
wrq.u.data.pointer = (caddr_t) key;
++i;
gotone++;
}
}
/* -- Check for token index -- */
if((i < count) &&
(sscanf(args[i], "[%i]", &temp) == 1) &&
(temp > 0) && (temp < IW_ENCODE_INDEX))
{
wrq.u.encoding.flags |= temp;
++i;
gotone++;
}
/* -- Check the various flags -- */
if((i < count) && (!strcasecmp(args[i], "off")))
{
wrq.u.data.flags |= IW_ENCODE_DISABLED;
++i;
gotone++;
}
if((i < count) && (!strcasecmp(args[i], "open")))
{
wrq.u.data.flags |= IW_ENCODE_OPEN;
++i;
gotone++;
}
if((i < count) && (!strncasecmp(args[i], "restricted", 5)))
{
wrq.u.data.flags |= IW_ENCODE_RESTRICTED;
++i;
gotone++;
}
if((i < count) && (!strncasecmp(args[i], "temporary", 4)))
{
wrq.u.data.flags |= IW_ENCODE_TEMP;
++i;
gotone++;
}
}
while(gotone != oldone);
/* Pointer is absent in new API */
if(wrq.u.data.pointer == NULL)
wrq.u.data.flags |= IW_ENCODE_NOKEY;
/* Check if we have any invalid argument */
if(!gotone)
{
errarg = 0;
return(IWERR_ARG_TYPE);
}
}
if(iw_set_ext(skfd, ifname, SIOCSIWENCODE, &wrq) < 0)
return(IWERR_SET_EXT);
/* Var arg */
return(i);
}
/*
* Set the wireless options requested on command line
* This function is too long and probably should be split,
* because it look like the perfect definition of spaghetti code,
* but I'm way to lazy
*/
static int
set_info(int skfd, /* The socket */
char * args[], /* Command line args */
int count, /* Args count */
char * ifname) /* Dev name */
{
struct iwreq wrq;
int i;
/* if nothing after the device name - will never happen */
if(count < 1)
{
fprintf(stderr, "Error : too few arguments.\n");
return(-1);
}
/* The other args on the line specify options to be set... */
for(i = 0; i < count; i++)
{
/* ---------- Commit changes to driver ---------- */
if(!strncmp(args[i], "commit", 6))
{
/* No args */
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWCOMMIT, &wrq,
"Commit changes");
continue;
}
/* ---------- Set network ID ---------- */
if((!strcasecmp(args[i], "nwid")) ||
(!strcasecmp(args[i], "domain")))
{
i++;
if(i >= count)
ABORT_ARG_NUM("Set NWID", SIOCSIWNWID);
if((!strcasecmp(args[i], "off")) ||
(!strcasecmp(args[i], "any")))
wrq.u.nwid.disabled = 1;
else
if(!strcasecmp(args[i], "on"))
{
/* Get old nwid */
IW_GET_EXT_ERR(skfd, ifname, SIOCGIWNWID, &wrq,
"Set NWID");
wrq.u.nwid.disabled = 0;
}
else
if(sscanf(args[i], "%lX", (unsigned long *) &(wrq.u.nwid.value))
!= 1)
ABORT_ARG_TYPE("Set NWID", SIOCSIWNWID, args[i]);
else
wrq.u.nwid.disabled = 0;
wrq.u.nwid.fixed = 1;
/* Set new nwid */
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWNWID, &wrq,
"Set NWID");
continue;
}
/* ---------- Set frequency / channel ---------- */
if((!strncmp(args[i], "freq", 4)) ||
(!strcmp(args[i], "channel")))
{
double freq;
if(++i >= count)
ABORT_ARG_NUM("Set Frequency", SIOCSIWFREQ);
if(sscanf(args[i], "%lg", &(freq)) != 1)
ABORT_ARG_TYPE("Set Frequency", SIOCSIWFREQ, args[i]);
if(index(args[i], 'G')) freq *= GIGA;
if(index(args[i], 'M')) freq *= MEGA;
if(index(args[i], 'k')) freq *= KILO;
iw_float2freq(freq, &(wrq.u.freq));
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWFREQ, &wrq,
"Set Frequency");
continue;
}
/* ---------- Set sensitivity ---------- */
if(!strncmp(args[i], "sens", 4))
{
if(++i >= count)
ABORT_ARG_NUM("Set Sensitivity", SIOCSIWSENS);
if(sscanf(args[i], "%i", &(wrq.u.sens.value)) != 1)
ABORT_ARG_TYPE("Set Sensitivity", SIOCSIWSENS, args[i]);
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWSENS, &wrq,
"Set Sensitivity");
continue;
}
/* ---------- Set encryption stuff ---------- */
if((!strncmp(args[i], "enc", 3)) ||
(!strcmp(args[i], "key")))
{
unsigned char key[IW_ENCODING_TOKEN_MAX];
if(++i >= count)
ABORT_ARG_NUM("Set Encode", SIOCSIWENCODE);
if(!strcasecmp(args[i], "on"))
{
/* Get old encryption information */
wrq.u.data.pointer = (caddr_t) key;
wrq.u.data.length = IW_ENCODING_TOKEN_MAX;
wrq.u.data.flags = 0;
IW_GET_EXT_ERR(skfd, ifname, SIOCGIWENCODE, &wrq,
"Set Encode");
wrq.u.data.flags &= ~IW_ENCODE_DISABLED; /* Enable */
}
else
{
int gotone = 0;
int oldone;
int keylen;
int temp;
wrq.u.data.pointer = (caddr_t) NULL;
wrq.u.data.flags = 0;
wrq.u.data.length = 0;
/* Allow arguments in any order (it's safe) */
do
{
oldone = gotone;
/* -- Check for the key -- */
if(i < count)
{
keylen = iw_in_key_full(skfd, ifname,
args[i], key, &wrq.u.data.flags);
if(keylen > 0)
{
wrq.u.data.length = keylen;
wrq.u.data.pointer = (caddr_t) key;
++i;
gotone++;
}
}
/* -- Check for token index -- */
if((i < count) &&
(sscanf(args[i], "%i", &temp) == 1) &&
(temp > 0) && (temp < IW_ENCODE_INDEX))
{
wrq.u.encoding.flags |= temp;
++i;
gotone++;
}
/* -- Check the various flags -- */
if((i < count) && (!strcasecmp(args[i], "off")))
{
wrq.u.data.flags |= IW_ENCODE_DISABLED;
++i;
gotone++;
}
if((i < count) && (!strcasecmp(args[i], "open")))
{
wrq.u.data.flags |= IW_ENCODE_OPEN;
++i;
gotone++;
}
if((i < count) && (!strncasecmp(args[i], "restricted", 5)))
{
wrq.u.data.flags |= IW_ENCODE_RESTRICTED;
++i;
gotone++;
}
#if WIRELESS_EXT > 15
if((i < count) && (!strncasecmp(args[i], "temporary", 4)))
{
wrq.u.data.flags |= IW_ENCODE_TEMP;
++i;
gotone++;
}
#endif
}
while(gotone != oldone);
/* Pointer is absent in new API */
if(wrq.u.data.pointer == NULL)
wrq.u.data.flags |= IW_ENCODE_NOKEY;
/* Check if we have any invalid argument */
if(!gotone)
ABORT_ARG_TYPE("Set Encode", SIOCSIWENCODE, args[i]);
/* Get back to last processed argument */
--i;
}
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWENCODE, &wrq,
"Set Encode");
continue;
}
/* ---------- Set ESSID ---------- */
if(!strcasecmp(args[i], "essid"))
{
char essid[IW_ESSID_MAX_SIZE + 1];
i++;
if(i >= count)
ABORT_ARG_NUM("Set ESSID", SIOCSIWESSID);
if((!strcasecmp(args[i], "off")) ||
(!strcasecmp(args[i], "any")))
{
wrq.u.essid.flags = 0;
essid[0] = '\0';
}
else
if(!strcasecmp(args[i], "on"))
{
/* Get old essid */
wrq.u.essid.pointer = (caddr_t) essid;
wrq.u.essid.length = IW_ESSID_MAX_SIZE + 1;
wrq.u.essid.flags = 0;
IW_GET_EXT_ERR(skfd, ifname, SIOCGIWESSID, &wrq,
"Set ESSID");
wrq.u.essid.flags = 1;
}
else
{
/* '-' allow to escape the ESSID string, allowing
* to set it to the string "any" or "off".
* This is a big ugly, but it will do for now */
if(!strcmp(args[i], "-"))
{
i++;
if(i >= count)
ABORT_ARG_NUM("Set ESSID", SIOCSIWESSID);
}
/* Check the size of what the user passed us to avoid
* buffer overflows */
if(strlen(args[i]) > IW_ESSID_MAX_SIZE)
ABORT_ARG_SIZE("Set ESSID", SIOCSIWESSID, IW_ESSID_MAX_SIZE);
else
{
int temp;
wrq.u.essid.flags = 1;
strcpy(essid, args[i]); /* Size checked, all clear */
/* Check for ESSID index */
if(((i+1) < count) &&
(sscanf(args[i+1], "[%i]", &temp) == 1) &&
(temp > 0) && (temp < IW_ENCODE_INDEX))
{
wrq.u.essid.flags = temp;
++i;
}
}
}
wrq.u.essid.pointer = (caddr_t) essid;
wrq.u.essid.length = strlen(essid) + 1;
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWESSID, &wrq,
"Set ESSID");
continue;
}
/* ---------- Set AP address ---------- */
if(!strcasecmp(args[i], "ap"))
{
if(++i >= count)
ABORT_ARG_NUM("Set AP Address", SIOCSIWAP);
if((!strcasecmp(args[i], "auto")) ||
(!strcasecmp(args[i], "any")))
{
/* Send a broadcast address */
iw_broad_ether(&(wrq.u.ap_addr));
}
else
{
if(!strcasecmp(args[i], "off"))
{
/* Send a NULL address */
iw_null_ether(&(wrq.u.ap_addr));
}
else
{
/* Get the address and check if the interface supports it */
if(iw_in_addr(skfd, ifname, args[i++], &(wrq.u.ap_addr)) < 0)
ABORT_ARG_TYPE("Set AP Address", SIOCSIWAP, args[i-1]);
}
}
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWAP, &wrq,
"Set AP Address");
continue;
}
/* ---------- Set NickName ---------- */
if(!strncmp(args[i], "nick", 4))
{
i++;
if(i >= count)
ABORT_ARG_NUM("Set Nickname", SIOCSIWNICKN);
if(strlen(args[i]) > IW_ESSID_MAX_SIZE)
ABORT_ARG_SIZE("Set Nickname", SIOCSIWNICKN, IW_ESSID_MAX_SIZE);
wrq.u.essid.pointer = (caddr_t) args[i];
wrq.u.essid.length = strlen(args[i]) + 1;
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWNICKN, &wrq,
"Set Nickname");
continue;
}
/* ---------- Set Bit-Rate ---------- */
if((!strncmp(args[i], "bit", 3)) ||
(!strcmp(args[i], "rate")))
{
if(++i >= count)
ABORT_ARG_NUM("Set Bit Rate", SIOCSIWRATE);
if(!strcasecmp(args[i], "auto"))
{
wrq.u.bitrate.value = -1;
wrq.u.bitrate.fixed = 0;
}
else
{
if(!strcasecmp(args[i], "fixed"))
{
/* Get old bitrate */
IW_GET_EXT_ERR(skfd, ifname, SIOCGIWRATE, &wrq,
"Set Bit Rate");
wrq.u.bitrate.fixed = 1;
}
else /* Should be a numeric value */
{
double brate;
if(sscanf(args[i], "%lg", &(brate)) != 1)
ABORT_ARG_TYPE("Set Bit Rate", SIOCSIWRATE, args[i]);
if(index(args[i], 'G')) brate *= GIGA;
if(index(args[i], 'M')) brate *= MEGA;
if(index(args[i], 'k')) brate *= KILO;
wrq.u.bitrate.value = (long) brate;
wrq.u.bitrate.fixed = 1;
/* Check for an additional argument */
if(((i+1) < count) &&
(!strcasecmp(args[i+1], "auto")))
{
wrq.u.bitrate.fixed = 0;
++i;
}
if(((i+1) < count) &&
(!strcasecmp(args[i+1], "fixed")))
{
wrq.u.bitrate.fixed = 1;
++i;
}
}
}
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWRATE, &wrq,
"Set Bit Rate");
continue;
}
/* ---------- Set RTS threshold ---------- */
if(!strncasecmp(args[i], "rts", 3))
{
i++;
if(i >= count)
ABORT_ARG_NUM("Set RTS Threshold", SIOCSIWRTS);
wrq.u.rts.value = -1;
wrq.u.rts.fixed = 1;
wrq.u.rts.disabled = 0;
if(!strcasecmp(args[i], "off"))
wrq.u.rts.disabled = 1; /* i.e. max size */
else
if(!strcasecmp(args[i], "auto"))
wrq.u.rts.fixed = 0;
else
{
if(!strcasecmp(args[i], "fixed"))
{
/* Get old RTS threshold */
IW_GET_EXT_ERR(skfd, ifname, SIOCGIWRTS, &wrq,
"Set RTS Threshold");
wrq.u.rts.fixed = 1;
}
else /* Should be a numeric value */
if(sscanf(args[i], "%li", (unsigned long *) &(wrq.u.rts.value))
!= 1)
ABORT_ARG_TYPE("Set RTS Threshold", SIOCSIWRTS, args[i]);
}
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWRTS, &wrq,
"Set RTS Threshold");
continue;
}
/* ---------- Set fragmentation threshold ---------- */
if(!strncmp(args[i], "frag", 4))
{
i++;
if(i >= count)
ABORT_ARG_NUM("Set Fragmentation Threshold", SIOCSIWFRAG);
wrq.u.frag.value = -1;
wrq.u.frag.fixed = 1;
wrq.u.frag.disabled = 0;
if(!strcasecmp(args[i], "off"))
wrq.u.frag.disabled = 1; /* i.e. max size */
else
if(!strcasecmp(args[i], "auto"))
wrq.u.frag.fixed = 0;
else
{
if(!strcasecmp(args[i], "fixed"))
{
/* Get old fragmentation threshold */
IW_GET_EXT_ERR(skfd, ifname, SIOCGIWFRAG, &wrq,
"Set Fragmentation Threshold");
wrq.u.frag.fixed = 1;
}
else /* Should be a numeric value */
if(sscanf(args[i], "%li",
(unsigned long *) &(wrq.u.frag.value))
!= 1)
ABORT_ARG_TYPE("Set Fragmentation Threshold", SIOCSIWFRAG,
args[i]);
}
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWFRAG, &wrq,
"Set Fragmentation Threshold");
continue;
}
/* ---------- Set operation mode ---------- */
if(!strcmp(args[i], "mode"))
{
int k;
i++;
if(i >= count)
ABORT_ARG_NUM("Set Mode", SIOCSIWMODE);
if(sscanf(args[i], "%i", &k) != 1)
{
k = 0;
while((k < IW_NUM_OPER_MODE) &&
strncasecmp(args[i], iw_operation_mode[k], 3))
k++;
}
if((k >= IW_NUM_OPER_MODE) || (k < 0))
ABORT_ARG_TYPE("Set Mode", SIOCSIWMODE, args[i]);
wrq.u.mode = k;
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWMODE, &wrq,
"Set Mode");
continue;
}
/* ---------- Set Power Management ---------- */
if(!strncmp(args[i], "power", 3))
{
if(++i >= count)
ABORT_ARG_NUM("Set Power Management", SIOCSIWPOWER);
if(!strcasecmp(args[i], "off"))
wrq.u.power.disabled = 1; /* i.e. max size */
else
if(!strcasecmp(args[i], "on"))
{
/* Get old Power info */
IW_GET_EXT_ERR(skfd, ifname, SIOCGIWPOWER, &wrq,
"Set Power Management");
wrq.u.power.disabled = 0;
}
else
{
double temp;
int gotone = 0;
/* Default - nope */
wrq.u.power.flags = IW_POWER_ON;
wrq.u.power.disabled = 0;
/* Check value modifier */
if(!strcasecmp(args[i], "min"))
{
wrq.u.power.flags |= IW_POWER_MIN;
if(++i >= count)
ABORT_ARG_NUM("Set Power Management", SIOCSIWPOWER);
}
else
if(!strcasecmp(args[i], "max"))
{
wrq.u.power.flags |= IW_POWER_MAX;
if(++i >= count)
ABORT_ARG_NUM("Set Power Management", SIOCSIWPOWER);
}
/* Check value type */
if(!strcasecmp(args[i], "period"))
{
wrq.u.power.flags |= IW_POWER_PERIOD;
if(++i >= count)
ABORT_ARG_NUM("Set Power Management", SIOCSIWPOWER);
}
else
if(!strcasecmp(args[i], "timeout"))
{
wrq.u.power.flags |= IW_POWER_TIMEOUT;
if(++i >= count)
ABORT_ARG_NUM("Set Power Management", SIOCSIWPOWER);
}
/* Is there any value to grab ? */
if(sscanf(args[i], "%lg", &(temp)) == 1)
{
temp *= MEGA; /* default = s */
if(index(args[i], 'u')) temp /= MEGA;
if(index(args[i], 'm')) temp /= KILO;
wrq.u.power.value = (long) temp;
if((wrq.u.power.flags & IW_POWER_TYPE) == 0)
wrq.u.power.flags |= IW_POWER_PERIOD;
++i;
gotone = 1;
}
/* Now, check the mode */
if(i < count)
{
if(!strcasecmp(args[i], "all"))
wrq.u.power.flags |= IW_POWER_ALL_R;
if(!strncasecmp(args[i], "unicast", 4))
wrq.u.power.flags |= IW_POWER_UNICAST_R;
if(!strncasecmp(args[i], "multicast", 5))
wrq.u.power.flags |= IW_POWER_MULTICAST_R;
if(!strncasecmp(args[i], "force", 5))
wrq.u.power.flags |= IW_POWER_FORCE_S;
if(!strcasecmp(args[i], "repeat"))
wrq.u.power.flags |= IW_POWER_REPEATER;
if(wrq.u.power.flags & IW_POWER_MODE)
{
++i;
gotone = 1;
}
}
if(!gotone)
ABORT_ARG_TYPE("Set Power Management", SIOCSIWPOWER,
args[i]);
--i;
}
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWPOWER, &wrq,
"Set Power Management");
continue;
}
#if WIRELESS_EXT > 9
/* ---------- Set Transmit-Power ---------- */
if(!strncmp(args[i], "txpower", 3))
{
struct iw_range range;
if(++i >= count)
ABORT_ARG_NUM("Set Tx Power", SIOCSIWTXPOW);
/* Extract range info */
if(iw_get_range_info(skfd, ifname, &range) < 0)
memset(&range, 0, sizeof(range));
/* Prepare the request */
wrq.u.txpower.value = -1;
wrq.u.txpower.fixed = 1;
wrq.u.txpower.disabled = 0;
wrq.u.data.flags = IW_TXPOW_DBM;
if(!strcasecmp(args[i], "off"))
wrq.u.txpower.disabled = 1; /* i.e. turn radio off */
else
if(!strcasecmp(args[i], "auto"))
wrq.u.txpower.fixed = 0; /* i.e. use power control */
else
{
if(!strcasecmp(args[i], "fixed"))
{
/* Get old tx-power */
IW_GET_EXT_ERR(skfd, ifname, SIOCGIWTXPOW, &wrq,
"Set Tx Power");
wrq.u.txpower.fixed = 1;
}
else /* Should be a numeric value */
{
int power;
int ismwatt = 0;
/* Get the value */
if(sscanf(args[i], "%i", &(power)) != 1)
ABORT_ARG_TYPE("Set Tx Power", SIOCSIWTXPOW, args[i]);
/* Check if milliwatt */
ismwatt = (index(args[i], 'm') != NULL);
/* Convert */
if(range.txpower_capa & IW_TXPOW_MWATT)
{
if(!ismwatt)
power = iw_dbm2mwatt(power);
wrq.u.data.flags = IW_TXPOW_MWATT;
}
else
{
if(ismwatt)
power = iw_mwatt2dbm(power);
wrq.u.data.flags = IW_TXPOW_DBM;
}
wrq.u.txpower.value = power;
/* Check for an additional argument */
if(((i+1) < count) &&
(!strcasecmp(args[i+1], "auto")))
{
wrq.u.txpower.fixed = 0;
++i;
}
if(((i+1) < count) &&
(!strcasecmp(args[i+1], "fixed")))
{
wrq.u.txpower.fixed = 1;
++i;
}
}
}
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWTXPOW, &wrq,
"Set Tx Power");
continue;
}
#endif
#if WIRELESS_EXT > 10
/* ---------- Set Retry limit ---------- */
if(!strncmp(args[i], "retry", 3))
{
double temp;
int gotone = 0;
if(++i >= count)
ABORT_ARG_NUM("Set Retry Limit", SIOCSIWRETRY);
/* Default - nope */
wrq.u.retry.flags = IW_RETRY_LIMIT;
wrq.u.retry.disabled = 0;
/* Check value modifier */
if(!strcasecmp(args[i], "min"))
{
wrq.u.retry.flags |= IW_RETRY_MIN;
if(++i >= count)
ABORT_ARG_NUM("Set Retry Limit", SIOCSIWRETRY);
}
else
if(!strcasecmp(args[i], "max"))
{
wrq.u.retry.flags |= IW_RETRY_MAX;
if(++i >= count)
ABORT_ARG_NUM("Set Retry Limit", SIOCSIWRETRY);
}
/* Check value type */
if(!strcasecmp(args[i], "limit"))
{
wrq.u.retry.flags |= IW_RETRY_LIMIT;
if(++i >= count)
ABORT_ARG_NUM("Set Retry Limit", SIOCSIWRETRY);
}
else
if(!strncasecmp(args[i], "lifetime", 4))
{
wrq.u.retry.flags &= ~IW_RETRY_LIMIT;
wrq.u.retry.flags |= IW_RETRY_LIFETIME;
if(++i >= count)
ABORT_ARG_NUM("Set Retry Limit", SIOCSIWRETRY);
}
/* Is there any value to grab ? */
if(sscanf(args[i], "%lg", &(temp)) == 1)
{
/* Limit is absolute, on the other hand lifetime is seconds */
if(!(wrq.u.retry.flags & IW_RETRY_LIMIT))
{
/* Normalise lifetime */
temp *= MEGA; /* default = s */
if(index(args[i], 'u')) temp /= MEGA;
if(index(args[i], 'm')) temp /= KILO;
}
wrq.u.retry.value = (long) temp;
++i;
gotone = 1;
}
if(!gotone)
ABORT_ARG_TYPE("Set Retry Limit", SIOCSIWRETRY, args[i]);
--i;
IW_SET_EXT_ERR(skfd, ifname, SIOCSIWRETRY, &wrq,
"Set Retry Limit");
continue;
}
#endif /* WIRELESS_EXT > 10 */
/* ---------- Other ---------- */
/* Here we have an unrecognised arg... */
fprintf(stderr, "Error : unrecognised wireless request \"%s\"\n",
args[i]);
return(-1);
} /* for(index ... */
return(0);
}