client.c

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

	  scptr += max_inresultlen;
	  dcptr += new_max_inresultlen;
	  for(i = 1; i < upper_part_size; i++){
	    memmove(dcptr, scptr, new_max_inresultlen);
	    scptr += max_inresultlen;
	    dcptr += new_max_inresultlen;
	  }
	  i = upper_part_size * new_max_inresultlen;
	  dcptr = inbufmem + new_queuelen * new_max_inresultlen - i;
	  memmove(dcptr, mcptr, i);

	  memmove(queue_entries + queueent_done_idx + n,
		queue_entries + queueent_done_idx,
		sizeof(queue_entries[0]) * upper_part_size);
	}

	if(queueent_requested_idx >= queueent_done_idx)
	  queueent_requested_idx += n;
	if(queueent_processed_idx >= queueent_done_idx)
	  queueent_processed_idx += n;
	queueent_done_idx += n;
    }
  }

  max_outarglen = new_max_outarglen;
  max_inresultlen = new_max_inresultlen;
  queuelen = new_queuelen;
  queue_commbufsiz = newsize;

  return(0);
}

Int32
switch_queue_bufsiz(Int32 newsize)
{
  Int32		i;

  if(! queue_entries)		/* no queue currently present */
    return(0);

  if(newsize == queue_commbufsiz)
    return(0);

  if(newsize > queue_commbufsiz){
    ER__(change_queue_bufsiz(newsize), i);
  }
  else{
    queue_entries[queue_insert_idx].req_queue_cbs = newsize;
  }

  return(0);
}

Int32
alloc_commbuf(Int32 newsize)
{
  if(newsize > MAXCOMMBUFSIZ || newsize < 0)
    return(NO_VALID_COMMBUFSIZ);

  commbufsiz = newsize;

  return(scbuf ? 0 : -1);
}

Int32
set_commbufsiz(Int32 newsize)
{
  Int32		i;

  if(newsize > MAXCOMMBUFSIZ || newsize < 0)
    return(NO_VALID_COMMBUFSIZ);

  if(QUEUEDOP){
    i = switch_queue_bufsiz(newsize);
    if(i)
	return(i);
  }

  ER__(send_commbufsiz(newsize), i);

  return(alloc_commbuf(newsize));
}

#define	OPTIMIZER_CHUNKSIZE	5000000
#define	MIN_CBSDIFF		(MINCOMMBUFSIZ >> 1)

