/mandos/trunk : revision 133

2

/*

3

* Mandos plugin runner - Run Mandos plugins

4

*

5

6

5

7

6

*

8

7

* This program is free software: you can redistribute it and/or

9

8

* modify it under the terms of the GNU General Public License as

28

27

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

29

28

EXIT_SUCCESS, realloc() */

30

29

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

31

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

32

stderr, STDOUT_FILENO */

30

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

31

fprintf(), stderr, STDOUT_FILENO */

33

32

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

34

33

stat, waitpid(), WIFEXITED(),

35

34

WEXITSTATUS(), wait(), pid_t,

38

37

#include <sys/select.h> /* fd_set, select(), FD_ZERO(),

39

38

FD_SET(), FD_ISSET(), FD_CLR */

40

39

#include <sys/wait.h> /* wait(), waitpid(), WIFEXITED(),

41

WEXITSTATUS(), WTERMSIG(),

42

WCOREDUMP() */

40

WEXITSTATUS() */

43

41

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

44

42

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

45

43

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

48

46

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

49

47

F_GETFD, F_SETFD, FD_CLOEXEC,

50

48

access(), pipe(), fork(), close()

51

dup2(), STDOUT_FILENO, _exit(),

49

dup2, STDOUT_FILENO, _exit(),

52

50

execv(), write(), read(),

53

51

close() */

54

52

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

55

53

FD_CLOEXEC */

56

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

57

strsignal() */

54

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

58

55

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

59

56

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

60

57

argp_state, struct argp,

64

61

#include <signal.h> /* struct sigaction, sigemptyset(),

65

62

sigaddset(), sigaction(),

66

63

sigprocmask(), SIG_BLOCK, SIGCHLD,

67

SIG_UNBLOCK, kill(), sig_atomic_t

68

*/

64

SIG_UNBLOCK, kill() */

69

65

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

70

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

71

66

72

67

#define BUFFER_SIZE 256

73

68

74

69

#define PDIR "/lib/mandos/plugins.d"

75

70

#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"

76

71

77

const char *argp_program_version = "plugin-runner " VERSION;

72

const char *argp_program_version = "plugin-runner 1.0";

78

73

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

79

74

75

struct plugin;

76

80

77

typedef struct plugin{

81

78

char *name; /* can be NULL or any plugin name */

82

79

char **argv;

84

81

char **environ;

85

82

int envc;

86

83

bool disabled;

87

84

88

85

/* Variables used for running processes*/

89

86

pid_t pid;

90

87

int fd;

92

89

size_t buffer_size;

93

90

size_t buffer_length;

94

91

bool eof;

95

volatile sig_atomic_t completed;

96

int status;

92

volatile bool completed;

93

volatile int status;

97

94

struct plugin *next;

98

95

} plugin;

99

96

100

97

static plugin *plugin_list = NULL;

101

98

102

/* Gets an existing plugin based on name,

99

/* Gets a existing plugin based on name,

103

100

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

104

101

static plugin *getplugin(char *name){

105

102

/* Check for exiting plugin with that name */

106

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

107

if((p->name == name)

108

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

103

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

104

if ((p->name == name)

105

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

109

106

return p;

110

107

}

111

108

}

112

109

/* Create a new plugin */

113

110

plugin *new_plugin = malloc(sizeof(plugin));

114

