/mandos/release

/*  -*- coding: utf-8; mode: c; mode: orgtbl -*- */

/*

 * Mandos plugin runner - Run Mandos plugins

 *

 * Copyright © 2008-2015 Teddy Hogeborn

 * Copyright © 2008-2015 Björn Påhlsson

 * 

 * 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, either version 3 of the

 * License, or (at your option) any later version.

 * 

 * This program is distributed in the hope that it will 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, see

 * <http://www.gnu.org/licenses/>.

 * 

 * Contact the authors at <mandos@recompile.se>.

 */

#define _GNU_SOURCE		/* TEMP_FAILURE_RETRY(), getline(),

				   O_CLOEXEC, pipe2() */

#include <stddef.h>		/* size_t, NULL */

#include <stdlib.h>		/* malloc(), exit(), EXIT_SUCCESS,

				   realloc() */

#include <stdbool.h>		/* bool, true, false */

#include <stdio.h>		/* fileno(), fprintf(),

				   stderr, STDOUT_FILENO, fclose() */

#include <sys/types.h>	        /* fstat(), struct stat, waitpid(),

				   WIFEXITED(), WEXITSTATUS(), wait(),

				   pid_t, uid_t, gid_t, getuid(),

				   getgid() */

#include <sys/select.h>		/* fd_set, select(), FD_ZERO(),

				   FD_SET(), FD_ISSET(), FD_CLR */

#include <sys/wait.h>		/* wait(), waitpid(), WIFEXITED(),

				   WEXITSTATUS(), WTERMSIG(),

				   WCOREDUMP() */

#include <sys/stat.h>		/* struct stat, fstat(), S_ISREG() */

#include <iso646.h>		/* and, or, not */

#include <dirent.h>		/* struct dirent, scandirat() */

#include <unistd.h>		/* fcntl(), F_GETFD, F_SETFD,

				   FD_CLOEXEC, write(), STDOUT_FILENO,

				   struct stat, fstat(), close(),

				   setgid(), setuid(), S_ISREG(),

				   faccessat() pipe2(), fork(),

				   _exit(), dup2(), fexecve(), read()

				*/

#include <fcntl.h>		/* fcntl(), F_GETFD, F_SETFD,

				   FD_CLOEXEC, openat(), scandirat(),

				   pipe2() */

#include <string.h>		/* strsep, strlen(), strsignal(),

				   strcmp(), strncmp() */

#include <errno.h>		/* errno */

#include <argp.h>		/* struct argp_option, struct

				   argp_state, struct argp,

				   argp_parse(), ARGP_ERR_UNKNOWN,

				   ARGP_KEY_END, ARGP_KEY_ARG,

				   error_t */

#include <signal.h> 		/* struct sigaction, sigemptyset(),

				   sigaddset(), sigaction(),

				   sigprocmask(), SIG_BLOCK, SIGCHLD,

				   SIG_UNBLOCK, kill(), sig_atomic_t

				*/

#include <errno.h>		/* errno, EBADF */

#include <inttypes.h>		/* intmax_t, PRIdMAX, strtoimax() */

#include <sysexits.h>		/* EX_OSERR, EX_USAGE, EX_IOERR,

				   EX_CONFIG, EX_UNAVAILABLE, EX_OK */

#include <errno.h> 		/* errno */

#include <error.h>		/* error() */

#include <fnmatch.h>		/* fnmatch() */

#define BUFFER_SIZE 256

#define PDIR "/lib/mandos/plugins.d"

#define PHDIR "/lib/mandos/plugin-helpers"

#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"

const char *argp_program_version = "plugin-runner " VERSION;

const char *argp_program_bug_address = "<mandos@recompile.se>";

typedef struct plugin{

  char *name;			/* can be NULL or any plugin name */

  char **argv;

  int argc;

  char **environ;

  int envc;

  bool disabled;

  /* Variables used for running processes*/

  pid_t pid;

  int fd;

  char *buffer;

  size_t buffer_size;

  size_t buffer_length;

  bool eof;

  volatile sig_atomic_t completed;

  int status;

  struct plugin *next;

} plugin;

