/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: 2021-02-01 19:30:45 UTC
  • Revision ID: teddy@recompile.se-20210201193045-lpg6aprpc4srem6k
Fix issue with french translation

Initial white space was missing in both msgid and msgstr of the french
translation, leading to checking tools reporing an incomplete
translation.  The string is a raw command line command, and therefore
did not need translation, so this was never a user-visible issue.

* debian/po/fr.po: Add missing whitespace to the id and translation
  for msgid " mandos-keygen -F/dev/null|grep ^key_id".

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-2015 Teddy Hogeborn
6
 
 * Copyright © 2008-2015 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-2020 Teddy Hogeborn
 
6
 * Copyright © 2008-2020 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
 */
25
26
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), getline(),
26
27
                                   O_CLOEXEC, pipe2() */
27
28
#include <stddef.h>             /* size_t, NULL */
28
 
#include <stdlib.h>             /* malloc(), exit(), EXIT_SUCCESS,
29
 
                                   realloc() */
 
29
#include <stdlib.h>             /* malloc(), reallocarray(), realloc(),
 
30
                                   EXIT_SUCCESS, exit() */
30
31
#include <stdbool.h>            /* bool, true, false */
31
32
#include <stdio.h>              /* fileno(), fprintf(),
32
33
                                   stderr, STDOUT_FILENO, fclose() */
37
38
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
38
39
                                   FD_SET(), FD_ISSET(), FD_CLR */
39
40
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
40
 
                                   WEXITSTATUS(), WTERMSIG(),
41
 
                                   WCOREDUMP() */
 
41
                                   WEXITSTATUS(), WTERMSIG() */
42
42
#include <sys/stat.h>           /* struct stat, fstat(), S_ISREG() */
43
43
#include <iso646.h>             /* and, or, not */
44
44
#include <dirent.h>             /* struct dirent, scandirat() */
47
47
                                   struct stat, fstat(), close(),
48
48
                                   setgid(), setuid(), S_ISREG(),
49
49
                                   faccessat() pipe2(), fork(),
50
 
                                   _exit(), dup2(), fexecve(), read()
51
 
                                */
 
50
                                   _exit(), dup2(), fexecve(), read(),
 
51
                                   lstat(), symlink() */
52
52
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
53
53
                                   FD_CLOEXEC, openat(), scandirat(),
54
54
                                   pipe2() */
179
179
  /* Resize the pointed-to array to hold one more pointer */
180
180
  char **new_array = NULL;
181
181
  do {
182
 
    new_array = realloc(*array, sizeof(char *)
183
 
                        * (size_t) ((*len) + 2));
 
182
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
183
    new_array = reallocarray(*array, (size_t)((*len) + 2),
 
184
                             sizeof(char *));
 
185
#else
 
186
    if(((size_t)((*len) + 2)) > (SIZE_MAX / sizeof(char *))){
 
187
      /* overflow */
 
188
      new_array = NULL;
 
189
      errno = ENOMEM;
 
190
    } else {
 
191
      new_array = realloc(*array, (size_t)((*len) + 2)
 
192
                          * sizeof(char *));
 
193
    }
 
194
#endif
184
195
  } while(new_array == NULL and errno == EINTR);
185
196
  /* Malloc check */
