/** * Find a device from the controlpoint by the UDN of the device. * * \param ctrlPoint Controlpoint in question * \param udn Type of the device * */ mUpnpDevice *mupnp_controlpoint_getdevicebyudn(mUpnpControlPoint *ctrlPoint, char *udn) { mUpnpDevice *dev = NULL; mUpnpDevice *childDev = NULL; mupnp_log_debug_l4("Entering...\n"); if (mupnp_strlen(udn) <= 0 || ctrlPoint == NULL) { return NULL; } for (dev = mupnp_controlpoint_getdevices(ctrlPoint); dev != NULL; dev = mupnp_device_next(dev)) { if (mupnp_strcmp(mupnp_device_getudn(dev), udn) == 0) { return dev; } childDev = mupnp_device_getdevicebyudn(dev, udn); if (childDev != NULL) { return childDev; } } mupnp_log_debug_l4("Leaving...\n"); return NULL; }
/** * Stop the control point. Stops sending/receiveing/responding to any messages. * * @param ctrlPoint The control point to stop * * @return true if successful; otherwise false * */ bool mupnp_controlpoint_stop(mUpnpControlPoint *ctrlPoint) { mUpnpDevice *dev = NULL; mUpnpSSDPServerList *ssdpServerList; mUpnpSSDPResponseServerList *ssdpResServerList; mUpnpHttpServerList *httpServerList; const char *udn = NULL; MUPNP_DEVICE_LISTENER listener = mupnp_controlpoint_getdevicelistener(ctrlPoint); mupnp_log_debug_l4("Entering...\n"); /* Stop expiration handling */ mupnp_thread_stop_with_cond(ctrlPoint->expThread, ctrlPoint->expCond); mupnp_log_debug_s("Expiration thread stopped.\n"); /**** SSDP Server ****/ ssdpServerList = mupnp_controlpoint_getssdpserverlist(ctrlPoint); mupnp_log_debug_s("Stopping ssdp servers.\n"); mupnp_ssdp_serverlist_setlistener(ssdpServerList, NULL); mupnp_ssdp_serverlist_setuserdata(ssdpServerList, NULL); mupnp_ssdp_serverlist_stop(ssdpServerList); mupnp_log_debug_s("Done\n"); mupnp_ssdp_serverlist_close(ssdpServerList); mupnp_ssdp_serverlist_clear(ssdpServerList); /**** SSDP Response Server ****/ ssdpResServerList = mupnp_controlpoint_getssdpresponseserverlist(ctrlPoint); mupnp_log_debug_s("Stopping ssdp response servers.\n"); mupnp_ssdpresponse_serverlist_setlistener(ssdpResServerList, NULL); mupnp_ssdpresponse_serverlist_setuserdata(ssdpResServerList, NULL); mupnp_ssdpresponse_serverlist_stop(ssdpResServerList); mupnp_log_debug_s("Done\n"); mupnp_ssdpresponse_serverlist_close(ssdpResServerList); mupnp_ssdpresponse_serverlist_clear(ssdpResServerList); /**** HTTP Server ****/ httpServerList = mupnp_controlpoint_gethttpserverlist(ctrlPoint); mupnp_log_debug_s("Stopping http servers.\n"); mupnp_http_serverlist_setlistener(httpServerList, NULL); mupnp_http_serverlist_stop(httpServerList); mupnp_log_debug_s("Done\n"); mupnp_http_serverlist_close(httpServerList); mupnp_http_serverlist_clear(httpServerList); mupnp_controlpoint_lock(ctrlPoint); mupnp_log_debug_s("Got controlpoint lock.\n"); /* Unsubscribe from all services */ for (dev = mupnp_controlpoint_getdevices(ctrlPoint); dev != NULL; dev = mupnp_device_next(dev)) { udn = mupnp_device_getudn(dev); /* Call device listener for each device */ if (udn != NULL && listener != NULL) { mupnp_controlpoint_unlock(ctrlPoint); listener(ctrlPoint, udn, mUpnpDeviceStatusRemoved); mupnp_controlpoint_lock(ctrlPoint); } } /* Empty device cache */ mupnp_devicelist_clear(ctrlPoint->deviceList); mupnp_log_debug_s("Device list cleared.\n"); mupnp_controlpoint_unlock(ctrlPoint); mupnp_log_debug_l4("Leaving...\n"); return true; }
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"); }