Пример #1
0
        public void run()
        {
            thread=this;

            byte[] foo;
            Buffer buf=new Buffer();
            Packet packet=new Packet(buf);
            int i=0;
            Channel channel;
            int[] start=new int[1];
            int[] length=new int[1];
            KeyExchange kex=null;

            try
            {
                while(_isConnected &&
                    thread!=null)
                {
                    buf=read(buf);
                    int msgType=buf.buffer[5]&0xff;
                    //      if(msgType!=94)
                    //System.Console.WriteLine("read: 94 ? "+msgType);

                    if(kex!=null && kex.getState()==msgType)
                    {
                        bool result=kex.next(buf);
                        if(!result)
                        {
                            throw new JSchException("verify: "+result);
                        }
                        continue;
                    }

                    switch(msgType)
                    {
                        case SSH_MSG_KEXINIT:
                            //System.Console.WriteLine("KEXINIT");
                            kex=receive_kexinit(buf);
                            break;

                        case SSH_MSG_NEWKEYS:
                            //System.Console.WriteLine("NEWKEYS");
                            send_newkeys();
                            receive_newkeys(buf, kex);
                            kex=null;
                            break;

                        case SSH_MSG_CHANNEL_DATA:
                            buf.getInt();
                            buf.getByte();
                            buf.getByte();
                            i=buf.getInt();
                            channel=Channel.getChannel(i, this);
                            foo=buf.getString(start, length);
                            if(channel==null)
                            {
                                break;
                            }
                            try
                            {
                                channel.write(foo, start[0], length[0]);
                            }
                            catch(Exception e)
                            {
                                //System.Console.WriteLine(e);
                                try{channel.disconnect();}
                                catch(Exception ee){}
                                break;
                            }
                            int len=length[0];
                            channel.setLocalWindowSize(channel.lwsize-len);
                            if(channel.lwsize<channel.lwsize_max/2)
                            {
                                packet.reset();
                                buf.putByte((byte)SSH_MSG_CHANNEL_WINDOW_ADJUST);
                                buf.putInt(channel.getRecipient());
                                buf.putInt(channel.lwsize_max-channel.lwsize);
                                write(packet);
                                channel.setLocalWindowSize(channel.lwsize_max);
                            }
                            break;

                        case SSH_MSG_CHANNEL_EXTENDED_DATA:
                            buf.getInt();
                            buf.getShort();
                            i=buf.getInt();
                            channel=Channel.getChannel(i, this);
                            buf.getInt();                   // data_type_code == 1
                            foo=buf.getString(start, length);
                            //System.Console.WriteLine("stderr: "+new String(foo,start[0],length[0]));
                            if(channel==null)
                            {
                                break;
                            }
                            //channel.write(foo, start[0], length[0]);
                            channel.write_ext(foo, start[0], length[0]);

                            len=length[0];
                            channel.setLocalWindowSize(channel.lwsize-len);
                            if(channel.lwsize<channel.lwsize_max/2)
                            {
                                packet.reset();
                                buf.putByte((byte)SSH_MSG_CHANNEL_WINDOW_ADJUST);
                                buf.putInt(channel.getRecipient());
                                buf.putInt(channel.lwsize_max-channel.lwsize);
                                write(packet);
                                channel.setLocalWindowSize(channel.lwsize_max);
                            }
                            break;

                        case SSH_MSG_CHANNEL_WINDOW_ADJUST:
                            buf.getInt();
                            buf.getShort();
                            i=buf.getInt();
                            channel=Channel.getChannel(i, this);
                            if(channel==null)
                            {
                                break;
                            }
                            channel.addRemoteWindowSize(buf.getInt());
                            break;

                        case SSH_MSG_CHANNEL_EOF:
                            buf.getInt();
                            buf.getShort();
                            i=buf.getInt();
                            channel=Channel.getChannel(i, this);
                            if(channel!=null)
                            {
                                //channel._eof_remote=true;
                                //channel.eof();
                                channel.eof_remote();
                            }
                            /*
                            packet.reset();
                            buf.putByte((byte)SSH_MSG_CHANNEL_EOF);
                            buf.putInt(channel.getRecipient());
                            write(packet);
                            */
                            break;
                        case SSH_MSG_CHANNEL_CLOSE:
                            buf.getInt();
                            buf.getShort();
                            i=buf.getInt();
                            channel=Channel.getChannel(i, this);
                            if(channel!=null)
                            {
                                //	      channel.close();
                                channel.disconnect();
                            }
                            /*
                                if(Channel.pool.size()==0){
                              thread=null;
                            }
                            */
                            break;
                        case SSH_MSG_CHANNEL_OPEN_CONFIRMATION:
                            buf.getInt();
                            buf.getShort();
                            i=buf.getInt();
                            channel=Channel.getChannel(i, this);
                            if(channel==null)
                            {
                                //break;
                            }
                            channel.setRecipient(buf.getInt());
                            channel.setRemoteWindowSize(buf.getInt());
                            channel.setRemotePacketSize(buf.getInt());
                            break;
                        case SSH_MSG_CHANNEL_OPEN_FAILURE:
                            buf.getInt();
                            buf.getShort();
                            i=buf.getInt();
                            channel=Channel.getChannel(i, this);
                            if(channel==null)
                            {
                                //break;
                            }
                            int reason_code=buf.getInt();
                            //foo=buf.getString();  // additional textual information
                            //foo=buf.getString();  // language tag
                            channel.exitstatus=reason_code;
                            channel._close=true;
                            channel._eof_remote=true;
                            channel.setRecipient(0);
                            break;
                        case SSH_MSG_CHANNEL_REQUEST:
                            buf.getInt();
                            buf.getShort();
                            i=buf.getInt();
                            foo=buf.getString();
                            bool reply=(buf.getByte()!=0);
                            channel=Channel.getChannel(i, this);
                            if(channel!=null)
                            {
                                byte reply_type=(byte)SSH_MSG_CHANNEL_FAILURE;
                                if((new String(foo)).equals("exit-status"))
                                {
                                    i=buf.getInt();             // exit-status
                                    channel.setExitStatus(i);
                                    //	    System.Console.WriteLine("exit-stauts: "+i);
                                    //          channel.close();
                                    reply_type=(byte)SSH_MSG_CHANNEL_SUCCESS;
                                }
                                if(reply)
                                {
                                    packet.reset();
                                    buf.putByte(reply_type);
                                    buf.putInt(channel.getRecipient());
                                    write(packet);
                                }
                            }
                            else
                            {
                            }
                            break;
                        case SSH_MSG_CHANNEL_OPEN:
                            buf.getInt();
                            buf.getShort();
                            foo=buf.getString();
                            String ctyp=new String(foo);
                            //System.Console.WriteLine("type="+ctyp);
                            if(!new String("forwarded-tcpip").equals(ctyp) &&
                                !(new String("x11").equals(ctyp) && x11_forwarding))
                            {
                                System.Console.WriteLine("Session.run: CHANNEL OPEN "+ctyp);
                                throw new IOException("Session.run: CHANNEL OPEN "+ctyp);
                            }
                            else
                            {
                                channel=Channel.getChannel(ctyp);
                                addChannel(channel);
                                channel.getData(buf);
                                channel.init();

                                packet.reset();
                                buf.putByte((byte)SSH_MSG_CHANNEL_OPEN_CONFIRMATION);
                                buf.putInt(channel.getRecipient());
                                buf.putInt(channel.id);
                                buf.putInt(channel.lwsize);
                                buf.putInt(channel.lmpsize);
                                write(packet);
                                Thread tmp=new Thread(channel);
                                tmp.setName("Channel "+ctyp+" "+host);
                                tmp.start();
                                break;
                            }
                        case SSH_MSG_CHANNEL_SUCCESS:
                            buf.getInt();
                            buf.getShort();
                            i=buf.getInt();
                            channel=Channel.getChannel(i, this);
                            if(channel==null)
                            {
                                break;
                            }
                            channel.reply=1;
                            break;
                        case SSH_MSG_CHANNEL_FAILURE:
                            buf.getInt();
                            buf.getShort();
                            i=buf.getInt();
                            channel=Channel.getChannel(i, this);
                            if(channel==null)
                            {
                                break;
                            }
                            channel.reply=0;
                            break;
                        case SSH_MSG_GLOBAL_REQUEST:
                            buf.getInt();
                            buf.getShort();
                            foo=buf.getString();       // request name
                            reply=(buf.getByte()!=0);
                            if(reply)
                            {
                                packet.reset();
                                buf.putByte((byte)SSH_MSG_REQUEST_FAILURE);
                                write(packet);
                            }
                            break;
                        case SSH_MSG_REQUEST_FAILURE:
                        case SSH_MSG_REQUEST_SUCCESS:
                            Thread t=grr.getThread();
                            if(t!=null)
                            {
                                grr.setReply(msgType==SSH_MSG_REQUEST_SUCCESS? 1 : 0);
                                t.interrupt();
                            }
                            break;
                        default:
                            System.Console.WriteLine("Session.run: unsupported type "+msgType);
                            throw new IOException("Unknown SSH message type "+msgType);
                    }
                }
            }
            catch(Exception e)
            {
                //System.Console.WriteLine("# Session.run");
                //e.printStackTrace();
            }
            try
            {
                disconnect();
            }
            catch(NullReferenceException e)
            {
                //System.Console.WriteLine("@1");
                //e.printStackTrace();
            }
            catch(Exception e)
            {
                //System.Console.WriteLine("@2");
                //e.printStackTrace();
            }
            _isConnected=false;
        }
