common/dlog.c

/*
 * Copyright (c) 2000-2001 Silicon Graphics, Inc.
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/select.h>
#include <fcntl.h>
#include <time.h>
#include <errno.h>
#include <signal.h>
#include <assert.h>
#include <string.h>

#include "config.h"

#include "types.h"
#include "mlog.h"
#include "dlog.h"
#include "getopt.h"

static int dlog_ttyfd = -1;
static volatile bool_t dlog_allowed_flag = BOOL_FALSE;
static bool_t dlog_timeouts_flag = BOOL_FALSE;
static char *promptstr = " -> ";

static sigset_t dlog_registered_sigs;

static bool_t promptinput( char *buf,
			   size_t bufsz,
			   ix_t *exceptionixp,
			   time32_t timeout,
			   ix_t timeoutix,
			   ix_t sigintix,
			   ix_t sighupix,
			   ix_t sigquitix,
			   char *fmt, ... );
static void dlog_string_query_print( void *ctxp, char *fmt, ... );

bool_t
dlog_init( int argc, char *argv[ ] )
{
	int c;

	/* can only call once
	 */
	assert( dlog_ttyfd == -1 );

	/* initially allow dialog, use stdin fd
	 */
	dlog_ttyfd = 0; /* stdin */
	dlog_allowed_flag = BOOL_TRUE;
	dlog_timeouts_flag = BOOL_TRUE;

	sigemptyset( &dlog_registered_sigs );

	/* look for command line option claiming the operator knows
	 * what's up.
	 */
	optind = 1;
	opterr = 0;
	while ( ( c = getopt( argc, argv, GETOPT_CMDSTRING )) != EOF ) {
		switch ( c ) {
		case GETOPT_FORCE:
			dlog_ttyfd = -1;
			dlog_allowed_flag = BOOL_FALSE;
			break;
		case GETOPT_NOTIMEOUTS:
			dlog_timeouts_flag = BOOL_FALSE;
			break;
		}
	}
#ifdef RESTORE
	/* look to see if restore source coming in on
	 * stdin. If so , try to open /dev/tty for dialogs.
	 */
	if ( optind < argc && ! strcmp( argv[ optind ], "-" )) {
		dlog_ttyfd = open( "/dev/tty", O_RDWR );
		if ( dlog_ttyfd < 0 ) {
			perror("/dev/tty");
			dlog_ttyfd = -1;
			dlog_allowed_flag = BOOL_FALSE;
		}
	}
#endif /* RESTORE */

#ifdef CHKSTDIN
	/* if stdin is not a tty, don't allow dialogs
	 */
	if ( dlog_allowed_flag ) {
		struct stat statbuf;
		int rval;

		assert( dlog_ttyfd >= 0 );
		rval = fstat( dlog_ttyfd, &statbuf );
		if ( rval ) {
			mlog( MLOG_VERBOSE | MLOG_WARNING,
			      _("could not fstat stdin (fd %d): %s (%d)\n"),
			      dlog_ttyfd,
			      strerror( errno ),
			      errno );
		} else {
			mlog( MLOG_DEBUG,
			      "stdin mode 0x%x\n",
			      statbuf.st_mode );
		}
	}
#endif /* CHKSTDIN */

	return BOOL_TRUE;
}

bool_t
dlog_allowed( void )
{
	return dlog_allowed_flag;
}

void
dlog_desist( void )
{
	dlog_allowed_flag = BOOL_FALSE;
}

int
dlog_fd( void )
{
	return dlog_ttyfd;
}

void
dlog_begin( char *preamblestr[ ], size_t preamblecnt )
{
	size_t ix;

	mlog_lock( );
	for ( ix = 0 ; ix < preamblecnt ; ix++ ) {
		mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
		      preamblestr[ ix ] );
	}
}

void
dlog_end( char *postamblestr[ ], size_t postamblecnt )
{
	size_t ix;

	for ( ix = 0 ; ix < postamblecnt ; ix++ ) {
		mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
		      postamblestr[ ix ] );
	}
	mlog_unlock( );
}

