/mandos/trunk : revision 838

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

19

* along with this program. If not, see

20

* <http://www.gnu.org/licenses/>.

21

*

22

* Contact the authors at <mandos@fukt.bsnet.se>.

22

* Contact the authors at <mandos@recompile.se>.

23

*/

24

25

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

26

asprintf() */

26

O_CLOEXEC, pipe2() */

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(),

32

stderr, STDOUT_FILENO */

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(),

37

dirfd() */

31

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

32

stderr, STDOUT_FILENO, fclose() */

33

#include <sys/types.h> /* fstat(), struct stat, waitpid(),

34

WIFEXITED(), WEXITSTATUS(), wait(),

35

pid_t, uid_t, gid_t, getuid(),

36

getgid() */

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

43

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

40

WEXITSTATUS(), WTERMSIG() */

41

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

44

42

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

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(),

49

F_GETFD, F_SETFD, FD_CLOEXEC,

50

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

51

dup2(), STDOUT_FILENO, _exit(),

52

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

53

close() */

43

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

44

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

45

FD_CLOEXEC, write(), STDOUT_FILENO,

46

struct stat, fstat(), close(),

47

setgid(), setuid(), S_ISREG(),

48

faccessat() pipe2(), fork(),

49

_exit(), dup2(), fexecve(), read()

50

*/

54

51

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

55

FD_CLOEXEC */

56

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

57

strsignal() */

52

FD_CLOEXEC, openat(), scandirat(),

53

pipe2() */

54

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

55

strcmp(), strncmp() */

58

56

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

59

57

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

60

58

argp_state, struct argp,

68

66

*/

69

67

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

70

68

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

69

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

70

EX_CONFIG, EX_UNAVAILABLE, EX_OK */

71

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

72

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

73

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

71

74

72

75

#define BUFFER_SIZE 256

73

76

74

77

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

78

#define PHDIR "/lib/mandos/plugin-helpers"

75

79

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

76

80

77

81

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

78

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

82

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

79

83

80

84

typedef struct plugin{

81

85

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

101

105

102

106

/* Gets an existing plugin based on name,

103

107

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

108

__attribute__((warn_unused_result))

104

109

static plugin *getplugin(char *name){

105

/* Check for exiting plugin with that name */

110

/* Check for existing plugin with that name */

106

111

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

107

112

if((p->name == name)

108

113

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

123

128

copy_name = strdup(name);

124

129

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

125

130

if(copy_name == NULL){

131

int e = errno;

126

132

free(new_plugin);

133

errno = e;

127

134

return NULL;

128

135

}

129

136

}

137

144

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

138

145

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

139

146

if(new_plugin->argv == NULL){

147

int e = errno;

140

148

free(copy_name);

141

149

free(new_plugin);

150

errno = e;

142

151

return NULL;

143

152

}

144

153

new_plugin->argv[0] = copy_name;

148

157

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

149

158

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

150

159

if(new_plugin->environ == NULL){

160

int e = errno;

151

161

free(copy_name);

152

162

free(new_plugin->argv);

153

163

free(new_plugin);

164

errno = e;

154

165

return NULL;

155

166

}

156

167

new_plugin->environ[0] = NULL;

161

172

}

162

173

163

174

/* Helper function for add_argument and add_environment */

175

__attribute__((nonnull, warn_unused_result))

164

176

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

165

177

int *len){

166

178

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

179

char **new_array = NULL;

167

180

do {

168

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

169

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

170

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

181

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

182

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

183

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

171

184

/* Malloc check */

172

if(*array == NULL){

185

if(new_array == NULL){

173

186

return false;

174

187

}

188

*array = new_array;

175

189

/* Make a copy of the new string */

176

190

char *copy;

177

191

do {

189

203

}

190

204

191

205

/* Add to a plugin's argument vector */

206

__attribute__((nonnull(2), warn_unused_result))

192

207

static bool add_argument(plugin *p, const char *arg){

193

208

if(p == NULL){

194

209

return false;

197

212

}

198

213

199

214

/* Add to a plugin's environment */

215

__attribute__((nonnull(2), warn_unused_result))

200

216

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

201

217

if(p == NULL){

202

218

return false;

204

220

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

205

221

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

206

222

/* Search for this environment variable */

207

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

208

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

223

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

224

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

209

225

/* It already exists */

210

226

if(replace){

211

char *new;

227

char *new_envdef;

212

228

do {

213

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

214

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

215

if(new == NULL){

229

new_envdef = realloc(*envdef, strlen(def) + 1);

230

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

231

if(new_envdef == NULL){

216

232

return false;

217

233

}

218

*e = new;

219

strcpy(*e, def);

234

*envdef = new_envdef;

235

strcpy(*envdef, def);

220

236

}

221

237

return true;

222

238

}

224

240

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

225

241

}

226

242

243

#ifndef O_CLOEXEC

227

244

/*

228

245

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

229

246

* Descriptor Flags".

230

247

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

231

248

*/

249

__attribute__((warn_unused_result))

232

250

static int set_cloexec_flag(int fd){

233

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

251

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

234

252

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

235

253

if(ret < 0){

236

254

return ret;

237

255

}

238

256

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

239

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

257

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

258

ret | FD_CLOEXEC));

240

259

}

260

#endif /* not O_CLOEXEC */

241

261

242

262

243

263

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

257

277

/* No child processes */

258

278

break;

259

279

}

260

perror("waitpid");

280

error(0, errno, "waitpid");

261

281

}

262

282

263

283

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

275

295

}

