Example #1
0
 protected virtual void ConnectChannel()
 {
     m_channel = m_session.openChannel(ChannelType);
     this.OnChannelReceived();
     m_channel.connect();
     this.OnConnected();
 }
Example #2
0
        private static AChannel MapMediaChannel(
            MediaServicesAccountConfig configMediaServicesAccount,
            MediaService mediaService,
            MediaChannel mediaChannel
            )
        {
            var achannel = new AChannel();

            string originId = configMediaServicesAccount.OriginMappings
                              .Denull()
                              .Where(x => x.ChannelId == mediaChannel.Id)
                              .Select(x => x.OriginId)
                              .FirstOrDefault();

            achannel.Origin = new AOrigin {
                Id = originId
            };

            achannel.Programs = mediaService.Programs
                                .Denull()
                                .Where(mp => mp.ChannelId == mediaChannel.Id)
                                .Select(mp =>
                                        new AProgram()
            {
                Asset = new AAsset()
            }
                                        )
                                .ToList();


            return(achannel);
        }
Example #3
0
    //address表示ip:端口
    public Session ConnectServer(string address)
    {
        AChannel channel = this.Service.ConnectChannel(address);

        channel.Start();
        Session session = new Session(channel);

        return(session);
    }
Example #4
0
        public Session(ETClient rNetwork, AChannel rChannel)
        {
            this.Id = STATIC_ID++;

            this.mNetwork = rNetwork;
            this.mChannel = rChannel;

            this.StartRecv();
        }
 static bool TransmitPacketB(byte[] buffer, int length)
 {
     if (Random.Next(2) == 0)
     {
         return(false);
     }
     AChannel.ReceivePacket(buffer, 0, length);
     return(true);
 }
Example #6
0
        /// <summary>
        /// 有用户连接进来了
        /// </summary>
        /// <param name="channel"></param>
        public void OnAcceptClient(AChannel channel)
        {
            Console.WriteLine("一个用户连接进来了");
            Session s = new Session();

            s.Awake(channel);
            s.Start();
            s.OnReadCallBack += OnRead;
        }
Example #7
0
        public virtual async Task <Session> Accept()
        {
            AChannel rChannel = await this.mService.AcceptChannel();

            Session rSession = new Session(this, rChannel);

            rChannel.ErrorCallback += (c, e) => { this.Remove(rSession.Id); };
            this.mSessions.Add(rSession.Id, rSession);
            return(rSession);
        }
Example #8
0
        private void Ac_ReadCallback(AChannel ac, MemoryStream ms)
        {
            var str_rv = Encoding.UTF8.GetString(ms.ToArray());

            Log.Debug($"{ac.Id}Msg:{str_rv}");
            var word_byts = Encoding.UTF8.GetBytes("Server:" + str_rv);

            ms.Write(word_byts, 0, word_byts.Length);
            ms.Position = 0;
            ac.Send(ms);
        }
Example #9
0
        public void Remove(AChannel channel)
        {
            UChannel tChannel = channel as UChannel;

            if (tChannel == null)
            {
                return;
            }
            this.idChannels.Remove(channel.Id);
            this.channels.Remove(channel.RemoteAddress);
        }
Example #10
0
        public void Remove(AChannel channel)
        {
            TChannel tChannel = channel as TChannel;

            if (tChannel == null)
            {
                return;
            }
            this.idChannels.Remove(channel.Id);
            this.channels.Remove(channel.RemoteAddress);
            this.timerManager.Remove(tChannel.SendTimer);
        }
Example #11
0
        /// <summary>
        /// Creates a directory on the remot server
        /// </summary>
        /// <param name="dir">The new directory</param>
        public override void Mkdir(string dir)
        {
            SCP_CheckConnectivity();

            AChannel channel = null;
            Stream   server  = null;

            m_cancelled = false;

            SCP_ConnectTo(out channel, out server, dir, true);
            SCP_EnterIntoDir(server, dir);
            channel.disconnect();
        }
