gzip.c

tftp client sorser code,Please download it and compolie it ,byebye

 *   If the member is a zip file, it must be the only one.
 */
local int get_method()
{
    uch flags;     /* compression flags */
    char magic[2]; /* magic header */
    ulg stamp;     /* time stamp */

    /* If --force and --stdout, zcat == cat, so do not complain about
     * premature end of file: use try_byte instead of get_byte.
     */
    if (force && to_stdout) 
    {
	magic[0] = (char)try_byte();
	magic[1] = (char)try_byte();
	/* If try_byte returned EOF, magic[1] == 0xff */
    } 
    else 
    {
	magic[0] = (char)get_byte();
	magic[1] = (char)get_byte();
    }
    method = -1;                 /* unknown yet */
    part_nb++;                   /* number of parts in gzip file */
    header_bytes = 0;
    last_member = RECORD_IO;
    /* assume multiple members in gzip file except for record oriented I/O */

    if (memcmp(magic, GZIP_MAGIC, 2) == 0
        || memcmp(magic, OLD_GZIP_MAGIC, 2) == 0) 
    {

	method = (int)get_byte();
	if (method != DEFLATED) 
	{
	    fprintf(stderr,
		    "%s: %s: unknown method %d -- get newer version of gzip\n",
		    progname, ifname, method);
	    exit_code = ERROR;
	    return -1;
	}
	flags  = (uch)get_byte();

	if ((flags & ENCRYPTED) != 0) 
	{
	    fprintf(stderr,
		    "%s: %s is encrypted -- get newer version of gzip\n",
		    progname, ifname);
	    exit_code = ERROR;
	    return -1;
	}
	if ((flags & CONTINUATION) != 0) 
        {
	    fprintf(stderr,
	   "%s: %s is a a multi-part gzip file -- get newer version of gzip\n",
		    progname, ifname);
	    exit_code = ERROR;
	    if (force <= 1) return -1;
	}
	if ((flags & RESERVED) != 0) 
        {
	    fprintf(stderr,
		    "%s: %s has flags 0x%x -- get newer version of gzip\n",
		    progname, ifname, flags);
	    exit_code = ERROR;
	    if (force <= 1) return -1;
	}
	stamp  = (ulg)get_byte();
	stamp |= ((ulg)get_byte()) << 8;
	stamp |= ((ulg)get_byte()) << 16;
	stamp |= ((ulg)get_byte()) << 24;
	if (stamp != 0 && !no_time) 
		time_stamp = stamp;

	(void)get_byte();  /* Ignore extra flags for the moment */
	(void)get_byte();  /* Ignore OS type for the moment */

	if ((flags & CONTINUATION) != 0) 
        {
	    unsigned part = (unsigned)get_byte();
	    part |= ((unsigned)get_byte())<<8;
	    if (verbose) 
            {
		fprintf(stderr,"%s: %s: part number %u\n",
			progname, ifname, part);
	    }
	}

	if ((flags & EXTRA_FIELD) != 0) 
        {
	    unsigned len = (unsigned)get_byte();
	    len |= ((unsigned)get_byte())<<8;
	    if (verbose) 
            {
		fprintf(stderr,"%s: %s: extra field of %u bytes ignored\n",
			progname, ifname, len);
	    }
	    while (len--) (void)get_byte();
	}

	/* Get original file name if it was truncated */
	if ((flags & ORIG_NAME) != 0) 
        {
	    if (no_name || (to_stdout && !list) || part_nb > 1) 
            {
		/* Discard the old name */
		char c; /* dummy used for NeXTstep 3.0 cc optimizer bug */
		do {c=get_byte();} while (c != 0);
	    } 
            else 
            {
		/* Copy the base name. Keep a directory prefix intact. */
                char *p = basename(ofname);
                char *base = p;
		for (;;) 
                {
		    *p = (char)get_char();
		    if (*p++ == '\0') break;
		    if (p >= ofname+sizeof(ofname)) 
                    {
			error("corrupted input -- file name too large");
		    }
		}
                /* If necessary, adapt the name to local OS conventions: */
                if (!list) 
                {
                   MAKE_LEGAL_NAME(base);
		   if (base) 
			list=0; /* avoid warning about unused variable */
                }
	    } /* no_name || to_stdout */
	} /* ORIG_NAME */

	/* Discard file comment if any */
	if ((flags & COMMENT) != 0) 
	{
	    while (get_char() != 0) /* null */ ;
	}
	if (part_nb == 1) 
	{
	    header_bytes = inptr + 2*sizeof(long); /* include crc and size */
	}

    } 
    else if (memcmp(magic, PKZIP_MAGIC, 2) == 0 && inptr == 2
	    && memcmp((char*)inbuf, PKZIP_MAGIC, 4) == 0) 
    {
	/* To simplify the code, we support a zip file when alone only.
         * We are thus guaranteed that the entire local header fits in inbuf.
         */
        inptr = 0;
	//work = unzip;
	//if (check_zipfile(ifd) != OK) 
	if (check_zipfile() != OK) 
		return -1;
	//if (check_zipfile() != OK) return -1;
	/* check_zipfile may get ofname from the local header */
	last_member = 1;

    } 
    else if (memcmp(magic, PACK_MAGIC, 2) == 0) 
    {
	work = unpack;
	method = PACKED;

    } 
    else if (memcmp(magic, LZW_MAGIC, 2) == 0) 
    {
	work = unlzw;
	method = COMPRESSED;
	last_member = 1;

    } 
    else if (memcmp(magic, LZH_MAGIC, 2) == 0) 
    {
	work = unlzh;
	method = LZHED;
	last_member = 1;

    } 
    else if (force && to_stdout && !list) 
    { /* pass input unchanged */
	method = STORED;
	work = copy;
        inptr = 0;
	last_member = 1;
    }

    if (method >= 0) 
	return method;

    if (part_nb == 1) 
    {	
	exit_code = ERROR;
	return -1;
    } 
    else 
    {
	WARN((stderr, "\n%s: %s: decompression OK, trailing garbage ignored\n",
	      progname, ifname));
	return -2;
    }
}


