/mandos/trunk : revision 24.1.66

65

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

66

67

#define BUFFER_SIZE 256

68

69

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

70

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

68

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

71

69

72

70

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

73

71

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

74

72

75

struct plugin;

76

77

typedef struct plugin{

78

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

79

char **argv;

80

int argc;

81

char **environ;

82

int envc;

83

bool disabled;

84

85

/* Variables used for running processes*/

73

struct process;

74

75

typedef struct process{

86

76

pid_t pid;

87

77

int fd;

88

78

char *buffer;

91

81

bool eof;

92

82

volatile bool completed;

93

83

volatile int status;

84

struct process *next;

85

} process;

86

87

typedef struct plugin{

88

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

89

char **argv;

90

int argc;

91

char **environ;

92

int envc;

93

bool disabled;

94

struct plugin *next;

95

} plugin;

96

97

static plugin *plugin_list = NULL;

98

99

/* Gets a existing plugin based on name,

100

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

101

static plugin *getplugin(char *name){

102

/* Check for exiting plugin with that name */

103

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

97

static plugin *getplugin(char *name, plugin **plugin_list){

98

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

104

99

if ((p->name == name)

105

100

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

106

101

return p;

118

113

return NULL;

119

114

}

120

115

}

121

116

122

117

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

123

118

.argc = 1,

119

.envc = 0,

124

120

.disabled = false,

125

.next = plugin_list };

121

.next = *plugin_list };

126

122

127

123

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

128

124

if (new_plugin->argv == NULL){

141

137

return NULL;

142

138

}

143

139

new_plugin->environ[0] = NULL;

144

145

140

/* Append the new plugin to the list */

146

plugin_list = new_plugin;

141

*plugin_list = new_plugin;

147

142

return new_plugin;

148

143

}

149

144

186

181

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

187

182

}

188

183

184

189

185

/*

190

186

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

191

187

* Descriptor Flags".

202

198

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

203

199

}

204

200

201

process *process_list = NULL;

205

202

206

203

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

207

204

status. */

208

205

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

209

206

while(true){

210

plugin *proc = plugin_list;

207

process *proc = process_list;

211

208

int status;

212

209

pid_t pid = waitpid(-1, &status, WNOHANG);

213

210

if(pid == 0){

235

232

}

236

233

}

237

234

238

/* Prints out a password to stdout */

239

235

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

240

236

ssize_t ret;

241

237

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

251

247

return true;

252

248

}

253

249

254

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

255

static void free_plugin(plugin *plugin_node){

256

257

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

258

free(*arg);

259

}

260

free(plugin_node->argv);

261

for(char **env = plugin_node->environ; *env != NULL; env++){

262

free(*env);

263

}

264

free(plugin_node->environ);

265

free(plugin_node->buffer);

266

267

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

268

if(plugin_node == plugin_list){

269

/* First one - simple */

270

plugin_list = plugin_list->next;

271

} else {

272

/* Second one or later */

273

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

274

if(p->next == plugin_node){

275

p->next = plugin_node->next;

276

break;

277

}

250

char **add_to_argv(char **argv, int *argc, char *arg){

251

if (argv == NULL){

252

*argc = 1;

253

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

254

if(argv == NULL){

255

return NULL;

278

256

}

279

}

280

281

free(plugin_node);

257

argv[0] = NULL; /* Will be set to argv[0] in main before parsing */

258

argv[1] = NULL;

259

}

260

*argc += 1;

261

argv = realloc(argv, sizeof(char *)

262

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

263

if(argv == NULL){

264

return NULL;

265

}

266

argv[*argc-1] = arg;

267

argv[*argc] = NULL;

268

return argv;

282

269

}

283

270

284

static void free_plugin_list(void){

285

while(plugin_list != NULL){

286

free_plugin(plugin_list);

271

static void free_plugin_list(plugin *plugin_list){

272

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

273

next = plugin_list->next;

274

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

275

free(*arg);

276

}

277

free(plugin_list->argv);

278

for(char **env = plugin_list->environ; *env != NULL; env++){

279

free(*env);

280

}

281

free(plugin_list->environ);

282

free(plugin_list);

287

283

}

288

284

}

289

285

290

286

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

291

char *plugindir = NULL;

292

char *argfile = NULL;

287

const char *plugindir = "/lib/mandos/plugins.d";

288

const char *argfile = ARGFILE;

293

289

FILE *conffp;

294

290

size_t d_name_len;

295

291

DIR *dir = NULL;

342

338

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

343

339

.arg = "DIRECTORY",

344

340

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

345

{ .name = "config-file", .key = 129,

346

.arg = "FILE",

347

.doc = "Specify a different configuration file", .group = 2 },

348

{ .name = "userid", .key = 130,

349

.arg = "ID", .flags = 0,

350

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

351

{ .name = "groupid", .key = 131,

352

.arg = "ID", .flags = 0,

353

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

354

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

355

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

341

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

342

.arg = "ID", .flags = 0,

343

.doc = "User ID the plugins will run as", .group = 2 },

344

{ .name = "groupid", .key = 130,

345

.arg = "ID", .flags = 0,

346

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

347

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

348

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

356

349

{ .name = NULL }

357

350

};

358

351

359

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

352

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

360

353

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

361

354

pointer to our plugin list pointer. */

355

plugin **plugins = state->input;

362

356

switch (key) {

363

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

357

case 'g':

364

358

if (arg != NULL){

365

359

char *p;

366

360

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

367

361

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

368

362

continue;

369

363

}

370

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

364

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

371

365

perror("add_argument");

372

366

return ARGP_ERR_UNKNOWN;

373

367

}

374

368

}

375

369

}