static plugin *plugin_list = NULL;

/* Gets an existing plugin based on name,

   or if none is found, creates a new one */

__attribute__((warn_unused_result))

static plugin *getplugin(char *name){

  /* Check for existing plugin with that name */

  for(plugin *p = plugin_list; p != NULL; p = p->next){

    if((p->name == name)

       or (p->name and name and (strcmp(p->name, name) == 0))){

      return p;

    }

  }

  /* Create a new plugin */

  plugin *new_plugin = NULL;

  do {

    new_plugin = malloc(sizeof(plugin));

  } while(new_plugin == NULL and errno == EINTR);

  if(new_plugin == NULL){

    return NULL;

  }

  char *copy_name = NULL;

  if(name != NULL){

    do {

      copy_name = strdup(name);

    } while(copy_name == NULL and errno == EINTR);

    if(copy_name == NULL){

      int e = errno;

      free(new_plugin);

      errno = e;

      return NULL;

    }

  }

  *new_plugin = (plugin){ .name = copy_name,

			  .argc = 1,

			  .disabled = false,

			  .next = plugin_list };

  do {

    new_plugin->argv = malloc(sizeof(char *) * 2);

  } while(new_plugin->argv == NULL and errno == EINTR);

  if(new_plugin->argv == NULL){

    int e = errno;

    free(copy_name);

    free(new_plugin);

    errno = e;

    return NULL;

  }

  new_plugin->argv[0] = copy_name;

  new_plugin->argv[1] = NULL;

  do {

    new_plugin->environ = malloc(sizeof(char *));

  } while(new_plugin->environ == NULL and errno == EINTR);

  if(new_plugin->environ == NULL){

    int e = errno;

    free(copy_name);

    free(new_plugin->argv);

    free(new_plugin);

    errno = e;

    return NULL;

  }

  new_plugin->environ[0] = NULL;

  /* Append the new plugin to the list */

  plugin_list = new_plugin;

  return new_plugin;

}

/* Helper function for add_argument and add_environment */

__attribute__((nonnull, warn_unused_result))

static bool add_to_char_array(const char *new, char ***array,

			      int *len){

  /* Resize the pointed-to array to hold one more pointer */

  char **new_array = NULL;

  do {

    new_array = realloc(*array, sizeof(char *)

			* (size_t) ((*len) + 2));

  } while(new_array == NULL and errno == EINTR);

  /* Malloc check */

  if(new_array == NULL){

    return false;

  }

  *array = new_array;

  /* Make a copy of the new string */

  char *copy;

  do {

    copy = strdup(new);

  } while(copy == NULL and errno == EINTR);

  if(copy == NULL){

    return false;

  }

  /* Insert the copy */

  (*array)[*len] = copy;

  (*len)++;

  /* Add a new terminating NULL pointer to the last element */

  (*array)[*len] = NULL;

  return true;

}

/* Add to a plugin's argument vector */

__attribute__((nonnull(2), warn_unused_result))

static bool add_argument(plugin *p, const char *arg){

  if(p == NULL){

    return false;

  }

  return add_to_char_array(arg, &(p->argv), &(p->argc));

}

/* Add to a plugin's environment */

__attribute__((nonnull(2), warn_unused_result))

static bool add_environment(plugin *p, const char *def, bool replace){

  if(p == NULL){

    return false;

  }

  /* namelen = length of name of environment variable */

  size_t namelen = (size_t)(strchrnul(def, '=') - def);

  /* Search for this environment variable */

  for(char **envdef = p->environ; *envdef != NULL; envdef++){

    if(strncmp(*envdef, def, namelen + 1) == 0){

      /* It already exists */

      if(replace){

	char *new_envdef;

	do {

	  new_envdef = realloc(*envdef, strlen(def) + 1);

	} while(new_envdef == NULL and errno == EINTR);

	if(new_envdef == NULL){

	  return false;

	}

	*envdef = new_envdef;

	strcpy(*envdef, def);

      }

      return true;

    }

  }

  return add_to_char_array(def, &(p->environ), &(p->envc));

}

