/mandos/trunk

« back to all changes in this revision

Viewing changes to plugins.d/plymouth.c

• browse files at revision 960
• compare with another revision
• download diff
• download tarball
• view history from revision 960

• reverse the comparison (960 to 1232)
• stop comparing with revision 1232

Show diffs side-by-side

added

removed

plugins.d/plymouth.c

2

2

/*

3

3

 * Plymouth - Read a password from Plymouth and output it

4

4

 * 

5

 

 * Copyright © 2010-2020 Teddy Hogeborn

6

 

 * Copyright © 2010-2020 Björn Påhlsson

 

5

 * Copyright © 2010-2018 Teddy Hogeborn

 

6

 * Copyright © 2010-2018 Björn Påhlsson

7

7

 * 

8

8

 * This file is part of Mandos.

9

9

 * 

44

44

                                   STDERR_FILENO, execv(), access() */

45

45

#include <stdlib.h>             /* free(), EXIT_FAILURE, realloc(),

46

46

                                   EXIT_SUCCESS, malloc(), _exit(),

47

 

                                   getenv(), reallocarray() */

 

47

                                   getenv() */

48

48

#include <dirent.h>             /* scandir(), alphasort() */

49

49

#include <inttypes.h>           /* intmax_t, strtoumax(), SCNuMAX */

50

50

#include <sys/stat.h>           /* struct stat, lstat() */

53

53

#include <errno.h>              /* TEMP_FAILURE_RETRY */

54

54

#include <argz.h>               /* argz_count(), argz_extract() */

55

55

#include <stdarg.h>             /* va_list, va_start(), ... */

56

 

#include <argp.h>

57

56

 

58

57

sig_atomic_t interrupted_by_signal = 0;

59

 

const char *argp_program_version = "plymouth " VERSION;

60

 

const char *argp_program_bug_address = "<mandos@recompile.se>";

61

58

 

62

59

/* Used by Ubuntu 11.04 (Natty Narwahl) */

63

60

const char plymouth_old_old_pid[] = "/dev/.initramfs/plymouth.pid";

72

69

                                        "--mode=boot",

73

70

                                        "--attach-to-session",

74

71

                                        NULL };

75

 

bool debug = false;

76

72

 

77

73

