void ClinkTestCase::testURIAdd()
{
CgNetURI *uri;
char *uriStr;
uri = cg_net_uri_new();
cg_net_uri_setvalue(uri, CLINK_TESTCASE_NET_URI_ADD_BASEPATH "/");
cg_net_uri_addpath(uri, CLINK_TESTCASE_NET_URI_ADD_EXTRAPATH);
uriStr = cg_net_uri_getvalue(uri);
CPPUNIT_ASSERT(cg_streq(uriStr, CLINK_TESTCASE_NET_URI_ADD_FULLPATH));
cg_net_uri_delete(uri);
uri = cg_net_uri_new();
cg_net_uri_setvalue(uri, CLINK_TESTCASE_NET_URI_ADD_BASEPATH);
cg_net_uri_addpath(uri, "/" CLINK_TESTCASE_NET_URI_ADD_EXTRAPATH);
uriStr = cg_net_uri_getvalue(uri);
CPPUNIT_ASSERT(cg_streq(uriStr, CLINK_TESTCASE_NET_URI_ADD_FULLPATH));
cg_net_uri_delete(uri);
uri = cg_net_uri_new();
cg_net_uri_setvalue(uri, CLINK_TESTCASE_NET_URI_ADD_BASEPATH);
cg_net_uri_addpath(uri, CLINK_TESTCASE_NET_URI_ADD_EXTRAPATH);
uriStr = cg_net_uri_getvalue(uri);
CPPUNIT_ASSERT(cg_streq(uriStr, CLINK_TESTCASE_NET_URI_ADD_FULLPATH));
cg_net_uri_delete(uri);
}
int cg_upnpav_content_gettype(CgUpnpAvContent* con)
{
if (cg_streq(cg_xml_node_getname(con), CG_UPNPAV_CONTENT_ITEM_STRING))
return CG_UPNPAV_CONTENT_ITEM;
if (cg_streq(cg_xml_node_getname(con), CG_UPNPAV_CONTENT_CONTAINER_STRING))
return CG_UPNPAV_CONTENT_CONTAINER;
return CG_UPNPAV_CONTENT_NONE;
}
void cg_upnpav_content_copy(CgUpnpAvContent* destContent, CgUpnpAvContent* srcContent)
{
CgXmlAttribute* attr;
CgUpnpAvContent* destNode;
CgUpnpAvContent* srcNode;
cg_xml_node_setname(destContent, cg_xml_node_getname(srcContent));
cg_xml_node_setvalue(destContent, cg_xml_node_getvalue(srcContent));
for (attr = cg_xml_node_getattributes(srcContent); attr; attr = cg_xml_attribute_next(attr))
cg_xml_node_setattribute(destContent, cg_xml_attribute_getname(attr), cg_xml_attribute_getvalue(attr));
for (srcNode = cg_xml_node_getchildnodes(srcContent); srcNode; srcNode = cg_xml_node_next(srcNode)) {
if (cg_upnpav_content_gettype(srcNode) != CG_UPNPAV_CONTENT_NONE)
continue;
if (cg_streq(cg_xml_node_getname(srcNode), CG_UPNPAV_RESOURCE_NAME)) {
destNode = cg_upnpav_resource_new();
cg_upnpav_resource_copy(destNode, srcNode);
}
else {
destNode = cg_upnpav_content_new();
cg_xml_node_setname(destNode, cg_xml_node_getname(srcNode));
cg_xml_node_setvalue(destNode, cg_xml_node_getvalue(srcNode));
for (attr = cg_xml_node_getattributes(srcNode); attr; attr = cg_xml_attribute_next(attr))
cg_xml_node_setattribute(destNode, cg_xml_attribute_getname(attr), cg_xml_attribute_getvalue(attr));
}
cg_xml_node_addchildnode(destContent, destNode);
}
}
BOOL cg_upnpav_dms_queryreceived(CgUpnpStateVariable *statVar)
{
CgUpnpDevice *dev;
CgUpnpService *service;
CgUpnpAvServer *dms;
CG_UPNPAV_STATEVARIABLE_LISTNER userQueryListener;
service = cg_upnp_statevariable_getservice(statVar);
if (!service)
return FALSE;
dev = (CgUpnpDevice *)cg_upnp_service_getdevice(service);
if (!dev)
return FALSE;
dms = (CgUpnpAvServer *)cg_upnp_device_getuserdata(dev);
if (!dms)
return FALSE;
userQueryListener = cg_upnpav_dms_getquerylistener(dms);
if (userQueryListener) {
if (userQueryListener(statVar))
return TRUE;
}
if (cg_streq(cg_upnp_service_getservicetype(service), CG_UPNPAV_DMS_CONTENTDIRECTORY_SERVICE_TYPE))
return cg_upnpav_dms_condir_queryreceived(statVar);
return FALSE;
}
void ClinkTestCase::testURI()
{
CgNetURI *uri = cg_net_uri_new();
cg_net_uri_setvalue(uri, CLINK_TESTCASE_NET_URI_PATH "?"
CLINK_TESTCASE_NET_URI_PARAM1_NAME "=" CLINK_TESTCASE_NET_URI_PARAM1_VALUE "&"
CLINK_TESTCASE_NET_URI_PARAM2_NAME "=" CLINK_TESTCASE_NET_URI_PARAM2_VALUE
"#" CLINK_TESTCASE_NET_URI_FRAGMENT);
CPPUNIT_ASSERT(cg_streq(cg_net_uri_getpath(uri), CLINK_TESTCASE_NET_URI_PATH));
CPPUNIT_ASSERT(cg_streq(cg_net_uri_getquery(uri),
CLINK_TESTCASE_NET_URI_PARAM1_NAME "=" CLINK_TESTCASE_NET_URI_PARAM1_VALUE "&"
CLINK_TESTCASE_NET_URI_PARAM2_NAME "=" CLINK_TESTCASE_NET_URI_PARAM2_VALUE
));
CPPUNIT_ASSERT(cg_streq(cg_net_uri_getfragment(uri), CLINK_TESTCASE_NET_URI_FRAGMENT));
CgDictionary *paramDir = cg_net_uri_getquerydictionary(uri);
CgDictionaryElement *paramElem;
paramElem = cg_dictionary_gets(paramDir);
CPPUNIT_ASSERT(paramElem != NULL);
CPPUNIT_ASSERT(cg_streq(cg_dictionary_element_getkey(paramElem), CLINK_TESTCASE_NET_URI_PARAM1_NAME));
CPPUNIT_ASSERT(cg_streq(cg_dictionary_element_getvalue(paramElem), CLINK_TESTCASE_NET_URI_PARAM1_VALUE));
paramElem = cg_dictionary_element_next(paramElem);
CPPUNIT_ASSERT(paramElem != NULL);
CPPUNIT_ASSERT(cg_streq(cg_dictionary_element_getkey(paramElem), CLINK_TESTCASE_NET_URI_PARAM2_NAME));
CPPUNIT_ASSERT(cg_streq(cg_dictionary_element_getvalue(paramElem), CLINK_TESTCASE_NET_URI_PARAM2_VALUE));
cg_net_uri_delete(uri);
}
BOOL cg_upnpav_dmr_queryreceived(CgUpnpStateVariable* statVar)
{
CgUpnpDevice* dev;
CgUpnpService* service;
CgUpnpAvRenderer* dmr;
CG_UPNPAV_STATEVARIABLE_LISTNER userQueryListener;
service = cg_upnp_statevariable_getservice(statVar);
if (!service)
return FALSE;
dev = (CgUpnpDevice*)cg_upnp_service_getdevice(service);
if (!dev)
return FALSE;
dmr = (CgUpnpAvRenderer*)cg_upnp_device_getuserdata(dev);
if (!dmr)
return FALSE;
userQueryListener = cg_upnpav_dmr_getquerylistener(dmr);
if (userQueryListener) {
if (userQueryListener(statVar))
return TRUE;
}
if (cg_streq(cg_upnp_service_getservicetype(service), CG_UPNPAV_DMR_AVTRANSPORT_SERVICE_TYPE))
return cg_upnpav_dmr_avtransport_queryreceived(statVar);
if (cg_streq(cg_upnp_service_getservicetype(service), CG_UPNPAV_DMR_RENDERINGCONTROL_SERVICE_TYPE))
return cg_upnpav_dmr_renderingctrl_queryreceived(statVar);
if (cg_streq(cg_upnp_service_getservicetype(service), CG_UPNPAV_DMR_CONNECTIONMANAGER_SERVICE_TYPE))
return cg_upnpav_dmr_conmgr_queryreceived(statVar);
return FALSE;
}
BOOL cg_upnpav_dmr_actionreceived(CgUpnpAction* action)
{
CgUpnpDevice* dev;
CgUpnpService* service;
CgUpnpAvRenderer* dmr;
CG_UPNPAV_ACTION_LISTNER userActionListener;
service = cg_upnp_action_getservice(action);
if (!service)
return FALSE;
dev = (CgUpnpDevice*)cg_upnp_service_getdevice(service);
if (!dev)
return FALSE;
dmr = (CgUpnpAvRenderer*)cg_upnp_device_getuserdata(dev);
if (!dmr)
return FALSE;
userActionListener = cg_upnpav_dmr_getactionlistener(dmr);
if (userActionListener) {
if (userActionListener(action))
return TRUE;
}
if (cg_streq(cg_upnp_service_getservicetype(service), CG_UPNPAV_DMR_AVTRANSPORT_SERVICE_TYPE))
return cg_upnpav_dmr_avtransport_actionreceived(action);
if (cg_streq(cg_upnp_service_getservicetype(service), CG_UPNPAV_DMR_RENDERINGCONTROL_SERVICE_TYPE))
return cg_upnpav_dmr_renderingctrl_actionreceived(action);
if (cg_streq(cg_upnp_service_getservicetype(service), CG_UPNPAV_DMR_CONNECTIONMANAGER_SERVICE_TYPE))
return cg_upnpav_dmr_conmgr_actionreceived(action);
return FALSE;
}
BOOL cg_upnpav_dms_actionreceived(CgUpnpAction *action)
{
CgUpnpDevice *dev;
CgUpnpService *service;
CgUpnpAvServer *dms;
CG_UPNP_ACTION_LISTNER userActionListener;
service = cg_upnp_action_getservice(action);
if (!service)
return FALSE;
dev = (CgUpnpDevice *)cg_upnp_service_getdevice(service);
if (!dev)
return FALSE;
dms = (CgUpnpAvServer *)cg_upnp_device_getuserdata(dev);
if (!dms)
return FALSE;
userActionListener = cg_upnpav_dms_getactionlistener(dms);
if (userActionListener) {
if (userActionListener(action))
return TRUE;
}
if (cg_streq(cg_upnp_service_getservicetype(service), CG_UPNPAV_DMS_CONTENTDIRECTORY_SERVICE_TYPE))
return cg_upnpav_dms_condir_actionreceived(action);
if (cg_streq(cg_upnp_service_getservicetype(service), CG_UPNPAV_DMS_MEDIARECEIVER_SERVICE_TYPE))
return cg_upnpav_dms_medrec_actionreceived(action);
if (cg_streq(cg_upnp_service_getservicetype(service), CG_UPNPAV_DMS_CONNECTIONMANAGER_SERVICE_TYPE))
return cg_upnpav_dms_conmgr_actionreceived(action);
return FALSE;
}
CgDictionaryElement *cg_dictionary_getelement(CgDictionary *dir, char *key)
{
CgDictionaryElement *dirElem;
char *dirElemKey;
cg_log_debug_l4("Entering...\n");
if (NULL == dir || cg_strlen(key) <= 0 )
return NULL;
for (dirElem = cg_dictionary_gets(dir); dirElem != NULL; dirElem = cg_dictionary_element_next(dirElem)) {
dirElemKey = cg_dictionary_element_getkey(dirElem);
if (cg_strlen(dirElemKey) <= 0)
continue;
if (cg_streq(dirElemKey, key) == TRUE)
return dirElem;
}
cg_log_debug_l4("Leaving...\n");
return NULL;
}
BOOL cg_upnpav_dms_conmgr_actionreceived(CgUpnpAction* action)
{
CgUpnpAvServer* dms;
CgUpnpDevice* dev;
char* actionName;
CgUpnpArgument* arg;
CgString* protocolInfos;
CgUpnpAvProtocolInfo* protocolInfo;
actionName = (char*)cg_upnp_action_getname(action);
if (cg_strlen(actionName) <= 0)
return FALSE;
dev = (CgUpnpDevice*)cg_upnp_service_getdevice(cg_upnp_action_getservice(action));
if (!dev)
return FALSE;
dms = (CgUpnpAvServer*)cg_upnp_device_getuserdata(dev);
if (!dms)
return FALSE;
/* GetProtocolInfo*/
if (cg_streq(actionName, CG_UPNPAV_DMS_CONNECTIONMANAGER_GET_PROTOCOL_INFO)) {
arg = cg_upnp_action_getargumentbyname(action, CG_UPNPAV_DMS_CONNECTIONMANAGER_SOURCE);
if (!arg)
return FALSE;
protocolInfos = cg_string_new();
for (protocolInfo = cg_upnpav_dms_getprotocolinfos(dms); protocolInfo; protocolInfo = cg_upnpav_protocolinfo_next(protocolInfo)) {
if (0 < cg_string_length(protocolInfos))
cg_string_addvalue(protocolInfos, ",");
cg_string_addvalue(protocolInfos, cg_upnpav_protocolinfo_getstring(protocolInfo));
}
cg_upnp_argument_setvalue(arg, cg_string_getvalue(protocolInfos));
cg_string_delete(protocolInfos);
return TRUE;
}
return FALSE;
}
void cg_upnp_device_ssdpmessagereceived(CgUpnpDevice *dev, CgUpnpSSDPPacket *ssdpPkt, int filter)
{
BOOL isRootDev;
char *ssdpST;
char *devUDN, *devType;
char ssdpMsg[CG_UPNP_SSDP_HEADER_LINE_MAXSIZE];
char deviceUSN[CG_UPNP_SSDP_HEADER_LINE_MAXSIZE];
#if defined WINCE
size_t n;
#else
int n;
#endif
CgUpnpService *service;
CgUpnpDevice *childDev;
char *ssdpMXString;
int ssdpMX;
cg_log_debug_l4("Entering...\n");
ssdpMXString = cg_http_headerlist_getvalue(ssdpPkt->headerList, CG_HTTP_MX);
ssdpST = cg_upnp_ssdp_packet_getst(ssdpPkt);
/* Check if this ssdp packet has already been checked + filtered */
if (filter)
{
/****************************************
* Request line
* Check the request line for errors, this is not ideal as it currently only
* checks for the presence of the strings and not the order.
***************************************/
/**** check for M-SEARCH and return if not found ****/
if (cg_strstr(cg_string_getvalue(ssdpPkt->dgmPkt->data), CG_HTTP_MSEARCH) < 0)
return;
/**** check for * and return if not found ****/
if (cg_strstr(cg_string_getvalue(ssdpPkt->dgmPkt->data), "*") < 0)
return;
/**** check HTTP version and return if not found ****/
if (cg_strstr(cg_string_getvalue(ssdpPkt->dgmPkt->data), CG_HTTP_VER11) < 0)
return;
/****************************************
* check HOST header, should always be 239.255.255.250:1900, return if incorrect
***************************************/
if (cg_strcmp(cg_upnp_ssdp_packet_gethost(ssdpPkt), CG_UPNP_SSDP_MULTICAST_ADDRESS) != 0)
return;
/****************************************
* check MAN header, return if incorrect
***************************************/
if (cg_upnp_ssdp_packet_isdiscover(ssdpPkt) == FALSE)
return;
/****************************************
* check MX header, return if incorrect
***************************************/
if (ssdpMXString == NULL || cg_strlen(ssdpMXString)==0)
/* return if the MX value does not exist or is empty */
return;
/* check if MX value is not an integer */
for (n=0; n<strlen(ssdpMXString); n++) {
if (isdigit(ssdpMXString[n]) == 0)
/* MX value contains a non-digit so is invalid */
return;
}
/****************************************
* check ST header and if empty return
***************************************/
if (cg_strlen(ssdpST) <= 0)
return;
/* Check if we have received this search recently
* and ignore duplicates. */
if ( filter_duplicate_m_search(ssdpPkt) )
return;
ssdpMX = cg_upnp_ssdp_packet_getmx(ssdpPkt);
cg_log_debug("Sleeping for a while... (MX:%d)\n", ssdpMX);
cg_waitrandom((ssdpMX*1000)/4);
}
isRootDev = cg_upnp_device_isrootdevice(dev);
if (cg_upnp_st_isalldevice(ssdpST) == TRUE) {
/* for root device only */
if (isRootDev == TRUE) {
cg_upnp_device_getnotifydevicent(dev, ssdpMsg, sizeof(ssdpMsg));
cg_upnp_device_getnotifydeviceusn(dev, deviceUSN, sizeof(deviceUSN));
cg_upnp_device_postsearchresponse(dev, ssdpPkt, ssdpMsg, deviceUSN);
}
/* for all devices send */
/* device type : device version */
cg_upnp_device_getnotifydevicetypent(dev, ssdpMsg, sizeof(ssdpMsg));
cg_upnp_device_getnotifydevicetypeusn(dev, deviceUSN, sizeof(deviceUSN));
cg_upnp_device_postsearchresponse(dev, ssdpPkt, ssdpMsg, deviceUSN);
/* device UUID */
cg_upnp_device_postsearchresponse(dev, ssdpPkt, cg_upnp_device_getudn(dev), cg_upnp_device_getudn(dev));
}
else if (cg_upnp_st_isrootdevice(ssdpST) == TRUE) {
if (isRootDev == TRUE) {
cg_upnp_device_getnotifydeviceusn(dev, deviceUSN, sizeof(deviceUSN));
cg_upnp_device_postsearchresponse(dev, ssdpPkt, CG_UPNP_ST_ROOT_DEVICE, deviceUSN);
}
}
else if (cg_upnp_st_isuuiddevice(ssdpST) == TRUE) {
devUDN = cg_upnp_device_getudn(dev);
if (cg_streq(ssdpST, devUDN) == TRUE)
cg_upnp_device_postsearchresponse(dev, ssdpPkt, devUDN, devUDN);
}
else if (cg_upnp_st_isurn(ssdpST) == TRUE) {
devType = cg_upnp_device_getdevicetype(dev);
if (cg_streq(ssdpST, devType) == TRUE) {
cg_upnp_device_getnotifydevicetypeusn(dev, deviceUSN, sizeof(deviceUSN));
cg_upnp_device_postsearchresponse(dev, ssdpPkt, devType, deviceUSN);
}
}
for (service=cg_upnp_device_getservices(dev); service != NULL; service = cg_upnp_service_next(service))
cg_upnp_service_ssdpmessagereceived(service, ssdpPkt);
for (childDev = cg_upnp_device_getdevices(dev); childDev != NULL; childDev = cg_upnp_device_next(childDev))
cg_upnp_device_ssdpmessagereceived(childDev, ssdpPkt, FALSE);
cg_log_debug_l4("Leaving...\n");
}
static BOOL cg_upnpav_content_comparebytitle(CgUpnpAvContent* con, void* userData)
{
if (!userData)
return FALSE;
return cg_streq(cg_upnpav_content_gettitle(con), (char*)userData);
}
void ClinkTestCase::testURI()
{
CgNetURI *uri;
//////////////////////////////////////////////////
uri = cg_net_uri_new();
cg_net_uri_setvalue(uri,
CLINK_TESTCASE_NET_URI_PROTOCOL "://"
CLINK_TESTCASE_NET_URI_HOST ":"
CLINK_TESTCASE_NET_URI_PORT
CLINK_TESTCASE_NET_URI_PATH);
CPPUNIT_ASSERT(cg_streq(cg_net_uri_getprotocol(uri), CLINK_TESTCASE_NET_URI_PROTOCOL));
CPPUNIT_ASSERT(cg_streq(cg_net_uri_gethost(uri), CLINK_TESTCASE_NET_URI_HOST));
CPPUNIT_ASSERT(cg_net_uri_getport(uri) == atoi(CLINK_TESTCASE_NET_URI_PORT));
CPPUNIT_ASSERT(cg_streq(cg_net_uri_getpath(uri), CLINK_TESTCASE_NET_URI_PATH));
//////////////////////////////////////////////////
uri = cg_net_uri_new();
cg_net_uri_setvalue(uri,
CLINK_TESTCASE_NET_URI_PROTOCOL "://"
CLINK_TESTCASE_NET_URI_HOST
CLINK_TESTCASE_NET_URI_PATH);
CPPUNIT_ASSERT(cg_streq(cg_net_uri_getprotocol(uri), CLINK_TESTCASE_NET_URI_PROTOCOL));
CPPUNIT_ASSERT(cg_streq(cg_net_uri_gethost(uri), CLINK_TESTCASE_NET_URI_HOST));
CPPUNIT_ASSERT(cg_net_uri_getport(uri) == CG_NET_URI_DEFAULT_HTTP_PORT);
CPPUNIT_ASSERT(cg_streq(cg_net_uri_getpath(uri), CLINK_TESTCASE_NET_URI_PATH));
//////////////////////////////////////////////////
uri = cg_net_uri_new();
cg_net_uri_setvalue(uri,
CLINK_TESTCASE_NET_URI_PROTOCOL_FTP "://"
CLINK_TESTCASE_NET_URI_HOST
CLINK_TESTCASE_NET_URI_PATH);
CPPUNIT_ASSERT(cg_streq(cg_net_uri_getprotocol(uri), CLINK_TESTCASE_NET_URI_PROTOCOL_FTP));
CPPUNIT_ASSERT(cg_streq(cg_net_uri_gethost(uri), CLINK_TESTCASE_NET_URI_HOST));
CPPUNIT_ASSERT(cg_net_uri_getport(uri) == CG_NET_URI_DEFAULT_FTP_PORT);
CPPUNIT_ASSERT(cg_streq(cg_net_uri_getpath(uri), CLINK_TESTCASE_NET_URI_PATH));
cg_net_uri_delete(uri);
//////////////////////////////////////////////////
uri = cg_net_uri_new();
cg_net_uri_setvalue(uri,
CLINK_TESTCASE_NET_URI_PROTOCOL "://"
CLINK_TESTCASE_NET_URI_HOST);
CPPUNIT_ASSERT(cg_streq(cg_net_uri_getprotocol(uri), CLINK_TESTCASE_NET_URI_PROTOCOL));
CPPUNIT_ASSERT(cg_streq(cg_net_uri_gethost(uri), CLINK_TESTCASE_NET_URI_HOST));
CPPUNIT_ASSERT(!cg_net_uri_haspath(uri));
cg_net_uri_delete(uri);
//////////////////////////////////////////////////
uri = cg_net_uri_new();
cg_net_uri_setvalue(uri,
CLINK_TESTCASE_NET_URI_PROTOCOL "://"
CLINK_TESTCASE_NET_URI_HOST "/");
CPPUNIT_ASSERT(cg_streq(cg_net_uri_getprotocol(uri), CLINK_TESTCASE_NET_URI_PROTOCOL));
CPPUNIT_ASSERT(cg_streq(cg_net_uri_gethost(uri), CLINK_TESTCASE_NET_URI_HOST));
CPPUNIT_ASSERT(cg_streq(cg_net_uri_getpath(uri), "/"));
cg_net_uri_delete(uri);
}
