URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [zlib/] [contrib/] [untgz/] [untgz.c] - Blame information for rev 833

Go to most recent revision | Details | Compare with Previous | View Log


/*
 * untgz.c -- Display contents and extract files from a gzip'd TAR file
 *
 * written by Pedro A. Aranda Gutierrez <paag@tid.es>
 * adaptation to Unix by Jean-loup Gailly <jloup@gzip.org>
 * various fixes by Cosmin Truta <cosmint@cs.ubbcluj.ro>
 */
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <errno.h>
 
#include "zlib.h"
 
#ifdef unix
#  include <unistd.h>
#else
#  include <direct.h>
#  include <io.h>
#endif
 
#ifdef WIN32
#include <windows.h>
#  ifndef F_OK
#    define F_OK  0
#  endif
#  define mkdir(dirname,mode)   _mkdir(dirname)
#  ifdef _MSC_VER
#    define access(path,mode)   _access(path,mode)
#    define chmod(path,mode)    _chmod(path,mode)
#    define strdup(str)         _strdup(str)
#  endif
#else
#  include <utime.h>
#endif
 
 
/* values used in typeflag field */
 
#define REGTYPE  '0'            /* regular file */
#define AREGTYPE '\0'           /* regular file */
#define LNKTYPE  '1'            /* link */
#define SYMTYPE  '2'            /* reserved */
#define CHRTYPE  '3'            /* character special */
#define BLKTYPE  '4'            /* block special */
#define DIRTYPE  '5'            /* directory */
#define FIFOTYPE '6'            /* FIFO special */
#define CONTTYPE '7'            /* reserved */
 
/* GNU tar extensions */
 
#define GNUTYPE_DUMPDIR  'D'    /* file names from dumped directory */
#define GNUTYPE_LONGLINK 'K'    /* long link name */
#define GNUTYPE_LONGNAME 'L'    /* long file name */
#define GNUTYPE_MULTIVOL 'M'    /* continuation of file from another volume */
#define GNUTYPE_NAMES    'N'    /* file name that does not fit into main hdr */
#define GNUTYPE_SPARSE   'S'    /* sparse file */
#define GNUTYPE_VOLHDR   'V'    /* tape/volume header */
 
 
/* tar header */
 
#define BLOCKSIZE     512
#define SHORTNAMESIZE 100
 
struct tar_header
{                               /* byte offset */
  char name[100];               /*   0 */
  char mode[8];                 /* 100 */
  char uid[8];                  /* 108 */
  char gid[8];                  /* 116 */
  char size[12];                /* 124 */
  char mtime[12];               /* 136 */
  char chksum[8];               /* 148 */
  char typeflag;                /* 156 */
  char linkname[100];           /* 157 */
  char magic[6];                /* 257 */
  char version[2];              /* 263 */
  char uname[32];               /* 265 */
  char gname[32];               /* 297 */
  char devmajor[8];             /* 329 */
  char devminor[8];             /* 337 */
  char prefix[155];             /* 345 */
                                /* 500 */
};
 
union tar_buffer
{
  char               buffer[BLOCKSIZE];
  struct tar_header  header;
};
 
struct attr_item
{
  struct attr_item  *next;
  char              *fname;
  int                mode;
  time_t             time;
};
 
enum { TGZ_EXTRACT, TGZ_LIST, TGZ_INVALID };
 
char *TGZfname          OF((const char *));
void TGZnotfound        OF((const char *));
 
int getoct              OF((char *, int));
char *strtime           OF((time_t *));
int setfiletime         OF((char *, time_t));
void push_attr          OF((struct attr_item **, char *, int, time_t));
void restore_attr       OF((struct attr_item **));
 
int ExprMatch           OF((char *, char *));
 
int makedir             OF((char *));
int matchname           OF((int, int, char **, char *));
 
void error              OF((const char *));
int tar                 OF((gzFile, int, int, int, char **));
 
void help               OF((int));
int main                OF((int, char **));
 
char *prog;
 
const char *TGZsuffix[] = { "\0", ".tar", ".tar.gz", ".taz", ".tgz", NULL };
 
/* return the file name of the TGZ archive */
/* or NULL if it does not exist */
 
char *TGZfname (const char *arcname)
{
  static char buffer[1024];
  int origlen,i;
 
  strcpy(buffer,arcname);
  origlen = strlen(buffer);
 
  for (i=0; TGZsuffix[i]; i++)
    {
       strcpy(buffer+origlen,TGZsuffix[i]);
       if (access(buffer,F_OK) == 0)
         return buffer;
    }
  return NULL;
}
 
 
/* error message for the filename */
 
