/mandos/release

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2024-11-17 18:43:11 UTC
  • mto: This revision was merged to the branch mainline in revision 412.
  • Revision ID: teddy@recompile.se-20241117184311-ox25kvngy62h209g
Debian package: Avoid suggesting a C compiler unnecessarily

The list of suggested packages, meant to enable the "mandos" program
to find the correct value of SO_BINDTODEVICE by using a C compiler,
are not necessary when Python 3.3 or later is used, since it has the
SO_BINDTODEVICE constant defined in the "socket" module.  Also, Python
2.6 or older has the same constant in the old "IN" module.  Therefore,
we should suggest these Python versions as alternatives to a C
compiler, so that a C compiler is not installed unnecessarily.

debian/control (Package: mandos/Suggests): Add "python3 (>= 3.3)" and
"python (<= 2.6)" as alternatives to "libc6-dev | libc-dev" and
"c-compiler".

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/*  -*- coding: utf-8 -*- */
 
1
/*  -*- coding: utf-8; mode: c; mode: orgtbl -*- */
2
2
/*
3
3
 * Mandos plugin runner - Run Mandos plugins
4
4
 *
5
 
 * Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
6
 
 * 
7
 
 * This program is free software: you can redistribute it and/or
8
 
 * modify it under the terms of the GNU General Public License as
9
 
 * published by the Free Software Foundation, either version 3 of the
10
 
 * License, or (at your option) any later version.
11
 
 * 
12
 
 * This program is distributed in the hope that it will be useful, but
 
5
 * Copyright © 2008-2022 Teddy Hogeborn
 
6
 * Copyright © 2008-2022 Björn Påhlsson
 
7
 * 
 
8
 * This file is part of Mandos.
 
9
 * 
 
10
 * Mandos is free software: you can redistribute it and/or modify it
 
11
 * under the terms of the GNU General Public License as published by
 
12
 * the Free Software Foundation, either version 3 of the License, or
 
13
 * (at your option) any later version.
 
14
 * 
 
15
 * Mandos is distributed in the hope that it will be useful, but
13
16
 * WITHOUT ANY WARRANTY; without even the implied warranty of
14
17
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
18
 * General Public License for more details.
16
19
 * 
17
20
 * You should have received a copy of the GNU General Public License
18
 
 * along with this program.  If not, see
19
 
 * <http://www.gnu.org/licenses/>.
 
21
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
20
22
 * 
21
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
23
 * Contact the authors at <mandos@recompile.se>.
22
24
 */
23
25
 
24
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY() */
25
 
 
 
26
#define _GNU_SOURCE             /* strchrnul(), TEMP_FAILURE_RETRY(),
 
27
                                   getline(), asprintf(), O_CLOEXEC,
 
28
                                   scandirat(), pipe2() */
 
29
#include <argp.h>               /* argp_program_version,
 
30
                                   argp_program_bug_address,
 
31
                                   struct argp_option,
 
32
                                   struct argp_state, argp_error(),
 
33
                                   ARGP_NO_EXIT, argp_state_help,
 
34
                                   ARGP_HELP_STD_HELP,
 
35
                                   ARGP_HELP_USAGE, ARGP_HELP_EXIT_OK,
 
36
                                   ARGP_KEY_ARG, ARGP_ERR_UNKNOWN,
 
37
                                   struct argp, argp_parse(),
 
38
                                   ARGP_IN_ORDER, ARGP_NO_HELP */
 
39
#include <stdbool.h>            /* bool, false, true */
 
40
#include <sys/types.h>          /* pid_t, sig_atomic_t, uid_t, gid_t,
 
41
                                   getuid(), setgid(), setuid() */
26
42
#include <stddef.h>             /* size_t, NULL */
27
 
#include <stdlib.h>             /* malloc(), exit(), EXIT_FAILURE,
28
 
                                   EXIT_SUCCESS, realloc() */
29
 
#include <stdbool.h>            /* bool, true, false */
30
 
#include <stdio.h>              /* perror, popen(), fileno(),
31
 
                                   fprintf(), stderr, STDOUT_FILENO */
32
 
#include <sys/types.h>          /* DIR, opendir(), stat(), struct
33
 
                                   stat, waitpid(), WIFEXITED(),
34
 
                                   WEXITSTATUS(), wait(), pid_t,
35
 
                                   uid_t, gid_t, getuid(), getgid(),
36
 
                                   dirfd() */
37
 
#include <sys/select.h>         /* fd_set, select(), FD_ZERO(),
38
 
                                   FD_SET(), FD_ISSET(), FD_CLR */
39
 
#include <sys/wait.h>           /* wait(), waitpid(), WIFEXITED(),
40
 
                                   WEXITSTATUS() */
41
 
#include <sys/stat.h>           /* struct stat, stat(), S_ISREG() */
42
 
#include <iso646.h>             /* and, or, not */
43
 
#include <dirent.h>             /* DIR, struct dirent, opendir(),
44
 
                                   readdir(), closedir(), dirfd() */
45
 
#include <unistd.h>             /* struct stat, stat(), S_ISREG(),
46
 
                                   fcntl(), setuid(), setgid(),
47
 
                                   F_GETFD, F_SETFD, FD_CLOEXEC,
48
 
                                   access(), pipe(), fork(), close()
49
 
                                   dup2, STDOUT_FILENO, _exit(),
50
 
                                   execv(), write(), read(),
51
 
                                   close() */
 
43
#include <iso646.h>             /* or, and, not */
 
44
#include <string.h>             /* strcmp(), strdup(), strchrnul(),
 
45
                                   strncmp(), strlen(), strcpy(),
 
46
                                   strsep(), strchr(), strsignal() */
 
47
#include <stdlib.h>             /* malloc(), free(), reallocarray(),
 
48
                                   realloc(), EXIT_SUCCESS */
 
49
#include <errno.h>              /* errno, EINTR, ENOMEM, ECHILD,
 
50
                                   error_t, EINVAL, EMFILE, ENFILE,
 
51
                                   ENOENT, ESRCH */
 
52
#include <stdint.h>             /* SIZE_MAX */
 
53
#define _GNU_SOURCE             /* strchrnul(), TEMP_FAILURE_RETRY(),
 
54
                                   getline(), asprintf(), O_CLOEXEC,
 
55
                                   scandirat(), pipe2() */
 
56
#include <unistd.h>             /* TEMP_FAILURE_RETRY(), ssize_t,
 
57
                                   write(), STDOUT_FILENO, uid_t,
 
58
                                   gid_t, getuid(), fchown(), close(),
 
59
                                   symlink(), setgid(), setuid(),
 
60
                                   faccessat(), X_OK, pipe(), pipe2(),
 
61
                                   fork(), _exit(), dup2(), fexecve(),
 
62
                                   read(), getpass() */
52
63
#include <fcntl.h>              /* fcntl(), F_GETFD, F_SETFD,
53
 
                                   FD_CLOEXEC */
54
 
#include <string.h>             /* strsep, strlen(), strcpy(),
55
 
                                   strcat() */
56
 
#include <errno.h>              /* errno */
57
 
#include <argp.h>               /* struct argp_option, struct
58
 
                                   argp_state, struct argp,
59
 
                                   argp_parse(), ARGP_ERR_UNKNOWN,
60
 
                                   ARGP_KEY_END, ARGP_KEY_ARG, error_t */
61
 
#include <signal.h>             /* struct sigaction, sigemptyset(),
62
 
                                   sigaddset(), sigaction(),
63
 
                                   sigprocmask(), SIG_BLOCK, SIGCHLD,
64
 
                                   SIG_UNBLOCK, kill() */
65
 
#include <errno.h>              /* errno, EBADF */
 
64
                                   FD_CLOEXEC, open(), O_RDONLY,
 
65
                                   O_CLOEXEC, openat() */
 
66
#include <sys/wait.h>           /* waitpid(), WNOHANG, WIFEXITED(),
 
67
                                   WEXITSTATUS(), WIFSIGNALED(),
 
68
                                   WTERMSIG(), wait() */
 
69
#include <error.h>              /* error() */
 
70
#include <stdio.h>              /* FILE, fprintf(), fopen(),
 
71
                                   getline(), fclose(), EOF,
 
72
                                   asprintf(), stderr */
 
73
#include <dirent.h>             /* struct dirent, scandirat(),
 
74
                                   alphasort() */
 
75
#include <sys/stat.h>           /* struct stat, fstat(), S_ISDIR(),
 
76
                                   lstat(), S_ISREG() */
 
77
#include <sys/select.h>         /* fd_set, FD_ZERO(), FD_SETSIZE,
 
78
                                   FD_SET(), select(), FD_CLR(),
 
79
                                   FD_ISSET() */
 
80
#include <signal.h>             /* struct sigaction, SA_NOCLDSTOP,
 
81
                                   sigemptyset(), sigaddset(),
 
82
                                   SIGCHLD, sigprocmask(), SIG_BLOCK,
 
83
                                   SIG_UNBLOCK, kill(), SIGTERM */
 
84
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_IOERR,
 
85
                                   EX_CONFIG, EX_UNAVAILABLE, EX_OK */
 
86
#include <inttypes.h>           /* intmax_t, strtoimax(), PRIdMAX */
 
87
#include <fnmatch.h>            /* fnmatch(), FNM_FILE_NAME,
 
88
                                   FNM_PERIOD, FNM_NOMATCH */
66
89
 
67
90
#define BUFFER_SIZE 256
68
 
#define CONFFILE "/conf/conf.d/mandos/client.conf"
69
 
 
70
 
const char *argp_program_version = "mandos-client 1.0";
71
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
72
 
 
73
 
struct process;
74
 
 
75
 
