/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2019-02-09 23:23:26 UTC
  • 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
2
2
/*
3
3
 * Mandos plugin runner - Run Mandos plugins
4
4
 *
5
 
 * Copyright © 2008-2011 Teddy Hogeborn
6
 
 * Copyright © 2008-2011 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
23
 * Contact the authors at <mandos@recompile.se>.
23
24
 */
24
25
 
25
26
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
26
 
                                   asprintf(), O_CLOEXEC */
 
27
                                   O_CLOEXEC, pipe2() */
27
28
#include <stddef.h>             /* size_t, NULL */
28
29
#include <stdlib.h>             /* malloc(), exit(), EXIT_SUCCESS,
29
30
                                   realloc() */
30
31
#include <stdbool.h>            /* bool, true, false */
31
32
#include <stdio.h>              /* fileno(), fprintf(),
32
 
                                   stderr, STDOUT_FILENO */
33
 
#include <sys/types.h>          /* DIR, fdopendir(), stat(), struct
34
 
                                   stat, waitpid(), WIFEXITED(),
35
 
                                   WEXITSTATUS(), wait(), pid_t,
36
 
                                   uid_t, gid_t, getuid(), getgid(),
37
 
                                   dirfd() */
 
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(), WTERMSIG(),
42
 
                                   WCOREDUMP() */
43
 
#include <sys/stat.h>           /* struct stat, stat(), S_ISREG() */
 
41
                                   WEXITSTATUS(), WTERMSIG() */
 
42
#include <sys/stat.h>           /* struct stat, fstat(), S_ISREG() */
44
43
#include <iso646.h>             /* and, or, not */
45
 
#include <dirent.h>             /* DIR, struct dirent, fdopendir(),
46
 
                                   readdir(), closedir(), dirfd() */
47
 
#include <unistd.h>             /* struct stat, stat(), S_ISREG(),
48
 
                                   fcntl(), setuid(), setgid(),
49
 
                                   F_GETFD, F_SETFD, FD_CLOEXEC,
50
 
                                   access(), pipe(), fork(), close()
51
 
                                   dup2(), STDOUT_FILENO, _exit(),
52
 
                                   execv(), write(), read(),
53
 
                                   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
                                */
54
52
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
55
 
                                   FD_CLOEXEC */
56
 
#include <string.h>             /* strsep, strlen(), asprintf(),
57
 
                                   strsignal(), strcmp(), strncmp() */
 
53
                                   FD_CLOEXEC, openat(), scandirat(),
 
54
                                   pipe2() */
 
55
#include <string.h>             /* strsep, strlen(), strsignal(),
 
56
                                   strcmp(), strncmp() */
58
57
#include <errno.h>              /* errno */
59
58
#include <argp.h>               /* struct argp_option, struct
60
59
                                   argp_state, struct argp,
72
71
                                   EX_CONFIG, EX_UNAVAILABLE, EX_OK */
73
72
#include <errno.h>              /* errno */
74
73
#include <error.h>              /* error() */
 
74
#include <fnmatch.h>            /* fnmatch() */
75
75
 
76
76
#define BUFFER_SIZE 256
77
77
 
78
78
#define PDIR "/lib/mandos/plugins.d"
 
79
#define PHDIR "/lib/mandos/plugin-helpers"
79
80
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
80
81
 
81
82
const char *argp_program_version = "plugin-runner " VERSION;
105
106
 
106
107
/* Gets an existing plugin based on name,
107
108
   or if none is found, creates a new one */
 
