/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugins.d/usplash.c

  • Committer: Teddy Hogeborn
  • Date: 2010-09-12 03:22:48 UTC
  • Revision ID: teddy@fukt.bsnet.se-20100912032248-6cizkymqivr5uzwm
* Makefile (run-server): Remove warning about now-eliminated error.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/usplash.c
2
2
/*
3
3
 * Usplash - Read a password from usplash and output it
4
4
 * 
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
 
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
16
14
 * WITHOUT ANY WARRANTY; without even the implied warranty of
17
15
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18
16
 * General Public License for more details.
19
17
 * 
20
18
 * You should have received a copy of the GNU General Public License
21
 
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
 
19
 * along with this program.  If not, see
 
20
 * <http://www.gnu.org/licenses/>.
22
21
 * 
23
 
 * Contact the authors at <mandos@recompile.se>.
 
22
 * Contact the authors at <mandos@fukt.bsnet.se>.
24
23
 */
25
24
 
26
25
#define _GNU_SOURCE             /* asprintf(), TEMP_FAILURE_RETRY() */
36
35
#include <sys/types.h>          /* size_t, ssize_t, pid_t, DIR, struct
37
36
                                   dirent */
38
37
#include <stddef.h>             /* NULL */
39
 
#include <string.h>             /* strlen(), memcmp(), strerror() */
40
 
#include <stdio.h>              /* asprintf(), vasprintf(), vprintf(),
41
 
                                   fprintf() */
 
38
#include <string.h>             /* strlen(), memcmp() */
 
39
#include <stdio.h>              /* asprintf()*/
42
40
#include <unistd.h>             /* close(), write(), readlink(),
43
41
                                   read(), STDOUT_FILENO, sleep(),
44
42
                                   fork(), setuid(), geteuid(),
51
49
#include <inttypes.h>           /* intmax_t, strtoimax() */
52
50
#include <sys/stat.h>           /* struct stat, lstat(), S_ISLNK */
53
51
#include <sysexits.h>           /* EX_OSERR, EX_UNAVAILABLE */
54
 
#include <argz.h>               /* argz_count(), argz_extract() */
55
 
#include <stdarg.h>             /* va_list, va_start(), ... */
56
52
 
57
53
sig_atomic_t interrupted_by_signal = 0;
58
54
int signal_received;
59
55
const char usplash_name[] = "/sbin/usplash";
60
56
 
61
 
/* Function to use when printing errors */
62
 
__attribute__((format (gnu_printf, 3, 4)))
63
 
void error_plus(int status, int errnum, const char *formatstring,
64
 
                ...){
65
 
  va_list ap;
66
 
  char *text;
67
 
  int ret;
68
 
  
69
 
  va_start(ap, formatstring);
70
 
  ret = vasprintf(&text, formatstring, ap);
71
 
  if(ret == -1){
72
 
    fprintf(stderr, "Mandos plugin %s: ",
73
 
            program_invocation_short_name);
74
 
    vfprintf(stderr, formatstring, ap);
75
 
    fprintf(stderr, ": ");
76
 
    fprintf(stderr, "%s\n", strerror(errnum));
77
 
    error(status, errno, "vasprintf while printing error");
78
 
    return;
79
 
  }
80
 
  fprintf(stderr, "Mandos plugin ");
81
 
  error(status, errnum, "%s", text);
82
 
  free(text);
83
 
}
84
 
 
85
57
static void termination_handler(int signum){
86
58
  if(interrupted_by_signal){
87
59
    return;
118
90
      ret = asprintf(&cmd_line_alloc, "%s %s", cmd, arg);
119
91
      if(ret == -1){
120
92
        int e = errno;
121
 
        close(*fifo_fd_r);
 
93
        TEMP_FAILURE_RETRY(close(*fifo_fd_r));
122
94
        errno = e;
123
95
        return false;
124
96
      }
134
106
                 cmd_line_len - written);
135
107
    if(sret == -1){
136
108
      int e = errno;
137
 
      close(*fifo_fd_r);
 
109
      TEMP_FAILURE_RETRY(close(*fifo_fd_r));
138
110
      free(cmd_line_alloc);
139
111
      errno = e;
140
112
      return false;
182
154
  size_t cmdline_len = 0;
183
155
  DIR *proc_dir = opendir("/proc");
184
156
  if(proc_dir == NULL){
185
 
    error_plus(0, errno, "opendir");
 
157
    error(0, errno, "opendir");
186
158
    return -1;
187
159
  }
188
160
  errno = 0;
210
182
      char *exe_link;
211
183
      ret = asprintf(&exe_link, "/proc/%s/exe", proc_ent->d_name);
212
184
      if(ret == -1){
213
 
        error_plus(0, errno, "asprintf");
 
185
        error(0, errno, "asprintf");
214
186
        goto fail_find_usplash;
215
187
      }
216
188
      
222
194
          free(exe_link);
223
195
          continue;
224
196
        }
225
 
        error_plus(0, errno, "lstat");
 
197
        error(0, errno, "lstat");
226
198
        free(exe_link);
227
199
        goto fail_find_usplash;
228
200
      }
