inetd.c

压缩包中包含LINUX下多个命令的源码

/*
 * Copyright (c) 1983, 1991, 1993, 1994, 2002
 *	The Regents of the University of California.  All rights reserved.
 *
 * 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.
 * 4. 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.
 */

#if 0
static char sccsid[] = "@(#)inetd.c	8.4 (Berkeley) 4/13/94";
#endif

/*
 * Inetd - Internet super-server
 *
 * This program invokes all internet services as needed.  Connection-oriented
 * services are invoked each time a connection is made, by creating a process.
 * This process is passed the connection as file descriptor 0 and is expected
 * to do a getpeername to find out the source host and port.
 *
 * Datagram oriented services are invoked when a datagram
 * arrives; a process is created and passed a pending message
 * on file descriptor 0.  Datagram servers may either connect
 * to their peer, freeing up the original socket for inetd
 * to receive further messages on, or ``take over the socket'',
 * processing all arriving datagrams and, eventually, timing
 * out.	 The first type of server is said to be ``multi-threaded'';
 * the second type of server ``single-threaded''.
 *
 * Inetd uses a configuration file which is read at startup
 * and, possibly, at some later time in response to a hangup signal.
 * The configuration file is ``free format'' with fields given in the
 * order shown below.  Continuation lines for an entry must being with
 * a space or tab.  All fields must be present in each entry.
 *
 *	service name			must be in /etc/services or must
 *					name a tcpmux service
 *	socket type			stream/dgram/raw/rdm/seqpacket
 *	protocol			must be in /etc/protocols
 *	wait/nowait			single-threaded/multi-threaded
 *	user				user to run daemon as
 *	server program			full path name
 *	server program arguments	maximum of MAXARGS (20)
 *
 * TCP services without official port numbers are handled with the
 * RFC1078-based tcpmux internal service. Tcpmux listens on port 1 for
 * requests. When a connection is made from a foreign host, the service
 * requested is passed to tcpmux, which looks it up in the servtab list
 * and returns the proper entry for the service. Tcpmux returns a
 * negative reply if the service doesn't exist, otherwise the invoked
 * server is expected to return the positive reply if the service type in
 * inetd.conf file has the prefix "tcpmux/". If the service type has the
 * prefix "tcpmux/+", tcpmux will return the positive reply for the
 * process; this is for compatibility with older server code, and also
 * allows you to invoke programs that use stdin/stdout without putting any
 * special server code in them. Services that use tcpmux are "nowait"
 * because they do not have a well-known port and hence cannot listen
 * for new requests.
 *
 * Comment lines are indicated by a `#' in column 1.
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <sys/types.h>
#include <sys/param.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#ifdef HAVE_SYS_WAIT_H
#include <sys/wait.h>
#endif
#ifdef TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# ifdef HAVE_SYS_TIME_H
#  include <sys/time.h>
# else
#  include <time.h>
# endif
#endif
#ifdef HAVE_SYS_RESOURCE_H
#include <sys/resource.h>
#endif

#include <netinet/in.h>
#include <arpa/inet.h>

#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <netdb.h>
#include <pwd.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>
#include <unistd.h>
#include <getopt.h>
#ifdef HAVE_SYS_SELECT_H
#include <sys/select.h>
#endif
#include <grp.h>

#define	TOOMANY		40		/* don't start more than TOOMANY */
#define	CNT_INTVL	60		/* servers in CNT_INTVL sec. */
#define	RETRYTIME	(60*10)		/* retry after bind or server fail */

#ifndef SIGCHLD
#define SIGCHLD	SIGCLD
#endif
#define	SIGBLOCK	(sigmask(SIGCHLD)|sigmask(SIGHUP)|sigmask(SIGALRM))

extern char *__progname;

int	debug = 0;
int	nsock, maxsock;
fd_set	allsock;
int	options;
int	timingout;
int	toomany = TOOMANY;
struct	servent *sp;

