corrade-vassal – Rev 1
?pathlinks?
using System;
using Gtk;
using GridProxyGUI;
using OpenMetaverse.StructuredData;
using OpenMetaverse.Packets;
using System.IO;
using System.IO.Compression;
using System.Text;
using System.Net;
using System.Collections.Generic;
using System.Collections.Concurrent;
namespace GridProxyGUI
{
public enum ItemType : int
{
Unknown = 0,
Login,
UDP,
Cap,
EQ
}
public class FilterItem
{
public delegate void FilterItemChangedDelegate(object sender, EventArgs e);
public event FilterItemChangedDelegate FilterItemChanged;
bool enabled;
public bool Enabled
{
get { return enabled; }
set
{
enabled = value;
if (FilterItemChanged != null)
{
FilterItemChanged(this, EventArgs.Empty);
}
}
}
public string Name;
public ItemType Type;
public OSDMap ToOSD()
{
OSDMap ret = new OSDMap();
ret["name"] = Name;
ret["type"] = (int)Type;
ret["enabled"] = enabled;
return ret;
}
public static FilterItem FromOSD(OSDMap map)
{
var ret = new FilterItem();
ret.Name = map["name"];
ret.enabled = map["enabled"];
ret.Type = (ItemType)map["type"].AsInteger();
return ret;
}
}
}
public partial class MainWindow
{
string SessionFileName;
List<string> LoginServers = new List<string>();
ConcurrentDictionary<string, FilterItem> UDPFilterItems = new ConcurrentDictionary<string, FilterItem>();
ConcurrentDictionary<string, FilterItem> CapFilterItems = new ConcurrentDictionary<string, FilterItem>();
ListStore udpStore = new ListStore(typeof(FilterItem));
ListStore capStore = new ListStore(typeof(FilterItem));
FilterScroller udpScroller, capScroller;
void LoadFromOSD(ConcurrentDictionary<string, FilterItem> items, OSDArray filters)
{
try
{
foreach (var filter in filters)
{
if (filter is OSDMap)
{
var item = FilterItem.FromOSD((OSDMap)filter);
items[item.Name] = item;
}
}
}
catch { }
}
void InitUDPFilters(OSDArray filters)
{
UDPFilterItems.Clear();
udpStore.Clear();
if (filters != null)
{
LoadFromOSD(UDPFilterItems, filters);
}
if (!UDPFilterItems.ContainsKey("Login Request"))
{
UDPFilterItems["Login Request"] = new FilterItem() { Enabled = true, Name = "Login Request", Type = ItemType.Login };
}
if (!UDPFilterItems.ContainsKey("Login Response"))
{
UDPFilterItems["Login Response"] = new FilterItem() { Enabled = true, Name = "Login Response", Type = ItemType.Login };
}
foreach (string name in Enum.GetNames(typeof(PacketType)))
{
if (!string.IsNullOrEmpty(name) && !UDPFilterItems.ContainsKey(name))
{
var item = new FilterItem() { Enabled = false, Name = name, Type = ItemType.UDP };
UDPFilterItems[name] = item;
}
}
List<string> keys = new List<string>(UDPFilterItems.Keys);
keys.Sort((a, b) => { return string.Compare(a.ToLower(), b.ToLower()); });
udpStore.AppendValues(UDPFilterItems["Login Request"]);
udpStore.AppendValues(UDPFilterItems["Login Response"]);
foreach (var key in keys)
{
UDPFilterItems[key].FilterItemChanged += item_FilterItemChanged;
if (UDPFilterItems[key].Type == ItemType.Login) continue;
udpStore.AppendValues(UDPFilterItems[key]);
}
}
void InitCapFilters(OSDArray filters)
{
CapFilterItems.Clear();
capStore.Clear();
if (filters != null)
{
LoadFromOSD(CapFilterItems, filters);
}
List<string> keys = new List<string>(CapFilterItems.Keys);
keys.Sort((a, b) =>
{
if (CapFilterItems[a].Type == ItemType.Cap && CapFilterItems[b].Type == ItemType.EQ)
return -1;
if (CapFilterItems[a].Type == ItemType.EQ && CapFilterItems[b].Type == ItemType.Cap)
return 1;
return string.Compare(a.ToLower(), b.ToLower());
});
foreach (var key in keys)
{
CapFilterItems[key].FilterItemChanged += item_FilterItemChanged;
capStore.AppendValues(CapFilterItems[key]);
}
}
void InitProxyFilters()
{
capScroller = new FilterScroller(containerFilterCap, capStore);
udpScroller = new FilterScroller(containerFilterUDP, udpStore);
OSDArray filters = null;
if (Options.Instance.ContainsKey("udp_filters") && Options.Instance["udp_filters"] is OSDArray)
{
filters = (OSDArray)Options.Instance["udp_filters"];
}
InitUDPFilters(filters);
filters = null;
if (Options.Instance.ContainsKey("cap_filters") && Options.Instance["cap_filters"] is OSDArray)
{
filters = (OSDArray)Options.Instance["cap_filters"];
}
InitCapFilters(filters);
}
void item_FilterItemChanged(object sender, EventArgs e)
{
if (proxy == null) return;
FilterItem item = (FilterItem)sender;
if (item.Type == ItemType.Cap)
{
proxy.AddCapsDelegate(item.Name, item.Enabled);
}
else if (item.Type == ItemType.UDP)
{
proxy.AddUDPDelegate(item.Name, item.Enabled);
}
}
void ApplyProxyFilters()
{
foreach (var item in UDPFilterItems.Values)
{
item_FilterItemChanged(item, EventArgs.Empty);
}
foreach (var item in CapFilterItems.Values)
{
item_FilterItemChanged(item, EventArgs.Empty);
}
}
void LoadSavedSettings()
{
if (Options.Instance.ContainsKey("main_split_pos"))
{
mainSplit.Position = Options.Instance["main_split_pos"];
mainSplit.PositionSet = true;
}
if (Options.Instance.ContainsKey("main_width"))
{
Resize(Options.Instance["main_width"], Options.Instance["main_height"]);
Move(Options.Instance["main_x"], Options.Instance["main_y"]);
}
// populate the listen box with the known IP Addresses of this host
cbListen.AppendText("127.0.0.1");
int selected = 0;
try
{
int current = 0;
foreach (var address in Dns.GetHostAddresses(Dns.GetHostName()))
{
if (address.AddressFamily != System.Net.Sockets.AddressFamily.InterNetwork || address.ToString() == "127.0.0.1") continue;
current++;
if (Options.Instance["listen_address"] == address.ToString())
{
selected = current;
}
cbListen.AppendText(address.ToString());
}
}
catch { }
cbListen.Active = selected;
if (Options.Instance["login_servers"] is OSDArray)
{
var servers = (OSDArray)Options.Instance["login_servers"];
for (int i = 0; i < servers.Count; i++)
{
LoginServers.Add(servers[i]);
}
}
if (LoginServers.Count < 3)
{
LoginServers.Add("https://login.agni.lindenlab.com/cgi-bin/login.cgi");
LoginServers.Add("https://login.aditi.lindenlab.com/cgi-bin/login.cgi");
LoginServers.Add("http://login.osgrid.org/");
}
foreach (var server in LoginServers)
{
cbLoginURL.AppendText(server);
}
selected = Options.Instance["selected_login_server"];
if (selected >= 0 && selected < LoginServers.Count)
{
cbLoginURL.Active = selected;
}
int port = 8080;
if (Options.Instance.ContainsKey("listen_port"))
{
port = Options.Instance["listen_port"];
}
txtPort.Text = port.ToString();
}
internal FilterItem GetFilter(Session session)
{
if (session is SessionCaps || session is SessionEvent)
{
foreach (var filter in CapFilterItems.Values)
{
if (filter.Name == session.Name)
{
return filter;
}
}
}
else
{
foreach (var filter in UDPFilterItems.Values)
{
if (filter.Name == session.Name)
{
return filter;
}
}
}
return null;
}
OSDArray ListStoreToOSD(ListStore list)
{
OSDArray ret = new OSDArray();
list.Foreach((model, path, iter) =>
{
var item = model.GetValue(iter, 0) as FilterItem;
if (null != item)
{
ret.Add(item.ToOSD());
}
return false;
});
return ret;
}
void SaveSettings()
{
Options.Instance["udp_filters"] = ListStoreToOSD(udpStore);
Options.Instance["cap_filters"] = ListStoreToOSD(capStore);
int port = 8080;
int.TryParse(txtPort.Text, out port);
Options.Instance["listen_port"] = port;
var currentServer = cbLoginURL.ActiveText.Trim();
Uri uriResult;
if (Uri.TryCreate(currentServer, UriKind.Absolute, out uriResult)
&& (uriResult.Scheme == Uri.UriSchemeHttp || uriResult.Scheme == Uri.UriSchemeHttps)
&& !LoginServers.Contains(currentServer))
{
LoginServers.Add(currentServer);
Options.Instance["selected_login_server"] = LoginServers.Count - 1;
}
else
{
Options.Instance["selected_login_server"] = cbLoginURL.Active;
}
if (LoginServers.Count > 0)
{
OSDArray loginServers = new OSDArray();
foreach (var s in LoginServers)
{
loginServers.Add(s);
}
Options.Instance["login_servers"] = loginServers;
}
Options.Instance["listen_address"] = cbListen.ActiveText;
Options.Instance["main_split_pos"] = mainSplit.Position;
int x, y;
GetSize(out x, out y); ;
Options.Instance["main_width"] = x;
Options.Instance["main_height"] = y;
GetPosition(out x, out y);
Options.Instance["main_x"] = x;
Options.Instance["main_y"] = y;
Options.Instance.Save();
Application.Quit();
}
void SaveSession()
{
OSDMap s = new OSDMap();
OSDArray array = new OSDArray();
foreach (object[] row in messages.Messages)
{
array.Add(((Session)row[0]).Serialize());
}
s["Version"] = "1.0";
s["Description"] = "Grid Proxy Session Archive";
s["Messages"] = array;
System.Threading.ThreadPool.QueueUserWorkItem((sync) =>
{
try
{
using (var file = File.Open(SessionFileName, FileMode.Create))
{
using (var compressed = new GZipStream(file, CompressionMode.Compress))
{
using (var writer = new System.Xml.XmlTextWriter(compressed, new UTF8Encoding(false)))
{
writer.Formatting = System.Xml.Formatting.Indented;
writer.WriteStartDocument();
writer.WriteStartElement(String.Empty, "llsd", String.Empty);
OSDParser.SerializeLLSDXmlElement(writer, s);
writer.WriteEndElement();
}
}
}
}
catch { }
});
}
void OpenSession(string fileName)
{
System.Threading.ThreadPool.QueueUserWorkItem((sync) =>
{
OSD data;
try
{
using (var file = File.OpenRead(fileName))
{
using (var compressed = new GZipStream(file, CompressionMode.Decompress))
{
data = OSDParser.DeserializeLLSDXml(compressed);
}
}
}
catch
{
return;
}
Application.Invoke((sender, e) =>
{
try
{
if (data != null && data is OSDMap)
{
messages.Messages.Clear();
OSDMap map = (OSDMap)data;
OSDArray msgs = (OSDArray)map["Messages"];
foreach (var msgOSD in msgs)
{
var msg = (OSDMap)msgOSD;
var session = Session.FromOSD(msg);
if (session != null)
{
messages.Messages.AppendValues(session);
}
}
SessionFileName = fileName;
}
}
catch { }
});
});
}
}