void TGZnotfound (const char *arcname)
{
  int i;
 
  fprintf(stderr,"%s: Couldn't find ",prog);
  for (i=0;TGZsuffix[i];i++)
    fprintf(stderr,(TGZsuffix[i+1]) ? "%s%s, " : "or %s%s\n",
            arcname,
            TGZsuffix[i]);
  exit(1);
}
 
 
/* convert octal digits to int */
/* on error return -1 */
 
int getoct (char *p,int width)
{
  int result = 0;
  char c;
 
  while (width--)
    {
      c = *p++;
      if (c == 0)
        break;
      if (c == ' ')
        continue;
      if (c < '0' || c > '7')
        return -1;
      result = result * 8 + (c - '0');
    }
  return result;
}
 
 
/* convert time_t to string */
/* use the "YYYY/MM/DD hh:mm:ss" format */
 
char *strtime (time_t *t)
{
  struct tm   *local;
  static char result[32];
 
  local = localtime(t);
  sprintf(result,"%4d/%02d/%02d %02d:%02d:%02d",
          local->tm_year+1900, local->tm_mon+1, local->tm_mday,
          local->tm_hour, local->tm_min, local->tm_sec);
  return result;
}
 
 
/* set file time */
 
int setfiletime (char *fname,time_t ftime)
{
#ifdef WIN32
  static int isWinNT = -1;
  SYSTEMTIME st;
  FILETIME locft, modft;
  struct tm *loctm;
  HANDLE hFile;
  int result;
 
  loctm = localtime(&ftime);
  if (loctm == NULL)
    return -1;
 
  st.wYear         = (WORD)loctm->tm_year + 1900;
  st.wMonth        = (WORD)loctm->tm_mon + 1;
  st.wDayOfWeek    = (WORD)loctm->tm_wday;
  st.wDay          = (WORD)loctm->tm_mday;
  st.wHour         = (WORD)loctm->tm_hour;
  st.wMinute       = (WORD)loctm->tm_min;
  st.wSecond       = (WORD)loctm->tm_sec;
  st.wMilliseconds = 0;
  if (!SystemTimeToFileTime(&st, &locft) ||
      !LocalFileTimeToFileTime(&locft, &modft))
    return -1;
 
  if (isWinNT < 0)
    isWinNT = (GetVersion() < 0x80000000) ? 1 : 0;
  hFile = CreateFile(fname, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
                     (isWinNT ? FILE_FLAG_BACKUP_SEMANTICS : 0),
                     NULL);
  if (hFile == INVALID_HANDLE_VALUE)
    return -1;
  result = SetFileTime(hFile, NULL, NULL, &modft) ? 0 : -1;
  CloseHandle(hFile);
  return result;
#else
  struct utimbuf settime;
 
  settime.actime = settime.modtime = ftime;
  return utime(fname,&settime);
#endif
}
 
 
/* push file attributes */
 
void push_attr(struct attr_item **list,char *fname,int mode,time_t time)
{
  struct attr_item *item;
 
  item = (struct attr_item *)malloc(sizeof(struct attr_item));
  if (item == NULL)
    error("Out of memory");
  item->fname = strdup(fname);
  item->mode  = mode;
  item->time  = time;
  item->next  = *list;
  *list       = item;
}
 
 
/* restore file attributes */
 
void restore_attr(struct attr_item **list)
{
  struct attr_item *item, *prev;
 
  for (item = *list; item != NULL; )
    {
      setfiletime(item->fname,item->time);
      chmod(item->fname,item->mode);
      prev = item;
      item = item->next;
      free(prev);
    }
  *list = NULL;
}
 
 
/* match regular expression */
 
#define ISSPECIAL(c) (((c) == '*') || ((c) == '/'))
 
int ExprMatch (char *string,char *expr)
{
  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++;
        }
    }
}
 
 
/* recursive mkdir */
/* abort on ENOENT; ignore other errors like "directory already exists" */
/* return 1 if OK */
/*        0 on error */
 
