/mandos/release : revision 24.1.186

1

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

2

/*

3

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

4

*

5

6

7

*

8

* This file is part of Mandos.

9

*

10

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

11

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

12

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

13

* (at your option) any later version.

14

*

15

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

16

* WITHOUT ANY WARRANTY; without even the implied warranty of

17

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

18

* General Public License for more details.

19

*

20

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

21

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

22

*

23

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

24

*/

25

26

#define _GNU_SOURCE

27

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

28

intmax_t, uint32_t, SCNx32,

29

SCNuMAX, SCNxMAX */

30

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

31

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

32

getpid() */

33

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

34

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

35

sigemptyset(), sigaddset(),

36

SIGCHLD, pthread_sigmask(),

37

SIG_BLOCK, SIG_SETMASK, SA_RESTART,

38

SA_NOCLDSTOP, sigfillset(), kill(),

39

SIGTERM, sigdelset(), SIGKILL,

40

NSIG, sigismember(), SA_ONSTACK,

41

SIG_DFL, SIG_IGN, SIGINT, SIGQUIT,

42

SIGHUP, SIGSTOP, SIG_UNBLOCK */

43

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

44

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

45

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

46

mkdtemp(), mkostemp() */

47

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

48

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

49

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

50

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

51

ENAMETOOLONG, ENOENT, ENOTDIR,

52

ENOMEM, EEXIST, ECHILD, EPERM,

53

EAGAIN, EINTR, ENOBUFS, EADDRINUSE,

54

ECONNREFUSED, ECONNRESET,

55

ETOOMANYREFS, EMSGSIZE, EBADF,

56

EINVAL */

57

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

58

explicit_bzero(), memset(),

59

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

60

memcmp(), basename() */

61

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

62

argz_extract(), argz_next(),

63

argz_add() */

64

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

65

epoll_ctl(), EPOLL_CTL_ADD,

66

struct epoll_event, EPOLLIN,

67

EPOLLRDHUP, EPOLLOUT,

68

epoll_pwait() */

69

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

70

CLOCK_MONOTONIC */

71

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

72

OPTION_ALIAS, struct argp_state,

73

ARGP_ERR_UNKNOWN, ARGP_KEY_ARGS,

74

struct argp, argp_parse(),

75

ARGP_NO_EXIT */

76

#include <stdint.h> /* SIZE_MAX */

77

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

78

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

79

STDOUT_FILENO, setresgid(),

80

setresuid(), execv(), ssize_t,

81

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

82

STDERR_FILENO, pause(), write(),

83

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

84

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

85

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

86

F_GETFD, F_GETFL, FD_CLOEXEC,

87

open(), O_WRONLY, O_NOCTTY,

88

O_RDONLY, O_NOFOLLOW */

89

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

90

WEXITSTATUS() */

91

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

92

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

93

IN_CLOEXEC, inotify_add_watch(),

94

IN_CLOSE_WRITE, IN_MOVED_TO,

95

IN_MOVED_FROM, IN_DELETE,

96

IN_EXCL_UNLINK, IN_ONLYDIR,

97

struct inotify_event */

98

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

99

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

100

fclose(), getline(), sscanf(),

101

feof(), ferror(), rename(),

102

fdopen(), fprintf(), fscanf() */

103

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

104

GError, g_key_file_load_from_file(),

105

G_KEY_FILE_NONE, TRUE, G_FILE_ERROR_NOENT,

106

g_key_file_get_string(), guint64,

107

g_key_file_get_uint64(),

108

G_KEY_FILE_ERROR_KEY_NOT_FOUND, gconstpointer,

109

g_assert_true(), g_assert_nonnull(),

110

g_assert_null(), g_assert_false(),

111

g_assert_cmpint(), g_assert_cmpuint(),

112

g_test_skip(), g_assert_cmpstr(),

113

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

114

GOptionContext, g_option_context_new(),

115

g_option_context_set_help_enabled(), FALSE,

116

g_option_context_set_ignore_unknown_options(),

117

gboolean, GOptionEntry, G_OPTION_ARG_NONE,

118

g_option_context_add_main_entries(),

119

g_option_context_parse(),

120

g_option_context_free(), g_error() */

121

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

122

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

123

SOCK_DGRAM, SOCK_NONBLOCK,

124

SOCK_CLOEXEC, connect(),

125

struct sockaddr, socklen_t,

126

shutdown(), SHUT_RD, send(),

127

MSG_NOSIGNAL, bind(), recv(),

128

socketpair() */

129

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

130

GLOB_ERR, GLOB_NOSORT, GLOB_MARK,

131

GLOB_ABORTED, GLOB_NOMATCH,

132

GLOB_NOSPACE */

133

134

/* End of includes */

135

136

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

137

138

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

139

typedef uintmax_t mono_microsecs;

140

141

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

142

typedef struct {

143

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

144

size_t length; /* Number of tasks */

145

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

146

size_t allocated;

147

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

148

mono_microsecs next_run;

149

} __attribute__((designated_init)) task_queue;

150

151

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

152

153

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

154

this type */

155

typedef void (task_func) (const struct task_struct,

156

task_queue *const)

157

__attribute__((nonnull));

158

159

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

160

161

Used for the "password" variable */

162

typedef struct {

163

char *data;

164

size_t length;

165

size_t allocated;

166

} __attribute__((designated_init)) buffer;

167

168

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

169

170

Used by the "cancelled_filenames" variable */

171

typedef struct {

172

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

173

size_t argz_len; /* the string_set_* functions */

174

} __attribute__((designated_init)) string_set;

175

176

/* "task_context" - local variables for tasks

177

178

This data structure distinguishes between different tasks which are

179

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

180

task function when each task is run.

181

182

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

183

typedef struct task_struct {

184

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

185

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

186

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

187

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

188

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

189

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

190

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

191

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

192

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

193

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

194

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

195

been cancelled for any reason; tasks pertaining to these question

196

files should not be run */

197

string_set *const cancelled_filenames;

198

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

199

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

200

const mono_microsecs *const current_time;

201

} __attribute__((designated_init)) task_context;

202

203

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

204

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

205

declared in the test section. */

206

__attribute__((warn_unused_result))

207

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

208

__attribute__((warn_unused_result, cold))

209

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

210

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

211

__attribute__((warn_unused_result, malloc))

212

task_queue *create_queue(void);

213

__attribute__((nonnull, warn_unused_result))

214

bool add_to_queue(task_queue *const, const task_context);

215

__attribute__((nonnull))

216

void cleanup_task(const task_context *const);

217

__attribute__((nonnull))

218

void cleanup_queue(task_queue *const *const);

219

__attribute__((pure, nonnull, warn_unused_result))

220

bool queue_has_question(const task_queue *const);

221

__attribute__((nonnull))

222

void cleanup_close(const int *const);

223

__attribute__((nonnull))

224

void cleanup_string(char *const *const);

225

__attribute__((nonnull))

226

void cleanup_buffer(buffer *const);

227

__attribute__((pure, nonnull, warn_unused_result))

228

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

229

__attribute__((nonnull, warn_unused_result))

230

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

231

__attribute__((nonnull))

232

void string_set_clear(string_set *);

233

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

234

__attribute__((nonnull, warn_unused_result))

235

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

236

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

237

const struct sigaction *const,

238

const sigset_t, const char *const,

239

const uid_t, const gid_t,

240

const char *const *const);

241

__attribute__((nonnull))

242

task_func wait_for_mandos_client_exit;

243

__attribute__((nonnull))

244

task_func read_mandos_client_output;

245

__attribute__((warn_unused_result))

246

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

247

buffer *const, const char *const,

248

string_set *, const mono_microsecs *const,

249

bool *const, bool *const);

250

__attribute__((nonnull))

251

task_func read_inotify_event;

252

__attribute__((nonnull))

253

task_func open_and_parse_question;

254

__attribute__((nonnull))

255

task_func cancel_old_question;

256

__attribute__((nonnull))

257

task_func connect_question_socket;

258

__attribute__((nonnull))

259

task_func send_password_to_socket;

260

__attribute__((warn_unused_result))

261

bool add_existing_questions(task_queue *const, const int,

262

buffer *const, string_set *,

263

const mono_microsecs *const,

264

bool *const, bool *const,

265

const char *const);

266

__attribute__((nonnull, warn_unused_result))

267

bool wait_for_event(const int, const mono_microsecs,

268

const mono_microsecs);

269

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

270

bool clear_all_fds_from_epoll_set(const int);

271

mono_microsecs get_current_time(void);

272

__attribute__((nonnull, warn_unused_result))

273

bool setup_signal_handler(struct sigaction *const);

274

__attribute__((nonnull))

275

bool restore_signal_handler(const struct sigaction *const);

276

__attribute__((nonnull, warn_unused_result))

277

bool block_sigchld(sigset_t *const);

278

__attribute__((nonnull))

279

bool restore_sigmask(const sigset_t *const);

280

__attribute__((nonnull))

281

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

282

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

283

284

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

285

286

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

287

288

Code here should be as simple as possible. */

289

290

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

291

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

292

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

293

294

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

295

296

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

297

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

298

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

299

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

300

if(run_tests(argc, argv)){

301

return EXIT_SUCCESS; /* All tests successful */

302

}

303

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

304

}

305

306

__attribute__((cleanup(cleanup_string)))

307

char *agent_directory = NULL;

308

309

__attribute__((cleanup(cleanup_string)))

310

char *helper_directory = NULL;

311

312

uid_t user = 0;

313

gid_t group = 0;

314

315

__attribute__((cleanup(cleanup_string)))

316

char *mandos_argz = NULL;

317

size_t mandos_argz_length = 0;

318

319

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

320

&helper_directory, &user, &group,

321

&mandos_argz, &mandos_argz_length)){

322

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

323

argument to parse_arguments() above, which should make

324

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

325

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

326

}

327

328

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

329

const char default_helper_directory[]

330

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

331

const char *const default_argv[]

332

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

333

334

/* Set variables to default values if unset */

335

if(agent_directory == NULL){

336

agent_directory = strdup(default_agent_directory);

337

if(agent_directory == NULL){

338

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

339

}

340

}

341

if(helper_directory == NULL){

342

helper_directory = strdup(default_helper_directory);

343

if(helper_directory == NULL){

344

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

345

}

346

}

347

if(user == 0){

348

user = 65534; /* nobody */

349

}

350

if(group == 0){

351

group = 65534; /* nogroup */

352

}

353

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

354

default values */

355

if(mandos_argz == NULL){

356

#ifdef __GNUC__

357

#pragma GCC diagnostic push

358

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

359

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

360

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

361

#pragma GCC diagnostic ignored "-Wcast-qual"

362

#endif

363

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

364

&mandos_argz_length);

365

#ifdef __GNUC__

366

#pragma GCC diagnostic pop

367

#endif

368

if(errno != 0){

369

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

370

}

371

}

372

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

373

374

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

375

mandos_argz_length)

376

+ 1) * sizeof(char *));

377

if(mandos_argv == NULL){

378

error_t saved_errno = errno;

379

free(mandos_argz);

380

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

381

}

382

argz_extract(mandos_argz, mandos_argz_length, mandos_argv);

383

384

sigset_t orig_sigmask;

385

if(not block_sigchld(&orig_sigmask)){

386

return EX_OSERR;

387

}

388

389

struct sigaction old_sigchld_action;

390

if(not setup_signal_handler(&old_sigchld_action)){

391

return EX_OSERR;

392

}

393

394

mono_microsecs current_time = 0;

395

396

bool mandos_client_exited = false;

397

bool quit_now = false;

398

__attribute__((cleanup(cleanup_close)))

399

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

400

if(epoll_fd < 0){

401

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

402

}

403

__attribute__((cleanup(cleanup_queue)))

404

task_queue *queue = create_queue();

405

if(queue == NULL){

406

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

407

}

408

409

__attribute__((cleanup(cleanup_buffer)))

410

buffer password = {};

411

bool password_is_read = false;

412

413

__attribute__((cleanup(string_set_clear)))

414

string_set cancelled_filenames = {};

415

416

/* Add tasks to queue */

417

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

418

&quit_now, &password, &password_is_read,

419

&old_sigchld_action, orig_sigmask,

420

helper_directory, user, group,

421

(const char *const *)mandos_argv)){

422

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

423

}

424

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

425

needed anymore */

426

free(mandos_argv);

427

free(mandos_argz);

428

mandos_argz = NULL;

429

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

430

agent_directory, &cancelled_filenames,

431

&current_time, &mandos_client_exited,

432

&password_is_read)){

433

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

434

case EACCES:

435

case ENAMETOOLONG:

436

case ENOENT:

437

case ENOTDIR:

438

return EX_OSFILE;

439

default:

440

return EX_OSERR;

441

}

442

}

443

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

444

&cancelled_filenames, &current_time,

445

&mandos_client_exited,

446

&password_is_read, agent_directory)){

447

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

448

}

449

450

/* Run queue */

451

do {

452

current_time = get_current_time();

453

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

454

const error_t saved_errno = errno;

455

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

456

" events");

457

}

458

459

current_time = get_current_time();

460

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

461

const error_t saved_errno = errno;

462

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

463

}

464

465

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

466

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

467

} while(queue_has_question(queue));

468

469

restore_signal_handler(&old_sigchld_action);

470

restore_sigmask(&orig_sigmask);

471

472

return EXIT_SUCCESS;

473

}

474

475

__attribute__((warn_unused_result))

476

mono_microsecs get_current_time(void){

477

struct timespec currtime;

478

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

479

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

480

return 0;

481

}

482

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

483

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

484

}

485

486

/* End of "main" section */

487

488

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

489

490

__attribute__((nonnull))

491

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

492

char **agent_directory, char **helper_directory,

493

uid_t *const user, gid_t *const group,

494

char **mandos_argz, size_t *mandos_argz_length){

495

496

const struct argp_option options[] = {

497

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

498

.doc="Systemd password agent directory" },

499

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

500

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

501

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

502

.flags=OPTION_HIDDEN | OPTION_ALIAS },

503

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

504

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

505

" user" },

506

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

507

.flags=OPTION_HIDDEN | OPTION_ALIAS },

508

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

509

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

510

" group" },

511

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

512

.flags=OPTION_HIDDEN | OPTION_ALIAS },

513

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

514

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

515

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

516

{ NULL },

517

};

518

519

__attribute__((nonnull(3)))

520

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

521

errno = 0;

522

switch(key){

523

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

524

*agent_directory = strdup(arg);

525

break;

526

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

527

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

528

*helper_directory = strdup(arg);

529

break;

530

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

531

case 130: /* --userid */

532

{

533

char *tmp;

534

uintmax_t tmp_id = 0;

535

errno = 0;

536

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

537

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

538

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

539

return ARGP_ERR_UNKNOWN;

540

}

541

*user = (uid_t)tmp_id;

542

errno = 0;

543

break;

544

}

545

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

546

case 131: /* --groupid */

547

{

548

char *tmp;

549

uintmax_t tmp_id = 0;

550

errno = 0;

551

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

552

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

553

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

554

return ARGP_ERR_UNKNOWN;

555

}

556

*group = (gid_t)tmp_id;

557

errno = 0;

558

break;

559

}

560

case ARGP_KEY_ARGS:

561

/* Copy arguments into argz vector */

562

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

563

mandos_argz_length);

564

default:

565

return ARGP_ERR_UNKNOWN;

566

}

567

return errno;

568

}

569

570

const struct argp argp = {

571

.options=options,

572

.parser=parse_opt,

573

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

574

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

575

" systemd password agent",

576

};

577

578

errno = argp_parse(&argp, argc, argv,

579

exit_failure ? 0 : ARGP_NO_EXIT, NULL, NULL);

580

581

return errno == 0;

582

}

583

584

__attribute__((nonnull, warn_unused_result))

585

bool block_sigchld(sigset_t *const orig_sigmask){

586

sigset_t sigchld_sigmask;

587

if(sigemptyset(&sigchld_sigmask) < 0){

588

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

589

return false;

590

}

591

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

592

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

593

return false;

594

}

595

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

596

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

597

return false;

598

}

599

return true;

600

}

601

602

__attribute__((nonnull, warn_unused_result, const))

603

bool restore_sigmask(const sigset_t *const orig_sigmask){

604

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

605

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

606

return false;

607

}

608

return true;

609

}

610

611

__attribute__((nonnull, warn_unused_result))

612

bool setup_signal_handler(struct sigaction *const old_sigchld_action){

613

struct sigaction sigchld_action = {

614

.sa_handler=handle_sigchld,

615

.sa_flags=SA_RESTART | SA_NOCLDSTOP,

616

};

617

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

618

signals automatically blocked during signal handler */

619

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

620

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

621

return false;

622

}

623

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

624

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

625

return false;

626

}

627

return true;

628

}

629

630

__attribute__((nonnull, warn_unused_result))

631

bool restore_signal_handler(const struct sigaction *const

632

old_sigchld_action){

633

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

634

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

635

return false;

636

}

637

return true;

638

}

639

640

__attribute__((warn_unused_result, malloc))

641

task_queue *create_queue(void){

642

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

643

if(queue){

644

queue->tasks = NULL;

645

queue->length = 0;

646

queue->allocated = 0;

647

queue->next_run = 0;

648

}

649

return queue;

650

}

651

652

__attribute__((nonnull, warn_unused_result))

653

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

654

if((queue->length + 1) > (SIZE_MAX / sizeof(task_context))){

655

/* overflow */

656

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

657

" tasks for queue->tasks", (uintmax_t)(queue->length + 1));

658

errno = ENOMEM;

659

return false;

660

}

661

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

662

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

663

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

664

needed_size);

665

if(new_tasks == NULL){

666

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

667

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

668

return false;

669

}

670

queue->tasks = new_tasks;

671

queue->allocated = needed_size;

672

}

673

/* Using memcpy here is necessary because doing */

674

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

675

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

676

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

677

sizeof(task_context));

678

return true;

679

}

680

681

__attribute__((nonnull))

682

void cleanup_task(const task_context *const task){

683

const error_t saved_errno = errno;

684

/* free and close all task data */

685

free(task->question_filename);

686

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

687

free(task->filename);

688

}

689

if(task->pid > 0){

690

kill(task->pid, SIGTERM);

691

}

692

if(task->fd > 0){

693

close(task->fd);

694

}

695

errno = saved_errno;

696

}

697

698

__attribute__((nonnull))

699

void free_queue(task_queue *const queue){

700

free(queue->tasks);

701

free(queue);

702

}

703

704

__attribute__((nonnull))

705

void cleanup_queue(task_queue *const *const queue){

706

if(*queue == NULL){

707

return;

708

}

709

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

710

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

711

cleanup_task(task);

712

}

713

free_queue(*queue);

714

}

715

716

__attribute__((pure, nonnull, warn_unused_result))

717

bool queue_has_question(const task_queue *const queue){

718

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

719

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

720

return true;

721

}

722

}

723

return false;

724

}

725

726

__attribute__((nonnull))

727

void cleanup_close(const int *const fd){

728

const error_t saved_errno = errno;

729

close(*fd);

730

errno = saved_errno;

731

}

732

733

__attribute__((nonnull))

734

void cleanup_string(char *const *const ptr){

735

free(*ptr);

736

}

737

738

__attribute__((nonnull))

739

void cleanup_buffer(buffer *buf){

740

if(buf->allocated > 0){

741

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

742

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

743

#else

744

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

745

#endif

746

}

747

if(buf->data != NULL){

748

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

749

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

750

}

751

free(buf->data);

752

buf->data = NULL;

753

}

754

buf->length = 0;

755

buf->allocated = 0;

756

}

757

758

__attribute__((pure, nonnull, warn_unused_result))

759

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

760

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

761

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

762

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

763

return true;

764

}

765

}

766

return false;

767

}

768

769

__attribute__((nonnull, warn_unused_result))

770

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

771

if(string_set_contains(*set, str)){

772

return true;

773

}

774

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

775

if(error == 0){

776

return true;

777

}

778

errno = error;

779

return false;

780

}

781

782

__attribute__((nonnull))

783

void string_set_clear(string_set *set){

784

free(set->argz);

785

set->argz = NULL;

786

set->argz_len = 0;

787

}

788

789

__attribute__((nonnull))

790

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

791

/* Swap contents of two string sets */

792

{

793

char *const tmp_argz = set1->argz;

794

set1->argz = set2->argz;

795

set2->argz = tmp_argz;

796

}

797

{

798

const size_t tmp_argz_len = set1->argz_len;

799

set1->argz_len = set2->argz_len;

800

set2->argz_len = tmp_argz_len;

801

}

802

}

803

804

__attribute__((nonnull, warn_unused_result))

805

bool start_mandos_client(task_queue *const queue,

806

const int epoll_fd,

807

bool *const mandos_client_exited,

808

bool *const quit_now, buffer *const password,

809

bool *const password_is_read,

810

const struct sigaction *const

811

old_sigchld_action, const sigset_t sigmask,

812

const char *const helper_directory,

813

const uid_t user, const gid_t group,

814

const char *const *const argv){

815

int pipefds[2];

816

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

817

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

818

return false;

819

}

820

821

const pid_t pid = fork();

822

if(pid == 0){

823

if(not restore_signal_handler(old_sigchld_action)){

824

_exit(EXIT_FAILURE);

825

}

826

if(not restore_sigmask(&sigmask)){

827

_exit(EXIT_FAILURE);

828

}

829

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

830

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

831

_exit(EXIT_FAILURE);

832

}

833

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

834

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

835

_exit(EXIT_FAILURE);

836

}

837

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

838

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

839

_exit(EXIT_FAILURE);

840

}

841

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

842

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

843

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

844

_exit(EXIT_FAILURE);

845

}

846

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

847

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

848

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

849

_exit(EXIT_FAILURE);

850

}

851

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

852

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

853

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

854

_exit(EXIT_FAILURE);

855

}

856

#ifdef __GNUC__

857

#pragma GCC diagnostic push

858

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

859

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

860

#pragma GCC diagnostic ignored "-Wcast-qual"

861

#endif

862

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

863

#ifdef __GNUC__

864

#pragma GCC diagnostic pop

865

#endif

866

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

867

_exit(EXIT_FAILURE);

868

}

869

close(pipefds[1]);

870

871

if(not add_to_queue(queue, (task_context){

872

.func=wait_for_mandos_client_exit,

873

.pid=pid,

874

.mandos_client_exited=mandos_client_exited,

875

.quit_now=quit_now,

876

})){

877

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

878

close(pipefds[0]);

879

return false;

880

}

881

882

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

883

&(struct epoll_event)

884

{ .events=EPOLLIN | EPOLLRDHUP });

885

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

886

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

887

close(pipefds[0]);

888

return false;

889

}

890

891

return add_to_queue(queue, (task_context){

892

.func=read_mandos_client_output,

893

.epoll_fd=epoll_fd,

894

.fd=pipefds[0],

895

.quit_now=quit_now,

896

.password=password,

897

.password_is_read=password_is_read,

898

});

899

}

900

901

__attribute__((nonnull))

902

void wait_for_mandos_client_exit(const task_context task,

903

task_queue *const queue){

904

const pid_t pid = task.pid;

905

bool *const mandos_client_exited = task.mandos_client_exited;

906

bool *const quit_now = task.quit_now;

907

908

int status;

909

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

910

case 0: /* Not exited yet */

911

if(not add_to_queue(queue, task)){

912

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

913

*quit_now = true;

914

}

915

break;

916

case -1: /* Error */

917

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

918

if(errno != ECHILD){

919

kill(pid, SIGTERM);

920

}

921

*quit_now = true;

922

break;

923

default: /* Has exited */

924

*mandos_client_exited = true;

925

if((not WIFEXITED(status))

926

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

927

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

928

*quit_now = true;

929

}

930

}

931

}

932

933

__attribute__((nonnull))

934

void read_mandos_client_output(const task_context task,

935

task_queue *const queue){

936

buffer *const password = task.password;

937

bool *const quit_now = task.quit_now;

938

bool *const password_is_read = task.password_is_read;

939

const int fd = task.fd;

940

const int epoll_fd = task.epoll_fd;

941

942

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

943

if(password->allocated < new_potential_size){

944

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

945

if(new_buffer == NULL){

946

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

947

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

948

*quit_now = true;

949

close(fd);

950

return;

951

}

952

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

953

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

954

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

955

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

956

}

957

}

958

if(password->length > 0){

959

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

960

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

961

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

962

#else

963

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

964

#endif

965

}

966

if(password->data != NULL){

967

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

968

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

969

}

970

free(password->data);

971

}

972

password->data = new_buffer;

973

password->allocated = new_potential_size;

974

}

975

976

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

977

+ password->length, PIPE_BUF);

978

979

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

980

*password_is_read = true;

981

close(fd);

982

return;

983

}

984

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

985

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

986

*quit_now = true;

987

close(fd);

988

return;

989

}

990

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

991

password->length += (size_t)read_length;

992

}

993

994

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

995

available yet */

996

997

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

998

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

999

&(struct epoll_event)

1000

{ .events=EPOLLIN | EPOLLRDHUP });

1001

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

1002

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

1003

*quit_now = true;

1004

close(fd);

1005

return;

1006

}

1007

1008

/* Re-add myself to the queue */

1009

if(not add_to_queue(queue, task)){

1010

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

1011

*quit_now = true;

1012

close(fd);

1013

}

1014

}

1015

1016

__attribute__((nonnull, warn_unused_result))

1017

bool add_inotify_dir_watch(task_queue *const queue,

1018

const int epoll_fd, bool *const quit_now,

1019

buffer *const password,

1020

const char *const dir,

1021

string_set *cancelled_filenames,

1022

const mono_microsecs *const current_time,

1023

bool *const mandos_client_exited,

1024

bool *const password_is_read){

1025

const int fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);

1026

if(fd == -1){

1027

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

1028

return false;

1029

}

1030

1031

if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE | IN_MOVED_TO

1032

| IN_MOVED_FROM| IN_DELETE | IN_EXCL_UNLINK

1033

| IN_ONLYDIR)

1034

== -1){

1035

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

1036

return false;

1037

}

1038

1039

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

1040

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

1041

&(struct epoll_event)

1042

{ .events=EPOLLIN | EPOLLRDHUP });

1043

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

1044

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

1045

close(fd);

1046

return false;

1047

}

1048

1049

const task_context read_inotify_event_task = {

1050

.func=read_inotify_event,

1051

.epoll_fd=epoll_fd,

1052

.quit_now=quit_now,

1053

.password=password,

1054

.fd=fd,

1055

.filename=strdup(dir),

1056

.cancelled_filenames=cancelled_filenames,

1057

.current_time=current_time,

1058

.mandos_client_exited=mandos_client_exited,

1059

.password_is_read=password_is_read,

1060

};

1061

if(read_inotify_event_task.filename == NULL){

1062

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

1063

close(fd);

1064

return false;

1065

}

1066

1067

return add_to_queue(queue, read_inotify_event_task);

1068

}

1069

1070

__attribute__((nonnull))

1071

void read_inotify_event(const task_context task,

1072

task_queue *const queue){

1073

const int fd = task.fd;

1074

const int epoll_fd = task.epoll_fd;

1075

char *const filename = task.filename;

1076

bool *quit_now = task.quit_now;

1077

buffer *const password = task.password;

1078

string_set *const cancelled_filenames = task.cancelled_filenames;

1079

const mono_microsecs *const current_time = task.current_time;

1080

bool *const mandos_client_exited = task.mandos_client_exited;

1081

bool *const password_is_read = task.password_is_read;

1082

1083

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

1084

const size_t ievent_size = (sizeof(struct inotify_event)

1085

+ NAME_MAX + 1);

1086

struct {

1087

struct inotify_event event;

1088

char name_buffer[NAME_MAX + 1];

1089

} ievent_buffer;

1090

struct inotify_event *const ievent = &ievent_buffer.event;

1091

1092

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

1093

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

1094

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

1095

*quit_now = true;

1096

cleanup_task(&task);

1097

return;

1098

}

1099

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

1100

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

1101

filename);

1102

*quit_now = true;

1103

cleanup_task(&task);

1104

return;

1105

}

1106

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

1107

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

1108

char *question_filename = NULL;

1109

const ssize_t question_filename_length

1110

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

1111

if(question_filename_length < 0){

1112

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

1113

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

1114

} else {

1115

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

1116

if(not add_to_queue(queue, (task_context){

1117

.func=open_and_parse_question,

1118

.epoll_fd=epoll_fd,

1119

.question_filename=question_filename,

1120

.filename=question_filename,

1121

.password=password,

1122

.cancelled_filenames=cancelled_filenames,

1123

.current_time=current_time,

1124

.mandos_client_exited=mandos_client_exited,

1125

.password_is_read=password_is_read,

1126

})){

1127

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

1128

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

1129

} else {

1130

/* Force the added task (open_and_parse_question) to run

1131

immediately */

1132

queue->next_run = 1;

1133

}

1134

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

1135

if(not string_set_add(cancelled_filenames,

1136

question_filename)){

1137

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

1138

" cancelled_questions", question_filename);

1139

*quit_now = true;

1140

free(question_filename);

1141

cleanup_task(&task);

1142

return;

1143

}

1144

free(question_filename);

1145

}

1146

}

1147

}

1148

1149

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

1150

available yet */

1151

1152

/* Re-add myself to the queue */

1153

if(not add_to_queue(queue, task)){

1154

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

1155

" queue", filename);

1156

*quit_now = true;

1157

cleanup_task(&task);

1158

return;

1159

}

1160

1161

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

1162

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

1163

&(struct epoll_event)

1164

{ .events=EPOLLIN | EPOLLRDHUP });

1165

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

1166

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

1167

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

1168

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

1169

one second from now */

1170

if((queue->next_run == 0)

1171

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

1172

queue->next_run = *current_time + 1000000;

1173

}

1174

}

1175

}

1176

1177

__attribute__((nonnull))

1178

void open_and_parse_question(const task_context task,

1179

task_queue *const queue){

1180

__attribute__((cleanup(cleanup_string)))

1181

char *question_filename = task.question_filename;

1182

const int epoll_fd = task.epoll_fd;

1183

buffer *const password = task.password;

1184

string_set *const cancelled_filenames = task.cancelled_filenames;

1185

const mono_microsecs *const current_time = task.current_time;

1186

bool *const mandos_client_exited = task.mandos_client_exited;

1187

bool *const password_is_read = task.password_is_read;

1188

1189

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

1190

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

1191

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

1192

__attribute__((nonnull))

1193

void cleanup_g_key_file(GKeyFile **key_file){

1194

if(*key_file != NULL){

1195

g_key_file_free(*key_file);

1196

}

1197

}

1198

1199

__attribute__((cleanup(cleanup_g_key_file)))

1200

GKeyFile *key_file = g_key_file_new();

1201

if(key_file == NULL){

1202

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

1203

question_filename);

1204

return;

1205

}

1206

GError *glib_error = NULL;

1207

if(g_key_file_load_from_file(key_file, question_filename,

1208

G_KEY_FILE_NONE, &glib_error) != TRUE){

1209

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

1210

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

1211

if(glib_error->code != G_FILE_ERROR_NOENT){

1212

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

1213

question_filename, glib_error->message);

1214

}

1215

return;

1216

}

1217

1218

__attribute__((cleanup(cleanup_string)))

1219

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

1220

"Socket",

1221

&glib_error);

1222

if(socket_name == NULL){

1223

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

1224

question_filename, glib_error->message);

1225

return;

1226

}

1227

1228

if(strlen(socket_name) == 0){

1229

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

1230

question_filename);

1231

return;

1232

}

1233

1234

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

1235

&glib_error);

1236

if(glib_error != NULL){

1237

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

1238

question_filename, glib_error->message);

1239

return;

1240

}

1241

1242

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

1243

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

1244

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

1245

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

1246

return;

1247

}

1248

1249

guint64 notafter = g_key_file_get_uint64(key_file, "Ask",

1250

"NotAfter", &glib_error);

1251

if(glib_error != NULL){

1252

if(glib_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND){

1253

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

1254

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

1255

}

1256

notafter = 0;

1257

}

1258

if(notafter != 0){

1259

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

1260

queue->next_run = notafter;

1261

}

1262

if(*current_time >= notafter){

1263

return;

1264

}

1265

}

1266

1267

const task_context connect_question_socket_task = {

1268

.func=connect_question_socket,

1269

.question_filename=strdup(question_filename),

1270

.epoll_fd=epoll_fd,

1271

.password=password,

1272

.filename=strdup(socket_name),

1273

.cancelled_filenames=task.cancelled_filenames,

1274

.mandos_client_exited=mandos_client_exited,

1275

.password_is_read=password_is_read,

1276

.current_time=current_time,

1277

};

1278

if(connect_question_socket_task.question_filename == NULL

1279

or connect_question_socket_task.filename == NULL

1280

or not add_to_queue(queue, connect_question_socket_task)){

1281

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

1282

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

1283

question_filename);

1284

cleanup_task(&connect_question_socket_task);

1285

return;

1286

}

1287

/* Force the added task (connect_question_socket) to run

1288

immediately */

1289

queue->next_run = 1;

1290

1291

if(notafter > 0){

1292

char *const dup_filename = strdup(question_filename);

1293

const task_context cancel_old_question_task = {

1294

.func=cancel_old_question,

1295

.question_filename=dup_filename,

1296

.notafter=notafter,

1297

.filename=dup_filename,

1298

.cancelled_filenames=cancelled_filenames,

1299

.current_time=current_time,

1300

};

1301

if(cancel_old_question_task.question_filename == NULL

1302

or not add_to_queue(queue, cancel_old_question_task)){

1303

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

1304

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

1305

cleanup_task(&cancel_old_question_task);

1306

return;

1307

}

1308

}

1309

}

1310

1311

__attribute__((nonnull))

1312

void cancel_old_question(const task_context task,

1313

task_queue *const queue){

1314

char *const question_filename = task.question_filename;

1315

string_set *const cancelled_filenames = task.cancelled_filenames;

1316

const mono_microsecs notafter = task.notafter;

1317

const mono_microsecs *const current_time = task.current_time;

1318

1319

if(*current_time >= notafter){

1320

if(not string_set_add(cancelled_filenames, question_filename)){

1321

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

1322

question_filename);

1323

}

1324

cleanup_task(&task);

1325

return;

1326

}

