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