untgz.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
#include <fcntl.h>
#include <direct.h>
#include <io.h>
#include "zlib.h"
#include <utime.h>

Include dependency graph for untgz.c:

Go to the source code of this file.

Classes
union	tar_buffer
struct	tar_header

Macros
#define	AREGTYPE   '\0' /* regular file */
#define	BLKTYPE   '4' /* block special */
#define	BLOCKSIZE   512
#define	CHRTYPE   '3' /* character special */
#define	CONTTYPE   '7' /* reserved */
#define	DIRTYPE   '5' /* directory */
#define	FIFOTYPE   '6' /* FIFO special */
#define	ISSPECIAL(c)   (((c) == '*') || ((c) == '/'))
#define	LNKTYPE   '1' /* link */
#define	REGTYPE   '0' /* regular file */
#define	SYMTYPE   '2' /* reserved */

Enumerations
enum	{ TGZ_EXTRACT = 0, TGZ_LIST }

Functions
void	error (const char *msg)
int	ExprMatch (char *string, char *expr)
int	getoct (char *p, int width)
void	help (int exitval)
int	makedir (char *newdir)
int	matchname (int arg, int argc, char **argv, char *fname)
void TGZnotfound	OF ((const char *))
int getoct	OF ((char *, int))
char *strtime	OF ((time_t *))
int ExprMatch	OF ((char *, char *))
int makedir	OF ((char *))
int matchname	OF ((int, int, char **, char *))
int tar	OF ((gzFile, int, int, int, char **))
void help	OF ((int))
int main	OF ((int, char **))
void TGZnotfound	OF ((const char *fname))
char *	strtime (time_t *t)
int	untar (gzFile in, const char *dest)
int	untargz (int fd, const char *dest)

Variables
char *	prog
static char *	TGZprefix [] = { "\0", ".tgz", ".tar.gz", ".tar", NULL }

Macro Definition Documentation

#define AREGTYPE   '\0' /* regular file */

Definition at line 47 of file untgz.c.

#define BLKTYPE   '4' /* block special */

Definition at line 51 of file untgz.c.

#define BLOCKSIZE   512

Definition at line 56 of file untgz.c.

#define CHRTYPE   '3' /* character special */

Definition at line 50 of file untgz.c.

#define CONTTYPE   '7' /* reserved */

Definition at line 54 of file untgz.c.

#define DIRTYPE   '5' /* directory */

Definition at line 52 of file untgz.c.

#define FIFOTYPE   '6' /* FIFO special */

Definition at line 53 of file untgz.c.

#define ISSPECIAL

(

c

)

(((c) == '*') || ((c) == '/'))

Definition at line 159 of file untgz.c.

#define LNKTYPE   '1' /* link */

Definition at line 48 of file untgz.c.

#define REGTYPE   '0' /* regular file */

Definition at line 46 of file untgz.c.

#define SYMTYPE   '2' /* reserved */

Definition at line 49 of file untgz.c.

Enumeration Type Documentation

anonymous enum

Enumerator
TGZ_EXTRACT
TGZ_LIST

Definition at line 84 of file untgz.c.

{ TGZ_EXTRACT = 0, TGZ_LIST };

Function Documentation

void error

(

const char *

msg

)

Definition at line 404 of file untgz.c.

{
    fprintf(stderr, "%s: %s\n", prog, msg);
//    exit(1); // don't exit on error
}

int ExprMatch	(	char *	string,
		char *	expr
	)

Definition at line 161 of file untgz.c.

{
  while (1)
    {
      if (ISSPECIAL(*expr))
    {
      if (*expr == '/')
        {
          if (*string != '\\' && *string != '/')
        return 0;
          string ++; expr++;
        }
      else if (*expr == '*')
        {
          if (*expr ++ == 0)
        return 1;
          while (*++string != *expr)
        if (*string == 0)
          return 0;
        }
    }
      else
    {
      if (*string != *expr)
        return 0;
      if (*expr++ == 0)
        return 1;
      string++;
    }
    }
}