253
225
        ret = asprintf(&cmdline_filename, "/proc/%s/cmdline",
254
226
                       proc_ent->d_name);
255
227
        if(ret == -1){
256
 
          error_plus(0, errno, "asprintf");
 
228
          error(0, errno, "asprintf");
257
229
          goto fail_find_usplash;
258
230
        }
259
231
        cl_fd = open(cmdline_filename, O_RDONLY);
260
232
        free(cmdline_filename);
261
233
        if(cl_fd == -1){
262
 
          error_plus(0, errno, "open");
 
234
          error(0, errno, "open");
263
235
          goto fail_find_usplash;
264
236
        }
265
237
      }
271
243
        if(cmdline_len + blocksize > cmdline_allocated){
272
244
          tmp = realloc(cmdline, cmdline_allocated + blocksize);
273
245
          if(tmp == NULL){
274
 
            error_plus(0, errno, "realloc");
 
246
            error(0, errno, "realloc");
275
247
            close(cl_fd);
276
248
            goto fail_find_usplash;
277
249
          }
282
254
        sret = read(cl_fd, cmdline + cmdline_len,
283
255
                    cmdline_allocated - cmdline_len);
284
256
        if(sret == -1){
285
 
          error_plus(0, errno, "read");
 
257
          error(0, errno, "read");
286
258
          close(cl_fd);
287
259
          goto fail_find_usplash;
288
260
        }
290
262
      } while(sret != 0);
291
263
      ret = close(cl_fd);
292
264
      if(ret == -1){
293
 
        error_plus(0, errno, "close");
 
265
        error(0, errno, "close");
294
266
        goto fail_find_usplash;
295
267
      }
296
268
    }
297
269
    /* Close directory */
298
270
    ret = closedir(proc_dir);
299
271
    if(ret == -1){
300
 
      error_plus(0, errno, "closedir");
 
272
      error(0, errno, "closedir");
301
273
      goto fail_find_usplash;
302
274
    }
303
275
    /* Success */
352
324
    sigemptyset(&new_action.sa_mask);
353
325
    ret = sigaddset(&new_action.sa_mask, SIGINT);
354
326
    if(ret == -1){
355
 
      error_plus(0, errno, "sigaddset");
 
327
      error(0, errno, "sigaddset");
356
328
      status = EX_OSERR;
357
329
      goto failure;
358
330
    }
359
331
    ret = sigaddset(&new_action.sa_mask, SIGHUP);
360
332
    if(ret == -1){
361
 
      error_plus(0, errno, "sigaddset");
 
333
      error(0, errno, "sigaddset");
362
334
      status = EX_OSERR;
363
335
      goto failure;
364
336
    }
365
337
    ret = sigaddset(&new_action.sa_mask, SIGTERM);
366
338
    if(ret == -1){
367
 
      error_plus(0, errno, "sigaddset");
 
339
      error(0, errno, "sigaddset");
368
340
      status = EX_OSERR;
369
341
      goto failure;
370
342
    }
371
343
    ret = sigaction(SIGINT, NULL, &old_action);