#ifndef O_CLOEXEC

/*

 * Based on the example in the GNU LibC manual chapter 13.13 "File

 * Descriptor Flags".

 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |

 */

__attribute__((warn_unused_result))

static int set_cloexec_flag(int fd){

  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));

  /* If reading the flags failed, return error indication now. */

  if(ret < 0){

    return ret;

  }

  /* Store modified flag word in the descriptor. */

  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,

				       ret | FD_CLOEXEC));

}

#endif	/* not O_CLOEXEC */

/* Mark processes as completed when they exit, and save their exit

   status. */

static void handle_sigchld(__attribute__((unused)) int sig){

  int old_errno = errno;

  while(true){

    plugin *proc = plugin_list;

    int status;

    pid_t pid = waitpid(-1, &status, WNOHANG);

    if(pid == 0){

      /* Only still running child processes */

      break;

    }

    if(pid == -1){

      if(errno == ECHILD){

	/* No child processes */

	break;

      }

      error(0, errno, "waitpid");

    }

    /* A child exited, find it in process_list */

    while(proc != NULL and proc->pid != pid){

      proc = proc->next;

    }

    if(proc == NULL){

      /* Process not found in process list */

      continue;

    }

    proc->status = status;

    proc->completed = 1;

  }

  errno = old_errno;

}

/* Prints out a password to stdout */

__attribute__((nonnull, warn_unused_result))

static bool print_out_password(const char *buffer, size_t length){

  ssize_t ret;

  for(size_t written = 0; written < length; written += (size_t)ret){

    ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,

				   length - written));

    if(ret < 0){

      return false;

    }

  }

  return true;

}

/* Removes and free a plugin from the plugin list */

__attribute__((nonnull))

static void free_plugin(plugin *plugin_node){

  for(char **arg = plugin_node->argv; *arg != NULL; arg++){

    free(*arg);

  }

  free(plugin_node->argv);

  for(char **env = plugin_node->environ; *env != NULL; env++){

    free(*env);

  }

  free(plugin_node->environ);

  free(plugin_node->buffer);

  /* Removes the plugin from the singly-linked list */

  if(plugin_node == plugin_list){

    /* First one - simple */

    plugin_list = plugin_list->next;

  } else {

    /* Second one or later */

    for(plugin *p = plugin_list; p != NULL; p = p->next){

      if(p->next == plugin_node){

	p->next = plugin_node->next;

	break;

      }

    }

  }

  free(plugin_node);

}

static void free_plugin_list(void){

  while(plugin_list != NULL){

    free_plugin(plugin_list);

  }

}