int makedir (char *newdir)
{
  char *buffer = strdup(newdir);
  char *p;
  int  len = strlen(buffer);
 
  if (len <= 0) {
    free(buffer);
    return 0;
  }
  if (buffer[len-1] == '/') {
    buffer[len-1] = '\0';
  }
  if (mkdir(buffer, 0755) == 0)
    {
      free(buffer);
      return 1;
    }
 
  p = buffer+1;
  while (1)
    {
      char hold;
 
      while(*p && *p != '\\' && *p != '/')
        p++;
      hold = *p;
      *p = 0;
      if ((mkdir(buffer, 0755) == -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)
{
  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 */
}
 
 
/* tar file list or extract */
 
int tar (gzFile in,int action,int arg,int argc,char **argv)
{
  union  tar_buffer buffer;
  int    len;
  int    err;
  int    getheader = 1;
  int    remaining = 0;
  FILE   *outfile = NULL;
  char   fname[BLOCKSIZE];
  int    tarmode;
  time_t tartime;
  struct attr_item *attributes = NULL;
 
  if (action == TGZ_LIST)
    printf("    date      time     size                       file\n"
           " ---------- -------- --------- -------------------------------------\n");
  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)
        {
          action = TGZ_INVALID; /* force error exit */
          remaining = 0;        /* force I/O cleanup */
        }
 
      /*
       * 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;
 
          tarmode = getoct(buffer.header.mode,8);
          tartime = (time_t)getoct(buffer.header.mtime,12);
          if (tarmode == -1 || tartime == (time_t)-1)
            {
              buffer.header.name[0] = 0;
              action = TGZ_INVALID;
            }
 
          if (getheader == 1)
            {
              strncpy(fname,buffer.header.name,SHORTNAMESIZE);
              if (fname[SHORTNAMESIZE-1] != 0)
                  fname[SHORTNAMESIZE] = 0;
            }
          else
            {
              /*
               * The file name is longer than SHORTNAMESIZE
               */
              if (strncmp(fname,buffer.header.name,SHORTNAMESIZE-1) != 0)
                  error("bad long name");
              getheader = 1;
            }
 
          /*
           * Act according to the type flag
           */
          switch (buffer.header.typeflag)
            {
            case DIRTYPE:
              if (action == TGZ_LIST)
                printf(" %s     <dir> %s\n",strtime(&tartime),fname);
              if (action == TGZ_EXTRACT)
                {
                  makedir(fname);
                  push_attr(&attributes,fname,tarmode,tartime);
                }
              break;
            case REGTYPE:
            case AREGTYPE:
              remaining = getoct(buffer.header.size,12);
              if (remaining == -1)
                {
                  action = TGZ_INVALID;
                  break;
                }
              if (action == TGZ_LIST)
                printf(" %s %9d %s\n",strtime(&tartime),remaining,fname);
              else if (action == TGZ_EXTRACT)
                {
                  if (matchname(arg,argc,argv,fname))
                    {
                      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");
                        }
                      }
                      if (outfile != NULL)
                        printf("Extracting %s\n",fname);
                      else
                        fprintf(stderr, "%s: Couldn't create %s",prog,fname);
                    }
                  else
                    outfile = NULL;
                }
              getheader = 0;
              break;
            case GNUTYPE_LONGLINK:
            case GNUTYPE_LONGNAME:
              remaining = getoct(buffer.header.size,12);
              if (remaining < 0 || remaining >= BLOCKSIZE)
                {
                  action = TGZ_INVALID;
                  break;
                }
              len = gzread(in, fname, BLOCKSIZE);
              if (len < 0)
                error(gzerror(in, &err));
              if (fname[BLOCKSIZE-1] != 0 || (int)strlen(fname) > remaining)
                {
                  action = TGZ_INVALID;
                  break;
                }
              getheader = 2;
              break;
            default:
              if (action == TGZ_LIST)
                printf(" %s     <---> %s\n",strtime(&tartime),fname);
              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);
                  outfile = NULL;
                  remove(fname);
                }
            }
          remaining -= bytes;
        }
 
      if (remaining == 0)
        {
          getheader = 1;
          if (outfile != NULL)
            {
              fclose(outfile);
              outfile = NULL;
              if (action != TGZ_INVALID)
                push_attr(&attributes,fname,tarmode,tartime);
            }
        }
 
      /*
       * Abandon if errors are found
       */
      if (action == TGZ_INVALID)
        {
          error("broken archive");
          break;
        }
    }
 
  /*
   * Restore file modes and time stamps
   */
  restore_attr(&attributes);
 
  if (gzclose(in) != Z_OK)
    error("failed gzclose");
 
  return 0;
}
 
 
/* ============================================================ */
 
void help(int exitval)
{
  printf("untgz version 0.2.1\n"
         "  using zlib version %s\n\n",
         zlibVersion());
  printf("Usage: untgz file.tgz            extract all files\n"
         "       untgz file.tgz fname ...  extract selected files\n"
         "       untgz -l file.tgz         list archive contents\n"
         "       untgz -h                  display this help\n");
  exit(exitval);
}
 
void error(const char *msg)
{
  fprintf(stderr, "%s: %s\n", prog, msg);
  exit(1);
}
 
 
/* ============================================================ */
 
#if defined(WIN32) && defined(__GNUC__)
int _CRT_glob = 0;      /* disable argument globbing in MinGW */
#endif
 