ix_t
dlog_multi_query( char *querystr[ ],
		  size_t querycnt,
		  char *choicestr[ ],
		  size_t choicecnt,
		  char *hilitestr,
		  size_t hiliteix,
		  char *defaultstr,
		  ix_t defaultix,
		  time32_t timeout,
		  ix_t timeoutix,
		  ix_t sigintix,
		  ix_t sighupix,
		  ix_t sigquitix )
{
	size_t ix;
	char buf[ 100 ];
	char *prepromptstr;

	/* sanity
	 */
	assert( dlog_allowed_flag );

	/* display query description strings
	 */
	for ( ix = 0 ; ix < querycnt ; ix++ ) {
		mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
		      querystr[ ix ] );
	}

	/* display the choices: NOTE: display is 1-based, code intfs 0-based!
	 */
	for ( ix = 0 ; ix < choicecnt ; ix++ ) {
		mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
		      "%u: %s",
		      ix + 1,
		      choicestr[ ix ] );
		if ( ix == hiliteix ) {
			mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
			      "%s",
			      hilitestr ?  hilitestr : " *" );
		}
		if ( ix == defaultix ) {
			mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
			      "%s",
			      defaultstr ?  defaultstr : _(" (default)") );
		}
		if ( dlog_timeouts_flag
		     &&
		     timeoutix != IXMAX
		     &&
		     ix == timeoutix ) {
			mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
			      _(" (timeout in %u sec)"),
			      timeout );
		}
		mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
		      "\n" );
	}

	/* read the tty until we get a proper answer or are interrupted
	 */
	prepromptstr = "";
	for ( ; ; ) {
		ix_t exceptionix;
		bool_t ok;

		/* prompt and accept input
		 */
		ok = promptinput( buf,
				  sizeof( buf ),
				  &exceptionix,
				  timeout,
				  timeoutix,
				  sigintix,
				  sighupix,
				  sigquitix,
				  prepromptstr,
				  choicecnt );
		if ( ok ) {
			long int val;
			char *end = buf;

			if ( ! strlen( buf )) {
				return defaultix;
			}

			val = strtol( buf, &end, 10 );
			if ( *end != '\0' || val < 1 || val > choicecnt ) {
				prepromptstr = _(
				      "please enter a value "
				      "between 1 and %d inclusive ");
				continue;
			}
			return val - 1; // return value is a 0-based index
		} else {
			return exceptionix;
		}
	}
	/* NOTREACHED */
}

void
dlog_multi_ack( char *ackstr[ ], size_t ackcnt )
{
	size_t ix;

	for ( ix = 0 ; ix < ackcnt ; ix++ ) {
		mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
		      ackstr[ ix ] );
	}
}

ix_t
dlog_string_query( dlog_ucbp_t ucb, /* user's print func */
		   void *uctxp,	  /* user's context for above */
		   char *bufp,	  /* typed string returned in */
		   size_t bufsz,	  /* buffer size */
		   time32_t timeout,  /* secs b4 giving up */
		   ix_t timeoutix,
		   ix_t sigintix,
		   ix_t sighupix,
		   ix_t sigquitix,
		   ix_t okix )
{
	ix_t exceptionix;
	bool_t ok;

	/* sanity
	 */
	assert( dlog_allowed_flag );

	/* call the caller's callback with his context, print context, and
	 * print operator
	 */
	( * ucb )( uctxp, dlog_string_query_print, 0 );

	/* if called for, print the timeout and a newline.
	 * if not, print just a newline
	 */
	if ( dlog_timeouts_flag && timeoutix != IXMAX ) {
		mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
		      _(" (timeout in %u sec)\n"),
		      timeout );
	} else {
		mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
		      "\n" );
	}

	/* prompt and accept input
	 */
	ok = promptinput( bufp,
			  bufsz,
			  &exceptionix,
			  timeout,
			  timeoutix,
			  sigintix,
			  sighupix,
			  sigquitix,
			  "" );
	if ( ok ) {
		return okix;
	} else {
		return exceptionix;
	}
}

void
dlog_string_ack( char *ackstr[ ], size_t ackcnt )
{
	dlog_multi_ack( ackstr, ackcnt );
}

/* ok that this is a static, since used under mutual exclusion lock
 */
static volatile int dlog_signo_received;

bool_t
dlog_sighandler( int signo )
{
	if ( sigismember( &dlog_registered_sigs, signo ) < 1 )
		return BOOL_FALSE;
	// only process the first signal
	sigemptyset( &dlog_registered_sigs );
	dlog_signo_received = signo;
	return BOOL_TRUE;
}

/* ARGSUSED */
static void
dlog_string_query_print( void *ctxp, char *fmt, ... )
{
	va_list args;

	assert( ! ctxp );

	va_start( args, fmt );
	mlog_va( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE, fmt, args );
	va_end( args );
}

