/mandos/release

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/release

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2019-02-09 23:23:26 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 370.
  • Revision ID: teddy@recompile.se-20190209232326-z1z2kzpgfixz7iaj
Add support for using raw public keys in TLS (RFC 7250)

Since GnuTLS removed support for OpenPGP keys in TLS (RFC 6091), and
no other library supports it, we have to change the protocol to use
something else.  We choose to use "raw public keys" (RFC 7250).  Since
we still use OpenPGP keys to decrypt the secret password, this means
that each client will have two keys: One OpenPGP key and one TLS
public/private key, and the key ID of the latter key is used to
identify clients instead of the fingerprint of the OpenPGP key.

Note that this code is still compatible with GnuTLS before version
3.6.0 (when OpenPGP key support was removed).  This commit merely adds
support for using raw pulic keys instead with GnuTLS 3.6.6. or later.

* DBUS-API (Signals/ClientNotFound): Change name of first parameter
                                     from "Fingerprint" to "KeyID".
  (Mandos Client Interface/Properties/KeyID): New.
* INSTALL: Document conflict with GnuTLS 3.6.0 (which removed OpenPGP
           key support) up until 3.6.6, when support for raw public
           keys was added.  Also document new dependency of client on
           "gnutls-bin" package (for certtool).
* Makefile (run-client): Depend on TLS key files, and also pass them
                         as arguments to client.
  (keydir/tls-privkey.pem, keydir/tls-pubkey.pem): New.
  (confdir/clients.conf): Add dependency on TLS public key.
  (purge-client): Add removal of TLS key files.
* clients.conf ([foo]/key_id, [bar]/key_id): New.
* debian/control (Source: mandos/Build-Depends): Also allow
                                                 libgnutls30 (>= 3.6.6)
  (Package: mandos/Depends): - '' -
  (Package: mandos/Description): Alter description to match new
                                 design.
  (Package: mandos-client/Description): - '' -
  (Package: mandos-client/Depends): Move "gnutls-bin | openssl" to
                                    here from "Recommends".
* debian/mandos-client.README.Debian: Add --tls-privkey and
                                      --tls-pubkey options to test
                                      command.
* debian/mandos-client.postinst (create_key): Renamed to "create_keys"
                                             (all callers changed),
                                             and also create TLS key.
* debian/mandos-client.postrm (purge): Also remove TLS key files.
* intro.xml (DESCRIPTION): Describe new dual-key design.
* mandos (GnuTLS): Define different functions depending on whether
                   support for raw public keys is detected.
  (Client.key_id): New attribute.
  (ClientDBus.KeyID_dbus_property): New method.
  (ProxyClient.__init__): Take new "key_id" parameter.
  (ClientHandler.handle): Use key IDs when using raw public keys and
                          use fingerprints when using OpenPGP keys.
  (ClientHandler.peer_certificate): Also handle raw public keys.
  (ClientHandler.key_id): New.
  (MandosServer.handle_ipc): Pass key ID over the pipe IPC.  Also
                             check for key ID matches when looking up
                             clients.
  (main): Default GnuTLS priority string depends on whether we are
          using raw public keys or not.  When unpickling clients, set
          key_id if not set in the pickle.
  (main/MandosDBusService.ClientNotFound): Change name of first
                                           parameter from
                                           "Fingerprint" to "KeyID".
* mandos-clients.conf.xml (OPTIONS): Document new "key_id" option.
  (OPTIONS/secret): Mention new key ID matchning.
  (EXPANSION/RUNTIME EXPANSION): Add new "key_id" option.
  (EXAMPLE): - '' -
* mandos-ctl (tablewords, main/keywords): Add new "KeyID" property.
* mandos-keygen: Create TLS key files.  New "--tls-keytype" (-T)
                 option.  Alter help text to be more clear about key
                 types.  When in password mode, also output "key_id"
                 option.
* mandos-keygen.xml (SYNOPSIS): Add new "--tls-keytype" (-T) option.
  (DESCRIPTION): Alter to match new dual-key design.
  (OVERVIEW): - '' -
  (FILES): Add TLS key files.
* mandos-options.xml (priority): Document new default priority string
                                 when using raw public keys.
* mandos.xml (NETWORK PROTOCOL): Describe new protocol using key ID.
  (BUGS): Remove issue about checking expire times of OpenPGP keys,
          since TLS public keys do not have expiration times.
  (SECURITY/CLIENT): Alter description to match new design.
  (SEE ALSO/GnuTLS): - '' -
  (SEE ALSO): Add reference to RFC 7250, and alter description of when
              RFC 6091 is used.
* overview.xml: Alter text to match new design.
* plugin-runner.xml (EXAMPLE): Add --tls-pubkey and --tls-privkey
                               options to mandos-client options.
* plugins.d/mandos-client.c: Use raw public keys when compiling with
                             supporting GnuTLS versions. Add new
                             "--tls-pubkey" and "--tls-privkey"
                             options (which do nothing if GnuTLS
                             library does not support raw public
                             keys).  Alter text throughout to reflect
                             new design.  Only generate new DH
                             parameters (based on size of OpenPGP key)
                             when using OpenPGP in TLS.  Default
                             GnuTLS priority string depends on whether
                             we are using raw public keys or not.
* plugins.d/mandos-client.xml (SYNOPSIS): Add new "--tls-privkey" (-t)
                                          and "--tls-pubkey" (-T)
                                          options.
  (DESCRIPTION): Describe new dual-key design.
  (OPTIONS): Document new "--tls-privkey" (-t) and "--tls-pubkey" (-T)
             options.
  (OPTIONS/--dh-bits): No longer necessarily depends on OpenPGP key
                       size.
  (FILES): Add default locations for TLS public and private key files.
  (EXAMPLE): Use new --tls-pubkey and --tls-privkey options.
  (SECURITY): Alter wording slightly to reflect new dual-key design.
  (SEE ALSO/GnuTLS): Alter description to match new design.
  (SEE ALSO): Add reference to RFC 7250, and alter description of when
              RFC 6091 is used.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin-runner.c
1
 
/*  -*- coding: utf-8 -*- */
 
1
/*  -*- coding: utf-8; mode: c; mode: orgtbl -*- */
2
2
/*
3
3
 * Mandos plugin runner - Run Mandos plugins
4
4
 *
5
 
 * Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
6
 
 * 
7
 
 * This program is free software: you can redistribute it and/or
8
 
 * modify it under the terms of the GNU General Public License as
9
 
 * published by the Free Software Foundation, either version 3 of the
10
 
 * License, or (at your option) any later version.
11
 
 * 
12
 
 * This program is distributed in the hope that it will be useful, but
 
5
 * Copyright © 2008-2018 Teddy Hogeborn
 
6
 * Copyright © 2008-2018 Björn Påhlsson
 
7
 * 
 
8
 * This file is part of Mandos.
 
9
 * 
 
10
 * Mandos is free software: you can redistribute it and/or modify it
 
11
 * under the terms of the GNU General Public License as published by
 
12
 * the Free Software Foundation, either version 3 of the License, or
 
13
 * (at your option) any later version.
 
14
 * 
 
15
 * Mandos is distributed in the hope that it will be useful, but
13
16
 * WITHOUT ANY WARRANTY; without even the implied warranty of
14
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
18
 * General Public License for more details.
16
19
 * 
17
20
 * You should have received a copy of the GNU General Public License
18
 
 * along with this program.  If not, see
19
 
 * <http://www.gnu.org/licenses/>.
 
21
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
20
22
 * 
21
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
23
 * Contact the authors at <mandos@recompile.se>.
22
24
 */
23
25
 
24
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline() */
25
 
 
 
26
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
 
27
                                   O_CLOEXEC, pipe2() */
26
28
#include <stddef.h>             /* size_t, NULL */
27
 
#include <stdlib.h>             /* malloc(), exit(), EXIT_FAILURE,
28
 
                                   EXIT_SUCCESS, realloc() */
 
29
#include <stdlib.h>             /* malloc(), exit(), EXIT_SUCCESS,
 
30
                                   realloc() */
29
31
#include <stdbool.h>            /* bool, true, false */
30
 
#include <stdio.h>              /* perror, popen(), fileno(),
31
 
                                   fprintf(), stderr, STDOUT_FILENO */
32
 
#include <sys/types.h>          /* DIR, opendir(), stat(), struct
33
 
                                   stat, waitpid(), WIFEXITED(),
34
 
                                   WEXITSTATUS(), wait(), pid_t,
35
 
                                   uid_t, gid_t, getuid(), getgid(),
36
 
                                   dirfd() */
 
32
#include <stdio.h>              /* fileno(), fprintf(),
 
33
                                   stderr, STDOUT_FILENO, fclose() */
 
34
#include <sys/types.h>          /* fstat(), struct stat, waitpid(),
 
35
                                   WIFEXITED(), WEXITSTATUS(), wait(),
 
36
                                   pid_t, uid_t, gid_t, getuid(),
 
37
                                   getgid() */
37
38
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
38
39
                                   FD_SET(), FD_ISSET(), FD_CLR */
39
40
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
40
 
                                   WEXITSTATUS() */
41
 
#include <sys/stat.h>           /* struct stat, stat(), S_ISREG() */
 
41
                                   WEXITSTATUS(), WTERMSIG() */
 
42
#include <sys/stat.h>           /* struct stat, fstat(), S_ISREG() */
42
43
#include <iso646.h>             /* and, or, not */
43
 
#include <dirent.h>             /* DIR, struct dirent, opendir(),
44
 
                                   readdir(), closedir(), dirfd() */
45
 
#include <unistd.h>             /* struct stat, stat(), S_ISREG(),
46
 
                                   fcntl(), setuid(), setgid(),
