buutil.c

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

Int32
peer_in_list(int fd, UChar * hostlist)
{
  UChar	*peern;
  Int32	r;

  peern = get_connected_peername(fd);
  if(!peern)
    return(-1);

  r = host_in_list(peern, hostlist);

  free(peern);

  return(r);
}

Int32
get_entry_by_host(UChar * liststr, UChar * hostname, UChar ** rentry)
{
  UChar		*lstr, *cptr, *wptr, *optr, *gentry;
  Int32		r = -1, i, gidx = -1;

  if(!liststr){
    errno = EINVAL;
    return(-1);
  }

  liststr = repl_substring(liststr, "%H", hostname);
  if(!liststr)
    return(-3);

  lstr = NEWP(UChar, MAX(strlen(hostname), strlen(liststr)) + 1);
  if(!lstr)
    CLEANUPR(-2);

  strcpy(lstr, hostname);
  if( (cptr = strchr(lstr, '.')) )
    *cptr = '\0';
  cptr = repl_substring(liststr, "%h", lstr);
  if(!cptr)
    CLEANUPR(-4);
  free(liststr);
  liststr = cptr;

  lstr = RENEWP(lstr, UChar, strlen(liststr) + 1);
  if(!lstr)		/* liststr might have become LONGER */
    CLEANUPR(-5);

  wptr = liststr;
  i = 0;
  forever{
    optr = wptr;
    wptr = sscanwordq(wptr, lstr);
    if(!wptr)
	break;

    for(cptr = strchr(lstr, ':'); cptr; cptr = strchr(cptr + 1, ':'))
      if(!escaped(lstr, cptr, '\\'))
	break;

    if(cptr){
	if(host_in_list(hostname, cptr + 1) > 0)
	  break;
    }
    else{
	gidx = i;
	gentry = optr;
    }

    i++;
  }

  if(!wptr && gidx >= 0)
    r = gidx;
  if(wptr)
    r = i;

  if(r >= 0){
    if(rentry){
      if(!wptr && gidx >= 0)
	sscanwordq(gentry, lstr);
      else
	*cptr = '\0';

      repl_esc_seq(lstr, '\\');

      *rentry = RENEWP(lstr, UChar, strlen(lstr) + 1);
      lstr = NULL;
    }
  }

 cleanup:
  ZFREE(lstr);
  ZFREE(liststr);

  return(r);
}

Int32
rename_if_exists(UChar * filename, UChar * denot)
{
  UChar		*cptr = NULL, *cptr2 = NULL;
  Int32		r = 0;

  if(!access(filename, F_OK)){
    cptr = strapp(filename, ".");
    if(!cptr)
	CLEANUPR(-2);
    cptr2 = tmp_name(cptr);
    if(!cptr2)
	CLEANUPR(-3);
    if(!denot)
	denot = T_("File");
    fprintf(stdout, T_("Warning: %s exists, renaming to `%s'.\n"),
					denot, cptr2);
    if(rename(filename, cptr2)){
	fprintf(stderr, T_("Error: Renaming %s failed.\n"), filename);
	r = -1;
    }
  }

 cleanup:
  ZFREE(cptr);
  ZFREE(cptr2);

  return(r);
}

#define	BUDEVCONF_NOMEM		-1
#define	BUDEVCONF_NUMFMT	-2
#define	BUDEVCONF_NUMENT	-3
#define	BUDEVCONF_INCONS	-4
#define	BUDEVCONF_DUPDEV	-5
#define	BUDEVCONF_EINVAL	-6
#define	BUDEVCONF_DUPPOS	-7

static UChar	*budevconf_errors[] = {
			TN_("No memory"),
			TN_("Numerical format error in device entry %d"),
			TN_("No slots or no drives configured for changer"),
			TN_("Inconsistent numbers of slots or loadports given in device entry %d"),
			TN_("Duplicate device name in entry %d"),
			TN_("Illegal value in entry %d"),
			TN_("Duplicate entry for position in changer"),
		};

