/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-03-18 22:29:25 UTC
  • Revision ID: teddy@recompile.se-20190318222925-jvhek84dgcfgj6g3
mandos-ctl: Refactor tests

* mandos-ctl: Where the clients names "foo" and "barbar" do not refer
              to the actual mock clients in the TestCommand class,
              change all occurrences of these names to "client1" and
              "client2" (or just "client" when only one is used) .
              Also change all test doubles to use correct terminology;
              some things called mocks are actually stubs or spies,
              and rename all true mocks to have "mock" in their names.
              Also eliminate duplicate values in tests; derive values
              from previously defined values whenever possible.

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,2009 Teddy Hogeborn
6
 
 * Copyright © 2008,2009 Björn Påhlsson
7
 
 * 
8
 
 * This program is free software: you can redistribute it and/or
9
 
 * modify it under the terms of the GNU General Public License as
10
 
 * published by the Free Software Foundation, either version 3 of the
11
 
 * License, or (at your option) any later version.
12
 
 * 
13
 
 * This program is distributed in the hope that it will be useful, but
 
5
 * Copyright © 2008-2018 Teddy Hogeborn
 
6
 * Copyright © 2008-2018 Björn Påhlsson
 
7
 * 
 
8
 * This file is part of Mandos.
 
9
 * 
 
10
 * Mandos is free software: you can redistribute it and/or modify it
 
11
 * under the terms of the GNU General Public License as published by
 
12
 * the Free Software Foundation, either version 3 of the License, or
 
13
 * (at your option) any later version.
 
14
 * 
 
15
 * Mandos is distributed in the hope that it will be useful, but
14
16
 * WITHOUT ANY WARRANTY; without even the implied warranty of
15
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
18
 * General Public License for more details.
17
19
 * 
18
20
 * You should have received a copy of the GNU General Public License
19
 
 * along with this program.  If not, see
20
 
 * <http://www.gnu.org/licenses/>.
 
21
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
21
22
 * 
22
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
23
 * Contact the authors at <mandos@recompile.se>.
23
24
 */
24
25
 
25
26
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
26
 
                                   asprintf(), 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
 
#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() */
 
32
#include <stdio.h>              /* fileno(), fprintf(),
 
33
                                   stderr, STDOUT_FILENO, fclose() */
 
34
#include <sys/types.h>          /* fstat(), struct stat, waitpid(),
 
35
                                   WIFEXITED(), WEXITSTATUS(), wait(),
 
36
                                   pid_t, uid_t, gid_t, getuid(),
 
37
                                   getgid() */
38
38
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
39
39
                                   FD_SET(), FD_ISSET(), FD_CLR */
40
40
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
41
 
                                   WEXITSTATUS(), 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,
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
       */
525
564
    case '?':                   /* --help */
526
565
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
527
566
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
567
      __builtin_unreachable();
528
568
    case -3:                    /* --usage */
529
569
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
530
570
      argp_state_help(state, state->out_stream,
531
571
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
572
      __builtin_unreachable();
532
573
    case 'V':                   /* --version */
533
574
      fprintf(state->out_stream, "%s\n", argp_program_version);
534
575
      exit(EXIT_SUCCESS);
544
585
      if(arg[0] == '\0'){
545
586
        break;
546
587
      }
 
588
      /* FALLTHROUGH */
547
589
    default:
548
590
      return ARGP_ERR_UNKNOWN;
549
591
    }
568
610
    case 129:                   /* --config-file */
569
611
      free(argfile);
570
612
      argfile = strdup(arg);
 
613
      if(argfile != NULL){
 
614
        errno = 0;
 
615
      }
571
616
      break;
572
617
    case 130:                   /* --userid */
573
618
    case 131:                   /* --groupid */
574
619
    case 132:                   /* --debug */
 
620
    case 133:                   /* --plugin-helper-dir */
575
621
    case '?':                   /* --help */
576
622
    case -3:                    /* --usage */
577
623
    case 'V':                   /* --version */
599
645
  case ENOMEM:
600
646
  default:
601
647
    errno = ret;
602
 
    perror("argp_parse");
 
648
    error(0, errno, "argp_parse");
603
649
    exitstatus = EX_OSERR;
604
650
    goto fallback;
605
651
  case EINVAL:
