static int
lua_set_acllist(lua_State *L, void *wl, lua_cmd_t *cmd, char *buf)
{
struct maclist *maclist = (struct maclist *) buf;
struct ether_addr *ea;
uint max = (WLC_IOCTL_MAXLEN - sizeof(int)) / ETHER_ADDR_LEN;
char *nargv[128];
char **argv;
uint len;
cmd_split(buf, (char **)nargv, 128);
argv = (char **)nargv;
/* Clear list */
maclist->count = htod32(0);
ea = maclist->ea;
while (*argv && maclist->count < max)
{
if (!wl_ether_atoe(*argv, ea))
{
return -1;
}
maclist->count++;
ea++;
argv++;
}
/* Set new list */
len = sizeof(maclist->count) + maclist->count * sizeof(maclist->ea);
maclist->count = htod32(maclist->count);
return wlu_set(wl, WLC_SET_MACLIST, maclist, len);
}
static int
lua_ctl_scan(lua_State *L, void *wl, lua_cmd_t *cmd, char *argv)
{
int params_size = WL_SCAN_PARAMS_FIXED_SIZE + WL_NUMCHANNELS * sizeof(uint16);
wl_scan_params_t *params;
int err = 0;
params_size += WL_SCAN_PARAMS_SSID_MAX * sizeof(wlc_ssid_t);
params = (wl_scan_params_t*)malloc(params_size);
if (params == NULL) {
fprintf(stderr, "Error allocating %d bytes for scan params\n", params_size);
return -1;
}
memset(params, 0, params_size);
memcpy(¶ms->bssid, ðer_bcast, ETHER_ADDR_LEN);
params->bss_type = DOT11_BSSTYPE_ANY;
params->scan_type = 0;
params->nprobes = -1;
params->active_time = -1;
params->passive_time = -1;
params->home_time = -1;
params->channel_num = 0;
params_size = (char*)params->channel_list - (char*)params;
err = wlu_set(wl, WLC_SCAN, params, params_size);
free(params);
return err;
}
int wlmIoctlSet(int cmd, void *buf, int len)
{
if (wlu_set(irh, cmd, buf, len)) {
printf("wlmIoctlSet: %s\n", wlmLastError());
return FALSE;
}
return TRUE;
}
int wlmDisassociateNetwork(void)
{
if (wlu_set(irh, WLC_DISASSOC, NULL, 0) < 0) {
printf("wlmDisassociateNetwork: %s\n", wlmLastError());
return FALSE;
}
return TRUE;
}
int wl_wnm_bsstq(void *wl)
{
char *cmd = "wnm_bsstq";
int buflen = strlen(cmd) + 1;
strcpy(buf, cmd);
return wlu_set(wl, WLC_SET_VAR, buf, buflen);
}
int wlmEnableAdapterUp(int enable)
{
/* Enable/disable adapter */
if (enable)
{
if (wlu_set(irh, WLC_UP, NULL, 0)) {
printf("wlmEnableAdapterUp: %s\n", wlmLastError());
return FALSE;
}
}
else {
if (wlu_set(irh, WLC_DOWN, NULL, 0)) {
printf("wlmEnableAdapterUp: %s\n", wlmLastError());
return FALSE;
}
}
return TRUE;
}
int wlmJoinNetwork(const char* ssid, WLM_JOIN_MODE mode)
{
wlc_ssid_t wlcSsid;
int infra = htod32(mode);
if (wlu_set(irh, WLC_SET_INFRA, &infra, sizeof(int)) < 0) {
printf("wlmJoinNetwork: %s\n", wlmLastError());
return FALSE;
}
wlcSsid.SSID_len = htod32(strlen(ssid));
memcpy(wlcSsid.SSID, ssid, wlcSsid.SSID_len);
if (wlu_set(irh, WLC_SET_SSID, &wlcSsid, sizeof(wlc_ssid_t)) < 0) {
printf("wlmJoinNetwork: %s\n", wlmLastError());
return FALSE;
}
return TRUE;
}
int wlmEnableEVMTest(int enable, WLM_RATE rate, int channel)
{
int val[3] = {0};
val[1] = WLM_RATE_1M; /* default value */
if (enable) {
val[0] = htod32(channel);
val[1] = htod32(rate);
wlmEnableAdapterUp(1);
if (wlu_set(irh, WLC_OUT, NULL, 0) < 0) {
printf("wlmEnableEVMTest: %s\n", wlmLastError());
return FALSE;
}
}
if (wlu_set(irh, WLC_EVM, val, sizeof(val)) < 0) {
printf("wlmEnableEVMTest: %s\n", wlmLastError());
return FALSE;
}
return TRUE;
}
int wlmPreambleSet(WLM_PREAMBLE preamble)
{
preamble = htod32(preamble);
if (wlu_set(irh, WLC_SET_PLCPHDR, &preamble, sizeof(preamble))) {
printf("wlmPreambleSet: %s\n", wlmLastError());
return FALSE;
}
return TRUE;
}
int wlmRxAntSet(int antenna)
{
/* Set 'antdiv' - select receive antenna */
antenna = htod32(antenna);
if (wlu_set(irh, WLC_SET_ANTDIV, &antenna, sizeof(antenna))) {
printf("wlmRxAntSet: %s\n", wlmLastError());
return FALSE;
}
return TRUE;
}
int wlmTxAntSet(int antenna)
{
/* Set 'txant' - select transmit antenna */
antenna = htod32(antenna);
if (wlu_set(irh, WLC_SET_TXANT, &antenna, sizeof(antenna))) {
printf("wlmTxAntSet: %s\n", wlmLastError());
return FALSE;
}
return TRUE;
}
int wlmEnableCarrierTone(int enable, WLM_BAND band, int channel)
{
int val = channel;
(void)band;
if (!enable) {
val = 0;
}
else {
wlmEnableAdapterUp(1);
if (wlu_set(irh, WLC_OUT, NULL, 0) < 0) {
printf("wlmEnableCarrierTone: %s\n", wlmLastError());
return FALSE;
}
}
val = htod32(val);
if (wlu_set(irh, WLC_FREQ_ACCURACY, &val, sizeof(int)) < 0) {
printf("wlmEnableCarrierTone: %s\n", wlmLastError());
return FALSE;
}
return TRUE;
}
int wlmGmodeSet(WLM_GMODE gmode)
{
/* Set 'gmode' - select mode in 2.4G band */
gmode = htod32(gmode);
if (wlu_set(irh, WLC_SET_GMODE, (void *)&gmode, sizeof(gmode))) {
printf("wlmGmodeSet: %s\n", wlmLastError());
return FALSE;
}
return TRUE;
}
int wlmBandSet(WLM_BAND band)
{
band = htod32(band);
if (wlu_set(irh, WLC_SET_BAND, (void *)&band, sizeof(band))) {
printf("wlmBandSet: %s\n", wlmLastError());
return FALSE;
}
curBand = band;
return TRUE;
}
/*
* set named iovar providing both parameter and i/o buffers
* iovar name is converted to lower case
*/
int
wlu_iovar_setbuf(void* wl, const char *iovar,
void *param, int paramlen, void *bufptr, int buflen)
{
int err;
int iolen;
iolen = wl_iovar_mkbuf(iovar, param, paramlen, bufptr, buflen, &err);
if (err)
return err;
return wlu_set(wl, WLC_SET_VAR, bufptr, iolen);
}
static int
lua_ctl_aclchk(lua_State *L, void *wl, lua_cmd_t *cmd, char *argv)
{
struct maclist *maclist = (struct maclist *) buf;
struct maclist *acllist = (struct maclist *) (buf + WLC_IOCTL_MAXLEN);
uint i, j, max = (WLC_IOCTL_MAXLEN - sizeof(int)) / ETHER_ADDR_LEN;
struct ether_addr *ea, *tea;
int ret, val, deauth;
if ((ret = wlu_get(wl, WLC_GET_MACMODE, &val, sizeof(int))) < 0)
return ret;
val = dtoh32(val);
if (val == 0)
{
return 0;
}
maclist->count = htod32(max);
if ((ret = wlu_get(wl, WLC_GET_ASSOCLIST, maclist, WLC_IOCTL_MAXLEN)) < 0)
{
return ret;
}
maclist->count = dtoh32(maclist->count);
acllist->count = htod32(max);
if ((ret = wlu_get(wl, WLC_GET_MACLIST, acllist, WLC_IOCTL_MAXLEN)) < 0)
{
return ret;
}
acllist->count = dtoh32(maclist->count);
for (i = 0, ea = maclist->ea; i < maclist->count && i < max; i++, ea++)
{
deauth = (val == 2) ? 1 : 0;
for (j = 0, tea = acllist->ea; j < acllist->count && j < max; j++, tea++)
{
if (memcmp(ea, tea, sizeof(struct ether_addr)) == 0)
{
deauth = !deauth;
}
}
if (deauth)
{
/* No reason code furnished, so driver will use its default */
ret = wlu_set(wl, WLC_SCB_DEAUTHENTICATE, ea, ETHER_ADDR_LEN);
}
}
return 0;
}
int wlmScanSuppress(int on)
{
int val;
if (on)
val = 1;
else
val = 0;
if (wlu_set(irh, WLC_SET_SCANSUPPRESS, &val, sizeof(int))) {
printf("wlmSetScansuppress: %s\n", wlmLastError());
return FALSE;
}
return TRUE;
}
int wlmChannelSet(int channel)
{
/* Check band lock first before set channel */
if ((channel <= 14) && (curBand != WLM_BAND_2G)) {
curBand = WLM_BAND_2G;
} else if ((channel > 14) && (curBand != WLM_BAND_5G)) {
curBand = WLM_BAND_5G;
}
/* Set 'channel' */
channel = htod32(channel);
if (wlu_set(irh, WLC_SET_CHANNEL, &channel, sizeof(channel))) {
printf("wlmChannelSet: %s\n", wlmLastError());
return FALSE;
}
return TRUE;
}
static int
lua_set_acl(lua_State *L, void *wl, lua_cmd_t *cmd, char *argv)
{
int ret;
int val;
if (!stricmp(argv, "deny"))
{
val = 1;
}
else if (!stricmp(argv, "allow"))
{
val = 2;
}
else
{
val = 0;
}
val = htod32(val);
ret = wlu_set(wl, WLC_SET_MACMODE, &val, sizeof(int));
return ret;
}
int wlmSecuritySet(WLM_AUTH_TYPE authType, WLM_AUTH_MODE authMode,
WLM_ENCRYPTION encryption, const char *key)
{
int length = 0;
int wpa_auth;
int sup_wpa;
int primary_key = 0;
wl_wsec_key_t wepKey[4];
wsec_pmk_t psk;
int wsec;
if (encryption != WLM_ENCRYPT_NONE && key == 0) {
printf("wlmSecuritySet: invalid key\n");
return FALSE;
}
if (key) {
length = strlen(key);
}
switch (encryption) {
case WLM_ENCRYPT_NONE:
wpa_auth = WPA_AUTH_DISABLED;
sup_wpa = 0;
break;
case WLM_ENCRYPT_WEP: {
int i;
int len = length / 4;
wpa_auth = WPA_AUTH_DISABLED;
sup_wpa = 0;
if (!(length == 40 || length == 104 || length == 128 || length == 256)) {
printf("wlmSecuritySet: invalid WEP key length %d"
" - expect 40, 104, 128, or 256"
" (i.e. 10, 26, 32, or 64 for each of 4 keys)\n", length);
return FALSE;
}
/* convert hex key string to 4 binary keys */
for (i = 0; i < 4; i++) {
wl_wsec_key_t *k = &wepKey[i];
const char *data = &key[i * len];
unsigned int j;
memset(k, 0, sizeof(*k));
k->index = i;
k->len = len / 2;
for (j = 0; j < k->len; j++) {
char hex[] = "XX";
char *end = NULL;
strncpy(hex, &data[j * 2], 2);
k->data[j] = (char)strtoul(hex, &end, 16);
if (*end != 0) {
printf("wlmSecuritySet: invalid WEP key"
" - expect hex values\n");
return FALSE;
}
}
switch (k->len) {
case 5:
k->algo = CRYPTO_ALGO_WEP1;
break;
case 13:
k->algo = CRYPTO_ALGO_WEP128;
break;
case 16:
k->algo = CRYPTO_ALGO_AES_CCM;
break;
case 32:
k->algo = CRYPTO_ALGO_TKIP;
break;
default:
/* invalid */
return FALSE;
}
k->flags |= WL_PRIMARY_KEY;
}
break;
}
case WLM_ENCRYPT_TKIP:
case WLM_ENCRYPT_AES: {
if (authMode != WLM_WPA_AUTH_PSK && authMode != WLM_WPA2_AUTH_PSK) {
printf("wlmSecuritySet: authentication mode must be WPA PSK or WPA2 PSK\n");
return FALSE;
}
wpa_auth = authMode;
sup_wpa = 1;
if (length < WSEC_MIN_PSK_LEN || length > WSEC_MAX_PSK_LEN) {
printf("wlmSecuritySet: passphrase must be between %d and %d characters\n",
WSEC_MIN_PSK_LEN, WSEC_MAX_PSK_LEN);
return FALSE;
}
psk.key_len = length;
psk.flags = WSEC_PASSPHRASE;
memcpy(psk.key, key, length);
break;
}
case WLM_ENCRYPT_WSEC:
case WLM_ENCRYPT_FIPS:
default:
printf("wlmSecuritySet: encryption not supported\n");
return FALSE;
}
if (wlu_iovar_setint(irh, "auth", authType)) {
printf("wlmSecuritySet: %s\n", wlmLastError());
return FALSE;
}
if (wlu_iovar_setint(irh, "wpa_auth", wpa_auth)) {
printf("wlmSecuritySet: %s\n", wlmLastError());
return FALSE;
}
if (wlu_iovar_setint(irh, "sup_wpa", sup_wpa)) {
printf("wlmSecuritySet: %s\n", wlmLastError());
return FALSE;
}
if (encryption == WLM_ENCRYPT_WEP) {
int i;
for (i = 0; i < 4; i++) {
wl_wsec_key_t *k = &wepKey[i];
k->index = htod32(k->index);
k->len = htod32(k->len);
k->algo = htod32(k->algo);
k->flags = htod32(k->flags);
if (wlu_set(irh, WLC_SET_KEY, k, sizeof(*k))) {
printf("wlmSecuritySet: %s\n", wlmLastError());
return FALSE;
}
}
primary_key = htod32(primary_key);
if (wlu_set(irh, WLC_SET_KEY_PRIMARY, &primary_key, sizeof(primary_key)) < 0) {
printf("wlmSecuritySet: %s\n", wlmLastError());
return FALSE;
}
}
else if (encryption == WLM_ENCRYPT_TKIP || encryption == WLM_ENCRYPT_AES) {
psk.key_len = htod16(psk.key_len);
psk.flags = htod16(psk.flags);
if (wlu_set(irh, WLC_SET_WSEC_PMK, &psk, sizeof(psk))) {
printf("wlmSecuritySet: %s\n", wlmLastError());
return FALSE;
}
}
wsec = htod32(encryption);
if (wlu_set(irh, WLC_SET_WSEC, &wsec, sizeof(wsec)) < 0) {
printf("wlmSecuritySet: %s\n", wlmLastError());
return FALSE;
}
return TRUE;
}
int wlmDeviceImageWrite(const char* byteStream, int length, WLM_IMAGE_TYPE imageType)
{
srom_rw_t *srt;
char buffer[WLC_IOCTL_MAXLEN] = {0};
char *bufp;
char *cisp, *cisdata;
cis_rw_t cish;
if (byteStream == NULL) {
printf("wlmDeviceImageWrite: Buffer is invalid!\n");
return FALSE;
}
if (length > SROM_MAX+1) {
printf("wlmDeviceImageWrite: Data length should be less than %d bytes\n", SROM_MAX);
return FALSE;
}
switch (imageType) {
case WLM_TYPE_SROM:
srt = (srom_rw_t *)buffer;
memcpy(srt->buf, byteStream, length);
if (length == SROM4_WORDS * 2) {
if ((srt->buf[SROM4_SIGN] != SROM4_SIGNATURE) &&
(srt->buf[SROM8_SIGN] != SROM4_SIGNATURE)) {
printf("wlmDeviceImageWrite: Data lacks a REV4 signature!\n");
return FALSE;
}
} else if ((length != SROM_WORDS * 2) && (length != SROM_MAX)) {
printf("wlmDeviceImageWrite: Data length is invalid!\n");
return FALSE;
}
srt->nbytes = length;
if (wlu_set(irh, WLC_SET_SROM, buffer, length + 8)) {
printf("wlmDeviceImageWrite: %s\n", wlmLastError());
return FALSE;
}
break;
case WLM_TYPE_OTP:
bufp = buffer;
strcpy(bufp, "ciswrite");
bufp += strlen("ciswrite") + 1;
cisp = bufp;
cisdata = cisp + sizeof(cish);
cish.source = htod32(0);
memcpy(cisdata, byteStream, length);
cish.byteoff = htod32(0);
cish.nbytes = htod32(length);
memcpy(cisp, (char*)&cish, sizeof(cish));
if (wl_set(irh, WLC_SET_VAR, buffer, (cisp - buffer) + sizeof(cish) + length) < 0) {
printf("wlmDeviceImageWrite: %s\n", wlmLastError());
return FALSE;
}
break;
case WLM_TYPE_AUTO:
if (!wlmDeviceImageWrite(byteStream, length, WLM_TYPE_SROM) &&
!wlmDeviceImageWrite(byteStream, length, WLM_TYPE_OTP)) {
printf("wlmDeviceImageWrite: %s\n", wlmLastError());
return FALSE;
}
break;
default:
printf("wlmDeviceImageWrite: Invalid image type!\n");
return FALSE;
}
return TRUE;
}
int wl_disassoc(void *wl)
{
return wlu_set(wl, WLC_DISASSOC, NULL, 0);
}
