tandem.c

给出了 zip 压缩算法的完整实现过程。

/*
  Copyright (c) 1990-2005 Info-ZIP.  All rights reserved.

  See the accompanying file LICENSE, version 2004-May-22 or later
  (the contents of which are also included in zip.h) for terms of use.
  If, for some reason, both of these files are missing, the Info-ZIP license
  also may be found at:  ftp://ftp.info-zip.org/pub/infozip/license.html
*/
/*
 * routines common to TANDEM (ZIP and UNZIP)
 */

#include "zip.h"   /* This sets up ZIP / UNZIP define */

#include <tal.h>
#include "$system.zsysdefs.zsysc" nolist
#include <cextdecs> nolist
#include "tannsk.h"

int isatty (fnum)
int fnum;
{
  return 1;
}

/********************/
/* Function in2ex() */
/********************/

char *in2ex(n)
  char *n;              /* internal file name */
/* Convert the zip file name to an external file name, returning the malloc'ed
   string or NULL if not enough memory. */
{
  char *x;              /* external file name */
  char *t;              /* pointer to internal */
  char *p;              /* pointer to internal */
  char *e;              /* pointer to internal */

  if ((x = malloc(strlen(n) + 4)) == NULL)  /* + 4 for safety */
    return NULL;
  *x= '\0';

  /* Junk pathname as requested */
#ifdef UNZIP
  if (uO.jflag && (t = strrchr(n, INTERNAL_DELIMITER)) != NULL)
    ++t;
  else
    t = n;
#endif /* UNZIP */
#ifdef ZIP
  if (!pathput)
    t = last(n, INTERNAL_DELIMITER);
  else
    t = n;
#endif /* ZIP */

  while (*t != '\0') {  /* File part could be sys, vol, subvol or file */
    if (*t == INTERNAL_DELIMITER) {    /* System, Volume or Subvol Name */
      t++;
      if (*t == INTERNAL_DELIMITER) {  /* System */
        strcat(x, TANDEM_NODE_STR);
        t++;
      }
      else
        strcat(x, TANDEM_DELIMITER_STR);
    }
    p = strchr(t, INTERNAL_DELIMITER);
    if (p == NULL)
      break;
    if ((e = strchr(t, DOS_EXTENSION)) == NULL)
      e = p;
    else
      e = _min(e, p);
    /* can't have Tandem name longer than 8 characters */
    strncat(x, t, _min(MAXFILEPARTLEN, (e - t)));
    t = p;
  }

  if ((e = strchr(t, DOS_EXTENSION)) == NULL)
    strncat(x, t, _min(MAXFILEPARTLEN, strlen(t)));
  else {
    strncat(x, t, _min(MAXFILEPARTLEN, (e - t)));
    strcat(x, TANDEM_EXTENSION_STR);
    strcat(x, e+1);  /* no restriction on extension length as its virtual*/
  }

  return x;
}

void zexit(status)
  int status;
{
  terminate_program (0,0,status,,,);   /* Exit(>0) creates saveabend files */
}


#ifdef fopen
#  undef fopen
#endif

FILE *zipopen(fname, opt)
const char *fname;
const char *opt;
{
  int fdesc,fnum,err;

#ifdef ZIP
  #define alist_items 1
  #define vlist_bytes 2
  short alist[alist_items]={42};
  unsigned short vlist[alist_items]={NSK_ZIPFILECODE};
  short extra, *err_item=&extra;
#endif /* ZIP */

  if (strcmp(opt,FOPW) == 0)
    if ((fdesc = creat(fname,,100,500)) != -1){
      fnum = fdtogfn (fdesc);
      err = (SETMODE (fnum, SET_FILE_BUFFERSIZE, TANDEM_BLOCKSIZE) != CCE);
      err = (SETMODE (fnum, SET_FILE_BUFFERED, 0, 0) != CCE);
      err = (SETMODE (fnum, SET_FILE_BUFFERED, 0, 1) != CCE);
      err = close(fdesc);
#ifdef ZIP
      err = FILE_ALTERLIST_((char *)fname,
                            (short)(strlen(fname)),
                            alist,
                            alist_items,
                            vlist,
                            vlist_bytes,
                            ,
                            err_item);
#endif /* ZIP */
    };

  return fopen(fname,opt);
}
#define fopen zipopen

#ifdef putc
#  undef putc
#endif

int zputc(ch, fptr)
  int ch;
  FILE *fptr;
{
  int err;
  err = putc(ch,fptr);
  fflush(fptr);
  return err;
}
#define putc zputc

