/** @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 rtp_queue_free (RTPMessageQueue *queue)
{
rtp_sig_mutex_free(queue->lock);
rtp_sig_semaphore_free(queue->sem);
return (0);
}
/*---------------------------------------------------------------------------*/
int rtp_timer_init (void)
{
if (rtpTimerInitialized == 0)
{
if (rtp_sig_mutex_alloc(&rtpTimerLock, 0) >= 0)
{
if (rtp_sig_semaphore_alloc(&rtpTimerSignal, 0) >= 0)
{
RTP_THREAD newThread;
DLLIST_INIT(&rtpTimerNewList);
DLLIST_INIT(&rtpTimerActiveList);
rtpTimerNextToProcess = 0;
if (rtp_thread_spawn (&newThread,
_rtp_timer_thread,
0,
0,
2,
0) >= 0)
{
rtpTimerInitialized = 1;
return (0);
}
rtp_sig_semaphore_free(rtpTimerSignal);
}
else
{
rtp_printf("rtp_timer_init - rtp_sig_semaphore_alloc failed!\n");
}
rtp_sig_mutex_free(rtpTimerLock);
}
else
{
rtp_printf("rtp_timer_init - rtp_sig_mutex_alloc failed!");
}
return (-1);
}
rtpTimerInitialized++;
return (0);
}
/*---------------------------------------------------------------------------*/
int rtp_queue_init (RTPMessageQueue *queue, int queueSize, long msgSize, void *messages)
{
tc_memset(queue, 0, sizeof(RTPMessageQueue));
if (rtp_sig_mutex_alloc(&queue->lock, 0) < 0)
{
return (-1);
}
if (rtp_sig_semaphore_alloc(&queue->sem, 0) < 0)
{
rtp_sig_mutex_free(queue->lock);
return (-1);
}
queue->queueSize = queueSize;
queue->msgSize = msgSize;
queue->first = 0;
queue->last = 0;
queue->messages = messages;
return (0);
}
int rtsmb_client_config(void)
{
int i, j;
if (rtsmb_client_config_initialized)
{
return 1;
}
#if ALLOC_FROM_HEAP
else
{
RTSMB_CLI_SESSION * sessions = safemalloc(sizeof(RTSMB_CLI_SESSION ) * CFG_RTSMB_CLI_MAX_SESSIONS);
RTSMB_CLI_SESSION_JOB * jobs = safemalloc(sizeof(RTSMB_CLI_SESSION_JOB ) * CFG_RTSMB_CLI_MAX_SESSIONS * CFG_RTSMB_CLI_MAX_JOBS_PER_SESSION);
RTSMB_CLI_SESSION_SHARE * shares = safemalloc(sizeof(RTSMB_CLI_SESSION_SHARE ) * CFG_RTSMB_CLI_MAX_SESSIONS * CFG_RTSMB_CLI_MAX_SHARES_PER_SESSION);
RTSMB_CLI_SESSION_FID * fids = safemalloc(sizeof(RTSMB_CLI_SESSION_FID ) * CFG_RTSMB_CLI_MAX_SESSIONS * CFG_RTSMB_CLI_MAX_FIDS_PER_SESSION);
RTSMB_CLI_SESSION_SEARCH * searches = safemalloc(sizeof(RTSMB_CLI_SESSION_SEARCH ) * CFG_RTSMB_CLI_MAX_SESSIONS * CFG_RTSMB_CLI_MAX_SEARCHES_PER_SESSION);
RTSMB_CLI_SESSION_SSTAT * share_search_stats = safemalloc(sizeof(RTSMB_CLI_SESSION_SSTAT ) * CFG_RTSMB_CLI_MAX_SESSIONS * CFG_RTSMB_CLI_MAX_SHARES_PER_SEARCH);
RTSMB_CLI_SESSION_DSTAT * file_search_stats = safemalloc(sizeof(RTSMB_CLI_SESSION_DSTAT ) * CFG_RTSMB_CLI_MAX_SESSIONS * CFG_RTSMB_CLI_MAX_SEARCHES_PER_SESSION * CFG_RTSMB_CLI_MAX_FILES_PER_SEARCH);
byte * wire_temp_buffers = safemalloc(sizeof(byte ) * CFG_RTSMB_CLI_MAX_SESSIONS * CFG_RTSMB_CLI_BUFFER_SIZE);
RTSMB_CLI_WIRE_BUFFER * wire_buffers = safemalloc(sizeof(RTSMB_CLI_WIRE_BUFFER ) * CFG_RTSMB_CLI_MAX_SESSIONS * CFG_RTSMB_CLI_MAX_BUFFERS_PER_WIRE);
byte * wire_buffer_buffers = safemalloc(sizeof(byte ) * CFG_RTSMB_CLI_MAX_SESSIONS * CFG_RTSMB_CLI_MAX_BUFFERS_PER_WIRE * CFG_RTSMB_CLI_BUFFER_SIZE);
RTSMB_CLI_SESSION_SERVER_SEARCH * server_search_results = safemalloc(sizeof(RTSMB_CLI_SESSION_SERVER_SEARCH) * CFG_RTSMB_CLI_MAX_SERVER_SEARCHES);
BBOOL * server_search_in_use = safemalloc(sizeof(BBOOL ) * CFG_RTSMB_CLI_MAX_SERVER_SEARCHES);
RTSMB_CHAR16 * server_search_names = safemalloc(sizeof(RTSMB_CHAR16 ) * CFG_RTSMB_CLI_MAX_SERVER_SEARCHES * CFG_RTSMB_CLI_MAX_SERVERS_PER_SEARCH * RTSMB_NB_NAME_SIZE);
#if (INCLUDE_RTSMB_CLIENT_EZ)
RTSMB_CLI_EZ_SEARCH * ez_share_searches = safemalloc(sizeof(RTSMB_CLI_EZ_SEARCH ) * CFG_RTSMB_CLI_MAX_SESSIONS);
RTSMB_CLI_EZ_SEARCH * ez_server_searches = safemalloc(sizeof(RTSMB_CLI_EZ_SEARCH ) * CFG_RTSMB_CLI_MAX_SERVER_SEARCHES);
RTSMB_CLI_SESSION_SRVSTAT * ez_server_stats = safemalloc(sizeof(RTSMB_CLI_SESSION_SRVSTAT ) * CFG_RTSMB_CLI_MAX_SERVER_SEARCHES);
RTSMB_CLI_EZ_THREAD * ez_threads = safemalloc(sizeof(RTSMB_CLI_EZ_THREAD ) * CFG_RTSMB_CLI_MAX_SUPPORTED_THREADS);
#endif
}
#endif
#ifdef INCLUDE_RTSMB_THREADSAFE
if (rtp_sig_mutex_alloc((RTP_MUTEX *) &prtsmb_cli_ctx->sessions_mutex, 0) < 0)
{
return 0;
}
if (rtp_sig_mutex_alloc((RTP_MUTEX *) &prtsmb_cli_ctx->server_search_mutex, 0) < 0)
{
rtp_sig_mutex_free(prtsmb_cli_ctx->sessions_mutex);
return 0;
}
#if (INCLUDE_RTSMB_CLIENT_EZ)
if (rtp_sig_mutex_alloc((RTP_MUTEX *) &prtsmb_cli_ctx->ez_threads_mutex, 0) < 0)
{
rtp_sig_mutex_free(prtsmb_cli_ctx->server_search_mutex);
rtp_sig_mutex_free(prtsmb_cli_ctx->sessions_mutex);
return 0;
}
#endif
#endif /* INCLUDE_RTSMB_THREADSAFE */
prtsmb_cli_ctx->max_sessions = CFG_RTSMB_CLI_MAX_SESSIONS;
prtsmb_cli_ctx->max_searches_per_session = CFG_RTSMB_CLI_MAX_SEARCHES_PER_SESSION;
prtsmb_cli_ctx->max_fids_per_session = CFG_RTSMB_CLI_MAX_FIDS_PER_SESSION;
prtsmb_cli_ctx->max_shares_per_session = CFG_RTSMB_CLI_MAX_SHARES_PER_SESSION;
prtsmb_cli_ctx->max_jobs_per_session = CFG_RTSMB_CLI_MAX_JOBS_PER_SESSION;
prtsmb_cli_ctx->max_buffers_per_wire = CFG_RTSMB_CLI_MAX_BUFFERS_PER_WIRE;
prtsmb_cli_ctx->buffer_size = CFG_RTSMB_CLI_BUFFER_SIZE;
prtsmb_cli_ctx->max_shares_per_search = CFG_RTSMB_CLI_MAX_SHARES_PER_SEARCH;
prtsmb_cli_ctx->max_server_searches = CFG_RTSMB_CLI_MAX_SERVER_SEARCHES;
prtsmb_cli_ctx->max_servers_per_search = CFG_RTSMB_CLI_MAX_SERVERS_PER_SEARCH;
prtsmb_cli_ctx->max_files_per_search = CFG_RTSMB_CLI_MAX_FILES_PER_SEARCH;
prtsmb_cli_ctx->max_supported_threads = CFG_RTSMB_CLI_MAX_SUPPORTED_THREADS;
prtsmb_cli_ctx->sessions = sessions;
prtsmb_cli_ctx->server_search_results = server_search_results;
prtsmb_cli_ctx->server_search_in_use = server_search_in_use;
#if (INCLUDE_RTSMB_CLIENT_EZ)
prtsmb_cli_ctx->ez_share_searches = ez_share_searches;
prtsmb_cli_ctx->ez_server_searches = ez_server_searches;
prtsmb_cli_ctx->ez_server_stats = ez_server_stats;
prtsmb_cli_ctx->ez_threads = ez_threads;
#endif
#if (INCLUDE_RTSMB_CLIENT_EZ)
for (i = 0; i < prtsmb_cli_ctx->max_supported_threads; i++)
{
prtsmb_cli_ctx->ez_threads[i].in_use = FALSE;
}
#endif
for (i = 0; i < prtsmb_cli_ctx->max_server_searches; i++)
{
#if (INCLUDE_RTSMB_CLIENT_EZ)
prtsmb_cli_ctx->ez_server_stats[i].sid = -1;
#endif
prtsmb_cli_ctx->server_search_results[i].srvstats = &server_search_names[i * prtsmb_cli_ctx->max_servers_per_search * RTSMB_NB_NAME_SIZE];
}
for (i = 0; i < prtsmb_cli_ctx->max_sessions; i++)
{
sessions[i].state = CSSN_STATE_UNUSED;
sessions[i].jobs = &jobs [i * prtsmb_cli_ctx->max_jobs_per_session];
sessions[i].shares = &shares [i * prtsmb_cli_ctx->max_shares_per_session];
sessions[i].fids = &fids [i * prtsmb_cli_ctx->max_fids_per_session];
sessions[i].searches = &searches [i * prtsmb_cli_ctx->max_searches_per_session];
sessions[i].wire.temp_buffer = &wire_temp_buffers [(dword)i * prtsmb_cli_ctx->buffer_size];
sessions[i].wire.buffers = &wire_buffers [i * prtsmb_cli_ctx->max_buffers_per_wire];
/* default to TCP over ethernet payload size */
sessions[i].wire.physical_packet_size = 1460;
sessions[i].share_search.sstats = &share_search_stats [i * prtsmb_cli_ctx->max_shares_per_search];
for (j = 0; j < prtsmb_cli_ctx->max_buffers_per_wire; j++)
{
sessions[i].wire.buffers[j].buffer = &wire_buffer_buffers [(dword)(i * prtsmb_cli_ctx->max_buffers_per_wire + j) * prtsmb_cli_ctx->buffer_size];
}
for (j = 0; j < prtsmb_cli_ctx->max_searches_per_session; j++)
{
sessions[i].searches[j].dstats = &file_search_stats [(i * prtsmb_cli_ctx->max_searches_per_session + j) * prtsmb_cli_ctx->max_files_per_search];
}
}
rtsmb_client_config_initialized = 1;
return 1;
}
int FreeMutex(wolfSSL_Mutex* m)
{
rtp_sig_mutex_free(*m);
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);
}
