/mandos/trunk : revision 484

1

/* -*- coding: utf-8 -*- */

1

/* -*- coding: utf-8; mode: c; mode: orgtbl -*- */

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() */

26

asprintf(), O_CLOEXEC */

27

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

28

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

29

EXIT_SUCCESS, realloc() */

28

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

29

realloc() */

30

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

31

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

31

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

32

stderr, STDOUT_FILENO */

33

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

33

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

34

stat, waitpid(), WIFEXITED(),

35

WEXITSTATUS(), wait(), pid_t,

36

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

38

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

39

FD_SET(), FD_ISSET(), FD_CLR */

40

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

41

WEXITSTATUS() */

41

WEXITSTATUS(), WTERMSIG(),

42

WCOREDUMP() */

42

43

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

43

44

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

44

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

45

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

45

46

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

46

47

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

47

48

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

52

53

close() */

53

54

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

54

55

FD_CLOEXEC */

55

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

56

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

57

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

56

58

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

57

59

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

58

60

argp_state, struct argp,

62

64

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

63

65

sigaddset(), sigaction(),

64

66

sigprocmask(), SIG_BLOCK, SIGCHLD,

65

SIG_UNBLOCK, kill() */

67

SIG_UNBLOCK, kill(), sig_atomic_t

68

*/

66

69

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

67

#include <inttypes.h> /* intmax_t, SCNdMAX, PRIdMAX, */

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() */

68

75

69

76

#define BUFFER_SIZE 256

70

77

81

88

char **environ;

82

89

int envc;

83

90

bool disabled;

84

91

85

92

/* Variables used for running processes*/

86

93

pid_t pid;

87

94

int fd;

89

96

size_t buffer_size;

90

97

size_t buffer_length;

91

98

bool eof;

92

volatile bool completed;

93

volatile int status;

99

volatile sig_atomic_t completed;

100

int status;

94

101

struct plugin *next;

95

102

} plugin;

96

103

99

106

/* Gets an existing plugin based on name,

100

107

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

101

108

static plugin *getplugin(char *name){

102

/* Check for exiting plugin with that name */

109

/* Check for existing plugin with that name */

103

110

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

104

111

if((p->name == name)

105

112

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

107

114

}

108

115

}

109

116

/* Create a new plugin */

110

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

117

plugin *new_plugin = NULL;

118

do {

119

new_plugin = malloc(sizeof(plugin));

120

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

111

121

if(new_plugin == NULL){

112

122

return NULL;

113

123

}

114

124

char *copy_name = NULL;

115

125

if(name != NULL){

116

copy_name = strdup(name);

126

do {

127

copy_name = strdup(name);

128

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

117

129

if(copy_name == NULL){

130

int e = errno;

131

free(new_plugin);

132

errno = e;

118

133

return NULL;

119

134

}

120

135

}

121

136

122

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

123

.argc = 1,

124

.disabled = false,

125

.next = plugin_list };

137

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

138

.argc = 1,

139

.disabled = false,

140

.next = plugin_list };

126

141

127

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

142