typedef struct process{
 
91
 
 
92
#define PDIR "/lib/mandos/plugins.d"
 
93
#define PHDIR "/lib/mandos/plugin-helpers"
 
94
#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"
 
95
 
 
96
const char *argp_program_version = "plugin-runner " VERSION;
 
97
const char *argp_program_bug_address = "<mandos@recompile.se>";
 
98
 
 
99
typedef struct plugin{
 
100
  char *name;                   /* can be NULL or any plugin name */
 
101
  char **argv;
 
102
  int argc;
 
103
  char **environ;
 
104
  int envc;
 
105
  bool disabled;
 
106
  
 
107
  /* Variables used for running processes*/
76
108
  pid_t pid;
77
109
  int fd;
78
110
  char *buffer;
79
111
  size_t buffer_size;
80
112
  size_t buffer_length;
81
113
  bool eof;
82
 
  bool completed;
 
114
  volatile sig_atomic_t completed;
83
115
  int status;
84
 
  struct process *next;
85
 
} process;
86
 
 
87
 
typedef struct plugin{
88
 
  char *name;                   /* can be NULL or any plugin name */
89
 
  char **argv;
90
 
  int argc;
91
 
  bool disabled;
92
116
  struct plugin *next;
93
117
} plugin;
94
118
 
95
 
static plugin *getplugin(char *name, plugin **plugin_list){
96
 
  for (plugin *p = *plugin_list; p != NULL; p = p->next){
97
 
    if ((p->name == name)
98
 
        or (p->name and name and (strcmp(p->name, name) == 0))){
 
119
static plugin *plugin_list = NULL;
 
120
 
 
121
/* Gets an existing plugin based on name,
 
122
   or if none is found, creates a new one */
 
123
__attribute__((warn_unused_result))
 
124
static plugin *getplugin(char *name){
 
125
  /* Check for existing plugin with that name */
 
126
  for(plugin *p = plugin_list; p != NULL; p = p->next){
 
127
    if((p->name == name)
 
128
       or (p->name and name and (strcmp(p->name, name) == 0))){
99
129
      return p;
100
130
    }
101
131
  }
102
132
  /* Create a new plugin */
103
 
  plugin *new_plugin = malloc(sizeof(plugin));
104
 
  if (new_plugin == NULL){
105
 
    perror("malloc");
106
 
    exit(EXIT_FAILURE);
107
 
  }
108
 
  new_plugin->name = name;
109
 
  new_plugin->argv = malloc(sizeof(char *) * 2);
110
 
  if (new_plugin->argv == NULL){
111
 
    perror("malloc");
112
 
    exit(EXIT_FAILURE);
113
 
  }
114
 
  new_plugin->argv[0] = name;
 
133
  plugin *new_plugin = NULL;
 
134
  do {
 
135
    new_plugin = malloc(sizeof(plugin));
 
136
  } while(new_plugin == NULL and errno == EINTR);
 
137
  if(new_plugin == NULL){
 
138
    return NULL;
 
139
  }
 
140
  char *copy_name = NULL;
 
141
  if(name != NULL){
 
142
    do {
 
143
      copy_name = strdup(name);
 
144
    } while(copy_name == NULL and errno == EINTR);
 
145
    if(copy_name == NULL){
 
146
      int e = errno;
 
147
      free(new_plugin);
 
148
      errno = e;
 
149
      return NULL;
 
150
    }
 
151
  }
 
152
  
 
153
  *new_plugin = (plugin){ .name = copy_name,
 
154
                          .argc = 1,
 
155
                          .disabled = false,
 
156
                          .next = plugin_list };
 
157
  
 
158
  do {
 
159
    new_plugin->argv = malloc(sizeof(char *) * 2);
 
160
  } while(new_plugin->argv == NULL and errno == EINTR);
 
161
  if(new_plugin->argv == NULL){
 
162
    int e = errno;
 
163
    free(copy_name);
 
164
    free(new_plugin);
 
165
    errno = e;
 
166
    return NULL;
 
167
  }
 
168
  new_plugin->argv[0] = copy_name;
115
169
  new_plugin->argv[1] = NULL;
116
 
  new_plugin->argc = 1;
117
 
  new_plugin->disabled = false;
118
 
  new_plugin->next = *plugin_list;
 
170
  
 
171
  do {
 
172
    new_plugin->environ = malloc(sizeof(char *));
 
173
  } while(new_plugin->environ == NULL and errno == EINTR);
 
174
  if(new_plugin->environ == NULL){
 
175
    int e = errno;
 
176
    free(copy_name);
 
177
    free(new_plugin->argv);
 
178
    free(new_plugin);
 
179
    errno = e;
 
180
    return NULL;
 
181
  }
 
182
  new_plugin->environ[0] = NULL;
 
183
  
119
184
  /* Append the new plugin to the list */
120
 
  *plugin_list = new_plugin;
 
185
  plugin_list = new_plugin;
121
186
  return new_plugin;
122
187
}
123
188
 
124
 
static void addargument(plugin *p, char *arg){
125
 
  p->argv[p->argc] = arg;
126
 
  p->argv = realloc(p->argv, sizeof(char *) * (size_t)(p->argc + 2));
127
 
  if (p->argv == NULL){
128
 
    perror("malloc");
129
 
    exit(EXIT_FAILURE);
130
 
  }
131
 
  p->argc++;
132
 
  p->argv[p->argc] = NULL;
133
 
}
134
 
 
 
189
/* Helper function for add_argument and add_environment */
 
190
__attribute__((nonnull, warn_unused_result))
 
191
static bool add_to_char_array(const char *new, char ***array,
 
192
                              int *len){
 
193
  /* Resize the pointed-to array to hold one more pointer */
 
194
  char **new_array = NULL;
 
195
  do {
 
196
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
197
    new_array = reallocarray(*array, (size_t)((*len) + 2),
 
198
                             sizeof(char *));
 
199
#else
 
200
    if(((size_t)((*len) + 2)) > (SIZE_MAX / sizeof(char *))){
 
201
      /* overflow */
 
202
      new_array = NULL;
 
203
      errno = ENOMEM;
 
204
    } else {
 
205
      new_array = realloc(*array, (size_t)((*len) + 2)
 
206
                          * sizeof(char *));
 
207
    }
 
208
#endif
 
209
  } while(new_array == NULL and errno == EINTR);
 
210
  /* Malloc check */
 
211
  if(new_array == NULL){
 
212
    return false;
 
213
  }
 
214
  *array = new_array;
 
215
  /* Make a copy of the new string */
 
216
  char *copy;
 
217
  do {
 
218
    copy = strdup(new);
 
219
  } while(copy == NULL and errno == EINTR);
 
220
  if(copy == NULL){
 
221
    return false;
 
222
  }
 
223
  /* Insert the copy */
 
224
  (*array)[*len] = copy;
 
225
  (*len)++;
 
226
  /* Add a new terminating NULL pointer to the last element */
 
227
  (*array)[*len] = NULL;
 
228
  return true;
 
229
}
 
230
 
 
231
/* Add to a plugin's argument vector */
 
232
__attribute__((nonnull(2), warn_unused_result))
 
233
static bool add_argument(plugin *p, const char *arg){
 
234
  if(p == NULL){
 
235
    return false;
 
236
  }
 
237
  return add_to_char_array(arg, &(p->argv), &(p->argc));
 
238
}
 
239
 
 
240
/* Add to a plugin's environment */
 
241
__attribute__((nonnull(2), warn_unused_result))
 
242
static bool add_environment(plugin *p, const char *def, bool replace){
 
243
  if(p == NULL){
 
244
    return false;
 
245
  }
 
246
  /* namelen = length of name of environment variable */
 
247
  size_t namelen = (size_t)(strchrnul(def, '=') - def);
 
248
  /* Search for this environment variable */
 
249
  for(char **envdef = p->environ; *envdef != NULL; envdef++){
 
250
    if(strncmp(*envdef, def, namelen + 1) == 0){
 
251
      /* It already exists */
 
252
      if(replace){
 
253
        char *new_envdef;
 
254
        do {
 
255
          new_envdef = realloc(*envdef, strlen(def) + 1);
 
256
        } while(new_envdef == NULL and errno == EINTR);
 
257
        if(new_envdef == NULL){
 
258
          return false;
 
259
        }
 
260
        *envdef = new_envdef;
 
261
        strcpy(*envdef, def);
 
262
      }
 
263
      return true;
 
264
    }
 
265
  }
 
266
  return add_to_char_array(def, &(p->environ), &(p->envc));
 
267
}
 
268
 
 
269
#ifndef O_CLOEXEC
135
270
/*
136
271
 * Based on the example in the GNU LibC manual chapter 13.13 "File
137
272
 * Descriptor Flags".
138
 
 * *Note File Descriptor Flags:(libc)Descriptor Flags.
 
273
 | [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |
139
274
 */
140
 
static int set_cloexec_flag(int fd)
141
 
{
142
 
  int ret = fcntl(fd, F_GETFD, 0);
 
275
__attribute__((warn_unused_result))
 
276
static int set_cloexec_flag(int fd){
 
277
  int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));
143
278
  /* If reading the flags failed, return error indication now. */
144
279
  if(ret < 0){
145
280
    return ret;
146
281
  }
147
282
  /* Store modified flag word in the descriptor. */
148
 
  return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);
 
283
  return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,
 
284
                                       ret | FD_CLOEXEC));
149
285
}
150
 
 
151
 
process *process_list = NULL;
152
 
 
153
 
/* Mark a process as completed when it exits, and save its exit
 
286
#endif  /* not O_CLOEXEC */
 
287
 
 
288
 
 
289
/* Mark processes as completed when they exit, and save their exit
154
290
   status. */
155
 
