/mandos/release : revision 198

1

/* -*- mode: c; coding: utf-8; after-save-hook: (lambda () (let* ((find-build-directory (lambda (try-directory &optional base-directory) (let ((base-directory (or base-directory try-directory))) (cond ((equal try-directory "/") base-directory) ((file-readable-p (concat (file-name-as-directory try-directory) "Makefile")) try-directory) ((funcall find-build-directory (directory-file-name (file-name-directory try-directory)) base-directory)))))) (build-directory (funcall find-build-directory (buffer-file-name))) (local-build-directory (if (fboundp 'file-local-name) (file-local-name build-directory) (or (file-remote-p build-directory 'localname) build-directory))) (command (file-relative-name (file-name-sans-extension (buffer-file-name)) build-directory))) (pcase (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (let ((qbdir (shell-quote-argument local-build-directory)) (qcmd (shell-quote-argument command))) (format "cd %s && CFLAGS=-Werror make --silent %s && %s --test --verbose" qbdir qcmd qcmd)) nil "*Test*")) (0 (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w)))) (_ (with-current-buffer "*Test*" (compilation-mode) (cd-absolute build-directory)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); -*- */

2

/*

3

* Mandos password agent - Simple password agent to run Mandos client

4

*

5

6

7

*

8

* This file is part of Mandos.

9

*

10

* Mandos is free software: you can redistribute it and/or modify it

11

* under the terms of the GNU General Public License as published by

12

* the Free Software Foundation, either version 3 of the License, or

13

* (at your option) any later version.

14

*

15

* Mandos is distributed in the hope that it will be useful, but

16

* WITHOUT ANY WARRANTY; without even the implied warranty of

17

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

18

* General Public License for more details.

19

*

20

* You should have received a copy of the GNU General Public License

21

* along with Mandos. If not, see <http://www.gnu.org/licenses/>.

22

*

23

* Contact the authors at <mandos@recompile.se>.

24

*/

25

26

#define _GNU_SOURCE

27

#include <inttypes.h> /* uintmax_t, PRIuMAX, PRIdMAX,

28

intmax_t, uint32_t, SCNx32,

29

SCNuMAX, SCNxMAX */

30

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

31

#include <sys/types.h> /* pid_t, uid_t, gid_t, getuid(),

32

getpid() */

33

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

34

#include <signal.h> /* struct sigaction, sigset_t,

35

sigemptyset(), sigaddset(),

36

SIGCHLD, pthread_sigmask(),

37

SIG_BLOCK, SIG_SETMASK, SA_RESTART,

38

SA_NOCLDSTOP, sigfillset(), kill(),

39

SIGTERM, sigdelset(), SIGKILL,

40

NSIG, sigismember(), SA_ONSTACK,

41

SIG_DFL, SIG_IGN, SIGINT, SIGQUIT,

42

SIGHUP, SIGSTOP, SIG_UNBLOCK */

43

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

44

malloc(), free(), strtoumax(),

45

realloc(), setenv(), calloc(),

46

mkdtemp(), mkostemp() */

47

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

48

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

49

#include <sysexits.h> /* EX_USAGE, EX_OSERR, EX_OSFILE */

50

#include <errno.h> /* errno, error_t, EACCES,

51

ENAMETOOLONG, ENOENT, ENOTDIR,

52

EEXIST, ECHILD, EPERM, ENOMEM,

53

EAGAIN, EINTR, ENOBUFS, EADDRINUSE,

54

ECONNREFUSED, ECONNRESET,

55

ETOOMANYREFS, EMSGSIZE, EBADF,

56

EINVAL */

57

#include <string.h> /* strdup(), memcpy(),

58

explicit_bzero(), memset(),

59

strcmp(), strlen(), strncpy(),

60

memcmp(), basename() */

61

#include <argz.h> /* argz_create(), argz_count(),

62

argz_extract(), argz_next(),

63

argz_add() */

64

#include <sys/epoll.h> /* epoll_create1(), EPOLL_CLOEXEC,

65

epoll_ctl(), EPOLL_CTL_ADD,

66

struct epoll_event, EPOLLIN,

67

EPOLLRDHUP, EPOLLOUT,

68

epoll_pwait() */

69

#include <time.h> /* struct timespec, clock_gettime(),

70

CLOCK_MONOTONIC */

71

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

72

OPTION_ALIAS, struct argp_state,

73

ARGP_ERR_UNKNOWN, ARGP_KEY_ARGS,

74

struct argp, argp_parse(),

75

ARGP_NO_EXIT */

76

#include <unistd.h> /* uid_t, gid_t, close(), pipe2(),

77

fork(), _exit(), dup2(),

78

STDOUT_FILENO, setresgid(),

79

setresuid(), execv(), ssize_t,

80

read(), dup3(), getuid(), dup(),

81

STDERR_FILENO, pause(), write(),

82

rmdir(), unlink(), getpid() */

83

#include <sys/mman.h> /* munlock(), mlock() */

84

#include <fcntl.h> /* O_CLOEXEC, O_NONBLOCK, fcntl(),

85

F_GETFD, F_GETFL, FD_CLOEXEC,

86

open(), O_WRONLY, O_NOCTTY,

87

O_RDONLY, O_NOFOLLOW */

88

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

89

WEXITSTATUS() */

90

#include <limits.h> /* PIPE_BUF, NAME_MAX, INT_MAX */

91

#include <sys/inotify.h> /* inotify_init1(), IN_NONBLOCK,

92

IN_CLOEXEC, inotify_add_watch(),

93

IN_CLOSE_WRITE, IN_MOVED_TO,

94

IN_MOVED_FROM, IN_DELETE,

95

IN_EXCL_UNLINK, IN_ONLYDIR,

96

struct inotify_event */

97

#include <fnmatch.h> /* fnmatch(), FNM_FILE_NAME */

98

#include <stdio.h> /* asprintf(), FILE, fopen(),

99

getline(), sscanf(), feof(),

100

ferror(), fclose(), stderr,

101

rename(), fdopen(), fprintf(),

102

fscanf() */

103

#include <glib.h> /* GKeyFile, g_key_file_free(), g_key_file_new(),

104

GError, g_key_file_load_from_file(),

105

G_KEY_FILE_NONE, TRUE, G_FILE_ERROR_NOENT,

106

g_key_file_get_string(), guint64,

107

g_key_file_get_uint64(),

108

G_KEY_FILE_ERROR_KEY_NOT_FOUND, gconstpointer,

109

g_assert_true(), g_assert_nonnull(),

110

g_assert_null(), g_assert_false(),

111

g_assert_cmpint(), g_assert_cmpuint(),

112

g_test_skip(), g_assert_cmpstr(),

113

g_test_init(), g_test_add(), g_test_run(),

114

GOptionContext, g_option_context_new(),

115

g_option_context_set_help_enabled(), FALSE,

116

g_option_context_set_ignore_unknown_options(),

117

gboolean, GOptionEntry, G_OPTION_ARG_NONE,

118

g_option_context_add_main_entries(),

119

g_option_context_parse(),

120

g_option_context_free(), g_error() */

121

#include <sys/un.h> /* struct sockaddr_un, SUN_LEN */

122

#include <sys/socket.h> /* AF_LOCAL, socket(), PF_LOCAL,

123

SOCK_DGRAM, SOCK_NONBLOCK,

124

SOCK_CLOEXEC, connect(),

125

struct sockaddr, socklen_t,

126

shutdown(), SHUT_RD, send(),

127

MSG_NOSIGNAL, bind(), recv(),

128

socketpair() */

129

#include <glob.h> /* globfree(), glob_t, glob(),

130

GLOB_ERR, GLOB_NOSORT, GLOB_MARK,

131

GLOB_ABORTED, GLOB_NOMATCH,

132

GLOB_NOSPACE */

133

134

/* End of includes */

135

136

/* Start of declarations of private types and functions */

137

138

/* microseconds of CLOCK_MONOTONIC absolute time; 0 means unset */

139

typedef uintmax_t mono_microsecs;

140

141

/* "task_queue" - A queue of tasks to be run */

142

typedef struct {

143

struct task_struct *tasks; /* Tasks in this queue */

144

size_t length; /* Number of tasks */

145

/* Memory allocated for "tasks", in bytes */

146

size_t allocated;

147

/* Time when this queue should be run, at the latest */

148

mono_microsecs next_run;

149

} __attribute__((designated_init)) task_queue;

150

151

/* "task_func" - A function type for task functions

152

153

I.e. functions for the code which runs when a task is run, all have

154

this type */

155

typedef void (task_func) (const struct task_struct,

156

task_queue *const)

157

__attribute__((nonnull));

158

159

/* "buffer" - A data buffer for a growing array of bytes

160

161

Used for the "password" variable */

162

typedef struct {

163

char *data;

164

size_t length;

165

size_t allocated;

166

} __attribute__((designated_init)) buffer;

167

168

/* "string_set" - A set type which can contain strings

169

170

Used by the "cancelled_filenames" variable */

171

typedef struct {

172

char *argz; /* Do not access these except in */

173

size_t argz_len; /* the string_set_* functions */

174

} __attribute__((designated_init)) string_set;

175

176

/* "task_context" - local variables for tasks

177

178

This data structure distinguishes between different tasks which are

179

using the same function. This data structure is passed to every

180

task function when each task is run.

181

182

Note that not every task uses every struct member. */

183

typedef struct task_struct {

184

task_func *const func; /* The function run by this task */

185

char *const question_filename; /* The question file */

186

const pid_t pid; /* Mandos client process ID */

187

const int epoll_fd; /* The epoll set file descriptor */

188

bool *const quit_now; /* Set to true on fatal errors */

189

const int fd; /* General purpose file descriptor */

190

bool *const mandos_client_exited; /* Set true when client exits */

191

buffer *const password; /* As read from client process */

192

bool *const password_is_read; /* "password" is done growing */

193

char *filename; /* General purpose file name */

194

/* A set of strings of all the file names of questions which have

195

been cancelled for any reason; tasks pertaining to these question

196

files should not be run */

197

string_set *const cancelled_filenames;

198

const mono_microsecs notafter; /* "NotAfter" from question file */

199

/* Updated before each queue run; is compared with queue.next_run */

200

const mono_microsecs *const current_time;

201

} __attribute__((designated_init)) task_context;

202

203

/* Declare all our functions here so we can define them in any order

204

below. Note: test functions are *not* declared here, they are

205

declared in the test section. */

206

__attribute__((warn_unused_result))

207

static bool should_only_run_tests(int *, char **[]);

208

__attribute__((warn_unused_result, cold))

209

static bool run_tests(int, char *[]);

210

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

211

__attribute__((warn_unused_result, malloc))

212

task_queue *create_queue(void);

213

__attribute__((nonnull, warn_unused_result))

214

bool add_to_queue(task_queue *const, const task_context);

215

__attribute__((nonnull))

216

void cleanup_task(const task_context *const);

217

__attribute__((nonnull))

218

void cleanup_queue(task_queue *const *const);

219

__attribute__((pure, nonnull, warn_unused_result))

220

bool queue_has_question(const task_queue *const);

221

__attribute__((nonnull))

222

void cleanup_close(const int *const);

223

__attribute__((nonnull))

224

void cleanup_string(char *const *const);

225

__attribute__((nonnull))

226

void cleanup_buffer(buffer *const);

227

__attribute__((pure, nonnull, warn_unused_result))

228

bool string_set_contains(const string_set, const char *const);

229

__attribute__((nonnull, warn_unused_result))

230

bool string_set_add(string_set *const, const char *const);

231

__attribute__((nonnull))

232

void string_set_clear(string_set *);

233

void string_set_swap(string_set *const, string_set *const);

234

__attribute__((nonnull, warn_unused_result))

235

bool start_mandos_client(task_queue *const, const int, bool *const,

236

bool *const, buffer *const, bool *const,

237

const struct sigaction *const,

238

const sigset_t, const char *const,

239

const uid_t, const gid_t,

240

const char *const *const);

241

__attribute__((nonnull))

242

task_func wait_for_mandos_client_exit;

243

__attribute__((nonnull))

244

task_func read_mandos_client_output;

245

__attribute__((warn_unused_result))

246

bool add_inotify_dir_watch(task_queue *const, const int, bool *const,

247

buffer *const, const char *const,

248

string_set *, const mono_microsecs *const,

249

bool *const, bool *const);

250

__attribute__((nonnull))

251

task_func read_inotify_event;

252

__attribute__((nonnull))

253

task_func open_and_parse_question;

254

__attribute__((nonnull))

255

task_func cancel_old_question;

256

__attribute__((nonnull))

257

task_func connect_question_socket;

258

__attribute__((nonnull))

259

task_func send_password_to_socket;

260

__attribute__((warn_unused_result))

261

bool add_existing_questions(task_queue *const, const int,

262

buffer *const, string_set *,

263

const mono_microsecs *const,

264

bool *const, bool *const,

265

const char *const);

266

__attribute__((nonnull, warn_unused_result))

267

bool wait_for_event(const int, const mono_microsecs,

268

const mono_microsecs);

269

bool run_queue(task_queue **const, string_set *const, bool *const);

270

bool clear_all_fds_from_epoll_set(const int);

271

mono_microsecs get_current_time(void);

272

__attribute__((nonnull, warn_unused_result))

273

bool setup_signal_handler(struct sigaction *const);

274

__attribute__((nonnull))

275

bool restore_signal_handler(const struct sigaction *const);

276

__attribute__((nonnull, warn_unused_result))

277

bool block_sigchld(sigset_t *const);

278

__attribute__((nonnull))

279

bool restore_sigmask(const sigset_t *const);

280

__attribute__((nonnull))

281

bool parse_arguments(int, char *[], const bool, char **, char **,

282

uid_t *const , gid_t *const, char **, size_t *);

283

284

/* End of declarations of private types and functions */

285

286

/* Start of "main" section; this section LACKS TESTS!

287

288

Code here should be as simple as possible. */

289

290

/* These are required to be global by Argp */

291

const char *argp_program_version = "password-agent " VERSION;

292

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

293

294

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

295

296

/* If the --test option is passed, skip all normal operations and

297

instead only run the run_tests() function, which also does all

298

its own option parsing, so we don't have to do anything here. */

299

if(should_only_run_tests(&argc, &argv)){

300

if(run_tests(argc, argv)){

301

return EXIT_SUCCESS; /* All tests successful */

302

}

303

return EXIT_FAILURE; /* Some test(s) failed */

304

}

305

306

__attribute__((cleanup(cleanup_string)))

307

char *agent_directory = NULL;

308

309

__attribute__((cleanup(cleanup_string)))

310

char *helper_directory = NULL;

311

312

uid_t user = 0;

313

gid_t group = 0;

314

315

__attribute__((cleanup(cleanup_string)))

316

char *mandos_argz = NULL;

317

size_t mandos_argz_length = 0;

318

319

if(not parse_arguments(argc, argv, true, &agent_directory,

320

&helper_directory, &user, &group,

321

&mandos_argz, &mandos_argz_length)){

322

/* This should never happen, since "true" is passed as the third

323

argument to parse_arguments() above, which should make

324

argp_parse() call exit() if any parsing error occurs. */

325

error(EX_USAGE, errno, "Failed to parse arguments");

326

}

327

328

const char default_agent_directory[] = "/run/systemd/ask-password";

329

const char default_helper_directory[]

330

= "/lib/mandos/plugin-helpers";

331

const char *const default_argv[]

332

= {"/lib/mandos/plugins.d/mandos-client", NULL };

333

334

/* Set variables to default values if unset */

335

if(agent_directory == NULL){

336

agent_directory = strdup(default_agent_directory);

337

if(agent_directory == NULL){

338

error(EX_OSERR, errno, "Failed strdup()");

339

}

340

}

341

if(helper_directory == NULL){

342

helper_directory = strdup(default_helper_directory);

343

if(helper_directory == NULL){

344

error(EX_OSERR, errno, "Failed strdup()");

345

}

346

}

347

if(user == 0){

348

user = 65534; /* nobody */

349

}

350

if(group == 0){

351

group = 65534; /* nogroup */

352

}

353

/* If parse_opt did not create an argz vector, create one with

354

default values */

355

if(mandos_argz == NULL){

356

#ifdef __GNUC__

357

#pragma GCC diagnostic push

358

/* argz_create() takes a non-const argv for some unknown reason -

359

argz_create() isn't modifying the strings, just copying them.

360

Therefore, this cast to non-const should be safe. */

361

#pragma GCC diagnostic ignored "-Wcast-qual"

362

#endif

363

errno = argz_create((char *const *)default_argv, &mandos_argz,

364

&mandos_argz_length);

365

#ifdef __GNUC__

366

#pragma GCC diagnostic pop

367

#endif

368

if(errno != 0){

369

error(EX_OSERR, errno, "Failed argz_create()");

370

}

371

}

372

/* Use argz vector to create a normal argv, usable by execv() */

373

374

char **mandos_argv = malloc((argz_count(mandos_argz,

375

mandos_argz_length)

376

+ 1) * sizeof(char *));

377

if(mandos_argv == NULL){

378

error_t saved_errno = errno;

379

free(mandos_argz);

380

error(EX_OSERR, saved_errno, "Failed malloc()");

381

}

382

argz_extract(mandos_argz, mandos_argz_length, mandos_argv);

383

384

sigset_t orig_sigmask;

385

if(not block_sigchld(&orig_sigmask)){

386

return EX_OSERR;

387

}

388

389

struct sigaction old_sigchld_action;

390

if(not setup_signal_handler(&old_sigchld_action)){

391

return EX_OSERR;

392

}

393

394

mono_microsecs current_time = 0;

395

396

bool mandos_client_exited = false;

397

bool quit_now = false;

398

__attribute__((cleanup(cleanup_close)))

399

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

400

if(epoll_fd < 0){

401

error(EX_OSERR, errno, "Failed to create epoll set fd");

402

}

403

__attribute__((cleanup(cleanup_queue)))

404

task_queue *queue = create_queue();

405

if(queue == NULL){

406

error(EX_OSERR, errno, "Failed to create task queue");

407

}

408

409

__attribute__((cleanup(cleanup_buffer)))

410

buffer password = {};

411

bool password_is_read = false;

412

413

__attribute__((cleanup(string_set_clear)))

414

string_set cancelled_filenames = {};

415

416

/* Add tasks to queue */

417

if(not start_mandos_client(queue, epoll_fd, &mandos_client_exited,

418

&quit_now, &password, &password_is_read,

419

&old_sigchld_action, orig_sigmask,

420

helper_directory, user, group,

421

(const char *const *)mandos_argv)){

422

return EX_OSERR; /* Error has already been printed */

423

}

424

/* These variables were only for start_mandos_client() and are not

425

needed anymore */

426

free(mandos_argv);

427

free(mandos_argz);

428

mandos_argz = NULL;

429

if(not add_inotify_dir_watch(queue, epoll_fd, &quit_now, &password,

430

agent_directory, &cancelled_filenames,

431

&current_time, &mandos_client_exited,

432

&password_is_read)){

433

switch(errno){ /* Error has already been printed */

434

case EACCES:

435

case ENAMETOOLONG:

436

case ENOENT:

437

case ENOTDIR:

438

return EX_OSFILE;

439

default:

440

return EX_OSERR;

441

}

442

}

443

if(not add_existing_questions(queue, epoll_fd, &password,

444

&cancelled_filenames, &current_time,

445

&mandos_client_exited,

446

&password_is_read, agent_directory)){

447

return EXIT_FAILURE; /* Error has already been printed */

448

}

449

450

/* Run queue */

451

do {

452

current_time = get_current_time();

453

if(not wait_for_event(epoll_fd, queue->next_run, current_time)){

454

const error_t saved_errno = errno;

455

error(EXIT_FAILURE, saved_errno, "Failure while waiting for"

456

" events");

457

}

458

459

current_time = get_current_time();

460

if(not run_queue(&queue, &cancelled_filenames, &quit_now)){

461

const error_t saved_errno = errno;

462

error(EXIT_FAILURE, saved_errno, "Failure while running queue");

463

}

464

465

/* When no tasks about questions are left in the queue, break out

466

of the loop (and implicitly exit the program) */

467

} while(queue_has_question(queue));

468

469

restore_signal_handler(&old_sigchld_action);

470

restore_sigmask(&orig_sigmask);

471

472

return EXIT_SUCCESS;

473

}

474

475

__attribute__((warn_unused_result))

476

mono_microsecs get_current_time(void){

477

struct timespec currtime;

478

if(clock_gettime(CLOCK_MONOTONIC, &currtime) != 0){

479

error(0, errno, "Failed to get current time");

480

return 0;

481

}

482

return ((mono_microsecs)currtime.tv_sec * 1000000) /* seconds */

483

+ ((mono_microsecs)currtime.tv_nsec / 1000); /* nanoseconds */

484

}

485

486

/* End of "main" section */

487

488

/* Start of regular code section; ALL this code has tests */

489

490

__attribute__((nonnull))

491

bool parse_arguments(int argc, char *argv[], const bool exit_failure,

492

char **agent_directory, char **helper_directory,

493

uid_t *const user, gid_t *const group,

494

char **mandos_argz, size_t *mandos_argz_length){

495

496

const struct argp_option options[] = {

497

{ .name="agent-directory",.key='d', .arg="DIRECTORY",

498

.doc="Systemd password agent directory" },

499

{ .name="helper-directory",.key=128, .arg="DIRECTORY",

500

.doc="Mandos Client password helper directory" },

501

{ .name="plugin-helper-dir", .key=129, /* From plugin-runner */

502

.flags=OPTION_HIDDEN | OPTION_ALIAS },

503

{ .name="user", .key='u', .arg="USERID",

504

.doc="User ID the Mandos Client will use as its unprivileged"

505

" user" },

506

{ .name="userid", .key=130, /* From plugin--runner */

507

.flags=OPTION_HIDDEN | OPTION_ALIAS },

508

{ .name="group", .key='g', .arg="GROUPID",

509

.doc="Group ID the Mandos Client will use as its unprivileged"

510

" group" },

511

{ .name="groupid", .key=131, /* From plugin--runner */

512

.flags=OPTION_HIDDEN | OPTION_ALIAS },

513

{ .name="test", .key=255, /* See should_only_run_tests() */

514

.doc="Skip normal operation, and only run self-tests. See"

515

" --test --help.", .group=10, },

516

{ NULL },

517

};

518

519

__attribute__((nonnull(3)))

520

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

521

errno = 0;

522

switch(key){

523

case 'd': /* --agent-directory */

524

*agent_directory = strdup(arg);

525

break;

526

case 128: /* --helper-directory */

527

case 129: /* --plugin-helper-dir */

528

*helper_directory = strdup(arg);

529

break;

530

case 'u': /* --user */

531

case 130: /* --userid */

532

{

533

char *tmp;

534

uintmax_t tmp_id = 0;

535

errno = 0;

536

tmp_id = (uid_t)strtoumax(arg, &tmp, 10);

537

if(errno != 0 or tmp == arg or *tmp != '\0'

538

or tmp_id != (uid_t)tmp_id or (uid_t)tmp_id == 0){

539

return ARGP_ERR_UNKNOWN;

540

}

541

*user = (uid_t)tmp_id;

542

errno = 0;

543

break;

544

}

545

case 'g': /* --group */

546

case 131: /* --groupid */

547

{

548

char *tmp;

549

uintmax_t tmp_id = 0;

550

errno = 0;

551

tmp_id = (uid_t)strtoumax(arg, &tmp, 10);

552

if(errno != 0 or tmp == arg or *tmp != '\0'

553

or tmp_id != (gid_t)tmp_id or (gid_t)tmp_id == 0){

554

return ARGP_ERR_UNKNOWN;

555

}

556

*group = (gid_t)tmp_id;

557

errno = 0;

558

break;

559

}

560

case ARGP_KEY_ARGS:

561

/* Copy arguments into argz vector */

562

return argz_create(state->argv + state->next, mandos_argz,

563

mandos_argz_length);

564

default:

565

return ARGP_ERR_UNKNOWN;

566

}

567

return errno;

568

}

569

570

const struct argp argp = {

571

.options=options,

572

.parser=parse_opt,

573

.args_doc="[MANDOS_CLIENT [OPTION...]]\n--test",

574

.doc = "Mandos password agent -- runs Mandos client as a"

575

" systemd password agent",

576

};

577

578

errno = argp_parse(&argp, argc, argv,

579

exit_failure ? 0 : ARGP_NO_EXIT, NULL, NULL);

580

581

return errno == 0;

582

}

583

584

__attribute__((nonnull, warn_unused_result))

585

bool block_sigchld(sigset_t *const orig_sigmask){

586

sigset_t sigchld_sigmask;

587

if(sigemptyset(&sigchld_sigmask) < 0){

588

error(0, errno, "Failed to empty signal set");

589

return false;

590

}

591

if(sigaddset(&sigchld_sigmask, SIGCHLD) < 0){

592

error(0, errno, "Failed to add SIGCHLD to signal set");

593

return false;

594

}

595

if(pthread_sigmask(SIG_BLOCK, &sigchld_sigmask, orig_sigmask) != 0){

596

error(0, errno, "Failed to block SIGCHLD signal");

597

return false;

598

}

599

return true;

600

}

601

602

__attribute__((nonnull, warn_unused_result, const))

603

bool restore_sigmask(const sigset_t *const orig_sigmask){

604

if(pthread_sigmask(SIG_SETMASK, orig_sigmask, NULL) != 0){

605

error(0, errno, "Failed to restore blocked signals");

606

return false;

607

}

608

return true;

609

}

610

611

__attribute__((nonnull, warn_unused_result))

612

bool setup_signal_handler(struct sigaction *const old_sigchld_action){

613

struct sigaction sigchld_action = {

614

.sa_handler=handle_sigchld,

615

.sa_flags=SA_RESTART | SA_NOCLDSTOP,

616

};

617

/* Set all signals in "sa_mask" struct member; this makes all

618

signals automatically blocked during signal handler */

619

if(sigfillset(&sigchld_action.sa_mask) != 0){

620

error(0, errno, "Failed to do sigfillset()");

621

return false;

622

}

623

if(sigaction(SIGCHLD, &sigchld_action, old_sigchld_action) != 0){

624

error(0, errno, "Failed to set SIGCHLD signal handler");

625

return false;

626

}

627

return true;

628

}

629

630

__attribute__((nonnull, warn_unused_result))

631

bool restore_signal_handler(const struct sigaction *const

632

old_sigchld_action){

633

if(sigaction(SIGCHLD, old_sigchld_action, NULL) != 0){

634

error(0, errno, "Failed to restore signal handler");

635

return false;

636

}

637

return true;

638

}

639

640

__attribute__((warn_unused_result, malloc))

641

task_queue *create_queue(void){

642

task_queue *queue = malloc(sizeof(task_queue));

643

if(queue){

644

queue->tasks = NULL;

645

queue->length = 0;

646

queue->allocated = 0;

647

queue->next_run = 0;

648

}

649

return queue;

650

}

651

652

__attribute__((nonnull, warn_unused_result))

653

bool add_to_queue(task_queue *const queue, const task_context task){

654

const size_t needed_size = sizeof(task_context)*(queue->length + 1);

655

if(needed_size > (queue->allocated)){

656

task_context *const new_tasks = realloc(queue->tasks,

657

needed_size);

658

if(new_tasks == NULL){

659

error(0, errno, "Failed to allocate %" PRIuMAX

660

" bytes for queue->tasks", (uintmax_t)needed_size);

661

return false;

662

}

663

queue->tasks = new_tasks;

664

queue->allocated = needed_size;

665

}

666

/* Using memcpy here is necessary because doing */

667

/* queue->tasks[queue->length++] = task; */

668

/* would violate const-ness of task members */

669

memcpy(&(queue->tasks[queue->length++]), &task,

670

sizeof(task_context));

671

return true;

672

}

673

674

__attribute__((nonnull))

675

void cleanup_task(const task_context *const task){

676

const error_t saved_errno = errno;

677

/* free and close all task data */

678

free(task->question_filename);

679

if(task->filename != task->question_filename){

680

free(task->filename);

681

}

682

if(task->pid > 0){

683

kill(task->pid, SIGTERM);

684

}

685

if(task->fd > 0){

686

close(task->fd);

687

}

688

errno = saved_errno;

689

}

690

691

__attribute__((nonnull))

692

void free_queue(task_queue *const queue){

693

free(queue->tasks);

694

free(queue);

695

}

696

697

__attribute__((nonnull))

698

void cleanup_queue(task_queue *const *const queue){

699

if(*queue == NULL){

700

return;

701

}

702

for(size_t i = 0; i < (*queue)->length; i++){

703

const task_context *const task = ((*queue)->tasks)+i;

704

cleanup_task(task);

705

}

706

free_queue(*queue);

707

}

708

709

__attribute__((pure, nonnull, warn_unused_result))

710

bool queue_has_question(const task_queue *const queue){

711

for(size_t i=0; i < queue->length; i++){

712

if(queue->tasks[i].question_filename != NULL){

713

return true;

714

}

715

}

716

return false;

717

}

718

719

__attribute__((nonnull))

720

void cleanup_close(const int *const fd){

721

const error_t saved_errno = errno;

722

close(*fd);

723

errno = saved_errno;

724

}

725

726

__attribute__((nonnull))

727

void cleanup_string(char *const *const ptr){

728

free(*ptr);

729

}

730

731

__attribute__((nonnull))

732

void cleanup_buffer(buffer *buf){

733

if(buf->allocated > 0){

734

#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 25)

735

explicit_bzero(buf->data, buf->allocated);

736

#else

737

memset(buf->data, '\0', buf->allocated);

738

#endif

739

}

740

if(buf->data != NULL){

741

if(munlock(buf->data, buf->allocated) != 0){

742

error(0, errno, "Failed to unlock memory of old buffer");

743

}

744

free(buf->data);

745

buf->data = NULL;

746

}

747

buf->length = 0;

748

buf->allocated = 0;

749

}

750

751

__attribute__((pure, nonnull, warn_unused_result))

752

bool string_set_contains(const string_set set, const char *const str){

753

for(const char *s = set.argz; s != NULL and set.argz_len > 0;

754

s = argz_next(set.argz, set.argz_len, s)){

755

if(strcmp(s, str) == 0){

756

return true;

757

}

758

}

759

return false;

760

}

761

762

__attribute__((nonnull, warn_unused_result))

763

bool string_set_add(string_set *const set, const char *const str){

764

if(string_set_contains(*set, str)){

765

return true;

766

}

767

error_t error = argz_add(&set->argz, &set->argz_len, str);

768

if(error == 0){

769

return true;

770

}

771

errno = error;

772

return false;

773

}

774

775

__attribute__((nonnull))

776

void string_set_clear(string_set *set){

777

free(set->argz);

778

set->argz = NULL;

779

set->argz_len = 0;

780

}

781

782

__attribute__((nonnull))

783

void string_set_swap(string_set *const set1, string_set *const set2){

784

/* Swap contents of two string sets */

785

{

786

char *const tmp_argz = set1->argz;

787

set1->argz = set2->argz;

788

set2->argz = tmp_argz;

789

}

790

{

791

const size_t tmp_argz_len = set1->argz_len;

792

set1->argz_len = set2->argz_len;

793

set2->argz_len = tmp_argz_len;

794

}

795

}

796

797

__attribute__((nonnull, warn_unused_result))

798

bool start_mandos_client(task_queue *const queue,

799

const int epoll_fd,

800

bool *const mandos_client_exited,

801

bool *const quit_now, buffer *const password,

802

bool *const password_is_read,

803

const struct sigaction *const

804

old_sigchld_action, const sigset_t sigmask,

805

const char *const helper_directory,

806

const uid_t user, const gid_t group,

807

const char *const *const argv){

808

int pipefds[2];

809

if(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK) != 0){

810

error(0, errno, "Failed to pipe2(..., O_CLOEXEC | O_NONBLOCK)");

811

return false;

812

}

813

814

const pid_t pid = fork();

815

if(pid == 0){

816

if(not restore_signal_handler(old_sigchld_action)){

817

_exit(EXIT_FAILURE);

818

}

819

if(not restore_sigmask(&sigmask)){

820

_exit(EXIT_FAILURE);

821

}

822

if(close(pipefds[0]) != 0){

823

error(0, errno, "Failed to close() parent pipe fd");

824

_exit(EXIT_FAILURE);

825

}

826

if(dup2(pipefds[1], STDOUT_FILENO) == -1){

827

error(0, errno, "Failed to dup2() pipe fd to stdout");

828

_exit(EXIT_FAILURE);

829

}

830

if(close(pipefds[1]) != 0){

831

error(0, errno, "Failed to close() old child pipe fd");

832

_exit(EXIT_FAILURE);

833

}

834

if(setenv("MANDOSPLUGINHELPERDIR", helper_directory, 1) != 0){

835

error(0, errno, "Failed to setenv(\"MANDOSPLUGINHELPERDIR\","

836

" \"%s\", 1)", helper_directory);

837

_exit(EXIT_FAILURE);

838

}

839

if(group != 0 and setresgid(group, 0, 0) == -1){

840

error(0, errno, "Failed to setresgid(-1, %" PRIuMAX ", %"

841

PRIuMAX")", (uintmax_t)group, (uintmax_t)group);

842

_exit(EXIT_FAILURE);

843

}

844

if(user != 0 and setresuid(user, 0, 0) == -1){

845

error(0, errno, "Failed to setresuid(-1, %" PRIuMAX ", %"

846

PRIuMAX")", (uintmax_t)user, (uintmax_t)user);

847

_exit(EXIT_FAILURE);

848

}

849

#ifdef __GNUC__

850

#pragma GCC diagnostic push

851

/* For historical reasons, the "argv" argument to execv() is not

852

const, but it is safe to override this. */

853

#pragma GCC diagnostic ignored "-Wcast-qual"

854

#endif

855

execv(argv[0], (char **)argv);

856

#ifdef __GNUC__

857

#pragma GCC diagnostic pop

858

#endif

859

error(0, errno, "execv(\"%s\", ...) failed", argv[0]);

860

_exit(EXIT_FAILURE);

861

}

862

close(pipefds[1]);

863

864

if(not add_to_queue(queue, (task_context){

865

.func=wait_for_mandos_client_exit,

866

.pid=pid,

867

.mandos_client_exited=mandos_client_exited,

868

.quit_now=quit_now,

869

})){

870

error(0, errno, "Failed to add wait_for_mandos_client to queue");

871

close(pipefds[0]);

872

return false;

873

}

874

875

const int ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, pipefds[0],

876

&(struct epoll_event)

877

{ .events=EPOLLIN | EPOLLRDHUP });

878

if(ret != 0 and errno != EEXIST){

879

error(0, errno, "Failed to add file descriptor to epoll set");

880

close(pipefds[0]);

881

return false;

882

}

883

884

return add_to_queue(queue, (task_context){

885

.func=read_mandos_client_output,

886

.epoll_fd=epoll_fd,

887

.fd=pipefds[0],

888

.quit_now=quit_now,

889

.password=password,

890

.password_is_read=password_is_read,

891

});

892

}

893

894

__attribute__((nonnull))

895

void wait_for_mandos_client_exit(const task_context task,

896

task_queue *const queue){

897

const pid_t pid = task.pid;

898

bool *const mandos_client_exited = task.mandos_client_exited;

899

bool *const quit_now = task.quit_now;

900

901

int status;

902

switch(waitpid(pid, &status, WNOHANG)){

903

case 0: /* Not exited yet */

904

if(not add_to_queue(queue, task)){

905

error(0, errno, "Failed to add myself to queue");

906

*quit_now = true;

907

}

908

break;

909

case -1: /* Error */

910

error(0, errno, "waitpid(%" PRIdMAX ") failed", (intmax_t)pid);

911

if(errno != ECHILD){

912

kill(pid, SIGTERM);

913

}

914

*quit_now = true;

915

break;

916

default: /* Has exited */

917

*mandos_client_exited = true;

918

if((not WIFEXITED(status))

919

or (WEXITSTATUS(status) != EXIT_SUCCESS)){

920

error(0, 0, "Mandos client failed or was killed");

921

*quit_now = true;

922

}

923

}

924

}

925

926

__attribute__((nonnull))

927

void read_mandos_client_output(const task_context task,

928

task_queue *const queue){

929

buffer *const password = task.password;

930

bool *const quit_now = task.quit_now;

931

bool *const password_is_read = task.password_is_read;

932

const int fd = task.fd;

933

const int epoll_fd = task.epoll_fd;

934

935

const size_t new_potential_size = (password->length + PIPE_BUF);

936

if(password->allocated < new_potential_size){

937

char *const new_buffer = calloc(new_potential_size, 1);

938

if(new_buffer == NULL){

939

error(0, errno, "Failed to allocate %" PRIuMAX

940

" bytes for password", (uintmax_t)new_potential_size);

941

*quit_now = true;

942

close(fd);

943

return;

944

}

945

if(mlock(new_buffer, new_potential_size) != 0){

946

/* Warn but do not treat as fatal error */

947

if(errno != EPERM and errno != ENOMEM){

948

error(0, errno, "Failed to lock memory for password");

949

}

950

}

951

if(password->length > 0){

952

memcpy(new_buffer, password->data, password->length);

953

#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 25)

954

explicit_bzero(password->data, password->allocated);

955

#else

956

memset(password->data, '\0', password->allocated);

957

#endif

958

}

959

if(password->data != NULL){

960

if(munlock(password->data, password->allocated) != 0){

961

error(0, errno, "Failed to unlock memory of old buffer");

962

}

963

free(password->data);

964

}

965

password->data = new_buffer;

966

password->allocated = new_potential_size;

967

}

968

969

const ssize_t read_length = read(fd, password->data

970

+ password->length, PIPE_BUF);

971

972

if(read_length == 0){ /* EOF */

973

*password_is_read = true;

974

close(fd);

975

return;

976

}

977

if(read_length < 0 and errno != EAGAIN){ /* Actual error */

978

error(0, errno, "Failed to read password from Mandos client");

979

*quit_now = true;

980

close(fd);

981

return;

982

}

983

if(read_length > 0){ /* Data has been read */

984

password->length += (size_t)read_length;

985

}

986

987

/* Either data was read, or EAGAIN was indicated, meaning no data

988

available yet */

989

990

/* Re-add the fd to the epoll set */

991

const int ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

992

&(struct epoll_event)

993

{ .events=EPOLLIN | EPOLLRDHUP });

994

if(ret != 0 and errno != EEXIST){

995

error(0, errno, "Failed to re-add file descriptor to epoll set");

996

*quit_now = true;

997

close(fd);

998

return;

999

}

1000

1001

/* Re-add myself to the queue */