109
__attribute__((warn_unused_result))
108
110
static plugin *getplugin(char *name){
109
111
  /* Check for existing plugin with that name */
110
112
  for(plugin *p = plugin_list; p != NULL; p = p->next){
171
173
}
172
174
 
173
175
/* Helper function for add_argument and add_environment */
 
176
__attribute__((nonnull, warn_unused_result))
174
177
static bool add_to_char_array(const char *new, char ***array,
175
178
                              int *len){
176
179
  /* Resize the pointed-to array to hold one more pointer */
 
180
  char **new_array = NULL;
177
181
  do {
178
 
    *array = realloc(*array, sizeof(char *)
179
 
                     * (size_t) ((*len) + 2));
180
 
  } while(*array == NULL and errno == EINTR);
 
182
    new_array = realloc(*array, sizeof(char *)
 
183
                        * (size_t) ((*len) + 2));
 
184
  } while(new_array == NULL and errno == EINTR);
181
185
  /* Malloc check */
182
 
  if(*array == NULL){
 
186
  if(new_array == NULL){
183
187
    return false;
184
188
  }
 
189
  *array = new_array;
185
190
  /* Make a copy of the new string */
186
191
  char *copy;
187
192
  do {
199
204
}
200
205
 
201
206
/* Add to a plugin's argument vector */
 
207
__attribute__((nonnull(2), warn_unused_result))
202
208
static bool add_argument(plugin *p, const char *arg){
203
209
  if(p == NULL){
204
210
    return false;
207
213
}
208
214
 
209
215
/* Add to a plugin's environment */
 
216
__attribute__((nonnull(2), warn_unused_result))
210
217
static bool add_environment(plugin *p, const char *def, bool replace){
211
218
  if(p == NULL){
212
219
    return false;
214
221
  /* namelen = length of name of environment variable */
215
222
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
216
223
  /* Search for this environment variable */
217
 
  for(char **e = p->environ; *e != NULL; e++){
218
 
    if(strncmp(*e, def, namelen + 1) == 0){
 
224
  for(char **envdef = p->environ; *envdef != NULL; envdef++){
 
225
    if(strncmp(*envdef, def, namelen + 1) == 0){
219
226
      /* It already exists */
220
227
      if(replace){
221
 
        char *new;
 
228
        char *new_envdef;
222
229
        do {
223
 
          new = realloc(*e, strlen(def) + 1);
224
 
        } while(new == NULL and errno == EINTR);
225
 
        if(new == NULL){
 
230
          new_envdef = realloc(*envdef, strlen(def) + 1);
 
231
        } while(new_envdef == NULL and errno == EINTR);
 
232
        if(new_envdef == NULL){
226
233
          return false;
227
234
        }
228
 
        *e = new;
229
 
        strcpy(*e, def);
 
235
        *envdef = new_envdef;
 
236
        strcpy(*envdef, def);
230
237
      }
231
238
      return true;
232
239
    }
234
241
  return add_to_char_array(def, &(p->environ), &(p->envc));
235
242
}
236
243
 
 
244
#ifndef O_CLOEXEC
237
245
/*
238
246
 * Based on the example in the GNU LibC manual chapter 13.13 "File
239
247
 * Descriptor Flags".
240
248
 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
241
249
 */
 
250
__attribute__((warn_unused_result))
242
251
static int set_cloexec_flag(int fd){
243
252
  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
244
253
  /* If reading the flags failed, return error indication now. */
249
258
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
250
259
                                       ret | FD_CLOEXEC));
251
260
}
 
261
#endif  /* not O_CLOEXEC */
252
262
 
253
263
 
254
264
/* Mark processes as completed when they exit, and save their exit
286
296
}
287
297
 
288
298
/* Prints out a password to stdout */
 
299
__attribute__((nonnull, warn_unused_result))
289
300
static bool print_out_password(const char *buffer, size_t length){
290
301
  ssize_t ret;
291
302
  for(size_t written = 0; written < length; written += (size_t)ret){
299
310
}
300
311
 
301
312
/* Removes and free a plugin from the plugin list */
 
313
__attribute__((nonnull))
302
314
static void free_plugin(plugin *plugin_node){
303
315
  
304
316
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
336
348
 
337
349
int main(int argc, char *argv[]){
338
350
  char *plugindir = NULL;
 
351
  char *pluginhelperdir = NULL;
339
352
  char *argfile = NULL;
340
353
  FILE *conffp;
341
 
  size_t d_name_len;
342
 
  DIR *dir = NULL;
343
 
  struct dirent *dirst;
 
354
  struct dirent **direntries = NULL;
344
355
  struct stat st;
345
356
  fd_set rfds_all;
346
357
  int ret, maxfd = 0;
354
365
                                      .sa_flags = SA_NOCLDSTOP };
355
366
  char **custom_argv = NULL;
356
367
  int custom_argc = 0;
 
368
  int dir_fd = -1;
357
369
  
358
370
  /* Establish a signal handler */
359
371
  sigemptyset(&sigchld_action.sa_mask);
404
416
      .doc = "Group ID the plugins will run as", .group = 3 },
405
417
    { .name = "debug", .key = 132,
406
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 },
407
423
    /*
408
424
     * These reproduce what we would get without ARGP_NO_HELP
409
425
     */
416
432
    { .name = NULL }
417
433
  };
418
434
  
 
435
  __attribute__((nonnull(3)))
419
436
  error_t parse_opt(int key, char *arg, struct argp_state *state){
420
437
    errno = 0;
421
438
    switch(key){
422
439
      char *tmp;
423
 
      intmax_t tmpmax;
 
440
      intmax_t tmp_id;
424
441
    case 'g':                   /* --global-options */
425
442
      {
426
443
        char *plugin_option;
429
446
            break;
430
447
          }
431
448
        }
 
449
        errno = 0;
432
450
      }
433
451
      break;
434
452
    case 'G':                   /* --global-env */
435
 
      add_environment(getplugin(NULL), arg, true);
 
453
      if(add_environment(getplugin(NULL), arg, true)){
 
454
        errno = 0;
 
455
      }
436
456
      break;
437
457
    case 'o':                   /* --options-for */
438
458
      {
455
475
            break;
456
476
          }
457
477
        }
 
478
        errno = 0;
458
479
      }
459
480
      break;
460
481
    case 'E':                   /* --env-for */
472
493
          errno = EINVAL;
473
494
          break;
474
495
        }
475
 
        add_environment(getplugin(arg), envdef, true);
 
496
        if(add_environment(getplugin(arg), envdef, true)){
 
497
          errno = 0;
 
498
        }
476
499
      }
477
500
      break;
478
501
    case 'd':                   /* --disable */
480
503
        plugin *p = getplugin(arg);
481
504
        if(p != NULL){
482
505
          p->disabled = true;
 
506
          errno = 0;
483
507
        }
484
508
      }