do {

143

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

144

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

128

145

if(new_plugin->argv == NULL){

146

int e = errno;

129

147

free(copy_name);

130

148

free(new_plugin);

149

errno = e;

131

150

return NULL;

132

151

}

133

152

new_plugin->argv[0] = copy_name;

134

153

new_plugin->argv[1] = NULL;

135

154

136

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

155

do {

156

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

157

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

137

158

if(new_plugin->environ == NULL){

159

int e = errno;

138

160

free(copy_name);

139

161

free(new_plugin->argv);

140

162

free(new_plugin);

163

errno = e;

141

164

return NULL;

142

165

}

143

166

new_plugin->environ[0] = NULL;

151

174

static bool add_to_char_array(const char *new, char ***array,

152

175

int *len){

153

176

/* Resize the pointed-to array to hold one more pointer */

154

*array = realloc(*array, sizeof(char *)

155

* (size_t) ((*len) + 2));

177

do {

178

*array = realloc(*array, sizeof(char *)

179

* (size_t) ((*len) + 2));

180

} while(*array == NULL and errno == EINTR);

156

181

/* Malloc check */

157

182

if(*array == NULL){

158

183

return false;

159

184

}

160

185

/* Make a copy of the new string */

161

char *copy = strdup(new);

186

char *copy;

187

do {

188

copy = strdup(new);

189

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

162

190

if(copy == NULL){

163

191

return false;

164

192

}

190

218

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

191

219

/* It already exists */

192

220

if(replace){

193

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

221

char *new;

222

do {

223

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

224

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

194

225

if(new == NULL){

195

226

return false;

196

227

}

206

237

/*

207

238

* Based on the example in the GNU LibC manual chapter 13.13 "File

208

239

* Descriptor Flags".

209

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

240

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

210

241

*/

211

242

static int set_cloexec_flag(int fd){

212

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

243

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

213

244

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

214

245

if(ret < 0){

215

246

return ret;

216

247

}

217

248

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

218

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

249

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

250

ret | FD_CLOEXEC));

219

251

}

220

252

221

253

222

254

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

223

255

status. */

224

256

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

257

int old_errno = errno;

225

258

while(true){

226

259

plugin *proc = plugin_list;

227

260

int status;

231

264

break;

232

265

}

233

266

if(pid == -1){

234

if(errno != ECHILD){

235

perror("waitpid");

267

if(errno == ECHILD){

268

/* No child processes */

269

break;

236

270

}

237

/* No child processes */

238

break;

271

error(0, errno, "waitpid");

239

272

}

240

273

241

274

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

247

280

continue;

248

281

}

249

282

proc->status = status;

250

proc->completed = true;

283

proc->completed = 1;

251

284

}

285

errno = old_errno;

252

286

}

253

287

254

288

/* Prints out a password to stdout */

276

310

}

277

311

free(plugin_node->environ);

278

312

free(plugin_node->buffer);

279

313

280

314

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

281

315

if(plugin_node == plugin_list){

282

316

/* First one - simple */

309

343

struct dirent *dirst;

310

344

struct stat st;

311

345

fd_set rfds_all;

312

int ret, numchars, maxfd = 0;

346

int ret, maxfd = 0;

313

347

ssize_t sret;

314

intmax_t tmpmax;

315

348

uid_t uid = 65534;

316

349

gid_t gid = 65534;

317

350

bool debug = false;

326

359

sigemptyset(&sigchld_action.sa_mask);

327

360

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

328

361

if(ret == -1){

329

perror("sigaddset");

330

exitstatus = EXIT_FAILURE;

362

error(0, errno, "sigaddset");

363

exitstatus = EX_OSERR;

331

364

goto fallback;

332

365

}

333

366

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

334

367

if(ret == -1){

335

perror("sigaction");

336

exitstatus = EXIT_FAILURE;

368

error(0, errno, "sigaction");

369

exitstatus = EX_OSERR;

337

370

goto fallback;

338

371

}

339

372

371

404

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

372

405

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

373

406

.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 },

374

416

{ .name = NULL }

375

417

};

376

418

377

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

378

struct argp_state *state) {

379

switch(key) {

419

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

420

errno = 0;

421

switch(key){

422

char *tmp;

423

intmax_t tmpmax;

380

424

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

381

if(arg != NULL){

382

char *p;

383

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

384

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

385

continue;

386

}

387

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

388

perror("add_argument");

389

return ARGP_ERR_UNKNOWN;

425

{

426

char *plugin_option;

427

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

428

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

429

break;

390

430

}

391

431

}

392

432

}

393

433

break;

394

434

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

395

if(arg == NULL){

396

break;

397

}

398

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

399

perror("add_environment");

400

}

435

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

401

436

break;

402

437

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

403

if(arg != NULL){

404

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

405

if(p_name[0] == '\0' or arg == NULL){

406

break;

407

}

408

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

409

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

410

break;

411

}

412

char *p;

413

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

414

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

415

continue;

416

}

417

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

418

perror("add_argument");

419

return ARGP_ERR_UNKNOWN;

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;

420

456

}

421

457

}

422

458

}

423

459

break;

424

460

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

425