276

296

277

297

/* Prints out a password to stdout */

298

__attribute__((nonnull, warn_unused_result))

278

299

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

279

300

ssize_t ret;

280

301

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

288

309

}

289

310

290

311

/* Removes and free a plugin from the plugin list */

312

__attribute__((nonnull))

291

313

static void free_plugin(plugin *plugin_node){

292

314

293

315

for(char **arg = plugin_node->argv; *arg != NULL; arg++){

325

347

326

348

int main(int argc, char *argv[]){

327

349

char *plugindir = NULL;

350

char *pluginhelperdir = NULL;

328

351

char *argfile = NULL;

329

352

FILE *conffp;

330

size_t d_name_len;

331

DIR *dir = NULL;

332

struct dirent *dirst;

353

struct dirent **direntries = NULL;

333

354

struct stat st;

334

355

fd_set rfds_all;

335

356

int ret, maxfd = 0;

343

364

.sa_flags = SA_NOCLDSTOP };

344

365

char **custom_argv = NULL;

345

366

int custom_argc = 0;

367

int dir_fd = -1;

346

368

347

369

/* Establish a signal handler */

348

370

sigemptyset(&sigchld_action.sa_mask);

349

371

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

350

372

if(ret == -1){

351

perror("sigaddset");

352

exitstatus = EXIT_FAILURE;

373

error(0, errno, "sigaddset");

374

exitstatus = EX_OSERR;

353

375

goto fallback;

354

376

}

355

377

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

356

378

if(ret == -1){

357

perror("sigaction");

358

exitstatus = EXIT_FAILURE;

379

error(0, errno, "sigaction");

380

exitstatus = EX_OSERR;

359

381

goto fallback;

360

382

}

361

383

393

415

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

394

416

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

395

417

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

418

{ .name = "plugin-helper-dir", .key = 133,

419

.arg = "DIRECTORY",

420

.doc = "Specify a different plugin helper directory",

421

.group = 2 },

422

/*

423

* These reproduce what we would get without ARGP_NO_HELP

424

*/

425

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

426

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

427

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

428

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

429

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

430

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

396

431

{ .name = NULL }

397

432

};

398

433

399

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

400

struct argp_state *state){

434

__attribute__((nonnull(3)))

435

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

436

errno = 0;

401

437

switch(key){

402

438

char *tmp;

403

intmax_t tmpmax;

439

intmax_t tmp_id;

404

440

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

405

if(arg != NULL){

441

{

406

442

char *plugin_option;

407

443

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

408

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

409

continue;

410

}

411

444

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

412

perror("add_argument");

413

return ARGP_ERR_UNKNOWN;

445

break;

414

446

}

415

447

}

448

errno = 0;

416

449

}

417

450

break;

418

451

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

419

if(arg == NULL){

420

break;

421

}

422

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

423

perror("add_environment");

452

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

453

errno = 0;

424

454

}

425

455

break;

426

456

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

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;

457

{

458

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

459

if(option_list == NULL){

460

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

461

errno = EINVAL;

462

break;

463

}

464

*option_list = '\0';

465

option_list++;

466

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

467

argp_error(state, "Empty plugin name");

468

errno = EINVAL;

469

break;

470

}

471

char *option;

472

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

473

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

474

break;

437

475

}

438

476

}

477

errno = 0;

439

478

}

440

479

break;

441

480

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

442

if(arg == NULL){

443

break;

444

}

445

481

{

446

482

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

447

483

if(envdef == NULL){

484

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

485

errno = EINVAL;

448

486

break;

449

487

}

450

488

*envdef = '\0';

451

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

452

perror("add_environment");

489

envdef++;

490

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

491

argp_error(state, "Empty plugin name");

492

errno = EINVAL;

493

break;

494

}