Example #12
0
        private async void ServerEvent(IService service)
        {
            AChannel channel = await service.GetChannel();

            for (int i = 0; i < echoTimes; ++i)
            {
                byte[] bytes = await channel.RecvAsync();

                CollectionAssert.AreEqual("0123456789".ToByteArray(), bytes);
                Array.Reverse(bytes);
                channel.SendAsync(bytes);
            }
        }
Example #13
0
 /// <summary>
 /// Closes the SSH subsystem
 /// </summary>
 public virtual void Close()
 {
     if (m_channel != null)
     {
         m_channel.disconnect();
         m_channel = null;
     }
     if (m_session != null)
     {
         m_session.disconnect();
         m_session = null;
     }
 }
Example #14
0
        private async void ClientEvent(IService service, string hostName, ushort port)
        {
            AChannel channel = service.GetChannel(hostName, port);

            for (int i = 0; i < echoTimes; ++i)
            {
                channel.SendAsync("0123456789".ToByteArray());
                byte[] bytes = await channel.RecvAsync();

                CollectionAssert.AreEqual("9876543210".ToByteArray(), bytes);
            }

            this.barrier.RemoveParticipant();
        }
Example #15
0
        /// <summary>
        /// Copies a file from local machine to a remote SSH machine.
        /// </summary>
        /// <param name="localPath">The local file path.</param>
        /// <param name="remotePath">The path of the remote file.</param>
        public void To(string localPath, string remotePath, bool _recursive)
        {
            SCP_CheckConnectivity();

            AChannel channel = null;
            Stream   server  = null;

            m_cancelled = false;

            try {
                //if we are sending a single file
                if (File.Exists(localPath))
                {
                    SCP_ConnectTo(out channel, out server, remotePath, _recursive);
                    SCP_SendFile(server, localPath, remotePath);
                    channel.disconnect();
                }
                //else, if we are sending a local directory
                else if (Directory.Exists(localPath))
                {
                    if (!_recursive)
                    {
                        throw new SshTransferException(Path.GetFileName("'" + localPath) + "' is a directory, you should use recursive transfer.");
                    }
                    SCP_ConnectTo(out channel, out server, remotePath, true);
                    ToRecursive(server, localPath, remotePath);
                    channel.disconnect();
                }
                else
                {
                    throw new SshTransferException("File not found: " + localPath);
                }
            }
            catch (Exception e) {
                if (Verbos)
                {
                    Console.WriteLine("Error: " + e.Message);
                }
                //SendEndMessage(remoteFile, localFile, filesize,filesize, "Transfer ended with an error.");
                try {
                    channel.disconnect();
                }
                catch {
                }
                throw e;
            }
        }
Example #16
0
		private async void SocketConnectAsync(AChannel channel)
		{
			while (true)
			{
				try
				{
					await channel.ConnectAsync();
					break;
				}
				catch (Exception e)
				{
					Log.Trace(e.ToString());
				}

				await this.Timer.Sleep(5000);
			}
		}
Example #17
0
        public void request(Session session, AChannel channel)
        {
            Buffer buf    = new Buffer();
            Packet packet = new Packet(buf);

            // send
            // byte     SSH_MSG_CHANNEL_REQUEST(98)
            // uint32 recipient channel
            // string request type       // "shell"
            // boolean want reply        // 0
            packet.reset();
            buf.putByte((byte)Session.SSH_MSG_CHANNEL_REQUEST);
            buf.putInt(channel.getRecipient());
            buf.putString(StringAux.getBytes("shell"));
            buf.putByte((byte)(waitForReply() ? 1 : 0));
            session.write(packet);
        }
Example #18
0
        private async void SocketConnectAsync(AChannel channel)
        {
            while (true)
            {
                try
                {
                    await channel.ConnectAsync();

                    break;
                }
                catch (Exception e)
                {
                    Log.Trace(e.ToString());
                }

                await this.Timer.Sleep(5000);
            }
        }