Int32
devices_from_confstr(
  UChar			*string,
  StreamerDevice	**streamersp,
  Int32			*num_streamersp,
  ChangerDevice		**changersp,
  Int32			*num_changersp)
{
  UChar			*cptr, *devptr, *endptr, *chgptr;
  Flag			nextdev, have_pos_in_changer;
  ChangerDevice		*changers = NULL, *cur_changer;
  Int32			num_changers = 0;
  StreamerDevice	*streamers = NULL;
  Int32			num_streamers = 0;
  Int32			cur_pos_in_changer;
  Int32			r = 0, i, nstr_1, nchr_1;
  int			i1, n;

  for(cptr = first_nospace(string); *cptr; cptr = devptr){
    for(devptr = cptr; ; devptr++){
      if(*devptr == '=' || *devptr == '@' || isspace(*devptr) || !(*devptr)){
	if(!(*devptr) || !escaped(cptr, devptr, '\\')){
	  nextdev = NO;

	  if(!(*devptr)){
	    nextdev = YES;
	  }
	  else if(isspace(*devptr)){
	    devptr = first_nospace(devptr);
	    if(*devptr != '=' && *devptr != '@')
		nextdev = YES;
	  }

	  streamers = ZRENEWP(streamers, StreamerDevice, num_streamers + 1);
	  if(!streamers)
	    GETOUTR(BUDEVCONF_NOMEM);
	  SETZERO(streamers[num_streamers]);
	  nstr_1 = num_streamers;
	  num_streamers++;

	  streamers[nstr_1].devicename = NEWP(UChar, (n = devptr - cptr) + 1);
	  if(!streamers[nstr_1].devicename)
	    GETOUTR(BUDEVCONF_NOMEM);

	  strncpy(streamers[nstr_1].devicename, cptr, n);
	  streamers[nstr_1].devicename[n] = '\0';

	  endptr = streamers[nstr_1].devicename + n - 1;
	  while(isspace(*endptr)
		&& !escaped(streamers[nstr_1].devicename, endptr, '\\'))
	    *(endptr--) = '\0';
	  repl_esc_seq(streamers[nstr_1].devicename, '\\');

	  for(i = 0; i < nstr_1; i++)
	    if(!strcmp(streamers[i].devicename, streamers[nstr_1].devicename))
		GETOUTR(BUDEVCONF_DUPDEV);

	  cur_changer = NULL;
	  have_pos_in_changer = NO;

	  if(!nextdev && *devptr == '='){
	    i = sscanf(++devptr, "%d%n", &i1, &n);
	    if(i < 1)
		GETOUTR(BUDEVCONF_NUMFMT);
	    if(i1 < 1)
		GETOUTR(BUDEVCONF_EINVAL);

	    cur_pos_in_changer = i1;
	    have_pos_in_changer = YES;

	    devptr = first_nospace(devptr + n);
	  }

	  if(!nextdev && *devptr == '@' && !escaped(cptr, devptr, '\\')){
	    devptr = first_nospace(devptr + 1);

	    for(chgptr = devptr; ; chgptr++){
	      if(*chgptr == '#' || *chgptr == '^' || isspace(*chgptr) || !(*chgptr)){
		if(!(*chgptr) || !escaped(devptr, chgptr, '\\')){
		  nextdev = NO;

		  if(!(*chgptr)){
		    nextdev = YES;
		  }
		  else if(isspace(*chgptr)){
		    chgptr = first_nospace(chgptr);
		    if(*chgptr != '#' && *chgptr != '^')
			nextdev = YES;
		  }

		  changers = ZRENEWP(changers, ChangerDevice, num_changers + 1);
		  if(!changers)
		    GETOUTR(BUDEVCONF_NOMEM);
		  SETZERO(changers[num_changers]);
		  nchr_1 = num_changers;
		  num_changers++;

		  changers[nchr_1].changername = NEWP(UChar, (n = chgptr - devptr) + 1);
		  if(!changers[nchr_1].changername)
		    GETOUTR(BUDEVCONF_NOMEM);

		  strncpy(changers[nchr_1].changername, devptr, n);
		  changers[nchr_1].changername[n] = '\0';

		  endptr = changers[nchr_1].changername + n - 1;
		  while(isspace(*endptr)
			&& !escaped(changers[nchr_1].changername, endptr, '\\'))
		    *(endptr--) = '\0';
		  repl_esc_seq(changers[nchr_1].changername, '\\');

		  cur_changer = changers + nchr_1;

		  for(i = 0; i < nchr_1; i++){
		    if(!strcmp(changers[i].changername, changers[nchr_1].changername)){
		      free(changers[nchr_1].changername);
		      num_changers--;
		      nchr_1--;

		      cur_changer = changers + i;

		      break;
		    }
		  }

		  if(*chgptr == '#'){
		    i = sscanf(++chgptr, "%d%n", &i1, &n);
		    if(i < 1)
			GETOUTR(BUDEVCONF_NUMFMT);
		    if(i1 < 1)
			GETOUTR(BUDEVCONF_EINVAL);

		    if(cur_changer->num_slots > 0
				&& cur_changer->num_slots != i1)
			GETOUTR(BUDEVCONF_INCONS);

		    cur_changer->num_slots = i1;

		    chgptr = first_nospace(chgptr + n);

		    if(!(*chgptr))
			nextdev = YES;
		  }
		  if(*chgptr == '^'){
		    i = sscanf(++chgptr, "%d%n", &i1, &n);
		    if(i < 1)
			GETOUTR(BUDEVCONF_NUMFMT);
		    if(i1 < 0)
			GETOUTR(BUDEVCONF_EINVAL);

		    if(cur_changer->num_loadports > 0
				&& cur_changer->num_loadports != i1)
			GETOUTR(BUDEVCONF_INCONS);

		    cur_changer->num_loadports = i1;

		    chgptr = first_nospace(chgptr + n);
		  }

		  break;
		}
	      }
	    }
	  }
	  else{
	    chgptr = devptr;
	  }

	  if(cur_changer){
	    streamers[nstr_1].changername_ptr = cur_changer->changername;
	    cur_changer->num_drives++;

	    if(have_pos_in_changer)
		streamers[nstr_1].pos_in_changer = cur_pos_in_changer;
	  }

	  devptr = chgptr;

	  break;
	}
      }
    }
  }

  for(i = 0; i < num_streamers; i++){
    if(!streamers[i].pos_in_changer && streamers[i].changername_ptr){
      cur_pos_in_changer = 1;

      for(n = 0; n < num_streamers; n++){	/* complete pos_in_changer */
	if(streamers[n].pos_in_changer == cur_pos_in_changer){
	  if(streamers[n].changername_ptr){
	    if(!strcmp(streamers[n].changername_ptr,
				streamers[i].changername_ptr)){
		cur_pos_in_changer++;
		n = -1;		/* restart search */
	    }
	  }
	}
      }

      streamers[i].pos_in_changer = cur_pos_in_changer;
    }

    if(streamers[i].pos_in_changer && streamers[i].changername_ptr)
      for(n = 0; n < i; n++)
        if(streamers[i].pos_in_changer == streamers[n].pos_in_changer
		&& !strcmp(streamers[i].changername_ptr, streamers[n].changername_ptr))
	  GETOUTR(BUDEVCONF_DUPPOS);

    for(n = 0; n < num_changers; n++){
      if(changers[n].num_slots < 1 || changers[n].num_drives < 1)
	GETOUTR(BUDEVCONF_NUMENT);

      if(streamers[i].changername_ptr){
	if(!strcmp(streamers[i].changername_ptr, changers[n].changername)){
	  streamers[i].changer = changers + n;
	  break;
	}
      }
    }
  }
  for(i = 0; i < num_streamers; i++)
    streamers[i].pos_in_changer--;	/* start with 0 - index */

  if(changersp)
    *changersp = changers;
  if(num_changersp)
    *num_changersp = num_changers;
  if(streamersp)
    *streamersp = streamers;
  if(num_streamersp)
    *num_streamersp = num_streamers;

 cleanup:
  return(r);

 getout:
  for(i = 0; i < num_changers; i++)
    ZFREE(changers[i].changername);
  for(i = 0; i < num_streamers; i++)
    ZFREE(streamers[i].devicename);
  if(num_streamersp)
    *num_streamersp = num_streamers - 1;
  CLEANUPR(r);
}

