/*

 * lftp - file transfer program

 *

 * Copyright (c) 1996-2012 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/>.

 */

/* Get information about a path (dir or file).  If _dir is a file, get

 * information about that file only.  If it's a directory, get information

 * about files in it.  If _showdir is true, act like ls -d: get information

 * about the directory itself.

 *

 * To find out if a path is a directory, attempt to chdir into it.  If it

 * succeeds it's a directory, otherwise it's a file (or there was an error).

 *

 * If the cache knows the file type of _dir, avoid changing directories if

 * possible, so cached listings don't touch the connection at all.

 *

 * List of cases:

 *

 * showdirs off:

 * 1. We CD into the directory.

 *    a. We get a listing.  Success.

 *    b. We fail to get a listing.  Fail.

 * 2. We fail to CD into the path. We fail to CD to the parent. Fail.

 * 3. We fail to CD into the path. We CD to the parent and fail to get a listing.

 *    Do GetInfoArray case.

 * 4. We fail to CD into the path. We CD to the parent and get a listing.

 *    a. The path we were looking for is a directory.  Fail.  (If it's a directory,

 *       we need to get its contents or nothing at all.)

 *    b. The path we were looking for is not a directory.  Success.

 *    c. The path we were looking for isn't there.  Do GetInfoArray case.

 *

 * showdirs on:

 *

 * 1. We CD to the parent and get a listing.  The path we were looking for

 *    is there.  Success.

 * 2. We CD to the parent and fail to get a listing.

 *    a. We CD to the path. (Partial success: we know it exists and is a directory.)

 *    b. We fail to CD to the path. Do GetInfoArray case.

 * 3. We fail to CD to the parent.

 *    a. We CD to the path.  The path is a directory.  Success (don't try to

 *       get more information.)

 *    b. We fail to CD to the path.  Fail.

 * 4. We CD to the parent and fail to get a listing OR

 *    We CD to the parent and the listing does not contain the path.

 *    a. We CD to the path.  The path is a directory.  Success (don't try to

 *       get more information.)

 *    b. We fail to CD to the path.  Do GetInfoArray case.

 *

 * GetInfoArray case:

 * A. We GetInfoArray in the parent, which tells us something.  We

 *    know the path exists, and is not a directory that we have access

 *    to.  Success.

 * B. We GetInfoArray in the parent, which doesn't tell us anything.

 *    We have no evidence the path exists at all. Fail.

 *

 * If we fail from something in cache, we don't know why, so turn cache off

 * and attempt to CD into the path to get an error message.

 *

 * All of these cases can operate out of cache, so be sure to test both, as

 * the code flow is often different.  (GetInfoArray never operates out of cache.)

 */

#include <config.h>

#include <assert.h>

#include "GetFileInfo.h"

#include "misc.h"

#include "LsCache.h"

GetFileInfo::GetFileInfo(const FileAccessRef& a, const char *_dir, bool _showdir)

   : ListInfo(0,0), session(a), dir(_dir?_dir:""), origdir(a->GetCwd())

{

   showdir=_showdir;

   state=INITIAL;

   tried_dir=tried_file=tried_info=false;

   result=0;

   li=0;

   from_cache=0;

   was_directory=false;

   prepend_path=true;

   const char *bn=basename_ptr(dir);

   if((bn[0]=='.' && (bn[1]==0 || bn[1]=='/' ||

                     (bn[1]=='.' && (bn[2]==0 || bn[2]=='/'))))

   || (bn[0]=='/'))

   {

      // . .. / are directories, don't try them as a file.

      tried_file=true;

   }

}

GetFileInfo::~GetFileInfo() {}

void GetFileInfo::PrepareToDie()

{

   if(session)

   {

      session->Close();

      session->SetCwd(origdir);

   }

}

int GetFileInfo::Do()