Example #19
0
 /// <summary>
 /// 创建一个新Session
 /// </summary>
 public virtual Session Create(string rAddress)
 {
     try
     {
         string[] ss       = rAddress.Split(':');
         int      nPort    = int.Parse(ss[1]);
         string   rHost    = ss[0];
         AChannel rChannel = this.mService.ConnectChannel(rHost, nPort);
         Session  rSession = new Session(this, rChannel);
         rChannel.ErrorCallback += (c, e) => { this.Remove(rSession.Id); };
         this.mSessions.Add(rSession.Id, rSession);
         return(rSession);
     }
     catch (Exception e)
     {
         Log.Error(e.ToString());
         return(null);
     }
 }
Example #20
0
        /// <summary>
        /// Connect a channel to the remote server using the 'SCP From' command ('scp -f')
        /// </summary>
        /// <param name="channel">Will contain the new connected channel</param>
        /// <param name="server">Will contaun the new connected server I/O stream</param>
        /// <param name="rfile">The remote path on the server</param>
        /// <param name="recursive">Idicate a recursive scp transfer</param>
        protected void SCP_ConnectFrom(out AChannel channel, out Stream server, string rfile, bool recursive)
        {
            string scpCommand = "scp -f ";

            if (recursive)
            {
                scpCommand += "-r ";
            }
            scpCommand += "\"" + rfile + "\"";

            channel = (ChannelExec)m_session.openChannel(ChannelType);
            ((ChannelExec)channel).setCommand(scpCommand);

            server =
                new LibSterileSSH.CombinedStream
                    (channel.getInputStream(), channel.getOutputStream());
            channel.connect();

            //SCP_CheckAck(server);
        }
Example #21
0
        public void request(Session session, AChannel channel)
        {
            Buffer buf    = new Buffer();
            Packet packet = new Packet(buf);

            bool reply = waitForReply();

            if (reply)
            {
                channel.reply = -1;
            }

            packet.reset();
            buf.putByte((byte)Session.SSH_MSG_CHANNEL_REQUEST);
            buf.putInt(channel.getRecipient());
            buf.putString(StringAux.getBytes("subsystem"));
            buf.putByte((byte)(waitForReply() ? 1 : 0));
            buf.putString(StringAux.getBytes("sftp"));
            session.write(packet);

            if (reply)
            {
                while (channel.reply == -1)
                {
                    try {
                        System.Threading.Thread.Sleep(10);
                    }
                    catch                    //(Exception ee)
                    {
                    }
                }
                if (channel.reply == 0)
                {
                    throw new SshClientException("failed to send sftp request");
                }
            }
        }
        public void request(Session session, AChannel channel)
        {
            Buffer buf    = new Buffer();
            Packet packet = new Packet(buf);

            //byte      SSH_MSG_CHANNEL_REQUEST
            //uint32    recipient_channel
            //string    "window-change"
            //boolean   FALSE
            //uint32    terminal width, columns
            //uint32    terminal height, rows
            //uint32    terminal width, pixels
            //uint32    terminal height, pixels
            packet.reset();
            buf.putByte((byte)Session.SSH_MSG_CHANNEL_REQUEST);
            buf.putInt(channel.getRecipient());
            buf.putString(StringAux.getBytes("window-change"));
            buf.putByte((byte)(waitForReply() ? 1 : 0));
            buf.putInt(width_columns);
            buf.putInt(height_rows);
            buf.putInt(width_pixels);
            buf.putInt(height_pixels);
            session.write(packet);
        }
Example #23
0
 public void Accept(AChannel ac)
 {
     ac.ReadCallback += Ac_ReadCallback;
     Log.Debug($"{ac.Id}:Accept");
 }
Example #24
0
		public void Remove(AChannel channel)
		{
			UChannel tChannel = channel as UChannel;
			if (tChannel == null)
			{
				return;
			}
			this.idChannels.Remove(channel.Id);
			this.channels.Remove(channel.RemoteAddress);
		}
