/mandos/trunk : revision 365

2

/*

3

* Mandos plugin runner - Run Mandos plugins

4

*

5

6

5

6

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

23

*/

24

25

#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), getline(),

26

asprintf(), O_CLOEXEC */

26

asprintf() */

27

#include <stddef.h> /* size_t, NULL */

28

#include <stdlib.h> /* malloc(), exit(), EXIT_SUCCESS,

29

realloc() */

28

#include <stdlib.h> /* malloc(), exit(), EXIT_FAILURE,

29

EXIT_SUCCESS, realloc() */

30

#include <stdbool.h> /* bool, true, false */

31

#include <stdio.h> /* fileno(), fprintf(),

31

#include <stdio.h> /* perror, fileno(), fprintf(),

32

stderr, STDOUT_FILENO */

33

#include <sys/types.h> /* DIR, fdopendir(), stat(), struct

33

#include <sys/types.h> /* DIR, opendir(), stat(), struct

34

stat, waitpid(), WIFEXITED(),

35

WEXITSTATUS(), wait(), pid_t,

36

uid_t, gid_t, getuid(), getgid(),

42

WCOREDUMP() */

43

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

44

#include <iso646.h> /* and, or, not */

45

#include <dirent.h> /* DIR, struct dirent, fdopendir(),

45

#include <dirent.h> /* DIR, struct dirent, opendir(),

46

readdir(), closedir(), dirfd() */

47

#include <unistd.h> /* struct stat, stat(), S_ISREG(),

48

fcntl(), setuid(), setgid(),

54

#include <fcntl.h> /* fcntl(), F_GETFD, F_SETFD,

55

FD_CLOEXEC */

56

#include <string.h> /* strsep, strlen(), asprintf(),

57

strsignal(), strcmp(), strncmp() */

57

strsignal() */

58

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

59

#include <argp.h> /* struct argp_option, struct

60

argp_state, struct argp,

68

*/

69

#include <errno.h> /* errno, EBADF */

70

#include <inttypes.h> /* intmax_t, PRIdMAX, strtoimax() */

71

#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_IOERR,

72

EX_CONFIG, EX_UNAVAILABLE, EX_OK */

73

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

74

#include <error.h> /* error() */

75

71

76

72

#define BUFFER_SIZE 256

77

73

106

102

/* Gets an existing plugin based on name,

107

103

or if none is found, creates a new one */

108

104

static plugin *getplugin(char *name){

109

/* Check for existing plugin with that name */

105

/* Check for exiting plugin with that name */

110

106

for(plugin *p = plugin_list; p != NULL; p = p->next){

111

107

if((p->name == name)

112

108

or (p->name and name and (strcmp(p->name, name) == 0))){

127

123

copy_name = strdup(name);

128

124

} while(copy_name == NULL and errno == EINTR);

129

125

if(copy_name == NULL){

130

int e = errno;

131

126

free(new_plugin);

132

errno = e;

133

127

return NULL;

134

128

}

135

129

}

143

137

new_plugin->argv = malloc(sizeof(char *) * 2);

144

138

} while(new_plugin->argv == NULL and errno == EINTR);

145

139

if(new_plugin->argv == NULL){

146

int e = errno;

147

140

free(copy_name);

148

141

free(new_plugin);

149

errno = e;

150

142

return NULL;

151

143

}

152

144

new_plugin->argv[0] = copy_name;

156

148

new_plugin->environ = malloc(sizeof(char *));

157

149

} while(new_plugin->environ == NULL and errno == EINTR);

158

150

if(new_plugin->environ == NULL){

159

int e = errno;

160

151

free(copy_name);

161

152

free(new_plugin->argv);

162

153

free(new_plugin);

163

errno = e;

164

154

return NULL;

165

155

}

166

156

new_plugin->environ[0] = NULL;

240

230

| [[info:libc:Descriptor%20Flags][File Descriptor Flags]] |

241

231

*/

242

232

static int set_cloexec_flag(int fd){

243

int ret = (int)TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));

233

int ret = TEMP_FAILURE_RETRY(fcntl(fd, F_GETFD, 0));

244

234

/* If reading the flags failed, return error indication now. */

245

