/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: 2024-09-09 04:24:39 UTC
  • Revision ID: teddy@recompile.se-20240909042439-j85mr20uli2hnyis
Eliminate compiler warnings

Many programs use nested functions, which now result in a linker
warning about executable stack.  Hide this warning.  Also, rewrite a
loop in the plymouth plugin to avoid warning about signed overflow.
This change also makes the plugin pick the alphabetically first
process entry instead of the last, in case many plymouth processes are
found (which should be unlikely).

* Makefile (plugin-runner, dracut-module/password-agent,
  plugins.d/password-prompt, plugins.d/mandos-client,
  plugins.d/plymouth): New target; set LDFLAGS to add "-Xlinker
  --no-warn-execstack".
* plugins.d/plymouth.c (get_pid): When no pid files are found, and we
  are looking through the process list, go though it from the start
  instead of from the end, i.e. in normal alphabetical order and not
  in reverse order.

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-2013 Teddy Hogeborn
6
 
 * Copyright © 2008-2013 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-2022 Teddy Hogeborn
 
6
 * Copyright © 2008-2022 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
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
26
 
                                   asprintf(), O_CLOEXEC */
 
26
#define _GNU_SOURCE             /* strchrnul(), TEMP_FAILURE_RETRY(),
 
27
                                   getline(), asprintf(), O_CLOEXEC,
 
28
                                   scandirat(), pipe2() */
 
29
#include <argp.h>               /* argp_program_version,
 
30
                                   argp_program_bug_address,
 
31
                                   struct argp_option,
 
32
                                   struct argp_state, argp_error(),
 
33
                                   ARGP_NO_EXIT, argp_state_help,
 
34
                                   ARGP_HELP_STD_HELP,
 
35
                                   ARGP_HELP_USAGE, ARGP_HELP_EXIT_OK,
 
36
                                   ARGP_KEY_ARG, ARGP_ERR_UNKNOWN,
 
37
                                   struct argp, argp_parse(),
 
38
                                   ARGP_IN_ORDER, ARGP_NO_HELP */
 
39
#include <stdbool.h>            /* bool, false, true */
 
40
#include <sys/types.h>          /* pid_t, sig_atomic_t, uid_t, gid_t,
 
41
                                   getuid(), setgid(), setuid() */
27
42
#include <stddef.h>             /* size_t, NULL */
28
 
#include <stdlib.h>             /* malloc(), exit(), EXIT_SUCCESS,
29
 
                                   realloc() */
30
 
#include <stdbool.h>            /* bool, true, false */
31
 
#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() */
38
 
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
39
 
                                   FD_SET(), FD_ISSET(), FD_CLR */
40
 
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
41
 
                                   WEXITSTATUS(), WTERMSIG(),
42
 
                                   WCOREDUMP() */
43
 
#include <sys/stat.h>           /* struct stat, stat(), S_ISREG() */
44
 
#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() */
 
43
#include <iso646.h>             /* or, and, not */
 
44
#include <string.h>             /* strcmp(), strdup(), strchrnul(),
 
45
                                   strncmp(), strlen(), strcpy(),
 
46
                                   strsep(), strchr(), strsignal() */
 
47
#include <stdlib.h>             /* malloc(), free(), reallocarray(),
 
48
                                   realloc(), EXIT_SUCCESS */
 
49
#include <errno.h>              /* errno, EINTR, ENOMEM, ECHILD,
 
50
                                   error_t, EINVAL, EMFILE, ENFILE,
 
51
                                   ENOENT, ESRCH */
 
52
#include <stdint.h>             /* SIZE_MAX */
 
53
#define _GNU_SOURCE             /* strchrnul(), TEMP_FAILURE_RETRY(),
 
54
                                   getline(), asprintf(), O_CLOEXEC,
 
55
                                   scandirat(), pipe2() */
 
56
#include <unistd.h>             /* TEMP_FAILURE_RETRY(), ssize_t,
 
57
                                   write(), STDOUT_FILENO, uid_t,
 
58
                                   gid_t, getuid(), fchown(), close(),
 
59
                                   symlink(), setgid(), setuid(),
 
60
                                   faccessat(), X_OK, pipe(), pipe2(),
 
61
                                   fork(), _exit(), dup2(), fexecve(),
 
62
                                   read(), getpass() */
54
63
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
55
 
                                   FD_CLOEXEC */
56
 
#include <string.h>             /* strsep, strlen(), asprintf(),
57
 
                                   strsignal(), strcmp(), strncmp() */
58
 
#include <errno.h>              /* errno */
59
 
#include <argp.h>               /* struct argp_option, struct
60
 
                                   argp_state, struct argp,
61
 
                                   argp_parse(), ARGP_ERR_UNKNOWN,
62
 
                                   ARGP_KEY_END, ARGP_KEY_ARG,
63
 
                                   error_t */
64
 