1002

if(not add_to_queue(queue, task)){

1003

error(0, errno, "Failed to add myself to queue");

1004

*quit_now = true;

1005

close(fd);

1006

}

1007

}

1008

1009

__attribute__((nonnull, warn_unused_result))

1010

bool add_inotify_dir_watch(task_queue *const queue,

1011

const int epoll_fd, bool *const quit_now,

1012

buffer *const password,

1013

const char *const dir,

1014

string_set *cancelled_filenames,

1015

const mono_microsecs *const current_time,

1016

bool *const mandos_client_exited,

1017

bool *const password_is_read){

1018

const int fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);

1019

if(fd == -1){

1020

error(0, errno, "Failed to create inotify instance");

1021

return false;

1022

}

1023

1024

if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE | IN_MOVED_TO

1025

| IN_MOVED_FROM| IN_DELETE | IN_EXCL_UNLINK

1026

| IN_ONLYDIR)

1027

== -1){

1028

error(0, errno, "Failed to create inotify watch on %s", dir);

1029

return false;

1030

}

1031

1032

/* Add the inotify fd to the epoll set */

1033

const int ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

1034

&(struct epoll_event)

1035

{ .events=EPOLLIN | EPOLLRDHUP });

1036

if(ret != 0 and errno != EEXIST){

1037

error(0, errno, "Failed to add file descriptor to epoll set");

1038

close(fd);

1039

return false;

1040

}

1041

1042

const task_context read_inotify_event_task = {

1043

.func=read_inotify_event,

1044

.epoll_fd=epoll_fd,

1045

.quit_now=quit_now,

1046

.password=password,

1047

.fd=fd,

1048

.filename=strdup(dir),

1049

.cancelled_filenames=cancelled_filenames,

1050

.current_time=current_time,

1051

.mandos_client_exited=mandos_client_exited,

1052

.password_is_read=password_is_read,

1053

};

1054

if(read_inotify_event_task.filename == NULL){

1055

error(0, errno, "Failed to strdup(\"%s\")", dir);

1056

close(fd);

1057

return false;

1058

}

1059

1060

return add_to_queue(queue, read_inotify_event_task);

1061

}

1062

1063

__attribute__((nonnull))

1064

void read_inotify_event(const task_context task,

1065

task_queue *const queue){

1066

const int fd = task.fd;

1067

const int epoll_fd = task.epoll_fd;

1068

char *const filename = task.filename;

1069

bool *quit_now = task.quit_now;

1070

buffer *const password = task.password;

1071

string_set *const cancelled_filenames = task.cancelled_filenames;

1072

const mono_microsecs *const current_time = task.current_time;

1073

bool *const mandos_client_exited = task.mandos_client_exited;

1074

bool *const password_is_read = task.password_is_read;

1075

1076

/* "sufficient to read at least one event." - inotify(7) */

1077

const size_t ievent_size = (sizeof(struct inotify_event)

1078

+ NAME_MAX + 1);

1079

struct {

1080

struct inotify_event event;

1081

char name_buffer[NAME_MAX + 1];

1082

} ievent_buffer;

1083

struct inotify_event *const ievent = &ievent_buffer.event;

1084

1085

const ssize_t read_length = read(fd, ievent, ievent_size);

1086

if(read_length == 0){ /* EOF */

1087

error(0, 0, "Got EOF from inotify fd for directory %s", filename);

1088

*quit_now = true;

1089

cleanup_task(&task);

1090

return;

1091

}

1092

if(read_length < 0 and errno != EAGAIN){ /* Actual error */

1093

error(0, errno, "Failed to read from inotify fd for directory %s",

1094

filename);

1095

*quit_now = true;

1096

cleanup_task(&task);

1097

return;

1098

}

1099

if(read_length > 0 /* Data has been read */

1100

and fnmatch("ask.*", ievent->name, FNM_FILE_NAME) == 0){

1101

char *question_filename = NULL;

1102

const ssize_t question_filename_length

1103

= asprintf(&question_filename, "%s/%s", filename, ievent->name);

1104

if(question_filename_length < 0){

1105

error(0, errno, "Failed to create file name from directory name"

1106

" %s and file name %s", filename, ievent->name);

1107

} else {

1108

if(ievent->mask & (IN_CLOSE_WRITE | IN_MOVED_TO)){

1109

if(not add_to_queue(queue, (task_context){

1110

.func=open_and_parse_question,

1111

.epoll_fd=epoll_fd,

1112

.question_filename=question_filename,

1113

.filename=question_filename,

1114

.password=password,

1115

.cancelled_filenames=cancelled_filenames,

1116

.current_time=current_time,

1117

.mandos_client_exited=mandos_client_exited,

1118

.password_is_read=password_is_read,

1119

})){

1120

error(0, errno, "Failed to add open_and_parse_question task"

1121

" for file name %s to queue", filename);

1122

} else {

1123

/* Force the added task (open_and_parse_question) to run

1124

immediately */

1125

queue->next_run = 1;

1126

}

1127

} else if(ievent->mask & (IN_MOVED_FROM | IN_DELETE)){

1128

if(not string_set_add(cancelled_filenames,

1129

question_filename)){

1130

error(0, errno, "Could not add question %s to"

1131

" cancelled_questions", question_filename);

1132

*quit_now = true;

1133

free(question_filename);

1134

cleanup_task(&task);

1135

return;

1136

}

1137

free(question_filename);

1138

}

1139

}

1140

}

1141

1142

/* Either data was read, or EAGAIN was indicated, meaning no data

1143

available yet */

1144

1145

/* Re-add myself to the queue */

1146

if(not add_to_queue(queue, task)){

1147

error(0, errno, "Failed to re-add read_inotify_event(%s) to"

1148

" queue", filename);

1149

*quit_now = true;

1150

cleanup_task(&task);

1151

return;

1152

}

1153

1154

/* Re-add the fd to the epoll set */

1155

const int ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

1156

&(struct epoll_event)

1157

{ .events=EPOLLIN | EPOLLRDHUP });

1158

if(ret != 0 and errno != EEXIST){

1159

error(0, errno, "Failed to re-add inotify file descriptor %d for"

1160

" directory %s to epoll set", fd, filename);

1161

/* Force the added task (read_inotify_event) to run again, at most

1162

one second from now */

1163

if((queue->next_run == 0)

1164

or (queue->next_run > (*current_time + 1000000))){

1165

queue->next_run = *current_time + 1000000;

1166

}

1167

}

1168

}

1169

1170

__attribute__((nonnull))

1171

void open_and_parse_question(const task_context task,

1172

task_queue *const queue){

1173

__attribute__((cleanup(cleanup_string)))

1174

char *question_filename = task.question_filename;

1175

const int epoll_fd = task.epoll_fd;

1176

buffer *const password = task.password;

1177

string_set *const cancelled_filenames = task.cancelled_filenames;

1178

const mono_microsecs *const current_time = task.current_time;

1179

bool *const mandos_client_exited = task.mandos_client_exited;

1180

bool *const password_is_read = task.password_is_read;

1181

1182

/* We use the GLib "Key-value file parser" functions to parse the

1183

question file. See <https://www.freedesktop.org/wiki/Software

1184

/systemd/PasswordAgents/> for specification of contents */

1185

__attribute__((nonnull))

1186

void cleanup_g_key_file(GKeyFile **key_file){

1187

if(*key_file != NULL){

1188

g_key_file_free(*key_file);

1189

}

1190

}

1191

1192

__attribute__((cleanup(cleanup_g_key_file)))

1193

GKeyFile *key_file = g_key_file_new();

1194

if(key_file == NULL){

1195

error(0, errno, "Failed g_key_file_new() for \"%s\"",

1196

question_filename);

1197

return;

1198

}

1199

GError *glib_error = NULL;

1200

if(g_key_file_load_from_file(key_file, question_filename,

1201

G_KEY_FILE_NONE, &glib_error) != TRUE){

1202

/* If a file was removed, we should ignore it, so */

1203

/* only show error message if file actually existed */

1204

if(glib_error->code != G_FILE_ERROR_NOENT){

1205

error(0, 0, "Failed to load question data from file \"%s\": %s",

1206

question_filename, glib_error->message);

1207

}

1208

return;

1209

}

1210

1211

__attribute__((cleanup(cleanup_string)))

1212

char *socket_name = g_key_file_get_string(key_file, "Ask",

1213

"Socket",

1214

&glib_error);

1215

if(socket_name == NULL){

1216

error(0, 0, "Question file \"%s\" did not contain \"Socket\": %s",

1217

question_filename, glib_error->message);

1218

return;

1219

}

1220

1221

if(strlen(socket_name) == 0){

1222

error(0, 0, "Question file \"%s\" had empty \"Socket\" value",

1223

question_filename);

1224

return;

1225

}

1226

1227

const guint64 pid = g_key_file_get_uint64(key_file, "Ask", "PID",

1228

&glib_error);

1229

if(glib_error != NULL){

1230

error(0, 0, "Question file \"%s\" contained bad \"PID\": %s",

1231

question_filename, glib_error->message);

1232

return;

1233

}

1234

1235

if((pid != (guint64)((pid_t)pid))

1236

or (kill((pid_t)pid, 0) != 0)){

1237

error(0, 0, "PID %" PRIuMAX " in question file \"%s\" is bad or"

1238

" does not exist", (uintmax_t)pid, question_filename);

1239

return;

1240

}

1241

1242

guint64 notafter = g_key_file_get_uint64(key_file, "Ask",

1243

"NotAfter", &glib_error);

1244

if(glib_error != NULL){

1245

if(glib_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND){

1246

error(0, 0, "Question file \"%s\" contained bad \"NotAfter\":"

1247

" %s", question_filename, glib_error->message);

1248

}

1249

notafter = 0;

1250

}

1251

if(notafter != 0){

1252

if(queue->next_run == 0 or (queue->next_run > notafter)){

1253

queue->next_run = notafter;

1254

}

1255

if(*current_time >= notafter){

1256

return;

1257

}

1258

}

1259

1260

const task_context connect_question_socket_task = {

1261

.func=connect_question_socket,

1262

.question_filename=strdup(question_filename),

1263

.epoll_fd=epoll_fd,

1264

.password=password,

1265

.filename=strdup(socket_name),

1266

.cancelled_filenames=task.cancelled_filenames,

1267

.mandos_client_exited=mandos_client_exited,

1268

.password_is_read=password_is_read,

1269

.current_time=current_time,

1270

};

1271

if(connect_question_socket_task.question_filename == NULL

1272

or connect_question_socket_task.filename == NULL

1273

or not add_to_queue(queue, connect_question_socket_task)){

1274

error(0, errno, "Failed to add connect_question_socket for socket"

1275

" %s (from \"%s\") to queue", socket_name,

1276

question_filename);

1277

cleanup_task(&connect_question_socket_task);

1278

return;

1279

}

1280

/* Force the added task (connect_question_socket) to run

1281

immediately */

1282

queue->next_run = 1;

1283

1284

if(notafter > 0){

1285

char *const dup_filename = strdup(question_filename);

1286

const task_context cancel_old_question_task = {

1287

.func=cancel_old_question,

1288

.question_filename=dup_filename,

1289

.notafter=notafter,

1290

.filename=dup_filename,

1291

.cancelled_filenames=cancelled_filenames,

1292

.current_time=current_time,

1293

};

1294

if(cancel_old_question_task.question_filename == NULL

1295

or not add_to_queue(queue, cancel_old_question_task)){

1296

error(0, errno, "Failed to add cancel_old_question for file "

1297

"\"%s\" to queue", question_filename);

1298

cleanup_task(&cancel_old_question_task);

1299

return;

1300

}

1301

}

1302

}

1303

1304

__attribute__((nonnull))

1305

void cancel_old_question(const task_context task,

1306

task_queue *const queue){

1307

char *const question_filename = task.question_filename;

1308

string_set *const cancelled_filenames = task.cancelled_filenames;

1309

const mono_microsecs notafter = task.notafter;

1310

const mono_microsecs *const current_time = task.current_time;

1311

1312

if(*current_time >= notafter){

1313

if(not string_set_add(cancelled_filenames, question_filename)){

1314

error(0, errno, "Failed to cancel question for file %s",

1315

question_filename);

1316

}

1317

cleanup_task(&task);

1318

return;

1319

}

1320

1321

if(not add_to_queue(queue, task)){

1322

error(0, errno, "Failed to add cancel_old_question for file "

1323

"%s to queue", question_filename);

1324

cleanup_task(&task);

1325

return;

1326

}

1327

1328

if((queue->next_run == 0) or (queue->next_run > notafter)){

1329

queue->next_run = notafter;

1330

}

1331

}

1332

1333

__attribute__((nonnull))

1334

void connect_question_socket(const task_context task,

1335

task_queue *const queue){

1336

char *const question_filename = task.question_filename;

1337

char *const filename = task.filename;

1338

const int epoll_fd = task.epoll_fd;

1339

buffer *const password = task.password;

1340

string_set *const cancelled_filenames = task.cancelled_filenames;

1341

bool *const mandos_client_exited = task.mandos_client_exited;

1342

bool *const password_is_read = task.password_is_read;

1343

const mono_microsecs *const current_time = task.current_time;

1344

1345

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

1346

1347

if(sizeof(sock_name.sun_path) <= strlen(filename)){

1348

error(0, 0, "Socket filename is larger than"

1349

" sizeof(sockaddr_un.sun_path); %" PRIuMAX ": \"%s\"",

1350

(uintmax_t)sizeof(sock_name.sun_path), filename);

1351

if(not string_set_add(cancelled_filenames, question_filename)){

1352

error(0, errno, "Failed to cancel question for file %s",

1353

question_filename);

1354

}

1355

cleanup_task(&task);

1356

return;

1357

}

1358

1359

const int fd = socket(PF_LOCAL, SOCK_DGRAM

1360

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

1361

if(fd < 0){

1362

error(0, errno,

1363

"Failed to create socket(PF_LOCAL, SOCK_DGRAM, 0)");

1364

if(not add_to_queue(queue, task)){

1365

error(0, errno, "Failed to add connect_question_socket for file"

1366

" \"%s\" and socket \"%s\" to queue", question_filename,

1367

filename);

1368

cleanup_task(&task);

1369

} else {

1370

/* Force the added task (connect_question_socket) to run

1371

immediately */

1372

queue->next_run = 1;

1373

}

1374

return;

1375

}

1376

1377

strncpy(sock_name.sun_path, filename, sizeof(sock_name.sun_path));

1378

if(connect(fd, (struct sockaddr *)&sock_name,

1379

(socklen_t)SUN_LEN(&sock_name)) != 0){

1380

error(0, errno, "Failed to connect socket to \"%s\"", filename);

1381

if(not add_to_queue(queue, task)){

1382

error(0, errno, "Failed to add connect_question_socket for file"

1383

" \"%s\" and socket \"%s\" to queue", question_filename,

1384

filename);

1385

cleanup_task(&task);

1386

} else {

1387

/* Force the added task (connect_question_socket) to run again,

1388

at most one second from now */

1389

if((queue->next_run == 0)

1390

or (queue->next_run > (*current_time + 1000000))){

1391

queue->next_run = *current_time + 1000000;

1392

}

1393

}

1394

return;

1395

}

1396

1397

/* Not necessary, but we can try, and merely warn on failure */

1398

if(shutdown(fd, SHUT_RD) != 0){

1399

error(0, errno, "Failed to shutdown reading from socket \"%s\"",

1400

filename);

1401

}

1402

1403

/* Add the fd to the epoll set */

1404

if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

1405

&(struct epoll_event){ .events=EPOLLOUT })

1406

!= 0){

1407

error(0, errno, "Failed to add inotify file descriptor %d for"

1408

" socket %s to epoll set", fd, filename);

1409

if(not add_to_queue(queue, task)){

1410

error(0, errno, "Failed to add connect_question_socket for file"

1411

" \"%s\" and socket \"%s\" to queue", question_filename,

1412

filename);

1413

cleanup_task(&task);

1414

} else {

1415

/* Force the added task (connect_question_socket) to run again,

1416

at most one second from now */

1417

if((queue->next_run == 0)

1418

or (queue->next_run > (*current_time + 1000000))){

1419

queue->next_run = *current_time + 1000000;

1420

}

1421

}

1422

return;

1423

}

1424

1425

/* add task send_password_to_socket to queue */

1426

const task_context send_password_to_socket_task = {

1427

.func=send_password_to_socket,

1428

.question_filename=question_filename,

1429

.filename=filename,

1430

.epoll_fd=epoll_fd,

1431

.fd=fd,

1432

.password=password,

1433

.cancelled_filenames=cancelled_filenames,

1434

.mandos_client_exited=mandos_client_exited,

1435

.password_is_read=password_is_read,

1436

.current_time=current_time,

1437

};

1438

1439

if(not add_to_queue(queue, send_password_to_socket_task)){

1440

error(0, errno, "Failed to add send_password_to_socket for"

1441

" file \"%s\" and socket \"%s\" to queue",

1442

question_filename, filename);

1443

cleanup_task(&send_password_to_socket_task);

1444

}

1445

}

1446

1447

__attribute__((nonnull))

1448

void send_password_to_socket(const task_context task,

1449

task_queue *const queue){

1450

char *const question_filename=task.question_filename;

1451

char *const filename=task.filename;

1452

const int epoll_fd=task.epoll_fd;

1453

const int fd=task.fd;

1454

buffer *const password=task.password;

1455

string_set *const cancelled_filenames=task.cancelled_filenames;

1456

bool *const mandos_client_exited = task.mandos_client_exited;

1457

bool *const password_is_read = task.password_is_read;

1458

const mono_microsecs *const current_time = task.current_time;

1459

1460

if(*mandos_client_exited and *password_is_read){

1461

1462

const size_t send_buffer_length = password->length + 2;

1463

char *send_buffer = malloc(send_buffer_length);

1464

if(send_buffer == NULL){

1465

error(0, errno, "Failed to allocate send_buffer");

1466

} else {

1467

if(mlock(send_buffer, send_buffer_length) != 0){

1468

/* Warn but do not treat as fatal error */

1469

if(errno != EPERM and errno != ENOMEM){

1470

error(0, errno, "Failed to lock memory for password"

1471

" buffer");

1472

}

1473

}

1474

/* “[…] send a single datagram to the socket consisting of the

1475

password string either prefixed with "+" or with "-"

1476

depending on whether the password entry was successful or

1477

not. You may but don't have to include a final NUL byte in

1478

your message.

1479

1480

— <https://www.freedesktop.org/wiki/Software/systemd/

1481

PasswordAgents/> (Wed 08 Oct 2014 02:14:28 AM UTC)

1482

*/

1483

send_buffer[0] = '+'; /* Prefix with "+" */

1484

/* Always add an extra NUL */

1485

send_buffer[password->length + 1] = '\0';

1486

if(password->length > 0){

1487

memcpy(send_buffer + 1, password->data, password->length);

1488

}

1489

errno = 0;

1490

ssize_t ssret = send(fd, send_buffer, send_buffer_length,

1491

MSG_NOSIGNAL);

1492

const error_t saved_errno = errno;

1493

#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 25)

1494

explicit_bzero(send_buffer, send_buffer_length);

1495

#else

1496

memset(send_buffer, '\0', send_buffer_length);

1497

#endif

1498

if(munlock(send_buffer, send_buffer_length) != 0){

1499

error(0, errno, "Failed to unlock memory of send buffer");

1500

}

1501

free(send_buffer);

1502

if(ssret < 0 or ssret < (ssize_t)send_buffer_length){

1503

switch(saved_errno){

1504

case EINTR:

1505

case ENOBUFS:

1506

case ENOMEM:

1507

case EADDRINUSE:

1508

case ECONNREFUSED:

1509

case ECONNRESET:

1510

case ENOENT:

1511

case ETOOMANYREFS:

1512

case EAGAIN:

1513

/* Retry, below */

1514

break;

1515

case EMSGSIZE:

1516

error(0, 0, "Password of size %" PRIuMAX " is too big",

1517

(uintmax_t)password->length);

1518

#if __GNUC__ < 7

1519

/* FALLTHROUGH */

1520

#else

1521

__attribute__((fallthrough));

1522

#endif

1523

case 0:

1524

if(ssret >= 0 and ssret < (ssize_t)send_buffer_length){

1525

error(0, 0, "Password only partially sent to socket");

1526

}

1527

#if __GNUC__ < 7

1528

/* FALLTHROUGH */

1529

#else

1530

__attribute__((fallthrough));

1531

#endif

1532

default:

1533

error(0, saved_errno, "Failed to send() to socket %s",

1534

filename);

1535

if(not string_set_add(cancelled_filenames,

1536

question_filename)){

1537

error(0, errno, "Failed to cancel question for file %s",

1538

question_filename);

1539

}

1540

cleanup_task(&task);

1541

return;

1542

}

1543

} else {

1544

/* Success */

1545

cleanup_task(&task);

1546

return;

1547

}

1548

}

1549

}

1550

1551

/* We failed or are not ready yet; retry later */

1552

1553

if(not add_to_queue(queue, task)){

1554

error(0, errno, "Failed to add send_password_to_socket for"

1555

" file %s and socket %s to queue", question_filename,

1556

filename);

1557

cleanup_task(&task);

1558

}

1559

1560

/* Add the fd to the epoll set */

1561

if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

1562

&(struct epoll_event){ .events=EPOLLOUT })

1563

!= 0){

1564

error(0, errno, "Failed to add socket file descriptor %d for"

1565

" socket %s to epoll set", fd, filename);

1566

/* Force the added task (send_password_to_socket) to run again, at

1567

most one second from now */

1568

if((queue->next_run == 0)

1569

or (queue->next_run > (*current_time + 1000000))){

1570

queue->next_run = *current_time + 1000000;

1571

}

1572

}

1573

}

1574

1575

__attribute__((warn_unused_result))

1576

bool add_existing_questions(task_queue *const queue,

1577

const int epoll_fd,

1578

buffer *const password,

1579

string_set *cancelled_filenames,

1580

const mono_microsecs *const current_time,

1581

bool *const mandos_client_exited,

1582

bool *const password_is_read,

1583

const char *const dirname){

1584

__attribute__((cleanup(cleanup_string)))

1585

char *dir_pattern = NULL;

1586

const int ret = asprintf(&dir_pattern, "%s/ask.*", dirname);

1587

if(ret < 0 or dir_pattern == NULL){

1588

error(0, errno, "Could not create glob pattern for directory %s",

1589

dirname);

1590

return false;

1591

}

1592

__attribute__((cleanup(globfree)))

1593

glob_t question_filenames = {};

1594

switch(glob(dir_pattern, GLOB_ERR | GLOB_NOSORT | GLOB_MARK,

1595

NULL, &question_filenames)){

1596

case GLOB_ABORTED:

1597

default:

1598

error(0, errno, "Failed to open directory %s", dirname);

1599

return false;

1600

case GLOB_NOMATCH:

1601

error(0, errno, "There are no question files in %s", dirname);

1602

return false;

1603

case GLOB_NOSPACE:

1604

error(0, errno, "Could not allocate memory for question file"

1605

" names in %s", dirname);

1606

#if __GNUC__ < 7

1607

/* FALLTHROUGH */

1608

#else

1609

__attribute__((fallthrough));

1610

#endif

1611

case 0:

1612

for(size_t i = 0; i < question_filenames.gl_pathc; i++){

1613

char *const question_filename = strdup(question_filenames

1614

.gl_pathv[i]);

1615

const task_context task = {

1616

.func=open_and_parse_question,

1617

.epoll_fd=epoll_fd,

1618

.question_filename=question_filename,

1619

.filename=question_filename,

1620

.password=password,

1621

.cancelled_filenames=cancelled_filenames,

1622

.current_time=current_time,

1623

.mandos_client_exited=mandos_client_exited,

1624

.password_is_read=password_is_read,

1625

};

1626

1627

if(question_filename == NULL

1628

or not add_to_queue(queue, task)){

1629

error(0, errno, "Failed to add open_and_parse_question for"

1630

" file %s to queue",

1631

question_filenames.gl_pathv[i]);

1632

free(question_filename);

1633

} else {

1634

queue->next_run = 1;

1635

}

1636

}

1637

return true;

1638

}

1639

}

1640

1641

__attribute__((nonnull, warn_unused_result))

1642

bool wait_for_event(const int epoll_fd,

1643

const mono_microsecs queue_next_run,

1644

const mono_microsecs current_time){

1645

__attribute__((const))

1646

int milliseconds_to_wait(const mono_microsecs currtime,

1647

const mono_microsecs nextrun){

1648

if(currtime >= nextrun){

1649

return 0;

1650

}

1651

const uintmax_t wait_time_ms = (nextrun - currtime) / 1000;

1652

if(wait_time_ms > (uintmax_t)INT_MAX){

1653

return INT_MAX;

1654

}

1655

return (int)wait_time_ms;

1656

}

1657

1658

const int wait_time_ms = milliseconds_to_wait(current_time,

1659

queue_next_run);

1660

1661

/* Prepare unblocking of SIGCHLD during epoll_pwait */

1662

sigset_t temporary_unblocked_sigmask;

1663

/* Get current signal mask */

1664

if(pthread_sigmask(-1, NULL, &temporary_unblocked_sigmask) != 0){

1665

return false;

1666

}

1667

/* Remove SIGCHLD from the signal mask */

1668

if(sigdelset(&temporary_unblocked_sigmask, SIGCHLD) != 0){

1669

return false;

1670

}

1671

struct epoll_event events[8]; /* Ignored */

1672

int ret = epoll_pwait(epoll_fd, events,

1673

sizeof(events) / sizeof(struct epoll_event),

1674

queue_next_run == 0 ? -1 : (int)wait_time_ms,

1675

&temporary_unblocked_sigmask);

1676

if(ret < 0 and errno != EINTR){

1677

error(0, errno, "Failed epoll_pwait(epfd=%d, ..., timeout=%d,"

1678

" ...", epoll_fd,

1679

queue_next_run == 0 ? -1 : (int)wait_time_ms);

1680

return false;

1681

}

1682

return clear_all_fds_from_epoll_set(epoll_fd);

1683

}

1684

1685

bool clear_all_fds_from_epoll_set(const int epoll_fd){

1686

/* Create a new empty epoll set */

1687

__attribute__((cleanup(cleanup_close)))

1688

const int new_epoll_fd = epoll_create1(EPOLL_CLOEXEC);

1689

if(new_epoll_fd < 0){

1690

return false;

1691

}

1692

/* dup3() the new epoll set fd over the old one, replacing it */

1693

if(dup3(new_epoll_fd, epoll_fd, O_CLOEXEC) < 0){

1694

return false;

1695

}

1696

return true;

1697

}

1698

1699

__attribute__((nonnull, warn_unused_result))

1700

bool run_queue(task_queue **const queue,

1701

string_set *const cancelled_filenames,

1702

bool *const quit_now){

1703

1704

task_queue *new_queue = create_queue();

1705

if(new_queue == NULL){

1706

return false;

1707

}

1708

1709

__attribute__((cleanup(string_set_clear)))

1710

string_set old_cancelled_filenames = {};

1711

string_set_swap(cancelled_filenames, &old_cancelled_filenames);

1712

1713

/* Declare i outside the for loop, since we might need i after the

1714

loop in case we aborted in the middle */

1715

size_t i;

1716

for(i=0; i < (*queue)->length and not *quit_now; i++){

1717

task_context *const task = &((*queue)->tasks[i]);

1718

const char *const question_filename = task->question_filename;

1719

/* Skip any task referencing a cancelled question filename */

1720

if(question_filename != NULL

1721

and string_set_contains(old_cancelled_filenames,

1722

question_filename)){

1723

cleanup_task(task);

1724

continue;

1725

}

1726

task->func(*task, new_queue);

1727

}

1728

1729

if(*quit_now){

1730

/* we might be in the middle of the queue, so clean up any

1731

remaining tasks in the current queue */

1732

for(; i < (*queue)->length; i++){

1733

cleanup_task(&((*queue)->tasks[i]));

1734

}

1735

free_queue(*queue);

1736

*queue = new_queue;

1737

new_queue = NULL;

1738

return false;

1739

}

1740

free_queue(*queue);

1741

*queue = new_queue;

1742

new_queue = NULL;

1743

1744

return true;

1745

}

1746

1747

/* End of regular code section */

1748

1749

/* Start of tests section; here are the tests for the above code */

1750

1751

/* This "fixture" data structure is used by the test setup and

1752

teardown functions */

1753

typedef struct {

1754

struct sigaction orig_sigaction;

1755

sigset_t orig_sigmask;

1756

} test_fixture;

1757

1758

static void test_setup(test_fixture *fixture,

1759

__attribute__((unused))

1760

gconstpointer user_data){

1761

g_assert_true(setup_signal_handler(&fixture->orig_sigaction));

1762

g_assert_true(block_sigchld(&fixture->orig_sigmask));

1763

}

1764

1765

static void test_teardown(test_fixture *fixture,

1766

__attribute__((unused))

1767

gconstpointer user_data){

1768

g_assert_true(restore_signal_handler(&fixture->orig_sigaction));

1769

g_assert_true(restore_sigmask(&fixture->orig_sigmask));

1770

}

1771

1772

/* Utility function used by tests to search queue for matching task */

1773

__attribute__((pure, nonnull, warn_unused_result))

1774

static task_context *find_matching_task(const task_queue *const queue,

1775

const task_context task){

1776

/* The argument "task" structure is a pattern to match; 0 in any

1777

member means any value matches, otherwise the value must match.

1778

The filename strings are compared by strcmp(), not by pointer. */

1779

for(size_t i = 0; i < queue->length; i++){

1780

task_context *const current_task = queue->tasks+i;

1781

/* Check all members of task_context, if set to a non-zero value.

1782

If a member does not match, continue to next task in queue */

1783

1784

/* task_func *const func */

1785

if(task.func != NULL and current_task->func != task.func){

1786

continue;

1787

}

1788

/* char *const question_filename; */

1789

if(task.question_filename != NULL

1790

and (current_task->question_filename == NULL

1791

or strcmp(current_task->question_filename,

1792

task.question_filename) != 0)){

1793

continue;

1794

}

1795

/* const pid_t pid; */

1796

if(task.pid != 0 and current_task->pid != task.pid){

1797

continue;

1798

}

1799

/* const int epoll_fd; */

1800

if(task.epoll_fd != 0

1801

and current_task->epoll_fd != task.epoll_fd){

1802

continue;

1803

}

1804

/* bool *const quit_now; */

1805

if(task.quit_now != NULL

1806

and current_task->quit_now != task.quit_now){

1807

continue;

1808

}

1809

/* const int fd; */

1810

if(task.fd != 0 and current_task->fd != task.fd){

1811

continue;

1812

}

1813

/* bool *const mandos_client_exited; */

1814

if(task.mandos_client_exited != NULL

1815

and current_task->mandos_client_exited

1816

!= task.mandos_client_exited){

1817

continue;

1818

}

1819

/* buffer *const password; */

1820

if(task.password != NULL

1821

and current_task->password != task.password){

1822

continue;

1823

}

1824

/* bool *const password_is_read; */

1825

if(task.password_is_read != NULL

1826

and current_task->password_is_read != task.password_is_read){

1827

continue;

1828

}

1829

/* char *filename; */

1830

if(task.filename != NULL

1831

and (current_task->filename == NULL

1832

or strcmp(current_task->filename, task.filename) != 0)){

1833

continue;

1834

}

1835

/* string_set *const cancelled_filenames; */

1836

if(task.cancelled_filenames != NULL

1837

and current_task->cancelled_filenames

1838

!= task.cancelled_filenames){

1839

continue;

1840

}

1841

/* const mono_microsecs notafter; */

1842

if(task.notafter != 0

1843

and current_task->notafter != task.notafter){

1844

continue;

1845

}

1846

/* const mono_microsecs *const current_time; */

1847

if(task.current_time != NULL

1848

and current_task->current_time != task.current_time){

1849

continue;

1850

}

1851

/* Current task matches all members; return it */

1852

return current_task;

1853

}

1854

/* No task in queue matches passed pattern task */

1855

return NULL;

1856

}

1857

1858

static void test_create_queue(__attribute__((unused))

1859

test_fixture *fixture,

1860

__attribute__((unused))

1861

gconstpointer user_data){

1862

__attribute__((cleanup(cleanup_queue)))

1863

task_queue *const queue = create_queue();

1864

g_assert_nonnull(queue);

1865

g_assert_null(queue->tasks);

1866

g_assert_true(queue->length == 0);

1867

g_assert_true(queue->next_run == 0);

1868

}

1869

1870

static task_func dummy_func;

1871

1872

static void test_add_to_queue(__attribute__((unused))

1873

test_fixture *fixture,

1874

__attribute__((unused))

1875

gconstpointer user_data){

1876

__attribute__((cleanup(cleanup_queue)))

1877

task_queue *queue = create_queue();

1878

g_assert_nonnull(queue);

1879

1880

g_assert_true(add_to_queue(queue,

1881

(task_context){ .func=dummy_func }));

1882

g_assert_true(queue->length == 1);

1883

g_assert_nonnull(queue->tasks);

1884

g_assert_true(queue->tasks[0].func == dummy_func);

1885

}

1886

1887

static void dummy_func(__attribute__((unused))

1888

const task_context task,

1889

__attribute__((unused))

1890

task_queue *const queue){

1891

}

1892

1893

static void test_queue_has_question_empty(__attribute__((unused))

1894

test_fixture *fixture,

1895

__attribute__((unused))

1896

gconstpointer user_data){

1897

__attribute__((cleanup(cleanup_queue)))

1898

task_queue *queue = create_queue();

1899

g_assert_nonnull(queue);

1900

g_assert_false(queue_has_question(queue));

1901

}

1902

1903

static void test_queue_has_question_false(__attribute__((unused))

1904

test_fixture *fixture,

1905

__attribute__((unused))

1906

gconstpointer user_data){

1907

__attribute__((cleanup(cleanup_queue)))

1908

task_queue *queue = create_queue();

1909

g_assert_nonnull(queue);

1910

g_assert_true(add_to_queue(queue,

1911

(task_context){ .func=dummy_func }));

1912

g_assert_false(queue_has_question(queue));

1913

}

1914

1915

static void test_queue_has_question_true(__attribute__((unused))

1916

test_fixture *fixture,

1917

__attribute__((unused))

1918

gconstpointer user_data){

1919

__attribute__((cleanup(cleanup_queue)))

1920

task_queue *queue = create_queue();

1921

g_assert_nonnull(queue);

1922

char *const question_filename

1923

= strdup("/nonexistent/question_filename");

1924

g_assert_nonnull(question_filename);

1925

task_context task = {

1926

.func=dummy_func,

1927

.question_filename=question_filename,

1928

};

1929

g_assert_true(add_to_queue(queue, task));

1930

g_assert_true(queue_has_question(queue));

1931

}

1932

1933

static void test_queue_has_question_false2(__attribute__((unused))

1934

test_fixture *fixture,

1935

__attribute__((unused))

1936

gconstpointer user_data){

1937

__attribute__((cleanup(cleanup_queue)))

1938

task_queue *queue = create_queue();

1939

g_assert_nonnull(queue);

1940

task_context task = { .func=dummy_func };

1941

g_assert_true(add_to_queue(queue, task));

1942

g_assert_true(add_to_queue(queue, task));

1943

g_assert_cmpint((int)queue->length, ==, 2);

1944

g_assert_false(queue_has_question(queue));

1945

}

1946

1947

static void test_queue_has_question_true2(__attribute__((unused))

1948

test_fixture *fixture,

1949

__attribute__((unused))

1950

gconstpointer user_data){

1951

__attribute__((cleanup(cleanup_queue)))

1952

task_queue *queue = create_queue();

1953

g_assert_nonnull(queue);

1954

task_context task1 = { .func=dummy_func };

1955

g_assert_true(add_to_queue(queue, task1));

1956

char *const question_filename

1957

= strdup("/nonexistent/question_filename");

1958

g_assert_nonnull(question_filename);

1959

task_context task2 = {

1960

.func=dummy_func,

1961

.question_filename=question_filename,

1962

};

1963

g_assert_true(add_to_queue(queue, task2));

1964

g_assert_cmpint((int)queue->length, ==, 2);

1965

g_assert_true(queue_has_question(queue));

1966

}

1967

1968

static void test_cleanup_buffer(__attribute__((unused))

1969

test_fixture *fixture,

1970

__attribute__((unused))

1971

gconstpointer user_data){

1972

buffer buf = {};

1973

1974

const size_t buffersize = 10;

1975

1976

buf.data = malloc(buffersize);

1977

g_assert_nonnull(buf.data);

1978

if(mlock(buf.data, buffersize) != 0){

1979

g_assert_true(errno == EPERM or errno == ENOMEM);

1980

}

1981

1982

cleanup_buffer(&buf);

1983

g_assert_null(buf.data);

1984

}

1985

1986

static

1987

void test_string_set_new_set_contains_nothing(__attribute__((unused))

1988

test_fixture *fixture,

1989

__attribute__((unused))

1990

gconstpointer

1991

user_data){

1992

__attribute__((cleanup(string_set_clear)))

1993

string_set set = {};

1994

g_assert_false(string_set_contains(set, "")); /* Empty string */

1995

g_assert_false(string_set_contains(set, "test_string"));

1996

}

1997

1998

static void

1999

test_string_set_with_added_string_contains_it(__attribute__((unused))

2000

test_fixture *fixture,

2001

__attribute__((unused))

2002

gconstpointer

2003

user_data){

2004

__attribute__((cleanup(string_set_clear)))

2005

string_set set = {};

2006

g_assert_true(string_set_add(&set, "test_string"));

2007

g_assert_true(string_set_contains(set, "test_string"));

2008

}

2009

2010

static void

2011

test_string_set_cleared_does_not_contain_str(__attribute__((unused))

2012

test_fixture *fixture,

2013

__attribute__((unused))

2014

gconstpointer user_data){

2015

__attribute__((cleanup(string_set_clear)))

2016

string_set set = {};

2017

g_assert_true(string_set_add(&set, "test_string"));

2018

string_set_clear(&set);

2019

g_assert_false(string_set_contains(set, "test_string"));

2020

}

2021

2022

static

2023

void test_string_set_swap_one_with_empty(__attribute__((unused))

2024

test_fixture *fixture,

2025

__attribute__((unused))

2026

gconstpointer user_data){

2027

__attribute__((cleanup(string_set_clear)))

2028

string_set set1 = {};

2029

__attribute__((cleanup(string_set_clear)))

2030

string_set set2 = {};

2031

g_assert_true(string_set_add(&set1, "test_string1"));

2032

string_set_swap(&set1, &set2);

2033

g_assert_false(string_set_contains(set1, "test_string1"));

2034

g_assert_true(string_set_contains(set2, "test_string1"));

2035

}