47
 
                                   F_GETFD, F_SETFD, FD_CLOEXEC,
48
 
                                   access(), pipe(), fork(), close()
49
 
                                   dup2, STDOUT_FILENO, _exit(),
50
 
                                   execv(), write(), read(),
51
 
                                   close() */
 
44
#include <dirent.h>             /* struct dirent, scandirat() */
 
45
#include <unistd.h>             /* fcntl(), F_GETFD, F_SETFD,
 
46
                                   FD_CLOEXEC, write(), STDOUT_FILENO,
 
47
                                   struct stat, fstat(), close(),
 
48
                                   setgid(), setuid(), S_ISREG(),
 
49
                                   faccessat() pipe2(), fork(),
 
50
                                   _exit(), dup2(), fexecve(), read()
 
51
                                */
52
52
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
53
 
                                   FD_CLOEXEC */
54
 
#include <string.h>             /* strsep, strlen(), strcpy(),
55
 
                                   strcat() */
 
53
                                   FD_CLOEXEC, openat(), scandirat(),
 
54
                                   pipe2() */
 
55
#include <string.h>             /* strsep, strlen(), strsignal(),
 
56
                                   strcmp(), strncmp() */
56
57
#include <errno.h>              /* errno */
57
58
#include <argp.h>               /* struct argp_option, struct
58
59
                                   argp_state, struct argp,
59
60
                                   argp_parse(), ARGP_ERR_UNKNOWN,
60
 
                                   ARGP_KEY_END, ARGP_KEY_ARG, error_t */
 
61
                                   ARGP_KEY_END, ARGP_KEY_ARG,
 
62
                                   error_t */
61
63
#include <signal.h>             /* struct sigaction, sigemptyset(),
62
64
                                   sigaddset(), sigaction(),
63
65
                                   sigprocmask(), SIG_BLOCK, SIGCHLD,
64
 
                                   SIG_UNBLOCK, kill() */
 
66
                                   SIG_UNBLOCK, kill(), sig_atomic_t
 
67
                                */
65
68
#include <errno.h>              /* errno, EBADF */
 
69
#include <inttypes.h>           /* intmax_t, PRIdMAX, strtoimax() */
 
70
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_IOERR,
 
71
                                   EX_CONFIG, EX_UNAVAILABLE, EX_OK */
 
72
#include <errno.h>              /* errno */
 
73
#include <error.h>              /* error() */
 
74
#include <fnmatch.h>            /* fnmatch() */
66
75
 
67
76
#define BUFFER_SIZE 256
68
 
#define ARGFILE "/conf/conf.d/mandos/plugin-runner.conf"
69
 
 
70
 
const char *argp_program_version = "plugin-runner 1.0";
71
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
72
 
 
73
 
struct process;
74
 
 
75
 
