/mandos/release : revision 322

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, EEXIST,

52

ECHILD, EPERM, ENOMEM, EAGAIN,

53

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

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_DELETE, struct inotify_event */

95

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

96

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

97

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

98

ferror(), fclose(), stderr,

99

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

100

fscanf() */

101

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

102

GError, g_key_file_load_from_file(),

103

G_KEY_FILE_NONE, TRUE, G_FILE_ERROR_NOENT,

104

g_key_file_get_string(), guint64,

105

g_key_file_get_uint64(),

106

G_KEY_FILE_ERROR_KEY_NOT_FOUND, gconstpointer,

107

g_assert_true(), g_assert_nonnull(),

108

g_assert_null(), g_assert_false(),

109

g_assert_cmpint(), g_assert_cmpuint(),

110

g_test_skip(), g_assert_cmpstr(),

111

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

112

GOptionContext, g_option_context_new(),

113

g_option_context_set_help_enabled(), FALSE,

114

g_option_context_set_ignore_unknown_options(),

115

gboolean, GOptionEntry, G_OPTION_ARG_NONE,

116

g_option_context_add_main_entries(),

117

g_option_context_parse(),

118

g_option_context_free(), g_error() */

119

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

120

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

121

SOCK_DGRAM, SOCK_NONBLOCK,

122

SOCK_CLOEXEC, connect(),

123

struct sockaddr, socklen_t,

124

shutdown(), SHUT_RD, send(),

125

MSG_NOSIGNAL, bind(), recv(),

126

socketpair() */

127

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

128

GLOB_ERR, GLOB_NOSORT, GLOB_MARK,

129

GLOB_ABORTED, GLOB_NOMATCH,

130

GLOB_NOSPACE */

131

132

/* End of includes */

133

134

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

135

136

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

137

typedef uintmax_t mono_microsecs;

138

139

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

140

typedef struct {

141

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

142

size_t length; /* Number of tasks */

143

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

144

size_t allocated;

145

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

146

mono_microsecs next_run;

147

} __attribute__((designated_init)) task_queue;

148

149

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

150

151

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

152

this type */

153

typedef void (task_func) (const struct task_struct,

154

task_queue *const)

155

__attribute__((nonnull));

156

157

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

158

159

Used for the "password" variable */

160

typedef struct {

161

char *data;

162

size_t length;

163

size_t allocated;

164

} __attribute__((designated_init)) buffer;

165

166

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

167

168

Used by the "cancelled_filenames" variable */

169

typedef struct {

170

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

171

size_t argz_len; /* the string_set_* functions */

172

} __attribute__((designated_init)) string_set;

173

174

/* "task_context" - local variables for tasks

175

176

This data structure distinguishes between different tasks which are

177

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

178

task function when each task is run.

179

180

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

181

typedef struct task_struct {

182

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

183

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

184

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

185

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

186

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

187

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

188

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

189

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

190

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

191

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

192

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

193

been cancelled for any reason; tasks pertaining to these question

194

files should not be run */

195

string_set *const cancelled_filenames;

196

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

197

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

198

const mono_microsecs *const current_time;

199

} __attribute__((designated_init)) task_context;

200

201

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

202

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

203

declared in the test section. */

204

__attribute__((warn_unused_result))

205

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

206

__attribute__((warn_unused_result, cold))

207

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

208

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

209

__attribute__((warn_unused_result, malloc))

210

task_queue *create_queue(void);

211

__attribute__((nonnull, warn_unused_result))

212

bool add_to_queue(task_queue *const, const task_context);

213

__attribute__((nonnull))

214

void cleanup_task(const task_context *const);

215

__attribute__((nonnull))

216

void cleanup_queue(task_queue *const *const);

217

__attribute__((pure, nonnull, warn_unused_result))

218

bool queue_has_question(const task_queue *const);

219

__attribute__((nonnull))

220

void cleanup_close(const int *const);

221

__attribute__((nonnull))

222

void cleanup_string(char *const *const);

223

__attribute__((nonnull))

224

void cleanup_buffer(buffer *const);

225

__attribute__((pure, nonnull, warn_unused_result))

226

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

227

__attribute__((nonnull, warn_unused_result))

228

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

229

__attribute__((nonnull))

230

void string_set_clear(string_set *);

231

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

232

__attribute__((nonnull, warn_unused_result))

233

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

234

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

235

const struct sigaction *const,

236

const sigset_t, const char *const,

237

const uid_t, const gid_t,

238

const char *const *const);

239

__attribute__((nonnull))

240

task_func wait_for_mandos_client_exit;

241

__attribute__((nonnull))

242

task_func read_mandos_client_output;

243

__attribute__((warn_unused_result))

244

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

245

buffer *const, const char *const,

246

string_set *, const mono_microsecs *const,

247

bool *const, bool *const);

248

__attribute__((nonnull))

249

task_func read_inotify_event;

250

__attribute__((nonnull))

251

task_func open_and_parse_question;

252

__attribute__((nonnull))

253

task_func cancel_old_question;

254

__attribute__((nonnull))

255

task_func connect_question_socket;

256

__attribute__((nonnull))

257

task_func send_password_to_socket;

258

__attribute__((warn_unused_result))

259

bool add_existing_questions(task_queue *const, const int,

260

buffer *const, string_set *,

261

const mono_microsecs *const,

262

bool *const, bool *const,

263

const char *const);

264

__attribute__((nonnull, warn_unused_result))

265

bool wait_for_event(const int, const mono_microsecs,

266

const mono_microsecs);

267

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

268

bool clear_all_fds_from_epoll_set(const int);

269

mono_microsecs get_current_time(void);

270

__attribute__((nonnull, warn_unused_result))

271

bool setup_signal_handler(struct sigaction *const);

272

__attribute__((nonnull))

273

bool restore_signal_handler(const struct sigaction *const);

274

__attribute__((nonnull, warn_unused_result))

275

bool block_sigchld(sigset_t *const);

276

__attribute__((nonnull))

277

bool restore_sigmask(const sigset_t *const);

278

__attribute__((nonnull))

279

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

280

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

281

282

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

283

284

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

285

286

Code here should be as simple as possible. */

287

288

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

289

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

290

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

291

292

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

293

294

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

295

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

296

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

297

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

298

if(run_tests(argc, argv)){

299

return EXIT_SUCCESS; /* All tests successful */

300

}

301

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

302

}

303

304

__attribute__((cleanup(cleanup_string)))

305

char *agent_directory = NULL;

306

307

__attribute__((cleanup(cleanup_string)))

308

char *helper_directory = NULL;

309

310

uid_t user = 0;

311

gid_t group = 0;

312

313

__attribute__((cleanup(cleanup_string)))

314

char *mandos_argz = NULL;

315

size_t mandos_argz_length = 0;

316

317

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

318

&helper_directory, &user, &group,

319

&mandos_argz, &mandos_argz_length)){

320

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

321

argument to parse_arguments() above, which should make

322

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

323

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

324

}

325

326

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

327

const char default_helper_directory[]

328

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

329

const char *const default_argv[]

330

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

331

332

/* Set variables to default values if unset */

333

if(agent_directory == NULL){

334

agent_directory = strdup(default_agent_directory);

335

if(agent_directory == NULL){

336

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

337

}

338

}

339

if(helper_directory == NULL){

340

helper_directory = strdup(default_helper_directory);

341

if(helper_directory == NULL){

342

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

343

}

344

}

345

if(user == 0){

346

user = 65534; /* nobody */

347

}

348

if(group == 0){

349

group = 65534; /* nogroup */

350

}

351

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

352

default values */

353

if(mandos_argz == NULL){

354

#ifdef __GNUC__

355

#pragma GCC diagnostic push

356

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

357

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

358

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

359

#pragma GCC diagnostic ignored "-Wcast-qual"

360

#endif

361

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

362

&mandos_argz_length);

363

#ifdef __GNUC__

364

#pragma GCC diagnostic pop

365

#endif

366

if(errno != 0){

367

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

368

}

369

}

370

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

371

372

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

373

mandos_argz_length)

374

+ 1) * sizeof(char *));

375

if(mandos_argv == NULL){

376

error_t saved_errno = errno;

377

free(mandos_argz);

378

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

379

}

380

argz_extract(mandos_argz, mandos_argz_length, mandos_argv);

381

382

sigset_t orig_sigmask;

383

if(not block_sigchld(&orig_sigmask)){

384

return EX_OSERR;

385

}

386

387

struct sigaction old_sigchld_action;

388

if(not setup_signal_handler(&old_sigchld_action)){

389

return EX_OSERR;

390

}

391

392

mono_microsecs current_time = 0;

393

394

bool mandos_client_exited = false;

395

bool quit_now = false;

396

__attribute__((cleanup(cleanup_close)))

397

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

398

if(epoll_fd < 0){

399

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

400

}

401

__attribute__((cleanup(cleanup_queue)))

402

task_queue *queue = create_queue();

403

if(queue == NULL){

404

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

405

}

406

407

__attribute__((cleanup(cleanup_buffer)))

408

buffer password = {};

409

bool password_is_read = false;

410

411

__attribute__((cleanup(string_set_clear)))

412

string_set cancelled_filenames = {};

413

414

/* Add tasks to queue */

415

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

416

&quit_now, &password, &password_is_read,

417

&old_sigchld_action, orig_sigmask,

418

helper_directory, user, group,

419

(const char *const *)mandos_argv)){

420

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

421

}

422

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

423

needed anymore */

424

free(mandos_argv);

425

free(mandos_argz);

426

mandos_argz = NULL;

427

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

428

agent_directory, &cancelled_filenames,

429

&current_time, &mandos_client_exited,

430

&password_is_read)){

431

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

432

case EACCES:

433

case ENAMETOOLONG:

434

case ENOENT:

435

case ENOTDIR:

436

return EX_OSFILE;

437

default:

438

return EX_OSERR;

439

}

440

}

441

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

442

&cancelled_filenames, &current_time,

443

&mandos_client_exited,

444

&password_is_read, agent_directory)){

445

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

446

}

447

448

/* Run queue */

449

do {

450

current_time = get_current_time();

451

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

452

const error_t saved_errno = errno;

453

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

454

" events");

455

}

456

457

current_time = get_current_time();

458

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

459

const error_t saved_errno = errno;

460

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

461

}

462

463

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

464

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

465

} while(queue_has_question(queue));

466

467

restore_signal_handler(&old_sigchld_action);

468

restore_sigmask(&orig_sigmask);

469

470

return EXIT_SUCCESS;

471

}

472

473

__attribute__((warn_unused_result))

474

mono_microsecs get_current_time(void){

475

struct timespec currtime;

476

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

477

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

478

return 0;

479

}

480

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

481

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

482

}

483

484

/* End of "main" section */

485

486

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

487

488

__attribute__((nonnull))

489

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

490

char **agent_directory, char **helper_directory,

491

uid_t *const user, gid_t *const group,

492

char **mandos_argz, size_t *mandos_argz_length){

493

494

const struct argp_option options[] = {

495

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

496

.doc="Systemd password agent directory" },

497

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

498

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

499

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

500

.flags=OPTION_HIDDEN | OPTION_ALIAS },

501

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

502

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

503

" user" },

504

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

505

.flags=OPTION_HIDDEN | OPTION_ALIAS },

506

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

507

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

508

" group" },

509

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

510

.flags=OPTION_HIDDEN | OPTION_ALIAS },

511

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

512

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

513

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

514

{ NULL },

515

};

516

517

__attribute__((nonnull(3)))

518

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

519

errno = 0;

520

switch(key){

521

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

522

*agent_directory = strdup(arg);

523

break;

524

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

525

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

526

*helper_directory = strdup(arg);

527

break;

528

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

529

case 130: /* --userid */

530

{

531

char *tmp;

532

uintmax_t tmp_id = 0;

533

errno = 0;

534

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

535

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

536

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

537

return ARGP_ERR_UNKNOWN;

538

}

539

*user = (uid_t)tmp_id;

540

errno = 0;

541

break;

542

}

543

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

544

case 131: /* --groupid */

545

{

546

char *tmp;

547

uintmax_t tmp_id = 0;

548

errno = 0;

549

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

550

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

551

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

552

return ARGP_ERR_UNKNOWN;

553

}

554

*group = (gid_t)tmp_id;

555

errno = 0;

556

break;

557

}

558

case ARGP_KEY_ARGS:

559

/* Copy arguments into argz vector */

560

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

561

mandos_argz_length);

562

default:

563

return ARGP_ERR_UNKNOWN;

564

}

565

return errno;

566

}

567

568

const struct argp argp = {

569

.options=options,

570

.parser=parse_opt,

571

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

572

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

573

" systemd password agent",

574

};

575

576

errno = argp_parse(&argp, argc, argv,

577

exit_failure ? 0 : ARGP_NO_EXIT, NULL, NULL);

578

579

return errno == 0;

580

}

581

582

__attribute__((nonnull, warn_unused_result))

583

bool block_sigchld(sigset_t *const orig_sigmask){

584

sigset_t sigchld_sigmask;

585

if(sigemptyset(&sigchld_sigmask) < 0){

586

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

587

return false;

588

}

589

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

590

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

591

return false;

592

}

593

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

594

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

595

return false;

596

}

597

return true;

598

}

599

600

__attribute__((nonnull, warn_unused_result, const))

601

bool restore_sigmask(const sigset_t *const orig_sigmask){

602

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

603

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

604

return false;

605

}

606

return true;

607

}

608

609

__attribute__((nonnull, warn_unused_result))

610

bool setup_signal_handler(struct sigaction *const old_sigchld_action){

611

struct sigaction sigchld_action = {

612

.sa_handler=handle_sigchld,

613

.sa_flags=SA_RESTART | SA_NOCLDSTOP,

614

};

615

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

616

signals automatically blocked during signal handler */

617

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

618

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

619

return false;

620

}

621

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

622

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

623

return false;

624

}

625

return true;

626

}

627

628

__attribute__((nonnull, warn_unused_result))

629

bool restore_signal_handler(const struct sigaction *const

630

old_sigchld_action){

631

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

632

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

633

return false;

634

}

635

return true;

636

}

637

638

__attribute__((warn_unused_result, malloc))

639

task_queue *create_queue(void){

640

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

641

if(queue){

642

queue->tasks = NULL;

643

queue->length = 0;

644

queue->allocated = 0;

645

queue->next_run = 0;

646

}

647

return queue;

648

}

649

650

__attribute__((nonnull, warn_unused_result))

651

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

652

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

653

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

654

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

655

needed_size);

656

if(new_tasks == NULL){

657

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

658

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

659

return false;

660

}

661

queue->tasks = new_tasks;

662

queue->allocated = needed_size;

663

}

664

/* Using memcpy here is necessary because doing */

665

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

666

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

667

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

668

sizeof(task_context));

669

return true;

670

}

671

672

__attribute__((nonnull))

673

void cleanup_task(const task_context *const task){

674

const error_t saved_errno = errno;

675

/* free and close all task data */

676

free(task->question_filename);

677

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

678

free(task->filename);

679

}

680

if(task->pid > 0){

681

kill(task->pid, SIGTERM);

682

}

683

if(task->fd > 0){

684

close(task->fd);

685

}

686

errno = saved_errno;

687

}

688

689

__attribute__((nonnull))

690

void free_queue(task_queue *const queue){

691

free(queue->tasks);

692

free(queue);

693

}

694

695

__attribute__((nonnull))

696

void cleanup_queue(task_queue *const *const queue){

697

if(*queue == NULL){

698

return;

699

}

700

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

701

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

702

cleanup_task(task);

703

}

704

free_queue(*queue);

705

}

706

707

__attribute__((pure, nonnull, warn_unused_result))

708

bool queue_has_question(const task_queue *const queue){

709

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

710

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

711

return true;

712

}

713

}

714

return false;

715

}

716

717

__attribute__((nonnull))

718

void cleanup_close(const int *const fd){

719

const error_t saved_errno = errno;

720

close(*fd);

721

errno = saved_errno;

722

}

723

724

__attribute__((nonnull))

725

void cleanup_string(char *const *const ptr){

726

free(*ptr);

727

}

728

729

__attribute__((nonnull))

730

void cleanup_buffer(buffer *buf){

731

if(buf->allocated > 0){

732

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

733

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

734

#else

735

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

736

#endif

737

}

738

if(buf->data != NULL){

739

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

740

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

741

}

742

free(buf->data);

743

buf->data = NULL;

744

}

745

buf->length = 0;

746

buf->allocated = 0;

747

}

748

749

__attribute__((pure, nonnull, warn_unused_result))

750

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

751

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

752

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

753

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

754

return true;

755

}

756

}

757

return false;

758

}

759

760

__attribute__((nonnull, warn_unused_result))

761

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

762

if(string_set_contains(*set, str)){

763

return true;

764

}

765

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

766

if(error == 0){

767

return true;

768

}

769

errno = error;

770

return false;

771

}

772

773

__attribute__((nonnull))

774

void string_set_clear(string_set *set){

775

free(set->argz);

776

set->argz = NULL;

777

set->argz_len = 0;

778

}

779

780

__attribute__((nonnull))

781

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

782

/* Swap contents of two string sets */

783

{

784

char *const tmp_argz = set1->argz;

785

set1->argz = set2->argz;

786

set2->argz = tmp_argz;

787

}

788

{

789

const size_t tmp_argz_len = set1->argz_len;

790

set1->argz_len = set2->argz_len;

791

set2->argz_len = tmp_argz_len;

792

}

793

}

794

795

__attribute__((nonnull, warn_unused_result))

796

bool start_mandos_client(task_queue *const queue,

797

const int epoll_fd,

798

bool *const mandos_client_exited,

799

bool *const quit_now, buffer *const password,

800

bool *const password_is_read,

801

const struct sigaction *const

802

old_sigchld_action, const sigset_t sigmask,

803

const char *const helper_directory,

804

const uid_t user, const gid_t group,

805

const char *const *const argv){

806

int pipefds[2];

807

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

808

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

809

return false;

810

}

811

812

const pid_t pid = fork();

813

if(pid == 0){

814

if(not restore_signal_handler(old_sigchld_action)){

815

_exit(EXIT_FAILURE);

816

}

817

if(not restore_sigmask(&sigmask)){

818

_exit(EXIT_FAILURE);

819

}

820

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

821

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

822

_exit(EXIT_FAILURE);

823

}

824

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

825

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

826

_exit(EXIT_FAILURE);

827

}

828

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

829

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

830

_exit(EXIT_FAILURE);

831

}

832

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

833

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

834

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

835

_exit(EXIT_FAILURE);

836

}

837

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

838

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

839

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

840

_exit(EXIT_FAILURE);

841

}

842

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

843

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

844

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

845

_exit(EXIT_FAILURE);

846

}

847

#ifdef __GNUC__

848

#pragma GCC diagnostic push

849

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

850

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

851

#pragma GCC diagnostic ignored "-Wcast-qual"

852

#endif

853

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

854

#ifdef __GNUC__

855

#pragma GCC diagnostic pop

856

#endif

857

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

858

_exit(EXIT_FAILURE);

859

}

860

close(pipefds[1]);

861

862

if(not add_to_queue(queue, (task_context){

863

.func=wait_for_mandos_client_exit,

864

.pid=pid,

865

.mandos_client_exited=mandos_client_exited,

866

.quit_now=quit_now,

867

})){

868

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

869

close(pipefds[0]);

870

return false;

871

}

872

873

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

874

&(struct epoll_event)

875

{ .events=EPOLLIN | EPOLLRDHUP });

876

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

877

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

878

close(pipefds[0]);

879

return false;

880

}

881

882

return add_to_queue(queue, (task_context){

883

.func=read_mandos_client_output,

884

.epoll_fd=epoll_fd,

885

.fd=pipefds[0],

886

.quit_now=quit_now,

887

.password=password,

888

.password_is_read=password_is_read,

889

});

890

}

891

892

__attribute__((nonnull))

893

void wait_for_mandos_client_exit(const task_context task,

894

task_queue *const queue){

895

const pid_t pid = task.pid;

896

bool *const mandos_client_exited = task.mandos_client_exited;

897

bool *const quit_now = task.quit_now;

898

899

int status;

900

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

901

case 0: /* Not exited yet */

902

if(not add_to_queue(queue, task)){

903

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

904

*quit_now = true;

905

}

906

break;

907

case -1: /* Error */

908

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

909

if(errno != ECHILD){

910

kill(pid, SIGTERM);

911

}

912

*quit_now = true;

913

break;

914

default: /* Has exited */

915

*mandos_client_exited = true;

916

if((not WIFEXITED(status))

917

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

918

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

919

*quit_now = true;

920

}

921

}

922

}

923

924

__attribute__((nonnull))

925

void read_mandos_client_output(const task_context task,

926

task_queue *const queue){

927

buffer *const password = task.password;

928

bool *const quit_now = task.quit_now;

929

bool *const password_is_read = task.password_is_read;

930

const int fd = task.fd;

931

const int epoll_fd = task.epoll_fd;

932

933

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

934

if(password->allocated < new_potential_size){

935

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

936

if(new_buffer == NULL){

937

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

938

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

939

*quit_now = true;

940

close(fd);

941

return;

942

}

943

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

944

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

945

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

946

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

947

}

948

}

949

if(password->length > 0){

950

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

951

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

952

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

953

#else

954

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

955

#endif

956

}

957

if(password->data != NULL){

958

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

959

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

960

}

961

free(password->data);

962

}

963

password->data = new_buffer;

964

password->allocated = new_potential_size;

965

}

966

967

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

968

+ password->length, PIPE_BUF);

969

970

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

971

*password_is_read = true;

972

close(fd);

973

return;

974

}

975

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

976

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

977

*quit_now = true;

978

close(fd);

979

return;

980

}

981

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

982

password->length += (size_t)read_length;

983

}

984

985

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

986

available yet */

987

988

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

989

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

990

&(struct epoll_event)

991

{ .events=EPOLLIN | EPOLLRDHUP });

992

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

993

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

994

*quit_now = true;

995

close(fd);

996

return;

997

}

998

999

/* Re-add myself to the queue */

1000

if(not add_to_queue(queue, task)){

1001

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

1002

*quit_now = true;

1003

close(fd);

1004

}

1005

}

1006

1007

__attribute__((nonnull, warn_unused_result))

1008

bool add_inotify_dir_watch(task_queue *const queue,

1009

const int epoll_fd, bool *const quit_now,

1010

buffer *const password,

1011

const char *const dir,

1012

string_set *cancelled_filenames,

1013

const mono_microsecs *const current_time,

1014

bool *const mandos_client_exited,

1015

bool *const password_is_read){

1016

const int fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);

1017

if(fd == -1){

1018

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

1019

return false;

1020

}

1021

1022

if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE | IN_MOVED_TO

1023

| IN_MOVED_FROM| IN_DELETE | IN_EXCL_UNLINK

1024

| IN_ONLYDIR)

1025

== -1){

1026

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

1027

return false;

1028

}

1029

1030

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

1031

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

1032

&(struct epoll_event)

1033

{ .events=EPOLLIN | EPOLLRDHUP });

1034

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

1035

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

1036

close(fd);

1037

return false;

1038

}

1039

1040

const task_context read_inotify_event_task = {

1041

.func=read_inotify_event,

1042

.epoll_fd=epoll_fd,

1043

.quit_now=quit_now,

1044

.password=password,

1045

.fd=fd,

1046

.filename=strdup(dir),

1047

.cancelled_filenames=cancelled_filenames,

1048

.current_time=current_time,

1049

.mandos_client_exited=mandos_client_exited,

1050

.password_is_read=password_is_read,

1051

};

1052

if(read_inotify_event_task.filename == NULL){

1053

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

1054

close(fd);

1055

return false;

1056

}

1057

1058

return add_to_queue(queue, read_inotify_event_task);

1059

}

1060

1061

__attribute__((nonnull))

1062

void read_inotify_event(const task_context task,

1063

task_queue *const queue){

1064

const int fd = task.fd;

1065

const int epoll_fd = task.epoll_fd;

1066

char *const filename = task.filename;

1067

bool *quit_now = task.quit_now;

1068

buffer *const password = task.password;

1069

string_set *const cancelled_filenames = task.cancelled_filenames;

1070

const mono_microsecs *const current_time = task.current_time;

1071

bool *const mandos_client_exited = task.mandos_client_exited;

1072

bool *const password_is_read = task.password_is_read;

1073

1074

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

1075

const size_t ievent_size = (sizeof(struct inotify_event)

1076

+ NAME_MAX + 1);

1077

struct {

1078

struct inotify_event event;

1079

char name_buffer[NAME_MAX + 1];

1080

} ievent_buffer;

1081

struct inotify_event *const ievent = &ievent_buffer.event;

1082

1083

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

1084

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

1085

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

1086

*quit_now = true;

1087

cleanup_task(&task);

1088

return;

1089

}

1090

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

1091

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

1092

filename);

1093

*quit_now = true;

1094

cleanup_task(&task);

1095

return;

1096

}

1097

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

1098

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

1099

char *question_filename = NULL;

1100

const ssize_t question_filename_length

1101

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

1102

if(question_filename_length < 0){

1103

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

1104

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

1105

} else {

1106

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

1107

if(not add_to_queue(queue, (task_context){

1108

.func=open_and_parse_question,

1109

.epoll_fd=epoll_fd,

1110

.question_filename=question_filename,

1111

.filename=question_filename,

1112

.password=password,

1113

.cancelled_filenames=cancelled_filenames,

1114

.current_time=current_time,

1115

.mandos_client_exited=mandos_client_exited,

1116

.password_is_read=password_is_read,

1117

})){

1118

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

1119

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

1120

} else {

1121

/* Force the added task (open_and_parse_question) to run

1122

immediately */

1123

queue->next_run = 1;

1124

}

1125

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

1126

if(not string_set_add(cancelled_filenames,

1127

question_filename)){

1128

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

1129

" cancelled_questions", question_filename);

1130

*quit_now = true;

1131

free(question_filename);

1132

cleanup_task(&task);

1133

return;

1134

}

1135

free(question_filename);

1136

}

1137

}

1138

}

1139

1140

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

1141

available yet */

1142

1143

/* Re-add myself to the queue */

1144

if(not add_to_queue(queue, task)){

1145

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

1146

" queue", filename);

1147

*quit_now = true;

1148

cleanup_task(&task);

1149

return;

1150

}

1151

1152

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

1153

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

1154

&(struct epoll_event)

1155

{ .events=EPOLLIN | EPOLLRDHUP });

1156

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

1157

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

1158

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

1159

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

1160

one second from now */

1161

if((queue->next_run == 0)

1162

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

1163

queue->next_run = *current_time + 1000000;

1164

}

1165

}

1166

}

1167

1168

__attribute__((nonnull))

1169

void open_and_parse_question(const task_context task,

1170

task_queue *const queue){

1171

__attribute__((cleanup(cleanup_string)))

1172

char *question_filename = task.question_filename;

1173

const int epoll_fd = task.epoll_fd;

1174

buffer *const password = task.password;

1175

string_set *const cancelled_filenames = task.cancelled_filenames;

1176

const mono_microsecs *const current_time = task.current_time;

1177

bool *const mandos_client_exited = task.mandos_client_exited;

1178

bool *const password_is_read = task.password_is_read;

1179

1180

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

1181

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

1182

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

1183

__attribute__((nonnull))

1184

void cleanup_g_key_file(GKeyFile **key_file){

1185

if(*key_file != NULL){

1186

g_key_file_free(*key_file);

1187

}

1188

}

1189

1190

__attribute__((cleanup(cleanup_g_key_file)))

1191

GKeyFile *key_file = g_key_file_new();

1192

if(key_file == NULL){

1193

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

1194

question_filename);

1195

return;

1196

}

1197

GError *glib_error = NULL;

1198

if(g_key_file_load_from_file(key_file, question_filename,

1199

G_KEY_FILE_NONE, &glib_error) != TRUE){

1200

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

1201

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

1202

if(glib_error->code != G_FILE_ERROR_NOENT){

1203

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

1204

question_filename, glib_error->message);

1205

}

1206

return;

1207

}

1208

1209

__attribute__((cleanup(cleanup_string)))

1210

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

1211

"Socket",

1212

&glib_error);

1213

if(socket_name == NULL){

1214

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

1215

question_filename, glib_error->message);

1216

return;

1217

}

1218

1219

if(strlen(socket_name) == 0){

1220

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

1221

question_filename);

1222

return;

1223

}

1224

1225

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

1226

&glib_error);

1227

if(glib_error != NULL){

1228

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

1229

question_filename, glib_error->message);

1230

return;

1231

}

1232

1233

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

1234

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

1235

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

1236

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

1237

return;

1238

}

1239

1240

guint64 notafter = g_key_file_get_uint64(key_file, "Ask",

1241

"NotAfter", &glib_error);

1242

if(glib_error != NULL){

1243

if(glib_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND){

1244

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

1245

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

1246

}

1247

notafter = 0;

1248

}

1249

if(notafter != 0){

1250

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

1251

queue->next_run = notafter;

1252

}

1253

if(*current_time >= notafter){

1254

return;

1255

}

1256

}

1257

1258

const task_context connect_question_socket_task = {

1259

.func=connect_question_socket,

1260

.question_filename=strdup(question_filename),

1261

.epoll_fd=epoll_fd,

1262

.password=password,

1263

.filename=strdup(socket_name),

1264

.cancelled_filenames=task.cancelled_filenames,

1265

.mandos_client_exited=mandos_client_exited,

1266

.password_is_read=password_is_read,

1267

.current_time=current_time,

1268

};

1269

if(connect_question_socket_task.question_filename == NULL

1270

or connect_question_socket_task.filename == NULL

1271

or not add_to_queue(queue, connect_question_socket_task)){

1272

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

1273

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

1274

question_filename);

1275

cleanup_task(&connect_question_socket_task);

1276

return;

1277

}

1278

/* Force the added task (connect_question_socket) to run

1279

immediately */

1280

queue->next_run = 1;

1281

1282

if(notafter > 0){

1283

char *const dup_filename = strdup(question_filename);

1284

const task_context cancel_old_question_task = {

1285

.func=cancel_old_question,

1286

.question_filename=dup_filename,

1287

.notafter=notafter,

1288

.filename=dup_filename,

1289

.cancelled_filenames=cancelled_filenames,

1290

.current_time=current_time,

1291

};

1292

if(cancel_old_question_task.question_filename == NULL

1293

or not add_to_queue(queue, cancel_old_question_task)){

1294

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

1295

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

1296

cleanup_task(&cancel_old_question_task);

1297

return;

1298

}

1299

}

1300

}

1301

1302

__attribute__((nonnull))

1303

void cancel_old_question(const task_context task,

1304

task_queue *const queue){

1305

char *const question_filename = task.question_filename;

1306

string_set *const cancelled_filenames = task.cancelled_filenames;

1307

const mono_microsecs notafter = task.notafter;

1308

const mono_microsecs *const current_time = task.current_time;

1309

1310

if(*current_time >= notafter){

1311

if(not string_set_add(cancelled_filenames, question_filename)){

1312

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

1313

question_filename);

1314

}

1315

cleanup_task(&task);

1316

return;

1317

}

1318

1319

if(not add_to_queue(queue, task)){

1320

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

1321

"%s to queue", question_filename);

1322

cleanup_task(&task);

1323

return;

1324

}

1325

1326

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

1327

queue->next_run = notafter;

1328

}

1329

}

1330

1331

__attribute__((nonnull))

1332

void connect_question_socket(const task_context task,

1333

task_queue *const queue){

1334

char *const question_filename = task.question_filename;

1335

char *const filename = task.filename;

1336

const int epoll_fd = task.epoll_fd;

1337

buffer *const password = task.password;

1338

string_set *const cancelled_filenames = task.cancelled_filenames;

1339

bool *const mandos_client_exited = task.mandos_client_exited;

1340

bool *const password_is_read = task.password_is_read;

1341

const mono_microsecs *const current_time = task.current_time;

1342

1343

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

1344

1345

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

1346

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

1347

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

1348

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

1349

if(not string_set_add(cancelled_filenames, question_filename)){

1350

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

1351

question_filename);

1352

}

1353

cleanup_task(&task);

1354

return;

1355

}

1356

1357

const int fd = socket(PF_LOCAL, SOCK_DGRAM

1358

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

1359

if(fd < 0){

1360

error(0, errno,

1361

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

1362

if(not add_to_queue(queue, task)){

1363

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

1364

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

1365

filename);

1366

cleanup_task(&task);

1367

} else {

1368

/* Force the added task (connect_question_socket) to run

1369

immediately */

1370

queue->next_run = 1;

1371

}

1372

return;

1373

}

1374

1375

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

1376

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

1377

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

1378

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

1379

if(not add_to_queue(queue, task)){

1380

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

1381

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

1382

filename);

1383

cleanup_task(&task);

1384

} else {

1385

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

1386

at most one second from now */

1387

if((queue->next_run == 0)

1388

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

1389

queue->next_run = *current_time + 1000000;

1390

}

1391

}

1392

return;

1393

}

1394

1395

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

1396

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

1397

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

1398

filename);

1399

}

1400

1401

/* Add the fd to the epoll set */

1402

if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

1403

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

1404

!= 0){

1405

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

1406

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

1407

if(not add_to_queue(queue, task)){

1408

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

1409

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

1410

filename);

1411

cleanup_task(&task);

1412

} else {

1413

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

1414

at most one second from now */

1415

if((queue->next_run == 0)

1416

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

1417

queue->next_run = *current_time + 1000000;

1418

}

1419

}

