private void processCall(object state)
{
PmlDictionary Message = (PmlDictionary)state;
bool wantReply = Message.ContainsKey("SID");
UInt32 SID = 0;
if (wantReply)
{
SID = Message.GetChild("SID").ToUInt32();
}
PmlDictionary reply = new PmlDictionary()
{
{ "CMD", "RPL" }, { "SID", SID }
};
try {
if (CallReceived != null)
{
PmlCallReceivedEventArgs ea = new PmlCallReceivedEventArgs(Message.GetChild("MSG"), wantReply, SID);
CallReceived(this, ea);
reply.Add("MSG", ea.Reply);
}
} catch (Exception ex) {
reply.Add("ERRMSG", ex.Message);
reply.Add("ERRTXT", ex.ToString());
}
if (wantReply && Channel.IsOpen)
{
try {
_WriteMessage(reply);
} catch { }
}
}
private static PmlDictionary ReadDictionary(BinaryReader Reader)
{
PmlDictionary ElementD = new PmlDictionary();
int size = ReadInt32(Reader);
return(ReadUntypedObject(Reader));
}
internal void Completed(PmlDictionary reply)
{
lock (this) {
this.Reply = reply;
Monitor.PulseAll(this);
}
}
private static void WriteDictionary(BinaryWriter w, PmlDictionary value)
{
WriteUInt32(w, (UInt32)value.Count);
foreach (KeyValuePair <String, PmlElement> kvp in value)
{
WriteString(w, kvp.Key);
WriteElementTo(kvp.Value, w);
}
}
private static void WriteUntypedObject(BinaryWriter w, PmlDictionary value)
{
foreach (KeyValuePair <String, PmlElement> kvp in value)
{
WriteString(w, kvp.Key);
WriteElementTo(kvp.Value, w);
}
WriteEnd(w);
}
private static PmlDictionary ReadUntypedObject(BinaryReader Reader)
{
PmlDictionary ElementD = new PmlDictionary();
string key = ReadShortString(Reader);
for (byte type = Reader.ReadByte(); type != 9; type = Reader.ReadByte())
{
ElementD.Add(key, ReadData(Reader, (AmfDataType)type));
key = ReadShortString(Reader);
}
return(ElementD);
}
protected void WriteSessionMessage(UInt32 SID, byte CMD, PmlElement MSG)
{
PmlDictionary Msg2 = new PmlDictionary()
{
{ "CMD", "SES" },
{ "SID", SID },
{ "SCMD", CMD },
};
if (MSG != null)
{
Msg2.Add("MSG", MSG);
}
_WriteMessage(Msg2);
}
public static PmlElement ReadElement(System.Xml.XmlNode X)
{
PmlType pType;
bool pTypeFound = false;
pType = PmlType.Null;
pTypeFound = true;
if (X.Attributes != null && X.Attributes.Count > 0 && X.Attributes["type"] != null)
{
switch (X.Attributes["type"].Value.ToLowerInvariant())
{
case "binary":
pType = PmlType.Binary;
break;
case "collection":
pType = PmlType.Collection;
break;
case "dictionary":
pType = PmlType.Dictionary;
break;
case "string":
pType = PmlType.String;
break;
case "null":
pType = PmlType.Null;
break;
case "integer":
pType = PmlType.Integer;
break;
default:
pTypeFound = false;
break;
}
}
else
{
pTypeFound = false;
}
if (!pTypeFound)
{
if (X.HasChildNodes)
{
if (X.ChildNodes.Count == 1 && X.FirstChild.NodeType == System.Xml.XmlNodeType.Text)
{
Int64 dummy;
UInt64 dummyu;
if (Int64.TryParse(X.FirstChild.Value, out dummy) || UInt64.TryParse(X.FirstChild.Value, out dummyu))
{
pType = PmlType.Integer;
}
else
{
pType = PmlType.String;
}
}
else if (X.FirstChild.Name == "item")
{
pType = PmlType.Collection;
}
else
{
pType = PmlType.Dictionary;
}
}
else
{
pType = PmlType.Null;
}
}
switch (pType)
{
case PmlType.Null:
return(new PmlNull());
case PmlType.Binary:
if (X.FirstChild == null)
{
return(new PmlBinary(new byte[0]));
}
else
{
return(new PmlBinary(Convert.FromBase64String(X.FirstChild.Value)));
}
case PmlType.Integer:
return(new PmlInteger(X.FirstChild.Value));
case PmlType.String:
if (X.FirstChild == null)
{
return(new PmlString(""));
}
else
{
return(new PmlString(X.FirstChild.Value));
}
case PmlType.Collection:
PmlCollection C = new PmlCollection();
foreach (XmlNode N in X.ChildNodes)
{
C.Add(ReadElement(N));
}
return(C);
case PmlType.Dictionary:
PmlDictionary D = new PmlDictionary();
foreach (XmlNode N in X.ChildNodes)
{
D.Add(N.Name, ReadElement(N));
}
return(D);
default:
return(null);
}
}
private static PmlElement ReadElementFrom(TextReader reader)
{
int c = FindNextToken(reader);
if (c == -1)
{
return(null);
}
if (c == '{')
{
reader.Read();
c = FindNextToken(reader);
PmlDictionary d = new PmlDictionary();
while (c != '}')
{
if (c == -1)
{
throw new EndOfStreamException();
}
String k = ReadString(reader);
c = FindNextToken(reader);
if (c != ':')
{
throw new JsonFormatException("Expected colon, got " + (Char)c);
}
reader.Read();
PmlElement e = ReadElementFrom(reader);
d.Add(k, e);
c = FindNextToken(reader);
if (c == '}')
{
break;
}
if (c != ',')
{
throw new JsonFormatException("Expected comma or closing curly brace, got " + (Char)c);
}
c = reader.Read();
c = FindNextToken(reader);
}
reader.Read();
return(d);
}
else if (c == '[')
{
reader.Read();
c = FindNextToken(reader);
PmlCollection l = new PmlCollection();
while (c != ']')
{
if (c == -1)
{
throw new EndOfStreamException();
}
PmlElement e = ReadElementFrom(reader);
l.Add(e);
c = FindNextToken(reader);
if (c == ']')
{
break;
}
if (c != ',')
{
throw new JsonFormatException("Expected comma or closing curly brace, got " + (Char)c);
}
c = reader.Read();
}
reader.Read();
return(l);
}
else if (c == '"' || c == '\'')
{
return(ReadString(reader));
}
else if (c == 'n')
{
ExpectLiteral(reader, "null");
return(new PmlNull());
}
else if (c == 't')
{
ExpectLiteral(reader, "true");
return(1);
}
else if (c == 'f')
{
ExpectLiteral(reader, "false");
return(0);
}
else if (c == '-' || (c >= '0' && c <= '9'))
{
StringBuilder sb = new StringBuilder();
while (c == '.' || c == '-' || c == '+' || c == '.' || c == 'e' || c == 'E' || (c >= '0' && c <= '9'))
{
sb.Append((Char)c);
reader.Read();
c = reader.Peek();
}
String str = sb.ToString();
if (str.IndexOf(".", StringComparison.OrdinalIgnoreCase) != -1 || str.IndexOf("e", StringComparison.OrdinalIgnoreCase) != -1)
{
Double number = Double.Parse(str, NumberStyles.Any, CultureInfo.InvariantCulture);
return(str);
}
else
{
return(Int64.Parse(str, NumberStyles.Any, CultureInfo.InvariantCulture));
}
}
else
{
throw new JsonFormatException("Expected JSON token, got " + (Char)c);
}
}
private static PmlElement ReadElementFrom(Stream stream, Encoding encoding)
{
Char type = ReadChar(stream);
switch (type)
{
case 'N':
ReadExpect(stream, ';');
return(new PmlNull());
case 'i':
ReadExpect(stream, ':');
return(new PmlInteger(ReadNumber(stream, ';')));
case 'd':
ReadExpect(stream, ':');
return(new PmlNumber(ReadNumber(stream, ';')));
case 's':
ReadExpect(stream, ':');
int strlen = int.Parse(ReadNumber(stream, ':'));
ReadExpect(stream, '"');
String str = ReadString(stream, encoding, strlen);
ReadExpect(stream, '"');
ReadExpect(stream, ';');
return(new PmlString(str));
case 'a':
PmlDictionary dict = new PmlDictionary();
ReadExpect(stream, ':');
int count = int.Parse(ReadNumber(stream, ':'));
ReadExpect(stream, '{');
for (int i = 0; i < count; i++)
{
Char read = ReadChar(stream);
String key;
switch (read)
{
case 'i':
ReadExpect(stream, ':');
key = ReadNumber(stream, ';');
break;
case 's':
ReadExpect(stream, ':');
strlen = int.Parse(ReadNumber(stream, ':'));
ReadExpect(stream, '"');
key = ReadString(stream, encoding, strlen);
ReadExpect(stream, '"');
ReadExpect(stream, ';');
break;
case 'd':
ReadExpect(stream, ':');
key = ReadNumber(stream, ';');
break;
default:
throw new NotSupportedException("Only integer and string keys are supported, got: " + read);
}
dict.Add(key, ReadElementFrom(stream, encoding));
}
ReadExpect(stream, '}');
return(dict);
default:
throw new NotSupportedException("Unknown type: " + type);
}
}
private static PmlElement ReadElementFrom(BinaryReader Reader)
{
Byte EType = Reader.ReadByte();
switch (EType)
{
case 0: return(new PmlNull());
case 1:
PmlDictionary ElementD = new PmlDictionary();
do
{
byte B = Reader.ReadByte();
if (B == 0)
{
return(ElementD);
}
else if (B == 1)
{
ElementD.Add(Reader.ReadString(), ReadElementFrom(Reader));
}
else
{
return(null);
}
}while (true);
case 2:
PmlCollection ElementC = new PmlCollection();
do
{
byte B = Reader.ReadByte();
if (B == 0)
{
return(ElementC);
}
else if (B == 1)
{
ElementC.Add(ReadElementFrom(Reader));
}
else
{
return(null);
}
}while (true);
case 10:
int Len = 0;
Len = Reader.ReadInt32();
return(new PmlBinary(Reader.ReadBytes(Len)));
case 11:
return(new PmlString(Reader.ReadString()));
case 20: {
byte B = Reader.ReadByte();
if (B == 0)
{
return(new PmlInteger(Reader.ReadUInt64()));
}
else if (B == 1)
{
return(new PmlInteger(Reader.ReadInt64()));
}
else
{
return(null);
}
}
case 21: return(Reader.ReadBoolean());
case 22: return(Reader.ReadDouble());
default:
throw new Exception("Unknown PML type code " + EType.ToString());
}
}