if(arg == NULL){

426

break;

427

}

428

461

{

429

462

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

430

463

if(envdef == NULL){

464

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

465

errno = EINVAL;

431

466

break;

432

467

}

433

468

*envdef = '\0';

434

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

435

perror("add_environment");

469

envdef++;

470

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

471

argp_error(state, "Empty plugin name");

472

errno = EINVAL;

473

break;

436

474

}

475

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

437

476

}

438

477

break;

439

478

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

440

if(arg != NULL){

479

{

441

480

plugin *p = getplugin(arg);

442

if(p == NULL){

443

return ARGP_ERR_UNKNOWN;

481

if(p != NULL){

482

p->disabled = true;

444

483

}

445

p->disabled = true;

446

484

}

447

485

break;

448

486

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

449

if(arg != NULL){

487

{

450

488

plugin *p = getplugin(arg);

451

if(p == NULL){

452

return ARGP_ERR_UNKNOWN;

489

if(p != NULL){

490

p->disabled = false;

453

491

}

454

p->disabled = false;

455

492

}

456

493

break;

457

494

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

458

495

free(plugindir);

459

496

plugindir = strdup(arg);

460

if(plugindir == NULL){

461

perror("strdup");

462

}

463

497

break;

464

498

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

465

499

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

466

500

break;

467

501

case 130: /* --userid */

468

ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);

469

if(ret < 1 or tmpmax != (uid_t)tmpmax

470

or arg[numchars] != '\0'){

471

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

472

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

473

} else {

474

uid = (uid_t)tmpmax;

502

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

503

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

504

or tmpmax != (uid_t)tmpmax){

505

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

506

PRIdMAX, arg, (intmax_t)uid);

507

break;

475

508

}

509

uid = (uid_t)tmpmax;

476

510

break;

477

511

case 131: /* --groupid */

478

ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);

479

if(ret < 1 or tmpmax != (gid_t)tmpmax

480

or arg[numchars] != '\0'){

481

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

482

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

483

} else {

484

gid = (gid_t)tmpmax;

512

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

513

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

514

or tmpmax != (gid_t)tmpmax){

515

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

516

PRIdMAX, arg, (intmax_t)gid);

517

break;

485

518

}

519

gid = (gid_t)tmpmax;

486

520

break;

487

521

case 132: /* --debug */

488

522

debug = true;

489

523

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;

490

538

/*

491

539

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

492

540

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

495

543

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

496

544

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

497

545

argument was empty, we ignore it silently. */

498

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

499

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

546

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

547

break;

500

548

}

501

break;

502

case ARGP_KEY_END:

503

break;

504

549

default:

505

550

return ARGP_ERR_UNKNOWN;

506

551

}

507

return 0;

552

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

508

553

}

509

554

510

555

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

511

556

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

512

557

error_t parse_opt_config_file(int key, char *arg,

513

558

__attribute__((unused))

514

struct argp_state *state) {

515

switch(key) {

559

struct argp_state *state){

560

errno = 0;

561

switch(key){

516

562

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

517

563

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

518

564

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

524

570

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

525

571

free(argfile);

526

572

argfile = strdup(arg);

527

if(argfile == NULL){

528

perror("strdup");

529

}

530

break;

573

break;

531

574

case 130: /* --userid */

532

575

case 131: /* --groupid */

533

576

case 132: /* --debug */

577

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

578

case -3: /* --usage */

579

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

534

580

case ARGP_KEY_ARG:

535

case ARGP_KEY_END:

536

581

break;

537

582

default:

538

583

return ARGP_ERR_UNKNOWN;

539

584

}

540

return 0;

585

return errno;

541

586

}

542

587

543

588

struct argp argp = { .options = options,

547

592

548

593

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

549

594

config file location, if any. */

550

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

551

if(ret == ARGP_ERR_UNKNOWN){

552

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

553

exitstatus = EXIT_FAILURE;

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;

554

609

goto fallback;

555

610

}

556

611

562

617

conffp = fopen(AFILE, "r");

563

618

} else {

564

619

conffp = fopen(argfile, "r");

565

}

620

}

566

621