void handle_sigchld(__attribute__((unused)) int sig){
156
 
  process *proc = process_list;
157
 
  int status;
158
 
  pid_t pid = wait(&status);
159
 
  if(pid == -1){
160
 
    perror("wait");
161
 
    return;
162
 
  }
163
 
  while(proc != NULL and proc->pid != pid){
164
 
    proc = proc->next;
165
 
  }
166
 
  if(proc == NULL){
167
 
    /* Process not found in process list */
168
 
    return;
169
 
  }
170
 
  proc->status = status;
171
 
  proc->completed = true;
 
291
static void handle_sigchld(__attribute__((unused)) int sig){
 
292
  int old_errno = errno;
 
293
  while(true){
 
294
    plugin *proc = plugin_list;
 
295
    int status;
 
296
    pid_t pid = waitpid(-1, &status, WNOHANG);
 
297
    if(pid == 0){
 
298
      /* Only still running child processes */
 
299
      break;
 
300
    }
 
301
    if(pid == -1){
 
302
      if(errno == ECHILD){
 
303
        /* No child processes */
 
304
        break;
 
305
      }
 
306
      error(0, errno, "waitpid");
 
307
    }
 
308
    
 
309
    /* A child exited, find it in process_list */
 
310
    while(proc != NULL and proc->pid != pid){
 
311
      proc = proc->next;
 
312
    }
 
313
    if(proc == NULL){
 
314
      /* Process not found in process list */
 
315
      continue;
 
316
    }
 
317
    proc->status = status;
 
318
    proc->completed = 1;
 
319
  }
 
320
  errno = old_errno;
172
321
}
173
322
 
174
 
bool print_out_password(const char *buffer, size_t length){
 
323
/* Prints out a password to stdout */
 
324
__attribute__((nonnull, warn_unused_result))
 
325
static bool print_out_password(const char *buffer, size_t length){
175
326
  ssize_t ret;
176
 
  if(length>0 and buffer[length-1] == '\n'){
177
 
    length--;
178
 
  }
179
327
  for(size_t written = 0; written < length; written += (size_t)ret){
180
328
    ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,
181
329
                                   length - written));
186
334
  return true;
187
335
}
188
336
 
189
 
char ** addcustomargument(char **argv, int *argc, char *arg){
190
 
 
191
 
  if (argv == NULL){
192
 
    *argc = 1;
193
 
    argv = malloc(sizeof(char*) * 2);
194
 
    if(argv == NULL){
195
 
      return NULL;
 
337
/* Removes and free a plugin from the plugin list */
 
338
__attribute__((nonnull))
 
339
static void free_plugin(plugin *plugin_node){
 
340
  
 
341
  for(char **arg = (plugin_node->argv)+1; *arg != NULL; arg++){
 
342
    free(*arg);
 
343
  }
 
344
  free(plugin_node->name);
 
345
  free(plugin_node->argv);
 
346
  for(char **env = plugin_node->environ; *env != NULL; env++){
 
347
    free(*env);
 
348
  }
 
349
  free(plugin_node->environ);
 
350
  free(plugin_node->buffer);
 
351
  
 
352
  /* Removes the plugin from the singly-linked list */
 
353
  if(plugin_node == plugin_list){
 
354
    /* First one - simple */
 
355
    plugin_list = plugin_list->next;
 
356
  } else {
 
357
    /* Second one or later */
 
358
    for(plugin *p = plugin_list; p != NULL; p = p->next){
 
359
      if(p->next == plugin_node){
 
360
        p->next = plugin_node->next;
 
361
        break;
 
362
      }
196
363
    }
197
 
    argv[0] = NULL;     /* Will be set to argv[0] in main before parsing */
198
 
    argv[1] = NULL;
199
 
  }
200
 
  *argc += 1;
201
 
  argv = realloc(argv, sizeof(char *)
202
 
                  * ((unsigned int) *argc + 1));
203
 
  if(argv == NULL){
204
 
    return NULL;
205
 
  }
206
 
  argv[*argc-1] = arg;
207
 
  argv[*argc] = NULL;   
208
 
  return argv;
 
364
  }
 
365
  
 
366
  free(plugin_node);
 
367
}
 
368
 
 
369
static void free_plugin_list(void){
 
370
  while(plugin_list != NULL){
 
371
    free_plugin(plugin_list);
 
372
  }
209
373
}
210
374
 
211
375
int main(int argc, char *argv[]){
212
 
  const char *plugindir = "/conf/conf.d/mandos/plugins.d";
213
 
  const char *conffile = CONFFILE;
 
376
  char *plugindir = NULL;
 
377
  char *pluginhelperdir = NULL;
 
378
  char *argfile = NULL;
214
379
  FILE *conffp;
215
 
  size_t d_name_len;
216
 
  DIR *dir = NULL;
217
 
  struct dirent *dirst;
 
380
  struct dirent **direntries = NULL;
218
381
  struct stat st;
219
382
  fd_set rfds_all;
220
383
  int ret, maxfd = 0;
 
384
  ssize_t sret;
221
385
  uid_t uid = 65534;
222
386
  gid_t gid = 65534;
223
387
  bool debug = false;
227
391
                                      .sa_flags = SA_NOCLDSTOP };
228
392
  char **custom_argv = NULL;
229
393
  int custom_argc = 0;
 
394
  int dir_fd = -1;
230
395
  
231
396
  /* Establish a signal handler */
232
397
  sigemptyset(&sigchld_action.sa_mask);
233
398
  ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);
234
 
  if(ret < 0){
235
 
    perror("sigaddset");
236
 
    exit(EXIT_FAILURE);
 
399
  if(ret == -1){
 
400
    error(0, errno, "sigaddset");
 
401
    exitstatus = EX_OSERR;
 
402
    goto fallback;
237
403
  }
238
404
  ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);
239
 
  if(ret < 0){
240
 
    perror("sigaction");
241
 
    exit(EXIT_FAILURE);
 
405
  if(ret == -1){
 
406
    error(0, errno, "sigaction");
 
407
    exitstatus = EX_OSERR;
 
408
    goto fallback;
242
409
  }
243
410
  
244
411
  /* The options we understand. */
246
413
    { .name = "global-options", .key = 'g',
247
414
      .arg = "OPTION[,OPTION[,...]]",
248
415
      .doc = "Options passed to all plugins" },
 
416
    { .name = "global-env", .key = 'G',
 
417
      .arg = "VAR=value",
 
418
      .doc = "Environment variable passed to all plugins" },
249
419
    { .name = "options-for", .key = 'o',
250
420
      .arg = "PLUGIN:OPTION[,OPTION[,...]]",
251
421
      .doc = "Options passed only to specified plugin" },
 
422
    { .name = "env-for", .key = 'E',
 
423
      .arg = "PLUGIN:ENV=value",
 
424
      .doc = "Environment variable passed to specified plugin" },
252
425
    { .name = "disable", .key = 'd',
253
426
      .arg = "PLUGIN",
254
427
      .doc = "Disable a specific plugin", .group = 1 },
 
428
    { .name = "enable", .key = 'e',
 
429
      .arg = "PLUGIN",
 
430
      .doc = "Enable a specific plugin", .group = 1 },
255
431
    { .name = "plugin-dir", .key = 128,
256
432
      .arg = "DIRECTORY",
257
433
      .doc = "Specify a different plugin directory", .group = 2 },
258
 
    { .name = "userid", .key = 129,
259
 
      .arg = "ID", .flags = 0,
260
 
      .doc = "User ID the plugins will run as", .group = 2 },
261
 
    { .name = "groupid", .key = 130,
262
 
      .arg = "ID", .flags = 0,
263
 
      .doc = "Group ID the plugins will run as", .group = 2 },
264
 
    { .name = "debug", .key = 131,
265
 
      .doc = "Debug mode", .group = 3 },
 
434
    { .name = "config-file", .key = 129,
 
435
      .arg = "FILE",
 
436
      .doc = "Specify a different configuration file", .group = 2 },
 
437
    { .name = "userid", .key = 130,
 
438
      .arg = "ID", .flags = 0,
 
439
      .doc = "User ID the plugins will run as", .group = 3 },
 
440
    { .name = "groupid", .key = 131,
 
441
      .arg = "ID", .flags = 0,
 
442
      .doc = "Group ID the plugins will run as", .group = 3 },
 
443
    { .name = "debug", .key = 132,
 
444
      .doc = "Debug mode", .group = 4 },
 
445
    { .name = "plugin-helper-dir", .key = 133,
 
446
      .arg = "DIRECTORY",
 
447
      .doc = "Specify a different plugin helper directory",
 
448
      .group = 2 },
 
449
    /*
 
450
     * These reproduce what we would get without ARGP_NO_HELP
 
451
     */
 
452
    { .name = "help", .key = '?',
 
453
      .doc = "Give this help list", .group = -1 },
 
454
    { .name = "usage", .key = -3,
 
455
      .doc = "Give a short usage message", .group = -1 },
 
456
    { .name = "version", .key = 'V',
 
457
      .doc = "Print program version", .group = -1 },
266
458
    { .name = NULL }
267
459
  };
268
460
  
269
 
  error_t parse_opt (int key, char *arg, struct argp_state *state) {
270
 
    /* Get the INPUT argument from `argp_parse', which we know is a
271
 
       pointer to our plugin list pointer. */
272
 
    plugin **plugins = state->input;
273
 
    switch (key) {
274
 
    case 'g':
275
 
      if (arg != NULL){
276
 
        char *p;
277
 
        while((p = strsep(&arg, ",")) != NULL){
278
 
          if(p[0] == '\0'){
279
 
            continue;
280
 
          }
281
 
          addargument(getplugin(NULL, plugins), p);
282
 
        }
283
 
      }
284
 
      break;
285
 
    case 'o':
286
 
      if (arg != NULL){
287
 
        char *name = strsep(&arg, ":");
288
 
        if(name[0] == '\0'){
289
 
          break;
290
 
        }
291
 
        char *opt = strsep(&arg, ":");
292
 
        if(opt[0] == '\0'){
293
 
          break;
294
 
        }
295
 
        if(opt != NULL){
296
 
          char *p;
297
 
          while((p = strsep(&opt, ",")) != NULL){
298
 
            if(p[0] == '\0'){
299
 
              continue;
300
 
            }
301
 
            addargument(getplugin(name, plugins), p);
302
 
          }
303
 
        }
304
 
      }
305
 
      break;
306
 
    case 'd':
307
 
      if (arg != NULL){
308
 
        getplugin(arg, plugins)->disabled = true;
309
 
      }
310
 
      break;
311
 
    case 128:
312
 
      plugindir = arg;
313
 
      break;
314
 
    case 129:
315
 
      uid = (uid_t)strtol(arg, NULL, 10);
316
 
      break;
317
 
    case 130:
318
 
      gid = (gid_t)strtol(arg, NULL, 10);
319
 
      break;
320
 
    case 131:
 
461
  __attribute__((nonnull(3)))
 
462
  error_t parse_opt(int key, char *arg, struct argp_state *state){
 
463
    errno = 0;
 
464
    switch(key){
 
465
      char *tmp;
 
466
      intmax_t tmp_id;
 
467
    case 'g':                   /* --global-options */
 
468
      {
 
469
        char *plugin_option;
 
470
        while((plugin_option = strsep(&arg, ",")) != NULL){
 
471
          if(not add_argument(getplugin(NULL), plugin_option)){
 
472
            break;
 
473
          }
 
474
        }
 
475
        errno = 0;
 
476
      }
 
477
      break;
 
478
    case 'G':                   /* --global-env */
 
479
      if(add_environment(getplugin(NULL), arg, true)){
 
480
        errno = 0;
 
481
      }
 
482
      break;
 
483
    case 'o':                   /* --options-for */
 
484
      {
 
485
        char *option_list = strchr(arg, ':');
 
486
        if(option_list == NULL){
 
487
          argp_error(state, "No colon in \"%s\"", arg);
 
488
          errno = EINVAL;
 
489
          break;
 
490
        }
 
491
        *option_list = '\0';
 
492
        option_list++;
 
493
        if(arg[0] == '\0'){
 
494
          argp_error(state, "Empty plugin name");
 
495
          errno = EINVAL;
 
496
          break;
 
497
        }
 
498
        char *option;
 
499
        while((option = strsep(&option_list, ",")) != NULL){
 
500
          if(not add_argument(getplugin(arg), option)){
 
501
            break;
 
502
          }
 
503
        }
 
504
        errno = 0;
 
505
      }
 
506
      break;
 
507
    case 'E':                   /* --env-for */
 
508
      {
 
509
        char *envdef = strchr(arg, ':');
 
510
        if(envdef == NULL){
 
511
          argp_error(state, "No colon in \"%s\"", arg);
 
512
          errno = EINVAL;
 
513
          break;
 
514
        }
 
515
        *envdef = '\0';
 
516
        envdef++;
 
517
        if(arg[0] == '\0'){
 
518
          argp_error(state, "Empty plugin name");
 
519
          errno = EINVAL;
 
520
          break;
 
521
        }
 
522
        if(add_environment(getplugin(arg), envdef, true)){
 
523
          errno = 0;
 
524
        }
 
525
      }
 
526
      break;
 
527
    case 'd':                   /* --disable */
 
528
      {
 
529
        plugin *p = getplugin(arg);
 
530
        if(p != NULL){
 
531
          p->disabled = true;
 
532
          errno = 0;
 
533
        }
 
534
      }
 
535
      break;
 
536
    case 'e':                   /* --enable */
 
537
      {
 
538
        plugin *p = getplugin(arg);
 
539
        if(p != NULL){
 
540
          p->disabled = false;
 
541
          errno = 0;
 
542
        }
 
543
      }
 
544
      break;
 
545
    case 128:                   /* --plugin-dir */
 
546
      free(plugindir);
 
547
      plugindir = strdup(arg);
 
548
      if(plugindir != NULL){
 
549
        errno = 0;
 
550
      }
 
551
      break;
 
552
    case 129:                   /* --config-file */
 
553
      /* This is already done by parse_opt_config_file() */
 
554
      break;
 
555
    case 130:                   /* --userid */
 
556
      tmp_id = strtoimax(arg, &tmp, 10);
 
557
      if(errno != 0 or tmp == arg or *tmp != '\0'
 
558
         or tmp_id != (uid_t)tmp_id){
 
559
        argp_error(state, "Bad user ID number: \"%s\", using %"
 
560
                   PRIdMAX, arg, (intmax_t)uid);
 
561
        break;
 
562
      }
 
563
      uid = (uid_t)tmp_id;
 
564
      errno = 0;
 
565
      break;
 
566
    case 131:                   /* --groupid */
 
567
      tmp_id = strtoimax(arg, &tmp, 10);
 
568
      if(errno != 0 or tmp == arg or *tmp != '\0'
 
569
         or tmp_id != (gid_t)tmp_id){
 
570
        argp_error(state, "Bad group ID number: \"%s\", using %"
 
571
                   PRIdMAX, arg, (intmax_t)gid);
 
572
        break;
 
573
      }
 
574
      gid = (gid_t)tmp_id;
 
575
      errno = 0;
 
576
      break;
 
577
    case 132:                   /* --debug */
321
578
      debug = true;
322
579
      break;
323
 
    case ARGP_KEY_ARG:
324
 
      fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg); 
325
 
      break;
326
 
    case ARGP_KEY_END:
327
 
      break;
328
 
    default:
329
 
      return ARGP_ERR_UNKNOWN;
330
 
    }
331
 
    return 0;
332
 
  }
333
 
  
334
 
  plugin *plugin_list = NULL;
335
 
  
336
 
  struct argp argp = { .options = options, .parser = parse_opt,
337
 
                       .args_doc = "[+PLUS_SEPARATED_OPTIONS]",
 
580
    case 133:                   /* --plugin-helper-dir */
 
581
      free(pluginhelperdir);
 
582
      pluginhelperdir = strdup(arg);
 
583
      if(pluginhelperdir != NULL){
 
584
        errno = 0;
 
585
      }
 
586
      break;
 
587
      /*
 
588
       * These reproduce what we would get without ARGP_NO_HELP
 
589
       */
 
590
    case '?':                   /* --help */
 
591
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
 
592
      argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);
 
593
      __builtin_unreachable();
 
594
    case -3:                    /* --usage */
 
595
      state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */
 
596
      argp_state_help(state, state->out_stream,
 
597
                      ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);
 
598
      __builtin_unreachable();
 
599
    case 'V':                   /* --version */
 
600
      fprintf(state->out_stream, "%s\n", argp_program_version);
 
601
      exit(EXIT_SUCCESS);
 
602
      break;
 
603
/*
 
604
 * When adding more options before this line, remember to also add a
 
605
 * "case" to the "parse_opt_config_file" function below.
 
606
 */
 
607
    case ARGP_KEY_ARG:
 
608
      /* Cryptsetup always passes an argument, which is an empty
 
609
         string if "none" was specified in /etc/crypttab.  So if
 
610
         argument was empty, we ignore it silently. */
 
611
      if(arg[0] == '\0'){
 
612
        break;
 
613
      }
 
614
#if __GNUC__ >= 7
 
615
      __attribute__((fallthrough));
 
616
#else
 
617
          /* FALLTHROUGH */
 
618
#endif
 
619
    default:
 
620
      return ARGP_ERR_UNKNOWN;
 
621
    }
 
622
    return errno;               /* Set to 0 at start */
 
623
  }
 
624
  
 
625
  /* This option parser is the same as parse_opt() above, except it
 
626
     ignores everything but the --config-file option. */
 
627
  error_t parse_opt_config_file(int key, char *arg,
 
628
                                __attribute__((unused))
 
629
                                struct argp_state *state){
 
630
    errno = 0;
 
631
    switch(key){
 
632
    case 'g':                   /* --global-options */
 
633
    case 'G':                   /* --global-env */
 
634
    case 'o':                   /* --options-for */
 
635
    case 'E':                   /* --env-for */
 
636
    case 'd':                   /* --disable */
 
637
    case 'e':                   /* --enable */
 
638
    case 128:                   /* --plugin-dir */
 
639
      break;
 
640
    case 129:                   /* --config-file */
 
641
      free(argfile);
 
642
      argfile = strdup(arg);
 
643
      if(argfile != NULL){
 
644
        errno = 0;
 
645
      }
 
646
      break;
 
647
    case 130:                   /* --userid */
 
648
    case 131:                   /* --groupid */
 
649
    case 132:                   /* --debug */
 
650
    case 133:                   /* --plugin-helper-dir */
 
651
    case '?':                   /* --help */
 
652
    case -3:                    /* --usage */
 
653
    case 'V':                   /* --version */
 
654
    case ARGP_KEY_ARG:
 
655
      break;
 
656
    default:
 
657
      return ARGP_ERR_UNKNOWN;
 
658
    }
 
659
    return errno;
 
660
  }
 
661
  
 
662
  struct argp argp = { .options = options,
 
663
                       .parser = parse_opt_config_file,
 
664
                       .args_doc = "",
338
665
                       .doc = "Mandos plugin runner -- Run plugins" };
339
666
  
340
 
  ret = argp_parse (&argp, argc, argv, 0, 0, &plugin_list);
341
 
  if (ret == ARGP_ERR_UNKNOWN){
342
 
    fprintf(stderr, "Unknown error while parsing arguments\n");
343
 
    exitstatus = EXIT_FAILURE;
344
 
    goto end;
345
 
  }
346
 
 
347
 
  conffp = fopen(conffile, "r");
 
667
  /* Parse using parse_opt_config_file() in order to get the custom
 
668
     config file location, if any. */
 
669
  ret = argp_parse(&argp, argc, argv,
 
670
                   ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
671
                   NULL, NULL);
 
672
  switch(ret){
 
673
  case 0:
 
674
    break;
 
675
  case ENOMEM:
 
676
  default:
 
677
    errno = ret;
 
678
    error(0, errno, "argp_parse");
 
679
    exitstatus = EX_OSERR;
 
680
    goto fallback;
 
681
  case EINVAL:
 
682
    exitstatus = EX_USAGE;
 
683
    goto fallback;
 
684
  }
 
685
  
 
686
  /* Reset to the normal argument parser */
 
687
  argp.parser = parse_opt;
 
688
  
 
689
  /* Open the configfile if available */
 
690
  if(argfile == NULL){
 
691
    conffp = fopen(AFILE, "r");
 
692
  } else {
 
693
    conffp = fopen(argfile, "r");
 
694
  }
348
695
  if(conffp != NULL){
349
696
    char *org_line = NULL;
 
697
    char *p, *arg, *new_arg, *line;
350
698
    size_t size = 0;
351
 
    ssize_t sret;
352
 
    char *p, *arg, *new_arg, *line;
353
699
    const char whitespace_delims[] = " \r\t\f\v\n";
354
700
    const char comment_delim[] = "#";
355
 
 
 
701
    
 
702
    custom_argc = 1;
 
703
    custom_argv = malloc(sizeof(char*) * 2);
 
704
    if(custom_argv == NULL){
 
705
      error(0, errno, "malloc");
 
706
      exitstatus = EX_OSERR;
 
707
      goto fallback;
 
708
    }
 
709
    custom_argv[0] = argv[0];
 
710
    custom_argv[1] = NULL;
 
711
    
 
712
    /* for each line in the config file, strip whitespace and ignore
 
713
       commented text */
356
714
    while(true){
357
715
      sret = getline(&org_line, &size, conffp);
358
716
      if(sret == -1){
359
717
        break;
360
718
      }
361
 
 
 
719
      
362
720
      line = org_line;
363
721
      arg = strsep(&line, comment_delim);
364
722
      while((p = strsep(&arg, whitespace_delims)) != NULL){
366
724
          continue;
367
725
        }
368
726
        new_arg = strdup(p);
369
 
        custom_argv = addcustomargument(custom_argv, &custom_argc, new_arg);
370
 
        if (custom_argv == NULL){
371
 
          perror("addcustomargument");
372
 
          exitstatus = EXIT_FAILURE;
373
 
          goto end;
374
 
        }
 
727
        if(new_arg == NULL){
 
728
          error(0, errno, "strdup");
 
729
          exitstatus = EX_OSERR;
 
730
          free(org_line);
 
731
          goto fallback;
 
732
        }
 
733
        
 
734
        custom_argc += 1;
 
735
        {
 
736
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)
 
737
          char **new_argv = reallocarray(custom_argv,
 
738
                                         (size_t)custom_argc + 1,
 
739
                                         sizeof(char *));
 
740
#else
 
741
          char **new_argv = NULL;
 
742
          if(((size_t)custom_argc + 1) > (SIZE_MAX / sizeof(char *))){
 
743
            /* overflow */
 
744
            errno = ENOMEM;
 
745
          } else {
 
746
            new_argv = realloc(custom_argv, ((size_t)custom_argc + 1)
 
747
                               * sizeof(char *));
 
748
          }
 
749
#endif
 
750
          if(new_argv == NULL){
 
751
            error(0, errno, "reallocarray");
 
752
            exitstatus = EX_OSERR;
 
753
            free(new_arg);
 
754
            free(org_line);
 
755
            goto fallback;
 
756
          } else {
 
757
            custom_argv = new_argv;
 
758
          }
 
759
        }
 
760
        custom_argv[custom_argc-1] = new_arg;
 
761
        custom_argv[custom_argc] = NULL;
375
762
      }
376
763
    }
 
