875 lines
31 KiB
C#
875 lines
31 KiB
C#
/*
|
|
* Analyst.cs: proxy that makes packet inspection and modifcation interactive
|
|
* See the README for usage instructions.
|
|
*
|
|
* Copyright (c) 2006 Austin Jennings
|
|
* Modified by "qode" and "mcortez" on December 21st, 2006 to work with the new
|
|
* pregen
|
|
* All rights reserved.
|
|
*
|
|
* - Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* - Redistributions of source code must retain the above copyright notice, this
|
|
* list of conditions and the following disclaimer.
|
|
* - Neither the name of the openmetaverse.org nor the names
|
|
* of its contributors may be used to endorse or promote products derived from
|
|
* this software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
|
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Net;
|
|
using System.Text.RegularExpressions;
|
|
using System.Reflection;
|
|
using System.Xml;
|
|
using Nwc.XmlRpc;
|
|
using OpenMetaverse;
|
|
using OpenMetaverse.StructuredData;
|
|
using OpenMetaverse.Packets;
|
|
using GridProxy;
|
|
|
|
|
|
public class CapAnalyst : ProxyPlugin
|
|
{
|
|
private ProxyFrame frame;
|
|
private Proxy proxy;
|
|
private HashSet<string> loggedCaps = new HashSet<string>();
|
|
private string logGrep = null;
|
|
private Dictionary<PacketType, Dictionary<BlockField, object>> modifiedPackets = new Dictionary<PacketType, Dictionary<BlockField, object>>();
|
|
private Assembly openmvAssembly;
|
|
private StreamWriter output;
|
|
|
|
//private PacketDecoder DecodePacket = new PacketDecoder();
|
|
|
|
public CapAnalyst(ProxyFrame frame)
|
|
{
|
|
this.frame = frame;
|
|
this.proxy = frame.proxy;
|
|
}
|
|
|
|
~CapAnalyst()
|
|
{
|
|
if (output != null)
|
|
output.Close();
|
|
}
|
|
|
|
public override void Init()
|
|
{
|
|
openmvAssembly = Assembly.Load("OpenMetaverse");
|
|
if (openmvAssembly == null) throw new Exception("Assembly load exception");
|
|
|
|
// build the table of /command delegates
|
|
InitializeCommandDelegates();
|
|
|
|
// handle command line arguments
|
|
foreach (string arg in frame.Args)
|
|
if (arg == "--log-all")
|
|
LogAll();
|
|
else if (arg.Contains("--log-whitelist="))
|
|
LogWhitelist(arg.Substring(arg.IndexOf('=') + 1));
|
|
else if (arg.Contains("--no-log-blacklist="))
|
|
NoLogBlacklist(arg.Substring(arg.IndexOf('=') + 1));
|
|
else if (arg.Contains("--output="))
|
|
SetOutput(arg.Substring(arg.IndexOf('=') + 1));
|
|
|
|
StartLogCap("FetchInventory2");
|
|
StartLogCap("FetchInventoryDescendents2");
|
|
|
|
Console.WriteLine("CapAnalyst loaded");
|
|
}
|
|
|
|
// InitializeCommandDelegates: configure Analyst's commands
|
|
private void InitializeCommandDelegates()
|
|
{
|
|
frame.AddCommand("/logcap", new ProxyFrame.CommandDelegate(CmdLog));
|
|
frame.AddCommand("/-logcap", new ProxyFrame.CommandDelegate(CmdNoLog));
|
|
// frame.AddCommand("/grep", new ProxyFrame.CommandDelegate(CmdGrep));
|
|
// frame.AddCommand("/drop", new ProxyFrame.CommandDelegate(CmdDrop));
|
|
// frame.AddCommand("/-drop", new ProxyFrame.CommandDelegate(CmdNoDrop));
|
|
// frame.AddCommand("/set", new ProxyFrame.CommandDelegate(CmdSet));
|
|
// frame.AddCommand("/-set", new ProxyFrame.CommandDelegate(CmdNoSet));
|
|
// frame.AddCommand("/inject", new ProxyFrame.CommandDelegate(CmdInject));
|
|
// frame.AddCommand("/in", new ProxyFrame.CommandDelegate(CmdInject));
|
|
}
|
|
|
|
// private static PacketType packetTypeFromName(string name)
|
|
// {
|
|
// Type packetTypeType = typeof(PacketType);
|
|
// System.Reflection.FieldInfo f = packetTypeType.GetField(name);
|
|
// if (f == null) throw new ArgumentException("Bad packet type");
|
|
// return (PacketType)Enum.ToObject(packetTypeType, (int)f.GetValue(packetTypeType));
|
|
// }
|
|
|
|
// CmdLog: handle a /log command
|
|
private void CmdLog(string[] words)
|
|
{
|
|
if (words.Length != 2)
|
|
SayToUser("Usage: /logcap <packet name>");
|
|
else if (words[1] == "*")
|
|
{
|
|
LogAll();
|
|
SayToUser("logging all caps");
|
|
}
|
|
else
|
|
{
|
|
// PacketType pType;
|
|
// try
|
|
// {
|
|
// pType = packetTypeFromName(words[1]);
|
|
// }
|
|
// catch (ArgumentException)
|
|
// {
|
|
// SayToUser("Bad cap name: " + words[1]);
|
|
// return;
|
|
// }
|
|
string capName = words[1];
|
|
|
|
StartLogCap(capName);
|
|
SayToUser("logging " + capName);
|
|
}
|
|
}
|
|
|
|
private void StartLogCap(string capName)
|
|
{
|
|
loggedCaps.Add(capName);
|
|
proxy.AddCapsDelegate(capName, LogCap);
|
|
}
|
|
|
|
// CmdNoLog: handle a /-log command
|
|
private void CmdNoLog(string[] words)
|
|
{
|
|
if (words.Length != 2)
|
|
SayToUser("Usage: /-logcap <cap name>");
|
|
else if (words[1] == "*")
|
|
{
|
|
NoLogAll();
|
|
SayToUser("stopped logging all caps");
|
|
}
|
|
else
|
|
{
|
|
// PacketType pType = packetTypeFromName(words[1]);
|
|
string capName = words[1];
|
|
loggedCaps.Remove(capName);
|
|
proxy.RemoveCapRequestDelegate(capName, LogCap);
|
|
|
|
SayToUser("stopped logging " + capName);
|
|
}
|
|
}
|
|
|
|
// CmdGrep: handle a /grep command
|
|
private void CmdGrep(string[] words)
|
|
{
|
|
if (words.Length == 1)
|
|
{
|
|
logGrep = null;
|
|
SayToUser("stopped filtering logs");
|
|
}
|
|
else
|
|
{
|
|
string[] regexArray = new string[words.Length - 1];
|
|
Array.Copy(words, 1, regexArray, 0, words.Length - 1);
|
|
logGrep = String.Join(" ", regexArray);
|
|
SayToUser("filtering log with " + logGrep);
|
|
}
|
|
}
|
|
|
|
private void CmdDrop(string[] words)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
private void CmdNoDrop(string[] words)
|
|
{
|
|
throw new NotImplementedException();
|
|
}
|
|
|
|
// CmdSet: handle a /set command
|
|
private void CmdSet(string[] words)
|
|
{
|
|
// if (words.Length < 5)
|
|
// SayToUser("Usage: /set <packet name> <block> <field> <value>");
|
|
// else
|
|
// {
|
|
// PacketType pType;
|
|
// try
|
|
// {
|
|
// pType = packetTypeFromName(words[1]);
|
|
// }
|
|
// catch (ArgumentException)
|
|
// {
|
|
// SayToUser("Bad packet name: " + words[1]);
|
|
// return;
|
|
// }
|
|
//
|
|
// string[] valueArray = new string[words.Length - 4];
|
|
// Array.Copy(words, 4, valueArray, 0, words.Length - 4);
|
|
// string valueString = String.Join(" ", valueArray);
|
|
// object value;
|
|
// try
|
|
// {
|
|
// value = MagicCast(words[1], words[2], words[3], valueString);
|
|
// }
|
|
// catch (Exception e)
|
|
// {
|
|
// SayToUser(e.Message);
|
|
// return;
|
|
// }
|
|
//
|
|
// Dictionary<BlockField, object> fields;
|
|
// if (modifiedPackets.ContainsKey(pType))
|
|
// fields = (Dictionary<BlockField, object>)modifiedPackets[pType];
|
|
// else
|
|
// fields = new Dictionary<BlockField, object>();
|
|
//
|
|
// fields[new BlockField(words[2], words[3])] = value;
|
|
// modifiedPackets[pType] = fields;
|
|
//
|
|
// proxy.AddDelegate(pType, Direction.Incoming, new PacketDelegate(ModifyIn));
|
|
// proxy.AddDelegate(pType, Direction.Outgoing, new PacketDelegate(ModifyOut));
|
|
//
|
|
// SayToUser("setting " + words[1] + "." + words[2] + "." + words[3] + " = " + valueString);
|
|
// }
|
|
}
|
|
|
|
// CmdNoSet: handle a /-set command
|
|
private void CmdNoSet(string[] words)
|
|
{
|
|
// if (words.Length == 2 && words[1] == "*")
|
|
// {
|
|
// foreach (PacketType pType in modifiedPackets.Keys)
|
|
// {
|
|
// proxy.RemoveDelegate(pType, Direction.Incoming, new PacketDelegate(ModifyIn));
|
|
// proxy.RemoveDelegate(pType, Direction.Outgoing, new PacketDelegate(ModifyOut));
|
|
// }
|
|
// modifiedPackets = new Dictionary<PacketType, Dictionary<BlockField, object>>();
|
|
//
|
|
// SayToUser("stopped setting all fields");
|
|
// }
|
|
// else if (words.Length == 4)
|
|
// {
|
|
// PacketType pType;
|
|
// try
|
|
// {
|
|
// pType = packetTypeFromName(words[1]);
|
|
// }
|
|
// catch (ArgumentException)
|
|
// {
|
|
// SayToUser("Bad packet name: " + words[1]);
|
|
// return;
|
|
// }
|
|
//
|
|
//
|
|
// if (modifiedPackets.ContainsKey(pType))
|
|
// {
|
|
// Dictionary<BlockField, object> fields = modifiedPackets[pType];
|
|
// fields.Remove(new BlockField(words[2], words[3]));
|
|
//
|
|
// if (fields.Count == 0)
|
|
// {
|
|
// modifiedPackets.Remove(pType);
|
|
//
|
|
// proxy.RemoveDelegate(pType, Direction.Incoming, new PacketDelegate(ModifyIn));
|
|
// proxy.RemoveDelegate(pType, Direction.Outgoing, new PacketDelegate(ModifyOut));
|
|
// }
|
|
// }
|
|
//
|
|
// SayToUser("stopped setting " + words[1] + "." + words[2] + "." + words[3]);
|
|
// }
|
|
// else
|
|
// SayToUser("Usage: /-set <packet name> <block> <field>");
|
|
}
|
|
|
|
|
|
// CmdInject: handle an /inject command
|
|
private void CmdInject(string[] words)
|
|
{
|
|
// if (words.Length < 2)
|
|
// SayToUser("Usage: /inject <packet file> [value]");
|
|
// else
|
|
// {
|
|
// string[] valueArray = new string[words.Length - 2];
|
|
// Array.Copy(words, 2, valueArray, 0, words.Length - 2);
|
|
// string value = String.Join(" ", valueArray);
|
|
//
|
|
// FileStream fs = null;
|
|
// StreamReader sr = null;
|
|
// Direction direction = Direction.Incoming;
|
|
// string name = null;
|
|
// string block = null;
|
|
// object blockObj = null;
|
|
// Type packetClass = null;
|
|
// Packet packet = null;
|
|
//
|
|
// try
|
|
// {
|
|
// fs = File.OpenRead(words[1] + ".packet");
|
|
// sr = new StreamReader(fs);
|
|
//
|
|
// string line;
|
|
// while ((line = sr.ReadLine()) != null)
|
|
// {
|
|
// Match match;
|
|
//
|
|
// if (name == null)
|
|
// {
|
|
// match = (new Regex(@"^\s*(in|out)\s+(\w+)\s*$")).Match(line);
|
|
// if (!match.Success)
|
|
// {
|
|
// SayToUser("expecting direction and packet name, got: " + line);
|
|
// return;
|
|
// }
|
|
//
|
|
// string lineDir = match.Groups[1].Captures[0].ToString();
|
|
// string lineName = match.Groups[2].Captures[0].ToString();
|
|
//
|
|
// if (lineDir == "in")
|
|
// direction = Direction.Incoming;
|
|
// else if (lineDir == "out")
|
|
// direction = Direction.Outgoing;
|
|
// else
|
|
// {
|
|
// SayToUser("expecting 'in' or 'out', got: " + line);
|
|
// return;
|
|
// }
|
|
//
|
|
// name = lineName;
|
|
// packetClass = openmvAssembly.GetType("OpenMetaverse.Packets." + name + "Packet");
|
|
// if (packetClass == null) throw new Exception("Couldn't get class " + name + "Packet");
|
|
// ConstructorInfo ctr = packetClass.GetConstructor(new Type[] { });
|
|
// if (ctr == null) throw new Exception("Couldn't get suitable constructor for " + name + "Packet");
|
|
// packet = (Packet)ctr.Invoke(new object[] { });
|
|
// //Console.WriteLine("Created new " + name + "Packet");
|
|
// }
|
|
// else
|
|
// {
|
|
// match = (new Regex(@"^\s*\[(\w+)\]\s*$")).Match(line);
|
|
// if (match.Success)
|
|
// {
|
|
// block = match.Groups[1].Captures[0].ToString();
|
|
// FieldInfo blockField = packetClass.GetField(block);
|
|
// if (blockField == null) throw new Exception("Couldn't get " + name + "Packet." + block);
|
|
// Type blockClass = blockField.FieldType;
|
|
// if (blockClass.IsArray)
|
|
// {
|
|
// blockClass = blockClass.GetElementType();
|
|
// ConstructorInfo ctr = blockClass.GetConstructor(new Type[] { });
|
|
// if (ctr == null) throw new Exception("Couldn't get suitable constructor for " + blockClass.Name);
|
|
// blockObj = ctr.Invoke(new object[] { });
|
|
// object[] arr = (object[])blockField.GetValue(packet);
|
|
// object[] narr = (object[])Array.CreateInstance(blockClass, arr.Length + 1);
|
|
// Array.Copy(arr, narr, arr.Length);
|
|
// narr[arr.Length] = blockObj;
|
|
// blockField.SetValue(packet, narr);
|
|
// //Console.WriteLine("Added block "+block);
|
|
// }
|
|
// else
|
|
// {
|
|
// blockObj = blockField.GetValue(packet);
|
|
// }
|
|
// if (blockObj == null) throw new Exception("Got " + name + "Packet." + block + " == null");
|
|
// //Console.WriteLine("Got block " + name + "Packet." + block);
|
|
//
|
|
// continue;
|
|
// }
|
|
//
|
|
// if (block == null)
|
|
// {
|
|
// SayToUser("expecting block name, got: " + line);
|
|
// return;
|
|
// }
|
|
//
|
|
// match = (new Regex(@"^\s*(\w+)\s*=\s*(.*)$")).Match(line);
|
|
// if (match.Success)
|
|
// {
|
|
// string lineField = match.Groups[1].Captures[0].ToString();
|
|
// string lineValue = match.Groups[2].Captures[0].ToString();
|
|
// object fval;
|
|
//
|
|
// //FIXME: use of MagicCast inefficient
|
|
// if (lineValue == "$Value")
|
|
// fval = MagicCast(name, block, lineField, value);
|
|
// else if (lineValue == "$UUID")
|
|
// fval = UUID.Random();
|
|
// else if (lineValue == "$AgentID")
|
|
// fval = frame.AgentID;
|
|
// else if (lineValue == "$SessionID")
|
|
// fval = frame.SessionID;
|
|
// else
|
|
// fval = MagicCast(name, block, lineField, lineValue);
|
|
//
|
|
// MagicSetField(blockObj, lineField, fval);
|
|
// continue;
|
|
// }
|
|
//
|
|
// SayToUser("expecting block name or field, got: " + line);
|
|
// return;
|
|
// }
|
|
// }
|
|
//
|
|
// if (name == null)
|
|
// {
|
|
// SayToUser("expecting direction and packet name, got EOF");
|
|
// return;
|
|
// }
|
|
//
|
|
// packet.Header.Reliable = true;
|
|
// //if (protocolManager.Command(name).Encoded)
|
|
// // packet.Header.Zerocoded = true;
|
|
// proxy.InjectPacket(packet, direction);
|
|
//
|
|
// SayToUser("injected " + words[1]);
|
|
// }
|
|
// catch (Exception e)
|
|
// {
|
|
// SayToUser("failed to inject " + words[1] + ": " + e.Message);
|
|
// Console.WriteLine("failed to inject " + words[1] + ": " + e.Message + "\n" + e.StackTrace);
|
|
// }
|
|
// finally
|
|
// {
|
|
// if (fs != null)
|
|
// fs.Close();
|
|
// if (sr != null)
|
|
// sr.Close();
|
|
// }
|
|
// }
|
|
}
|
|
|
|
// SayToUser: send a message to the user as in-world chat
|
|
private void SayToUser(string message)
|
|
{
|
|
ChatFromSimulatorPacket packet = new ChatFromSimulatorPacket();
|
|
packet.ChatData.FromName = Utils.StringToBytes("Analyst");
|
|
packet.ChatData.SourceID = UUID.Random();
|
|
packet.ChatData.OwnerID = frame.AgentID;
|
|
packet.ChatData.SourceType = (byte)2;
|
|
packet.ChatData.ChatType = (byte)1;
|
|
packet.ChatData.Audible = (byte)1;
|
|
packet.ChatData.Position = new Vector3(0, 0, 0);
|
|
packet.ChatData.Message = Utils.StringToBytes(message);
|
|
proxy.InjectPacket(packet, Direction.Incoming);
|
|
}
|
|
|
|
// BlockField: product type for a block name and field name
|
|
private struct BlockField
|
|
{
|
|
public string block;
|
|
public string field;
|
|
|
|
|
|
public BlockField(string block, string field)
|
|
{
|
|
this.block = block;
|
|
this.field = field;
|
|
}
|
|
}
|
|
|
|
private static void MagicSetField(object obj, string field, object val)
|
|
{
|
|
Type cls = obj.GetType();
|
|
|
|
FieldInfo fieldInf = cls.GetField(field);
|
|
if (fieldInf == null)
|
|
{
|
|
PropertyInfo prop = cls.GetProperty(field);
|
|
if (prop == null) throw new Exception("Couldn't find field " + cls.Name + "." + field);
|
|
prop.SetValue(obj, val, null);
|
|
//throw new Exception("FIXME: can't set properties");
|
|
}
|
|
else
|
|
{
|
|
fieldInf.SetValue(obj, val);
|
|
}
|
|
}
|
|
|
|
// MagicCast: given a packet/block/field name and a string, convert the string to a value of the appropriate type
|
|
private object MagicCast(string name, string block, string field, string value)
|
|
{
|
|
Type packetClass = openmvAssembly.GetType("OpenMetaverse.Packets." + name + "Packet");
|
|
if (packetClass == null) throw new Exception("Couldn't get class " + name + "Packet");
|
|
|
|
FieldInfo blockField = packetClass.GetField(block);
|
|
if (blockField == null) throw new Exception("Couldn't get " + name + "Packet." + block);
|
|
Type blockClass = blockField.FieldType;
|
|
if (blockClass.IsArray) blockClass = blockClass.GetElementType();
|
|
// Console.WriteLine("DEBUG: " + blockClass.Name);
|
|
|
|
FieldInfo fieldField = blockClass.GetField(field); PropertyInfo fieldProp = null;
|
|
Type fieldClass = null;
|
|
if (fieldField == null)
|
|
{
|
|
fieldProp = blockClass.GetProperty(field);
|
|
if (fieldProp == null) throw new Exception("Couldn't get " + name + "Packet." + block + "." + field);
|
|
fieldClass = fieldProp.PropertyType;
|
|
}
|
|
else
|
|
{
|
|
fieldClass = fieldField.FieldType;
|
|
}
|
|
|
|
try
|
|
{
|
|
if (fieldClass == typeof(byte))
|
|
{
|
|
return Convert.ToByte(value);
|
|
}
|
|
else if (fieldClass == typeof(ushort))
|
|
{
|
|
return Convert.ToUInt16(value);
|
|
}
|
|
else if (fieldClass == typeof(uint))
|
|
{
|
|
return Convert.ToUInt32(value);
|
|
}
|
|
else if (fieldClass == typeof(ulong))
|
|
{
|
|
return Convert.ToUInt64(value);
|
|
}
|
|
else if (fieldClass == typeof(sbyte))
|
|
{
|
|
return Convert.ToSByte(value);
|
|
}
|
|
else if (fieldClass == typeof(short))
|
|
{
|
|
return Convert.ToInt16(value);
|
|
}
|
|
else if (fieldClass == typeof(int))
|
|
{
|
|
return Convert.ToInt32(value);
|
|
}
|
|
else if (fieldClass == typeof(long))
|
|
{
|
|
return Convert.ToInt64(value);
|
|
}
|
|
else if (fieldClass == typeof(float))
|
|
{
|
|
return Convert.ToSingle(value);
|
|
}
|
|
else if (fieldClass == typeof(double))
|
|
{
|
|
return Convert.ToDouble(value);
|
|
}
|
|
else if (fieldClass == typeof(UUID))
|
|
{
|
|
return new UUID(value);
|
|
}
|
|
else if (fieldClass == typeof(bool))
|
|
{
|
|
if (value.ToLower() == "true")
|
|
return true;
|
|
else if (value.ToLower() == "false")
|
|
return false;
|
|
else
|
|
throw new Exception();
|
|
}
|
|
else if (fieldClass == typeof(byte[]))
|
|
{
|
|
return Utils.StringToBytes(value);
|
|
}
|
|
else if (fieldClass == typeof(Vector3))
|
|
{
|
|
Vector3 result;
|
|
if (Vector3.TryParse(value, out result))
|
|
return result;
|
|
else
|
|
throw new Exception();
|
|
}
|
|
else if (fieldClass == typeof(Vector3d))
|
|
{
|
|
Vector3d result;
|
|
if (Vector3d.TryParse(value, out result))
|
|
return result;
|
|
else
|
|
throw new Exception();
|
|
}
|
|
else if (fieldClass == typeof(Vector4))
|
|
{
|
|
Vector4 result;
|
|
if (Vector4.TryParse(value, out result))
|
|
return result;
|
|
else
|
|
throw new Exception();
|
|
}
|
|
else if (fieldClass == typeof(Quaternion))
|
|
{
|
|
Quaternion result;
|
|
if (Quaternion.TryParse(value, out result))
|
|
return result;
|
|
else
|
|
throw new Exception();
|
|
}
|
|
else
|
|
{
|
|
throw new Exception("unsupported field type " + fieldClass);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
throw new Exception("unable to interpret " + value + " as " + fieldClass);
|
|
}
|
|
}
|
|
|
|
// ModifyIn: modify an incoming packet
|
|
private Packet ModifyIn(Packet packet, IPEndPoint endPoint)
|
|
{
|
|
return Modify(packet, endPoint, Direction.Incoming);
|
|
}
|
|
|
|
// ModifyOut: modify an outgoing packet
|
|
private Packet ModifyOut(Packet packet, IPEndPoint endPoint)
|
|
{
|
|
return Modify(packet, endPoint, Direction.Outgoing);
|
|
}
|
|
|
|
// Modify: modify a packet
|
|
private Packet Modify(Packet packet, IPEndPoint endPoint, Direction direction)
|
|
{
|
|
if (modifiedPackets.ContainsKey(packet.Type))
|
|
{
|
|
try
|
|
{
|
|
Dictionary<BlockField, object> changes = modifiedPackets[packet.Type];
|
|
Type packetClass = packet.GetType();
|
|
|
|
foreach (KeyValuePair<BlockField, object> change in changes)
|
|
{
|
|
BlockField bf = change.Key;
|
|
FieldInfo blockField = packetClass.GetField(bf.block);
|
|
if (blockField.FieldType.IsArray) // We're modifying a variable block.
|
|
{
|
|
// Modify each block in the variable block identically.
|
|
// This is really simple, can probably be improved.
|
|
object[] blockArray = (object[])blockField.GetValue(packet);
|
|
foreach (object blockElement in blockArray)
|
|
{
|
|
MagicSetField(blockElement, bf.field, change.Value);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
//Type blockClass = blockField.FieldType;
|
|
object blockObject = blockField.GetValue(packet);
|
|
MagicSetField(blockObject, bf.field, change.Value);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Console.WriteLine("failed to modify " + packet.Type + ": " + e.Message);
|
|
Console.WriteLine(e.StackTrace);
|
|
}
|
|
}
|
|
|
|
return packet;
|
|
}
|
|
|
|
// LogAll: register logging delegates for all packets
|
|
private void LogAll()
|
|
{
|
|
// Type packetTypeType = typeof(PacketType);
|
|
// System.Reflection.MemberInfo[] packetTypes = packetTypeType.GetMembers();
|
|
//
|
|
// for (int i = 0; i < packetTypes.Length; i++)
|
|
// {
|
|
// if (packetTypes[i].MemberType == System.Reflection.MemberTypes.Field && packetTypes[i].DeclaringType == packetTypeType)
|
|
// {
|
|
// string name = packetTypes[i].Name;
|
|
// PacketType pType;
|
|
//
|
|
// try
|
|
// {
|
|
// pType = packetTypeFromName(name);
|
|
// }
|
|
// catch (Exception)
|
|
// {
|
|
// continue;
|
|
// }
|
|
//
|
|
// loggedCaps[pType] = null;
|
|
//
|
|
// proxy.AddDelegate(pType, Direction.Incoming, new PacketDelegate(LogPacketIn));
|
|
// proxy.AddDelegate(pType, Direction.Outgoing, new PacketDelegate(LogPacketOut));
|
|
// }
|
|
// }
|
|
}
|
|
|
|
private void LogWhitelist(string whitelistFile)
|
|
{
|
|
// try
|
|
// {
|
|
// string[] lines = File.ReadAllLines(whitelistFile);
|
|
// int count = 0;
|
|
//
|
|
// for (int i = 0; i < lines.Length; i++)
|
|
// {
|
|
// string line = lines[i].Trim();
|
|
// if (line.Length == 0)
|
|
// continue;
|
|
//
|
|
// PacketType pType;
|
|
//
|
|
// try
|
|
// {
|
|
// pType = packetTypeFromName(line);
|
|
// proxy.AddDelegate(pType, Direction.Incoming, new PacketDelegate(LogPacketIn));
|
|
// proxy.AddDelegate(pType, Direction.Outgoing, new PacketDelegate(LogPacketOut));
|
|
// ++count;
|
|
// }
|
|
// catch (ArgumentException)
|
|
// {
|
|
// Console.WriteLine("Bad packet name: " + line);
|
|
// }
|
|
// }
|
|
//
|
|
// Console.WriteLine(String.Format("Logging {0} packet types loaded from whitelist", count));
|
|
// }
|
|
// catch (Exception)
|
|
// {
|
|
// Console.WriteLine("Failed to load packet whitelist from " + whitelistFile);
|
|
// }
|
|
}
|
|
|
|
private void NoLogBlacklist(string blacklistFile)
|
|
{
|
|
// try
|
|
// {
|
|
// string[] lines = File.ReadAllLines(blacklistFile);
|
|
// int count = 0;
|
|
//
|
|
// for (int i = 0; i < lines.Length; i++)
|
|
// {
|
|
// string line = lines[i].Trim();
|
|
// if (line.Length == 0)
|
|
// continue;
|
|
//
|
|
// PacketType pType;
|
|
//
|
|
// try
|
|
// {
|
|
// pType = packetTypeFromName(line);
|
|
// string[] noLogStr = new string[] {"/-log", line};
|
|
// CmdNoLog(noLogStr);
|
|
// ++count;
|
|
// }
|
|
// catch (ArgumentException)
|
|
// {
|
|
// Console.WriteLine("Bad packet name: " + line);
|
|
// }
|
|
// }
|
|
//
|
|
// Console.WriteLine(String.Format("Not logging {0} packet types loaded from blacklist", count));
|
|
// }
|
|
// catch (Exception)
|
|
// {
|
|
// Console.WriteLine("Failed to load packet blacklist from " + blacklistFile);
|
|
// }
|
|
}
|
|
|
|
private void SetOutput(string outputFile)
|
|
{
|
|
try
|
|
{
|
|
output = new StreamWriter(outputFile, false);
|
|
Console.WriteLine("Logging packets to " + outputFile);
|
|
}
|
|
catch (Exception)
|
|
{
|
|
Console.WriteLine(String.Format("Failed to open {0} for logging", outputFile));
|
|
}
|
|
}
|
|
|
|
// NoLogAll: unregister logging delegates for all packets
|
|
private void NoLogAll()
|
|
{
|
|
// Type packetTypeType = typeof(PacketType);
|
|
// System.Reflection.MemberInfo[] packetTypes = packetTypeType.GetMembers();
|
|
//
|
|
// for (int i = 0; i < packetTypes.Length; i++)
|
|
// {
|
|
// if (packetTypes[i].MemberType == System.Reflection.MemberTypes.Field && packetTypes[i].DeclaringType == packetTypeType)
|
|
// {
|
|
// string name = packetTypes[i].Name;
|
|
// PacketType pType;
|
|
//
|
|
// try
|
|
// {
|
|
// pType = packetTypeFromName(name);
|
|
// }
|
|
// catch (Exception)
|
|
// {
|
|
// continue;
|
|
// }
|
|
//
|
|
// loggedCaps.Remove(pType);
|
|
//
|
|
// proxy.RemoveDelegate(pType, Direction.Incoming, new PacketDelegate(LogPacketIn));
|
|
// proxy.RemoveDelegate(pType, Direction.Outgoing, new PacketDelegate(LogPacketOut));
|
|
// }
|
|
// }
|
|
}
|
|
|
|
private bool LogCap(CapsRequest req, CapsStage stage)
|
|
{
|
|
if (stage == CapsStage.Request)
|
|
return false;
|
|
|
|
using (StringWriter sw = new StringWriter())
|
|
{
|
|
using (XmlTextWriter xtw = new XmlTextWriter(sw))
|
|
{
|
|
xtw.Formatting = Formatting.Indented;
|
|
OSDParser.SerializeLLSDXmlElement(xtw, req.Request);
|
|
}
|
|
|
|
Console.WriteLine("REQUEST {0}", req.Info.CapType);
|
|
Console.WriteLine(sw.ToString());
|
|
}
|
|
|
|
using (StringWriter sw = new StringWriter())
|
|
{
|
|
using (XmlTextWriter xtw = new XmlTextWriter(sw))
|
|
{
|
|
xtw.Formatting = Formatting.Indented;
|
|
OSDParser.SerializeLLSDXmlElement(xtw, req.Response);
|
|
}
|
|
|
|
Console.WriteLine("RESPONSE {0}", req.Info.CapType);
|
|
Console.WriteLine(sw.ToString());
|
|
}
|
|
|
|
Console.WriteLine("------------------------------");
|
|
|
|
// We don't want to stop any other delegates from executing.
|
|
return false;
|
|
}
|
|
|
|
// InterpretOptions: produce a string representing a packet's header options
|
|
private static string InterpretOptions(Header header)
|
|
{
|
|
return "["
|
|
+ (header.AppendedAcks ? "Ack" : " ")
|
|
+ " "
|
|
+ (header.Resent ? "Res" : " ")
|
|
+ " "
|
|
+ (header.Reliable ? "Rel" : " ")
|
|
+ " "
|
|
+ (header.Zerocoded ? "Zer" : " ")
|
|
+ "]"
|
|
;
|
|
}
|
|
} |