sysutils.c

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

/****************** Start of $RCSfile: sysutils.c,v $  ****************
*
* $Source: /home/alb/afbackup/afbackup-3.3.8.1/RCS/sysutils.c,v $
* $Id: sysutils.c,v 1.7 2005/01/24 18:58:10 alb Exp alb $
* $Date: 2005/01/24 18:58:10 $
* $Author: alb $
*
*
******* description ***********************************************
*
*
*
*******************************************************************/

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

  static char * fileversion = "$RCSfile: sysutils.c,v $ $Source: /home/alb/afbackup/afbackup-3.3.8.1/RCS/sysutils.c,v $ $Id: sysutils.c,v 1.7 2005/01/24 18:58:10 alb Exp alb $ " PACKAGE " " VERSION_STRING;

#include <stdio.h>
#include <unistd.h>
#include <stdarg.h>
#include <x_defs.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/un.h>
#ifdef	HAVE_SYS_TIME_H
#include <sys/time.h>
#endif
#ifdef  HAVE_SYS_VFS_H
#include <sys/vfs.h>
#endif
#ifdef	HAVE_SYS_STATVFS_H
#include <sys/statvfs.h>
#endif
#ifdef  HAVE_SYS_STATFS_H
#include <sys/statfs.h>
#endif
#ifdef	HAVE_SYS_FS_TYPES_H
#include <sys/fs_types.h>
#endif
#include <sys/stat.h>
#ifdef	HAVE_MNTENT_H
#include <mntent.h>
#endif
#ifdef	HAVE_TIME_H
#ifdef	TIME_WITH_SYS_TIME
#include <time.h>
#endif
#endif
#ifndef HAVE_TERMIOS_H
# include <termio.h>
#else
# include <termios.h>
#endif /* HAVE_TERMIOS_H */
#ifdef	HAVE_SYS_PARAM_H
#include <sys/param.h>
#endif
#ifdef	HAVE_SYS_UCRED_H
#include <sys/ucred.h>
#endif
#ifdef	HAVE_SYS_MOUNT_H
#include <sys/mount.h>
#endif
#ifdef	HAVE_SYS_VMOUNT_H
#include <sys/vmount.h>
#endif
#ifdef	HAVE_SYS_MNTCTL_H
#include <sys/mntctl.h>
#endif
#ifdef	HAVE_SYS_MNTTAB_H
#include <sys/mnttab.h>
#endif
#include <syslog.h>
#include <signal.h>
#include <grp.h>

#include <sysutils.h>
#include <fileutil.h>

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

#ifndef	HAVE_STRERROR
#include <errno.h>

#ifndef	HAVE_SYS_ERRLIST_DEF
extern	char *sys_errlist[];
#endif

char *
strerror(int no)
{
  return(sys_errlist[no]);

#if 0
  static char	*msg = "Unknown error (no sys_errlist available)";
  return(msg);
#endif
}

#endif

#ifndef	HAVE_SETITIMER
#include <errno.h>

static Timer	rtimer = -1;

int
setitimer(
    int			which,
    struct itimerval	*timeval,
    struct itimerval	*otimeval)
{
    struct Signal_Event	evp;
    struct itimerval	timer_value, old_timer_value, *timer_ptr, *old_timer_ptr;

    if(which != ITIMER_REAL)
	return(EINVAL);

    if(rtimer == -1){
	evp.sigev_signum = SIGALRM;

	rtimer = timer_make(CLOCK_TYPE_REALTIME, &evp);
	if(rtimer == -1)
	    return(-1);
    }

    timer_ptr = NULL;

    if(timeval){
	timer_value.it_value.tv_sec = timeval->it_value.tv_sec;
	timer_value.it_value.tv_usec = timeval->it_value.tv_usec;
	timer_value.it_interval.tv_sec = timeval->it_interval.tv_sec;
	timer_value.it_interval.tv_usec = timeval->it_interval.tv_usec;

	timer_ptr = &timer_value;
    }

    old_timer_ptr = (otimeval ? &old_timer_value : NULL);

    if(timer_set(rtimer, 0, timer_ptr, old_timer_ptr) != 0)
	return(-1);

