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); }