1327

1328

if(not add_to_queue(queue, task)){

1329

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

1330

"%s to queue", question_filename);

1331

cleanup_task(&task);

1332

return;

1333

}

1334

1335

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

1336

queue->next_run = notafter;

1337

}

1338

}

1339

1340

__attribute__((nonnull))

1341

void connect_question_socket(const task_context task,

1342

task_queue *const queue){

1343

char *const question_filename = task.question_filename;

1344

char *const filename = task.filename;

1345

const int epoll_fd = task.epoll_fd;

1346

buffer *const password = task.password;

1347

string_set *const cancelled_filenames = task.cancelled_filenames;

1348

bool *const mandos_client_exited = task.mandos_client_exited;

1349

bool *const password_is_read = task.password_is_read;

1350

const mono_microsecs *const current_time = task.current_time;

1351

1352

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

1353

1354

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

1355

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

1356

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

1357

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

1358

if(not string_set_add(cancelled_filenames, question_filename)){

1359

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

1360

question_filename);

1361

}

1362

cleanup_task(&task);

1363

return;

1364

}

1365

1366

const int fd = socket(PF_LOCAL, SOCK_DGRAM

1367

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

1368

if(fd < 0){

1369

error(0, errno,

1370

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

1371

if(not add_to_queue(queue, task)){

1372

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

1373

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

1374

filename);

1375

cleanup_task(&task);

1376

} else {

1377

/* Force the added task (connect_question_socket) to run

1378

immediately */

1379

queue->next_run = 1;

1380

}

1381

return;

1382

}

1383

1384

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

1385

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

1386

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

1387

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

1388

if(not add_to_queue(queue, task)){

1389

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

1390

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

1391

filename);

1392

cleanup_task(&task);

1393

} else {

1394

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

1395

at most one second from now */

1396

if((queue->next_run == 0)

1397

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

1398

queue->next_run = *current_time + 1000000;

1399

}

1400

}

1401

return;

1402

}

1403

1404

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

1405

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

1406

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

1407

filename);

1408

}

1409

1410

/* Add the fd to the epoll set */

1411

if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

1412

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

1413

!= 0){

1414

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

1415

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

1416

if(not add_to_queue(queue, task)){

1417

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

1418

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

1419

filename);

1420

cleanup_task(&task);

1421

} else {

1422

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

1423

at most one second from now */

1424

if((queue->next_run == 0)

1425

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

1426

queue->next_run = *current_time + 1000000;

1427

}

1428

}

1429

return;

1430

}

1431

1432

/* add task send_password_to_socket to queue */

1433

const task_context send_password_to_socket_task = {

1434

.func=send_password_to_socket,

1435

.question_filename=question_filename,

1436

.filename=filename,

1437

.epoll_fd=epoll_fd,

1438

.fd=fd,

1439

.password=password,

1440

.cancelled_filenames=cancelled_filenames,

1441

.mandos_client_exited=mandos_client_exited,

1442

.password_is_read=password_is_read,

1443

.current_time=current_time,

1444

};

1445

1446

if(not add_to_queue(queue, send_password_to_socket_task)){

1447

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

1448

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

1449

question_filename, filename);

1450

cleanup_task(&send_password_to_socket_task);

1451

}

1452

}

1453

1454

__attribute__((nonnull))

1455

void send_password_to_socket(const task_context task,

1456

task_queue *const queue){

1457

char *const question_filename=task.question_filename;

1458

char *const filename=task.filename;

1459

const int epoll_fd=task.epoll_fd;

1460

const int fd=task.fd;

1461

buffer *const password=task.password;

1462

string_set *const cancelled_filenames=task.cancelled_filenames;

1463

bool *const mandos_client_exited = task.mandos_client_exited;

1464

bool *const password_is_read = task.password_is_read;

1465

const mono_microsecs *const current_time = task.current_time;

1466

1467

if(*mandos_client_exited and *password_is_read){

1468

1469

const size_t send_buffer_length = password->length + 2;

1470

char *send_buffer = malloc(send_buffer_length);

1471

if(send_buffer == NULL){

1472

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

1473

} else {

1474

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

1475

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

1476

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

1477

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

1478

" buffer");

1479

}

1480

}

1481

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

1482

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

1483

depending on whether the password entry was successful or

1484

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

1485

your message.

1486

1487

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

1488

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

1489

*/

1490

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

1491

/* Always add an extra NUL */

1492

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

1493

if(password->length > 0){

1494

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

1495

}

1496

errno = 0;

1497

ssize_t ssret = send(fd, send_buffer, send_buffer_length,

1498

MSG_NOSIGNAL);

1499

const error_t saved_errno = errno;

1500

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

1501

explicit_bzero(send_buffer, send_buffer_length);

1502

#else

1503

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

1504

#endif

1505

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

1506

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

1507

}

1508

free(send_buffer);

1509

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

1510

switch(saved_errno){

1511

case EINTR:

1512

case ENOBUFS:

1513

case ENOMEM:

1514

case EADDRINUSE:

1515

case ECONNREFUSED:

1516

case ECONNRESET:

1517

case ENOENT:

1518

case ETOOMANYREFS:

1519

case EAGAIN:

1520

/* Retry, below */

1521

break;

1522

case EMSGSIZE:

1523

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

1524

(uintmax_t)password->length);

1525

#if __GNUC__ < 7

1526

/* FALLTHROUGH */

1527

#else

1528

__attribute__((fallthrough));

1529

#endif

1530

case 0:

1531

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

1532

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

1533

}

1534

#if __GNUC__ < 7

1535

/* FALLTHROUGH */

1536

#else

1537

__attribute__((fallthrough));

1538

#endif

1539

default:

1540

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

1541

filename);

1542

if(not string_set_add(cancelled_filenames,

1543

question_filename)){

1544

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

1545

question_filename);

1546

}

1547

cleanup_task(&task);

1548

return;

1549

}

1550

} else {

1551

/* Success */

1552

cleanup_task(&task);

1553

return;

1554

}

1555

}

1556

}

1557

1558

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

1559

1560

if(not add_to_queue(queue, task)){

1561

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

1562

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

1563

filename);

1564

cleanup_task(&task);

1565

}

1566

1567

/* Add the fd to the epoll set */

1568

if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

1569

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

1570

!= 0){

1571

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

1572

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

1573

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

1574

most one second from now */

1575

if((queue->next_run == 0)

1576

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

1577

queue->next_run = *current_time + 1000000;

1578

}

1579

}

1580

}

1581

1582

__attribute__((warn_unused_result))

1583

bool add_existing_questions(task_queue *const queue,

1584

const int epoll_fd,

1585

buffer *const password,

1586

string_set *cancelled_filenames,

1587

const mono_microsecs *const current_time,

1588

bool *const mandos_client_exited,

1589

bool *const password_is_read,

1590

const char *const dirname){

1591

__attribute__((cleanup(cleanup_string)))

1592

char *dir_pattern = NULL;

1593

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

1594

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

1595

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

1596

dirname);

1597

return false;

1598

}

1599

__attribute__((cleanup(globfree)))

1600

glob_t question_filenames = {};

1601

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

1602

NULL, &question_filenames)){

1603

case GLOB_ABORTED:

1604

default:

1605

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

1606

return false;

1607

case GLOB_NOMATCH:

1608

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

1609

return false;

1610

case GLOB_NOSPACE:

1611

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

1612

" names in %s", dirname);

1613

#if __GNUC__ < 7

1614

/* FALLTHROUGH */

1615

#else

1616

__attribute__((fallthrough));

1617

#endif

1618

case 0:

1619

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

1620

char *const question_filename = strdup(question_filenames

1621

.gl_pathv[i]);

1622

const task_context task = {

1623

.func=open_and_parse_question,

1624

.epoll_fd=epoll_fd,

1625

.question_filename=question_filename,

1626

.filename=question_filename,

1627

.password=password,

1628

.cancelled_filenames=cancelled_filenames,

1629

.current_time=current_time,

1630

.mandos_client_exited=mandos_client_exited,

1631

.password_is_read=password_is_read,

1632

};

1633

1634

if(question_filename == NULL

1635

or not add_to_queue(queue, task)){

1636

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

1637

" file %s to queue",

1638

question_filenames.gl_pathv[i]);

1639

free(question_filename);

1640

} else {

1641

queue->next_run = 1;

1642

}

1643

}

1644

return true;

1645

}

1646

}

1647

1648

__attribute__((nonnull, warn_unused_result))

1649

bool wait_for_event(const int epoll_fd,

1650

const mono_microsecs queue_next_run,

1651

const mono_microsecs current_time){

1652

__attribute__((const))

1653

int milliseconds_to_wait(const mono_microsecs currtime,

1654

const mono_microsecs nextrun){

1655

if(currtime >= nextrun){

1656

return 0;

1657

}

1658

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

1659

if(wait_time_ms > (uintmax_t)INT_MAX){

1660

return INT_MAX;

1661

}

1662

return (int)wait_time_ms;

1663

}

1664

1665

const int wait_time_ms = milliseconds_to_wait(current_time,

1666

queue_next_run);

1667

1668

/* Prepare unblocking of SIGCHLD during epoll_pwait */

1669

sigset_t temporary_unblocked_sigmask;

1670

/* Get current signal mask */

1671

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

1672

return false;

1673

}

1674

/* Remove SIGCHLD from the signal mask */

1675

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

1676

return false;

1677

}

1678

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

1679

int ret = epoll_pwait(epoll_fd, events,

1680

sizeof(events) / sizeof(struct epoll_event),

1681

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

1682

&temporary_unblocked_sigmask);

1683

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

1684

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

1685

" ...", epoll_fd,

1686

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

1687

return false;

1688

}

1689

return clear_all_fds_from_epoll_set(epoll_fd);

1690

}

1691

1692

bool clear_all_fds_from_epoll_set(const int epoll_fd){

1693

/* Create a new empty epoll set */

1694

__attribute__((cleanup(cleanup_close)))

1695

const int new_epoll_fd = epoll_create1(EPOLL_CLOEXEC);

1696

if(new_epoll_fd < 0){

1697

return false;

1698

}

1699

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

1700

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

1701

return false;

1702

}

1703

return true;

1704

}

1705

1706

__attribute__((nonnull, warn_unused_result))

1707

bool run_queue(task_queue **const queue,

1708

string_set *const cancelled_filenames,

1709

bool *const quit_now){

1710

1711

task_queue *new_queue = create_queue();

1712

if(new_queue == NULL){

1713

return false;

1714

}

1715

1716

__attribute__((cleanup(string_set_clear)))

1717

string_set old_cancelled_filenames = {};

1718

string_set_swap(cancelled_filenames, &old_cancelled_filenames);

1719

1720

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

1721

loop in case we aborted in the middle */

1722

size_t i;

1723

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

1724

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

1725

const char *const question_filename = task->question_filename;

1726

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

1727

if(question_filename != NULL

1728

and string_set_contains(old_cancelled_filenames,

1729

question_filename)){

1730

cleanup_task(task);

1731

continue;

1732

}

1733

task->func(*task, new_queue);

1734

}

1735

1736

if(*quit_now){

1737

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

1738

remaining tasks in the current queue */

1739

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

1740

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

1741

}

1742

free_queue(*queue);

1743

*queue = new_queue;

1744

new_queue = NULL;

1745

return false;

1746

}

1747

free_queue(*queue);

1748

*queue = new_queue;

1749

new_queue = NULL;

1750

1751

return true;

1752

}

1753

1754

/* End of regular code section */

1755

1756

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

1757

1758

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

1759

teardown functions */

1760

typedef struct {

1761

struct sigaction orig_sigaction;

1762

sigset_t orig_sigmask;

1763

} test_fixture;

1764

1765

static void test_setup(test_fixture *fixture,

1766

__attribute__((unused))

1767

gconstpointer user_data){

1768

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

1769

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

1770

}

1771

1772

static void test_teardown(test_fixture *fixture,

1773

__attribute__((unused))

1774

gconstpointer user_data){

1775

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

1776

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

1777

}

1778

1779

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

1780

__attribute__((pure, nonnull, warn_unused_result))

1781

static task_context *find_matching_task(const task_queue *const queue,

1782

const task_context task){

1783

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

1784

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

1785

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

1786

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

1787

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

1788

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

1789

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

1790

1791

/* task_func *const func */

1792

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

1793

continue;

1794

}

1795

/* char *const question_filename; */

1796

if(task.question_filename != NULL

1797

and (current_task->question_filename == NULL

1798

or strcmp(current_task->question_filename,

1799

task.question_filename) != 0)){

1800

continue;

1801

}

1802

/* const pid_t pid; */

1803

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

1804

continue;

1805

}

1806

/* const int epoll_fd; */

1807

if(task.epoll_fd != 0

1808

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

1809

continue;

1810

}

1811

/* bool *const quit_now; */

1812

if(task.quit_now != NULL

1813

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

1814

continue;

1815

}

1816

/* const int fd; */

1817

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

1818

continue;

1819

}

1820

/* bool *const mandos_client_exited; */

1821

if(task.mandos_client_exited != NULL

1822

and current_task->mandos_client_exited

1823

!= task.mandos_client_exited){

1824

continue;

1825

}

1826

/* buffer *const password; */

1827

if(task.password != NULL

1828

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

1829

continue;

1830

}

1831

/* bool *const password_is_read; */

1832

if(task.password_is_read != NULL

1833

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

1834

continue;

1835

}

1836

/* char *filename; */

1837

if(task.filename != NULL

1838

and (current_task->filename == NULL

1839

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

1840

continue;

1841

}

1842

/* string_set *const cancelled_filenames; */

1843

if(task.cancelled_filenames != NULL

1844

and current_task->cancelled_filenames

1845

!= task.cancelled_filenames){

1846

continue;

1847

}

1848

/* const mono_microsecs notafter; */

1849

if(task.notafter != 0

1850

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

1851

continue;

1852

}

1853

/* const mono_microsecs *const current_time; */

1854

if(task.current_time != NULL

1855

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

1856

continue;

1857

}

1858

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

1859

return current_task;

1860

}

1861

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

1862

return NULL;

1863

}

1864

1865

static void test_create_queue(__attribute__((unused))

1866

test_fixture *fixture,

1867

__attribute__((unused))

1868

gconstpointer user_data){

1869

__attribute__((cleanup(cleanup_queue)))

1870

task_queue *const queue = create_queue();

1871

g_assert_nonnull(queue);

1872

g_assert_null(queue->tasks);

1873

g_assert_true(queue->length == 0);

1874

g_assert_true(queue->next_run == 0);

1875

}

1876

1877

static task_func dummy_func;

1878

1879

static void test_add_to_queue(__attribute__((unused))

1880

test_fixture *fixture,

1881

__attribute__((unused))

1882

gconstpointer user_data){

1883

__attribute__((cleanup(cleanup_queue)))

1884

task_queue *queue = create_queue();

1885

g_assert_nonnull(queue);

1886

1887

g_assert_true(add_to_queue(queue,

1888

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

1889

g_assert_true(queue->length == 1);

1890

g_assert_nonnull(queue->tasks);

1891

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

1892

}

1893

1894

static void test_add_to_queue_overflow(__attribute__((unused))

1895

test_fixture *fixture,

1896

__attribute__((unused))

1897

gconstpointer user_data){

1898

__attribute__((cleanup(cleanup_queue)))

1899

task_queue *queue = create_queue();

1900

g_assert_nonnull(queue);

1901

g_assert_true(queue->length == 0);

1902

queue->length = SIZE_MAX / sizeof(task_context); /* fake max size */

1903

1904

FILE *real_stderr = stderr;

1905

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

1906

g_assert_nonnull(devnull);

1907

stderr = devnull;

1908

const bool ret = add_to_queue(queue,

1909

(task_context){ .func=dummy_func });

1910

g_assert_true(errno == ENOMEM);

1911

g_assert_false(ret);

1912

stderr = real_stderr;

1913

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

1914

queue->length = 0; /* Restore real size */

1915

}

1916

1917

static void dummy_func(__attribute__((unused))

1918

const task_context task,

1919

__attribute__((unused))

1920

task_queue *const queue){

1921

}

1922

1923

static void test_queue_has_question_empty(__attribute__((unused))

1924

test_fixture *fixture,

1925

__attribute__((unused))

1926

gconstpointer user_data){

1927

__attribute__((cleanup(cleanup_queue)))

1928

task_queue *queue = create_queue();

1929

g_assert_nonnull(queue);

1930

g_assert_false(queue_has_question(queue));

1931

}

1932

1933

static void test_queue_has_question_false(__attribute__((unused))

1934

test_fixture *fixture,

1935

__attribute__((unused))

1936

gconstpointer user_data){

1937

__attribute__((cleanup(cleanup_queue)))

1938

task_queue *queue = create_queue();

1939

g_assert_nonnull(queue);

1940

g_assert_true(add_to_queue(queue,

1941

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

1942

g_assert_false(queue_has_question(queue));

1943

}

1944

1945

static void test_queue_has_question_true(__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

char *const question_filename

1953

= strdup("/nonexistent/question_filename");

1954

g_assert_nonnull(question_filename);

1955

task_context task = {

1956

.func=dummy_func,

1957

.question_filename=question_filename,

1958

};

1959

g_assert_true(add_to_queue(queue, task));

1960

g_assert_true(queue_has_question(queue));

1961

}

1962

1963

static void test_queue_has_question_false2(__attribute__((unused))

1964

test_fixture *fixture,

1965

__attribute__((unused))

1966

gconstpointer user_data){

1967

__attribute__((cleanup(cleanup_queue)))

1968

task_queue *queue = create_queue();

1969

g_assert_nonnull(queue);

1970

task_context task = { .func=dummy_func };

1971

g_assert_true(add_to_queue(queue, task));

1972

g_assert_true(add_to_queue(queue, task));

1973

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

1974

g_assert_false(queue_has_question(queue));

1975

}

1976

1977

static void test_queue_has_question_true2(__attribute__((unused))

1978

test_fixture *fixture,

1979

__attribute__((unused))

1980

gconstpointer user_data){

1981

__attribute__((cleanup(cleanup_queue)))

1982

task_queue *queue = create_queue();

1983

g_assert_nonnull(queue);

1984

task_context task1 = { .func=dummy_func };

1985

g_assert_true(add_to_queue(queue, task1));

1986

char *const question_filename

1987

= strdup("/nonexistent/question_filename");

1988

g_assert_nonnull(question_filename);

1989

task_context task2 = {

1990

.func=dummy_func,

1991

.question_filename=question_filename,

1992

};

1993

g_assert_true(add_to_queue(queue, task2));

1994

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

1995

g_assert_true(queue_has_question(queue));

1996

}

1997

1998

static void test_cleanup_buffer(__attribute__((unused))

1999

test_fixture *fixture,

2000

__attribute__((unused))

2001

gconstpointer user_data){

2002

buffer buf = {};

2003

2004

const size_t buffersize = 10;

2005

2006

buf.data = malloc(buffersize);

2007

g_assert_nonnull(buf.data);

2008

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

2009

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

2010

}

2011

2012

cleanup_buffer(&buf);

2013

g_assert_null(buf.data);

2014

}

2015

2016

static

2017

void test_string_set_new_set_contains_nothing(__attribute__((unused))

2018

test_fixture *fixture,

2019

__attribute__((unused))

2020

gconstpointer

2021

user_data){

2022

__attribute__((cleanup(string_set_clear)))

2023

string_set set = {};

2024

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

2025

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

2026

}

2027

2028

static void

2029

test_string_set_with_added_string_contains_it(__attribute__((unused))

2030

test_fixture *fixture,

2031

__attribute__((unused))

2032

gconstpointer

2033

user_data){

2034

__attribute__((cleanup(string_set_clear)))

2035

string_set set = {};

2036

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

2037

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

2038

}

2039

2040

static void

2041

test_string_set_cleared_does_not_contain_str(__attribute__((unused))

2042

test_fixture *fixture,

2043

__attribute__((unused))

2044

gconstpointer user_data){

2045

__attribute__((cleanup(string_set_clear)))

2046

string_set set = {};

2047

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

2048

string_set_clear(&set);

2049

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

2050

}

2051

2052

static

2053

void test_string_set_swap_one_with_empty(__attribute__((unused))

2054

test_fixture *fixture,

2055

__attribute__((unused))

2056

gconstpointer user_data){

2057

__attribute__((cleanup(string_set_clear)))

2058

string_set set1 = {};

2059

__attribute__((cleanup(string_set_clear)))

2060

string_set set2 = {};

2061

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

2062

string_set_swap(&set1, &set2);

2063

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

2064

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

2065

}

2066

2067

static

2068

void test_string_set_swap_empty_with_one(__attribute__((unused))

2069

test_fixture *fixture,

2070

__attribute__((unused))

2071

gconstpointer user_data){

2072

__attribute__((cleanup(string_set_clear)))

2073

string_set set1 = {};

2074

__attribute__((cleanup(string_set_clear)))

2075

string_set set2 = {};

2076

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

2077

string_set_swap(&set1, &set2);

2078

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

2079

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

2080

}

2081

2082

static void test_string_set_swap_one_with_one(__attribute__((unused))

2083

test_fixture *fixture,

2084

__attribute__((unused))

2085

gconstpointer

2086

user_data){

2087

__attribute__((cleanup(string_set_clear)))

2088

string_set set1 = {};

2089

__attribute__((cleanup(string_set_clear)))

2090

string_set set2 = {};

2091

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

2092

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

2093

string_set_swap(&set1, &set2);

2094

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

2095

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

2096

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

2097

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

2098

}

2099

2100

static bool fd_has_cloexec_and_nonblock(const int);

2101

2102

static bool epoll_set_contains(int, int, uint32_t);

2103

2104

static void test_start_mandos_client(test_fixture *fixture,

2105

__attribute__((unused))

2106

gconstpointer user_data){

2107

2108

bool mandos_client_exited = false;

2109

bool quit_now = false;

2110

__attribute__((cleanup(cleanup_close)))

2111

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2112

g_assert_cmpint(epoll_fd, >=, 0);

2113

__attribute__((cleanup(cleanup_queue)))

2114

task_queue *queue = create_queue();

2115

g_assert_nonnull(queue);

2116

buffer password = {};

2117

bool password_is_read = false;

2118

const char helper_directory[] = "/nonexistent";

2119

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

2120

2121

g_assert_true(start_mandos_client(queue, epoll_fd,

2122

&mandos_client_exited, &quit_now,

2123

&password, &password_is_read,

2124

&fixture->orig_sigaction,

2125

fixture->orig_sigmask,

2126

helper_directory, 0, 0, argv));

2127

2128

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

2129

2130

const task_context *const added_wait_task

2131

= find_matching_task(queue, (task_context){

2132

.func=wait_for_mandos_client_exit,

2133

.mandos_client_exited=&mandos_client_exited,

2134

.quit_now=&quit_now,

2135

});

2136

g_assert_nonnull(added_wait_task);

2137

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

2138

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

2139

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

2140

2141

const task_context *const added_read_task

2142

= find_matching_task(queue, (task_context){

2143

.func=read_mandos_client_output,

2144

.epoll_fd=epoll_fd,

2145

.password=&password,

2146

.password_is_read=&password_is_read,

2147

.quit_now=&quit_now,

2148

});

2149

g_assert_nonnull(added_read_task);

2150

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

2151

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

2152

g_assert_true(epoll_set_contains(epoll_fd, added_read_task->fd,

2153

EPOLLIN | EPOLLRDHUP));

2154

}

2155

2156

static bool fd_has_cloexec_and_nonblock(const int fd){

2157

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

2158

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

2159

return ((socket_fd_flags >= 0)

2160

and (socket_fd_flags & FD_CLOEXEC)

2161

and (socket_file_flags >= 0)

2162

and (socket_file_flags & O_NONBLOCK));

2163

}

2164

2165

__attribute__((const))

2166

bool is_privileged(void){

2167

uid_t user = getuid() + 1;

2168

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

2169

user++;

2170

}

2171

gid_t group = getuid() + 1;

2172

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

2173

group++;

2174

}

2175

const pid_t pid = fork();

2176

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

2177

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

2178

if(errno != EPERM){

2179

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

2180

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

2181

}

2182

exit(EXIT_FAILURE);

2183

}

2184

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

2185

if(errno != EPERM){

2186

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

2187

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

2188

}

2189

exit(EXIT_FAILURE);

2190

}

2191

exit(EXIT_SUCCESS);

2192

}

2193

int status;

2194

waitpid(pid, &status, 0);

2195

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

2196

return true;

2197

}

2198

return false;

2199

}

2200

2201

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

2202

/* Only scan for events in this eventmask */

2203

const uint32_t eventmask = EPOLLIN | EPOLLOUT | EPOLLRDHUP;

2204

__attribute__((cleanup(cleanup_string)))

2205

char *fdinfo_name = NULL;

2206

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

2207

g_assert_cmpint(ret, >, 0);

2208

g_assert_nonnull(fdinfo_name);

2209

2210

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

2211

g_assert_nonnull(fdinfo);

2212

uint32_t reported_events;

2213

buffer line = {};

2214

int found_fd = -1;

2215

2216

do {

2217

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

2218

break;

2219

}

2220

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

2221

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

2222

&found_fd, &reported_events) == 2){

2223

if(found_fd == fd){

2224

break;

2225

}

2226

}

2227

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

2228

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

2229

free(line.data);

2230

if(found_fd != fd){

2231

return false;

2232

}

2233

2234

if(events == 0){

2235

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

2236

return true;

2237

}

2238

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

2239

}

2240

2241

static void test_start_mandos_client_execv(test_fixture *fixture,

2242

__attribute__((unused))

2243

gconstpointer user_data){

2244

bool mandos_client_exited = false;

2245

bool quit_now = false;

2246

__attribute__((cleanup(cleanup_close)))

2247

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2248

g_assert_cmpint(epoll_fd, >=, 0);

2249

__attribute__((cleanup(cleanup_queue)))

2250

task_queue *queue = create_queue();

2251

g_assert_nonnull(queue);

2252

__attribute__((cleanup(cleanup_buffer)))

2253

buffer password = {};

2254

const char helper_directory[] = "/nonexistent";

2255

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

2256

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

2257

2258

{

2259

__attribute__((cleanup(cleanup_close)))

2260

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

2261

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2262

g_assert_cmpint(devnull_fd, >=, 0);

2263

__attribute__((cleanup(cleanup_close)))

2264

const int real_stderr_fd = dup(STDERR_FILENO);

2265

g_assert_cmpint(real_stderr_fd, >=, 0);

2266

dup2(devnull_fd, STDERR_FILENO);

2267

2268

const bool success = start_mandos_client(queue, epoll_fd,

2269

&mandos_client_exited,

2270

&quit_now,

2271

&password,

2272

(bool[]){false},

2273

&fixture->orig_sigaction,

2274

fixture->orig_sigmask,

2275

helper_directory, 0, 0,

2276

argv);

2277

dup2(real_stderr_fd, STDERR_FILENO);

2278

g_assert_true(success);

2279

}

2280

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

2281

2282

struct timespec starttime, currtime;

2283

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

2284

do {

2285

queue->next_run = 0;

2286

string_set cancelled_filenames = {};

2287

2288

{

2289

__attribute__((cleanup(cleanup_close)))

2290

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

2291

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2292

g_assert_cmpint(devnull_fd, >=, 0);

2293

__attribute__((cleanup(cleanup_close)))

2294

const int real_stderr_fd = dup(STDERR_FILENO);

2295

g_assert_cmpint(real_stderr_fd, >=, 0);

2296

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

2297

dup2(devnull_fd, STDERR_FILENO);

2298

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

2299

&quit_now);

2300

dup2(real_stderr_fd, STDERR_FILENO);

2301

if(not success){

2302

break;

2303

}

2304

}

2305

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

2306

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

2307

and (not quit_now)

2308

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

2309

2310

g_assert_true(quit_now);

2311

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

2312

g_assert_true(mandos_client_exited);

2313

}

2314

2315

static void test_start_mandos_client_suid_euid(test_fixture *fixture,

2316

__attribute__((unused))

2317

gconstpointer

2318

user_data){

2319

if(not is_privileged()){

2320

g_test_skip("Not privileged");

2321

return;

2322

}

2323

2324

bool mandos_client_exited = false;

2325

bool quit_now = false;

2326

__attribute__((cleanup(cleanup_close)))

2327

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2328

g_assert_cmpint(epoll_fd, >=, 0);

2329

__attribute__((cleanup(cleanup_queue)))

2330

task_queue *queue = create_queue();

2331

g_assert_nonnull(queue);

2332

__attribute__((cleanup(cleanup_buffer)))

2333

buffer password = {};

2334

bool password_is_read = false;

2335

const char helper_directory[] = "/nonexistent";

2336

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

2337

uid_t user = 1000;

2338

gid_t group = 1001;

2339

2340

const bool success = start_mandos_client(queue, epoll_fd,

2341

&mandos_client_exited,

2342

&quit_now, &password,

2343

&password_is_read,

2344

&fixture->orig_sigaction,

2345

fixture->orig_sigmask,

2346

helper_directory, user,

2347

group, argv);

2348

g_assert_true(success);

2349

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

2350

2351

struct timespec starttime, currtime;

2352

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

2353

do {

2354

queue->next_run = 0;

2355

string_set cancelled_filenames = {};

2356

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

2357

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

2358

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

2359

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

2360

and (not quit_now)

2361

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

2362

2363

g_assert_false(quit_now);

2364

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

2365

g_assert_true(mandos_client_exited);

2366

2367

g_assert_true(password_is_read);

2368

g_assert_nonnull(password.data);

2369

2370

uintmax_t id;

2371

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

2372

==, 1);

2373

g_assert_true((uid_t)id == id);

2374

2375

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

2376

}

2377

2378

static void test_start_mandos_client_suid_egid(test_fixture *fixture,

2379

__attribute__((unused))

2380

gconstpointer

2381

user_data){

2382

if(not is_privileged()){

2383

g_test_skip("Not privileged");

2384

return;

2385

}

2386

2387

bool mandos_client_exited = false;

2388

bool quit_now = false;

2389

__attribute__((cleanup(cleanup_close)))

2390

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2391

g_assert_cmpint(epoll_fd, >=, 0);

2392

__attribute__((cleanup(cleanup_queue)))

2393

task_queue *queue = create_queue();

2394

g_assert_nonnull(queue);

2395

__attribute__((cleanup(cleanup_buffer)))

2396

buffer password = {};

2397

bool password_is_read = false;

2398

const char helper_directory[] = "/nonexistent";

2399

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

2400

uid_t user = 1000;

2401

gid_t group = 1001;

2402

2403

const bool success = start_mandos_client(queue, epoll_fd,

2404

&mandos_client_exited,

2405

&quit_now, &password,

2406

&password_is_read,

2407

&fixture->orig_sigaction,

2408

fixture->orig_sigmask,

2409

helper_directory, user,

2410

group, argv);

2411

g_assert_true(success);

2412

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

2413

2414

struct timespec starttime, currtime;

2415

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

2416

do {

2417

queue->next_run = 0;

2418

string_set cancelled_filenames = {};

2419

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

2420

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

2421

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

2422

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

2423

and (not quit_now)

2424

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

2425

2426

g_assert_false(quit_now);

2427

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

2428

g_assert_true(mandos_client_exited);

2429

2430

g_assert_true(password_is_read);

2431

g_assert_nonnull(password.data);

2432

2433

uintmax_t id;

2434

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

2435

==, 1);

2436

g_assert_true((gid_t)id == id);

2437

2438

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

2439

}

2440

2441

static void test_start_mandos_client_suid_ruid(test_fixture *fixture,

2442

__attribute__((unused))

2443

gconstpointer

2444

user_data){

2445

if(not is_privileged()){

2446

g_test_skip("Not privileged");

2447

return;

2448

}

2449

2450

bool mandos_client_exited = false;

2451

bool quit_now = false;

2452

__attribute__((cleanup(cleanup_close)))

2453

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2454

g_assert_cmpint(epoll_fd, >=, 0);

2455

__attribute__((cleanup(cleanup_queue)))

2456

task_queue *queue = create_queue();

2457

g_assert_nonnull(queue);

2458

__attribute__((cleanup(cleanup_buffer)))

2459

buffer password = {};

2460

bool password_is_read = false;

2461

const char helper_directory[] = "/nonexistent";

2462

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

2463

NULL };

2464

uid_t user = 1000;

2465

gid_t group = 1001;

2466

2467

const bool success = start_mandos_client(queue, epoll_fd,

2468

&mandos_client_exited,

2469

&quit_now, &password,

2470

&password_is_read,

2471

&fixture->orig_sigaction,

2472

fixture->orig_sigmask,

2473

helper_directory, user,

2474

group, argv);

2475

g_assert_true(success);

2476

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

2477

2478

struct timespec starttime, currtime;

2479

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

2480

do {

2481

queue->next_run = 0;

2482

string_set cancelled_filenames = {};

2483

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

2484

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

2485

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

2486

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

2487

and (not quit_now)

2488

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

2489

2490

g_assert_false(quit_now);

2491

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

2492

g_assert_true(mandos_client_exited);

2493

2494

g_assert_true(password_is_read);

2495

g_assert_nonnull(password.data);

2496

2497

uintmax_t id;

2498

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

2499

==, 1);

2500

g_assert_true((uid_t)id == id);

2501

2502

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

2503

}

2504

2505

static void test_start_mandos_client_suid_rgid(test_fixture *fixture,

2506

__attribute__((unused))

2507

gconstpointer

2508

user_data){

2509

if(not is_privileged()){

2510

g_test_skip("Not privileged");

2511

return;

2512

}

2513

2514

bool mandos_client_exited = false;

2515

bool quit_now = false;

2516

__attribute__((cleanup(cleanup_close)))

2517

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2518

g_assert_cmpint(epoll_fd, >=, 0);

2519

__attribute__((cleanup(cleanup_queue)))

2520

task_queue *queue = create_queue();

2521

g_assert_nonnull(queue);

2522

__attribute__((cleanup(cleanup_buffer)))

2523

buffer password = {};

2524

bool password_is_read = false;

2525

const char helper_directory[] = "/nonexistent";

2526

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

2527

NULL };

