/mandos/release : revision 74

21

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

22

*/

23

24

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

25

asprintf() */

24

#define _GNU_SOURCE /* TEMP_FAILURE_RETRY() */

25

26

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

27

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

28

EXIT_SUCCESS, realloc() */

51

close() */

52

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

53

FD_CLOEXEC */

54

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

54

#include <string.h> /* strtok, strlen(), strcpy(),

55

strcat() */

55

56

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

56

57

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

57

58

argp_state, struct argp,

58

59

argp_parse(), ARGP_ERR_UNKNOWN,

59

ARGP_KEY_END, ARGP_KEY_ARG,

60

error_t */

60

ARGP_KEY_END, ARGP_KEY_ARG, error_t */

61

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

62

sigaddset(), sigaction(),

63

sigprocmask(), SIG_BLOCK, SIGCHLD,

66

67

#define BUFFER_SIZE 256

68

69

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

70

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

71

72

69

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

73

70

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

74

71

81

78

size_t buffer_size;

82

79

size_t buffer_length;

83

80

bool eof;

84

volatile bool completed;

85

volatile int status;

81

bool completed;

82

int status;

86

83

struct process *next;

87

84

} process;

88

85

90

87

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

91

88

char **argv;

92

89

int argc;

93

char **environ;

94

int envc;

95

90

bool disabled;

96

91

struct plugin *next;

97

92

} plugin;

106

101

/* Create a new plugin */

107

102

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

108

103

if (new_plugin == NULL){

109

return NULL;

110

}

111

char *copy_name = NULL;

112

if(name != NULL){

113

copy_name = strdup(name);

114

if(copy_name == NULL){

115

return NULL;

116

}

117

}

118

119

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

120

.argc = 1,

121

.envc = 0,

122

.disabled = false,

123

.next = *plugin_list };

124

104

perror("malloc");

105

exit(EXIT_FAILURE);

106

}

107

new_plugin->name = name;

125

108

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

126

109

if (new_plugin->argv == NULL){

127

free(copy_name);

128

free(new_plugin);

129

return NULL;

110

perror("malloc");

111

exit(EXIT_FAILURE);

130

112

}

131

new_plugin->argv[0] = copy_name;

113

new_plugin->argv[0] = name;

132

114

new_plugin->argv[1] = NULL;

133

134

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

135

if(new_plugin->environ == NULL){

136

free(copy_name);

137

free(new_plugin->argv);

138

free(new_plugin);

139

return NULL;

140

}

141

new_plugin->environ[0] = NULL;

115

new_plugin->argc = 1;

116

new_plugin->disabled = false;

117

new_plugin->next = *plugin_list;

142

118

/* Append the new plugin to the list */

143

119

*plugin_list = new_plugin;

144

120

return new_plugin;

145

121

}

146

122

147

/* Helper function for add_argument and add_environment */

148

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

149

int *len){

150

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

151

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

152

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

153

/* Malloc check */

154

if(*array == NULL){

155

return false;

156

}

157

/* Make a copy of the new string */

158

char *copy = strdup(new);

159

if(copy == NULL){

160

return false;

161

}

162

/* Insert the copy */

163

(*array)[*len] = copy;

164

(*len)++;

165

/* Add a new terminating NULL pointer to the last element */

166

(*array)[*len] = NULL;

167

return true;

168

}

169

170

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

171

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

172

if(p == NULL){

173

return false;

174

}

175

return add_to_char_array(arg, &(p->argv), &(p->argc));

176

}

177

178

/* Add to a plugin's environment */

179

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

180

if(p == NULL){

181

return false;

182

}

183

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

184

}

185

123

static void addargument(plugin *p, char *arg){

124

p->argv[p->argc] = arg;

125

p->argv = realloc(p->argv, sizeof(char *) * (size_t)(p->argc + 2));

126

if (p->argv == NULL){

127

perror("malloc");

128

exit(EXIT_FAILURE);

129

}

130

p->argc++;

131

p->argv[p->argc] = NULL;

132

}

186

133

187

134

/*

188

135

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

202

149

203

150

process *process_list = NULL;

204

151

205

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

152

/* Mark a process as completed when it exits, and save its exit

206

153

status. */

207

154

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

208

