genutils.c

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

/****************** Start of $RCSfile: genutils.c,v $  ****************
*
* $Source: /home/alb/afbackup/afbackup-3.3.8.1/RCS/genutils.c,v $
* $Id: genutils.c,v 1.4 2004/07/08 20:34:45 alb Exp alb $
* $Date: 2004/07/08 20:34:45 $
* $Author: alb $
*
*
******* description ***********************************************
*
*
*
*******************************************************************/

#include <conf.h>
#include <version.h>

  static char * fileversion = "$RCSfile: genutils.c,v $ $Source: /home/alb/afbackup/afbackup-3.3.8.1/RCS/genutils.c,v $ $Id: genutils.c,v 1.4 2004/07/08 20:34:45 alb Exp alb $ " PACKAGE " " VERSION_STRING;

#include <stdio.h>
#include <string.h>
#include <errno.h>
#ifdef HAVE_MALLOC_H
#include <malloc.h>
#endif
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <unistd.h>
#include <sys/stat.h>
#include <math.h>
#include <mvals.h>
#include <fcntl.h>
#include <signal.h>
#ifdef HAVE_TERMIOS_H
# include <termios.h>
#else
# include <termio.h>
#endif
#include <genutils.h>
#include <x_data.h>
#include <fileutil.h>
#include <sys/types.h>
#include <time.h>

#define	GETOUT		{ goto getout; }
#define	CLEANUP		{ goto cleanup; }
#define	CLEANUPR(ret)	{ r = ret ; goto cleanup; }

static	char	*compiler_error = "Compiler problems. Call for maintainance\n";

static void
util_fatal(UChar * s)
{
    fprintf(stderr, "\n%s failed !\n", s);
    exit(-1);
}

Int32
FSEEK_SAFE(
    FILE	*fp,
    Int32	start,
    Int32	flag)
{ 
    Int32	val;		/* exit on failed fseek */

    if((val = fseek(fp, start, flag)) != 0)
	util_fatal("fseek");

    return(val);
}

void *
MALLOC_SAFE(Int32 nr)
{
    void	*ret;		/* exit on failed malloc */

    if((ret = (void *) malloc_forced(nr)) == NULL)
	util_fatal("malloc");

    return(ret);
}

void *
REALLOC_SAFE(void * old_ptr, Int32 nr)
{
    void	*ret;		/* exit on failed realloc */

    if((ret = (void *) realloc_forced((void *) old_ptr, nr)) == NULL)
	util_fatal("realloc");

    return(ret);
}

UChar *
STRDUP_SAFE(UChar * str)
{
    UChar	*ret;

    if((ret = strdup(str)) == NULL)
	util_fatal("strdup");

    return(ret);
}

Int32
empty_string(UChar * str)
{
  Int32	i, o;

  o = strlen(str);

  for(i = 0; i < o; i++)
    if(! isspace(str[i]))
      return(0);

  return(1);
}

void
nomemmsgexit(void * ptr, FILE * fp)
{
  if(!ptr){
    if(fp)
	fprintf(fp, T_("Error: Cannot allocate memory.\n"));
    exit(1);
  }
}

/*
 * Returns a pointer to the first non-whitespace character in string.
 * Returns NULL and sets errno on error.
 */

UChar *
first_nospace(UChar * string)
{
  if(!string){
    errno = EINVAL;
    return(NULL);
  }

  while(isspace(*string) && *string)
    string++;

  return(string);
}

UChar *
first_space(UChar * string)
{
  if(!string){
    errno = EINVAL;
    return(NULL);
  }

  while(!isspace(*string) && *string)
    string++;

  return(string);
}

Int32			/* look, if file "name" exists, */
existfile(UChar * name)		/* make sure, it's no directory */
				/* return 1, if ok, else 0 */
{		
    struct stat	stp;

    if(stat(name, &stp) != 0){
	if(errno == NO_SUCH_FILE)
	    errno = 0;
	return(0);
    }

    if(S_ISDIR(stp.st_mode))
	return(0);

    return(1);
}

FILE *
FOPEN_SAFE(
    UChar	*name,
    UChar	*mode)
{
    FILE	*fp;

    fp = fopen(name, mode);

    if(fp == NULL)
	util_fatal("fopen");

    return(fp);
}

#define	MEMSWAPMAXSIZE	512

