public static object Parse(
XmlReader rdr,
Type valueType,
MappingAction action,
out Type parsedType,
out Type parsedArrayType)
{
parsedType = parsedArrayType = null;
rdr.ReadToDescendant("value");
var mappingStack = new MappingStack("request");
return new XmlRpcDeserializer().ParseValueElement(rdr, valueType, mappingStack, action);
}
public static object Parse(
XmlReader rdr,
Type valueType,
MappingAction action,
XmlRpcDeserializer deserializer,
out Type parsedType,
out Type parsedArrayType)
{
parsedType = parsedArrayType = null;
rdr.ReadToDescendant("value");
MappingStack parseStack = new MappingStack("request");
object obj = deserializer.ParseValueElement(rdr, valueType, parseStack, action);
return obj;
}
private object MapDouble(string value, Type valType, MappingStack mappingStack, MappingAction mappingAction,
out Type mappedType)
{
CheckExpectedType(valType, typeof(double), mappingStack);
mappedType = typeof(double);
return(OnStack("double", mappingStack, (() =>
{
try
{
return double.Parse(value, CultureInfo.InvariantCulture.NumberFormat);
}
catch (Exception exception0)
{
throw new XmlRpcInvalidXmlRpcException(mappingStack.MappingType + " contains invalid double value " +
StackDump(mappingStack));
}
})));
}
private XmlRpcFaultException ParseFault(IEnumerator<Node> iter, MappingStack parseStack,
MappingAction mappingAction)
{
iter.MoveNext();
Type mappedType;
var xmlRpcStruct = MapHashtable(iter, null, parseStack, mappingAction, out mappedType) as XmlRpcStruct;
object obj1 = xmlRpcStruct["faultCode"];
object obj2 = xmlRpcStruct["faultString"];
if (obj1 is string)
{
int result;
if (!int.TryParse(obj1 as string, out result))
throw new XmlRpcInvalidXmlRpcException("faultCode not int or string");
obj1 = result;
}
return new XmlRpcFaultException((int)obj1, (string)obj2);
}
protected object MapHashtable(IEnumerator <Node> iter, Type valType, MappingStack mappingStack,
MappingAction mappingAction, out Type mappedType)
{
mappedType = null;
var xmlRpcStruct = new XmlRpcStruct();
(mappingStack).Push("struct mapped to XmlRpcStruct");
try
{
while (iter.MoveNext())
{
if (iter.Current is StructMember)
{
string str = (iter.Current as StructMember).Value;
if (xmlRpcStruct.ContainsKey(str) && !IgnoreDuplicateMembers)
{
throw new XmlRpcInvalidXmlRpcException(mappingStack.MappingType +
" contains struct value with duplicate member " + str +
" " + StackDump(mappingStack));
}
else
{
iter.MoveNext();
object obj = OnStack(string.Format("member {0}", str), mappingStack,
(() => MapValueNode(iter, null, mappingStack, mappingAction)));
if (!xmlRpcStruct.ContainsKey(str))
{
xmlRpcStruct[str] = obj;
}
}
}
else
{
break;
}
}
}
finally
{
mappingStack.Pop();
}
return(xmlRpcStruct);
}
private object MapBoolean(string value, Type valType, MappingStack mappingStack, MappingAction mappingAction,
out Type mappedType)
{
CheckExpectedType(valType, typeof(bool), mappingStack);
mappedType = typeof(bool);
return(OnStack("boolean", mappingStack, (() =>
{
if (value == "1")
{
return true;
}
if (value == "0")
{
return false;
}
throw new XmlRpcInvalidXmlRpcException(mappingStack.MappingType + " contains invalid boolean value " +
StackDump(mappingStack));
})));
}
private object MapInt(string value, Type valType, MappingStack mappingStack, MappingAction mappingAction,
out Type mappedType)
{
CheckExpectedType(valType, typeof(int), mappingStack);
if (valType != null && valType.IsEnum)
{
return(MapNumberToEnum(value, valType, "int", mappingStack, out mappedType));
}
mappedType = typeof(int);
return(OnStack("integer", mappingStack, (() =>
{
int local0;
if (!int.TryParse(value, out local0))
{
throw new XmlRpcInvalidXmlRpcException(mappingStack.MappingType + " contains invalid int value " +
StackDump(mappingStack));
}
return local0;
})));
}
private XmlRpcFaultException ParseFault(IEnumerator <Node> iter, MappingStack parseStack,
MappingAction mappingAction)
{
iter.MoveNext();
Type mappedType;
var xmlRpcStruct = MapHashtable(iter, null, parseStack, mappingAction, out mappedType) as XmlRpcStruct;
object obj1 = xmlRpcStruct["faultCode"];
object obj2 = xmlRpcStruct["faultString"];
if (obj1 is string)
{
int result;
if (!int.TryParse(obj1 as string, out result))
{
throw new XmlRpcInvalidXmlRpcException("faultCode not int or string");
}
obj1 = result;
}
return(new XmlRpcFaultException((int)obj1, (string)obj2));
}
private object MapBase64(string value, Type valType, MappingStack mappingStack,
out Type mappedType)
{
CheckExpectedType(valType, typeof(byte[]), mappingStack);
mappedType = typeof(int);
return(OnStack("base64", mappingStack, (() =>
{
if (value == "")
{
return new byte[0];
}
try
{
return Convert.FromBase64String(value);
}
catch (Exception exception0)
{
throw new XmlRpcInvalidXmlRpcException(mappingStack.MappingType + " contains invalid base64 value " +
StackDump(mappingStack));
}
})));
}
private void AddCustomField(IEnumerator <Node> iter, MappingStack mappingStack, MappingAction mappingAction, string name,
object instance)
{
Type valType;
if (iter.Current is Base64Value || iter.Current is LongValue)
{
valType = typeof(long);
}
else if (iter.Current is BooleanValue)
{
valType = typeof(bool);
}
else if (iter.Current is DateTimeValue)
{
valType = typeof(DateTime);
}
else if (iter.Current is DoubleValue)
{
valType = typeof(double);
}
else if (iter.Current is IntValue)
{
valType = typeof(int);
}
else if (iter.Current is StringValue)
{
valType = typeof(string);
}
else
{
return;
}
object obj = OnStack(name, mappingStack, (() => MapValueNode(iter, valType, mappingStack, mappingAction)));
((Table)instance).SetCustomField(name, obj);
}
private XmlRpcException DeserializeFault(IEnumerator <Node> iter)
{
var parseStack = new MappingStack("fault response");
throw ParseFault(iter, parseStack, MappingAction.Error);
}
private void ReportMissingMembers(Type valueType, IEnumerable <string> names, MappingStack mappingStack)
{
var stringBuilder = new StringBuilder();
int num = 0;
string str1 = "";
foreach (string memberName in names)
{
if (MemberMappingAction(valueType, memberName, MappingAction.Error) == MappingAction.Error)
{
stringBuilder.Append(str1);
stringBuilder.Append(memberName);
str1 = " ";
++num;
}
}
if (num <= 0)
{
return;
}
string str2 = "";
if (num > 1)
{
str2 = "s";
}
throw new XmlRpcTypeMismatchException(mappingStack.MappingType +
" contains struct value with missing non-optional member" + str2 +
": " + (stringBuilder) + " " + StackDump(mappingStack));
}
public object MapValueNode(IEnumerator <Node> iter, Type valType, MappingStack mappingStack,
MappingAction mappingAction)
{
var valueNode = iter.Current as ValueNode;
if (valType != null && valType.BaseType == null)
{
valType = null;
}
if (valueNode is StringValue && valueNode.ImplicitValue)
{
CheckImplictString(valType, mappingStack);
}
object obj = null;
Type mappedType;
if (iter.Current is ArrayValue)
{
obj = MapArray(iter, valType, mappingStack, mappingAction, out mappedType);
}
else if (iter.Current is StructValue)
{
if (valType != null && valType != typeof(XmlRpcStruct) && !valType.IsSubclassOf(typeof(XmlRpcStruct)))
{
obj = MapStruct(iter, valType, mappingStack, mappingAction, out mappedType);
}
else
{
if (valType == null || valType == typeof(object))
{
valType = typeof(XmlRpcStruct);
}
obj = MapHashtable(iter, valType, mappingStack, mappingAction, out mappedType);
}
}
else if (iter.Current is Base64Value)
{
obj = MapBase64(valueNode.Value, valType, mappingStack, out mappedType);
}
else if (iter.Current is IntValue)
{
obj = MapInt(valueNode.Value, valType, mappingStack, mappingAction, out mappedType);
}
else if (iter.Current is LongValue)
{
obj = MapLong(valueNode.Value, valType, mappingStack, mappingAction, out mappedType);
}
else if (iter.Current is StringValue)
{
obj = MapString(valueNode.Value, valType, mappingStack, mappingAction, out mappedType);
}
else if (iter.Current is BooleanValue)
{
obj = MapBoolean(valueNode.Value, valType, mappingStack, mappingAction, out mappedType);
}
else if (iter.Current is DoubleValue)
{
obj = MapDouble(valueNode.Value, valType, mappingStack, mappingAction, out mappedType);
}
else if (iter.Current is DateTimeValue)
{
obj = MapDateTime(valueNode.Value, valType, mappingStack, mappingAction, out mappedType);
}
else if (iter.Current is NilValue)
{
obj = MapNilValue(valType, mappingStack, out mappedType);
}
return(obj);
}
XmlRpcFaultException ParseFault(
IEnumerator<Node> iter,
MappingStack parseStack,
MappingAction mappingAction)
{
iter.MoveNext(); // move to StructValue
Type parsedType;
var faultStruct = MapHashtable(iter, null, parseStack, mappingAction,
out parsedType) as XmlRpcStruct;
object faultCode = faultStruct["faultCode"];
object faultString = faultStruct["faultString"];
if (faultCode is string)
{
int value;
if (!Int32.TryParse(faultCode as string, out value))
throw new XmlRpcInvalidXmlRpcException("faultCode not int or string");
faultCode = value;
}
return new XmlRpcFaultException((int)faultCode, (string)faultString);
}
private object MapNumberToEnum(string value, Type enumType, string xmlRpcType, MappingStack mappingStack,
out Type mappedType)
{
mappedType = enumType;
return(OnStack(xmlRpcType, mappingStack, (() =>
{
try
{
object local2 = Convert.ChangeType(long.Parse(value), Enum.GetUnderlyingType(enumType), null);
if (Enum.IsDefined(enumType, local2))
{
return Enum.ToObject(enumType, local2);
}
throw new XmlRpcInvalidEnumValue(mappingStack.MappingType + " contains " + xmlRpcType +
"mapped to undefined enum value " + StackDump(mappingStack));
}
catch (XmlRpcInvalidEnumValue exception0)
{
throw;
}
catch (Exception exception1)
{
throw new XmlRpcInvalidEnumValue(mappingStack.MappingType + " contains invalid or out of range " +
xmlRpcType + " value mapped to enum " + StackDump(mappingStack));
}
})));
}
private object MapStringToEnum(string value, Type enumType, string xmlRpcType, MappingStack mappingStack,
MappingAction mappingAction, out Type mappedType)
{
mappedType = enumType;
return(OnStack(xmlRpcType, mappingStack, (() =>
{
try
{
return Enum.Parse(enumType, value, true);
}
catch (XmlRpcInvalidEnumValue exception_0)
{
throw;
}
catch (Exception exception_1)
{
throw new XmlRpcInvalidEnumValue(mappingStack.MappingType + " contains invalid or out of range " +
xmlRpcType + " value mapped to enum " + StackDump(mappingStack));
}
})));
}
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);
}
}
private XmlRpcException DeserializeFault(IEnumerator<Node> iter)
{
MappingStack faultStack = new MappingStack("fault response");
// TODO: use global action setting
MappingAction mappingAction = MappingAction.Error;
XmlRpcFaultException faultEx = ParseFault(iter, faultStack, // TODO: fix
mappingAction);
throw faultEx;
}
private object MapStruct(IEnumerator <Node> iter, Type valueType, MappingStack mappingStack,
MappingAction mappingAction, out Type mappedType)
{
mappedType = null;
if (valueType.IsPrimitive)
{
throw new XmlRpcTypeMismatchException(mappingStack.MappingType + " contains struct value where " +
XmlRpcTypeInfo.GetXmlRpcTypeString(valueType) + " expected " +
StackDump(mappingStack));
}
if (valueType.IsGenericType)
{
if (valueType.GetGenericTypeDefinition() == typeof(Nullable <>))
{
valueType = valueType.GetGenericArguments()[0];
}
}
object instance;
try
{
instance = Activator.CreateInstance(valueType);
}
catch (Exception ex)
{
throw new XmlRpcTypeMismatchException(mappingStack.MappingType + " contains struct value where " +
XmlRpcTypeInfo.GetXmlRpcTypeString(valueType) +
" expected (as type " + valueType.Name + ") " +
StackDump(mappingStack));
}
MappingAction mappingAction1 = mappingAction;
if (valueType != null)
{
(mappingStack).Push("struct mapped to type " + valueType.Name);
mappingAction1 = StructMappingAction(valueType, mappingAction);
}
else
{
(mappingStack).Push("struct");
}
List <string> names = new List <string>();
CreateFieldNamesMap(valueType, names);
int num = 0;
List <string> list = new List <string>();
try
{
while (iter.MoveNext())
{
if (iter.Current is StructMember)
{
string XmlRpcName = (iter.Current as StructMember).Value;
if (list.Contains(XmlRpcName))
{
if (!IgnoreDuplicateMembers)
{
throw new XmlRpcInvalidXmlRpcException(mappingStack.MappingType +
" contains struct value with duplicate member " +
XmlRpcName + " " + StackDump(mappingStack));
}
}
else
{
list.Add(XmlRpcName);
string name = GetStructName(valueType, XmlRpcName) ?? XmlRpcName;
MemberInfo element = valueType.GetField(name) ??
(MemberInfo)valueType.GetProperty(name);
if (element == null)
{
iter.MoveNext();
//If this is a table object, then we need to populate
// the value in the custom fields dictionary.
if (valueType.IsSubclassOf(typeof(Table)))
{
AddCustomField(iter, mappingStack, mappingAction, name, instance);
}
if (iter.Current is ComplexValueNode)
{
int depth = iter.Current.Depth;
while (!(iter.Current is EndComplexValueNode) || iter.Current.Depth != depth)
{
iter.MoveNext();
}
}
}
else
{
if (names.Contains(name))
{
names.Remove(name);
}
else if (Attribute.IsDefined(element, typeof(NonSerializedAttribute)))
{
(mappingStack).Push(string.Format("member {0}", name));
throw new XmlRpcNonSerializedMember(
"Cannot map XML-RPC struct member onto member marked as [NonSerialized]: " +
StackDump(mappingStack));
}
Type memberType = element.MemberType == MemberTypes.Field
? (element as FieldInfo).FieldType
: (element as PropertyInfo).PropertyType;
string p = valueType == null
? string.Format("member {0}", name)
: string.Format("member {0} mapped to type {1}", name,
memberType.Name);
iter.MoveNext();
object obj = OnStack(p, mappingStack,
(() =>
MapValueNode(iter, memberType, mappingStack, mappingAction)));
if (element.MemberType == MemberTypes.Field)
{
(element as FieldInfo).SetValue(instance, obj);
}
else
{
(element as PropertyInfo).SetValue(instance, obj, null);
}
++num;
}
}
}
else
{
break;
}
}
if (mappingAction1 == MappingAction.Error && names.Count > 0)
{
ReportMissingMembers(valueType, names, mappingStack);
}
return(instance);
}
finally
{
mappingStack.Pop();
}
}
private XmlRpcException DeserializeFault(IEnumerator<Node> iter)
{
var parseStack = new MappingStack("fault response");
throw ParseFault(iter, parseStack, MappingAction.Error);
}
public static object ParseValue(string xml, Type valueType)
{
MappingAction action = MappingAction.Error;
StringReader sr = new StringReader(xml);
XmlReader rdr = XmlRpcXmlReader.Create(sr);
rdr.MoveToContent();
MappingStack parseStack = new MappingStack("value");
var deser = new XmlRpcDeserializer();
object obj = deser.ParseValueElement(rdr, valueType, parseStack, action);
return obj;
}
private object MapArray(IEnumerator <Node> iter, Type valType, MappingStack mappingStack,
MappingAction mappingAction, out Type mappedType)
{
mappedType = null;
if (valType != null && !valType.IsArray && (valType != typeof(Array) && valType != typeof(object)))
{
throw new XmlRpcTypeMismatchException(mappingStack.MappingType + " contains array value where " +
XmlRpcTypeInfo.GetXmlRpcTypeString(valType) + " expected " +
StackDump(mappingStack));
}
if (valType != null)
{
if (XmlRpcTypeInfo.GetXmlRpcType(valType) == XmlRpcType.tMultiDimArray)
{
(mappingStack).Push("array mapped to type " + valType.Name);
return(MapMultiDimArray(iter, valType, mappingStack, mappingAction));
}
else
{
(mappingStack).Push("array mapped to type " + valType.Name);
}
}
else
{
(mappingStack).Push("array");
}
List <object> list = new List <object>();
Type valType1 = DetermineArrayItemType(valType);
bool flag = false;
Type elementType = null;
while (iter.MoveNext() && iter.Current is ValueNode)
{
(mappingStack).Push(string.Format("element {0}", list.Count));
object obj = MapValueNode(iter, valType1, mappingStack, mappingAction);
list.Add(obj);
mappingStack.Pop();
}
foreach (object obj in list)
{
if (obj != null)
{
if (!flag)
{
elementType = obj.GetType();
flag = true;
}
else if (elementType != obj.GetType())
{
elementType = null;
}
}
}
object[] args = new object[1]
{
list.Count
};
object obj1 = valType == null || valType == typeof(Array) || valType == typeof(object)
? (elementType != null
? Array.CreateInstance(elementType, (int)args[0])
: CreateArrayInstance(typeof(object[]), args))
: CreateArrayInstance(valType, args);
for (int index = 0; index < list.Count; ++index)
{
((Array)obj1).SetValue(list[index], index);
}
mappingStack.Pop();
return(obj1);
}
string StackDump(MappingStack parseStack)
{
StringBuilder sb = new StringBuilder();
foreach (string elem in parseStack)
{
sb.Insert(0, elem);
sb.Insert(0, " : ");
}
sb.Insert(0, parseStack.MappingType);
sb.Insert(0, "[");
sb.Append("]");
return sb.ToString();
}
