server.c

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

  if(!insfilenum || !inscart)
    EM__(NULL);
  memset(inscart, 0, num_cartsets * sizeof(Int32));
  memset(insfilenum, 0, num_cartsets * sizeof(Int32));

  if(cartsetstr){
    EM__(cartridge_sets = NEWP(Uns32Range *, num_cartsets + 1));
    EM__(cartset_clients = NEWP(UChar *, num_cartsets + 1));
    memset(cartset_clients, 0, sizeof(UChar *) * (num_cartsets + 1));

    for(i = 0; i < num_cartsets; i++){
	EM__(cptr = strwordq(cartsetstr, i));

	EM__(cartridge_sets[i] = sscan_Uns32Ranges(cptr, 1, num_cartridges,
				NULL, &cptr2));
	EM__(cartset_clients[i] = strdup(*cptr2 == ':' ?
					cptr2 + 1 : (UChar *) ""));
	  
	free(cptr);
    }
  }
  else if(endcarts){
    free_array((UChar **) cartridge_sets, 0);

    EM__(cartridge_sets = NEWP(Uns32Range *, num_cartsets + 1));

    for(i = 0; i < num_cartsets; i++){	/* and set up some arrays */
      insfilenum[i] = 1;

      EM__(cartridge_sets[i] = add_to_Uns32Ranges(NULL, 1, endcarts[i]));

      for(j = 0; j < num_cartsets; j++){
	if(endcarts[j] < endcarts[i] &&
			cartridge_sets[i][0].first < endcarts[j] + 1)
	  cartridge_sets[i][0].first = endcarts[j] + 1;
      }

      inscart[i] = cartridge_sets[i][0].first;
    }
  }
  cartridge_sets[num_cartsets] = NULL;
  for(i = 0; i < num_cartsets - 1; i++){
    for(j = i + 1; j < num_cartsets; j++){
      if(overlap_Uns32Ranges(cartridge_sets[i], cartridge_sets[j])){
	logmsg(LOG_ERR, T_("Error: Cartridge sets %d and %d have common cartridges.\n"),
					i + 1, j + 1);
	r = CONFIG_ERROR;
      }
    }
  }

  bytesontape_file = strapp(vardir, FN_DIRSEPSTR BYTESONTAPE_FILE);
  pref_client_file = strapp(vardir, FN_DIRSEPSTR PREFCLIENT_FILE);
  precious_tapes_file = strapp(vardir, FN_DIRSEPSTR PRECIOUS_TAPES_FILE);
  ro_tapes_file = strapp(vardir, FN_DIRSEPSTR READONLY_TAPES_FILE);
  cartorder_file = strapp(vardir, FN_DIRSEPSTR CARTRIDGE_ORDER_FILE);
  tape_usage_file = strapp(vardir, FN_DIRSEPSTR TAPE_USAGE_FILE);
  used_blocksizes_file = strapp(vardir, FN_DIRSEPSTR USED_BLOCKSIZES_FILE);
  client_message_file = strapp(vardir, FN_DIRSEPSTR CLIENT_MESSAGE_FILE);

  EEM__(put_in_sh(&setfilecmd));
  EEM__(put_in_sh(&skipfilescmd));
  if(erasetapecmd){
    EEM__(put_in_sh(&erasetapecmd));
  }
  if(initmediacmd){
    EEM__(put_in_sh(&initmediacmd));
  }
  EEM__(put_in_sh(&nextcartcmd));

  EEM__(put_in_sh(&weofcmd));

  if(setcartcmd){
    EEM__(put_in_sh(&setcartcmd));
  }

  if(tapefullcmd){
    cptr = tapefullcmd;
    EM__(tapefullcmd = repl_substring(tapefullcmd, "%C", configfilename));
    free(cptr);
    EEM__(put_in_sh(&tapefullcmd));
  }

  cptr = mail_program;
  mail_program = repl_substring(mail_program, "%u", user_to_inform);
  free(cptr);
  EEM__(put_in_sh(&mail_program));

  if(!setfilecmd || !nextcartcmd || !mail_program || !weofcmd || !statusfile
	|| !bytesontape_file || !precious_tapes_file || !ro_tapes_file
	|| !pref_client_file || !cartorder_file || ! tape_usage_file
	|| !used_blocksizes_file || !client_message_file || !skipfilescmd){
    EM__(NULL);
  }

  if(!strncmp(statusfile, ">>", 2)){
    memmove(statusfile, statusfile + 2, strlen(statusfile) - 1);
    massage_string(statusfile);
    statusf_append = YES;
  }

  if(streamerbuf_confstr){
    EM__(cptr = strdup(streamerbuf_confstr));
    cptr2 = cptr;
    i = 0;
    while( (cptr2 = sscanwordq(cptr2, cptr)) ){
	i1 = -1;
	sscanf(cptr, "%lf%n", &d1, &i1);
	if(i1 == strlen(cptr)){
	  switch(i){
	   case 0:
		streamerbuf_conf_size = (Uns32) d1;
		break;
	   case 1:
		streamerbuf_conf_highmark = d1;
		break;
	   case 2:
		streamerbuf_conf_lowmark = d1;
		break;
	   default:
		logmsg(LOG_WARNING,
			T_("Warning: Unrecognized parameter in streamer buffer configuration."));
	  }
	  i++;
	}
	else{
	  if(streamerbuf_memfile){
	    logmsg(LOG_WARNING,
			T_("Warning: Unrecognized parameter in streamer buffer configuration."));
	  }
	  else{
	    EM__(streamerbuf_memfile = strdup(cptr));
	    EEM__(repl_dirs(&streamerbuf_memfile));
	  }
	}
    }
    free(cptr);
  }

  if(nobuffering)
    streamermode &= ~BUFFERED_OPERATION;

  if(!reconfig){
    tapeblocksize = conf_tapeblocksize;
    EM__(tapebuffer = ZRENEWP(tapebuffer, UChar, tapeblocksize + 2));
  }

  set_commbufsiz(commbufsiz);

  infobuffersize = align_n(INFOBLOCKSIZE, tapeblocksize);
  EM__(infobuffer = NEWP(UChar, infobuffersize));
  memset(infobuffer, 0, sizeof(UChar) * infobuffersize);

  if(lfd >= 0 && lfd != 2)
    close(lfd);

  if(loggingfile){
    if(loggingfile[0] == '@'){
	if(isspace(loggingfile[1]) || !loggingfile[1])
	  syslog_ident = strdup(PACKAGE);
	else
	  syslog_ident = strword(loggingfile + 1, 0);

	EM__(syslog_ident);

	cptr = first_nospace(first_space(loggingfile));
	memmove(loggingfile, cptr, strlen(cptr) + 1);
	if(empty_string(loggingfile))
	  ZFREE(loggingfile);
    }
  }

  cptr = loggingfile;
  if(!cptr)
    cptr = NULLFILE;
  if(access(cptr, W_OK))
    cptr = NULLFILE;
  lfd = open(cptr, O_APPEND | O_CREAT | O_WRONLY, 0644);
  if(lfd < 0)
    lfd = 2;
  else{
    if(!slavemode)
	dup2(lfd, 1);
    dup2(lfd, 2);
  }

  if(maxbytes_per_file < tapeblocksize){
    logmsg(LOG_INFO, T_("Warning: Maximum filesize must be at least one tape block. "
			"Reset to %d.\n"), tapeblocksize);
    maxbytes_per_file = tapeblocksize;
  }

  if(maxbytes_per_tape_str){
    Real64	default_bytes_per_tape = -1.0;
    double	d1;
    int		i1;

    EM__(maxbytes_per_tape = NEWP(Real64, num_cartridges));

    for(i = 0; i < num_cartridges; i++)
	maxbytes_per_tape[i] = -1.0;

    cptr = maxbytes_per_tape_str;
    while(cptr){
	if(!*cptr)
	  break;

	i = sscanf(cptr, "%lf%n", &d1, &i1);
	if(i < 1){
	  logmsg(LOG_NOTICE, T_("Warning: (MaxBytesPerTape): Entry not recognized, ignored.\n"));
	  break;
	}

	cptr2 = first_nospace(cptr + i1);

	if(*cptr2 && !isdigit(*cptr2)){
	  Uns32Range	*ranges;

	  ranges = sscan_Uns32Ranges(cptr, 1, num_cartridges, &i, &cptr2);
	  if(! ranges || i < 1 || *cptr2 != ':'
				|| sscanf(cptr2 + 1, "%lf%n", &d1, &i1) < 1){
		logmsg(LOG_NOTICE, T_("Warning: (MaxBytesPerTape): Entry not recognized, ignored.\n"));
		free(ranges);
		cptr = cptr2;
		continue;
	  }

	  cptr = cptr2 + 1 + i1;
	  for(i--; i >= 0; i--){
		for(j = ranges[i].first; j <= ranges[i].last; j++){
		  if(j < 1){
		    logmsg(LOG_NOTICE, T_("Warning: (MaxBytesPerTape): First cartridge number too low, starting with 1.\n"));
		    j = 0;
		    continue;
		  }
		  if(j > num_cartridges){
		    logmsg(LOG_NOTICE, T_("Warning: (MaxBytesPerTape): First cartridge number too high, stopping at %d.\n"),
					num_cartridges);
		    break;
		  }

		  maxbytes_per_tape[j - 1] = (Real64) d1;
		}
	  }

	  free(ranges);
	}
	else{
	  default_bytes_per_tape = d1;
	  cptr = cptr2;
	}
    }

    i1 = 0;
    for(i = 0; i < num_cartridges; i++){
	if(maxbytes_per_tape[i] < 0.0)
	  maxbytes_per_tape[i] = default_bytes_per_tape;
	else
	  i1 = 1;
    }

    if(!i1 && default_bytes_per_tape < 0.0){
	ZFREE(maxbytes_per_tape);
	ZFREE(maxbytes_per_tape_str);
    }
  }

  /* read the file containing the current position: # of cartridge and file */
  if(read_tapepos_file()){
    logmsg(LOG_NOTICE, T_("Warning: No tape-state file found. Assuming initial startup with first cartridge in set.\n"));

    write_tapepos_file_msg();
  }


  return(r);
}