485
509
      break;
488
512
        plugin *p = getplugin(arg);
489
513
        if(p != NULL){
490
514
          p->disabled = false;
 
515
          errno = 0;
491
516
        }
492
517
      }
493
518
      break;
494
519
    case 128:                   /* --plugin-dir */
495
520
      free(plugindir);
496
521
      plugindir = strdup(arg);
 
522
      if(plugindir != NULL){
 
523
        errno = 0;
 
524
      }
497
525
      break;
498
526
    case 129:                   /* --config-file */
499
527
      /* This is already done by parse_opt_config_file() */
500
528
      break;
501
529
    case 130:                   /* --userid */
502
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
530
      tmp_id = strtoimax(arg, &tmp, 10);
503
531
      if(errno != 0 or tmp == arg or *tmp != '\0'
504
 
         or tmpmax != (uid_t)tmpmax){
 
532
         or tmp_id != (uid_t)tmp_id){
505
533
        argp_error(state, "Bad user ID number: \"%s\", using %"
506
534
                   PRIdMAX, arg, (intmax_t)uid);
507
535
        break;
508
536
      }
509
 
      uid = (uid_t)tmpmax;
 
537
      uid = (uid_t)tmp_id;
 
538
      errno = 0;
510
539
      break;
511
540
    case 131:                   /* --groupid */
512
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
541
      tmp_id = strtoimax(arg, &tmp, 10);
513
542
      if(errno != 0 or tmp == arg or *tmp != '\0'
514
 
         or tmpmax != (gid_t)tmpmax){
 
543
         or tmp_id != (gid_t)tmp_id){
515
544
        argp_error(state, "Bad group ID number: \"%s\", using %"
516
545
                   PRIdMAX, arg, (intmax_t)gid);
517
546
        break;
518
547
      }