Example #25
0
        /// <summary>
        /// Copies a file from a remote SSH machine to the local machine using SCP.
        /// </summary>
        /// <param name="remoteFile">The remmote file name</param>
        /// <param name="localPath">The local destination path</param>
        /// <param name="recursive">Value indicating whether a recursive transfer should take place</param>
        public void From(string remoteFile, string localPath, bool _recursive)
        {
            SCP_CheckConnectivity();

            AChannel channel = null;
            Stream   server  = null;

            m_cancelled = false;
            int    filesize = 0;
            String filename = null;
            string cmd      = null;

            try {
                String dir = null;
                if (Directory.Exists(localPath))
                {
                    dir = Path.GetFullPath(localPath);
                }

                SCP_ConnectFrom(out channel, out server, remoteFile, _recursive);

                byte[] buf = new byte[1024];

                // send '\0'
                SCP_SendAck(server);
                int c = SCP_CheckAck(server);

                //parse scp commands
                while ((c == 'D') || (c == 'C') || (c == 'E'))
                {
                    if (m_cancelled)
                    {
                        break;
                    }

                    cmd = "" + (char)c;
                    if (c == 'E')
                    {
                        c   = SCP_CheckAck(server);
                        dir = Path.GetDirectoryName(dir);
                        if (Verbos)
                        {
                            Console.WriteLine("E");
                        }
                        //send '\0'
                        SCP_SendAck(server);
                        c = (char)SCP_CheckAck(server);
                        continue;
                    }

                    // read '0644 ' or '0755 '
                    server.Read(buf, 0, 5);
                    for (int i = 0; i < 5; i++)
                    {
                        cmd += (char)buf[i];
                    }

                    //reading file size
                    filesize = 0;
                    while (true)
                    {
                        server.Read(buf, 0, 1);
                        if (buf[0] == ' ')
                        {
                            break;
                        }
                        filesize = filesize * 10 + (buf[0] - '0');
                    }

                    //reading file name
                    for (int i = 0; ; i++)
                    {
                        server.Read(buf, i, 1);
                        if (buf[i] == (byte)0x0a)
                        {
                            filename = StringAux.getString(buf, 0, i);
                            break;
                        }
                    }
                    cmd += " " + filesize + " " + filename;
                    // send '\0'
                    SCP_SendAck(server);

                    //Receive file
                    if (c == 'C')
                    {
                        if (Verbos)
                        {
                            Console.WriteLine("Sending file modes: " + cmd);
                        }
                        SCP_ReceiveFile(server, remoteFile,
                                        dir == null ? localPath : dir + "/" + filename,
                                        filesize);

                        if (m_cancelled)
                        {
                            break;
                        }

                        // send '\0'
                        SCP_SendAck(server);
                    }
                    //Enter directory
                    else if (c == 'D')
                    {
                        if (dir == null)
                        {
                            if (File.Exists(localPath))
                            {
                                throw new SshTransferException("'" + localPath + "' is not a directory");
                            }
                            dir = localPath;
                            Directory.CreateDirectory(dir);
                        }
                        if (Verbos)
                        {
                            Console.WriteLine("Entering directory: " + cmd);
                        }
                        dir += "/" + filename;
                        Directory.CreateDirectory(dir);
                    }

                    c = SCP_CheckAck(server);
                }
                channel.disconnect();
            }
            catch (Exception e) {
                if (Verbos)
                {
                    Console.WriteLine("Error: " + e.Message);
                }
                try {
                    channel.disconnect();
                }
                catch {
                }
                throw e;
            }
        }
Example #26
0
 private static void AChannelError(BenchmarkClientComponent self, AChannel aChannel, int errorCode)
 {
     ShowErrorMessage(self, errorCode);
 }
Example #27
0
 private void KService_DisConnectCallback(AChannel ac)
 {
     Log.Debug($"{ac.Id}:disconnect");
 }