while(true){

209

process *proc = process_list;

210

int status;

211

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

212

if(pid == 0){

213

/* Only still running child processes */

214

break;

215

}

216

if(pid == -1){

217

if (errno != ECHILD){

218

perror("waitpid");

219

}

220

/* No child processes */

221

break;

222

}

223

224

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

225

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

226

proc = proc->next;

227

}

228

if(proc == NULL){

229

/* Process not found in process list */

230

continue;

231

}

232

proc->status = status;

233

proc->completed = true;

234

}

155

process *proc = process_list;

156

int status;

157

pid_t pid = wait(&status);

158

if(pid == -1){

159

perror("wait");

160

return;

161

}

162

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

163

proc = proc->next;

164

}

165

if(proc == NULL){

166

/* Process not found in process list */

167

return;

168

}

169

proc->status = status;

170

proc->completed = true;

235

171

}

236

172

237

173

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

249

185

return true;

250

186

}

251

187

252

static void free_plugin_list(plugin *plugin_list){

253

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

254

next = plugin_list->next;

255

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

256

free(*arg);

257

}

258

free(plugin_list->argv);

259

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

260

free(*env);

261

}

262

free(plugin_list->environ);

263

free(plugin_list);

264

}

265

}

266

267

188

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

268

char *plugindir = NULL;

269

char *argfile = NULL;

270

FILE *conffp;

189

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

271

190

size_t d_name_len;

272

191

DIR *dir = NULL;

273

192

struct dirent *dirst;

281

200

struct sigaction old_sigchld_action;

282

201

struct sigaction sigchld_action = { .sa_handler = handle_sigchld,

283

202

.sa_flags = SA_NOCLDSTOP };

284

char **custom_argv = NULL;

285

int custom_argc = 0;

286

203

char *plus_options = NULL;

204

char **plus_argv = NULL;

205

287

206

/* Establish a signal handler */

288

207

sigemptyset(&sigchld_action.sa_mask);

289

208

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

290

if(ret == -1){

209

if(ret < 0){

291

210

perror("sigaddset");

292

exitstatus = EXIT_FAILURE;

293

goto fallback;

211

exit(EXIT_FAILURE);

294

212

}

295

213

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

296

if(ret == -1){

214

if(ret < 0){

297

215

perror("sigaction");

298

exitstatus = EXIT_FAILURE;

299

goto fallback;

216

exit(EXIT_FAILURE);

300

217

}

301

218

302

219

/* The options we understand. */

304

221

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

305

222

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

306

223

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

307

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

308

.arg = "VAR=value",

309

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

310

224

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

311

225

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

312

226

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

313

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

314

.arg = "PLUGIN:ENV=value",

315

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

316

227

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

317

228

.arg = "PLUGIN",

318

229

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

319

230

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

320

231

.arg = "DIRECTORY",

321

232

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

322

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

323

.arg = "FILE",

324

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

325

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

326

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

327

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

328

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

329

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

330

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

331

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

332

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

233

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

234

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

235

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

236

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

237

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

238

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

239

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

240

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

333

241

{ .name = NULL }

334

242

};

335

243

340

248

switch (key) {

341

249

case 'g':

342

250

if (arg != NULL){

343

char *p;

344

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

345

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

346

continue;

347

}

348

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

349

perror("add_argument");

350

return ARGP_ERR_UNKNOWN;

351

}

352

}

353

}

354

break;

355

case 'e':

356

if(arg == NULL){

357

break;

358

}

359

{

360

char *envdef = strdup(arg);

361

if(envdef == NULL){

362

break;

363

}

364

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

365

perror("add_environment");

366

}

251

char *p = strtok(arg, ",");

252

do{

253

addargument(getplugin(NULL, plugins), p);

254

p = strtok(NULL, ",");

255

} while (p != NULL);

367

256

}

368

257

break;

369

258

case 'o':

370

259

if (arg != NULL){

371

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

372

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

373

break;

374

}

375

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

376

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

377

break;

378

}

379

if(opt != NULL){

380

char *p;

381

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

382

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

383

continue;

384

}

385

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

386

perror("add_argument");

387

return ARGP_ERR_UNKNOWN;

388

}

389

}

390

}

391

}

392

break;

393

case 'f':

394