    if(otimeval){
	otimeval->it_value.tv_sec = old_timer_value.it_value.tv_sec;
	otimeval->it_value.tv_usec = old_timer_value.it_value.tv_usec;
	otimeval->it_interval.tv_sec = old_timer_value.it_interval.tv_sec;
	otimeval->it_interval.tv_usec = old_timer_value.it_interval.tv_usec;
    }

    return(0);
}

int
getitimer(
    int			which,
    struct itimerval	*timeval)
{
    struct Signal_Event	evp;
    struct itimerval	timer_value;

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

    if(!timeval)
	return(0);

    if(rtimer == -1){
	evp.sigev_signum = SIGALRM;

	rtimer = timer_make(CLOCK_REALTIME, &evp);
	if(rtimer != -1)
	    return(-1);
    }

    if(timer_get(rtimer, &timer_value) != 0)
	return(-1);

    if(timeval){
	timeval->it_value.tv_sec = timer_value.it_value.tv_sec;
	timeval->it_value.tv_usec = timer_value.it_value.tv_usec;
	timeval->it_interval.tv_sec = timer_value.it_interval.tv_sec;
	timeval->it_interval.tv_usec = timer_value.it_interval.tv_usec;
    }

    return(0);
}

#endif	/* !defined(HAVE_SETITIMER) */


#include <genutils.h>
#include <x_timer.h>
#include <errno.h>

#define	STOP_TIMERS	setitimer(ITIMER_REAL, &itimer_null, NULL)
#define	START_TIMERS	start_timers()

#define	ADD_TIME(dest, t1, t2)	{ (dest).tv_sec = (t1).tv_sec + (t2).tv_sec; \
				  (dest).tv_usec = \
					(t1).tv_usec + (t2).tv_usec; \
				  if((dest).tv_usec >= 1000000){ \
				    (dest).tv_usec -= 1000000; \
				    (dest).tv_sec++; } }
#define	SUB_TIME(dest, t1, t2)	{ if((t1).tv_usec < (t2).tv_usec){ \
				    (dest).tv_sec = \
					(t1).tv_sec - (t2).tv_sec - 1;\
				    (dest).tv_usec = (t1).tv_usec + 1000000 \
							- (t2).tv_usec; } \
				  else{ \
				    (dest).tv_sec = \
				    (t1).tv_sec - (t2).tv_sec; \
				    (dest).tv_usec = (t1).tv_usec - (t2).tv_usec;}}
#define	CP_TIME(dest, src)	{ (dest).tv_usec = (src).tv_usec; \
				  (dest).tv_sec = (src).tv_sec; }
#define	IS_LATER(now, timer)	((now).tv_sec > (timer).tv_sec ? 1 : \
				  ((now).tv_sec < (timer).tv_sec ? 0 : \
				    ((now).tv_usec >= (timer).tv_usec ? 1 : 0)))
#define	TIMERSIZE	sizeof(TimerDataStruct)

typedef struct _aix_posix_timer {
  int			timer_id;
  struct timeval	exp_time;
  struct timeval	interval;
  signal_t		signal;
  char			repeat;
}	TimerDataStruct;

static	void	(*org_handler)() = SIG_DFL;
static	char	handler_installed = 0;

static	char	timer_signal = 0;

static	int	num_active_timers = 0;
static	int	num_timers = 0;
static	int	max_num_timers = 0;

static	Timer	actid = 2783;

static	TimerDataStruct	*active_timers = NULL;
static	TimerDataStruct	*timers = NULL;
static	TimerDataStruct	tmp_timer;

static struct itimerval		tmp_itimer, loc_itimer;

static struct itimerval itimer_null = { { (int) 0, (int) 0 },
					{ (int) 0, (int) 0 } };

static void
exec_timer(int * act_timer_idx_ptr)
{
  int	i, j, act_timer_idx, sigfl;

  act_timer_idx = *act_timer_idx_ptr;

  sigfl = active_timers[act_timer_idx].signal;

  if(active_timers[act_timer_idx].repeat){
    ADD_TIME(active_timers[act_timer_idx].exp_time,
		active_timers[act_timer_idx].exp_time,
		active_timers[act_timer_idx].interval);

    for(i = act_timer_idx + 1; i < num_active_timers; i++)
	if(IS_LATER(active_timers[i].exp_time,
			active_timers[act_timer_idx].exp_time))
	  break;

    if(i > act_timer_idx + 1){
	memcpy(&tmp_timer, &active_timers[act_timer_idx], TIMERSIZE);
	for(j = act_timer_idx; j < i - 1; j++)
	  memcpy(&active_timers[j], &active_timers[j + 1], TIMERSIZE);
	memcpy(&active_timers[i - 1], &tmp_timer, TIMERSIZE);

	(*act_timer_idx_ptr)--;
    }
  }
  else{
    (*act_timer_idx_ptr)--;
    num_active_timers--;
    for(i = act_timer_idx; i < num_active_timers; i++)
	memcpy(active_timers + i, active_timers + i + 1, TIMERSIZE);
  }

  timer_signal = 1;
  kill(getpid(), sigfl);
  timer_signal = 0;
}