int main(int argc,char **argv)
{
    int         action = TGZ_EXTRACT;
    int         arg = 1;
    char        *TGZfile;
    gzFile      *f;
 
    prog = strrchr(argv[0],'\\');
    if (prog == NULL)
      {
        prog = strrchr(argv[0],'/');
        if (prog == NULL)
          {
            prog = strrchr(argv[0],':');
            if (prog == NULL)
              prog = argv[0];
            else
              prog++;
          }
        else
          prog++;
      }
    else
      prog++;
 
    if (argc == 1)
      help(0);
 
    if (strcmp(argv[arg],"-l") == 0)
      {
        action = TGZ_LIST;
        if (argc == ++arg)
          help(0);
      }
    else if (strcmp(argv[arg],"-h") == 0)
      {
        help(0);
      }
 
    if ((TGZfile = TGZfname(argv[arg])) == NULL)
      TGZnotfound(argv[arg]);
 
    ++arg;
    if ((action == TGZ_LIST) && (arg != argc))
      help(1);
 
/*
 *  Process the TGZ file
 */
    switch(action)
      {
      case TGZ_LIST:
      case TGZ_EXTRACT:
        f = gzopen(TGZfile,"rb");
        if (f == NULL)
          {
            fprintf(stderr,"%s: Couldn't gzopen %s\n",prog,TGZfile);
            return 1;
          }
        exit(tar(f, action, arg, argc, argv));
      break;
 
      default:
        error("Unknown option");
        exit(1);
      }
 
    return 0;
}

Browse

Tools

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [zlib/] [contrib/] [untgz/] [untgz.c] - Blame information for rev 833