2528

uid_t user = 1000;

2529

gid_t group = 1001;

2530

2531

const bool success = start_mandos_client(queue, epoll_fd,

2532

&mandos_client_exited,

2533

&quit_now, &password,

2534

&password_is_read,

2535

&fixture->orig_sigaction,

2536

fixture->orig_sigmask,

2537

helper_directory, user,

2538

group, argv);

2539

g_assert_true(success);

2540

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

2541

2542

struct timespec starttime, currtime;

2543

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

2544

do {

2545

queue->next_run = 0;

2546

string_set cancelled_filenames = {};

2547

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

2548

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

2549

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

2550

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

2551

and (not quit_now)

2552

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

2553

2554

g_assert_false(quit_now);

2555

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

2556

g_assert_true(mandos_client_exited);

2557

2558

g_assert_true(password_is_read);

2559

g_assert_nonnull(password.data);

2560

2561

uintmax_t id;

2562

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

2563

==, 1);

2564

g_assert_true((gid_t)id == id);

2565

2566

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

2567

}

2568

2569

static void test_start_mandos_client_read(test_fixture *fixture,

2570

__attribute__((unused))

2571

gconstpointer user_data){

2572

bool mandos_client_exited = false;

2573

bool quit_now = false;

2574

__attribute__((cleanup(cleanup_close)))

2575

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2576

g_assert_cmpint(epoll_fd, >=, 0);

2577

__attribute__((cleanup(cleanup_queue)))

2578

task_queue *queue = create_queue();

2579

g_assert_nonnull(queue);

2580

__attribute__((cleanup(cleanup_buffer)))

2581

buffer password = {};

2582

bool password_is_read = false;

2583

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

2584

const char helper_directory[] = "/nonexistent";

2585

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

2586

NULL };

2587

2588

const bool success = start_mandos_client(queue, epoll_fd,

2589

&mandos_client_exited,

2590

&quit_now, &password,

2591

&password_is_read,

2592

&fixture->orig_sigaction,

2593

fixture->orig_sigmask,

2594

helper_directory, 0, 0,

2595

argv);

2596

g_assert_true(success);

2597

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

2598

2599

struct timespec starttime, currtime;

2600

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

2601

do {

2602

queue->next_run = 0;

2603

string_set cancelled_filenames = {};

2604

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

2605

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

2606

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

2607

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

2608

and (not quit_now)

2609

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

2610

2611

g_assert_false(quit_now);

2612

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

2613

g_assert_true(mandos_client_exited);

2614

2615

g_assert_true(password_is_read);

2616

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

2617

sizeof(dummy_test_password)-1);

2618

g_assert_nonnull(password.data);

2619

g_assert_cmpint(memcmp(dummy_test_password, password.data,

2620

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

2621

}

2622

2623

static

2624

void test_start_mandos_client_helper_directory(test_fixture *fixture,

2625

__attribute__((unused))

2626

gconstpointer

2627

user_data){

2628

bool mandos_client_exited = false;

2629

bool quit_now = false;

2630

__attribute__((cleanup(cleanup_close)))

2631

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2632

g_assert_cmpint(epoll_fd, >=, 0);

2633

__attribute__((cleanup(cleanup_queue)))

2634

task_queue *queue = create_queue();

2635

g_assert_nonnull(queue);

2636

__attribute__((cleanup(cleanup_buffer)))

2637

buffer password = {};

2638

bool password_is_read = false;

2639

const char helper_directory[] = "/nonexistent";

2640

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

2641

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

2642

2643

const bool success = start_mandos_client(queue, epoll_fd,

2644

&mandos_client_exited,

2645

&quit_now, &password,

2646

&password_is_read,

2647

&fixture->orig_sigaction,

2648

fixture->orig_sigmask,

2649

helper_directory, 0, 0,

2650

argv);

2651

g_assert_true(success);

2652

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

2653

2654

struct timespec starttime, currtime;

2655

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

2656

do {

2657

queue->next_run = 0;

2658

string_set cancelled_filenames = {};

2659

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

2660

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

2661

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

2662

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

2663

and (not quit_now)

2664

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

2665

2666

g_assert_false(quit_now);

2667

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

2668

g_assert_true(mandos_client_exited);

2669

2670

g_assert_true(password_is_read);

2671

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

2672

sizeof(helper_directory)-1);

2673

g_assert_nonnull(password.data);

2674

g_assert_cmpint(memcmp(helper_directory, password.data,

2675

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

2676

}

2677

2678

__attribute__((nonnull, warn_unused_result))

2679

static bool proc_status_sigblk_to_sigset(const char *const,

2680

sigset_t *const);

2681

2682

static void test_start_mandos_client_sigmask(test_fixture *fixture,

2683

__attribute__((unused))

2684

gconstpointer user_data){

2685

bool mandos_client_exited = false;

2686

bool quit_now = false;

2687

__attribute__((cleanup(cleanup_close)))

2688

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2689

g_assert_cmpint(epoll_fd, >=, 0);

2690

__attribute__((cleanup(cleanup_queue)))

2691

task_queue *queue = create_queue();

2692

g_assert_nonnull(queue);

2693

__attribute__((cleanup(cleanup_buffer)))

2694

buffer password = {};

2695

bool password_is_read = false;

2696

const char helper_directory[] = "/nonexistent";

2697

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

2698

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

2699

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

2700

2701

g_assert_true(start_mandos_client(queue, epoll_fd,

2702

&mandos_client_exited, &quit_now,

2703

&password, &password_is_read,

2704

&fixture->orig_sigaction,

2705

fixture->orig_sigmask,

2706

helper_directory, 0, 0, argv));

2707

2708

struct timespec starttime, currtime;

2709

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

2710

do {

2711

queue->next_run = 0;

2712

string_set cancelled_filenames = {};

2713

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

2714

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

2715

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

2716

} while((not (mandos_client_exited and password_is_read))

2717

and (not quit_now)

2718

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

2719

g_assert_true(mandos_client_exited);

2720

g_assert_true(password_is_read);

2721

2722

sigset_t parsed_sigmask;

2723

g_assert_true(proc_status_sigblk_to_sigset(password.data,

2724

&parsed_sigmask));

2725

2726

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

2727

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

2728

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

2729

g_assert_true(has_signal);

2730

} else {

2731

g_assert_false(has_signal);

2732

}

2733

}

2734

}

2735

2736

__attribute__((nonnull, warn_unused_result))

2737

static bool proc_status_sigblk_to_sigset(const char *const sigblk,

2738

sigset_t *const sigmask){

2739

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

2740

uintmax_t scanned_sigmask;

2741

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

2742

return false;

2743

}

2744

if(sigemptyset(sigmask) != 0){

2745

return false;

2746

}

2747

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

2748

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

2749

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

2750

return false;

2751

}

2752

}

2753

}

2754

return true;

2755

}

2756

2757

static void run_task_with_stderr_to_dev_null(const task_context task,

2758

task_queue *const queue);

2759

2760

static

2761

void test_wait_for_mandos_client_exit_badpid(__attribute__((unused))

2762

test_fixture *fixture,

2763

__attribute__((unused))

2764

gconstpointer user_data){

2765

2766

bool mandos_client_exited = false;

2767

bool quit_now = false;

2768

2769

__attribute__((cleanup(cleanup_queue)))

2770

task_queue *queue = create_queue();

2771

g_assert_nonnull(queue);

2772

const task_context task = {

2773

.func=wait_for_mandos_client_exit,

2774

.pid=1,

2775

.mandos_client_exited=&mandos_client_exited,

2776

.quit_now=&quit_now,

2777

};

2778

run_task_with_stderr_to_dev_null(task, queue);

2779

2780

g_assert_false(mandos_client_exited);

2781

g_assert_true(quit_now);

2782

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

2783

}

2784

2785

static void run_task_with_stderr_to_dev_null(const task_context task,

2786

task_queue *const queue){

2787

FILE *real_stderr = stderr;

2788

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

2789

g_assert_nonnull(devnull);

2790

2791

stderr = devnull;

2792

task.func(task, queue);

2793

stderr = real_stderr;

2794

2795

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

2796

}

2797

2798

static

2799

void test_wait_for_mandos_client_exit_noexit(test_fixture *fixture,

2800

__attribute__((unused))

2801

gconstpointer user_data){

2802

bool mandos_client_exited = false;

2803

bool quit_now = false;

2804

2805

pid_t create_eternal_process(void){

2806

const pid_t pid = fork();

2807

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

2808

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

2809

_exit(EXIT_FAILURE);

2810

}

2811

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

2812

_exit(EXIT_FAILURE);

2813

}

2814

while(true){

2815

pause();

2816

}

2817

}

2818

return pid;

2819

}

2820

pid_t pid = create_eternal_process();

2821

g_assert_true(pid != -1);

2822

2823

__attribute__((cleanup(cleanup_queue)))

2824

task_queue *queue = create_queue();

2825

g_assert_nonnull(queue);

2826

const task_context task = {

2827

.func=wait_for_mandos_client_exit,

2828

.pid=pid,

2829

.mandos_client_exited=&mandos_client_exited,

2830

.quit_now=&quit_now,

2831

};

2832

task.func(task, queue);

2833

2834

g_assert_false(mandos_client_exited);

2835

g_assert_false(quit_now);

2836

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

2837

2838

g_assert_nonnull(find_matching_task(queue, (task_context){

2839

.func=wait_for_mandos_client_exit,

2840

.pid=task.pid,

2841

.mandos_client_exited=&mandos_client_exited,

2842

.quit_now=&quit_now,

2843

}));

2844

}

2845

2846

static

2847

void test_wait_for_mandos_client_exit_success(test_fixture *fixture,

2848

__attribute__((unused))

2849

gconstpointer

2850

user_data){

2851

bool mandos_client_exited = false;

2852

bool quit_now = false;

2853

2854

pid_t create_successful_process(void){

2855

const pid_t pid = fork();

2856

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

2857

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

2858

_exit(EXIT_FAILURE);

2859

}

2860

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

2861

_exit(EXIT_FAILURE);

2862

}

2863

exit(EXIT_SUCCESS);

2864

}

2865

return pid;

2866

}

2867

const pid_t pid = create_successful_process();

2868

g_assert_true(pid != -1);

2869

2870

__attribute__((cleanup(cleanup_queue)))

2871

task_queue *queue = create_queue();

2872

g_assert_nonnull(queue);

2873

const task_context initial_task = {

2874

.func=wait_for_mandos_client_exit,

2875

.pid=pid,

2876

.mandos_client_exited=&mandos_client_exited,

2877

.quit_now=&quit_now,

2878

};

2879

g_assert_true(add_to_queue(queue, initial_task));

2880

2881

struct timespec starttime, currtime;

2882

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

2883

__attribute__((cleanup(cleanup_close)))

2884

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2885

do {

2886

queue->next_run = 0;

2887

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

2888

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

2889

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

2890

} while((not mandos_client_exited)

2891

and (not quit_now)

2892

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

2893

2894

g_assert_true(mandos_client_exited);

2895

g_assert_false(quit_now);

2896

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

2897

}

2898

2899

static

2900

void test_wait_for_mandos_client_exit_failure(test_fixture *fixture,

2901

__attribute__((unused))

2902

gconstpointer

2903

user_data){

2904

bool mandos_client_exited = false;

2905

bool quit_now = false;

2906

2907

pid_t create_failing_process(void){

2908

const pid_t pid = fork();

2909

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

2910

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

2911

_exit(EXIT_FAILURE);

2912

}

2913

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

2914

_exit(EXIT_FAILURE);

2915

}

2916

exit(EXIT_FAILURE);

2917

}

2918

return pid;

2919

}

2920

const pid_t pid = create_failing_process();

2921

g_assert_true(pid != -1);

2922

2923

__attribute__((cleanup(string_set_clear)))

2924

string_set cancelled_filenames = {};

2925

__attribute__((cleanup(cleanup_close)))

2926

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2927

g_assert_cmpint(epoll_fd, >=, 0);

2928

__attribute__((cleanup(cleanup_queue)))

2929

task_queue *queue = create_queue();

2930

g_assert_nonnull(queue);

2931

g_assert_true(add_to_queue(queue, (task_context){

2932

.func=wait_for_mandos_client_exit,

2933

.pid=pid,

2934

.mandos_client_exited=&mandos_client_exited,

2935

.quit_now=&quit_now,

2936

}));

2937

2938

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

2939

2940

__attribute__((cleanup(cleanup_close)))

2941

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

2942

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2943

g_assert_cmpint(devnull_fd, >=, 0);

2944

__attribute__((cleanup(cleanup_close)))

2945

const int real_stderr_fd = dup(STDERR_FILENO);

2946

g_assert_cmpint(real_stderr_fd, >=, 0);

2947

2948

struct timespec starttime, currtime;

2949

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

2950

do {

2951

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

2952

dup2(devnull_fd, STDERR_FILENO);

2953

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

2954

&quit_now);

2955

dup2(real_stderr_fd, STDERR_FILENO);

2956

if(not success){

2957

break;

2958

}

2959

2960

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

2961

} while((not mandos_client_exited)

2962

and (not quit_now)

2963

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

2964

2965

g_assert_true(quit_now);

2966

g_assert_true(mandos_client_exited);

2967

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

2968

}

2969

2970

static

2971

void test_wait_for_mandos_client_exit_killed(test_fixture *fixture,

2972

__attribute__((unused))

2973

gconstpointer user_data){

2974

bool mandos_client_exited = false;

2975

bool quit_now = false;

2976

2977

pid_t create_killed_process(void){

2978

const pid_t pid = fork();

2979

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

2980

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

2981

_exit(EXIT_FAILURE);

2982

}

2983

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

2984

_exit(EXIT_FAILURE);

2985

}

2986

while(true){

2987

pause();

2988

}

2989

}

2990

kill(pid, SIGKILL);

2991

return pid;

2992

}

2993

const pid_t pid = create_killed_process();

2994

g_assert_true(pid != -1);

2995

2996

__attribute__((cleanup(string_set_clear)))

2997

string_set cancelled_filenames = {};

2998

__attribute__((cleanup(cleanup_close)))

2999

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3000

g_assert_cmpint(epoll_fd, >=, 0);

3001

__attribute__((cleanup(cleanup_queue)))

3002

task_queue *queue = create_queue();

3003

g_assert_nonnull(queue);

3004

g_assert_true(add_to_queue(queue, (task_context){

3005

.func=wait_for_mandos_client_exit,

3006

.pid=pid,

3007

.mandos_client_exited=&mandos_client_exited,

3008

.quit_now=&quit_now,

3009

}));

3010

3011

__attribute__((cleanup(cleanup_close)))

3012

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

3013

O_WRONLY | O_CLOEXEC, O_NOCTTY);

3014

g_assert_cmpint(devnull_fd, >=, 0);

3015

__attribute__((cleanup(cleanup_close)))

3016

const int real_stderr_fd = dup(STDERR_FILENO);

3017

g_assert_cmpint(real_stderr_fd, >=, 0);

3018

3019

struct timespec starttime, currtime;

3020

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

3021

do {

3022

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

3023

dup2(devnull_fd, STDERR_FILENO);

3024

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

3025

&quit_now);

3026

dup2(real_stderr_fd, STDERR_FILENO);

3027

if(not success){

3028

break;

3029

}

3030

3031

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

3032

} while((not mandos_client_exited)

3033

and (not quit_now)

3034

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

3035

3036

g_assert_true(mandos_client_exited);

3037

g_assert_true(quit_now);

3038

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

3039

}

3040

3041

static bool epoll_set_does_not_contain(int, int);

3042

3043

static

3044

void test_read_mandos_client_output_readerror(__attribute__((unused))

3045

test_fixture *fixture,

3046

__attribute__((unused))

3047

gconstpointer

3048

user_data){

3049

__attribute__((cleanup(cleanup_close)))

3050

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3051

g_assert_cmpint(epoll_fd, >=, 0);

3052

3053

__attribute__((cleanup(cleanup_buffer)))

3054

buffer password = {};

3055

3056

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

3057

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

3058

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3059

3060

bool password_is_read = false;

3061

bool quit_now = false;

3062

__attribute__((cleanup(cleanup_queue)))

3063

task_queue *queue = create_queue();

3064

g_assert_nonnull(queue);

3065

3066

task_context task = {

3067

.func=read_mandos_client_output,

3068

.epoll_fd=epoll_fd,

3069

.fd=fd,

3070

.password=&password,

3071

.password_is_read=&password_is_read,

3072

.quit_now=&quit_now,

3073

};

3074

run_task_with_stderr_to_dev_null(task, queue);

3075

g_assert_false(password_is_read);

3076

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

3077

g_assert_true(quit_now);

3078

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

3079

3080

g_assert_true(epoll_set_does_not_contain(epoll_fd, fd));

3081

3082

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

3083

}

3084

3085

static bool epoll_set_does_not_contain(int epoll_fd, int fd){

3086

return not epoll_set_contains(epoll_fd, fd, 0);

3087

}

3088

3089

static

3090

void test_read_mandos_client_output_nodata(__attribute__((unused))

3091

test_fixture *fixture,

3092

__attribute__((unused))

3093

gconstpointer user_data){

3094

__attribute__((cleanup(cleanup_close)))

3095

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3096

g_assert_cmpint(epoll_fd, >=, 0);

3097

3098

int pipefds[2];

3099

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

3100

3101

__attribute__((cleanup(cleanup_buffer)))

3102

buffer password = {};

3103

3104

bool password_is_read = false;

3105

bool quit_now = false;

3106

__attribute__((cleanup(cleanup_queue)))

3107

task_queue *queue = create_queue();

3108

g_assert_nonnull(queue);

3109

3110

task_context task = {

3111

.func=read_mandos_client_output,

3112

.epoll_fd=epoll_fd,

3113

.fd=pipefds[0],

3114

.password=&password,

3115

.password_is_read=&password_is_read,

3116

.quit_now=&quit_now,

3117

};

3118

task.func(task, queue);

3119

g_assert_false(password_is_read);

3120

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

3121

g_assert_false(quit_now);

3122

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

3123

3124

g_assert_nonnull(find_matching_task(queue, (task_context){

3125

.func=read_mandos_client_output,

3126

.epoll_fd=epoll_fd,

3127

.fd=pipefds[0],

3128

.password=&password,

3129

.password_is_read=&password_is_read,

3130

.quit_now=&quit_now,

3131

}));

3132

3133

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3134

EPOLLIN | EPOLLRDHUP));

3135

3136

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

3137

}

3138

3139

static void test_read_mandos_client_output_eof(__attribute__((unused))

3140

test_fixture *fixture,

3141

__attribute__((unused))

3142

gconstpointer

3143

user_data){

3144

__attribute__((cleanup(cleanup_close)))

3145

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3146

g_assert_cmpint(epoll_fd, >=, 0);

3147

3148

int pipefds[2];

3149

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

3150

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

3151

3152

__attribute__((cleanup(cleanup_buffer)))

3153

buffer password = {};

3154

3155

bool password_is_read = false;

3156

bool quit_now = false;

3157

__attribute__((cleanup(cleanup_queue)))

3158

task_queue *queue = create_queue();

3159

g_assert_nonnull(queue);

3160

3161

task_context task = {

3162

.func=read_mandos_client_output,

3163

.epoll_fd=epoll_fd,

3164

.fd=pipefds[0],

3165

.password=&password,

3166

.password_is_read=&password_is_read,

3167

.quit_now=&quit_now,

3168

};

3169

task.func(task, queue);

3170

g_assert_true(password_is_read);

3171

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

3172

g_assert_false(quit_now);

3173

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

3174

3175

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

3176

3177

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

3178

}

3179

3180

static

3181

void test_read_mandos_client_output_once(__attribute__((unused))

3182

test_fixture *fixture,

3183

__attribute__((unused))

3184

gconstpointer user_data){

3185

__attribute__((cleanup(cleanup_close)))

3186

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3187

g_assert_cmpint(epoll_fd, >=, 0);

3188

3189

int pipefds[2];

3190

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

3191

3192

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

3193

/* Start with a pre-allocated buffer */

3194

__attribute__((cleanup(cleanup_buffer)))

3195

buffer password = {

3196

.data=malloc(sizeof(dummy_test_password)),

3197

.length=0,

3198

.allocated=sizeof(dummy_test_password),

3199

};

3200

g_assert_nonnull(password.data);

3201

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

3202

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

3203

}

3204

3205

bool password_is_read = false;

3206

bool quit_now = false;

3207

__attribute__((cleanup(cleanup_queue)))

3208

task_queue *queue = create_queue();

3209

g_assert_nonnull(queue);

3210

3211

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3212

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

3213

sizeof(dummy_test_password)),

3214

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

3215

3216

task_context task = {

3217

.func=read_mandos_client_output,

3218

.epoll_fd=epoll_fd,

3219

.fd=pipefds[0],

3220

.password=&password,

3221

.password_is_read=&password_is_read,

3222

.quit_now=&quit_now,

3223

};

3224

task.func(task, queue);

3225

3226

g_assert_false(password_is_read);

3227

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

3228

(int)sizeof(dummy_test_password));

3229

g_assert_nonnull(password.data);

3230

g_assert_cmpint(memcmp(password.data, dummy_test_password,

3231

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

3232

3233

g_assert_false(quit_now);

3234

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

3235

3236

g_assert_nonnull(find_matching_task(queue, (task_context){

3237

.func=read_mandos_client_output,

3238

.epoll_fd=epoll_fd,

3239

.fd=pipefds[0],

3240

.password=&password,

3241

.password_is_read=&password_is_read,

3242

.quit_now=&quit_now,

3243

}));

3244

3245

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3246

EPOLLIN | EPOLLRDHUP));

3247

3248

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

3249

}

3250

3251

static

3252

void test_read_mandos_client_output_malloc(__attribute__((unused))

3253

test_fixture *fixture,

3254

__attribute__((unused))

3255

gconstpointer user_data){

3256

__attribute__((cleanup(cleanup_close)))

3257

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3258

g_assert_cmpint(epoll_fd, >=, 0);

3259

3260

int pipefds[2];

3261

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

3262

3263

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

3264

/* Start with an empty buffer */

3265

__attribute__((cleanup(cleanup_buffer)))

3266

buffer password = {};

3267

3268

bool password_is_read = false;

3269

bool quit_now = false;

3270

__attribute__((cleanup(cleanup_queue)))

3271

task_queue *queue = create_queue();

3272

g_assert_nonnull(queue);

3273

3274

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3275

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

3276

sizeof(dummy_test_password)),

3277

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

3278

3279

task_context task = {

3280

.func=read_mandos_client_output,

3281

.epoll_fd=epoll_fd,

3282

.fd=pipefds[0],

3283

.password=&password,

3284

.password_is_read=&password_is_read,

3285

.quit_now=&quit_now,

3286

};

3287

task.func(task, queue);

3288

3289

g_assert_false(password_is_read);

3290

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

3291

(int)sizeof(dummy_test_password));

3292

g_assert_nonnull(password.data);

3293

g_assert_cmpint(memcmp(password.data, dummy_test_password,

3294

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

3295

3296

g_assert_false(quit_now);

3297

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

3298

3299

g_assert_nonnull(find_matching_task(queue, (task_context){

3300

.func=read_mandos_client_output,

3301

.epoll_fd=epoll_fd,

3302

.fd=pipefds[0],

3303

.password=&password,

3304

.password_is_read=&password_is_read,

3305

.quit_now=&quit_now,

3306

}));

3307

3308

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3309

EPOLLIN | EPOLLRDHUP));

3310

3311

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

3312

}

3313

3314

static

3315

void test_read_mandos_client_output_append(__attribute__((unused))

3316

test_fixture *fixture,

3317

__attribute__((unused))

3318

gconstpointer user_data){

3319

__attribute__((cleanup(cleanup_close)))

3320

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3321

g_assert_cmpint(epoll_fd, >=, 0);

3322

3323

int pipefds[2];

3324

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

3325

3326

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

3327

__attribute__((cleanup(cleanup_buffer)))

3328

buffer password = {

3329

.data=malloc(PIPE_BUF),

3330

.length=PIPE_BUF,

3331

.allocated=PIPE_BUF,

3332

};

3333

g_assert_nonnull(password.data);

3334

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

3335

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

3336

}

3337

3338

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

3339

char password_expected[PIPE_BUF];

3340

memcpy(password_expected, password.data, PIPE_BUF);

3341

3342

bool password_is_read = false;

3343

bool quit_now = false;

3344

__attribute__((cleanup(cleanup_queue)))

3345

task_queue *queue = create_queue();

3346

g_assert_nonnull(queue);

3347

3348

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3349

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

3350

sizeof(dummy_test_password)),

3351

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

3352

3353

task_context task = {

3354

.func=read_mandos_client_output,

3355

.epoll_fd=epoll_fd,

3356

.fd=pipefds[0],

3357

.password=&password,

3358

.password_is_read=&password_is_read,

3359

.quit_now=&quit_now,

3360

};

3361

task.func(task, queue);

3362

3363

g_assert_false(password_is_read);

3364

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

3365

PIPE_BUF + sizeof(dummy_test_password));

3366

g_assert_nonnull(password.data);

3367

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

3368

==, 0);

3369

g_assert_cmpint(memcmp(password.data + PIPE_BUF,

3370

dummy_test_password,

3371

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

3372

g_assert_false(quit_now);

3373

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

3374

3375

g_assert_nonnull(find_matching_task(queue, (task_context){

3376

.func=read_mandos_client_output,

3377

.epoll_fd=epoll_fd,

3378

.fd=pipefds[0],

3379

.password=&password,

3380

.password_is_read=&password_is_read,

3381

.quit_now=&quit_now,

3382

}));

3383

3384

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3385

EPOLLIN | EPOLLRDHUP));

3386

}

3387

3388

static char *make_temporary_directory(void);

3389

3390

static void test_add_inotify_dir_watch(__attribute__((unused))

3391

test_fixture *fixture,

3392

__attribute__((unused))

3393

gconstpointer user_data){

3394

__attribute__((cleanup(cleanup_close)))

3395

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3396

g_assert_cmpint(epoll_fd, >=, 0);

3397

__attribute__((cleanup(cleanup_queue)))

3398

task_queue *queue = create_queue();

3399

g_assert_nonnull(queue);

3400

__attribute__((cleanup(string_set_clear)))

3401

string_set cancelled_filenames = {};

3402

const mono_microsecs current_time = 0;

3403

3404

bool quit_now = false;

3405

buffer password = {};

3406

bool mandos_client_exited = false;

3407

bool password_is_read = false;

3408

3409

__attribute__((cleanup(cleanup_string)))

3410

char *tempdir = make_temporary_directory();

3411

g_assert_nonnull(tempdir);

3412

3413

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3414

&password, tempdir,

3415

&cancelled_filenames,

3416

&current_time,

3417

&mandos_client_exited,

3418

&password_is_read));

3419

3420

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

3421

3422

const task_context *const added_read_task

3423

= find_matching_task(queue, (task_context){

3424

.func=read_inotify_event,

3425

.epoll_fd=epoll_fd,

3426

.quit_now=&quit_now,

3427

.password=&password,

3428

.filename=tempdir,

3429

.cancelled_filenames=&cancelled_filenames,

3430

.current_time=&current_time,

3431

.mandos_client_exited=&mandos_client_exited,

3432

.password_is_read=&password_is_read,

3433

});

3434

g_assert_nonnull(added_read_task);

3435

3436

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

3437

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3438

g_assert_true(epoll_set_contains(added_read_task->epoll_fd,

3439

added_read_task->fd,

3440

EPOLLIN | EPOLLRDHUP));

3441

3442

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

3443

}

3444

3445

static char *make_temporary_directory(void){

3446

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

3447

g_assert_nonnull(name);

3448

char *result = mkdtemp(name);

3449

if(result == NULL){

3450

free(name);

3451

}

3452

return result;

3453

}

3454

3455

static void test_add_inotify_dir_watch_fail(__attribute__((unused))

3456

test_fixture *fixture,

3457

__attribute__((unused))

3458

gconstpointer user_data){

3459

__attribute__((cleanup(cleanup_close)))

3460

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3461

g_assert_cmpint(epoll_fd, >=, 0);

3462

__attribute__((cleanup(cleanup_queue)))

3463

task_queue *queue = create_queue();

3464

g_assert_nonnull(queue);

3465

__attribute__((cleanup(string_set_clear)))

3466

string_set cancelled_filenames = {};

3467

const mono_microsecs current_time = 0;

3468

3469

bool quit_now = false;

3470

buffer password = {};

3471

bool mandos_client_exited = false;

3472

bool password_is_read = false;

3473

3474

const char nonexistent_dir[] = "/nonexistent";

3475

3476

FILE *real_stderr = stderr;

3477

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

3478

g_assert_nonnull(devnull);

3479

stderr = devnull;

3480

g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3481

&password, nonexistent_dir,

3482

&cancelled_filenames,

3483

&current_time,

3484

&mandos_client_exited,

3485

&password_is_read));

3486

stderr = real_stderr;

3487

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

3488

3489

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

3490

}

3491

3492

static void test_add_inotify_dir_watch_nondir(__attribute__((unused))

3493

test_fixture *fixture,

3494

__attribute__((unused))

3495

gconstpointer

3496

user_data){

3497

__attribute__((cleanup(cleanup_close)))

3498

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3499

g_assert_cmpint(epoll_fd, >=, 0);

3500

__attribute__((cleanup(cleanup_queue)))

3501

task_queue *queue = create_queue();

3502

g_assert_nonnull(queue);

3503

__attribute__((cleanup(string_set_clear)))

3504

string_set cancelled_filenames = {};

3505

const mono_microsecs current_time = 0;

3506

3507

bool quit_now = false;

3508

buffer password = {};

3509

bool mandos_client_exited = false;

3510

bool password_is_read = false;

3511

3512

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

3513

3514

FILE *real_stderr = stderr;

3515

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

3516

g_assert_nonnull(devnull);

3517

stderr = devnull;

3518

g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3519

&password, not_a_directory,

3520

&cancelled_filenames,

3521

&current_time,

3522

&mandos_client_exited,

3523

&password_is_read));

3524

stderr = real_stderr;

3525

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

3526

3527

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

3528

}

3529

3530

static void test_add_inotify_dir_watch_EAGAIN(__attribute__((unused))

3531

test_fixture *fixture,

3532

__attribute__((unused))

3533

gconstpointer

3534

user_data){

3535

__attribute__((cleanup(cleanup_close)))

3536

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3537

g_assert_cmpint(epoll_fd, >=, 0);

3538

__attribute__((cleanup(cleanup_queue)))

3539

task_queue *queue = create_queue();

3540

g_assert_nonnull(queue);

3541

__attribute__((cleanup(string_set_clear)))

3542

string_set cancelled_filenames = {};

3543

const mono_microsecs current_time = 0;

3544

3545

bool quit_now = false;

3546

buffer password = {};

3547

bool mandos_client_exited = false;

3548

bool password_is_read = false;

3549

3550

__attribute__((cleanup(cleanup_string)))

3551

char *tempdir = make_temporary_directory();

3552

g_assert_nonnull(tempdir);

3553

3554

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3555

&password, tempdir,

3556

&cancelled_filenames,

3557

&current_time,

3558

&mandos_client_exited,

3559

&password_is_read));

3560

3561

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

3562

3563

const task_context *const added_read_task

3564

= find_matching_task(queue,

3565

(task_context){ .func=read_inotify_event });

3566

g_assert_nonnull(added_read_task);

3567

3568

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

3569

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3570

3571

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

3572

const size_t ievent_size = (sizeof(struct inotify_event)

3573

+ NAME_MAX + 1);

3574

struct inotify_event *ievent = malloc(ievent_size);

3575

g_assert_nonnull(ievent);

3576

3577

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

3578

-1);

3579

g_assert_cmpint(errno, ==, EAGAIN);

3580

3581

free(ievent);

3582

3583

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

3584

}

3585

3586

static char *make_temporary_file_in_directory(const char

3587

*const dir);

3588

3589

static

3590

void test_add_inotify_dir_watch_IN_CLOSE_WRITE(__attribute__((unused))

3591

test_fixture *fixture,

3592

__attribute__((unused))

3593

gconstpointer

3594

user_data){

3595

__attribute__((cleanup(cleanup_close)))

3596

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3597

g_assert_cmpint(epoll_fd, >=, 0);

3598

__attribute__((cleanup(cleanup_queue)))

3599

task_queue *queue = create_queue();

3600

g_assert_nonnull(queue);

3601

__attribute__((cleanup(string_set_clear)))

3602

string_set cancelled_filenames = {};

3603

const mono_microsecs current_time = 0;

3604

3605

bool quit_now = false;

3606

buffer password = {};

3607

bool mandos_client_exited = false;

3608

bool password_is_read = false;

3609

3610

__attribute__((cleanup(cleanup_string)))

3611

char *tempdir = make_temporary_directory();

3612

g_assert_nonnull(tempdir);

3613

3614

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3615

&password, tempdir,

3616

&cancelled_filenames,

3617

&current_time,

3618

&mandos_client_exited,

3619

&password_is_read));

3620

3621

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

3622

3623

const task_context *const added_read_task

3624

= find_matching_task(queue,

3625

(task_context){ .func=read_inotify_event });

3626

g_assert_nonnull(added_read_task);

3627

3628

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

3629

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3630

3631

__attribute__((cleanup(cleanup_string)))

3632

char *filename = make_temporary_file_in_directory(tempdir);

3633

g_assert_nonnull(filename);

3634

3635

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

3636

const size_t ievent_size = (sizeof(struct inotify_event)

3637

+ NAME_MAX + 1);

3638

struct inotify_event *ievent = malloc(ievent_size);