764
    do {
 
765
      ret = fclose(conffp);
 
766
    } while(ret == EOF and errno == EINTR);
 
767
    if(ret == EOF){
 
768
      error(0, errno, "fclose");
 
769
      exitstatus = EX_IOERR;
 
770
      goto fallback;
 
771
    }
377
772
    free(org_line);
378
 
  } else{
379
 
    /* check for harmfull errors */
380
 
    if (errno == EMFILE or errno == ENFILE or errno == ENOMEM){
381
 
      perror("fopen");
382
 
      exitstatus = EXIT_FAILURE;
383
 
      goto end;
 
773
  } else {
 
774
    /* Check for harmful errors and go to fallback. Other errors might
 
775
       not affect opening plugins */
 
776
    if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){
 
777
      error(0, errno, "fopen");
 
778
      exitstatus = EX_OSERR;
 
779
      goto fallback;
384
780
    }
385
781
  }
386
 
 
 
782
  /* If there were any arguments from the configuration file, pass
 
783
     them to parser as command line arguments */
387
784
  if(custom_argv != NULL){
388
 
    custom_argv[0] = argv[0];
389
 
    ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, &plugin_list);
390
 
    if (ret == ARGP_ERR_UNKNOWN){
391
 
      fprintf(stderr, "Unknown error while parsing arguments\n");
392
 
      exitstatus = EXIT_FAILURE;
393
 
      goto end;
 
785
    ret = argp_parse(&argp, custom_argc, custom_argv,
 
786
                     ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
787
                     NULL, NULL);
 
788
    switch(ret){
 
789
    case 0:
 
790
      break;
 
791
    case ENOMEM:
 
792
    default:
 
793
      errno = ret;
 
794
      error(0, errno, "argp_parse");
 
795
      exitstatus = EX_OSERR;
 
796
      goto fallback;
 
797
    case EINVAL:
 
798
      exitstatus = EX_CONFIG;
 
799
      goto fallback;
 
800
    }
 
801
  }
 