626
672
    custom_argc = 1;
627
673
    custom_argv = malloc(sizeof(char*) * 2);
628
674
    if(custom_argv == NULL){
629
 
      perror("malloc");
 
675
      error(0, errno, "malloc");
630
676
      exitstatus = EX_OSERR;
631
677
      goto fallback;
632
678
    }
649
695
        }
650
696
        new_arg = strdup(p);
651
697
        if(new_arg == NULL){
652
 
          perror("strdup");
 
698
          error(0, errno, "strdup");
653
699
          exitstatus = EX_OSERR;
654
700
          free(org_line);
655
701
          goto fallback;
656
702
        }
657
703
        
658
704
        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;
 
705
        {
 
706
          char **new_argv = realloc(custom_argv, sizeof(char *)
 
707
                                    * ((size_t)custom_argc + 1));
 
708
          if(new_argv == NULL){
 
709
            error(0, errno, "realloc");
 
710
            exitstatus = EX_OSERR;
 
711
            free(new_arg);
 
712
            free(org_line);
 
713
            goto fallback;
 
714
          } else {
 
715
            custom_argv = new_argv;
 
716
          }
666
717
        }
667
718
        custom_argv[custom_argc-1] = new_arg;
668
719
        custom_argv[custom_argc] = NULL;
672
723
      ret = fclose(conffp);
673
724
    } while(ret == EOF and errno == EINTR);
674
725
    if(ret == EOF){
675
 
      perror("fclose");
 
726
      error(0, errno, "fclose");
676
727
      exitstatus = EX_IOERR;
677
728
      goto fallback;
678
729
    }
681
732
    /* Check for harmful errors and go to fallback. Other errors might
682
733
       not affect opening plugins */
683
734
    if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
684
 
      perror("fopen");
 
735
      error(0, errno, "fopen");
685
736
      exitstatus = EX_OSERR;
686
737
      goto fallback;
687
738
    }
698
749
    case ENOMEM:
699
750
    default:
700
751
      errno = ret;
701
 
      perror("argp_parse");
 
752
      error(0, errno, "argp_parse");
702
753
      exitstatus = EX_OSERR;
703
754
      goto fallback;
704
755
    case EINVAL:
718
769
  case ENOMEM:
719
770
  default:
720
771
    errno = ret;
721
 
    perror("argp_parse");
 
772
    error(0, errno, "argp_parse");
722
773
    exitstatus = EX_OSERR;
723
774
    goto fallback;
724
775
  case EINVAL:
726
777
    goto fallback;
727
778
  }
728
779
  
 
780
  {
 
781
    char *pluginhelperenv;
 
782
    bool bret = true;
 
783
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
 
784
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
785
    if(ret != -1){
 
786
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
 
787
    }
 
788
    if(ret == -1 or not bret){
 
789
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
 
790
            " environment variable to \"%s\" for all plugins\n",
 
791
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
792
    }
 
793
    if(ret != -1){
 
794
      free(pluginhelperenv);
 
795
    }
 
796
  }
 
797
  
729
798
  if(debug){
730
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
799
    for(plugin *p = plugin_list; p != NULL; p = p->next){
731
800
      fprintf(stderr, "Plugin: %s has %d arguments\n",
732
801
              p->name ? p->name : "Global", p->argc - 1);
733
802
      for(char **a = p->argv; *a != NULL; a++){
740
809
    }
741
810
  }
742
811
  
743
 
  /* Strip permissions down to nobody */
744
 
  setgid(gid);
 
812
  if(getuid() == 0){
 
813
    /* Work around Debian bug #633582:
 
814
       <https://bugs.debian.org/633582> */
 
815
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
 
816
    if(plugindir_fd == -1){
 
817
      if(errno != ENOENT){
 
818
        error(0, errno, "open(\"" PDIR "\")");
 
819
      }
 
820
    } else {
 
821
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
 
822
      if(ret == -1){
 
823
        error(0, errno, "fstat");
 
824
      } else {
 
825
        if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
 
826
          ret = fchown(plugindir_fd, uid, gid);
 
827
          if(ret == -1){
 
828
            error(0, errno, "fchown");
 
829
          }
 
830
        }
 
831
      }
 
832
      close(plugindir_fd);
 
833
    }
 
834
  }
 