#include <signal.h>             /* struct sigaction, sigemptyset(),
65
 
                                   sigaddset(), sigaction(),
66
 
                                   sigprocmask(), SIG_BLOCK, SIGCHLD,
67
 
                                   SIG_UNBLOCK, kill(), sig_atomic_t
68
 
                                */
69
 
#include <errno.h>              /* errno, EBADF */
70
 
#include <inttypes.h>           /* intmax_t, PRIdMAX, strtoimax() */
 
64
                                   FD_CLOEXEC, open(), O_RDONLY,
 
65
                                   O_CLOEXEC, openat() */
 
66
#include <sys/wait.h>           /* waitpid(), WNOHANG, WIFEXITED(),
 
67
                                   WEXITSTATUS(), WIFSIGNALED(),
 
68
                                   WTERMSIG(), wait() */
 
69
#include <error.h>              /* error() */
 
70
#include <stdio.h>              /* FILE, fprintf(), fopen(),
 
71
                                   getline(), fclose(), EOF,
 
72
                                   asprintf(), stderr */
 
73
#include <dirent.h>             /* struct dirent, scandirat(),
 
74
                                   alphasort() */
 
75
#include <sys/stat.h>           /* struct stat, fstat(), S_ISDIR(),
 
76
                                   lstat(), S_ISREG() */
 
77
#include <sys/select.h>         /* fd_set, FD_ZERO(), FD_SETSIZE,
 
78
                                   FD_SET(), select(), FD_CLR(),
 
79
                                   FD_ISSET() */
 
80
#include <signal.h>             /* struct sigaction, SA_NOCLDSTOP,
 
81
                                   sigemptyset(), sigaddset(),
 
82
                                   SIGCHLD, sigprocmask(), SIG_BLOCK,
 
83
                                   SIG_UNBLOCK, kill(), SIGTERM */
71
84
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_IOERR,
72
85
                                   EX_CONFIG, EX_UNAVAILABLE, EX_OK */
73
 
#include <errno.h>              /* errno */
74
 
#include <error.h>              /* error() */
 
86
#include <inttypes.h>           /* intmax_t, strtoimax(), PRIdMAX */
 
87
#include <fnmatch.h>            /* fnmatch(), FNM_FILE_NAME,
 
88
                                   FNM_PERIOD, FNM_NOMATCH */
75
89
 
76
90
#define BUFFER_SIZE 256
77
91
 
78
92
#define PDIR "/lib/mandos/plugins.d"
 
93
#define PHDIR "/lib/mandos/plugin-helpers"
79
94
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
80
95
 
81
96
const char *argp_program_version = "plugin-runner " VERSION;
105
120
 
106
121
/* Gets an existing plugin based on name,
107
122
   or if none is found, creates a new one */
 