519
 
      gid = (gid_t)tmpmax;
 
548
      gid = (gid_t)tmp_id;
 
549
      errno = 0;
520
550
      break;
521
551
    case 132:                   /* --debug */
522
552
      debug = true;
523
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;
524
561
      /*
525
562
       * These reproduce what we would get without ARGP_NO_HELP
526
563
       */
546
583
      if(arg[0] == '\0'){
547
584
        break;
548
585
      }
 
586
      /* FALLTHROUGH */
549
587
    default:
550
588
      return ARGP_ERR_UNKNOWN;
551
589
    }
570
608
    case 129:                   /* --config-file */
571
609
      free(argfile);
572
610
      argfile = strdup(arg);
 
611
      if(argfile != NULL){
 
612
        errno = 0;
 
613
      }
573
614
      break;
574
615
    case 130:                   /* --userid */
575
616
    case 131:                   /* --groupid */
576
617
    case 132:                   /* --debug */
 
618
    case 133:                   /* --plugin-helper-dir */
577
619
    case '?':                   /* --help */
578
620
    case -3:                    /* --usage */
579
621
    case 'V':                   /* --version */
658
700
        }
659
701
        
660
702
        custom_argc += 1;
661
 
        custom_argv = realloc(custom_argv, sizeof(char *)
662
 
                              * ((unsigned int) custom_argc + 1));
663
 
        if(custom_argv == NULL){
664
 
          error(0, errno, "realloc");
665
 
          exitstatus = EX_OSERR;
666
 
          free(org_line);
667
 
          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
          }
668
715
        }
669
716
        custom_argv[custom_argc-1] = new_arg;
670
717
        custom_argv[custom_argc] = NULL;
728
775
    goto fallback;
729
776
  }
730
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
    }
 
794
  }
 
795
  
