/mandos/release : revision 24.1.51

23

24

#define _GNU_SOURCE /* TEMP_FAILURE_RETRY() */

25

26

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

27

stderr, STDOUT_FILENO */

26

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

27

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

28

EXIT_SUCCESS, realloc() */

29

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

30

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

31

fprintf(), stderr, STDOUT_FILENO */

32

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

33

stat, waitpid(), WIFEXITED(),

34

WEXITSTATUS(), wait(), pid_t,

35

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

36

dirfd() */

37

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

38

FD_SET(), FD_ISSET(), FD_CLR */

39

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

40

WEXITSTATUS() */

41

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

28

42

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

29

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

30

struct stat, waitpid(),

31

WIFEXITED(), WEXITSTATUS(),

32

wait() */

33

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

34

43

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

35

readdir(), closedir() */

36

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

44

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

37

45

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

38

fcntl() */

39

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

40

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

41

#include <stdlib.h> /* EXIT_FAILURE */

42

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

43

FD_SET(), FD_ISSET() */

44

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

45

#include <stdbool.h> /* true */

46

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

47

WEXITSTATUS() */

46

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

47

F_GETFD, F_SETFD, FD_CLOEXEC,

48

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

49

dup2, STDOUT_FILENO, _exit(),

50

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

51

close() */

52

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

53

FD_CLOEXEC */

54

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

55

strcat() */

48

56

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

49

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

50

struct argp_state, struct argp,

51

argp_parse() */

57

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

58

argp_state, struct argp,

59

argp_parse(), ARGP_ERR_UNKNOWN,

60

ARGP_KEY_END, ARGP_KEY_ARG, error_t */

61

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

62

sigaddset(), sigaction(),

63

sigprocmask(), SIG_BLOCK, SIGCHLD,

64

SIG_UNBLOCK, kill() */

65

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

66

67

#define BUFFER_SIZE 256

68

#define CONFFILE "/conf/conf.d/mandos/client.conf"

69

70

const char *argp_program_version = "mandos-client 1.0";

71

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

52

72

53

73

struct process;

54

74

58

78

char *buffer;

59

79

size_t buffer_size;

60

80

size_t buffer_length;

81

bool eof;

82

bool completed;

83

int status;

61

84

struct process *next;

62

85

} process;

63

86

69

92

struct plugin *next;

70

93

} plugin;

71

94

72

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

95

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

73

96

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

74

97

if ((p->name == name)

75

98

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

98

121

return new_plugin;

99

122

}

100

123

101

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

124

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

102

125

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

103

126

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

104

127

if (p->argv == NULL){

114

137

* Descriptor Flags".

115

138

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

116

139

*/

117

int set_cloexec_flag(int fd)

140

static int set_cloexec_flag(int fd)

118

141

{

119

142

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

120

143

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

125

148

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

126

149

}

127

150

128

129

#define BUFFER_SIZE 256

130

131

const char *argp_program_version =

132

"plugbasedclient 0.9";

133

const char *argp_program_bug_address =

134

"<mandos@fukt.bsnet.se>";

151

process *process_list = NULL;

152

153

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

154

status. */

155

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

156

process *proc = process_list;

157

int status;

158

pid_t pid = wait(&status);

159

if(pid == -1){

160

perror("wait");

161

return;

162

}

163

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

164

proc = proc->next;

165

}

166

if(proc == NULL){

167

/* Process not found in process list */

168

return;

169

}

170

proc->status = status;

171

proc->completed = true;

172

}

173

174

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

175

ssize_t ret;

176

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

177

length--;

178

}

179

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

180

ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO, buffer + written,

181

length - written));

182

if(ret < 0){

183

return false;

184

}

185

}

186

return true;

187

}

188

189

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

190

191

if (argv == NULL){

192

*argc = 1;

193

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

194

if(argv == NULL){

195

return NULL;

196

}

197

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

198

argv[1] = NULL;

199

}

200

*argc += 1;

201

argv = realloc(argv, sizeof(char *)

202

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

203

if(argv == NULL){

204

return NULL;

205

}

206

argv[*argc-1] = arg;

207

argv[*argc] = NULL;

208

return argv;

209

}

135

210

136

211

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

137

212

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

213

const char *conffile = CONFFILE;

214

FILE *conffp;

138

215