835
  
 
836
  /* Lower permissions */
 
837
  ret = setgid(gid);
745
838
  if(ret == -1){
746
 
    perror("setgid");
 
839
    error(0, errno, "setgid");
747
840
  }
748
841
  ret = setuid(uid);
749
842
  if(ret == -1){
750
 
    perror("setuid");
 
843
    error(0, errno, "setuid");
751
844
  }
752
845
  
753
846
  /* Open plugin directory with close_on_exec flag */
754
847
  {
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
 
    }
 
848
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
849
#ifdef O_CLOEXEC
 
850
                  O_CLOEXEC
 
851
#else  /* not O_CLOEXEC */
 
852
                  0
 
853
#endif  /* not O_CLOEXEC */
 
854
                  );
773
855
    if(dir_fd == -1){
774
 
      perror("Could not open plugin dir");
 
856
      error(0, errno, "Could not open plugin dir");
775
857
      exitstatus = EX_UNAVAILABLE;
776
858
      goto fallback;
777
859
    }
780
862
  /* Set the FD_CLOEXEC flag on the directory */
781
863
    ret = set_cloexec_flag(dir_fd);
782
864
    if(ret < 0){
783
 
      perror("set_cloexec_flag");
784
 
      TEMP_FAILURE_RETRY(close(dir_fd));
 
865
      error(0, errno, "set_cloexec_flag");
785
866
      exitstatus = EX_OSERR;
786
867
      goto fallback;
787
868
    }
788
869
#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;
 
870
  }
 
871
  
 
872
  int good_name(const struct dirent * const dirent){
 
873
    const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
 
874
                                      "*.dpkg-old", "*.dpkg-bak",
 
875
                                      "*.dpkg-divert", NULL };
 
876
#ifdef __GNUC__
 
877
#pragma GCC diagnostic push
 
878
#pragma GCC diagnostic ignored "-Wcast-qual"
 
879
#endif
 
880
    for(const char **pat = (const char **)patterns;
 
881
        *pat != NULL; pat++){
 
882
#ifdef __GNUC__
 
883
#pragma GCC diagnostic pop
 
884
#endif
 
885
      if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
 
886
         != FNM_NOMATCH){
 
887
        if(debug){
 
888
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
 
889
                    " matching pattern %s\n", dirent->d_name, *pat);
 
890
        }
 
891
        return 0;
 
892
      }
796
893
    }
 
894
    return 1;
 
895
  }
 
896
  
 
897
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
898
                             alphasort);
 
899
  if(numplugins == -1){
 
900
    error(0, errno, "Could not scan plugin dir");
 
901
    direntries = NULL;
 
902
    exitstatus = EX_OSERR;
 
903
    goto fallback;
797
904
  }
798
905
  
799
906
  FD_ZERO(&rfds_all);
800
907
  
801
908
  /* 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");
 
909
  for(int i = 0; i < numplugins; i++){
 
910
    
 
911
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
912
    if(plugin_fd == -1){
 
913
      error(0, errno, "Could not open plugin");
 
914
      free(direntries[i]);
874
915
      continue;
875
916
    }
876
 
    
877
 
    ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));
 
917
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
878
918
    if(ret == -1){
879
 
      perror("stat");
880
 
      free(filename);
 
919
      error(0, errno, "stat");
 
920
      close(plugin_fd);
 
921
      free(direntries[i]);
881
922
      continue;
882
923
    }
883
924
    
884
925
    /* Ignore non-executable files */
885
926
    if(not S_ISREG(st.st_mode)
886
 
       or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){
 
927
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
928
                                        X_OK, 0)) != 0)){
887
929
      if(debug){
888
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
889
 
                " with bad type or mode\n", filename);
 
930
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
931
                " with bad type or mode\n",
 
932
                plugindir != NULL ? plugindir : PDIR,
 
933
                direntries[i]->d_name);
890
934
      }
891
 
      free(filename);
 
935
      close(plugin_fd);
 
936
      free(direntries[i]);
892
937
      continue;
893
938
    }
894
939
    
895
 
    plugin *p = getplugin(dirst->d_name);
 
940
    plugin *p = getplugin(direntries[i]->d_name);