int main(int argc, char *argv[]){

  char *plugindir = NULL;

  char *pluginhelperdir = NULL;

  char *argfile = NULL;

  FILE *conffp;

  struct dirent **direntries = NULL;

  struct stat st;

  fd_set rfds_all;

  int ret, maxfd = 0;

  ssize_t sret;

  uid_t uid = 65534;

  gid_t gid = 65534;

  bool debug = false;

  int exitstatus = EXIT_SUCCESS;

  struct sigaction old_sigchld_action;

  struct sigaction sigchld_action = { .sa_handler = handle_sigchld,

				      .sa_flags = SA_NOCLDSTOP };

  char **custom_argv = NULL;

  int custom_argc = 0;

  int dir_fd = -1;

  /* Establish a signal handler */

  sigemptyset(&sigchld_action.sa_mask);

  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);

  if(ret == -1){

    error(0, errno, "sigaddset");

    exitstatus = EX_OSERR;

    goto fallback;

  }

  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);

  if(ret == -1){

    error(0, errno, "sigaction");

    exitstatus = EX_OSERR;

    goto fallback;

  }

  /* The options we understand. */

  struct argp_option options[] = {

    { .name = "global-options", .key = 'g',

      .arg = "OPTION[,OPTION[,...]]",

      .doc = "Options passed to all plugins" },

    { .name = "global-env", .key = 'G',

      .arg = "VAR=value",

      .doc = "Environment variable passed to all plugins" },

    { .name = "options-for", .key = 'o',

      .arg = "PLUGIN:OPTION[,OPTION[,...]]",

      .doc = "Options passed only to specified plugin" },

    { .name = "env-for", .key = 'E',

      .arg = "PLUGIN:ENV=value",

      .doc = "Environment variable passed to specified plugin" },

    { .name = "disable", .key = 'd',

      .arg = "PLUGIN",

      .doc = "Disable a specific plugin", .group = 1 },

    { .name = "enable", .key = 'e',

      .arg = "PLUGIN",

      .doc = "Enable a specific plugin", .group = 1 },

    { .name = "plugin-dir", .key = 128,

      .arg = "DIRECTORY",

      .doc = "Specify a different plugin directory", .group = 2 },

    { .name = "config-file", .key = 129,

      .arg = "FILE",

      .doc = "Specify a different configuration file", .group = 2 },

    { .name = "userid", .key = 130,

      .arg = "ID", .flags = 0,

      .doc = "User ID the plugins will run as", .group = 3 },

    { .name = "groupid", .key = 131,

      .arg = "ID", .flags = 0,

      .doc = "Group ID the plugins will run as", .group = 3 },

    { .name = "debug", .key = 132,

      .doc = "Debug mode", .group = 4 },

    { .name = "plugin-helper-dir", .key = 133,

      .arg = "DIRECTORY",

      .doc = "Specify a different plugin helper directory",

      .group = 2 },

    /*

     * These reproduce what we would get without ARGP_NO_HELP

     */

    { .name = "help", .key = '?',

      .doc = "Give this help list", .group = -1 },

    { .name = "usage", .key = -3,

      .doc = "Give a short usage message", .group = -1 },

    { .name = "version", .key = 'V',

      .doc = "Print program version", .group = -1 },

    { .name = NULL }

  };

  __attribute__((nonnull(3)))

  error_t parse_opt(int key, char *arg, struct argp_state *state){

    errno = 0;

    switch(key){

      char *tmp;

      intmax_t tmp_id;

    case 'g': 			/* --global-options */

      {

	char *plugin_option;

	while((plugin_option = strsep(&arg, ",")) != NULL){

	  if(not add_argument(getplugin(NULL), plugin_option)){

	    break;

	  }

	}

	errno = 0;

      }

      break;

    case 'G':			/* --global-env */

      if(add_environment(getplugin(NULL), arg, true)){

	errno = 0;

      }

      break;

    case 'o':			/* --options-for */

      {

	char *option_list = strchr(arg, ':');

	if(option_list == NULL){

	  argp_error(state, "No colon in \"%s\"", arg);

	  errno = EINVAL;

	  break;

	}

	*option_list = '\0';

	option_list++;

	if(arg[0] == '\0'){

	  argp_error(state, "Empty plugin name");

	  errno = EINVAL;

	  break;

	}

	char *option;

	while((option = strsep(&option_list, ",")) != NULL){

	  if(not add_argument(getplugin(arg), option)){

	    break;

	  }

	}

	errno = 0;

      }

      break;

    case 'E':			/* --env-for */

      {

	char *envdef = strchr(arg, ':');

	if(envdef == NULL){

	  argp_error(state, "No colon in \"%s\"", arg);

	  errno = EINVAL;

	  break;

	}

	*envdef = '\0';

	envdef++;

	if(arg[0] == '\0'){

	  argp_error(state, "Empty plugin name");

	  errno = EINVAL;

	  break;

	}

	if(add_environment(getplugin(arg), envdef, true)){

	  errno = 0;

	}

      }

      break;

    case 'd':			/* --disable */

      {

	plugin *p = getplugin(arg);

	if(p != NULL){

	  p->disabled = true;

	  errno = 0;

	}

      }

      break;

    case 'e':			/* --enable */