tandem.c

zip压缩

  char *fptr;
  short extension = 0;

  *fname = *ext = '\0';  /* set to null string */

  fstart = (char *) srce;

  if ((fptr = strrchr(fstart, TANDEM_EXTENSION)) != NULL) {
    extension = 1;

    fptr++;
    strncat(ext, fptr, _min(EXTENSION_MAX, strlen(fptr)));

    fptr = strchr(fstart, TANDEM_EXTENSION);  /* End of filename */
    strncat(fname, fstart, _min(FILENAME_MAX, (fptr - fstart)));
  }
  else {
    /* just copy string */
    strncat(fname, srce, _min(FILENAME_MAX, strlen(srce)));
  }

  return extension;
}

static 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,
     else mktime screws up if we set the isdst flag to -1 */
  temp_tm.tm_isdst = (err[0] ? 0 : ((lct == lst) ? 0 : 1));

  julian_dayno = INTERPRETTIMESTAMP(itime, date_time);

  temp_tm.tm_sec   = date_time[5];
  temp_tm.tm_min   = date_time[4];
  temp_tm.tm_hour  = date_time[3];
  temp_tm.tm_mday  = date_time[2];
  temp_tm.tm_mon   = date_time[1] - 1;     /* C's so sad */
  temp_tm.tm_year  = date_time[0] - 1900;  /* it's almost funny */

  return (mktime(&temp_tm));
}

/* TANDEM version of stat() function */
int stat(n, s)
  const char *n;
  struct stat *s;
{
  #define ilist_items 26
  #define klist_items 4
  #define slist_items 3
  #define ulist_items 1
  #define flist_size 100

  short err, i, extension;
  char fname[FILENAME_MAX + 1];
  short fnamelen;
  char ext[EXTENSION_MAX + 1];

                         /* #0  #1  #2  #3  #4  #5  #6  #7  #8  #9 */
  short ilist[ilist_items]={56,144, 54,142, 58, 62, 60, 41, 42, 44,
                            50, 51, 52, 61, 63, 66, 67, 70, 72, 73,
                            74, 75, 76, 77, 78, 79                 };
  short ilen[ilist_items] ={ 4,  4,  4,  2,  1,  2,  1,  1,  1,  1,
                             1,  1,  1,  1,  1,  1,  1,  1,  1,  1,
                             1,  1,  1,  1,  1,  1                 };
  short ioff[ilist_items];

                         /* #0  #1  #2  #3  #4  #5  #6  #7  #8  #9 */
  short klist[klist_items]={45, 46, 68, 69                         };
  short klen[klist_items] ={ 1,  1,  1,  1                         };
  short koff[klist_items];

                         /* #0  #1  #2  #3  #4  #5  #6  #7  #8  #9 */
  short slist[slist_items]={43, 80, 90                             };
  short slen[slist_items] ={ 1,  1,  1                             };
  short soff[slist_items];

                         /* #0  #1  #2  #3  #4  #5  #6  #7  #8  #9 */
  short ulist[ulist_items]={65                                     };
  short ulen[ulist_items] ={ 1                                     };
  short uoff[ulist_items];

  short flist[flist_size];
  short extra[2];
  short *rlen=&extra[0];
  short *err_item=&extra[1];
  unsigned short *fowner;
  unsigned short *fprogid;
  char *fsec;

  nsk_stat_ov *nsk_ov;
  nsk_file_attrs *nsk_attr;

  short end, count, kind, level, options, searchid;
  short info[5];

  /* Initialise stat structure */
  s->st_dev = _S_GUARDIANOBJECT;
  s->st_ino = 0;
  s->st_nlink = 0;
  s->st_rdev = 0;
  s->st_uid = s->st_gid = 0;
  s->st_size = 0;
  s->st_atime = s->st_ctime = s->st_mtime = 0;
  s->st_reserved[0] = 0;
  s->st_reserved[1] = 0;
  s->st_reserved[2] = 0;
  nsk_ov = (nsk_stat_ov *)&s->st_reserved[0];
  nsk_attr = (nsk_file_attrs *)&nsk_ov->ov.nsk_ef_region;

  /* Check to see if name contains a (pseudo) file extension */
  extension = parsename (n,fname,ext);

  fnamelen = strlen(fname);

  options = 3; /* Allow Subvols and Templates */
  err = FILENAME_SCAN_( fname,
                        fnamelen,
                        &count,
                        &kind,
                        &level,
                        options
                      );

  /* allow kind == 2 (DEFINE names) */
  if (err != 0) return -1;

  if (kind == 1 || (kind == 0 && level < 2)) {
    /* Pattern, Subvol Name or One part Filename - lets see if it exists */
    err = FILENAME_FINDSTART_ ( &searchid,
                                fname,
                                fnamelen,
                                ,
                                DISK_DEVICE
                              );

    if (err != 0) {
      end = FILENAME_FINDFINISH_ ( searchid );
      return -1;
    }

    err = FILENAME_FINDNEXT_ ( searchid,
                               fname,
                               FILENAME_MAX,
                               &fnamelen,
                               info
                              );
    end = FILENAME_FINDFINISH_ ( searchid );

    if (err != 0)
      return -1;  /* Non existing template, subvol or file */

    if (kind == 1 || info[2] == -1) {
      s->st_mode = S_IFDIR;    /* Its an existing template or directory */
      return 0;
    }

    /* Must be a real file so drop to code below to get info on it */
  }