if(arg == NULL){

395

break;

396

}

397

{

398

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

399

if(envdef == NULL){

400

break;

401

}

402

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

403

if(p_name == NULL){

404

break;

405

}

406

envdef++;

407

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

408

perror("add_environment");

260

char *name = strtok(arg, ":");

261

char *p = strtok(NULL, ":");

262

if(p != NULL){

263

p = strtok(p, ",");

264

do{

265

addargument(getplugin(name, plugins), p);

266

p = strtok(NULL, ",");

267

} while (p != NULL);

409

268

}

410

269

}

411

270

break;

412

271

case 'd':

413

272

if (arg != NULL){

414

plugin *p = getplugin(arg, plugins);

415

if(p == NULL){

416

return ARGP_ERR_UNKNOWN;

417

}

418

p->disabled = true;

273

getplugin(arg, plugins)->disabled = true;

419

274

}

420

275

break;

421

276

case 128:

422

plugindir = strdup(arg);

423

if(plugindir == NULL){

424

perror("strdup");

425

}

277

plugindir = arg;

426

278

break;

427

279

case 129:

428

argfile = strdup(arg);

429

if(argfile == NULL){

430

perror("strdup");

431

}

432

break;

280

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

281

break;

433

282

case 130:

434

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

283

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

435

284

break;

436

285

case 131:

437

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

438

break;

439

case 132:

440

286

debug = true;

441

287

break;

442

288

case ARGP_KEY_ARG:

443

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

289

if(plus_options != NULL or arg == NULL or arg[0] != '+'){

290

argp_usage (state);

291

}

292

plus_options = arg;

444

293

break;

445

294

case ARGP_KEY_END:

446

295

break;

460

309

if (ret == ARGP_ERR_UNKNOWN){

461

310

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

462

311

exitstatus = EXIT_FAILURE;

463

goto fallback;

464

}

465

466

if (argfile == NULL){

467

conffp = fopen(AFILE, "r");

468

} else {

469

conffp = fopen(argfile, "r");

312

goto end;

470

313

}

471

314

472

if(conffp != NULL){

473

char *org_line = NULL;

474

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

475

size_t size = 0;

476

ssize_t sret;

477

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

478

const char comment_delim[] = "#";

479

480

custom_argc = 1;

481

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

482

if(custom_argv == NULL){

315

if(plus_options){

316

/* This is a mangled argument in the form of

317

"+--option+--other-option=parameter+--yet-another-option", etc */

318

/* Make new argc and argv vars, and call argp_parse() again. */

319

plus_options++; /* skip the first '+' character */

320

const char delims[] = "+";

321

char *arg;

322

int new_argc = 1;

323

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

324

if(plus_argv == NULL){

483

325

perror("malloc");

484

326

exitstatus = EXIT_FAILURE;

485

goto fallback;

486

}

487

custom_argv[0] = argv[0];

488

custom_argv[1] = NULL;

489

490

while(true){

491

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

492

if(sret == -1){

493

break;

494

}

495

496

line = org_line;

497

arg = strsep(&line, comment_delim);

498

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

499

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

500

continue;

501

}

502

new_arg = strdup(p);

503

if(new_arg == NULL){

504

perror("strdup");

505

exitstatus = EXIT_FAILURE;

506

free(org_line);

507

goto fallback;

508

}

509

510

custom_argc += 1;

511

custom_argv = realloc(custom_argv, sizeof(char *)

512

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

513

if(custom_argv == NULL){

514

perror("realloc");

515

exitstatus = EXIT_FAILURE;

516

free(org_line);

517

goto fallback;

518

}

519

custom_argv[custom_argc-1] = new_arg;

520

custom_argv[custom_argc] = NULL;

521

}

522

}

523

free(org_line);

524

} else{

525

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

526

not affect opening plugins */

527

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

528

perror("fopen");

529

exitstatus = EXIT_FAILURE;

530

goto fallback;

531

}

532

}

533

534

if(custom_argv != NULL){

535

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

327

goto end;

328

}

329

plus_argv[0] = argv[0];

330

plus_argv[1] = NULL;

331

arg = strtok(plus_options, delims); /* Get first argument */

332

