/mandos/trunk : revision 105

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

258

parsing */

259

argv[1] = NULL;

260

}

261

*argc += 1;

262

argv = realloc(argv, sizeof(char *)

263

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

264

if(argv == NULL){

265

return NULL;

266

}

267

argv[*argc-1] = arg;

268

argv[*argc] = NULL;

269

return argv;

282

270

}

283

271

284

static void free_plugin_list(void){

285

while(plugin_list != NULL){

286

free_plugin(plugin_list);

272

static void free_plugin_list(plugin *plugin_list){

273

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

274

next = plugin_list->next;

275

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

276

free(*arg);

277

}

278

free(plugin_list->argv);

279

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

280

free(*env);

281

}

282

free(plugin_list->environ);

283

free(plugin_list);

287

284

}

288

285

}

289

286

290

287

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

291

char *plugindir = NULL;

292

char *argfile = NULL;

288

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

289

const char *argfile = ARGFILE;

293

290

FILE *conffp;

294

291

size_t d_name_len;

295

292

DIR *dir = NULL;

342

339

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

343

340

.arg = "DIRECTORY",

344

341

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

342

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

343

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

344

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

345

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

346

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

347

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

348

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

349

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

356

350

{ .name = NULL }

357

351

};

358

352

359

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

360

struct argp_state *state) {

353

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

361

354

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

362

355

pointer to our plugin list pointer. */

356

plugin **plugins = state->input;

363

357

switch (key) {

364

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

358

case 'g':

365

359

if (arg != NULL){

366

360

char *p;

367

361

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

368

362

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

369

363

continue;

370

364

}

371

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

365

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

372

366

perror("add_argument");

373

367

return ARGP_ERR_UNKNOWN;

374

368

}

375

369

}

376

370

}

377

371

break;

378

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

372

case 'e':

379

373

if(arg == NULL){

380

374

break;

381

375

}

384

378

if(envdef == NULL){

385

379

break;

386

380

}

387

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

381

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

388

382

perror("add_environment");

389

383

}

390

384

}

391

385

break;

392

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

386

case 'o':

393

387

if (arg != NULL){

394

388

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

395

389

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

405

399

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

406

400

continue;

407

401

}

408

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

402

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

409

403

perror("add_argument");

410

404

return ARGP_ERR_UNKNOWN;

411

405

}

413

407

}

414

408

}

415

409

break;

416

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

410

case 'f':

417

411

if(arg == NULL){

418

412

break;

419

413

}

427

421

break;

428

422

}

429

423

envdef++;

430

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

424

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

431

425

perror("add_environment");

432

426

}

433

427

}

434

428

break;

435

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

429

case 'd':

436

430

if (arg != NULL){

437

plugin *p = getplugin(arg);

431

plugin *p = getplugin(arg, plugins);

438

432

if(p == NULL){

439

433

return ARGP_ERR_UNKNOWN;

440

434

}

441

435

p->disabled = true;

442

436

}

443

437

break;

444

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

445

plugindir = strdup(arg);

446

if(plugindir == NULL){

447

perror("strdup");

448

}

438

case 128:

439

plugindir = arg;

449

440

break;

450

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

451

argfile = strdup(arg);

452

if(argfile == NULL){

453

perror("strdup");

454

}

455

break;

456

case 130: /* --userid */

441

case 129:

457

442

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

458

443

break;

459

case 131: /* --groupid */

444

case 130:

460

445

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

461

446

break;

462

case 132: /* --debug */

447

case 131:

463

448

debug = true;

464

449

break;

465

450

case ARGP_KEY_ARG:

473

458

return 0;

474

459

}

475

460

461

plugin *plugin_list = NULL;

462

476

463

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

477

464

.args_doc = "[+PLUS_SEPARATED_OPTIONS]",

478

465

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

479

466

480

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

467

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

481

468

if (ret == ARGP_ERR_UNKNOWN){

482

469

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

483

470

exitstatus = EXIT_FAILURE;

484

471

goto fallback;

485

472

}

486

473

487

/* Opens the configfile if aviable */

488

if (argfile == NULL){

489

conffp = fopen(AFILE, "r");

490

} else {

491

conffp = fopen(argfile, "r");

492

}

