/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() */
46
 
#include <errno.h>              /* errno */
 
47
#include <string.h>             /* memcmp(), strerror() */
 
48
#include <errno.h>              /* errno, EACCES, ENOTDIR, ELOOP,
 
49
                                   ENOENT, ENAMETOOLONG, EMFILE,
 
50
                                   ENFILE, ENOMEM, ENOEXEC, EINVAL,
 
51
                                   E2BIG, EFAULT, EIO, ETXTBSY,
 
52
                                   EISDIR, ELIBBAD, EPERM, EINTR,
 
53
                                   ECHILD */
 
54
#include <error.h>              /* error() */
47
55
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
48
56
                                   WEXITSTATUS() */
 
57
#include <sysexits.h>           /* EX_OSERR, EX_OSFILE,
 
58
                                   EX_UNAVAILABLE */
 
59
#include <stdarg.h>             /* va_list, va_start(), ... */
49
60
 
50
61
sig_atomic_t interrupted_by_signal = 0;
51
62
int signal_received;
52
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
 
53
89
static void termination_handler(int signum){
54
90
  if(interrupted_by_signal){
55
91
    return;
65
101
  DIR *proc_dir = NULL;
66
102
  pid_t splashy_pid = 0;
67
103
  pid_t splashy_command_pid = 0;
 
104
  int exitstatus = EXIT_FAILURE;
68
105
  
69
106
  /* Create prompt string */
70
107
  {
90
127
    }
91
128
    if(ret == -1){
92
129
      prompt = NULL;
 
130
      exitstatus = EX_OSERR;
93
131
      goto failure;
94
132
    }
95
133
  }
99
137
    const char splashy_name[] = "/sbin/splashy";
100
138
    proc_dir = opendir("/proc");
101
139
    if(proc_dir == NULL){
102
 
      perror("opendir");
 
140
      int e = errno;
 
141
      error_plus(0, errno, "opendir");
 
142
      switch(e){
 
143
      case EACCES:
 
144
      case ENOTDIR:
 
145
      case ELOOP:
 
146
      case ENOENT:
 
147
      default:
 
148
        exitstatus = EX_OSFILE;
 
149
        break;
 
150
      case ENAMETOOLONG:
 
151
      case EMFILE:
 
152
      case ENFILE:
 
153
      case ENOMEM:
 
154
        exitstatus = EX_OSERR;
 
155
        break;
 
156
      }
103
157
      goto failure;
104
158
    }
105
159
    for(struct dirent *proc_ent = readdir(proc_dir);
126
180
        char *exe_link;
127
181
        ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
128
182
        if(ret == -1){
129
 
          perror("asprintf");
 
183
          error_plus(0, errno, "asprintf");
 
184
          exitstatus = EX_OSERR;
130
185
          goto failure;
131
186
        }
132
187
        
138
193
            free(exe_link);
139
194
            continue;
140
195
          }
141
 
          perror("lstat");
 
196
          int e = errno;
 
197
          error_plus(0, errno, "lstat");
142
198
          free(exe_link);
 
199
          switch(e){
 
200
          case EACCES:
 
201
          case ENOTDIR:
 
202
          case ELOOP:
 
203
          default:
 
204
            exitstatus = EX_OSFILE;
 
205
            break;
 
206
          case ENAMETOOLONG:
 
207
            exitstatus = EX_OSERR;
 
208
            break;
 
209
          }
143
210
          goto failure;
144
211
        }
145
212
        if(not S_ISLNK(exe_stat.st_mode)
163
230
    proc_dir = NULL;
164
231
  }
165
232
  if(splashy_pid == 0){
 
233
    exitstatus = EX_UNAVAILABLE;
166
234
    goto failure;
167
235
  }
168
236
  
174
242
    sigemptyset(&new_action.sa_mask);
175
243
    ret = sigaddset(&new_action.sa_mask, SIGINT);
176
244
    if(ret == -1){
177
 
      perror("sigaddset");
 
245
      error_plus(0, errno, "sigaddset");
 
246
      exitstatus = EX_OSERR;
178
247
      goto failure;
179
248
    }
180
249
    ret = sigaddset(&new_action.sa_mask, SIGHUP);
181
250
    if(ret == -1){
182
 
      perror("sigaddset");
 
251
      error_plus(0, errno, "sigaddset");
 
252
      exitstatus = EX_OSERR;
183
253
      goto failure;
184
254
    }
185
255
    ret = sigaddset(&new_action.sa_mask, SIGTERM);
186
256
    if(ret == -1){
187
 
      perror("sigaddset");
 
257
      error_plus(0, errno, "sigaddset");
 
258
      exitstatus = EX_OSERR;
188
259
      goto failure;
189
260
    }
190
261
    ret = sigaction(SIGINT, NULL, &old_action);
191
262
    if(ret == -1){
192
 
      perror("sigaction");
 
263
      error_plus(0, errno, "sigaction");
 
264
      exitstatus = EX_OSERR;
193
265
      goto failure;
194
266
    }
195
267
    if(old_action.sa_handler != SIG_IGN){
196
268
      ret = sigaction(SIGINT, &new_action, NULL);
197
269
      if(ret == -1){
198
 
        perror("sigaction");
 
270
        error_plus(0, errno, "sigaction");
 
271
        exitstatus = EX_OSERR;
199
272
        goto failure;
200
273
      }
201
274
    }
202
275
    ret = sigaction(SIGHUP, NULL, &old_action);
