/*

 * 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 <sys/types.h>

#include <sys/stat.h>

#include <errno.h>

#include <fcntl.h>

#include <unistd.h>

#include <assert.h>

#include <mbswidth.h>

#include "MirrorJob.h"

#include "CmdExec.h"

#include "rmJob.h"

#include "mvJob.h"

#include "ChmodJob.h"

#include "mkdirJob.h"

#include "misc.h"

#include "plural.h"

#include "FindJob.h"

#include "url.h"

#include "CopyJob.h"

#include "pgetJob.h"

#include "log.h"

#define set_state(s) do { state=(s); \

   Log::global->Format(11,"mirror(%p) enters state %s\n", this, #s); } while(0)

#define waiting_num waiting.count()

#define transfer_count root_mirror->root_transfer_count

xstring& MirrorJob::FormatStatus(xstring& s,int v,const char *tab)

{

   if(Done())

      goto final;

   switch(state)

   {

   case(INITIAL_STATE):

   case(FINISHING):

   case(DONE):

   case(WAITING_FOR_TRANSFER):

   case(TARGET_REMOVE_OLD):

   case(TARGET_REMOVE_OLD_FIRST):

   case(TARGET_CHMOD):

   case(TARGET_MKDIR):

   case(SOURCE_REMOVING_SAME):

   case(LAST_EXEC):

      break;

   case(MAKE_TARGET_DIR):

      s.appendf("\tmkdir `%s' [%s]\n",target_dir.get(),target_session->CurrentStatus());

      break;

   case(CHANGING_DIR_SOURCE):

   case(CHANGING_DIR_TARGET):

      if(target_session->IsOpen())

	 s.appendf("\tcd `%s' [%s]\n",target_dir.get(),target_session->CurrentStatus());

      if(source_session->IsOpen())

	 s.appendf("\tcd `%s' [%s]\n",source_dir.get(),source_session->CurrentStatus());

      break;

   case(GETTING_LIST_INFO):

      if(target_list_info)

      {

	 if(target_relative_dir)

	    s.appendf("\t%s: %s\n",target_relative_dir.get(),target_list_info->Status());

	 else

	    s.appendf("\t%s\n",target_list_info->Status());

      }

      if(source_list_info)

      {

	 if(source_relative_dir)

	    s.appendf("\t%s: %s\n",source_relative_dir.get(),source_list_info->Status());

	 else

	    s.appendf("\t%s\n",source_list_info->Status());

      }

      break;

   }

   return s;

final:

   if(stats.dirs>0)

      s.appendf(plural("%sTotal: %d director$y|ies$, %d file$|s$, %d symlink$|s$\n",

		     stats.dirs,stats.tot_files,stats.tot_symlinks),

	 tab,stats.dirs,stats.tot_files,stats.tot_symlinks);

   if(stats.new_files || stats.new_symlinks)

      s.appendf(plural("%sNew: %d file$|s$, %d symlink$|s$\n",

		     stats.new_files,stats.new_symlinks),

	 tab,stats.new_files,stats.new_symlinks);

   if(stats.mod_files || stats.mod_symlinks)

      s.appendf(plural("%sModified: %d file$|s$, %d symlink$|s$\n",

		     stats.mod_files,stats.mod_symlinks),

	 tab,stats.mod_files,stats.mod_symlinks);

   if(stats.bytes)

      s.appendf("%s%s\n",tab,CopyJob::FormatBytesTimeRate(stats.bytes,transfer_time_elapsed));

   if(stats.del_dirs || stats.del_files || stats.del_symlinks)

      s.appendf(plural(FlagSet(DELETE) ?

	       "%sRemoved: %d director$y|ies$, %d file$|s$, %d symlink$|s$\n"

	      :"%sTo be removed: %d director$y|ies$, %d file$|s$, %d symlink$|s$\n",

	      stats.del_dirs,stats.del_files,stats.del_symlinks),

	 tab,stats.del_dirs,stats.del_files,stats.del_symlinks);

   if(stats.error_count)

      s.appendf(plural("%s%d error$|s$ detected\n",stats.error_count),

	       tab,stats.error_count);

   return s;

}

void  MirrorJob::ShowRunStatus(const SMTaskRef<StatusLine>& s)

{

   int w=s->GetWidthDelayed();

   switch(state)

   {

   case(INITIAL_STATE):

      break;

   // these have a sub-job

   case(WAITING_FOR_TRANSFER):

   case(TARGET_REMOVE_OLD):

   case(TARGET_REMOVE_OLD_FIRST):

   case(TARGET_CHMOD):

   case(TARGET_MKDIR):

   case(SOURCE_REMOVING_SAME):

   case(FINISHING):

   case(DONE):

   case(LAST_EXEC):

      Job::ShowRunStatus(s);

      break;

   case(MAKE_TARGET_DIR):

      s->Show("mkdir `%s' [%s]",target_dir.get(),target_session->CurrentStatus());

      break;

   case(CHANGING_DIR_SOURCE):

   case(CHANGING_DIR_TARGET):

      if(target_session->IsOpen() && (!source_session->IsOpen() || now%4>=2))

	 s->Show("cd `%s' [%s]",target_dir.get(),target_session->CurrentStatus());

      else if(source_session->IsOpen())

	 s->Show("cd `%s' [%s]",source_dir.get(),source_session->CurrentStatus());

      break;

   case(GETTING_LIST_INFO):

      if(target_list_info && (!source_list_info || now%4>=2))

      {

	 const char *status=target_list_info->Status();

	 int status_w=mbswidth(status, 0);

	 int dw=w-status_w;

	 if(dw<20)

	    dw=20;

	 if(target_relative_dir)

	    s->Show("%s: %s",squeeze_file_name(target_relative_dir,dw),status);

	 else

	    s->Show("%s",status);

      }

      else if(source_list_info)

      {

	 const char *status=source_list_info->Status();

	 int status_w=mbswidth(status, 0);

	 int dw=w-status_w;

	 if(dw<20)

	    dw=20;

	 if(source_relative_dir)

	    s->Show("%s: %s",squeeze_file_name(source_relative_dir,dw),status);

	 else

	    s->Show("%s",status);

      }

      break;

   }

}

xstring& MirrorJob::FormatShortStatus(xstring& s)

{

   if(bytes_to_transfer>0 && (!parent_mirror || parent_mirror->bytes_to_transfer!=bytes_to_transfer)) {

      long long curr_bytes_transferred=GetBytesCount();

      if(parent_mirror)

         curr_bytes_transferred+=bytes_transferred;

      s.appendf("%s/%s (%d%%)",

	 xhuman(curr_bytes_transferred),xhuman(bytes_to_transfer),

	 percent(curr_bytes_transferred,bytes_to_transfer));

      double rate=GetTransferRate();

      if(rate>=1)

	 s.append(' ').append(Speedometer::GetStrProper(rate));

   }

   return s;

}

void MirrorJob::TransferStarted(CopyJob *cp)

{

   if(transfer_count==0)

      root_mirror->transfer_start_ts=now;

   JobStarted(cp);

}

void MirrorJob::JobStarted(Job *j)

{

   AddWaiting(j);

   transfer_count++;

}

void MirrorJob::TransferFinished(Job *j)

{

   long long bytes_count=j->GetBytesCount();

   AddBytesTransferred(bytes_count);

   stats.bytes+=bytes_count;

   stats.time +=j->GetTimeSpent();

   if(j->ExitCode()==0 && verbose_report>=2) {

      xstring finished;

      const xstring& cmd=j->GetCmdLine();

      if(cmd[0]=='\\')

	 finished.append(cmd+1,cmd.length()-1);

      else

	 finished.append(cmd);

      const xstring& rate=Speedometer::GetStrProper(j->GetTransferRate());

      if(rate.length()>0)

	 finished.append(" (").append(rate).append(')');

      if(!(FlagSet(SCAN_ALL_FIRST) && finished.begins_with("mirror")))

	 Report(_("Finished %s"),finished.get());

   }

   JobFinished(j);

   if(transfer_count==0)

      root_mirror->transfer_time_elapsed += now-root_mirror->transfer_start_ts;

}

void MirrorJob::JobFinished(Job *j)

{

   if(j->ExitCode()!=0)

      stats.error_count++;

   RemoveWaiting(j);

   Delete(j);

   assert(transfer_count>0);

   transfer_count--;

}

off_t MirrorJob::GetBytesCount()

{

   long long bytes_count=Job::GetBytesCount();

   if(!parent_mirror) {

      // bytes_transferred is cumulative over the mirror tree,

      // add it on the top only

      bytes_count+=bytes_transferred;

   }

   return bytes_count;

}

double MirrorJob::GetTimeSpent()

{

   double t=transfer_time_elapsed;

   if(transfer_count>0)

      t+=now-root_mirror->transfer_start_ts;

   return t;

}

void  MirrorJob::HandleFile(FileInfo *file)

{

   int	 res;

   struct stat st;

   // TODO: get rid of local hacks.

   const char *dst_name=file->name;

   if(FlagSet(TARGET_FLAT))

      dst_name=basename_ptr(dst_name);

   // dir_name returns pointer to static data - need to dup it.

   const char *source_name=dir_file(source_dir,file->name);

   source_name=alloca_strdup(source_name);

   const char *target_name=dir_file(target_dir,dst_name);

   target_name=alloca_strdup(target_name);

   const char *source_name_rel=dir_file(source_relative_dir,file->name);

   source_name_rel=alloca_strdup(source_name_rel);

   const char *target_name_rel=dir_file(target_relative_dir,dst_name);

   target_name_rel=alloca_strdup(target_name_rel);

   FileInfo::type filetype=FileInfo::NORMAL;

   if(file->Has(file->TYPE))

      filetype=file->filetype;

   else

   {

      FileInfo *target=target_set->FindByName(file->name);

      if(target && target->Has(target->TYPE))

	 filetype=target->filetype;

   }

   switch(filetype)

   {

      case(FileInfo::NORMAL):

      case(FileInfo::REDIRECT):

      {

	 bool remove_target=false;

	 bool cont_this=false;

	 bool use_pget=(pget_n>1) && target_is_local;

	 if(file->Has(file->SIZE) && file->size

	    use_pget=false;

	 if(target_is_local)

	 {

	    if(lstat(target_name,&st)!=-1)

	    {

	       // few safety checks.

	       FileInfo *old=new_files_set->FindByName(file->name);

	       if(old)

		  goto skip;  // file has appeared after mirror start

	       old=old_files_set->FindByName(file->name);

	       if(old && ((old->Has(old->SIZE) && old->size!=st.st_size)

			||(old->Has(old->DATE) && old->date!=st.st_mtime)))

		  goto skip;  // the file has changed after mirror start

	       if(!script_only && access(target_name,W_OK)==-1)

	       {

		  // try to enable write access.

		  chmod(target_name,st.st_mode|0200);

	       }

	    }

	 }

	 FileInfo *old=target_set->FindByName(FileCopy::TempFileName(file->name));

	 if(old)

	 {

	    if(FlagSet(CONTINUE)

	    && old->Has(file->TYPE) && old->filetype==old->NORMAL

	    && (FlagSet(IGNORE_TIME) ||

		(file->Has(file->DATE) && old->Has(old->DATE)

		&& file->date + file->date.ts_prec < old->date - old->date.ts_prec))

	    && file->Has(file->SIZE) && old->Has(old->SIZE)

	    && file->size >= old->size)

	    {

	       cont_this=true;

	       stats.mod_files++;

	    }

	    else if(!to_rm_mismatched->FindByName(file->name))

	    {

	       if(!FlagSet(OVERWRITE)) {

		  remove_target=true;

		  Report(_("Removing old file `%s'"),target_name_rel);

	       } else {

		  Report(_("Overwriting old file `%s'"),target_name_rel);

	       }

	       stats.mod_files++;

	    }

	    else

	       stats.new_files++;

	 }

	 else if(FlagSet(ONLY_EXISTING))

	 {

	    Report(_("Skipping file `%s' (only-existing)"),source_name_rel);

	    goto skip;

	 }

	 else

	    stats.new_files++;

	 Report(_("Transferring file `%s'"),source_name_rel);

	 if(script)

	 {

	    ArgV args(use_pget?"pget":"get");

	    if(use_pget)

	    {

	       args.Append("-n");

	       args.Append(pget_n);

	    }

	    if(cont_this)

	       args.Append("-c");

	    if(remove_target)

	       args.Append("-e");

	    if(FlagSet(ASCII))

	       args.Append("-a");

	    if(remove_source_files)

	       args.Append("-E");

	    args.Append("-O");

	    args.Append(target_is_local?target_dir.get()

			:target_session->GetConnectURL().get());

	    args.Append(source_session->GetFileURL(file->name));

	    xstring_ca cmd(args.CombineQuoted());

	    fprintf(script,"%s\n",cmd.get());

	    if(script_only)

	       goto skip;

	 }

	 FileCopyPeer *src_peer=0;

	 if(source_is_local)

	    src_peer=new FileCopyPeerFDStream(new FileStream(source_name,O_RDONLY),FileCopyPeer::GET);

	 else

	    src_peer=new FileCopyPeerFA(source_session->Clone(),file->name,FA::RETRIEVE);

	 FileCopyPeer *dst_peer=0;

	 if(target_is_local)

	    dst_peer=new FileCopyPeerFDStream(new FileStream(target_name,O_WRONLY|O_CREAT|(cont_this?0:O_TRUNC)),FileCopyPeer::PUT);

	 else

	    dst_peer=new FileCopyPeerFA(target_session->Clone(),dst_name,FA::STORE);

	 FileCopy *c=FileCopy::New(src_peer,dst_peer,cont_this);

	 if(remove_source_files)

	    c->RemoveSourceLater();

	 if(remove_target)

	    c->RemoveTargetFirst();

	 if(FlagSet(ASCII))

	    c->Ascii();

	 CopyJob *cp=(use_pget ? new pgetJob(c,file->name,pget_n) : new CopyJob(c,file->name,"mirror"));

	 if(file->Has(file->DATE))

	    cp->SetDate(file->date);

	 if(file->Has(file->SIZE) && !FlagSet(IGNORE_SIZE))

	    cp->SetSize(file->size);

	 TransferStarted(cp);

	 cp->cmdline.vset("\\transfer `",source_name_rel,"'",NULL);

	 set_state(WAITING_FOR_TRANSFER);

	 break;

      }

      case(FileInfo::DIRECTORY):

      {

	 if(recursion_mode==RECURSION_NEVER || FlagSet(NO_RECURSION))

	    goto skip;

	 bool create_target_subdir=true;

	 const FileInfo *old=0;

	 if(FlagSet(TARGET_FLAT)) {

	    create_target_subdir=false;

	    target_name=target_dir;

	    goto do_submirror;

	 }

	 if(target_set)

	    old=target_set->FindByName(file->name);

	 if(!old)

	 {

	    if(FlagSet(ONLY_EXISTING))

	    {

	       Report(_("Skipping directory `%s' (only-existing)"),target_name_rel);

	       goto skip;

	    }

	 }

	 else if(old->TypeIs(old->DIRECTORY))

	 {

	    create_target_subdir=false;

	 }

	 if(target_is_local && !script_only)

	 {

	    if((FlagSet(RETR_SYMLINKS)?stat:lstat)(target_name,&st)!=-1)

	    {

	       if(S_ISDIR(st.st_mode))

	       {

		  // try to enable write access

		  // only if not enabled as chmod can clear sgid flags on directories

		  if(st.st_mode!=(st.st_mode|0700))

		     chmod(target_name,st.st_mode|0700);

		  create_target_subdir=false;

	       }

	       else

	       {

		  Report(_("Removing old local file `%s'"),target_name_rel);

		  if(remove(target_name)==-1)

		  {

		     eprintf("mirror: remove(%s): %s\n",target_name,strerror(errno));

		     goto skip;

		  }

		  create_target_subdir=true;

	       }

	    }

	 }

      do_submirror:

	 // launch sub-mirror

	 MirrorJob *mj=new MirrorJob(this,

	    source_session->Clone(),target_session->Clone(),

	    source_name,target_name);

	 AddWaiting(mj);

	 mj->cmdline.vset("\\mirror `",source_name_rel,"'",NULL);

	 mj->source_relative_dir.set(source_name_rel);

	 mj->target_relative_dir.set(target_name_rel);

	 mj->create_target_dir=create_target_subdir;

	 if(verbose_report>=3) {

	    if(FlagSet(SCAN_ALL_FIRST))

	       Report(_("Scanning directory `%s'"),mj->target_relative_dir.get());

	    else

	       Report(_("Mirroring directory `%s'"),mj->target_relative_dir.get());

	 }

	 break;

      }

      case(FileInfo::SYMLINK):

      {

	 if(FlagSet(NO_SYMLINKS))

	    goto skip;

	 if(!file->symlink)

	    goto skip;

	 if(!target_is_local)

	 {

	    if(script)

	    {

	       ArgV args("ln");

	       args.Append("-s");

	       args.Append(file->symlink);

	       args.Append(target_name);

	       xstring_ca cmd(args.CombineQuoted());

	       fprintf(script,"%s\n",cmd.get());

	       if(script_only)

		  goto skip;

	    }

	    bool remove_target=false;

	    FileInfo *old=target_set->FindByName(file->name);

	    if(old && !to_rm_mismatched->FindByName(file->name))

	    {

	       Report(_("Removing old file `%s'"),target_name_rel);

	       remove_target=true;

	       stats.mod_symlinks++;

	    }

	    else

	       stats.new_symlinks++;

	    Report(_("Making symbolic link `%s' to `%s'"),target_name_rel,file->symlink.get());

	    mvJob *j=new mvJob(target_session->Clone(),file->symlink,target_name,FA::SYMLINK);

	    if(remove_target)

	       j->RemoveTargetFirst();

	    JobStarted(j);

	    RemoveSourceLater(file);

	    break;

	 }

	 if(script)

	 {

	    ArgV args("shell");

	    args.Append("ln");

	    args.Append("-sf");

	    args.Append(shell_encode(file->symlink));

	    args.Append(shell_encode(target_name));

	    xstring_ca cmd(args.CombineQuoted());

	    fprintf(script,"%s\n",cmd.get());

	    if(script_only)

	       goto skip;

	 }

	 struct stat st;

	 if(lstat(target_name,&st)!=-1)

	 {

	    Report(_("Removing old local file `%s'"),target_name_rel);

	    stats.mod_symlinks++;

	    if(remove(target_name)==-1)

	    {

	       eprintf("mirror: remove(%s): %s\n",target_name,strerror(errno));

	       goto skip;

	    }

	 }

	 else

	 {

	    if(FlagSet(ONLY_EXISTING))

	    {

	       Report(_("Skipping symlink `%s' (only-existing)"),target_name_rel);

	       goto skip;

	    }

	    stats.new_symlinks++;

	 }

	 Report(_("Making symbolic link `%s' to `%s'"),target_name_rel,file->symlink.get());

	 res=symlink(file->symlink,target_name);

	 if(res==-1)

	    eprintf("mirror: symlink(%s): %s\n",target_name,strerror(errno));

	 RemoveSourceLater(file);

	 break;

      }

   case FileInfo::UNKNOWN:

      break;

   }

skip:

   return;

}

void  MirrorJob::InitSets()

{

   if(FlagSet(TARGET_FLAT) && !parent_mirror && target_set)

      source_set->Sort(FileSet::BYNAME_FLAT);

   source_set->Count(NULL,&stats.tot_files,&stats.tot_symlinks,&stats.tot_files);

   to_rm=new FileSet(target_set);

   to_rm->SubtractAny(source_set);

   if(FlagSet(DELETE_EXCLUDED) && target_set_excluded)

      to_rm->Merge(target_set_excluded);

   to_transfer=new FileSet(source_set);

   if(!FlagSet(TRANSFER_ALL)) {

      same=new FileSet(source_set);

      int ignore=0;

      if(FlagSet(ONLY_NEWER))

	 ignore|=FileInfo::IGNORE_SIZE_IF_OLDER|FileInfo::IGNORE_DATE_IF_OLDER;

      if(!FlagSet(UPLOAD_OLDER) && strcmp(target_session->GetProto(),"file"))

	 ignore|=FileInfo::IGNORE_DATE_IF_OLDER;

      if(FlagSet(IGNORE_TIME))

	 ignore|=FileInfo::DATE;

      if(FlagSet(IGNORE_SIZE))

	 ignore|=FileInfo::SIZE;

      to_transfer->SubtractSame(target_set,ignore);

      same->SubtractAny(to_transfer);

   }

   if(newer_than!=NO_DATE)

      to_transfer->SubtractNotNewerThan(newer_than);

   if(older_than!=NO_DATE)

      to_transfer->SubtractNotOlderThan(older_than);

   if(size_range)

      to_transfer->SubtractSizeOutside(size_range);

   if(FlagSet(SCAN_ALL_FIRST)) {

      to_mkdir=new FileSet(to_transfer);

      to_mkdir->SubtractNotDirs();

      to_mkdir->SubtractAny(target_set);

   }

   switch(recursion_mode) {

   case RECURSION_NEVER:

      to_transfer->SubtractDirs();

      break;

   case RECURSION_MISSING:

      to_transfer->SubtractDirs(target_set);

      break;

   case RECURSION_NEWER:

      to_transfer->SubtractNotOlderDirs(target_set);

      break;

   case RECURSION_ALWAYS:

      break;

   }

   if(skip_noaccess)

      to_transfer->ExcludeUnaccessible(source_session->GetUser());

   new_files_set=new FileSet(to_transfer);

   new_files_set->SubtractAny(target_set);

   old_files_set=new FileSet(target_set);

   old_files_set->SubtractNotIn(to_transfer);

   to_rm_mismatched=new FileSet(old_files_set);

   to_rm_mismatched->SubtractSameType(to_transfer);

   to_rm_mismatched->SubtractNotDirs();

   if(!FlagSet(DELETE))

      to_transfer->SubtractAny(to_rm_mismatched);

   if(FlagSet(TARGET_FLAT) && !parent_mirror && target_set) {

      source_set->Unsort();

      to_transfer->UnsortFlat();

      to_transfer->SubtractDirs();

      same->UnsortFlat();

      to_mkdir->Empty();

      new_files_set->UnsortFlat();

   }

   const char *sort_by=ResMgr::Query("mirror:sort-by",0);

   bool desc=strstr(sort_by,"-desc");

   if(!strncmp(sort_by,"name",4))

      to_transfer->SortByPatternList(ResMgr::Query("mirror:order",0));

   else if(!strncmp(sort_by,"date",4))

      to_transfer->Sort(FileSet::BYDATE);

   else if(!strncmp(sort_by,"size",4))

      to_transfer->Sort(FileSet::BYSIZE,false,true);

   if(desc)

      to_transfer->ReverseSort();

   int dir_count=0;

   if(to_mkdir) {

      to_mkdir->Count(&dir_count,NULL,NULL,NULL);

      only_dirs = (dir_count==to_mkdir->count());

   } else {

      to_transfer->Count(&dir_count,NULL,NULL,NULL);

      only_dirs = (dir_count==to_transfer->count());

   }

}

/* root_transfer_count of child mirrors contains the value to add or

   subtract from transfer_count when doing "cd", "mkdir", "ls" on the source

   or target directories. This would prevent other mirrors (siblings, etc)

   from starting more jobs.

   root_transfer_count is initialized once in ctor, so that change of

   mirror:parallel-directories setting won't disbalance the count.

*/