474

conffp = fopen(argfile, "r");

493

475

if(conffp != NULL){

494

476

char *org_line = NULL;

495

477

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

498

480

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

499

481

const char comment_delim[] = "#";

500

482

501

custom_argc = 1;

502

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

503

if(custom_argv == NULL){

504

perror("malloc");

505

exitstatus = EXIT_FAILURE;

506

goto fallback;

507

}

508

custom_argv[0] = argv[0];

509

custom_argv[1] = NULL;

510

511

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

512

commented text */

513

483

while(true){

514

484

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

515

485

if(sret == -1){

523

493

continue;

524

494

}

525

495

new_arg = strdup(p);

526

if(new_arg == NULL){

527

perror("strdup");

528

exitstatus = EXIT_FAILURE;

529

free(org_line);

530

goto fallback;

531

}

532

533

custom_argc += 1;

534

custom_argv = realloc(custom_argv, sizeof(char *)

535

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

536

if(custom_argv == NULL){

537

perror("realloc");

538

exitstatus = EXIT_FAILURE;

539

free(org_line);

540

goto fallback;

541

}

542

custom_argv[custom_argc-1] = new_arg;

543

custom_argv[custom_argc] = NULL;

496

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

497

if (custom_argv == NULL){

498

perror("add_to_argv");

499

exitstatus = EXIT_FAILURE;

500

goto fallback;

501

}

544

502

}

545

503

}

546

504

free(org_line);

553

511

goto fallback;

554

512

}

555

513

}

556

/* If there was any arguments from configuration file,

557

pass them to parser as command arguments */

514

558

515

if(custom_argv != NULL){

559

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

516

custom_argv[0] = argv[0];

517

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

518

&plugin_list);

560

519

if (ret == ARGP_ERR_UNKNOWN){

561

520

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

562

521

exitstatus = EXIT_FAILURE;

577

536

}

578

537

}

579

538

}

580

581

/* Strip permissions down to nobody */

539

582

540

ret = setuid(uid);

583

541

if (ret == -1){

584

542

perror("setuid");

585

}

543

}

544

586

545

setgid(gid);

587

546

if (ret == -1){

588

547

perror("setgid");

589

548

}

590

591

if (plugindir == NULL){

592

dir = opendir(PDIR);

593

} else {

594

dir = opendir(plugindir);

595

}

596

549

550

dir = opendir(plugindir);

597

551

if(dir == NULL){

598

552

perror("Could not open plugin dir");

599

553

exitstatus = EXIT_FAILURE;

614

568

}

615

569

616

570

FD_ZERO(&rfds_all);

617

618

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

571

619

572

while(true){

620

573

dirst = readdir(dir);

621

574

652

605

break;

653

606

}

654

607

}

608

655

609

if(bad_name){

656

610

continue;

657

611

}

612

658

613

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

659

614

size_t suf_len = strlen(*suf);

660

615

if((d_name_len >= suf_len)

687

642

free(filename);

688

643

continue;

689

644

}

690

691

/* Ignore non-executable files */

645

692

646

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

693

647

if(debug){

694

648

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

697

651

free(filename);

698

652

continue;

699

653

}

700

701

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

654

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

702

655

if(p == NULL){

703

656

perror("getplugin");

704

657

free(filename);

714

667

}

715

668

{

716

669

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

717

plugin *g = getplugin(NULL);

670

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

718

671

if(g != NULL){

719

672

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

720

673

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

752

705

exitstatus = EXIT_FAILURE;

753

706

goto fallback;

754

707

}

755

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

756

708

ret = set_cloexec_flag(pipefd[0]);

757

709

if(ret < 0){

758

710

perror("set_cloexec_flag");

816

768

}

817

769

/* no return */

818

770

}

819

/* Parent process */

820

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

771

/* parent process */

821

772

free(filename);

822

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

823

if (new_plugin == NULL){

824

perror("getplugin");

773

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

774

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

775

if (new_process == NULL){

776

perror("malloc");

825

777

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

826

778

if(ret < 0){

827

perror("sigprocmask");

779

perror("sigprocmask");

828

780

}

829

781

exitstatus = EXIT_FAILURE;

830

782

goto fallback;

831

783

}

832

784

833

new_plugin->pid = pid;

834

new_plugin->fd = pipefd[0];

835

785

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

786

.fd = pipefd[0],

787

.next = process_list };