2036

2037

static

2038

void test_string_set_swap_empty_with_one(__attribute__((unused))

2039

test_fixture *fixture,

2040

__attribute__((unused))

2041

gconstpointer user_data){

2042

__attribute__((cleanup(string_set_clear)))

2043

string_set set1 = {};

2044

__attribute__((cleanup(string_set_clear)))

2045

string_set set2 = {};

2046

g_assert_true(string_set_add(&set2, "test_string2"));

2047

string_set_swap(&set1, &set2);

2048

g_assert_true(string_set_contains(set1, "test_string2"));

2049

g_assert_false(string_set_contains(set2, "test_string2"));

2050

}

2051

2052

static void test_string_set_swap_one_with_one(__attribute__((unused))

2053

test_fixture *fixture,

2054

__attribute__((unused))

2055

gconstpointer

2056

user_data){

2057

__attribute__((cleanup(string_set_clear)))

2058

string_set set1 = {};

2059

__attribute__((cleanup(string_set_clear)))

2060

string_set set2 = {};

2061

g_assert_true(string_set_add(&set1, "test_string1"));

2062

g_assert_true(string_set_add(&set2, "test_string2"));

2063

string_set_swap(&set1, &set2);

2064

g_assert_false(string_set_contains(set1, "test_string1"));

2065

g_assert_true(string_set_contains(set1, "test_string2"));

2066

g_assert_false(string_set_contains(set2, "test_string2"));

2067

g_assert_true(string_set_contains(set2, "test_string1"));

2068

}

2069

2070

static bool fd_has_cloexec_and_nonblock(const int);

2071

2072

static bool epoll_set_contains(int, int, uint32_t);

2073

2074

static void test_start_mandos_client(test_fixture *fixture,

2075

__attribute__((unused))

2076

gconstpointer user_data){

2077

2078

bool mandos_client_exited = false;

2079

bool quit_now = false;

2080

__attribute__((cleanup(cleanup_close)))

2081

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2082

g_assert_cmpint(epoll_fd, >=, 0);

2083

__attribute__((cleanup(cleanup_queue)))

2084

task_queue *queue = create_queue();

2085

g_assert_nonnull(queue);

2086

buffer password = {};

2087

bool password_is_read = false;

2088

const char helper_directory[] = "/nonexistent";

2089

const char *const argv[] = { "/bin/true", NULL };

2090

2091

g_assert_true(start_mandos_client(queue, epoll_fd,

2092

&mandos_client_exited, &quit_now,

2093

&password, &password_is_read,

2094

&fixture->orig_sigaction,

2095

fixture->orig_sigmask,

2096

helper_directory, 0, 0, argv));

2097

2098

g_assert_cmpuint((unsigned int)queue->length, >=, 2);

2099

2100

const task_context *const added_wait_task

2101

= find_matching_task(queue, (task_context){

2102

.func=wait_for_mandos_client_exit,

2103

.mandos_client_exited=&mandos_client_exited,

2104

.quit_now=&quit_now,

2105

});

2106

g_assert_nonnull(added_wait_task);

2107

g_assert_cmpint(added_wait_task->pid, >, 0);

2108

g_assert_cmpint(kill(added_wait_task->pid, SIGKILL), ==, 0);

2109

waitpid(added_wait_task->pid, NULL, 0);

2110

2111

const task_context *const added_read_task

2112

= find_matching_task(queue, (task_context){

2113

.func=read_mandos_client_output,

2114

.epoll_fd=epoll_fd,

2115

.password=&password,

2116

.password_is_read=&password_is_read,

2117

.quit_now=&quit_now,

2118

});

2119

g_assert_nonnull(added_read_task);

2120

g_assert_cmpint(added_read_task->fd, >, 2);

2121

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

2122

g_assert_true(epoll_set_contains(epoll_fd, added_read_task->fd,

2123

EPOLLIN | EPOLLRDHUP));

2124

}

2125

2126

static bool fd_has_cloexec_and_nonblock(const int fd){

2127

const int socket_fd_flags = fcntl(fd, F_GETFD, 0);

2128

const int socket_file_flags = fcntl(fd, F_GETFL, 0);

2129

return ((socket_fd_flags >= 0)

2130

and (socket_fd_flags & FD_CLOEXEC)

2131

and (socket_file_flags >= 0)

2132

and (socket_file_flags & O_NONBLOCK));

2133

}

2134

2135

__attribute__((const))

2136

bool is_privileged(void){

2137

uid_t user = getuid() + 1;

2138

if(user == 0){ /* Overflow check */

2139

user++;

2140

}

2141

gid_t group = getuid() + 1;

2142

if(group == 0){ /* Overflow check */

2143

group++;

2144

}

2145

const pid_t pid = fork();

2146

if(pid == 0){ /* Child */

2147

if(setresgid((uid_t)-1, group, group) == -1){

2148

if(errno != EPERM){

2149

error(EXIT_FAILURE, errno, "Failed to setresgid(-1, %" PRIuMAX

2150

", %" PRIuMAX")", (uintmax_t)group, (uintmax_t)group);

2151

}

2152

exit(EXIT_FAILURE);

2153

}

2154

if(setresuid((uid_t)-1, user, user) == -1){

2155

if(errno != EPERM){

2156

error(EXIT_FAILURE, errno, "Failed to setresuid(-1, %" PRIuMAX

2157

", %" PRIuMAX")", (uintmax_t)user, (uintmax_t)user);

2158

}

2159

exit(EXIT_FAILURE);

2160

}

2161

exit(EXIT_SUCCESS);

2162

}

2163

int status;

2164

waitpid(pid, &status, 0);

2165

if(WIFEXITED(status) and (WEXITSTATUS(status) == EXIT_SUCCESS)){

2166

return true;

2167

}

2168

return false;

2169

}

2170

2171

static bool epoll_set_contains(int epoll_fd, int fd, uint32_t events){

2172

/* Only scan for events in this eventmask */

2173

const uint32_t eventmask = EPOLLIN | EPOLLOUT | EPOLLRDHUP;

2174

__attribute__((cleanup(cleanup_string)))

2175

char *fdinfo_name = NULL;

2176

int ret = asprintf(&fdinfo_name, "/proc/self/fdinfo/%d", epoll_fd);

2177

g_assert_cmpint(ret, >, 0);

2178

g_assert_nonnull(fdinfo_name);

2179

2180

FILE *fdinfo = fopen(fdinfo_name, "r");

2181

g_assert_nonnull(fdinfo);

2182

uint32_t reported_events;

2183

buffer line = {};

2184

int found_fd = -1;

2185

2186

do {

2187

if(getline(&line.data, &line.allocated, fdinfo) < 0){

2188

break;

2189

}

2190

/* See proc(5) for format of /proc/PID/fdinfo/FD for epoll fd's */

2191

if(sscanf(line.data, "tfd: %d events: %" SCNx32 " ",

2192

&found_fd, &reported_events) == 2){

2193

if(found_fd == fd){

2194

break;

2195

}

2196

}

2197

} while(not feof(fdinfo) and not ferror(fdinfo));

2198

g_assert_cmpint(fclose(fdinfo), ==, 0);

2199

free(line.data);

2200

if(found_fd != fd){

2201

return false;

2202

}

2203

2204

if(events == 0){

2205

/* Don't check events if none are given */

2206

return true;

2207

}

2208

return (reported_events & eventmask) == (events & eventmask);

2209

}

2210

2211

static void test_start_mandos_client_execv(test_fixture *fixture,

2212

__attribute__((unused))

2213

gconstpointer user_data){

2214

bool mandos_client_exited = false;

2215

bool quit_now = false;

2216

__attribute__((cleanup(cleanup_close)))

2217

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2218

g_assert_cmpint(epoll_fd, >=, 0);

2219

__attribute__((cleanup(cleanup_queue)))

2220

task_queue *queue = create_queue();

2221

g_assert_nonnull(queue);

2222

__attribute__((cleanup(cleanup_buffer)))

2223

buffer password = {};

2224

const char helper_directory[] = "/nonexistent";

2225

/* Can't execv("/", ...), so this should fail */

2226

const char *const argv[] = { "/", NULL };

2227

2228

{

2229

__attribute__((cleanup(cleanup_close)))

2230

const int devnull_fd = open("/dev/null",

2231

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2232

g_assert_cmpint(devnull_fd, >=, 0);

2233

__attribute__((cleanup(cleanup_close)))

2234

const int real_stderr_fd = dup(STDERR_FILENO);

2235

g_assert_cmpint(real_stderr_fd, >=, 0);

2236

dup2(devnull_fd, STDERR_FILENO);

2237

2238

const bool success = start_mandos_client(queue, epoll_fd,

2239

&mandos_client_exited,

2240

&quit_now,

2241

&password,

2242

(bool[]){false},

2243

&fixture->orig_sigaction,

2244

fixture->orig_sigmask,

2245

helper_directory, 0, 0,

2246

argv);

2247

dup2(real_stderr_fd, STDERR_FILENO);

2248

g_assert_true(success);

2249

}

2250

g_assert_cmpuint((unsigned int)queue->length, ==, 2);

2251

2252

struct timespec starttime, currtime;

2253

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);

2254

do {

2255

queue->next_run = 0;

2256

string_set cancelled_filenames = {};

2257

2258

{

2259

__attribute__((cleanup(cleanup_close)))

2260

const int devnull_fd = open("/dev/null",

2261

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2262

g_assert_cmpint(devnull_fd, >=, 0);

2263

__attribute__((cleanup(cleanup_close)))

2264

const int real_stderr_fd = dup(STDERR_FILENO);

2265

g_assert_cmpint(real_stderr_fd, >=, 0);

2266

g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));

2267

dup2(devnull_fd, STDERR_FILENO);

2268

const bool success = run_queue(&queue, &cancelled_filenames,

2269

&quit_now);

2270

dup2(real_stderr_fd, STDERR_FILENO);

2271

if(not success){

2272

break;

2273

}

2274

}

2275

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);

2276

} while(((queue->length) > 0)

2277

and (not quit_now)

2278

and ((currtime.tv_sec - starttime.tv_sec) < 10));

2279

2280

g_assert_true(quit_now);

2281

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

2282

g_assert_true(mandos_client_exited);

2283

}

2284

2285

static void test_start_mandos_client_suid_euid(test_fixture *fixture,

2286

__attribute__((unused))

2287

gconstpointer

2288

user_data){

2289

if(not is_privileged()){

2290

g_test_skip("Not privileged");

2291

return;

2292

}

2293

2294

bool mandos_client_exited = false;

2295

bool quit_now = false;

2296

__attribute__((cleanup(cleanup_close)))

2297

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2298

g_assert_cmpint(epoll_fd, >=, 0);

2299

__attribute__((cleanup(cleanup_queue)))

2300

task_queue *queue = create_queue();

2301

g_assert_nonnull(queue);

2302

__attribute__((cleanup(cleanup_buffer)))

2303

buffer password = {};

2304

bool password_is_read = false;

2305

const char helper_directory[] = "/nonexistent";

2306

const char *const argv[] = { "/usr/bin/id", "--user", NULL };

2307

uid_t user = 1000;

2308

gid_t group = 1001;

2309

2310

const bool success = start_mandos_client(queue, epoll_fd,

2311

&mandos_client_exited,

2312

&quit_now, &password,

2313

&password_is_read,

2314

&fixture->orig_sigaction,

2315

fixture->orig_sigmask,

2316

helper_directory, user,

2317

group, argv);

2318

g_assert_true(success);

2319

g_assert_cmpuint((unsigned int)queue->length, >, 0);

2320

2321

struct timespec starttime, currtime;

2322

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);

2323

do {

2324

queue->next_run = 0;

2325

string_set cancelled_filenames = {};

2326

g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));

2327

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

2328

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);

2329

} while(((queue->length) > 0)

2330

and (not quit_now)

2331

and ((currtime.tv_sec - starttime.tv_sec) < 10));

2332

2333

g_assert_false(quit_now);

2334

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

2335

g_assert_true(mandos_client_exited);

2336

2337

g_assert_true(password_is_read);

2338

g_assert_nonnull(password.data);

2339

2340

uintmax_t id;

2341

g_assert_cmpint(sscanf(password.data, "%" SCNuMAX "\n", &id),

2342

==, 1);

2343

g_assert_true((uid_t)id == id);

2344

2345

g_assert_cmpuint((unsigned int)id, ==, 0);

2346

}

2347

2348

static void test_start_mandos_client_suid_egid(test_fixture *fixture,

2349

__attribute__((unused))

2350

gconstpointer

2351

user_data){

2352

if(not is_privileged()){

2353

g_test_skip("Not privileged");

2354

return;

2355

}

2356

2357

bool mandos_client_exited = false;

2358

bool quit_now = false;

2359

__attribute__((cleanup(cleanup_close)))

2360

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2361

g_assert_cmpint(epoll_fd, >=, 0);

2362

__attribute__((cleanup(cleanup_queue)))

2363

task_queue *queue = create_queue();

2364

g_assert_nonnull(queue);

2365

__attribute__((cleanup(cleanup_buffer)))

2366

buffer password = {};

2367

bool password_is_read = false;

2368

const char helper_directory[] = "/nonexistent";

2369

const char *const argv[] = { "/usr/bin/id", "--group", NULL };

2370

uid_t user = 1000;

2371

gid_t group = 1001;

2372

2373

const bool success = start_mandos_client(queue, epoll_fd,

2374

&mandos_client_exited,

2375

&quit_now, &password,

2376

&password_is_read,

2377

&fixture->orig_sigaction,

2378

fixture->orig_sigmask,

2379

helper_directory, user,

2380

group, argv);

2381

g_assert_true(success);

2382

g_assert_cmpuint((unsigned int)queue->length, >, 0);

2383

2384

struct timespec starttime, currtime;

2385

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);

2386

do {

2387

queue->next_run = 0;

2388

string_set cancelled_filenames = {};

2389

g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));

2390

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

2391

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);

2392

} while(((queue->length) > 0)

2393

and (not quit_now)

2394

and ((currtime.tv_sec - starttime.tv_sec) < 10));

2395

2396

g_assert_false(quit_now);

2397

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

2398

g_assert_true(mandos_client_exited);

2399

2400

g_assert_true(password_is_read);

2401

g_assert_nonnull(password.data);

2402

2403

uintmax_t id;

2404

g_assert_cmpint(sscanf(password.data, "%" SCNuMAX "\n", &id),

2405

==, 1);

2406

g_assert_true((gid_t)id == id);

2407

2408

g_assert_cmpuint((unsigned int)id, ==, 0);

2409

}

2410

2411

static void test_start_mandos_client_suid_ruid(test_fixture *fixture,

2412

__attribute__((unused))

2413

gconstpointer

2414

user_data){

2415

if(not is_privileged()){

2416

g_test_skip("Not privileged");

2417

return;

2418

}

2419

2420

bool mandos_client_exited = false;

2421

bool quit_now = false;

2422

__attribute__((cleanup(cleanup_close)))

2423

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2424

g_assert_cmpint(epoll_fd, >=, 0);

2425

__attribute__((cleanup(cleanup_queue)))

2426

task_queue *queue = create_queue();

2427

g_assert_nonnull(queue);

2428

__attribute__((cleanup(cleanup_buffer)))

2429

buffer password = {};

2430

bool password_is_read = false;

2431

const char helper_directory[] = "/nonexistent";

2432

const char *const argv[] = { "/usr/bin/id", "--user", "--real",

2433

NULL };

2434

uid_t user = 1000;

2435

gid_t group = 1001;

2436

2437

const bool success = start_mandos_client(queue, epoll_fd,

2438

&mandos_client_exited,

2439

&quit_now, &password,

2440

&password_is_read,

2441

&fixture->orig_sigaction,

2442

fixture->orig_sigmask,

2443

helper_directory, user,

2444

group, argv);

2445

g_assert_true(success);

2446

g_assert_cmpuint((unsigned int)queue->length, >, 0);

2447

2448

struct timespec starttime, currtime;

2449

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);

2450

do {

2451

queue->next_run = 0;

2452

string_set cancelled_filenames = {};

2453

g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));

2454

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

2455

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);

2456

} while(((queue->length) > 0)

2457

and (not quit_now)

2458

and ((currtime.tv_sec - starttime.tv_sec) < 10));

2459

2460

g_assert_false(quit_now);

2461

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

2462

g_assert_true(mandos_client_exited);

2463

2464

g_assert_true(password_is_read);

2465

g_assert_nonnull(password.data);

2466

2467

uintmax_t id;

2468

g_assert_cmpint(sscanf(password.data, "%" SCNuMAX "\n", &id),

2469

==, 1);

2470

g_assert_true((uid_t)id == id);

2471

2472

g_assert_cmpuint((unsigned int)id, ==, user);

2473

}

2474

2475

static void test_start_mandos_client_suid_rgid(test_fixture *fixture,

2476

__attribute__((unused))

2477

gconstpointer

2478

user_data){

2479

if(not is_privileged()){

2480

g_test_skip("Not privileged");

2481

return;

2482

}

2483

2484

bool mandos_client_exited = false;

2485

bool quit_now = false;

2486

__attribute__((cleanup(cleanup_close)))

2487

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2488

g_assert_cmpint(epoll_fd, >=, 0);

2489

__attribute__((cleanup(cleanup_queue)))

2490

task_queue *queue = create_queue();

2491

g_assert_nonnull(queue);

2492

__attribute__((cleanup(cleanup_buffer)))

2493

buffer password = {};

2494

bool password_is_read = false;

2495

const char helper_directory[] = "/nonexistent";

2496

const char *const argv[] = { "/usr/bin/id", "--group", "--real",

2497

NULL };

2498

uid_t user = 1000;

2499

gid_t group = 1001;

2500

2501

const bool success = start_mandos_client(queue, epoll_fd,

2502

&mandos_client_exited,

2503

&quit_now, &password,

2504

&password_is_read,

2505

&fixture->orig_sigaction,

2506

fixture->orig_sigmask,

2507

helper_directory, user,

2508

group, argv);

2509

g_assert_true(success);

2510

g_assert_cmpuint((unsigned int)queue->length, >, 0);

2511

2512

struct timespec starttime, currtime;

2513

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);

2514

do {

2515

queue->next_run = 0;

2516

string_set cancelled_filenames = {};

2517

g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));

2518

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

2519

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);

2520

} while(((queue->length) > 0)

2521

and (not quit_now)

2522

and ((currtime.tv_sec - starttime.tv_sec) < 10));

2523

2524

g_assert_false(quit_now);

2525

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

2526

g_assert_true(mandos_client_exited);

2527

2528

g_assert_true(password_is_read);

2529

g_assert_nonnull(password.data);

2530

2531

uintmax_t id;

2532

g_assert_cmpint(sscanf(password.data, "%" SCNuMAX "\n", &id),

2533

==, 1);

2534

g_assert_true((gid_t)id == id);

2535

2536

g_assert_cmpuint((unsigned int)id, ==, group);

2537

}

2538

2539

static void test_start_mandos_client_read(test_fixture *fixture,

2540

__attribute__((unused))

2541

gconstpointer user_data){

2542

bool mandos_client_exited = false;

2543

bool quit_now = false;

2544

__attribute__((cleanup(cleanup_close)))

2545

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2546

g_assert_cmpint(epoll_fd, >=, 0);

2547

__attribute__((cleanup(cleanup_queue)))

2548

task_queue *queue = create_queue();

2549

g_assert_nonnull(queue);

2550

__attribute__((cleanup(cleanup_buffer)))

2551

buffer password = {};

2552

bool password_is_read = false;

2553

const char dummy_test_password[] = "dummy test password";

2554

const char helper_directory[] = "/nonexistent";

2555

const char *const argv[] = { "/bin/echo", "-n", dummy_test_password,

2556

NULL };

2557

2558

const bool success = start_mandos_client(queue, epoll_fd,

2559

&mandos_client_exited,

2560

&quit_now, &password,

2561

&password_is_read,

2562

&fixture->orig_sigaction,

2563

fixture->orig_sigmask,

2564

helper_directory, 0, 0,

2565

argv);

2566

g_assert_true(success);

2567

g_assert_cmpuint((unsigned int)queue->length, >, 0);

2568

2569

struct timespec starttime, currtime;

2570

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);

2571

do {

2572

queue->next_run = 0;

2573

string_set cancelled_filenames = {};

2574

g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));

2575

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

2576

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);

2577

} while(((queue->length) > 0)

2578

and (not quit_now)

2579

and ((currtime.tv_sec - starttime.tv_sec) < 10));

2580

2581

g_assert_false(quit_now);

2582

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

2583

g_assert_true(mandos_client_exited);

2584

2585

g_assert_true(password_is_read);

2586

g_assert_cmpint((int)password.length, ==,

2587

sizeof(dummy_test_password)-1);

2588

g_assert_nonnull(password.data);

2589

g_assert_cmpint(memcmp(dummy_test_password, password.data,

2590

sizeof(dummy_test_password)-1), ==, 0);

2591

}

2592

2593

static

2594

void test_start_mandos_client_helper_directory(test_fixture *fixture,

2595

__attribute__((unused))

2596

gconstpointer

2597

user_data){

2598

bool mandos_client_exited = false;

2599

bool quit_now = false;

2600

__attribute__((cleanup(cleanup_close)))

2601

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2602

g_assert_cmpint(epoll_fd, >=, 0);

2603

__attribute__((cleanup(cleanup_queue)))

2604

task_queue *queue = create_queue();

2605

g_assert_nonnull(queue);

2606

__attribute__((cleanup(cleanup_buffer)))

2607

buffer password = {};

2608

bool password_is_read = false;

2609

const char helper_directory[] = "/nonexistent";

2610

const char *const argv[] = { "/bin/sh", "-c",

2611

"echo -n ${MANDOSPLUGINHELPERDIR}", NULL };

2612

2613

const bool success = start_mandos_client(queue, epoll_fd,

2614

&mandos_client_exited,

2615

&quit_now, &password,

2616

&password_is_read,

2617

&fixture->orig_sigaction,

2618

fixture->orig_sigmask,

2619

helper_directory, 0, 0,

2620

argv);

2621

g_assert_true(success);

2622

g_assert_cmpuint((unsigned int)queue->length, >, 0);

2623

2624

struct timespec starttime, currtime;

2625

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);

2626

do {

2627

queue->next_run = 0;

2628

string_set cancelled_filenames = {};

2629

g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));

2630

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

2631

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);

2632

} while(((queue->length) > 0)

2633

and (not quit_now)

2634

and ((currtime.tv_sec - starttime.tv_sec) < 10));

2635

2636

g_assert_false(quit_now);

2637

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

2638

g_assert_true(mandos_client_exited);

2639

2640

g_assert_true(password_is_read);

2641

g_assert_cmpint((int)password.length, ==,

2642

sizeof(helper_directory)-1);

2643

g_assert_nonnull(password.data);

2644

g_assert_cmpint(memcmp(helper_directory, password.data,

2645

sizeof(helper_directory)-1), ==, 0);

2646

}

2647

2648

__attribute__((nonnull, warn_unused_result))

2649

static bool proc_status_sigblk_to_sigset(const char *const,

2650

sigset_t *const);

2651

2652

static void test_start_mandos_client_sigmask(test_fixture *fixture,

2653

__attribute__((unused))

2654

gconstpointer user_data){

2655

bool mandos_client_exited = false;

2656

bool quit_now = false;

2657

__attribute__((cleanup(cleanup_close)))

2658

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2659

g_assert_cmpint(epoll_fd, >=, 0);

2660

__attribute__((cleanup(cleanup_queue)))

2661

task_queue *queue = create_queue();

2662

g_assert_nonnull(queue);

2663

__attribute__((cleanup(cleanup_buffer)))

2664

buffer password = {};

2665

bool password_is_read = false;

2666

const char helper_directory[] = "/nonexistent";

2667

/* see proc(5) for format of /proc/self/status */

2668

const char *const argv[] = { "/usr/bin/awk",

2669

"$1==\"SigBlk:\"{ print $2 }", "/proc/self/status", NULL };

2670

2671

g_assert_true(start_mandos_client(queue, epoll_fd,

2672

&mandos_client_exited, &quit_now,

2673

&password, &password_is_read,

2674

&fixture->orig_sigaction,

2675

fixture->orig_sigmask,

2676

helper_directory, 0, 0, argv));

2677

2678

struct timespec starttime, currtime;

2679

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);

2680

do {

2681

queue->next_run = 0;

2682

string_set cancelled_filenames = {};

2683

g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));

2684

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

2685

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);

2686

} while((not (mandos_client_exited and password_is_read))

2687

and (not quit_now)

2688

and ((currtime.tv_sec - starttime.tv_sec) < 10));

2689

g_assert_true(mandos_client_exited);

2690

g_assert_true(password_is_read);

2691

2692

sigset_t parsed_sigmask;

2693

g_assert_true(proc_status_sigblk_to_sigset(password.data,

2694

&parsed_sigmask));

2695

2696

for(int signum = 1; signum < NSIG; signum++){

2697

const bool has_signal = sigismember(&parsed_sigmask, signum);

2698

if(sigismember(&fixture->orig_sigmask, signum)){

2699

g_assert_true(has_signal);

2700

} else {

2701

g_assert_false(has_signal);

2702

}

2703

}

2704

}

2705

2706

__attribute__((nonnull, warn_unused_result))

2707

static bool proc_status_sigblk_to_sigset(const char *const sigblk,

2708

sigset_t *const sigmask){

2709

/* parse /proc/PID/status SigBlk value and convert to a sigset_t */

2710

uintmax_t scanned_sigmask;

2711

if(sscanf(sigblk, "%" SCNxMAX " ", &scanned_sigmask) != 1){

2712

return false;

2713

}

2714

if(sigemptyset(sigmask) != 0){

2715

return false;

2716

}

2717

for(int signum = 1; signum < NSIG; signum++){

2718

if(scanned_sigmask & ((uintmax_t)1 << (signum-1))){

2719

if(sigaddset(sigmask, signum) != 0){

2720

return false;

2721

}

2722

}

2723

}

2724

return true;

2725

}

2726

2727

static void run_task_with_stderr_to_dev_null(const task_context task,

2728

task_queue *const queue);

2729

2730

static

2731

void test_wait_for_mandos_client_exit_badpid(__attribute__((unused))

2732

test_fixture *fixture,

2733

__attribute__((unused))

2734

gconstpointer user_data){

2735

2736

bool mandos_client_exited = false;

2737

bool quit_now = false;

2738

2739

__attribute__((cleanup(cleanup_queue)))

2740

task_queue *queue = create_queue();

2741

g_assert_nonnull(queue);

2742

const task_context task = {

2743

.func=wait_for_mandos_client_exit,

2744

.pid=1,

2745

.mandos_client_exited=&mandos_client_exited,

2746

.quit_now=&quit_now,

2747

};

2748

run_task_with_stderr_to_dev_null(task, queue);

2749

2750

g_assert_false(mandos_client_exited);

2751

g_assert_true(quit_now);

2752

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

2753

}

2754

2755

static void run_task_with_stderr_to_dev_null(const task_context task,

2756

task_queue *const queue){

2757

FILE *real_stderr = stderr;

2758

FILE *devnull = fopen("/dev/null", "we");

2759

g_assert_nonnull(devnull);

2760

2761

stderr = devnull;

2762

task.func(task, queue);

2763

stderr = real_stderr;

2764

2765

g_assert_cmpint(fclose(devnull), ==, 0);

2766

}

2767

2768

static

2769

void test_wait_for_mandos_client_exit_noexit(test_fixture *fixture,

2770

__attribute__((unused))

2771

gconstpointer user_data){

2772

bool mandos_client_exited = false;

2773

bool quit_now = false;

2774

2775

pid_t create_eternal_process(void){

2776

const pid_t pid = fork();

2777

if(pid == 0){ /* Child */

2778

if(not restore_signal_handler(&fixture->orig_sigaction)){

2779

_exit(EXIT_FAILURE);

2780

}

2781

if(not restore_sigmask(&fixture->orig_sigmask)){

2782

_exit(EXIT_FAILURE);

2783

}

2784

while(true){

2785

pause();

2786

}

2787

}

2788

return pid;

2789

}

2790

pid_t pid = create_eternal_process();

2791

g_assert_true(pid != -1);

2792

2793

__attribute__((cleanup(cleanup_queue)))

2794

task_queue *queue = create_queue();

2795

g_assert_nonnull(queue);

2796

const task_context task = {

2797

.func=wait_for_mandos_client_exit,

2798

.pid=pid,

2799

.mandos_client_exited=&mandos_client_exited,

2800

.quit_now=&quit_now,

2801

};

2802

task.func(task, queue);

2803

2804

g_assert_false(mandos_client_exited);

2805

g_assert_false(quit_now);

2806

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

2807

2808

g_assert_nonnull(find_matching_task(queue, (task_context){

2809

.func=wait_for_mandos_client_exit,

2810

.pid=task.pid,

2811

.mandos_client_exited=&mandos_client_exited,

2812

.quit_now=&quit_now,

2813

}));

2814

}

2815

2816

static

2817

void test_wait_for_mandos_client_exit_success(test_fixture *fixture,

2818

__attribute__((unused))

2819

gconstpointer

2820

user_data){

2821

bool mandos_client_exited = false;

2822

bool quit_now = false;

2823

2824

pid_t create_successful_process(void){

2825

const pid_t pid = fork();

2826

if(pid == 0){ /* Child */

2827

if(not restore_signal_handler(&fixture->orig_sigaction)){

2828

_exit(EXIT_FAILURE);

2829

}

2830

if(not restore_sigmask(&fixture->orig_sigmask)){

2831

_exit(EXIT_FAILURE);

2832

}

2833

exit(EXIT_SUCCESS);

2834

}

2835

return pid;

2836

}

2837

const pid_t pid = create_successful_process();

2838

g_assert_true(pid != -1);

2839

2840

__attribute__((cleanup(cleanup_queue)))

2841

task_queue *queue = create_queue();

2842

g_assert_nonnull(queue);

2843

const task_context initial_task = {

2844

.func=wait_for_mandos_client_exit,

2845

.pid=pid,

2846

.mandos_client_exited=&mandos_client_exited,

2847

.quit_now=&quit_now,

2848

};

2849

g_assert_true(add_to_queue(queue, initial_task));

2850

2851

struct timespec starttime, currtime;

2852

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);

2853

__attribute__((cleanup(cleanup_close)))

2854

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2855

do {

2856

queue->next_run = 0;

2857

g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));

2858

g_assert_true(run_queue(&queue, (string_set[]){{}}, &quit_now));

2859

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);

2860

} while((not mandos_client_exited)

2861

and (not quit_now)

2862

and ((currtime.tv_sec - starttime.tv_sec) < 10));

2863

2864

g_assert_true(mandos_client_exited);

2865

g_assert_false(quit_now);

2866

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

2867

}

2868

2869

static

2870

void test_wait_for_mandos_client_exit_failure(test_fixture *fixture,

2871

__attribute__((unused))

2872

gconstpointer

2873

user_data){

2874

bool mandos_client_exited = false;

2875

bool quit_now = false;

2876

2877

pid_t create_failing_process(void){

2878

const pid_t pid = fork();

2879

if(pid == 0){ /* Child */

2880

if(not restore_signal_handler(&fixture->orig_sigaction)){

2881

_exit(EXIT_FAILURE);

2882

}

2883

if(not restore_sigmask(&fixture->orig_sigmask)){

2884

_exit(EXIT_FAILURE);

2885

}

2886

exit(EXIT_FAILURE);

2887

}

2888

return pid;

2889

}

2890

const pid_t pid = create_failing_process();

2891

g_assert_true(pid != -1);

2892

2893

__attribute__((cleanup(string_set_clear)))

2894

string_set cancelled_filenames = {};

2895

__attribute__((cleanup(cleanup_close)))

2896

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2897

g_assert_cmpint(epoll_fd, >=, 0);

2898

__attribute__((cleanup(cleanup_queue)))

2899

task_queue *queue = create_queue();

2900

g_assert_nonnull(queue);

2901

g_assert_true(add_to_queue(queue, (task_context){

2902

.func=wait_for_mandos_client_exit,

2903

.pid=pid,

2904

.mandos_client_exited=&mandos_client_exited,

2905

.quit_now=&quit_now,

2906

}));

2907

2908

g_assert_true(sigismember(&fixture->orig_sigmask, SIGCHLD) == 0);

2909

2910

__attribute__((cleanup(cleanup_close)))

2911

const int devnull_fd = open("/dev/null",

2912

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2913

g_assert_cmpint(devnull_fd, >=, 0);

2914

__attribute__((cleanup(cleanup_close)))

2915

const int real_stderr_fd = dup(STDERR_FILENO);

2916

g_assert_cmpint(real_stderr_fd, >=, 0);

2917

2918

struct timespec starttime, currtime;

2919

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);

2920

do {

2921

g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));

2922

dup2(devnull_fd, STDERR_FILENO);

2923

const bool success = run_queue(&queue, &cancelled_filenames,

2924

&quit_now);

2925

dup2(real_stderr_fd, STDERR_FILENO);

2926

if(not success){

2927

break;

2928

}

2929

2930

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);

2931

} while((not mandos_client_exited)

2932

and (not quit_now)

2933

and ((currtime.tv_sec - starttime.tv_sec) < 10));

2934

2935

g_assert_true(quit_now);

2936

g_assert_true(mandos_client_exited);

2937

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

2938

}

2939

2940

static

2941

void test_wait_for_mandos_client_exit_killed(test_fixture *fixture,

2942

__attribute__((unused))

2943

gconstpointer user_data){

2944

bool mandos_client_exited = false;

2945

bool quit_now = false;

2946

2947

pid_t create_killed_process(void){

2948

const pid_t pid = fork();

2949

if(pid == 0){ /* Child */

2950

if(not restore_signal_handler(&fixture->orig_sigaction)){

2951

_exit(EXIT_FAILURE);

2952

}

2953

if(not restore_sigmask(&fixture->orig_sigmask)){

2954

_exit(EXIT_FAILURE);

2955

}

2956

while(true){

2957

pause();

2958

}

2959

}

2960

kill(pid, SIGKILL);

2961

return pid;

2962

}

2963

const pid_t pid = create_killed_process();

2964

g_assert_true(pid != -1);

2965

2966

__attribute__((cleanup(string_set_clear)))

2967

string_set cancelled_filenames = {};

2968

__attribute__((cleanup(cleanup_close)))

2969

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2970

g_assert_cmpint(epoll_fd, >=, 0);

2971

__attribute__((cleanup(cleanup_queue)))

2972

task_queue *queue = create_queue();

2973

g_assert_nonnull(queue);

2974

g_assert_true(add_to_queue(queue, (task_context){

2975

.func=wait_for_mandos_client_exit,

2976

.pid=pid,

2977

.mandos_client_exited=&mandos_client_exited,

2978

.quit_now=&quit_now,

2979

}));

2980

2981

__attribute__((cleanup(cleanup_close)))

2982

const int devnull_fd = open("/dev/null",

2983

O_WRONLY | O_CLOEXEC, O_NOCTTY);

2984

g_assert_cmpint(devnull_fd, >=, 0);

2985

__attribute__((cleanup(cleanup_close)))

2986

const int real_stderr_fd = dup(STDERR_FILENO);

2987

g_assert_cmpint(real_stderr_fd, >=, 0);

2988

2989

struct timespec starttime, currtime;

2990

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &starttime) == 0);

2991

do {

2992

g_assert_true(wait_for_event(epoll_fd, queue->next_run, 0));

2993

dup2(devnull_fd, STDERR_FILENO);

2994

const bool success = run_queue(&queue, &cancelled_filenames,

2995

&quit_now);

2996

dup2(real_stderr_fd, STDERR_FILENO);

2997

if(not success){

2998

break;

2999

}

3000

3001

g_assert_true(clock_gettime(CLOCK_MONOTONIC, &currtime) == 0);

3002

} while((not mandos_client_exited)

3003

and (not quit_now)

3004

and ((currtime.tv_sec - starttime.tv_sec) < 10));

3005

3006

g_assert_true(mandos_client_exited);

3007

g_assert_true(quit_now);

3008

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

3009

}

3010

3011

static bool epoll_set_does_not_contain(int, int);

3012

3013

static

3014

void test_read_mandos_client_output_readerror(__attribute__((unused))

3015

test_fixture *fixture,

3016

__attribute__((unused))

3017

gconstpointer

3018

user_data){

3019

__attribute__((cleanup(cleanup_close)))

3020

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3021

g_assert_cmpint(epoll_fd, >=, 0);

3022

3023

__attribute__((cleanup(cleanup_buffer)))

3024

buffer password = {};

3025

3026

/* Reading /proc/self/mem from offset 0 will always give EIO */

3027

const int fd = open("/proc/self/mem",

3028

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3029

3030

bool password_is_read = false;

3031

bool quit_now = false;

3032

__attribute__((cleanup(cleanup_queue)))

3033

task_queue *queue = create_queue();

3034

g_assert_nonnull(queue);

3035

3036

task_context task = {

3037

.func=read_mandos_client_output,

3038

.epoll_fd=epoll_fd,

3039

.fd=fd,

3040

.password=&password,

3041

.password_is_read=&password_is_read,

3042

.quit_now=&quit_now,

3043

};

3044

run_task_with_stderr_to_dev_null(task, queue);

3045

g_assert_false(password_is_read);

3046

g_assert_cmpint((int)password.length, ==, 0);

3047

g_assert_true(quit_now);

3048

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

3049

3050

g_assert_true(epoll_set_does_not_contain(epoll_fd, fd));

3051

3052

g_assert_cmpint(close(fd), ==, -1);

3053

}

3054

3055

static bool epoll_set_does_not_contain(int epoll_fd, int fd){

3056

return not epoll_set_contains(epoll_fd, fd, 0);

3057

}

3058

3059

static

3060

void test_read_mandos_client_output_nodata(__attribute__((unused))

3061

test_fixture *fixture,

3062

__attribute__((unused))

3063

gconstpointer user_data){

3064

__attribute__((cleanup(cleanup_close)))

3065

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3066

g_assert_cmpint(epoll_fd, >=, 0);

3067

3068

int pipefds[2];

3069

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

3070

3071

__attribute__((cleanup(cleanup_buffer)))

3072

buffer password = {};

3073

3074

bool password_is_read = false;

3075

bool quit_now = false;

3076

__attribute__((cleanup(cleanup_queue)))

3077

task_queue *queue = create_queue();

3078

g_assert_nonnull(queue);

3079

3080

task_context task = {

3081

.func=read_mandos_client_output,

3082

.epoll_fd=epoll_fd,

3083

.fd=pipefds[0],

3084

.password=&password,

3085

.password_is_read=&password_is_read,

3086

.quit_now=&quit_now,

3087

};

3088

task.func(task, queue);

3089

g_assert_false(password_is_read);

3090

g_assert_cmpint((int)password.length, ==, 0);

3091

g_assert_false(quit_now);

3092

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

3093

3094

g_assert_nonnull(find_matching_task(queue, (task_context){

3095

.func=read_mandos_client_output,

3096

.epoll_fd=epoll_fd,

3097

.fd=pipefds[0],

3098

.password=&password,

3099

.password_is_read=&password_is_read,

3100

.quit_now=&quit_now,

3101

}));

3102

3103

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3104

EPOLLIN | EPOLLRDHUP));