372
344
    if(ret == -1){
373
345
      if(errno != EINTR){
374
 
        error_plus(0, errno, "sigaction");
 
346
        error(0, errno, "sigaction");
375
347
        status = EX_OSERR;
376
348
      }
377
349
      goto failure;
380
352
      ret = sigaction(SIGINT, &new_action, NULL);
381
353
      if(ret == -1){
382
354
        if(errno != EINTR){
383
 
          error_plus(0, errno, "sigaction");
 
355
          error(0, errno, "sigaction");
384
356
          status = EX_OSERR;
385
357
        }
386
358
        goto failure;
389
361
    ret = sigaction(SIGHUP, NULL, &old_action);
390
362
    if(ret == -1){
391
363
      if(errno != EINTR){
392
 
        error_plus(0, errno, "sigaction");
 
364
        error(0, errno, "sigaction");
393
365
        status = EX_OSERR;
394
366
      }
395
367
      goto failure;
398
370
      ret = sigaction(SIGHUP, &new_action, NULL);
399
371
      if(ret == -1){
400
372
        if(errno != EINTR){
401
 
          error_plus(0, errno, "sigaction");
 
373
          error(0, errno, "sigaction");
402
374
          status = EX_OSERR;
403
375
        }
404
376
        goto failure;
407
379
    ret = sigaction(SIGTERM, NULL, &old_action);
408
380
    if(ret == -1){
409
381
      if(errno != EINTR){
410
 
        error_plus(0, errno, "sigaction");
 
382
        error(0, errno, "sigaction");
411
383
        status = EX_OSERR;
412
384
      }
413
385
      goto failure;
416
388
      ret = sigaction(SIGTERM, &new_action, NULL);
417
389
      if(ret == -1){
418
390
        if(errno != EINTR){
419
 
          error_plus(0, errno, "sigaction");
 
391
          error(0, errno, "sigaction");
420
392
          status = EX_OSERR;
421
393
        }
422
394
        goto failure;
428
400
  /* Write command to FIFO */
429
401
  if(not usplash_write(&fifo_fd, "TIMEOUT", "0")){
430
402
    if(errno != EINTR){
431
 
      error_plus(0, errno, "usplash_write");
 
403
      error(0, errno, "usplash_write");
432
404
      status = EX_OSERR;
433
405
    }
434
406
    goto failure;
440
412
  
441
413
  if(not usplash_write(&fifo_fd, "INPUTQUIET", prompt)){
442
414
    if(errno != EINTR){
443
 
      error_plus(0, errno, "usplash_write");
 
415
      error(0, errno, "usplash_write");
444
416
      status = EX_OSERR;
445
417
    }
446
418
    goto failure;
458
430
  outfifo_fd = open("/dev/.initramfs/usplash_outfifo", O_RDONLY);
459
431
  if(outfifo_fd == -1){
460
432
    if(errno != EINTR){
461
 
      error_plus(0, errno, "open");
 
433
      error(0, errno, "open");
462
434
      status = EX_OSERR;
463
435
    }
464
436
    goto failure;
477
449
      char *tmp = realloc(buf, buf_allocated + blocksize);
478
450
      if(tmp == NULL){
479
451
        if(errno != EINTR){
480
 
          error_plus(0, errno, "realloc");
 
452
          error(0, errno, "realloc");
481
453
          status = EX_OSERR;
482
454
        }
483
455
        goto failure;
489
461
                buf_allocated - buf_len);
490
462
    if(sret == -1){
491
463
      if(errno != EINTR){
492
 
        error_plus(0, errno, "read");
 
464
        error(0, errno, "read");
493
465
        status = EX_OSERR;
494
466
      }
495
 
      close(outfifo_fd);
 
467
      TEMP_FAILURE_RETRY(close(outfifo_fd));
496
468
      goto failure;
497
469
    }
498
470
    if(interrupted_by_signal){
504
476
  ret = close(outfifo_fd);
505
477
  if(ret == -1){
506
478
    if(errno != EINTR){
507
 
      error_plus(0, errno, "close");
 
479
      error(0, errno, "close");
508
480
      status = EX_OSERR;
509
481
    }
510
482
    goto failure;
517
489
  
518
490
  if(not usplash_write(&fifo_fd, "TIMEOUT", "15")){
519
491
    if(errno != EINTR){
520
 
      error_plus(0, errno, "usplash_write");
 
492
      error(0, errno, "usplash_write");
521
493
      status = EX_OSERR;
522
494
    }
523
495
    goto failure;
530
502
  ret = close(fifo_fd);
531
503
  if(ret == -1){
532
504
    if(errno != EINTR){
533
 
      error_plus(0, errno, "close");
 
505
      error(0, errno, "close");
534
506
      status = EX_OSERR;
535
507
    }
536
508
    goto failure;
544
516
      sret = write(STDOUT_FILENO, buf + written, buf_len - written);
545
517
      if(sret == -1){
546
518
        if(errno != EINTR){
547
 
          error_plus(0, errno, "write");
 
519
          error(0, errno, "write");
548
520
          status = EX_OSERR;
549
521
        }
550
522
        goto failure;
579
551
  
580
552
  /* Close FIFO */
581
553
  if(fifo_fd != -1){
582
 
    ret = close(fifo_fd);
 
554
    ret = (int)TEMP_FAILURE_RETRY(close(fifo_fd));
583
555
    if(ret == -1 and errno != EINTR){
584
 
      error_plus(0, errno, "close");
 
556
      error(0, errno, "close");
585
557
    }
586
558
    fifo_fd = -1;
587
559
  }
588
560
  
589
561
  /* Close output FIFO */
590
562
  if(outfifo_fd != -1){
591
 
    ret = close(outfifo_fd);
 
563
    ret = (int)TEMP_FAILURE_RETRY(close(outfifo_fd));
592
564
    if(ret == -1){
593
 
      error_plus(0, errno, "close");
594
 
    }
595
 
  }
596
 
  
597
 
  /* Create argv for new usplash*/
598
 
  char **cmdline_argv = malloc((argz_count(cmdline, cmdline_len) + 1)
599
 
                               * sizeof(char *)); /* Count args */
600
 
  if(cmdline_argv == NULL){
601
 
    error_plus(0, errno, "malloc");
602
 
    return status;
603
 
  }
604
 
  argz_extract(cmdline, cmdline_len, cmdline_argv); /* Create argv */
605
 
  
 
565
      error(0, errno, "close");
 
566
    }
 
567
  }
 
568
  
 
569
  /* Create argc and argv for new usplash*/
 
570
  int cmdline_argc = 0;
 
571
  char **cmdline_argv = malloc(sizeof(char *));
 
572
  {
 
573
    size_t position = 0;
 
574
    while(position < cmdline_len){
 
575
      char **tmp = realloc(cmdline_argv,
 
576
                           (sizeof(char *)
 
577
                            * (size_t)(cmdline_argc + 2)));
 
578
      if(tmp == NULL){
 
579
        error(0, errno, "realloc");
 
580
        free(cmdline_argv);
 
581
        return status;
 
582
      }
 
583
      cmdline_argv = tmp;
 
584
      cmdline_argv[cmdline_argc] = cmdline + position;
 
585
      cmdline_argc++;
 
586
      position += strlen(cmdline + position) + 1;
 
587
    }
 
588
    cmdline_argv[cmdline_argc] = NULL;
 
589
  }
606
590
  /* Kill old usplash */
607
591
  kill(usplash_pid, SIGTERM);
608
592
  sleep(2);
619
603
       the real user ID (_mandos) */
620
604
    ret = setuid(geteuid());
621
605
    if(ret == -1){
622
 
      error_plus(0, errno, "setuid");
 
606
      error(0, errno, "setuid");
623
607
    }
624
608
    
625
609
    setsid();
626
610
    ret = chdir("/");
627
611
    if(ret == -1){
628
 
      error_plus(0, errno, "chdir");
 
612
      error(0, errno, "chdir");
629
613
      _exit(EX_OSERR);
630
614
    }
631
615
/*     if(fork() != 0){ */
633
617
/*     } */
634
618
    ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */
635
619
    if(ret == -1){
636
 
      error_plus(0, errno, "dup2");
 
620
      error(0, errno, "dup2");
637
621
      _exit(EX_OSERR);
638
622
    }
639
623
    
640
624
    execv(usplash_name, cmdline_argv);
641
625
    if(not interrupted_by_signal){
642
 
      error_plus(0, errno, "execv");
 
626
      error(0, errno, "execv");
643
627
    }
644
628
    free(cmdline);
645
629
    free(cmdline_argv);
650
634
  sleep(2);
651
635
  if(not usplash_write(&fifo_fd, "PULSATE", NULL)){
652
636
    if(errno != EINTR){
653
 
      error_plus(0, errno, "usplash_write");
 
637
      error(0, errno, "usplash_write");
654
638
    }
655
639
  }
656
640
  
657
641
  /* Close FIFO (again) */
658
642
  if(fifo_fd != -1){
659
 
    ret = close(fifo_fd);
 
643
    ret = (int)TEMP_FAILURE_RETRY(close(fifo_fd));
660
644
    if(ret == -1 and errno != EINTR){
661
 
      error_plus(0, errno, "close");
 
645
      error(0, errno, "close");
662
646
    }
663
647
    fifo_fd = -1;
664
648
  }
669
653
    ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
670
654
                                            &signal_action, NULL));
671
655
    if(ret == -1){
672
 
      error_plus(0, errno, "sigaction");
 
656
      error(0, errno, "sigaction");
673
657
    }
674
658
    do {
675
659
      ret = raise(signal_received);
676
660
    } while(ret != 0 and errno == EINTR);
677
661
    if(ret != 0){
678
 
      error_plus(0, errno, "raise");
 
662
      error(0, errno, "raise");
679
663
      abort();
680
664
    }
681
665
    TEMP_FAILURE_RETRY(pause());