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; }