  err = FILE_GETINFOLISTBYNAME_( fname,
                                 fnamelen,
                                 ilist,
                                 ilist_items,
                                 flist,
                                 flist_size,
                                 rlen,
                                 err_item
                               );
  if (err != 0) return -1;

  ioff[0] = 0;

  /*  Build up table of offets into result list */
  for (i=1; i < ilist_items; i++)
    ioff[i] = ioff[i-1] + ilen[i-1];

  /* Set up main stat fields */

  /* Setup timestamps */
  s->st_atime = gmt_to_time_t ((long long *)&flist[ioff[0]]);
  s->st_mtime = s->st_ctime = gmt_to_time_t ((long long *)&flist[ioff[1]]);
  nsk_ov->ov.creation_time = gmt_to_time_t ((long long *)&flist[ioff[2]]);

  s->st_size = *(off_t *)&flist[ioff[3]];

  fowner = (unsigned short *)&flist[ioff[4]];
  s->st_uid = *fowner & 0x00ff;
  s->st_gid = *fowner >> 8;

  /* Note that Purge security (fsec[3]) in NSK has no relevance to stat() */
  fsec = (char *)&flist[ioff[5]];
  fprogid = (unsigned short *)&flist[ioff[6]];

  s->st_mode = S_IFREG |  /* Regular File */
  /*  Parse Read Flag */
               ((fsec[0] & 0x03) == 0x00 ? S_IROTH : 0) |
               ((fsec[0] & 0x02) == 0x00 ? S_IRGRP : 0) |
               ((fsec[0] & 0x03) != 0x03 ? S_IRUSR : 0) |
  /*  Parse Write Flag */
               ((fsec[1] & 0x03) == 0x00 ? S_IWOTH : 0) |
               ((fsec[1] & 0x02) == 0x00 ? S_IWGRP : 0) |
               ((fsec[1] & 0x03) != 0x03 ? S_IWUSR : 0) |
  /*  Parse Execute Flag */
               ((fsec[2] & 0x03) == 0x00 ? S_IXOTH : 0) |
               ((fsec[2] & 0x02) == 0x00 ? S_IXGRP : 0) |
               ((fsec[2] & 0x03) != 0x03 ? S_IXUSR : 0) |
  /*  Parse Progid */
               (*fprogid == 1 ? (S_ISUID | S_ISGID) : 0) ;

  /* Set up NSK additional stat fields */
  nsk_attr->progid   = (unsigned) flist[ioff[6]];
  nsk_attr->filetype = (unsigned) flist[ioff[7]];
  nsk_attr->filecode = (unsigned) flist[ioff[8]];
  nsk_attr->block    = (unsigned short) flist[ioff[9]];
  nsk_attr->priext   = (unsigned short) flist[ioff[10]];
  nsk_attr->secext   = (unsigned short) flist[ioff[11]];
  nsk_attr->maxext   = (unsigned short) flist[ioff[12]];
  nsk_attr->flags.clearonpurge = (unsigned) flist[ioff[13]];
  nsk_attr->licensed     = (unsigned) flist[ioff[14]];
  nsk_attr->flags.audited      = (unsigned) flist[ioff[15]];
  nsk_attr->flags.acompress    = (unsigned) flist[ioff[16]];
  nsk_attr->flags.refresheof   = (unsigned) flist[ioff[17]];
  nsk_attr->flags.buffered     = (unsigned) (flist[ioff[18]] == 0 ? 1 : 0);
  nsk_attr->flags.verified     = (unsigned) flist[ioff[19]];
  nsk_attr->flags.serial       = (unsigned) flist[ioff[20]];
  nsk_attr->flags.crashopen    = (unsigned) flist[ioff[22]];
  nsk_attr->flags.rollforward  = (unsigned) flist[ioff[23]];
  nsk_attr->flags.broken       = (unsigned) flist[ioff[24]];
  nsk_attr->flags.corrupt      = (unsigned) flist[ioff[25]];
  nsk_attr->fileopen     = (unsigned) flist[ioff[21]];