Int32				/* Albi's 3-walking-points optimizer */
try_optimize_throughput()	/* ("albimizer") */
{
  static Flag	meas_initialized = NO;
  static Real64	ratios[3];
  static Int32	cbs[3], actidx, chunksize, cbsdiff;
  static struct timeval	last_time;
  struct timeval	act_time;
  Real64	timediff, ratio;
  Int32		i, maxidx;

  if(!server_can_setcbufsiz)
    return(0);

  if(!meas_initialized){
    chunksize = queue_entries ? MAX(allocated_outmem, OPTIMIZER_CHUNKSIZE) : OPTIMIZER_CHUNKSIZE;

    gettimeofday(&last_time, NULL);

    cbs[0] = MINCOMMBUFSIZ;
    cbs[2] = MAXCOMMBUFSIZ;
    cbs[1] = (MINCOMMBUFSIZ + MAXCOMMBUFSIZ) / 2;
    cbsdiff = (MAXCOMMBUFSIZ - MINCOMMBUFSIZ) / 2;
    ratios[0] = ratios[1] = ratios[2] = -1.0;
    actidx = 0;

    bytes_transferred = 0;
    meas_initialized = YES;

    return(set_commbufsiz(cbs[actidx]));
  }

  if(bytes_transferred < chunksize)
	return(0);

  gettimeofday(&act_time, NULL);

  timediff = (Real64) act_time.tv_sec + ((Real64) act_time.tv_usec / 1.0e6)
	- ((Real64) last_time.tv_sec + ((Real64) last_time.tv_usec / 1.0e6));
  if(timediff < 0.0)
    timediff += 86400.0;

  COPYVAL(last_time, act_time);

  ratio = (Real64) bytes_transferred / timediff;

  bytes_transferred = 0;

  ratios[actidx] = ratio;

  if(ratios[0] < 0.0)
    actidx = 0;
  else if(ratios[1] < 0.0)
    actidx = 1;
  else if(ratios[2] < 0.0)
    actidx = 2;
  else
    actidx = -1;

  if(actidx >= 0)			/* still have unknown values */
    return(set_commbufsiz(cbs[actidx]));	/* go on measuring */

  maxidx = 0;
  if(ratios[1] > ratios[0])
    maxidx = 1;
  if(ratios[2] > ratios[maxidx])
    maxidx = 2;

  switch(maxidx){
    case 1:
	i = cbsdiff >> 1;
	if(i < MIN_CBSDIFF){
	  ratio = drandom();
	  actidx = 1;
	  if(ratio < 0.07){		/* curiosity kills the cat */
	    actidx = 0;
	  }
	  if(ratio > 0.93){
	    actidx = 2;
	  }
	}
	else{
	  cbsdiff = i;
	  ratios[0] = ratios[1] = ratios[2] = -1.0;
	  cbs[0] += cbsdiff;
	  cbs[2] -= cbsdiff;
	  actidx = 0;
	}

	break;

    case 0:
	actidx = 0;
	if(cbs[0] - cbsdiff < MINCOMMBUFSIZ){
	  i = cbsdiff >> 1;
	  if(i >= MIN_CBSDIFF){
	    cbsdiff = i;
	    if(cbs[0] - i < MINCOMMBUFSIZ){
		cbs[0] = MINCOMMBUFSIZ;
		cbs[1] = MINCOMMBUFSIZ + cbsdiff;
		cbs[2] = MINCOMMBUFSIZ + (cbsdiff << 1);
		ratios[0] = ratios[1] = ratios[2] = -1.0;
	    }
	    else{
		cbs[2] = cbs[1];
		cbs[1] = cbs[0];
		cbs[0] -= i;
		ratios[2] = ratios[1];
		ratios[1] = ratios[0];
	    }
	  }
	  else{
	    cbs[0] = MINCOMMBUFSIZ;
	    cbs[1] = MINCOMMBUFSIZ + MIN_CBSDIFF;
	    cbs[2] = MINCOMMBUFSIZ + (MIN_CBSDIFF << 1);
	    cbsdiff = MIN_CBSDIFF;
	    ratio = drandom();
	    if(ratio < 0.07)
		actidx = 1;
	    if(ratio < 0.005)
		actidx = 2;
	  }
	}
	else{
	    cbs[2] = cbs[1];
	    cbs[1] = cbs[0];
	    cbs[0] -= cbsdiff;
	    ratios[2] = ratios[1];
	    ratios[1] = ratios[0];
	}

	break;

     case 2:
	actidx = 2;
	if(cbs[2] + cbsdiff > MAXCOMMBUFSIZ){
	  i = cbsdiff >> 1;
	  if(i >= MIN_CBSDIFF){
	    cbsdiff = i;
	    if(cbs[2] + i > MAXCOMMBUFSIZ){
		cbs[2] = MAXCOMMBUFSIZ;
		cbs[1] = MAXCOMMBUFSIZ - cbsdiff;
		cbs[0] = MAXCOMMBUFSIZ - (cbsdiff << 1);
		ratios[0] = ratios[1] = ratios[2] = -1.0;
	    }
	    else{
		cbs[0] = cbs[1];
		cbs[1] = cbs[2];
		cbs[2] += i;
		ratios[0] = ratios[1];
		ratios[1] = ratios[2];
	    }
	  }
	  else{
	    cbs[2] = MAXCOMMBUFSIZ;
	    cbs[1] = MAXCOMMBUFSIZ - MIN_CBSDIFF;
	    cbs[0] = MAXCOMMBUFSIZ - (MIN_CBSDIFF << 1);
	    cbsdiff = MIN_CBSDIFF;
	    ratio = drandom();
	    if(ratio < 0.07)
		actidx = 1;
	    if(ratio < 0.005)
		actidx = 0;
	  }
	}
	else{
	    cbs[0] = cbs[1];
	    cbs[1] = cbs[2];
	    cbs[2] += cbsdiff;
	    ratios[0] = ratios[1];
	    ratios[1] = ratios[2];
	}

	break;
  }

  return(set_commbufsiz(cbs[actidx]));
}

Int32
send_svrmsg(int fromfd, int tofd, UChar * msg, Int32 len)
{
  Int32		i;
  UChar		lbuf[DEFCOMMBUFSIZ + 2];

  if(len > DEFCOMMBUFSIZ - 4)
    return(-1);

  Uns32_to_xref(lbuf + 1, len);
  memcpy(lbuf + 1 + 4, msg, len * sizeof(UChar));

  if(QUEUEDOP)
    return(append_to_queue(MESSAGETEXT, NULL, 0, lbuf + 1, 4 + len));

  lbuf[0] = MESSAGETEXT;

  i = 1 + 4 + len;
  if(write_forced(tofd, lbuf, i) != i)
    return(- errno);

  bytes_transferred += ESTIM_PROT_OVERHEAD + i;

  return(result());
}

UChar
send_buffer_to_server()
{
  Int32		i, num, r;
  UChar		*cptr;

  scbuf[0] = WRITETOTAPE;

  cptr = scbuf;
  num = commbufsiz + 1;

  if(savefile){
    cptr = cbuf;
    num = commbufsiz;

    i = write_forced(commfd, cptr, num);

    return(i < num ? - errno : 0);
  }

  filenum_valid = wrfilenum_valid = rdfilenum_valid = NO;

  if(QUEUEDOP){
    r = append_to_queue(WRITETOTAPE, NULL, 0, cbuf, commbufsiz);

    return(r);
  }

  if(write_forced(commfd, cptr, num) != num)
    return(- errno);

  bytes_transferred += ESTIM_PROT_OVERHEAD + num;

  r = result();

  return(r);
}

