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");
}
void cg_upnp_dms_youtube_http_listener(CgHttpRequest *httpReq)
{
CgUpnpMediaServer *dms;
CgUpnpDevice *dev;
char *httpURI;
int contentMD5Idx;
char *contentMd5;
CgHttpResponse *httpRes;
CgSocket *sock;
char chunkedChar[32];
BOOL isHeadRequest;
struct stat fileStat;
off_t fileSize;
FILE *fp;
char readBuf[CG_FILE_READ_CHUNK_SIZE];
off_t nRead;
off_t nReadCnt;
off_t nWroteCnt;
char contentFile[CG_MD5_STRING_BUF_SIZE+8];
dev = (CgUpnpDevice *)cg_http_request_getuserdata(httpReq);
if (!dev) {
cg_http_request_postbadrequest(httpReq);
return;
}
dms = (CgUpnpMediaServer *)cg_upnp_device_getuserdata(dev);
if (!dms) {
cg_http_request_postbadrequest(httpReq);
return;
}
httpURI = cg_http_request_geturi(httpReq);
if (cg_strlen(httpURI) <= 0) {
cg_http_request_postbadrequest(httpReq);
return;
}
if (cg_strstr(httpURI, CG_UPNP_MEDIA_YOUTUBE_RESURL_PATH) < 0) {
cg_upnp_device_httprequestrecieved(httpReq);
return;
}
contentMD5Idx = cg_strrchr(httpURI, "/", 1);
if (contentMD5Idx < 0) {
cg_http_request_postbadrequest(httpReq);
return;
}
contentMd5 = httpURI + contentMD5Idx + 1;
cg_strcpy(contentFile, contentMd5);
cg_strcat(contentFile, "." CG_UPNP_MEDIA_YOUTUBE_TRANSCODE_FILEEXT);
cg_upnp_dms_lock(dms);
isHeadRequest = cg_http_request_isheadrequest(httpReq);
httpRes = cg_http_response_new();
#if defined(CG_USE_CHUNKED_STREAM)
cg_http_response_setversion(httpRes, CG_HTTP_VER11);
#else
cg_http_response_setversion(httpRes, CG_HTTP_VER10);
#endif
cg_http_response_setstatuscode(httpRes, CG_HTTP_STATUS_OK);
cg_http_response_setcontenttype(httpRes, CG_UPNP_MEDIA_YOUTUBE_CONTENT_MIMETYPE);
sock = cg_http_request_getsocket(httpReq);
cg_socket_settimeout(sock, 0);
fileSize = 0;
if (stat(contentFile, &fileStat) == 0)
fileSize = fileStat.st_size;
#if defined(CG_USE_CHUNKED_STREAM)
cg_http_packet_setheadervalue((CgHttpPacket*)httpRes, "Transfer-Encoding", "chunked");
#else
cg_http_response_setcontentlength(httpRes, fileSize);
#endif
cg_http_request_postresponse(httpReq, httpRes);
if (0 < fileSize) {
nReadCnt = 0;
nWroteCnt = 0;
fp = fopen(contentFile, "rb");
if (fp) {
nRead = fread(readBuf, sizeof(char), CG_FILE_READ_CHUNK_SIZE, fp);
while (nReadCnt < fileSize && 0 < nRead) {
nReadCnt += nRead;
#if defined(CG_USE_CHUNKED_STREAM)
sprintf(chunkedChar, "%x%s", nRead, CG_HTTP_CRLF);
cg_socket_write(sock, chunkedChar, cg_strlen(chunkedChar));
#endif
nWroteCnt += cg_socket_write(sock, readBuf, nRead);
#if defined(CG_USE_CHUNKED_STREAM)
cg_socket_write(sock, CG_HTTP_CRLF, sizeof(CG_HTTP_CRLF)-1);
#endif
nRead = fread(readBuf, sizeof(char), CG_FILE_READ_CHUNK_SIZE, fp);
}
fclose(fp);
}
}
#if defined(CG_USE_CHUNKED_STREAM)
sprintf(chunkedChar, "%x%s", 0, CG_HTTP_CRLF);
cg_socket_write(sock, chunkedChar, cg_strlen(chunkedChar));
#endif
cg_socket_close(sock);
cg_http_response_delete(httpRes);
cg_upnp_dms_unlock(dms);
}
CgHttpResponse *cg_http_request_post_main(CgHttpRequest *httpReq, char *ipaddr, int port, BOOL isSecure)
{
CgSocket *sock;
char *method, *uri, *version;
#ifdef CG_SHOW_TIMINGS
struct timeval start_time, end_time, elapsed_time;
#endif
CgString *firstLine;
cg_log_debug_l4("Entering...\n");
#ifdef CG_SHOW_TIMINGS
gettimeofday(&start_time, NULL);
#endif
cg_http_response_clear(httpReq->httpRes);
cg_log_debug_s("(HTTP) Posting:\n");
cg_http_request_print(httpReq);
#if defined(CG_USE_OPENSSL)
if (isSecure == FALSE)
sock = cg_socket_stream_new();
else
sock = cg_socket_ssl_new();
#else
sock = cg_socket_stream_new();
#endif
cg_socket_settimeout(sock, cg_http_request_gettimeout(httpReq));
if (cg_socket_connect(sock, ipaddr, port) == FALSE) {
cg_socket_delete(sock);
return httpReq->httpRes;
}
cg_http_request_sethost(httpReq, ipaddr, port);
cg_http_packet_setheadervalue((CgHttpPacket*)httpReq, CG_HTTP_USERAGENT, cg_http_request_getuseragent(httpReq));
method = cg_http_request_getmethod(httpReq);
uri = cg_http_request_geturi(httpReq);
version = cg_http_request_getversion(httpReq);
if (method == NULL || uri == NULL || version == NULL) {
cg_socket_close(sock);
cg_socket_delete(sock);
return httpReq->httpRes;
}
#ifdef CG_SHOW_TIMINGS
cg_log_debug_s("\nRequest: %s%s%s:%d%s%s%s\n", method, CG_HTTP_SP, ipaddr, port, uri, CG_HTTP_SP, version);
#endif
/**** send first line ****/
firstLine = cg_string_new();
cg_string_addvalue(firstLine, method);
cg_string_addvalue(firstLine, CG_HTTP_SP);
cg_string_addvalue(firstLine, uri);
cg_string_addvalue(firstLine, CG_HTTP_SP);
cg_string_addvalue(firstLine, version);
cg_string_addvalue(firstLine, CG_HTTP_CRLF);
cg_socket_write(sock, cg_string_getvalue(firstLine), cg_string_length(firstLine));
cg_string_delete(firstLine);
/**** send header and content ****/
cg_http_packet_post((CgHttpPacket *)httpReq, sock);
/**** read response ****/
cg_http_response_read(httpReq->httpRes, sock, cg_http_request_isheadrequest(httpReq));
#ifdef CG_SHOW_TIMINGS
gettimeofday(&end_time, NULL);
timersub(&end_time, &start_time, &elapsed_time);
cg_log_debug_s("Getting HTTP-response completed. Elapsed time: "
"%ld msec\n", ((elapsed_time.tv_sec*1000) +
(elapsed_time.tv_usec/1000)));
cg_total_elapsed_time += (elapsed_time.tv_sec*1000000)+
(elapsed_time.tv_usec);
#endif
cg_socket_close(sock);
cg_socket_delete(sock);
cg_http_response_print(httpReq->httpRes);
cg_log_debug_l4("Leaving...\n");
return httpReq->httpRes;
}
