/*	$OpenBSD: main.c,v 1.91 2016/07/14 08:31:18 semarie Exp $	*/

/*

 * Copyright (c) 1992, 1993

 *	The Regents of the University of California.  All rights reserved.

 * Copyright (c) 1997-2002 Michael Shalayeff

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *

 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

 * IN NO EVENT SHALL THE AUTHOR OR HIS RELATIVES BE LIABLE FOR ANY DIRECT,

 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

 * SERVICES; LOSS OF MIND, USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,

 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING

 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF

 * THE POSSIBILITY OF SUCH DAMAGE.

 */

#include <sys/time.h>

#include <sys/stat.h>

#include <getopt.h>

#include <err.h>

#include <errno.h>

#include <fts.h>

#include <libgen.h>

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>

#include <string.h>

#include <unistd.h>

#include <limits.h>

#include <fcntl.h>

#include <paths.h>

#include "compress.h"

#define min(a,b) ((a) < (b)? (a) : (b))

int cat, decomp, pipin, force, verbose, testmode, list, recurse, storename;

extern char *__progname;

const struct compressor {

	const char *name;

	const char *suffix;

	const u_char *magic;

	const char *comp_opts;

	const char *decomp_opts;

	const char *cat_opts;

	void *(*open)(int, const char *, char *, int, u_int32_t, int);

	int (*read)(void *, char *, int);

	int (*write)(void *, const char *, int);

	int (*close)(void *, struct z_info *, const char *, struct stat *);

} c_table[] = {

#define M_DEFLATE (&c_table[0])

	{

		"deflate",

		".gz",

		"\037\213",

		"123456789ab:cdfhLlNnOo:qrS:tVv",

		"cfhLlNno:qrtVv",

		"fhqr",

		gz_open,

		gz_read,

		gz_write,

		gz_close

	},

#define M_COMPRESS (&c_table[1])

#ifndef SMALL

	{

		"compress",

		".Z",

		"\037\235",

		"123456789ab:cdfghlNnOo:qrS:tv",

		"cfhlNno:qrtv",

		"fghqr",

		z_open,

		zread,

		zwrite,

		z_close

	},

#endif /* SMALL */

#if 0

#define M_LZH (&c_table[2])

  { "lzh", ".lzh", "\037\240", lzh_open, lzh_read, lzh_write, lzh_close },

#define M_ZIP (&c_table[3])

  { "zip", ".zip", "PK", zip_open, zip_read, zip_write, zip_close },

#define M_PACK (&c_table[4])

  { "pack", ".pak", "\037\036", pak_open, pak_read, pak_write, pak_close },

#endif

  { NULL }

};

#ifndef SMALL

const struct compressor null_method = {

	"null",

	".nul",

	"XX",

	"123456789ab:cdfghlNnOo:qrS:tv",

	"cfhlNno:qrtv",

	"fghqr",

	null_open,

	null_read,

	null_write,

	null_close

};

#endif /* SMALL */

int permission(const char *);

__dead void usage(int);

int docompress(const char *, char *, const struct compressor *,

    int, struct stat *);

int dodecompress(const char *, char *, const struct compressor *,

    int, struct stat *);

const struct compressor *check_method(int);

const char *check_suffix(const char *);

char *set_outfile(const char *, char *, size_t);

void list_stats(const char *, const struct compressor *, struct z_info *);

void verbose_info(const char *, off_t, off_t, u_int32_t);