void
statusmsg(UChar * fmt, ...)
{
  static UChar	logged_err = 0;
  FILE		*fp;
  Int32		i;
  va_list	args;

  if(!statusfile)
    return;

  if(!statusf_append){
    i = unlink(statusfile);
    if(i && errno && errno != ENOENT){
      if(!logged_err){
	logmsg(LOG_ERR, T_("Error: Status file `%s' cannot be removed. Status report disabled.\n"),
				statusfile);
	logged_err = 1;
      }

      return;
    }
  }

  fp = fopen(statusfile, statusf_append ? "a" : "w");
  if(!fp){
    if(!logged_err){
	logmsg(LOG_ERR, T_("Error: Status file `%s' cannot be written. Status report disabled.\n"),
				statusfile);
	logged_err = 1;
    }

    return;
  }

  va_start(args, fmt);

  fprintf(fp, "%s [%d], ", actimestr(), (int) getpid());
  vfprintf(fp, fmt, args);

  va_end(args);

  fclose(fp);
}

static void
send_status(UChar statusc)	/* utility */
{
  write_forced(commwfd, &statusc, 1);
}

void
command_failed(UChar cmd, UChar * str)
{
  logmsg(LOG_ERR, T_("Error: Command %d ('%c') failed (%s)\n"), cmd, cmd, str);
}