#ifndef NO_UTIME
/* ========================================================================
 * Set the access and modification times from the given stat buffer.
 */
local void reset_times (char *name, struct stat *statb)
{
    struct utimbuf	timep;

    /* Copy the time stamp */
    timep.actime  = statb->st_atime;
    timep.modtime = statb->st_mtime;

    /* Some systems (at least OS/2) do not support utime on directories */
    if (utime(name, &timep) && !S_ISDIR(statb->st_mode)) 
    {
	WARN((stderr, "%s: ", progname));
	if (!quiet) 
		perror(ofname);
    }
}
#endif


/* ========================================================================
 * Copy modes, times, ownership from input file to output file.
 * IN assertion: to_stdout is false.
 */
/*
local void copy_stat(stuct stat *ifstat)
{
#ifndef NO_UTIME
    if (decompress && time_stamp != 0 && ifstat->st_mtime != time_stamp) 
    {
	ifstat->st_mtime = time_stamp;
	if (verbose > 1) 
	{
	    fprintf(stderr, "%s: time stamp restored\n", ofname);
	}
    }
    reset_times(ofname, ifstat);
#endif
    // Copy the protection modes 
    if (chmod(ofname, ifstat->st_mode & 07777)) 
    {
	WARN((stderr, "%s: ", progname));
	if (!quiet) perror(ofname);
    }
#ifndef NO_CHOWN
    chown(ofname, ifstat->st_uid, ifstat->st_gid);  // Copy ownership
#endif
    remove_ofname = 0;
    // It's now safe to remove the input file: 
    (void) chmod(ifname, 0777);
    if (unlink(ifname)) {
	WARN((stderr, "%s: ", progname));
	if (!quiet) 
		perror(ifname);
    }
}

*/
/* ========================================================================
 * Free all dynamically allocated variables and exit with the given code.
 */
local void do_exit(int exitcode)
{
    static int in_exit = 0;

    if (in_exit) exit(exitcode);
    in_exit = 1;
    if (env != NULL)  free(env),  env  = NULL;
    if (args != NULL) free((char*)args), args = NULL;
    FREE(inbuf);
    FREE(outbuf);
    FREE(d_buf);
    FREE(window);
#ifndef MAXSEG_64K
    FREE(tab_prefix);
#else
    FREE(tab_prefix0);
    FREE(tab_prefix1);
#endif
    exit(exitcode);
}

/* ========================================================================
 * Signal and error handler.
 */

RETSIGTYPE abort_gzip()
{
   if (remove_ofname) 
   {
       unlink (ofname);
   }
   do_exit(ERROR);
}

char *strlwr(char *s)
{
	char *t;
	for (t = s; *t; t++)
		*t = tolow(*t);
	return s;
}