896
941
    if(p == NULL){
897
 
      perror("getplugin");
898
 
      free(filename);
 
942
      error(0, errno, "getplugin");
 
943
      close(plugin_fd);
 
944
      free(direntries[i]);
899
945
      continue;
900
946
    }
901
947
    if(p->disabled){
902
948
      if(debug){
903
949
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
904
 
                dirst->d_name);
 
950
                direntries[i]->d_name);
905
951
      }
906
 
      free(filename);
 
952
      close(plugin_fd);
 
953
      free(direntries[i]);
907
954
      continue;
908
955
    }
909
956
    {
912
959
      if(g != NULL){
913
960
        for(char **a = g->argv + 1; *a != NULL; a++){
914
961
          if(not add_argument(p, *a)){
915
 
            perror("add_argument");
 
962
            error(0, errno, "add_argument");
916
963
          }
917
964
        }
918
965
        /* Add global environment variables */
919
966
        for(char **e = g->environ; *e != NULL; e++){
920
967
          if(not add_environment(p, *e, false)){
921
 
            perror("add_environment");
 
968
            error(0, errno, "add_environment");
922
969
          }
923
970
        }
924
971
      }
925
972
    }
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. */
 
973
    /* If this plugin has any environment variables, we need to
 
974
       duplicate the environment from this process, too. */
929
975
    if(p->environ[0] != NULL){
930
976
      for(char **e = environ; *e != NULL; e++){
931
977
        if(not add_environment(p, *e, false)){
932
 
          perror("add_environment");
 
978
          error(0, errno, "add_environment");
933
979
        }
934
980
      }
935
981
    }
936
982
    
937
983
    int pipefd[2];
 
984
#ifndef O_CLOEXEC
938
985
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
986
#else  /* O_CLOEXEC */
 
987
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
988
#endif  /* O_CLOEXEC */
939
989
    if(ret == -1){
940
 
      perror("pipe");
941
 
      exitstatus = EX_OSERR;
942
 
      goto fallback;
943
 
    }
 
990
      error(0, errno, "pipe");
 
991
      exitstatus = EX_OSERR;
 
992
      free(direntries[i]);
 
993
      goto fallback;
 
994
    }
 
995
    if(pipefd[0] >= FD_SETSIZE){
 
996
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
997
              FD_SETSIZE);
 
998
      close(pipefd[0]);
 
999
      close(pipefd[1]);
 
1000
      exitstatus = EX_OSERR;
 
1001
      free(direntries[i]);
 
1002
      goto fallback;
 
1003
    }
 
1004
#ifndef O_CLOEXEC
944
1005
    /* Ask OS to automatic close the pipe on exec */
945
1006
    ret = set_cloexec_flag(pipefd[0]);
946
1007
    if(ret < 0){
947
 
      perror("set_cloexec_flag");
 
1008
      error(0, errno, "set_cloexec_flag");
 
1009
      close(pipefd[0]);
 
1010
      close(pipefd[1]);
948
1011
      exitstatus = EX_OSERR;
 
1012
      free(direntries[i]);
949
1013
      goto fallback;
950
1014
    }
951
1015
    ret = set_cloexec_flag(pipefd[1]);
952
1016
    if(ret < 0){
953
 
      perror("set_cloexec_flag");
 
1017
      error(0, errno, "set_cloexec_flag");
 
1018
      close(pipefd[0]);
 
1019
      close(pipefd[1]);
954
1020
      exitstatus = EX_OSERR;
 
1021
      free(direntries[i]);
955
1022
      goto fallback;
956
1023
    }
 
1024
#endif  /* not O_CLOEXEC */
957
1025
    /* Block SIGCHLD until process is safely in process list */
958
1026
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
959
1027
                                              &sigchld_action.sa_mask,
960
1028
                                              NULL));
961
1029
    if(ret < 0){
962
 
      perror("sigprocmask");
 
1030
      error(0, errno, "sigprocmask");
963
1031
      exitstatus = EX_OSERR;
 
1032
      free(direntries[i]);
964
1033
      goto fallback;
965
1034
    }
966
1035
    /* Starting a new process to be watched */
969
1038
      pid = fork();
970
1039
    } while(pid == -1 and errno == EINTR);
971
1040
    if(pid == -1){
972
 
      perror("fork");
 
1041
      error(0, errno, "fork");
 
1042
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1043
                                     &sigchld_action.sa_mask, NULL));
 
