/**
* 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 main( int argc, char **argv)
{
int c;
int y;
if( !init() ) {
endwin();
printf( "init screen failed\n");
return 0;
}
if( !cfgread() ) {
endwin();
printf( "config file open error\n");
return 0;
}
printtitle();
dsphelp();
y = 0;
dspcaption(y);
dspcomment( y);
dsppage();
while( 1) {
c = wgetch(wMain);
switch( c) {
case KEY_UP:
case '8':
case 'k':
y--;
break;
case KEY_DOWN:
case 'j':
case '2':
y++;
break;
case KEY_LEFT:
case '4':
case 'h':
page --;
if( page < 0 ) page = 0;
else {
dsppage();
}
break;
case KEY_RIGHT:
case '6':
case 'l':
page ++;
if( page > maxpage ) page = maxpage ;
else {
if( y+page*LINENUM >= menucnt) y = 0;
dsppage();
}
break;
case 'q':
exitmain( 0);
break;
case 10:
case 13:
case KEY_ENTER:
werase( wMsg);
wrefresh( wMsg);
if( menu[y].sure ) {
int recv;
mvwprintw( wMsg, 0,0, "are you sure? [y]\n");
recv = wgetch( wMsg);
werase( wMsg);
wrefresh( wMsg);
if( tolower(recv) != 'y' ) break;
}
wprintw( wMsg, " ");
wrefresh(wMsg);
system( menu[y+page*LINENUM].script);
{
int recv;
mvwprintw( wMsg, 0,0,"\nhit any key\n");
recv = wgetch( wMsg);
erase();
refresh();
werase( wMsg);
wrefresh( wMsg);
werase( wComment);
werase( wMain);
printtitle();
dsphelp();
dsppage();
}
}
if( y < 0 ) y = 0;
if( y >= LINENUM ) y = LINENUM -1;
if( y+page*LINENUM >= menucnt ) y --;
// move( y,2);
dspcaption( y);
dspcomment( y);
}
return 0;
}
