int Config_GetPPP(HTTPCONNECTION hConnection, LIST *pParamList, int iAction, XML *pReturnXML) { int i; switch (iAction) { case CA_AUTH: return AUTH_USER; case CA_CONFIG: tt_rmutex_lock(&g_rmutex); AddHttpNum(pReturnXML, "Enable", g_ConfigParam.bPPPEnable); for (i = 0; i < sizeof(g_ConfigParam.aacPPPServer) / sizeof(g_ConfigParam.aacPPPServer[0]); ++i) { char acName[32]; snprintf(acName, sizeof(acName), "Server%d", i); AddHttpValue(pReturnXML, acName, g_ConfigParam.aacPPPServer[i]); } for (i = 0; i < sizeof(g_ConfigParam.aiPPPPort) / sizeof(g_ConfigParam.aiPPPPort[0]); ++i) { char acName[32]; snprintf(acName, sizeof(acName), "Port%d", i); AddHttpNum(pReturnXML, acName, g_ConfigParam.aiPPPPort[i]); } AddHttpValue(pReturnXML, "User", g_ConfigParam.acPPPUser); AddHttpValue(pReturnXML, "Pass", g_ConfigParam.acPPPPass); AddHttpValue(pReturnXML, "Status", (ppot_is_online() ? "online" : "offline")); tt_rmutex_unlock(&g_rmutex); return 0; } return -1; }
void thread_entry(void *arg) { THREAD_ARG_T *the_arg = (THREAD_ARG_T *)arg; while(1) { int i; int value; /* Show LED so that users know that the thread is running. */ int cur_ticks = tt_get_ticks (); if(cur_ticks % 64 < 32) DrvGPIO_SetBit(the_arg->gpio_group, the_arg->gpio_bit); /* Turn off LED */ else DrvGPIO_ClrBit(the_arg->gpio_group, the_arg->gpio_bit); /* Turn on LED */ /* Lock the mutex */ tt_rmutex_lock(the_arg->mutex); /* Update value */ for(i = 0; i < THREAD_NUM; ++i) ++the_arg->value[i]; /* (Recursive) Lock the mutex again */ tt_rmutex_lock(the_arg->mutex); /* Check the lock operation by checking value */ value = the_arg->value[0]; for(i = 0; i < THREAD_NUM; ++i) { if(the_arg->value[i] != value) { /* To run to here indicates that the test for mutex lock has been failed. */ tt_printf("Failed\n"); while(1); } } /* (Recursive) Unlock the mutex */ tt_rmutex_unlock(the_arg->mutex); /* Unlock the mutex */ tt_rmutex_unlock(the_arg->mutex); } }
void vjpegLock (void) { #ifndef ECOS tt_rmutex_lock (&g_vpJPEG.mtLock); #else cyg_mutex_lock (&g_vpJPEG.mtLock); #endif }
int Config_SetUPnP(HTTPCONNECTION hConnection, LIST *pParamList, int iAction, XML *pReturnXML) { BOOL bEnableUPnP; unsigned short usUPnPPort; const char *acWatchdogIP; switch (iAction) { case CA_AUTH: return AUTH_ADMIN; case CA_CONFIG: if (httpIsExistParam(pParamList, "Enable")) bEnableUPnP = httpGetBool(pParamList, "Enable"); else bEnableUPnP = g_ConfigParam.bEnableUPnP; if (httpIsExistParam(pParamList, "Port")) usUPnPPort = httpGetLong(pParamList, "Port"); else usUPnPPort = g_ConfigParam.usUPnPPort; if (httpIsExistParam(pParamList, "WatchdogIP")) acWatchdogIP = httpGetString(pParamList, "WatchdogIP"); if (bEnableUPnP != g_ConfigParam.bEnableUPnP || usUPnPPort != g_ConfigParam.usUPnPPort || strcmp(acWatchdogIP, g_ConfigParam.acWatchdogIP)) { tt_rmutex_lock(&g_rmutex); g_ConfigParam.bEnableUPnP = bEnableUPnP; g_ConfigParam.usUPnPPort = usUPnPPort; httpMyStrncpy(g_ConfigParam.acWatchdogIP, acWatchdogIP, sizeof(g_ConfigParam.acWatchdogIP)); tt_rmutex_unlock(&g_rmutex); WriteFlashMemory(&g_ConfigParam); RebootOnConnectionOver(hConnection); } return 0; break; } return -1; }
int Config_GetUPnP(HTTPCONNECTION hConnection, LIST *pParamList, int iAction, XML *pReturnXML) { char acIP[32]; unsigned short ausPort[5]; int iSuccessNum; int i; switch (iAction) { case CA_AUTH: return AUTH_USER; case CA_CONFIG: iSuccessNum = upnp_get_port(0, ausPort); //AddHttpNum(pReturnXML, "Rt0", iSuccessNum); if (iSuccessNum < 0) iSuccessNum = 0; for (i = iSuccessNum; i < sizeof(ausPort) / sizeof(ausPort[0]); ++i) ausPort[i] = 0; if ((iSuccessNum = upnp_get_extip(0, acIP)) < 0) acIP[0] = 0; //AddHttpNum(pReturnXML, "Rt1", iSuccessNum); tt_rmutex_lock(&g_rmutex); AddHttpNum(pReturnXML, "Enable", g_ConfigParam.bEnableUPnP); AddHttpNum(pReturnXML, "Port", (int) (g_ConfigParam.usUPnPPort == 0 ? DEFAULT_UPNP_FIRST_EXT_PORT : g_ConfigParam.usUPnPPort)); AddHttpValue(pReturnXML, "WatchdogIP", g_ConfigParam.acWatchdogIP); tt_rmutex_unlock(&g_rmutex); AddHttpValue(pReturnXML, "IP", acIP); AddHttpNum(pReturnXML, "HTTP", (int)ausPort[0]); AddHttpNum(pReturnXML, "RTSP_TCP", (int)ausPort[1]); AddHttpNum(pReturnXML, "RTSP_UDP", (int)ausPort[2]); return 0; } return -1; }
int Config_GetWlan(HTTPCONNECTION hConnection, LIST *pParamList, int iAction, XML *pReturnXML) { int iLen; char ac[128]; int j; //prism_cnfDesireSSID_t *pESSIDList; //int iESSIDNum; switch (iAction) { case CA_AUTH: return AUTH_ADMIN; case CA_CONFIG: tt_rmutex_lock(&g_rmutex); AddHttpValue(pReturnXML, G_PC_ESSID, (char *)g_ConfigParam.acWlanESSID); AddHttpValue(pReturnXML, G_PC_MODE, g_apcWlanOperationMode[((int)g_ConfigParam.ucWlanOperationMode >= 0 && (int)g_ConfigParam.ucWlanOperationMode < sizeof(g_apcWlanOperationMode) / sizeof(const char *)) ? (int)g_ConfigParam.ucWlanOperationMode : 0]); AddHttpValue(pReturnXML, G_PC_KEY, (strlen((char *)g_ConfigParam.acWlanKey) > 0 ? "*" : "")); AddHttpNum(pReturnXML, G_PC_CHANNEL, g_ConfigParam.ulWlanChannel); /* Useless items */ #if 0 AddHttpValue(pReturnXML, G_PC_WEPSET, "Disable"); AddHttpValue(pReturnXML, G_PC_WEPASC, ""); AddHttpValue(pReturnXML, G_PC_WEPGROUP, ""); //AddHttpValue(pReturnXML, G_PC_WEP64, ac); AddHttpValue(pReturnXML, G_PC_WEP64_TYPE, "Wep64ASC"); //AddHttpValue(pReturnXML, G_PC_WEP128, ac); AddHttpValue(pReturnXML, G_PC_WEP128_TYPE, "Wep128ASC"); #else AddHttpValue(pReturnXML, G_PC_WEPSET, (g_ConfigParam.ucWepSet == WEP_SET_K64 ? "K64" : (g_ConfigParam.ucWepSet == WEP_SET_K128 ? "K128" : (g_ConfigParam.ucWepSet == WEP_SET_ASC ? "Asc": "Disable")))); AddHttpValue(pReturnXML, G_PC_WEPASC, (strlen((char*) g_ConfigParam.acWepAsc) > 0 ? "*" : "")); AddHttpNum(pReturnXML, G_PC_WEPGROUP, 0); if (g_ConfigParam.bWep64UseAsc) { memcpy(ac, g_ConfigParam.acWep64, 5); ac[5] = '\0'; } else { for (iLen = 0, j = 0; j < 5; j++) { iLen += sprintf(ac + iLen, "%02x", (int)(unsigned char)g_ConfigParam.acWep64[j]); } } //AddHttpValue(pReturnXML, G_PC_WEP64, ac); AddHttpValue(pReturnXML, G_PC_WEP64_TYPE, (g_ConfigParam.bWep64UseAsc ? "Wep64ASC" : "Wep64HEX")); if (g_ConfigParam.bWep128UseAsc) { memcpy(ac, g_ConfigParam.acWep128, 13); ac[13] = '\0'; } else { for (iLen = 0, j = 0; j < 13; j++) { iLen += sprintf(ac + iLen, "%02x", (int)(unsigned char)g_ConfigParam.acWep128[j]); } } //AddHttpValue(pReturnXML, G_PC_WEP128, ac); AddHttpValue(pReturnXML, G_PC_WEP128_TYPE, (g_ConfigParam.bWep128UseAsc ? "Wep128ASC" : "Wep128HEX")); { enum SET_WIFI_STATE_E wifiState; wsp_get_config_state(&wifiState, NULL); switch(wifiState) { case SET_WIFI__TRYING: AddHttpValue(pReturnXML, "CurrentWiFiState", "TRYING"); break; case SET_WIFI__OK: AddHttpValue(pReturnXML, "CurrentWiFiState", "OK"); break; default: AddHttpValue(pReturnXML, "CurrentWiFiState", "NO_INIT"); } } #endif tt_rmutex_unlock(&g_rmutex); return 0; } return -1; }
void mcuLock() { tt_rmutex_lock(&g_rmutex_MCU); }
int Config_GetIP(HTTPCONNECTION hConnection, LIST *pParamList, int iAction, XML *pReturnXML) { char ac[128]; int i; const char *pcInterface; int iInterface; unsigned long ulClientIP; ulClientIP = httpGetClientAddr(hConnection).s_addr; switch (iAction) { case CA_AUTH: if (ulClientIP == 0x0100007f) return AUTH_ANY; else return AUTH_USER; break; case CA_CONFIG: tt_rmutex_lock(&g_rmutex); AddHttpValue(pReturnXML, G_PC_CAMERANAME, g_ConfigParam.acCameraName); for (i = 0; i < 3; i++) { char acName[8]; sprintf(acName, G_PC_DNS_N, i); httpIP2String(g_ConfigParam.aulAsDNS[i], ac); AddHttpValue(pReturnXML, acName, ac); } #ifndef WLAN if (!httpIsExistParam(pParamList, G_PC_INTERFACE)) pcInterface = g_apcNetworkInterface[0]; #else if (!httpIsExistParam(pParamList, G_PC_INTERFACE)) pcInterface = g_apcNetworkInterface[1]; #endif else pcInterface = httpGetString(pParamList, G_PC_INTERFACE); for (iInterface = 0; iInterface < sizeof(g_apcNetworkInterface) / sizeof(const char *); iInterface++) if (strcasecmp(g_apcNetworkInterface[iInterface], pcInterface) == 0) break; if (iInterface < sizeof(g_apcNetworkInterface) / sizeof(const char *)) { httpLong2String(g_ConfigParam.abAsNetEnable[iInterface], ac); AddHttpValue(pReturnXML, G_PC_ENABLE, ac); AddHttpValue(pReturnXML, G_PC_IPWAY, (g_ConfigParam.aucIPAssignedWay[iInterface] == IP_ASSIGNMENT_MANUALLY?"manually":"dhcp") ); httpIP2String(g_ConfigParam.ulAsIPAddress[iInterface], ac); AddHttpValue(pReturnXML, G_PC_IP, ac); httpIP2String(g_ConfigParam.ulAsNetmask[iInterface], ac); AddHttpValue(pReturnXML, G_PC_NETMASK, ac); httpIP2String(g_ConfigParam.ulAsGateway[iInterface], ac); AddHttpValue(pReturnXML, G_PC_GATEWAY, ac); } { unsigned long ulCurrentIP; unsigned long ulCurrentSubnetMask; unsigned long ulCurrentGateway; unsigned long ulCurrentDNSServer[3]; enum SET_IP_STATE_E ipState; GetPubIPInfo(&ulCurrentIP, &ulCurrentSubnetMask, &ulCurrentGateway, ulCurrentDNSServer); httpIP2String(ulCurrentIP, ac); AddHttpValue(pReturnXML, "CurrentIP", ac); httpIP2String(ulCurrentSubnetMask, ac); AddHttpValue(pReturnXML, "CurrentNetmask", ac); httpIP2String(ulCurrentGateway, ac); AddHttpValue(pReturnXML, "CurrentGateway", ac); for (i = 0; i < 3; i++) { char acName[16]; sprintf(acName, "CurrentDNS%d", i); httpIP2String(ulCurrentDNSServer[i], ac); AddHttpValue(pReturnXML, acName, ac); } wsp_get_config_state(NULL, &ipState); switch(ipState) { case SET_IP__DHCP_TRYING: AddHttpValue(pReturnXML, "CurrentIPState", "DHCP_TRYING"); break; case SET_IP__DHCP_FAILED: AddHttpValue(pReturnXML, "CurrentIPState", "DHCP_FAILED"); break; case SET_IP__DHCP_OK: AddHttpValue(pReturnXML, "CurrentIPState", "DHCP_OK"); break; case SET_IP__STATIC_IP_TRYING: AddHttpValue(pReturnXML, "CurrentIPState", "STATIC_IP_TRYING"); break; case SET_IP__STATIC_IP_FAILED: AddHttpValue(pReturnXML, "CurrentIPState", "STATIC_IP_FAILED"); break; case SET_IP__STATIC_IP_OK: AddHttpValue(pReturnXML, "CurrentIPState", "STATIC_IP_OK"); break; default: AddHttpValue(pReturnXML, "CurrentIPState", "NO_INIT"); } } tt_rmutex_unlock(&g_rmutex); return 0; break; } return -1; }
int Config_SetIP(HTTPCONNECTION hConnection, LIST *pParamList, int iAction, XML *pReturnXML) { const char *pcIPAssignedWay; const char *pcInterface; int iInterface; unsigned char ucIPAssignedWay; int i; BOOL bIsChange = FALSE; unsigned long ulClientIP; ulClientIP = httpGetClientAddr(hConnection).s_addr; switch (iAction) { case CA_AUTH: //diag_printf("CA_AUTH Config_SetIP!\n"); tt_rmutex_lock(&g_rmutex); if (ulClientIP == 0x0100007f) return AUTH_ANY; else return AUTH_ADMIN; break; case CA_CONFIG: diag_printf("CA_CONFIG Config_SetIP!\n"); if (httpIsExistParam(pParamList, "CameraName")) { httpMyStrncpy(g_ConfigParam.acCameraName, httpGetString(pParamList, "CameraName"), sizeof(g_ConfigParam.acCameraName)); bIsChange = TRUE; } #ifndef WLAN if (!httpIsExistParam(pParamList, "Interface")) pcInterface = g_apcNetworkInterface[0]; #else if (!httpIsExistParam(pParamList, "Interface")) pcInterface = g_apcNetworkInterface[1]; #endif else pcInterface = httpGetString(pParamList, "Interface"); for (iInterface = 0; iInterface < sizeof(g_apcNetworkInterface) / sizeof(const char *); iInterface++) if (strcasecmp(g_apcNetworkInterface[iInterface], pcInterface) == 0) break; if (iInterface < sizeof(g_apcNetworkInterface) / sizeof(const char *)) { BOOL bAsNetEnable_Before = g_ConfigParam.abAsNetEnable[iInterface]; g_ConfigParam.abAsNetEnable[iInterface] = httpGetBool(pParamList, "Enable"); if (g_ConfigParam.abAsNetEnable[iInterface] != bAsNetEnable_Before) bIsChange = TRUE; pcIPAssignedWay = httpGetString(pParamList, "IPWay"); if (strcasecmp(pcIPAssignedWay, "manually") == 0) ucIPAssignedWay = IP_ASSIGNMENT_MANUALLY; else if (strcasecmp(pcIPAssignedWay, "dhcp") == 0) ucIPAssignedWay = IP_ASSIGNMENT_DHCP; else ucIPAssignedWay = g_ConfigParam.aucIPAssignedWay[iInterface]; if (ucIPAssignedWay != g_ConfigParam.aucIPAssignedWay[iInterface]) { g_ConfigParam.aucIPAssignedWay[iInterface] = ucIPAssignedWay; bIsChange = TRUE; } if (httpIsExistParam(pParamList, "IP")) { g_ConfigParam.ulAsIPAddress[iInterface] = httpGetIP(pParamList, "IP"); bIsChange = TRUE; } if (httpIsExistParam(pParamList, "Netmask")) { g_ConfigParam.ulAsNetmask[iInterface] = httpGetIP(pParamList, "Netmask"); bIsChange = TRUE; } if (httpIsExistParam(pParamList, "Gateway")) { g_ConfigParam.ulAsGateway[iInterface] = httpGetIP(pParamList, "Gateway"); bIsChange = TRUE; } //SIMON if (httpIsExistParam(pParamList, "WatchdogIP")) { g_ConfigParam.ulAsGateway[iInterface] = httpGetIP(pParamList, "Gateway"); bIsChange = TRUE; } } for (i = 0; i < 3; i++) { char ac[16]; sprintf(ac, "DNS%d", i); if (httpIsExistParam(pParamList, ac)) { g_ConfigParam.aulAsDNS[i] = httpGetIP(pParamList, ac); bIsChange = TRUE; } } if (bIsChange == TRUE) { WebCameraLog(CL_PRIVILEGE_COMMON, CL_SET_IP, pcIPAssignedWay, hConnection); WriteFlashMemory(&g_ConfigParam); } tt_rmutex_unlock(&g_rmutex); /*Set new ip address*/ //SetIP(); wsp_set_network_ip(); diag_printf("CA_CONFIG Config_SetIP -- end!\n"); return 0; break; } return -1; }
int Config_SetPPP(HTTPCONNECTION hConnection, LIST *pParamList, int iAction, XML *pReturnXML) { BOOL bConfigChanged = FALSE; BOOL bPPPEnable; const char *apcPPPServer[ sizeof(g_ConfigParam.aacPPPServer) / sizeof(g_ConfigParam.aacPPPServer[0])]; int aiPPPPort[ sizeof(g_ConfigParam.aiPPPPort) / sizeof(g_ConfigParam.aiPPPPort[0])]; const char *pcPPPUser; const char *pcPPPPass; int i; switch (iAction) { case CA_AUTH: return AUTH_ADMIN; case CA_CONFIG: if (httpIsExistParam(pParamList, "Enable")) bPPPEnable = httpGetBool(pParamList, "Enable"); else bPPPEnable = g_ConfigParam.bPPPEnable; if (bPPPEnable != g_ConfigParam.bPPPEnable) bConfigChanged = TRUE; for (i = 0; i < sizeof(g_ConfigParam.aacPPPServer) / sizeof(g_ConfigParam.aacPPPServer[0]); ++i) { char acName[32]; snprintf(acName, sizeof(acName), "Server%d", i); apcPPPServer[i] = g_ConfigParam.aacPPPServer[i]; if (httpIsExistParam(pParamList, acName)) { apcPPPServer[i] = httpGetString(pParamList, acName); if (strcmp(apcPPPServer[i], g_ConfigParam.aacPPPServer[i]) != 0) bConfigChanged = TRUE; } } if (httpIsExistParam(pParamList, "Server")) { apcPPPServer[0] = httpGetString(pParamList, "Server"); if (strcmp(apcPPPServer[0], g_ConfigParam.aacPPPServer[0]) != 0) bConfigChanged = TRUE; } for (i = 0; i < sizeof(g_ConfigParam.aiPPPPort) / sizeof(g_ConfigParam.aiPPPPort[0]); ++i) { char acName[32]; snprintf(acName, sizeof(acName), "Port%d", i); aiPPPPort[i] = g_ConfigParam.aiPPPPort[i]; if (httpIsExistParam(pParamList, acName)) { aiPPPPort[i] = httpGetLong(pParamList, acName); if (aiPPPPort[i] != g_ConfigParam.aiPPPPort[i]) bConfigChanged = TRUE; } } if (httpIsExistParam(pParamList, "Port")) { aiPPPPort[0] = httpGetLong(pParamList, "Port"); if (aiPPPPort[0] != g_ConfigParam.aiPPPPort[0]) bConfigChanged = TRUE; } if (httpIsExistParam(pParamList, "User")) pcPPPUser = httpGetString(pParamList, "User"); else pcPPPUser = g_ConfigParam.acPPPUser; if (strcmp(pcPPPUser, g_ConfigParam.acPPPUser) != 0) bConfigChanged = TRUE; if (httpIsExistParam(pParamList, "Pass")) pcPPPPass = httpGetString(pParamList, "Pass"); else pcPPPPass = g_ConfigParam.acPPPPass; if (strcmp(pcPPPPass, g_ConfigParam.acPPPPass) != 0) bConfigChanged = TRUE; if (bConfigChanged) { tt_rmutex_lock(&g_rmutex); g_ConfigParam.bPPPEnable = bPPPEnable; for (i = 0; i < sizeof(g_ConfigParam.aacPPPServer) / sizeof(g_ConfigParam.aacPPPServer[0]); ++i) httpMyStrncpy(g_ConfigParam.aacPPPServer[i], apcPPPServer[i], sizeof(g_ConfigParam.aacPPPServer[i])); for (i = 0; i < sizeof(g_ConfigParam.aiPPPPort) / sizeof(g_ConfigParam.aiPPPPort[0]); ++i) g_ConfigParam.aiPPPPort[i] = aiPPPPort[i]; httpMyStrncpy(g_ConfigParam.acPPPUser, pcPPPUser, sizeof(g_ConfigParam.acPPPUser)); httpMyStrncpy(g_ConfigParam.acPPPPass, pcPPPPass, sizeof(g_ConfigParam.acPPPPass)); tt_rmutex_unlock(&g_rmutex); WriteFlashMemory(&g_ConfigParam); } if (!bPPPEnable) { /* Disconnect if possible */ //if (ppot_is_connecting()) ppot_disconnect(); } if(bPPPEnable && bConfigChanged) //&& !ppot_is_connecting()) { ppot_connect(apcPPPServer, aiPPPPort, sizeof(apcPPPServer) / sizeof(apcPPPServer[0]), pcPPPUser, pcPPPPass); } return 0; break; } return -1; }