pack.c

一套客户/服务器模式的备份系统代码,跨平台,支持linux,AIX, IRIX, FreeBSD, Digital Unix (OSF1), Solaris and HP-UX.

	if( (i = ofunc(buf, 4, params)) ){
	  params->vars.errnum |= EPACKWRITE;
	  return(i);
	}
    }
  }

  params->vars.sum_uncompr_filesizes += (Real64) statb->st_size;

  return(0);
}

#ifdef	USE_POSIX_ACLS
#ifdef	ACL_TYPE_DEFAULT_DIR
#define	PACKER_ACL_NUM_TYPES	3
#else
#define	PACKER_ACL_NUM_TYPES	2
#endif

#ifdef	NACLBASE
#define	PACKER_MIN_ACL_ENTRIES	NACLBASE
#else
#ifdef	ACL_MIN_ENTRIES
#define	PACKER_MIN_ACL_ENTRIES	ACL_MIN_ENTRIES
#else
#define	PACKER_MIN_ACL_ENTRIES	4
#endif
#endif

acl_type_t packer_posix_acl_types_arr[3] = {
		ACL_TYPE_ACCESS,
		ACL_TYPE_DEFAULT,
#if PACKER_ACL_NUM_TYPES >= 3
		ACL_TYPE_DEFAULT_DIR,
#endif
};

Int32
packer_posix_acl_types(Int32 idx)
{
  return(packer_posix_acl_types_arr[idx]);
}
#endif

static Int32
write_acls(UChar * name, struct stat * statb, AarParams * params)
{
  Int32		i, k, n;
  UChar		sbuf[128];	/* space for > 3 x 64 Bit unsigned */

#ifdef	USE_POSIX_ACLS
{
  Uns32		acl_types;
  acl_t		acl;
  acl_entry_t	acl_entry;
  UChar		*acl_strs[3];
  ssize_t	aclstrlens[3];

  memset(acl_strs, 0, 3 * sizeof(acl_strs[0]));
  acl_types = 0;

  n = IS_DIRECTORY((*statb)) ? PACKER_ACL_NUM_TYPES : 1;
  for(i = 0; i < n; i++){
    acl = acl_get_file(name, packer_posix_acl_types(i));
    if(acl){
#ifndef	sgi
#ifndef	__osf__

	for(k = 0; acl_get_entry(acl, k ? ACL_NEXT_ENTRY : ACL_FIRST_ENTRY, &acl_entry); k++);

#else
	acl_first_entry(acl);			/* this is for OSF1 */
	for(k = 0; acl_get_entry(acl); k++);
	acl_first_entry(acl);
#endif
#else
	k = acl->acl_cnt;			/* and this is for IRIX */
#endif

	if(k > PACKER_MIN_ACL_ENTRIES){
	  acl_strs[i] =
#ifdef	HAVE_ACL_TO_SHORT_TEXT
			acl_to_short_text
#else
			acl_to_text
#endif
					(acl, &(aclstrlens[i]));
	  if(!acl_strs[i])
	    return(-ENOMEM);

	  acl_types |= (1 << i);
	}
        acl_free(acl);
    }
  }

  if(acl_types){
    sprintf(sbuf, "%d;%d", (int) POSIX_ACL, (int) acl_types);
    if( (k = params->outputfunc(sbuf, strlen(sbuf), params)) )
	return(k);

    for(i = 0; i < n; i++){
      if(acl_strs[i]){
	sprintf(sbuf, ";%d;", (int) aclstrlens[i]);
	if( (k = params->outputfunc(sbuf, strlen(sbuf), params)) )
	  return(k);
	if( (k = params->outputfunc(acl_strs[i], aclstrlens[i], params)) )
	  return(k);
#ifdef	HAVE_ACL_FREE_TEXT
	acl_free_text(acl_strs[i]);
#else
	acl_free(acl_strs[i]);
#endif
      }
    }
    if( (k = params->outputfunc(";.", 2, params)) )
	return(k);
  }
}
#else	/* defined(USE_POSIX_ACLS) */

#ifdef	USE_SOLARIS2_ACLS
{
  aclent_t	*acls;
  int		nacls;

  nacls = acl(name, GETACLCNT, 0, NULL);
  if(nacls > MIN_ACL_ENTRIES){
    acls = NEWP(aclent_t, nacls);
    if(!acls)
	return(-ENOMEM);

    nacls = acl(name, GETACL, nacls, acls);

    sprintf(sbuf, "%d;%d;", (int) SOLARIS2_ACL, (int) nacls);
    if( (k = params->outputfunc(sbuf, strlen(sbuf), params)) )
	return(k);

    for(i = 0; i < nacls; i++){
	sprintf(sbuf, "%d;%d;%d;", (int) acls[i].a_type,
			(int) acls[i].a_id, (int) acls[i].a_perm);
	if( (k = params->outputfunc(sbuf, strlen(sbuf), params)) ){
	  free(acls);
	  return(k);
	}
    }

    free(acls);
    if( (k = params->outputfunc(".", 1, params)) )
	return(k);
  }
}
#endif

#ifdef	USE_HPUX10_ACLS
{
  struct acl_entry	*acls;
  int			nacls;

  nacls = getacl(name, 0, NULL);
  if(nacls > NBASEENTRIES){
    acls = NEWP(struct acl_entry, nacls);
    if(!acls)
	return(-ENOMEM);

    nacls = getacl(name, nacls, acls);

    sprintf(sbuf, "%d;%d;", (int) HPUX10_ACL, (int) nacls);
    if( (k = params->outputfunc(sbuf, strlen(sbuf), params)) )
	return(k);

    for(i = 0; i < nacls; i++){
	sprintf(sbuf, "%d;%d;%d;", (int) acls[i].uid,
			(int) acls[i].gid, (int) acls[i].mode);
	if( (k = params->outputfunc(sbuf, strlen(sbuf), params)) ){
	  free(acls);
	  return(k);
	}
    }

    free(acls);
    if( (k = params->outputfunc(".", 1, params)) )
	return(k);
  }
}
#endif
#endif /* defined(USE_POSIX_ACLS) */

  return(0);
}