if(conffp != NULL){

567

622

char *org_line = NULL;

568

623

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

569

624

size_t size = 0;

570

625

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

571

626

const char comment_delim[] = "#";

572

627

573

628

custom_argc = 1;

574

629

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

575

630

if(custom_argv == NULL){

576

perror("malloc");

577

exitstatus = EXIT_FAILURE;

631

error(0, errno, "malloc");

632

exitstatus = EX_OSERR;

578

633

goto fallback;

579

634

}

580

635

custom_argv[0] = argv[0];

581

636

custom_argv[1] = NULL;

582

637

583

638

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

584

639

commented text */

585

640

while(true){

587

642

if(sret == -1){

588

643

break;

589

644

}

590

645

591

646

line = org_line;

592

647

arg = strsep(&line, comment_delim);

593

648

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

596

651

}

597

652

new_arg = strdup(p);

598

653

if(new_arg == NULL){

599

perror("strdup");

600

exitstatus = EXIT_FAILURE;

654

error(0, errno, "strdup");

655

exitstatus = EX_OSERR;

601

656

free(org_line);

602

657

goto fallback;

603

658

}

606

661

custom_argv = realloc(custom_argv, sizeof(char *)

607

662

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

608

663

if(custom_argv == NULL){

609

perror("realloc");

610

exitstatus = EXIT_FAILURE;

664

error(0, errno, "realloc");

665

exitstatus = EX_OSERR;

611

666

free(org_line);

612

667

goto fallback;

613

668

}

614

669

custom_argv[custom_argc-1] = new_arg;

615

custom_argv[custom_argc] = NULL;

670

custom_argv[custom_argc] = NULL;

616

671

}

617

672

}

673

do {

674

ret = fclose(conffp);

675

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

676

if(ret == EOF){

677

error(0, errno, "fclose");

678

exitstatus = EX_IOERR;

679

goto fallback;

680

}

618

681

free(org_line);

619

682

} else {

620

683

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

621

684

not affect opening plugins */

622

685

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

623

perror("fopen");

624

exitstatus = EXIT_FAILURE;

686

error(0, errno, "fopen");

687

exitstatus = EX_OSERR;

625

688

goto fallback;

626

689

}

627

690

}

628

/* If there was any arguments from configuration file,

629

pass them to parser as command arguments */

691

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

692

them to parser as command line arguments */

630

693

if(custom_argv != NULL){

631

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

632

0, NULL);

633

if(ret == ARGP_ERR_UNKNOWN){

634

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

635

exitstatus = EXIT_FAILURE;

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;

636

708

goto fallback;

637

709

}

638

710

}

639

711

640

712

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

641

713

config file */

642

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

643

if(ret == ARGP_ERR_UNKNOWN){

644

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

645

exitstatus = EXIT_FAILURE;

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;

646

728

goto fallback;

647

729

}

648

730

661

743

}

662

744

663

745

/* Strip permissions down to nobody */

746

setgid(gid);

747

if(ret == -1){

748

error(0, errno, "setgid");

749

}

664

750

ret = setuid(uid);

665

751

if(ret == -1){

666

perror("setuid");

667

}

668

setgid(gid);

669

if(ret == -1){

670

perror("setgid");

671

}

672

673

if(plugindir == NULL){

674

dir = opendir(PDIR);

675

} else {

676

dir = opendir(plugindir);

677

}

678

679

if(dir == NULL){

680

perror("Could not open plugin dir");

681

exitstatus = EXIT_FAILURE;

682

goto fallback;

683

}

684

685

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

752

error(0, errno, "setuid");

753

}

754

755

/* Open plugin directory with close_on_exec flag */

686

756

{

687

int dir_fd = dirfd(dir);

688

if(dir_fd >= 0){

689

ret = set_cloexec_flag(dir_fd);

690

if(ret < 0){

691

perror("set_cloexec_flag");

692

exitstatus = EXIT_FAILURE;

693

goto fallback;

694

}

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;

695

798

}

696

799

}

697

800

699

802

700

803

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

701

804