495

if(add_environment(getplugin(arg), envdef, true)){

496

errno = 0;

453

497

}

454

498

}

455

499

break;

456

500

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

457

if(arg != NULL){

501

{

458

502

plugin *p = getplugin(arg);

459

if(p == NULL){

460

return ARGP_ERR_UNKNOWN;

503

if(p != NULL){

504

p->disabled = true;

505

errno = 0;

461

506

}

462

p->disabled = true;

463

507

}

464

508

break;

465

509

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

466

if(arg != NULL){

510

{

467

511

plugin *p = getplugin(arg);

468

if(p == NULL){

469

return ARGP_ERR_UNKNOWN;

512

if(p != NULL){

513

p->disabled = false;

514

errno = 0;

470

515

}

471

p->disabled = false;

472

516

}

473

517

break;

474

518

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

475

519

free(plugindir);

476

520

plugindir = strdup(arg);

477

if(plugindir == NULL){

478

perror("strdup");

521

if(plugindir != NULL){

522

errno = 0;

479

523

}

480

524

break;

481

525

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

482

526

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

483

527

break;

484

528

case 130: /* --userid */

485

errno = 0;

486

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

529

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

487

530

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

488

or tmpmax != (uid_t)tmpmax){

489

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

490

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

491

} else {

492

uid = (uid_t)tmpmax;

531

or tmp_id != (uid_t)tmp_id){

532

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

533

PRIdMAX, arg, (intmax_t)uid);

534

break;

493

535

}

536

uid = (uid_t)tmp_id;

537

errno = 0;

494

538

break;

495

539

case 131: /* --groupid */

496

errno = 0;

497

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

540

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

498

541

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

499

or tmpmax != (gid_t)tmpmax){

500

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

501

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

502

} else {

503

gid = (gid_t)tmpmax;

542

or tmp_id != (gid_t)tmp_id){

543

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

544

PRIdMAX, arg, (intmax_t)gid);

545

break;

504

546

}

547

gid = (gid_t)tmp_id;

548

errno = 0;

505

549

break;

506

550

case 132: /* --debug */

507

551

debug = true;

508

552

break;

553

case 133: /* --plugin-helper-dir */

554

free(pluginhelperdir);

555

pluginhelperdir = strdup(arg);

556

if(pluginhelperdir != NULL){

557

errno = 0;

558

}

559

break;

560

/*

561

* These reproduce what we would get without ARGP_NO_HELP

562

*/

563

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

564

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

565

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

566

case -3: /* --usage */

567

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

568

argp_state_help(state, state->out_stream,

569

ARGP_HELP_USAGE | ARGP_HELP_EXIT_OK);

570

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

571

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

572

exit(EXIT_SUCCESS);

573

break;

509

574

/*

510

575

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

511

576

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

514

579

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

515

580

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

516

581

argument was empty, we ignore it silently. */

517

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

518

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

582

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

583

break;

519

584

}

520

break;

521

case ARGP_KEY_END:

522

break;

523

585

default:

524

586

return ARGP_ERR_UNKNOWN;

525

587

}

526

return 0;

588

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

527

589

}

528

590

529

591

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

531

593

