/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

* plugins.d/askpass-fifo.c (main): Don't print message if FIFO exists.

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
 
5
 * Copyright © 2008-2011 Teddy Hogeborn
 
6
 * Copyright © 2008-2011 Björn Påhlsson
7
7
 * 
8
8
 * This program is free software: you can redistribute it and/or
9
9
 * modify it under the terms of the GNU General Public License as
29
29
                                   SIG_IGN, kill(), SIGKILL */
30
30
#include <stddef.h>             /* NULL */
31
31
#include <stdlib.h>             /* getenv() */
32
 
#include <stdio.h>              /* asprintf(), perror() */
 
32
#include <stdio.h>              /* asprintf() */
33
33
#include <stdlib.h>             /* EXIT_FAILURE, free(),
34
34
                                   EXIT_SUCCESS */
35
35
#include <sys/types.h>          /* pid_t, DIR, struct dirent,
43
43
                                   STDOUT_FILENO, _exit(),
44
44
                                   pause() */
45
45
#include <string.h>             /* memcmp() */
46
 
#include <errno.h>              /* errno */
 
46
#include <errno.h>              /* errno, EACCES, ENOTDIR, ELOOP,
 
47
                                   ENOENT, ENAMETOOLONG, EMFILE,
 
48
                                   ENFILE, ENOMEM, ENOEXEC, EINVAL,
 
49
                                   E2BIG, EFAULT, EIO, ETXTBSY,
 
50
                                   EISDIR, ELIBBAD, EPERM, EINTR,
 
51
                                   ECHILD */
 
52
#include <error.h>              /* error() */
47
53
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
48
54
                                   WEXITSTATUS() */
49
 
 
50
55
#include <sysexits.h>           /* EX_OSERR, EX_OSFILE,
51
56
                                   EX_UNAVAILABLE */
52
57
 
105
110
    proc_dir = opendir("/proc");
