RPCmin_XML (minimal XML-RPC client) in C#

using System;
using System.Collections;
using System.Collections.Generic;
using System.Xml;
using System.IO;
using System.Text;
using System.Net;

using UnityEngine;

public class RPCmin_XML
{
    public class RPCFault
    { // a simple struct with a code and a string. All errors will be given to you as one of these
        public int FaultCode = 400; // if there's a better "generic fault", let me know
        public string FaultString;

        public RPCFault(string faultString = "") { FaultString = faultString; }
    };

    public string URL;

    public RPCmin_XML(string _URL = null)
    { // hang on to the URL. If we make several calls, it'll likely be to the same URL
        URL = _URL;
    }

    // the following calls are Unity-specific. If you're using generic C#, use the blocking calls or roll your own threaded version
    public static MonoBehaviour MBHook { protected get; set; } = null; // coroutines require a monobehavior, so we'll hook into an existing one. Set this to a monobehavior (preferably a singleton) for the coroutine

    public bool Call(MonoBehaviour mBHook, string method, object[] parms = null, Action<object> fnSuccess = null, Action<RPCFault> fnFault = null)
    {
        MBHook = mBHook;
        return Call(method, parms, fnSuccess, fnFault);
    }

    public bool Call(string method, object[] parms = null, Action<object> fnSuccess = null, Action<RPCFault> fnFault = null)
    { // non-blocking call that returns immediately and returns success or fault as actions. Returns true if call was sent
        bool RetVal = false;
        if ((URL != null) && (MBHook != null))
        { // build the request
            var Form = new WWWForm();
            var Headers = Form.headers;
            Headers["Content-Type"] = "text/xml;charset=UTF-8";

            string Request = EncodeXMLRPCRequest(method, parms);
//          Debug.Log(Request);
            var wwwRequest = new WWW(URL, Encoding.UTF8.GetBytes(Request), Headers);

            MBHook.StartCoroutine(WaitForRequest(wwwRequest, fnSuccess, fnFault)); //  Start a coroutine which will wait until our servers comes back
            RetVal = true;
        }
        return RetVal;
    }

    static public bool RPCXMLCall(string _URL, MonoBehaviour mBHook, string method, object[] parms = null, Action<object> fnSuccess = null, Action<RPCFault> fnFault = null)
    { // if you're just making one call, do this. It'll make the call, return from whence it came, and then disappear
        return new RPCmin_XML(_URL).Call(mBHook, method, parms, fnSuccess, fnFault);
    }

    static public bool RPCXMLCall(string _URL, string method, object[] parms = null, Action<object> fnSuccess = null, Action<RPCFault> fnFault = null)
    { // if you're just making one call, do this. It'll make the call, return from whence it came, and then disappear
        return new RPCmin_XML(_URL).Call(method, parms, fnSuccess, fnFault);
    }

    protected IEnumerator WaitForRequest(WWW wwwResult, Action<object> fnSuccess, Action<RPCFault> fnFault)
    { // coroutine that yields until a result appears. Might want to add a timeout here eventually.
        yield return wwwResult;

        if (String.IsNullOrEmpty(wwwResult.error))
        { // parse the XML and see if there's a fault
            string HTMLResult = Encoding.UTF8.GetString(wwwResult.bytes);
            object Ob = DecodeXMLRPCResult(HTMLResult);
            if (Ob == null)
                fnFault.Invoke(new RPCFault("Could not parse " + HTMLResult)); // not something parse-able
            else if (Ob.GetType().ToString().Contains("RPCFault"))
                fnFault.Invoke((RPCFault)Ob); // RPC didn't run, most likely passed it bogus info
            else
                fnSuccess.Invoke(Ob); // returned a non-fault object, which is good
        }
        else
        { // we got some error text from the http server
            RPCFault Fault = new RPCFault(wwwResult.error);

            if ((wwwResult.responseHeaders != null) && wwwResult.responseHeaders.ContainsKey("STATUS"))
            { // getting the numeric fault code isn't easy
                string[] StatusStrs = wwwResult.responseHeaders["STATUS"].Split(' ');
                int StatusInt;
                if ((StatusStrs.Length >= 3) && int.TryParse(StatusStrs[1], out StatusInt))
                    Fault.FaultCode = StatusInt; // the second value was a number, so assumme it's the fault code
            }
            fnFault.Invoke(Fault);
        }
    }
    // End of the Unity-specific stuff