error_t parse_opt_config_file(int key, char *arg,

532

594

__attribute__((unused))

533

595

struct argp_state *state){

596

errno = 0;

534

597

switch(key){

535

598

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

536

599

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

543

606

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

544

607

free(argfile);

545

608

argfile = strdup(arg);

546

if(argfile == NULL){

547

perror("strdup");

609

if(argfile != NULL){

610

errno = 0;

548

611

}

549

612

break;

550

613

case 130: /* --userid */

551

614

case 131: /* --groupid */

552

615

case 132: /* --debug */

616

case 133: /* --plugin-helper-dir */

617

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

618

case -3: /* --usage */

619

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

553

620

case ARGP_KEY_ARG:

554

case ARGP_KEY_END:

555

621

break;

556

622

default:

557

623

return ARGP_ERR_UNKNOWN;

558

624

}

559

return 0;

625

return errno;

560

626

}

561

627

562

628

struct argp argp = { .options = options,

566

632

567

633

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

568

634

config file location, if any. */

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;

635

ret = argp_parse(&argp, argc, argv,

636

ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,

637

NULL, NULL);

638

switch(ret){

639

case 0:

640

break;

641

case ENOMEM:

642

default:

643

errno = ret;

644

error(0, errno, "argp_parse");

645

exitstatus = EX_OSERR;

646

goto fallback;

647

case EINVAL:

648

exitstatus = EX_USAGE;

573

649

goto fallback;

574

650

}

575

651

592

668

custom_argc = 1;

593

669

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

594

670

if(custom_argv == NULL){

595

perror("malloc");

596

exitstatus = EXIT_FAILURE;

671

error(0, errno, "malloc");

672

exitstatus = EX_OSERR;

597

673

goto fallback;

598

674

}

599

675

custom_argv[0] = argv[0];

615

691

}

616

692

new_arg = strdup(p);

617

693

if(new_arg == NULL){

618

perror("strdup");

619

exitstatus = EXIT_FAILURE;

694

error(0, errno, "strdup");

695

exitstatus = EX_OSERR;

620

696

free(org_line);

621

697

goto fallback;

622

698

}

623

699

624

700

custom_argc += 1;

625

custom_argv = realloc(custom_argv, sizeof(char *)

626

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

627

if(custom_argv == NULL){

628

perror("realloc");

629

exitstatus = EXIT_FAILURE;

630

free(org_line);

631

goto fallback;

701

{

702

char **new_argv = realloc(custom_argv, sizeof(char *)

703

* ((size_t)custom_argc + 1));

704

if(new_argv == NULL){

705

error(0, errno, "realloc");

706

exitstatus = EX_OSERR;

707

free(new_arg);

708

free(org_line);

709

goto fallback;

710

} else {

711

custom_argv = new_argv;

712

}

632

713

}

633

714

custom_argv[custom_argc-1] = new_arg;

634

715

custom_argv[custom_argc] = NULL;

638

719

ret = fclose(conffp);

639

720

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

640

721

if(ret == EOF){

641

perror("fclose");

642

exitstatus = EXIT_FAILURE;

722

error(0, errno, "fclose");

723

exitstatus = EX_IOERR;

643

724

goto fallback;

644

725

}

645

726

free(org_line);

647

728

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

648

729

not affect opening plugins */

649

730

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

650

perror("fopen");

651

exitstatus = EXIT_FAILURE;

731

error(0, errno, "fopen");

732

exitstatus = EX_OSERR;

652

733

goto fallback;

653

734

}

654

735

}

655

/* If there was any arguments from configuration file,

656

pass them to parser as command arguments */

736

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

737

them to parser as command line arguments */

657

738

if(custom_argv != NULL){

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;

739

ret = argp_parse(&argp, custom_argc, custom_argv,

740

ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,

741

NULL, NULL);

742

switch(ret){

743

case 0:

744

break;

745

case ENOMEM:

746

default:

747

errno = ret;

748

error(0, errno, "argp_parse");

749

exitstatus = EX_OSERR;

750

goto fallback;

751

case EINVAL:

752

exitstatus = EX_CONFIG;

663

753

goto fallback;

664

754

}

665

755

}

666

756

667

757

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

668

758

config file */

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;

673

goto fallback;

759

ret = argp_parse(&argp, argc, argv,

760

ARGP_IN_ORDER | ARGP_NO_EXIT | ARGP_NO_HELP,

761

NULL, NULL);

762

switch(ret){

763

case 0:

764

break;

765

case ENOMEM:

766

default:

767

errno = ret;

768

error(0, errno, "argp_parse");

769

exitstatus = EX_OSERR;

770

goto fallback;

771

case EINVAL:

772

exitstatus = EX_USAGE;

773

goto fallback;

774

}

775

776

{

777

char *pluginhelperenv;

778

bool bret = true;

779

ret = asprintf(&pluginhelperenv, "MANDOSPLUGINHELPERDIR=%s",

780

pluginhelperdir != NULL ? pluginhelperdir : PHDIR);

781

if(ret != -1){

782

bret = add_environment(getplugin(NULL), pluginhelperenv, true);

783

}

784

if(ret == -1 or not bret){

785

error(0, errno, "Failed to set MANDOSPLUGINHELPERDIR"

786

" environment variable to \"%s\" for all plugins\n",

787

pluginhelperdir != NULL ? pluginhelperdir : PHDIR);

788

}

789

if(ret != -1){

790

free(pluginhelperenv);

791

}

674

792

}

675

793

676

794

if(debug){

687

805

}

688

806

}

689

807

690

/* Strip permissions down to nobody */

691

setgid(gid);

808

