/*      $NetBSD: amd.c,v 1.1.1.3 2015/01/17 16:34:15 christos Exp $     */

/*
* Copyright (c) 1997-2014 Erez Zadok
* Copyright (c) 1989 Jan-Simon Pendry
* Copyright (c) 1989 Imperial College of Science, Technology & Medicine
* Copyright (c) 1989 The Regents of the University of California.
* All rights reserved.
*
* This code is derived from software contributed to Berkeley by
* Jan-Simon Pendry at Imperial College, London.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
* 3. Neither the name of the University nor the names of its contributors
*    may be used to endorse or promote products derived from this software
*    without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
*
* File: am-utils/amd/amd.c
*
*/

/*
* Automounter
*/

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif /* HAVE_CONFIG_H */
#include <am_defs.h>
#include <amd.h>

struct amu_global_options gopt; /* where global options are stored */

char pid_fsname[SIZEOF_PID_FSNAME]; /* "kiska.southseas.nz:(pid%d)" */
char *hostdomain = "unknown.domain";
#define SIZEOF_HOSTD (2 * MAXHOSTNAMELEN + 1)   /* Host+domain */
char hostd[SIZEOF_HOSTD];       /* Host+domain */
char *endian = ARCH_ENDIAN;     /* Big or Little endian */
char *cpu = HOST_CPU;           /* CPU type */
char *PrimNetName;              /* name of primary network */
char *PrimNetNum;               /* number of primary network */

int immediate_abort;            /* Should close-down unmounts be retried */
int orig_umask = 022;
int select_intr_valid;

jmp_buf select_intr;
struct amd_stats amd_stats;     /* Server statistics */
struct in_addr myipaddr;        /* (An) IP address of this host */
time_t do_mapc_reload = 0;      /* mapc_reload() call required? */

#ifdef HAVE_FS_AUTOFS
int amd_use_autofs = 0;
#endif /* HAVE_FS_AUTOFS */

#ifdef HAVE_SIGACTION
sigset_t masked_sigs;
#endif /* HAVE_SIGACTION */


/*
* Signal handler:
* SIGINT - tells amd to do a full shutdown, including unmounting all
*       filesystem.
* SIGTERM - tells amd to shutdown now.  Just unmounts the automount nodes.
*/
static RETSIGTYPE
sigterm(int sig)
{
#ifdef REINSTALL_SIGNAL_HANDLER
 signal(sig, sigterm);
#endif /* REINSTALL_SIGNAL_HANDLER */

 switch (sig) {
 case SIGINT:
   immediate_abort = 15;
   break;

 case SIGTERM:
   immediate_abort = -1;
   /* fall through... */

 default:
   plog(XLOG_WARNING, "WARNING: automounter going down on signal %d", sig);
   break;
 }
 if (select_intr_valid)
   longjmp(select_intr, sig);
}


/*
* Hook for cache reload.
* When a SIGHUP arrives it schedules a call to mapc_reload
*/
static RETSIGTYPE
sighup(int sig)
{
#ifdef REINSTALL_SIGNAL_HANDLER
 signal(sig, sighup);
#endif /* REINSTALL_SIGNAL_HANDLER */

 if (sig != SIGHUP)
   dlog("spurious call to sighup");
 /*
  * Force a reload by zero'ing the timer
  */
 if (amd_state == Run)
   do_mapc_reload = 0;
}


static RETSIGTYPE
parent_exit(int sig)
{
 /*
  * This signal handler is called during Amd initialization.  The parent
  * forks a child to do all the hard automounting work, and waits for a
  * SIGQUIT signal from the child.  When the parent gets the signal it's
  * supposed to call this handler and exit(3), thus completing the
  * daemonizing process.  Alas, on some systems, especially Linux 2.4/2.6
  * with Glibc, exit(3) doesn't always terminate the parent process.
  * Worse, the parent process now refuses to accept any more SIGQUIT
  * signals -- they are blocked.  What's really annoying is that this
  * doesn't happen all the time, suggesting a race condition somewhere.
  * (This happens even if I change the logic to use another signal.)  I
  * traced this to something which exit(3) does in addition to exiting the
  * process, probably some atexit() stuff or other side-effects related to
  * signal handling.  Either way, since at this stage the parent process
  * just needs to terminate, I'm simply calling _exit(2).  Note also that
  * the OpenGroup doesn't list exit(3) as a recommended "Base Interface"
  * but they do list _exit(2) as one.  This fix seems to work reliably all
  * the time. -Erez (2/27/2005)
  */
 _exit(0);
}