802
  
 
803
  /* Parse actual command line arguments, to let them override the
 
804
     config file */
 
805
  ret = argp_parse(&argp, argc, argv,
 
806
                   ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,
 
807
                   NULL, NULL);
 
808
  switch(ret){
 
809
  case 0:
 
810
    break;
 
811
  case ENOMEM:
 
812
  default:
 
813
    errno = ret;
 
814
    error(0, errno, "argp_parse");
 
815
    exitstatus = EX_OSERR;
 
816
    goto fallback;
 
817
  case EINVAL:
 
818
    exitstatus = EX_USAGE;
 
819
    goto fallback;
 
820
  }
 
821
  
 
822
  {
 
823
    char *pluginhelperenv;
 
824
    bool bret = true;
 
825
    ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",
 
826
                   pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
827
    if(ret != -1){
 
828
      bret = add_environment(getplugin(NULL), pluginhelperenv, true);
 
829
    }
 
830
    if(ret == -1 or not bret){
 
831
      error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"
 
832
            " environment variable to \"%s\" for all plugins\n",
 
833
            pluginhelperdir != NULL ? pluginhelperdir : PHDIR);
 
834
    }
 
835
    if(ret != -1){
 
836
      free(pluginhelperenv);
394
837
    }
395
838
  }
396
839
  
397
840
  if(debug){
398
 
    for(plugin *p = plugin_list; p != NULL; p=p->next){
 
841
    for(plugin *p = plugin_list; p != NULL; p = p->next){
399
842
      fprintf(stderr, "Plugin: %s has %d arguments\n",
400
843
              p->name ? p->name : "Global", p->argc - 1);
401
844
      for(char **a = p->argv; *a != NULL; a++){
402
845
        fprintf(stderr, "\tArg: %s\n", *a);
403
846
      }
404
 
    }
405
 
  }
406
 
  
 
847
      fprintf(stderr, "...and %d environment variables\n", p->envc);
 
848
      for(char **a = p->environ; *a != NULL; a++){
 
849
        fprintf(stderr, "\t%s\n", *a);
 
850
      }
 
851
    }
 
852
  }
 
853
  
 
854
  if(getuid() == 0){
 
855
    /* Work around Debian bug #633582:
 
856
       <https://bugs.debian.org/633582> */
 
857
    int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);
 
858
    if(plugindir_fd == -1){
 
859
      if(errno != ENOENT){
 
860
        error(0, errno, "open(\"" PDIR "\")");
 
861
      }
 
862
    } else {
 
863
      ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));
 
864
      if(ret == -1){
 
865
        error(0, errno, "fstat");
 
866
      } else {
 
867
        if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
 
868
          ret = fchown(plugindir_fd, uid, gid);
 
869
          if(ret == -1){
 
870
            error(0, errno, "fchown");
 
871
          }
 
872
        }
 
873
      }
 
874
      close(plugindir_fd);
 
875
    }
 
876
 
 
877
    /* Work around Debian bug #981302
 
878
       <https://bugs.debian.org/981302> */
 
879
    if(lstat("/dev/fd", &st) != 0 and errno == ENOENT){
 
880
      ret = symlink("/proc/self/fd", "/dev/fd");
 
881
      if(ret == -1){
 
882
        error(0, errno, "Failed to create /dev/fd symlink");
 
883
      }
 
884
    }
 
885
  }
 
886
  
 
887
  /* Lower permissions */
 
888
  ret = setgid(gid);
 
889
  if(ret == -1){
 
890
    error(0, errno, "setgid");
 
891
  }
407
892
  ret = setuid(uid);
408
 
  if (ret == -1){
409
 
    perror("setuid");
410
 
  }
411
 
  
412
 
  setgid(gid);
413
 
  if (ret == -1){
414
 
    perror("setgid");
415
 
  }
416
 
  
417
 
  dir = opendir(plugindir);
418
 
  if(dir == NULL){
419
 
    perror("Could not open plugin dir");
420
 
    exitstatus = EXIT_FAILURE;
421
 
    goto end;
422
 
  }
423
 
  
424
 
  /* Set the FD_CLOEXEC flag on the directory, if possible */
 
893
  if(ret == -1){
 
894
    error(0, errno, "setuid");
 
895
  }
 
896
  
 
897
  /* Open plugin directory with close_on_exec flag */
