2019-01-13 21:03:10 +01:00
using System ;
2016-10-30 00:22:20 +02:00
using System.Collections.Generic ;
2018-09-12 19:26:21 +02:00
using System.Collections.ObjectModel ;
2021-02-14 15:11:46 +01:00
using System.Globalization ;
2018-09-12 19:26:21 +02:00
using System.Linq ;
2019-07-07 21:03:26 +02:00
using System.Net ;
2018-09-12 19:26:21 +02:00
using System.Threading ;
using System.Threading.Tasks ;
2019-02-22 05:06:49 +01:00
using MediaBrowser.Common.Net ;
2022-07-19 21:28:04 +02:00
using Microsoft.AspNetCore.HttpOverrides ;
2016-10-30 00:22:20 +02:00
2018-09-12 19:26:21 +02:00
namespace Rssdp.Infrastructure
2016-10-30 00:22:20 +02:00
{
2018-09-12 19:26:21 +02:00
/// <summary>
/// Provides the platform independent logic for publishing SSDP devices (notifications and search responses).
/// </summary>
public class SsdpDevicePublisher : DisposableManagedObjectBase , ISsdpDevicePublisher
{
private ISsdpCommunicationsServer _CommsServer ;
private string _OSName ;
private string _OSVersion ;
2019-02-22 05:06:49 +01:00
private bool _sendOnlyMatchedHost ;
2018-09-12 19:26:21 +02:00
private bool _SupportPnpRootDevice ;
private IList < SsdpRootDevice > _Devices ;
private IReadOnlyList < SsdpRootDevice > _ReadOnlyDevices ;
2019-02-05 09:49:46 +01:00
private Timer _RebroadcastAliveNotificationsTimer ;
2018-09-12 19:26:21 +02:00
private IDictionary < string , SearchRequest > _RecentSearchRequests ;
private Random _Random ;
private const string ServerVersion = "1.0" ;
/// <summary>
/// Default constructor.
/// </summary>
2021-11-16 12:24:17 +01:00
public SsdpDevicePublisher (
ISsdpCommunicationsServer communicationsServer ,
string osName ,
string osVersion ,
bool sendOnlyMatchedHost )
2018-09-12 19:26:21 +02:00
{
2020-06-20 10:35:29 +02:00
if ( communicationsServer = = null )
{
throw new ArgumentNullException ( nameof ( communicationsServer ) ) ;
}
if ( osName = = null )
{
throw new ArgumentNullException ( nameof ( osName ) ) ;
}
if ( osName . Length = = 0 )
{
throw new ArgumentException ( "osName cannot be an empty string." , nameof ( osName ) ) ;
}
if ( osVersion = = null )
{
throw new ArgumentNullException ( nameof ( osVersion ) ) ;
}
if ( osVersion . Length = = 0 )
{
throw new ArgumentException ( "osVersion cannot be an empty string." , nameof ( osName ) ) ;
}
2018-09-12 19:26:21 +02:00
_SupportPnpRootDevice = true ;
_Devices = new List < SsdpRootDevice > ( ) ;
_ReadOnlyDevices = new ReadOnlyCollection < SsdpRootDevice > ( _Devices ) ;
_RecentSearchRequests = new Dictionary < string , SearchRequest > ( StringComparer . OrdinalIgnoreCase ) ;
_Random = new Random ( ) ;
_CommsServer = communicationsServer ;
_CommsServer . RequestReceived + = CommsServer_RequestReceived ;
_OSName = osName ;
_OSVersion = osVersion ;
2019-02-22 05:06:49 +01:00
_sendOnlyMatchedHost = sendOnlyMatchedHost ;
2018-09-12 19:26:21 +02:00
_CommsServer . BeginListeningForBroadcasts ( ) ;
}
public void StartBroadcastingAliveMessages ( TimeSpan interval )
{
2019-02-05 09:49:46 +01:00
_RebroadcastAliveNotificationsTimer = new Timer ( SendAllAliveNotifications , null , TimeSpan . FromSeconds ( 5 ) , interval ) ;
2018-09-12 19:26:21 +02:00
}
/// <summary>
/// Adds a device (and it's children) to the list of devices being published by this server, making them discoverable to SSDP clients.
/// </summary>
/// <remarks>
/// <para>Adding a device causes "alive" notification messages to be sent immediately, or very soon after. Ensure your device/description service is running before adding the device object here.</para>
/// <para>Devices added here with a non-zero cache life time will also have notifications broadcast periodically.</para>
/// <para>This method ignores duplicate device adds (if the same device instance is added multiple times, the second and subsequent add calls do nothing).</para>
/// </remarks>
/// <param name="device">The <see cref="SsdpDevice"/> instance to add.</param>
2019-01-13 21:37:13 +01:00
/// <exception cref="ArgumentNullException">Thrown if the <paramref name="device"/> argument is null.</exception>
/// <exception cref="InvalidOperationException">Thrown if the <paramref name="device"/> contains property values that are not acceptable to the UPnP 1.0 specification.</exception>
2020-11-18 14:46:14 +01:00
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Performance", "CA1804:RemoveUnusedLocals", MessageId = "t", Justification = "Capture task to local variable suppresses compiler warning, but task is not really needed.")]
2018-09-12 19:26:21 +02:00
public void AddDevice ( SsdpRootDevice device )
{
2020-06-20 10:35:29 +02:00
if ( device = = null )
{
throw new ArgumentNullException ( nameof ( device ) ) ;
}
2018-09-12 19:26:21 +02:00
ThrowIfDisposed ( ) ;
bool wasAdded = false ;
lock ( _Devices )
{
if ( ! _Devices . Contains ( device ) )
{
_Devices . Add ( device ) ;
wasAdded = true ;
}
}
if ( wasAdded )
{
WriteTrace ( "Device Added" , device ) ;
SendAliveNotifications ( device , true , CancellationToken . None ) ;
}
}
/// <summary>
/// Removes a device (and it's children) from the list of devices being published by this server, making them undiscoverable.
/// </summary>
/// <remarks>
/// <para>Removing a device causes "byebye" notification messages to be sent immediately, advising clients of the device/service becoming unavailable. We recommend removing the device from the published list before shutting down the actual device/service, if possible.</para>
/// <para>This method does nothing if the device was not found in the collection.</para>
/// </remarks>
/// <param name="device">The <see cref="SsdpDevice"/> instance to add.</param>
2019-01-13 21:37:13 +01:00
/// <exception cref="ArgumentNullException">Thrown if the <paramref name="device"/> argument is null.</exception>
2018-09-12 19:26:21 +02:00
public async Task RemoveDevice ( SsdpRootDevice device )
{
2020-06-20 10:35:29 +02:00
if ( device = = null )
{
throw new ArgumentNullException ( nameof ( device ) ) ;
}
2018-09-12 19:26:21 +02:00
bool wasRemoved = false ;
lock ( _Devices )
{
if ( _Devices . Contains ( device ) )
{
_Devices . Remove ( device ) ;
wasRemoved = true ;
}
}
if ( wasRemoved )
{
WriteTrace ( "Device Removed" , device ) ;
await SendByeByeNotifications ( device , true , CancellationToken . None ) . ConfigureAwait ( false ) ;
}
}
/// <summary>
/// Returns a read only list of devices being published by this instance.
/// </summary>
public IEnumerable < SsdpRootDevice > Devices
{
get
{
return _ReadOnlyDevices ;
}
}
/// <summary>
/// If true (default) treats root devices as both upnp:rootdevice and pnp:rootdevice types.
/// </summary>
/// <remarks>
/// <para>Enabling this option will cause devices to show up in Microsoft Windows Explorer's network screens (if discovery is enabled etc.). Windows Explorer appears to search only for pnp:rootdeivce and not upnp:rootdevice.</para>
2020-11-18 14:46:14 +01:00
/// <para>If false, the system will only use upnp:rootdevice for notification broadcasts and and search responses, which is correct according to the UPnP/SSDP spec.</para>
2018-09-12 19:26:21 +02:00
/// </remarks>
public bool SupportPnpRootDevice
{
get { return _SupportPnpRootDevice ; }
2020-06-15 23:43:52 +02:00
2018-09-12 19:26:21 +02:00
set
{
_SupportPnpRootDevice = value ;
}
}
/// <summary>
/// Stops listening for requests, stops sending periodic broadcasts, disposes all internal resources.
/// </summary>
/// <param name="disposing"></param>
protected override void Dispose ( bool disposing )
{
if ( disposing )
{
DisposeRebroadcastTimer ( ) ;
var commsServer = _CommsServer ;
if ( commsServer ! = null )
{
commsServer . RequestReceived - = this . CommsServer_RequestReceived ;
}
var tasks = Devices . ToList ( ) . Select ( RemoveDevice ) . ToArray ( ) ;
Task . WaitAll ( tasks ) ;
_CommsServer = null ;
if ( commsServer ! = null )
{
if ( ! commsServer . IsShared )
2020-06-20 11:12:36 +02:00
{
2018-09-12 19:26:21 +02:00
commsServer . Dispose ( ) ;
2020-06-20 11:12:36 +02:00
}
2018-09-12 19:26:21 +02:00
}
_RecentSearchRequests = null ;
}
}
2019-07-07 21:03:26 +02:00
private void ProcessSearchRequest (
string mx ,
string searchTarget ,
IPEndPoint remoteEndPoint ,
IPAddress receivedOnlocalIpAddress ,
CancellationToken cancellationToken )
2018-09-12 19:26:21 +02:00
{
if ( String . IsNullOrEmpty ( searchTarget ) )
{
2021-02-14 15:11:46 +01:00
WriteTrace ( String . Format ( CultureInfo . InvariantCulture , "Invalid search request received From {0}, Target is null/empty." , remoteEndPoint . ToString ( ) ) ) ;
2018-09-12 19:26:21 +02:00
return ;
}
2020-06-14 11:11:11 +02:00
// WriteTrace(String.Format("Search Request Received From {0}, Target = {1}", remoteEndPoint.ToString(), searchTarget));
2018-09-12 19:26:21 +02:00
if ( IsDuplicateSearchRequest ( searchTarget , remoteEndPoint ) )
{
2020-06-14 11:11:11 +02:00
// WriteTrace("Search Request is Duplicate, ignoring.");
2018-09-12 19:26:21 +02:00
return ;
}
2020-06-14 11:11:11 +02:00
// Wait on random interval up to MX, as per SSDP spec.
// Also, as per UPnP 1.1/SSDP spec ignore missing/bank MX header. If over 120, assume random value between 0 and 120.
// Using 16 as minimum as that's often the minimum system clock frequency anyway.
2018-09-12 19:26:21 +02:00
int maxWaitInterval = 0 ;
if ( String . IsNullOrEmpty ( mx ) )
{
2020-06-14 11:11:11 +02:00
// Windows Explorer is poorly behaved and doesn't supply an MX header value.
// if (this.SupportPnpRootDevice)
2018-09-12 19:26:21 +02:00
mx = "1" ;
2020-06-14 11:11:11 +02:00
// else
// return;
2018-09-12 19:26:21 +02:00
}
2020-06-20 10:35:29 +02:00
if ( ! Int32 . TryParse ( mx , out maxWaitInterval ) | | maxWaitInterval < = 0 )
{
return ;
}
2018-09-12 19:26:21 +02:00
if ( maxWaitInterval > 120 )
2020-06-20 10:35:29 +02:00
{
2018-09-12 19:26:21 +02:00
maxWaitInterval = _Random . Next ( 0 , 120 ) ;
2020-06-20 10:35:29 +02:00
}
2018-09-12 19:26:21 +02:00
2020-06-14 11:11:11 +02:00
// Do not block synchronously as that may tie up a threadpool thread for several seconds.
2018-09-12 19:26:21 +02:00
Task . Delay ( _Random . Next ( 16 , ( maxWaitInterval * 1000 ) ) ) . ContinueWith ( ( parentTask ) = >
{
2020-06-14 11:11:11 +02:00
// Copying devices to local array here to avoid threading issues/enumerator exceptions.
2018-09-12 19:26:21 +02:00
IEnumerable < SsdpDevice > devices = null ;
lock ( _Devices )
{
if ( String . Compare ( SsdpConstants . SsdpDiscoverAllSTHeader , searchTarget , StringComparison . OrdinalIgnoreCase ) = = 0 )
2020-06-20 10:35:29 +02:00
{
2018-09-12 19:26:21 +02:00
devices = GetAllDevicesAsFlatEnumerable ( ) . ToArray ( ) ;
2020-06-20 10:35:29 +02:00
}
2018-09-12 19:26:21 +02:00
else if ( String . Compare ( SsdpConstants . UpnpDeviceTypeRootDevice , searchTarget , StringComparison . OrdinalIgnoreCase ) = = 0 | | ( this . SupportPnpRootDevice & & String . Compare ( SsdpConstants . PnpDeviceTypeRootDevice , searchTarget , StringComparison . OrdinalIgnoreCase ) = = 0 ) )
2020-06-20 10:35:29 +02:00
{
2018-09-12 19:26:21 +02:00
devices = _Devices . ToArray ( ) ;
2020-06-20 10:35:29 +02:00
}
2018-09-12 19:26:21 +02:00
else if ( searchTarget . Trim ( ) . StartsWith ( "uuid:" , StringComparison . OrdinalIgnoreCase ) )
2020-06-20 10:35:29 +02:00
{
2018-09-12 19:26:21 +02:00
devices = ( from device in GetAllDevicesAsFlatEnumerable ( ) where String . Compare ( device . Uuid , searchTarget . Substring ( 5 ) , StringComparison . OrdinalIgnoreCase ) = = 0 select device ) . ToArray ( ) ;
2020-06-20 10:35:29 +02:00
}
2018-09-12 19:26:21 +02:00
else if ( searchTarget . StartsWith ( "urn:" , StringComparison . OrdinalIgnoreCase ) )
2020-06-20 10:35:29 +02:00
{
2018-09-12 19:26:21 +02:00
devices = ( from device in GetAllDevicesAsFlatEnumerable ( ) where String . Compare ( device . FullDeviceType , searchTarget , StringComparison . OrdinalIgnoreCase ) = = 0 select device ) . ToArray ( ) ;
2020-06-20 10:35:29 +02:00
}
2018-09-12 19:26:21 +02:00
}
if ( devices ! = null )
{
var deviceList = devices . ToList ( ) ;
2020-06-14 11:11:11 +02:00
// WriteTrace(String.Format("Sending {0} search responses", deviceList.Count));
2018-09-12 19:26:21 +02:00
foreach ( var device in deviceList )
{
2020-10-04 10:56:33 +02:00
var root = device . ToRootDevice ( ) ;
2022-07-19 21:28:04 +02:00
var source = new IPData ( root . Address , new IPNetwork ( root . Address , root . PrefixLength ) , root . FriendlyName ) ;
var destination = new IPData ( remoteEndPoint . Address , new IPNetwork ( root . Address , root . PrefixLength ) ) ;
if ( ! _sendOnlyMatchedHost | | source . Address . Equals ( destination . Address ) )
2019-02-22 05:06:49 +01:00
{
SendDeviceSearchResponses ( device , remoteEndPoint , receivedOnlocalIpAddress , cancellationToken ) ;
}
2018-09-12 19:26:21 +02:00
}
}
} ) ;
}
private IEnumerable < SsdpDevice > GetAllDevicesAsFlatEnumerable ( )
{
return _Devices . Union ( _Devices . SelectManyRecursive < SsdpDevice > ( ( d ) = > d . Devices ) ) ;
}
2019-07-07 21:03:26 +02:00
private void SendDeviceSearchResponses (
SsdpDevice device ,
IPEndPoint endPoint ,
IPAddress receivedOnlocalIpAddress ,
CancellationToken cancellationToken )
2018-09-12 19:26:21 +02:00
{
bool isRootDevice = ( device as SsdpRootDevice ) ! = null ;
if ( isRootDevice )
{
SendSearchResponse ( SsdpConstants . UpnpDeviceTypeRootDevice , device , GetUsn ( device . Udn , SsdpConstants . UpnpDeviceTypeRootDevice ) , endPoint , receivedOnlocalIpAddress , cancellationToken ) ;
if ( this . SupportPnpRootDevice )
2020-06-20 11:12:36 +02:00
{
2018-09-12 19:26:21 +02:00
SendSearchResponse ( SsdpConstants . PnpDeviceTypeRootDevice , device , GetUsn ( device . Udn , SsdpConstants . PnpDeviceTypeRootDevice ) , endPoint , receivedOnlocalIpAddress , cancellationToken ) ;
2020-06-20 11:12:36 +02:00
}
2018-09-12 19:26:21 +02:00
}
SendSearchResponse ( device . Udn , device , device . Udn , endPoint , receivedOnlocalIpAddress , cancellationToken ) ;
SendSearchResponse ( device . FullDeviceType , device , GetUsn ( device . Udn , device . FullDeviceType ) , endPoint , receivedOnlocalIpAddress , cancellationToken ) ;
}
private string GetUsn ( string udn , string fullDeviceType )
{
2021-02-14 15:11:46 +01:00
return String . Format ( CultureInfo . InvariantCulture , "{0}::{1}" , udn , fullDeviceType ) ;
2018-09-12 19:26:21 +02:00
}
2019-07-07 21:03:26 +02:00
private async void SendSearchResponse (
string searchTarget ,
SsdpDevice device ,
string uniqueServiceName ,
IPEndPoint endPoint ,
IPAddress receivedOnlocalIpAddress ,
CancellationToken cancellationToken )
2018-09-12 19:26:21 +02:00
{
var rootDevice = device . ToRootDevice ( ) ;
2020-06-14 11:11:11 +02:00
// var additionalheaders = FormatCustomHeadersForResponse(device);
2018-09-12 19:26:21 +02:00
const string header = "HTTP/1.1 200 OK" ;
var values = new Dictionary < string , string > ( StringComparer . OrdinalIgnoreCase ) ;
values [ "EXT" ] = "" ;
values [ "DATE" ] = DateTime . UtcNow . ToString ( "r" ) ;
values [ "CACHE-CONTROL" ] = "max-age = " + rootDevice . CacheLifetime . TotalSeconds ;
values [ "ST" ] = searchTarget ;
2021-02-14 15:11:46 +01:00
values [ "SERVER" ] = string . Format ( CultureInfo . InvariantCulture , "{0}/{1} UPnP/1.0 RSSDP/{2}" , _OSName , _OSVersion , ServerVersion ) ;
2018-09-12 19:26:21 +02:00
values [ "USN" ] = uniqueServiceName ;
values [ "LOCATION" ] = rootDevice . Location . ToString ( ) ;
var message = BuildMessage ( header , values ) ;
try
{
2018-12-16 00:48:40 +01:00
await _CommsServer . SendMessage (
System . Text . Encoding . UTF8 . GetBytes ( message ) ,
endPoint ,
receivedOnlocalIpAddress ,
cancellationToken )
. ConfigureAwait ( false ) ;
2018-09-12 19:26:21 +02:00
}
2018-12-15 19:53:09 +01:00
catch ( Exception )
2018-09-12 19:26:21 +02:00
{
}
2020-06-14 11:11:11 +02:00
// WriteTrace(String.Format("Sent search response to " + endPoint.ToString()), device);
2018-09-12 19:26:21 +02:00
}
2019-07-07 21:03:26 +02:00
private bool IsDuplicateSearchRequest ( string searchTarget , IPEndPoint endPoint )
2018-09-12 19:26:21 +02:00
{
var isDuplicateRequest = false ;
var newRequest = new SearchRequest ( ) { EndPoint = endPoint , SearchTarget = searchTarget , Received = DateTime . UtcNow } ;
lock ( _RecentSearchRequests )
{
if ( _RecentSearchRequests . ContainsKey ( newRequest . Key ) )
{
var lastRequest = _RecentSearchRequests [ newRequest . Key ] ;
if ( lastRequest . IsOld ( ) )
2020-06-20 11:12:36 +02:00
{
2018-09-12 19:26:21 +02:00
_RecentSearchRequests [ newRequest . Key ] = newRequest ;
2020-06-20 11:12:36 +02:00
}
2018-09-12 19:26:21 +02:00
else
2020-06-20 11:19:16 +02:00
{
2018-09-12 19:26:21 +02:00
isDuplicateRequest = true ;
2020-06-20 11:19:16 +02:00
}
2018-09-12 19:26:21 +02:00
}
else
{
_RecentSearchRequests . Add ( newRequest . Key , newRequest ) ;
if ( _RecentSearchRequests . Count > 10 )
2020-06-20 11:12:36 +02:00
{
2018-09-12 19:26:21 +02:00
CleanUpRecentSearchRequestsAsync ( ) ;
2020-06-20 11:12:36 +02:00
}
2018-09-12 19:26:21 +02:00
}
}
return isDuplicateRequest ;
}
private void CleanUpRecentSearchRequestsAsync ( )
{
lock ( _RecentSearchRequests )
{
foreach ( var requestKey in ( from r in _RecentSearchRequests where r . Value . IsOld ( ) select r . Key ) . ToArray ( ) )
{
_RecentSearchRequests . Remove ( requestKey ) ;
}
}
}
private void SendAllAliveNotifications ( object state )
{
try
{
2020-06-20 10:35:29 +02:00
if ( IsDisposed )
{
return ;
}
2018-09-12 19:26:21 +02:00
2020-06-14 11:11:11 +02:00
// WriteTrace("Begin Sending Alive Notifications For All Devices");
2018-09-12 19:26:21 +02:00
SsdpRootDevice [ ] devices ;
lock ( _Devices )
{
devices = _Devices . ToArray ( ) ;
}
foreach ( var device in devices )
{
2020-06-20 10:35:29 +02:00
if ( IsDisposed )
{
return ;
}
2018-09-12 19:26:21 +02:00
SendAliveNotifications ( device , true , CancellationToken . None ) ;
}
2020-06-14 11:11:11 +02:00
// WriteTrace("Completed Sending Alive Notifications For All Devices");
2018-09-12 19:26:21 +02:00
}
catch ( ObjectDisposedException ex )
{
WriteTrace ( "Publisher stopped, exception " + ex . Message ) ;
Dispose ( ) ;
}
}
private void SendAliveNotifications ( SsdpDevice device , bool isRoot , CancellationToken cancellationToken )
{
if ( isRoot )
{
SendAliveNotification ( device , SsdpConstants . UpnpDeviceTypeRootDevice , GetUsn ( device . Udn , SsdpConstants . UpnpDeviceTypeRootDevice ) , cancellationToken ) ;
if ( this . SupportPnpRootDevice )
2020-06-20 11:12:36 +02:00
{
2018-09-12 19:26:21 +02:00
SendAliveNotification ( device , SsdpConstants . PnpDeviceTypeRootDevice , GetUsn ( device . Udn , SsdpConstants . PnpDeviceTypeRootDevice ) , cancellationToken ) ;
2020-06-20 11:12:36 +02:00
}
2018-09-12 19:26:21 +02:00
}
SendAliveNotification ( device , device . Udn , device . Udn , cancellationToken ) ;
SendAliveNotification ( device , device . FullDeviceType , GetUsn ( device . Udn , device . FullDeviceType ) , cancellationToken ) ;
foreach ( var childDevice in device . Devices )
{
SendAliveNotifications ( childDevice , false , cancellationToken ) ;
}
}
private void SendAliveNotification ( SsdpDevice device , string notificationType , string uniqueServiceName , CancellationToken cancellationToken )
{
var rootDevice = device . ToRootDevice ( ) ;
const string header = "NOTIFY * HTTP/1.1" ;
var values = new Dictionary < string , string > ( StringComparer . OrdinalIgnoreCase ) ;
2019-01-08 00:24:34 +01:00
// If needed later for non-server devices, these headers will need to be dynamic
2018-09-12 19:26:21 +02:00
values [ "HOST" ] = "239.255.255.250:1900" ;
values [ "DATE" ] = DateTime . UtcNow . ToString ( "r" ) ;
values [ "CACHE-CONTROL" ] = "max-age = " + rootDevice . CacheLifetime . TotalSeconds ;
values [ "LOCATION" ] = rootDevice . Location . ToString ( ) ;
2021-02-14 15:11:46 +01:00
values [ "SERVER" ] = string . Format ( CultureInfo . InvariantCulture , "{0}/{1} UPnP/1.0 RSSDP/{2}" , _OSName , _OSVersion , ServerVersion ) ;
2018-09-12 19:26:21 +02:00
values [ "NTS" ] = "ssdp:alive" ;
values [ "NT" ] = notificationType ;
values [ "USN" ] = uniqueServiceName ;
var message = BuildMessage ( header , values ) ;
2019-02-23 03:15:38 +01:00
_CommsServer . SendMulticastMessage ( message , _sendOnlyMatchedHost ? rootDevice . Address : null , cancellationToken ) ;
2018-09-12 19:26:21 +02:00
2020-06-14 11:11:11 +02:00
// WriteTrace(String.Format("Sent alive notification"), device);
2018-09-12 19:26:21 +02:00
}
private Task SendByeByeNotifications ( SsdpDevice device , bool isRoot , CancellationToken cancellationToken )
{
var tasks = new List < Task > ( ) ;
if ( isRoot )
{
tasks . Add ( SendByeByeNotification ( device , SsdpConstants . UpnpDeviceTypeRootDevice , GetUsn ( device . Udn , SsdpConstants . UpnpDeviceTypeRootDevice ) , cancellationToken ) ) ;
if ( this . SupportPnpRootDevice )
2020-06-20 11:12:36 +02:00
{
2018-09-12 19:26:21 +02:00
tasks . Add ( SendByeByeNotification ( device , "pnp:rootdevice" , GetUsn ( device . Udn , "pnp:rootdevice" ) , cancellationToken ) ) ;
2020-06-20 11:12:36 +02:00
}
2018-09-12 19:26:21 +02:00
}
tasks . Add ( SendByeByeNotification ( device , device . Udn , device . Udn , cancellationToken ) ) ;
2021-02-14 15:11:46 +01:00
tasks . Add ( SendByeByeNotification ( device , String . Format ( CultureInfo . InvariantCulture , "urn:{0}" , device . FullDeviceType ) , GetUsn ( device . Udn , device . FullDeviceType ) , cancellationToken ) ) ;
2018-09-12 19:26:21 +02:00
foreach ( var childDevice in device . Devices )
{
tasks . Add ( SendByeByeNotifications ( childDevice , false , cancellationToken ) ) ;
}
return Task . WhenAll ( tasks ) ;
}
[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Naming", "CA2204:Literals should be spelled correctly", MessageId = "byebye", Justification = "Correct value for this type of notification in SSDP.")]
private Task SendByeByeNotification ( SsdpDevice device , string notificationType , string uniqueServiceName , CancellationToken cancellationToken )
{
const string header = "NOTIFY * HTTP/1.1" ;
var values = new Dictionary < string , string > ( StringComparer . OrdinalIgnoreCase ) ;
2019-01-08 00:24:34 +01:00
// If needed later for non-server devices, these headers will need to be dynamic
2018-09-12 19:26:21 +02:00
values [ "HOST" ] = "239.255.255.250:1900" ;
values [ "DATE" ] = DateTime . UtcNow . ToString ( "r" ) ;
2021-02-14 15:11:46 +01:00
values [ "SERVER" ] = string . Format ( CultureInfo . InvariantCulture , "{0}/{1} UPnP/1.0 RSSDP/{2}" , _OSName , _OSVersion , ServerVersion ) ;
2018-09-12 19:26:21 +02:00
values [ "NTS" ] = "ssdp:byebye" ;
values [ "NT" ] = notificationType ;
values [ "USN" ] = uniqueServiceName ;
var message = BuildMessage ( header , values ) ;
var sendCount = IsDisposed ? 1 : 3 ;
2021-02-14 15:11:46 +01:00
WriteTrace ( String . Format ( CultureInfo . InvariantCulture , "Sent byebye notification" ) , device ) ;
2019-02-23 03:15:38 +01:00
return _CommsServer . SendMulticastMessage ( message , sendCount , _sendOnlyMatchedHost ? device . ToRootDevice ( ) . Address : null , cancellationToken ) ;
2018-09-12 19:26:21 +02:00
}
private void DisposeRebroadcastTimer ( )
{
var timer = _RebroadcastAliveNotificationsTimer ;
_RebroadcastAliveNotificationsTimer = null ;
if ( timer ! = null )
2020-06-20 11:12:36 +02:00
{
2018-09-12 19:26:21 +02:00
timer . Dispose ( ) ;
2020-06-20 11:12:36 +02:00
}
2018-09-12 19:26:21 +02:00
}
private TimeSpan GetMinimumNonZeroCacheLifetime ( )
{
2020-06-20 11:12:36 +02:00
var nonzeroCacheLifetimesQuery = (
from device
in _Devices
where device . CacheLifetime ! = TimeSpan . Zero
select device . CacheLifetime ) . ToList ( ) ;
2018-09-12 19:26:21 +02:00
if ( nonzeroCacheLifetimesQuery . Any ( ) )
2020-06-20 11:12:36 +02:00
{
2018-09-12 19:26:21 +02:00
return nonzeroCacheLifetimesQuery . Min ( ) ;
2020-06-20 11:12:36 +02:00
}
2018-09-12 19:26:21 +02:00
else
2020-06-20 11:12:36 +02:00
{
2018-09-12 19:26:21 +02:00
return TimeSpan . Zero ;
2020-06-20 11:12:36 +02:00
}
2018-09-12 19:26:21 +02:00
}
private string GetFirstHeaderValue ( System . Net . Http . Headers . HttpRequestHeaders httpRequestHeaders , string headerName )
{
string retVal = null ;
IEnumerable < String > values = null ;
if ( httpRequestHeaders . TryGetValues ( headerName , out values ) & & values ! = null )
2020-06-20 11:12:36 +02:00
{
2018-09-12 19:26:21 +02:00
retVal = values . FirstOrDefault ( ) ;
2020-06-20 11:12:36 +02:00
}
2018-09-12 19:26:21 +02:00
return retVal ;
}
public Action < string > LogFunction { get ; set ; }
private void WriteTrace ( string text )
{
if ( LogFunction ! = null )
{
LogFunction ( text ) ;
}
2020-06-14 11:11:11 +02:00
// System.Diagnostics.Debug.WriteLine(text, "SSDP Publisher");
2018-09-12 19:26:21 +02:00
}
private void WriteTrace ( string text , SsdpDevice device )
{
var rootDevice = device as SsdpRootDevice ;
if ( rootDevice ! = null )
2020-06-20 11:12:36 +02:00
{
2018-09-12 19:26:21 +02:00
WriteTrace ( text + " " + device . DeviceType + " - " + device . Uuid + " - " + rootDevice . Location ) ;
2020-06-20 11:12:36 +02:00
}
2018-09-12 19:26:21 +02:00
else
2020-06-20 11:19:16 +02:00
{
2018-09-12 19:26:21 +02:00
WriteTrace ( text + " " + device . DeviceType + " - " + device . Uuid ) ;
2020-06-20 11:19:16 +02:00
}
2018-09-12 19:26:21 +02:00
}
private void CommsServer_RequestReceived ( object sender , RequestReceivedEventArgs e )
{
2020-06-20 10:35:29 +02:00
if ( this . IsDisposed )
{
return ;
}
2018-09-12 19:26:21 +02:00
if ( string . Equals ( e . Message . Method . Method , SsdpConstants . MSearchMethod , StringComparison . OrdinalIgnoreCase ) )
{
2020-06-14 11:11:11 +02:00
// According to SSDP/UPnP spec, ignore message if missing these headers.
2018-09-12 19:26:21 +02:00
// Edit: But some devices do it anyway
2020-06-14 11:11:11 +02:00
// if (!e.Message.Headers.Contains("MX"))
2019-01-08 00:24:34 +01:00
// WriteTrace("Ignoring search request - missing MX header.");
2020-06-14 11:11:11 +02:00
// else if (!e.Message.Headers.Contains("MAN"))
2019-01-08 00:24:34 +01:00
// WriteTrace("Ignoring search request - missing MAN header.");
2020-06-14 11:11:11 +02:00
// else
2018-09-12 19:26:21 +02:00
ProcessSearchRequest ( GetFirstHeaderValue ( e . Message . Headers , "MX" ) , GetFirstHeaderValue ( e . Message . Headers , "ST" ) , e . ReceivedFrom , e . LocalIpAddress , CancellationToken . None ) ;
}
}
private class SearchRequest
{
2019-07-07 21:03:26 +02:00
public IPEndPoint EndPoint { get ; set ; }
2020-06-15 23:43:52 +02:00
2018-09-12 19:26:21 +02:00
public DateTime Received { get ; set ; }
2020-06-15 23:43:52 +02:00
2018-09-12 19:26:21 +02:00
public string SearchTarget { get ; set ; }
public string Key
{
get { return this . SearchTarget + ":" + this . EndPoint . ToString ( ) ; }
}
public bool IsOld ( )
{
return DateTime . UtcNow . Subtract ( this . Received ) . TotalMilliseconds > 500 ;
}
}
2016-10-30 00:22:20 +02:00
}
2018-12-15 19:53:09 +01:00
}