struct	servtab {
  char	*se_service;		/* name of service */
  int	se_socktype;		/* type of socket to use */
  char	*se_proto;		/* protocol used */
  short	se_wait;		/* single threaded server */
  short	se_checked;		/* looked at during merge */
  char	*se_user;		/* user name to run as */
  struct biltin *se_bi;		/* if built-in, description */
  char	*se_server;		/* server program */
#define	MAXARGV 20
  char	*se_argv[MAXARGV+1];	/* program arguments */
  int	se_fd;			/* open descriptor */
  int	se_type;		/* type */
  struct sockaddr_in se_ctrladdr;/* bound address */
  int	se_count;		/* number started since se_time */
  struct	timeval se_time;	/* start of se_count */
  struct	servtab *se_next;
} *servtab;

#define NORM_TYPE	0
#define MUX_TYPE	1
#define MUXPLUS_TYPE	2
#define ISMUX(sep)	(((sep)->se_type == MUX_TYPE) || \
			 ((sep)->se_type == MUXPLUS_TYPE))
#define ISMUXPLUS(sep)	((sep)->se_type == MUXPLUS_TYPE)


void		chargen_dg __P((int, struct servtab *));
void		chargen_stream __P((int, struct servtab *));
void		close_sep __P((struct servtab *));
void		config __P((int));
void		daytime_dg __P((int, struct servtab *));
void		daytime_stream __P((int, struct servtab *));
void		discard_dg __P((int, struct servtab *));
void		discard_stream __P((int, struct servtab *));
void		echo_dg __P((int, struct servtab *));
void		echo_stream __P((int, struct servtab *));
void		endconfig __P((FILE *));
struct servtab *enter __P((struct servtab *));
void		freeconfig __P((struct servtab *));
struct servtab *getconfigent __P((FILE *, const char *));
void		machtime_dg __P((int, struct servtab *));
void		machtime_stream __P((int, struct servtab *));
char	       *newstr __P((const char *));
char	       *nextline __P((FILE *));
void		nextconfig __P((const char *));
void		print_service __P((const char *, const char *, struct servtab *));
void		reapchild __P((int));
void		retry __P((int));
FILE           *setconfig __P((const char *));
void		setup __P((struct servtab *));
char	       *sskip __P((char **, FILE *, const char *));
char	       *skip __P((char **, FILE *));
void		tcpmux __P((int s, struct servtab *sep));
void		set_proc_title __P ((char *, int));
void		initring __P((void));
long		machtime __P((void));
void            run_service __P ((int ctrl, struct servtab *sep));

struct biltin {
  const char	*bi_service;	/* internally provided service name */
  int	bi_socktype;		/* type of socket supported */
  short	bi_fork;		/* 1 if should fork before call */
  short	bi_wait;		/* 1 if should wait for child */
  void	(*bi_fn) __P((int s, struct servtab *)); /*function which performs it */
} biltins[] = {
  /* Echo received data */
  { "echo",	SOCK_STREAM,	1, 0,	echo_stream },
  { "echo",	SOCK_DGRAM,	0, 0,	echo_dg },

  /* Internet /dev/null */
  { "discard",	SOCK_STREAM,	1, 0,	discard_stream },
  { "discard",	SOCK_DGRAM,	0, 0,	discard_dg },

  /* Return 32 bit time since 1970 */
  { "time",	SOCK_STREAM,	0, 0,	machtime_stream },
  { "time",	SOCK_DGRAM,	0, 0,	machtime_dg },

  /* Return human-readable time */
  { "daytime",	SOCK_STREAM,	0, 0,	daytime_stream },
  { "daytime",	SOCK_DGRAM,	0, 0,	daytime_dg },

  /* Familiar character generator */
  { "chargen",	SOCK_STREAM,	1, 0,	chargen_stream },
  { "chargen",	SOCK_DGRAM,	0, 0,	chargen_dg },

  { "tcpmux",	SOCK_STREAM,	1, 0,	tcpmux },

  { NULL, 0, 0, 0, NULL }
};

#define NUMINT	(sizeof(intab) / sizeof(struct inent))
char	**Argv;
char 	*LastArg;

char **config_files;