static bool_t
promptinput( char *buf,
	     size_t bufsz,
	     ix_t *exceptionixp,
	     time32_t timeout,
	     ix_t timeoutix,
	     ix_t sigintix,
	     ix_t sighupix,
	     ix_t sigquitix,
	     char *fmt,
	     ... )
{
	va_list args;
	time32_t now = time( NULL );
	int nread = -1;
	sigset_t orig_set;
	char *bufp = buf;

	/* display the pre-prompt
	 */
	va_start( args, fmt );
	mlog_va( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE, fmt, args );
	va_end( args );

	/* display standard prompt
	 */
#ifdef NOTYET
	if ( dlog_timeouts_flag && timeoutix != IXMAX ) {
		mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
		      _("(timeout in %d sec)"),
		      timeout );
	}
#endif /* NOTYET */
	mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE, promptstr );

	/* set up timeout
	 */
	if ( dlog_timeouts_flag && timeoutix != IXMAX ) {
		timeout += now;
	} else {
		timeout = TIMEMAX;
	}

	/* set up signal handling
	 * the mlog lock is held for the life of the dialog (see dlog_begin)
	 * and it's possible the main thread, which normally does the signal
	 * handling, is now waiting on the mlog lock trying to log a message.
	 * so unblock the relevant signals for this thread. note this means
	 * the current thread or the main thread might handle one of these
	 * signals.
	 */
	dlog_signo_received = -1;
	sigemptyset( &dlog_registered_sigs );
	if ( sigintix != IXMAX ) {
		sigaddset( &dlog_registered_sigs, SIGINT );
	}
	if ( sighupix != IXMAX ) {
		sigaddset( &dlog_registered_sigs, SIGHUP );
		sigaddset( &dlog_registered_sigs, SIGTERM );
	}
	if ( sigquitix != IXMAX ) {
		sigaddset( &dlog_registered_sigs, SIGQUIT );
	}

	pthread_sigmask( SIG_UNBLOCK, &dlog_registered_sigs, &orig_set );

	/* wait for input, timeout, or interrupt.
	 * note we come out of the select() frequently in order to
	 * check for a signal. the signal may have been handled by the
	 * the main thread, so we can't rely on the signal waking us
	 * up from the select().
	 */
	while ( now < timeout && dlog_signo_received == -1 && dlog_allowed_flag ) {
		int rc;
		fd_set rfds;
		struct timeval tv = { 0, 100000 }; // 100 ms

		FD_ZERO( &rfds );
		FD_SET( dlog_ttyfd, &rfds );

		rc = select( dlog_ttyfd + 1, &rfds, NULL, NULL, &tv );
		if ( rc > 0 && FD_ISSET( dlog_ttyfd, &rfds ) ) {
			nread = read( dlog_ttyfd, bufp, bufsz );
			if ( nread < 0 ) {
				break; // error handled below
			} else if ( nread == 0 && buf == bufp ) {
				mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE, "\n" );
				*bufp = 0;
				break; // no input, return an empty string
			} else if ( nread > 0 && bufp[nread-1] == '\n' ) {
				// received a full line, chomp the newline
				bufp[nread-1] = 0;
				break;
			} else if ( nread == bufsz ) {
				// no more room, truncate and return
				bufp[nread-1] = 0;
				break;
			}

			// keep waiting for a full line of input
			bufp += nread;
			bufsz -= nread;
			nread = -1;
		}
		now = time( NULL );
	}

	/* restore signal handling
	 */
	pthread_sigmask( SIG_SETMASK, &orig_set, NULL );
	sigemptyset( &dlog_registered_sigs );
	
	/* check for timeout or interrupt
	 */
	if ( nread < 0 ) {
		if ( now >= timeout ) {
			mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
			      _("timeout\n") );
			*exceptionixp = timeoutix;
		} else if ( dlog_signo_received == SIGINT ) {
			mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
			      _("keyboard interrupt\n") );
			mlog_exit_hint(RV_KBD_INTR);
			*exceptionixp = sigintix;
		} else if ( dlog_signo_received == SIGHUP ) {
			mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
			      _("hangup\n") );
			*exceptionixp = sighupix;
		} else if ( dlog_signo_received == SIGTERM ) {
			mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
			      _("terminate\n") );
			*exceptionixp = sighupix;
		} else if ( dlog_signo_received == SIGQUIT ) {
			mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
			      _("keyboard quit\n") );
			mlog_exit_hint(RV_KBD_INTR);
			*exceptionixp = sigquitix;
		} else {
			mlog( MLOG_NORMAL | MLOG_NOLOCK | MLOG_BARE,
			      _("abnormal dialog termination\n"));
			*exceptionixp = sigquitix;
		}
		return BOOL_FALSE;
	} else {
		assert( dlog_signo_received == -1 );
		*exceptionixp = 0;
		return BOOL_TRUE;
	}
}