typedef struct process{
 
77
 
 
78
#define PDIR "/lib/mandos/plugins.d"
 
79
#define PHDIR "/lib/mandos/plugin-helpers"
 
80
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
 
81
 
 
82
const char *argp_program_version = "plugin-runner " VERSION;
 
83
const char *argp_program_bug_address = "<mandos@recompile.se>";
 
84
 
 
85
typedef struct plugin{
 
86
  char *name;                   /* can be NULL or any plugin name */
 
87
  char **argv;
 
88
  int argc;
 
89
  char **environ;
 
90
  int envc;
 
91
  bool disabled;
 
92
  
 
93
  /* Variables used for running processes*/
76
94
  pid_t pid;
77
95
  int fd;
78
96
  char *buffer;
79
97
  size_t buffer_size;
80
98
  size_t buffer_length;
81
99
  bool eof;
82
 
  bool completed;
 
100
  volatile sig_atomic_t completed;
83
101
  int status;
84
 
  struct process *next;
85
 
} process;
86
 
 
87
 
typedef struct plugin{
88
 
  char *name;                   /* can be NULL or any plugin name */
89
 
  char **argv;
90
 
  int argc;
91
 
  bool disabled;
92
102
  struct plugin *next;
93
103
} plugin;
94
104
 
95
 
static plugin *getplugin(char *name, plugin **plugin_list){
96
 
  for (plugin *p = *plugin_list; p != NULL; p = p->next){
97
 
    if ((p->name == name)
98
 
        or (p->name and name and (strcmp(p->name, name) == 0))){
 
105
static plugin *plugin_list = NULL;
 
106
 
 
107
/* Gets an existing plugin based on name,
 
108
   or if none is found, creates a new one */
 
109
__attribute__((warn_unused_result))
 
110
static plugin *getplugin(char *name){
 
111
  /* Check for existing plugin with that name */
 
112
  for(plugin *p = plugin_list; p != NULL; p = p->next){
 
113
    if((p->name == name)
 
114
       or (p->name and name and (strcmp(p->name, name) == 0))){
99
115
      return p;
100
116
    }
101
117
  }
102
118
  /* Create a new plugin */
103
 
  plugin *new_plugin = malloc(sizeof(plugin));
104
 
  if (new_plugin == NULL){
105
 
    perror("malloc");
106
 
    exit(EXIT_FAILURE);
107
 
  }
108
 
  new_plugin->name = name;
109
 
  new_plugin->argv = malloc(sizeof(char *) * 2);
110
 
  if (new_plugin->argv == NULL){
111
 
    perror("malloc");
112
 
    exit(EXIT_FAILURE);
113
 
  }
114
 
  new_plugin->argv[0] = name;
 
119
  plugin *new_plugin = NULL;
 
120
  do {
 
121
    new_plugin = malloc(sizeof(plugin));
 
122
  } while(new_plugin == NULL and errno == EINTR);
 
123
  if(new_plugin == NULL){
 
124
    return NULL;
 
125
  }
 
126
  char *copy_name = NULL;
 
127
  if(name != NULL){
 
128
    do {
 
129
      copy_name = strdup(name);
 
130
    } while(copy_name == NULL and errno == EINTR);
 
131
    if(copy_name == NULL){
 
132
      int e = errno;
 
133
      free(new_plugin);
 
134
      errno = e;
 
135
      return NULL;
 
136
    }
 
137
  }
 
138
  
 
139
  *new_plugin = (plugin){ .name = copy_name,
 
140
                          .argc = 1,
 
141
                          .disabled = false,
 
142
                          .next = plugin_list };
 
143
  
 
144
  do {
 
145
    new_plugin->argv = malloc(sizeof(char *) * 2);
 
146
  } while(new_plugin->argv == NULL and errno == EINTR);
 
147
  if(new_plugin->argv == NULL){
 
148
    int e = errno;
 
149
    free(copy_name);
 
150
    free(new_plugin);
 
151
    errno = e;
 
152
    return NULL;
 
153
  }
 
154
  new_plugin->argv[0] = copy_name;
115
155
  new_plugin->argv[1] = NULL;
116
 
  new_plugin->argc = 1;
117
 
  new_plugin->disabled = false;
118
 
  new_plugin->next = *plugin_list;
 
156
  
 
157
  do {
 
158
    new_plugin->environ = malloc(sizeof(char *));
 
159
  } while(new_plugin->environ == NULL and errno == EINTR);
 
160
  if(new_plugin->environ == NULL){
 
161
    int e = errno;
 
162
    free(copy_name);
 
163
    free(new_plugin->argv);
 
164
    free(new_plugin);
 
165
    errno = e;
 
166
    return NULL;
 
167
  }
 
168
  new_plugin->environ[0] = NULL;
 
169
  
119
170
  /* Append the new plugin to the list */
120
 
  *plugin_list = new_plugin;
 
171
  plugin_list = new_plugin;
121
172
  return new_plugin;
122
173
}
123
174
 
124
 
static void addargument(plugin *p, char *arg){
125
 
  p->argv[p->argc] = arg;
126
 
  p->argv = realloc(p->argv, sizeof(char *) * (size_t)(p->argc + 2));
127
 
  if (p->argv == NULL){
128
 
    perror("malloc");
129
 
    exit(EXIT_FAILURE);
130
 
  }
131
 
  p->argc++;
132
 
  p->argv[p->argc] = NULL;
133
 
}
134
 
 
 
175
/* Helper function for add_argument and add_environment */
 
176
__attribute__((nonnull, warn_unused_result))
 
177
static bool add_to_char_array(const char *new, char ***array,
 
178
                              int *len){
 
179
  /* Resize the pointed-to array to hold one more pointer */
 
180
  char **new_array = NULL;
 
181
  do {
 
182
    new_array = realloc(*array, sizeof(char *)
 
183
                        * (size_t) ((*len) + 2));
 
184
  } while(new_array == NULL and errno == EINTR);
 
185
  /* Malloc check */
 
186
  if(new_array == NULL){
 
187
    return false;
 
188
  }
 
189
  *array = new_array;
 
190
  /* Make a copy of the new string */
 
191
  char *copy;
 
192
  do {
 
193
    copy = strdup(new);
 
194
  } while(copy == NULL and errno == EINTR);
 
195
  if(copy == NULL){
 
196
    return false;
 
197
  }
 
198
  /* Insert the copy */
 
199
  (*array)[*len] = copy;
 
200
  (*len)++;
 
201
  /* Add a new terminating NULL pointer to the last element */
 
202
  (*array)[*len] = NULL;
 
203
  return true;
 
204
}
 
205
 
 
206
/* Add to a plugin's argument vector */
 
207
__attribute__((nonnull(2), warn_unused_result))
 
208
static bool add_argument(plugin *p, const char *arg){
 
209
  if(p == NULL){
 
210
    return false;
 
211
  }
 
212
  return add_to_char_array(arg, &(p->argv), &(p->argc));
 
213
}
 
214
 
 
215
/* Add to a plugin's environment */
 
216
__attribute__((nonnull(2), warn_unused_result))
 
217
static bool add_environment(plugin *p, const char *def, bool replace){
 
218
  if(p == NULL){
 
219
    return false;
 
220
  }
 
221
  /* namelen = length of name of environment variable */
 
222
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
 
223
  /* Search for this environment variable */
 
224
  for(char **envdef = p->environ; *envdef != NULL; envdef++){
 
225
    if(strncmp(*envdef, def, namelen + 1) == 0){
 
226
      /* It already exists */
 
227
      if(replace){
 
228
        char *new_envdef;
 
229
        do {
 
230
          new_envdef = realloc(*envdef, strlen(def) + 1);
 
231
        } while(new_envdef == NULL and errno == EINTR);
 
232
        if(new_envdef == NULL){
 
233
          return false;
 
234
        }
 
235
        *envdef = new_envdef;
 
236
        strcpy(*envdef, def);
 
237
      }
 
238
      return true;
 
239
    }
 
240
  }
 
241
  return add_to_char_array(def, &(p->environ), &(p->envc));
 
242
}
 
243
 
 
244
#ifndef O_CLOEXEC
135
245
/*
136
246
 * Based on the example in the GNU LibC manual chapter 13.13 "File
137
247
 * Descriptor Flags".
138
 
 * *Note File Descriptor Flags:(libc)Descriptor Flags.
 
248
 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
139
249
 */
140
 
static int set_cloexec_flag(int fd)
141
 
{
142
 
  int ret = fcntl(fd, F_GETFD, 0);
 
250
__attribute__((warn_unused_result))
 
251
static int set_cloexec_flag(int fd){
 
252
  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
143
253
  /* If reading the flags failed, return error indication now. */
144
254
  if(ret < 0){
145
255
    return ret;
146
256
  }
147
257
  /* Store modified flag word in the descriptor. */
148
 
  return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
 
258
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
 
259
                                       ret | FD_CLOEXEC));
149
260
}
150
 
 
151
 
process *process_list = NULL;
152
 
 
153
 
/* Mark a process as completed when it exits, and save its exit
 
261
#endif  /* not O_CLOEXEC */
 
262
 
 
263
 
 
264
/* Mark processes as completed when they exit, and save their exit
154
265
   status. */
155
 
void handle_sigchld(__attribute__((unused)) int sig){
156
 
  process *proc = process_list;
157
 
  int status;
158
 
  pid_t pid = wait(&status);
159
 
  if(pid == -1){
160
 
    perror("wait");
161
 
    return;
162
 
  }
163
 
  while(proc != NULL and proc->pid != pid){
164
 
    proc = proc->next;
165
 
  }
166
 
  if(proc == NULL){
167
 
    /* Process not found in process list */
168
 
    return;
169
 
  }
170
 
  proc->status = status;
171
 
  proc->completed = true;
 
266
static void handle_sigchld(__attribute__((unused)) int sig){
 
267
  int old_errno = errno;
 
268
  while(true){
 
269
    plugin *proc = plugin_list;
 
270
    int status;
 
271
    pid_t pid = waitpid(-1, &status, WNOHANG);
 
272
    if(pid == 0){
 
273
      /* Only still running child processes */
 
274
      break;
 
275
    }
 
276
    if(pid == -1){
 
277
      if(errno == ECHILD){
 
278
        /* No child processes */
 
279
        break;
 
280
      }
 
281
      error(0, errno, "waitpid");
 
282
    }
 
283
    
 
284
    /* A child exited, find it in process_list */
 
285
    while(proc != NULL and proc->pid != pid){
 
286
      proc = proc->next;
 
287
    }
 
288
    if(proc == NULL){
 
289
      /* Process not found in process list */
 
290
      continue;
 
291
    }
 
292
    proc->status = status;
 
293
    proc->completed = 1;
 
294
  }
 
295
  errno = old_errno;
172
296
}
173
297
 
174
 
bool print_out_password(const char *buffer, size_t length){
 
298
/* Prints out a password to stdout */
 
299
__attribute__((nonnull, warn_unused_result))
 
300
static bool print_out_password(const char *buffer, size_t length){
175
301
  ssize_t ret;
176
 
  if(length>0 and buffer[length-1] == '\n'){
177
 
    length--;
178
 
  }
179
302
  for(size_t written = 0; written < length; written += (size_t)ret){
180
303
    ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
181
304
                                   length - written));
186
309
  return true;
187
310
}
188
311
 
189
 
char ** addcustomargument(char **argv, int *argc, char *arg){
190
 
 
191
 
  if (argv == NULL){
192
 
    *argc = 1;
193
 
    argv = malloc(sizeof(char*) * 2);
194
 
    if(argv == NULL){
195
 
      return NULL;
 
312
/* Removes and free a plugin from the plugin list */
 
313
__attribute__((nonnull))
 
314
static void free_plugin(plugin *plugin_node){
 
315
  
 
316
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
317
    free(*arg);
 
318
  }
 
319
  free(plugin_node->argv);
 
320
  for(char **env = plugin_node->environ; *env != NULL; env++){
 
321
    free(*env);
 
322
  }
 
323
  free(plugin_node->environ);
 
324
  free(plugin_node->buffer);
 
325
  
 
326
  /* Removes the plugin from the singly-linked list */
 
327
  if(plugin_node == plugin_list){
 
328
    /* First one - simple */
 
329
    plugin_list = plugin_list->next;
 
330
  } else {
 
331
    /* Second one or later */
 
332
    for(plugin *p = plugin_list; p != NULL; p = p->next){
 
333
      if(p->next == plugin_node){
 
334
        p->next = plugin_node->next;
 
335
        break;
 
336
      }
196
337
    }
197
 
    argv[0] = NULL;     /* Will be set to argv[0] in main before parsing */
198
 
    argv[1] = NULL;
199
 
  }
200
 
  *argc += 1;
201
 
  argv = realloc(argv, sizeof(char *)
202
 
                  * ((unsigned int) *argc + 1));
203
 
  if(argv == NULL){
204
 
    return NULL;
205
 
  }
206
 
  argv[*argc-1] = arg;
207
 
  argv[*argc] = NULL;   
208
 
  return argv;
 
338
  }
 
339
  
 
340
  free(plugin_node);
 
341
}
 
342
 
 
343
static void free_plugin_list(void){
 
344
  while(plugin_list != NULL){
 
345
    free_plugin(plugin_list);
 
346
  }
209
347
}
210
348
 
211
349
int main(int argc, char *argv[]){
212
 
  const char *plugindir = "/lib/mandos/plugins.d";
213
 
  const char *argfile = ARGFILE;
 
350
  char *plugindir = NULL;
 
351
  char *pluginhelperdir = NULL;
 
352
  char *argfile = NULL;
214
353
  FILE *conffp;
215
 
  size_t d_name_len;
216
 
  DIR *dir = NULL;
217
 
  struct dirent *dirst;
 
354
  struct dirent **direntries = NULL;
218
355
  struct stat st;
219
356
  fd_set rfds_all;
220
357
  int ret, maxfd = 0;
 
358
  ssize_t sret;
221
359
  uid_t uid = 65534;
222
360
  gid_t gid = 65534;
223
361
  bool debug = false;
227
365
                                      .sa_flags = SA_NOCLDSTOP };
228
366
  char **custom_argv = NULL;
229
367
  int custom_argc = 0;
 
368
  int dir_fd = -1;
230
369
  
231
370
  /* Establish a signal handler */
232
371
  sigemptyset(&sigchld_action.sa_mask);
233
372
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
234
 
  if(ret < 0){
235
 
    perror("sigaddset");
236
 
    exit(EXIT_FAILURE);
 
373
  if(ret == -1){
 
374
    error(0, errno, "sigaddset");
 
375
    exitstatus = EX_OSERR;
 
376
    goto fallback;
237
377
  }
238
378
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
239
 
  if(ret < 0){
240
 
    perror("sigaction");
241
 
    exit(EXIT_FAILURE);
 
379
  if(ret == -1){
 
380
    error(0, errno, "sigaction");
 
381
    exitstatus = EX_OSERR;
 
382
    goto fallback;
242
383
  }
243
384
  
244
385
  /* The options we understand. */
246
387
    { .name = "global-options", .key = 'g',
247
388
      .arg = "OPTION[,OPTION[,...]]",
248
389
      .doc = "Options passed to all plugins" },
 
390
    { .name = "global-env", .key = 'G',
 
391
      .arg = "VAR=value",
 
392
      .doc = "Environment variable passed to all plugins" },
249
393
    { .name = "options-for", .key = 'o',
250
394
      .arg = "PLUGIN:OPTION[,OPTION[,...]]",
251
395
      .doc = "Options passed only to specified plugin" },
 
396
    { .name = "env-for", .key = 'E',
 
397
      .arg = "PLUGIN:ENV=value",
 
398
      .doc = "Environment variable passed to specified plugin" },
252
399
    { .name = "disable", .key = 'd',
253
400
      .arg = "PLUGIN",
254
401
      .doc = "Disable a specific plugin", .group = 1 },
 
402
    { .name = "enable", .key = 'e',
 
403
      .arg = "PLUGIN",
 
404
      .doc = "Enable a specific plugin", .group = 1 },
255
405
    { .name = "plugin-dir", .key = 128,
256
406
      .arg = "DIRECTORY",
257
407
      .doc = "Specify a different plugin directory", .group = 2 },
258
 
    { .name = "userid", .key = 129,
259
 
      .arg = "ID", .flags = 0,
260
 
      .doc = "User ID the plugins will run as", .group = 2 },
261
 
    { .name = "groupid", .key = 130,
262
 
      .arg = "ID", .flags = 0,
263
 
      .doc = "Group ID the plugins will run as", .group = 2 },
264
 
    { .name = "debug", .key = 131,
265
 
      .doc = "Debug mode", .group = 3 },
 
408
    { .name = "config-file", .key = 129,
 
409
      .arg = "FILE",
 
410
      .doc = "Specify a different configuration file", .group = 2 },
 
411
    { .name = "userid", .key = 130,
 
412
      .arg = "ID", .flags = 0,
 
413
      .doc = "User ID the plugins will run as", .group = 3 },
 
414
    { .name = "groupid", .key = 131,
 
415
      .arg = "ID", .flags = 0,
 
416
      .doc = "Group ID the plugins will run as", .group = 3 },
 
417
    { .name = "debug", .key = 132,
 
418
      .doc = "Debug mode", .group = 4 },
 
419
    { .name = "plugin-helper-dir", .key = 133,
 
420
      .arg = "DIRECTORY",
 
421
      .doc = "Specify a different plugin helper directory",
 
422
      .group = 2 },
 
423
    /*
 
424
     * These reproduce what we would get without ARGP_NO_HELP
 
425
     */
 
426
    { .name = "help", .key = '?',
 
427
      .doc = "Give this help list", .group = -1 },
 
428
    { .name = "usage", .key = -3,
 
429
      .doc = "Give a short usage message", .group = -1 },
 
430
    { .name = "version", .key = 'V',
 
431
      .doc = "Print program version", .group = -1 },
266
432
    { .name = NULL }
267
433
  };
268
434
  
269
 
  error_t parse_opt (int key, char *arg, struct argp_state *state) {
270
 
    /* Get the INPUT argument from `argp_parse', which we know is a
271
 
       pointer to our plugin list pointer. */
272
 
    plugin **plugins = state->input;
273
 
    switch (key) {
274
 
    case 'g':
275
 
      if (arg != NULL){
276
 
        char *p;
277
 
        while((p = strsep(&arg, ",")) != NULL){
278
 
          if(p[0] == '\0'){
279
 
            continue;
280
 
          }
281
 
          addargument(getplugin(NULL, plugins), p);
282
 
        }
283
 
      }
284
 
      break;
285
 
    case 'o':
286
 
      if (arg != NULL){
287
 
        char *name = strsep(&arg, ":");
288
 
        if(name[0] == '\0'){
289
 
          break;
290
 
        }
291
 
        char *opt = strsep(&arg, ":");
292
 
        if(opt[0] == '\0'){
293
 
          break;
294
 
        }
295
 
        if(opt != NULL){
296
 
          char *p;
297
 
          while((p = strsep(&opt, ",")) != NULL){
298
 
            if(p[0] == '\0'){
299
 
              continue;
300
 
            }
301
 
            addargument(getplugin(name, plugins), p);
302
 
          }
303
 
        }
304
 
      }
305
 
      break;
306
 
    case 'd':
307
 
      if (arg != NULL){
308
 
        getplugin(arg, plugins)->disabled = true;
309
 
      }
310
 
      break;
311
 
    case 128:
312
 
      plugindir = arg;
313
 
      break;
314
 
    case 129:
315
 
      uid = (uid_t)strtol(arg, NULL, 10);
316
 
      break;
317
 
    case 130:
318
 
      gid = (gid_t)strtol(arg, NULL, 10);
319
 
      break;
320
 
    case 131:
 
435
  __attribute__((nonnull(3)))
 
436
  error_t parse_opt(int key, char *arg, struct argp_state *state){
 
437
    errno = 0;
 
438
    switch(key){
 
439
      char *tmp;
 
440
      intmax_t tmp_id;
 
441
    case 'g':                   /* --global-options */
 
442
      {
 
443
        char *plugin_option;
 
444
        while((plugin_option = strsep(&arg, ",")) != NULL){
 
445
          if(not add_argument(getplugin(NULL), plugin_option)){
 
446
            break;
 
447
          }
 
448
        }
 
449
        errno = 0;
 
450
      }
 
451
      break;
 
452
    case 'G':                   /* --global-env */
 
453
      if(add_environment(getplugin(NULL), arg, true)){
 
454
        errno = 0;
 
455
      }
 
456
      break;
 
457
    case 'o':                   /* --options-for */
 
458
      {
 
459
        char *option_list = strchr(arg, ':');
 
460
        if(option_list == NULL){
 
461
          argp_error(state, "No colon in \"%s\"", arg);
 
462
          errno = EINVAL;
 
463
          break;
 
464
        }
 
465
        *option_list = '\0';
 
466
        option_list++;
 
467
        if(arg[0] == '\0'){
 
468
          argp_error(state, "Empty plugin name");
 
469
          errno = EINVAL;
 
470
          break;
 
471
        }
 
472
        char *option;
 
473
        while((option = strsep(&option_list, ",")) != NULL){
 
474
          if(not add_argument(getplugin(arg), option)){
 
475
            break;
 
476
          }
 
477
        }
 
478
        errno = 0;
 
479
      }
 
480
      break;
 
481
    case 'E':                   /* --env-for */
 
482
      {
 
483
        char *envdef = strchr(arg, ':');
 
484
        if(envdef == NULL){
 
485
          argp_error(state, "No colon in \"%s\"", arg);
 
486
          errno = EINVAL;
 
487
          break;
 
488
        }
 
489
        *envdef = '\0';
 
490
        envdef++;
 
491
        if(arg[0] == '\0'){
 
492
          argp_error(state, "Empty plugin name");
 
493
          errno = EINVAL;
 
494
          break;
 
495
        }
 
496
        if(add_environment(getplugin(arg), envdef, true)){
 
497
          errno = 0;
 
498
        }
 
499
      }
 
500
      break;
 
501
    case 'd':                   /* --disable */
 
502
      {
 
503
        plugin *p = getplugin(arg);
 
504
        if(p != NULL){
 
505
          p->disabled = true;
 
506
          errno = 0;
 
507
        }
 
508
      }
 
509
      break;
 
510
    case 'e':                   /* --enable */
 
511
      {
 
512
        plugin *p = getplugin(arg);
 
513
        if(p != NULL){
 
514
          p->disabled = false;
 
515
          errno = 0;
 
516
        }
 
517
      }
 
518
      break;
 
519
    case 128:                   /* --plugin-dir */
 
520
      free(plugindir);
 
521
      plugindir = strdup(arg);
 
522
      if(plugindir != NULL){
 
523
        errno = 0;
 
524
      }
 
525
      break;
 
526
    case 129:                   /* --config-file */
 
527
      /* This is already done by parse_opt_config_file() */
 
528
      break;
 
529
    case 130:                   /* --userid */
 
530
      tmp_id = strtoimax(arg, &tmp, 10);
 
531
      if(errno != 0 or tmp == arg or *tmp != '\0'
 
532
         or tmp_id != (uid_t)tmp_id){
 
533
        argp_error(state, "Bad user ID number: \"%s\", using %"
 
534
                   PRIdMAX, arg, (intmax_t)uid);
 
535
        break;
 
536
      }
 
537
      uid = (uid_t)tmp_id;
 
538
      errno = 0;
 
539
      break;
 
540
    case 131:                   /* --groupid */
 
541
      tmp_id = strtoimax(arg, &tmp, 10);
 
542
      if(errno != 0 or tmp == arg or *tmp != '\0'
 
543
         or tmp_id != (gid_t)tmp_id){
 
544
        argp_error(state, "Bad group ID number: \"%s\", using %"
 
545
                   PRIdMAX, arg, (intmax_t)gid);
 
546
        break;
 
547
      }
 
548
      gid = (gid_t)tmp_id;
 
549
      errno = 0;
 
550
      break;
 
551
    case 132:                   /* --debug */
321
552
      debug = true;
322
553
      break;
323
 
    case ARGP_KEY_ARG:
324
 
      fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg); 
325
 
      break;
326
 
    case ARGP_KEY_END:
327
 
      break;
328
 
    default:
329
 
      return ARGP_ERR_UNKNOWN;
330
 
    }
331
 
    return 0;
332
 
  }
333
 
  
334
 
  plugin *plugin_list = NULL;
335
 
  
336
 
  struct argp argp = { .options = options, .parser = parse_opt,
337
 
                       .args_doc = "[+PLUS_SEPARATED_OPTIONS]",
 
554
    case 133:                   /* --plugin-helper-dir */
 
555
      free(pluginhelperdir);
 
556
      pluginhelperdir = strdup(arg);
 
557
      if(pluginhelperdir != NULL){
 
558
        errno = 0;
 
559
      }
 
560
      break;
 
561
      /*
 
562
       * These reproduce what we would get without ARGP_NO_HELP
 
563
       */
 
564
    case '?':                   /* --help */
 
565
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
 
566
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
567
    case -3:                    /* --usage */
 
568
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
 
569
      argp_state_help(state, state->out_stream,
 
570
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
571
    case 'V':                   /* --version */
 
572
      fprintf(state->out_stream, "%s\n", argp_program_version);
 
573
      exit(EXIT_SUCCESS);
 
574
      break;
 
575
/*
 
576
 * When adding more options before this line, remember to also add a
 
577
 * "case" to the "parse_opt_config_file" function below.
 
578
 */
 
579
    case ARGP_KEY_ARG:
 
580
      /* Cryptsetup always passes an argument, which is an empty
 
581
         string if "none" was specified in /etc/crypttab.  So if
 
582
         argument was empty, we ignore it silently. */
 
583
      if(arg[0] == '\0'){
 
584
        break;
 
585
      }
 
586
      /* FALLTHROUGH */
 
587
    default:
 
588
      return ARGP_ERR_UNKNOWN;
 
589
    }
 
590
    return errno;               /* Set to 0 at start */
 
591
  }
 
592
  
 
593
  /* This option parser is the same as parse_opt() above, except it
 
594
     ignores everything but the --config-file option. */
 
595
  error_t parse_opt_config_file(int key, char *arg,
 
596
                                __attribute__((unused))
 
597
                                struct argp_state *state){
 
598
    errno = 0;
 
599
    switch(key){
 
600
    case 'g':                   /* --global-options */
 
601
    case 'G':                   /* --global-env */
 
602
    case 'o':                   /* --options-for */
 
603
    case 'E':                   /* --env-for */
 
604
    case 'd':                   /* --disable */
 
605
    case 'e':                   /* --enable */
 
606
    case 128:                   /* --plugin-dir */
 
607
      break;
 
608
    case 129:                   /* --config-file */
 
609
      free(argfile);
 
610
      argfile = strdup(arg);
 
611
      if(argfile != NULL){
 
612
        errno = 0;
 
613
      }
 
614
      break;
 
615
    case 130:                   /* --userid */
 
616
    case 131:                   /* --groupid */
 
617
    case 132:                   /* --debug */
 
618
    case 133:                   /* --plugin-helper-dir */
 
619
    case '?':                   /* --help */
 
620
    case -3:                    /* --usage */
 
621
    case 'V':                   /* --version */
 
622
    case ARGP_KEY_ARG:
 
623
      break;
 
624
    default:
 
625
      return ARGP_ERR_UNKNOWN;
 
626
    }
 
627
    return errno;
 
628
  }
 
629
  
 
630
  struct argp argp = { .options = options,
 
631
                       .parser = parse_opt_config_file,
 
632
                       .args_doc = "",
338
633
                       .doc = "Mandos plugin runner -- Run plugins" };
339
634
  
340
 
  ret = argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
341
 
  if (ret == ARGP_ERR_UNKNOWN){
342
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
343
 
    exitstatus = EXIT_FAILURE;
344
 
    goto end;
345
 
  }
346
 
 
347
 
  conffp = fopen(argfile, "r");
 
635
  /* Parse using parse_opt_config_file() in order to get the custom
 
636
     config file location, if any. */
 
637
  ret = argp_parse(&argp, argc, argv,
 
638
                   ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
639
                   NULL, NULL);
 
640
  switch(ret){
 
641
  case 0:
 
642
    break;
 
643
  case ENOMEM:
 
644
  default:
 
645
    errno = ret;
 
646
    error(0, errno, "argp_parse");
 
647
    exitstatus = EX_OSERR;
 
648
    goto fallback;
 
649
  case EINVAL:
 
650
    exitstatus = EX_USAGE;
 
651
    goto fallback;
 
652
  }
 
653
  
 
654
  /* Reset to the normal argument parser */
 
655
  argp.parser = parse_opt;
 
656
  
 
657
  /* Open the configfile if available */
 
658
  if(argfile == NULL){
 
659
    conffp = fopen(AFILE, "r");
 
660
  } else {
 
661
    conffp = fopen(argfile, "r");
 
662
  }
348
663
  if(conffp != NULL){
349
664
    char *org_line = NULL;
 
665
    char *p, *arg, *new_arg, *line;
350
666
    size_t size = 0;
351
 
    ssize_t sret;
352
 
    char *p, *arg, *new_arg, *line;
353
667
    const char whitespace_delims[] = " \r\t\f\v\n";
354
668
    const char comment_delim[] = "#";
355
 
 
 
669
    
 
670
    custom_argc = 1;
 
671
    custom_argv = malloc(sizeof(char*) * 2);
 
672
    if(custom_argv == NULL){
 
673
      error(0, errno, "malloc");
 
674
      exitstatus = EX_OSERR;
 
675
      goto fallback;
 
676
    }
 
677
    custom_argv[0] = argv[0];
 
678
    custom_argv[1] = NULL;
 
679
    
 
680
    /* for each line in the config file, strip whitespace and ignore
 
681
       commented text */
356
682
    while(true){
357
683
      sret = getline(&org_line, &size, conffp);
358
684
      if(sret == -1){
359
685
        break;
360
686
      }
361
 
 
 
687
      
362
688
      line = org_line;
363
689
      arg = strsep(&line, comment_delim);
364
690
      while((p = strsep(&arg, whitespace_delims)) != NULL){
366
692
          continue;
367
693
        }
368
694
        new_arg = strdup(p);
369
 
        custom_argv = addcustomargument(custom_argv, &custom_argc, new_arg);
370
 
        if (custom_argv == NULL){
371
 
          perror("addcustomargument");
372
 
          exitstatus = EXIT_FAILURE;
373
 
          goto end;
374
 
        }
 
695
        if(new_arg == NULL){
 
696
          error(0, errno, "strdup");
 
697
          exitstatus = EX_OSERR;
 
698
          free(org_line);
 
699
          goto fallback;
 
700
        }
 
701
        
 
702
        custom_argc += 1;
 
703
        {
 
704
          char **new_argv = realloc(custom_argv, sizeof(char *)
 
705
                                    * ((size_t)custom_argc + 1));
 
706
          if(new_argv == NULL){
 
707
            error(0, errno, "realloc");
 
708
            exitstatus = EX_OSERR;
 
709
            free(new_arg);
 
710
            free(org_line);
 
711
            goto fallback;
 
712
          } else {
 
713
            custom_argv = new_argv;
 
714
          }
 
715
        }
 
716
        custom_argv[custom_argc-1] = new_arg;
 
717
        custom_argv[custom_argc] = NULL;
375
718
      }
376
719
    }
 
720
    do {
 
721
      ret = fclose(conffp);
 
722
    } while(ret == EOF and errno == EINTR);
 
723
    if(ret == EOF){
 
724
      error(0, errno, "fclose");
 
725
      exitstatus = EX_IOERR;
 
726
      goto fallback;
 
727
    }
377
728
    free(org_line);
378
 
  } else{
 
729
  } else {
379
730
    /* Check for harmful errors and go to fallback. Other errors might
380
731
       not affect opening plugins */
381
 
    if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
382
 
      perror("fopen");
383
 
      exitstatus = EXIT_FAILURE;
384
 
      goto end;
 
732
    if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
 
733
      error(0, errno, "fopen");
 
734
      exitstatus = EX_OSERR;
 
735
      goto fallback;
385
736
    }
386
737
  }
387
 
 
 
738
  /* If there were any arguments from the configuration file, pass
 
739
     them to parser as command line arguments */
388
740
  if(custom_argv != NULL){
389
 
    custom_argv[0] = argv[0];
390
 
    ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, &plugin_list);
391
 
    if (ret == ARGP_ERR_UNKNOWN){
392
 
      fprintf(stderr, "Unknown error while parsing arguments\n");
393
 
      exitstatus = EXIT_FAILURE;
394
 
      goto end;
 
741
    ret = argp_parse(&argp, custom_argc, custom_argv,
 
742
                     ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
743
                     NULL, NULL);
 
744
    switch(ret){
 
745
    case 0:
 
746
      break;
 
747
    case ENOMEM:
 
748
    default:
 
749
      errno = ret;
 
750
      error(0, errno, "argp_parse");
 
751
      exitstatus = EX_OSERR;
 
752
      goto fallback;
 
753
    case EINVAL:
 
754
      exitstatus = EX_CONFIG;
 
755
      goto fallback;
 
756
    }
 
757
  }
 
758
  
 
759
  /* Parse actual command line arguments, to let them override the
 
760
     config file */
 
761
  ret = argp_parse(&argp, argc, argv,
 
762
                   ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
763
                   NULL, NULL);
 
764
  switch(ret){
 
765
  case 0:
 
766
    break;
 
767
  case ENOMEM:
 
768
  default:
 
769
    errno = ret;
 
770
    error(0, errno, "argp_parse");
 
771
    exitstatus = EX_OSERR;
 
772
    goto fallback;
 
773
  case EINVAL:
 
774
    exitstatus = EX_USAGE;
 
775
    goto fallback;
 
776
  }
 
777
  
 
778
  {
 
779
    char *pluginhelperenv;
 
780
    bool bret = true;
 
781
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
 
782
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
783
    if(ret != -1){
 
784
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
 
785
    }
 
786
    if(ret == -1 or not bret){
 
787
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
 
788
            " environment variable to \"%s\" for all plugins\n",
 
789
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
790
    }
 
791
    if(ret != -1){
 
792
      free(pluginhelperenv);
395
793
    }
396
794
  }
397
795
  
398
796
  if(debug){
399
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
797
    for(plugin *p = plugin_list; p != NULL; p = p->next){
400
798
      fprintf(stderr, "Plugin: %s has %d arguments\n",
401
799
              p->name ? p->name : "Global", p->argc - 1);
402
800
      for(char **a = p->argv; *a != NULL; a++){
403
801
        fprintf(stderr, "\tArg: %s\n", *a);
404
802
      }
405
 
    }
406
 
  }
407
 
  
 
803
      fprintf(stderr, "...and %d environment variables\n", p->envc);
 
804
      for(char **a = p->environ; *a != NULL; a++){
 
805
        fprintf(stderr, "\t%s\n", *a);
 
806
      }
 
807
    }
 
808
  }
 
809
  
 
810
  if(getuid() == 0){
 
811
    /* Work around Debian bug #633582:
 
812
       <https://bugs.debian.org/633582> */
 
813
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
 
814
    if(plugindir_fd == -1){
 
815
      if(errno != ENOENT){
 
816
        error(0, errno, "open(\"" PDIR "\")");
 
817
      }
 
818
    } else {
 
819
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
 
820
      if(ret == -1){
 
821
        error(0, errno, "fstat");
 
822
      } else {
 
823
        if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
 
824
          ret = fchown(plugindir_fd, uid, gid);
 
825
          if(ret == -1){
 
826
            error(0, errno, "fchown");
 
827
          }
 
828
        }
 
829
      }
 
830
      close(plugindir_fd);
 
831
    }
 
832
  }
 
833
  
 
834
  /* Lower permissions */
 
835
  ret = setgid(gid);
 
836
  if(ret == -1){
 
837
    error(0, errno, "setgid");
 
838
  }
408
839
  ret = setuid(uid);
409
 
  if (ret == -1){
410
 
    perror("setuid");
411
 
  }
412
 
  
413
 
  setgid(gid);
414
 
  if (ret == -1){
415
 
    perror("setgid");
416
 
  }
417
 
  
418
 
  dir = opendir(plugindir);
419
 
  if(dir == NULL){
420
 
    perror("Could not open plugin dir");
421
 
    exitstatus = EXIT_FAILURE;
422
 
    goto end;
423
 
  }
424
 
  
425
 
  /* Set the FD_CLOEXEC flag on the directory, if possible */
 
840
  if(ret == -1){
 
841
    error(0, errno, "setuid");
 
842
  }
 
843
  
 
844
  /* Open plugin directory with close_on_exec flag */
426
845
  {
427
 
    int dir_fd = dirfd(dir);
428
 
    if(dir_fd >= 0){
429
 
      ret = set_cloexec_flag(dir_fd);
430
 
      if(ret < 0){
431
 
        perror("set_cloexec_flag");
432
 
        exitstatus = EXIT_FAILURE;
433
 
        goto end;
 
846
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
847
#ifdef O_CLOEXEC
 
848
                  O_CLOEXEC
 
849
#else  /* not O_CLOEXEC */
 
850
                  0
 
851
#endif  /* not O_CLOEXEC */
 
852
                  );
 
853
    if(dir_fd == -1){
 
854
      error(0, errno, "Could not open plugin dir");
 
855
      exitstatus = EX_UNAVAILABLE;
 
856
      goto fallback;
 
857
    }
 
858
    
 
859
#ifndef O_CLOEXEC
 
860
  /* Set the FD_CLOEXEC flag on the directory */
 
861
    ret = set_cloexec_flag(dir_fd);
 
862
    if(ret < 0){
 
863
      error(0, errno, "set_cloexec_flag");
 
864
      exitstatus = EX_OSERR;
 
865
      goto fallback;
 
866
    }
 
867
#endif  /* O_CLOEXEC */
 
868
  }
 
869
  
 
870
  int good_name(const struct dirent * const dirent){
 
871
    const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
 
872
                                      "*.dpkg-old", "*.dpkg-bak",
 
873
                                      "*.dpkg-divert", NULL };
 
874
#ifdef __GNUC__
 
875
#pragma GCC diagnostic push
 
876
#pragma GCC diagnostic ignored "-Wcast-qual"
 
877
#endif
 
878
    for(const char **pat = (const char **)patterns;
 
879
        *pat != NULL; pat++){
 
880
#ifdef __GNUC__
 
881
#pragma GCC diagnostic pop
 
882
#endif
 
883
      if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
 
884
         != FNM_NOMATCH){
 
885
        if(debug){
 
886
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
 
887
                    " matching pattern %s\n", dirent->d_name, *pat);
 
888
        }
 
889
        return 0;
434
890
      }
435
891
    }
 
892
    return 1;
 
893
  }
 