3639

g_assert_nonnull(ievent);

3640

3641

ssize_t read_size = 0;

3642

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

3643

3644

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

3645

g_assert_true(ievent->mask & IN_CLOSE_WRITE);

3646

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

3647

3648

free(ievent);

3649

3650

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

3651

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

3652

}

3653

3654

static char *make_temporary_prefixed_file_in_directory(const char

3655

*const prefix,

3656

const char

3657

*const dir){

3658

char *filename = NULL;

3659

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

3660

>, 0);

3661

g_assert_nonnull(filename);

3662

const int fd = mkostemp(filename, O_CLOEXEC);

3663

g_assert_cmpint(fd, >=, 0);

3664

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

3665

return filename;

3666

}

3667

3668

static char *make_temporary_file_in_directory(const char

3669

*const dir){

3670

return make_temporary_prefixed_file_in_directory("temp", dir);

3671

}

3672

3673

static

3674

void test_add_inotify_dir_watch_IN_MOVED_TO(__attribute__((unused))

3675

test_fixture *fixture,

3676

__attribute__((unused))

3677

gconstpointer user_data){

3678

__attribute__((cleanup(cleanup_close)))

3679

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3680

g_assert_cmpint(epoll_fd, >=, 0);

3681

__attribute__((cleanup(cleanup_queue)))

3682

task_queue *queue = create_queue();

3683

g_assert_nonnull(queue);

3684

__attribute__((cleanup(string_set_clear)))

3685

string_set cancelled_filenames = {};

3686

const mono_microsecs current_time = 0;

3687

3688

bool quit_now = false;

3689

buffer password = {};

3690

bool mandos_client_exited = false;

3691

bool password_is_read = false;

3692

3693

__attribute__((cleanup(cleanup_string)))

3694

char *watchdir = make_temporary_directory();

3695

g_assert_nonnull(watchdir);

3696

3697

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3698

&password, watchdir,

3699

&cancelled_filenames,

3700

&current_time,

3701

&mandos_client_exited,

3702

&password_is_read));

3703

3704

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

3705

3706

const task_context *const added_read_task

3707

= find_matching_task(queue,

3708

(task_context){ .func=read_inotify_event });

3709

g_assert_nonnull(added_read_task);

3710

3711

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

3712

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3713

3714

char *sourcedir = make_temporary_directory();

3715

g_assert_nonnull(sourcedir);

3716

3717

__attribute__((cleanup(cleanup_string)))

3718

char *filename = make_temporary_file_in_directory(sourcedir);

3719

g_assert_nonnull(filename);

3720

3721

__attribute__((cleanup(cleanup_string)))

3722

char *targetfilename = NULL;

3723

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

3724

basename(filename)), >, 0);

3725

g_assert_nonnull(targetfilename);

3726

3727

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

3728

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

3729

free(sourcedir);

3730

3731

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

3732

const size_t ievent_size = (sizeof(struct inotify_event)

3733

+ NAME_MAX + 1);

3734

struct inotify_event *ievent = malloc(ievent_size);

3735

g_assert_nonnull(ievent);

3736

3737

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

3738

3739

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

3740

g_assert_true(ievent->mask & IN_MOVED_TO);

3741

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

3742

3743

free(ievent);

3744

3745

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

3746

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

3747

}

3748

3749

static

3750

void test_add_inotify_dir_watch_IN_MOVED_FROM(__attribute__((unused))

3751

test_fixture *fixture,

3752

__attribute__((unused))

3753

gconstpointer

3754

user_data){

3755

__attribute__((cleanup(cleanup_close)))

3756

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3757

g_assert_cmpint(epoll_fd, >=, 0);

3758

__attribute__((cleanup(cleanup_queue)))

3759

task_queue *queue = create_queue();

3760

g_assert_nonnull(queue);

3761

__attribute__((cleanup(string_set_clear)))

3762

string_set cancelled_filenames = {};

3763

const mono_microsecs current_time = 0;

3764

3765

bool quit_now = false;

3766

buffer password = {};

3767

bool mandos_client_exited = false;

3768

bool password_is_read = false;

3769

3770

__attribute__((cleanup(cleanup_string)))

3771

char *tempdir = make_temporary_directory();

3772

g_assert_nonnull(tempdir);

3773

3774

__attribute__((cleanup(cleanup_string)))

3775

char *tempfilename = make_temporary_file_in_directory(tempdir);

3776

g_assert_nonnull(tempfilename);

3777

3778

__attribute__((cleanup(cleanup_string)))

3779

char *targetdir = make_temporary_directory();

3780

g_assert_nonnull(targetdir);

3781

3782

__attribute__((cleanup(cleanup_string)))

3783

char *targetfilename = NULL;

3784

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

3785

basename(tempfilename)), >, 0);

3786

g_assert_nonnull(targetfilename);

3787

3788

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3789

&password, tempdir,

3790

&cancelled_filenames,

3791

&current_time,

3792

&mandos_client_exited,

3793

&password_is_read));

3794

3795

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

3796

3797

const task_context *const added_read_task

3798

= find_matching_task(queue,

3799

(task_context){ .func=read_inotify_event });

3800

g_assert_nonnull(added_read_task);

3801

3802

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

3803

const size_t ievent_size = (sizeof(struct inotify_event)

3804

+ NAME_MAX + 1);

3805

struct inotify_event *ievent = malloc(ievent_size);

3806

g_assert_nonnull(ievent);

3807

3808

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

3809

3810

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

3811

g_assert_true(ievent->mask & IN_MOVED_FROM);

3812

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

3813

3814

free(ievent);

3815

3816

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

3817

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

3818

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

3819

}

3820

3821

static

3822

void test_add_inotify_dir_watch_IN_DELETE(__attribute__((unused))

3823

test_fixture *fixture,

3824

__attribute__((unused))

3825

gconstpointer user_data){

3826

__attribute__((cleanup(cleanup_close)))

3827

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3828

g_assert_cmpint(epoll_fd, >=, 0);

3829

__attribute__((cleanup(cleanup_queue)))

3830

task_queue *queue = create_queue();

3831

g_assert_nonnull(queue);

3832

__attribute__((cleanup(string_set_clear)))

3833

string_set cancelled_filenames = {};

3834

const mono_microsecs current_time = 0;

3835

3836

bool quit_now = false;

3837

buffer password = {};

3838

bool mandos_client_exited = false;

3839

bool password_is_read = false;

3840

3841

__attribute__((cleanup(cleanup_string)))

3842

char *tempdir = make_temporary_directory();

3843

g_assert_nonnull(tempdir);

3844

3845

__attribute__((cleanup(cleanup_string)))

3846

char *tempfile = make_temporary_file_in_directory(tempdir);

3847

g_assert_nonnull(tempfile);

3848

3849

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3850

&password, tempdir,

3851

&cancelled_filenames,

3852

&current_time,

3853

&mandos_client_exited,

3854

&password_is_read));

3855

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

3856

3857

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

3858

3859

const task_context *const added_read_task

3860

= find_matching_task(queue,

3861

(task_context){ .func=read_inotify_event });

3862

g_assert_nonnull(added_read_task);

3863

3864

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

3865

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3866

3867

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

3868

const size_t ievent_size = (sizeof(struct inotify_event)

3869

+ NAME_MAX + 1);

3870

struct inotify_event *ievent = malloc(ievent_size);

3871

g_assert_nonnull(ievent);

3872

3873

ssize_t read_size = 0;

3874

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

3875

3876

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

3877

g_assert_true(ievent->mask & IN_DELETE);

3878

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

3879

3880

free(ievent);

3881

3882

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

3883

}

3884

3885

static

3886

void test_add_inotify_dir_watch_IN_EXCL_UNLINK(__attribute__((unused))

3887

test_fixture *fixture,

3888

__attribute__((unused))

3889

gconstpointer

3890

user_data){

3891

__attribute__((cleanup(cleanup_close)))

3892

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3893

g_assert_cmpint(epoll_fd, >=, 0);

3894

__attribute__((cleanup(cleanup_queue)))

3895

task_queue *queue = create_queue();

3896

g_assert_nonnull(queue);

3897

__attribute__((cleanup(string_set_clear)))

3898

string_set cancelled_filenames = {};

3899

const mono_microsecs current_time = 0;

3900

3901

bool quit_now = false;

3902

buffer password = {};

3903

bool mandos_client_exited = false;

3904

bool password_is_read = false;

3905

3906

__attribute__((cleanup(cleanup_string)))

3907

char *tempdir = make_temporary_directory();

3908

g_assert_nonnull(tempdir);

3909

3910

__attribute__((cleanup(cleanup_string)))

3911

char *tempfile = make_temporary_file_in_directory(tempdir);

3912

g_assert_nonnull(tempfile);

3913

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

3914

| O_NOFOLLOW);

3915

g_assert_cmpint(tempfile_fd, >, 2);

3916

3917

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3918

&password, tempdir,

3919

&cancelled_filenames,

3920

&current_time,

3921

&mandos_client_exited,

3922

&password_is_read));

3923

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

3924

3925

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

3926

3927

const task_context *const added_read_task

3928

= find_matching_task(queue,

3929

(task_context){ .func=read_inotify_event });

3930

g_assert_nonnull(added_read_task);

3931

3932

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

3933

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3934

3935

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

3936

const size_t ievent_size = (sizeof(struct inotify_event)

3937

+ NAME_MAX + 1);

3938

struct inotify_event *ievent = malloc(ievent_size);

3939

g_assert_nonnull(ievent);

3940

3941

ssize_t read_size = 0;

3942

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

3943

3944

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

3945

g_assert_true(ievent->mask & IN_DELETE);

3946

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

3947

3948

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

3949

3950

/* IN_EXCL_UNLINK should make the closing of the previously unlinked

3951

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

3952

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

3953

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

3954

g_assert_true(errno == EAGAIN);

3955

3956

free(ievent);

3957

3958

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

3959

}

3960

3961

static void test_read_inotify_event_readerror(__attribute__((unused))

3962

test_fixture *fixture,

3963

__attribute__((unused))

3964

gconstpointer

3965

user_data){

3966

__attribute__((cleanup(cleanup_close)))

3967

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3968

g_assert_cmpint(epoll_fd, >=, 0);

3969

const mono_microsecs current_time = 0;

3970

3971

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

3972

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

3973

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3974

3975

bool quit_now = false;

3976

__attribute__((cleanup(cleanup_queue)))

3977

task_queue *queue = create_queue();

3978

g_assert_nonnull(queue);

3979

3980

task_context task = {

3981

.func=read_inotify_event,

3982

.epoll_fd=epoll_fd,

3983

.fd=fd,

3984

.quit_now=&quit_now,

3985

.filename=strdup("/nonexistent"),

3986

.cancelled_filenames = &(string_set){},

3987

.notafter=0,

3988

.current_time=&current_time,

3989

};

3990

g_assert_nonnull(task.filename);

3991

run_task_with_stderr_to_dev_null(task, queue);

3992

g_assert_true(quit_now);

3993

g_assert_true(queue->next_run == 0);

3994

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

3995

3996

g_assert_true(epoll_set_does_not_contain(epoll_fd, fd));

3997

3998

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

3999

}

4000

4001

static void test_read_inotify_event_bad_epoll(__attribute__((unused))

4002

test_fixture *fixture,

4003

__attribute__((unused))

4004

gconstpointer

4005

user_data){

4006

const mono_microsecs current_time = 17;

4007

4008

int pipefds[2];

4009

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

4010

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

4011

4012

bool quit_now = false;

4013

buffer password = {};

4014

bool mandos_client_exited = false;

4015

bool password_is_read = false;

4016

__attribute__((cleanup(cleanup_queue)))

4017

task_queue *queue = create_queue();

4018

g_assert_nonnull(queue);

4019

4020

task_context task = {

4021

.func=read_inotify_event,

4022

.epoll_fd=epoll_fd,

4023

.fd=pipefds[0],

4024

.quit_now=&quit_now,

4025

.password=&password,

4026

.filename=strdup("/nonexistent"),

4027

.cancelled_filenames = &(string_set){},

4028

.notafter=0,

4029

.current_time=&current_time,

4030

.mandos_client_exited=&mandos_client_exited,

4031

.password_is_read=&password_is_read,

4032

};

4033

g_assert_nonnull(task.filename);

4034

run_task_with_stderr_to_dev_null(task, queue);

4035

4036

g_assert_nonnull(find_matching_task(queue, task));

4037

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

4038

4039

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

4040

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

4041

}

4042

4043

static void test_read_inotify_event_nodata(__attribute__((unused))

4044

test_fixture *fixture,

4045

__attribute__((unused))

4046

gconstpointer user_data){

4047

__attribute__((cleanup(cleanup_close)))

4048

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4049

g_assert_cmpint(epoll_fd, >=, 0);

4050

const mono_microsecs current_time = 0;

4051

4052

int pipefds[2];

4053

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

4054

4055

bool quit_now = false;

4056

buffer password = {};

4057

bool mandos_client_exited = false;

4058

bool password_is_read = false;

4059

__attribute__((cleanup(cleanup_queue)))

4060

task_queue *queue = create_queue();

4061

g_assert_nonnull(queue);

4062

4063

task_context task = {

4064

.func=read_inotify_event,

4065

.epoll_fd=epoll_fd,

4066

.fd=pipefds[0],

4067

.quit_now=&quit_now,

4068

.password=&password,

4069

.filename=strdup("/nonexistent"),

4070

.cancelled_filenames = &(string_set){},

4071

.notafter=0,

4072

.current_time=&current_time,

4073

.mandos_client_exited=&mandos_client_exited,

4074

.password_is_read=&password_is_read,

4075

};

4076

g_assert_nonnull(task.filename);

4077

task.func(task, queue);

4078

g_assert_false(quit_now);

4079

g_assert_true(queue->next_run == 0);

4080

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

4081

4082

g_assert_nonnull(find_matching_task(queue, (task_context){

4083

.func=read_inotify_event,

4084

.epoll_fd=epoll_fd,

4085

.fd=pipefds[0],

4086

.quit_now=&quit_now,

4087

.password=&password,

4088

.filename=task.filename,

4089

.cancelled_filenames=task.cancelled_filenames,

4090

.current_time=&current_time,

4091

.mandos_client_exited=&mandos_client_exited,

4092

.password_is_read=&password_is_read,

4093

}));

4094

4095

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4096

EPOLLIN | EPOLLRDHUP));

4097

4098

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

4099

}

4100

4101

static void test_read_inotify_event_eof(__attribute__((unused))

4102

test_fixture *fixture,

4103

__attribute__((unused))

4104

gconstpointer user_data){

4105

__attribute__((cleanup(cleanup_close)))

4106

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4107

g_assert_cmpint(epoll_fd, >=, 0);

4108

const mono_microsecs current_time = 0;

4109

4110

int pipefds[2];

4111

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

4112

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

4113

4114

bool quit_now = false;

4115

buffer password = {};

4116

__attribute__((cleanup(cleanup_queue)))

4117

task_queue *queue = create_queue();

4118

g_assert_nonnull(queue);

4119

4120

task_context task = {

4121

.func=read_inotify_event,

4122

.epoll_fd=epoll_fd,

4123

.fd=pipefds[0],

4124

.quit_now=&quit_now,

4125

.password=&password,

4126

.filename=strdup("/nonexistent"),

4127

.cancelled_filenames = &(string_set){},

4128

.notafter=0,

4129

.current_time=&current_time,

4130

};

4131

run_task_with_stderr_to_dev_null(task, queue);

4132

g_assert_true(quit_now);

4133

g_assert_true(queue->next_run == 0);

4134

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

4135

4136

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

4137

4138

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

4139

}

4140

4141

static

4142

void test_read_inotify_event_IN_CLOSE_WRITE(__attribute__((unused))

4143

test_fixture *fixture,

4144

__attribute__((unused))

4145

gconstpointer user_data){

4146

__attribute__((cleanup(cleanup_close)))

4147

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4148

g_assert_cmpint(epoll_fd, >=, 0);

4149

const mono_microsecs current_time = 0;

4150

4151

int pipefds[2];

4152

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

4153

4154

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

4155

const size_t ievent_max_size = (sizeof(struct inotify_event)

4156

+ NAME_MAX + 1);

4157

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4158

struct {

4159

struct inotify_event event;

4160

char name_buffer[NAME_MAX + 1];

4161

} ievent_buffer;

4162

struct inotify_event *const ievent = &ievent_buffer.event;

4163

4164

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

4165

ievent->mask = IN_CLOSE_WRITE;

4166

ievent->len = sizeof(dummy_file_name);

4167

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

4168

const size_t ievent_size = (sizeof(struct inotify_event)

4169

+ sizeof(dummy_file_name));

4170

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

4171

==, ievent_size);

4172

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

4173

4174

bool quit_now = false;

4175

buffer password = {};

4176

bool mandos_client_exited = false;

4177

bool password_is_read = false;

4178

__attribute__((cleanup(cleanup_queue)))

4179

task_queue *queue = create_queue();

4180

g_assert_nonnull(queue);

4181

4182

task_context task = {

4183

.func=read_inotify_event,

4184

.epoll_fd=epoll_fd,

4185

.fd=pipefds[0],

4186

.quit_now=&quit_now,

4187

.password=&password,

4188

.filename=strdup("/nonexistent"),

4189

.cancelled_filenames = &(string_set){},

4190

.notafter=0,

4191

.current_time=&current_time,

4192

.mandos_client_exited=&mandos_client_exited,

4193

.password_is_read=&password_is_read,

4194

};

4195

task.func(task, queue);

4196

g_assert_false(quit_now);

4197

g_assert_true(queue->next_run != 0);

4198

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

4199

4200

g_assert_nonnull(find_matching_task(queue, (task_context){

4201

.func=read_inotify_event,

4202

.epoll_fd=epoll_fd,

4203

.fd=pipefds[0],

4204

.quit_now=&quit_now,

4205

.password=&password,

4206

.filename=task.filename,

4207

.cancelled_filenames=task.cancelled_filenames,

4208

.current_time=&current_time,

4209

.mandos_client_exited=&mandos_client_exited,

4210

.password_is_read=&password_is_read,

4211

}));

4212

4213

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4214

EPOLLIN | EPOLLRDHUP));

4215

4216

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

4217

4218

__attribute__((cleanup(cleanup_string)))

4219

char *filename = NULL;

4220

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

4221

dummy_file_name), >, 0);

4222

g_assert_nonnull(filename);

4223

g_assert_nonnull(find_matching_task(queue, (task_context){

4224

.func=open_and_parse_question,

4225

.epoll_fd=epoll_fd,

4226

.filename=filename,

4227

.question_filename=filename,

4228

.password=&password,

4229

.cancelled_filenames=task.cancelled_filenames,

4230

.current_time=&current_time,

4231

.mandos_client_exited=&mandos_client_exited,

4232

.password_is_read=&password_is_read,

4233

}));

4234

}

4235

4236

static

4237

void test_read_inotify_event_IN_MOVED_TO(__attribute__((unused))

4238

test_fixture *fixture,

4239

__attribute__((unused))

4240

gconstpointer user_data){

4241

__attribute__((cleanup(cleanup_close)))

4242

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4243

g_assert_cmpint(epoll_fd, >=, 0);

4244

const mono_microsecs current_time = 0;

4245

4246

int pipefds[2];

4247

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

4248

4249

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

4250

const size_t ievent_max_size = (sizeof(struct inotify_event)

4251

+ NAME_MAX + 1);

4252

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4253

struct {

4254

struct inotify_event event;

4255

char name_buffer[NAME_MAX + 1];

4256

} ievent_buffer;

4257

struct inotify_event *const ievent = &ievent_buffer.event;

4258

4259

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

4260

ievent->mask = IN_MOVED_TO;

4261

ievent->len = sizeof(dummy_file_name);

4262

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

4263

const size_t ievent_size = (sizeof(struct inotify_event)

4264

+ sizeof(dummy_file_name));

4265

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

4266

==, ievent_size);

4267

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

4268

4269

bool quit_now = false;

4270

buffer password = {};

4271

bool mandos_client_exited = false;

4272

bool password_is_read = false;

4273

__attribute__((cleanup(cleanup_queue)))

4274

task_queue *queue = create_queue();

4275

g_assert_nonnull(queue);

4276

4277

task_context task = {

4278

.func=read_inotify_event,

4279

.epoll_fd=epoll_fd,

4280

.fd=pipefds[0],

4281

.quit_now=&quit_now,

4282

.password=&password,

4283

.filename=strdup("/nonexistent"),

4284

.cancelled_filenames = &(string_set){},

4285

.notafter=0,

4286

.current_time=&current_time,

4287

.mandos_client_exited=&mandos_client_exited,

4288

.password_is_read=&password_is_read,

4289

};

4290

task.func(task, queue);

4291

g_assert_false(quit_now);

4292

g_assert_true(queue->next_run != 0);

4293

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

4294

4295

g_assert_nonnull(find_matching_task(queue, (task_context){

4296

.func=read_inotify_event,

4297

.epoll_fd=epoll_fd,

4298

.fd=pipefds[0],

4299

.quit_now=&quit_now,

4300

.password=&password,

4301

.filename=task.filename,

4302

.cancelled_filenames=task.cancelled_filenames,

4303

.current_time=&current_time,

4304

.mandos_client_exited=&mandos_client_exited,

4305

.password_is_read=&password_is_read,

4306

}));

4307

4308

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4309

EPOLLIN | EPOLLRDHUP));

4310

4311

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

4312

4313

__attribute__((cleanup(cleanup_string)))

4314

char *filename = NULL;

4315

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

4316

dummy_file_name), >, 0);

4317

g_assert_nonnull(filename);

4318

g_assert_nonnull(find_matching_task(queue, (task_context){

4319

.func=open_and_parse_question,

4320

.epoll_fd=epoll_fd,

4321

.filename=filename,

4322

.question_filename=filename,

4323

.password=&password,

4324

.cancelled_filenames=task.cancelled_filenames,

4325

.current_time=&current_time,

4326

.mandos_client_exited=&mandos_client_exited,

4327

.password_is_read=&password_is_read,

4328

}));

4329

}

4330

4331

static

4332

void test_read_inotify_event_IN_MOVED_FROM(__attribute__((unused))

4333

test_fixture *fixture,

4334

__attribute__((unused))

4335

gconstpointer user_data){

4336

__attribute__((cleanup(cleanup_close)))

4337

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4338

g_assert_cmpint(epoll_fd, >=, 0);

4339

__attribute__((cleanup(string_set_clear)))

4340

string_set cancelled_filenames = {};

4341

const mono_microsecs current_time = 0;

4342

4343

int pipefds[2];

4344

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

4345

4346

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

4347

const size_t ievent_max_size = (sizeof(struct inotify_event)

4348

+ NAME_MAX + 1);

4349

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4350

struct {

4351

struct inotify_event event;

4352

char name_buffer[NAME_MAX + 1];

4353

} ievent_buffer;

4354

struct inotify_event *const ievent = &ievent_buffer.event;

4355

4356

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

4357

ievent->mask = IN_MOVED_FROM;

4358

ievent->len = sizeof(dummy_file_name);

4359

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

4360

const size_t ievent_size = (sizeof(struct inotify_event)

4361

+ sizeof(dummy_file_name));

4362

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

4363

==, ievent_size);

4364

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

4365

4366

bool quit_now = false;

4367

buffer password = {};

4368

bool mandos_client_exited = false;

4369

bool password_is_read = false;

4370

__attribute__((cleanup(cleanup_queue)))

4371

task_queue *queue = create_queue();

4372

g_assert_nonnull(queue);

4373

4374

task_context task = {

4375

.func=read_inotify_event,

4376

.epoll_fd=epoll_fd,

4377

.fd=pipefds[0],

4378

.quit_now=&quit_now,

4379

.password=&password,

4380

.filename=strdup("/nonexistent"),

4381

.cancelled_filenames=&cancelled_filenames,

4382

.current_time=&current_time,

4383

.mandos_client_exited=&mandos_client_exited,

4384

.password_is_read=&password_is_read,

4385

};

4386

task.func(task, queue);

4387

g_assert_false(quit_now);

4388

g_assert_true(queue->next_run == 0);

4389

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

4390

4391

g_assert_nonnull(find_matching_task(queue, (task_context){

4392

.func=read_inotify_event,

4393

.epoll_fd=epoll_fd,

4394

.fd=pipefds[0],

4395

.quit_now=&quit_now,

4396

.password=&password,

4397

.filename=task.filename,

4398

.cancelled_filenames=&cancelled_filenames,

4399

.current_time=&current_time,

4400

.mandos_client_exited=&mandos_client_exited,

4401

.password_is_read=&password_is_read,

4402

}));

4403

4404

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4405

EPOLLIN | EPOLLRDHUP));

4406

4407

__attribute__((cleanup(cleanup_string)))

4408

char *filename = NULL;

4409

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

4410

dummy_file_name), >, 0);

4411

g_assert_nonnull(filename);

4412

g_assert_true(string_set_contains(*task.cancelled_filenames,

4413

filename));

4414

}

4415

4416

static void test_read_inotify_event_IN_DELETE(__attribute__((unused))

4417

test_fixture *fixture,

4418

__attribute__((unused))

4419

gconstpointer

4420

user_data){

4421

__attribute__((cleanup(cleanup_close)))

4422

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4423

g_assert_cmpint(epoll_fd, >=, 0);

4424

__attribute__((cleanup(string_set_clear)))

4425

string_set cancelled_filenames = {};

4426

const mono_microsecs current_time = 0;

4427

4428

int pipefds[2];

4429

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

4430

4431

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

4432

const size_t ievent_max_size = (sizeof(struct inotify_event)

4433

+ NAME_MAX + 1);

4434

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4435

struct {

4436

struct inotify_event event;

4437

char name_buffer[NAME_MAX + 1];

4438

} ievent_buffer;

4439

struct inotify_event *const ievent = &ievent_buffer.event;

4440

4441

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

4442

ievent->mask = IN_DELETE;

4443

ievent->len = sizeof(dummy_file_name);

4444

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

4445

const size_t ievent_size = (sizeof(struct inotify_event)

4446

+ sizeof(dummy_file_name));

4447

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

4448

==, ievent_size);

4449

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

4450

4451

bool quit_now = false;

4452

buffer password = {};

4453

bool mandos_client_exited = false;

4454

bool password_is_read = false;

4455

__attribute__((cleanup(cleanup_queue)))

4456

task_queue *queue = create_queue();

4457

g_assert_nonnull(queue);

4458

4459

task_context task = {

4460

.func=read_inotify_event,

4461

.epoll_fd=epoll_fd,

4462

.fd=pipefds[0],

4463

.quit_now=&quit_now,

4464

.password=&password,

4465

.filename=strdup("/nonexistent"),

4466

.cancelled_filenames=&cancelled_filenames,

4467

.current_time=&current_time,

4468

.mandos_client_exited=&mandos_client_exited,

4469

.password_is_read=&password_is_read,

4470

};

4471

task.func(task, queue);

4472

g_assert_false(quit_now);

4473

g_assert_true(queue->next_run == 0);

4474

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

4475

4476

g_assert_nonnull(find_matching_task(queue, (task_context){

4477

.func=read_inotify_event,

4478

.epoll_fd=epoll_fd,

4479

.fd=pipefds[0],

4480

.quit_now=&quit_now,

4481

.password=&password,

4482

.filename=task.filename,

4483

.cancelled_filenames=&cancelled_filenames,

4484

.current_time=&current_time,

4485

.mandos_client_exited=&mandos_client_exited,

4486

.password_is_read=&password_is_read,

4487

}));

4488

4489

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4490

EPOLLIN | EPOLLRDHUP));

4491

4492

__attribute__((cleanup(cleanup_string)))

4493

char *filename = NULL;

4494

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

4495

dummy_file_name), >, 0);

4496

g_assert_nonnull(filename);

4497

g_assert_true(string_set_contains(*task.cancelled_filenames,

4498

filename));

4499

}

4500

4501

static void

4502

test_read_inotify_event_IN_CLOSE_WRITE_badname(__attribute__((unused))

4503

test_fixture *fixture,

4504

__attribute__((unused))

4505

gconstpointer

4506

user_data){

4507

__attribute__((cleanup(cleanup_close)))

4508

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4509

g_assert_cmpint(epoll_fd, >=, 0);

4510

const mono_microsecs current_time = 0;

4511

4512

int pipefds[2];

4513

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

4514

4515

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

4516

const size_t ievent_max_size = (sizeof(struct inotify_event)

4517

+ NAME_MAX + 1);

4518

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4519

struct {

4520

struct inotify_event event;

4521

char name_buffer[NAME_MAX + 1];

4522

} ievent_buffer;

4523

struct inotify_event *const ievent = &ievent_buffer.event;

4524

4525

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

4526

ievent->mask = IN_CLOSE_WRITE;

4527

ievent->len = sizeof(dummy_file_name);

4528

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

4529

const size_t ievent_size = (sizeof(struct inotify_event)

4530

+ sizeof(dummy_file_name));

4531

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

4532

==, ievent_size);

4533

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

4534

4535

bool quit_now = false;

4536

buffer password = {};

4537

bool mandos_client_exited = false;

4538

bool password_is_read = false;

4539

__attribute__((cleanup(cleanup_queue)))

4540

task_queue *queue = create_queue();

4541

g_assert_nonnull(queue);

4542

4543

task_context task = {

4544

.func=read_inotify_event,

4545

.epoll_fd=epoll_fd,

4546

.fd=pipefds[0],

4547

.quit_now=&quit_now,

4548

.password=&password,

4549

.filename=strdup("/nonexistent"),

4550

.cancelled_filenames = &(string_set){},

4551

.notafter=0,

4552

.current_time=&current_time,

4553

.mandos_client_exited=&mandos_client_exited,

4554

.password_is_read=&password_is_read,

4555

};

4556

task.func(task, queue);

4557

g_assert_false(quit_now);

4558

g_assert_true(queue->next_run == 0);

4559

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

4560

4561

g_assert_nonnull(find_matching_task(queue, (task_context){

4562

.func=read_inotify_event,

4563

.epoll_fd=epoll_fd,

4564

.fd=pipefds[0],

4565

.quit_now=&quit_now,

4566

.password=&password,

4567

.filename=task.filename,

4568

.cancelled_filenames=task.cancelled_filenames,

4569

.current_time=&current_time,

4570

.mandos_client_exited=&mandos_client_exited,

4571

.password_is_read=&password_is_read,

4572

}));

4573

4574

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4575

EPOLLIN | EPOLLRDHUP));

4576

}

4577

4578

static void

4579

test_read_inotify_event_IN_MOVED_TO_badname(__attribute__((unused))

4580

test_fixture *fixture,

4581

__attribute__((unused))

4582

gconstpointer user_data){

4583

__attribute__((cleanup(cleanup_close)))

4584

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4585

g_assert_cmpint(epoll_fd, >=, 0);

4586

const mono_microsecs current_time = 0;

4587

4588

int pipefds[2];

4589

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

4590

4591

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

4592

const size_t ievent_max_size = (sizeof(struct inotify_event)

4593

+ NAME_MAX + 1);

4594

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4595

struct {

4596

struct inotify_event event;

4597

char name_buffer[NAME_MAX + 1];

4598

} ievent_buffer;

4599

struct inotify_event *const ievent = &ievent_buffer.event;

4600

4601

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

4602

ievent->mask = IN_MOVED_TO;

4603

ievent->len = sizeof(dummy_file_name);

4604

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

4605

const size_t ievent_size = (sizeof(struct inotify_event)

4606

+ sizeof(dummy_file_name));

4607

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

4608

==, ievent_size);

4609

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

4610

4611

bool quit_now = false;

4612

buffer password = {};

4613

bool mandos_client_exited = false;

4614

bool password_is_read = false;

4615

__attribute__((cleanup(cleanup_queue)))

4616

task_queue *queue = create_queue();

4617

g_assert_nonnull(queue);

4618

4619

task_context task = {

4620

.func=read_inotify_event,

4621

.epoll_fd=epoll_fd,

4622

.fd=pipefds[0],

4623

.quit_now=&quit_now,

4624

.password=&password,

4625

.filename=strdup("/nonexistent"),

4626

.cancelled_filenames = &(string_set){},

4627

.notafter=0,

4628

.current_time=&current_time,

4629

.mandos_client_exited=&mandos_client_exited,

4630

.password_is_read=&password_is_read,

4631

};

4632

task.func(task, queue);

4633

g_assert_false(quit_now);

4634

g_assert_true(queue->next_run == 0);

4635

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

4636

4637

g_assert_nonnull(find_matching_task(queue, (task_context){

4638

.func=read_inotify_event,

4639

.epoll_fd=epoll_fd,

4640

.fd=pipefds[0],

4641

.quit_now=&quit_now,

4642

.password=&password,

4643

.filename=task.filename,

4644

.cancelled_filenames=task.cancelled_filenames,

4645

.current_time=&current_time,

4646

.mandos_client_exited=&mandos_client_exited,

4647

.password_is_read=&password_is_read,

4648

}));

4649

4650

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4651

EPOLLIN | EPOLLRDHUP));

4652

}

4653

4654

static void

4655

test_read_inotify_event_IN_MOVED_FROM_badname(__attribute__((unused))

4656

test_fixture *fixture,

4657

__attribute__((unused))

4658

gconstpointer

4659

user_data){

4660

__attribute__((cleanup(cleanup_close)))

4661

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4662

g_assert_cmpint(epoll_fd, >=, 0);

4663

__attribute__((cleanup(string_set_clear)))

4664

string_set cancelled_filenames = {};

4665

const mono_microsecs current_time = 0;

4666

4667

int pipefds[2];

4668

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

4669

4670

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

4671

const size_t ievent_max_size = (sizeof(struct inotify_event)

4672

+ NAME_MAX + 1);

4673

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4674

struct {

4675

struct inotify_event event;

4676

char name_buffer[NAME_MAX + 1];

4677

} ievent_buffer;

4678

struct inotify_event *const ievent = &ievent_buffer.event;

4679

4680

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

4681

ievent->mask = IN_MOVED_FROM;

4682

ievent->len = sizeof(dummy_file_name);

4683

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

4684

const size_t ievent_size = (sizeof(struct inotify_event)

4685

+ sizeof(dummy_file_name));

4686

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

4687

==, ievent_size);

4688

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

4689

4690

bool quit_now = false;

4691

buffer password = {};

4692

bool mandos_client_exited = false;

4693

bool password_is_read = false;

4694

__attribute__((cleanup(cleanup_queue)))

4695

task_queue *queue = create_queue();

4696

g_assert_nonnull(queue);

4697

4698

task_context task = {

4699

.func=read_inotify_event,

4700

.epoll_fd=epoll_fd,

4701

.fd=pipefds[0],

4702

.quit_now=&quit_now,

4703

.password=&password,

4704

.filename=strdup("/nonexistent"),

4705

.cancelled_filenames=&cancelled_filenames,

4706

.current_time=&current_time,

4707

.mandos_client_exited=&mandos_client_exited,

4708

.password_is_read=&password_is_read,

4709

};

4710

task.func(task, queue);

4711

g_assert_false(quit_now);

4712

g_assert_true(queue->next_run == 0);

4713

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

4714

4715

g_assert_nonnull(find_matching_task(queue, (task_context){

4716

.func=read_inotify_event,

4717

.epoll_fd=epoll_fd,

4718

.fd=pipefds[0],

4719

.quit_now=&quit_now,

4720

.password=&password,

4721

.filename=task.filename,

4722

.cancelled_filenames=&cancelled_filenames,

4723

.current_time=&current_time,

4724

.mandos_client_exited=&mandos_client_exited,

4725

.password_is_read=&password_is_read,

4726

}));

4727

4728

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4729

EPOLLIN | EPOLLRDHUP));

4730

4731

__attribute__((cleanup(cleanup_string)))

4732

char *filename = NULL;

4733

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

4734

dummy_file_name), >, 0);

4735

g_assert_nonnull(filename);

4736

g_assert_false(string_set_contains(cancelled_filenames, filename));

4737

}

4738

4739

static

4740

void test_read_inotify_event_IN_DELETE_badname(__attribute__((unused))

4741

test_fixture *fixture,

4742

__attribute__((unused))

4743

gconstpointer

4744

user_data){

4745

__attribute__((cleanup(cleanup_close)))

4746

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4747

g_assert_cmpint(epoll_fd, >=, 0);

4748

__attribute__((cleanup(string_set_clear)))

4749

string_set cancelled_filenames = {};

4750

const mono_microsecs current_time = 0;

4751

4752

int pipefds[2];

4753

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

4754

4755

/* "sufficient to read at least one event." - inotify(7) */