235

if(ret < 0){

246

236

return ret;

247

237

}

248

238

/* Store modified flag word in the descriptor. */

249

return (int)TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD,

250

ret | FD_CLOEXEC));

239

return TEMP_FAILURE_RETRY(fcntl(fd, F_SETFD, ret | FD_CLOEXEC));

251

240

}

252

241

253

242

268

257

/* No child processes */

269

258

break;

270

259

}

271

error(0, errno, "waitpid");

260

perror("waitpid");

272

261

}

273

262

274

263

/* A child exited, find it in process_list */

359

348

sigemptyset(&sigchld_action.sa_mask);

360

349

ret = sigaddset(&sigchld_action.sa_mask, SIGCHLD);

361

350

if(ret == -1){

362

error(0, errno, "sigaddset");

363

exitstatus = EX_OSERR;

351

perror("sigaddset");

352

exitstatus = EXIT_FAILURE;

364

353

goto fallback;

365

354

}

366

355

ret = sigaction(SIGCHLD, &sigchld_action, &old_sigchld_action);

367

356

if(ret == -1){

368

error(0, errno, "sigaction");

369

exitstatus = EX_OSERR;

357

perror("sigaction");

358

exitstatus = EXIT_FAILURE;

370

359

goto fallback;

371

360

}

372

361

404

393

.doc = "Group ID the plugins will run as", .group = 3 },

405

394

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

406

395

.doc = "Debug mode", .group = 4 },

407

/*

408

* These reproduce what we would get without ARGP_NO_HELP

409

*/

410

{ .name = "help", .key = '?',

411

.doc = "Give this help list", .group = -1 },

412

{ .name = "usage", .key = -3,

413

.doc = "Give a short usage message", .group = -1 },

414

{ .name = "version", .key = 'V',

415

.doc = "Print program version", .group = -1 },

416

396

{ .name = NULL }

417

397

};

418

398

419

