269 lines
11 KiB
C#
269 lines
11 KiB
C#
//
|
|
// Authors:
|
|
// Ben Motmans <ben.motmans@gmail.com>
|
|
// Lucas Ontivero lucasontivero@gmail.com
|
|
//
|
|
// Copyright (C) 2007 Ben Motmans
|
|
// Copyright (C) 2014 Lucas Ontivero
|
|
//
|
|
// Permission is hereby granted, free of charge, to any person obtaining
|
|
// a copy of this software and associated documentation files (the
|
|
// "Software"), to deal in the Software without restriction, including
|
|
// without limitation the rights to use, copy, modify, merge, publish,
|
|
// distribute, sublicense, and/or sell copies of the Software, and to
|
|
// permit persons to whom the Software is furnished to do so, subject to
|
|
// the following conditions:
|
|
//
|
|
// The above copyright notice and this permission notice shall be
|
|
// included in all copies or substantial portions of the Software.
|
|
//
|
|
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
|
|
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
//
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Net;
|
|
using System.Diagnostics;
|
|
using System.Net.Sockets;
|
|
using System.Threading;
|
|
using System.Xml;
|
|
|
|
namespace Open.Nat
|
|
{
|
|
internal class UpnpSearcher : Searcher
|
|
{
|
|
private readonly IIPAddressesProvider _ipprovider;
|
|
private readonly IDictionary<Uri, NatDevice> _devices;
|
|
private readonly Dictionary<IPAddress, DateTime> _lastFetched;
|
|
private static readonly string[] ServiceTypes = new[]{
|
|
"WANIPConnection:2",
|
|
"WANPPPConnection:2",
|
|
"WANIPConnection:1",
|
|
"WANPPPConnection:1"
|
|
};
|
|
|
|
internal UpnpSearcher(IIPAddressesProvider ipprovider)
|
|
{
|
|
_ipprovider = ipprovider;
|
|
Sockets = CreateSockets();
|
|
_devices = new Dictionary<Uri, NatDevice>();
|
|
_lastFetched = new Dictionary<IPAddress, DateTime>();
|
|
}
|
|
|
|
private List<UdpClient> CreateSockets()
|
|
{
|
|
var clients = new List<UdpClient>();
|
|
try
|
|
{
|
|
var ips = _ipprovider.UnicastAddresses();
|
|
|
|
foreach (var ipAddress in ips)
|
|
{
|
|
try
|
|
{
|
|
clients.Add(new UdpClient(new IPEndPoint(ipAddress, 0)));
|
|
}
|
|
catch (Exception)
|
|
{
|
|
continue; // Move on to the next address.
|
|
}
|
|
}
|
|
}
|
|
catch (Exception)
|
|
{
|
|
clients.Add(new UdpClient(0));
|
|
}
|
|
return clients;
|
|
}
|
|
|
|
protected override void Discover(UdpClient client, CancellationToken cancelationToken)
|
|
{
|
|
NextSearch = DateTime.UtcNow.AddSeconds(1);
|
|
var searchEndpoint = new IPEndPoint(
|
|
WellKnownConstants.IPv4MulticastAddress
|
|
/*IPAddress.Broadcast*/
|
|
, 1900);
|
|
|
|
foreach (var serviceType in ServiceTypes)
|
|
{
|
|
var datax = DiscoverDeviceMessage.Encode(serviceType);
|
|
var data = Encoding.ASCII.GetBytes(datax);
|
|
|
|
// UDP is unreliable, so send 3 requests at a time (per Upnp spec, sec 1.1.2)
|
|
// Yes, however it works perfectly well with just 1 request.
|
|
for (var i = 0; i < 2; i++)
|
|
{
|
|
if (cancelationToken.IsCancellationRequested) return;
|
|
client.Send(data, data.Length, searchEndpoint);
|
|
}
|
|
}
|
|
}
|
|
|
|
public override NatDevice AnalyseReceivedResponse(IPAddress localAddress, byte[] response, IPEndPoint endpoint)
|
|
{
|
|
// Convert it to a string for easy parsing
|
|
string dataString = null;
|
|
|
|
// No matter what, this method should never throw an exception. If something goes wrong
|
|
// we should still be in a position to handle the next reply correctly.
|
|
try
|
|
{
|
|
dataString = Encoding.UTF8.GetString(response);
|
|
var message = new DiscoveryResponseMessage(dataString);
|
|
var serviceType = message["ST"];
|
|
|
|
NatDiscoverer.TraceSource.TraceEvent(TraceEventType.Verbose, 0, "UPnP Response: {0}", dataString);
|
|
|
|
if (!IsValidControllerService(serviceType)) return null;
|
|
NatDiscoverer.TraceSource.LogInfo("UPnP Response: Router advertised a '{0}' service!!!", serviceType);
|
|
|
|
var location = message["Location"];
|
|
var locationUri = new Uri(location);
|
|
|
|
NatDiscoverer.TraceSource.LogInfo("Found device at: {0}", locationUri.ToString());
|
|
|
|
if (_devices.ContainsKey(locationUri))
|
|
{
|
|
NatDiscoverer.TraceSource.LogInfo("Already found - Ignored");
|
|
_devices[locationUri].Touch();
|
|
return null;
|
|
}
|
|
|
|
// If we send 3 requests at a time, ensure we only fetch the services list once
|
|
// even if three responses are received
|
|
if (_lastFetched.ContainsKey(endpoint.Address))
|
|
{
|
|
var last = _lastFetched[endpoint.Address];
|
|
if ((DateTime.Now - last) < TimeSpan.FromSeconds(20))
|
|
return null;
|
|
}
|
|
_lastFetched[endpoint.Address] = DateTime.Now;
|
|
|
|
NatDiscoverer.TraceSource.LogInfo("{0}:{1}: Fetching service list", locationUri.Host, locationUri.Port );
|
|
|
|
var deviceInfo = BuildUpnpNatDeviceInfo(localAddress, locationUri);
|
|
|
|
UpnpNatDevice device;
|
|
lock (_devices)
|
|
{
|
|
device = new UpnpNatDevice(deviceInfo);
|
|
if (!_devices.ContainsKey(locationUri))
|
|
{
|
|
_devices.Add(locationUri, device);
|
|
}
|
|
}
|
|
return device;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
NatDiscoverer.TraceSource.LogError("Unhandled exception when trying to decode a device's response. ");
|
|
NatDiscoverer.TraceSource.LogError("Report the issue in https://github.com/lontivero/Open.Nat/issues");
|
|
NatDiscoverer.TraceSource.LogError("Also copy and paste the following info:");
|
|
NatDiscoverer.TraceSource.LogError("-- beging ---------------------------------");
|
|
NatDiscoverer.TraceSource.LogError(ex.Message);
|
|
NatDiscoverer.TraceSource.LogError("Data string:");
|
|
NatDiscoverer.TraceSource.LogError(dataString ?? "No data available");
|
|
NatDiscoverer.TraceSource.LogError("-- end ------------------------------------");
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static bool IsValidControllerService(string serviceType)
|
|
{
|
|
var services = from serviceName in ServiceTypes
|
|
let serviceUrn = string.Format("urn:schemas-upnp-org:service:{0}", serviceName)
|
|
where serviceType.ContainsIgnoreCase(serviceUrn)
|
|
select new {ServiceName = serviceName, ServiceUrn = serviceUrn};
|
|
|
|
return services.Any();
|
|
}
|
|
|
|
private UpnpNatDeviceInfo BuildUpnpNatDeviceInfo(IPAddress localAddress, Uri location)
|
|
{
|
|
NatDiscoverer.TraceSource.LogInfo("Found device at: {0}", location.ToString());
|
|
|
|
var hostEndPoint = new IPEndPoint(IPAddress.Parse(location.Host), location.Port);
|
|
|
|
WebResponse response = null;
|
|
try
|
|
{
|
|
var request = WebRequest.CreateHttp(location);
|
|
request.Headers.Add("ACCEPT-LANGUAGE", "en");
|
|
request.Method = "GET";
|
|
|
|
response = request.GetResponse();
|
|
|
|
var httpresponse = response as HttpWebResponse;
|
|
|
|
if (httpresponse != null && httpresponse.StatusCode != HttpStatusCode.OK)
|
|
{
|
|
var message = string.Format("Couldn't get services list: {0} {1}", httpresponse.StatusCode, httpresponse.StatusDescription);
|
|
throw new Exception(message);
|
|
}
|
|
|
|
var xmldoc = ReadXmlResponse(response);
|
|
|
|
NatDiscoverer.TraceSource.LogInfo("{0}: Parsed services list", hostEndPoint);
|
|
|
|
var ns = new XmlNamespaceManager(xmldoc.NameTable);
|
|
ns.AddNamespace("ns", "urn:schemas-upnp-org:device-1-0");
|
|
var services = xmldoc.SelectNodes("//ns:service", ns);
|
|
|
|
foreach (XmlNode service in services)
|
|
{
|
|
var serviceType = service.GetXmlElementText("serviceType");
|
|
if (!IsValidControllerService(serviceType)) continue;
|
|
|
|
NatDiscoverer.TraceSource.LogInfo("{0}: Found service: {1}", hostEndPoint, serviceType);
|
|
|
|
var serviceControlUrl = service.GetXmlElementText("controlURL");
|
|
NatDiscoverer.TraceSource.LogInfo("{0}: Found upnp service at: {1}", hostEndPoint, serviceControlUrl);
|
|
|
|
NatDiscoverer.TraceSource.LogInfo("{0}: Handshake Complete", hostEndPoint);
|
|
return new UpnpNatDeviceInfo(localAddress, location, serviceControlUrl, serviceType);
|
|
}
|
|
|
|
throw new Exception("No valid control service was found in the service descriptor document");
|
|
}
|
|
catch (WebException ex)
|
|
{
|
|
// Just drop the connection, FIXME: Should i retry?
|
|
NatDiscoverer.TraceSource.LogError("{0}: Device denied the connection attempt: {1}", hostEndPoint, ex);
|
|
var inner = ex.InnerException as SocketException;
|
|
if (inner != null)
|
|
{
|
|
NatDiscoverer.TraceSource.LogError("{0}: ErrorCode:{1}", hostEndPoint, inner.ErrorCode);
|
|
NatDiscoverer.TraceSource.LogError("Go to http://msdn.microsoft.com/en-us/library/system.net.sockets.socketerror.aspx");
|
|
NatDiscoverer.TraceSource.LogError("Usually this happens. Try resetting the device and try again. If you are in a VPN, disconnect and try again.");
|
|
}
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
if (response != null)
|
|
response.Close();
|
|
}
|
|
}
|
|
|
|
private static XmlDocument ReadXmlResponse(WebResponse response)
|
|
{
|
|
using (var reader = new StreamReader(response.GetResponseStream(), Encoding.UTF8))
|
|
{
|
|
var servicesXml = reader.ReadToEnd();
|
|
var xmldoc = new XmlDocument();
|
|
xmldoc.LoadXml(servicesXml);
|
|
return xmldoc;
|
|
}
|
|
}
|
|
}
|
|
}
|