4756

const size_t ievent_max_size = (sizeof(struct inotify_event)

4757

+ NAME_MAX + 1);

4758

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4759

struct {

4760

struct inotify_event event;

4761

char name_buffer[NAME_MAX + 1];

4762

} ievent_buffer;

4763

struct inotify_event *const ievent = &ievent_buffer.event;

4764

4765

const char dummy_file_name[] = "ignored.dummy_file_name";

4766

ievent->mask = IN_DELETE;

4767

ievent->len = sizeof(dummy_file_name);

4768

memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));

4769

const size_t ievent_size = (sizeof(struct inotify_event)

4770

+ sizeof(dummy_file_name));

4771

g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),

4772

==, ievent_size);

4773

g_assert_cmpint(close(pipefds[1]), ==, 0);

4774

4775

bool quit_now = false;

4776

buffer password = {};

4777

bool mandos_client_exited = false;

4778

bool password_is_read = false;

4779

__attribute__((cleanup(cleanup_queue)))

4780

task_queue *queue = create_queue();

4781

g_assert_nonnull(queue);

4782

4783

task_context task = {

4784

.func=read_inotify_event,

4785

.epoll_fd=epoll_fd,

4786

.fd=pipefds[0],

4787

.quit_now=&quit_now,

4788

.password=&password,

4789

.filename=strdup("/nonexistent"),

4790

.cancelled_filenames=&cancelled_filenames,

4791

.current_time=&current_time,

4792

.mandos_client_exited=&mandos_client_exited,

4793

.password_is_read=&password_is_read,

4794

};

4795

task.func(task, queue);

4796

g_assert_false(quit_now);

4797

g_assert_true(queue->next_run == 0);

4798

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

4799

4800

g_assert_nonnull(find_matching_task(queue, (task_context){

4801

.func=read_inotify_event,

4802

.epoll_fd=epoll_fd,

4803

.fd=pipefds[0],

4804

.quit_now=&quit_now,

4805

.password=&password,

4806

.filename=task.filename,

4807

.cancelled_filenames=&cancelled_filenames,

4808

.current_time=&current_time,

4809

.mandos_client_exited=&mandos_client_exited,

4810

.password_is_read=&password_is_read,

4811

}));

4812

4813

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4814

EPOLLIN | EPOLLRDHUP));

4815

4816

__attribute__((cleanup(cleanup_string)))

4817

char *filename = NULL;

4818

g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,

4819

dummy_file_name), >, 0);

4820

g_assert_nonnull(filename);

4821

g_assert_false(string_set_contains(cancelled_filenames, filename));

4822

}

4823

4824

static

4825

void test_open_and_parse_question_ENOENT(__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

bool mandos_client_exited = false;

4835

bool password_is_read = false;

4836

__attribute__((cleanup(cleanup_queue)))

4837

task_queue *queue = create_queue();

4838

g_assert_nonnull(queue);

4839

4840

char *const filename = strdup("/nonexistent");

4841

g_assert_nonnull(filename);

4842

task_context task = {

4843

.func=open_and_parse_question,

4844

.question_filename=filename,

4845

.epoll_fd=epoll_fd,

4846

.password=(buffer[]){{}},

4847

.filename=filename,

4848

.cancelled_filenames=&cancelled_filenames,

4849

.current_time=(mono_microsecs[]){0},

4850

.mandos_client_exited=&mandos_client_exited,

4851

.password_is_read=&password_is_read,

4852

};

4853

task.func(task, queue);

4854

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4855

}

4856

4857

static void test_open_and_parse_question_EIO(__attribute__((unused))

4858

test_fixture *fixture,

4859

__attribute__((unused))

4860

gconstpointer user_data){

4861

__attribute__((cleanup(cleanup_close)))

4862

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4863

g_assert_cmpint(epoll_fd, >=, 0);

4864

__attribute__((cleanup(string_set_clear)))

4865

string_set cancelled_filenames = {};

4866

buffer password = {};

4867

bool mandos_client_exited = false;

4868

bool password_is_read = false;

4869

__attribute__((cleanup(cleanup_queue)))

4870

task_queue *queue = create_queue();

4871

g_assert_nonnull(queue);

4872

const mono_microsecs current_time = 0;

4873

4874

char *filename = strdup("/proc/self/mem");

4875

task_context task = {

4876

.func=open_and_parse_question,

4877

.question_filename=filename,

4878

.epoll_fd=epoll_fd,

4879

.password=&password,

4880

.filename=filename,

4881

.cancelled_filenames=&cancelled_filenames,

4882

.current_time=&current_time,

4883

.mandos_client_exited=&mandos_client_exited,

4884

.password_is_read=&password_is_read,

4885

};

4886

run_task_with_stderr_to_dev_null(task, queue);

4887

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4888

}

4889

4890

static void

4891

test_open_and_parse_question_parse_error(__attribute__((unused))

4892

test_fixture *fixture,

4893

__attribute__((unused))

4894

gconstpointer user_data){

4895

__attribute__((cleanup(cleanup_close)))

4896

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4897

g_assert_cmpint(epoll_fd, >=, 0);

4898

__attribute__((cleanup(string_set_clear)))

4899

string_set cancelled_filenames = {};

4900

__attribute__((cleanup(cleanup_queue)))

4901

task_queue *queue = create_queue();

4902

g_assert_nonnull(queue);

4903

4904

__attribute__((cleanup(cleanup_string)))

4905

char *tempfilename = strdup("/tmp/mandosXXXXXX");

4906

g_assert_nonnull(tempfilename);

4907

int tempfile = mkostemp(tempfilename, O_CLOEXEC);

4908

g_assert_cmpint(tempfile, >, 0);

4909

const char bad_data[] = "this is bad syntax\n";

4910

g_assert_cmpint(write(tempfile, bad_data, sizeof(bad_data)),

4911

==, sizeof(bad_data));

4912

g_assert_cmpint(close(tempfile), ==, 0);

4913

4914

char *const filename = strdup(tempfilename);

4915

g_assert_nonnull(filename);

4916

task_context task = {

4917

.func=open_and_parse_question,

4918

.question_filename=filename,

4919

.epoll_fd=epoll_fd,

4920

.password=(buffer[]){{}},

4921

.filename=filename,

4922

.cancelled_filenames=&cancelled_filenames,

4923

.current_time=(mono_microsecs[]){0},

4924

.mandos_client_exited=(bool[]){false},

4925

.password_is_read=(bool[]){false},

4926

};

4927

run_task_with_stderr_to_dev_null(task, queue);

4928

4929

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4930

4931

g_assert_cmpint(unlink(tempfilename), ==, 0);

4932

}

4933

4934

static

4935

void test_open_and_parse_question_nosocket(__attribute__((unused))

4936

test_fixture *fixture,

4937

__attribute__((unused))

4938

gconstpointer user_data){

4939

__attribute__((cleanup(cleanup_close)))

4940

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4941

g_assert_cmpint(epoll_fd, >=, 0);

4942

__attribute__((cleanup(string_set_clear)))

4943

string_set cancelled_filenames = {};

4944

__attribute__((cleanup(cleanup_queue)))

4945

task_queue *queue = create_queue();

4946

g_assert_nonnull(queue);

4947

4948

__attribute__((cleanup(cleanup_string)))

4949

char *tempfilename = strdup("/tmp/mandosXXXXXX");

4950

g_assert_nonnull(tempfilename);

4951

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4952

g_assert_cmpint(questionfile, >, 0);

4953

FILE *qf = fdopen(questionfile, "w");

4954

g_assert_cmpint(fprintf(qf, "[Ask]\nPID=1\n"), >, 0);

4955

g_assert_cmpint(fclose(qf), ==, 0);

4956

4957

char *const filename = strdup(tempfilename);

4958

g_assert_nonnull(filename);

4959

task_context task = {

4960

.func=open_and_parse_question,

4961

.question_filename=filename,

4962

.epoll_fd=epoll_fd,

4963

.password=(buffer[]){{}},

4964

.filename=filename,

4965

.cancelled_filenames=&cancelled_filenames,

4966

.current_time=(mono_microsecs[]){0},

4967

.mandos_client_exited=(bool[]){false},

4968

.password_is_read=(bool[]){false},

4969

};

4970

run_task_with_stderr_to_dev_null(task, queue);

4971

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4972

4973

g_assert_cmpint(unlink(tempfilename), ==, 0);

4974

}

4975

4976

static

4977

void test_open_and_parse_question_badsocket(__attribute__((unused))

4978

test_fixture *fixture,

4979

__attribute__((unused))

4980

gconstpointer user_data){

4981

__attribute__((cleanup(cleanup_close)))

4982

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4983

g_assert_cmpint(epoll_fd, >=, 0);

4984

__attribute__((cleanup(string_set_clear)))

4985

string_set cancelled_filenames = {};

4986

__attribute__((cleanup(cleanup_queue)))

4987

task_queue *queue = create_queue();

4988

g_assert_nonnull(queue);

4989

4990

__attribute__((cleanup(cleanup_string)))

4991

char *tempfilename = strdup("/tmp/mandosXXXXXX");

4992

g_assert_nonnull(tempfilename);

4993

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4994

g_assert_cmpint(questionfile, >, 0);

4995

FILE *qf = fdopen(questionfile, "w");

4996

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=\nPID=1\n"), >, 0);

4997

g_assert_cmpint(fclose(qf), ==, 0);

4998

4999

char *const filename = strdup(tempfilename);

5000

g_assert_nonnull(filename);

5001

task_context task = {

5002

.func=open_and_parse_question,

5003

.question_filename=filename,

5004

.epoll_fd=epoll_fd,

5005

.password=(buffer[]){{}},

5006

.filename=filename,

5007

.cancelled_filenames=&cancelled_filenames,

5008

.current_time=(mono_microsecs[]){0},

5009

.mandos_client_exited=(bool[]){false},

5010

.password_is_read=(bool[]){false},

5011

};

5012

run_task_with_stderr_to_dev_null(task, queue);

5013

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5014

5015

g_assert_cmpint(unlink(tempfilename), ==, 0);

5016

}

5017

5018

static

5019

void test_open_and_parse_question_nopid(__attribute__((unused))

5020

test_fixture *fixture,

5021

__attribute__((unused))

5022

gconstpointer user_data){

5023

__attribute__((cleanup(cleanup_close)))

5024

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5025

g_assert_cmpint(epoll_fd, >=, 0);

5026

__attribute__((cleanup(string_set_clear)))

5027

string_set cancelled_filenames = {};

5028

__attribute__((cleanup(cleanup_queue)))

5029

task_queue *queue = create_queue();

5030

g_assert_nonnull(queue);

5031

5032

__attribute__((cleanup(cleanup_string)))

5033

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5034

g_assert_nonnull(tempfilename);

5035

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5036

g_assert_cmpint(questionfile, >, 0);

5037

FILE *qf = fdopen(questionfile, "w");

5038

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\n"), >, 0);

5039

g_assert_cmpint(fclose(qf), ==, 0);

5040

5041

char *const filename = strdup(tempfilename);

5042

g_assert_nonnull(filename);

5043

task_context task = {

5044

.func=open_and_parse_question,

5045

.question_filename=filename,

5046

.epoll_fd=epoll_fd,

5047

.password=(buffer[]){{}},

5048

.filename=filename,

5049

.cancelled_filenames=&cancelled_filenames,

5050

.current_time=(mono_microsecs[]){0},

5051

.mandos_client_exited=(bool[]){false},

5052

.password_is_read=(bool[]){false},

5053

};

5054

run_task_with_stderr_to_dev_null(task, queue);

5055

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5056

5057

g_assert_cmpint(unlink(tempfilename), ==, 0);

5058

}

5059

5060

static

5061

void test_open_and_parse_question_badpid(__attribute__((unused))

5062

test_fixture *fixture,

5063

__attribute__((unused))

5064

gconstpointer user_data){

5065

__attribute__((cleanup(cleanup_close)))

5066

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5067

g_assert_cmpint(epoll_fd, >=, 0);

5068

__attribute__((cleanup(string_set_clear)))

5069

string_set cancelled_filenames = {};

5070

__attribute__((cleanup(cleanup_queue)))

5071

task_queue *queue = create_queue();

5072

g_assert_nonnull(queue);

5073

5074

__attribute__((cleanup(cleanup_string)))

5075

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5076

g_assert_nonnull(tempfilename);

5077

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5078

g_assert_cmpint(questionfile, >, 0);

5079

FILE *qf = fdopen(questionfile, "w");

5080

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=\n"),

5081

>, 0);

5082

g_assert_cmpint(fclose(qf), ==, 0);

5083

5084

char *const filename = strdup(tempfilename);

5085

g_assert_nonnull(filename);

5086

task_context task = {

5087

.func=open_and_parse_question,

5088

.question_filename=filename,

5089

.epoll_fd=epoll_fd,

5090

.password=(buffer[]){{}},

5091

.filename=filename,

5092

.cancelled_filenames=&cancelled_filenames,

5093

.current_time=(mono_microsecs[]){0},

5094

.mandos_client_exited=(bool[]){false},

5095

.password_is_read=(bool[]){false},

5096

};

5097

run_task_with_stderr_to_dev_null(task, queue);

5098

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5099

5100

g_assert_cmpint(unlink(tempfilename), ==, 0);

5101

}

5102

5103

static void

5104

test_open_and_parse_question_noexist_pid(__attribute__((unused))

5105

test_fixture *fixture,

5106

__attribute__((unused))

5107

gconstpointer user_data){

5108

__attribute__((cleanup(cleanup_close)))

5109

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5110

g_assert_cmpint(epoll_fd, >=, 0);

5111

__attribute__((cleanup(string_set_clear)))

5112

string_set cancelled_filenames = {};

5113

buffer password = {};

5114

bool mandos_client_exited = false;

5115

bool password_is_read = false;

5116

__attribute__((cleanup(cleanup_queue)))

5117

task_queue *queue = create_queue();

5118

g_assert_nonnull(queue);

5119

const mono_microsecs current_time = 0;

5120

5121

/* Find value of sysctl kernel.pid_max */

5122

uintmax_t pid_max = 0;

5123

FILE *sysctl_pid_max = fopen("/proc/sys/kernel/pid_max", "r");

5124

g_assert_nonnull(sysctl_pid_max);

5125

g_assert_cmpint(fscanf(sysctl_pid_max, "%" PRIuMAX, &pid_max),

5126

==, 1);

5127

g_assert_cmpint(fclose(sysctl_pid_max), ==, 0);

5128

5129

pid_t nonexisting_pid = ((pid_t)pid_max)+1;

5130

g_assert_true(nonexisting_pid > 0); /* Overflow check */

5131

5132

__attribute__((cleanup(cleanup_string)))

5133

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5134

g_assert_nonnull(tempfilename);

5135

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5136

g_assert_cmpint(questionfile, >, 0);

5137

FILE *qf = fdopen(questionfile, "w");

5138

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5139

PRIuMAX"\n", (uintmax_t)nonexisting_pid),

5140

>, 0);

5141

g_assert_cmpint(fclose(qf), ==, 0);

5142

5143

char *const question_filename = strdup(tempfilename);

5144

g_assert_nonnull(question_filename);

5145

task_context task = {

5146

.func=open_and_parse_question,

5147

.question_filename=question_filename,

5148

.epoll_fd=epoll_fd,

5149

.password=&password,

5150

.filename=question_filename,

5151

.cancelled_filenames=&cancelled_filenames,

5152

.current_time=&current_time,

5153

.mandos_client_exited=&mandos_client_exited,

5154

.password_is_read=&password_is_read,

5155

};

5156

run_task_with_stderr_to_dev_null(task, queue);

5157

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5158

5159

g_assert_cmpint(unlink(tempfilename), ==, 0);

5160

}

5161

5162

static void

5163

test_open_and_parse_question_no_notafter(__attribute__((unused))

5164

test_fixture *fixture,

5165

__attribute__((unused))

5166

gconstpointer user_data){

5167

__attribute__((cleanup(cleanup_close)))

5168

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5169

g_assert_cmpint(epoll_fd, >=, 0);

5170

__attribute__((cleanup(string_set_clear)))

5171

string_set cancelled_filenames = {};

5172

buffer password = {};

5173

bool mandos_client_exited = false;

5174

bool password_is_read = false;

5175

__attribute__((cleanup(cleanup_queue)))

5176

task_queue *queue = create_queue();

5177

g_assert_nonnull(queue);

5178

const mono_microsecs current_time = 0;

5179

5180

__attribute__((cleanup(cleanup_string)))

5181

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5182

g_assert_nonnull(tempfilename);

5183

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5184

g_assert_cmpint(questionfile, >, 0);

5185

FILE *qf = fdopen(questionfile, "w");

5186

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5187

PRIuMAX "\n", (uintmax_t)getpid()), >, 0);

5188

g_assert_cmpint(fclose(qf), ==, 0);

5189

5190

char *const filename = strdup(tempfilename);

5191

g_assert_nonnull(filename);

5192

task_context task = {

5193

.func=open_and_parse_question,

5194

.question_filename=filename,

5195

.epoll_fd=epoll_fd,

5196

.password=&password,

5197

.filename=filename,

5198

.cancelled_filenames=&cancelled_filenames,

5199

.current_time=&current_time,

5200

.mandos_client_exited=&mandos_client_exited,

5201

.password_is_read=&password_is_read,

5202

};

5203

task.func(task, queue);

5204

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5205

5206

__attribute__((cleanup(cleanup_string)))

5207

char *socket_filename = strdup("/nonexistent");

5208

g_assert_nonnull(socket_filename);

5209

g_assert_nonnull(find_matching_task(queue, (task_context){

5210

.func=connect_question_socket,

5211

.question_filename=tempfilename,

5212

.filename=socket_filename,

5213

.epoll_fd=epoll_fd,

5214

.password=&password,

5215

.current_time=&current_time,

5216

.mandos_client_exited=&mandos_client_exited,

5217

.password_is_read=&password_is_read,

5218

}));

5219

5220

g_assert_true(queue->next_run != 0);

5221

5222

g_assert_cmpint(unlink(tempfilename), ==, 0);

5223

}

5224

5225

static void

5226

test_open_and_parse_question_bad_notafter(__attribute__((unused))

5227

test_fixture *fixture,

5228

__attribute__((unused))

5229

gconstpointer user_data){

5230

__attribute__((cleanup(cleanup_close)))

5231

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5232

g_assert_cmpint(epoll_fd, >=, 0);

5233

__attribute__((cleanup(string_set_clear)))

5234

string_set cancelled_filenames = {};

5235

buffer password = {};

5236

bool mandos_client_exited = false;

5237

bool password_is_read = false;

5238

__attribute__((cleanup(cleanup_queue)))

5239

task_queue *queue = create_queue();

5240

g_assert_nonnull(queue);

5241

const mono_microsecs current_time = 0;

5242

5243

__attribute__((cleanup(cleanup_string)))

5244

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5245

g_assert_nonnull(tempfilename);

5246

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5247

g_assert_cmpint(questionfile, >, 0);

5248

FILE *qf = fdopen(questionfile, "w");

5249

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5250

PRIuMAX "\nNotAfter=\n",

5251

(uintmax_t)getpid()), >, 0);

5252

g_assert_cmpint(fclose(qf), ==, 0);

5253

5254

char *const filename = strdup(tempfilename);

5255

g_assert_nonnull(filename);

5256

task_context task = {

5257

.func=open_and_parse_question,

5258

.question_filename=filename,

5259

.epoll_fd=epoll_fd,

5260

.password=&password,

5261

.filename=filename,

5262

.cancelled_filenames=&cancelled_filenames,

5263

.current_time=&current_time,

5264

.mandos_client_exited=&mandos_client_exited,

5265

.password_is_read=&password_is_read,

5266

};

5267

run_task_with_stderr_to_dev_null(task, queue);

5268

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5269

5270

__attribute__((cleanup(cleanup_string)))

5271

char *socket_filename = strdup("/nonexistent");

5272

g_assert_nonnull(find_matching_task(queue, (task_context){

5273

.func=connect_question_socket,

5274

.question_filename=tempfilename,

5275

.filename=socket_filename,

5276

.epoll_fd=epoll_fd,

5277

.password=&password,

5278

.current_time=&current_time,

5279

.mandos_client_exited=&mandos_client_exited,

5280

.password_is_read=&password_is_read,

5281

}));

5282

g_assert_true(queue->next_run != 0);

5283

5284

g_assert_cmpint(unlink(tempfilename), ==, 0);

5285

}

5286

5287

static

5288

void assert_open_and_parse_question_with_notafter(const mono_microsecs

5289

current_time,

5290

const mono_microsecs

5291

notafter,

5292

const mono_microsecs

5293

next_queue_run){

5294

__attribute__((cleanup(cleanup_close)))

5295

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5296

g_assert_cmpint(epoll_fd, >=, 0);

5297

__attribute__((cleanup(string_set_clear)))

5298

string_set cancelled_filenames = {};

5299

buffer password = {};

5300

bool mandos_client_exited = false;

5301

bool password_is_read = false;

5302

__attribute__((cleanup(cleanup_queue)))

5303

task_queue *queue = create_queue();

5304

g_assert_nonnull(queue);

5305

queue->next_run = next_queue_run;

5306

5307

__attribute__((cleanup(cleanup_string)))

5308

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5309

g_assert_nonnull(tempfilename);

5310

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5311

g_assert_cmpint(questionfile, >, 0);

5312

FILE *qf = fdopen(questionfile, "w");

5313

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5314

PRIuMAX "\nNotAfter=%" PRIuMAX "\n",

5315

(uintmax_t)getpid(), notafter), >, 0);

5316

g_assert_cmpint(fclose(qf), ==, 0);

5317

5318

char *const filename = strdup(tempfilename);

5319

g_assert_nonnull(filename);

5320

task_context task = {

5321

.func=open_and_parse_question,

5322

.question_filename=filename,

5323

.epoll_fd=epoll_fd,

5324

.password=&password,

5325

.filename=filename,

5326

.cancelled_filenames=&cancelled_filenames,

5327

.current_time=&current_time,

5328

.mandos_client_exited=&mandos_client_exited,

5329

.password_is_read=&password_is_read,

5330

};

5331

task.func(task, queue);

5332

5333

if(queue->length >= 1){

5334

__attribute__((cleanup(cleanup_string)))

5335

char *socket_filename = strdup("/nonexistent");

5336

g_assert_nonnull(find_matching_task(queue, (task_context){

5337

.func=connect_question_socket,

5338

.filename=socket_filename,

5339

.epoll_fd=epoll_fd,

5340

.password=&password,

5341

.current_time=&current_time,

5342

.cancelled_filenames=&cancelled_filenames,

5343

.mandos_client_exited=&mandos_client_exited,

5344

.password_is_read=&password_is_read,

5345

}));

5346

g_assert_true(queue->next_run != 0);

5347

}

5348

5349

if(notafter == 0){

5350

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5351

} else if(current_time >= notafter) {

5352

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5353

} else {

5354

g_assert_nonnull(find_matching_task(queue, (task_context){

5355

.func=cancel_old_question,

5356

.question_filename=tempfilename,

5357

.filename=tempfilename,

5358

.notafter=notafter,

5359

.cancelled_filenames=&cancelled_filenames,

5360

.current_time=&current_time,

5361

}));

5362

}

5363

g_assert_true(queue->next_run == 1);

5364

5365

g_assert_cmpint(unlink(tempfilename), ==, 0);

5366

}

5367

5368

static void

5369

test_open_and_parse_question_notafter_0(__attribute__((unused))

5370

test_fixture *fixture,

5371

__attribute__((unused))

5372

gconstpointer user_data){

5373

/* current_time, notafter, next_queue_run */

5374

assert_open_and_parse_question_with_notafter(0, 0, 0);

5375

}

5376

5377

static void

5378

test_open_and_parse_question_notafter_1(__attribute__((unused))

5379

test_fixture *fixture,

5380

__attribute__((unused))

5381

gconstpointer user_data){

5382

/* current_time, notafter, next_queue_run */

5383

assert_open_and_parse_question_with_notafter(0, 1, 0);

5384

}

5385

5386

static void

5387

test_open_and_parse_question_notafter_1_1(__attribute__((unused))

5388

test_fixture *fixture,

5389

__attribute__((unused))

5390

gconstpointer user_data){

5391

/* current_time, notafter, next_queue_run */

5392

assert_open_and_parse_question_with_notafter(0, 1, 1);

5393

}

5394

5395

static void

5396

test_open_and_parse_question_notafter_1_2(__attribute__((unused))

5397

test_fixture *fixture,

5398

__attribute__((unused))

5399

gconstpointer user_data){

5400

/* current_time, notafter, next_queue_run */

5401

assert_open_and_parse_question_with_notafter(0, 1, 2);

5402

}

5403

5404

static void

5405

test_open_and_parse_question_equal_notafter(__attribute__((unused))

5406

test_fixture *fixture,

5407

__attribute__((unused))

5408

gconstpointer user_data){

5409

/* current_time, notafter, next_queue_run */

5410

assert_open_and_parse_question_with_notafter(1, 1, 0);

5411

}

5412

5413

static void

5414

test_open_and_parse_question_late_notafter(__attribute__((unused))

5415

test_fixture *fixture,

5416

__attribute__((unused))

5417

gconstpointer user_data){

5418

/* current_time, notafter, next_queue_run */

5419

assert_open_and_parse_question_with_notafter(2, 1, 0);

5420

}

5421

5422

static void assert_cancel_old_question_param(const mono_microsecs

5423

next_queue_run,

5424

const mono_microsecs

5425

notafter,

5426

const mono_microsecs

5427

current_time,

5428

const mono_microsecs

5429

next_set_to){

5430

__attribute__((cleanup(string_set_clear)))

5431

string_set cancelled_filenames = {};

5432

__attribute__((cleanup(cleanup_queue)))

5433

task_queue *queue = create_queue();

5434

g_assert_nonnull(queue);

5435

queue->next_run = next_queue_run;

5436

5437

char *const question_filename = strdup("/nonexistent");

5438

g_assert_nonnull(question_filename);

5439

task_context task = {

5440

.func=cancel_old_question,

5441

.question_filename=question_filename,

5442

.filename=question_filename,

5443

.notafter=notafter,

5444

.cancelled_filenames=&cancelled_filenames,

5445

.current_time=&current_time,

5446

};

5447

task.func(task, queue);

5448

5449

if(current_time >= notafter){

5450

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5451

g_assert_true(string_set_contains(cancelled_filenames,

5452

"/nonexistent"));

5453

} else {

5454

g_assert_nonnull(find_matching_task(queue, (task_context){

5455

.func=cancel_old_question,

5456

.question_filename=question_filename,

5457

.filename=question_filename,

5458

.notafter=notafter,

5459

.cancelled_filenames=&cancelled_filenames,

5460

.current_time=&current_time,

5461

}));

5462

5463

g_assert_false(string_set_contains(cancelled_filenames,

5464

question_filename));

5465

}

5466

g_assert_cmpuint((unsigned int)queue->next_run, ==,

5467

(unsigned int)next_set_to);

5468

}

5469

5470

static void test_cancel_old_question_0_1_2(__attribute__((unused))

5471

test_fixture *fixture,

5472

__attribute__((unused))

5473

gconstpointer user_data){

5474

/* next_queue_run unset,

5475

cancellation should happen because time has come,

5476

next_queue_run should be unchanged */

5477

/* next_queue_run, notafter, current_time, next_set_to */

5478

assert_cancel_old_question_param(0, 1, 2, 0);

5479

}

5480

5481

static void test_cancel_old_question_0_2_1(__attribute__((unused))

5482

test_fixture *fixture,

5483

__attribute__((unused))

5484

gconstpointer user_data){

5485

/* If next_queue_run is 0, meaning unset, and notafter is 2,

5486

and current_time is not yet notafter or greater,

5487

update value of next_queue_run to value of notafter */

5488

/* next_queue_run, notafter, current_time, next_set_to */

5489

assert_cancel_old_question_param(0, 2, 1, 2);

5490

}

5491

5492

static void test_cancel_old_question_1_2_3(__attribute__((unused))

5493

test_fixture *fixture,

5494

__attribute__((unused))

5495

gconstpointer user_data){

5496

/* next_queue_run 1,

5497

cancellation should happen because time has come,

5498

next_queue_run should be unchanged */

5499

/* next_queue_run, notafter, current_time, next_set_to */

5500

assert_cancel_old_question_param(1, 2, 3, 1);

5501

}

5502

5503

static void test_cancel_old_question_1_3_2(__attribute__((unused))

5504

test_fixture *fixture,

5505

__attribute__((unused))

5506

gconstpointer user_data){

5507

/* If next_queue_run is set,

5508

and current_time is not yet notafter or greater,

5509

and notafter is larger than next_queue_run

5510

next_queue_run should be unchanged */

5511

/* next_queue_run, notafter, current_time, next_set_to */

5512

assert_cancel_old_question_param(1, 3, 2, 1);

5513

}

5514

5515

static void test_cancel_old_question_2_1_3(__attribute__((unused))

5516

test_fixture *fixture,

5517

__attribute__((unused))

5518

gconstpointer user_data){

5519

/* next_queue_run 2,

5520

cancellation should happen because time has come,

5521

next_queue_run should be unchanged */

5522

/* next_queue_run, notafter, current_time, next_set_to */

5523

assert_cancel_old_question_param(2, 1, 3, 2);

5524

}

5525

5526

static void test_cancel_old_question_2_3_1(__attribute__((unused))

5527

test_fixture *fixture,

5528

__attribute__((unused))

5529

gconstpointer user_data){

5530

/* If next_queue_run is set,

5531

and current_time is not yet notafter or greater,

5532

and notafter is larger than next_queue_run

5533

next_queue_run should be unchanged */

5534

/* next_queue_run, notafter, current_time, next_set_to */

5535

assert_cancel_old_question_param(2, 3, 1, 2);

5536

}

5537

5538

static void test_cancel_old_question_3_1_2(__attribute__((unused))

5539

test_fixture *fixture,

5540

__attribute__((unused))

5541

gconstpointer user_data){

5542

/* next_queue_run 3,

5543

cancellation should happen because time has come,

5544

next_queue_run should be unchanged */

5545

/* next_queue_run, notafter, current_time, next_set_to */

5546

assert_cancel_old_question_param(3, 1, 2, 3);

5547

}

5548

5549

static void test_cancel_old_question_3_2_1(__attribute__((unused))

5550

test_fixture *fixture,

5551

__attribute__((unused))

5552

gconstpointer user_data){

5553

/* If next_queue_run is set,

5554

and current_time is not yet notafter or greater,

5555

and notafter is smaller than next_queue_run

5556

update value of next_queue_run to value of notafter */

5557

/* next_queue_run, notafter, current_time, next_set_to */

5558

assert_cancel_old_question_param(3, 2, 1, 2);

5559

}

5560

5561

static void

5562