static	void
process_timers()
{
  int		i;
  struct timeval	acttime;
  struct timezone	actzone;


  if(num_active_timers == 0)
    return;

  gettimeofday(&acttime, &actzone);

  for(i = 0; i < num_active_timers; i++){
    if(IS_LATER(acttime, active_timers[i].exp_time)){
	exec_timer(&i);
    }
    else
	break;
  }
}

static int
start_timers()
{
  int		i;
  struct timeval	acttime;
  struct timezone	actzone;

  if(!num_active_timers)
    return(0);

  tmp_itimer.it_interval.tv_sec = 0;
  tmp_itimer.it_interval.tv_usec = 0;

  do{
    i = 0;

    gettimeofday(&acttime, &actzone);

    SUB_TIME(tmp_itimer.it_value, active_timers[0].exp_time, acttime);

    if((tmp_itimer.it_value.tv_sec == 0 && tmp_itimer.it_value.tv_usec == 0)
			|| tmp_itimer.it_value.tv_sec < 0){
	exec_timer(&i);
	i = 1;
    }
  } while(i);

  return(setitimer(ITIMER_REAL, &tmp_itimer, NULL));
}

static	char	handler_active = 0;

static void
handler(signal_t sig)
{
  if(timer_signal){
    if(org_handler != SIG_DFL)
	org_handler(sig);
  }
  else{
    while(handler_active);

    handler_active = 1;

    STOP_TIMERS;

    process_timers();

    START_TIMERS;

    handler_active = 0;
  }
}


Timer
timer_make(ClockID id, struct Signal_Event *sigev)
{
  struct sigaction	siga, osiga;

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

  STOP_TIMERS;

  num_timers++;

  if(num_timers > max_num_timers){
    max_num_timers = num_timers;

    if(timers)
	timers = RENEWP(timers, TimerDataStruct, max_num_timers);
    else
	timers = NEWP(TimerDataStruct, 1);

    if(active_timers)
	active_timers = RENEWP(active_timers, TimerDataStruct,
					max_num_timers);
    else
	active_timers = NEWP(TimerDataStruct, 1);

    if(!timers && ! active_timers){
	errno = ENOMEM;
	return(-1);
    }
  }

  process_timers();

  START_TIMERS;

  tmp_itimer.it_interval.tv_sec = 0;
  tmp_itimer.it_interval.tv_usec = 0;

  if(! handler_installed){
    SETZERO(siga);
    siga.sa_handler = handler;
    sigaction(SIGALRM, &siga, &osiga);

    org_handler = osiga.sa_handler;

    handler_installed = 1;
  }

  actid++;

  timers[num_timers - 1].timer_id = actid;
  timers[num_timers - 1].signal = sigev->sigev_signum;

  return(actid);
}

static void
clear_timer(int idx)
{
  num_active_timers--;

  for(; idx < num_active_timers; idx++)
    memcpy(&active_timers[idx], &active_timers[idx + 1], TIMERSIZE);
}

static int
remove_timer(Timer timerid)
{
  int	i;

  for(i = 0; i < num_timers; i++){
    if(timerid == timers[i].timer_id){
	num_timers--;
	for(; i < num_timers; i++)
	  memcpy(&timers[i], &timers[i + 1], TIMERSIZE);
	return(0);
    }
  }

  errno = EINVAL;

  return(-1);
}

int
timer_del(Timer timerid)
{
  int	i, res;

  res = -1;
  if(num_active_timers > 0){
    for(i = 0; i < num_active_timers; i++){
	if(active_timers[i].timer_id == timerid){
	  STOP_TIMERS;

	  clear_timer(i);

	  START_TIMERS;

	  res = remove_timer(timerid);
	}
    }
  }

  return(res);
}