1420

return;

1421

}

1422

1423

/* add task send_password_to_socket to queue */

1424

const task_context send_password_to_socket_task = {

1425

.func=send_password_to_socket,

1426

.question_filename=question_filename,

1427

.filename=filename,

1428

.epoll_fd=epoll_fd,

1429

.fd=fd,

1430

.password=password,

1431

.cancelled_filenames=cancelled_filenames,

1432

.mandos_client_exited=mandos_client_exited,

1433

.password_is_read=password_is_read,

1434

.current_time=current_time,

1435

};

1436

1437

if(not add_to_queue(queue, send_password_to_socket_task)){

1438

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

1439

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

1440

question_filename, filename);

1441

cleanup_task(&send_password_to_socket_task);

1442

}

1443

}

1444

1445

__attribute__((nonnull))

1446

void send_password_to_socket(const task_context task,

1447

task_queue *const queue){

1448

char *const question_filename=task.question_filename;

1449

char *const filename=task.filename;

1450

const int epoll_fd=task.epoll_fd;

1451

const int fd=task.fd;

1452

buffer *const password=task.password;

1453

string_set *const cancelled_filenames=task.cancelled_filenames;

1454

bool *const mandos_client_exited = task.mandos_client_exited;

1455

bool *const password_is_read = task.password_is_read;

1456

const mono_microsecs *const current_time = task.current_time;

1457

1458

if(*mandos_client_exited and *password_is_read){

1459

1460

const size_t send_buffer_length = password->length + 2;

1461

char *send_buffer = malloc(send_buffer_length);

1462

if(send_buffer == NULL){

1463

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

1464

} else {

1465

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

1466

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

1467

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

1468

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

1469

" buffer");

1470

}

1471

}

1472

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

1473

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

1474

depending on whether the password entry was successful or

1475

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

1476

your message.

1477

1478

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

1479

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

1480

*/

1481

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

1482

/* Always add an extra NUL */

1483

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

1484

if(password->length > 0){

1485

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

1486

}

1487

errno = 0;

1488

ssize_t ssret = send(fd, send_buffer, send_buffer_length,

1489

MSG_NOSIGNAL);

1490

const error_t saved_errno = errno;

1491

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

1492

explicit_bzero(send_buffer, send_buffer_length);

1493

#else

1494

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

1495

#endif

1496

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

1497

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

1498

}

1499

free(send_buffer);

1500

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

1501

switch(saved_errno){

1502

case EINTR:

1503

case ENOBUFS:

1504

case ENOMEM:

1505

case EADDRINUSE:

1506

case ECONNREFUSED:

1507

case ECONNRESET:

1508

case ENOENT:

1509

case ETOOMANYREFS:

1510

case EAGAIN:

1511

/* Retry, below */

1512

break;

1513

case EMSGSIZE:

1514

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

1515

(uintmax_t)password->length);

1516

#if __GNUC__ < 7

1517

/* FALLTHROUGH */

1518

#else

1519

__attribute__((fallthrough));

1520

#endif

1521

case 0:

1522

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

1523

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

1524

}

1525

#if __GNUC__ < 7

1526

/* FALLTHROUGH */

1527

#else

1528

__attribute__((fallthrough));

1529

#endif

1530

default:

1531

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

1532

filename);

1533

if(not string_set_add(cancelled_filenames,

1534

question_filename)){

1535

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

1536

question_filename);

1537

}

1538

cleanup_task(&task);

1539

return;

1540

}

1541

} else {

1542

/* Success */

1543

cleanup_task(&task);

1544

return;

1545

}

1546

}

1547

}

1548

1549

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

1550

1551

if(not add_to_queue(queue, task)){

1552

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

1553

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

1554

filename);

1555

cleanup_task(&task);

1556

}

1557

1558

/* Add the fd to the epoll set */

1559

if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

1560

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

1561

!= 0){

1562

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

1563

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

1564

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

1565

most one second from now */

1566

if((queue->next_run == 0)

1567

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

1568

queue->next_run = *current_time + 1000000;

1569

}

1570

}

1571

}

1572

1573

__attribute__((warn_unused_result))

1574

bool add_existing_questions(task_queue *const queue,

1575

const int epoll_fd,

1576

buffer *const password,

1577

string_set *cancelled_filenames,

1578

const mono_microsecs *const current_time,

1579

bool *const mandos_client_exited,

1580

bool *const password_is_read,

1581

const char *const dirname){

1582

__attribute__((cleanup(cleanup_string)))

1583

char *dir_pattern = NULL;

1584

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

1585

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

1586

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

1587

dirname);

1588

return false;

1589

}

1590

__attribute__((cleanup(globfree)))

1591

glob_t question_filenames = {};

1592

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

1593

NULL, &question_filenames)){

1594

case GLOB_ABORTED:

1595

default:

1596

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

1597

return false;

1598

case GLOB_NOMATCH:

1599

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

1600

return false;

1601

case GLOB_NOSPACE:

1602

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

1603

" names in %s", dirname);

1604

#if __GNUC__ < 7

1605

/* FALLTHROUGH */

1606

#else

1607

__attribute__((fallthrough));

1608

#endif

1609

case 0:

1610

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

1611

char *const question_filename = strdup(question_filenames

1612

.gl_pathv[i]);

1613

const task_context task = {

1614

.func=open_and_parse_question,

1615

.epoll_fd=epoll_fd,

1616

.question_filename=question_filename,

1617

.filename=question_filename,

1618

.password=password,

1619

.cancelled_filenames=cancelled_filenames,

1620

.current_time=current_time,

1621

.mandos_client_exited=mandos_client_exited,

1622

.password_is_read=password_is_read,

1623

};

1624

1625

if(question_filename == NULL

1626

or not add_to_queue(queue, task)){

1627

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

1628

" file %s to queue",

1629

question_filenames.gl_pathv[i]);

1630

free(question_filename);

1631

} else {

1632

queue->next_run = 1;

1633

}

1634

}

1635

return true;

1636

}

1637

}

1638

1639

__attribute__((nonnull, warn_unused_result))

1640

bool wait_for_event(const int epoll_fd,

1641

const mono_microsecs queue_next_run,

1642

const mono_microsecs current_time){

1643

__attribute__((const))

1644

int milliseconds_to_wait(const mono_microsecs currtime,

1645

const mono_microsecs nextrun){

1646

if(currtime >= nextrun){

1647

return 0;

1648

}

1649

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

1650

if(wait_time_ms > (uintmax_t)INT_MAX){

1651

return INT_MAX;

1652

}

1653

return (int)wait_time_ms;

1654

}

1655

1656

const int wait_time_ms = milliseconds_to_wait(current_time,

1657

queue_next_run);

1658

1659

/* Prepare unblocking of SIGCHLD during epoll_pwait */

1660

sigset_t temporary_unblocked_sigmask;

1661

/* Get current signal mask */

1662

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

1663

return false;

1664

}

1665

/* Remove SIGCHLD from the signal mask */

1666

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

1667

return false;

1668

}

1669

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

1670

int ret = epoll_pwait(epoll_fd, events,

1671

sizeof(events) / sizeof(struct epoll_event),

1672

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

1673

&temporary_unblocked_sigmask);

1674

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

1675

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

1676

" ...", epoll_fd,

1677

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

1678

return false;

1679

}

1680

return clear_all_fds_from_epoll_set(epoll_fd);

1681

}

1682

1683

bool clear_all_fds_from_epoll_set(const int epoll_fd){

1684

/* Create a new empty epoll set */

1685

__attribute__((cleanup(cleanup_close)))

1686

const int new_epoll_fd = epoll_create1(EPOLL_CLOEXEC);

1687

if(new_epoll_fd < 0){

1688

return false;

1689

}

1690

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

1691

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

1692

return false;

1693

}

1694

return true;

1695

}

1696

1697

__attribute__((nonnull, warn_unused_result))

1698

bool run_queue(task_queue **const queue,

1699

string_set *const cancelled_filenames,

1700

bool *const quit_now){

1701

1702

task_queue *new_queue = create_queue();

1703

if(new_queue == NULL){

1704

return false;

1705

}

1706

1707

__attribute__((cleanup(string_set_clear)))

1708

string_set old_cancelled_filenames = {};

1709

string_set_swap(cancelled_filenames, &old_cancelled_filenames);

1710

1711

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

1712

loop in case we aborted in the middle */

1713

size_t i;

1714

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

1715

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

1716

const char *const question_filename = task->question_filename;

1717

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

1718

if(question_filename != NULL

1719

and string_set_contains(old_cancelled_filenames,

1720

question_filename)){

1721

cleanup_task(task);

1722

continue;

1723

}

1724

task->func(*task, new_queue);

1725

}

1726

1727

if(*quit_now){

1728

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

1729

remaining tasks in the current queue */

1730

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

1731

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

1732

}

1733

free_queue(*queue);

1734

*queue = new_queue;

1735

new_queue = NULL;

1736

return false;

1737

}

1738

free_queue(*queue);

1739

*queue = new_queue;

1740

new_queue = NULL;

1741

1742

return true;

1743

}

1744

1745

/* End of regular code section */

1746

1747

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

1748

1749

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

1750

teardown functions */

1751

typedef struct {

1752

struct sigaction orig_sigaction;

1753

sigset_t orig_sigmask;

1754

} test_fixture;

1755

1756

static void test_setup(test_fixture *fixture,

1757

__attribute__((unused))

1758

gconstpointer user_data){

1759

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

1760

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

1761

}

1762

1763

static void test_teardown(test_fixture *fixture,

1764

__attribute__((unused))

1765

gconstpointer user_data){

1766

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

1767

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

1768

}

1769

1770

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

1771

__attribute__((pure, nonnull, warn_unused_result))

1772

static task_context *find_matching_task(const task_queue *const queue,

1773

const task_context task){

1774

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

1775

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

1776

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

1777

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

1778

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

1779

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

1780

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

1781

1782

/* task_func *const func */

1783

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

1784

continue;

1785

}

1786

/* char *const question_filename; */

1787

if(task.question_filename != NULL

1788

and (current_task->question_filename == NULL

1789

or strcmp(current_task->question_filename,

1790

task.question_filename) != 0)){

1791

continue;

1792

}

1793

/* const pid_t pid; */

1794

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

1795

continue;

1796

}

1797

/* const int epoll_fd; */

1798

if(task.epoll_fd != 0

1799

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

1800

continue;

1801

}

1802

/* bool *const quit_now; */

1803

if(task.quit_now != NULL

1804

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

1805

continue;

1806

}

1807

/* const int fd; */

1808

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

1809

continue;

1810

}

1811

/* bool *const mandos_client_exited; */

1812

if(task.mandos_client_exited != NULL

1813

and current_task->mandos_client_exited

1814

!= task.mandos_client_exited){

1815

continue;

1816

}

1817

/* buffer *const password; */

1818

if(task.password != NULL

1819

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

1820

continue;

1821

}

1822

/* bool *const password_is_read; */

1823

if(task.password_is_read != NULL

1824

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

1825

continue;

1826

}

1827

/* char *filename; */

1828

if(task.filename != NULL

1829

and (current_task->filename == NULL

1830

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

1831

continue;

1832

}

1833

/* string_set *const cancelled_filenames; */

1834

if(task.cancelled_filenames != NULL

1835

and current_task->cancelled_filenames

1836

!= task.cancelled_filenames){

1837

continue;

1838

}

1839

/* const mono_microsecs notafter; */

1840

if(task.notafter != 0

1841

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

1842

continue;

1843

}

1844

/* const mono_microsecs *const current_time; */

1845

if(task.current_time != NULL

1846

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

1847

continue;

1848

}

1849

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

1850

return current_task;

1851

}

1852

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

1853

return NULL;

1854

}

1855

1856

static void test_create_queue(__attribute__((unused))

1857

test_fixture *fixture,

1858

__attribute__((unused))

1859

gconstpointer user_data){

1860

__attribute__((cleanup(cleanup_queue)))

1861

task_queue *const queue = create_queue();

1862

g_assert_nonnull(queue);

1863

g_assert_null(queue->tasks);

1864

g_assert_true(queue->length == 0);

1865

g_assert_true(queue->next_run == 0);

1866

}

1867

1868

static task_func dummy_func;

1869

1870

static void test_add_to_queue(__attribute__((unused))

1871

test_fixture *fixture,

1872

__attribute__((unused))

1873

gconstpointer user_data){

1874

__attribute__((cleanup(cleanup_queue)))

1875

task_queue *queue = create_queue();

1876

g_assert_nonnull(queue);

1877

1878

g_assert_true(add_to_queue(queue,

1879

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

1880

g_assert_true(queue->length == 1);

1881

g_assert_nonnull(queue->tasks);

1882

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

1883

}

1884

1885

static void dummy_func(__attribute__((unused))

1886

const task_context task,

1887

__attribute__((unused))

1888

task_queue *const queue){

1889

}

1890

1891

static void test_queue_has_question_empty(__attribute__((unused))

1892

test_fixture *fixture,

1893

__attribute__((unused))

1894

gconstpointer user_data){

1895

__attribute__((cleanup(cleanup_queue)))

1896

task_queue *queue = create_queue();

1897

g_assert_nonnull(queue);

1898

g_assert_false(queue_has_question(queue));

1899

}

1900

1901

static void test_queue_has_question_false(__attribute__((unused))

1902

test_fixture *fixture,

1903

__attribute__((unused))

1904

gconstpointer user_data){

1905

__attribute__((cleanup(cleanup_queue)))

1906

task_queue *queue = create_queue();

1907

g_assert_nonnull(queue);

1908

g_assert_true(add_to_queue(queue,

1909

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

1910

g_assert_false(queue_has_question(queue));

1911

}

1912

1913

static void test_queue_has_question_true(__attribute__((unused))

1914

test_fixture *fixture,

1915

__attribute__((unused))

1916

gconstpointer user_data){

1917

__attribute__((cleanup(cleanup_queue)))

1918

task_queue *queue = create_queue();

1919

g_assert_nonnull(queue);

1920

char *const question_filename

1921

= strdup("/nonexistent/question_filename");

1922

g_assert_nonnull(question_filename);

1923

task_context task = {

1924

.func=dummy_func,

1925

.question_filename=question_filename,

1926

};

1927

g_assert_true(add_to_queue(queue, task));

1928

g_assert_true(queue_has_question(queue));

1929

}

1930

1931

static void test_queue_has_question_false2(__attribute__((unused))

1932

test_fixture *fixture,

1933

__attribute__((unused))

1934

gconstpointer user_data){

1935

__attribute__((cleanup(cleanup_queue)))

1936

task_queue *queue = create_queue();

1937

g_assert_nonnull(queue);

1938

task_context task = { .func=dummy_func };

1939

g_assert_true(add_to_queue(queue, task));

1940

g_assert_true(add_to_queue(queue, task));

1941

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

1942

g_assert_false(queue_has_question(queue));

1943

}

1944

1945

static void test_queue_has_question_true2(__attribute__((unused))

1946

test_fixture *fixture,

1947

__attribute__((unused))

1948

gconstpointer user_data){

1949

__attribute__((cleanup(cleanup_queue)))

1950

task_queue *queue = create_queue();

1951

g_assert_nonnull(queue);

1952

task_context task1 = { .func=dummy_func };

1953

g_assert_true(add_to_queue(queue, task1));

1954

char *const question_filename

1955

= strdup("/nonexistent/question_filename");

1956

g_assert_nonnull(question_filename);

1957

task_context task2 = {

1958

.func=dummy_func,

1959

.question_filename=question_filename,

1960

};

1961

g_assert_true(add_to_queue(queue, task2));

1962

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

1963

g_assert_true(queue_has_question(queue));

1964

}

1965

1966

static void test_cleanup_buffer(__attribute__((unused))

1967

test_fixture *fixture,

1968

__attribute__((unused))

1969

gconstpointer user_data){

1970

buffer buf = {};

1971

1972

const size_t buffersize = 10;

1973

1974

buf.data = malloc(buffersize);

1975

g_assert_nonnull(buf.data);

1976

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

1977

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

1978

}

1979

1980

cleanup_buffer(&buf);

1981

g_assert_null(buf.data);

1982

}

1983

1984

static

1985

void test_string_set_new_set_contains_nothing(__attribute__((unused))

1986

test_fixture *fixture,

1987

__attribute__((unused))

1988

gconstpointer

1989

user_data){

1990

__attribute__((cleanup(string_set_clear)))

1991

string_set set = {};

1992

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

1993

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

1994

}

1995

1996

static void

1997

test_string_set_with_added_string_contains_it(__attribute__((unused))

1998

test_fixture *fixture,

1999

__attribute__((unused))

2000

gconstpointer

2001

user_data){

2002

__attribute__((cleanup(string_set_clear)))

2003

string_set set = {};

2004

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

2005

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

2006

}

2007

2008

static void

2009

test_string_set_cleared_does_not_contain_str(__attribute__((unused))

2010

test_fixture *fixture,

2011

__attribute__((unused))

2012

gconstpointer user_data){

2013

__attribute__((cleanup(string_set_clear)))

2014

string_set set = {};

2015

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

2016

string_set_clear(&set);

2017

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

2018

}

2019

2020

static

2021

void test_string_set_swap_one_with_empty(__attribute__((unused))

2022

test_fixture *fixture,

2023

__attribute__((unused))

2024

gconstpointer user_data){

2025

__attribute__((cleanup(string_set_clear)))

2026

string_set set1 = {};

2027

__attribute__((cleanup(string_set_clear)))

2028

string_set set2 = {};

2029

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

2030

string_set_swap(&set1, &set2);

2031

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

2032

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

2033

}

2034

2035

static

2036

void test_string_set_swap_empty_with_one(__attribute__((unused))

2037

test_fixture *fixture,

2038

__attribute__((unused))

2039

gconstpointer user_data){

2040

__attribute__((cleanup(string_set_clear)))

2041

string_set set1 = {};

2042

__attribute__((cleanup(string_set_clear)))

2043

string_set set2 = {};

2044

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

2045

string_set_swap(&set1, &set2);

2046

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

2047

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

2048

}

2049

2050

static void test_string_set_swap_one_with_one(__attribute__((unused))

2051

test_fixture *fixture,

2052

__attribute__((unused))

2053

gconstpointer

2054

user_data){

2055

__attribute__((cleanup(string_set_clear)))

2056

string_set set1 = {};

2057

__attribute__((cleanup(string_set_clear)))

2058

string_set set2 = {};

2059

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

2060

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

2061

string_set_swap(&set1, &set2);

2062

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

2063

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

2064

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

2065

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

2066

}

2067

2068

static bool fd_has_cloexec_and_nonblock(const int);

2069

2070

static bool epoll_set_contains(int, int, uint32_t);

2071

2072

static void test_start_mandos_client(test_fixture *fixture,

2073

__attribute__((unused))

2074

gconstpointer user_data){

2075

2076

bool mandos_client_exited = false;

2077

bool quit_now = false;

2078

__attribute__((cleanup(cleanup_close)))

2079

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2080

g_assert_cmpint(epoll_fd, >=, 0);

2081

__attribute__((cleanup(cleanup_queue)))

2082

task_queue *queue = create_queue();

2083

g_assert_nonnull(queue);

2084

buffer password = {};

2085

bool password_is_read = false;

2086

const char helper_directory[] = "/nonexistent";

2087

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

2088

2089

g_assert_true(start_mandos_client(queue, epoll_fd,

2090

&mandos_client_exited, &quit_now,

2091

&password, &password_is_read,

2092

&fixture->orig_sigaction,

2093

fixture->orig_sigmask,

2094

helper_directory, 0, 0, argv));

2095

2096

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

2097

2098

const task_context *const added_wait_task

2099

= find_matching_task(queue, (task_context){

2100

.func=wait_for_mandos_client_exit,

2101

.mandos_client_exited=&mandos_client_exited,

2102

.quit_now=&quit_now,

2103

});

2104

g_assert_nonnull(added_wait_task);

2105

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

2106

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

2107

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

2108

2109

const task_context *const added_read_task

2110

= find_matching_task(queue, (task_context){

2111

.func=read_mandos_client_output,

2112

.epoll_fd=epoll_fd,

2113

.password=&password,

2114

.password_is_read=&password_is_read,

2115

.quit_now=&quit_now,

2116

});

2117

g_assert_nonnull(added_read_task);

2118

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

2119

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

2120

g_assert_true(epoll_set_contains(epoll_fd, added_read_task->fd,

2121

EPOLLIN | EPOLLRDHUP));

2122

}

2123

2124

static bool fd_has_cloexec_and_nonblock(const int fd){

2125

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

2126

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

2127

return ((socket_fd_flags >= 0)

2128

and (socket_fd_flags & FD_CLOEXEC)

2129

and (socket_file_flags >= 0)

2130

and (socket_file_flags & O_NONBLOCK));

2131

}

2132

2133

__attribute__((const))

2134

bool is_privileged(void){

2135

uid_t user = getuid() + 1;

2136

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

2137

user++;

2138

}

2139

gid_t group = getuid() + 1;

2140

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

2141

group++;

2142

}

2143

const pid_t pid = fork();

2144

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

2145

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

2146

if(errno != EPERM){

2147

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

2148

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

2149

}

2150

exit(EXIT_FAILURE);

2151

}

2152

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

2153

if(errno != EPERM){

2154

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

2155

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

2156

}

2157

exit(EXIT_FAILURE);

2158

}

2159

exit(EXIT_SUCCESS);

2160

}

2161

int status;

2162

waitpid(pid, &status, 0);

2163

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

2164

return true;

2165

}

2166

return false;

2167

}

2168

2169

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

2170

/* Only scan for events in this eventmask */

2171

const uint32_t eventmask = EPOLLIN | EPOLLOUT | EPOLLRDHUP;

2172

__attribute__((cleanup(cleanup_string)))

2173

char *fdinfo_name = NULL;

2174

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

2175

g_assert_cmpint(ret, >, 0);

2176

g_assert_nonnull(fdinfo_name);

2177

2178

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

2179

g_assert_nonnull(fdinfo);

2180

uint32_t reported_events;

2181

buffer line = {};

2182

int found_fd = -1;

2183

2184

do {

2185

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

2186

break;

2187

}

2188

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

2189

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

2190

&found_fd, &reported_events) == 2){

2191

if(found_fd == fd){

2192

break;

2193

}

2194

}

2195

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

2196

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

2197

free(line.data);

2198

if(found_fd != fd){

2199

return false;

2200

}

2201

2202

if(events == 0){

2203

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

2204

return true;

2205

}

2206

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

2207

}

2208

2209

static void test_start_mandos_client_execv(test_fixture *fixture,

2210

__attribute__((unused))

2211

gconstpointer user_data){

2212

bool mandos_client_exited = false;

2213

bool quit_now = false;

2214

__attribute__((cleanup(cleanup_close)))

2215

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2216

g_assert_cmpint(epoll_fd, >=, 0);

2217

__attribute__((cleanup(cleanup_queue)))

2218

task_queue *queue = create_queue();

2219

g_assert_nonnull(queue);

2220

__attribute__((cleanup(cleanup_buffer)))

2221

buffer password = {};

2222

const char helper_directory[] = "/nonexistent";

2223

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

2224

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

2225

2226

{

2227

__attribute__((cleanup(cleanup_close)))

2228

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

2229

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2230

g_assert_cmpint(devnull_fd, >=, 0);

2231

__attribute__((cleanup(cleanup_close)))

2232

const int real_stderr_fd = dup(STDERR_FILENO);

2233

g_assert_cmpint(real_stderr_fd, >=, 0);

2234

dup2(devnull_fd, STDERR_FILENO);

2235

2236

const bool success = start_mandos_client(queue, epoll_fd,

2237

&mandos_client_exited,

2238

&quit_now,

2239

&password,

2240

(bool[]){false},

2241

&fixture->orig_sigaction,

2242

fixture->orig_sigmask,

2243

helper_directory, 0, 0,

2244

argv);

2245

dup2(real_stderr_fd, STDERR_FILENO);

2246

g_assert_true(success);

2247

}

2248

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

2249

2250

struct timespec starttime, currtime;

2251

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

2252

do {

2253

queue->next_run = 0;

2254

string_set cancelled_filenames = {};

2255

2256

{

2257

__attribute__((cleanup(cleanup_close)))

2258

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

2259

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2260

g_assert_cmpint(devnull_fd, >=, 0);

2261

__attribute__((cleanup(cleanup_close)))

2262

const int real_stderr_fd = dup(STDERR_FILENO);

2263

g_assert_cmpint(real_stderr_fd, >=, 0);

2264

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

2265

dup2(devnull_fd, STDERR_FILENO);

2266

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

2267

&quit_now);

2268

dup2(real_stderr_fd, STDERR_FILENO);

2269

if(not success){

2270

break;

2271

}

2272

}

2273

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

2274

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

2275

and (not quit_now)

2276

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

2277

2278

g_assert_true(quit_now);

2279

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

2280

g_assert_true(mandos_client_exited);

2281

}

2282

2283

static void test_start_mandos_client_suid_euid(test_fixture *fixture,

2284

__attribute__((unused))

2285

gconstpointer

2286

user_data){

2287

if(not is_privileged()){

2288

g_test_skip("Not privileged");

2289

return;

2290

}

2291

2292

bool mandos_client_exited = false;

2293

bool quit_now = false;

2294

__attribute__((cleanup(cleanup_close)))

2295

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2296

g_assert_cmpint(epoll_fd, >=, 0);

2297

__attribute__((cleanup(cleanup_queue)))

2298

task_queue *queue = create_queue();

2299

g_assert_nonnull(queue);

2300

__attribute__((cleanup(cleanup_buffer)))

2301

buffer password = {};

2302

bool password_is_read = false;

2303

const char helper_directory[] = "/nonexistent";

2304

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

2305

uid_t user = 1000;

2306

gid_t group = 1001;

2307

2308

const bool success = start_mandos_client(queue, epoll_fd,

2309

&mandos_client_exited,

2310

&quit_now, &password,

2311

&password_is_read,

2312

&fixture->orig_sigaction,

2313

fixture->orig_sigmask,

2314

helper_directory, user,

2315

group, argv);

2316

g_assert_true(success);

2317

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

2318

2319

struct timespec starttime, currtime;

2320

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

2321

do {

2322

queue->next_run = 0;

2323

string_set cancelled_filenames = {};

2324

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

2325

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

2326

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

2327

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

2328

and (not quit_now)

2329

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

2330

2331

g_assert_false(quit_now);

2332

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

2333

g_assert_true(mandos_client_exited);

2334

2335

g_assert_true(password_is_read);

2336

g_assert_nonnull(password.data);

2337

2338

uintmax_t id;

2339

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

2340

==, 1);

2341

g_assert_true((uid_t)id == id);

2342

2343

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

2344

}

2345

2346

static void test_start_mandos_client_suid_egid(test_fixture *fixture,

2347

__attribute__((unused))

2348

gconstpointer

2349

user_data){

2350

if(not is_privileged()){

2351

g_test_skip("Not privileged");

2352

return;

2353

}

2354

2355

bool mandos_client_exited = false;

2356

bool quit_now = false;

2357

__attribute__((cleanup(cleanup_close)))

2358

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2359

g_assert_cmpint(epoll_fd, >=, 0);

2360

__attribute__((cleanup(cleanup_queue)))

2361

task_queue *queue = create_queue();

2362

g_assert_nonnull(queue);

2363

__attribute__((cleanup(cleanup_buffer)))

2364

buffer password = {};

2365

bool password_is_read = false;

2366

const char helper_directory[] = "/nonexistent";

2367

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

2368

uid_t user = 1000;

2369

gid_t group = 1001;

2370

2371

const bool success = start_mandos_client(queue, epoll_fd,

2372

&mandos_client_exited,

2373

&quit_now, &password,

2374

&password_is_read,

2375

&fixture->orig_sigaction,

2376

fixture->orig_sigmask,

2377

helper_directory, user,

2378

group, argv);

2379

g_assert_true(success);

2380

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

2381

2382

struct timespec starttime, currtime;

2383

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

2384

do {

2385

queue->next_run = 0;

2386

string_set cancelled_filenames = {};

2387

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

2388

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

2389

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

2390

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

2391

and (not quit_now)

2392

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

2393

2394

g_assert_false(quit_now);

2395

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

2396

g_assert_true(mandos_client_exited);

2397

2398

g_assert_true(password_is_read);

2399

g_assert_nonnull(password.data);

2400

2401

uintmax_t id;

2402

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

2403

==, 1);

2404

g_assert_true((gid_t)id == id);

2405

2406

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

2407

}

2408

2409

static void test_start_mandos_client_suid_ruid(test_fixture *fixture,

2410

__attribute__((unused))

2411

gconstpointer

2412

user_data){

2413

if(not is_privileged()){

2414

g_test_skip("Not privileged");

2415

return;

2416

}

2417

2418

bool mandos_client_exited = false;

2419

bool quit_now = false;

2420

__attribute__((cleanup(cleanup_close)))

2421

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2422

g_assert_cmpint(epoll_fd, >=, 0);

2423

__attribute__((cleanup(cleanup_queue)))

2424

task_queue *queue = create_queue();

2425

g_assert_nonnull(queue);

2426

__attribute__((cleanup(cleanup_buffer)))

2427

buffer password = {};

2428

bool password_is_read = false;

2429

const char helper_directory[] = "/nonexistent";

2430

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

2431

NULL };

2432

uid_t user = 1000;

2433

gid_t group = 1001;

2434

2435

const bool success = start_mandos_client(queue, epoll_fd,

2436

&mandos_client_exited,

2437

&quit_now, &password,

2438

&password_is_read,

2439

&fixture->orig_sigaction,

2440

fixture->orig_sigmask,

2441

helper_directory, user,

2442

group, argv);

2443

g_assert_true(success);

2444

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

2445

2446

struct timespec starttime, currtime;

2447

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

2448

do {

2449

queue->next_run = 0;

2450

string_set cancelled_filenames = {};

2451

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

2452

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

2453

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

2454

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

2455

and (not quit_now)

2456

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

2457

2458

g_assert_false(quit_now);

2459

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

2460

g_assert_true(mandos_client_exited);

2461

2462

g_assert_true(password_is_read);

2463

g_assert_nonnull(password.data);

2464

2465

uintmax_t id;

2466

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

2467

==, 1);

2468

g_assert_true((uid_t)id == id);

2469

2470

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

2471

}

2472

2473

static void test_start_mandos_client_suid_rgid(test_fixture *fixture,

2474

__attribute__((unused))

2475

gconstpointer

2476

user_data){

2477

if(not is_privileged()){

2478

g_test_skip("Not privileged");

2479

return;

2480

}

2481

2482

bool mandos_client_exited = false;

2483

bool quit_now = false;

2484

__attribute__((cleanup(cleanup_close)))

2485

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2486

g_assert_cmpint(epoll_fd, >=, 0);

2487

__attribute__((cleanup(cleanup_queue)))

2488

task_queue *queue = create_queue();

2489

g_assert_nonnull(queue);

2490

__attribute__((cleanup(cleanup_buffer)))

2491

buffer password = {};

2492

bool password_is_read = false;

2493

const char helper_directory[] = "/nonexistent";

2494

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

2495

NULL };

2496

uid_t user = 1000;

2497

gid_t group = 1001;

2498

2499

const bool success = start_mandos_client(queue, epoll_fd,

2500

&mandos_client_exited,

2501

&quit_now, &password,

2502

&password_is_read,

2503

&fixture->orig_sigaction,

2504

fixture->orig_sigmask,

2505

helper_directory, user,

2506

group, argv);

2507

g_assert_true(success);

2508

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

2509

2510

struct timespec starttime, currtime;

2511

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

2512

do {

2513

queue->next_run = 0;

2514

string_set cancelled_filenames = {};

2515

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

2516

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

2517

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

2518

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

2519

and (not quit_now)

2520

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

2521

2522

g_assert_false(quit_now);

2523

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

2524

g_assert_true(mandos_client_exited);

2525

2526

g_assert_true(password_is_read);

2527

g_assert_nonnull(password.data);

2528

2529

uintmax_t id;

2530

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

2531

==, 1);

2532

g_assert_true((gid_t)id == id);

2533

2534

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

2535

}

2536

2537

static void test_start_mandos_client_read(test_fixture *fixture,

2538

__attribute__((unused))

2539

gconstpointer user_data){

2540

bool mandos_client_exited = false;

2541

bool quit_now = false;

2542

__attribute__((cleanup(cleanup_close)))

2543

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2544

g_assert_cmpint(epoll_fd, >=, 0);

2545

__attribute__((cleanup(cleanup_queue)))

2546

task_queue *queue = create_queue();

2547

g_assert_nonnull(queue);

2548

__attribute__((cleanup(cleanup_buffer)))

2549

buffer password = {};

2550

bool password_is_read = false;

2551

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

2552

const char helper_directory[] = "/nonexistent";

2553

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

2554

NULL };

2555

2556

const bool success = start_mandos_client(queue, epoll_fd,

2557

&mandos_client_exited,

2558

&quit_now, &password,

2559

&password_is_read,

2560

&fixture->orig_sigaction,

2561

fixture->orig_sigmask,

2562

helper_directory, 0, 0,

2563

argv);

2564

g_assert_true(success);

2565

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

2566

2567

struct timespec starttime, currtime;

2568

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

2569