size_t d_name_len;

139

DIR *dir;

216

DIR *dir = NULL;

140

217

struct dirent *dirst;

141

218

struct stat st;

142

219

fd_set rfds_all;

143

220

int ret, maxfd = 0;

144

process *process_list = NULL;

221

uid_t uid = 65534;

222

gid_t gid = 65534;

145

223

bool debug = false;

146

224

int exitstatus = EXIT_SUCCESS;

225

struct sigaction old_sigchld_action;

226

struct sigaction sigchld_action = { .sa_handler = handle_sigchld,

227

.sa_flags = SA_NOCLDSTOP };

228

char **custom_argv = NULL;

229

int custom_argc = 0;

230

231

/* Establish a signal handler */

232

sigemptyset(&sigchld_action.sa_mask);

233

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

234

if(ret < 0){

235

perror("sigaddset");

236

exit(EXIT_FAILURE);

237

}

238

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

239

if(ret < 0){

240

perror("sigaction");

241

exit(EXIT_FAILURE);

242

}

147

243

148

244

/* The options we understand. */

149

245

struct argp_option options[] = {

159

255

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

160

256

.arg = "DIRECTORY",

161

257

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

162

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

258

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

259

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

260

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

261

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

262

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

263

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

264

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

163

265

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

164

266

{ .name = NULL }

165

267

};

166

268

167

269

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

168

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

169

know is a pointer to our plugin list pointer. */

270

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

271

pointer to our plugin list pointer. */

170

272

plugin **plugins = state->input;

171

273

switch (key) {

172

274

case 'g':

173

275

if (arg != NULL){

174

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

175

do{

276

char *p;

277

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

278

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

279

continue;

280

}

176

281

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

177

p = strtok(NULL, ",");

178

} while (p);

282

}

179

283

}

180

284

break;

181

285

case 'o':

182

286

if (arg != NULL){

183

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

184

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

185

if(p){

186

p = strtok(p, ",");

187

do{

287

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

288

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

289

break;

290

}

291

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

292

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

293

break;

294

}

295

if(opt != NULL){

296

char *p;

297

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

298

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

299

continue;

300

}

188

301

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

189

p = strtok(NULL, ",");

190

} while (p);

302

}

191

303

}

192

304

}

193

305

break;

200

312

plugindir = arg;

201

313

break;

202

314

case 129:

315

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

316

break;

317

case 130:

318

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

319

break;

320

case 131:

203

321

debug = true;

204

322

break;

205

323

case ARGP_KEY_ARG:

206

argp_usage (state);

324

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

207

325

break;

208

326

case ARGP_KEY_END:

209

327

break;

216

334

plugin *plugin_list = NULL;

217

335

218

336

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

219

.args_doc = "",

337

.args_doc = "[+PLUS_SEPARATED_OPTIONS]",

220

338

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

221

339

222

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

340

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

341

if (ret == ARGP_ERR_UNKNOWN){

342

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

343

exitstatus = EXIT_FAILURE;

344

goto end;

345

}

346

347

conffp = fopen(conffile, "r");

348

if(conffp != NULL){

349

char *org_line = NULL;

350

size_t size = 0;

351

ssize_t sret;

352

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

353

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

354

const char comment_delim[] = "#";

355

356

while(true){

357

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

358

if(sret == -1){

359

break;

360

}

361

362

line = org_line;

363

arg = strsep(&line, comment_delim);

364

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

365

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

366

continue;

367

}

368

new_arg = strdup(p);

369

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

370

if (custom_argv == NULL){

371

perror("addcustomargument");

372

exitstatus = EXIT_FAILURE;

373

goto end;

374

}

375

}

376

}

377

free(org_line);

378

} else{

379

/* check for harmfull errors */

380

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

381

perror("fopen");

382

exitstatus = EXIT_FAILURE;

383

goto end;

384

}

385

}

386

387

if(custom_argv != NULL){

388

custom_argv[0] = argv[0];

389

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

390

if (ret == ARGP_ERR_UNKNOWN){

391

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

392

exitstatus = EXIT_FAILURE;

393

goto end;

394

}

395

}

223

396

224

397

if(debug){

225

398

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

231

404

}

232

405

}

233

406

407

ret = setuid(uid);

408

if (ret == -1){

409

perror("setuid");

410

}

