UPnPAction.cs

using System;
using System.IO;
using System.Collections.Generic;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using System.Xml;
 
namespace Waher.Networking.UPnP
{
    public class UPnPAction
    {
        private readonly Dictionary<string, UPnPArgument> argumentByName = new Dictionary<string, UPnPArgument>();
        private readonly ServiceDescriptionDocument parent;
        private readonly XmlElement xml;
        private readonly UPnPArgument[] arguments;
        private readonly string name;
 
        internal UPnPAction(XmlElement Xml, ServiceDescriptionDocument Parent)
        {
            List<UPnPArgument> Arguments = new List<UPnPArgument>();
 
            this.parent = Parent;
            this.xml = Xml;
 
            foreach (XmlNode N in Xml.ChildNodes)
            {
                switch (N.LocalName)
                {
                    case "name":
                        this.name = N.InnerText;
                        break;
 
                    case "argumentList":
                        foreach (XmlNode N2 in N.ChildNodes)
                        {
                            if (N2.LocalName == "argument")
                            {
                                UPnPArgument Argument = new UPnPArgument((XmlElement)N2);
                                Arguments.Add(Argument);
                                this.argumentByName[Argument.Name] = Argument;
                            }
                        }
                        break;
                }
            }
 
            this.arguments = Arguments.ToArray();
        }
 
        public XmlElement Xml => this.xml;
 
        public string Name => this.name;
 
        public UPnPArgument[] Arguments => this.arguments;
 
        public ServiceDescriptionDocument ServiceDescriptionDocument => this.parent;
 
        public object Invoke(out Dictionary<string, object> OutputValues, params KeyValuePair<string, object>[] InputValues)
        {
            return this.Invoke(out OutputValues, 10000, InputValues);
        }
 
        public object Invoke(Dictionary<string, object> InputValues, out Dictionary<string, object> OutputValues)
        {
            return this.Invoke(InputValues, out OutputValues, 10000);
        }
 
        public object Invoke(out Dictionary<string, object> OutputValues, int Timeout, params KeyValuePair<string, object>[] InputValues)
        {
            Dictionary<string, object> InputValues2 = new Dictionary<string, object>();
 
            foreach (KeyValuePair<string, object> P in InputValues)
                InputValues2[P.Key] = P.Value;
 
            return this.Invoke(InputValues2, out OutputValues, Timeout);
        }
 
        public object Invoke(Dictionary<string, object> InputValues, out Dictionary<string, object> OutputValues, int Timeout)
        {
            KeyValuePair<object, Dictionary<string, object>> Result = this.InvokeAsync(InputValues, Timeout).Result;
            OutputValues = Result.Value;
            return Result.Key;
        }
 
        public Task<KeyValuePair<object, Dictionary<string, object>>> InvokeAsync(int Timeout, params KeyValuePair<string, object>[] InputValues)
        {
            Dictionary<string, object> InputValues2 = new Dictionary<string, object>();
 
            foreach (KeyValuePair<string, object> P in InputValues)
                InputValues2[P.Key] = P.Value;
 
            return this.InvokeAsync(InputValues2, Timeout);
        }
 