test_connect_question_socket_name_too_long(__attribute__((unused))

5563

test_fixture *fixture,

5564

__attribute__((unused))

5565

gconstpointer user_data){

5566

__attribute__((cleanup(cleanup_close)))

5567

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5568

g_assert_cmpint(epoll_fd, >=, 0);

5569

const char question_filename[] = "/nonexistent/question";

5570

__attribute__((cleanup(string_set_clear)))

5571

string_set cancelled_filenames = {};

5572

__attribute__((cleanup(cleanup_queue)))

5573

task_queue *queue = create_queue();

5574

g_assert_nonnull(queue);

5575

__attribute__((cleanup(cleanup_string)))

5576

char *tempdir = make_temporary_directory();

5577

g_assert_nonnull(tempdir);

5578

struct sockaddr_un unix_socket = { .sun_family=AF_LOCAL };

5579

char socket_name[sizeof(unix_socket.sun_path)];

5580

memset(socket_name, 'x', sizeof(socket_name));

5581

socket_name[sizeof(socket_name)-1] = '\0';

5582

char *filename = NULL;

5583

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5584

>, 0);

5585

g_assert_nonnull(filename);

5586

5587

task_context task = {

5588

.func=connect_question_socket,

5589

.question_filename=strdup(question_filename),

5590

.epoll_fd=epoll_fd,

5591

.password=(buffer[]){{}},

5592

.filename=filename,

5593

.cancelled_filenames=&cancelled_filenames,

5594

.mandos_client_exited=(bool[]){false},

5595

.password_is_read=(bool[]){false},

5596

.current_time=(mono_microsecs[]){0},

5597

};

5598

g_assert_nonnull(task.question_filename);

5599

run_task_with_stderr_to_dev_null(task, queue);

5600

5601

g_assert_true(string_set_contains(cancelled_filenames,

5602

question_filename));

5603

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5604

g_assert_true(queue->next_run == 0);

5605

5606

g_assert_cmpint(rmdir(tempdir), ==, 0);

5607

}

5608

5609

static

5610

void test_connect_question_socket_connect_fail(__attribute__((unused))

5611

test_fixture *fixture,

5612

__attribute__((unused))

5613

gconstpointer

5614

user_data){

5615

__attribute__((cleanup(cleanup_close)))

5616

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5617

g_assert_cmpint(epoll_fd, >=, 0);

5618

const char question_filename[] = "/nonexistent/question";

5619

__attribute__((cleanup(string_set_clear)))

5620

string_set cancelled_filenames = {};

5621

const mono_microsecs current_time = 3;

5622

__attribute__((cleanup(cleanup_queue)))

5623

task_queue *queue = create_queue();

5624

g_assert_nonnull(queue);

5625

__attribute__((cleanup(cleanup_string)))

5626

char *tempdir = make_temporary_directory();

5627

g_assert_nonnull(tempdir);

5628

char socket_name[] = "nonexistent";

5629

char *filename = NULL;

5630

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5631

>, 0);

5632

g_assert_nonnull(filename);

5633

5634

task_context task = {

5635

.func=connect_question_socket,

5636

.question_filename=strdup(question_filename),

5637

.epoll_fd=epoll_fd,

5638

.password=(buffer[]){{}},

5639

.filename=filename,

5640

.cancelled_filenames=&cancelled_filenames,

5641

.mandos_client_exited=(bool[]){false},

5642

.password_is_read=(bool[]){false},

5643

.current_time=&current_time,

5644

};

5645

g_assert_nonnull(task.question_filename);

5646

run_task_with_stderr_to_dev_null(task, queue);

5647

5648

g_assert_nonnull(find_matching_task(queue, task));

5649

5650

g_assert_false(string_set_contains(cancelled_filenames,

5651

question_filename));

5652

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5653

g_assert_true(queue->next_run == 1000000 + current_time);

5654

5655

g_assert_cmpint(rmdir(tempdir), ==, 0);

5656

}

5657

5658

static

5659

void test_connect_question_socket_bad_epoll(__attribute__((unused))

5660

test_fixture *fixture,

5661

__attribute__((unused))

5662

gconstpointer user_data){

5663

__attribute__((cleanup(cleanup_close)))

5664

const int epoll_fd = open("/dev/null",

5665

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5666

__attribute__((cleanup(cleanup_string)))

5667

char *const question_filename = strdup("/nonexistent/question");

5668

g_assert_nonnull(question_filename);

5669

__attribute__((cleanup(string_set_clear)))

5670

string_set cancelled_filenames = {};

5671

const mono_microsecs current_time = 5;

5672

__attribute__((cleanup(cleanup_queue)))

5673

task_queue *queue = create_queue();

5674

g_assert_nonnull(queue);

5675

__attribute__((cleanup(cleanup_string)))

5676

char *tempdir = make_temporary_directory();

5677

g_assert_nonnull(tempdir);

5678

__attribute__((cleanup(cleanup_close)))

5679

const int sock_fd = socket(PF_LOCAL, SOCK_DGRAM

5680

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

5681

g_assert_cmpint(sock_fd, >=, 0);

5682

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

5683

const char socket_name[] = "socket_name";

5684

__attribute__((cleanup(cleanup_string)))

5685

char *filename = NULL;

5686

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5687

>, 0);

5688

g_assert_nonnull(filename);

5689

g_assert_cmpint((int)strlen(filename), <,

5690

(int)sizeof(sock_name.sun_path));

5691

strncpy(sock_name.sun_path, filename, sizeof(sock_name.sun_path));

5692

sock_name.sun_path[sizeof(sock_name.sun_path)-1] = '\0';

5693

g_assert_cmpint((int)bind(sock_fd, (struct sockaddr *)&sock_name,

5694

(socklen_t)SUN_LEN(&sock_name)), >=, 0);

5695

task_context task = {

5696

.func=connect_question_socket,

5697

.question_filename=strdup(question_filename),

5698

.epoll_fd=epoll_fd,

5699

.password=(buffer[]){{}},

5700

.filename=strdup(filename),

5701

.cancelled_filenames=&cancelled_filenames,

5702

.mandos_client_exited=(bool[]){false},

5703

.password_is_read=(bool[]){false},

5704

.current_time=&current_time,

5705

};

5706

g_assert_nonnull(task.question_filename);

5707

run_task_with_stderr_to_dev_null(task, queue);

5708

5709

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5710

const task_context *const added_task

5711

= find_matching_task(queue, task);

5712

g_assert_nonnull(added_task);

5713

g_assert_true(queue->next_run == 1000000 + current_time);

5714

5715

g_assert_cmpint(unlink(filename), ==, 0);

5716

g_assert_cmpint(rmdir(tempdir), ==, 0);

5717

}

5718

5719

static

5720

void test_connect_question_socket_usable(__attribute__((unused))

5721

test_fixture *fixture,

5722

__attribute__((unused))

5723

gconstpointer user_data){

5724

__attribute__((cleanup(cleanup_close)))

5725

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5726

g_assert_cmpint(epoll_fd, >=, 0);

5727

__attribute__((cleanup(cleanup_string)))

5728

char *const question_filename = strdup("/nonexistent/question");

5729

g_assert_nonnull(question_filename);

5730

__attribute__((cleanup(string_set_clear)))

5731

string_set cancelled_filenames = {};

5732

buffer password = {};

5733

bool mandos_client_exited = false;

5734

bool password_is_read = false;

5735

const mono_microsecs current_time = 0;

5736

__attribute__((cleanup(cleanup_queue)))

5737

task_queue *queue = create_queue();

5738

g_assert_nonnull(queue);

5739

__attribute__((cleanup(cleanup_string)))

5740

char *tempdir = make_temporary_directory();

5741

g_assert_nonnull(tempdir);

5742

__attribute__((cleanup(cleanup_close)))

5743

const int sock_fd = socket(PF_LOCAL, SOCK_DGRAM

5744

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

5745

g_assert_cmpint(sock_fd, >=, 0);

5746

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

5747

const char socket_name[] = "socket_name";

5748

__attribute__((cleanup(cleanup_string)))

5749

char *filename = NULL;

5750

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5751

>, 0);

5752

g_assert_nonnull(filename);

5753

g_assert_cmpint((int)strlen(filename), <,

5754

(int)sizeof(sock_name.sun_path));

5755

strncpy(sock_name.sun_path, filename, sizeof(sock_name.sun_path));

5756

sock_name.sun_path[sizeof(sock_name.sun_path)-1] = '\0';

5757

g_assert_cmpint((int)bind(sock_fd, (struct sockaddr *)&sock_name,

5758

(socklen_t)SUN_LEN(&sock_name)), >=, 0);

5759

task_context task = {

5760

.func=connect_question_socket,

5761

.question_filename=strdup(question_filename),

5762

.epoll_fd=epoll_fd,

5763

.password=&password,

5764

.filename=strdup(filename),

5765

.cancelled_filenames=&cancelled_filenames,

5766

.mandos_client_exited=&mandos_client_exited,

5767

.password_is_read=&password_is_read,

5768

.current_time=&current_time,

5769

};

5770

g_assert_nonnull(task.question_filename);

5771

task.func(task, queue);

5772

5773

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5774

const task_context *const added_task

5775

= find_matching_task(queue, (task_context){

5776

.func=send_password_to_socket,

5777

.question_filename=question_filename,

5778

.filename=filename,

5779

.epoll_fd=epoll_fd,

5780

.password=&password,

5781

.cancelled_filenames=&cancelled_filenames,

5782

.mandos_client_exited=&mandos_client_exited,

5783

.password_is_read=&password_is_read,

5784

.current_time=&current_time,

5785

});

5786

g_assert_nonnull(added_task);

5787

g_assert_cmpint(added_task->fd, >, 0);

5788

5789

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5790

EPOLLOUT));

5791

5792

const int fd = added_task->fd;

5793

g_assert_cmpint(fd, >, 0);

5794

g_assert_true(fd_has_cloexec_and_nonblock(fd));

5795

5796

/* write to fd */

5797

char write_data[PIPE_BUF];

5798

{

5799

/* Construct test password buffer */

5800

/* Start with + since that is what the real procotol uses */

5801

write_data[0] = '+';

5802

/* Set a special character at string end just to mark the end */

5803

write_data[sizeof(write_data)-2] = 'y';

5804

/* Set NUL at buffer end, as suggested by the protocol */

5805

write_data[sizeof(write_data)-1] = '\0';

5806

/* Fill rest of password with 'x' */

5807

memset(write_data+1, 'x', sizeof(write_data)-3);

5808

g_assert_cmpint((int)send(fd, write_data, sizeof(write_data),

5809

MSG_NOSIGNAL), ==, sizeof(write_data));

5810

}

5811

5812

/* read from sock_fd */

5813

char read_data[sizeof(write_data)];

5814

g_assert_cmpint((int)read(sock_fd, read_data, sizeof(read_data)),

5815

==, sizeof(read_data));

5816

5817

g_assert_true(memcmp(write_data, read_data, sizeof(write_data))

5818

== 0);

5819

5820

/* writing to sock_fd should fail */

5821

g_assert_cmpint(send(sock_fd, write_data, sizeof(write_data),

5822

MSG_NOSIGNAL), <, 0);

5823

5824

/* reading from fd should fail */

5825

g_assert_cmpint((int)recv(fd, read_data, sizeof(read_data),

5826

MSG_NOSIGNAL), <, 0);

5827

5828

g_assert_cmpint(unlink(filename), ==, 0);

5829

g_assert_cmpint(rmdir(tempdir), ==, 0);

5830

}

5831

5832

static void

5833

test_send_password_to_socket_client_not_exited(__attribute__((unused))

5834

test_fixture *fixture,

5835

__attribute__((unused))

5836

gconstpointer

5837

user_data){

5838

__attribute__((cleanup(cleanup_close)))

5839

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5840

g_assert_cmpint(epoll_fd, >=, 0);

5841

__attribute__((cleanup(cleanup_string)))

5842

char *const question_filename = strdup("/nonexistent/question");

5843

g_assert_nonnull(question_filename);

5844

__attribute__((cleanup(cleanup_string)))

5845

char *const filename = strdup("/nonexistent/socket");

5846

g_assert_nonnull(filename);

5847

__attribute__((cleanup(string_set_clear)))

5848

string_set cancelled_filenames = {};

5849

buffer password = {};

5850

bool password_is_read = true;

5851

__attribute__((cleanup(cleanup_queue)))

5852

task_queue *queue = create_queue();

5853

g_assert_nonnull(queue);

5854

int socketfds[2];

5855

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5856

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5857

socketfds), ==, 0);

5858

__attribute__((cleanup(cleanup_close)))

5859

const int read_socket = socketfds[0];

5860

const int write_socket = socketfds[1];

5861

task_context task = {

5862

.func=send_password_to_socket,

5863

.question_filename=strdup(question_filename),

5864

.filename=strdup(filename),

5865

.epoll_fd=epoll_fd,

5866

.fd=write_socket,

5867

.password=&password,

5868

.cancelled_filenames=&cancelled_filenames,

5869

.mandos_client_exited=(bool[]){false},

5870

.password_is_read=&password_is_read,

5871

.current_time=(mono_microsecs[]){0},

5872

};

5873

g_assert_nonnull(task.question_filename);

5874

5875

task.func(task, queue);

5876

5877

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5878

5879

const task_context *const added_task

5880

= find_matching_task(queue, task);

5881

g_assert_nonnull(added_task);

5882

g_assert_cmpuint((unsigned int)password.length, ==, 0);

5883

g_assert_true(password_is_read);

5884

5885

g_assert_cmpint(added_task->fd, >, 0);

5886

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5887

EPOLLOUT));

5888

}

5889

5890

static void

5891

test_send_password_to_socket_password_not_read(__attribute__((unused))

5892

test_fixture *fixture,

5893

__attribute__((unused))

5894

gconstpointer

5895

user_data){

5896

__attribute__((cleanup(cleanup_close)))

5897

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5898

g_assert_cmpint(epoll_fd, >=, 0);

5899

__attribute__((cleanup(cleanup_string)))

5900

char *const question_filename = strdup("/nonexistent/question");

5901

g_assert_nonnull(question_filename);

5902

__attribute__((cleanup(cleanup_string)))

5903

char *const filename = strdup("/nonexistent/socket");

5904

__attribute__((cleanup(string_set_clear)))

5905

string_set cancelled_filenames = {};

5906

buffer password = {};

5907

__attribute__((cleanup(cleanup_queue)))

5908

task_queue *queue = create_queue();

5909

g_assert_nonnull(queue);

5910

int socketfds[2];

5911

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5912

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5913

socketfds), ==, 0);

5914

__attribute__((cleanup(cleanup_close)))

5915

const int read_socket = socketfds[0];

5916

const int write_socket = socketfds[1];

5917

task_context task = {

5918

.func=send_password_to_socket,

5919

.question_filename=strdup(question_filename),

5920

.filename=strdup(filename),

5921

.epoll_fd=epoll_fd,

5922

.fd=write_socket,

5923

.password=&password,

5924

.cancelled_filenames=&cancelled_filenames,

5925

.mandos_client_exited=(bool[]){false},

5926

.password_is_read=(bool[]){false},

5927

.current_time=(mono_microsecs[]){0},

5928

};

5929

g_assert_nonnull(task.question_filename);

5930

5931

task.func(task, queue);

5932

5933

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5934

5935

const task_context *const added_task = find_matching_task(queue,

5936

task);

5937

g_assert_nonnull(added_task);

5938

g_assert_cmpuint((unsigned int)password.length, ==, 0);

5939

g_assert_true(queue->next_run == 0);

5940

5941

g_assert_cmpint(added_task->fd, >, 0);

5942

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5943

EPOLLOUT));

5944

}

5945

5946

static

5947

void test_send_password_to_socket_EMSGSIZE(__attribute__((unused))

5948

test_fixture *fixture,

5949

__attribute__((unused))

5950

gconstpointer user_data){

5951

__attribute__((cleanup(cleanup_close)))

5952

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5953

g_assert_cmpint(epoll_fd, >=, 0);

5954

const char question_filename[] = "/nonexistent/question";

5955

char *const filename = strdup("/nonexistent/socket");

5956

__attribute__((cleanup(string_set_clear)))

5957

string_set cancelled_filenames = {};

5958

const size_t oversized = 1024*1024; /* Limit seems to be 212960 */

5959

__attribute__((cleanup(cleanup_buffer)))

5960

buffer password = {

5961

.data=malloc(oversized),

5962

.length=oversized,

5963

.allocated=oversized,

5964

};

5965

g_assert_nonnull(password.data);

5966

if(mlock(password.data, password.allocated) != 0){

5967

g_assert_true(errno == EPERM or errno == ENOMEM);

5968

}

5969

/* Construct test password buffer */

5970

/* Start with + since that is what the real procotol uses */

5971

password.data[0] = '+';

5972

/* Set a special character at string end just to mark the end */

5973

password.data[oversized-3] = 'y';

5974

/* Set NUL at buffer end, as suggested by the protocol */

5975

password.data[oversized-2] = '\0';

5976

/* Fill rest of password with 'x' */

5977

memset(password.data+1, 'x', oversized-3);

5978

5979

__attribute__((cleanup(cleanup_queue)))

5980

task_queue *queue = create_queue();

5981

g_assert_nonnull(queue);

5982

int socketfds[2];

5983

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5984

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5985

socketfds), ==, 0);

5986

__attribute__((cleanup(cleanup_close)))

5987

const int read_socket = socketfds[0];

5988

__attribute__((cleanup(cleanup_close)))

5989

const int write_socket = socketfds[1];

5990

task_context task = {

5991

.func=send_password_to_socket,

5992

.question_filename=strdup(question_filename),

5993

.filename=filename,

5994

.epoll_fd=epoll_fd,

5995

.fd=write_socket,

5996

.password=&password,

5997

.cancelled_filenames=&cancelled_filenames,

5998

.mandos_client_exited=(bool[]){true},

5999

.password_is_read=(bool[]){true},

6000

.current_time=(mono_microsecs[]){0},

6001

};

6002

g_assert_nonnull(task.question_filename);

6003

6004

run_task_with_stderr_to_dev_null(task, queue);

6005

6006

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6007

g_assert_true(string_set_contains(cancelled_filenames,

6008

question_filename));

6009

}

6010

6011

static void test_send_password_to_socket_retry(__attribute__((unused))

6012

test_fixture *fixture,

6013

__attribute__((unused))

6014

gconstpointer

6015

user_data){

6016

__attribute__((cleanup(cleanup_close)))

6017

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6018

g_assert_cmpint(epoll_fd, >=, 0);

6019

__attribute__((cleanup(cleanup_string)))

6020

char *const question_filename = strdup("/nonexistent/question");

6021

g_assert_nonnull(question_filename);

6022

__attribute__((cleanup(cleanup_string)))

6023

char *const filename = strdup("/nonexistent/socket");

6024

g_assert_nonnull(filename);

6025

__attribute__((cleanup(string_set_clear)))

6026

string_set cancelled_filenames = {};

6027

__attribute__((cleanup(cleanup_buffer)))

6028

buffer password = {};

6029

6030

__attribute__((cleanup(cleanup_queue)))

6031

task_queue *queue = create_queue();

6032

g_assert_nonnull(queue);

6033

int socketfds[2];

6034

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6035

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6036

socketfds), ==, 0);

6037

__attribute__((cleanup(cleanup_close)))

6038

const int read_socket = socketfds[0];

6039

const int write_socket = socketfds[1];

6040

/* Close the server side socket to force ECONNRESET on client */

6041

g_assert_cmpint(close(read_socket), ==, 0);

6042

task_context task = {

6043

.func=send_password_to_socket,

6044

.question_filename=strdup(question_filename),

6045

.filename=strdup(filename),

6046

.epoll_fd=epoll_fd,

6047

.fd=write_socket,

6048

.password=&password,

6049

.cancelled_filenames=&cancelled_filenames,

6050

.mandos_client_exited=(bool[]){true},

6051

.password_is_read=(bool[]){true},

6052

.current_time=(mono_microsecs[]){0},

6053

};

6054

g_assert_nonnull(task.question_filename);

6055

6056

task.func(task, queue);

6057

6058

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6059

6060

const task_context *const added_task = find_matching_task(queue,

6061

task);

6062

g_assert_nonnull(added_task);

6063

g_assert_cmpuint((unsigned int)password.length, ==, 0);

6064

6065

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

6066

EPOLLOUT));

6067

}

6068

6069

static

6070

void test_send_password_to_socket_bad_epoll(__attribute__((unused))

6071

test_fixture *fixture,

6072

__attribute__((unused))

6073

gconstpointer user_data){

6074

__attribute__((cleanup(cleanup_close)))

6075

const int epoll_fd = open("/dev/null",

6076

O_WRONLY | O_CLOEXEC | O_NOCTTY);

6077

__attribute__((cleanup(cleanup_string)))

6078

char *const question_filename = strdup("/nonexistent/question");

6079

g_assert_nonnull(question_filename);

6080

__attribute__((cleanup(cleanup_string)))

6081

char *const filename = strdup("/nonexistent/socket");

6082

g_assert_nonnull(filename);

6083

__attribute__((cleanup(string_set_clear)))

6084

string_set cancelled_filenames = {};

6085

__attribute__((cleanup(cleanup_buffer)))

6086

buffer password = {};

6087

6088

const mono_microsecs current_time = 11;

6089

__attribute__((cleanup(cleanup_queue)))

6090

task_queue *queue = create_queue();

6091

g_assert_nonnull(queue);

6092

int socketfds[2];

6093

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6094

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6095

socketfds), ==, 0);

6096

__attribute__((cleanup(cleanup_close)))

6097

const int read_socket = socketfds[0];

6098

const int write_socket = socketfds[1];

6099

/* Close the server side socket to force ECONNRESET on client */

6100

g_assert_cmpint(close(read_socket), ==, 0);

6101

task_context task = {

6102

.func=send_password_to_socket,

6103

.question_filename=strdup(question_filename),

6104

.filename=strdup(filename),

6105

.epoll_fd=epoll_fd,

6106

.fd=write_socket,

6107

.password=&password,

6108

.cancelled_filenames=&cancelled_filenames,

6109

.mandos_client_exited=(bool[]){true},

6110

.password_is_read=(bool[]){true},

6111

.current_time=&current_time,

6112

};

6113

g_assert_nonnull(task.question_filename);

6114

6115

run_task_with_stderr_to_dev_null(task, queue);

6116

6117

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6118

6119

const task_context *const added_task = find_matching_task(queue,

6120

task);

6121

g_assert_nonnull(added_task);

6122

g_assert_true(queue->next_run == current_time + 1000000);

6123

g_assert_cmpuint((unsigned int)password.length, ==, 0);

6124

}

6125

6126

static void assert_send_password_to_socket_password(buffer password){

6127

__attribute__((cleanup(cleanup_close)))

6128

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6129

g_assert_cmpint(epoll_fd, >=, 0);

6130

char *const question_filename = strdup("/nonexistent/question");

6131

g_assert_nonnull(question_filename);

6132

char *const filename = strdup("/nonexistent/socket");

6133

g_assert_nonnull(filename);

6134

__attribute__((cleanup(string_set_clear)))

6135

string_set cancelled_filenames = {};

6136

6137

__attribute__((cleanup(cleanup_queue)))

6138

task_queue *queue = create_queue();

6139

g_assert_nonnull(queue);

6140

int socketfds[2];

6141

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6142

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6143

socketfds), ==, 0);

6144

__attribute__((cleanup(cleanup_close)))

6145

const int read_socket = socketfds[0];

6146

const int write_socket = socketfds[1];

6147

task_context task = {

6148

.func=send_password_to_socket,

6149

.question_filename=question_filename,

6150

.filename=filename,

6151

.epoll_fd=epoll_fd,

6152

.fd=write_socket,

6153

.password=&password,

6154

.cancelled_filenames=&cancelled_filenames,

6155

.mandos_client_exited=(bool[]){true},

6156

.password_is_read=(bool[]){true},

6157

.current_time=(mono_microsecs[]){0},

6158

};

6159

6160

char *expected_written_data = malloc(password.length + 2);

6161

g_assert_nonnull(expected_written_data);

6162

expected_written_data[0] = '+';

6163

expected_written_data[password.length + 1] = '\0';

6164

if(password.length > 0){

6165

g_assert_nonnull(password.data);

6166

memcpy(expected_written_data + 1, password.data, password.length);

6167

}

6168

6169

task.func(task, queue);

6170

6171

char buf[PIPE_BUF];

6172

g_assert_cmpint((int)read(read_socket, buf, PIPE_BUF), ==,

6173

(int)(password.length + 2));

6174

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6175

6176

g_assert_true(memcmp(expected_written_data, buf,

6177

password.length + 2) == 0);

6178

6179

g_assert_true(epoll_set_does_not_contain(epoll_fd, write_socket));

6180

6181

free(expected_written_data);

6182

}

6183

6184

static void

6185

test_send_password_to_socket_null_password(__attribute__((unused))

6186

test_fixture *fixture,

6187

__attribute__((unused))

6188

gconstpointer user_data){

6189

__attribute__((cleanup(cleanup_buffer)))

6190

buffer password = {};

6191

assert_send_password_to_socket_password(password);

6192

}

6193

6194

static void

6195

test_send_password_to_socket_empty_password(__attribute__((unused))

6196

test_fixture *fixture,

6197

__attribute__((unused))

6198

gconstpointer user_data){

6199

__attribute__((cleanup(cleanup_buffer)))

6200

buffer password = {

6201

.data=malloc(1), /* because malloc(0) may return NULL */

6202

.length=0,

6203

.allocated=0, /* deliberate lie */

6204

};

6205

g_assert_nonnull(password.data);

6206

assert_send_password_to_socket_password(password);

6207

}

6208

6209

static void

6210

test_send_password_to_socket_empty_str_pass(__attribute__((unused))

6211

test_fixture *fixture,

6212

__attribute__((unused))

6213

gconstpointer user_data){

6214

__attribute__((cleanup(cleanup_buffer)))

6215

buffer password = {

6216

.data=strdup(""),

6217

.length=0,

6218

.allocated=1,

6219

};

6220

if(mlock(password.data, password.allocated) != 0){

6221

g_assert_true(errno == EPERM or errno == ENOMEM);

6222

}

6223

assert_send_password_to_socket_password(password);

6224

}

6225

6226

static void

6227

test_send_password_to_socket_text_password(__attribute__((unused))

6228

test_fixture *fixture,

6229

__attribute__((unused))

6230

gconstpointer user_data){

6231

const char dummy_test_password[] = "dummy test password";

6232

__attribute__((cleanup(cleanup_buffer)))

6233

buffer password = {

6234

.data = strdup(dummy_test_password),

6235

.length = strlen(dummy_test_password),

6236

.allocated = sizeof(dummy_test_password),

6237

};

6238

if(mlock(password.data, password.allocated) != 0){

6239

g_assert_true(errno == EPERM or errno == ENOMEM);

6240

}

6241

assert_send_password_to_socket_password(password);

6242

}

6243

6244

static void

6245

test_send_password_to_socket_binary_password(__attribute__((unused))

6246

test_fixture *fixture,

6247

__attribute__((unused))

6248

gconstpointer user_data){

6249

__attribute__((cleanup(cleanup_buffer)))

6250

buffer password = {

6251

.data=malloc(255),

6252

.length=255,

6253

.allocated=255,

6254

};

6255

g_assert_nonnull(password.data);

6256

if(mlock(password.data, password.allocated) != 0){

6257

g_assert_true(errno == EPERM or errno == ENOMEM);

6258

}

6259

char c = 1; /* Start at 1, avoiding NUL */

6260

for(int i=0; i < 255; i++){

6261

password.data[i] = c++;

6262

}

6263

assert_send_password_to_socket_password(password);

6264

}

6265

6266

static void

6267

test_send_password_to_socket_nuls_in_password(__attribute__((unused))

6268

test_fixture *fixture,

6269

__attribute__((unused))

6270

gconstpointer

6271

user_data){

6272

char test_password[] = {'\0', 'a', '\0', 'b', '\0', 'c', '\0'};

6273

__attribute__((cleanup(cleanup_buffer)))

6274

buffer password = {

6275

.data=malloc(sizeof(test_password)),

6276

.length=sizeof(test_password),

6277

.allocated=sizeof(test_password),

6278

};

6279

g_assert_nonnull(password.data);

6280

if(mlock(password.data, password.allocated) !=0){

6281

g_assert_true(errno == EPERM or errno == ENOMEM);

6282

}

6283

memcpy(password.data, test_password, password.allocated);

6284

assert_send_password_to_socket_password(password);

6285

}

6286

6287

static bool assert_add_existing_questions_to_devnull(task_queue

6288

*const,

6289

const int,

6290

buffer *const,

6291

string_set *,

6292

const

6293

mono_microsecs

6294

*const,

6295

bool *const,

6296

bool *const,

6297

const char

6298

*const);

6299

6300

static void test_add_existing_questions_ENOENT(__attribute__((unused))

6301

test_fixture *fixture,

6302

__attribute__((unused))

6303

gconstpointer

6304

user_data){

6305

__attribute__((cleanup(cleanup_queue)))

6306

task_queue *queue = create_queue();

6307

g_assert_nonnull(queue);

6308

__attribute__((cleanup(cleanup_close)))

6309

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6310

g_assert_cmpint(epoll_fd, >=, 0);

6311

__attribute__((cleanup(string_set_clear)))

6312

string_set cancelled_filenames = {};

6313

6314

g_assert_false(assert_add_existing_questions_to_devnull

6315

(queue,

6316

epoll_fd,

6317

(buffer[]){{}}, /* password */

6318

&cancelled_filenames,

6319

(mono_microsecs[]){0}, /* current_time */

6320

(bool[]){false}, /* mandos_client_exited */

6321

(bool[]){false}, /* password_is_read */

6322

"/nonexistent")); /* dirname */

6323

6324

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6325

}

6326

6327

static

6328

bool assert_add_existing_questions_to_devnull(task_queue

6329

*const queue,

6330

const int

6331

epoll_fd,

6332

buffer *const

6333

password,

6334

string_set

6335

*cancelled_filenames,

6336

const mono_microsecs

6337

*const current_time,

6338

bool *const

6339

mandos_client_exited,

6340

bool *const

6341

password_is_read,

6342

const char *const

6343

dirname){

6344

__attribute__((cleanup(cleanup_close)))

6345

const int devnull_fd = open("/dev/null",

6346

O_WRONLY | O_CLOEXEC | O_NOCTTY);

6347

g_assert_cmpint(devnull_fd, >=, 0);

6348

__attribute__((cleanup(cleanup_close)))

6349

const int real_stderr_fd = dup(STDERR_FILENO);

6350

g_assert_cmpint(real_stderr_fd, >=, 0);

6351

dup2(devnull_fd, STDERR_FILENO);

6352

const bool ret = add_existing_questions(queue, epoll_fd, password,

6353

cancelled_filenames,

6354

current_time,

6355

mandos_client_exited,

6356

password_is_read, dirname);

6357

dup2(real_stderr_fd, STDERR_FILENO);

6358

return ret;

6359

}

6360

6361

static

6362

void test_add_existing_questions_no_questions(__attribute__((unused))

6363

test_fixture *fixture,

6364

__attribute__((unused))

6365

gconstpointer

6366

user_data){

6367

__attribute__((cleanup(cleanup_queue)))

6368

task_queue *queue = create_queue();

6369

g_assert_nonnull(queue);

6370

__attribute__((cleanup(cleanup_close)))

6371

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6372

g_assert_cmpint(epoll_fd, >=, 0);

6373

__attribute__((cleanup(string_set_clear)))

6374

string_set cancelled_filenames = {};

6375

__attribute__((cleanup(cleanup_string)))

6376

char *tempdir = make_temporary_directory();

6377

g_assert_nonnull(tempdir);

6378

6379

g_assert_false(assert_add_existing_questions_to_devnull

6380

(queue,

6381

epoll_fd,

6382

(buffer[]){{}}, /* password */

6383

&cancelled_filenames,

6384

(mono_microsecs[]){0}, /* current_time */

6385

(bool[]){false}, /* mandos_client_exited */

6386

(bool[]){false}, /* password_is_read */

6387

tempdir));

6388

6389

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6390

6391

g_assert_cmpint(rmdir(tempdir), ==, 0);

6392

}

6393

6394

static char *make_question_file_in_directory(const char *const);

6395

6396

static

6397

void test_add_existing_questions_one_question(__attribute__((unused))

6398

test_fixture *fixture,

6399

__attribute__((unused))

6400

gconstpointer

6401

user_data){

6402

__attribute__((cleanup(cleanup_queue)))

6403

task_queue *queue = create_queue();

6404

g_assert_nonnull(queue);

6405

__attribute__((cleanup(cleanup_close)))

6406

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6407

g_assert_cmpint(epoll_fd, >=, 0);

6408

__attribute__((cleanup(cleanup_buffer)))

6409

buffer password = {};

6410

__attribute__((cleanup(string_set_clear)))

6411

string_set cancelled_filenames = {};

6412

const mono_microsecs current_time = 0;

6413

bool mandos_client_exited = false;

6414

bool password_is_read = false;

6415

__attribute__((cleanup(cleanup_string)))

6416

char *tempdir = make_temporary_directory();

6417

g_assert_nonnull(tempdir);

6418

__attribute__((cleanup(cleanup_string)))

6419

char *question_filename

6420

= make_question_file_in_directory(tempdir);

6421

g_assert_nonnull(question_filename);

6422

6423

g_assert_true(assert_add_existing_questions_to_devnull

6424

(queue,

6425

epoll_fd,

6426

&password,

6427

&cancelled_filenames,

6428

&current_time,

6429

&mandos_client_exited,

6430

&password_is_read,

6431

tempdir));

6432

6433

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6434

6435

g_assert_nonnull(find_matching_task(queue, (task_context){

6436

.func=open_and_parse_question,

6437

.epoll_fd=epoll_fd,

6438

.filename=question_filename,

6439

.question_filename=question_filename,

6440

.password=&password,

6441

.cancelled_filenames=&cancelled_filenames,

6442

.current_time=&current_time,

6443

.mandos_client_exited=&mandos_client_exited,

6444

.password_is_read=&password_is_read,

6445

}));

6446

6447

g_assert_true(queue->next_run == 1);

6448

6449

g_assert_cmpint(unlink(question_filename), ==, 0);

6450

g_assert_cmpint(rmdir(tempdir), ==, 0);

6451

}

6452

6453