3105

3106

g_assert_cmpint(close(pipefds[1]), ==, 0);

3107

}

3108

3109

static void test_read_mandos_client_output_eof(__attribute__((unused))

3110

test_fixture *fixture,

3111

__attribute__((unused))

3112

gconstpointer

3113

user_data){

3114

__attribute__((cleanup(cleanup_close)))

3115

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3116

g_assert_cmpint(epoll_fd, >=, 0);

3117

3118

int pipefds[2];

3119

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

3120

g_assert_cmpint(close(pipefds[1]), ==, 0);

3121

3122

__attribute__((cleanup(cleanup_buffer)))

3123

buffer password = {};

3124

3125

bool password_is_read = false;

3126

bool quit_now = false;

3127

__attribute__((cleanup(cleanup_queue)))

3128

task_queue *queue = create_queue();

3129

g_assert_nonnull(queue);

3130

3131

task_context task = {

3132

.func=read_mandos_client_output,

3133

.epoll_fd=epoll_fd,

3134

.fd=pipefds[0],

3135

.password=&password,

3136

.password_is_read=&password_is_read,

3137

.quit_now=&quit_now,

3138

};

3139

task.func(task, queue);

3140

g_assert_true(password_is_read);

3141

g_assert_cmpint((int)password.length, ==, 0);

3142

g_assert_false(quit_now);

3143

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

3144

3145

g_assert_true(epoll_set_does_not_contain(epoll_fd, pipefds[0]));

3146

3147

g_assert_cmpint(close(pipefds[0]), ==, -1);

3148

}

3149

3150

static

3151

void test_read_mandos_client_output_once(__attribute__((unused))

3152

test_fixture *fixture,

3153

__attribute__((unused))

3154

gconstpointer user_data){

3155

__attribute__((cleanup(cleanup_close)))

3156

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3157

g_assert_cmpint(epoll_fd, >=, 0);

3158

3159

int pipefds[2];

3160

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

3161

3162

const char dummy_test_password[] = "dummy test password";

3163

/* Start with a pre-allocated buffer */

3164

__attribute__((cleanup(cleanup_buffer)))

3165

buffer password = {

3166

.data=malloc(sizeof(dummy_test_password)),

3167

.length=0,

3168

.allocated=sizeof(dummy_test_password),

3169

};

3170

g_assert_nonnull(password.data);

3171

if(mlock(password.data, password.allocated) != 0){

3172

g_assert_true(errno == EPERM or errno == ENOMEM);

3173

}

3174

3175

bool password_is_read = false;

3176

bool quit_now = false;

3177

__attribute__((cleanup(cleanup_queue)))

3178

task_queue *queue = create_queue();

3179

g_assert_nonnull(queue);

3180

3181

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3182

g_assert_cmpint((int)write(pipefds[1], dummy_test_password,

3183

sizeof(dummy_test_password)),

3184

==, (int)sizeof(dummy_test_password));

3185

3186

task_context task = {

3187

.func=read_mandos_client_output,

3188

.epoll_fd=epoll_fd,

3189

.fd=pipefds[0],

3190

.password=&password,

3191

.password_is_read=&password_is_read,

3192

.quit_now=&quit_now,

3193

};

3194

task.func(task, queue);

3195

3196

g_assert_false(password_is_read);

3197

g_assert_cmpint((int)password.length, ==,

3198

(int)sizeof(dummy_test_password));

3199

g_assert_nonnull(password.data);

3200

g_assert_cmpint(memcmp(password.data, dummy_test_password,

3201

sizeof(dummy_test_password)), ==, 0);

3202

3203

g_assert_false(quit_now);

3204

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

3205

3206

g_assert_nonnull(find_matching_task(queue, (task_context){

3207

.func=read_mandos_client_output,

3208

.epoll_fd=epoll_fd,

3209

.fd=pipefds[0],

3210

.password=&password,

3211

.password_is_read=&password_is_read,

3212

.quit_now=&quit_now,

3213

}));

3214

3215

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3216

EPOLLIN | EPOLLRDHUP));

3217

3218

g_assert_cmpint(close(pipefds[1]), ==, 0);

3219

}

3220

3221

static

3222

void test_read_mandos_client_output_malloc(__attribute__((unused))

3223

test_fixture *fixture,

3224

__attribute__((unused))

3225

gconstpointer user_data){

3226

__attribute__((cleanup(cleanup_close)))

3227

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3228

g_assert_cmpint(epoll_fd, >=, 0);

3229

3230

int pipefds[2];

3231

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

3232

3233

const char dummy_test_password[] = "dummy test password";

3234

/* Start with an empty buffer */

3235

__attribute__((cleanup(cleanup_buffer)))

3236

buffer password = {};

3237

3238

bool password_is_read = false;

3239

bool quit_now = false;

3240

__attribute__((cleanup(cleanup_queue)))

3241

task_queue *queue = create_queue();

3242

g_assert_nonnull(queue);

3243

3244

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3245

g_assert_cmpint((int)write(pipefds[1], dummy_test_password,

3246

sizeof(dummy_test_password)),

3247

==, (int)sizeof(dummy_test_password));

3248

3249

task_context task = {

3250

.func=read_mandos_client_output,

3251

.epoll_fd=epoll_fd,

3252

.fd=pipefds[0],

3253

.password=&password,

3254

.password_is_read=&password_is_read,

3255

.quit_now=&quit_now,

3256

};

3257

task.func(task, queue);

3258

3259

g_assert_false(password_is_read);

3260

g_assert_cmpint((int)password.length, ==,

3261

(int)sizeof(dummy_test_password));

3262

g_assert_nonnull(password.data);

3263

g_assert_cmpint(memcmp(password.data, dummy_test_password,

3264

sizeof(dummy_test_password)), ==, 0);

3265

3266

g_assert_false(quit_now);

3267

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

3268

3269

g_assert_nonnull(find_matching_task(queue, (task_context){

3270

.func=read_mandos_client_output,

3271

.epoll_fd=epoll_fd,

3272

.fd=pipefds[0],

3273

.password=&password,

3274

.password_is_read=&password_is_read,

3275

.quit_now=&quit_now,

3276

}));

3277

3278

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3279

EPOLLIN | EPOLLRDHUP));

3280

3281

g_assert_cmpint(close(pipefds[1]), ==, 0);

3282

}

3283

3284

static

3285

void test_read_mandos_client_output_append(__attribute__((unused))

3286

test_fixture *fixture,

3287

__attribute__((unused))

3288

gconstpointer user_data){

3289

__attribute__((cleanup(cleanup_close)))

3290

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3291

g_assert_cmpint(epoll_fd, >=, 0);

3292

3293

int pipefds[2];

3294

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

3295

3296

const char dummy_test_password[] = "dummy test password";

3297

__attribute__((cleanup(cleanup_buffer)))

3298

buffer password = {

3299

.data=malloc(PIPE_BUF),

3300

.length=PIPE_BUF,

3301

.allocated=PIPE_BUF,

3302

};

3303

g_assert_nonnull(password.data);

3304

if(mlock(password.data, password.allocated) != 0){

3305

g_assert_true(errno == EPERM or errno == ENOMEM);

3306

}

3307

3308

memset(password.data, 'x', PIPE_BUF);

3309

char password_expected[PIPE_BUF];

3310

memcpy(password_expected, password.data, PIPE_BUF);

3311

3312

bool password_is_read = false;

3313

bool quit_now = false;

3314

__attribute__((cleanup(cleanup_queue)))

3315

task_queue *queue = create_queue();

3316

g_assert_nonnull(queue);

3317

3318

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3319

g_assert_cmpint((int)write(pipefds[1], dummy_test_password,

3320

sizeof(dummy_test_password)),

3321

==, (int)sizeof(dummy_test_password));

3322

3323

task_context task = {

3324

.func=read_mandos_client_output,

3325

.epoll_fd=epoll_fd,

3326

.fd=pipefds[0],

3327

.password=&password,

3328

.password_is_read=&password_is_read,

3329

.quit_now=&quit_now,

3330

};

3331

task.func(task, queue);

3332

3333

g_assert_false(password_is_read);

3334

g_assert_cmpint((int)password.length, ==,

3335

PIPE_BUF + sizeof(dummy_test_password));

3336

g_assert_nonnull(password.data);

3337

g_assert_cmpint(memcmp(password_expected, password.data, PIPE_BUF),

3338

==, 0);

3339

g_assert_cmpint(memcmp(password.data + PIPE_BUF,

3340

dummy_test_password,

3341

sizeof(dummy_test_password)), ==, 0);

3342

g_assert_false(quit_now);

3343

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

3344

3345

g_assert_nonnull(find_matching_task(queue, (task_context){

3346

.func=read_mandos_client_output,

3347

.epoll_fd=epoll_fd,

3348

.fd=pipefds[0],

3349

.password=&password,

3350

.password_is_read=&password_is_read,

3351

.quit_now=&quit_now,

3352

}));

3353

3354

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3355

EPOLLIN | EPOLLRDHUP));

3356

}

3357

3358

static char *make_temporary_directory(void);

3359

3360

static void test_add_inotify_dir_watch(__attribute__((unused))

3361

test_fixture *fixture,

3362

__attribute__((unused))

3363

gconstpointer user_data){

3364

__attribute__((cleanup(cleanup_close)))

3365

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3366

g_assert_cmpint(epoll_fd, >=, 0);

3367

__attribute__((cleanup(cleanup_queue)))

3368

task_queue *queue = create_queue();

3369

g_assert_nonnull(queue);

3370

__attribute__((cleanup(string_set_clear)))

3371

string_set cancelled_filenames = {};

3372

const mono_microsecs current_time = 0;

3373

3374

bool quit_now = false;

3375

buffer password = {};

3376

bool mandos_client_exited = false;

3377

bool password_is_read = false;

3378

3379

__attribute__((cleanup(cleanup_string)))

3380

char *tempdir = make_temporary_directory();

3381

g_assert_nonnull(tempdir);

3382

3383

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3384

&password, tempdir,

3385

&cancelled_filenames,

3386

&current_time,

3387

&mandos_client_exited,

3388

&password_is_read));

3389

3390

g_assert_cmpuint((unsigned int)queue->length, >, 0);

3391

3392

const task_context *const added_read_task

3393

= find_matching_task(queue, (task_context){

3394

.func=read_inotify_event,

3395

.epoll_fd=epoll_fd,

3396

.quit_now=&quit_now,

3397

.password=&password,

3398

.filename=tempdir,

3399

.cancelled_filenames=&cancelled_filenames,

3400

.current_time=&current_time,

3401

.mandos_client_exited=&mandos_client_exited,

3402

.password_is_read=&password_is_read,

3403

});

3404

g_assert_nonnull(added_read_task);

3405

3406

g_assert_cmpint(added_read_task->fd, >, 2);

3407

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3408

g_assert_true(epoll_set_contains(added_read_task->epoll_fd,

3409

added_read_task->fd,

3410

EPOLLIN | EPOLLRDHUP));

3411

3412

g_assert_cmpint(rmdir(tempdir), ==, 0);

3413

}

3414

3415

static char *make_temporary_directory(void){

3416

char *name = strdup("/tmp/mandosXXXXXX");

3417

g_assert_nonnull(name);

3418

char *result = mkdtemp(name);

3419

if(result == NULL){

3420

free(name);

3421

}

3422

return result;

3423

}

3424

3425

static void test_add_inotify_dir_watch_fail(__attribute__((unused))

3426

test_fixture *fixture,

3427

__attribute__((unused))

3428

gconstpointer user_data){

3429

__attribute__((cleanup(cleanup_close)))

3430

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3431

g_assert_cmpint(epoll_fd, >=, 0);

3432

__attribute__((cleanup(cleanup_queue)))

3433

task_queue *queue = create_queue();

3434

g_assert_nonnull(queue);

3435

__attribute__((cleanup(string_set_clear)))

3436

string_set cancelled_filenames = {};

3437

const mono_microsecs current_time = 0;

3438

3439

bool quit_now = false;

3440

buffer password = {};

3441

bool mandos_client_exited = false;

3442

bool password_is_read = false;

3443

3444

const char nonexistent_dir[] = "/nonexistent";

3445

3446

FILE *real_stderr = stderr;

3447

FILE *devnull = fopen("/dev/null", "we");

3448

g_assert_nonnull(devnull);

3449

stderr = devnull;

3450

g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3451

&password, nonexistent_dir,

3452

&cancelled_filenames,

3453

&current_time,

3454

&mandos_client_exited,

3455

&password_is_read));

3456

stderr = real_stderr;

3457

g_assert_cmpint(fclose(devnull), ==, 0);

3458

3459

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

3460

}

3461

3462

static void test_add_inotify_dir_watch_nondir(__attribute__((unused))

3463

test_fixture *fixture,

3464

__attribute__((unused))

3465

gconstpointer

3466

user_data){

3467

__attribute__((cleanup(cleanup_close)))

3468

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3469

g_assert_cmpint(epoll_fd, >=, 0);

3470

__attribute__((cleanup(cleanup_queue)))

3471

task_queue *queue = create_queue();

3472

g_assert_nonnull(queue);

3473

__attribute__((cleanup(string_set_clear)))

3474

string_set cancelled_filenames = {};

3475

const mono_microsecs current_time = 0;

3476

3477

bool quit_now = false;

3478

buffer password = {};

3479

bool mandos_client_exited = false;

3480

bool password_is_read = false;

3481

3482

const char not_a_directory[] = "/dev/tty";

3483

3484

FILE *real_stderr = stderr;

3485

FILE *devnull = fopen("/dev/null", "we");

3486

g_assert_nonnull(devnull);

3487

stderr = devnull;

3488

g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3489

&password, not_a_directory,

3490

&cancelled_filenames,

3491

&current_time,

3492

&mandos_client_exited,

3493

&password_is_read));

3494

stderr = real_stderr;

3495

g_assert_cmpint(fclose(devnull), ==, 0);

3496

3497

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

3498

}

3499

3500

static void test_add_inotify_dir_watch_EAGAIN(__attribute__((unused))

3501

test_fixture *fixture,

3502

__attribute__((unused))

3503

gconstpointer

3504

user_data){

3505

__attribute__((cleanup(cleanup_close)))

3506

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3507

g_assert_cmpint(epoll_fd, >=, 0);

3508

__attribute__((cleanup(cleanup_queue)))

3509

task_queue *queue = create_queue();

3510

g_assert_nonnull(queue);

3511

__attribute__((cleanup(string_set_clear)))

3512

string_set cancelled_filenames = {};

3513

const mono_microsecs current_time = 0;

3514

3515

bool quit_now = false;

3516

buffer password = {};

3517

bool mandos_client_exited = false;

3518

bool password_is_read = false;

3519

3520

__attribute__((cleanup(cleanup_string)))

3521

char *tempdir = make_temporary_directory();

3522

g_assert_nonnull(tempdir);

3523

3524

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3525

&password, tempdir,

3526

&cancelled_filenames,

3527

&current_time,

3528

&mandos_client_exited,

3529

&password_is_read));

3530

3531

g_assert_cmpuint((unsigned int)queue->length, >, 0);

3532

3533

const task_context *const added_read_task

3534

= find_matching_task(queue,

3535

(task_context){ .func=read_inotify_event });

3536

g_assert_nonnull(added_read_task);

3537

3538

g_assert_cmpint(added_read_task->fd, >, 2);

3539

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3540

3541

/* "sufficient to read at least one event." - inotify(7) */

3542

const size_t ievent_size = (sizeof(struct inotify_event)

3543

+ NAME_MAX + 1);

3544

struct inotify_event *ievent = malloc(ievent_size);

3545

g_assert_nonnull(ievent);

3546

3547

g_assert_cmpint(read(added_read_task->fd, ievent, ievent_size), ==,

3548

-1);

3549

g_assert_cmpint(errno, ==, EAGAIN);

3550

3551

free(ievent);

3552

3553

g_assert_cmpint(rmdir(tempdir), ==, 0);

3554

}

3555

3556

static char *make_temporary_file_in_directory(const char

3557

*const dir);

3558

3559

static

3560

void test_add_inotify_dir_watch_IN_CLOSE_WRITE(__attribute__((unused))

3561

test_fixture *fixture,

3562

__attribute__((unused))

3563

gconstpointer

3564

user_data){

3565

__attribute__((cleanup(cleanup_close)))

3566

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3567

g_assert_cmpint(epoll_fd, >=, 0);

3568

__attribute__((cleanup(cleanup_queue)))

3569

task_queue *queue = create_queue();

3570

g_assert_nonnull(queue);

3571

__attribute__((cleanup(string_set_clear)))

3572

string_set cancelled_filenames = {};

3573

const mono_microsecs current_time = 0;

3574

3575

bool quit_now = false;

3576

buffer password = {};

3577

bool mandos_client_exited = false;

3578

bool password_is_read = false;

3579

3580

__attribute__((cleanup(cleanup_string)))

3581

char *tempdir = make_temporary_directory();

3582

g_assert_nonnull(tempdir);

3583

3584

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3585

&password, tempdir,

3586

&cancelled_filenames,

3587

&current_time,

3588

&mandos_client_exited,

3589

&password_is_read));

3590

3591

g_assert_cmpuint((unsigned int)queue->length, >, 0);

3592

3593

const task_context *const added_read_task

3594

= find_matching_task(queue,

3595

(task_context){ .func=read_inotify_event });

3596

g_assert_nonnull(added_read_task);

3597

3598

g_assert_cmpint(added_read_task->fd, >, 2);

3599

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3600

3601

__attribute__((cleanup(cleanup_string)))

3602

char *filename = make_temporary_file_in_directory(tempdir);

3603

g_assert_nonnull(filename);

3604

3605

/* "sufficient to read at least one event." - inotify(7) */

3606

const size_t ievent_size = (sizeof(struct inotify_event)

3607

+ NAME_MAX + 1);

3608

struct inotify_event *ievent = malloc(ievent_size);

3609

g_assert_nonnull(ievent);

3610

3611

ssize_t read_size = 0;

3612

read_size = read(added_read_task->fd, ievent, ievent_size);

3613

3614

g_assert_cmpint((int)read_size, >, 0);

3615

g_assert_true(ievent->mask & IN_CLOSE_WRITE);

3616

g_assert_cmpstr(ievent->name, ==, basename(filename));

3617

3618

free(ievent);

3619

3620

g_assert_cmpint(unlink(filename), ==, 0);

3621

g_assert_cmpint(rmdir(tempdir), ==, 0);

3622

}

3623

3624

static char *make_temporary_prefixed_file_in_directory(const char

3625

*const prefix,

3626

const char

3627

*const dir){

3628

char *filename = NULL;

3629

g_assert_cmpint(asprintf(&filename, "%s/%sXXXXXX", dir, prefix),

3630

>, 0);

3631

g_assert_nonnull(filename);

3632

const int fd = mkostemp(filename, O_CLOEXEC);

3633

g_assert_cmpint(fd, >=, 0);

3634

g_assert_cmpint(close(fd), ==, 0);

3635

return filename;

3636

}

3637

3638

static char *make_temporary_file_in_directory(const char

3639

*const dir){

3640

return make_temporary_prefixed_file_in_directory("temp", dir);

3641

}

3642

3643

static

3644

void test_add_inotify_dir_watch_IN_MOVED_TO(__attribute__((unused))

3645

test_fixture *fixture,

3646

__attribute__((unused))

3647

gconstpointer user_data){

3648

__attribute__((cleanup(cleanup_close)))

3649

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3650

g_assert_cmpint(epoll_fd, >=, 0);

3651

__attribute__((cleanup(cleanup_queue)))

3652

task_queue *queue = create_queue();

3653

g_assert_nonnull(queue);

3654

__attribute__((cleanup(string_set_clear)))

3655

string_set cancelled_filenames = {};

3656

const mono_microsecs current_time = 0;

3657

3658

bool quit_now = false;

3659

buffer password = {};

3660

bool mandos_client_exited = false;

3661

bool password_is_read = false;

3662

3663

__attribute__((cleanup(cleanup_string)))

3664

char *watchdir = make_temporary_directory();

3665

g_assert_nonnull(watchdir);

3666

3667

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3668

&password, watchdir,

3669

&cancelled_filenames,

3670

&current_time,

3671

&mandos_client_exited,

3672

&password_is_read));

3673

3674

g_assert_cmpuint((unsigned int)queue->length, >, 0);

3675

3676

const task_context *const added_read_task

3677

= find_matching_task(queue,

3678

(task_context){ .func=read_inotify_event });

3679

g_assert_nonnull(added_read_task);

3680

3681

g_assert_cmpint(added_read_task->fd, >, 2);

3682

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3683

3684

char *sourcedir = make_temporary_directory();

3685

g_assert_nonnull(sourcedir);

3686

3687

__attribute__((cleanup(cleanup_string)))

3688

char *filename = make_temporary_file_in_directory(sourcedir);

3689

g_assert_nonnull(filename);

3690

3691

__attribute__((cleanup(cleanup_string)))

3692

char *targetfilename = NULL;

3693

g_assert_cmpint(asprintf(&targetfilename, "%s/%s", watchdir,

3694

basename(filename)), >, 0);

3695

g_assert_nonnull(targetfilename);

3696

3697

g_assert_cmpint(rename(filename, targetfilename), ==, 0);

3698

g_assert_cmpint(rmdir(sourcedir), ==, 0);

3699

free(sourcedir);

3700

3701

/* "sufficient to read at least one event." - inotify(7) */

3702

const size_t ievent_size = (sizeof(struct inotify_event)

3703

+ NAME_MAX + 1);

3704

struct inotify_event *ievent = malloc(ievent_size);

3705

g_assert_nonnull(ievent);

3706

3707

ssize_t read_size = read(added_read_task->fd, ievent, ievent_size);

3708

3709

g_assert_cmpint((int)read_size, >, 0);

3710

g_assert_true(ievent->mask & IN_MOVED_TO);

3711

g_assert_cmpstr(ievent->name, ==, basename(targetfilename));

3712

3713

free(ievent);

3714

3715

g_assert_cmpint(unlink(targetfilename), ==, 0);

3716

g_assert_cmpint(rmdir(watchdir), ==, 0);

3717

}

3718

3719

static

3720

void test_add_inotify_dir_watch_IN_MOVED_FROM(__attribute__((unused))

3721

test_fixture *fixture,

3722

__attribute__((unused))

3723

gconstpointer

3724

user_data){

3725

__attribute__((cleanup(cleanup_close)))

3726

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3727

g_assert_cmpint(epoll_fd, >=, 0);

3728

__attribute__((cleanup(cleanup_queue)))

3729

task_queue *queue = create_queue();

3730

g_assert_nonnull(queue);

3731

__attribute__((cleanup(string_set_clear)))

3732

string_set cancelled_filenames = {};

3733

const mono_microsecs current_time = 0;

3734

3735

bool quit_now = false;

3736

buffer password = {};

3737

bool mandos_client_exited = false;

3738

bool password_is_read = false;

3739

3740

__attribute__((cleanup(cleanup_string)))

3741

char *tempdir = make_temporary_directory();

3742

g_assert_nonnull(tempdir);

3743

3744

__attribute__((cleanup(cleanup_string)))

3745

char *tempfilename = make_temporary_file_in_directory(tempdir);

3746

g_assert_nonnull(tempfilename);

3747

3748

__attribute__((cleanup(cleanup_string)))

3749

char *targetdir = make_temporary_directory();

3750

g_assert_nonnull(targetdir);

3751

3752

__attribute__((cleanup(cleanup_string)))

3753

char *targetfilename = NULL;

3754

g_assert_cmpint(asprintf(&targetfilename, "%s/%s", targetdir,

3755

basename(tempfilename)), >, 0);

3756

g_assert_nonnull(targetfilename);

3757

3758

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3759

&password, tempdir,

3760

&cancelled_filenames,

3761

&current_time,

3762

&mandos_client_exited,

3763

&password_is_read));

3764

3765

g_assert_cmpint(rename(tempfilename, targetfilename), ==, 0);

3766

3767

const task_context *const added_read_task

3768

= find_matching_task(queue,

3769

(task_context){ .func=read_inotify_event });

3770

g_assert_nonnull(added_read_task);

3771

3772

/* "sufficient to read at least one event." - inotify(7) */

3773

const size_t ievent_size = (sizeof(struct inotify_event)

3774

+ NAME_MAX + 1);

3775

struct inotify_event *ievent = malloc(ievent_size);

3776

g_assert_nonnull(ievent);

3777

3778

ssize_t read_size = read(added_read_task->fd, ievent, ievent_size);

3779

3780

g_assert_cmpint((int)read_size, >, 0);

3781

g_assert_true(ievent->mask & IN_MOVED_FROM);

3782

g_assert_cmpstr(ievent->name, ==, basename(tempfilename));

3783

3784

free(ievent);

3785

3786

g_assert_cmpint(unlink(targetfilename), ==, 0);

3787

g_assert_cmpint(rmdir(targetdir), ==, 0);

3788

g_assert_cmpint(rmdir(tempdir), ==, 0);

3789

}

3790

3791

static

3792

void test_add_inotify_dir_watch_IN_DELETE(__attribute__((unused))

3793

test_fixture *fixture,

3794

__attribute__((unused))

3795

gconstpointer user_data){

3796

__attribute__((cleanup(cleanup_close)))

3797

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3798

g_assert_cmpint(epoll_fd, >=, 0);

3799

__attribute__((cleanup(cleanup_queue)))

3800

task_queue *queue = create_queue();

3801

g_assert_nonnull(queue);

3802

__attribute__((cleanup(string_set_clear)))

3803

string_set cancelled_filenames = {};

3804

const mono_microsecs current_time = 0;

3805

3806

bool quit_now = false;

3807

buffer password = {};

3808

bool mandos_client_exited = false;

3809

bool password_is_read = false;

3810

3811

__attribute__((cleanup(cleanup_string)))

3812

char *tempdir = make_temporary_directory();

3813

g_assert_nonnull(tempdir);

3814

3815

__attribute__((cleanup(cleanup_string)))

3816

char *tempfile = make_temporary_file_in_directory(tempdir);

3817

g_assert_nonnull(tempfile);

3818

3819

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3820

&password, tempdir,

3821

&cancelled_filenames,

3822

&current_time,

3823

&mandos_client_exited,

3824

&password_is_read));

3825

g_assert_cmpint(unlink(tempfile), ==, 0);

3826

3827

g_assert_cmpuint((unsigned int)queue->length, >, 0);

3828

3829

const task_context *const added_read_task

3830

= find_matching_task(queue,

3831

(task_context){ .func=read_inotify_event });

3832

g_assert_nonnull(added_read_task);

3833

3834

g_assert_cmpint(added_read_task->fd, >, 2);

3835

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3836

3837

/* "sufficient to read at least one event." - inotify(7) */

3838

const size_t ievent_size = (sizeof(struct inotify_event)

3839

+ NAME_MAX + 1);

3840

struct inotify_event *ievent = malloc(ievent_size);

3841

g_assert_nonnull(ievent);

3842

3843

ssize_t read_size = 0;

3844

read_size = read(added_read_task->fd, ievent, ievent_size);

3845

3846

g_assert_cmpint((int)read_size, >, 0);

3847

g_assert_true(ievent->mask & IN_DELETE);

3848

g_assert_cmpstr(ievent->name, ==, basename(tempfile));

3849

3850

free(ievent);

3851

3852

g_assert_cmpint(rmdir(tempdir), ==, 0);

3853

}

3854

3855

static

3856

void test_add_inotify_dir_watch_IN_EXCL_UNLINK(__attribute__((unused))

3857

test_fixture *fixture,

3858

__attribute__((unused))

3859

gconstpointer

3860

user_data){

3861

__attribute__((cleanup(cleanup_close)))

3862

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3863

g_assert_cmpint(epoll_fd, >=, 0);

3864

__attribute__((cleanup(cleanup_queue)))

3865

task_queue *queue = create_queue();

3866

g_assert_nonnull(queue);

3867

__attribute__((cleanup(string_set_clear)))

3868

string_set cancelled_filenames = {};

3869

const mono_microsecs current_time = 0;

3870

3871

bool quit_now = false;

3872

buffer password = {};

3873

bool mandos_client_exited = false;

3874

bool password_is_read = false;

3875

3876

__attribute__((cleanup(cleanup_string)))

3877

char *tempdir = make_temporary_directory();

3878

g_assert_nonnull(tempdir);

3879

3880

__attribute__((cleanup(cleanup_string)))

3881

char *tempfile = make_temporary_file_in_directory(tempdir);

3882

g_assert_nonnull(tempfile);

3883

int tempfile_fd = open(tempfile, O_WRONLY | O_CLOEXEC | O_NOCTTY

3884

| O_NOFOLLOW);

3885

g_assert_cmpint(tempfile_fd, >, 2);

3886

3887

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3888

&password, tempdir,

3889

&cancelled_filenames,

3890

&current_time,

3891

&mandos_client_exited,

3892

&password_is_read));

3893

g_assert_cmpint(unlink(tempfile), ==, 0);

3894

3895

g_assert_cmpuint((unsigned int)queue->length, >, 0);

3896

3897

const task_context *const added_read_task

3898

= find_matching_task(queue,

3899

(task_context){ .func=read_inotify_event });

3900

g_assert_nonnull(added_read_task);

3901

3902

g_assert_cmpint(added_read_task->fd, >, 2);

3903

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3904

3905

/* "sufficient to read at least one event." - inotify(7) */

3906

const size_t ievent_size = (sizeof(struct inotify_event)

3907

+ NAME_MAX + 1);

3908

struct inotify_event *ievent = malloc(ievent_size);

3909

g_assert_nonnull(ievent);

3910

3911

ssize_t read_size = 0;

3912

read_size = read(added_read_task->fd, ievent, ievent_size);

3913

3914

g_assert_cmpint((int)read_size, >, 0);

3915

g_assert_true(ievent->mask & IN_DELETE);

3916

g_assert_cmpstr(ievent->name, ==, basename(tempfile));

3917

3918

g_assert_cmpint(close(tempfile_fd), ==, 0);

3919

3920

/* IN_EXCL_UNLINK should make the closing of the previously unlinked

3921

file not appear as an ievent, so we should not see it now. */

3922

read_size = read(added_read_task->fd, ievent, ievent_size);

3923

g_assert_cmpint((int)read_size, ==, -1);

3924

g_assert_true(errno == EAGAIN);

3925

3926

free(ievent);

3927

3928

g_assert_cmpint(rmdir(tempdir), ==, 0);

3929

}

3930

3931

static void test_read_inotify_event_readerror(__attribute__((unused))

3932

test_fixture *fixture,

3933

__attribute__((unused))

3934

gconstpointer

3935

user_data){

3936

__attribute__((cleanup(cleanup_close)))

3937

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3938

g_assert_cmpint(epoll_fd, >=, 0);

3939

const mono_microsecs current_time = 0;

3940

3941

/* Reading /proc/self/mem from offset 0 will always result in EIO */

3942

const int fd = open("/proc/self/mem",

3943

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3944

3945

bool quit_now = false;

3946

__attribute__((cleanup(cleanup_queue)))

3947

task_queue *queue = create_queue();

3948

g_assert_nonnull(queue);

3949

3950

task_context task = {

3951

.func=read_inotify_event,

3952

.epoll_fd=epoll_fd,

3953

.fd=fd,

3954

.quit_now=&quit_now,

3955

.filename=strdup("/nonexistent"),

3956

.cancelled_filenames = &(string_set){},

3957

.notafter=0,

3958

.current_time=&current_time,

3959

};

3960

g_assert_nonnull(task.filename);

3961

run_task_with_stderr_to_dev_null(task, queue);

3962

g_assert_true(quit_now);

3963

g_assert_true(queue->next_run == 0);

3964

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

3965

3966

g_assert_true(epoll_set_does_not_contain(epoll_fd, fd));

3967

3968

g_assert_cmpint(close(fd), ==, -1);

3969

}

3970

3971

static void test_read_inotify_event_bad_epoll(__attribute__((unused))

3972

test_fixture *fixture,

3973

__attribute__((unused))

3974

gconstpointer

3975

user_data){

3976

const mono_microsecs current_time = 17;

3977

3978

int pipefds[2];

3979

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

3980

const int epoll_fd = pipefds[0]; /* This will obviously fail */

3981

3982

bool quit_now = false;

3983

buffer password = {};

3984

bool mandos_client_exited = false;

3985

bool password_is_read = false;

3986

__attribute__((cleanup(cleanup_queue)))

3987

task_queue *queue = create_queue();

3988

g_assert_nonnull(queue);

3989

3990

task_context task = {

3991

.func=read_inotify_event,

3992

.epoll_fd=epoll_fd,

3993

.fd=pipefds[0],

3994

.quit_now=&quit_now,

3995

.password=&password,

3996

.filename=strdup("/nonexistent"),

3997

.cancelled_filenames = &(string_set){},

3998

.notafter=0,

3999

.current_time=&current_time,

4000

.mandos_client_exited=&mandos_client_exited,

4001

.password_is_read=&password_is_read,

4002

};

4003

g_assert_nonnull(task.filename);

4004

run_task_with_stderr_to_dev_null(task, queue);

4005

4006

g_assert_nonnull(find_matching_task(queue, task));

4007

g_assert_true(queue->next_run == 1000000 + current_time);

4008

4009

g_assert_cmpint(close(pipefds[0]), ==, 0);

4010

g_assert_cmpint(close(pipefds[1]), ==, 0);

4011

}

4012

4013

static void test_read_inotify_event_nodata(__attribute__((unused))

4014

test_fixture *fixture,

4015

__attribute__((unused))

4016

gconstpointer user_data){

4017

__attribute__((cleanup(cleanup_close)))

4018

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4019

g_assert_cmpint(epoll_fd, >=, 0);

4020

const mono_microsecs current_time = 0;

4021

4022

int pipefds[2];

4023

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

4024

4025

bool quit_now = false;

4026

buffer password = {};

4027

bool mandos_client_exited = false;

4028

bool password_is_read = false;

4029

__attribute__((cleanup(cleanup_queue)))

4030

task_queue *queue = create_queue();

4031

g_assert_nonnull(queue);

4032

4033

task_context task = {

4034

.func=read_inotify_event,

4035

.epoll_fd=epoll_fd,

4036

.fd=pipefds[0],

4037

.quit_now=&quit_now,

4038

.password=&password,

4039

.filename=strdup("/nonexistent"),

4040

.cancelled_filenames = &(string_set){},

4041

.notafter=0,

4042

.current_time=&current_time,

4043

.mandos_client_exited=&mandos_client_exited,

4044

.password_is_read=&password_is_read,

4045

};

4046

g_assert_nonnull(task.filename);

4047

task.func(task, queue);

4048

g_assert_false(quit_now);

4049

g_assert_true(queue->next_run == 0);

4050

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

4051

4052

g_assert_nonnull(find_matching_task(queue, (task_context){

4053

.func=read_inotify_event,

4054

.epoll_fd=epoll_fd,

4055

.fd=pipefds[0],

4056

.quit_now=&quit_now,

4057

.password=&password,

4058

.filename=task.filename,

4059

.cancelled_filenames=task.cancelled_filenames,

4060

.current_time=&current_time,

4061

.mandos_client_exited=&mandos_client_exited,

4062

.password_is_read=&password_is_read,

4063

}));

4064

4065

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4066

EPOLLIN | EPOLLRDHUP));

4067

4068

g_assert_cmpint(close(pipefds[1]), ==, 0);

4069

}

4070

4071

static void test_read_inotify_event_eof(__attribute__((unused))

4072

test_fixture *fixture,

4073

__attribute__((unused))

4074

gconstpointer user_data){

4075

__attribute__((cleanup(cleanup_close)))

4076

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4077

g_assert_cmpint(epoll_fd, >=, 0);

4078

const mono_microsecs current_time = 0;

4079

4080

int pipefds[2];

4081

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

4082

g_assert_cmpint(close(pipefds[1]), ==, 0);

4083

4084

bool quit_now = false;

4085

buffer password = {};

4086

__attribute__((cleanup(cleanup_queue)))

4087

task_queue *queue = create_queue();

4088

g_assert_nonnull(queue);

4089

4090

task_context task = {

4091

.func=read_inotify_event,

4092

.epoll_fd=epoll_fd,

4093

.fd=pipefds[0],

4094

.quit_now=&quit_now,

4095

.password=&password,

4096

.filename=strdup("/nonexistent"),

4097

.cancelled_filenames = &(string_set){},

4098

.notafter=0,

4099

.current_time=&current_time,

4100

};

4101

run_task_with_stderr_to_dev_null(task, queue);

4102

g_assert_true(quit_now);

4103

g_assert_true(queue->next_run == 0);

4104

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4105

4106

g_assert_true(epoll_set_does_not_contain(epoll_fd, pipefds[0]));

4107

4108

g_assert_cmpint(close(pipefds[0]), ==, -1);

4109

}

4110

4111

static

4112

void test_read_inotify_event_IN_CLOSE_WRITE(__attribute__((unused))

4113

test_fixture *fixture,

4114

__attribute__((unused))

4115

gconstpointer user_data){

4116

__attribute__((cleanup(cleanup_close)))

4117

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4118

g_assert_cmpint(epoll_fd, >=, 0);

4119

const mono_microsecs current_time = 0;

4120

4121

int pipefds[2];

4122

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

4123

4124

/* "sufficient to read at least one event." - inotify(7) */

4125

const size_t ievent_max_size = (sizeof(struct inotify_event)

4126

+ NAME_MAX + 1);

4127

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4128

struct {

4129

struct inotify_event event;

4130

char name_buffer[NAME_MAX + 1];

4131

} ievent_buffer;

4132

struct inotify_event *const ievent = &ievent_buffer.event;

4133

4134

const char dummy_file_name[] = "ask.dummy_file_name";

4135

ievent->mask = IN_CLOSE_WRITE;

4136

ievent->len = sizeof(dummy_file_name);

4137

memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));