while(arg != NULL){

333

new_argc++;

334

plus_argv = realloc(plus_argv, sizeof(char *)

335

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

336

if(plus_argv == NULL){

337

perror("realloc");

338

exitstatus = EXIT_FAILURE;

339

goto end;

340

}

341

plus_argv[new_argc-1] = arg;

342

plus_argv[new_argc] = NULL;

343

arg = strtok(NULL, delims); /* Get next argument */

344

}

345

ret = argp_parse (&argp, new_argc, plus_argv, 0, 0, &plugin_list);

536

346

if (ret == ARGP_ERR_UNKNOWN){

537

347

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

538

348

exitstatus = EXIT_FAILURE;

539

goto fallback;

349

goto end;

540

350

}

541

351

}

542

352

547

357

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

548

358

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

549

359

}

550

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

551

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

552

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

553

}

554

360

}

555

361

}

556

362

563

369

if (ret == -1){

564

370

perror("setgid");

565

371

}

566

567

if (plugindir == NULL){

568

dir = opendir(PDIR);

569

} else {

570

dir = opendir(plugindir);

571

}

572

372

373

dir = opendir(plugindir);

573

374

if(dir == NULL){

574

375

perror("Could not open plugin dir");

575

376

exitstatus = EXIT_FAILURE;

576

goto fallback;

377

goto end;

577

378

}

578

379

579

380

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

584

385

if(ret < 0){

585

386

perror("set_cloexec_flag");

586

387

exitstatus = EXIT_FAILURE;

587

goto fallback;

388

goto end;

588

389

}

589

390

}

590

391

}

599

400

if (errno == EBADF){

600

401

perror("readdir");

601

402

exitstatus = EXIT_FAILURE;

602

goto fallback;

403

goto end;

603

404

}

604

405

break;

605

406

}

650

451

continue;

651

452

}

652

453

}

653

654

char *filename;

655

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

656

if(ret < 0){

657

perror("asprintf");

454

455

char *filename = malloc(d_name_len + strlen(plugindir) + 2);

456

if (filename == NULL){

457

perror("malloc");

658

458

continue;

659

459

}

460

strcpy(filename, plugindir); /* Spurious warning */

461

strcat(filename, "/"); /* Spurious warning */

462

strcat(filename, dirst->d_name); /* Spurious warning */

660

463

661

464

ret = stat(filename, &st);

662

465

if (ret == -1){

673

476

free(filename);

674

477

continue;

675

478

}

676

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

677

if(p == NULL){

678

perror("getplugin");

679

free(filename);

680

continue;

681

}

682

if(p->disabled){

479

if(getplugin(dirst->d_name, &plugin_list)->disabled){

683

480

if(debug){

684

481

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

685

482

dirst->d_name);

687

484

free(filename);

688

485

continue;

689

486

}

487

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

690

488

{

691

489

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

692

490

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

693

if(g != NULL){

694

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

695

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

696

perror("add_argument");

697

}

698

}

699

/* Add global environment variables */

700

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

701

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

702

perror("add_environment");

703

}

704

}

705

}

706

}

707

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

708

using execve and need to duplicate the environment from this

709

process, too. */

710

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

711

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

712

char *copy = strdup(*e);

713

if(copy == NULL){

714

perror("strdup");

715

continue;

716

}

717

if(not add_environment(p, copy)){

718

perror("add_environment");

719

}

720

}

721

}

722

723

int pipefd[2];

491

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

492

addargument(p, *a);

493

}

494

}

495

int pipefd[2];

724

496

ret = pipe(pipefd);

725

497

if (ret == -1){

726

498

perror("pipe");

727

499

exitstatus = EXIT_FAILURE;

728

goto fallback;

500

goto end;

729

501

}

730

502

ret = set_cloexec_flag(pipefd[0]);

731

503

if(ret < 0){

732

504

perror("set_cloexec_flag");

733

505

exitstatus = EXIT_FAILURE;

734

goto fallback;

506

goto end;

735

507

}

736

508

ret = set_cloexec_flag(pipefd[1]);

737

509

if(ret < 0){

738

510

perror("set_cloexec_flag");

739

511

exitstatus = EXIT_FAILURE;

740

goto fallback;

512

goto end;

741

513

}

742

514

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

743

515

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

744

516