if(new_plugin == NULL){

111

if (new_plugin == NULL){

115

112

return NULL;

116

113

}

117

114

char *copy_name = NULL;

118

115

if(name != NULL){

119

116

copy_name = strdup(name);

120

117

if(copy_name == NULL){

121

free(new_plugin);

122

118

return NULL;

123

119

}

124

120

}

125

126

*new_plugin = (plugin){ .name = copy_name,

127

.argc = 1,

128

.disabled = false,

129

.next = plugin_list };

121

122

*new_plugin = (plugin) { .name = copy_name,

123

.argc = 1,

124

.disabled = false,

125

.next = plugin_list };

130

126

131

127

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

132

if(new_plugin->argv == NULL){

128

if (new_plugin->argv == NULL){

133

129

free(copy_name);

134

130

free(new_plugin);

135

131

return NULL;

136

132

}

137

133

new_plugin->argv[0] = copy_name;

138

134

new_plugin->argv[1] = NULL;

139

135

140

136

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

141

137

if(new_plugin->environ == NULL){

142

138

free(copy_name);

145

141

return NULL;

146

142

}

147

143

new_plugin->environ[0] = NULL;

148

144

149

145

/* Append the new plugin to the list */

150

146

plugin_list = new_plugin;

151

147

return new_plugin;

183

179

}

184

180

185

181

/* Add to a plugin's environment */

186

static bool add_environment(plugin *p, const char *def, bool replace){

182

static bool add_environment(plugin *p, const char *def){

187

183

if(p == NULL){

188

184

return false;

189

185

}

190

/* namelen = length of name of environment variable */

191

size_t namelen = (size_t)(strchrnul(def, '=') - def);

192

/* Search for this environment variable */

193

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

194

if(strncmp(*e, def, namelen + 1) == 0){

195

/* It already exists */

196

if(replace){

197

char *new = realloc(*e, strlen(def) + 1);

198

if(new == NULL){

199

return false;

200

}

201

*e = new;

202

strcpy(*e, def);

203

}

204

return true;

205

}

206

}

207

186

return add_to_char_array(def, &(p->environ), &(p->envc));

208

187

}

209

188

212

191

* Descriptor Flags".

213

192

* *Note File Descriptor Flags:(libc)Descriptor Flags.

214

193

*/

215

static int set_cloexec_flag(int fd){

194

static int set_cloexec_flag(int fd)

195

{

216

196

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

217

197

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

218

198

if(ret < 0){

225

205

226

206

/* Mark processes as completed when they exit, and save their exit

227

207

status. */

228

static void handle_sigchld(__attribute__((unused)) int sig){

229

int old_errno = errno;

208

void handle_sigchld(__attribute__((unused)) int sig){

230

209

while(true){

231

210

plugin *proc = plugin_list;

232

211

int status;

236

215

break;

237

216

}

238

217

if(pid == -1){

239

if(errno == ECHILD){

240

/* No child processes */

241

break;

218

if (errno != ECHILD){

219

perror("waitpid");

242

220

}

243

perror("waitpid");

221

/* No child processes */

222

break;

244

223

}

245

224

246

225

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

247

226

while(proc != NULL and proc->pid != pid){

248

227

proc = proc->next;

252

231

continue;

253

232

}

254

233

proc->status = status;

255

proc->completed = 1;

234

proc->completed = true;

256

235

}

257

errno = old_errno;

258

236

}

259

237

260

238

/* Prints out a password to stdout */

261

static bool print_out_password(const char *buffer, size_t length){

239

bool print_out_password(const char *buffer, size_t length){

262

240

ssize_t ret;

241

if(length>0 and buffer[length-1] == '\n'){

242

length--;

243

}

263

244

for(size_t written = 0; written < length; written += (size_t)ret){

264

245

ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,

265

246

length - written));

282

263

}

283

264

free(plugin_node->environ);

284

265

free(plugin_node->buffer);

285

266

286

267

/* Removes the plugin from the singly-linked list */

287

268

if(plugin_node == plugin_list){

288

269

/* First one - simple */

316

297

struct stat st;

317

298

fd_set rfds_all;

318

299

int ret, maxfd = 0;

319

ssize_t sret;

320

intmax_t tmpmax;

321

300

uid_t uid = 65534;

322

301

gid_t gid = 65534;

323

302

bool debug = false;

348

327

{ .name = "global-options", .key = 'g',

349

328

.arg = "OPTION[,OPTION[,...]]",

350

329

.doc = "Options passed to all plugins" },

351

{ .name = "global-env", .key = 'G',

330

{ .name = "global-envs", .key = 'e',

352

331

.arg = "VAR=value",

353

332

.doc = "Environment variable passed to all plugins" },

354

333

{ .name = "options-for", .key = 'o',

355

334

.arg = "PLUGIN:OPTION[,OPTION[,...]]",

356

335

.doc = "Options passed only to specified plugin" },

357

{ .name = "env-for", .key = 'E',

336

{ .name = "envs-for", .key = 'f',

358

337

.arg = "PLUGIN:ENV=value",

359

338

.doc = "Environment variable passed to specified plugin" },

360

339

{ .name = "disable", .key = 'd',

361

340

.arg = "PLUGIN",

362

341

.doc = "Disable a specific plugin", .group = 1 },

363

{ .name = "enable", .key = 'e',

364

.arg = "PLUGIN",

365

.doc = "Enable a specific plugin", .group = 1 },

366

342

{ .name = "plugin-dir", .key = 128,

367

343

.arg = "DIRECTORY",

368

344

.doc = "Specify a different plugin directory", .group = 2 },

380

356

{ .name = NULL }

381

357

};

382

358

383

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

384

struct argp_state *state){

385

char *tmp;

386

switch(key){

359

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

360

struct argp_state *state) {

361

/* Get the INPUT argument from `argp_parse', which we know is a

362

pointer to our plugin list pointer. */

363

switch (key) {

387

364

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

388

if(arg != NULL){

389

char *plugin_option;

390

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

391

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

365

if (arg != NULL){

366

char *p;

367

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

368

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

392

369

continue;

393

370

}

394

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

371

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

395

372

perror("add_argument");

396

373

return ARGP_ERR_UNKNOWN;

397

374

}

398

375

}

399

376

}

400

377

break;

401

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

378

case 'e': /* --global-envs */

402

379

if(arg == NULL){

403

380

break;

404

381

}

405

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

406

perror("add_environment");

382

{

383

char *envdef = strdup(arg);

384

if(envdef == NULL){

385

break;

386

}

387

if(not add_environment(getplugin(NULL), envdef)){

388

perror("add_environment");

389

}

407

390

}

408

391

break;

409

392

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

410

if(arg != NULL){

411

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

412

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

413

break;

414

}

415

char *plugin_option;

416

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

417

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

418

perror("add_argument");

419

return ARGP_ERR_UNKNOWN;

393

if (arg != NULL){

394

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

395

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

396

break;

397

}

398

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

399

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

400

break;

401

}

402

if(opt != NULL){

403

char *p;

404

while((p = strsep(&opt, ",")) != NULL){

405

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

406

continue;

407

}

408

if(not add_argument(getplugin(p_name), p)){

409

perror("add_argument");

410

return ARGP_ERR_UNKNOWN;

411

}

420

412

}

421

413

}

422

414

}

423

415

break;

424

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

416

case 'f': /* --envs-for */

425

417

if(arg == NULL){

426

418

break;

427

419

}

430

422

if(envdef == NULL){

431

423

break;

432

424

}

433

*envdef = '\0';

434

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

425

char *p_name = strndup(arg, (size_t) (envdef-arg));

426

if(p_name == NULL){

427

break;

428

}

429

envdef++;

430

if(not add_environment(getplugin(p_name), envdef)){

435

431

perror("add_environment");

436

432

}

437

433

}

438

434

break;

439

435

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

440

if(arg != NULL){

436

if (arg != NULL){

441

437

plugin *p = getplugin(arg);

442

438

if(p == NULL){

443

439

return ARGP_ERR_UNKNOWN;

445

441

p->disabled = true;

446

442

}

447

443

break;

448

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

449

if(arg != NULL){

450

plugin *p = getplugin(arg);

451

if(p == NULL){

452

return ARGP_ERR_UNKNOWN;

453

}

454

p->disabled = false;

455

}

456

break;

457

444

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

458

free(plugindir);

459

445

plugindir = strdup(arg);

460

446

if(plugindir == NULL){

461

447

perror("strdup");

462

}

463

break;

464

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

465

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

466

break;

467

case 130: /* --userid */

468

errno = 0;

469

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

470

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

471

or tmpmax != (uid_t)tmpmax){

472

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

473

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

474

} else {

475

uid = (uid_t)tmpmax;

476

}

477

break;

478

case 131: /* --groupid */

479

errno = 0;

480

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

481

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

482

or tmpmax != (gid_t)tmpmax){

483

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

484

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

485

} else {

486

gid = (gid_t)tmpmax;

487

}

488

break;

489

case 132: /* --debug */

490

debug = true;

491

break;

492

/*

493

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

494

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

495

*/

496

case ARGP_KEY_ARG:

497

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

498

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

499

argument was empty, we ignore it silently. */

500

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

501

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

502

}

503

break;

504

case ARGP_KEY_END:

505

break;

506

default:

507

return ARGP_ERR_UNKNOWN;

508

}

509

return 0;

510

}

