/*
* 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 "FileSet.h"
#include <sys/types.h>
#include <sys/stat.h>
#include <utime.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/stat.h>
#include <fnmatch.h>
#include <locale.h>
#include <mbswidth.h>
CDECL_BEGIN
#include <filemode.h>
#include "human.h"
CDECL_END
#include "misc.h"
#include "ResMgr.h"
#include "FileSetOutput.h"
#include "ArgV.h"
#include "ColumnOutput.h"
#include "DirColors.h"
#include "FileGlob.h"
#include "CopyJob.h"
ResDecl res_default_cls ("cmd:cls-default", "-F", FileSetOutput::ValidateArgv,ResMgr::NoClosure),
res_default_comp_cls ("cmd:cls-completion-default", "-FBa",FileSetOutput::ValidateArgv,ResMgr::NoClosure);
ResDecl res_time_style ("cmd:time-style", "%b %e %Y|%b %e %H:%M", 0, ResMgr::NoClosure);
/* note: this sorts (add a nosort if necessary) */
void FileSetOutput::print(FileSet &fs, const JobRef<OutputJob>& o) const
{
fs.Sort(sort, sort_casefold, sort_reverse);
if(sort_dirs_first) fs.Sort(FileSet::DIRSFIRST, false, sort_reverse);
ColumnOutput c;
DirColors &col=*DirColors::GetInstance();
const char *suffix_color = "";
/* Most fields are only printed if at least one file has that
* information; if no files have perm information, for example,
* discard the entire field. */
int have = fs.Have();
for(int i = 0; fs[i]; i++) {
const FileInfo *f = fs[i];
if(!showdots && !list_directories &&
(!strcmp(basename_ptr(f->name),".") || !strcmp(basename_ptr(f->name),"..")))
continue;
if(pat && *pat &&
fnmatch(pat, f->name, patterns_casefold? FNM_CASEFOLD:0))
continue;
c.append();
if((mode & PERMS) && (f->defined&FileInfo::MODE)) {
char mode[16];
memset(mode, 0, sizeof(mode));
strmode(f->mode, mode);
/* FIXME: f->mode doesn't have type info; it wouldn't
* be hard to fix that */
if(f->filetype == FileInfo::DIRECTORY) mode[0] = 'd';
else if(f->filetype == FileInfo::SYMLINK) mode[0] = 'l';
else mode[0] = '-';
c.add(mode, "");
} else if(have & FileInfo::MODE) {
c.add(" ", "");
}
if((have & FileInfo::NLINKS) && (mode & NLINKS)) {
if(f->defined&f->NLINKS)
c.addf("%4i ", "", f->nlinks);
else
c.addf("%4i ", "", "");
}
if((have & FileInfo::USER) && (mode & USER)) {
c.addf("%-8.8s ", "", (f->defined&f->USER)? f->user: "");
}
if((have & FileInfo::GROUP) && (mode & GROUP)) {
c.addf("%-8.8s ", "", (f->defined&f->GROUP)? f->group: "");
}
if((mode & SIZE) && (have&FileInfo::SIZE)) {
char sz[LONGEST_HUMAN_READABLE + 2];
if((f->filetype == FileInfo::NORMAL || !size_filesonly)
&& (f->defined&f->SIZE)) {
char buffer[LONGEST_HUMAN_READABLE + 1];
snprintf(sz, sizeof(sz), "%8s ",
human_readable (f->size, buffer, human_opts, 1,
output_block_size? output_block_size:1024));
} else {
snprintf(sz, sizeof(sz), "%8s ", ""); /* pad */
}
c.add(sz, "");
}
/* We use unprec dates; doing MDTMs for each file in ls is far too
* slow. If someone actually wants that (to get dates on servers with
* unparsable dates, or more accurate dates), it wouldn't be
* difficult. If we did this, we could also support --full-time. */
if((mode & DATE) && (have & f->DATE)) {
/* Consider a time to be recent if it is within the past six
* months. A Gregorian year has 365.2425 * 24 * 60 * 60 ==
* 31556952 seconds on the average. Write this value as an
* integer constant to avoid floating point hassles. */
const int six_months_ago = SMTask::now.UnixTime() - 31556952 / 2;
bool recent = six_months_ago <= f->date;
const char *use_fmt=time_fmt;
if(!use_fmt)
use_fmt=ResMgr::Query("cmd:time-style",0);
if(!use_fmt || !*use_fmt)
use_fmt="%b %e %Y\n%b %e %H:%M";
xstring_ca dt_mem(xstrftime(use_fmt, localtime (&f->date.ts)));
char *dt=strtok(dt_mem.get_non_const(),"\n|");
if(recent) {
char *dt1=strtok(NULL,"\n|");
if(dt1)
dt=dt1;
}
if (!(f->defined&f->DATE)) {
/* put an empty field; make sure it's the same width */
int wid = mbswidth(dt, 0);
dt = string_alloca(wid+1);
memset(dt, ' ', wid);
dt[wid] = 0;
}
c.addf("%s ", "", dt);
}
const char *nm = f->name;
if(basenames) nm = basename_ptr(nm);
c.add(nm, col.GetColor(f));
if(classify)
c.add(FileInfoSuffix(*f), suffix_color);
if((mode & LINKS) &&
f->filetype == FileInfo::SYMLINK &&
f->symlink) {
c.add(" -> ", "");
/* see if we have a file entry for the symlink */
FileInfo tmpfi;
FileInfo *lfi = fs.FindByName(f->symlink);
if(!lfi) {
/* create a temporary one */
tmpfi.SetName(f->symlink);
lfi = &tmpfi;
}
c.add(lfi->name, col.GetColor(lfi));
if(classify)
c.add(FileInfoSuffix(*lfi), suffix_color);
}
}
c.print(o, single_column? 0:width, color);
}
const char *FileSetOutput::FileInfoSuffix(const FileInfo &fi) const
{
if(!(fi.defined&fi.TYPE))
return "";
if(fi.filetype == FileInfo::DIRECTORY)
return "/";
else if(fi.filetype == FileInfo::SYMLINK)
return "@";
return "";
}
void FileSetOutput::config(const OutputJob *o)
{
width = o->GetWidth();
if(width == -1)
width = 80;
color = ResMgr::QueryTriBool("color:use-color", 0, o->IsTTY());
}
void FileSetOutput::long_list()
{
single_column = true;
mode = ALL;
/* -l's default size is 1; otherwise 1024 */
if(!output_block_size)
output_block_size = 1;
}
const char *FileSetOutput::parse_res(const char *res)
{
Ref<ArgV> arg(new ArgV("",res));
const char *error=parse_argv(arg);
if(error)
return error;
/* shouldn't be any non-option arguments */
if(arg->count() > 1)
return _("non-option arguments found");
return 0;
}
const char *FileSetOutput::ValidateArgv(xstring_c *s)
{
if(!*s) return NULL;
FileSetOutput tmp;
const char *ret = tmp.parse_res(*s);
if(ret) return ret;
return NULL;
}
int FileSetOutput::Need() const
{
int need=FileInfo::NAME;
if(mode & PERMS)
need|=FileInfo::MODE;
// if(mode & SIZE) /* this must be optional */
// need|=FileInfo::SIZE;
// if(mode & DATE) /* this too */
// need|=FileInfo::DATE;
if(mode & LINKS)
need|=FileInfo::SYMLINK_DEF;
if(mode & USER)
need|=FileInfo::USER;
if(mode & GROUP)
need|=FileInfo::GROUP;
if(need_exact_time)
need|=FileInfo::DATE;
return need;
}
#undef super
#define super SessionJob
clsJob::clsJob(FA *s, ArgV *a, FileSetOutput *_opts, OutputJob *_output):
SessionJob(s),
fso(_opts),
args(a),
done(0),
use_cache(true),
error(false),
state(INIT)
{
list_info=0;
if(args->count() == 1)
args->Add("");
output=_output;
AddWaiting(output);
}
int clsJob::Done()
{
return done && output->Done();
}
int clsJob::Do()
{
int m=STALL;
if(output->Done())
state=DONE;
switch(state)
{
case INIT:
state=START_LISTING;
m=MOVED;
case START_LISTING:
{
list_info=0;
/* next: */
mask.set(0);
dir.set(args->getnext());
if(!dir) {
/* done */
state=DONE;
return MOVED;
}
/* If the basename contains wildcards, set up the mask. */
const char *bn = basename_ptr(dir);
if(Glob::HasWildcards(bn)) {
/* The mask is the whole argument, not just the basename; this is
* because the whole relative paths will end up in the FileSet, and
* that's what this pattern will be matched against. */
mask.set(dir);
// leave the final / on the path, to prevent the dirname of
// "file/*" from being treated as a file
dir.truncate(bn-dir); // this can result in dir eq ""
} else {
// no need to glob, just unquote metacharacters.
Glob::UnquoteWildcards(const_cast<char*>(bn));
}
list_info=new GetFileInfo(session, dir, fso->list_directories);
list_info->UseCache(use_cache);
list_info->Need(fso->Need());
state=GETTING_LIST_INFO;
m=MOVED;
}
case GETTING_LIST_INFO:
{
if(!list_info->Done())
return m;
if(list_info->Error()) {
eprintf("%s\n", list_info->ErrorText());
error=true;
state=START_LISTING;
return MOVED;
}
/* one just finished */
fso->pat.move_here(mask);
FileSet *res = list_info->GetResult();
if(res)
fso->print(*res, output);
fso->pat.set(0);
delete res;
state=START_LISTING;
return MOVED;
}
case DONE:
if(!done)
{
output->PutEOF();
done=true;
m=MOVED;
}
break;
}
return m;
}
void clsJob::SuspendInternal()
{
super::SuspendInternal();
if(list_info)
list_info->SuspendSlave();
session->SuspendSlave();
}
void clsJob::ResumeInternal()
{
if(list_info)
list_info->ResumeSlave();
session->ResumeSlave();
super::ResumeInternal();
}
void clsJob::ShowRunStatus(const SMTaskRef<StatusLine>& s)
{
if(fso->quiet)
return;
if(!output->ShowStatusLine(s))
return;
if(list_info && !list_info->Done())
{
const char *curr = args->getcurr();
if(!*curr)
curr = ".";
const char *stat = list_info->Status();
if(*stat)
s->Show("`%s' %s %s", curr, stat, output->Status(s));
}
else
s->Show("%s", output->Status(s));
}
xstring& clsJob::FormatStatus(xstring& s,int v,const char *prefix)
{
Job::FormatStatus(s,v,prefix);
if(list_info)
{
const char *curr = args->getcurr();
if(!*curr)
curr = ".";
const char *stat = list_info->Status();
if(*stat)
s.appendf("%s`%s' %s\n", prefix, curr, stat);
}
return s;
}