do {

2570

queue->next_run = 0;

2571

string_set cancelled_filenames = {};

2572

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

2573

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

2574

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

2575

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

2576

and (not quit_now)

2577

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

2578

2579

g_assert_false(quit_now);

2580

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

2581

g_assert_true(mandos_client_exited);

2582

2583

g_assert_true(password_is_read);

2584

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

2585

sizeof(dummy_test_password)-1);

2586

g_assert_nonnull(password.data);

2587

g_assert_cmpint(memcmp(dummy_test_password, password.data,

2588

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

2589

}

2590

2591

static

2592

void test_start_mandos_client_helper_directory(test_fixture *fixture,

2593

__attribute__((unused))

2594

gconstpointer

2595

user_data){

2596

bool mandos_client_exited = false;

2597

bool quit_now = false;

2598

__attribute__((cleanup(cleanup_close)))

2599

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2600

g_assert_cmpint(epoll_fd, >=, 0);

2601

__attribute__((cleanup(cleanup_queue)))

2602

task_queue *queue = create_queue();

2603

g_assert_nonnull(queue);

2604

__attribute__((cleanup(cleanup_buffer)))

2605

buffer password = {};

2606

bool password_is_read = false;

2607

const char helper_directory[] = "/nonexistent";

2608

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

2609

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

2610

2611

const bool success = start_mandos_client(queue, epoll_fd,

2612

&mandos_client_exited,

2613

&quit_now, &password,

2614

&password_is_read,

2615

&fixture->orig_sigaction,

2616

fixture->orig_sigmask,

2617

helper_directory, 0, 0,

2618

argv);

2619

g_assert_true(success);

2620

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

2621

2622

struct timespec starttime, currtime;

2623

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

2624

do {

2625

queue->next_run = 0;

2626

string_set cancelled_filenames = {};

2627

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

2628

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

2629

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

2630

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

2631

and (not quit_now)

2632

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

2633

2634

g_assert_false(quit_now);

2635

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

2636

g_assert_true(mandos_client_exited);

2637

2638

g_assert_true(password_is_read);

2639

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

2640

sizeof(helper_directory)-1);

2641

g_assert_nonnull(password.data);

2642

g_assert_cmpint(memcmp(helper_directory, password.data,

2643

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

2644

}

2645

2646

__attribute__((nonnull, warn_unused_result))

2647

static bool proc_status_sigblk_to_sigset(const char *const,

2648

sigset_t *const);

2649

2650

static void test_start_mandos_client_sigmask(test_fixture *fixture,

2651

__attribute__((unused))

2652

gconstpointer user_data){

2653

bool mandos_client_exited = false;

2654

bool quit_now = false;

2655

__attribute__((cleanup(cleanup_close)))

2656

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2657

g_assert_cmpint(epoll_fd, >=, 0);

2658

__attribute__((cleanup(cleanup_queue)))

2659

task_queue *queue = create_queue();

2660

g_assert_nonnull(queue);

2661

__attribute__((cleanup(cleanup_buffer)))

2662

buffer password = {};

2663

bool password_is_read = false;

2664

const char helper_directory[] = "/nonexistent";

2665

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

2666

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

2667

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

2668

2669

g_assert_true(start_mandos_client(queue, epoll_fd,

2670

&mandos_client_exited, &quit_now,

2671

&password, &password_is_read,

2672

&fixture->orig_sigaction,

2673

fixture->orig_sigmask,

2674

helper_directory, 0, 0, argv));

2675

2676

struct timespec starttime, currtime;

2677

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

2678

do {

2679

queue->next_run = 0;

2680

string_set cancelled_filenames = {};

2681

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

2682

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

2683

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

2684

} while((not (mandos_client_exited and password_is_read))

2685

and (not quit_now)

2686

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

2687

g_assert_true(mandos_client_exited);

2688

g_assert_true(password_is_read);

2689

2690

sigset_t parsed_sigmask;

2691

g_assert_true(proc_status_sigblk_to_sigset(password.data,

2692

&parsed_sigmask));

2693

2694

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

2695

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

2696

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

2697

g_assert_true(has_signal);

2698

} else {

2699

g_assert_false(has_signal);

2700

}

2701

}

2702

}

2703

2704

__attribute__((nonnull, warn_unused_result))

2705

static bool proc_status_sigblk_to_sigset(const char *const sigblk,

2706

sigset_t *const sigmask){

2707

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

2708

uintmax_t scanned_sigmask;

2709

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

2710

return false;

2711

}

2712

if(sigemptyset(sigmask) != 0){

2713

return false;

2714

}

2715

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

2716

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

2717

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

2718

return false;

2719

}

2720

}

2721

}

2722

return true;

2723

}

2724

2725

static void run_task_with_stderr_to_dev_null(const task_context task,

2726

task_queue *const queue);

2727

2728

static

2729

void test_wait_for_mandos_client_exit_badpid(__attribute__((unused))

2730

test_fixture *fixture,

2731

__attribute__((unused))

2732

gconstpointer user_data){

2733

2734

bool mandos_client_exited = false;

2735

bool quit_now = false;

2736

2737

__attribute__((cleanup(cleanup_queue)))

2738

task_queue *queue = create_queue();

2739

g_assert_nonnull(queue);

2740

const task_context task = {

2741

.func=wait_for_mandos_client_exit,

2742

.pid=1,

2743

.mandos_client_exited=&mandos_client_exited,

2744

.quit_now=&quit_now,

2745

};

2746

run_task_with_stderr_to_dev_null(task, queue);

2747

2748

g_assert_false(mandos_client_exited);

2749

g_assert_true(quit_now);

2750

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

2751

}

2752

2753

static void run_task_with_stderr_to_dev_null(const task_context task,

2754

task_queue *const queue){

2755

FILE *real_stderr = stderr;

2756

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

2757

g_assert_nonnull(devnull);

2758

2759

stderr = devnull;

2760

task.func(task, queue);

2761

stderr = real_stderr;

2762

2763

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

2764

}

2765

2766

static

2767

void test_wait_for_mandos_client_exit_noexit(test_fixture *fixture,

2768

__attribute__((unused))

2769

gconstpointer user_data){

2770

bool mandos_client_exited = false;

2771

bool quit_now = false;

2772

2773

pid_t create_eternal_process(void){

2774

const pid_t pid = fork();

2775

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

2776

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

2777

_exit(EXIT_FAILURE);

2778

}

2779

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

2780

_exit(EXIT_FAILURE);

2781

}

2782

while(true){

2783

pause();

2784

}

2785

}

2786

return pid;

2787

}

2788

pid_t pid = create_eternal_process();

2789

g_assert_true(pid != -1);

2790

2791

__attribute__((cleanup(cleanup_queue)))

2792

task_queue *queue = create_queue();

2793

g_assert_nonnull(queue);

2794

const task_context task = {

2795

.func=wait_for_mandos_client_exit,

2796

.pid=pid,

2797

.mandos_client_exited=&mandos_client_exited,

2798

.quit_now=&quit_now,

2799

};

2800

task.func(task, queue);

2801

2802

g_assert_false(mandos_client_exited);

2803

g_assert_false(quit_now);

2804

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

2805

2806

g_assert_nonnull(find_matching_task(queue, (task_context){

2807

.func=wait_for_mandos_client_exit,

2808

.pid=task.pid,

2809

.mandos_client_exited=&mandos_client_exited,

2810

.quit_now=&quit_now,

2811

}));

2812

}

2813

2814

static

2815

void test_wait_for_mandos_client_exit_success(test_fixture *fixture,

2816

__attribute__((unused))

2817

gconstpointer

2818

user_data){

2819

bool mandos_client_exited = false;

2820

bool quit_now = false;

2821

2822

pid_t create_successful_process(void){

2823

const pid_t pid = fork();

2824

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

2825

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

2826

_exit(EXIT_FAILURE);

2827

}

2828

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

2829

_exit(EXIT_FAILURE);

2830

}

2831

exit(EXIT_SUCCESS);

2832

}

2833

return pid;

2834

}

2835

const pid_t pid = create_successful_process();

2836

g_assert_true(pid != -1);

2837

2838

__attribute__((cleanup(cleanup_queue)))

2839

task_queue *queue = create_queue();

2840

g_assert_nonnull(queue);

2841

const task_context initial_task = {

2842

.func=wait_for_mandos_client_exit,

2843

.pid=pid,

2844

.mandos_client_exited=&mandos_client_exited,

2845

.quit_now=&quit_now,

2846

};

2847

g_assert_true(add_to_queue(queue, initial_task));

2848

2849

struct timespec starttime, currtime;

2850

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

2851

__attribute__((cleanup(cleanup_close)))

2852

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2853

do {

2854

queue->next_run = 0;

2855

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

2856

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

2857

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

2858

} while((not mandos_client_exited)

2859

and (not quit_now)

2860

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

2861

2862

g_assert_true(mandos_client_exited);

2863

g_assert_false(quit_now);

2864

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

2865

}

2866

2867

static

2868

void test_wait_for_mandos_client_exit_failure(test_fixture *fixture,

2869

__attribute__((unused))

2870

gconstpointer

2871

user_data){

2872

bool mandos_client_exited = false;

2873

bool quit_now = false;

2874

2875

pid_t create_failing_process(void){

2876

const pid_t pid = fork();

2877

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

2878

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

2879

_exit(EXIT_FAILURE);

2880

}

2881

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

2882

_exit(EXIT_FAILURE);

2883

}

2884

exit(EXIT_FAILURE);

2885

}

2886

return pid;

2887

}

2888

const pid_t pid = create_failing_process();

2889

g_assert_true(pid != -1);

2890

2891

__attribute__((cleanup(string_set_clear)))

2892

string_set cancelled_filenames = {};

2893

__attribute__((cleanup(cleanup_close)))

2894

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2895

g_assert_cmpint(epoll_fd, >=, 0);

2896

__attribute__((cleanup(cleanup_queue)))

2897

task_queue *queue = create_queue();

2898

g_assert_nonnull(queue);

2899

g_assert_true(add_to_queue(queue, (task_context){

2900

.func=wait_for_mandos_client_exit,

2901

.pid=pid,

2902

.mandos_client_exited=&mandos_client_exited,

2903

.quit_now=&quit_now,

2904

}));

2905

2906

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

2907

2908

__attribute__((cleanup(cleanup_close)))

2909

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

2910

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2911

g_assert_cmpint(devnull_fd, >=, 0);

2912

__attribute__((cleanup(cleanup_close)))

2913

const int real_stderr_fd = dup(STDERR_FILENO);

2914

g_assert_cmpint(real_stderr_fd, >=, 0);

2915

2916

struct timespec starttime, currtime;

2917

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

2918

do {

2919

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

2920

dup2(devnull_fd, STDERR_FILENO);

2921

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

2922

&quit_now);

2923

dup2(real_stderr_fd, STDERR_FILENO);

2924

if(not success){

2925

break;

2926

}

2927

2928

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

2929

} while((not mandos_client_exited)

2930

and (not quit_now)

2931

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

2932

2933

g_assert_true(quit_now);

2934

g_assert_true(mandos_client_exited);

2935

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

2936

}

2937

2938

static

2939

void test_wait_for_mandos_client_exit_killed(test_fixture *fixture,

2940

__attribute__((unused))

2941

gconstpointer user_data){

2942

bool mandos_client_exited = false;

2943

bool quit_now = false;

2944

2945

pid_t create_killed_process(void){

2946

const pid_t pid = fork();

2947

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

2948

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

2949

_exit(EXIT_FAILURE);

2950

}

2951

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

2952

_exit(EXIT_FAILURE);

2953

}

2954

while(true){

2955

pause();

2956

}

2957

}

2958

kill(pid, SIGKILL);

2959

return pid;

2960

}

2961

const pid_t pid = create_killed_process();

2962

g_assert_true(pid != -1);

2963

2964

__attribute__((cleanup(string_set_clear)))

2965

string_set cancelled_filenames = {};

2966

__attribute__((cleanup(cleanup_close)))

2967

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2968

g_assert_cmpint(epoll_fd, >=, 0);

2969

__attribute__((cleanup(cleanup_queue)))

2970

task_queue *queue = create_queue();

2971

g_assert_nonnull(queue);

2972

g_assert_true(add_to_queue(queue, (task_context){

2973

.func=wait_for_mandos_client_exit,

2974

.pid=pid,

2975

.mandos_client_exited=&mandos_client_exited,

2976

.quit_now=&quit_now,

2977

}));

2978

2979

__attribute__((cleanup(cleanup_close)))

2980

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

2981

O_WRONLY | O_CLOEXEC, O_NOCTTY);

2982

g_assert_cmpint(devnull_fd, >=, 0);

2983

__attribute__((cleanup(cleanup_close)))

2984

const int real_stderr_fd = dup(STDERR_FILENO);

2985

g_assert_cmpint(real_stderr_fd, >=, 0);

2986

2987

struct timespec starttime, currtime;

2988

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

2989

do {

2990

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

2991

dup2(devnull_fd, STDERR_FILENO);

2992

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

2993

&quit_now);

2994

dup2(real_stderr_fd, STDERR_FILENO);

2995

if(not success){

2996

break;

2997

}

2998

2999

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

3000

} while((not mandos_client_exited)

3001

and (not quit_now)

3002

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

3003

3004

g_assert_true(mandos_client_exited);

3005

g_assert_true(quit_now);

3006

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

3007

}

3008

3009

static bool epoll_set_does_not_contain(int, int);

3010

3011

static

3012

void test_read_mandos_client_output_readerror(__attribute__((unused))

3013

test_fixture *fixture,

3014

__attribute__((unused))

3015

gconstpointer

3016

user_data){

3017

__attribute__((cleanup(cleanup_close)))

3018

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3019

g_assert_cmpint(epoll_fd, >=, 0);

3020

3021

__attribute__((cleanup(cleanup_buffer)))

3022

buffer password = {};

3023

3024

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

3025

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

3026

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3027

3028

bool password_is_read = false;

3029

bool quit_now = false;

3030

__attribute__((cleanup(cleanup_queue)))

3031

task_queue *queue = create_queue();

3032

g_assert_nonnull(queue);

3033

3034

task_context task = {

3035

.func=read_mandos_client_output,

3036

.epoll_fd=epoll_fd,

3037

.fd=fd,

3038

.password=&password,

3039

.password_is_read=&password_is_read,

3040

.quit_now=&quit_now,

3041

};

3042

run_task_with_stderr_to_dev_null(task, queue);

3043

g_assert_false(password_is_read);

3044

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

3045

g_assert_true(quit_now);

3046

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

3047

3048

g_assert_true(epoll_set_does_not_contain(epoll_fd, fd));

3049

3050

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

3051

}

3052

3053

static bool epoll_set_does_not_contain(int epoll_fd, int fd){

3054

return not epoll_set_contains(epoll_fd, fd, 0);

3055

}

3056

3057

static

3058

void test_read_mandos_client_output_nodata(__attribute__((unused))

3059

test_fixture *fixture,

3060

__attribute__((unused))

3061

gconstpointer user_data){

3062

__attribute__((cleanup(cleanup_close)))

3063

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3064

g_assert_cmpint(epoll_fd, >=, 0);

3065

3066

int pipefds[2];

3067

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

3068

3069

__attribute__((cleanup(cleanup_buffer)))

3070

buffer password = {};

3071

3072

bool password_is_read = false;

3073

bool quit_now = false;

3074

__attribute__((cleanup(cleanup_queue)))

3075

task_queue *queue = create_queue();

3076

g_assert_nonnull(queue);

3077

3078

task_context task = {

3079

.func=read_mandos_client_output,

3080

.epoll_fd=epoll_fd,

3081

.fd=pipefds[0],

3082

.password=&password,

3083

.password_is_read=&password_is_read,

3084

.quit_now=&quit_now,

3085

};

3086

task.func(task, queue);

3087

g_assert_false(password_is_read);

3088

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

3089

g_assert_false(quit_now);

3090

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

3091

3092

g_assert_nonnull(find_matching_task(queue, (task_context){

3093

.func=read_mandos_client_output,

3094

.epoll_fd=epoll_fd,

3095

.fd=pipefds[0],

3096

.password=&password,

3097

.password_is_read=&password_is_read,

3098

.quit_now=&quit_now,

3099

}));

3100

3101

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3102

EPOLLIN | EPOLLRDHUP));

3103

3104

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

3105

}

3106

3107

static void test_read_mandos_client_output_eof(__attribute__((unused))

3108

test_fixture *fixture,

3109

__attribute__((unused))

3110

gconstpointer

3111

user_data){

3112

__attribute__((cleanup(cleanup_close)))

3113

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3114

g_assert_cmpint(epoll_fd, >=, 0);

3115

3116

int pipefds[2];

3117

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

3118

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

3119

3120

__attribute__((cleanup(cleanup_buffer)))

3121

buffer password = {};

3122

3123

bool password_is_read = false;

3124

bool quit_now = false;

3125

__attribute__((cleanup(cleanup_queue)))

3126

task_queue *queue = create_queue();

3127

g_assert_nonnull(queue);

3128

3129

task_context task = {

3130

.func=read_mandos_client_output,

3131

.epoll_fd=epoll_fd,

3132

.fd=pipefds[0],

3133

.password=&password,

3134

.password_is_read=&password_is_read,

3135

.quit_now=&quit_now,

3136

};

3137

task.func(task, queue);

3138

g_assert_true(password_is_read);

3139

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

3140

g_assert_false(quit_now);

3141

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

3142

3143

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

3144

3145

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

3146

}

3147

3148

static

3149

void test_read_mandos_client_output_once(__attribute__((unused))

3150

test_fixture *fixture,

3151

__attribute__((unused))

3152

gconstpointer user_data){

3153

__attribute__((cleanup(cleanup_close)))

3154

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3155

g_assert_cmpint(epoll_fd, >=, 0);

3156

3157

int pipefds[2];

3158

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

3159

3160

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

3161

/* Start with a pre-allocated buffer */

3162

__attribute__((cleanup(cleanup_buffer)))

3163

buffer password = {

3164

.data=malloc(sizeof(dummy_test_password)),

3165

.length=0,

3166

.allocated=sizeof(dummy_test_password),

3167

};

3168

g_assert_nonnull(password.data);

3169

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

3170

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

3171

}

3172

3173

bool password_is_read = false;

3174

bool quit_now = false;

3175

__attribute__((cleanup(cleanup_queue)))

3176

task_queue *queue = create_queue();

3177

g_assert_nonnull(queue);

3178

3179

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3180

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

3181

sizeof(dummy_test_password)),

3182

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

3183

3184

task_context task = {

3185

.func=read_mandos_client_output,

3186

.epoll_fd=epoll_fd,

3187

.fd=pipefds[0],

3188

.password=&password,

3189

.password_is_read=&password_is_read,

3190

.quit_now=&quit_now,

3191

};

3192

task.func(task, queue);

3193

3194

g_assert_false(password_is_read);

3195

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

3196

(int)sizeof(dummy_test_password));

3197

g_assert_nonnull(password.data);

3198

g_assert_cmpint(memcmp(password.data, dummy_test_password,

3199

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

3200

3201

g_assert_false(quit_now);

3202

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

3203

3204

g_assert_nonnull(find_matching_task(queue, (task_context){

3205

.func=read_mandos_client_output,

3206

.epoll_fd=epoll_fd,

3207

.fd=pipefds[0],

3208

.password=&password,

3209

.password_is_read=&password_is_read,

3210

.quit_now=&quit_now,

3211

}));

3212

3213

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3214

EPOLLIN | EPOLLRDHUP));

3215

3216

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

3217

}

3218

3219

static

3220

void test_read_mandos_client_output_malloc(__attribute__((unused))

3221

test_fixture *fixture,

3222

__attribute__((unused))

3223

gconstpointer user_data){

3224

__attribute__((cleanup(cleanup_close)))

3225

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3226

g_assert_cmpint(epoll_fd, >=, 0);

3227

3228

int pipefds[2];

3229

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

3230

3231

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

3232

/* Start with an empty buffer */

3233

__attribute__((cleanup(cleanup_buffer)))

3234

buffer password = {};

3235

3236

bool password_is_read = false;

3237

bool quit_now = false;

3238

__attribute__((cleanup(cleanup_queue)))

3239

task_queue *queue = create_queue();

3240

g_assert_nonnull(queue);

3241

3242

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3243

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

3244

sizeof(dummy_test_password)),

3245

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

3246

3247

task_context task = {

3248

.func=read_mandos_client_output,

3249

.epoll_fd=epoll_fd,

3250

.fd=pipefds[0],

3251

.password=&password,

3252

.password_is_read=&password_is_read,

3253

.quit_now=&quit_now,

3254

};

3255

task.func(task, queue);

3256

3257

g_assert_false(password_is_read);

3258

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

3259

(int)sizeof(dummy_test_password));

3260

g_assert_nonnull(password.data);

3261

g_assert_cmpint(memcmp(password.data, dummy_test_password,

3262

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

3263

3264

g_assert_false(quit_now);

3265

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

3266

3267

g_assert_nonnull(find_matching_task(queue, (task_context){

3268

.func=read_mandos_client_output,

3269

.epoll_fd=epoll_fd,

3270

.fd=pipefds[0],

3271

.password=&password,

3272

.password_is_read=&password_is_read,

3273

.quit_now=&quit_now,

3274

}));

3275

3276

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3277

EPOLLIN | EPOLLRDHUP));

3278

3279

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

3280

}

3281

3282

static

3283

void test_read_mandos_client_output_append(__attribute__((unused))

3284

test_fixture *fixture,

3285

__attribute__((unused))

3286

gconstpointer user_data){

3287

__attribute__((cleanup(cleanup_close)))

3288

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3289

g_assert_cmpint(epoll_fd, >=, 0);

3290

3291

int pipefds[2];

3292

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

3293

3294

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

3295

__attribute__((cleanup(cleanup_buffer)))

3296

buffer password = {

3297

.data=malloc(PIPE_BUF),

3298

.length=PIPE_BUF,

3299

.allocated=PIPE_BUF,

3300

};

3301

g_assert_nonnull(password.data);

3302

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

3303

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

3304

}

3305

3306

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

3307

char password_expected[PIPE_BUF];

3308

memcpy(password_expected, password.data, PIPE_BUF);

3309

3310

bool password_is_read = false;

3311

bool quit_now = false;

3312

__attribute__((cleanup(cleanup_queue)))

3313

task_queue *queue = create_queue();

3314

g_assert_nonnull(queue);

3315

3316

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3317

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

3318

sizeof(dummy_test_password)),

3319

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

3320

3321

task_context task = {

3322

.func=read_mandos_client_output,

3323

.epoll_fd=epoll_fd,

3324

.fd=pipefds[0],

3325

.password=&password,

3326

.password_is_read=&password_is_read,

3327

.quit_now=&quit_now,

3328

};

3329

task.func(task, queue);

3330

3331

g_assert_false(password_is_read);

3332

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

3333

PIPE_BUF + sizeof(dummy_test_password));

3334

g_assert_nonnull(password.data);

3335

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

3336

==, 0);

3337

g_assert_cmpint(memcmp(password.data + PIPE_BUF,

3338

dummy_test_password,

3339

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

3340

g_assert_false(quit_now);

3341

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

3342

3343

g_assert_nonnull(find_matching_task(queue, (task_context){

3344

.func=read_mandos_client_output,

3345

.epoll_fd=epoll_fd,

3346

.fd=pipefds[0],

3347

.password=&password,

3348

.password_is_read=&password_is_read,

3349

.quit_now=&quit_now,

3350

}));

3351

3352

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3353

EPOLLIN | EPOLLRDHUP));

3354

}

3355

3356

static char *make_temporary_directory(void);

3357

3358

static void test_add_inotify_dir_watch(__attribute__((unused))

3359

test_fixture *fixture,

3360

__attribute__((unused))

3361

gconstpointer user_data){

3362

__attribute__((cleanup(cleanup_close)))

3363

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3364

g_assert_cmpint(epoll_fd, >=, 0);

3365

__attribute__((cleanup(cleanup_queue)))

3366

task_queue *queue = create_queue();

3367

g_assert_nonnull(queue);

3368

__attribute__((cleanup(string_set_clear)))

3369

string_set cancelled_filenames = {};

3370

const mono_microsecs current_time = 0;

3371

3372

bool quit_now = false;

3373

buffer password = {};

3374

bool mandos_client_exited = false;

3375

bool password_is_read = false;

3376

3377

__attribute__((cleanup(cleanup_string)))

3378

char *tempdir = make_temporary_directory();

3379

g_assert_nonnull(tempdir);

3380

3381

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3382

&password, tempdir,

3383

&cancelled_filenames,

3384

&current_time,

3385

&mandos_client_exited,

3386

&password_is_read));

3387

3388

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

3389

3390

const task_context *const added_read_task

3391

= find_matching_task(queue, (task_context){

3392

.func=read_inotify_event,

3393

.epoll_fd=epoll_fd,

3394

.quit_now=&quit_now,

3395

.password=&password,

3396

.filename=tempdir,

3397

.cancelled_filenames=&cancelled_filenames,

3398

.current_time=&current_time,

3399

.mandos_client_exited=&mandos_client_exited,

3400

.password_is_read=&password_is_read,

3401

});

3402

g_assert_nonnull(added_read_task);

3403

3404

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

3405

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3406

g_assert_true(epoll_set_contains(added_read_task->epoll_fd,

3407

added_read_task->fd,

3408

EPOLLIN | EPOLLRDHUP));

3409

3410

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

3411

}

3412

3413

static char *make_temporary_directory(void){

3414

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

3415

g_assert_nonnull(name);

3416

char *result = mkdtemp(name);

3417

if(result == NULL){

3418

free(name);

3419

}

3420

return result;

3421

}

3422

3423

static void test_add_inotify_dir_watch_fail(__attribute__((unused))

3424

test_fixture *fixture,

3425

__attribute__((unused))

3426

gconstpointer user_data){

3427

__attribute__((cleanup(cleanup_close)))

3428

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3429

g_assert_cmpint(epoll_fd, >=, 0);

3430

__attribute__((cleanup(cleanup_queue)))

3431

task_queue *queue = create_queue();

3432

g_assert_nonnull(queue);

3433

__attribute__((cleanup(string_set_clear)))

3434

string_set cancelled_filenames = {};

3435

const mono_microsecs current_time = 0;

3436

3437

bool quit_now = false;

3438

buffer password = {};

3439

bool mandos_client_exited = false;

3440

bool password_is_read = false;

3441

3442

const char nonexistent_dir[] = "/nonexistent";

3443

3444

FILE *real_stderr = stderr;

3445

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

3446

g_assert_nonnull(devnull);

3447

stderr = devnull;

3448

g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3449

&password, nonexistent_dir,

3450

&cancelled_filenames,

3451

&current_time,

3452

&mandos_client_exited,

3453

&password_is_read));

3454

stderr = real_stderr;

3455

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

3456

3457

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

3458

}

3459

3460

static void test_add_inotify_dir_watch_nondir(__attribute__((unused))

3461

test_fixture *fixture,

3462

__attribute__((unused))

3463

gconstpointer

3464

user_data){

3465

__attribute__((cleanup(cleanup_close)))

3466

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3467

g_assert_cmpint(epoll_fd, >=, 0);

3468

__attribute__((cleanup(cleanup_queue)))

3469

task_queue *queue = create_queue();

3470

g_assert_nonnull(queue);

3471

__attribute__((cleanup(string_set_clear)))

3472

string_set cancelled_filenames = {};

3473

const mono_microsecs current_time = 0;

3474

3475

bool quit_now = false;

3476

buffer password = {};

3477

bool mandos_client_exited = false;

3478

bool password_is_read = false;

3479

3480

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

3481

3482

FILE *real_stderr = stderr;

3483

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

3484

g_assert_nonnull(devnull);

3485

stderr = devnull;

3486

g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3487

&password, not_a_directory,

3488

&cancelled_filenames,

3489

&current_time,

3490

&mandos_client_exited,

3491

&password_is_read));

3492

stderr = real_stderr;

3493

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

3494

3495

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

3496

}

3497

3498

static void test_add_inotify_dir_watch_EAGAIN(__attribute__((unused))

3499

test_fixture *fixture,

3500

__attribute__((unused))

3501

gconstpointer

3502

user_data){

3503

__attribute__((cleanup(cleanup_close)))

3504

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3505

g_assert_cmpint(epoll_fd, >=, 0);

3506

__attribute__((cleanup(cleanup_queue)))

3507

task_queue *queue = create_queue();

3508

g_assert_nonnull(queue);

3509

__attribute__((cleanup(string_set_clear)))

3510

string_set cancelled_filenames = {};

3511

const mono_microsecs current_time = 0;

3512

3513

bool quit_now = false;

3514

buffer password = {};

3515

bool mandos_client_exited = false;

3516

bool password_is_read = false;

3517

3518

__attribute__((cleanup(cleanup_string)))

3519

char *tempdir = make_temporary_directory();

3520

g_assert_nonnull(tempdir);

3521

3522

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3523

&password, tempdir,

3524

&cancelled_filenames,

3525

&current_time,

3526

&mandos_client_exited,

3527

&password_is_read));

3528

3529

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

3530

3531

const task_context *const added_read_task

3532

= find_matching_task(queue,

3533

(task_context){ .func=read_inotify_event });

3534

g_assert_nonnull(added_read_task);

3535

3536

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

3537

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3538

3539

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

3540

const size_t ievent_size = (sizeof(struct inotify_event)

3541

+ NAME_MAX + 1);

3542

struct inotify_event *ievent = malloc(ievent_size);

3543

g_assert_nonnull(ievent);

3544

3545

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

3546

-1);

3547

g_assert_cmpint(errno, ==, EAGAIN);

3548

3549

free(ievent);

3550

3551

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

3552

}

3553

3554

static char *make_temporary_file_in_directory(const char

3555

*const dir);

3556

3557

static

3558

void test_add_inotify_dir_watch_IN_CLOSE_WRITE(__attribute__((unused))

3559

test_fixture *fixture,

3560

__attribute__((unused))

3561

gconstpointer

3562

user_data){

3563

__attribute__((cleanup(cleanup_close)))

3564

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3565

g_assert_cmpint(epoll_fd, >=, 0);

3566

__attribute__((cleanup(cleanup_queue)))

3567

task_queue *queue = create_queue();

3568

g_assert_nonnull(queue);

3569

__attribute__((cleanup(string_set_clear)))

3570

string_set cancelled_filenames = {};

3571

const mono_microsecs current_time = 0;

3572

3573

bool quit_now = false;

3574

buffer password = {};

3575

bool mandos_client_exited = false;

3576

bool password_is_read = false;

3577

3578

__attribute__((cleanup(cleanup_string)))

3579

char *tempdir = make_temporary_directory();

3580

g_assert_nonnull(tempdir);

3581

3582

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3583

&password, tempdir,

3584

&cancelled_filenames,

3585

&current_time,

3586

&mandos_client_exited,

3587

&password_is_read));

3588

3589

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

3590

3591

const task_context *const added_read_task

3592

= find_matching_task(queue,

3593

(task_context){ .func=read_inotify_event });

3594

g_assert_nonnull(added_read_task);

3595

3596

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

3597

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3598

3599

__attribute__((cleanup(cleanup_string)))

3600

char *filename = make_temporary_file_in_directory(tempdir);

3601

g_assert_nonnull(filename);

3602

3603

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

3604

const size_t ievent_size = (sizeof(struct inotify_event)

3605

+ NAME_MAX + 1);

3606

struct inotify_event *ievent = malloc(ievent_size);

3607

g_assert_nonnull(ievent);

3608

3609

ssize_t read_size = 0;

3610

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

3611

3612

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

3613

g_assert_true(ievent->mask & IN_CLOSE_WRITE);

3614

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

3615

3616

free(ievent);

3617

3618

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

3619

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

3620

}

3621

3622

static char *make_temporary_prefixed_file_in_directory(const char

3623

*const prefix,

3624

const char

3625

*const dir){

3626

char *filename = NULL;

3627

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

3628

>, 0);

3629

g_assert_nonnull(filename);

3630

const int fd = mkostemp(filename, O_CLOEXEC);

3631

g_assert_cmpint(fd, >=, 0);

3632

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

3633

return filename;

3634

}

3635

3636

static char *make_temporary_file_in_directory(const char

3637

*const dir){

3638

return make_temporary_prefixed_file_in_directory("temp", dir);

3639

}

3640

3641

static

3642

void test_add_inotify_dir_watch_IN_MOVED_TO(__attribute__((unused))

3643

test_fixture *fixture,

3644

__attribute__((unused))

3645

gconstpointer user_data){

3646

__attribute__((cleanup(cleanup_close)))

3647

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3648

g_assert_cmpint(epoll_fd, >=, 0);

3649

__attribute__((cleanup(cleanup_queue)))

3650

task_queue *queue = create_queue();

3651

g_assert_nonnull(queue);

3652

__attribute__((cleanup(string_set_clear)))

3653

string_set cancelled_filenames = {};

3654

const mono_microsecs current_time = 0;

3655

3656

bool quit_now = false;

3657

buffer password = {};

3658

bool mandos_client_exited = false;

3659

bool password_is_read = false;

3660

3661

__attribute__((cleanup(cleanup_string)))

3662

char *watchdir = make_temporary_directory();

3663

g_assert_nonnull(watchdir);

3664

3665

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3666

&password, watchdir,

3667

&cancelled_filenames,

3668

&current_time,

3669

&mandos_client_exited,

3670

&password_is_read));

3671

3672

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