425
898
  {
426
 
    int dir_fd = dirfd(dir);
427
 
    if(dir_fd >= 0){
428
 
      ret = set_cloexec_flag(dir_fd);
429
 
      if(ret < 0){
430
 
        perror("set_cloexec_flag");
431
 
        exitstatus = EXIT_FAILURE;
432
 
        goto end;
 
899
    dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |
 
900
#ifdef O_CLOEXEC
 
901
                  O_CLOEXEC
 
902
#else  /* not O_CLOEXEC */
 
903
                  0
 
904
#endif  /* not O_CLOEXEC */
 
905
                  );
 
906
    if(dir_fd == -1){
 
907
      error(0, errno, "Could not open plugin dir");
 
908
      exitstatus = EX_UNAVAILABLE;
 
909
      goto fallback;
 
910
    }
 
911
    
 
912
#ifndef O_CLOEXEC
 
913
  /* Set the FD_CLOEXEC flag on the directory */
 
914
    ret = set_cloexec_flag(dir_fd);
 
915
    if(ret < 0){
 
916
      error(0, errno, "set_cloexec_flag");
 
917
      exitstatus = EX_OSERR;
 
918
      goto fallback;
 
919
    }
 
920
#endif  /* O_CLOEXEC */
 
921
  }
 
922
  
 
923
  int good_name(const struct dirent * const dirent){
 
924
    const char * const patterns[] = { ".*", "#*#", "*~", "*.dpkg-new",
 
925
                                      "*.dpkg-old", "*.dpkg-bak",
 
926
                                      "*.dpkg-divert", NULL };
 
927
#ifdef __GNUC__
 
928
#pragma GCC diagnostic push
 
929
#pragma GCC diagnostic ignored "-Wcast-qual"
 
930
#endif
 
931
    for(const char **pat = (const char **)patterns;
 
932
        *pat != NULL; pat++){
 
933
#ifdef __GNUC__
 
934
#pragma GCC diagnostic pop
 
935
#endif
 
936
      if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)
 
937
         != FNM_NOMATCH){
 
938
        if(debug){
 
939
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
 
940
                    " matching pattern %s\n", dirent->d_name, *pat);
 
941
        }
 
942
        return 0;
433
943
      }
434
944
    }
 
945
    return 1;
 
946
  }
 
947
  
 
948
  int numplugins = scandirat(dir_fd, ".", &direntries, good_name,
 
949
                             alphasort);
 
950
  if(numplugins == -1){
 
951
    error(0, errno, "Could not scan plugin dir");
 
952
    direntries = NULL;
 
953
    exitstatus = EX_OSERR;
 
954
    goto fallback;
435
955
  }
436
956
  
437
957
  FD_ZERO(&rfds_all);
438
958
  
439
 
  while(true){
440
 
    dirst = readdir(dir);
441
 
    
442
 
    // All directory entries have been processed
443
 
    if(dirst == NULL){
444
 
      if (errno == EBADF){
445
 
        perror("readdir");
446
 
        exitstatus = EXIT_FAILURE;
447
 
        goto end;
448
 
      }
449
 
      break;
450
 
    }
451
 
    
452
 
    d_name_len = strlen(dirst->d_name);
453
 
    
454
 
    // Ignore dotfiles, backup files and other junk
455
 
    {
456
 
      bool bad_name = false;
457
 
      
458
 
      const char const *bad_prefixes[] = { ".", "#", NULL };
459
 
      
460
 
      const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",
461
 
                                           ".dpkg-old",
462
 
                                           ".dpkg-divert", NULL };
463
 
      for(const char **pre = bad_prefixes; *pre != NULL; pre++){
464
 
        size_t pre_len = strlen(*pre);
465
 
        if((d_name_len >= pre_len)
466
 
           and strncmp((dirst->d_name), *pre, pre_len) == 0){
467
 
          if(debug){
468
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
469
 
                    " with bad prefix %s\n", dirst->d_name, *pre);
470
 
          }
471
 
          bad_name = true;
472
 
          break;
473
 
        }
474
 
      }
475
 
      
476
 
      if(bad_name){
477
 
        continue;
478
 
      }
479
 
      
480
 
      for(const char **suf = bad_suffixes; *suf != NULL; suf++){
481
 
        size_t suf_len = strlen(*suf);
482
 
        if((d_name_len >= suf_len)
483
 
           and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)
484
 
                == 0)){
485
 
          if(debug){
486
 
            fprintf(stderr, "Ignoring plugin dir entry \"%s\""
487
 
                    " with bad suffix %s\n", dirst->d_name, *suf);
488
 
          }
489
 
          bad_name = true;
490
 
          break;
491
 
        }
492
 
      }
493
 
      
494
 
      if(bad_name){
495
 
        continue;
496
 
      }
497
 
    }
498
 
    
499
 
    char *filename = malloc(d_name_len + strlen(plugindir) + 2);
500
 
    if (filename == NULL){
501
 
      perror("malloc");
502
 
      continue;
503
 
    }
504
 
    strcpy(filename, plugindir); /* Spurious warning */
505
 
    strcat(filename, "/");      /* Spurious warning */
506
 
    strcat(filename, dirst->d_name); /* Spurious warning */
507
 
    
508
 
    ret = stat(filename, &st);
509
 
    if (ret == -1){
510
 
      perror("stat");
511
 
      free(filename);
512
 
      continue;
513
 
    }
514
 
    
515
 
    if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){
 
959
  /* Read and execute any executable in the plugin directory*/
 
960
  for(int i = 0; i < numplugins; i++){
 
961
    
 
962
    int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);
 
963
    if(plugin_fd == -1){
 
964
      error(0, errno, "Could not open plugin");
 
965
      free(direntries[i]);
 
966
      continue;
 
967
    }
 
968
    ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));
 
969
    if(ret == -1){
 
970
      error(0, errno, "stat");
 
971
      close(plugin_fd);
 
972
      free(direntries[i]);
 
973
      continue;
 
974
    }
 
975
    
 
976
    /* Ignore non-executable files */
 
977
    if(not S_ISREG(st.st_mode)
 
978
       or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,
 
979
                                        X_OK, 0)) != 0)){
516
980
      if(debug){
517
 
        fprintf(stderr, "Ignoring plugin dir entry \"%s\""
518
 
                " with bad type or mode\n", filename);
 
981
        fprintf(stderr, "Ignoring plugin dir entry \"%s/%s\""
 
982
                " with bad type or mode\n",
 
983
                plugindir != NULL ? plugindir : PDIR,
 
984
                direntries[i]->d_name);
519
985
      }
520
 
      free(filename);
521
 
      continue;
522
 
    }
523
 
    if(getplugin(dirst->d_name, &plugin_list)->disabled){
 
986
      close(plugin_fd);
 
987
      free(direntries[i]);
 
988
      continue;
 
989
    }
 
990
    
 
991
    plugin *p = getplugin(direntries[i]->d_name);
 
992
    if(p == NULL){
 
993
      error(0, errno, "getplugin");
 
994
      close(plugin_fd);
 
995
      free(direntries[i]);
 
996
      continue;
 
997
    }
 
998
    if(p->disabled){
524
999
      if(debug){
525
1000
        fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",
526
 
                dirst->d_name);
 
1001
                direntries[i]->d_name);
527
1002
      }
528
 
      free(filename);
 
1003
      close(plugin_fd);
 
1004
      free(direntries[i]);
529
1005
      continue;
530
1006
    }
531
 
    plugin *p = getplugin(dirst->d_name, &plugin_list);
532
1007
    {
533
1008
      /* Add global arguments to argument list for this plugin */
534
 
      plugin *g = getplugin(NULL, &plugin_list);
535
 
      for(char **a = g->argv + 1; *a != NULL; a++){
536
 
        addargument(p, *a);
537
 
      }
538
 
    }
539
 
    int pipefd[2]; 
540
 
    ret = pipe(pipefd);
541
 
    if (ret == -1){
542
 
      perror("pipe");
543
 
      exitstatus = EXIT_FAILURE;
544
 
      goto end;
545
 
    }
 
1009
      plugin *g = getplugin(NULL);
 
1010
      if(g != NULL){
 
1011
        for(char **a = g->argv + 1; *a != NULL; a++){
 
1012
          if(not add_argument(p, *a)){
 
1013
            error(0, errno, "add_argument");
 
1014
          }
 
1015
        }
 
1016
        /* Add global environment variables */
 
1017
        for(char **e = g->environ; *e != NULL; e++){
 
1018
          if(not add_environment(p, *e, false)){
 
1019
            error(0, errno, "add_environment");
 
1020
          }
 
1021
        }
 
1022
      }
 
1023
    }
 
1024
    /* If this plugin has any environment variables, we need to
 
1025
       duplicate the environment from this process, too. */
 
1026
    if(p->environ[0] != NULL){
 
1027
      for(char **e = environ; *e != NULL; e++){
 
1028
        if(not add_environment(p, *e, false)){
 
1029
          error(0, errno, "add_environment");
 
1030
        }
 
1031
      }
 
1032
    }
 
1033
    
 
1034
    int pipefd[2];
 
1035
#ifndef O_CLOEXEC
 
1036
    ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));
 
1037
#else  /* O_CLOEXEC */
 
1038
    ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));
 
1039
#endif  /* O_CLOEXEC */
 
1040
    if(ret == -1){
 
1041
      error(0, errno, "pipe");
 
1042
      exitstatus = EX_OSERR;
 
1043
      free(direntries[i]);
 
1044
      goto fallback;
 
1045
    }
 
1046
    if(pipefd[0] >= FD_SETSIZE){
 
1047
      fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],
 
1048
              FD_SETSIZE);
 
1049
      close(pipefd[0]);
 
1050
      close(pipefd[1]);
 
1051
      exitstatus = EX_OSERR;
 
1052
      free(direntries[i]);
 
1053
      goto fallback;
 
1054
    }
 
1055
#ifndef O_CLOEXEC
 
1056
    /* Ask OS to automatic close the pipe on exec */
546
1057
    ret = set_cloexec_flag(pipefd[0]);