123
__attribute__((warn_unused_result))
108
124
static plugin *getplugin(char *name){
109
125
  /* Check for existing plugin with that name */
110
126
  for(plugin *p = plugin_list; p != NULL; p = p->next){
171
187
}
172
188
 
173
189
/* Helper function for add_argument and add_environment */
174
 
__attribute__((nonnull))
 
190
__attribute__((nonnull, warn_unused_result))
175
191
static bool add_to_char_array(const char *new, char ***array,
176
192
                              int *len){
177
193
  /* Resize the pointed-to array to hold one more pointer */
 
194
  char **new_array = NULL;
178
195
  do {
179
 
    *array = realloc(*array, sizeof(char *)
180
 
                     * (size_t) ((*len) + 2));
181
 
  } while(*array == NULL and errno == EINTR);
 
196
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
197
    new_array = reallocarray(*array, (size_t)((*len) + 2),
 
198
                             sizeof(char *));
 
199
#else
 
200
    if(((size_t)((*len) + 2)) > (SIZE_MAX / sizeof(char *))){
 
201
      /* overflow */
 
202
      new_array = NULL;
 
203
      errno = ENOMEM;
 
204
    } else {
 
205
      new_array = realloc(*array, (size_t)((*len) + 2)
 
206
                          * sizeof(char *));
 
207
    }
 
208
#endif
 
209
  } while(new_array == NULL and errno == EINTR);
182
210
  /* Malloc check */
183
 
  if(*array == NULL){
 
211
  if(new_array == NULL){
184
212
    return false;
185
213
  }
 
214
  *array = new_array;
186
215
  /* Make a copy of the new string */
187
216
  char *copy;
188
217
  do {
200
229
}
201
230
 
202
231
/* Add to a plugin's argument vector */
203
 
__attribute__((nonnull(2)))
 
232
__attribute__((nonnull(2), warn_unused_result))
204
233
static bool add_argument(plugin *p, const char *arg){
205
234
  if(p == NULL){
206
235
    return false;
209
238
}
210
239
 
211
240
/* Add to a plugin's environment */
212
 
__attribute__((nonnull(2)))
 
241
__attribute__((nonnull(2), warn_unused_result))
213
242
static bool add_environment(plugin *p, const char *def, bool replace){
214
243
  if(p == NULL){
215
244
    return false;
217
246
  /* namelen = length of name of environment variable */
218
247
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
219
248
  /* Search for this environment variable */
220
 
  for(char **e = p->environ; *e != NULL; e++){
221
 
    if(strncmp(*e, def, namelen + 1) == 0){
 
249
  for(char **envdef = p->environ; *envdef != NULL; envdef++){
 
250
    if(strncmp(*envdef, def, namelen + 1) == 0){
222
251
      /* It already exists */
223
252
      if(replace){
224
 
        char *new;
 
253
        char *new_envdef;
225
254
        do {
226
 
          new = realloc(*e, strlen(def) + 1);
227
 
        } while(new == NULL and errno == EINTR);
228
 
        if(new == NULL){
 
255
          new_envdef = realloc(*envdef, strlen(def) + 1);
 
256
        } while(new_envdef == NULL and errno == EINTR);
 
257
        if(new_envdef == NULL){
229
258
          return false;
230
259
        }
231
 
        *e = new;
232
 
        strcpy(*e, def);
 
260
        *envdef = new_envdef;
 
261
        strcpy(*envdef, def);
233
262
      }
234
263
      return true;
235
264
    }
237
266
  return add_to_char_array(def, &(p->environ), &(p->envc));
238
267
}
239
268
 
 
269
#ifndef O_CLOEXEC
240
270
/*
241
271
 * Based on the example in the GNU LibC manual chapter 13.13 "File
242
272
 * Descriptor Flags".
243
273
 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
244
274
 */
 
275
__attribute__((warn_unused_result))
245
276
static int set_cloexec_flag(int fd){
246
277
  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
247
278
  /* If reading the flags failed, return error indication now. */
252
283
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
253
284
                                       ret | FD_CLOEXEC));
254
285
}
 
286
#endif  /* not O_CLOEXEC */
255
287
 
256
288
 
257
289
/* Mark processes as completed when they exit, and save their exit
289
321
}
290
322
 
291
323
/* Prints out a password to stdout */
292
 
__attribute__((nonnull))
 
324
__attribute__((nonnull, warn_unused_result))
293
325
static bool print_out_password(const char *buffer, size_t length){
294
326
  ssize_t ret;
295
327
  for(size_t written = 0; written < length; written += (size_t)ret){
306
338
__attribute__((nonnull))
307
339
static void free_plugin(plugin *plugin_node){
308
340
  
309
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
341
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
310
342
    free(*arg);
311
343
  }
 
344
  free(plugin_node->name);
312
345
  free(plugin_node->argv);
313
346
  for(char **env = plugin_node->environ; *env != NULL; env++){
314
347
    free(*env);
341
374
 
342
375
int main(int argc, char *argv[]){
343
376
  char *plugindir = NULL;
 
377
  char *pluginhelperdir = NULL;
344
378
  char *argfile = NULL;
345
379
  FILE *conffp;
346
 
  size_t d_name_len;
347
 
  DIR *dir = NULL;
348
 
  struct dirent *dirst;
 
380
  struct dirent **direntries = NULL;
349
381
  struct stat st;
350
382
  fd_set rfds_all;
351
383
  int ret, maxfd = 0;
359
391
                                      .sa_flags = SA_NOCLDSTOP };
360
392
  char **custom_argv = NULL;
361
393
  int custom_argc = 0;
 
394
  int dir_fd = -1;
362
395
  
363
396
  /* Establish a signal handler */
364
397
  sigemptyset(&sigchld_action.sa_mask);
409
442
      .doc = "Group ID the plugins will run as", .group = 3 },
410
443
    { .name = "debug", .key = 132,
411
444
      .doc = "Debug mode", .group = 4 },
 
445
    { .name = "plugin-helper-dir", .key = 133,
 
446
      .arg = "DIRECTORY",
 
447
      .doc = "Specify a different plugin helper directory",
 
448
      .group = 2 },
412
449
    /*
413
450
     * These reproduce what we would get without ARGP_NO_HELP
414
451
     */
435
472
            break;
436
473
          }
437
474
        }
 
475
        errno = 0;
438
476
      }
439
477
      break;
440
478
    case 'G':                   /* --global-env */
441
 
      add_environment(getplugin(NULL), arg, true);
 
479
      if(add_environment(getplugin(NULL), arg, true)){
 
480
        errno = 0;
 
481
      }
442
482
      break;
443
483
    case 'o':                   /* --options-for */
444
484
      {
461
501
            break;
462
502
          }
463
503
        }
 
504
        errno = 0;
464
505
      }
465
506
      break;
466
507
    case 'E':                   /* --env-for */
478
519
          errno = EINVAL;
479
520
          break;
480
521
        }
481
 
        add_environment(getplugin(arg), envdef, true);
 
522
        if(add_environment(getplugin(arg), envdef, true)){
 
523
          errno = 0;
 
524
        }
482
525
      }