int
timer_get(Timer timerid, struct itimerval *value)
{
  int	i;
  struct timeval	acttime;
  struct timezone	actzone;

  for(i = 0; i < num_active_timers; i++){
    if(timerid == active_timers[i].timer_id){
	if(active_timers[i].repeat){
	  value->it_interval.tv_usec =
			active_timers[i].interval.tv_usec;
	  value->it_interval.tv_sec =
			active_timers[i].interval.tv_sec;
	}
	else{
	  value->it_interval.tv_sec = 0;
	  value->it_interval.tv_usec = 0;
	}

	gettimeofday(&acttime, &actzone);
	SUB_TIME(tmp_itimer.it_value, active_timers[i].exp_time, acttime);
	if(tmp_itimer.it_value.tv_sec < 0){
	  tmp_itimer.it_value.tv_sec = 0;
	  tmp_itimer.it_value.tv_usec = 0;
	}
	value->it_value.tv_sec = tmp_itimer.it_value.tv_sec;
	value->it_value.tv_usec = tmp_itimer.it_value.tv_usec;

	return(0);
    }
  }

  for(i = 0; i < num_timers; i++)
    if(timerid == timers[i].timer_id)
	break;

  if(i < num_timers)
    return(0);

  return(-1);
}

int
timer_set(
  Timer		timerid,
  int		flags,
  struct itimerval	*value,
  struct itimerval	*ovalue)
{
  struct timeval	acttime;
  struct timezone	actzone;
  int	i, j, tnum;

  for(tnum = 0; tnum < num_timers; tnum++)
    if(timerid == timers[tnum].timer_id)
	break;

  if(tnum >= num_timers){
    errno = EINVAL;
    return(-1);
  };

  memset(&tmp_itimer, 0, sizeof(tmp_itimer));

  loc_itimer.it_interval.tv_sec = value->it_interval.tv_sec;
  loc_itimer.it_interval.tv_usec = value->it_interval.tv_usec;
  loc_itimer.it_value.tv_sec = value->it_value.tv_sec;
  loc_itimer.it_value.tv_usec = value->it_value.tv_usec;

  /*if(!loc_itimer.it_value.tv_sec && !loc_itimer.it_value.tv_usec &&
	(loc_itimer.it_interval.tv_sec || loc_itimer.it_interval.tv_usec)){
    loc_itimer.it_value.tv_sec = loc_itimer.it_interval.tv_sec;
    loc_itimer.it_value.tv_usec = loc_itimer.it_interval.tv_usec;
  }*/

  STOP_TIMERS;

  for(i = 0; i < num_active_timers; i++)
    if(active_timers[i].timer_id == timerid){
	gettimeofday(&acttime, &actzone);

	SUB_TIME(tmp_itimer.it_value, active_timers[i].exp_time, acttime);
	if(active_timers[i].repeat)
	  CP_TIME(tmp_itimer.it_interval, active_timers[i].interval);

	if(tmp_itimer.it_value.tv_sec < 0){
	  tmp_itimer.it_value.tv_sec = 0;
	  tmp_itimer.it_value.tv_usec = 0;
	}

	clear_timer(i);
	break;
    }

  gettimeofday(&acttime, &actzone);

  if(ovalue){
    ovalue->it_interval.tv_sec = tmp_itimer.it_interval.tv_sec;
    ovalue->it_interval.tv_usec = tmp_itimer.it_interval.tv_usec;
    ovalue->it_value.tv_sec = tmp_itimer.it_value.tv_sec;
    ovalue->it_value.tv_usec = tmp_itimer.it_value.tv_usec;
  }

  tmp_timer.timer_id = timerid;

  tmp_timer.repeat = !(loc_itimer.it_interval.tv_sec == 0
				&& loc_itimer.it_interval.tv_usec == 0);

  tmp_timer.signal = timers[tnum].signal;

  tmp_timer.interval.tv_sec = loc_itimer.it_interval.tv_sec;
  tmp_timer.interval.tv_usec = loc_itimer.it_interval.tv_usec;

  if(flags & TIMER_ADDREL){
    ADD_TIME(tmp_timer.exp_time, loc_itimer.it_value, tmp_itimer.it_value);
  }
  else{
    if(flags & TIMER_ABSTIME){
      CP_TIME(tmp_timer.exp_time, loc_itimer.it_value);
    }
    else{
      ADD_TIME(tmp_timer.exp_time, loc_itimer.it_value, acttime);
    }
  }

