/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugin-runner.c

  • Committer: Teddy Hogeborn
  • Date: 2019-02-09 23:23:26 UTC
  • Revision ID: teddy@recompile.se-20190209232326-z1z2kzpgfixz7iaj
Add support for using raw public keys in TLS (RFC 7250)

Since GnuTLS removed support for OpenPGP keys in TLS (RFC 6091), and
no other library supports it, we have to change the protocol to use
something else.  We choose to use "raw public keys" (RFC 7250).  Since
we still use OpenPGP keys to decrypt the secret password, this means
that each client will have two keys: One OpenPGP key and one TLS
public/private key, and the key ID of the latter key is used to
identify clients instead of the fingerprint of the OpenPGP key.

Note that this code is still compatible with GnuTLS before version
3.6.0 (when OpenPGP key support was removed).  This commit merely adds
support for using raw pulic keys instead with GnuTLS 3.6.6. or later.

* DBUS-API (Signals/ClientNotFound): Change name of first parameter
                                     from "Fingerprint" to "KeyID".
  (Mandos Client Interface/Properties/KeyID): New.
* INSTALL: Document conflict with GnuTLS 3.6.0 (which removed OpenPGP
           key support) up until 3.6.6, when support for raw public
           keys was added.  Also document new dependency of client on
           "gnutls-bin" package (for certtool).
* Makefile (run-client): Depend on TLS key files, and also pass them
                         as arguments to client.
  (keydir/tls-privkey.pem, keydir/tls-pubkey.pem): New.
  (confdir/clients.conf): Add dependency on TLS public key.
  (purge-client): Add removal of TLS key files.
* clients.conf ([foo]/key_id, [bar]/key_id): New.
* debian/control (Source: mandos/Build-Depends): Also allow
                                                 libgnutls30 (>= 3.6.6)
  (Package: mandos/Depends): - '' -
  (Package: mandos/Description): Alter description to match new
                                 design.
  (Package: mandos-client/Description): - '' -
  (Package: mandos-client/Depends): Move "gnutls-bin | openssl" to
                                    here from "Recommends".
* debian/mandos-client.README.Debian: Add --tls-privkey and
                                      --tls-pubkey options to test
                                      command.
* debian/mandos-client.postinst (create_key): Renamed to "create_keys"
                                             (all callers changed),
                                             and also create TLS key.
* debian/mandos-client.postrm (purge): Also remove TLS key files.
* intro.xml (DESCRIPTION): Describe new dual-key design.
* mandos (GnuTLS): Define different functions depending on whether
                   support for raw public keys is detected.
  (Client.key_id): New attribute.
  (ClientDBus.KeyID_dbus_property): New method.
  (ProxyClient.__init__): Take new "key_id" parameter.
  (ClientHandler.handle): Use key IDs when using raw public keys and
                          use fingerprints when using OpenPGP keys.
  (ClientHandler.peer_certificate): Also handle raw public keys.
  (ClientHandler.key_id): New.
  (MandosServer.handle_ipc): Pass key ID over the pipe IPC.  Also
                             check for key ID matches when looking up
                             clients.
  (main): Default GnuTLS priority string depends on whether we are
          using raw public keys or not.  When unpickling clients, set
          key_id if not set in the pickle.
  (main/MandosDBusService.ClientNotFound): Change name of first
                                           parameter from
                                           "Fingerprint" to "KeyID".
* mandos-clients.conf.xml (OPTIONS): Document new "key_id" option.
  (OPTIONS/secret): Mention new key ID matchning.
  (EXPANSION/RUNTIME EXPANSION): Add new "key_id" option.
  (EXAMPLE): - '' -
* mandos-ctl (tablewords, main/keywords): Add new "KeyID" property.
* mandos-keygen: Create TLS key files.  New "--tls-keytype" (-T)
                 option.  Alter help text to be more clear about key
                 types.  When in password mode, also output "key_id"
                 option.
* mandos-keygen.xml (SYNOPSIS): Add new "--tls-keytype" (-T) option.
  (DESCRIPTION): Alter to match new dual-key design.
  (OVERVIEW): - '' -
  (FILES): Add TLS key files.
* mandos-options.xml (priority): Document new default priority string
                                 when using raw public keys.
* mandos.xml (NETWORK PROTOCOL): Describe new protocol using key ID.
  (BUGS): Remove issue about checking expire times of OpenPGP keys,
          since TLS public keys do not have expiration times.
  (SECURITY/CLIENT): Alter description to match new design.
  (SEE ALSO/GnuTLS): - '' -
  (SEE ALSO): Add reference to RFC 7250, and alter description of when
              RFC 6091 is used.
* overview.xml: Alter text to match new design.
* plugin-runner.xml (EXAMPLE): Add --tls-pubkey and --tls-privkey
                               options to mandos-client options.
* plugins.d/mandos-client.c: Use raw public keys when compiling with
                             supporting GnuTLS versions. Add new
                             "--tls-pubkey" and "--tls-privkey"
                             options (which do nothing if GnuTLS
                             library does not support raw public
                             keys).  Alter text throughout to reflect
                             new design.  Only generate new DH
                             parameters (based on size of OpenPGP key)
                             when using OpenPGP in TLS.  Default
                             GnuTLS priority string depends on whether
                             we are using raw public keys or not.
* plugins.d/mandos-client.xml (SYNOPSIS): Add new "--tls-privkey" (-t)
                                          and "--tls-pubkey" (-T)
                                          options.
  (DESCRIPTION): Describe new dual-key design.
  (OPTIONS): Document new "--tls-privkey" (-t) and "--tls-pubkey" (-T)
             options.
  (OPTIONS/--dh-bits): No longer necessarily depends on OpenPGP key
                       size.
  (FILES): Add default locations for TLS public and private key files.
  (EXAMPLE): Use new --tls-pubkey and --tls-privkey options.
  (SECURITY): Alter wording slightly to reflect new dual-key design.
  (SEE ALSO/GnuTLS): Alter description to match new design.
  (SEE ALSO): Add reference to RFC 7250, and alter description of when
              RFC 6091 is used.

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