const struct option longopts[] = {

#ifndef SMALL

	{ "ascii",	no_argument,		0, 'a' },

	{ "stdout",	no_argument,		0, 'c' },

	{ "to-stdout",	no_argument,		0, 'c' },

	{ "decompress",	no_argument,		0, 'd' },

	{ "uncompress",	no_argument,		0, 'd' },

	{ "force",	no_argument,		0, 'f' },

	{ "help",	no_argument,		0, 'h' },

	{ "list",	no_argument,		0, 'l' },

	{ "license",	no_argument,		0, 'L' },

	{ "no-name",	no_argument,		0, 'n' },

	{ "name",	no_argument,		0, 'N' },

	{ "quiet",	no_argument,		0, 'q' },

	{ "recursive",	no_argument,		0, 'r' },

	{ "suffix",	required_argument,	0, 'S' },

	{ "test",	no_argument,		0, 't' },

	{ "verbose",	no_argument,		0, 'v' },

	{ "version",	no_argument,		0, 'V' },

	{ "fast",	no_argument,		0, '1' },

	{ "best",	no_argument,		0, '9' },

#endif /* SMALL */

	{ NULL }

};

int

main(int argc, char *argv[])

	FTS *ftsp;

	FTSENT *entry;

	const struct compressor *method;

	const char *optstr, *s;

	char *p, *infile;

	char outfile[PATH_MAX], _infile[PATH_MAX], suffix[16];

	int bits, ch, error, rc, cflag, oflag;

	} else {

#ifdef SMALL

		method = M_DEFLATE;

#else

#endif /* SMALL */

	}

	} else {

		}

		    strcmp(p, "compress"))

	}

				    argc + argc_extra + 1, sizeof(char *));

			}

		}

				;

		}

	}

		case '1':

		case '2':

		case '3':

		case '4':

		case '5':

		case '6':

		case '7':

		case '8':

		case '9':

		case 'a':

		case 'b':

			/*

			 * POSIX 1002.3 says 9 <= bits <= 14 for portable

			 * apps, but says the implementation may allow

			 * greater.

			 */

			break;

		case 'c':

		case 'd':		/* Backward compatible. */

		case 'f':

		case 'g':

		case 'l':

		case 'n':

		case 'N':

#ifndef SMALL

		case 'O':

#endif /* SMALL */

		case 'o':

			    sizeof(outfile)) >= sizeof(outfile))

		case 'q':

		case 'S':

		case 't':

		case 'V':

		case 'v':

		case 'L':

		case 'r':

		case 'h':

			break;

		default:

		}

	}

	/*

	 * By default, when compressing store the original name and timestamp

	 * in the header.  Do not restore these when decompressing unless

	 * the -N option is given.

	 */

		}

		else

			case FTS_D:

					    infile);

				}

				continue;

			case FTS_DP:

				continue;

			case FTS_NS:

				/*

				 * If file does not exist and has no suffix,

				 * tack on the default suffix and try that.

				 */

					    strcmp(p, suffix) != 0) &&

					    snprintf(_infile, sizeof(_infile),

					    "%s%s", infile, suffix) <

					    sizeof(_infile) &&

					    stat(_infile, entry->fts_statp) ==

					    0 &&

					    S_ISREG(entry->fts_statp->st_mode)) {

					}

				}

			case FTS_ERR:

			case FTS_DNR:

				    strerror(entry->fts_errno));

			default:

				    !(S_ISLNK(entry->fts_statp->st_mode) &&

				    cat)) {

					    infile, cat ? "" : ": unchanged");

				}

				break;

			}

			    infile, s);

		}

				    sizeof outfile) == NULL) {

						    "ignored", infile);

					}

					continue;

				}

			} else {

				    "%s%s", infile, suffix) >= sizeof(outfile)) {

					    infile, suffix);

				}

			}

		}

		    (infile, outfile, method, bits, entry->fts_statp);

		case SUCCESS:

			}

			break;

		case WARNING:

		default:

			break;

		}

	}

}

int

docompress(const char *in, char *out, const struct compressor *method,

    int bits, struct stat *sb)

{

#ifndef SMALL

	u_char buf[Z_BUFSIZE];

	char *name;

	int error, ifd, ofd, flags, oreg;

	void *cookie;

	ssize_t nr;

	u_int32_t mtime;

	struct z_info info;

	struct stat osb;

	else

	}

	else {

			}

		}

	}

	}

			    out);

	}

	}

	}

		}

	}

	}

	}

	}

