public HttpProxyHandler(ITunnel tunnel, IMessageWriter messageWriter)
{
_clients = new Hashtable();
_tunnel = tunnel;
_messageWriter = messageWriter;
_tunnel.DataReceived += new EventHandler <DataReceivedEventArgs>(Tunnel_DataReceived);
}
public void Setup()
{
tunnel = Substitute.For <ITunnel>();
RabbitTunnel.Factory = Substitute.For <TunnelFactory>();
RabbitTunnel.Factory.Create(Arg.Any <string>()).Returns(tunnel);
Global.DefaultWatcher = Substitute.For <IRabbitWatcher>();
}
public static bool FindAndExecute(string[] args, ILogger logger, ITunnel tunnel, int sid)
{
if (args.Length <= 0)
{
return(false);
}
var sw = args[0];
var parameters = new string[args.Length - 1];
Array.ConstrainedCopy(args, 1, parameters, 0, parameters.Length);
foreach (var cmd in GetCommands())
{
if ((sw != cmd.Switch) || (parameters.Length != cmd.ParametersName.Length))
{
continue;
}
cmd.Execute(parameters, logger, tunnel, sid);
return(true);
}
return(false);
}
public void Setup()
{
tunnel = Substitute.For <ITunnel>();
RabbitTunnel.Factory = Substitute.For <TunnelFactory>();
RabbitTunnel.Factory.Create(Arg.Any <string>()).Returns(tunnel);
InternalDependencies.RpcQueueHelper = Substitute.For <IRpcQueueHelper>();
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Constructeur
/// </summary>
/// <param name="tunnel">le tunnel</param>
/// <param name="sid">le jeton de session</param>
/// -----------------------------------------------------------------------------
public AdminForm (ITunnel tunnel, int sid)
{
InitializeComponent();
_tunnel = tunnel;
_sid = sid;
_sidhex = _sid.ToString("x");
}
private void InitializeForwards(ITunnel tunnel, int sid)
{
foreach (var forward in ClientConfig.Forwards.Values)
{
if (!forward.Enabled)
{
continue;
}
var remotePort = forward.RemotePort;
var localPort = forward.LocalPort;
var shared = forward.Shared;
var address = forward.Address;
if (_servers.ContainsKey(localPort))
{
Log(string.Format(Strings.FORWARD_CANCELED, localPort, address, remotePort), ESeverity.WARN);
}
else
{
var server = new GatewayServer(localPort, shared, remotePort, address, tunnel, sid);
_servers.Add(localPort, server);
}
}
}
private void Init()
{
_tunnel = RabbitTunnel.Factory.Create(_rabbitMqConnectionString);
_tunnel.SetRouteFinder(new RpcRouteFinderAdapter(_routeFinder));
_tunnel.SetSerializer(Global.DefaultSerializer);
if (_routeFinder.CreateExchangeAndQueue)
{
var routingKey = _routeFinder.RequestQueue;
var requestQueueName = _routeFinder.RequestQueue;
var requestExchange = _routeFinder.RequestExchangeName;
Action <IModel> createRequestQueues = channel =>
{
var arguments = new Dictionary <string, object>();
var autoDeleteLoadBalanceRequestQueue = !string.IsNullOrEmpty(_serverId) && !string.IsNullOrEmpty(requestExchange);
channel.QueueDeclare(requestQueueName, true, false, autoDeleteLoadBalanceRequestQueue, arguments);
if (!string.IsNullOrEmpty(requestExchange))
{
channel.ExchangeDeclare(requestExchange, _routeFinder.RequestExchangeType, true, false, null);
channel.QueueBind(requestQueueName, requestExchange, routingKey);
}
};
InternalDependencies.RpcQueueHelper.CreateQueues(_rabbitMqConnectionString, createRequestQueues);
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Lance la commande
/// </summary>
/// <param name="parameters">les parametres</param>
/// <param name="logger">le logger</param>
/// <param name="tunnel">le tunnel</param>
/// <param name="sid">le jeton de session</param>
/// -----------------------------------------------------------------------------
public override void Execute(string[] parameters, ILogger logger, ITunnel tunnel, int sid)
{
foreach (var cmd in GetCommands())
{
logger.Log(this, String.Format("{0}: {1}", cmd.Help, cmd.Switch + " " + string.Join(" ", cmd.ParametersName)), ESeverity.INFO);
}
}
public void Setup()
{
tunnel = Substitute.For<ITunnel>();
RabbitTunnel.Factory = Substitute.For<TunnelFactory>();
RabbitTunnel.Factory.Create(Arg.Any<string>()).Returns(tunnel);
Global.DefaultWatcher = Substitute.For<IRabbitWatcher>();
}
public void StartTunnel(ITunnel tunnel, string localIPAddress, int localPort)
{
UInt16 connectionNum = 1;
IPAddress localAddr = IPAddress.Parse(localIPAddress);
_tunnel = tunnel;
_tunnel.DataReceived += Tunnel_DataReceived;
//open server socket
TcpListener tcpListener = new TcpListener(localAddr, localPort);
tcpListener.Start();
_messageWriter.WriteLine("Starting Tunnel Client");
//Start Polling Thread
Thread bgThread = new Thread(new ThreadStart(PollingLoop));
bgThread.IsBackground = true;
bgThread.Name = "PollingThread";
bgThread.Start();
while (true)
{
//Wait for new connection
TcpClient tcpClient = tcpListener.AcceptTcpClient();
SocketClient sclient = new SocketClient(tunnel, tcpClient, _messageWriter, connectionNum++);
bgThread = new Thread(new ThreadStart(sclient.HandleMessages));
bgThread.IsBackground = true;
bgThread.Name = "SocketClientThread";
bgThread.Start();
}
}
public void Setup()
{
tunnel = Substitute.For<ITunnel>();
RabbitTunnel.Factory = Substitute.For<TunnelFactory>();
RabbitTunnel.Factory.Create(Arg.Any<string>()).Returns(tunnel);
InternalDependencies.RpcQueueHelper = Substitute.For<IRpcQueueHelper>();
}
void ITunnelCallback.TunnelClosed(ITunnel tunnel)
{
if (!tunnelClosed)
{
lock (this)
{
if (tunnelClosed)
{
return;
}
tunnelClosed = true;
}
try
{
if (socketA.Connected)
{
try
{
messageLogger.LogAToB("socketA.Shutdown");
socketA.Shutdown(SocketShutdown.Both);
}
catch (SocketException se) { messageLogger.Log("SocketException in socketA.Shutdown: {0}", se.Message); }
}
catch (ObjectDisposedException ode) { messageLogger.Log("ObjectDisposedException in socketA.Shutdown: {0}", ode.Message); }
if (socketB.Connected)
{
try
{
messageLogger.LogBToA("socketB.Shutdown");
socketB.Shutdown(SocketShutdown.Both);
}
catch (SocketException se) { messageLogger.Log("SocketException in socketB.Shutdown: {0}", se.Message); }
}
public SocksServer(int port, bool shared, ITunnel tunnel, int sid) : base(port, shared)
{
Log(string.Format(Strings.SOCKS_SERVER_STARTED, Ip, port), ESeverity.INFO);
_tunnel = tunnel;
_sid = sid;
}
public AdminForm(ITunnel tunnel, int sid)
{
InitializeComponent();
_tunnel = tunnel;
_sid = sid;
_sidhex = _sid.ToString("x");
}
public ClientInstance(ITunnel tunnel, string ca_path, string cert_path, string sign_path)
{
Tunnel = tunnel;
CertificatePath = cert_path;
CertificateAuthorityPath = ca_path;
SignaturePath = sign_path;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Constructeur
/// </summary>
/// <param name="port">port local côté client</param>
/// <param name="shared">bind sur toutes les ip/ip locale</param>
/// <param name="tunnel">tunnel de communication</param>
/// <param name="sid">session-id</param>
/// -----------------------------------------------------------------------------
public SocksServer(int port, bool shared, ITunnel tunnel, int sid)
: base(port, shared)
{
Log(string.Format(Strings.SOCKS_SERVER_STARTED, Ip, port), ESeverity.INFO);
_tunnel = tunnel;
_sid = sid;
}
public static ITunnelWithPrioritySupport WithPrioritySupport(this ITunnel tunnel)
{
if (!(tunnel is ITunnelWithPrioritySupport))
{
throw new InvalidCastException("Current tunnel object is not supporting priority queues");
}
return(tunnel as ITunnelWithPrioritySupport);
}
public SocketClient(ITunnel Tunnel, TcpClient tcpclient, IMessageWriter messageWriter, UInt16 socketId)
{
_client = tcpclient;
_tunnel = Tunnel;
_messageWriter = messageWriter;
_socketId = socketId;
//Register DataReceived handler with the tunnel
Tunnel.DataReceived += new EventHandler <DataReceivedEventArgs>(Tunnel_DataReceived);
}
public GatewayServer(int localport, bool shared, int remoteport, string address, ITunnel tunnel, int sid) : base(localport, shared)
{
Log(string.Format(Strings.FORWARDING, Ip, localport, address, remoteport), ESeverity.INFO);
_tunnel = tunnel;
_sid = sid;
_address = address;
_remoteport = remoteport;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Constructeur
/// </summary>
/// <param name="localport">port local côté client</param>
/// <param name="shared">bind sur toutes les ip/ip locale</param>
/// <param name="remoteport">port distant côté serveur</param>
/// <param name="address">adresse côté serveur</param>
/// <param name="tunnel">tunnel de communication</param>
/// <param name="sid">session-id</param>
/// -----------------------------------------------------------------------------
public GatewayServer(int localport, bool shared, int remoteport, string address, ITunnel tunnel, int sid)
: base(localport, shared)
{
Log(string.Format(Strings.FORWARDING, Ip, localport, address, remoteport), ESeverity.INFO);
_tunnel = tunnel;
_sid = sid;
_address = address;
_remoteport = remoteport;
}
public void Setup()
{
tunnel = Substitute.For <ITunnel>();
methodMatcher = Substitute.For <IMethodMatcher>();
RabbitTunnel.Factory = Substitute.For <TunnelFactory>();
RabbitTunnel.Factory.Create(Arg.Any <string>()).Returns(tunnel);
Global.DefaultWatcher = Substitute.For <IRabbitWatcher>();
InternalDependencies.RpcQueueHelper = Substitute.For <IRpcQueueHelper>();
InternalDependencies.MethodMatcher = methodMatcher;
}
public ITunnel Get(string id)
{
ITunnel tunnel = null;
if (_tables.TryGetValue(id, out tunnel))
{
return(tunnel);
}
return(null);
}
public void Setup()
{
tunnel = Substitute.For<ITunnel>();
methodMatcher = Substitute.For<IMethodMatcher>();
RabbitTunnel.Factory = Substitute.For<TunnelFactory>();
RabbitTunnel.Factory.Create(Arg.Any<string>()).Returns(tunnel);
Global.DefaultWatcher = Substitute.For<IRabbitWatcher>();
InternalDependencies.RpcQueueHelper = Substitute.For<IRpcQueueHelper>();
InternalDependencies.MethodMatcher = methodMatcher;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Constructeur
/// </summary>
/// <param name="client">le socket client pour la communication locale</param>
/// <param name="tunnel">le tunnel pour la communication distante</param>
/// <param name="sid">le session-id</param>
/// <param name="address">l'adresse distante de connexion</param>
/// <param name="port">le port distant de connexion</param>
/// -----------------------------------------------------------------------------
public Gateway(TcpClient client, ITunnel tunnel, int sid, string address, int port)
{
_client = client;
_tunnel = tunnel;
_sid = sid;
_stream = client.GetStream();
_address = address;
_port = port;
var thr = new Thread(CommunicationThread) {IsBackground = true};
thr.Start();
}
public BurrowRpcClientCoordinator(string rabbitMqConnectionString = null, IRpcRouteFinder routeFinder = null)
{
_rabbitMqConnectionString = InternalDependencies.RpcQueueHelper.TryGetValidConnectionString(rabbitMqConnectionString);
_routeFinder = routeFinder ?? new DefaultRpcRouteFinder <T>();
_tunnel = RabbitTunnel.Factory.Create(_rabbitMqConnectionString);
_tunnel.SetRouteFinder(new RpcRouteFinderAdapter(_routeFinder));
_tunnel.SetSerializer(Global.DefaultSerializer);
var subscriptionName = typeof(T).Name;
Init(subscriptionName);
}
public override void Execute(string[] parameters, ILogger logger, ITunnel tunnel, int sid)
{
int targetsid;
if (int.TryParse(parameters[0], System.Globalization.NumberStyles.HexNumber, null, out targetsid))
{
var response = tunnel.KillSession(new KillSessionRequest(targetsid, sid));
logger.Log(this, response.Message, response.Success ? ESeverity.INFO : ESeverity.ERROR);
}
else
{
logger.Log(this, Strings.CHECK_PARAMETERS, ESeverity.ERROR);
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Lance la commande
/// </summary>
/// <param name="parameters">les parametres</param>
/// <param name="logger">le logger</param>
/// <param name="tunnel">le tunnel</param>
/// <param name="sid">le jeton de session</param>
/// -----------------------------------------------------------------------------
public override void Execute(string[] parameters, ILogger logger, ITunnel tunnel, int sid)
{
MonitorResponse response = tunnel.Monitor(new SessionContextRequest(sid));
if (response.Success)
{
LogObject(logger, 0, response.Sessions);
logger.Log(this, string.Format(Strings.CURRENT_SID, sid.ToString("x")), ESeverity.INFO);
}
else
{
logger.Log(this, response.Message, ESeverity.ERROR);
}
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Lance la commande
/// </summary>
/// <param name="parameters">les parametres</param>
/// <param name="logger">le logger</param>
/// <param name="tunnel">le tunnel</param>
/// <param name="sid">le jeton de session</param>
/// -----------------------------------------------------------------------------
public override void Execute(string[] parameters, ILogger logger, ITunnel tunnel, int sid)
{
int targetsid;
if (int.TryParse(parameters[0], System.Globalization.NumberStyles.HexNumber, null, out targetsid))
{
var response = tunnel.KillSession(new KillSessionRequest(targetsid, sid));
logger.Log(this, response.Message, response.Success ? ESeverity.INFO : ESeverity.ERROR);
}
else
{
logger.Log(this, Strings.CHECK_PARAMETERS, ESeverity.ERROR);
}
}
public Gateway(TcpClient client, ITunnel tunnel, int sid, string address, int port)
{
_client = client;
_tunnel = tunnel;
_sid = sid;
_stream = client.GetStream();
_address = address;
_port = port;
var thr = new Thread(CommunicationThread)
{
IsBackground = true
};
thr.Start();
}
private void InitializeSocks(ITunnel tunnel, int sid)
{
if (!ClientConfig.SocksEnabled)
{
return;
}
var port = ClientConfig.SocksPort;
if (_servers.ContainsKey(port))
{
Log(string.Format(Strings.SOCKS_SERVER_DISABLED, port), ESeverity.WARN);
}
else
{
var socks = new SocksServer(port, ClientConfig.SocksShared, tunnel, sid);
_servers.Add(port, socks);
}
}
public void xg(int indnt, StreamWriter writer, ITunnel node, string msg)
{
indent(indnt, writer);
if (msg != "")
{
writer.WriteLine(msg);
}
writer.Write("<ITunnel NodeId=\"" + node.UniqueId + "\" ParentId=\"" + node.ParentNode.UniqueId + "\">\n");
indent(indnt + 1, writer);
writer.Write("<IsInput>" + node.IsInput() + "</IsInput>\n");
indent(indnt + 1, writer);
writer.Write("<GetInnerTerminal TerminalId=\"" + node.GetInnerTerminal().UniqueId + "\"/>\n");
indent(indnt + 1, writer);
writer.Write("<GetOuterTerminal TerminalId=\"" + node.GetOuterTerminal().UniqueId + "\"/>\n");
indent(indnt + 1, writer);
writer.Write("<IndexingMode>" + node.IndexingMode + "</IndexingMode>\n");
PrintTerminals(indnt + 1, writer, node.Terminals);
indent(indnt, writer);
writer.Write("</ITunnel>\n");
}
public void StartTunnel(ITunnel tunnel)
{
//for testing purposes
//todo: replace with actual implementation
try
{
_messageWriter.WriteLine("Server Running...\nPress Enter to Quit.");
//Tunnel.DataReceived += new EventHandler<DataReceivedEventArgs>(Tunnel_DataReceived);
HttpProxyHandler handler = new HttpProxyHandler(tunnel, _messageWriter);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message + "\n" + ex.StackTrace);
}
//Console.ReadLine();
}
public void Manage(ITunnel tunnel)
{
Tunnels.Add(tunnel);
_tables.Add(tunnel.Id, tunnel);
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Trouve puis execute une commande
/// </summary>
/// <param name="args">l'ensemble des arguments</param>
/// <param name="logger">le logger</param>
/// <param name="tunnel">le tunnel</param>
/// <param name="sid">le jeton de session</param>
/// <returns>true si la commande a été trouvée</returns>
/// -----------------------------------------------------------------------------
public static bool FindAndExecute(string[] args, ILogger logger, ITunnel tunnel, int sid)
{
if (args.Length > 0)
{
var sw = args[0];
var parameters = new string[args.Length - 1];
Array.ConstrainedCopy(args, 1, parameters, 0, parameters.Length);
foreach (var cmd in GetCommands())
{
if ((sw != cmd.Switch) || (parameters.Length != cmd.ParametersName.Length))
continue;
cmd.Execute(parameters, logger, tunnel, sid);
return true;
}
}
return false;
}
/// ----------------------------------------------------------------------------- /// <summary> /// Lance la commande /// </summary> /// <param name="parameters">les parametres</param> /// <param name="logger">le logger</param> /// <param name="tunnel">le tunnel</param> /// <param name="sid">le jeton de session</param> /// ----------------------------------------------------------------------------- public abstract void Execute(string[] parameters, ILogger logger, ITunnel tunnel, int sid);
public EncryptedLink(ITunnel tunnel)
{
Tunnel = tunnel;
}
public TamirSession(ITunnel tunnel, int remotePort)
{
this.tunnel = tunnel;
this.remotePort = remotePort;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Lance la commande
/// </summary>
/// <param name="parameters">les parametres</param>
/// <param name="logger">le logger</param>
/// <param name="tunnel">le tunnel</param>
/// <param name="sid">le jeton de session</param>
/// -----------------------------------------------------------------------------
public override void Execute(string[] parameters, ILogger logger, ITunnel tunnel, int sid)
{
foreach (var cmd in GetCommands())
logger.Log(this, String.Format("{0}: {1}", cmd.Help, cmd.Switch + " " + string.Join(" ", cmd.ParametersName)), ESeverity.INFO);
}
public TunnelDataEncrypter(ITunnel tunnel, string keypass)
{
_tunnel = tunnel;
_tunnel.DataReceived += new EventHandler <DataReceivedEventArgs>(Decrypt_DataReceived);
_myPass = keypass;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Mise en place du serveur Socks
/// </summary>
/// <param name="tunnel">le tunnel crée avec le serveur</param>
/// <param name="sid">le session id courant</param>
/// -----------------------------------------------------------------------------
private void InitializeSocks(ITunnel tunnel, int sid)
{
if (!ClientConfig.SocksEnabled)
return;
var port = ClientConfig.SocksPort;
if (_servers.ContainsKey(port))
{
Log(string.Format(Strings.SOCKS_SERVER_DISABLED, port), ESeverity.WARN);
}
else
{
var socks = new SocksServer(port, ClientConfig.SocksShared, tunnel, sid);
_servers.Add(port, socks);
}
}
private void SetTunnel(ITunnel tunnel)
{
_tunnel = tunnel;
Position = TunnelVector3.Zero;
}
/// -----------------------------------------------------------------------------
/// <summary>
/// Mise en place des ports à l'écoute pour les forwards via le tunnel
/// </summary>
/// <param name="tunnel">le tunnel crée avec le serveur</param>
/// <param name="sid">le session id courant</param>
/// -----------------------------------------------------------------------------
private void InitializeForwards(ITunnel tunnel, int sid)
{
foreach (var forward in ClientConfig.Forwards.Values)
{
if (!forward.Enabled)
continue;
var remotePort = forward.RemotePort;
var localPort = forward.LocalPort;
var shared = forward.Shared;
var address = forward.Address;
if (_servers.ContainsKey(localPort))
{
Log(string.Format(Strings.FORWARD_CANCELED, localPort, address, remotePort), ESeverity.WARN);
}
else
{
var server = new GatewayServer(localPort, @shared, remotePort, address, tunnel, sid);
_servers.Add(localPort, server);
}
}
}
public void Setup()
{
tunnel = Substitute.For<ITunnel>();
RabbitTunnel.Factory = Substitute.For<TunnelFactory>();
RabbitTunnel.Factory.Create(Arg.Any<string>()).Returns(tunnel);
}
public abstract void Execute(string[] parameters, ILogger logger, ITunnel tunnel, int sid);
public void Setup()
{
tunnel = Substitute.For <ITunnel>();
RabbitTunnel.Factory = Substitute.For <TunnelFactory>();
RabbitTunnel.Factory.Create(Arg.Any <string>()).Returns(tunnel);
}
public bool LoadMetadata(Stream strmMetadata)
{
string str = XmlConvert.ToString(true);
SessionFlags none = SessionFlags.None;
string str2 = null;
try
{
XmlTextReader reader = new XmlTextReader(strmMetadata) {
WhitespaceHandling = WhitespaceHandling.None
};
while (reader.Read())
{
long num;
string str4;
if ((reader.NodeType == XmlNodeType.Element) && ((str4 = reader.Name) != null))
{
if (!(str4 == "Session"))
{
if (str4 == "SessionFlag")
{
goto Label_00F1;
}
if (str4 == "SessionTimers")
{
goto Label_0117;
}
if (str4 == "TunnelInfo")
{
goto Label_0328;
}
if (str4 == "PipeInfo")
{
goto Label_0372;
}
}
else
{
if (reader.GetAttribute("Aborted") != null)
{
this.m_state = SessionStates.Aborted;
}
if (reader.GetAttribute("BitFlags") != null)
{
this.BitFlags = (SessionFlags) uint.Parse(reader.GetAttribute("BitFlags"), NumberStyles.HexNumber);
}
if (reader.GetAttribute("SID") != null)
{
str2 = reader.GetAttribute("SID");
}
}
}
continue;
Label_00F1:
this.oFlags.Add(reader.GetAttribute("N"), reader.GetAttribute("V"));
continue;
Label_0117:
this.Timers.ClientConnected = XmlConvert.ToDateTime(reader.GetAttribute("ClientConnected"), XmlDateTimeSerializationMode.RoundtripKind);
string attribute = reader.GetAttribute("ClientBeginRequest");
if (attribute != null)
{
this.Timers.ClientBeginRequest = XmlConvert.ToDateTime(attribute, XmlDateTimeSerializationMode.RoundtripKind);
}
attribute = reader.GetAttribute("GotRequestHeaders");
if (attribute != null)
{
this.Timers.FiddlerGotRequestHeaders = XmlConvert.ToDateTime(attribute, XmlDateTimeSerializationMode.RoundtripKind);
}
this.Timers.ClientDoneRequest = XmlConvert.ToDateTime(reader.GetAttribute("ClientDoneRequest"), XmlDateTimeSerializationMode.RoundtripKind);
attribute = reader.GetAttribute("GatewayTime");
if (attribute != null)
{
this.Timers.GatewayDeterminationTime = XmlConvert.ToInt32(attribute);
}
attribute = reader.GetAttribute("DNSTime");
if (attribute != null)
{
this.Timers.DNSTime = XmlConvert.ToInt32(attribute);
}
attribute = reader.GetAttribute("TCPConnectTime");
if (attribute != null)
{
this.Timers.TCPConnectTime = XmlConvert.ToInt32(attribute);
}
attribute = reader.GetAttribute("HTTPSHandshakeTime");
if (attribute != null)
{
this.Timers.HTTPSHandshakeTime = XmlConvert.ToInt32(attribute);
}
attribute = reader.GetAttribute("ServerConnected");
if (attribute != null)
{
this.Timers.ServerConnected = XmlConvert.ToDateTime(attribute, XmlDateTimeSerializationMode.RoundtripKind);
}
attribute = reader.GetAttribute("FiddlerBeginRequest");
if (attribute != null)
{
this.Timers.FiddlerBeginRequest = XmlConvert.ToDateTime(attribute, XmlDateTimeSerializationMode.RoundtripKind);
}
this.Timers.ServerGotRequest = XmlConvert.ToDateTime(reader.GetAttribute("ServerGotRequest"), XmlDateTimeSerializationMode.RoundtripKind);
attribute = reader.GetAttribute("ServerBeginResponse");
if (attribute != null)
{
this.Timers.ServerBeginResponse = XmlConvert.ToDateTime(attribute, XmlDateTimeSerializationMode.RoundtripKind);
}
attribute = reader.GetAttribute("GotResponseHeaders");
if (attribute != null)
{
this.Timers.FiddlerGotResponseHeaders = XmlConvert.ToDateTime(attribute, XmlDateTimeSerializationMode.RoundtripKind);
}
this.Timers.ServerDoneResponse = XmlConvert.ToDateTime(reader.GetAttribute("ServerDoneResponse"), XmlDateTimeSerializationMode.RoundtripKind);
this.Timers.ClientBeginResponse = XmlConvert.ToDateTime(reader.GetAttribute("ClientBeginResponse"), XmlDateTimeSerializationMode.RoundtripKind);
this.Timers.ClientDoneResponse = XmlConvert.ToDateTime(reader.GetAttribute("ClientDoneResponse"), XmlDateTimeSerializationMode.RoundtripKind);
continue;
Label_0328:
num = 0L;
long result = 0L;
if (long.TryParse(reader.GetAttribute("BytesEgress"), out num) && long.TryParse(reader.GetAttribute("BytesIngress"), out result))
{
this.__oTunnel = new MockTunnel(num, result);
}
continue;
Label_0372:
this.bBufferResponse = str != reader.GetAttribute("Streamed");
if (!this.bBufferResponse)
{
none |= SessionFlags.ResponseStreamed;
}
if (str == reader.GetAttribute("CltReuse"))
{
none |= SessionFlags.ClientPipeReused;
}
if (str == reader.GetAttribute("Reused"))
{
none |= SessionFlags.ServerPipeReused;
}
if (this.oResponse != null)
{
this.oResponse._bWasForwarded = str == reader.GetAttribute("Forwarded");
if (this.oResponse._bWasForwarded)
{
none |= SessionFlags.SentToGateway;
}
}
}
if (this.BitFlags == SessionFlags.None)
{
this.BitFlags = none;
}
if (this.Timers.ClientBeginRequest.Ticks < 1L)
{
this.Timers.ClientBeginRequest = this.Timers.ClientConnected;
}
if (this.Timers.FiddlerBeginRequest.Ticks < 1L)
{
this.Timers.FiddlerBeginRequest = this.Timers.ServerGotRequest;
}
if (this.Timers.FiddlerGotRequestHeaders.Ticks < 1L)
{
this.Timers.FiddlerGotRequestHeaders = this.Timers.ClientBeginRequest;
}
if (this.Timers.FiddlerGotResponseHeaders.Ticks < 1L)
{
this.Timers.FiddlerGotResponseHeaders = this.Timers.ServerBeginResponse;
}
if ((this.m_clientPort == 0) && this.oFlags.ContainsKey("X-ClientPort"))
{
int.TryParse(this.oFlags["X-ClientPort"], out this.m_clientPort);
}
if (str2 != null)
{
if (this.oFlags.ContainsKey("ui-comments"))
{
this.oFlags["x-OriginalSessionID"] = str2;
}
else
{
this.oFlags["ui-comments"] = string.Format("[#{0}] {1}", str2, this.oFlags["ui-comments"]);
}
}
reader.Close();
return true;
}
catch (Exception exception)
{
FiddlerApplication.ReportException(exception);
return false;
}
}