731
796
  if(debug){
732
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
797
    for(plugin *p = plugin_list; p != NULL; p = p->next){
733
798
      fprintf(stderr, "Plugin: %s has %d arguments\n",
734
799
              p->name ? p->name : "Global", p->argc - 1);
735
800
      for(char **a = p->argv; *a != NULL; a++){
744
809
  
745
810
  if(getuid() == 0){
746
811
    /* Work around Debian bug #633582:
747
 
       <http://bugs.debian.org/633582> */
 
812
       <https://bugs.debian.org/633582> */
748
813
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
749
814
    if(plugindir_fd == -1){
750
 
      error(0, errno, "open");
 
815
      if(errno != ENOENT){
 
816
        error(0, errno, "open(\"" PDIR "\")");
 
817
      }
751
818
    } else {
752
819
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
753
820
      if(ret == -1){
760
827
          }
761
828
        }
762
829
      }
763
 
      TEMP_FAILURE_RETRY(close(plugindir_fd));
 
830
      close(plugindir_fd);
764
831
    }
765
832
  }
766
833
  
767
834
  /* Lower permissions */
768
 
  setgid(gid);
 
835
  ret = setgid(gid);
769
836
  if(ret == -1){
770
837
    error(0, errno, "setgid");
771
838
  }
776
843
  
777
844
  /* Open plugin directory with close_on_exec flag */
778
845
  {
779
 
    int dir_fd = -1;
780
 
    if(plugindir == NULL){
781
 
      dir_fd = open(PDIR, O_RDONLY |
782
 
#ifdef O_CLOEXEC
783
 
                    O_CLOEXEC
784
 
#else  /* not O_CLOEXEC */
785
 
                    0
786
 
#endif  /* not O_CLOEXEC */
787
 
                    );
788
 
    } else {
789
 
      dir_fd = open(plugindir, O_RDONLY |
790
 
#ifdef O_CLOEXEC
791
 
                    O_CLOEXEC
792
 
#else  /* not O_CLOEXEC */
793
 
                    0
794
 
#endif  /* not O_CLOEXEC */
795
 
                    );
796
 
    }
 
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
                  );
797
853
    if(dir_fd == -1){
798
854
      error(0, errno, "Could not open plugin dir");
799
855
      exitstatus = EX_UNAVAILABLE;
805
861
    ret = set_cloexec_flag(dir_fd);
806
862
    if(ret < 0){
807
863
      error(0, errno, "set_cloexec_flag");
808
 
      TEMP_FAILURE_RETRY(close(dir_fd));
809
864
      exitstatus = EX_OSERR;
810
865
      goto fallback;
811
866
    }
812
867
#endif  /* O_CLOEXEC */
813
 
    
814
 
    dir = fdopendir(dir_fd);
815
 
    if(dir == NULL){
816
 
      error(0, errno, "Could not open plugin dir");
817
 
      TEMP_FAILURE_RETRY(close(dir_fd));
818
 
      exitstatus = EX_OSERR;
819
 
      goto fallback;
 
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;
 
890
      }
820
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;
821
902
  }
822
903
  
823
904
  FD_ZERO(&rfds_all);
824
905
  
825
906
  /* Read and execute any executable in the plugin directory*/
826
 
  while(true){
827
 
    do {
828
 
      dirst = readdir(dir);
829
 
    } while(dirst == NULL and errno == EINTR);
830
 
    
831
 
    /* All directory entries have been processed */
832
 
    if(dirst == NULL){
833
 
      if(errno == EBADF){
834
 
        error(0, errno, "readdir");
835
 
        exitstatus = EX_IOERR;
836
 
        goto fallback;
837
 
      }
838
 
      break;
839
 
    }
840
 
    
841
 
    d_name_len = strlen(dirst->d_name);
842
 
    
843
 
    /* Ignore dotfiles, backup files and other junk */
844
 
    {
845
 
      bool bad_name = false;
846
 
      
847
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
848
 
      
849
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
850
 
                                           ".dpkg-old",
851
 
                                           ".dpkg-bak",
852
 
                                           ".dpkg-divert", NULL };
853
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
854
 
        size_t pre_len = strlen(*pre);
855
 
        if((d_name_len >= pre_len)
856
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
857
 
          if(debug){
858
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
859
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
860
 
          }
861
 
          bad_name = true;
862
 
          break;
863
 
        }
864
 
      }
865
 
      if(bad_name){
866
 
        continue;
867
 
      }
868
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
869
 
        size_t suf_len = strlen(*suf);
870
 
        if((d_name_len >= suf_len)
871
 
           and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
872
 
                == 0)){
873
 
          if(debug){
874
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
875
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
876
 
          }
877
 
          bad_name = true;
878
 
          break;
879
 
        }
880
 
      }
881
 
      
882
 
      if(bad_name){
883
 
        continue;
884
 
      }
885
 
    }
886
 
    
887
 
    char *filename;
888
 
    if(plugindir == NULL){
889
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
890
 
                                             dirst->d_name));
891
 
    } else {
892
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
893
 
                                             plugindir,
894
 
                                             dirst->d_name));
895
 
    }
896
 
    if(ret < 0){
897
 
      error(0, errno, "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]);
898
913
      continue;
899
914
    }
900
 
    
901
 
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
 
915
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
902
916
    if(ret == -1){
903
917
      error(0, errno, "stat");
904
 
      free(filename);
 
918
      close(plugin_fd);
 
919
      free(direntries[i]);
905
920
      continue;
906
921
    }
907
922
    
908
923
    /* Ignore non-executable files */
909
924
    if(not S_ISREG(st.st_mode)
910
 
       or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
 
925
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
926
                                        X_OK, 0)) != 0)){
911
927
      if(debug){
912
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
913
 
                " 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);
914
932
      }
915
 
      free(filename);
 
933
      close(plugin_fd);
 
934
      free(direntries[i]);
916
935
      continue;
917
936
    }
918
937
    
919
 
    plugin *p = getplugin(dirst->d_name);
 
938
    plugin *p = getplugin(direntries[i]->d_name);
