/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: 2019-08-05 21:14:05 UTC
  • Revision ID: teddy@recompile.se-20190805211405-9m6hecekaihpttz9
Override lintian warnings about upgrading from old versions

There are some really things which are imperative that we fix in case
someone were to upgrade from a really old version.  We want to keep
these fixes in the postinst maintainer scripts, even though lintian
complains about such old upgrades not being supported by Debian in
general.  We prefer the code being there, for the sake of the users.

* debian/mandos-client.lintian-overrides
  (maintainer-script-supports-ancient-package-version): New.
  debian/mandos.lintian-overrides
  (maintainer-script-supports-ancient-package-version): - '' -

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