static void cg_upnp_ssdp_server_thread(CgThread *thread)
{
CgUpnpSSDPServer *server;
CgUpnpSSDPPacket *ssdpPkt;
void *userData;
cg_log_debug_l4("Entering...\n");
server = (CgUpnpSSDPServer *)cg_thread_getuserdata(thread);
userData = cg_upnp_ssdp_server_getuserdata(server);
if (cg_upnp_ssdp_server_isopened(server) == FALSE)
return;
ssdpPkt = cg_upnp_ssdp_packet_new();
cg_upnp_ssdp_packet_setuserdata(ssdpPkt, userData);
while (cg_thread_isrunnable(thread) == TRUE) {
if (cg_upnp_httpmu_socket_recv(server->httpmuSock, ssdpPkt) <= 0)
break;
cg_upnp_ssdp_server_performlistener(server, ssdpPkt);
cg_upnp_ssdp_packet_clear(ssdpPkt);
}
cg_upnp_ssdp_packet_delete(ssdpPkt);
cg_log_debug_l4("Leaving...\n");
}
/**
* cg_upnp_device_advertiser_isrunning
*
* Check if the advertiser has been started
*
* \param dev Device that is being advertised
*/
BOOL cg_upnp_device_advertiser_isrunning(CgUpnpDevice *dev)
{
CgThread *advertiser;
cg_log_debug_l4("Entering...\n");
advertiser = cg_upnp_device_getadvertiserthead(dev);
if (advertiser != NULL)
return cg_thread_isrunnable(advertiser);
return FALSE;
}
static int cg_http_request_progress_callback(void *ptr, double dltotal, double dlnow, double ultotal, double ulnow)
{
CgThread *self = cg_thread_self();
cg_log_debug_s("Curl call progressing... Got thread %p\n", self);
if ( ( NULL != self ) && !cg_thread_isrunnable(self))
{
cg_log_debug_s("Thread is not runnable anymore! Informing libcurl to abort\n");
return TRUE;
}
return FALSE;
}
/**
* cg_upnp_device_advertiser_action
*
* Function run as a UPnP device advertisement
* thread.
*
* \param thread The thread context that this function is running in
*/
static void cg_upnp_device_advertiser_action(CgThread *thread)
{
CgUpnpDevice *dev;
CgTime leaseTime;
CgTime notifyInterval;
cg_log_debug_l4("Entering...\n");
/**
* Get the device struct that this function is advertising.
*/
dev = (CgUpnpDevice *)cg_thread_getuserdata(thread);
/**
* Lease time
*/
leaseTime = cg_upnp_device_getleasetime(dev);
/* Run this thread until it is stopped from outside */
while ( cg_thread_isrunnable(thread) == TRUE )
{
notifyInterval = (leaseTime/4) + (long)((float)leaseTime * (cg_random() * 0.25f));
notifyInterval *= 1000;
/* Sleep *notifyInterval* msecs */
cg_wait(notifyInterval);
/* Check if we must exit before sending new announce */
if ( cg_thread_isrunnable(thread) == FALSE ) break;
/* Initiate advertise routine after sleeping */
cg_upnp_device_announce(dev);
}
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");
}
static void cg_http_server_clientthread(CgThread *thread)
{
CgHttpServerClientData *clientData;
CgHttpServer *httpServer;
CgSocket *clientSock;
void *httpServerUserData;
CgHttpRequest *httpReq;
char *version = NULL;
cg_log_debug_l4("Entering...\n");
clientData = (CgHttpServerClientData *)cg_thread_getuserdata(thread);
httpServer = clientData->httpServer;
clientSock = clientData->clientSock;
httpServerUserData = cg_http_server_getuserdata(httpServer);
httpReq = cg_http_request_new();
cg_http_request_setsocket(httpReq, clientSock);
/**** Thanks for Makela Aapo (10/31/05) ****/
while (cg_http_request_read(httpReq, clientSock) == TRUE && cg_thread_isrunnable(thread) == TRUE) {
/* Check some validity of the request */
version = cg_http_request_getversion(httpReq);
if (cg_strcmp(version, CG_HTTP_VER11) == 0)
{
/* According to HTTP/1.1 spec, we must not tolerate
HTTP/1.1 request without HOST-header */
if (cg_http_request_gethost(httpReq) == NULL)
{
cg_http_request_postbadrequest(httpReq);
continue;
}
}
if (httpServer->listener != NULL) {
cg_http_request_setuserdata(httpReq, httpServerUserData);
httpServer->listener(httpReq);
}
/* Close connection according to HTTP version and headers */
if (cg_strcmp(version, CG_HTTP_VER10) == 0)
{
/* Terminate connection after HTTP/1.0 request */
break;
}
/* We are having HTTP/1.1 or better => terminate, if requested */
if (cg_http_request_iskeepaliveconnection(httpReq) == FALSE)
{
break;
}
}
cg_log_debug_s("Dropping HTTP client\n");
cg_http_request_delete(httpReq);
cg_socket_close(clientSock);
cg_socket_delete(clientSock);
cg_http_server_clientdata_delete(clientData);
cg_thread_setuserdata(thread, NULL);
// This code frequently crashes. mutex lock referencing free'd memory.
cg_http_server_lock(httpServer);
cg_thread_remove(thread);
cg_http_server_unlock(httpServer);
cg_log_debug_l4("Leaving...\n");
cg_thread_delete(thread);
}
