/*

 * 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 <stddef.h>

#include <errno.h>

#include <unistd.h>

#include <ctype.h>

#include <fcntl.h>

#include "CmdExec.h"

#include "xstring.h"

#include "SignalHook.h"

#include "alias.h"

#include "misc.h"

#include "ResMgr.h"

#include "module.h"

#include "url.h"

#include "QueueFeeder.h"

#include "LocalDir.h"

#include "ConnectionSlot.h"

#include "DummyProto.h"

#define RL_PROMPT_START_IGNORE	'\001'

#define RL_PROMPT_END_IGNORE	'\002'

#define super SessionJob

#define waiting_num waiting.count()

static ResType lftp_cmd_vars[] = {

   {"cmd:default-protocol",	 "ftp",	  0,0},

   {"cmd:long-running",		 "30",	  ResMgr::UNumberValidate,0},

   {"cmd:remote-completion",	 "on",	  ResMgr::BoolValidate,0},

   {"cmd:prompt",		 "lftp \\S\\? \\u\\@\\h:\\w> ",0,0},

   {"cmd:default-title",	 "lftp \\h:\\w",0,0},

   {"cmd:ls-default",		 "",	  0,0},

   {"cmd:csh-history",		 "off",	  ResMgr::BoolValidate,ResMgr::NoClosure},

   {"cmd:verify-path",		 "yes",	  ResMgr::BoolValidate,0},

   {"cmd:verify-path-cached",	 "no",	  ResMgr::BoolValidate,0},

   {"cmd:verify-host",		 "yes",	  ResMgr::BoolValidate,0},

   {"cmd:at-exit",		 "",	  0,0},

   {"cmd:at-exit-bg",		 "",	  0,0},

   {"cmd:at-exit-fg",		 "",	  0,0},

   {"cmd:at-background",	 "",	  0,0},

   {"cmd:at-terminate",		 "",	  0,0},

   {"cmd:at-finish",		 "",	  0,0},

   {"cmd:at-queue-finish",	 "",	  0,0},

   {"cmd:fail-exit",		 "no",	  ResMgr::BoolValidate,ResMgr::NoClosure},

   {"cmd:verbose",		 "no",	  ResMgr::BoolValidate,ResMgr::NoClosure},

   {"cmd:interactive",		 "auto",  ResMgr::TriBoolValidate,ResMgr::NoClosure},

   {"cmd:show-status",		 "yes",	  ResMgr::BoolValidate,ResMgr::NoClosure},

   {"cmd:move-background",	 "yes",	  ResMgr::BoolValidate,ResMgr::NoClosure},

   {"cmd:move-background-detach","yes",	  ResMgr::BoolValidate,ResMgr::NoClosure},

   {"cmd:set-term-status",	 "no",	  ResMgr::BoolValidate,0},

   {"cmd:term-status",		 "",	  0, 0},

   {"cmd:trace",		 "no",	  ResMgr::BoolValidate,ResMgr::NoClosure},

   {"cmd:parallel",		 "1",	  ResMgr::UNumberValidate,0},

   {"cmd:queue-parallel",	 "1",	  ResMgr::UNumberValidate,0},

   {"cmd:cls-exact-time",	 "yes",	  ResMgr::BoolValidate,ResMgr::NoClosure},

   {0}

};

static ResDecls lftp_cmd_vars_register(lftp_cmd_vars);

CmdExec	 *CmdExec::cwd_owner;

CmdExec	 *CmdExec::chain;

JobRef<CmdExec> CmdExec::top;

void  CmdExec::SaveCWD()

{

   if(!cwd)

      cwd=new LocalDirectory;

   cwd->SetFromCWD();

   if(cwd_owner==0)

      cwd_owner=this;

}

int  CmdExec::RestoreCWD()

{

   if(cwd_owner==this)

      return 0;

   if(cwd==0)

      return -1;

   const char *err=cwd->Chdir();

   if(!err)

   {

      cwd_owner=this;

      return 0;

   }

   const char *name=cwd->GetName();

   eprintf(_("Warning: chdir(%s) failed: %s\n"),name?name:"?",err);

   return -1;

}

void CmdExec::FeedCmd(const char *c)

{

   partial_cmd=false;

   start_time=now;

   cmd_buf.Put(c);

};

void CmdExec::PrependCmd(const char *c)

{

   start_time=now;

   int len=strlen(c);

   int nl=(len>0 && c[len-1]!='\n');

   if(nl)

      cmd_buf.Prepend("\n",1);

   cmd_buf.Prepend(c,len);

   if(alias_field>0)

      alias_field+=len+nl;

}

int CmdExec::find_cmd(const char *cmd_name,const struct cmd_rec **ret)

{

   int part=0;

   const cmd_rec *c=dyn_cmd_table?dyn_cmd_table.get():static_cmd_table;

   const int count=dyn_cmd_table?dyn_cmd_table.count():static_cmd_table_length;

   for(int i=0; i

   {

      if(!strcasecmp(c->name,cmd_name))

      {

	 *ret=c;

	 return 1;

      }

      if(!strncasecmp(c->name,cmd_name,strlen(cmd_name)))

      {

	 part++;

	 *ret=c;

      }

   }

   if(part!=1)

      *ret=0;

   return part;

}

CMD(lcd);

void  CmdExec::exec_parsed_command()

{

   switch(condition)

   {

   case(COND_ANY):

      if(exit_code!=0 && ResMgr::QueryBool("cmd:fail-exit",0))

      {

         failed_exit_code=exit_code;

	 while(feeder)

	    RemoveFeeder();

	 cmd_buf.Empty();

	 return;

      }

      break;

   case(COND_AND):

      if(exit_code!=0)

	 return;

      break;

   case(COND_OR):

      if(exit_code==0)

	 return;

      break;

   }

   prev_exit_code=exit_code;

   exit_code=1;

   if(interactive)

   {

      SignalHook::ResetCount(SIGINT);

      SignalHook::ResetCount(SIGHUP);

      SignalHook::ResetCount(SIGTSTP);

   }

   bool did_default=false;

   if(ResMgr::QueryBool("cmd:trace",0))

   {

      xstring_ca c(args->CombineQuoted());

      printf("+ %s\n",c.get());

   }

restart:

   const struct cmd_rec *c;

   const char *cmd_name=args->getarg(0);

   if(!cmd_name)

      return;

   int part=find_cmd(cmd_name,&c);

   if(part<=0)

      eprintf(_("Unknown command `%s'.\n"),cmd_name);

   else if(part>1)

      eprintf(_("Ambiguous command `%s'.\n"),cmd_name);

   else

   {

      if(RestoreCWD()==-1)

      {

	 if(c->creator!=cmd_lcd)

	    return;

      }

      args->setarg(0,c->name); // in case it was abbreviated

      args->rewind();

      xstring_ca cmdline(args->Combine());   // save the cmdline

      Job *new_job=0;

      if(c->creator==0)

      {

	 if(did_default)

	 {

	    eprintf(_("Module for command `%s' did not register the command.\n"),cmd_name);

	    exit_code=1;

	    return;

	 }

	 new_job=default_cmd();

	 did_default=true;

      }

      else

      {

	 new_job=c->creator(this);

      }

      if(new_job==this || builtin)

      {

	 if(builtin==BUILTIN_EXEC_RESTART)

	 {

	    builtin=BUILTIN_NONE;

	    goto restart;

	 }

	 return;

      }

      RevertToSavedSession();

      if(new_job) {

	 if(!new_job->cmdline)

	    new_job->cmdline.move_here(cmdline);

	 AddNewJob(new_job);

      }

   }

}

void CmdExec::AddNewJob(Job *new_job)

{

   if(new_job->jobno<0)

      new_job->AllocJobno();

   new_job->SetParentFg(this,!background);

   exit_code=0;

   AddWaiting(new_job);

   if(background) {

      Roll(new_job);

      if(!new_job->Done())

	 SuspendJob(new_job);

   }

}

void CmdExec::SuspendJob(Job *j)

{

   j->Bg();

   if(interactive)

      j->ListOneJob(0,0,"&";;

   last_bg=j->jobno;

   exit_code=0;

   RemoveWaiting(j);

}

void CmdExec::ExecParsed(ArgV *a,FDStream *o,bool b)

{

   Enter();

   args=a;

   output=o;

   background=b;

   condition=COND_ANY;

   exec_parsed_command();

   Leave();

}

bool CmdExec::Idle()

{

   return(waiting_num==0 && builtin==BUILTIN_NONE && (cmd_buf.Size()==0 || partial_cmd));

}

int CmdExec::Done()

{

   Enter();

   bool done = (feeder==0 && Idle())

      || (auto_terminate_in_bg && NumberOfChildrenJobs()==0 && !in_foreground_pgrp());

   Leave();

   return done;

}

void CmdExec::RemoveFeeder()

{

   free_used_aliases();

   if(!feeder)

      return;

   // save old cwd if necessary

   if(interactive && feeder->prev==0)

      cwd_history.Set(session);

   cmd_buf.Empty();

   cmd_buf.Put(feeder->saved_buf);

   partial_cmd=false;

   if(feeder==queue_feeder)

      queue_feeder=0;

   delete replace_value(feeder,feeder->prev);

   Reconfig(0);

   SetInteractive();

}

void CmdExec::ReuseSavedSession()

{

   saved_session=0;

}

void CmdExec::RevertToSavedSession()

{

   if(saved_session==0)

      return;

   ChangeSession(saved_session.borrow());

}

void CmdExec::ChangeSlot(const char *n)

{

   if(!n || !*n)

   {

      slot.set(0);

      return;

   }

   slot.set(n);

   const FileAccess *s=ConnectionSlot::FindSession(n);

   if(!s)

      ConnectionSlot::Set(n,session);

   else

      ChangeSession(s->Clone());

}

void CmdExec::AtFinish()

{

   if(queue_feeder && queue_feeder->JobCount())

      return;

   if(!fed_at_finish && NumAwaitedJobs()==0 && cmd_buf.Size()==0) {

      FeedCmd(ResMgr::Query(queue_feeder?"cmd:at-queue-finish":"cmd:at-finish",0));

      FeedCmd("\n");

      fed_at_finish=true;

   }

}

int CmdExec::Do()

{

   int m=STALL;

   if(builtin!=BUILTIN_NONE)

   {

      int res;

      switch(builtin)

      {

      case(BUILTIN_CD):

	 res=session->Done();

	 if(res==FA::OK)

	 {

	    // done

	    if(status_line)

	       status_line->Clear();

	    if(interactive || verbose)

	    {

	       const char *cwd=session->GetCwd();

	       eprintf(_("cd ok, cwd=%s\n"),cwd?cwd:"~");

	       cwd_history.Set(session,old_cwd);

	    }

	    if(slot)

	       ConnectionSlot::SetCwd(slot,session->GetCwd());

	    session->Close();

	    exit_code=0;

	    builtin=BUILTIN_NONE;

	    redirections=0;

	    beep_if_long();

	    return MOVED;

	 }

	 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)

	       {

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

		  if(++redirections>max_redirections)

		  {

		     eprintf("cd: %s\n",_("Too many redirections"));

		     goto cd_err_done;

		  }

		  char *loc=alloca_strdup(loc_c);

		  ParsedURL u(loc,true);

		  if(!u.proto)

		  {

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

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

		     new_cwd.Change(0,is_file,loc);

		     session->PathVerify(new_cwd);

		     session->Roll();

		     return MOVED;

		  }

		  session->Close();

		  exit_code=0;

		  builtin=BUILTIN_NONE;

		  PrependCmd(xstring::get_tmp("open ").append_quoted(loc));

		  return MOVED;

	       }

	    }

	    // error

	    if(status_line)

	       status_line->Clear();

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

	 cd_err_done:

	    session->Close();

	    builtin=BUILTIN_NONE;

	    redirections=0;

	    beep_if_long();

	    exit_code=1;

	    return MOVED;

	 }

	 break;

      case(BUILTIN_OPEN):

	 res=session->Done();

	 if(res==FA::OK)

	 {

	    if(status_line)

	       status_line->Clear();

	    session->Close();

	    ReuseSavedSession();

	    builtin=BUILTIN_NONE;

	    redirections=0;

	    beep_if_long();

	    exit_code=0;

	    return MOVED;

	 }

	 if(res<0)

	 {

	    if(status_line)

	       status_line->Clear();

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

	    session->Close();

	    RevertToSavedSession();

	    builtin=BUILTIN_NONE;

	    redirections=0;

	    beep_if_long();

	    exit_code=1;

	    return MOVED;

	 }

	 break;

      case(BUILTIN_GLOB):

	 if(glob->Error())

	 {

	    if(status_line)

	       status_line->Clear();

	    eprintf("%s: %s\n",args->getarg(0),glob->ErrorText());

	 }

	 else if(glob->Done())

	 {

	    FileSet &list=*glob->GetResult();

	    for(int i=0; list[i]; i++)

	       args_glob->Append(list[i]->name);

	 }

	 if(glob->Done() || glob->Error())

	 {

	    const char *pat=args->getnext();

	    if(!pat)

	    {

	       glob=0;

	       // it was last argument

	       args=args_glob.borrow();

	       builtin=BUILTIN_NONE;

	       redirections=0;

	       if(status_line)

		  status_line->Clear();

	       exit_code=prev_exit_code;

	       RevertToSavedSession();

	       exec_parsed_command();

	       return MOVED;

	    }

	    glob->NewGlob(pat);

	    m=MOVED;

	 }

	 break;

      case(BUILTIN_NONE):

      case(BUILTIN_EXEC_RESTART):

	 abort(); // can't happen

      }

      if(interactive)

      {

	 if(SignalHook::GetCount(SIGINT))

	 {

	    if(status_line)

	       status_line->WriteLine(_("Interrupt"));

	    return AcceptSig(SIGINT);

	 }

	 if(SignalHook::GetCount(SIGTSTP))

	 {

	    if(builtin==BUILTIN_CD || builtin==BUILTIN_OPEN)

	    {

	       if(status_line)

		  status_line->Clear();

	       if(builtin==BUILTIN_CD)

		  session->ChdirAccept();

	       session->Close();

	       exit_code=0;

	       builtin=BUILTIN_NONE;

	       redirections=0;

	       return MOVED;

	    }

	    else

	    {

	       SignalHook::ResetCount(SIGTSTP);

	    }

	 }

	 if(SignalHook::GetCount(SIGHUP))

	 {

	    SetInteractive(false);

	    return MOVED;

	 }

      }

      if(status_line && show_status && status_line->CanShowNow())

	 ShowRunStatus(status_line);   // this is only for top level CmdExec.

      return m;

   }

   if(waiting_num>0)

   {

      Job *j;

      while((j=FindDoneAwaitedJob())!=0)

      {

	 j->Bg();

	 if(status_line)

	    status_line->Clear();

	 if(interactive || verbose)

	    j->SayFinal(); // final phrase like 'rm succeed'

	 exit_code=j->ExitCode();

	 RemoveWaiting(j);

	 Delete(j);

	 beep_if_long();

	 return MOVED;

      }

      if(interactive)

      {

	 if(SignalHook::GetCount(SIGINT))

	 {

	    for(int i=0; i

	       waiting[i]->Bg();

	    SignalHook::ResetCount(SIGINT);

	    if(status_line)

	       status_line->WriteLine(_("Interrupt"));

	    return AcceptSig(SIGINT);

	 }

	 if(SignalHook::GetCount(SIGTSTP))

	 {

	    while(waiting_num>0)

	       SuspendJob(waiting[0]);

	    return MOVED;

	 }

	 if(SignalHook::GetCount(SIGHUP))

	 {

	    SetInteractive(false);

	    return MOVED;

	 }

      }

      if(status_line && show_status && status_line->CanShowNow())

	 ShowRunStatus(status_line);   // this is only for top level CmdExec.

      if(m != STALL || interactive || waiting_num >= max_waiting)

	 return m;

   }

   if(!interactive)

   {

      BuryDoneJobs();

      if(FindJob(last_bg)==0)

	 last_bg=-1;

   }

try_get_cmd:

   if(cmd_buf.Size()==0 || partial_cmd)

   {

      if(feeder)

      {

	 if(interactive && !partial_cmd)

	 {

	    ListDoneJobs();

	    BuryDoneJobs();

	    if(FindJob(last_bg)==0)

	       last_bg=-1;

	 }

	 if(status_line && show_status)

	 {

	    const char *def_title = FormatPrompt(ResMgr::Query("cmd:default-title",getenv("TERM")));

	    status_line->DefaultTitle(def_title);

	    status_line->Clear();

	 }

	 const char *prompt=MakePrompt();

	 feeder_called=true;

	 if(fg)

	    feeder->Fg();

	 const char *cmd=feeder->NextCmd(this,prompt);

	 feeder_called=false;

	 if(!cmd)

	 {

	    if(cmd_buf.Size()>0 && partial_cmd)

	    {

	       const char *next_cmd=cmd_buf.Get();

	       if(last_char(next_cmd)!='\n')

	       {

		  // missing EOL on last line, add it

		  FeedCmd("\n");

		  goto try_get_cmd;

	       }

	       fprintf(stderr,_("Warning: discarding incomplete command\n"));

	    }

	    if(!feeder->RealEOF() && top_level)

	    {

	       cmd_buf.Empty();

	       FeedCmd("exit;");

	       return MOVED;

	    }

	    if(waiting_num > 0)

	      return m;

	    RemoveFeeder();

	    m=MOVED;

	    goto try_get_cmd;

	 }

	 if(cmd[0])

	 {

	    auto_terminate_in_bg=false;

	    FeedCmd(cmd);

	    Roll();

	    if(!Idle())

	       fed_at_finish=false;

	    return MOVED;

	 }

	 else

	 {

	    if(SignalHook::GetCount(SIGINT)>0)

	    {

	       SignalHook::ResetCount(SIGINT);

	       cmd_buf.Empty();	 // flush unparsed command

	       return MOVED;

	    }

	 }

      }

      return m;

   }

   parse_result res = parse_one_cmd();

   if(alias_field<=0)

      free_used_aliases();

   switch(res)

   {

   case(PARSE_ERR):

      return MOVED;

   case(PARSE_AGAIN):

      partial_cmd=true;

      goto try_get_cmd;

   case(PARSE_OK):

      if(feeder)

	 feeder->Bg();

      break;

   }

   if(args==0 || args->count()==0) {

      AtFinish();

      return MOVED;  // empty command

   }

   if(interactive)

      session->DontSleep(); // We don't want to get a delay just after user

			    // entered a command.

   exec_parsed_command();

   return MOVED;

}

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

{

   switch(builtin)

   {

   case(BUILTIN_CD):

      if(session->IsOpen())

	 s->Show("cd `%s' [%s]",squeeze_file_name(args->getarg(1),s->GetWidthDelayed()-40),session->CurrentStatus());

      break;

   case(BUILTIN_OPEN):

      if(session->IsOpen())

	 s->Show("open `%s' [%s]",session->GetHostName(),session->CurrentStatus());

      break;

   case(BUILTIN_GLOB):

      s->Show("%s",glob->Status());

      break;

   case(BUILTIN_EXEC_RESTART):

      abort(); // can't happen

   case(BUILTIN_NONE):

      if(waiting_num>0)

	 Job::ShowRunStatus(s);

      else

	 s->Clear();

      break;

   }

}

xstring& CmdExec::FormatStatus(xstring& s,int v,const char *prefix)

{

   SessionJob::FormatStatus(s,v,prefix);

   if(builtin)

   {

      xstring_ca ac(args->Combine());

      return s.appendf(_("\tExecuting builtin `%s' [%s]\n"),ac.get(),session->CurrentStatus());

   }

   if(queue_feeder)

   {

      if(IsSuspended())

	 s.appendf("%s%s\n",prefix,_("Queue is stopped."));

      BuryDoneJobs();

      for(int i=0; i

      {

	 if(i==0)

	    s.appendf("%s%s ",prefix,_("Now executing:"));

	 if(v==0)

	    waiting[i]->FormatOneJob(s,v);

	 else

	    waiting[i]->FormatJobTitle(s);

	 if(i+1

	    s.appendf("%s\t-",prefix);

      }

      return queue_feeder->FormatStatus(s,v,prefix);

   }

   if(waiting_num==1)

      return s.appendf(_("\tWaiting for job [%d] to terminate\n"),waiting[0]->jobno);

   else if(waiting_num>1)

   {

      s.appendf(_("\tWaiting for termination of jobs: "));

      for(int i=0; i

      {

	 s.appendf("[%d]",waiting[i]->jobno);

	 s.append(i+1

      }

      return s;

   }

   if(cmd_buf.Size()>0)

      s.append(_("\tRunning\n"));

   else if(feeder)

      s.append(_("\tWaiting for command\n"));

   return s;

}

void CmdExec::init(LocalDirectory *c)

{

   // add this to chain

   next=chain;

   chain=this;

   background=false;

   interactive=false;

   show_status=true;

   top_level=false;

   auto_terminate_in_bg=false;

   feeder=0;

   feeder_called=false;

   used_aliases=0;

   partial_cmd=false;

   alias_field=0;

   default_output=0;

   condition=COND_ANY;

   prev_exit_code=0;

   exit_code=0;

   failed_exit_code=0;

   last_bg=-1;

   fed_at_finish=true;

   cwd=c;

   if(!cwd)

      SaveCWD();

   remote_completion=false;

   long_running=0;

   csh_history=false;

   verify_host=verify_path=true;

   verify_path_cached=false;

   start_time=0;

   redirections=0;

   queue_feeder=0;

   max_waiting=1;

   saved_session=0;

   builtin=BUILTIN_NONE;

   Reconfig();

}

CmdExec::CmdExec(FileAccess *s,LocalDirectory *c)

   : SessionJob(s?s:new DummyProto), parent_exec(0)

{

   init(c);

}

CmdExec::CmdExec(CmdExec *parent)

   : SessionJob(parent->session->Clone()), parent_exec(parent)

{

   init(parent->cwd->Clone());

}

CmdExec::~CmdExec()

{

   // remove this from chain.

   for(CmdExec **scan=&chain; *scan; scan=&(*scan)->next)

   {

      if(this==*scan)

      {

	 *scan=(*scan)->next;

	 break;

      }

   }

   free_used_aliases();

   if(cwd_owner==this)

      cwd_owner=0;

}

const char *CmdExec::FormatPrompt(const char *scan)

{

   const char *cwd=session->GetCwd();

   if(cwd==0 || cwd[0]==0)

      cwd="~";

   {

      const char *home=session->GetHome();

      int home_len=xstrlen(home);

      if(home_len>1 && !strncmp(cwd,home,home_len)

      && (cwd[home_len]=='/' || cwd[home_len]==0))

      {

	 cwd=xstring::format("~%s",cwd+home_len);

      }

   }

   const char *cwdb=session->GetCwd();

   if(cwdb==0 || cwdb[0]==0)

      cwdb="~";

   const char *p=strrchr(cwdb,'/');

   if(p && p>cwdb)

      cwdb=p+1;

   const char *lcwd=this->cwd->GetName();

   {

      const char *home=get_home();

      int home_len=xstrlen(home);

      if(home_len>1 && !strncmp(lcwd,home,home_len)

      && (lcwd[home_len]=='/' || lcwd[home_len]==0))

      {

	 lcwd=xstring::format("~%s",lcwd+home_len);