client.c

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

  if(write_forced(commfd, buf, 129) != 129)
    return(- errno);

  bytes_transferred += ESTIM_PROT_OVERHEAD + 129;

  return(result());
}

Int32
setnumbytesvalid(Int32 numbytes)
{
  UChar		buf[8];
  Int32		i;

  Uns32_to_xref(buf + 1, numbytes);

  if(QUEUEDOP){
    i = append_to_queue(SETNUMWRITEVALID, NULL, 0, buf + 1, 4);

    return(i);
  }

  buf[0] = SETNUMWRITEVALID;

  if(write_forced(commfd, buf, 5) != 5)
    return(- errno);

  bytes_transferred += ESTIM_PROT_OVERHEAD + 5;

  return(result());
}

Int32
skipfiles(Int32 numfiles)
{
  UChar		buf[8];
  Int32		i;

  filenum_valid = wrfilenum_valid = rdfilenum_valid = NO;

  buf[0] = SKIPFILES;
  Uns32_to_xref(buf + 1, numfiles & 0x7fffffff);
  
  reset_data_buffer;

  if(QUEUEDOP){
    i = append_to_queue(SKIPFILES, NULL, 0, buf + 1, 4);

    return(i);
  }

  if(write_forced(commfd, buf, 5) != 5)
    return(- errno);

  bytes_transferred += ESTIM_PROT_OVERHEAD + 5;

  return(result());
}

Int32
simple_command(UChar cmd)
{
  Int32		i;

  if(QUEUEDOP){
    i = append_to_queue(cmd, NULL, 0, NULL, 0);

    return(i);
  }

  if(write_forced(commfd, &cmd, 1) != 1)
    return(- errno);

  bytes_transferred += ESTIM_PROT_OVERHEAD + 1;

  return(result());
}

Int32
open_write(Int8 raw)
{
  Int32		i;
  UChar		cmd;

  filenum_valid = wrfilenum_valid = rdfilenum_valid = NO;

  cmd = (raw ? OPENFORRAWWRITE : OPENFORWRITE);

  endofrec = 0;

  reset_data_buffer;

  filenum = wrfilenum;
  cart = wrcart;

  if(QUEUEDOP)
    return(append_to_queue(cmd, NULL, 0, NULL, 0));

  reset_tape_io;

  bytes_wr_unkn_pos = 0;

  if( (i = send_cmd(cmd)) )
    return(i);

  return(result());
}

Int32
open_read(Int8 raw)
{
  Int32		i;
  UChar		cmd;

  filenum_valid = wrfilenum_valid = rdfilenum_valid = NO;

  cmd = (raw ? OPENFORRAWREAD : OPENFORREAD);

  endofrec = 0;

  reset_data_buffer;

  filenum = rdfilenum;
  cart = rdcart;

  if(QUEUEDOP)
    return(append_to_queue(cmd, NULL, 0, NULL, 0));

  reset_tape_io;

  if( (i = send_cmd(cmd)) )
    return(i);

  return(result());
}

Int32
closetape(Int8 rewind)
{
  Int32		i;
  UChar		cmd;

  cmd = (rewind ? CLOSETAPE : CLOSETAPEN);

  filenum_valid = wrfilenum_valid = rdfilenum_valid = NO;

  reset_data_buffer;

  if(QUEUEDOP){
    i = append_to_queue(cmd, NULL, 0, NULL, 0);

#if 0		/* don't waste time waiting for the tape */
    j = post_process_rest_of_queue(0);
#endif

    return(i);
  }

  reset_tape_io;

  if( (i = send_cmd(cmd)) )
    return(i);

  return(result());
}

Int32
request_newfile()
{
  Int32		i;

  filenum_valid = wrfilenum_valid = rdfilenum_valid = NO;

  if(QUEUEDOP)
    return(append_to_queue(REQUESTNEWFILE, NULL, 0, NULL, 0));

  if( (i = send_cmd(REQUESTNEWFILE)) )
    return(i);

  return(result());
}