Пример #2
0
        /*
        public void finalize() throws Throwable{
          disconnect();
          jsch=null;
        }
        */
        public void disconnect()
        {
            if(!_isConnected) return;

            //System.Console.WriteLine(this+": disconnect");
            //Thread.dumpStack();
            /*
            for(int i=0; i<Channel.pool.size(); i++){
              try{
                Channel c=((Channel)(Channel.pool.elementAt(i)));
            if(c.session==this) c.eof();
              }
              catch(Exception e){
              }
            }
            */

            Channel.disconnect(this);

            _isConnected=false;

            PortWatcher.delPort(this);
            ChannelForwardedTCPIP.delPort(this);

            lock(connectThread)
            {
                connectThread.yield();
                connectThread.interrupt();
                connectThread=null;
            }
            thread=null;
            try
            {
                if(io!=null)
                {
                    if(io.ins!=null) io.ins.Close();
                    if(io.outs!=null) io.outs.Close();
                    if(io.outs_ext!=null) io.outs_ext.Close();
                }
                if(proxy==null)
                {
                    if(socket!=null)
                        socket.close();
                }
                else
                {
                    lock(proxy)
                    {
                        proxy.close();
                    }
                    proxy=null;
                }
            }
            catch(Exception e)
            {
                //      e.printStackTrace();
            }
            io=null;
            socket=null;
            //    lock(jsch.pool){
            //      jsch.pool.removeElement(this);
            //    }

            jsch.removeSession(this);

            //System.gc();
        }