#ifdef LICENSED
_tal _priv short FILE_CHANGELABEL_ (
 short,          /* IN */
 short,          /* IN */
 const short _far *    /* IN */
 );

_c _callable int changelabel OF((short, const short *, const short *));

_c _callable int changelabel(fnum, modtime, actime)
  short fnum;
  const short *modtime;
  const short *actime;
{
  int err;

  err = FILE_CHANGELABEL_(fnum, 16, modtime);
  if (!err)
    err = FILE_CHANGELABEL_(fnum, 17, actime);
  return err;
}

int islicensed(void)
{
  #define plist_items 1
  #define plist_size 10

  short myphandle[ZSYS_VAL_PHANDLE_WLEN];
  short licensetag[plist_items] = {37};
  short licensed[plist_size];
  short maxlen = plist_size;
  short items = plist_items;
  short resultlen[1], err;

  err = PROCESSHANDLE_NULLIT_(myphandle);

  if (!err)
    err = PROCESS_GETINFO_(myphandle);

  if (!err)
    err = PROCESS_GETINFOLIST_(/*cpu*/,
                               /*pin*/,
                               /*nodename*/,
                               /*nodenamelen*/,
                               myphandle,
                               licensetag,
                               items,
                               licensed,
                               maxlen,
                               resultlen
                              );

  if (err != 0)
    return 0;
  else
    return licensed[0];
}
#endif /* LICENSED */

int utime(file, time)
  const char *file;
  const ztimbuf *time;
{
#ifdef LICENSED
  int result, err;
  union timestamp_ov {
    long long fulltime;
    short wordtime[4];
  };
  union timestamp_ov lasttime, opentime;
  struct tm *modt, *opent;
  short datetime[8], errormask[1];
  short len, fnum, access, exclus, options;
  char fname[FILENAME_MAX + 1];
  short extension;
  char ext[EXTENSION_MAX + 1];

  if (islicensed() ) {
    /* Attempt to update file label */
    modt = gmtime( &time->modtime );

    datetime[0] = modt->tm_year + 1900;
    datetime[1] = modt->tm_mon + 1;
    datetime[2] = modt->tm_mday;
    datetime[3] = modt->tm_hour;
    datetime[4] = modt->tm_min;
    datetime[5] = modt->tm_sec;
    datetime[6] = datetime[7] = 0;
    errormask[0] = 0;
    lasttime.fulltime = COMPUTETIMESTAMP (datetime, errormask);

    opent = gmtime( &time->actime );

    datetime[0] = opent->tm_year + 1900;
    datetime[1] = opent->tm_mon + 1;
    datetime[2] = opent->tm_mday;
    datetime[3] = opent->tm_hour;
    datetime[4] = opent->tm_min;
    datetime[5] = opent->tm_sec;
    datetime[6] = datetime[7] = 0;
    errormask[0] = 0;
    opentime.fulltime = COMPUTETIMESTAMP (datetime, errormask);

    /* Remove any (pseudo) file extension */
    extension = parsename (file,fname,ext);
    len = strlen(fname);

    access = NSK_WRONLY;
    exclus = NSK_SHARED;
    options = NSK_NOUPDATEOPENTIME;

    extension = parsename (file,fname,ext);
    len = strlen(fname);

    err = FILE_OPEN_((char *)fname, len, &fnum, access, exclus,,,options,,,);
    result = changelabel(fnum,lasttime.wordtime,opentime.wordtime);
    err = FILE_CLOSE_(fnum);
    return result;
  }
  return -1;
#else  /* !LICENSED */
  return 0;             /* "no error", to suppress annoying failure messages */
#endif  /* ?LICENSED */
}

/* TANDEM version of chmod() function */