int getoct	(	char *	p,
		int	width
	)

Definition at line 127 of file untgz.c.

{
  int result = 0;
  char c;
  
  while (width --)
    {
      c = *p++;
      if (c == ' ')
    continue;
      if (c == 0)
    break;
      result = result * 8 + (c - '0');
    }
  return result;
}

void help

(

int

exitval

)

Definition at line 392 of file untgz.c.

{
  fprintf(stderr,
      "untgz v 0.1\n"
      " an sample application of zlib 1.0.4\n\n"
        "Usage : untgz TGZfile            to extract all files\n"
        "        untgz TGZfile fname ...  to extract selected files\n"
        "        untgz -l TGZfile         to list archive contents\n"
        "        untgz -h                 to display this help\n\n");
  exit(exitval);
}

int makedir

(

char *

newdir

)

Definition at line 200 of file untgz.c.

{
  char *buffer = strdup(newdir);
  char *p;
  int  len = (int)strlen(buffer);
  
  if (len <= 0) {
    free(buffer);
    return 0;
  }
  if (buffer[len-1] == '/') {
    buffer[len-1] = '\0';
  }
  if (mkdir(buffer, 0775) == 0)
    {
      free(buffer);
      return 1;
    }

  p = buffer+1;
  while (1)
    {
      char hold;
      
      while(*p && *p != '\\' && *p != '/')
    p++;
      hold = *p;
      *p = 0;
      if ((mkdir(buffer, 0775) == -1) && (errno == ENOENT))
    {
      fprintf(stderr,"%s: couldn't create directory %s\n",prog,buffer);
      free(buffer);
      return 0;
    }
      if (hold == 0)
    break;
      *p++ = hold;
    }
  free(buffer);
  return 1;
}

int matchname	(	int	arg,
		int	argc,
		char **	argv,
		char *	fname
	)

Definition at line 242 of file untgz.c.

{
  if (arg == argc)      /* no arguments given (untgz tgzarchive) */
    return 1;

  while (arg < argc)
    if (ExprMatch(fname,argv[arg++]))
     return 1;

  return 0; /* ignore this for the moment being */
}

void TGZnotfound OF

(

(const char *)

)

int getoct OF

(

(char *, int)

)

char* strtime OF

(

(time_t *)

)

int ExprMatch OF

(

(char *, char *)

)

int makedir OF

(

(char *)

)

int matchname OF

(

(int, int, char **, char *)

)

int tar OF

(

(gzFile, int, int, int, char **)

)

void help OF

(

(int)

)

int main OF

(

(int, char **)

)

void TGZnotfound OF

(

(const char *fname)

)

Definition at line 112 of file untgz.c.

{
  int i;

  fprintf(stderr,"%s : couldn't find ",prog);
  for (i=0;TGZprefix[i];i++)
    fprintf(stderr,(TGZprefix[i+1]) ? "%s%s, " : "or %s%s\n",
            fname,
            TGZprefix[i]);
  exit(1);
}

char* strtime

(

time_t *

t

)

Definition at line 144 of file untgz.c.

{
  struct tm   *local;
  static char result[32];

  local = localtime(t);
  sprintf(result,"%2d/%02d/%4d %02d:%02d:%02d",
      local->tm_mday, local->tm_mon+1, local->tm_year+1900,
      local->tm_hour, local->tm_min,   local->tm_sec);
  return result;
}

int untar	(	gzFile	in,
		const char *	dest
	)

