/*---------------------------------------------------------------------- | main +---------------------------------------------------------------------*/ int main(int argc, char** argv) { NPT_COMPILER_UNUSED(argc); NPT_COMPILER_UNUSED(argv); #if defined(WIN32) && defined(_DEBUG) _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF); _CrtSetAllocHook(AllocHook); #endif TestSharedVariables(); TestPrio(); Test3(100000, 0.0f, 0.0f); Test3(300, 0.1f, 0.0f); Test3(100, 0.5f, 0.4f); Test4(); Test1(); Test2(); NPT_Debug("- program done -\n"); return 0; }
/*---------------------------------------------------------------------- | PLT_CtrlPointInvokeActionTask::ProcessResponse +---------------------------------------------------------------------*/ NPT_Result PLT_CtrlPointInvokeActionTask::ProcessResponse(NPT_Result res, NPT_HttpRequest* request, const NPT_HttpRequestContext& context, NPT_HttpResponse* response) { NPT_COMPILER_UNUSED(request); NPT_COMPILER_UNUSED(context); return m_CtrlPoint->ProcessActionResponse(res, response, m_Action, m_Userdata); }
/*---------------------------------------------------------------------- | PLT_CtrlPointSubscribeEventTask::ProcessResponse +---------------------------------------------------------------------*/ NPT_Result PLT_CtrlPointSubscribeEventTask::ProcessResponse(NPT_Result res, NPT_HttpRequest* request, const NPT_HttpRequestContext& context, NPT_HttpResponse* response) { NPT_COMPILER_UNUSED(request); NPT_COMPILER_UNUSED(context); return m_CtrlPoint->ProcessSubscribeResponse(res, response, m_Service, m_Userdata); }
// NPT_HttpRequetsHandler methods virtual NPT_Result SetupResponse(NPT_HttpRequest& request, const NPT_HttpRequestContext& context, NPT_HttpResponse& response) { NPT_COMPILER_UNUSED(request); NPT_COMPILER_UNUSED(context); NPT_HttpEntity* entity = response.GetEntity(); if (entity == NULL) return NPT_ERROR_INVALID_STATE; entity->SetContentType(m_MimeType); entity->SetInputStream(m_Body); return NPT_SUCCESS; }
void GPAC_MediaController::OnBrowseResult(NPT_Result res, PLT_DeviceDataReference& device, PLT_BrowseInfo* info, void* userdata) { NPT_COMPILER_UNUSED(device); NPT_COMPILER_UNUSED(device); if (!userdata) return; PLT_BrowseDataReference* data = (PLT_BrowseDataReference*) userdata; (*data)->res = res; if (NPT_SUCCEEDED(res) && info) { (*data)->info = *info; } (*data)->shared_var.SetValue(1); delete data; }
/*---------------------------------------------------------------------- | PLT_MediaServer::OnGetCurrentConnectionInfo +---------------------------------------------------------------------*/ NPT_Result PLT_MediaServer::OnGetCurrentConnectionInfo(PLT_ActionReference& action, const PLT_HttpRequestContext& context) { NPT_COMPILER_UNUSED(context); if (NPT_FAILED(action->VerifyArgumentValue("ConnectionID", "0"))) { action->SetError(706,"No Such Connection."); return NPT_FAILURE; } if (NPT_FAILED(action->SetArgumentValue("RcsID", "-1"))){ return NPT_FAILURE; } if (NPT_FAILED(action->SetArgumentValue("AVTransportID", "-1"))) { return NPT_FAILURE; } if (NPT_FAILED(action->SetArgumentValue("ProtocolInfo", "http-get:*:*:*"))) { return NPT_FAILURE; } if (NPT_FAILED(action->SetArgumentValue("PeerConnectionManager", "/"))) { return NPT_FAILURE; } if (NPT_FAILED(action->SetArgumentValue("PeerConnectionID", "-1"))) { return NPT_FAILURE; } if (NPT_FAILED(action->SetArgumentValue("Direction", "Output"))) { return NPT_FAILURE; } if (NPT_FAILED(action->SetArgumentValue("Status", "Unknown"))) { return NPT_FAILURE; } return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | CMediaCrawler::ProcessFileRequest +---------------------------------------------------------------------*/ NPT_Result CMediaCrawler::ProcessFileRequest(NPT_HttpRequest& request, NPT_HttpResponse& response, NPT_SocketInfo& info) { NPT_COMPILER_UNUSED(info); NPT_LOG_FINE("CMediaCrawler::ProcessFileRequest Received Request:"); PLT_LOG_HTTP_MESSAGE(NPT_LOG_LEVEL_FINE, &request); if (request.GetMethod().Compare("GET") && request.GetMethod().Compare("HEAD")) { response.SetStatus(500, "Internal Server Error"); return NPT_SUCCESS; } // add the user agent header, some stupid media servers like YME needs it if (!request.GetHeaders().GetHeader(NPT_HTTP_HEADER_USER_AGENT)) { request.GetHeaders().SetHeader(NPT_HTTP_HEADER_USER_AGENT, "Platinum/" PLT_PLATINUM_VERSION_STRING); } // File requested NPT_HttpResponse* out_response = NULL; NPT_HttpUrlQuery query(request.GetUrl().GetQuery()); const char* url = query.GetField("url"); if (url) { // look for handler CStreamHandler* handler = NULL; NPT_ContainerFind(m_StreamHandlers, CStreamHandlerFinder(NULL, url), handler); if (handler && NPT_SUCCEEDED(handler->ProcessFileRequest(request, out_response)) && out_response) { // copy response code and reason response.SetStatus(out_response->GetStatusCode(), out_response->GetReasonPhrase()); // copy headers NPT_List<NPT_HttpHeader*>::Iterator headers = out_response->GetHeaders().GetHeaders().GetFirstItem(); while (headers) { response.GetHeaders().SetHeader((*headers)->GetName(), (*headers)->GetValue()); ++headers; } response.SetEntity(new NPT_HttpEntity(response.GetHeaders())); // update inputstream NPT_HttpEntity* out_entity; if ((out_entity = out_response->GetEntity()) != NULL) { NPT_InputStreamReference inputstream; out_entity->GetInputStream(inputstream); if (!inputstream.IsNull()) { // set the stream but do not update the content length response.GetEntity()->SetInputStream(inputstream, false); } } delete out_response; return NPT_SUCCESS; } } response.SetStatus(404, "File Not Found"); return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | PLT_HttpClient::WaitForResponse +---------------------------------------------------------------------*/ NPT_Result PLT_HttpClient::WaitForResponse(NPT_InputStreamReference& input_stream, NPT_HttpRequest& request, NPT_SocketInfo& info, NPT_HttpResponse*& response) { NPT_COMPILER_UNUSED(info); // create a buffered stream for this connection stream NPT_BufferedInputStreamReference buffered_input_stream(new NPT_BufferedInputStream(input_stream)); // parse the response NPT_CHECK(NPT_HttpResponse::Parse(*buffered_input_stream, response)); // unbuffer the stream buffered_input_stream->SetBufferSize(0); // create an entity if one is expected in the response if (request.GetMethod() == NPT_HTTP_METHOD_GET || request.GetMethod() == NPT_HTTP_METHOD_POST) { NPT_HttpEntity* response_entity = new NPT_HttpEntity(response->GetHeaders()); // Transfer-Encoding: chunked ? if (response_entity->GetTransferEncoding() == "chunked") { NPT_InputStreamReference body_stream(new NPT_HttpChunkedDecoderInputStream(buffered_input_stream)); response_entity->SetInputStream((NPT_InputStreamReference)body_stream); } else { response_entity->SetInputStream((NPT_InputStreamReference)buffered_input_stream); } response->SetEntity(response_entity); } return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | NPT_DynamicLibrary::Load +---------------------------------------------------------------------*/ NPT_Result NPT_DynamicLibrary::Load(const char* name, NPT_Flags flags, NPT_DynamicLibrary*& library) { NPT_WIN32_USE_CHAR_CONVERSION; NPT_COMPILER_UNUSED(flags); if (name == NULL) return NPT_ERROR_INVALID_PARAMETERS; // default return value library = NULL; // load the lib NPT_LOG_FINE_2("loading library %s, flags=%x", name, flags); HMODULE handle = LoadLibraryW(NPT_WIN32_A2W(name)); if (handle == NULL) { NPT_LOG_FINE("library not found"); return NPT_FAILURE; } // instantiate the object NPT_LOG_FINE_1("library %s loaded", name); library = new NPT_DynamicLibrary(new NPT_Win32DynamicLibrary(handle, name)); return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | PLT_LightSampleDevice::OnAction +---------------------------------------------------------------------*/ NPT_Result PLT_LightSampleDevice::OnAction(PLT_ActionReference& action, const PLT_HttpRequestContext& context) { NPT_COMPILER_UNUSED(context); /* parse the action name */ NPT_String name = action->GetActionDesc().GetName(); if (name.Compare("SetTarget") == 0) { NPT_String value; action->GetArgumentValue("newTargetValue", value); PLT_StateVariable* variable = action->GetActionDesc().GetService()->FindStateVariable("Status"); if (NPT_FAILED(variable->SetValue(value))) { action->SetError(402, "Invalid Args"); return NPT_FAILURE; } return NPT_SUCCESS; } else if (name.Compare("GetStatus") == 0) { PLT_StateVariable* variable = action->GetActionDesc().GetService()->FindStateVariable("Status"); if (variable) { action->SetArgumentValue("ResultStatus", variable->GetValue()); return NPT_SUCCESS; } } action->SetError(501, "Action Failed"); return NPT_FAILURE; }
NPT_Result GPAC_GenericDevice::OnAction(PLT_ActionReference& action, const PLT_HttpRequestContext& context) { NPT_COMPILER_UNUSED(context); #ifdef GPAC_HAS_SPIDERMONKEY gf_mx_p(m_pMutex); #endif PLT_ActionDesc &act_desc = action->GetActionDesc(); NPT_String name = act_desc.GetName(); #ifdef GPAC_HAS_SPIDERMONKEY assert(!m_pSema); #endif GF_LOG(GF_LOG_INFO, GF_LOG_NETWORK, ("[UPnP] Action %s called (thread %d)\n", (char *) name, gf_th_id() )); #ifdef GPAC_HAS_SPIDERMONKEY if (JSVAL_IS_NULL(act_proc)) { gf_mx_v(m_pMutex); return NPT_SUCCESS; } jsval argv[2]; m_pUPnP->LockJavascript(GF_TRUE); JSObject *js_action = JS_NewObject(m_pUPnP->m_pJSCtx, &m_pUPnP->upnpDeviceClass._class, 0, 0); argv[0] = OBJECT_TO_JSVAL(js_action); SMJS_SET_PRIVATE(m_pUPnP->m_pJSCtx, js_action, this); act_ref = action; JS_DefineProperty(m_pUPnP->m_pJSCtx, js_action, "Name", STRING_TO_JSVAL( JS_NewStringCopyZ(m_pUPnP->m_pJSCtx, name) ), 0, 0, JSPROP_READONLY | JSPROP_PERMANENT); GPAC_Service *service = (GPAC_Service *) act_desc.GetService(); JS_DefineProperty(m_pUPnP->m_pJSCtx, js_action, "Service", service->m_pObj ? OBJECT_TO_JSVAL( service->m_pObj) : JSVAL_NULL, 0, 0, JSPROP_READONLY | JSPROP_PERMANENT); JS_DefineFunction(m_pUPnP->m_pJSCtx, js_action, "GetArgument", upnp_action_get_argument, 1, 0); JS_DefineFunction(m_pUPnP->m_pJSCtx, js_action, "SendReply", upnp_action_send_reply, 1, 0); /*create a semaphore*/ m_pSema = gf_sema_new(1, 0); jsval rval; JS_CallFunctionValue(m_pUPnP->m_pJSCtx, obj, act_proc, 1, argv, &rval); SMJS_SET_PRIVATE(m_pUPnP->m_pJSCtx, js_action, NULL); m_pUPnP->LockJavascript(GF_FALSE); if (JSVAL_IS_INT(rval) && (JSVAL_TO_INT(rval) != 0)) { action->SetError(JSVAL_TO_INT(rval), "Action Failed"); } /*wait on the semaphore*/ if (!gf_sema_wait_for(m_pSema, 10000)) { GF_LOG(GF_LOG_WARNING, GF_LOG_NETWORK, ("[UPnP] Reply processing to action %s timeout - sending incomplete reply)\n", (char *) name)); } gf_sema_del(m_pSema); m_pSema = NULL; gf_mx_v(m_pMutex); #endif return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | PLT_FileMediaServer::ServeFile +---------------------------------------------------------------------*/ NPT_Result PLT_FileMediaServer::ServeFile(NPT_HttpRequest& request, const NPT_HttpRequestContext& context, NPT_HttpResponse& response, const NPT_String& uri_path, const NPT_String& file_path) { NPT_COMPILER_UNUSED(context); // prevent hackers from accessing files outside of our root if ((file_path.Find("/..") >= 0) || (file_path.Find("\\..") >= 0)) { return NPT_FAILURE; } // File requested NPT_String path = m_FileBaseUri.GetPath(); if (path.Compare(uri_path.Left(path.GetLength()), true) == 0) { NPT_Position start, end; PLT_HttpHelper::GetRange(request, start, end); return PLT_FileServer::ServeFile(response, NPT_FilePath::Create(m_Path, file_path), start, end, !request.GetMethod().Compare("HEAD")); } // Album Art requested path = m_AlbumArtBaseUri.GetPath(); if (path.Compare(uri_path.Left(path.GetLength()), true) == 0) { return OnAlbumArtRequest(response, m_Path + file_path); } return NPT_FAILURE; }
/*---------------------------------------------------------------------- | PLT_MediaServer::OnGetSystemUpdateID +---------------------------------------------------------------------*/ NPT_Result PLT_MediaServer::OnGetSystemUpdateID(PLT_ActionReference& action, const PLT_HttpRequestContext& context) { NPT_COMPILER_UNUSED(context); return action->SetArgumentsOutFromStateVariable(); }
NPT_Result operator()(NPT_HttpHeader*& header) const { NPT_COMPILER_UNUSED(header); NPT_LOG_L2(m_Logger, m_Level, "%s: %s", (const char*)header->GetName(), (const char*)header->GetValue()); return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | main +---------------------------------------------------------------------*/ int main(int argc, char** argv) { NPT_COMPILER_UNUSED(argc); NPT_COMPILER_UNUSED(argv); #if defined(WIN32) && defined(_DEBUG) _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_CHECK_ALWAYS_DF | _CRTDBG_LEAK_CHECK_DF); #endif TestSharedVariables(); NPT_Debug("- program done -\n"); return 0; }
/*---------------------------------------------------------------------- | PLT_HttpHelper::ToLog +---------------------------------------------------------------------*/ NPT_Result PLT_HttpHelper::ToLog(NPT_LoggerReference logger, int level, NPT_HttpRequest* request) { NPT_COMPILER_UNUSED(logger); NPT_COMPILER_UNUSED(level); NPT_CHECK_POINTER(request); NPT_StringOutputStreamReference stream(new NPT_StringOutputStream); request->GetHeaders().GetHeaders().Apply(NPT_HttpHeaderPrinter((NPT_OutputStreamReference&)stream)); NPT_LOG_L4(logger, level, "\n%s %s %s\n%s", (const char*)request->GetMethod(), (const char*)request->GetUrl().ToRequestString(true), (const char*)request->GetProtocol(), (const char*)stream->GetString()); return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | NPT_HttpResponse::ToLog +---------------------------------------------------------------------*/ NPT_Result PLT_HttpHelper::ToLog(NPT_LoggerReference logger, int level, NPT_HttpResponse* response) { NPT_COMPILER_UNUSED(logger); NPT_COMPILER_UNUSED(level); NPT_CHECK_POINTER(response); NPT_StringOutputStreamReference stream(new NPT_StringOutputStream); response->GetHeaders().GetHeaders().Apply(NPT_HttpHeaderPrinter((NPT_OutputStreamReference&)stream)); NPT_LOG_L4(logger, level, "\n%s %d %s\n%s", (const char*)response->GetProtocol(), response->GetStatusCode(), (const char*)response->GetReasonPhrase(), (const char*)stream->GetString()); return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | PLT_CtrlPointGetDescriptionTask::ProcessResponse +---------------------------------------------------------------------*/ NPT_Result PLT_SsdpSearchTask::ProcessResponse(NPT_Result res, NPT_HttpRequest* request, const NPT_HttpRequestContext& context, NPT_HttpResponse* response) { NPT_COMPILER_UNUSED(request); return m_Listener->ProcessSsdpSearchResponse(res, context, response); }
/*---------------------------------------------------------------------- | PLT_CtrlPointGetSCPDTask::ProcessResponse +---------------------------------------------------------------------*/ NPT_Result PLT_CtrlPointGetSCPDTask::ProcessResponse(NPT_Result res, NPT_HttpRequest* request, const NPT_HttpRequestContext& context, NPT_HttpResponse* response) { NPT_COMPILER_UNUSED(context); return m_CtrlPoint->ProcessGetSCPDResponse(res, request, response, m_Device); }
/*---------------------------------------------------------------------- | PLT_CtrlPointGetDescriptionTask::ProcessResponse +---------------------------------------------------------------------*/ NPT_Result PLT_CtrlPointGetDescriptionTask::ProcessResponse(NPT_Result res, NPT_HttpRequest* request, const NPT_HttpRequestContext& context, NPT_HttpResponse* response) { NPT_COMPILER_UNUSED(request); return m_CtrlPoint->ProcessGetDescriptionResponse(res, context, response, m_RootDevice); }
/*---------------------------------------------------------------------- | PLT_Downloader::ProcessResponse +---------------------------------------------------------------------*/ NPT_Result PLT_Downloader::ProcessResponse(NPT_Result res, const NPT_HttpRequest& request, const NPT_HttpRequestContext& context, NPT_HttpResponse* response) { NPT_COMPILER_UNUSED(request); NPT_COMPILER_UNUSED(context); if (NPT_FAILED(res)) { NPT_LOG_WARNING_2("Downloader error %d for %s", res, m_URL.ToString().GetChars()); m_State = PLT_DOWNLOADER_ERROR; return res; } m_State = PLT_DOWNLOADER_DOWNLOADING; NPT_HttpEntity* entity; NPT_InputStreamReference body; if (!response || !(entity = response->GetEntity()) || NPT_FAILED(entity->GetInputStream(body)) || body.IsNull()) { m_State = PLT_DOWNLOADER_ERROR; NPT_LOG_WARNING_2("No body %d for %s", res, m_URL.ToString().GetChars()); return NPT_FAILURE; } // Read body (no content length means until socket is closed) res = NPT_StreamToStreamCopy(*body.AsPointer(), *m_Output.AsPointer(), 0, entity->GetContentLength()); if (NPT_FAILED(res)) { NPT_LOG_WARNING_2("Downloader error %d for %s", res, m_URL.ToString().GetChars()); m_State = PLT_DOWNLOADER_ERROR; return res; } NPT_LOG_INFO_1("Finished downloading %s", m_URL.ToString().GetChars()); m_State = PLT_DOWNLOADER_SUCCESS; return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | PLT_HttpHelper::ToLog +---------------------------------------------------------------------*/ NPT_Result PLT_HttpHelper::ToLog(NPT_LoggerReference logger, int level, const char* prefix, const NPT_HttpRequest& request) { NPT_COMPILER_UNUSED(logger); NPT_COMPILER_UNUSED(level); NPT_StringOutputStreamReference stream(new NPT_StringOutputStream); NPT_OutputStreamReference output = stream; request.GetHeaders().GetHeaders().Apply(NPT_HttpHeaderPrinter(output)); NPT_LOG_L5(logger, level, "%s\n%s %s %s\n%s", prefix, (const char*)request.GetMethod(), (const char*)request.GetUrl().ToRequestString(true), (const char*)request.GetProtocol(), (const char*)stream->GetString()); return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | PLT_FileMediaServer::ProcessFileRequest +---------------------------------------------------------------------*/ NPT_Result PLT_FileMediaServer::ProcessFileRequest(NPT_HttpRequest& request, NPT_HttpResponse& response, NPT_SocketInfo& client_info) { NPT_COMPILER_UNUSED(client_info); NPT_LOG_FINE("PLT_FileMediaServer::ProcessFileRequest Received Request:"); PLT_LOG_HTTP_MESSAGE(NPT_LOG_LEVEL_FINE, &request); response.GetHeaders().SetHeader("Accept-Ranges", "bytes"); if (request.GetMethod().Compare("GET") && request.GetMethod().Compare("HEAD")) { response.SetStatus(500, "Internal Server Error"); return NPT_SUCCESS; } // File requested NPT_String path = m_FileBaseUri.GetPath(); NPT_String strUri = NPT_Uri::PercentDecode(request.GetUrl().GetPath()); NPT_HttpUrlQuery query(request.GetUrl().GetQuery()); NPT_String file_path = query.GetField("path"); // hack for XBMC support for 360, we urlencoded the ? to that the 360 doesn't strip out the query // but then the query ends being parsed as part of the path int index = strUri.Find("path="); if (index>0) file_path = strUri.Right(strUri.GetLength()-index-5); if (file_path.GetLength() == 0) goto failure; // HACK for wmp: somehow they inverse our slashes ! // do it only if we're on windows if (m_DirDelimiter == "\\") { file_path.Replace('/', '\\'); } if (path.Compare(strUri.Left(path.GetLength()), true) == 0) { NPT_Integer start, end; PLT_HttpHelper::GetRange(&request, start, end); return PLT_FileServer::ServeFile(m_Path + file_path, &response, start, end, !request.GetMethod().Compare("HEAD")); } // Album Art requested path = m_AlbumArtBaseUri.GetPath(); if (path.Compare(strUri.Left(path.GetLength()), true) == 0) { return OnAlbumArtRequest(m_Path + file_path, response); } failure: response.SetStatus(404, "File Not Found"); return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | main +---------------------------------------------------------------------*/ int main(int argc, char** argv) { NPT_COMPILER_UNUSED(argc); NPT_COMPILER_UNUSED(argv); printf("MessagesTest2:: start\n"); TestServer* server = new TestServer(); TestClient* client1 = new TestClient(server, 1); TestClient* client2 = new TestClient(server, 2); NPT_MessageQueue* queue = new NPT_SimpleMessageQueue(); client1->SetQueue(queue); client2->SetQueue(queue); server->Wait(); delete client1; delete client2; delete server; delete queue; printf("MessagesTest2:: end\n"); }
/*---------------------------------------------------------------------- | NPT_HttpResponse::ToLog +---------------------------------------------------------------------*/ NPT_Result PLT_HttpHelper::ToLog(NPT_LoggerReference logger, int level, const char* prefix, const NPT_HttpResponse& response) { NPT_COMPILER_UNUSED(logger); NPT_COMPILER_UNUSED(level); NPT_StringOutputStreamReference stream(new NPT_StringOutputStream); NPT_OutputStreamReference output = stream; response.GetHeaders().GetHeaders().Apply(NPT_HttpHeaderPrinter(output)); NPT_LOG_L5(logger, level, "%s\n%s %d %s\n%s", prefix, (const char*)response.GetProtocol(), response.GetStatusCode(), (const char*)response.GetReasonPhrase(), (const char*)stream->GetString()); return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | PLT_HttpHelper::ToLog +---------------------------------------------------------------------*/ NPT_Result PLT_HttpHelper::ToLog(NPT_LoggerReference logger, int level, NPT_HttpRequest* request) { NPT_COMPILER_UNUSED(logger); NPT_COMPILER_UNUSED(level); if (!request) { NPT_LOG_L(logger, level, "NULL HTTP Request!"); return NPT_FAILURE; } NPT_StringOutputStreamReference stream(new NPT_StringOutputStream); NPT_OutputStreamReference output = stream; request->GetHeaders().GetHeaders().Apply(NPT_HttpHeaderPrinter(output)); NPT_LOG_L4(logger, level, "\n%s %s %s\n%s", (const char*)request->GetMethod(), (const char*)request->GetUrl().ToRequestString(true), (const char*)request->GetProtocol(), (const char*)stream->GetString()); return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | NPT_HttpResponse::ToLog +---------------------------------------------------------------------*/ NPT_Result PLT_HttpHelper::ToLog(NPT_LoggerReference logger, int level, NPT_HttpResponse* response) { NPT_COMPILER_UNUSED(logger); NPT_COMPILER_UNUSED(level); if (!response) { NPT_LOG_L(logger, level, "NULL HTTP Response!"); return NPT_FAILURE; } NPT_StringOutputStreamReference stream(new NPT_StringOutputStream); NPT_OutputStreamReference output = stream; response->GetHeaders().GetHeaders().Apply(NPT_HttpHeaderPrinter(output)); NPT_LOG_L4(logger, level, "\n%s %d %s\n%s", (const char*)response->GetProtocol(), response->GetStatusCode(), (const char*)response->GetReasonPhrase(), (const char*)stream->GetString()); return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | PLT_MediaConnect::OnRegisterDevice +---------------------------------------------------------------------*/ NPT_Result PLT_MediaConnect::OnRegisterDevice(PLT_ActionReference& action, PLT_MediaConnectInfo* mc_info) { NPT_COMPILER_UNUSED(mc_info); NPT_String reqMsgBase64; action->GetArgumentValue("RegistrationReqMsg", reqMsgBase64); NPT_String respMsgBase64; action->SetArgumentValue("RegistrationRespMsg", respMsgBase64); return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | PLT_Downloader::ProcessResponse +---------------------------------------------------------------------*/ NPT_Result PLT_Downloader::ProcessResponse(NPT_Result res, NPT_HttpRequest* request, const NPT_HttpRequestContext& context, NPT_HttpResponse* response) { NPT_COMPILER_UNUSED(request); NPT_COMPILER_UNUSED(context); if (NPT_FAILED(res)) { m_State = PLT_DOWNLOADER_ERROR; return res; } m_State = PLT_DOWNLOADER_DOWNLOADING; NPT_HttpEntity* entity; NPT_InputStreamReference body; if (!response || !(entity = response->GetEntity()) || NPT_FAILED(entity->GetInputStream(body)) || body.IsNull()) { m_State = PLT_DOWNLOADER_ERROR; return NPT_FAILURE; } // Read body (no content length means until socket is closed) res = NPT_StreamToStreamCopy(*body.AsPointer(), *m_Output.AsPointer(), 0, entity->GetContentLength()); if (NPT_FAILED(res)) { m_State = PLT_DOWNLOADER_ERROR; return res; } m_State = PLT_DOWNLOADER_SUCCESS; return NPT_SUCCESS; }
/*---------------------------------------------------------------------- | PLT_SsdpListenTask::SetupResponse +---------------------------------------------------------------------*/ NPT_Result PLT_SsdpListenTask::SetupResponse(NPT_HttpRequest& request, const NPT_HttpRequestContext& context, NPT_HttpResponse& response) { NPT_COMPILER_UNUSED(response); NPT_AutoLock lock(m_Mutex); m_Listeners.Apply(PLT_SsdpPacketListenerIterator(request, context)); // return error since we don't have anything to respond // as we use a separate task to respond with ssdp return NPT_ERROR_TERMINATED; }