{

   int res;

   int m=STALL;

   if(Done())

      return m;

   switch(state)

   {

   case INITIAL:

      state=CHANGE_DIR;

      m=MOVED;

      if(use_cache)

      {

	 int is_dir=-1;

	 if(last_char(dir)=='/')

	    is_dir=1;

	 else

	    is_dir=FileAccess::cache->IsDirectory(session,dir);

	 switch(is_dir)

	 {

	 case 0:

	    tried_dir = true; /* it's a file */

	    from_cache = true;

	    break;

	 case 1:

	    if(!showdir)

	       tried_file = true; /* it's a dir */

	    from_cache = true;

	    break;

	 }

      }

      assert(!tried_dir || !tried_file || !tried_info); /* always do at least one */

   case CHANGE_DIR:

   {

      if(tried_dir && tried_file && tried_info) {

	 /* We tried everything; no luck.  Fail. */

	 if(saved_error_text)

	 {

	    SetError(saved_error_text);

	    state=DONE;

	    return MOVED;

	 }

	 /* We don't have an error message.  We may have done everything

	  * out of cache. */

	 tried_dir=false;  // this will get error message.

	 from_cache=false;

      }

      session->SetCwd(origdir);

      const char *cd_path=0;

      if(!tried_dir && (tried_file || !showdir))

      {

	 /* First, try to treat the path as a directory,

	  * if we are going to show its contents */

	 tried_dir=true;

	 cd_path = dir;

	 path_to_prefix.set(dir);

	 was_directory=true;

      }

      else if(!tried_file)

      {

	 /* Try to treat the path as a file.  If showdir is true,

	  * this is done first. */

	 tried_file=true;

	 /* Chdir to the parent directory of the path: */

	 session->Chdir(dir, false);

	 cd_path = "..";

	 path_to_prefix.set(dirname(dir));

	 was_directory=false;

      }

      else if(!tried_info)

      {

	 tried_info=true;

	 /* This is always done after tried_file or a failed tried_dir,

	  * so we should be in the parent, but let's make sure: */

	 session->Chdir(dir, false);

	 session->Chdir("..", false);

	 path_to_prefix.set(dirname(dir));

	 was_directory=false;

	 /* We tried both; no luck. Fall back on ARRAY_INFO. */

	 state=GETTING_INFO_ARRAY;

	 return MOVED;

      }

      /* We still need to Chdir() if we're operating out of cache (that's how you

       * look up cache entries).  However, we don't really want to change the

       * directory of the session (ie. send a CWD if we're FTP), so set verify to

       * false if we're operating out of cache.  */

      bool cd_verify = !from_cache;

      /* We can *not* do this out of cache if 1: dir starts with a ~ and 2: we don't

       * know the home path.

       *

       * Yes we can, usually--we may know the home path in home_auto (FTP), but

       * GetHome won't return that.  We need to do this if we *really* don't know

       * it. */

      /* if(dir[0] == '~' && !session->GetHome())

	 cd_verify = true; */

      session->Chdir(cd_path, cd_verify);

      state=CHANGING_DIR;

      m=MOVED;

   }

   case CHANGING_DIR:

      res=session->Done();

      if(res==FA::IN_PROGRESS)

	 return m;

      if(res<0)

      {

	 /* Failed.  Save the error, then go back and try to CD again.

	  * Only save the first error, so error texts contain the full

	  * path. */

	 if(!saved_error_text)

	    saved_error_text.set(session->StrError(res));

	 session->Close();

	 if(res==FA::NO_FILE)

	 {

	    /* If this is a CWD to the parent, and it failed, we

	     * can't do GetInfoArray. */

	    if(!was_directory)

	       tried_info=true;

	    state=CHANGE_DIR;

	    return MOVED;

	 }

	 SetError(saved_error_text);

	 state=DONE;

	 return MOVED;

      }

      session->Close();

      if(!from_cache)

	 FileAccess::cache->SetDirectory(session,"",true);

      /* Now that we've connected, we should have the home directory path. Find out

       * the real name of the path.  (We may have something like "~/..".) */

      if(!verify_fn)

      {

	 FileAccess::Path pwd(session->GetCwd());

	 session->SetCwd(origdir);

	 session->Chdir(dir, false);

	 verify_fn.set(basename_ptr(session->GetCwd()));

	 /* go back */

	 session->SetCwd(pwd);

      }

      /* Special case: looking up "/". Make a phony entry. */

      if(showdir && !strcmp(verify_fn, "/"))

      {

	 FileInfo *fi = new FileInfo(verify_fn);

	 fi->SetType(fi->DIRECTORY);

	 result = new FileSet;

	 result->Add(fi);

	 path_to_prefix.set(dirname(dir));

	 state=DONE;

	 return MOVED;

      }

      if(was_directory && showdir)

      {

	 /* We could chdir to the dir, but we should not get dir listing.

	  * We got here because either we could not get dir listing of

	  * parent directory or the file name was not found in parent

	  * directory index. */

	 FileInfo *fi = new FileInfo(dir);

	 fi->SetType(fi->DIRECTORY);

	 path_to_prefix.set(dirname(dir));

	 result = new FileSet;

	 result->Add(fi);

	 state=DONE;

	 return MOVED;

      }

      /* Get a listing: */

      li=session->MakeListInfo();

      if(follow_symlinks) li->FollowSymlinks();

      li->UseCache(use_cache);

      li->NoNeed(FileInfo::ALL_INFO); /* clear need */

      li->Need(need);

      li->SetExclude(exclude_prefix, exclude);

      state=GETTING_LIST;

      m=MOVED;

   case GETTING_LIST:

      if(li->Error()) {

	 /* If we're listing contents of dirs, and this was listing

	  * a path (as a directory), fail: */

	 if(!showdir && was_directory)

	 {

	    SetError(li->ErrorText());

	    return MOVED;

	 }

	 if(!saved_error_text)

	    saved_error_text.set(li->ErrorText());

	 /* Otherwise, go on to try the next mode. */

	 state=CHANGE_DIR;

	 return MOVED;

      }

      if(!li->Done())

	 return m;

      state=DONE;

      m=MOVED;

      /* Got the list.  Steal it from the listinfo: */

      result=li->GetResult();

      li=0;

      /* If this was a listing of the basename: */

      if(!was_directory) {

	 verify_fn.rtrim('/');

	 /* Find the file with our filename: */

	 const FileInfo *file = result->FindByName(verify_fn);

	 if(!file) {

	    /* It doesn't exist, or we have no result (failed). */

	    result=0;

	    tried_file=true;

	    from_cache=false;

	    state=CHANGE_DIR;

	    return MOVED;

	 }

	 /* If we're not listing directories as files, and the file is a

	  * directory, we should have been able to Chdir into it to begin

	  * with.  We probably got Access Denied.  Fail. */

	 if(!showdir && (file->defined&file->TYPE) && file->filetype==FileInfo::DIRECTORY) {

	    result=0;

	    if(saved_error_text)

	    {

	       SetError(saved_error_text);

	       goto done;

	    }

	    tried_file=true;

	    from_cache=false;

	    state=CHANGE_DIR;

	    return MOVED;

	 }

	 FileInfo *copy = new FileInfo(*file);

	 result=new FileSet();

	 result->Add(copy);

      }

      goto done;

   case GETTING_INFO_ARRAY:

      if(session->IsClosed())

      {

	 /*

	  * Try to get requested information with GetInfoArray.  This

	  * also serves as a last attempt to see if the file exists--we

	  * only get here if everything else thinks the path doesn't exist.

	  */

	 FileInfo *fi=new FileInfo(verify_fn);

	 fi->need=need;

	 /* We need to do at least one. */

	 if(!fi->need)

	    fi->need=fi->DATE;

	 get_info.Empty();

	 get_info.Add(fi);

	 session->GetInfoArray(&get_info);

      }

      res=session->Done();

      if(res==FA::IN_PROGRESS)

	 return m;

      if(res < 0)

      {

	 if(!saved_error_text)

	    saved_error_text.set(session->StrError(res));

	 state=CHANGE_DIR;

	 return MOVED;

      }

      session->Close();

      {

	 FileInfo *fi=get_info[0];

	 if(!fi->HasAny(fi->SIZE|fi->DATE))

	 {

	    /* We didn't get any information.  The file probably doesn't

	     * exist.  Not necessarily: it might have been a directory

	     * that we don't have access to CD into.  Some servers will

	     * refuse to give even an MDTM for directories.  We could

	     * scan the MDTM and/or SIZE responses for "not a plain file"

	     * for some servers (proftpd). */

	    state=CHANGE_DIR;

	    return MOVED;

	 }

	 /* We got at least one, so the file exists. Return what we know. */

	 was_directory = false;

	 result = new FileSet;

	 result->Add(new FileInfo(*fi));

      }

      state=DONE;

      return MOVED;

done:

   case DONE:

      if(!done)

      {

	 if(result && showdir && result->get_fnum()>0)

	 {

	    FileInfo *f = (*result)[0];

	    /* Make sure the filename is what was requested (ie ".."). */

	    const char *fn = basename_ptr(dir);

	    f->SetName(*fn? fn:".");

	    /* If we're in show_dir mode, was_directory will always be false;

	     * set it to whether the single file is actually a directory or not. */

	    if(f->defined&f->TYPE)

	       was_directory = (f->filetype == f->DIRECTORY);

	 }

	 if(result && prepend_path)

	    result->PrependPath(path_to_prefix);

	 done=true;

	 m=MOVED;

      }

      return m;

   }

   abort();

}

const char *GetFileInfo::Status()

{

   if(Done())

      return "";

   if(li && !li->Done()) return li->Status();

   if(session->IsOpen())

      return session->CurrentStatus();

   return "";

}