error_t parse_opt(int key, char *arg, struct argp_state *state){

420

errno = 0;

399

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

400

struct argp_state *state){

421

401

switch(key){

422

402

char *tmp;

423

403

intmax_t tmpmax;

424

404

case 'g': /* --global-options */

425

{

405

if(arg != NULL){

426

406

char *plugin_option;

427

407

while((plugin_option = strsep(&arg, ",")) != NULL){

408

if(plugin_option[0] == '\0'){

409

continue;

410

}

428

411

if(not add_argument(getplugin(NULL), plugin_option)){

429

break;

412

perror("add_argument");

413

return ARGP_ERR_UNKNOWN;

430

414

}

431

415

}

432

416

}

433

417

break;

434

418

case 'G': /* --global-env */

435

add_environment(getplugin(NULL), arg, true);

419

if(arg == NULL){

420

break;

421

}

422

if(not add_environment(getplugin(NULL), arg, true)){

423

perror("add_environment");

424

}

436

425

break;

437

426

case 'o': /* --options-for */

438

{

439

char *option_list = strchr(arg, ':');

440

if(option_list == NULL){

441

argp_error(state, "No colon in \"%s\"", arg);

442

errno = EINVAL;

443

break;

444

}

445

*option_list = '\0';

446

option_list++;

447

if(arg[0] == '\0'){

448

argp_error(state, "Empty plugin name");

449

errno = EINVAL;

450

break;

451

}

452

char *option;

453

while((option = strsep(&option_list, ",")) != NULL){

454

if(not add_argument(getplugin(arg), option)){

455

break;

427

if(arg != NULL){

428

char *plugin_name = strsep(&arg, ":");

429

if(plugin_name[0] == '\0'){

430

break;

431

}

432

char *plugin_option;

433

while((plugin_option = strsep(&arg, ",")) != NULL){

434

if(not add_argument(getplugin(plugin_name), plugin_option)){

435

perror("add_argument");

436

return ARGP_ERR_UNKNOWN;

456

437

}

457

438

}

458

439

}

459

440

break;

460

441

case 'E': /* --env-for */

442

if(arg == NULL){

443

break;

444

}

461

445

{

462

446

char *envdef = strchr(arg, ':');

463

447

if(envdef == NULL){

464

argp_error(state, "No colon in \"%s\"", arg);

465

errno = EINVAL;

466

448

break;

467

449

}

468

450

*envdef = '\0';

469

envdef++;

470

if(arg[0] == '\0'){

471

argp_error(state, "Empty plugin name");

472

errno = EINVAL;

473

break;

451

if(not add_environment(getplugin(arg), envdef+1, true)){

452

perror("add_environment");

474

453

}

475

add_environment(getplugin(arg), envdef, true);

476

454

}

477

455

break;

478

456

case 'd': /* --disable */

479

{

457

if(arg != NULL){

480

458

plugin *p = getplugin(arg);

481

if(p != NULL){

482

p->disabled = true;

459

if(p == NULL){

460

return ARGP_ERR_UNKNOWN;

483

461

}

462

p->disabled = true;

484

463

}

485

464

break;

486

465

case 'e': /* --enable */

487

{

466

if(arg != NULL){

488

467

plugin *p = getplugin(arg);

489

if(p != NULL){

490

p->disabled = false;

468

if(p == NULL){

469

return ARGP_ERR_UNKNOWN;

491

470

}

471

p->disabled = false;

492

472

}

493

473

break;

494

474

case 128: /* --plugin-dir */

495

475

free(plugindir);

496

476

plugindir = strdup(arg);

477

if(plugindir == NULL){

478

perror("strdup");

479

}

497

480

break;

498

481

case 129: /* --config-file */

499

482

/* This is already done by parse_opt_config_file() */

500

483

break;

501

484

case 130: /* --userid */

485

errno = 0;

502

486

tmpmax = strtoimax(arg, &tmp, 10);

503

487

if(errno != 0 or tmp == arg or *tmp != '\0'

504

488

or tmpmax != (uid_t)tmpmax){

505

argp_error(state, "Bad user ID number: \"%s\", using %"

506

PRIdMAX, arg, (intmax_t)uid);

507

break;

489

fprintf(stderr, "Bad user ID number: \"%s\", using %"

490

PRIdMAX "\n", arg, (intmax_t)uid);

491

} else {

492

uid = (uid_t)tmpmax;

508

493

}

509

uid = (uid_t)tmpmax;

510

494

break;

511

495

case 131: /* --groupid */

496

errno = 0;

512

497

tmpmax = strtoimax(arg, &tmp, 10);

513

498

if(errno != 0 or tmp == arg or *tmp != '\0'

514

499

or tmpmax != (gid_t)tmpmax){

515

argp_error(state, "Bad group ID number: \"%s\", using %"

516

PRIdMAX, arg, (intmax_t)gid);

517

break;

500

fprintf(stderr, "Bad group ID number: \"%s\", using %"

501

PRIdMAX "\n", arg, (intmax_t)gid);

502

} else {

503

gid = (gid_t)tmpmax;

518

504

}

519

gid = (gid_t)tmpmax;

520

505

break;

521

506

case 132: /* --debug */

522

507

debug = true;

523

508

break;

524

/*

525

* These reproduce what we would get without ARGP_NO_HELP

526

*/

527

case '?': /* --help */

528

state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */

529

argp_state_help(state, state->out_stream, ARGP_HELP_STD_HELP);

530

case -3: /* --usage */

531

state->flags &= ~(unsigned int)ARGP_NO_EXIT; /* force exit */

532

argp_state_help(state, state->out_stream,

533

ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);

534

case 'V': /* --version */

535

fprintf(state->out_stream, "%s\n", argp_program_version);

536

exit(EXIT_SUCCESS);

537

break;

538

509

/*

539

510

* When adding more options before this line, remember to also add a

540

511

* "case" to the "parse_opt_config_file" function below.

543

514

/* Cryptsetup always passes an argument, which is an empty

544

515

string if "none" was specified in /etc/crypttab. So if

545

516

argument was empty, we ignore it silently. */

546

if(arg[0] == '\0'){

547

break;

517

if(arg[0] != '\0'){

518

fprintf(stderr, "Ignoring unknown argument \"%s\"\n", arg);

548

519

}

520

break;

521

case ARGP_KEY_END:

522

break;

549

523

default:

550

524

return ARGP_ERR_UNKNOWN;

551

525

}

552

return errno; /* Set to 0 at start */

526

return 0;

553

527

}

554

528

555

529

/* This option parser is the same as parse_opt() above, except it

557

531

error_t parse_opt_config_file(int key, char *arg,

558

532

__attribute__((unused))

559

533

struct argp_state *state){

560

errno = 0;

561

534

switch(key){

562

535

case 'g': /* --global-options */

563

536

case 'G': /* --global-env */

570

543

case 129: /* --config-file */

571

544

free(argfile);

572

545

argfile = strdup(arg);

546

if(argfile == NULL){

547

perror("strdup");

548

}

573

549

break;

574

550

case 130: /* --userid */

575

551

case 131: /* --groupid */

576

552

case 132: /* --debug */

577

case '?': /* --help */

578

case -3: /* --usage */

579

case 'V': /* --version */

580

553

case ARGP_KEY_ARG:

554

case ARGP_KEY_END:

581

555

break;

582

556

default:

583

557

return ARGP_ERR_UNKNOWN;

584

558

}

585

return errno;

559

return 0;

586

560

}

587

561

588

562

struct argp argp = { .options = options,

592

566

593

567

/* Parse using parse_opt_config_file() in order to get the custom

594

568

config file location, if any. */

595

ret = argp_parse(&argp, argc, argv,

596

ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,

597

NULL, NULL);

598

switch(ret){

599

case 0:

600

break;

601

case ENOMEM:

602

default:

603

errno = ret;

604

error(0, errno, "argp_parse");

605

exitstatus = EX_OSERR;

606

goto fallback;

607

case EINVAL:

608

exitstatus = EX_USAGE;

569

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

570

if(ret == ARGP_ERR_UNKNOWN){

571

fprintf(stderr, "Unknown error while parsing arguments\n");

572

exitstatus = EXIT_FAILURE;

609

573

goto fallback;

610

574

}

611

575

628

592

custom_argc = 1;

629

593

custom_argv = malloc(sizeof(char*) * 2);

630

594

if(custom_argv == NULL){

631

error(0, errno, "malloc");

632

exitstatus = EX_OSERR;

595

perror("malloc");

596

exitstatus = EXIT_FAILURE;

633

597

goto fallback;

634

598

}

635

599

custom_argv[0] = argv[0];

651

615

}

652

616

new_arg = strdup(p);

653

617

if(new_arg == NULL){

654

error(0, errno, "strdup");

655

exitstatus = EX_OSERR;

618

perror("strdup");

619

exitstatus = EXIT_FAILURE;

656

620

free(org_line);

657

621

goto fallback;

658

622

}

661

625

custom_argv = realloc(custom_argv, sizeof(char *)

662

626

* ((unsigned int) custom_argc + 1));

663

627

if(custom_argv == NULL){

664

error(0, errno, "realloc");

665

exitstatus = EX_OSERR;

628

perror("realloc");

629

exitstatus = EXIT_FAILURE;

666

630

free(org_line);

667

631

goto fallback;

668

632

}

674

638

ret = fclose(conffp);

675

639

} while(ret == EOF and errno == EINTR);

676

640

if(ret == EOF){

677

error(0, errno, "fclose");

678

exitstatus = EX_IOERR;

641

perror("fclose");

642

exitstatus = EXIT_FAILURE;

679

643

goto fallback;

680

644

}

681

645

free(org_line);

683

647

/* Check for harmful errors and go to fallback. Other errors might

684

648

not affect opening plugins */

685

649

if(errno == EMFILE or errno == ENFILE or errno == ENOMEM){

686

error(0, errno, "fopen");

687

exitstatus = EX_OSERR;

650

perror("fopen");

651

exitstatus = EXIT_FAILURE;

688

652

goto fallback;

689

653

}

690

654

}

691

/* If there were any arguments from the configuration file, pass

692

them to parser as command line arguments */

655

/* If there was any arguments from configuration file,

656

pass them to parser as command arguments */

693

657

if(custom_argv != NULL){

694

ret = argp_parse(&argp, custom_argc, custom_argv,

695

ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,

696

NULL, NULL);

697

switch(ret){

698

case 0:

699

break;

700

case ENOMEM:

701

default:

702

errno = ret;

703

error(0, errno, "argp_parse");

704

exitstatus = EX_OSERR;

705

goto fallback;

706

case EINVAL:

707

exitstatus = EX_CONFIG;

658

ret = argp_parse(&argp, custom_argc, custom_argv, ARGP_IN_ORDER,

659

0, NULL);

660

if(ret == ARGP_ERR_UNKNOWN){

661

fprintf(stderr, "Unknown error while parsing arguments\n");

662

exitstatus = EXIT_FAILURE;

708

663

goto fallback;

709

664

}

710

665

}

711

666

712

667

/* Parse actual command line arguments, to let them override the

713

668

config file */

714

ret = argp_parse(&argp, argc, argv,

715

ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,

716

NULL, NULL);

717

switch(ret){

718

case 0:

719

break;

720

case ENOMEM:

721

default:

722

errno = ret;

723

error(0, errno, "argp_parse");

724

exitstatus = EX_OSERR;

725

goto fallback;

726

case EINVAL:

727

exitstatus = EX_USAGE;

669

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

670

if(ret == ARGP_ERR_UNKNOWN){

671

fprintf(stderr, "Unknown error while parsing arguments\n");

672

exitstatus = EXIT_FAILURE;

728

673

goto fallback;

729

674

}

730

675

745

690

/* Strip permissions down to nobody */

746

691

setgid(gid);

747

692

if(ret == -1){

748

error(0, errno, "setgid");

693

perror("setgid");

749

694

}

750

695

ret = setuid(uid);

751

696

if(ret == -1){

752

error(0, errno, "setuid");

753

}

754

755

/* Open plugin directory with close_on_exec flag */

697

perror("setuid");

698

}

699

700

if(plugindir == NULL){

701

dir = opendir(PDIR);

702

} else {

703

dir = opendir(plugindir);

704

}

705

706

if(dir == NULL){

707

perror("Could not open plugin dir");

708

exitstatus = EXIT_FAILURE;

709

goto fallback;

710

}

711

712

/* Set the FD_CLOEXEC flag on the directory, if possible */

756

713

{

757

int dir_fd = -1;

758

if(plugindir == NULL){

759

dir_fd = open(PDIR, O_RDONLY |

760

#ifdef O_CLOEXEC

761

O_CLOEXEC

762

#else /* not O_CLOEXEC */

763

0

764

#endif /* not O_CLOEXEC */

765

);

766

} else {

767

dir_fd = open(plugindir, O_RDONLY |

768

#ifdef O_CLOEXEC

769

O_CLOEXEC

770

#else /* not O_CLOEXEC */

771

0

772

#endif /* not O_CLOEXEC */

773

);

774

}

775

if(dir_fd == -1){

776

error(0, errno, "Could not open plugin dir");

777

exitstatus = EX_UNAVAILABLE;

778

goto fallback;

779

}

780

781

#ifndef O_CLOEXEC

782

/* Set the FD_CLOEXEC flag on the directory */

783

ret = set_cloexec_flag(dir_fd);

784

if(ret < 0){

785

error(0, errno, "set_cloexec_flag");

786

TEMP_FAILURE_RETRY(close(dir_fd));

787

exitstatus = EX_OSERR;

788

goto fallback;

789

}

790

#endif /* O_CLOEXEC */

791

792

dir = fdopendir(dir_fd);

793

if(dir == NULL){

794

error(0, errno, "Could not open plugin dir");

795

TEMP_FAILURE_RETRY(close(dir_fd));

796

exitstatus = EX_OSERR;

797

goto fallback;

714

int dir_fd = dirfd(dir);

715

if(dir_fd >= 0){

716

ret = set_cloexec_flag(dir_fd);

717

if(ret < 0){

718

perror("set_cloexec_flag");

719

exitstatus = EXIT_FAILURE;

720

goto fallback;

721

}

798

722

}

799

723

}

800

724

809

733

/* All directory entries have been processed */

810

734

if(dirst == NULL){

811

735

if(errno == EBADF){

812

error(0, errno, "readdir");

813

exitstatus = EX_IOERR;

736

perror("readdir");

737

exitstatus = EXIT_FAILURE;

814

738

goto fallback;

815

739

}

816

740

break;

846

770

for(const char **suf = bad_suffixes; *suf != NULL; suf++){

847

771

size_t suf_len = strlen(*suf);

848

772

if((d_name_len >= suf_len)

849

and (strcmp((dirst->d_name) + d_name_len-suf_len, *suf)

773

and (strcmp((dirst->d_name)+d_name_len-suf_len, *suf)

850

774

== 0)){

851

775

if(debug){

852

776

fprintf(stderr, "Ignoring plugin dir entry \"%s\""

864

788

865

789

char *filename;

866

790

if(plugindir == NULL){

867

ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",

868

dirst->d_name));

791

ret = TEMP_FAILURE_RETRY(asprintf(&filename, PDIR "/%s",

792

dirst->d_name));

869

793

} else {

870

ret = (int)TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s",

871

plugindir,

872

dirst->d_name));

794

ret = TEMP_FAILURE_RETRY(asprintf(&filename, "%s/%s", plugindir,

795

dirst->d_name));

873

796

}

874

797

if(ret < 0){

875

error(0, errno, "asprintf");

798

perror("asprintf");

876

799

continue;

877

800

}

878

801

879

ret = (int)TEMP_FAILURE_RETRY(stat(filename, &st));

802

ret = TEMP_FAILURE_RETRY(stat(filename, &st));

880

803

if(ret == -1){

881

error(0, errno, "stat");

804

perror("stat");

882

805

free(filename);

883

806

continue;

884

807

}

896

819

897

820

plugin *p = getplugin(dirst->d_name);

898

821

if(p == NULL){

899

error(0, errno, "getplugin");

822

perror("getplugin");

900

823

free(filename);

901

824

continue;

902

825

}

914

837

if(g != NULL){

915

838

for(char **a = g->argv + 1; *a != NULL; a++){

916

839

if(not add_argument(p, *a)){

917

error(0, errno, "add_argument");

840

perror("add_argument");

918

841

}

919

842

}

920

843

/* Add global environment variables */

921

844

for(char **e = g->environ; *e != NULL; e++){

922

845

if(not add_environment(p, *e, false)){

923

error(0, errno, "add_environment");

846

perror("add_environment");

924

847

}

925

848

}

926

849

}

931

854

if(p->environ[0] != NULL){

932

855

for(char **e = environ; *e != NULL; e++){

933

856

if(not add_environment(p, *e, false)){

934

error(0, errno, "add_environment");

857

perror("add_environment");

935

858

}

936

859

}

937

860

}

938

861

939

862

int pipefd[2];

940

ret = (int)TEMP_FAILURE_RETRY(pipe(pipefd));

863

ret = TEMP_FAILURE_RETRY(pipe(pipefd));

941

864

if(ret == -1){

942

error(0, errno, "pipe");

943

exitstatus = EX_OSERR;

865

perror("pipe");

866

exitstatus = EXIT_FAILURE;

944

867

goto fallback;

945

868

}

946

869

/* Ask OS to automatic close the pipe on exec */

947

870

ret = set_cloexec_flag(pipefd[0]);

948

871

if(ret < 0){

949

error(0, errno, "set_cloexec_flag");

950

exitstatus = EX_OSERR;

872

perror("set_cloexec_flag");

873

exitstatus = EXIT_FAILURE;

951

874

goto fallback;

952

875

}

953

876

ret = set_cloexec_flag(pipefd[1]);

954

877

if(ret < 0){

955

error(0, errno, "set_cloexec_flag");

956

exitstatus = EX_OSERR;

878

perror("set_cloexec_flag");

879

exitstatus = EXIT_FAILURE;

957

880

goto fallback;

958

881

}

959

882

/* Block SIGCHLD until process is safely in process list */

960

ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,

961

&sigchld_action.sa_mask,

962

NULL));

883

ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,

884

&sigchld_action.sa_mask,

885

NULL));

963

886

if(ret < 0){

964

error(0, errno, "sigprocmask");

965

exitstatus = EX_OSERR;

887

perror("sigprocmask");

888

exitstatus = EXIT_FAILURE;

966

889

goto fallback;

967

890

}

968

891

/* Starting a new process to be watched */

971

894

pid = fork();

972

895

} while(pid == -1 and errno == EINTR);

973

896

if(pid == -1){

974

error(0, errno, "fork");

975

exitstatus = EX_OSERR;

897

perror("fork");

898

exitstatus = EXIT_FAILURE;

976

899

goto fallback;

977

900

}

978

901

if(pid == 0){

979

902

/* this is the child process */

980

903

ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);

981

904

if(ret < 0){

982

error(0, errno, "sigaction");

983

_exit(EX_OSERR);

905

perror("sigaction");

906

_exit(EXIT_FAILURE);

984

907

}

985

908

ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);

986

909

if(ret < 0){

987

error(0, errno, "sigprocmask");

988

_exit(EX_OSERR);

910

perror("sigprocmask");

911

_exit(EXIT_FAILURE);

989

912

}

990

913

991

914

ret = dup2(pipefd[1], STDOUT_FILENO); /* replace our stdout */

992

915

if(ret == -1){

993

error(0, errno, "dup2");

994

_exit(EX_OSERR);

916

perror("dup2");

917

_exit(EXIT_FAILURE);

995

918

}

996

919

997

920

if(dirfd(dir) < 0){

1001

924

}

1002

925

if(p->environ[0] == NULL){

1003

926

if(execv(filename, p->argv) < 0){

1004

error(0, errno, "execv for %s", filename);

1005

_exit(EX_OSERR);

927

perror("execv");

928

_exit(EXIT_FAILURE);

1006

929

}

1007

930

} else {

1008

931

if(execve(filename, p->argv, p->environ) < 0){

1009

error(0, errno, "execve for %s", filename);

1010

_exit(EX_OSERR);

932

perror("execve");

933

_exit(EXIT_FAILURE);

1011

934

}

1012

935

}

1013

936

/* no return */

1018

941

free(filename);

1019

942

plugin *new_plugin = getplugin(dirst->d_name);

1020

943

if(new_plugin == NULL){

1021

error(0, errno, "getplugin");

1022

ret = (int)(TEMP_FAILURE_RETRY

1023

(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,

1024

NULL)));

944

perror("getplugin");

945

ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,

946

&sigchld_action.sa_mask,

947

NULL));

1025

948

if(ret < 0){

1026

error(0, errno, "sigprocmask");

949

perror("sigprocmask");

1027

950

}

1028

exitstatus = EX_OSERR;

951

exitstatus = EXIT_FAILURE;

1029

952

goto fallback;

1030

953

}

1031

954

1034

957

1035

958

/* Unblock SIGCHLD so signal handler can be run if this process

1036

959

has already completed */

1037

ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,

1038

&sigchld_action.sa_mask,

1039

NULL));