411

412

setgid(gid);

413

if (ret == -1){

414

perror("setgid");

415

}

416

234

417

dir = opendir(plugindir);

235

418

if(dir == NULL){

236

419

perror("Could not open plugin dir");

237

420

exitstatus = EXIT_FAILURE;

238

421

goto end;

239

422

}

423

240

424

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

241

425

{

242

426

int dir_fd = dirfd(dir);

250

434

}

251

435

}

252

436

253

if(dir == NULL){

254

fprintf(stderr, "Can not open directory\n");

255

return EXIT_FAILURE;

256

}

257

258

437

FD_ZERO(&rfds_all);

259

438

260

439

while(true){

262

441

263

442

// All directory entries have been processed

264

443

if(dirst == NULL){

444

if (errno == EBADF){

445

perror("readdir");

446

exitstatus = EXIT_FAILURE;

447

goto end;

448

}

265

449

break;

266

450

}

267

451

315

499

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

316

500

if (filename == NULL){

317

501

perror("malloc");

318

exitstatus = EXIT_FAILURE;

319

goto end;

320

}

321

strcpy(filename, plugindir);

322

strcat(filename, "/");

323

strcat(filename, dirst->d_name);

324

325

stat(filename, &st);

326

502

continue;

503

}

504

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

505

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

506

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

507

508

ret = stat(filename, &st);

509

if (ret == -1){

510

perror("stat");

511

free(filename);

512

continue;

513

}

514

327

515

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

328

516

if(debug){

329

517

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

330

518

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

331

519

}

520

free(filename);

332

521

continue;

333

522

}

334

523

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

336

525

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

337

526

dirst->d_name);

338

527

}

528

free(filename);

339

529

continue;

340

530

}

341

531

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

365

555

exitstatus = EXIT_FAILURE;

366

556

goto end;

367

557

}

558

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

559

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

560

if(ret < 0){

561

perror("sigprocmask");

562

exitstatus = EXIT_FAILURE;

563

goto end;

564

}

368

565

// Starting a new process to be watched

369

566

pid_t pid = fork();

567

if(pid == -1){

568

perror("fork");

569

exitstatus = EXIT_FAILURE;

570

goto end;

571

}

370

572

if(pid == 0){

371

573

/* this is the child process */

372

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

574

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

575

if(ret < 0){

576

perror("sigaction");

577

_exit(EXIT_FAILURE);

578

}

579

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

580

if(ret < 0){

581

perror("sigprocmask");

582

_exit(EXIT_FAILURE);

583

}

584

585

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

586

if(ret == -1){

587

perror("dup2");

588

_exit(EXIT_FAILURE);

589

}

373

590

374

591

if(dirfd(dir) < 0){

375

592

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

376

and must close it manually */

593

above and must now close it manually here. */

377

594

closedir(dir);

378

595

}

379

596

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

383

600

/* no return */

384

601

}

385

602

/* parent process */

603

free(filename);

386

604

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

387

605

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

388

606

if (new_process == NULL){

389

607

perror("malloc");

608

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

609

if(ret < 0){

610

perror("sigprocmask");

611

}

390

612

exitstatus = EXIT_FAILURE;

391

613

goto end;

392

614

}

394

616

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

395

617

.fd = pipefd[0],

396

618

.next = process_list };

619

// List handling

620

process_list = new_process;

621

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

622

has already completed */

623

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

624

if(ret < 0){

625

perror("sigprocmask");

626

exitstatus = EXIT_FAILURE;

627

goto end;

628

}

629

397

630

FD_SET(new_process->fd, &rfds_all);

398

631

399

632

if (maxfd < new_process->fd){

400

633

maxfd = new_process->fd;

401

634

}

402

635

403

//List handling

404

process_list = new_process;

405

636

}

406

637

407

638

/* Free the plugin list */

412

643

}

413

644

414

645

closedir(dir);

415

646

dir = NULL;

647

416

648

if (process_list == NULL){

417

fprintf(stderr, "No plugin processes started, exiting\n");

418

return EXIT_FAILURE;

649

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

650

" directory?\n");

651

process_list = NULL;

419

652

}

420