    public static RPCFault Fault(object Ob)
    { // pass the result of the Call() below here, it will return a RPCFault if it's a fault, or null if not
        return Ob.GetType().Equals(typeof(RPCFault)) ? (RPCFault)Ob : null;
    }

    public object Call(string method, object[] parms = null)
    { // returns an object that you can cast to the results you expect, null if there is no URL, or a RPCmin_XML.RPCFault if there is a fault
        object RetVal = null;
        if (URL != null)
        { // build the request
            HttpWebRequest HTTPRequest = (HttpWebRequest)WebRequest.Create(URL);
            HTTPRequest.Method = "POST";
            HTTPRequest.ContentType = "text/xml";

            // Add the request stream.
            Stream RequestStream = HTTPRequest.GetRequestStream();
            string Request = EncodeXMLRPCRequest(method, parms);
//          Debug.Log(Request);
            byte[] Bytes = Encoding.UTF8.GetBytes(Request);
            RequestStream.Write(Bytes, 0, Bytes.Length);
            RequestStream.Close();

            HttpWebResponse HTTPResponse = (HttpWebResponse)HTTPRequest.GetResponse(); // Now send it off

            // And we're (hopefully) back. Get the response as a stream with the required encoding format.
            StreamReader ReadStream = new StreamReader(HTTPResponse.GetResponseStream(), Encoding.UTF8);
            RetVal = DecodeXMLRPCResult(ReadStream.ReadToEnd()); // now parse the received XML back into an object
            ReadStream.Close();

            HTTPResponse.Close();
        }
        return RetVal;
    }

    // End of the public interface

    protected const string XMLRPC_STRING = "string"; // string
    protected const string XMLRPC_INT = "int"; // int
    protected const string XMLRPC_I4 = "i4"; // int
    protected const string XMLRPC_DOUBLE = "double"; // double, float
    protected const string XMLRPC_BOOLEAN = "boolean"; // bool
    protected const string XMLRPC_ARRAY = "array"; // Array
    protected const string XMLRPC_STRUCT = "struct"; // Hashtable
    protected const string XMLRPC_DATE = "dateTime.iso8601"; // DateTimeOffset (preferred) or DateTime
    protected const string XMLRPC_BASE64 = "base64"; // byte[]

    protected string XMLRPCTypeOf(object obValue)
    { // converts a C# type to its equivalent in XMLRPC
        Type ObType = obValue.GetType();

        if (ObType.Equals(typeof(int)) || ObType.Equals(typeof(uint)) || ObType.Equals(typeof(short)) || ObType.Equals(typeof(ushort)))
            return XMLRPC_INT; // you can send all kinds of ints, but only an standard 32-bit signed int comes back
        else if (ObType.Equals(typeof(double)) || ObType.Equals(typeof(float)))
            return XMLRPC_DOUBLE; // you can send floats or doubles, but only a double comes back
        else if (ObType.Equals(typeof(bool)))
            return XMLRPC_BOOLEAN;
        else if (ObType.Equals(typeof(Hashtable)))
            return XMLRPC_STRUCT;
        else if (ObType.Equals(typeof(DateTime)) || ObType.Equals(typeof(DateTimeOffset)))
            return XMLRPC_DATE; // you can pass a DateTime or a DateTimeOffset. A DateTimeOffset comes back
        else if (ObType.Equals(typeof(byte[])))
            return XMLRPC_BASE64; // It converts to Base64 and back, so you'll get a byte[] back
        else if (ObType.IsArray)
            return XMLRPC_ARRAY;
        else // everything else is a string, per the spec
            return XMLRPC_STRING;
    }