483
526
      break;
484
527
    case 'd':                   /* --disable */
486
529
        plugin *p = getplugin(arg);
487
530
        if(p != NULL){
488
531
          p->disabled = true;
 
532
          errno = 0;
489
533
        }
490
534
      }
491
535
      break;
494
538
        plugin *p = getplugin(arg);
495
539
        if(p != NULL){
496
540
          p->disabled = false;
 
541
          errno = 0;
497
542
        }
498
543
      }
499
544
      break;
500
545
    case 128:                   /* --plugin-dir */
501
546
      free(plugindir);
502
547
      plugindir = strdup(arg);
 
548
      if(plugindir != NULL){
 
549
        errno = 0;
 
550
      }
503
551
      break;
504
552
    case 129:                   /* --config-file */
505
553
      /* This is already done by parse_opt_config_file() */
513
561
        break;
514
562
      }
515
563
      uid = (uid_t)tmp_id;
 
564
      errno = 0;
516
565
      break;
517
566
    case 131:                   /* --groupid */
518
567
      tmp_id = strtoimax(arg, &tmp, 10);
523
572
        break;
524
573
      }
525
574
      gid = (gid_t)tmp_id;
 
575
      errno = 0;
526
576
      break;
527
577
    case 132:                   /* --debug */
528
578
      debug = true;
529
579
      break;
 
580
    case 133:                   /* --plugin-helper-dir */
 
581
      free(pluginhelperdir);
 
582
      pluginhelperdir = strdup(arg);
 
583
      if(pluginhelperdir != NULL){
 
584
        errno = 0;
 
585
      }
 
586
      break;
530
587
      /*
531
588
       * These reproduce what we would get without ARGP_NO_HELP
532
589
       */
533
590
    case '?':                   /* --help */
534
591
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
535
592
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
593
      __builtin_unreachable();
536
594
    case -3:                    /* --usage */
537
595
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
538
596
      argp_state_help(state, state->out_stream,
539
597
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
598
      __builtin_unreachable();
540
599
    case 'V':                   /* --version */
541
600
      fprintf(state->out_stream, "%s\n", argp_program_version);
542
601
      exit(EXIT_SUCCESS);
552
611
      if(arg[0] == '\0'){
553
612
        break;
554
613
      }
 
614
#if __GNUC__ >= 7
 
615
      __attribute__((fallthrough));
 
616
#else
 
617
          /* FALLTHROUGH */
 
618
#endif
555
619
    default:
556
620
      return ARGP_ERR_UNKNOWN;
557
621
    }
576
640
    case 129:                   /* --config-file */
577
641
      free(argfile);
578
642
      argfile = strdup(arg);
 
643
      if(argfile != NULL){
 
644
        errno = 0;
 
645
      }
579
646
      break;
580
647
    case 130:                   /* --userid */
581
648
    case 131:                   /* --groupid */
582
649
    case 132:                   /* --debug */
 
650
    case 133:                   /* --plugin-helper-dir */
583
651
    case '?':                   /* --help */
584
652
    case -3:                    /* --usage */
585
653
    case 'V':                   /* --version */
664
732
        }
665
733
        
666
734
        custom_argc += 1;
667
 
        custom_argv = realloc(custom_argv, sizeof(char *)
668
 
                              * ((unsigned int) custom_argc + 1));
669
 
        if(custom_argv == NULL){
670
 
          error(0, errno, "realloc");
671
 
          exitstatus = EX_OSERR;
672
 
          free(org_line);
673
 
          goto fallback;
 
735
        {
 
736
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
737
          char **new_argv = reallocarray(custom_argv,
 
738
                                         (size_t)custom_argc + 1,
 
739
                                         sizeof(char *));
 
740
#else
 
741
          char **new_argv = NULL;
 
742
          if(((size_t)custom_argc + 1) > (SIZE_MAX / sizeof(char *))){
 
743
            /* overflow */
 
744
            errno = ENOMEM;
 
745
          } else {
 
746
            new_argv = realloc(custom_argv, ((size_t)custom_argc + 1)
 
747
                               * sizeof(char *));
 
748
          }
 
749
#endif
 
750
          if(new_argv == NULL){
 
751
            error(0, errno, "reallocarray");
 
752
            exitstatus = EX_OSERR;
 
753
            free(new_arg);
 
754
            free(org_line);
 
755
            goto fallback;
 
756
          } else {
 
757
            custom_argv = new_argv;
 
758
          }
674
759
        }
675
760
        custom_argv[custom_argc-1] = new_arg;
676
761
        custom_argv[custom_argc] = NULL;
734
819
    goto fallback;
735
820
  }