Int32
request_newcart()
{
  Int32		i;

  filenum_valid = wrfilenum_valid = rdfilenum_valid = NO;

  if(QUEUEDOP)
    return(append_to_queue(REQUESTNEWCART, NULL, 0, NULL, 0));

  if( (i = send_cmd(REQUESTNEWCART)) )
    return(i);

  return(result());
}

Int32
erasetape()
{
  Int32		i;
  UChar		cmd;

  cmd = ERASETAPE;

  if(QUEUEDOP){
    i = append_to_queue(cmd, NULL, 0, NULL, 0);

    return(i);
  }

  if( (i = send_cmd(cmd)) )
    return(i);

  return(result());
}

UChar *
fault_string(Int32 code)
{
  Int32		i, sz;

  if(!code)
    return("");

  sz = sizeof(fault_messages) / sizeof(fault_messages[0]);

  for(i = 0; i < sz; i++){
    if(code == (Int32) fault_messages[i].code)
	return(fault_messages[i].msg);
  }

  return(T_("unknown fault"));
}


Int32
close_connection()
{
  Int32		i, j;

  filenum_valid = wrfilenum_valid = rdfilenum_valid = NO;

  reset_data_buffer;

  if(QUEUEDOP){
    i = append_to_queue(GOODBYE, NULL, 0, NULL, 0);

    j = post_process_rest_of_queue(0);

    return(i ? i : j);
  }

  if( (i = send_cmd(GOODBYE)) )
    return(i);

  return(result());
}

Int32
request_client_backup(UChar * cmdname)
{
  Int32		i;
  Uns32		n;
  UChar		*buf, lenstr[5], exitst, *cptr, *cptr2;

  n = strlen(cmdname);

  if(n == 0){
    errmsg(T_("Warning: Empty command supplied. Nothing happens"));
    return(0);
  }

  buf = strapp("...", cmdname);
  if(!buf)
    return(-errno);
  buf[0] = CLIENTBACKUP;
  buf[1] = n % 251;
  buf[2] = 1;		/* suppress output if queued */

  if(QUEUEDOP){
    i = append_to_queue(CLIENTBACKUP, cbuf, 5, buf + 1, n + 2);

    free(buf);

    return(i);
  }

  buf[2] = 0;
  i = n + 3;
  i = (write_forced(commfd, buf, i) != i);
  free(buf);

  bytes_transferred += ESTIM_PROT_OVERHEAD + i;

  if(i)
    return(i);

  if(read_forced(commfd, lenstr, 5) != 5)
    return(- errno);

  bytes_transferred += ESTIM_PROT_OVERHEAD + 5;

  exitst = lenstr[0];
  xref_to_Uns32(&n, lenstr + 1);

  buf = NEWP(UChar, n + 1);
  if(!buf){
    errmsg("Error: No memory, where absolutely needed");
  }

  if(read_forced(commfd, buf, n) != n)
    return(- errno);
  buf[n] = '\0';

  bytes_transferred += ESTIM_PROT_OVERHEAD + n;

  if(n > 0){
    cptr = buf;
    forever{
	if(!(*cptr))
	  break;
	cptr2 = strchr(cptr, '\n');
	if(cptr2)
	  *cptr2 = '\0';
	if(c_f_verbose)
	  fprintf(stdout, "%s: ", servername);

	fprintf(stdout, "%s\n", cptr);
	if(cptr2)
	  cptr = cptr2 + 1;
	else
	  break;
    }
  }
  free(buf);

  if(n < 1 && exitst){
    fprintf(stderr,
	T_(">>> Remote process exited with status %d, but produced no output.\n"),
	exitst);
  }

  return(result() | (exitst << 16));
}

Int32
get_message(UChar ** retmsg)
{
  Int32		i, n;
  UChar		c, *msgbuf = NULL, nbuf[4];

  c = GETCURMSG;
  if(write_forced(commfd, &c, 1) != 1)
    return(- errno);

  if(read_forced(commfd, nbuf, 4) != 4)
    return(- errno);

  xref_to_Uns32(&n, nbuf);
  msgbuf = NEWP(UChar, n + 1);
  if(!msgbuf)
    return(- errno);

  i = read_forced(commfd, msgbuf, n);
  if(i < 0)
	return(- errno);

  msgbuf[i] = '\0';

  *retmsg = msgbuf;

  return(result());
}