894
  
 
895
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
896
                             alphasort);
 
897
  if(numplugins == -1){
 
898
    error(0, errno, "Could not scan plugin dir");
 
899
    direntries = NULL;
 
900
    exitstatus = EX_OSERR;
 
901
    goto fallback;
436
902
  }
437
903
  
438
904
  FD_ZERO(&rfds_all);
439
905
  
440
 
  while(true){
441
 
    dirst = readdir(dir);
442
 
    
443
 
    // All directory entries have been processed
444
 
    if(dirst == NULL){
445
 
      if (errno == EBADF){
446
 
        perror("readdir");
447
 
        exitstatus = EXIT_FAILURE;
448
 
        goto end;
449
 
      }
450
 
      break;
451
 
    }
452
 
    
453
 
    d_name_len = strlen(dirst->d_name);
454
 
    
455
 
    // Ignore dotfiles, backup files and other junk
456
 
    {
457
 
      bool bad_name = false;
458
 
      
459
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
460
 
      
461
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
462
 
                                           ".dpkg-old",
463
 
                                           ".dpkg-divert", NULL };
464
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
465
 
        size_t pre_len = strlen(*pre);
466
 
        if((d_name_len >= pre_len)
467
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
468
 
          if(debug){
469
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
470
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
471
 
          }
472
 
          bad_name = true;
473
 
          break;
474
 
        }
475
 
      }
