BOOL cg_http_server_start(CgHttpServer *httpServer)
{
cg_log_debug_l4("Entering...\n");
if (httpServer->acceptThread != NULL)
return FALSE;
httpServer->acceptThread = cg_thread_new();
cg_thread_setaction(httpServer->acceptThread, cg_http_server_thread);
cg_thread_setuserdata(httpServer->acceptThread, httpServer);
/**** Thanks for Makela Aapo (10/31/05) ****/
httpServer->clientThreads = cg_threadlist_new();
if (cg_thread_start(httpServer->acceptThread) == FALSE) {
cg_thread_delete(httpServer->acceptThread);
httpServer->acceptThread = NULL;
/**** Thanks for Makela Aapo (10/31/05) ****/
cg_threadlist_delete(httpServer->clientThreads);
httpServer->clientThreads = NULL;
return FALSE;
}
cg_log_debug_l4("Leaving...\n");
return TRUE;
}
/**
* cg_upnp_device_advertiser_start
*
* Start the advertiser thread for the given device
*
* \param dev The device that is to be advertised
*/
BOOL cg_upnp_device_advertiser_start(CgUpnpDevice *dev)
{
CgThread *advertiser;
cg_log_debug_l4("Entering...\n");
/* Get the already existing (created in device_new) advertiser thread */
advertiser = cg_upnp_device_getadvertiserthead(dev);
/* Store the device into the advertiser thread struct's user data */
cg_thread_setuserdata(advertiser, dev);
/* Set the function that will run the thread */
cg_thread_setaction(advertiser, cg_upnp_device_advertiser_action);
/* Start the thread */
return cg_thread_start(advertiser);
cg_log_debug_l4("Leaving...\n");
}
BOOL cg_upnp_ssdp_server_start(CgUpnpSSDPServer *server)
{
if (server->recvThread != NULL)
return FALSE;
cg_log_debug_l4("Entering...\n");
server->recvThread = cg_thread_new();
cg_thread_setaction(server->recvThread, cg_upnp_ssdp_server_thread);
cg_thread_setuserdata(server->recvThread, server);
if (cg_thread_start(server->recvThread) == FALSE) {
cg_thread_delete(server->recvThread);
server->recvThread = NULL;
return FALSE;
}
return TRUE;
cg_log_debug_l4("Leaving...\n");
}
static void cg_http_server_thread(CgThread *thread)
{
CgHttpServer *httpServer;
CgThread *httpClientThread;
CgHttpServerClientData *clientData;
CgSocket *serverSock;
CgSocket *clientSock;
cg_log_debug_l4("Entering...\n");
httpServer = (CgHttpServer *)cg_thread_getuserdata(thread);
if (cg_http_server_isopened(httpServer) == FALSE)
return;
serverSock = httpServer->sock;
while (cg_thread_isrunnable(thread) == TRUE) {
clientSock = cg_socket_stream_new();
if (cg_socket_accept(serverSock, clientSock) == FALSE) {
cg_socket_delete(clientSock);
break;
}
cg_socket_settimeout(clientSock, cg_http_server_gettimeout(httpServer));
clientData = cg_http_server_clientdata_new(httpServer, clientSock);
httpClientThread = cg_thread_new();
cg_thread_setaction(httpClientThread, cg_http_server_clientthread);
cg_thread_setuserdata(httpClientThread, clientData);
/**** Thanks for Makela Aapo (10/31/05) ****/
cg_http_server_lock(httpServer);
cg_threadlist_add(httpServer->clientThreads, httpClientThread);
cg_http_server_unlock(httpServer);
cg_thread_start(httpClientThread);
}
cg_log_debug_l4("Leaving...\n");
}
/**
* Activate the control point. Starts listening for SSDP messages etc.
* You must call this function before you can actually use a control point.
*
* @param ctrlPoint The control point to start
*
* @return TRUE if successful; otherwise FALSE
*
*/
BOOL cg_upnp_controlpoint_start(CgUpnpControlPoint *ctrlPoint)
{
CgHttpServerList *httpServerList;
CG_HTTP_LISTENER httpListener;
int httpEventPort;
CgUpnpSSDPServerList *ssdpServerList;
CgUpnpSSDPResponseServerList *ssdpResServerList;
int ssdpResPort;
int ssdpMaxResPort;
cg_log_debug_l4("Entering...\n");
cg_upnp_controlpoint_stop(ctrlPoint);
/* Expiration handling */
cg_thread_start(ctrlPoint->expThread);
/**** Cache current interfaces ****/
cg_net_gethostinterfaces(ctrlPoint->ifCache);
/**** HTTP Server ****/
httpEventPort = cg_upnp_controlpoint_geteventport(ctrlPoint);
httpServerList = cg_upnp_controlpoint_gethttpserverlist(ctrlPoint);
/* Opening HTTP server may fail, so try many ports */
while(cg_http_serverlist_open(httpServerList, httpEventPort) == FALSE) {
cg_upnp_controlpoint_seteventport(ctrlPoint, httpEventPort + 1);
httpEventPort = cg_upnp_controlpoint_geteventport(ctrlPoint);
}
cg_http_serverlist_setuserdata(httpServerList, ctrlPoint);
httpListener = cg_upnp_controlpoint_gethttplistener(ctrlPoint);
if (httpListener == NULL)
httpListener = cg_upnp_controlpoint_httprequestreceived;
cg_http_serverlist_setlistener(httpServerList, httpListener);
cg_http_serverlist_start(httpServerList);
/**** SSDP Server ****/
ssdpServerList = cg_upnp_controlpoint_getssdpserverlist(ctrlPoint);
if (cg_upnp_ssdp_serverlist_open(ssdpServerList) == FALSE)
return FALSE;
cg_upnp_ssdp_serverlist_setlistener(ssdpServerList, cg_upnp_controlpoint_ssdplistner);
cg_upnp_ssdp_serverlist_setuserdata(ssdpServerList, ctrlPoint);
if (cg_upnp_ssdp_serverlist_start(ssdpServerList) == FALSE)
return FALSE;
/**** SSDP Response Server ****/
ssdpResPort = cg_upnp_controlpoint_getssdpresponseport(ctrlPoint);
/* below is the max SSDP Response port number to assign (rosfran.borges) */
ssdpMaxResPort = ssdpResPort + CG_UPNP_CONTROLPOINT_SSDP_RESPONSE_PORT_MAX_TRIES_INDEX;
ssdpResServerList = cg_upnp_controlpoint_getssdpresponseserverlist(ctrlPoint);
/* Opening SSDP response server may fail, so try many ports */
while(cg_upnp_ssdpresponse_serverlist_open(ssdpResServerList, ssdpResPort) == FALSE &&
(ssdpResPort < ssdpMaxResPort) ) {
cg_upnp_controlpoint_setssdpresponseport(ctrlPoint, ssdpResPort + 1);
ssdpResPort = cg_upnp_controlpoint_getssdpresponseport(ctrlPoint);
}
cg_upnp_ssdpresponse_serverlist_setlistener(ssdpResServerList, cg_upnp_controlpoint_ssdpresponselistner);
cg_upnp_ssdpresponse_serverlist_setuserdata(ssdpResServerList, ctrlPoint);
if (cg_upnp_ssdpresponse_serverlist_start(ssdpResServerList) == FALSE)
return FALSE;
cg_log_debug_l4("Leaving...\n");
return TRUE;
}
