C:/work/OMMR/OCHHP_OMMR_OMMR/Code/Assemblies/SharpSSH/Source/SharpSSH-1.1.1.13.src/SharpSSH/SshStream.cs

Go to the documentation of this file.

using System;
using System.IO;
using System.Collections;
using Tamir.SharpSsh.jsch;
using Tamir.Streams;
using System.Text;
using System.Text.RegularExpressions;

/* 
 * SshStream.cs
 * 
 * THIS SOURCE CODE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY
 * KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR
 * PURPOSE.
 * 
 * Copyright (C) 2005 Tamir Gal, tamirgal@myrealbox.com.
 */

namespace Tamir.SharpSsh
{
        public class SshStream : Stream
        {
                private Stream m_in;
                private Stream m_out;
                private ChannelShell m_channel;
                private string m_host;
                private Regex m_prompt;
                private string m_escapeCharPattern;
                private bool m_removeTerminalChars = false;
                private Session m_session;

                public SshStream(string host, string username, string password)
                {
                        this.m_host = host;
                        JSch jsch=new JSch();
                        m_session=jsch.getSession(username, host, 22);
                        m_session.setPassword( password );
                
                        Hashtable config=new Hashtable();
                        config.Add("StrictHostKeyChecking", "no");
                        m_session.setConfig(config);
                
                        m_session.connect();
                        m_channel=(ChannelShell)m_session.openChannel("shell");

                        m_in    = m_channel.getInputStream();
                        m_out   = m_channel.getOutputStream();

                        m_channel.connect();
                        m_channel.setPtySize(80, 132, 1024, 768);

                        Prompt = "\n";
                        m_escapeCharPattern = "\\[[0-9;?]*[^0-9;]";
                }

                public override int Read(byte[] buffer, int offset, int count)
                {
                        return m_in.Read(buffer, offset, count);
                }

                public virtual int Read(byte[] buffer)
                {
                        return Read(buffer, 0, buffer.Length);
                }

                public override int ReadByte()
                {
                        return m_in.ReadByte();
                }
                
                public override void WriteByte(byte value)
                {
                        m_out.WriteByte(value);
                }

                public override void Write(byte[] buffer, int offset, int count)
                {
                        m_out.Write(buffer, offset, count);
                }

                public virtual void Write(byte[] buffer)
                {
                        Write(buffer, 0, buffer.Length);
                }

                public void Write(String data)
                {
                        data += "\r";
                        Write( Encoding.Default.GetBytes( data ) );
                        Flush();
                }

                public override void Close()
                {
                        try
                        {
                                base.Close ();
                                m_in.Close();
                                m_out.Close();
                                m_channel.close();
                                m_channel.disconnect();
                                m_session.disconnect();
                        }
                        catch{}
                }

                public override bool CanRead
                {
                        get
                        {
                                return m_in.CanRead;
                        }
                }

                public override bool CanWrite
                {
                        get
                        {
                                return m_out.CanWrite;
                        }
                }

                public override bool CanSeek
                {
                        get
                        {
                                return false;
                        }
                }

                public override void Flush()
                {
                        m_out.Flush();
                }

                public override long Length
                {
                        get
                        {
                                return 0;
                        }
                }

                public override long Position
                {
                        get
                        {
                                return 0;
                        }
                        set
                        {
                        }
                }

                public override void SetLength(long value)
                {
                }

                public override long Seek(long offset, SeekOrigin origin)
                {
                        return 0;
                }

                public string Prompt
                {
                        get{return m_prompt.ToString();}
                        set{m_prompt = new Regex(value, RegexOptions.Singleline);}
                }

                public bool RemoveTerminalEmulationCharacters
                {
                        get{return m_removeTerminalChars;}
                        set{m_removeTerminalChars=value;}
                }

                public string Cipher
                {
                        get{return m_session.getCipher();}
                }

                public string Mac
                {
                        get{return m_session.getMac();}
                }

                public string ServerVersion
                {
                        get{return m_session.getServerVersion();}
                }

                public string ClientVersion
                {
                        get{return m_session.getClientVersion();}
                }

                public string ReadResponse()
                {
                        int readCount;
                        StringBuilder resp = new StringBuilder();
                        byte[] buff = new byte[1024];
                        Match match;

                        do 
                        {
                                readCount = this.Read(buff);
                                resp.Append( System.Text.Encoding.Default.GetString( buff), 0, readCount);
                                string s = resp.ToString();
                                match = m_prompt.Match( s );
                        }while(!match.Success);

                        return HandleTerminalChars( resp.ToString() );
                }

                private string HandleTerminalChars(string str)
                {
                        if(RemoveTerminalEmulationCharacters)
                        {
                                str = str.Replace("(B)0", "");
                                str = Regex.Replace(str, m_escapeCharPattern, "");
                                str = str.Replace(((char)15).ToString(), "");
                                str = Regex.Replace(str, ((char)27).ToString()+"=*", "");
                                //str = Regex.Replace(str, "\\s*\r\n", "\r\n");
                        }
                        return str;
                }
        }
}

---