while(true){

702

dirst = readdir(dir);

805

do {

806

dirst = readdir(dir);

807

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

703

808

704

809

/* All directory entries have been processed */

705

810

if(dirst == NULL){

706

811

if(errno == EBADF){

707

perror("readdir");

708

exitstatus = EXIT_FAILURE;

812

error(0, errno, "readdir");

813

exitstatus = EX_IOERR;

709

814

goto fallback;

710

815

}

711

816

break;

741

846

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

742

847

size_t suf_len = strlen(*suf);

743

848

if((d_name_len >= suf_len)

744

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

849

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

745

850

== 0)){

746

851

if(debug){

747

852

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

756

861

continue;

757

862

}

758

863

}

759

864

760

865

char *filename;

761

866

if(plugindir == NULL){

762

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

867

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

868

dirst->d_name));

763

869

} else {

764

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

870

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

871

plugindir,

872

dirst->d_name));

765

873

}

766

874

if(ret < 0){

767

perror("asprintf");

875

error(0, errno, "asprintf");

768

876

continue;

769

877

}

770

878

771

ret = stat(filename, &st);

879

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

772

880

if(ret == -1){

773

perror("stat");

881

error(0, errno, "stat");

774

882

free(filename);

775

883

continue;

776

884

}

777

885

778

886

/* Ignore non-executable files */

779

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

887

if(not S_ISREG(st.st_mode)

888

or (TEMP_FAILURE_RETRY(access(filename, X_OK)) != 0)){

780

889

if(debug){

781

890

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

782

891

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

787

896

788

897

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

789

898

if(p == NULL){

790

perror("getplugin");

899

error(0, errno, "getplugin");

791

900

free(filename);

792

901

continue;

793

902

}

805

914

if(g != NULL){

806

915

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

807

916

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

808

perror("add_argument");

917

error(0, errno, "add_argument");

809

918

}

810

919

}

811

920

/* Add global environment variables */

812

921

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

813

922

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

814

perror("add_environment");

923

error(0, errno, "add_environment");

815

924

}

816

925

}

817

926

}

822

931

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

823

932

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

824

933

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

825

perror("add_environment");

934

error(0, errno, "add_environment");

826

935

}

827

936

}

828

937

}

829

938

830

939

int pipefd[2];

831

ret = pipe(pipefd);

940

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

832

941

if(ret == -1){

833

perror("pipe");

834

exitstatus = EXIT_FAILURE;

942

error(0, errno, "pipe");

943

exitstatus = EX_OSERR;

835

944

goto fallback;

836

945

}

837

946

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

838

947

ret = set_cloexec_flag(pipefd[0]);

839

948

if(ret < 0){

840

perror("set_cloexec_flag");

841

exitstatus = EXIT_FAILURE;

949

error(0, errno, "set_cloexec_flag");

950

exitstatus = EX_OSERR;

842

951

goto fallback;

843

952

}

844

953

ret = set_cloexec_flag(pipefd[1]);

845

954

if(ret < 0){

846

perror("set_cloexec_flag");

847

exitstatus = EXIT_FAILURE;

955

error(0, errno, "set_cloexec_flag");

956

exitstatus = EX_OSERR;

848

957

goto fallback;

849

958

}

850

959

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

851

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

960

ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,

961

&sigchld_action.sa_mask,

962

NULL));

852

963

if(ret < 0){

853

perror("sigprocmask");

854

exitstatus = EXIT_FAILURE;

964

error(0, errno, "sigprocmask");

965

exitstatus = EX_OSERR;

855

966

goto fallback;

856

967

}

857

968

/* Starting a new process to be watched */

858

pid_t pid = fork();

969

pid_t pid;

970