static void termination_handler(__attribute__((unused))int signum){

78

74

  if(interrupted_by_signal){

81

77

  interrupted_by_signal = 1;

82

78

}

83

79

 

84

 

__attribute__((format (gnu_printf, 2, 3), nonnull))

85

 

int fprintf_plus(FILE *stream, const char *format, ...){

86

 

  va_list ap;

87

 

  va_start (ap, format);

88

 

  fprintf(stream, "Mandos plugin %s: ", program_invocation_short_name);

89

 

  return vfprintf(stream, format, ap);

90

 

}

91

 

 

92

80

/* Function to use when printing errors */

93

81

__attribute__((format (gnu_printf, 3, 4)))

94

82

void error_plus(int status, int errnum, const char *formatstring,

171

159

 

172

160

__attribute__((nonnull (2, 3)))

173

161

bool exec_and_wait(pid_t *pid_return, const char *path,

174

 

                   const char * const * const argv, bool interruptable,

 

162

                   const char * const *argv, bool interruptable,

175

163

                   bool daemonize){

176

164

  int status;

177

165

  int ret;

178

166

  pid_t pid;

179

 

  if(debug){

180

 

    for(const char * const *arg = argv; *arg != NULL; arg++){

181

 

      fprintf_plus(stderr, "exec_and_wait arg: %s\n", *arg);

182

 

    }

183

 

    fprintf_plus(stderr, "exec_and_wait end of args\n");

184

 

  }

185

 

 

186

167

  pid = fork();

187

168

  if(pid == -1){

188

169

    error_plus(0, errno, "fork");

204

185

    char **tmp;

205

186

    int i = 0;

206

187

    for (; argv[i] != NULL; i++){

207

 

#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 26)

208

 

      tmp = reallocarray(new_argv, ((size_t)i + 2),

209

 

                         sizeof(const char *));

210

 

#else

211

 

      if(((size_t)i + 2) > (SIZE_MAX / sizeof(const char *))){

212

 

        /* overflow */

213

 

        tmp = NULL;

214

 

        errno = ENOMEM;

215

 

      } else {

216

 

        tmp = realloc(new_argv, ((size_t)i + 2) * sizeof(const char *));

217

 

      }

218

 

#endif

 

188

      tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 2));

219

189

      if(tmp == NULL){

220

 

        error_plus(0, errno, "reallocarray");

 

190

        error_plus(0, errno, "realloc");

221

191

        free(new_argv);

222

192

        _exit(EX_OSERR);

223

193

      }

239

209

          and ((not interrupted_by_signal)

240

210

               or (not interruptable)));

241

211

  if(interrupted_by_signal and interruptable){

242

 

    if(debug){

243

 

      fprintf_plus(stderr, "Interrupted by signal\n");

244

 

    }

245

212

    return false;

246

213

  }

247

214

  if(ret == -1){

248

215

    error_plus(0, errno, "waitpid");

249

216

    return false;

250

217

  }

251

 

  if(debug){

252

 

    if(WIFEXITED(status)){

253

 

      fprintf_plus(stderr, "exec_and_wait exited: %d\n",

254

 

                   WEXITSTATUS(status));

255

 

    } else if(WIFSIGNALED(status)) {

256

 

      fprintf_plus(stderr, "exec_and_wait signaled: %d\n",

257

 

                   WTERMSIG(status));

258

 

    }

259

 

  }

260

218

  if(WIFEXITED(status) and (WEXITSTATUS(status) == 0)){

261

219

    return true;

262

220

  }

449

407

 

450

408

int main(__attribute__((unused))int argc,

451

409

         __attribute__((unused))char **argv){

452

 

  char *prompt = NULL;

 

410

  char *prompt;

453

411

  char *prompt_arg;

454

412

  pid_t plymouth_command_pid;

455

413

  int ret;

456

414

  bool bret;

457

415

 

458

 

  {

459

 

    struct argp_option options[] = {

460

 

      { .name = "prompt", .key = 128, .arg = "PROMPT",

461

 

        .doc = "The prompt to show" },

462

 

      { .name = "debug", .key = 129,

463

 

        .doc = "Debug mode" },

464

 

      { .name = NULL }

465

 

    };

466

 

    

467

 

    __attribute__((nonnull(3)))

468

 

    error_t parse_opt (int key, char *arg, __attribute__((unused))

469

 

                       struct argp_state *state){

470

 

      errno = 0;

471

 

      switch (key){

472

 

      case 128:                 /* --prompt */

473

 

        prompt = arg;

474

 

        if(debug){

475

 

          fprintf_plus(stderr, "Custom prompt \"%s\"\n", prompt);

476

 

        }

477

 

        break;

478

 

      case 129:                 /* --debug */

479

 

        debug = true;

480

 

        break;

481

 

      default:

482

 

        return ARGP_ERR_UNKNOWN;

483

 

      }

484

 

      return errno;

485

 

    }

486

 

    

487

 

    struct argp argp = { .options = options, .parser = parse_opt,

488

 

                         .args_doc = "",

489

 

                         .doc = "Mandos plymouth -- Read and"

490

 

                         " output a password" };

491

 

    ret = argp_parse(&argp, argc, argv, ARGP_IN_ORDER, NULL, NULL);

492

 

    switch(ret){

493

 

    case 0:

494

 

      break;

495

 

    case ENOMEM:

496

 

    default:

497

 

      errno = ret;

498

 

      error_plus(0, errno, "argp_parse");

499

 

      return EX_OSERR;

500

 

    case EINVAL:

501

 

      error_plus(0, errno, "argp_parse");

502

 

      return EX_USAGE;

503

 

    }

504

 

  }

505

 

  

506

416

  /* test -x /bin/plymouth */

507

417

  ret = access(plymouth_path, X_OK);

508

418

  if(ret == -1){

509

419

    /* Plymouth is probably not installed.  Don't print an error

510

420

       message, just exit. */

511

 

    if(debug){

512

 

      fprintf_plus(stderr, "Plymouth (%s) not found\n",

513

 

                   plymouth_path);

514

 

    }

515

421

    exit(EX_UNAVAILABLE);

516

422

  }

517

423

  

551

457

    }

552

458

    /* Plymouth is probably not running.  Don't print an error

553

459

       message, just exit. */

554

 

    if(debug){

555

 

      fprintf_plus(stderr, "Plymouth not running\n");

556

 

    }

557

460

    exit(EX_UNAVAILABLE);

558

461

  }

559

462

  

560

 

  if(prompt != NULL){

561

 

    ret = asprintf(&prompt_arg, "--prompt=%s", prompt);

562

 

  } else {

563

 

    char *made_prompt = makeprompt();

564

 

    ret = asprintf(&prompt_arg, "--prompt=%s", made_prompt);

565

 

    free(made_prompt);

566

 

  }

 

463

  prompt = makeprompt();

 

464

  ret = asprintf(&prompt_arg, "--prompt=%s", prompt);

 

465

  free(prompt);

567

466

  if(ret == -1){

568

467

    error_plus(EX_OSERR, errno, "asprintf");

569

468

  }

570

469

  

571

470

  /* plymouth ask-for-password --prompt="$prompt" */

572

 

  if(debug){

573

 

    fprintf_plus(stderr, "Prompting for password via Plymouth\n");

574

 

  }

575

471

  bret = exec_and_wait(&plymouth_command_pid,

576

472

                       plymouth_path, (const char *[])

577

473

                       { plymouth_path, "ask-for-password",

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0