Line No.	Rev	Author	Line
1	745	jeremybenn	`/*`
2			`* untgz.c -- Display contents and extract files from a gzip'd TAR file`
3			`*`
4			`* written by Pedro A. Aranda Gutierrez <paag@tid.es>`
5			`* adaptation to Unix by Jean-loup Gailly <jloup@gzip.org>`
6			`* various fixes by Cosmin Truta <cosmint@cs.ubbcluj.ro>`
7			`*/`
8
9			`#include <stdio.h>`
10			`#include <stdlib.h>`
11			`#include <string.h>`
12			`#include <time.h>`
13			`#include <errno.h>`
14
15			`#include "zlib.h"`
16
17			`#ifdef unix`
18			`# include <unistd.h>`
19			`#else`
20			`# include <direct.h>`
21			`# include <io.h>`
22			`#endif`
23
24			`#ifdef WIN32`
25			`#include <windows.h>`
26			`# ifndef F_OK`
27			`# define F_OK 0`
28			`# endif`
29			`# define mkdir(dirname,mode) _mkdir(dirname)`
30			`# ifdef _MSC_VER`
31			`# define access(path,mode) _access(path,mode)`
32			`# define chmod(path,mode) _chmod(path,mode)`
33			`# define strdup(str) _strdup(str)`
34			`# endif`
35			`#else`
36			`# include <utime.h>`
37			`#endif`
38
39
40			`/* values used in typeflag field */`
41
42			`#define REGTYPE '0' /* regular file */`
43			`#define AREGTYPE '\0' /* regular file */`
44			`#define LNKTYPE '1' /* link */`
45			`#define SYMTYPE '2' /* reserved */`
46			`#define CHRTYPE '3' /* character special */`
47			`#define BLKTYPE '4' /* block special */`
48			`#define DIRTYPE '5' /* directory */`
49			`#define FIFOTYPE '6' /* FIFO special */`
50			`#define CONTTYPE '7' /* reserved */`
51
52			`/* GNU tar extensions */`
53
54			`#define GNUTYPE_DUMPDIR 'D' /* file names from dumped directory */`
55			`#define GNUTYPE_LONGLINK 'K' /* long link name */`
56			`#define GNUTYPE_LONGNAME 'L' /* long file name */`
57			`#define GNUTYPE_MULTIVOL 'M' /* continuation of file from another volume */`
58			`#define GNUTYPE_NAMES 'N' /* file name that does not fit into main hdr */`
59			`#define GNUTYPE_SPARSE 'S' /* sparse file */`
60			`#define GNUTYPE_VOLHDR 'V' /* tape/volume header */`
61
62
63			`/* tar header */`
64
65			`#define BLOCKSIZE 512`
66			`#define SHORTNAMESIZE 100`
67
68			`struct tar_header`
69			`{ /* byte offset */`
70			`char name[100]; /* 0 */`
71			`char mode[8]; /* 100 */`
72			`char uid[8]; /* 108 */`
73			`char gid[8]; /* 116 */`
74			`char size[12]; /* 124 */`
75			`char mtime[12]; /* 136 */`
76			`char chksum[8]; /* 148 */`
77			`char typeflag; /* 156 */`
78			`char linkname[100]; /* 157 */`
79			`char magic[6]; /* 257 */`
80			`char version[2]; /* 263 */`
81			`char uname[32]; /* 265 */`
82			`char gname[32]; /* 297 */`
83			`char devmajor[8]; /* 329 */`
84			`char devminor[8]; /* 337 */`
85			`char prefix[155]; /* 345 */`
86			`/* 500 */`
87			`};`
88
89			`union tar_buffer`
90			`{`
91			`char buffer[BLOCKSIZE];`
92			`struct tar_header header;`
93			`};`
94
95			`struct attr_item`
96			`{`
97			`struct attr_item *next;`
98			`char *fname;`
99			`int mode;`
100			`time_t time;`
101			`};`
102
103			`enum { TGZ_EXTRACT, TGZ_LIST, TGZ_INVALID };`
104
105			`char TGZfname OF((const char ));`
106			`void TGZnotfound OF((const char *));`
107
108			`int getoct OF((char *, int));`
109			`char strtime OF((time_t ));`
110			`int setfiletime OF((char *, time_t));`
111			`void push_attr OF((struct attr_item *, char , int, time_t));`
112			`void restore_attr OF((struct attr_item **));`
113
114			`int ExprMatch OF((char , char ));`
115
116			`int makedir OF((char *));`
117			`int matchname OF((int, int, char *, char ));`
118
119			`void error OF((const char *));`
120			`int tar OF((gzFile, int, int, int, char **));`
121
122			`void help OF((int));`
123			`int main OF((int, char **));`
124
125			`char *prog;`
126
127			`const char *TGZsuffix[] = { "\0", ".tar", ".tar.gz", ".taz", ".tgz", NULL };`
128
129			`/* return the file name of the TGZ archive */`
130			`/* or NULL if it does not exist */`
131
132			`char TGZfname (const char arcname)`
133			`{`
134			`static char buffer[1024];`
135			`int origlen,i;`
136
137			`strcpy(buffer,arcname);`
138			`origlen = strlen(buffer);`
139
140			`for (i=0; TGZsuffix[i]; i++)`
141			`{`
142			`strcpy(buffer+origlen,TGZsuffix[i]);`
143			`if (access(buffer,F_OK) == 0)`
144			`return buffer;`
145			`}`
146			`return NULL;`
147			`}`
148
149
150			`/* error message for the filename */`
151
152			`void TGZnotfound (const char *arcname)`
153			`{`
154			`int i;`
155
156			`fprintf(stderr,"%s: Couldn't find ",prog);`
157			`for (i=0;TGZsuffix[i];i++)`
158			`fprintf(stderr,(TGZsuffix[i+1]) ? "%s%s, " : "or %s%s\n",`
159			`arcname,`
160			`TGZsuffix[i]);`
161			`exit(1);`
162			`}`
163
164
165			`/* convert octal digits to int */`
166			`/* on error return -1 */`
167
168			`int getoct (char *p,int width)`
169			`{`
170			`int result = 0;`
171			`char c;`
172
173			`while (width--)`
174			`{`
175			`c = *p++;`
176			`if (c == 0)`
177			`break;`
178			`if (c == ' ')`
179			`continue;`
180			`if (c < '0' \|\| c > '7')`
181			`return -1;`
182			`result = result * 8 + (c - '0');`
183			`}`
184			`return result;`
185			`}`
186
187
188			`/* convert time_t to string */`
189			`/* use the "YYYY/MM/DD hh:mm:ss" format */`
190
191			`char strtime (time_t t)`
192			`{`
193			`struct tm *local;`
194			`static char result[32];`
195
196			`local = localtime(t);`
197			`sprintf(result,"%4d/%02d/%02d %02d:%02d:%02d",`
198			`local->tm_year+1900, local->tm_mon+1, local->tm_mday,`
199			`local->tm_hour, local->tm_min, local->tm_sec);`
200			`return result;`
201			`}`
202
203
204			`/* set file time */`
205
206			`int setfiletime (char *fname,time_t ftime)`
207			`{`
208			`#ifdef WIN32`
209			`static int isWinNT = -1;`
210			`SYSTEMTIME st;`
211			`FILETIME locft, modft;`
212			`struct tm *loctm;`
213			`HANDLE hFile;`
214			`int result;`
215
216			`loctm = localtime(&ftime);`
217			`if (loctm == NULL)`
218			`return -1;`
219
220			`st.wYear = (WORD)loctm->tm_year + 1900;`
221			`st.wMonth = (WORD)loctm->tm_mon + 1;`
222			`st.wDayOfWeek = (WORD)loctm->tm_wday;`
223			`st.wDay = (WORD)loctm->tm_mday;`
224			`st.wHour = (WORD)loctm->tm_hour;`
225			`st.wMinute = (WORD)loctm->tm_min;`
226			`st.wSecond = (WORD)loctm->tm_sec;`
227			`st.wMilliseconds = 0;`
228			`if (!SystemTimeToFileTime(&st, &locft) \|\|`
229			`!LocalFileTimeToFileTime(&locft, &modft))`
230			`return -1;`
231
232			`if (isWinNT < 0)`
233			`isWinNT = (GetVersion() < 0x80000000) ? 1 : 0;`
234			`hFile = CreateFile(fname, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,`
235			`(isWinNT ? FILE_FLAG_BACKUP_SEMANTICS : 0),`
236			`NULL);`
237			`if (hFile == INVALID_HANDLE_VALUE)`
238			`return -1;`
239			`result = SetFileTime(hFile, NULL, NULL, &modft) ? 0 : -1;`
240			`CloseHandle(hFile);`
241			`return result;`
242			`#else`
243			`struct utimbuf settime;`
244
245			`settime.actime = settime.modtime = ftime;`
246			`return utime(fname,&settime);`
247			`#endif`
248			`}`
249
250
251			`/* push file attributes */`
252
253			`void push_attr(struct attr_item *list,char fname,int mode,time_t time)`
254			`{`
255			`struct attr_item *item;`
256
257			`item = (struct attr_item *)malloc(sizeof(struct attr_item));`
258			`if (item == NULL)`
259			`error("Out of memory");`
260			`item->fname = strdup(fname);`
261			`item->mode = mode;`
262			`item->time = time;`
263			`item->next = *list;`
264			`*list = item;`
265			`}`
266
267
268			`/* restore file attributes */`
269
270			`void restore_attr(struct attr_item **list)`
271			`{`
272			`struct attr_item item, prev;`
273
274			`for (item = *list; item != NULL; )`
275			`{`
276			`setfiletime(item->fname,item->time);`
277			`chmod(item->fname,item->mode);`
278			`prev = item;`
279			`item = item->next;`
280			`free(prev);`
281			`}`
282			`*list = NULL;`
283			`}`
284
285
286			`/* match regular expression */`
287
288			`#define ISSPECIAL(c) (((c) == '*') \|\| ((c) == '/'))`
289
290			`int ExprMatch (char string,char expr)`
291			`{`
292			`while (1)`
293			`{`
294			`if (ISSPECIAL(*expr))`
295			`{`
296			`if (*expr == '/')`
297			`{`
298			`if (string != '\\' && string != '/')`
299			`return 0;`
300			`string ++; expr++;`
301			`}`
302			`else if (expr == '')`
303			`{`
304			`if (*expr ++ == 0)`
305			`return 1;`
306			`while (++string != expr)`
307			`if (*string == 0)`
308			`return 0;`
309			`}`
310			`}`
311			`else`
312			`{`
313			`if (string != expr)`
314			`return 0;`
315			`if (*expr++ == 0)`
316			`return 1;`
317			`string++;`
318			`}`
319			`}`
320			`}`
321
322
323			`/* recursive mkdir */`
324			`/* abort on ENOENT; ignore other errors like "directory already exists" */`
325			`/* return 1 if OK */`
326			`/* 0 on error */`
327
328			`int makedir (char *newdir)`
329			`{`
330			`char *buffer = strdup(newdir);`
331			`char *p;`
332			`int len = strlen(buffer);`
333
334			`if (len <= 0) {`
335			`free(buffer);`
336			`return 0;`
337			`}`
338			`if (buffer[len-1] == '/') {`
339			`buffer[len-1] = '\0';`
340			`}`
341			`if (mkdir(buffer, 0755) == 0)`
342			`{`
343			`free(buffer);`
344			`return 1;`
345			`}`
346
347			`p = buffer+1;`
348			`while (1)`
349			`{`
350			`char hold;`
351
352			`while(p && p != '\\' && *p != '/')`
353			`p++;`
354			`hold = *p;`
355			`*p = 0;`
356			`if ((mkdir(buffer, 0755) == -1) && (errno == ENOENT))`
357			`{`
358			`fprintf(stderr,"%s: Couldn't create directory %s\n",prog,buffer);`
359			`free(buffer);`
360			`return 0;`
361			`}`
362			`if (hold == 0)`
363			`break;`
364			`*p++ = hold;`
365			`}`
366			`free(buffer);`
367			`return 1;`
368			`}`
369
370
371			`int matchname (int arg,int argc,char *argv,char fname)`
372			`{`
373			`if (arg == argc) /* no arguments given (untgz tgzarchive) */`
374			`return 1;`
375
376			`while (arg < argc)`
377			`if (ExprMatch(fname,argv[arg++]))`
378			`return 1;`
379
380			`return 0; /* ignore this for the moment being */`
381			`}`
382
383
384			`/* tar file list or extract */`
385
386			`int tar (gzFile in,int action,int arg,int argc,char **argv)`
387			`{`
388			`union tar_buffer buffer;`
389			`int len;`
390			`int err;`
391			`int getheader = 1;`
392			`int remaining = 0;`
393			`FILE *outfile = NULL;`
394			`char fname[BLOCKSIZE];`
395			`int tarmode;`
396			`time_t tartime;`
397			`struct attr_item *attributes = NULL;`
398
399			`if (action == TGZ_LIST)`
400			`printf(" date time size file\n"`
401			`" ---------- -------- --------- -------------------------------------\n");`
402			`while (1)`
403			`{`
404			`len = gzread(in, &buffer, BLOCKSIZE);`
405			`if (len < 0)`
406			`error(gzerror(in, &err));`
407			`/*`
408			`* Always expect complete blocks to process`
409			`* the tar information.`
410			`*/`
411			`if (len != BLOCKSIZE)`
412			`{`
413			`action = TGZ_INVALID; /* force error exit */`
414			`remaining = 0; /* force I/O cleanup */`
415			`}`
416
417			`/*`
418			`* If we have to get a tar header`
419			`*/`
420			`if (getheader >= 1)`
421			`{`
422			`/*`
423			`* if we met the end of the tar`
424			`* or the end-of-tar block,`
425			`* we are done`
426			`*/`
427			`if (len == 0 \|\| buffer.header.name[0] == 0)`
428			`break;`
429
430			`tarmode = getoct(buffer.header.mode,8);`
431			`tartime = (time_t)getoct(buffer.header.mtime,12);`
432			`if (tarmode == -1 \|\| tartime == (time_t)-1)`
433			`{`
434			`buffer.header.name[0] = 0;`
435			`action = TGZ_INVALID;`
436			`}`
437
438			`if (getheader == 1)`
439			`{`
440			`strncpy(fname,buffer.header.name,SHORTNAMESIZE);`
441			`if (fname[SHORTNAMESIZE-1] != 0)`
442			`fname[SHORTNAMESIZE] = 0;`
443			`}`
444			`else`
445			`{`
446			`/*`
447			`* The file name is longer than SHORTNAMESIZE`
448			`*/`
449			`if (strncmp(fname,buffer.header.name,SHORTNAMESIZE-1) != 0)`
450			`error("bad long name");`
451			`getheader = 1;`
452			`}`
453
454			`/*`
455			`* Act according to the type flag`
456			`*/`
457			`switch (buffer.header.typeflag)`
458			`{`
459			`case DIRTYPE:`
460			`if (action == TGZ_LIST)`
461			`printf(" %s <dir> %s\n",strtime(&tartime),fname);`
462			`if (action == TGZ_EXTRACT)`
463			`{`
464			`makedir(fname);`
465			`push_attr(&attributes,fname,tarmode,tartime);`
466			`}`
467			`break;`
468			`case REGTYPE:`
469			`case AREGTYPE:`
470			`remaining = getoct(buffer.header.size,12);`
471			`if (remaining == -1)`
472			`{`
473			`action = TGZ_INVALID;`
474			`break;`
475			`}`
476			`if (action == TGZ_LIST)`
477			`printf(" %s %9d %s\n",strtime(&tartime),remaining,fname);`
478			`else if (action == TGZ_EXTRACT)`
479			`{`
480			`if (matchname(arg,argc,argv,fname))`
481			`{`
482			`outfile = fopen(fname,"wb");`
483			`if (outfile == NULL) {`
484			`/* try creating directory */`
485			`char *p = strrchr(fname, '/');`
486			`if (p != NULL) {`
487			`*p = '\0';`
488			`makedir(fname);`
489			`*p = '/';`
490			`outfile = fopen(fname,"wb");`
491			`}`
492			`}`
493			`if (outfile != NULL)`
494			`printf("Extracting %s\n",fname);`
495			`else`
496			`fprintf(stderr, "%s: Couldn't create %s",prog,fname);`
497			`}`
498			`else`
499			`outfile = NULL;`
500			`}`
501			`getheader = 0;`
502			`break;`
503			`case GNUTYPE_LONGLINK:`
504			`case GNUTYPE_LONGNAME:`
505			`remaining = getoct(buffer.header.size,12);`
506			`if (remaining < 0 \|\| remaining >= BLOCKSIZE)`
507			`{`
508			`action = TGZ_INVALID;`
509			`break;`
510			`}`
511			`len = gzread(in, fname, BLOCKSIZE);`
512			`if (len < 0)`
513			`error(gzerror(in, &err));`
514			`if (fname[BLOCKSIZE-1] != 0 \|\| (int)strlen(fname) > remaining)`
515			`{`
516			`action = TGZ_INVALID;`
517			`break;`
518			`}`
519			`getheader = 2;`
520			`break;`
521			`default:`
522			`if (action == TGZ_LIST)`
523			`printf(" %s <---> %s\n",strtime(&tartime),fname);`
524			`break;`
525			`}`
526			`}`
527			`else`
528			`{`
529			`unsigned int bytes = (remaining > BLOCKSIZE) ? BLOCKSIZE : remaining;`
530
531			`if (outfile != NULL)`
532			`{`
533			`if (fwrite(&buffer,sizeof(char),bytes,outfile) != bytes)`
534			`{`
535			`fprintf(stderr,`
536			`"%s: Error writing %s -- skipping\n",prog,fname);`
537			`fclose(outfile);`
538			`outfile = NULL;`
539			`remove(fname);`
540			`}`
541			`}`
542			`remaining -= bytes;`
543			`}`
544
545			`if (remaining == 0)`
546			`{`
547			`getheader = 1;`
548			`if (outfile != NULL)`
549			`{`
550			`fclose(outfile);`
551			`outfile = NULL;`
552			`if (action != TGZ_INVALID)`
553			`push_attr(&attributes,fname,tarmode,tartime);`
554			`}`
555			`}`
556
557			`/*`
558			`* Abandon if errors are found`
559			`*/`
560			`if (action == TGZ_INVALID)`
561			`{`
562			`error("broken archive");`
563			`break;`
564			`}`
565			`}`
566
567			`/*`
568			`* Restore file modes and time stamps`
569			`*/`
570			`restore_attr(&attributes);`
571
572			`if (gzclose(in) != Z_OK)`
573			`error("failed gzclose");`
574
575			`return 0;`
576			`}`
577
578
579			`/* ============================================================ */`
580
581			`void help(int exitval)`
582			`{`
583			`printf("untgz version 0.2.1\n"`
584			`" using zlib version %s\n\n",`
585			`zlibVersion());`
586			`printf("Usage: untgz file.tgz extract all files\n"`
587			`" untgz file.tgz fname ... extract selected files\n"`
588			`" untgz -l file.tgz list archive contents\n"`
589			`" untgz -h display this help\n");`
590			`exit(exitval);`
591			`}`
592
593			`void error(const char *msg)`
594			`{`
595			`fprintf(stderr, "%s: %s\n", prog, msg);`
596			`exit(1);`
597			`}`
598
599
600			`/* ============================================================ */`
601
602			`#if defined(WIN32) && defined(__GNUC__)`
603			`int _CRT_glob = 0; /* disable argument globbing in MinGW */`
604			`#endif`
605
606			`int main(int argc,char **argv)`
607			`{`
608			`int action = TGZ_EXTRACT;`
609			`int arg = 1;`
610			`char *TGZfile;`
611			`gzFile *f;`
612
613			`prog = strrchr(argv[0],'\\');`
614			`if (prog == NULL)`
615			`{`
616			`prog = strrchr(argv[0],'/');`
617			`if (prog == NULL)`
618			`{`
619			`prog = strrchr(argv[0],':');`
620			`if (prog == NULL)`
621			`prog = argv[0];`
622			`else`
623			`prog++;`
624			`}`
625			`else`
626			`prog++;`
627			`}`
628			`else`
629			`prog++;`
630
631			`if (argc == 1)`
632			`help(0);`
633
634			`if (strcmp(argv[arg],"-l") == 0)`
635			`{`
636			`action = TGZ_LIST;`
637			`if (argc == ++arg)`
638			`help(0);`
639			`}`
640			`else if (strcmp(argv[arg],"-h") == 0)`
641			`{`
642			`help(0);`
643			`}`
644
645			`if ((TGZfile = TGZfname(argv[arg])) == NULL)`
646			`TGZnotfound(argv[arg]);`
647
648			`++arg;`
649			`if ((action == TGZ_LIST) && (arg != argc))`
650			`help(1);`
651
652			`/*`
653			`* Process the TGZ file`
654			`*/`
655			`switch(action)`
656			`{`
657			`case TGZ_LIST:`
658			`case TGZ_EXTRACT:`
659			`f = gzopen(TGZfile,"rb");`
660			`if (f == NULL)`
661			`{`
662			`fprintf(stderr,"%s: Couldn't gzopen %s\n",prog,TGZfile);`
663			`return 1;`
664			`}`
665			`exit(tar(f, action, arg, argc, argv));`
666			`break;`
667
668			`default:`
669			`error("Unknown option");`
670			`exit(1);`
671			`}`
672
673			`return 0;`
674			`}`