/mandos/trunk : revision 48

21

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

22

*/

23

24

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

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

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

26

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

27

stderr, STDOUT_FILENO */

42

28

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

43

34

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

44

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

35

readdir(), closedir() */

36

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

45

37

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

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

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

56

48

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

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

49

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

50

struct argp_state, struct argp,

51

argp_parse() */

66

52

67

53

#define BUFFER_SIZE 256

68

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

69

70

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

71

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

72

54

73

55

struct process;

74

56

148

130

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

149

131

}

150

132

133

const char *argp_program_version = "plugbasedclient 0.9";

134

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

135

151

136

process *process_list = NULL;

152

137

153

138

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

156

141

process *proc = process_list;

157

142

int status;

158

143

pid_t pid = wait(&status);

159

if(pid == -1){

160

perror("wait");

161

return;

162

}

163

144

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

164

145

proc = proc->next;

165

146

}

171

152

proc->completed = true;

172

153

}

173

154

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

}

210

211

155

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

212

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

213

const char *argfile = ARGFILE;

214

FILE *conffp;

156

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

215

157

size_t d_name_len;

216

158

DIR *dir = NULL;

217

159

struct dirent *dirst;

225

167

struct sigaction old_sigchld_action;

226

168

struct sigaction sigchld_action = { .sa_handler = handle_sigchld,

227

169

.sa_flags = SA_NOCLDSTOP };

228

char **custom_argv = NULL;

229

int custom_argc = 0;

170

char *plus_options = NULL;

171

char **plus_argv = NULL;

230

172

231

173

/* Establish a signal handler */

232

174

sigemptyset(&sigchld_action.sa_mask);

273

215

switch (key) {

274

216

case 'g':

275

217

if (arg != NULL){

276

char *p;

277

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

278

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

279

continue;

280

}

218

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

219

do{

281

220

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

282

}

221

p = strtok(NULL, ",");

222

} while (p != NULL);

283

223

}

284

224

break;

285

225

case 'o':

286

226

if (arg != NULL){

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

}

227

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

228

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

229

if(p != NULL){

230

p = strtok(p, ",");

231

do{

301

232

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

302

}

233

p = strtok(NULL, ",");

234

} while (p != NULL);

303

235

}

304

236

}

305

237

break;

321

253

debug = true;

322

254

break;

323

255

case ARGP_KEY_ARG:

324

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

256

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

257

argp_usage (state);

258

}

259

plus_options = arg;

325

260

break;

326

261

case ARGP_KEY_END:

327

262

break;

337

272

.args_doc = "[+PLUS_SEPARATED_OPTIONS]",

338

273

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

339

274

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(argfile, "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 harmful errors and go to fallback. Other errors might

380

not affect opening plugins */

381

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

382

perror("fopen");

383

exitstatus = EXIT_FAILURE;

384

goto end;

385

}

386

}

387

388