511

512

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

513

ignores everything but the --config-file option. */

514

error_t parse_opt_config_file(int key, char *arg,

515

__attribute__((unused))

516

struct argp_state *state){

517

switch(key){

518

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

519

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

520

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

521

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

522

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

523

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

524

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

525

break;

526

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

527

free(argfile);

448

}

449

break;

450

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

528

451

argfile = strdup(arg);

529

452

if(argfile == NULL){

530

453

perror("strdup");

531

454

}

532

break;

455

break;

533

456

case 130: /* --userid */

457

uid = (uid_t)strtol(arg, NULL, 10);

458

break;

534

459

case 131: /* --groupid */

460

gid = (gid_t)strtol(arg, NULL, 10);

461

break;

535

462

case 132: /* --debug */

463

debug = true;

464

break;

536

465

case ARGP_KEY_ARG:

466

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

467

break;

537

468

case ARGP_KEY_END:

538

469

break;

539

470

default:

542

473

return 0;

543

474

}

544

475

545

struct argp argp = { .options = options,

546

.parser = parse_opt_config_file,

547

.args_doc = "",

476

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

477

.args_doc = "[+PLUS_SEPARATED_OPTIONS]",

548

478

.doc = "Mandos plugin runner -- Run plugins" };

549

479

550

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

