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?
}
