XnStatus SyncSocketConnection::Connect()
{
if (IsConnected())
{
return XN_STATUS_OK;
}
XnStatus nRetVal = xnOSCreateSocket(XN_OS_TCP_SOCKET, m_strIP, m_nPort, &m_hSocket);
if (nRetVal != XN_STATUS_OK)
{
xnLogError(XN_MASK_SYNC_SOCKET, "Failed to create socket %s:%u: %s", m_strIP, m_nPort, xnGetStatusString(nRetVal));
m_hSocket = NULL;
return nRetVal;
}
nRetVal = xnOSConnectSocket(m_hSocket, CONNECT_TIMEOUT);
if (nRetVal != XN_STATUS_OK)
{
xnLogError(XN_MASK_SYNC_SOCKET, "Failed to connect socket %s:%u: %s", m_strIP, m_nPort, xnGetStatusString(nRetVal));
xnOSCloseSocket(m_hSocket);
m_hSocket = NULL;
return nRetVal;
}
return XN_STATUS_OK;
}
XnStatus ServerSocketInConnection::ConnectSocket(XN_SOCKET_HANDLE& hSocket, const XnChar* strIP, XnUInt16 nPort)
{
XnStatus nRetVal = XN_STATUS_OK;
(void)strIP; //Ignore IP parameter - accept connections from any IP.
XN_SOCKET_HANDLE hListenSocket = NULL;
nRetVal = xnOSCreateSocket(XN_OS_TCP_SOCKET, "0.0.0.0", nPort, &hListenSocket);
XN_IS_STATUS_OK_LOG_ERROR("Create data listen socket", nRetVal);
nRetVal = xnOSBindSocket(hListenSocket);
if (nRetVal != XN_STATUS_OK)
{
xnOSCloseSocket(hListenSocket);
XN_IS_STATUS_OK_LOG_ERROR("Bind data listen socket", nRetVal);
}
nRetVal = xnOSListenSocket(hListenSocket);
if (nRetVal != XN_STATUS_OK)
{
xnOSCloseSocket(hListenSocket);
XN_IS_STATUS_OK_LOG_ERROR("Listen to data socket", nRetVal);
}
xnLogVerbose(XN_MASK_SOCKETS, "Server accepting %s:%u...", strIP, nPort);
nRetVal = xnOSAcceptSocket(hListenSocket, &hSocket, XN_WAIT_INFINITE);
xnOSCloseSocket(hListenSocket);
XN_IS_STATUS_OK_LOG_ERROR("Accept data socket", nRetVal);
xnLogVerbose(XN_MASK_SOCKETS, "Server accepted connection on port %u", nPort);
return XN_STATUS_OK;
}
XnStatus ClientSocketInConnection::ConnectSocket(XN_SOCKET_HANDLE& hSocket, const XnChar* strIP, XnUInt16 nPort)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = xnOSCreateSocket(XN_OS_TCP_SOCKET, strIP, nPort, &hSocket);
XN_IS_STATUS_OK_LOG_ERROR("Create input socket", nRetVal);
xnLogVerbose(XN_MASK_SOCKETS, "Client connecting to %s:%u...", strIP, nPort);
nRetVal = xnOSConnectSocket(hSocket, CONNECT_TIMEOUT);
XN_IS_STATUS_OK_LOG_ERROR("Connect input socket", nRetVal);
xnLogVerbose(XN_MASK_SOCKETS, "Client connected to %s:%u", strIP, nPort);
return XN_STATUS_OK;
}
XnStatus XnSensorClient::CreateIOStreamImpl(const XnChar *strConnectionString, XnIOStream *&pStream)
{
XnStatus nRetVal = XN_STATUS_OK;
nRetVal = xnOSCreateSocket(XN_OS_TCP_SOCKET, XN_SENSOR_SERVER_IP_ADDRESS, XN_SENSOR_SERVER_PORT, &m_hSocket);
XN_IS_STATUS_OK(nRetVal);
// connect to server
XnUInt64 nStart;
xnOSGetTimeStamp(&nStart);
nRetVal = XN_STATUS_OS_NETWORK_TIMEOUT;
for (XnUInt32 nRetries = 0; (nRetries < XN_SENSOR_CLIENT_CONNECT_RETRIES) && (nRetVal != XN_STATUS_OK); nRetries++)
{
nRetVal = xnOSConnectSocket(m_hSocket, XN_SENSOR_CLIENT_WAIT_FOR_SERVER);
}
if (nRetVal == XN_STATUS_OS_NETWORK_TIMEOUT)
{
xnLogError(XN_MASK_SENSOR_CLIENT, "Got timeout waiting for server");
return nRetVal;
}
else if (nRetVal != XN_STATUS_OK)
{
xnLogError(XN_MASK_SENSOR_CLIENT, "Got an error trying to connect to server socket: %s", xnGetStatusString(nRetVal));
return nRetVal;
}
XnIONetworkStream *pNetworkStream = XN_NEW(XnIONetworkStream, m_hSocket);
if (pNetworkStream == NULL)
{
xnOSCloseSocket(m_hSocket);
return XN_STATUS_ALLOC_FAILED;
}
pNetworkStream->SetReadTimeout(XN_SENSOR_CLIENT_READ_TIMEOUT);
pStream = pNetworkStream;
// create outgoing data packer (incoming is created by base class)
m_pOutgoingPacker = XN_NEW(XnDataPacker, pNetworkStream, XN_SENSOR_SERVER_CONFIG_PACKER_SIZE);
if (m_pOutgoingPacker == NULL)
{
XN_DELETE(pNetworkStream);
xnOSCloseSocket(m_hSocket);
return XN_STATUS_ALLOC_FAILED;
}
nRetVal = m_pOutgoingPacker->Init();
if (nRetVal != XN_STATUS_OK)
{
XN_DELETE(pNetworkStream);
XN_DELETE(m_pOutgoingPacker);
xnOSCloseSocket(m_hSocket);
return nRetVal;
}
// send server a request to open the sensor
nRetVal = m_pOutgoingPacker->WriteCustomData(XN_SENSOR_SERVER_MESSAGE_OPEN_SENSOR, strConnectionString, strlen(strConnectionString) + 1);
if (nRetVal != XN_STATUS_OK)
{
XN_DELETE(pNetworkStream);
XN_DELETE(m_pOutgoingPacker);
xnOSCloseSocket(m_hSocket);
return nRetVal;
}
return (XN_STATUS_OK);
}
XnStatus XnSensorServer::InitServer()
{
XnStatus nRetVal = XN_STATUS_OK;
XnBool bEnableMultiUsers = FALSE;
XnUInt32 nValue;
if (XN_STATUS_OK == xnOSReadIntFromINI(m_strConfigFile, XN_SENSOR_SERVER_CONFIG_FILE_SECTION, XN_MODULE_PROPERTY_ENABLE_MULTI_USERS, &nValue))
{
bEnableMultiUsers = (nValue == TRUE);
}
nRetVal = xnOSCreateNamedMutexEx(&m_hServerRunningMutex, XN_SENSOR_SERVER_RUNNING_MUTEX_NAME, bEnableMultiUsers);
XN_IS_STATUS_OK(nRetVal);
XnAutoMutexLocker serverRunningLock(m_hServerRunningMutex, XN_SENSOR_SERVER_RUNNING_MUTEX_TIMEOUT);
nRetVal = serverRunningLock.GetStatus();
if (nRetVal != XN_STATUS_OK)
{
//This could mean there's another server/client that's frozen and they're jamming the mutex...
xnLogError(XN_MASK_SENSOR_SERVER, "Failed to lock server mutex: %s - exiting.", xnGetStatusString(nRetVal));
XN_ASSERT(FALSE);
return XN_STATUS_OS_MUTEX_TIMEOUT;
}
//From now on we're protected by m_hServerRunningMutex until we return from this function
/*Create the Server Running event.
This is created as a manual-reset event, because only the server resets it when it's shutting down. */
nRetVal = xnOSOpenNamedEventEx(&m_hServerRunningEvent, XN_SENSOR_SERVER_RUNNING_EVENT_NAME, bEnableMultiUsers);
if (nRetVal != XN_STATUS_OK)
{
nRetVal = xnOSCreateNamedEventEx(&m_hServerRunningEvent, XN_SENSOR_SERVER_RUNNING_EVENT_NAME, TRUE, bEnableMultiUsers);
XN_IS_STATUS_OK(nRetVal);
}
if (IsServerRunning())
{
//Another server is already running.
xnLogInfo(XN_MASK_SENSOR_SERVER, "Detected another server running - exiting.");
xnOSCloseEvent(&m_hServerRunningEvent);
m_hServerRunningEvent = NULL;
return XN_STATUS_DEVICE_SERVER_ALREADY_RUNNING;
}
nRetVal = m_sensorsManager.Init();
XN_IS_STATUS_OK(nRetVal);
// init network
nRetVal = xnOSInitNetwork();
XN_IS_STATUS_OK(nRetVal);
// create lock
nRetVal = xnOSCreateCriticalSection(&m_hSessionsLock);
XN_IS_STATUS_OK(nRetVal);
// create the listen socket
nRetVal = xnOSCreateSocket(XN_OS_TCP_SOCKET, XN_SENSOR_SERVER_IP_ADDRESS, XN_SENSOR_SERVER_PORT, &m_hListenSocket);
XN_IS_STATUS_OK(nRetVal);
// bind it
nRetVal = xnOSBindSocket(m_hListenSocket);
XN_IS_STATUS_OK(nRetVal);
// start listening
nRetVal = xnOSListenSocket(m_hListenSocket);
XN_IS_STATUS_OK(nRetVal);
xnLogVerbose(XN_MASK_SENSOR_SERVER, "Server is now listening");
/*Set the event to signal that the server is ready for requests. We do this AFTER we start listening so
the clients can wait on the event and then connect to the server socket. */
nRetVal = xnOSSetEvent(m_hServerRunningEvent);
XN_IS_STATUS_OK(nRetVal);
xnOSGetTimeStamp(&m_nLastSessionActivity);
return (XN_STATUS_OK);
}
