mUpnpDevice *upnp_clock_device_new()
{
mUpnpDevice *clockDev;
mUpnpService *timeService;
clockDev = mupnp_device_new();
if (mupnp_device_parsedescription(clockDev, CLOCK_DEVICE_DESCRIPTION, strlen(CLOCK_DEVICE_DESCRIPTION)) == FALSE) {
mupnp_device_delete(clockDev);
return NULL;
}
timeService = mupnp_device_getservicebyexacttype(clockDev, "urn:schemas-upnp-org:service:timer:1");
if (timeService == NULL) {
mupnp_device_delete(clockDev);
return NULL;
}
if (mupnp_service_parsedescription(timeService, CLOCK_SERVICE_DESCRIPTION, strlen(CLOCK_SERVICE_DESCRIPTION)) == FALSE) {
mupnp_device_delete(clockDev);
return NULL;
}
mupnp_device_setactionlistener(clockDev, upnp_clock_actionreceived);
mupnp_device_setquerylistener(clockDev, upnp_clock_queryreceived);
mupnp_device_sethttplistener(clockDev, upnp_clock_device_httprequestrecieved);
return clockDev;
}
void mupnp_controlpoint_removedevicebyssdppacket(mUpnpControlPoint *ctrlPoint, mUpnpSSDPPacket *ssdpPkt)
{
const char *usn;
char udn[MUPNP_UDN_LEN_MAX];
mUpnpDevice *dev;
MUPNP_DEVICE_LISTENER listener = mupnp_controlpoint_getdevicelistener(ctrlPoint);
mupnp_log_debug_l4("Entering...\n");
usn = mupnp_ssdp_packet_getusn(ssdpPkt);
mupnp_usn_getudn(usn, udn, sizeof(udn));
mupnp_controlpoint_lock(ctrlPoint);
dev = mupnp_controlpoint_getdevicebyudn(ctrlPoint, udn);
if (dev == NULL) {
mupnp_controlpoint_unlock(ctrlPoint);
return;
}
if (listener != NULL)
{
mupnp_controlpoint_unlock(ctrlPoint);
listener(ctrlPoint, udn, mUpnpDeviceStatusRemoved);
mupnp_controlpoint_lock(ctrlPoint);
}
mupnp_device_delete(dev);
mupnp_controlpoint_unlock(ctrlPoint);
mupnp_log_debug_l4("Leaving...\n");
}
static mUpnpDevice *mupnp_controlpoint_createdevicefromssdkpacket(mUpnpSSDPPacket *ssdpPkt)
{
const char *location;
mUpnpNetURL *url;
mUpnpDevice *dev;
bool parseSuccess;
mupnp_log_debug_l4("Entering...\n");
location = mupnp_ssdp_packet_getlocation(ssdpPkt);
if (mupnp_strlen(location) <= 0)
return NULL;
dev = mupnp_device_new();
url = mupnp_net_url_new();
mupnp_net_url_set(url, location);
parseSuccess = mupnp_device_parsedescriptionurl(dev, url);
if (parseSuccess) {
mupnp_device_sethttpport(dev, mupnp_net_url_getport(url));
}
mupnp_net_url_delete(url);
if (parseSuccess == false) {
mupnp_device_delete(dev);
return NULL;
}
mupnp_device_setssdppacket(dev, ssdpPkt);
#ifndef MUPNP_OPTIMIZED_CP_MODE
if (mupnp_controlpoint_parseservicesfordevice(dev, ssdpPkt) == false)
{
mupnp_device_delete(dev);
return NULL;
}
#endif
mupnp_log_debug_l4("Leaving...\n");
return dev;
}
RoundUpnpServer* round_upnp_server_new(void)
{
RoundUpnpServer* server = (RoundUpnpServer*)malloc(sizeof(RoundUpnpServer));
if (!server)
return NULL;
server->dev = mupnp_device_new();
if (!server->dev) {
round_upnp_server_delete(server);
return NULL;
}
// Setup UPnP Device
if (!mupnp_device_parsedescription(server->dev, ROUND_UPNP_SERVER_DEVICE_DESCRIPTION, strlen(ROUND_UPNP_SERVER_DEVICE_DESCRIPTION))) {
mupnp_device_delete(server->dev);
return NULL;
}
mUpnpService* upnpSrv = mupnp_device_getservicebyexacttype(server->dev, ROUND_UPNP_SERVICE_TYPE);
if (upnpSrv == NULL) {
mupnp_device_delete(server->dev);
return NULL;
}
if (!mupnp_service_parsedescription(upnpSrv, ROUND_UPNP_SERVER_SERVICE_DESCRIPTION, strlen(ROUND_UPNP_SERVER_SERVICE_DESCRIPTION))) {
mupnp_device_delete(server->dev);
return NULL;
}
mupnp_device_setactionlistener(server->dev, round_upnp_server_actionreceived);
mupnp_device_setquerylistener(server->dev, round_upnp_server_queryreceived);
mupnp_device_sethttplistener(server->dev, round_upnp_server_httprequestrecieved);
// Set Listener
round_upnp_server_setrpcrequestlistener(server, NULL);
return server;
}
bool round_upnp_server_delete(RoundUpnpServer* server)
{
if (!server)
return false;
round_upnp_server_stop(server);
mupnp_device_delete(server->dev);
free(server);
return true;
}
void mupnp_upnpav_dmr_delete(mUpnpAvRenderer *dmr)
{
if (dmr == NULL)
return;
if (dmr->mutex)
mupnp_mutex_delete(dmr->mutex);
if (dmr->protocolInfoList)
mupnp_upnpav_protocolinfolist_delete(dmr->protocolInfoList);
mupnp_device_delete(dmr->dev);
free(dmr);
}
void mupnp_upnpav_dms_delete(mUpnpAvServer *dms)
{
if (dms == NULL)
return;
if (dms->rootContent)
mupnp_upnpav_content_delete(dms->rootContent);
if (dms->mutex)
mupnp_mutex_delete(dms->mutex);
if (dms->protocolInfoList)
mupnp_upnpav_protocolinfolist_delete(dms->protocolInfoList);
if (dms->networkInterfaceList)
mupnp_net_interfacelist_delete(dms->networkInterfaceList);
mupnp_device_delete(dms->dev);
free(dms);
}
void ExitApp()
{
mupnp_device_stop(clockDev);
mupnp_device_delete(clockDev);
}
mUpnpAvRenderer *mupnp_upnpav_dmr_new()
{
mUpnpAvRenderer *dmr;
char *lastChange;
dmr = (mUpnpAvRenderer *)malloc(sizeof(mUpnpAvRenderer));
dmr->dev = mupnp_device_new();
if (!dmr->dev) {
free(dmr);
return NULL;
}
if (mupnp_device_parsedescription(dmr->dev, CG_UPNPAV_DMR_DEVICE_DESCRIPTION, mupnp_strlen(CG_UPNPAV_DMR_DEVICE_DESCRIPTION)) == false) {
mupnp_device_delete(dmr->dev);
free(dmr);
return NULL;
}
if (mupnp_upnpav_dmr_conmgr_init(dmr) == false) {
mupnp_device_delete(dmr->dev);
free(dmr);
return NULL;
}
if (mupnp_upnpav_dmr_renderingctrl_init(dmr) == false) {
mupnp_device_delete(dmr->dev);
free(dmr);
return NULL;
}
if (mupnp_upnpav_dmr_avtransport_init(dmr) == false) {
mupnp_device_delete(dmr->dev);
free(dmr);
return NULL;
}
dmr->mutex = mupnp_mutex_new();
if (!dmr->mutex) {
mupnp_upnpav_dmr_delete(dmr);
return NULL;
}
mupnp_device_setactionlistener(dmr->dev, mupnp_upnpav_dmr_actionreceived);
mupnp_device_setquerylistener(dmr->dev, mupnp_upnpav_dmr_queryreceived);
mupnp_device_sethttplistener(dmr->dev, mupnp_upnpav_dmr_device_httprequestrecieved);
mupnp_upnpav_dmr_setactionlistener(dmr, NULL);
mupnp_upnpav_dmr_setquerylistener(dmr, NULL);
mupnp_upnpav_dmr_sethttplistener(dmr, NULL);
mupnp_device_setuserdata(dmr->dev, dmr);
mupnp_device_updateudn(dmr->dev);
dmr->protocolInfoList = mupnp_upnpav_protocolinfolist_new();
mupnp_upnpav_dmr_setavtransportlastchange(dmr, "<Event xmlns = "urn:schemas-upnp-org:metadata-1-0/AVT/"/>");
mupnp_upnpav_dmr_setsourceprotocolinfo(dmr, "");
mupnp_upnpav_dmr_setcurrentconnectionids(dmr, "0");
lastChange = "<Event xmlns = "urn:schemas-upnp-org:metadata-1-0/RCS/">"
"<InstanceID val="0">"
"<Volume val="100" channel="RF"/>"
"<Volume val="100" channel="LF"/>"
"</InstanceID>"
"</Event>";
mupnp_upnpav_dmr_setrenderingcontrollastchange(dmr, lastChange);
return dmr;
}
mUpnpAvServer *mupnp_upnpav_dms_new()
{
mUpnpAvServer *dms;
dms = (mUpnpAvServer *)malloc(sizeof(mUpnpAvServer));
dms->dev = mupnp_device_new();
if (!dms->dev) {
free(dms);
return NULL;
}
if (mupnp_device_parsedescription(dms->dev, CG_UPNPAV_DMS_DEVICE_DESCRIPTION, mupnp_strlen(CG_UPNPAV_DMS_DEVICE_DESCRIPTION)) == false) {
mupnp_device_delete(dms->dev);
free(dms);
return NULL;
}
if (mupnp_upnpav_dms_conmgr_init(dms) == false) {
mupnp_device_delete(dms->dev);
free(dms);
return NULL;
}
if (mupnp_upnpav_dms_condir_init(dms) == false) {
mupnp_device_delete(dms->dev);
free(dms);
return NULL;
}
if (mupnp_upnpav_dms_medrec_init(dms) == false) {
mupnp_device_delete(dms->dev);
free(dms);
return NULL;
}
dms->rootContent = mupnp_upnpav_content_new();
mupnp_upnpav_content_settype(dms->rootContent, CG_UPNPAV_CONTENT_CONTAINER);
mupnp_upnpav_content_settitle(dms->rootContent, CG_UPNPAV_ROOT_CONTENT_TITLE);
mupnp_upnpav_content_setid(dms->rootContent, CG_UPNPAV_ROOT_CONTENT_ID);
mupnp_upnpav_content_setparentid(dms->rootContent, CG_UPNPAV_ROOT_CONTENT_PARENTID);
if (!dms->rootContent) {
mupnp_upnpav_dms_delete(dms);
return NULL;
}
dms->mutex = mupnp_mutex_new();
if (!dms->mutex) {
mupnp_upnpav_dms_delete(dms);
return NULL;
}
dms->networkInterfaceList = mupnp_net_interfacelist_new();
if (!dms->networkInterfaceList) {
mupnp_upnpav_dms_delete(dms);
return NULL;
}
mupnp_device_setactionlistener(dms->dev, mupnp_upnpav_dms_actionreceived);
mupnp_device_setquerylistener(dms->dev, mupnp_upnpav_dms_queryreceived);
mupnp_device_sethttplistener(dms->dev, mupnp_upnpav_dms_device_httprequestrecieved);
mupnp_upnpav_dms_setactionlistener(dms, NULL);
mupnp_upnpav_dms_setquerylistener(dms, NULL);
mupnp_upnpav_dms_sethttplistener(dms, NULL);
mupnp_device_setuserdata(dms->dev, dms);
mupnp_device_updateudn(dms->dev);
dms->protocolInfoList = mupnp_upnpav_protocolinfolist_new();
return dms;
}