1044
      close(pipefd[0]);
 
1045
      close(pipefd[1]);
973
1046
      exitstatus = EX_OSERR;
 
1047
      free(direntries[i]);
974
1048
      goto fallback;
975
1049
    }
976
1050
    if(pid == 0){
977
1051
      /* this is the child process */
978
1052
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
979
1053
      if(ret < 0){
980
 
        perror("sigaction");
 
1054
        error(0, errno, "sigaction");
981
1055
        _exit(EX_OSERR);
982
1056
      }
983
1057
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
984
1058
      if(ret < 0){
985
 
        perror("sigprocmask");
 
1059
        error(0, errno, "sigprocmask");
986
1060
        _exit(EX_OSERR);
987
1061
      }
988
1062
      
989
1063
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
990
1064
      if(ret == -1){
991
 
        perror("dup2");
 
1065
        error(0, errno, "dup2");
992
1066
        _exit(EX_OSERR);
993
1067
      }
994
1068
      
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
 
        }
 
1069
      if(fexecve(plugin_fd, p->argv,
 
1070
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1071
        error(0, errno, "fexecve for %s/%s",
 
1072
              plugindir != NULL ? plugindir : PDIR,
 
1073
              direntries[i]->d_name);
 
1074
        _exit(EX_OSERR);
1010
1075
      }
1011
1076
      /* no return */
1012
1077
    }
1013
1078
    /* 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);
 
1079
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1080
    close(plugin_fd);
 
1081
    plugin *new_plugin = getplugin(direntries[i]->d_name);
1018
1082
    if(new_plugin == NULL){
1019
 
      perror("getplugin");
 
1083
      error(0, errno, "getplugin");
1020
1084
      ret = (int)(TEMP_FAILURE_RETRY
1021
1085
                  (sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
1022
1086
                               NULL)));
1023
1087
      if(ret < 0){
1024
 
        perror("sigprocmask");
 
1088
        error(0, errno, "sigprocmask");
1025
1089
      }
1026
1090
      exitstatus = EX_OSERR;
 
1091
      free(direntries[i]);
1027
1092
      goto fallback;
1028
1093
    }
 
1094
    free(direntries[i]);
1029
1095
    
1030
1096
    new_plugin->pid = pid;
1031
1097
    new_plugin->fd = pipefd[0];
1032
 
    
 
1098
 
 
1099
    if(debug){
 
1100
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1101
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1102
    }
 
1103
 
1033
1104
    /* Unblock SIGCHLD so signal handler can be run if this process
1034
1105
       has already completed */
1035
1106
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1036
1107
                                              &sigchld_action.sa_mask,
1037
1108
                                              NULL));
1038
1109
    if(ret < 0){
1039
 
      perror("sigprocmask");
 
1110
      error(0, errno, "sigprocmask");
1040
1111
      exitstatus = EX_OSERR;
1041
1112
      goto fallback;
1042
1113
    }
1043
1114
    
1044
 
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
1045
 
                                          -Wconversion */
 
1115
    FD_SET(new_plugin->fd, &rfds_all);
1046
1116
    
1047
1117
    if(maxfd < new_plugin->fd){
1048
1118
      maxfd = new_plugin->fd;
1049
1119
    }
1050
1120
  }
1051
1121
  
1052
 
  TEMP_FAILURE_RETRY(closedir(dir));
1053
 
  dir = NULL;
 
1122
  free(direntries);
 
1123
  direntries = NULL;
 
1124
  close(dir_fd);
 
1125
  dir_fd = -1;
1054
1126
  free_plugin(getplugin(NULL));
1055
1127
  
1056
1128
  for(plugin *p = plugin_list; p != NULL; p = p->next){
1069
1141
    fd_set rfds = rfds_all;
1070
1142
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
1071
1143
    if(select_ret == -1 and errno != EINTR){
1072
 
      perror("select");
 
1144
      error(0, errno, "select");
1073
1145
      exitstatus = EX_OSERR;
1074
1146
      goto fallback;
1075
1147
    }
1095
1167
                      (intmax_t) (proc->pid),
1096
1168
                      WTERMSIG(proc->status),
1097
1169
                      strsignal(WTERMSIG(proc->status)));