376

370

break;

377

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

371

case 'e':

378

372

if(arg == NULL){

379

373

break;

380

374

}

383

377

if(envdef == NULL){

384

378

break;

385

379

}

386

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

380

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

387

381

perror("add_environment");

388

382

}

389

383

}

390

384

break;

391

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

385

case 'o':

392

386

if (arg != NULL){

393

387

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

394

388

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

404

398

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

405

399

continue;

406

400

}

407

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

401

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

408

402

perror("add_argument");

409

403

return ARGP_ERR_UNKNOWN;

410

404

}

412

406

}

413

407

}

414

408

break;

415

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

409

case 'f':

416

410

if(arg == NULL){

417

411

break;

418

412

}

426

420

break;

427

421

}

428

422

envdef++;

429

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

423

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

430

424

perror("add_environment");

431

425

}

432

426

}

433

427

break;

434

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

428

case 'd':

435

429

if (arg != NULL){

436

plugin *p = getplugin(arg);

430

plugin *p = getplugin(arg, plugins);

437

431

if(p == NULL){

438

432

return ARGP_ERR_UNKNOWN;

439

433

}

440

434

p->disabled = true;

441

435

}

442

436

break;

443

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

444

plugindir = strdup(arg);

445

if(plugindir == NULL){

446

perror("strdup");

447

}

437

case 128:

438

plugindir = arg;

448

439

break;

449

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

450

argfile = strdup(arg);

451

if(argfile == NULL){

452

perror("strdup");

453

}

454

break;

455

case 130: /* --userid */

440

case 129:

456

441

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

457

442

break;

458

case 131: /* --groupid */

443

case 130:

459

444

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

460

445

break;

461

case 132: /* --debug */

446

case 131:

462

447

debug = true;

463

448

break;

464

449

case ARGP_KEY_ARG:

472

457

return 0;

473

458

}

474

459

460

plugin *plugin_list = NULL;

461

475

462

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

476

463

.args_doc = "[+PLUS_SEPARATED_OPTIONS]",

477

464

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

478

465

479

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

466

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

480

467

if (ret == ARGP_ERR_UNKNOWN){

481

468

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

482

469

exitstatus = EXIT_FAILURE;

483

470

goto fallback;

484

471

}

485

472

486

/* Opens the configfile if aviable */

487

if (argfile == NULL){

488

conffp = fopen(AFILE, "r");

489

} else {

490

conffp = fopen(argfile, "r");

491

}

473

conffp = fopen(argfile, "r");

492

474