476
 
      
477
 
      if(bad_name){
478
 
        continue;
479
 
      }
480
 
      
481
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
482
 
        size_t suf_len = strlen(*suf);
483
 
        if((d_name_len >= suf_len)
484
 
           and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
485
 
                == 0)){
486
 
          if(debug){
487
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
488
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
489
 
          }
490
 
          bad_name = true;
491
 
          break;
492
 
        }
493
 
      }
494
 
      
495
 
      if(bad_name){
496
 
        continue;
497
 
      }
498
 
    }
499
 
    
500
 
    char *filename = malloc(d_name_len + strlen(plugindir) + 2);
501
 
    if (filename == NULL){
502
 
      perror("malloc");
503
 
      continue;
504
 
    }
505
 
    strcpy(filename, plugindir); /* Spurious warning */
506
 
    strcat(filename, "/");      /* Spurious warning */
507
 
    strcat(filename, dirst->d_name); /* Spurious warning */
508
 
    
509
 
    ret = stat(filename, &st);
510
 
    if (ret == -1){
511
 
      perror("stat");
512
 
      free(filename);
513
 
      continue;
514
 
    }
515
 
    
516
 
    if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
 
906
  /* Read and execute any executable in the plugin directory*/
 
907
  for(int i = 0; i < numplugins; i++){
 
908
    
 
909
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
910
    if(plugin_fd == -1){
 
911
      error(0, errno, "Could not open plugin");
 
912
      free(direntries[i]);
 
913
      continue;
 
914
    }
 
915
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
 
916
    if(ret == -1){
 
917
      error(0, errno, "stat");
 
918
      close(plugin_fd);
 
919
      free(direntries[i]);
 
920
      continue;
 
921
    }
 
922
    
 
923
    /* Ignore non-executable files */
 
924
    if(not S_ISREG(st.st_mode)
 
925
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
926
                                        X_OK, 0)) != 0)){
517
927
      if(debug){
518
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
519
 
                " with bad type or mode\n", filename);
 
928
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
929
                " with bad type or mode\n",
 
930
                plugindir != NULL ? plugindir : PDIR,
 
931
                direntries[i]->d_name);