if(getuid() == 0){

809

/* Work around Debian bug #633582:

810

<http://bugs.debian.org/633582> */

811

int plugindir_fd = open(/* plugindir or */ PDIR, O_RDONLY);

812

if(plugindir_fd == -1){

813

if(errno != ENOENT){

814

error(0, errno, "open(\"" PDIR "\")");

815

}

816

} else {

817

ret = (int)TEMP_FAILURE_RETRY(fstat(plugindir_fd, &st));

818

if(ret == -1){

819

error(0, errno, "fstat");

820

} else {

821

if(S_ISDIR(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){

822

ret = fchown(plugindir_fd, uid, gid);

823

if(ret == -1){

824

error(0, errno, "fchown");

825

}

826

}

827

}

828

close(plugindir_fd);

829

}

830

}

831

832

/* Lower permissions */

833

ret = setgid(gid);

692

834

if(ret == -1){

693

perror("setgid");

835

error(0, errno, "setgid");

694

836

}

695

837

ret = setuid(uid);

696

838

if(ret == -1){

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

839

error(0, errno, "setuid");

840

}

841

842

/* Open plugin directory with close_on_exec flag */

713

843

{

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;

844

dir_fd = open(plugindir != NULL ? plugindir : PDIR, O_RDONLY |

845

#ifdef O_CLOEXEC

846

O_CLOEXEC

847

#else /* not O_CLOEXEC */

848

0

849

#endif /* not O_CLOEXEC */

850

);

851

if(dir_fd == -1){

852

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

853

exitstatus = EX_UNAVAILABLE;

854

goto fallback;

855

}

856

857

#ifndef O_CLOEXEC

858

/* Set the FD_CLOEXEC flag on the directory */

859

ret = set_cloexec_flag(dir_fd);

860

if(ret < 0){

861

error(0, errno, "set_cloexec_flag");

862

exitstatus = EX_OSERR;

863

goto fallback;

864

}

865

#endif /* O_CLOEXEC */

866

}

867

868

int good_name(const struct dirent * const dirent){

869

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

870

"*.dpkg-old", "*.dpkg-bak",

871

"*.dpkg-divert", NULL };

872

#ifdef __GNUC__

873

#pragma GCC diagnostic push

874

#pragma GCC diagnostic ignored "-Wcast-qual"

875

#endif

876

for(const char **pat = (const char **)patterns;

877

*pat != NULL; pat++){

878

#ifdef __GNUC__

879

#pragma GCC diagnostic pop

880

#endif

881

if(fnmatch(*pat, dirent->d_name, FNM_FILE_NAME | FNM_PERIOD)

882

!= FNM_NOMATCH){

883

if(debug){

884

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

885

" matching pattern %s\n", dirent->d_name, *pat);

886

}

887

return 0;

721

888

}

722

889

}

890

return 1;

891

}

892

893

int numplugins = scandirat(dir_fd, ".", &direntries, good_name,

894

alphasort);

895

if(numplugins == -1){

896

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

897

direntries = NULL;

898

exitstatus = EX_OSERR;

899

goto fallback;

723

900

}

724

901

725

902

FD_ZERO(&rfds_all);

726

903

727

904

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

728

while(true){

729

do {

730

dirst = readdir(dir);

731

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

732

733

/* All directory entries have been processed */

734

if(dirst == NULL){

735

if(errno == EBADF){

736

perror("readdir");

737

exitstatus = EXIT_FAILURE;

738

goto fallback;

739

}

740

break;

741

}

742

743

d_name_len = strlen(dirst->d_name);

744

745

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

746

{

747

bool bad_name = false;

748

749

const char const *bad_prefixes[] = { ".", "#", NULL };

750

751

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

752

".dpkg-old",

753

".dpkg-bak",

754

".dpkg-divert", NULL };

755

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

756

size_t pre_len = strlen(*pre);

757

if((d_name_len >= pre_len)

758

and strncmp((dirst->d_name), *pre, pre_len) == 0){

759

if(debug){

760

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

761

" with bad prefix %s\n", dirst->d_name, *pre);

762

}

763

bad_name = true;

764

break;

765

}

766

}

767

if(bad_name){

768

continue;

769

}

770

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

771

size_t suf_len = strlen(*suf);

772

if((d_name_len >= suf_len)

773

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

774

== 0)){

775

if(debug){

776

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

777

" with bad suffix %s\n", dirst->d_name, *suf);

778

}

779

bad_name = true;

780

break;

781

}

782

}

783

784

if(bad_name){

785

continue;

786

}

787

}

788

789

char *filename;

790

if(plugindir == NULL){

791

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

792

dirst->d_name));

793

} else {

794

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

795

dirst->d_name));

796

}

797