Int32
poll_messages()
{
  UChar		*msg, *cptr, *cptr2;
  time_t	msgtime, servertime, starttime;

  starttime = UNSPECIFIED_TIME;

  forever{
    while(!get_message(&msg)){
	cptr = strchr(msg, '\n');
	cptr2 = NULL;
	if(cptr)
	  cptr2 = strchr(++cptr, '\n');
	if(cptr2){
	  msgtime = strint2time(msg);
	  servertime = strint2time(cptr);

	  if(starttime == UNSPECIFIED_TIME){
	    starttime = servertime;
	  }

	  if(msgtime != UNSPECIFIED_TIME
			&& servertime != UNSPECIFIED_TIME
			&& msgtime >= starttime){
	    fprintf(stdout, "%s", ++cptr2);
	    fflush(stdout);

	    starttime = msgtime + 1;
	  }
	}

	free(msg);
	ms_sleep(bu_msg_itv * 1000);
    }
    ms_sleep(bu_msg_itv * 1000);
  }

  return(0);
}

UChar **
get_file_list(FILE * fp)
{
  UChar		*line;
  UChar		**filelist = NULL;
  Int32		num_files = 0;

  while(!feof(fp)){
    line = fget_alloc_str(fp);
    if(!line)
	continue;
    chop(line);

    filelist = ZRENEWP(filelist, UChar *, num_files + 2);
    if(!filelist){
	errmsg("Error: memory exhausted by the list of files");
	exit(54);
    }

    filelist[num_files] = line;
    num_files++;
    filelist[num_files] = NULL;
  }

  return(filelist);
}

void
pre_extended_verbose(UChar * str, AarParams * params)
{
  if(! savefile){
    if(bu_create){
	E__(getwrcartandfile(params));
	filenum = wrfilenum;
	cart = wrcart;
    }
    else{
	if(server_can_sendrdpos){
	  E__(getrdcartandfile(params));
	  filenum = rdfilenum;
	  cart = rdcart;
	}
	else{
	  E__(getcartandfile(params));
	  rdfilenum = filenum;	/* for backward compatibility. In open_read */
	  rdcart = cart;	/* rdxxxx must be set correctly */
	}
    }

    params->vars.actfile = filenum;
    params->vars.actcart = cart;
  }
}

void
extended_verbose(UChar * str, AarParams * params)
{
  static UChar	*lstr = NULL;	/* not multithreading safe */
  static Int32	nall = 0;

  FILE		*fp;
  UChar		mtimestr[30];
  Int32		l;

  fp = ((params->mode == MODE_CREATE && save_stdio) ?
			params->errfp : params->outfp);

  if(verbose){
    if(verbose & VERBOSE_LOCATION)
	fprintf(fp, "%s%s%d%s", servername, PORTSEP, (int) portnum, LOCSEP);

    if(verbose & VERBOSE_CART_FILE)
	fprintf(fp, "%d.%d", (int) params->vars.actcart,
			(int) params->vars.actfile);

    if(verbose & VERBOSE_UID)
	fprintf(fp, UIDSEP "%d", (int) params->vars.uid);

    if(verbose & VERBOSE_MTIME){
	time_t_to_intstr(params->vars.mtime, mtimestr);
	fprintf(fp, MTIMESEP "%s", mtimestr);
    }

    fprintf(fp, ": ");
  }

  l = strlen(str) + 1;
  if(l > nall)
    lstr = ZRENEWP(lstr, UChar, nall = l);
  if(!lstr){
    errmsg("Error: No memory, where absolutely needed");
    return;
  }

  strcpy(lstr, str);
  rm_backspace(lstr);

  fprintf(fp, "%s", lstr);
}

void
normal_verbose(UChar * str, AarParams * params)
{
  static UChar	*lstr = NULL;	/* not multithreading safe */
  static Int32	nall = 0;

  FILE		*fp;
  Int32		l;

  l = strlen(str) + 1;