/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 plugins.d/splashy.c

  • Committer: Teddy Hogeborn
  • Date: 2019-07-29 16:35:53 UTC
  • mto: This revision was merged to the branch mainline in revision 384.
  • Revision ID: teddy@recompile.se-20190729163553-1i442i2cbx64c537
Make tests and man page examples match

Make the tests test_manual_page_example[1-5] match exactly what is
written in the manual page, and add comments to manual page as
reminders to keep tests and manual page examples in sync.

* mandos-ctl (Test_commands_from_options.test_manual_page_example_1):
  Remove "--verbose" option, since the manual does not have it as the
  first example, and change assertion to match.
* mandos-ctl.xml (EXAMPLE): Add comments to all examples documenting
  which test function they correspond to.  Also remove unnecessary
  quotes from option arguments in fourth example, and clarify language
  slightly in fifth example.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/splashy.c
2
2
/*
3
3
 * Splashy - Read a password from splashy and output it
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(), asprintf() */
29
30
                                   SIG_IGN, kill(), SIGKILL */
30
31
#include <stddef.h>             /* NULL */
31
32
#include <stdlib.h>             /* getenv() */
32
 
#include <stdio.h>              /* asprintf(), perror() */
 
33
#include <stdio.h>              /* asprintf(), vasprintf(), vprintf(),
 
34
                                   fprintf() */
33
35
#include <stdlib.h>             /* EXIT_FAILURE, free(),
34
36
                                   EXIT_SUCCESS */
35
37
#include <sys/types.h>          /* pid_t, DIR, struct dirent,
42
44
                                   sleep(), dup2() STDERR_FILENO,
43
45
                                   STDOUT_FILENO, _exit(),
44
46
                                   pause() */
45
 
#include <string.h>             /* memcmp() */
 
47
#include <string.h>             /* memcmp(), strerror() */
46
48
#include <errno.h>              /* errno, EACCES, ENOTDIR, ELOOP,
47
49
                                   ENOENT, ENAMETOOLONG, EMFILE,
48
50
                                   ENFILE, ENOMEM, ENOEXEC, EINVAL,
49
51
                                   E2BIG, EFAULT, EIO, ETXTBSY,
50
52
                                   EISDIR, ELIBBAD, EPERM, EINTR,
51
53
                                   ECHILD */
 
54
#include <error.h>              /* error() */
52
55
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
53
56
                                   WEXITSTATUS() */
54
57
#include <sysexits.h>           /* EX_OSERR, EX_OSFILE,
55
58
                                   EX_UNAVAILABLE */
 
59
#include <stdarg.h>             /* va_list, va_start(), ... */
56
60
 
57
61
sig_atomic_t interrupted_by_signal = 0;
58
62
int signal_received;
59
63
 
 
64
/* Function to use when printing errors */
 
65
__attribute__((format (gnu_printf, 3, 4)))
 
66
void error_plus(int status, int errnum, const char *formatstring,
 
67
                ...){
 
68
  va_list ap;
 
69
  char *text;
 
70
  int ret;
 
71
  
 
72
  va_start(ap, formatstring);
 
73
  ret = vasprintf(&text, formatstring, ap);
 
74
  if(ret == -1){
 
75
    fprintf(stderr, "Mandos plugin %s: ",
 
76
            program_invocation_short_name);
 
77
    vfprintf(stderr, formatstring, ap);
 
78
    fprintf(stderr, ": ");
 
79
    fprintf(stderr, "%s\n", strerror(errnum));
 
80
    error(status, errno, "vasprintf while printing error");
 
81
    return;
 
82
  }
 
83
  fprintf(stderr, "Mandos plugin ");
 
84
  error(status, errnum, "%s", text);
 
85
  free(text);
 
86
}
 
87
 
 
88
 
