Advertisement
Guest User

Untitled

a guest
Jan 23rd, 2012
352
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 42.42 KB | None | 0 0
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <netdb.h>
  5. #include <unistd.h>
  6. #include <sys/types.h>
  7. #include <sys/socket.h>
  8. #include <sys/select.h>
  9. #include <netinet/in.h>
  10. #include <arpa/inet.h>
  11. #include <pthread.h>
  12. #include <enet/enet.h>
  13. #include <fcntl.h>
  14. #include <net/route.h>
  15. #include <enet_flash.h>
  16.  
  17. #ifndef ENET_AGENTD_PORT
  18. #define ENET_AGENTD_PORT 13364
  19. #endif
  20.  
  21. extern int admin_site_survey(SITESURVEY *sites);
  22. extern int get_ap_info(WLANINFO *wlaninfo);
  23. extern int enet_avs_msg_port;
  24. extern int enet_disable_all_leds;
  25. extern int g_link_status;
  26. extern int has_no_wireless;
  27.  
  28. #ifdef ENET_SUPPORT_WLAN
  29. extern int getRegionCountryNum(int a, int b);
  30. #endif
  31.  
  32. extern void enet_form_set_date_time(int year,int mon,int day,int hour,int min,int sec);
  33. extern void enet_set_essid_any();
  34. extern void enet_restore_essid();
  35. void getRegionCountryRange(int cr, int *a, int *b);
  36.  
  37. int saveCountryRegionFlash(int CountryRegion);
  38. int saveMACFlash(unsigned char *mac);
  39.  
  40.  
  41. static unsigned char mynodeid[6];
  42.  
  43. static pthread_t ledctl_handle;
  44.  
  45. static inline u8 atoh(char c)
  46. {
  47.     unsigned x;
  48.     switch (c) {
  49.     case 'F': case 'f': return 15;
  50.     case 'E': case 'e': return 14;
  51.     case 'D': case 'd': return 13;
  52.     case 'C': case 'c': return 12;
  53.     case 'B': case 'b': return 11;
  54.     case 'A': case 'a': return 10;
  55.     }
  56.     x = c - '0';
  57.     return (x >= 0 && x <= 9) ? x : 0;
  58. }
  59.  
  60.  
  61. static int check_tcpcfg(TCPCFG *cfg)
  62. {
  63.     unsigned char nodenum[6] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
  64.    
  65.     if (!memcmp(cfg->NodeID, nodenum, 6)  || !memcmp(cfg->NodeID, mynodeid, 6)) {
  66.         if (cfg->edicfg[3] + cfg->edicfg[1] == cfg->edicfg[2] && cfg->edicfg[0] == 0)
  67.             return 1;
  68.         else   
  69.             return 0;
  70.     }
  71.     else
  72.         return 0;
  73. }
  74.  
  75. static void SetTCPCfgPkt(TCPCFG *cfg, unsigned char command, unsigned char *nodenum)
  76. {
  77.     bzero(cfg, sizeof(TCPCFG));
  78.     memcpy(cfg->NodeID, nodenum, 6);
  79.    
  80.     cfg->edicfg[0] = RESPONSE;
  81.     cfg->edicfg[1] = command;
  82.     cfg->edicfg[2] = 0xff;
  83.     cfg->edicfg[3] = 0xff - command;
  84. }
  85.  
  86. static void Set_IC_NAME(IC_NAME *ic, enet_t *enet)
  87. {
  88.     int a, b;
  89.     in_addr_t ip;
  90.  
  91.     bzero(ic, sizeof(IC_NAME));
  92.     memcpy(ic->IC_Name, enet->model_name, sizeof(enet->model_name));
  93.    
  94.     //memcpy(ic->IC_IP, &enet->lan.ip, sizeof(in_addr_t));
  95.     memset(ic->IC_IP, 0, sizeof(ic->IC_IP));
  96.     if (enet_get_ip(ENET_LAN_BRIDGE, &ip) > 0)
  97.         memcpy(ic->IC_IP, &ip, sizeof(in_addr_t));
  98.    
  99. #ifdef ENET_SUPPORT_WLAN
  100.     getRegionCountryRange(enet->wl_g.CountryRegion, &a, &b);
  101. #endif
  102.  
  103.     ic->IC_Reserved0[0] = a; // Tester: Wireless Channel a-b
  104.     ic->IC_Reserved0[1] = b; // Tester: Wireless Channel a-b
  105.  
  106.     ic->IC_Reserved0[2] = FIRMWARE_VERSION_A; // Tester: Firmware Version A.B
  107.     ic->IC_Reserved0[3] = FIRMWARE_VERSION_B; // Tester: Firmware Version A.B
  108.    
  109.     ic->IC_VendorID = enet->model; // Tester: Model (0:Edmiax 1:GLP 2:DDC 3:ICT) (in enet.h)
  110.    
  111.     ic->IC_SubVendorID = enet->type; // Tester: Type (0:IC1000 1:IC1000WG 2:IC3000, 3:IC3000WG 6:IC1500 7:IC1500WG 8:IC1500S)
  112.  
  113.  
  114.     ic->IC_DeviceType = IC_DeviceType_IPCamera; // Admin:
  115.     ic->IC_DeviceModel = enet->type + 1; // Admin: IC_DeviceModel_IC1500WG;
  116.     ic->IC_Setted = enet->IC_Setted;
  117.    
  118.     //memcpy(ic->IC_Reserved1, "5678", 4); //
  119.     //ic->IC_Reserved1[0] = 4;
  120.     //ic->IC_Reserved1[1] = 5;
  121.     //ic->IC_Reserved1[2] = 6;
  122.     //ic->IC_Reserved1[3] = 7;
  123. }
  124.  
  125. static void Set_IC_SETTING(IC_SETTING *icsetting, enet_t *enet)
  126. {
  127.     char tmp[32];
  128.     char firmware_version[5]={0,0,0,0,0};
  129.     in_addr_t netmask;
  130.     struct in_addr gw;
  131.     in_addr_t dns;
  132.  
  133.         memcpy(icsetting->email, enet->email.rcpt, 32); //enet_smtp.h : #define MAX_EMAIL_LEN 64
  134.  
  135.     memcpy(icsetting->emailserver, &enet->email.server, 32); icsetting->emailserver[31] = 0;
  136.    
  137.     memcpy(icsetting->IC_SUBNET, &enet->lan.mask, sizeof(in_addr_t));
  138.     memcpy(icsetting->IC_GATEWAY, &enet->lan.gateway, sizeof(in_addr_t));
  139.     memcpy(icsetting->IC_DNS, &enet->dns1, sizeof(in_addr_t));
  140.    
  141.     icsetting->IC_PORT = htons(enet_avs_msg_port);
  142.     icsetting->IC_WEB_PORT = htons(enet->httpd_port);
  143.  
  144.     if (enet->avs.video.width == 640 && enet->avs.video.height == 480)
  145.     {
  146.         icsetting->IC_Resolution = 3;
  147.     }
  148.     else if (enet->avs.video.width == 320 && enet->avs.video.height == 240)
  149.     {
  150.         icsetting->IC_Resolution = 2;
  151.     }
  152.    
  153.     sscanf(enet_firmware_version(), "%s %s", firmware_version, tmp);
  154.     memcpy(icsetting->IC_FirmwareVer, firmware_version, 5);
  155.    
  156.     //memcpy(icsetting->IC_Password, enet->passwd, 5); obsolete
  157.     strncpy(icsetting->IC_LongPassword, enet->passwd, IPCAM_PASSWD_LEN);
  158.    
  159.     icsetting->IC_DDNS_ENABLE = (int) enet->ddns.enable;
  160.     memcpy(icsetting->IC_DDNS_DOMAIN, enet->ddns.host, 32); icsetting->IC_DDNS_DOMAIN[32] = 0;
  161.     memcpy(icsetting->IC_DDNS_ACCOUNT, enet->ddns.login, 0x11);
  162.     memcpy(icsetting->IC_DDNS_PASSWORD, enet->ddns.passwd, 0x11);
  163.  
  164.     icsetting->IC_UPNP_ENABLE = (int) enet->upnp_enable;
  165.     memcpy(icsetting->IC_Name, enet->model_name, sizeof(enet->model_name)); //enet:32
  166.  
  167.     icsetting->IC_DHCP_ENABLE = (int) enet->lan.dhcp_enable;
  168.     icsetting->IC_PPPOE_ENABLE = (int) enet->pppoe.enable;
  169.  
  170. #if defined AGENTED_SUPPORT_MD
  171.     icsetting->m_IC_MD_3010.IC_MD_enable = enet->avs.md.enable;
  172.     //enet_debug("enet.avs.md.enable is %d",icsetting->IC_MD_enable);
  173.    
  174.     icsetting->m_IC_MD_3010.IC_MD_email = enet->avs.md.email;
  175.     icsetting->m_IC_MD_3010.IC_MD_ftp = enet->avs.md.ftp;
  176.    
  177.     memcpy(icsetting->m_IC_MD_3010.IC_MD_title , enet->avs.md.title , MAX_TITLE_LEN-1 );
  178.     icsetting->m_IC_MD_3010.IC_MD_title[MAX_TITLE_LEN-1] = '\0';
  179.    
  180.     icsetting->m_IC_MD_3010.IC_MD_length = htonl(enet->avs.md.length);
  181. //  enet_debug("icsetting->IC_MD_length is %d",icsetting->IC_MD_length);
  182. //  enet_debug("enet->avs.md.length is %d",enet->avs.md.length);
  183.    
  184.     icsetting->m_IC_MD_3010.IC_MD_delay = htonl(enet->avs.md.delay);
  185. //  icsetting->IC_MD_delay = enet->avs.md.delay;
  186. //  enet_debug("icsetting->IC_MD_delay is %d",icsetting->IC_MD_delay);
  187. //  enet_debug("enet->avs.md.delay is %d",enet->avs.md.delay);
  188. #endif 
  189.  
  190. }
  191.  
  192. static void Set_MyNodeID()
  193. {
  194.     enet_t enet;
  195.     enet_load(&enet);
  196.     memcpy(mynodeid, enet.lan.mac, 6);
  197. }
  198.  
  199. static void dispatch(unsigned char *buf, int buf_len, int sock, struct sockaddr_in *agentd_svr)
  200. {
  201.     enet_t enet;
  202.     TCPCFG cfg, cfgret;
  203.     IC_NAME ic;
  204.     IC_SETTING icsetting;
  205.     IC_CONFIG icconfig;
  206.     WLANINFO wlaninfo;
  207.     SITESURVEY sites[20];
  208.     IC_LED icled;
  209.  
  210.     unsigned char cmd;
  211.     unsigned char send_buf[1024], tmpbuf[64];
  212.     char tftp_cmd[128];
  213.     int ap_num = 0, i;
  214.     int rval, need_reboot = 0;
  215.     unsigned char CountryRegion = 0;
  216.  
  217.     static unsigned char need_save = 0; // in order to save time, we only save setting to flash when need_save is 1.
  218.  
  219.     EMAIL_AUTH email_auth;
  220.     FTP_SETTING ftp;
  221.     PPPOE_SETTING pppoe;
  222.     TEST_EMAIL testmail;
  223.     USERS users;
  224.     DATETIME datetime;
  225.     //struct in_addr ntp_addr;
  226.     int WepKeyLen = 0;
  227.  
  228.     enet_runtime_t *rt;
  229.  
  230.     char *userid = NULL; //for user account management
  231.  
  232.     //enet_debug("UDP packet from %s (port:%d)", inet_ntoa(agentd_svr->sin_addr), ntohs(agentd_svr->sin_port));
  233.  
  234.     rval = 0;
  235.     memcpy(&cfg, buf, sizeof(cfg));
  236.    
  237.     if (check_tcpcfg(&cfg)){
  238.         cmd = cfg.edicfg[1];
  239.         enet_load(&enet);
  240.         bzero(send_buf, 1024);
  241.        
  242.         switch (cmd) {
  243.             case RESET :
  244.                 enet_debug("recv cmd: %d  RESET", cmd);
  245.                 system("/sbin/reboot");
  246.                 break;
  247.            
  248.             case READ_SETTING :
  249.                 agentd_svr->sin_addr.s_addr = INADDR_BROADCAST;
  250.             case READ_SETTING_MANUAL :
  251.                 //if (agentd_svr->sin_addr.s_addr == INADDR_BROADCAST)
  252.                 //    enet_debug("recv cmd: %d  READ_SETTING", cmd);
  253.                 //else
  254.                 //    enet_debug("recv cmd: %d  READ_SETTING_MANUAL", cmd);
  255.                 bzero(&icsetting, sizeof(IC_SETTING));
  256.                 Set_IC_SETTING(&icsetting, &enet);
  257.                 //enet_debug("enet.passwd:%s", enet.passwd);
  258.                 SetTCPCfgPkt(&cfgret, cmd, mynodeid);
  259.                 memcpy(send_buf, &cfgret, sizeof(TCPCFG));
  260.                 memcpy(send_buf + sizeof(TCPCFG), &icsetting, sizeof(IC_SETTING));
  261.                
  262.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(IC_SETTING), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!
  263.                 usleep(10000);
  264.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(IC_SETTING), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!
  265.                 usleep(10000);
  266.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(IC_SETTING), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!                
  267.                 break;
  268.                
  269.             case SET_CONFIG :
  270.                 /*
  271.                     neo@acelink 2008/09/11: Apply to new Admin utility
  272.                 */
  273.                 //enet_debug("recv cmd: %d  SET_CONFIG", cmd);
  274.                 bzero(&icconfig, sizeof(IC_CONFIG));
  275.                 memcpy(&icconfig, buf, sizeof(IC_CONFIG));
  276.  
  277.                 /* save configutation */
  278.                 memcpy(enet.model_name, icconfig.IC_Name, sizeof(enet.model_name)); // enet: 32
  279.                 strncpy(enet.passwd, icconfig.IC_LongPassword, IPCAM_PASSWD_LEN);
  280.                 umSetUserPassword((char *) enet.login, (char *) enet.passwd); // for httpd server
  281.                 enet.lan.dhcp_enable = (bool) icconfig.IC_DHCP_ENABLE;
  282.                 if (!enet.lan.dhcp_enable) {
  283.                     memcpy(&enet.lan.ip, icconfig.IC_IP, sizeof(in_addr_t));
  284.                     memcpy(&enet.lan.mask, icconfig.IC_SUBNET, sizeof(in_addr_t));
  285.                     memcpy(&enet.lan.gateway, icconfig.IC_GATEWAY, sizeof(in_addr_t));
  286.                     memcpy(&enet.dns1, icconfig.IC_DNS, sizeof(in_addr_t));
  287.                 }
  288.                 enet.IC_Setted = 1;            
  289.                
  290.                 need_reboot = 0;
  291.                 if (enet.httpd_port != ntohs(icconfig.IC_WEB_PORT))
  292.                     need_reboot = 1;
  293.  
  294.                 enet.httpd_port = ntohs(icconfig.IC_WEB_PORT);
  295.  
  296.                 if (need_reboot == 1) {
  297.                     enet_save_apply(&enet);
  298.                     enet_reboot();
  299.                 }
  300.  
  301.                 enet_save_apply(&enet);
  302.  
  303.                 //alert admin refresh info
  304.                 cmd = READ_SETTING;
  305.                 bzero(&icsetting, sizeof(IC_SETTING));
  306.                 Set_IC_SETTING(&icsetting, &enet);
  307.                 SetTCPCfgPkt(&cfgret, cmd, mynodeid);
  308.                 memcpy(send_buf, &cfgret, sizeof(TCPCFG));
  309.                 memcpy(send_buf + sizeof(TCPCFG), &icsetting, sizeof(IC_SETTING));
  310.                 agentd_svr->sin_addr.s_addr = INADDR_BROADCAST;
  311.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(IC_SETTING), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!
  312.                 usleep(10000);
  313.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(IC_SETTING), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!
  314.                 usleep(10000);
  315.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(IC_SETTING), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!              
  316.                 break;
  317.            
  318.             case SEARCH_IPCAM :
  319.                 agentd_svr->sin_addr.s_addr = INADDR_BROADCAST;
  320.             case SEARCH_MANUAL :
  321.                 //if (agentd_svr->sin_addr.s_addr == INADDR_BROADCAST)
  322.                 //    enet_debug("recv cmd: %d  SEARCH_IPCAM", cmd);
  323.                 //else
  324.                 //    enet_debug("recv cmd: %d  SEARCH_MANUAL", cmd);
  325.                 Set_IC_NAME(&ic, &enet);
  326.                 SetTCPCfgPkt(&cfgret, cmd, mynodeid);
  327.                 memcpy(send_buf, &cfgret, sizeof(TCPCFG));
  328.                 memcpy(send_buf + sizeof(TCPCFG), &ic, sizeof(IC_NAME));
  329.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(IC_NAME), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!
  330.                 usleep(10000);
  331.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(IC_NAME), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!
  332.                 usleep(10000);
  333.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(IC_NAME), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!
  334.                
  335.                 if (need_save == 1) {
  336.                     //enet_debug("save setting.....");
  337.                     need_save = 0;
  338.                     enet_save_apply(&enet);
  339.                 }
  340.  
  341.                 break;
  342.                
  343.             case FIRMWARE_UPGRADE :
  344.                 enet_debug("recv cmd: %d  FIRMWARE_UPGRADE", cmd);
  345.                 enet_attach_runtime((void**)&rt);
  346.                 enet_avs_src_stop(&rt->avs_svr.src);
  347.                 enet_avs_ctl_stop(&rt->avs_svr.ctl);
  348.                 enet_detach_runtime((void**)&rt);
  349.                 sprintf(tftp_cmd, "/usr/bin/tftp get %s:newimg.bin", inet_ntoa(agentd_svr->sin_addr));
  350.                 system(tftp_cmd);
  351.                 enet_reboot();
  352.                 break;
  353.                
  354.             case FACTORY_DEFAULT :
  355.                 enet_debug("recv cmd: %d  FACTORY_DEFAULT", cmd);
  356.                 enet_reset();
  357.                 break;
  358.            
  359. #ifdef ENET_SUPPORT_WLAN
  360.             case GETWLAN_COMMAND :
  361.                 agentd_svr->sin_addr.s_addr = INADDR_BROADCAST;        
  362.             case GETWLAN_COMMAND_MANUAL :
  363.                 //if (agentd_svr->sin_addr.s_addr == INADDR_BROADCAST)
  364.                 //    enet_debug("recv cmd: %d  GETWLAN_COMMAND", cmd);
  365.                 //else
  366.                 //    enet_debug("recv cmd: %d  GETWLAN_COMMAND_MANUAL", cmd);
  367.                 // ref enet_wireless.h
  368.                
  369.                 bzero(&wlaninfo, sizeof(WLANINFO));
  370.                
  371.                 memcpy(wlaninfo.SSID, enet.wl_g.ssid, 32);
  372.                 wlaninfo.SSID[32] = '\0';
  373.  
  374.                 switch (enet.wl_g.auth)
  375.                 {
  376.                     case 0 : // None
  377.                         wlaninfo.auth_mode = 0;
  378.                         wlaninfo.Encryption = 0;
  379.                         break;
  380.  
  381.                     case 1 : // Open
  382.                         wlaninfo.auth_mode = 1;
  383.                         if (enet.wl_g.encry == 0) // None
  384.                             wlaninfo.Encryption = 0;
  385.                         else if (enet.wl_g.encry == 1) // WEP
  386.                         {
  387.                             wlaninfo.Encryption = enet.wl_g.wep_keysize + 1;
  388.                             wlaninfo.Key_Format = 1 - enet.wl_g.wep_keytype;
  389.                         }
  390.                         break;
  391.  
  392.                     case 2 : // Shared
  393.                         wlaninfo.auth_mode = 2;
  394.                         wlaninfo.Encryption = enet.wl_g.wep_keysize + 1;
  395.                         wlaninfo.Key_Format = 1 - enet.wl_g.wep_keytype;
  396.                         break;
  397.  
  398.                     case 3 : // WPAPSK
  399.                         wlaninfo.auth_mode = 3;
  400.                         if (enet.wl_g.encry == 2)
  401.                             wlaninfo.Encryption = 3;
  402.                         else if (enet.wl_g.encry == 3)
  403.                             wlaninfo.Encryption = 4;
  404.                        
  405.                         break;
  406.                     case 4 : // WPA2PSK
  407.                         wlaninfo.auth_mode = 4;
  408.                         if (enet.wl_g.encry == 2)
  409.                             wlaninfo.Encryption = 3;
  410.                         else if (enet.wl_g.encry == 3)
  411.                             wlaninfo.Encryption = 4;
  412.                        
  413.                         break;
  414.  
  415.                     case 5 : // WPANone
  416.                         wlaninfo.auth_mode = 5;
  417.                         if (enet.wl_g.encry == 2)
  418.                             wlaninfo.Encryption = 3;
  419.                         else if (enet.wl_g.encry == 3)
  420.                             wlaninfo.Encryption = 4;
  421.                        
  422.                         break;
  423.                 }
  424.                
  425.                 /*
  426.                 if (enet.wl_g.auth == 0 || (enet.wl_g.auth == 1 && enet.wl_g.encry == 0)) //( None or (Open&&None))
  427.                     wlaninfo.Encryption = 0;
  428.                 else
  429.                     wlaninfo.Encryption = (enet.wl_g.wep_keysize == WL_WEP_64_BITS) ? 1 : 2;
  430.                
  431.                 */
  432.                 //enet_debug("Encryption:%d", wlaninfo.Encryption);
  433.                 wlaninfo.Key_Format = enet.wl_g.wep_keytype == 0 ? 1 : 0; // 0 : ASCII, 1: HEX  (enet: 0:hex 1:ascii)
  434.                 wlaninfo.Default_Key = enet.wl_g.defkey;
  435.                
  436.                 //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  437.                 if (enet.wl_g.wep_keysize == WL_WEP_64_BITS && enet.wl_g.wep_keytype == 1) { //ACSII 64 bit
  438.                     // Key 1
  439.                     sprintf(wlaninfo.Key[0], "%02X%02X%02X%02X%02X",
  440.                     enet.wl_g.wepkey1[0], enet.wl_g.wepkey1[1],enet.wl_g.wepkey1[2],enet.wl_g.wepkey1[3],enet.wl_g.wepkey1[4]);
  441.  
  442.                     // Key 2
  443.                     sprintf(wlaninfo.Key[1], "%02X%02X%02X%02X%02X",
  444.                     enet.wl_g.wepkey2[0], enet.wl_g.wepkey2[1],enet.wl_g.wepkey2[2],enet.wl_g.wepkey2[3],enet.wl_g.wepkey2[4]);
  445.  
  446.                     // Key 3
  447.                     sprintf(wlaninfo.Key[2], "%02X%02X%02X%02X%02X",
  448.                     enet.wl_g.wepkey3[0], enet.wl_g.wepkey3[1],enet.wl_g.wepkey3[2],enet.wl_g.wepkey3[3],enet.wl_g.wepkey3[4]);
  449.  
  450.                     // Key 4
  451.                     sprintf(wlaninfo.Key[3], "%02X%02X%02X%02X%02X",
  452.                     enet.wl_g.wepkey4[0], enet.wl_g.wepkey4[1],enet.wl_g.wepkey4[2],enet.wl_g.wepkey4[3],enet.wl_g.wepkey4[4]);
  453.                 }
  454.  
  455.                 if (enet.wl_g.wep_keysize == WL_WEP_128_BITS && enet.wl_g.wep_keytype == 1) { //ACSII 128 bit
  456.                     // Key 1
  457.                     sprintf(wlaninfo.Key[0], "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
  458.                     enet.wl_g.wepkey1[0], enet.wl_g.wepkey1[1],enet.wl_g.wepkey1[2],enet.wl_g.wepkey1[3],enet.wl_g.wepkey1[4],
  459.                     enet.wl_g.wepkey1[5], enet.wl_g.wepkey1[6],enet.wl_g.wepkey1[7],enet.wl_g.wepkey1[8],enet.wl_g.wepkey1[9],
  460.                     enet.wl_g.wepkey1[10], enet.wl_g.wepkey1[11],enet.wl_g.wepkey1[12]);
  461.                    
  462.                     // Key 2
  463.                     sprintf(wlaninfo.Key[1], "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
  464.                     enet.wl_g.wepkey2[0], enet.wl_g.wepkey2[1],enet.wl_g.wepkey2[2],enet.wl_g.wepkey2[3],enet.wl_g.wepkey2[4],
  465.                     enet.wl_g.wepkey2[5], enet.wl_g.wepkey2[6],enet.wl_g.wepkey2[7],enet.wl_g.wepkey2[8],enet.wl_g.wepkey2[9],
  466.                     enet.wl_g.wepkey2[10], enet.wl_g.wepkey2[11],enet.wl_g.wepkey2[12]);
  467.  
  468.                     // Key 3
  469.                     sprintf(wlaninfo.Key[2], "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
  470.                     enet.wl_g.wepkey3[0], enet.wl_g.wepkey3[1],enet.wl_g.wepkey3[2],enet.wl_g.wepkey3[3],enet.wl_g.wepkey3[4],
  471.                     enet.wl_g.wepkey3[5], enet.wl_g.wepkey3[6],enet.wl_g.wepkey3[7],enet.wl_g.wepkey3[8],enet.wl_g.wepkey3[9],
  472.                     enet.wl_g.wepkey3[10], enet.wl_g.wepkey3[11],enet.wl_g.wepkey3[12]);
  473.  
  474.                     // Key 4
  475.                     sprintf(wlaninfo.Key[3], "%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
  476.                     enet.wl_g.wepkey4[0], enet.wl_g.wepkey4[1],enet.wl_g.wepkey4[2],enet.wl_g.wepkey4[3],enet.wl_g.wepkey4[4],
  477.                     enet.wl_g.wepkey4[5], enet.wl_g.wepkey4[6],enet.wl_g.wepkey4[7],enet.wl_g.wepkey4[8],enet.wl_g.wepkey4[9],
  478.                     enet.wl_g.wepkey4[10], enet.wl_g.wepkey4[11],enet.wl_g.wepkey4[12]);
  479.                 }
  480.  
  481.                 if (enet.wl_g.wep_keysize == WL_WEP_64_BITS && enet.wl_g.wep_keytype == 0) { // HEX 64 bit
  482.                     memcpy(wlaninfo.Key[0], enet.wl_g.wepkey1, 10);
  483.                     memcpy(wlaninfo.Key[1], enet.wl_g.wepkey2, 10);
  484.                     memcpy(wlaninfo.Key[2], enet.wl_g.wepkey3, 10);
  485.                     memcpy(wlaninfo.Key[3], enet.wl_g.wepkey4, 10);
  486.                 }
  487.  
  488.                 if (enet.wl_g.wep_keysize == WL_WEP_128_BITS && enet.wl_g.wep_keytype == 0) { // HEX 128 bit
  489.                     memcpy(wlaninfo.Key[0], enet.wl_g.wepkey1, 26);
  490.                     memcpy(wlaninfo.Key[1], enet.wl_g.wepkey2, 26);
  491.                     memcpy(wlaninfo.Key[2], enet.wl_g.wepkey3, 26);
  492.                     memcpy(wlaninfo.Key[3], enet.wl_g.wepkey4, 26);
  493.                 }
  494.                 /*
  495.                 enet_debug("enet key1:%s.", enet.wl_g.wepkey1);
  496.                 enet_debug("enet key2:%s.", enet.wl_g.wepkey2);
  497.                 enet_debug("enet key3:%s.", enet.wl_g.wepkey3);
  498.                 enet_debug("enet key4:%s.", enet.wl_g.wepkey4);
  499.                 enet_debug("wlaninfo.Key[0]:%s.", wlaninfo.Key[0]);
  500.                 enet_debug("wlaninfo.Key[1]:%s.", wlaninfo.Key[1]);
  501.                 enet_debug("wlaninfo.Key[2]:%s.", wlaninfo.Key[2]);
  502.                 enet_debug("wlaninfo.Key[3]:%s.", wlaninfo.Key[3]);
  503.                 */
  504.                 //XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  505.  
  506.                 memcpy(wlaninfo.WPA_KEY, enet.wl_g.wpakey, 64);
  507.                 wlaninfo.WPA_KEY[64] = 0;
  508.  
  509.                 //check if already connected to AP
  510.                 get_ap_info(&wlaninfo);
  511.  
  512.                 //enet_debug("wlaninfo.WPA_KEY:%s.", wlaninfo.WPA_KEY);
  513.                
  514.                 if (enet.wl_g.enable == 0 || has_no_wireless) //wireless is disabled
  515.                     wlaninfo.Network_Type = 0;
  516.                 else
  517.                     wlaninfo.Network_Type = (enet.wl_g.mode == WL_MODE_STA_INFRA) ? 2 : 1;
  518.                
  519.                 //enet_debug("wlaninfo.Network_Type:%d", wlaninfo.Network_Type);
  520.                
  521.                 SetTCPCfgPkt(&cfgret, cmd, mynodeid);
  522.                 memcpy(send_buf, &cfgret, sizeof(TCPCFG));
  523.                 memcpy(send_buf + sizeof(TCPCFG), &wlaninfo, sizeof(WLANINFO));
  524.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(WLANINFO), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!
  525.                 usleep(10000);
  526.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(WLANINFO), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!            
  527.                 usleep(10000);
  528.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(WLANINFO), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!            
  529.                 break;
  530.  
  531.             case SITESURVEY_COMMAND :
  532.                 agentd_svr->sin_addr.s_addr = INADDR_BROADCAST;
  533.             case SITESURVEY_COMMAND_MANUAL :
  534.                 //if (agentd_svr->sin_addr.s_addr == INADDR_BROADCAST)
  535.                 //    enet_debug("recv cmd: %d  SITESURVEY_COMMAND", cmd);
  536.                 //else
  537.                 //    enet_debug("recv cmd: %d  SITESURVEY_COMMAND_MANUAL", cmd);
  538.                 /*
  539.                     STATUS_WLAN = 0,
  540.                     STATUS_LAN = 1
  541.                 */
  542.                 if (enet.wl_g.enable == 0 || g_link_status == 1) {
  543.                     enet_set_essid_any(); // modify configuration file
  544.                     //system("/sbin/ifconfig ra0 up"); obsoleted, admin doesn't user this command anymore
  545.                 }
  546.  
  547.                 for (i = 0 ; i < 3 ; i++) {
  548.                     ap_num = admin_site_survey(sites);
  549.                     if (ap_num > 0) break;
  550.                     sleep(1);
  551.                 }
  552.    
  553.                 if (enet.wl_g.enable == 0 || g_link_status == 1) {
  554.                     //system("/sbin/ifconfig ra0 down"); obsoleted, obsoleted, admin doesn't user this command anymore
  555.                     enet_restore_essid(&(enet.wl_g)); // restore configuration file
  556.                 }
  557.  
  558.                 if (ap_num > 0)
  559.                 {
  560.                     ap_num = (ap_num > 20) ? 20 : ap_num;
  561.                     SetTCPCfgPkt(&cfgret, cmd, mynodeid);
  562.                     memcpy(send_buf, &cfgret, sizeof(TCPCFG));
  563.                     memcpy(send_buf + sizeof(TCPCFG), sites, sizeof(SITESURVEY)*ap_num);
  564.                     sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(SITESURVEY)*ap_num, 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!
  565.                     //usleep(10000);
  566.                     //sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(SITESURVEY)*ap_num, 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!
  567.                     //usleep(10000);
  568.                     //sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(SITESURVEY)*ap_num, 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!             
  569.                 }
  570.                 else
  571.                 {
  572.                     SetTCPCfgPkt(&cfgret, cmd, mynodeid);
  573.                     memcpy(send_buf, &cfgret, sizeof(TCPCFG));
  574.                     sendto(sock, send_buf, sizeof(TCPCFG), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  575.                     //usleep(10000);
  576.                     //sendto(sock, send_buf, sizeof(TCPCFG), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  577.                     //usleep(10000);
  578.                     //sendto(sock, send_buf, sizeof(TCPCFG), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  579.                 }
  580.  
  581.                 break;
  582. #endif
  583.             case LED_ON_OFF_COMMAND :
  584.                 agentd_svr->sin_addr.s_addr = INADDR_BROADCAST;
  585.             case LED_ON_OFF_COMMAND_MANUAL :
  586.                 break;
  587.  
  588.             case READ_EMAIL_AUTH :
  589.                 agentd_svr->sin_addr.s_addr = INADDR_BROADCAST;
  590.             case READ_EMAIL_AUTH_MANUAL :
  591.                 //if (agentd_svr->sin_addr.s_addr == INADDR_BROADCAST)
  592.                 //    enet_debug("recv cmd: %d  READ_EMAIL_AUTH", cmd);
  593.                 //else
  594.                 //    enet_debug("recv cmd: %d  READ_EMAIL_AUTH_MANUAL", cmd);
  595.                 memset(&email_auth, 0, sizeof(email_auth));
  596.                 email_auth.emailauth = enet.email.email_auth;
  597.                 memcpy(email_auth.emailaccount, enet.email.username, 32);
  598.                 memcpy(email_auth.emailpassword, enet.email.passwd, 32);
  599.                 memcpy(email_auth.emailsender, enet.email.retn, 32);
  600.  
  601.                 SetTCPCfgPkt(&cfgret, cmd, mynodeid);
  602.                 memcpy(send_buf, &cfgret, sizeof(TCPCFG));
  603.                 memcpy(send_buf + sizeof(TCPCFG), &email_auth, sizeof(email_auth));
  604.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(email_auth), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!
  605.                 usleep(10000);
  606.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(email_auth), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!
  607.                 usleep(10000);
  608.                 sendto(sock, send_buf, sizeof(TCPCFG) + sizeof(email_auth), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in)); //server maxinum only read 1024 bytes!                
  609.                 break;
  610.  
  611.             case SET_EMAIL_AUTH :
  612.                 //enet_debug("recv cmd: %d  SET_EMAIL_AUTH", cmd);
  613.                 memset(&email_auth, 0, sizeof(email_auth));
  614.                 memcpy(&email_auth, buf + sizeof(TCPCFG), sizeof(email_auth));
  615.                
  616.                 enet.email.email_auth = email_auth.emailauth;
  617.                 memcpy(enet.email.username, email_auth.emailaccount, 32);
  618.                 memcpy(enet.email.passwd, email_auth.emailpassword, 32);
  619.                 memcpy(enet.email.retn, email_auth.emailsender, 32);
  620.                 //enet_debug("%d %s %s %s", enet.email.email_auth, enet.email.username, enet.email.passwd, email_auth.emailsender);
  621.                 //enet_save_apply(&enet);
  622.                 enet_save_to_rt(&enet);
  623.                 enet_apply();
  624.                 need_save = 1;
  625.                 break;
  626.  
  627.             case SEND_TEST_EMAIL :
  628.                 //enet_debug("recv cmd: %d  SEND_TEST_EMAIL", cmd);
  629.                 memset(&testmail, 0, sizeof(testmail));
  630.                 memcpy(&testmail, buf, sizeof(testmail));
  631.                
  632.                 enet.email.email_auth = testmail.email_auth;
  633.                 memcpy(enet.email.username, testmail.email_account, 32);
  634.                 memcpy(enet.email.passwd, testmail.email_password, 32);
  635.                 memcpy(enet.email.retn, testmail.email_sender, 32);
  636.  
  637.                                         memcpy(enet.email.rcpt, testmail.email_receive, 32);
  638.  
  639.                 memcpy(enet.email.server, testmail.email_server, 32);
  640.                 //enet_save_apply(&enet);
  641.                 enet_save_to_rt(&enet);
  642.                 enet_apply();
  643.                 enet_test_email();
  644.                 need_save = 1;
  645.                 break;
  646.            
  647.             case READ_FTP_SETTING :
  648.                 agentd_svr->sin_addr.s_addr = INADDR_BROADCAST;
  649.             case READ_FTP_SETTING_MANUAL :
  650.                 //if (agentd_svr->sin_addr.s_addr == INADDR_BROADCAST)
  651.                 //    enet_debug("recv cmd: %d  READ_FTP_SETTING", cmd);
  652.                 //else
  653.                 //    enet_debug("recv cmd: %d  READ_FTP_SETTING_MANUAL", cmd);
  654.                 memset(&ftp, 0, sizeof(ftp));
  655.                 SetTCPCfgPkt(&ftp.header, cmd, mynodeid);
  656.                 memcpy(ftp.Server, enet.avs.ftp.server, 64);
  657.                 ftp.Port = enet.avs.ftp.port;
  658.                 ftp.Port = htonl(ftp.Port);
  659.                 memcpy(ftp.UserName, enet.avs.ftp.user, 32);
  660.                 memcpy(ftp.Password, enet.avs.ftp.passwd, 32);
  661.                 memcpy(ftp.Folder, enet.avs.ftp.path, 128);
  662.                 ftp.Passive = enet.avs.ftp.passive;
  663.                 memcpy(send_buf, &ftp, sizeof(FTP_SETTING));
  664.                 sendto(sock, send_buf, sizeof(FTP_SETTING), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  665.                 usleep(10000);
  666.                 sendto(sock, send_buf, sizeof(FTP_SETTING), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  667.                 usleep(10000);
  668.                 sendto(sock, send_buf, sizeof(FTP_SETTING), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  669.                 break;
  670.  
  671.             case SET_FTP_SETTING :
  672.                 //enet_debug("recv cmd: %d  SET_FTP_SETTING", cmd);
  673.                 memset(&ftp, 0, sizeof(FTP_SETTING));
  674.                 memcpy(&ftp, buf, sizeof(FTP_SETTING));
  675.                 memcpy(enet.avs.ftp.server,ftp.Server, 64);
  676.                 enet.avs.ftp.port = ntohl(ftp.Port);
  677.                 memcpy(enet.avs.ftp.user, ftp.UserName, 32);
  678.                 memcpy(enet.avs.ftp.passwd, ftp.Password, 32);
  679.                 memcpy(enet.avs.ftp.path, ftp.Folder, 128);
  680.                 enet.avs.ftp.passive = ftp.Passive;
  681.                 //enet_save_apply(&enet);
  682.                 enet_save_to_rt(&enet);
  683.                 enet_apply();
  684.                 need_save = 1;
  685.                 break;
  686.  
  687.             case READ_PPPOE_SETTING :
  688.                 agentd_svr->sin_addr.s_addr = INADDR_BROADCAST;
  689.             case READ_PPPOE_SETTING_MANUAL :
  690.                 //if (agentd_svr->sin_addr.s_addr == INADDR_BROADCAST)
  691.                 //    enet_debug("recv cmd: %d  READ_PPPOE_SETTING", cmd);
  692.                 //else
  693.                 //    enet_debug("recv cmd: %d  READ_PPPOE_SETTING_MANUAL", cmd);
  694.                 memset(&pppoe, 0, sizeof(pppoe));
  695.                 SetTCPCfgPkt(&pppoe.header, cmd, mynodeid);
  696.                 pppoe.MTU = htonl(enet.pppoe.mtu);
  697.                 memcpy(pppoe.UserName, enet.pppoe.username, 64);
  698.                 memcpy(pppoe.Password, enet.pppoe.passwd, 64);
  699.                 memcpy(send_buf, &pppoe, sizeof(PPPOE_SETTING));
  700.                 sendto(sock, send_buf, sizeof(PPPOE_SETTING), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  701.                 usleep(10000);
  702.                 sendto(sock, send_buf, sizeof(PPPOE_SETTING), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  703.                 usleep(10000);
  704.                 sendto(sock, send_buf, sizeof(PPPOE_SETTING), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  705.                 break;
  706.             case SET_PPPOE_SETTING :
  707.                 //enet_debug("recv cmd: %d  SET_PPPOE_SETTING", cmd);
  708.                 memset(&pppoe, 0, sizeof(PPPOE_SETTING));
  709.                 memcpy(&pppoe, buf, sizeof(PPPOE_SETTING));
  710.                 enet.pppoe.mtu = ntohl(pppoe.MTU);
  711.                 memcpy(enet.pppoe.username, pppoe.UserName, 64);
  712.                 memcpy(enet.pppoe.passwd, pppoe.Password, 64);
  713.                 //enet_save_apply(&enet);
  714.                 enet_save_to_rt(&enet);
  715.                 enet_apply();
  716.                 need_save = 1;
  717.                 break;
  718.  
  719.             case GET_USERS :
  720.                 agentd_svr->sin_addr.s_addr = INADDR_BROADCAST;
  721.             case GET_USERS_MANUAL :
  722.                 //if (agentd_svr->sin_addr.s_addr == INADDR_BROADCAST)
  723.                 //    enet_debug("recv cmd: %d  GET_USERS", cmd);
  724.                 //else
  725.                 //    enet_debug("recv cmd: %d  GET_USERS_MANUAL", cmd);
  726.                 memset(&users, 0, sizeof(users));
  727.                 SetTCPCfgPkt(&users.header, cmd, mynodeid);
  728.                 for (i = 0 ; i < 4 ; i++)
  729.                 {
  730.                     strncpy(users.users[i], enet.users[i].login, IPCAM_LOGIN_LEN);
  731.                     strncpy(users.passwd[i], enet.users[i].passwd, IPCAM_PASSWD_LEN);
  732.                     if (enet.users[i].enabled)
  733.                         users.check |= 1 << i;
  734.  
  735.                     //enet_debug("%s %s %X", users.users[i], users.passwd[i], users.check);
  736.                 }
  737.                 memcpy(send_buf, &users, sizeof(users));
  738.                 sendto(sock, send_buf, sizeof(users), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  739.                 usleep(10000);
  740.                 sendto(sock, send_buf, sizeof(users), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  741.                 usleep(10000);
  742.                 sendto(sock, send_buf, sizeof(users), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  743.                 break;
  744.  
  745.             case SET_USERS :
  746.                 //enet_debug("recv cmd: %d  SET_USERS", cmd);
  747.  
  748.                 // delete all normal users first
  749.                 userid = umGetFirstUser();
  750.                 while (userid) {
  751.                     if (!strcmp(umGetUserGroup(userid), "guest")) {
  752.                         if (umDeleteUser(userid) == 0) {
  753.                             userid = umGetFirstUser();
  754.                         }
  755.                     }
  756.                     else
  757.                         userid = umGetNextUser(userid);
  758.                 }
  759.  
  760.                 memset(&users, 0, sizeof(users));
  761.                 memcpy(&users, buf, sizeof(users));
  762.                 for (i = 0 ; i < 4 ; i++)
  763.                 {
  764.                     strncpy(enet.users[i].login, users.users[i], IPCAM_LOGIN_LEN);
  765.                     strncpy(enet.users[i].passwd, users.passwd[i], IPCAM_PASSWD_LEN);
  766.                     if (users.check & 1 << i)
  767.                     {
  768.                         enet.users[i].enabled = 1;
  769.                         umAddUser(users.users[i], users.passwd[i], "guest", 0, 0);
  770.                     }
  771.                     else
  772.                         enet.users[i].enabled = 0;
  773.  
  774.                     //enet_debug("%s %s %X", enet.users[i].login, enet.users[i].passwd, enet.users[i].enabled);
  775.                 }
  776.                 //enet_save_apply(&enet);
  777.                 enet_save_to_rt(&enet);
  778.                 enet_apply();
  779.                 need_save = 1;
  780.                 break;
  781.            
  782.             case READ_TIME_SETTING :
  783.                 agentd_svr->sin_addr.s_addr = INADDR_BROADCAST;
  784.             case READ_TIME_SETTING_MANUAL :
  785.                 //if (agentd_svr->sin_addr.s_addr == INADDR_BROADCAST)
  786.                 //    enet_debug("recv cmd: %d  READ_TIME_SETTING", cmd);
  787.                 //else
  788.                 //    enet_debug("recv cmd: %d  READ_TIME_SETTING_MANUAL", cmd);
  789.                 enet_load(&enet);
  790.                 memset(&datetime, 0, sizeof(datetime));
  791.                 SetTCPCfgPkt(&datetime.header, cmd, mynodeid);
  792.                 datetime.timezone = htonl(enet.ntp.tz);
  793.                 //ntp_addr.s_addr = enet.ntp.ntpserver;
  794.                 //strcpy(datetime.server, inet_ntoa(ntp_addr));
  795.                 strncpy(datetime.server, enet.ntp.ntpservername, 31); datetime.server[31] = 0;
  796.                 //enet_debug("ntp server:%s", datetime.server);
  797.                 datetime.mode = enet.ntp.mode;
  798.                 memcpy(send_buf, &datetime, sizeof(datetime));
  799.                 sendto(sock, send_buf, sizeof(datetime), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  800.                 usleep(10000);
  801.                 sendto(sock, send_buf, sizeof(datetime), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  802.                 usleep(10000);
  803.                 sendto(sock, send_buf, sizeof(datetime), 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  804.                 break;
  805.            
  806.             case SET_TIME_SETTING :
  807.                 //enet_debug("recv cmd: %d  SET_TIME_SETTING", cmd);
  808.                 enet_load(&enet);
  809.                 memset(&datetime, 0, sizeof(datetime));
  810.                 memcpy(&datetime, buf, sizeof(datetime));
  811.                 datetime.timezone = ntohl(datetime.timezone);
  812.                 if (datetime.mode == 0) //manual
  813.                 {
  814.                     enet.ntp.mode = 0;
  815.                     //enet_debug("datetime.timezone:%d", datetime.timezone);
  816.                     for (i = 0; i < num_enet_tz; i++) {
  817.                         if (enet_tz[i].tz == datetime.timezone) {
  818.                             enet.ntp.tz = enet_tz[i].tz;
  819.                             enet.ntp.mw = enet_tz[i].mw;
  820.                         }
  821.                     }
  822.                     enet_form_set_date_time(ntohl(datetime.year),
  823.                                             ntohl(datetime.month),
  824.                                             ntohl(datetime.day),
  825.                                             ntohl(datetime.hour),
  826.                                             ntohl(datetime.minutes),
  827.                                             ntohl(datetime.second));
  828.                 }
  829.                 else if (datetime.mode == 1) // ntp
  830.                 {
  831.                     //enet.ntp.ntpserver = inet_addr(datetime.server);
  832.                     strcpy(enet.ntp.ntpservername, datetime.server);
  833.                     for (i = 0; i < num_enet_tz; i++) {
  834.                         if (enet_tz[i].tz == datetime.timezone) {
  835.                             enet.ntp.tz = enet_tz[i].tz;
  836.                             enet.ntp.mw = enet_tz[i].mw;
  837.                         }
  838.                     }
  839.                     enet.ntp.mode = 1;
  840.                     //enet_sync_ntp(); this blocks too long
  841.                 }
  842.                 //enet_save_apply(&enet);
  843.                 enet_save_to_rt(&enet);
  844.                 enet_apply();
  845.                 need_save = 1;
  846.                 break;
  847.  
  848.             default:
  849.                 //enet_debug("recv cmd: %d  Unknown command!", cmd);
  850.                 break;
  851.         }
  852.     }
  853.     else {
  854.        
  855.         /*
  856.          * check special case (Tester �M��)
  857.          */
  858.        
  859.         // Tester: set Domain Channel (Wireless Country Region)
  860.         if (buf[6] == 0x06 && buf[7] == 0x00 && buf[8] == 0xF9 && buf[9] == 0xFF && buf[10] == 0x00 && buf[11] == 0x02)
  861.         {
  862.             enet_debug("recv cmd: set Domain Channel");
  863.             enet_load(&enet);
  864.             bzero(&cfgret, sizeof(TCPCFG));
  865.             memset(cfgret.NodeID, 0xFF, 6);
  866.             cfgret.edicfg[0] = 0x06;
  867.             cfgret.edicfg[1] = RESPONSE;
  868.             cfgret.edicfg[2] = 0xff - 0x06;
  869.             cfgret.edicfg[3] = 0xff - RESPONSE;
  870.             memcpy(send_buf, &cfgret, sizeof(TCPCFG));
  871.             memcpy(send_buf + 12, "PASS", sizeof(TCPCFG));
  872.             //enet_debug("Channel: %d-%d", buf[12], buf[13]);
  873.             #ifdef ENET_SUPPORT_WLAN
  874.             if (getRegionCountryNum(buf[12], buf[13]) >= 0)
  875.             {
  876.                 CountryRegion = getRegionCountryNum(buf[12], buf[13]);
  877.                 // enet_debug("CountryRegion:%d", CountryRegion);
  878.                 enet.wl_g.CountryRegion = CountryRegion;
  879.                 enet_save_apply(&enet);
  880.                
  881.                 // save CountryRegion to flash for reset-to-default
  882.                 if (saveCountryRegionFlash(CountryRegion) != HW_SETTING_LENGTH)
  883.                     memcpy(send_buf + 12, "FAIL", sizeof(TCPCFG));
  884.                
  885.             }
  886.             else
  887.             #endif
  888.                 memcpy(send_buf + 12, "FAIL", sizeof(TCPCFG));
  889.            
  890.             agentd_svr->sin_addr.s_addr = INADDR_BROADCAST;
  891.             sendto(sock, send_buf, 16, 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  892.         }
  893.         else if (buf[6] == 0x01 && buf[7] == 0x00 && buf[8] == 0xFE && buf[9] == 0xFF) // Tester: Upgrade FW
  894.         {
  895.             enet_debug("Tester: Upgrade FW");
  896.             enet_load(&enet);
  897.             sprintf(tftp_cmd, "/usr/bin/tftp get %s:run.bin", inet_ntoa(agentd_svr->sin_addr));
  898.             system(tftp_cmd);
  899.  
  900.             bzero(&cfgret, sizeof(TCPCFG));
  901.             memset(cfgret.NodeID, 0xFF, 6);
  902.             cfgret.edicfg[0] = 0x01;
  903.             cfgret.edicfg[1] = RESPONSE;
  904.             cfgret.edicfg[2] = 0xff - 0x01;
  905.             cfgret.edicfg[3] = 0xff - RESPONSE;
  906.             memcpy(send_buf, &cfgret, sizeof(TCPCFG));
  907.             memcpy(send_buf + 12, "PASS", sizeof(TCPCFG));
  908.             agentd_svr->sin_addr.s_addr = INADDR_BROADCAST;
  909.             sendto(sock, send_buf, 16, 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  910.             enet_reboot();
  911.         }
  912.         else // Tester: set Ethernet MAC ID
  913.         {
  914.             long command = *((long*)buf);
  915.             enet_load(&enet);
  916.             command = ntohl(command);
  917.             if (command == 22) {
  918.                 enet_debug("MAC: %X %X %X %X %X %X\n", buf[20], buf[21], buf[22], buf[23], buf[24], buf[25]);
  919.                 if (saveMACFlash(&buf[20]) == HW_SETTING_LENGTH) {
  920.                     enet_t enet;
  921.                     enet_factory(&enet);
  922.                     enet_save(&enet);
  923.                     //enet_save_apply(&enet);
  924.                     Set_MyNodeID();
  925.  
  926.                     // write anything
  927.                     memset(send_buf, 0xEE, 20);
  928.                     agentd_svr->sin_addr.s_addr = INADDR_BROADCAST;
  929.                     sendto(sock, send_buf, 16, 0, (struct sockaddr *)agentd_svr, sizeof(struct sockaddr_in));
  930.                 }
  931.             }
  932.         }
  933.     }
  934. }
  935.  
  936.  
  937. /**
  938.  * Start the agent and its threads
  939.  */
  940.  
  941. static void *agentd_thread(void *args)
  942. {
  943.     int sock;
  944.     int rval, fromlen;
  945.     unsigned char recv_buf[MAX_SIZE];
  946.     struct sockaddr_in svr;
  947.     struct sockaddr_in agentd_svr_addr;
  948.     enet_agentd_t *agentd = (enet_agentd_t *) args;
  949.     int t = 1;
  950.     enet_t enet;
  951.     TCPCFG cfgret;
  952.     IC_SETTING icsetting;
  953.     IC_NAME ic;
  954.     unsigned char cmd;
  955.     unsigned char send_buf[1024];
  956.     fd_set readfds;
  957.     struct timeval timeout;
  958.    
  959.  
  960.     enet_debug("enet agentd started  PID:%d", getpid());
  961.     Set_MyNodeID(); // mynodeid == mac address
  962.     enet_load(&enet);
  963.  
  964.     sock = socket(AF_INET, SOCK_DGRAM, 0);
  965.     if (sock < 0){
  966.         enet_perror("socket()");
  967.         return NULL;
  968.     }
  969.    
  970.     // neo@acelink: send a search reponse packet to alert admin-program
  971.     t = 1;
  972.     setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &t, sizeof(int));
  973.     memset(&svr, 0x0, sizeof(svr));
  974.     svr.sin_family = AF_INET;
  975.     svr.sin_addr.s_addr = INADDR_BROADCAST;
  976.     svr.sin_port = htons(ENET_AGENTD_PORT);
  977.    
  978.     bzero(send_buf, 1024);
  979.     bzero(&icsetting, sizeof(IC_SETTING));
  980.     cmd = SEARCH_IPCAM;
  981.     Set_IC_NAME(&ic, &enet);
  982.     SetTCPCfgPkt(&cfgret, cmd, mynodeid);
  983.     memcpy(send_buf, &cfgret, sizeof(TCPCFG));
  984.     memcpy(send_buf + sizeof(TCPCFG), &ic, sizeof(IC_NAME));
  985.     rval = sendto(sock,  send_buf, sizeof(TCPCFG) + sizeof(IC_NAME), 0, (struct sockaddr *)&svr, sizeof(svr));
  986.     usleep(10000);
  987.     rval = sendto(sock,  send_buf, sizeof(TCPCFG) + sizeof(IC_NAME), 0, (struct sockaddr *)&svr, sizeof(svr));
  988.     usleep(10000);
  989.     rval = sendto(sock,  send_buf, sizeof(TCPCFG) + sizeof(IC_NAME), 0, (struct sockaddr *)&svr, sizeof(svr));
  990.     close(sock);
  991.     // neo@acelink --end
  992.  
  993.     memset(&svr, 0x0, sizeof(svr));
  994.     svr.sin_family = AF_INET;
  995.     svr.sin_addr.s_addr = INADDR_ANY;
  996.     svr.sin_port = htons(ENET_AGENTD_PORT);
  997.  
  998.     sock = socket(AF_INET, SOCK_DGRAM, 0);
  999.     if (sock < 0){
  1000.         enet_perror("socket()");
  1001.         return NULL;
  1002.     }
  1003.  
  1004.     t = 1;
  1005.     setsockopt(sock, SOL_SOCKET, SO_BROADCAST, &t, sizeof(int));
  1006.     setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &t, sizeof(int));
  1007.     rval = bind(sock, (struct sockaddr *)&svr, sizeof(svr));
  1008.     if (rval < 0){
  1009.         enet_perror("bind()");
  1010.         close(sock);
  1011.         return NULL;
  1012.     }
  1013.  
  1014.     while (agentd->running){
  1015.         FD_ZERO(&readfds);
  1016.         FD_SET(sock, &readfds);
  1017.         timeout.tv_sec = 0;
  1018.         timeout.tv_usec = 50000;
  1019.         if ((rval = select(sock+1, &readfds, NULL, NULL, &timeout)) > 0) {
  1020.             if (FD_ISSET(sock, &readfds)) {
  1021.                 fromlen = sizeof(agentd_svr_addr);
  1022.                 rval = recvfrom(sock, recv_buf, sizeof(recv_buf), 0, (struct sockaddr *)&agentd_svr_addr, &fromlen);
  1023.                 if (rval < 0)
  1024.                     enet_perror("recvfrom()");
  1025.                
  1026.                 if(rval > 0){
  1027.                     dispatch(recv_buf, rval, sock, &agentd_svr_addr);
  1028.                 }
  1029.             }
  1030.         }
  1031.         else if (rval < 0) {
  1032.             //enet_perror("agentd:");
  1033.             agentd->running = 0;
  1034.         }
  1035.     }
  1036.  
  1037.     close(sock);
  1038.  
  1039.     enet_debug("enet_agentd end...");
  1040.  
  1041.     return NULL;
  1042. }
  1043.  
  1044.  
  1045. void write_proc_led(int led, int status)
  1046. {
  1047.     /*
  1048.      led:   POWER_LED   :("0")
  1049.             NETWORK_LED :("1")
  1050.      
  1051.      status:
  1052.         LED_OFF             (0)
  1053.         LED_ON              (1)
  1054.         LED_BLINK           (2)
  1055.         LED_RANDOM_BLINK    (3)
  1056.      */
  1057.     FILE *f = fopen("/proc/led", "w");
  1058.     if (f) {
  1059.         //fprintf(f, "%d", val);
  1060.         fprintf(f, "%d %d", led, status);
  1061.         fclose(f);
  1062.     }
  1063. }
  1064.  
  1065.  
  1066. // keep LAN/WLAN LED on or off
  1067. static void *led_thread(void *args)
  1068. {
  1069.     enet_agentd_t *agentd = (enet_agentd_t *) args;
  1070.     return NULL;
  1071. }
  1072.  
  1073. void enet_agentd_init(void *obj)
  1074. {
  1075.     enet_runtime_t *rt = (enet_runtime_t *) obj;
  1076.     enet_agentd_t *agentd = &rt->agentd;
  1077.  
  1078.     memset(agentd, 0x0, sizeof(*agentd));
  1079. }
  1080.  
  1081. void enet_agentd_start(void *obj)
  1082. {
  1083.     enet_runtime_t *rt = (enet_runtime_t *) obj;
  1084.     enet_agentd_t *agentd = &rt->agentd;
  1085.  
  1086.     if (agentd->running)
  1087.         return;
  1088.  
  1089.     agentd->running = 1;
  1090.  
  1091.     pthread_create(&agentd->thread, NULL, agentd_thread, agentd);
  1092.     pthread_create(&ledctl_handle, NULL, led_thread, agentd);
  1093. }
  1094.  
  1095. void enet_agentd_cleanup(void *obj)
  1096. {
  1097.     enet_agentd_stop(obj);
  1098. }
  1099.  
  1100. void enet_agentd_restart(void *obj)
  1101. {
  1102.     enet_agentd_stop(obj);
  1103.     enet_agentd_start(obj);
  1104. }
  1105. void enet_agentd_stop(void *obj)
  1106. {
  1107.     enet_runtime_t *rt = (enet_runtime_t *) obj;
  1108.     enet_agentd_t *agentd = &rt->agentd;
  1109.  
  1110.     if (!agentd->running)
  1111.         return;
  1112.  
  1113.     agentd->running = 0;
  1114.     pthread_join(agentd->thread, NULL);
  1115.     pthread_join(ledctl_handle, NULL);
  1116. }
  1117.  
  1118. bool enet_agentd_isrunning(void *obj)
  1119. {
  1120.     enet_runtime_t *rt = (enet_runtime_t *) obj;
  1121.     enet_agentd_t *agentd = &rt->agentd;
  1122.     return agentd->running;
  1123. }
  1124.  
  1125.  
  1126.  
  1127. //////////////////////////////////////////////////////////////////////////////
  1128. int saveCountryRegionFlash(int CountryRegion)
  1129. {
  1130.     int fh;
  1131.     int rval = -1;
  1132.     unsigned char val = CountryRegion;
  1133.     char buf[HW_SETTING_LENGTH];
  1134.  
  1135.     if ((fh = open (FLASH_DEVICE_NAME_HWINFO, O_RDWR)) < 0){
  1136.             fprintf(stderr, "Can't read from flash memory!");
  1137.             return -1;
  1138.     }
  1139.     else {
  1140.             read(fh, buf, HW_SETTING_LENGTH);
  1141.             buf[6] = val;
  1142.             lseek(fh, 0, SEEK_SET);
  1143.             rval = write(fh, buf, HW_SETTING_LENGTH);
  1144.             close(fh);
  1145.     }
  1146.    
  1147.     if (rval != HW_SETTING_LENGTH)
  1148.     {
  1149.         enet_debug("saveCountryRegionFlash(): write flash error!");
  1150.         perror("");
  1151.     }
  1152.  
  1153.     return rval;
  1154.  
  1155. }
  1156.  
  1157.  
  1158. int saveMACFlash(unsigned char *mac)
  1159. {  
  1160.     int fh;
  1161.     unsigned char mac_addr[6];
  1162.     int i, rval = -1;
  1163.     char buf[HW_SETTING_LENGTH];
  1164.  
  1165.    
  1166.     for (i = 0 ; i < 6 ; i++) {
  1167.         mac_addr[i] = *(mac+i);
  1168.         fprintf(stderr, "%02X\n", mac_addr[i]);
  1169.     }
  1170.  
  1171.     if ((fh = open (FLASH_DEVICE_NAME_HWINFO, O_RDWR)) < 0){
  1172.             fprintf(stderr, "Can't read from flash memory!");
  1173.     }
  1174.     else {
  1175.             read(fh, buf, HW_SETTING_LENGTH);
  1176.             memcpy(buf, mac_addr, 6);
  1177.             lseek(fh, 0, SEEK_SET);
  1178.             rval = write(fh, buf, HW_SETTING_LENGTH);
  1179.             close(fh);
  1180.     }
  1181.  
  1182.     if (rval != HW_SETTING_LENGTH)
  1183.     {
  1184.         enet_debug("saveMACFlash(): write flash error!");
  1185.         perror("");
  1186.     }
  1187.  
  1188.     return rval;
  1189. }
  1190.  
  1191.  
  1192. void getRegionCountryRange(int cr, int *a, int *b)
  1193. {
  1194. #ifdef RT2500
  1195.     switch (cr)
  1196.     {
  1197.         case 0 : *a = 1 ; *b = 11; break;
  1198.         case 1 : *a = 1 ; *b = 11; break;
  1199.         case 2 : *a = 1 ; *b = 13; break;
  1200.         case 3 : *a = 10 ; *b = 11; break;
  1201.         case 4 : *a = 10 ; *b = 13; break;
  1202.         case 5 : *a = 14 ; *b = 14; break;
  1203.         case 6 : *a = 1 ; *b = 14; break;
  1204.         case 7 : *a = 3 ; *b = 9; break;
  1205.     }
  1206. #elif defined (RT2561)  || defined (RT2860)
  1207.     switch (cr)
  1208.     {
  1209.         case 0 : *a = 1 ; *b = 11; break;
  1210.         case 1 : *a = 1 ; *b = 13; break;
  1211.         case 2 : *a = 10 ; *b = 11; break;
  1212.         case 3 : *a = 10 ; *b = 13; break;
  1213.         case 4 : *a = 14 ; *b = 14; break;
  1214.         case 5 : *a = 1 ; *b = 14; break;
  1215.         case 6 : *a = 3 ; *b = 9; break;
  1216.     }
  1217. #endif
  1218. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement