/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: 2015-07-20 03:03:33 UTC
  • Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.

The mandos-keygen program in Mandos version 1.6.0 and older generated
2048-bit DSA keys, and when GnuTLS uses these it has trouble
connecting using the Mandos default priority string.  This was
previously fixed in Mandos 1.6.2, but the bug reappeared when using
GnuTLS 3, so the default priority string has to change again; this
time also the Mandos client has to change its default, so now the
server and the client should use the same default priority string:

SECURE256:!CTYPE-X.509:+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256

* mandos (main/server_defaults): Changed default priority string.
* mandos-options.xml (/section/para[id="priority_compat"]): Removed.
  (/section/para[id="priority"]): Changed default priority string.
* mandos.conf ([DEFAULT]/priority): - '' -
* mandos.conf.xml (OPTIONS/priority): Refer to the id "priority"
                                      instead of "priority_compat".
* mandos.xml (OPTIONS/--priority): - '' -
* plugins.d/mandos-client.c (main): Changed default priority string.

Show diffs side-by-side

added added

removed removed

Lines of Context:
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
 
5
 * Copyright © 2008-2014 Teddy Hogeborn
 
6
 * Copyright © 2008-2014 Björn Påhlsson
7
7
 * 
8
8
 * This program is free software: you can redistribute it and/or
9
9
 * modify it under the terms of the GNU General Public License as
19
19
 * along with this program.  If not, see
20
20
 * <http://www.gnu.org/licenses/>.
21
21
 * 
22
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
22
 * Contact the authors at <mandos@recompile.se>.
23
23
 */
24
24
 
25
25
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
26
 
                                   asprintf(), O_CLOEXEC */
 
26
                                   O_CLOEXEC, pipe2() */
27
27
#include <stddef.h>             /* size_t, NULL */
28
28
#include <stdlib.h>             /* malloc(), exit(), EXIT_SUCCESS,
29
29
                                   realloc() */
30
30
#include <stdbool.h>            /* bool, true, false */
31
 
#include <stdio.h>              /* perror, 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() */
 
31
#include <stdio.h>              /* fileno(), fprintf(),
 
32
                                   stderr, STDOUT_FILENO, fclose() */
 
33
#include <sys/types.h>          /* fstat(), struct stat, waitpid(),
 
34
                                   WIFEXITED(), WEXITSTATUS(), wait(),
 
35
                                   pid_t, uid_t, gid_t, getuid(),
 
36
                                   getgid() */
38
37
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
39
38
                                   FD_SET(), FD_ISSET(), FD_CLR */
40
39
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
41
40
                                   WEXITSTATUS(), WTERMSIG(),
42
41
                                   WCOREDUMP() */
43
 
#include <sys/stat.h>           /* struct stat, stat(), S_ISREG() */
 
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() */
 
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,
70
69
#include <inttypes.h>           /* intmax_t, PRIdMAX, strtoimax() */
71
70
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_IOERR,
72
71
                                   EX_CONFIG, EX_UNAVAILABLE, EX_OK */
 
72
#include <errno.h>              /* errno */
 
73
#include <error.h>              /* error() */
 
74
#include <fnmatch.h>            /* fnmatch() */
73
75
 
74
76
#define BUFFER_SIZE 256
75
77
 
76
78
#define PDIR "/lib/mandos/plugins.d"
 
79
#define PHDIR "/lib/mandos/plugin-helpers"
77
80
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
78
81
 
79
82
const char *argp_program_version = "plugin-runner " VERSION;
80
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
83
const char *argp_program_bug_address = "<mandos@recompile.se>";
81
84
 
82
85
typedef struct plugin{
83
86
  char *name;                   /* can be NULL or any plugin name */
103
106
 
104
107
/* Gets an existing plugin based on name,
105
108
   or if none is found, creates a new one */
 
109
__attribute__((warn_unused_result))
106
110
static plugin *getplugin(char *name){
107
111
  /* Check for existing plugin with that name */
108
112
  for(plugin *p = plugin_list; p != NULL; p = p->next){
169
173
}
170
174
 
171
175
/* Helper function for add_argument and add_environment */
 
176
__attribute__((nonnull, warn_unused_result))
172
177
static bool add_to_char_array(const char *new, char ***array,
173
178
                              int *len){
174
179
  /* Resize the pointed-to array to hold one more pointer */
 
180
  char **new_array = NULL;
175
181
  do {
176
 
    *array = realloc(*array, sizeof(char *)
177
 
                     * (size_t) ((*len) + 2));
178
 
  } 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);
179
185
  /* Malloc check */
180
 
  if(*array == NULL){
 
186
  if(new_array == NULL){
181
187
    return false;
182
188
  }
 
189
  *array = new_array;
183
190
  /* Make a copy of the new string */
184
191
  char *copy;
185
192
  do {
197
204
}
198
205
 
199
206
/* Add to a plugin's argument vector */
 
207
__attribute__((nonnull(2), warn_unused_result))
200
208
static bool add_argument(plugin *p, const char *arg){
201
209
  if(p == NULL){
202
210
    return false;
205
213
}
206
214
 
207
215
/* Add to a plugin's environment */
 
216
__attribute__((nonnull(2), warn_unused_result))
208
217
static bool add_environment(plugin *p, const char *def, bool replace){
209
218
  if(p == NULL){
210
219
    return false;
212
221
  /* namelen = length of name of environment variable */
213
222
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
214
223
  /* Search for this environment variable */
215
 
  for(char **e = p->environ; *e != NULL; e++){
216
 
    if(strncmp(*e, def, namelen + 1) == 0){
 
224
  for(char **envdef = p->environ; *envdef != NULL; envdef++){
 
225
    if(strncmp(*envdef, def, namelen + 1) == 0){
217
226
      /* It already exists */
218
227
      if(replace){
219
 
        char *new;
 
228
        char *new_envdef;
220
229
        do {
221
 
          new = realloc(*e, strlen(def) + 1);
222
 
        } while(new == NULL and errno == EINTR);
223
 
        if(new == NULL){
 
230
          new_envdef = realloc(*envdef, strlen(def) + 1);
 
231
        } while(new_envdef == NULL and errno == EINTR);
 
232
        if(new_envdef == NULL){
224
233
          return false;
225
234
        }
226
 
        *e = new;
227
 
        strcpy(*e, def);
 
235
        *envdef = new_envdef;
 
236
        strcpy(*envdef, def);
228
237
      }
229
238
      return true;
230
239
    }
232
241
  return add_to_char_array(def, &(p->environ), &(p->envc));
233
242
}
234
243
 
 
244
#ifndef O_CLOEXEC
235
245
/*
236
246
 * Based on the example in the GNU LibC manual chapter 13.13 "File
237
247
 * Descriptor Flags".
238
248
 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
239
249
 */
 
250
__attribute__((warn_unused_result))
240
251
static int set_cloexec_flag(int fd){
241
252
  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
242
253
  /* If reading the flags failed, return error indication now. */
247
258
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
248
259
                                       ret | FD_CLOEXEC));
249
260
}
 
261
#endif  /* not O_CLOEXEC */
250
262
 
251
263
 
252
264
/* Mark processes as completed when they exit, and save their exit
266
278
        /* No child processes */
267
279
        break;
268
280
      }
269
 
      perror("waitpid");
 
281
      error(0, errno, "waitpid");
270
282
    }
271
283
    
272
284
    /* A child exited, find it in process_list */
284
296
}
285
297
 
286
298
/* Prints out a password to stdout */
 
299
__attribute__((nonnull, warn_unused_result))
287
300
static bool print_out_password(const char *buffer, size_t length){
288
301
  ssize_t ret;
289
302
  for(size_t written = 0; written < length; written += (size_t)ret){
297
310
}
298
311
 
299
312
/* Removes and free a plugin from the plugin list */
 
313
__attribute__((nonnull))
300
314
static void free_plugin(plugin *plugin_node){
301
315
  
302
316
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
334
348
 
335
349
int main(int argc, char *argv[]){
336
350
  char *plugindir = NULL;
 
351
  char *pluginhelperdir = NULL;
337
352
  char *argfile = NULL;
338
353
  FILE *conffp;
339
 
  size_t d_name_len;
340
 
  DIR *dir = NULL;
341
 
  struct dirent *dirst;
 
354
  struct dirent **direntries = NULL;
342
355
  struct stat st;
343
356
  fd_set rfds_all;
344
357
  int ret, maxfd = 0;
352
365
                                      .sa_flags = SA_NOCLDSTOP };
353
366
  char **custom_argv = NULL;
354
367
  int custom_argc = 0;
 
368
  int dir_fd = -1;
355
369
  
356
370
  /* Establish a signal handler */
357
371
  sigemptyset(&sigchld_action.sa_mask);
358
372
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
359
373
  if(ret == -1){
360
 
    perror("sigaddset");
 
374
    error(0, errno, "sigaddset");
361
375
    exitstatus = EX_OSERR;
362
376
    goto fallback;
363
377
  }
364
378
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
365
379
  if(ret == -1){
366
 
    perror("sigaction");
 
380
    error(0, errno, "sigaction");
367
381
    exitstatus = EX_OSERR;
368
382
    goto fallback;
369
383
  }
402
416
      .doc = "Group ID the plugins will run as", .group = 3 },
403
417
    { .name = "debug", .key = 132,
404
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 },
405
423
    /*
406
424
     * These reproduce what we would get without ARGP_NO_HELP
407
425
     */
414
432
    { .name = NULL }
415
433
  };
416
434
  
 
435
  __attribute__((nonnull(3)))
417
436
  error_t parse_opt(int key, char *arg, struct argp_state *state){
418
437
    errno = 0;
419
438
    switch(key){
420
439
      char *tmp;
421
 
      intmax_t tmpmax;
 
440
      intmax_t tmp_id;
422
441
    case 'g':                   /* --global-options */
423
442
      {
424
443
        char *plugin_option;
427
446
            break;
428
447
          }
429
448
        }
 
449
        errno = 0;
430
450
      }
431
451
      break;
432
452
    case 'G':                   /* --global-env */
433
 
      add_environment(getplugin(NULL), arg, true);
 
453
      if(add_environment(getplugin(NULL), arg, true)){
 
454
        errno = 0;
 
455
      }
434
456
      break;
435
457
    case 'o':                   /* --options-for */
436
458
      {
453
475
            break;
454
476
          }
455
477
        }
 
478
        errno = 0;
456
479
      }
457
480
      break;
458
481
    case 'E':                   /* --env-for */
470
493
          errno = EINVAL;
471
494
          break;
472
495
        }
473
 
        add_environment(getplugin(arg), envdef, true);
 
496
        if(add_environment(getplugin(arg), envdef, true)){
 
497
          errno = 0;
 
498
        }
474
499
      }
475
500
      break;
476
501
    case 'd':                   /* --disable */
478
503
        plugin *p = getplugin(arg);
479
504
        if(p != NULL){
480
505
          p->disabled = true;
 
506
          errno = 0;
481
507
        }
482
508
      }
483
509
      break;
486
512
        plugin *p = getplugin(arg);
487
513
        if(p != NULL){
488
514
          p->disabled = false;
 
515
          errno = 0;
489
516
        }
490
517
      }
491
518
      break;
492
519
    case 128:                   /* --plugin-dir */
493
520
      free(plugindir);
494
521
      plugindir = strdup(arg);
 
522
      if(plugindir != NULL){
 
523
        errno = 0;
 
524
      }
495
525
      break;
496
526
    case 129:                   /* --config-file */
497
527
      /* This is already done by parse_opt_config_file() */
498
528
      break;
499
529
    case 130:                   /* --userid */
500
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
530
      tmp_id = strtoimax(arg, &tmp, 10);
501
531
      if(errno != 0 or tmp == arg or *tmp != '\0'
502
 
         or tmpmax != (uid_t)tmpmax){
 
532
         or tmp_id != (uid_t)tmp_id){
503
533
        argp_error(state, "Bad user ID number: \"%s\", using %"
504
534
                   PRIdMAX, arg, (intmax_t)uid);
505
535
        break;
506
536
      }
507
 
      uid = (uid_t)tmpmax;
 
537
      uid = (uid_t)tmp_id;
 
538
      errno = 0;
508
539
      break;
509
540
    case 131:                   /* --groupid */
510
 
      tmpmax = strtoimax(arg, &tmp, 10);
 
541
      tmp_id = strtoimax(arg, &tmp, 10);
511
542
      if(errno != 0 or tmp == arg or *tmp != '\0'
512
 
         or tmpmax != (gid_t)tmpmax){
 
543
         or tmp_id != (gid_t)tmp_id){
513
544
        argp_error(state, "Bad group ID number: \"%s\", using %"
514
545
                   PRIdMAX, arg, (intmax_t)gid);
515
546
        break;
516
547
      }
517
 
      gid = (gid_t)tmpmax;
 
548
      gid = (gid_t)tmp_id;
 
549
      errno = 0;
518
550
      break;
519
551
    case 132:                   /* --debug */
520
552
      debug = true;
521
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;
522
561
      /*
523
562
       * These reproduce what we would get without ARGP_NO_HELP
524
563
       */
568
607
    case 129:                   /* --config-file */
569
608
      free(argfile);
570
609
      argfile = strdup(arg);
 
610
      if(argfile != NULL){
 
611
        errno = 0;
 
612
      }
571
613
      break;
572
614
    case 130:                   /* --userid */
573
615
    case 131:                   /* --groupid */
574
616
    case 132:                   /* --debug */
 
617
    case 133:                   /* --plugin-helper-dir */
575
618
    case '?':                   /* --help */
576
619
    case -3:                    /* --usage */
577
620
    case 'V':                   /* --version */
599
642
  case ENOMEM:
600
643
  default:
601
644
    errno = ret;
602
 
    perror("argp_parse");
 
645
    error(0, errno, "argp_parse");
603
646
    exitstatus = EX_OSERR;
604
647
    goto fallback;
605
648
  case EINVAL:
626
669
    custom_argc = 1;
627
670
    custom_argv = malloc(sizeof(char*) * 2);
628
671
    if(custom_argv == NULL){
629
 
      perror("malloc");
 
672
      error(0, errno, "malloc");
630
673
      exitstatus = EX_OSERR;
631
674
      goto fallback;
632
675
    }
649
692
        }
650
693
        new_arg = strdup(p);
651
694
        if(new_arg == NULL){
652
 
          perror("strdup");
 
695
          error(0, errno, "strdup");
653
696
          exitstatus = EX_OSERR;
654
697
          free(org_line);
655
698
          goto fallback;
656
699
        }
657
700
        
658
701
        custom_argc += 1;
659
 
        custom_argv = realloc(custom_argv, sizeof(char *)
660
 
                              * ((unsigned int) custom_argc + 1));
661
 
        if(custom_argv == NULL){
662
 
          perror("realloc");
663
 
          exitstatus = EX_OSERR;
664
 
          free(org_line);
665
 
          goto fallback;
 
702
        {
 
703
          char **new_argv = realloc(custom_argv, sizeof(char *)
 
704
                                    * ((unsigned int)
 
705
                                       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
          }
666
715
        }
667
716
        custom_argv[custom_argc-1] = new_arg;
668
717
        custom_argv[custom_argc] = NULL;
672
721
      ret = fclose(conffp);
673
722
    } while(ret == EOF and errno == EINTR);
674
723
    if(ret == EOF){
675
 
      perror("fclose");
 
724
      error(0, errno, "fclose");
676
725
      exitstatus = EX_IOERR;
677
726
      goto fallback;
678
727
    }
681
730
    /* Check for harmful errors and go to fallback. Other errors might
682
731
       not affect opening plugins */
683
732
    if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
684
 
      perror("fopen");
 
733
      error(0, errno, "fopen");
685
734
      exitstatus = EX_OSERR;
686
735
      goto fallback;
687
736
    }
698
747
    case ENOMEM:
699
748
    default:
700
749
      errno = ret;
701
 
      perror("argp_parse");
 
750
      error(0, errno, "argp_parse");
702
751
      exitstatus = EX_OSERR;
703
752
      goto fallback;
704
753
    case EINVAL:
718
767
  case ENOMEM:
719
768
  default:
720
769
    errno = ret;
721
 
    perror("argp_parse");
 
770
    error(0, errno, "argp_parse");
722
771
    exitstatus = EX_OSERR;
723
772
    goto fallback;
724
773
  case EINVAL:
726
775
    goto fallback;
727
776
  }
728
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
  
729
796
  if(debug){
730
797
    for(plugin *p = plugin_list; p != NULL; p=p->next){
731
798
      fprintf(stderr, "Plugin: %s has %d arguments\n",
740
807
    }
741
808
  }
742
809
  
743
 
  /* Strip permissions down to nobody */
744
 
  setgid(gid);
 
810
  if(getuid() == 0){
 
811
    /* Work around Debian bug #633582:
 
812
       <http://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);
745
836
  if(ret == -1){
746
 
    perror("setgid");
 
837
    error(0, errno, "setgid");
747
838
  }
748
839
  ret = setuid(uid);
749
840
  if(ret == -1){
750
 
    perror("setuid");
 
841
    error(0, errno, "setuid");
751
842
  }
752
843
  
753
844
  /* Open plugin directory with close_on_exec flag */
754
845
  {
755
 
    int dir_fd = -1;
756
 
    if(plugindir == NULL){
757
 
      dir_fd = open(PDIR, O_RDONLY |
758
 
#ifdef O_CLOEXEC
759
 
                    O_CLOEXEC
760
 
#else  /* not O_CLOEXEC */
761
 
                    0
762
 
#endif  /* not O_CLOEXEC */
763
 
                    );
764
 
    } else {
765
 
      dir_fd = open(plugindir, O_RDONLY |
766
 
#ifdef O_CLOEXEC
767
 
                    O_CLOEXEC
768
 
#else  /* not O_CLOEXEC */
769
 
                    0
770
 
#endif  /* not O_CLOEXEC */
771
 
                    );
772
 
    }
 
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
                  );
773
853
    if(dir_fd == -1){
774
 
      perror("Could not open plugin dir");
 
854
      error(0, errno, "Could not open plugin dir");
775
855
      exitstatus = EX_UNAVAILABLE;
776
856
      goto fallback;
777
857
    }
780
860
  /* Set the FD_CLOEXEC flag on the directory */
781
861
    ret = set_cloexec_flag(dir_fd);
782
862
    if(ret < 0){
783
 
      perror("set_cloexec_flag");
784
 
      TEMP_FAILURE_RETRY(close(dir_fd));
 
863
      error(0, errno, "set_cloexec_flag");
785
864
      exitstatus = EX_OSERR;
786
865
      goto fallback;
787
866
    }
788
867
#endif  /* O_CLOEXEC */
789
 
    
790
 
    dir = fdopendir(dir_fd);
791
 
    if(dir == NULL){
792
 
      perror("Could not open plugin dir");
793
 
      TEMP_FAILURE_RETRY(close(dir_fd));
794
 
      exitstatus = EX_OSERR;
795
 
      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
      }
796
891
    }
 
892
    return 1;
 
893
  }
 
894
  
 
895
#ifdef __GLIBC__
 
896
#if __GLIBC_PREREQ(2, 15)
 
897
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
898
                             alphasort);
 
899
#else  /* not __GLIBC_PREREQ(2, 15) */
 
900
  int numplugins = scandir(plugindir != NULL ? plugindir : PDIR,
 
901
                           &direntries, good_name, alphasort);
 
902
#endif  /* not __GLIBC_PREREQ(2, 15) */
 
903
#else   /* not __GLIBC__ */
 
904
  int numplugins = scandir(plugindir != NULL ? plugindir : PDIR,
 
905
                           &direntries, good_name, alphasort);
 
906
#endif  /* not __GLIBC__ */
 
907
  if(numplugins == -1){
 
908
    error(0, errno, "Could not scan plugin dir");
 
909
    direntries = NULL;
 
910
    exitstatus = EX_OSERR;
 
911
    goto fallback;
797
912
  }
798
913
  
799
914
  FD_ZERO(&rfds_all);
800
915
  
801
916
  /* Read and execute any executable in the plugin directory*/
802
 
  while(true){
803
 
    do {
804
 
      dirst = readdir(dir);
805
 
    } while(dirst == NULL and errno == EINTR);
806
 
    
807
 
    /* All directory entries have been processed */
808
 
    if(dirst == NULL){
809
 
      if(errno == EBADF){
810
 
        perror("readdir");
811
 
        exitstatus = EX_IOERR;
812
 
        goto fallback;
813
 
      }
814
 
      break;
815
 
    }
816
 
    
817
 
    d_name_len = strlen(dirst->d_name);
818
 
    
819
 
    /* Ignore dotfiles, backup files and other junk */
820
 
    {
821
 
      bool bad_name = false;
822
 
      
823
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
824
 
      
825
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
826
 
                                           ".dpkg-old",
827
 
                                           ".dpkg-bak",
828
 
                                           ".dpkg-divert", NULL };
829
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
830
 
        size_t pre_len = strlen(*pre);
831
 
        if((d_name_len >= pre_len)
832
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
833
 
          if(debug){
834
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
835
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
836
 
          }
837
 
          bad_name = true;
838
 
          break;
839
 
        }
840
 
      }
841
 
      if(bad_name){
842
 
        continue;
843
 
      }
844
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
845
 
        size_t suf_len = strlen(*suf);
846
 
        if((d_name_len >= suf_len)
847
 
           and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
848
 
                == 0)){
849
 
          if(debug){
850
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
851
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
852
 
          }
853
 
          bad_name = true;
854
 
          break;
855
 
        }
856
 
      }
857
 
      
858
 
      if(bad_name){
859
 
        continue;
860
 
      }
861
 
    }
862
 
    
863
 
    char *filename;
864
 
    if(plugindir == NULL){
865
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",
866
 
                                             dirst->d_name));
867
 
    } else {
868
 
      ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",
869
 
                                             plugindir,
870
 
                                             dirst->d_name));
871
 
    }
872
 
    if(ret < 0){
873
 
      perror("asprintf");
 
917
  for(int i = 0; i < numplugins; i++){
 
918
    
 
919
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
920
    if(plugin_fd == -1){
 
921
      error(0, errno, "Could not open plugin");
 
922
      free(direntries[i]);
874
923
      continue;
875
924
    }
876
 
    
877
 
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
 
925
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
878
926
    if(ret == -1){
879
 
      perror("stat");
880
 
      free(filename);
 
927
      error(0, errno, "stat");
 
928
      close(plugin_fd);
 
929
      free(direntries[i]);
881
930
      continue;
882
931
    }
883
932
    
884
933
    /* Ignore non-executable files */
885
934
    if(not S_ISREG(st.st_mode)
886
 
       or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
 
935
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
936
                                        X_OK, 0)) != 0)){
887
937
      if(debug){
888
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
889
 
                " with bad type or mode\n", filename);
 
938
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
939
                " with bad type or mode\n",
 
940
                plugindir != NULL ? plugindir : PDIR,
 
941
                direntries[i]->d_name);
890
942
      }
891
 
      free(filename);
 
943
      close(plugin_fd);
 
944
      free(direntries[i]);
892
945
      continue;
893
946
    }
894
947
    
895
 
    plugin *p = getplugin(dirst->d_name);
 
948
    plugin *p = getplugin(direntries[i]->d_name);
896
949
    if(p == NULL){
897
 
      perror("getplugin");
898
 
      free(filename);
 
950
      error(0, errno, "getplugin");
 
951
      close(plugin_fd);
 
952
      free(direntries[i]);
899
953
      continue;
900
954
    }
901
955
    if(p->disabled){
902
956
      if(debug){
903
957
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
904
 
                dirst->d_name);
 
958
                direntries[i]->d_name);
905
959
      }
906
 
      free(filename);
 
960
      close(plugin_fd);
 
961
      free(direntries[i]);
907
962
      continue;
908
963
    }
909
964
    {
912
967
      if(g != NULL){
913
968
        for(char **a = g->argv + 1; *a != NULL; a++){
914
969
          if(not add_argument(p, *a)){
915
 
            perror("add_argument");
 
970
            error(0, errno, "add_argument");
916
971
          }
917
972
        }
918
973
        /* Add global environment variables */
919
974
        for(char **e = g->environ; *e != NULL; e++){
920
975
          if(not add_environment(p, *e, false)){
921
 
            perror("add_environment");
 
976
            error(0, errno, "add_environment");
922
977
          }
923
978
        }
924
979
      }
925
980
    }
926
 
    /* If this plugin has any environment variables, we will call
927
 
       using execve and need to duplicate the environment from this
928
 
       process, too. */
 
981
    /* If this plugin has any environment variables, we need to
 
982
       duplicate the environment from this process, too. */
929
983
    if(p->environ[0] != NULL){
930
984
      for(char **e = environ; *e != NULL; e++){
931
985
        if(not add_environment(p, *e, false)){
932
 
          perror("add_environment");
 
986
          error(0, errno, "add_environment");
933
987
        }
934
988
      }
935
989
    }
936
990
    
937
991
    int pipefd[2];
 
992
#ifndef O_CLOEXEC
938
993
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
994
#else  /* O_CLOEXEC */
 
995
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
996
#endif  /* O_CLOEXEC */
939
997
    if(ret == -1){
940
 
      perror("pipe");
941
 
      exitstatus = EX_OSERR;
942
 
      goto fallback;
943
 
    }
 
998
      error(0, errno, "pipe");
 
999
      exitstatus = EX_OSERR;
 
1000
      free(direntries[i]);
 
1001
      goto fallback;
 
1002
    }
 
1003
    if(pipefd[0] >= FD_SETSIZE){
 
1004
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
1005
              FD_SETSIZE);
 
1006
      close(pipefd[0]);
 
1007
      close(pipefd[1]);
 
1008
      exitstatus = EX_OSERR;
 
1009
      free(direntries[i]);
 
1010
      goto fallback;
 
1011
    }
 
1012
#ifndef O_CLOEXEC
944
1013
    /* Ask OS to automatic close the pipe on exec */
945
1014
    ret = set_cloexec_flag(pipefd[0]);
946
1015
    if(ret < 0){
947
 
      perror("set_cloexec_flag");
 
1016
      error(0, errno, "set_cloexec_flag");
 
1017
      close(pipefd[0]);
 
1018
      close(pipefd[1]);
948
1019
      exitstatus = EX_OSERR;
 
1020
      free(direntries[i]);
949
1021
      goto fallback;
950
1022
    }
951
1023
    ret = set_cloexec_flag(pipefd[1]);
952
1024
    if(ret < 0){
953
 
      perror("set_cloexec_flag");
 
1025
      error(0, errno, "set_cloexec_flag");
 
1026
      close(pipefd[0]);
 
1027
      close(pipefd[1]);
954
1028
      exitstatus = EX_OSERR;
 
1029
      free(direntries[i]);
955
1030
      goto fallback;
956
1031
    }
 
1032
#endif  /* not O_CLOEXEC */
957
1033
    /* Block SIGCHLD until process is safely in process list */
958
1034
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
959
1035
                                              &sigchld_action.sa_mask,
960
1036
                                              NULL));
961
1037
    if(ret < 0){
962
 
      perror("sigprocmask");
 
1038
      error(0, errno, "sigprocmask");
963
1039
      exitstatus = EX_OSERR;
 
1040
      free(direntries[i]);
964
1041
      goto fallback;
965
1042
    }
966
1043
    /* Starting a new process to be watched */
969
1046
      pid = fork();
970
1047
    } while(pid == -1 and errno == EINTR);
971
1048
    if(pid == -1){
972
 
      perror("fork");
 
1049
      error(0, errno, "fork");
 
1050
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1051
                                     &sigchld_action.sa_mask, NULL));
 
1052
      close(pipefd[0]);
 
1053
      close(pipefd[1]);
973
1054
      exitstatus = EX_OSERR;
 
1055
      free(direntries[i]);
974
1056
      goto fallback;
975
1057
    }
976
1058
    if(pid == 0){
977
1059
      /* this is the child process */
978
1060
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
979
1061
      if(ret < 0){
980
 
        perror("sigaction");
 
1062
        error(0, errno, "sigaction");
981
1063
        _exit(EX_OSERR);
982
1064
      }
983
1065
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
984
1066
      if(ret < 0){
985
 
        perror("sigprocmask");
 
1067
        error(0, errno, "sigprocmask");
986
1068
        _exit(EX_OSERR);
987
1069
      }
988
1070
      
989
1071
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
990
1072
      if(ret == -1){
991
 
        perror("dup2");
 
1073
        error(0, errno, "dup2");
992
1074
        _exit(EX_OSERR);
993
1075
      }
994
1076
      
995
 
      if(dirfd(dir) < 0){
996
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
997
 
           above and must now close it manually here. */
998
 
        closedir(dir);
999
 
      }
1000
 
      if(p->environ[0] == NULL){
1001
 
        if(execv(filename, p->argv) < 0){
1002
 
          perror("execv");
1003
 
          _exit(EX_OSERR);
1004
 
        }
1005
 
      } else {
1006
 
        if(execve(filename, p->argv, p->environ) < 0){
1007
 
          perror("execve");
1008
 
          _exit(EX_OSERR);
1009
 
        }
 
1077
      if(fexecve(plugin_fd, p->argv,
 
1078
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1079
        error(0, errno, "fexecve for %s/%s",
 
1080
              plugindir != NULL ? plugindir : PDIR,
 
1081
              direntries[i]->d_name);
 
1082
        _exit(EX_OSERR);
1010
1083
      }
1011
1084
      /* no return */
1012
1085
    }
1013
1086
    /* Parent process */
1014
 
    TEMP_FAILURE_RETRY(close(pipefd[1])); /* Close unused write end of
1015
 
                                             pipe */
1016
 
    free(filename);
1017
 
    plugin *new_plugin = getplugin(dirst->d_name);
 
1087
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1088
    close(plugin_fd);
 
1089
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1018
1090
    if(new_plugin == NULL){
1019
 
      perror("getplugin");
 
1091
      error(0, errno, "getplugin");
1020
1092
      ret = (int)(TEMP_FAILURE_RETRY
1021
1093
                  (sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1022
1094
                               NULL)));
1023
1095
      if(ret < 0){
1024
 
        perror("sigprocmask");
 
1096
        error(0, errno, "sigprocmask");
1025
1097
      }
1026
1098
      exitstatus = EX_OSERR;
 
1099
      free(direntries[i]);
1027
1100
      goto fallback;
1028
1101
    }
 
1102
    free(direntries[i]);
1029
1103
    
1030
1104
    new_plugin->pid = pid;
1031
1105
    new_plugin->fd = pipefd[0];
1036
1110
                                              &sigchld_action.sa_mask,
1037
1111
                                              NULL));
1038
1112
    if(ret < 0){
1039
 
      perror("sigprocmask");
 
1113
      error(0, errno, "sigprocmask");
1040
1114
      exitstatus = EX_OSERR;
1041
1115
      goto fallback;
1042
1116
    }
1043
1117
    
 
1118
#if defined (__GNUC__) and defined (__GLIBC__)
 
1119
#if not __GLIBC_PREREQ(2, 16)
 
1120
#pragma GCC diagnostic push
 
1121
#pragma GCC diagnostic ignored "-Wsign-conversion"
 
1122
#endif
 
1123
#endif
1044
1124
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1045
 
                                          -Wconversion */
 
1125
                                          -Wconversion in GNU libc
 
1126
                                          before 2.16 */
 
1127
#if defined (__GNUC__) and defined (__GLIBC__)
 
1128
#if not __GLIBC_PREREQ(2, 16)
 
1129
#pragma GCC diagnostic pop
 
1130
#endif
 
1131
#endif
1046
1132
    
1047
1133
    if(maxfd < new_plugin->fd){
1048
1134
      maxfd = new_plugin->fd;
1049
1135
    }
1050
1136
  }
1051
1137
  
1052
 
  TEMP_FAILURE_RETRY(closedir(dir));
1053
 
  dir = NULL;
 
1138
  free(direntries);
 
1139
  direntries = NULL;
 
1140
  close(dir_fd);
 
1141
  dir_fd = -1;
1054
1142
  free_plugin(getplugin(NULL));
1055
1143
  
1056
1144
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1069
1157
    fd_set rfds = rfds_all;
1070
1158
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
1071
1159
    if(select_ret == -1 and errno != EINTR){
1072
 
      perror("select");
 
1160
      error(0, errno, "select");
1073
1161
      exitstatus = EX_OSERR;
1074
1162
      goto fallback;
1075
1163
    }
1102
1190
          }
1103
1191
          
1104
1192
          /* Remove the plugin */
 
1193
#if defined (__GNUC__) and defined (__GLIBC__)
 
1194
#if not __GLIBC_PREREQ(2, 16)
 
1195
#pragma GCC diagnostic push
 
1196
#pragma GCC diagnostic ignored "-Wsign-conversion"
 
1197
#endif
 
1198
#endif
1105
1199
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1106
 
                                          -Wconversion */
 
1200
                                          -Wconversion in GNU libc
 
1201
                                          before 2.16 */
 
1202
#if defined (__GNUC__) and defined (__GLIBC__)
 
1203
#if not __GLIBC_PREREQ(2, 16)
 