void MirrorJob::MirrorStarted()

{

   if(!parent_mirror)

      return;

   transfer_count+=root_transfer_count;

}

void MirrorJob::MirrorFinished()

{

   if(!parent_mirror)

      return;

   assert(transfer_count>=root_transfer_count);

   transfer_count-=root_transfer_count;

}

void MirrorJob::HandleChdir(FileAccessRef& session, int &redirections)

{

   if(!session->IsOpen())

      return;

   int res=session->Done();

   if(res<0)

   {

      if(res==FA::FILE_MOVED)

      {

	 // cd to another url.

	 const char *loc_c=session->GetNewLocation();

	 int max_redirections=ResMgr::Query("xfer:max-redirections",0);

	 if(loc_c && max_redirections>0)

	 {

	    if(++redirections>max_redirections)

	       goto cd_err_normal;

	    eprintf(_("%s: received redirection to `%s'\n"),"mirror",loc_c);

	    char *loc=alloca_strdup(loc_c);

	    ParsedURL u(loc,true);

	    bool is_file=(last_char(loc)!='/');

	    if(!u.proto)

	    {

	       FileAccess::Path new_cwd(session->GetNewCwd());

	       new_cwd.Change(0,is_file,loc);

	       session->PathVerify(new_cwd);

	       session->Roll();

	       return;

	    }

	    session->Close(); // loc_c is no longer valid.

	    session=FA::New(&u);

	    FileAccess::Path new_cwd(u.path,is_file,url::path_ptr(loc));

	    session->PathVerify(new_cwd);

	    return;

	 }

      }

   cd_err_normal:

      if(session==target_session && (script_only || FlagSet(SCAN_ALL_FIRST)))

      {

	 char *dir=alloca_strdup(session->GetFile());

	 session->Close();

	 session->Chdir(dir,false);

	 no_target_dir=true;

	 return;

      }

      if(session==source_session && create_target_dir

      && !FlagSet(NO_EMPTY_DIRS) && !skip_noaccess && parent_mirror)

      {

	 // create target dir even if failed to cd to source dir.

	 if(script)

	    fprintf(script,"mkdir %s\n",target_session->GetFileURL(target_dir).get());

	 if(!script_only)

	 {

	    ArgV *a=new ArgV("mkdir");

	    a->Append(target_dir);

	    mkdirJob *mkj=new mkdirJob(target_session->Clone(),a);

	    a->CombineTo(mkj->cmdline);

	    JobStarted(mkj);

	 }

      }

      remove_this_source_dir=false;

      eprintf("mirror: %s\n",session->StrError(res));

      stats.error_count++;

      MirrorFinished();

      set_state(FINISHING);

      source_session->Close();

      target_session->Close();

      return;

   }

   if(res==FA::OK)

      session->Close();

}