4138

const size_t ievent_size = (sizeof(struct inotify_event)

4139

+ sizeof(dummy_file_name));

4140

g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),

4141

==, ievent_size);

4142

g_assert_cmpint(close(pipefds[1]), ==, 0);

4143

4144

bool quit_now = false;

4145

buffer password = {};

4146

bool mandos_client_exited = false;

4147

bool password_is_read = false;

4148

__attribute__((cleanup(cleanup_queue)))

4149

task_queue *queue = create_queue();

4150

g_assert_nonnull(queue);

4151

4152

task_context task = {

4153

.func=read_inotify_event,

4154

.epoll_fd=epoll_fd,

4155

.fd=pipefds[0],

4156

.quit_now=&quit_now,

4157

.password=&password,

4158

.filename=strdup("/nonexistent"),

4159

.cancelled_filenames = &(string_set){},

4160

.notafter=0,

4161

.current_time=&current_time,

4162

.mandos_client_exited=&mandos_client_exited,

4163

.password_is_read=&password_is_read,

4164

};

4165

task.func(task, queue);

4166

g_assert_false(quit_now);

4167

g_assert_true(queue->next_run != 0);

4168

g_assert_cmpuint((unsigned int)queue->length, >=, 1);

4169

4170

g_assert_nonnull(find_matching_task(queue, (task_context){

4171

.func=read_inotify_event,

4172

.epoll_fd=epoll_fd,

4173

.fd=pipefds[0],

4174

.quit_now=&quit_now,

4175

.password=&password,

4176

.filename=task.filename,

4177

.cancelled_filenames=task.cancelled_filenames,

4178

.current_time=&current_time,

4179

.mandos_client_exited=&mandos_client_exited,

4180

.password_is_read=&password_is_read,

4181

}));

4182

4183

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4184

EPOLLIN | EPOLLRDHUP));

4185

4186

g_assert_cmpuint((unsigned int)queue->length, >=, 2);

4187

4188

__attribute__((cleanup(cleanup_string)))

4189

char *filename = NULL;

4190

g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,

4191

dummy_file_name), >, 0);

4192

g_assert_nonnull(filename);

4193

g_assert_nonnull(find_matching_task(queue, (task_context){

4194

.func=open_and_parse_question,

4195

.epoll_fd=epoll_fd,

4196

.filename=filename,

4197

.question_filename=filename,

4198

.password=&password,

4199

.cancelled_filenames=task.cancelled_filenames,

4200

.current_time=&current_time,

4201

.mandos_client_exited=&mandos_client_exited,

4202

.password_is_read=&password_is_read,

4203

}));

4204

}

4205

4206

static

4207

void test_read_inotify_event_IN_MOVED_TO(__attribute__((unused))

4208

test_fixture *fixture,

4209

__attribute__((unused))

4210

gconstpointer user_data){

4211

__attribute__((cleanup(cleanup_close)))

4212

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4213

g_assert_cmpint(epoll_fd, >=, 0);

4214

const mono_microsecs current_time = 0;

4215

4216

int pipefds[2];

4217

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

4218

4219

/* "sufficient to read at least one event." - inotify(7) */

4220

const size_t ievent_max_size = (sizeof(struct inotify_event)

4221

+ NAME_MAX + 1);

4222

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4223

struct {

4224

struct inotify_event event;

4225

char name_buffer[NAME_MAX + 1];

4226

} ievent_buffer;

4227

struct inotify_event *const ievent = &ievent_buffer.event;

4228

4229

const char dummy_file_name[] = "ask.dummy_file_name";

4230

ievent->mask = IN_MOVED_TO;

4231

ievent->len = sizeof(dummy_file_name);

4232

memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));

4233

const size_t ievent_size = (sizeof(struct inotify_event)

4234

+ sizeof(dummy_file_name));

4235

g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),

4236

==, ievent_size);

4237

g_assert_cmpint(close(pipefds[1]), ==, 0);

4238

4239

bool quit_now = false;

4240

buffer password = {};

4241

bool mandos_client_exited = false;

4242

bool password_is_read = false;

4243

__attribute__((cleanup(cleanup_queue)))

4244

task_queue *queue = create_queue();

4245

g_assert_nonnull(queue);

4246

4247

task_context task = {

4248

.func=read_inotify_event,

4249

.epoll_fd=epoll_fd,

4250

.fd=pipefds[0],

4251

.quit_now=&quit_now,

4252

.password=&password,

4253

.filename=strdup("/nonexistent"),

4254

.cancelled_filenames = &(string_set){},

4255

.notafter=0,

4256

.current_time=&current_time,

4257

.mandos_client_exited=&mandos_client_exited,

4258

.password_is_read=&password_is_read,

4259

};

4260

task.func(task, queue);

4261

g_assert_false(quit_now);

4262

g_assert_true(queue->next_run != 0);

4263

g_assert_cmpuint((unsigned int)queue->length, >=, 1);

4264

4265

g_assert_nonnull(find_matching_task(queue, (task_context){

4266

.func=read_inotify_event,

4267

.epoll_fd=epoll_fd,

4268

.fd=pipefds[0],

4269

.quit_now=&quit_now,

4270

.password=&password,

4271

.filename=task.filename,

4272

.cancelled_filenames=task.cancelled_filenames,

4273

.current_time=&current_time,

4274

.mandos_client_exited=&mandos_client_exited,

4275

.password_is_read=&password_is_read,

4276

}));

4277

4278

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4279

EPOLLIN | EPOLLRDHUP));

4280

4281

g_assert_cmpuint((unsigned int)queue->length, >=, 2);

4282

4283

__attribute__((cleanup(cleanup_string)))

4284

char *filename = NULL;

4285

g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,

4286

dummy_file_name), >, 0);

4287

g_assert_nonnull(filename);

4288

g_assert_nonnull(find_matching_task(queue, (task_context){

4289

.func=open_and_parse_question,

4290

.epoll_fd=epoll_fd,

4291

.filename=filename,

4292

.question_filename=filename,

4293

.password=&password,

4294

.cancelled_filenames=task.cancelled_filenames,

4295

.current_time=&current_time,

4296

.mandos_client_exited=&mandos_client_exited,

4297

.password_is_read=&password_is_read,

4298

}));

4299

}

4300

4301

static

4302

void test_read_inotify_event_IN_MOVED_FROM(__attribute__((unused))

4303

test_fixture *fixture,

4304

__attribute__((unused))

4305

gconstpointer user_data){

4306

__attribute__((cleanup(cleanup_close)))

4307

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4308

g_assert_cmpint(epoll_fd, >=, 0);

4309

__attribute__((cleanup(string_set_clear)))

4310

string_set cancelled_filenames = {};

4311

const mono_microsecs current_time = 0;

4312

4313

int pipefds[2];

4314

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

4315

4316

/* "sufficient to read at least one event." - inotify(7) */

4317

const size_t ievent_max_size = (sizeof(struct inotify_event)

4318

+ NAME_MAX + 1);

4319

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4320

struct {

4321

struct inotify_event event;

4322

char name_buffer[NAME_MAX + 1];

4323

} ievent_buffer;

4324

struct inotify_event *const ievent = &ievent_buffer.event;

4325

4326

const char dummy_file_name[] = "ask.dummy_file_name";

4327

ievent->mask = IN_MOVED_FROM;

4328

ievent->len = sizeof(dummy_file_name);

4329

memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));

4330

const size_t ievent_size = (sizeof(struct inotify_event)

4331

+ sizeof(dummy_file_name));

4332

g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),

4333

==, ievent_size);

4334

g_assert_cmpint(close(pipefds[1]), ==, 0);

4335

4336

bool quit_now = false;

4337

buffer password = {};

4338

bool mandos_client_exited = false;

4339

bool password_is_read = false;

4340

__attribute__((cleanup(cleanup_queue)))

4341

task_queue *queue = create_queue();

4342

g_assert_nonnull(queue);

4343

4344

task_context task = {

4345

.func=read_inotify_event,

4346

.epoll_fd=epoll_fd,

4347

.fd=pipefds[0],

4348

.quit_now=&quit_now,

4349

.password=&password,

4350

.filename=strdup("/nonexistent"),

4351

.cancelled_filenames=&cancelled_filenames,

4352

.current_time=&current_time,

4353

.mandos_client_exited=&mandos_client_exited,

4354

.password_is_read=&password_is_read,

4355

};

4356

task.func(task, queue);

4357

g_assert_false(quit_now);

4358

g_assert_true(queue->next_run == 0);

4359

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

4360

4361

g_assert_nonnull(find_matching_task(queue, (task_context){

4362

.func=read_inotify_event,

4363

.epoll_fd=epoll_fd,

4364

.fd=pipefds[0],

4365

.quit_now=&quit_now,

4366

.password=&password,

4367

.filename=task.filename,

4368

.cancelled_filenames=&cancelled_filenames,

4369

.current_time=&current_time,

4370

.mandos_client_exited=&mandos_client_exited,

4371

.password_is_read=&password_is_read,

4372

}));

4373

4374

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4375

EPOLLIN | EPOLLRDHUP));

4376

4377

__attribute__((cleanup(cleanup_string)))

4378

char *filename = NULL;

4379

g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,

4380

dummy_file_name), >, 0);

4381

g_assert_nonnull(filename);

4382

g_assert_true(string_set_contains(*task.cancelled_filenames,

4383

filename));

4384

}

4385

4386

static void test_read_inotify_event_IN_DELETE(__attribute__((unused))

4387

test_fixture *fixture,

4388

__attribute__((unused))

4389

gconstpointer

4390

user_data){

4391

__attribute__((cleanup(cleanup_close)))

4392

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4393

g_assert_cmpint(epoll_fd, >=, 0);

4394

__attribute__((cleanup(string_set_clear)))

4395

string_set cancelled_filenames = {};

4396

const mono_microsecs current_time = 0;

4397

4398

int pipefds[2];

4399

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

4400

4401

/* "sufficient to read at least one event." - inotify(7) */

4402

const size_t ievent_max_size = (sizeof(struct inotify_event)

4403

+ NAME_MAX + 1);

4404

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4405

struct {

4406

struct inotify_event event;

4407

char name_buffer[NAME_MAX + 1];

4408

} ievent_buffer;

4409

struct inotify_event *const ievent = &ievent_buffer.event;

4410

4411

const char dummy_file_name[] = "ask.dummy_file_name";

4412

ievent->mask = IN_DELETE;

4413

ievent->len = sizeof(dummy_file_name);

4414

memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));

4415

const size_t ievent_size = (sizeof(struct inotify_event)

4416

+ sizeof(dummy_file_name));

4417

g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),

4418

==, ievent_size);

4419

g_assert_cmpint(close(pipefds[1]), ==, 0);

4420

4421

bool quit_now = false;

4422

buffer password = {};

4423

bool mandos_client_exited = false;

4424

bool password_is_read = false;

4425

__attribute__((cleanup(cleanup_queue)))

4426

task_queue *queue = create_queue();

4427

g_assert_nonnull(queue);

4428

4429

task_context task = {

4430

.func=read_inotify_event,

4431

.epoll_fd=epoll_fd,

4432

.fd=pipefds[0],

4433

.quit_now=&quit_now,

4434

.password=&password,

4435

.filename=strdup("/nonexistent"),

4436

.cancelled_filenames=&cancelled_filenames,

4437

.current_time=&current_time,

4438

.mandos_client_exited=&mandos_client_exited,

4439

.password_is_read=&password_is_read,

4440

};

4441

task.func(task, queue);

4442

g_assert_false(quit_now);

4443

g_assert_true(queue->next_run == 0);

4444

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

4445

4446

g_assert_nonnull(find_matching_task(queue, (task_context){

4447

.func=read_inotify_event,

4448

.epoll_fd=epoll_fd,

4449

.fd=pipefds[0],

4450

.quit_now=&quit_now,

4451

.password=&password,

4452

.filename=task.filename,

4453

.cancelled_filenames=&cancelled_filenames,

4454

.current_time=&current_time,

4455

.mandos_client_exited=&mandos_client_exited,

4456

.password_is_read=&password_is_read,

4457

}));

4458

4459

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4460

EPOLLIN | EPOLLRDHUP));

4461

4462

__attribute__((cleanup(cleanup_string)))

4463

char *filename = NULL;

4464

g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,

4465

dummy_file_name), >, 0);

4466

g_assert_nonnull(filename);

4467

g_assert_true(string_set_contains(*task.cancelled_filenames,

4468

filename));

4469

}

4470

4471

static void

4472

test_read_inotify_event_IN_CLOSE_WRITE_badname(__attribute__((unused))

4473

test_fixture *fixture,

4474

__attribute__((unused))

4475

gconstpointer

4476

user_data){

4477

__attribute__((cleanup(cleanup_close)))

4478

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4479

g_assert_cmpint(epoll_fd, >=, 0);

4480

const mono_microsecs current_time = 0;

4481

4482

int pipefds[2];

4483

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

4484

4485

/* "sufficient to read at least one event." - inotify(7) */

4486

const size_t ievent_max_size = (sizeof(struct inotify_event)

4487

+ NAME_MAX + 1);

4488

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4489

struct {

4490

struct inotify_event event;

4491

char name_buffer[NAME_MAX + 1];

4492

} ievent_buffer;

4493

struct inotify_event *const ievent = &ievent_buffer.event;

4494

4495

const char dummy_file_name[] = "ignored.dummy_file_name";

4496

ievent->mask = IN_CLOSE_WRITE;

4497

ievent->len = sizeof(dummy_file_name);

4498

memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));

4499

const size_t ievent_size = (sizeof(struct inotify_event)

4500

+ sizeof(dummy_file_name));

4501

g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),

4502

==, ievent_size);

4503

g_assert_cmpint(close(pipefds[1]), ==, 0);

4504

4505

bool quit_now = false;

4506

buffer password = {};

4507

bool mandos_client_exited = false;

4508

bool password_is_read = false;

4509

__attribute__((cleanup(cleanup_queue)))

4510

task_queue *queue = create_queue();

4511

g_assert_nonnull(queue);

4512

4513

task_context task = {

4514

.func=read_inotify_event,

4515

.epoll_fd=epoll_fd,

4516

.fd=pipefds[0],

4517

.quit_now=&quit_now,

4518

.password=&password,

4519

.filename=strdup("/nonexistent"),

4520

.cancelled_filenames = &(string_set){},

4521

.notafter=0,

4522

.current_time=&current_time,

4523

.mandos_client_exited=&mandos_client_exited,

4524

.password_is_read=&password_is_read,

4525

};

4526

task.func(task, queue);

4527

g_assert_false(quit_now);

4528

g_assert_true(queue->next_run == 0);

4529

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

4530

4531

g_assert_nonnull(find_matching_task(queue, (task_context){

4532

.func=read_inotify_event,

4533

.epoll_fd=epoll_fd,

4534

.fd=pipefds[0],

4535

.quit_now=&quit_now,

4536

.password=&password,

4537

.filename=task.filename,

4538

.cancelled_filenames=task.cancelled_filenames,

4539

.current_time=&current_time,

4540

.mandos_client_exited=&mandos_client_exited,

4541

.password_is_read=&password_is_read,

4542

}));

4543

4544

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4545

EPOLLIN | EPOLLRDHUP));

4546

}

4547

4548

static void

4549

test_read_inotify_event_IN_MOVED_TO_badname(__attribute__((unused))

4550

test_fixture *fixture,

4551

__attribute__((unused))

4552

gconstpointer user_data){

4553

__attribute__((cleanup(cleanup_close)))

4554

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4555

g_assert_cmpint(epoll_fd, >=, 0);

4556

const mono_microsecs current_time = 0;

4557

4558

int pipefds[2];

4559

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

4560

4561

/* "sufficient to read at least one event." - inotify(7) */

4562

const size_t ievent_max_size = (sizeof(struct inotify_event)

4563

+ NAME_MAX + 1);

4564

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4565

struct {

4566

struct inotify_event event;

4567

char name_buffer[NAME_MAX + 1];

4568

} ievent_buffer;

4569

struct inotify_event *const ievent = &ievent_buffer.event;

4570

4571

const char dummy_file_name[] = "ignored.dummy_file_name";

4572

ievent->mask = IN_MOVED_TO;

4573

ievent->len = sizeof(dummy_file_name);

4574

memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));

4575

const size_t ievent_size = (sizeof(struct inotify_event)

4576

+ sizeof(dummy_file_name));

4577

g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),

4578

==, ievent_size);

4579

g_assert_cmpint(close(pipefds[1]), ==, 0);

4580

4581

bool quit_now = false;

4582

buffer password = {};

4583

bool mandos_client_exited = false;

4584

bool password_is_read = false;

4585

__attribute__((cleanup(cleanup_queue)))

4586

task_queue *queue = create_queue();

4587

g_assert_nonnull(queue);

4588

4589

task_context task = {

4590

.func=read_inotify_event,

4591

.epoll_fd=epoll_fd,

4592

.fd=pipefds[0],

4593

.quit_now=&quit_now,

4594

.password=&password,

4595

.filename=strdup("/nonexistent"),

4596

.cancelled_filenames = &(string_set){},

4597

.notafter=0,

4598

.current_time=&current_time,

4599

.mandos_client_exited=&mandos_client_exited,

4600

.password_is_read=&password_is_read,

4601

};

4602

task.func(task, queue);

4603

g_assert_false(quit_now);

4604

g_assert_true(queue->next_run == 0);

4605

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

4606

4607

g_assert_nonnull(find_matching_task(queue, (task_context){

4608

.func=read_inotify_event,

4609

.epoll_fd=epoll_fd,

4610

.fd=pipefds[0],

4611

.quit_now=&quit_now,

4612

.password=&password,

4613

.filename=task.filename,

4614

.cancelled_filenames=task.cancelled_filenames,

4615

.current_time=&current_time,

4616

.mandos_client_exited=&mandos_client_exited,

4617

.password_is_read=&password_is_read,

4618

}));

4619

4620

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4621

EPOLLIN | EPOLLRDHUP));

4622

}

4623

4624

static void

4625

test_read_inotify_event_IN_MOVED_FROM_badname(__attribute__((unused))

4626

test_fixture *fixture,

4627

__attribute__((unused))

4628

gconstpointer

4629

user_data){

4630

__attribute__((cleanup(cleanup_close)))

4631

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4632

g_assert_cmpint(epoll_fd, >=, 0);

4633

__attribute__((cleanup(string_set_clear)))

4634

string_set cancelled_filenames = {};

4635

const mono_microsecs current_time = 0;

4636

4637

int pipefds[2];

4638

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

4639

4640

/* "sufficient to read at least one event." - inotify(7) */

4641

const size_t ievent_max_size = (sizeof(struct inotify_event)

4642

+ NAME_MAX + 1);

4643

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4644

struct {

4645

struct inotify_event event;

4646

char name_buffer[NAME_MAX + 1];

4647

} ievent_buffer;

4648

struct inotify_event *const ievent = &ievent_buffer.event;

4649

4650

const char dummy_file_name[] = "ignored.dummy_file_name";

4651

ievent->mask = IN_MOVED_FROM;

4652

ievent->len = sizeof(dummy_file_name);

4653

memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));

4654

const size_t ievent_size = (sizeof(struct inotify_event)

4655

+ sizeof(dummy_file_name));

4656

g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),

4657

==, ievent_size);

4658

g_assert_cmpint(close(pipefds[1]), ==, 0);

4659

4660

bool quit_now = false;

4661

buffer password = {};

4662

bool mandos_client_exited = false;

4663

bool password_is_read = false;

4664

__attribute__((cleanup(cleanup_queue)))

4665

task_queue *queue = create_queue();

4666

g_assert_nonnull(queue);

4667

4668

task_context task = {

4669

.func=read_inotify_event,

4670

.epoll_fd=epoll_fd,

4671

.fd=pipefds[0],

4672

.quit_now=&quit_now,

4673

.password=&password,

4674

.filename=strdup("/nonexistent"),

4675

.cancelled_filenames=&cancelled_filenames,

4676

.current_time=&current_time,

4677

.mandos_client_exited=&mandos_client_exited,

4678

.password_is_read=&password_is_read,

4679

};

4680

task.func(task, queue);

4681

g_assert_false(quit_now);

4682

g_assert_true(queue->next_run == 0);

4683

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

4684

4685

g_assert_nonnull(find_matching_task(queue, (task_context){

4686

.func=read_inotify_event,

4687

.epoll_fd=epoll_fd,

4688

.fd=pipefds[0],

4689

.quit_now=&quit_now,

4690

.password=&password,

4691

.filename=task.filename,

4692

.cancelled_filenames=&cancelled_filenames,

4693

.current_time=&current_time,

4694

.mandos_client_exited=&mandos_client_exited,

4695

.password_is_read=&password_is_read,

4696

}));

4697

4698

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4699

EPOLLIN | EPOLLRDHUP));

4700

4701

__attribute__((cleanup(cleanup_string)))

4702

char *filename = NULL;

4703

g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,

4704

dummy_file_name), >, 0);

4705

g_assert_nonnull(filename);

4706

g_assert_false(string_set_contains(cancelled_filenames, filename));

4707

}

4708

4709

static

4710

void test_read_inotify_event_IN_DELETE_badname(__attribute__((unused))

4711

test_fixture *fixture,

4712

__attribute__((unused))

4713

gconstpointer

4714

user_data){

4715

__attribute__((cleanup(cleanup_close)))

4716

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4717

g_assert_cmpint(epoll_fd, >=, 0);

4718

__attribute__((cleanup(string_set_clear)))

4719

string_set cancelled_filenames = {};

4720

const mono_microsecs current_time = 0;

4721

4722

int pipefds[2];

4723

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

4724

4725

/* "sufficient to read at least one event." - inotify(7) */

4726

const size_t ievent_max_size = (sizeof(struct inotify_event)

4727

+ NAME_MAX + 1);

4728

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4729

struct {

4730

struct inotify_event event;

4731

char name_buffer[NAME_MAX + 1];

4732

} ievent_buffer;

4733

struct inotify_event *const ievent = &ievent_buffer.event;

4734

4735

const char dummy_file_name[] = "ignored.dummy_file_name";

4736

ievent->mask = IN_DELETE;

4737

ievent->len = sizeof(dummy_file_name);

4738

memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));

4739

const size_t ievent_size = (sizeof(struct inotify_event)

4740

+ sizeof(dummy_file_name));

4741

g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),

4742

==, ievent_size);

4743

g_assert_cmpint(close(pipefds[1]), ==, 0);

4744

4745

bool quit_now = false;

4746

buffer password = {};

4747

bool mandos_client_exited = false;

4748

bool password_is_read = false;

4749

__attribute__((cleanup(cleanup_queue)))

4750

task_queue *queue = create_queue();

4751

g_assert_nonnull(queue);

4752

4753

task_context task = {

4754

.func=read_inotify_event,

4755

.epoll_fd=epoll_fd,

4756

.fd=pipefds[0],

4757

.quit_now=&quit_now,

4758

.password=&password,

4759

.filename=strdup("/nonexistent"),

4760

.cancelled_filenames=&cancelled_filenames,

4761

.current_time=&current_time,

4762

.mandos_client_exited=&mandos_client_exited,

4763

.password_is_read=&password_is_read,

4764

};

4765

task.func(task, queue);

4766

g_assert_false(quit_now);

4767

g_assert_true(queue->next_run == 0);

4768

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

4769

4770

g_assert_nonnull(find_matching_task(queue, (task_context){

4771

.func=read_inotify_event,

4772

.epoll_fd=epoll_fd,

4773

.fd=pipefds[0],

4774

.quit_now=&quit_now,

4775

.password=&password,

4776

.filename=task.filename,

4777

.cancelled_filenames=&cancelled_filenames,

4778

.current_time=&current_time,

4779

.mandos_client_exited=&mandos_client_exited,

4780

.password_is_read=&password_is_read,

4781

}));

4782

4783

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4784

EPOLLIN | EPOLLRDHUP));

4785

4786

__attribute__((cleanup(cleanup_string)))

4787

char *filename = NULL;

4788

g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,

4789

dummy_file_name), >, 0);

4790

g_assert_nonnull(filename);

4791

g_assert_false(string_set_contains(cancelled_filenames, filename));

4792

}

4793

4794

static

4795

void test_open_and_parse_question_ENOENT(__attribute__((unused))

4796

test_fixture *fixture,

4797

__attribute__((unused))

4798

gconstpointer user_data){

4799

__attribute__((cleanup(cleanup_close)))

4800

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4801

g_assert_cmpint(epoll_fd, >=, 0);

4802

__attribute__((cleanup(string_set_clear)))

4803

string_set cancelled_filenames = {};

4804

bool mandos_client_exited = false;

4805

bool password_is_read = false;

4806

__attribute__((cleanup(cleanup_queue)))

4807

task_queue *queue = create_queue();

4808

g_assert_nonnull(queue);

4809

4810

char *const filename = strdup("/nonexistent");

4811

g_assert_nonnull(filename);

4812

task_context task = {

4813

.func=open_and_parse_question,

4814

.question_filename=filename,

4815

.epoll_fd=epoll_fd,

4816

.password=(buffer[]){{}},

4817

.filename=filename,

4818

.cancelled_filenames=&cancelled_filenames,

4819

.current_time=(mono_microsecs[]){0},

4820

.mandos_client_exited=&mandos_client_exited,

4821

.password_is_read=&password_is_read,

4822

};

4823

task.func(task, queue);

4824

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4825

}

4826

4827

static void test_open_and_parse_question_EIO(__attribute__((unused))

4828

test_fixture *fixture,

4829

__attribute__((unused))

4830

gconstpointer user_data){

4831

__attribute__((cleanup(cleanup_close)))

4832

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4833

g_assert_cmpint(epoll_fd, >=, 0);

4834

__attribute__((cleanup(string_set_clear)))

4835

string_set cancelled_filenames = {};

4836

buffer password = {};

4837

bool mandos_client_exited = false;

4838

bool password_is_read = false;

4839

__attribute__((cleanup(cleanup_queue)))

4840

task_queue *queue = create_queue();

4841

g_assert_nonnull(queue);

4842

const mono_microsecs current_time = 0;

4843

4844

char *filename = strdup("/proc/self/mem");

4845

task_context task = {

4846

.func=open_and_parse_question,

4847

.question_filename=filename,

4848

.epoll_fd=epoll_fd,

4849

.password=&password,

4850

.filename=filename,

4851

.cancelled_filenames=&cancelled_filenames,

4852

.current_time=&current_time,

4853

.mandos_client_exited=&mandos_client_exited,

4854

.password_is_read=&password_is_read,

4855

};

4856

run_task_with_stderr_to_dev_null(task, queue);

4857

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4858

}

4859

4860

static void

4861

test_open_and_parse_question_parse_error(__attribute__((unused))

4862

test_fixture *fixture,

4863

__attribute__((unused))

4864

gconstpointer user_data){

4865

__attribute__((cleanup(cleanup_close)))

4866

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4867

g_assert_cmpint(epoll_fd, >=, 0);

4868

__attribute__((cleanup(string_set_clear)))

4869

string_set cancelled_filenames = {};

4870

__attribute__((cleanup(cleanup_queue)))

4871

task_queue *queue = create_queue();

4872

g_assert_nonnull(queue);

4873

4874

__attribute__((cleanup(cleanup_string)))

4875

char *tempfilename = strdup("/tmp/mandosXXXXXX");

4876

g_assert_nonnull(tempfilename);

4877

int tempfile = mkostemp(tempfilename, O_CLOEXEC);

4878

g_assert_cmpint(tempfile, >, 0);

4879

const char bad_data[] = "this is bad syntax\n";

4880

g_assert_cmpint(write(tempfile, bad_data, sizeof(bad_data)),

4881

==, sizeof(bad_data));

4882

g_assert_cmpint(close(tempfile), ==, 0);

4883

4884

char *const filename = strdup(tempfilename);

4885

g_assert_nonnull(filename);

4886

task_context task = {

4887

.func=open_and_parse_question,

4888

.question_filename=filename,

4889

.epoll_fd=epoll_fd,

4890

.password=(buffer[]){{}},

4891

.filename=filename,

4892

.cancelled_filenames=&cancelled_filenames,

4893

.current_time=(mono_microsecs[]){0},

4894

.mandos_client_exited=(bool[]){false},

4895

.password_is_read=(bool[]){false},

4896

};

4897

run_task_with_stderr_to_dev_null(task, queue);

4898

4899

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4900

4901

g_assert_cmpint(unlink(tempfilename), ==, 0);

4902

}

4903

4904

static

4905

void test_open_and_parse_question_nosocket(__attribute__((unused))

4906

test_fixture *fixture,

4907

__attribute__((unused))

4908

gconstpointer user_data){

4909

__attribute__((cleanup(cleanup_close)))

4910

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4911

g_assert_cmpint(epoll_fd, >=, 0);

4912

__attribute__((cleanup(string_set_clear)))

4913

string_set cancelled_filenames = {};

4914

__attribute__((cleanup(cleanup_queue)))

4915

task_queue *queue = create_queue();

4916

g_assert_nonnull(queue);

4917

4918

__attribute__((cleanup(cleanup_string)))

4919

char *tempfilename = strdup("/tmp/mandosXXXXXX");

4920

g_assert_nonnull(tempfilename);

4921

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4922

g_assert_cmpint(questionfile, >, 0);

4923

FILE *qf = fdopen(questionfile, "w");

4924

g_assert_cmpint(fprintf(qf, "[Ask]\nPID=1\n"), >, 0);

4925

g_assert_cmpint(fclose(qf), ==, 0);

4926

4927

char *const filename = strdup(tempfilename);

4928

g_assert_nonnull(filename);

4929

task_context task = {

4930

.func=open_and_parse_question,

4931

.question_filename=filename,

4932

.epoll_fd=epoll_fd,

4933

.password=(buffer[]){{}},

4934

.filename=filename,

4935

.cancelled_filenames=&cancelled_filenames,

4936

.current_time=(mono_microsecs[]){0},

4937

.mandos_client_exited=(bool[]){false},

4938

.password_is_read=(bool[]){false},

4939

};

4940

run_task_with_stderr_to_dev_null(task, queue);

4941

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4942

4943

g_assert_cmpint(unlink(tempfilename), ==, 0);

4944

}

4945

4946

static

4947

void test_open_and_parse_question_badsocket(__attribute__((unused))

4948

test_fixture *fixture,

4949

__attribute__((unused))

4950

gconstpointer user_data){

4951

__attribute__((cleanup(cleanup_close)))

4952

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4953

g_assert_cmpint(epoll_fd, >=, 0);

4954

__attribute__((cleanup(string_set_clear)))

4955

string_set cancelled_filenames = {};

4956

__attribute__((cleanup(cleanup_queue)))

4957

task_queue *queue = create_queue();

4958

g_assert_nonnull(queue);

4959

4960

__attribute__((cleanup(cleanup_string)))

4961

char *tempfilename = strdup("/tmp/mandosXXXXXX");

4962

g_assert_nonnull(tempfilename);

4963

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4964

g_assert_cmpint(questionfile, >, 0);

4965

FILE *qf = fdopen(questionfile, "w");

4966

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=\nPID=1\n"), >, 0);

4967

g_assert_cmpint(fclose(qf), ==, 0);

4968

4969

char *const filename = strdup(tempfilename);

4970

g_assert_nonnull(filename);

4971

task_context task = {

4972

.func=open_and_parse_question,

4973

.question_filename=filename,

4974

.epoll_fd=epoll_fd,

4975

.password=(buffer[]){{}},

4976

.filename=filename,

4977

.cancelled_filenames=&cancelled_filenames,

4978

.current_time=(mono_microsecs[]){0},

4979

.mandos_client_exited=(bool[]){false},

4980

.password_is_read=(bool[]){false},

4981

};

4982

run_task_with_stderr_to_dev_null(task, queue);

4983

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4984

4985

g_assert_cmpint(unlink(tempfilename), ==, 0);

4986

}

4987

4988

static

4989

void test_open_and_parse_question_nopid(__attribute__((unused))

4990

test_fixture *fixture,

4991

__attribute__((unused))

4992

gconstpointer user_data){

4993

__attribute__((cleanup(cleanup_close)))

4994

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4995

g_assert_cmpint(epoll_fd, >=, 0);

4996

__attribute__((cleanup(string_set_clear)))

4997

string_set cancelled_filenames = {};

4998

__attribute__((cleanup(cleanup_queue)))

4999

task_queue *queue = create_queue();

5000

g_assert_nonnull(queue);

5001

5002

__attribute__((cleanup(cleanup_string)))

5003

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5004

g_assert_nonnull(tempfilename);

5005

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5006

g_assert_cmpint(questionfile, >, 0);

5007

FILE *qf = fdopen(questionfile, "w");

5008

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\n"), >, 0);

5009

g_assert_cmpint(fclose(qf), ==, 0);

5010

5011

char *const filename = strdup(tempfilename);

5012

g_assert_nonnull(filename);

5013

task_context task = {

5014

.func=open_and_parse_question,

5015

.question_filename=filename,

5016

.epoll_fd=epoll_fd,

5017

.password=(buffer[]){{}},

5018

.filename=filename,

5019

.cancelled_filenames=&cancelled_filenames,

5020

.current_time=(mono_microsecs[]){0},

5021

.mandos_client_exited=(bool[]){false},

5022

.password_is_read=(bool[]){false},

5023

};

5024

run_task_with_stderr_to_dev_null(task, queue);

5025

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5026

5027

g_assert_cmpint(unlink(tempfilename), ==, 0);

5028

}

5029

5030

static

5031

void test_open_and_parse_question_badpid(__attribute__((unused))

5032

test_fixture *fixture,

5033

__attribute__((unused))

5034

gconstpointer user_data){

5035

__attribute__((cleanup(cleanup_close)))

5036

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5037

g_assert_cmpint(epoll_fd, >=, 0);

5038

__attribute__((cleanup(string_set_clear)))

5039

string_set cancelled_filenames = {};

5040

__attribute__((cleanup(cleanup_queue)))

5041

task_queue *queue = create_queue();

5042

g_assert_nonnull(queue);

5043

5044

__attribute__((cleanup(cleanup_string)))

5045

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5046

g_assert_nonnull(tempfilename);

5047

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5048

g_assert_cmpint(questionfile, >, 0);

5049

FILE *qf = fdopen(questionfile, "w");

5050

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=\n"),

5051

>, 0);

5052

g_assert_cmpint(fclose(qf), ==, 0);

5053

5054

char *const filename = strdup(tempfilename);

5055

g_assert_nonnull(filename);

5056

task_context task = {

5057

.func=open_and_parse_question,

5058

.question_filename=filename,

5059

.epoll_fd=epoll_fd,

5060

.password=(buffer[]){{}},

5061

.filename=filename,

5062

.cancelled_filenames=&cancelled_filenames,

5063

.current_time=(mono_microsecs[]){0},

5064

.mandos_client_exited=(bool[]){false},

5065

.password_is_read=(bool[]){false},

5066

};

5067

run_task_with_stderr_to_dev_null(task, queue);

5068

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5069

5070

g_assert_cmpint(unlink(tempfilename), ==, 0);

5071

}

5072

5073

static void

5074

test_open_and_parse_question_noexist_pid(__attribute__((unused))

5075

test_fixture *fixture,

5076

__attribute__((unused))

5077

gconstpointer user_data){

5078

__attribute__((cleanup(cleanup_close)))

5079

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5080

g_assert_cmpint(epoll_fd, >=, 0);

5081

__attribute__((cleanup(string_set_clear)))

5082

string_set cancelled_filenames = {};

5083

buffer password = {};

5084

bool mandos_client_exited = false;

5085

bool password_is_read = false;

5086

__attribute__((cleanup(cleanup_queue)))

5087

task_queue *queue = create_queue();

5088

g_assert_nonnull(queue);

5089

const mono_microsecs current_time = 0;

5090

5091

/* Find value of sysctl kernel.pid_max */

5092

uintmax_t pid_max = 0;

5093

FILE *sysctl_pid_max = fopen("/proc/sys/kernel/pid_max", "r");

5094

g_assert_nonnull(sysctl_pid_max);

5095

g_assert_cmpint(fscanf(sysctl_pid_max, "%" PRIuMAX, &pid_max),

5096

==, 1);

5097

g_assert_cmpint(fclose(sysctl_pid_max), ==, 0);

5098

5099

pid_t nonexisting_pid = ((pid_t)pid_max)+1;

5100

g_assert_true(nonexisting_pid > 0); /* Overflow check */

5101

5102

__attribute__((cleanup(cleanup_string)))

5103

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5104

g_assert_nonnull(tempfilename);

5105

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5106

g_assert_cmpint(questionfile, >, 0);

5107

FILE *qf = fdopen(questionfile, "w");

5108

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5109

PRIuMAX"\n", (uintmax_t)nonexisting_pid),

5110

>, 0);

5111

g_assert_cmpint(fclose(qf), ==, 0);

5112

5113

char *const question_filename = strdup(tempfilename);

5114

g_assert_nonnull(question_filename);

5115

task_context task = {

5116

.func=open_and_parse_question,

5117

.question_filename=question_filename,

5118

.epoll_fd=epoll_fd,

5119

.password=&password,

5120

.filename=question_filename,

5121

.cancelled_filenames=&cancelled_filenames,

5122

.current_time=&current_time,

5123

.mandos_client_exited=&mandos_client_exited,

5124

.password_is_read=&password_is_read,

5125

};

5126

run_task_with_stderr_to_dev_null(task, queue);

5127

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5128

5129

g_assert_cmpint(unlink(tempfilename), ==, 0);

5130

}

5131

5132

static void

5133

test_open_and_parse_question_no_notafter(__attribute__((unused))

5134

test_fixture *fixture,

5135

__attribute__((unused))

5136

gconstpointer user_data){

5137

__attribute__((cleanup(cleanup_close)))

5138

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5139

g_assert_cmpint(epoll_fd, >=, 0);

5140

__attribute__((cleanup(string_set_clear)))

5141

string_set cancelled_filenames = {};

5142

buffer password = {};

5143

bool mandos_client_exited = false;

5144

bool password_is_read = false;

5145

__attribute__((cleanup(cleanup_queue)))

5146

task_queue *queue = create_queue();

5147

g_assert_nonnull(queue);

5148

const mono_microsecs current_time = 0;

5149

5150

__attribute__((cleanup(cleanup_string)))

5151

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5152

g_assert_nonnull(tempfilename);

5153

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5154

g_assert_cmpint(questionfile, >, 0);

5155

FILE *qf = fdopen(questionfile, "w");

5156

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5157

PRIuMAX "\n", (uintmax_t)getpid()), >, 0);