186
197
  if(new_array == NULL){
313
324
__attribute__((nonnull))
314
325
static void free_plugin(plugin *plugin_node){
315
326
  
316
 
  for(char **arg = plugin_node->argv; *arg != NULL; arg++){
 
327
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
317
328
    free(*arg);
318
329
  }
 
330
  free(plugin_node->name);
319
331
  free(plugin_node->argv);
320
332
  for(char **env = plugin_node->environ; *env != NULL; env++){
321
333
    free(*env);
564
576
    case '?':                   /* --help */
565
577
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
566
578
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
579
      __builtin_unreachable();
567
580
    case -3:                    /* --usage */
568
581
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
569
582
      argp_state_help(state, state->out_stream,
570
583
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
584
      __builtin_unreachable();
571
585
    case 'V':                   /* --version */
572
586
      fprintf(state->out_stream, "%s\n", argp_program_version);
573
587
      exit(EXIT_SUCCESS);
583
597
      if(arg[0] == '\0'){
584
598
        break;
585
599
      }
 
600
#if __GNUC__ >= 7
 
601
      __attribute__((fallthrough));
 
602
#else
 
603
          /* FALLTHROUGH */
 
604
#endif
586
605
    default:
587
606
      return ARGP_ERR_UNKNOWN;
588
607
    }
700
719
        
701
720
        custom_argc += 1;
702
721
        {
703
 
          char **new_argv = realloc(custom_argv, sizeof(char *)
704
 
                                    * ((unsigned int)
705
 
                                       custom_argc + 1));
 
722
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
723
          char **new_argv = reallocarray(custom_argv, (size_t)custom_argc + 1,
 
724
                                         sizeof(char *));
 
725
#else
 
726
          char **new_argv = NULL;
 
727
          if(((size_t)custom_argc + 1) > (SIZE_MAX / sizeof(char *))){
 
728
            /* overflow */
 
729
            errno = ENOMEM;
 
730
          } else {
 
731
            new_argv = realloc(custom_argv, ((size_t)custom_argc + 1)
 
732
                               * sizeof(char *));
 
733
          }
 
734
#endif
706
735
          if(new_argv == NULL){
707
 
            error(0, errno, "realloc");
 
736
            error(0, errno, "reallocarray");
708
737
            exitstatus = EX_OSERR;
709
738
            free(new_arg);
710
739
            free(org_line);
794
823
  }
795
824
  
796
825
  if(debug){
797
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
826
    for(plugin *p = plugin_list; p != NULL; p = p->next){
798
827
      fprintf(stderr, "Plugin: %s has %d arguments\n",
799
828
              p->name ? p->name : "Global", p->argc - 1);
800
829
      for(char **a = p->argv; *a != NULL; a++){
809
838
  
810
839
  if(getuid() == 0){
811
840
    /* Work around Debian bug #633582:
812
 
       <http://bugs.debian.org/633582> */
 
841
       <https://bugs.debian.org/633582> */
813
842
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
814
843
    if(plugindir_fd == -1){
815
844
      if(errno != ENOENT){
829
858
      }
830
859
      close(plugindir_fd);
831
860
    }
 
861
 
 
862
    /* Work around Debian bug #981302
 
863
       <https://bugs.debian.org/981302> */
 
864
    if(lstat("/dev/fd", &st) != 0 and errno == ENOENT){
 
865
      ret = symlink("/proc/self/fd", "/dev/fd");
 
866
      if(ret == -1){
 
867
        error(0, errno, "Failed to create /dev/fd symlink");
 
868
      }
 
869
    }
832
870
  }
833
871
  
834
872
  /* Lower permissions */
892
930
    return 1;
893
931
  }
894
932
  
895
 
#ifdef __GLIBC__
896
 
#if __GLIBC_PREREQ(2, 15)
897
933
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
898
934
                             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
935
  if(numplugins == -1){
908
936
    error(0, errno, "Could not scan plugin dir");
909
937
    direntries = NULL;
1103
1131
    
1104
1132
    new_plugin->pid = pid;
1105
1133
    new_plugin->fd = pipefd[0];
1106
 
    
 
1134
 
 
1135
    if(debug){
 
1136
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1137
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1138
    }
 
1139
 
1107
1140
    /* Unblock SIGCHLD so signal handler can be run if this process
1108
1141
       has already completed */
1109
1142
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
1115
1148
      goto fallback;
1116
1149
    }
1117
1150
    
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
1124
 
    FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from
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
 
1151
    FD_SET(new_plugin->fd, &rfds_all);
1132
1152
    
1133
1153
    if(maxfd < new_plugin->fd){
1134
1154
      maxfd = new_plugin->fd;
1183
1203
                      (intmax_t) (proc->pid),
1184
1204
                      WTERMSIG(proc->status),
1185
1205
                      strsignal(WTERMSIG(proc->status)));
1186
 
            } else if(WCOREDUMP(proc->status)){
1187
 
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"
1188
 
                      " core\n", proc->name, (intmax_t) (proc->pid));
1189
1206
            }
1190
1207
          }
1191
1208
          
1192
1209
          /* 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
1199
 
          FD_CLR(proc->fd, &rfds_all); /* Spurious warning from
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
 
1210
          FD_CLR(proc->fd, &rfds_all);
1207
1211
          
1208
1212
          /* Block signal while modifying process_list */
1209
1213
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
1249
1253
      }
1250
1254
      
1251
1255
      /* 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
1258
 
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious
1259
 
                                                         warning from
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
 
1256
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
1269
1257
        /* This process had nothing to say at this time */
1270
1258
        proc = proc->next;
1271
1259
        continue;