static Int32
l_writeout(UChar * name, AarParams * params, Flag dont_save_as_hardlink)
{
  struct stat	statb, pdirstatb;
  Int32		i, n;
  Flag		compress;
  UChar		buf[BUFFERSIZ], sbuf[MAXPATHLEN + 100];
  UChar		verbosestr[MAXPATHLEN * 4 + 100], mtimestr[50];
  UChar		esc_name[MAXPATHLEN * 4 + 100];
  int		fd, pid, pst, ftype, ftype_attrs;
  UChar		*hlinkname;
  DIR		*dir;
  struct dirent	*entry;
  UChar		*cptr;
  FILE		*errfp;
  UChar		*unzipcmd;
  Int32		(*ofunc)(UChar *, Int32, AarParams *);
  Int32		(*readfunc)(int, UChar *, Int32);
  Uns8		filecontents = 0;
  struct utimbuf utim;
  Flag		cks;
  Uns32		crc32sum;	/* uninitialized OK */
  Flag		no_hardlink;

  cks = NO;

#ifdef	USE_ZLIB

  cks = params->check;

#else

  if(params->check){
    fprintf(stderr, T_("Warning: CRC32 checksumming not available (requires zlib).\n"));
    params->check = NO;
  }

#endif  

  ftype_attrs = 0;
  if(! strncmp(name, NOVERIFYPREFIX, i = strlen(NOVERIFYPREFIX))){
    ftype_attrs |= PACK_NOVERIFY;
    name += i;
  }

  if(! strncmp(name, CMDINOUTPREFIX, i = strlen(CMDINOUTPREFIX)))
    if(strstr(name + i, CMDINOUTSEP))
	return(write_cmdio(name, params, ftype_attrs));

  ofunc = params->outputfunc;
  readfunc = params->readfunc;

  unzipcmd = "";
  if(params->zipcmd && params->unzipcmd)
    if(*params->zipcmd && *params->unzipcmd)
      unzipcmd = params->unzipcmd;

  errfp = params->errfp;

  if(! strncmp(name, FILECONTPREFIX, i = strlen(FILECONTPREFIX))){
    filecontents = 1;
    name += i;
  }
  if(! strncmp(name, FILECONTZPREFIX, i = strlen(FILECONTZPREFIX))){
    filecontents = 1 | ((unzipcmd[0]
#ifdef	USE_ZLIB
			|| params->bi_compr_level > 0
#endif
				) ? (1 << 1) : 0);
    name += i;
  }

  strcpy(esc_name, name);

  repl_esc_seq(name, ESCAPE_CHARACTER);

  i = lstat(name, &statb);

  if(i < 0){
    fprintf(errfp, T_("Error: cannot lstat `%s'.\n"), name);
    params->vars.errnum |= EPACKNOENT;
    return(-ENOENT);
  }

  if((! IS_DIRECTORY(statb) || ! params->recursive)
			&& (! time_cond(statb, params)
				|| ! uid_cond(statb, params)))
    return(0);

  params->vars.num_fsentries++;

  SETZERO(utim);	/* on some architectures utim is more complex */
  utim.modtime = statb.st_mtime;
  utim.actime = statb.st_atime;

  params->vars.uid = statb.st_uid;
  params->vars.mtime = statb.st_mtime;

#ifndef	HAVE_LCHOWN

  if(IS_SYMLINK(statb)){		/* if the symlink is owned by root, */
    if(statb.st_uid == 0 && statb.st_gid == 0){		/* print UID of the */
	strcpy(verbosestr, name);			/* parent directory */
	cleanpath(verbosestr);
	cptr = FN_LASTDIRDELIM(verbosestr);
	if(cptr){
	  *(cptr + 1) = '\0';
	  if(!FN_ISROOTDIR(verbosestr))
	    *cptr = '\0';
	  i = stat(verbosestr, &pdirstatb);
	}
	else{
	  i = stat(FN_CURDIR, &pdirstatb);
	}

	if(!i)
	  params->vars.uid = pdirstatb.st_uid;
    }
  }

#endif

  if(params->pre_verbosefunc && ! IS_DIRECTORY(statb))
    (*params->pre_verbosefunc)(NULL, params);

  if(IS_SYMLINK(statb)){
    i = readlink(name, buf, BUFFERSIZ);

    if(i < 0){
	fprintf(errfp, T_("Error: cannot read symlink `%s'.\n"), name);
	params->vars.errnum |= EPACKSYMLINK;
	return(-errno);
    }

    buf[i] = '\0';

    sprintf(sbuf, "%d;%lu;%s;%d;%d;%d;%s;", SYMLINK | ftype_attrs,
			(unsigned long) statb.st_mode,
			(char *) time_t_to_intstr(statb.st_mtime, mtimestr),
			(int) statb.st_uid, (int) statb.st_gid,
			(int) strlen(name), name);
    if( (i = ofunc(sbuf, strlen(sbuf), params)) ){
	params->vars.errnum |= EPACKWRITE;
	return(i);
    }
    sprintf(sbuf, "%d;%s.", (int) strlen(buf), buf);
    if( (i = ofunc(sbuf, strlen(sbuf), params)) ){
	params->vars.errnum |= EPACKWRITE;
	return(i);
    }

    /* if(!params->dont_keep_atime)
	utime(name, &utim); */ /* Yes, this was a bug */

    if(params->verbose && params->verbosefunc){
	sprintf(verbosestr, "%s\n", esc_name);
	params->verbosefunc(verbosestr, params);
    }

    return(0);
  }

  i = stat(name, &statb);

  if(i == -1){
    fprintf(errfp, T_("Error: cannot stat `%s'.\n"), name);
    params->vars.errnum |= EPACKNOENT;

    return(-ENOENT);
  }

  no_hardlink = (!IS_HARDLINK(statb) || dont_save_as_hardlink);

  if(!IS_DIRECTORY(statb) && no_hardlink){
    i = write_acls(name, &statb, params);
    if(i){
	params->vars.errnum |= EPACKACLS;
	return(i);
    }
  }

  utim.modtime = statb.st_mtime;
  utim.actime = statb.st_atime;

  if(filecontents){
    ER__(write_filecont(name, &statb, params,
			filecontents & (1 << 1), ftype_attrs), i);

    if(params->verbose && params->verbosefunc){
	sprintf(verbosestr, "%s\n", esc_name);
	params->verbosefunc(verbosestr, params);
    }
  } else if(IS_DIRECTORY(statb)){
    if(params->recursive){
      dir = opendir(name);

      if(!dir){
	fprintf(errfp, T_("Error: cannot read directory `%s'.\n"), name);
	params->vars.errnum |= EPACKNOENT;

	return(-ENOENT);
      }

      forever{
	entry = readdir(dir);
	if(! entry)
	  break;

	cptr = (UChar *) &(entry->d_name[0]);

	if(!strcmp(cptr, FN_CURDIR) || !strcmp(cptr, FN_PARENTDIR))
	  continue;

	strcpy(buf, esc_name);
	i = strlen(buf);
	if(i < FN_DIRSEPLEN || !FN_ISDIRSEP(buf[i - FN_DIRSEPLEN])){
	  strcpy(buf + i, FN_DIRSEPSTR);
	  i += FN_DIRSEPLEN;
	}
	mk_esc_seq(cptr, ESCAPE_CHARACTER, buf + i);

	l_writeout(buf, params, NO);
      }

      closedir(dir);
    }

    if(time_cond(statb, params)){	/* only, if time condition satisf */
      if(params->pre_verbosefunc)
	(*params->pre_verbosefunc)(NULL, params);

      i = write_acls(name, &statb, params);
      if(i){
	params->vars.errnum |= EPACKACLS;
	return(i);
      }

      sprintf(sbuf, "%d;%lu;%s;%d;%d;%d;%s.", DIRECTORY | ftype_attrs,
			(unsigned long) statb.st_mode,
			(char *) time_t_to_intstr(statb.st_mtime, mtimestr),
			(int) statb.st_uid, (int) statb.st_gid,
			(int) strlen(name), name);
      ER__(ofunc(sbuf, strlen(sbuf), params), i);

      if(params->verbose && params->verbosefunc){
	sprintf(verbosestr, "%s\n", esc_name);
	params->verbosefunc(verbosestr, params);
      }
    }

    if(!params->dont_keep_atime)
	utime(name, &utim);
  }
  else if(! no_hardlink){
    if(link_in_list(statb.st_ino, statb.st_dev, &hlinkname)){
      sprintf(sbuf, "%d;%lu;%s;%d;%d;%d;%s;", HARDLINK | ftype_attrs,
			(unsigned long) statb.st_mode,
			(char *) time_t_to_intstr(statb.st_mtime, mtimestr),
			(int) statb.st_uid, (int) statb.st_gid,
			(int) strlen(name), name);
      ER__(ofunc(sbuf, strlen(sbuf), params), i);
      sprintf(sbuf, "%d;%s.", (int) strlen(hlinkname), hlinkname);
      ER__(ofunc(sbuf, strlen(sbuf), params), i);

      if(params->verbose && params->verbosefunc){
	sprintf(verbosestr, "%s\n", esc_name);
	params->verbosefunc(verbosestr, params);
      }
    }
    else{
	l_writeout(esc_name, params, YES);

	add_link(name, statb.st_ino, statb.st_dev);
    }

    if(!params->dont_keep_atime)
	utime(name, &utim);
  }
  else if(IS_FIFO(statb)){
    sprintf(sbuf, "%d;%lu;%s;%d;%d;%d;%s.", FIFO | ftype_attrs,
			(unsigned long) statb.st_mode,
			(char *) time_t_to_intstr(statb.st_mtime, mtimestr),
			(int) statb.st_uid, (int) statb.st_gid,
			(int) strlen(name), name);
    ER__(ofunc(sbuf, strlen(sbuf), params), i)

    if(!params->dont_keep_atime)
	utime(name, &utim);

    if(params->verbose && params->verbosefunc){
	sprintf(verbosestr, "%s\n", esc_name);
	params->verbosefunc(verbosestr, params);
    }
  }
  else if(IS_SOCKET(statb)){
    sprintf(sbuf, "%d;%lu;%s;%d;%d;%d;%s.", SOCKET | ftype_attrs,
			(unsigned long) statb.st_mode,