551

config file location, if any. */

552

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

553

if(ret == ARGP_ERR_UNKNOWN){

480

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

481

if (ret == ARGP_ERR_UNKNOWN){

554

482

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

555

483

exitstatus = EXIT_FAILURE;

556

484

goto fallback;

557

485

}

558

559

/* Reset to the normal argument parser */

560

argp.parser = parse_opt;

561

562

/* Open the configfile if available */

563

if(argfile == NULL){

486

487

/* Opens the configfile if aviable */

488

if (argfile == NULL){

564

489

conffp = fopen(AFILE, "r");

565

490

} else {

566

491

conffp = fopen(argfile, "r");

567

}

492

}

568

493

if(conffp != NULL){

569

494

char *org_line = NULL;

570

495

char *p, *arg, *new_arg, *line;

571

496

size_t size = 0;

497

ssize_t sret;

572

498

const char whitespace_delims[] = " \r\t\f\v\n";

573

499

const char comment_delim[] = "#";

574

500

575

501

custom_argc = 1;

576

502

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

577

503

if(custom_argv == NULL){

581

507

}

582

508

custom_argv[0] = argv[0];

583

509

custom_argv[1] = NULL;

584

510

585

511

/* for each line in the config file, strip whitespace and ignore

586

512

commented text */

587

513

while(true){

589

515

if(sret == -1){

590

516

break;

591

517

}

592

518

593

519

line = org_line;

594

520

arg = strsep(&line, comment_delim);

595

521

while((p = strsep(&arg, whitespace_delims)) != NULL){

614

540

goto fallback;

615

541

}

616

542

custom_argv[custom_argc-1] = new_arg;

617

custom_argv[custom_argc] = NULL;

543

custom_argv[custom_argc] = NULL;

618

544

}

619

545

}

620

546

free(org_line);

621

} else {

547

} else{

622

548

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

623

549

not affect opening plugins */

624

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

550

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

625

551

perror("fopen");

626

552

exitstatus = EXIT_FAILURE;

627

553

goto fallback;

630

556

/* If there was any arguments from configuration file,

631

557

pass them to parser as command arguments */

632

558

if(custom_argv != NULL){

633

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

634

0, NULL);

635

if(ret == ARGP_ERR_UNKNOWN){

559

ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, NULL);

560

if (ret == ARGP_ERR_UNKNOWN){

636

561

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

637

562

exitstatus = EXIT_FAILURE;

638

563

goto fallback;

639

564

}

640

565

}

