void CSpoofRemote::SendCommand(const char *pCommand) { #if defined(CONF_SPOOFING) if(!pCommand || str_length(pCommand) <= 0) return; // save the command, but no control messages if(str_length(pCommand) > 4) str_copy(m_aLastCommand, pCommand, sizeof(m_aLastCommand)); if(!IsConnected()) { Console()->Print(0, "spfrmt", "not connected. Use spf_connect first!", false); str_copy(m_aLastMessage, "[Local]: not connected. Use spf_connect first!", sizeof(m_aLastMessage)); return; } if(net_tcp_send(m_Socket, pCommand, str_length(pCommand)) < 0) { Console()->Print(0, "spfrmt", "error while sending, disconnecting!", false); dbg_msg("spfrmt", "error while sending"); Disconnect(); } #endif }
int CNetConsole::Update() { NETSOCKET Socket; NETADDR Addr; if(net_tcp_accept(m_Socket, &Socket, &Addr) > 0) { // check if we just should drop the packet char aBuf[128]; if(NetBan() && NetBan()->IsBanned(&Addr, aBuf, sizeof(aBuf))) { // banned, reply with a message and drop net_tcp_send(Socket, aBuf, str_length(aBuf)); net_tcp_close(Socket); } else AcceptClient(Socket, &Addr); } for(int i = 0; i < NET_MAX_CONSOLE_CLIENTS; i++) { if(m_aSlots[i].m_Connection.State() == NET_CONNSTATE_ONLINE) m_aSlots[i].m_Connection.Update(); if(m_aSlots[i].m_Connection.State() == NET_CONNSTATE_ERROR) Drop(i, m_aSlots[i].m_Connection.ErrorString()); } return 0; }
int CConsoleNetConnection::Send(const char *pLine) { if(State() != NET_CONNSTATE_ONLINE) return -1; char aBuf[1024]; str_copy(aBuf, pLine, (int)(sizeof(aBuf))-2); int Length = str_length(aBuf); aBuf[Length] = m_aLineEnding[0]; aBuf[Length+1] = m_aLineEnding[1]; aBuf[Length+2] = m_aLineEnding[2]; Length += 3; const char *pData = aBuf; while(true) { int Send = net_tcp_send(m_Socket, pData, Length); if(Send < 0) { m_State = NET_CONNSTATE_ERROR; str_copy(m_aErrorString, "failed to send packet", sizeof(m_aErrorString)); return -1; } if(Send >= Length) break; pData += Send; Length -= Send; } return 0; }
void FUNCTION_ATTRIBUTE mqtt_timer(void *arg) { MQTT_Client* client = (MQTT_Client*)arg; struct data_buf buffer; INFO("%s, %d\n", __func__, client->connState); if(client->connState == MQTT_DATA){ client->keepAliveTick ++; if(client->keepAliveTick > client->mqtt_state.connect_info->keepalive){ // check heart beat. if(client->heart_beat_flag == 0) { client->connState = TCP_RECONNECT_REQ; } INFO("\r\nMQTT: Send keepalive packet to %s:%d!\r\n", client->host, client->port); client->mqtt_state.outbound_message = mqtt_msg_pingreq(&client->mqtt_state.mqtt_connection); client->mqtt_state.pending_msg_type = MQTT_MSG_TYPE_PINGREQ; client->mqtt_state.pending_msg_type = mqtt_get_type(client->mqtt_state.outbound_message->data); client->mqtt_state.pending_msg_id = mqtt_get_id(client->mqtt_state.outbound_message->data, client->mqtt_state.outbound_message->length); client->sendTimeout = MQTT_SEND_TIMOUT; buffer.length = client->mqtt_state.outbound_message->length; buffer.data = client->mqtt_state.outbound_message->data; INFO("MQTT: Sending, type: %d, id: %04X\r\n",client->mqtt_state.pending_msg_type, client->mqtt_state.pending_msg_id); net_tcp_send(client->pCon, buffer, client->sendTimeout); client->mqtt_state.outbound_message = NULL; client->keepAliveTick = 0; client->heart_beat_flag = 0; MQTT_Task(client); } } else if(client->connState == TCP_RECONNECT_REQ){ INFO("%s, client->reconnectTick:%d\n", __func__, client->reconnectTick); client->reconnectTick ++; if(client->reconnectTick > MQTT_RECONNECT_TIMEOUT) { client->reconnectTick = 0; client->connState = TCP_RECONNECT; MQTT_Task(client); } }else if(client->connState == TCP_CONNECTING){ INFO("%s, client->connectTick:%d\n", __func__, client->connectTick); client->connectTick ++; if(client->connectTick > MQTT_CONNECT_TIMEOUT) { client->connState = TCP_CONNECTING_ERROR; client->connectTick = 0; MQTT_Task(client); } } if(client->sendTimeout > 0) client->sendTimeout --; }
void FUNCTION_ATTRIBUTE MQTT_Task(MQTT_Client *client) { INFO("MQTT TASK: state: %d\n", client->connState); uint8_t dataBuffer[MQTT_BUF_SIZE]; uint16_t dataLen; struct data_buf buffer; if(client == NULL) return; switch(client->connState){ case TCP_RECONNECT_REQ: break; case TCP_RECONNECT: MQTT_Connect(client); INFO("TCP: Reconnect to: %s:%d\r\n", client->host, client->port); client->connState = TCP_CONNECTING; break; case MQTT_DATA: INFO("MQTT TASK DATA\n"); if(QUEUE_IsEmpty(&client->msgQueue) || client->sendTimeout != 0) { break; } if(QUEUE_Gets(&client->msgQueue, dataBuffer, &dataLen, MQTT_BUF_SIZE) == 0){ INFO("%s, dataLen:%d\n", __func__, dataLen); client->mqtt_state.pending_msg_type = mqtt_get_type(dataBuffer); client->mqtt_state.pending_msg_id = mqtt_get_id(dataBuffer, dataLen); client->sendTimeout = MQTT_SEND_TIMOUT; buffer.length = dataLen; buffer.data = dataBuffer; INFO("MQTT: Sending, type: %d, id: %04X\r\n",client->mqtt_state.pending_msg_type, client->mqtt_state.pending_msg_id); net_tcp_send(client->pCon, buffer, client->sendTimeout); client->mqtt_state.outbound_message = NULL; break; } break; case TCP_CONNECTING_ERROR: MQTT_Disconnect(client); MQTT_exit(client); break; } }
int CNetConsole::AcceptClient(NETSOCKET Socket, const NETADDR *pAddr) { char aError[256] = { 0 }; int FreeSlot = -1; // look for free slot or multiple client for(int i = 0; i < NET_MAX_CONSOLE_CLIENTS; i++) { if(FreeSlot == -1 && m_aSlots[i].m_Connection.State() == NET_CONNSTATE_OFFLINE) FreeSlot = i; if(m_aSlots[i].m_Connection.State() != NET_CONNSTATE_OFFLINE) { if(net_addr_comp(pAddr, m_aSlots[i].m_Connection.PeerAddress()) == 0) { str_copy(aError, "only one client per IP allowed", sizeof(aError)); break; } } } // accept client if(!aError[0] && FreeSlot != -1) { m_aSlots[FreeSlot].m_Connection.Init(Socket, pAddr); if(m_pfnNewClient) m_pfnNewClient(FreeSlot, m_UserPtr); return 0; } // reject client if(!aError[0]) str_copy(aError, "no free slot available", sizeof(aError)); net_tcp_send(Socket, aError, str_length(aError)); net_tcp_close(Socket); return -1; }
/** * @brief Tcp client connect success callback function. * @param arg: contain the ip link information * @retval None */ void FUNCTION_ATTRIBUTE mqtt_tcpclient_connect_cb(void *arg, int8_t errno) { struct pando_tcp_conn *pCon = (struct pando_tcp_conn *)arg; MQTT_Client* client = (MQTT_Client *)pCon->reverse; struct data_buf buffer; net_tcp_register_disconnected_callback(pCon, mqtt_tcpclient_discon_cb); net_tcp_register_recv_callback(pCon, mqtt_tcpclient_recv); net_tcp_register_sent_callback(pCon, mqtt_tcpclient_sent_cb); INFO("MQTT: Connected to broker %s:%d\r\n", client->host, client->port); mqtt_msg_init(&client->mqtt_state.mqtt_connection, client->mqtt_state.out_buffer, client->mqtt_state.out_buffer_length); client->mqtt_state.outbound_message = mqtt_msg_connect(&client->mqtt_state.mqtt_connection, client->mqtt_state.connect_info); client->mqtt_state.pending_msg_type = mqtt_get_type(client->mqtt_state.outbound_message->data); client->mqtt_state.pending_msg_id = mqtt_get_id(client->mqtt_state.outbound_message->data, client->mqtt_state.outbound_message->length); client->sendTimeout = MQTT_SEND_TIMOUT; buffer.length = client->mqtt_state.outbound_message->length; buffer.data = client->mqtt_state.outbound_message->data; INFO("MQTT: Sending, type: %d, id: %04X\r\n",client->mqtt_state.pending_msg_type, client->mqtt_state.pending_msg_id); net_tcp_send(pCon, buffer, client->sendTimeout); client->mqtt_state.outbound_message = NULL; client->connState = MQTT_CONNECT_SENDING; MQTT_Task(client); }
IGeoIP::GeoInfo CGeoIP::GetInfo(std::string ip) { dbg_msg("GeoIP", "Searching geolocation of '%s'...", ip.c_str()); NETADDR bindAddr; mem_zero(&bindAddr, sizeof(bindAddr)); char aNetBuff[1024]; std::string jsonData; IGeoIP::GeoInfo rInfo; //Connect bindAddr.type = NETTYPE_IPV4; m_Socket = net_tcp_create(bindAddr); net_set_non_blocking(m_Socket); if(net_tcp_connect(m_Socket, &m_HostAddress) < 0) { if (net_errno() != EINPROGRESS) { dbg_msg("GeoIP","ERROR: Can't connect."); net_tcp_close(m_Socket); return rInfo; } } net_socket_read_wait(m_Socket, 1); net_set_blocking(m_Socket); //Send request str_format(aNetBuff, sizeof(aNetBuff), "GET /geoip/%s HTTP/1.0\r\nHost: www.telize.com\r\n\r\n", ip.c_str()); net_tcp_send(m_Socket, aNetBuff, strlen(aNetBuff)); //read data bool errors = true; std::string NetData; int TotalRecv = 0; int TotalBytes = 0; int CurrentRecv = 0; bool isHead = true; int enterCtrl = 0; while ((CurrentRecv = net_tcp_recv(m_Socket, aNetBuff, sizeof(aNetBuff))) > 0) { for (int i=0; i<CurrentRecv ; i++) { if (isHead) { if (aNetBuff[i]=='\n') { enterCtrl++; if (enterCtrl == 2) { isHead = false; NetData.clear(); continue; } std::transform(NetData.begin(), NetData.end(), NetData.begin(), ::tolower); if (NetData.find("content-length:") != std::string::npos) { sscanf(NetData.c_str(), "content-length:%d", &TotalBytes); if (TotalBytes == 0) sscanf(NetData.c_str(), "content-length: %d", &TotalBytes); } NetData.clear(); continue; } else if (aNetBuff[i]!='\r') enterCtrl=0; NetData+=aNetBuff[i]; } else { if (TotalBytes == 0) { net_tcp_close(m_Socket); dbg_msg("GeoIP","ERROR: Error with size received data."); break; } jsonData += aNetBuff[i]; TotalRecv++; if (TotalRecv == TotalBytes) { errors = false; break; } } } } //Finish net_tcp_close(m_Socket); if (!errors) { // parse json data json_settings JsonSettings; mem_zero(&JsonSettings, sizeof(JsonSettings)); char aError[256]; json_value *pJsonData = json_parse_ex(&JsonSettings, jsonData.c_str(), jsonData.length(), aError); if (pJsonData == 0) { dbg_msg("GeoIP", "Error: %s", aError); return rInfo; } // generate configurations const json_value &countryCode = (*pJsonData)["country_code"]; if (countryCode.type == json_string) str_copy(rInfo.m_aCountryCode, (const char *)countryCode, sizeof(rInfo.m_aCountryCode)); const json_value &countryName = (*pJsonData)["country"]; if (countryName.type == json_string) str_copy(rInfo.m_aCountryName, (const char *)countryName, sizeof(rInfo.m_aCountryName)); //const json_value &isp = (*pJsonData)["isp"]; //if (isp.type == json_string) geoInfo->m_Isp = (const char *)isp; } return rInfo; }
bool CHttpDownloader::GetToFile(const char *url, const char *dest, unsigned timeOut, unsigned downloadSpeed) { if (!dest || dest[0] == 0) return false; int64 downloadTime = time_get(); unsigned chunkBytes = 0; NETSOCKET sock; NETADDR nadd, bindAddr; mem_zero(&nadd, sizeof(nadd)); mem_zero(&bindAddr, sizeof(bindAddr)); bindAddr.type = NETTYPE_IPV4; NETURL NetUrl = CreateUrl(url); if (net_host_lookup(NetUrl.m_aHost, &nadd, NETTYPE_IPV4) != 0) { dbg_msg("HttpDownloader", "Error can't found '%s'...", NetUrl.m_aHost); return false; } nadd.port = 80; sock = net_tcp_create(bindAddr); if (net_tcp_connect(sock, &nadd) != 0) { dbg_msg("HttpDownloader", "Error can't connect with '%s'...", NetUrl.m_aHost); net_tcp_close(sock); return false; } net_socket_rcv_timeout(sock, timeOut); char aBuff[512] = {0}; str_format(aBuff, sizeof(aBuff), "GET %s HTTP/1.0\r\nHost: %s\r\n\r\n", NetUrl.m_aSlug, NetUrl.m_aHost); net_tcp_send(sock, aBuff, str_length(aBuff)); std::string NetData; unsigned TotalRecv = 0; unsigned TotalBytes = 0; int CurrentRecv = 0; unsigned nlCount = 0; char aNetBuff[1024] = {0}; IOHANDLE dstFile = NULL; do { // Limit Speed if (downloadSpeed > 0) { int64 ctime = time_get(); if (ctime - downloadTime <= time_freq()) { if (chunkBytes >= downloadSpeed) { int tdff = (time_freq() - (ctime - downloadTime)) / 1000; thread_sleep(tdff); continue; } } else { chunkBytes = 0; downloadTime = time_get(); } } // CurrentRecv = net_tcp_recv(sock, aNetBuff, sizeof(aNetBuff)); chunkBytes += CurrentRecv; for (int i=0; i<CurrentRecv ; i++) { if (nlCount < 2) { if (aNetBuff[i] == '\r' || aNetBuff[i] == '\n') { ++nlCount; if (NetData.size() > 0) { std::transform(NetData.begin(), NetData.end(), NetData.begin(), ::tolower); if (NetData.find("404 not found") != std::string::npos) { dbg_msg("HttpDownloader", "ERROR 404: '%s' not found...", NetUrl.m_aFile); net_tcp_close(sock); return false; } else if (NetData.find("content-length:") != std::string::npos) { char aFileSize[64]; str_copy(aFileSize, NetData.substr(15).c_str(), sizeof(aFileSize)); str_trim(aFileSize); TotalBytes = atoi(aFileSize); } NetData.clear(); } if (aNetBuff[i] == '\r') ++i; continue; } nlCount = 0; NetData += aNetBuff[i]; } else { if (nlCount == 2) { if (TotalBytes <= 0) { dbg_msg("HttpDownloader", "Error downloading '%s'...", NetUrl.m_aFile); net_tcp_close(sock); return false; } dstFile = io_open(dest, IOFLAG_WRITE); if(!dstFile) { dbg_msg("HttpDownloader", "Error creating '%s'...", dest); net_tcp_close(sock); return false; } ++nlCount; } io_write(dstFile, &aNetBuff[i], 1); TotalRecv++; if (TotalRecv == TotalBytes) break; } } } while (CurrentRecv > 0); net_tcp_close(sock); if (TotalRecv > 0) { io_close(dstFile); return true; } return false; }
unsigned CHttpDownloader::GetFileSize(const char *url, unsigned timeOut) { NETSOCKET sock; NETADDR nadd, bindAddr; mem_zero(&nadd, sizeof(nadd)); mem_zero(&bindAddr, sizeof(bindAddr)); bindAddr.type = NETTYPE_IPV4; NETURL NetUrl = CreateUrl(url); if (net_host_lookup(NetUrl.m_aHost, &nadd, NETTYPE_IPV4) != 0) { dbg_msg("HttpDownloader", "Error can't found '%s'...", NetUrl.m_aHost); return false; } nadd.port = 80; sock = net_tcp_create(bindAddr); net_socket_rcv_timeout(sock, timeOut); if (net_tcp_connect(sock, &nadd) != 0) { dbg_msg("HttpDownloader", "Error can't connect with '%s'...", NetUrl.m_aHost); net_tcp_close(sock); return false; } char aBuff[512] = {0}; str_format(aBuff, sizeof(aBuff), "GET %s HTTP/1.0\r\nHost: %s\r\n\r\n", NetUrl.m_aSlug, NetUrl.m_aHost); net_tcp_send(sock, aBuff, str_length(aBuff)); std::string NetData; int TotalBytes = 0; int CurrentRecv = 0; int nlCount = 0; char aNetBuff[1024] = {0}; do { CurrentRecv = net_tcp_recv(sock, aNetBuff, sizeof(aNetBuff)); for (int i=0; i<CurrentRecv ; i++) { if (nlCount < 2) { if (aNetBuff[i] == '\r' || aNetBuff[i] == '\n') { ++nlCount; if (NetData.size() > 0) { std::transform(NetData.begin(), NetData.end(), NetData.begin(), ::tolower); if (NetData.find("404 not found") != std::string::npos) { dbg_msg("HttpDownloader", "ERROR 404: '%s' not found...", NetUrl.m_aFile); net_tcp_close(sock); return false; } else if (NetData.find("content-length:") != std::string::npos) { char aFileSize[64]; str_copy(aFileSize, NetData.substr(15).c_str(), sizeof(aFileSize)); str_trim(aFileSize); TotalBytes = atoi(aFileSize); if (TotalBytes <= 0) { dbg_msg("HttpDownloader", "Error getting size of '%s'...", NetUrl.m_aFile); net_tcp_close(sock); return 0; } net_tcp_close(sock); return TotalBytes; } NetData.clear(); } if (aNetBuff[i] == '\r') ++i; continue; } nlCount = 0; NetData += aNetBuff[i]; } else { dbg_msg("HttpDownloader", "Error getting size of '%s'...", NetUrl.m_aFile); net_tcp_close(sock); return 0; } } } while (CurrentRecv > 0); return 0; }
// TODO: Ugly but works bool CUpdater::GetFile(const char *url, const char *path) { NETSOCKET Socket = invalid_socket; NETADDR HostAddress, BindAddr; mem_zero(&HostAddress, sizeof(HostAddress)); mem_zero(&BindAddr, sizeof(BindAddr)); char aNetBuff[1024]; //Lookup if(net_host_lookup(UPDATES_HOST, &HostAddress, NETTYPE_IPV4) != 0) { dbg_msg("autoupdate", "Error running host lookup"); return false; } HostAddress.port = 80; //Connect BindAddr.type = NETTYPE_IPV4; Socket = net_tcp_create(BindAddr); if(net_tcp_connect(Socket, &HostAddress) != 0) { net_tcp_close(Socket); dbg_msg("autoupdate","Error connecting to host"); return false; } //Send request str_format(aNetBuff, sizeof(aNetBuff), "GET "UPDATES_BASE_PATH"%s HTTP/1.0\r\nHost: "UPDATES_HOST"\r\n\r\n", url); net_tcp_send(Socket, aNetBuff, str_length(aNetBuff)); //read data IOHANDLE dstFile = 0; std::string NetData; int TotalRecv = 0, TotalBytes = 0, CurrentRecv = 0, enterCtrl = 0; bool isHead = true, isStatusLine = true; while ((CurrentRecv = net_tcp_recv(Socket, aNetBuff, sizeof(aNetBuff))) > 0) { for (int i=0; i<CurrentRecv ; i++) { if (isHead) { if (aNetBuff[i]=='\n') { if (++enterCtrl == 2) // Go To Body Part { dstFile = io_open(path, IOFLAG_WRITE); if (!dstFile) { net_tcp_close(Socket); dbg_msg("autoupdate","Error writing to disk"); return false; } str_copy(m_CurrentDownloadFileName, url, sizeof(m_CurrentDownloadFileName)); isHead = false; NetData.clear(); continue; } std::transform(NetData.begin(), NetData.end(), NetData.begin(), ::tolower); // Check Status if (isStatusLine) { bool isCodeOk = NetData.find("200") != std::string::npos; bool isStatusOk = NetData.find("ok") != std::string::npos; if (!isCodeOk || !isStatusOk) { net_tcp_close(Socket); dbg_msg("autoupdate","Server Host returns error code"); return false; } } isStatusLine = false; // Get File Size std::size_t fpos = std::string::npos; if ((fpos=NetData.find("content-length:")) != std::string::npos) sscanf(NetData.substr(fpos+15).c_str(), "%d", &TotalBytes); NetData.clear(); continue; } else if (aNetBuff[i]!='\r') enterCtrl=0; NetData+=aNetBuff[i]; } else // Body Part { if (TotalBytes <= 0) { io_close(dstFile); net_tcp_close(Socket); dbg_msg("autoupdate","Error receiving file"); return false; } m_CurrentDownloadProgress = (float)TotalRecv/(float)TotalBytes; io_write(dstFile, &aNetBuff[i], 1); TotalRecv++; if (TotalRecv == TotalBytes) break; } } } //Finish io_close(dstFile); net_tcp_close(Socket); return true; }