60
89
static void termination_handler(int signum){
61
90
  if(interrupted_by_signal){
62
91
    return;
109
138
    proc_dir = opendir("/proc");
110
139
    if(proc_dir == NULL){
111
140
      int e = errno;
112
 
      perror("opendir");
 
141
      error_plus(0, errno, "opendir");
113
142
      switch(e){
114
143
      case EACCES:
115
144
      case ENOTDIR:
151
180
        char *exe_link;
152
181
        ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
153
182
        if(ret == -1){
154
 
          perror("asprintf");
 
183
          error_plus(0, errno, "asprintf");
155
184
          exitstatus = EX_OSERR;
156
185
          goto failure;
157
186
        }
165
194
            continue;
166
195
          }
167
196
          int e = errno;
168
 
          perror("lstat");
 
197
          error_plus(0, errno, "lstat");
169
198
          free(exe_link);
170
199
          switch(e){
171
200
          case EACCES:
213
242
    sigemptyset(&new_action.sa_mask);
214
243
    ret = sigaddset(&new_action.sa_mask, SIGINT);
215
244
    if(ret == -1){
216
 
      perror("sigaddset");
 
245
      error_plus(0, errno, "sigaddset");
217
246
      exitstatus = EX_OSERR;
218
247
      goto failure;
219
248
    }
220
249
    ret = sigaddset(&new_action.sa_mask, SIGHUP);
221
250
    if(ret == -1){
222
 
      perror("sigaddset");
 
251
      error_plus(0, errno, "sigaddset");
223
252
      exitstatus = EX_OSERR;
224
253
      goto failure;
225
254
    }
226
255
    ret = sigaddset(&new_action.sa_mask, SIGTERM);
227
256
    if(ret == -1){
228
 
      perror("sigaddset");
 
257
      error_plus(0, errno, "sigaddset");
229
258
      exitstatus = EX_OSERR;
230
259
      goto failure;
231
260
    }
232
261
    ret = sigaction(SIGINT, NULL, &old_action);
233
262
    if(ret == -1){
234
 
      perror("sigaction");
 
263
      error_plus(0, errno, "sigaction");
235
264
      exitstatus = EX_OSERR;
236
265
      goto failure;
237
266
    }
238
267
    if(old_action.sa_handler != SIG_IGN){
239
268
      ret = sigaction(SIGINT, &new_action, NULL);
240
269
      if(ret == -1){
241
 
        perror("sigaction");
 
270
        error_plus(0, errno, "sigaction");
242
271
        exitstatus = EX_OSERR;
243
272
        goto failure;
244
273
      }
245
274
    }
246
275
    ret = sigaction(SIGHUP, NULL, &old_action);
247
276
    if(ret == -1){
248
 
      perror("sigaction");
 
277
      error_plus(0, errno, "sigaction");
249
278
      exitstatus = EX_OSERR;
250
279
      goto failure;
251
280
    }
252
281
    if(old_action.sa_handler != SIG_IGN){
253
282
      ret = sigaction(SIGHUP, &new_action, NULL);
254
283
      if(ret == -1){
255
 
        perror("sigaction");
 
284
        error_plus(0, errno, "sigaction");
256
285
        exitstatus = EX_OSERR;
257
286
        goto failure;
258
287
      }
259
288
    }
260
289
    ret = sigaction(SIGTERM, NULL, &old_action);
261
290
    if(ret == -1){
262
 
      perror("sigaction");
 
291
      error_plus(0, errno, "sigaction");
263
292
      exitstatus = EX_OSERR;
264
293
      goto failure;
265
294
    }
266
295
    if(old_action.sa_handler != SIG_IGN){
267
296
      ret = sigaction(SIGTERM, &new_action, NULL);
268
297
      if(ret == -1){
269
 
        perror("sigaction");
 
298
        error_plus(0, errno, "sigaction");
270
299
        exitstatus = EX_OSERR;
271
300
        goto failure;
272
301
      }
283
312
    goto failure;
284
313
  }
285
314
  if(splashy_command_pid == -1){
286
 
    perror("fork");
 
315
    error_plus(0, errno, "fork");
287
316
    exitstatus = EX_OSERR;
288
317
    goto failure;
289
318
  }
293
322
      const char splashy_command[] = "/sbin/splashy_update";
294
323
      execl(splashy_command, splashy_command, prompt, (char *)NULL);
295
324
      int e = errno;
296
 
      perror("execl");
 
325
      error_plus(0, errno, "execl");
297
326
      switch(e){
298
327
      case EACCES:
299
328
      case ENOENT:
313
342
      case ENOTDIR:
314
343
      case ELOOP:
315
344
      case EISDIR:
316
 
      case ELIBBAD:
 
345
#ifdef ELIBBAD
 
346
      case ELIBBAD:             /* Linux only */
 
347
#endif
317
348
      case EPERM:
318
349
        _exit(EX_OSFILE);
319
350
      }
341
372
      goto failure;
342
373
    }
343
374
    if(ret == -1){
344
 
      perror("waitpid");
 
375
      error_plus(0, errno, "waitpid");
345
376
      if(errno == ECHILD){
346
377
        splashy_command_pid = 0;
347
378
      }
379
410
         the real user ID (_mandos) */
380
411
      ret = setuid(geteuid());
381
412
      if(ret == -1){
382
 
        perror("setuid");
 
413
        error_plus(0, errno, "setuid");
383
414
      }
384
415
      
385
416
      setsid();
386
417
      ret = chdir("/");
387
418
      if(ret == -1){
388
 
        perror("chdir");
 
419
        error_plus(0, errno, "chdir");
389
420
      }
390
421
/*       if(fork() != 0){ */
391
422
/*      _exit(EXIT_SUCCESS); */
392
423
/*       } */
393
424
      ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace stdout */
394
425
      if(ret == -1){
395
 
        perror("dup2");
 
426
        error_plus(0, errno, "dup2");
396
427
        _exit(EX_OSERR);
397
428
      }
398
429
      
399
430
      execl("/sbin/splashy", "/sbin/splashy", "boot", (char *)NULL);
400
431
      {
401
432
        int e = errno;
402
 
        perror("execl");
 
433
        error_plus(0, errno, "execl");
403
434
        switch(e){
404
435
        case EACCES:
405
436
        case ENOENT:
425
456
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
426
457
                                            &signal_action, NULL));
427
458
    if(ret == -1){
428
 
      perror("sigaction");
 
459
      error_plus(0, errno, "sigaction");
429
460
    }
430
461
    do {
431
462
      ret = raise(signal_received);
432
463
    } while(ret != 0 and errno == EINTR);
433
464
    if(ret != 0){
434
 
      perror("raise");
 
465
      error_plus(0, errno, "raise");
435
466
      abort();
436
467
    }
437
468
    TEMP_FAILURE_RETRY(pause());