void
prot_error(UChar * str, Int32 num)
{
  UChar	buf[100];

  sprintf(buf, str, num);
  logmsg(LOG_ERR, T_("%s, Protocol Error: %s\n"), actimestr(), buf);

  send_status(PROTOCOL_ERROR);
}

void
command_error(UChar * str)
{
  logmsg(LOG_ERR, T_("Command Error: %s.\n"), str);
}

Int32
cartset_of_cart(Int32 cart)
{
  Int32	i;

  for(i = 0; i < num_cartsets; i++)
    if(in_Uns32Ranges(cartridge_sets[i], cart))
	return(i);

  logmsg(LOG_NOTICE, T_("Warning: Cartridge %d is not in any cartridge set. Assuming current set %d\n"),
			(int) cart, (int) active_cartset + 1);

  return(active_cartset);
}

Int32
host_in_list_msg(UChar * host, UChar * list)
{
  Int32	r;

  r = host_in_list(host, list);
  if(r < 0)
    logmsg(LOG_ERR, T_("Error: Unable to determine, whether client has access. Most recent system error: %s\n"),
			strerror(errno));

  return(r);
}

Int32
host_permitted(UChar * remotehost, Int32 cartridge)
{
  Int32	i;

  if(slavemode)		/* can't check in slavemode, cause we don't */
    return(0);		/* have direct connection to the client(s) */

  if(!cartset_clients)	/* default, if not configured: access granted */
    return(0);

  i = cartset_of_cart(cartridge);
  if(host_in_list_msg(remotehost, cartset_clients[i]) <= 0){
    logmsg(LOG_CRIT, T_("Warning: Client %s tried to access cartridge set %d, denied.\n"),
					remotehost, (int) i + 1);
    return((Int32) CARTSET_EACCESS);
  }

  return(0);
}

