/*----------------------------------------------------------------------
| 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;
}