do {

971

pid = fork();

972

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

859

973

if(pid == -1){

860

perror("fork");

861

exitstatus = EXIT_FAILURE;

974

error(0, errno, "fork");

975

exitstatus = EX_OSERR;

862

976

goto fallback;

863

977

}

864

978

if(pid == 0){

865

979

/* this is the child process */

866

980

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

867

981

if(ret < 0){

868

perror("sigaction");

869

_exit(EXIT_FAILURE);

982

error(0, errno, "sigaction");

983

_exit(EX_OSERR);

870

984

}

871

985

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

872

986

if(ret < 0){

873

perror("sigprocmask");

874

_exit(EXIT_FAILURE);

987

error(0, errno, "sigprocmask");

988

_exit(EX_OSERR);

875

989

}

876

990

877

991

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

878

992

if(ret == -1){

879

perror("dup2");

880

_exit(EXIT_FAILURE);

993

error(0, errno, "dup2");

994

_exit(EX_OSERR);

881

995

}

882

996

883

997

if(dirfd(dir) < 0){

887

1001

}

888

1002

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

889

1003

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

890

perror("execv");

891

_exit(EXIT_FAILURE);

1004

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

1005

_exit(EX_OSERR);

892

1006

}

893

1007

} else {

894

1008

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

895

perror("execve");

896

_exit(EXIT_FAILURE);

1009

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

1010

_exit(EX_OSERR);

897

1011

}

898

1012

}

899

1013

/* no return */

900

1014

}

901

1015

/* Parent process */

902

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

1016

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

1017

pipe */

903

1018

free(filename);

904

1019

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

905

1020

if(new_plugin == NULL){

906

perror("getplugin");

907

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

1021

error(0, errno, "getplugin");

1022

ret = (int)(TEMP_FAILURE_RETRY

1023

(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,

1024

NULL)));

908

1025

if(ret < 0){

909

perror("sigprocmask");

1026

error(0, errno, "sigprocmask");

910

1027

}

911

exitstatus = EXIT_FAILURE;

1028

exitstatus = EX_OSERR;

912

1029

goto fallback;

913

1030

}

914

1031

917

1034

918

1035

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

919

1036

has already completed */

920

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

1037

ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,

1038

&sigchld_action.sa_mask,

1039

NULL));

921

1040

if(ret < 0){

922

perror("sigprocmask");

923

exitstatus = EXIT_FAILURE;

1041

error(0, errno, "sigprocmask");

1042

exitstatus = EX_OSERR;

924

1043

goto fallback;

925

1044

}

926

1045

927

FD_SET(new_plugin->fd, &rfds_all);

1046

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

1047

-Wconversion */

928

1048

929

1049

if(maxfd < new_plugin->fd){

930

1050

maxfd = new_plugin->fd;

931

1051

}

932

1052

}

933

1053

934

closedir(dir);

1054

TEMP_FAILURE_RETRY(closedir(dir));

935

1055

dir = NULL;

1056

free_plugin(getplugin(NULL));

936

1057

937

1058

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

938

1059

