int Socketprintf(const char * fmt,...) { va_list ap; int n; va_start(ap,fmt); if (socketRedirectPointer == NULL) { // Function as printf return vprintf(fmt, ap); } else { // Send through socket n = vsnprintf(socketRedirectTemp + 2, SOCKET_REDIRECT_MAX_LENGTH-1, fmt, ap); if (n < 0) { for (n=0; n<SOCKET_REDIRECT_MAX_LENGTH; n++) { socketRedirectTemp[n+2] = ' '; } vsnprintf(socketRedirectTemp + 2, SOCKET_REDIRECT_MAX_LENGTH-1, fmt, ap); n = SOCKET_REDIRECT_MAX_LENGTH; } socketRedirectTemp[0] = SOCKET_REDIRECT_STDOUT; socketRedirectTemp[1] = (char)n; n = SocketSend(socketRedirectPointer, socketRedirectTemp, n+2); if (n < 0) { fprintf(stderr, "Cannot redirect through socket! The original text:\n"); vfprintf(stderr, fmt, ap); return -1; } } return n; }
static bool _mPerfRunServer(const char* listen, const struct mArguments* args, const struct PerfOpts* perfOpts) { SocketSubsystemInit(); Socket server = SocketOpenTCP(7216, NULL); if (SOCKET_FAILED(server)) { SocketSubsystemDeinit(); return false; } if (SOCKET_FAILED(SocketListen(server, 0))) { SocketClose(server); SocketSubsystemDeinit(); return false; } _socket = SocketAccept(server, NULL); if (perfOpts->csv) { const char* header = "game_code,frames,duration,renderer\n"; SocketSend(_socket, header, strlen(header)); } char path[PATH_MAX]; while (SocketRecv(_socket, path, sizeof(path)) > 0) { char* nl = strchr(path, '\n'); if (nl == path) { break; } if (nl) { nl[0] = '\0'; } if (!_mPerfRunCore(path, args, perfOpts)) { break; } } SocketClose(_socket); SocketClose(server); SocketSubsystemDeinit(); return true; }
static void _sendMessage(struct GDBStub* stub) { if (stub->lineAck != GDB_ACK_OFF) { stub->lineAck = GDB_ACK_PENDING; } uint8_t checksum = 0; int i = 1; char buffer = stub->outgoing[0]; char swap; stub->outgoing[0] = '$'; if (buffer) { for (; i < GDB_STUB_MAX_LINE - 5; ++i) { checksum += buffer; swap = stub->outgoing[i]; stub->outgoing[i] = buffer; buffer = swap; if (!buffer) { ++i; break; } } } stub->outgoing[i] = '#'; _int2hex8(checksum, &stub->outgoing[i + 1]); stub->outgoing[i + 3] = 0; mLOG(DEBUGGER, DEBUG, "> %s", stub->outgoing); SocketSend(stub->connection, stub->outgoing, i + 3); }
// Once connected to the network, check the sockets for pending information // and when information is ready, send either a Ping or a Pong. void NetworkUpdate() { // CheckSockets // // If any of the sockets in the socket_set are pending (received data, or requests) // then mark the socket as being ready. You can check this with IsSocketReady(client_res->socket) int active = CheckSockets(socket_set, 0); if (active != 0) { TraceLog(LOG_DEBUG, "There are currently %d socket(s) with data to be processed.", active); } // IsSocketReady // // If the socket is ready, attempt to receive data from the socket // int bytesRecv = 0; // if (IsSocketReady(server_res->socket)) { // bytesRecv = SocketReceive(server_res->socket, recvBuffer, msglen); // } int bytesRecv = SocketReceive(server_res->socket, recvBuffer, msglen); // If we received data, was that data a "Ping!" or a "Pong!" if (bytesRecv > 0) { if (strcmp(recvBuffer, pingmsg) == 0) { pong = true; } if (strcmp(recvBuffer, pongmsg) == 0) { ping = true; } } // After each delay has expired, send a response "Ping!" for a "Pong!" and vice versa elapsed += GetFrameTime(); if (elapsed > delay) { if (ping) { ping = false; SocketSend(server_res->socket, pingmsg, msglen); } else if (pong) { pong = false; SocketSend(server_res->socket, pongmsg, msglen); } elapsed = 0.0f; } }
const bool RemoteMinerClient::Update(const int ms) { if(IsConnected()) { m_timeval.tv_sec=0; m_timeval.tv_usec=ms*1000; FD_ZERO(&m_readfs); FD_ZERO(&m_writefs); FD_SET(m_socket,&m_readfs); if(m_sendbuffer.size()>0) { FD_SET(m_socket,&m_writefs); } select(m_socket+1,&m_readfs,&m_writefs,0,&m_timeval); if(IsConnected() && FD_ISSET(m_socket,&m_readfs)) { SocketReceive(); } if(IsConnected() && FD_ISSET(m_socket,&m_writefs)) { SocketSend(); } } if(IsConnected()) { return true; } else { return false; } }
OSStatus _connectFTCServer( mico_Context_t * const inContext, int *fd) { OSStatus err; struct sockaddr_t addr; json_object *easylink_report = NULL; const char *json_str; size_t httpResponseLen = 0; *fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); addr.s_ip = inContext->flashContentInRam.micoSystemConfig.easylinkServerIP; addr.s_port = FTC_PORT; err = connect(*fd, &addr, sizeof(addr)); require_noerr(err, exit); _FTCClientConnected = true; easylink_log("Connect to FTC server success, fd: %d", *fd); easylink_report = ConfigCreateReportJsonMessage( inContext ); require( easylink_report, exit ); json_str = json_object_to_json_string(easylink_report); require( json_str, exit ); easylink_log("Send config object=%s", json_str); err = CreateHTTPMessage( "POST", kEasyLinkURLAuth, kMIMEType_JSON, (uint8_t *)json_str, strlen(json_str), &httpResponse, &httpResponseLen ); require_noerr( err, exit ); require( httpResponse, exit ); json_object_put(easylink_report); err = SocketSend( *fd, httpResponse, httpResponseLen ); free(httpResponse); require_noerr( err, exit ); easylink_log("Current configuration sent"); exit: return err; }
int HKSecureSocketSend( int sockfd, void *buf, size_t len, security_session_t *session) { OSStatus err = kNoErr; uint8_t* encryptedData = NULL; ssize_t sentLength = 0; uint64_t encryptedDataLen; encryptedData = malloc(len + crypto_aead_chacha20poly1305_ABYTES + 4); require_action(encryptedData, exit, err = kNoMemoryErr); *(int *)encryptedData = len; err = crypto_aead_chacha20poly1305_encrypt(encryptedData+4, &encryptedDataLen, (uint8_t *)buf, len, (const uint8_t *)encryptedData, 4, NULL, (uint8_t *)(&session->outputSeqNo), (const unsigned char *)session->OutputKey); session->outputSeqNo++; require_noerr_string(err, exit, "crypto_aead_chacha20poly1305_encrypt failed"); require_string(encryptedDataLen - crypto_aead_chacha20poly1305_ABYTES == len, exit, "encryptedDataLen is not properly set"); err = SocketSend( sockfd, encryptedData, encryptedDataLen + 4 ); require_noerr( err, exit ); exit: if(encryptedData) free(encryptedData); return sentLength; }
void localTcpClient_thread(void *inFd) { OSStatus err; int i; int indexForPortTable; int clientFd = *(int *)inFd; int currentRecved = 0; int clientLoopBackFd = -1; uint8_t *inDataBuffer = NULL; uint8_t *outDataBuffer = NULL; int len; struct sockaddr_t addr; fd_set readfds; struct timeval_t t; inDataBuffer = malloc(wlanBufferLen); require_action(inDataBuffer, exit, err = kNoMemoryErr); outDataBuffer = malloc(wlanBufferLen); require_action(outDataBuffer, exit, err = kNoMemoryErr); for(i=0; i < MAX_Local_Client_Num; i++) { if( Context->appStatus.loopBack_PortList[i] == 0 ){ Context->appStatus.loopBack_PortList[i] = loopBackPortTable[clientFd]; indexForPortTable = i; break; } } /*Loopback fd, recv data from other thread */ clientLoopBackFd = socket( AF_INET, SOCK_DGRM, IPPROTO_UDP ); require_action(IsValidSocket( clientLoopBackFd ), exit, err = kNoResourcesErr ); addr.s_ip = IPADDR_LOOPBACK; addr.s_port = Context->appStatus.loopBack_PortList[indexForPortTable]; err = bind( clientLoopBackFd, &addr, sizeof(addr) ); require_noerr( err, exit ); t.tv_sec = 4; t.tv_usec = 0; while(1){ FD_ZERO(&readfds); FD_SET(clientFd, &readfds); FD_SET(clientLoopBackFd, &readfds); select(1, &readfds, NULL, NULL, &t); /*recv UART data using loopback fd*/ if (FD_ISSET( clientLoopBackFd, &readfds )) { len = recv( clientLoopBackFd, outDataBuffer, wlanBufferLen, 0 ); SocketSend( clientFd, outDataBuffer, len ); } /*Read data from tcp clients and process these data using HA protocol */ if (FD_ISSET(clientFd, &readfds)) { len = recv(clientFd, inDataBuffer+currentRecved, wlanBufferLen-currentRecved, 0); require_action_quiet(len>0, exit, err = kConnectionErr); currentRecved += len; haWlanCommandProcess(inDataBuffer, ¤tRecved, clientFd, Context); } } exit: server_log("Exit: Client exit with err = %d", err); Context->appStatus.loopBack_PortList[indexForPortTable] = 0; if(clientLoopBackFd != -1) SocketClose(&clientLoopBackFd); SocketClose(&clientFd); if(inDataBuffer) free(inDataBuffer); if(outDataBuffer) free(outDataBuffer); mico_rtos_delete_thread(NULL); return; }
/*************************************************** Send purpose Sends the given data to the connected client. if 'len' is 0 or less then the given data is assumed to be 0 terminated params data -pointer to the data to send len -length of the data to send return number of bytes sent SOCKET_ERROR - on fail ****************************************************/ int CUT_WSThread::Send(LPCSTR data, int len, int flags){ if(len < 0) len = (int)strlen((char *)data); return SocketSend(m_clientSocket, (char *)data, len, flags); }
void IRCClientThread::thread() { int ciphersuites[] = { SSL_EDH_RSA_AES_256_SHA, SSL_EDH_RSA_CAMELLIA_256_SHA, SSL_EDH_RSA_AES_128_SHA, SSL_EDH_RSA_CAMELLIA_128_SHA, SSL_EDH_RSA_DES_168_SHA, SSL_RSA_AES_256_SHA, SSL_RSA_CAMELLIA_256_SHA, SSL_RSA_AES_128_SHA, SSL_RSA_CAMELLIA_128_SHA, SSL_RSA_DES_168_SHA, SSL_RSA_RC4_128_SHA, SSL_RSA_RC4_128_MD5, 0 }; int rval=0; fd_set readfs; fd_set writefs; struct timeval tv; std::string temp(""); // setup SSL connection first if(m_contype==IRCClientConnection::CON_SSL) { m_log->Error("IRCClientThread::thread SSL handshaking with client"); ssl_set_ciphersuites(&(m_ssl->m_ssl),ciphersuites); rval=ssl_handshake(&(m_ssl->m_ssl)); if(rval!=0) { StringFunctions::Convert(rval,temp); m_log->Error("IRCClientThread::thread couldn't handshake with client - return value = "+temp); Disconnect(); return; } } while(should_stop()==false && IsConnected()==true) { tv.tv_sec=0; tv.tv_usec=100000; FD_ZERO(&readfs); FD_ZERO(&writefs); FD_SET(m_socket,&readfs); if(SendBufferSize()>0) { FD_SET(m_socket,&writefs); } rval=select(m_socket+1,&readfs,&writefs,0,&tv); if(rval>0) { if(FD_ISSET(m_socket,&readfs)) { SocketReceive(); } if(IsConnected() && FD_ISSET(m_socket,&writefs)) { SocketSend(); } } if(m_wantdisconnect==true) { Disconnect(); } } }
OSStatus _LocalConfigRespondInComingMessage(int fd, HTTPHeader_t* inHeader, mico_Context_t * const inContext) { OSStatus err = kUnknownErr; const char * json_str; uint8_t *httpResponse = NULL; size_t httpResponseLen = 0; json_object* report = NULL; config_log_trace(); if(HTTPHeaderMatchURL( inHeader, kCONFIGURLRead ) == kNoErr){ report = ConfigCreateReportJsonMessage( inContext ); require( report, exit ); json_str = json_object_to_json_string(report); require_action( json_str, exit, err = kNoMemoryErr ); config_log("Send config object=%s", json_str); err = CreateSimpleHTTPMessageNoCopy( kMIMEType_JSON, strlen(json_str), &httpResponse, &httpResponseLen ); require_noerr( err, exit ); require( httpResponse, exit ); err = SocketSend( fd, httpResponse, httpResponseLen ); require_noerr( err, exit ); err = SocketSend( fd, (uint8_t *)json_str, strlen(json_str) ); require_noerr( err, exit ); config_log("Current configuration sent"); goto exit; } else if(HTTPHeaderMatchURL( inHeader, kCONFIGURLWrite ) == kNoErr){ if(inHeader->contentLength > 0){ config_log("Recv new configuration, apply and reset"); err = ConfigIncommingJsonMessage( inHeader->extraDataPtr, inContext); require_noerr( err, exit ); inContext->flashContentInRam.micoSystemConfig.configured = allConfigured; MICOUpdateConfiguration(inContext); err = CreateSimpleHTTPOKMessage( &httpResponse, &httpResponseLen ); require_noerr( err, exit ); require( httpResponse, exit ); err = SocketSend( fd, httpResponse, httpResponseLen ); SocketClose(&fd); inContext->micoStatus.sys_state = eState_Software_Reset; if(inContext->micoStatus.sys_state_change_sem != NULL ); mico_rtos_set_semaphore(&inContext->micoStatus.sys_state_change_sem); mico_thread_sleep(MICO_WAIT_FOREVER); } goto exit; } else if(HTTPHeaderMatchURL( inHeader, kCONFIGURLWriteByUAP ) == kNoErr){ if(inHeader->contentLength > 0){ config_log("Recv new configuration from uAP, apply and connect to AP"); err = ConfigIncommingJsonMessageUAP( inHeader->extraDataPtr, inContext); require_noerr( err, exit ); MICOUpdateConfiguration(inContext); err = CreateSimpleHTTPOKMessage( &httpResponse, &httpResponseLen ); require_noerr( err, exit ); require( httpResponse, exit ); err = SocketSend( fd, httpResponse, httpResponseLen ); require_noerr( err, exit ); sleep(1); micoWlanSuspendSoftAP(); _easylinkConnectWiFi( inContext ); err = kConnectionErr; //Return an err to close socket and exit the current thread } goto exit; } #ifdef MICO_FLASH_FOR_UPDATE else if(HTTPHeaderMatchURL( inHeader, kCONFIGURLOTA ) == kNoErr){ if(inHeader->contentLength > 0){ config_log("Receive OTA data!"); memset(&inContext->flashContentInRam.bootTable, 0, sizeof(boot_table_t)); inContext->flashContentInRam.bootTable.length = inHeader->contentLength; inContext->flashContentInRam.bootTable.start_address = UPDATE_START_ADDRESS; inContext->flashContentInRam.bootTable.type = 'A'; inContext->flashContentInRam.bootTable.upgrade_type = 'U'; if(inContext->flashContentInRam.micoSystemConfig.configured != allConfigured) inContext->flashContentInRam.micoSystemConfig.easyLinkByPass = EASYLINK_SOFT_AP_BYPASS; MICOUpdateConfiguration(inContext); SocketClose(&fd); inContext->micoStatus.sys_state = eState_Software_Reset; if(inContext->micoStatus.sys_state_change_sem != NULL ); mico_rtos_set_semaphore(&inContext->micoStatus.sys_state_change_sem); mico_thread_sleep(MICO_WAIT_FOREVER); } goto exit; } #endif else{ return kNotFoundErr; }; exit: if(inHeader->persistent == false) //Return an err to close socket and exit the current thread err = kConnectionErr; if(httpResponse) free(httpResponse); if(report) json_object_put(report); return err; }
bool _mPerfRunCore(const char* fname, const struct mArguments* args, const struct PerfOpts* perfOpts) { struct mCore* core = mCoreFind(fname); if (!core) { return false; } // TODO: Put back debugger char gameCode[9] = { 0 }; core->init(core); if (!perfOpts->noVideo) { core->setVideoBuffer(core, _outputBuffer, 256); } mCoreLoadFile(core, fname); mCoreConfigInit(&core->config, "perf"); mCoreConfigLoad(&core->config); if (perfOpts->threadedVideo) { mCoreConfigSetOverrideIntValue(&core->config, "threadedVideo", 1); } else { mCoreConfigSetOverrideIntValue(&core->config, "threadedVideo", 0); } struct mCoreOptions opts = {}; mCoreConfigMap(&core->config, &opts); opts.audioSync = false; opts.videoSync = false; applyArguments(args, NULL, &core->config); mCoreConfigLoadDefaults(&core->config, &opts); mCoreConfigSetDefaultValue(&core->config, "idleOptimization", "detect"); mCoreLoadConfig(core); core->reset(core); if (_savestate) { mCoreLoadStateNamed(core, _savestate, 0); } core->getGameCode(core, gameCode); int frames = perfOpts->frames; if (!frames) { frames = perfOpts->duration * 60; } struct timeval tv; gettimeofday(&tv, 0); uint64_t start = 1000000LL * tv.tv_sec + tv.tv_usec; _mPerfRunloop(core, &frames, perfOpts->csv); gettimeofday(&tv, 0); uint64_t end = 1000000LL * tv.tv_sec + tv.tv_usec; uint64_t duration = end - start; mCoreConfigFreeOpts(&opts); mCoreConfigDeinit(&core->config); core->deinit(core); float scaledFrames = frames * 1000000.f; if (perfOpts->csv) { char buffer[256]; const char* rendererName; if (perfOpts->noVideo) { rendererName = "none"; } else if (perfOpts->threadedVideo) { rendererName = "threaded-software"; } else { rendererName = "software"; } snprintf(buffer, sizeof(buffer), "%s,%i,%" PRIu64 ",%s\n", gameCode, frames, duration, rendererName); printf("%s", buffer); if (_socket != INVALID_SOCKET) { SocketSend(_socket, buffer, strlen(buffer)); } } else { printf("%u frames in %" PRIu64 " microseconds: %g fps (%gx)\n", frames, duration, scaledFrames / duration, scaledFrames / (duration * 60.f)); } return true; }
transresult_t CSockWrap::Send(void* ptr, int nbytes) { transresult_t rt; SocketSend(m_hSocket, (const char*)ptr, nbytes,rt); return rt; }
static void _nak(struct GDBStub* stub) { char nak = '-'; mLOG(DEBUGGER, WARN, "Packet error"); SocketSend(stub->connection, &nak, 1); }
static void _ack(struct GDBStub* stub) { char ack = '+'; SocketSend(stub->connection, &ack, 1); }
OSStatus _LocalConfigRespondInComingMessage(int fd, ECS_HTTPHeader_t* inHeader, mico_Context_t * const inContext) { OSStatus err = kUnknownErr; const char * json_str; uint8_t *httpResponse = NULL; size_t httpResponseLen = 0; json_object* report = NULL; char err_msg[32] = {0}; char *bonjour_txt_record = NULL; char *bonjour_txt_field = NULL; MVDActivateRequestData_t devActivateRequestData; MVDAuthorizeRequestData_t devAuthorizeRequestData; MVDResetRequestData_t devResetRequestData; MVDOTARequestData_t devOTARequestData; MVDGetStateRequestData_t devGetStateRequestData; fogcloud_config_log_trace(); if(ECS_HTTPHeaderMatchURL( inHeader, kCONFIGURLDevState ) == kNoErr){ if(inHeader->contentLength > 0){ fogcloud_config_log("Recv device getState request."); memset((void*)&devGetStateRequestData, '\0', sizeof(devGetStateRequestData)); err = getMVDGetStateRequestData(inHeader->extraDataPtr, &devGetStateRequestData); require_noerr( err, exit ); report = json_object_new_object(); err = MicoFogCloudGetState(inContext, devGetStateRequestData, report); require_noerr( err, exit ); fogcloud_config_log("get device state success!"); json_str = (char*)json_object_to_json_string(report); //config_log("json_str=%s", json_str); err = ECS_CreateSimpleHTTPMessage( ECS_kMIMEType_JSON, (uint8_t*)json_str, strlen(json_str), &httpResponse, &httpResponseLen ); require( httpResponse, exit ); err = SocketSend( fd, httpResponse, httpResponseLen ); SocketClose(&fd); } goto exit; } else if(ECS_HTTPHeaderMatchURL( inHeader, kCONFIGURLDevActivate ) == kNoErr){ if(inHeader->contentLength > 0){ fogcloud_config_log("Recv device activate request."); memset((void*)&devActivateRequestData, '\0', sizeof(devActivateRequestData)); err = getMVDActivateRequestData(inHeader->extraDataPtr, &devActivateRequestData); require_noerr( err, exit ); err = MicoFogCloudActivate(inContext, devActivateRequestData); require_noerr( err, exit ); fogcloud_config_log("Device activate success!"); //------------------------------------------------------------------------ fog_config_server_running = false; // stop fog config server fogcloud_config_log("update bonjour txt record."); // update owner binding flag in txt record of bonjour suspend_bonjour_service(true); mico_rtos_lock_mutex(&inContext->flashContentInRam_mutex); inContext->flashContentInRam.appConfig.fogcloudConfig.owner_binding = true; err = MICOUpdateConfiguration(inContext); mico_rtos_unlock_mutex(&inContext->flashContentInRam_mutex); bonjour_txt_record = malloc(550); require_action(bonjour_txt_record, exit, err = kNoMemoryErr); bonjour_txt_field = __strdup_trans_dot(inContext->micoStatus.mac); sprintf(bonjour_txt_record, "MAC=%s.", bonjour_txt_field); free(bonjour_txt_field); bonjour_txt_field = __strdup_trans_dot((inContext->flashContentInRam.appConfig.fogcloudConfig.owner_binding) ? "true" : "false"); sprintf(bonjour_txt_record, "%sBinding=%s.", bonjour_txt_record, bonjour_txt_field); free(bonjour_txt_field); bonjour_txt_field = __strdup_trans_dot(FIRMWARE_REVISION); sprintf(bonjour_txt_record, "%sFirmware Rev=%s.", bonjour_txt_record, bonjour_txt_field); free(bonjour_txt_field); bonjour_txt_field = __strdup_trans_dot(HARDWARE_REVISION); sprintf(bonjour_txt_record, "%sHardware Rev=%s.", bonjour_txt_record, bonjour_txt_field); free(bonjour_txt_field); bonjour_txt_field = __strdup_trans_dot(MicoGetVer()); sprintf(bonjour_txt_record, "%sMICO OS Rev=%s.", bonjour_txt_record, bonjour_txt_field); free(bonjour_txt_field); bonjour_txt_field = __strdup_trans_dot(MODEL); sprintf(bonjour_txt_record, "%sModel=%s.", bonjour_txt_record, bonjour_txt_field); free(bonjour_txt_field); bonjour_txt_field = __strdup_trans_dot(PROTOCOL); sprintf(bonjour_txt_record, "%sProtocol=%s.", bonjour_txt_record, bonjour_txt_field); free(bonjour_txt_field); bonjour_txt_field = __strdup_trans_dot(MANUFACTURER); sprintf(bonjour_txt_record, "%sManufacturer=%s.", bonjour_txt_record, bonjour_txt_field); free(bonjour_txt_field); sprintf(bonjour_txt_record, "%sSeed=%u.", bonjour_txt_record, inContext->flashContentInRam.micoSystemConfig.seed); bonjour_update_txt_record(bonjour_txt_record); if(NULL != bonjour_txt_record) free(bonjour_txt_record); suspend_bonjour_service(false); //------------------------------------------------------------------------ report = json_object_new_object(); require_action(report, exit, err = kNoMemoryErr); json_object_object_add(report, "device_id", json_object_new_string(inContext->flashContentInRam.appConfig.fogcloudConfig.deviceId)); json_str = (char*)json_object_to_json_string(report); //config_log("json_str=%s", json_str); err = ECS_CreateSimpleHTTPMessage( ECS_kMIMEType_JSON, (uint8_t*)json_str, strlen(json_str), &httpResponse, &httpResponseLen ); require_noerr( err, exit ); require( httpResponse, exit ); err = SocketSend( fd, httpResponse, httpResponseLen ); SocketClose(&fd); } goto exit; } else if(ECS_HTTPHeaderMatchURL( inHeader, kCONFIGURLDevAuthorize ) == kNoErr){ if(inHeader->contentLength > 0){ fogcloud_config_log("Recv device authorize request."); memset((void*)&devAuthorizeRequestData, '\0', sizeof(devAuthorizeRequestData)); err = getMVDAuthorizeRequestData( inHeader->extraDataPtr, &devAuthorizeRequestData); require_noerr( err, exit ); err = MicoFogCloudAuthorize(inContext, devAuthorizeRequestData); require_noerr( err, exit ); fogcloud_config_log("Device authorize success!"); report = json_object_new_object(); require_action(report, exit, err = kNoMemoryErr); json_object_object_add(report, "device_id", json_object_new_string(inContext->flashContentInRam.appConfig.fogcloudConfig.deviceId)); json_str = (char*)json_object_to_json_string(report); //config_log("json_str=%s", json_str); err = ECS_CreateSimpleHTTPMessage( ECS_kMIMEType_JSON, (uint8_t*)json_str, strlen(json_str), &httpResponse, &httpResponseLen ); require( httpResponse, exit ); err = SocketSend( fd, httpResponse, httpResponseLen ); SocketClose(&fd); } goto exit; } else if(ECS_HTTPHeaderMatchURL( inHeader, kCONFIGURLResetCloudDevInfo ) == kNoErr){ if(inHeader->contentLength > 0){ fogcloud_config_log("Recv cloud device info reset request."); memset((void*)&devResetRequestData, '\0', sizeof(devResetRequestData)); err = getMVDResetRequestData( inHeader->extraDataPtr, &devResetRequestData); require_noerr( err, exit ); err = MicoFogCloudResetCloudDevInfo(inContext, devResetRequestData); require_noerr( err, exit ); fogcloud_config_log("Device cloud reset success!"); err = ECS_CreateSimpleHTTPOKMessage( &httpResponse, &httpResponseLen ); require_noerr( err, exit ); require( httpResponse, exit ); err = SocketSend( fd, httpResponse, httpResponseLen ); SocketClose(&fd); inContext->micoStatus.sys_state = eState_Software_Reset; require(inContext->micoStatus.sys_state_change_sem, exit); mico_rtos_set_semaphore(&inContext->micoStatus.sys_state_change_sem); } goto exit; } else if(ECS_HTTPHeaderMatchURL( inHeader, kCONFIGURLDevFWUpdate ) == kNoErr){ if(inHeader->contentLength > 0){ fogcloud_config_log("Recv device fw_update request."); memset((void*)&devOTARequestData, '\0', sizeof(devOTARequestData)); err = getMVDOTARequestData( inHeader->extraDataPtr, &devOTARequestData); require_noerr( err, exit ); err = MicoFogCloudFirmwareUpdate(inContext, devOTARequestData); require_noerr( err, exit ); fogcloud_config_log("Device firmware update success!"); err = ECS_CreateSimpleHTTPOKMessage( &httpResponse, &httpResponseLen ); require_noerr( err, exit ); require( httpResponse, exit ); err = SocketSend( fd, httpResponse, httpResponseLen ); SocketClose(&fd); fogcloud_config_log("OTA bin_size=%lld, bin_version=%s", inContext->appStatus.fogcloudStatus.RecvRomFileSize, inContext->flashContentInRam.appConfig.fogcloudConfig.romVersion ); if(0 == inContext->appStatus.fogcloudStatus.RecvRomFileSize){ //no need to update, return size = 0, no need to boot bootloader err = kNoErr; goto exit; } mico_rtos_lock_mutex(&inContext->flashContentInRam_mutex); memset(&inContext->flashContentInRam.bootTable, 0, sizeof(boot_table_t)); inContext->flashContentInRam.bootTable.length = inContext->appStatus.fogcloudStatus.RecvRomFileSize; inContext->flashContentInRam.bootTable.start_address = UPDATE_START_ADDRESS; inContext->flashContentInRam.bootTable.type = 'A'; inContext->flashContentInRam.bootTable.upgrade_type = 'U'; MICOUpdateConfiguration(inContext); mico_rtos_unlock_mutex(&inContext->flashContentInRam_mutex); inContext->micoStatus.sys_state = eState_Software_Reset; require(inContext->micoStatus.sys_state_change_sem, exit); mico_rtos_set_semaphore(&inContext->micoStatus.sys_state_change_sem); } goto exit; } else{ return kNotFoundErr; }; exit: if((kNoErr != err) && (fd > 0)){ //ECS_CreateSimpleHTTPFailedMessage( &httpResponse, &httpResponseLen ); sprintf(err_msg, "{\"error\": %d}", err); ECS_CreateHTTPFailedMessage("500", "FAILED", ECS_kMIMEType_JSON, strlen(err_msg), (uint8_t*)err_msg, strlen(err_msg), &httpResponse, &httpResponseLen ); require( httpResponse, exit ); SocketSend( fd, httpResponse, httpResponseLen ); SocketClose(&fd); } if(httpResponse) free(httpResponse); if(report) json_object_put(report); return err; }
NTSTATUS SocketTest(PVOID Context) { PSOCKET_FACTORY SocketFactory = NULL; PSOCKET Socket; NTSTATUS Status; CHAR HttpResponse[4]; CHAR HttpRequest[] = "GET / HTTP/1.1\nHost: rbc.ru\nUser-Agent: Mozilla/5.0 (Windows NT 6.3; WOW64)\nAccept: */*\n\n"; ULONG Sent, Received; BOOLEAN Disconnected; SocketFactory = NpAlloc(sizeof(*SocketFactory), TESTS_TAG); if (!SocketFactory) return STATUS_INSUFFICIENT_RESOURCES; Status = SocketFactoryInit(SocketFactory); if (!NT_SUCCESS(Status)) { KLErr("SocketFactoryInit failed Status 0x%x", Status); goto socket_factory_free; } Status = SocketConnect(SocketFactory, L"rbc.ru", L"80", &Socket); if (!NT_SUCCESS(Status)) { KLErr("SocketConnect failed Status 0x%x", Status); goto socket_factory_release; } Status = SocketSend(Socket, HttpRequest, sizeof(HttpRequest), &Sent); if (!NT_SUCCESS(Status)) { KLErr("SocketSend failed Status 0x%x", Status); goto socket_close; } if (Sent != sizeof(HttpRequest)) { Status = STATUS_UNSUCCESSFUL; KLErr("SocketSend failed Sent %d", Sent); goto socket_close; } Status = SocketReceive(Socket, HttpResponse, sizeof(HttpResponse), &Received, &Disconnected); if (!NT_SUCCESS(Status)) { KLErr("SocketReceive failed Status 0x%x", Status); goto socket_close; } if ((Received != sizeof(HttpResponse)) || Disconnected) { KLErr("Received %d Disconnected %d", Received, Disconnected); Status = STATUS_UNSUCCESSFUL; goto socket_close; } if (4 != RtlCompareMemory(HttpResponse, "HTTP", 4)) { KLErr("Incorrect data received"); Status = STATUS_UNSUCCESSFUL; goto socket_close; } Status = STATUS_SUCCESS; socket_close: SocketClose(Socket); socket_factory_release: SocketFactoryRelease(SocketFactory); socket_factory_free: NpFree(SocketFactory, TESTS_TAG); KLInf("SocketTest Status 0x%x", Status); return Status; }
void remoteTcpClient_thread(void *inContext) { client_log_trace(); OSStatus err = kUnknownErr; int len; mico_Context_t *Context = inContext; struct sockaddr_t addr; fd_set readfds; char ipstr[16]; struct timeval_t t; int remoteTcpClient_loopBack_fd = -1; int remoteTcpClient_fd = -1; uint8_t *inDataBuffer = NULL; uint8_t *outDataBuffer = NULL; mico_rtos_init_semaphore(&_wifiConnected_sem, 1); /* Regisist notifications */ err = MICOAddNotification( mico_notify_WIFI_STATUS_CHANGED, (void *)clientNotify_WifiStatusHandler ); require_noerr( err, exit ); inDataBuffer = malloc(wlanBufferLen); require_action(inDataBuffer, exit, err = kNoMemoryErr); outDataBuffer = malloc(wlanBufferLen); require_action(inDataBuffer, exit, err = kNoMemoryErr); /*Loopback fd, recv data from other thread */ remoteTcpClient_loopBack_fd = socket( AF_INET, SOCK_DGRM, IPPROTO_UDP ); require_action(IsValidSocket( remoteTcpClient_loopBack_fd ), exit, err = kNoResourcesErr ); addr.s_ip = IPADDR_LOOPBACK; addr.s_port = REMOTE_TCP_CLIENT_LOOPBACK_PORT; err = bind( remoteTcpClient_loopBack_fd, &addr, sizeof(addr) ); require_noerr( err, exit ); t.tv_sec = 4; t.tv_usec = 0; while(1) { if(remoteTcpClient_fd == -1 ) { if(_wifiConnected == false){ require_action_quiet(mico_rtos_get_semaphore(&_wifiConnected_sem, 200000) == kNoErr, Continue, err = kTimeoutErr); } err = gethostbyname((char *)Context->flashContentInRam.appConfig.remoteServerDomain, (uint8_t *)ipstr, 16); require_noerr(err, ReConnWithDelay); remoteTcpClient_fd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); addr.s_ip = inet_addr(ipstr); addr.s_port = Context->flashContentInRam.appConfig.remoteServerPort; err = connect(remoteTcpClient_fd, &addr, sizeof(addr)); require_noerr_quiet(err, ReConnWithDelay); Context->appStatus.isRemoteConnected = true; client_log("Remote server connected at port: %d, fd: %d", Context->flashContentInRam.appConfig.remoteServerPort, remoteTcpClient_fd); }else{ FD_ZERO(&readfds); FD_SET(remoteTcpClient_fd, &readfds); FD_SET(remoteTcpClient_loopBack_fd, &readfds); select(1, &readfds, NULL, NULL, &t); /*recv UART data using loopback fd*/ if (FD_ISSET( remoteTcpClient_loopBack_fd, &readfds) ) { len = recv( remoteTcpClient_loopBack_fd, outDataBuffer, wlanBufferLen, 0 ); SocketSend( remoteTcpClient_fd, outDataBuffer, len ); } /*recv wlan data using remote client fd*/ if (FD_ISSET(remoteTcpClient_fd, &readfds)) { len = recv(remoteTcpClient_fd, inDataBuffer, wlanBufferLen, 0); if(len <= 0) { client_log("Remote client closed, fd: %d", remoteTcpClient_fd); Context->appStatus.isRemoteConnected = false; goto ReConnWithDelay; } sppWlanCommandProcess(inDataBuffer, &len, remoteTcpClient_fd, Context); } Continue: continue; ReConnWithDelay: if(remoteTcpClient_fd != -1){ SocketClose(&remoteTcpClient_fd); } sleep(CLOUD_RETRY); } } exit: if(inDataBuffer) free(inDataBuffer); if(outDataBuffer) free(outDataBuffer); if(remoteTcpClient_loopBack_fd != -1) SocketClose(&remoteTcpClient_loopBack_fd); client_log("Exit: Remote TCP client exit with err = %d", err); mico_rtos_delete_thread(NULL); return; }
static PRInt32 PR_CALLBACK SocketWrite(PRFileDesc *fd, const void *buf, PRInt32 amount) { return SocketSend(fd, buf, amount, 0, PR_INTERVAL_NO_TIMEOUT); }
OSStatus _LocalConfigRespondInComingMessage(int fd, ECS_HTTPHeader_t* inHeader, mico_Context_t * const inContext) { OSStatus err = kUnknownErr; const char * json_str; uint8_t *httpResponse = NULL; size_t httpResponseLen = 0; json_object* report = NULL; char err_msg[32] = {0}; MVDActivateRequestData_t devActivateRequestData; MVDAuthorizeRequestData_t devAuthorizeRequestData; MVDResetRequestData_t devResetRequestData; MVDOTARequestData_t devOTARequestData; MVDGetStateRequestData_t devGetStateRequestData; fogcloud_config_log_trace(); if(ECS_HTTPHeaderMatchURL( inHeader, kCONFIGURLDevState ) == kNoErr){ if(inHeader->contentLength > 0){ fogcloud_config_log("Recv device getState request."); memset((void*)&devGetStateRequestData, '\0', sizeof(devGetStateRequestData)); err = getMVDGetStateRequestData(inHeader->extraDataPtr, &devGetStateRequestData); require_noerr( err, exit ); report = json_object_new_object(); err = MicoFogCloudGetState(inContext, devGetStateRequestData, report); require_noerr( err, exit ); fogcloud_config_log("get device state success!"); json_str = (char*)json_object_to_json_string(report); //config_log("json_str=%s", json_str); err = ECS_CreateSimpleHTTPMessage( ECS_kMIMEType_JSON, (uint8_t*)json_str, strlen(json_str), &httpResponse, &httpResponseLen ); require( httpResponse, exit ); err = SocketSend( fd, httpResponse, httpResponseLen ); SocketClose(&fd); } goto exit; } else if(ECS_HTTPHeaderMatchURL( inHeader, kCONFIGURLDevActivate ) == kNoErr){ if(inHeader->contentLength > 0){ fogcloud_config_log("Recv device activate request."); memset((void*)&devActivateRequestData, '\0', sizeof(devActivateRequestData)); err = getMVDActivateRequestData(inHeader->extraDataPtr, &devActivateRequestData); require_noerr( err, exit ); err = MicoFogCloudActivate(inContext, devActivateRequestData); require_noerr( err, exit ); fogcloud_config_log("Device activate success!"); report = json_object_new_object(); require_action(report, exit, err = kNoMemoryErr); json_object_object_add(report, "device_id", json_object_new_string(inContext->flashContentInRam.appConfig.fogcloudConfig.deviceId)); json_str = (char*)json_object_to_json_string(report); //config_log("json_str=%s", json_str); err = ECS_CreateSimpleHTTPMessage( ECS_kMIMEType_JSON, (uint8_t*)json_str, strlen(json_str), &httpResponse, &httpResponseLen ); require_noerr( err, exit ); require( httpResponse, exit ); err = SocketSend( fd, httpResponse, httpResponseLen ); SocketClose(&fd); } goto exit; } else if(ECS_HTTPHeaderMatchURL( inHeader, kCONFIGURLDevAuthorize ) == kNoErr){ if(inHeader->contentLength > 0){ fogcloud_config_log("Recv device authorize request."); memset((void*)&devAuthorizeRequestData, '\0', sizeof(devAuthorizeRequestData)); err = getMVDAuthorizeRequestData( inHeader->extraDataPtr, &devAuthorizeRequestData); require_noerr( err, exit ); err = MicoFogCloudAuthorize(inContext, devAuthorizeRequestData); require_noerr( err, exit ); fogcloud_config_log("Device authorize success!"); report = json_object_new_object(); require_action(report, exit, err = kNoMemoryErr); json_object_object_add(report, "device_id", json_object_new_string(inContext->flashContentInRam.appConfig.fogcloudConfig.deviceId)); json_str = (char*)json_object_to_json_string(report); //config_log("json_str=%s", json_str); err = ECS_CreateSimpleHTTPMessage( ECS_kMIMEType_JSON, (uint8_t*)json_str, strlen(json_str), &httpResponse, &httpResponseLen ); require( httpResponse, exit ); err = SocketSend( fd, httpResponse, httpResponseLen ); SocketClose(&fd); } goto exit; } else if(ECS_HTTPHeaderMatchURL( inHeader, kCONFIGURLResetCloudDevInfo ) == kNoErr){ if(inHeader->contentLength > 0){ fogcloud_config_log("Recv cloud device info reset request."); memset((void*)&devResetRequestData, '\0', sizeof(devResetRequestData)); err = getMVDResetRequestData( inHeader->extraDataPtr, &devResetRequestData); require_noerr( err, exit ); err = MicoFogCloudResetCloudDevInfo(inContext, devResetRequestData); require_noerr( err, exit ); fogcloud_config_log("Device cloud reset success!"); err = ECS_CreateSimpleHTTPOKMessage( &httpResponse, &httpResponseLen ); require_noerr( err, exit ); require( httpResponse, exit ); err = SocketSend( fd, httpResponse, httpResponseLen ); SocketClose(&fd); inContext->micoStatus.sys_state = eState_Software_Reset; require(inContext->micoStatus.sys_state_change_sem, exit); mico_rtos_set_semaphore(&inContext->micoStatus.sys_state_change_sem); } goto exit; } #ifdef MICO_FLASH_FOR_UPDATE else if(ECS_HTTPHeaderMatchURL( inHeader, kCONFIGURLDevFWUpdate ) == kNoErr){ if(inHeader->contentLength > 0){ fogcloud_config_log("Recv device fw_update request."); memset((void*)&devOTARequestData, '\0', sizeof(devOTARequestData)); err = getMVDOTARequestData( inHeader->extraDataPtr, &devOTARequestData); require_noerr( err, exit ); err = MicoFogCloudFirmwareUpdate(inContext, devOTARequestData); require_noerr( err, exit ); fogcloud_config_log("Device firmware update success!"); err = ECS_CreateSimpleHTTPOKMessage( &httpResponse, &httpResponseLen ); require_noerr( err, exit ); require( httpResponse, exit ); err = SocketSend( fd, httpResponse, httpResponseLen ); SocketClose(&fd); fogcloud_config_log("OTA bin_size=%lld, bin_version=%s", inContext->appStatus.fogcloudStatus.RecvRomFileSize, inContext->flashContentInRam.appConfig.fogcloudConfig.romVersion ); if(0 == inContext->appStatus.fogcloudStatus.RecvRomFileSize){ //no need to update, return size = 0, no need to boot bootloader err = kNoErr; goto exit; } mico_rtos_lock_mutex(&inContext->flashContentInRam_mutex); memset(&inContext->flashContentInRam.bootTable, 0, sizeof(boot_table_t)); inContext->flashContentInRam.bootTable.length = inContext->appStatus.fogcloudStatus.RecvRomFileSize; inContext->flashContentInRam.bootTable.start_address = UPDATE_START_ADDRESS; inContext->flashContentInRam.bootTable.type = 'A'; inContext->flashContentInRam.bootTable.upgrade_type = 'U'; MICOUpdateConfiguration(inContext); mico_rtos_unlock_mutex(&inContext->flashContentInRam_mutex); inContext->micoStatus.sys_state = eState_Software_Reset; require(inContext->micoStatus.sys_state_change_sem, exit); mico_rtos_set_semaphore(&inContext->micoStatus.sys_state_change_sem); } goto exit; } #endif else{ return kNotFoundErr; }; exit: if((kNoErr != err) && (fd > 0)){ //ECS_CreateSimpleHTTPFailedMessage( &httpResponse, &httpResponseLen ); sprintf(err_msg, "{\"error\": %d}", err); ECS_CreateHTTPFailedMessage("500", "FAILED", ECS_kMIMEType_JSON, strlen(err_msg), (uint8_t*)err_msg, strlen(err_msg), &httpResponse, &httpResponseLen ); require( httpResponse, exit ); SocketSend( fd, httpResponse, httpResponseLen ); SocketClose(&fd); } if(httpResponse) free(httpResponse); if(report) json_object_put(report); return err; }