641

566

642

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

643

config file */

644

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

645

if(ret == ARGP_ERR_UNKNOWN){

646

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

647

exitstatus = EXIT_FAILURE;

648

goto fallback;

649

}

650

651

567

if(debug){

652

568

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

653

569

fprintf(stderr, "Plugin: %s has %d arguments\n",

655

571

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

656

572

fprintf(stderr, "\tArg: %s\n", *a);

657

573

}

658

fprintf(stderr, "...and %d environment variables\n", p->envc);

574

fprintf(stderr, "...and %u environment variables\n", p->envc);

659

575

for(char **a = p->environ; *a != NULL; a++){

660

576

fprintf(stderr, "\t%s\n", *a);

661

577

}

662

578

}

663

579

}

664

580

665

581

/* Strip permissions down to nobody */

582

ret = setuid(uid);

583

if (ret == -1){

584

perror("setuid");

585

}

666

586

setgid(gid);

667

if(ret == -1){

587

if (ret == -1){

668

588

perror("setgid");

669

589

}

670

ret = setuid(uid);

671

if(ret == -1){

672

perror("setuid");

673

}

674

675

if(plugindir == NULL){

590

591

if (plugindir == NULL){

676

592

dir = opendir(PDIR);

677

593

} else {

678

594

dir = opendir(plugindir);

698

614

}

699

615

700

616

FD_ZERO(&rfds_all);

701

617

702

618

/* Read and execute any executable in the plugin directory*/

703

619

while(true){

704

620

dirst = readdir(dir);

705

621

706

/* All directory entries have been processed */

622

// All directory entries have been processed

707

623

if(dirst == NULL){

708

if(errno == EBADF){

624

if (errno == EBADF){

709

625

perror("readdir");

710

626

exitstatus = EXIT_FAILURE;

711

627

goto fallback;

715

631

716

632

d_name_len = strlen(dirst->d_name);

717

633

718

/* Ignore dotfiles, backup files and other junk */

634

// Ignore dotfiles, backup files and other junk

719

635

{

720

636

bool bad_name = false;

721

637

723

639

724

640

const char const *bad_suffixes[] = { "~", "#", ".dpkg-new",

725

641

".dpkg-old",

726

".dpkg-bak",

727

642

".dpkg-divert", NULL };

728

643

for(const char **pre = bad_prefixes; *pre != NULL; pre++){

729

644

size_t pre_len = strlen(*pre);

758

673

continue;

759

674

}

760

675

}

761

676

762

677

char *filename;

763

if(plugindir == NULL){

764

ret = asprintf(&filename, PDIR "/%s", dirst->d_name);

765

} else {

766

ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);

767

}

678

ret = asprintf(&filename, "%s/%s", plugindir, dirst->d_name);

768

679

if(ret < 0){

769

680

perror("asprintf");

770

681

continue;

771

682

}

772

683

773

684

ret = stat(filename, &st);

774

if(ret == -1){

685

if (ret == -1){

775

686

perror("stat");

776

687

free(filename);

777

688

continue;

778

689

}

779

690

780

691

/* Ignore non-executable files */

781

if(not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){

692

if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){

782

693

if(debug){

783

694

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

784

695

" with bad type or mode\n", filename);

812

723

}

813

724

/* Add global environment variables */

814

725

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

815

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

726

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

816

727

perror("add_environment");

817

728

}

818

729

}

823

734

process, too. */

824

735

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

825

736

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

826

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

737

char *copy = strdup(*e);

738

if(copy == NULL){

739

perror("strdup");

740

continue;

741

}

742

if(not add_environment(p, copy)){

827

743

perror("add_environment");

828

744

}

829

745

}

831

747

832

748

int pipefd[2];

833

749

ret = pipe(pipefd);

834

if(ret == -1){

750

if (ret == -1){

835

751

perror("pipe");

836

752

exitstatus = EXIT_FAILURE;

837

753

goto fallback;

850

766

goto fallback;

851

767

}

852

768

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

853

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

769

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

854

770

if(ret < 0){

855

771

perror("sigprocmask");

856

772

exitstatus = EXIT_FAILURE;

857

773

goto fallback;

858

774

}

859

/* Starting a new process to be watched */

775

// Starting a new process to be watched

860

776

pid_t pid = fork();

861

777

if(pid == -1){

862

778

perror("fork");

870

786

perror("sigaction");

871

787

_exit(EXIT_FAILURE);

872

788

}

873

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

789

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

874

790

if(ret < 0){

875

791

perror("sigprocmask");

876

792

_exit(EXIT_FAILURE);

877

793

}

878

794

879

795

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

880

796

if(ret == -1){

881

797

perror("dup2");

904

820

close(pipefd[1]); /* Close unused write end of pipe */

905

821

free(filename);

906

822

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

907

if(new_plugin == NULL){

823

if (new_plugin == NULL){

908

824

perror("getplugin");

909

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

825

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

910

826

if(ret < 0){

911

827

perror("sigprocmask");

912

828

}

919

835

920

836

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

921

837

has already completed */

922

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

838

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

923

839

if(ret < 0){

924

840

perror("sigprocmask");

925

841

exitstatus = EXIT_FAILURE;

928

844

929

845

FD_SET(new_plugin->fd, &rfds_all);

930

846

931

if(maxfd < new_plugin->fd){

847

if (maxfd < new_plugin->fd){

932

848

maxfd = new_plugin->fd;

933

849

}

850

934

851

}

935

852

936

853

closedir(dir);

937

854

dir = NULL;

938

free_plugin(getplugin(NULL));

939

855

940

856

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

941

857

if(p->pid != 0){

942

858

break;

947

863

free_plugin_list();

948

864

}

949

865

}

950

866

951

867

/* Main loop while running plugins exist */

952

868

while(plugin_list){

953

869

fd_set rfds = rfds_all;

954

870

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

955

if(select_ret == -1){

871

if (select_ret == -1){

956

872

perror("select");

957

873

exitstatus = EXIT_FAILURE;

958

874

goto fallback;

959

875

}

960

876

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

961

877

from one of them */

962

for(plugin *proc = plugin_list; proc != NULL;){

878

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

963

879

/* Is this process completely done? */

964

if(proc->completed and proc->eof){

880

if(proc->eof and proc->completed){

965

881

/* Only accept the plugin output if it exited cleanly */

966

882

if(not WIFEXITED(proc->status)

967

883

or WEXITSTATUS(proc->status) != 0){

968

884

/* Bad exit by plugin */

969

885

970

886

if(debug){

971

887

if(WIFEXITED(proc->status)){

972

fprintf(stderr, "Plugin %s [%" PRIdMAX "] exited with"

973

" status %d\n", proc->name,

974

(intmax_t) (proc->pid),

888

fprintf(stderr, "Plugin %u exited with status %d\n",

889

(unsigned int) (proc->pid),

975

890

WEXITSTATUS(proc->status));

976

} else if(WIFSIGNALED(proc->status)){

977

fprintf(stderr, "Plugin %s [%" PRIdMAX "] killed by"

978

" signal %d: %s\n", proc->name,

979

(intmax_t) (proc->pid),

980

WTERMSIG(proc->status),

981

strsignal(WTERMSIG(proc->status)));

891

} else if(WIFSIGNALED(proc->status)) {

892

fprintf(stderr, "Plugin %u killed by signal %d\n",

893

(unsigned int) (proc->pid),

894

WTERMSIG(proc->status));

982

895

} else if(WCOREDUMP(proc->status)){

983

fprintf(stderr, "Plugin %s [%" PRIdMAX "] dumped"

984

" core\n", proc->name, (intmax_t) (proc->pid));

896

fprintf(stderr, "Plugin %d dumped core\n",

897

(unsigned int) (proc->pid));

985

898

}

986

899

}

987

900

988

901

/* Remove the plugin */

989

902

FD_CLR(proc->fd, &rfds_all);

990

903

991

904

/* Block signal while modifying process_list */

992

905

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

993

906

if(ret < 0){

995

908

exitstatus = EXIT_FAILURE;

996

909

goto fallback;

997

910

}

998

999

plugin *next_plugin = proc->next;

1000

911

free_plugin(proc);

1001

proc = next_plugin;

1002

1003

912

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

1004

ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,

1005

NULL);

913

ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,

914

NULL);

1006

915

if(ret < 0){

1007

916

perror("sigprocmask");

1008

917

exitstatus = EXIT_FAILURE;

1012

921

if(plugin_list == NULL){

1013

922

break;

1014

923

}

1015

1016

924

continue;

1017

925

}

1018

926

1019

927

/* This process exited nicely, so print its buffer */

1020

928

1021

929

bool bret = print_out_password(proc->buffer,

1022

930

proc->buffer_length);

1023

931

if(not bret){

1030

938

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

1031

939

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

1032

940

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

1033

proc = proc->next;

1034

941

continue;

1035

942

}

1036

943

/* Before reading, make the process' data buffer large enough */

1037

944

if(proc->buffer_length + BUFFER_SIZE > proc->buffer_size){

1038

945

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

1039

946

+ (size_t) BUFFER_SIZE);

1040

if(proc->buffer == NULL){

947

if (proc->buffer == NULL){

1041

948

perror("malloc");

1042

949

exitstatus = EXIT_FAILURE;

1043

950

goto fallback;

1045

952

proc->buffer_size += BUFFER_SIZE;

1046

953

}

1047

954

/* Read from the process */

1048

sret = read(proc->fd, proc->buffer + proc->buffer_length,

1049

BUFFER_SIZE);

1050

if(sret < 0){

955

ret = read(proc->fd, proc->buffer + proc->buffer_length,

956

BUFFER_SIZE);

957

if(ret < 0){

1051

958

/* Read error from this process; ignore the error */

1052

proc = proc->next;

1053

959

continue;

1054

960

}

1055

if(sret == 0){

961

if(ret == 0){

1056

962

/* got EOF */

1057

963

proc->eof = true;

1058

964

} else {

1059

proc->buffer_length += (size_t) sret;

965

proc->buffer_length += (size_t) ret;

1060

966

}

1061

967

}

1062

968

}

1063

1064

969

970

1065

971

fallback:

1066

972

1067

973

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

1070

976

bool bret;

1071

977

fprintf(stderr, "Going to fallback mode using getpass(3)\n");

1072

978

char *passwordbuffer = getpass("Password: ");

1073

size_t len = strlen(passwordbuffer);

1074

/* Strip trailing newline */

1075

if(len > 0 and passwordbuffer[len-1] == '\n'){

1076

passwordbuffer[len-1] = '\0'; /* not strictly necessary */

1077

len--;

1078

}

1079

bret = print_out_password(passwordbuffer, len);

979

bret = print_out_password(passwordbuffer, strlen(passwordbuffer));

1080

980

if(not bret){

1081

981

perror("print_out_password");

1082

982

exitstatus = EXIT_FAILURE;

1089

989

perror("sigaction");

1090

990

exitstatus = EXIT_FAILURE;

1091

991

}

1092

992

1093

993

if(custom_argv != NULL){

1094

994

for(char **arg = custom_argv+1; *arg != NULL; arg++){

1095

995

free(*arg);

1101

1001

closedir(dir);

1102

1002

}

1103

1003

1104

/* Kill the processes */

1004

/* Free the process list and kill the processes */

1105

1005

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

1106

1006

if(p->pid != 0){

1107

1007

close(p->fd);

1120

1020

if(errno != ECHILD){

1121

1021

perror("wait");

1122

1022

}

1123

1023

1124

1024

free_plugin_list();

1125

1025

1126

1026

free(plugindir);