547
1058
    if(ret < 0){
548
 
      perror("set_cloexec_flag");
549
 
      exitstatus = EXIT_FAILURE;
550
 
      goto end;
 
1059
      error(0, errno, "set_cloexec_flag");
 
1060
      close(pipefd[0]);
 
1061
      close(pipefd[1]);
 
1062
      exitstatus = EX_OSERR;
 
1063
      free(direntries[i]);
 
1064
      goto fallback;
551
1065
    }
552
1066
    ret = set_cloexec_flag(pipefd[1]);
553
1067
    if(ret < 0){
554
 
      perror("set_cloexec_flag");
555
 
      exitstatus = EXIT_FAILURE;
556
 
      goto end;
 
1068
      error(0, errno, "set_cloexec_flag");
 
1069
      close(pipefd[0]);
 
1070
      close(pipefd[1]);
 
1071
      exitstatus = EX_OSERR;
 
1072
      free(direntries[i]);
 
1073
      goto fallback;
557
1074
    }
 
1075
#endif  /* not O_CLOEXEC */
558
1076
    /* Block SIGCHLD until process is safely in process list */
559
 
    ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
 
1077
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,
 
1078
                                              &sigchld_action.sa_mask,
 
1079
                                              NULL));
560
1080
    if(ret < 0){
561
 
      perror("sigprocmask");
562
 
      exitstatus = EXIT_FAILURE;
563
 
      goto end;
 
1081
      error(0, errno, "sigprocmask");
 
1082
      exitstatus = EX_OSERR;
 
1083
      free(direntries[i]);
 
1084
      goto fallback;
564
1085
    }
565
 
    // Starting a new process to be watched
566
 
    pid_t pid = fork();
 
1086
    /* Starting a new process to be watched */
 
1087
    pid_t pid;
 
1088
    do {
 
1089
      pid = fork();
 
1090
    } while(pid == -1 and errno == EINTR);
567
1091
    if(pid == -1){
568
 
      perror("fork");
569
 
      exitstatus = EXIT_FAILURE;
570
 
      goto end;
 
1092
      error(0, errno, "fork");
 
1093
      TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1094
                                     &sigchld_action.sa_mask, NULL));
 
1095
      close(pipefd[0]);
 
1096
      close(pipefd[1]);
 
1097
      exitstatus = EX_OSERR;
 
1098
      free(direntries[i]);
 
1099
      goto fallback;
571
1100
    }
572
1101
    if(pid == 0){
573
1102
      /* this is the child process */
574
1103
      ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
575
1104
      if(ret < 0){
576
 
        perror("sigaction");
577
 
        _exit(EXIT_FAILURE);
 
1105
        error(0, errno, "sigaction");
 
1106
        _exit(EX_OSERR);
578
1107
      }
579
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
1108
      ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
580
1109
      if(ret < 0){
581
 
        perror("sigprocmask");
582
 
        _exit(EXIT_FAILURE);
 
1110
        error(0, errno, "sigprocmask");
 
1111
        _exit(EX_OSERR);
583
1112
      }
584
 
 
 
1113
      
585
1114
      ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */
586
1115
      if(ret == -1){
587
 
        perror("dup2");
588
 
        _exit(EXIT_FAILURE);
 
1116
        error(0, errno, "dup2");
 
1117
        _exit(EX_OSERR);
589
1118
      }
590
1119
      
591
 
      if(dirfd(dir) < 0){
592
 
        /* If dir has no file descriptor, we could not set FD_CLOEXEC
593
 
           above and must now close it manually here. */
594
 
        closedir(dir);
595
 
      }
596
 
      if(execv(filename, p->argv) < 0){
597
 
        perror("execv");
598
 
        _exit(EXIT_FAILURE);
 
1120
      if(fexecve(plugin_fd, p->argv,
 
1121
                (p->environ[0] != NULL) ? p->environ : environ) < 0){
 
1122
        error(0, errno, "fexecve for %s/%s",
 
1123
              plugindir != NULL ? plugindir : PDIR,
 
1124
              direntries[i]->d_name);
 
1125
        _exit(EX_OSERR);
599
1126
      }
600
1127
      /* no return */
601
1128
    }
602
 
    /* parent process */
603
 
    free(filename);
604
 
    close(pipefd[1]);           /* close unused write end of pipe */
605
 
    process *new_process = malloc(sizeof(process));
606
 
    if (new_process == NULL){
607
 
      perror("malloc");
608
 
      ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
1129
    /* Parent process */
 
1130
    close(pipefd[1]);           /* Close unused write end of pipe */
 
1131
    close(plugin_fd);
 
1132
    plugin *new_plugin = getplugin(direntries[i]->d_name);
 
1133
    if(new_plugin == NULL){
 
1134
      error(0, errno, "getplugin");
 
1135
      ret = (int)(TEMP_FAILURE_RETRY
 
1136
                  (sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,
 
1137
                               NULL)));
609
1138
      if(ret < 0){
610
 
        perror("sigprocmask");
 
1139
        error(0, errno, "sigprocmask");
611
1140
      }
612
 
      exitstatus = EXIT_FAILURE;
613
 
      goto end;
 
1141
      exitstatus = EX_OSERR;
 
1142
      free(direntries[i]);
 
1143
      goto fallback;
614
1144
    }
 
1145
    free(direntries[i]);
615
1146
    
616
 
    *new_process = (struct process){ .pid = pid,
617
 
                                     .fd = pipefd[0],
618
 
                                     .next = process_list };
619
 
    // List handling
620
 
    process_list = new_process;
 
1147
    new_plugin->pid = pid;
 
1148
    new_plugin->fd = pipefd[0];
 
1149
 
 
1150
    if(debug){
 
1151
      fprintf(stderr, "Plugin %s started (PID %" PRIdMAX ")\n",
 
1152
              new_plugin->name, (intmax_t) (new_plugin->pid));
 
1153
    }
 
1154
 
621
1155
    /* Unblock SIGCHLD so signal handler can be run if this process
622
1156
       has already completed */
623
 
    ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);
 
1157
    ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,
 
1158
                                              &sigchld_action.sa_mask,
 
1159
                                              NULL));
624
1160
    if(ret < 0){
625
 
      perror("sigprocmask");
626
 
      exitstatus = EXIT_FAILURE;
627
 
      goto end;
628
 
    }
629
 
    
630
 
    FD_SET(new_process->fd, &rfds_all);
631
 
    
632
 
    if (maxfd < new_process->fd){
633
 
      maxfd = new_process->fd;
634
 
    }
635
 
    
636
 
  }
637
 
  
638
 
  /* Free the plugin list */
639
 
  for(plugin *next; plugin_list != NULL; plugin_list = next){
640
 
    next = plugin_list->next;
641
 
    free(plugin_list->argv);
642
 
    free(plugin_list);
643
 
  }
644
 
  
645
 
  closedir(dir);
646
 
  dir = NULL;
647
 
    
648
 
  if (process_list == NULL){
649
 
    fprintf(stderr, "No plugin processes started. Incorrect plugin"
650
 
            " directory?\n");
651
 
    process_list = NULL;
652
 
  }
653
 
  while(process_list){
 
1161
      error(0, errno, "sigprocmask");
 
1162
      exitstatus = EX_OSERR;
 
1163
      goto fallback;
 
1164
    }
 
1165
    
 
1166
    FD_SET(new_plugin->fd, &rfds_all);
 
1167
    
 
1168
    if(maxfd < new_plugin->fd){
 
1169
      maxfd = new_plugin->fd;
 
1170
    }
 
1171
  }
 
1172
  
 
1173
  free(direntries);
 
1174
  direntries = NULL;
 
1175
  close(dir_fd);
 
1176
  dir_fd = -1;
 
1177
  free_plugin(getplugin(NULL));
 
1178
  
 
1179
  for(plugin *p = plugin_list; p != NULL; p = p->next){
 
1180
    if(p->pid != 0){
 
1181
      break;
 
1182
    }
 
1183
    if(p->next == NULL){
 
1184
      fprintf(stderr, "No plugin processes started. Incorrect plugin"
 
1185
              " directory?\n");
 
1186
      free_plugin_list();
 
1187
    }
 
1188
  }
 
1189
  
 
1190
  /* Main loop while running plugins exist */
 
1191
  while(plugin_list){
654
1192
    fd_set rfds = rfds_all;
655
1193
    int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);