  if(loc_itimer.it_value.tv_sec || loc_itimer.it_value.tv_usec
	|| loc_itimer.it_interval.tv_sec || loc_itimer.it_interval.tv_usec){
    for(i = 0; i < num_active_timers; i++)
      if(IS_LATER(active_timers[i].exp_time, tmp_timer.exp_time))
	  break;

    for(j = num_active_timers; j > i; j--)
      memcpy(&active_timers[j], &active_timers[j - 1], TIMERSIZE);

    memcpy(&active_timers[i], &tmp_timer, TIMERSIZE);

    num_active_timers++;
  }

  process_timers();

  return(START_TIMERS);
}

int
clock_get(ClockID clock_id, struct timeval *tp)
{
  struct timeval	acttime;
  struct timezone	actzone;

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

  gettimeofday(&acttime, &actzone);

  tp->tv_sec = acttime.tv_sec;
  tp->tv_usec = acttime.tv_usec;

  return(0);
}


#if !defined(WINDOWS_LIKE)

#include <signal.h>
#include <unistd.h>
#include <x_types.h>


#ifndef	NSIG
#ifdef	_SIGMAX
#define	NSIG	_SIGMAX
#else
#ifdef	SIGMAX
#define	NSIG	SIGMAX
#else
#define	NSIG	32
#endif
#endif
#endif

#ifndef HAVE_TERMIOS_H
static struct termio	org_ttyattr;
#else
static struct termios	org_ttyattr;
#endif
static void		(*org_sighandlers[NSIG])(int);
static UChar		signals_set = 0;

static void
reset_signals()
{
  Int32	i;

#ifndef HAVE_TERMIOS_H
  ioctl(0, TCSETA, &org_ttyattr);
#else
  tcsetattr(0, TCSANOW, &org_ttyattr);
#endif

  if(!signals_set)
    return;

  for(i = 0; i < NSIG; i++)
    signal(i, org_sighandlers[i]);

  signals_set = 0;
}

static void
ttsighandl(int sig)
{
  reset_signals();

  if(org_sighandlers[sig])
    org_sighandlers[sig](sig);
  else
    exit(1);
}

Int32
getinchr(UChar * c, Uns32 timeout)
{
#ifndef HAVE_TERMIOS_H
  struct termio		new_ttyattr;
#else
  struct termios	new_ttyattr;
#endif
  Int32		i;
  char		a;
  Uns32		ltime;
  char		stime;

  if(c == NULL)
    return(EINVAL);

  stime = (char)(timeout & 63);
  ltime = timeout / 64 + 1;

#ifndef HAVE_TERMIOS_H
  if(ioctl(0, TCGETA, &org_ttyattr))
#else
  if(tcgetattr(0, &org_ttyattr))
#endif
    return(-1);

  memcpy(&new_ttyattr, &org_ttyattr, sizeof(org_ttyattr));
  if(timeout){
    new_ttyattr.c_cc[VMIN] = '\0';
  }
  else{
    new_ttyattr.c_cc[VMIN] = '\001';
    new_ttyattr.c_cc[VTIME] = '\0';
  }
  new_ttyattr.c_lflag &= ~(ICANON | ECHO);

  for(i = 0; i < NSIG; i++)
    org_sighandlers[i] = signal(i, ttsighandl);
  signals_set = 1;


  do{
    if(timeout){
      if(ltime > 1){
	new_ttyattr.c_cc[VTIME] = (char) 64;
      }
      else{
	new_ttyattr.c_cc[VTIME] = stime;
      }
      ltime--;
    }

#ifndef HAVE_TERMIOS_H
    if(ioctl(0, TCSETA, &new_ttyattr)){
#else
    if(tcsetattr(0, TCSANOW, &new_ttyattr)){
#endif
      reset_signals();
      return(-1);
    }

    i = read(0, &a, 1);
  } while(timeout ? (ltime > 0 && i < 1) : (i < 1));

  reset_signals();

  if(i > 0){
    *c = a;
    return(1);
  }

  return(0);
}

Flag
is_a_tty(int fd)
{
#ifndef HAVE_TERMIOS_H
  struct termio		ttyattrs;
#else