Int32
memswap(		/* exchange values of miscallaneous */
  void	*var1,		/* types of variables */
  void	*var2,
  Int32	size)
{
  UChar	*ptr1, *ptr2, *tswapspace;
  UChar	memswapspace[MEMSWAPMAXSIZE];
  Int32	i;

  if(size < 0 || !var1 || !var2){
    errno = EINVAL;
    return(-1);
  }

  ptr1 = (UChar *) var1;
  ptr2 = (UChar *) var2;

  tswapspace = NEWP(UChar, size);

  if(tswapspace){
    memcpy(tswapspace, ptr1, size);
    memcpy(ptr1, ptr2, size);
    memcpy(ptr2, tswapspace, size);

    free(tswapspace);
  }
  else{
    while(size > 0){
	i = size > MEMSWAPMAXSIZE ? MEMSWAPMAXSIZE : size;

	memcpy(memswapspace, ptr1, i);
	memcpy(ptr1, ptr2, i);
	memcpy(ptr2, memswapspace, i);
	ptr1 += i;
	ptr2 += i;
	size -= i;
    }
  }

  return(0);
}

UChar *
memfind(UChar * mem1, Int32 len1, UChar * mem2, Int32 len2)
{
  UChar		*cptr1, *eptr, *cptr2, *cptr3;
  Int32	i;

  if(len2 > len1 || len2 == 0)
    return(NULL);

  eptr = mem1 + len1 - len2;
  len2--;
  for(cptr1 = mem1; cptr1 <= eptr; cptr1++){
    if(*cptr1 == *mem2){
      cptr2 = cptr1;
      cptr2++;
      cptr3 = mem2;
      cptr3++;
      for(i = len2; i; i--, cptr2++, cptr3++){
	if(*cptr2 != *cptr3)
	  break;
      }

      if(! i)
	return(cptr1);
    }
  }

  return(NULL);
}

#define	MEMMOVEBUFSIZE	512

void *
mem_move(void * vdest, void * vsrc, size_t n)
{
  UChar		buf[MEMMOVEBUFSIZE], *src, *dest;
  Int32		i;

  if(n < 0 || !vsrc || !vdest){
    errno = EINVAL;
    return(NULL);
  }

  if(vdest == vsrc)
    return(vdest);

  src = (UChar *) vsrc;
  dest = (UChar *) vdest;

  if(dest > src + n || src > dest + n){
    memcpy(dest, src, n);
    return(vdest);
  }

  if(dest > src){
    dest += n;
    src += n;

    while(n > 0){
	i = n > MEMMOVEBUFSIZE ? MEMMOVEBUFSIZE : n;

	src -= i;
	dest -= i;
	n -= i;

	memcpy(buf, src, i);
	memcpy(dest, buf, i);
    }
  }
  else{
    while(n > 0){
	i = n > MEMMOVEBUFSIZE ? MEMMOVEBUFSIZE : n;

	memcpy(buf, src, i);
	memcpy(dest, buf, i);
	n -= i;

	src += i;
	dest += i;
    }
  }

  return(vdest);
}

void *
mem_move2(void * vdest, void * vsrc, size_t n)
{
  UChar		buf[(MEMMOVEBUFSIZE << 3)], *src, *dest;
  Int32		i;

  if(n < 0 || !vsrc || !vdest){
    errno = EINVAL;
    return(NULL);
  }

  if(vdest == vsrc)
    return(vdest);

  src = (UChar *) vsrc;
  dest = (UChar *) vdest;

  if(dest > src + n || src > dest + n){
    memcpy(dest, src, n);
    return(vdest);
  }

  if(dest > src){
    dest += n;
    src += n;

    while(n > 0){
	i = n > (MEMMOVEBUFSIZE << 3) ? (MEMMOVEBUFSIZE << 3) : n;

	src -= i;
	dest -= i;
	n -= i;

	memcpy(buf, src, i);
	memcpy(dest, buf, i);
    }
  }
  else{
    while(n > 0){
	i = n > (MEMMOVEBUFSIZE << 3) ? (MEMMOVEBUFSIZE << 3) : n;

	memcpy(buf, src, i);
	memcpy(dest, buf, i);
	n -= i;

	src += i;
	dest += i;
    }
  }

  return(vdest);
}

void *
mem_move3(void * vdest, void * vsrc, size_t n)
{
  UChar		buf[(MEMMOVEBUFSIZE << 6)], *src, *dest;
  Int32		i;

  if(n < 0 || !vsrc || !vdest){
    errno = EINVAL;
    return(NULL);
  }

  if(vdest == vsrc)
    return(vdest);

  src = (UChar *) vsrc;
  dest = (UChar *) vdest;

  if(dest > src + n || src > dest + n){
    memcpy(dest, src, n);
    return(vdest);
  }

  if(dest > src){
    dest += n;
    src += n;

    while(n > 0){
	i = n > (MEMMOVEBUFSIZE << 6) ? (MEMMOVEBUFSIZE << 6) : n;

	src -= i;
	dest -= i;
	n -= i;

	memcpy(buf, src, i);
	memcpy(dest, buf, i);
    }
  }
  else{
    while(n > 0){
	i = n > (MEMMOVEBUFSIZE << 6) ? (MEMMOVEBUFSIZE << 6) : n;

	memcpy(buf, src, i);
	memcpy(dest, buf, i);
	n -= i;

	src += i;
	dest += i;
    }
  }

  return(vdest);
}