3673

3674

const task_context *const added_read_task

3675

= find_matching_task(queue,

3676

(task_context){ .func=read_inotify_event });

3677

g_assert_nonnull(added_read_task);

3678

3679

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

3680

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3681

3682

char *sourcedir = make_temporary_directory();

3683

g_assert_nonnull(sourcedir);

3684

3685

__attribute__((cleanup(cleanup_string)))

3686

char *filename = make_temporary_file_in_directory(sourcedir);

3687

g_assert_nonnull(filename);

3688

3689

__attribute__((cleanup(cleanup_string)))

3690

char *targetfilename = NULL;

3691

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

3692

basename(filename)), >, 0);

3693

g_assert_nonnull(targetfilename);

3694

3695

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

3696

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

3697

free(sourcedir);

3698

3699

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

3700

const size_t ievent_size = (sizeof(struct inotify_event)

3701

+ NAME_MAX + 1);

3702

struct inotify_event *ievent = malloc(ievent_size);

3703

g_assert_nonnull(ievent);

3704

3705

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

3706

3707

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

3708

g_assert_true(ievent->mask & IN_MOVED_TO);

3709

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

3710

3711

free(ievent);

3712

3713

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

3714

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

3715

}

3716

3717

static

3718

void test_add_inotify_dir_watch_IN_MOVED_FROM(__attribute__((unused))

3719

test_fixture *fixture,

3720

__attribute__((unused))

3721

gconstpointer

3722

user_data){

3723

__attribute__((cleanup(cleanup_close)))

3724

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3725

g_assert_cmpint(epoll_fd, >=, 0);

3726

__attribute__((cleanup(cleanup_queue)))

3727

task_queue *queue = create_queue();

3728

g_assert_nonnull(queue);

3729

__attribute__((cleanup(string_set_clear)))

3730

string_set cancelled_filenames = {};

3731

const mono_microsecs current_time = 0;

3732

3733

bool quit_now = false;

3734

buffer password = {};

3735

bool mandos_client_exited = false;

3736

bool password_is_read = false;

3737

3738

__attribute__((cleanup(cleanup_string)))

3739

char *tempdir = make_temporary_directory();

3740

g_assert_nonnull(tempdir);

3741

3742

__attribute__((cleanup(cleanup_string)))

3743

char *tempfilename = make_temporary_file_in_directory(tempdir);

3744

g_assert_nonnull(tempfilename);

3745

3746

__attribute__((cleanup(cleanup_string)))

3747

char *targetdir = make_temporary_directory();

3748

g_assert_nonnull(targetdir);

3749

3750

__attribute__((cleanup(cleanup_string)))

3751

char *targetfilename = NULL;

3752

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

3753

basename(tempfilename)), >, 0);

3754

g_assert_nonnull(targetfilename);

3755

3756

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3757

&password, tempdir,

3758

&cancelled_filenames,

3759

&current_time,

3760

&mandos_client_exited,

3761

&password_is_read));

3762

3763

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

3764

3765

const task_context *const added_read_task

3766

= find_matching_task(queue,

3767

(task_context){ .func=read_inotify_event });

3768

g_assert_nonnull(added_read_task);

3769

3770

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

3771

const size_t ievent_size = (sizeof(struct inotify_event)

3772

+ NAME_MAX + 1);

3773

struct inotify_event *ievent = malloc(ievent_size);

3774

g_assert_nonnull(ievent);

3775

3776

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

3777

3778

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

3779

g_assert_true(ievent->mask & IN_MOVED_FROM);

3780

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

3781

3782

free(ievent);

3783

3784

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

3785

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

3786

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

3787

}

3788

3789

static

3790

void test_add_inotify_dir_watch_IN_DELETE(__attribute__((unused))

3791

test_fixture *fixture,

3792

__attribute__((unused))

3793

gconstpointer user_data){

3794

__attribute__((cleanup(cleanup_close)))

3795

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3796

g_assert_cmpint(epoll_fd, >=, 0);

3797

__attribute__((cleanup(cleanup_queue)))

3798

task_queue *queue = create_queue();

3799

g_assert_nonnull(queue);

3800

__attribute__((cleanup(string_set_clear)))

3801

string_set cancelled_filenames = {};

3802

const mono_microsecs current_time = 0;

3803

3804

bool quit_now = false;

3805

buffer password = {};

3806

bool mandos_client_exited = false;

3807

bool password_is_read = false;

3808

3809

__attribute__((cleanup(cleanup_string)))

3810

char *tempdir = make_temporary_directory();

3811

g_assert_nonnull(tempdir);

3812

3813

__attribute__((cleanup(cleanup_string)))

3814

char *tempfile = make_temporary_file_in_directory(tempdir);

3815

g_assert_nonnull(tempfile);

3816

3817

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3818

&password, tempdir,

3819

&cancelled_filenames,

3820

&current_time,

3821

&mandos_client_exited,

3822

&password_is_read));

3823

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

3824

3825

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

3826

3827

const task_context *const added_read_task

3828

= find_matching_task(queue,

3829

(task_context){ .func=read_inotify_event });

3830

g_assert_nonnull(added_read_task);

3831

3832

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

3833

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3834

3835

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

3836

const size_t ievent_size = (sizeof(struct inotify_event)

3837

+ NAME_MAX + 1);

3838

struct inotify_event *ievent = malloc(ievent_size);

3839

g_assert_nonnull(ievent);

3840

3841

ssize_t read_size = 0;

3842

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

3843

3844

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

3845

g_assert_true(ievent->mask & IN_DELETE);

3846

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

3847

3848

free(ievent);

3849

3850

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

3851

}

3852

3853

static

3854

void test_add_inotify_dir_watch_IN_EXCL_UNLINK(__attribute__((unused))

3855

test_fixture *fixture,

3856

__attribute__((unused))

3857

gconstpointer

3858

user_data){

3859

__attribute__((cleanup(cleanup_close)))

3860

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3861

g_assert_cmpint(epoll_fd, >=, 0);

3862

__attribute__((cleanup(cleanup_queue)))

3863

task_queue *queue = create_queue();

3864

g_assert_nonnull(queue);

3865

__attribute__((cleanup(string_set_clear)))

3866

string_set cancelled_filenames = {};

3867

const mono_microsecs current_time = 0;

3868

3869

bool quit_now = false;

3870

buffer password = {};

3871

bool mandos_client_exited = false;

3872

bool password_is_read = false;

3873

3874

__attribute__((cleanup(cleanup_string)))

3875

char *tempdir = make_temporary_directory();

3876

g_assert_nonnull(tempdir);

3877

3878

__attribute__((cleanup(cleanup_string)))

3879

char *tempfile = make_temporary_file_in_directory(tempdir);

3880

g_assert_nonnull(tempfile);

3881

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

3882

| O_NOFOLLOW);

3883

g_assert_cmpint(tempfile_fd, >, 2);

3884

3885

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3886

&password, tempdir,

3887

&cancelled_filenames,

3888

&current_time,

3889

&mandos_client_exited,

3890

&password_is_read));

3891

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

3892

3893

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

3894

3895

const task_context *const added_read_task

3896

= find_matching_task(queue,

3897

(task_context){ .func=read_inotify_event });

3898

g_assert_nonnull(added_read_task);

3899

3900

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

3901

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3902

3903

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

3904

const size_t ievent_size = (sizeof(struct inotify_event)

3905

+ NAME_MAX + 1);

3906

struct inotify_event *ievent = malloc(ievent_size);

3907

g_assert_nonnull(ievent);

3908

3909

ssize_t read_size = 0;

3910

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

3911

3912

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

3913

g_assert_true(ievent->mask & IN_DELETE);

3914

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

3915

3916

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

3917

3918

/* IN_EXCL_UNLINK should make the closing of the previously unlinked

3919

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

3920

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

3921

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

3922

g_assert_true(errno == EAGAIN);

3923

3924

free(ievent);

3925

3926

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

3927

}

3928

3929

static void test_read_inotify_event_readerror(__attribute__((unused))

3930

test_fixture *fixture,

3931

__attribute__((unused))

3932

gconstpointer

3933

user_data){

3934

__attribute__((cleanup(cleanup_close)))

3935

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3936

g_assert_cmpint(epoll_fd, >=, 0);

3937

const mono_microsecs current_time = 0;

3938

3939

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

3940

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

3941

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3942

3943

bool quit_now = false;

3944

__attribute__((cleanup(cleanup_queue)))

3945

task_queue *queue = create_queue();

3946

g_assert_nonnull(queue);

3947

3948

task_context task = {

3949

.func=read_inotify_event,

3950

.epoll_fd=epoll_fd,

3951

.fd=fd,

3952

.quit_now=&quit_now,

3953

.filename=strdup("/nonexistent"),

3954

.cancelled_filenames = &(string_set){},

3955

.notafter=0,

3956

.current_time=&current_time,

3957

};

3958

g_assert_nonnull(task.filename);

3959

run_task_with_stderr_to_dev_null(task, queue);

3960

g_assert_true(quit_now);

3961

g_assert_true(queue->next_run == 0);

3962

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

3963

3964

g_assert_true(epoll_set_does_not_contain(epoll_fd, fd));

3965

3966

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

3967

}

3968

3969

static void test_read_inotify_event_bad_epoll(__attribute__((unused))

3970

test_fixture *fixture,

3971

__attribute__((unused))

3972

gconstpointer

3973

user_data){

3974

const mono_microsecs current_time = 17;

3975

3976

int pipefds[2];

3977

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

3978

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

3979

3980

bool quit_now = false;

3981

buffer password = {};

3982

bool mandos_client_exited = false;

3983

bool password_is_read = false;

3984

__attribute__((cleanup(cleanup_queue)))

3985

task_queue *queue = create_queue();

3986

g_assert_nonnull(queue);

3987

3988

task_context task = {

3989

.func=read_inotify_event,

3990

.epoll_fd=epoll_fd,

3991

.fd=pipefds[0],

3992

.quit_now=&quit_now,

3993

.password=&password,

3994

.filename=strdup("/nonexistent"),

3995

.cancelled_filenames = &(string_set){},

3996

.notafter=0,

3997

.current_time=&current_time,

3998

.mandos_client_exited=&mandos_client_exited,

3999

.password_is_read=&password_is_read,

4000

};

4001

g_assert_nonnull(task.filename);

4002

run_task_with_stderr_to_dev_null(task, queue);

4003

4004

g_assert_nonnull(find_matching_task(queue, task));

4005

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

4006

4007

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

4008

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

4009

}

4010

4011

static void test_read_inotify_event_nodata(__attribute__((unused))

4012

test_fixture *fixture,

4013

__attribute__((unused))

4014

gconstpointer user_data){

4015

__attribute__((cleanup(cleanup_close)))

4016

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4017

g_assert_cmpint(epoll_fd, >=, 0);

4018

const mono_microsecs current_time = 0;

4019

4020

int pipefds[2];

4021

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

4022

4023

bool quit_now = false;

4024

buffer password = {};

4025

bool mandos_client_exited = false;

4026

bool password_is_read = false;

4027

__attribute__((cleanup(cleanup_queue)))

4028

task_queue *queue = create_queue();

4029

g_assert_nonnull(queue);

4030

4031

task_context task = {

4032

.func=read_inotify_event,

4033

.epoll_fd=epoll_fd,

4034

.fd=pipefds[0],

4035

.quit_now=&quit_now,

4036

.password=&password,

4037

.filename=strdup("/nonexistent"),

4038

.cancelled_filenames = &(string_set){},

4039

.notafter=0,

4040

.current_time=&current_time,

4041

.mandos_client_exited=&mandos_client_exited,

4042

.password_is_read=&password_is_read,

4043

};

4044

g_assert_nonnull(task.filename);

4045

task.func(task, queue);

4046

g_assert_false(quit_now);

4047

g_assert_true(queue->next_run == 0);

4048

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

4049

4050

g_assert_nonnull(find_matching_task(queue, (task_context){

4051

.func=read_inotify_event,

4052

.epoll_fd=epoll_fd,

4053

.fd=pipefds[0],

4054

.quit_now=&quit_now,

4055

.password=&password,

4056

.filename=task.filename,

4057

.cancelled_filenames=task.cancelled_filenames,

4058

.current_time=&current_time,

4059

.mandos_client_exited=&mandos_client_exited,

4060

.password_is_read=&password_is_read,

4061

}));

4062

4063

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4064

EPOLLIN | EPOLLRDHUP));

4065

4066

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

4067

}

4068

4069

static void test_read_inotify_event_eof(__attribute__((unused))

4070

test_fixture *fixture,

4071

__attribute__((unused))

4072

gconstpointer user_data){

4073

__attribute__((cleanup(cleanup_close)))

4074

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4075

g_assert_cmpint(epoll_fd, >=, 0);

4076

const mono_microsecs current_time = 0;

4077

4078

int pipefds[2];

4079

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

4080

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

4081

4082

bool quit_now = false;

4083

buffer password = {};

4084

__attribute__((cleanup(cleanup_queue)))

4085

task_queue *queue = create_queue();

4086

g_assert_nonnull(queue);

4087

4088

task_context task = {

4089

.func=read_inotify_event,

4090

.epoll_fd=epoll_fd,

4091

.fd=pipefds[0],

4092

.quit_now=&quit_now,

4093

.password=&password,

4094

.filename=strdup("/nonexistent"),

4095

.cancelled_filenames = &(string_set){},

4096

.notafter=0,

4097

.current_time=&current_time,

4098

};

4099

run_task_with_stderr_to_dev_null(task, queue);

4100

g_assert_true(quit_now);

4101

g_assert_true(queue->next_run == 0);

4102

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

4103

4104

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

4105

4106

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

4107

}

4108

4109

static

4110

void test_read_inotify_event_IN_CLOSE_WRITE(__attribute__((unused))

4111

test_fixture *fixture,

4112

__attribute__((unused))

4113

gconstpointer user_data){

4114

__attribute__((cleanup(cleanup_close)))

4115

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4116

g_assert_cmpint(epoll_fd, >=, 0);

4117

const mono_microsecs current_time = 0;

4118

4119

int pipefds[2];

4120

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

4121

4122

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

4123

const size_t ievent_max_size = (sizeof(struct inotify_event)

4124

+ NAME_MAX + 1);

4125

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4126

struct {

4127

struct inotify_event event;

4128

char name_buffer[NAME_MAX + 1];

4129

} ievent_buffer;

4130

struct inotify_event *const ievent = &ievent_buffer.event;

4131

4132

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

4133

ievent->mask = IN_CLOSE_WRITE;

4134

ievent->len = sizeof(dummy_file_name);

4135

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

4136

const size_t ievent_size = (sizeof(struct inotify_event)

4137

+ sizeof(dummy_file_name));

4138

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

4139

==, ievent_size);

4140

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

4141

4142

bool quit_now = false;

4143

buffer password = {};

4144

bool mandos_client_exited = false;

4145

bool password_is_read = false;

4146

__attribute__((cleanup(cleanup_queue)))

4147

task_queue *queue = create_queue();

4148

g_assert_nonnull(queue);

4149

4150

task_context task = {

4151

.func=read_inotify_event,

4152

.epoll_fd=epoll_fd,

4153

.fd=pipefds[0],

4154

.quit_now=&quit_now,

4155

.password=&password,

4156

.filename=strdup("/nonexistent"),

4157

.cancelled_filenames = &(string_set){},

4158

.notafter=0,

4159

.current_time=&current_time,

4160

.mandos_client_exited=&mandos_client_exited,

4161

.password_is_read=&password_is_read,

4162

};

4163

task.func(task, queue);

4164

g_assert_false(quit_now);

4165

g_assert_true(queue->next_run != 0);

4166

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

4167

4168

g_assert_nonnull(find_matching_task(queue, (task_context){

4169

.func=read_inotify_event,

4170

.epoll_fd=epoll_fd,

4171

.fd=pipefds[0],

4172

.quit_now=&quit_now,

4173

.password=&password,

4174

.filename=task.filename,

4175

.cancelled_filenames=task.cancelled_filenames,

4176

.current_time=&current_time,

4177

.mandos_client_exited=&mandos_client_exited,

4178

.password_is_read=&password_is_read,

4179

}));

4180

4181

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4182

EPOLLIN | EPOLLRDHUP));

4183

4184

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

4185

4186

__attribute__((cleanup(cleanup_string)))

4187

char *filename = NULL;

4188

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

4189

dummy_file_name), >, 0);

4190

g_assert_nonnull(filename);

4191

g_assert_nonnull(find_matching_task(queue, (task_context){

4192

.func=open_and_parse_question,

4193

.epoll_fd=epoll_fd,

4194

.filename=filename,

4195

.question_filename=filename,

4196

.password=&password,

4197

.cancelled_filenames=task.cancelled_filenames,

4198

.current_time=&current_time,

4199

.mandos_client_exited=&mandos_client_exited,

4200

.password_is_read=&password_is_read,

4201

}));

4202

}

4203

4204

static

4205

void test_read_inotify_event_IN_MOVED_TO(__attribute__((unused))

4206

test_fixture *fixture,

4207

__attribute__((unused))

4208

gconstpointer user_data){

4209

__attribute__((cleanup(cleanup_close)))

4210

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4211

g_assert_cmpint(epoll_fd, >=, 0);

4212

const mono_microsecs current_time = 0;

4213

4214

int pipefds[2];

4215

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

4216

4217

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

4218

const size_t ievent_max_size = (sizeof(struct inotify_event)

4219

+ NAME_MAX + 1);

4220

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4221

struct {

4222

struct inotify_event event;

4223

char name_buffer[NAME_MAX + 1];

4224

} ievent_buffer;

4225

struct inotify_event *const ievent = &ievent_buffer.event;

4226

4227

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

4228

ievent->mask = IN_MOVED_TO;

4229

ievent->len = sizeof(dummy_file_name);

4230

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

4231

const size_t ievent_size = (sizeof(struct inotify_event)

4232

+ sizeof(dummy_file_name));

4233

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

4234

==, ievent_size);

4235

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

4236

4237

bool quit_now = false;

4238

buffer password = {};

4239

bool mandos_client_exited = false;

4240

bool password_is_read = false;

4241

__attribute__((cleanup(cleanup_queue)))

4242

task_queue *queue = create_queue();

4243

g_assert_nonnull(queue);

4244

4245

task_context task = {

4246

.func=read_inotify_event,

4247

.epoll_fd=epoll_fd,

4248

.fd=pipefds[0],

4249

.quit_now=&quit_now,

4250

.password=&password,

4251

.filename=strdup("/nonexistent"),

4252

.cancelled_filenames = &(string_set){},

4253

.notafter=0,

4254

.current_time=&current_time,

4255

.mandos_client_exited=&mandos_client_exited,

4256

.password_is_read=&password_is_read,

4257

};

4258

task.func(task, queue);

4259

g_assert_false(quit_now);

4260

g_assert_true(queue->next_run != 0);

4261

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

4262

4263

g_assert_nonnull(find_matching_task(queue, (task_context){

4264

.func=read_inotify_event,

4265

.epoll_fd=epoll_fd,

4266

.fd=pipefds[0],

4267

.quit_now=&quit_now,

4268

.password=&password,

4269

.filename=task.filename,

4270

.cancelled_filenames=task.cancelled_filenames,

4271

.current_time=&current_time,

4272

.mandos_client_exited=&mandos_client_exited,

4273

.password_is_read=&password_is_read,

4274

}));

4275

4276

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4277

EPOLLIN | EPOLLRDHUP));

4278

4279

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

4280

4281

__attribute__((cleanup(cleanup_string)))

4282

char *filename = NULL;

4283

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

4284

dummy_file_name), >, 0);

4285

g_assert_nonnull(filename);

4286

g_assert_nonnull(find_matching_task(queue, (task_context){

4287

.func=open_and_parse_question,

4288

.epoll_fd=epoll_fd,

4289

.filename=filename,

4290

.question_filename=filename,

4291

.password=&password,

4292

.cancelled_filenames=task.cancelled_filenames,

4293

.current_time=&current_time,

4294

.mandos_client_exited=&mandos_client_exited,

4295

.password_is_read=&password_is_read,

4296

}));

4297

}

4298

4299

static

4300

void test_read_inotify_event_IN_MOVED_FROM(__attribute__((unused))

4301

test_fixture *fixture,

4302

__attribute__((unused))

4303

gconstpointer user_data){

4304

__attribute__((cleanup(cleanup_close)))

4305

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4306

g_assert_cmpint(epoll_fd, >=, 0);

4307

__attribute__((cleanup(string_set_clear)))

4308

string_set cancelled_filenames = {};

4309

const mono_microsecs current_time = 0;

4310

4311

int pipefds[2];

4312

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

4313

4314

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

4315

const size_t ievent_max_size = (sizeof(struct inotify_event)

4316

+ NAME_MAX + 1);

4317

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4318

struct {

4319

struct inotify_event event;

4320

char name_buffer[NAME_MAX + 1];

4321

} ievent_buffer;

4322

struct inotify_event *const ievent = &ievent_buffer.event;

4323

4324

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

4325

ievent->mask = IN_MOVED_FROM;

4326

ievent->len = sizeof(dummy_file_name);

4327

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

4328

const size_t ievent_size = (sizeof(struct inotify_event)

4329

+ sizeof(dummy_file_name));

4330

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

4331

==, ievent_size);

4332

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

4333

4334

bool quit_now = false;

4335

buffer password = {};

4336

bool mandos_client_exited = false;

4337

bool password_is_read = false;

4338

__attribute__((cleanup(cleanup_queue)))

4339

task_queue *queue = create_queue();

4340

g_assert_nonnull(queue);

4341

4342

task_context task = {

4343

.func=read_inotify_event,

4344

.epoll_fd=epoll_fd,

4345

.fd=pipefds[0],

4346

.quit_now=&quit_now,

4347

.password=&password,

4348

.filename=strdup("/nonexistent"),

4349

.cancelled_filenames=&cancelled_filenames,

4350

.current_time=&current_time,

4351

.mandos_client_exited=&mandos_client_exited,

4352

.password_is_read=&password_is_read,

4353

};

4354

task.func(task, queue);

4355

g_assert_false(quit_now);

4356

g_assert_true(queue->next_run == 0);

4357

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

4358

4359

g_assert_nonnull(find_matching_task(queue, (task_context){

4360

.func=read_inotify_event,

4361

.epoll_fd=epoll_fd,

4362

.fd=pipefds[0],

4363

.quit_now=&quit_now,

4364

.password=&password,

4365

.filename=task.filename,

4366

.cancelled_filenames=&cancelled_filenames,

4367

.current_time=&current_time,

4368

.mandos_client_exited=&mandos_client_exited,

4369

.password_is_read=&password_is_read,

4370

}));

4371

4372

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4373

EPOLLIN | EPOLLRDHUP));

4374

4375

__attribute__((cleanup(cleanup_string)))

4376

char *filename = NULL;

4377

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

4378

dummy_file_name), >, 0);

4379

g_assert_nonnull(filename);

4380

g_assert_true(string_set_contains(*task.cancelled_filenames,

4381

filename));

4382

}

4383

4384

static void test_read_inotify_event_IN_DELETE(__attribute__((unused))

4385

test_fixture *fixture,

4386

__attribute__((unused))

4387

gconstpointer

4388

user_data){

4389

__attribute__((cleanup(cleanup_close)))

4390

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4391

g_assert_cmpint(epoll_fd, >=, 0);

4392

__attribute__((cleanup(string_set_clear)))

4393

string_set cancelled_filenames = {};

4394

const mono_microsecs current_time = 0;

4395

4396

int pipefds[2];

4397

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

4398

4399

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

4400

const size_t ievent_max_size = (sizeof(struct inotify_event)

4401

+ NAME_MAX + 1);

4402

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4403

struct {

4404

struct inotify_event event;

4405

char name_buffer[NAME_MAX + 1];

4406

} ievent_buffer;

4407

struct inotify_event *const ievent = &ievent_buffer.event;

4408

4409

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

4410

ievent->mask = IN_DELETE;

4411

ievent->len = sizeof(dummy_file_name);

4412

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

4413

const size_t ievent_size = (sizeof(struct inotify_event)

4414

+ sizeof(dummy_file_name));

4415

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

4416

==, ievent_size);

4417

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

4418

4419

bool quit_now = false;

4420

buffer password = {};

4421

bool mandos_client_exited = false;

4422

bool password_is_read = false;

4423

__attribute__((cleanup(cleanup_queue)))

4424

task_queue *queue = create_queue();

4425

g_assert_nonnull(queue);

4426

4427

task_context task = {

4428

.func=read_inotify_event,

4429

.epoll_fd=epoll_fd,

4430

.fd=pipefds[0],

4431

.quit_now=&quit_now,

4432

.password=&password,

4433

.filename=strdup("/nonexistent"),

4434

.cancelled_filenames=&cancelled_filenames,

4435

.current_time=&current_time,

4436

.mandos_client_exited=&mandos_client_exited,

4437

.password_is_read=&password_is_read,

4438

};

4439

task.func(task, queue);

4440

g_assert_false(quit_now);

4441

g_assert_true(queue->next_run == 0);

4442

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

4443

4444

g_assert_nonnull(find_matching_task(queue, (task_context){

4445

.func=read_inotify_event,

4446

.epoll_fd=epoll_fd,

4447

.fd=pipefds[0],

4448

.quit_now=&quit_now,

4449

.password=&password,

4450

.filename=task.filename,

4451

.cancelled_filenames=&cancelled_filenames,

4452

.current_time=&current_time,

4453

.mandos_client_exited=&mandos_client_exited,

4454

.password_is_read=&password_is_read,

4455

}));

4456

4457

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4458

EPOLLIN | EPOLLRDHUP));

4459

4460

__attribute__((cleanup(cleanup_string)))

4461

char *filename = NULL;

4462

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

4463

dummy_file_name), >, 0);

4464

g_assert_nonnull(filename);

4465

g_assert_true(string_set_contains(*task.cancelled_filenames,

4466

filename));

4467

}

4468

4469

static void

4470

test_read_inotify_event_IN_CLOSE_WRITE_badname(__attribute__((unused))

4471

test_fixture *fixture,

4472

__attribute__((unused))

4473

gconstpointer

4474

user_data){

4475

__attribute__((cleanup(cleanup_close)))

4476

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4477

g_assert_cmpint(epoll_fd, >=, 0);

4478

const mono_microsecs current_time = 0;

4479

4480

int pipefds[2];

4481

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

4482

4483

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

4484

const size_t ievent_max_size = (sizeof(struct inotify_event)

4485

+ NAME_MAX + 1);

4486

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4487

struct {

4488

struct inotify_event event;

4489

char name_buffer[NAME_MAX + 1];

4490

} ievent_buffer;

4491

struct inotify_event *const ievent = &ievent_buffer.event;

4492

4493

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

4494

ievent->mask = IN_CLOSE_WRITE;

4495

ievent->len = sizeof(dummy_file_name);

4496

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

4497

const size_t ievent_size = (sizeof(struct inotify_event)

4498

+ sizeof(dummy_file_name));

4499

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

4500

==, ievent_size);

4501

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

4502

4503

bool quit_now = false;

4504

buffer password = {};

4505

bool mandos_client_exited = false;

4506

bool password_is_read = false;

4507

__attribute__((cleanup(cleanup_queue)))

4508

task_queue *queue = create_queue();

4509

g_assert_nonnull(queue);

4510

4511

task_context task = {

4512

.func=read_inotify_event,

4513

.epoll_fd=epoll_fd,

4514

.fd=pipefds[0],

4515

.quit_now=&quit_now,

4516

.password=&password,

4517

.filename=strdup("/nonexistent"),

4518

.cancelled_filenames = &(string_set){},

4519

.notafter=0,

4520

.current_time=&current_time,

4521

.mandos_client_exited=&mandos_client_exited,

4522

.password_is_read=&password_is_read,

4523

};

4524

task.func(task, queue);

4525

g_assert_false(quit_now);

4526

g_assert_true(queue->next_run == 0);

4527

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

4528

4529

g_assert_nonnull(find_matching_task(queue, (task_context){

4530

.func=read_inotify_event,

4531

.epoll_fd=epoll_fd,

4532

.fd=pipefds[0],

4533

.quit_now=&quit_now,

4534

.password=&password,

4535

.filename=task.filename,

4536

.cancelled_filenames=task.cancelled_filenames,

4537

.current_time=&current_time,

4538

.mandos_client_exited=&mandos_client_exited,

4539

.password_is_read=&password_is_read,

4540

}));

4541

4542

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4543

EPOLLIN | EPOLLRDHUP));

4544

}

4545

4546

static void

4547

test_read_inotify_event_IN_MOVED_TO_badname(__attribute__((unused))

4548

test_fixture *fixture,

4549

__attribute__((unused))

4550

gconstpointer user_data){

4551

__attribute__((cleanup(cleanup_close)))

4552

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4553

g_assert_cmpint(epoll_fd, >=, 0);

4554

const mono_microsecs current_time = 0;

4555

4556

int pipefds[2];

4557

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

4558

4559

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

4560

const size_t ievent_max_size = (sizeof(struct inotify_event)

4561

+ NAME_MAX + 1);

4562

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4563

struct {

4564

struct inotify_event event;

4565

char name_buffer[NAME_MAX + 1];

4566

} ievent_buffer;

4567

struct inotify_event *const ievent = &ievent_buffer.event;

4568

4569

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

4570

ievent->mask = IN_MOVED_TO;

4571

ievent->len = sizeof(dummy_file_name);

4572

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

4573

const size_t ievent_size = (sizeof(struct inotify_event)

4574

+ sizeof(dummy_file_name));

4575

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

4576

==, ievent_size);

4577

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

4578

4579

bool quit_now = false;

4580

buffer password = {};

4581

bool mandos_client_exited = false;

4582

bool password_is_read = false;

4583

__attribute__((cleanup(cleanup_queue)))

4584

task_queue *queue = create_queue();

4585

g_assert_nonnull(queue);

4586

4587

task_context task = {

4588

.func=read_inotify_event,

4589

.epoll_fd=epoll_fd,

4590

.fd=pipefds[0],

4591

.quit_now=&quit_now,

4592

.password=&password,

4593

.filename=strdup("/nonexistent"),

4594

.cancelled_filenames = &(string_set){},

4595

.notafter=0,

4596

.current_time=&current_time,

4597

.mandos_client_exited=&mandos_client_exited,

4598

.password_is_read=&password_is_read,

4599

};

4600

task.func(task, queue);

4601

g_assert_false(quit_now);

4602

g_assert_true(queue->next_run == 0);

4603

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

4604

4605

g_assert_nonnull(find_matching_task(queue, (task_context){

4606

.func=read_inotify_event,

4607

.epoll_fd=epoll_fd,

4608

.fd=pipefds[0],

4609

.quit_now=&quit_now,

4610

.password=&password,

4611

.filename=task.filename,

4612

.cancelled_filenames=task.cancelled_filenames,

4613

.current_time=&current_time,

4614

.mandos_client_exited=&mandos_client_exited,

4615

.password_is_read=&password_is_read,

4616

}));

4617

4618

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4619

EPOLLIN | EPOLLRDHUP));

4620

}

4621

4622

static void

4623

test_read_inotify_event_IN_MOVED_FROM_badname(__attribute__((unused))

4624

test_fixture *fixture,

4625

__attribute__((unused))

4626

gconstpointer

4627

user_data){

4628

__attribute__((cleanup(cleanup_close)))

4629

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4630

g_assert_cmpint(epoll_fd, >=, 0);

4631

__attribute__((cleanup(string_set_clear)))

4632

string_set cancelled_filenames = {};

4633

const mono_microsecs current_time = 0;

4634

4635

int pipefds[2];

4636

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

4637

4638

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

4639

const size_t ievent_max_size = (sizeof(struct inotify_event)

4640

+ NAME_MAX + 1);

4641

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4642

struct {

4643

struct inotify_event event;

4644

char name_buffer[NAME_MAX + 1];

4645

} ievent_buffer;

4646

struct inotify_event *const ievent = &ievent_buffer.event;

4647

4648

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

4649

ievent->mask = IN_MOVED_FROM;

4650

ievent->len = sizeof(dummy_file_name);

4651

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

4652

const size_t ievent_size = (sizeof(struct inotify_event)

4653

+ sizeof(dummy_file_name));

4654

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

4655

==, ievent_size);

4656

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

4657

4658

bool quit_now = false;

4659

buffer password = {};

4660

bool mandos_client_exited = false;

4661

bool password_is_read = false;

4662

__attribute__((cleanup(cleanup_queue)))

4663

task_queue *queue = create_queue();

4664

g_assert_nonnull(queue);

4665

4666

task_context task = {

4667

.func=read_inotify_event,

4668

.epoll_fd=epoll_fd,

4669

.fd=pipefds[0],

4670

.quit_now=&quit_now,

4671

.password=&password,

4672

.filename=strdup("/nonexistent"),

4673

.cancelled_filenames=&cancelled_filenames,

4674

.current_time=&current_time,

4675

.mandos_client_exited=&mandos_client_exited,

4676

.password_is_read=&password_is_read,

4677

};

4678

task.func(task, queue);

4679

g_assert_false(quit_now);

4680

g_assert_true(queue->next_run == 0);

4681

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

4682

4683

g_assert_nonnull(find_matching_task(queue, (task_context){

4684

.func=read_inotify_event,

4685

.epoll_fd=epoll_fd,

4686

.fd=pipefds[0],

4687

.quit_now=&quit_now,

4688

.password=&password,

4689

.filename=task.filename,

4690

.cancelled_filenames=&cancelled_filenames,

4691

.current_time=&current_time,

4692

.mandos_client_exited=&mandos_client_exited,

4693

.password_is_read=&password_is_read,

4694

}));

4695

4696

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4697

EPOLLIN | EPOLLRDHUP));

4698

4699

__attribute__((cleanup(cleanup_string)))

4700

char *filename = NULL;

4701

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

4702

dummy_file_name), >, 0);

4703

g_assert_nonnull(filename);

4704

g_assert_false(string_set_contains(cancelled_filenames, filename));

4705

}

4706

4707

static

4708

void test_read_inotify_event_IN_DELETE_badname(__attribute__((unused))

4709

test_fixture *fixture,

4710

__attribute__((unused))

4711

gconstpointer

4712

user_data){

4713

__attribute__((cleanup(cleanup_close)))

4714

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4715

g_assert_cmpint(epoll_fd, >=, 0);

4716

__attribute__((cleanup(string_set_clear)))

4717

string_set cancelled_filenames = {};

4718

const mono_microsecs current_time = 0;

4719

4720

int pipefds[2];

4721

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

4722

4723

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

4724

const size_t ievent_max_size = (sizeof(struct inotify_event)

4725

+ NAME_MAX + 1);

4726

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4727

struct {

4728

struct inotify_event event;

4729

char name_buffer[NAME_MAX + 1];

4730

} ievent_buffer;

4731

struct inotify_event *const ievent = &ievent_buffer.event;

4732

4733

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

4734

ievent->mask = IN_DELETE;

4735

ievent->len = sizeof(dummy_file_name);

4736

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

4737

const size_t ievent_size = (sizeof(struct inotify_event)

4738

+ sizeof(dummy_file_name));

4739

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

4740

==, ievent_size);

4741

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

4742

4743

bool quit_now = false;

4744

buffer password = {};

4745

bool mandos_client_exited = false;

4746

bool password_is_read = false;

4747

__attribute__((cleanup(cleanup_queue)))

4748

task_queue *queue = create_queue();

4749

g_assert_nonnull(queue);

4750

4751

task_context task = {

4752

.func=read_inotify_event,

4753

.epoll_fd=epoll_fd,

4754

.fd=pipefds[0],

4755

.quit_now=&quit_now,

4756

.password=&password,

4757

.filename=strdup("/nonexistent"),

4758

.cancelled_filenames=&cancelled_filenames,

4759

.current_time=&current_time,

4760

.mandos_client_exited=&mandos_client_exited,

4761

.password_is_read=&password_is_read,

4762

};

4763

task.func(task, queue);

4764

g_assert_false(quit_now);

4765

g_assert_true(queue->next_run == 0);

4766

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

4767

4768

g_assert_nonnull(find_matching_task(queue, (task_context){

4769

.func=read_inotify_event,

4770

.epoll_fd=epoll_fd,

4771

.fd=pipefds[0],

4772

.quit_now=&quit_now,

4773

.password=&password,

4774

.filename=task.filename,

4775

.cancelled_filenames=&cancelled_filenames,

4776

.current_time=&current_time,

4777

.mandos_client_exited=&mandos_client_exited,

4778

.password_is_read=&password_is_read,

4779

}));

4780

4781

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4782

EPOLLIN | EPOLLRDHUP));

4783

4784

__attribute__((cleanup(cleanup_string)))

4785

char *filename = NULL;

4786

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

4787

dummy_file_name), >, 0);

4788

g_assert_nonnull(filename);

4789

g_assert_false(string_set_contains(cancelled_filenames, filename));

4790

}

4791

4792

static

4793

void test_open_and_parse_question_ENOENT(__attribute__((unused))

4794

test_fixture *fixture,

4795

__attribute__((unused))

4796

gconstpointer user_data){

4797

__attribute__((cleanup(cleanup_close)))

4798

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4799

g_assert_cmpint(epoll_fd, >=, 0);

4800

__attribute__((cleanup(string_set_clear)))

4801

string_set cancelled_filenames = {};

4802

bool mandos_client_exited = false;

4803

bool password_is_read = false;

4804

__attribute__((cleanup(cleanup_queue)))

4805

task_queue *queue = create_queue();

4806

g_assert_nonnull(queue);

4807

4808

char *const filename = strdup("/nonexistent");

4809

g_assert_nonnull(filename);

4810

task_context task = {

4811

.func=open_and_parse_question,

4812

.question_filename=filename,

4813

.epoll_fd=epoll_fd,

4814

.password=(buffer[]){{}},

4815

.filename=filename,

4816

.cancelled_filenames=&cancelled_filenames,

4817

.current_time=(mono_microsecs[]){0},

4818

.mandos_client_exited=&mandos_client_exited,

4819

.password_is_read=&password_is_read,

4820

};

4821

task.func(task, queue);

4822

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

4823

}

4824

4825

static void test_open_and_parse_question_EIO(__attribute__((unused))

4826

test_fixture *fixture,

4827

__attribute__((unused))

4828

gconstpointer user_data){

4829

__attribute__((cleanup(cleanup_close)))

4830

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4831

g_assert_cmpint(epoll_fd, >=, 0);

4832

__attribute__((cleanup(string_set_clear)))

4833

string_set cancelled_filenames = {};

4834

buffer password = {};

4835

bool mandos_client_exited = false;

4836

bool password_is_read = false;

4837

__attribute__((cleanup(cleanup_queue)))

4838

task_queue *queue = create_queue();

4839

g_assert_nonnull(queue);

4840

const mono_microsecs current_time = 0;

4841

4842

char *filename = strdup("/proc/self/mem");

4843

task_context task = {

4844

.func=open_and_parse_question,

4845

.question_filename=filename,

4846

.epoll_fd=epoll_fd,

4847

.password=&password,

4848

.filename=filename,

4849

.cancelled_filenames=&cancelled_filenames,

4850

.current_time=&current_time,

4851

.mandos_client_exited=&mandos_client_exited,

4852

.password_is_read=&password_is_read,

4853

};

4854

run_task_with_stderr_to_dev_null(task, queue);

4855

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

4856

}

4857

4858

static void

4859

test_open_and_parse_question_parse_error(__attribute__((unused))

4860

test_fixture *fixture,

4861

__attribute__((unused))

4862

gconstpointer user_data){

4863

__attribute__((cleanup(cleanup_close)))

4864

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4865

g_assert_cmpint(epoll_fd, >=, 0);

4866

__attribute__((cleanup(string_set_clear)))

4867

string_set cancelled_filenames = {};

4868

__attribute__((cleanup(cleanup_queue)))

4869

task_queue *queue = create_queue();

4870

g_assert_nonnull(queue);

4871

4872

__attribute__((cleanup(cleanup_string)))

4873

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

4874

g_assert_nonnull(tempfilename);

4875

int tempfile = mkostemp(tempfilename, O_CLOEXEC);

4876

g_assert_cmpint(tempfile, >, 0);

4877

const char bad_data[] = "this is bad syntax\n";

4878

g_assert_cmpint(write(tempfile, bad_data, sizeof(bad_data)),

4879

==, sizeof(bad_data));

4880

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

4881

4882

char *const filename = strdup(tempfilename);

4883

g_assert_nonnull(filename);

4884

task_context task = {

4885

.func=open_and_parse_question,

4886

.question_filename=filename,

4887

.epoll_fd=epoll_fd,

4888

.password=(buffer[]){{}},

4889

.filename=filename,

4890

.cancelled_filenames=&cancelled_filenames,

4891

.current_time=(mono_microsecs[]){0},

4892

.mandos_client_exited=(bool[]){false},

4893

.password_is_read=(bool[]){false},

4894

};

4895

run_task_with_stderr_to_dev_null(task, queue);

4896

4897

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

4898

4899

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

4900

}

4901

4902

static

4903

void test_open_and_parse_question_nosocket(__attribute__((unused))

4904

test_fixture *fixture,

4905

__attribute__((unused))

4906

gconstpointer user_data){

4907

__attribute__((cleanup(cleanup_close)))

4908

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4909

g_assert_cmpint(epoll_fd, >=, 0);

4910

__attribute__((cleanup(string_set_clear)))

4911

string_set cancelled_filenames = {};

4912

__attribute__((cleanup(cleanup_queue)))

4913

task_queue *queue = create_queue();

4914

g_assert_nonnull(queue);

4915

4916

__attribute__((cleanup(cleanup_string)))

4917

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

4918

g_assert_nonnull(tempfilename);

4919

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4920

g_assert_cmpint(questionfile, >, 0);

4921

FILE *qf = fdopen(questionfile, "w");

4922

g_assert_cmpint(fprintf(qf, "[Ask]\nPID=1\n"), >, 0);

4923

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

4924

4925

char *const filename = strdup(tempfilename);

4926

g_assert_nonnull(filename);

4927

task_context task = {

4928

.func=open_and_parse_question,

4929

.question_filename=filename,

4930

.epoll_fd=epoll_fd,

4931

.password=(buffer[]){{}},

4932

.filename=filename,

4933

.cancelled_filenames=&cancelled_filenames,

4934

.current_time=(mono_microsecs[]){0},

4935

.mandos_client_exited=(bool[]){false},

4936

.password_is_read=(bool[]){false},

4937

};

4938

run_task_with_stderr_to_dev_null(task, queue);

4939

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

4940

4941

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

4942

}

4943

4944

static

4945

void test_open_and_parse_question_badsocket(__attribute__((unused))

4946

test_fixture *fixture,

4947

__attribute__((unused))

4948

gconstpointer user_data){

4949

__attribute__((cleanup(cleanup_close)))

4950

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4951

g_assert_cmpint(epoll_fd, >=, 0);

4952

__attribute__((cleanup(string_set_clear)))

4953

string_set cancelled_filenames = {};

4954

__attribute__((cleanup(cleanup_queue)))

4955

task_queue *queue = create_queue();

4956

g_assert_nonnull(queue);

4957

4958

__attribute__((cleanup(cleanup_string)))

4959

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

4960

g_assert_nonnull(tempfilename);

4961

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4962

g_assert_cmpint(questionfile, >, 0);

4963

FILE *qf = fdopen(questionfile, "w");

4964

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=\nPID=1\n"), >, 0);

4965

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

4966

4967

char *const filename = strdup(tempfilename);

4968

g_assert_nonnull(filename);

4969

task_context task = {

4970

.func=open_and_parse_question,

4971

.question_filename=filename,

4972

.epoll_fd=epoll_fd,

4973

.password=(buffer[]){{}},

4974

.filename=filename,

4975

.cancelled_filenames=&cancelled_filenames,

4976

.current_time=(mono_microsecs[]){0},

4977

.mandos_client_exited=(bool[]){false},

4978

.password_is_read=(bool[]){false},

4979

};

4980

run_task_with_stderr_to_dev_null(task, queue);

4981

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

4982

4983

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

4984

}

4985

4986

static

4987

void test_open_and_parse_question_nopid(__attribute__((unused))

4988

test_fixture *fixture,

4989

__attribute__((unused))

4990

gconstpointer user_data){

4991

__attribute__((cleanup(cleanup_close)))

4992

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4993

g_assert_cmpint(epoll_fd, >=, 0);

4994

__attribute__((cleanup(string_set_clear)))

4995

string_set cancelled_filenames = {};

4996

__attribute__((cleanup(cleanup_queue)))

4997

task_queue *queue = create_queue();

4998

g_assert_nonnull(queue);

4999

5000

__attribute__((cleanup(cleanup_string)))

5001

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

5002

g_assert_nonnull(tempfilename);

5003

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5004

g_assert_cmpint(questionfile, >, 0);

5005

FILE *qf = fdopen(questionfile, "w");

5006

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\n"), >, 0);

5007

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

5008

5009

char *const filename = strdup(tempfilename);

5010

g_assert_nonnull(filename);

5011

task_context task = {

5012

.func=open_and_parse_question,

5013

.question_filename=filename,

5014

.epoll_fd=epoll_fd,

5015

.password=(buffer[]){{}},

5016

.filename=filename,

5017

.cancelled_filenames=&cancelled_filenames,

5018

.current_time=(mono_microsecs[]){0},

5019

.mandos_client_exited=(bool[]){false},

5020

.password_is_read=(bool[]){false},

5021

};

5022

run_task_with_stderr_to_dev_null(task, queue);

5023

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

5024

5025

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

5026

}

5027

5028

static

5029

void test_open_and_parse_question_badpid(__attribute__((unused))

5030

test_fixture *fixture,

5031

__attribute__((unused))

5032

gconstpointer user_data){

5033

__attribute__((cleanup(cleanup_close)))

5034

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5035

g_assert_cmpint(epoll_fd, >=, 0);

5036

__attribute__((cleanup(string_set_clear)))

5037

string_set cancelled_filenames = {};

5038

__attribute__((cleanup(cleanup_queue)))

5039

task_queue *queue = create_queue();

5040

g_assert_nonnull(queue);

5041

5042

__attribute__((cleanup(cleanup_string)))

5043

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

5044

g_assert_nonnull(tempfilename);

5045

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5046

g_assert_cmpint(questionfile, >, 0);

5047

FILE *qf = fdopen(questionfile, "w");

5048

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=\n"),

5049

>, 0);

5050

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

5051

5052

char *const filename = strdup(tempfilename);

5053

g_assert_nonnull(filename);

5054

task_context task = {

5055

.func=open_and_parse_question,

5056

.question_filename=filename,

5057

.epoll_fd=epoll_fd,

5058

.password=(buffer[]){{}},

5059

.filename=filename,

5060

.cancelled_filenames=&cancelled_filenames,

5061

.current_time=(mono_microsecs[]){0},

5062

.mandos_client_exited=(bool[]){false},

5063

.password_is_read=(bool[]){false},

5064

};

5065

run_task_with_stderr_to_dev_null(task, queue);

5066

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

5067

5068

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

5069

}

5070

5071

static void

5072

test_open_and_parse_question_noexist_pid(__attribute__((unused))

5073

test_fixture *fixture,

5074

__attribute__((unused))

5075

gconstpointer user_data){

5076

__attribute__((cleanup(cleanup_close)))

5077

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5078

g_assert_cmpint(epoll_fd, >=, 0);

5079

__attribute__((cleanup(string_set_clear)))

5080

string_set cancelled_filenames = {};

5081

buffer password = {};

5082

bool mandos_client_exited = false;

5083

bool password_is_read = false;

5084

__attribute__((cleanup(cleanup_queue)))

5085

task_queue *queue = create_queue();

5086

g_assert_nonnull(queue);

5087

const mono_microsecs current_time = 0;

5088

5089

/* Find value of sysctl kernel.pid_max */

