/*

 * lftp - file transfer program

 *

 * Copyright (c) 1996-2017 by Alexander V. Lukyanov (lav@yars.free.net)

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 3 of the License, or

 * (at your option) any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 */

#include <config.h>

#include "SFtp.h"

#include "ArgV.h"

#include "log.h"

#include "ascii_ctype.h"

#include "FileGlob.h"

#include "misc.h"

#include "LsCache.h"

#include <assert.h>

#include <errno.h>

#include <stddef.h>

#define max_buf 0x10000

#define super SSH_Access

bool SFtp::GetBetterConnection(int level,bool limit_reached)

{

   bool need_sleep=false;

   for(FA *fo=FirstSameSite(); fo!=0; fo=NextSameSite(fo))

   {

      SFtp *o=(SFtp*)fo; // we are sure it is SFtp.

      if(!o->recv_buf)

	 continue;

      if(o->state!=CONNECTED || o->mode!=CLOSED)

      {

	 if(level<2)

	    continue;

	 if(!connection_takeover || (o->priority>=priority && !o->IsSuspended()))

	    continue;

	 o->Disconnect();

	 return need_sleep;

      }

      if(level==0 && xstrcmp(real_cwd,o->real_cwd))

	 continue;

      // borrow the connection

      MoveConnectionHere(o);

      break;

   }

   return need_sleep;

}

int SFtp::Do()