106
111
    if(proc_dir == NULL){
107
112
      int e = errno;
108
 
      perror("opendir");
 
113
      error(0, errno, "opendir");
109
114
      switch(e){
110
115
      case EACCES:
111
116
      case ENOTDIR:
147
152
        char *exe_link;
148
153
        ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
149
154
        if(ret == -1){
150
 
          perror("asprintf");
 
155
          error(0, errno, "asprintf");
151
156
          exitstatus = EX_OSERR;
152
157
          goto failure;
153
158
        }
161
166
            continue;
162
167
          }
163
168
          int e = errno;
164
 
          perror("lstat");
 
169
          error(0, errno, "lstat");
165
170
          free(exe_link);
166
171
          switch(e){
167
172
          case EACCES:
209
214
    sigemptyset(&new_action.sa_mask);
210
215
    ret = sigaddset(&new_action.sa_mask, SIGINT);
211
216
    if(ret == -1){
212
 
      perror("sigaddset");
 
217
      error(0, errno, "sigaddset");
213
218
      exitstatus = EX_OSERR;
214
219
      goto failure;
215
220
    }
216
221
    ret = sigaddset(&new_action.sa_mask, SIGHUP);
217
222
    if(ret == -1){
218
 
      perror("sigaddset");
 
223
      error(0, errno, "sigaddset");
219
224
      exitstatus = EX_OSERR;
220
225
      goto failure;
221
226
    }
222
227
    ret = sigaddset(&new_action.sa_mask, SIGTERM);
223
228
    if(ret == -1){
224
 
      perror("sigaddset");
 
229
      error(0, errno, "sigaddset");
225
230
      exitstatus = EX_OSERR;
226
231
      goto failure;
227
232
    }
228
233
    ret = sigaction(SIGINT, NULL, &old_action);
229
234
    if(ret == -1){
230
 
      perror("sigaction");
 
235
      error(0, errno, "sigaction");
231
236
      exitstatus = EX_OSERR;
232
237
      goto failure;
233
238
    }
234
239
    if(old_action.sa_handler != SIG_IGN){
235
240
      ret = sigaction(SIGINT, &new_action, NULL);
236
241
      if(ret == -1){
237
 
        perror("sigaction");
 
242
        error(0, errno, "sigaction");
238
243
        exitstatus = EX_OSERR;
239
244
        goto failure;
240
245
      }
241
246
    }
242
247
    ret = sigaction(SIGHUP, NULL, &old_action);
243
248
    if(ret == -1){
244
 
      perror("sigaction");
 
249
      error(0, errno, "sigaction");
245
250
      exitstatus = EX_OSERR;
246
251
      goto failure;
247
252
    }
248
253
    if(old_action.sa_handler != SIG_IGN){
249
254
      ret = sigaction(SIGHUP, &new_action, NULL);
250
255
      if(ret == -1){
251
 
        perror("sigaction");
 
256
        error(0, errno, "sigaction");
252
257
        exitstatus = EX_OSERR;
253
258
        goto failure;
254
259
      }
255
260
    }
256
261
    ret = sigaction(SIGTERM, NULL, &old_action);
257
262
    if(ret == -1){
258
 
      perror("sigaction");
 
263
      error(0, errno, "sigaction");
259
264
      exitstatus = EX_OSERR;
260
265
      goto failure;
261
266
    }
262
267
    if(old_action.sa_handler != SIG_IGN){
263
268
      ret = sigaction(SIGTERM, &new_action, NULL);
264
269
      if(ret == -1){
265
 
        perror("sigaction");
 
270
        error(0, errno, "sigaction");
266
271
        exitstatus = EX_OSERR;
267
272
        goto failure;
268
273
      }
279
284
    goto failure;
280
285
  }
281
286
  if(splashy_command_pid == -1){
282
 
    perror("fork");
 
287
    error(0, errno, "fork");
283
288
    exitstatus = EX_OSERR;
284
289
    goto failure;
285
290
  }
288
293
    if(not interrupted_by_signal){
289
294
      const char splashy_command[] = "/sbin/splashy_update";
290
295
      execl(splashy_command, splashy_command, prompt, (char *)NULL);
291
 
      perror("execl");
 
296
      int e = errno;
 
297
      error(0, errno, "execl");
 
298
      switch(e){
 
299
      case EACCES:
 
300
      case ENOENT:
 
301
      case ENOEXEC:
 
302
      case EINVAL:
 
303
        _exit(EX_UNAVAILABLE);
 
304
      case ENAMETOOLONG:
 
305
      case E2BIG:
 
306
      case ENOMEM:
 
307
      case EFAULT:
 
308
      case EIO:
 
309
      case EMFILE:
 
310
      case ENFILE:
 
311
      case ETXTBSY:
 
312
      default:
 
313
        _exit(EX_OSERR);
 
314
      case ENOTDIR:
 
315
      case ELOOP:
 
316
      case EISDIR:
 
317
#ifdef ELIBBAD
 
318
      case ELIBBAD:             /* Linux only */
 
319
#endif
 
320
      case EPERM:
 
321
        _exit(EX_OSFILE);
 
322
      }
292
323
    }
293
324
    free(prompt);
294
325
    _exit(EXIT_FAILURE);
313
344
      goto failure;
314
345
    }
315
346
    if(ret == -1){
316
 
      perror("waitpid");
 
347
      error(0, errno, "waitpid");
317
348
      if(errno == ECHILD){
318
349
        splashy_command_pid = 0;
319
350
      }
351
382
         the real user ID (_mandos) */
352
383
      ret = setuid(geteuid());
353
384
      if(ret == -1){
354
 
        perror("setuid");
 
385
        error(0, errno, "setuid");
355
386
      }
356
387
      
357
388
      setsid();
358
389
      ret = chdir("/");
359
390
      if(ret == -1){
360
 
        perror("chdir");
 
391
        error(0, errno, "chdir");
361
392
      }
362
393
/*       if(fork() != 0){ */
363
394
/*      _exit(EXIT_SUCCESS); */
364
395
/*       } */
365
396
      ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace stdout */
366
397
      if(ret == -1){
367
 
        perror("dup2");
 
398
        error(0, errno, "dup2");
368
399
        _exit(EX_OSERR);
369
400
      }
370
401
      
371
402
      execl("/sbin/splashy", "/sbin/splashy", "boot", (char *)NULL);
372
403
      {
373
404
        int e = errno;
374
 
        perror("execl");
 
405
        error(0, errno, "execl");
375
406
        switch(e){
376
407
        case EACCES:
377
408
        case ENOENT:
397
428
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
398
429
                                            &signal_action, NULL));
399
430
    if(ret == -1){
400
 
      perror("sigaction");
 
431
      error(0, errno, "sigaction");
401
432
    }
402
433
    do {
403
434
      ret = raise(signal_received);
404
435
    } while(ret != 0 and errno == EINTR);
405
436
    if(ret != 0){
406
 
      perror("raise");
 
437
      error(0, errno, "raise");
407
438
      abort();
408
439
    }
409
440
    TEMP_FAILURE_RETRY(pause());