736
821
  
 
822
  {
 
823
    char *pluginhelperenv;
 
824
    bool bret = true;
 
825
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
 
826
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
827
    if(ret != -1){
 
828
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
 
829
    }
 
830
    if(ret == -1 or not bret){
 
831
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
 
832
            " environment variable to \"%s\" for all plugins\n",
 
833
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
834
    }
 
835
    if(ret != -1){
 
836
      free(pluginhelperenv);
 
837
    }
 
838
  }
 
839
  
737
840
  if(debug){
738
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
841
    for(plugin *p = plugin_list; p != NULL; p = p->next){
739
842
      fprintf(stderr, "Plugin: %s has %d arguments\n",
740
843
              p->name ? p->name : "Global", p->argc - 1);
741
844
      for(char **a = p->argv; *a != NULL; a++){
750
853
  
751
854
  if(getuid() == 0){
752
855
    /* Work around Debian bug #633582:
753
 
       <http://bugs.debian.org/633582> */
 
856
       <https://bugs.debian.org/633582> */
754
857
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
755
858
    if(plugindir_fd == -1){
756
 
      error(0, errno, "open");
 
859
      if(errno != ENOENT){
 
860
        error(0, errno, "open(\"" PDIR "\")");
 
861
      }
757
862
    } else {
758
863
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
759
864
      if(ret == -1){
766
871
          }
767
872
        }
768
873
      }
769
 
      TEMP_FAILURE_RETRY(close(plugindir_fd));
 
874
      close(plugindir_fd);
 
875
    }
 
876
 
 
877
    /* Work around Debian bug #981302
 
878
       <https://bugs.debian.org/981302> */
 
879
    if(lstat("/dev/fd", &st) != 0 and errno == ENOENT){
 
880
      ret = symlink("/proc/self/fd", "/dev/fd");
 
881
      if(ret == -1){
 
882
        error(0, errno, "Failed to create /dev/fd symlink");
 
883
      }
770
884
    }
771
885
  }
772
886
  
782
896
  
783
897
  /* Open plugin directory with close_on_exec flag */
784
898
  {
785
 
    int dir_fd = -1;
786
 
    if(plugindir == NULL){
787
 
      dir_fd = open(PDIR, O_RDONLY |
788
 
#ifdef O_CLOEXEC
789
 
                    O_CLOEXEC
790
 
#else  /* not O_CLOEXEC */
791
 
                    0
792
 
#endif  /* not O_CLOEXEC */
793
 
                    );
794
 
    } else {
795
 
      dir_fd = open(plugindir, O_RDONLY |
796
 
#ifdef O_CLOEXEC
797
 
                    O_CLOEXEC
798
 
#else  /* not O_CLOEXEC */
799
 
                    0
800
 
#endif  /* not O_CLOEXEC */
801
 
                    );
802
 
    }
 
899
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
900
#ifdef O_CLOEXEC
 
901
                  O_CLOEXEC
 
902
#else  /* not O_CLOEXEC */
 
903
                  0
 
904
#endif  /* not O_CLOEXEC */
 
905
                  );
803
906
    if(dir_fd == -1){
804
907
      error(0, errno, "Could not open plugin dir");
805
908
      exitstatus = EX_UNAVAILABLE;
811
914
    ret = set_cloexec_flag(dir_fd);
812
915
    if(ret < 0){
813
916
      error(0, errno, "set_cloexec_flag");
814
 
      TEMP_FAILURE_RETRY(close(dir_fd));
815
917
      exitstatus = EX_OSERR;
816
918
      goto fallback;
817
919
    }
818
920
#endif  /* O_CLOEXEC */
819
 
    
820
 
    dir = fdopendir(dir_fd);
821
 
    if(dir == NULL){
822
 
      error(0, errno, "Could not open plugin dir");
823
 
      TEMP_FAILURE_RETRY(close(dir_fd));
824
 
      exitstatus = EX_OSERR;
825
 
      goto fallback;
 
921
  }
 
922
  
 
923
  int good_name(const struct dirent * const dirent){
 
924
    const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
 
925
                                      "*.dpkg-old", "*.dpkg-bak",
 
926
                                      "*.dpkg-divert", NULL };
 
927
#ifdef __GNUC__
 
928
#pragma GCC diagnostic push
 
929
#pragma GCC diagnostic ignored "-Wcast-qual"
 
930
#endif
 
931
    for(const char **pat = (const char **)patterns;
 
932
        *pat != NULL; pat++){
 
933
#ifdef __GNUC__
 
934
#pragma GCC diagnostic pop
 
935
#endif
 
936
      if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
 
937
         != FNM_NOMATCH){
 
938
        if(debug){
 
939
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
 
940
                    " matching pattern %s\n", dirent->d_name, *pat);
 
941
        }
 
942
        return 0;
 
943
      }
826
944
    }
 
945
    return 1;
 
946
  }
 
947
  
 
948
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
949
                             alphasort);
 
