daily pastebin goal
48%
SHARE
TWEET

Untitled

a guest Jan 23rd, 2012 227 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  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. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top