enum DH_TransferModes DH_GetRequestedTransferMode(struct packetheader *p)
{
char *transferModeValue = ILibGetHeaderLine(p,"transferMode.dlna.org",21);
enum DH_TransferModes RetVal = DH_TransferMode_Unspecified;
if(transferModeValue!=NULL)
{
if(strcmp(transferModeValue,"Streaming")==0)
{
RetVal = DH_TransferMode_Streaming;
}
else if(strcmp(transferModeValue,"Interactive")==0)
{
RetVal = DH_TransferMode_Interactive;
}
else if(strcmp(transferModeValue,"Background")==0)
{
RetVal = DH_TransferMode_Bulk;
}
}
return(RetVal);
}
DH_TransferStatus DHS_SavePostToLocalFile(struct ILibWebServer_Session *session, ILibThreadPool pool, struct packetheader *header, const char *file_name, int append_flag, void *user_obj, DHS_OnResponseDone callback_response)
{
DH_TransferStatus RetVal = NULL;
char *hdr_field = NULL;
int temp = 0;
FILE *f;
struct DH_Data *data = NULL;
int Start,End,TotalLength;
int needClose = 0;
//
// Check the append flag
//
if(append_flag==0 && ILibGetHeaderLine(header,"content-range",13)!=NULL)
{
ILibWebClient_Parse_ContentRange(ILibGetHeaderLine(header,"content-range",13),&Start,&End,&TotalLength);
if(Start!=0)
{
//
// append_flag indicates overwrite, but the header's indicate partial content
// this is not allowed
//
if(ILibGetHeaderLine(header,"Expect",6)==NULL)
{
needClose = 1;
}
ILibWebServer_Send_Raw(session,"HTTP/1.1 406 Not Acceptable\r\n\r\n",31,ILibAsyncSocket_MemoryOwnership_STATIC,1);
if(needClose!=0)
{
// If the client did not send "Expect 100 Continue", then the request body may already be in transit, so we must close the socket
ILibWebServer_DisconnectSession(session);
}
return(NULL);
}
}
if(append_flag==0)
{
f = fopen(file_name,"wb");
}
else
{
f = fopen(file_name,"r+b");
}
if(f==NULL)
{
//
// Error
//
if(ILibGetHeaderLine(header,"Expect",6)==NULL)
{
needClose = 1;
}
ILibWebServer_Send_Raw(session,"HTTP/1.1 404 File not found\r\n\r\n",31,ILibAsyncSocket_MemoryOwnership_STATIC,1);
if(needClose!=0)
{
// If the client did not send "Expect 100 Continue", then the request body may already be in transit, so we must close the socket
ILibWebServer_DisconnectSession(session);
}
return(NULL);
}
data = (struct DH_Data*)malloc(sizeof(struct DH_Data));
memset(data,0,sizeof(struct DH_Data));
data->callback_response = callback_response;
data->f = f;
data->header = header;
data->session = session;
data->pool = pool;
data->OriginalReceivePtr = session->OnReceive;
data->user_object = user_obj;
RetVal = data->TransferStatus = DH_CreateNewTransferStatus();
RetVal->ServerSession = session;
RetVal->SessionFlag = 1;
ILibWebServer_OverrideReceiveHandler(session,&DHS_OnReceive_SavePostToLocalFile);
session->User3 = data;
session->OnDisconnect = &DHS_OnDisconnect;
//
// Check to see if we need to advance the file pointer
//
if(append_flag!=0)
{
hdr_field = ILibGetHeaderLine(header,"content-range",13);
if(hdr_field==NULL)
{
//
// Just append to the end of the file
//
fseek(f,0,SEEK_END);
}
else
{
//
// Advance the file pointer the specified amount
//
int SourceFileLength = 0;
ILibWebClient_Parse_ContentRange(hdr_field,&Start,&End,&TotalLength);
if(Start==-1 && End==-1 && TotalLength==-1)
{
// Invalid Range
ILibWebServer_Send_Raw(session,"HTTP/1.1 400 Bad Request\r\n\r\n",28,ILibAsyncSocket_MemoryOwnership_STATIC,1);
if(ILibGetHeaderLine(header,"Expect",6)==NULL)
{
// If the client did not send "Expect 100 Continue", then the request body may already be in transit, so we must close the socket
ILibWebServer_DisconnectSession(session);
}
return(NULL);
}
else
{
// Valid Range
fseek(f,0,SEEK_END);
SourceFileLength = (int)ftell(f);
if(SourceFileLength != Start)
{
ILibWebServer_Send_Raw(session,"HTTP/1.1 409 Conflict\r\n\r\n",25,ILibAsyncSocket_MemoryOwnership_STATIC,1);
if(ILibGetHeaderLine(header,"Expect",6)==NULL)
{
// If the client did not send "Expect 100 Continue", then the request body may already be in transit, so we must close the socket
ILibWebServer_DisconnectSession(session);
}
return(NULL);
}
}
}
}
if(session->done!=0)
{
//
// All the data is here, so OnReceive won't be called anymore
//
DHS_OnReceive_SavePostToLocalFile(session,0,header,session->buffer,&temp,session->bufferLength,session->done);
}
else
{
hdr_field = ILibGetHeaderLine(header,"Content-Length",14);
if(hdr_field!=NULL)
{
data->TransferStatus->TotalBytesToBeReceived = atol(hdr_field);
}
//
// Check to see if we are supposed to send a 100 Continue response
//
hdr_field = ILibGetHeaderLine(header,"expect",6);
if(hdr_field != NULL && strcasecmp(hdr_field,"100-continue")==0)
{
//
// Send 100-Continue
//
ILibWebServer_Send_Raw(session,"HTTP/1.1 100 Continue\r\n\r\n",25,ILibAsyncSocket_MemoryOwnership_STATIC,0);
}
else if(hdr_field != NULL)
{
//
// We don't recognize the expectation
//
ILibWebServer_Send_Raw(session,"HTTP/1.1 417 Expectation Failed\r\n\r\n",35,ILibAsyncSocket_MemoryOwnership_STATIC,1);
if(ILibGetHeaderLine(header,"Expect",6)==NULL)
{
// If the client did not send "Expect 100 Continue", then the request body may already be in transit, so we must close the socket
ILibWebServer_DisconnectSession(session);
}
RetVal = NULL;
}
}
return(RetVal);
}
void DH_RequestResponse(ILibWebClient_StateObject WebStateObject,int InterruptFlag,struct packetheader *header,char *bodyBuffer,int *beginPointer,int endPointer,int done,void *user1,void *user2,int *PAUSE)
{
struct DHC_Data *data = (struct DHC_Data*)user1;
enum DHC_Errors status;
void *Abort = NULL;
char *rangeResult;
struct parser_result *pr;
long total;
char *contentFeatures;
struct DLNAProtocolInfo *pi;
ILibReaderWriterLock rwLock = NULL;
struct packetheader *GetRequest = NULL;
struct sockaddr_in dest;
int needToIssueRange = 0;
int needToIssueRealRequest = 0;
int MustNotResume = 0;
struct packetheader *req;
char *temp;
if(data==NULL)
{
//
// We appeared to be in the wrong state, most likely received
// some bad responses, so if we ignore it, we should recover.
//
return;
}
if((header==NULL && done!=0) || (header!=NULL && header->StatusCode!=200 && header->StatusCode!=206 && done!=0))
{
fclose(data->f);
if(header==NULL)
{
status = DHC_ERRORS_CONNECTION_FAILED_OR_ABORTED;
}
else
{
status = DHC_ERRORS_HTTP;
}
if(data->Callback!=NULL)
{
if(header!=NULL)
{
header->StatusData[header->StatusDataLength]=0;
}
data->Callback(data->TransferStatus, status, header==NULL?0:header->StatusCode, header==NULL?NULL:header->StatusData,data->user);
}
DH_DestroyTransferStatus(data->TransferStatus);
if(data->ActualPacket!=NULL)
{
ILibDestructPacket(data->ActualPacket);
}
free(data);
ILibWebClient_ResetUserObjects(WebStateObject,NULL, NULL);
}
else if(header!=NULL && (header->StatusCode==200 || header->StatusCode==206))
{
if(data->ActualPacket!=NULL)
{
if(data->DoneProcessingContentFeatures==0)
{
data->DoneProcessingContentFeatures = 1;
//
// Determine if Range is supported, then do another Head Range Request
//
if(data->TransferStatus->Reserved4!=0 && data->TransferStatus->RequestToken!=NULL)
{
//
// Abort... Nothing really to do, because at this point we already finished.
// Only thing to do, is to not actually issue the request.
//
data->TransferStatus->RequestToken = NULL;
}
else
{
//
// Transfer Mode wasn't specified
//
contentFeatures = ILibGetHeaderLine(header,"contentFeatures.dlna.org",24);
if(contentFeatures!=NULL)
{
temp = ILibString_Cat("http-get:*:*:",13,contentFeatures,(int)strlen(contentFeatures));
pi = DLNAProtocolInfo_Parse(temp,(int)strlen(temp));
if(pi!=NULL)
{
if(pi->TM_B!=0)
{
DH_AddHeader_transferMode(data->ActualPacket,DH_TransferMode_Bulk);
data->TransferMode = DH_TransferMode_Bulk;
}
else if(pi->TM_I!=0)
{
DH_AddHeader_transferMode(data->ActualPacket,DH_TransferMode_Interactive);
data->TransferMode = DH_TransferMode_Interactive;
}
else if(pi->TM_S!=0)
{
DH_AddHeader_transferMode(data->ActualPacket,DH_TransferMode_Streaming);
data->TransferMode = DH_TransferMode_Streaming;
}
needToIssueRange = pi->SupportsByteBasedSeek;
DLNAProtocolInfo_Destruct(pi);
}
free(temp);
}
else
{
//
// since the server didn't respond with a DLNA Content Features, then
// most likely this is a plain Media Server, in which case, if it doesn't support range
// it won't return an error, and it'll just ignore the header, so we can issue a range
// request anyways.
//
needToIssueRange = 1;
}
if(needToIssueRange!=0)
{
//
// Issue a Range Request
//
req = ILibCreateEmptyPacket();
ILibSetVersion(req,"1.1",3);
ILibAddHeaderLine(req,"Host",4,ILibGetHeaderLine(data->ActualPacket,"Host",4),(int)strlen(ILibGetHeaderLine(data->ActualPacket,"Host",4)));
ILibSetDirective(req,"HEAD",4,data->ActualPacket->DirectiveObj,data->ActualPacket->DirectiveObjLength);
DH_AddHeader_Range(req,0,-1);
memset(&dest,0,sizeof(struct sockaddr_in));
dest.sin_family = AF_INET;
dest.sin_addr.s_addr = header->Source->sin_addr.s_addr;
dest.sin_port = header->Source->sin_port;
ILibReaderWriterLock_WriteLock(data->rwLock);
switch(data->TransferMode)
{
case DH_TransferMode_Bulk:
ILibWebClient_SetQosForNextRequest(data->manager,ILibAsyncSocket_QOS_BACKGROUND);
break;
case DH_TransferMode_Streaming:
ILibWebClient_SetQosForNextRequest(data->manager,ILibAsyncSocket_QOS_AUDIO_VIDEO);
break;
}
data->TransferStatus->RequestToken = data->token = ILibWebClient_PipelineRequest(data->manager,&dest,req,&DH_RequestResponse,data,NULL);
ILibReaderWriterLock_WriteUnLock(data->rwLock);
}
else
{
//
// Range is not supported, so just continue with making the request.
// However, before we do, since range isn't supported, we need to make
// sure that we aren't trying to resume.
MustNotResume = 1;
needToIssueRealRequest = 1;
}
}
}
else
{
//
// Process the Range Response
//
rangeResult = ILibGetHeaderLine(header,"content-range",13);
if(rangeResult!=NULL)
{
pr = ILibParseString(rangeResult,0,(int)strlen(rangeResult),"/",1);
total = atol(pr->LastResult->data);
ILibDestructParserResults(pr);
total -= data->StartPosition;
sem_wait(&(data->TransferStatus->syncLock));
data->TransferStatus->TotalBytesToBeReceived = total;
sem_post(&(data->TransferStatus->syncLock));
}
else
{
//
// We couldn't get a range result, so we need to make sure
// we don't try to do a resume.
//
MustNotResume = 1;
}
//
// Continue with actually making the content request
//
needToIssueRealRequest = 1;
}
if(needToIssueRealRequest!=0 && !(data->TransferStatus->Reserved4!=0 && data->TransferStatus->RequestToken!=NULL))
{
GetRequest = data->ActualPacket;
data->ActualPacket = NULL;
rwLock = (ILibReaderWriterLock)ILibWebClient_GetUser(data->manager);
memset(&dest,0,sizeof(struct sockaddr_in));
dest.sin_family = AF_INET;
dest.sin_addr.s_addr = header->Source->sin_addr.s_addr;
dest.sin_port = header->Source->sin_port;
if(MustNotResume!=0)
{
//
// Range isn't supported, so we must not resume
//
if(data->StartPosition!=0)
{
data->StartPosition = 0;
fseek(data->f,0,SEEK_SET);
}
}
else if(data->StartPosition!=0)
{
DH_AddHeader_Range(GetRequest,data->StartPosition,-1);
}
ILibReaderWriterLock_WriteLock(rwLock);
switch(data->TransferMode)
{
case DH_TransferMode_Bulk:
ILibWebClient_SetQosForNextRequest(data->manager,ILibAsyncSocket_QOS_BACKGROUND);
break;
case DH_TransferMode_Streaming:
ILibWebClient_SetQosForNextRequest(data->manager,ILibAsyncSocket_QOS_AUDIO_VIDEO);
break;
}
data->TransferStatus->RequestToken = data->token = ILibWebClient_PipelineRequest(data->manager,&dest,GetRequest,&DH_RequestResponse,data,NULL);
ILibReaderWriterLock_WriteUnLock(rwLock);
}
*beginPointer = endPointer; // Don't really need to do this, because it should always be zero
return;
}
data->buffer = bodyBuffer;
data->bufferLength = endPointer;
*beginPointer = endPointer;
data->GotContinue = done;
if(endPointer!=0 || done)
{
*PAUSE = 1;
}
if(data->token!=NULL)
{
data->webState = ILibWebClient_GetStateObjectFromRequestToken(data->token);
}
if(data->TransferStatus->Reserved4!=0 && data->TransferStatus->RequestToken!=NULL)
{
//
// Abort
//
Abort = data->TransferStatus->RequestToken;
data->TransferStatus->RequestToken = NULL;
ILibWebClient_CancelRequest(Abort);
}
else if(data->TransferStatus->RequestToken!=NULL)
{
if(endPointer>0 || done)
{
ILibThreadPool_QueueUserWorkItem(data->pool,data,&DH_Pool_RequestResponse);
}
}
}
}
DH_TransferStatus DHS_RespondWithLocalFile(struct ILibWebServer_Session *session, ILibThreadPool pool, struct packetheader *header, size_t buffer_size, const char *file_name, unsigned int supported_transfer_mode, const char *mime_type, const char *content_features, const char* ifo_uri, void *user_obj, DHS_OnResponseDone callback_response)
{
DH_TransferStatus retval = NULL;
FILE *f;
struct DH_Data *data = NULL;
struct packetheader *resp = NULL;
char *ifo, *cf = NULL;
long RangeStart,RangeLength,FileLength;
char len[255];
enum ILibWebClient_Range_Result RangeResult = 0;
enum DH_TransferModes transferMode;
if(session->done==0)
{
//
// If the get request wasn't completely received yet, then we don't need to do anything yet
//
return NULL;
}
f = fopen(file_name,"rb");
if(f!=NULL)
{
data = (struct DH_Data*)malloc(sizeof(struct DH_Data));
memset(data,0,sizeof(struct DH_Data));
resp = ILibCreateEmptyPacket();
ILibSetVersion(resp,"1.1",3);
fseek(f,0,SEEK_END);
FileLength = ftell(f);
fseek(f,0,SEEK_SET);
cf = ILibGetHeaderLine(header,"getcontentFeatures.dlna.org",27);
if(cf!= NULL && memcmp(cf, "1", 1)!=0)
{
ILibWebServer_Send_Raw(session,"HTTP/1.1 400 Bad Request\r\n\r\n",28,ILibAsyncSocket_MemoryOwnership_STATIC,1);
fclose(f);
free(data);
ILibDestructPacket(resp);
return(NULL);
}
transferMode = DH_GetRequestedTransferMode(header);
if(
((transferMode == DH_TransferMode_Bulk) ||
(transferMode == DH_TransferMode_Interactive))
&&
((ILibGetHeaderLine(header,"TimeSeekRange.dlna.org",22)!=NULL) ||
(ILibGetHeaderLine(header,"PlaySpeed.dlna.org",18)!=NULL) ||
(ILibGetHeaderLine(header,"realTimeInfo.dlna.org",21)!=NULL)
)
)
{
ILibWebServer_Send_Raw(session,"HTTP/1.1 400 Bad Request\r\n\r\n",28,ILibAsyncSocket_MemoryOwnership_STATIC,1);
fclose(f);
free(data);
ILibDestructPacket(resp);
return(NULL);
}
if(ILibGetHeaderLine(header,"Range",5)!=NULL)
{
RangeResult = ILibWebClient_Parse_Range(ILibGetHeaderLine(header,"Range",5),&RangeStart,&RangeLength,FileLength);
switch(RangeResult)
{
case ILibWebClient_Range_Result_OK:
fseek(f,RangeStart,SEEK_SET);
data->BytesLeft = RangeLength;
ILibSetStatusCode(resp,206,"Partial Content",15);
DH_AddHeader_ContentRange(resp,RangeStart,(RangeStart+RangeLength)-1,FileLength);
break;
case ILibWebClient_Range_Result_INVALID_RANGE:
ILibWebServer_Send_Raw(session,"HTTP/1.1 416 Invalid Range\r\n\r\n",30,ILibAsyncSocket_MemoryOwnership_STATIC,1);
fclose(f);
free(data);
ILibDestructPacket(resp);
return(NULL);
break;
case ILibWebClient_Range_Result_BAD_REQUEST:
ILibWebServer_Send_Raw(session,"HTTP/1.1 400 Bad Request\r\n\r\n",28,ILibAsyncSocket_MemoryOwnership_STATIC,1);
fclose(f);
free(data);
ILibDestructPacket(resp);
return(NULL);
break;
}
}
else if(ILibGetHeaderLine(header,"TimeSeekRange.dlna.org",22)!=NULL)
{
ILibWebServer_Send_Raw(session,"HTTP/1.1 406 Time-based seek not supported\r\n\r\n",46,ILibAsyncSocket_MemoryOwnership_STATIC,1);
fclose(f);
free(data);
ILibDestructPacket(resp);
return(NULL);
}
else if(ILibGetHeaderLine(header,"PlaySpeed.dlna.org",18)!=NULL)
{
ILibWebServer_Send_Raw(session,"HTTP/1.1 406 PlaySpeeds not supported\r\n\r\n",41,ILibAsyncSocket_MemoryOwnership_STATIC,1);
fclose(f);
free(data);
ILibDestructPacket(resp);
return(NULL);
}
else
{
ILibSetStatusCode(resp,200,"OK",2);
data->BytesLeft = FileLength;
sprintf(len,"%ld",data->BytesLeft);
ILibAddHeaderLine(resp,"Content-Length",14,len,(int)strlen(len));
ILibAddHeaderLine(resp,"Accept-Ranges",13,"bytes",5);
}
if(transferMode == DH_TransferMode_Unspecified && mime_type != NULL)
{
if(ILibString_StartsWith(mime_type, (int) strlen(mime_type), "video/", 6) != 0)
{
DH_AddHeader_transferMode(resp, DH_TransferMode_Streaming);
}
else if(ILibString_StartsWith(mime_type, (int) strlen(mime_type), "audio/", 6) != 0)
{
DH_AddHeader_transferMode(resp, DH_TransferMode_Streaming);
}
else if(ILibString_StartsWith(mime_type, (int) strlen(mime_type), "image/", 6) != 0)
{
DH_AddHeader_transferMode(resp, DH_TransferMode_Interactive);
}
}
else if(!(transferMode & supported_transfer_mode))
{
//
// Specified transfer mode is not supported
//
ILibWebServer_Send_Raw(session,"HTTP/1.1 406 Not Acceptable\r\n\r\n",31,ILibAsyncSocket_MemoryOwnership_STATIC,1);
fclose(f);
free(data);
ILibDestructPacket(resp);
return(NULL);
}
else
{
DH_AddHeader_transferMode(resp,transferMode);
}
data->callback_response = callback_response;
data->f = f;
data->header = header;
data->session = session;
data->pool = pool;
data->TransferStatus = retval = DH_CreateNewTransferStatus();
data->TransferStatus->TotalBytesToBeSent = data->BytesLeft;
data->user_object = user_obj;
retval->ServerSession = session;
session->OnDisconnect = &DH_Disconnect;
if(content_features!=NULL)
{
ILibAddHeaderLine(resp,"contentFeatures.dlna.org",24,(char*) content_features,(int)strlen(content_features));
}
if(mime_type!=NULL)
{
ILibAddHeaderLine(resp,"Content-Type",12,(char*)mime_type,(int)strlen(mime_type));
}
else
{
ILibAddHeaderLine(resp,"Content-Type",12,(char*)DHS_DEFAULT_MIMETYPE,(int)strlen(DHS_DEFAULT_MIMETYPE));
}
if(ifo_uri!=NULL)
{
ifo = (char*)malloc((int)strlen(ifo_uri)+25);
sprintf(ifo,"ifoFileURI.dlna.org=\"%s\"",ifo_uri);
ILibAddHeaderLine(resp,"PRAGMA",6,ifo,(int)strlen(ifo));
free(ifo);
}
ILibWebServer_StreamHeader(session,resp);
if(header->DirectiveLength==4 && strncasecmp(header->Directive,"HEAD",4)==0)
{
ILibWebServer_StreamBody(session,NULL,0,ILibAsyncSocket_MemoryOwnership_STATIC,1);
fclose(data->f);
data->f = NULL;
DH_DestroyTransferStatus(data->TransferStatus);
free(data);
session->OnDisconnect = NULL;
return(NULL);
}
else
{
lock_init(&(data->SendStatusLock),0,1);
ILibThreadPool_QueueUserWorkItem(pool,data,&DH_Pool);
}
}
else
{
//
// Error opening file
//
ILibWebServer_Send_Raw(session,"HTTP/1.1 404 File Not Found\r\n\r\n",31,ILibAsyncSocket_MemoryOwnership_STATIC,1);
}
return retval;
}
