/*----------------------------------------------------------------------
| CUPnP::CUPnP
+---------------------------------------------------------------------*/
CUPnP::CUPnP() :
m_MediaBrowser(NULL),
m_MediaController(NULL),
m_LogHandler(NULL),
m_ServerHolder(new CDeviceHostReferenceHolder()),
m_RendererHolder(new CRendererReferenceHolder()),
m_CtrlPointHolder(new CCtrlPointReferenceHolder())
{
NPT_LogManager::GetDefault().Configure("plist:.level=FINE;.handlers=CustomHandler;");
NPT_LogHandler::Create("xbmc", "CustomHandler", m_LogHandler);
m_LogHandler->SetCustomHandlerFunction(&UPnPLogger);
// initialize upnp context
m_UPnP = new PLT_UPnP();
// keep main IP around
if (g_application.getNetwork().GetFirstConnectedInterface()) {
m_IP = g_application.getNetwork().GetFirstConnectedInterface()->GetCurrentIPAddress().c_str();
}
NPT_List<NPT_IpAddress> list;
if (NPT_SUCCEEDED(PLT_UPnPMessageHelper::GetIPAddresses(list)) && list.GetItemCount()) {
m_IP = (*(list.GetFirstItem())).ToString();
}
else if(m_IP.empty())
m_IP = "localhost";
// start upnp monitoring
m_UPnP->Start();
}
/*----------------------------------------------------------------------
| CUPnP::StartRenderer
+---------------------------------------------------------------------*/
void CUPnP::StartRenderer()
{
if (!m_RendererHolder->m_Device.IsNull()) return;
CStdString filename;
URIUtils::AddFileToFolder(CProfilesManager::Get().GetUserDataFolder(), "upnpserver.xml", filename);
CUPnPSettings::Get().Load(filename);
m_RendererHolder->m_Device = CreateRenderer(CUPnPSettings::Get().GetRendererPort());
NPT_Result res = m_UPnP->AddDevice(m_RendererHolder->m_Device);
// failed most likely because port is in use, try again with random port now
if (NPT_FAILED(res) && CUPnPSettings::Get().GetRendererPort() != 0) {
m_RendererHolder->m_Device = CreateRenderer(0);
res = m_UPnP->AddDevice(m_RendererHolder->m_Device);
}
// save port but don't overwrite saved settings if random
if (NPT_SUCCEEDED(res) && CUPnPSettings::Get().GetRendererPort() == 0) {
CUPnPSettings::Get().SetRendererPort(m_RendererHolder->m_Device->GetPort());
}
// save UUID
CUPnPSettings::Get().SetRendererUUID(m_RendererHolder->m_Device->GetUUID().GetChars());
CUPnPSettings::Get().Save(filename);
}
/*----------------------------------------------------------------------
| CMediaCrawler::ProcessFileRequest
+---------------------------------------------------------------------*/
NPT_Result
CMediaCrawler::ProcessFileRequest(NPT_HttpRequest& request,
const NPT_HttpRequestContext& context,
NPT_HttpResponse& response)
{
NPT_COMPILER_UNUSED(context);
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;
}
/*----------------------------------------------------------------------
| NPT_LogManager::ConfigureLogger
+---------------------------------------------------------------------*/
NPT_Result
NPT_LogManager::ConfigureLogger(NPT_Logger* logger)
{
/* configure the level */
NPT_String* level_value = GetConfigValue(logger->m_Name,".level");
if (level_value) {
NPT_Int32 value;
/* try a symbolic name */
value = NPT_Log::GetLogLevel(*level_value);
if (value < 0) {
/* try a numeric value */
if (NPT_FAILED(level_value->ToInteger(value, false))) {
value = -1;
}
}
if (value >= 0) {
logger->m_Level = value;
logger->m_LevelIsInherited = false;
}
}
/* remove any existing handlers */
logger->DeleteHandlers();
/* configure the handlers */
NPT_String* handlers = GetConfigValue(logger->m_Name,".handlers");
if (handlers) {
const char* handlers_list = handlers->GetChars();
const char* cursor = handlers_list;
const char* name_start = handlers_list;
NPT_String handler_name;
NPT_LogHandler* handler;
for (;;) {
if (*cursor == '\0' || *cursor == ',') {
if (cursor != name_start) {
handler_name.Assign(name_start, (NPT_Size)(cursor-name_start));
handler_name.Trim(" \t");
/* create a handler */
if (NPT_SUCCEEDED(
NPT_LogHandler::Create(logger->m_Name, handler_name, handler))) {
logger->AddHandler(handler);
}
}
if (*cursor == '\0') break;
name_start = cursor+1;
}
++cursor;
}
}
/* configure the forwarding */
NPT_String* forward = GetConfigValue(logger->m_Name,".forward");
if (forward && !ConfigValueIsBooleanTrue(*forward)) {
logger->m_ForwardToParent = false;
}
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| NPT_LogTcpHandler::Create
+---------------------------------------------------------------------*/
NPT_Result
NPT_LogTcpHandler::Create(const char* logger_name, NPT_LogHandler*& handler)
{
/* compute a prefix for the configuration of this handler */
NPT_String logger_prefix = logger_name;
logger_prefix += ".TcpHandler";
/* allocate a new object */
NPT_LogTcpHandler* instance = new NPT_LogTcpHandler();
handler = instance;
/* configure the object */
const NPT_String* hostname = LogManager.GetConfigValue(logger_prefix, ".hostname");
if (hostname) {
instance->m_Host = *hostname;
} else {
/* default hostname */
instance->m_Host = "localhost";
}
const NPT_String* port = LogManager.GetConfigValue(logger_prefix, ".port");
if (port) {
NPT_UInt32 port_int;
if (NPT_SUCCEEDED(port->ToInteger(port_int, true))) {
instance->m_Port = (NPT_UInt16)port_int;
} else {
instance->m_Port = NPT_LOG_TCP_HANDLER_DEFAULT_PORT;
}
} else {
/* default port */
instance->m_Port = NPT_LOG_TCP_HANDLER_DEFAULT_PORT;
}
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_FileMediaServer::GetEntryCount
+---------------------------------------------------------------------*/
NPT_Result
PLT_FileMediaServer::GetEntryCount(const char* path, NPT_Cardinal& count)
{
NPT_String dir_path = path;
// reset output params
count = 0;
// ensure path ends with a delimiter
if (!dir_path.EndsWith(m_DirDelimiter)) {
dir_path += m_DirDelimiter;
}
NPT_Directory directory(dir_path);
NPT_String entryName;
NPT_Result res = directory.GetNextEntry(entryName);
if (NPT_FAILED(res)) {
NPT_LOG_WARNING_1("PLT_FileMediaServer::OnBrowseDirectChildren - failed to open dir %s", (const char*) path);
return res;
}
do {
/* Check if the item would be ok to add to a didl */
// NPT_Reference<PLT_MediaObject> item(BuildFromFilePath(dir_path + entryName, false));
// if (!item.IsNull()) {
// count++;
// }
NPT_DirectoryEntryInfo info;
if (ProceedWithEntry(dir_path + entryName, info)) count++;
res = directory.GetNextEntry(entryName);
} while (NPT_SUCCEEDED(res));
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_HttpServer::ServeFile
+---------------------------------------------------------------------*/
NPT_Result
PLT_HttpServer::ServeFile(const NPT_HttpRequest& request,
const NPT_HttpRequestContext& context,
NPT_HttpResponse& response,
NPT_String file_path)
{
NPT_InputStreamReference stream;
NPT_File file(file_path);
NPT_FileInfo file_info;
// prevent hackers from accessing files outside of our root
if ((file_path.Find("/..") >= 0) || (file_path.Find("\\..") >= 0) ||
NPT_FAILED(NPT_File::GetInfo(file_path, &file_info))) {
return NPT_ERROR_NO_SUCH_ITEM;
}
// check for range requests
const NPT_String* range_spec = request.GetHeaders().GetHeaderValue(NPT_HTTP_HEADER_RANGE);
// handle potential 304 only if range header not set
NPT_DateTime date;
NPT_TimeStamp timestamp;
if (NPT_SUCCEEDED(PLT_UPnPMessageHelper::GetIfModifiedSince((NPT_HttpMessage&)request, date)) &&
!range_spec) {
date.ToTimeStamp(timestamp);
NPT_LOG_INFO_5("File %s timestamps: request=%d (%s) vs file=%d (%s)",
(const char*)request.GetUrl().GetPath(),
(NPT_UInt32)timestamp.ToSeconds(),
(const char*)date.ToString(),
(NPT_UInt32)file_info.m_ModificationTime,
(const char*)NPT_DateTime(file_info.m_ModificationTime).ToString());
if (timestamp >= file_info.m_ModificationTime) {
// it's a match
NPT_LOG_FINE_1("Returning 304 for %s", request.GetUrl().GetPath().GetChars());
response.SetStatus(304, "Not Modified", NPT_HTTP_PROTOCOL_1_1);
return NPT_SUCCESS;
}
}
// open file
if (NPT_FAILED(file.Open(NPT_FILE_OPEN_MODE_READ)) ||
NPT_FAILED(file.GetInputStream(stream)) ||
stream.IsNull()) {
return NPT_ERROR_NO_SUCH_ITEM;
}
// set Last-Modified and Cache-Control headers
if (file_info.m_ModificationTime) {
NPT_DateTime last_modified = NPT_DateTime(file_info.m_ModificationTime);
response.GetHeaders().SetHeader("Last-Modified", last_modified.ToString(NPT_DateTime::FORMAT_RFC_1123), true);
response.GetHeaders().SetHeader("Cache-Control", "max-age=0,must-revalidate", true);
//response.GetHeaders().SetHeader("Cache-Control", "max-age=1800", true);
}
PLT_HttpRequestContext tmp_context(request, context);
return ServeStream(request, context, response, stream, PLT_MimeType::GetMimeType(file_path, &tmp_context));
}
/*----------------------------------------------------------------------
| BtPlayerServer::Run
+---------------------------------------------------------------------*/
void
BtPlayerServer::Run()
{
NPT_Result result;
do {
result = m_Player.PumpMessage();
} while (NPT_SUCCEEDED(result));
}
/*----------------------------------------------------------------------
| PLT_MicroMediaController::PopDirectoryStackToRoot
+---------------------------------------------------------------------*/
void
PLT_MicroMediaController::PopDirectoryStackToRoot(void)
{
NPT_String val;
while (NPT_SUCCEEDED(m_CurBrowseDirectoryStack.Peek(val)) && val.Compare("0")) {
m_CurBrowseDirectoryStack.Pop(val);
}
}
const Object *RootContainer::findObject(const NPT_String& id) const
{
Object **obj;
if (NPT_SUCCEEDED(m_objectMap.Get(id, obj))) {
return *obj;
}
return NULL;
}
/*----------------------------------------------------------------------
| PLT_DeviceData::SetDescription
+---------------------------------------------------------------------*/
NPT_Result
PLT_DeviceData::SetDescription(PLT_DeviceDataReference& root_device,
NPT_TimeInterval leasetime,
NPT_HttpUrl description_url,
const char* description,
const NPT_HttpRequestContext& context)
{
NPT_XmlParser parser;
NPT_XmlNode* tree = NULL;
NPT_Result res;
NPT_XmlElementNode* root = NULL;
NPT_String URLBase;
// create new device if none passed
if (root_device.IsNull()) {
root_device = new PLT_DeviceData(description_url, "", leasetime);
}
res = parser.Parse(description, tree);
NPT_CHECK_LABEL_SEVERE(res, cleanup);
root = tree->AsElementNode();
if (!root ||
root->GetTag() != "root" ||
!root->GetNamespace() ||
*root->GetNamespace() != "urn:schemas-upnp-org:device-1-0") {
NPT_LOG_INFO_1("root namespace is invalid: %s",
(root&&root->GetNamespace())?root->GetNamespace()->GetChars():"null");
NPT_CHECK_LABEL_SEVERE(NPT_FAILURE, cleanup);
}
// look for optional URLBase element
if (NPT_SUCCEEDED(PLT_XmlHelper::GetChildText(root, "URLBase", URLBase))) {
NPT_HttpUrl url(URLBase);
// Some devices like Connect360 try to be funny - not so
if (url.GetHost().ToLowercase() == "localhost" ||
url.GetHost().ToLowercase() == "127.0.0.1") {
url.SetHost(context.GetRemoteAddress().GetIpAddress().ToString());
}
root_device->SetURLBase(url);
} else {
// No URLBase, derive from description url
root_device->SetURLBase(description_url);
}
// at least one root device child element is required
NPT_XmlElementNode* device;
if (!(device = PLT_XmlHelper::GetChild(root, "device"))) {
NPT_CHECK_LABEL_SEVERE(NPT_FAILURE, cleanup);
}
res = SetDescriptionDevice(root_device, device, context);
cleanup:
// delete the tree
delete tree;
return res;
}
/*----------------------------------------------------------------------
| NPT_DirectoryRemove
+---------------------------------------------------------------------*/
NPT_Result
NPT_DirectoryRemove(const char* path, bool recursively)
{
NPT_Result res;
NPT_DirectoryEntryInfo info;
NPT_String root_path = path;
// replace delimiters with the proper one for the platform
root_path.Replace((NPT_DIR_DELIMITER_CHR == '/')?'\\':'/', NPT_DIR_DELIMITER_CHR);
// remove excessive delimiters
root_path.TrimRight(NPT_DIR_DELIMITER_CHR);
NPT_CHECK_WARNING(NPT_DirectoryEntry::GetInfo(root_path, &info));
if (info.type == NPT_FILE_TYPE || !recursively) {
return NPT_Directory::Remove(root_path);
}
{
// enumerate all entries
NPT_Directory dir(path);
NPT_String entry_path;
NPT_String name;
do {
res = dir.GetNextEntry(name, &info);
if (NPT_SUCCEEDED(res)) {
// build full path to entry
entry_path = root_path;
// append filename
NPT_DirectoryAppendToPath(entry_path, name);
// try to remove entry recursively
res = NPT_DirectoryRemove(entry_path, true);
}
} while (NPT_SUCCEEDED(res));
}
// if no more items in directory, try to delete it
if (res == NPT_ERROR_NO_SUCH_ITEM) {
return NPT_Directory::Remove(path);
}
return res;
}
void FrontEnd::SsdpBroadcastTask::exec()
{
while (!aborted()) {
if (NPT_SUCCEEDED(m_waitVar.WaitWhileEquals(0, 5000))) {
break;
}
m_owner->broadcastIfNecessary();
}
}
/*----------------------------------------------------------------------
| PLT_DeviceData::FindServiceByEventSubURI
+---------------------------------------------------------------------*/
NPT_Result
PLT_DeviceData::FindServiceByEventSubURI(const char* uri,
PLT_Service*& service)
{
if (NPT_SUCCEEDED(NPT_ContainerFind(m_Services,
PLT_ServiceEventSubURLFinder(uri),
service))) {
return NPT_SUCCESS;
}
for (int i=0; i < (int)m_EmbeddedDevices.GetItemCount(); i++) {
if (NPT_SUCCEEDED(NPT_ContainerFind(m_EmbeddedDevices[i]->m_Services,
PLT_ServiceEventSubURLFinder(uri),
service)))
return NPT_SUCCESS;
}
return NPT_FAILURE;
}
/*----------------------------------------------------------------------
| PLT_MediaBrowser::OnDeviceAdded
+---------------------------------------------------------------------*/
NPT_Result
PLT_MediaBrowser::OnDeviceAdded(PLT_DeviceDataReference& device)
{
// verify the device implements the function we need
PLT_Service* serviceCDS;
PLT_Service* serviceCMR;
NPT_String type;
if (!device->GetType().StartsWith("urn:schemas-upnp-org:device:MediaServer"))
return NPT_FAILURE;
type = "urn:schemas-upnp-org:service:ContentDirectory:*";
if (NPT_FAILED(device->FindServiceByType(type, serviceCDS))) {
NPT_LOG_WARNING_2("Service %s not found in device \"%s\"",
type.GetChars(),
device->GetFriendlyName().GetChars());
return NPT_FAILURE;
} else {
// in case it's a newer upnp implementation, force to 1
serviceCDS->ForceVersion(1);
}
type = "urn:schemas-upnp-org:service:ConnectionManager:*";
if (NPT_FAILED(device->FindServiceByType(type, serviceCMR))) {
NPT_LOG_WARNING_2("Service %s not found in device \"%s\"",
type.GetChars(),
device->GetFriendlyName().GetChars());
return NPT_FAILURE;
} else {
// in case it's a newer upnp implementation, force to 1
serviceCMR->ForceVersion(1);
}
{
NPT_AutoLock lock(m_MediaServers);
PLT_DeviceDataReference data;
NPT_String uuid = device->GetUUID();
// is it a new device?
if (NPT_SUCCEEDED(NPT_ContainerFind(m_MediaServers, PLT_DeviceDataFinder(uuid), data))) {
NPT_LOG_WARNING_1("Device (%s) is already in our list!", (const char*)uuid);
return NPT_FAILURE;
}
NPT_LOG_FINE_1("Device Found: %s", (const char*)*device);
m_MediaServers.Add(device);
}
if (m_Delegate && m_Delegate->OnMSAdded(device)) {
m_CtrlPoint->Subscribe(serviceCDS);
m_CtrlPoint->Subscribe(serviceCMR);
}
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| NPT_File::Rename
+---------------------------------------------------------------------*/
NPT_Result
NPT_File::Rename(const char* path)
{
NPT_Result result = Rename(m_Path.GetChars(), path);
if (NPT_SUCCEEDED(result)) {
m_Path = path;
}
return result;
}
/*----------------------------------------------------------------------
| PLT_DeviceData::FindEmbeddedDeviceByType
+---------------------------------------------------------------------*/
NPT_Result
PLT_DeviceData::FindEmbeddedDeviceByType(const char* type,
PLT_DeviceDataReference& device)
{
NPT_Result res = NPT_ContainerFind(m_EmbeddedDevices,
PLT_DeviceDataFinderByType(type),
device);
if (NPT_SUCCEEDED(res)) return res;
for (int i=0; i<(int)m_EmbeddedDevices.GetItemCount(); i++) {
res = m_EmbeddedDevices[i]->FindEmbeddedDeviceByType(
type,
device);
if (NPT_SUCCEEDED(res)) return res;
}
return NPT_FAILURE;
}
/*----------------------------------------------------------------------
| PLT_MicroMediaController::HandleCmd_pwd
+---------------------------------------------------------------------*/
void
PLT_MicroMediaController::HandleCmd_pwd()
{
NPT_Stack<NPT_String> tempStack;
NPT_String val;
while (NPT_SUCCEEDED(m_CurBrowseDirectoryStack.Peek(val))) {
m_CurBrowseDirectoryStack.Pop(val);
tempStack.Push(val);
}
while (NPT_SUCCEEDED(tempStack.Peek(val))) {
tempStack.Pop(val);
printf("%s/", (const char*)val);
m_CurBrowseDirectoryStack.Push(val);
}
printf("\n");
}
/*----------------------------------------------------------------------
| PLT_MicroMediaController::HandleCmd_open
+---------------------------------------------------------------------*/
void
PLT_MicroMediaController::HandleCmd_open()
{
NPT_String object_id;
PLT_StringMap tracks;
PLT_DeviceDataReference device;
GetCurMediaRenderer(device);
if (!device.IsNull()) {
// get the protocol info to try to see in advance if a track would play on the device
// issue a browse
DoBrowse();
if (!m_MostRecentBrowseResults.IsNull()) {
// create a map item id -> item title
NPT_List<PLT_MediaObject*>::Iterator item = m_MostRecentBrowseResults->GetFirstItem();
while (item) {
if (!(*item)->IsContainer()) {
tracks.Put((*item)->m_ObjectID, (*item)->m_Title);
}
++item;
}
// let the user choose which one
object_id = ChooseIDFromTable(tracks);
if (object_id.GetLength()) {
// look back for the PLT_MediaItem in the results
PLT_MediaObject* track = NULL;
if (NPT_SUCCEEDED(NPT_ContainerFind(*m_MostRecentBrowseResults, PLT_MediaItemIDFinder(object_id), track))) {
if (track->m_Resources.GetItemCount() > 0) {
// look for best resource to use by matching each resource to a sink advertised by renderer
NPT_Cardinal resource_index = 0;
if (NPT_FAILED(FindBestResource(device, *track, resource_index))) {
printf("No matching resource\n");
return;
}
// invoke the setUri
printf("Issuing SetAVTransportURI with url=%s & didl=%s",
(const char*)track->m_Resources[resource_index].m_Uri,
(const char*)track->m_Didl);
SetAVTransportURI(device, 0, track->m_Resources[resource_index].m_Uri, track->m_Didl, NULL);
} else {
printf("Couldn't find the proper resource\n");
}
} else {
printf("Couldn't find the track\n");
}
}
m_MostRecentBrowseResults = NULL;
}
}
}
/*----------------------------------------------------------------------
| NPT_SelectableMessageQueue::PumpMessage
+---------------------------------------------------------------------*/
NPT_Result
NPT_SelectableMessageQueue::PumpMessage(bool blocking)
{
NPT_Result result = NPT_SimpleMessageQueue::PumpMessage(blocking);
if (NPT_SUCCEEDED(result)) {
// flush the event
FlushEvent();
}
return result;
}
/*----------------------------------------------------------------------
| CUPnPRenderer::Announce
+---------------------------------------------------------------------*/
void
CUPnPRenderer::Announce(AnnouncementFlag flag, const char *sender, const char *message, const std::string& json_data)
{
if (strcmp(sender, "xbmc") != 0)
return;
NPT_AutoLock lock(m_state);
//PLT_Service *avt, *rct;
#if 1
#else
if (flag == Player) {
if (NPT_FAILED(FindServiceByType("urn:schemas-upnp-org:service:AVTransport:1", avt)))
return;
if (strcmp(message, "OnPlay") == 0) {
avt->SetStateVariable("AVTransportURI", CApplication::getInstance().CurrentFile().c_str());
avt->SetStateVariable("CurrentTrackURI", g_application.CurrentFile().c_str());
NPT_String meta;
if (NPT_SUCCEEDED(GetMetadata(meta))) {
avt->SetStateVariable("CurrentTrackMetadata", meta);
avt->SetStateVariable("AVTransportURIMetaData", meta);
}
avt->SetStateVariable("TransportPlaySpeed", NPT_String::FromInteger(data["speed"].asInteger()));
avt->SetStateVariable("TransportState", "PLAYING");
/* this could be a transition to next track, so clear next */
avt->SetStateVariable("NextAVTransportURI", "");
avt->SetStateVariable("NextAVTransportURIMetaData", "");
}
else if (strcmp(message, "OnPause") == 0) {
avt->SetStateVariable("TransportPlaySpeed", NPT_String::FromInteger(data["speed"].asInteger()));
avt->SetStateVariable("TransportState", "PAUSED_PLAYBACK");
}
else if (strcmp(message, "OnSpeedChanged") == 0) {
avt->SetStateVariable("TransportPlaySpeed", NPT_String::FromInteger(data["speed"].asInteger()));
}
}
else if (flag == Application && strcmp(message, "OnVolumeChanged") == 0) {
if (NPT_FAILED(FindServiceByType("urn:schemas-upnp-org:service:RenderingControl:1", rct)))
return;
CStdString buffer;
buffer.Format("%ld", data["volume"].asInteger());
rct->SetStateVariable("Volume", buffer.c_str());
buffer.Format("%ld", 256 * (data["volume"].asInteger() * 60 - 60) / 100);
rct->SetStateVariable("VolumeDb", buffer.c_str());
rct->SetStateVariable("Mute", data["muted"].asBoolean() ? "1" : "0");
}
#endif
}
/*----------------------------------------------------------------------
| main
+---------------------------------------------------------------------*/
int
main(int /*argc*/, char** /*argv*/)
{
// setup debugging
#if defined(WIN32) && defined(_DEBUG)
int flags = _crtDbgFlag |
_CRTDBG_ALLOC_MEM_DF |
_CRTDBG_DELAY_FREE_MEM_DF |
_CRTDBG_CHECK_ALWAYS_DF;
_CrtSetDbgFlag(flags);
//AllocConsole();
//freopen("CONOUT$", "w", stdout);
#endif
NPT_IpAddress addr;
NPT_Result result;
result = addr.ResolveName("www.perdu.com");
CHECK(NPT_SUCCEEDED(result));
Resolver resolver1("www.perdu.com", addr);
result = addr.ResolveName("zebulon.bok.net");
CHECK(NPT_SUCCEEDED(result));
Resolver resolver2("zebulon.bok.net", addr);
resolver1.Start();
resolver2.Start();
NPT_System::Sleep(10.0);
NeedToStop = true;
resolver1.Wait();
resolver2.Wait();
#if defined(WIN32) && defined(_DEBUG)
_CrtDumpMemoryLeaks();
#endif
return 0;
}
/*----------------------------------------------------------------------
| PLT_HttpServer::Start
+---------------------------------------------------------------------*/
NPT_Result
PLT_HttpServer::Start()
{
NPT_Result res = NPT_FAILURE;
// we can't restart an aborted server
if (m_Aborted) return NPT_ERROR_INVALID_STATE;
// if we're given a port for our http server, try it
if (m_Port) {
res = SetListenPort(m_Port, m_ReuseAddress);
// return right away if failed and not allowed to try again randomly
if (NPT_FAILED(res) && !m_AllowRandomPortOnBindFailure) {
NPT_CHECK_SEVERE(res);
}
}
// try random port now
if (!m_Port || NPT_FAILED(res)) {
int retries = 100;
do {
int random = NPT_System::GetRandomInteger();
int port = (unsigned short)(1024 + (random % 1024));
if (NPT_SUCCEEDED(SetListenPort(port, m_ReuseAddress))) {
break;
}
} while (--retries > 0);
if (retries == 0) NPT_CHECK_SEVERE(NPT_FAILURE);
}
// keep track of port server has successfully bound
m_Port = m_BoundPort;
// Tell server to try to listen to more incoming sockets
// (this could fail silently)
if (m_TaskManager->GetMaxTasks() > 20) {
m_Socket.Listen(m_TaskManager->GetMaxTasks());
}
// start a task to listen for incoming connections
// and keep it around so we can abort the server
m_HttpListenTask = new PLT_HttpListenTask(this, &m_Socket, false);
m_TaskManager->StartTask(m_HttpListenTask, NULL, false);
NPT_SocketInfo info;
m_Socket.GetInfo(info);
NPT_LOG_INFO_2("HttpServer listening on %s:%d",
(const char*)info.local_address.GetIpAddress().ToString(),
m_Port);
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| NPT_BufferedInputStream::GetAvailable
+---------------------------------------------------------------------*/
NPT_Result
NPT_BufferedInputStream::GetAvailable(NPT_LargeSize& available)
{
NPT_LargeSize source_available = 0;
NPT_Result result = m_Source->GetAvailable(source_available);
if (NPT_SUCCEEDED(result)) {
available = m_Buffer.valid-m_Buffer.offset + source_available;
return NPT_SUCCESS;
} else {
available = m_Buffer.valid-m_Buffer.offset;
return available?NPT_SUCCESS:result;
}
}
/*----------------------------------------------------------------------
| PLT_DeviceData::FindServiceByEventSubURL
+---------------------------------------------------------------------*/
NPT_Result
PLT_DeviceData::FindServiceByEventSubURL(const char* url,
PLT_Service*& service,
bool recursive /* = false */)
{
NPT_Result res = NPT_ContainerFind(m_Services,
PLT_ServiceEventSubURLFinder(url),
service);
if (NPT_SUCCEEDED(res)) return res;
if (recursive) {
for (int i=0; i<(int)m_EmbeddedDevices.GetItemCount(); i++) {
res = m_EmbeddedDevices[i]->FindServiceByEventSubURL(
url,
service,
recursive);
if (NPT_SUCCEEDED(res)) return res;
}
}
return NPT_FAILURE;
}
/*----------------------------------------------------------------------
| OZN_Database::CheckTableSchema
+---------------------------------------------------------------------*/
NPT_Result
OZN_Database::CheckTableSchema(const OZN_TableDescription& desc)
{
NPT_Result res = NPT_FAILURE;
NPT_String sql;
NPT_String sql_create;
OZN_StringProperty schema(0, "");
const char* result;
// generate the sql statement we would use to create the table
NPT_CHECK(OZN_Sql::CreateTable(desc, sql_create));
// generate the sql statement to query for a table schema
NPT_CHECK(OZN_Sql::GetTableSchema(desc.name, sql));
// query the db, if the table doesn't exist it will fail
res = ExecuteScalar(sql, schema);
result = schema.GetValue().string;
if (NPT_SUCCEEDED(res) && result && result[0] != '\0') {
//if existing table schema sql matches the one we would use
// then it is the same table and same schema version
if (NPT_StringsEqual(result, sql_create)) {
return NPT_SUCCESS;
}
// weird, the query succeeded but returned nothing
return NPT_FAILURE;
}
// close bracket
OZN_Sql::Close(sql_create);
// table doesn't exist, create it
NPT_CHECK(ExecuteDML(sql_create, NULL));
if (desc.unique_index_ids_count && desc.unique_index_ids) {
res = OZN_Sql::CreateUniqueIndex(desc,
desc.unique_index_ids,
desc.unique_index_ids_count,
sql);
NPT_CHECK(res);
// close bracket
OZN_Sql::Close(sql);
// create unique index
NPT_CHECK(ExecuteDML(sql, NULL));
}
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_MicroMediaController::OnMRAdded
+---------------------------------------------------------------------*/
bool
PLT_MicroMediaController::OnMRAdded(PLT_DeviceDataReference& device)
{
NPT_String uuid = device->GetUUID();
// test if it's a media renderer
PLT_Service* service;
if (NPT_SUCCEEDED(device->FindServiceByType("urn:schemas-upnp-org:service:AVTransport:*", service))) {
NPT_AutoLock lock(m_MediaRenderers);
m_MediaRenderers.Put(uuid, device);
}
return true;
}
/*----------------------------------------------------------------------
| PLT_SyncMediaBrowser::OnDeviceAdded
+---------------------------------------------------------------------*/
NPT_Result
PLT_SyncMediaBrowser::OnDeviceAdded(PLT_DeviceDataReference& device)
{
NPT_String uuid = device->GetUUID();
// test if it's a media server
PLT_Service* service;
if (NPT_SUCCEEDED(device->FindServiceByType("urn:schemas-upnp-org:service:ContentDirectory:*", service))) {
NPT_AutoLock lock(m_MediaServers);
m_MediaServers.Put(uuid, device);
}
return PLT_MediaBrowser::OnDeviceAdded(device);
}
/*----------------------------------------------------------------------
| PLT_SyncMediaBrowser::IsCached
+---------------------------------------------------------------------*/
bool
PLT_SyncMediaBrowser::IsCached(const char* uuid, const char* object_id)
{
NPT_AutoLock lock(m_MediaServers);
const NPT_List<PLT_DeviceMapEntry*>::Iterator it =
m_MediaServers.GetEntries().Find(PLT_DeviceMapFinderByUUID(uuid));
if (!it) {
m_Cache.Clear(uuid);
return false; // device with this service has gone away
}
PLT_MediaObjectListReference list;
return NPT_SUCCEEDED(m_Cache.Get(uuid, object_id, list))?true:false;
}
/*----------------------------------------------------------------------
| TestAttributeNormalization
+---------------------------------------------------------------------*/
static void
TestAttributeNormalization()
{
const char* xml = "<x a='\n\n xyz abc 
 
 	   12\r\n3\r4\n5 6 '/>";
NPT_XmlParser parser;
NPT_XmlNode* root = NULL;
NPT_Result result = parser.Parse(xml, root);
CHECK(NPT_SUCCEEDED(result));
CHECK(root != NULL);
CHECK(root->AsElementNode() != NULL);
const NPT_String* a = root->AsElementNode()->GetAttribute("a");
CHECK(*a == " xyz abc \r \n \t 12 3 4 5 6 ");
delete root;
}