if(conffp != NULL){

493

475

char *org_line = NULL;

494

476

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

497

479

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

498

480

const char comment_delim[] = "#";

499

481

500

custom_argc = 1;

501

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

502

if(custom_argv == NULL){

503

perror("malloc");

504

exitstatus = EXIT_FAILURE;

505

goto fallback;

506

}

507

custom_argv[0] = argv[0];

508

custom_argv[1] = NULL;

509

510

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

511

482

while(true){

512

483

sret = getline(&org_line, &size, conffp);

513

484

if(sret == -1){

521

492

continue;

522

493

}

523

494

new_arg = strdup(p);

524

if(new_arg == NULL){

525

perror("strdup");

526

exitstatus = EXIT_FAILURE;

527

free(org_line);

528

goto fallback;

529

}

530

531

custom_argc += 1;

532

custom_argv = realloc(custom_argv, sizeof(char *)

533

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

534

if(custom_argv == NULL){

535

perror("realloc");

536

exitstatus = EXIT_FAILURE;

537

free(org_line);

538

goto fallback;

539

}

540

custom_argv[custom_argc-1] = new_arg;

541

custom_argv[custom_argc] = NULL;

495

custom_argv = add_to_argv(custom_argv, &custom_argc, new_arg);

496

if (custom_argv == NULL){

497

perror("add_to_argv");

498

exitstatus = EXIT_FAILURE;

499

goto fallback;

500

}

542

501

}

543

502

}

544

503

free(org_line);

551

510

goto fallback;

552

511

}

553

512

}

554

/* If there was any arguments from configuration file,

555

pass them to parser as command arguments */

513

556

514

if(custom_argv != NULL){

557

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

515

custom_argv[0] = argv[0];

516

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

558

517

if (ret == ARGP_ERR_UNKNOWN){

559

518

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

560

519

exitstatus = EXIT_FAILURE;

575

534

}

576

535

}

577

536

}

578

579

/* Strip permissions down to nobody */

537

580

538

ret = setuid(uid);

581

539

if (ret == -1){

582

540

perror("setuid");

583

}

541

}

542

584

543

setgid(gid);

585

544

if (ret == -1){

586

545

perror("setgid");

587

546

}

588

589

if (plugindir == NULL){

590

dir = opendir(PDIR);

591

} else {

592

dir = opendir(plugindir);

593

}

594

547

548

dir = opendir(plugindir);

595

549

if(dir == NULL){

596

550

perror("Could not open plugin dir");

597

551

exitstatus = EXIT_FAILURE;

612

566

}

613

567

614

568

FD_ZERO(&rfds_all);

615

616

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

569

617

570

while(true){

618

571

dirst = readdir(dir);

619

572

650

603

break;

651

604

}

652

605

}

606

653

607

if(bad_name){

654

608

continue;

655

609

}

610

656

611

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

657

612

size_t suf_len = strlen(*suf);

658

613

if((d_name_len >= suf_len)

685

640

free(filename);

686

641

continue;

687

642

}

688

689

/* Ignore non-executable files */

643

690

644

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

691

645

if(debug){

692

646

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

695

649

free(filename);

696

650

continue;

697

651

}

698

699

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

652

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

700

653

if(p == NULL){

701

654

perror("getplugin");

702

655

free(filename);

712

665

}

713

666

{

714

667

/* Add global arguments to argument list for this plugin */

715

plugin *g = getplugin(NULL);

668

plugin *g = getplugin(NULL, &plugin_list);

716

669

if(g != NULL){

717

670

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

718

671

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

750

703

exitstatus = EXIT_FAILURE;

751

704

goto fallback;

752

705

}

753

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

754

706

ret = set_cloexec_flag(pipefd[0]);

755

707

if(ret < 0){

756

708

perror("set_cloexec_flag");

814

766

}

815

767

/* no return */

816

768

}

817

/* Parent process */

818

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

769

/* parent process */

819

770

free(filename);

820

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

821

if (new_plugin == NULL){

822

perror("getplugin");

771

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

772

process *new_process = malloc(sizeof(process));

773

if (new_process == NULL){

774

perror("malloc");

823

775

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

824

776

if(ret < 0){

825

perror("sigprocmask");

777

perror("sigprocmask");

826

778

}

827

779

exitstatus = EXIT_FAILURE;

828

780

goto fallback;

829

781

}

830

782

831

new_plugin->pid = pid;

832

new_plugin->fd = pipefd[0];

833

783

*new_process = (struct process){ .pid = pid,

784

.fd = pipefd[0],

785

.next = process_list };

786

// List handling

787

process_list = new_process;

834

788

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

835

789

has already completed */

836

790

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

840

794

goto fallback;

841

795

}