if(custom_argv != NULL){

389

custom_argv[0] = argv[0];

390

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

391

if (ret == ARGP_ERR_UNKNOWN){

392

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

393

exitstatus = EXIT_FAILURE;

394

goto end;

395

}

275

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

276

277

if(plus_options){

278

/* This is a mangled argument in the form of

279

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

280

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

281

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

282

const char delims[] = "+";

283

char *arg;

284

int new_argc = 1;

285

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

286

if(plus_argv == NULL){

287

perror("malloc");

288

exitstatus = EXIT_FAILURE;

289

goto end;

290

}

291

plus_argv[0] = argv[0];

292

plus_argv[1] = NULL;

293

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

294

while(arg != NULL){

295

new_argc++;

296

plus_argv = realloc(plus_argv, sizeof(char *)

297

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

298

if(plus_argv == NULL){

299

perror("malloc");

300

exitstatus = EXIT_FAILURE;

301

goto end;

302

}

303

plus_argv[new_argc-1] = arg;

304

plus_argv[new_argc] = NULL;

305

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

306

}

307

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

396

308

}

397

309

398

310

if(debug){

442

354

443

355

// All directory entries have been processed

444

356

if(dirst == NULL){

445

if (errno == EBADF){

446

perror("readdir");

447

exitstatus = EXIT_FAILURE;

448

goto end;

449

}

450

357

break;

451

358

}

452

359

500

407

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

501

408

if (filename == NULL){

502

409

perror("malloc");

503

continue;

410

exitstatus = EXIT_FAILURE;

411

goto end;

504

412

}

505

413

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

506

414

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

507

415

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

508

416

509

ret = stat(filename, &st);

510

if (ret == -1){

511

perror("stat");

512

free(filename);

513

continue;

514

}

417

stat(filename, &st);

515

418

516

419

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

517

420

if(debug){

565

468

}

566

469

// Starting a new process to be watched

567

470

pid_t pid = fork();

568

if(pid == -1){

569

perror("fork");

570

exitstatus = EXIT_FAILURE;

571

goto end;

572

}

573

471

if(pid == 0){

574

472

/* this is the child process */

575

473

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

582

480

perror("sigprocmask");

583

481

_exit(EXIT_FAILURE);

584

482

}

585

586

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

587

if(ret == -1){

588

perror("dup2");

589

_exit(EXIT_FAILURE);

590

}

483

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

591

484

592

485

if(dirfd(dir) < 0){

593

486

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

645

538

646

539

closedir(dir);

647

540

dir = NULL;

648

541

649

542

if (process_list == NULL){

650

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

651

" directory?\n");

652

process_list = NULL;

543

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

544

exitstatus = EXIT_FAILURE;

545

goto end;

653

546

}

654

547

while(process_list){

655

548

fd_set rfds = rfds_all;

670

563

/* Bad exit by plugin */

671

564

if(debug){

672

565

if(WIFEXITED(proc->status)){

673

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

674

(unsigned int) (proc->pid),

675

WEXITSTATUS(proc->status));

566

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

567

proc->pid, WEXITSTATUS(proc->status));

676

568

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

677

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

678

(unsigned int) (proc->pid),

679

WTERMSIG(proc->status));

569

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

570

proc->pid, WTERMSIG(proc->status));

680

571

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

681

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

682

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

572

fprintf(stderr, "Plugin %d dumped core\n", proc->pid);

683

573

}

684

574

}

685

575

/* Remove the plugin */

718

608

break;

719

609

}

720

610

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

721

722

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

723

if(not bret){

724

perror("print_out_password");

725

exitstatus = EXIT_FAILURE;

611

for(size_t written = 0; written < proc->buffer_length;

612

written += (size_t)ret){

613

ret = TEMP_FAILURE_RETRY(write(STDOUT_FILENO,

614

proc->buffer + written,

615

proc->buffer_length

616

- written));

617

if(ret < 0){

618

perror("write");

619

exitstatus = EXIT_FAILURE;

620

goto end;

621

}

726

622

}

727

623

goto end;

728

624

}

757

653

}

758

654

}

759

655

}

760

761

656

if(process_list == NULL){

657

fprintf(stderr, "All plugin processes failed, exiting\n");

658

exitstatus = EXIT_FAILURE;

659

}

660

762

661

end:

763

764

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

765

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

766

bool bret;

767

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

768

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

769

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

770

if(not bret){

771

perror("print_out_password");

772

exitstatus = EXIT_FAILURE;

773

goto end;

774

}

775

}

776

777

662

/* Restore old signal handler */

778

663

sigaction(SIGCHLD, &old_sigchld_action, NULL);

779

664

780

free(custom_argv);

665

free(plus_argv);

781

666

782

667

/* Free the plugin list */

783

668

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

794

679

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

795

680

next = process_list->next;

796

681

close(process_list->fd);

797

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

798

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

799

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

800

perror("kill");

801

}

682

kill(process_list->pid, SIGTERM);

802

683

free(process_list->buffer);

803

684

free(process_list);

804

685

}