if(ret < 0){

798

perror("asprintf");

905

for(int i = 0; i < numplugins; i++){

906

907

int plugin_fd = openat(dir_fd, direntries[i]->d_name, O_RDONLY);

908

if(plugin_fd == -1){

909

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

910

free(direntries[i]);

799

911

continue;

800

912

}

801

802

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

913

ret = (int)TEMP_FAILURE_RETRY(fstat(plugin_fd, &st));

803

914

if(ret == -1){

804

perror("stat");

805

free(filename);

915

error(0, errno, "stat");

916

close(plugin_fd);

917

free(direntries[i]);

806

918

continue;

807

919

}

808

920

809

921

/* Ignore non-executable files */

810

922

if(not S_ISREG(st.st_mode)

811

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

923

or (TEMP_FAILURE_RETRY(faccessat(dir_fd, direntries[i]->d_name,

924

X_OK, 0)) != 0)){

812

925

if(debug){

813

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

814

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

926

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

927

" with bad type or mode\n",

928

plugindir != NULL ? plugindir : PDIR,

929

direntries[i]->d_name);

815

930

}

816

free(filename);

931

close(plugin_fd);

932

free(direntries[i]);

817

933

continue;

818

934

}

819

935

820

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

936

plugin *p = getplugin(direntries[i]->d_name);

821

937

if(p == NULL){

822

perror("getplugin");

823

free(filename);

938

error(0, errno, "getplugin");

939

close(plugin_fd);

940

free(direntries[i]);

824

941

continue;

825

942

}

826

943

if(p->disabled){

827

944

if(debug){

828

945

fprintf(stderr, "Ignoring disabled plugin \"%s\"\n",

829

dirst->d_name);

946

direntries[i]->d_name);

830

947

}

831

free(filename);

948

close(plugin_fd);

949

free(direntries[i]);

832

950

continue;

833

951

}

834

952

{

837

955

if(g != NULL){

838

956

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

839

957

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

840

perror("add_argument");

958

error(0, errno, "add_argument");

841

959

}

842

960

}

843

961

/* Add global environment variables */

844

962

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

845

963

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

846

perror("add_environment");

964

error(0, errno, "add_environment");

847

965

}

848

966

}

849

967

}

850

968

}

851

/* If this plugin has any environment variables, we will call

852

using execve and need to duplicate the environment from this

853

process, too. */

969

/* If this plugin has any environment variables, we need to

970

duplicate the environment from this process, too. */

854

971

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

855

972

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

856

973

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

857

perror("add_environment");

974

error(0, errno, "add_environment");

858

975

}

859

976

}

860

977

}

861

978

862

979

int pipefd[2];

863

ret = TEMP_FAILURE_RETRY(pipe(pipefd));

980

#ifndef O_CLOEXEC

981

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

982

#else /* O_CLOEXEC */

983

ret = (int)TEMP_FAILURE_RETRY(pipe2(pipefd, O_CLOEXEC));

984

#endif /* O_CLOEXEC */

864

985

if(ret == -1){

865

perror("pipe");

866

exitstatus = EXIT_FAILURE;

867

goto fallback;

868

}

986

error(0, errno, "pipe");

987

exitstatus = EX_OSERR;

988

free(direntries[i]);

989

goto fallback;

990

}

991

if(pipefd[0] >= FD_SETSIZE){

992

fprintf(stderr, "pipe()[0] (%d) >= FD_SETSIZE (%d)", pipefd[0],

993

FD_SETSIZE);

994

close(pipefd[0]);

995

close(pipefd[1]);

996

exitstatus = EX_OSERR;

997

free(direntries[i]);

998

goto fallback;

999

}

1000

#ifndef O_CLOEXEC

869

1001

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

870

1002

ret = set_cloexec_flag(pipefd[0]);

871

1003

if(ret < 0){

872

perror("set_cloexec_flag");

873

exitstatus = EXIT_FAILURE;

1004

error(0, errno, "set_cloexec_flag");

1005

close(pipefd[0]);

1006

close(pipefd[1]);

1007

exitstatus = EX_OSERR;

1008

free(direntries[i]);

874

1009

goto fallback;

875

1010

}

876

1011

ret = set_cloexec_flag(pipefd[1]);

877

1012

if(ret < 0){

878

perror("set_cloexec_flag");

879

exitstatus = EXIT_FAILURE;

1013

error(0, errno, "set_cloexec_flag");

1014

close(pipefd[0]);

1015

close(pipefd[1]);

1016

exitstatus = EX_OSERR;

1017

free(direntries[i]);

880

1018

goto fallback;

881

1019

}

1020

#endif /* not O_CLOEXEC */

882

1021

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

883

ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,

884

&sigchld_action.sa_mask,

885

NULL));

1022

ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,

1023

&sigchld_action.sa_mask,