static int
daemon_mode(void)
{
 int bgpid;

#ifdef HAVE_SIGACTION
 struct sigaction sa, osa;

 memset(&sa, 0, sizeof(sa));
 sa.sa_handler = parent_exit;
 sa.sa_flags = 0;
 sigemptyset(&(sa.sa_mask));
 sigaddset(&(sa.sa_mask), SIGQUIT);
 sigaction(SIGQUIT, &sa, &osa);
#else /* not HAVE_SIGACTION */
 signal(SIGQUIT, parent_exit);
#endif /* not HAVE_SIGACTION */

 bgpid = background();

 if (bgpid != 0) {
   /*
    * Now wait for the automount points to
    * complete.
    */
   for (;;)
     pause();
   /* should never reach here */
 }
#ifdef HAVE_SIGACTION
 sigaction(SIGQUIT, &osa, NULL);
#else /* not HAVE_SIGACTION */
 signal(SIGQUIT, SIG_DFL);
#endif /* not HAVE_SIGACTION */

 /*
  * Record our pid to make it easier to kill the correct amd.
  */
 if (gopt.flags & CFM_PRINT_PID) {
   if (STREQ(gopt.pid_file, "/dev/stdout")) {
     printf("%ld\n", (long) am_mypid);
     /* flush stdout, just in case */
     fflush(stdout);
   } else {
     FILE *f;
     mode_t prev_umask = umask(0022); /* set secure temporary umask */

     f = fopen(gopt.pid_file, "w");
     if (f) {
       fprintf(f, "%ld\n", (long) am_mypid);
       (void) fclose(f);
     } else {
       fprintf(stderr, "cannot open %s (errno=%d)\n", gopt.pid_file, errno);
     }
     umask(prev_umask);        /* restore umask */
   }
 }

 /*
  * Pretend we are in the foreground again
  */
 foreground = 1;

 /*
  * Dissociate from the controlling terminal
  */
 amu_release_controlling_tty();

 return getppid();
}


/*
* Initialize global options structure.
*/
static void
init_global_options(void)
{
#if defined(HAVE_SYS_UTSNAME_H) && defined(HAVE_UNAME)
 static struct utsname un;
#endif /* defined(HAVE_SYS_UTSNAME_H) && defined(HAVE_UNAME) */
 int i;

 memset(&gopt, 0, sizeof(struct amu_global_options));

 /* name of current architecture */
 gopt.arch = HOST_ARCH;

 /* automounter temp dir */
 gopt.auto_dir = "/a";

 /* toplevel attribute cache timeout */
 gopt.auto_attrcache = 0;

 /* cluster name */
 gopt.cluster = NULL;

 /* executable map timeout */
 gopt.exec_map_timeout = AMFS_EXEC_MAP_TIMEOUT;

 /*
  * kernel architecture: this you must get from uname() if possible.
  */
#if defined(HAVE_SYS_UTSNAME_H) && defined(HAVE_UNAME)
 if (uname(&un) >= 0)
   gopt.karch = un.machine;
 else
#endif /* defined(HAVE_SYS_UTSNAME_H) && defined(HAVE_UNAME) */
   gopt.karch = HOST_ARCH;

 /* amd log file */
 gopt.logfile = NULL;

 /* operating system name */
 gopt.op_sys = HOST_OS_NAME;

 /* OS version */
 gopt.op_sys_ver = HOST_OS_VERSION;

 /* full OS name and version */
 gopt.op_sys_full = HOST_OS;

 /* OS version */
 gopt.op_sys_vendor = HOST_VENDOR;

 /* pid file */
 gopt.pid_file = "/dev/stdout";

 /* local domain */
 gopt.sub_domain = NULL;

 /* reset NFS (and toplvl) retransmit counter and retry interval */
 for (i=0; i<AMU_TYPE_MAX; ++i) {
   gopt.amfs_auto_retrans[i] = -1; /* -1 means "never set before" */
   gopt.amfs_auto_timeo[i] = -1; /* -1 means "never set before" */
 }

 /* cache duration */
 gopt.am_timeo = AM_TTL;

 /* dismount interval */
 gopt.am_timeo_w = AM_TTL_W;

 /* map reload intervl */
 gopt.map_reload_interval = ONE_HOUR;

 /*
  * various CFM_* flags that are on by default.
  */
 gopt.flags = CFM_DEFAULT_FLAGS;

#ifdef HAVE_MAP_HESIOD
 /* Hesiod rhs zone */
 gopt.hesiod_base = "automount";
#endif /* HAVE_MAP_HESIOD */

#ifdef HAVE_MAP_LDAP
 /* LDAP base */
 gopt.ldap_base = NULL;

 /* LDAP host ports */
 gopt.ldap_hostports = NULL;

 /* LDAP cache */
 gopt.ldap_cache_seconds = 0;
 gopt.ldap_cache_maxmem = 131072;

 /* LDAP protocol version */
 gopt.ldap_proto_version = 2;
#endif /* HAVE_MAP_LDAP */

#ifdef HAVE_MAP_NIS
 /* YP domain name */
 gopt.nis_domain = NULL;
#endif /* HAVE_MAP_NIS */
}


