コード例 #1
0
ファイル: Proxy.cs プロジェクト: HTD/Woof.Sockets
 /// <summary>
 /// Creates a new proxy between 2 targets.
 /// </summary>
 /// <param name="a">Point A.</param>
 /// <param name="b">Point B.</param>
 public Proxy(HostTarget a, HostTarget b)
 {
     A           = a;
     B           = b;
     ProxyServer = new ActiveEndPoint <T>(B);
     ProxyServer.SessionSpawned += ProxyServer_SessionSpawned;
 }
コード例 #2
0
ファイル: Router.cs プロジェクト: HTD/Woof.Sockets
        /// <summary>
        /// Handles this server sessions spawn.
        /// </summary>
        /// <param name="sender">Local session.</param>
        /// <param name="e">Formal junk.</param>
        private void RoutingServer_SessionSpawned(object sender, EventArgs e)
        {
            var session = sender as ActiveSession <T>;

            session.End             += Session_End;
            session.IsClientSide     = true;
            session.ExceptionThrown += AllTargets_ExceptionThrown;
            session.MessageReceived += Session_MessageReceived;
            var servers = new List <ActiveEndPoint <T> >();

            for (int i = 0, n = Targets.Length; i < n; i++)
            {
                var remote = new ActiveEndPoint <T>(Targets[i], session)
                {
                    Index = i
                };
                remote.ExceptionThrown += AllTargets_ExceptionThrown;
                remote.MessageReceived += Remote_MessageReceived;
                remote.SessionClosed   += Remote_SessionClosed;
                servers.Add(remote);
            }
            session.Remotes     = servers.ToArray();
            session.Route       = RouteDefault;
            session.IsBroadcast = IsBroadcast;
            SessionStarted?.Invoke(session, EventArgs.Empty);
            foreach (var server in session.Remotes)
            {
                server.Connect();
            }
            if (!session.Remotes.All(i => i.IsConnected))
            {
                session.Close();
            }
        }
コード例 #3
0
 /// <summary>
 /// Creates a new session.
 /// </summary>
 /// <param name="owner">Owner end point.</param>
 /// <param name="socket">Session socket.</param>
 /// <param name="id">Session identifier.</param>
 public ActiveSession(ActiveEndPoint <T> owner, Socket socket, int id)
 {
     Owner  = owner;
     Id     = id;
     Socket = socket;
     Stream = new NetworkStreamEx(socket, Owner.Host.AuthenticationData);
     Stream.Authenticate(); // TODO: make authentication optional for StartTLS support
     if (typeof(T) == typeof(byte[]))
     {
         Transceiver = new BinaryTransceiver() as ITransceiver <T>;
     }
     else if (typeof(T) == typeof(BinaryPacket))
     {
         Transceiver = new FastBinaryTransceiver() as ITransceiver <T>;
     }
     else if (typeof(T) == typeof(X690.Message))
     {
         Transceiver = new X690Transceiver() as ITransceiver <T>;
     }
     else if (typeof(T) == typeof(string))
     {
         Transceiver = new StringTransceiver() as ITransceiver <T>;
     }
     else
     {
         throw new InvalidDataException("Unsupported message type.");
     }
 }
コード例 #4
0
ファイル: Router.cs プロジェクト: HTD/Woof.Sockets
 /// <summary>
 /// Creates a new end point router from common target to multiple remote targets.
 /// </summary>
 /// <param name="common">Common end.</param>
 /// <param name="targets">Remote targets.</param>
 public Router(HostTarget common, params HostTarget[] targets)
 {
     Common        = common;
     Targets       = targets;
     RoutingServer = new ActiveEndPoint <T>(Common)
     {
         Index = -1
     };
     RoutingServer.ExceptionThrown += AllTargets_ExceptionThrown;
     RoutingServer.SessionSpawned  += RoutingServer_SessionSpawned;
 }
コード例 #5
0
ファイル: Proxy.cs プロジェクト: HTD/Woof.Sockets
        /// <summary>
        /// Handles this server sessions spawn.
        /// </summary>
        /// <param name="sender">Local session.</param>
        /// <param name="e">Formal junk.</param>
        private void ProxyServer_SessionSpawned(object sender, EventArgs e)
        {
            var session = sender as ActiveSession <T>;

            session.End             += Session_End;
            session.IsClientSide     = true;
            session.ExceptionThrown += Session_ExceptionThrown;
            session.MessageReceived += Session_MessageReceived;
            var remote = new ActiveEndPoint <T>(A, session);

            remote.MessageReceived += Remote_MessageReceived;
            remote.ExceptionThrown += Session_ExceptionThrown;
            session.Remotes         = new[] { remote };
            SessionStarted?.Invoke(this, EventArgs.Empty);
            remote.Connect();
            if (!remote.IsConnected)
            {
                session.Close();
            }
        }