1024

NULL));

886

1025

if(ret < 0){

887

perror("sigprocmask");

888

exitstatus = EXIT_FAILURE;

1026

error(0, errno, "sigprocmask");

1027

exitstatus = EX_OSERR;

1028

free(direntries[i]);

889

1029

goto fallback;

890

1030

}

891

1031

/* Starting a new process to be watched */

894

1034

pid = fork();

895

1035

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

896

1036

if(pid == -1){

897

perror("fork");

898

exitstatus = EXIT_FAILURE;

1037

error(0, errno, "fork");

1038

TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,

1039

&sigchld_action.sa_mask, NULL));

1040

close(pipefd[0]);

1041

close(pipefd[1]);

1042

exitstatus = EX_OSERR;

1043

free(direntries[i]);

899

1044

goto fallback;

900

1045

}

901

1046

if(pid == 0){

902

1047

/* this is the child process */

903

1048

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

904

1049

if(ret < 0){

905

perror("sigaction");

906

_exit(EXIT_FAILURE);

1050

error(0, errno, "sigaction");

1051

_exit(EX_OSERR);

907

1052

}

908

1053

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

909

1054

if(ret < 0){

910

perror("sigprocmask");

911

_exit(EXIT_FAILURE);

1055

error(0, errno, "sigprocmask");

1056

_exit(EX_OSERR);

912

1057

}

913

1058

914

1059

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

915

1060

if(ret == -1){

916

perror("dup2");

917

_exit(EXIT_FAILURE);

1061

error(0, errno, "dup2");

1062

_exit(EX_OSERR);

918

1063

}

919

1064

920

if(dirfd(dir) < 0){

921

/* If dir has no file descriptor, we could not set FD_CLOEXEC

922

above and must now close it manually here. */

923

closedir(dir);

924

}

925

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

926

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

927

perror("execv");

928

_exit(EXIT_FAILURE);

929

}

930

} else {

931

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

932

perror("execve");

933

_exit(EXIT_FAILURE);

934

}

1065

if(fexecve(plugin_fd, p->argv,

1066

(p->environ[0] != NULL) ? p->environ : environ) < 0){

1067

error(0, errno, "fexecve for %s/%s",

1068

plugindir != NULL ? plugindir : PDIR,

1069

direntries[i]->d_name);

1070

_exit(EX_OSERR);

935

1071

}

936

1072

/* no return */

937

1073

}

938

1074

/* Parent process */

939

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

940

pipe */

941

free(filename);

942

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

1075

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

1076

close(plugin_fd);

1077

plugin *new_plugin = getplugin(direntries[i]->d_name);

943

1078

if(new_plugin == NULL){

944

perror("getplugin");

945

ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,

946

&sigchld_action.sa_mask,

947

NULL));

1079

error(0, errno, "getplugin");

1080

ret = (int)(TEMP_FAILURE_RETRY

1081

(sigprocmask(SIG_UNBLOCK, &sigchld_action.sa_mask,

1082

NULL)));

948

1083

if(ret < 0){

949

perror("sigprocmask");

1084

error(0, errno, "sigprocmask");

950

1085

}

951

exitstatus = EXIT_FAILURE;

1086

exitstatus = EX_OSERR;

1087

free(direntries[i]);

952

1088

goto fallback;

953

1089

}

1090

free(direntries[i]);

954

1091

955

1092

new_plugin->pid = pid;

956

1093

new_plugin->fd = pipefd[0];

957

1094

958

1095

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

959

1096

has already completed */

960

ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,

961

&sigchld_action.sa_mask,

962

NULL));

1097

ret = (int)TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,

1098

&sigchld_action.sa_mask,

1099

NULL));

963

1100

if(ret < 0){

964

perror("sigprocmask");

965

exitstatus = EXIT_FAILURE;

1101

error(0, errno, "sigprocmask");

1102

exitstatus = EX_OSERR;

966

1103

goto fallback;

967

1104

}

968

1105

973

1110

}

974

1111

}

975

1112

976

TEMP_FAILURE_RETRY(closedir(dir));

977

dir = NULL;

1113

free(direntries);

1114

direntries = NULL;

1115

close(dir_fd);

1116

dir_fd = -1;

978

1117

free_plugin(getplugin(NULL));

979

1118

980

1119

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

993

1132

fd_set rfds = rfds_all;

994

1133

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

995

1134

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

996

perror("select");

997

exitstatus = EXIT_FAILURE;

1135

error(0, errno, "select");

1136

exitstatus = EX_OSERR;

998

1137

goto fallback;

999

1138

}

1000

1139

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

1019