/*
* Lock process text and data segment in memory (after forking the daemon)
*/
static void
do_memory_locking(void)
{
#if defined(HAVE_PLOCK) || defined(HAVE_MLOCKALL)
 int locked_ok = 0;
#else /* not HAVE_PLOCK and not HAVE_MLOCKALL */
 plog(XLOG_WARNING, "Process memory locking not supported by the OS");
#endif /* not HAVE_PLOCK and not HAVE_MLOCKALL */
#ifdef HAVE_PLOCK
# ifdef _AIX
 /*
  * On AIX you must lower the stack size using ulimit() before calling
  * plock.  Otherwise plock will reserve a lot of memory space based on
  * your maximum stack size limit.  Since it is not easily possible to
  * tell what should the limit be, I print a warning before calling
  * plock().  See the manual pages for ulimit(1,3,4) on your AIX system.
  */
 plog(XLOG_WARNING, "AIX: may need to lower stack size using ulimit(3) before calling plock");
# endif /* _AIX */
 if (!locked_ok && plock(PROCLOCK) != 0)
   plog(XLOG_WARNING, "Couldn't lock process pages in memory using plock(): %m");
 else
   locked_ok = 1;
#endif /* HAVE_PLOCK */
#ifdef HAVE_MLOCKALL
 if (!locked_ok && mlockall(MCL_CURRENT|MCL_FUTURE) != 0)
   plog(XLOG_WARNING, "Couldn't lock process pages in memory using mlockall(): %m");
 else
   locked_ok = 1;
#endif /* HAVE_MLOCKALL */
#if defined(HAVE_PLOCK) || defined(HAVE_MLOCKALL)
 if (locked_ok)
   plog(XLOG_INFO, "Locked process pages in memory");
#endif /* HAVE_PLOCK || HAVE_MLOCKALL */

#if defined(HAVE_MADVISE) && defined(MADV_PROTECT)
   madvise(NULL, 0, MADV_PROTECT); /* may be redundant of the above worked out */
#endif /* defined(HAVE_MADVISE) && defined(MADV_PROTECT) */
}