void MirrorJob::HandleListInfoCreation(const FileAccessRef& session,SMTaskRef<ListInfo>& list_info,const char *relative_dir)

{

   if(state!=GETTING_LIST_INFO)

      return;

   if(session==target_session && no_target_dir)

   {

      target_set=new FileSet();

      return;

   }

   list_info=session->MakeListInfo();

   if(list_info==0)

   {

      eprintf(_("mirror: protocol `%s' is not suitable for mirror\n"),

	       session->GetProto());

      MirrorFinished();

      set_state(FINISHING);

      return;

   }

   list_info->UseCache(use_cache);

   int need=FileInfo::ALL_INFO;

   if(FlagSet(IGNORE_TIME))

      need&=~FileInfo::DATE;

   if(FlagSet(IGNORE_SIZE))

      need&=~FileInfo::SIZE;

   list_info->Need(need);

   if(FlagSet(RETR_SYMLINKS))

      list_info->FollowSymlinks();

   list_info->SetExclude(relative_dir,top_exclude?top_exclude:exclude);

   list_info->Roll();

}

void MirrorJob::HandleListInfo(SMTaskRef<ListInfo>& list_info, Ref<FileSet>& set, Ref<FileSet> *fsx)

{

   if(!list_info)

      return;

   if(!list_info->Done())

      return;

   if(list_info->Error())

   {

      eprintf("mirror: %s\n",list_info->ErrorText());

      stats.error_count++;

      MirrorFinished();

      set_state(FINISHING);

      source_list_info=0;

      target_list_info=0;

      return;

   }

   set=list_info->GetResult();

   if(fsx)

      *fsx=list_info->GetExcluded();

   list_info=0;

   set->ExcludeDots(); // don't need .. and .

}