1204
#pragma GCC diagnostic pop
 
1205
#endif
 
1206
#endif
1107
1207
          
1108
1208
          /* Block signal while modifying process_list */
1109
1209
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1111
1211
                                         &sigchld_action.sa_mask,
1112
1212
                                         NULL));
1113
1213
          if(ret < 0){
1114
 
            perror("sigprocmask");
 
1214
            error(0, errno, "sigprocmask");
1115
1215
            exitstatus = EX_OSERR;
1116
1216
            goto fallback;
1117
1217
          }
1125
1225
                      (sigprocmask(SIG_UNBLOCK,
1126
1226
                                   &sigchld_action.sa_mask, NULL)));
1127
1227
          if(ret < 0){
1128
 
            perror("sigprocmask");
 
1228
            error(0, errno, "sigprocmask");
1129
1229
            exitstatus = EX_OSERR;
1130
1230
            goto fallback;
1131
1231
          }
1142
1242
        bool bret = print_out_password(proc->buffer,
1143
1243
                                       proc->buffer_length);
1144
1244
        if(not bret){
1145
 
          perror("print_out_password");
 
1245
          error(0, errno, "print_out_password");
1146
1246
          exitstatus = EX_IOERR;
1147
1247
        }
1148
1248
        goto fallback;
1149
1249
      }
1150
1250
      
1151
1251
      /* This process has not completed.  Does it have any output? */
 
1252
#if defined (__GNUC__) and defined (__GLIBC__)
 
1253
#if not __GLIBC_PREREQ(2, 16)
 
1254
#pragma GCC diagnostic push
 
1255
#pragma GCC diagnostic ignored "-Wsign-conversion"
 
1256
#endif
 
1257
#endif
1152
1258
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1153
1259
                                                         warning from
1154
 
                                                         -Wconversion */
 
1260
                                                         -Wconversion
 
1261
                                                         in GNU libc
 
1262
                                                         before
 
1263
                                                         2.16 */
 
1264
#if defined (__GNUC__) and defined (__GLIBC__)
 
1265
#if not __GLIBC_PREREQ(2, 16)
 
1266
#pragma GCC diagnostic pop
 
1267
#endif
 
1268
#endif
1155
1269
        /* This process had nothing to say at this time */
1156
1270
        proc = proc->next;
1157
1271
        continue;
1158
1272
      }
1159
1273
      /* Before reading, make the process' data buffer large enough */
1160
1274
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
1161
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
1162
 
                               + (size_t) BUFFER_SIZE);
1163
 
        if(proc->buffer == NULL){
1164
 
          perror("malloc");
 
1275
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1276
                                   + (size_t) BUFFER_SIZE);
 
1277
        if(new_buffer == NULL){
 
1278
          error(0, errno, "malloc");
1165
1279
          exitstatus = EX_OSERR;
1166
1280
          goto fallback;
1167
1281
        }
 
1282
        proc->buffer = new_buffer;
1168
1283
        proc->buffer_size += BUFFER_SIZE;
1169
1284
      }
1170
1285
      /* Read from the process */
1204
1319
    }
1205
1320
    bret = print_out_password(passwordbuffer, len);
1206
1321
    if(not bret){
1207
 
      perror("print_out_password");
 
1322
      error(0, errno, "print_out_password");
1208
1323
      exitstatus = EX_IOERR;
1209
1324
    }
1210
1325
  }
1212
1327
  /* Restore old signal handler */
1213
1328
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1214
1329
  if(ret == -1){
1215
 
    perror("sigaction");
 
1330
    error(0, errno, "sigaction");
1216
1331
    exitstatus = EX_OSERR;
1217
1332
  }
1218
1333
  
1223
1338
    free(custom_argv);
1224
1339
  }
1225
1340
  
1226
 
  if(dir != NULL){
1227
 
    closedir(dir);
 
1341
  free(direntries);
 
1342
  
 
1343
  if(dir_fd != -1){
 
1344
    close(dir_fd);
1228
1345
  }
1229
1346
  
1230
1347
  /* Kill the processes */
1234
1351
      ret = kill(p->pid, SIGTERM);
1235
1352
      if(ret == -1 and errno != ESRCH){
1236
1353
        /* Set-uid proccesses might not get closed */
1237
 
        perror("kill");
 
1354
        error(0, errno, "kill");
1238
1355
      }
1239
1356
    }
1240
1357
  }
1244
1361
    ret = wait(NULL);
1245
1362
  } while(ret >= 0);
1246
1363
  if(errno != ECHILD){
1247
 
    perror("wait");
 
1364
    error(0, errno, "wait");
1248
1365
  }
1249
1366
  
1250
1367
  free_plugin_list();
1251
1368
  
1252
1369
  free(plugindir);
 
1370
  free(pluginhelperdir);
1253
1371
  free(argfile);
1254
1372
  
1255
1373
  return exitstatus;