920
939
    if(p == NULL){
921
940
      error(0, errno, "getplugin");
922
 
      free(filename);
 
941
      close(plugin_fd);
 
942
      free(direntries[i]);
923
943
      continue;
924
944
    }
925
945
    if(p->disabled){
926
946
      if(debug){
927
947
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
928
 
                dirst->d_name);
 
948
                direntries[i]->d_name);
929
949
      }
930
 
      free(filename);
 
950
      close(plugin_fd);
 
951
      free(direntries[i]);
931
952
      continue;
932
953
    }
933
954
    {
947
968
        }
948
969
      }
949
970
    }
950
 
    /* If this plugin has any environment variables, we will call
951
 
       using execve and need to duplicate the environment from this
952
 
       process, too. */
 
971
    /* If this plugin has any environment variables, we need to
 
972
       duplicate the environment from this process, too. */
953
973
    if(p->environ[0] != NULL){
954
974
      for(char **e = environ; *e != NULL; e++){
955
975
        if(not add_environment(p, *e, false)){
959
979
    }
960
980
    
961
981
    int pipefd[2];
 
982
#ifndef O_CLOEXEC
962
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 */
963
987
    if(ret == -1){
964
988
      error(0, errno, "pipe");
965
989
      exitstatus = EX_OSERR;
966
 
      goto fallback;
967
 
    }
 
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
968
1003
    /* Ask OS to automatic close the pipe on exec */
969
1004
    ret = set_cloexec_flag(pipefd[0]);
970
1005
    if(ret < 0){
971
1006
      error(0, errno, "set_cloexec_flag");
 
1007
      close(pipefd[0]);
 
1008
      close(pipefd[1]);
972
1009
      exitstatus = EX_OSERR;
 
1010
      free(direntries[i]);
973
1011
      goto fallback;
974
1012
    }
975
1013
    ret = set_cloexec_flag(pipefd[1]);
976
1014
    if(ret < 0){
977
1015
      error(0, errno, "set_cloexec_flag");
 
1016
      close(pipefd[0]);
 
1017
      close(pipefd[1]);
978
1018
      exitstatus = EX_OSERR;
 
1019
      free(direntries[i]);
979
1020
      goto fallback;
980
1021
    }
 
1022
#endif  /* not O_CLOEXEC */
981
1023
    /* Block SIGCHLD until process is safely in process list */
982
1024
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
983
1025
                                              &sigchld_action.sa_mask,
985
1027
    if(ret < 0){
986
1028
      error(0, errno, "sigprocmask");
987
1029
      exitstatus = EX_OSERR;
 
1030
      free(direntries[i]);
988
1031
      goto fallback;
989
1032
    }
990
1033
    /* Starting a new process to be watched */
994
1037
    } while(pid == -1 and errno == EINTR);
995
1038
    if(pid == -1){
996
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]);
997
1044
      exitstatus = EX_OSERR;
 
1045
      free(direntries[i]);
998
1046
      goto fallback;
999
1047
    }
1000
1048
    if(pid == 0){
1016
1064
        _exit(EX_OSERR);
1017
1065
      }
1018
1066
      
1019
 
      if(dirfd(dir) < 0){
1020
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
1021
 
           above and must now close it manually here. */
1022
 
        closedir(dir);
1023
 
      }
1024
 
      if(p->environ[0] == NULL){
1025
 
        if(execv(filename, p->argv) < 0){
1026
 
          error(0, errno, "execv for %s", filename);
1027
 
          _exit(EX_OSERR);
1028
 
        }
1029
 
      } else {
1030
 
        if(execve(filename, p->argv, p->environ) < 0){
1031
 
          error(0, errno, "execve for %s", filename);
1032
 
          _exit(EX_OSERR);
1033
 
        }
 
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);
1034
1073
      }
1035
1074
      /* no return */
1036
1075
    }
1037
1076
    /* Parent process */
1038
 
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1039
 
                                             pipe */
1040
 
    free(filename);
1041
 
    plugin *new_plugin = getplugin(dirst->d_name);
 