520
932
      }
521
 
      free(filename);
522
 
      continue;
523
 
    }
524
 
    if(getplugin(dirst->d_name, &plugin_list)->disabled){
 
933
      close(plugin_fd);
 
934
      free(direntries[i]);
 
935
      continue;
 
936
    }
 
937
    
 
938
    plugin *p = getplugin(direntries[i]->d_name);
 
939
    if(p == NULL){
 
940
      error(0, errno, "getplugin");
 
941
      close(plugin_fd);
 
942
      free(direntries[i]);
 
943
      continue;
 
944
    }
 
945
    if(p->disabled){
525
946
      if(debug){
526
947
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
527
 
                dirst->d_name);
 
948
                direntries[i]->d_name);
528
949
      }
529
 
      free(filename);
 
950
      close(plugin_fd);
 
951
      free(direntries[i]);
530
952
      continue;
531
953
    }
532
 
    plugin *p = getplugin(dirst->d_name, &plugin_list);
533
954
    {
534
955
      /* Add global arguments to argument list for this plugin */
535
 
      plugin *g = getplugin(NULL, &plugin_list);
536
 
      for(char **a = g->argv + 1; *a != NULL; a++){
537
 
        addargument(p, *a);
538
 
      }
539
 
    }
540
 
    int pipefd[2]; 
541
 
    ret = pipe(pipefd);
542
 
    if (ret == -1){
543
 
      perror("pipe");
544
 
      exitstatus = EXIT_FAILURE;
545
 
      goto end;
546
 
    }
 
956
      plugin *g = getplugin(NULL);
 
957
      if(g != NULL){
 
958
        for(char **a = g->argv + 1; *a != NULL; a++){
 
959
          if(not add_argument(p, *a)){
 
960
            error(0, errno, "add_argument");
 
961
          }
 
962
        }
 
963
        /* Add global environment variables */
 
964
        for(char **e = g->environ; *e != NULL; e++){
 
965
          if(not add_environment(p, *e, false)){
 
966
            error(0, errno, "add_environment");
 
967
          }
 
968
        }
 
969
      }
 
970
    }
 
971
    /* If this plugin has any environment variables, we need to
 
972
       duplicate the environment from this process, too. */
 
973
    if(p->environ[0] != NULL){
 
974
      for(char **e = environ; *e != NULL; e++){
 
975
        if(not add_environment(p, *e, false)){
 
976
          error(0, errno, "add_environment");
 
977
        }
 
978
      }
 
979
    }
 
980
    
 
981
    int pipefd[2];
 
982
#ifndef O_CLOEXEC
 
983
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
984
#else  /* O_CLOEXEC */
 
985
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
986
#endif  /* O_CLOEXEC */
 
987
    if(ret == -1){
 
988
      error(0, errno, "pipe");
 
989
      exitstatus = EX_OSERR;
 
990
      free(direntries[i]);
 
991
      goto fallback;
 
992
    }
 
993
    if(pipefd[0] >= FD_SETSIZE){
 
994
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
995
              FD_SETSIZE);
 