if(p->pid != 0){

949

1070

while(plugin_list){

950

1071

fd_set rfds = rfds_all;

951

1072

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

952

if(select_ret == -1){

953

perror("select");

954

exitstatus = EXIT_FAILURE;

1073

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

1074

error(0, errno, "select");

1075

exitstatus = EX_OSERR;

955

1076

goto fallback;

956

1077

}

957

1078

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

958

1079

from one of them */

959

1080

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

960

1081

/* Is this process completely done? */

961

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

1082

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

962

1083

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

963

1084

if(not WIFEXITED(proc->status)

964

1085

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

965

1086

/* Bad exit by plugin */

966

1087

967

1088

if(debug){

968

1089

if(WIFEXITED(proc->status)){

969

fprintf(stderr, "Plugin %" PRIdMAX " exited with status"

970

" %d\n", (intmax_t) (proc->pid),

1090

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

1091

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

1092

(intmax_t) (proc->pid),

971

1093

WEXITSTATUS(proc->status));

972

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

973

fprintf(stderr, "Plugin %" PRIdMAX " killed by signal"

974

" %d\n", (intmax_t) (proc->pid),

975

WTERMSIG(proc->status));

1094

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

1095

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

1096

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

1097

(intmax_t) (proc->pid),

1098

WTERMSIG(proc->status),

1099

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

976

1100

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

977

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

978

(intmax_t) (proc->pid));

1101

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

1102

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

979

1103

}

980

1104

}

981

1105

982

1106

/* Remove the plugin */

983

FD_CLR(proc->fd, &rfds_all);

984

1107

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

1108

-Wconversion */

1109

985

1110

/* Block signal while modifying process_list */

986

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

1111

ret = (int)TEMP_FAILURE_RETRY(sigprocmask

1112

(SIG_BLOCK,

1113

&sigchld_action.sa_mask,

1114

NULL));

987

1115

if(ret < 0){

988

perror("sigprocmask");

989

exitstatus = EXIT_FAILURE;

1116

error(0, errno, "sigprocmask");

1117

exitstatus = EX_OSERR;

990

1118

goto fallback;

991

1119

}

992

1120

995

1123

proc = next_plugin;

996

1124

997

1125

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

998

ret = sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,

999

NULL);

1126

ret = (int)(TEMP_FAILURE_RETRY

1127

(sigprocmask(SIG_UNBLOCK,

1128

&sigchld_action.sa_mask, NULL)));

1000

1129

if(ret < 0){

1001

perror("sigprocmask");

1002

exitstatus = EXIT_FAILURE;

1130

error(0, errno, "sigprocmask");

1131

exitstatus = EX_OSERR;

1003

1132

goto fallback;

1004

1133

}

1005

1134

1015

1144

bool bret = print_out_password(proc->buffer,

1016

1145

proc->buffer_length);

1017

1146

if(not bret){

1018

perror("print_out_password");

1019

exitstatus = EXIT_FAILURE;

1147

error(0, errno, "print_out_password");

1148

exitstatus = EX_IOERR;

1020

1149

}

1021

1150

goto fallback;

1022

1151

}

1023

1152

1024

1153

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

1025

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

1154

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

1155

warning from

1156

-Wconversion */

1026

1157

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

1027

1158

proc = proc->next;

1028

1159

continue;

1032

1163

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

1033

1164

+ (size_t) BUFFER_SIZE);

1034

1165

if(proc->buffer == NULL){

1035

perror("malloc");

1036

exitstatus = EXIT_FAILURE;

1166

error(0, errno, "malloc");

1167

exitstatus = EX_OSERR;

1037

1168

goto fallback;

1038

1169

}

1039

1170

proc->buffer_size += BUFFER_SIZE;

1040

1171

}

1041

1172

/* Read from the process */

1042

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

1043

BUFFER_SIZE);

1173

sret = TEMP_FAILURE_RETRY(read(proc->fd,

1174

proc->buffer

1175

+ proc->buffer_length,

1176

BUFFER_SIZE));

1044

1177

if(sret < 0){

1045

1178

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

1046

1179

proc = proc->next;

1054

1187

}

1055

1188

}

1056

1189

}

1057

1058

1190

1191

1059

1192

fallback:

1060

1193

1061

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

1194

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

1195

and exitstatus != EX_OK)){

1062

1196

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

1063

1197

occured */

1064

1198

bool bret;

1072

1206

}

1073

1207

bret = print_out_password(passwordbuffer, len);

1074

1208

if(not bret){

1075

perror("print_out_password");

1076

exitstatus = EXIT_FAILURE;

1209

error(0, errno, "print_out_password");

1210

exitstatus = EX_IOERR;

1077

1211

}

1078

1212

}

1079

1213

1080

1214

/* Restore old signal handler */

1081

1215

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

1082

1216

if(ret == -1){

1083

perror("sigaction");

1084

exitstatus = EXIT_FAILURE;

1217

error(0, errno, "sigaction");

1218

exitstatus = EX_OSERR;

1085

1219

}

1086

1220

1087

1221

if(custom_argv != NULL){

1102

1236

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

1103

1237

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

1104

1238

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

1105

perror("kill");

1239

error(0, errno, "kill");

1106

1240

}

1107

1241

}

1108

1242

}

1109

1243

1110

1244

/* Wait for any remaining child processes to terminate */

1111

do{

1245

do {

1112

1246

ret = wait(NULL);

1113

1247

} while(ret >= 0);

1114

1248

if(errno != ECHILD){

1115

perror("wait");

1249

error(0, errno, "wait");

1116

1250

}

1117

1251

1118

1252

free_plugin_list();