/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/password-prompt.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:
2
2
/*
3
3
 * Password-prompt - Read a password from the terminal and print it
4
4
 * 
5
 
 * Copyright © 2008-2012 Teddy Hogeborn
6
 
 * Copyright © 2008-2012 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-2019 Teddy Hogeborn
 
6
 * Copyright © 2008-2019 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
23
 * Contact the authors at <mandos@recompile.se>.
23
24
 */
26
27
 
27
28
#include <termios.h>            /* struct termios, tcsetattr(),
28
29
                                   TCSAFLUSH, tcgetattr(), ECHO */
29
 
#include <unistd.h>             /* struct termios, tcsetattr(),
30
 
                                   STDIN_FILENO, TCSAFLUSH,
31
 
                                   tcgetattr(), ECHO, readlink() */
 
30
#include <unistd.h>             /* access(), struct termios,
 
31
                                   tcsetattr(), STDIN_FILENO,
 
32
                                   TCSAFLUSH, tcgetattr(), ECHO,
 
33
                                   readlink() */
32
34
#include <signal.h>             /* sig_atomic_t, raise(), struct
33
35
                                   sigaction, sigemptyset(),
34
36
                                   sigaction(), sigaddset(), SIGINT,
72
74
/* Needed for conflict resolution */
73
75
const char plymouth_name[] = "plymouthd";
74
76
 
75
 
__attribute__((format (gnu_printf, 2, 3), nonnull(1)))
76
 
int fprintf_plus(FILE *stream, const char *format, ...){
77
 
  va_list ap;
78
 
  va_start (ap, format);
79
 
  
80
 
  TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
81
 
                             program_invocation_short_name));
82
 
  return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
83
 
}
84
 
 
85
77
/* Function to use when printing errors */
86
78
__attribute__((format (gnu_printf, 3, 4)))
87
79
void error_plus(int status, int errnum, const char *formatstring,
92
84
  
93
85
  va_start(ap, formatstring);
94
86
  ret = vasprintf(&text, formatstring, ap);
95
 
  if (ret == -1){
 
87
  if(ret == -1){
96
88
    fprintf(stderr, "Mandos plugin %s: ",
97
89
            program_invocation_short_name);
98
90
    vfprintf(stderr, formatstring, ap);
119
111
     from the terminal.  Password-prompt will exit if it detects
120
112
     plymouth since plymouth performs the same functionality.
121
113
   */
 
114
  if(access("/run/plymouth/pid", R_OK) == 0){
 
115
    return true;
 
116
  }
 
117
  
122
118
  __attribute__((nonnull))
123
119
  int is_plymouth(const struct dirent *proc_entry){
124
120
    int ret;
222
218
  struct dirent **direntries = NULL;
223
219
  int ret;
224
220
  ret = scandir("/proc", &direntries, is_plymouth, alphasort);
225
 
  if (ret == -1){
 
221
  if(ret == -1){
226
222
    error_plus(1, errno, "scandir");
227
223
  }
 
224
  {
 
225
    int i = ret;
 
226
    while(i--){
 
227
      free(direntries[i]);
 
228
    }
 
229
  }
228
230
  free(direntries);
229
231
  return ret > 0;
230
232
}
237
239
  struct termios t_new, t_old;
238
240
  char *buffer = NULL;
239
241
  char *prefix = NULL;
 
242
  char *prompt = NULL;
240
243
  int status = EXIT_SUCCESS;
241
244
  struct sigaction old_action,
242
245
    new_action = { .sa_handler = termination_handler,
246
249
      { .name = "prefix", .key = 'p',
247
250
        .arg = "PREFIX", .flags = 0,
248
251
        .doc = "Prefix shown before the prompt", .group = 2 },
 
252
      { .name = "prompt", .key = 129,
 
253
        .arg = "PROMPT", .flags = 0,
 
254
        .doc = "The prompt to show", .group = 2 },
249
255
      { .name = "debug", .key = 128,
250
256
        .doc = "Debug mode", .group = 3 },
251
257
      /*
264
270
    error_t parse_opt (int key, char *arg, struct argp_state *state){
265
271
      errno = 0;
266
272
      switch (key){
267
 
      case 'p':
 
273
      case 'p':                 /* --prefix */
268
274
        prefix = arg;
269
275
        break;
270
 
      case 128:
 
276
      case 128:                 /* --debug */
271
277
        debug = true;
272
278
        break;
 
279
      case 129:                 /* --prompt */
 
280
        prompt = arg;
 
281
        break;
273
282
        /*
274
283
         * These reproduce what we would get without ARGP_NO_HELP
275
284
         */
277
286
        argp_state_help(state, state->out_stream,
278
287
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
279
288
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
289
        __builtin_unreachable();
280
290
      case -3:                  /* --usage */
281
291
        argp_state_help(state, state->out_stream,
282
292
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
293
        __builtin_unreachable();
283
294
      case 'V':                 /* --version */
284
295
        fprintf(state->out_stream, "%s\n", argp_program_version);
285
296
        exit(argp_err_exit_status);
313
324
    fprintf(stderr, "Starting %s\n", argv[0]);
314
325
  }
315
326
 
316
 
  if (conflict_detection()){
 
327
  if(conflict_detection()){
317
328
    if(debug){
318
329
      fprintf(stderr, "Stopping %s because of conflict\n", argv[0]);
319
330
    }
428
439
    if(prefix){
429
440
      fprintf(stderr, "%s ", prefix);
430
441
    }
431
 
    {
 
442
    if(prompt != NULL){
 
443
      fprintf(stderr, "%s: ", prompt);
 
444
    } else {
432
445
      const char *cryptsource = getenv("CRYPTTAB_SOURCE");
433
446
      const char *crypttarget = getenv("CRYPTTAB_NAME");
434
447
      /* Before cryptsetup 1.1.0~rc2 */
509
522
    }
510
523
    if(sret < 0){
511
524
      int e = errno;
512
 
      if(errno != EINTR and not feof(stdin)){
513
 
        error_plus(0, errno, "getline");
514
 
        switch(e){
515
 
        case EBADF:
516
 
          status = EX_UNAVAILABLE;
517
 
          break;
518
 
        case EIO:
519
 
        case EINVAL:
520
 
        default:
521
 
          status = EX_IOERR;
522
 
          break;
 
525
      if(errno != EINTR){
 
526
        if(not feof(stdin)){
 
527
          error_plus(0, errno, "getline");
 
528
          switch(e){
 
529
          case EBADF:
 
530
            status = EX_UNAVAILABLE;
 
531
            break;
 
532
          case EIO:
 
533
          case EINVAL:
 
534
          default:
 
535
            status = EX_IOERR;
 
536
            break;
 
537
          }
 
538
          break;
 
539
        } else {
 
540
          clearerr(stdin);
523
541
        }
524
 
        break;
525
542
      }
526
543
    }
527
544
    /* if(sret == 0), then the only sensible thing to do is to retry