#else

	warnx("compression not supported");

	return (FAILURE);

#endif

}

const struct compressor *

check_method(int fd)

	const struct compressor *method;

	u_char magic[2];

		    magic[1] == method->magic[1])

	}

#ifndef SMALL

	}

#endif /* SMALL */

}

int

dodecompress(const char *in, char *out, const struct compressor *method,

    int bits, struct stat *sb)

	u_char buf[Z_BUFSIZE];

	char oldname[PATH_MAX];

	int error, oreg, ifd, ofd;

	void *cookie;

	ssize_t nr;

	struct z_info info;

	struct stat osb;

	else

	}

			    in);

	}

	}

	/* XXX - open constrains outfile to MAXPATHLEN so this is safe */

	}

		} else

	}

	else {

		else {

				}

			}

		}

		}

	}

		}

	}

			    errno == EINVAL ? "crc error" : strerror(errno));

	}

	}

			    sb->st_atimespec.tv_sec = info.mtime;

			    sb->st_atimespec.tv_nsec = 0;

		} else

	}

	}

			    info.hlen);

		}

	}

	/* On error, clean up the file we created but preserve errno. */

}

void

setfile(const char *name, int fd, struct stat *fs)

	struct timespec ts[2];

		return;

	/*

	 * If input was a pipe we don't have any info to restore but we

	 * must set the mode since the current mode on the file is 0200.

	 */

	}

	/*

	 * Changing the ownership probably won't succeed, unless we're root

	 * or POSIX_CHOWN_RESTRICTED is not set.  Set uid/gid bits are not

	 * allowed.

	 */

	}

}

int

permission(const char *fname)

{

	int ch, first;

}

/*

 * Check infile for a known suffix and return the suffix portion or NULL.

 */

const char *

check_suffix(const char *infile)

{

	int i;

	static char *suffixes[] = { "Z", "gz", "z", "tgz", "taz", NULL };

		}

	}

}

/*

 * Set outfile based on the suffix.  In most cases we just strip

 * off the suffix but things like .tgz and .taz are special.

 */

char *

set_outfile(const char *infile, char *outfile, size_t osize)

{

	const char *s;

	char *cp;

	/*

	 * Convert tgz and taz -> tar, else drop the suffix.

	 */

	else

}

/*

 * Print output for the -l option.

 */

void

list_stats(const char *name, const struct compressor *method,

    struct z_info *info)

{

	static off_t compressed_total, uncompressed_total, header_total;

	static u_int nruns;

	char *timestr;

		}

	}

			    timestr);

		}

		    (long long)(info->total_in + info->hlen),

		    (long long)info->total_out,

		    ((long long)info->total_out - (long long)info->total_in) *

		    100.0 / info->total_out, name);

		    (long long)(compressed_total + header_total),

		    (long long)uncompressed_total,

		    (uncompressed_total - compressed_total) *

		    100.0 / uncompressed_total);

	}

}

void

verbose_info(const char *file, off_t compressed, off_t uncompressed,

    u_int32_t hlen)

{

	}

		    (uncompressed - compressed) * 100.0 / uncompressed, file);

	}

	    (long long)(decomp ? compressed : uncompressed),

	    (long long)(decomp ? uncompressed : compressed));

}

__dead void

usage(int status)

{

	case MODE_COMP:

		    "[-b bits] [-o filename] [-S suffix]\n"

		    "       %*s [file ...]\n", __progname,

		    !gzip ? "g" : "", gzip ? "L" : "", gzip ? "V" : "",

		    (int)strlen(__progname), "");

	case MODE_DECOMP:

		    "[file ...]\n", __progname,

		    gzip ? "L" : "", gzip ? "V" : "");

	case MODE_CAT:

		    __progname, gzip ? "" : "g");

		break;

	}

}