static char *make_question_file_in_directory(const char

6454

*const dir){

6455

return make_temporary_prefixed_file_in_directory("ask.", dir);

6456

}

6457

6458

static

6459

void test_add_existing_questions_two_questions(__attribute__((unused))

6460

test_fixture *fixture,

6461

__attribute__((unused))

6462

gconstpointer

6463

user_data){

6464

__attribute__((cleanup(cleanup_queue)))

6465

task_queue *queue = create_queue();

6466

g_assert_nonnull(queue);

6467

__attribute__((cleanup(cleanup_close)))

6468

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6469

g_assert_cmpint(epoll_fd, >=, 0);

6470

__attribute__((cleanup(cleanup_buffer)))

6471

buffer password = {};

6472

__attribute__((cleanup(string_set_clear)))

6473

string_set cancelled_filenames = {};

6474

const mono_microsecs current_time = 0;

6475

bool mandos_client_exited = false;

6476

bool password_is_read = false;

6477

__attribute__((cleanup(cleanup_string)))

6478

char *tempdir = make_temporary_directory();

6479

g_assert_nonnull(tempdir);

6480

__attribute__((cleanup(cleanup_string)))

6481

char *question_filename1

6482

= make_question_file_in_directory(tempdir);

6483

g_assert_nonnull(question_filename1);

6484

__attribute__((cleanup(cleanup_string)))

6485

char *question_filename2

6486

= make_question_file_in_directory(tempdir);

6487

g_assert_nonnull(question_filename2);

6488

6489

g_assert_true(assert_add_existing_questions_to_devnull

6490

(queue,

6491

epoll_fd,

6492

&password,

6493

&cancelled_filenames,

6494

&current_time,

6495

&mandos_client_exited,

6496

&password_is_read,

6497

tempdir));

6498

6499

g_assert_cmpuint((unsigned int)queue->length, ==, 2);

6500

6501

g_assert_true(queue->next_run == 1);

6502

6503

__attribute__((cleanup(string_set_clear)))

6504

string_set seen_questions = {};

6505

6506

bool queue_contains_question_opener(char *const question_filename){

6507

return(find_matching_task(queue, (task_context){

6508

.func=open_and_parse_question,

6509

.epoll_fd=epoll_fd,

6510

.question_filename=question_filename,

6511

.password=&password,

6512

.cancelled_filenames=&cancelled_filenames,

6513

.current_time=&current_time,

6514

.mandos_client_exited=&mandos_client_exited,

6515

.password_is_read=&password_is_read,

6516

}) != NULL);

6517

}

6518

6519

g_assert_true(queue_contains_question_opener(question_filename1));

6520

g_assert_true(queue_contains_question_opener(question_filename2));

6521

6522

g_assert_true(queue->next_run == 1);

6523

6524

g_assert_cmpint(unlink(question_filename1), ==, 0);

6525

g_assert_cmpint(unlink(question_filename2), ==, 0);

6526

g_assert_cmpint(rmdir(tempdir), ==, 0);

6527

}

6528

6529

static void

6530

test_add_existing_questions_non_questions(__attribute__((unused))

6531

test_fixture *fixture,

6532

__attribute__((unused))

6533

gconstpointer user_data){

6534

__attribute__((cleanup(cleanup_queue)))

6535

task_queue *queue = create_queue();

6536

g_assert_nonnull(queue);

6537

__attribute__((cleanup(cleanup_close)))

6538

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6539

g_assert_cmpint(epoll_fd, >=, 0);

6540

__attribute__((cleanup(string_set_clear)))

6541

string_set cancelled_filenames = {};

6542

__attribute__((cleanup(cleanup_string)))

6543

char *tempdir = make_temporary_directory();

6544

g_assert_nonnull(tempdir);

6545

__attribute__((cleanup(cleanup_string)))

6546

char *question_filename1

6547

= make_temporary_file_in_directory(tempdir);

6548

g_assert_nonnull(question_filename1);

6549

__attribute__((cleanup(cleanup_string)))

6550

char *question_filename2

6551

= make_temporary_file_in_directory(tempdir);

6552

g_assert_nonnull(question_filename2);

6553

6554

g_assert_false(assert_add_existing_questions_to_devnull

6555

(queue,

6556

epoll_fd,

6557

(buffer[]){{}}, /* password */

6558

&cancelled_filenames,

6559

(mono_microsecs[]){0}, /* current_time */

6560

(bool[]){false}, /* mandos_client_exited */

6561

(bool[]){false}, /* password_is_read */

6562

tempdir));

6563

6564

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6565

6566

g_assert_cmpint(unlink(question_filename1), ==, 0);

6567

g_assert_cmpint(unlink(question_filename2), ==, 0);

6568

g_assert_cmpint(rmdir(tempdir), ==, 0);

6569

}

6570

6571

static void

6572

test_add_existing_questions_both_types(__attribute__((unused))

6573

test_fixture *fixture,

6574

__attribute__((unused))

6575

gconstpointer user_data){

6576

__attribute__((cleanup(cleanup_queue)))

6577

task_queue *queue = create_queue();

6578

g_assert_nonnull(queue);

6579

__attribute__((cleanup(cleanup_close)))

6580

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6581

g_assert_cmpint(epoll_fd, >=, 0);

6582

__attribute__((cleanup(cleanup_buffer)))

6583

buffer password = {};

6584

__attribute__((cleanup(string_set_clear)))

6585

string_set cancelled_filenames = {};

6586

const mono_microsecs current_time = 0;

6587

bool mandos_client_exited = false;

6588

bool password_is_read = false;

6589

__attribute__((cleanup(cleanup_string)))

6590

char *tempdir = make_temporary_directory();

6591

g_assert_nonnull(tempdir);

6592

__attribute__((cleanup(cleanup_string)))

6593

char *tempfilename1 = make_temporary_file_in_directory(tempdir);

6594

g_assert_nonnull(tempfilename1);

6595

__attribute__((cleanup(cleanup_string)))

6596

char *tempfilename2 = make_temporary_file_in_directory(tempdir);

6597

g_assert_nonnull(tempfilename2);

6598

__attribute__((cleanup(cleanup_string)))

6599

char *question_filename

6600

= make_question_file_in_directory(tempdir);

6601

g_assert_nonnull(question_filename);

6602

6603

g_assert_true(assert_add_existing_questions_to_devnull

6604

(queue,

6605

epoll_fd,

6606

&password,

6607

&cancelled_filenames,

6608

&current_time,

6609

&mandos_client_exited,

6610

&password_is_read,

6611

tempdir));

6612

6613

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6614

6615

g_assert_nonnull(find_matching_task(queue, (task_context){

6616

.func=open_and_parse_question,

6617

.epoll_fd=epoll_fd,

6618

.filename=question_filename,

6619

.question_filename=question_filename,

6620

.password=&password,

6621

.cancelled_filenames=&cancelled_filenames,

6622

.current_time=&current_time,

6623

.mandos_client_exited=&mandos_client_exited,

6624

.password_is_read=&password_is_read,

6625

}));

6626

6627

g_assert_true(queue->next_run == 1);

6628

6629

g_assert_cmpint(unlink(tempfilename1), ==, 0);

6630

g_assert_cmpint(unlink(tempfilename2), ==, 0);

6631

g_assert_cmpint(unlink(question_filename), ==, 0);

6632

g_assert_cmpint(rmdir(tempdir), ==, 0);

6633

}

6634

6635

static void test_wait_for_event_timeout(__attribute__((unused))

6636

test_fixture *fixture,

6637

__attribute__((unused))

6638

gconstpointer user_data){

6639

__attribute__((cleanup(cleanup_close)))

6640

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6641

g_assert_cmpint(epoll_fd, >=, 0);

6642

6643

g_assert_true(wait_for_event(epoll_fd, 1, 0));

6644

}

6645

6646

static void test_wait_for_event_event(__attribute__((unused))

6647

test_fixture *fixture,

6648

__attribute__((unused))

6649

gconstpointer user_data){

6650

__attribute__((cleanup(cleanup_close)))

6651

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6652

g_assert_cmpint(epoll_fd, >=, 0);

6653

int pipefds[2];

6654

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

6655

__attribute__((cleanup(cleanup_close)))

6656

const int read_pipe = pipefds[0];

6657

__attribute__((cleanup(cleanup_close)))

6658

const int write_pipe = pipefds[1];

6659

g_assert_cmpint(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, read_pipe,

6660

&(struct epoll_event)

6661

{ .events=EPOLLIN | EPOLLRDHUP }), ==, 0);

6662

g_assert_cmpint((int)write(write_pipe, "x", 1), ==, 1);

6663

6664

g_assert_true(wait_for_event(epoll_fd, 0, 0));

6665

}

6666

6667

static void test_wait_for_event_sigchld(test_fixture *fixture,

6668

__attribute__((unused))

6669

gconstpointer user_data){

6670

const pid_t pid = fork();

6671

if(pid == 0){ /* Child */

6672

if(not restore_signal_handler(&fixture->orig_sigaction)){

6673

_exit(EXIT_FAILURE);

6674

}

6675

if(not restore_sigmask(&fixture->orig_sigmask)){

6676

_exit(EXIT_FAILURE);

6677

}

6678

exit(EXIT_SUCCESS);

6679

}

6680

g_assert_true(pid != -1);

6681

__attribute__((cleanup(cleanup_close)))

6682

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6683

g_assert_cmpint(epoll_fd, >=, 0);

6684

6685

g_assert_true(wait_for_event(epoll_fd, 0, 0));

6686

6687

int status;

6688

g_assert_true(waitpid(pid, &status, 0) == pid);

6689

g_assert_true(WIFEXITED(status));

6690

g_assert_cmpint(WEXITSTATUS(status), ==, EXIT_SUCCESS);

6691

}

6692

6693

static void test_run_queue_zeroes_next_run(__attribute__((unused))

6694

test_fixture *fixture,

6695

__attribute__((unused))

6696

gconstpointer user_data){

6697

__attribute__((cleanup(cleanup_queue)))

6698

task_queue *queue = create_queue();

6699

g_assert_nonnull(queue);

6700

queue->next_run = 1;

6701

__attribute__((cleanup(cleanup_close)))

6702

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6703

__attribute__((cleanup(string_set_clear)))

6704

string_set cancelled_filenames = {};

6705

bool quit_now = false;

6706

6707

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6708

g_assert_false(quit_now);

6709

g_assert_cmpuint((unsigned int)queue->next_run, ==, 0);

6710

}

6711

6712

static

6713

void test_run_queue_clears_cancelled_filenames(__attribute__((unused))

6714

test_fixture *fixture,

6715

__attribute__((unused))

6716

gconstpointer

6717

user_data){

6718

__attribute__((cleanup(cleanup_queue)))

6719

task_queue *queue = create_queue();

6720

g_assert_nonnull(queue);

6721

__attribute__((cleanup(string_set_clear)))

6722

string_set cancelled_filenames = {};

6723

bool quit_now = false;

6724

const char question_filename[] = "/nonexistent/question_filename";

6725

g_assert_true(string_set_add(&cancelled_filenames,

6726

question_filename));

6727

6728

g_assert_true(add_to_queue(queue,

6729

(task_context){ .func=dummy_func }));

6730

6731

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6732

g_assert_false(quit_now);

6733

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6734

g_assert_false(string_set_contains(cancelled_filenames,

6735

question_filename));

6736

}

6737

6738

static

6739

void test_run_queue_skips_cancelled_filenames(__attribute__((unused))

6740

test_fixture *fixture,

6741

__attribute__((unused))

6742

gconstpointer

6743

user_data){

6744

__attribute__((cleanup(cleanup_queue)))

6745

task_queue *queue = create_queue();

6746

g_assert_nonnull(queue);

6747

__attribute__((cleanup(string_set_clear)))

6748

string_set cancelled_filenames = {};

6749

bool quit_now = false;

6750

int pipefds[2];

6751

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

6752

__attribute__((cleanup(cleanup_close)))

6753

const int read_pipe = pipefds[0];

6754

g_assert_cmpint(close(pipefds[1]), ==, 0);

6755

const char question_filename[] = "/nonexistent/question_filename";

6756

g_assert_true(string_set_add(&cancelled_filenames,

6757

question_filename));

6758

__attribute__((nonnull))

6759

void quit_func(const task_context task,

6760

__attribute__((unused)) task_queue *const q){

6761

g_assert_nonnull(task.quit_now);

6762

*task.quit_now = true;

6763

}

6764

task_context task = {

6765

.func=quit_func,

6766

.question_filename=strdup(question_filename),

6767

.quit_now=&quit_now,

6768

.fd=read_pipe,

6769

};

6770

g_assert_nonnull(task.question_filename);

6771

6772

g_assert_true(add_to_queue(queue, task));

6773

6774

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6775

g_assert_false(quit_now);

6776

6777

/* read_pipe should be closed already */

6778

errno = 0;

6779

bool read_pipe_closed = (close(read_pipe) == -1);

6780

read_pipe_closed &= (errno == EBADF);

6781

g_assert_true(read_pipe_closed);

6782

}

6783

6784

static void test_run_queue_one_task(__attribute__((unused))

6785

test_fixture *fixture,

6786

__attribute__((unused))

6787

gconstpointer user_data){

6788

__attribute__((cleanup(cleanup_queue)))

6789

task_queue *queue = create_queue();

6790

g_assert_nonnull(queue);

6791

__attribute__((cleanup(string_set_clear)))

6792

string_set cancelled_filenames = {};

6793

bool quit_now = false;

6794

6795

__attribute__((nonnull))

6796

void next_run_func(__attribute__((unused))

6797

const task_context task,

6798

task_queue *const q){

6799

q->next_run = 1;

6800

}

6801

6802

task_context task = {

6803

.func=next_run_func,

6804

};

6805

g_assert_true(add_to_queue(queue, task));

6806

6807

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6808

g_assert_cmpuint((unsigned int)(queue->next_run), ==, 1);

6809

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6810

}

6811

6812

static void test_run_queue_two_tasks(__attribute__((unused))

6813

test_fixture *fixture,

6814

__attribute__((unused))

6815

gconstpointer user_data){

6816

__attribute__((cleanup(cleanup_queue)))

6817

task_queue *queue = create_queue();

6818

g_assert_nonnull(queue);

6819

queue->next_run = 1;

6820

__attribute__((cleanup(string_set_clear)))

6821

string_set cancelled_filenames = {};

6822

bool quit_now = false;

6823

bool mandos_client_exited = false;

6824

6825

__attribute__((nonnull))

6826

void next_run_func(__attribute__((unused))

6827

const task_context task,

6828

task_queue *const q){

6829

q->next_run = 1;

6830

}

6831

6832

__attribute__((nonnull))

6833

void exited_func(const task_context task,

6834

__attribute__((unused)) task_queue *const q){

6835

*task.mandos_client_exited = true;

6836

}

6837

6838

task_context task1 = {

6839

.func=next_run_func,

6840

};

6841

g_assert_true(add_to_queue(queue, task1));

6842

6843

task_context task2 = {

6844

.func=exited_func,

6845

.mandos_client_exited=&mandos_client_exited,

6846

};

6847

g_assert_true(add_to_queue(queue, task2));

6848

6849

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6850

g_assert_false(quit_now);

6851

g_assert_cmpuint((unsigned int)(queue->next_run), ==, 1);

6852

g_assert_true(mandos_client_exited);

6853

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6854

}

6855

6856

static void test_run_queue_two_tasks_quit(__attribute__((unused))

6857

test_fixture *fixture,

6858

__attribute__((unused))

6859

gconstpointer user_data){

6860

__attribute__((cleanup(cleanup_queue)))

6861

task_queue *queue = create_queue();

6862

g_assert_nonnull(queue);

6863

__attribute__((cleanup(string_set_clear)))

6864

string_set cancelled_filenames = {};

6865

bool quit_now = false;

6866

bool mandos_client_exited = false;

6867

bool password_is_read = false;

6868

6869

__attribute__((nonnull))

6870

void set_exited_func(const task_context task,

6871

__attribute__((unused)) task_queue *const q){

6872

*task.mandos_client_exited = true;

6873

*task.quit_now = true;

6874

}

6875

task_context task1 = {

6876

.func=set_exited_func,

6877

.quit_now=&quit_now,

6878

.mandos_client_exited=&mandos_client_exited,

6879

};

6880

g_assert_true(add_to_queue(queue, task1));

6881

6882

__attribute__((nonnull))

6883

void set_read_func(const task_context task,

6884

__attribute__((unused)) task_queue *const q){

6885

*task.quit_now = true;

6886

*task.password_is_read = true;

6887

}

6888

task_context task2 = {

6889

.func=set_read_func,

6890

.quit_now=&quit_now,

6891

.password_is_read=&password_is_read,

6892

};

6893

g_assert_true(add_to_queue(queue, task2));

6894

6895

g_assert_false(run_queue(&queue, &cancelled_filenames, &quit_now));

6896

g_assert_true(quit_now);

6897

g_assert_true(mandos_client_exited xor password_is_read);

6898

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6899

}

6900

6901

static void test_run_queue_two_tasks_cleanup(__attribute__((unused))

6902

test_fixture *fixture,

6903

__attribute__((unused))

6904

gconstpointer user_data){

6905

__attribute__((cleanup(cleanup_queue)))

6906

task_queue *queue = create_queue();

6907

g_assert_nonnull(queue);

6908

__attribute__((cleanup(string_set_clear)))

6909

string_set cancelled_filenames = {};

6910

int pipefds[2];

6911

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

6912

__attribute__((cleanup(cleanup_close)))

6913

const int read_pipe = pipefds[0];

6914

__attribute__((cleanup(cleanup_close)))

6915

const int write_pipe = pipefds[1];

6916

bool quit_now = false;

6917

6918

__attribute__((nonnull))

6919

void read_func(const task_context task,

6920

__attribute__((unused)) task_queue *const q){

6921

*task.quit_now = true;

6922

}

6923

task_context task1 = {

6924

.func=read_func,

6925

.quit_now=&quit_now,

6926

.fd=read_pipe,

6927

};

6928

g_assert_true(add_to_queue(queue, task1));

6929

6930

__attribute__((nonnull))

6931

void write_func(const task_context task,

6932

__attribute__((unused)) task_queue *const q){

6933

*task.quit_now = true;

6934

}

6935

task_context task2 = {

6936

.func=write_func,

6937

.quit_now=&quit_now,

6938

.fd=write_pipe,

6939

};

6940

g_assert_true(add_to_queue(queue, task2));

6941

6942

g_assert_false(run_queue(&queue, &cancelled_filenames, &quit_now));

6943

g_assert_true(quit_now);

6944

6945

/* Either read_pipe or write_pipe should be closed already */

6946

errno = 0;

6947

bool close_read_pipe = (close(read_pipe) == -1);

6948

close_read_pipe &= (errno == EBADF);

6949

errno = 0;

6950

bool close_write_pipe = (close(write_pipe) == -1);

6951

close_write_pipe &= (errno == EBADF);

6952

g_assert_true(close_read_pipe xor close_write_pipe);

6953

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6954

}

6955

6956

static void test_setup_signal_handler(__attribute__((unused))

6957

test_fixture *fixture,

6958

__attribute__((unused))

6959

gconstpointer user_data){

6960

/* Save current SIGCHLD action, whatever it is */

6961

struct sigaction expected_sigchld_action;

6962

g_assert_cmpint(sigaction(SIGCHLD, NULL, &expected_sigchld_action),

6963

==, 0);

6964

6965

/* Act; i.e. run the setup_signal_handler() function */

6966

struct sigaction actual_old_sigchld_action;

6967

g_assert_true(setup_signal_handler(&actual_old_sigchld_action));

6968

6969

/* Check that the function correctly set "actual_old_sigchld_action"

6970

to the same values as the previously saved

6971

"expected_sigchld_action" */

6972

/* Check member sa_handler */

6973

g_assert_true(actual_old_sigchld_action.sa_handler

6974

== expected_sigchld_action.sa_handler);

6975

/* Check member sa_mask */

6976

for(int signum = 1; signum < NSIG; signum++){

6977

const int expected_old_block_state

6978

= sigismember(&expected_sigchld_action.sa_mask, signum);

6979

g_assert_cmpint(expected_old_block_state, >=, 0);

6980

const int actual_old_block_state

6981

= sigismember(&actual_old_sigchld_action.sa_mask, signum);

6982

g_assert_cmpint(actual_old_block_state, >=, 0);

6983

g_assert_cmpint(actual_old_block_state,

6984

==, expected_old_block_state);

6985

}

6986

/* Check member sa_flags */

6987

g_assert_true((actual_old_sigchld_action.sa_flags

6988

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

6989

== (expected_sigchld_action.sa_flags

6990

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART)));

6991

6992

/* Retrieve the current signal handler for SIGCHLD as set by

6993

setup_signal_handler() */

6994

struct sigaction actual_new_sigchld_action;

6995

g_assert_cmpint(sigaction(SIGCHLD, NULL,

6996

&actual_new_sigchld_action), ==, 0);

6997

/* Check that the signal handler (member sa_handler) is correctly

6998

set to the "handle_sigchld" function */

6999

g_assert_true(actual_new_sigchld_action.sa_handler != SIG_DFL);

7000

g_assert_true(actual_new_sigchld_action.sa_handler != SIG_IGN);

7001

g_assert_true(actual_new_sigchld_action.sa_handler

7002

== handle_sigchld);

7003

/* Check (in member sa_mask) that at least a handful of signals are

7004

actually blocked during the signal handler */

7005

for(int signum = 1; signum < NSIG; signum++){

7006

int actual_new_block_state;

7007

switch(signum){

7008

case SIGTERM:

7009

case SIGINT:

7010

case SIGQUIT:

7011

case SIGHUP:

7012

actual_new_block_state

7013

= sigismember(&actual_new_sigchld_action.sa_mask, signum);

7014

g_assert_cmpint(actual_new_block_state, ==, 1);

7015

continue;

7016

case SIGKILL: /* non-blockable */

7017

case SIGSTOP: /* non-blockable */

7018

case SIGCHLD: /* always blocked */

7019

default:

7020

continue;

7021

}

7022

}

7023

/* Check member sa_flags */

7024

g_assert_true((actual_new_sigchld_action.sa_flags

7025

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

7026

== (SA_NOCLDSTOP | SA_RESTART));

7027

7028

/* Restore signal handler */

7029

g_assert_cmpint(sigaction(SIGCHLD, &expected_sigchld_action, NULL),

7030

==, 0);

7031

}

7032

7033

static void test_restore_signal_handler(__attribute__((unused))

7034

test_fixture *fixture,

7035

__attribute__((unused))

7036

gconstpointer user_data){

7037

/* Save current SIGCHLD action, whatever it is */

7038

struct sigaction expected_sigchld_action;

7039

g_assert_cmpint(sigaction(SIGCHLD, NULL, &expected_sigchld_action),

7040

==, 0);

7041

/* Since we haven't established a signal handler yet, there should

7042

not be one established. But another test may have relied on

7043

restore_signal_handler() to restore the signal handler, and if

7044

restore_signal_handler() is buggy (which we should be prepared

7045

for in this test) the signal handler may not have been restored

7046

properly; check for this: */

7047

g_assert_true(expected_sigchld_action.sa_handler != handle_sigchld);

7048

7049

/* Establish a signal handler */

7050

struct sigaction sigchld_action = {

7051

.sa_handler=handle_sigchld,

7052

.sa_flags=SA_RESTART | SA_NOCLDSTOP,

7053

};

7054

g_assert_cmpint(sigfillset(&sigchld_action.sa_mask), ==, 0);

7055

g_assert_cmpint(sigaction(SIGCHLD, &sigchld_action, NULL), ==, 0);

7056

7057

/* Act; i.e. run the restore_signal_handler() function */

7058

g_assert_true(restore_signal_handler(&expected_sigchld_action));

7059

7060

/* Retrieve the restored signal handler data */

7061

struct sigaction actual_restored_sigchld_action;

7062

g_assert_cmpint(sigaction(SIGCHLD, NULL,

7063

&actual_restored_sigchld_action), ==, 0);

7064

7065

/* Check that the function correctly restored the signal action, as

7066

saved in "actual_restored_sigchld_action", to the same values as

7067

the previously saved "expected_sigchld_action" */

7068

/* Check member sa_handler */

7069

g_assert_true(actual_restored_sigchld_action.sa_handler

7070

== expected_sigchld_action.sa_handler);

7071

/* Check member sa_mask */

7072

for(int signum = 1; signum < NSIG; signum++){

7073

const int expected_old_block_state

7074

= sigismember(&expected_sigchld_action.sa_mask, signum);

7075

g_assert_cmpint(expected_old_block_state, >=, 0);

7076

const int actual_restored_block_state

7077

= sigismember(&actual_restored_sigchld_action.sa_mask, signum);

7078

g_assert_cmpint(actual_restored_block_state, >=, 0);

7079

g_assert_cmpint(actual_restored_block_state,

7080

==, expected_old_block_state);

7081

}

7082

/* Check member sa_flags */

7083

g_assert_true((actual_restored_sigchld_action.sa_flags

7084

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

7085

== (expected_sigchld_action.sa_flags

7086

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART)));

7087

}

7088

7089

static void test_block_sigchld(__attribute__((unused))

7090

test_fixture *fixture,

7091

__attribute__((unused))

7092

gconstpointer user_data){

7093

/* Save original signal mask */

7094

sigset_t expected_sigmask;

7095

g_assert_cmpint(pthread_sigmask(-1, NULL, &expected_sigmask),

7096

==, 0);

7097

7098

/* Make sure SIGCHLD is unblocked for this test */

7099

sigset_t sigchld_sigmask;

7100

g_assert_cmpint(sigemptyset(&sigchld_sigmask), ==, 0);

7101

g_assert_cmpint(sigaddset(&sigchld_sigmask, SIGCHLD), ==, 0);

7102

g_assert_cmpint(pthread_sigmask(SIG_UNBLOCK, &sigchld_sigmask,

7103

NULL), ==, 0);

7104

7105

/* Act; i.e. run the block_sigchld() function */

7106

sigset_t actual_old_sigmask;

7107

g_assert_true(block_sigchld(&actual_old_sigmask));

7108

7109

/* Check the actual_old_sigmask; it should be the same as the

7110

previously saved signal mask "expected_sigmask". */

7111

for(int signum = 1; signum < NSIG; signum++){

7112

const int expected_old_block_state

7113

= sigismember(&expected_sigmask, signum);

7114

g_assert_cmpint(expected_old_block_state, >=, 0);

7115

const int actual_old_block_state

7116

= sigismember(&actual_old_sigmask, signum);

7117

g_assert_cmpint(actual_old_block_state, >=, 0);

7118

g_assert_cmpint(actual_old_block_state,

7119

==, expected_old_block_state);

7120

}

7121

7122

/* Retrieve the newly set signal mask */

7123

sigset_t actual_sigmask;

7124

g_assert_cmpint(pthread_sigmask(-1, NULL, &actual_sigmask), ==, 0);

7125

7126

/* SIGCHLD should be blocked */

7127

g_assert_cmpint(sigismember(&actual_sigmask, SIGCHLD), ==, 1);

7128

7129

/* Restore signal mask */

7130

g_assert_cmpint(pthread_sigmask(SIG_SETMASK, &expected_sigmask,

7131

NULL), ==, 0);

7132

}

7133

7134

static void test_restore_sigmask(__attribute__((unused))

7135

test_fixture *fixture,

7136

__attribute__((unused))

7137

gconstpointer user_data){

7138

/* Save original signal mask */

7139

sigset_t orig_sigmask;

7140

g_assert_cmpint(pthread_sigmask(-1, NULL, &orig_sigmask), ==, 0);

7141

7142

/* Make sure SIGCHLD is blocked for this test */

7143

sigset_t sigchld_sigmask;

7144

g_assert_cmpint(sigemptyset(&sigchld_sigmask), ==, 0);

7145

g_assert_cmpint(sigaddset(&sigchld_sigmask, SIGCHLD), ==, 0);

7146

g_assert_cmpint(pthread_sigmask(SIG_BLOCK, &sigchld_sigmask,

7147

NULL), ==, 0);

7148

7149

/* Act; i.e. run the restore_sigmask() function */

7150

g_assert_true(restore_sigmask(&orig_sigmask));

7151

7152

/* Retrieve the newly restored signal mask */

7153

sigset_t restored_sigmask;

7154

g_assert_cmpint(pthread_sigmask(-1, NULL, &restored_sigmask),

7155

==, 0);

7156

7157

/* Check the restored_sigmask; it should be the same as the

7158

previously saved signal mask "orig_sigmask". */

7159

for(int signum = 1; signum < NSIG; signum++){

7160

const int orig_block_state = sigismember(&orig_sigmask, signum);

7161

g_assert_cmpint(orig_block_state, >=, 0);

7162

const int restored_block_state = sigismember(&restored_sigmask,

7163

signum);

7164

g_assert_cmpint(restored_block_state, >=, 0);

7165

g_assert_cmpint(restored_block_state, ==, orig_block_state);

7166

}

7167

7168

/* Restore signal mask */

7169

g_assert_cmpint(pthread_sigmask(SIG_SETMASK, &orig_sigmask,

7170

NULL), ==, 0);

7171

}

7172

7173

static void test_parse_arguments_noargs(__attribute__((unused))

7174

test_fixture *fixture,

7175

__attribute__((unused))

7176

gconstpointer user_data){

7177

char *argv[] = {

7178

strdup("prgname"),

7179

NULL };

7180

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7181

7182

char *agent_directory = NULL;

7183

char *helper_directory = NULL;

7184

uid_t user = 0;

7185

gid_t group = 0;

7186

char *mandos_argz = NULL;

7187

size_t mandos_argz_length = 0;

7188

7189

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7190

&helper_directory, &user, &group,

7191

&mandos_argz, &mandos_argz_length));

7192

g_assert_null(agent_directory);

7193

g_assert_null(helper_directory);

7194

g_assert_true(user == 0);

7195

g_assert_true(group == 0);

7196

g_assert_null(mandos_argz);

7197

g_assert_true(mandos_argz_length == 0);

7198

7199

for(char **arg = argv; *arg != NULL; arg++){

7200

free(*arg);

7201

}

7202

}

7203

7204

__attribute__((nonnull))

7205

static bool parse_arguments_devnull(int argc, char *argv[],

7206

const bool exit_failure,

7207

char **agent_directory,

7208

char **helper_directory,

7209

uid_t *const user,

7210

gid_t *const group,

7211

char **mandos_argz,

7212

size_t *mandos_argz_length){

7213

7214

FILE *real_stderr = stderr;

7215

FILE *devnull = fopen("/dev/null", "we");

7216

g_assert_nonnull(devnull);

7217

stderr = devnull;

7218

7219

const bool ret = parse_arguments(argc, argv, exit_failure,

7220

agent_directory,

7221

helper_directory, user, group,

7222

mandos_argz, mandos_argz_length);

7223

const error_t saved_errno = errno;

7224

7225

stderr = real_stderr;

7226

g_assert_cmpint(fclose(devnull), ==, 0);

7227

7228

errno = saved_errno;

7229

7230

return ret;

7231

}

7232

7233

static void test_parse_arguments_invalid(__attribute__((unused))

7234

test_fixture *fixture,

7235

__attribute__((unused))

7236

gconstpointer user_data){

7237

char *argv[] = {

7238

strdup("prgname"),

7239

strdup("--invalid"),

7240

NULL };

7241

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7242

7243

char *agent_directory = NULL;

7244

char *helper_directory = NULL;

7245

uid_t user = 0;

7246

gid_t group = 0;

7247

char *mandos_argz = NULL;

7248

size_t mandos_argz_length = 0;

7249

7250

g_assert_false(parse_arguments_devnull(argc, argv, false,

7251

&agent_directory,

7252

&helper_directory, &user,

7253

&group, &mandos_argz,

7254

&mandos_argz_length));

7255

7256

g_assert_true(errno == EINVAL);

7257

g_assert_null(agent_directory);

7258

g_assert_null(helper_directory);

7259

g_assert_null(mandos_argz);

7260

g_assert_true(mandos_argz_length == 0);

7261

7262

for(char **arg = argv; *arg != NULL; arg++){

7263

free(*arg);

7264

}

7265

}

7266

7267

static void test_parse_arguments_long_dir(__attribute__((unused))

7268

test_fixture *fixture,

7269

__attribute__((unused))

7270

gconstpointer user_data){

7271

char *argv[] = {

7272

strdup("prgname"),

7273

strdup("--agent-directory"),

7274

strdup("/tmp"),

7275

NULL };

7276

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7277

7278

__attribute__((cleanup(cleanup_string)))

7279

char *agent_directory = NULL;

7280

char *helper_directory = NULL;

7281

uid_t user = 0;

7282

gid_t group = 0;

7283

__attribute__((cleanup(cleanup_string)))

7284

char *mandos_argz = NULL;

7285

size_t mandos_argz_length = 0;

7286

7287

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7288

&helper_directory, &user, &group,

7289

&mandos_argz, &mandos_argz_length));

7290

7291

g_assert_cmpstr(agent_directory, ==, "/tmp");

7292

g_assert_null(helper_directory);

7293

g_assert_true(user == 0);

7294

g_assert_true(group == 0);

7295

g_assert_null(mandos_argz);

7296

g_assert_true(mandos_argz_length == 0);

7297

7298

for(char **arg = argv; *arg != NULL; arg++){

7299

free(*arg);

7300

}

7301

}

7302

7303

static void test_parse_arguments_short_dir(__attribute__((unused))

7304

test_fixture *fixture,

7305

__attribute__((unused))

7306

gconstpointer user_data){

7307

char *argv[] = {

7308

strdup("prgname"),

7309

strdup("-d"),

7310

strdup("/tmp"),

7311

NULL };

7312

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7313

7314

__attribute__((cleanup(cleanup_string)))

7315

char *agent_directory = NULL;

7316

char *helper_directory = NULL;

7317

uid_t user = 0;

7318

gid_t group = 0;

7319

__attribute__((cleanup(cleanup_string)))

7320

char *mandos_argz = NULL;

7321

size_t mandos_argz_length = 0;

7322

7323

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7324

&helper_directory, &user, &group,

7325

&mandos_argz, &mandos_argz_length));

