/* lzop.c --
This file is part of the lzop file compressor.
Copyright (C) 1996-2010 Markus Franz Xaver Johannes Oberhumer
All Rights Reserved.
lzop and the LZO library are free software; you can redistribute them
and/or modify them under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 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; see the file COPYING.
If not, write to the Free Software Foundation, Inc.,
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
Markus F.X.J. Oberhumer
<markus@oberhumer.com>
http://www.oberhumer.com/opensource/lzop/
*/
#include "conf.h"
#include "version.h"
/*************************************************************************
// options
**************************************************************************/
int opt_cmd = CMD_NONE;
int opt_method = 0;
int opt_level = 0;
int opt_filter = 0;
int opt_checksum = -1;
int opt_console = CON_INIT;
lzo_bool opt_crc32 = 0;
lzo_bool opt_decompress_safe = 1;
lzo_bool opt_file = 0;
int opt_force = 0;
lzo_bool opt_ignorewarn = 0;
lzo_bool opt_keep = 0;
int opt_num_threads = 1; /* NOT YET IMPLEMENTED */
#ifdef MAINT
int opt_noheader = 0;
#endif
lzo_bool opt_nowarn = 0;
const char *opt_ls_flags = "";
int opt_name = -1;
const char *opt_output_name = NULL;
const char *opt_output_path = NULL;
lzo_bool opt_optimize = 0;
lzo_bool opt_path = 0;
lzo_bool opt_restore_mode = 1;
lzo_bool opt_restore_time = 1;
lzo_bool opt_shortname = 0;
int opt_stdin = 0;
lzo_bool opt_stdout = 0;
char opt_suffix[1+SUFFIX_MAX+1] = { 0 };
lzo_bool opt_unlink = 0;
int opt_verbose = 1;
static int done_output_name = 0;
static int done_output_path = 0;
static int done_suffix = 0;
/* invocation options */
enum {
PGM_LZOP,
PGM_UNLZOP,
PGM_OCAT
};
int opt_pgm = PGM_LZOP;
const char *argv0 = "";
const char *progname = "";
MODE_T u_mask = 0700;
time_t current_time;
FILE *con_term = NULL;
static int num_files = -1;
static int exit_code = EXIT_OK;
static file_t fi;
static file_t fo;
static unsigned long total_d_files = 0;
static unsigned long total_c_files = 0;
static lzop_ulong_t total_d_len = 0;
static lzop_ulong_t total_c_len = 0;
/* some statistics */
static lzop_ulong_t total_bytes_written = 0;
static lzop_ulong_t total_bytes_read = 0;
/*************************************************************************
// exit handlers
**************************************************************************/
static void do_exit(void)
{
static lzo_bool in_exit = 0;
if (in_exit)
exit(exit_code);
in_exit = 1;
fflush(con_term);
fflush(stderr);
exit(exit_code);
}
#define EXIT_FATAL 3
static lzo_bool set_eec(int ec, int *eec)
{
if (ec == EXIT_FATAL)
{
*eec = EXIT_ERROR;
return 1;
}
else if (ec < 0 || ec == EXIT_ERROR)
{
*eec = EXIT_ERROR;
}
else if (ec == EXIT_WARN)
{
if (!opt_ignorewarn)
if (*eec == EXIT_OK)
*eec = ec;
}
else if (ec == EXIT_OK)
{
/* do nothing */
}
else
{
assert(0);
}
return 0;
}
static lzo_bool set_ec(int ec)
{
return set_eec(ec,&exit_code);
}
void e_exit(int ec)
{
(void) set_ec(ec);
do_exit();
}
void e_usage(void)
{
usage();
e_exit(EXIT_USAGE);
}
void e_memory(void)
{
head();
fflush(con_term);
fprintf(stderr,"%s: out of memory\n", argv0);
e_exit(EXIT_MEMORY);
}
void e_method(int m)
{
fflush(con_term);
#if (UINT_MAX < LZO_0xffffffffL)
/* 16-bit DOS/Windows */
fprintf(stderr,"%s: 16-bit versions are not officially supported\n", argv0);
#endif
fprintf(stderr,"%s: illegal method option -- %c\n", argv0, m & 255);
e_usage();
}
#if defined(OPTIONS_VAR)
void e_envopt(const char *n)
{
fflush(con_term);
if (n)
fprintf(stderr,"%s: invalid string '%s' in environment variable '%s'\n",
argv0, n, OPTIONS_VAR);
else
fprintf(stderr,"%s: illegal option in environment variable '%s'\n",
argv0, OPTIONS_VAR);
e_exit(EXIT_USAGE);
}
#endif
RETSIGTYPE __acc_cdecl_sighandler e_sighandler(acc_signo_t signo)
{
UNUSED(signo);
e_exit(EXIT_FATAL);
}
/*************************************************************************
// error handlers
**************************************************************************/
static void do_error(file_t *ft, const char *n, const char *msg, int ec, int err)
{
const char *fn;
const char *errmsg;
fflush(con_term);
if (!(ec == EXIT_WARN && (opt_nowarn || opt_ignorewarn || opt_verbose == 0)))
{
fn = ft && ft->name[0] ? ft->name : UNKNOWN_NAME;
fprintf(stderr, "%s%s: %s: ", n, progname, fn);
if (ec == EXIT_WARN)
fprintf(stderr, "warning: ");
if (err != 0)
{
errmsg = strerror(err);
if (msg && msg[0])
fprintf(stderr, "%s: %s\n", msg, errmsg);
else
fprintf(stderr, "%s\n", errmsg);
}
else
fprintf(stderr, "%s\n", msg);
fflush(stderr);
}
if (set_ec(ec))
do_exit();
}
static const char *err_nl = "";
void set_err_nl(lzo_bool x)
{
err_nl = x ? "\n" : "";
}
void fatal(file_t *ft, const char *msg)
{
do_error(ft,err_nl,msg,EXIT_FATAL,0);
}
void error(file_t *ft, const char *msg)
{
do_error(ft,err_nl,msg,EXIT_ERROR,0);
}
void warn(file_t *ft, const char *msg)
{
do_error(ft,err_nl,msg,EXIT_WARN,0);
}
void info(file_t *ft, const char *msg)
{
do_error(ft,err_nl,msg,EXIT_OK,0);
}
void p_fatal(file_t *ft, const char *msg)
{
do_error(ft,err_nl,msg,EXIT_FATAL,errno);
}
void p_error(file_t *ft, const char *msg)
{
do_error(ft,err_nl,msg,EXIT_ERROR,errno);
}
void p_warn(file_t *ft, const char *msg)
{
do_error(ft,err_nl,msg,EXIT_WARN,errno);
}
void read_error(file_t *ft)
{
const char *fn = ft && ft->name[0] ? ft->name : UNKNOWN_NAME;
const char *errmsg = "unexpected end of file";
if (errno != 0)
errmsg = strerror(errno);
fflush(con_term);
fprintf(stderr, "%s%s: %s: %s\n", err_nl, progname, errmsg, fn);
e_exit(EXIT_FATAL);
}
void write_error(file_t *ft)
{
const char *fn = ft && ft->name[0] ? ft->name : UNKNOWN_NAME;
const char *errmsg = "write error";
if (errno != 0)
errmsg = strerror(errno);
fflush(con_term);
fprintf(stderr, "%s%s: %s: %s\n", err_nl, progname, errmsg, fn);
e_exit(EXIT_FATAL);
}
/*************************************************************************
// file_t
**************************************************************************/
void f_reset(file_t *ft)
{
ft->opt_name = opt_name;
ft->part = 0;
ft->bytes_read = 0;
ft->bytes_written = 0;
ft->warn_multipart = 0;
ft->warn_unknown_suffix = 0;
}
void f_init(void)
{
memset(&fi,0,sizeof(file_t));
memset(&fo,0,sizeof(file_t));
fi.fd = -1;
fo.fd = -1;
#if defined(USE_FOPEN)
fi.file = NULL;
fo.file = NULL;
#endif
f_reset(&fi);
f_reset(&fo);
}
int f_open(file_t *ft, lzo_bool r)
{
assert(ft->name[0]);
ft->fd = -1;
#if defined(O_BINARY)
ft->open_flags |= O_BINARY;
#endif
#if (ACC_OS_WIN32 || ACC_OS_WIN64) && defined(_O_SEQUENTIAL)
ft->open_flags |= _O_SEQUENTIAL;
#endif
#if defined(USE_FOPEN)
ft->file = NULL;
if (r)
ft->file = fopen(ft->name,"rb");
else if (ft->open_flags & O_EXCL)
{
if (file_exists(ft->name))
errno = EEXIST;
else
ft->file = fopen(ft->name,"wb");
}
else
ft->file = fopen(ft->name,"wb");
if (ft->file != NULL)
{
ft->fd = fileno(ft->file);
assert(ft->fd >= 0);
}
#else
if (r)
ft->fd = open(ft->name, ft->open_flags, 0);
else
{
#if defined(O_EXCL_BROKEN)
if ((ft->open_flags & O_EXCL) && file_exists(ft->name))
errno = EEXIST;
else
#endif
ft->fd = open(ft->name, ft->open_flags, ft->st.st_mode);
}
#endif
if (ft->fd >= 0 && (ft->fd == STDIN_FILENO || ft->fd == STDOUT_FILENO || ft->fd == STDERR_FILENO))
{
fatal(ft,"sanity check failed: f_open()");
ft->fd = -1;
}
return ft->fd;
}
int f_close(file_t *ft)
{
int r;
if (ft->fd < 0)
return 0;
if (ft->fd == STDIN_FILENO || ft->fd == STDOUT_FILENO || ft->fd == STDERR_FILENO)
return 0;
#if defined(USE_FOPEN)
assert(ft->file != NULL);
r = fclose(ft->file);
ft->file = NULL;
#else
r = close(ft->fd);
#endif
ft->fd = -1;
return r;
}
/*************************************************************************
// read and write
// handles partial pipe writes and interrupted system calls
**************************************************************************/
lzo_int read_buf(file_t *ft, lzo_voidp buffer, lzo_int cnt)
{
lzo_int n;
long l;
assert(cnt >= 0 && cnt < LONG_MAX);
l = acc_safe_hread(ft->fd, buffer, (long) cnt);
n = (lzo_int) l;
assert(n >= 0); assert(n == l);
ft->bytes_read += n;
total_bytes_read += n;
return n;
}
void write_buf(file_t *ft, const lzo_voidp buffer, lzo_int cnt)
{
lzo_int n;
long l;
assert(cnt >= 0 && cnt < LONG_MAX);
if (ft->fd < 0)
return;
l = acc_safe_hwrite(ft->fd, buffer, (long) cnt);
n = (lzo_int) l;
assert(n >= 0); assert(n == l);
ft->bytes_written += n;
total_bytes_written += n;
if (n != cnt)
write_error(ft);
}
/*************************************************************************
// misc IO
**************************************************************************/
static unsigned get_be16(const unsigned char *b)
{
unsigned v;
v = (unsigned) b[1] << 0;
v |= (unsigned) b[0] << 8;
return v;
}
static void set_be16(unsigned char *b, unsigned v)
{
b[1] = (unsigned char) (v >> 0);
b[0] = (unsigned char) (v >> 8);
}
static lzo_uint32 get_be32(const unsigned char *b)
{
lzo_uint32 v;
v = (lzo_uint32) b[3] << 0;
v |= (lzo_uint32) b[2] << 8;
v |= (lzo_uint32) b[1] << 16;
v |= (lzo_uint32) b[0] << 24;
return v;
}
static void set_be32(unsigned char *b, lzo_uint32 v)
{
b[3] = (unsigned char) (v >> 0);
b[2] = (unsigned char) (v >> 8);
b[1] = (unsigned char) (v >> 16);
b[0] = (unsigned char) (v >> 24);
}
#if 0 /* NOT USED */
static void write8(file_t *ft, int v)
{
unsigned char b = (unsigned char) v;
write_buf(ft,&b,1);
}
#endif
void read32(file_t *ft, lzo_uint32 *v)
{
unsigned char b[4];
if (read_buf(ft,b,4) != 4)
read_error(ft);
*v = get_be32(b);
}
void write32(file_t *ft, lzo_uint32 v)
{
unsigned char b[4];
set_be32(b,v);
write_buf(ft,b,4);
}
static int f_read8(file_t *ft, unsigned char *b)
{
unsigned char bb;
if (read_buf(ft,&bb,1) != 1)
read_error(ft);
ft->f_adler32 = lzo_adler32(ft->f_adler32,&bb,1);
ft->f_crc32 = lzo_crc32(ft->f_crc32,&bb,1);
if (b)
*b = bb;
return bb;
}
static void f_write8(file_t *ft, int v)
{
unsigned char b = (unsigned char) v;
write_buf(ft,&b,1);
ft->f_adler32 = lzo_adler32(ft->f_adler32,&b,1);
ft->f_crc32 = lzo_crc32(ft->f_crc32,&b,1);
}
static void f_read16(file_t *ft, unsigned *v)
{
unsigned char b[2];
if (read_buf(ft,b,2) != 2)
read_error(ft);
ft->f_adler32 = lzo_adler32(ft->f_adler32,b,2);
ft->f_crc32 = lzo_crc32(ft->f_crc32,b,2);
*v = get_be16(b);
}
static void f_write16(file_t *ft, unsigned v)
{
unsigned char b[2];
set_be16(b,v);
write_buf(ft,b,2);
ft->f_adler32 = lzo_adler32(ft->f_adler32,b,2);
ft->f_crc32 = lzo_crc32(ft->f_crc32,b,2);
}
static void f_read32(file_t *ft, lzo_uint32 *v)
{
unsigned char b[4];
if (read_buf(ft,b,4) != 4)
read_error(ft);
ft->f_adler32 = lzo_adler32(ft->f_adler32,b,4);
ft->f_crc32 = lzo_crc32(ft->f_crc32,b,4);
*v = get_be32(b);
}
static void f_write32(file_t *ft, lzo_uint32 v)
{
unsigned char b[4];
set_be32(b,v);
write_buf(ft,b,4);
ft->f_adler32 = lzo_adler32(ft->f_adler32,b,4);
ft->f_crc32 = lzo_crc32(ft->f_crc32,b,4);
}
static void f_write(file_t *ft, const lzo_voidp buf, lzo_int cnt)
{
if (cnt > 0)
{
write_buf(ft,buf,cnt);
ft->f_adler32 = lzo_adler32(ft->f_adler32,(const lzo_bytep)buf,cnt);
ft->f_crc32 = lzo_crc32(ft->f_crc32,(const lzo_bytep)buf,cnt);
}
}
static lzo_int f_read(file_t *ft, lzo_voidp buf, lzo_int cnt)
{
cnt = read_buf(ft,buf,cnt);
if (cnt > 0)
{
ft->f_adler32 = lzo_adler32(ft->f_adler32,(const lzo_bytep)buf,cnt);
ft->f_crc32 = lzo_crc32(ft->f_crc32,(const lzo_bytep)buf,cnt);
}
return cnt;
}
/***********************************************************************
// lzop file signature
************************************************************************/
/*
* The first nine bytes of a lzop file always contain the following values:
*
* 0 1 2 3 4 5 6 7 8
* --- --- --- --- --- --- --- --- ---
* (hex) 89 4c 5a 4f 00 0d 0a 1a 0a
* (decimal) 137 76 90 79 0 13 10 26 10
* (C notation - ASCII) \211 L Z O \0 \r \n \032 \n
*/
static const unsigned char lzop_magic[9] =
{ 0x89, 0x4c, 0x5a, 0x4f, 0x00, 0x0d, 0x0a, 0x1a, 0x0a };
static const char * const header_error[] = {
"[0]",
"not a " PACKAGE " file", /* 1 */
"header corrupted (checksum error)", /* 2 */
"header corrupted", /* 3 */
"header corrupted (DOS -> UNIX conversion ?)", /* 4 */
"header corrupted (DOS -> Mac conversion ?)", /* 5 */
"header corrupted (UNIX -> Mac conversion ?)", /* 6 */
"header corrupted (Mac -> UNIX conversion ?)", /* 7 */
"header corrupted (UNIX -> DOS conversion ?)", /* 8 */
"header corrupted (end of line conversion ?)", /* 9 */
"header corrupted (DOS EOF conversion ?)", /* 10 */
"header corrupted (transmitted through a 7-bit channel ?)", /* 11 */
"header corrupted (transmitted in text mode ?)", /* 12 */
"unknown header flags -- get a newer version of " PACKAGE, /* 13 */
"unknown compression method -- get a newer version of " PACKAGE, /* 14 */
"unknown compression level -- get a newer version of " PACKAGE, /* 15 */
"you need a newer version of " PACKAGE, /* 16 */
"compression method not supported -- recompile " PACKAGE, /* 17 */
"decompression method not supported -- recompile " PACKAGE, /* 18 */
NULL
};
static int check_magic(const unsigned char *magic)
{
const unsigned char *m;
if (memcmp(magic,lzop_magic,sizeof(lzop_magic)) == 0)
return 0;
/* We have a bad magic signature. Try to figure what possibly
* could have gone wrong. */
/* look at bytes 1-3: "LZO" in hex and local text format */
if (memcmp(&magic[1],&lzop_magic[1],3) != 0 &&
memcmp(&magic[1],"LZO",3) != 0)
return 1;
/* look at byte 4 */
if (magic[4] != lzop_magic[4])
return 1;
/* look at bytes 5-8 */
m = &magic[5];
if (memcmp(m,"\012\012\032",3) == 0)
return 7;
if (memcmp(m,"\012\012",2) == 0)
return 4;
if (memcmp(m,"\012\032",2) == 0)
return 4;
if (memcmp(m,"\015\012\012",3) == 0)
return 10;
if (memcmp(m,"\015\012\032\012",4) == 0)
return 9;
if (memcmp(m,"\015\012\032\015",4) == 0)
return 8;
if (memcmp(m,"\015\015\012\032",4) == 0)
return 8;
if (memcmp(m,"\015\015\032",3) == 0)
return 6;
if (memcmp(m,"\015\032",2) == 0)
return 5;
if (memcmp(m,&lzop_magic[5],4) != 0)
return 12;
/* look at byte 0 */
if (magic[0] == (unsigned char) (lzop_magic[0] & 0x7f))
return 11;
if (magic[0] != lzop_magic[0])
return 12;
return 3;
}
/*************************************************************************
// lzop file header
**************************************************************************/
void init_compress_header(header_t *h, const file_t *fip, const file_t *fop)
{
assert(opt_method > 0);
assert(opt_level > 0);
assert(fip->st.st_mode == 0 || S_ISREG(fip->st.st_mode));
memset(h,0,sizeof(header_t));
h->version = LZOP_VERSION & 0xffff;
h->version_needed_to_extract = opt_filter ? 0x0950: 0x0940;
h->lib_version = lzo_version() & 0xffff;
h->method = (unsigned char) opt_method;
h->level = (unsigned char) opt_level;
h->filter = opt_filter;
h->flags = 0;
h->flags |= F_OS & F_OS_MASK;
h->flags |= F_CS & F_CS_MASK;
if (opt_filter)
h->flags |= F_H_FILTER;
if (fip->fd == STDIN_FILENO)
h->flags |= F_STDIN;
if (fop->fd == STDOUT_FILENO)
h->flags |= F_STDOUT;
if (!opt_file && num_files > 1)
h->flags |= F_MULTIPART;
#ifdef OPT_NAME_DEFAULT
h->flags |= F_NAME_DEFAULT;
#endif
#ifdef DOSISH
h->flags |= F_DOSISH;
#endif
if (opt_crc32)
{
h->flags |= F_H_CRC32;
if (h->version_needed_to_extract < 0x1001)
h->version_needed_to_extract = 0x1001;
}
h->mode = fix_mode_for_header(fip->st.st_mode);
if (fip->st.st_mtime)
{
h->mtime_low = (lzo_uint32) (fip->st.st_mtime);
h->mtime_high = (lzo_uint32) (fip->st.st_mtime >> 16 >> 16);
if ((lzo_int32) h->mtime_high < 0)
h->mtime_high = 0;
}
if (fip->name[0] && fip->fd != STDIN_FILENO)
{
int r = 0;
if (opt_path)
{
char newname[255+1];
r = fn_cleanpath(fip->name, newname, sizeof(newname), 0);
if (r > 0 && newname[0] && strlen(newname) <= 255)
{
strcpy(h->name, newname);
h->flags |= F_H_PATH;
if (h->version_needed_to_extract < 0x1001)
h->version_needed_to_extract = 0x1001;
}
else
r = 0;
}
if (r == 0)
{
const char *n = fn_basename(fip->name);
if (n[0] && strlen(n) <= 255)
strcpy(h->name, n);
}
}
}
void write_header(file_t *ft, const header_t *h)
{
size_t l;
#ifdef MAINT
/* undocumented option '--no-header'. just for testing. */
if (opt_noheader > 0)
{
switch (opt_noheader)
{
case 1:
write32(ft,h->flags);
break;
case 2:
write32(ft,h->flags);
write8(ft,h->method);
write8(ft,h->level);
break;
default:
/* write no header at all */
break;
}
return;
}
#endif
write_buf(ft,lzop_magic,sizeof(lzop_magic));
ft->f_adler32 = ADLER32_INIT_VALUE;
ft->f_crc32 = CRC32_INIT_VALUE;
f_write16(ft,h->version);
f_write16(ft,h->lib_version);
f_write16(ft,h->version_needed_to_extract);
f_write8(ft,h->method);
f_write8(ft,h->level);
f_write32(ft,h->flags);
if (h->flags & F_H_FILTER)
f_write32(ft,h->filter);
f_write32(ft,h->mode);
f_write32(ft,h->mtime_low);
f_write32(ft,h->mtime_high);
l = strlen(h->name);
assert(l <= 255);
f_write8(ft,(int)l);
if (l > 0)
f_write(ft,h->name,(int)l);
if (h->flags & F_H_CRC32)
f_write32(ft,ft->f_crc32);
else
f_write32(ft,ft->f_adler32);
}
static int read_header(file_t *ft, header_t *h)
{
int r;
int l;
lzo_uint32 checksum;
memset(h,0,sizeof(header_t));
h->version_needed_to_extract = 0x0900; /* first public lzop version */
h->level = 0;
h->method_name = "unknown";
ft->f_adler32 = ADLER32_INIT_VALUE;
ft->f_crc32 = CRC32_INIT_VALUE;
f_read16(ft,&h->version);
if (h->version < 0x0900)
return 3;
f_read16(ft,&h->lib_version);
if (h->version >= 0x0940)
{
f_read16(ft,&h->version_needed_to_extract);
if (h->version_needed_to_extract > LZOP_VERSION)
return 16;
if (h->version_needed_to_extract < 0x0900)
return 3;
}
f_read8(ft,&h->method);
if (h->version >= 0x0940)
f_read8(ft,&h->level);
f_read32(ft,&h->flags);
if (h->flags & F_H_FILTER)
f_read32(ft,&h->filter);
f_read32(ft,&h->mode);
#if 1
if (h->flags & F_STDIN) /* do not use mode from stdin compression */
h->mode = 0;
#endif
f_read32(ft,&h->mtime_low);
if (h->version >= 0x0940)
f_read32(ft,&h->mtime_high);
if (h->version < 0x0120) {
if (h->mtime_low == 0xffffffffUL)
h->mtime_low = 0;
h->mtime_high = 0;
}
l = f_read8(ft,NULL);
if (l > 0) {
char name[255+1];
if (f_read(ft,name,l) != l)
read_error(ft);
name[l] = 0;
if (fn_cleanpath(name, h->name, 255+1, 1|2) < 0)
h->name[0] = 0;
}
checksum = (h->flags & F_H_CRC32) ? ft->f_crc32 : ft->f_adler32;
f_read32(ft,&h->header_checksum);
if (h->header_checksum != checksum)
return 2;
if (h->method <= 0)
return 14;
r = x_get_method(h);
if (r != 0)
return r;
/* check reserved flags */
if (h->flags & F_RESERVED)
return (opt_force >= 2) ? -13 : 13;
/* skip extra field [not used yet] */
if (h->flags & F_H_EXTRA_FIELD)
{
lzo_uint32 k;
/* note: the checksum also covers the length */
ft->f_adler32 = ADLER32_INIT_VALUE;
ft->f_crc32 = CRC32_INIT_VALUE;
f_read32(ft,&h->extra_field_len);
for (k = 0; k < h->extra_field_len; k++)
(void) f_read8(ft,NULL);
checksum = (h->flags & F_H_CRC32) ? ft->f_crc32 : ft->f_adler32;
f_read32(ft,&h->extra_field_checksum);
if (h->extra_field_checksum != checksum)
return 3;
if (opt_verbose >= 2)
info(ft,"ignoring extra field");
}
return 0;
}
/* return 0 for valid magic, -1 for EOF, or positive value for error */
static int p_magic(file_t *ft)
{
int r;
lzo_int l;
unsigned char magic[sizeof(lzop_magic)];
l = read_buf(ft,magic,sizeof(magic));
if (ft->part > 0 && l <= 0)
return -1;
if (l == (lzo_int) sizeof(magic))
r = check_magic(magic);
else
r = 1;
assert(r >= 0);
if (ft->part > 0 && r == 1)
{
#if 1
/* gzip: check for trailing zero bytes */
unsigned char b;
while (--l >= 0)
if (magic[(int)l] != '\0')
goto garbage;
while (read_buf(ft,&b,1) == 1)
if (b != '\0')
goto garbage;
if (opt_verbose >= 2)
warn(ft,"ignoring trailing zero bytes in " PACKAGE " file");
return -1;
garbage:
#endif
warn(ft,"ignoring trailing garbage in " PACKAGE " file");
return -1;
}
if (r != 0)
{
assert(r > 0 && r <= 18);
error(ft,header_error[r]);
}
return r;
}
static lzo_bool p_header(file_t *ft, header_t *h)
{
int r;
r = read_header(ft,h);
if (r == 0)
return 1;
if (r < 0)
{
r = -r;
assert(r > 0 && r <= 18);
error(ft,header_error[r]);
return 1;
}
else
{
assert(r > 0 && r <= 18);
error(ft,header_error[r]);
return 0;
}
}
/*************************************************************************
// test
**************************************************************************/
void do_test(const header_t *h, lzop_ulong_t d_len, lzop_ulong_t c_len)
{
total_d_files++;
total_c_len += c_len;
total_d_len += d_len;
UNUSED(h);
}
void do_test_total(void)
{
FILE *f;
if ((total_c_files < 2 && total_d_files < 2) || opt_verbose < 2)
return;
f = stderr;
fprintf(f,"%lu file%s successfully tested", total_c_files,
total_c_files == 1 ? " was" : "s were");
if (total_c_files != total_d_files)
fprintf(f," [containing %lu files]", total_d_files);
fprintf(f,"\n");
fflush(f);
}
/*************************************************************************
// list a file
**************************************************************************/
static unsigned long get_ratio(lzop_ulong_t d_len, lzop_ulong_t c_len)
{
unsigned long n1 = 1000L * 1000L;
unsigned long n2 = 1;
const lzop_ulong_t umax = ~((lzop_ulong_t)0);
if (d_len <= 0)
return c_len <= 0 ? 0ul : n1;
while (n1 > 1 && c_len > (umax / n1))
{
n1 /= 10;
n2 *= 10;
}
return (unsigned long) ((c_len * n1) / (d_len / n2));
}
static void pr_size(FILE *f, lzop_ulong_t a, lzop_ulong_t b, int flags)
{
unsigned long ratio, r1, r2, al, bl;
ratio = (flags & 1) ? get_ratio(a, b) : get_ratio(b, a);
ratio += 500; /* for rounding */
r1 = ratio / 10000;
r2 = (ratio % 10000) / 1000;
#if (SIZEOF_LONG >= 8) || !defined(acc_int64l_t)
al = (unsigned long) a;
bl = (unsigned long) b;
fprintf(f,"%9lu %9lu %3lu.%01lu%%", al, bl, r1, r2);
#else
al = (unsigned long) (a % 1000000000ul);
bl = (unsigned long) (b % 1000000000ul);
if (a == al && b == bl)
{
fprintf(f,"%9lu %9lu %3lu.%01lu%%", al, bl, r1, r2);
}
else if (a == al)
{
unsigned long bh = (unsigned long) (b / 1000000000ul);
fprintf(f,"%9lu %lu%09lu %3lu.%01lu%%", al, bh, bl, r1, r2);
}
else if (b == bl)
{
unsigned long ah = (unsigned long) (a / 1000000000ul);
fprintf(f,"%lu%09lu %9lu %3lu.%01lu%%", ah, al, bl, r1, r2);
}
else
{
unsigned long ah = (unsigned long) (a / 1000000000ul);
unsigned long bh = (unsigned long) (b / 1000000000ul);
fprintf(f,"%lu%09lu %lu%09lu %3lu.%01lu%%", ah, al, bh, bl, r1, r2);
}
#endif
}
static char *modestr(lzo_uint32 mode)
{
static char s[10+1];
mode_string(fix_mode_for_ls(mode),s);
s[0] = '-';
s[10] = 0;
return s;
}
void do_list(const header_t *h, lzop_ulong_t d_len, lzop_ulong_t c_len)
{
FILE *f;
char s[40];
time_t t;
f = stdout;
s[0] = 0;
t = get_mtime(h);
if (total_d_files == 0 && opt_verbose > 0)
{
if (opt_verbose >= 3)
((void)0);
else if (opt_verbose >= 2)
{
fprintf(f,"Method Length Packed Ratio ");
fprintf(f," Date Time Name\n");
fprintf(f,"------ ------ ------ ----- ");
fprintf(f," ---- ---- ----\n");
}
else
{
fprintf(f,"%-11s ", "method");
fprintf(f,"compressed uncompr. ratio");
fprintf(f," uncompressed_name\n");
}
fflush(f);
}
if (opt_verbose >= 3)
{
fprintf(f,"%-10s", modestr(h->mode));
if (t)
time2str(s,sizeof(s),&t);
fprintf(f," %-19s",s);
fprintf(f," %-20s",fi.name);
if (fo.name[0])
fprintf(f," %s", fo.name);
}
else if (opt_verbose >= 2)
{
fprintf(f,"%-11s ", h->method_name);
pr_size(f, d_len, c_len, 1);
if (t)
time2str(s,sizeof(s),&t);
s[16] = 0; /* cut off seconds */
fprintf(f," %-16s",s);
if (fo.name[0])
fprintf(f," %s", fo.name);
}
else
{
fprintf(f,"%-11s ", h->method_name);
pr_size(f, c_len, d_len, 0);
if (fo.name[0])
fprintf(f," %s", fo.name);
}
fprintf(f,"\n");
fflush(f);
total_d_files++;
total_c_len += c_len;
total_d_len += d_len;
}
void do_list_total(void)
{
FILE *f;
if (total_d_files < 2 || opt_verbose == 0)
return;
if (opt_verbose >= 3)
return;
f = stdout;
if (opt_verbose >= 2)
{
fprintf(f," ------- ------- ----- ");
fprintf(f," ----\n");
fprintf(f,"%-11s ", "");
pr_size(f, total_d_len, total_c_len, 1);
fprintf(f," %-16s", "");
fprintf(f," %lu files\n", total_d_files);
}
else
{
fprintf(f,"%-11s ", "");
pr_size(f, total_c_len, total_d_len, 0);
fprintf(f," (totals -- %lu files)\n", total_d_files);
}
fflush(f);
}
/*************************************************************************
// list a file similar to 'ls -ln'
**************************************************************************/
void do_ls(const header_t *h, lzop_ulong_t d_len, lzop_ulong_t c_len)
{
FILE *f;
char s[40];
time_t t;
const char *name = fo.name[0] ? fo.name : UNKNOWN_NAME;
f = stdout;
t = get_mtime(h);
if (t == 0)
time(&t);
fprintf(f,"%-10s 1", modestr(h->mode));
if (opt_stdin)
fprintf(f," %-8s", "user");
else
fprintf(f," %-8ld", (long) fi.st.st_uid);
if (!strchr(opt_ls_flags,'G'))
{
if (opt_stdin)
fprintf(f," %-8s", "group");
else
fprintf(f," %-8ld", (long) fi.st.st_gid);
}
#if (SIZEOF_LONG >= 8) || !defined(acc_int64l_t)
fprintf(f," %8lu", (unsigned long) d_len);
#else
{
unsigned long d0, d1, d2;
d0 = (unsigned long) (d_len % 100000000ul);
if (d0 == d_len)
fprintf(f," %8lu", d0);
else
{
d1 = (unsigned long) ((d_len / 100000000ul) % 100000000ul);
d2 = (unsigned long) ((d_len / 100000000ul) / 100000000ul);
if (d2 != 0)
fprintf(f,"%lu%08lu%08lu", d2, d1, d0);
else
fprintf(f,"%lu%08lu", d1, d0);
}
}
#endif
time2ls(s, sizeof(s), &t);
fprintf(f," %-12s",s);
if (strchr(opt_ls_flags,'Q'))
fprintf(f," \"%s\"", name);
else
fprintf(f," %s", name);
if (strchr(opt_ls_flags,'F'))
if (h->mode & 0111)
fprintf(f,"*");
fprintf(f,"\n");
fflush(f);
UNUSED(c_len);
}
/*************************************************************************
// header info
**************************************************************************/
static void print_version(FILE *f, unsigned v)
{
fprintf(f,"%1x.%03x", (v >> 12) & 0xf, v & 0xfff);
}
static void print_os(FILE *f, lzo_uint32 flags)
{
flags = (flags & F_OS_MASK) >> F_OS_SHIFT;
fprintf(f,"%2ld", (long) flags);
}
void do_info(const header_t *h, lzop_ulong_t d_len, lzop_ulong_t c_len)
{
int v = opt_verbose;
FILE *f;
f = stdout;
opt_verbose = 2;
++total_d_files; /* do not print the list-header */
do_list(h,d_len,c_len);
--total_d_files;
opt_verbose = v;
fprintf(f," ");
print_version(f,h->version);
fprintf(f," ");
print_version(f,h->lib_version);
fprintf(f," ");
print_version(f,h->version_needed_to_extract);
fprintf(f," Fl: 0x%08lx", (long) h->flags);
fprintf(f," Mo: 0%011lo", (long) h->mode);
fprintf(f," Me: %d/%d", h->method, h->level);
fprintf(f," OS: ");
print_os(f,h->flags);
if (h->filter)
fprintf(f," Fi: %3ld", (long) h->filter);
fprintf(f,"\n");
}
/*************************************************************************
// determine name of output file
**************************************************************************/
static lzo_bool can_restore_name(file_t *ft, const header_t *h)
{
if (h->name[0] == 0 || ft->opt_name == 0)
return 0;
else if (ft->opt_name > 0)
return 1;
#ifdef OPT_NAME_DEFAULT
#if 1
else
return 1;
#else
/* restore the name by default only when created on such a system */
else if ((h->flags & F_NAME_DEFAULT))
return 1;
else
return 0;
#endif
#else
/* do not restore the name by default */
else
return 0;
#endif /* OPT_NAME_DEFAULT */
}
static lzo_bool oname_error(void)
{
if (opt_force >= 2 || opt_cmd == CMD_TEST)
{
warn(&fi,"can't determine name of output file -- using default");
return 1;
}
if (opt_name != 1)
error(&fi,"can't determine name of output file (try option '-N')");
else
error(&fi,"can't determine name of output file (use option '-o')");
strcpy(fo.name,UNKNOWN_NAME);
return 0;
}
static lzo_bool p_set_oname(const header_t *h)
{
char *base;
char *ext;
int suff;
size_t l;
const char *err_name;
const char *s;
size_t sl;
fo.name[0] = 0;
if (opt_output_name)
{
/* name given on command line; perform no additional checks */
strcpy(fo.name,opt_output_name);
return 1;
}
assert(!opt_stdout);
assert(opt_file);
#if defined(NRVP)
err_name = (opt_cmd == CMD_COMPRESS) ? "nrvp.nrv" : "nrvp.raw";
s = opt_suffix[0] ? opt_suffix : ".nrv";
#else
err_name = (opt_cmd == CMD_COMPRESS) ? "lzop.lzo" : "lzop.raw";
s = opt_suffix[0] ? opt_suffix : ".lzo";
#endif
sl = strlen(s);
if (opt_output_path)
{
strcpy(fo.name,opt_output_path);
fn_addslash(fo.name,1);
if (!opt_stdin)
strcat(fo.name,fn_basename(fi.name));
}
else if (!opt_stdin)
strcpy(fo.name,fi.name);
l = strlen(fo.name);
if (l >= PATH_MAX)
{
error(&fo,"name too long (use option '-o')");
return 0;
}
base = fo.name + fn_baseindex(fo.name);
suff = fn_has_suffix(base);
ext = strchr(base,'.');
if (opt_cmd == CMD_COMPRESS)
{
assert(!opt_stdin);
assert(base[0]);
#if defined(DOSISH)
if (suff == SUFF_TAR)
{
#if defined(NRVP)
strcpy(ext, opt_suffix[0] ? opt_suffix : ".tnv");
#else
strcpy(ext, opt_suffix[0] ? opt_suffix : ".tzo");
#endif
}
else
#endif
if (opt_shortname && ext)
strcpy(ext,s);
else
strcat(fo.name,s);
}
else
{
lzo_bool u = 0;
if (can_restore_name(&fi,h))
{
if (opt_path)
strcpy(base,h->name);
else
strcpy(base,fn_basename(h->name));
}
else if (opt_stdin)
{
if (!oname_error())
return 0;
strcpy(base,err_name);
}
else if (suff == SUFF_LZO)
fo.name[l-4] = 0;
else if (suff == SUFF_LZOP)
fo.name[l-5] = 0;
else if (suff == SUFF_NRV)
fo.name[l-4] = 0;
else if (suff == SUFF_TZO)
strcpy(&fo.name[l-4],".tar");
else if (suff == SUFF_USER)
fo.name[l-sl] = 0;
else
{
u = 1;
if (opt_shortname && ext)
strcpy(ext,".raw");
else
strcat(fo.name,".raw");
}
if (u && opt_cmd == CMD_DECOMPRESS && !opt_stdin)
{
#if 1
if (!(opt_force >= 2))
{
if (fi.warn_unknown_suffix == 0)
error(&fi,"unknown suffix -- ignored");
fi.warn_unknown_suffix = 1;
return 0;
}
#else
/* gzip: '--force' doesn't override these checks */
if (fi.warn_unknown_suffix == 0)
error(&fi,"unknown suffix -- ignored");
fi.warn_unknown_suffix = 1;
return 0;
#endif
}
}
if (strlen(fo.name) >= PATH_MAX)
{
error(&fo,"name too long (use option '-o')");
return 0;
}
#if defined(DOSISH)
s = maybe_rename_file(fo.name);
if (s == NULL)
{
if (!oname_error())
return 0;
strcpy(base,err_name);
}
else if (s != fo.name)
{
if (strcmp(s,fo.name) != 0)
{
warn(&fo,"renaming output file to match OS conventions");
strcpy(fo.name,s);
}
}
#endif
UNUSED(ext);
return 1;
}
/*************************************************************************
// stdin/stdout
**************************************************************************/
static lzo_bool check_stdin(file_t *ft)
{
if (!opt_force && acc_isatty(STDIN_FILENO))
{
strcpy(ft->name,STDIN_NAME);
if (opt_cmd == CMD_COMPRESS)
fatal(ft,"uncompressed data not read from a terminal");
else
fatal(ft,"compressed data not read from a terminal");
return 0;
}
return 1;
}
static lzo_bool check_stdout(file_t *ft)
{
if (!(opt_cmd == CMD_COMPRESS || opt_cmd == CMD_DECOMPRESS))
return 1;
if (!opt_force && acc_isatty(STDOUT_FILENO))
{
strcpy(ft->name,STDOUT_NAME);
if (opt_cmd == CMD_COMPRESS)
fatal(ft,"compressed data not written to a terminal");
else
fatal(ft,"uncompressed data not written to a terminal");
return 0;
}
return 1;
}
static lzo_bool open_stdin(file_t *ft)
{
static lzo_bool setmode_done = 0;
assert(ft->fd == -1);
f_reset(ft);
strcpy(ft->name,STDIN_NAME);
ft->fd = STDIN_FILENO;
#if !defined(NO_SETMODE)
if (!setmode_done)
{
if (acc_set_binmode(ft->fd, 1) == -1)
{
p_fatal(ft,"acc_set_binmode(stdin) failed");
return 0;
}
}
#endif
setmode_done = 1;
ft->st.st_mtime = time(NULL);
#if 1 && defined(HAVE_FSTAT)
{
struct stat st;
if (fstat(ft->fd, &st) == 0 && S_ISREG(st.st_mode))
ft->st = st;
}
#endif
ft->st.st_atime = fix_time(ft->st.st_atime);
ft->st.st_mtime = fix_time(ft->st.st_mtime);
return 1;
}
static lzo_bool open_stdout(file_t *ft)
{
static lzo_bool setmode_done = 0;
assert(ft->fd == -1);
f_reset(ft);
strcpy(ft->name,STDOUT_NAME);
if (!(opt_cmd == CMD_COMPRESS || opt_cmd == CMD_DECOMPRESS))
{
ft->fd = -2; /* special file-handle for dummy output */
return 1;
}
ft->fd = STDOUT_FILENO;
#if !defined(NO_SETMODE)
if (!setmode_done)
{
if (acc_set_binmode(ft->fd, 1) == -1)
{
p_fatal(ft,"acc_set_binmode(stdout) failed");
return 0;
}
}
#endif
setmode_done = 1;
return 1;
}
/*************************************************************************
// open input file
**************************************************************************/
lzo_bool p_open_fi(const char *name)
{
int r, saved_errno;
#if defined(HAVE_LSTAT) && defined(S_ISLNK)
int r2;
#endif
if (fi.fd != -1)
return 1;
f_reset(&fi);
/* prepare file name */
assert(name != NULL);
if (strlen(name) >= PATH_MAX)
{
if (strlen(name) >= sizeof(fi.name))
strcpy(fi.name,UNKNOWN_NAME);
else
strcpy(fi.name,name);
error(&fi,"name too long");
return 0;
}
strcpy(fi.name,name);
fn_strlwr(fi.name);
if (opt_cmd == CMD_COMPRESS)
{
int suff = fn_has_suffix(fi.name);
#if 1
if (opt_stdout || opt_output_name)
suff = SUFF_NONE; /* do not warn */
#endif
#if 1
if (opt_force >= 2)
suff = SUFF_NONE; /* do not warn */
#else
/* gzip: '--force' doesn't override these checks */
#endif
if (suff == SUFF_LZO)
{
warn(&fi,"already has .lzo suffix -- unchanged");
return 0;
}
else if (suff == SUFF_LZOP)
{
warn(&fi,"already has .lzop suffix -- unchanged");
return 0;
}
else if (suff == SUFF_NRV)
{
warn(&fi,"already has .nrv suffix -- unchanged");
return 0;
}
else if (suff == SUFF_TZO)
{
warn(&fi,"already has .tzo suffix -- unchanged");
return 0;
}
else if (suff == SUFF_USER)
{
warn(&fi,"already has user suffix -- unchanged");
return 0;
}
}
/* open file */
errno = 0;
r = stat(fi.name, &fi.st);
saved_errno = errno;
if (r != 0)
memset(&fi.st, 0, sizeof(fi.st));
#if defined(HAVE_LSTAT) && defined(S_ISLNK)
r2 = lstat(fi.name, &fi.lst);
if (r2 != 0)
memset(&fi.lst, 0, sizeof(fi.lst));
if (r2 == 0 && S_ISLNK(fi.lst.st_mode))
{
if (r != 0)
{
errno = saved_errno;
#if 0
p_error(&fi,"can't open input file -- dangling symlink");
#else
do_error(&fi,err_nl,"can't open input file: Dangling symlink",EXIT_ERROR,0);
#endif
return 0;
}
}
#endif
if (r == 0 && !S_ISREG(fi.st.st_mode))
{
warn(&fi,"not a regular file -- skipped");
return 0;
}
fi.open_flags = O_RDONLY;
f_open(&fi,1);
#if 0 && defined(__DJGPP__)
/* try again without LFN */
if (fi.fd < 0 && errno == ENOENT && _USE_LFN)
{
if (!(_crt0_startup_flags & _CRT0_FLAG_NO_LFN))
{
int k = _crt0_startup_flags;
_crt0_startup_flags |= _CRT0_FLAG_NO_LFN;
r = stat(fi.name, &fi.st);
saved_errno = errno;
_crt0_startup_flags = k;
if (r == 0 && !S_ISREG(fi.st.st_mode))
{
warn(&fi,"not a regular file -- skipped");
return 0;
}
f_open(&fi,1);
}
}
#endif
if (fi.fd < 0)
{
p_error(&fi,"can't open input file");
return 0;
}
if (r != 0)
{
errno = saved_errno;
p_error(&fi,"can't stat input file");
(void) f_close(&fi);
return 0;
}
fi.st.st_atime = fix_time(fi.st.st_atime);
fi.st.st_mtime = fix_time(fi.st.st_mtime);
return 1;
}
/*************************************************************************
// open output file
**************************************************************************/
lzo_bool p_open_fo(const header_t *h)
{
if (fo.fd != -1)
return 1;
f_reset(&fo);
if (!p_set_oname(h))
return 0;
fn_strlwr(fo.name);
if (!(opt_cmd == CMD_COMPRESS || opt_cmd == CMD_DECOMPRESS))
{
fo.fd = opt_output_name ? -2 : -1;
return 1;
}
if (fn_is_same_file(fi.name,fo.name))
{
if (opt_cmd == CMD_COMPRESS)
error(&fi,"can't compress to same file");
else
error(&fi,"can't decompress to same file");
return 0;
}
fo.open_flags = O_CREAT | O_WRONLY;
if (opt_force)
fo.open_flags |= O_TRUNC;
else
fo.open_flags |= O_EXCL;
#if defined(__MINT__)
fo.open_flags |= O_TRUNC | O_DENYRW;
#endif
fo.st.st_mode = fix_mode_for_open(fi.st.st_mode);
if (opt_cmd == CMD_DECOMPRESS && opt_path && (h->flags & F_H_PATH))
{
/* create missing directories */
char *name;
int n = 0;
name = fo.name;
while (name[n])
{
while (name[n] && name[n] != '/')
n++;
if (name[n] == '/')
{
name[n] = 0;
(void) acc_mkdir(name, 0777);
name[n] = DIR_SEP[0];
n++;
}
}
}
f_open(&fo,0);
if (fo.fd < 0)
{
if ((fo.open_flags & O_EXCL) && errno == EEXIST)
error(&fo,"already exists; not overwritten");
else
p_error(&fo,"can't open output file");
return 0;
}
return 1;
}
/*************************************************************************
// close files
**************************************************************************/
static lzo_bool p_close(int i, int o)
{
int r = 1;
if (i && f_close(&fi) != 0)
{
p_error(&fi,"can't close input file");
r = 0;
}
if (o && f_close(&fo) != 0)
{
p_error(&fo,"can't close output file");
r = 0;
}
return r;
}
/*************************************************************************
// compress
**************************************************************************/
static void copy_perms(void)
{
#if defined(HAVE_UTIME)
/* copy the time stamp */
struct utimbuf u;
u.actime = fi.st.st_atime;
u.modtime = fi.st.st_mtime;
if (utime(fo.name,&u) != 0)
p_warn(&fo,"can't copy file time");
#endif
#if defined(HAVE_CHMOD)
/* copy the protection mode */
fo.st.st_mode = fi.st.st_mode;
if (chmod(fo.name, fo.st.st_mode) != 0)
p_warn(&fo,"can't copy file mode");
#endif
#if defined(HAVE_CHOWN)
/* copy the ownership */
if (chown(fo.name, fi.st.st_uid, fi.st.st_gid) != 0) {
/* ignore */
}
#endif
}
static lzo_bool do_compress(const char *name, lzo_bool handle_perms)
{
lzo_bool ok = 1;
header_t header;
if (!p_open_fi(name))
return 0;
if (!p_open_fo(NULL))
{
if (opt_output_name || opt_stdout)
e_exit(EXIT_ERROR);
return 0;
}
ok = x_compress(&fi,&fo,&header);
if (!ok)
return 0;
if (handle_perms)
{
if (!p_close(1,1))
return 0;
copy_perms();
}
return ok;
}
/*************************************************************************
// decompress
**************************************************************************/
static void restore_perms(const header_t *h)
{
#if defined(HAVE_UTIME)
/* restore or copy the time stamp */
struct utimbuf u;
if (opt_restore_time && (h->mtime_low || h->mtime_high))
{
u.actime = u.modtime = get_mtime(h);
if (u.actime)
if (utime(fo.name,&u) != 0)
p_warn(&fo,"can't restore file time");
}
else if (fi.st.st_atime && fi.st.st_mtime)
{
u.actime = fi.st.st_atime;
u.modtime = fi.st.st_mtime;
if (utime(fo.name,&u) != 0)
p_warn(&fo,"can't copy file time");
}
#endif
#if defined(HAVE_CHMOD)
/* restore or copy the protection mode */
if (opt_restore_mode && h->mode)
{
fo.st.st_mode = fix_mode_for_chmod(h->mode);
if (chmod(fo.name, fo.st.st_mode) != 0)
p_warn(&fo,"can't restore file mode");
}
else if (fi.st.st_mode > 0)
{
fo.st.st_mode = fi.st.st_mode;
if (chmod(fo.name, fo.st.st_mode) != 0)
p_warn(&fo,"can't copy file mode");
}
#endif
#if defined(HAVE_CHOWN)
/* copy the ownership */
if (!opt_stdin)
if (chown(fo.name, fi.st.st_uid, fi.st.st_gid) != 0) {
/* ignore */
}
#endif
UNUSED(h);
}
static lzo_bool warn_multipart(file_t *ft, const header_t *h)
{
if (!((ft->part > 0) || (h->flags & F_MULTIPART)))
return 1;
if (opt_stdin && opt_stdout && opt_cmd == CMD_TEST && can_restore_name(ft,h))
return 1;
if (opt_stdout || opt_output_name)
{
if (!ft->warn_multipart)
warn(&fi,"this is a multipart archive (try option '-N')");
ft->warn_multipart = 1;
}
else if (opt_file && !can_restore_name(ft,h))
{
ft->opt_name = 1;
if (opt_cmd == CMD_TEST)
{
if (!ft->warn_multipart)
warn(&fi,"this is a multipart archive (try option '-N')");
ft->warn_multipart = 1;
}
else if (can_restore_name(ft,h))
{
if (!ft->warn_multipart)
warn(&fi,"multipart archive -- restoring file names");
ft->warn_multipart = 1;
}
else
{
error(&fi,"multipart archive, but no filename stored (use option '-o')");
return 0;
}
}
return 1;
}
static lzo_bool do_decompress(const char *name, lzo_bool handle_perms)
{
lzo_bool ok = 1;
lzo_bool unlink_ok = 1;
lzo_bool skip = 0;
header_t header;
int r;
if (!p_open_fi(name))
return 0;
for ( ; ok; fi.part++)
{
r = p_magic(&fi);
if (r > 0)
return 0;
if (fi.part == 0)
total_c_files++;
if (fi.part > 0 && (opt_file || (r < 0 && handle_perms)))
{
if (!p_close(0,1))
return 0;
if (!skip && handle_perms && (opt_file || (r < 0 && fi.part == 1)))
restore_perms(&header);
}
if (r < 0)
{
assert(fi.part > 0);
break;
}
if (!p_header(&fi,&header))
{
/* use '--info -f -f' to try to list a corrupted header */
if (opt_cmd == CMD_INFO && opt_force >= 2)
{
(void) x_get_method(&header);
do_info(&header,0,0);
}
return 0;
}
#if 0
/* debug */
do_info(&header,0,0);
#endif
if (!warn_multipart(&fi,&header))
return 0;
skip = 0;
ok = p_open_fo(&header);
if (!ok)
{
unlink_ok = 0;
if (opt_output_name || opt_stdout)
e_exit(EXIT_ERROR);
if (opt_cmd != CMD_TEST)
skip = 1;
}
ok = x_decompress(&fi,&fo,&header,skip);
}
return ok && unlink_ok;
}
/*************************************************************************
// process files
**************************************************************************/
static lzo_bool do_one_file(const char *name, lzo_bool handle_perms)
{
lzo_bool ok;
if (opt_cmd == CMD_COMPRESS)
ok = do_compress(name,handle_perms);
else
ok = do_decompress(name,handle_perms);
if (!p_close(1,0))
ok = 0;
if (opt_file && !p_close(0,1))
ok = 0;
if (ok && opt_unlink)
{
#if defined(HAVE_CHMOD)
(void) chmod(fi.name, 0777);
#endif
if (unlink(fi.name) != 0)
p_warn(&fi,"can't unlink file");
}
if (fi.fd == -1)
fi.name[0] = 0;
if (fo.fd == -1)
fo.name[0] = 0;
return ok;
}
static void do_files(int i, int argc, char *argv[])
{
lzo_bool handle_perms;
if (opt_cmd == CMD_COMPRESS)
handle_perms = !opt_stdin;
else if (opt_cmd == CMD_DECOMPRESS)
handle_perms = 1;
else
handle_perms = 0;
if (opt_stdin)
{
assert(opt_stdout || opt_output_name || opt_output_path);
assert(i == argc);
assert(num_files == 0);
if (!check_stdin(&fi) || !open_stdin(&fi))
return;
}
if (opt_stdout)
{
assert(!opt_output_name);
if (!check_stdout(&fo) || !open_stdout(&fo))
return;
handle_perms = 0;
}
if (opt_output_name)
{
assert(!opt_stdout);
handle_perms &= (num_files == 1);
}
if (opt_stdin)
do_one_file(NULL,handle_perms);
else
{
for ( ; i < argc; i++)
do_one_file(argv[i],handle_perms);
}
(void) p_close(1,1);
if (opt_cmd == CMD_LIST)
do_list_total();
if (opt_cmd == CMD_TEST)
do_test_total();
}
/*************************************************************************
// check options
**************************************************************************/
static void check_not_both(lzo_bool e1, lzo_bool e2, int c1, int c2)
{
if (e1 && e2)
{
fprintf(stderr,"%s: ",argv0);
fprintf(stderr,"cannot use both '-%c' and '-%c'\n", c1, c2);
e_usage();
}
}
void check_options(int i, int argc)
{
assert(i <= argc);
if (opt_keep)
opt_unlink = 0;
if (!(opt_cmd == CMD_COMPRESS || opt_cmd == CMD_DECOMPRESS))
opt_unlink = 0;
if (opt_stdin == OPT_STDIN_GUESSED && i != argc)
opt_stdin = 0;
if (opt_stdin)
{
opt_unlink = 0;
#if 0
/* gzip: always use stdout */
opt_stdout = 1;
#else
if (!opt_output_name && !opt_output_path)
opt_stdout = 1;
#endif
}
if (opt_stdout)
{
check_not_both(1, opt_output_name != NULL, 'c', 'o');
check_not_both(1, opt_output_path != NULL, 'c', 'p');
check_not_both(1, opt_suffix[0] != 0, 'c', 'S');
opt_output_name = NULL;
opt_output_path = NULL;
opt_suffix[0] = 0;
if (opt_unlink && !opt_force)
{
fprintf(stderr,"%s: both '-c' and '-U' given (use '-f' to force)\n",argv0);
e_usage();
}
}
if (opt_output_name)
{
check_not_both(1, opt_output_path != NULL, 'o', 'p');
check_not_both(1, opt_suffix[0] != 0, 'o', 'S');
opt_output_path = NULL;
opt_suffix[0] = 0;
}
/* check number of remaining args */
if (opt_stdin)
{
if (opt_cmd == CMD_COMPRESS && opt_output_path)
{
fprintf(stderr,"%s: cannot use '-p' when compressing stdin\n",argv0);
e_usage();
}
/* No more args allowed */
if (i != argc)
{
fprintf(stderr,"%s: no filename allowed when reading from stdin\n",argv0);
e_usage();
}
}
else
{
if (i == argc)
{
fprintf(stderr,"%s: nothing to do !\n",argv0);
e_usage();
}
if (opt_stdout || opt_output_name)
{
#if 1
/* Allow multiple files */
if (i + 1 != argc)
{
opt_name = 1;
}
#else
/* Exactly one input file */
if (i + 1 != argc)
{
fprintf(stderr,"%s: only one file allowed\n",argv0);
e_usage();
}
#endif
}
}
opt_file = !opt_stdout && !opt_output_name;
}
/*************************************************************************
// misc
**************************************************************************/
void e_help(void)
{
if (opt_pgm == PGM_LZOP)
help();
else if (opt_pgm == PGM_UNLZOP)
help();
else if (opt_pgm == PGM_OCAT)
{
if (opt_stdin)
check_stdin(&fi);
if (opt_stdout)
check_stdout(&fo);
usage();
}
else
help();
e_exit(EXIT_USAGE);
}
void set_term(FILE *f)
{
if (f)
con_term = f;
else
con_term = acc_isatty(STDOUT_FILENO) ? stdout : stderr;
}
void set_cmd(int cmd)
{
if (cmd == CMD_COMPRESS && (opt_pgm == PGM_UNLZOP || opt_pgm == PGM_OCAT))
return;
#if 0
if (opt_cmd != CMD_NONE && cmd != opt_cmd)
{
fprintf(stderr,"%s: multiple commands given\n",argv0);
e_usage();
}
opt_cmd = cmd;
#else
/* gzip: commands have a certain priority */
if (cmd > opt_cmd)
opt_cmd = cmd;
#endif
}
lzo_bool set_method(int m, int l)
{
if (x_set_method(m,l) != 0)
return 0;
set_cmd(CMD_COMPRESS);
return 1;
}
void set_output_name(const char *n, lzo_bool allow_m)
{
#if 1
if (done_output_name > 0)
{
fprintf(stderr,"%s: option '-o' more than once given\n",argv0);
e_usage();
}
#endif
if (!n || !n[0] || (!allow_m && n[0] == '-'))
{
fprintf(stderr,"%s: missing output name\n",argv0);
e_usage();
}
if (strlen(n) >= PATH_MAX)
{
fprintf(stderr,"%s: output name too long\n",argv0);
e_usage();
}
opt_output_name = n;
done_output_name++;
}
void set_output_path(const char *n, lzo_bool allow_m)
{
int r;
struct stat st;
file_t f;
#if 1
if (done_output_path > 0)
{
fprintf(stderr,"%s: option '-p' more than once given\n",argv0);
e_usage();
}
#endif
if (!n || (!allow_m && n[0] == '-'))
{
fprintf(stderr,"%s: missing path\n",argv0);
e_usage();
}
if (strlen(n) >= PATH_MAX)
{
fprintf(stderr,"%s: path too long\n",argv0);
e_usage();
}
if (n[0])
{
r = stat(n, &st);
if (r != 0)
{
strcpy(f.name,n);
p_fatal(&f,"invalid path");
}
#if defined(S_ISDIR)
if (!S_ISDIR(st.st_mode))
{
strcpy(f.name,n);
fatal(&f,"invalid path - must be a directory");
}
#endif
}
#if defined(HAVE_ACCESS) && defined(W_OK)
{
const char *p = n[0] ? n : ".";
if (access(p,W_OK) != 0)
{
strcpy(f.name,p);
p_fatal(&f,"can't write to path");
}
}
#endif
opt_output_path = n;
done_output_path++;
}
lzo_bool set_suffix(const char *n)
{
size_t l;
const char *p;
static const char * const invalid_suffixes[] =
{ "ace", "arc", "arj", "bz", "bz2", "gz", "lha", "lzh",
#if !defined(NRVP)
"nrv", "tnv",
#endif
"rar", "raw", "sz", "tar", "taz", "tbz", "tgz", "tsz",
"upx", "Z", "zip", "zoo", NULL };
const char * const *is = invalid_suffixes;
#if 1
if (done_suffix > 0)
{
fprintf(stderr,"%s: option '-S' more than once given\n",argv0);
e_usage();
return 0;
}
#endif
while (n && *n == '.')
n++;
if (!n || *n == 0 || *n == '-')
return 0;
#if 1 || defined(DOSISH)
if (strchr(n,'.'))
return 0;
#endif
for (p = n; *p; p++)
if (strchr("+*?=/\\ \t\n\r\a", *p))
return 0;
for ( ; *is; is++)
if (strcasecmp(n,*is) == 0)
return 0;
l = strlen(n);
if (l + 1 > SUFFIX_MAX || (opt_shortname && l > 3))
{
fprintf(stderr,"%s: suffix '%s' is too long\n",argv0,n);
e_usage();
return 0;
}
opt_suffix[0] = '.';
strcpy(opt_suffix + 1, n);
done_suffix++;
return 1;
}
/*************************************************************************
// get options
**************************************************************************/
static
char* prepare_shortopts(char *buf, const char *n,
const struct acc_getopt_longopt_t *longopts)
{
char *o = buf;
for ( ; n && *n; n++)
if (*n != ' ')
*o++ = *n;
*o = 0;
for ( ; longopts && longopts->name; longopts++)
{
int v = longopts->val;
if (v > 0 && v < 256 && strchr(buf,v) == NULL)
{
*o++ = (char) v;
if (longopts->has_arg >= 1)
*o++ = ':';
if (longopts->has_arg >= 2)
*o++ = ':';
*o = 0;
}
}
return buf;
}
static int do_option(acc_getopt_p g, int optc)
{
#define mfx_optarg g->optarg
int i = 0;
int m = -1;
switch (optc)
{
case 'c':
opt_stdout = 1;
break;
case 'C':
opt_checksum = (opt_checksum >= 1) ? opt_checksum + 1 : 1;
opt_decompress_safe = 1;
break;
case 'd':
set_cmd(CMD_DECOMPRESS);
break;
case 'f':
opt_force++;
break;
case 'F':
opt_checksum = 0;
opt_decompress_safe = 0;
break;
case 'h':
case 'H':
case '?':
set_cmd(CMD_HELP);
break;
case 'h'+256:
/* according to GNU standards */
set_term(stdout);
opt_console = CON_NONE;
help();
e_exit(EXIT_OK);
break;
case 'i':
case 'i'+256:
set_cmd(CMD_INFO);
break;
case 'I':
set_cmd(CMD_SYSINFO);
break;
case 'k':
opt_keep = 1;
break;
case 'l':
set_cmd(CMD_LIST);
break;
case 'L':
set_cmd(CMD_LICENSE);
break;
case 'n':
opt_name = 0;
opt_path = 0;
break;
case 'N':
opt_name = 1;
break;
case 'o':
set_output_name(mfx_optarg,1);
break;
case 'p':
case 'p'+256:
if (mfx_optarg && mfx_optarg[0])
set_output_path(mfx_optarg,0);
else if (optc == 'p')
set_output_path("",0);
else
set_output_path(NULL,0);
break;
case 'P':
opt_path = 1;
opt_name = 1;
break;
case 'q':
opt_verbose = 0;
break;
case 'S':
if (!set_suffix(mfx_optarg))
{
fprintf(stderr,"%s: invalid suffix '%s'\n",argv0,mfx_optarg);
e_usage();
}
break;
case 't':
set_cmd(CMD_TEST);
break;
case 'T':
if (!(mfx_optarg && isdigit(mfx_optarg[0])))
{
fprintf(stderr,"%s: invalid '--threads=' args: '%s'\n",argv0,mfx_optarg);
e_usage();
}
opt_num_threads = atoi(mfx_optarg);
if (opt_num_threads < 1 || opt_num_threads > MAX_NUM_THREADS)
{
fprintf(stderr,"%s: invalid number of threads: %d\n",argv0,opt_num_threads);
e_usage();
}
#if !defined(WITH_THREADS)
opt_num_threads = 1;
#endif
break;
case 'U':
opt_unlink = 1;
break;
case 'v':
opt_verbose = (opt_verbose < 2) ? 2 : opt_verbose + 1;
break;
case 'V':
set_cmd(CMD_VERSION);
break;
case 'V'+256:
/* according to GNU standards */
set_term(stdout);
opt_console = CON_NONE;
fprintf(stdout,"lzop %s\n",LZOP_VERSION_STRING);
fprintf(stdout,"LZO library %s\n",lzo_version_string());
fprintf(stdout,"Copyright (C) 1996-2010 Markus Franz Xaver Johannes Oberhumer\n");
e_exit(EXIT_OK);
break;
case 'x':
set_cmd(CMD_DECOMPRESS);
opt_name = 1;
opt_path = 1;
opt_restore_mode = 1;
opt_restore_time = 1;
if (!opt_output_name && !opt_output_path)
{
set_output_path("",0);
--done_output_path;
}
opt_unlink = 0;
break;
case 'Z'+256:
set_cmd(CMD_LS);
if (mfx_optarg && mfx_optarg[0])
{
opt_ls_flags = mfx_optarg;
for (i = 0; opt_ls_flags[i]; i++)
if (!strchr("FGQ",opt_ls_flags[i]))
{
fprintf(stderr,"%s: invalid '--ls' flags: '%s'\n",argv0,mfx_optarg);
e_usage();
}
}
break;
#ifdef MAINT
case 520:
opt_noheader++;
break;
#endif
case 522:
opt_stdin = 0;
break;
case 523:
opt_restore_mode = 0;
break;
case 524:
opt_restore_time = 0;
break;
case 525:
opt_nowarn = 1;
break;
case 526:
opt_ignorewarn = 1;
break;
case 527:
opt_crc32 = 1;
break;
case 512:
opt_console = CON_NONE;
break;
case 513:
opt_console = CON_ANSI_MONO;
break;
case 514:
opt_console = CON_ANSI_COLOR;
break;
case 515:
set_cmd(CMD_INTRO);
break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
if (!set_method(0,optc - '0'))
e_method(optc);
break;
#if defined(WITH_NRV)
case 811:
if (m < 0) m = M_NRV1A;
/* fallthrough */
case 812:
if (m < 0) m = M_NRV1B;
/* fallthrough */
case 813:
if (m < 0) m = M_NRV2A;
/* fallthrough */
case 814:
if (m < 0) m = M_NRV2B;
i = 1;
if (mfx_optarg && isdigit(mfx_optarg[0]) && !mfx_optarg[1])
i = mfx_optarg[0] - '0';
if (!set_method(m,i))
e_usage();
break;
#endif
#if defined(WITH_ZLIB)
case 801:
i = 6;
if (mfx_optarg && mfx_optarg[0] && !mfx_optarg[1])
i = mfx_optarg[0] - '0';
if (!set_method(M_ZLIB,i))
e_usage();
break;
#endif
case 521:
if (!(mfx_optarg && isdigit(mfx_optarg[0])))
{
fprintf(stderr,"%s: invalid '--filter=' args: '%s'\n",argv0,mfx_optarg);
e_usage();
}
if (strcmp(mfx_optarg,"0") == 0)
{
opt_filter = 0;
break;
}
opt_filter = atoi(mfx_optarg);
if (opt_filter < 1 || opt_filter > 16)
{
fprintf(stderr,"%s: invalid filter: %d\n",argv0,opt_filter);
e_usage();
}
break;
case '\0':
return -1;
case ':':
return -2;
default:
fprintf(stderr,"%s: internal error in getopt (%d)\n",argv0,optc);
return -3;
}
UNUSED(i);
UNUSED(m);
return 0;
#undef mfx_optarg
}
static void handle_opterr(acc_getopt_p g, const char *f, void *v)
{
struct A { va_list ap; };
struct A *a = (struct A *) v;
fprintf( stderr, "%s: ", g->progname);
if (a)
vfprintf(stderr, f, a->ap);
else
fprintf( stderr, "UNKNOWN GETOPT ERROR");
fprintf( stderr, "\n");
}
static int get_options(int argc, char **argv)
{
static const struct acc_getopt_longopt_t longopts[] =
{
{"best", 0, 0, '9'}, /* compress better */
{"decompress", 0, 0, 'd'}, /* decompress */
{"fast", 0, 0, '1'}, /* compress faster */
{"help", 0, 0, 'h'+256}, /* give help */
{"info", 0, 0, 'i'+256},
{"license", 0, 0, 'L'}, /* display software license */
{"list", 0, 0, 'l'}, /* list .lzo file contents */
{"ls", 2, 0, 'Z'+256}, /* list .lzo file contents */
{"sysinfo", 0, 0, 'I'},
{"test", 0, 0, 't'}, /* test compressed file integrity */
{"uncompress", 0, 0, 'd'}, /* decompress */
{"version", 0, 0, 'V'+256}, /* display version number */
#if defined(WITH_NRV)
{"nrv1a", 0x22, 0, 811},
{"nrv2a", 0x22, 0, 813},
{"nrv2b", 0x22, 0, 814},
#endif
#if defined(WITH_ZLIB)
{"zlib", 0x22, 0, 801},
#endif
{"checksum", 0, 0, 'C'},
{"crc32", 0x10, 0, 527}, /* use a crc32 checksum instead of adler32 */
{"delete", 0, 0, 'U'},
{"extract", 0, 0, 'x'},
{"filter", 1, 0, 521},
{"force", 0, 0, 'f'}, /* force overwrite of output file */
{"ignore-warn",0, 0, 526}, /* ignore any warnings */
{"keep", 0, 0, 'k'},
{"name", 0, 0, 'N'}, /* restore original name */
{"no-checksum",0, 0, 'F'},
#ifdef MAINT
{"no-header", 0, 0, 520},
#endif
{"no-mode", 0, 0, 523}, /* don't restore original mode */
{"no-name", 0, 0, 'n'}, /* don't restore original name */
{"no-stdin", 0, 0, 522},
{"no-time", 0, 0, 524}, /* don't restore original time */
{"no-warn", 0, 0, 525}, /* do not display any warnings */
{"output", 1, 0, 'o'},
{"path", 1, 0, 'p'+256},
{"quiet", 0, 0, 'q'}, /* quiet mode */
{"silent", 0, 0, 'q'}, /* quiet mode */
{"stdout", 0, 0, 'c'}, /* write output on standard output */
{"suffix", 1, 0, 'S'}, /* use given suffix instead of .lzo */
{"threads", 0x21, 0, 'T'}, /* number of threads */
{"to-stdout", 0, 0, 'c'}, /* write output on standard output */
{"unlink", 0, 0, 'U'},
{"verbose", 0, 0, 'v'}, /* verbose mode */
{"no-color", 0, 0, 512},
{"mono", 0, 0, 513},
{"color", 0, 0, 514},
{"intro", 0, 0, 515},
{ 0, 0, 0, 0 }
};
acc_getopt_t mfx_getopt;
int optc;
int i;
char shortopts[128];
prepare_shortopts(shortopts, "123456789hH?PVp::", longopts),
acc_getopt_init(&mfx_getopt, 1, argc, argv);
mfx_getopt.progname = argv0;
mfx_getopt.opterr = handle_opterr;
while ((optc = acc_getopt(&mfx_getopt, shortopts, longopts, NULL)) >= 0)
{
if (do_option(&mfx_getopt, optc) != 0)
e_usage();
}
/* accept "-" as synonym for stdin */
for (i = mfx_getopt.optind; i < argc; i++)
if (strcmp(argv[i], "-") == 0)
opt_stdin = OPT_STDIN_REQUESTED;
for (i = mfx_getopt.optind; i < argc; i++)
if (strcmp(argv[i], "-") != 0)
break;
return i;
}
#if defined(OPTIONS_VAR)
static void get_envoptions(int argc, char **argv)
{
/* only some options are allowed in the environment variable */
static const struct acc_getopt_longopt_t longopts[] =
{
{"best", 0, 0, '9'}, /* compress better */
{"checksum", 0, 0, 'C'},
{"crc32", 0x10, 0, 527}, /* use a crc32 checksum instead of adler32 */
{"delete", 0, 0, 'U'},
{"fast", 0, 0, '1'}, /* compress faster */
{"ignore-warn",0, 0, 526}, /* ignore any warnings */
{"keep", 0, 0, 'k'},
{"name", 0, 0, 'N'}, /* restore original name */
{"no-checksum",0, 0, 'F'},
{"no-mode", 0, 0, 523}, /* don't restore original mode */
{"no-name", 0, 0, 'n'}, /* don't restore original name */
{"no-time", 0, 0, 524}, /* don't restore original time */
{"no-stdin", 0, 0, 522},
{"no-warn", 0, 0, 525}, /* do not display any warnings */
{"quiet", 0, 0, 'q'}, /* quiet mode */
{"silent", 0, 0, 'q'}, /* quiet mode */
{"threads", 0x21, 0, 'T'}, /* number of threads */
{"unlink", 0, 0, 'U'},
{"verbose", 0, 0, 'v'}, /* verbose mode */
{"no-color", 0, 0, 512},
{"mono", 0, 0, 513},
{"color", 0, 0, 514},
{ 0, 0, 0, 0 }
};
char *env, *p;
int i, optc;
int nargc;
char **nargv = NULL;
static const char sep[] = " \t";
acc_getopt_t mfx_getopt;
char shortopts[128];
env = (char *) getenv(OPTIONS_VAR);
if (env == NULL || !env[0])
return;
p = (char *) malloc(strlen(env)+1);
if (p == NULL)
return;
strcpy(p,env);
env = p;
nargc = 1;
for (;;)
{
while (*p && strchr(sep,*p))
p++;
if (*p == '\0')
break;
nargc++;
while (*p && !strchr(sep,*p))
p++;
if (*p == '\0')
break;
p++;
}
if (nargc > 1)
nargv = (char **) calloc(nargc+1,sizeof(char *));
if (nargv == NULL)
{
free(env);
return;
}
nargv[0] = argv[0];
p = env;
nargc = 1;
for (;;)
{
while (*p && strchr(sep,*p))
p++;
if (*p == '\0')
break;
nargv[nargc++] = p;
while (*p && !strchr(sep,*p))
p++;
if (*p == '\0')
break;
*p++ = '\0';
}
nargv[nargc] = NULL;
#if 0
/* debug */
fprintf(stderr,"%3d\n",nargc);
for (i = 0; i <= nargc; i++)
fprintf(stderr,"%3d '%s'\n",i,nargv[i]);
#endif
for (i = 1; i < nargc; i++)
if (nargv[i][0] != '-' || !nargv[i][1] || strcmp(nargv[i],"--") == 0)
e_envopt(nargv[i]);
prepare_shortopts(shortopts, "123456789P", longopts);
acc_getopt_init(&mfx_getopt, 1, nargc, nargv);
mfx_getopt.progname = argv0;
mfx_getopt.opterr = handle_opterr;
while ((optc = acc_getopt(&mfx_getopt, shortopts, longopts, NULL)) >= 0)
{
if (do_option(&mfx_getopt, optc) != 0)
e_envopt(NULL);
}
if (mfx_getopt.optind < nargc)
e_envopt(nargv[mfx_getopt.optind]);
free(nargv);
free(env);
UNUSED(argc);
if (opt_checksum)
opt_checksum = -1; /* reset to default */
}
#endif /* defined(OPTIONS_VAR) */
#define ACC_WANT_ACC_CHK_CH 1
#undef ACCCHK_ASSERT
#include "miniacc.h"
#undef ACCCHK_ASSERT
static void sanity_check(void)
{
#if (ACC_CC_MSC && ((_MSC_VER) < 700))
#else
#define ACCCHK_ASSERT(expr) ACC_COMPILE_TIME_ASSERT(expr)
#include "miniacc.h"
#endif
#undef ACCCHK_ASSERT
#undef ACC_WANT_ACC_CHK_CH
}
/*************************************************************************
// main entry point
**************************************************************************/
int __acc_cdecl_main main(int argc, char *argv[])
{
int i;
lzo_bool foreground = 0;
static char default_argv0[] = "lzop";
int cmdline_cmd = CMD_NONE;
sanity_check();
#if defined(__MINT__)
__binmode(1);
__set_binmode(stdout, 0);
__set_binmode(stderr, 0);
#endif
acc_wildargv(&argc, &argv);
#if defined(__DJGPP__)
opt_shortname = !_USE_LFN;
#elif (ACC_OS_DOS16 || ACC_OS_WIN16 || ACC_OS_DOS32)
opt_shortname = 1;
#endif
current_time = fix_time(time(NULL));
if (!argv[0] || !argv[0][0])
argv[0] = default_argv0;
argv0 = argv[0];
progname = fn_basename(argv0);
#if defined(DOSISH)
if (strcasecmp(progname,"lzop.exe") == 0)
progname = default_argv0;
else if (strcasecmp(progname,"lzop.ttp") == 0)
progname = default_argv0;
#endif
/* For compatibility with gzip, use program name as an option. */
if (strncasecmp(progname, "un", 2) == 0) /* unlzop */
opt_pgm = PGM_UNLZOP;
#if 0
if (progname[0] && strcasecmp(progname+1, "cat") == 0) /* ocat */
opt_pgm = PGM_OCAT;
#endif
set_term(stderr);
opt_stdin = acc_isatty(STDIN_FILENO) ? 0 : OPT_STDIN_GUESSED;
UNUSED(foreground);
#ifdef SIGINT
foreground = signal(SIGINT, SIG_IGN) != SIG_IGN;
if (foreground)
(void) signal(SIGINT, e_sighandler);
#endif
#ifdef SIGBREAK
if (foreground)
(void) signal(SIGBREAK, e_sighandler);
#endif
#ifdef SIGTERM
if (signal(SIGTERM, SIG_IGN) != SIG_IGN)
(void) signal(SIGTERM, e_sighandler);
#endif
#ifdef SIGHUP
if (signal(SIGHUP, SIG_IGN) != SIG_IGN)
(void) signal(SIGHUP, e_sighandler);
#endif
#if defined(HAVE_UMASK)
u_mask = (MODE_T) umask(0700);
(void) umask(u_mask);
#endif
u_mask &= 0777;
#if defined(WITH_LZO)
if (lzo_init() != LZO_E_OK)
{
head();
fprintf(stderr,"lzo_init() failed - check your LZO installation !\n");
if (LZO_VERSION != lzo_version())
fprintf(stderr,"library version conflict (%x, %x) - check your LZO installation !\n", LZO_VERSION, lzo_version());
e_exit(EXIT_LZO_INIT);
}
#if 0
if (lzo_version() < LZO_VERSION)
{
head();
fprintf(stderr,"library version conflict (%x, %x) - check your LZO installation !\n", LZO_VERSION, lzo_version());
e_exit(EXIT_LZO_INIT);
}
#endif
#endif
#if defined(WITH_NRV)
if (nrv_init() != NRV_E_OK)
{
e_exit(EXIT_LZO_INIT);
}
#endif
ACC_COMPILE_TIME_ASSERT(sizeof(lzo_uint32) >= 4)
#if defined(SIZEOF_SIZE_T)
ACC_COMPILE_TIME_ASSERT(sizeof(size_t) == SIZEOF_SIZE_T)
#endif
ACC_COMPILE_TIME_ASSERT(sizeof(fi.name) >= 2*(PATH_MAX))
assert(STDIN_FILENO >= 0);
assert(STDOUT_FILENO >= 0);
assert(STDERR_FILENO >= 0);
f_init();
#if defined(OPTIONS_VAR)
get_envoptions(argc,argv);
#endif
assert(cmdline_cmd == CMD_NONE);
i = get_options(argc,argv);
assert(i <= argc);
set_term(NULL);
cmdline_cmd = opt_cmd;
switch (opt_cmd)
{
case CMD_NONE:
/* For compatibility with gzip, use program name as an option. */
if (opt_pgm == PGM_UNLZOP)
{
set_cmd(CMD_DECOMPRESS);
break;
}
#if 0
if (opt_pgm == PGM_OCAT)
{
set_cmd(CMD_DECOMPRESS);
if (i == argc)
opt_stdin = OPT_STDIN_REQUESTED;
if (!opt_output_name)
opt_stdout = 1;
break;
}
#endif
/* default - compress */
if (!set_method(0,3))
e_method('3');
break;
case CMD_COMPRESS:
break;
case CMD_DECOMPRESS:
break;
case CMD_TEST:
opt_checksum = 1;
opt_decompress_safe = 1;
break;
case CMD_LIST:
break;
case CMD_LS:
break;
case CMD_INFO:
break;
case CMD_SYSINFO:
sysinfo();
e_exit(EXIT_OK);
break;
case CMD_LICENSE:
license();
e_exit(EXIT_OK);
break;
case CMD_HELP:
help();
e_exit(EXIT_OK);
break;
case CMD_INTRO:
opt_console = CON_SCREEN;
(void) ((con_intro(con_term) || (help(), 0)));
e_exit(EXIT_OK);
case CMD_VERSION:
version();
e_exit(EXIT_OK);
break;
default:
/* ??? */
break;
}
if (opt_cmd != CMD_COMPRESS)
{
opt_method = 0;
opt_level = 0;
opt_filter = 0;
}
if (!opt_stdin && !opt_stdout && opt_verbose > 0)
{
if (argc == 1)
{
/* no arguments */
(void) (opt_pgm == PGM_LZOP && con_intro(con_term));
e_help();
}
#if 0
else if (cmdline_cmd == CMD_NONE && i == argc)
{
/* no command and no file */
e_help();
}
#endif
}
set_term(stderr);
check_options(i,argc);
num_files = argc - i;
if (!x_enter(NULL))
e_memory();
do_files(i,argc,argv);
x_leave(NULL);
do_exit();
return exit_code;
}
/*
vi:ts=4:et
*/