5090

uintmax_t pid_max = 0;

5091

FILE *sysctl_pid_max = fopen("/proc/sys/kernel/pid_max", "r");

5092

g_assert_nonnull(sysctl_pid_max);

5093

g_assert_cmpint(fscanf(sysctl_pid_max, "%" PRIuMAX, &pid_max),

5094

==, 1);

5095

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

5096

5097

pid_t nonexisting_pid = ((pid_t)pid_max)+1;

5098

g_assert_true(nonexisting_pid > 0); /* Overflow check */

5099

5100

__attribute__((cleanup(cleanup_string)))

5101

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

5102

g_assert_nonnull(tempfilename);

5103

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5104

g_assert_cmpint(questionfile, >, 0);

5105

FILE *qf = fdopen(questionfile, "w");

5106

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5107

PRIuMAX"\n", (uintmax_t)nonexisting_pid),

5108

>, 0);

5109

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

5110

5111

char *const question_filename = strdup(tempfilename);

5112

g_assert_nonnull(question_filename);

5113

task_context task = {

5114

.func=open_and_parse_question,

5115

.question_filename=question_filename,

5116

.epoll_fd=epoll_fd,

5117

.password=&password,

5118

.filename=question_filename,

5119

.cancelled_filenames=&cancelled_filenames,

5120

.current_time=&current_time,

5121

.mandos_client_exited=&mandos_client_exited,

5122

.password_is_read=&password_is_read,

5123

};

5124

run_task_with_stderr_to_dev_null(task, queue);

5125

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

5126

5127

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

5128

}

5129

5130

static void

5131

test_open_and_parse_question_no_notafter(__attribute__((unused))

5132

test_fixture *fixture,

5133

__attribute__((unused))

5134

gconstpointer user_data){

5135

__attribute__((cleanup(cleanup_close)))

5136

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5137

g_assert_cmpint(epoll_fd, >=, 0);

5138

__attribute__((cleanup(string_set_clear)))

5139

string_set cancelled_filenames = {};

5140

buffer password = {};

5141

bool mandos_client_exited = false;

5142

bool password_is_read = false;

5143

__attribute__((cleanup(cleanup_queue)))

5144

task_queue *queue = create_queue();

5145

g_assert_nonnull(queue);

5146

const mono_microsecs current_time = 0;

5147

5148

__attribute__((cleanup(cleanup_string)))

5149

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

5150

g_assert_nonnull(tempfilename);

5151

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5152

g_assert_cmpint(questionfile, >, 0);

5153

FILE *qf = fdopen(questionfile, "w");

5154

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5155

PRIuMAX "\n", (uintmax_t)getpid()), >, 0);

5156

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

5157

5158

char *const filename = strdup(tempfilename);

5159

g_assert_nonnull(filename);

5160

task_context task = {

5161

.func=open_and_parse_question,

5162

.question_filename=filename,

5163

.epoll_fd=epoll_fd,

5164

.password=&password,

5165

.filename=filename,

5166

.cancelled_filenames=&cancelled_filenames,

5167

.current_time=&current_time,

5168

.mandos_client_exited=&mandos_client_exited,

5169

.password_is_read=&password_is_read,

5170

};

5171

task.func(task, queue);

5172

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5173

5174

__attribute__((cleanup(cleanup_string)))

5175

char *socket_filename = strdup("/nonexistent");

5176

g_assert_nonnull(socket_filename);

5177

g_assert_nonnull(find_matching_task(queue, (task_context){

5178

.func=connect_question_socket,

5179

.question_filename=tempfilename,

5180

.filename=socket_filename,

5181

.epoll_fd=epoll_fd,

5182

.password=&password,

5183

.current_time=&current_time,

5184

.mandos_client_exited=&mandos_client_exited,

5185

.password_is_read=&password_is_read,

5186

}));

5187

5188

g_assert_true(queue->next_run != 0);

5189

5190

g_assert_cmpint(unlink(tempfilename), ==, 0);

5191

}

5192

5193

static void

5194

test_open_and_parse_question_bad_notafter(__attribute__((unused))

5195

test_fixture *fixture,

5196

__attribute__((unused))

5197

gconstpointer user_data){

5198

__attribute__((cleanup(cleanup_close)))

5199

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5200

g_assert_cmpint(epoll_fd, >=, 0);

5201

__attribute__((cleanup(string_set_clear)))

5202

string_set cancelled_filenames = {};

5203

buffer password = {};

5204

bool mandos_client_exited = false;

5205

bool password_is_read = false;

5206

__attribute__((cleanup(cleanup_queue)))

5207

task_queue *queue = create_queue();

5208

g_assert_nonnull(queue);

5209

const mono_microsecs current_time = 0;

5210

5211

__attribute__((cleanup(cleanup_string)))

5212

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5213

g_assert_nonnull(tempfilename);

5214

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5215

g_assert_cmpint(questionfile, >, 0);

5216

FILE *qf = fdopen(questionfile, "w");

5217

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5218

PRIuMAX "\nNotAfter=\n",

5219

(uintmax_t)getpid()), >, 0);

5220

g_assert_cmpint(fclose(qf), ==, 0);

5221

5222

char *const filename = strdup(tempfilename);

5223

g_assert_nonnull(filename);

5224

task_context task = {

5225

.func=open_and_parse_question,

5226

.question_filename=filename,

5227

.epoll_fd=epoll_fd,

5228

.password=&password,

5229

.filename=filename,

5230

.cancelled_filenames=&cancelled_filenames,

5231

.current_time=&current_time,

5232

.mandos_client_exited=&mandos_client_exited,

5233

.password_is_read=&password_is_read,

5234

};

5235

run_task_with_stderr_to_dev_null(task, queue);

5236

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5237

5238

__attribute__((cleanup(cleanup_string)))

5239

char *socket_filename = strdup("/nonexistent");

5240

g_assert_nonnull(find_matching_task(queue, (task_context){

5241

.func=connect_question_socket,

5242

.question_filename=tempfilename,

5243

.filename=socket_filename,

5244

.epoll_fd=epoll_fd,

5245

.password=&password,

5246

.current_time=&current_time,

5247

.mandos_client_exited=&mandos_client_exited,

5248

.password_is_read=&password_is_read,

5249

}));

5250

g_assert_true(queue->next_run != 0);

5251

5252

g_assert_cmpint(unlink(tempfilename), ==, 0);

5253

}

5254

5255

static

5256

void assert_open_and_parse_question_with_notafter(const mono_microsecs

5257

current_time,

5258

const mono_microsecs

5259

notafter,

5260

const mono_microsecs

5261

next_queue_run){

5262

__attribute__((cleanup(cleanup_close)))

5263

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5264

g_assert_cmpint(epoll_fd, >=, 0);

5265

__attribute__((cleanup(string_set_clear)))

5266

string_set cancelled_filenames = {};

5267

buffer password = {};

5268

bool mandos_client_exited = false;

5269

bool password_is_read = false;

5270

__attribute__((cleanup(cleanup_queue)))

5271

task_queue *queue = create_queue();

5272

g_assert_nonnull(queue);

5273

queue->next_run = next_queue_run;

5274

5275

__attribute__((cleanup(cleanup_string)))

5276

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5277

g_assert_nonnull(tempfilename);

5278

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5279

g_assert_cmpint(questionfile, >, 0);

5280

FILE *qf = fdopen(questionfile, "w");

5281

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5282

PRIuMAX "\nNotAfter=%" PRIuMAX "\n",

5283

(uintmax_t)getpid(), notafter), >, 0);

5284

g_assert_cmpint(fclose(qf), ==, 0);

5285

5286

char *const filename = strdup(tempfilename);

5287

g_assert_nonnull(filename);

5288

task_context task = {

5289

.func=open_and_parse_question,

5290

.question_filename=filename,

5291

.epoll_fd=epoll_fd,

5292

.password=&password,

5293

.filename=filename,

5294

.cancelled_filenames=&cancelled_filenames,

5295

.current_time=&current_time,

5296

.mandos_client_exited=&mandos_client_exited,

5297

.password_is_read=&password_is_read,

5298

};

5299

task.func(task, queue);

5300

5301

if(queue->length >= 1){

5302

__attribute__((cleanup(cleanup_string)))

5303

char *socket_filename = strdup("/nonexistent");

5304

g_assert_nonnull(find_matching_task(queue, (task_context){

5305

.func=connect_question_socket,

5306

.filename=socket_filename,

5307

.epoll_fd=epoll_fd,

5308

.password=&password,

5309

.current_time=&current_time,

5310

.cancelled_filenames=&cancelled_filenames,

5311

.mandos_client_exited=&mandos_client_exited,

5312

.password_is_read=&password_is_read,

5313

}));

5314

g_assert_true(queue->next_run != 0);

5315

}

5316

5317

if(notafter == 0){

5318

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5319

} else if(current_time >= notafter) {

5320

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5321

} else {

5322

g_assert_nonnull(find_matching_task(queue, (task_context){

5323

.func=cancel_old_question,

5324

.question_filename=tempfilename,

5325

.filename=tempfilename,

5326

.notafter=notafter,

5327

.cancelled_filenames=&cancelled_filenames,

5328

.current_time=&current_time,

5329

}));

5330

}

5331

g_assert_true(queue->next_run == 1);

5332

5333

g_assert_cmpint(unlink(tempfilename), ==, 0);

5334

}

5335

5336

static void

5337

test_open_and_parse_question_notafter_0(__attribute__((unused))

5338

test_fixture *fixture,

5339

__attribute__((unused))

5340

gconstpointer user_data){

5341

/* current_time, notafter, next_queue_run */

5342

assert_open_and_parse_question_with_notafter(0, 0, 0);

5343

}

5344

5345

static void

5346

test_open_and_parse_question_notafter_1(__attribute__((unused))

5347

test_fixture *fixture,

5348

__attribute__((unused))

5349

gconstpointer user_data){

5350

/* current_time, notafter, next_queue_run */

5351

assert_open_and_parse_question_with_notafter(0, 1, 0);

5352

}

5353

5354

static void

5355

test_open_and_parse_question_notafter_1_1(__attribute__((unused))

5356

test_fixture *fixture,

5357

__attribute__((unused))

5358

gconstpointer user_data){

5359

/* current_time, notafter, next_queue_run */

5360

assert_open_and_parse_question_with_notafter(0, 1, 1);

5361

}

5362

5363

static void

5364

test_open_and_parse_question_notafter_1_2(__attribute__((unused))

5365

test_fixture *fixture,

5366

__attribute__((unused))

5367

gconstpointer user_data){

5368

/* current_time, notafter, next_queue_run */

5369

assert_open_and_parse_question_with_notafter(0, 1, 2);

5370

}

5371

5372

static void

5373

test_open_and_parse_question_equal_notafter(__attribute__((unused))

5374

test_fixture *fixture,

5375

__attribute__((unused))

5376

gconstpointer user_data){

5377

/* current_time, notafter, next_queue_run */

5378

assert_open_and_parse_question_with_notafter(1, 1, 0);

5379

}

5380

5381

static void

5382

test_open_and_parse_question_late_notafter(__attribute__((unused))

5383

test_fixture *fixture,

5384

__attribute__((unused))

5385

gconstpointer user_data){

5386

/* current_time, notafter, next_queue_run */

5387

assert_open_and_parse_question_with_notafter(2, 1, 0);

5388

}

5389

5390

static void assert_cancel_old_question_param(const mono_microsecs

5391

next_queue_run,

5392

const mono_microsecs

5393

notafter,

5394

const mono_microsecs

5395

current_time,

5396

const mono_microsecs

5397

next_set_to){

5398

__attribute__((cleanup(string_set_clear)))

5399

string_set cancelled_filenames = {};

5400

__attribute__((cleanup(cleanup_queue)))

5401

task_queue *queue = create_queue();

5402

g_assert_nonnull(queue);

5403

queue->next_run = next_queue_run;

5404

5405

char *const question_filename = strdup("/nonexistent");

5406

g_assert_nonnull(question_filename);

5407

task_context task = {

5408

.func=cancel_old_question,

5409

.question_filename=question_filename,

5410

.filename=question_filename,

5411

.notafter=notafter,

5412

.cancelled_filenames=&cancelled_filenames,

5413

.current_time=&current_time,

5414

};

5415

task.func(task, queue);

5416

5417

if(current_time >= notafter){

5418

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5419

g_assert_true(string_set_contains(cancelled_filenames,

5420

"/nonexistent"));

5421

} else {

5422

g_assert_nonnull(find_matching_task(queue, (task_context){

5423

.func=cancel_old_question,

5424

.question_filename=question_filename,

5425

.filename=question_filename,

5426

.notafter=notafter,

5427

.cancelled_filenames=&cancelled_filenames,

5428

.current_time=&current_time,

5429

}));

5430

5431

g_assert_false(string_set_contains(cancelled_filenames,

5432

question_filename));

5433

}

5434

g_assert_cmpuint((unsigned int)queue->next_run, ==,

5435

(unsigned int)next_set_to);

5436

}

5437

5438

static void test_cancel_old_question_0_1_2(__attribute__((unused))

5439

test_fixture *fixture,

5440

__attribute__((unused))

5441

gconstpointer user_data){

5442

/* next_queue_run unset,

5443

cancellation should happen because time has come,

5444

next_queue_run should be unchanged */

5445

/* next_queue_run, notafter, current_time, next_set_to */

5446

assert_cancel_old_question_param(0, 1, 2, 0);

5447

}

5448

5449

static void test_cancel_old_question_0_2_1(__attribute__((unused))

5450

test_fixture *fixture,

5451

__attribute__((unused))

5452

gconstpointer user_data){

5453

/* If next_queue_run is 0, meaning unset, and notafter is 2,

5454

and current_time is not yet notafter or greater,

5455

update value of next_queue_run to value of notafter */

5456

/* next_queue_run, notafter, current_time, next_set_to */

5457

assert_cancel_old_question_param(0, 2, 1, 2);

5458

}

5459

5460

static void test_cancel_old_question_1_2_3(__attribute__((unused))

5461

test_fixture *fixture,

5462

__attribute__((unused))

5463

gconstpointer user_data){

5464

/* next_queue_run 1,

5465

cancellation should happen because time has come,

5466

next_queue_run should be unchanged */

5467

/* next_queue_run, notafter, current_time, next_set_to */

5468

assert_cancel_old_question_param(1, 2, 3, 1);

5469

}

5470

5471

static void test_cancel_old_question_1_3_2(__attribute__((unused))

5472

test_fixture *fixture,

5473

__attribute__((unused))

5474

gconstpointer user_data){

5475

/* If next_queue_run is set,

5476

and current_time is not yet notafter or greater,

5477

and notafter is larger than next_queue_run

5478

next_queue_run should be unchanged */

5479

/* next_queue_run, notafter, current_time, next_set_to */

5480

assert_cancel_old_question_param(1, 3, 2, 1);

5481

}

5482

5483

static void test_cancel_old_question_2_1_3(__attribute__((unused))

5484

test_fixture *fixture,

5485

__attribute__((unused))

5486

gconstpointer user_data){

5487

/* next_queue_run 2,

5488

cancellation should happen because time has come,

5489

next_queue_run should be unchanged */

5490

/* next_queue_run, notafter, current_time, next_set_to */

5491

assert_cancel_old_question_param(2, 1, 3, 2);

5492

}

5493

5494

static void test_cancel_old_question_2_3_1(__attribute__((unused))

5495

test_fixture *fixture,

5496

__attribute__((unused))

5497

gconstpointer user_data){

5498

/* If next_queue_run is set,

5499

and current_time is not yet notafter or greater,

5500

and notafter is larger than next_queue_run

5501

next_queue_run should be unchanged */

5502

/* next_queue_run, notafter, current_time, next_set_to */

5503

assert_cancel_old_question_param(2, 3, 1, 2);

5504

}

5505

5506

static void test_cancel_old_question_3_1_2(__attribute__((unused))

5507

test_fixture *fixture,

5508

__attribute__((unused))

5509

gconstpointer user_data){

5510

/* next_queue_run 3,

5511

cancellation should happen because time has come,

5512

next_queue_run should be unchanged */

5513

/* next_queue_run, notafter, current_time, next_set_to */

5514

assert_cancel_old_question_param(3, 1, 2, 3);

5515

}

5516

5517

static void test_cancel_old_question_3_2_1(__attribute__((unused))

5518

test_fixture *fixture,

5519

__attribute__((unused))

5520

gconstpointer user_data){

5521

/* If next_queue_run is set,

5522

and current_time is not yet notafter or greater,

5523

and notafter is smaller than next_queue_run

5524

update value of next_queue_run to value of notafter */

5525

/* next_queue_run, notafter, current_time, next_set_to */

5526

assert_cancel_old_question_param(3, 2, 1, 2);

5527

}

5528

5529

static void

5530

test_connect_question_socket_name_too_long(__attribute__((unused))

5531

test_fixture *fixture,

5532

__attribute__((unused))

5533

gconstpointer user_data){

5534

__attribute__((cleanup(cleanup_close)))

5535

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5536

g_assert_cmpint(epoll_fd, >=, 0);

5537

const char question_filename[] = "/nonexistent/question";

5538

__attribute__((cleanup(string_set_clear)))

5539

string_set cancelled_filenames = {};

5540

__attribute__((cleanup(cleanup_queue)))

5541

task_queue *queue = create_queue();

5542

g_assert_nonnull(queue);

5543

__attribute__((cleanup(cleanup_string)))

5544

char *tempdir = make_temporary_directory();

5545

g_assert_nonnull(tempdir);

5546

struct sockaddr_un unix_socket = { .sun_family=AF_LOCAL };

5547

char socket_name[sizeof(unix_socket.sun_path)];

5548

memset(socket_name, 'x', sizeof(socket_name));

5549

socket_name[sizeof(socket_name)-1] = '\0';

5550

char *filename = NULL;

5551

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5552

>, 0);

5553

g_assert_nonnull(filename);

5554

5555

task_context task = {

5556

.func=connect_question_socket,

5557

.question_filename=strdup(question_filename),

5558

.epoll_fd=epoll_fd,

5559

.password=(buffer[]){{}},

5560

.filename=filename,

5561

.cancelled_filenames=&cancelled_filenames,

5562

.mandos_client_exited=(bool[]){false},

5563

.password_is_read=(bool[]){false},

5564

.current_time=(mono_microsecs[]){0},

5565

};

5566

g_assert_nonnull(task.question_filename);

5567

run_task_with_stderr_to_dev_null(task, queue);

5568

5569

g_assert_true(string_set_contains(cancelled_filenames,

5570

question_filename));

5571

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5572

g_assert_true(queue->next_run == 0);

5573

5574

g_assert_cmpint(rmdir(tempdir), ==, 0);

5575

}

5576

5577

static

5578