    protected string EncodeXMLRPCValue(object obValue)
    { // figures out what an object is, converts it to a string, and returns it bracketed with <value><type>
        String RetVal = null;
        string TypeStr = XMLRPCTypeOf(obValue);

        switch (TypeStr)
        {
            case XMLRPC_INT:
                RetVal = ((int)obValue).ToString();
            break;

            case XMLRPC_DOUBLE:
                RetVal = ((double)obValue).ToString();
            break;

            case XMLRPC_BOOLEAN:
                RetVal = (((bool)obValue) ? "1" : "0");
            break;

            case XMLRPC_ARRAY:
            {
                StringBuilder S = new StringBuilder();
                foreach (object Ob in (Array)obValue)
                {
                    string Node = EncodeXMLRPCValue(Ob);
                    if (Node != null)
                        S.AppendLine(Node);
                }

                if (S.Length > 0) // we encoded something
                    RetVal = "<data>" + S.ToString() + "</data>";
            }
            break;

            case XMLRPC_STRUCT:
            {
                StringBuilder S = new StringBuilder();
                foreach (string Key in ((Hashtable)obValue).Keys)
                {
                    string Node = EncodeXMLRPCValue(((Hashtable)obValue)[Key]);
                    if (Node != null)
                    { // this was a good value, so save the key and value
                        S.AppendLine("<member>");
                        S.AppendLine("<name>" + Key + "</name>");
                        S.AppendLine(Node);
                        S.AppendLine("</member>");
                    }
                }

                if (S.Length > 0) // we encoded something
                    RetVal = S.ToString();
            }
            break;

            case XMLRPC_DATE:
            {
                DateTimeOffset D;
                if (obValue.GetType().ToString() == "System.DateTime")
                    D = new DateTimeOffset((DateTime)obValue);
                else
                    D = (DateTimeOffset)obValue;

                RetVal = D.ToString("o");
            }
            break;

            case XMLRPC_BASE64:
                RetVal = Convert.ToBase64String((byte[])obValue);
            break;

            default: // assume string
                TypeStr = XMLRPC_STRING;
                RetVal = ((string)obValue).ToString();
            break;
        }

        return String.IsNullOrEmpty(RetVal) ? null : "<value><" + TypeStr + ">" + RetVal.ToString() + "</" + TypeStr + "></value>";
    }

    protected string EncodeXMLRPCRequest(string method, object[] parms)
    { // returns an XMLRPC-formatted object to send to a server
        StringBuilder XMLRPC = new StringBuilder();
        XMLRPC.AppendLine("<?xml version = \"1.0\" ?>");
        XMLRPC.AppendLine("<methodCall>");
        XMLRPC.AppendLine("<methodName>" + method + "</methodName>");

        if (parms != null)
        {
            StringBuilder S = new StringBuilder();

            foreach (object Item in parms)
            {
                string ObEncoded = EncodeXMLRPCValue(Item);
                if (ObEncoded != null)
                    S.AppendLine("<param>" + ObEncoded + "</param>");
            }

            if (S.Length > 0)
                XMLRPC.AppendLine("<params>" + S.ToString() + "</params>");
        }

        XMLRPC.AppendLine("</methodCall>");
        return XMLRPC.ToString();
    }

    protected static readonly string[] Format8601 = new string[] { "s", "u", "o" }; // permissive date parsing, as we don't know what the server thinks is standard

    protected object DecodeXMLRPCValue(XmlNode Node)
    { // converts a single XML <type> string to an object
        object RetVal = null;

