public void SerializeRequest(Stream stm, XmlRpcRequest request)
{
var xtw = XmlRpcXmlWriter.Create(stm, XmlRpcFormatSettings);
xtw.WriteStartDocument();
xtw.WriteStartElement(string.Empty, "methodCall", string.Empty);
{
var mappingActions = new MappingActions();
mappingActions = GetTypeMappings(request.Mi, mappingActions);
mappingActions = GetMappingActions(request.Mi, mappingActions);
WriteFullElementString(xtw, "methodName", request.Method);
if (request.Args.Length > 0 || UseEmptyParamsTag)
{
xtw.WriteStartElement("params");
try
{
if (!IsStructParamsMethod(request.Mi))
SerializeParams(xtw, request, mappingActions);
else
SerializeStructParams(xtw, request, mappingActions);
}
catch (XmlRpcUnsupportedTypeException ex)
{
throw new XmlRpcUnsupportedTypeException(
ex.UnsupportedType,
string.Format(
"A parameter is of, or contains an instance of, type {0} which cannot be mapped to an XML-RPC type",
ex.UnsupportedType));
}
WriteFullEndElement(xtw);
}
}
WriteFullEndElement(xtw);
xtw.Flush();
}
public XmlRpcResponse Invoke(XmlRpcRequest request)
{
MethodInfo mi = null;
if (request.mi != null)
{
mi = request.mi;
}
else
{
mi = this.GetType().GetMethod(request.method);
}
// exceptions thrown during an MethodInfo.Invoke call are
// package as inner of
Object reto;
try
{
reto = mi.Invoke(this, request.args);
}
catch(Exception ex)
{
if (ex.InnerException != null)
throw ex.InnerException;
throw ex;
}
// methods which have void return type always return integer 0
// because XML-RPC doesn't support no return type (could use nil
// but want to maintain backwards compatibility in this area)
if (mi != null && mi.ReturnType == typeof(void))
reto = 0;
XmlRpcResponse response = new XmlRpcResponse(reto);
return response;
}
public XmlRpcResponse Invoke(XmlRpcRequest request)
{
MethodInfo mi = null;
if (request.mi != null)
{
mi = request.mi;
}
else
{
mi = this.GetType().GetMethod(request.method);
}
// exceptions thrown during an MethodInfo.Invoke call are
// package as inner of
Object reto;
try
{
reto = mi.Invoke(this, request.args);
}
catch(Exception ex)
{
if (ex.InnerException != null)
throw ex.InnerException;
throw ex;
}
XmlRpcResponse response = new XmlRpcResponse(reto);
return response;
}
public void SerializeObjectParams()
{
Stream stm = new MemoryStream();
XmlRpcRequest req = new XmlRpcRequest();
req.args = new Object[] { new object[] { 1, "one" } };
req.method = "Foo";
req.mi = typeof(IFoo).GetMethod("Foo");
var ser = new XmlRpcRequestSerializer();
ser.SerializeRequest(stm, req);
stm.Position = 0;
TextReader tr = new StreamReader(stm);
string reqstr = tr.ReadToEnd();
Assert.AreEqual(
@"<?xml version=""1.0""?>
<methodCall>
<methodName>Foo</methodName>
<params>
<param>
<value>
<i4>1</i4>
</value>
</param>
<param>
<value>
<string>one</string>
</value>
</param>
</params>
</methodCall>", reqstr);
}
//internal members
internal XmlRpcAsyncResult(
XmlRpcClientProtocol ClientProtocol,
XmlRpcRequest XmlRpcReq,
Encoding XmlEncoding,
bool useEmptyParamsTag,
bool useIndentation,
int indentation,
bool UseIntTag,
bool UseStringTag,
WebRequest Request,
AsyncCallback UserCallback,
object UserAsyncState,
int retryNumber)
{
xmlRpcRequest = XmlRpcReq;
clientProtocol = ClientProtocol;
request = Request;
userAsyncState = UserAsyncState;
userCallback = UserCallback;
_completedSynchronously = true;
xmlEncoding = XmlEncoding;
_useEmptyParamsTag = useEmptyParamsTag;
_useIndentation = useIndentation;
_indentation = indentation;
this.UseIntTag = UseIntTag;
this.UseStringTag = UseStringTag;
}
public void SerializeRequestNil()
{
Stream stm = new MemoryStream();
XmlRpcRequest req = new XmlRpcRequest();
req.args = new Object[] { null, 1234567 };
req.method = "NilMethod";
req.mi = this.GetType().GetMethod("NilMethod");
var ser = new XmlRpcRequestSerializer();
ser.Indentation = 4;
ser.SerializeRequest(stm, req);
stm.Position = 0;
TextReader tr = new StreamReader(stm);
string reqstr = tr.ReadToEnd();
Assert.AreEqual(
@"<?xml version=""1.0""?>
<methodCall>
<methodName>NilMethod</methodName>
<params>
<param>
<value>
<nil />
</value>
</param>
<param>
<value>
<i4>1234567</i4>
</value>
</param>
</params>
</methodCall>", reqstr);
}
/// <summary>
///
/// </summary>
/// <param name="stm"></param>
/// <param name="request"></param>
public void SerializeRequest(Stream stm, XmlRpcRequest request)
{
XmlWriter xtw = XmlRpcXmlWriter.Create(stm, base.XmlRpcFormatSettings);
xtw.WriteStartDocument();
xtw.WriteStartElement("", "methodCall", "");
{
// TODO: use global action setting
NullMappingAction mappingAction = NullMappingAction.Error;
WriteFullElementString(xtw, "methodName", request.method);
if (request.args.Length > 0 || UseEmptyParamsTag)
{
xtw.WriteStartElement("params");
try
{
if (!IsStructParamsMethod(request.mi))
SerializeParams(xtw, request, mappingAction);
else
SerializeStructParams(xtw, request, mappingAction);
}
catch (XmlRpcUnsupportedTypeException ex)
{
throw new XmlRpcUnsupportedTypeException(ex.UnsupportedType,
String.Format("A parameter is of, or contains an instance of, "
+ "type {0} which cannot be mapped to an XML-RPC type",
ex.UnsupportedType));
}
WriteFullEndElement(xtw);
}
}
WriteFullEndElement(xtw);
xtw.Flush();
}
public void SerializeRequestNilParams()
{
var stm = new MemoryStream();
var req = new XmlRpcRequest();
req.Args = new Object[] { new object[] { 1, null, 2 } };
req.Method = "NilParamsMethod";
req.Mi = GetType().GetMethod("NilParamsMethod");
var ser = new XmlRpcRequestSerializer();
ser.Indentation = 4;
ser.SerializeRequest(stm, req);
stm.Position = 0;
var tr = new StreamReader(stm);
tr.ReadToEnd().ShouldBe(
@"<?xml version=""1.0""?>
<methodCall>
<methodName>NilParamsMethod</methodName>
<params>
<param>
<value>
<i4>1</i4>
</value>
</param>
<param>
<value>
<nil />
</value>
</param>
<param>
<value>
<i4>2</i4>
</value>
</param>
</params>
</methodCall>");
}
//internal members
internal XmlRpcAsyncResult(
XmlRpcClientProtocol ClientProtocol,
XmlRpcRequest XmlRpcReq,
XmlRpcFormatSettings xmlRpcFormatSettings,
WebRequest Request,
AsyncCallback UserCallback,
object UserAsyncState)
{
XmlRpcRequest = XmlRpcReq;
_clientProtocol = ClientProtocol;
_request = Request;
_userAsyncState = UserAsyncState;
_userCallback = UserCallback;
_completedSynchronously = true;
XmlRpcFormatSettings = xmlRpcFormatSettings;
}
//internal members
internal XmlRpcAsyncResult(
XmlRpcClientProtocol ClientProtocol,
XmlRpcRequest XmlRpcReq,
XmlRpcFormatSettings xmlRpcFormatSettings,
WebRequest Request,
AsyncCallback UserCallback,
object UserAsyncState,
int retryNumber)
{
xmlRpcRequest = XmlRpcReq;
clientProtocol = ClientProtocol;
request = Request;
userAsyncState = UserAsyncState;
userCallback = UserCallback;
completedSynchronously = true;
XmlRpcFormatSettings = xmlRpcFormatSettings;
}
void SerializeParams(XmlWriter xtw, XmlRpcRequest request,
MappingActions mappingActions)
{
ParameterInfo[] pis = null;
if (request.mi != null)
{
pis = request.mi.GetParameters();
}
for (int i = 0; i < request.args.Length; i++)
{
var paramMappingActions = pis == null ? mappingActions
: GetMappingActions(pis[i], mappingActions);
if (pis != null)
{
if (i >= pis.Length)
throw new XmlRpcInvalidParametersException("Number of request "
+ "parameters greater than number of proxy method parameters.");
if (i == pis.Length - 1
&& Attribute.IsDefined(pis[i], typeof(ParamArrayAttribute)))
{
Array ary = (Array)request.args[i];
foreach (object o in ary)
{
//if (o == null)
// throw new XmlRpcNullParameterException(
// "Null parameter in params array");
xtw.WriteStartElement("", "param", "");
Serialize(xtw, o, paramMappingActions);
WriteFullEndElement(xtw);
}
break;
}
}
//if (request.args[i] == null)
//{
// throw new XmlRpcNullParameterException(String.Format(
// "Null method parameter #{0}", i + 1));
//}
xtw.WriteStartElement("", "param", "");
Serialize(xtw, request.args[i], paramMappingActions);
WriteFullEndElement(xtw);
}
}
public void Class()
{
Stream stm = new MemoryStream();
XmlRpcRequest req = new XmlRpcRequest();
TestClass arg = new TestClass();
arg._int = 456;
arg._string = "Test Class";
req.Args = new object[] { arg };
req.Method = "Foo";
var ser = new XmlRpcRequestSerializer();
ser.SerializeRequest(stm, req);
stm.Position = 0;
TextReader tr = new StreamReader(stm);
string reqstr = tr.ReadToEnd();
Assert.AreEqual(@"<?xml version=""1.0""?>
<methodCall>
<methodName>Foo</methodName>
<params>
<param>
<value>
<struct>
<member>
<name>_int</name>
<value>
<i4>456</i4>
</value>
</member>
<member>
<name>_string</name>
<value>
<string>Test Class</string>
</value>
</member>
</struct>
</value>
</param>
</params>
</methodCall>", reqstr);
}
public void SerializeIntNoParams()
{
Stream stm = new MemoryStream();
XmlRpcRequest req = new XmlRpcRequest();
req.args = new object[] { new int[] { 1, 2, 3 } };
req.method = "BarNotParams";
req.mi = typeof(IFoo).GetMethod("BarNotParams");
var ser = new XmlRpcRequestSerializer();
ser.SerializeRequest(stm, req);
stm.Position = 0;
TextReader tr = new StreamReader(stm);
string reqstr = tr.ReadToEnd();
Assert.AreEqual(
@"<?xml version=""1.0""?>
<methodCall>
<methodName>BarNotParams</methodName>
<params>
<param>
<value>
<array>
<data>
<value>
<i4>1</i4>
</value>
<value>
<i4>2</i4>
</value>
<value>
<i4>3</i4>
</value>
</data>
</array>
</value>
</param>
</params>
</methodCall>", reqstr);
}
public void SerializeRequest(Stream stm, XmlRpcRequest request)
{
XmlTextWriter xtw = new XmlTextWriter(stm, m_encoding);
ConfigureXmlFormat(xtw);
xtw.WriteStartDocument();
xtw.WriteStartElement("", "methodCall", "");
{
// TODO: use global action setting
MappingAction mappingAction = MappingAction.Error;
if (request.xmlRpcMethod == null)
xtw.WriteElementString("methodName", request.method);
else
xtw.WriteElementString("methodName", request.xmlRpcMethod);
if (request.args.Length > 0 || UseEmptyParamsTag)
{
xtw.WriteStartElement("", "params", "");
try
{
if (!IsStructParamsMethod(request.mi))
SerializeParams(xtw, request, mappingAction);
else
SerializeStructParams(xtw, request, mappingAction);
}
catch (XmlRpcUnsupportedTypeException ex)
{
throw new XmlRpcUnsupportedTypeException(ex.UnsupportedType,
String.Format("A parameter is of, or contains an instance of, "
+ "type {0} which cannot be mapped to an XML-RPC type",
ex.UnsupportedType));
}
xtw.WriteEndElement();
}
}
xtw.WriteEndElement();
xtw.Flush();
}
public void SerializeRequestArrayWithNull()
{
Stream stm = new MemoryStream();
XmlRpcRequest req = new XmlRpcRequest();
string[] array = new string[] { "AAA", null, "CCC" };
req.args = new Object[] { array };
req.method = "ArrayMethod";
req.mi = this.GetType().GetMethod("ArrayMethod");
var ser = new XmlRpcRequestSerializer();
ser.Indentation = 4;
ser.SerializeRequest(stm, req);
stm.Position = 0;
TextReader tr = new StreamReader(stm);
string reqstr = tr.ReadToEnd();
Assert.AreEqual(
@"<?xml version=""1.0""?>
<methodCall>
<methodName>ArrayMethod</methodName>
<params>
<param>
<value>
<array>
<data>
<value>
<string>AAA</string>
</value>
<value>
<nil />
</value>
<value>
<string>CCC</string>
</value>
</data>
</array>
</value>
</param>
</params>
</methodCall>", reqstr);
}
public void SerializeRequestStructArrayWithNil()
{
Stream stm = new MemoryStream();
XmlRpcRequest req = new XmlRpcRequest();
req.args = new Object[] { new StructWithArray { ints = new int?[] { 1, null, 3 } } };
req.method = "NilMethod";
req.mi = this.GetType().GetMethod("NilMethod");
var ser = new XmlRpcRequestSerializer();
ser.Indentation = 4;
ser.SerializeRequest(stm, req);
stm.Position = 0;
TextReader tr = new StreamReader(stm);
string reqstr = tr.ReadToEnd();
Assert.AreEqual(
@"<?xml version=""1.0""?>
<methodCall>
<methodName>NilMethod</methodName>
<params>
<param>
<value>
<struct>
<member>
<name>ints</name>
<value>
<array>
<data>
<value>
<i4>1</i4>
</value>
<value>
<nil />
</value>
<value>
<i4>3</i4>
</value>
</data>
</array>
</value>
</member>
</struct>
</value>
</param>
</params>
</methodCall>", reqstr);
}
// private methods
//
void SerializeMessage(
IMethodCallMessage mcm,
ref ITransportHeaders headers,
ref Stream stream)
{
ITransportHeaders reqHeaders = new TransportHeaders();
reqHeaders["__Uri"] = mcm.Uri;
reqHeaders["Content-Type"] = "text/xml; charset=\"utf-8\"";
reqHeaders["__RequestVerb"] = "POST";
MethodInfo mi = (MethodInfo)mcm.MethodBase;
string methodName = GetRpcMethodName(mi);
XmlRpcRequest xmlRpcReq = new XmlRpcRequest(methodName, mcm.InArgs);
// TODO: possibly call GetRequestStream from next sink in chain?
// TODO: SoapClientFormatter sink uses ChunkedStream - check why?
Stream stm = new MemoryStream();
var serializer = new XmlRpcRequestSerializer();
serializer.SerializeRequest(stm, xmlRpcReq);
stm.Position = 0;
headers = reqHeaders;
stream = stm;
}
public object Invoke(
Object clientObj,
MethodInfo mi,
params object[] parameters)
{
#if (!COMPACT_FRAMEWORK)
_responseHeaders = null;
_responseCookies = null;
#endif
WebRequest webReq = null;
object reto = null;
try
{
string useUrl = GetEffectiveUrl(clientObj);
webReq = GetWebRequest(new Uri(useUrl));
XmlRpcRequest req = MakeXmlRpcRequest(webReq, mi, parameters,
clientObj, _xmlRpcMethod, _id);
SetProperties(webReq);
SetRequestHeaders(_headers, webReq);
#if (!COMPACT_FRAMEWORK)
SetClientCertificates(_clientCertificates, webReq);
#endif
Stream serStream = null;
Stream reqStream = null;
bool logging = (RequestEvent != null);
if (!logging)
{
serStream = reqStream = webReq.GetRequestStream();
}
else
{
serStream = new MemoryStream(2000);
}
try
{
XmlRpcSerializer serializer = new XmlRpcSerializer();
if (_xmlEncoding != null)
{
serializer.XmlEncoding = _xmlEncoding;
}
serializer.UseIndentation = _useIndentation;
serializer.Indentation = _indentation;
serializer.NonStandard = _nonStandard;
serializer.UseStringTag = _useStringTag;
serializer.UseIntTag = _useIntTag;
serializer.UseEmptyParamsTag = _useEmptyParamsTag;
serializer.SerializeRequest(serStream, req);
if (logging)
{
reqStream = webReq.GetRequestStream();
serStream.Position = 0;
Util.CopyStream(serStream, reqStream);
reqStream.Flush();
serStream.Position = 0;
OnRequest(new XmlRpcRequestEventArgs(req.proxyId, req.number,
serStream));
}
}
finally
{
if (reqStream != null)
{
reqStream.Close();
}
}
HttpWebResponse webResp = GetWebResponse(webReq) as HttpWebResponse;
#if (!COMPACT_FRAMEWORK)
_responseCookies = webResp.Cookies;
_responseHeaders = webResp.Headers;
#endif
Stream respStm = null;
Stream deserStream;
logging = (ResponseEvent != null);
try
{
respStm = webResp.GetResponseStream();
if (!logging)
{
deserStream = respStm;
}
else
{
deserStream = new MemoryStream(2000);
Util.CopyStream(respStm, deserStream);
deserStream.Flush();
deserStream.Position = 0;
}
#if (!COMPACT_FRAMEWORK && !FX1_0)
deserStream = MaybeDecompressStream((HttpWebResponse)webResp,
deserStream);
#endif
try
{
XmlRpcResponse resp = ReadResponse(req, webResp, deserStream, null);
reto = resp.retVal;
}
finally
{
if (logging)
{
deserStream.Position = 0;
OnResponse(new XmlRpcResponseEventArgs(req.proxyId, req.number,
deserStream));
}
}
}
finally
{
if (respStm != null)
{
respStm.Close();
}
}
}
finally
{
if (webReq != null)
{
webReq = null;
}
}
return(reto);
}
public void SerializeWithMappingOnInterface()
{
Stream stm = new MemoryStream();
XmlRpcRequest req = new XmlRpcRequest();
req.Args = new Object[]
{
IntEnum.Zero,
new IntEnum[] { IntEnum.One, IntEnum.Two },
new ItfEnumClass
{
IntEnum = ItfEnum.One,
intEnum = ItfEnum.Two,
IntEnums = new ItfEnum[] { ItfEnum.One, ItfEnum.Two },
intEnums = new ItfEnum[] { ItfEnum.Three, ItfEnum.Four },
}
};
req.Method = "MappingOnMethod";
req.Mi = this.GetType().GetMethod("MappingOnMethod");
var ser = new XmlRpcRequestSerializer();
ser.SerializeRequest(stm, req);
stm.Position = 0;
TextReader tr = new StreamReader(stm);
string reqstr = tr.ReadToEnd();
Assert.AreEqual(
@"<?xml version=""1.0""?>
<methodCall>
<methodName>MappingOnMethod</methodName>
<params>
<param>
<value>
<string>Zero</string>
</value>
</param>
<param>
<value>
<array>
<data>
<value>
<string>One</string>
</value>
<value>
<string>Two</string>
</value>
</data>
</array>
</value>
</param>
<param>
<value>
<struct>
<member>
<name>IntEnum</name>
<value>
<string>One</string>
</value>
</member>
<member>
<name>IntEnums</name>
<value>
<array>
<data>
<value>
<string>One</string>
</value>
<value>
<string>Two</string>
</value>
</data>
</array>
</value>
</member>
<member>
<name>intEnum</name>
<value>
<string>Two</string>
</value>
</member>
<member>
<name>intEnums</name>
<value>
<array>
<data>
<value>
<string>Three</string>
</value>
<value>
<string>Four</string>
</value>
</data>
</array>
</value>
</member>
</struct>
</value>
</param>
</params>
</methodCall>", reqstr);
}
public void SerializeRequest(Stream stm, XmlRpcRequest request)
{
XmlTextWriter xtw = new XmlTextWriter(stm, m_encoding);
ConfigureXmlFormat(xtw);
xtw.WriteStartDocument();
xtw.WriteStartElement("", "methodCall", "");
{
ParameterInfo[] pis = null;
if (request.mi != null)
{
pis = request.mi.GetParameters();
}
// TODO: use global action setting
MappingAction mappingAction = MappingAction.Error;
if (request.xmlRpcMethod == null)
xtw.WriteElementString("methodName", request.method);
else
xtw.WriteElementString("methodName", request.xmlRpcMethod);
if (request.args.Length > 0 || UseEmptyParamsTag)
{
xtw.WriteStartElement("", "params", "");
try
{
for (int i = 0; i < request.args.Length; i++)
{
if (pis != null)
{
if (i >= pis.Length)
throw new XmlRpcInvalidParametersException("Number of request "
+ "parameters greater than number of proxy method parameters.");
if (Attribute.IsDefined(pis[i], typeof(ParamArrayAttribute)))
{
Array ary = (Array)request.args[i];
foreach (object o in ary)
{
if (o == null)
throw new XmlRpcNullParameterException(
"Null parameter in params array");
xtw.WriteStartElement("", "param", "");
Serialize(xtw, o, mappingAction);
xtw.WriteEndElement();
}
break;
}
}
if (request.args[i] == null)
{
throw new XmlRpcNullParameterException(String.Format(
"Null method parameter #{0}", i + 1));
}
xtw.WriteStartElement("", "param", "");
Serialize(xtw, request.args[i], mappingAction);
xtw.WriteEndElement();
}
}
catch (XmlRpcUnsupportedTypeException ex)
{
throw new XmlRpcUnsupportedTypeException(ex.UnsupportedType,
String.Format("A parameter is of, or contains an instance of, "
+ "type {0} which cannot be mapped to an XML-RPC type",
ex.UnsupportedType));
}
xtw.WriteEndElement();
}
}
xtw.WriteEndElement();
xtw.Flush();
}
XmlRpcResponse ReadResponse(
XmlRpcRequest req,
WebResponse webResp,
Stream respStm)
{
HttpWebResponse httpResp = (HttpWebResponse)webResp;
if (httpResp.StatusCode != HttpStatusCode.OK)
{
// status 400 is used for errors caused by the client
// status 500 is used for server errors (not server application
// errors which are returned as fault responses)
if (httpResp.StatusCode == HttpStatusCode.BadRequest)
throw new XmlRpcException(httpResp.StatusDescription);
else
throw new XmlRpcServerException(httpResp.StatusDescription);
}
var deserializer = new XmlRpcResponseDeserializer();
deserializer.NonStandard = _nonStandard;
Type retType = req.mi.ReturnType;
XmlRpcResponse xmlRpcResp
= deserializer.DeserializeResponse(respStm, retType);
return xmlRpcResp;
}
public object Invoke(
Object clientObj,
MethodInfo mi,
params object[] parameters)
{
#if (SILVERLIGHT)
throw new NotSupportedException();
#else
_responseHeaders = null;
_responseCookies = null;
WebRequest webReq = null;
object reto = null;
try
{
string useUrl = GetEffectiveUrl(clientObj);
webReq = GetWebRequest(new Uri(useUrl));
XmlRpcRequest req = MakeXmlRpcRequest(webReq, mi, parameters,
clientObj, _xmlRpcMethod, _id);
SetProperties(webReq);
SetRequestHeaders(Headers, webReq);
#if (!COMPACT_FRAMEWORK)
SetClientCertificates(ClientCertificates, webReq);
#endif
Stream serStream = null;
Stream reqStream = null;
bool logging = (RequestEvent != null);
if (!logging)
{
serStream = reqStream = webReq.GetRequestStream();
}
else
{
serStream = new MemoryStream(2000);
}
try
{
var serializer = new XmlRpcRequestSerializer(XmlRpcFormatSettings);
serializer.SerializeRequest(serStream, req);
if (logging)
{
reqStream = webReq.GetRequestStream();
serStream.Position = 0;
Util.CopyStream(serStream, reqStream);
reqStream.Flush();
serStream.Position = 0;
OnRequest(new XmlRpcRequestEventArgs(req.ProxyId, req.number,
serStream));
}
}
finally
{
if (reqStream != null)
{
reqStream.Close();
}
}
HttpWebResponse webResp = GetWebResponse(webReq) as HttpWebResponse;
_responseCookies = webResp.Cookies;
_responseHeaders = webResp.Headers;
Stream respStm = null;
Stream deserStream;
logging = (ResponseEvent != null);
try
{
respStm = webResp.GetResponseStream();
#if (!COMPACT_FRAMEWORK && !FX1_0)
respStm = MaybeDecompressStream((HttpWebResponse)webResp,
respStm);
#endif
if (!logging)
{
deserStream = respStm;
}
else
{
deserStream = new MemoryStream(2000);
Util.CopyStream(respStm, deserStream);
deserStream.Flush();
deserStream.Position = 0;
}
if (logging)
{
OnResponse(new XmlRpcResponseEventArgs(req.ProxyId, req.number,
deserStream));
deserStream.Position = 0;
}
XmlRpcResponse resp = ReadResponse(req, webResp, deserStream);
reto = resp.RetVal;
}
finally
{
if (respStm != null)
{
respStm.Close();
}
}
}
finally
{
if (webReq != null)
{
webReq = null;
}
}
return(reto);
#endif
}
static void GetRequestStreamCallback(IAsyncResult asyncResult)
{
XmlRpcAsyncResult clientResult
= (XmlRpcAsyncResult)asyncResult.AsyncState;
clientResult.CompletedSynchronously = asyncResult.CompletedSynchronously;
try
{
Stream serStream = null;
Stream reqStream = null;
bool logging = (clientResult.ClientProtocol.RequestEvent != null);
if (!logging)
{
serStream = reqStream
= clientResult.Request.EndGetRequestStream(asyncResult);
}
else
{
serStream = new MemoryStream(2000);
}
try
{
XmlRpcRequest req = clientResult.XmlRpcRequest;
var serializer = new XmlRpcRequestSerializer();
if (clientResult.XmlRpcFormatSettings.XmlEncoding != null)
{
serializer.XmlEncoding = clientResult.XmlRpcFormatSettings.XmlEncoding;
}
serializer.UseEmptyElementTags = clientResult.XmlRpcFormatSettings.UseEmptyElementTags;
serializer.UseEmptyParamsTag = clientResult.XmlRpcFormatSettings.UseEmptyParamsTag;
serializer.UseIndentation = clientResult.XmlRpcFormatSettings.UseIndentation;
serializer.Indentation = clientResult.XmlRpcFormatSettings.Indentation;
serializer.UseIntTag = clientResult.XmlRpcFormatSettings.UseIntTag;
serializer.UseStringTag = clientResult.XmlRpcFormatSettings.UseStringTag;
serializer.SerializeRequest(serStream, req);
if (logging)
{
reqStream = clientResult.Request.EndGetRequestStream(asyncResult);
serStream.Position = 0;
Util.CopyStream(serStream, reqStream);
reqStream.Flush();
serStream.Position = 0;
clientResult.ClientProtocol.OnRequest(
new XmlRpcRequestEventArgs(req.ProxyId, req.number, serStream));
}
}
finally
{
if (reqStream != null)
{
reqStream.Close();
}
}
clientResult.Request.BeginGetResponse(
new AsyncCallback(GetResponseCallback), clientResult);
}
catch (Exception ex)
{
ProcessAsyncException(clientResult, ex);
}
}
public void SerializeZeroParametersNoParams()
{
Stream stm = new MemoryStream();
XmlRpcRequest req = new XmlRpcRequest();
req.args = new Object[0];
req.method = "FooZeroParameters";
req.mi = typeof(IFoo).GetMethod("FooZeroParameters");
var ser = new XmlRpcRequestSerializer();
ser.UseEmptyParamsTag = false;
ser.SerializeRequest(stm, req);
stm.Position = 0;
TextReader tr = new StreamReader(stm);
string reqstr = tr.ReadToEnd();
Assert.AreEqual(
@"<?xml version=""1.0""?>
<methodCall>
<methodName>FooZeroParameters</methodName>
</methodCall>", reqstr);
}
public void SerializeWithMappingOnInterface()
{
Stream stm = new MemoryStream();
XmlRpcRequest req = new XmlRpcRequest();
req.args = new Object[]
{
IntEnum.Zero,
new IntEnum[] { IntEnum.One, IntEnum.Two },
new ItfEnumClass
{
IntEnum = ItfEnum.One,
intEnum = ItfEnum.Two,
IntEnums = new ItfEnum[] { ItfEnum.One, ItfEnum.Two },
intEnums = new ItfEnum[] { ItfEnum.Three, ItfEnum.Four },
}
};
req.method = "MappingOnMethod";
req.mi = this.GetType().GetMethod("MappingOnMethod");
var ser = new XmlRpcRequestSerializer();
ser.SerializeRequest(stm, req);
stm.Position = 0;
TextReader tr = new StreamReader(stm);
string reqstr = tr.ReadToEnd();
Assert.AreEqual(
@"<?xml version=""1.0""?>
<methodCall>
<methodName>MappingOnMethod</methodName>
<params>
<param>
<value>
<string>Zero</string>
</value>
</param>
<param>
<value>
<array>
<data>
<value>
<string>One</string>
</value>
<value>
<string>Two</string>
</value>
</data>
</array>
</value>
</param>
<param>
<value>
<struct>
<member>
<name>IntEnum</name>
<value>
<string>One</string>
</value>
</member>
<member>
<name>IntEnums</name>
<value>
<array>
<data>
<value>
<string>One</string>
</value>
<value>
<string>Two</string>
</value>
</data>
</array>
</value>
</member>
<member>
<name>intEnum</name>
<value>
<string>Two</string>
</value>
</member>
<member>
<name>intEnums</name>
<value>
<array>
<data>
<value>
<string>Three</string>
</value>
<value>
<string>Four</string>
</value>
</data>
</array>
</value>
</member>
</struct>
</value>
</param>
</params>
</methodCall>", reqstr);
}
public void SerializeMassimo()
{
object[] param1 = new object[] { "test/Gain1", "Gain", 1, 1,
new double[] { 0.5 } };
object[] param2 = new object[] { "test/METER", "P1", 1, 1,
new double[] { -1.0 } };
Stream stm = new MemoryStream();
XmlRpcRequest req = new XmlRpcRequest();
req.args = new Object[] { "IFTASK",
new object[] { param1, param2 } };
req.method = "Send_Param";
req.mi = this.GetType().GetMethod("Send_Param");
var ser = new XmlRpcRequestSerializer();
ser.SerializeRequest(stm, req);
stm.Position = 0;
TextReader tr = new StreamReader(stm);
string reqstr = tr.ReadToEnd();
Assert.AreEqual(massimoRequest, reqstr);
}
public XmlRpcRequest DeserializeRequest(XmlReader rdr, Type svcType)
{
try
{
XmlRpcRequest request = new XmlRpcRequest();
IEnumerator <Node> iter = new XmlRpcParser().ParseRequest(rdr).GetEnumerator();
iter.MoveNext();
string methodName = (iter.Current as MethodName).Name;
request.method = methodName;
request.mi = null;
ParameterInfo[] pis = null;
if (svcType != null)
{
// retrieve info for the method which handles this XML-RPC method
XmlRpcServiceInfo svcInfo
= XmlRpcServiceInfo.CreateServiceInfo(svcType);
request.mi = svcInfo.GetMethodInfo(request.method);
// if a service type has been specified and we cannot find the requested
// method then we must throw an exception
if (request.mi == null)
{
string msg = String.Format("unsupported method called: {0}",
request.method);
throw new XmlRpcUnsupportedMethodException(msg);
}
// method must be marked with XmlRpcMethod attribute
Attribute attr = Attribute.GetCustomAttribute(request.mi,
typeof(XmlRpcMethodAttribute));
if (attr == null)
{
throw new XmlRpcMethodAttributeException(
"Method must be marked with the XmlRpcMethod attribute.");
}
pis = request.mi.GetParameters();
}
bool gotParams = iter.MoveNext();
if (!gotParams)
{
if (svcType != null)
{
if (pis.Length == 0)
{
request.args = new object[0];
return(request);
}
else
{
throw new XmlRpcInvalidParametersException(
"Method takes parameters and params element is missing.");
}
}
else
{
request.args = new object[0];
return(request);
}
}
int paramsPos = pis != null?GetParamsPos(pis) : -1;
Type paramsType = null;
if (paramsPos != -1)
{
paramsType = pis[paramsPos].ParameterType.GetElementType();
}
int minParamCount = pis == null ? int.MaxValue
: (paramsPos == -1 ? pis.Length : paramsPos);
MappingStack mappingStack = new MappingStack("request");
MappingAction mappingAction = MappingAction.Error;
var objs = new List <object>();
var paramsObjs = new List <object>();
int paramCount = 0;
while (iter.MoveNext())
{
paramCount++;
if (svcType != null && paramCount > minParamCount && paramsPos == -1)
{
throw new XmlRpcInvalidParametersException(
"Request contains too many param elements based on method signature.");
}
if (paramCount <= minParamCount)
{
if (svcType != null)
{
mappingStack.Push(String.Format("parameter {0}", paramCount));
// TODO: why following commented out?
// parseStack.Push(String.Format("parameter {0} mapped to type {1}",
// i, pis[i].ParameterType.Name));
var obj = MapValueNode(iter,
pis[paramCount - 1].ParameterType, mappingStack, mappingAction);
objs.Add(obj);
}
else
{
mappingStack.Push(String.Format("parameter {0}", paramCount));
var obj = MapValueNode(iter, null, mappingStack, mappingAction);
objs.Add(obj);
}
mappingStack.Pop();
}
else
{
mappingStack.Push(String.Format("parameter {0}", paramCount + 1));
var paramsObj = MapValueNode(iter, paramsType, mappingStack, mappingAction);
paramsObjs.Add(paramsObj);
mappingStack.Pop();
}
}
if (svcType != null && paramCount < minParamCount)
{
throw new XmlRpcInvalidParametersException(
"Request contains too few param elements based on method signature.");
}
if (paramsPos != -1)
{
Object[] args = new Object[1];
args[0] = paramCount - minParamCount;
Array varargs = (Array)Activator.CreateInstance(pis[paramsPos].ParameterType, args);
for (int i = 0; i < paramsObjs.Count; i++)
{
varargs.SetValue(paramsObjs[i], i);
}
objs.Add(varargs);
}
request.args = objs.ToArray();
return(request);
}
catch (XmlException ex)
{
NPx.Log.Error(ex.ToString());
throw new XmlRpcIllFormedXmlException("Request contains invalid XML", ex);
}
}
XmlRpcRequest MakeXmlRpcRequest(WebRequest webReq, MethodInfo mi,
object[] parameters, object clientObj, string xmlRpcMethod,
Guid proxyId)
{
webReq.Method = "POST";
webReq.ContentType = "text/xml";
string rpcMethodName = XmlRpcTypeInfo.GetRpcMethodName(mi);
XmlRpcRequest req = new XmlRpcRequest(rpcMethodName, parameters, mi,
xmlRpcMethod, proxyId);
return req;
}
public void SerializeRequest()
{
Stream stm = new MemoryStream();
XmlRpcRequest req = new XmlRpcRequest();
req.args = new Object[] { IntEnum.Two };
req.method = "Foo";
var ser = new XmlRpcRequestSerializer();
ser.SerializeRequest(stm, req);
stm.Position = 0;
TextReader tr = new StreamReader(stm);
string reqstr = tr.ReadToEnd();
Assert.AreEqual(
@"<?xml version=""1.0""?>
<methodCall>
<methodName>Foo</methodName>
<params>
<param>
<value>
<i4>2</i4>
</value>
</param>
</params>
</methodCall>", reqstr);
}
public XmlRpcRequest DeserializeRequest(XmlDocument xdoc, Type svcType)
{
XmlRpcRequest request = new XmlRpcRequest();
XmlNode callNode = xdoc.SelectSingleNode("./methodCall");
if (callNode == null)
{
throw new XmlRpcInvalidXmlRpcException(
"Request XML not valid XML-RPC - missing methodCall element.");
}
XmlNode methodNode = callNode.SelectSingleNode("./methodName");
if (methodNode == null)
{
throw new XmlRpcInvalidXmlRpcException(
"Request XML not valid XML-RPC - missing methodName element.");
}
request.method = methodNode.FirstChild.Value;
if (request.method == "")
{
throw new XmlRpcInvalidXmlRpcException(
"Request XML not valid XML-RPC - empty methodName.");
}
request.mi = null;
ParameterInfo[] pis = new ParameterInfo[0];
if (svcType != null)
{
// retrieve info for the method which handles this XML-RPC method
XmlRpcServiceInfo svcInfo
= XmlRpcServiceInfo.CreateServiceInfo(svcType);
request.mi = svcInfo.GetMethodInfo(request.method);
// if a service type has been specified and we cannot find the requested
// method then we must throw an exception
if (request.mi == null)
{
string msg = String.Format("unsupported method called: {0}",
request.method);
throw new XmlRpcUnsupportedMethodException(msg);
}
// method must be marked with XmlRpcMethod attribute
Attribute attr = Attribute.GetCustomAttribute(request.mi,
typeof(XmlRpcMethodAttribute));
if (attr == null)
{
throw new XmlRpcMethodAttributeException(
"Method must be marked with the XmlRpcMethod attribute.");
}
pis = request.mi.GetParameters();
}
XmlNode paramsNode = callNode.SelectSingleNode("./params");
if (paramsNode == null)
{
if (svcType != null)
{
if (pis.Length == 0)
{
request.args = new object[0];
return request;
}
else
{
throw new XmlRpcInvalidParametersException(
"Method takes parameters and params element is missing.");
}
}
else
{
request.args = new object[0];
return request;
}
}
XmlNodeList paramNodes = paramsNode.SelectNodes("./param");
int paramsPos = GetParamsPos(pis);
if (paramNodes.Count < paramsPos)
{
throw new XmlRpcInvalidParametersException(
"Method takes parameters and there is incorrect number of param "
+ "elements.");
}
ParseStack parseStack = new ParseStack("request");
// TODO: use global action setting
MappingAction mappingAction = MappingAction.Error;
int paramObjCount = (paramsPos == -1 ?paramNodes.Count : paramsPos + 1);
Object[] paramObjs = new Object[paramObjCount];
// parse ordinary parameters
int ordinaryParams = (paramsPos == -1 ?paramNodes.Count :paramsPos);
for (int i = 0; i < ordinaryParams; i++)
{
XmlNode paramNode = paramNodes[i];
XmlNode valueNode = paramNode.SelectSingleNode("./value");
if (valueNode == null)
throw new XmlRpcInvalidXmlRpcException("Missing value element.");
XmlNode node = valueNode.SelectSingleNode("./*");
if (node == null)
node = valueNode.FirstChild;
if (svcType != null)
{
parseStack.Push(String.Format("parameter {0}", i + 1));
// TODO: why following commented out?
// parseStack.Push(String.Format("parameter {0} mapped to type {1}",
// i, pis[i].ParameterType.Name));
paramObjs[i] = ParseValue(node, pis[i].ParameterType, parseStack,
mappingAction);
}
else
{
parseStack.Push(String.Format("parameter {0}", i));
paramObjs[i] = ParseValue(node, null, parseStack, mappingAction);
}
parseStack.Pop();
}
// parse params parameters
if (paramsPos != -1)
{
Type paramsType = pis[paramsPos].ParameterType.GetElementType();
Object[] args = new Object[1];
args[0] = paramNodes.Count - paramsPos;
Array varargs = (Array)CreateArrayInstance(pis[paramsPos].ParameterType,
args);
for (int i = 0; i < varargs.Length; i++)
{
XmlNode paramNode = paramNodes[i + paramsPos];
XmlNode valueNode = paramNode.SelectSingleNode("value");
if (valueNode == null)
throw new XmlRpcInvalidXmlRpcException("Missing value element.");
XmlNode node = valueNode.SelectSingleNode("./*");
if (node == null)
node = valueNode.FirstChild;
parseStack.Push(String.Format("parameter {0}", i + 1 + paramsPos));
varargs.SetValue(ParseValue(node, paramsType, parseStack,
mappingAction), i);
parseStack.Pop();
}
paramObjs[paramsPos] = varargs;
}
request.args = paramObjs;
return request;
}
public XmlRpcRequest DeserializeRequest(XmlReader rdr, Type svcType)
{
try
{
XmlRpcRequest request = new XmlRpcRequest();
IEnumerator<Node> iter = new XmlRpcParser().ParseRequest(rdr).GetEnumerator();
iter.MoveNext();
string methodName = (iter.Current as MethodName).Name;
request.method = methodName;
request.mi = null;
ParameterInfo[] pis = null;
if (svcType != null)
{
// retrieve info for the method which handles this XML-RPC method
XmlRpcServiceInfo svcInfo
= XmlRpcServiceInfo.CreateServiceInfo(svcType);
request.mi = svcInfo.GetMethodInfo(request.method);
// if a service type has been specified and we cannot find the requested
// method then we must throw an exception
if (request.mi == null)
{
string msg = String.Format("unsupported method called: {0}",
request.method);
throw new XmlRpcUnsupportedMethodException(msg);
}
// method must be marked with XmlRpcMethod attribute
Attribute attr = Attribute.GetCustomAttribute(request.mi,
typeof(XmlRpcMethodAttribute));
if (attr == null)
{
throw new XmlRpcMethodAttributeException(
"Method must be marked with the XmlRpcMethod attribute.");
}
pis = request.mi.GetParameters();
}
bool gotParams = iter.MoveNext();
if (!gotParams)
{
if (svcType != null)
{
if (pis.Length == 0)
{
request.args = new object[0];
return request;
}
else
{
throw new XmlRpcInvalidParametersException(
"Method takes parameters and params element is missing.");
}
}
else
{
request.args = new object[0];
return request;
}
}
int paramsPos = pis != null ? GetParamsPos(pis) : -1;
Type paramsType = null;
if (paramsPos != -1)
paramsType = pis[paramsPos].ParameterType.GetElementType();
int minParamCount = pis == null ? int.MaxValue
: (paramsPos == -1 ? pis.Length : paramsPos);
MappingStack mappingStack = new MappingStack("request");
MappingAction mappingAction = MappingAction.Error;
var objs = new List<object>();
var paramsObjs = new List<object>();
int paramCount = 0;
while (iter.MoveNext())
{
paramCount++;
if (svcType != null && paramCount > minParamCount && paramsPos == -1)
throw new XmlRpcInvalidParametersException(
"Request contains too many param elements based on method signature.");
if (paramCount <= minParamCount)
{
if (svcType != null)
{
mappingStack.Push(String.Format("parameter {0}", paramCount));
// TODO: why following commented out?
// parseStack.Push(String.Format("parameter {0} mapped to type {1}",
// i, pis[i].ParameterType.Name));
var obj = MapValueNode(iter,
pis[paramCount - 1].ParameterType, mappingStack, mappingAction);
objs.Add(obj);
}
else
{
mappingStack.Push(String.Format("parameter {0}", paramCount));
var obj = MapValueNode(iter, null, mappingStack, mappingAction);
objs.Add(obj);
}
mappingStack.Pop();
}
else
{
mappingStack.Push(String.Format("parameter {0}", paramCount + 1));
var paramsObj = MapValueNode(iter, paramsType, mappingStack, mappingAction);
paramsObjs.Add(paramsObj);
mappingStack.Pop();
}
}
if (svcType != null && paramCount < minParamCount)
throw new XmlRpcInvalidParametersException(
"Request contains too few param elements based on method signature.");
if (paramsPos != -1)
{
Object[] args = new Object[1];
args[0] = paramCount - minParamCount;
Array varargs = (Array)Activator.CreateInstance(pis[paramsPos].ParameterType, args);
for (int i = 0; i < paramsObjs.Count; i++)
varargs.SetValue(paramsObjs[i], i);
objs.Add(varargs);
}
request.args = objs.ToArray();
return request;
}
catch (XmlException ex)
{
throw new XmlRpcIllFormedXmlException("Request contains invalid XML", ex);
}
}
void SerializeStructParams(
XmlWriter xtw,
XmlRpcRequest request,
MappingActions mappingActions)
{
var pis = request.Mi.GetParameters();
if (request.Args.Length > pis.Length)
throw new XmlRpcInvalidParametersException(
"Number of request parameters greater than number of proxy method parameters.");
if (Attribute.IsDefined(pis[request.Args.Length - 1],
typeof(ParamArrayAttribute)))
{
throw new XmlRpcInvalidParametersException(
"params parameter cannot be used with StructParams.");
}
xtw.WriteStartElement("", "param", "");
xtw.WriteStartElement("", "value", "");
xtw.WriteStartElement("", "struct", "");
for (int i = 0; i < request.Args.Length; i++)
{
if (request.Args[i] == null)
{
throw new XmlRpcNullParameterException(
string.Format(
"Null method parameter #{0}",
i + 1));
}
xtw.WriteStartElement("", "member", "");
WriteFullElementString(xtw, "name", pis[i].Name);
Serialize(xtw, request.Args[i], mappingActions);
WriteFullEndElement(xtw);
}
WriteFullEndElement(xtw);
WriteFullEndElement(xtw);
WriteFullEndElement(xtw);
}
public void DateTimeLocales()
{
CultureInfo oldci = Thread.CurrentThread.CurrentCulture;
try
{
foreach (string locale in Utils.GetLocales())
{
try
{
CultureInfo ci = new CultureInfo(locale);
Thread.CurrentThread.CurrentCulture = ci;
if (ci.LCID == 0x401 // ar-SA (Arabic - Saudi Arabia)
|| ci.LCID == 0x465 // div-MV (Dhivehi - Maldives)
|| ci.LCID == 0x41e) // th-TH (Thai - Thailand)
break;
DateTime dt = new DateTime(1900, 01, 02, 03, 04, 05);
while (dt < DateTime.Now)
{
Stream stm = new MemoryStream();
XmlRpcRequest req = new XmlRpcRequest();
req.args = new Object[] { dt };
req.method = "Foo";
var ser = new XmlRpcRequestSerializer();
ser.SerializeRequest(stm, req);
stm.Position = 0;
var deserializer = new XmlRpcRequestDeserializer();
XmlRpcRequest request = deserializer.DeserializeRequest(stm, null);
Assert.IsTrue(request.args[0] is DateTime,
"argument is DateTime");
DateTime dt0 = (DateTime)request.args[0];
Assert.AreEqual(dt0, dt, "DateTime argument 0");
dt += new TimeSpan(100, 1, 1, 1);
}
}
catch (Exception ex)
{
Assert.Fail(String.Format("unexpected exception {0}: {1}",
locale, ex.Message));
}
}
}
finally
{
Thread.CurrentThread.CurrentCulture = oldci;
}
}
void SerializeParams(
XmlWriter xtw,
XmlRpcRequest request,
MappingActions mappingActions)
{
ParameterInfo[] pis = null;
if (request.Mi != null)
pis = request.Mi.GetParameters();
for (var i = 0; i < request.Args.Length; i++)
{
var paramMappingActions = pis == null
? mappingActions
: GetMappingActions(pis[i], mappingActions);
if (pis != null)
{
if (i >= pis.Length)
throw new XmlRpcInvalidParametersException(
"Number of request parameters greater than number of proxy method parameters.");
if (i == pis.Length - 1 && Attribute.IsDefined(pis[i], typeof(ParamArrayAttribute)))
{
var ary = (Array)request.Args[i];
foreach (var o in ary)
{
xtw.WriteStartElement("", "param", "");
Serialize(xtw, o, paramMappingActions);
WriteFullEndElement(xtw);
}
break;
}
}
xtw.WriteStartElement("", "param", "");
Serialize(xtw, request.Args[i], paramMappingActions);
WriteFullEndElement(xtw);
}
}
Header[] GetChannelHeaders(
ITransportHeaders requestHeaders,
XmlRpcRequest xmlRpcReq,
Type svcType)
{
string requestUri = (string) requestHeaders["__RequestUri"];
XmlRpcServiceInfo svcInfo = XmlRpcServiceInfo.CreateServiceInfo(svcType);
ArrayList hdrList = new ArrayList();
hdrList.Add(new Header("__Uri", requestUri));
hdrList.Add(new Header("__TypeName", svcType.AssemblyQualifiedName));
hdrList.Add(new Header("__MethodName",
svcInfo.GetMethodName(xmlRpcReq.method)));
hdrList.Add(new Header("__Args", xmlRpcReq.args));
return (Header[])hdrList.ToArray(typeof(Header));
}