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; } }