        XmlNode ValueNode = Node.FirstChild;
        switch (ValueNode.LocalName)
        {
            case XMLRPC_INT:
            case XMLRPC_I4:
            case XMLRPC_BOOLEAN:
            {
                int Val = 0;
                int.TryParse(ValueNode.InnerText, out Val);

                if (ValueNode.LocalName == XMLRPC_BOOLEAN)
                    RetVal = (Val == 0) ? false : true;
                else
                    RetVal = Val;
            }
            break;

            case XMLRPC_STRING:
                RetVal = ValueNode.InnerText;
            break;

            case XMLRPC_DOUBLE:
            {
                double Val = 0.0;
                double.TryParse(ValueNode.InnerText, out Val);
                RetVal = Val;
            }
            break;

            case XMLRPC_ARRAY:
            {
                List<object> ObArr = new List<object>();

                foreach (XmlNode ArrayNode in ValueNode.FirstChild) // there's a single <data> member, so get around it
                {
                    object ObArrayElement = DecodeXMLRPCValue(ArrayNode);
                    if (ObArrayElement != null)
                        ObArr.Add(ObArrayElement);
                }

                if (ObArr.Count > 0)
                    RetVal = ObArr.ToArray(); // there's an array with items, so return it
            }
            break;

            case XMLRPC_STRUCT:
            {
                Hashtable H = new Hashtable();

                foreach (XmlNode StructNode in ValueNode) // loop through the <member> members
                {
                    string Key = null;
                    object Value = null;

                    XmlNode StructNameNode = StructNode.SelectSingleNode("name");
                    if (StructNameNode != null)
                        Key = StructNameNode.InnerText;

                    XmlNode StructValueNode = StructNode.SelectSingleNode("value");
                    if (StructValueNode != null)
                        Value = DecodeXMLRPCValue(StructValueNode);

                    if ((Key != null) && (Value != null))
                        H[Key] = Value;
                }

                if (H.Count > 0) // there was something in the struct
                    RetVal = H;
            }
            break;

            case XMLRPC_DATE:
                DateTimeOffset Result;
                if (DateTimeOffset.TryParseExact(ValueNode.InnerText, Format8601, System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.AllowWhiteSpaces | System.Globalization.DateTimeStyles.AdjustToUniversal, out Result))
                    RetVal = Result;
            break;

            case XMLRPC_BASE64:
                RetVal = Convert.FromBase64String(ValueNode.InnerText);
            break;
        }

        return RetVal;
    }

    protected object DecodeXMLRPCResult(string XMLResultString)
    {
//      Debug.Log(XMLResultString);
        object RetVal = null;
        XmlDocument XML = new XmlDocument();
        XML.LoadXml(XMLResultString);
        XmlNode XMLMethodResponse = XML.SelectSingleNode("/methodResponse");
        if (XMLMethodResponse != null)
        { // we have a response
            XmlNode XMLFault = XMLMethodResponse.SelectSingleNode("fault");
            if (XMLFault != null)
            { // we have a <fault> tag, so create a fault
                RetVal = new RPCFault();

                foreach (XmlNode XMLFaultMember in XMLFault.SelectNodes("value/struct/member"))
                { // get the value
                    object XMLFaultMemberValue = DecodeXMLRPCValue(XMLFaultMember.SelectSingleNode("value"));
                    switch (XMLRPCTypeOf(XMLFaultMemberValue))
                    { // only concerned about string and int values, as those are the code and the error
                        case XMLRPC_STRING:
                            ((RPCFault)RetVal).FaultString = (string)XMLFaultMemberValue;
                        break;

                        case XMLRPC_INT:
                            ((RPCFault)RetVal).FaultCode = (int)XMLFaultMemberValue;
                        break;
                    }
                }
            }
            else // no fault, so parse the value
                RetVal = DecodeXMLRPCValue(XMLMethodResponse.SelectNodes("params/param/value").Item(0)); // return only has one param and value, so assume the first
        }
        return RetVal;
    }
}