788

// List handling

789

process_list = new_process;

836

790

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

837

791

has already completed */

838

792

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

842

796

goto fallback;

843

797

}

844

798

845

FD_SET(new_plugin->fd, &rfds_all);

799

FD_SET(new_process->fd, &rfds_all);

846

800

847

if (maxfd < new_plugin->fd){

848

maxfd = new_plugin->fd;

801

if (maxfd < new_process->fd){

802

maxfd = new_process->fd;

849

803

}

850

804

851

805

}

852

806

807

free_plugin_list(plugin_list);

808

plugin_list = NULL;

809

853

810

closedir(dir);

854

811

dir = NULL;

855

856

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

857

if(p->pid != 0){

858

break;

859

}

860

if(p->next == NULL){

861

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

862

" directory?\n");

863

free_plugin_list();

864

}

812

813

if (process_list == NULL){

814

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

815

" directory?\n");

816

process_list = NULL;

865

817

}

866

867

/* Main loop while running plugins exist */

868

while(plugin_list){

818

while(process_list){

869

819

fd_set rfds = rfds_all;

870

820

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

871

821

if (select_ret == -1){

875

825

}

876

826

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

877

827

from one of them */

878

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

828

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

879

829

/* Is this process completely done? */

880

830

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

881

831

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

882

832

if(not WIFEXITED(proc->status)

883

833

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

884

834

/* Bad exit by plugin */

885

886

835

if(debug){

887

836

if(WIFEXITED(proc->status)){

888

837

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

897

846

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

898

847

}

899

848

}

900

901

849

/* Remove the plugin */

902

850

FD_CLR(proc->fd, &rfds_all);

903

904

851

/* Block signal while modifying process_list */

905

852

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

906

853

if(ret < 0){

908

855

exitstatus = EXIT_FAILURE;

909

856

goto fallback;

910

857

}

911

free_plugin(proc);

858

/* Delete this process entry from the list */

859

if(process_list == proc){

860

/* First one - simple */

861

process_list = proc->next;

862

} else {

863

/* Second one or later */

864

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

865

if(p->next == proc){

866

p->next = proc->next;

867

break;

868

}

869

}

870

}

912

871

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

913

872

ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,

914

873

NULL);

915

874

if(ret < 0){

916

875

perror("sigprocmask");

917

exitstatus = EXIT_FAILURE;

918

goto fallback;

919

}

920

921

if(plugin_list == NULL){

922

break;

923

}

924

continue;

876

}

877

free(proc->buffer);

878

free(proc);

879

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

880

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

881

the process list */

882

break;

925

883

}

926

927

884

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

928

885

929

886

bool bret = print_out_password(proc->buffer,

934

891

}

935

892

goto fallback;

936

893

}

937

938

894

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

939

895

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

940

896

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

970

926

971

927

fallback:

972

928

973

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

929

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

974

930

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

975

931

occured */

976

932

bool bret;

991

947

}

992

948

993

949

if(custom_argv != NULL){

994

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

950

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

995

951

free(*arg);

996

952

}

997

953

free(custom_argv);

998

954

}

955

free_plugin_list(plugin_list);

999

956

1000

957

if(dir != NULL){

1001

958

closedir(dir);

1002

959

}

1003

960

1004

961

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

1005

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

1006

if(p->pid != 0){

1007

close(p->fd);

1008

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

1009

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

1010

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

1011

perror("kill");

1012

}

962

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

963

next = process_list->next;

964

close(process_list->fd);

965

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

966

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

967

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

968

perror("kill");

1013

969

}

970

free(process_list->buffer);

971

free(process_list);

1014

972

}

1015

973

1016

974

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

1020

978

if(errno != ECHILD){

1021

979

perror("wait");

1022

980

}

1023

1024

free_plugin_list();

1025

1026

free(plugindir);

1027

free(argfile);

1028

981

1029

982

return exitstatus;

1030

983

}