656
 
    if (select_ret == -1){
657
 
      perror("select");
658
 
      exitstatus = EXIT_FAILURE;
659
 
      goto end;
 
1194
    if(select_ret == -1 and errno != EINTR){
 
1195
      error(0, errno, "select");
 
1196
      exitstatus = EX_OSERR;
 
1197
      goto fallback;
660
1198
    }
661
1199
    /* OK, now either a process completed, or something can be read
662
1200
       from one of them */
663
 
    for(process *proc = process_list; proc ; proc = proc->next){
 
1201
    for(plugin *proc = plugin_list; proc != NULL;){
664
1202
      /* Is this process completely done? */
665
 
      if(proc->eof and proc->completed){
 
1203
      if(proc->completed and proc->eof){
666
1204
        /* Only accept the plugin output if it exited cleanly */
667
1205
        if(not WIFEXITED(proc->status)
668
1206
           or WEXITSTATUS(proc->status) != 0){
669
1207
          /* Bad exit by plugin */
 
1208
          
670
1209
          if(debug){
671
1210
            if(WIFEXITED(proc->status)){
672
 
              fprintf(stderr, "Plugin %u exited with status %d\n",
673
 
                      (unsigned int) (proc->pid),
 
1211
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"
 
1212
                      " status %d\n", proc->name,
 
1213
                      (intmax_t) (proc->pid),
674
1214
                      WEXITSTATUS(proc->status));
675
 
            } else if(WIFSIGNALED(proc->status)) {
676
 
              fprintf(stderr, "Plugin %u killed by signal %d\n",
677
 
                      (unsigned int) (proc->pid),
678
 
                      WTERMSIG(proc->status));
679
 
            } else if(WCOREDUMP(proc->status)){
680
 
              fprintf(stderr, "Plugin %d dumped core\n",
681
 
                      (unsigned int) (proc->pid));
 
1215
            } else if(WIFSIGNALED(proc->status)){
 
1216
              fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"
 
1217
                      " signal %d: %s\n", proc->name,
 
1218
                      (intmax_t) (proc->pid),
 
1219
                      WTERMSIG(proc->status),
 
1220
                      strsignal(WTERMSIG(proc->status)));
682
1221
            }
683
1222
          }
 
1223
          
684
1224
          /* Remove the plugin */
685
1225
          FD_CLR(proc->fd, &rfds_all);
 
1226
          
686
1227
          /* Block signal while modifying process_list */
687
 
          ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);
 
1228
          ret = (int)TEMP_FAILURE_RETRY(sigprocmask
 
1229
                                        (SIG_BLOCK,
 
1230
                                         &sigchld_action.sa_mask,
 
1231
                                         NULL));
688
1232
          if(ret < 0){
689
 
            perror("sigprocmask");
690
 
            exitstatus = EXIT_FAILURE;
691
 
            goto end;
692
 
          }
693
 
          /* Delete this process entry from the list */
694
 
          if(process_list == proc){
695
 
            /* First one - simple */
696
 
            process_list = proc->next;
697
 
          } else {
698
 
            /* Second one or later */
699
 
            for(process *p = process_list; p != NULL; p = p->next){
700
 
              if(p->next == proc){
701
 
                p->next = proc->next;
702
 
                break;
703
 
              }
704
 
            }
705
 
          }
 
1233
            error(0, errno, "sigprocmask");
 
1234
            exitstatus = EX_OSERR;
 
1235
            goto fallback;
 
1236
          }
 
1237
          
 
1238
          plugin *next_plugin = proc->next;
 
1239
          free_plugin(proc);
 
1240
          proc = next_plugin;
 
1241
          
706
1242
          /* We are done modifying process list, so unblock signal */
707
 
          ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,
708
 
                             NULL);
 
1243
          ret = (int)(TEMP_FAILURE_RETRY
 
1244
                      (sigprocmask(SIG_UNBLOCK,
 
1245
                                   &sigchld_action.sa_mask, NULL)));
709
1246
          if(ret < 0){
710
 
            perror("sigprocmask");
711
 
          }
712
 
          free(proc->buffer);
713
 
          free(proc);
714
 
          /* We deleted this process from the list, so we can't go
715
 
             proc->next.  Therefore, start over from the beginning of
716
 
             the process list */
717
 
          break;
 
1247
            error(0, errno, "sigprocmask");
 
1248
            exitstatus = EX_OSERR;
 
1249
            goto fallback;
 
1250
          }
 
1251
          
 
1252
          if(plugin_list == NULL){
 
1253
            break;
 
1254
          }
 
1255
          
 
1256
          continue;
718
1257
        }
 
1258
        
719
1259
        /* This process exited nicely, so print its buffer */
720
 
 
721
 
        bool bret = print_out_password(proc->buffer, proc->buffer_length);
 
1260
        
 
1261
        bool bret = print_out_password(proc->buffer,
 
1262
                                       proc->buffer_length);
722
1263
        if(not bret){
723
 
          perror("print_out_password");
724
 
          exitstatus = EXIT_FAILURE;
 
1264
          error(0, errno, "print_out_password");
 
1265
          exitstatus = EX_IOERR;
725
1266
        }
726
 
        goto end;
 
1267
        goto fallback;
727
1268
      }
 
1269
      
728
1270
      /* This process has not completed.  Does it have any output? */
729
1271
      if(proc->eof or not FD_ISSET(proc->fd, &rfds)){
730
1272
        /* This process had nothing to say at this time */
 
1273
        proc = proc->next;
731
1274
        continue;
732
1275
      }
733
1276
      /* Before reading, make the process' data buffer large enough */
734
1277
      if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){
735
 
        proc->buffer = realloc(proc->buffer, proc->buffer_size
736
 
                               + (size_t) BUFFER_SIZE);
737
 
        if (proc->buffer == NULL){
738
 
          perror("malloc");
739
 
          exitstatus = EXIT_FAILURE;
740
 
          goto end;
 
1278
        char *new_buffer = realloc(proc->buffer, proc->buffer_size
 
1279
                                   + (size_t) BUFFER_SIZE);
 
1280
        if(new_buffer == NULL){
 
1281
          error(0, errno, "malloc");
 
1282
          exitstatus = EX_OSERR;
 
1283
          goto fallback;
741
1284
        }
 
1285
        proc->buffer = new_buffer;
742
1286
        proc->buffer_size += BUFFER_SIZE;
743
1287
      }
744
1288
      /* Read from the process */
745
 
      ret = read(proc->fd, proc->buffer + proc->buffer_length,
746
 
                 BUFFER_SIZE);
747
 
      if(ret < 0){
 
1289
      sret = TEMP_FAILURE_RETRY(read(proc->fd,
 
1290
                                     proc->buffer
 
1291
                                     + proc->buffer_length,
 
1292
                                     BUFFER_SIZE));
 
1293
      if(sret < 0){
748
1294
        /* Read error from this process; ignore the error */
 
1295
        proc = proc->next;
749
1296
        continue;
750
1297
      }
751
 
      if(ret == 0){
 
1298
      if(sret == 0){
752
1299
        /* got EOF */
753
1300
        proc->eof = true;
754
1301
      } else {
755
 
        proc->buffer_length += (size_t) ret;
 
1302
        proc->buffer_length += (size_t) sret;
756
1303
      }
757
1304
    }
758
1305
  }
759
 
 
760
 
 
761
 
 end:
762
 
  
763
 
  if(process_list == NULL or exitstatus != EXIT_SUCCESS){
764
 
    /* Fallback if all plugins failed, none are found or an error occured */
 
1306
  
 
1307
  
 
1308
 fallback:
 
1309
  
 
1310
  if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS
 
1311
                             and exitstatus != EX_OK)){
 
1312
    /* Fallback if all plugins failed, none are found or an error
 
1313
       occured */
765
1314
    bool bret;
766
1315
    fprintf(stderr, "Going to fallback mode using getpass(3)\n");
767
1316
    char *passwordbuffer = getpass("Password: ");
768
 
    bret = print_out_password(passwordbuffer, strlen(passwordbuffer));
 
1317
    size_t len = strlen(passwordbuffer);
 
1318
    /* Strip trailing newline */
 
1319
    if(len > 0 and passwordbuffer[len-1] == '\n'){
 
1320
      passwordbuffer[len-1] = '\0'; /* not strictly necessary */
 
1321
      len--;
 
1322
    }
 
1323
    bret = print_out_password(passwordbuffer, len);
769
1324
    if(not bret){
770
 
      perror("print_out_password");
771
 
      exitstatus = EXIT_FAILURE;
772
 
      goto end;
 
1325
      error(0, errno, "print_out_password");
 
1326
      exitstatus = EX_IOERR;
773
1327
    }
774
1328
  }
775
1329
  
776
1330
  /* Restore old signal handler */
777
 
  sigaction(SIGCHLD, &old_sigchld_action, NULL);
778
 
  
779
 
  free(custom_argv);
780
 
  
781
 
  /* Free the plugin list */
782
 
  for(plugin *next; plugin_list != NULL; plugin_list = next){
783
 
    next = plugin_list->next;
784
 
    free(plugin_list->argv);
785
 
    free(plugin_list);
786
 
  }
787
 
  
788
 
  if(dir != NULL){
789
 
    closedir(dir);
790
 
  }
791
 
  
792
 
  /* Free the process list and kill the processes */
793
 
  for(process *next; process_list != NULL; process_list = next){
794
 
    next = process_list->next;
795
 
    close(process_list->fd);
796
 
    ret = kill(process_list->pid, SIGTERM);
797
 
    if(ret == -1 and errno != ESRCH){
798
 
      /* set-uid proccesses migth not get closed */
799
 
      perror("kill");
800
 
    }
801
 
    free(process_list->buffer);
802
 
    free(process_list);
 
1331
  ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);
 
1332
  if(ret == -1){
 
1333
    error(0, errno, "sigaction");
 
1334
    exitstatus = EX_OSERR;
 
1335
  }
 
1336
  
 
1337
  if(custom_argv != NULL){
 
1338
    for(char **arg = custom_argv+1; *arg != NULL; arg++){
 
1339
      free(*arg);
 
1340
    }
 
1341
    free(custom_argv);
 
1342
  }
 
1343
  
 
1344
  free(direntries);
 
1345
  
 
1346
  if(dir_fd != -1){
 
1347
    close(dir_fd);
 
1348
  }
 
1349
  
 
1350
  /* Kill the processes */
 
1351
  for(plugin *p = plugin_list; p != NULL; p = p->next){
 
1352
    if(p->pid != 0){
 
1353
      close(p->fd);
 
1354
      ret = kill(p->pid, SIGTERM);
 
1355
      if(ret == -1 and errno != ESRCH){
 
1356
        /* Set-uid proccesses might not get closed */
 
1357
        error(0, errno, "kill");
 
1358
      }
 
1359
    }
803
1360
  }
804
1361
  
805
1362
  /* Wait for any remaining child processes to terminate */
806
 
  do{
 
1363
  do {
807
1364
    ret = wait(NULL);
808
1365
  } while(ret >= 0);
809
1366
  if(errno != ECHILD){
810
 
    perror("wait");
 
1367
    error(0, errno, "wait");
811
1368
  }
812
1369
  
 
1370
  free_plugin_list();
 
1371
  
 
1372
  free(plugindir);
 
1373
  free(pluginhelperdir);
 
1374
  free(argfile);
 
1375
  
813
1376
  return exitstatus;
814
1377
}