while(true){

653

while(process_list){

421

654

fd_set rfds = rfds_all;

422

655

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

423

656

if (select_ret == -1){

425

658

exitstatus = EXIT_FAILURE;

426

659

goto end;

427

660

}

661

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

662

from one of them */

428

663

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

429

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

664

/* Is this process completely done? */

665

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

666

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

667

if(not WIFEXITED(proc->status)

668

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

669

/* Bad exit by plugin */

670

if(debug){

671

if(WIFEXITED(proc->status)){

672

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

673

(unsigned int) (proc->pid),

674

WEXITSTATUS(proc->status));

675

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

676

fprintf(stderr, "Plugin %u killed by signal %d\n",

677

(unsigned int) (proc->pid),

678

WTERMSIG(proc->status));

679

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

680

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

681

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

682

}

683

}

684

/* Remove the plugin */

685

FD_CLR(proc->fd, &rfds_all);

686

/* Block signal while modifying process_list */

687

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

688

if(ret < 0){

689

perror("sigprocmask");

690

exitstatus = EXIT_FAILURE;

691

goto end;

692

}

693

/* Delete this process entry from the list */

694

if(process_list == proc){

695

/* First one - simple */

696

process_list = proc->next;

697

} else {

698

/* Second one or later */

699

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

700

if(p->next == proc){

701

p->next = proc->next;

702

break;

703

}

704

}

705

}

706

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

707

ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,

708

NULL);

709

if(ret < 0){

710

perror("sigprocmask");

711

}

712

free(proc->buffer);

713

free(proc);

714

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

715

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

716

the process list */

717

break;

718

}

719

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

720

721

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

722

if(not bret){

723

perror("print_out_password");

724

exitstatus = EXIT_FAILURE;

725

}

726

goto end;

727

}

728

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

729

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

730

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

430

731

continue;

431

732

}

733

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

432

734

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

433

735

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

434

736

+ (size_t) BUFFER_SIZE);

439

741

}

440

742

proc->buffer_size += BUFFER_SIZE;

441

743

}

744

/* Read from the process */

442

745

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

443

746

BUFFER_SIZE);

444

747

if(ret < 0){

445

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

748

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

446

749

continue;

447

750

}

448

proc->buffer_length += (size_t) ret;

449

751

if(ret == 0){

450

752

/* got EOF */

451

/* wait for process exit */

452

int status;

453

waitpid(proc->pid, &status, 0);

454

if(not WIFEXITED(status) or WEXITSTATUS(status) != 0){

455

FD_CLR(proc->fd, &rfds_all);

456

continue;

457

}

458

for(size_t written = 0;

459

written < proc->buffer_length; written += (size_t)ret){

460

ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO,

461

proc->buffer + written,

462

proc->buffer_length

463

- written));

464

if(ret < 0){

465

perror("write");

466

exitstatus = EXIT_FAILURE;

467

goto end;

468

}

469

}

470

goto end;

753

proc->eof = true;

754

} else {

755

proc->buffer_length += (size_t) ret;

471

756

}

472

757

}

473

758

}

474

759

760

475

761

end:

762

763

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

764

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

765

bool bret;

766

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

767

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

768

bret = print_out_password(passwordbuffer, strlen(passwordbuffer));

769

if(not bret){

770

perror("print_out_password");

771

exitstatus = EXIT_FAILURE;

772

goto end;

773

}

774

}

775

776

/* Restore old signal handler */

777

sigaction(SIGCHLD, &old_sigchld_action, NULL);

778

779

free(custom_argv);

780

781

/* Free the plugin list */

782

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

783

next = plugin_list->next;

784

free(plugin_list->argv);

785

free(plugin_list);

786

}

787

788

if(dir != NULL){

789

closedir(dir);

790

}

791

792

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

476

793

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

794

next = process_list->next;

477

795

close(process_list->fd);

478

kill(process_list->pid, SIGTERM);

796

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

797

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

798

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

799

perror("kill");

800

}

479

801

free(process_list->buffer);

480

802

free(process_list);

481

803

}

482

804

483

while(true){

484

int status;

485

ret = wait(&status);

486

if (ret == -1){

487

if(errno != ECHILD){

488

perror("wait");

489

}

490

break;

491

}

492

}

805

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

806

do{

807

ret = wait(NULL);

808

} while(ret >= 0);

809

if(errno != ECHILD){

810

perror("wait");

811

}

812

493

813

return exitstatus;

494

814

}