5158

g_assert_cmpint(fclose(qf), ==, 0);

5159

5160

char *const filename = strdup(tempfilename);

5161

g_assert_nonnull(filename);

5162

task_context task = {

5163

.func=open_and_parse_question,

5164

.question_filename=filename,

5165

.epoll_fd=epoll_fd,

5166

.password=&password,

5167

.filename=filename,

5168

.cancelled_filenames=&cancelled_filenames,

5169

.current_time=&current_time,

5170

.mandos_client_exited=&mandos_client_exited,

5171

.password_is_read=&password_is_read,

5172

};

5173

task.func(task, queue);

5174

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5175

5176

__attribute__((cleanup(cleanup_string)))

5177

char *socket_filename = strdup("/nonexistent");

5178

g_assert_nonnull(socket_filename);

5179

g_assert_nonnull(find_matching_task(queue, (task_context){

5180

.func=connect_question_socket,

5181

.question_filename=tempfilename,

5182

.filename=socket_filename,

5183

.epoll_fd=epoll_fd,

5184

.password=&password,

5185

.current_time=&current_time,

5186

.mandos_client_exited=&mandos_client_exited,

5187

.password_is_read=&password_is_read,

5188

}));

5189

5190

g_assert_true(queue->next_run != 0);

5191

5192

g_assert_cmpint(unlink(tempfilename), ==, 0);

5193

}

5194

5195

static void

5196

test_open_and_parse_question_bad_notafter(__attribute__((unused))

5197

test_fixture *fixture,

5198

__attribute__((unused))

5199

gconstpointer user_data){

5200

__attribute__((cleanup(cleanup_close)))

5201

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5202

g_assert_cmpint(epoll_fd, >=, 0);

5203

__attribute__((cleanup(string_set_clear)))

5204

string_set cancelled_filenames = {};

5205

buffer password = {};

5206

bool mandos_client_exited = false;

5207

bool password_is_read = false;

5208

__attribute__((cleanup(cleanup_queue)))

5209

task_queue *queue = create_queue();

5210

g_assert_nonnull(queue);

5211

const mono_microsecs current_time = 0;

5212

5213

__attribute__((cleanup(cleanup_string)))

5214

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5215

g_assert_nonnull(tempfilename);

5216

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5217

g_assert_cmpint(questionfile, >, 0);

5218

FILE *qf = fdopen(questionfile, "w");

5219

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5220

PRIuMAX "\nNotAfter=\n",

5221

(uintmax_t)getpid()), >, 0);

5222

g_assert_cmpint(fclose(qf), ==, 0);

5223

5224

char *const filename = strdup(tempfilename);

5225

g_assert_nonnull(filename);

5226

task_context task = {

5227

.func=open_and_parse_question,

5228

.question_filename=filename,

5229

.epoll_fd=epoll_fd,

5230

.password=&password,

5231

.filename=filename,

5232

.cancelled_filenames=&cancelled_filenames,

5233

.current_time=&current_time,

5234

.mandos_client_exited=&mandos_client_exited,

5235

.password_is_read=&password_is_read,

5236

};

5237

run_task_with_stderr_to_dev_null(task, queue);

5238

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5239

5240

__attribute__((cleanup(cleanup_string)))

5241

char *socket_filename = strdup("/nonexistent");

5242

g_assert_nonnull(find_matching_task(queue, (task_context){

5243

.func=connect_question_socket,

5244

.question_filename=tempfilename,

5245

.filename=socket_filename,

5246

.epoll_fd=epoll_fd,

5247

.password=&password,

5248

.current_time=&current_time,

5249

.mandos_client_exited=&mandos_client_exited,

5250

.password_is_read=&password_is_read,

5251

}));

5252

g_assert_true(queue->next_run != 0);

5253

5254

g_assert_cmpint(unlink(tempfilename), ==, 0);

5255

}

5256

5257

static

5258

void assert_open_and_parse_question_with_notafter(const mono_microsecs

5259

current_time,

5260

const mono_microsecs

5261

notafter,

5262

const mono_microsecs

5263

next_queue_run){

5264

__attribute__((cleanup(cleanup_close)))

5265

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5266

g_assert_cmpint(epoll_fd, >=, 0);

5267

__attribute__((cleanup(string_set_clear)))

5268

string_set cancelled_filenames = {};

5269

buffer password = {};

5270

bool mandos_client_exited = false;

5271

bool password_is_read = false;

5272

__attribute__((cleanup(cleanup_queue)))

5273

task_queue *queue = create_queue();

5274

g_assert_nonnull(queue);

5275

queue->next_run = next_queue_run;

5276

5277

__attribute__((cleanup(cleanup_string)))

5278

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5279

g_assert_nonnull(tempfilename);

5280

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5281

g_assert_cmpint(questionfile, >, 0);

5282

FILE *qf = fdopen(questionfile, "w");

5283

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5284

PRIuMAX "\nNotAfter=%" PRIuMAX "\n",

5285

(uintmax_t)getpid(), notafter), >, 0);

5286

g_assert_cmpint(fclose(qf), ==, 0);

5287

5288

char *const filename = strdup(tempfilename);

5289

g_assert_nonnull(filename);

5290

task_context task = {

5291

.func=open_and_parse_question,

5292

.question_filename=filename,

5293

.epoll_fd=epoll_fd,

5294

.password=&password,

5295

.filename=filename,

5296

.cancelled_filenames=&cancelled_filenames,

5297

.current_time=&current_time,

5298

.mandos_client_exited=&mandos_client_exited,

5299

.password_is_read=&password_is_read,

5300

};

5301

task.func(task, queue);

5302

5303

if(queue->length >= 1){

5304

__attribute__((cleanup(cleanup_string)))

5305

char *socket_filename = strdup("/nonexistent");

5306

g_assert_nonnull(find_matching_task(queue, (task_context){

5307

.func=connect_question_socket,

5308

.filename=socket_filename,

5309

.epoll_fd=epoll_fd,

5310

.password=&password,

5311

.current_time=&current_time,

5312

.cancelled_filenames=&cancelled_filenames,

5313

.mandos_client_exited=&mandos_client_exited,

5314

.password_is_read=&password_is_read,

5315

}));

5316

g_assert_true(queue->next_run != 0);

5317

}

5318

5319

if(notafter == 0){

5320

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5321

} else if(current_time >= notafter) {

5322

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5323

} else {

5324

g_assert_nonnull(find_matching_task(queue, (task_context){

5325

.func=cancel_old_question,

5326

.question_filename=tempfilename,

5327

.filename=tempfilename,

5328

.notafter=notafter,

5329

.cancelled_filenames=&cancelled_filenames,

5330

.current_time=&current_time,

5331

}));

5332

}

5333

g_assert_true(queue->next_run == 1);

5334

5335

g_assert_cmpint(unlink(tempfilename), ==, 0);

5336

}

5337

5338

static void

5339

test_open_and_parse_question_notafter_0(__attribute__((unused))

5340

test_fixture *fixture,

5341

__attribute__((unused))

5342

gconstpointer user_data){

5343

/* current_time, notafter, next_queue_run */

5344

assert_open_and_parse_question_with_notafter(0, 0, 0);

5345

}

5346

5347

static void

5348

test_open_and_parse_question_notafter_1(__attribute__((unused))

5349

test_fixture *fixture,

5350

__attribute__((unused))

5351

gconstpointer user_data){

5352

/* current_time, notafter, next_queue_run */

5353

assert_open_and_parse_question_with_notafter(0, 1, 0);

5354

}

5355

5356

static void

5357

test_open_and_parse_question_notafter_1_1(__attribute__((unused))

5358

test_fixture *fixture,

5359

__attribute__((unused))

5360

gconstpointer user_data){

5361

/* current_time, notafter, next_queue_run */

5362

assert_open_and_parse_question_with_notafter(0, 1, 1);

5363

}

5364

5365

static void

5366

test_open_and_parse_question_notafter_1_2(__attribute__((unused))

5367

test_fixture *fixture,

5368

__attribute__((unused))

5369

gconstpointer user_data){

5370

/* current_time, notafter, next_queue_run */

5371

assert_open_and_parse_question_with_notafter(0, 1, 2);

5372

}

5373

5374

static void

5375

test_open_and_parse_question_equal_notafter(__attribute__((unused))

5376

test_fixture *fixture,

5377

__attribute__((unused))

5378

gconstpointer user_data){

5379

/* current_time, notafter, next_queue_run */

5380

assert_open_and_parse_question_with_notafter(1, 1, 0);

5381

}

5382

5383

static void

5384

test_open_and_parse_question_late_notafter(__attribute__((unused))

5385

test_fixture *fixture,

5386

__attribute__((unused))

5387

gconstpointer user_data){

5388

/* current_time, notafter, next_queue_run */

5389

assert_open_and_parse_question_with_notafter(2, 1, 0);

5390

}

5391

5392

static void assert_cancel_old_question_param(const mono_microsecs

5393

next_queue_run,

5394

const mono_microsecs

5395

notafter,

5396

const mono_microsecs

5397

current_time,

5398

const mono_microsecs

5399

next_set_to){

5400

__attribute__((cleanup(string_set_clear)))

5401

string_set cancelled_filenames = {};

5402

__attribute__((cleanup(cleanup_queue)))

5403

task_queue *queue = create_queue();

5404

g_assert_nonnull(queue);

5405

queue->next_run = next_queue_run;

5406

5407

char *const question_filename = strdup("/nonexistent");

5408

g_assert_nonnull(question_filename);

5409

task_context task = {

5410

.func=cancel_old_question,

5411

.question_filename=question_filename,

5412

.filename=question_filename,

5413

.notafter=notafter,

5414

.cancelled_filenames=&cancelled_filenames,

5415

.current_time=&current_time,

5416

};

5417

task.func(task, queue);

5418

5419

if(current_time >= notafter){

5420

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5421

g_assert_true(string_set_contains(cancelled_filenames,

5422

"/nonexistent"));

5423

} else {

5424

g_assert_nonnull(find_matching_task(queue, (task_context){

5425

.func=cancel_old_question,

5426

.question_filename=question_filename,

5427

.filename=question_filename,

5428

.notafter=notafter,

5429

.cancelled_filenames=&cancelled_filenames,

5430

.current_time=&current_time,

5431

}));

5432

5433

g_assert_false(string_set_contains(cancelled_filenames,

5434

question_filename));

5435

}

5436

g_assert_cmpuint((unsigned int)queue->next_run, ==,

5437

(unsigned int)next_set_to);

5438

}

5439

5440

static void test_cancel_old_question_0_1_2(__attribute__((unused))

5441

test_fixture *fixture,

5442

__attribute__((unused))

5443

gconstpointer user_data){

5444

/* next_queue_run unset,

5445

cancellation should happen because time has come,

5446

next_queue_run should be unchanged */

5447

/* next_queue_run, notafter, current_time, next_set_to */

5448

assert_cancel_old_question_param(0, 1, 2, 0);

5449

}

5450

5451

static void test_cancel_old_question_0_2_1(__attribute__((unused))

5452

test_fixture *fixture,

5453

__attribute__((unused))

5454

gconstpointer user_data){

5455

/* If next_queue_run is 0, meaning unset, and notafter is 2,

5456

and current_time is not yet notafter or greater,

5457

update value of next_queue_run to value of notafter */

5458

/* next_queue_run, notafter, current_time, next_set_to */

5459

assert_cancel_old_question_param(0, 2, 1, 2);

5460

}

5461

5462

static void test_cancel_old_question_1_2_3(__attribute__((unused))

5463

test_fixture *fixture,

5464

__attribute__((unused))

5465

gconstpointer user_data){

5466

/* next_queue_run 1,

5467

cancellation should happen because time has come,

5468

next_queue_run should be unchanged */

5469

/* next_queue_run, notafter, current_time, next_set_to */

5470

assert_cancel_old_question_param(1, 2, 3, 1);

5471

}

5472

5473

static void test_cancel_old_question_1_3_2(__attribute__((unused))

5474

test_fixture *fixture,

5475

__attribute__((unused))

5476

gconstpointer user_data){

5477

/* If next_queue_run is set,

5478

and current_time is not yet notafter or greater,

5479

and notafter is larger than next_queue_run

5480

next_queue_run should be unchanged */

5481

/* next_queue_run, notafter, current_time, next_set_to */

5482

assert_cancel_old_question_param(1, 3, 2, 1);

5483

}

5484

5485

static void test_cancel_old_question_2_1_3(__attribute__((unused))

5486

test_fixture *fixture,

5487

__attribute__((unused))

5488

gconstpointer user_data){

5489

/* next_queue_run 2,

5490

cancellation should happen because time has come,

5491

next_queue_run should be unchanged */

5492

/* next_queue_run, notafter, current_time, next_set_to */

5493

assert_cancel_old_question_param(2, 1, 3, 2);

5494

}

5495

5496

static void test_cancel_old_question_2_3_1(__attribute__((unused))

5497

test_fixture *fixture,

5498

__attribute__((unused))

5499

gconstpointer user_data){

5500

/* If next_queue_run is set,

5501

and current_time is not yet notafter or greater,

5502

and notafter is larger than next_queue_run

5503

next_queue_run should be unchanged */

5504

/* next_queue_run, notafter, current_time, next_set_to */

5505

assert_cancel_old_question_param(2, 3, 1, 2);

5506

}

5507

5508

static void test_cancel_old_question_3_1_2(__attribute__((unused))

5509

test_fixture *fixture,

5510

__attribute__((unused))

5511

gconstpointer user_data){

5512

/* next_queue_run 3,

5513

cancellation should happen because time has come,

5514

next_queue_run should be unchanged */

5515

/* next_queue_run, notafter, current_time, next_set_to */

5516

assert_cancel_old_question_param(3, 1, 2, 3);

5517

}

5518

5519

static void test_cancel_old_question_3_2_1(__attribute__((unused))

5520

test_fixture *fixture,

5521

__attribute__((unused))

5522

gconstpointer user_data){

5523

/* If next_queue_run is set,

5524

and current_time is not yet notafter or greater,

5525

and notafter is smaller than next_queue_run

5526

update value of next_queue_run to value of notafter */

5527

/* next_queue_run, notafter, current_time, next_set_to */

5528

assert_cancel_old_question_param(3, 2, 1, 2);

5529

}

5530

5531

static void

5532

test_connect_question_socket_name_too_long(__attribute__((unused))

5533

test_fixture *fixture,

5534

__attribute__((unused))

5535

gconstpointer user_data){

5536

__attribute__((cleanup(cleanup_close)))

5537

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5538

g_assert_cmpint(epoll_fd, >=, 0);

5539

const char question_filename[] = "/nonexistent/question";

5540

__attribute__((cleanup(string_set_clear)))

5541

string_set cancelled_filenames = {};

5542

__attribute__((cleanup(cleanup_queue)))

5543

task_queue *queue = create_queue();

5544

g_assert_nonnull(queue);

5545

__attribute__((cleanup(cleanup_string)))

5546

char *tempdir = make_temporary_directory();

5547

g_assert_nonnull(tempdir);

5548

struct sockaddr_un unix_socket = { .sun_family=AF_LOCAL };

5549

char socket_name[sizeof(unix_socket.sun_path)];

5550

memset(socket_name, 'x', sizeof(socket_name));

5551

socket_name[sizeof(socket_name)-1] = '\0';

5552

char *filename = NULL;

5553

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5554

>, 0);

5555

g_assert_nonnull(filename);

5556

5557

task_context task = {

5558

.func=connect_question_socket,

5559

.question_filename=strdup(question_filename),

5560

.epoll_fd=epoll_fd,

5561

.password=(buffer[]){{}},

5562

.filename=filename,

5563

.cancelled_filenames=&cancelled_filenames,

5564

.mandos_client_exited=(bool[]){false},

5565

.password_is_read=(bool[]){false},

5566

.current_time=(mono_microsecs[]){0},

5567

};

5568

g_assert_nonnull(task.question_filename);

5569

run_task_with_stderr_to_dev_null(task, queue);

5570

5571

g_assert_true(string_set_contains(cancelled_filenames,

5572

question_filename));

5573

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5574

g_assert_true(queue->next_run == 0);

5575

5576

g_assert_cmpint(rmdir(tempdir), ==, 0);

5577

}

5578

5579

static

5580

void test_connect_question_socket_connect_fail(__attribute__((unused))

5581

test_fixture *fixture,

5582

__attribute__((unused))

5583

gconstpointer

5584

user_data){

5585

__attribute__((cleanup(cleanup_close)))

5586

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5587

g_assert_cmpint(epoll_fd, >=, 0);

5588

const char question_filename[] = "/nonexistent/question";

5589

__attribute__((cleanup(string_set_clear)))

5590

string_set cancelled_filenames = {};

5591

const mono_microsecs current_time = 3;

5592

__attribute__((cleanup(cleanup_queue)))

5593

task_queue *queue = create_queue();

5594

g_assert_nonnull(queue);

5595

__attribute__((cleanup(cleanup_string)))

5596

char *tempdir = make_temporary_directory();

5597

g_assert_nonnull(tempdir);

5598

char socket_name[] = "nonexistent";

5599

char *filename = NULL;

5600

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5601

>, 0);

5602

g_assert_nonnull(filename);

5603

5604

task_context task = {

5605

.func=connect_question_socket,

5606

.question_filename=strdup(question_filename),

5607

.epoll_fd=epoll_fd,

5608

.password=(buffer[]){{}},

5609

.filename=filename,

5610

.cancelled_filenames=&cancelled_filenames,

5611

.mandos_client_exited=(bool[]){false},

5612

.password_is_read=(bool[]){false},

5613

.current_time=&current_time,

5614

};

5615

g_assert_nonnull(task.question_filename);

5616

run_task_with_stderr_to_dev_null(task, queue);

5617

5618

g_assert_nonnull(find_matching_task(queue, task));

5619

5620

g_assert_false(string_set_contains(cancelled_filenames,

5621

question_filename));

5622

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5623

g_assert_true(queue->next_run == 1000000 + current_time);

5624

5625

g_assert_cmpint(rmdir(tempdir), ==, 0);

5626

}

5627

5628

static

5629

void test_connect_question_socket_bad_epoll(__attribute__((unused))

5630

test_fixture *fixture,

5631

__attribute__((unused))

5632

gconstpointer user_data){

5633

__attribute__((cleanup(cleanup_close)))

5634

const int epoll_fd = open("/dev/null",

5635

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5636

__attribute__((cleanup(cleanup_string)))

5637

char *const question_filename = strdup("/nonexistent/question");

5638

g_assert_nonnull(question_filename);

5639

__attribute__((cleanup(string_set_clear)))

5640

string_set cancelled_filenames = {};

5641

const mono_microsecs current_time = 5;

5642

__attribute__((cleanup(cleanup_queue)))

5643

task_queue *queue = create_queue();

5644

g_assert_nonnull(queue);

5645

__attribute__((cleanup(cleanup_string)))

5646

char *tempdir = make_temporary_directory();

5647

g_assert_nonnull(tempdir);

5648

__attribute__((cleanup(cleanup_close)))

5649

const int sock_fd = socket(PF_LOCAL, SOCK_DGRAM

5650

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

5651

g_assert_cmpint(sock_fd, >=, 0);

5652

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

5653

const char socket_name[] = "socket_name";

5654

__attribute__((cleanup(cleanup_string)))

5655

char *filename = NULL;

5656

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5657

>, 0);

5658

g_assert_nonnull(filename);

5659

g_assert_cmpint((int)strlen(filename), <,

5660

(int)sizeof(sock_name.sun_path));

5661

strncpy(sock_name.sun_path, filename, sizeof(sock_name.sun_path));

5662

sock_name.sun_path[sizeof(sock_name.sun_path)-1] = '\0';

5663

g_assert_cmpint((int)bind(sock_fd, (struct sockaddr *)&sock_name,

5664

(socklen_t)SUN_LEN(&sock_name)), >=, 0);

5665

task_context task = {

5666

.func=connect_question_socket,

5667

.question_filename=strdup(question_filename),

5668

.epoll_fd=epoll_fd,

5669

.password=(buffer[]){{}},

5670

.filename=strdup(filename),

5671

.cancelled_filenames=&cancelled_filenames,

5672

.mandos_client_exited=(bool[]){false},

5673

.password_is_read=(bool[]){false},

5674

.current_time=&current_time,

5675

};

5676

g_assert_nonnull(task.question_filename);

5677

run_task_with_stderr_to_dev_null(task, queue);

5678

5679

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5680

const task_context *const added_task

5681

= find_matching_task(queue, task);

5682

g_assert_nonnull(added_task);

5683

g_assert_true(queue->next_run == 1000000 + current_time);

5684

5685

g_assert_cmpint(unlink(filename), ==, 0);

5686

g_assert_cmpint(rmdir(tempdir), ==, 0);

5687

}

5688

5689

static

5690

void test_connect_question_socket_usable(__attribute__((unused))

5691

test_fixture *fixture,

5692

__attribute__((unused))

5693

gconstpointer user_data){

5694

__attribute__((cleanup(cleanup_close)))

5695

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5696

g_assert_cmpint(epoll_fd, >=, 0);

5697

__attribute__((cleanup(cleanup_string)))

5698

char *const question_filename = strdup("/nonexistent/question");

5699

g_assert_nonnull(question_filename);

5700

__attribute__((cleanup(string_set_clear)))

5701

string_set cancelled_filenames = {};

5702

buffer password = {};

5703

bool mandos_client_exited = false;

5704

bool password_is_read = false;

5705

const mono_microsecs current_time = 0;

5706

__attribute__((cleanup(cleanup_queue)))

5707

task_queue *queue = create_queue();

5708

g_assert_nonnull(queue);

5709

__attribute__((cleanup(cleanup_string)))

5710

char *tempdir = make_temporary_directory();

5711

g_assert_nonnull(tempdir);

5712

__attribute__((cleanup(cleanup_close)))

5713

const int sock_fd = socket(PF_LOCAL, SOCK_DGRAM

5714

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

5715

g_assert_cmpint(sock_fd, >=, 0);

5716

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

5717

const char socket_name[] = "socket_name";

5718

__attribute__((cleanup(cleanup_string)))

5719

char *filename = NULL;

5720

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5721

>, 0);

5722

g_assert_nonnull(filename);

5723

g_assert_cmpint((int)strlen(filename), <,

5724

(int)sizeof(sock_name.sun_path));

5725

strncpy(sock_name.sun_path, filename, sizeof(sock_name.sun_path));

5726

sock_name.sun_path[sizeof(sock_name.sun_path)-1] = '\0';

5727

g_assert_cmpint((int)bind(sock_fd, (struct sockaddr *)&sock_name,

5728

(socklen_t)SUN_LEN(&sock_name)), >=, 0);

5729

task_context task = {

5730

.func=connect_question_socket,

5731

.question_filename=strdup(question_filename),

5732

.epoll_fd=epoll_fd,

5733

.password=&password,

5734

.filename=strdup(filename),

5735

.cancelled_filenames=&cancelled_filenames,

5736

.mandos_client_exited=&mandos_client_exited,

5737

.password_is_read=&password_is_read,

5738

.current_time=&current_time,

5739

};

5740

g_assert_nonnull(task.question_filename);

5741

task.func(task, queue);

5742

5743

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5744

const task_context *const added_task

5745

= find_matching_task(queue, (task_context){

5746

.func=send_password_to_socket,

5747

.question_filename=question_filename,

5748

.filename=filename,

5749

.epoll_fd=epoll_fd,

5750

.password=&password,

5751

.cancelled_filenames=&cancelled_filenames,

5752

.mandos_client_exited=&mandos_client_exited,

5753

.password_is_read=&password_is_read,

5754

.current_time=&current_time,

5755

});

5756

g_assert_nonnull(added_task);

5757

g_assert_cmpint(added_task->fd, >, 0);

5758

5759

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5760

EPOLLOUT));

5761

5762

const int fd = added_task->fd;

5763

g_assert_cmpint(fd, >, 0);

5764

g_assert_true(fd_has_cloexec_and_nonblock(fd));

5765

5766

/* write to fd */

5767

char write_data[PIPE_BUF];

5768

{

5769

/* Construct test password buffer */

5770

/* Start with + since that is what the real procotol uses */

5771

write_data[0] = '+';

5772

/* Set a special character at string end just to mark the end */

5773

write_data[sizeof(write_data)-2] = 'y';

5774

/* Set NUL at buffer end, as suggested by the protocol */

5775

write_data[sizeof(write_data)-1] = '\0';

5776

/* Fill rest of password with 'x' */

5777

memset(write_data+1, 'x', sizeof(write_data)-3);

5778

g_assert_cmpint((int)send(fd, write_data, sizeof(write_data),

5779

MSG_NOSIGNAL), ==, sizeof(write_data));

5780

}

5781

5782

/* read from sock_fd */

5783

char read_data[sizeof(write_data)];

5784

g_assert_cmpint((int)read(sock_fd, read_data, sizeof(read_data)),

5785

==, sizeof(read_data));

5786

5787

g_assert_true(memcmp(write_data, read_data, sizeof(write_data))

5788

== 0);

5789

5790

/* writing to sock_fd should fail */

5791

g_assert_cmpint(send(sock_fd, write_data, sizeof(write_data),

5792

MSG_NOSIGNAL), <, 0);

5793

5794

/* reading from fd should fail */

5795

g_assert_cmpint((int)recv(fd, read_data, sizeof(read_data),

5796

MSG_NOSIGNAL), <, 0);

5797

5798

g_assert_cmpint(unlink(filename), ==, 0);

5799

g_assert_cmpint(rmdir(tempdir), ==, 0);

5800

}

5801

5802

static void

5803

test_send_password_to_socket_client_not_exited(__attribute__((unused))

5804

test_fixture *fixture,

5805

__attribute__((unused))

5806

gconstpointer

5807

user_data){

5808

__attribute__((cleanup(cleanup_close)))

5809

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5810

g_assert_cmpint(epoll_fd, >=, 0);

5811

__attribute__((cleanup(cleanup_string)))

5812

char *const question_filename = strdup("/nonexistent/question");

5813

g_assert_nonnull(question_filename);

5814

__attribute__((cleanup(cleanup_string)))

5815

char *const filename = strdup("/nonexistent/socket");

5816

g_assert_nonnull(filename);

5817

__attribute__((cleanup(string_set_clear)))

5818

string_set cancelled_filenames = {};

5819

buffer password = {};

5820

bool password_is_read = true;

5821

__attribute__((cleanup(cleanup_queue)))

5822

task_queue *queue = create_queue();

5823

g_assert_nonnull(queue);

5824

int socketfds[2];

5825

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5826

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5827

socketfds), ==, 0);

5828

__attribute__((cleanup(cleanup_close)))

5829

const int read_socket = socketfds[0];

5830

const int write_socket = socketfds[1];

5831

task_context task = {

5832

.func=send_password_to_socket,

5833

.question_filename=strdup(question_filename),

5834

.filename=strdup(filename),

5835

.epoll_fd=epoll_fd,

5836

.fd=write_socket,

5837

.password=&password,

5838

.cancelled_filenames=&cancelled_filenames,

5839

.mandos_client_exited=(bool[]){false},

5840

.password_is_read=&password_is_read,

5841

.current_time=(mono_microsecs[]){0},

5842

};

5843

g_assert_nonnull(task.question_filename);

5844

5845

task.func(task, queue);

5846

5847

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5848

5849

const task_context *const added_task

5850

= find_matching_task(queue, task);

5851

g_assert_nonnull(added_task);

5852

g_assert_cmpuint((unsigned int)password.length, ==, 0);

5853

g_assert_true(password_is_read);

5854

5855

g_assert_cmpint(added_task->fd, >, 0);

5856

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5857

EPOLLOUT));

5858

}

5859

5860

static void

5861

test_send_password_to_socket_password_not_read(__attribute__((unused))

5862

test_fixture *fixture,

5863

__attribute__((unused))

5864

gconstpointer

5865

user_data){

5866

__attribute__((cleanup(cleanup_close)))

5867

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5868

g_assert_cmpint(epoll_fd, >=, 0);

5869

__attribute__((cleanup(cleanup_string)))

5870

char *const question_filename = strdup("/nonexistent/question");

5871

g_assert_nonnull(question_filename);

5872

__attribute__((cleanup(cleanup_string)))

5873

char *const filename = strdup("/nonexistent/socket");

5874

__attribute__((cleanup(string_set_clear)))

5875

string_set cancelled_filenames = {};

5876

buffer password = {};

5877

__attribute__((cleanup(cleanup_queue)))

5878

task_queue *queue = create_queue();

5879

g_assert_nonnull(queue);

5880

int socketfds[2];

5881

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5882

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5883

socketfds), ==, 0);

5884

__attribute__((cleanup(cleanup_close)))

5885

const int read_socket = socketfds[0];

5886

const int write_socket = socketfds[1];

5887

task_context task = {

5888

.func=send_password_to_socket,

5889

.question_filename=strdup(question_filename),

5890

.filename=strdup(filename),

5891

.epoll_fd=epoll_fd,

5892

.fd=write_socket,

5893

.password=&password,

5894

.cancelled_filenames=&cancelled_filenames,

5895

.mandos_client_exited=(bool[]){false},

5896

.password_is_read=(bool[]){false},

5897

.current_time=(mono_microsecs[]){0},

5898

};

5899

g_assert_nonnull(task.question_filename);

5900

5901

task.func(task, queue);

5902

5903

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5904

5905

const task_context *const added_task = find_matching_task(queue,

5906

task);

5907

g_assert_nonnull(added_task);

5908

g_assert_cmpuint((unsigned int)password.length, ==, 0);

5909

g_assert_true(queue->next_run == 0);

5910

5911

g_assert_cmpint(added_task->fd, >, 0);

5912

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5913

EPOLLOUT));

5914

}

5915

5916

static

5917

void test_send_password_to_socket_EMSGSIZE(__attribute__((unused))

5918

test_fixture *fixture,

5919

__attribute__((unused))

5920

gconstpointer user_data){

5921

__attribute__((cleanup(cleanup_close)))

5922

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5923

g_assert_cmpint(epoll_fd, >=, 0);

5924

const char question_filename[] = "/nonexistent/question";

5925

char *const filename = strdup("/nonexistent/socket");

5926

__attribute__((cleanup(string_set_clear)))

5927

string_set cancelled_filenames = {};

5928

const size_t oversized = 1024*1024; /* Limit seems to be 212960 */

5929

__attribute__((cleanup(cleanup_buffer)))

5930

buffer password = {

5931

.data=malloc(oversized),

5932

.length=oversized,

5933

.allocated=oversized,

5934

};

5935

g_assert_nonnull(password.data);

5936

if(mlock(password.data, password.allocated) != 0){

5937

g_assert_true(errno == EPERM or errno == ENOMEM);

5938

}

5939

/* Construct test password buffer */

5940

/* Start with + since that is what the real procotol uses */

5941

password.data[0] = '+';

5942

/* Set a special character at string end just to mark the end */

5943

password.data[oversized-3] = 'y';

5944

/* Set NUL at buffer end, as suggested by the protocol */

5945

password.data[oversized-2] = '\0';

5946

/* Fill rest of password with 'x' */

5947

memset(password.data+1, 'x', oversized-3);

5948

5949

__attribute__((cleanup(cleanup_queue)))

5950

task_queue *queue = create_queue();

5951

g_assert_nonnull(queue);

5952

int socketfds[2];

5953

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5954

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5955

socketfds), ==, 0);

5956

__attribute__((cleanup(cleanup_close)))

5957

const int read_socket = socketfds[0];

5958

__attribute__((cleanup(cleanup_close)))

5959

const int write_socket = socketfds[1];

5960

task_context task = {

5961

.func=send_password_to_socket,

5962

.question_filename=strdup(question_filename),

5963

.filename=filename,

5964

.epoll_fd=epoll_fd,

5965

.fd=write_socket,

5966

.password=&password,

5967

.cancelled_filenames=&cancelled_filenames,

5968

.mandos_client_exited=(bool[]){true},

5969

.password_is_read=(bool[]){true},

5970

.current_time=(mono_microsecs[]){0},

5971

};

5972

g_assert_nonnull(task.question_filename);

5973

5974

run_task_with_stderr_to_dev_null(task, queue);

5975

5976

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5977

g_assert_true(string_set_contains(cancelled_filenames,

5978

question_filename));

5979

}

5980

5981

static void test_send_password_to_socket_retry(__attribute__((unused))

5982

test_fixture *fixture,

5983

__attribute__((unused))

5984

gconstpointer

5985

user_data){

5986

__attribute__((cleanup(cleanup_close)))

5987

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5988

g_assert_cmpint(epoll_fd, >=, 0);

5989

__attribute__((cleanup(cleanup_string)))

5990

char *const question_filename = strdup("/nonexistent/question");

5991

g_assert_nonnull(question_filename);

5992

__attribute__((cleanup(cleanup_string)))

5993

char *const filename = strdup("/nonexistent/socket");

5994

g_assert_nonnull(filename);

5995

__attribute__((cleanup(string_set_clear)))

5996

string_set cancelled_filenames = {};

5997

__attribute__((cleanup(cleanup_buffer)))

5998

buffer password = {};

5999

6000

__attribute__((cleanup(cleanup_queue)))

6001

task_queue *queue = create_queue();

6002

g_assert_nonnull(queue);

6003

int socketfds[2];

6004

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6005

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6006

socketfds), ==, 0);

6007

__attribute__((cleanup(cleanup_close)))

6008

const int read_socket = socketfds[0];

6009

const int write_socket = socketfds[1];

6010

/* Close the server side socket to force ECONNRESET on client */

6011

g_assert_cmpint(close(read_socket), ==, 0);

6012

task_context task = {

6013

.func=send_password_to_socket,

6014

.question_filename=strdup(question_filename),

6015

.filename=strdup(filename),

6016

.epoll_fd=epoll_fd,

6017

.fd=write_socket,

6018

.password=&password,

6019

.cancelled_filenames=&cancelled_filenames,

6020

.mandos_client_exited=(bool[]){true},

6021

.password_is_read=(bool[]){true},

6022

.current_time=(mono_microsecs[]){0},

6023

};

6024

g_assert_nonnull(task.question_filename);

6025

6026

task.func(task, queue);

6027

6028

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6029

6030

const task_context *const added_task = find_matching_task(queue,

6031

task);

6032

g_assert_nonnull(added_task);

6033

g_assert_cmpuint((unsigned int)password.length, ==, 0);

6034

6035

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

6036

EPOLLOUT));

6037

}

6038

6039

static

6040

void test_send_password_to_socket_bad_epoll(__attribute__((unused))

6041

test_fixture *fixture,

6042

__attribute__((unused))

6043

gconstpointer user_data){

6044

__attribute__((cleanup(cleanup_close)))

6045

const int epoll_fd = open("/dev/null",

6046

O_WRONLY | O_CLOEXEC | O_NOCTTY);

6047

__attribute__((cleanup(cleanup_string)))

6048

char *const question_filename = strdup("/nonexistent/question");

6049

g_assert_nonnull(question_filename);

6050

__attribute__((cleanup(cleanup_string)))

6051

char *const filename = strdup("/nonexistent/socket");

6052

g_assert_nonnull(filename);

6053

__attribute__((cleanup(string_set_clear)))

6054

string_set cancelled_filenames = {};

6055

__attribute__((cleanup(cleanup_buffer)))

6056

buffer password = {};

6057

6058

const mono_microsecs current_time = 11;

6059

__attribute__((cleanup(cleanup_queue)))

6060

task_queue *queue = create_queue();

6061

g_assert_nonnull(queue);

6062

int socketfds[2];

6063

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6064

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6065

socketfds), ==, 0);

6066

__attribute__((cleanup(cleanup_close)))

6067

const int read_socket = socketfds[0];

6068

const int write_socket = socketfds[1];

6069

/* Close the server side socket to force ECONNRESET on client */

6070

g_assert_cmpint(close(read_socket), ==, 0);

6071

task_context task = {

6072

.func=send_password_to_socket,

6073

.question_filename=strdup(question_filename),

6074

.filename=strdup(filename),

6075

.epoll_fd=epoll_fd,

6076

.fd=write_socket,

6077

.password=&password,

6078

.cancelled_filenames=&cancelled_filenames,

6079

.mandos_client_exited=(bool[]){true},

6080

.password_is_read=(bool[]){true},

6081

.current_time=&current_time,

6082

};

6083

g_assert_nonnull(task.question_filename);

6084

6085

run_task_with_stderr_to_dev_null(task, queue);

6086

6087

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6088

6089

const task_context *const added_task = find_matching_task(queue,

6090

task);

6091

g_assert_nonnull(added_task);

6092

g_assert_true(queue->next_run == current_time + 1000000);

6093

g_assert_cmpuint((unsigned int)password.length, ==, 0);

6094

}

6095

6096

static void assert_send_password_to_socket_password(buffer password){

6097

__attribute__((cleanup(cleanup_close)))

6098

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6099

g_assert_cmpint(epoll_fd, >=, 0);

6100

char *const question_filename = strdup("/nonexistent/question");

6101

g_assert_nonnull(question_filename);

6102

char *const filename = strdup("/nonexistent/socket");

6103

g_assert_nonnull(filename);

6104

__attribute__((cleanup(string_set_clear)))

6105

string_set cancelled_filenames = {};

6106

6107

__attribute__((cleanup(cleanup_queue)))

6108

task_queue *queue = create_queue();

6109

g_assert_nonnull(queue);

6110

int socketfds[2];

6111

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6112

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6113

socketfds), ==, 0);

6114

__attribute__((cleanup(cleanup_close)))

6115

const int read_socket = socketfds[0];

6116

const int write_socket = socketfds[1];

6117

task_context task = {

6118

.func=send_password_to_socket,

6119

.question_filename=question_filename,

6120

.filename=filename,

6121

.epoll_fd=epoll_fd,

6122

.fd=write_socket,

6123

.password=&password,

6124

.cancelled_filenames=&cancelled_filenames,

6125

.mandos_client_exited=(bool[]){true},

6126

.password_is_read=(bool[]){true},

6127

.current_time=(mono_microsecs[]){0},

6128

};

6129

6130

char *expected_written_data = malloc(password.length + 2);

6131

g_assert_nonnull(expected_written_data);

6132

expected_written_data[0] = '+';

6133

expected_written_data[password.length + 1] = '\0';

6134

if(password.length > 0){

6135

g_assert_nonnull(password.data);

6136

memcpy(expected_written_data + 1, password.data, password.length);

6137

}

6138