1098
 
            } else if(WCOREDUMP(proc->status)){
1099
 
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1100
 
                      " core\n", proc->name, (intmax_t) (proc->pid));
1101
1170
            }
1102
1171
          }
1103
1172
          
1104
1173
          /* Remove the plugin */
1105
 
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
1106
 
                                          -Wconversion */
 
1174
          FD_CLR(proc->fd, &rfds_all);
1107
1175
          
1108
1176
          /* Block signal while modifying process_list */
1109
1177
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1111
1179
                                         &sigchld_action.sa_mask,
1112
1180
                                         NULL));
1113
1181
          if(ret < 0){
1114
 
            perror("sigprocmask");
 
1182
            error(0, errno, "sigprocmask");
1115
1183
            exitstatus = EX_OSERR;
1116
1184
            goto fallback;
1117
1185
          }
1125
1193
                      (sigprocmask(SIG_UNBLOCK,
1126
1194
                                   &sigchld_action.sa_mask, NULL)));
1127
1195
          if(ret < 0){
1128
 
            perror("sigprocmask");
 
1196
            error(0, errno, "sigprocmask");
1129
1197
            exitstatus = EX_OSERR;
1130
1198
            goto fallback;
1131
1199
          }
1142
1210
        bool bret = print_out_password(proc->buffer,
1143
1211
                                       proc->buffer_length);
1144
1212
        if(not bret){
1145
 
          perror("print_out_password");
 
1213
          error(0, errno, "print_out_password");
1146
1214
          exitstatus = EX_IOERR;
1147
1215
        }
1148
1216
        goto fallback;
1149
1217
      }
1150
1218
      
1151
1219
      /* This process has not completed.  Does it have any output? */
1152
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1153
 
                                                         warning from
1154
 
                                                         -Wconversion */
 
1220
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1155
1221
        /* This process had nothing to say at this time */
1156
1222
        proc = proc->next;
1157
1223
        continue;
1158
1224
      }
1159
1225
      /* Before reading, make the process' data buffer large enough */
1160
1226
      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");
 
1227
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1228
                                   + (size_t) BUFFER_SIZE);
 
1229
        if(new_buffer == NULL){
 
1230
          error(0, errno, "malloc");
1165
1231
          exitstatus = EX_OSERR;
1166
1232
          goto fallback;
1167
1233
        }
 
1234
        proc->buffer = new_buffer;
1168
1235
        proc->buffer_size += BUFFER_SIZE;
1169
1236
      }
1170
1237
      /* Read from the process */
1204
1271
    }
1205
1272
    bret = print_out_password(passwordbuffer, len);
1206
1273
    if(not bret){
1207
 
      perror("print_out_password");
 
1274
      error(0, errno, "print_out_password");
1208
1275
      exitstatus = EX_IOERR;
1209
1276
    }
1210
1277
  }
1212
1279
  /* Restore old signal handler */
1213
1280
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
1214
1281
  if(ret == -1){
1215
 
    perror("sigaction");
 
1282
    error(0, errno, "sigaction");
1216
1283
    exitstatus = EX_OSERR;
1217
1284
  }
1218
1285
  
1223
1290
    free(custom_argv);
1224
1291
  }
1225
1292
  
1226
 
  if(dir != NULL){
1227
 
    closedir(dir);
 
1293
  free(direntries);
 
1294
  
 
1295
  if(dir_fd != -1){
 
1296
    close(dir_fd);
1228
1297
  }
1229
1298
  
1230
1299
  /* Kill the processes */
1234
1303
      ret = kill(p->pid, SIGTERM);
1235
1304
      if(ret == -1 and errno != ESRCH){
1236
1305
        /* Set-uid proccesses might not get closed */
1237
 
        perror("kill");
 
1306
        error(0, errno, "kill");
1238
1307
      }
1239
1308
    }
1240
1309
  }
1244
1313
    ret = wait(NULL);
1245
1314
  } while(ret >= 0);
1246
1315
  if(errno != ECHILD){
1247
 
    perror("wait");
 
1316
    error(0, errno, "wait");
1248
1317
  }
1249
1318
  
1250
1319
  free_plugin_list();
1251
1320
  
1252
1321
  free(plugindir);
 
1322
  free(pluginhelperdir);
1253
1323
  free(argfile);
1254
1324
  
1255
1325
  return exitstatus;