int
main(int argc, char *argv[])
{
 char *domdot, *verstr, *vertmp;
 int ppid = 0;
 int error;
 char *progname = NULL;                /* "amd" */
 char hostname[MAXHOSTNAMELEN + 1] = "localhost"; /* Hostname */

 /*
  * Make sure some built-in assumptions are true before we start
  */
 assert(sizeof(nfscookie) >= sizeof(u_int));
 assert(sizeof(int) >= 4);

 /*
  * Set processing status.
  */
 amd_state = Start;

 /*
  * Determine program name
  */
 if (argv[0]) {
   progname = strrchr(argv[0], '/');
   if (progname && progname[1])
     progname++;
   else
     progname = argv[0];
 }
 if (!progname)
   progname = "amd";
 am_set_progname(progname);

 /*
  * Initialize process id.  This is kept
  * cached since it is used for generating
  * and using file handles.
  */
 am_set_mypid();

 /*
  * Get local machine name
  */
 if (gethostname(hostname, sizeof(hostname)) < 0) {
   plog(XLOG_FATAL, "gethostname: %m");
   going_down(1);
   return 1;
 }
 hostname[sizeof(hostname) - 1] = '\0';

 /*
  * Check it makes sense
  */
 if (!*hostname) {
   plog(XLOG_FATAL, "host name is not set");
   going_down(1);
   return 1;
 }

 /*
  * Initialize global options structure.
  */
 init_global_options();

 /*
  * Partially initialize hostd[].  This
  * is completed in get_args().
  */
 if ((domdot = strchr(hostname, '.'))) {
   /*
    * Hostname already contains domainname.
    * Split out hostname and domainname
    * components
    */
   *domdot++ = '\0';
   hostdomain = domdot;
 }
 xstrlcpy(hostd, hostname, sizeof(hostd));
 am_set_hostname(hostname);

 /*
  * Setup signal handlers
  */
 /* SIGINT: trap interrupts for shutdowns */
 setup_sighandler(SIGINT, sigterm);
 /* SIGTERM: trap terminate so we can shutdown cleanly (some chance) */
 setup_sighandler(SIGTERM, sigterm);
 /* SIGHUP: hangups tell us to reload the cache */
 setup_sighandler(SIGHUP, sighup);
 /*
  * SIGCHLD: trap Death-of-a-child.  These allow us to pick up the exit
  * status of backgrounded mounts.  See "sched.c".
  */
 setup_sighandler(SIGCHLD, sigchld);
#ifdef HAVE_SIGACTION
 /* construct global "masked_sigs" used in nfs_start.c */
 sigemptyset(&masked_sigs);
 sigaddset(&masked_sigs, SIGINT);
 sigaddset(&masked_sigs, SIGTERM);
 sigaddset(&masked_sigs, SIGHUP);
 sigaddset(&masked_sigs, SIGCHLD);
#endif /* HAVE_SIGACTION */

 /*
  * Fix-up any umask problems.  Most systems default
  * to 002 which is not too convenient for our purposes
  */
 orig_umask = umask(0);

 /*
  * Figure out primary network name
  */
 getwire(&PrimNetName, &PrimNetNum);

 /*
  * Determine command-line arguments.
  * (Also initialize amd.conf parameters, maps, and more.)
  */
 get_args(argc, argv);

 /*
  * Log version information.
  */
 vertmp = get_version_string();
 verstr = strtok(vertmp, "\n");
 plog(XLOG_INFO, "AM-UTILS VERSION INFORMATION:");
 while (verstr) {
   plog(XLOG_INFO, "%s", verstr);
   verstr = strtok(NULL, "\n");
 }
 XFREE(vertmp);

 /*
  * Get our own IP address so that we can mount the automounter.  We pass
  * localhost_address which could be used as the default localhost
  * name/address in amu_get_myaddress().
  */
 amu_get_myaddress(&myipaddr, gopt.localhost_address);
 plog(XLOG_INFO, "My ip addr is %s", inet_ntoa(myipaddr));

 /* avoid hanging on other NFS servers if started elsewhere */
 if (chdir("/") < 0)
   plog(XLOG_INFO, "cannot chdir to /: %m");

 /*
  * Now check we are root.
  */
 if (geteuid() != 0) {
   plog(XLOG_FATAL, "Must be root to mount filesystems (euid = %ld)", (long) geteuid());
   going_down(1);
   return 1;
 }

#ifdef HAVE_MAP_NIS
 /*
  * If the domain was specified then bind it here
  * to circumvent any default bindings that may
  * be done in the C library.
  */
 if (gopt.nis_domain && yp_bind(gopt.nis_domain)) {
   plog(XLOG_FATAL, "Can't bind to NIS domain \"%s\"", gopt.nis_domain);
   going_down(1);
   return 1;
 }
#endif /* HAVE_MAP_NIS */

 if (amuDebug(D_DAEMON))
   ppid = daemon_mode();

 /*
  * Lock process text and data segment in memory.
  */
 if (gopt.flags & CFM_PROCESS_LOCK) {
   do_memory_locking();
 }

 do_mapc_reload = clocktime(NULL) + gopt.map_reload_interval;

 /*
  * Register automounter with system.
  */
 error = mount_automounter(ppid);
 if (error && ppid)
   kill(ppid, SIGALRM);

#ifdef HAVE_FS_AUTOFS
 /*
  * XXX this should be part of going_down(), but I can't move it there
  * because it would be calling non-library code from the library... ugh
  */
 if (amd_use_autofs)
   destroy_autofs_service();
#endif /* HAVE_FS_AUTOFS */

 going_down(error);

 abort();
 return 1; /* should never get here */
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.