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