status_t
BNetworkDevice::GetNextNetwork(uint32& cookie, wireless_network& network)
{
status_t status = get_scan_result(Name(), network, cookie, NULL, NULL);
if (status != B_OK)
return status;
cookie++;
return B_OK;
}
/**
* 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;
}
QStringList IcdPrivate::scan(icd_scan_request_flags flags,
QStringList &network_types,
QList<IcdScanResult>& scan_results,
QString& error)
{
Q_UNUSED(network_types);
QStringList scanned_types;
QTimer timer;
QVariant reply;
QVariantList vl;
bool last_result = false;
IcdScanResult result;
int all_waited;
clearState();
reply = mDBus->call(ICD_DBUS_API_SCAN_REQ, (uint)flags);
if (reply.type() != QVariant::List)
return scanned_types;
vl = reply.toList();
if (vl.isEmpty()) {
error = "Scan did not return anything.";
return scanned_types;
}
reply = vl.first();
scanned_types = reply.toStringList();
//qDebug() << "Scanning:" << scanned_types;
all_waited = scanned_types.size();
timer.setSingleShot(true);
timer.start(timeout);
scan_results.clear();
while (!last_result) {
while (timer.isActive() && mInterface.isEmpty() && mError.isEmpty()) {
QCoreApplication::processEvents(QEventLoop::AllEvents, 1000);
}
if (!timer.isActive()) {
//qDebug() << "Timeout happened";
break;
}
if (mSignal != ICD_DBUS_API_SCAN_SIG) {
//qDebug() << "Received" << mSignal << "while waiting" << ICD_DBUS_API_SCAN_SIG << ", ignoring";
mInterface.clear();
continue;
}
if (mError.isEmpty()) {
QString msgInterface = receivedSignals.takeFirst().toString();
QString msgSignal = receivedSignals.takeFirst().toString();
QList<QVariant> msgArgs = receivedSignals.takeFirst().toList();
//qDebug() << "Signal" << msgSignal << "received.";
//qDebug() << "Params:" << msgArgs;
while (!msgSignal.isEmpty()) {
get_scan_result(msgArgs, result);
#if 0
qDebug() << "Received: " <<
"status =" << result.status <<
", timestamp =" << result.timestamp <<
", service_type =" << result.scan.service_type <<
", service_name =" << result.service_name <<
", service_attrs =" << result.scan.service_attrs <<
", service_id =" << result.scan.service_id <<
", service_priority =" << result.service_priority <<
", network_type =" << result.scan.network_type <<
", network_name =" << result.network_name <<
", network_attrs =" << result.scan.network_attrs <<
", network_id =" << "-" <<
", network_priority =" << result.network_priority <<
", signal_strength =" << result.signal_strength <<
", station_id =" << result.station_id <<
", signal_dB =" << result.signal_dB;
#endif
if (result.status == ICD_SCAN_COMPLETE) {
//qDebug() << "waited =" << all_waited;
if (--all_waited == 0) {
last_result = true;
break;
}
} else
scan_results << result;
if (receivedSignals.isEmpty())
break;
msgInterface = receivedSignals.takeFirst().toString();
msgSignal = receivedSignals.takeFirst().toString();
msgArgs = receivedSignals.takeFirst().toList();
}
mInterface.clear();
} else {
qWarning() << "Error while scanning:" << mError;
break;
}
}
timer.stop();
error = mError;
return scanned_types;
}