void test_connect_question_socket_connect_fail(__attribute__((unused))

5579

test_fixture *fixture,

5580

__attribute__((unused))

5581

gconstpointer

5582

user_data){

5583

__attribute__((cleanup(cleanup_close)))

5584

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5585

g_assert_cmpint(epoll_fd, >=, 0);

5586

const char question_filename[] = "/nonexistent/question";

5587

__attribute__((cleanup(string_set_clear)))

5588

string_set cancelled_filenames = {};

5589

const mono_microsecs current_time = 3;

5590

__attribute__((cleanup(cleanup_queue)))

5591

task_queue *queue = create_queue();

5592

g_assert_nonnull(queue);

5593

__attribute__((cleanup(cleanup_string)))

5594

char *tempdir = make_temporary_directory();

5595

g_assert_nonnull(tempdir);

5596

char socket_name[] = "nonexistent";

5597

char *filename = NULL;

5598

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5599

>, 0);

5600

g_assert_nonnull(filename);

5601

5602

task_context task = {

5603

.func=connect_question_socket,

5604

.question_filename=strdup(question_filename),

5605

.epoll_fd=epoll_fd,

5606

.password=(buffer[]){{}},

5607

.filename=filename,

5608

.cancelled_filenames=&cancelled_filenames,

5609

.mandos_client_exited=(bool[]){false},

5610

.password_is_read=(bool[]){false},

5611

.current_time=&current_time,

5612

};

5613

g_assert_nonnull(task.question_filename);

5614

run_task_with_stderr_to_dev_null(task, queue);

5615

5616

g_assert_nonnull(find_matching_task(queue, task));

5617

5618

g_assert_false(string_set_contains(cancelled_filenames,

5619

question_filename));

5620

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5621

g_assert_true(queue->next_run == 1000000 + current_time);

5622

5623

g_assert_cmpint(rmdir(tempdir), ==, 0);

5624

}

5625

5626

static

5627

void test_connect_question_socket_bad_epoll(__attribute__((unused))

5628

test_fixture *fixture,

5629

__attribute__((unused))

5630

gconstpointer user_data){

5631

__attribute__((cleanup(cleanup_close)))

5632

const int epoll_fd = open("/dev/null",

5633

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5634

__attribute__((cleanup(cleanup_string)))

5635

char *const question_filename = strdup("/nonexistent/question");

5636

g_assert_nonnull(question_filename);

5637

__attribute__((cleanup(string_set_clear)))

5638

string_set cancelled_filenames = {};

5639

const mono_microsecs current_time = 5;

5640

__attribute__((cleanup(cleanup_queue)))

5641

task_queue *queue = create_queue();

5642

g_assert_nonnull(queue);

5643

__attribute__((cleanup(cleanup_string)))

5644

char *tempdir = make_temporary_directory();

5645

g_assert_nonnull(tempdir);

5646

__attribute__((cleanup(cleanup_close)))

5647

const int sock_fd = socket(PF_LOCAL, SOCK_DGRAM

5648

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

5649

g_assert_cmpint(sock_fd, >=, 0);

5650

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

5651

const char socket_name[] = "socket_name";

5652

__attribute__((cleanup(cleanup_string)))

5653

char *filename = NULL;

5654

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5655

>, 0);

5656

g_assert_nonnull(filename);

5657

g_assert_cmpint((int)strlen(filename), <,

5658

(int)sizeof(sock_name.sun_path));

5659

strncpy(sock_name.sun_path, filename, sizeof(sock_name.sun_path));

5660

sock_name.sun_path[sizeof(sock_name.sun_path)-1] = '\0';

5661

g_assert_cmpint((int)bind(sock_fd, (struct sockaddr *)&sock_name,

5662

(socklen_t)SUN_LEN(&sock_name)), >=, 0);

5663

task_context task = {

5664

.func=connect_question_socket,

5665

.question_filename=strdup(question_filename),

5666

.epoll_fd=epoll_fd,

5667

.password=(buffer[]){{}},

5668

.filename=strdup(filename),

5669

.cancelled_filenames=&cancelled_filenames,

5670

.mandos_client_exited=(bool[]){false},

5671

.password_is_read=(bool[]){false},

5672

.current_time=&current_time,

5673

};

5674

g_assert_nonnull(task.question_filename);

5675

run_task_with_stderr_to_dev_null(task, queue);

5676

5677

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5678

const task_context *const added_task

5679

= find_matching_task(queue, task);

5680

g_assert_nonnull(added_task);

5681

g_assert_true(queue->next_run == 1000000 + current_time);

5682

5683

g_assert_cmpint(unlink(filename), ==, 0);

5684

g_assert_cmpint(rmdir(tempdir), ==, 0);

5685

}

5686

5687

static

5688

void test_connect_question_socket_usable(__attribute__((unused))

5689

test_fixture *fixture,

5690

__attribute__((unused))

5691

gconstpointer user_data){

5692

__attribute__((cleanup(cleanup_close)))

5693

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5694

g_assert_cmpint(epoll_fd, >=, 0);

5695

__attribute__((cleanup(cleanup_string)))

5696

char *const question_filename = strdup("/nonexistent/question");

5697

g_assert_nonnull(question_filename);

5698

__attribute__((cleanup(string_set_clear)))

5699

string_set cancelled_filenames = {};

5700

buffer password = {};

5701

bool mandos_client_exited = false;

5702

bool password_is_read = false;

5703

const mono_microsecs current_time = 0;

5704

__attribute__((cleanup(cleanup_queue)))

5705

task_queue *queue = create_queue();

5706

g_assert_nonnull(queue);

5707

__attribute__((cleanup(cleanup_string)))

5708

char *tempdir = make_temporary_directory();

5709

g_assert_nonnull(tempdir);

5710

__attribute__((cleanup(cleanup_close)))

5711

const int sock_fd = socket(PF_LOCAL, SOCK_DGRAM

5712

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

5713

g_assert_cmpint(sock_fd, >=, 0);

5714

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

5715

const char socket_name[] = "socket_name";

5716

__attribute__((cleanup(cleanup_string)))

5717

char *filename = NULL;

5718

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5719

>, 0);

5720

g_assert_nonnull(filename);

5721

g_assert_cmpint((int)strlen(filename), <,

5722

(int)sizeof(sock_name.sun_path));

5723

strncpy(sock_name.sun_path, filename, sizeof(sock_name.sun_path));

5724

sock_name.sun_path[sizeof(sock_name.sun_path)-1] = '\0';

5725

g_assert_cmpint((int)bind(sock_fd, (struct sockaddr *)&sock_name,

5726

(socklen_t)SUN_LEN(&sock_name)), >=, 0);

5727

task_context task = {

5728

.func=connect_question_socket,

5729

.question_filename=strdup(question_filename),

5730

.epoll_fd=epoll_fd,

5731

.password=&password,

5732

.filename=strdup(filename),

5733

.cancelled_filenames=&cancelled_filenames,

5734

.mandos_client_exited=&mandos_client_exited,

5735

.password_is_read=&password_is_read,

5736

.current_time=&current_time,

5737

};

5738

g_assert_nonnull(task.question_filename);

5739

task.func(task, queue);

5740

5741

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5742

const task_context *const added_task

5743

= find_matching_task(queue, (task_context){

5744

.func=send_password_to_socket,

5745

.question_filename=question_filename,

5746

.filename=filename,

5747

.epoll_fd=epoll_fd,

5748

.password=&password,

5749

.cancelled_filenames=&cancelled_filenames,

5750

.mandos_client_exited=&mandos_client_exited,

5751

.password_is_read=&password_is_read,

5752

.current_time=&current_time,

5753

});

5754

g_assert_nonnull(added_task);

5755

g_assert_cmpint(added_task->fd, >, 0);

5756

5757

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5758

EPOLLOUT));

5759

5760

const int fd = added_task->fd;

5761

g_assert_cmpint(fd, >, 0);

5762

g_assert_true(fd_has_cloexec_and_nonblock(fd));

5763

5764

/* write to fd */

5765

char write_data[PIPE_BUF];

5766

{

5767

/* Construct test password buffer */

5768

/* Start with + since that is what the real procotol uses */

5769

write_data[0] = '+';

5770

/* Set a special character at string end just to mark the end */

5771

write_data[sizeof(write_data)-2] = 'y';

5772

/* Set NUL at buffer end, as suggested by the protocol */

5773

write_data[sizeof(write_data)-1] = '\0';

5774

/* Fill rest of password with 'x' */

5775

memset(write_data+1, 'x', sizeof(write_data)-3);

5776

g_assert_cmpint((int)send(fd, write_data, sizeof(write_data),

5777

MSG_NOSIGNAL), ==, sizeof(write_data));

5778

}

5779

5780

/* read from sock_fd */

5781

char read_data[sizeof(write_data)];

5782

g_assert_cmpint((int)read(sock_fd, read_data, sizeof(read_data)),

5783

==, sizeof(read_data));

5784

5785

g_assert_true(memcmp(write_data, read_data, sizeof(write_data))

5786

== 0);

5787

5788

/* writing to sock_fd should fail */

5789

g_assert_cmpint(send(sock_fd, write_data, sizeof(write_data),

5790

MSG_NOSIGNAL), <, 0);

5791

5792

/* reading from fd should fail */

5793

g_assert_cmpint((int)recv(fd, read_data, sizeof(read_data),

5794

MSG_NOSIGNAL), <, 0);

5795

5796

g_assert_cmpint(unlink(filename), ==, 0);

5797

g_assert_cmpint(rmdir(tempdir), ==, 0);

5798

}

5799

5800

static void

5801

test_send_password_to_socket_client_not_exited(__attribute__((unused))

5802

test_fixture *fixture,

5803

__attribute__((unused))

5804

gconstpointer

5805

user_data){

5806

__attribute__((cleanup(cleanup_close)))

5807

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5808

g_assert_cmpint(epoll_fd, >=, 0);

5809

__attribute__((cleanup(cleanup_string)))

5810

char *const question_filename = strdup("/nonexistent/question");

5811

g_assert_nonnull(question_filename);

5812

__attribute__((cleanup(cleanup_string)))

5813

char *const filename = strdup("/nonexistent/socket");

5814

g_assert_nonnull(filename);

5815

__attribute__((cleanup(string_set_clear)))

5816

string_set cancelled_filenames = {};

5817

buffer password = {};

5818

bool password_is_read = true;

5819

__attribute__((cleanup(cleanup_queue)))

5820

task_queue *queue = create_queue();

5821

g_assert_nonnull(queue);

5822

int socketfds[2];

5823

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5824

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5825

socketfds), ==, 0);

5826

__attribute__((cleanup(cleanup_close)))

5827

const int read_socket = socketfds[0];

5828

const int write_socket = socketfds[1];

5829

task_context task = {

5830

.func=send_password_to_socket,

5831

.question_filename=strdup(question_filename),

5832

.filename=strdup(filename),

5833

.epoll_fd=epoll_fd,

5834

.fd=write_socket,

5835

.password=&password,

5836

.cancelled_filenames=&cancelled_filenames,

5837

.mandos_client_exited=(bool[]){false},

5838

.password_is_read=&password_is_read,

5839

.current_time=(mono_microsecs[]){0},

5840

};

5841

g_assert_nonnull(task.question_filename);

5842

5843

task.func(task, queue);

5844

5845

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5846

5847

const task_context *const added_task

5848

= find_matching_task(queue, task);

5849

g_assert_nonnull(added_task);

5850

g_assert_cmpuint((unsigned int)password.length, ==, 0);

5851

g_assert_true(password_is_read);

5852

5853

g_assert_cmpint(added_task->fd, >, 0);

5854

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5855

EPOLLOUT));

5856

}

5857

5858

static void

5859

test_send_password_to_socket_password_not_read(__attribute__((unused))

5860

test_fixture *fixture,

5861

__attribute__((unused))

5862

gconstpointer

5863

user_data){

5864

__attribute__((cleanup(cleanup_close)))

5865

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5866

g_assert_cmpint(epoll_fd, >=, 0);

5867

__attribute__((cleanup(cleanup_string)))

5868

char *const question_filename = strdup("/nonexistent/question");

5869

g_assert_nonnull(question_filename);

5870

__attribute__((cleanup(cleanup_string)))

5871

char *const filename = strdup("/nonexistent/socket");

5872

__attribute__((cleanup(string_set_clear)))

5873

string_set cancelled_filenames = {};

5874

buffer password = {};

5875

__attribute__((cleanup(cleanup_queue)))

5876

task_queue *queue = create_queue();

5877

g_assert_nonnull(queue);

5878

int socketfds[2];

5879

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5880

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5881

socketfds), ==, 0);

5882

__attribute__((cleanup(cleanup_close)))

5883

const int read_socket = socketfds[0];

5884

const int write_socket = socketfds[1];

5885

task_context task = {

5886

.func=send_password_to_socket,

5887

.question_filename=strdup(question_filename),

5888

.filename=strdup(filename),

5889

.epoll_fd=epoll_fd,

5890

.fd=write_socket,

5891

.password=&password,

5892

.cancelled_filenames=&cancelled_filenames,

5893

.mandos_client_exited=(bool[]){false},

5894

.password_is_read=(bool[]){false},

5895

.current_time=(mono_microsecs[]){0},

5896

};

5897

g_assert_nonnull(task.question_filename);

5898

5899

task.func(task, queue);

5900

5901

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5902

5903

const task_context *const added_task = find_matching_task(queue,

5904

task);

5905

g_assert_nonnull(added_task);

5906

g_assert_cmpuint((unsigned int)password.length, ==, 0);

5907

g_assert_true(queue->next_run == 0);

5908

5909

g_assert_cmpint(added_task->fd, >, 0);

5910

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5911

EPOLLOUT));

5912

}

5913

5914

static

5915

void test_send_password_to_socket_EMSGSIZE(__attribute__((unused))

5916

test_fixture *fixture,

5917

__attribute__((unused))

5918

gconstpointer user_data){

5919

__attribute__((cleanup(cleanup_close)))

5920

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5921

g_assert_cmpint(epoll_fd, >=, 0);

5922

const char question_filename[] = "/nonexistent/question";

5923

char *const filename = strdup("/nonexistent/socket");

5924

__attribute__((cleanup(string_set_clear)))

5925

string_set cancelled_filenames = {};

5926

const size_t oversized = 1024*1024; /* Limit seems to be 212960 */

5927

__attribute__((cleanup(cleanup_buffer)))

5928

buffer password = {

5929

.data=malloc(oversized),

5930

.length=oversized,

5931

.allocated=oversized,

5932

};

5933

g_assert_nonnull(password.data);

5934

if(mlock(password.data, password.allocated) != 0){

5935

g_assert_true(errno == EPERM or errno == ENOMEM);

5936

}

5937

/* Construct test password buffer */

5938

/* Start with + since that is what the real procotol uses */

5939

password.data[0] = '+';

5940

/* Set a special character at string end just to mark the end */

5941

password.data[oversized-3] = 'y';

5942

/* Set NUL at buffer end, as suggested by the protocol */

5943

password.data[oversized-2] = '\0';

5944

/* Fill rest of password with 'x' */

5945

memset(password.data+1, 'x', oversized-3);

5946

5947

__attribute__((cleanup(cleanup_queue)))

5948

task_queue *queue = create_queue();

5949

g_assert_nonnull(queue);

5950

int socketfds[2];

5951

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5952

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5953

socketfds), ==, 0);

5954

__attribute__((cleanup(cleanup_close)))

5955

const int read_socket = socketfds[0];

5956

__attribute__((cleanup(cleanup_close)))

5957

const int write_socket = socketfds[1];

5958

task_context task = {

5959

.func=send_password_to_socket,

5960

.question_filename=strdup(question_filename),

5961

.filename=filename,

5962

.epoll_fd=epoll_fd,

5963

.fd=write_socket,

5964

.password=&password,

5965

.cancelled_filenames=&cancelled_filenames,

5966

.mandos_client_exited=(bool[]){true},

5967

.password_is_read=(bool[]){true},

5968

.current_time=(mono_microsecs[]){0},

5969

};

5970

g_assert_nonnull(task.question_filename);

5971

5972

run_task_with_stderr_to_dev_null(task, queue);

5973

5974

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5975

g_assert_true(string_set_contains(cancelled_filenames,

5976

question_filename));

5977

}

5978

5979

static void test_send_password_to_socket_retry(__attribute__((unused))

5980

test_fixture *fixture,

5981

__attribute__((unused))

5982

gconstpointer

5983

user_data){

5984

__attribute__((cleanup(cleanup_close)))

5985

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5986

g_assert_cmpint(epoll_fd, >=, 0);

5987

__attribute__((cleanup(cleanup_string)))

5988

char *const question_filename = strdup("/nonexistent/question");

5989

g_assert_nonnull(question_filename);

5990

__attribute__((cleanup(cleanup_string)))

5991

char *const filename = strdup("/nonexistent/socket");

5992

g_assert_nonnull(filename);

5993

__attribute__((cleanup(string_set_clear)))

5994

string_set cancelled_filenames = {};

5995

__attribute__((cleanup(cleanup_buffer)))

5996

buffer password = {};

5997

5998

__attribute__((cleanup(cleanup_queue)))

5999

task_queue *queue = create_queue();

6000

g_assert_nonnull(queue);

6001

int socketfds[2];

6002

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6003

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6004

socketfds), ==, 0);

6005

__attribute__((cleanup(cleanup_close)))

6006

const int read_socket = socketfds[0];

6007

const int write_socket = socketfds[1];

6008

/* Close the server side socket to force ECONNRESET on client */

6009

g_assert_cmpint(close(read_socket), ==, 0);

6010

task_context task = {

6011

.func=send_password_to_socket,

6012

.question_filename=strdup(question_filename),

6013

.filename=strdup(filename),

6014

.epoll_fd=epoll_fd,

6015

.fd=write_socket,

6016

.password=&password,

6017

.cancelled_filenames=&cancelled_filenames,

6018

.mandos_client_exited=(bool[]){true},

6019

.password_is_read=(bool[]){true},

6020

.current_time=(mono_microsecs[]){0},

6021

};

6022

g_assert_nonnull(task.question_filename);

6023

6024

task.func(task, queue);

6025

6026

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6027

6028

const task_context *const added_task = find_matching_task(queue,

6029

task);

6030

g_assert_nonnull(added_task);

6031

g_assert_cmpuint((unsigned int)password.length, ==, 0);

6032

6033

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

6034

EPOLLOUT));

6035

}

6036

6037

static

6038

void test_send_password_to_socket_bad_epoll(__attribute__((unused))

6039

test_fixture *fixture,

6040

__attribute__((unused))

6041

gconstpointer user_data){

6042

__attribute__((cleanup(cleanup_close)))

6043

const int epoll_fd = open("/dev/null",

6044

O_WRONLY | O_CLOEXEC | O_NOCTTY);

6045

__attribute__((cleanup(cleanup_string)))

6046

char *const question_filename = strdup("/nonexistent/question");

6047

g_assert_nonnull(question_filename);

6048

__attribute__((cleanup(cleanup_string)))

6049

char *const filename = strdup("/nonexistent/socket");

6050

g_assert_nonnull(filename);

6051

__attribute__((cleanup(string_set_clear)))

6052

string_set cancelled_filenames = {};

6053

__attribute__((cleanup(cleanup_buffer)))

6054

buffer password = {};

6055

6056

const mono_microsecs current_time = 11;

6057

__attribute__((cleanup(cleanup_queue)))

6058

task_queue *queue = create_queue();

6059

g_assert_nonnull(queue);

6060

int socketfds[2];

6061

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6062

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6063

socketfds), ==, 0);

6064

__attribute__((cleanup(cleanup_close)))

6065

const int read_socket = socketfds[0];

6066

const int write_socket = socketfds[1];

6067

/* Close the server side socket to force ECONNRESET on client */

6068

g_assert_cmpint(close(read_socket), ==, 0);

6069

task_context task = {

6070

.func=send_password_to_socket,

6071

.question_filename=strdup(question_filename),

6072

.filename=strdup(filename),

6073

.epoll_fd=epoll_fd,

6074

.fd=write_socket,

6075

.password=&password,

6076

.cancelled_filenames=&cancelled_filenames,

6077

.mandos_client_exited=(bool[]){true},

6078

.password_is_read=(bool[]){true},

6079

.current_time=&current_time,

6080

};

6081

g_assert_nonnull(task.question_filename);

6082

6083

run_task_with_stderr_to_dev_null(task, queue);

6084

6085

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6086

6087

const task_context *const added_task = find_matching_task(queue,

6088

task);

6089

g_assert_nonnull(added_task);

6090

g_assert_true(queue->next_run == current_time + 1000000);

6091

g_assert_cmpuint((unsigned int)password.length, ==, 0);

6092

}

6093

6094

static void assert_send_password_to_socket_password(buffer password){

6095

__attribute__((cleanup(cleanup_close)))

6096

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6097

g_assert_cmpint(epoll_fd, >=, 0);

6098

char *const question_filename = strdup("/nonexistent/question");

6099

g_assert_nonnull(question_filename);

6100

char *const filename = strdup("/nonexistent/socket");

6101

g_assert_nonnull(filename);

6102

__attribute__((cleanup(string_set_clear)))

6103

string_set cancelled_filenames = {};

6104

6105

__attribute__((cleanup(cleanup_queue)))

6106

task_queue *queue = create_queue();

6107

g_assert_nonnull(queue);

6108

int socketfds[2];

6109

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6110

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6111

socketfds), ==, 0);

6112

__attribute__((cleanup(cleanup_close)))

6113

const int read_socket = socketfds[0];

6114

const int write_socket = socketfds[1];

6115

task_context task = {

6116

.func=send_password_to_socket,

6117

.question_filename=question_filename,

6118

.filename=filename,

6119

.epoll_fd=epoll_fd,

6120

.fd=write_socket,

6121

.password=&password,

6122

.cancelled_filenames=&cancelled_filenames,

6123

.mandos_client_exited=(bool[]){true},

6124

.password_is_read=(bool[]){true},

6125

.current_time=(mono_microsecs[]){0},

6126

};

6127

6128

char *expected_written_data = malloc(password.length + 2);

6129

g_assert_nonnull(expected_written_data);

6130

expected_written_data[0] = '+';

6131

expected_written_data[password.length + 1] = '\0';

6132

if(password.length > 0){

6133

g_assert_nonnull(password.data);

6134

memcpy(expected_written_data + 1, password.data, password.length);

6135

}

6136

6137

task.func(task, queue);

6138

6139

char buf[PIPE_BUF];

6140

g_assert_cmpint((int)read(read_socket, buf, PIPE_BUF), ==,

6141

(int)(password.length + 2));

6142

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6143

6144

g_assert_true(memcmp(expected_written_data, buf,

6145

password.length + 2) == 0);

6146

6147

g_assert_true(epoll_set_does_not_contain(epoll_fd, write_socket));

6148

6149

free(expected_written_data);

6150

}

6151

6152

static void

6153

test_send_password_to_socket_null_password(__attribute__((unused))

6154

test_fixture *fixture,

6155

__attribute__((unused))

6156

gconstpointer user_data){

6157

__attribute__((cleanup(cleanup_buffer)))

6158

buffer password = {};

6159

assert_send_password_to_socket_password(password);

6160

}

6161

6162

static void

6163

test_send_password_to_socket_empty_password(__attribute__((unused))

6164

test_fixture *fixture,

6165

__attribute__((unused))

6166

gconstpointer user_data){

6167

__attribute__((cleanup(cleanup_buffer)))

6168

buffer password = {

6169

.data=malloc(1), /* because malloc(0) may return NULL */

6170

.length=0,

6171

.allocated=0, /* deliberate lie */

6172

};

6173

g_assert_nonnull(password.data);

6174

assert_send_password_to_socket_password(password);

6175

}

6176

6177

static void

6178

test_send_password_to_socket_empty_str_pass(__attribute__((unused))

6179

test_fixture *fixture,

6180

__attribute__((unused))

6181

gconstpointer user_data){

6182

__attribute__((cleanup(cleanup_buffer)))

6183

buffer password = {

6184

.data=strdup(""),

6185

.length=0,

6186

.allocated=1,

6187

};

6188

if(mlock(password.data, password.allocated) != 0){

6189

g_assert_true(errno == EPERM or errno == ENOMEM);

6190

}

6191

assert_send_password_to_socket_password(password);

6192

}

6193

6194

static void

6195

test_send_password_to_socket_text_password(__attribute__((unused))

6196

test_fixture *fixture,

6197

__attribute__((unused))

6198

gconstpointer user_data){

6199

const char dummy_test_password[] = "dummy test password";

6200

__attribute__((cleanup(cleanup_buffer)))

6201

buffer password = {

6202

.data = strdup(dummy_test_password),

6203

.length = strlen(dummy_test_password),

6204

.allocated = sizeof(dummy_test_password),

6205

};

6206

if(mlock(password.data, password.allocated) != 0){

6207

g_assert_true(errno == EPERM or errno == ENOMEM);

6208

}

6209

assert_send_password_to_socket_password(password);

6210

}

6211

6212

static void

6213

test_send_password_to_socket_binary_password(__attribute__((unused))

6214

test_fixture *fixture,

6215

__attribute__((unused))

6216

gconstpointer user_data){

6217

__attribute__((cleanup(cleanup_buffer)))

6218

buffer password = {

6219

.data=malloc(255),

6220

.length=255,

6221

.allocated=255,

6222

};

6223

g_assert_nonnull(password.data);

6224

if(mlock(password.data, password.allocated) != 0){

6225

g_assert_true(errno == EPERM or errno == ENOMEM);

6226

}

6227

char c = 1; /* Start at 1, avoiding NUL */

6228

for(int i=0; i < 255; i++){

6229

password.data[i] = c++;

6230

}

6231

assert_send_password_to_socket_password(password);

6232

}

6233

6234

static void

6235

test_send_password_to_socket_nuls_in_password(__attribute__((unused))

6236

test_fixture *fixture,

6237

__attribute__((unused))

6238

gconstpointer

6239

user_data){

6240

char test_password[] = {'\0', 'a', '\0', 'b', '\0', 'c', '\0'};

6241

__attribute__((cleanup(cleanup_buffer)))

6242

buffer password = {

6243

.data=malloc(sizeof(test_password)),

6244

.length=sizeof(test_password),

6245

.allocated=sizeof(test_password),

6246

};

6247

g_assert_nonnull(password.data);

6248

if(mlock(password.data, password.allocated) !=0){

6249

g_assert_true(errno == EPERM or errno == ENOMEM);

6250

}

6251

memcpy(password.data, test_password, password.allocated);

6252

assert_send_password_to_socket_password(password);

6253

}

6254

6255

static bool assert_add_existing_questions_to_devnull(task_queue

6256

*const,

6257

const int,

6258

buffer *const,

6259

string_set *,

6260

const

6261

mono_microsecs

6262

*const,

6263

bool *const,

6264

bool *const,

6265

const char

6266

*const);

6267

6268

static void test_add_existing_questions_ENOENT(__attribute__((unused))

6269

test_fixture *fixture,

6270

__attribute__((unused))

6271

gconstpointer

6272

user_data){

6273

__attribute__((cleanup(cleanup_queue)))

6274

task_queue *queue = create_queue();

6275

g_assert_nonnull(queue);

6276

__attribute__((cleanup(cleanup_close)))

6277

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6278

g_assert_cmpint(epoll_fd, >=, 0);

6279

__attribute__((cleanup(string_set_clear)))

6280

string_set cancelled_filenames = {};

6281

6282

g_assert_false(assert_add_existing_questions_to_devnull

6283

(queue,

6284

epoll_fd,

6285

(buffer[]){{}}, /* password */

6286

&cancelled_filenames,

6287

(mono_microsecs[]){0}, /* current_time */

6288

(bool[]){false}, /* mandos_client_exited */

6289

(bool[]){false}, /* password_is_read */

6290

"/nonexistent")); /* dirname */

6291

6292

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6293

}

6294

6295

static

6296

bool assert_add_existing_questions_to_devnull(task_queue

6297

*const queue,

6298

const int

6299

epoll_fd,

6300

buffer *const

6301

password,

6302

string_set

6303

*cancelled_filenames,

6304

const mono_microsecs

6305

*const current_time,

6306

bool *const

6307

mandos_client_exited,

6308

bool *const

6309

password_is_read,

6310

const char *const

6311

dirname){

6312

__attribute__((cleanup(cleanup_close)))

6313

const int devnull_fd = open("/dev/null",

6314

O_WRONLY | O_CLOEXEC | O_NOCTTY);

6315

g_assert_cmpint(devnull_fd, >=, 0);

6316

__attribute__((cleanup(cleanup_close)))

6317

const int real_stderr_fd = dup(STDERR_FILENO);

6318

g_assert_cmpint(real_stderr_fd, >=, 0);

6319

dup2(devnull_fd, STDERR_FILENO);

6320

const bool ret = add_existing_questions(queue, epoll_fd, password,

6321

cancelled_filenames,

6322

current_time,

6323

mandos_client_exited,

6324

password_is_read, dirname);

6325

dup2(real_stderr_fd, STDERR_FILENO);

6326

return ret;

6327

}

6328

6329

static

6330

void test_add_existing_questions_no_questions(__attribute__((unused))

6331

test_fixture *fixture,

6332

__attribute__((unused))

6333

gconstpointer

6334

user_data){

6335

__attribute__((cleanup(cleanup_queue)))

6336

task_queue *queue = create_queue();

6337

g_assert_nonnull(queue);

6338

__attribute__((cleanup(cleanup_close)))

6339

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6340

g_assert_cmpint(epoll_fd, >=, 0);

6341

__attribute__((cleanup(string_set_clear)))

6342

string_set cancelled_filenames = {};

6343

__attribute__((cleanup(cleanup_string)))

6344

char *tempdir = make_temporary_directory();

6345

g_assert_nonnull(tempdir);

6346

6347

g_assert_false(assert_add_existing_questions_to_devnull

6348

(queue,

6349

epoll_fd,

6350

(buffer[]){{}}, /* password */

6351

&cancelled_filenames,

6352

(mono_microsecs[]){0}, /* current_time */

6353

(bool[]){false}, /* mandos_client_exited */

6354

(bool[]){false}, /* password_is_read */

6355

tempdir));

6356

6357

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6358

6359

g_assert_cmpint(rmdir(tempdir), ==, 0);

6360

}

6361

6362

static char *make_question_file_in_directory(const char *const);

6363

6364

static

6365

void test_add_existing_questions_one_question(__attribute__((unused))

6366

test_fixture *fixture,

6367

__attribute__((unused))

6368

gconstpointer

6369

user_data){

6370

__attribute__((cleanup(cleanup_queue)))

6371

task_queue *queue = create_queue();

6372

g_assert_nonnull(queue);

6373

__attribute__((cleanup(cleanup_close)))

6374

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6375

g_assert_cmpint(epoll_fd, >=, 0);

6376

__attribute__((cleanup(cleanup_buffer)))

6377

buffer password = {};

6378

__attribute__((cleanup(string_set_clear)))

6379

string_set cancelled_filenames = {};

6380

const mono_microsecs current_time = 0;

6381

bool mandos_client_exited = false;

6382

bool password_is_read = false;

6383

__attribute__((cleanup(cleanup_string)))

6384

char *tempdir = make_temporary_directory();

6385

g_assert_nonnull(tempdir);

6386

__attribute__((cleanup(cleanup_string)))

6387

char *question_filename

6388

= make_question_file_in_directory(tempdir);

6389

g_assert_nonnull(question_filename);

6390

6391

g_assert_true(assert_add_existing_questions_to_devnull

6392

(queue,

6393

epoll_fd,

6394

&password,

6395

&cancelled_filenames,

6396

&current_time,

6397

&mandos_client_exited,

6398

&password_is_read,

6399

tempdir));

6400

6401

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6402

6403

g_assert_nonnull(find_matching_task(queue, (task_context){

6404

.func=open_and_parse_question,

6405

.epoll_fd=epoll_fd,

6406

.filename=question_filename,

6407

.question_filename=question_filename,

6408

.password=&password,

6409

.cancelled_filenames=&cancelled_filenames,

6410

.current_time=&current_time,

6411

.mandos_client_exited=&mandos_client_exited,

6412

.password_is_read=&password_is_read,

6413

}));

6414

6415

g_assert_true(queue->next_run == 1);

6416

6417

g_assert_cmpint(unlink(question_filename), ==, 0);

6418

g_assert_cmpint(rmdir(tempdir), ==, 0);

6419

}

6420

6421

static char *make_question_file_in_directory(const char

6422

*const dir){

6423

return make_temporary_prefixed_file_in_directory("ask.", dir);

6424

}

6425

6426

static

6427