1077
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1078
    close(plugin_fd);
 
1079
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1042
1080
    if(new_plugin == NULL){
1043
1081
      error(0, errno, "getplugin");
1044
1082
      ret = (int)(TEMP_FAILURE_RETRY
1048
1086
        error(0, errno, "sigprocmask");
1049
1087
      }
1050
1088
      exitstatus = EX_OSERR;
 
1089
      free(direntries[i]);
1051
1090
      goto fallback;
1052
1091
    }
 
1092
    free(direntries[i]);
1053
1093
    
1054
1094
    new_plugin->pid = pid;
1055
1095
    new_plugin->fd = pipefd[0];
1056
 
    
 
1096
 
 
1097
    if(debug){
 
1098
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1099
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1100
    }
 
1101
 
1057
1102
    /* Unblock SIGCHLD so signal handler can be run if this process
1058
1103
       has already completed */
1059
1104
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1065
1110
      goto fallback;
1066
1111
    }
1067
1112
    
1068
 
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1069
 
                                          -Wconversion */
 
1113
    FD_SET(new_plugin->fd, &rfds_all);
1070
1114
    
1071
1115
    if(maxfd < new_plugin->fd){
1072
1116
      maxfd = new_plugin->fd;
1073
1117
    }
1074
1118
  }
1075
1119
  
1076
 
  TEMP_FAILURE_RETRY(closedir(dir));
1077
 
  dir = NULL;
 
1120
  free(direntries);
 
1121
  direntries = NULL;
 
1122
  close(dir_fd);
 
1123
  dir_fd = -1;
1078
1124
  free_plugin(getplugin(NULL));
1079
1125
  
1080
1126
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1119
1165
                      (intmax_t) (proc->pid),
1120
1166
                      WTERMSIG(proc->status),
1121
1167
                      strsignal(WTERMSIG(proc->status)));
1122
 
            } else if(WCOREDUMP(proc->status)){
1123
 
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1124
 
                      " core\n", proc->name, (intmax_t) (proc->pid));
1125
1168
            }
1126
1169
          }
1127
1170
          
1128
1171
          /* Remove the plugin */
1129
 
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1130
 
                                          -Wconversion */
 
1172
          FD_CLR(proc->fd, &rfds_all);
1131
1173
          
1132
1174
          /* Block signal while modifying process_list */
1133
1175
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1173
1215
      }
1174
1216
      
1175
1217
      /* This process has not completed.  Does it have any output? */
1176
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1177
 
                                                         warning from
1178
 
                                                         -Wconversion */
 
1218
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1179
1219
        /* This process had nothing to say at this time */
1180
1220
        proc = proc->next;
1181
1221
        continue;
1182
1222
      }
1183
1223
      /* Before reading, make the process' data buffer large enough */
1184
1224
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1185
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1186
 
                               + (size_t) BUFFER_SIZE);
1187
 
        if(proc->buffer == NULL){
 
1225
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1226
                                   + (size_t) BUFFER_SIZE);
 
1227
        if(new_buffer == NULL){
1188
1228
          error(0, errno, "malloc");
1189
1229
          exitstatus = EX_OSERR;
1190
1230
          goto fallback;
1191
1231
        }
 
1232
        proc->buffer = new_buffer;
1192
1233
        proc->buffer_size += BUFFER_SIZE;
1193
1234
      }
1194
1235
      /* Read from the process */
1247
1288
    free(custom_argv);
1248
1289
  }
1249
1290
  
1250
 
  if(dir != NULL){
1251
 
    closedir(dir);
 
1291
  free(direntries);
 
1292
  
 
1293
  if(dir_fd != -1){
 
1294
    close(dir_fd);
1252
1295
  }
1253
1296
  
1254
1297
  /* Kill the processes */
1274
1317
  free_plugin_list();
1275
1318
  
1276
1319
  free(plugindir);
 
1320
  free(pluginhelperdir);
1277
1321
  free(argfile);
1278
1322
  
1279
1323
  return exitstatus;