842

796

843

FD_SET(new_plugin->fd, &rfds_all);

797

FD_SET(new_process->fd, &rfds_all);

844

798

845

if (maxfd < new_plugin->fd){

846

maxfd = new_plugin->fd;

799

if (maxfd < new_process->fd){

800

maxfd = new_process->fd;

847

801

}

848

802

849

803

}

850

804

805

free_plugin_list(plugin_list);

806

plugin_list = NULL;

807

851

808

closedir(dir);

852

809

dir = NULL;

853

854

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

855

if(p->pid != 0){

856

break;

857

}

858

if(p->next == NULL){

859

fprintf(stderr, "No plugin processes started. Incorrect plugin"

860

" directory?\n");

861

free_plugin_list();

862

}

810

811

if (process_list == NULL){

812

fprintf(stderr, "No plugin processes started. Incorrect plugin"

813

" directory?\n");

814

process_list = NULL;

863

815

}

864

865

/* Main loop while running plugins exist */

866

while(plugin_list){

816

while(process_list){

867

817

fd_set rfds = rfds_all;

868

818

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

869

819

if (select_ret == -1){

873

823

}

874

824

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

875

825

from one of them */

876

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

826

for(process *proc = process_list; proc ; proc = proc->next){

877

827

/* Is this process completely done? */

878

828

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

879

829

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

880

830

if(not WIFEXITED(proc->status)

881

831

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

882

832

/* Bad exit by plugin */

883

884

833

if(debug){

885

834

if(WIFEXITED(proc->status)){

886

835

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

895

844

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

896

845

}

897

846

}

898

899

847

/* Remove the plugin */

900

848

FD_CLR(proc->fd, &rfds_all);

901

902

849

/* Block signal while modifying process_list */

903

850

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

904

851

if(ret < 0){

906

853

exitstatus = EXIT_FAILURE;

907

854

goto fallback;

908

855

}

909

free_plugin(proc);

856

/* Delete this process entry from the list */

857

if(process_list == proc){

858

/* First one - simple */

859

process_list = proc->next;

860

} else {

861

/* Second one or later */

862

for(process *p = process_list; p != NULL; p = p->next){

863

if(p->next == proc){

864

p->next = proc->next;

865

break;

866

}

867

}

868

}

910

869

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

911

870

ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,

912

871

NULL);

913

872

if(ret < 0){

914

873

perror("sigprocmask");

915

exitstatus = EXIT_FAILURE;

916

goto fallback;

917

}

918

919

if(plugin_list == NULL){

920

break;

921

}

922

continue;

874

}

875

free(proc->buffer);

876

free(proc);

877

/* We deleted this process from the list, so we can't go

878

proc->next. Therefore, start over from the beginning of

879

the process list */

880

break;

923

881

}

924

925

882

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

926

883

927

884

bool bret = print_out_password(proc->buffer,

932

889

}

933

890

goto fallback;

934

891

}

935

936

892

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

937

893

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

938

894

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

968

924

969

925

fallback:

970

926

971

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

927

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

972

928

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

973

929

occured */

974

930

bool bret;

989

945

}

990

946

991

947

if(custom_argv != NULL){

992

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

948

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

993

949

free(*arg);

994

950

}

995

951

free(custom_argv);

996

952

}

953

free_plugin_list(plugin_list);

997

954

998

955

if(dir != NULL){

999

956

closedir(dir);

1000

957

}

1001

958

1002

959

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

1003

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

1004

if(p->pid != 0){

1005

close(p->fd);

1006

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

1007

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

1008

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

1009

perror("kill");

1010

}

960

for(process *next; process_list != NULL; process_list = next){

961

next = process_list->next;

962

close(process_list->fd);

963

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

964

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

965

/* set-uid proccesses migth not get closed */

966

perror("kill");

1011

967

}

968

free(process_list->buffer);

969

free(process_list);

1012

970

}

1013

971

1014

972

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

1018

976

if(errno != ECHILD){

1019

977

perror("wait");

1020

978

}

1021

1022

free_plugin_list();

1023

1024

free(plugindir);

1025

free(argfile);

1026

979

1027

980

return exitstatus;

1028

981

}