void test_add_existing_questions_two_questions(__attribute__((unused))

6428

test_fixture *fixture,

6429

__attribute__((unused))

6430

gconstpointer

6431

user_data){

6432

__attribute__((cleanup(cleanup_queue)))

6433

task_queue *queue = create_queue();

6434

g_assert_nonnull(queue);

6435

__attribute__((cleanup(cleanup_close)))

6436

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6437

g_assert_cmpint(epoll_fd, >=, 0);

6438

__attribute__((cleanup(cleanup_buffer)))

6439

buffer password = {};

6440

__attribute__((cleanup(string_set_clear)))

6441

string_set cancelled_filenames = {};

6442

const mono_microsecs current_time = 0;

6443

bool mandos_client_exited = false;

6444

bool password_is_read = false;

6445

__attribute__((cleanup(cleanup_string)))

6446

char *tempdir = make_temporary_directory();

6447

g_assert_nonnull(tempdir);

6448

__attribute__((cleanup(cleanup_string)))

6449

char *question_filename1

6450

= make_question_file_in_directory(tempdir);

6451

g_assert_nonnull(question_filename1);

6452

__attribute__((cleanup(cleanup_string)))

6453

char *question_filename2

6454

= make_question_file_in_directory(tempdir);

6455

g_assert_nonnull(question_filename2);

6456

6457

g_assert_true(assert_add_existing_questions_to_devnull

6458

(queue,

6459

epoll_fd,

6460

&password,

6461

&cancelled_filenames,

6462

&current_time,

6463

&mandos_client_exited,

6464

&password_is_read,

6465

tempdir));

6466

6467

g_assert_cmpuint((unsigned int)queue->length, ==, 2);

6468

6469

g_assert_true(queue->next_run == 1);

6470

6471

__attribute__((cleanup(string_set_clear)))

6472

string_set seen_questions = {};

6473

6474

bool queue_contains_question_opener(char *const question_filename){

6475

return(find_matching_task(queue, (task_context){

6476

.func=open_and_parse_question,

6477

.epoll_fd=epoll_fd,

6478

.question_filename=question_filename,

6479

.password=&password,

6480

.cancelled_filenames=&cancelled_filenames,

6481

.current_time=&current_time,

6482

.mandos_client_exited=&mandos_client_exited,

6483

.password_is_read=&password_is_read,

6484

}) != NULL);

6485

}

6486

6487

g_assert_true(queue_contains_question_opener(question_filename1));

6488

g_assert_true(queue_contains_question_opener(question_filename2));

6489

6490

g_assert_true(queue->next_run == 1);

6491

6492

g_assert_cmpint(unlink(question_filename1), ==, 0);

6493

g_assert_cmpint(unlink(question_filename2), ==, 0);

6494

g_assert_cmpint(rmdir(tempdir), ==, 0);

6495

}

6496

6497

static void

6498

test_add_existing_questions_non_questions(__attribute__((unused))

6499

test_fixture *fixture,

6500

__attribute__((unused))

6501

gconstpointer user_data){

6502

__attribute__((cleanup(cleanup_queue)))

6503

task_queue *queue = create_queue();

6504

g_assert_nonnull(queue);

6505

__attribute__((cleanup(cleanup_close)))

6506

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6507

g_assert_cmpint(epoll_fd, >=, 0);

6508

__attribute__((cleanup(string_set_clear)))

6509

string_set cancelled_filenames = {};

6510

__attribute__((cleanup(cleanup_string)))

6511

char *tempdir = make_temporary_directory();

6512

g_assert_nonnull(tempdir);

6513

__attribute__((cleanup(cleanup_string)))

6514

char *question_filename1

6515

= make_temporary_file_in_directory(tempdir);

6516

g_assert_nonnull(question_filename1);

6517

__attribute__((cleanup(cleanup_string)))

6518

char *question_filename2

6519

= make_temporary_file_in_directory(tempdir);

6520

g_assert_nonnull(question_filename2);

6521

6522

g_assert_false(assert_add_existing_questions_to_devnull

6523

(queue,

6524

epoll_fd,

6525

(buffer[]){{}}, /* password */

6526

&cancelled_filenames,

6527

(mono_microsecs[]){0}, /* current_time */

6528

(bool[]){false}, /* mandos_client_exited */

6529

(bool[]){false}, /* password_is_read */

6530

tempdir));

6531

6532

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6533

6534

g_assert_cmpint(unlink(question_filename1), ==, 0);

6535

g_assert_cmpint(unlink(question_filename2), ==, 0);

6536

g_assert_cmpint(rmdir(tempdir), ==, 0);

6537

}

6538

6539

static void

6540

test_add_existing_questions_both_types(__attribute__((unused))

6541

test_fixture *fixture,

6542

__attribute__((unused))

6543

gconstpointer user_data){

6544

__attribute__((cleanup(cleanup_queue)))

6545

task_queue *queue = create_queue();

6546

g_assert_nonnull(queue);

6547

__attribute__((cleanup(cleanup_close)))

6548

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6549

g_assert_cmpint(epoll_fd, >=, 0);

6550

__attribute__((cleanup(cleanup_buffer)))

6551

buffer password = {};

6552

__attribute__((cleanup(string_set_clear)))

6553

string_set cancelled_filenames = {};

6554

const mono_microsecs current_time = 0;

6555

bool mandos_client_exited = false;

6556

bool password_is_read = false;

6557

__attribute__((cleanup(cleanup_string)))

6558

char *tempdir = make_temporary_directory();

6559

g_assert_nonnull(tempdir);

6560

__attribute__((cleanup(cleanup_string)))

6561

char *tempfilename1 = make_temporary_file_in_directory(tempdir);

6562

g_assert_nonnull(tempfilename1);

6563

__attribute__((cleanup(cleanup_string)))

6564

char *tempfilename2 = make_temporary_file_in_directory(tempdir);

6565

g_assert_nonnull(tempfilename2);

6566

__attribute__((cleanup(cleanup_string)))

6567

char *question_filename

6568

= make_question_file_in_directory(tempdir);

6569

g_assert_nonnull(question_filename);

6570

6571

g_assert_true(assert_add_existing_questions_to_devnull

6572

(queue,

6573

epoll_fd,

6574

&password,

6575

&cancelled_filenames,

6576

&current_time,

6577

&mandos_client_exited,

6578

&password_is_read,

6579

tempdir));

6580

6581

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6582

6583

g_assert_nonnull(find_matching_task(queue, (task_context){

6584

.func=open_and_parse_question,

6585

.epoll_fd=epoll_fd,

6586

.filename=question_filename,

6587

.question_filename=question_filename,

6588

.password=&password,

6589

.cancelled_filenames=&cancelled_filenames,

6590

.current_time=&current_time,

6591

.mandos_client_exited=&mandos_client_exited,

6592

.password_is_read=&password_is_read,

6593

}));

6594

6595

g_assert_true(queue->next_run == 1);

6596

6597

g_assert_cmpint(unlink(tempfilename1), ==, 0);

6598

g_assert_cmpint(unlink(tempfilename2), ==, 0);

6599

g_assert_cmpint(unlink(question_filename), ==, 0);

6600

g_assert_cmpint(rmdir(tempdir), ==, 0);

6601

}

6602

6603

static void test_wait_for_event_timeout(__attribute__((unused))

6604

test_fixture *fixture,

6605

__attribute__((unused))

6606

gconstpointer user_data){

6607

__attribute__((cleanup(cleanup_close)))

6608

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6609

g_assert_cmpint(epoll_fd, >=, 0);

6610

6611

g_assert_true(wait_for_event(epoll_fd, 1, 0));

6612

}

6613

6614

static void test_wait_for_event_event(__attribute__((unused))

6615

test_fixture *fixture,

6616

__attribute__((unused))

6617

gconstpointer user_data){

6618

__attribute__((cleanup(cleanup_close)))

6619

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6620

g_assert_cmpint(epoll_fd, >=, 0);

6621

int pipefds[2];

6622

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

6623

__attribute__((cleanup(cleanup_close)))

6624

const int read_pipe = pipefds[0];

6625

__attribute__((cleanup(cleanup_close)))

6626

const int write_pipe = pipefds[1];

6627

g_assert_cmpint(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, read_pipe,

6628

&(struct epoll_event)

6629

{ .events=EPOLLIN | EPOLLRDHUP }), ==, 0);

6630

g_assert_cmpint((int)write(write_pipe, "x", 1), ==, 1);

6631

6632

g_assert_true(wait_for_event(epoll_fd, 0, 0));

6633

}

6634

6635

static void test_wait_for_event_sigchld(test_fixture *fixture,

6636

__attribute__((unused))

6637

gconstpointer user_data){

6638

const pid_t pid = fork();

6639

if(pid == 0){ /* Child */

6640

if(not restore_signal_handler(&fixture->orig_sigaction)){

6641

_exit(EXIT_FAILURE);

6642

}

6643

if(not restore_sigmask(&fixture->orig_sigmask)){

6644

_exit(EXIT_FAILURE);

6645

}

6646

exit(EXIT_SUCCESS);

6647

}

6648

g_assert_true(pid != -1);

6649

__attribute__((cleanup(cleanup_close)))

6650

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6651

g_assert_cmpint(epoll_fd, >=, 0);

6652

6653

g_assert_true(wait_for_event(epoll_fd, 0, 0));

6654

6655

int status;

6656

g_assert_true(waitpid(pid, &status, 0) == pid);

6657

g_assert_true(WIFEXITED(status));

6658

g_assert_cmpint(WEXITSTATUS(status), ==, EXIT_SUCCESS);

6659

}

6660

6661

static void test_run_queue_zeroes_next_run(__attribute__((unused))

6662

test_fixture *fixture,

6663

__attribute__((unused))

6664

gconstpointer user_data){

6665

__attribute__((cleanup(cleanup_queue)))

6666

task_queue *queue = create_queue();

6667

g_assert_nonnull(queue);

6668

queue->next_run = 1;

6669

__attribute__((cleanup(cleanup_close)))

6670

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6671

__attribute__((cleanup(string_set_clear)))

6672

string_set cancelled_filenames = {};

6673

bool quit_now = false;

6674

6675

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6676

g_assert_false(quit_now);

6677

g_assert_cmpuint((unsigned int)queue->next_run, ==, 0);

6678

}

6679

6680

static

6681

void test_run_queue_clears_cancelled_filenames(__attribute__((unused))

6682

test_fixture *fixture,

6683

__attribute__((unused))

6684

gconstpointer

6685

user_data){

6686

__attribute__((cleanup(cleanup_queue)))

6687

task_queue *queue = create_queue();

6688

g_assert_nonnull(queue);

6689

__attribute__((cleanup(string_set_clear)))

6690

string_set cancelled_filenames = {};

6691

bool quit_now = false;

6692

const char question_filename[] = "/nonexistent/question_filename";

6693

g_assert_true(string_set_add(&cancelled_filenames,

6694

question_filename));

6695

6696

g_assert_true(add_to_queue(queue,

6697

(task_context){ .func=dummy_func }));

6698

6699

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6700

g_assert_false(quit_now);

6701

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6702

g_assert_false(string_set_contains(cancelled_filenames,

6703

question_filename));

6704

}

6705

6706

static

6707

void test_run_queue_skips_cancelled_filenames(__attribute__((unused))

6708

test_fixture *fixture,

6709

__attribute__((unused))

6710

gconstpointer

6711

user_data){

6712

__attribute__((cleanup(cleanup_queue)))

6713

task_queue *queue = create_queue();

6714

g_assert_nonnull(queue);

6715

__attribute__((cleanup(string_set_clear)))

6716

string_set cancelled_filenames = {};

6717

bool quit_now = false;

6718

int pipefds[2];

6719

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

6720

__attribute__((cleanup(cleanup_close)))

6721

const int read_pipe = pipefds[0];

6722

g_assert_cmpint(close(pipefds[1]), ==, 0);

6723

const char question_filename[] = "/nonexistent/question_filename";

6724

g_assert_true(string_set_add(&cancelled_filenames,

6725

question_filename));

6726

__attribute__((nonnull))

6727

void quit_func(const task_context task,

6728

__attribute__((unused)) task_queue *const q){

6729

g_assert_nonnull(task.quit_now);

6730

*task.quit_now = true;

6731

}

6732

task_context task = {

6733

.func=quit_func,

6734

.question_filename=strdup(question_filename),

6735

.quit_now=&quit_now,

6736

.fd=read_pipe,

6737

};

6738

g_assert_nonnull(task.question_filename);

6739

6740

g_assert_true(add_to_queue(queue, task));

6741

6742

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6743

g_assert_false(quit_now);

6744

6745

/* read_pipe should be closed already */

6746

errno = 0;

6747

bool read_pipe_closed = (close(read_pipe) == -1);

6748

read_pipe_closed &= (errno == EBADF);

6749

g_assert_true(read_pipe_closed);

6750

}

6751

6752

static void test_run_queue_one_task(__attribute__((unused))

6753

test_fixture *fixture,

6754

__attribute__((unused))

6755

gconstpointer user_data){

6756

__attribute__((cleanup(cleanup_queue)))

6757

task_queue *queue = create_queue();

6758

g_assert_nonnull(queue);

6759

__attribute__((cleanup(string_set_clear)))

6760

string_set cancelled_filenames = {};

6761

bool quit_now = false;

6762

6763

__attribute__((nonnull))

6764

void next_run_func(__attribute__((unused))

6765

const task_context task,

6766

task_queue *const q){

6767

q->next_run = 1;

6768

}

6769

6770

task_context task = {

6771

.func=next_run_func,

6772

};

6773

g_assert_true(add_to_queue(queue, task));

6774

6775

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6776

g_assert_cmpuint((unsigned int)(queue->next_run), ==, 1);

6777

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6778

}

6779

6780

static void test_run_queue_two_tasks(__attribute__((unused))

6781

test_fixture *fixture,

6782

__attribute__((unused))

6783

gconstpointer user_data){

6784

__attribute__((cleanup(cleanup_queue)))

6785

task_queue *queue = create_queue();

6786

g_assert_nonnull(queue);

6787

queue->next_run = 1;

6788

__attribute__((cleanup(string_set_clear)))

6789

string_set cancelled_filenames = {};

6790

bool quit_now = false;

6791

bool mandos_client_exited = false;

6792

6793

__attribute__((nonnull))

6794

void next_run_func(__attribute__((unused))

6795

const task_context task,

6796

task_queue *const q){

6797

q->next_run = 1;

6798

}

6799

6800

__attribute__((nonnull))

6801

void exited_func(const task_context task,

6802

__attribute__((unused)) task_queue *const q){

6803

*task.mandos_client_exited = true;

6804

}

6805

6806

task_context task1 = {

6807

.func=next_run_func,

6808

};

6809

g_assert_true(add_to_queue(queue, task1));

6810

6811

task_context task2 = {

6812

.func=exited_func,

6813

.mandos_client_exited=&mandos_client_exited,

6814

};

6815

g_assert_true(add_to_queue(queue, task2));

6816

6817

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6818

g_assert_false(quit_now);

6819

g_assert_cmpuint((unsigned int)(queue->next_run), ==, 1);

6820

g_assert_true(mandos_client_exited);

6821

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6822

}

6823

6824

static void test_run_queue_two_tasks_quit(__attribute__((unused))

6825

test_fixture *fixture,

6826

__attribute__((unused))

6827

gconstpointer user_data){

6828

__attribute__((cleanup(cleanup_queue)))

6829

task_queue *queue = create_queue();

6830

g_assert_nonnull(queue);

6831

__attribute__((cleanup(string_set_clear)))

6832

string_set cancelled_filenames = {};

6833

bool quit_now = false;

6834

bool mandos_client_exited = false;

6835

bool password_is_read = false;

6836

6837

__attribute__((nonnull))

6838

void set_exited_func(const task_context task,

6839

__attribute__((unused)) task_queue *const q){

6840

*task.mandos_client_exited = true;

6841

*task.quit_now = true;

6842

}

6843

task_context task1 = {

6844

.func=set_exited_func,

6845

.quit_now=&quit_now,

6846

.mandos_client_exited=&mandos_client_exited,

6847

};

6848

g_assert_true(add_to_queue(queue, task1));

6849

6850

__attribute__((nonnull))

6851

void set_read_func(const task_context task,

6852

__attribute__((unused)) task_queue *const q){

6853

*task.quit_now = true;

6854

*task.password_is_read = true;

6855

}

6856

task_context task2 = {

6857

.func=set_read_func,

6858

.quit_now=&quit_now,

6859

.password_is_read=&password_is_read,

6860

};

6861

g_assert_true(add_to_queue(queue, task2));

6862

6863

g_assert_false(run_queue(&queue, &cancelled_filenames, &quit_now));

6864

g_assert_true(quit_now);

6865

g_assert_true(mandos_client_exited xor password_is_read);

6866

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6867

}

6868

6869

static void test_run_queue_two_tasks_cleanup(__attribute__((unused))

6870

test_fixture *fixture,

6871

__attribute__((unused))

6872

gconstpointer user_data){

6873

__attribute__((cleanup(cleanup_queue)))

6874

task_queue *queue = create_queue();

6875

g_assert_nonnull(queue);

6876

__attribute__((cleanup(string_set_clear)))

6877

string_set cancelled_filenames = {};

6878

int pipefds[2];

6879

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

6880

__attribute__((cleanup(cleanup_close)))

6881

const int read_pipe = pipefds[0];

6882

__attribute__((cleanup(cleanup_close)))

6883

const int write_pipe = pipefds[1];

6884

bool quit_now = false;

6885

6886

__attribute__((nonnull))

6887

void read_func(const task_context task,

6888

__attribute__((unused)) task_queue *const q){

6889

*task.quit_now = true;

6890

}

6891

task_context task1 = {

6892

.func=read_func,

6893

.quit_now=&quit_now,

6894

.fd=read_pipe,

6895

};

6896

g_assert_true(add_to_queue(queue, task1));

6897

6898

__attribute__((nonnull))

6899

void write_func(const task_context task,

6900

__attribute__((unused)) task_queue *const q){

6901

*task.quit_now = true;

6902

}

6903

task_context task2 = {

6904

.func=write_func,

6905

.quit_now=&quit_now,

6906

.fd=write_pipe,

6907

};

6908

g_assert_true(add_to_queue(queue, task2));

6909

6910

g_assert_false(run_queue(&queue, &cancelled_filenames, &quit_now));

6911

g_assert_true(quit_now);

6912

6913

/* Either read_pipe or write_pipe should be closed already */

6914

errno = 0;

6915

bool close_read_pipe = (close(read_pipe) == -1);

6916

close_read_pipe &= (errno == EBADF);

6917

errno = 0;

6918

bool close_write_pipe = (close(write_pipe) == -1);

6919

close_write_pipe &= (errno == EBADF);

6920

g_assert_true(close_read_pipe xor close_write_pipe);

6921

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6922

}

6923

6924

static void test_setup_signal_handler(__attribute__((unused))

6925

test_fixture *fixture,

6926

__attribute__((unused))

6927

gconstpointer user_data){

6928

/* Save current SIGCHLD action, whatever it is */

6929

struct sigaction expected_sigchld_action;

6930

g_assert_cmpint(sigaction(SIGCHLD, NULL, &expected_sigchld_action),

6931

==, 0);

6932

6933

/* Act; i.e. run the setup_signal_handler() function */

6934

struct sigaction actual_old_sigchld_action;

6935

g_assert_true(setup_signal_handler(&actual_old_sigchld_action));

6936

6937

/* Check that the function correctly set "actual_old_sigchld_action"

6938

to the same values as the previously saved

6939

"expected_sigchld_action" */

6940

/* Check member sa_handler */

6941

g_assert_true(actual_old_sigchld_action.sa_handler

6942

== expected_sigchld_action.sa_handler);

6943

/* Check member sa_mask */

6944

for(int signum = 1; signum < NSIG; signum++){

6945

const int expected_old_block_state

6946

= sigismember(&expected_sigchld_action.sa_mask, signum);

6947

g_assert_cmpint(expected_old_block_state, >=, 0);

6948

const int actual_old_block_state

6949

= sigismember(&actual_old_sigchld_action.sa_mask, signum);

6950

g_assert_cmpint(actual_old_block_state, >=, 0);

6951

g_assert_cmpint(actual_old_block_state,

6952

==, expected_old_block_state);

6953

}

6954

/* Check member sa_flags */

6955

g_assert_true((actual_old_sigchld_action.sa_flags

6956

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

6957

== (expected_sigchld_action.sa_flags

6958

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART)));

6959

6960

/* Retrieve the current signal handler for SIGCHLD as set by

6961

setup_signal_handler() */

6962

struct sigaction actual_new_sigchld_action;

6963

g_assert_cmpint(sigaction(SIGCHLD, NULL,

6964

&actual_new_sigchld_action), ==, 0);

6965

/* Check that the signal handler (member sa_handler) is correctly

6966

set to the "handle_sigchld" function */

6967

g_assert_true(actual_new_sigchld_action.sa_handler != SIG_DFL);

6968

g_assert_true(actual_new_sigchld_action.sa_handler != SIG_IGN);

6969

g_assert_true(actual_new_sigchld_action.sa_handler

6970

== handle_sigchld);

6971

/* Check (in member sa_mask) that at least a handful of signals are

6972

actually blocked during the signal handler */

6973

for(int signum = 1; signum < NSIG; signum++){

6974

int actual_new_block_state;

6975

switch(signum){

6976

case SIGTERM:

6977

case SIGINT:

6978

case SIGQUIT:

6979

case SIGHUP:

6980

actual_new_block_state

6981

= sigismember(&actual_new_sigchld_action.sa_mask, signum);

6982

g_assert_cmpint(actual_new_block_state, ==, 1);

6983

continue;

6984

case SIGKILL: /* non-blockable */

6985

case SIGSTOP: /* non-blockable */

6986

case SIGCHLD: /* always blocked */

6987

default:

6988

continue;

6989

}

6990

}

6991

/* Check member sa_flags */

6992

g_assert_true((actual_new_sigchld_action.sa_flags

6993

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

6994

== (SA_NOCLDSTOP | SA_RESTART));

6995

6996

/* Restore signal handler */

6997

g_assert_cmpint(sigaction(SIGCHLD, &expected_sigchld_action, NULL),

6998

==, 0);

6999

}

7000

7001

static void test_restore_signal_handler(__attribute__((unused))

7002

test_fixture *fixture,

7003

__attribute__((unused))

7004

gconstpointer user_data){

7005

/* Save current SIGCHLD action, whatever it is */

7006

struct sigaction expected_sigchld_action;

7007

g_assert_cmpint(sigaction(SIGCHLD, NULL, &expected_sigchld_action),

7008

==, 0);

7009

/* Since we haven't established a signal handler yet, there should

7010

not be one established. But another test may have relied on

7011

restore_signal_handler() to restore the signal handler, and if

7012

restore_signal_handler() is buggy (which we should be prepared

7013

for in this test) the signal handler may not have been restored

7014

properly; check for this: */

7015

g_assert_true(expected_sigchld_action.sa_handler != handle_sigchld);

7016

7017

/* Establish a signal handler */

7018

struct sigaction sigchld_action = {

7019

.sa_handler=handle_sigchld,

7020

.sa_flags=SA_RESTART | SA_NOCLDSTOP,

7021

};

7022

g_assert_cmpint(sigfillset(&sigchld_action.sa_mask), ==, 0);

7023

g_assert_cmpint(sigaction(SIGCHLD, &sigchld_action, NULL), ==, 0);

7024

7025

/* Act; i.e. run the restore_signal_handler() function */

7026

g_assert_true(restore_signal_handler(&expected_sigchld_action));

7027

7028

/* Retrieve the restored signal handler data */

7029

struct sigaction actual_restored_sigchld_action;

7030

g_assert_cmpint(sigaction(SIGCHLD, NULL,

7031

&actual_restored_sigchld_action), ==, 0);

7032

7033

/* Check that the function correctly restored the signal action, as

7034

saved in "actual_restored_sigchld_action", to the same values as

7035

the previously saved "expected_sigchld_action" */

7036

/* Check member sa_handler */

7037

g_assert_true(actual_restored_sigchld_action.sa_handler

7038

== expected_sigchld_action.sa_handler);

7039

/* Check member sa_mask */

7040

for(int signum = 1; signum < NSIG; signum++){

7041

const int expected_old_block_state

7042

= sigismember(&expected_sigchld_action.sa_mask, signum);

7043

g_assert_cmpint(expected_old_block_state, >=, 0);

7044

const int actual_restored_block_state

7045

= sigismember(&actual_restored_sigchld_action.sa_mask, signum);

7046

g_assert_cmpint(actual_restored_block_state, >=, 0);

7047

g_assert_cmpint(actual_restored_block_state,

7048

==, expected_old_block_state);

7049

}

7050

/* Check member sa_flags */

7051

g_assert_true((actual_restored_sigchld_action.sa_flags

7052

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

7053

== (expected_sigchld_action.sa_flags

7054

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART)));

7055

}

7056

7057

static void test_block_sigchld(__attribute__((unused))

7058

test_fixture *fixture,

7059

__attribute__((unused))

7060

gconstpointer user_data){

7061

/* Save original signal mask */

7062

sigset_t expected_sigmask;

7063

g_assert_cmpint(pthread_sigmask(-1, NULL, &expected_sigmask),

7064

==, 0);

7065

7066

/* Make sure SIGCHLD is unblocked for this test */

7067

sigset_t sigchld_sigmask;

7068

g_assert_cmpint(sigemptyset(&sigchld_sigmask), ==, 0);

7069

g_assert_cmpint(sigaddset(&sigchld_sigmask, SIGCHLD), ==, 0);

7070

g_assert_cmpint(pthread_sigmask(SIG_UNBLOCK, &sigchld_sigmask,

7071

NULL), ==, 0);

7072

7073

/* Act; i.e. run the block_sigchld() function */

7074

sigset_t actual_old_sigmask;

7075

g_assert_true(block_sigchld(&actual_old_sigmask));

7076

7077

/* Check the actual_old_sigmask; it should be the same as the

7078

previously saved signal mask "expected_sigmask". */

7079

for(int signum = 1; signum < NSIG; signum++){

7080

const int expected_old_block_state

7081

= sigismember(&expected_sigmask, signum);

7082

g_assert_cmpint(expected_old_block_state, >=, 0);

7083

const int actual_old_block_state

7084

= sigismember(&actual_old_sigmask, signum);

7085

g_assert_cmpint(actual_old_block_state, >=, 0);

7086

g_assert_cmpint(actual_old_block_state,

7087

==, expected_old_block_state);

7088

}

7089

7090

/* Retrieve the newly set signal mask */

7091

sigset_t actual_sigmask;

7092

g_assert_cmpint(pthread_sigmask(-1, NULL, &actual_sigmask), ==, 0);

7093

7094

/* SIGCHLD should be blocked */

7095

g_assert_cmpint(sigismember(&actual_sigmask, SIGCHLD), ==, 1);

7096

7097

/* Restore signal mask */

7098

g_assert_cmpint(pthread_sigmask(SIG_SETMASK, &expected_sigmask,

7099

NULL), ==, 0);

7100

}

7101

7102

static void test_restore_sigmask(__attribute__((unused))

7103

test_fixture *fixture,

7104

__attribute__((unused))

7105

gconstpointer user_data){

7106

/* Save original signal mask */

7107

sigset_t orig_sigmask;

7108

g_assert_cmpint(pthread_sigmask(-1, NULL, &orig_sigmask), ==, 0);

7109

7110

/* Make sure SIGCHLD is blocked for this test */

7111

sigset_t sigchld_sigmask;

7112

g_assert_cmpint(sigemptyset(&sigchld_sigmask), ==, 0);

7113

g_assert_cmpint(sigaddset(&sigchld_sigmask, SIGCHLD), ==, 0);

7114

g_assert_cmpint(pthread_sigmask(SIG_BLOCK, &sigchld_sigmask,

7115

NULL), ==, 0);

7116

7117

/* Act; i.e. run the restore_sigmask() function */

7118

g_assert_true(restore_sigmask(&orig_sigmask));

7119

7120

/* Retrieve the newly restored signal mask */

7121

sigset_t restored_sigmask;

7122

g_assert_cmpint(pthread_sigmask(-1, NULL, &restored_sigmask),

7123

==, 0);

7124

7125

/* Check the restored_sigmask; it should be the same as the

7126

previously saved signal mask "orig_sigmask". */

7127

for(int signum = 1; signum < NSIG; signum++){

7128

const int orig_block_state = sigismember(&orig_sigmask, signum);

7129

g_assert_cmpint(orig_block_state, >=, 0);

7130

const int restored_block_state = sigismember(&restored_sigmask,

7131

signum);

7132

g_assert_cmpint(restored_block_state, >=, 0);

7133

g_assert_cmpint(restored_block_state, ==, orig_block_state);

7134

}

7135

7136

/* Restore signal mask */

7137

g_assert_cmpint(pthread_sigmask(SIG_SETMASK, &orig_sigmask,

7138

NULL), ==, 0);

7139

}

7140

7141

static void test_parse_arguments_noargs(__attribute__((unused))

7142

test_fixture *fixture,

7143

__attribute__((unused))

7144

gconstpointer user_data){

7145

char *argv[] = {

7146

strdup("prgname"),

7147

NULL };

7148

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7149

7150

char *agent_directory = NULL;

7151

char *helper_directory = NULL;

7152

uid_t user = 0;

7153

gid_t group = 0;

7154

char *mandos_argz = NULL;

7155

size_t mandos_argz_length = 0;

7156

7157

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7158

&helper_directory, &user, &group,

7159

&mandos_argz, &mandos_argz_length));

7160

g_assert_null(agent_directory);

7161

g_assert_null(helper_directory);

7162

g_assert_true(user == 0);

7163

g_assert_true(group == 0);

7164

g_assert_null(mandos_argz);

7165

g_assert_true(mandos_argz_length == 0);

7166

7167

for(char **arg = argv; *arg != NULL; arg++){

7168

free(*arg);

7169

}

7170

}

7171

7172

__attribute__((nonnull))

7173

static bool parse_arguments_devnull(int argc, char *argv[],

7174

const bool exit_failure,

7175

char **agent_directory,

7176

char **helper_directory,

7177

uid_t *const user,

7178

gid_t *const group,

7179

char **mandos_argz,

7180

size_t *mandos_argz_length){

7181

7182

FILE *real_stderr = stderr;

7183

FILE *devnull = fopen("/dev/null", "we");

7184

g_assert_nonnull(devnull);

7185

stderr = devnull;

7186

7187

const bool ret = parse_arguments(argc, argv, exit_failure,

7188

agent_directory,

7189

helper_directory, user, group,

7190

mandos_argz, mandos_argz_length);

7191

const error_t saved_errno = errno;

7192

7193

stderr = real_stderr;

7194

g_assert_cmpint(fclose(devnull), ==, 0);

7195

7196

errno = saved_errno;

7197

7198

return ret;

7199

}

7200

7201

static void test_parse_arguments_invalid(__attribute__((unused))

7202

test_fixture *fixture,

7203

__attribute__((unused))

7204

gconstpointer user_data){

7205

char *argv[] = {

7206

strdup("prgname"),

7207

strdup("--invalid"),

7208

NULL };

7209

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7210

7211

char *agent_directory = NULL;

7212

char *helper_directory = NULL;

7213

uid_t user = 0;

7214

gid_t group = 0;

7215

char *mandos_argz = NULL;

7216

size_t mandos_argz_length = 0;

7217

7218

g_assert_false(parse_arguments_devnull(argc, argv, false,

7219

&agent_directory,

7220

&helper_directory, &user,

7221

&group, &mandos_argz,

7222

&mandos_argz_length));

7223

7224

g_assert_true(errno == EINVAL);

7225

g_assert_null(agent_directory);

7226

g_assert_null(helper_directory);

7227

g_assert_null(mandos_argz);

7228

g_assert_true(mandos_argz_length == 0);

7229

7230

for(char **arg = argv; *arg != NULL; arg++){

7231

free(*arg);

7232

}

7233

}

7234

7235

static void test_parse_arguments_long_dir(__attribute__((unused))

7236

test_fixture *fixture,

7237

__attribute__((unused))

7238

gconstpointer user_data){

7239

char *argv[] = {

7240

strdup("prgname"),

7241

strdup("--agent-directory"),

7242

strdup("/tmp"),

7243

NULL };

7244

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7245

7246

__attribute__((cleanup(cleanup_string)))

7247

char *agent_directory = NULL;

7248

char *helper_directory = NULL;

7249

uid_t user = 0;

7250

gid_t group = 0;

7251

__attribute__((cleanup(cleanup_string)))

7252

char *mandos_argz = NULL;

7253

size_t mandos_argz_length = 0;

7254

7255

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7256

&helper_directory, &user, &group,

7257

&mandos_argz, &mandos_argz_length));

7258

7259

g_assert_cmpstr(agent_directory, ==, "/tmp");

7260

g_assert_null(helper_directory);

7261

g_assert_true(user == 0);

7262

g_assert_true(group == 0);

7263

g_assert_null(mandos_argz);

7264

g_assert_true(mandos_argz_length == 0);

7265

7266

for(char **arg = argv; *arg != NULL; arg++){

7267

free(*arg);

7268

}

7269

}

7270

7271

static void test_parse_arguments_short_dir(__attribute__((unused))

7272

test_fixture *fixture,

7273

__attribute__((unused))

7274

gconstpointer user_data){

7275

char *argv[] = {

7276

strdup("prgname"),

7277

strdup("-d"),

7278

strdup("/tmp"),

7279

NULL };

7280

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7281

7282

__attribute__((cleanup(cleanup_string)))

7283

char *agent_directory = NULL;

7284

char *helper_directory = NULL;

7285

uid_t user = 0;

7286

gid_t group = 0;

7287

__attribute__((cleanup(cleanup_string)))

7288

char *mandos_argz = NULL;

7289

size_t mandos_argz_length = 0;

7290

7291

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7292

&helper_directory, &user, &group,

7293

&mandos_argz, &mandos_argz_length));

7294

7295

g_assert_cmpstr(agent_directory, ==, "/tmp");

7296

g_assert_null(helper_directory);

7297

g_assert_true(user == 0);

7298

g_assert_true(group == 0);

7299

g_assert_null(mandos_argz);

7300

g_assert_true(mandos_argz_length == 0);

7301

7302