Definition at line 257 of file untgz.c.

                                        {
    union  tar_buffer buffer;
    int    len;
    int    err;
    int    getheader = 1;
    int    remaining = 0;
    FILE   *outfile = NULL;
    char   fname[BLOCKSIZE];
    time_t tartime;
  
    while (1) {
        len = gzread(in, &buffer, BLOCKSIZE);
        if (len < 0)
            error (gzerror(in, &err));
        /*
        * Always expect complete blocks to process
        * the tar information.
        */
        if (len != BLOCKSIZE)
            error("gzread: incomplete block read");
     
        /*
        * If we have to get a tar header
        */
        if (getheader == 1) {
            /*
            * if we met the end of the tar
            * or the end-of-tar block,
            * we are done
            */
            if ((len == 0)  || (buffer.header.name[0]== 0)) break;

            tartime = (time_t)getoct(buffer.header.mtime,12);
            strcpy(fname, dest);
            if ((fname[strlen(fname)-1] != '/') && (fname[strlen(fname)-1] != '\\'))
                    strcat(fname, "/");
            strcat(fname, buffer.header.name);
      
            switch (buffer.header.typeflag) {
            case DIRTYPE:
                makedir(fname);
                break;
            case REGTYPE:
            case AREGTYPE:
                remaining = getoct(buffer.header.size,12);
                if (remaining) {
                    outfile = fopen(fname,"wb");
                    if (outfile == NULL) {
                        // try creating directory
                        char *p = strrchr(fname, '/');
                        if (p != NULL) {
                            *p = '\0';
                            makedir(fname);
                            *p = '/';
                            outfile = fopen(fname,"wb");
                        }
                    }
/*
                    fprintf(stderr,
                        "%s %s\n",
                        (outfile) ? "Extracting" : "Couldn't create",
                        fname);
*/
                }
                else
                    outfile = NULL;
                /*
                * could have no contents
                */
                getheader = (remaining) ? 0 : 1;
                break;
            default:
                break;
            }
        }
        else    {
            unsigned int bytes = (remaining > BLOCKSIZE) ? BLOCKSIZE : remaining;

            if (outfile != NULL) {
                if (fwrite(&buffer,sizeof(char),bytes,outfile) != bytes) {
                    fprintf(stderr,"%s : error writing %s skipping...\n",prog,fname);
                    fclose(outfile);
                    unlink(fname);
                }
            }
            remaining -= bytes;
            if (remaining == 0) {
                getheader = 1;
                if (outfile != NULL) {
#ifdef WIN32
                    HANDLE hFile;
                    FILETIME ftm,ftLocal;
                    SYSTEMTIME st;
                    struct tm localt;
 
                    fclose(outfile);

                    localt = *localtime(&tartime);

                    hFile = CreateFile(fname, GENERIC_READ | GENERIC_WRITE,
                    0, NULL, OPEN_EXISTING, 0, NULL);
          
                    st.wYear = (WORD)localt.tm_year+1900;
                    st.wMonth = (WORD)localt.tm_mon;
                    st.wDayOfWeek = (WORD)localt.tm_wday;
                    st.wDay = (WORD)localt.tm_mday;
                    st.wHour = (WORD)localt.tm_hour;
                    st.wMinute = (WORD)localt.tm_min;
                    st.wSecond = (WORD)localt.tm_sec;
                    st.wMilliseconds = 0;
                    SystemTimeToFileTime(&st,&ftLocal);
                    LocalFileTimeToFileTime(&ftLocal,&ftm);
                    SetFileTime(hFile,&ftm,NULL,&ftm);
                    CloseHandle(hFile);

                    outfile = NULL;
#else
                    struct utimbuf settime;

                    settime.actime = settime.modtime = tartime;

                    fclose(outfile);
                    outfile = NULL;
                    utime(fname,&settime);
#endif
                }
            }
        }
    }
    return 0;
}

int untargz	(	int	fd,
		const char *	dest
	)

Definition at line 411 of file untgz.c.

                                      {
    gzFile  f;

    f = gzdopen(fd, "rb");
    if (f == NULL) {
        fprintf(stderr,"%s: Couldn't gzopen file\n",    prog);
        return 1;
    }

    return untar(f, dest);
}

Variable Documentation

char* prog

Definition at line 101 of file untgz.c.

char* TGZprefix[] = { "\0", ".tgz", ".tar.gz", ".tar", NULL }

static

Definition at line 105 of file untgz.c.