6139

task.func(task, queue);

6140

6141

char buf[PIPE_BUF];

6142

g_assert_cmpint((int)read(read_socket, buf, PIPE_BUF), ==,

6143

(int)(password.length + 2));

6144

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6145

6146

g_assert_true(memcmp(expected_written_data, buf,

6147

password.length + 2) == 0);

6148

6149

g_assert_true(epoll_set_does_not_contain(epoll_fd, write_socket));

6150

6151

free(expected_written_data);

6152

}

6153

6154

static void

6155

test_send_password_to_socket_null_password(__attribute__((unused))

6156

test_fixture *fixture,

6157

__attribute__((unused))

6158

gconstpointer user_data){

6159

__attribute__((cleanup(cleanup_buffer)))

6160

buffer password = {};

6161

assert_send_password_to_socket_password(password);

6162

}

6163

6164

static void

6165

test_send_password_to_socket_empty_password(__attribute__((unused))

6166

test_fixture *fixture,

6167

__attribute__((unused))

6168

gconstpointer user_data){

6169

__attribute__((cleanup(cleanup_buffer)))

6170

buffer password = {

6171

.data=malloc(1), /* because malloc(0) may return NULL */

6172

.length=0,

6173

.allocated=0, /* deliberate lie */

6174

};

6175

g_assert_nonnull(password.data);

6176

assert_send_password_to_socket_password(password);

6177

}

6178

6179

static void

6180

test_send_password_to_socket_empty_str_pass(__attribute__((unused))

6181

test_fixture *fixture,

6182

__attribute__((unused))

6183

gconstpointer user_data){

6184

__attribute__((cleanup(cleanup_buffer)))

6185

buffer password = {

6186

.data=strdup(""),

6187

.length=0,

6188

.allocated=1,

6189

};

6190

if(mlock(password.data, password.allocated) != 0){

6191

g_assert_true(errno == EPERM or errno == ENOMEM);

6192

}

6193

assert_send_password_to_socket_password(password);

6194

}

6195

6196

static void

6197

test_send_password_to_socket_text_password(__attribute__((unused))

6198

test_fixture *fixture,

6199

__attribute__((unused))

6200

gconstpointer user_data){

6201

const char dummy_test_password[] = "dummy test password";

6202

__attribute__((cleanup(cleanup_buffer)))

6203

buffer password = {

6204

.data = strdup(dummy_test_password),

6205

.length = strlen(dummy_test_password),

6206

.allocated = sizeof(dummy_test_password),

6207

};

6208

if(mlock(password.data, password.allocated) != 0){

6209

g_assert_true(errno == EPERM or errno == ENOMEM);

6210

}

6211

assert_send_password_to_socket_password(password);

6212

}

6213

6214

static void

6215

test_send_password_to_socket_binary_password(__attribute__((unused))

6216

test_fixture *fixture,

6217

__attribute__((unused))

6218

gconstpointer user_data){

6219

__attribute__((cleanup(cleanup_buffer)))

6220

buffer password = {

6221

.data=malloc(255),

6222

.length=255,

6223

.allocated=255,

6224

};

6225

g_assert_nonnull(password.data);

6226

if(mlock(password.data, password.allocated) != 0){

6227

g_assert_true(errno == EPERM or errno == ENOMEM);

6228

}

6229

char c = 1; /* Start at 1, avoiding NUL */

6230

for(int i=0; i < 255; i++){

6231

password.data[i] = c++;

6232

}

6233

assert_send_password_to_socket_password(password);

6234

}

6235

6236

static void

6237

test_send_password_to_socket_nuls_in_password(__attribute__((unused))

6238

test_fixture *fixture,

6239

__attribute__((unused))

6240

gconstpointer

6241

user_data){

6242

char test_password[] = {'\0', 'a', '\0', 'b', '\0', 'c', '\0'};

6243

__attribute__((cleanup(cleanup_buffer)))

6244

buffer password = {

6245

.data=malloc(sizeof(test_password)),

6246

.length=sizeof(test_password),

6247

.allocated=sizeof(test_password),

6248

};

6249

g_assert_nonnull(password.data);

6250

if(mlock(password.data, password.allocated) !=0){

6251

g_assert_true(errno == EPERM or errno == ENOMEM);

6252

}

6253

memcpy(password.data, test_password, password.allocated);

6254

assert_send_password_to_socket_password(password);

6255

}

6256

6257

static bool assert_add_existing_questions_to_devnull(task_queue

6258

*const,

6259

const int,

6260

buffer *const,

6261

string_set *,

6262

const

6263

mono_microsecs

6264

*const,

6265

bool *const,

6266

bool *const,

6267

const char

6268

*const);

6269

6270

static void test_add_existing_questions_ENOENT(__attribute__((unused))

6271

test_fixture *fixture,

6272

__attribute__((unused))

6273

gconstpointer

6274

user_data){

6275

__attribute__((cleanup(cleanup_queue)))

6276

task_queue *queue = create_queue();

6277

g_assert_nonnull(queue);

6278

__attribute__((cleanup(cleanup_close)))

6279

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6280

g_assert_cmpint(epoll_fd, >=, 0);

6281

__attribute__((cleanup(string_set_clear)))

6282

string_set cancelled_filenames = {};

6283

6284

g_assert_false(assert_add_existing_questions_to_devnull

6285

(queue,

6286

epoll_fd,

6287

(buffer[]){{}}, /* password */

6288

&cancelled_filenames,

6289

(mono_microsecs[]){0}, /* current_time */

6290

(bool[]){false}, /* mandos_client_exited */

6291

(bool[]){false}, /* password_is_read */

6292

"/nonexistent")); /* dirname */

6293

6294

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6295

}

6296

6297

static

6298

bool assert_add_existing_questions_to_devnull(task_queue

6299

*const queue,

6300

const int

6301

epoll_fd,

6302

buffer *const

6303

password,

6304

string_set

6305

*cancelled_filenames,

6306

const mono_microsecs

6307

*const current_time,

6308

bool *const

6309

mandos_client_exited,

6310

bool *const

6311

password_is_read,

6312

const char *const

6313

dirname){

6314

__attribute__((cleanup(cleanup_close)))

6315

const int devnull_fd = open("/dev/null",

6316

O_WRONLY | O_CLOEXEC | O_NOCTTY);

6317

g_assert_cmpint(devnull_fd, >=, 0);

6318

__attribute__((cleanup(cleanup_close)))

6319

const int real_stderr_fd = dup(STDERR_FILENO);

6320

g_assert_cmpint(real_stderr_fd, >=, 0);

6321

dup2(devnull_fd, STDERR_FILENO);

6322

const bool ret = add_existing_questions(queue, epoll_fd, password,

6323

cancelled_filenames,

6324

current_time,

6325

mandos_client_exited,

6326

password_is_read, dirname);

6327

dup2(real_stderr_fd, STDERR_FILENO);

6328

return ret;

6329

}

6330

6331

static

6332

void test_add_existing_questions_no_questions(__attribute__((unused))

6333

test_fixture *fixture,

6334

__attribute__((unused))

6335

gconstpointer

6336

user_data){

6337

__attribute__((cleanup(cleanup_queue)))

6338

task_queue *queue = create_queue();

6339

g_assert_nonnull(queue);

6340

__attribute__((cleanup(cleanup_close)))

6341

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6342

g_assert_cmpint(epoll_fd, >=, 0);

6343

__attribute__((cleanup(string_set_clear)))

6344

string_set cancelled_filenames = {};

6345

__attribute__((cleanup(cleanup_string)))

6346

char *tempdir = make_temporary_directory();

6347

g_assert_nonnull(tempdir);

6348

6349

g_assert_false(assert_add_existing_questions_to_devnull

6350

(queue,

6351

epoll_fd,

6352

(buffer[]){{}}, /* password */

6353

&cancelled_filenames,

6354

(mono_microsecs[]){0}, /* current_time */

6355

(bool[]){false}, /* mandos_client_exited */

6356

(bool[]){false}, /* password_is_read */

6357

tempdir));

6358

6359

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6360

6361

g_assert_cmpint(rmdir(tempdir), ==, 0);

6362

}

6363

6364

static char *make_question_file_in_directory(const char *const);

6365

6366

static

6367

void test_add_existing_questions_one_question(__attribute__((unused))

6368

test_fixture *fixture,

6369

__attribute__((unused))

6370

gconstpointer

6371

user_data){

6372

__attribute__((cleanup(cleanup_queue)))

6373

task_queue *queue = create_queue();

6374

g_assert_nonnull(queue);

6375

__attribute__((cleanup(cleanup_close)))

6376

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6377

g_assert_cmpint(epoll_fd, >=, 0);

6378

__attribute__((cleanup(cleanup_buffer)))

6379

buffer password = {};

6380

__attribute__((cleanup(string_set_clear)))

6381

string_set cancelled_filenames = {};

6382

const mono_microsecs current_time = 0;

6383

bool mandos_client_exited = false;

6384

bool password_is_read = false;

6385

__attribute__((cleanup(cleanup_string)))

6386

char *tempdir = make_temporary_directory();

6387

g_assert_nonnull(tempdir);

6388

__attribute__((cleanup(cleanup_string)))

6389

char *question_filename

6390

= make_question_file_in_directory(tempdir);

6391

g_assert_nonnull(question_filename);

6392

6393

g_assert_true(assert_add_existing_questions_to_devnull

6394

(queue,

6395

epoll_fd,

6396

&password,

6397

&cancelled_filenames,

6398

&current_time,

6399

&mandos_client_exited,

6400

&password_is_read,

6401

tempdir));

6402

6403

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6404

6405

g_assert_nonnull(find_matching_task(queue, (task_context){

6406

.func=open_and_parse_question,

6407

.epoll_fd=epoll_fd,

6408

.filename=question_filename,

6409

.question_filename=question_filename,

6410

.password=&password,

6411

.cancelled_filenames=&cancelled_filenames,

6412

.current_time=&current_time,

6413

.mandos_client_exited=&mandos_client_exited,

6414

.password_is_read=&password_is_read,

6415

}));

6416

6417

g_assert_true(queue->next_run == 1);

6418

6419

g_assert_cmpint(unlink(question_filename), ==, 0);

6420

g_assert_cmpint(rmdir(tempdir), ==, 0);

6421

}

6422

6423

static char *make_question_file_in_directory(const char

6424

*const dir){

6425

return make_temporary_prefixed_file_in_directory("ask.", dir);

6426

}

6427

6428

static

6429

void test_add_existing_questions_two_questions(__attribute__((unused))

6430

test_fixture *fixture,

6431

__attribute__((unused))

6432

gconstpointer

6433

user_data){

6434

__attribute__((cleanup(cleanup_queue)))

6435

task_queue *queue = create_queue();

6436

g_assert_nonnull(queue);

6437

__attribute__((cleanup(cleanup_close)))

6438

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6439

g_assert_cmpint(epoll_fd, >=, 0);

6440

__attribute__((cleanup(cleanup_buffer)))

6441

buffer password = {};

6442

__attribute__((cleanup(string_set_clear)))

6443

string_set cancelled_filenames = {};

6444

const mono_microsecs current_time = 0;

6445

bool mandos_client_exited = false;

6446

bool password_is_read = false;

6447

__attribute__((cleanup(cleanup_string)))

6448

char *tempdir = make_temporary_directory();

6449

g_assert_nonnull(tempdir);

6450

__attribute__((cleanup(cleanup_string)))

6451

char *question_filename1

6452

= make_question_file_in_directory(tempdir);

6453

g_assert_nonnull(question_filename1);

6454

__attribute__((cleanup(cleanup_string)))

6455

char *question_filename2

6456

= make_question_file_in_directory(tempdir);

6457

g_assert_nonnull(question_filename2);

6458

6459

g_assert_true(assert_add_existing_questions_to_devnull

6460

(queue,

6461

epoll_fd,

6462

&password,

6463

&cancelled_filenames,

6464

&current_time,

6465

&mandos_client_exited,

6466

&password_is_read,

6467

tempdir));

6468

6469

g_assert_cmpuint((unsigned int)queue->length, ==, 2);

6470

6471

g_assert_true(queue->next_run == 1);

6472

6473

__attribute__((cleanup(string_set_clear)))

6474

string_set seen_questions = {};

6475

6476

bool queue_contains_question_opener(char *const question_filename){

6477

return(find_matching_task(queue, (task_context){

6478

.func=open_and_parse_question,

6479

.epoll_fd=epoll_fd,

6480

.question_filename=question_filename,

6481

.password=&password,

6482

.cancelled_filenames=&cancelled_filenames,

6483

.current_time=&current_time,

6484

.mandos_client_exited=&mandos_client_exited,

6485

.password_is_read=&password_is_read,

6486

}) != NULL);

6487

}

6488

6489

g_assert_true(queue_contains_question_opener(question_filename1));

6490

g_assert_true(queue_contains_question_opener(question_filename2));

6491

6492

g_assert_true(queue->next_run == 1);

6493

6494

g_assert_cmpint(unlink(question_filename1), ==, 0);

6495

g_assert_cmpint(unlink(question_filename2), ==, 0);

6496

g_assert_cmpint(rmdir(tempdir), ==, 0);

6497

}

6498

6499

static void

6500

test_add_existing_questions_non_questions(__attribute__((unused))

6501

test_fixture *fixture,

6502

__attribute__((unused))

6503

gconstpointer user_data){

6504

__attribute__((cleanup(cleanup_queue)))

6505

task_queue *queue = create_queue();

6506

g_assert_nonnull(queue);

6507

__attribute__((cleanup(cleanup_close)))

6508

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6509

g_assert_cmpint(epoll_fd, >=, 0);

6510

__attribute__((cleanup(string_set_clear)))

6511

string_set cancelled_filenames = {};

6512

__attribute__((cleanup(cleanup_string)))

6513

char *tempdir = make_temporary_directory();

6514

g_assert_nonnull(tempdir);

6515

__attribute__((cleanup(cleanup_string)))

6516

char *question_filename1

6517

= make_temporary_file_in_directory(tempdir);

6518

g_assert_nonnull(question_filename1);

6519

__attribute__((cleanup(cleanup_string)))

6520

char *question_filename2

6521

= make_temporary_file_in_directory(tempdir);

6522

g_assert_nonnull(question_filename2);

6523

6524

g_assert_false(assert_add_existing_questions_to_devnull

6525

(queue,

6526

epoll_fd,

6527

(buffer[]){{}}, /* password */

6528

&cancelled_filenames,

6529

(mono_microsecs[]){0}, /* current_time */

6530

(bool[]){false}, /* mandos_client_exited */

6531

(bool[]){false}, /* password_is_read */

6532

tempdir));

6533

6534

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6535

6536

g_assert_cmpint(unlink(question_filename1), ==, 0);

6537

g_assert_cmpint(unlink(question_filename2), ==, 0);

6538

g_assert_cmpint(rmdir(tempdir), ==, 0);

6539

}

6540

6541

static void

6542

test_add_existing_questions_both_types(__attribute__((unused))

6543

test_fixture *fixture,

6544

__attribute__((unused))

6545

gconstpointer user_data){

6546

__attribute__((cleanup(cleanup_queue)))

6547

task_queue *queue = create_queue();

6548

g_assert_nonnull(queue);

6549

__attribute__((cleanup(cleanup_close)))

6550

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6551

g_assert_cmpint(epoll_fd, >=, 0);

6552

__attribute__((cleanup(cleanup_buffer)))

6553

buffer password = {};

6554

__attribute__((cleanup(string_set_clear)))

6555

string_set cancelled_filenames = {};

6556

const mono_microsecs current_time = 0;

6557

bool mandos_client_exited = false;

6558

bool password_is_read = false;

6559

__attribute__((cleanup(cleanup_string)))

6560

char *tempdir = make_temporary_directory();

6561

g_assert_nonnull(tempdir);

6562

__attribute__((cleanup(cleanup_string)))

6563

char *tempfilename1 = make_temporary_file_in_directory(tempdir);

6564

g_assert_nonnull(tempfilename1);

6565

__attribute__((cleanup(cleanup_string)))

6566

char *tempfilename2 = make_temporary_file_in_directory(tempdir);

6567

g_assert_nonnull(tempfilename2);

6568

__attribute__((cleanup(cleanup_string)))

6569

char *question_filename

6570

= make_question_file_in_directory(tempdir);

6571

g_assert_nonnull(question_filename);

6572

6573

g_assert_true(assert_add_existing_questions_to_devnull

6574

(queue,

6575

epoll_fd,

6576

&password,

6577

&cancelled_filenames,

6578

&current_time,

6579

&mandos_client_exited,

6580

&password_is_read,

6581

tempdir));

6582

6583

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6584

6585

g_assert_nonnull(find_matching_task(queue, (task_context){

6586

.func=open_and_parse_question,

6587

.epoll_fd=epoll_fd,

6588

.filename=question_filename,

6589

.question_filename=question_filename,

6590

.password=&password,

6591

.cancelled_filenames=&cancelled_filenames,

6592

.current_time=&current_time,

6593

.mandos_client_exited=&mandos_client_exited,

6594

.password_is_read=&password_is_read,

6595

}));

6596

6597

g_assert_true(queue->next_run == 1);

6598

6599

g_assert_cmpint(unlink(tempfilename1), ==, 0);

6600

g_assert_cmpint(unlink(tempfilename2), ==, 0);

6601

g_assert_cmpint(unlink(question_filename), ==, 0);

6602

g_assert_cmpint(rmdir(tempdir), ==, 0);

6603

}

6604

6605

static void test_wait_for_event_timeout(__attribute__((unused))

6606

test_fixture *fixture,

6607

__attribute__((unused))

6608

gconstpointer user_data){

6609

__attribute__((cleanup(cleanup_close)))

6610

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6611

g_assert_cmpint(epoll_fd, >=, 0);

6612

6613

g_assert_true(wait_for_event(epoll_fd, 1, 0));

6614

}

6615

6616

static void test_wait_for_event_event(__attribute__((unused))

6617

test_fixture *fixture,

6618

__attribute__((unused))

6619

gconstpointer user_data){

6620

__attribute__((cleanup(cleanup_close)))

6621

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6622

g_assert_cmpint(epoll_fd, >=, 0);

6623

int pipefds[2];

6624

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

6625

__attribute__((cleanup(cleanup_close)))

6626

const int read_pipe = pipefds[0];

6627

__attribute__((cleanup(cleanup_close)))

6628

const int write_pipe = pipefds[1];

6629

g_assert_cmpint(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, read_pipe,

6630

&(struct epoll_event)

6631

{ .events=EPOLLIN | EPOLLRDHUP }), ==, 0);

6632

g_assert_cmpint((int)write(write_pipe, "x", 1), ==, 1);

6633

6634

g_assert_true(wait_for_event(epoll_fd, 0, 0));

6635

}

6636

6637

static void test_wait_for_event_sigchld(test_fixture *fixture,

6638

__attribute__((unused))

6639

gconstpointer user_data){

6640

const pid_t pid = fork();

6641

if(pid == 0){ /* Child */

6642

if(not restore_signal_handler(&fixture->orig_sigaction)){

6643

_exit(EXIT_FAILURE);

6644

}

6645

if(not restore_sigmask(&fixture->orig_sigmask)){

6646

_exit(EXIT_FAILURE);

6647

}

6648

exit(EXIT_SUCCESS);

6649

}

6650

g_assert_true(pid != -1);

6651

__attribute__((cleanup(cleanup_close)))

6652

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6653

g_assert_cmpint(epoll_fd, >=, 0);

6654

6655

g_assert_true(wait_for_event(epoll_fd, 0, 0));

6656

6657

int status;

6658

g_assert_true(waitpid(pid, &status, 0) == pid);

6659

g_assert_true(WIFEXITED(status));

6660

g_assert_cmpint(WEXITSTATUS(status), ==, EXIT_SUCCESS);

6661

}

6662

6663

static void test_run_queue_zeroes_next_run(__attribute__((unused))

6664

test_fixture *fixture,

6665

__attribute__((unused))

6666

gconstpointer user_data){

6667

__attribute__((cleanup(cleanup_queue)))

6668

task_queue *queue = create_queue();

6669

g_assert_nonnull(queue);

6670

queue->next_run = 1;

6671

__attribute__((cleanup(cleanup_close)))

6672

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6673

__attribute__((cleanup(string_set_clear)))

6674

string_set cancelled_filenames = {};

6675

bool quit_now = false;

6676

6677

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6678

g_assert_false(quit_now);

6679

g_assert_cmpuint((unsigned int)queue->next_run, ==, 0);

6680

}

6681

6682

static

6683

void test_run_queue_clears_cancelled_filenames(__attribute__((unused))

6684

test_fixture *fixture,

6685

__attribute__((unused))

6686

gconstpointer

6687

user_data){

6688

__attribute__((cleanup(cleanup_queue)))

6689

task_queue *queue = create_queue();

6690

g_assert_nonnull(queue);

6691

__attribute__((cleanup(string_set_clear)))

6692

string_set cancelled_filenames = {};

6693

bool quit_now = false;

6694

const char question_filename[] = "/nonexistent/question_filename";

6695

g_assert_true(string_set_add(&cancelled_filenames,

6696

question_filename));

6697

6698

g_assert_true(add_to_queue(queue,

6699

(task_context){ .func=dummy_func }));

6700

6701

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6702

g_assert_false(quit_now);

6703

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6704

g_assert_false(string_set_contains(cancelled_filenames,

6705

question_filename));

6706

}

6707

6708

static

6709

void test_run_queue_skips_cancelled_filenames(__attribute__((unused))

6710

test_fixture *fixture,

6711

__attribute__((unused))

6712

gconstpointer

6713

user_data){

6714

__attribute__((cleanup(cleanup_queue)))

6715

task_queue *queue = create_queue();

6716

g_assert_nonnull(queue);

6717

__attribute__((cleanup(string_set_clear)))

6718

string_set cancelled_filenames = {};

6719

bool quit_now = false;

6720

int pipefds[2];

6721

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

6722

__attribute__((cleanup(cleanup_close)))

6723

const int read_pipe = pipefds[0];

6724

g_assert_cmpint(close(pipefds[1]), ==, 0);

6725

const char question_filename[] = "/nonexistent/question_filename";

6726

g_assert_true(string_set_add(&cancelled_filenames,

6727

question_filename));

6728

__attribute__((nonnull))

6729

void quit_func(const task_context task,

6730

__attribute__((unused)) task_queue *const q){

6731

g_assert_nonnull(task.quit_now);

6732

*task.quit_now = true;

6733

}

6734

task_context task = {

6735

.func=quit_func,

6736

.question_filename=strdup(question_filename),

6737

.quit_now=&quit_now,

6738

.fd=read_pipe,

6739

};

6740

g_assert_nonnull(task.question_filename);

6741

6742

g_assert_true(add_to_queue(queue, task));

6743

6744

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6745

g_assert_false(quit_now);

6746

6747

/* read_pipe should be closed already */

6748

errno = 0;

6749

bool read_pipe_closed = (close(read_pipe) == -1);

6750

read_pipe_closed &= (errno == EBADF);

6751

g_assert_true(read_pipe_closed);

6752

}

6753

6754

static void test_run_queue_one_task(__attribute__((unused))

6755

test_fixture *fixture,

6756

__attribute__((unused))

6757

gconstpointer user_data){

6758

__attribute__((cleanup(cleanup_queue)))

6759

task_queue *queue = create_queue();

6760

g_assert_nonnull(queue);

6761

__attribute__((cleanup(string_set_clear)))

6762

string_set cancelled_filenames = {};

6763

bool quit_now = false;

6764

6765

__attribute__((nonnull))

6766

void next_run_func(__attribute__((unused))

6767

const task_context task,

6768

task_queue *const q){

6769

q->next_run = 1;

6770

}

6771

6772

task_context task = {

6773

.func=next_run_func,

6774

};

6775

g_assert_true(add_to_queue(queue, task));

6776

6777

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6778

g_assert_cmpuint((unsigned int)(queue->next_run), ==, 1);

6779

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6780

}

6781

6782

static void test_run_queue_two_tasks(__attribute__((unused))

6783

test_fixture *fixture,

6784

__attribute__((unused))

6785

gconstpointer user_data){

6786

__attribute__((cleanup(cleanup_queue)))

6787

task_queue *queue = create_queue();

6788

g_assert_nonnull(queue);

6789

queue->next_run = 1;

6790

__attribute__((cleanup(string_set_clear)))

6791

string_set cancelled_filenames = {};

6792

bool quit_now = false;

6793

bool mandos_client_exited = false;

6794

6795

__attribute__((nonnull))

6796

void next_run_func(__attribute__((unused))

6797

const task_context task,

6798

task_queue *const q){

6799

q->next_run = 1;

6800

}

6801

6802

__attribute__((nonnull))

6803

void exited_func(const task_context task,

6804

__attribute__((unused)) task_queue *const q){

6805

*task.mandos_client_exited = true;

6806

}

6807

6808

task_context task1 = {

6809

.func=next_run_func,

6810

};

6811

g_assert_true(add_to_queue(queue, task1));

6812

6813

task_context task2 = {

6814

.func=exited_func,

6815

.mandos_client_exited=&mandos_client_exited,

6816

};

6817

g_assert_true(add_to_queue(queue, task2));

6818

6819

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6820

g_assert_false(quit_now);

6821

g_assert_cmpuint((unsigned int)(queue->next_run), ==, 1);

6822

g_assert_true(mandos_client_exited);

6823

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6824

}

6825

6826

static void test_run_queue_two_tasks_quit(__attribute__((unused))

6827

test_fixture *fixture,

6828

__attribute__((unused))

6829

gconstpointer user_data){

6830

__attribute__((cleanup(cleanup_queue)))

6831

task_queue *queue = create_queue();

6832

g_assert_nonnull(queue);

6833

__attribute__((cleanup(string_set_clear)))

6834

string_set cancelled_filenames = {};

6835

bool quit_now = false;

6836

bool mandos_client_exited = false;

6837

bool password_is_read = false;

6838

6839

__attribute__((nonnull))

6840

void set_exited_func(const task_context task,

6841

__attribute__((unused)) task_queue *const q){

6842

*task.mandos_client_exited = true;

6843

*task.quit_now = true;

6844

}

6845

task_context task1 = {

6846

.func=set_exited_func,

6847

.quit_now=&quit_now,

6848

.mandos_client_exited=&mandos_client_exited,

6849

};

6850

g_assert_true(add_to_queue(queue, task1));

6851

6852

__attribute__((nonnull))

6853

void set_read_func(const task_context task,

6854

__attribute__((unused)) task_queue *const q){

6855

*task.quit_now = true;

6856

*task.password_is_read = true;

6857

}

6858

task_context task2 = {

6859

.func=set_read_func,

6860

.quit_now=&quit_now,

6861

.password_is_read=&password_is_read,

6862

};

6863

g_assert_true(add_to_queue(queue, task2));

6864

6865

g_assert_false(run_queue(&queue, &cancelled_filenames, &quit_now));

6866

g_assert_true(quit_now);

6867

g_assert_true(mandos_client_exited xor password_is_read);

6868

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6869

}

6870

6871

static void test_run_queue_two_tasks_cleanup(__attribute__((unused))

6872

test_fixture *fixture,

6873

__attribute__((unused))

6874

gconstpointer user_data){

6875

__attribute__((cleanup(cleanup_queue)))

6876

task_queue *queue = create_queue();

6877

g_assert_nonnull(queue);

6878

__attribute__((cleanup(string_set_clear)))

6879

string_set cancelled_filenames = {};

6880

int pipefds[2];

6881

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

6882

__attribute__((cleanup(cleanup_close)))

6883

const int read_pipe = pipefds[0];

6884

__attribute__((cleanup(cleanup_close)))

6885

const int write_pipe = pipefds[1];

6886

bool quit_now = false;

6887

6888

__attribute__((nonnull))

6889

void read_func(const task_context task,

6890

__attribute__((unused)) task_queue *const q){

6891

*task.quit_now = true;

6892

}

6893

task_context task1 = {

6894

.func=read_func,

6895

.quit_now=&quit_now,

6896

.fd=read_pipe,

6897

};

6898

g_assert_true(add_to_queue(queue, task1));

6899

6900

__attribute__((nonnull))

6901

void write_func(const task_context task,

6902

__attribute__((unused)) task_queue *const q){

6903

*task.quit_now = true;

6904

}

6905

task_context task2 = {

6906

.func=write_func,

6907

.quit_now=&quit_now,

6908

.fd=write_pipe,

6909

};

6910

g_assert_true(add_to_queue(queue, task2));

6911

6912

g_assert_false(run_queue(&queue, &cancelled_filenames, &quit_now));

6913

g_assert_true(quit_now);

6914

6915

/* Either read_pipe or write_pipe should be closed already */

6916

errno = 0;

6917

bool close_read_pipe = (close(read_pipe) == -1);

6918

close_read_pipe &= (errno == EBADF);

6919

errno = 0;

6920

bool close_write_pipe = (close(write_pipe) == -1);

6921

close_write_pipe &= (errno == EBADF);

6922

g_assert_true(close_read_pipe xor close_write_pipe);

6923

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6924

}

6925

6926

static void test_setup_signal_handler(__attribute__((unused))

6927

test_fixture *fixture,

6928

__attribute__((unused))

6929

gconstpointer user_data){

6930

/* Save current SIGCHLD action, whatever it is */

6931

struct sigaction expected_sigchld_action;

6932

g_assert_cmpint(sigaction(SIGCHLD, NULL, &expected_sigchld_action),

6933

==, 0);

6934

6935

/* Act; i.e. run the setup_signal_handler() function */

6936

struct sigaction actual_old_sigchld_action;

6937

g_assert_true(setup_signal_handler(&actual_old_sigchld_action));

6938

6939

/* Check that the function correctly set "actual_old_sigchld_action"

6940

to the same values as the previously saved

6941

"expected_sigchld_action" */

6942

/* Check member sa_handler */

6943

g_assert_true(actual_old_sigchld_action.sa_handler

6944

== expected_sigchld_action.sa_handler);

6945

/* Check member sa_mask */

6946

for(int signum = 1; signum < NSIG; signum++){

6947

const int expected_old_block_state

6948

= sigismember(&expected_sigchld_action.sa_mask, signum);

6949

g_assert_cmpint(expected_old_block_state, >=, 0);

6950

const int actual_old_block_state

6951

= sigismember(&actual_old_sigchld_action.sa_mask, signum);

6952

g_assert_cmpint(actual_old_block_state, >=, 0);

6953

g_assert_cmpint(actual_old_block_state,

6954

==, expected_old_block_state);

6955

}

6956

/* Check member sa_flags */

6957

g_assert_true((actual_old_sigchld_action.sa_flags

6958

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

6959

== (expected_sigchld_action.sa_flags

6960

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART)));

6961

6962

/* Retrieve the current signal handler for SIGCHLD as set by

6963

setup_signal_handler() */

6964

struct sigaction actual_new_sigchld_action;

6965

g_assert_cmpint(sigaction(SIGCHLD, NULL,

6966

&actual_new_sigchld_action), ==, 0);

6967

/* Check that the signal handler (member sa_handler) is correctly

6968

set to the "handle_sigchld" function */

6969

g_assert_true(actual_new_sigchld_action.sa_handler != SIG_DFL);

6970

g_assert_true(actual_new_sigchld_action.sa_handler != SIG_IGN);

6971

g_assert_true(actual_new_sigchld_action.sa_handler

6972

== handle_sigchld);

6973

/* Check (in member sa_mask) that at least a handful of signals are

6974

actually blocked during the signal handler */

6975

for(int signum = 1; signum < NSIG; signum++){

6976

int actual_new_block_state;

6977

switch(signum){

6978

case SIGTERM:

6979

case SIGINT:

6980

case SIGQUIT:

6981

case SIGHUP:

6982

actual_new_block_state

6983

= sigismember(&actual_new_sigchld_action.sa_mask, signum);

6984

g_assert_cmpint(actual_new_block_state, ==, 1);

6985

continue;

6986

case SIGKILL: /* non-blockable */

6987

case SIGSTOP: /* non-blockable */

6988

case SIGCHLD: /* always blocked */

6989

default:

6990

continue;

6991

}

6992

}

6993

/* Check member sa_flags */

6994

g_assert_true((actual_new_sigchld_action.sa_flags

6995

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

6996

== (SA_NOCLDSTOP | SA_RESTART));

6997

6998

/* Restore signal handler */

6999

g_assert_cmpint(sigaction(SIGCHLD, &expected_sigchld_action, NULL),

7000

==, 0);

7001

}

7002

7003

static void test_restore_signal_handler(__attribute__((unused))

7004

test_fixture *fixture,

7005

__attribute__((unused))

7006

gconstpointer user_data){

7007

/* Save current SIGCHLD action, whatever it is */

7008

struct sigaction expected_sigchld_action;

7009

g_assert_cmpint(sigaction(SIGCHLD, NULL, &expected_sigchld_action),

7010

==, 0);

7011

/* Since we haven't established a signal handler yet, there should

7012

not be one established. But another test may have relied on

7013

restore_signal_handler() to restore the signal handler, and if

7014

restore_signal_handler() is buggy (which we should be prepared

7015

for in this test) the signal handler may not have been restored

7016

properly; check for this: */

7017

g_assert_true(expected_sigchld_action.sa_handler != handle_sigchld);

7018

7019

/* Establish a signal handler */

7020

struct sigaction sigchld_action = {

7021

.sa_handler=handle_sigchld,

7022

.sa_flags=SA_RESTART | SA_NOCLDSTOP,

7023

};

7024

g_assert_cmpint(sigfillset(&sigchld_action.sa_mask), ==, 0);

7025

g_assert_cmpint(sigaction(SIGCHLD, &sigchld_action, NULL), ==, 0);

7026

7027

/* Act; i.e. run the restore_signal_handler() function */

7028

g_assert_true(restore_signal_handler(&expected_sigchld_action));

7029

7030

/* Retrieve the restored signal handler data */

7031

struct sigaction actual_restored_sigchld_action;

7032

g_assert_cmpint(sigaction(SIGCHLD, NULL,

7033

&actual_restored_sigchld_action), ==, 0);

7034

7035

/* Check that the function correctly restored the signal action, as

7036

saved in "actual_restored_sigchld_action", to the same values as

7037

the previously saved "expected_sigchld_action" */

7038

/* Check member sa_handler */

7039

g_assert_true(actual_restored_sigchld_action.sa_handler

7040

== expected_sigchld_action.sa_handler);

7041

/* Check member sa_mask */

7042

for(int signum = 1; signum < NSIG; signum++){

7043

const int expected_old_block_state

7044

= sigismember(&expected_sigchld_action.sa_mask, signum);

7045

g_assert_cmpint(expected_old_block_state, >=, 0);

7046

const int actual_restored_block_state

7047

= sigismember(&actual_restored_sigchld_action.sa_mask, signum);

7048

g_assert_cmpint(actual_restored_block_state, >=, 0);

7049

g_assert_cmpint(actual_restored_block_state,

7050

==, expected_old_block_state);

7051

}

7052

/* Check member sa_flags */

7053

g_assert_true((actual_restored_sigchld_action.sa_flags

7054

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

7055

== (expected_sigchld_action.sa_flags

7056

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART)));

7057

}

7058

7059

static void test_block_sigchld(__attribute__((unused))

7060

test_fixture *fixture,

7061

__attribute__((unused))

7062

gconstpointer user_data){

7063

/* Save original signal mask */

7064

sigset_t expected_sigmask;

7065

g_assert_cmpint(pthread_sigmask(-1, NULL, &expected_sigmask),

7066

==, 0);

7067

7068

/* Make sure SIGCHLD is unblocked for this test */

7069

sigset_t sigchld_sigmask;

7070

g_assert_cmpint(sigemptyset(&sigchld_sigmask), ==, 0);

7071

g_assert_cmpint(sigaddset(&sigchld_sigmask, SIGCHLD), ==, 0);

7072

g_assert_cmpint(pthread_sigmask(SIG_UNBLOCK, &sigchld_sigmask,

7073

NULL), ==, 0);

7074

7075

/* Act; i.e. run the block_sigchld() function */

7076

sigset_t actual_old_sigmask;

7077

g_assert_true(block_sigchld(&actual_old_sigmask));

7078

7079

/* Check the actual_old_sigmask; it should be the same as the

7080

previously saved signal mask "expected_sigmask". */

7081

for(int signum = 1; signum < NSIG; signum++){

7082

const int expected_old_block_state

7083

= sigismember(&expected_sigmask, signum);

7084

g_assert_cmpint(expected_old_block_state, >=, 0);

7085

const int actual_old_block_state

7086

= sigismember(&actual_old_sigmask, signum);

7087

g_assert_cmpint(actual_old_block_state, >=, 0);

7088

g_assert_cmpint(actual_old_block_state,

7089

==, expected_old_block_state);

7090

}

7091

7092

/* Retrieve the newly set signal mask */

7093

sigset_t actual_sigmask;

7094

g_assert_cmpint(pthread_sigmask(-1, NULL, &actual_sigmask), ==, 0);

7095

7096

/* SIGCHLD should be blocked */

7097

g_assert_cmpint(sigismember(&actual_sigmask, SIGCHLD), ==, 1);

7098

7099

/* Restore signal mask */

7100

g_assert_cmpint(pthread_sigmask(SIG_SETMASK, &expected_sigmask,

7101

NULL), ==, 0);

7102

}

7103

7104

static void test_restore_sigmask(__attribute__((unused))

7105

test_fixture *fixture,

7106

__attribute__((unused))

7107

gconstpointer user_data){

7108

/* Save original signal mask */

7109

sigset_t orig_sigmask;

7110

g_assert_cmpint(pthread_sigmask(-1, NULL, &orig_sigmask), ==, 0);

7111

7112

/* Make sure SIGCHLD is blocked for this test */

7113

sigset_t sigchld_sigmask;

7114

g_assert_cmpint(sigemptyset(&sigchld_sigmask), ==, 0);

7115

g_assert_cmpint(sigaddset(&sigchld_sigmask, SIGCHLD), ==, 0);

7116

g_assert_cmpint(pthread_sigmask(SIG_BLOCK, &sigchld_sigmask,

7117

NULL), ==, 0);

7118

7119

/* Act; i.e. run the restore_sigmask() function */

7120

g_assert_true(restore_sigmask(&orig_sigmask));

7121

7122

/* Retrieve the newly restored signal mask */

7123

sigset_t restored_sigmask;

7124

g_assert_cmpint(pthread_sigmask(-1, NULL, &restored_sigmask),

7125

==, 0);

7126

7127

/* Check the restored_sigmask; it should be the same as the

7128

previously saved signal mask "orig_sigmask". */

7129

for(int signum = 1; signum < NSIG; signum++){

7130

const int orig_block_state = sigismember(&orig_sigmask, signum);

7131

g_assert_cmpint(orig_block_state, >=, 0);

7132

const int restored_block_state = sigismember(&restored_sigmask,

7133

signum);

7134

g_assert_cmpint(restored_block_state, >=, 0);

7135

g_assert_cmpint(restored_block_state, ==, orig_block_state);

7136

}

7137

7138

/* Restore signal mask */

7139

g_assert_cmpint(pthread_sigmask(SIG_SETMASK, &orig_sigmask,

7140

NULL), ==, 0);

7141

}

7142

7143

static void test_parse_arguments_noargs(__attribute__((unused))

7144

test_fixture *fixture,

7145

__attribute__((unused))

7146

gconstpointer user_data){

7147

char *argv[] = {

7148

strdup("prgname"),

7149

NULL };

7150

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7151

7152

char *agent_directory = NULL;

7153

char *helper_directory = NULL;

7154

uid_t user = 0;

7155

gid_t group = 0;

7156

char *mandos_argz = NULL;

7157

size_t mandos_argz_length = 0;

7158

7159

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7160

&helper_directory, &user, &group,

7161

&mandos_argz, &mandos_argz_length));

