/*
* 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 "xmalloc.h"
#include "xstring.h"
#include "trio.h"
#include <pwd.h>
#include <unistd.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include <ctype.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <pwd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#ifdef HAVE_TERMIOS_H
#include <termios.h>
#endif
#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
#endif
#if LIBIDN2
# include <idn2.h>
#endif
#ifdef HAVE_DLFCN_H
# include <dlfcn.h>
#endif
CDECL_BEGIN
#include "regex.h"
#include "human.h"
CDECL_END
#include "misc.h"
#include "ProcWait.h"
#include "SignalHook.h"
#include "url.h"
#include "ResMgr.h"
#include <mbswidth.h>
#include "strftime.h"
const char *dir_file(const char *dir,const char *file)
{
if(dir==0 || dir[0]==0)
return file?file:dir;
if(file==0 || file[0]==0)
return dir;
if(file[0]=='/')
return file;
if(file[0]=='.' && file[1]=='/')
file+=2;
xstring& buf=xstring::get_tmp();
size_t len=strlen(dir);
if(len==0)
return buf.set(file);
if(dir[len-1]=='/')
return buf.vset(dir,file,NULL);
return buf.vset(dir,"/",file,NULL);
}
const char *url_file(const char *url,const char *file)
{
static xstring buf;
if(buf && url==buf) // it is possible to url_file(url_file(url,dir),file)
url=alloca_strdup(url);
if(!url || url[0]==0)
{
buf.set(file?file:"");
return buf;
}
ParsedURL u(url);
if(!u.proto)
{
buf.set(dir_file(url,file));
return buf;
}
if(file && file[0]=='~')
u.path.set(file);
else
u.path.set(dir_file(u.path,file));
buf.truncate();
return u.CombineTo(buf);
}
const char *output_file_name(const char *src,const char *dst,bool dst_local,
const char *dst_base,bool make_dirs)
{
bool dst_is_dir=false;
if(dst)
{
if(dst_base)
dst=url_file(dst_base,dst);
ParsedURL u_dst(dst,true);
if(u_dst.proto)
dst_local=false;
if(dst_local)
{
dst=expand_home_relative(dst);
struct stat st;
if(stat(dst,&st)!=-1 && S_ISDIR(st.st_mode))
dst_is_dir=true;
}
else
{
int len=xstrlen(u_dst.path);
if(len>0 && u_dst.path[len-1]=='/')
dst_is_dir=true;
}
if(!dst_is_dir)
return dst;
}
ParsedURL u_src(src,true);
if(u_src.proto)
src=u_src.path;
if(!src)
return ""; // there will be error anyway.
const char *base=basename_ptr(src);
if(make_dirs && !dst)
{
base=src;
if(base[0]=='~')
{
base=strchr(base,'/');
if(!base)
base="";
}
while(*base=='/')
base++;
}
return url_file(dst?dst:dst_base,base);
}
const char *basename_ptr(const char *s)
{
const char *s1=s+strlen(s);
while(s1>s && s1[-1]=='/')
s1--;
while(s1>s && s1[-1]!='/')
s1--;
return s1;
}
const char *expand_home_relative(const char *s)
{
if(s[0]!='~')
return s;
const char *home=0;
const char *sl=strchr(s+1,'/');
static xstring ret_path;
if(s[1]==0 || s[1]=='/')
{
home=get_home();
}
else
{
// extract user name and find the home
int name_len=(sl?sl-s-1:strlen(s+1));
struct passwd *pw=getpwnam(xstring::get_tmp(s+1,name_len));
if(pw)
home=pw->pw_dir;
}
if(home==0)
return s;
if(sl)
return ret_path.vset(home,sl,NULL);
return home;
}
int create_directories(char *path)
{
char *sl=path;
int res;
if(access(path,0)==0)
return 0;
for(;;)
{
sl=strchr(sl,'/');
if(sl==path)
{
sl++;
continue;
}
if(sl)
*sl=0;
if(access(path,0)==-1)
{
res=mkdir(path,0777);
if(res==-1)
{
if(errno!=EEXIST)
{
fprintf(stderr,"mkdir(%s): %s\n",path,strerror(errno));
if(sl)
*sl='/';
return(-1);
}
}
}
if(sl)
*sl++='/';
else
break;
}
return 0;
}
void truncate_file_tree(const char *dir)
{
fflush(stderr);
pid_t pid;
switch(pid=fork())
{
case(0): // child
SignalHook::Ignore(SIGINT);
SignalHook::Ignore(SIGTSTP);
SignalHook::Ignore(SIGQUIT);
SignalHook::Ignore(SIGHUP);
execlp("rm","rm","-rf",dir,(char*)NULL);
perror("execlp(rm)");
fflush(stderr);
_exit(1);
case(-1): // error
perror("fork()");
return;
default: // parent
(new ProcWait(pid))->Auto(); // don't wait for termination
}
}
int fd_width(int fd)
{
if(fd == -1) return -1;
if(!isatty(fd)) return 0;
#ifdef TIOCGWINSZ
struct winsize sz;
sz.ws_col=sz.ws_row=0;
ioctl(fd,TIOCGWINSZ,&sz);
if(sz.ws_col==0)
sz.ws_col=80;
return(sz.ws_col);
#else /* !TIOCGWINSZ */
return 80;
#endif
}
char *xgetcwd()
{
char *cwd=getcwd(0,0); // glibc extension
if(cwd) {
xmalloc_register_block(cwd);
return cwd;
}
int size=256;
cwd=(char*)xmalloc(size);
for(;;)
{
if(getcwd(cwd,size))
return cwd;
if(errno!=ERANGE)
return strcpy(cwd,".");
cwd=(char*)xrealloc(cwd,size*=2);
}
}
void xgetcwd_to(xstring& s)
{
int size=256;
for(;;) {
s.get_space(size);
if(getcwd(s.get_non_const(),size)) {
s.set_length(strlen(s.get()));
return;
}
if(errno!=ERANGE) {
s.set(".");
return;
}
size*=2;
}
}
int parse_perms(const char *s)
{
int p=0;
if(strlen(s)!=9
&& !(strlen(s)==10 && s[9]=='+')) // ACL tag
bad: return -1;
switch(s[0])
{
case('r'): p|=S_IRUSR; break;
case('-'): break;
default: goto bad;
}
switch(s[1])
{
case('w'): p|=S_IWUSR; break;
case('-'): break;
default: goto bad;
}
switch(s[2])
{
case('S'): p|=S_ISUID; break;
case('s'): p|=S_ISUID; // fall-through
case('x'): p|=S_IXUSR; break;
case('-'): break;
default: goto bad;
}
s+=3;
switch(s[0])
{
case('r'): p|=S_IRGRP; break;
case('-'): break;
default: goto bad;
}
switch(s[1])
{
case('w'): p|=S_IWGRP; break;
case('-'): break;
default: goto bad;
}
switch(s[2])
{
case('S'): p|=S_ISGID; break;
case('s'): p|=S_ISGID; // fall-through
case('x'): p|=S_IXGRP; break;
case('-'): break;
default: goto bad;
}
s+=3;
switch(s[0])
{
case('r'): p|=S_IROTH; break;
case('-'): break;
default: goto bad;
}
switch(s[1])
{
case('w'): p|=S_IWOTH; break;
case('-'): break;
default: goto bad;
}
switch(s[2])
{
case('T'): p|=S_ISVTX; break;
case('t'): p|=S_ISVTX; // fall-through
case('x'): p|=S_IXOTH; break;
case('l'): case('L'): p|=S_ISGID; p&=~S_IXGRP; break;
case('-'): break;
default: goto bad;
}
return p;
}
// it does not prepend file type.
const char *format_perms(int p)
{
static char s[10];
memset(s,'-',9);
if(p&0400) s[0]='r';
if(p&0200) s[1]='w';
if(p&0100) s[2]='x';
if(p&0040) s[3]='r';
if(p&0020) s[4]='w';
if(p&0010) s[5]='x';
if(p&0004) s[6]='r';
if(p&0002) s[7]='w';
if(p&0001) s[8]='x';
if(p&01000) s[8]=(p&0001?'t':'T');
if(p&02000) s[5]=(p&0010?'s':'S');
if(p&04000) s[2]=(p&0100?'s':'S');
return s;
}
const char month_names[][4]={
"Jan","Feb","Mar","Apr","May","Jun",
"Jul","Aug","Sep","Oct","Nov","Dec",
""
};
int parse_month(const char *m)
{
for(int i=0; month_names[i][0]; i++)
if(!strcasecmp(month_names[i],m))
return(i%12);
return -1;
}
int parse_year_or_time(const char *year_or_time,int *year,int *hour,int *minute)
{
if(year_or_time[2]==':')
{
if(2!=sscanf(year_or_time,"%2d:%2d",hour,minute))
return -1;
*year=-1;
}
else
{
if(1!=sscanf(year_or_time,"%d",year))
return -1;;
*hour=*minute=0;
}
return 0;
}
int guess_year(int month,int day,int hour,int minute)
{
const struct tm &now=SMTask::now;
int year=now.tm_year+1900;
if(month *32+ day
> now.tm_mon*32+now.tm_mday+6)
year--;
return year;
}
int percent(off_t offset,off_t size)
{
if(offset>=size)
return 100;
// use floating point to avoid integer overflow.
return int(double(offset)*100/size);
}
const char *squeeze_file_name(const char *name,int w)
{
static xstring buf;
int mbflags=0;
name=url::remove_password(name);
int name_width=mbswidth(name,mbflags);
if(name_width<=w)
return name;
const char *b=basename_ptr(name);
int b_width=name_width-mbsnwidth(name,b-name,mbflags);
if(b_width<=w-4 && b_width>w-15)
return buf.vset(".../",b,NULL);
int b_len=strlen(b);
while(b_width>(w<3?w-1:w-3) && b_len>0)
{
int ch_len=mblen(b,b_len);
if(ch_len<1)
ch_len=1;
b_width-=mbsnwidth(b,ch_len,mbflags);
b+=ch_len;
b_len-=ch_len;
}
if(w>=6)
buf.set("...");
else
buf.set("<");
return buf.append(b);
}
/* Converts struct tm to time_t, assuming the data in tm is UTC rather
than local timezone (mktime assumes the latter).
Contributed by Roger Beeman <beeman@cisco.com>, with the help of
Mark Baushke <mdb@cisco.com> and the rest of the Gurus at CISCO. */
time_t
mktime_from_utc (const struct tm *t)
{
struct tm tc;
memcpy(&tc, t, sizeof(struct tm));
/* UTC times are never DST; if we say -1, we'll introduce odd localtime-
* dependant errors. */
tc.tm_isdst = 0;
time_t tl = mktime (&tc);
if (tl == -1)
return -1;
time_t tb = mktime (gmtime (&tl));
return (tl <= tb ? (tl + (tl - tb)) : (tl - (tb - tl)));
}
static void set_tz(const char *tz)
{
static char *put_tz;
static int put_tz_alloc;
if(!tz)
{
unsetenv("TZ");
xfree(put_tz);
put_tz=0;
put_tz_alloc=0;
tzset();
return;
}
int tz_len=strlen(tz)+4;
char *new_tz=put_tz;
if(tz_len>put_tz_alloc)
new_tz=(char*)xmalloc(put_tz_alloc=tz_len);
snprintf(new_tz,tz_len,"TZ=%s",tz);
if(new_tz!=put_tz)
{
putenv(new_tz);
xfree(put_tz);
put_tz=new_tz;
}
// now initialize libc variables from env TZ.
tzset();
}
static char *saved_tz=0;
static void save_tz()
{
xstrset(saved_tz,getenv("TZ"));
}
static void restore_tz()
{
set_tz(saved_tz);
}
time_t mktime_from_tz(struct tm *t,const char *tz)
{
if(!tz || !*tz)
return mktime(t);
if(!strcasecmp(tz,"GMT"))
return mktime_from_utc(t);
if(isdigit((unsigned char)*tz) || *tz=='+' || *tz=='-')
{
int tz1_len=strlen(tz)+4;
char *tz1=string_alloca(tz1_len);
snprintf(tz1,tz1_len,"GMT%s",tz);
tz=tz1;
}
save_tz();
set_tz(tz);
time_t res=mktime(t);
restore_tz();
return res;
}
bool re_match(const char *line,const char *a,int flags)
{
if(!a || !*a)
return false;
regex_t re;
if(regcomp(&re,a,REG_EXTENDED|REG_NOSUB|flags))
return false;
bool res=(0==regexec(&re,line,0,0,0));
regfree(&re);
return res;
}
xstring& SubstTo(xstring& buf,const char *txt, const subst_t *s)
{
buf.nset("",0);
char str[3];
bool last_subst_empty=true;
while(*txt)
{
char ch = *txt++;
const char *to_add = NULL;
if(ch=='\\' && *txt && *txt!='\\')
{
ch=*txt++;
if(ch >= '0' && ch < '8') {
int len;
unsigned code;
txt--;
if(sscanf(txt,"%3o%n",&code,&len)!=1)
continue; // should never happen.
ch=code;
txt+=len;
str[0]=ch;
str[1]=0;
to_add=str;
} else {
if(ch=='?')
{
if(last_subst_empty)
txt++;
to_add="";
}
for(int i = 0; s[i].from; i++) {
if(s[i].from != ch)
continue;
to_add=s[i].to;
if(!to_add)
to_add = "";
last_subst_empty = (*to_add==0);
}
if(!to_add) {
str[0]='\\';
str[1]=ch;
str[2]=0;
to_add=str;
}
}
}
else
{
if(ch=='\\' && *txt=='\\')
txt++;
str[0]=ch;
str[1]=0;
to_add=str;
}
if(to_add==0)
continue;
buf.append(to_add);
}
return(buf);
}
void xgettimeofday(time_t *sec, int *usec)
{
#ifdef HAVE_GETTIMEOFDAY
struct timeval tv;
gettimeofday(&tv,0);
if(sec) *sec = tv.tv_sec;
if(usec) *usec = tv.tv_usec;
#else
if(sec) time(sec);
if(usec) *usec = 0;
#endif
}
char *xstrftime(const char *format, const struct tm *tm)
{
char *ret = NULL;
int siz = 32;
struct tm dummy;
memset(&dummy, 0, sizeof(dummy));
if(tm == NULL)
tm = &dummy;
for(;;)
{
ret = (char *) xrealloc(ret, siz);
int res=strftime(ret, siz, format, tm);
if(res>0 && res<siz)
return ret; /* success */
/* more space */
siz*=2;
}
}
/* /file/name -> /file
* /file -> /
* file/name -> "file"
* file/name/ -> "file"
* file -> ""
* note: the last differs from dirname(1) (which would return ".")
*
*/
void strip_trailing_slashes(xstring& ret)
{
int len=ret.length();
while(len>0 && ret[len-1]=='/')
len--;
if(len==0 && ret[0]=='/')
len=1+(ret[1]=='/');
if(len>0)
ret.truncate(len);
}
xstring& dirname_modify(xstring &ret)
{
strip_trailing_slashes(ret);
const char *slash=strrchr(ret,'/');
if(!slash)
ret.truncate(0); /* file with no path */
else if(slash==ret)
ret.truncate(1); /* the slash is the first character */
else
ret.truncate(slash-ret);
return ret;
}
xstring& dirname(const char *path)
{
return dirname_modify(xstring::get_tmp(path));
}
char last_char(const char *str)
{
int len=strlen(str);
return str[len-(len>0)];
}
/* How many bytes it will take to store LEN bytes in base64. */
int
base64_length(int len)
{
return (4 * (((len) + 2) / 3));
}
/* Encode the string S of length LENGTH to base64 format and place it
to STORE. STORE will be 0-terminated, and must point to a writable
buffer of at least 1+BASE64_LENGTH(length) bytes. */
void
base64_encode (const char *s, char *store, int length)
{
/* Conversion table. */
static const char tbl[64] = {
'A','B','C','D','E','F','G','H',
'I','J','K','L','M','N','O','P',
'Q','R','S','T','U','V','W','X',
'Y','Z','a','b','c','d','e','f',
'g','h','i','j','k','l','m','n',
'o','p','q','r','s','t','u','v',
'w','x','y','z','0','1','2','3',
'4','5','6','7','8','9','+','/'
};
int i;
unsigned char *p = (unsigned char *)store;
/* Transform the 3x8 bits to 4x6 bits, as required by base64. */
for (i = 0; i < length; i += 3)
{
*p++ = tbl[s[0] >> 2];
*p++ = tbl[((s[0] & 3) << 4) + (s[1] >> 4)];
*p++ = tbl[((s[1] & 0xf) << 2) + (s[2] >> 6)];
*p++ = tbl[s[2] & 0x3f];
s += 3;
}
/* Pad the result if necessary... */
if (i == length + 1)
*(p - 1) = '=';
else if (i == length + 2)
*(p - 1) = *(p - 2) = '=';
/* ...and zero-terminate it. */
*p = '\0';
}
bool temporary_network_error(int err)
{
switch(err)
{
case(EPIPE):
case(EIO):
case(ETIMEDOUT):
#ifdef ECONNRESET
case(ECONNRESET):
#endif
case(ECONNREFUSED):
#ifdef EHOSTUNREACH
case(EHOSTUNREACH):
#endif
#ifdef EHOSTDOWN
case(EHOSTDOWN):
#endif
#ifdef ENETRESET
case(ENETRESET):
#endif
#ifdef ENETUNREACH
case(ENETUNREACH):
#endif
#ifdef ENETDOWN
case(ENETDOWN):
#endif
#ifdef ECONNABORTED
case(ECONNABORTED):
#endif
#ifdef EADDRNOTAVAIL
case(EADDRNOTAVAIL):
#endif
return true;
}
return false;
}
const char *get_home()
{
static char *home=NULL;
if(home)
return home;
home=getenv("HOME");
if(home)
return home;
struct passwd *pw=getpwuid(getuid());
if(pw && pw->pw_dir)
return home=pw->pw_dir;
return NULL;
}
const char *get_lftp_home_nocreate()
{
static char *lftp_home=NULL;
if(lftp_home)
return *lftp_home?lftp_home:NULL;
lftp_home=getenv("LFTP_HOME");
if(!lftp_home)
{
const char *h=get_home();
if(h)
lftp_home=xstring::cat(h,"/.lftp",NULL).borrow();
else
return NULL;
}
else
lftp_home=xstrdup(lftp_home);
return *lftp_home?lftp_home:NULL;
}
const char *get_lftp_home_if_exists()
{
const char *home=get_lftp_home_nocreate();
struct stat st;
if(stat(home,&st)==-1 || !S_ISDIR(st.st_mode))
return NULL;
return home;
}
// new XDG directories
const char *get_lftp_dir(char *&cached_dir,const char *env,const char *def)
{
if(cached_dir)
return cached_dir;
// use old existing directory for compatibility
const char *dir=get_lftp_home_if_exists();
if(dir)
return cached_dir=xstrdup(dir);
// use explicit directory if specified, otherwise use default under home
const char *home=getenv(env);
if(home) {
// explicit XDG dir
(void)mkdir(home,0755);
dir=xstring::cat(home,"/lftp",NULL);
} else {
home=get_home();
if(!home)
return NULL;
xstring& path=xstring::get_tmp(home);
path.append('/');
const char *slash=strchr(def,'/');
if(slash) {
path.append(def,slash-def);
(void)mkdir(path,0755);
path.append(slash);
} else {
path.append(def);
}
(void)mkdir(path,0755);
dir=path.append("/lftp");
}
(void)mkdir(dir,0755);
return cached_dir=xstrdup(dir);
}
const char *get_lftp_config_dir()
{
static char *config_dir;
return get_lftp_dir(config_dir,"XDG_CONFIG_HOME",".config");
}
const char *get_lftp_data_dir()
{
static char *data_dir;
return get_lftp_dir(data_dir,"XDG_DATA_HOME",".local/share");
}
const char *get_lftp_cache_dir()
{
static char *cache_dir;
return get_lftp_dir(cache_dir,"XDG_CACHE_HOME",".cache");
}
const char *memrchr(const char *buf,char c,size_t len)
{
buf+=len;
while(len-->0)
if(*--buf==c)
return buf;
return 0;
}
bool is_shell_special(char c)
{
switch (c)
{
case '\'':
case '(': case ')':
case '!': case '{': case '}': /* reserved words */
case '^':
case '$': case '`': /* expansion chars */
case '*': case '[': case '?': case ']': /* globbing chars */
case ' ': case '\t': case '\n': /* IFS white space */
case '"': case '\\': /* quoting chars */
case '|': case '&': case ';': /* shell metacharacters */
case '<': case '>':
case '#': /* comment char */
return true;
}
return false;
}
const xstring& shell_encode(const char *string,int len)
{
if(!string)
return xstring::null;
static xstring result;
result.get_space(2 + 2 * len);
char *r = result.get_non_const();
if(string[0]=='-' || string[0]=='~')
{
*r++='.';
*r++='/';
}
int c;
for (const char *s = string; s && (c = *s); s++)
{
if (is_shell_special(c))
*r++ = '\\';
*r++ = c;
}
result.set_length(r-result);
return (result);
}
void remove_tags(char *buf)
{
int len=strlen(buf);
for(;;)
{
char *less=strchr(buf,'<');
char *amp=strstr(buf," ");
if(!less && !amp)
break;
if(amp && (!less || amp<less))
{
amp[0]=' ';
memmove(amp+1,amp+6,len-(amp+6-buf)+1);
len-=amp+6-buf;
buf=amp+1;
continue;
}
char *more=strchr(less+1,'>');
if(!more)
break;
memmove(less,more+1,len-(more+1-buf)+1);
len-=more+1-buf;
buf=less;
}
}
void rtrim(char *s)
{
int len=strlen(s);
while(len>0 && (s[len-1]==' ' || s[len-1]=='\t' || s[len-1]=='\r'))
s[--len]=0;
}
bool in_foreground_pgrp()
{
static int tty_fd;
if(tty_fd==-1)
return true;
pid_t pg=tcgetpgrp(tty_fd);
if(pg==(pid_t)-1 && !isatty(tty_fd)) {
tty_fd=open("/dev/tty",O_RDONLY);
if(tty_fd==-1)
return true;
pg=tcgetpgrp(tty_fd);
}
if(pg==(pid_t)-1 || pg==getpgrp())
return true;
return false;
}
void random_init()
{
static bool init;
if(!init)
{
srandom(time(NULL)+getpid());
init=true;
}
}
double random01()
{
return random()/2147483648.0;
}
#include <sys/utsname.h>
const char *get_nodename()
{
static struct utsname u;
if(uname(&u)==0)
return u.nodename;
return "NODE";
}
const char *xhuman(long long n)
{
char *buf=xstring::tmp_buf(LONGEST_HUMAN_READABLE + 1);
return human_readable(n, buf, human_autoscale|human_SI, 1, 1);
}
const char *xidna_to_ascii(const char *name)
{
#if LIBIDN2
if(!name)
return 0;
static xstring_c name_ace_tmp;
name_ace_tmp.unset();
if(idn2_to_ascii_lz(name,name_ace_tmp.buf_ptr(),0)==IDN2_OK) {
xmalloc_register_block((void*)name_ace_tmp.get());
return name_ace_tmp;
}
#endif//LIBIDN2
return name;
}
bool xtld_name_ok(const char *name)
{
#if LIBIDN2
if(mbswidth(name,MBSW_REJECT_INVALID|MBSW_REJECT_UNPRINTABLE)<=0)
return false;
if(idn2_lookup_ul(name,NULL,0)==IDN2_OK)
return true;
#endif//LIBIDN2
return false;
}
bool is_ipv4_address(const char *s)
{
struct in_addr addr;
return inet_pton(AF_INET,s,&addr)>0;
}
bool is_ipv6_address(const char *s)
{
#if INET6
struct in6_addr addr;
return inet_pton(AF_INET6,s,&addr)>0;
#else
return false;
#endif
}
int lftp_fallocate(int fd,off_t sz)
{
#if defined(HAVE_FALLOCATE)
return fallocate(fd,0,0,sz);
#elif defined(HAVE_POSIX_FALLOCATE)
return posix_fallocate(fd,0,sz);
#else
errno=ENOSYS;
return -1;
#endif
}
void call_dynamic_hook(const char *name) {
#if defined(HAVE_DLOPEN) && defined(RTLD_DEFAULT)
typedef void (*func)();
func f=(func)dlsym(RTLD_DEFAULT,name);
if(f) f();
#endif
}