int   MirrorJob::Do()

{

   int	 res;

   int	 m=STALL;

   FileInfo *file;

   Job	 *j;

   switch(state)

   {

   case(INITIAL_STATE):

      remove_this_source_dir=(remove_source_dirs && source_dir.last_char()!='/');

      if(!strcmp(target_dir,".") || !strcmp(target_dir,"..") || (FlagSet(SCAN_ALL_FIRST) && parent_mirror))

	 create_target_dir=false;

      source_session->Chdir(source_dir);

      source_redirections=0;

      source_session->Roll();

      set_state(CHANGING_DIR_SOURCE);

      m=MOVED;

      /*fallthrough*/

   case(CHANGING_DIR_SOURCE):

      HandleChdir(source_session,source_redirections);

      if(state!=CHANGING_DIR_SOURCE)

	 return MOVED;

      if(source_session->IsOpen())

	 return m;

      source_dir.set(source_session->GetCwd().GetDirectory());

   pre_MAKE_TARGET_DIR:

   {

      if(!create_target_dir)

	 goto pre_CHANGING_DIR_TARGET;

      if(target_is_local)

      {

	 struct stat st;

	 if((FlagSet(RETR_SYMLINKS)?stat:lstat)(target_dir,&st)!=-1)

	 {

	    if(S_ISDIR(st.st_mode))

	    {

	       // try to enable write access

	       // only if not enabled as chmod can clear sgid flags on directories

	       if(!script_only && (st.st_mode!=(st.st_mode|0700)))

		  chmod(target_dir,st.st_mode|0700);