public void AllowInvalidHTTPContentLeadingWhiteSpace()
{
string xml = @"
<?xml version=""1.0"" ?>
<methodResponse>
<params>
<param>
<value><i4>12345</i4></value>
</param>
</params>
</methodResponse>";
Stream stm = new MemoryStream();
StreamWriter wrtr = new StreamWriter(stm, Encoding.ASCII);
wrtr.Write(xml);
wrtr.Flush();
stm.Position = 0;
XmlRpcSerializer serializer = new XmlRpcSerializer();
serializer.NonStandard = XmlRpcNonStandard.AllowInvalidHTTPContent;
XmlRpcResponse response = serializer.DeserializeResponse(stm, typeof(int));
Object o = response.retVal;
Assert.IsTrue(o != null, "retval not null");
Assert.IsTrue(o is int, "retval is int");
Assert.AreEqual((int)o, 12345, "retval is 12345");
}
public void AdvogatoProblem()
{
string xml = @"<?xml version='1.0'?>
<methodResponse>
<params>
<param>
<array>
<data>
<value>
<dateTime.iso8601>20020707T11:25:37</dateTime.iso8601>
</value>
<value>
<dateTime.iso8601>20020707T11:37:12</dateTime.iso8601>
</value>
</data>
</array>
</param>
</params>
</methodResponse>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
try
{
XmlRpcResponse response
= serializer.DeserializeResponse(sr, null);
Object o = response.retVal;
Assert.Fail("should have thrown XmlRpcInvalidXmlRpcException");
}
catch(XmlRpcInvalidXmlRpcException)
{
}
}
public XmlRpcSerializer()
{
Mapper.Initialize((config) =>
{
config.CreateMap<PostStatus, string>().ConvertUsing(src => src.ToRPC());
config.CreateMap<PostOrderBy, string>().ConvertUsing(src => src.ToRPC());
config.CreateMap<Order, string>().ConvertUsing(src => src.ToRPC());
config.CreateMap<Rpc.PostFilter, PostFilterProxy>()
.ForMember(
dest => dest.PostStatus,
opt => opt.MapFrom(
source => new string[] { Mapper.Map<string>(source.PostStatus) }
)
);
});
var doc = new XmlDocument();
doc.Load("SampleData/getpost.xml");
var response = new CookComputing.XmlRpc.XmlRpcSerializer().DeserializeResponse(
doc,
typeof(Rpc.Post)
);
this._subject = response.retVal as Rpc.Post;
this._expected = this.ExpectedPost();
}
public static XmlDocument Serialize(
string testName,
object obj,
Encoding encoding,
MappingAction action)
{
Stream stm = new MemoryStream();
XmlTextWriter xtw = new XmlTextWriter(stm, Encoding.UTF8);
xtw.Formatting = Formatting.Indented;
xtw.Indentation = 2;
xtw.WriteStartDocument();
XmlRpcSerializer ser = new XmlRpcSerializer();
ser.Serialize(xtw, obj, action);
xtw.Flush();
//Console.WriteLine(testName);
stm.Position = 0;
TextReader trdr = new StreamReader(stm, new UTF8Encoding(), true, 4096);
String s = trdr.ReadLine();
while (s != null)
{
//Console.WriteLine(s);
s = trdr.ReadLine();
}
stm.Position = 0;
XmlDocument xdoc = new XmlDocument();
xdoc.PreserveWhitespace = true;
xdoc.Load(stm);
return xdoc;
}
public XmlRpcSerializer()
{
Mapper.Initialize((config) =>
{
config.CreateMap <PostStatus, string>().ConvertUsing(src => src.ToRPC());
config.CreateMap <PostOrderBy, string>().ConvertUsing(src => src.ToRPC());
config.CreateMap <Order, string>().ConvertUsing(src => src.ToRPC());
config.CreateMap <Rpc.PostFilter, PostFilterProxy>()
.ForMember(
dest => dest.PostStatus,
opt => opt.MapFrom(
source => new string[] { Mapper.Map <string>(source.PostStatus) }
)
);
});
var doc = new XmlDocument();
doc.Load("SampleData/getpost.xml");
var response = new CookComputing.XmlRpc.XmlRpcSerializer().DeserializeResponse(
doc,
typeof(Rpc.Post)
);
this._subject = response.retVal as Rpc.Post;
this._expected = this.ExpectedPost();
}
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");
XmlRpcSerializer ser = new XmlRpcSerializer();
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);
}
public void PaoloLiveraniProblem()
{
try
{
XmlRpcResponse resp = new XmlRpcResponse(new DataSet());
Stream responseStream = new MemoryStream();
XmlRpcSerializer serializer = new XmlRpcSerializer();
serializer.SerializeResponse(responseStream, resp);
}
catch(XmlRpcInvalidReturnType ex)
{
string s = ex.Message;
}
}
public Stream Invoke(Stream requestStream)
{
try
{
var serializer = new XmlRpcResponseSerializer();
var deserializer = new XmlRpcRequestDeserializer();
Type type = this.GetType();
XmlRpcServiceAttribute serviceAttr = (XmlRpcServiceAttribute)
Attribute.GetCustomAttribute(this.GetType(),
typeof(XmlRpcServiceAttribute));
if (serviceAttr != null)
{
if (serviceAttr.XmlEncoding != null)
{
serializer.XmlEncoding = Encoding.GetEncoding(serviceAttr.XmlEncoding) ?? Config.DefaultEncoding;
}
serializer.UseEmptyParamsTag = serviceAttr.UseEmptyElementTags;
serializer.UseIntTag = serviceAttr.UseIntTag;
serializer.UseStringTag = serviceAttr.UseStringTag;
serializer.UseIndentation = serviceAttr.UseIndentation;
serializer.Indentation = serviceAttr.Indentation;
}
XmlRpcRequest xmlRpcReq = deserializer.DeserializeRequest(requestStream, this.GetType());
XmlRpcResponse xmlRpcResp = Invoke(xmlRpcReq);
Stream responseStream = new MemoryStream();
serializer.SerializeResponse(responseStream, xmlRpcResp);
responseStream.Seek(0, SeekOrigin.Begin);
return responseStream;
}
catch (Exception ex)
{
XmlRpcFaultException fex;
if (ex is XmlRpcException)
fex = new XmlRpcFaultException(0, ((XmlRpcException)ex).Message);
else if (ex is XmlRpcFaultException)
fex = (XmlRpcFaultException)ex;
else
fex = new XmlRpcFaultException(0, ex.Message);
XmlRpcSerializer serializer = new XmlRpcSerializer();
Stream responseStream = new MemoryStream();
serializer.SerializeFaultResponse(responseStream, fex);
responseStream.Seek(0, SeekOrigin.Begin);
return responseStream;
}
}
public static XmlReader Serialize(
string testName,
object obj,
Encoding encoding,
MappingActions actions)
{
Stream stm = new MemoryStream();
XmlWriter xtw = XmlRpcXmlWriter.Create(stm, new XmlRpcFormatSettings());
xtw.WriteStartDocument();
XmlRpcSerializer ser = new XmlRpcSerializer();
ser.Serialize(xtw, obj, actions);
xtw.Flush();
stm.Position = 0;
XmlReader rdr = XmlRpcXmlReader.Create(stm);
return rdr;
}
public XmlRpcSerializer()
{
var doc = new XmlDocument();
doc.Load("SampleData/getAuthors.xml");
var response = new CookComputing.XmlRpc.XmlRpcSerializer().DeserializeResponse(
doc,
typeof(Rpc.Author[])
);
this._subject = response.retVal as IEnumerable<Rpc.Author>;
//= new List<Author>();
this._expected = this.ExpectedAuthors();
}
// private methods
//
MethodCall DeserializeRequest(
ITransportHeaders requestHeaders,
Stream requestStream)
{
string requestUri = (string)requestHeaders["__RequestUri"];
Type svcType = GetServiceType(requestUri);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest xmlRpcReq
= serializer.DeserializeRequest(requestStream, svcType);
Header[] headers = GetChannelHeaders(requestHeaders, xmlRpcReq, svcType);
MethodCall mthdCall = new MethodCall(headers);
mthdCall.ResolveMethod();
return(mthdCall);
}
public XmlRpcSerializer()
{
var doc = new XmlDocument();
doc.Load("SampleData/getAuthors.xml");
var response = new CookComputing.XmlRpc.XmlRpcSerializer().DeserializeResponse(
doc,
typeof(Rpc.Author[])
);
this._subject = response.retVal as IEnumerable<Rpc.Author>;
//= new List<Author>();
this._expected = this.ExpectedAuthors();
}
public static string SerializeToString(
string testName,
object obj,
MappingAction action)
{
StringWriter strwrtr = new StringWriter();
XmlTextWriter xtw = new XmlTextWriter(strwrtr);
// xtw.Formatting = formatting;
// xtw.Indentation = indentation;
xtw.WriteStartDocument();
XmlRpcSerializer ser = new XmlRpcSerializer();
ser.Serialize(xtw, obj, action);
xtw.Flush();
//Console.WriteLine(testName);
//Console.WriteLine(strwrtr.ToString());
return strwrtr.ToString();
}
public ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream
)
{
// use presence of SOAPAction header to determine if this is a SOAP
// request - if so pass onto next sink in chain
string soapAction = (string)requestHeaders["SOAPAction"];
if (soapAction != null)
{
return(m_next.ProcessMessage(sinkStack, requestMsg, requestHeaders,
requestStream, out responseMsg, out responseHeaders,
out responseStream));
}
// for time being assume we have an XML-RPC request (need to improve
// this in case there are other non-SOAP formatters in the chain)
try
{
MethodCall mthdCall = DeserializeRequest(requestHeaders, requestStream);
sinkStack.Push(this, mthdCall);
// forward to next sink in chain - pass request stream as null to
// indicate that we have deserialized the request
m_next.ProcessMessage(sinkStack, mthdCall, requestHeaders, null,
out responseMsg, out responseHeaders, out responseStream);
SerializeResponse(responseMsg, ref responseHeaders, ref responseStream);
}
catch (Exception ex)
{
responseMsg = new ReturnMessage(ex, (IMethodCallMessage)requestMsg);
responseStream = new MemoryStream();
XmlRpcFaultException fex = new XmlRpcFaultException(0, ex.Message);
XmlRpcSerializer serializer = new XmlRpcSerializer();
serializer.SerializeFaultResponse(responseStream,
(XmlRpcFaultException)fex);
responseHeaders = new TransportHeaders();
}
return(ServerProcessing.Complete);
}
// private methods
//
MethodCall DeserializeRequest(
ITransportHeaders requestHeaders,
Stream requestStream)
{
string requestUri = (string)requestHeaders["__RequestUri"];
string typeName = GetTypeName(requestUri);
Type svcType = Type.GetType(typeName);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest xmlRpcReq
= serializer.DeserializeRequest(requestStream, svcType);
// TODO: optimise out two calls to GetRegisteredWellKnownServiceTypes
Header[] headers = GetChannelHeaders(requestHeaders, xmlRpcReq);
MethodCall mthdCall = new MethodCall(headers);
mthdCall.ResolveMethod();
return(mthdCall);
}
public static string SerializeValue(object value, bool indent)
{
var memStm = new MemoryStream();
var writer = XmlRpcXmlWriter.Create(
memStm,
new XmlRpcFormatSettings {
OmitXmlDeclaration = true, UseIndentation = indent
});
var serializer = new XmlRpcSerializer();
serializer.Serialize(writer, value, new MappingActions {
NullMappingAction = NullMappingAction.Error
});
writer.Flush();
memStm.Position = 0;
return(new StreamReader(memStm).ReadToEnd());
}
public Stream Invoke(Stream requestStream)
{
try
{
var serializer = new XmlRpcResponseSerializer();
var deserializer = new XmlRpcRequestDeserializer();
var serviceAttr = Attribute.GetCustomAttribute(GetType(), typeof(XmlRpcServiceAttribute)) as XmlRpcServiceAttribute;
if (serviceAttr != null)
{
if (serviceAttr.XmlEncoding != null)
serializer.XmlEncoding = Encoding.GetEncoding(serviceAttr.XmlEncoding);
serializer.UseEmptyParamsTag = serviceAttr.UseEmptyElementTags;
serializer.UseIntTag = serviceAttr.UseIntTag;
serializer.UseStringTag = serviceAttr.UseStringTag;
serializer.UseIndentation = serviceAttr.UseIndentation;
serializer.Indentation = serviceAttr.Indentation;
}
var xmlRpcReq = deserializer.DeserializeRequest(requestStream, GetType());
var xmlRpcResp = Invoke(xmlRpcReq);
var responseStream = new MemoryStream();
serializer.SerializeResponse(responseStream, xmlRpcResp);
responseStream.Seek(0, SeekOrigin.Begin);
return responseStream;
}
catch (Exception ex)
{
XmlRpcFaultException fex;
var xmlRpcException = ex as XmlRpcException;
if (xmlRpcException != null)
fex = new XmlRpcFaultException(0, xmlRpcException.Message);
else
{
fex = (ex as XmlRpcFaultException)
?? new XmlRpcFaultException(0, ex.Message);
}
var serializer = new XmlRpcSerializer();
var responseStream = new MemoryStream();
serializer.SerializeFaultResponse(responseStream, fex);
responseStream.Seek(0, SeekOrigin.Begin);
return responseStream;
}
}
public void IntegerNullType()
{
string xml = @"<?xml version=""1.0"" ?>
<methodResponse>
<params>
<param>
<value><int>12345</int></value>
</param>
</params>
</methodResponse>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcResponse response = serializer.DeserializeResponse(sr, null);
Object o = response.retVal;
Assert.IsTrue(o != null, "retval not null");
Assert.IsTrue(o is int, "retval is int");
Assert.AreEqual((int)o, 12345, "retval is 12345");
}
public void WithXmlDocPropertyPresentShouldDeserializeProperly()
{
// Arrange
var xmlSerializer = new XmlRpcSerializer();
const string reply = @"<?xml version='1.0'?>
<methodResponse><params><param>
<value><struct><member><name>XmlDoc</name><value>this is a string</value></member></struct></value>
</param></params></methodResponse>";
var expected = new P2000ReturnStructure
{
XmlDoc = "this is a string"
};
// Act
var actual = xmlSerializer.DeserializeStringResponse<P2000ReturnStructure>(reply);
// Assert
DtoAssert.AreEqual(expected, actual);
}
XmlRpcResponse ReadResponse(
XmlRpcRequest req,
WebResponse webResp,
Stream respStm,
Type returnType)
{
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);
}
}
XmlRpcSerializer serializer = new XmlRpcSerializer();
if (xmlDecoding != null)
{
serializer.XmlDecoding = xmlDecoding;
}
Type retType = returnType;
if (retType == null)
{
retType = req.mi.ReturnType;
}
XmlRpcResponse xmlRpcResp
= serializer.DeserializeResponse(respStm, retType);
return(xmlRpcResp);
}
public void Base64Empty()
{
string xml = @"<?xml version=""1.0""?>
<methodCall>
<methodName>TestHex</methodName>
<params>
<param>
<value>
<base64></base64>
</value>
</param>
</params>
</methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, null);
Assert.AreEqual(request.args[0].GetType(), typeof(byte[]),
"argument is byte[]");
Assert.AreEqual(request.args[0], new byte[0],
"argument is zero length byte[]");
}
public void Base64()
{
string xml = @"<?xml version=""1.0""?>
<methodCall>
<methodName>TestHex</methodName>
<params>
<param>
<value>
<base64>AQIDBAUGBwg=</base64>
</value>
</param>
</params>
</methodCall>";
StringReader sr = new StringReader(xml);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest request = serializer.DeserializeRequest(sr, null);
Assert.AreEqual(request.args[0].GetType(), typeof(byte[]),
"argument is byte[]");
byte[] ret = (byte[])request.args[0];
Assert.AreEqual(8, ret.Length, "argument is byte[8]");
for (int i = 0; i < ret.Length; i++)
Assert.AreEqual(i+1, ret[i], "members are 1 to 8");
}
public void DateTime_Empty_NonStandard()
{
Type parsedType, parsedArrayType;
string xml = @"<?xml version=""1.0"" ?>
<value><dateTime.iso8601></dateTime.iso8601></value>";
XmlRpcSerializer serializer = new XmlRpcSerializer();
object obj = Utils.Parse(xml, typeof(DateTime), MappingAction.Error, serializer,
out parsedType, out parsedArrayType);
}
public static object Parse(
XmlDocument xdoc,
Type valueType,
MappingAction action,
XmlRpcSerializer serializer,
out Type parsedType,
out Type parsedArrayType)
{
XmlNode node = xdoc.SelectSingleNode("value").FirstChild;
XmlRpcSerializer.ParseStack parseStack
= new XmlRpcSerializer.ParseStack("request");
object obj = serializer.ParseValue(node, valueType, parseStack, action,
out parsedType, out parsedArrayType);
return obj;
}
public void DateTime_Empty_Standard()
{
Type parsedType, parsedArrayType;
string xml = @"<?xml version=""1.0"" ?>
<value><dateTime.iso8601></dateTime.iso8601></value>";
XmlRpcSerializer serializer = new XmlRpcSerializer();
serializer.NonStandard = XmlRpcNonStandard.MapEmptyDateTimeToMinValue;
object obj = Utils.Parse(xml, typeof(DateTime), MappingAction.Error, serializer,
out parsedType, out parsedArrayType);
Assert.AreEqual(DateTime.MinValue, (DateTime)obj);
}
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;
XmlRpcSerializer serializer = new XmlRpcSerializer();
if (clientResult.XmlEncoding != null)
serializer.XmlEncoding = clientResult.XmlEncoding;
serializer.UseEmptyParamsTag = clientResult.UseEmptyParamsTag;
serializer.UseIndentation = clientResult.UseIndentation;
serializer.Indentation = clientResult.Indentation;
serializer.UseIntTag = clientResult.UseIntTag;
serializer.UseStringTag = clientResult.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 static object Parse(
string xml,
Type valueType,
MappingAction action,
XmlRpcSerializer serializer,
out Type parsedType,
out Type parsedArrayType)
{
StringReader sr = new StringReader(xml);
XmlDocument xdoc = new XmlDocument();
xdoc.Load(sr);
return Parse(xdoc, valueType, action, serializer,
out parsedType, out parsedArrayType);
}
public object Invoke(
Object clientObj,
MethodInfo mi,
params object[] parameters)
{
#if (!COMPACT_FRAMEWORK && !SILVERLIGHT)
_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);
#if (!SILVERLIGHT)
SetRequestHeaders(_headers, webReq);
#endif
#if (!COMPACT_FRAMEWORK && !SILVERLIGHT)
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 && !SILVERLIGHT)
_responseCookies = webResp.Cookies;
#endif
#if (!COMPACT_FRAMEWORK && !SILVERLIGHT)
_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 && !SILVERLIGHT)
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;
}
XmlRpcResponse ReadResponse(
XmlRpcRequest req,
WebResponse webResp,
Stream respStm,
Type returnType)
{
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 (!SILVERLIGHT)
if (httpResp.StatusCode == HttpStatusCode.BadRequest)
throw new XmlRpcException(httpResp.StatusDescription);
else
throw new XmlRpcServerException(httpResp.StatusDescription);
#else
throw new XmlRpcServerException(httpResp.StatusDescription);
#endif
}
XmlRpcSerializer serializer = new XmlRpcSerializer();
serializer.NonStandard = _nonStandard;
Type retType = returnType;
if (retType == null)
retType = req.mi.ReturnType;
XmlRpcResponse xmlRpcResp
= serializer.DeserializeResponse(respStm, retType);
return xmlRpcResp;
}
void SerializeResponse(
IMessage responseMsg,
ref ITransportHeaders responseHeaders,
ref Stream responseStream)
{
XmlRpcSerializer serializer = new XmlRpcSerializer();
responseStream = new MemoryStream();
responseHeaders = new TransportHeaders();
ReturnMessage retMsg = (ReturnMessage)responseMsg;
if (retMsg.Exception == null)
{
XmlRpcResponse xmlRpcResp = new XmlRpcResponse(retMsg.ReturnValue);
serializer.SerializeResponse(responseStream, xmlRpcResp);
}
else if (retMsg.Exception is XmlRpcFaultException)
{
serializer.SerializeFaultResponse(responseStream,
(XmlRpcFaultException)retMsg.Exception);
}
else
{
serializer.SerializeFaultResponse(responseStream,
new XmlRpcFaultException(1, retMsg.Exception.Message));
}
responseHeaders["Content-Type"] = "text/xml; charset=\"utf-8\"";
}
IMessage DeserializeMessage(
IMethodCallMessage mcm,
ITransportHeaders headers,
Stream stream)
{
XmlRpcSerializer serializer = new XmlRpcSerializer();
object tp = mcm.MethodBase;
System.Reflection.MethodInfo mi = (System.Reflection.MethodInfo)tp;
System.Type t = mi.ReturnType;
XmlRpcResponse xmlRpcResp = serializer.DeserializeResponse(stream, t);
IMessage imsg = new ReturnMessage(xmlRpcResp.retVal, null, 0, null, mcm);
return imsg;
}
// 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();
XmlRpcSerializer serializer = new XmlRpcSerializer();
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 ServerProcessing ProcessMessage(
IServerChannelSinkStack sinkStack,
IMessage requestMsg,
ITransportHeaders requestHeaders,
Stream requestStream,
out IMessage responseMsg,
out ITransportHeaders responseHeaders,
out Stream responseStream
)
{
// use presence of SOAPAction header to determine if this is a SOAP
// request - if so pass onto next sink in chain
string soapAction = (string) requestHeaders["SOAPAction"];
if (soapAction != null)
{
return m_next.ProcessMessage(sinkStack, requestMsg, requestHeaders,
requestStream, out responseMsg, out responseHeaders,
out responseStream);
}
// for time being assume we have an XML-RPC request (need to improve
// this in case there are other non-SOAP formatters in the chain)
try
{
MethodCall mthdCall = DeserializeRequest(requestHeaders, requestStream);
sinkStack.Push(this, mthdCall);
// forward to next sink in chain - pass request stream as null to
// indicate that we have deserialized the request
m_next.ProcessMessage(sinkStack, mthdCall, requestHeaders, null,
out responseMsg, out responseHeaders, out responseStream);
SerializeResponse(responseMsg, ref responseHeaders, ref responseStream);
}
catch (Exception ex)
{
responseMsg = new ReturnMessage(ex, (IMethodCallMessage)requestMsg);
responseStream = new MemoryStream();
XmlRpcFaultException fex = new XmlRpcFaultException(0, ex.Message);
XmlRpcSerializer serializer = new XmlRpcSerializer();
serializer.SerializeFaultResponse(responseStream,
(XmlRpcFaultException)fex);
responseHeaders = new TransportHeaders();
}
return ServerProcessing.Complete;
}
public void DateTime_WordPress()
{
// yyyyMMddThh:mm:ssZ
Type parsedType, parsedArrayType;
string xml = @"<?xml version=""1.0"" ?>
<value><dateTime.iso8601>20020706T11:25:37Z</dateTime.iso8601></value>";
XmlRpcSerializer serializer = new XmlRpcSerializer();
serializer.NonStandard = XmlRpcNonStandard.AllowNonStandardDateTime;
object obj = Utils.Parse(xml, typeof(DateTime), MappingAction.Error,
serializer, out parsedType, out parsedArrayType);
Assert.AreEqual(new DateTime(2002, 7, 6, 11, 25, 37),
(DateTime)obj);
}
public void StructOrderTest()
{
byte[] testb = new Byte[]
{
121, 111, 117, 32, 99, 97, 110, 39, 116, 32, 114, 101, 97, 100,
32, 116, 104, 105, 115, 33
};
Struct1 str1 = new Struct1();
str1.mi = 34567;
str1.ms = "another test string";
str1.mb = true;
str1.md = 8765.123;
str1.mdt = new DateTime(2002, 7, 6, 11, 25, 37);
str1.mb64 = testb;
str1.ma = new int[] { 1, 2, 3, 4, 5 };
Stream stm = new MemoryStream();
XmlRpcRequest req = new XmlRpcRequest();
req.args = new Object[] { str1 };
req.method = "Foo";
XmlRpcSerializer ser = new XmlRpcSerializer();
ser.SerializeRequest(stm, req);
stm.Position = 0;
TextReader tr = new StreamReader(stm);
string reqstr = tr.ReadToEnd();
Assert.Less(reqstr.IndexOf(">mi</"), reqstr.IndexOf(">ms</"));
Assert.Less(reqstr.IndexOf(">ms</"), reqstr.IndexOf(">mb</"));
Assert.Less(reqstr.IndexOf(">mb</"), reqstr.IndexOf(">md</"));
Assert.Less(reqstr.IndexOf(">md</"), reqstr.IndexOf(">mdt</"));
Assert.Less(reqstr.IndexOf(">mdt</"), reqstr.IndexOf(">mb64</"));
Assert.Less(reqstr.IndexOf(">mb64</"), reqstr.IndexOf(">ma</"));
}
public static string SerializeValue(object value, bool indent)
{
var memStm = new MemoryStream();
var writer = XmlRpcXmlWriter.Create(
memStm,
new XmlRpcFormatSettings { OmitXmlDeclaration = true, UseIndentation = indent });
var serializer = new XmlRpcSerializer();
serializer.Serialize(writer, value, new MappingActions { NullMappingAction = NullMappingAction.Error });
writer.Flush();
memStm.Position = 0;
return new StreamReader(memStm).ReadToEnd();
}
// private methods
//
MethodCall DeserializeRequest(
ITransportHeaders requestHeaders,
Stream requestStream)
{
string requestUri = (string) requestHeaders["__RequestUri"];
Type svcType = GetServiceType(requestUri);
XmlRpcSerializer serializer = new XmlRpcSerializer();
XmlRpcRequest xmlRpcReq
= serializer.DeserializeRequest(requestStream, svcType);
Header[] headers = GetChannelHeaders(requestHeaders, xmlRpcReq, svcType);
MethodCall mthdCall = new MethodCall(headers);
mthdCall.ResolveMethod();
return mthdCall;
}
