/* 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 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 */