if(ret < 0){

745

517

perror("sigprocmask");

746

518

exitstatus = EXIT_FAILURE;

747

goto fallback;

519

goto end;

748

520

}

749

521

// Starting a new process to be watched

750

522

pid_t pid = fork();

751

523

if(pid == -1){

752

524

perror("fork");

753

525

exitstatus = EXIT_FAILURE;

754

goto fallback;

526

goto end;

755

527

}

756

528

if(pid == 0){

757

529

/* this is the child process */

777

549

above and must now close it manually here. */

778

550

closedir(dir);

779

551

}

780

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

781

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

782

perror("execv");

783

_exit(EXIT_FAILURE);

784

}

785

} else {

786

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

787

perror("execve");

788

_exit(EXIT_FAILURE);

789

}

552

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

553

perror("execv");

554

_exit(EXIT_FAILURE);

790

555

}

791

556

/* no return */

792

557

}

801

566

perror("sigprocmask");

802

567

}

803

568

exitstatus = EXIT_FAILURE;

804

goto fallback;

569

goto end;

805

570

}

806

571

807

572

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

815

580

if(ret < 0){

816

581

perror("sigprocmask");

817

582

exitstatus = EXIT_FAILURE;

818

goto fallback;

583

goto end;

819

584

}

820

585

821

586

FD_SET(new_process->fd, &rfds_all);

825

590

}

826

591

827

592

}

828

829

free_plugin_list(plugin_list);

830

plugin_list = NULL;

593

594

/* Free the plugin list */

595

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

596

next = plugin_list->next;

597

free(plugin_list->argv);

598

free(plugin_list);

599

}

831

600

832

601

closedir(dir);

833

602

dir = NULL;

843

612

if (select_ret == -1){

844

613

perror("select");

845

614

exitstatus = EXIT_FAILURE;

846

goto fallback;

615

goto end;

847

616

}

848

617

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

849

618

from one of them */

871

640

/* Remove the plugin */

872

641

FD_CLR(proc->fd, &rfds_all);

873

642

/* Block signal while modifying process_list */

874

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

643

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

875

644

if(ret < 0){

876

645

perror("sigprocmask");

877

646

exitstatus = EXIT_FAILURE;

878

goto fallback;

647

goto end;

879

648

}

880

649

/* Delete this process entry from the list */

881

650

if(process_list == proc){

905

674

}

906

675

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

907

676

908

bool bret = print_out_password(proc->buffer,

909

proc->buffer_length);

677

bool bret = print_out_password(proc->buffer, proc->buffer_length);

910

678

if(not bret){

911

679

perror("print_out_password");

912

680

exitstatus = EXIT_FAILURE;

913

681

}

914

goto fallback;

682

goto end;

915

683

}

916

684

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

917

685

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

925

693

if (proc->buffer == NULL){

926

694

perror("malloc");

927

695

exitstatus = EXIT_FAILURE;

928

goto fallback;

696

goto end;

929

697

}

930

698

proc->buffer_size += BUFFER_SIZE;

931

699

}

946

714

}

947

715

948

716

949

fallback:

717

end:

950

718

951

719

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

952

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

953

occured */

720

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

954

721

bool bret;

955

722

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

956

723

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

958

725

if(not bret){

959

726

perror("print_out_password");

960

727

exitstatus = EXIT_FAILURE;

728

goto end;

961

729

}

962

730

}

963

731

964

732

/* Restore old signal handler */

965

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

966

if(ret == -1){

967

perror("sigaction");

968

exitstatus = EXIT_FAILURE;

969

}

970

971

if(custom_argv != NULL){

972

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

973

free(*arg);

974

}

975

free(custom_argv);

976

}

977

free_plugin_list(plugin_list);

733

sigaction(SIGCHLD, &old_sigchld_action, NULL);

734

735

free(plus_argv);

736

737

/* Free the plugin list */

738

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

739

next = plugin_list->next;

740

free(plugin_list->argv);

741

free(plugin_list);

742

}

978

743

979

744

if(dir != NULL){

980

745

closedir(dir);

1000

765

if(errno != ECHILD){

1001

766

perror("wait");

1002

767

}

1003

1004

free(plugindir);

1005

free(argfile);

1006

768

1007

769

return exitstatus;

1008

770

}