mUpnpService *SelectService(mUpnpDevice *dev)
{
mUpnpService *service;
int n;
char key;
int serviceNum;
n = 0;
for (service = mupnp_device_getservices(dev); service != NULL; service = mupnp_service_next(service)) {
key = 'a' + n;
if ('z' < key)
break;
printf(" [%c] = %s\n", key, mupnp_service_getservicetype(service));
n++;
}
printf("Select Service : ");
key = kbgetkey();
key = tolower(key);
printf("%c\n", key);
if (!isalpha(key))
return NULL;
serviceNum = key - 'a';
service = mupnp_device_getservices(dev);
for (n=0; n<serviceNum; n++)
service = mupnp_service_next(service);
return service;
}
bool mupnp_controlpoint_parseservicesfordevice(mUpnpDevice *dev, mUpnpSSDPPacket *ssdpPkt)
{
mUpnpService *service;
mUpnpDevice *childDev;
mupnp_log_debug_l4("Entering...\n");
for (service=mupnp_device_getservices(dev); service != NULL; service = mupnp_service_next(service)) {
if (mupnp_controlpoint_parsescservicescpd(service) == false) {
return false;
}
}
/* Now only root SCPDs for root services are parsed, but also child
devices' services have to be parsed, so parse them */
for (childDev=mupnp_device_getdevices(dev); childDev != NULL; childDev = mupnp_device_next(childDev)) {
if (mupnp_controlpoint_parseservicesfordevice(childDev, ssdpPkt) == false)
{
return false;
}
}
mupnp_log_debug_l4("Leaving...\n");
return true;
}
void PrintDeviceInfo(mUpnpDevice *dev, int indent)
{
char indentStr[128];
int n;
mUpnpService *service;
int serviceCnt;
mUpnpAction *action;
int actionCnt;
mUpnpArgumentList *arg;
int argCnt;
mUpnpStateVariable *stateVar;
int stateVarCnt;
for (n=0; n<indent && n<(sizeof(indentStr)-1); n++)
indentStr[n] = ' ';
indentStr[n] = '\0';
serviceCnt = 0;
for (service = mupnp_device_getservices(dev); service != NULL; service = mupnp_service_next(service)) {
printf("%s service[%d] = %s\n", indentStr, ++serviceCnt, mupnp_service_getservicetype(service));
actionCnt = 0;
for (action = mupnp_service_getactions(service); action != NULL; action = mupnp_action_next(action)) {
printf("%s action[%d] = %s\n", indentStr, ++actionCnt, mupnp_action_getname(action));
argCnt = 0;
for (arg = mupnp_action_getarguments(action); arg != NULL; arg = mupnp_argument_next(arg)) {
printf("%s arg[%d] = %s\n", indentStr, ++argCnt, mupnp_argument_getname(arg));
}
}
stateVarCnt = 0;
for (stateVar = mupnp_service_getstatevariables(service); stateVar != NULL; stateVar = mupnp_statevariable_next(stateVar)) {
printf("%s stateVar[%d] = %s = %s\n",
indentStr,
++stateVarCnt,
mupnp_statevariable_getname(stateVar),
mupnp_statevariable_getvalue(stateVar));
}
}
}
void mupnp_device_ssdpmessagereceived(mUpnpDevice *dev, mUpnpSSDPPacket *ssdpPkt, int filter)
{
BOOL isRootDev;
const char *ssdpST;
const char *devUDN, *devType;
char ssdpMsg[MUPNP_SSDP_HEADER_LINE_MAXSIZE];
char deviceUSN[MUPNP_SSDP_HEADER_LINE_MAXSIZE];
#if defined WINCE
size_t n;
#else
int n;
#endif
mUpnpService *service;
mUpnpDevice *childDev;
const char *ssdpMXString;
int ssdpMX;
const char *ssdpTargetAddr;
mupnp_log_debug_l4("Entering...\n");
ssdpMXString = mupnp_http_headerlist_getvalue(ssdpPkt->headerList, CG_HTTP_MX);
ssdpST = mupnp_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 (mupnp_strstr(mupnp_string_getvalue(ssdpPkt->dgmPkt->data), CG_HTTP_MSEARCH) < 0)
return;
/**** check for * and return if not found ****/
if (mupnp_strstr(mupnp_string_getvalue(ssdpPkt->dgmPkt->data), "*") < 0)
return;
/**** check HTTP version and return if not found ****/
if (mupnp_strstr(mupnp_string_getvalue(ssdpPkt->dgmPkt->data), CG_HTTP_VER11) < 0)
return;
/****************************************
* check HOST header, should always be 239.255.255.250:1900, return if incorrect
***************************************/
ssdpTargetAddr = mupnp_ssdp_packet_gethost(ssdpPkt);
if (mupnp_strcmp(ssdpTargetAddr, MUPNP_SSDP_MULTICAST_ADDRESS) != 0 && !mupnp_net_isipv6address(ssdpTargetAddr) )
return;
/****************************************
* check MAN header, return if incorrect
***************************************/
if (mupnp_ssdp_packet_isdiscover(ssdpPkt) == FALSE)
return;
/****************************************
* check MX header, return if incorrect
***************************************/
if (ssdpMXString == NULL || mupnp_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 (mupnp_strlen(ssdpST) <= 0)
return;
/* Check if we have received this search recently
* and ignore duplicates. */
if ( filter_duplicate_m_search(ssdpPkt) )
return;
ssdpMX = mupnp_ssdp_packet_getmx(ssdpPkt);
mupnp_log_debug("Sleeping for a while... (MX:%d)\n", ssdpMX);
mupnp_waitrandom((ssdpMX*1000)/4);
}
isRootDev = mupnp_device_isrootdevice(dev);
if (mupnp_st_isalldevice(ssdpST) == TRUE) {
/* for root device only */
if (isRootDev == TRUE) {
mupnp_device_getnotifydevicent(dev, ssdpMsg, sizeof(ssdpMsg));
mupnp_device_getnotifydeviceusn(dev, deviceUSN, sizeof(deviceUSN));
mupnp_device_postsearchresponse(dev, ssdpPkt, ssdpMsg, deviceUSN);
}
/* for all devices send */
/* device type : device version */
mupnp_device_getnotifydevicetypent(dev, ssdpMsg, sizeof(ssdpMsg));
mupnp_device_getnotifydevicetypeusn(dev, deviceUSN, sizeof(deviceUSN));
mupnp_device_postsearchresponse(dev, ssdpPkt, ssdpMsg, deviceUSN);
/* device UUID */
mupnp_device_postsearchresponse(dev, ssdpPkt, mupnp_device_getudn(dev), mupnp_device_getudn(dev));
}
else if (mupnp_st_isrootdevice(ssdpST) == TRUE) {
if (isRootDev == TRUE) {
mupnp_device_getnotifydeviceusn(dev, deviceUSN, sizeof(deviceUSN));
mupnp_device_postsearchresponse(dev, ssdpPkt, MUPNP_ST_ROOT_DEVICE, deviceUSN);
}
}
else if (mupnp_st_isuuiddevice(ssdpST) == TRUE) {
devUDN = mupnp_device_getudn(dev);
if (mupnp_streq(ssdpST, devUDN) == TRUE)
mupnp_device_postsearchresponse(dev, ssdpPkt, devUDN, devUDN);
}
else if (mupnp_st_isurn(ssdpST) == TRUE) {
devType = mupnp_device_getdevicetype(dev);
if (mupnp_streq(ssdpST, devType) == TRUE) {
mupnp_device_getnotifydevicetypeusn(dev, deviceUSN, sizeof(deviceUSN));
mupnp_device_postsearchresponse(dev, ssdpPkt, devType, deviceUSN);
}
}
for (service=mupnp_device_getservices(dev); service != NULL; service = mupnp_service_next(service))
mupnp_service_ssdpmessagereceived(service, ssdpPkt);
for (childDev = mupnp_device_getdevices(dev); childDev != NULL; childDev = mupnp_device_next(childDev))
mupnp_device_ssdpmessagereceived(childDev, ssdpPkt, FALSE);
mupnp_log_debug_l4("Leaving...\n");
}