static void
usage (int err)
{
  if (err != 0)
    {
      fprintf (stderr, "Usage: %s [OPTION...] [CONF-FILE [CONF-DIR]] ...\n",
	       __progname);
      fprintf (stderr, "Try `%s --help' for more information.\n", __progname);
    }
  else
    {
      fprintf (stdout, "Usage: %s [OPTION...] [CONF-FILE [CONF-DIR]] ...\n",
	       __progname);
      puts ("Internet super-server.\n\n\
  -d, --debug               Debug mode\n\
  -R, --rate NUMBER         Maximum invocation rate (per second)\n\
      --help                Display this help and exit\n\
  -V, --version             Output version information and exit");

      fprintf (stdout, "\nSubmit bug reports to %s.\n", PACKAGE_BUGREPORT);
    }
  exit (err);
}

static const char *short_options = "dR:V";
static struct option long_options[] =
{
  { "debug", no_argument, 0, 'd' },
  { "rate", required_argument, 0, 'R' },
  { "help", no_argument, 0, '&' },
  { "version", no_argument, 0, 'V' },
  { 0, 0, 0, 0 }
};

int
main (int argc, char *argv[], char *envp[])
{
  int option;
  struct servtab *sep;
  int dofork;
  pid_t pid;

#ifndef HAVE___PROGNAME
  __progname = argv[0];
#endif

  Argv = argv;
  if (envp == 0 || *envp == 0)
    envp = argv;
  while (*envp)
    envp++;
  LastArg = envp[-1] + strlen (envp[-1]);

  while ((option = getopt_long (argc, argv, short_options,
				long_options, 0)) != EOF)
    {
      switch (option)
	{
	case 'd': /* Debug.  */
	  debug = 1;
	  options |= SO_DEBUG;
	  break;

	case 'R': /* Invocation rate.  */
	  {
	    char *p;
	    int number;
	    number = strtol (optarg, &p, 0);
	    if (number < 1 || *p)
	      syslog (LOG_ERR,
		      "-R %s: bad value for service invocation rate",
		      optarg);
	    else
	      toomany = number;
	    break;
	  }

	case '&': /* Usage.  */
	  usage (0);
	  /* Not reached.  */

	case 'V': /* Version.  */
	  printf ("inetd (%s) %s\n", PACKAGE_NAME, PACKAGE_VERSION);
	  exit (0);
	  /* Not reached.  */

	case '?':
	default:
	  usage (1);
	  /* Not reached.  */
	}
    }

  if (optind < argc)
    {
      int i;
      config_files = calloc (argc - optind + 1, sizeof (*config_files));
      for (i = 0; optind < argc; optind++, i++)
	{
	  config_files[i] = strdup (argv[optind]);
	}
    }
  else
    {
      config_files = calloc (3, sizeof (*config_files));
      config_files[0] = newstr (PATH_INETDCONF);
      config_files[1] = newstr (PATH_INETDDIR);
    }

  if (debug == 0)
    {
      daemon (0, 0);
    }

  openlog ("inetd", LOG_PID | LOG_NOWAIT, LOG_DAEMON);

#if defined(HAVE_SIGACTION)
  {
    struct sigaction sa;
    memset ((char *)&sa, 0, sizeof(sa));
    sigemptyset (&sa.sa_mask);
    sigaddset (&sa.sa_mask, SIGCHLD);
    sigaddset (&sa.sa_mask, SIGHUP);
    sigaddset (&sa.sa_mask, SIGALRM);
#ifdef SA_RESTART
    sa.sa_flags = SA_RESTART;
#endif
    sa.sa_handler = retry;
    sigaction (SIGALRM, &sa, (struct sigaction *)0);
    config (0);
    sa.sa_handler = config;
    sigaction (SIGHUP, &sa, (struct sigaction *)0);
    sa.sa_handler = reapchild;
    sigaction (SIGCHLD, &sa, (struct sigaction *)0);
    sa.sa_handler = SIG_IGN;
    sigaction (SIGPIPE, &sa, (struct sigaction *)0);
  }
#elif defined(HAVE_SIGVEC)
  {
    struct sigvec sv;
    memset (&sv, 0, sizeof(sv));
    sv.sv_mask = SIGBLOCK;
    sv.sv_handler = retry;
    sigvec (SIGALRM, &sv, (struct sigvec *)0);
    config (0);
    sv.sv_handler = config;
    sigvec (SIGHUP, &sv, (struct sigvec *)0);
    sv.sv_handler = reapchild;
    sigvec (SIGCHLD, &sv, (struct sigvec *)0);
    sv.sv_mask = 0L;
    sv.sv_handler = SIG_IGN;
    sigvec (SIGPIPE, &sv, (struct sigvec *)0);
  }
#else /* !HAVE_SIGVEC */
  signal (SIGALRM, retry);
  config (0);
  signal (SIGHUP, config);
  signal (SIGCHLD, reapchild);
  signal (SIGPIPE, SIG_IGN);
#endif /* HAVE_SIGACTION */

  {
    /* space for daemons to overwrite environment for ps */
#define	DUMMYSIZE	100
    char dummy[DUMMYSIZE];

    (void)memset(dummy, 'x', DUMMYSIZE - 1);
    dummy[DUMMYSIZE - 1] = '\0';
    (void)setenv("inetd_dummy", dummy, 1);
  }

  for (;;)
    {
      int n, ctrl;
      fd_set readable;

      if (nsock == 0)
	{
#ifdef HAVE_SIGACTION
	  {
	    sigset_t sigs;
	    sigemptyset (&sigs);
	    sigaddset (&sigs, SIGCHLD);
	    sigaddset (&sigs, SIGHUP);
	    sigaddset (&sigs, SIGALRM);
	    sigprocmask (SIG_BLOCK, &sigs, 0);
	  }
#else
	  (void) sigblock (SIGBLOCK);
#endif
	  while (nsock == 0)
	    sigpause (0L);
#ifdef HAVE_SIGACTION
	  {
	    sigset_t empty;
	    sigemptyset (&empty);
	    sigprocmask (SIG_SETMASK, &empty, 0);
	  }
#else
	  (void) sigsetmask (0L);
#endif
	}
      readable = allsock;
      if ((n = select (maxsock + 1, &readable, (fd_set *)0,
		      (fd_set *)0, (struct timeval *)0)) <= 0)
	{
	  if (n < 0 && errno != EINTR)
	    syslog (LOG_WARNING, "select: %m");
	  sleep (1);
	  continue;
	}
      for (sep = servtab; n && sep; sep = sep->se_next)
	if (sep->se_fd != -1 && FD_ISSET (sep->se_fd, &readable))
	  {
	    n--;
	    if (debug)
	      fprintf (stderr, "someone wants %s\n", sep->se_service);
	    if (!sep->se_wait && sep->se_socktype == SOCK_STREAM)
	      {
		ctrl = accept (sep->se_fd, (struct sockaddr *)0, (int *)0);
		if (debug)
		  fprintf (stderr, "accept, ctrl %d\n", ctrl);
		if (ctrl < 0)
		  {
		    if (errno != EINTR)
		      syslog (LOG_WARNING, "accept (for %s): %m",
			      sep->se_service);
		    continue;
		  }
	      }
	    else
	      ctrl = sep->se_fd;
#ifdef HAVE_SIGACTION
	    {
	      sigset_t sigs;
	      sigemptyset (&sigs);
	      sigaddset (&sigs, SIGCHLD);
	      sigaddset (&sigs, SIGHUP);
	      sigaddset (&sigs, SIGALRM);
	      sigprocmask (SIG_BLOCK, &sigs, 0);
	    }
#else
	    (void) sigblock (SIGBLOCK);
#endif
	    pid = 0;
	    dofork = (sep->se_bi == 0 || sep->se_bi->bi_fork);
	    if (dofork)
	      {
		if (sep->se_count++ == 0)
		  (void)gettimeofday (&sep->se_time, (struct timezone *)0);
		else if (sep->se_count >= toomany)
		  {
		    struct timeval now;

		    (void)gettimeofday (&now, (struct timezone *)0);
		    if (now.tv_sec - sep->se_time.tv_sec > CNT_INTVL)
		      {
			sep->se_time = now;
			sep->se_count = 1;
		      }
		    else
		      {
			syslog (LOG_ERR,
				"%s/%s server failing (looping), service terminated",
				sep->se_service, sep->se_proto);
			close_sep (sep);
#ifdef HAVE_SIGACTION
			{
			  sigset_t empty;
			  sigemptyset (&empty);
			  sigprocmask (SIG_SETMASK, &empty, 0);
			}
#else
			sigsetmask (0L);
#endif
			if (!timingout)
			  {