void
add_to_written_tapes(Int32 cart)
{
  EM__(written_tapes = add_to_Uns32Ranges(written_tapes, cart, cart));

  pack_Uns32Ranges(written_tapes, NULL);
}

Int32
wait_for_flag_file()
{
  int		fd;
  struct stat	statb;

  fd = open(CARTREADY_FILE, O_CREAT | O_WRONLY, 0600);
  if(fd < 0){
    logmsg(LOG_ERR, T_("Error: Cannot create flag file `%s' to wait for cartridge ready"),
			CARTREADY_FILE);
    do_exit(13);
  }
  close(fd);

  while(!stat(CARTREADY_FILE, &statb)){
    ms_sleep(1000);

    if(check_interrupted())
	  do_exit(1);
  }

  return(0);
}

Int32
set_storefile()
{
  UChar		buf[20];
  Int32		file_to_set;

  if(actfilenum <= 0)	/* can only happen, if uninitialized */
    file_to_set = 0;	/* in this case we point to the label */
  else
    file_to_set = actfilenum - 1 + (have_infobuffer ? 1 : 0);
  sprintf(buf, "%d", (int) file_to_set);

  ZFREE(storefile);
  storefile = strchain(devicename, "/data.", buf, NULL);

  if(!storefile)
    return(FATAL_ERROR);

  return(0);
}

Int32				/* take tape offline, unload */
change_cartridge(Flag wait_success, Int32 next_cart, Flag for_writing)
{
  Int32		i;
  UChar		*cmd = NULL, *cptr = NULL;
  UChar		nbuf[20];

  sprintf(nbuf, "%d", (int) actcart);
  if( (cptr = repl_substring(nextcartcmd, "%c", nbuf)) ){
    sprintf(nbuf, "%d", (int) actcart - 1);
    cmd = repl_substring(cptr, "%b", nbuf);
    ZFREE(cptr);

    if(cmd && next_cart > 0){
      sprintf(nbuf, "%d", (int) next_cart);
      cptr = cmd;
      cmd = repl_substring(cmd, "%n", nbuf);
      ZFREE(cptr);

      if(cmd){
	sprintf(nbuf, "%d", (int) next_cart - 1);
	cptr = cmd;
	cmd = repl_substring(cmd, "%m", nbuf);
	ZFREE(cptr);

	if(cmd){
	  sprintf(nbuf, "%d", (int) num_cartridges);
	  cptr = cmd;
	  cmd = repl_substring(cmd, "%N", nbuf);
	  ZFREE(cptr);

	  if(cmd){
	    cptr = cmd;
	    cmd = repl_dev_pats(cmd, devicename, changername);
	    ZFREE(cptr);
	  }
	}
      }
    }
  }

  if(!cmd){
    logmsg(LOG_WARNING, T_("Warning: Could not replace %-mark in change cartridge command, leaving it unmodified.\n"));
  }

  i = wait_for_service(for_writing ? LOCK_WRITE : LOCK_READ, NO);
  if(i)
    return(i);

  i = poll_device_cmd(cmd ? cmd : nextcartcmd, wait_success, 0);

  have_infobuffer = NO;
  tried_infobuffer = NO;

  tape_rewound = NO;
  tape_moved = YES;

  media_initialized = NO;

  filenum_incr_by_eof = NO;

  ZFREE(cmd);

  return(i);
}

Int32
wait_for_device(Int8 lock_mode, Flag quiet)
{
  int		fd, i, st;
  time_t	t, t_mail, t_giveup;
  FILE		*fp;

  i = wait_for_service(lock_mode, quiet);
  if(i)
    return(i);

  initmedia();

  fd = -1;
  st = stat(devicename, &devstatb);
  if(!st && !IS_DIRECTORY(devstatb)){