7162

g_assert_null(agent_directory);

7163

g_assert_null(helper_directory);

7164

g_assert_true(user == 0);

7165

g_assert_true(group == 0);

7166

g_assert_null(mandos_argz);

7167

g_assert_true(mandos_argz_length == 0);

7168

7169

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

7170

free(*arg);

7171

}

7172

}

7173

7174

__attribute__((nonnull))

7175

static bool parse_arguments_devnull(int argc, char *argv[],

7176

const bool exit_failure,

7177

char **agent_directory,

7178

char **helper_directory,

7179

uid_t *const user,

7180

gid_t *const group,

7181

char **mandos_argz,

7182

size_t *mandos_argz_length){

7183

7184

FILE *real_stderr = stderr;

7185

FILE *devnull = fopen("/dev/null", "we");

7186

g_assert_nonnull(devnull);

7187

stderr = devnull;

7188

7189

const bool ret = parse_arguments(argc, argv, exit_failure,

7190

agent_directory,

7191

helper_directory, user, group,

7192

mandos_argz, mandos_argz_length);

7193

const error_t saved_errno = errno;

7194

7195

stderr = real_stderr;

7196

g_assert_cmpint(fclose(devnull), ==, 0);

7197

7198

errno = saved_errno;

7199

7200

return ret;

7201

}

7202

7203

static void test_parse_arguments_invalid(__attribute__((unused))

7204

test_fixture *fixture,

7205

__attribute__((unused))

7206

gconstpointer user_data){

7207

char *argv[] = {

7208

strdup("prgname"),

7209

strdup("--invalid"),

7210

NULL };

7211

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7212

7213

char *agent_directory = NULL;

7214

char *helper_directory = NULL;

7215

uid_t user = 0;

7216

gid_t group = 0;

7217

char *mandos_argz = NULL;

7218

size_t mandos_argz_length = 0;

7219

7220

g_assert_false(parse_arguments_devnull(argc, argv, false,

7221

&agent_directory,

7222

&helper_directory, &user,

7223

&group, &mandos_argz,

7224

&mandos_argz_length));

7225

7226

g_assert_true(errno == EINVAL);

7227

g_assert_null(agent_directory);

7228

g_assert_null(helper_directory);

7229

g_assert_null(mandos_argz);

7230

g_assert_true(mandos_argz_length == 0);

7231

7232

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

7233

free(*arg);

7234

}

7235

}

7236

7237

static void test_parse_arguments_long_dir(__attribute__((unused))

7238

test_fixture *fixture,

7239

__attribute__((unused))

7240

gconstpointer user_data){

7241

char *argv[] = {

7242

strdup("prgname"),

7243

strdup("--agent-directory"),

7244

strdup("/tmp"),

7245

NULL };

7246

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7247

7248

__attribute__((cleanup(cleanup_string)))

7249

char *agent_directory = NULL;

7250

char *helper_directory = NULL;

7251

uid_t user = 0;

7252

gid_t group = 0;

7253

__attribute__((cleanup(cleanup_string)))

7254

char *mandos_argz = NULL;

7255

size_t mandos_argz_length = 0;

7256

7257

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7258

&helper_directory, &user, &group,

7259

&mandos_argz, &mandos_argz_length));

7260

7261

g_assert_cmpstr(agent_directory, ==, "/tmp");

7262

g_assert_null(helper_directory);

7263

g_assert_true(user == 0);

7264

g_assert_true(group == 0);

7265

g_assert_null(mandos_argz);

7266

g_assert_true(mandos_argz_length == 0);

7267

7268

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

7269

free(*arg);

7270

}

7271

}

7272

7273

static void test_parse_arguments_short_dir(__attribute__((unused))

7274

test_fixture *fixture,

7275

__attribute__((unused))

7276

gconstpointer user_data){

7277

char *argv[] = {

7278

strdup("prgname"),

7279

strdup("-d"),

7280

strdup("/tmp"),

7281

NULL };

7282

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7283

7284

__attribute__((cleanup(cleanup_string)))

7285

char *agent_directory = NULL;

7286

char *helper_directory = NULL;

7287

uid_t user = 0;

7288

gid_t group = 0;

7289

__attribute__((cleanup(cleanup_string)))

7290

char *mandos_argz = NULL;

7291

size_t mandos_argz_length = 0;

7292

7293

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7294

&helper_directory, &user, &group,

7295

&mandos_argz, &mandos_argz_length));

7296

7297

g_assert_cmpstr(agent_directory, ==, "/tmp");

7298

g_assert_null(helper_directory);

7299

g_assert_true(user == 0);

7300

g_assert_true(group == 0);

7301

g_assert_null(mandos_argz);

7302

g_assert_true(mandos_argz_length == 0);

7303

7304

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

7305

free(*arg);

7306

}

7307

}

7308

7309

static

7310

void test_parse_arguments_helper_directory(__attribute__((unused))

7311

test_fixture *fixture,

7312

__attribute__((unused))

7313

gconstpointer user_data){

7314

char *argv[] = {

7315

strdup("prgname"),

7316

strdup("--helper-directory"),

7317

strdup("/tmp"),

7318

NULL };

7319

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7320

7321

char *agent_directory = NULL;

7322

__attribute__((cleanup(cleanup_string)))

7323

char *helper_directory = NULL;

7324

uid_t user = 0;

7325

gid_t group = 0;

7326

__attribute__((cleanup(cleanup_string)))

7327

char *mandos_argz = NULL;

7328

size_t mandos_argz_length = 0;

7329

7330

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7331

&helper_directory, &user, &group,

7332

&mandos_argz, &mandos_argz_length));

7333

7334

g_assert_cmpstr(helper_directory, ==, "/tmp");

7335

g_assert_null(agent_directory);

7336

g_assert_true(user == 0);

7337

g_assert_true(group == 0);

7338

g_assert_null(mandos_argz);

7339

g_assert_true(mandos_argz_length == 0);

7340

7341

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

7342

free(*arg);

7343

}

7344

}

7345

7346

static

7347

void test_parse_arguments_plugin_helper_dir(__attribute__((unused))

7348

test_fixture *fixture,

7349

__attribute__((unused))

7350

gconstpointer user_data){

7351

char *argv[] = {

7352

strdup("prgname"),

7353

strdup("--plugin-helper-dir"),

7354

strdup("/tmp"),

7355

NULL };

7356

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7357

7358

char *agent_directory = NULL;

7359

__attribute__((cleanup(cleanup_string)))

7360

char *helper_directory = NULL;

7361

uid_t user = 0;

7362

gid_t group = 0;

7363

__attribute__((cleanup(cleanup_string)))

7364

char *mandos_argz = NULL;

7365

size_t mandos_argz_length = 0;

7366

7367

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7368

&helper_directory, &user, &group,

7369

&mandos_argz, &mandos_argz_length));

7370

7371

g_assert_cmpstr(helper_directory, ==, "/tmp");

7372

g_assert_null(agent_directory);

7373

g_assert_true(user == 0);

7374

g_assert_true(group == 0);

7375

g_assert_null(mandos_argz);

7376

g_assert_true(mandos_argz_length == 0);

7377

7378

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

7379

free(*arg);

7380

}

7381

}

7382

7383

static void test_parse_arguments_user(__attribute__((unused))

7384

test_fixture *fixture,

7385

__attribute__((unused))

7386

gconstpointer user_data){

7387

char *argv[] = {

7388

strdup("prgname"),

7389

strdup("--user"),

7390

strdup("1000"),

7391

NULL };

7392

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7393

7394

char *agent_directory = NULL;

7395

__attribute__((cleanup(cleanup_string)))

7396

char *helper_directory = NULL;

7397

uid_t user = 0;

7398

gid_t group = 0;

7399

__attribute__((cleanup(cleanup_string)))

7400

char *mandos_argz = NULL;

7401

size_t mandos_argz_length = 0;

7402

7403

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7404

&helper_directory, &user, &group,

7405

&mandos_argz, &mandos_argz_length));

7406

7407

g_assert_null(helper_directory);

7408

g_assert_null(agent_directory);

7409

g_assert_cmpuint((unsigned int)user, ==, 1000);

7410

g_assert_true(group == 0);

7411

g_assert_null(mandos_argz);

7412

g_assert_true(mandos_argz_length == 0);

7413

7414

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

7415

free(*arg);

7416

}

7417

}

7418

7419

static void test_parse_arguments_user_invalid(__attribute__((unused))

7420

test_fixture *fixture,

7421

__attribute__((unused))

7422

gconstpointer

7423

user_data){

7424

char *argv[] = {

7425

strdup("prgname"),

7426

strdup("--user"),

7427

strdup("invalid"),

7428

NULL };

7429

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7430

7431

char *agent_directory = NULL;

7432

__attribute__((cleanup(cleanup_string)))

7433

char *helper_directory = NULL;

7434

uid_t user = 0;

7435

gid_t group = 0;

7436

__attribute__((cleanup(cleanup_string)))

7437

char *mandos_argz = NULL;

7438

size_t mandos_argz_length = 0;

7439

7440

g_assert_false(parse_arguments_devnull(argc, argv, false,

7441

&agent_directory,

7442

&helper_directory, &user,

7443

&group, &mandos_argz,

7444

&mandos_argz_length));

7445

7446

g_assert_null(helper_directory);

7447

g_assert_null(agent_directory);

7448

g_assert_cmpuint((unsigned int)user, ==, 0);

7449

g_assert_true(group == 0);

7450

g_assert_null(mandos_argz);

7451

g_assert_true(mandos_argz_length == 0);

7452

7453

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

7454

free(*arg);

7455

}

7456

}

7457

7458

static

7459

void test_parse_arguments_user_zero_invalid(__attribute__((unused))

7460

test_fixture *fixture,

7461

__attribute__((unused))

7462

gconstpointer user_data){

7463

char *argv[] = {

7464

strdup("prgname"),

7465

strdup("--user"),

7466

strdup("0"),

7467

NULL };

7468

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7469

7470

char *agent_directory = NULL;

7471

__attribute__((cleanup(cleanup_string)))

7472

char *helper_directory = NULL;

7473

uid_t user = 0;

7474

gid_t group = 0;

7475

__attribute__((cleanup(cleanup_string)))

7476

char *mandos_argz = NULL;

7477

size_t mandos_argz_length = 0;

7478

7479

g_assert_false(parse_arguments_devnull(argc, argv, false,

7480

&agent_directory,

7481

&helper_directory, &user,

7482

&group, &mandos_argz,

7483

&mandos_argz_length));

7484

7485

g_assert_null(helper_directory);

7486

g_assert_null(agent_directory);

7487

g_assert_cmpuint((unsigned int)user, ==, 0);

7488

g_assert_true(group == 0);

7489

g_assert_null(mandos_argz);

7490

g_assert_true(mandos_argz_length == 0);

7491

7492

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

7493

free(*arg);

7494

}

7495

}

7496

7497

static void test_parse_arguments_group(__attribute__((unused))

7498

test_fixture *fixture,

7499

__attribute__((unused))

7500

gconstpointer user_data){

7501

char *argv[] = {

7502

strdup("prgname"),

7503

strdup("--group"),

7504

strdup("1000"),

7505

NULL };

7506

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7507

7508

char *agent_directory = NULL;

7509

__attribute__((cleanup(cleanup_string)))

7510

char *helper_directory = NULL;

7511

uid_t user = 0;

7512

gid_t group = 0;

7513

__attribute__((cleanup(cleanup_string)))

7514

char *mandos_argz = NULL;

7515

size_t mandos_argz_length = 0;

7516

7517

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7518

&helper_directory, &user, &group,

7519

&mandos_argz, &mandos_argz_length));

7520

7521

g_assert_null(helper_directory);

7522

g_assert_null(agent_directory);

7523

g_assert_true(user == 0);

7524

g_assert_cmpuint((unsigned int)group, ==, 1000);

7525

g_assert_null(mandos_argz);

7526

g_assert_true(mandos_argz_length == 0);

7527

7528

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

7529

free(*arg);

7530

}

7531

}

7532

7533

static void test_parse_arguments_group_invalid(__attribute__((unused))

7534

test_fixture *fixture,

7535

__attribute__((unused))

7536

gconstpointer

7537

user_data){

7538

char *argv[] = {

7539

strdup("prgname"),

7540

strdup("--group"),

7541

strdup("invalid"),

7542

NULL };

7543

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7544

7545

char *agent_directory = NULL;

7546

__attribute__((cleanup(cleanup_string)))

7547

char *helper_directory = NULL;

7548

uid_t user = 0;

7549

gid_t group = 0;

7550

__attribute__((cleanup(cleanup_string)))

7551

char *mandos_argz = NULL;

7552

size_t mandos_argz_length = 0;

7553

7554

g_assert_false(parse_arguments_devnull(argc, argv, false,

7555

&agent_directory,

7556

&helper_directory, &user,

7557

&group, &mandos_argz,

7558

&mandos_argz_length));

7559

7560

g_assert_null(helper_directory);

7561

g_assert_null(agent_directory);

7562

g_assert_true(user == 0);

7563

g_assert_true(group == 0);

7564

g_assert_null(mandos_argz);

7565

g_assert_true(mandos_argz_length == 0);

7566

7567

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

7568

free(*arg);

7569

}

7570

}

7571

7572

static

7573

void test_parse_arguments_group_zero_invalid(__attribute__((unused))

7574

test_fixture *fixture,

7575

__attribute__((unused))

7576

gconstpointer user_data){

7577

char *argv[] = {

7578

strdup("prgname"),

7579

strdup("--group"),

7580

strdup("0"),

7581

NULL };

7582

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7583

7584

char *agent_directory = NULL;

7585

__attribute__((cleanup(cleanup_string)))

7586

char *helper_directory = NULL;

7587

uid_t user = 0;

7588

gid_t group = 0;

7589

__attribute__((cleanup(cleanup_string)))

7590

char *mandos_argz = NULL;

7591

size_t mandos_argz_length = 0;

7592

7593

g_assert_false(parse_arguments_devnull(argc, argv, false,

7594

&agent_directory,

7595

&helper_directory, &user,

7596

&group, &mandos_argz,

7597

&mandos_argz_length));

7598

7599

g_assert_null(helper_directory);

7600

g_assert_null(agent_directory);

7601

g_assert_cmpuint((unsigned int)group, ==, 0);

7602

g_assert_true(group == 0);

7603

g_assert_null(mandos_argz);

7604

g_assert_true(mandos_argz_length == 0);

7605

7606

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

7607

free(*arg);

7608

}

7609

}

7610

7611

static void test_parse_arguments_mandos_noargs(__attribute__((unused))

7612

test_fixture *fixture,

7613

__attribute__((unused))

7614

gconstpointer

7615

user_data){

7616

char *argv[] = {

7617

strdup("prgname"),

7618

strdup("mandos-client"),

7619

NULL };

7620

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7621

7622

__attribute__((cleanup(cleanup_string)))

7623

char *agent_directory = NULL;

7624

__attribute__((cleanup(cleanup_string)))

7625

char *helper_directory = NULL;

7626

uid_t user = 0;

7627

gid_t group = 0;

7628

__attribute__((cleanup(cleanup_string)))

7629

char *mandos_argz = NULL;

7630

size_t mandos_argz_length = 0;

7631

7632

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7633

&helper_directory, &user, &group,

7634

&mandos_argz, &mandos_argz_length));

7635

7636

g_assert_null(agent_directory);

7637

g_assert_null(helper_directory);

7638

g_assert_true(user == 0);

7639

g_assert_true(group == 0);

7640

g_assert_cmpstr(mandos_argz, ==, "mandos-client");

7641

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7642

mandos_argz_length),

7643

==, 1);

7644

7645

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

7646

free(*arg);

7647

}

7648

}

7649

7650

static void test_parse_arguments_mandos_args(__attribute__((unused))

7651

test_fixture *fixture,

7652

__attribute__((unused))

7653

gconstpointer user_data){

7654

char *argv[] = {

7655

strdup("prgname"),

7656

strdup("mandos-client"),

7657

strdup("one"),

7658

strdup("two"),

7659

strdup("three"),

7660

NULL };

7661

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7662

7663

__attribute__((cleanup(cleanup_string)))

7664

char *agent_directory = NULL;

7665

__attribute__((cleanup(cleanup_string)))

7666

char *helper_directory = NULL;

7667

uid_t user = 0;

7668

gid_t group = 0;

7669

__attribute__((cleanup(cleanup_string)))

7670

char *mandos_argz = NULL;

7671

size_t mandos_argz_length = 0;

7672

7673

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7674

&helper_directory, &user, &group,

7675

&mandos_argz, &mandos_argz_length));

7676

7677

g_assert_null(agent_directory);

7678

g_assert_null(helper_directory);

7679

g_assert_true(user == 0);

7680

g_assert_true(group == 0);

7681

char *marg = mandos_argz;

7682

g_assert_cmpstr(marg, ==, "mandos-client");

7683

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7684

g_assert_cmpstr(marg, ==, "one");

7685

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7686

g_assert_cmpstr(marg, ==, "two");

7687

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7688

g_assert_cmpstr(marg, ==, "three");

7689

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7690

mandos_argz_length),

7691

==, 4);

7692

7693

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

7694

free(*arg);

7695

}

7696

}

7697

7698

static void test_parse_arguments_all_args(__attribute__((unused))

7699

test_fixture *fixture,

7700

__attribute__((unused))

7701

gconstpointer user_data){

7702

char *argv[] = {

7703

strdup("prgname"),

7704

strdup("--agent-directory"),

7705

strdup("/tmp"),

7706

strdup("--helper-directory"),

7707

strdup("/var/tmp"),

7708

strdup("--user"),

7709

strdup("1"),

7710

strdup("--group"),

7711

strdup("2"),

7712

strdup("mandos-client"),

7713

strdup("one"),

7714

strdup("two"),

7715

strdup("three"),

7716

NULL };

7717

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7718

7719

__attribute__((cleanup(cleanup_string)))

7720

char *agent_directory = NULL;

7721

__attribute__((cleanup(cleanup_string)))

7722

char *helper_directory = NULL;

7723

uid_t user = 0;

7724

gid_t group = 0;

7725

__attribute__((cleanup(cleanup_string)))

7726

char *mandos_argz = NULL;

7727

size_t mandos_argz_length = 0;

7728

7729

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7730

&helper_directory, &user, &group,

7731

&mandos_argz, &mandos_argz_length));

7732

7733

g_assert_cmpstr(agent_directory, ==, "/tmp");

7734

g_assert_cmpstr(helper_directory, ==, "/var/tmp");

7735

g_assert_true(user == 1);

7736

g_assert_true(group == 2);

7737

char *marg = mandos_argz;

7738

g_assert_cmpstr(marg, ==, "mandos-client");

7739

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7740

g_assert_cmpstr(marg, ==, "one");

7741

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7742

g_assert_cmpstr(marg, ==, "two");

7743

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7744

g_assert_cmpstr(marg, ==, "three");

7745

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7746

mandos_argz_length),

7747

==, 4);

7748

7749

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

7750

free(*arg);

7751

}

7752

}

7753

7754

static void test_parse_arguments_mixed(__attribute__((unused))

7755

test_fixture *fixture,

7756

__attribute__((unused))

7757

gconstpointer user_data){

7758

char *argv[] = {

7759

strdup("prgname"),

7760

strdup("mandos-client"),

7761

strdup("--user"),

7762

strdup("1"),

7763

strdup("one"),

7764

strdup("--agent-directory"),

7765

strdup("/tmp"),

7766

strdup("two"),

7767

strdup("three"),

7768

strdup("--helper-directory=/var/tmp"),

7769

NULL };

7770

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7771

7772

__attribute__((cleanup(cleanup_string)))

7773

char *agent_directory = NULL;

7774

__attribute__((cleanup(cleanup_string)))

7775

char *helper_directory = NULL;

7776

uid_t user = 0;

7777

gid_t group = 0;

7778

__attribute__((cleanup(cleanup_string)))

7779

char *mandos_argz = NULL;

7780

size_t mandos_argz_length = 0;

7781

7782

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7783

&helper_directory, &user, &group,

7784

&mandos_argz, &mandos_argz_length));

7785

7786

g_assert_cmpstr(agent_directory, ==, "/tmp");

7787

g_assert_cmpstr(helper_directory, ==, "/var/tmp");

7788

g_assert_true(user == 1);

7789

g_assert_true(group == 0);

7790

char *marg = mandos_argz;

7791

g_assert_cmpstr(marg, ==, "mandos-client");

7792

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7793

g_assert_cmpstr(marg, ==, "one");

7794

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7795

g_assert_cmpstr(marg, ==, "two");

7796

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7797

g_assert_cmpstr(marg, ==, "three");

7798

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7799

mandos_argz_length),

7800

==, 4);

7801

7802

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

7803

free(*arg);

7804

}

7805

}

7806

7807

/* End of tests section */

7808

7809

/* Test boilerplate section; New tests should be added to the test

7810

suite definition here, in the "run_tests" function.

7811

7812

Finally, this section also contains the should_only_run_tests()

7813

function used by main() for deciding if tests should be run or to

7814

start normally. */

7815

7816

__attribute__((cold))

7817

static bool run_tests(int argc, char *argv[]){

7818

g_test_init(&argc, &argv, NULL);

7819

7820

/* A macro to add a test with no setup or teardown functions */

7821

#define test_add(testpath, testfunc) \

7822

do { \

7823

g_test_add((testpath), test_fixture, NULL, NULL, \

7824

(testfunc), NULL); \

7825

} while(false)

7826

7827

/* Test the signal-related functions first, since some other tests

7828

depend on these functions in their setups and teardowns */

7829

test_add("/signal-handling/setup", test_setup_signal_handler);

7830

test_add("/signal-handling/restore", test_restore_signal_handler);

7831

test_add("/signal-handling/block", test_block_sigchld);

7832

test_add("/signal-handling/restore-sigmask", test_restore_sigmask);

7833

7834

/* Regular non-signal-related tests; these use no setups or

7835

teardowns */

7836

test_add("/parse_arguments/noargs", test_parse_arguments_noargs);

7837

test_add("/parse_arguments/invalid", test_parse_arguments_invalid);

7838

test_add("/parse_arguments/long-dir",

7839

test_parse_arguments_long_dir);

7840

test_add("/parse_arguments/short-dir",

7841

test_parse_arguments_short_dir);

7842

test_add("/parse_arguments/helper-directory",

7843

test_parse_arguments_helper_directory);

7844

test_add("/parse_arguments/plugin-helper-dir",

7845

test_parse_arguments_plugin_helper_dir);

7846

test_add("/parse_arguments/user", test_parse_arguments_user);

7847

test_add("/parse_arguments/user-invalid",

7848

test_parse_arguments_user_invalid);

7849

test_add("/parse_arguments/user-zero-invalid",

7850

test_parse_arguments_user_zero_invalid);

7851

test_add("/parse_arguments/group", test_parse_arguments_group);

7852

test_add("/parse_arguments/group-invalid",

7853

test_parse_arguments_group_invalid);

7854

test_add("/parse_arguments/group-zero-invalid",

7855

test_parse_arguments_group_zero_invalid);

7856

test_add("/parse_arguments/mandos-noargs",

7857

test_parse_arguments_mandos_noargs);

7858

test_add("/parse_arguments/mandos-args",

7859

test_parse_arguments_mandos_args);

7860

test_add("/parse_arguments/all-args",

7861

test_parse_arguments_all_args);

7862

test_add("/parse_arguments/mixed", test_parse_arguments_mixed);

7863

test_add("/queue/create", test_create_queue);

7864

test_add("/queue/add", test_add_to_queue);

7865

test_add("/queue/has_question/empty",

7866

test_queue_has_question_empty);

7867

test_add("/queue/has_question/false",

7868

test_queue_has_question_false);

7869

test_add("/queue/has_question/true", test_queue_has_question_true);

7870

test_add("/queue/has_question/false2",

7871

test_queue_has_question_false2);

7872

test_add("/queue/has_question/true2",

7873

test_queue_has_question_true2);

7874

test_add("/buffer/cleanup", test_cleanup_buffer);

7875

test_add("/string_set/net-set-contains-nothing",

7876

test_string_set_new_set_contains_nothing);

7877

test_add("/string_set/with-added-string-contains-it",

7878

test_string_set_with_added_string_contains_it);

7879

test_add("/string_set/cleared-does-not-contain-string",

7880

test_string_set_cleared_does_not_contain_str);

7881

test_add("/string_set/swap/one-with-empty",

7882

test_string_set_swap_one_with_empty);

7883

test_add("/string_set/swap/empty-with-one",

7884

test_string_set_swap_empty_with_one);

7885

test_add("/string_set/swap/one-with-one",

7886

test_string_set_swap_one_with_one);

7887

7888

/* A macro to add a test using the setup and teardown functions */

7889

#define test_add_st(path, func) \

7890

do { \

7891

g_test_add((path), test_fixture, NULL, test_setup, (func), \

7892

test_teardown); \

7893

} while(false)

7894

7895

/* Signal-related tests; these use setups and teardowns which

7896

establish, during each test run, a signal handler for, and a

7897

signal mask blocking, the SIGCHLD signal, just like main() */

7898

test_add_st("/wait_for_event/timeout", test_wait_for_event_timeout);

7899

test_add_st("/wait_for_event/event", test_wait_for_event_event);

7900

test_add_st("/wait_for_event/sigchld", test_wait_for_event_sigchld);

7901

test_add_st("/run_queue/zeroes-next-run",

7902

test_run_queue_zeroes_next_run);

7903

test_add_st("/run_queue/clears-cancelled_filenames",

7904

test_run_queue_clears_cancelled_filenames);

7905

test_add_st("/run_queue/skips-cancelled-filenames",

7906

test_run_queue_skips_cancelled_filenames);

7907

test_add_st("/run_queue/one-task", test_run_queue_one_task);

7908

test_add_st("/run_queue/two-tasks", test_run_queue_two_tasks);

7909

test_add_st("/run_queue/two-tasks/quit",

7910

test_run_queue_two_tasks_quit);

7911

test_add_st("/run_queue/two-tasks-cleanup",

7912

test_run_queue_two_tasks_cleanup);

7913

test_add_st("/task-creators/start_mandos_client",

7914

test_start_mandos_client);

7915

test_add_st("/task-creators/start_mandos_client/execv",

7916

test_start_mandos_client_execv);

7917

test_add_st("/task-creators/start_mandos_client/suid/euid",

7918

test_start_mandos_client_suid_euid);

7919

test_add_st("/task-creators/start_mandos_client/suid/egid",

7920

test_start_mandos_client_suid_egid);

7921

test_add_st("/task-creators/start_mandos_client/suid/ruid",

7922

test_start_mandos_client_suid_ruid);

7923

test_add_st("/task-creators/start_mandos_client/suid/rgid",

7924

test_start_mandos_client_suid_rgid);

7925

test_add_st("/task-creators/start_mandos_client/read",

7926

test_start_mandos_client_read);

7927

test_add_st("/task-creators/start_mandos_client/helper-directory",

7928

test_start_mandos_client_helper_directory);

7929

test_add_st("/task-creators/start_mandos_client/sigmask",

7930

test_start_mandos_client_sigmask);

7931

test_add_st("/task/wait_for_mandos_client_exit/badpid",

7932

test_wait_for_mandos_client_exit_badpid);

7933

test_add_st("/task/wait_for_mandos_client_exit/noexit",

7934

test_wait_for_mandos_client_exit_noexit);

7935

test_add_st("/task/wait_for_mandos_client_exit/success",

7936

test_wait_for_mandos_client_exit_success);

7937

test_add_st("/task/wait_for_mandos_client_exit/failure",

7938

test_wait_for_mandos_client_exit_failure);

7939

test_add_st("/task/wait_for_mandos_client_exit/killed",

7940

test_wait_for_mandos_client_exit_killed);

7941

test_add_st("/task/read_mandos_client_output/readerror",

7942

test_read_mandos_client_output_readerror);

7943

test_add_st("/task/read_mandos_client_output/nodata",

7944

test_read_mandos_client_output_nodata);

7945

test_add_st("/task/read_mandos_client_output/eof",

7946

test_read_mandos_client_output_eof);

7947

test_add_st("/task/read_mandos_client_output/once",

7948

test_read_mandos_client_output_once);

7949

test_add_st("/task/read_mandos_client_output/malloc",

7950

test_read_mandos_client_output_malloc);

7951

test_add_st("/task/read_mandos_client_output/append",

7952

test_read_mandos_client_output_append);

7953

test_add_st("/task-creators/add_inotify_dir_watch",

7954

test_add_inotify_dir_watch);

7955

test_add_st("/task-creators/add_inotify_dir_watch/fail",

7956

test_add_inotify_dir_watch_fail);

7957

test_add_st("/task-creators/add_inotify_dir_watch/not-a-directory",

7958

test_add_inotify_dir_watch_nondir);

7959

test_add_st("/task-creators/add_inotify_dir_watch/EAGAIN",

7960

test_add_inotify_dir_watch_EAGAIN);

7961

test_add_st("/task-creators/add_inotify_dir_watch/IN_CLOSE_WRITE",

7962

test_add_inotify_dir_watch_IN_CLOSE_WRITE);

7963

test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_TO",

7964

test_add_inotify_dir_watch_IN_MOVED_TO);

7965

test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_FROM",

7966

test_add_inotify_dir_watch_IN_MOVED_FROM);

7967

test_add_st("/task-creators/add_inotify_dir_watch/IN_EXCL_UNLINK",

7968

test_add_inotify_dir_watch_IN_EXCL_UNLINK);

7969

test_add_st("/task-creators/add_inotify_dir_watch/IN_DELETE",

7970

test_add_inotify_dir_watch_IN_DELETE);

7971

test_add_st("/task/read_inotify_event/readerror",

7972

test_read_inotify_event_readerror);

7973

test_add_st("/task/read_inotify_event/bad-epoll",

7974

test_read_inotify_event_bad_epoll);

7975

test_add_st("/task/read_inotify_event/nodata",

7976

test_read_inotify_event_nodata);

7977

test_add_st("/task/read_inotify_event/eof",

7978

test_read_inotify_event_eof);

7979

test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE",

7980

test_read_inotify_event_IN_CLOSE_WRITE);

7981

test_add_st("/task/read_inotify_event/IN_MOVED_TO",

7982

test_read_inotify_event_IN_MOVED_TO);

7983

test_add_st("/task/read_inotify_event/IN_MOVED_FROM",

7984

test_read_inotify_event_IN_MOVED_FROM);

7985

test_add_st("/task/read_inotify_event/IN_DELETE",

7986

test_read_inotify_event_IN_DELETE);

7987

test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE/badname",

7988

test_read_inotify_event_IN_CLOSE_WRITE_badname);

7989

test_add_st("/task/read_inotify_event/IN_MOVED_TO/badname",

7990

test_read_inotify_event_IN_MOVED_TO_badname);

7991

test_add_st("/task/read_inotify_event/IN_MOVED_FROM/badname",

7992

test_read_inotify_event_IN_MOVED_FROM_badname);

7993

test_add_st("/task/read_inotify_event/IN_DELETE/badname",

7994

test_read_inotify_event_IN_DELETE_badname);

7995

test_add_st("/task/open_and_parse_question/ENOENT",

7996

test_open_and_parse_question_ENOENT);

7997

test_add_st("/task/open_and_parse_question/EIO",

7998

test_open_and_parse_question_EIO);

7999

test_add_st("/task/open_and_parse_question/parse-error",

8000

test_open_and_parse_question_parse_error);

8001

test_add_st("/task/open_and_parse_question/nosocket",

8002

test_open_and_parse_question_nosocket);

8003

test_add_st("/task/open_and_parse_question/badsocket",

8004

test_open_and_parse_question_badsocket);

8005

test_add_st("/task/open_and_parse_question/nopid",

8006

test_open_and_parse_question_nopid);

8007

test_add_st("/task/open_and_parse_question/badpid",

8008

test_open_and_parse_question_badpid);

8009

test_add_st("/task/open_and_parse_question/noexist_pid",

8010

test_open_and_parse_question_noexist_pid);

8011

test_add_st("/task/open_and_parse_question/no-notafter",

8012

test_open_and_parse_question_no_notafter);

8013

test_add_st("/task/open_and_parse_question/bad-notafter",

8014

test_open_and_parse_question_bad_notafter);

8015

test_add_st("/task/open_and_parse_question/notafter-0",

8016

test_open_and_parse_question_notafter_0);

8017

test_add_st("/task/open_and_parse_question/notafter-1",

8018

test_open_and_parse_question_notafter_1);

8019

test_add_st("/task/open_and_parse_question/notafter-1-1",

8020

test_open_and_parse_question_notafter_1_1);

8021

test_add_st("/task/open_and_parse_question/notafter-1-2",

8022

test_open_and_parse_question_notafter_1_2);

8023

test_add_st("/task/open_and_parse_question/equal-notafter",

8024

test_open_and_parse_question_equal_notafter);

8025

test_add_st("/task/open_and_parse_question/late-notafter",

8026

test_open_and_parse_question_late_notafter);

8027

test_add_st("/task/cancel_old_question/0-1-2",

8028

test_cancel_old_question_0_1_2);

8029

test_add_st("/task/cancel_old_question/0-2-1",

8030

test_cancel_old_question_0_2_1);

8031

test_add_st("/task/cancel_old_question/1-2-3",

8032

test_cancel_old_question_1_2_3);

8033

test_add_st("/task/cancel_old_question/1-3-2",

8034

test_cancel_old_question_1_3_2);

8035

test_add_st("/task/cancel_old_question/2-1-3",

8036

test_cancel_old_question_2_1_3);

8037

test_add_st("/task/cancel_old_question/2-3-1",

8038

test_cancel_old_question_2_3_1);

8039

test_add_st("/task/cancel_old_question/3-1-2",

8040

test_cancel_old_question_3_1_2);

8041

test_add_st("/task/cancel_old_question/3-2-1",

8042

test_cancel_old_question_3_2_1);

8043

test_add_st("/task/connect_question_socket/name-too-long",

8044

test_connect_question_socket_name_too_long);

8045

test_add_st("/task/connect_question_socket/connect-fail",

8046

test_connect_question_socket_connect_fail);

8047

test_add_st("/task/connect_question_socket/bad-epoll",

8048

test_connect_question_socket_bad_epoll);

8049

test_add_st("/task/connect_question_socket/usable",

8050

test_connect_question_socket_usable);

8051

test_add_st("/task/send_password_to_socket/client-not-exited",

8052

test_send_password_to_socket_client_not_exited);

8053

test_add_st("/task/send_password_to_socket/password-not-read",

8054

test_send_password_to_socket_password_not_read);

8055

test_add_st("/task/send_password_to_socket/EMSGSIZE",

8056

test_send_password_to_socket_EMSGSIZE);

8057

test_add_st("/task/send_password_to_socket/retry",

8058

test_send_password_to_socket_retry);

8059

test_add_st("/task/send_password_to_socket/bad-epoll",

8060

test_send_password_to_socket_bad_epoll);

8061

test_add_st("/task/send_password_to_socket/null-password",

8062

test_send_password_to_socket_null_password);

8063

test_add_st("/task/send_password_to_socket/empty-password",

8064

test_send_password_to_socket_empty_password);

8065

test_add_st("/task/send_password_to_socket/empty-str-password",

8066

test_send_password_to_socket_empty_str_pass);

8067

test_add_st("/task/send_password_to_socket/text-password",

8068

test_send_password_to_socket_text_password);

8069

test_add_st("/task/send_password_to_socket/binary-password",

8070

test_send_password_to_socket_binary_password);

8071

test_add_st("/task/send_password_to_socket/nuls-in-password",

8072

test_send_password_to_socket_nuls_in_password);

8073

test_add_st("/task-creators/add_existing_questions/ENOENT",

8074

test_add_existing_questions_ENOENT);

8075

test_add_st("/task-creators/add_existing_questions/no-questions",

8076

test_add_existing_questions_no_questions);

8077

test_add_st("/task-creators/add_existing_questions/one-question",

8078

test_add_existing_questions_one_question);

8079

test_add_st("/task-creators/add_existing_questions/two-questions",

8080

test_add_existing_questions_two_questions);

8081

test_add_st("/task-creators/add_existing_questions/non-questions",

8082

test_add_existing_questions_non_questions);

8083

test_add_st("/task-creators/add_existing_questions/both-types",

8084

test_add_existing_questions_both_types);

8085

8086

return g_test_run() == 0;

8087

}

8088

8089

static bool should_only_run_tests(int *argc_p, char **argv_p[]){

8090

GOptionContext *context = g_option_context_new("");

8091

8092

g_option_context_set_help_enabled(context, FALSE);

8093

g_option_context_set_ignore_unknown_options(context, TRUE);

8094

8095

gboolean run_tests = FALSE;

8096

GOptionEntry entries[] = {

8097

{ "test", 0, 0, G_OPTION_ARG_NONE,

8098

&run_tests, "Run tests", NULL },

8099

{ NULL }

8100

};

8101

g_option_context_add_main_entries(context, entries, NULL);

8102

8103

GError *error = NULL;

8104

8105

if(g_option_context_parse(context, argc_p, argv_p, &error) != TRUE){

8106

g_option_context_free(context);

8107

g_error("Failed to parse options: %s", error->message);

8108

}

8109

8110

g_option_context_free(context);

8111

return run_tests != FALSE;

8112

}