Пример #3
0
        public void connect(int connectTimeout)
        {
            if(_isConnected)
            {
                throw new JSchException("session is already connected");
            }
            io=new IO();
            if(random==null)
            {
                try
                {
                    Class c=Class.forName(getConfig("random"));
                    random=(Random)(c.newInstance());
                }
                catch(Exception e)
                {
                    System.Console.Error.WriteLine("connect: random "+e);
                }
            }
            Packet.setRandom(random);

            try
            {
                int i, j;
                int pad=0;

                if(proxy==null)
                {
                    proxy=jsch.getProxy(host);
                    if(proxy!=null)
                    {
                        lock(proxy)
                        {
                            proxy.close();
                        }
                    }
                }

                if(proxy==null)
                {
                    Stream In;
                    Stream Out;
                    if(socket_factory==null)
                    {
                        socket=Util.createSocket(host, port, connectTimeout);
                        In=socket.getInputStream();
                        Out=socket.getOutputStream();
                    }
                    else
                    {
                        socket=socket_factory.createSocket(host, port);
                        In=socket_factory.getInputStream(socket);
                        Out=socket_factory.getOutputStream(socket);
                    }
                    //if(timeout>0){ socket.setSoTimeout(timeout); }
                    socket.setTcpNoDelay(true);
                    io.setInputStream(In);
                    io.setOutputStream(Out);
                }
                else
                {
                    lock(proxy)
                    {
                        proxy.connect(this, host, port, connectTimeout);
                        io.setInputStream(proxy.getInputStream());
                        io.setOutputStream(proxy.getOutputStream());
                        socket=proxy.getSocket();
                    }
                }

                if(connectTimeout>0 && socket!=null)
                {
                    socket.setSoTimeout(connectTimeout);
                }

                _isConnected=true;

                i=0;
                j=0;
                while(i<buf.buffer.Length)
                {
                    j=io.getByte();
                    if(j<0)break;
                    buf.buffer[i]=(byte)j; i++;
                    if(j==10)break;
                }
                if(j<0)
                {
                    throw new JSchException("connection is closed by foreign host");
                }

                if(buf.buffer[i-1]==10)
                {    // 0x0a
                    i--;
                    if(buf.buffer[i-1]==13)
                    {  // 0x0d
                        i--;
                    }
                }

                if(i==buf.buffer.Length ||
                    i<7 ||                                      // SSH-1.99 or SSH-2.0
                    (buf.buffer[4]=='1' && buf.buffer[6]!='9')  // SSH-1.5
                    )
                {
                    throw new JSchException("invalid server's version String");
                }

                V_S=new byte[i]; Fireball.Ssh.java.System.arraycopy(buf.buffer, 0, V_S, 0, i);
                //System.Console.WriteLine("V_S: ("+i+") ["+new String(V_S)+"]");

                //io.put(V_C, 0, V_C.Length); io.put("\n".getBytes(), 0, 1);
            {
                // Some Cisco devices will miss to read '\n' if it is sent separately.
                byte[] foo=new byte[V_C.Length+1];
                Fireball.Ssh.java.System.arraycopy(V_C, 0, foo, 0, V_C.Length);
                foo[foo.Length-1]=(byte)'\n';
                io.put(foo, 0, foo.Length);
            }

                buf=read(buf);
                //System.Console.WriteLine("read: 20 ? "+buf.buffer[5]);
                if(buf.buffer[5]!=SSH_MSG_KEXINIT)
                {
                    throw new JSchException("invalid protocol: "+buf.buffer[5]);
                }
                KeyExchange kex=receive_kexinit(buf);

                while(true)
                {
                    buf=read(buf);
                    if(kex.getState()==buf.buffer[5])
                    {
                        bool result=kex.next(buf);
                        if(!result)
                        {
                            //System.Console.WriteLine("verify: "+result);
                            in_kex=false;
                            throw new JSchException("verify: "+result);
                        }
                    }
                    else
                    {
                        in_kex=false;
                        throw new JSchException("invalid protocol(kex): "+buf.buffer[5]);
                    }
                    if(kex.getState()==KeyExchange.STATE_END)
                    {
                        break;
                    }
                }

                try{ checkHost(host, kex); }
                catch(JSchException ee)
                {
                    in_kex=false;
                    throw ee;
                }

                send_newkeys();

                // receive SSH_MSG_NEWKEYS(21)
                buf=read(buf);
                //System.Console.WriteLine("read: 21 ? "+buf.buffer[5]);
                if(buf.buffer[5]==SSH_MSG_NEWKEYS)
                {
                    receive_newkeys(buf, kex);
                }
                else
                {
                    throw new JSchException("invalid protocol(newkyes): "+buf.buffer[5]);
                }

                bool auth=false;
                bool auth_cancel=false;

                UserAuthNone usn=new UserAuthNone(userinfo);
                auth=usn.start(this);

                String methods=usn.getMethods().toLowerCase();
                // methods: publickey,password,keyboard-interactive
                if(methods==null)
                {
                    methods="publickey,password,keyboard-interactive";
                }

            loop:
                while(true)
                {

                    //System.Console.WriteLine("methods: "+methods);

                    while(!auth &&
                        methods!=null && methods.Length()>0)
                    {

                        //System.Console.WriteLine("  methods: "+methods);

                        UserAuth us=null;
                        if(methods.startsWith("publickey"))
                        {
                            //System.Console.WriteLine("   jsch.identities.size()="+jsch.identities.size());
                            lock(jsch.identities)
                            {
                                if(jsch.identities.size()>0)
                                {
                                    us=new UserAuthPublicKey(userinfo);
                                }
                            }
                        }
                        else if(methods.startsWith("keyboard-interactive"))
                        {
                            if(userinfo is UIKeyboardInteractive)
                            {
                                us=new UserAuthKeyboardInteractive(userinfo);
                            }
                        }
                        else if(methods.startsWith("password"))
                        {
                            us=new UserAuthPassword(userinfo);
                        }
                        if(us!=null)
                        {
                            try
                            {
                                auth=us.start(this);
                                auth_cancel=false;
                            }
                            catch(JSchAuthCancelException ee)
                            {
                                //System.Console.WriteLine(ee);
                                auth_cancel=true;
                            }
                            catch(JSchPartialAuthException ee)
                            {
                                methods=ee.getMethods();
                                //System.Console.WriteLine("PartialAuth: "+methods);
                                auth_cancel=false;
                                continue;//loop;
                            }
                            catch(RuntimeException ee)
                            {
                                throw ee;
                            }
                            catch(Exception ee)
                            {
                                System.Console.WriteLine("ee: "+ee); // SSH_MSG_DISCONNECT: 2 Too many authentication failures
                            }
                        }
                        if(!auth)
                        {
                            int comma=methods.indexOf(",");
                            if(comma==-1) break;
                            methods=methods.subString(comma+1);
                        }
                    }
                    break;
                }

                if(connectTimeout>0 || timeout>0)
                {
                    socket.setSoTimeout(timeout);
                }

                if(auth)
                {
                    isAuthed=true;
                    connectThread=new Thread(this);
                    connectThread.setName("Connect thread "+host+" session");
                    connectThread.start();
                    return;
                }
                if(auth_cancel)
                    throw new JSchException("Auth cancel");
                throw new JSchException("Auth fail");
            }
            catch(Exception e)
            {
                if(_isConnected)
                {
                    try
                    {
                        packet.reset();
                        buf.putByte((byte)SSH_MSG_DISCONNECT);
                        buf.putInt(3);
                        buf.putString(new String(e.ToString()).getBytes());
                        buf.putString(new String("en").getBytes());
                        write(packet);
                        disconnect();
                    }
                    catch(Exception ee)
                    {
                    }
                }
                _isConnected=false;
                //e.printStackTrace();
                if(e is RuntimeException) throw (RuntimeException)e;
                if(e is JSchException) throw (JSchException)e;
                throw new JSchException("Session.connect: "+e);
            }
        }
Пример #4
0
 internal void setThread(Thread thread)
 {
     this.thread=thread;
     this.reply=-1;
 }
Пример #5
0
 public void setPortForwardingL(String boundaddress, int lport, String host, int rport, ServerSocketFactory ssf)
 {
     PortWatcher pw=PortWatcher.addPort(this, boundaddress, lport, host, rport, ssf);
     Thread tmp=new Thread(pw);
     tmp.setName("PortWatcher Thread for "+host);
     tmp.start();
 }