950
  if(numplugins == -1){
 
951
    error(0, errno, "Could not scan plugin dir");
 
952
    direntries = NULL;
 
953
    exitstatus = EX_OSERR;
 
954
    goto fallback;
827
955
  }
828
956
  
829
957
  FD_ZERO(&rfds_all);
830
958
  
831
959
  /* Read and execute any executable in the plugin directory*/
832
 
  while(true){
833
 
    do {
834
 
      dirst = readdir(dir);
835
 
    } while(dirst == NULL and errno == EINTR);
836
 
    
837
 
    /* All directory entries have been processed */
838
 
    if(dirst == NULL){
839
 
      if(errno == EBADF){
840
 
        error(0, errno, "readdir");
841
 
        exitstatus = EX_IOERR;
842
 
        goto fallback;
843
 
      }
844
 
      break;
845
 
    }
846
 
    
847
 
    d_name_len = strlen(dirst->d_name);
848
 
    
849
 
    /* Ignore dotfiles, backup files and other junk */
850
 
    {
851
 
      bool bad_name = false;
852
 
      
853
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
854
 
      
855
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
856
 
                                           ".dpkg-old",
857
 
                                           ".dpkg-bak",
858
 
                                           ".dpkg-divert", NULL };
859
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
860
 
        size_t pre_len = strlen(*pre);
861
 
        if((d_name_len >= pre_len)
862
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
863
 
          if(debug){
864
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
865
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
866
 
          }
867
 
          bad_name = true;
868
 
          break;
869
 
        }
870
 
      }
871
 
      if(bad_name){
872
 
        continue;
873
 
      }
874
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
875
 
        size_t suf_len = strlen(*suf);
876
 
        if((d_name_len >= suf_len)
877
 
           and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)
878
 
                == 0)){
879
 
          if(debug){
880
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
881
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
882
 
          }
883
 
          bad_name = true;
884
 
          break;
885
 
        }
886
 
      }
887
 
      
888
 
      if(bad_name){
889
 
        continue;
890
 
      }
891
 
    }
892
 
    
893
 
    char *filename;
894
 
    if(plugindir == NULL){
895
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
896
 
                                             dirst->d_name));
897
 
    } else {
898
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
899
 
                                             plugindir,
900
 
                                             dirst->d_name));
901
 
    }
902
 
    if(ret < 0){
903
 
      error(0, errno, "asprintf");
 
960
  for(int i = 0; i < numplugins; i++){
 
961
    
 
962
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
963
    if(plugin_fd == -1){
 
964
      error(0, errno, "Could not open plugin");
 
965
      free(direntries[i]);
904
966
      continue;
905
967
    }
906
 
    
907
 
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
 
968
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
908
969
    if(ret == -1){
909
970
      error(0, errno, "stat");
910
 
      free(filename);
 
971
      close(plugin_fd);
 
972
      free(direntries[i]);
911
973
      continue;
912
974
    }
913
975
    
914
976
    /* Ignore non-executable files */
915
977
    if(not S_ISREG(st.st_mode)
916
 
       or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
 
978
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
979
                                        X_OK, 0)) != 0)){
917
980
      if(debug){
918
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
919
 
                " with bad type or mode\n", filename);
 
981
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
982
                " with bad type or mode\n",
 
983
                plugindir != NULL ? plugindir : PDIR,
 
984
                direntries[i]->d_name);
920
985
      }
921
 
      free(filename);
 
986
      close(plugin_fd);
 
987
      free(direntries[i]);
922
988
      continue;
923
989
    }
924
990
    
925
 
    plugin *p = getplugin(dirst->d_name);
 
991
    plugin *p = getplugin(direntries[i]->d_name);
926
992
    if(p == NULL){
927
993
      error(0, errno, "getplugin");
928
 
      free(filename);
 
994
      close(plugin_fd);
 
995
      free(direntries[i]);
929
996
      continue;
930
997
    }
931
998
    if(p->disabled){
932
999
      if(debug){
933
1000
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
934
 
                dirst->d_name);
 
1001
                direntries[i]->d_name);
935
1002
      }
936
 
      free(filename);
 
1003
      close(plugin_fd);
 
1004
      free(direntries[i]);
937
1005
      continue;
938
1006
    }
939
1007
    {
953
1021
        }
954
1022
      }
955
1023
    }
956
 
    /* If this plugin has any environment variables, we will call
957
 
       using execve and need to duplicate the environment from this
958
 
       process, too. */
 
1024
    /* If this plugin has any environment variables, we need to
 
1025
       duplicate the environment from this process, too. */