996
      close(pipefd[0]);
 
997
      close(pipefd[1]);
 
998
      exitstatus = EX_OSERR;
 
999
      free(direntries[i]);
 
1000
      goto fallback;
 
1001
    }
 
1002
#ifndef O_CLOEXEC
 
1003
    /* Ask OS to automatic close the pipe on exec */
547
1004
    ret = set_cloexec_flag(pipefd[0]);
548
1005
    if(ret < 0){
549
 
      perror("set_cloexec_flag");
550
 
      exitstatus = EXIT_FAILURE;
551
 
      goto end;
 
1006
      error(0, errno, "set_cloexec_flag");
 
1007
      close(pipefd[0]);
 
1008
      close(pipefd[1]);
 
1009
      exitstatus = EX_OSERR;
 
1010
      free(direntries[i]);
 
1011
      goto fallback;
552
1012
    }
553
1013
    ret = set_cloexec_flag(pipefd[1]);
554
1014
    if(ret < 0){
555
 
      perror("set_cloexec_flag");
556
 
      exitstatus = EXIT_FAILURE;
557
 
      goto end;
 
1015
      error(0, errno, "set_cloexec_flag");
 
1016
      close(pipefd[0]);
 
1017
      close(pipefd[1]);
 
1018
      exitstatus = EX_OSERR;
 
1019
      free(direntries[i]);
 
1020
      goto fallback;
558
1021
    }
 
1022
#endif  /* not O_CLOEXEC */
559
1023
    /* Block SIGCHLD until process is safely in process list */
560
 
    ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
 
1024
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
 
1025
                                              &sigchld_action.sa_mask,
 
1026
                                              NULL));
561
1027
    if(ret < 0){
562
 
      perror("sigprocmask");
563
 
      exitstatus = EXIT_FAILURE;
564
 
      goto end;
 
1028
      error(0, errno, "sigprocmask");
 
1029
      exitstatus = EX_OSERR;
 
1030
      free(direntries[i]);
 
1031
      goto fallback;
565
1032
    }
566
 
    // Starting a new process to be watched
567
 
    pid_t pid = fork();
 
1033
    /* Starting a new process to be watched */
 
1034
    pid_t pid;
 
1035
    do {
 
1036
      pid = fork();
 
1037
    } while(pid == -1 and errno == EINTR);
568
1038
    if(pid == -1){
569
 
      perror("fork");
570
 
      exitstatus = EXIT_FAILURE;
571
 
      goto end;
 
1039
      error(0, errno, "fork");
 
1040
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1041
                                     &sigchld_action.sa_mask, NULL));
 
1042
      close(pipefd[0]);
 
1043
      close(pipefd[1]);
 
1044
      exitstatus = EX_OSERR;
 
1045
      free(direntries[i]);
 
1046
      goto fallback;
572
1047
    }
573
1048
    if(pid == 0){
574
1049
      /* this is the child process */
575
1050
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
576
1051
      if(ret < 0){
577
 
        perror("sigaction");
578
 
        _exit(EXIT_FAILURE);
 
1052
        error(0, errno, "sigaction");
 
1053
        _exit(EX_OSERR);
579
1054
      }
580
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
1055
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
581
1056
      if(ret < 0){
582
 
        perror("sigprocmask");
583
 
        _exit(EXIT_FAILURE);
 
1057
        error(0, errno, "sigprocmask");
 
1058
        _exit(EX_OSERR);
584
1059
      }
585
 
 
 
1060
      
586
1061
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
587
1062
      if(ret == -1){
588
 
        perror("dup2");
589
 
        _exit(EXIT_FAILURE);
 
1063
        error(0, errno, "dup2");
 
1064
        _exit(EX_OSERR);
590
1065
      }
591
1066
      
592
 
      if(dirfd(dir) < 0){
593
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
594
 
           above and must now close it manually here. */
595
 
        closedir(dir);
596
 
      }
597
 
      if(execv(filename, p->argv) < 0){
598
 
        perror("execv");
599
 
        _exit(EXIT_FAILURE);
 
1067
      if(fexecve(plugin_fd, p->argv,
 
1068
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1069
        error(0, errno, "fexecve for %s/%s",
 
1070
              plugindir != NULL ? plugindir : PDIR,
 
1071
              direntries[i]->d_name);
 
1072
        _exit(EX_OSERR);
600
1073
      }
601
1074
      /* no return */
602
1075
    }
603
 
    /* parent process */
604
 
    free(filename);
605
 
    close(pipefd[1]);           /* close unused write end of pipe */
606
 
    process *new_process = malloc(sizeof(process));
607
 
    if (new_process == NULL){
608
 
      perror("malloc");
609
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
1076
    /* Parent process */
 
1077
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1078
    close(plugin_fd);
 
1079
    plugin *new_plugin = getplugin(direntries[i]->d_name);
 
1080
    if(new_plugin == NULL){
 
1081
      error(0, errno, "getplugin");
 
1082
      ret = (int)(TEMP_FAILURE_RETRY
 
1083
                  (sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
 
1084
                               NULL)));
610
1085
      if(ret < 0){
611
 
        perror("sigprocmask");
 
1086
        error(0, errno, "sigprocmask");
612
1087
      }
613
 
      exitstatus = EXIT_FAILURE;
614
 
      goto end;
 
1088
      exitstatus = EX_OSERR;
 
1089
      free(direntries[i]);
 
1090
      goto fallback;
615
1091
    }
 
1092
    free(direntries[i]);
616
1093
    
617
 
    *new_process = (struct process){ .pid = pid,
618
 
                                     .fd = pipefd[0],
619
 
                                     .next = process_list };
620
 
    // List handling
621
 
    process_list = new_process;
 
1094
    new_plugin->pid = pid;
 
1095
    new_plugin->fd = pipefd[0];
 
1096
 
 
1097
    if(debug){
 
1098
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1099
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1100
    }
 
1101
 
622
1102
    /* Unblock SIGCHLD so signal handler can be run if this process
623
1103
       has already completed */
624
 
    ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
1104
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1105
                                              &sigchld_action.sa_mask,
 
1106
                                              NULL));
625
1107
    if(ret < 0){
626
 
      perror("sigprocmask");
627
 
      exitstatus = EXIT_FAILURE;
628
 
      goto end;
629
 
    }
630
 
    
631
 
    FD_SET(new_process->fd, &rfds_all);
632
 
    
633
 
    if (maxfd < new_process->fd){
634
 
      maxfd = new_process->fd;
635
 
    }
636
 
    
637
 
  }
638
 
  
639
 
  /* Free the plugin list */
640
 
  for(plugin *next; plugin_list != NULL; plugin_list = next){
641
 
    next = plugin_list->next;
642
 
    free(plugin_list->argv);
643
 
    free(plugin_list);
644
 
  }
645
 
  
646
 
  closedir(dir);
647
 
  dir = NULL;
648
 
    
649
 
  if (process_list == NULL){
650
 
    fprintf(stderr, "No plugin processes started. Incorrect plugin"
651
 
            " directory?\n");
652
 
    process_list = NULL;
653
 
  }
654
 
  while(process_list){
 
1108
      error(0, errno, "sigprocmask");
 
1109
      exitstatus = EX_OSERR;
 
1110
      goto fallback;
 
1111
    }
 
1112
    
 
1113
    FD_SET(new_plugin->fd, &rfds_all);
 
1114
    
 
1115
    if(maxfd < new_plugin->fd){
 
1116
      maxfd = new_plugin->fd;
 
1117
    }
 
1118
  }
 
1119
  
 
1120
  free(direntries);
 
1121
  direntries = NULL;
 
1122
  close(dir_fd);
 
1123
  dir_fd = -1;
 
1124
  free_plugin(getplugin(NULL));
 
1125
  
 
1126
  for(plugin *p = plugin_list; p != NULL; p = p->next){
 
1127
    if(p->pid != 0){
 
1128
      break;
 
1129
    }
 
1130
    if(p->next == NULL){
 
1131
      fprintf(stderr, "No plugin processes started. Incorrect plugin"
 
1132
              " directory?\n");
 
1133
      free_plugin_list();
 
1134
    }
 
1135
  }
 
1136
  
 
1137
  /* Main loop while running plugins exist */
 
