int FileTransferProtocol::recvFilename(net::Socket &s, string &filename) { int bytes_received; // First, receive the filename size (3 bytes ascii-encoded unsigned integer) char buf[3]; bytes_received = s.recv(buf, 3, 0); if (bytes_received == SOCKET_ERROR || bytes_received != 3) { onTransferError("Could not receive filename header size!"); return -1; } // Try to parse what we have received size_t len; if (EOF == sscanf_s(buf, "%3lu", &len)) { onTransferError("Could not parse filename header size!"); return -1; } // Finally, allocate a string and receive the filename char *nameBuf = (char*)malloc(len + 1); nameBuf[len] = '\0'; bytes_received = s.recv(nameBuf, len, 0); if (bytes_received == SOCKET_ERROR || bytes_received != len) { free(nameBuf); onTransferError("Could not receive filename header!"); } filename = string(nameBuf); free(nameBuf); return 0; }
int FileTransferProtocol::sendFilename(net::Socket &s, string filename) { int bytes_sent; char fNameHeader[4]; sprintf_s(fNameHeader, "%03lu", (unsigned long)filename.size()); bytes_sent = s.send(fNameHeader, 3, 0); if (bytes_sent == SOCKET_ERROR || bytes_sent != 3) { onTransferError("Could not send filename size"); return -1; } bytes_sent = s.send(filename.c_str(), filename.size(), 0); if (bytes_sent == SOCKET_ERROR || bytes_sent != filename.size()) { onTransferError("Could not send filename"); return -1; } return 0; }
void Server::onSocketRecv(net::Socket& socket, const MutableBuffer& buffer, const net::Address& peerAddress) { TraceL << "Data received: " << buffer.size() << endl; stun::Message message; char* buf = bufferCast<char*>(buffer); std::size_t len = buffer.size(); std::size_t nread = 0; while (len > 0 && (nread = message.read(constBuffer(buf, len))) > 0) { if (message.classType() == stun::Message::Request || message.classType() == stun::Message::Indication) { Request request(message, socket.transport(), socket.address(), peerAddress); // TODO: Only authenticate stun::Message::Request types handleRequest(request, _observer.authenticateRequest(this, request)); } else { assert(0 && "unknown request type"); } buf += nread; len -= nread; } if (len == buffer.size()) WarnL << "Non STUN packet received" << std::endl; #if 0 stun::Message message; if (message.read(constBuffer(packet.data(), packet.size()))) { assert(message.state() == stun::Message::Request); Request request(*info->socket, message, info->socket->address(), info->peerAddress); AuthenticationState state = _observer.authenticateRequest(this, request); handleRequest(request, state); } else #endif } void Server::onTCPSocketClosed(net::Socket& socket) { TraceL << "TCP socket closed" << endl; releaseTCPSocket(&socket); }
int FileTransferProtocol::sendCommand(net::Socket &s, char command) { int bytes_sent = s.send(&command, 1, 0); if (bytes_sent == SOCKET_ERROR || bytes_sent != 1) { onTransferError("Could not send command!"); return -1; } return 0; }
int FileTransferProtocol::sendErr(net::Socket &s) { char buf[3] = { 'E', 'R', 'R' }; int bytes_sent = s.send(buf, 3, 0); if (bytes_sent == SOCKET_ERROR || bytes_sent != 3) { onTransferError("Could not send error notice to client!"); return -1; } return 0; }
int FileTransferProtocol::waitForAck(net::Socket &s, string errmsg) { char ackbuf[4] = " "; // Either ACK or ERR int bytes_received = s.recv(ackbuf, 3, 0); if (bytes_received == SOCKET_ERROR || bytes_received != 3 || strcmp(ackbuf, "ERR") == 0) { onTransferError(errmsg); return -1; } return 0; }
int FileTransferProtocol::sendAck(net::Socket &s) { char buf[3] = { 'A', 'C', 'K' }; int bytes_sent = s.send(buf, 3, 0); if (bytes_sent == SOCKET_ERROR || bytes_sent != 3) { onTransferError("Could not acknowledge client!"); return -1; } return 0; }
namespace Network { Net::Socket serverSocket; void cleanUp() { Net::cleanup(); } void init() { Net::startup(); serverSocket.listenIPv4(30001); } }
bool accept_client(net::Socket remote, std::string origin) { /* printf("Verifying origin: \"%s\"\n" "Verifying remote: \"%s\"\n", origin.c_str(), remote.to_string().c_str()); */ (void) origin; return remote.address() == net::ip4::Addr(10,0,0,1); }
void checkResponse(net::Socket& socket) throw (Exception) { iostream::XdrInputStream& istream = socket.getXdrInputStream(); int responseType = 0; istream.read(responseType); if (responseType == net::MessageProtocol::ERROR) { throw Exception("Exception has occurred"); } else if (responseType != net::MessageProtocol::REPLY) { throw Exception("Internal implementation error"); } }
void checkResponse(net::Socket& socket) throw (Exception) { iostream::XdrInputStream& istream = socket.getXdrInputStream(); int responseType = 0; istream.read(responseType); if (responseType == net::MessageProtocol::ERROR) { throw Exception(); } else if (responseType != net::MessageProtocol::REPLY) { throw Exception(); } }
size_t StreamSocketReceiver::receiveHeader(net::Socket &s) { char buf[20]; size_t bytes_received; if (bytes_received = s.recv(buf, 20) != 20) { throw IncompleteReceiveException(bytes_received, 20); } // Try to parse length of payload in header size_t len; if (EOF == sscanf_s(buf, "%20lu", &len)) { throw UnparseableHeaderException(buf); } return len; }
int FileTransferProtocol::recvCommand(net::Socket &s, char &command) { char d; int bytes_received; bytes_received = s.recv(&d, 1, 0); if (bytes_received == SOCKET_ERROR || bytes_received != 1) { onTransferError("Could not receive direction from client!"); return -1; } if (d != 'D' && d != 'U' && d != 'L' && d != 'Q') { onTransferError("Client sent invalid direction!"); return -1; } command = d; return 0; }
void init(string ip, unsigned short _port) { Net::startup(); try { socketClient.connectIPv4(ip, _port); } catch (...) { DebugError("Cannot connect to the server!"); return; } threadRun = true; mutex = MutexCreate(); t = ThreadCreate(networkThread, NULL); }
void StreamSocketReceiver::receivePayload(net::Socket &s, ostream &stream, size_t len) { void *buf = malloc(this->packet_size); size_t bytes_read = 0; while (bytes_read < len) { size_t exp_bytes = min(this->packet_size, len - bytes_read); size_t bytes_recv = s.recv((char*)buf, exp_bytes); if (bytes_recv != exp_bytes) { free(buf); throw IncompleteReceiveException(bytes_read + bytes_recv, len); } bytes_read += bytes_recv; stream.write((char*)buf, bytes_recv); } free(buf); }
namespace Network { Net::Socket socketClient; Thread_t t; Mutex_t mutex; std::queue<Request> reqs; bool threadRun = true; void init(string ip, unsigned short _port) { Net::startup(); try { socketClient.connectIPv4(ip, _port); } catch (...) { DebugError("Cannot connect to the server!"); return; } threadRun = true; mutex = MutexCreate(); t = ThreadCreate(networkThread, NULL); } int getRequestCount() { return reqs.size(); } Net::Socket& getClientSocket() { return socketClient; } ThreadFunc networkThread(void *) { while (true) { MutexLock(mutex); if (!threadRun) { MutexUnlock(mutex); break; } if (reqs.empty()) { MutexUnlock(mutex); continue; } Request& r = reqs.front(); //if (r._signal == PLAYER_PACKET_SEND && ((PlayerPacket*)r._dataSend)->onlineID != player::onlineID) // cout << "[ERROR]WTF!!!" << endl; if (r._dataSend != nullptr && r._dataLen != 0) { Net::Buffer buffer(r._dataLen + sizeof(int) * 2); int len = r._dataLen + sizeof(int); buffer.write((void*)&len, sizeof(int)); buffer.write((void*)&r._signal, sizeof(int)); buffer.write((void*)r._dataSend, r._dataLen); getClientSocket().send(buffer); } else { Net::Buffer buffer(sizeof(int) * 2); int len = sizeof(int); buffer.write((void*)&len, sizeof(int)); buffer.write((void*)&r._signal, sizeof(int)); getClientSocket().send(buffer); } if (r._callback) { //判断有无回调函数 auto callback = r._callback; MutexUnlock(mutex); int len = getClientSocket().recvInt(); //获得数据长度 Net::Buffer buffer(len); getClientSocket().recv(buffer, Net::BufferConditionExactLength(len)); if (len > 0) callback(buffer.getData(), len); //调用回调函数 MutexLock(mutex); } reqs.pop(); MutexUnlock(mutex); } return 0; } void pushRequest(Request& r) { if (reqs.size() + 1 > networkRequestMax) { //超过请求队列长度,试图精简队列 if (!reqs.front().isImportant()) reqs.pop(); } if (reqs.size() + 1 > networkRequestMax * 2) { //大量超过请求队列长度,只保留重要请求 std::queue<Request> q; while (reqs.size() != 0) { if (reqs.front().isImportant()) q.push(reqs.front()); reqs.pop(); } reqs = q; } reqs.push(r); } void cleanUp() { threadRun = false; ThreadWait(t); ThreadDestroy(t); MutexDestroy(mutex); getClientSocket().close(); Net::cleanup(); } }
void init() { Net::startup(); serverSocket.listenIPv4(30001); }