960

ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,

961

&sigchld_action.sa_mask,

962

NULL));

1040

963

if(ret < 0){

1041

error(0, errno, "sigprocmask");

1042

exitstatus = EX_OSERR;

964

perror("sigprocmask");

965

exitstatus = EXIT_FAILURE;

1043

966

goto fallback;

1044

967

}

1045

968

1046

FD_SET(new_plugin->fd, &rfds_all); /* Spurious warning from

1047

-Wconversion */

969

FD_SET(new_plugin->fd, &rfds_all);

1048

970

1049

971

if(maxfd < new_plugin->fd){

1050

972

maxfd = new_plugin->fd;

1071

993

fd_set rfds = rfds_all;

1072

994

int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);

1073

995

if(select_ret == -1 and errno != EINTR){

1074

error(0, errno, "select");

1075

exitstatus = EX_OSERR;

996

perror("select");

997

exitstatus = EXIT_FAILURE;

1076

998

goto fallback;

1077

999

}

1078

1000

/* OK, now either a process completed, or something can be read

1104

1026

}

1105

1027

1106

1028

/* Remove the plugin */

1107

FD_CLR(proc->fd, &rfds_all); /* Spurious warning from

1108

-Wconversion */

1029

FD_CLR(proc->fd, &rfds_all);

1109

