/*----------------------------------------------------------------------*
rtp_net_getifaceaddr
*----------------------------------------------------------------------*/
int rtp_net_getifaceaddr (unsigned char *localAddr, unsigned char *remoteAddr,
int remotePort, int remoteType)
{
RTP_SOCKET tempSock;
int localPort;
int localType;
if (rtp_net_socket_datagram(&tempSock) >= 0)
{
/* determine the local IP address that is receiving this request by
creating a temporary UDP socket and connecting it back to the
sender; we then query the IP address of the temp socket using
getsockname. */
if (rtp_net_connect(tempSock, remoteAddr, remotePort, remoteType) >= 0)
{
if (rtp_net_getsockname(tempSock, localAddr, &localPort, &localType) >= 0)
{
rtp_net_closesocket(tempSock);
return (0);
}
}
rtp_net_closesocket(tempSock);
}
return (-1);
}
void rtsmb_srv_net_shutdown (void)
{
if (rtp_net_closesocket((RTP_SOCKET) net_nsSock))
{
RTSMB_DEBUG_OUTPUT_STR("ERROR IN CLOSESOCKET\n", RTSMB_DEBUG_TYPE_ASCII);
}
if (rtp_net_closesocket((RTP_SOCKET) net_ssnSock))
{
RTSMB_DEBUG_OUTPUT_STR("ERROR IN CLOSESOCKET\n", RTSMB_DEBUG_TYPE_ASCII);
}
rtsmb_srv_net_thread_close (mainThread);
}
void SSDP_ServerDestroy (
SSDPServerContext *ctx /** pointer to SSDP context */
)
{
rtp_strfree(ctx->serverName);
rtp_net_closesocket(ctx->announceSocket);
}
/** @memo Destroy an HTTP Managed Server instance.
@doc This function must be called to release sockets, semaphores and treads
owned by this instance of the server. This function does not de-allocate the
HTTPServerContext or the server's connectCtxArray, that must be done explicitly.
@see HTTP_ServerInit
@return nothing
*/
void HTTP_ServerDestroy (
HTTPServerContext* server, /** Pointer to structure that was initialized by HTTP_ServerInit */
HTTPServerConnection** connectCtxArray /** The server's contextArray is returned in the variable. Call rtp_free() to release it.*/
)
{
rtp_net_closesocket(server->serverSocket);
#ifdef HTTP_SERVER_MULTITHREAD
{
RTP_MUTEX helperThreadMutex;
RTP_SEMAPHORE helperThreadSemaphore;
if (connectCtxArray)
{
*connectCtxArray = server->connectionContextArray;
}
rtp_sig_mutex_free(server->lock);
rtp_helper_thread_ctx_destroy (
&server->helperContext,
&helperThreadMutex,
&helperThreadSemaphore
);
rtp_sig_mutex_free(helperThreadMutex);
rtp_sig_semaphore_free(helperThreadSemaphore);
}
#endif /* HTTP_SERVER_MULTITHREAD */
rtp_memset((unsigned char *) server, 0, sizeof(HTTPServerContext));
}
int RTIP_SOCKETS_Driver::Close(SOCK_SOCKET socket)
{
NATIVE_PROFILE_PAL_NETWORK();
int ret;
ret = rtp_net_closesocket((RTP_HANDLE) socket);
return ret;
}
/*---------------------------------------------------------------------------*/
int HTTP_ServerConnectionClose (HTTPServerRequestContext *ctx,
HTTPSession *session)
{
if (!ctx->connectionClosed)
{
ctx->connectionClosed = 1;
rtp_net_closesocket(ctx->socketHandle);
}
return (0);
}
/*---------------------------------------------------------------------------*/
int HTTP_ClientSessionClose (
HTTPClientSession* clientSession
)
{
if (clientSession->socketOpen)
{
clientSession->socketOpen = 0;
return (rtp_net_closesocket(clientSession->netSock));
}
return (-1);
}
RTSMB_STATIC PNET_SESSIONCTX rtsmb_srv_net_connection_open (PNET_THREAD pThread)
{
PNET_SESSIONCTX pNetCtx;
RTP_SOCKET sock;
unsigned char clientAddr[4];
int clientPort;
int ipVersion;
/**
* Move connection to a shiny new port and socket.
*/
RTSMB_DEBUG_OUTPUT_STR("about to accept\n", RTSMB_DEBUG_TYPE_ASCII);
if (rtp_net_accept ((RTP_SOCKET *) &sock,(RTP_SOCKET) net_ssnSock, clientAddr, &clientPort, &ipVersion) < 0)
{
RTSMB_DEBUG_OUTPUT_STR("rtsmb_srv_net_connection_open: accept error\n", RTSMB_DEBUG_TYPE_ASCII);
return (PNET_SESSIONCTX)0;
}
pNetCtx = allocateSession();
RTSMB_DEBUG_OUTPUT_STR("allocateSession back\n", RTSMB_DEBUG_TYPE_ASCII);
if(pNetCtx)
{
pNetCtx->sock = sock;
RTSMB_DEBUG_OUTPUT_STR("SMBS_InitSessionCtx\n", RTSMB_DEBUG_TYPE_ASCII);
pNetCtx->lastActivity = rtp_get_system_msec ();
SMBS_InitSessionCtx(&(pNetCtx->smbCtx), pNetCtx->sock);
RTSMB_DEBUG_OUTPUT_STR("Back SMBS_InitSessionCtx\n", RTSMB_DEBUG_TYPE_ASCII);
SMBS_SetBuffers (&pNetCtx->smbCtx, pThread->inBuffer, prtsmb_srv_ctx->small_buffer_size, pThread->outBuffer, prtsmb_srv_ctx->small_buffer_size, pThread->tmpBuffer, prtsmb_srv_ctx->small_buffer_size);
RTSMB_DEBUG_OUTPUT_STR ("rtsmb_srv_net_connection_open: socket ", RTSMB_DEBUG_TYPE_ASCII);
RTSMB_DEBUG_OUTPUT_DINT (pNetCtx->sock);
RTSMB_DEBUG_OUTPUT_STR (" opened\n", RTSMB_DEBUG_TYPE_ASCII);
return pNetCtx;
}
else
{
RTSMB_DEBUG_OUTPUT_STR("rtsmb_srv_net_connection_open: No free sessions\n", RTSMB_DEBUG_TYPE_ASCII);
/* let them know we are rejecting their request */
rtsmb_srv_nbss_send_session_response (sock, FALSE);
if (rtp_net_closesocket((RTP_SOCKET) sock))
{
RTSMB_DEBUG_OUTPUT_STR("ERROR IN CLOSESOCKET\n", RTSMB_DEBUG_TYPE_ASCII);
}
return (PNET_SESSIONCTX)0;
}
}
/** @memo Wait for a client to connect and process one request.
@doc This function must be called to serve content. It processes one HTTP POST, PUT or GET request and then
returs. In a multithreaded environment a background thread may be created that just calls this function continuously.
A singlethreaded application must call this function from the main loop of the program.
@return 0 if a request was process, negative if it timed out or failed.
*/
int HTTP_ServerProcessOneRequest (HTTPServerContext *server, /** Pointer to structure that was initialized by HTTP_ServerInit */
HTTP_INT32 timeoutMsec) /** Time to wait for a connection, 0 is forever */
{
RTP_SOCKET sockHandle;
RTP_NET_ADDR clientAddr;
int result = -1;
if (rtp_net_read_select(server->serverSocket, timeoutMsec) < 0)
{
return (result);
}
if (rtp_net_accept(&sockHandle, server->serverSocket, clientAddr.ipAddr, &clientAddr.port, &clientAddr.type) < 0)
{
return (result);
}
#ifdef HTTP_SERVER_MULTITHREAD
{
HTTPServerConnection* connectionCtx = server->jobFreeList;
if (connectionCtx)
{
server->jobFreeList = (HTTPServerConnection*) connectionCtx->job.next;
connectionCtx->clientAddr = clientAddr;
connectionCtx->socket = sockHandle;
if (rtp_helper_thread_queue_job(&server->helperContext, &connectionCtx->job) >= 0)
{
rtp_helper_thread_start_cond(&server->helperContext, server->maxHelperThreads);
}
result = 0;
}
else
{
result = -1;
/* do a hard close */
rtp_net_setlinger(sockHandle, 1, 0);
rtp_net_closesocket(sockHandle);
}
}
#else /* HTTP_SERVER_SINGLETHREAD */
result = HTTP_ServerProcessOneConnection(server, sockHandle, &clientAddr);
#endif /* HTTP_SERVER_MULTITHREAD */
return (result);
}
RTSMB_STATIC void rtsmb_srv_net_connection_close (PNET_SESSIONCTX pSCtx )
{
RTSMB_DEBUG_OUTPUT_STR ("CloseConnection: socket ", RTSMB_DEBUG_TYPE_ASCII);
RTSMB_DEBUG_OUTPUT_DINT (pSCtx->sock);
RTSMB_DEBUG_OUTPUT_STR (" closed\n", RTSMB_DEBUG_TYPE_ASCII);
SMBS_CloseSession( &(pSCtx->smbCtx) );
/* kill conection */
if (rtp_net_closesocket((RTP_SOCKET) pSCtx->sock))
{
RTSMB_DEBUG_OUTPUT_STR("ERROR IN CLOSESOCKET\n", RTSMB_DEBUG_TYPE_ASCII);
}
freeSession (pSCtx);
}
/*---------------------------------------------------------------------------*/
int HTTP_ClientSessionOpenAddr (
HTTPClientSession* clientSession,
RTP_NET_ADDR* addr,
unsigned blocking,
HTTP_INT32 timeoutMsec
)
{
clientSession->netAddr = *addr;
if (rtp_net_socket_stream_dual (&clientSession->netSock, addr->type) >= 0)
{
/* attempt to put the socket into non-blocking mode */
rtp_net_setblocking (clientSession->netSock, blocking);
clientSession->socketOpen = 1;
/* bind to any IP address (of the same type as the server) and port */
if (rtp_net_bind_dual (clientSession->netSock,
RTP_NET_STREAM,
0 /* addr = ANY */,
0 /* port = ANY*/,
clientSession->netAddr.type) >= 0)
{
int connectResult;
connectResult = rtp_net_connect_dual (clientSession->netSock,
RTP_NET_STREAM,
clientSession->netAddr.ipAddr,
clientSession->netAddr.port,
clientSession->netAddr.type);
if (connectResult == -2 /* EWOULDBLOCK */ ||
connectResult == 0)
{
return (0);
}
}
clientSession->socketOpen = 0;
rtp_net_closesocket(clientSession->netSock);
}
return (-1);
}
/*---------------------------------------------------------------------------*/
int HTTP_ServerProcessOneConnection (HTTPServerContext *server,
RTP_SOCKET sockHandle,
RTP_NET_ADDR *clientAddr)
{
RtpNetSockStruct s;
HTTPRequest request;
HTTPSession session;
int result;
HTTP_UINT8 tempBuffer[1024];
HTTP_INT32 tempBufferSize = 1024;
int requestProcessed = 0;
HTTPServerPath *serverPath;
HTTP_INT32 len;
HTTPServerRequestContext ctx;
s.sockHandle = sockHandle;
_HTTP_ServerInitRequestContext(server, &ctx);
ctx.socketHandle = sockHandle;
s.serverKeepAlive = 0;
s.keepAlive = 0;
/* create an HTTP session */
result = HTTP_InitSession (&session,
RtpNetSockReadFn,
RtpNetSockWriteFn,
&s);
HTTP_SetWriteBufferSize(&session, 1452);
if (result < 0)
{
/* Server error */
_HTTP_ServerSendError (&ctx, &session, 500, "Internal Server Error");
HTTP_FreeSession(&session);
rtp_net_closesocket(s.sockHandle);
return (-1);
}
/* validate the client by network address */
if (_HTTP_ServerValidateClient(server, clientAddr) < 0)
{
_HTTP_ServerSendError (&ctx, &session, 403, "Forbidden");
HTTP_FreeSession(&session);
rtp_net_closesocket(s.sockHandle);
return (-1);
}
/* Read the request */
len = HTTP_ReadRequest(&session, &request, tempBuffer, tempBufferSize);
if (len < 0)
{
/* Bad request */
_HTTP_ServerSendError (&ctx, &session, 400, "Bad Request");
HTTP_FreeSession(&session);
rtp_net_closesocket(s.sockHandle);
return (-1);
}
serverPath = _HTTP_ServerFindMatchingPath(server, request.target);
if (serverPath)
{
switch (serverPath->fn(serverPath->userData, &ctx, &session, &request, clientAddr))
{
case HTTP_REQUEST_STATUS_DONE:
requestProcessed = 1;
break;
case HTTP_REQUEST_STATUS_CONTINUE:
break;
}
}
if (!requestProcessed)
{
_HTTP_ServerHandleRequest(&ctx, &session, &request, clientAddr);
}
HTTP_FreeSession(&session);
if (!ctx.connectionClosed)
{
/* tbd - add support for connection keep-alive */
rtp_net_closesocket(s.sockHandle);
}
return (0);
}
int HTTP_ServerInit (HTTPServerContext *server, /** pointer to uninitialized \Ref{HTTPServerContext} struct */
const HTTP_CHAR *name, /** Server name. Sent in HTTP header. */
const HTTP_CHAR *rootDir, /** Path to the root directory for content. */
const HTTP_CHAR *defaultFile, /** Default Filename if "\" or "path\" is passed with no file name. */
HTTP_INT8 httpMajorVersion, /** Normally 1 for HTTP 1.1 */
HTTP_INT8 httpMinorVersion, /** Normally 1 for HTTP 1.1 */
HTTP_UINT8 *ipAddr, /** V4/V6 examples: ipaddr[4] = {192, 168, 0, 6}; ipAddr = "fe80::20b:dbff:fe2f:c162"; */
HTTP_INT16 port, /** port number (80) usually */
HTTP_INT16 ipType, /** ipversion 4 or 6 */
HTTP_BOOL allowKeepAlive, /** If HTTP version < 1.1 enables keep-alive support. For 1,1 and greater keep-alive is the default.*/
HTTPServerConnection* connectCtxArray, /** pointer to uninitialized bytes, must be (sizeof(HTTPServerConnection) * maxConnections)) bytes. */
HTTP_INT16 maxConnections, /** The maximum limit on simultaneous HTTP server connections */
HTTP_INT16 maxHelperThreads /** If HTTP_SERVER_MULTITHREAD is defined, the max number of helper threads to spawn */
)
{
rtp_memset((unsigned char *) server, 0, sizeof(HTTPServerContext));
if (rtp_net_socket_stream_dual(&server->serverSocket, ipType) >= 0)
{
if (rtp_net_bind_dual(server->serverSocket, RTP_NET_STREAM, ipAddr, port, ipType) >= 0 &&
rtp_net_listen(server->serverSocket, maxConnections) >= 0)
{
if (!ipAddr)
{
if (rtp_net_getsockname(server->serverSocket, server->serverAddress.ipAddr,
&server->serverAddress.port, &server->serverAddress.type) < 0)
{
rtp_memset(server->serverAddress.ipAddr, 0, RTP_NET_IP_ALEN);
}
}
else
{
rtp_memcpy(server->serverAddress.ipAddr, ipAddr, RTP_NET_IP_ALEN);
server->serverAddress.port = port;
}
if (name)
{
rtp_strncpy(server->serverName, name, HTTP_SERVER_NAME_LEN-1);
}
else
{
rtp_strncpy(server->serverName, HTTP_SERVER_NAME_STRING, HTTP_SERVER_NAME_LEN-1);
}
server->httpMajorVersion = httpMajorVersion;
server->httpMinorVersion = httpMinorVersion;
if (rootDir)
{
rtp_strncpy(server->rootDir, rootDir, HTTP_SERVER_PATH_LEN-1);
}
else
{
/* default to the current working directory */
server->rootDir[0] = '.';
server->rootDir[1] = 0;
}
if (defaultFile)
{
rtp_strncpy(server->defaultFile, defaultFile, HTTP_SERVER_DEFAULT_FILE_LEN-1);
}
else
{
rtp_strncpy(server->defaultFile, HTTP_SERVER_DEFAULT_FILE, HTTP_SERVER_DEFAULT_FILE_LEN-1);
}
if (!allowKeepAlive ||
(server->httpMajorVersion == 1 && server->httpMinorVersion > 0) ||
(server->httpMajorVersion > 1))
{
server->allowKeepAlive = allowKeepAlive;
server->maxConnections = maxConnections;
DLLIST_INIT(&server->pathList);
DLLIST_INIT(&server->realmList);
server->allowedClientList = 0;
server->numAllowedClients = 0;
server->blockedClientList = 0;
server->numBlockedClients = 0;
#ifdef HTTP_SERVER_KEEP_ALIVE
DLLIST_INIT(&server->openConnections);
#endif /* HTTP_SERVER_KEEP_ALIVE */
#ifdef HTTP_SERVER_MULTITHREAD
server->connectionContextArray = connectCtxArray;
server->maxHelperThreads = maxHelperThreads;
/* allocate the server lock */
if (rtp_sig_mutex_alloc(&server->lock, 0) >= 0)
{
RTP_MUTEX helperThreadMutex;
RTP_SEMAPHORE helperThreadSemaphore;
/* initialize the session queue */
if (rtp_sig_mutex_alloc(&helperThreadMutex, 0) >= 0)
{
if (rtp_sig_semaphore_alloc(&helperThreadSemaphore, 0) >= 0)
{
if (rtp_helper_thread_ctx_init (
&server->helperContext,
helperThreadMutex,
helperThreadSemaphore
) >= 0)
{
int n;
// initialize the free job list
server->jobFreeList = connectCtxArray;
for (n = 0; n < maxConnections-1; n++)
{
connectCtxArray[n].job.next = &(connectCtxArray[n+1].job);
connectCtxArray[n].job.execute = _HTTP_ServerExecuteJob;
connectCtxArray[n].server = server;
}
connectCtxArray[n].job.next = 0;
connectCtxArray[n].job.execute = _HTTP_ServerExecuteJob;
connectCtxArray[n].server = server;
server->status = HTTP_SERVER_INITIALIZED;
return (0);
}
rtp_sig_semaphore_free(helperThreadSemaphore);
}
rtp_sig_mutex_free(helperThreadMutex);
}
rtp_sig_mutex_free(server->lock);
}
#else /* HTTP_SERVER_MULTITHREAD */
//server->queueFirst = 0;
//server->queueLast = 0;
server->status = HTTP_SERVER_INITIALIZED;
return (0);
#endif /* HTTP_SERVER_MULTITHREAD */
}
}
rtp_net_closesocket(server->serverSocket);
}
return (-1);
}
