CActiveSocket* CActiveSocket::NewL(RSocketServ& aServer, TUint aAddrFamily, TUint aSockType, TUint aProtocol) { CActiveSocket* self = new (ELeave) CActiveSocket(aServer, aAddrFamily, aProtocol); CleanupStack::PushL(self); self->ConstructL(aSockType); CleanupStack::Pop(self); return self; }
void Send(uint8* buf,int32 size) { uint8* bufn=new uint8[size+sizeof(int32)]; int32* sizeB=reinterpret_cast<int32*>(bufn); *sizeB=htonl(size); memcpy(bufn+sizeof(int32),buf,size); if(mysock->Send(bufn,size+sizeof(int32))!=size+sizeof(int32)) { CoreSuspender suspend; color_ostream_proxy out(Core::getInstance().getConsole()); out.printerr("%s\n",translate_socket_error(mysock->GetSocketError())); } delete [] bufn; }
void run() { while(alive) { int pos=mysock->Receive(sizeof(uint32_t)); if(pos<=0) { alive=false; return; } uint32_t *d=(uint32_t*)mysock->GetData(); if(d!=0) { uint32_t size=ntohl(*d); uint8_t* buffer=new uint8_t[size]; uint8_t* cptr=buffer; uint32_t csize=0; while(csize<size) { int ret=mysock->Receive(sizeof(uint32_t)); if(ret<=0) { alive=false; return; } memcpy(cptr,mysock->GetData(),ret); cptr+=ret; csize+=ret; } CoreSuspender suspend; color_ostream_proxy out(Core::getInstance().getConsole()); onDataRecieved(out,myId,size,buffer); delete [] buffer; } else { CoreSuspender suspend; color_ostream_proxy out(Core::getInstance().getConsole()); out.printerr("%s\n",translate_socket_error(mysock->GetSocketError())); return; } } }
~Connection() { mysock->Close(); myThread->join(); CoreSuspender suspend; color_ostream_proxy out(Core::getInstance().getConsole()); onDisconnect(out,myId); delete mysock; delete myThread; }
TRequestorStatus CActiveSocket::OnResolve(TInt aStatus, TAny* aPtr) { CActiveSocket* sock = static_cast<CActiveSocket*>(aPtr); sock->iHostName.Close(); if (aStatus == KErrNone) { TRequestor req(CActiveSocket::OnConnect, CActiveSocket::CancelConnect, sock); sock->iFunc->SetRequestor(req); TInetAddr& inet = TInetAddr::Cast(sock->iNameEntry().iAddr); inet.SetPort(sock->iPort); sock->iSocket.Connect(inet, sock->iFunc->RequestStatus()); return EYield; } else { // Raise error sock->iFunc->RaiseError(_L8("Resolving host failed"), aStatus); // Clear iFunc, we are done doing async invocations sock->iFunc = NULL; return EResume; } }
int main(int argc, char **argv) { CActiveSocket socket; // Instantiate active socket object (defaults to TCP). char time[50]; memset(&time, 0, 50); //-------------------------------------------------------------------------- // Initialize our socket object //-------------------------------------------------------------------------- socket.Initialize(); //-------------------------------------------------------------------------- // Create a connection to the time server so that data can be sent // and received. //-------------------------------------------------------------------------- if (socket.Open("time-C.timefreq.bldrdoc.gov", 13)) { //---------------------------------------------------------------------- // Send a requtest the server requesting the current time. //---------------------------------------------------------------------- if (socket.Send((const uint8 *)"\n", 1)) { //---------------------------------------------------------------------- // Receive response from the server. //---------------------------------------------------------------------- socket.Receive(49); memcpy(&time, socket.GetData(), 49); printf("%s\n", time); //---------------------------------------------------------------------- // Close the connection. //---------------------------------------------------------------------- socket.Close(); } } return 1; }
int main(int argc, char **argv) { CPassiveSocket socket; CActiveSocket *pClient = NULL; //-------------------------------------------------------------------------- // Initialize our socket object //-------------------------------------------------------------------------- socket.Initialize(); socket.Listen((const uint8 *)"127.0.0.1", 6789); while (true) { if ((pClient = socket.Accept()) != NULL) { //------------------------------------------------------------------ // Receive request from the client. //------------------------------------------------------------------ if (pClient->Receive(MAX_PACKET)) { // ERROR HERE # 7 //-------------------------------------------------------------- // Send response to client and close connection to the client. //-------------------------------------------------------------- pClient->Send((const uint8 *)pClient->GetData(), pClient->GetBytesReceived()); pClient->Close(); } delete pClient; } } //-------------------------------------------------------------------------- // Receive request from the client. //-------------------------------------------------------------------------- socket.Close(); return 1; }
//------------------------------------------------------------------------------ // // Accept() - // //------------------------------------------------------------------------------ CActiveSocket *CPassiveSocket::Accept() { uint32 nSockLen; CActiveSocket *pClientSocket = NULL; SOCKET socket = CSimpleSocket::SocketError; if (m_nSocketType != CSimpleSocket::SocketTypeTcp) { SetSocketError(CSimpleSocket::SocketProtocolError); return pClientSocket; } pClientSocket = new CActiveSocket(); //-------------------------------------------------------------------------- // Wait for incoming connection. //-------------------------------------------------------------------------- if (pClientSocket != NULL) { CSocketError socketErrno = SocketSuccess; m_timer.Initialize(); m_timer.SetStartTime(); nSockLen = sizeof(m_stClientSockaddr); do { errno = 0; socket = accept(m_socket, (struct sockaddr *)&m_stClientSockaddr, (socklen_t *)&nSockLen); if (socket != -1) { pClientSocket->SetSocketHandle(socket); pClientSocket->TranslateSocketError(); socketErrno = pClientSocket->GetSocketError(); socklen_t nSockLen = sizeof(struct sockaddr); //------------------------------------------------------------- // Store client and server IP and port information for this // connection. //------------------------------------------------------------- getpeername(m_socket, (struct sockaddr *)&pClientSocket->m_stClientSockaddr, &nSockLen); memcpy((void *)&pClientSocket->m_stClientSockaddr, (void *)&m_stClientSockaddr, nSockLen); memset(&pClientSocket->m_stServerSockaddr, 0, nSockLen); getsockname(m_socket, (struct sockaddr *)&pClientSocket->m_stServerSockaddr, &nSockLen); } else { TranslateSocketError(); socketErrno = GetSocketError(); } } while (socketErrno == CSimpleSocket::SocketInterrupted); m_timer.SetEndTime(); if (socketErrno != CSimpleSocket::SocketSuccess) { delete pClientSocket; pClientSocket = NULL; } } return pClientSocket; }
int main(int argc, char *argv[]) { b3CommandLineArgs parseArgs(argc,argv); b3Clock clock; double timeOutInSeconds = 10; DummyGUIHelper guiHelper; MyCommandProcessor* sm = new MyCommandProcessor; sm->setGuiHelper(&guiHelper); int port = 6667; parseArgs.GetCmdLineArgument("port",port); gVerboseNetworkMessagesServer = parseArgs.CheckCmdLineFlag("verbose"); #ifndef NO_SHARED_MEMORY int key = 0; if (parseArgs.GetCmdLineArgument("sharedMemoryKey",key)) { sm->setSharedMemoryKey(key); } #endif//NO_SHARED_MEMORY bool isPhysicsClientConnected = sm->connect(); bool exitRequested = false; if (isPhysicsClientConnected) { printf("Starting TCP server using port %d\n", port); CPassiveSocket socket; CActiveSocket *pClient = NULL; //-------------------------------------------------------------------------- // Initialize our socket object //-------------------------------------------------------------------------- socket.Initialize(); socket.Listen("localhost", port); //socket.SetBlocking(); int curNumErr = 0; while (!exitRequested) { b3Clock::usleep(0); if ((pClient = socket.Accept()) != NULL) { b3AlignedObjectArray<char> bytesReceived; int clientPort = socket.GetClientPort(); printf("connected from %s:%d\n", socket.GetClientAddr(),clientPort); if (pClient->Receive(4)) { int clientKey = *(int*)pClient->GetData(); if (clientKey==SHARED_MEMORY_MAGIC_NUMBER) { printf("Client version OK %d\n", clientKey); } else { printf("Server version (%d) mismatches Client Version (%d)\n", SHARED_MEMORY_MAGIC_NUMBER,clientKey); continue; } } //---------------------------------------------------------------------- // Receive request from the client. //---------------------------------------------------------------------- while (1) { //printf("try receive\n"); bool receivedData = false; int maxLen = 4 + sizeof(SharedMemoryStatus)+SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE; if (pClient->Receive(maxLen)) { //heuristic to detect disconnected clients CSimpleSocket::CSocketError err = pClient->GetSocketError(); if (err != CSimpleSocket::SocketSuccess || !pClient->IsSocketValid()) { b3Clock::usleep(100); curNumErr++; if (curNumErr>100) { printf("TCP Connection error = %d, curNumErr = %d\n", (int)err, curNumErr); break; } } curNumErr = 0; char* msg2 = (char*) pClient->GetData(); int numBytesRec2 = pClient->GetBytesReceived(); int curSize = bytesReceived.size(); bytesReceived.resize(bytesReceived.size()+numBytesRec2); for (int i=0;i<numBytesRec2;i++) { bytesReceived[curSize+i] = msg2[i]; } if (bytesReceived.size() >= 4) { int numBytesRec = bytesReceived.size(); if (numBytesRec>=10) { if (strncmp(&bytesReceived[0],"disconnect",10)==0) { printf("Disconnect request received\n"); bytesReceived.clear(); break; } if (strncmp(&bytesReceived[0],"terminateserver",10)==0) { printf("Terminate server request received\n"); exitRequested = true; bytesReceived.clear(); break; } } if (gVerboseNetworkMessagesServer) { printf("received message length [%d]\n",numBytesRec); } receivedData = true; SharedMemoryCommand cmd; SharedMemoryCommand* cmdPtr = 0; int type = *(int*)&bytesReceived[0]; //performance test if (numBytesRec == sizeof(int)) { cmdPtr = &cmd; cmd.m_type = *(int*)&bytesReceived[0]; } else { if (numBytesRec == sizeof(SharedMemoryCommand)) { cmdPtr = (SharedMemoryCommand*)&bytesReceived[0]; } else { if (numBytesRec==36) { cmdPtr = &cmd; memcpy(&cmd, &bytesReceived[0], numBytesRec); } } } if (cmdPtr) { SharedMemoryStatus serverStatus; b3AlignedObjectArray<char> buffer; buffer.resize(SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE); bool hasStatus = sm->processCommand(*cmdPtr,serverStatus, &buffer[0], buffer.size()); double startTimeSeconds = clock.getTimeInSeconds(); double curTimeSeconds = clock.getTimeInSeconds(); while ((!hasStatus) && ((curTimeSeconds - startTimeSeconds) <timeOutInSeconds)) { hasStatus = sm->receiveStatus(serverStatus, &buffer[0], buffer.size()); curTimeSeconds = clock.getTimeInSeconds(); } if (gVerboseNetworkMessagesServer) { //printf("buffer.size = %d\n", buffer.size()); printf("serverStatus.m_numDataStreamBytes = %d\n", serverStatus.m_numDataStreamBytes); } if (hasStatus) { b3AlignedObjectArray<unsigned char> packetData; unsigned char* statBytes = (unsigned char*)&serverStatus; if (cmdPtr->m_type == CMD_STEP_FORWARD_SIMULATION) { packetData.resize(4 + sizeof(int)); int sz = packetData.size(); int curPos = 0; MySerializeInt(sz, &packetData[curPos]); curPos += 4; for (int i = 0; i < sizeof(int); i++) { packetData[i + curPos] = statBytes[i]; } curPos += sizeof(int); pClient->Send( &packetData[0], packetData.size() ); } else { if (cmdPtr->m_type == CMD_REQUEST_VR_EVENTS_DATA) { int headerSize = 16+5 * sizeof(int) + sizeof(smUint64_t) + sizeof(char*) + sizeof(b3VRControllerEvent)*serverStatus.m_sendVREvents.m_numVRControllerEvents; packetData.resize(4 + headerSize); int sz = packetData.size(); int curPos = 0; MySerializeInt(sz, &packetData[curPos]); curPos += 4; for (int i = 0; i < headerSize; i++) { packetData[i + curPos] = statBytes[i]; } curPos += headerSize; pClient->Send(&packetData[0], packetData.size()); } else { //create packetData with [int packetSizeInBytes, status, streamBytes) packetData.resize(4 + sizeof(SharedMemoryStatus) + serverStatus.m_numDataStreamBytes); int sz = packetData.size(); int curPos = 0; if (gVerboseNetworkMessagesServer) { //printf("buffer.size = %d\n", buffer.size()); printf("serverStatus packed size = %d\n", sz); } MySerializeInt(sz, &packetData[curPos]); curPos += 4; for (int i = 0; i < sizeof(SharedMemoryStatus); i++) { packetData[i + curPos] = statBytes[i]; } curPos += sizeof(SharedMemoryStatus); for (int i = 0; i < serverStatus.m_numDataStreamBytes; i++) { packetData[i + curPos] = buffer[i]; } pClient->Send(&packetData[0], packetData.size()); } } } bytesReceived.clear(); } else { //likely an incomplete packet, let's append more bytes //printf("received packet with unknown contents\n"); } } } if (!receivedData) { //printf("Didn't receive data.\n"); } } printf("Disconnecting client.\n"); pClient->Close(); delete pClient; } } socket.Close(); socket.Shutdown(CSimpleSocket::Both); } else { printf("Error: cannot connect to shared memory physics server."); } delete sm; return 0; }
void CActiveSocket::NewL(RSocketServ& aSocketServ, RPointerArray<CActiveSocket>& aActiveSockets, Wap::TBearer aBearer, TWapMessageType aType, MProgressNotify* aNotify, const TSockAddr& aRemoteAddr, RConnection* aConnection) /** The static new function instanciates corresponding Bearers in terms of the input bearer type. This function is used by Fully specified Wap APIs which will open a socket with a single, named remote host. @internalComponent @released @since v8.0 @param aSocketServ the shared RSocketServ instance used in the Wap messaging API which owns this bearer @param aActiveSockets the bearer array used in the Wap messaging API which owns the bearer @param aBearer the bearer to listen on (use EAll for all bearers) @param aType the type of the wap message that will received @param aNotify the instance to be notified when a wap message is received @param aRemoteAddr the remote host to be communicate with @param aConnection the shared connection from Wap messaging API client */ { //Instanciate the corresponding switch(aBearer) { case Wap::ESMS7: case Wap::ESMS: case Wap::EWAPSMS7: case Wap::EWAPSMS: { CActiveSocket* me = new(ELeave) CActiveSocketSMS(aSocketServ, aNotify, aBearer, aRemoteAddr); CleanupStack::PushL(me); me->ConstructL(aType); aActiveSockets.AppendL(me); CleanupStack::Pop(me); break; } case Wap::EIP: { CActiveSocket* me = new(ELeave) CActiveSocketUDP(aSocketServ, aNotify, aBearer, aRemoteAddr, aConnection); CleanupStack::PushL(me); me->ConstructL(aType); aActiveSockets.AppendL(me); CleanupStack::Pop(me); break; } case Wap::EAll: { CActiveSocket* me = new(ELeave) CActiveSocketUDP(aSocketServ, aNotify, aBearer, aRemoteAddr, aConnection); CleanupStack::PushL(me); me->ConstructL(aType); CActiveSocket* me1 = new(ELeave) CActiveSocketSMS(aSocketServ, aNotify, aBearer, aRemoteAddr); CleanupStack::PushL(me1); me1->ConstructL(aType); aActiveSockets.ReserveL(2); // pre-allocate the memory aActiveSockets.AppendL(me1); CleanupStack::Pop(me1); aActiveSockets.AppendL(me); CleanupStack::Pop(me); break; } default: { OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CACTIVESOCKET_NEWL_1_1, "CActiveSocket::NewL Unknown Bearer Type"); User::Leave(Wap::EBearerError); } } }
void Close() { mysock->Close();//should do everything okay? }