void *
mem_move4(void * vdest, void * vsrc, size_t n)
{
  UChar		buf[(MEMMOVEBUFSIZE << 9)], *src, *dest;
  Int32		i;

  if(n < 0 || !vsrc || !vdest){
    errno = EINVAL;
    return(NULL);
  }

  if(vdest == vsrc)
    return(vdest);

  src = (UChar *) vsrc;
  dest = (UChar *) vdest;

  if(dest > src + n || src > dest + n){
    memcpy(dest, src, n);
    return(vdest);
  }

  if(dest > src){
    dest += n;
    src += n;

    while(n > 0){
	i = n > (MEMMOVEBUFSIZE << 9) ? (MEMMOVEBUFSIZE << 9) : n;

	src -= i;
	dest -= i;
	n -= i;

	memcpy(buf, src, i);
	memcpy(dest, buf, i);
    }
  }
  else{
    while(n > 0){
	i = n > (MEMMOVEBUFSIZE << 9) ? (MEMMOVEBUFSIZE << 9) : n;

	memcpy(buf, src, i);
	memcpy(dest, buf, i);
	n -= i;

	src += i;
	dest += i;
    }
  }

  return(vdest);
}

void
repl_esc_seq(UChar * string, UChar escchar)
{
  UChar	*cptr1, *cptr2, c;
  Int32	i, n;

  for(cptr1 = cptr2 = string; *cptr1; cptr1++, cptr2++){
    if(*cptr1 == escchar){
      c = *(++cptr1);

      switch(c){
	case 'n':
	  *cptr2 = '\n';
	  break;
	case 't':
	  *cptr2 = '\t';
	  break;
	case 'a':
	  *cptr2 = '\a';
	  break;
	case 'b':
	  *cptr2 = '\b';
	  break;
	case 'r':
	  *cptr2 = '\r';
	  break;
	case 'f':
	  *cptr2 = '\f';
	  break;
	case 'v':
	  *cptr2 = '\v';
	  break;
	default:
	  if(c >= '0' && c <= '7'){
	    n = 0;
	    for(i = 0; i < 3; i++){
	      c = cptr1[i];
	      if(c < '0' || c > '7')
		break;

	      n = (n << 3) | (c - '0');
	    }

	    cptr1 += i - 1;

	    *cptr2 = (UChar) n;
	  }
	  else{
	    *cptr2 = *cptr1;

	    if(! *cptr2)
	      cptr1--;
	  }
      }
    }
    else{
      *cptr2 = *cptr1;
    }
  }

  *cptr2 = '\0';
}

Int32
rm_backspace(UChar * str)
{
  Int32		l;
  UChar		*cptr;

  if(!str)
    return(0);

  l = strlen(str);
  while((cptr = strchr(str + 1, '\b'))){
    memmove(cptr - 1, cptr + 1,
		(l /* + 1 */ - (cptr /* + 1 */ - str)) * sizeof(UChar));
    l -= 2;
  }

  return(0);
}

UChar *
mk_esc_seq(UChar * string, UChar escchar, UChar * ret_string)
{
  UChar	*new_string, *cptr, c, *strptr, r, obuf[5], *endp;
  Int32	len;

  len = strlen(string);
  strptr = string + len;

  if(!ret_string){
    new_string = NEWP(UChar, (len << 2) + 1);
    if(!new_string)
	return(NULL);
  }
  else
    new_string = ret_string;

  endp = cptr = new_string + (len << 2);
  *cptr = '\0';
  for(; len > 0; len--){
    c = *(--strptr);
    if(c == '\"' || c == escchar){
	*(--cptr) = c;
	*(--cptr) = escchar;
    }
    else{
	if(isprint(c) || ((c & 0x80) && (c & 0x60))){
	  *(--cptr) = c;
	}
	else{
	  r = '\0';

	  switch(c){
	   case '\n':
	    r = 'n';
	    break;
	   case '\t':
	    r = 't';
	    break;
	   case '\a':
	    r = 'a';
	    break;
	   case '\b':
	    r = 'b';
	    break;
	   case '\r':
	    r = 'r';
	    break;
	   case '\f':
	    r = 'f';
	    break;
	   case '\v':
	    r = 'v';
	    break;
	  }

	  if(r){
	    *(--cptr) = r;
	    *(--cptr) = escchar;
	  }
	  else{
	    cptr -= 2;
	    sprintf(obuf, "%03o", (int) c);
	    memcpy(--cptr, obuf, 3 * sizeof(UChar));
	    *(--cptr) = escchar;
	  }
	}
    }
  }

  len = endp - cptr;
  memmove(new_string, cptr, ++len);
  if(!ret_string)
    new_string = RENEWP(new_string, UChar, len);

  return(new_string);
}