  if (nsk_attr->filetype == NSK_UNSTRUCTURED) {
    /* extra info for Unstructured files */
    err = FILE_GETINFOLISTBYNAME_( fname,
                                   fnamelen,
                                   ulist,
                                   ulist_items,
                                   flist,
                                   flist_size,
                                   rlen,
                                   err_item
                                 );
    if (err != 0) return -1;

    uoff[0] = 0;

    /*  Build up table of offets into result list */
    for (i=1; i < ulist_items; i++)
      uoff[i] = uoff[i-1] + ulen[i-1];
  }
  else {
    /* extra info for Structured files */
    err = FILE_GETINFOLISTBYNAME_( fname,
                                   fnamelen,
                                   slist,
                                   slist_items,
                                   flist,
                                   flist_size,
                                   rlen,
                                   err_item
                                 );
    if (err != 0) return -1;

    soff[0] = 0;

    /*  Build up table of offets into result list */
    for (i=1; i < slist_items; i++)
      soff[i] = soff[i-1] + slen[i-1];

    nsk_attr->reclen   = (unsigned) flist[soff[0]];
    nsk_attr->flags.secpart   = (unsigned) flist[soff[1]];
    nsk_attr->flags.primpart  = (unsigned)
     ( (flist[soff[2]] > 0 && nsk_attr->flags.secpart == 0) ? 1 : 0 );

    if (nsk_attr->filetype == NSK_KEYSEQUENCED) {
      /* extra info for Key Sequenced files */
      err = FILE_GETINFOLISTBYNAME_( fname,
                                     fnamelen,
                                     klist,
                                     klist_items,
                                     flist,
                                     flist_size,
                                     rlen,
                                     err_item
                                   );
      if (err != 0) return -1;

      koff[0] = 0;

      /*  Build up table of offets into result list */
      for (i=1; i < klist_items; i++)
        koff[i] = koff[i-1] + klen[i-1];

      nsk_attr->keyoff   = (unsigned) flist[koff[0]];
      nsk_attr->keylen   = (unsigned) flist[koff[1]];
      nsk_attr->flags.dcompress = (unsigned) flist[koff[2]];
      nsk_attr->flags.icompress = (unsigned) flist[koff[3]];
    }
  }

  return 0;
}

#ifndef SFX
/* TANDEM Directory processing */

DIR *opendir(const char *dirname)
{
   short i, resolve;
   char sname[FILENAME_MAX + 1];
   short snamelen;
   char fname[FILENAME_MAX + 1];
   short fnamelen;
   char *p;
   short searchid, err, end;
   struct dirent *entry;
   DIR *dirp;
   char ext[EXTENSION_MAX + 1];
   short extension;

   extension = parsename(dirname, sname, ext);
   snamelen = strlen(sname);

   /*  First we work out how detailed the template is...
    *  e.g. If the template is DAVES*.* we want the search result
    *       in the same format
    */

   p = sname;
   i = 0;
   while ((p = strchr(p, TANDEM_DELIMITER)) != NULL){
     i++;
     p++;
   };
   resolve = 2 - i;

   /*  Attempt to start a filename template */
   err = FILENAME_FINDSTART_ ( &searchid,
                               sname,
                               snamelen,
                               resolve,
                               DISK_DEVICE
                             );
   if (err != 0) {
     end = FILENAME_FINDFINISH_(searchid);
     return NULL;
   }

   /* Create DIR structure */
   if ((dirp = malloc(sizeof(DIR))) == NULL ) {
     end = FILENAME_FINDFINISH_(searchid);
     return NULL;
   }
   dirp->D_list = dirp->D_curpos = NULL;
   strcpy(dirp->D_path, dirname);

   while ((err = FILENAME_FINDNEXT_(searchid,
                                    fname,
                                    FILENAME_MAX,
                                    &fnamelen
                                   )
           ) == 0 ){
     /*  Create space for entry */
     if ((entry = malloc (sizeof(struct dirent))) == NULL) {
       end = FILENAME_FINDFINISH_(searchid);
       return NULL;
     }

     /*  Link to last entry */
     if (dirp->D_curpos == NULL)
       dirp->D_list = dirp->D_curpos = entry;  /* First name */
     else {
       dirp->D_curpos->d_next = entry;         /* Link */
       dirp->D_curpos = entry;
     };
     /* Add directory entry */
     *dirp->D_curpos->d_name = '\0';
     strncat(dirp->D_curpos->d_name,fname,fnamelen);
     if (extension) {
       strcat(dirp->D_curpos->d_name,TANDEM_EXTENSION_STR);
       strcat(dirp->D_curpos->d_name,ext);
     };
     dirp->D_curpos->d_next = NULL;
   };

   end = FILENAME_FINDFINISH_(searchid);

   if (err == 1) {  /*  Should return EOF at end of search */
     dirp->D_curpos = dirp->D_list;        /* Set current pos to start */
     return dirp;
   }
   else
     return NULL;
}

struct dirent *readdir(DIR *dirp)
{
   struct dirent *cur;

   cur = dirp->D_curpos;
   dirp->D_curpos = dirp->D_curpos->d_next;
   return cur;
}

void rewinddir(DIR *dirp)
{
   dirp->D_curpos = dirp->D_list;
}

int closedir(DIR *dirp)
{
   struct dirent *node;

   while (dirp->D_list != NULL) {
      node = dirp->D_list;
      dirp->D_list = dirp->D_list->d_next;
      free( node );
   }
   free( dirp );
   return 0;
}

#endif /* !SFX */