203
276
    if(ret == -1){
204
 
      perror("sigaction");
 
277
      error_plus(0, errno, "sigaction");
 
278
      exitstatus = EX_OSERR;
205
279
      goto failure;
206
280
    }
207
281
    if(old_action.sa_handler != SIG_IGN){
208
282
      ret = sigaction(SIGHUP, &new_action, NULL);
209
283
      if(ret == -1){
210
 
        perror("sigaction");
 
284
        error_plus(0, errno, "sigaction");
 
285
        exitstatus = EX_OSERR;
211
286
        goto failure;
212
287
      }
213
288
    }
214
289
    ret = sigaction(SIGTERM, NULL, &old_action);
215
290
    if(ret == -1){
216
 
      perror("sigaction");
 
291
      error_plus(0, errno, "sigaction");
 
292
      exitstatus = EX_OSERR;
217
293
      goto failure;
218
294
    }
219
295
    if(old_action.sa_handler != SIG_IGN){
220
296
      ret = sigaction(SIGTERM, &new_action, NULL);
221
297
      if(ret == -1){
222
 
        perror("sigaction");
 
298
        error_plus(0, errno, "sigaction");
 
299
        exitstatus = EX_OSERR;
223
300
        goto failure;
224
301
      }
225
302
    }
235
312
    goto failure;
236
313
  }
237
314
  if(splashy_command_pid == -1){
238
 
    perror("fork");
 
315
    error_plus(0, errno, "fork");
 
316
    exitstatus = EX_OSERR;
239
317
    goto failure;
240
318
  }
241
319
  /* Child */
243
321
    if(not interrupted_by_signal){
244
322
      const char splashy_command[] = "/sbin/splashy_update";
245
323
      execl(splashy_command, splashy_command, prompt, (char *)NULL);
246
 
      perror("execl");
 
324
      int e = errno;
 
325
      error_plus(0, errno, "execl");
 
326
      switch(e){
 
327
      case EACCES:
 
328
      case ENOENT:
 
329
      case ENOEXEC:
 
330
      case EINVAL:
 
331
        _exit(EX_UNAVAILABLE);
 
332
      case ENAMETOOLONG:
 
333
      case E2BIG:
 
334
      case ENOMEM:
 
335
      case EFAULT:
 
336
      case EIO:
 
337
      case EMFILE:
 
338
      case ENFILE:
 
339
      case ETXTBSY:
 
340
      default:
 
341
        _exit(EX_OSERR);
 
342
      case ENOTDIR:
 
343
      case ELOOP:
 
344
      case EISDIR:
 
345
#ifdef ELIBBAD
 
346
      case ELIBBAD:             /* Linux only */
 
347
#endif
 
348
      case EPERM:
 
349
        _exit(EX_OSFILE);
 
350
      }
247
351
    }
248
352
    free(prompt);
249
353
    _exit(EXIT_FAILURE);
268
372
      goto failure;
269
373
    }
270
374
    if(ret == -1){
271
 
      perror("waitpid");
 
375
      error_plus(0, errno, "waitpid");
272
376
      if(errno == ECHILD){
273
377
        splashy_command_pid = 0;
274
378
      }
306
410
         the real user ID (_mandos) */
307
411
      ret = setuid(geteuid());
308
412
      if(ret == -1){
309
 
        perror("setuid");
 
413
        error_plus(0, errno, "setuid");
310
414
      }
311
415
      
312
416
      setsid();
313
417
      ret = chdir("/");
314
418
      if(ret == -1){
315
 
        perror("chdir");
 
419
        error_plus(0, errno, "chdir");
316
420
      }
317
421
/*       if(fork() != 0){ */
318
422
/*      _exit(EXIT_SUCCESS); */
319
423
/*       } */
320
424
      ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace stdout */
321
425
      if(ret == -1){
322
 
        perror("dup2");
323
 
        _exit(EXIT_FAILURE);
 
426
        error_plus(0, errno, "dup2");
 
427
        _exit(EX_OSERR);
324
428
      }
325
 
    
 
429
      
326
430
      execl("/sbin/splashy", "/sbin/splashy", "boot", (char *)NULL);
327
 
      perror("execl");
328
 
      _exit(EXIT_FAILURE);
 
431
      {
 
432
        int e = errno;
 
433
        error_plus(0, errno, "execl");
 
434
        switch(e){
 
435
        case EACCES:
 
436
        case ENOENT:
 
437
        case ENOEXEC:
 
438
        default:
 
439
          _exit(EX_UNAVAILABLE);
 
440
        case ENAMETOOLONG:
 
441
        case E2BIG:
 
442
        case ENOMEM:
 
443
          _exit(EX_OSERR);
 
444
        case ENOTDIR:
 
445
        case ELOOP:
 
446
          _exit(EX_OSFILE);
 
447
        }
 
448
      }
329
449
    }
330
450
  }
331
451
  
336
456
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
337
457
                                            &signal_action, NULL));
338
458
    if(ret == -1){
339
 
      perror("sigaction");
 
459
      error_plus(0, errno, "sigaction");
340
460
    }
341
461
    do {
342
462
      ret = raise(signal_received);
343
463
    } while(ret != 0 and errno == EINTR);
344
464
    if(ret != 0){
345
 
      perror("raise");
 
465
      error_plus(0, errno, "raise");
346
466
      abort();
347
467
    }
348
468
    TEMP_FAILURE_RETRY(pause());
349
469
  }
350
470
  
351
 
  return EXIT_FAILURE;
 
471
  return exitstatus;
352
472
}