Int32
memrepl(
  UChar		*buf,
  Int32		buflen,
  UChar		*repl,
  Int32		repllen,
  UChar		*new,
  Int32		newlen)
{
  UChar		*cptr, *cptr2, *cptr3, *eptr, *sptr;

  sptr = buf;
  while( (cptr = memfind(sptr, buflen - (sptr - buf), repl, repllen)) ){
    cptr += repllen;
    if(newlen > repllen){
	cptr2 = buf + buflen - 1;
	cptr3 = cptr2 + newlen - repllen;
	while(cptr2 >= cptr)
	  *(cptr3--) = *(cptr2--);
    }
    if(newlen < repllen){
	cptr3 = cptr;
	cptr2 = cptr3 + newlen - repllen;
	eptr = buf + buflen;
	while(cptr3 < eptr)
	  *(cptr2++) = *(cptr3++);
    }

    memcpy(cptr - repllen, new, newlen * sizeof(UChar));
    buflen += newlen - repllen;
    sptr = cptr - repllen + newlen;
  }

  return(buflen);
}

Int32
fscanword(
   FILE         *fp,
   UChar         *string)
{
   Int32  i = 0;
   UChar 	a;

   do{
        if(fread(&a, sizeof(UChar), 1, fp) < 1){
            fclose(fp);
            return((Int32) EOF);
        }
   } while(isspace(a));
   
   string[0] = a;

   do{
        i++;
        if(fread(&a, sizeof(UChar), 1, fp) < 1){
            fclose(fp);
            return((Int32) EOF);
        }
        string[i] = a;
   } while(!isspace(a));

   string[i] = '\0';

   return(NO_ERROR);
}

Int32
fscanwordq(FILE * fp, UChar * word)
{
  Flag	quoted = NO;
  Int32	numc;
  UChar	c;

  numc = 0;
  c = '\0';
  do{
    if(fread(&c, sizeof(UChar), 1, fp) < 1){
	if(word)
	  *word = '\0';

	return(EOF);
    }

    numc++;
  }while(isspace(c));

  forever{
    if(!c){
	if(fread(&c, sizeof(UChar), 1, fp) < 1)
	  break;
	numc++;
    }

    if(isspace(c) && !quoted)
	break;

    if(c == '\\'){
	if(fread(&c, sizeof(UChar), 1, fp) < 1)
	  break;
	numc++;

	if(word){
	  if(c != '\"')
	    *(word++) = '\\';
	  *(word++) = c;
	}
    }
    else{
	if(c == '\"'){
	  quoted = ! quoted;
	  c = '\0';
	  continue;
	}

	if(word){
	  *(word++) = c;
	}
    }
    c = '\0';
  }

  if(word)
    *word = '\0';

  return(numc);
}

UChar *
sscanword(
   UChar         *str,
   UChar         *word)
{
  Int32		i = 0, pos = 0;

  while(ISSPACE(str[pos])){
	if(str[pos] == '\0'){
	    if(word)
		word[0] = '\0';
	    return(NULL);
	}
	pos++;
  }

  while(!ISSPACE(str[pos])){
	if(word)
	  word[i] = str[pos];
	pos++;
	i++;
  }

  if(word)
    word[i] = '\0';

  return(str + pos);
}

/*
 * Scans the first argument <str> to locate the next word (a word is defined
 * as a sequence of non-whitespace characters, or a mixture of whitespace
 * and nonwhitespace delimited by a pair of double quotes (")).
 *
 * Returns a pointer to the first non-whitespace character following the 
 * first word.
 *
 * If the second argument, <word>, is non-NULL, then the scanned word
 * is copied into <word>.  (<word> is then '\0'-terminated).
 */

UChar *
sscanwordq(UChar * str, UChar * word)
{
  Flag	quoted = NO;

  if(!str){
    errno = EINVAL;
    return(NULL);
  }

  str = first_nospace(str);
  if(! *str)
    return(NULL);

  for(; *str && (!isspace(*str) || quoted); str++){
    if(*str == '\\'){
	str++;
	if(word){
	  if(*str != '\"' && *str)
	    *(word++) = '\\';
	  *(word++) = *str;