        public async Task<KeyValuePair<object, Dictionary<string, object>>> InvokeAsync(Dictionary<string, object> InputValues, int Timeout)
        {
            Dictionary<string, object> OutputValues;
            StringBuilder Soap = new StringBuilder();
            UPnPStateVariable Variable;
            object Result = null;
            object First = null;
 
            Soap.AppendLine("<?xml version=\"1.0\"?>");
            Soap.AppendLine("<s:Envelope xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">");
            Soap.AppendLine("<s:Body>");
            Soap.Append("<u:");
            Soap.Append(this.name);
            Soap.Append(" xmlns:u=\"");
            Soap.Append(XmlAttributeEncode(this.parent.Service.ServiceType));
            Soap.AppendLine("\">");
 
            foreach (UPnPArgument Argument in this.arguments)
            {
                if (Argument.Direction == ArgumentDirection.In)
                {
                    Soap.Append("<");
                    Soap.Append(Argument.Name);
                    Soap.Append(">");
 
                    if (InputValues.TryGetValue(Argument.Name, out object Value) &&
                        !((Variable = this.parent.GetVariable(Argument.RelatedStateVariable)) is null))
                    {
                        Soap.Append(XmlAttributeEncode(await Variable.ValueToXmlString(Value)));
                    }
 
                    Soap.Append("</");
                    Soap.Append(Argument.Name);
                    Soap.Append(">");
                }
            }
 
            Soap.Append("</u:");
            Soap.Append(this.name);
            Soap.AppendLine(">");
            Soap.AppendLine("</s:Body>");
            Soap.AppendLine("</s:Envelope>");
 
            using (HttpClient HttpClient = new HttpClient())
            {
                HttpClient.Timeout = TimeSpan.FromMilliseconds(Timeout);
                HttpClient.DefaultRequestHeaders.ExpectContinue = false;
 
                HttpContent Body = new StringContent(Soap.ToString(), Encoding.UTF8, "text/xml");
                Body.Headers.Add("SOAPACTION", "\"" + this.parent.Service.ServiceType + "#" + this.name + "\"");
 
                XmlDocument ResponseXml;
 
                HttpResponseMessage Response = await HttpClient.PostAsync(this.parent.Service.ControlURI, Body);
                Stream Stream = await Response.Content.ReadAsStreamAsync(); // Regardless of status code, we check for XML content.
 
                ResponseXml = new XmlDocument()
                {
                    PreserveWhitespace = true
                };
                ResponseXml.Load(Stream);
 
                if (ResponseXml.DocumentElement is null ||
                    ResponseXml.DocumentElement.LocalName != "Envelope" ||
                    ResponseXml.DocumentElement.NamespaceURI != "http://schemas.xmlsoap.org/soap/envelope/")
                {
                    throw new Exception("Unexpected response returned.");
                }
 
                XmlElement ResponseBody = GetChildElement(ResponseXml.DocumentElement, "Body", "http://schemas.xmlsoap.org/soap/envelope/")
                    ?? throw new Exception("Response body not found.");
 
                XmlElement ActionResponse = GetChildElement(ResponseBody, this.name + "Response", this.parent.Service.ServiceType);
                if (ActionResponse is null)
                {
                    XmlElement ResponseFault = GetChildElement(ResponseBody, "Fault", "http://schemas.xmlsoap.org/soap/envelope/")
                        ?? throw new Exception("Unable to parse response.");
 
                    string FaultCode = string.Empty;
                    string FaultString = string.Empty;
                    string UPnPErrorCode = string.Empty;
                    string UPnPErrorDescription = string.Empty;
 
                    foreach (XmlNode N in ResponseFault.ChildNodes)
                    {
                        switch (N.LocalName)
                        {
                            case "faultcode":
                                FaultCode = N.InnerText;
                                break;
 
                            case "faultstring":
                                FaultString = N.InnerText;
                                break;
 
                            case "detail":
                                foreach (XmlNode N2 in N.ChildNodes)
                                {
                                    switch (N2.LocalName)
                                    {
                                        case "UPnPError":
                                            foreach (XmlNode N3 in N2.ChildNodes)
                                            {
                                                switch (N3.LocalName)
                                                {
                                                    case "errorCode":
                                                        UPnPErrorCode = N3.InnerText;
                                                        break;
 
                                                    case "errorDescription":
                                                        UPnPErrorDescription = N3.InnerText;
                                                        break;
                                                }
                                            }
                                            break;
                                    }
                                }
                                break;
                        }
                    }
 
                    throw new UPnPException(FaultCode, FaultString, UPnPErrorCode, UPnPErrorDescription);
                }
 
                XmlElement E;
 
                OutputValues = new Dictionary<string, object>();
 
                foreach (XmlNode N in ActionResponse.ChildNodes)
                {
                    E = N as XmlElement;
                    if (E is null)
                        continue;
 
                    if (this.argumentByName.TryGetValue(E.LocalName, out UPnPArgument Argument2))
                    {
                        if (!((Variable = this.parent.GetVariable(Argument2.RelatedStateVariable)) is null))
                        {
                            object Value2 = Variable.XmlStringToValue(E.InnerText);
                            OutputValues[E.LocalName] = Value2;
 
                            if (First is null)
                                First = Value2;
 
                            if (Argument2.ReturnValue && Result is null)
                                Result = Value2;
                        }
                        else
                        {
                            if (First is null)
                                First = E.InnerXml;
 
                            OutputValues[E.LocalName] = E.InnerXml;
                        }
                    }
                    else
                    {
                        if (First is null)
                            First = E.InnerXml;
 
                        OutputValues[E.LocalName] = E.InnerXml;
                    }
                }
            }
 
            if (Result is null)
                Result = First;
 
            return new KeyValuePair<object, Dictionary<string, object>>(Result, OutputValues);
        }
 
        private static XmlElement GetChildElement(XmlElement E, string LocalName, string Namespace)
        {
            XmlElement E2;
 
            foreach (XmlNode N in E.ChildNodes)
            {
                E2 = N as XmlElement;
                if (E2 is null)
                    continue;
 
                if (E2.LocalName == LocalName && E2.NamespaceURI == Namespace)
                    return E2;
            }
 
            return null;
        }
 
        public static string XmlAttributeEncode(string AttributeValue)
        {
            if (AttributeValue is null || AttributeValue.IndexOfAny(reservedCharacters) < 0)
                return AttributeValue;
 
            return AttributeValue.
                Replace("&", "&amp;").
                Replace("<", "&lt;").
                Replace(">", "&gt;").
                Replace("\"", "&quot;").
                Replace("'", "&apos;");
        }
 
        private static readonly char[] reservedCharacters = new char[] { '&', '<', '>', '"', '\'' };
 
    }
}