for(char **arg = argv; *arg != NULL; arg++){

7303

free(*arg);

7304

}

7305

}

7306

7307

static

7308

void test_parse_arguments_helper_directory(__attribute__((unused))

7309

test_fixture *fixture,

7310

__attribute__((unused))

7311

gconstpointer user_data){

7312

char *argv[] = {

7313

strdup("prgname"),

7314

strdup("--helper-directory"),

7315

strdup("/tmp"),

7316

NULL };

7317

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7318

7319

char *agent_directory = NULL;

7320

__attribute__((cleanup(cleanup_string)))

7321

char *helper_directory = NULL;

7322

uid_t user = 0;

7323

gid_t group = 0;

7324

__attribute__((cleanup(cleanup_string)))

7325

char *mandos_argz = NULL;

7326

size_t mandos_argz_length = 0;

7327

7328

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7329

&helper_directory, &user, &group,

7330

&mandos_argz, &mandos_argz_length));

7331

7332

g_assert_cmpstr(helper_directory, ==, "/tmp");

7333

g_assert_null(agent_directory);

7334

g_assert_true(user == 0);

7335

g_assert_true(group == 0);

7336

g_assert_null(mandos_argz);

7337

g_assert_true(mandos_argz_length == 0);

7338

7339

for(char **arg = argv; *arg != NULL; arg++){

7340

free(*arg);

7341

}

7342

}

7343

7344

static

7345

void test_parse_arguments_plugin_helper_dir(__attribute__((unused))

7346

test_fixture *fixture,

7347

__attribute__((unused))

7348

gconstpointer user_data){

7349

char *argv[] = {

7350

strdup("prgname"),

7351

strdup("--plugin-helper-dir"),

7352

strdup("/tmp"),

7353

NULL };

7354

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7355

7356

char *agent_directory = NULL;

7357

__attribute__((cleanup(cleanup_string)))

7358

char *helper_directory = NULL;

7359

uid_t user = 0;

7360

gid_t group = 0;

7361

__attribute__((cleanup(cleanup_string)))

7362

char *mandos_argz = NULL;

7363

size_t mandos_argz_length = 0;

7364

7365

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7366

&helper_directory, &user, &group,

7367

&mandos_argz, &mandos_argz_length));

7368

7369

g_assert_cmpstr(helper_directory, ==, "/tmp");

7370

g_assert_null(agent_directory);

7371

g_assert_true(user == 0);

7372

g_assert_true(group == 0);

7373

g_assert_null(mandos_argz);

7374

g_assert_true(mandos_argz_length == 0);

7375

7376

for(char **arg = argv; *arg != NULL; arg++){

7377

free(*arg);

7378

}

7379

}

7380

7381

static void test_parse_arguments_user(__attribute__((unused))

7382

test_fixture *fixture,

7383

__attribute__((unused))

7384

gconstpointer user_data){

7385

char *argv[] = {

7386

strdup("prgname"),

7387

strdup("--user"),

7388

strdup("1000"),

7389

NULL };

7390

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7391

7392

char *agent_directory = NULL;

7393

__attribute__((cleanup(cleanup_string)))

7394

char *helper_directory = NULL;

7395

uid_t user = 0;

7396

gid_t group = 0;

7397

__attribute__((cleanup(cleanup_string)))

7398

char *mandos_argz = NULL;

7399

size_t mandos_argz_length = 0;

7400

7401

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7402

&helper_directory, &user, &group,

7403

&mandos_argz, &mandos_argz_length));

7404

7405

g_assert_null(helper_directory);

7406

g_assert_null(agent_directory);

7407

g_assert_cmpuint((unsigned int)user, ==, 1000);

7408

g_assert_true(group == 0);

7409

g_assert_null(mandos_argz);

7410

g_assert_true(mandos_argz_length == 0);

7411

7412

for(char **arg = argv; *arg != NULL; arg++){

7413

free(*arg);

7414

}

7415

}

7416

7417

static void test_parse_arguments_user_invalid(__attribute__((unused))

7418

test_fixture *fixture,

7419

__attribute__((unused))

7420

gconstpointer

7421

user_data){

7422

char *argv[] = {

7423

strdup("prgname"),

7424

strdup("--user"),

7425

strdup("invalid"),

7426

NULL };

7427

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7428

7429

char *agent_directory = NULL;

7430

__attribute__((cleanup(cleanup_string)))

7431

char *helper_directory = NULL;

7432

uid_t user = 0;

7433

gid_t group = 0;

7434

__attribute__((cleanup(cleanup_string)))

7435

char *mandos_argz = NULL;

7436

size_t mandos_argz_length = 0;

7437

7438

g_assert_false(parse_arguments_devnull(argc, argv, false,

7439

&agent_directory,

7440

&helper_directory, &user,

7441

&group, &mandos_argz,

7442

&mandos_argz_length));

7443

7444

g_assert_null(helper_directory);

7445

g_assert_null(agent_directory);

7446

g_assert_cmpuint((unsigned int)user, ==, 0);

7447

g_assert_true(group == 0);

7448

g_assert_null(mandos_argz);

7449

g_assert_true(mandos_argz_length == 0);

7450

7451

for(char **arg = argv; *arg != NULL; arg++){

7452

free(*arg);

7453

}

7454

}

7455

7456

static

7457

void test_parse_arguments_user_zero_invalid(__attribute__((unused))

7458

test_fixture *fixture,

7459

__attribute__((unused))

7460

gconstpointer user_data){

7461

char *argv[] = {

7462

strdup("prgname"),

7463

strdup("--user"),

7464

strdup("0"),

7465

NULL };

7466

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7467

7468

char *agent_directory = NULL;

7469

__attribute__((cleanup(cleanup_string)))

7470

char *helper_directory = NULL;

7471

uid_t user = 0;

7472

gid_t group = 0;

7473

__attribute__((cleanup(cleanup_string)))

7474

char *mandos_argz = NULL;

7475

size_t mandos_argz_length = 0;

7476

7477

g_assert_false(parse_arguments_devnull(argc, argv, false,

7478

&agent_directory,

7479

&helper_directory, &user,

7480

&group, &mandos_argz,

7481

&mandos_argz_length));

7482

7483

g_assert_null(helper_directory);

7484

g_assert_null(agent_directory);

7485

g_assert_cmpuint((unsigned int)user, ==, 0);

7486

g_assert_true(group == 0);

7487

g_assert_null(mandos_argz);

7488

g_assert_true(mandos_argz_length == 0);

7489

7490

for(char **arg = argv; *arg != NULL; arg++){

7491

free(*arg);

7492

}

7493

}

7494

7495

static void test_parse_arguments_group(__attribute__((unused))

7496

test_fixture *fixture,

7497

__attribute__((unused))

7498

gconstpointer user_data){

7499

char *argv[] = {

7500

strdup("prgname"),

7501

strdup("--group"),

7502

strdup("1000"),

7503

NULL };

7504

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7505

7506

char *agent_directory = NULL;

7507

__attribute__((cleanup(cleanup_string)))

7508

char *helper_directory = NULL;

7509

uid_t user = 0;

7510

gid_t group = 0;

7511

__attribute__((cleanup(cleanup_string)))

7512

char *mandos_argz = NULL;

7513

size_t mandos_argz_length = 0;

7514

7515

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7516

&helper_directory, &user, &group,

7517

&mandos_argz, &mandos_argz_length));

7518

7519

g_assert_null(helper_directory);

7520

g_assert_null(agent_directory);

7521

g_assert_true(user == 0);

7522

g_assert_cmpuint((unsigned int)group, ==, 1000);

7523

g_assert_null(mandos_argz);

7524

g_assert_true(mandos_argz_length == 0);

7525

7526

for(char **arg = argv; *arg != NULL; arg++){

7527

free(*arg);

7528

}

7529

}

7530

7531

static void test_parse_arguments_group_invalid(__attribute__((unused))

7532

test_fixture *fixture,

7533

__attribute__((unused))

7534

gconstpointer

7535

user_data){

7536

char *argv[] = {

7537

strdup("prgname"),

7538

strdup("--group"),

7539

strdup("invalid"),

7540

NULL };

7541

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7542

7543

char *agent_directory = NULL;

7544

__attribute__((cleanup(cleanup_string)))

7545

char *helper_directory = NULL;

7546

uid_t user = 0;

7547

gid_t group = 0;

7548

__attribute__((cleanup(cleanup_string)))

7549

char *mandos_argz = NULL;

7550

size_t mandos_argz_length = 0;

7551

7552

g_assert_false(parse_arguments_devnull(argc, argv, false,

7553

&agent_directory,

7554

&helper_directory, &user,

7555

&group, &mandos_argz,

7556

&mandos_argz_length));

7557

7558

g_assert_null(helper_directory);

7559

g_assert_null(agent_directory);

7560

g_assert_true(user == 0);

7561

g_assert_true(group == 0);

7562

g_assert_null(mandos_argz);

7563

g_assert_true(mandos_argz_length == 0);

7564

7565

for(char **arg = argv; *arg != NULL; arg++){

7566

free(*arg);

7567

}

7568

}

7569

7570

static

7571

void test_parse_arguments_group_zero_invalid(__attribute__((unused))

7572

test_fixture *fixture,

7573

__attribute__((unused))

7574

gconstpointer user_data){

7575

char *argv[] = {

7576

strdup("prgname"),

7577

strdup("--group"),

7578

strdup("0"),

7579

NULL };

7580

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7581

7582

char *agent_directory = NULL;

7583

__attribute__((cleanup(cleanup_string)))

7584

char *helper_directory = NULL;

7585

uid_t user = 0;

7586

gid_t group = 0;

7587

__attribute__((cleanup(cleanup_string)))

7588

char *mandos_argz = NULL;

7589

size_t mandos_argz_length = 0;

7590

7591

g_assert_false(parse_arguments_devnull(argc, argv, false,

7592

&agent_directory,

7593

&helper_directory, &user,

7594

&group, &mandos_argz,

7595

&mandos_argz_length));

7596

7597

g_assert_null(helper_directory);

7598

g_assert_null(agent_directory);

7599

g_assert_cmpuint((unsigned int)group, ==, 0);

7600

g_assert_true(group == 0);

7601

g_assert_null(mandos_argz);

7602

g_assert_true(mandos_argz_length == 0);

7603

7604

for(char **arg = argv; *arg != NULL; arg++){

7605

free(*arg);

7606

}

7607

}

7608

7609

static void test_parse_arguments_mandos_noargs(__attribute__((unused))

7610

test_fixture *fixture,

7611

__attribute__((unused))

7612

gconstpointer

7613

user_data){

7614

char *argv[] = {

7615

strdup("prgname"),

7616

strdup("mandos-client"),

7617

NULL };

7618

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7619

7620

__attribute__((cleanup(cleanup_string)))

7621

char *agent_directory = NULL;

7622

__attribute__((cleanup(cleanup_string)))

7623

char *helper_directory = NULL;

7624

uid_t user = 0;

7625

gid_t group = 0;

7626

__attribute__((cleanup(cleanup_string)))

7627

char *mandos_argz = NULL;

7628

size_t mandos_argz_length = 0;

7629

7630

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7631

&helper_directory, &user, &group,

7632

&mandos_argz, &mandos_argz_length));

7633

7634

g_assert_null(agent_directory);

7635

g_assert_null(helper_directory);

7636

g_assert_true(user == 0);

7637

g_assert_true(group == 0);

7638

g_assert_cmpstr(mandos_argz, ==, "mandos-client");

7639

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7640

mandos_argz_length),

7641

==, 1);

7642

7643

for(char **arg = argv; *arg != NULL; arg++){

7644

free(*arg);

7645

}

7646

}

7647

7648

static void test_parse_arguments_mandos_args(__attribute__((unused))

7649

test_fixture *fixture,

7650

__attribute__((unused))

7651

gconstpointer user_data){

7652

char *argv[] = {

7653

strdup("prgname"),

7654

strdup("mandos-client"),

7655

strdup("one"),

7656

strdup("two"),

7657

strdup("three"),

7658

NULL };

7659

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7660

7661

__attribute__((cleanup(cleanup_string)))

7662

char *agent_directory = NULL;

7663

__attribute__((cleanup(cleanup_string)))

7664

char *helper_directory = NULL;

7665

uid_t user = 0;

7666

gid_t group = 0;

7667

__attribute__((cleanup(cleanup_string)))

7668

char *mandos_argz = NULL;

7669

size_t mandos_argz_length = 0;

7670

7671

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7672

&helper_directory, &user, &group,

7673

&mandos_argz, &mandos_argz_length));

7674

7675

g_assert_null(agent_directory);

7676

g_assert_null(helper_directory);

7677

g_assert_true(user == 0);

7678

g_assert_true(group == 0);

7679

char *marg = mandos_argz;

7680

g_assert_cmpstr(marg, ==, "mandos-client");

7681

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7682

g_assert_cmpstr(marg, ==, "one");

7683

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7684

g_assert_cmpstr(marg, ==, "two");

7685

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7686

g_assert_cmpstr(marg, ==, "three");

7687

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7688

mandos_argz_length),

7689

==, 4);

7690

7691

for(char **arg = argv; *arg != NULL; arg++){

7692

free(*arg);

7693

}

7694

}

7695

7696

static void test_parse_arguments_all_args(__attribute__((unused))

7697

test_fixture *fixture,

7698

__attribute__((unused))

7699

gconstpointer user_data){

7700

char *argv[] = {

7701

strdup("prgname"),

7702

strdup("--agent-directory"),

7703

strdup("/tmp"),

7704

strdup("--helper-directory"),

7705

strdup("/var/tmp"),

7706

strdup("--user"),

7707

strdup("1"),

7708

strdup("--group"),

7709

strdup("2"),

7710

strdup("mandos-client"),

7711

strdup("one"),

7712

strdup("two"),

7713

strdup("three"),

7714

NULL };

7715

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7716

7717

__attribute__((cleanup(cleanup_string)))

7718

char *agent_directory = NULL;

7719

__attribute__((cleanup(cleanup_string)))

7720

char *helper_directory = NULL;

7721

uid_t user = 0;

7722

gid_t group = 0;

7723

__attribute__((cleanup(cleanup_string)))

7724

char *mandos_argz = NULL;

7725

size_t mandos_argz_length = 0;

7726

7727

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7728

&helper_directory, &user, &group,

7729

&mandos_argz, &mandos_argz_length));

7730

7731

g_assert_cmpstr(agent_directory, ==, "/tmp");

7732

g_assert_cmpstr(helper_directory, ==, "/var/tmp");

7733

g_assert_true(user == 1);

7734

g_assert_true(group == 2);

7735

char *marg = mandos_argz;

7736

g_assert_cmpstr(marg, ==, "mandos-client");

7737

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7738

g_assert_cmpstr(marg, ==, "one");

7739

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7740

g_assert_cmpstr(marg, ==, "two");

7741

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7742

g_assert_cmpstr(marg, ==, "three");

7743

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7744

mandos_argz_length),

7745

==, 4);

7746

7747

for(char **arg = argv; *arg != NULL; arg++){

7748

free(*arg);

7749

}

7750

}

7751

7752

static void test_parse_arguments_mixed(__attribute__((unused))

7753

test_fixture *fixture,

7754

__attribute__((unused))

7755

gconstpointer user_data){

7756

char *argv[] = {

7757

strdup("prgname"),

7758

strdup("mandos-client"),

7759

strdup("--user"),

7760

strdup("1"),

7761

strdup("one"),

7762

strdup("--agent-directory"),

7763

strdup("/tmp"),

7764

strdup("two"),

7765

strdup("three"),

7766

strdup("--helper-directory=/var/tmp"),

7767

NULL };

7768

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7769

7770

__attribute__((cleanup(cleanup_string)))

7771

char *agent_directory = NULL;

7772

__attribute__((cleanup(cleanup_string)))

7773

char *helper_directory = NULL;

7774

uid_t user = 0;

7775

gid_t group = 0;

7776

__attribute__((cleanup(cleanup_string)))

7777

char *mandos_argz = NULL;

7778

size_t mandos_argz_length = 0;

7779

7780

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7781

&helper_directory, &user, &group,

7782

&mandos_argz, &mandos_argz_length));

7783

7784

g_assert_cmpstr(agent_directory, ==, "/tmp");

7785

g_assert_cmpstr(helper_directory, ==, "/var/tmp");

7786

g_assert_true(user == 1);

7787

g_assert_true(group == 0);

7788

char *marg = mandos_argz;

7789

g_assert_cmpstr(marg, ==, "mandos-client");

7790

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7791

g_assert_cmpstr(marg, ==, "one");

7792

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7793

g_assert_cmpstr(marg, ==, "two");

7794

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7795

g_assert_cmpstr(marg, ==, "three");

7796

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7797

mandos_argz_length),

7798

==, 4);

7799

7800

for(char **arg = argv; *arg != NULL; arg++){

7801

free(*arg);

7802

}

7803

}

7804

7805

/* End of tests section */

7806

7807

/* Test boilerplate section; New tests should be added to the test

7808

suite definition here, in the "run_tests" function.

7809

7810

Finally, this section also contains the should_only_run_tests()

7811

function used by main() for deciding if tests should be run or to

7812

start normally. */

7813

7814

__attribute__((cold))

7815

static bool run_tests(int argc, char *argv[]){

7816

g_test_init(&argc, &argv, NULL);

7817

7818

/* A macro to add a test with no setup or teardown functions */

7819

#define test_add(testpath, testfunc) \

7820

do { \

7821

g_test_add((testpath), test_fixture, NULL, NULL, \

7822

(testfunc), NULL); \

7823

} while(false)

7824

7825

/* Test the signal-related functions first, since some other tests

7826

depend on these functions in their setups and teardowns */

7827

test_add("/signal-handling/setup", test_setup_signal_handler);

7828

test_add("/signal-handling/restore", test_restore_signal_handler);

7829

test_add("/signal-handling/block", test_block_sigchld);

7830

test_add("/signal-handling/restore-sigmask", test_restore_sigmask);

7831

7832

/* Regular non-signal-related tests; these use no setups or

7833

teardowns */

7834

test_add("/parse_arguments/noargs", test_parse_arguments_noargs);

7835

test_add("/parse_arguments/invalid", test_parse_arguments_invalid);

7836

test_add("/parse_arguments/long-dir",

7837

test_parse_arguments_long_dir);

7838

test_add("/parse_arguments/short-dir",

7839

test_parse_arguments_short_dir);

7840

test_add("/parse_arguments/helper-directory",

7841

test_parse_arguments_helper_directory);

7842

test_add("/parse_arguments/plugin-helper-dir",

7843

test_parse_arguments_plugin_helper_dir);

7844

test_add("/parse_arguments/user", test_parse_arguments_user);

7845

test_add("/parse_arguments/user-invalid",

7846

test_parse_arguments_user_invalid);

7847

test_add("/parse_arguments/user-zero-invalid",

7848

test_parse_arguments_user_zero_invalid);

7849

test_add("/parse_arguments/group", test_parse_arguments_group);

7850

test_add("/parse_arguments/group-invalid",

7851

test_parse_arguments_group_invalid);

7852

test_add("/parse_arguments/group-zero-invalid",

7853

test_parse_arguments_group_zero_invalid);

7854

test_add("/parse_arguments/mandos-noargs",

7855

test_parse_arguments_mandos_noargs);

7856

test_add("/parse_arguments/mandos-args",

7857

test_parse_arguments_mandos_args);

7858

test_add("/parse_arguments/all-args",

7859

test_parse_arguments_all_args);

7860

test_add("/parse_arguments/mixed", test_parse_arguments_mixed);

7861

test_add("/queue/create", test_create_queue);

7862

test_add("/queue/add", test_add_to_queue);

7863

test_add("/queue/has_question/empty",

7864

test_queue_has_question_empty);

7865

test_add("/queue/has_question/false",

7866

test_queue_has_question_false);

7867

test_add("/queue/has_question/true", test_queue_has_question_true);

7868

test_add("/queue/has_question/false2",

7869

test_queue_has_question_false2);

7870

test_add("/queue/has_question/true2",

7871

test_queue_has_question_true2);

7872

test_add("/buffer/cleanup", test_cleanup_buffer);

7873

test_add("/string_set/net-set-contains-nothing",

7874

test_string_set_new_set_contains_nothing);

7875

test_add("/string_set/with-added-string-contains-it",

7876

test_string_set_with_added_string_contains_it);

7877

test_add("/string_set/cleared-does-not-contain-string",

7878

test_string_set_cleared_does_not_contain_str);

7879

test_add("/string_set/swap/one-with-empty",

7880

test_string_set_swap_one_with_empty);

7881

test_add("/string_set/swap/empty-with-one",

7882

test_string_set_swap_empty_with_one);

7883

test_add("/string_set/swap/one-with-one",

7884

test_string_set_swap_one_with_one);

7885

7886

/* A macro to add a test using the setup and teardown functions */

7887

#define test_add_st(path, func) \

7888

do { \

7889

g_test_add((path), test_fixture, NULL, test_setup, (func), \

7890

test_teardown); \

7891

} while(false)

7892

7893

/* Signal-related tests; these use setups and teardowns which

7894

establish, during each test run, a signal handler for, and a

7895

signal mask blocking, the SIGCHLD signal, just like main() */

7896

test_add_st("/wait_for_event/timeout", test_wait_for_event_timeout);

7897

test_add_st("/wait_for_event/event", test_wait_for_event_event);

7898

test_add_st("/wait_for_event/sigchld", test_wait_for_event_sigchld);

7899

test_add_st("/run_queue/zeroes-next-run",

7900

test_run_queue_zeroes_next_run);

7901

test_add_st("/run_queue/clears-cancelled_filenames",

7902

test_run_queue_clears_cancelled_filenames);

7903

test_add_st("/run_queue/skips-cancelled-filenames",

7904

test_run_queue_skips_cancelled_filenames);

7905

test_add_st("/run_queue/one-task", test_run_queue_one_task);

7906

test_add_st("/run_queue/two-tasks", test_run_queue_two_tasks);

7907

test_add_st("/run_queue/two-tasks/quit",

7908

test_run_queue_two_tasks_quit);

7909

test_add_st("/run_queue/two-tasks-cleanup",

7910

test_run_queue_two_tasks_cleanup);

7911

test_add_st("/task-creators/start_mandos_client",

7912

test_start_mandos_client);

7913

test_add_st("/task-creators/start_mandos_client/execv",

7914

test_start_mandos_client_execv);

7915

test_add_st("/task-creators/start_mandos_client/suid/euid",

7916

test_start_mandos_client_suid_euid);

7917

test_add_st("/task-creators/start_mandos_client/suid/egid",

7918

test_start_mandos_client_suid_egid);

7919

test_add_st("/task-creators/start_mandos_client/suid/ruid",

7920

test_start_mandos_client_suid_ruid);

7921

test_add_st("/task-creators/start_mandos_client/suid/rgid",

7922

test_start_mandos_client_suid_rgid);

7923

test_add_st("/task-creators/start_mandos_client/read",

7924

test_start_mandos_client_read);

7925

test_add_st("/task-creators/start_mandos_client/helper-directory",

7926

test_start_mandos_client_helper_directory);

7927

test_add_st("/task-creators/start_mandos_client/sigmask",

7928

test_start_mandos_client_sigmask);

7929

test_add_st("/task/wait_for_mandos_client_exit/badpid",

7930

test_wait_for_mandos_client_exit_badpid);

7931

test_add_st("/task/wait_for_mandos_client_exit/noexit",

7932

test_wait_for_mandos_client_exit_noexit);

7933

test_add_st("/task/wait_for_mandos_client_exit/success",

7934

test_wait_for_mandos_client_exit_success);

7935

test_add_st("/task/wait_for_mandos_client_exit/failure",

7936

test_wait_for_mandos_client_exit_failure);

7937

test_add_st("/task/wait_for_mandos_client_exit/killed",

7938

test_wait_for_mandos_client_exit_killed);

7939

test_add_st("/task/read_mandos_client_output/readerror",

7940

test_read_mandos_client_output_readerror);

7941

test_add_st("/task/read_mandos_client_output/nodata",

7942

test_read_mandos_client_output_nodata);

7943

test_add_st("/task/read_mandos_client_output/eof",

7944

test_read_mandos_client_output_eof);

7945

test_add_st("/task/read_mandos_client_output/once",

7946

test_read_mandos_client_output_once);

7947

test_add_st("/task/read_mandos_client_output/malloc",

7948

test_read_mandos_client_output_malloc);

7949

test_add_st("/task/read_mandos_client_output/append",

7950

test_read_mandos_client_output_append);

7951

test_add_st("/task-creators/add_inotify_dir_watch",

7952

test_add_inotify_dir_watch);

7953

test_add_st("/task-creators/add_inotify_dir_watch/fail",

7954

test_add_inotify_dir_watch_fail);

7955

test_add_st("/task-creators/add_inotify_dir_watch/not-a-directory",

7956

test_add_inotify_dir_watch_nondir);

7957

test_add_st("/task-creators/add_inotify_dir_watch/EAGAIN",

7958

test_add_inotify_dir_watch_EAGAIN);

7959

test_add_st("/task-creators/add_inotify_dir_watch/IN_CLOSE_WRITE",

7960

test_add_inotify_dir_watch_IN_CLOSE_WRITE);

7961

test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_TO",

7962

test_add_inotify_dir_watch_IN_MOVED_TO);

7963

test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_FROM",

7964

test_add_inotify_dir_watch_IN_MOVED_FROM);

7965

test_add_st("/task-creators/add_inotify_dir_watch/IN_EXCL_UNLINK",

7966

test_add_inotify_dir_watch_IN_EXCL_UNLINK);

7967

test_add_st("/task-creators/add_inotify_dir_watch/IN_DELETE",

7968

test_add_inotify_dir_watch_IN_DELETE);

7969

test_add_st("/task/read_inotify_event/readerror",

7970

test_read_inotify_event_readerror);

7971

test_add_st("/task/read_inotify_event/bad-epoll",

7972

test_read_inotify_event_bad_epoll);

7973

test_add_st("/task/read_inotify_event/nodata",

7974

test_read_inotify_event_nodata);

7975

test_add_st("/task/read_inotify_event/eof",

7976

test_read_inotify_event_eof);

7977

test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE",

7978

test_read_inotify_event_IN_CLOSE_WRITE);

7979

test_add_st("/task/read_inotify_event/IN_MOVED_TO",

7980

test_read_inotify_event_IN_MOVED_TO);

7981

test_add_st("/task/read_inotify_event/IN_MOVED_FROM",

7982

test_read_inotify_event_IN_MOVED_FROM);

7983

test_add_st("/task/read_inotify_event/IN_DELETE",

7984

test_read_inotify_event_IN_DELETE);

7985

test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE/badname",

7986

test_read_inotify_event_IN_CLOSE_WRITE_badname);

7987

test_add_st("/task/read_inotify_event/IN_MOVED_TO/badname",

7988

test_read_inotify_event_IN_MOVED_TO_badname);

7989

test_add_st("/task/read_inotify_event/IN_MOVED_FROM/badname",

7990

test_read_inotify_event_IN_MOVED_FROM_badname);

7991

test_add_st("/task/read_inotify_event/IN_DELETE/badname",

7992

test_read_inotify_event_IN_DELETE_badname);

7993

test_add_st("/task/open_and_parse_question/ENOENT",

7994

test_open_and_parse_question_ENOENT);

7995

test_add_st("/task/open_and_parse_question/EIO",

7996

test_open_and_parse_question_EIO);

7997

test_add_st("/task/open_and_parse_question/parse-error",

7998

test_open_and_parse_question_parse_error);

7999

test_add_st("/task/open_and_parse_question/nosocket",

8000

test_open_and_parse_question_nosocket);

8001

test_add_st("/task/open_and_parse_question/badsocket",

8002

test_open_and_parse_question_badsocket);

8003

test_add_st("/task/open_and_parse_question/nopid",

8004

test_open_and_parse_question_nopid);

8005

test_add_st("/task/open_and_parse_question/badpid",

8006

test_open_and_parse_question_badpid);

8007

test_add_st("/task/open_and_parse_question/noexist_pid",

8008

test_open_and_parse_question_noexist_pid);

8009

test_add_st("/task/open_and_parse_question/no-notafter",

8010

test_open_and_parse_question_no_notafter);

8011

test_add_st("/task/open_and_parse_question/bad-notafter",

8012

test_open_and_parse_question_bad_notafter);

8013

test_add_st("/task/open_and_parse_question/notafter-0",

8014

test_open_and_parse_question_notafter_0);

8015

test_add_st("/task/open_and_parse_question/notafter-1",

8016

test_open_and_parse_question_notafter_1);

8017

test_add_st("/task/open_and_parse_question/notafter-1-1",

8018

test_open_and_parse_question_notafter_1_1);

8019

test_add_st("/task/open_and_parse_question/notafter-1-2",

8020

test_open_and_parse_question_notafter_1_2);

8021

test_add_st("/task/open_and_parse_question/equal-notafter",

8022

test_open_and_parse_question_equal_notafter);

8023

test_add_st("/task/open_and_parse_question/late-notafter",

8024

test_open_and_parse_question_late_notafter);

8025

test_add_st("/task/cancel_old_question/0-1-2",

8026

test_cancel_old_question_0_1_2);

8027

test_add_st("/task/cancel_old_question/0-2-1",

8028

test_cancel_old_question_0_2_1);

8029

test_add_st("/task/cancel_old_question/1-2-3",

8030

test_cancel_old_question_1_2_3);

8031

test_add_st("/task/cancel_old_question/1-3-2",

8032

test_cancel_old_question_1_3_2);

8033

test_add_st("/task/cancel_old_question/2-1-3",

8034

test_cancel_old_question_2_1_3);

8035

test_add_st("/task/cancel_old_question/2-3-1",

8036

test_cancel_old_question_2_3_1);

8037

test_add_st("/task/cancel_old_question/3-1-2",

8038

test_cancel_old_question_3_1_2);

8039

test_add_st("/task/cancel_old_question/3-2-1",

8040

test_cancel_old_question_3_2_1);

8041

test_add_st("/task/connect_question_socket/name-too-long",

8042

test_connect_question_socket_name_too_long);

8043

test_add_st("/task/connect_question_socket/connect-fail",

8044

test_connect_question_socket_connect_fail);

8045

test_add_st("/task/connect_question_socket/bad-epoll",

8046

test_connect_question_socket_bad_epoll);

8047

test_add_st("/task/connect_question_socket/usable",

8048

test_connect_question_socket_usable);

8049

test_add_st("/task/send_password_to_socket/client-not-exited",

8050

test_send_password_to_socket_client_not_exited);

8051

test_add_st("/task/send_password_to_socket/password-not-read",

8052

test_send_password_to_socket_password_not_read);

8053

test_add_st("/task/send_password_to_socket/EMSGSIZE",

8054

test_send_password_to_socket_EMSGSIZE);

8055

test_add_st("/task/send_password_to_socket/retry",

8056

test_send_password_to_socket_retry);

8057

test_add_st("/task/send_password_to_socket/bad-epoll",

8058

test_send_password_to_socket_bad_epoll);

8059

test_add_st("/task/send_password_to_socket/null-password",

8060

test_send_password_to_socket_null_password);

8061

test_add_st("/task/send_password_to_socket/empty-password",

8062

test_send_password_to_socket_empty_password);

8063

test_add_st("/task/send_password_to_socket/empty-str-password",

8064

test_send_password_to_socket_empty_str_pass);

8065

test_add_st("/task/send_password_to_socket/text-password",

8066

test_send_password_to_socket_text_password);

8067

test_add_st("/task/send_password_to_socket/binary-password",

8068

test_send_password_to_socket_binary_password);

8069

test_add_st("/task/send_password_to_socket/nuls-in-password",

8070

test_send_password_to_socket_nuls_in_password);

8071

test_add_st("/task-creators/add_existing_questions/ENOENT",

8072

test_add_existing_questions_ENOENT);

8073

test_add_st("/task-creators/add_existing_questions/no-questions",

8074

test_add_existing_questions_no_questions);

8075

test_add_st("/task-creators/add_existing_questions/one-question",

8076

test_add_existing_questions_one_question);

8077

test_add_st("/task-creators/add_existing_questions/two-questions",

8078

test_add_existing_questions_two_questions);

8079

test_add_st("/task-creators/add_existing_questions/non-questions",

8080

test_add_existing_questions_non_questions);

8081

test_add_st("/task-creators/add_existing_questions/both-types",

8082

test_add_existing_questions_both_types);

8083

8084

return g_test_run() == 0;

8085

}

8086

8087

static bool should_only_run_tests(int *argc_p, char **argv_p[]){

8088

GOptionContext *context = g_option_context_new("");

8089

8090

g_option_context_set_help_enabled(context, FALSE);

8091

g_option_context_set_ignore_unknown_options(context, TRUE);

8092

8093

gboolean run_tests = FALSE;

8094

GOptionEntry entries[] = {

8095

{ "test", 0, 0, G_OPTION_ARG_NONE,

8096

&run_tests, "Run tests", NULL },

8097

{ NULL }

8098

};

8099

g_option_context_add_main_entries(context, entries, NULL);

8100

8101

GError *error = NULL;

8102

8103

if(g_option_context_parse(context, argc_p, argv_p, &error) != TRUE){

8104

g_option_context_free(context);

8105

g_error("Failed to parse options: %s", error->message);

8106

}

8107

8108

g_option_context_free(context);

8109

return run_tests != FALSE;

8110

}