int chmod(file, unix_sec)
  const char *file;
  mode_t unix_sec;
{
  FILE *stream;
  struct nsk_sec_type {
    unsigned progid : 1;
    unsigned clear  : 1;
    unsigned null   : 2;
    unsigned read   : 3;
    unsigned write  : 3;
    unsigned execute: 3;
    unsigned purge  : 3;
  };
  union nsk_sec_ov {
    struct nsk_sec_type bit_ov;
    short int_ov;
  };
  union nsk_sec_ov nsk_sec;
  short fnum, err, nsk_sec_int;
  short len, access, exclus, extension, options;
  char fname[FILENAME_MAX + 1];
  char ext[EXTENSION_MAX + 1];

  nsk_sec.bit_ov.progid = 0;
  nsk_sec.bit_ov.clear  = 0;
  nsk_sec.bit_ov.null   = 0;

  /*  4="N", 5="C", 6="U", 7="-"   */

  if (unix_sec & S_IROTH) nsk_sec.bit_ov.read = 4;
  else if (unix_sec & S_IRGRP) nsk_sec.bit_ov.read = 5;
  else if (unix_sec & S_IRUSR) nsk_sec.bit_ov.read = 6;
  else nsk_sec.bit_ov.read = 7;

  if (unix_sec & S_IWOTH) nsk_sec.bit_ov.write = 4;
  else if (unix_sec & S_IWGRP) nsk_sec.bit_ov.write = 5;
  else if (unix_sec & S_IWUSR) nsk_sec.bit_ov.write = 6;
  else nsk_sec.bit_ov.write = 7;

  if (unix_sec & S_IXOTH) nsk_sec.bit_ov.execute = 4;
  else if (unix_sec & S_IXGRP) nsk_sec.bit_ov.execute = 5;
  else if (unix_sec & S_IXUSR) nsk_sec.bit_ov.execute = 6;
  else nsk_sec.bit_ov.execute = 7;

  nsk_sec.bit_ov.purge = nsk_sec.bit_ov.write;

  nsk_sec_int = nsk_sec.int_ov;

  access = NSK_RDONLY;
  exclus = NSK_SHARED;
  options = NSK_NOUPDATEOPENTIME;

  extension = parsename (file,fname,ext);
  len = strlen(fname);

  err = FILE_OPEN_((char *)fname, len, &fnum, access, exclus,,,options,,,);
  err = (SETMODE(fnum, SET_FILE_SECURITY, nsk_sec_int) != CCE);
  err = FILE_CLOSE_(fnum);

  return (err != 0 ? -1 : 0);
}

/* TANDEM version of chown() function */

int chown(file, uid, gid)
  const char *file;
  uid_t uid;
  gid_t gid;
{
  FILE *stream;
  struct nsk_own_type {
    unsigned group  : 8;
    unsigned user   : 8;
  };
  union nsk_own_ov {
    struct nsk_own_type bit_ov;
    short int_ov;
  };
  union nsk_own_ov nsk_own;
  short fnum, err, nsk_own_int;
  short len, access, exclus, extension, options;
  char fname[FILENAME_MAX + 1];
  char ext[EXTENSION_MAX + 1];

  nsk_own.bit_ov.group = gid;
  nsk_own.bit_ov.user  = uid;

  nsk_own_int = nsk_own.int_ov;

  access = NSK_RDONLY;
  exclus = NSK_SHARED;
  options = NSK_NOUPDATEOPENTIME;

  extension = parsename (file,fname,ext);
  len = strlen(fname);

  err = FILE_OPEN_((char *)fname, len, &fnum, access, exclus,,,options,,,);
  err = (SETMODE(fnum, SET_FILE_OWNER, nsk_own_int) != CCE);
  err = FILE_CLOSE_(fnum);
  return (err != 0 ? -1 : 0);
}

/* TANDEM version of getch() - non-echo character reading */
int zgetch(void)
{
  char ch;
  int f,fnum,count, rlen,wlen, err;

  rlen = 1;
  wlen = 0;
  f = fileno(stdin);
  fnum = fdtogfn (f);
  #define ECHO_MODE 20
  err = (SETMODE(fnum, ECHO_MODE, 0) != CCE);
  err = (READX(fnum, &ch, rlen, (short *) &count) != CCE);
  err = (SETMODE(fnum, ECHO_MODE, 1) != CCE);

  if (err)
    if (err != 1)
      return EOF;
    else
      ch = 'q';
  else
    if (count == 0)
      ch = '\r';

  return (int)ch;
}

/* TANDEM version of stat() function */

time_t gmt_to_time_t (gmt)
  long long *gmt;
{
  #define GMT_TO_LCT 0
  #define GMT_TO_LST 1

  struct tm temp_tm;
  short  date_time[8];
  long   julian_dayno;
  long long lct, lst, itime;
  short  err[1], type;

  type = GMT_TO_LCT;
  lct = CONVERTTIMESTAMP(*gmt, type,, err);

  if (!err[0]) {
    type = GMT_TO_LST;
    lst = CONVERTTIMESTAMP(*gmt, type,, err);
  }

  itime = (err[0] ? *gmt : lct);
  /* If we have no DST in force then make sure we give it a value,