void
anthy_ask_scan(void (*request_scan)(struct textdict *, void *),
void *arg)
{
DIR *dir;
struct dirent *de;
int size = 0;
request_scan(anthy_private_text_dic, arg);
request_scan(anthy_imported_text_dic, arg);
dir = opendir(imported_dic_dir);
if (!dir) {
return ;
}
while ((de = readdir(dir))) {
struct stat st_buf;
struct textdict *td;
char *fn = malloc(strlen(imported_dic_dir) +
strlen(de->d_name) + 3);
if (!fn) {
break;
}
sprintf(fn, "%s/%s", imported_dic_dir, de->d_name);
if (stat(fn, &st_buf)) {
free(fn);
continue;
}
if (!S_ISREG(st_buf.st_mode)) {
free(fn);
continue;
}
size += st_buf.st_size;
if (size > MAX_DICT_SIZE) {
free(fn);
break;
}
td = anthy_textdict_open(fn);
request_scan(td, arg);
anthy_textdict_close(td);
free(fn);
}
closedir(dir);
}
int autoscan_notify_scan(struct wpa_supplicant *wpa_s,
struct wpa_scan_results *scan_res)
{
int interval;
if (wpa_s->autoscan && wpa_s->autoscan_priv) {
interval = wpa_s->autoscan->notify_scan(wpa_s->autoscan_priv,
scan_res);
if (interval <= 0)
return -1;
wpa_s->scan_interval = interval;
wpa_s->sched_scan_interval = interval;
request_scan(wpa_s);
}
return 0;
}
/**
* access_mib -access mib parameters
* @pmib: mib structure pointer
* @flag: ACCESS_MIB_SET, ACCESS_MIB_GET,
* ACCESS_MIB_BY_NAME, ACCESS_MIB_BY_ID, ACCESS_MIB_ACTION
* @nameid: if ACCESS_MIB_BY_NAME, pointer to mib name
* if ACCESS_MIB_BY_ID, pointer to mib id
* @data1: if ACCESS_MIB_SET, set data of 1st argument
* if ACCESS_MIB_GET, read data for return
* @data2: if ACCESS_MIB_SET, set data of 2nd argument
*
*
* Get/Set mib value from/to pmib structure.
* Success: return 0 for ACCESS_MIB_SET command
* return read mib length for ACCESS_MIB_GET command
* Failure: return -1
* Action command: return 1
*/
int access_mib(struct mib *pmib, int flag, char *nameid, void *data1, void *data2)
{
int val, i = 0, ret = RET_OK;
#ifdef CMD_LINE
int j;
char *ptr;
#endif
unsigned char bVal;
unsigned short wVal;
struct mdio_mem32_param mem_param;
void *data=NULL;
if (nameid == NULL) {
DEBUG_ERR("nameid == NULL!\n");
return -1;
}
while (cmd_table[i].type != LAST_ENTRY) {
if (
#ifdef CMD_LINE
((flag & ACCESS_MIB_BY_NAME) && !strcmp(cmd_table[i].name, nameid)) ||
#endif
((flag & ACCESS_MIB_BY_ID) && (cmd_table[i].id == *((int *)nameid)))) {
// Do ioctl
if (cmd_table[i].action == ACT_IOCTL && (flag & ACCESS_MIB_ACTION)) {
if (cmd_table[i].id == id_write_memory) {
#ifdef CMD_LINE
if (flag & ACCESS_MIB_BY_NAME) {
if (!data1 || !data2) {
DEBUG_ERR("Invalid argument for id_write_memory!\n");
return -RET_INVALID_ARG;
}
if (sscanf(data1, "%x", (unsigned int *)&mem_param.addr) != 1) {
DEBUG_ERR("Invalid argument 1 for id_write_memory!\n");
return -RET_INVALID_ARG;
}
if (sscanf(data2, "%x", (unsigned int *)&mem_param.val) != 1) {
DEBUG_ERR("Invalid argument 2 for id_write_memory!\n");
return -RET_INVALID_ARG;
}
DEBUG_OUT("addr=0x%x, value=0x%x\n", (unsigned int)mem_param.addr, (unsigned int)mem_param.val);
data = &mem_param;
}
else
#endif
{
memcpy((void *)&mem_param, data1, sizeof(struct mdio_mem32_param));
data = (void *)&mem_param;
}
}
else if (cmd_table[i].id == id_read_memory) {
#ifdef CMD_LINE
if (flag & ACCESS_MIB_BY_NAME) {
if (!data1) {
DEBUG_ERR("Invalid argument for id_read_memory!\n");
return -RET_INVALID_ARG;
}
if (sscanf(data1, "%x", (unsigned int *)&mem_param.addr) != 1) {
DEBUG_ERR("Invalid argument 1 for id_read_memory!\n");
return -RET_INVALID_ARG;
}
DEBUG_OUT("addr=0x%x\n", (unsigned int)mem_param.addr);
data = &mem_param.addr;
}
else
#endif
{
memcpy((void *)&mem_param.addr, data1, sizeof(int));;
data = (void *)&mem_param.addr;
}
}
else if (cmd_table[i].id == id_wlan_mac_addr) {
#ifdef ACCESS_WLAN_IF
get_wlan_mac_addr(IF_WLAN, data1);
#else
memset(data1, 0, 6);
#endif
return 6; //length of mac address
}
#ifdef RT_WLAN
else if (cmd_table[i].id == id_get_wlan_info) {
return get_wlan_info(data1);
}
else if (cmd_table[i].id == id_request_scan) {
return request_scan(data1);
}
else if (cmd_table[i].id == id_get_scan_result) {
return get_scan_result(data1);
}
else if (cmd_table[i].id == id_cfgwrite) {
return cfgwrite(data1);
}
else if (cmd_table[i].id == id_cfgread) {
return cfgread(data1);
}
else if (cmd_table[i].id == id_priv_shortretry) {
return priv_retrylimit(data1, 1);
}
else if (cmd_table[i].id == id_priv_longretry) {
return priv_retrylimit(data1, 0);
}
#endif
else {
DEBUG_ERR("Not supported now!\n");
return -RET_NOT_SUPPORT_NOW;
}
ret = do_mdio_ioctl(cmd_table[i].id, data);
if (ret > 0 && ((unsigned long)data) != ((unsigned long)data1) &&
(flag & ACCESS_MIB_BY_ID))
memcpy(data1, data, ret);
#ifdef CMD_LINE
if (ret >= 0 && cmd_table[i].id == id_read_memory && (flag & ACCESS_MIB_BY_NAME))
printf("0x%s=0x%04x\n", (char *)data1, *((int *)data));
#endif
return ret;
}
// Do MIB R/W
if ((cmd_table[i].action == ACT_MIB_RW || cmd_table[i].action == ACT_MIB_RW_IOCTL) &&
(flag & ACCESS_MIB_GET || flag & ACCESS_MIB_SET)) {
switch (cmd_table[i].type) {
case BYTE_T:
if (flag & ACCESS_MIB_SET) {
#ifdef CMD_LINE
if (flag & ACCESS_MIB_BY_NAME)
bVal = (unsigned char)atoi(data1);
else
#endif
bVal = ((unsigned char *)data1)[0];
if ((cmd_table[i].def=="" || (cmd_table[i].def && val != atoi(cmd_table[i].def))) &&
(((int)bVal) < cmd_table[i].start || ((int)bVal) > cmd_table[i].end)) {
DEBUG_ERR("Invalid BYTE_T cmd range [%d, %d, %d])!\n", bVal, cmd_table[i].start, cmd_table[i].end);
return -RET_INVALID_RANGE;
}
memcpy(((unsigned char *)pmib)+cmd_table[i].offset, &bVal, 1);
}
else {
memcpy(&bVal, ((unsigned char *)pmib)+cmd_table[i].offset, 1);
#ifdef CMD_LINE
if (flag & ACCESS_MIB_BY_NAME)
printf("%s=%d\n", cmd_table[i].name, (int)bVal);
else
#endif
memcpy(data1, &bVal, 1);
ret = 1;
}
break;
case WORD_T:
if (flag & ACCESS_MIB_SET) {
#ifdef CMD_LINE
if (flag & ACCESS_MIB_BY_NAME)
wVal = (unsigned short)atoi(data1);
else
#endif
memcpy(&wVal, data1, 2);
if ((cmd_table[i].def=="" || (cmd_table[i].def && val != atoi(cmd_table[i].def))) &&
(((int)wVal) < cmd_table[i].start || ((int)wVal) > cmd_table[i].end)) {
DEBUG_ERR("Invalid WORD_T cmd range [%d, %d, %d])!\n", val, cmd_table[i].start, cmd_table[i].end);
return -RET_INVALID_RANGE;
}
memcpy(((unsigned char *)pmib)+cmd_table[i].offset, &wVal, 2);
}
else {
memcpy(&wVal, ((unsigned char *)pmib)+cmd_table[i].offset, 2);
#ifdef CMD_LINE
if (flag & ACCESS_MIB_BY_NAME)
printf("%s=%d\n", cmd_table[i].name, (int)wVal);
else
#endif
memcpy(data1, &wVal, 2);
ret = 2;
}
break;
case INT_T:
case INT_BIT_T:
if (flag & ACCESS_MIB_SET) {
#ifdef CMD_LINE
if (flag & ACCESS_MIB_BY_NAME)
val = atoi(data1);
else
#endif
memcpy(&val, data1, 4);
if ((cmd_table[i].def=="" || (cmd_table[i].def && val != atoi(cmd_table[i].def))) &&
(val < cmd_table[i].start || val > cmd_table[i].end)) {
DEBUG_ERR("Invalid INT_T cmd range [%d, %d, %d])!\n", val, cmd_table[i].start, cmd_table[i].end);
return -RET_INVALID_RANGE;
}
if ((cmd_table[i].type == INT_BIT_T) && is_more_bit_asserted(val)) {
DEBUG_ERR("Invalid cmd range [%d, %d, %d])!\n", val, cmd_table[i].start, cmd_table[i].end);
return -RET_INVALID_RANGE;
}
memcpy(((unsigned char *)pmib)+cmd_table[i].offset, &val, 4);
}
else {
memcpy(&val, ((unsigned char *)pmib)+cmd_table[i].offset, 4);
#ifdef CMD_LINE
if (flag & ACCESS_MIB_BY_NAME)
printf("%s=%d\n", cmd_table[i].name, val);
else
#endif
memcpy(data1, &val, 4);
ret = 4;
}
break;
case STRING_T:
if (flag & ACCESS_MIB_SET) {
if ((strlen(data1) > 0) && (strlen(data1) < cmd_table[i].start || strlen(data1) > cmd_table[i].end)) {
DEBUG_ERR("Invalid STRINT_T cmd range [%d, %d, %d])!\n", strlen(data1), cmd_table[i].start, cmd_table[i].end);
return -RET_INVALID_RANGE;
}
strcpy(((unsigned char *)pmib)+cmd_table[i].offset, data1);
}
else {
#ifdef CMD_LINE
if (flag & ACCESS_MIB_BY_NAME)
printf("%s=\"%s\"\n", cmd_table[i].name, ((unsigned char *)pmib)+cmd_table[i].offset);
else
#endif
{
strcpy(data1, ((unsigned char *)pmib)+cmd_table[i].offset);
ret = strlen(data1);
}
}
break;
case BYTE_6_T:
case BYTE_13_T:
if (flag & ACCESS_MIB_SET) {
#ifdef CMD_LINE
if (flag & ACCESS_MIB_BY_NAME) {
if (strlen(data1) != cmd_table[i].start*2) {
DEBUG_ERR("Invalid BYTE cmd length [%d, %d])!\n", strlen(data1), cmd_table[i].start);
return -RET_INVALID_RANGE;
}
for (j=0, ptr=data1; *ptr && j<cmd_table[i].start; j++, ptr+=2) {
if (!isxdigit((int)*ptr) || !isxdigit((int)*(ptr+1)) ) {
DEBUG_ERR("%s: Invalid BYTE_T vlaue!\n", __FUNCTION__);
return -RET_INVALID_RANGE;
}
*(((unsigned char *)pmib)+cmd_table[i].offset+j) = convert_atob(ptr, 16);
}
}
else
#endif
memcpy(((unsigned char *)pmib)+cmd_table[i].offset, data1, cmd_table[i].start);
}
else {
#ifdef CMD_LINE
if (flag & ACCESS_MIB_BY_NAME) {
ptr = ((unsigned char *)pmib)+cmd_table[i].offset;
if (cmd_table[i].type ==BYTE_6_T)
ret = printf("%s=%02x%02x%02x%02x%02x%02x\n", cmd_table[i].name,
*ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4), *(ptr+5));
else
ret = printf("%s=%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x%02x\n",
cmd_table[i].name,
*ptr, *(ptr+1), *(ptr+2), *(ptr+3), *(ptr+4), *(ptr+5), *(ptr+6),
*(ptr+7), *(ptr+8), *(ptr+9), *(ptr+10), *(ptr+11), *(ptr+12));
}
else
#endif
{
memcpy(data1, ((unsigned char *)pmib)+cmd_table[i].offset, cmd_table[i].start);
ret = cmd_table[i].start;
}
}
break;
default:
DEBUG_ERR("Invalid mib type!\n");
return -RET_NOT_NOW;
}
}
// Do ioctl
if (cmd_table[i].action == ACT_MIB_RW_IOCTL && (flag & ACCESS_MIB_ACTION)) {
int ret1 = do_mdio_ioctl(cmd_table[i].id, ((unsigned char *)pmib)+cmd_table[i].offset);
if (ret1 != RET_OK)
ret = ret1;
}
return ret;
}
i++;
}
DEBUG_ERR("Can't find mib!\n");
return -RET_INVALID_CMD_ID;
}
int autoscan_init(struct wpa_supplicant *wpa_s, int req_scan)
{
const char *name = wpa_s->conf->autoscan;
const char *params;
size_t nlen;
int i;
const struct autoscan_ops *ops = NULL;
if (wpa_s->autoscan && wpa_s->autoscan_priv)
return 0;
if (name == NULL)
return 0;
params = os_strchr(name, ':');
if (params == NULL) {
params = "";
nlen = os_strlen(name);
} else {
nlen = params - name;
params++;
}
for (i = 0; autoscan_modules[i]; i++) {
if (os_strncmp(name, autoscan_modules[i]->name, nlen) == 0) {
ops = autoscan_modules[i];
break;
}
}
if (ops == NULL) {
wpa_printf(MSG_ERROR, "autoscan: Could not find module "
"matching the parameter '%s'", name);
return -1;
}
wpa_s->autoscan_params = NULL;
wpa_s->autoscan_priv = ops->init(wpa_s, params);
if (wpa_s->autoscan_priv == NULL)
return -1;
wpa_s->autoscan = ops;
wpa_printf(MSG_DEBUG, "autoscan: Initialized module '%s' with "
"parameters '%s'", ops->name, params);
if (!req_scan)
return 0;
/*
* Cancelling existing scan requests, if any.
*/
wpa_supplicant_cancel_sched_scan(wpa_s);
wpa_supplicant_cancel_scan(wpa_s);
/*
* Firing first scan, which will lead to call autoscan_notify_scan.
*/
request_scan(wpa_s);
return 0;
}