1138
  while(plugin_list){
655
1139
    fd_set rfds = rfds_all;
656
1140
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
657
 
    if (select_ret == -1){
658
 
      perror("select");
659
 
      exitstatus = EXIT_FAILURE;
660
 
      goto end;
 
1141
    if(select_ret == -1 and errno != EINTR){
 
1142
      error(0, errno, "select");
 
1143
      exitstatus = EX_OSERR;
 
1144
      goto fallback;
661
1145
    }
662
1146
    /* OK, now either a process completed, or something can be read
663
1147
       from one of them */
664
 
    for(process *proc = process_list; proc ; proc = proc->next){
 
1148
    for(plugin *proc = plugin_list; proc != NULL;){
665
1149
      /* Is this process completely done? */
666
 
      if(proc->eof and proc->completed){
 
1150
      if(proc->completed and proc->eof){
667
1151
        /* Only accept the plugin output if it exited cleanly */
668
1152
        if(not WIFEXITED(proc->status)
669
1153
           or WEXITSTATUS(proc->status) != 0){
670
1154
          /* Bad exit by plugin */
 
1155
          
671
1156
          if(debug){
672
1157
            if(WIFEXITED(proc->status)){
673
 
              fprintf(stderr, "Plugin %u exited with status %d\n",
674
 
                      (unsigned int) (proc->pid),
 
1158
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
 
1159
                      " status %d\n", proc->name,
 
1160
                      (intmax_t) (proc->pid),
675
1161
                      WEXITSTATUS(proc->status));
676
 
            } else if(WIFSIGNALED(proc->status)) {
677
 
              fprintf(stderr, "Plugin %u killed by signal %d\n",
678
 
                      (unsigned int) (proc->pid),
679
 
                      WTERMSIG(proc->status));
680
 
            } else if(WCOREDUMP(proc->status)){
681
 
              fprintf(stderr, "Plugin %d dumped core\n",
682
 
                      (unsigned int) (proc->pid));
 
1162
            } else if(WIFSIGNALED(proc->status)){
 
1163
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
 
1164
                      " signal %d: %s\n", proc->name,
 
1165
                      (intmax_t) (proc->pid),
 
1166
                      WTERMSIG(proc->status),
 
1167
                      strsignal(WTERMSIG(proc->status)));
683
1168
            }
684
1169
          }
 
1170
          
685
1171
          /* Remove the plugin */
686
1172
          FD_CLR(proc->fd, &rfds_all);
 
1173
          
687
1174
          /* Block signal while modifying process_list */
688
 
          ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
 
1175
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
 
1176
                                        (SIG_BLOCK,
 
1177
                                         &sigchld_action.sa_mask,
 
1178
                                         NULL));
689
1179
          if(ret < 0){
690
 
            perror("sigprocmask");
691
 
            exitstatus = EXIT_FAILURE;
692
 
            goto end;
693
 
          }
694
 
          /* Delete this process entry from the list */
695
 
          if(process_list == proc){
696
 
            /* First one - simple */
697
 
            process_list = proc->next;
698
 
          } else {
699
 
            /* Second one or later */
700
 
            for(process *p = process_list; p != NULL; p = p->next){
701
 
              if(p->next == proc){
702
 
                p->next = proc->next;
703
 
                break;
704
 
              }
705
 
            }
706
 
          }
 
1180
            error(0, errno, "sigprocmask");
 
1181
            exitstatus = EX_OSERR;
 
1182
            goto fallback;
 
1183
          }
 
1184
          
 
1185
          plugin *next_plugin = proc->next;
 
1186
          free_plugin(proc);
 
1187
          proc = next_plugin;
 
1188
          
707
1189
          /* We are done modifying process list, so unblock signal */
708
 
          ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
709
 
                             NULL);
 
1190
          ret = (int)(TEMP_FAILURE_RETRY
 
1191
                      (sigprocmask(SIG_UNBLOCK,
 
1192
                                   &sigchld_action.sa_mask, NULL)));
710
1193
          if(ret < 0){
711
 
            perror("sigprocmask");
712
 
          }
713
 
          free(proc->buffer);
714
 
          free(proc);
715
 
          /* We deleted this process from the list, so we can't go
716
 
             proc->next.  Therefore, start over from the beginning of
717
 
             the process list */
718
 
          break;
 
1194
            error(0, errno, "sigprocmask");
 
1195
            exitstatus = EX_OSERR;
 
1196
            goto fallback;
 
1197
          }
 
1198
          
 
1199
          if(plugin_list == NULL){
 
1200
            break;
 
1201
          }
 
1202
          
 
1203
          continue;
719
1204
        }
 
1205
        
720
1206
        /* This process exited nicely, so print its buffer */
721
 
 
722
 
        bool bret = print_out_password(proc->buffer, proc->buffer_length);
 
1207
        
 
1208
        bool bret = print_out_password(proc->buffer,
 
1209
                                       proc->buffer_length);
723
1210
        if(not bret){
724
 
          perror("print_out_password");
725
 
          exitstatus = EXIT_FAILURE;
 
1211
          error(0, errno, "print_out_password");
 
1212
          exitstatus = EX_IOERR;
726
1213
        }
727
 
        goto end;
 
1214
        goto fallback;
728
1215
      }
 
1216
      
729
1217
      /* This process has not completed.  Does it have any output? */
730
1218
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
731
1219
        /* This process had nothing to say at this time */
 
1220
        proc = proc->next;
732
1221
        continue;
733
1222
      }
734
1223
      /* Before reading, make the process' data buffer large enough */
735
1224
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
736
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
737
 
                               + (size_t) BUFFER_SIZE);
738
 
        if (proc->buffer == NULL){
739
 
          perror("malloc");
740
 
          exitstatus = EXIT_FAILURE;
741
 
          goto end;
 
1225
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1226
                                   + (size_t) BUFFER_SIZE);
 
1227
        if(new_buffer == NULL){
 
1228
          error(0, errno, "malloc");
 
1229
          exitstatus = EX_OSERR;
 
1230
          goto fallback;
742
1231
        }
 
1232
        proc->buffer = new_buffer;
743
1233
        proc->buffer_size += BUFFER_SIZE;
744
1234
      }
745
1235
      /* Read from the process */
746
 
      ret = read(proc->fd, proc->buffer + proc->buffer_length,
747
 
                 BUFFER_SIZE);
748
 
      if(ret < 0){
 
1236
      sret = TEMP_FAILURE_RETRY(read(proc->fd,
 
1237
                                     proc->buffer
 
1238
                                     + proc->buffer_length,
 
1239
                                     BUFFER_SIZE));
 
1240
      if(sret < 0){
749
1241
        /* Read error from this process; ignore the error */
 
1242
        proc = proc->next;
750
1243
        continue;
751
1244
      }
752
 
      if(ret == 0){
 
1245
      if(sret == 0){
753
1246
        /* got EOF */
754
1247
        proc->eof = true;
755
1248
      } else {
756
 
        proc->buffer_length += (size_t) ret;
 
1249
        proc->buffer_length += (size_t) sret;
757
1250
      }
758
1251
    }
759
1252
  }
760
 
 
761
 
 
762
 
 end:
763
 
  
764
 
  if(process_list == NULL or exitstatus != EXIT_SUCCESS){
765
 
    /* Fallback if all plugins failed, none are found or an error occured */
 
1253
  
 
1254
  
 
1255
 fallback:
 
1256
  
 
1257
  if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
 
1258
                             and exitstatus != EX_OK)){
 
1259
    /* Fallback if all plugins failed, none are found or an error
 
1260
       occured */
766
1261
    bool bret;
767
1262
    fprintf(stderr, "Going to fallback mode using getpass(3)\n");
768
1263
    char *passwordbuffer = getpass("Password: ");
769
 
    bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
 
1264
    size_t len = strlen(passwordbuffer);
 
1265
    /* Strip trailing newline */
 
1266
    if(len > 0 and passwordbuffer[len-1] == '\n'){
 
1267
      passwordbuffer[len-1] = '\0'; /* not strictly necessary */
 
1268
      len--;
 
1269
    }
 
1270
    bret = print_out_password(passwordbuffer, len);
770
1271
    if(not bret){
771
 
      perror("print_out_password");
772
 
      exitstatus = EXIT_FAILURE;
773
 
      goto end;
 
1272
      error(0, errno, "print_out_password");
 
1273
      exitstatus = EX_IOERR;
774
1274
    }
775
1275
  }
776
1276
  
777
1277
  /* Restore old signal handler */
778
 
  sigaction(SIGCHLD, &old_sigchld_action, NULL);
779
 
  
780
 
  free(custom_argv);
781
 
  
782
 
  /* Free the plugin list */
783
 
  for(plugin *next; plugin_list != NULL; plugin_list = next){
784
 
    next = plugin_list->next;
785
 
    free(plugin_list->argv);
786
 
    free(plugin_list);
787
 
  }
788
 
  
789
 
  if(dir != NULL){
790
 
    closedir(dir);
791
 
  }
792
 
  
793
 
  /* Free the process list and kill the processes */
794
 
  for(process *next; process_list != NULL; process_list = next){
795
 
    next = process_list->next;
796
 
    close(process_list->fd);
797
 
    ret = kill(process_list->pid, SIGTERM);
798
 
    if(ret == -1 and errno != ESRCH){
799
 
      /* set-uid proccesses migth not get closed */
800
 
      perror("kill");
801
 
    }
802
 
    free(process_list->buffer);
803
 
    free(process_list);
 
1278
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
 
1279
  if(ret == -1){
 
1280
    error(0, errno, "sigaction");
 
1281
    exitstatus = EX_OSERR;
 
1282
  }
 
1283
  
 
1284
  if(custom_argv != NULL){
 
1285
    for(char **arg = custom_argv+1; *arg != NULL; arg++){
 
1286
      free(*arg);
 
1287
    }
 
1288
    free(custom_argv);
 
1289
  }
 
1290
  
 
1291
  free(direntries);
 
1292
  
 
1293
  if(dir_fd != -1){
 
1294
    close(dir_fd);
 
1295
  }
 
1296
  
 
1297
  /* Kill the processes */
 
1298
  for(plugin *p = plugin_list; p != NULL; p = p->next){
 
1299
    if(p->pid != 0){
 
1300
      close(p->fd);
 
1301
      ret = kill(p->pid, SIGTERM);
 
1302
      if(ret == -1 and errno != ESRCH){
 
1303
        /* Set-uid proccesses might not get closed */
 
1304
        error(0, errno, "kill");
 
1305
      }
 
1306
    }
804
1307
  }
805
1308
  
806
1309
  /* Wait for any remaining child processes to terminate */
807
 
  do{
 
1310
  do {
808
1311
    ret = wait(NULL);
809
1312
  } while(ret >= 0);
810
1313
  if(errno != ECHILD){
811
 
    perror("wait");
 
1314
    error(0, errno, "wait");
812
1315
  }
813
1316
  
 
1317
  free_plugin_list();
 
1318
  
 
1319
  free(plugindir);
 
1320
  free(pluginhelperdir);
 
1321
  free(argfile);
 
1322
  
814
1323
  return exitstatus;
815
1324
}