1158

(intmax_t) (proc->pid),

1020

1159

WTERMSIG(proc->status),

1021

1160

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

1022

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

1023

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

1024

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

1025

1161

}

1026

1162

}

1027

1163

1029

1165

FD_CLR(proc->fd, &rfds_all);

1030

1166

1031

1167

/* Block signal while modifying process_list */

1032

ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_BLOCK,

1033

&sigchld_action.sa_mask,

1034

NULL));

1168

ret = (int)TEMP_FAILURE_RETRY(sigprocmask

1169

(SIG_BLOCK,

1170

&sigchld_action.sa_mask,

1171

NULL));

1035

1172

if(ret < 0){

1036

perror("sigprocmask");

1037

exitstatus = EXIT_FAILURE;

1173

error(0, errno, "sigprocmask");

1174

exitstatus = EX_OSERR;

1038

1175

goto fallback;

1039

1176

}

1040

1177

1043

1180

proc = next_plugin;

1044

1181

1045

1182

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

1046

ret = TEMP_FAILURE_RETRY(sigprocmask(SIG_UNBLOCK,

1047

&sigchld_action.sa_mask,

1048

NULL));

1183

ret = (int)(TEMP_FAILURE_RETRY

1184

(sigprocmask(SIG_UNBLOCK,

1185

&sigchld_action.sa_mask, NULL)));

1049

1186

if(ret < 0){

1050

perror("sigprocmask");

1051

exitstatus = EXIT_FAILURE;

1187

error(0, errno, "sigprocmask");

1188

exitstatus = EX_OSERR;

1052

1189

goto fallback;

1053

1190

}

1054

1191

1064

1201

bool bret = print_out_password(proc->buffer,

1065

1202

proc->buffer_length);

1066

1203

if(not bret){

1067

perror("print_out_password");

1068

exitstatus = EXIT_FAILURE;

1204

error(0, errno, "print_out_password");

1205

exitstatus = EX_IOERR;

1069

1206

}

1070

1207

goto fallback;

1071

1208

}

1078

1215

}

1079

1216

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

1080

1217

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

1081

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

1082

+ (size_t) BUFFER_SIZE);

1083

if(proc->buffer == NULL){

1084

perror("malloc");

1085

exitstatus = EXIT_FAILURE;

1218

char *new_buffer = realloc(proc->buffer, proc->buffer_size

1219

+ (size_t) BUFFER_SIZE);

1220

if(new_buffer == NULL){

1221

error(0, errno, "malloc");

1222

exitstatus = EX_OSERR;

1086

1223

goto fallback;

1087

1224

}

1225

proc->buffer = new_buffer;

1088

1226

proc->buffer_size += BUFFER_SIZE;

1089

1227

}

1090

1228

/* Read from the process */

1109

1247

1110

1248

fallback:

1111

1249

1112

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

1250

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

1251

and exitstatus != EX_OK)){

1113

1252

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

1114

1253

occured */

1115

1254

bool bret;

1123

1262

}

1124

1263

bret = print_out_password(passwordbuffer, len);

1125

1264

if(not bret){

1126

perror("print_out_password");

1127

exitstatus = EXIT_FAILURE;

1265

error(0, errno, "print_out_password");

1266

exitstatus = EX_IOERR;

1128

1267

}

1129

1268

}

1130

1269

1131

1270

/* Restore old signal handler */

1132

1271

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

1133

1272

if(ret == -1){

1134

perror("sigaction");

1135

exitstatus = EXIT_FAILURE;

1273

error(0, errno, "sigaction");

1274

exitstatus = EX_OSERR;

1136

1275

}

1137

1276

1138

1277

if(custom_argv != NULL){

1142

1281

free(custom_argv);

1143

1282

}

1144

1283

1145

if(dir != NULL){

1146

closedir(dir);

1284

free(direntries);

1285

1286

if(dir_fd != -1){

1287

close(dir_fd);

1147

1288

}

1148

1289

1149

1290

/* Kill the processes */

1153

1294

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

1154

1295

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

1155

1296

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

1156

perror("kill");

1297

error(0, errno, "kill");

1157

1298

}

1158

1299

}

1159

1300

}

1163

1304

ret = wait(NULL);

1164

1305

} while(ret >= 0);

1165

1306

if(errno != ECHILD){

1166

perror("wait");

1307

error(0, errno, "wait");

1167

1308

}

1168

1309

1169

1310

free_plugin_list();

1170

1311

1171

1312

free(plugindir);

1313

free(pluginhelperdir);

1172

1314

free(argfile);

1173

1315

1174

1316

return exitstatus;