1030

1110

1031

/* Block signal while modifying process_list */

1111

ret = (int)TEMP_FAILURE_RETRY(sigprocmask

1112

(SIG_BLOCK,

1113

&sigchld_action.sa_mask,

1114

NULL));

1032

ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,

1033

&sigchld_action.sa_mask,

1034

NULL));

1115

1035

if(ret < 0){

1116

error(0, errno, "sigprocmask");

1117

exitstatus = EX_OSERR;

1036

perror("sigprocmask");

1037

exitstatus = EXIT_FAILURE;

1118

1038

goto fallback;

1119

1039

}

1120

1040

1123

1043

proc = next_plugin;

1124

1044

1125

1045

/* We are done modifying process list, so unblock signal */

1126

ret = (int)(TEMP_FAILURE_RETRY

1127

(sigprocmask(SIG_UNBLOCK,

1128

&sigchld_action.sa_mask, NULL)));

1046

ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,

1047

&sigchld_action.sa_mask,

1048

NULL));

1129

1049

if(ret < 0){

1130

error(0, errno, "sigprocmask");

1131

exitstatus = EX_OSERR;

1050

perror("sigprocmask");

1051

exitstatus = EXIT_FAILURE;

1132

1052

goto fallback;

1133

1053

}

1134

1054

1144