7326

7327

g_assert_cmpstr(agent_directory, ==, "/tmp");

7328

g_assert_null(helper_directory);

7329

g_assert_true(user == 0);

7330

g_assert_true(group == 0);

7331

g_assert_null(mandos_argz);

7332

g_assert_true(mandos_argz_length == 0);

7333

7334

for(char **arg = argv; *arg != NULL; arg++){

7335

free(*arg);

7336

}

7337

}

7338

7339

static

7340

void test_parse_arguments_helper_directory(__attribute__((unused))

7341

test_fixture *fixture,

7342

__attribute__((unused))

7343

gconstpointer user_data){

7344

char *argv[] = {

7345

strdup("prgname"),

7346

strdup("--helper-directory"),

7347

strdup("/tmp"),

7348

NULL };

7349

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7350

7351

char *agent_directory = NULL;

7352

__attribute__((cleanup(cleanup_string)))

7353

char *helper_directory = NULL;

7354

uid_t user = 0;

7355

gid_t group = 0;

7356

__attribute__((cleanup(cleanup_string)))

7357

char *mandos_argz = NULL;

7358

size_t mandos_argz_length = 0;

7359

7360

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7361

&helper_directory, &user, &group,

7362

&mandos_argz, &mandos_argz_length));

7363

7364

g_assert_cmpstr(helper_directory, ==, "/tmp");

7365

g_assert_null(agent_directory);

7366

g_assert_true(user == 0);

7367

g_assert_true(group == 0);

7368

g_assert_null(mandos_argz);

7369

g_assert_true(mandos_argz_length == 0);

7370

7371

for(char **arg = argv; *arg != NULL; arg++){

7372

free(*arg);

7373

}

7374

}

7375

7376

static

7377

void test_parse_arguments_plugin_helper_dir(__attribute__((unused))

7378

test_fixture *fixture,

7379

__attribute__((unused))

7380

gconstpointer user_data){

7381

char *argv[] = {

7382

strdup("prgname"),

7383

strdup("--plugin-helper-dir"),

7384

strdup("/tmp"),

7385

NULL };

7386

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7387

7388

char *agent_directory = NULL;

7389

__attribute__((cleanup(cleanup_string)))

7390

char *helper_directory = NULL;

7391

uid_t user = 0;

7392

gid_t group = 0;

7393

__attribute__((cleanup(cleanup_string)))

7394

char *mandos_argz = NULL;

7395

size_t mandos_argz_length = 0;

7396

7397

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7398

&helper_directory, &user, &group,

7399

&mandos_argz, &mandos_argz_length));

7400

7401

g_assert_cmpstr(helper_directory, ==, "/tmp");

7402

g_assert_null(agent_directory);

7403

g_assert_true(user == 0);

7404

g_assert_true(group == 0);

7405

g_assert_null(mandos_argz);

7406

g_assert_true(mandos_argz_length == 0);

7407

7408

for(char **arg = argv; *arg != NULL; arg++){

7409

free(*arg);

7410

}

7411

}

7412

7413

static void test_parse_arguments_user(__attribute__((unused))

7414

test_fixture *fixture,

7415

__attribute__((unused))

7416

gconstpointer user_data){

7417

char *argv[] = {

7418

strdup("prgname"),

7419

strdup("--user"),

7420

strdup("1000"),

7421

NULL };

7422

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7423

7424

char *agent_directory = NULL;

7425

__attribute__((cleanup(cleanup_string)))

7426

char *helper_directory = NULL;

7427

uid_t user = 0;

7428

gid_t group = 0;

7429

__attribute__((cleanup(cleanup_string)))

7430

char *mandos_argz = NULL;

7431

size_t mandos_argz_length = 0;

7432

7433

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7434

&helper_directory, &user, &group,

7435

&mandos_argz, &mandos_argz_length));

7436

7437

g_assert_null(helper_directory);

7438

g_assert_null(agent_directory);

7439

g_assert_cmpuint((unsigned int)user, ==, 1000);

7440

g_assert_true(group == 0);

7441

g_assert_null(mandos_argz);

7442

g_assert_true(mandos_argz_length == 0);

7443

7444

for(char **arg = argv; *arg != NULL; arg++){

7445

free(*arg);

7446

}

7447

}

7448

7449

static void test_parse_arguments_user_invalid(__attribute__((unused))

7450

test_fixture *fixture,

7451

__attribute__((unused))

7452

gconstpointer

7453

user_data){

7454

char *argv[] = {

7455

strdup("prgname"),

7456

strdup("--user"),

7457

strdup("invalid"),

7458

NULL };

7459

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7460

7461

char *agent_directory = NULL;

7462

__attribute__((cleanup(cleanup_string)))

7463

char *helper_directory = NULL;

7464

uid_t user = 0;

7465

gid_t group = 0;

7466

__attribute__((cleanup(cleanup_string)))

7467

char *mandos_argz = NULL;

7468

size_t mandos_argz_length = 0;

7469

7470

g_assert_false(parse_arguments_devnull(argc, argv, false,

7471

&agent_directory,

7472

&helper_directory, &user,

7473

&group, &mandos_argz,

7474

&mandos_argz_length));

7475

7476

g_assert_null(helper_directory);

7477

g_assert_null(agent_directory);

7478

g_assert_cmpuint((unsigned int)user, ==, 0);

7479

g_assert_true(group == 0);

7480

g_assert_null(mandos_argz);

7481

g_assert_true(mandos_argz_length == 0);

7482

7483

for(char **arg = argv; *arg != NULL; arg++){

7484

free(*arg);

7485

}

7486

}

7487

7488

static

7489

void test_parse_arguments_user_zero_invalid(__attribute__((unused))

7490

test_fixture *fixture,

7491

__attribute__((unused))

7492

gconstpointer user_data){

7493

char *argv[] = {

7494

strdup("prgname"),

7495

strdup("--user"),

7496

strdup("0"),

7497

NULL };

7498

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7499

7500

char *agent_directory = NULL;

7501

__attribute__((cleanup(cleanup_string)))

7502

char *helper_directory = NULL;

7503

uid_t user = 0;

7504

gid_t group = 0;

7505

__attribute__((cleanup(cleanup_string)))

7506

char *mandos_argz = NULL;

7507

size_t mandos_argz_length = 0;

7508

7509

g_assert_false(parse_arguments_devnull(argc, argv, false,

7510

&agent_directory,

7511

&helper_directory, &user,

7512

&group, &mandos_argz,

7513

&mandos_argz_length));

7514

7515

g_assert_null(helper_directory);

7516

g_assert_null(agent_directory);

7517

g_assert_cmpuint((unsigned int)user, ==, 0);

7518

g_assert_true(group == 0);

7519

g_assert_null(mandos_argz);

7520

g_assert_true(mandos_argz_length == 0);

7521

7522

for(char **arg = argv; *arg != NULL; arg++){

7523

free(*arg);

7524

}

7525

}

7526

7527

static void test_parse_arguments_group(__attribute__((unused))

7528

test_fixture *fixture,

7529

__attribute__((unused))

7530

gconstpointer user_data){

7531

char *argv[] = {

7532

strdup("prgname"),

7533

strdup("--group"),

7534

strdup("1000"),

7535

NULL };

7536

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7537

7538

char *agent_directory = NULL;

7539

__attribute__((cleanup(cleanup_string)))

7540

char *helper_directory = NULL;

7541

uid_t user = 0;

7542

gid_t group = 0;

7543

__attribute__((cleanup(cleanup_string)))

7544

char *mandos_argz = NULL;

7545

size_t mandos_argz_length = 0;

7546

7547

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7548

&helper_directory, &user, &group,

7549

&mandos_argz, &mandos_argz_length));

7550

7551

g_assert_null(helper_directory);

7552

g_assert_null(agent_directory);

7553

g_assert_true(user == 0);

7554

g_assert_cmpuint((unsigned int)group, ==, 1000);

7555

g_assert_null(mandos_argz);

7556

g_assert_true(mandos_argz_length == 0);

7557

7558

for(char **arg = argv; *arg != NULL; arg++){

7559

free(*arg);

7560

}

7561

}

7562

7563

static void test_parse_arguments_group_invalid(__attribute__((unused))

7564

test_fixture *fixture,

7565

__attribute__((unused))

7566

gconstpointer

7567

user_data){

7568

char *argv[] = {

7569

strdup("prgname"),

7570

strdup("--group"),

7571

strdup("invalid"),

7572

NULL };

7573

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7574

7575

char *agent_directory = NULL;

7576

__attribute__((cleanup(cleanup_string)))

7577

char *helper_directory = NULL;

7578

uid_t user = 0;

7579

gid_t group = 0;

7580

__attribute__((cleanup(cleanup_string)))

7581

char *mandos_argz = NULL;

7582

size_t mandos_argz_length = 0;

7583

7584

g_assert_false(parse_arguments_devnull(argc, argv, false,

7585

&agent_directory,

7586

&helper_directory, &user,

7587

&group, &mandos_argz,

7588

&mandos_argz_length));

7589

7590

g_assert_null(helper_directory);

7591

g_assert_null(agent_directory);

7592

g_assert_true(user == 0);

7593

g_assert_true(group == 0);

7594

g_assert_null(mandos_argz);

7595

g_assert_true(mandos_argz_length == 0);

7596

7597

for(char **arg = argv; *arg != NULL; arg++){

7598

free(*arg);

7599

}

7600

}

7601

7602

static

7603

void test_parse_arguments_group_zero_invalid(__attribute__((unused))

7604

test_fixture *fixture,

7605

__attribute__((unused))

7606

gconstpointer user_data){

7607

char *argv[] = {

7608

strdup("prgname"),

7609

strdup("--group"),

7610

strdup("0"),

7611

NULL };

7612

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7613

7614

char *agent_directory = NULL;

7615

__attribute__((cleanup(cleanup_string)))

7616

char *helper_directory = NULL;

7617

uid_t user = 0;

7618

gid_t group = 0;

7619

__attribute__((cleanup(cleanup_string)))

7620

char *mandos_argz = NULL;

7621

size_t mandos_argz_length = 0;

7622

7623

g_assert_false(parse_arguments_devnull(argc, argv, false,

7624

&agent_directory,

7625

&helper_directory, &user,

7626

&group, &mandos_argz,

7627

&mandos_argz_length));

7628

7629

g_assert_null(helper_directory);

7630

g_assert_null(agent_directory);

7631

g_assert_cmpuint((unsigned int)group, ==, 0);

7632

g_assert_true(group == 0);

7633

g_assert_null(mandos_argz);

7634

g_assert_true(mandos_argz_length == 0);

7635

7636

for(char **arg = argv; *arg != NULL; arg++){

7637

free(*arg);

7638

}

7639

}

7640

7641

static void test_parse_arguments_mandos_noargs(__attribute__((unused))

7642

test_fixture *fixture,

7643

__attribute__((unused))

7644

gconstpointer

7645

user_data){

7646

char *argv[] = {

7647

strdup("prgname"),

7648

strdup("mandos-client"),

7649

NULL };

7650

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7651

7652

__attribute__((cleanup(cleanup_string)))

7653

char *agent_directory = NULL;

7654

__attribute__((cleanup(cleanup_string)))

7655

char *helper_directory = NULL;

7656

uid_t user = 0;

7657

gid_t group = 0;

7658

__attribute__((cleanup(cleanup_string)))

7659

char *mandos_argz = NULL;

7660

size_t mandos_argz_length = 0;

7661

7662

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7663

&helper_directory, &user, &group,

7664

&mandos_argz, &mandos_argz_length));

7665

7666

g_assert_null(agent_directory);

7667

g_assert_null(helper_directory);

7668

g_assert_true(user == 0);

7669

g_assert_true(group == 0);

7670

g_assert_cmpstr(mandos_argz, ==, "mandos-client");

7671

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7672

mandos_argz_length),

7673

==, 1);

7674

7675

for(char **arg = argv; *arg != NULL; arg++){

7676

free(*arg);

7677

}

7678

}

7679

7680

static void test_parse_arguments_mandos_args(__attribute__((unused))

7681

test_fixture *fixture,

7682

__attribute__((unused))

7683

gconstpointer user_data){

7684

char *argv[] = {

7685

strdup("prgname"),

7686

strdup("mandos-client"),

7687

strdup("one"),

7688

strdup("two"),

7689

strdup("three"),

7690

NULL };

7691

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7692

7693

__attribute__((cleanup(cleanup_string)))

7694

char *agent_directory = NULL;

7695

__attribute__((cleanup(cleanup_string)))

7696

char *helper_directory = NULL;

7697

uid_t user = 0;

7698

gid_t group = 0;

7699

__attribute__((cleanup(cleanup_string)))

7700

char *mandos_argz = NULL;

7701

size_t mandos_argz_length = 0;

7702

7703

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7704

&helper_directory, &user, &group,

7705

&mandos_argz, &mandos_argz_length));

7706

7707

g_assert_null(agent_directory);

7708

g_assert_null(helper_directory);

7709

g_assert_true(user == 0);

7710

g_assert_true(group == 0);

7711

char *marg = mandos_argz;

7712

g_assert_cmpstr(marg, ==, "mandos-client");

7713

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7714

g_assert_cmpstr(marg, ==, "one");

7715

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7716

g_assert_cmpstr(marg, ==, "two");

7717

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7718

g_assert_cmpstr(marg, ==, "three");

7719

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7720

mandos_argz_length),

7721

==, 4);

7722

7723

for(char **arg = argv; *arg != NULL; arg++){

7724

free(*arg);

7725

}

7726

}

7727

7728

static void test_parse_arguments_all_args(__attribute__((unused))

7729

test_fixture *fixture,

7730

__attribute__((unused))

7731

gconstpointer user_data){

7732

char *argv[] = {

7733

strdup("prgname"),

7734

strdup("--agent-directory"),

7735

strdup("/tmp"),

7736

strdup("--helper-directory"),

7737

strdup("/var/tmp"),

7738

strdup("--user"),

7739

strdup("1"),

7740

strdup("--group"),

7741

strdup("2"),

7742

strdup("mandos-client"),

7743

strdup("one"),

7744

strdup("two"),

7745

strdup("three"),

7746

NULL };

7747

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7748

7749

__attribute__((cleanup(cleanup_string)))

7750

char *agent_directory = NULL;

7751

__attribute__((cleanup(cleanup_string)))

7752

char *helper_directory = NULL;

7753

uid_t user = 0;

7754

gid_t group = 0;

7755

__attribute__((cleanup(cleanup_string)))

7756

char *mandos_argz = NULL;

7757

size_t mandos_argz_length = 0;

7758

7759

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7760

&helper_directory, &user, &group,

7761

&mandos_argz, &mandos_argz_length));

7762

7763

g_assert_cmpstr(agent_directory, ==, "/tmp");

7764

g_assert_cmpstr(helper_directory, ==, "/var/tmp");

7765

g_assert_true(user == 1);

7766

g_assert_true(group == 2);

7767

char *marg = mandos_argz;

7768

g_assert_cmpstr(marg, ==, "mandos-client");

7769

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7770

g_assert_cmpstr(marg, ==, "one");

7771

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7772

g_assert_cmpstr(marg, ==, "two");

7773

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7774

g_assert_cmpstr(marg, ==, "three");

7775

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7776

mandos_argz_length),

7777

==, 4);

7778

7779

for(char **arg = argv; *arg != NULL; arg++){

7780

free(*arg);

7781

}

7782

}

7783

7784

static void test_parse_arguments_mixed(__attribute__((unused))

7785

test_fixture *fixture,

7786

__attribute__((unused))

7787

gconstpointer user_data){

7788

char *argv[] = {

7789

strdup("prgname"),

7790

strdup("mandos-client"),

7791

strdup("--user"),

7792

strdup("1"),

7793

strdup("one"),

7794

strdup("--agent-directory"),

7795

strdup("/tmp"),

7796

strdup("two"),

7797

strdup("three"),

7798

strdup("--helper-directory=/var/tmp"),

7799

NULL };

7800

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7801

7802

__attribute__((cleanup(cleanup_string)))

7803

char *agent_directory = NULL;

7804

__attribute__((cleanup(cleanup_string)))

7805

char *helper_directory = NULL;

7806

uid_t user = 0;

7807

gid_t group = 0;

7808

__attribute__((cleanup(cleanup_string)))

7809

char *mandos_argz = NULL;

7810

size_t mandos_argz_length = 0;

7811

7812

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7813

&helper_directory, &user, &group,

7814

&mandos_argz, &mandos_argz_length));

7815

7816

g_assert_cmpstr(agent_directory, ==, "/tmp");

7817

g_assert_cmpstr(helper_directory, ==, "/var/tmp");

7818

g_assert_true(user == 1);

7819

g_assert_true(group == 0);

7820

char *marg = mandos_argz;

7821

g_assert_cmpstr(marg, ==, "mandos-client");

7822

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7823

g_assert_cmpstr(marg, ==, "one");

7824

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7825

g_assert_cmpstr(marg, ==, "two");

7826

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7827

g_assert_cmpstr(marg, ==, "three");

7828

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7829

mandos_argz_length),

7830

==, 4);

7831

7832

for(char **arg = argv; *arg != NULL; arg++){

7833

free(*arg);

7834

}

7835

}

7836

7837

/* End of tests section */

7838

7839

/* Test boilerplate section; New tests should be added to the test

7840

suite definition here, in the "run_tests" function.

7841

7842

Finally, this section also contains the should_only_run_tests()

7843

function used by main() for deciding if tests should be run or to

7844

start normally. */

7845

7846

__attribute__((cold))

7847

static bool run_tests(int argc, char *argv[]){

7848

g_test_init(&argc, &argv, NULL);

7849

7850

/* A macro to add a test with no setup or teardown functions */

7851

#define test_add(testpath, testfunc) \

7852

do { \

7853

g_test_add((testpath), test_fixture, NULL, NULL, \

7854

(testfunc), NULL); \

7855

} while(false)

7856

7857

/* Test the signal-related functions first, since some other tests

7858

depend on these functions in their setups and teardowns */

7859

test_add("/signal-handling/setup", test_setup_signal_handler);

7860

test_add("/signal-handling/restore", test_restore_signal_handler);

7861

test_add("/signal-handling/block", test_block_sigchld);

7862

test_add("/signal-handling/restore-sigmask", test_restore_sigmask);

7863

7864

/* Regular non-signal-related tests; these use no setups or

7865

teardowns */

7866

test_add("/parse_arguments/noargs", test_parse_arguments_noargs);

7867

test_add("/parse_arguments/invalid", test_parse_arguments_invalid);

7868

test_add("/parse_arguments/long-dir",

7869

test_parse_arguments_long_dir);

7870

test_add("/parse_arguments/short-dir",

7871

test_parse_arguments_short_dir);

7872

test_add("/parse_arguments/helper-directory",

7873

test_parse_arguments_helper_directory);

7874

test_add("/parse_arguments/plugin-helper-dir",

7875

test_parse_arguments_plugin_helper_dir);

7876

test_add("/parse_arguments/user", test_parse_arguments_user);

7877

test_add("/parse_arguments/user-invalid",

7878

test_parse_arguments_user_invalid);

7879

test_add("/parse_arguments/user-zero-invalid",

7880

test_parse_arguments_user_zero_invalid);

7881

test_add("/parse_arguments/group", test_parse_arguments_group);

7882

test_add("/parse_arguments/group-invalid",

7883

test_parse_arguments_group_invalid);

7884

test_add("/parse_arguments/group-zero-invalid",

7885

test_parse_arguments_group_zero_invalid);

7886

test_add("/parse_arguments/mandos-noargs",

7887

test_parse_arguments_mandos_noargs);

7888

test_add("/parse_arguments/mandos-args",

7889

test_parse_arguments_mandos_args);

7890

test_add("/parse_arguments/all-args",

7891

test_parse_arguments_all_args);

7892

test_add("/parse_arguments/mixed", test_parse_arguments_mixed);

7893

test_add("/queue/create", test_create_queue);

7894

test_add("/queue/add", test_add_to_queue);

7895

test_add("/queue/add/overflow", test_add_to_queue_overflow);

7896

test_add("/queue/has_question/empty",

7897

test_queue_has_question_empty);

7898

test_add("/queue/has_question/false",

7899

test_queue_has_question_false);

7900

test_add("/queue/has_question/true", test_queue_has_question_true);

7901

test_add("/queue/has_question/false2",

7902

test_queue_has_question_false2);

7903

test_add("/queue/has_question/true2",

7904

test_queue_has_question_true2);

7905

test_add("/buffer/cleanup", test_cleanup_buffer);

7906

test_add("/string_set/net-set-contains-nothing",

7907

test_string_set_new_set_contains_nothing);

7908

test_add("/string_set/with-added-string-contains-it",

7909

test_string_set_with_added_string_contains_it);

7910

test_add("/string_set/cleared-does-not-contain-string",

7911

test_string_set_cleared_does_not_contain_str);

7912

test_add("/string_set/swap/one-with-empty",

7913

test_string_set_swap_one_with_empty);

7914

test_add("/string_set/swap/empty-with-one",

7915

test_string_set_swap_empty_with_one);

7916

test_add("/string_set/swap/one-with-one",

7917

test_string_set_swap_one_with_one);

7918

7919

/* A macro to add a test using the setup and teardown functions */

7920

#define test_add_st(path, func) \

7921

do { \

7922

g_test_add((path), test_fixture, NULL, test_setup, (func), \

7923

test_teardown); \

7924

} while(false)

7925

7926

/* Signal-related tests; these use setups and teardowns which

7927

establish, during each test run, a signal handler for, and a

7928

signal mask blocking, the SIGCHLD signal, just like main() */

7929

test_add_st("/wait_for_event/timeout", test_wait_for_event_timeout);

7930

test_add_st("/wait_for_event/event", test_wait_for_event_event);

7931

test_add_st("/wait_for_event/sigchld", test_wait_for_event_sigchld);

7932

test_add_st("/run_queue/zeroes-next-run",

7933

test_run_queue_zeroes_next_run);

7934

test_add_st("/run_queue/clears-cancelled_filenames",

7935

test_run_queue_clears_cancelled_filenames);

7936

test_add_st("/run_queue/skips-cancelled-filenames",

7937

test_run_queue_skips_cancelled_filenames);

7938

test_add_st("/run_queue/one-task", test_run_queue_one_task);

7939

test_add_st("/run_queue/two-tasks", test_run_queue_two_tasks);

7940

test_add_st("/run_queue/two-tasks/quit",

7941

test_run_queue_two_tasks_quit);

7942

test_add_st("/run_queue/two-tasks-cleanup",

7943

test_run_queue_two_tasks_cleanup);

7944

test_add_st("/task-creators/start_mandos_client",

7945

test_start_mandos_client);

7946

test_add_st("/task-creators/start_mandos_client/execv",

7947

test_start_mandos_client_execv);

7948

test_add_st("/task-creators/start_mandos_client/suid/euid",

7949

test_start_mandos_client_suid_euid);

7950

test_add_st("/task-creators/start_mandos_client/suid/egid",

7951

test_start_mandos_client_suid_egid);

7952

test_add_st("/task-creators/start_mandos_client/suid/ruid",

7953

test_start_mandos_client_suid_ruid);

7954

test_add_st("/task-creators/start_mandos_client/suid/rgid",

7955

test_start_mandos_client_suid_rgid);

7956

test_add_st("/task-creators/start_mandos_client/read",

7957

test_start_mandos_client_read);

7958

test_add_st("/task-creators/start_mandos_client/helper-directory",

7959

test_start_mandos_client_helper_directory);

7960

test_add_st("/task-creators/start_mandos_client/sigmask",

7961

test_start_mandos_client_sigmask);

7962

test_add_st("/task/wait_for_mandos_client_exit/badpid",

7963

test_wait_for_mandos_client_exit_badpid);

7964

test_add_st("/task/wait_for_mandos_client_exit/noexit",

7965

test_wait_for_mandos_client_exit_noexit);

7966

test_add_st("/task/wait_for_mandos_client_exit/success",

7967

test_wait_for_mandos_client_exit_success);

7968

test_add_st("/task/wait_for_mandos_client_exit/failure",

7969

test_wait_for_mandos_client_exit_failure);

7970

test_add_st("/task/wait_for_mandos_client_exit/killed",

7971

test_wait_for_mandos_client_exit_killed);

7972

test_add_st("/task/read_mandos_client_output/readerror",

7973

test_read_mandos_client_output_readerror);

7974

test_add_st("/task/read_mandos_client_output/nodata",

7975

test_read_mandos_client_output_nodata);

7976

test_add_st("/task/read_mandos_client_output/eof",

7977

test_read_mandos_client_output_eof);

7978

test_add_st("/task/read_mandos_client_output/once",

7979

test_read_mandos_client_output_once);

7980

test_add_st("/task/read_mandos_client_output/malloc",

7981

test_read_mandos_client_output_malloc);

7982

test_add_st("/task/read_mandos_client_output/append",

7983

test_read_mandos_client_output_append);

7984

test_add_st("/task-creators/add_inotify_dir_watch",

7985

test_add_inotify_dir_watch);

7986

test_add_st("/task-creators/add_inotify_dir_watch/fail",

7987

test_add_inotify_dir_watch_fail);

7988

test_add_st("/task-creators/add_inotify_dir_watch/not-a-directory",

7989

test_add_inotify_dir_watch_nondir);

7990

test_add_st("/task-creators/add_inotify_dir_watch/EAGAIN",

7991

test_add_inotify_dir_watch_EAGAIN);

7992

test_add_st("/task-creators/add_inotify_dir_watch/IN_CLOSE_WRITE",

7993

test_add_inotify_dir_watch_IN_CLOSE_WRITE);

7994

test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_TO",

7995

test_add_inotify_dir_watch_IN_MOVED_TO);

7996

test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_FROM",

7997

test_add_inotify_dir_watch_IN_MOVED_FROM);

7998

test_add_st("/task-creators/add_inotify_dir_watch/IN_EXCL_UNLINK",

7999

test_add_inotify_dir_watch_IN_EXCL_UNLINK);

8000

test_add_st("/task-creators/add_inotify_dir_watch/IN_DELETE",

8001

test_add_inotify_dir_watch_IN_DELETE);

8002

test_add_st("/task/read_inotify_event/readerror",

8003

test_read_inotify_event_readerror);

8004

test_add_st("/task/read_inotify_event/bad-epoll",

8005

test_read_inotify_event_bad_epoll);

8006

test_add_st("/task/read_inotify_event/nodata",

8007

test_read_inotify_event_nodata);

8008

test_add_st("/task/read_inotify_event/eof",

8009

test_read_inotify_event_eof);

8010

test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE",

8011

test_read_inotify_event_IN_CLOSE_WRITE);

8012

test_add_st("/task/read_inotify_event/IN_MOVED_TO",

8013

test_read_inotify_event_IN_MOVED_TO);

8014

test_add_st("/task/read_inotify_event/IN_MOVED_FROM",

8015

test_read_inotify_event_IN_MOVED_FROM);

8016

test_add_st("/task/read_inotify_event/IN_DELETE",

8017

test_read_inotify_event_IN_DELETE);

8018

test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE/badname",

8019

test_read_inotify_event_IN_CLOSE_WRITE_badname);

8020

test_add_st("/task/read_inotify_event/IN_MOVED_TO/badname",

8021

test_read_inotify_event_IN_MOVED_TO_badname);

8022

test_add_st("/task/read_inotify_event/IN_MOVED_FROM/badname",

8023

test_read_inotify_event_IN_MOVED_FROM_badname);

8024

test_add_st("/task/read_inotify_event/IN_DELETE/badname",

8025

test_read_inotify_event_IN_DELETE_badname);

8026

test_add_st("/task/open_and_parse_question/ENOENT",

8027

test_open_and_parse_question_ENOENT);

8028

test_add_st("/task/open_and_parse_question/EIO",

8029

test_open_and_parse_question_EIO);

8030

test_add_st("/task/open_and_parse_question/parse-error",

8031

test_open_and_parse_question_parse_error);

8032

test_add_st("/task/open_and_parse_question/nosocket",

8033

test_open_and_parse_question_nosocket);

8034

test_add_st("/task/open_and_parse_question/badsocket",

8035

test_open_and_parse_question_badsocket);

8036

test_add_st("/task/open_and_parse_question/nopid",

8037

test_open_and_parse_question_nopid);

8038

test_add_st("/task/open_and_parse_question/badpid",

8039

test_open_and_parse_question_badpid);

8040

test_add_st("/task/open_and_parse_question/noexist_pid",

8041

test_open_and_parse_question_noexist_pid);

8042

test_add_st("/task/open_and_parse_question/no-notafter",

8043

test_open_and_parse_question_no_notafter);

8044

test_add_st("/task/open_and_parse_question/bad-notafter",

8045

test_open_and_parse_question_bad_notafter);

8046

test_add_st("/task/open_and_parse_question/notafter-0",

8047

test_open_and_parse_question_notafter_0);

8048

test_add_st("/task/open_and_parse_question/notafter-1",

8049

test_open_and_parse_question_notafter_1);

8050

test_add_st("/task/open_and_parse_question/notafter-1-1",

8051

test_open_and_parse_question_notafter_1_1);

8052

test_add_st("/task/open_and_parse_question/notafter-1-2",

8053

test_open_and_parse_question_notafter_1_2);

8054

test_add_st("/task/open_and_parse_question/equal-notafter",

8055

test_open_and_parse_question_equal_notafter);

8056

test_add_st("/task/open_and_parse_question/late-notafter",

8057

test_open_and_parse_question_late_notafter);

8058

test_add_st("/task/cancel_old_question/0-1-2",

8059

test_cancel_old_question_0_1_2);

8060

test_add_st("/task/cancel_old_question/0-2-1",

8061

test_cancel_old_question_0_2_1);

8062

test_add_st("/task/cancel_old_question/1-2-3",

8063

test_cancel_old_question_1_2_3);

8064

test_add_st("/task/cancel_old_question/1-3-2",

8065

test_cancel_old_question_1_3_2);

8066

test_add_st("/task/cancel_old_question/2-1-3",

8067

test_cancel_old_question_2_1_3);

8068

test_add_st("/task/cancel_old_question/2-3-1",

8069

test_cancel_old_question_2_3_1);

8070

test_add_st("/task/cancel_old_question/3-1-2",

8071

test_cancel_old_question_3_1_2);

8072

test_add_st("/task/cancel_old_question/3-2-1",

8073

test_cancel_old_question_3_2_1);

8074

test_add_st("/task/connect_question_socket/name-too-long",

8075

test_connect_question_socket_name_too_long);

8076

test_add_st("/task/connect_question_socket/connect-fail",

8077

test_connect_question_socket_connect_fail);

8078

test_add_st("/task/connect_question_socket/bad-epoll",

8079

test_connect_question_socket_bad_epoll);

8080

test_add_st("/task/connect_question_socket/usable",

8081

test_connect_question_socket_usable);

8082

test_add_st("/task/send_password_to_socket/client-not-exited",

8083

test_send_password_to_socket_client_not_exited);

8084

test_add_st("/task/send_password_to_socket/password-not-read",

8085

test_send_password_to_socket_password_not_read);

8086

test_add_st("/task/send_password_to_socket/EMSGSIZE",

8087

test_send_password_to_socket_EMSGSIZE);

8088

test_add_st("/task/send_password_to_socket/retry",

8089

test_send_password_to_socket_retry);

8090

test_add_st("/task/send_password_to_socket/bad-epoll",

8091

test_send_password_to_socket_bad_epoll);

8092

test_add_st("/task/send_password_to_socket/null-password",

8093

test_send_password_to_socket_null_password);

8094

test_add_st("/task/send_password_to_socket/empty-password",

8095

test_send_password_to_socket_empty_password);

8096

test_add_st("/task/send_password_to_socket/empty-str-password",

8097

test_send_password_to_socket_empty_str_pass);

8098

test_add_st("/task/send_password_to_socket/text-password",

8099

test_send_password_to_socket_text_password);

8100

test_add_st("/task/send_password_to_socket/binary-password",

8101

test_send_password_to_socket_binary_password);

8102

test_add_st("/task/send_password_to_socket/nuls-in-password",

8103

test_send_password_to_socket_nuls_in_password);

8104

test_add_st("/task-creators/add_existing_questions/ENOENT",

8105

test_add_existing_questions_ENOENT);

8106

test_add_st("/task-creators/add_existing_questions/no-questions",

8107

test_add_existing_questions_no_questions);

8108

test_add_st("/task-creators/add_existing_questions/one-question",

8109

test_add_existing_questions_one_question);

8110

test_add_st("/task-creators/add_existing_questions/two-questions",

8111

test_add_existing_questions_two_questions);

8112

test_add_st("/task-creators/add_existing_questions/non-questions",

8113

test_add_existing_questions_non_questions);

8114

test_add_st("/task-creators/add_existing_questions/both-types",

8115

test_add_existing_questions_both_types);

8116

8117

return g_test_run() == 0;

8118

}

8119

8120

static bool should_only_run_tests(int *argc_p, char **argv_p[]){

8121

GOptionContext *context = g_option_context_new("");

8122

8123

g_option_context_set_help_enabled(context, FALSE);

8124

g_option_context_set_ignore_unknown_options(context, TRUE);

8125

8126

gboolean should_run_tests = FALSE;

8127

GOptionEntry entries[] = {

8128

{ "test", 0, 0, G_OPTION_ARG_NONE,

8129

&should_run_tests, "Run tests", NULL },

8130

{ NULL }

8131

};

8132

g_option_context_add_main_entries(context, entries, NULL);

8133

8134

GError *error = NULL;

8135

8136

if(g_option_context_parse(context, argc_p, argv_p, &error) != TRUE){

8137

g_option_context_free(context);

8138

g_error("Failed to parse options: %s", error->message);

8139

}

8140

8141

g_option_context_free(context);

8142

return should_run_tests != FALSE;

8143

}