959
1026
    if(p->environ[0] != NULL){
960
1027
      for(char **e = environ; *e != NULL; e++){
961
1028
        if(not add_environment(p, *e, false)){
965
1032
    }
966
1033
    
967
1034
    int pipefd[2];
 
1035
#ifndef O_CLOEXEC
968
1036
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
1037
#else  /* O_CLOEXEC */
 
1038
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
1039
#endif  /* O_CLOEXEC */
969
1040
    if(ret == -1){
970
1041
      error(0, errno, "pipe");
971
1042
      exitstatus = EX_OSERR;
972
 
      goto fallback;
973
 
    }
 
1043
      free(direntries[i]);
 
1044
      goto fallback;
 
1045
    }
 
1046
    if(pipefd[0] >= FD_SETSIZE){
 
1047
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
1048
              FD_SETSIZE);
 
1049
      close(pipefd[0]);
 
1050
      close(pipefd[1]);
 
1051
      exitstatus = EX_OSERR;
 
1052
      free(direntries[i]);
 
1053
      goto fallback;
 
1054
    }
 
1055
#ifndef O_CLOEXEC
974
1056
    /* Ask OS to automatic close the pipe on exec */
975
1057
    ret = set_cloexec_flag(pipefd[0]);
976
1058
    if(ret < 0){
977
1059
      error(0, errno, "set_cloexec_flag");
 
1060
      close(pipefd[0]);
 
1061
      close(pipefd[1]);
978
1062
      exitstatus = EX_OSERR;
 
1063
      free(direntries[i]);
979
1064
      goto fallback;
980
1065
    }
981
1066
    ret = set_cloexec_flag(pipefd[1]);
982
1067
    if(ret < 0){
983
1068
      error(0, errno, "set_cloexec_flag");
 
1069
      close(pipefd[0]);
 
1070
      close(pipefd[1]);
984
1071
      exitstatus = EX_OSERR;
 
1072
      free(direntries[i]);
985
1073
      goto fallback;
986
1074
    }
 
1075
#endif  /* not O_CLOEXEC */
987
1076
    /* Block SIGCHLD until process is safely in process list */
988
1077
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
989
1078
                                              &sigchld_action.sa_mask,
991
1080
    if(ret < 0){
992
1081
      error(0, errno, "sigprocmask");
993
1082
      exitstatus = EX_OSERR;
 
1083
      free(direntries[i]);
994
1084
      goto fallback;
995
1085
    }
996
1086
    /* Starting a new process to be watched */
1000
1090
    } while(pid == -1 and errno == EINTR);
1001
1091
    if(pid == -1){
1002
1092
      error(0, errno, "fork");
 
1093
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1094
                                     &sigchld_action.sa_mask, NULL));
 
1095
      close(pipefd[0]);
 
1096
      close(pipefd[1]);
1003
1097
      exitstatus = EX_OSERR;
 
1098
      free(direntries[i]);
1004
1099
      goto fallback;
1005
1100
    }
1006
1101
    if(pid == 0){
1022
1117
        _exit(EX_OSERR);
1023
1118
      }
1024
1119
      
1025
 
      if(dirfd(dir) < 0){
1026
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
1027
 
           above and must now close it manually here. */
1028
 
        closedir(dir);
1029
 
      }
1030
 
      if(p->environ[0] == NULL){
1031
 
        if(execv(filename, p->argv) < 0){
1032
 
          error(0, errno, "execv for %s", filename);
1033
 
          _exit(EX_OSERR);
1034
 
        }
1035
 
      } else {
1036
 
        if(execve(filename, p->argv, p->environ) < 0){
1037
 
          error(0, errno, "execve for %s", filename);
1038
 
          _exit(EX_OSERR);
1039
 
        }
 
1120
      if(fexecve(plugin_fd, p->argv,
 
1121
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1122
        error(0, errno, "fexecve for %s/%s",
 
1123
              plugindir != NULL ? plugindir : PDIR,
 
1124
              direntries[i]->d_name);
 
1125
        _exit(EX_OSERR);
1040
1126
      }
1041
1127
      /* no return */
1042
1128
    }
1043
1129
    /* Parent process */
1044
 
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1045
 
                                             pipe */
1046
 
    free(filename);
1047
 
    plugin *new_plugin = getplugin(dirst->d_name);
 
1130
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1131
    close(plugin_fd);
 
1132
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1048
1133
    if(new_plugin == NULL){
1049
1134
      error(0, errno, "getplugin");
1050
1135
      ret = (int)(TEMP_FAILURE_RETRY
1054
1139
        error(0, errno, "sigprocmask");
1055
1140
      }
1056
1141
      exitstatus = EX_OSERR;
 
1142
      free(direntries[i]);
1057
1143
      goto fallback;
1058
1144
    }
 
1145
    free(direntries[i]);
1059
1146
    
1060
1147
    new_plugin->pid = pid;
1061
1148
    new_plugin->fd = pipefd[0];
1062
 
    
 
1149
 
 
1150
    if(debug){
 
1151
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1152
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1153
    }
 
1154
 
1063
1155
    /* Unblock SIGCHLD so signal handler can be run if this process
1064
1156
       has already completed */
1065
1157
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1071
1163
      goto fallback;
1072
1164
    }
1073
1165
    