1064

bool bret = print_out_password(proc->buffer,

1145

1065

proc->buffer_length);

1146

1066

if(not bret){

1147

error(0, errno, "print_out_password");

1148

exitstatus = EX_IOERR;

1067

perror("print_out_password");

1068

exitstatus = EXIT_FAILURE;

1149

1069

}

1150

1070

goto fallback;

1151

1071

}

1152

1072

1153

1073

/* This process has not completed. Does it have any output? */

1154

if(proc->eof or not FD_ISSET(proc->fd, &rfds)){ /* Spurious

1155

warning from

1156

-Wconversion */

1074

if(proc->eof or not FD_ISSET(proc->fd, &rfds)){

1157

1075

/* This process had nothing to say at this time */

1158

1076

proc = proc->next;

1159

1077

continue;

1163

1081

proc->buffer = realloc(proc->buffer, proc->buffer_size

1164

1082

+ (size_t) BUFFER_SIZE);

1165

1083

if(proc->buffer == NULL){

1166

error(0, errno, "malloc");

1167

exitstatus = EX_OSERR;

1084

perror("malloc");

1085

exitstatus = EXIT_FAILURE;

1168

1086

goto fallback;

1169

1087

}

1170

1088

proc->buffer_size += BUFFER_SIZE;

1191

1109

1192

1110

fallback:

1193

1111

1194

if(plugin_list == NULL or (exitstatus != EXIT_SUCCESS

1195

and exitstatus != EX_OK)){

1112

if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){

1196

1113

/* Fallback if all plugins failed, none are found or an error

1197

1114

occured */

1198

1115

bool bret;

1206

1123

}

1207

1124

bret = print_out_password(passwordbuffer, len);

1208

1125

if(not bret){

1209

error(0, errno, "print_out_password");

1210

exitstatus = EX_IOERR;

1126

perror("print_out_password");

1127

exitstatus = EXIT_FAILURE;

1211

1128

}

1212

1129

}

1213

1130

1214

1131

/* Restore old signal handler */

1215

1132

ret = sigaction(SIGCHLD, &old_sigchld_action, NULL);

1216

1133

if(ret == -1){

1217

error(0, errno, "sigaction");

1218

exitstatus = EX_OSERR;

1134

perror("sigaction");

1135

exitstatus = EXIT_FAILURE;

1219

1136

}

1220

1137

1221

1138

if(custom_argv != NULL){

1236

1153

ret = kill(p->pid, SIGTERM);

1237

1154

if(ret == -1 and errno != ESRCH){

1238

1155

/* Set-uid proccesses might not get closed */

1239

error(0, errno, "kill");

1156

perror("kill");

1240

1157

}

1241

1158

}

1242

1159

}

1246

1163

ret = wait(NULL);

1247

1164

} while(ret >= 0);

1248

1165

if(errno != ECHILD){

1249

error(0, errno, "wait");

1166

perror("wait");

1250

1167

}

1251

1168

1252

1169

free_plugin_list();