/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: 2015-07-20 03:03:33 UTC
  • mto: (237.7.594 trunk)
  • mto: This revision was merged to the branch mainline in revision 325.
  • Revision ID: teddy@recompile.se-20150720030333-203m2aeblypcsfte
Bug fix for GnuTLS 3: be compatible with old 2048-bit DSA keys.

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

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

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

Show diffs side-by-side

added added

removed removed

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