Example #28
0
 private void Ac_ReadCallback(AChannel ac, MemoryStream ms)
 {
     Log.Debug(Encoding.UTF8.GetString(ms.ToArray()));
 }
 static bool TransmitPacketB(byte[] buffer, int length)
 {
     AChannel.ReceivePacket(buffer, 0, length);
     return(true);
 }
Example #30
0
		public void Remove(AChannel channel)
		{
			TChannel tChannel = channel as TChannel;
			if (tChannel == null)
			{
				return;
			}
			this.idChannels.Remove(channel.Id);
			this.channels.Remove(channel.RemoteAddress);
			this.timerManager.Remove(tChannel.SendTimer);
		}
Example #31
0
    public void OnGUI()
    {
        if (ChannelType == NetworkProtocol.TCP)
        {
            GUILayout.BeginVertical();
            if (GUILayout.Button("Connect", GUILayout.Width(200)))
            {
                m_AChannel = (TChannel)m_AService.ConnectChannel(NetHelper.ToIPEndPoint("127.0.0.1", 2500));
                m_AChannel.ReadCallback += AChannel_ReadCallback;
            }

            if (GUILayout.Button("Send", GUILayout.Width(200)))
            {
                using (var mem = new MemoryStream())
                {
                    var word_byts = Encoding.UTF8.GetBytes("Hello Tcp!");
                    mem.Write(word_byts, 0, word_byts.Length);
                    mem.Position = 0;
                    m_AChannel.Send(mem);
                }
            }

            if (GUILayout.Button("DisConnect", GUILayout.Width(200)))
            {
                m_AChannel.DisConnect();
            }
            GUILayout.EndVertical();
        }
        else if (ChannelType == NetworkProtocol.KCP)
        {
            GUILayout.BeginVertical();
            if (GUILayout.Button("Connect", GUILayout.Width(200)))
            {
                m_AChannel = m_AService.ConnectChannel(NetHelper.ToIPEndPoint("127.0.0.1", 2000));
                m_AChannel.ReadCallback += AChannel_ReadCallback;
            }

            if (GUILayout.Button("Send", GUILayout.Width(200)))
            {
                using (var mem = new MemoryStream())
                {
                    var word_byts = Encoding.UTF8.GetBytes("Hello Kcp!");
                    mem.Write(word_byts, 0, word_byts.Length);
                    mem.Position = 0;
                    m_AChannel.Send(mem);
                }
            }

            if (GUILayout.Button("DisConnect", GUILayout.Width(200)))
            {
                m_AChannel.DisConnect();
            }
            GUILayout.EndVertical();
        }
        else if (ChannelType == NetworkProtocol.WebSocket)
        {
            GUILayout.BeginVertical();
            if (GUILayout.Button("Connect", GUILayout.Width(200)))
            {
                m_AChannel = m_AService.ConnectChannel("ws://127.0.0.1:3000/");
                m_AChannel.ReadCallback += AChannel_ReadCallback;
            }

            if (GUILayout.Button("Send", GUILayout.Width(200)))
            {
                using (var mem = new MemoryStream())
                {
                    var word_byts = Encoding.UTF8.GetBytes("Hello websocket!");
                    mem.Write(word_byts, 0, word_byts.Length);
                    mem.Position = 0;
                    m_AChannel.Send(mem);
                }
            }

            if (GUILayout.Button("DisConnect", GUILayout.Width(200)))
            {
                m_AChannel.DisConnect();
            }
            GUILayout.EndVertical();
        }
    }
Example #32
0
 private void AChannel_ReadCallback(AChannel ac, MemoryStream ms)
 {
     Log.Debug($"{ac.Id}Msg:{Encoding.UTF8.GetString(ms.ToArray())}");
 }
Example #33
0
 //收取断开消息
 private void AService_DisConnectedCallback(AChannel ac)
 {
     Log.Debug($"{ac.Id}:DisConnect");
 }