{

   int m=STALL;

   const char *b;

   int s;

   // check if idle time exceeded

   if(mode==CLOSED && send_buf && idle_timer.Stopped())

   {

      LogNote(1,_("Closing idle connection"));

      Disconnect();

      return m;

   }

   if(Error())

      return m;

   if(!hostname)

      return m;

   if(send_buf && send_buf->Error())

   {

      LogError(0,"send: %s",send_buf->ErrorText());

      Disconnect(send_buf->ErrorText());

      return MOVED;

   }

   if(state!=CONNECTING_1 && state!=CONNECTING_2)

      m|=HandleReplies();

   if(Error())

      return m;

   if(send_buf)

      timeout_timer.Reset(send_buf->EventTime());

   if(recv_buf)

      timeout_timer.Reset(recv_buf->EventTime());

   if(pty_send_buf)

      timeout_timer.Reset(pty_send_buf->EventTime());

   if(pty_recv_buf)

      timeout_timer.Reset(pty_recv_buf->EventTime());

   // check for timeout only if there should be connection activity.

   if(state!=DISCONNECTED && state!=CONNECTED

   && mode!=CLOSED && CheckTimeout())

      return MOVED;

   if((state==FILE_RECV || state==FILE_SEND)

   && rate_limit==0)

      rate_limit=new RateLimit(hostname);

   switch(state)

   {

   case DISCONNECTED:

   {

      if(mode==CLOSED)

	 return m;

      if(mode==CONNECT_VERIFY)

	 return m;

      // walk through SFtp classes and try to find identical idle session

      // first try "easy" cases of session take-over.

      for(int i=0; i<3; i++)

      {

	 bool limit_reached=(connection_limit>0

			    && connection_limit<=CountConnections());

	 if(i>=2 && !limit_reached)

	    break;

	 bool need_sleep=GetBetterConnection(i,limit_reached);

	 if(state!=DISCONNECTED)

	    return MOVED;

	 if(need_sleep)

	    return m;

      }

      if(!ReconnectAllowed())

	 return m;

      if(!NextTry())

	 return MOVED;

      const char *init=Query("server-program",hostname);

      const char *prog=Query("connect-program",hostname);

      if(!prog || !prog[0])

	 prog="ssh -a -x";

      ArgV args;

      if(!strchr(init,'/'))

      {

	 if(init[0])

	    args.Add("-s");   // run ssh2 subsystem

	 // sftpd does not have a greeting

	 received_greeting=true;

      }

      else

	 init=xstring::cat("echo SFTP: >&2;",init,NULL);

      if(user)

      {

	 args.Add("-l");

	 args.Add(user);

      }

      if(portname)

      {

	 args.Add("-p");

	 args.Add(portname);

      }

      args.Add(hostname);

      if(init[0])

	 args.Add(init);

      xstring_ca cmd_q(args.CombineShellQuoted(0));

      xstring& cmd_str=xstring::cat(prog," ",cmd_q.get(),NULL);

      LogNote(9,"%s (%s)",_("Running connect program"),cmd_str.get());

      ssh=new PtyShell(cmd_str);

      ssh->UsePipes();

      state=CONNECTING;

      timeout_timer.Reset();

      m=MOVED;

   }

   case CONNECTING:

   {

      int fd=ssh->getfd();

      if(fd==-1)

      {

	 if(ssh->error())

	 {

	    SetError(FATAL,ssh->error_text);

	    return MOVED;

	 }

	 TimeoutS(1);

	 return m;

      }

      MakePtyBuffers();

      set_real_cwd("~");

      state=CONNECTING_1;

      m=MOVED;

   }

   case CONNECTING_1:

      m|=HandleSSHMessage();

      if(state!=CONNECTING_1)

	 return MOVED;

      if(!received_greeting)

	 return m;

      SendRequest(new Request_INIT(Query("protocol-version",hostname)),Expect::FXP_VERSION);

      state=CONNECTING_2;

      return MOVED;

   case CONNECTING_2:

      m|=HandleSSHMessage();

      if(state!=CONNECTING_2)

	 return MOVED;

      m|=HandleReplies();

      if(protocol_version==0)

	 return m;

      if(home_auto==0)

	 SendRequest(new Request_REALPATH("."),Expect::HOME_PATH);

      state=CONNECTED;

      m=MOVED;

   case CONNECTED:

      if(home.path==0 && !RespQueueIsEmpty())

	 return m;

      if(mode==CLOSED)

	 return m;

      SendRequest();

      return MOVED;

   case FILE_RECV:

      if(file_buf->Size()>=rate_limit->BytesAllowedToGet())

      {

	 recv_buf->Suspend();

	 Timeout(1000);

      }

      else if(file_buf->Size()>=max_buf)

      {

	 recv_buf->Suspend();

	 m=MOVED;

      }

      else if(recv_buf->IsSuspended())

      {

	 recv_buf->Resume();

	 if(recv_buf->Size()>0 || (recv_buf->Size()==0 && recv_buf->Eof()))

	    m=MOVED;

      }

      break;

   case FILE_SEND:

      // pack data from file_buf.

      file_buf->Get(&b,&s);

      if(s==0 && !eof)

	 return m;

      if(s

	 return m;   // wait for more data before sending.

      if(RespQueueSize()>max_packets_in_flight)

	 return m;

      if(s==0)

      {

	 // no more data, set attributes and close the file.

	 Request_FSETSTAT *req=new Request_FSETSTAT(handle,protocol_version);

	 if(entity_date!=NO_DATE) {

	    req->attrs.mtime=entity_date;

	    req->attrs.flags|=SSH_FILEXFER_ATTR_MODIFYTIME;

	 }

	 req->attrs.size=pos;

	 req->attrs.flags|=SSH_FILEXFER_ATTR_SIZE;

	 SendRequest(req,Expect::IGNORE);

	 CloseHandle(Expect::DEFAULT);

	 state=WAITING;

	 m=MOVED;

	 break;

      }

      if(s>size_write)

	 s=size_write;

      SendRequest(new Request_WRITE(handle,request_pos,b,s),Expect::WRITE_STATUS);

      file_buf->Skip(s);

      request_pos+=s;

      flush_timer.Reset();

      m=MOVED;

      break;

   case WAITING:

      if(mode==ARRAY_INFO)

	 SendArrayInfoRequests();

      break;

   case DONE:

      break;

   }

   return m;

}

void SFtp::MoveConnectionHere(SFtp *o)

{

   super::MoveConnectionHere(o);

   protocol_version=o->protocol_version;

   recv_translate=o->recv_translate.borrow();

   send_translate=o->send_translate.borrow();

   rate_limit=o->rate_limit.borrow();

   expect_queue.move_here(o->expect_queue);

   timeout_timer.Reset(o->timeout_timer);

   ssh_id=o->ssh_id;

   state=CONNECTED;

   o->Disconnect();

   if(!home)

      set_home(home_auto);

   ResumeInternal();

}

void SFtp::DisconnectLL()

{

   super::DisconnectLL();

   handle.set(0);

   file_buf=0;

   EmptyRespQueue();

   state=DISCONNECTED;

   if(mode==STORE)

      SetError(STORE_FAILED);

   protocol_version=0;

   send_translate=0;

   recv_translate=0;

   ssh_id=0;

   home_auto.set(FindHomeAuto());

   // may have to resend file info queries.

   if(fileset_for_info)

      fileset_for_info->rewind();

}

void SFtp::Init()

{

   state=DISCONNECTED;

   ssh_id=0;

   eof=false;

   received_greeting=false;

   password_sent=0;

   protocol_version=0;

   send_translate=0;

   recv_translate=0;

   max_packets_in_flight=16;

   max_packets_in_flight_slow_start=1;

   size_read=0x8000;

   size_write=0x8000;

   use_full_path=false;

   flush_timer.Set(0,500);

}

SFtp::SFtp() : SSH_Access("SFTP:")

{

   Init();

   Reconfig(0);

}

SFtp::~SFtp()

{

   Disconnect();

   Close();

}

SFtp::SFtp(const SFtp *o) : super(o)

{

   Init();

   Reconfig(0);

}

bool SFtp::Packet::HasID()

{

   return(type!=SSH_FXP_INIT && type!=SSH_FXP_VERSION);

}

void SFtp::Packet::PackString(Buffer *b,const char *str,int len)

{

   if(len==-1)

      len=strlen(str);

   b->PackUINT32BE(len);

   b->Put(str,len);

}

SFtp::unpack_status_t SFtp::Packet::UnpackString(const Buffer *b,int *offset,int limit,xstring *str_out)

{

   if(limit-*offset<4)

   {

      // We unpack strings when we have already received complete packet,

      // so it is not possible to receive any more data.

      LogError(2,"bad string in reply (truncated length field)");

      return UNPACK_WRONG_FORMAT;

   }

   int len=b->UnpackUINT32BE(*offset);

   if(len>limit-*offset-4)

   {

      LogError(2,"bad string in reply (invalid length field)");

      return UNPACK_WRONG_FORMAT;

   }

   *offset+=4;

   const char *data;

   int data_len;

   b->Get(&data,&data_len);

   str_out->nset(data+*offset,len);

   *offset+=len;

   return UNPACK_SUCCESS;

}

SFtp::unpack_status_t SFtp::Packet::Unpack(const Buffer *b)

{

   unpacked=0;

   if(b->Size()<4)

      return b->Eof()?UNPACK_PREMATURE_EOF:UNPACK_NO_DATA_YET;

   length=b->UnpackUINT32BE(0);

   unpacked+=4;

   if(length<1)

      return UNPACK_WRONG_FORMAT;

   if(b->Size()

      return b->Eof()?UNPACK_PREMATURE_EOF:UNPACK_NO_DATA_YET;

   int t=b->UnpackUINT8(4);

   unpacked++;

   if(!is_valid_reply(t))

      return UNPACK_WRONG_FORMAT;

   type=(packet_type)t;

   if(HasID())

   {

      if(length<5)

	 return UNPACK_WRONG_FORMAT;

      id=b->UnpackUINT32BE(5);

      unpacked+=4;

   }

   else

   {

      id=0;

   }

   return UNPACK_SUCCESS;

}

SFtp::unpack_status_t SFtp::UnpackPacket(Buffer *b,SFtp::Packet **p)

{

   Packet *&pp=*p;

   pp=0;

   Packet probe;

   unpack_status_t res=probe.Unpack(b);

   if(res!=UNPACK_SUCCESS)

      return res;

   LogRecvF(9,"got a packet, length=%d, type=%d(%s), id=%u\n",

      probe.GetLength(),probe.GetPacketType(),probe.GetPacketTypeText(),probe.GetID());

   switch(probe.GetPacketType())

   {

   case SSH_FXP_VERSION:

      pp=new Reply_VERSION();

      break;

   case SSH_FXP_NAME:

      pp=new Reply_NAME(protocol_version);

      break;

   case SSH_FXP_ATTRS:

      pp=new Reply_ATTRS(protocol_version);

      break;

   case SSH_FXP_STATUS:

      pp=new Reply_STATUS(protocol_version);

      break;

   case SSH_FXP_HANDLE:

      pp=new Reply_HANDLE();

      break;

   case SSH_FXP_DATA:

      pp=new Reply_DATA();

      break;

   case SSH_FXP_INIT:

   case SSH_FXP_OPEN:

   case SSH_FXP_CLOSE:

   case SSH_FXP_READ:

   case SSH_FXP_WRITE:

   case SSH_FXP_LSTAT:

   case SSH_FXP_FSTAT:

   case SSH_FXP_SETSTAT:

   case SSH_FXP_FSETSTAT:

   case SSH_FXP_OPENDIR:

   case SSH_FXP_READDIR:

   case SSH_FXP_REMOVE:

   case SSH_FXP_MKDIR:

   case SSH_FXP_RMDIR:

   case SSH_FXP_REALPATH:

   case SSH_FXP_STAT:

   case SSH_FXP_RENAME:

   case SSH_FXP_READLINK:

   case SSH_FXP_SYMLINK:

   case SSH_FXP_LINK:

   case SSH_FXP_BLOCK:

   case SSH_FXP_UNBLOCK:

   case SSH_FXP_EXTENDED:

      LogError(0,"request in reply??");

      return UNPACK_WRONG_FORMAT;

   case SSH_FXP_EXTENDED_REPLY:

      LogError(0,"unexpected SSH_FXP_EXTENDED_REPLY");

      return UNPACK_WRONG_FORMAT;

   }

   res=pp->Unpack(b);

   if(res!=UNPACK_SUCCESS)

   {

      switch(res)

      {

      case UNPACK_PREMATURE_EOF:

	 LogError(0,"premature eof");

	 break;

      case UNPACK_WRONG_FORMAT:

	 LogError(0,"wrong packet format");

	 break;

      case UNPACK_NO_DATA_YET:

      case UNPACK_SUCCESS:

	 ;

      }

      probe.DropData(b);

      delete pp;

      pp=0;

   }

   return res;

}

void SFtp::SendRequest(Packet *request,Expect::expect_t tag,int i)

{

   request->SetID(ssh_id++);

   request->ComputeLength();

   LogSendF(9,"sending a packet, length=%d, type=%d(%s), id=%u\n",

      request->GetLength(),request->GetPacketType(),request->GetPacketTypeText(),request->GetID());

   request->Pack(send_buf.get_non_const());

   PushExpect(new Expect(request,tag,i));

}

const char *SFtp::SkipHome(const char *path)

{

   if(path[0]=='~' && path[1]=='/' && path[2])

      return path+2;

   if(path[0]=='~' && !path[1])

      return ".";

   if(!home)

      return path;

   int home_len=home.path.length();

   if(strncmp(home,path,home_len))

      return path;

   if(path[home_len]=='/' && path[home_len+1] && path[home_len+1]!='/')

      return path+home_len+1;

   if(!path[home_len])

      return ".";

   return path;

}

const char *SFtp::WirePath(const char *path)

{

   path=dir_file(cwd,path);

   if(!use_full_path || path[0]=='~')

      path=SkipHome(path);

   LogNote(9,"path on wire is `%s'",path);

   return lc_to_utf8(path);

}

void SFtp::SendRequest()

{

   max_packets_in_flight_slow_start=1;

   ExpandTildeInCWD();

   switch((open_mode)mode)

   {

   case CHANGE_DIR:

      LogNote(9,"checking directory `%s'",file.get());

      SendRequest(new Request_STAT(lc_to_utf8(file),0,protocol_version),Expect::CWD);

      SendRequest(new Request_STAT(lc_to_utf8(dir_file(file,".")),0,protocol_version),Expect::CWD);

      state=WAITING;

      break;

   case RETRIEVE:

      SendRequest(new Request_OPEN(WirePath(file),SSH_FXF_READ,

	 ACE4_READ_DATA|ACE4_READ_ATTRIBUTES,SSH_FXF_OPEN_EXISTING,protocol_version),Expect::HANDLE);

      state=WAITING;

      break;

   case LIST:

   case LONG_LIST:

      SendRequest(new Request_OPENDIR(WirePath(file)),Expect::HANDLE);

      state=WAITING;

      break;

   case STORE:

      SendRequest(

	 new Request_OPEN(WirePath(file),

	    SSH_FXF_WRITE|SSH_FXF_CREAT|(pos==0?SSH_FXF_TRUNC:0),

	    ACE4_WRITE_DATA|ACE4_WRITE_ATTRIBUTES,

	    pos==0?SSH_FXF_CREATE_TRUNCATE:SSH_FXF_OPEN_OR_CREATE,

	    protocol_version),

	 Expect::HANDLE);

      state=WAITING;

      break;

   case ARRAY_INFO:

      state=WAITING;

      break;

   case RENAME:

   {

      if(protocol_version<3)

      {

	 SetError(NOT_SUPP);

	 break;

      }

      unsigned options=0;

      if(rename_f) {

	 options=SSH_FXF_RENAME_OVERWRITE;

	 if(protocol_version<5) {

	    // overwrite is not supported, remove the target explicitly

	    SendRequest(new Request_REMOVE(WirePath(file1)),Expect::IGNORE);

	 }

      }

      SendRequest(new Request_RENAME(WirePath(file),WirePath(file1),

			options,protocol_version),Expect::DEFAULT);

      state=WAITING;

      break;

   }

   case CHANGE_MODE:

   {

      Request_SETSTAT *req=new Request_SETSTAT(WirePath(file),protocol_version);

      req->attrs.permissions=chmod_mode;

      req->attrs.flags|=SSH_FILEXFER_ATTR_PERMISSIONS;

      SendRequest(req,Expect::DEFAULT);

      state=WAITING;

      break;

   }

   case MAKE_DIR:

      if(mkdir_p)

      {

	 Ref<StringSet> dirs(MkdirMakeSet());

	 for(int i=0; i<dirs->Count(); i++)

	    SendRequest(new Request_MKDIR(WirePath(dirs->String(i)),protocol_version),Expect::IGNORE);

      }

      SendRequest(new Request_MKDIR(WirePath(file),protocol_version),Expect::DEFAULT);

      state=WAITING;

      break;

   case REMOVE_DIR:

      SendRequest(new Request_RMDIR(WirePath(file)),Expect::DEFAULT);

      state=WAITING;

      break;

   case REMOVE:

      SendRequest(new Request_REMOVE(WirePath(file)),Expect::DEFAULT);

      state=WAITING;

      break;

   case LINK:

      if(protocol_version<6) {

	 SetError(NOT_SUPP);

	 break;

      }

   case SYMLINK:

      if(protocol_version<3) {

	 SetError(NOT_SUPP);

	 break;

      }

      if(protocol_version>=6)

	 SendRequest(new Request_LINK(mode==SYMLINK?lc_to_utf8(file):WirePath(file),WirePath(file1),mode==SYMLINK),Expect::DEFAULT);

      else

	 SendRequest(new Request_SYMLINK(lc_to_utf8(file),WirePath(file1)),Expect::DEFAULT);

      state=WAITING;

      break;

   case QUOTE_CMD:

   case MP_LIST:

      SetError(NOT_SUPP);

      break;

   case CONNECT_VERIFY:

   case CLOSED:

      abort();

   }

}

void SFtp::SendArrayInfoRequests()

{

   for(FileInfo *fi=fileset_for_info->curr();

      fi && RespQueueSize()

      fi=fileset_for_info->next())

   {

      if(fi->need&(fi->SIZE|fi->DATE|fi->MODE|fi->TYPE|fi->USER|fi->GROUP)) {

	 unsigned flags=0;

	 if(fi->need&fi->SIZE) flags|=SSH_FILEXFER_ATTR_SIZE;

	 if(fi->need&fi->DATE) flags|=SSH_FILEXFER_ATTR_MODIFYTIME;

	 if(fi->need&fi->MODE) flags|=SSH_FILEXFER_ATTR_PERMISSIONS;

	 if(fi->need&(fi->USER|fi->GROUP)) flags|=SSH_FILEXFER_ATTR_OWNERGROUP;

	 SendRequest(new Request_STAT(WirePath(fi->name),flags,

	    protocol_version),Expect::INFO,fileset_for_info->curr_index());

      }

      if(fi->need&fi->SYMLINK_DEF && protocol_version>=3)

	 SendRequest(new Request_READLINK(WirePath(fi->name)),

	    Expect::INFO_READLINK,fileset_for_info->curr_index());

   }

   if(RespQueueIsEmpty())

      state=DONE;

}

void SFtp::CloseHandle(Expect::expect_t c)

{

   if(handle)

   {

      SendRequest(new Request_CLOSE(handle),c);

      handle.set(0);

   }

}

void SFtp::Close()

{

   switch(state)

   {

   case(DISCONNECTED):

   case(WAITING):

   case(CONNECTED):

   case(DONE):

   case(FILE_RECV):

   case(FILE_SEND):

      break;

   case(CONNECTING):

   case(CONNECTING_1):

   case(CONNECTING_2):

      Disconnect();

   }

   CloseExpectQueue();

   state=(recv_buf?CONNECTED:DISCONNECTED);

   eof=false;

   file_buf=0;

   file_set=0;

   CloseHandle(Expect::IGNORE);

   super::Close();

   // don't need these out-of-order packets anymore

   ooo_chain.truncate();

   if(recv_buf)

      recv_buf->Resume();

}

int SFtp::HandlePty()

{

   int m=STALL;

   if(pty_recv_buf==0)

      return m;

   const char *b;

   int s;

   pty_recv_buf->Get(&b,&s);

   const char *eol=(const char*)memchr(b,'\n',s);

   if(!eol)

   {

      if(pty_recv_buf->Eof())

	 LogError(0,_("Peer closed connection"));

      if(pty_recv_buf->Error())

	 LogError(0,"pty read: %s",pty_recv_buf->ErrorText());

      if(pty_recv_buf->Eof() || pty_recv_buf->Error())

      {

	 Disconnect(pty_recv_buf->ErrorText());

	 m=MOVED;

      }

      return m;

   }

   m=MOVED;

   s=eol-b+1;

   char *line=string_alloca(s);

   memcpy(line,b,s-1);

   line[s-1]=0;

   pty_recv_buf->Skip(s);

   LogRecv(4,line);

   return m;

}

void SFtp::HandleExpect(Expect *e)

{

   const Packet *reply=e->reply;

   if(reply->TypeIs(SSH_FXP_STATUS))

   {

      Reply_STATUS *r=(Reply_STATUS*)reply;

      const char *message=r->GetMessage();

      LogNote(9,"status code=%d(%s), message=%s",r->GetCode(),r->GetCodeText(),

	 message?message:"NULL");

   }

   switch(e->tag)

   {

   case Expect::FXP_VERSION:

      if(reply->TypeIs(SSH_FXP_VERSION))

      {

	 protocol_version=((Reply_VERSION*)reply)->GetVersion();

	 LogNote(9,"protocol version set to %d",protocol_version);

	 const char *charset=0;

	 if(protocol_version>=4)

	    charset="UTF-8";

	 else

	    charset=ResMgr::Query("sftp:charset",hostname);

	 if(charset && *charset)

	 {

	    send_translate=new DirectedBuffer(DirectedBuffer::PUT);

	    recv_translate=new DirectedBuffer(DirectedBuffer::GET);

	    send_translate->SetTranslation(charset,false);

	    recv_translate->SetTranslation(charset,true);

	 }

      }

      else

      {

	 Disconnect();

	 SetError(FATAL,"cannot negotiate protocol version");

      }

      break;

   case Expect::HOME_PATH:

      if(reply->TypeIs(SSH_FXP_NAME))

      {

	 Reply_NAME *r=(Reply_NAME*)reply;

	 const NameAttrs *a=r->GetNameAttrs(0);

	 if(a && !home_auto)

	 {

	    home_auto.set(utf8_to_lc(a->name));

	    LogNote(9,"home set to %s",home_auto.get());

	    PropagateHomeAuto();

	    if(!home)

	       set_home(home_auto);

	    cache->SetDirectory(this, home, true);

	 }

      }

      break;

   case Expect::CWD:

      if(reply->TypeIs(SSH_FXP_ATTRS))

      {

	 const FileAttrs *a=((Reply_ATTRS*)reply)->GetAttrs();

	 if(a->type!=SSH_FILEXFER_TYPE_DIRECTORY

	 && a->type!=SSH_FILEXFER_TYPE_SYMLINK)	// workaround for RouterOS v6

	 {

	    LogError(1,"got file type %d",a->type);

	    cache->SetDirectory(this,cwd,false);

	    SetError(NO_FILE,strerror(ENOTDIR));

	    break;

	 }

	 if(mode==CHANGE_DIR && GetExpectCount(Expect::CWD)==0)

	 {

	    cwd.Set(file);

	    eof=true;

	    cache->SetDirectory(this,cwd,true);

	 }

      }

      else

	 SetError(NO_FILE,reply);

      break;

   case Expect::HANDLE:

      if(reply->TypeIs(SSH_FXP_HANDLE))

      {

	 handle.set(((Reply_HANDLE*)reply)->GetHandle());

	 state=(mode==STORE?FILE_SEND:FILE_RECV);

	 file_buf=new Buffer;

	 xstring handle_x("");

	 int handle_len=handle.length();

	 for(int i=0; i

	    handle_x.appendf("%02X",(unsigned char)handle[i]);

	 LogNote(9,"got file handle %s (%d)",handle_x.get(),handle_len);

	 request_pos=real_pos=pos;

	 if(mode==RETRIEVE) {

	    SendRequest(new Request_FSTAT(handle,

	       SSH_FILEXFER_ATTR_SIZE|SSH_FILEXFER_ATTR_MODIFYTIME|SSH_FILEXFER_ATTR_PERMISSIONS,

	       protocol_version),Expect::INFO);

	 }

      }

      else

	 SetError(NO_FILE,reply);

      break;

   case Expect::HANDLE_STALE:

      if(reply->TypeIs(SSH_FXP_HANDLE))

      {

	 // close the handle immediately.

	 const xstring &handle=((Reply_HANDLE*)reply)->GetHandle();

	 SendRequest(new Request_CLOSE(handle),Expect::IGNORE);

      }

      break;

   case Expect::DATA:

      if(max_packets_in_flight_slow_start

	 max_packets_in_flight_slow_start++;

      if(reply->TypeIs(SSH_FXP_DATA))

      {

	 const Request_READ *r=e->request.Cast<Request_READ>();

	 Reply_DATA *d=(Reply_DATA*)reply;

	 if(r->pos==pos+file_buf->Size())

	 {

	    const char *b; int s;

	    d->GetData(&b,&s);

	    LogNote(9,"data packet: pos=%lld, size=%d",(long long)r->pos,s);

	    file_buf->Put(b,s);

	    if(d->Eof())

	       goto eof;