Int32
send_pending(Flag rawaccess)
{
  Int32		i, num_pad_bytes = 0;

  while(cbufptr > commbufsiz){
    ER__(send_buffer_to_server(), i);

    cbufptr -= commbufsiz;

    memcpy(cbuf, cbuf + commbufsiz, cbufptr);
  }

  if(cbufptr > 0){
    if(cbufptr < commbufsiz){
	num_pad_bytes = commbufsiz - cbufptr;
	memset(cbuf + cbufptr, 0, num_pad_bytes * sizeof(UChar));

	if(rawaccess)
	  setnumbytesvalid(cbufptr);
    }

    ER__(send_buffer_to_server(), i);
  }

  cbufptr = 0;

  if(!savefile && !rawaccess){
    memset(cbuf, 0, commbufsiz * sizeof(UChar));
    num_pad_bytes = MAXCOMMBUFSIZ - num_pad_bytes;

    /* This was on the server side previously, what is inaccurate. */
    /* The client should take care itself, that there is enough pad */
    /* space after the data to find the end of packing mark */
    for(; num_pad_bytes > 0; num_pad_bytes -= commbufsiz){
	ER__(send_buffer_to_server(), i);
    }
  }

  return(0);
}

Int32
send_to_server(UChar * buf, Int32 num)
{
  UChar		*cptr;
  Int32		j, n;

  if(num == 0)
    return(0);

  cptr = buf;

  forever{
    while(cbufptr > commbufsiz){
	ER__(send_buffer_to_server(), j);

	cbufptr -= commbufsiz;

	memcpy(cbuf, cbuf + commbufsiz, cbufptr);
    }

    if(cbufptr + num <= commbufsiz){
      memcpy(cbuf + cbufptr, cptr, num * sizeof(UChar));

      cbufptr += num;

      return(0);
    }

    n = commbufsiz - cbufptr;
    if(n > 0){
      memcpy(cbuf + cbufptr, cptr, n * sizeof(UChar));
    }

    ER__(send_buffer_to_server(), j);

    cptr += n;
    num -= n;

    cbufptr = 0;
  }

  return(0);
}

Int32
bu_output(UChar * buf, Int32 num, AarParams * params)
{
  if(savefile)
    return(send_to_server(buf, num));

  params->vars.bytes_saved += (Real64) num;

  try_optimize_throughput();

  bytes_wr_unkn_pos += num;		/* assuming write will succeed */
  if(bytes_wr_unkn_pos > MAX_NUM_WRITE_WITHOUT_POS_UPDATE){
    filenum_valid = wrfilenum_valid = rdfilenum_valid = NO;
					/* force a tape position update */
    getwrcartandfile(params);		/* from time to time to avoid */
    filenum = wrfilenum;			/* falling behind too far */
    cart = wrcart;
  }

  return(send_to_server(buf, num));
}

Int32
receive_buffer_from_server()
{
  Int32		i, j;

  filenum_valid = wrfilenum_valid = rdfilenum_valid = NO;

  if(QUEUEDOP){
    i = append_to_queue(READFROMTAPE, cbuf, commbufsiz, NULL, 0);

    j = post_process_rest_of_queue(0);

    return(i ? i : j);
  }

  if(!savefile){
    if( (i = send_cmd(READFROMTAPE)) )
      return(i);
  }

  if(read_forced(commfd, cbuf, commbufsiz) != commbufsiz)
    return(- errno);

  bytes_transferred += ESTIM_PROT_OVERHEAD + commbufsiz;

  return(result());
}

Int32
receive(UChar * buf, Int32 num, Int32 * num_read)
{
  static Int32	nbytes_in_inbuf = 0;
  static Flag	no_more_to_receive = NO;
  Int32		res, j;
  UChar		*cptr;

  if(num == 0){
    *num_read = 0;
    return(0);
  }

  cptr = buf;

  j = num;

  forever{
    if(cbufptr == 0){
	if(!endofrec){
	  res = receive_buffer_from_server();
	  no_more_to_receive = NO;
	}
	else{
	  no_more_to_receive = YES;
	  res = 0;
	}

	if(!res){
	  nbytes_in_inbuf = (no_more_to_receive ? 0 : commbufsiz);
	}
	else{
	  if(res < 0){
	    *num_read = num - j;
	    return(res);
	  }
	  else{
	    if(res == ENDOFFILEREACHED || res == ENDOFTAPEREACHED){
		getnumbytesvalid(&nbytes_in_inbuf);

		endofrec = 1;
	    }
	    else{
		*num_read = num - j;
		return(res);
	    }
	  }
	}
    }

    if(nbytes_in_inbuf - cbufptr <= j){
	if(cbufptr < nbytes_in_inbuf)
	  memcpy(cptr, cbuf + cbufptr, nbytes_in_inbuf - cbufptr);

	cptr += (nbytes_in_inbuf - cbufptr);
	j -= (nbytes_in_inbuf - cbufptr);
	cbufptr = 0;

	if(endofrec){
	  *num_read = num - j;
	  return(ENDOFFILEREACHED);
	}
	if(j == 0){