1074
 
#if defined (__GNUC__) and defined (__GLIBC__)
1075
 
#if not __GLIBC_PREREQ(2, 16)
1076
 
#pragma GCC diagnostic push
1077
 
#pragma GCC diagnostic ignored "-Wsign-conversion"
1078
 
#endif
1079
 
#endif
1080
 
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1081
 
                                          -Wconversion in GNU libc
1082
 
                                          before 2.16 */
1083
 
#if defined (__GNUC__) and defined (__GLIBC__)
1084
 
#if not __GLIBC_PREREQ(2, 16)
1085
 
#pragma GCC diagnostic pop
1086
 
#endif
1087
 
#endif
 
1166
    FD_SET(new_plugin->fd, &rfds_all);
1088
1167
    
1089
1168
    if(maxfd < new_plugin->fd){
1090
1169
      maxfd = new_plugin->fd;
1091
1170
    }
1092
1171
  }
1093
1172
  
1094
 
  TEMP_FAILURE_RETRY(closedir(dir));
1095
 
  dir = NULL;
 
1173
  free(direntries);
 
1174
  direntries = NULL;
 
1175
  close(dir_fd);
 
1176
  dir_fd = -1;
1096
1177
  free_plugin(getplugin(NULL));
1097
1178
  
1098
1179
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1137
1218
                      (intmax_t) (proc->pid),
1138
1219
                      WTERMSIG(proc->status),
1139
1220
                      strsignal(WTERMSIG(proc->status)));
1140
 
            } else if(WCOREDUMP(proc->status)){
1141
 
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1142
 
                      " core\n", proc->name, (intmax_t) (proc->pid));
1143
1221
            }
1144
1222
          }
1145
1223
          
1146
1224
          /* Remove the plugin */
1147
 
#if defined (__GNUC__) and defined (__GLIBC__)
1148
 
#if not __GLIBC_PREREQ(2, 16)
1149
 
#pragma GCC diagnostic push
1150
 
#pragma GCC diagnostic ignored "-Wsign-conversion"
1151
 
#endif
1152
 
#endif
1153
 
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1154
 
                                          -Wconversion in GNU libc
1155
 
                                          before 2.16 */
1156
 
#if defined (__GNUC__) and defined (__GLIBC__)
1157
 
#if not __GLIBC_PREREQ(2, 16)
1158
 
#pragma GCC diagnostic pop
1159
 
#endif
1160
 
#endif
 
1225
          FD_CLR(proc->fd, &rfds_all);
1161
1226
          
1162
1227
          /* Block signal while modifying process_list */
1163
1228
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1203
1268
      }
1204
1269
      
1205
1270
      /* This process has not completed.  Does it have any output? */
1206
 
#if defined (__GNUC__) and defined (__GLIBC__)
1207
 
#if not __GLIBC_PREREQ(2, 16)
1208
 
#pragma GCC diagnostic push
1209
 
#pragma GCC diagnostic ignored "-Wsign-conversion"
1210
 
#endif
1211
 
#endif
1212
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1213
 
                                                         warning from
1214
 
                                                         -Wconversion
1215
 
                                                         in GNU libc
1216
 
                                                         before
1217
 
                                                         2.16 */
1218
 
#if defined (__GNUC__) and defined (__GLIBC__)
1219
 
#if not __GLIBC_PREREQ(2, 16)
1220
 
#pragma GCC diagnostic pop
1221
 
#endif
1222
 
#endif
 
1271
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1223
1272
        /* This process had nothing to say at this time */
1224
1273
        proc = proc->next;
1225
1274
        continue;
1226
1275
      }
1227
1276
      /* Before reading, make the process' data buffer large enough */
1228
1277
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1229
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1230
 
                               + (size_t) BUFFER_SIZE);
1231
 
        if(proc->buffer == NULL){
 
1278
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1279
                                   + (size_t) BUFFER_SIZE);
 
1280
        if(new_buffer == NULL){
1232
1281
          error(0, errno, "malloc");
1233
1282
          exitstatus = EX_OSERR;
1234
1283
          goto fallback;
1235
1284
        }
 
1285
        proc->buffer = new_buffer;
1236
1286
        proc->buffer_size += BUFFER_SIZE;
1237
1287
      }
1238
1288
      /* Read from the process */
1291
1341
    free(custom_argv);
1292
1342
  }
1293
1343
  
1294
 
  if(dir != NULL){
1295
 
    closedir(dir);
 
1344
  free(direntries);
 
1345
  
 
1346
  if(dir_fd != -1){
 
1347
    close(dir_fd);
1296
1348
  }
1297
1349
  
1298
1350
  /* Kill the processes */
1318
1370
  free_plugin_list();
1319
1371
  
1320
1372
  free(plugindir);
 
1373
  free(pluginhelperdir);
1321
1374
  free(argfile);
1322
1375
  
1323
1376
  return exitstatus;