UChar *
devices_from_confstr_strerr(Int32 errn)
{
  return(T_(budevconf_errors[-1 - errn]));
}

Int32
devices_from_confstr_msg(
  UChar			*string,
  StreamerDevice	**streamersp,
  Int32			*num_streamersp,
  ChangerDevice		**changersp,
  Int32			*num_changersp,
  FILE			*fp)
{
  Int32		r, nsp;
  UChar		*rawmsg, *msg, numbuf[32];

  r = devices_from_confstr(string, streamersp, &nsp, changersp, num_changersp);

  if(r){
    sprintf(numbuf, "%d", (int) nsp + 1);

    rawmsg = devices_from_confstr_strerr(r);

    msg = repl_substring(rawmsg, "%d", numbuf);

    fprintf(fp, "%s: %s\n", T_("Error"), msg ? msg : rawmsg);

    ZFREE(msg);
  }

  if(num_streamersp)
    *num_streamersp = nsp;

  return(r);
}

void
free_devices_and_changers(
  StreamerDevice	*streamers,
  Int32			num_streamers,
  ChangerDevice		*changers,
  Int32			num_changers)
{
  Int32		i;

  if(streamers){
    for(i = 0; i < num_streamers; i++)
      ZFREE(streamers[i].devicename);
    free(streamers);
  }
  if(changers){
    for(i = 0; i < num_changers; i++)
      ZFREE(changers[i].changername);
    free(streamers);
  }
}

UChar *
repl_dev_pats(UChar * str, UChar * streamer, UChar * changer)
{
  UChar		*cptr;

  if(streamer){
    str = repl_substring(str, "%d", streamer);
    if(!str)
	return(NULL);
  }
  if(changer){
    cptr = repl_substring(str, "%D", changer);
    if(streamer)
	free(str);
    str = cptr;
  }

  return(str);
}