/mandos/release : revision 237.7.35

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(pid == -1){

872

error(0, errno, "Failed to fork()");

873

close(pipefds[0]);

874

return false;

875

}

876

877

if(not add_to_queue(queue, (task_context){

878

.func=wait_for_mandos_client_exit,

879

.pid=pid,

880

.mandos_client_exited=mandos_client_exited,

881

.quit_now=quit_now,

882

})){

883

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

884

close(pipefds[0]);

885

return false;

886

}

887

888

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

889

&(struct epoll_event)

890

{ .events=EPOLLIN | EPOLLRDHUP });

891

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

892

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

893

close(pipefds[0]);

894

return false;

895

}

896

897

return add_to_queue(queue, (task_context){

898

.func=read_mandos_client_output,

899

.epoll_fd=epoll_fd,

900

.fd=pipefds[0],

901

.quit_now=quit_now,

902

.password=password,

903

.password_is_read=password_is_read,

904

});

905

}

906

907

__attribute__((nonnull))

908

void wait_for_mandos_client_exit(const task_context task,

909

task_queue *const queue){

910

const pid_t pid = task.pid;

911

bool *const mandos_client_exited = task.mandos_client_exited;

912

bool *const quit_now = task.quit_now;

913

914

int status;

915

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

916

case 0: /* Not exited yet */

917

if(not add_to_queue(queue, task)){

918

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

919

*quit_now = true;

920

}

921

break;

922

case -1: /* Error */

923

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

924

if(errno != ECHILD){

925

kill(pid, SIGTERM);

926

}

927

*quit_now = true;

928

break;

929

default: /* Has exited */

930

*mandos_client_exited = true;

931

if((not WIFEXITED(status))

932

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

933

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

934

*quit_now = true;

935

}

936

}

937

}

938

939

__attribute__((nonnull))

940

void read_mandos_client_output(const task_context task,

941

task_queue *const queue){

942

buffer *const password = task.password;

943

bool *const quit_now = task.quit_now;

944

bool *const password_is_read = task.password_is_read;

945

const int fd = task.fd;

946

const int epoll_fd = task.epoll_fd;

947

948

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

949

if(password->allocated < new_potential_size){

950

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

951

if(new_buffer == NULL){

952

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

953

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

954

*quit_now = true;

955

close(fd);

956

return;

957

}

958

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

959

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

960

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

961

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

962

}

963

}

964

if(password->length > 0){

965

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

966

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

967

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

968

#else

969

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

970

#endif

971

}

972

if(password->data != NULL){

973

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

974

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

975

}

976

free(password->data);

977

}

978

password->data = new_buffer;

979

password->allocated = new_potential_size;

980

}

981

982

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

983

+ password->length, PIPE_BUF);

984

985

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

986

*password_is_read = true;

987

close(fd);

988

return;

989

}

990

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

991

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

992

*quit_now = true;

993

close(fd);

994

return;

995

}

996

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

997

password->length += (size_t)read_length;

998

}

999

1000

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

1001

available yet */

1002

1003

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

1004

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

1005

&(struct epoll_event)

1006

{ .events=EPOLLIN | EPOLLRDHUP });

1007

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

1008

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

1009

*quit_now = true;

1010

close(fd);

1011

return;

1012

}

1013

1014

/* Re-add myself to the queue */

1015

if(not add_to_queue(queue, task)){

1016

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

1017

*quit_now = true;

1018

close(fd);

1019

}

1020

}

1021

1022

__attribute__((nonnull, warn_unused_result))

1023

bool add_inotify_dir_watch(task_queue *const queue,

1024

const int epoll_fd, bool *const quit_now,

1025

buffer *const password,

1026

const char *const dir,

1027

string_set *cancelled_filenames,

1028

const mono_microsecs *const current_time,

1029

bool *const mandos_client_exited,

1030

bool *const password_is_read){

1031

const int fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);

1032

if(fd == -1){

1033

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

1034

return false;

1035

}

1036

1037

if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE | IN_MOVED_TO

1038

| IN_MOVED_FROM| IN_DELETE | IN_EXCL_UNLINK

1039

| IN_ONLYDIR)

1040

== -1){

1041

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

1042

return false;

1043

}

1044

1045

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

1046

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

1047

&(struct epoll_event)

1048

{ .events=EPOLLIN | EPOLLRDHUP });

1049

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

1050

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

1051

close(fd);

1052

return false;

1053

}

1054

1055

const task_context read_inotify_event_task = {

1056

.func=read_inotify_event,

1057

.epoll_fd=epoll_fd,

1058

.quit_now=quit_now,

1059

.password=password,

1060

.fd=fd,

1061

.filename=strdup(dir),

1062

.cancelled_filenames=cancelled_filenames,

1063

.current_time=current_time,

1064

.mandos_client_exited=mandos_client_exited,

1065

.password_is_read=password_is_read,

1066

};

1067

if(read_inotify_event_task.filename == NULL){

1068

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

1069

close(fd);

1070

return false;

1071

}

1072

1073

return add_to_queue(queue, read_inotify_event_task);

1074

}

1075

1076

__attribute__((nonnull))

1077

void read_inotify_event(const task_context task,

1078

task_queue *const queue){

1079

const int fd = task.fd;

1080

const int epoll_fd = task.epoll_fd;

1081

char *const filename = task.filename;

1082

bool *quit_now = task.quit_now;

1083

buffer *const password = task.password;

1084

string_set *const cancelled_filenames = task.cancelled_filenames;

1085

const mono_microsecs *const current_time = task.current_time;

1086

bool *const mandos_client_exited = task.mandos_client_exited;

1087

bool *const password_is_read = task.password_is_read;

1088

1089

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

1090

const size_t ievent_size = (sizeof(struct inotify_event)

1091

+ NAME_MAX + 1);

1092

struct {

1093

struct inotify_event event;

1094

char name_buffer[NAME_MAX + 1];

1095

} ievent_buffer;

1096

struct inotify_event *const ievent = &ievent_buffer.event;

1097

1098

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

1099

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

1100

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

1101

*quit_now = true;

1102

cleanup_task(&task);

1103

return;

1104

}

1105

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

1106

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

1107

filename);

1108

*quit_now = true;

1109

cleanup_task(&task);

1110

return;

1111

}

1112

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

1113

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

1114

char *question_filename = NULL;

1115

const ssize_t question_filename_length

1116

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

1117

if(question_filename_length < 0){

1118

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

1119

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

1120

} else {

1121

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

1122

if(not add_to_queue(queue, (task_context){

1123

.func=open_and_parse_question,

1124

.epoll_fd=epoll_fd,

1125

.question_filename=question_filename,

1126

.filename=question_filename,

1127

.password=password,

1128

.cancelled_filenames=cancelled_filenames,

1129

.current_time=current_time,

1130

.mandos_client_exited=mandos_client_exited,

1131

.password_is_read=password_is_read,

1132

})){

1133

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

1134

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

1135

} else {

1136

/* Force the added task (open_and_parse_question) to run

1137

immediately */

1138

queue->next_run = 1;

1139

}

1140

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

1141

if(not string_set_add(cancelled_filenames,

1142

question_filename)){

1143

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

1144

" cancelled_questions", question_filename);

1145

*quit_now = true;

1146

free(question_filename);

1147

cleanup_task(&task);

1148

return;

1149

}

1150

free(question_filename);

1151

}

1152

}

1153

}

1154

1155

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

1156

available yet */

1157

1158

/* Re-add myself to the queue */

1159

if(not add_to_queue(queue, task)){

1160

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

1161

" queue", filename);

1162

*quit_now = true;

1163

cleanup_task(&task);

1164

return;

1165

}

1166

1167

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

1168

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

1169

&(struct epoll_event)

1170

{ .events=EPOLLIN | EPOLLRDHUP });

1171

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

1172

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

1173

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

1174

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

1175

one second from now */

1176

if((queue->next_run == 0)

1177

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

1178

queue->next_run = *current_time + 1000000;

1179

}

1180

}

1181

}

1182

1183

__attribute__((nonnull))

1184

void open_and_parse_question(const task_context task,

1185

task_queue *const queue){

1186

__attribute__((cleanup(cleanup_string)))

1187

char *question_filename = task.question_filename;

1188

const int epoll_fd = task.epoll_fd;

1189

buffer *const password = task.password;

1190

string_set *const cancelled_filenames = task.cancelled_filenames;

1191

const mono_microsecs *const current_time = task.current_time;

1192

bool *const mandos_client_exited = task.mandos_client_exited;

1193

bool *const password_is_read = task.password_is_read;

1194

1195

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

1196

question file. See <https://systemd.io/PASSWORD_AGENTS/> for

1197

specification of contents */

1198

__attribute__((nonnull))

1199

void cleanup_g_key_file(GKeyFile **key_file){

1200

if(*key_file != NULL){

1201

g_key_file_free(*key_file);

1202

}

1203

}

1204

1205

__attribute__((cleanup(cleanup_g_key_file)))

1206

GKeyFile *key_file = g_key_file_new();

1207

if(key_file == NULL){

1208

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

1209

question_filename);

1210

return;

1211

}

1212

GError *glib_error = NULL;

1213

if(g_key_file_load_from_file(key_file, question_filename,

1214

G_KEY_FILE_NONE, &glib_error) != TRUE){

1215

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

1216

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

1217

if(glib_error->code != G_FILE_ERROR_NOENT){

1218

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

1219

question_filename, glib_error->message);

1220

}

1221

return;

1222

}

1223

1224

__attribute__((cleanup(cleanup_string)))

1225

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

1226

"Socket",

1227

&glib_error);

1228

if(socket_name == NULL){

1229

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

1230

question_filename, glib_error->message);

1231

return;

1232

}

1233

1234

if(strlen(socket_name) == 0){

1235

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

1236

question_filename);

1237

return;

1238

}

1239

1240

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

1241

&glib_error);

1242

if(glib_error != NULL){

1243

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

1244

question_filename, glib_error->message);

1245

return;

1246

}

1247

1248

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

1249

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

1250

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

1251

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

1252

return;

1253

}

1254

1255

guint64 notafter = g_key_file_get_uint64(key_file, "Ask",

1256

"NotAfter", &glib_error);

1257

if(glib_error != NULL){

1258

if(glib_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND){

1259

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

1260

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

1261

}

1262

notafter = 0;

1263

}

1264

if(notafter != 0){

1265

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

1266

queue->next_run = notafter;

1267

}

1268

if(*current_time >= notafter){

1269

return;

1270

}

1271

}

1272

1273

const task_context connect_question_socket_task = {

1274

.func=connect_question_socket,

1275

.question_filename=strdup(question_filename),

1276

.epoll_fd=epoll_fd,

1277

.password=password,

1278

.filename=strdup(socket_name),

1279

.cancelled_filenames=task.cancelled_filenames,

1280

.mandos_client_exited=mandos_client_exited,

1281

.password_is_read=password_is_read,

1282

.current_time=current_time,

1283

};

1284

if(connect_question_socket_task.question_filename == NULL

1285

or connect_question_socket_task.filename == NULL

1286

or not add_to_queue(queue, connect_question_socket_task)){

1287

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

1288

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

1289

question_filename);

1290

cleanup_task(&connect_question_socket_task);

1291

return;

1292

}

1293

/* Force the added task (connect_question_socket) to run

1294

immediately */

1295

queue->next_run = 1;

1296

1297

if(notafter > 0){

1298

char *const dup_filename = strdup(question_filename);

1299

const task_context cancel_old_question_task = {

1300

.func=cancel_old_question,

1301

.question_filename=dup_filename,

1302

.notafter=notafter,

1303

.filename=dup_filename,

1304

.cancelled_filenames=cancelled_filenames,

1305

.current_time=current_time,

1306

};

1307

if(cancel_old_question_task.question_filename == NULL

1308

or not add_to_queue(queue, cancel_old_question_task)){

1309

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

1310

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

1311

cleanup_task(&cancel_old_question_task);

1312

return;

1313

}

1314

}

1315

}

1316

1317

__attribute__((nonnull))

1318

void cancel_old_question(const task_context task,

1319

task_queue *const queue){

1320

char *const question_filename = task.question_filename;

1321

string_set *const cancelled_filenames = task.cancelled_filenames;

1322

const mono_microsecs notafter = task.notafter;

1323

const mono_microsecs *const current_time = task.current_time;

1324

1325

if(*current_time >= notafter){

1326

if(not string_set_add(cancelled_filenames, question_filename)){

1327

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

1328

question_filename);

1329

}

1330

cleanup_task(&task);

1331

return;

1332

}

1333

1334

if(not add_to_queue(queue, task)){

1335

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

1336

"%s to queue", question_filename);

1337

cleanup_task(&task);

1338

return;

1339

}

1340

1341

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

1342

queue->next_run = notafter;

1343

}

1344

}

1345

1346

__attribute__((nonnull))

1347

void connect_question_socket(const task_context task,

1348

task_queue *const queue){

1349

char *const question_filename = task.question_filename;

1350

char *const filename = task.filename;

1351

const int epoll_fd = task.epoll_fd;

1352

buffer *const password = task.password;

1353

string_set *const cancelled_filenames = task.cancelled_filenames;

1354

bool *const mandos_client_exited = task.mandos_client_exited;

1355

bool *const password_is_read = task.password_is_read;

1356

const mono_microsecs *const current_time = task.current_time;

1357

1358

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

1359

1360

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

1361

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

1362

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

1363

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

1364

if(not string_set_add(cancelled_filenames, question_filename)){

1365

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

1366

question_filename);

1367

}

1368

cleanup_task(&task);

1369

return;

1370

}

1371

1372

const int fd = socket(PF_LOCAL, SOCK_DGRAM

1373

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

1374

if(fd < 0){

1375

error(0, errno,

1376

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

1377

if(not add_to_queue(queue, task)){

1378

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

1379

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

1380

filename);

1381

cleanup_task(&task);

1382

} else {

1383

/* Force the added task (connect_question_socket) to run

1384

immediately */

1385

queue->next_run = 1;

1386

}

1387

return;

1388

}

1389

1390

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

1391

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

1392

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

1393

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

1394

if(not add_to_queue(queue, task)){

1395

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

1396

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

1397

filename);

1398

cleanup_task(&task);

1399

} else {

1400

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

1401

at most one second from now */

1402

if((queue->next_run == 0)

1403

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

1404

queue->next_run = *current_time + 1000000;

1405

}

1406

}

1407

return;

1408

}

1409

1410

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

1411

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

1412

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

1413

filename);

1414

}

1415

1416

/* Add the fd to the epoll set */

1417

if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

1418

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

1419

!= 0){

1420

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

1421

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

1422

if(not add_to_queue(queue, task)){

1423

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

1424

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

1425

filename);

1426

cleanup_task(&task);

1427

} else {

1428

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

1429

at most one second from now */

1430

if((queue->next_run == 0)

1431

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

1432

queue->next_run = *current_time + 1000000;

1433

}

1434

}

1435

return;

1436

}

1437

1438

/* add task send_password_to_socket to queue */

1439

const task_context send_password_to_socket_task = {

1440

.func=send_password_to_socket,

1441

.question_filename=question_filename,

1442

.filename=filename,

1443

.epoll_fd=epoll_fd,

1444

.fd=fd,

1445

.password=password,

1446

.cancelled_filenames=cancelled_filenames,

1447

.mandos_client_exited=mandos_client_exited,

1448

.password_is_read=password_is_read,

1449

.current_time=current_time,

1450

};

1451

1452

if(not add_to_queue(queue, send_password_to_socket_task)){

1453

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

1454

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

1455

question_filename, filename);

1456

cleanup_task(&send_password_to_socket_task);

1457

}

1458

}

1459

1460

__attribute__((nonnull))

1461

void send_password_to_socket(const task_context task,

1462

task_queue *const queue){

1463

char *const question_filename=task.question_filename;

1464

char *const filename=task.filename;

1465

const int epoll_fd=task.epoll_fd;

1466

const int fd=task.fd;

1467

buffer *const password=task.password;

1468

string_set *const cancelled_filenames=task.cancelled_filenames;

1469

bool *const mandos_client_exited = task.mandos_client_exited;

1470

bool *const password_is_read = task.password_is_read;

1471

const mono_microsecs *const current_time = task.current_time;

1472

1473

if(*mandos_client_exited and *password_is_read){

1474

1475

const size_t send_buffer_length = password->length + 2;

1476

char *send_buffer = malloc(send_buffer_length);

1477

if(send_buffer == NULL){

1478

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

1479

} else {

1480

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

1481

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

1482

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

1483

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

1484

" buffer");

1485

}

1486

}

1487

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

1488

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

1489

depending on whether the password entry was successful or

1490

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

1491

your message.

1492

1493

— <https://systemd.io/PASSWORD_AGENTS/> (Tue, 15 Sep 2020

1494

14:24:20 GMT)

1495

*/

1496

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

1497

/* Always add an extra NUL */

1498

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

1499

if(password->length > 0){

1500

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

1501

}

1502

errno = 0;

1503

ssize_t ssret = send(fd, send_buffer, send_buffer_length,

1504

MSG_NOSIGNAL);

1505

const error_t saved_errno = (ssret < 0) ? errno : 0;

1506

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

1507

explicit_bzero(send_buffer, send_buffer_length);

1508

#else

1509

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

1510

#endif

1511

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

1512

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

1513

}

1514

free(send_buffer);

1515

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

1516

switch(saved_errno){

1517

case EINTR:

1518

case ENOBUFS:

1519

case ENOMEM:

1520

case EADDRINUSE:

1521

case ECONNREFUSED:

1522

case ECONNRESET:

1523

case ENOENT:

1524

case ETOOMANYREFS:

1525

case EAGAIN:

1526

/* Retry, below */

1527

break;

1528

case EMSGSIZE:

1529

error(0, saved_errno, "Password of size %" PRIuMAX

1530

" is too big", (uintmax_t)password->length);

1531

#if __GNUC__ < 7

1532

/* FALLTHROUGH */

1533

#else

1534

__attribute__((fallthrough));

1535

#endif

1536

case 0:

1537

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

1538

error(0, 0, "Password only partially sent to socket %s: %"

1539

PRIuMAX " out of %" PRIuMAX " bytes sent", filename,

1540

(uintmax_t)ssret, (uintmax_t)send_buffer_length);

1541

}

1542

#if __GNUC__ < 7

1543

/* FALLTHROUGH */

1544

#else

1545

__attribute__((fallthrough));

1546

#endif

1547

default:

1548

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

1549

filename);

1550

if(not string_set_add(cancelled_filenames,

1551

question_filename)){

1552

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

1553

question_filename);

1554

}

1555

cleanup_task(&task);

1556

return;

1557

}

1558

} else {

1559

/* Success */

1560

cleanup_task(&task);

1561

return;

1562

}

1563

}

1564

}

1565

1566

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

1567

1568

if(not add_to_queue(queue, task)){

1569

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

1570

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

1571

filename);

1572

cleanup_task(&task);

1573

}

1574

1575

/* Add the fd to the epoll set */

1576

if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

1577

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

1578

!= 0){

1579

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

1580

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

1581

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

1582

most one second from now */

1583

if((queue->next_run == 0)

1584

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

1585

queue->next_run = *current_time + 1000000;

1586

}

1587

}

1588

}

1589

1590

__attribute__((warn_unused_result))

1591

bool add_existing_questions(task_queue *const queue,

1592

const int epoll_fd,

1593

buffer *const password,

1594

string_set *cancelled_filenames,

1595

const mono_microsecs *const current_time,

1596

bool *const mandos_client_exited,

1597

bool *const password_is_read,

1598

const char *const dirname){

1599

__attribute__((cleanup(cleanup_string)))

1600

char *dir_pattern = NULL;

1601

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

1602

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

1603

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

1604

dirname);

1605

return false;

1606

}

1607

__attribute__((cleanup(globfree)))

1608

glob_t question_filenames = {};

1609

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

1610

NULL, &question_filenames)){

1611

case GLOB_ABORTED:

1612

default:

1613

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

1614

return false;

1615

case GLOB_NOMATCH:

1616

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

1617

return false;

1618

case GLOB_NOSPACE:

1619

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

1620

" names in %s", dirname);

1621

#if __GNUC__ < 7

1622

/* FALLTHROUGH */

1623

#else

1624

__attribute__((fallthrough));

1625

#endif

1626

case 0:

1627

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

1628

char *const question_filename = strdup(question_filenames

1629

.gl_pathv[i]);

1630

const task_context task = {

1631

.func=open_and_parse_question,

1632

.epoll_fd=epoll_fd,

1633

.question_filename=question_filename,

1634

.filename=question_filename,

1635

.password=password,

1636

.cancelled_filenames=cancelled_filenames,

1637

.current_time=current_time,

1638

.mandos_client_exited=mandos_client_exited,

1639

.password_is_read=password_is_read,

1640

};

1641

1642

if(question_filename == NULL

1643

or not add_to_queue(queue, task)){

1644

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

1645

" file %s to queue",

1646

question_filenames.gl_pathv[i]);

1647

free(question_filename);

1648

} else {

1649

queue->next_run = 1;

1650

}

1651

}

1652

return true;

1653

}

1654

}

1655

1656

__attribute__((nonnull, warn_unused_result))

1657

bool wait_for_event(const int epoll_fd,

1658

const mono_microsecs queue_next_run,

1659

const mono_microsecs current_time){

1660

__attribute__((const))

1661

int milliseconds_to_wait(const mono_microsecs currtime,

1662

const mono_microsecs nextrun){

1663

if(currtime >= nextrun){

1664

return 0;

1665

}

1666

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

1667

if(wait_time_ms > (uintmax_t)INT_MAX){

1668

return INT_MAX;

1669

}

1670

return (int)wait_time_ms;

1671

}

1672

1673

const int wait_time_ms = milliseconds_to_wait(current_time,

1674

queue_next_run);

1675

1676

/* Prepare unblocking of SIGCHLD during epoll_pwait */

1677

sigset_t temporary_unblocked_sigmask;

1678

/* Get current signal mask */

1679

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

1680

return false;

1681

}

1682

/* Remove SIGCHLD from the signal mask */

1683

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

1684

return false;

1685

}

1686

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

1687

int ret = epoll_pwait(epoll_fd, events,

1688

sizeof(events) / sizeof(struct epoll_event),

1689

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

1690

&temporary_unblocked_sigmask);

1691

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

1692

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

1693

" ...", epoll_fd,

1694

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

1695

return false;

1696

}

1697

return clear_all_fds_from_epoll_set(epoll_fd);

1698

}

1699

1700

bool clear_all_fds_from_epoll_set(const int epoll_fd){

1701

/* Create a new empty epoll set */

1702

__attribute__((cleanup(cleanup_close)))

1703

const int new_epoll_fd = epoll_create1(EPOLL_CLOEXEC);

1704

if(new_epoll_fd < 0){

1705

return false;

1706

}

1707

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

1708

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

1709

return false;

1710

}

1711

return true;

1712

}

1713

1714

__attribute__((nonnull, warn_unused_result))

1715

bool run_queue(task_queue **const queue,

1716

string_set *const cancelled_filenames,

1717

bool *const quit_now){

1718

1719

task_queue *new_queue = create_queue();

1720

if(new_queue == NULL){

1721

return false;

1722

}

1723

1724

__attribute__((cleanup(string_set_clear)))

1725

string_set old_cancelled_filenames = {};

1726

string_set_swap(cancelled_filenames, &old_cancelled_filenames);

1727

1728

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

1729

loop in case we aborted in the middle */

1730

size_t i;

1731

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

1732

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

1733

const char *const question_filename = task->question_filename;

1734

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

1735

if(question_filename != NULL

1736

and string_set_contains(old_cancelled_filenames,

1737

question_filename)){

1738

cleanup_task(task);

1739

continue;

1740

}

1741

task->func(*task, new_queue);

1742

}

1743

1744

if(*quit_now){

1745

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

1746

remaining tasks in the current queue */

1747

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

1748

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

1749

}

1750

free_queue(*queue);

1751

*queue = new_queue;

1752

new_queue = NULL;

1753

return false;

1754

}

1755

free_queue(*queue);

1756

*queue = new_queue;

1757

new_queue = NULL;

1758

1759

return true;

1760

}

1761

1762

/* End of regular code section */

1763

1764

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

1765

1766

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

1767

teardown functions */

1768

typedef struct {

1769

struct sigaction orig_sigaction;

1770

sigset_t orig_sigmask;

1771

} test_fixture;

1772

1773

static void test_setup(test_fixture *fixture,

1774

__attribute__((unused))

1775

gconstpointer user_data){

1776

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

1777

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

1778

}

1779

1780

static void test_teardown(test_fixture *fixture,

1781

__attribute__((unused))

1782

gconstpointer user_data){

1783

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

1784

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

1785

}

1786

1787

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

1788

__attribute__((pure, nonnull, warn_unused_result))

1789

static task_context *find_matching_task(const task_queue *const queue,

1790

const task_context task){

1791

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

1792

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

1793

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

1794

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

1795

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

1796

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

1797

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

1798

1799

/* task_func *const func */

1800

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

1801

continue;

1802

}

1803

/* char *const question_filename; */

1804

if(task.question_filename != NULL

1805

and (current_task->question_filename == NULL

1806

or strcmp(current_task->question_filename,

1807

task.question_filename) != 0)){

1808

continue;

1809

}

1810

/* const pid_t pid; */

1811

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

1812

continue;

1813

}

1814

/* const int epoll_fd; */

1815

if(task.epoll_fd != 0

1816

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

1817

continue;

1818

}

1819

/* bool *const quit_now; */

1820

if(task.quit_now != NULL

1821

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

1822

continue;

1823

}

1824

/* const int fd; */

1825

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

1826

continue;

1827

}

1828

/* bool *const mandos_client_exited; */

1829

if(task.mandos_client_exited != NULL

1830

and current_task->mandos_client_exited

1831

!= task.mandos_client_exited){

1832

continue;

1833

}

1834

/* buffer *const password; */

1835

if(task.password != NULL

1836

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

1837

continue;

1838

}

1839

/* bool *const password_is_read; */

1840

if(task.password_is_read != NULL

1841

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

1842

continue;

1843

}

1844

/* char *filename; */

1845

if(task.filename != NULL

1846

and (current_task->filename == NULL

1847

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

1848

continue;

1849

}

1850

/* string_set *const cancelled_filenames; */

1851

if(task.cancelled_filenames != NULL

1852

and current_task->cancelled_filenames

1853

!= task.cancelled_filenames){

1854

continue;

1855

}

1856

/* const mono_microsecs notafter; */

1857

if(task.notafter != 0

1858

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

1859

continue;

1860

}

1861

/* const mono_microsecs *const current_time; */

1862

if(task.current_time != NULL

1863

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

1864

continue;

1865

}

1866

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

1867

return current_task;

1868

}

1869

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

1870

return NULL;

1871

}

1872

1873

static void test_create_queue(__attribute__((unused))

1874

test_fixture *fixture,

1875

__attribute__((unused))

1876

gconstpointer user_data){

1877

__attribute__((cleanup(cleanup_queue)))

1878

task_queue *const queue = create_queue();

1879

g_assert_nonnull(queue);

1880

g_assert_null(queue->tasks);

1881

g_assert_true(queue->length == 0);

1882

g_assert_true(queue->next_run == 0);

1883

}

1884

1885

static task_func dummy_func;

1886

1887

static void test_add_to_queue(__attribute__((unused))

1888

test_fixture *fixture,

1889

__attribute__((unused))

1890

gconstpointer user_data){

1891

__attribute__((cleanup(cleanup_queue)))

1892

task_queue *queue = create_queue();

1893

g_assert_nonnull(queue);

1894

1895

g_assert_true(add_to_queue(queue,

1896

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

1897

g_assert_true(queue->length == 1);

1898

g_assert_nonnull(queue->tasks);

1899

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

1900

}

1901

1902

static void test_add_to_queue_overflow(__attribute__((unused))

1903

test_fixture *fixture,

1904

__attribute__((unused))

1905

gconstpointer user_data){

1906

__attribute__((cleanup(cleanup_queue)))

1907

task_queue *queue = create_queue();

1908

g_assert_nonnull(queue);

1909

g_assert_true(queue->length == 0);

1910

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

1911

1912

FILE *real_stderr = stderr;

1913

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

1914

g_assert_nonnull(devnull);

1915

stderr = devnull;

1916

const bool ret = add_to_queue(queue,

1917

(task_context){ .func=dummy_func });

1918

g_assert_true(errno == ENOMEM);

1919

g_assert_false(ret);

1920

stderr = real_stderr;

1921

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

1922

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

1923

}

1924

1925

static void dummy_func(__attribute__((unused))

1926

const task_context task,

1927

__attribute__((unused))

1928

task_queue *const queue){

1929

}

1930

1931

static void test_queue_has_question_empty(__attribute__((unused))

1932

test_fixture *fixture,

1933

__attribute__((unused))

1934

gconstpointer user_data){

1935

__attribute__((cleanup(cleanup_queue)))

1936

task_queue *queue = create_queue();

1937

g_assert_nonnull(queue);

1938

g_assert_false(queue_has_question(queue));

1939

}

1940

1941

static void test_queue_has_question_false(__attribute__((unused))

1942

test_fixture *fixture,

1943

__attribute__((unused))

1944

gconstpointer user_data){

1945

__attribute__((cleanup(cleanup_queue)))

1946

task_queue *queue = create_queue();

1947

g_assert_nonnull(queue);

1948

g_assert_true(add_to_queue(queue,

1949

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

1950

g_assert_false(queue_has_question(queue));

1951

}

1952

1953

static void test_queue_has_question_true(__attribute__((unused))

1954

test_fixture *fixture,

1955

__attribute__((unused))

1956

gconstpointer user_data){

1957

__attribute__((cleanup(cleanup_queue)))

1958

task_queue *queue = create_queue();

1959

g_assert_nonnull(queue);

1960

char *const question_filename

1961

= strdup("/nonexistent/question_filename");

1962

g_assert_nonnull(question_filename);

1963

task_context task = {

1964

.func=dummy_func,

1965

.question_filename=question_filename,

1966

};

1967

g_assert_true(add_to_queue(queue, task));

1968

g_assert_true(queue_has_question(queue));

1969

}

1970

1971

static void test_queue_has_question_false2(__attribute__((unused))

1972

test_fixture *fixture,

1973

__attribute__((unused))

1974

gconstpointer user_data){

1975

__attribute__((cleanup(cleanup_queue)))

1976

task_queue *queue = create_queue();

1977

g_assert_nonnull(queue);

1978

task_context task = { .func=dummy_func };

1979

g_assert_true(add_to_queue(queue, task));

1980

g_assert_true(add_to_queue(queue, task));

1981

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

1982

g_assert_false(queue_has_question(queue));

1983

}

1984

1985

static void test_queue_has_question_true2(__attribute__((unused))

1986

test_fixture *fixture,

1987

__attribute__((unused))

1988

gconstpointer user_data){

1989

__attribute__((cleanup(cleanup_queue)))

1990

task_queue *queue = create_queue();

1991

g_assert_nonnull(queue);

1992

task_context task1 = { .func=dummy_func };

1993

g_assert_true(add_to_queue(queue, task1));

1994

char *const question_filename

1995

= strdup("/nonexistent/question_filename");

1996

g_assert_nonnull(question_filename);

1997

task_context task2 = {

1998

.func=dummy_func,

1999

.question_filename=question_filename,

2000

};

2001

g_assert_true(add_to_queue(queue, task2));

2002

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

2003

g_assert_true(queue_has_question(queue));

2004

}

2005

2006

static void test_cleanup_buffer(__attribute__((unused))

2007

test_fixture *fixture,

2008

__attribute__((unused))

2009

gconstpointer user_data){

2010

buffer buf = {};

2011

2012

const size_t buffersize = 10;

2013

2014

buf.data = malloc(buffersize);

2015

g_assert_nonnull(buf.data);

2016

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

2017

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

2018

}

2019

2020

cleanup_buffer(&buf);

2021

g_assert_null(buf.data);

2022

}

2023

2024

static

2025

void test_string_set_new_set_contains_nothing(__attribute__((unused))

2026

test_fixture *fixture,

2027

__attribute__((unused))

2028

gconstpointer

2029

user_data){

2030

__attribute__((cleanup(string_set_clear)))

2031

string_set set = {};

2032

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

2033

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

2034

}

2035

2036

static void

2037

test_string_set_with_added_string_contains_it(__attribute__((unused))

2038

test_fixture *fixture,

2039

__attribute__((unused))

2040

gconstpointer

2041

user_data){

2042

__attribute__((cleanup(string_set_clear)))

2043

string_set set = {};

2044

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

2045

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

2046

}

2047

2048

static void

2049

test_string_set_cleared_does_not_contain_str(__attribute__((unused))

2050

test_fixture *fixture,

2051

__attribute__((unused))

2052

gconstpointer user_data){

2053

__attribute__((cleanup(string_set_clear)))

2054

string_set set = {};

2055

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

2056

string_set_clear(&set);

2057

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

2058

}

2059

2060

static

2061

void test_string_set_swap_one_with_empty(__attribute__((unused))

2062

test_fixture *fixture,

2063

__attribute__((unused))

2064

gconstpointer user_data){

2065

__attribute__((cleanup(string_set_clear)))

2066

string_set set1 = {};

2067

__attribute__((cleanup(string_set_clear)))

2068

string_set set2 = {};

2069

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

2070

string_set_swap(&set1, &set2);

2071

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

2072

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

2073

}

2074

2075

static

2076

void test_string_set_swap_empty_with_one(__attribute__((unused))

2077

test_fixture *fixture,

2078

__attribute__((unused))

2079

gconstpointer user_data){

2080

__attribute__((cleanup(string_set_clear)))

2081

string_set set1 = {};

2082

__attribute__((cleanup(string_set_clear)))

2083

string_set set2 = {};

2084

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

2085

string_set_swap(&set1, &set2);

2086

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

2087

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

2088

}

2089

2090

static void test_string_set_swap_one_with_one(__attribute__((unused))

2091

test_fixture *fixture,

2092

__attribute__((unused))

2093

gconstpointer

2094

user_data){

2095

__attribute__((cleanup(string_set_clear)))

2096

string_set set1 = {};

2097

__attribute__((cleanup(string_set_clear)))

2098

string_set set2 = {};

2099

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

2100

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

2101

string_set_swap(&set1, &set2);

2102

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

2103

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

2104

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

2105

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

2106

}

2107

2108

static bool fd_has_cloexec_and_nonblock(const int);

2109

2110

static bool epoll_set_contains(int, int, uint32_t);

2111

2112

static void test_start_mandos_client(test_fixture *fixture,

2113

__attribute__((unused))

2114

gconstpointer user_data){

2115

2116

bool mandos_client_exited = false;

2117

bool quit_now = false;

2118

__attribute__((cleanup(cleanup_close)))

2119

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2120

g_assert_cmpint(epoll_fd, >=, 0);

2121

__attribute__((cleanup(cleanup_queue)))

2122

task_queue *queue = create_queue();

2123

g_assert_nonnull(queue);

2124

buffer password = {};

2125

bool password_is_read = false;

2126

const char helper_directory[] = "/nonexistent";

2127

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

2128

2129

g_assert_true(start_mandos_client(queue, epoll_fd,

2130

&mandos_client_exited, &quit_now,

2131

&password, &password_is_read,

2132

&fixture->orig_sigaction,

2133

fixture->orig_sigmask,

2134

helper_directory, 0, 0, argv));

2135

2136

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

2137

2138

const task_context *const added_wait_task

2139

= find_matching_task(queue, (task_context){

2140

.func=wait_for_mandos_client_exit,

2141

.mandos_client_exited=&mandos_client_exited,

2142

.quit_now=&quit_now,

2143

});

2144

g_assert_nonnull(added_wait_task);

2145

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

2146

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

2147

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

2148

2149

const task_context *const added_read_task

2150

= find_matching_task(queue, (task_context){

2151

.func=read_mandos_client_output,

2152

.epoll_fd=epoll_fd,

2153

.password=&password,

2154

.password_is_read=&password_is_read,

2155

.quit_now=&quit_now,

2156

});

2157

g_assert_nonnull(added_read_task);

2158

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

2159

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

2160

g_assert_true(epoll_set_contains(epoll_fd, added_read_task->fd,

2161

EPOLLIN | EPOLLRDHUP));

2162

}

2163

2164

static bool fd_has_cloexec_and_nonblock(const int fd){

2165

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

2166

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

2167

return ((socket_fd_flags >= 0)

2168

and (socket_fd_flags & FD_CLOEXEC)

2169

and (socket_file_flags >= 0)

2170

and (socket_file_flags & O_NONBLOCK));

2171

}

2172

2173

__attribute__((const))

2174

bool is_privileged(void){

2175

uid_t user = getuid() + 1;

2176

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

2177

user++;

2178

}

2179

gid_t group = getuid() + 1;

2180

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

2181

group++;

2182

}

2183

const pid_t pid = fork();

2184

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

2185

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

2186

if(errno != EPERM){

2187

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

2188

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

2189

}

2190

exit(EXIT_FAILURE);

2191

}

2192

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

2193

if(errno != EPERM){

2194

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

2195

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

2196

}

2197

exit(EXIT_FAILURE);

2198

}

2199

exit(EXIT_SUCCESS);

2200

}

2201

if(pid == -1){

2202

error(EXIT_FAILURE, errno, "Failed to fork()");

2203

}

2204

2205

int status;

2206

waitpid(pid, &status, 0);

2207

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

2208

return true;

2209

}

2210

return false;

2211

}

2212

2213

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

2214

/* Only scan for events in this eventmask */

2215

const uint32_t eventmask = EPOLLIN | EPOLLOUT | EPOLLRDHUP;

2216

__attribute__((cleanup(cleanup_string)))

2217

char *fdinfo_name = NULL;

2218

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

2219

g_assert_cmpint(ret, >, 0);

2220

g_assert_nonnull(fdinfo_name);

2221

2222

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

2223

g_assert_nonnull(fdinfo);

2224

uint32_t reported_events;

2225

buffer line = {};

2226

int found_fd = -1;

2227

2228

do {

2229

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

2230

break;

2231

}

2232

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

2233

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

2234

&found_fd, &reported_events) == 2){

2235

if(found_fd == fd){

2236

break;

2237

}

2238

}

2239

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

2240

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

2241

free(line.data);

2242

if(found_fd != fd){

2243

return false;

2244

}

2245

2246

if(events == 0){

2247

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

2248

return true;

2249

}

2250

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

2251

}

2252

2253

static void test_start_mandos_client_execv(test_fixture *fixture,

2254

__attribute__((unused))

2255

gconstpointer user_data){

2256

bool mandos_client_exited = false;

2257

bool quit_now = false;

2258

__attribute__((cleanup(cleanup_close)))

2259

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2260

g_assert_cmpint(epoll_fd, >=, 0);

2261

__attribute__((cleanup(cleanup_queue)))

2262

task_queue *queue = create_queue();

2263

g_assert_nonnull(queue);

2264

__attribute__((cleanup(cleanup_buffer)))

2265

buffer password = {};

2266

const char helper_directory[] = "/nonexistent";

2267

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

2268

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

2269

2270

{

2271

__attribute__((cleanup(cleanup_close)))

2272

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

2273

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2274

g_assert_cmpint(devnull_fd, >=, 0);

2275

__attribute__((cleanup(cleanup_close)))

2276

const int real_stderr_fd = dup(STDERR_FILENO);

2277

g_assert_cmpint(real_stderr_fd, >=, 0);

2278

dup2(devnull_fd, STDERR_FILENO);

2279

2280

const bool success = start_mandos_client(queue, epoll_fd,

2281

&mandos_client_exited,

2282

&quit_now,

2283

&password,

2284

(bool[]){false},

2285

&fixture->orig_sigaction,

2286

fixture->orig_sigmask,

2287

helper_directory, 0, 0,

2288

argv);

2289

dup2(real_stderr_fd, STDERR_FILENO);

2290

g_assert_true(success);

2291

}

2292

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

2293

2294

struct timespec starttime, currtime;

2295

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

2296

do {

2297

queue->next_run = 0;

2298

string_set cancelled_filenames = {};

2299

2300

{

2301

__attribute__((cleanup(cleanup_close)))

2302

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

2303

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2304

g_assert_cmpint(devnull_fd, >=, 0);

2305

__attribute__((cleanup(cleanup_close)))

2306

const int real_stderr_fd = dup(STDERR_FILENO);

2307

g_assert_cmpint(real_stderr_fd, >=, 0);

2308

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

2309

dup2(devnull_fd, STDERR_FILENO);

2310

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

2311

&quit_now);

2312

dup2(real_stderr_fd, STDERR_FILENO);

2313

if(not success){

2314

break;

2315

}

2316

}

2317

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

2318

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

2319

and (not quit_now)

2320

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

2321

2322

g_assert_true(quit_now);

2323

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

2324

g_assert_true(mandos_client_exited);

2325

}

2326

2327

static void test_start_mandos_client_suid_euid(test_fixture *fixture,

2328

__attribute__((unused))

2329

gconstpointer

2330

user_data){

2331

if(not is_privileged()){

2332

g_test_skip("Not privileged");

2333

return;

2334

}

2335

2336

bool mandos_client_exited = false;

2337

bool quit_now = false;

2338

__attribute__((cleanup(cleanup_close)))

2339

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2340

g_assert_cmpint(epoll_fd, >=, 0);

2341

__attribute__((cleanup(cleanup_queue)))

2342

task_queue *queue = create_queue();

2343

g_assert_nonnull(queue);

2344

__attribute__((cleanup(cleanup_buffer)))

2345

buffer password = {};

2346

bool password_is_read = false;

2347

const char helper_directory[] = "/nonexistent";

2348

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

2349

uid_t user = 1000;

2350

gid_t group = 1001;

2351

2352

const bool success = start_mandos_client(queue, epoll_fd,

2353

&mandos_client_exited,

2354

&quit_now, &password,

2355

&password_is_read,

2356

&fixture->orig_sigaction,

2357

fixture->orig_sigmask,

2358

helper_directory, user,

2359

group, argv);

2360

g_assert_true(success);

2361

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

2362

2363

struct timespec starttime, currtime;

2364

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

2365

do {

2366

queue->next_run = 0;

2367

string_set cancelled_filenames = {};

2368

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

2369

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

2370

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

2371

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

2372

and (not quit_now)

2373

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

2374

2375

g_assert_false(quit_now);

2376

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

2377

g_assert_true(mandos_client_exited);

2378

2379

g_assert_true(password_is_read);

2380

g_assert_nonnull(password.data);

2381

2382

uintmax_t id;

2383

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

2384

==, 1);

2385

g_assert_true((uid_t)id == id);

2386

2387

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

2388

}

2389

2390

static void test_start_mandos_client_suid_egid(test_fixture *fixture,

2391

__attribute__((unused))

2392

gconstpointer

2393

user_data){

2394

if(not is_privileged()){

2395

g_test_skip("Not privileged");

2396

return;

2397

}

2398

2399

bool mandos_client_exited = false;

2400

bool quit_now = false;

2401

__attribute__((cleanup(cleanup_close)))

2402

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2403

g_assert_cmpint(epoll_fd, >=, 0);

2404

__attribute__((cleanup(cleanup_queue)))

2405

task_queue *queue = create_queue();

2406

g_assert_nonnull(queue);

2407

__attribute__((cleanup(cleanup_buffer)))

2408

buffer password = {};

2409

bool password_is_read = false;

2410

const char helper_directory[] = "/nonexistent";

2411

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

2412

uid_t user = 1000;

2413

gid_t group = 1001;

2414

2415

const bool success = start_mandos_client(queue, epoll_fd,

2416

&mandos_client_exited,

2417

&quit_now, &password,

2418

&password_is_read,

2419

&fixture->orig_sigaction,

2420

fixture->orig_sigmask,

2421

helper_directory, user,

2422

group, argv);

2423

g_assert_true(success);

2424

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

2425

2426

struct timespec starttime, currtime;

2427

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

2428

do {

2429

queue->next_run = 0;

2430

string_set cancelled_filenames = {};

2431

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

2432

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

2433

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

2434

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

2435

and (not quit_now)

2436

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

2437

2438

g_assert_false(quit_now);

2439

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

2440

g_assert_true(mandos_client_exited);

2441

2442

g_assert_true(password_is_read);

2443

g_assert_nonnull(password.data);

2444

2445

uintmax_t id;

2446

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

2447

==, 1);

2448

g_assert_true((gid_t)id == id);

2449

2450

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

2451

}

2452

2453

static void test_start_mandos_client_suid_ruid(test_fixture *fixture,

2454

__attribute__((unused))

2455

gconstpointer

2456

user_data){

2457

if(not is_privileged()){

2458

g_test_skip("Not privileged");

2459

return;

2460

}

2461

2462

bool mandos_client_exited = false;

2463

bool quit_now = false;

2464

__attribute__((cleanup(cleanup_close)))

2465

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2466

g_assert_cmpint(epoll_fd, >=, 0);

2467

__attribute__((cleanup(cleanup_queue)))

2468

task_queue *queue = create_queue();

2469

g_assert_nonnull(queue);

2470

__attribute__((cleanup(cleanup_buffer)))

2471

buffer password = {};

2472

bool password_is_read = false;

2473

const char helper_directory[] = "/nonexistent";

2474

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

2475

NULL };

2476

uid_t user = 1000;

2477

gid_t group = 1001;

2478

2479

const bool success = start_mandos_client(queue, epoll_fd,

2480

&mandos_client_exited,

2481

&quit_now, &password,

2482

&password_is_read,

2483

&fixture->orig_sigaction,

2484

fixture->orig_sigmask,

2485

helper_directory, user,

2486

group, argv);

2487

g_assert_true(success);

2488

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

2489

2490

struct timespec starttime, currtime;

2491

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

2492

do {

2493

queue->next_run = 0;

2494

string_set cancelled_filenames = {};

2495

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

2496

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

2497

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

2498

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

2499

and (not quit_now)

2500

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

2501

2502

g_assert_false(quit_now);

2503

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

2504

g_assert_true(mandos_client_exited);

2505

2506

g_assert_true(password_is_read);

2507

g_assert_nonnull(password.data);

2508

2509

uintmax_t id;

2510

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

2511

==, 1);

2512

g_assert_true((uid_t)id == id);

2513

2514

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

2515

}

2516

2517

static void test_start_mandos_client_suid_rgid(test_fixture *fixture,

2518

__attribute__((unused))

2519

gconstpointer

2520

user_data){

2521

if(not is_privileged()){

2522

g_test_skip("Not privileged");

2523

return;

2524

}

2525

2526

bool mandos_client_exited = false;

2527

bool quit_now = false;

2528

__attribute__((cleanup(cleanup_close)))

2529

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2530

g_assert_cmpint(epoll_fd, >=, 0);

2531

__attribute__((cleanup(cleanup_queue)))

2532

task_queue *queue = create_queue();

2533

g_assert_nonnull(queue);

2534

__attribute__((cleanup(cleanup_buffer)))

2535

buffer password = {};

2536

bool password_is_read = false;

2537

const char helper_directory[] = "/nonexistent";

2538

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

2539

NULL };

2540

uid_t user = 1000;

2541

gid_t group = 1001;

2542

2543

const bool success = start_mandos_client(queue, epoll_fd,

2544

&mandos_client_exited,

2545

&quit_now, &password,

2546

&password_is_read,

2547

&fixture->orig_sigaction,

2548

fixture->orig_sigmask,

2549

helper_directory, user,

2550

group, argv);

2551

g_assert_true(success);

2552

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

2553

2554

struct timespec starttime, currtime;

2555

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

2556

do {

2557

queue->next_run = 0;

2558

string_set cancelled_filenames = {};

2559

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

2560

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

2561

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

2562

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

2563

and (not quit_now)

2564

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

2565

2566

g_assert_false(quit_now);

2567

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

2568

g_assert_true(mandos_client_exited);

2569

2570

g_assert_true(password_is_read);

2571

g_assert_nonnull(password.data);

2572

2573

uintmax_t id;

2574

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

2575

==, 1);

2576

g_assert_true((gid_t)id == id);

2577

2578

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

2579

}

2580

2581

static void test_start_mandos_client_read(test_fixture *fixture,

2582

__attribute__((unused))

2583

gconstpointer user_data){

2584

bool mandos_client_exited = false;

2585

bool quit_now = false;

2586

__attribute__((cleanup(cleanup_close)))

2587

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2588

g_assert_cmpint(epoll_fd, >=, 0);

2589

__attribute__((cleanup(cleanup_queue)))

2590

task_queue *queue = create_queue();

2591

g_assert_nonnull(queue);

2592

__attribute__((cleanup(cleanup_buffer)))

2593

buffer password = {};

2594

bool password_is_read = false;

2595

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

2596

const char helper_directory[] = "/nonexistent";

2597

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

2598

NULL };

2599

2600

const bool success = start_mandos_client(queue, epoll_fd,

2601

&mandos_client_exited,

2602

&quit_now, &password,

2603

&password_is_read,

2604

&fixture->orig_sigaction,

2605

fixture->orig_sigmask,

2606

helper_directory, 0, 0,

2607

argv);

2608

g_assert_true(success);

2609

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

2610

2611

struct timespec starttime, currtime;

2612

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

2613

do {

2614

queue->next_run = 0;

2615

string_set cancelled_filenames = {};

2616

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

2617

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

2618

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

2619

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

2620

and (not quit_now)

2621

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

2622

2623

g_assert_false(quit_now);

2624

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

2625

g_assert_true(mandos_client_exited);

2626

2627

g_assert_true(password_is_read);

2628

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

2629

sizeof(dummy_test_password)-1);

2630

g_assert_nonnull(password.data);

2631

g_assert_cmpint(memcmp(dummy_test_password, password.data,

2632

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

2633

}

2634

2635

static

2636

void test_start_mandos_client_helper_directory(test_fixture *fixture,

2637

__attribute__((unused))

2638

gconstpointer

2639

user_data){

2640

bool mandos_client_exited = false;

2641

bool quit_now = false;

2642

__attribute__((cleanup(cleanup_close)))

2643

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2644

g_assert_cmpint(epoll_fd, >=, 0);

2645

__attribute__((cleanup(cleanup_queue)))

2646

task_queue *queue = create_queue();

2647

g_assert_nonnull(queue);

2648

__attribute__((cleanup(cleanup_buffer)))

2649

buffer password = {};

2650

bool password_is_read = false;

2651

const char helper_directory[] = "/nonexistent";

2652

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

2653

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

2654

2655

const bool success = start_mandos_client(queue, epoll_fd,

2656

&mandos_client_exited,

2657

&quit_now, &password,

2658

&password_is_read,

2659

&fixture->orig_sigaction,

2660

fixture->orig_sigmask,

2661

helper_directory, 0, 0,

2662

argv);

2663

g_assert_true(success);

2664

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

2665

2666

struct timespec starttime, currtime;

2667

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

2668

do {

2669

queue->next_run = 0;

2670

string_set cancelled_filenames = {};

2671

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

2672

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

2673

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

2674

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

2675

and (not quit_now)

2676

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

2677

2678

g_assert_false(quit_now);

2679

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

2680

g_assert_true(mandos_client_exited);

2681

2682

g_assert_true(password_is_read);

2683

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

2684

sizeof(helper_directory)-1);

2685

g_assert_nonnull(password.data);

2686

g_assert_cmpint(memcmp(helper_directory, password.data,

2687

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

2688

}

2689

2690

__attribute__((nonnull, warn_unused_result))

2691

static bool proc_status_sigblk_to_sigset(const char *const,

2692

sigset_t *const);

2693

2694

static void test_start_mandos_client_sigmask(test_fixture *fixture,

2695

__attribute__((unused))

2696

gconstpointer user_data){

2697

bool mandos_client_exited = false;

2698

bool quit_now = false;

2699

__attribute__((cleanup(cleanup_close)))

2700

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2701

g_assert_cmpint(epoll_fd, >=, 0);

2702

__attribute__((cleanup(cleanup_queue)))

2703

task_queue *queue = create_queue();

2704

g_assert_nonnull(queue);

2705

__attribute__((cleanup(cleanup_buffer)))

2706

buffer password = {};

2707

bool password_is_read = false;

2708

const char helper_directory[] = "/nonexistent";

2709

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

2710

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

2711

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

2712

2713

g_assert_true(start_mandos_client(queue, epoll_fd,

2714

&mandos_client_exited, &quit_now,

2715

&password, &password_is_read,

2716

&fixture->orig_sigaction,

2717

fixture->orig_sigmask,

2718

helper_directory, 0, 0, argv));

2719

2720

struct timespec starttime, currtime;

2721

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

2722

do {

2723

queue->next_run = 0;

2724

string_set cancelled_filenames = {};

2725

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

2726

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

2727

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

2728

} while((not (mandos_client_exited and password_is_read))

2729

and (not quit_now)

2730

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

2731

g_assert_true(mandos_client_exited);

2732

g_assert_true(password_is_read);

2733

2734

sigset_t parsed_sigmask;

2735

g_assert_true(proc_status_sigblk_to_sigset(password.data,

2736

&parsed_sigmask));

2737

2738

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

2739

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

2740

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

2741

g_assert_true(has_signal);

2742

} else {

2743

g_assert_false(has_signal);

2744

}

2745

}

2746

}

2747

2748

__attribute__((nonnull, warn_unused_result))

2749

static bool proc_status_sigblk_to_sigset(const char *const sigblk,

2750

sigset_t *const sigmask){

2751

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

2752

uintmax_t scanned_sigmask;

2753

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

2754

return false;

2755

}

2756

if(sigemptyset(sigmask) != 0){

2757

return false;

2758

}

2759

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

2760

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

2761

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

2762

return false;

2763

}

2764

}

2765

}

2766

return true;

2767

}

2768

2769

static void run_task_with_stderr_to_dev_null(const task_context task,

2770

task_queue *const queue);

2771

2772

static

2773

void test_wait_for_mandos_client_exit_badpid(__attribute__((unused))

2774

test_fixture *fixture,

2775

__attribute__((unused))

2776

gconstpointer user_data){

2777

2778

bool mandos_client_exited = false;

2779

bool quit_now = false;

2780

2781

__attribute__((cleanup(cleanup_queue)))

2782

task_queue *queue = create_queue();

2783

g_assert_nonnull(queue);

2784

const task_context task = {

2785

.func=wait_for_mandos_client_exit,

2786

.pid=1,

2787

.mandos_client_exited=&mandos_client_exited,

2788

.quit_now=&quit_now,

2789

};

2790

run_task_with_stderr_to_dev_null(task, queue);

2791

2792

g_assert_false(mandos_client_exited);

2793

g_assert_true(quit_now);

2794

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

2795

}

2796

2797

static void run_task_with_stderr_to_dev_null(const task_context task,

2798

task_queue *const queue){

2799

FILE *real_stderr = stderr;

2800

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

2801

g_assert_nonnull(devnull);

2802

2803

stderr = devnull;

2804

task.func(task, queue);

2805

stderr = real_stderr;

2806

2807

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

2808

}

2809

2810

static

2811

void test_wait_for_mandos_client_exit_noexit(test_fixture *fixture,

2812

__attribute__((unused))

2813

gconstpointer user_data){

2814

bool mandos_client_exited = false;

2815

bool quit_now = false;

2816

2817

pid_t create_eternal_process(void){

2818

const pid_t pid = fork();

2819

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

2820

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

2821

_exit(EXIT_FAILURE);

2822

}

2823

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

2824

_exit(EXIT_FAILURE);

2825

}

2826

while(true){

2827

pause();

2828

}

2829

}

2830

return pid;

2831

}

2832

pid_t pid = create_eternal_process();

2833

g_assert_true(pid != -1);

2834

2835

__attribute__((cleanup(cleanup_queue)))

2836

task_queue *queue = create_queue();

2837

g_assert_nonnull(queue);

2838

const task_context task = {

2839

.func=wait_for_mandos_client_exit,

2840

.pid=pid,

2841

.mandos_client_exited=&mandos_client_exited,

2842

.quit_now=&quit_now,

2843

};

2844

task.func(task, queue);

2845

2846

g_assert_false(mandos_client_exited);

2847

g_assert_false(quit_now);

2848

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

2849

2850

g_assert_nonnull(find_matching_task(queue, (task_context){

2851

.func=wait_for_mandos_client_exit,

2852

.pid=task.pid,

2853

.mandos_client_exited=&mandos_client_exited,

2854

.quit_now=&quit_now,

2855

}));

2856

}

2857

2858

static

2859

void test_wait_for_mandos_client_exit_success(test_fixture *fixture,

2860

__attribute__((unused))

2861

gconstpointer

2862

user_data){

2863

bool mandos_client_exited = false;

2864

bool quit_now = false;

2865

2866

pid_t create_successful_process(void){

2867

const pid_t pid = fork();

2868

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

2869

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

2870

_exit(EXIT_FAILURE);

2871

}

2872

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

2873

_exit(EXIT_FAILURE);

2874

}

2875

exit(EXIT_SUCCESS);

2876

}

2877

return pid;

2878

}

2879

const pid_t pid = create_successful_process();

2880

g_assert_true(pid != -1);

2881

2882

__attribute__((cleanup(cleanup_queue)))

2883

task_queue *queue = create_queue();

2884

g_assert_nonnull(queue);

2885

const task_context initial_task = {

2886

.func=wait_for_mandos_client_exit,

2887

.pid=pid,

2888

.mandos_client_exited=&mandos_client_exited,

2889

.quit_now=&quit_now,

2890

};

2891

g_assert_true(add_to_queue(queue, initial_task));

2892

2893

struct timespec starttime, currtime;

2894

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

2895

__attribute__((cleanup(cleanup_close)))

2896

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2897

do {

2898

queue->next_run = 0;

2899

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

2900

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

2901

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

2902

} while((not mandos_client_exited)

2903

and (not quit_now)

2904

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

2905

2906

g_assert_true(mandos_client_exited);

2907

g_assert_false(quit_now);

2908

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

2909

}

2910

2911

static

2912

void test_wait_for_mandos_client_exit_failure(test_fixture *fixture,

2913

__attribute__((unused))

2914

gconstpointer

2915

user_data){

2916

bool mandos_client_exited = false;

2917

bool quit_now = false;

2918

2919

pid_t create_failing_process(void){

2920

const pid_t pid = fork();

2921

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

2922

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

2923

_exit(EXIT_FAILURE);

2924

}

2925

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

2926

_exit(EXIT_FAILURE);

2927

}

2928

exit(EXIT_FAILURE);

2929

}

2930

return pid;

2931

}

2932

const pid_t pid = create_failing_process();

2933

g_assert_true(pid != -1);

2934

2935

__attribute__((cleanup(string_set_clear)))

2936

string_set cancelled_filenames = {};

2937

__attribute__((cleanup(cleanup_close)))

2938

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2939

g_assert_cmpint(epoll_fd, >=, 0);

2940

__attribute__((cleanup(cleanup_queue)))

2941

task_queue *queue = create_queue();

2942

g_assert_nonnull(queue);

2943

g_assert_true(add_to_queue(queue, (task_context){

2944

.func=wait_for_mandos_client_exit,

2945

.pid=pid,

2946

.mandos_client_exited=&mandos_client_exited,

2947

.quit_now=&quit_now,

2948

}));

2949

2950

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

2951

2952

__attribute__((cleanup(cleanup_close)))

2953

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

2954

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2955

g_assert_cmpint(devnull_fd, >=, 0);

2956

__attribute__((cleanup(cleanup_close)))

2957

const int real_stderr_fd = dup(STDERR_FILENO);

2958

g_assert_cmpint(real_stderr_fd, >=, 0);

2959

2960

struct timespec starttime, currtime;

2961

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

2962

do {

2963

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

2964

dup2(devnull_fd, STDERR_FILENO);

2965

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

2966

&quit_now);

2967

dup2(real_stderr_fd, STDERR_FILENO);

2968

if(not success){

2969

break;

2970

}

2971

2972

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

2973

} while((not mandos_client_exited)

2974

and (not quit_now)

2975

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

2976

2977

g_assert_true(quit_now);

2978

g_assert_true(mandos_client_exited);

2979

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

2980

}

2981

2982

static

2983

void test_wait_for_mandos_client_exit_killed(test_fixture *fixture,

2984

__attribute__((unused))

2985

gconstpointer user_data){

2986

bool mandos_client_exited = false;

2987

bool quit_now = false;

2988

2989

pid_t create_killed_process(void){

2990

const pid_t pid = fork();

2991

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

2992

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

2993

_exit(EXIT_FAILURE);

2994

}

2995

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

2996

_exit(EXIT_FAILURE);

2997

}

2998

while(true){

2999

pause();

3000

}

3001

}

3002

kill(pid, SIGKILL);

3003

return pid;

3004

}

3005

const pid_t pid = create_killed_process();

3006

g_assert_true(pid != -1);

3007

3008

__attribute__((cleanup(string_set_clear)))

3009

string_set cancelled_filenames = {};

3010

__attribute__((cleanup(cleanup_close)))

3011

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3012

g_assert_cmpint(epoll_fd, >=, 0);

3013

__attribute__((cleanup(cleanup_queue)))

3014

task_queue *queue = create_queue();

3015

g_assert_nonnull(queue);

3016

g_assert_true(add_to_queue(queue, (task_context){

3017

.func=wait_for_mandos_client_exit,

3018

.pid=pid,

3019

.mandos_client_exited=&mandos_client_exited,

3020

.quit_now=&quit_now,

3021

}));

3022

3023

__attribute__((cleanup(cleanup_close)))

3024

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

3025

O_WRONLY | O_CLOEXEC, O_NOCTTY);

3026

g_assert_cmpint(devnull_fd, >=, 0);

3027

__attribute__((cleanup(cleanup_close)))

3028

const int real_stderr_fd = dup(STDERR_FILENO);

3029

g_assert_cmpint(real_stderr_fd, >=, 0);

3030

3031

struct timespec starttime, currtime;

3032

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

3033

do {

3034

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

3035

dup2(devnull_fd, STDERR_FILENO);

3036

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

3037

&quit_now);

3038

dup2(real_stderr_fd, STDERR_FILENO);

3039

if(not success){

3040

break;

3041

}

3042

3043

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

3044

} while((not mandos_client_exited)

3045

and (not quit_now)

3046

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

3047

3048

g_assert_true(mandos_client_exited);

3049

g_assert_true(quit_now);

3050

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

3051

}

3052

3053

static bool epoll_set_does_not_contain(int, int);

3054

3055

static

3056

void test_read_mandos_client_output_readerror(__attribute__((unused))

3057

test_fixture *fixture,

3058

__attribute__((unused))

3059

gconstpointer

3060

user_data){

3061

__attribute__((cleanup(cleanup_close)))

3062

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3063

g_assert_cmpint(epoll_fd, >=, 0);

3064

3065

__attribute__((cleanup(cleanup_buffer)))

3066

buffer password = {};

3067

3068

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

3069

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

3070

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3071

3072

bool password_is_read = false;

3073

bool quit_now = false;

3074

__attribute__((cleanup(cleanup_queue)))

3075

task_queue *queue = create_queue();

3076

g_assert_nonnull(queue);

3077

3078

task_context task = {

3079

.func=read_mandos_client_output,

3080

.epoll_fd=epoll_fd,

3081

.fd=fd,

3082

.password=&password,

3083

.password_is_read=&password_is_read,

3084

.quit_now=&quit_now,

3085

};

3086

run_task_with_stderr_to_dev_null(task, queue);

3087

g_assert_false(password_is_read);

3088

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

3089

g_assert_true(quit_now);

3090

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

3091

3092

g_assert_true(epoll_set_does_not_contain(epoll_fd, fd));

3093

3094

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

3095

}

3096

3097

static bool epoll_set_does_not_contain(int epoll_fd, int fd){

3098

return not epoll_set_contains(epoll_fd, fd, 0);

3099

}

3100

3101

static

3102

void test_read_mandos_client_output_nodata(__attribute__((unused))

3103

test_fixture *fixture,

3104

__attribute__((unused))

3105

gconstpointer user_data){

3106

__attribute__((cleanup(cleanup_close)))

3107

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3108

g_assert_cmpint(epoll_fd, >=, 0);

3109

3110

int pipefds[2];

3111

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

3112

3113

__attribute__((cleanup(cleanup_buffer)))

3114

buffer password = {};

3115

3116

bool password_is_read = false;

3117

bool quit_now = false;

3118

__attribute__((cleanup(cleanup_queue)))

3119

task_queue *queue = create_queue();

3120

g_assert_nonnull(queue);

3121

3122

task_context task = {

3123

.func=read_mandos_client_output,

3124

.epoll_fd=epoll_fd,

3125

.fd=pipefds[0],

3126

.password=&password,

3127

.password_is_read=&password_is_read,

3128

.quit_now=&quit_now,

3129

};

3130

task.func(task, queue);

3131

g_assert_false(password_is_read);

3132

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

3133

g_assert_false(quit_now);

3134

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

3135

3136

g_assert_nonnull(find_matching_task(queue, (task_context){

3137

.func=read_mandos_client_output,

3138

.epoll_fd=epoll_fd,

3139

.fd=pipefds[0],

3140

.password=&password,

3141

.password_is_read=&password_is_read,

3142

.quit_now=&quit_now,

3143

}));

3144

3145

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3146

EPOLLIN | EPOLLRDHUP));

3147

3148

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

3149

}

3150

3151

static void test_read_mandos_client_output_eof(__attribute__((unused))

3152

test_fixture *fixture,

3153

__attribute__((unused))

3154

gconstpointer

3155

user_data){

3156

__attribute__((cleanup(cleanup_close)))

3157

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3158

g_assert_cmpint(epoll_fd, >=, 0);

3159

3160

int pipefds[2];

3161

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

3162

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

3163

3164

__attribute__((cleanup(cleanup_buffer)))

3165

buffer password = {};

3166

3167

bool password_is_read = false;

3168

bool quit_now = false;

3169

__attribute__((cleanup(cleanup_queue)))

3170

task_queue *queue = create_queue();

3171

g_assert_nonnull(queue);

3172

3173

task_context task = {

3174

.func=read_mandos_client_output,

3175

.epoll_fd=epoll_fd,

3176

.fd=pipefds[0],

3177

.password=&password,

3178

.password_is_read=&password_is_read,

3179

.quit_now=&quit_now,

3180

};

3181

task.func(task, queue);

3182

g_assert_true(password_is_read);

3183

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

3184

g_assert_false(quit_now);

3185

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

3186

3187

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

3188

3189

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

3190

}

3191

3192

static

3193

void test_read_mandos_client_output_once(__attribute__((unused))

3194

test_fixture *fixture,

3195

__attribute__((unused))

3196

gconstpointer user_data){

3197

__attribute__((cleanup(cleanup_close)))

3198

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3199

g_assert_cmpint(epoll_fd, >=, 0);

3200

3201

int pipefds[2];

3202

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

3203

3204

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

3205

/* Start with a pre-allocated buffer */

3206

__attribute__((cleanup(cleanup_buffer)))

3207

buffer password = {

3208

.data=malloc(sizeof(dummy_test_password)),

3209

.length=0,

3210

.allocated=sizeof(dummy_test_password),

3211

};

3212

g_assert_nonnull(password.data);

3213

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

3214

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

3215

}

3216

3217

bool password_is_read = false;

3218

bool quit_now = false;

3219

__attribute__((cleanup(cleanup_queue)))

3220

task_queue *queue = create_queue();

3221

g_assert_nonnull(queue);

3222

3223

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3224

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

3225

sizeof(dummy_test_password)),

3226

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

3227

3228

task_context task = {

3229

.func=read_mandos_client_output,

3230

.epoll_fd=epoll_fd,

3231

.fd=pipefds[0],

3232

.password=&password,

3233

.password_is_read=&password_is_read,

3234

.quit_now=&quit_now,

3235

};

3236

task.func(task, queue);

3237

3238

g_assert_false(password_is_read);

3239

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

3240

(int)sizeof(dummy_test_password));

3241

g_assert_nonnull(password.data);

3242

g_assert_cmpint(memcmp(password.data, dummy_test_password,

3243

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

3244

3245

g_assert_false(quit_now);

3246

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

3247

3248

g_assert_nonnull(find_matching_task(queue, (task_context){

3249

.func=read_mandos_client_output,

3250

.epoll_fd=epoll_fd,

3251

.fd=pipefds[0],

3252

.password=&password,

3253

.password_is_read=&password_is_read,

3254

.quit_now=&quit_now,

3255

}));

3256

3257

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3258

EPOLLIN | EPOLLRDHUP));

3259

3260

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

3261

}

3262

3263

static

3264

void test_read_mandos_client_output_malloc(__attribute__((unused))

3265

test_fixture *fixture,

3266

__attribute__((unused))

3267

gconstpointer user_data){

3268

__attribute__((cleanup(cleanup_close)))

3269

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3270

g_assert_cmpint(epoll_fd, >=, 0);

3271

3272

int pipefds[2];

3273

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

3274

3275

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

3276

/* Start with an empty buffer */

3277

__attribute__((cleanup(cleanup_buffer)))

3278

buffer password = {};

3279

3280

bool password_is_read = false;

3281

bool quit_now = false;

3282

__attribute__((cleanup(cleanup_queue)))

3283

task_queue *queue = create_queue();

3284

g_assert_nonnull(queue);

3285

3286

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3287

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

3288

sizeof(dummy_test_password)),

3289

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

3290

3291

task_context task = {

3292

.func=read_mandos_client_output,

3293

.epoll_fd=epoll_fd,

3294

.fd=pipefds[0],

3295

.password=&password,

3296

.password_is_read=&password_is_read,

3297

.quit_now=&quit_now,

3298

};

3299

task.func(task, queue);

3300

3301

g_assert_false(password_is_read);

3302

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

3303

(int)sizeof(dummy_test_password));

3304

g_assert_nonnull(password.data);

3305

g_assert_cmpint(memcmp(password.data, dummy_test_password,

3306

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

3307

3308

g_assert_false(quit_now);

3309

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

3310

3311

g_assert_nonnull(find_matching_task(queue, (task_context){

3312

.func=read_mandos_client_output,

3313

.epoll_fd=epoll_fd,

3314

.fd=pipefds[0],

3315

.password=&password,

3316

.password_is_read=&password_is_read,

3317

.quit_now=&quit_now,

3318

}));

3319

3320

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3321

EPOLLIN | EPOLLRDHUP));

3322

3323

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

3324

}

3325

3326

static

3327

void test_read_mandos_client_output_append(__attribute__((unused))

3328

test_fixture *fixture,

3329

__attribute__((unused))

3330

gconstpointer user_data){

3331

__attribute__((cleanup(cleanup_close)))

3332

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3333

g_assert_cmpint(epoll_fd, >=, 0);

3334

3335

int pipefds[2];

3336

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

3337

3338

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

3339

__attribute__((cleanup(cleanup_buffer)))

3340

buffer password = {

3341

.data=malloc(PIPE_BUF),

3342

.length=PIPE_BUF,

3343

.allocated=PIPE_BUF,

3344

};

3345

g_assert_nonnull(password.data);

3346

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

3347

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

3348

}

3349

3350

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

3351

char password_expected[PIPE_BUF];

3352

memcpy(password_expected, password.data, PIPE_BUF);

3353

3354

bool password_is_read = false;

3355

bool quit_now = false;

3356

__attribute__((cleanup(cleanup_queue)))

3357

task_queue *queue = create_queue();

3358

g_assert_nonnull(queue);

3359

3360

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3361

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

3362

sizeof(dummy_test_password)),

3363

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

3364

3365

task_context task = {

3366

.func=read_mandos_client_output,

3367

.epoll_fd=epoll_fd,

3368

.fd=pipefds[0],

3369

.password=&password,

3370

.password_is_read=&password_is_read,

3371

.quit_now=&quit_now,

3372

};

3373

task.func(task, queue);

3374

3375

g_assert_false(password_is_read);

3376

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

3377

PIPE_BUF + sizeof(dummy_test_password));

3378

g_assert_nonnull(password.data);

3379

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

3380

==, 0);

3381

g_assert_cmpint(memcmp(password.data + PIPE_BUF,

3382

dummy_test_password,

3383

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

3384

g_assert_false(quit_now);

3385

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

3386

3387

g_assert_nonnull(find_matching_task(queue, (task_context){

3388

.func=read_mandos_client_output,

3389

.epoll_fd=epoll_fd,

3390

.fd=pipefds[0],

3391

.password=&password,

3392

.password_is_read=&password_is_read,

3393

.quit_now=&quit_now,

3394

}));

3395

3396

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3397

EPOLLIN | EPOLLRDHUP));

3398

}

3399

3400

static char *make_temporary_directory(void);

3401

3402

static void test_add_inotify_dir_watch(__attribute__((unused))

3403

test_fixture *fixture,

3404

__attribute__((unused))

3405

gconstpointer user_data){

3406

__attribute__((cleanup(cleanup_close)))

3407

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3408

g_assert_cmpint(epoll_fd, >=, 0);

3409

__attribute__((cleanup(cleanup_queue)))

3410

task_queue *queue = create_queue();

3411

g_assert_nonnull(queue);

3412

__attribute__((cleanup(string_set_clear)))

3413

string_set cancelled_filenames = {};

3414

const mono_microsecs current_time = 0;

3415

3416

bool quit_now = false;

3417

buffer password = {};

3418

bool mandos_client_exited = false;

3419

bool password_is_read = false;

3420

3421

__attribute__((cleanup(cleanup_string)))

3422

char *tempdir = make_temporary_directory();

3423

g_assert_nonnull(tempdir);

3424

3425

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3426

&password, tempdir,

3427

&cancelled_filenames,

3428

&current_time,

3429

&mandos_client_exited,

3430

&password_is_read));

3431

3432

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

3433

3434

const task_context *const added_read_task

3435

= find_matching_task(queue, (task_context){

3436

.func=read_inotify_event,

3437

.epoll_fd=epoll_fd,

3438

.quit_now=&quit_now,

3439

.password=&password,

3440

.filename=tempdir,

3441

.cancelled_filenames=&cancelled_filenames,

3442

.current_time=&current_time,

3443

.mandos_client_exited=&mandos_client_exited,

3444

.password_is_read=&password_is_read,

3445

});

3446

g_assert_nonnull(added_read_task);

3447

3448

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

3449

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3450

g_assert_true(epoll_set_contains(added_read_task->epoll_fd,

3451

added_read_task->fd,

3452

EPOLLIN | EPOLLRDHUP));

3453

3454

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

3455

}

3456

3457

static char *make_temporary_directory(void){

3458

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

3459

g_assert_nonnull(name);

3460

char *result = mkdtemp(name);

3461

if(result == NULL){

3462

free(name);

3463

}

3464

return result;

3465

}

3466

3467

static void test_add_inotify_dir_watch_fail(__attribute__((unused))

3468

test_fixture *fixture,

3469

__attribute__((unused))

3470

gconstpointer user_data){

3471

__attribute__((cleanup(cleanup_close)))

3472

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3473

g_assert_cmpint(epoll_fd, >=, 0);

3474

__attribute__((cleanup(cleanup_queue)))

3475

task_queue *queue = create_queue();

3476

g_assert_nonnull(queue);

3477

__attribute__((cleanup(string_set_clear)))

3478

string_set cancelled_filenames = {};

3479

const mono_microsecs current_time = 0;

3480

3481

bool quit_now = false;

3482

buffer password = {};

3483

bool mandos_client_exited = false;

3484

bool password_is_read = false;

3485

3486

const char nonexistent_dir[] = "/nonexistent";

3487

3488

FILE *real_stderr = stderr;

3489

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

3490

g_assert_nonnull(devnull);

3491

stderr = devnull;

3492

g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3493

&password, nonexistent_dir,

3494

&cancelled_filenames,

3495

&current_time,

3496

&mandos_client_exited,

3497

&password_is_read));

3498

stderr = real_stderr;

3499

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

3500

3501

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

3502

}

3503

3504

static void test_add_inotify_dir_watch_nondir(__attribute__((unused))

3505

test_fixture *fixture,

3506

__attribute__((unused))

3507

gconstpointer

3508

user_data){

3509

__attribute__((cleanup(cleanup_close)))

3510

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3511

g_assert_cmpint(epoll_fd, >=, 0);

3512

__attribute__((cleanup(cleanup_queue)))

3513

task_queue *queue = create_queue();

3514

g_assert_nonnull(queue);

3515

__attribute__((cleanup(string_set_clear)))

3516

string_set cancelled_filenames = {};

3517

const mono_microsecs current_time = 0;

3518

3519

bool quit_now = false;

3520

buffer password = {};

3521

bool mandos_client_exited = false;

3522

bool password_is_read = false;

3523

3524

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

3525

3526

FILE *real_stderr = stderr;

3527

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

3528

g_assert_nonnull(devnull);

3529

stderr = devnull;

3530

g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3531

&password, not_a_directory,

3532

&cancelled_filenames,

3533

&current_time,

3534

&mandos_client_exited,

3535

&password_is_read));

3536

stderr = real_stderr;

3537

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

3538

3539

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

3540

}

3541

3542

static void test_add_inotify_dir_watch_EAGAIN(__attribute__((unused))

3543

test_fixture *fixture,

3544

__attribute__((unused))

3545

gconstpointer

3546

user_data){

3547

__attribute__((cleanup(cleanup_close)))

3548

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3549

g_assert_cmpint(epoll_fd, >=, 0);

3550

__attribute__((cleanup(cleanup_queue)))

3551

task_queue *queue = create_queue();

3552

g_assert_nonnull(queue);

3553

__attribute__((cleanup(string_set_clear)))

3554

string_set cancelled_filenames = {};

3555

const mono_microsecs current_time = 0;

3556

3557

bool quit_now = false;

3558

buffer password = {};

3559

bool mandos_client_exited = false;

3560

bool password_is_read = false;

3561

3562

__attribute__((cleanup(cleanup_string)))

3563

char *tempdir = make_temporary_directory();

3564

g_assert_nonnull(tempdir);

3565

3566

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3567

&password, tempdir,

3568

&cancelled_filenames,

3569

&current_time,

3570

&mandos_client_exited,

3571

&password_is_read));

3572

3573

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

3574

3575

const task_context *const added_read_task

3576

= find_matching_task(queue,

3577

(task_context){ .func=read_inotify_event });

3578

g_assert_nonnull(added_read_task);

3579

3580

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

3581

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3582

3583

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

3584

const size_t ievent_size = (sizeof(struct inotify_event)

3585

+ NAME_MAX + 1);

3586

struct inotify_event *ievent = malloc(ievent_size);

3587

g_assert_nonnull(ievent);

3588

3589

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

3590

-1);

3591

g_assert_cmpint(errno, ==, EAGAIN);

3592

3593

free(ievent);

3594

3595

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

3596

}

3597

3598

static char *make_temporary_file_in_directory(const char

3599

*const dir);

3600

3601

static

3602

void test_add_inotify_dir_watch_IN_CLOSE_WRITE(__attribute__((unused))

3603

test_fixture *fixture,

3604

__attribute__((unused))

3605

gconstpointer

3606

user_data){

3607

__attribute__((cleanup(cleanup_close)))

3608

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3609

g_assert_cmpint(epoll_fd, >=, 0);

3610

__attribute__((cleanup(cleanup_queue)))

3611

task_queue *queue = create_queue();

3612

g_assert_nonnull(queue);

3613

__attribute__((cleanup(string_set_clear)))

3614

string_set cancelled_filenames = {};

3615

const mono_microsecs current_time = 0;

3616

3617

bool quit_now = false;

3618

buffer password = {};

3619

bool mandos_client_exited = false;

3620

bool password_is_read = false;

3621

3622

__attribute__((cleanup(cleanup_string)))

3623

char *tempdir = make_temporary_directory();

3624

g_assert_nonnull(tempdir);

3625

3626

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3627

&password, tempdir,

3628

&cancelled_filenames,

3629

&current_time,

3630

&mandos_client_exited,

3631

&password_is_read));

3632

3633

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

3634

3635

const task_context *const added_read_task

3636

= find_matching_task(queue,

3637

(task_context){ .func=read_inotify_event });

3638

g_assert_nonnull(added_read_task);

3639

3640

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

3641

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3642

3643

__attribute__((cleanup(cleanup_string)))

3644

char *filename = make_temporary_file_in_directory(tempdir);

3645

g_assert_nonnull(filename);

3646

3647

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

3648

const size_t ievent_size = (sizeof(struct inotify_event)

3649

+ NAME_MAX + 1);

3650

struct inotify_event *ievent = malloc(ievent_size);

3651

g_assert_nonnull(ievent);

3652

3653

ssize_t read_size = 0;

3654

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

3655

3656

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

3657

g_assert_true(ievent->mask & IN_CLOSE_WRITE);

3658

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

3659

3660

free(ievent);

3661

3662

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

3663

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

3664

}

3665

3666

static char *make_temporary_prefixed_file_in_directory(const char

3667

*const prefix,

3668

const char

3669

*const dir){

3670

char *filename = NULL;

3671

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

3672

>, 0);

3673

g_assert_nonnull(filename);

3674

const int fd = mkostemp(filename, O_CLOEXEC);

3675

g_assert_cmpint(fd, >=, 0);

3676

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

3677

return filename;

3678

}

3679

3680

static char *make_temporary_file_in_directory(const char

3681

*const dir){

3682

return make_temporary_prefixed_file_in_directory("temp", dir);

3683

}

3684

3685

static

3686

void test_add_inotify_dir_watch_IN_MOVED_TO(__attribute__((unused))

3687

test_fixture *fixture,

3688

__attribute__((unused))

3689

gconstpointer user_data){

3690

__attribute__((cleanup(cleanup_close)))

3691

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3692

g_assert_cmpint(epoll_fd, >=, 0);

3693

__attribute__((cleanup(cleanup_queue)))

3694

task_queue *queue = create_queue();

3695

g_assert_nonnull(queue);

3696

__attribute__((cleanup(string_set_clear)))

3697

string_set cancelled_filenames = {};

3698

const mono_microsecs current_time = 0;

3699

3700

bool quit_now = false;

3701

buffer password = {};

3702

bool mandos_client_exited = false;

3703

bool password_is_read = false;

3704

3705

__attribute__((cleanup(cleanup_string)))

3706

char *watchdir = make_temporary_directory();

3707

g_assert_nonnull(watchdir);

3708

3709

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3710

&password, watchdir,

3711

&cancelled_filenames,

3712

&current_time,

3713

&mandos_client_exited,

3714

&password_is_read));

3715

3716

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

3717

3718

const task_context *const added_read_task

3719

= find_matching_task(queue,

3720

(task_context){ .func=read_inotify_event });

3721

g_assert_nonnull(added_read_task);

3722

3723

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

3724

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3725

3726

char *sourcedir = make_temporary_directory();

3727

g_assert_nonnull(sourcedir);

3728

3729

__attribute__((cleanup(cleanup_string)))

3730

char *filename = make_temporary_file_in_directory(sourcedir);

3731

g_assert_nonnull(filename);

3732

3733

__attribute__((cleanup(cleanup_string)))

3734

char *targetfilename = NULL;

3735

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

3736

basename(filename)), >, 0);

3737

g_assert_nonnull(targetfilename);

3738

3739

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

3740

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

3741

free(sourcedir);

3742

3743

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

3744

const size_t ievent_size = (sizeof(struct inotify_event)

3745

+ NAME_MAX + 1);

3746

struct inotify_event *ievent = malloc(ievent_size);

3747

g_assert_nonnull(ievent);

3748

3749

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

3750

3751

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

3752

g_assert_true(ievent->mask & IN_MOVED_TO);

3753

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

3754

3755

free(ievent);

3756

3757

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

3758

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

3759

}

3760

3761

static

3762

void test_add_inotify_dir_watch_IN_MOVED_FROM(__attribute__((unused))

3763

test_fixture *fixture,

3764

__attribute__((unused))

3765

gconstpointer

3766

user_data){

3767

__attribute__((cleanup(cleanup_close)))

3768

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3769

g_assert_cmpint(epoll_fd, >=, 0);

3770

__attribute__((cleanup(cleanup_queue)))

3771

task_queue *queue = create_queue();

3772

g_assert_nonnull(queue);

3773

__attribute__((cleanup(string_set_clear)))

3774

string_set cancelled_filenames = {};

3775

const mono_microsecs current_time = 0;

3776

3777

bool quit_now = false;

3778

buffer password = {};

3779

bool mandos_client_exited = false;

3780

bool password_is_read = false;

3781

3782

__attribute__((cleanup(cleanup_string)))

3783

char *tempdir = make_temporary_directory();

3784

g_assert_nonnull(tempdir);

3785

3786

__attribute__((cleanup(cleanup_string)))

3787

char *tempfilename = make_temporary_file_in_directory(tempdir);

3788

g_assert_nonnull(tempfilename);

3789

3790

__attribute__((cleanup(cleanup_string)))

3791

char *targetdir = make_temporary_directory();

3792

g_assert_nonnull(targetdir);

3793

3794

__attribute__((cleanup(cleanup_string)))

3795

char *targetfilename = NULL;

3796

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

3797

basename(tempfilename)), >, 0);

3798

g_assert_nonnull(targetfilename);

3799

3800

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3801

&password, tempdir,

3802

&cancelled_filenames,

3803

&current_time,

3804

&mandos_client_exited,

3805

&password_is_read));

3806

3807

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

3808

3809

const task_context *const added_read_task

3810

= find_matching_task(queue,

3811

(task_context){ .func=read_inotify_event });

3812

g_assert_nonnull(added_read_task);

3813

3814

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

3815

const size_t ievent_size = (sizeof(struct inotify_event)

3816

+ NAME_MAX + 1);

3817

struct inotify_event *ievent = malloc(ievent_size);

3818

g_assert_nonnull(ievent);

3819

3820

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

3821

3822

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

3823

g_assert_true(ievent->mask & IN_MOVED_FROM);

3824

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

3825

3826

free(ievent);

3827

3828

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

3829

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

3830

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

3831

}

3832

3833

static

3834

void test_add_inotify_dir_watch_IN_DELETE(__attribute__((unused))

3835

test_fixture *fixture,

3836

__attribute__((unused))

3837

gconstpointer user_data){

3838

__attribute__((cleanup(cleanup_close)))

3839

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3840

g_assert_cmpint(epoll_fd, >=, 0);

3841

__attribute__((cleanup(cleanup_queue)))

3842

task_queue *queue = create_queue();

3843

g_assert_nonnull(queue);

3844

__attribute__((cleanup(string_set_clear)))

3845

string_set cancelled_filenames = {};

3846

const mono_microsecs current_time = 0;

3847

3848

bool quit_now = false;

3849

buffer password = {};

3850

bool mandos_client_exited = false;

3851

bool password_is_read = false;

3852

3853

__attribute__((cleanup(cleanup_string)))

3854

char *tempdir = make_temporary_directory();

3855

g_assert_nonnull(tempdir);

3856

3857

__attribute__((cleanup(cleanup_string)))

3858

char *tempfile = make_temporary_file_in_directory(tempdir);

3859

g_assert_nonnull(tempfile);

3860

3861

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3862

&password, tempdir,

3863

&cancelled_filenames,

3864

&current_time,

3865

&mandos_client_exited,

3866

&password_is_read));

3867

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

3868

3869

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

3870

3871

const task_context *const added_read_task

3872

= find_matching_task(queue,

3873

(task_context){ .func=read_inotify_event });

3874

g_assert_nonnull(added_read_task);

3875

3876

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

3877

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3878

3879

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

3880

const size_t ievent_size = (sizeof(struct inotify_event)

3881

+ NAME_MAX + 1);

3882

struct inotify_event *ievent = malloc(ievent_size);

3883

g_assert_nonnull(ievent);

3884

3885

ssize_t read_size = 0;

3886

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

3887

3888

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

3889

g_assert_true(ievent->mask & IN_DELETE);

3890

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

3891

3892

free(ievent);

3893

3894

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

3895

}

3896

3897

static

3898

void test_add_inotify_dir_watch_IN_EXCL_UNLINK(__attribute__((unused))

3899

test_fixture *fixture,

3900

__attribute__((unused))

3901

gconstpointer

3902

user_data){

3903

__attribute__((cleanup(cleanup_close)))

3904

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3905

g_assert_cmpint(epoll_fd, >=, 0);

3906

__attribute__((cleanup(cleanup_queue)))

3907

task_queue *queue = create_queue();

3908

g_assert_nonnull(queue);

3909

__attribute__((cleanup(string_set_clear)))

3910

string_set cancelled_filenames = {};

3911

const mono_microsecs current_time = 0;

3912

3913

bool quit_now = false;

3914

buffer password = {};

3915

bool mandos_client_exited = false;

3916

bool password_is_read = false;

3917

3918

__attribute__((cleanup(cleanup_string)))

3919

char *tempdir = make_temporary_directory();

3920

g_assert_nonnull(tempdir);

3921

3922

__attribute__((cleanup(cleanup_string)))

3923

char *tempfile = make_temporary_file_in_directory(tempdir);

3924

g_assert_nonnull(tempfile);

3925

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

3926

| O_NOFOLLOW);

3927

g_assert_cmpint(tempfile_fd, >, 2);

3928

3929

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3930

&password, tempdir,

3931

&cancelled_filenames,

3932

&current_time,

3933

&mandos_client_exited,

3934

&password_is_read));

3935

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

3936

3937

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

3938

3939

const task_context *const added_read_task

3940

= find_matching_task(queue,

3941

(task_context){ .func=read_inotify_event });

3942

g_assert_nonnull(added_read_task);

3943

3944

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

3945

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3946

3947

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

3948

const size_t ievent_size = (sizeof(struct inotify_event)

3949

+ NAME_MAX + 1);

3950

struct inotify_event *ievent = malloc(ievent_size);

3951

g_assert_nonnull(ievent);

3952

3953

ssize_t read_size = 0;

3954

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

3955

3956

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

3957

g_assert_true(ievent->mask & IN_DELETE);

3958

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

3959

3960

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

3961

3962

/* IN_EXCL_UNLINK should make the closing of the previously unlinked

3963

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

3964

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

3965

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

3966

g_assert_true(errno == EAGAIN);

3967

3968

free(ievent);

3969

3970

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

3971

}

3972

3973

static void test_read_inotify_event_readerror(__attribute__((unused))

3974

test_fixture *fixture,

3975

__attribute__((unused))

3976

gconstpointer

3977

user_data){

3978

__attribute__((cleanup(cleanup_close)))

3979

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3980

g_assert_cmpint(epoll_fd, >=, 0);

3981

const mono_microsecs current_time = 0;

3982

3983

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

3984

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

3985

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3986

3987

bool quit_now = false;

3988

__attribute__((cleanup(cleanup_queue)))

3989

task_queue *queue = create_queue();

3990

g_assert_nonnull(queue);

3991

3992

task_context task = {

3993

.func=read_inotify_event,

3994

.epoll_fd=epoll_fd,

3995

.fd=fd,

3996

.quit_now=&quit_now,

3997

.filename=strdup("/nonexistent"),

3998

.cancelled_filenames = &(string_set){},

3999

.notafter=0,

4000

.current_time=&current_time,

4001

};

4002

g_assert_nonnull(task.filename);

4003

run_task_with_stderr_to_dev_null(task, queue);

4004

g_assert_true(quit_now);

4005

g_assert_true(queue->next_run == 0);

4006

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

4007

4008

g_assert_true(epoll_set_does_not_contain(epoll_fd, fd));

4009

4010

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

4011

}

4012

4013

static void test_read_inotify_event_bad_epoll(__attribute__((unused))

4014

test_fixture *fixture,

4015

__attribute__((unused))

4016

gconstpointer

4017

user_data){

4018

const mono_microsecs current_time = 17;

4019

4020

int pipefds[2];

4021

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

4022

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

4023

4024

bool quit_now = false;

4025

buffer password = {};

4026

bool mandos_client_exited = false;

4027

bool password_is_read = false;

4028

__attribute__((cleanup(cleanup_queue)))

4029

task_queue *queue = create_queue();

4030

g_assert_nonnull(queue);

4031

4032

task_context task = {

4033

.func=read_inotify_event,

4034

.epoll_fd=epoll_fd,

4035

.fd=pipefds[0],

4036

.quit_now=&quit_now,

4037

.password=&password,

4038

.filename=strdup("/nonexistent"),

4039

.cancelled_filenames = &(string_set){},

4040

.notafter=0,

4041

.current_time=&current_time,

4042

.mandos_client_exited=&mandos_client_exited,

4043

.password_is_read=&password_is_read,

4044

};

4045

g_assert_nonnull(task.filename);

4046

run_task_with_stderr_to_dev_null(task, queue);

4047

4048

g_assert_nonnull(find_matching_task(queue, task));

4049

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

4050

4051

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

4052

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

4053

}

4054

4055

static void test_read_inotify_event_nodata(__attribute__((unused))

4056

test_fixture *fixture,

4057

__attribute__((unused))

4058

gconstpointer user_data){

4059

__attribute__((cleanup(cleanup_close)))

4060

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4061

g_assert_cmpint(epoll_fd, >=, 0);

4062

const mono_microsecs current_time = 0;

4063

4064

int pipefds[2];

4065

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

4066

4067

bool quit_now = false;

4068

buffer password = {};

4069

bool mandos_client_exited = false;

4070

bool password_is_read = false;

4071

__attribute__((cleanup(cleanup_queue)))

4072

task_queue *queue = create_queue();

4073

g_assert_nonnull(queue);

4074

4075

task_context task = {

4076

.func=read_inotify_event,

4077

.epoll_fd=epoll_fd,

4078

.fd=pipefds[0],

4079

.quit_now=&quit_now,

4080

.password=&password,

4081

.filename=strdup("/nonexistent"),

4082

.cancelled_filenames = &(string_set){},

4083

.notafter=0,

4084

.current_time=&current_time,

4085

.mandos_client_exited=&mandos_client_exited,

4086

.password_is_read=&password_is_read,

4087

};

4088

g_assert_nonnull(task.filename);

4089

task.func(task, queue);

4090

g_assert_false(quit_now);

4091

g_assert_true(queue->next_run == 0);

4092

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

4093

4094

g_assert_nonnull(find_matching_task(queue, (task_context){

4095

.func=read_inotify_event,

4096

.epoll_fd=epoll_fd,

4097

.fd=pipefds[0],

4098

.quit_now=&quit_now,

4099

.password=&password,

4100

.filename=task.filename,

4101

.cancelled_filenames=task.cancelled_filenames,

4102

.current_time=&current_time,

4103

.mandos_client_exited=&mandos_client_exited,

4104

.password_is_read=&password_is_read,

4105

}));

4106

4107

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4108

EPOLLIN | EPOLLRDHUP));

4109

4110

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

4111

}

4112

4113

static void test_read_inotify_event_eof(__attribute__((unused))

4114

test_fixture *fixture,

4115

__attribute__((unused))

4116

gconstpointer user_data){

4117

__attribute__((cleanup(cleanup_close)))

4118

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4119

g_assert_cmpint(epoll_fd, >=, 0);

4120

const mono_microsecs current_time = 0;

4121

4122

int pipefds[2];

4123

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

4124

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

4125

4126

bool quit_now = false;

4127

buffer password = {};

4128

__attribute__((cleanup(cleanup_queue)))

4129

task_queue *queue = create_queue();

4130

g_assert_nonnull(queue);

4131

4132

task_context task = {

4133

.func=read_inotify_event,

4134

.epoll_fd=epoll_fd,

4135

.fd=pipefds[0],

4136

.quit_now=&quit_now,

4137

.password=&password,

4138

.filename=strdup("/nonexistent"),

4139

.cancelled_filenames = &(string_set){},

4140

.notafter=0,

4141

.current_time=&current_time,

4142

};

4143

run_task_with_stderr_to_dev_null(task, queue);

4144

g_assert_true(quit_now);

4145

g_assert_true(queue->next_run == 0);

4146

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

4147

4148

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

4149

4150

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

4151

}

4152

4153

static

4154

void test_read_inotify_event_IN_CLOSE_WRITE(__attribute__((unused))

4155

test_fixture *fixture,

4156

__attribute__((unused))

4157

gconstpointer user_data){

4158

__attribute__((cleanup(cleanup_close)))

4159

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4160

g_assert_cmpint(epoll_fd, >=, 0);

4161

const mono_microsecs current_time = 0;

4162

4163

int pipefds[2];

4164

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

4165

4166

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

4167

const size_t ievent_max_size = (sizeof(struct inotify_event)

4168

+ NAME_MAX + 1);

4169

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4170

struct {

4171

struct inotify_event event;

4172

char name_buffer[NAME_MAX + 1];

4173

} ievent_buffer;

4174

struct inotify_event *const ievent = &ievent_buffer.event;

4175

4176

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

4177

ievent->mask = IN_CLOSE_WRITE;

4178

ievent->len = sizeof(dummy_file_name);

4179

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

4180

const size_t ievent_size = (sizeof(struct inotify_event)

4181

+ sizeof(dummy_file_name));

4182

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

4183

==, ievent_size);

4184

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

4185

4186

bool quit_now = false;

4187

buffer password = {};

4188

bool mandos_client_exited = false;

4189

bool password_is_read = false;

4190

__attribute__((cleanup(cleanup_queue)))

4191

task_queue *queue = create_queue();

4192

g_assert_nonnull(queue);

4193

4194

task_context task = {

4195

.func=read_inotify_event,

4196

.epoll_fd=epoll_fd,

4197

.fd=pipefds[0],

4198

.quit_now=&quit_now,

4199

.password=&password,

4200

.filename=strdup("/nonexistent"),

4201

.cancelled_filenames = &(string_set){},

4202

.notafter=0,

4203

.current_time=&current_time,

4204

.mandos_client_exited=&mandos_client_exited,

4205

.password_is_read=&password_is_read,

4206

};

4207

task.func(task, queue);

4208

g_assert_false(quit_now);

4209

g_assert_true(queue->next_run != 0);

4210

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

4211

4212

g_assert_nonnull(find_matching_task(queue, (task_context){

4213

.func=read_inotify_event,

4214

.epoll_fd=epoll_fd,

4215

.fd=pipefds[0],

4216

.quit_now=&quit_now,

4217

.password=&password,

4218

.filename=task.filename,

4219

.cancelled_filenames=task.cancelled_filenames,

4220

.current_time=&current_time,

4221

.mandos_client_exited=&mandos_client_exited,

4222

.password_is_read=&password_is_read,

4223

}));

4224

4225

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4226

EPOLLIN | EPOLLRDHUP));

4227

4228

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

4229

4230

__attribute__((cleanup(cleanup_string)))

4231

char *filename = NULL;

4232

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

4233

dummy_file_name), >, 0);

4234

g_assert_nonnull(filename);

4235

g_assert_nonnull(find_matching_task(queue, (task_context){

4236

.func=open_and_parse_question,

4237

.epoll_fd=epoll_fd,

4238

.filename=filename,

4239

.question_filename=filename,

4240

.password=&password,

4241

.cancelled_filenames=task.cancelled_filenames,

4242

.current_time=&current_time,

4243

.mandos_client_exited=&mandos_client_exited,

4244

.password_is_read=&password_is_read,

4245

}));

4246

}

4247

4248

static

4249

void test_read_inotify_event_IN_MOVED_TO(__attribute__((unused))

4250

test_fixture *fixture,

4251

__attribute__((unused))

4252

gconstpointer user_data){

4253

__attribute__((cleanup(cleanup_close)))

4254

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4255

g_assert_cmpint(epoll_fd, >=, 0);

4256

const mono_microsecs current_time = 0;

4257

4258

int pipefds[2];

4259

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

4260

4261

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

4262

const size_t ievent_max_size = (sizeof(struct inotify_event)

4263

+ NAME_MAX + 1);

4264

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4265

struct {

4266

struct inotify_event event;

4267

char name_buffer[NAME_MAX + 1];

4268

} ievent_buffer;

4269

struct inotify_event *const ievent = &ievent_buffer.event;

4270

4271

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

4272

ievent->mask = IN_MOVED_TO;

4273

ievent->len = sizeof(dummy_file_name);

4274

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

4275

const size_t ievent_size = (sizeof(struct inotify_event)

4276

+ sizeof(dummy_file_name));

4277

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

4278

==, ievent_size);

4279

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

4280

4281

bool quit_now = false;

4282

buffer password = {};

4283

bool mandos_client_exited = false;

4284

bool password_is_read = false;

4285

__attribute__((cleanup(cleanup_queue)))

4286

task_queue *queue = create_queue();

4287

g_assert_nonnull(queue);

4288

4289

task_context task = {

4290

.func=read_inotify_event,

4291

.epoll_fd=epoll_fd,

4292

.fd=pipefds[0],

4293

.quit_now=&quit_now,

4294

.password=&password,

4295

.filename=strdup("/nonexistent"),

4296

.cancelled_filenames = &(string_set){},

4297

.notafter=0,

4298

.current_time=&current_time,

4299

.mandos_client_exited=&mandos_client_exited,

4300

.password_is_read=&password_is_read,

4301

};

4302

task.func(task, queue);

4303

g_assert_false(quit_now);

4304

g_assert_true(queue->next_run != 0);

4305

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

4306

4307

g_assert_nonnull(find_matching_task(queue, (task_context){

4308

.func=read_inotify_event,

4309

.epoll_fd=epoll_fd,

4310

.fd=pipefds[0],

4311

.quit_now=&quit_now,

4312

.password=&password,

4313

.filename=task.filename,

4314

.cancelled_filenames=task.cancelled_filenames,

4315

.current_time=&current_time,

4316

.mandos_client_exited=&mandos_client_exited,

4317

.password_is_read=&password_is_read,

4318

}));

4319

4320

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4321

EPOLLIN | EPOLLRDHUP));

4322

4323

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

4324

4325

__attribute__((cleanup(cleanup_string)))

4326

char *filename = NULL;

4327

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

4328

dummy_file_name), >, 0);

4329

g_assert_nonnull(filename);

4330

g_assert_nonnull(find_matching_task(queue, (task_context){

4331

.func=open_and_parse_question,

4332

.epoll_fd=epoll_fd,

4333

.filename=filename,

4334

.question_filename=filename,

4335

.password=&password,

4336

.cancelled_filenames=task.cancelled_filenames,

4337

.current_time=&current_time,

4338

.mandos_client_exited=&mandos_client_exited,

4339

.password_is_read=&password_is_read,

4340

}));

4341

}

4342

4343

static

4344

void test_read_inotify_event_IN_MOVED_FROM(__attribute__((unused))

4345

test_fixture *fixture,

4346

__attribute__((unused))

4347

gconstpointer user_data){

4348

__attribute__((cleanup(cleanup_close)))

4349

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4350

g_assert_cmpint(epoll_fd, >=, 0);

4351

__attribute__((cleanup(string_set_clear)))

4352

string_set cancelled_filenames = {};

4353

const mono_microsecs current_time = 0;

4354

4355

int pipefds[2];

4356

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

4357

4358

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

4359

const size_t ievent_max_size = (sizeof(struct inotify_event)

4360

+ NAME_MAX + 1);

4361

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4362

struct {

4363

struct inotify_event event;

4364

char name_buffer[NAME_MAX + 1];

4365

} ievent_buffer;

4366

struct inotify_event *const ievent = &ievent_buffer.event;

4367

4368

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

4369

ievent->mask = IN_MOVED_FROM;

4370

ievent->len = sizeof(dummy_file_name);

4371

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

4372

const size_t ievent_size = (sizeof(struct inotify_event)

4373

+ sizeof(dummy_file_name));

4374

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

4375

==, ievent_size);

4376

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

4377

4378

bool quit_now = false;

4379

buffer password = {};

4380

bool mandos_client_exited = false;

4381

bool password_is_read = false;

4382

__attribute__((cleanup(cleanup_queue)))

4383

task_queue *queue = create_queue();

4384

g_assert_nonnull(queue);

4385

4386

task_context task = {

4387

.func=read_inotify_event,

4388

.epoll_fd=epoll_fd,

4389

.fd=pipefds[0],

4390

.quit_now=&quit_now,

4391

.password=&password,

4392

.filename=strdup("/nonexistent"),

4393

.cancelled_filenames=&cancelled_filenames,

4394

.current_time=&current_time,

4395

.mandos_client_exited=&mandos_client_exited,

4396

.password_is_read=&password_is_read,

4397

};

4398

task.func(task, queue);

4399

g_assert_false(quit_now);

4400

g_assert_true(queue->next_run == 0);

4401

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

4402

4403

g_assert_nonnull(find_matching_task(queue, (task_context){

4404

.func=read_inotify_event,

4405

.epoll_fd=epoll_fd,

4406

.fd=pipefds[0],

4407

.quit_now=&quit_now,

4408

.password=&password,

4409

.filename=task.filename,

4410

.cancelled_filenames=&cancelled_filenames,

4411

.current_time=&current_time,

4412

.mandos_client_exited=&mandos_client_exited,

4413

.password_is_read=&password_is_read,

4414

}));

4415

4416

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4417

EPOLLIN | EPOLLRDHUP));

4418

4419

__attribute__((cleanup(cleanup_string)))

4420

char *filename = NULL;

4421

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

4422

dummy_file_name), >, 0);

4423

g_assert_nonnull(filename);

4424

g_assert_true(string_set_contains(*task.cancelled_filenames,

4425

filename));

4426

}

4427

4428

static void test_read_inotify_event_IN_DELETE(__attribute__((unused))

4429

test_fixture *fixture,

4430

__attribute__((unused))

4431

gconstpointer

4432

user_data){

4433

__attribute__((cleanup(cleanup_close)))

4434

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4435

g_assert_cmpint(epoll_fd, >=, 0);

4436

__attribute__((cleanup(string_set_clear)))

4437

string_set cancelled_filenames = {};

4438

const mono_microsecs current_time = 0;

4439

4440

int pipefds[2];

4441

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

4442

4443

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

4444

const size_t ievent_max_size = (sizeof(struct inotify_event)

4445

+ NAME_MAX + 1);

4446

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4447

struct {

4448

struct inotify_event event;

4449

char name_buffer[NAME_MAX + 1];

4450

} ievent_buffer;

4451

struct inotify_event *const ievent = &ievent_buffer.event;

4452

4453

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

4454

ievent->mask = IN_DELETE;

4455

ievent->len = sizeof(dummy_file_name);

4456

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

4457

const size_t ievent_size = (sizeof(struct inotify_event)

4458

+ sizeof(dummy_file_name));

4459

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

4460

==, ievent_size);

4461

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

4462

4463

bool quit_now = false;

4464

buffer password = {};

4465

bool mandos_client_exited = false;

4466

bool password_is_read = false;

4467

__attribute__((cleanup(cleanup_queue)))

4468

task_queue *queue = create_queue();

4469

g_assert_nonnull(queue);

4470

4471

task_context task = {

4472

.func=read_inotify_event,

4473

.epoll_fd=epoll_fd,

4474

.fd=pipefds[0],

4475

.quit_now=&quit_now,

4476

.password=&password,

4477

.filename=strdup("/nonexistent"),

4478

.cancelled_filenames=&cancelled_filenames,

4479

.current_time=&current_time,

4480

.mandos_client_exited=&mandos_client_exited,

4481

.password_is_read=&password_is_read,

4482

};

4483

task.func(task, queue);

4484

g_assert_false(quit_now);

4485

g_assert_true(queue->next_run == 0);

4486

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

4487

4488

g_assert_nonnull(find_matching_task(queue, (task_context){

4489

.func=read_inotify_event,

4490

.epoll_fd=epoll_fd,

4491

.fd=pipefds[0],

4492

.quit_now=&quit_now,

4493

.password=&password,

4494

.filename=task.filename,

4495

.cancelled_filenames=&cancelled_filenames,

4496

.current_time=&current_time,

4497

.mandos_client_exited=&mandos_client_exited,

4498

.password_is_read=&password_is_read,

4499

}));

4500

4501

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4502

EPOLLIN | EPOLLRDHUP));

4503

4504

__attribute__((cleanup(cleanup_string)))

4505

char *filename = NULL;

4506

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

4507

dummy_file_name), >, 0);

4508

g_assert_nonnull(filename);

4509

g_assert_true(string_set_contains(*task.cancelled_filenames,

4510

filename));

4511

}

4512

4513

static void

4514

test_read_inotify_event_IN_CLOSE_WRITE_badname(__attribute__((unused))

4515

test_fixture *fixture,

4516

__attribute__((unused))

4517

gconstpointer

4518

user_data){

4519

__attribute__((cleanup(cleanup_close)))

4520

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4521

g_assert_cmpint(epoll_fd, >=, 0);

4522

const mono_microsecs current_time = 0;

4523

4524

int pipefds[2];

4525

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

4526

4527

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

4528

const size_t ievent_max_size = (sizeof(struct inotify_event)

4529

+ NAME_MAX + 1);

4530

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4531

struct {

4532

struct inotify_event event;

4533

char name_buffer[NAME_MAX + 1];

4534

} ievent_buffer;

4535

struct inotify_event *const ievent = &ievent_buffer.event;

4536

4537

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

4538

ievent->mask = IN_CLOSE_WRITE;

4539

ievent->len = sizeof(dummy_file_name);

4540

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

4541

const size_t ievent_size = (sizeof(struct inotify_event)

4542

+ sizeof(dummy_file_name));

4543

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

4544

==, ievent_size);

4545

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

4546

4547

bool quit_now = false;

4548

buffer password = {};

4549

bool mandos_client_exited = false;

4550

bool password_is_read = false;

4551

__attribute__((cleanup(cleanup_queue)))

4552

task_queue *queue = create_queue();

4553

g_assert_nonnull(queue);

4554

4555

task_context task = {

4556

.func=read_inotify_event,

4557

.epoll_fd=epoll_fd,

4558

.fd=pipefds[0],

4559

.quit_now=&quit_now,

4560

.password=&password,

4561

.filename=strdup("/nonexistent"),

4562

.cancelled_filenames = &(string_set){},

4563

.notafter=0,

4564

.current_time=&current_time,

4565

.mandos_client_exited=&mandos_client_exited,

4566

.password_is_read=&password_is_read,

4567

};

4568

task.func(task, queue);

4569

g_assert_false(quit_now);

4570

g_assert_true(queue->next_run == 0);

4571

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

4572

4573

g_assert_nonnull(find_matching_task(queue, (task_context){

4574

.func=read_inotify_event,

4575

.epoll_fd=epoll_fd,

4576

.fd=pipefds[0],

4577

.quit_now=&quit_now,

4578

.password=&password,

4579

.filename=task.filename,

4580

.cancelled_filenames=task.cancelled_filenames,

4581

.current_time=&current_time,

4582

.mandos_client_exited=&mandos_client_exited,

4583

.password_is_read=&password_is_read,

4584

}));

4585

4586

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4587

EPOLLIN | EPOLLRDHUP));

4588

}

4589

4590

static void

4591

test_read_inotify_event_IN_MOVED_TO_badname(__attribute__((unused))

4592

test_fixture *fixture,

4593

__attribute__((unused))

4594

gconstpointer user_data){

4595

__attribute__((cleanup(cleanup_close)))

4596

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4597

g_assert_cmpint(epoll_fd, >=, 0);

4598

const mono_microsecs current_time = 0;

4599

4600

int pipefds[2];

4601

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

4602

4603

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

4604

const size_t ievent_max_size = (sizeof(struct inotify_event)

4605

+ NAME_MAX + 1);

4606

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4607

struct {

4608

struct inotify_event event;

4609

char name_buffer[NAME_MAX + 1];

4610

} ievent_buffer;

4611

struct inotify_event *const ievent = &ievent_buffer.event;

4612

4613

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

4614

ievent->mask = IN_MOVED_TO;

4615

ievent->len = sizeof(dummy_file_name);

4616

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

4617

const size_t ievent_size = (sizeof(struct inotify_event)

4618

+ sizeof(dummy_file_name));

4619

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

4620

==, ievent_size);

4621

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

4622

4623

bool quit_now = false;

4624

buffer password = {};

4625

bool mandos_client_exited = false;

4626

bool password_is_read = false;

4627

__attribute__((cleanup(cleanup_queue)))

4628

task_queue *queue = create_queue();

4629

g_assert_nonnull(queue);

4630

4631

task_context task = {

4632

.func=read_inotify_event,

4633

.epoll_fd=epoll_fd,

4634

.fd=pipefds[0],

4635

.quit_now=&quit_now,

4636

.password=&password,

4637

.filename=strdup("/nonexistent"),

4638

.cancelled_filenames = &(string_set){},

4639

.notafter=0,

4640

.current_time=&current_time,

4641

.mandos_client_exited=&mandos_client_exited,

4642

.password_is_read=&password_is_read,

4643

};

4644

task.func(task, queue);

4645

g_assert_false(quit_now);

4646

g_assert_true(queue->next_run == 0);

4647

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

4648

4649

g_assert_nonnull(find_matching_task(queue, (task_context){

4650

.func=read_inotify_event,

4651

.epoll_fd=epoll_fd,

4652

.fd=pipefds[0],

4653

.quit_now=&quit_now,

4654

.password=&password,

4655

.filename=task.filename,

4656

.cancelled_filenames=task.cancelled_filenames,

4657

.current_time=&current_time,

4658

.mandos_client_exited=&mandos_client_exited,

4659

.password_is_read=&password_is_read,

4660

}));

4661

4662

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4663

EPOLLIN | EPOLLRDHUP));

4664

}

4665

4666

static void

4667

test_read_inotify_event_IN_MOVED_FROM_badname(__attribute__((unused))

4668

test_fixture *fixture,

4669

__attribute__((unused))

4670

gconstpointer

4671

user_data){

4672

__attribute__((cleanup(cleanup_close)))

4673

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4674

g_assert_cmpint(epoll_fd, >=, 0);

4675

__attribute__((cleanup(string_set_clear)))

4676

string_set cancelled_filenames = {};

4677

const mono_microsecs current_time = 0;

4678

4679

int pipefds[2];

4680

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

4681

4682

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

4683

const size_t ievent_max_size = (sizeof(struct inotify_event)

4684

+ NAME_MAX + 1);

4685

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4686

struct {

4687

struct inotify_event event;

4688

char name_buffer[NAME_MAX + 1];

4689

} ievent_buffer;

4690

struct inotify_event *const ievent = &ievent_buffer.event;

4691

4692

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

4693

ievent->mask = IN_MOVED_FROM;

4694

ievent->len = sizeof(dummy_file_name);

4695

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

4696

const size_t ievent_size = (sizeof(struct inotify_event)

4697

+ sizeof(dummy_file_name));

4698

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

4699

==, ievent_size);

4700

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

4701

4702

bool quit_now = false;

4703

buffer password = {};

4704

bool mandos_client_exited = false;

4705

bool password_is_read = false;

4706

__attribute__((cleanup(cleanup_queue)))

4707

task_queue *queue = create_queue();

4708

g_assert_nonnull(queue);

4709

4710

task_context task = {

4711

.func=read_inotify_event,

4712

.epoll_fd=epoll_fd,

4713

.fd=pipefds[0],

4714

.quit_now=&quit_now,

4715

.password=&password,

4716

.filename=strdup("/nonexistent"),

4717

.cancelled_filenames=&cancelled_filenames,

4718

.current_time=&current_time,

4719

.mandos_client_exited=&mandos_client_exited,

4720

.password_is_read=&password_is_read,

4721

};

4722

task.func(task, queue);

4723

g_assert_false(quit_now);

4724

g_assert_true(queue->next_run == 0);

4725

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

4726

4727

g_assert_nonnull(find_matching_task(queue, (task_context){

4728

.func=read_inotify_event,

4729

.epoll_fd=epoll_fd,

4730

.fd=pipefds[0],

4731

.quit_now=&quit_now,

4732

.password=&password,

4733

.filename=task.filename,

4734

.cancelled_filenames=&cancelled_filenames,

4735

.current_time=&current_time,

4736

.mandos_client_exited=&mandos_client_exited,

4737

.password_is_read=&password_is_read,

4738

}));

4739

4740

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4741

EPOLLIN | EPOLLRDHUP));

4742

4743

__attribute__((cleanup(cleanup_string)))

4744

char *filename = NULL;

4745

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

4746

dummy_file_name), >, 0);

4747

g_assert_nonnull(filename);

4748

g_assert_false(string_set_contains(cancelled_filenames, filename));

4749

}

4750

4751

static

4752

void test_read_inotify_event_IN_DELETE_badname(__attribute__((unused))

4753

test_fixture *fixture,

4754

__attribute__((unused))

4755

gconstpointer

4756

user_data){

4757

__attribute__((cleanup(cleanup_close)))

4758

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4759

g_assert_cmpint(epoll_fd, >=, 0);

4760

__attribute__((cleanup(string_set_clear)))

4761

string_set cancelled_filenames = {};

4762

const mono_microsecs current_time = 0;

4763

4764

int pipefds[2];

4765

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

4766

4767

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

4768

const size_t ievent_max_size = (sizeof(struct inotify_event)

4769

+ NAME_MAX + 1);

4770

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4771

struct {

4772

struct inotify_event event;

4773

char name_buffer[NAME_MAX + 1];

4774

} ievent_buffer;

4775

struct inotify_event *const ievent = &ievent_buffer.event;

4776

4777

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

4778

ievent->mask = IN_DELETE;

4779

ievent->len = sizeof(dummy_file_name);

4780

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

4781

const size_t ievent_size = (sizeof(struct inotify_event)

4782

+ sizeof(dummy_file_name));

4783

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

4784

==, ievent_size);

4785

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

4786

4787

bool quit_now = false;

4788

buffer password = {};

4789

bool mandos_client_exited = false;

4790

bool password_is_read = false;

4791

__attribute__((cleanup(cleanup_queue)))

4792

task_queue *queue = create_queue();

4793

g_assert_nonnull(queue);

4794

4795

task_context task = {

4796

.func=read_inotify_event,

4797

.epoll_fd=epoll_fd,

4798

.fd=pipefds[0],

4799

.quit_now=&quit_now,

4800

.password=&password,

4801

.filename=strdup("/nonexistent"),

4802

.cancelled_filenames=&cancelled_filenames,

4803

.current_time=&current_time,

4804

.mandos_client_exited=&mandos_client_exited,

4805

.password_is_read=&password_is_read,

4806

};

4807

task.func(task, queue);

4808

g_assert_false(quit_now);

4809

g_assert_true(queue->next_run == 0);

4810

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

4811

4812

g_assert_nonnull(find_matching_task(queue, (task_context){

4813

.func=read_inotify_event,

4814

.epoll_fd=epoll_fd,

4815

.fd=pipefds[0],

4816

.quit_now=&quit_now,

4817

.password=&password,

4818

.filename=task.filename,

4819

.cancelled_filenames=&cancelled_filenames,

4820

.current_time=&current_time,

4821

.mandos_client_exited=&mandos_client_exited,

4822

.password_is_read=&password_is_read,

4823

}));

4824

4825

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4826

EPOLLIN | EPOLLRDHUP));

4827

4828

__attribute__((cleanup(cleanup_string)))

4829

char *filename = NULL;

4830

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

4831

dummy_file_name), >, 0);

4832

g_assert_nonnull(filename);

4833

g_assert_false(string_set_contains(cancelled_filenames, filename));

4834

}

4835

4836

static

4837

void test_open_and_parse_question_ENOENT(__attribute__((unused))

4838

test_fixture *fixture,

4839

__attribute__((unused))

4840

gconstpointer user_data){

4841

__attribute__((cleanup(cleanup_close)))

4842

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4843

g_assert_cmpint(epoll_fd, >=, 0);

4844

__attribute__((cleanup(string_set_clear)))

4845

string_set cancelled_filenames = {};

4846

bool mandos_client_exited = false;

4847

bool password_is_read = false;

4848

__attribute__((cleanup(cleanup_queue)))

4849

task_queue *queue = create_queue();

4850

g_assert_nonnull(queue);

4851

4852

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

4853

g_assert_nonnull(filename);

4854

task_context task = {

4855

.func=open_and_parse_question,

4856

.question_filename=filename,

4857

.epoll_fd=epoll_fd,

4858

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

4859

.filename=filename,

4860

.cancelled_filenames=&cancelled_filenames,

4861

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

4862

.mandos_client_exited=&mandos_client_exited,

4863

.password_is_read=&password_is_read,

4864

};

4865

task.func(task, queue);

4866

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

4867

}

4868

4869

static void test_open_and_parse_question_EIO(__attribute__((unused))

4870

test_fixture *fixture,

4871

__attribute__((unused))

4872

gconstpointer user_data){

4873

__attribute__((cleanup(cleanup_close)))

4874

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4875

g_assert_cmpint(epoll_fd, >=, 0);

4876

__attribute__((cleanup(string_set_clear)))

4877

string_set cancelled_filenames = {};

4878

buffer password = {};

4879

bool mandos_client_exited = false;

4880

bool password_is_read = false;

4881

__attribute__((cleanup(cleanup_queue)))

4882

task_queue *queue = create_queue();

4883

g_assert_nonnull(queue);

4884

const mono_microsecs current_time = 0;

4885

4886

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

4887

task_context task = {

4888

.func=open_and_parse_question,

4889

.question_filename=filename,

4890

.epoll_fd=epoll_fd,

4891

.password=&password,

4892

.filename=filename,

4893

.cancelled_filenames=&cancelled_filenames,

4894

.current_time=&current_time,

4895

.mandos_client_exited=&mandos_client_exited,

4896

.password_is_read=&password_is_read,

4897

};

4898

run_task_with_stderr_to_dev_null(task, queue);

4899

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

4900

}

4901

4902

static void

4903

test_open_and_parse_question_parse_error(__attribute__((unused))

4904

test_fixture *fixture,

4905

__attribute__((unused))

4906

gconstpointer user_data){

4907

__attribute__((cleanup(cleanup_close)))

4908

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4909

g_assert_cmpint(epoll_fd, >=, 0);

4910

__attribute__((cleanup(string_set_clear)))

4911

string_set cancelled_filenames = {};

4912

__attribute__((cleanup(cleanup_queue)))

4913

task_queue *queue = create_queue();

4914

g_assert_nonnull(queue);

4915

4916

__attribute__((cleanup(cleanup_string)))

4917

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

4918

g_assert_nonnull(tempfilename);

4919

int tempfile = mkostemp(tempfilename, O_CLOEXEC);

4920

g_assert_cmpint(tempfile, >, 0);

4921

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

4922

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

4923

==, sizeof(bad_data));

4924

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

4925

4926

char *const filename = strdup(tempfilename);

4927

g_assert_nonnull(filename);

4928

task_context task = {

4929

.func=open_and_parse_question,

4930

.question_filename=filename,

4931

.epoll_fd=epoll_fd,

4932

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

4933

.filename=filename,

4934

.cancelled_filenames=&cancelled_filenames,

4935

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

4936

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

4937

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

4938

};

4939

run_task_with_stderr_to_dev_null(task, queue);

4940

4941

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

4942

4943

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

4944

}

4945

4946

static

4947

void test_open_and_parse_question_nosocket(__attribute__((unused))

4948

test_fixture *fixture,

4949

__attribute__((unused))

4950

gconstpointer user_data){

4951

__attribute__((cleanup(cleanup_close)))

4952

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4953

g_assert_cmpint(epoll_fd, >=, 0);

4954

__attribute__((cleanup(string_set_clear)))

4955

string_set cancelled_filenames = {};

4956

__attribute__((cleanup(cleanup_queue)))

4957

task_queue *queue = create_queue();

4958

g_assert_nonnull(queue);

4959

4960

__attribute__((cleanup(cleanup_string)))

4961

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

4962

g_assert_nonnull(tempfilename);

4963

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4964

g_assert_cmpint(questionfile, >, 0);

4965

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

4966

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

4967

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

4968

4969

char *const filename = strdup(tempfilename);

4970

g_assert_nonnull(filename);

4971

task_context task = {

4972

.func=open_and_parse_question,

4973

.question_filename=filename,

4974

.epoll_fd=epoll_fd,

4975

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

4976

.filename=filename,

4977

.cancelled_filenames=&cancelled_filenames,

4978

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

4979

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

4980

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

4981

};

4982

run_task_with_stderr_to_dev_null(task, queue);

4983

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

4984

4985

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

4986

}

4987

4988

static

4989

void test_open_and_parse_question_badsocket(__attribute__((unused))

4990

test_fixture *fixture,

4991

__attribute__((unused))

4992

gconstpointer user_data){

4993

__attribute__((cleanup(cleanup_close)))

4994

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4995

g_assert_cmpint(epoll_fd, >=, 0);

4996

__attribute__((cleanup(string_set_clear)))

4997

string_set cancelled_filenames = {};

4998

__attribute__((cleanup(cleanup_queue)))

4999

task_queue *queue = create_queue();

5000

g_assert_nonnull(queue);

5001

5002

__attribute__((cleanup(cleanup_string)))

5003

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

5004

g_assert_nonnull(tempfilename);

5005

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5006

g_assert_cmpint(questionfile, >, 0);

5007

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

5008

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

5009

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

5010

5011

char *const filename = strdup(tempfilename);

5012

g_assert_nonnull(filename);

5013

task_context task = {

5014

.func=open_and_parse_question,

5015

.question_filename=filename,

5016

.epoll_fd=epoll_fd,

5017

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

5018

.filename=filename,

5019

.cancelled_filenames=&cancelled_filenames,

5020

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

5021

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

5022

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

5023

};

5024

run_task_with_stderr_to_dev_null(task, queue);

5025

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

5026

5027

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

5028

}

5029

5030

static

5031

void test_open_and_parse_question_nopid(__attribute__((unused))

5032

test_fixture *fixture,

5033

__attribute__((unused))

5034

gconstpointer user_data){

5035

__attribute__((cleanup(cleanup_close)))

5036

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5037

g_assert_cmpint(epoll_fd, >=, 0);

5038

__attribute__((cleanup(string_set_clear)))

5039

string_set cancelled_filenames = {};

5040

__attribute__((cleanup(cleanup_queue)))

5041

task_queue *queue = create_queue();

5042

g_assert_nonnull(queue);

5043

5044

__attribute__((cleanup(cleanup_string)))

5045

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

5046

g_assert_nonnull(tempfilename);

5047

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5048

g_assert_cmpint(questionfile, >, 0);

5049

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

5050

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\n"), >, 0);

5051

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

5052

5053

char *const filename = strdup(tempfilename);

5054

g_assert_nonnull(filename);

5055

task_context task = {

5056

.func=open_and_parse_question,

5057

.question_filename=filename,

5058

.epoll_fd=epoll_fd,

5059

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

5060

.filename=filename,

5061

.cancelled_filenames=&cancelled_filenames,

5062

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

5063

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

5064

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

5065

};

5066

run_task_with_stderr_to_dev_null(task, queue);

5067

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

5068

5069

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

5070

}

5071

5072

static

5073

void test_open_and_parse_question_badpid(__attribute__((unused))

5074

test_fixture *fixture,

5075

__attribute__((unused))

5076

gconstpointer user_data){

5077

__attribute__((cleanup(cleanup_close)))

5078

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5079

g_assert_cmpint(epoll_fd, >=, 0);

5080

__attribute__((cleanup(string_set_clear)))

5081

string_set cancelled_filenames = {};

5082

__attribute__((cleanup(cleanup_queue)))

5083

task_queue *queue = create_queue();

5084

g_assert_nonnull(queue);

5085

5086

__attribute__((cleanup(cleanup_string)))

5087

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

5088

g_assert_nonnull(tempfilename);

5089

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5090

g_assert_cmpint(questionfile, >, 0);

5091

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

5092

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=\n"),

5093

>, 0);

5094

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

5095

5096

char *const filename = strdup(tempfilename);

5097

g_assert_nonnull(filename);

5098

task_context task = {

5099

.func=open_and_parse_question,

5100

.question_filename=filename,

5101

.epoll_fd=epoll_fd,

5102

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

5103

.filename=filename,

5104

.cancelled_filenames=&cancelled_filenames,

5105

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

5106

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

5107

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

5108

};

5109

run_task_with_stderr_to_dev_null(task, queue);

5110

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

5111

5112

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

5113

}

5114

5115

static void

5116

test_open_and_parse_question_noexist_pid(__attribute__((unused))

5117

test_fixture *fixture,

5118

__attribute__((unused))

5119

gconstpointer user_data){

5120

__attribute__((cleanup(cleanup_close)))

5121

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5122

g_assert_cmpint(epoll_fd, >=, 0);

5123

__attribute__((cleanup(string_set_clear)))

5124

string_set cancelled_filenames = {};

5125

buffer password = {};

5126

bool mandos_client_exited = false;

5127

bool password_is_read = false;

5128

__attribute__((cleanup(cleanup_queue)))

5129

task_queue *queue = create_queue();

5130

g_assert_nonnull(queue);

5131

const mono_microsecs current_time = 0;

5132

5133

/* Find value of sysctl kernel.pid_max */

5134

uintmax_t pid_max = 0;

5135

FILE *sysctl_pid_max = fopen("/proc/sys/kernel/pid_max", "r");

5136

g_assert_nonnull(sysctl_pid_max);

5137

g_assert_cmpint(fscanf(sysctl_pid_max, "%" PRIuMAX, &pid_max),

5138

==, 1);

5139

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

5140

5141

pid_t nonexisting_pid = ((pid_t)pid_max)+1;

5142

g_assert_true(nonexisting_pid > 0); /* Overflow check */

5143

5144

__attribute__((cleanup(cleanup_string)))

5145

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

5146

g_assert_nonnull(tempfilename);

5147

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5148

g_assert_cmpint(questionfile, >, 0);

5149

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

5150

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5151

PRIuMAX"\n", (uintmax_t)nonexisting_pid),

5152

>, 0);

5153

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

5154

5155

char *const question_filename = strdup(tempfilename);

5156

g_assert_nonnull(question_filename);

5157

task_context task = {

5158

.func=open_and_parse_question,

5159

.question_filename=question_filename,

5160

.epoll_fd=epoll_fd,

5161

.password=&password,

5162

.filename=question_filename,

5163

.cancelled_filenames=&cancelled_filenames,

5164

.current_time=&current_time,

5165

.mandos_client_exited=&mandos_client_exited,

5166

.password_is_read=&password_is_read,

5167

};

5168

run_task_with_stderr_to_dev_null(task, queue);

5169

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

5170

5171

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

5172

}

5173

5174

static void

5175

test_open_and_parse_question_no_notafter(__attribute__((unused))

5176

test_fixture *fixture,

5177

__attribute__((unused))

5178

gconstpointer user_data){

5179

__attribute__((cleanup(cleanup_close)))

5180

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5181

g_assert_cmpint(epoll_fd, >=, 0);

5182

__attribute__((cleanup(string_set_clear)))

5183

string_set cancelled_filenames = {};

5184

buffer password = {};

5185

bool mandos_client_exited = false;

5186

bool password_is_read = false;

5187

__attribute__((cleanup(cleanup_queue)))

5188

task_queue *queue = create_queue();

5189

g_assert_nonnull(queue);

5190

const mono_microsecs current_time = 0;

5191

5192

__attribute__((cleanup(cleanup_string)))

5193

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

5194

g_assert_nonnull(tempfilename);

5195

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5196

g_assert_cmpint(questionfile, >, 0);

5197

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

5198

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5199

PRIuMAX "\n", (uintmax_t)getpid()), >, 0);

5200

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

5201

5202

char *const filename = strdup(tempfilename);

5203

g_assert_nonnull(filename);

5204

task_context task = {

5205

.func=open_and_parse_question,

5206

.question_filename=filename,

5207

.epoll_fd=epoll_fd,

5208

.password=&password,

5209

.filename=filename,

5210

.cancelled_filenames=&cancelled_filenames,

5211

.current_time=&current_time,

5212

.mandos_client_exited=&mandos_client_exited,

5213

.password_is_read=&password_is_read,

5214

};

5215

task.func(task, queue);

5216

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

5217

5218

__attribute__((cleanup(cleanup_string)))

5219

char *socket_filename = strdup("/nonexistent");

5220

g_assert_nonnull(socket_filename);

5221

g_assert_nonnull(find_matching_task(queue, (task_context){

5222

.func=connect_question_socket,

5223

.question_filename=tempfilename,

5224

.filename=socket_filename,

5225

.epoll_fd=epoll_fd,

5226

.password=&password,

5227

.current_time=&current_time,

5228

.mandos_client_exited=&mandos_client_exited,

5229

.password_is_read=&password_is_read,

5230

}));

5231

5232

g_assert_true(queue->next_run != 0);

5233

5234

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

5235

}

5236

5237

static void

5238

test_open_and_parse_question_bad_notafter(__attribute__((unused))

5239

test_fixture *fixture,

5240

__attribute__((unused))

5241

gconstpointer user_data){

5242

__attribute__((cleanup(cleanup_close)))

5243

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5244

g_assert_cmpint(epoll_fd, >=, 0);

5245

__attribute__((cleanup(string_set_clear)))

5246

string_set cancelled_filenames = {};

5247

buffer password = {};

5248

bool mandos_client_exited = false;

5249

bool password_is_read = false;

5250

__attribute__((cleanup(cleanup_queue)))

5251

task_queue *queue = create_queue();

5252

g_assert_nonnull(queue);

5253

const mono_microsecs current_time = 0;

5254

5255

__attribute__((cleanup(cleanup_string)))

5256

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

5257

g_assert_nonnull(tempfilename);

5258

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5259

g_assert_cmpint(questionfile, >, 0);

5260

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

5261

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5262

PRIuMAX "\nNotAfter=\n",

5263

(uintmax_t)getpid()), >, 0);

5264

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

5265

5266

char *const filename = strdup(tempfilename);

5267

g_assert_nonnull(filename);

5268

task_context task = {

5269

.func=open_and_parse_question,

5270

.question_filename=filename,

5271

.epoll_fd=epoll_fd,

5272

.password=&password,

5273

.filename=filename,

5274

.cancelled_filenames=&cancelled_filenames,

5275

.current_time=&current_time,

5276

.mandos_client_exited=&mandos_client_exited,

5277

.password_is_read=&password_is_read,

5278

};

5279

run_task_with_stderr_to_dev_null(task, queue);

5280

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

5281

5282

__attribute__((cleanup(cleanup_string)))

5283

char *socket_filename = strdup("/nonexistent");

5284

g_assert_nonnull(find_matching_task(queue, (task_context){

5285

.func=connect_question_socket,

5286

.question_filename=tempfilename,

5287

.filename=socket_filename,

5288

.epoll_fd=epoll_fd,

5289

.password=&password,

5290

.current_time=&current_time,

5291

.mandos_client_exited=&mandos_client_exited,

5292

.password_is_read=&password_is_read,

5293

}));

5294

g_assert_true(queue->next_run != 0);

5295

5296

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

5297

}

5298

5299

static

5300

void assert_open_and_parse_question_with_notafter(const mono_microsecs

5301

current_time,

5302

const mono_microsecs

5303

notafter,

5304

const mono_microsecs

5305

next_queue_run){

5306

__attribute__((cleanup(cleanup_close)))

5307

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5308

g_assert_cmpint(epoll_fd, >=, 0);

5309

__attribute__((cleanup(string_set_clear)))

5310

string_set cancelled_filenames = {};

5311

buffer password = {};

5312

bool mandos_client_exited = false;

5313

bool password_is_read = false;

5314

__attribute__((cleanup(cleanup_queue)))

5315

task_queue *queue = create_queue();

5316

g_assert_nonnull(queue);

5317

queue->next_run = next_queue_run;

5318

5319

__attribute__((cleanup(cleanup_string)))

5320

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

5321

g_assert_nonnull(tempfilename);

5322

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5323

g_assert_cmpint(questionfile, >, 0);

5324

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

5325

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5326

PRIuMAX "\nNotAfter=%" PRIuMAX "\n",

5327

(uintmax_t)getpid(), notafter), >, 0);

5328

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

5329

5330

char *const filename = strdup(tempfilename);

5331

g_assert_nonnull(filename);

5332

task_context task = {

5333

.func=open_and_parse_question,

5334

.question_filename=filename,

5335

.epoll_fd=epoll_fd,

5336

.password=&password,

5337

.filename=filename,

5338

.cancelled_filenames=&cancelled_filenames,

5339

.current_time=&current_time,

5340

.mandos_client_exited=&mandos_client_exited,

5341

.password_is_read=&password_is_read,

5342

};

5343

task.func(task, queue);

5344

5345

if(queue->length >= 1){

5346

__attribute__((cleanup(cleanup_string)))

5347

char *socket_filename = strdup("/nonexistent");

5348

g_assert_nonnull(find_matching_task(queue, (task_context){

5349

.func=connect_question_socket,

5350

.filename=socket_filename,

5351

.epoll_fd=epoll_fd,

5352

.password=&password,

5353

.current_time=&current_time,

5354

.cancelled_filenames=&cancelled_filenames,

5355

.mandos_client_exited=&mandos_client_exited,

5356

.password_is_read=&password_is_read,

5357

}));

5358

g_assert_true(queue->next_run != 0);

5359

}

5360

5361

if(notafter == 0){

5362

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

5363

} else if(current_time >= notafter) {

5364

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

5365

} else {

5366

g_assert_nonnull(find_matching_task(queue, (task_context){

5367

.func=cancel_old_question,

5368

.question_filename=tempfilename,

5369

.filename=tempfilename,

5370

.notafter=notafter,

5371

.cancelled_filenames=&cancelled_filenames,

5372

.current_time=&current_time,

5373

}));

5374

}

5375

g_assert_true(queue->next_run == 1);

5376

5377

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

5378

}

5379

5380

static void

5381

test_open_and_parse_question_notafter_0(__attribute__((unused))

5382

test_fixture *fixture,

5383

__attribute__((unused))

5384

gconstpointer user_data){

5385

/* current_time, notafter, next_queue_run */

5386

assert_open_and_parse_question_with_notafter(0, 0, 0);

5387

}

5388

5389

static void

5390

test_open_and_parse_question_notafter_1(__attribute__((unused))

5391

test_fixture *fixture,

5392

__attribute__((unused))

5393

gconstpointer user_data){

5394

/* current_time, notafter, next_queue_run */

5395

assert_open_and_parse_question_with_notafter(0, 1, 0);

5396

}

5397

5398

static void

5399

test_open_and_parse_question_notafter_1_1(__attribute__((unused))

5400

test_fixture *fixture,

5401

__attribute__((unused))

5402

gconstpointer user_data){

5403

/* current_time, notafter, next_queue_run */

5404

assert_open_and_parse_question_with_notafter(0, 1, 1);

5405

}

5406

5407

static void

5408

test_open_and_parse_question_notafter_1_2(__attribute__((unused))

5409

test_fixture *fixture,

5410

__attribute__((unused))

5411

gconstpointer user_data){

5412

/* current_time, notafter, next_queue_run */

5413

assert_open_and_parse_question_with_notafter(0, 1, 2);

5414

}

5415

5416

static void

5417

test_open_and_parse_question_equal_notafter(__attribute__((unused))

5418

test_fixture *fixture,

5419

__attribute__((unused))

5420

gconstpointer user_data){

5421

/* current_time, notafter, next_queue_run */

5422

assert_open_and_parse_question_with_notafter(1, 1, 0);

5423

}

5424

5425

static void

5426

test_open_and_parse_question_late_notafter(__attribute__((unused))

5427

test_fixture *fixture,

5428

__attribute__((unused))

5429

gconstpointer user_data){

5430

/* current_time, notafter, next_queue_run */

5431

assert_open_and_parse_question_with_notafter(2, 1, 0);

5432

}

5433

5434

static void assert_cancel_old_question_param(const mono_microsecs

5435

next_queue_run,

5436

const mono_microsecs

5437

notafter,

5438

const mono_microsecs

5439

current_time,

5440

const mono_microsecs

5441

next_set_to){

5442

__attribute__((cleanup(string_set_clear)))

5443

string_set cancelled_filenames = {};

5444

__attribute__((cleanup(cleanup_queue)))

5445

task_queue *queue = create_queue();

5446

g_assert_nonnull(queue);

5447

queue->next_run = next_queue_run;

5448

5449

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

5450

g_assert_nonnull(question_filename);

5451

task_context task = {

5452

.func=cancel_old_question,

5453

.question_filename=question_filename,

5454

.filename=question_filename,

5455

.notafter=notafter,

5456

.cancelled_filenames=&cancelled_filenames,

5457

.current_time=&current_time,

5458

};

5459

task.func(task, queue);

5460

5461

if(current_time >= notafter){

5462

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

5463

g_assert_true(string_set_contains(cancelled_filenames,

5464

"/nonexistent"));

5465

} else {

5466

g_assert_nonnull(find_matching_task(queue, (task_context){

5467

.func=cancel_old_question,

5468

.question_filename=question_filename,

5469

.filename=question_filename,

5470

.notafter=notafter,

5471

.cancelled_filenames=&cancelled_filenames,

5472

.current_time=&current_time,

5473

}));

5474

5475

g_assert_false(string_set_contains(cancelled_filenames,

5476

question_filename));

5477

}

5478

g_assert_cmpuint((unsigned int)queue->next_run, ==,

5479

(unsigned int)next_set_to);

5480

}

5481

5482

static void test_cancel_old_question_0_1_2(__attribute__((unused))

5483

test_fixture *fixture,

5484

__attribute__((unused))

5485

gconstpointer user_data){

5486

/* next_queue_run unset,

5487

cancellation should happen because time has come,

5488

next_queue_run should be unchanged */

5489

/* next_queue_run, notafter, current_time, next_set_to */

5490

assert_cancel_old_question_param(0, 1, 2, 0);

5491

}

5492

5493

static void test_cancel_old_question_0_2_1(__attribute__((unused))

5494

test_fixture *fixture,

5495

__attribute__((unused))

5496

gconstpointer user_data){

5497

/* If next_queue_run is 0, meaning unset, and notafter is 2,

5498

and current_time is not yet notafter or greater,

5499

update value of next_queue_run to value of notafter */

5500

/* next_queue_run, notafter, current_time, next_set_to */

5501

assert_cancel_old_question_param(0, 2, 1, 2);

5502

}

5503

5504

static void test_cancel_old_question_1_2_3(__attribute__((unused))

5505

test_fixture *fixture,

5506

__attribute__((unused))

5507

gconstpointer user_data){

5508

/* next_queue_run 1,

5509

cancellation should happen because time has come,

5510

next_queue_run should be unchanged */

5511

/* next_queue_run, notafter, current_time, next_set_to */

5512

assert_cancel_old_question_param(1, 2, 3, 1);

5513

}

5514

5515

static void test_cancel_old_question_1_3_2(__attribute__((unused))

5516

test_fixture *fixture,

5517

__attribute__((unused))

5518

gconstpointer user_data){

5519

/* If next_queue_run is set,

5520

and current_time is not yet notafter or greater,

5521

and notafter is larger than next_queue_run

5522

next_queue_run should be unchanged */

5523

/* next_queue_run, notafter, current_time, next_set_to */

5524

assert_cancel_old_question_param(1, 3, 2, 1);

5525

}

5526

5527

static void test_cancel_old_question_2_1_3(__attribute__((unused))

5528

test_fixture *fixture,

5529

__attribute__((unused))

5530

gconstpointer user_data){

5531

/* next_queue_run 2,

5532

cancellation should happen because time has come,

5533

next_queue_run should be unchanged */

5534

/* next_queue_run, notafter, current_time, next_set_to */

5535

assert_cancel_old_question_param(2, 1, 3, 2);

5536

}

5537

5538

static void test_cancel_old_question_2_3_1(__attribute__((unused))

5539

test_fixture *fixture,

5540

__attribute__((unused))

5541

gconstpointer user_data){

5542

/* If next_queue_run is set,

5543

and current_time is not yet notafter or greater,

5544

and notafter is larger than next_queue_run

5545

next_queue_run should be unchanged */

5546

/* next_queue_run, notafter, current_time, next_set_to */

5547

assert_cancel_old_question_param(2, 3, 1, 2);

5548

}

5549

5550

static void test_cancel_old_question_3_1_2(__attribute__((unused))

5551

test_fixture *fixture,

5552

__attribute__((unused))

5553

gconstpointer user_data){

5554

/* next_queue_run 3,

5555

cancellation should happen because time has come,

5556

next_queue_run should be unchanged */

5557

/* next_queue_run, notafter, current_time, next_set_to */

5558

assert_cancel_old_question_param(3, 1, 2, 3);

5559

}

5560

5561

static void test_cancel_old_question_3_2_1(__attribute__((unused))

5562

test_fixture *fixture,

5563

__attribute__((unused))

5564

gconstpointer user_data){

5565

/* If next_queue_run is set,

5566

and current_time is not yet notafter or greater,

5567

and notafter is smaller than next_queue_run

5568

update value of next_queue_run to value of notafter */

5569

/* next_queue_run, notafter, current_time, next_set_to */

5570

assert_cancel_old_question_param(3, 2, 1, 2);

5571

}

5572

5573

static void

5574

test_connect_question_socket_name_too_long(__attribute__((unused))

5575

test_fixture *fixture,

5576

__attribute__((unused))

5577

gconstpointer user_data){

5578

__attribute__((cleanup(cleanup_close)))

5579

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5580

g_assert_cmpint(epoll_fd, >=, 0);

5581

const char question_filename[] = "/nonexistent/question";

5582

__attribute__((cleanup(string_set_clear)))

5583

string_set cancelled_filenames = {};

5584

__attribute__((cleanup(cleanup_queue)))

5585

task_queue *queue = create_queue();

5586

g_assert_nonnull(queue);

5587

__attribute__((cleanup(cleanup_string)))

5588

char *tempdir = make_temporary_directory();

5589

g_assert_nonnull(tempdir);

5590

struct sockaddr_un unix_socket = { .sun_family=AF_LOCAL };

5591

char socket_name[sizeof(unix_socket.sun_path)];

5592

memset(socket_name, 'x', sizeof(socket_name));

5593

socket_name[sizeof(socket_name)-1] = '\0';

5594

char *filename = NULL;

5595

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5596

>, 0);

5597

g_assert_nonnull(filename);

5598

5599

task_context task = {

5600

.func=connect_question_socket,

5601

.question_filename=strdup(question_filename),

5602

.epoll_fd=epoll_fd,

5603

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

5604

.filename=filename,

5605

.cancelled_filenames=&cancelled_filenames,

5606

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

5607

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

5608

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

5609

};

5610

g_assert_nonnull(task.question_filename);

5611

run_task_with_stderr_to_dev_null(task, queue);

5612

5613

g_assert_true(string_set_contains(cancelled_filenames,

5614

question_filename));

5615

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

5616

g_assert_true(queue->next_run == 0);

5617

5618

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

5619

}

5620

5621

static

5622

void test_connect_question_socket_connect_fail(__attribute__((unused))

5623

test_fixture *fixture,

5624

__attribute__((unused))

5625

gconstpointer

5626

user_data){

5627

__attribute__((cleanup(cleanup_close)))

5628

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5629

g_assert_cmpint(epoll_fd, >=, 0);

5630

const char question_filename[] = "/nonexistent/question";

5631

__attribute__((cleanup(string_set_clear)))

5632

string_set cancelled_filenames = {};

5633

const mono_microsecs current_time = 3;

5634

__attribute__((cleanup(cleanup_queue)))

5635

task_queue *queue = create_queue();

5636

g_assert_nonnull(queue);

5637

__attribute__((cleanup(cleanup_string)))

5638

char *tempdir = make_temporary_directory();

5639

g_assert_nonnull(tempdir);

5640

char socket_name[] = "nonexistent";

5641

char *filename = NULL;

5642

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5643

>, 0);

5644

g_assert_nonnull(filename);

5645

5646

task_context task = {

5647

.func=connect_question_socket,

5648

.question_filename=strdup(question_filename),

5649

.epoll_fd=epoll_fd,

5650

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

5651

.filename=filename,

5652

.cancelled_filenames=&cancelled_filenames,

5653

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

5654

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

5655

.current_time=&current_time,

5656

};

5657

g_assert_nonnull(task.question_filename);

5658

run_task_with_stderr_to_dev_null(task, queue);

5659

5660

g_assert_nonnull(find_matching_task(queue, task));

5661

5662

g_assert_false(string_set_contains(cancelled_filenames,

5663

question_filename));

5664

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

5665

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

5666

5667

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

5668

}

5669

5670

static

5671

void test_connect_question_socket_bad_epoll(__attribute__((unused))

5672

test_fixture *fixture,

5673

__attribute__((unused))

5674

gconstpointer user_data){

5675

__attribute__((cleanup(cleanup_close)))

5676

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

5677

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5678

__attribute__((cleanup(cleanup_string)))

5679

char *const question_filename = strdup("/nonexistent/question");

5680

g_assert_nonnull(question_filename);

5681

__attribute__((cleanup(string_set_clear)))

5682

string_set cancelled_filenames = {};

5683

const mono_microsecs current_time = 5;

5684

__attribute__((cleanup(cleanup_queue)))

5685

task_queue *queue = create_queue();

5686

g_assert_nonnull(queue);

5687

__attribute__((cleanup(cleanup_string)))

5688

char *tempdir = make_temporary_directory();

5689

g_assert_nonnull(tempdir);

5690

__attribute__((cleanup(cleanup_close)))

5691

const int sock_fd = socket(PF_LOCAL, SOCK_DGRAM

5692

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

5693

g_assert_cmpint(sock_fd, >=, 0);

5694

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

5695

const char socket_name[] = "socket_name";

5696

__attribute__((cleanup(cleanup_string)))

5697

char *filename = NULL;

5698

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5699

>, 0);

5700

g_assert_nonnull(filename);

5701

g_assert_cmpint((int)strlen(filename), <,

5702

(int)sizeof(sock_name.sun_path));

5703

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

5704

sock_name.sun_path[sizeof(sock_name.sun_path)-1] = '\0';

5705

g_assert_cmpint((int)bind(sock_fd, (struct sockaddr *)&sock_name,

5706

(socklen_t)SUN_LEN(&sock_name)), >=, 0);

5707

task_context task = {

5708

.func=connect_question_socket,

5709

.question_filename=strdup(question_filename),

5710

.epoll_fd=epoll_fd,

5711

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

5712

.filename=strdup(filename),

5713

.cancelled_filenames=&cancelled_filenames,

5714

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

5715

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

5716

.current_time=&current_time,

5717

};

5718

g_assert_nonnull(task.question_filename);

5719

run_task_with_stderr_to_dev_null(task, queue);

5720

5721

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

5722

const task_context *const added_task

5723

= find_matching_task(queue, task);

5724

g_assert_nonnull(added_task);

5725

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

5726

5727

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

5728

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

5729

}

5730

5731

static

5732

void test_connect_question_socket_usable(__attribute__((unused))

5733

test_fixture *fixture,

5734

__attribute__((unused))

5735

gconstpointer user_data){

5736

__attribute__((cleanup(cleanup_close)))

5737

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5738

g_assert_cmpint(epoll_fd, >=, 0);

5739

__attribute__((cleanup(cleanup_string)))

5740

char *const question_filename = strdup("/nonexistent/question");

5741

g_assert_nonnull(question_filename);

5742

__attribute__((cleanup(string_set_clear)))

5743

string_set cancelled_filenames = {};

5744

buffer password = {};

5745

bool mandos_client_exited = false;

5746

bool password_is_read = false;

5747

const mono_microsecs current_time = 0;

5748

__attribute__((cleanup(cleanup_queue)))

5749

task_queue *queue = create_queue();

5750

g_assert_nonnull(queue);

5751

__attribute__((cleanup(cleanup_string)))

5752

char *tempdir = make_temporary_directory();

5753

g_assert_nonnull(tempdir);

5754

__attribute__((cleanup(cleanup_close)))

5755

const int sock_fd = socket(PF_LOCAL, SOCK_DGRAM

5756

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

5757

g_assert_cmpint(sock_fd, >=, 0);

5758

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

5759

const char socket_name[] = "socket_name";

5760

__attribute__((cleanup(cleanup_string)))

5761

char *filename = NULL;

5762

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5763

>, 0);

5764

g_assert_nonnull(filename);

5765

g_assert_cmpint((int)strlen(filename), <,

5766

(int)sizeof(sock_name.sun_path));

5767

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

5768

sock_name.sun_path[sizeof(sock_name.sun_path)-1] = '\0';

5769

g_assert_cmpint((int)bind(sock_fd, (struct sockaddr *)&sock_name,

5770

(socklen_t)SUN_LEN(&sock_name)), >=, 0);

5771

task_context task = {

5772

.func=connect_question_socket,

5773

.question_filename=strdup(question_filename),

5774

.epoll_fd=epoll_fd,

5775

.password=&password,

5776

.filename=strdup(filename),

5777

.cancelled_filenames=&cancelled_filenames,

5778

.mandos_client_exited=&mandos_client_exited,

5779

.password_is_read=&password_is_read,

5780

.current_time=&current_time,

5781

};

5782

g_assert_nonnull(task.question_filename);

5783

task.func(task, queue);

5784

5785

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

5786

const task_context *const added_task

5787

= find_matching_task(queue, (task_context){

5788

.func=send_password_to_socket,

5789

.question_filename=question_filename,

5790

.filename=filename,

5791

.epoll_fd=epoll_fd,

5792

.password=&password,

5793

.cancelled_filenames=&cancelled_filenames,

5794

.mandos_client_exited=&mandos_client_exited,

5795

.password_is_read=&password_is_read,

5796

.current_time=&current_time,

5797

});

5798

g_assert_nonnull(added_task);

5799

g_assert_cmpint(added_task->fd, >, 0);

5800

5801

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5802

EPOLLOUT));

5803

5804

const int fd = added_task->fd;

5805

g_assert_cmpint(fd, >, 0);

5806

g_assert_true(fd_has_cloexec_and_nonblock(fd));

5807

5808

/* write to fd */

5809

char write_data[PIPE_BUF];

5810

{

5811

/* Construct test password buffer */

5812

/* Start with + since that is what the real protocol uses */

5813

write_data[0] = '+';

5814

/* Set a special character at string end just to mark the end */

5815

write_data[sizeof(write_data)-2] = 'y';

5816

/* Set NUL at buffer end, as suggested by the protocol */

5817

write_data[sizeof(write_data)-1] = '\0';

5818

/* Fill rest of password with 'x' */

5819

memset(write_data+1, 'x', sizeof(write_data)-3);

5820

g_assert_cmpint((int)send(fd, write_data, sizeof(write_data),

5821

MSG_NOSIGNAL), ==, sizeof(write_data));

5822

}

5823

5824

/* read from sock_fd */

5825

char read_data[sizeof(write_data)];

5826

g_assert_cmpint((int)read(sock_fd, read_data, sizeof(read_data)),

5827

==, sizeof(read_data));

5828

5829

g_assert_true(memcmp(write_data, read_data, sizeof(write_data))

5830

== 0);

5831

5832

/* writing to sock_fd should fail */

5833

g_assert_cmpint(send(sock_fd, write_data, sizeof(write_data),

5834

MSG_NOSIGNAL), <, 0);

5835

5836

/* reading from fd should fail */

5837

g_assert_cmpint((int)recv(fd, read_data, sizeof(read_data),

5838

MSG_NOSIGNAL), <, 0);

5839

5840

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

5841

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

5842

}

5843

5844

static void

5845

test_send_password_to_socket_client_not_exited(__attribute__((unused))

5846

test_fixture *fixture,

5847

__attribute__((unused))

5848

gconstpointer

5849

user_data){

5850

__attribute__((cleanup(cleanup_close)))

5851

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5852

g_assert_cmpint(epoll_fd, >=, 0);

5853

__attribute__((cleanup(cleanup_string)))

5854

char *const question_filename = strdup("/nonexistent/question");

5855

g_assert_nonnull(question_filename);

5856

__attribute__((cleanup(cleanup_string)))

5857

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

5858

g_assert_nonnull(filename);

5859

__attribute__((cleanup(string_set_clear)))

5860

string_set cancelled_filenames = {};

5861

buffer password = {};

5862

bool password_is_read = true;

5863

__attribute__((cleanup(cleanup_queue)))

5864

task_queue *queue = create_queue();

5865

g_assert_nonnull(queue);

5866

int socketfds[2];

5867

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5868

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5869

socketfds), ==, 0);

5870

__attribute__((cleanup(cleanup_close)))

5871

const int read_socket = socketfds[0];

5872

const int write_socket = socketfds[1];

5873

task_context task = {

5874

.func=send_password_to_socket,

5875

.question_filename=strdup(question_filename),

5876

.filename=strdup(filename),

5877

.epoll_fd=epoll_fd,

5878

.fd=write_socket,

5879

.password=&password,

5880

.cancelled_filenames=&cancelled_filenames,

5881

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

5882

.password_is_read=&password_is_read,

5883

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

5884

};

5885

g_assert_nonnull(task.question_filename);

5886

5887

task.func(task, queue);

5888

5889

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

5890

5891

const task_context *const added_task

5892

= find_matching_task(queue, task);

5893

g_assert_nonnull(added_task);

5894

g_assert_cmpuint((unsigned int)password.length, ==, 0);

5895

g_assert_true(password_is_read);

5896

5897

g_assert_cmpint(added_task->fd, >, 0);

5898

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5899

EPOLLOUT));

5900

}

5901

5902

static void

5903

test_send_password_to_socket_password_not_read(__attribute__((unused))

5904

test_fixture *fixture,

5905

__attribute__((unused))

5906

gconstpointer

5907

user_data){

5908

__attribute__((cleanup(cleanup_close)))

5909

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5910

g_assert_cmpint(epoll_fd, >=, 0);

5911

__attribute__((cleanup(cleanup_string)))

5912

char *const question_filename = strdup("/nonexistent/question");

5913

g_assert_nonnull(question_filename);

5914

__attribute__((cleanup(cleanup_string)))

5915

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

5916

__attribute__((cleanup(string_set_clear)))

5917

string_set cancelled_filenames = {};

5918

buffer password = {};

5919

__attribute__((cleanup(cleanup_queue)))

5920

task_queue *queue = create_queue();

5921

g_assert_nonnull(queue);

5922

int socketfds[2];

5923

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5924

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5925

socketfds), ==, 0);

5926

__attribute__((cleanup(cleanup_close)))

5927

const int read_socket = socketfds[0];

5928

const int write_socket = socketfds[1];

5929

task_context task = {

5930

.func=send_password_to_socket,

5931

.question_filename=strdup(question_filename),

5932

.filename=strdup(filename),

5933

.epoll_fd=epoll_fd,

5934

.fd=write_socket,

5935

.password=&password,

5936

.cancelled_filenames=&cancelled_filenames,

5937

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

5938

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

5939

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

5940

};

5941

g_assert_nonnull(task.question_filename);

5942

5943

task.func(task, queue);

5944

5945

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

5946

5947

const task_context *const added_task = find_matching_task(queue,

5948

task);

5949

g_assert_nonnull(added_task);

5950

g_assert_cmpuint((unsigned int)password.length, ==, 0);

5951

g_assert_true(queue->next_run == 0);

5952

5953

g_assert_cmpint(added_task->fd, >, 0);

5954

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5955

EPOLLOUT));

5956

}

5957

5958

static

5959

void test_send_password_to_socket_EMSGSIZE(__attribute__((unused))

5960

test_fixture *fixture,

5961

__attribute__((unused))

5962

gconstpointer user_data){

5963

__attribute__((cleanup(cleanup_close)))

5964

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5965

g_assert_cmpint(epoll_fd, >=, 0);

5966

const char question_filename[] = "/nonexistent/question";

5967

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

5968

__attribute__((cleanup(string_set_clear)))

5969

string_set cancelled_filenames = {};

5970

int socketfds[2];

5971

5972

/* Find a message size which triggers EMSGSIZE */

5973

__attribute__((cleanup(cleanup_string)))

5974

char *message_buffer = NULL;

5975

size_t message_size = PIPE_BUF + 1;

5976

for(ssize_t ssret = 0; ssret >= 0; message_size += 1024){

5977

if(message_size >= 1024*1024*1024){ /* 1 GiB */

5978

g_test_skip("Skipping EMSGSIZE test: Will not try 1GiB");

5979

return;

5980

}

5981

free(message_buffer);

5982

message_buffer = malloc(message_size);

5983

if(message_buffer == NULL){

5984

g_test_skip("Skipping EMSGSIZE test");

5985

g_test_message("Failed to malloc() %" PRIuMAX " bytes",

5986

(uintmax_t)message_size);

5987

return;

5988

}

5989

/* Fill buffer with 'x' */

5990

memset(message_buffer, 'x', message_size);

5991

/* Create a new socketpair for each message size to avoid having

5992

to empty the pipe by reading the message to a separate buffer

5993

*/

5994

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5995

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5996

socketfds), ==, 0);

5997

ssret = send(socketfds[1], message_buffer, message_size,

5998

MSG_NOSIGNAL);

5999

error_t saved_errno = errno;

6000

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

6001

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

6002

6003

if(ssret < 0){

6004

if(saved_errno != EMSGSIZE) {

6005

g_test_skip("Skipping EMSGSIZE test");

6006

g_test_message("Error on send(): %s", strerror(saved_errno));

6007

return;

6008

}

6009

} else if(ssret != (ssize_t)message_size){

6010

g_test_skip("Skipping EMSGSIZE test");

6011

g_test_message("Partial send(): %" PRIuMAX " of %" PRIdMAX

6012

" bytes", (uintmax_t)ssret,

6013

(intmax_t)message_size);

6014

return;

6015

}

6016

}

6017

g_test_message("EMSGSIZE triggered by %" PRIdMAX " bytes",

6018

(intmax_t)message_size);

6019

6020

buffer password = {

6021

.data=message_buffer,

6022

.length=message_size - 2, /* Compensate for added '+' and NUL */

6023

.allocated=message_size,

6024

};

6025

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

6026

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

6027

}

6028

6029

__attribute__((cleanup(cleanup_queue)))

6030

task_queue *queue = create_queue();

6031

g_assert_nonnull(queue);

6032

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6033

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6034

socketfds), ==, 0);

6035

__attribute__((cleanup(cleanup_close)))

6036

const int read_socket = socketfds[0];

6037

__attribute__((cleanup(cleanup_close)))

6038

const int write_socket = socketfds[1];

6039

task_context task = {

6040

.func=send_password_to_socket,

6041

.question_filename=strdup(question_filename),

6042

.filename=filename,

6043

.epoll_fd=epoll_fd,

6044

.fd=write_socket,

6045

.password=&password,

6046

.cancelled_filenames=&cancelled_filenames,

6047

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

6048

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

6049

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

6050

};

6051

g_assert_nonnull(task.question_filename);

6052

6053

run_task_with_stderr_to_dev_null(task, queue);

6054

6055

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

6056

g_assert_true(string_set_contains(cancelled_filenames,

6057

question_filename));

6058

}

6059

6060

static void test_send_password_to_socket_retry(__attribute__((unused))

6061

test_fixture *fixture,

6062

__attribute__((unused))

6063

gconstpointer

6064

user_data){

6065

__attribute__((cleanup(cleanup_close)))

6066

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6067

g_assert_cmpint(epoll_fd, >=, 0);

6068

__attribute__((cleanup(cleanup_string)))

6069

char *const question_filename = strdup("/nonexistent/question");

6070

g_assert_nonnull(question_filename);

6071

__attribute__((cleanup(cleanup_string)))

6072

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

6073

g_assert_nonnull(filename);

6074

__attribute__((cleanup(string_set_clear)))

6075

string_set cancelled_filenames = {};

6076

__attribute__((cleanup(cleanup_buffer)))

6077

buffer password = {};

6078

6079

__attribute__((cleanup(cleanup_queue)))

6080

task_queue *queue = create_queue();

6081

g_assert_nonnull(queue);

6082

int socketfds[2];

6083

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6084

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6085

socketfds), ==, 0);

6086

__attribute__((cleanup(cleanup_close)))

6087

const int read_socket = socketfds[0];

6088

const int write_socket = socketfds[1];

6089

/* Close the server side socket to force ECONNRESET on client */

6090

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

6091

task_context task = {

6092

.func=send_password_to_socket,

6093

.question_filename=strdup(question_filename),

6094

.filename=strdup(filename),

6095

.epoll_fd=epoll_fd,

6096

.fd=write_socket,

6097

.password=&password,

6098

.cancelled_filenames=&cancelled_filenames,

6099

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

6100

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

6101

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

6102

};

6103

g_assert_nonnull(task.question_filename);

6104

6105

task.func(task, queue);

6106

6107

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

6108

6109

const task_context *const added_task = find_matching_task(queue,

6110

task);

6111

g_assert_nonnull(added_task);

6112

g_assert_cmpuint((unsigned int)password.length, ==, 0);

6113

6114

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

6115

EPOLLOUT));

6116

}

6117

6118

static

6119

void test_send_password_to_socket_bad_epoll(__attribute__((unused))

6120

test_fixture *fixture,

6121

__attribute__((unused))

6122

gconstpointer user_data){

6123

__attribute__((cleanup(cleanup_close)))

6124

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

6125

O_WRONLY | O_CLOEXEC | O_NOCTTY);

6126

__attribute__((cleanup(cleanup_string)))

6127

char *const question_filename = strdup("/nonexistent/question");

6128

g_assert_nonnull(question_filename);

6129

__attribute__((cleanup(cleanup_string)))

6130

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

6131

g_assert_nonnull(filename);

6132

__attribute__((cleanup(string_set_clear)))

6133

string_set cancelled_filenames = {};

6134

__attribute__((cleanup(cleanup_buffer)))

6135

buffer password = {};

6136

6137

const mono_microsecs current_time = 11;

6138

__attribute__((cleanup(cleanup_queue)))

6139

task_queue *queue = create_queue();

6140

g_assert_nonnull(queue);

6141

int socketfds[2];

6142

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6143

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6144

socketfds), ==, 0);

6145

__attribute__((cleanup(cleanup_close)))

6146

const int read_socket = socketfds[0];

6147

const int write_socket = socketfds[1];

6148

/* Close the server side socket to force ECONNRESET on client */

6149

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

6150

task_context task = {

6151

.func=send_password_to_socket,

6152

.question_filename=strdup(question_filename),

6153

.filename=strdup(filename),

6154

.epoll_fd=epoll_fd,

6155

.fd=write_socket,

6156

.password=&password,

6157

.cancelled_filenames=&cancelled_filenames,

6158

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

6159

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

6160

.current_time=&current_time,

6161

};

6162

g_assert_nonnull(task.question_filename);

6163

6164

run_task_with_stderr_to_dev_null(task, queue);

6165

6166

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

6167

6168

const task_context *const added_task = find_matching_task(queue,

6169

task);

6170

g_assert_nonnull(added_task);

6171

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

6172

g_assert_cmpuint((unsigned int)password.length, ==, 0);

6173

}

6174

6175

static void assert_send_password_to_socket_password(buffer password){

6176

__attribute__((cleanup(cleanup_close)))

6177

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6178

g_assert_cmpint(epoll_fd, >=, 0);

6179

char *const question_filename = strdup("/nonexistent/question");

6180

g_assert_nonnull(question_filename);

6181

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

6182

g_assert_nonnull(filename);

6183

__attribute__((cleanup(string_set_clear)))

6184

string_set cancelled_filenames = {};

6185

6186

__attribute__((cleanup(cleanup_queue)))

6187

task_queue *queue = create_queue();

6188

g_assert_nonnull(queue);

6189

int socketfds[2];

6190

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6191

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6192

socketfds), ==, 0);

6193

__attribute__((cleanup(cleanup_close)))

6194

const int read_socket = socketfds[0];

6195

const int write_socket = socketfds[1];

6196

task_context task = {

6197

.func=send_password_to_socket,

6198

.question_filename=question_filename,

6199

.filename=filename,

6200

.epoll_fd=epoll_fd,

6201

.fd=write_socket,

6202

.password=&password,

6203

.cancelled_filenames=&cancelled_filenames,

6204

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

6205

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

6206

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

6207

};

6208

6209

char *expected_written_data = malloc(password.length + 2);

6210

g_assert_nonnull(expected_written_data);

6211

expected_written_data[0] = '+';

6212

expected_written_data[password.length + 1] = '\0';

6213

if(password.length > 0){

6214

g_assert_nonnull(password.data);

6215

memcpy(expected_written_data + 1, password.data, password.length);

6216

}

6217

6218

task.func(task, queue);

6219

6220

char buf[PIPE_BUF];

6221

g_assert_cmpint((int)read(read_socket, buf, PIPE_BUF), ==,

6222

(int)(password.length + 2));

6223

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

6224

6225

g_assert_true(memcmp(expected_written_data, buf,

6226

password.length + 2) == 0);

6227

6228

g_assert_true(epoll_set_does_not_contain(epoll_fd, write_socket));

6229

6230

free(expected_written_data);

6231

}

6232

6233

static void

6234

test_send_password_to_socket_null_password(__attribute__((unused))

6235

test_fixture *fixture,

6236

__attribute__((unused))

6237

gconstpointer user_data){

6238

__attribute__((cleanup(cleanup_buffer)))

6239

buffer password = {};

6240

assert_send_password_to_socket_password(password);

6241

}

6242

6243

static void

6244

test_send_password_to_socket_empty_password(__attribute__((unused))

6245

test_fixture *fixture,

6246

__attribute__((unused))

6247

gconstpointer user_data){

6248

__attribute__((cleanup(cleanup_buffer)))

6249

buffer password = {

6250

.data=malloc(1), /* because malloc(0) may return NULL */

6251

.length=0,

6252

.allocated=0, /* deliberate lie */

6253

};

6254

g_assert_nonnull(password.data);

6255

assert_send_password_to_socket_password(password);

6256

}

6257

6258

static void

6259

test_send_password_to_socket_empty_str_pass(__attribute__((unused))

6260

test_fixture *fixture,

6261

__attribute__((unused))

6262

gconstpointer user_data){

6263

__attribute__((cleanup(cleanup_buffer)))

6264

buffer password = {

6265

.data=strdup(""),

6266

.length=0,

6267

.allocated=1,

6268

};

6269

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

6270

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

6271

}

6272

assert_send_password_to_socket_password(password);

6273

}

6274

6275

static void

6276

test_send_password_to_socket_text_password(__attribute__((unused))

6277

test_fixture *fixture,

6278

__attribute__((unused))

6279

gconstpointer user_data){

6280

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

6281

__attribute__((cleanup(cleanup_buffer)))

6282

buffer password = {

6283

.data = strdup(dummy_test_password),

6284

.length = strlen(dummy_test_password),

6285

.allocated = sizeof(dummy_test_password),

6286

};

6287

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

6288

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

6289

}

6290

assert_send_password_to_socket_password(password);

6291

}

6292

6293

static void

6294

test_send_password_to_socket_binary_password(__attribute__((unused))

6295

test_fixture *fixture,

6296

__attribute__((unused))

6297

gconstpointer user_data){

6298

__attribute__((cleanup(cleanup_buffer)))

6299

buffer password = {

6300

.data=malloc(255),

6301

.length=255,

6302

.allocated=255,

6303

};

6304

g_assert_nonnull(password.data);

6305

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

6306

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

6307

}

6308

char c = 1; /* Start at 1, avoiding NUL */

6309

for(int i=0; i < 255; i++){

6310

password.data[i] = c++;

6311

}

6312

assert_send_password_to_socket_password(password);

6313

}

6314

6315

static void

6316

test_send_password_to_socket_nuls_in_password(__attribute__((unused))

6317

test_fixture *fixture,

6318

__attribute__((unused))

6319

gconstpointer

6320

user_data){

6321

char test_password[] = {'\0', 'a', '\0', 'b', '\0', 'c', '\0'};

6322

__attribute__((cleanup(cleanup_buffer)))

6323

buffer password = {

6324

.data=malloc(sizeof(test_password)),

6325

.length=sizeof(test_password),

6326

.allocated=sizeof(test_password),

6327

};

6328

g_assert_nonnull(password.data);

6329

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

6330

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

6331

}

6332

memcpy(password.data, test_password, password.allocated);

6333

assert_send_password_to_socket_password(password);

6334

}

6335

6336

static bool assert_add_existing_questions_to_devnull(task_queue

6337

*const,

6338

const int,

6339

buffer *const,

6340

string_set *,

6341

const

6342

mono_microsecs

6343

*const,

6344

bool *const,

6345

bool *const,

6346

const char

6347

*const);

6348

6349

static void test_add_existing_questions_ENOENT(__attribute__((unused))

6350

test_fixture *fixture,

6351

__attribute__((unused))

6352

gconstpointer

6353

user_data){

6354

__attribute__((cleanup(cleanup_queue)))

6355

task_queue *queue = create_queue();

6356

g_assert_nonnull(queue);

6357

__attribute__((cleanup(cleanup_close)))

6358

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6359

g_assert_cmpint(epoll_fd, >=, 0);

6360

__attribute__((cleanup(string_set_clear)))

6361

string_set cancelled_filenames = {};

6362

6363

g_assert_false(assert_add_existing_questions_to_devnull

6364

(queue,

6365

epoll_fd,

6366

(buffer[]){{}}, /* password */

6367

&cancelled_filenames,

6368

(mono_microsecs[]){0}, /* current_time */

6369

(bool[]){false}, /* mandos_client_exited */

6370

(bool[]){false}, /* password_is_read */

6371

"/nonexistent")); /* dirname */

6372

6373

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

6374

}

6375

6376

static

6377

bool assert_add_existing_questions_to_devnull(task_queue

6378

*const queue,

6379

const int

6380

epoll_fd,

6381

buffer *const

6382

password,

6383

string_set

6384

*cancelled_filenames,

6385

const mono_microsecs

6386

*const current_time,

6387

bool *const

6388

mandos_client_exited,

6389

bool *const

6390

password_is_read,

6391

const char *const

6392

dirname){

6393

__attribute__((cleanup(cleanup_close)))

6394

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

6395

O_WRONLY | O_CLOEXEC | O_NOCTTY);

6396

g_assert_cmpint(devnull_fd, >=, 0);

6397

__attribute__((cleanup(cleanup_close)))

6398

const int real_stderr_fd = dup(STDERR_FILENO);

6399

g_assert_cmpint(real_stderr_fd, >=, 0);

6400

dup2(devnull_fd, STDERR_FILENO);

6401

const bool ret = add_existing_questions(queue, epoll_fd, password,

6402

cancelled_filenames,

6403

current_time,

6404

mandos_client_exited,

6405

password_is_read, dirname);

6406

dup2(real_stderr_fd, STDERR_FILENO);

6407

return ret;

6408

}

6409

6410

static

6411

void test_add_existing_questions_no_questions(__attribute__((unused))

6412

test_fixture *fixture,

6413

__attribute__((unused))

6414

gconstpointer

6415

user_data){

6416

__attribute__((cleanup(cleanup_queue)))

6417

task_queue *queue = create_queue();

6418

g_assert_nonnull(queue);

6419

__attribute__((cleanup(cleanup_close)))

6420

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6421

g_assert_cmpint(epoll_fd, >=, 0);

6422

__attribute__((cleanup(string_set_clear)))

6423

string_set cancelled_filenames = {};

6424

__attribute__((cleanup(cleanup_string)))

6425

char *tempdir = make_temporary_directory();

6426

g_assert_nonnull(tempdir);

6427

6428

g_assert_false(assert_add_existing_questions_to_devnull

6429

(queue,

6430

epoll_fd,

6431

(buffer[]){{}}, /* password */

6432

&cancelled_filenames,

6433

(mono_microsecs[]){0}, /* current_time */

6434

(bool[]){false}, /* mandos_client_exited */

6435

(bool[]){false}, /* password_is_read */

6436

tempdir));

6437

6438

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

6439

6440

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

6441

}

6442

6443

static char *make_question_file_in_directory(const char *const);

6444

6445

static

6446

void test_add_existing_questions_one_question(__attribute__((unused))

6447

test_fixture *fixture,

6448

__attribute__((unused))

6449

gconstpointer

6450

user_data){

6451

__attribute__((cleanup(cleanup_queue)))

6452

task_queue *queue = create_queue();

6453

g_assert_nonnull(queue);

6454

__attribute__((cleanup(cleanup_close)))

6455

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6456

g_assert_cmpint(epoll_fd, >=, 0);

6457

__attribute__((cleanup(cleanup_buffer)))

6458

buffer password = {};

6459

__attribute__((cleanup(string_set_clear)))

6460

string_set cancelled_filenames = {};

6461

const mono_microsecs current_time = 0;

6462

bool mandos_client_exited = false;

6463

bool password_is_read = false;

6464

__attribute__((cleanup(cleanup_string)))

6465

char *tempdir = make_temporary_directory();

6466

g_assert_nonnull(tempdir);

6467

__attribute__((cleanup(cleanup_string)))

6468

char *question_filename

6469

= make_question_file_in_directory(tempdir);

6470

g_assert_nonnull(question_filename);

6471

6472

g_assert_true(assert_add_existing_questions_to_devnull

6473

(queue,

6474

epoll_fd,

6475

&password,

6476

&cancelled_filenames,

6477

&current_time,

6478

&mandos_client_exited,

6479

&password_is_read,

6480

tempdir));

6481

6482

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

6483

6484

g_assert_nonnull(find_matching_task(queue, (task_context){

6485

.func=open_and_parse_question,

6486

.epoll_fd=epoll_fd,

6487

.filename=question_filename,

6488

.question_filename=question_filename,

6489

.password=&password,

6490

.cancelled_filenames=&cancelled_filenames,

6491

.current_time=&current_time,

6492

.mandos_client_exited=&mandos_client_exited,

6493

.password_is_read=&password_is_read,

6494

}));

6495

6496

g_assert_true(queue->next_run == 1);

6497

6498

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

6499

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

6500

}

6501

6502

static char *make_question_file_in_directory(const char

6503

*const dir){

6504

return make_temporary_prefixed_file_in_directory("ask.", dir);

6505

}

6506

6507

static

6508

void test_add_existing_questions_two_questions(__attribute__((unused))

6509

test_fixture *fixture,

6510

__attribute__((unused))

6511

gconstpointer

6512

user_data){

6513

__attribute__((cleanup(cleanup_queue)))

6514

task_queue *queue = create_queue();

6515

g_assert_nonnull(queue);

6516

__attribute__((cleanup(cleanup_close)))

6517

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6518

g_assert_cmpint(epoll_fd, >=, 0);

6519

__attribute__((cleanup(cleanup_buffer)))

6520

buffer password = {};

6521

__attribute__((cleanup(string_set_clear)))

6522

string_set cancelled_filenames = {};

6523

const mono_microsecs current_time = 0;

6524

bool mandos_client_exited = false;

6525

bool password_is_read = false;

6526

__attribute__((cleanup(cleanup_string)))

6527

char *tempdir = make_temporary_directory();

6528

g_assert_nonnull(tempdir);

6529

__attribute__((cleanup(cleanup_string)))

6530

char *question_filename1

6531

= make_question_file_in_directory(tempdir);

6532

g_assert_nonnull(question_filename1);

6533

__attribute__((cleanup(cleanup_string)))

6534

char *question_filename2

6535

= make_question_file_in_directory(tempdir);

6536

g_assert_nonnull(question_filename2);

6537

6538

g_assert_true(assert_add_existing_questions_to_devnull

6539

(queue,

6540

epoll_fd,

6541

&password,

6542

&cancelled_filenames,

6543

&current_time,

6544

&mandos_client_exited,

6545

&password_is_read,

6546

tempdir));

6547

6548

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

6549

6550

g_assert_true(queue->next_run == 1);

6551

6552

__attribute__((cleanup(string_set_clear)))

6553

string_set seen_questions = {};

6554

6555

bool queue_contains_question_opener(char *const question_filename){

6556

return(find_matching_task(queue, (task_context){

6557

.func=open_and_parse_question,

6558

.epoll_fd=epoll_fd,

6559

.question_filename=question_filename,

6560

.password=&password,

6561

.cancelled_filenames=&cancelled_filenames,

6562

.current_time=&current_time,

6563

.mandos_client_exited=&mandos_client_exited,

6564

.password_is_read=&password_is_read,

6565

}) != NULL);

6566

}

6567

6568

g_assert_true(queue_contains_question_opener(question_filename1));

6569

g_assert_true(queue_contains_question_opener(question_filename2));

6570

6571

g_assert_true(queue->next_run == 1);

6572

6573

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

6574

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

6575

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

6576

}

6577

6578

static void

6579

test_add_existing_questions_non_questions(__attribute__((unused))

6580

test_fixture *fixture,

6581

__attribute__((unused))

6582

gconstpointer user_data){

6583

__attribute__((cleanup(cleanup_queue)))

6584

task_queue *queue = create_queue();

6585

g_assert_nonnull(queue);

6586

__attribute__((cleanup(cleanup_close)))

6587

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6588

g_assert_cmpint(epoll_fd, >=, 0);

6589

__attribute__((cleanup(string_set_clear)))

6590

string_set cancelled_filenames = {};

6591

__attribute__((cleanup(cleanup_string)))

6592

char *tempdir = make_temporary_directory();

6593

g_assert_nonnull(tempdir);

6594

__attribute__((cleanup(cleanup_string)))

6595

char *question_filename1

6596

= make_temporary_file_in_directory(tempdir);

6597

g_assert_nonnull(question_filename1);

6598

__attribute__((cleanup(cleanup_string)))

6599

char *question_filename2

6600

= make_temporary_file_in_directory(tempdir);

6601

g_assert_nonnull(question_filename2);

6602

6603

g_assert_false(assert_add_existing_questions_to_devnull

6604

(queue,

6605

epoll_fd,

6606

(buffer[]){{}}, /* password */

6607

&cancelled_filenames,

6608

(mono_microsecs[]){0}, /* current_time */

6609

(bool[]){false}, /* mandos_client_exited */

6610

(bool[]){false}, /* password_is_read */

6611

tempdir));

6612

6613

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

6614

6615

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

6616

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

6617

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

6618

}

6619

6620

static void

6621

test_add_existing_questions_both_types(__attribute__((unused))

6622

test_fixture *fixture,

6623

__attribute__((unused))

6624

gconstpointer user_data){

6625

__attribute__((cleanup(cleanup_queue)))

6626

task_queue *queue = create_queue();

6627

g_assert_nonnull(queue);

6628

__attribute__((cleanup(cleanup_close)))

6629

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6630

g_assert_cmpint(epoll_fd, >=, 0);

6631

__attribute__((cleanup(cleanup_buffer)))

6632

buffer password = {};

6633

__attribute__((cleanup(string_set_clear)))

6634

string_set cancelled_filenames = {};

6635

const mono_microsecs current_time = 0;

6636

bool mandos_client_exited = false;

6637

bool password_is_read = false;

6638

__attribute__((cleanup(cleanup_string)))

6639

char *tempdir = make_temporary_directory();

6640

g_assert_nonnull(tempdir);

6641

__attribute__((cleanup(cleanup_string)))

6642

char *tempfilename1 = make_temporary_file_in_directory(tempdir);

6643

g_assert_nonnull(tempfilename1);

6644

__attribute__((cleanup(cleanup_string)))

6645

char *tempfilename2 = make_temporary_file_in_directory(tempdir);

6646

g_assert_nonnull(tempfilename2);

6647

__attribute__((cleanup(cleanup_string)))

6648

char *question_filename

6649

= make_question_file_in_directory(tempdir);

6650

g_assert_nonnull(question_filename);

6651

6652

g_assert_true(assert_add_existing_questions_to_devnull

6653

(queue,

6654

epoll_fd,

6655

&password,

6656

&cancelled_filenames,

6657

&current_time,

6658

&mandos_client_exited,

6659

&password_is_read,

6660

tempdir));

6661

6662

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

6663

6664

g_assert_nonnull(find_matching_task(queue, (task_context){

6665

.func=open_and_parse_question,

6666

.epoll_fd=epoll_fd,

6667

.filename=question_filename,

6668

.question_filename=question_filename,

6669

.password=&password,

6670

.cancelled_filenames=&cancelled_filenames,

6671

.current_time=&current_time,

6672

.mandos_client_exited=&mandos_client_exited,

6673

.password_is_read=&password_is_read,

6674

}));

6675

6676

g_assert_true(queue->next_run == 1);

6677

6678

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

6679

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

6680

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

6681

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

6682

}

6683

6684

static void test_wait_for_event_timeout(__attribute__((unused))

6685

test_fixture *fixture,

6686

__attribute__((unused))

6687

gconstpointer user_data){

6688

__attribute__((cleanup(cleanup_close)))

6689

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6690

g_assert_cmpint(epoll_fd, >=, 0);

6691

6692

g_assert_true(wait_for_event(epoll_fd, 1, 0));

6693

}

6694

6695

static void test_wait_for_event_event(__attribute__((unused))

6696

test_fixture *fixture,

6697

__attribute__((unused))

6698

gconstpointer user_data){

6699

__attribute__((cleanup(cleanup_close)))

6700

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6701

g_assert_cmpint(epoll_fd, >=, 0);

6702

int pipefds[2];

6703

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

6704

__attribute__((cleanup(cleanup_close)))

6705

const int read_pipe = pipefds[0];

6706

__attribute__((cleanup(cleanup_close)))

6707

const int write_pipe = pipefds[1];

6708

g_assert_cmpint(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, read_pipe,

6709

&(struct epoll_event)

6710

{ .events=EPOLLIN | EPOLLRDHUP }), ==, 0);

6711

g_assert_cmpint((int)write(write_pipe, "x", 1), ==, 1);

6712

6713

g_assert_true(wait_for_event(epoll_fd, 0, 0));

6714

}

6715

6716

static void test_wait_for_event_sigchld(test_fixture *fixture,

6717

__attribute__((unused))

6718

gconstpointer user_data){

6719

const pid_t pid = fork();

6720

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

6721

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

6722

_exit(EXIT_FAILURE);

6723

}

6724

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

6725

_exit(EXIT_FAILURE);

6726

}

6727

exit(EXIT_SUCCESS);

6728

}

6729

g_assert_true(pid != -1);

6730

__attribute__((cleanup(cleanup_close)))

6731

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6732

g_assert_cmpint(epoll_fd, >=, 0);

6733

6734

g_assert_true(wait_for_event(epoll_fd, 0, 0));

6735

6736

int status;

6737

g_assert_true(waitpid(pid, &status, 0) == pid);

6738

g_assert_true(WIFEXITED(status));

6739

g_assert_cmpint(WEXITSTATUS(status), ==, EXIT_SUCCESS);

6740

}

6741

6742

static void test_run_queue_zeroes_next_run(__attribute__((unused))

6743

test_fixture *fixture,

6744

__attribute__((unused))

6745

gconstpointer user_data){

6746

__attribute__((cleanup(cleanup_queue)))

6747

task_queue *queue = create_queue();

6748

g_assert_nonnull(queue);

6749

queue->next_run = 1;

6750

__attribute__((cleanup(cleanup_close)))

6751

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6752

__attribute__((cleanup(string_set_clear)))

6753

string_set cancelled_filenames = {};

6754

bool quit_now = false;

6755

6756

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

6757

g_assert_false(quit_now);

6758

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

6759

}

6760

6761

static

6762

void test_run_queue_clears_cancelled_filenames(__attribute__((unused))

6763

test_fixture *fixture,

6764

__attribute__((unused))

6765

gconstpointer

6766

user_data){

6767

__attribute__((cleanup(cleanup_queue)))

6768

task_queue *queue = create_queue();

6769

g_assert_nonnull(queue);

6770

__attribute__((cleanup(string_set_clear)))

6771

string_set cancelled_filenames = {};

6772

bool quit_now = false;

6773

const char question_filename[] = "/nonexistent/question_filename";

6774

g_assert_true(string_set_add(&cancelled_filenames,

6775

question_filename));

6776

6777

g_assert_true(add_to_queue(queue,

6778

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

6779

6780

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

6781

g_assert_false(quit_now);

6782

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

6783

g_assert_false(string_set_contains(cancelled_filenames,

6784

question_filename));

6785

}

6786

6787

static

6788

void test_run_queue_skips_cancelled_filenames(__attribute__((unused))

6789

test_fixture *fixture,

6790

__attribute__((unused))

6791

gconstpointer

6792

user_data){

6793

__attribute__((cleanup(cleanup_queue)))

6794

task_queue *queue = create_queue();

6795

g_assert_nonnull(queue);

6796

__attribute__((cleanup(string_set_clear)))

6797

string_set cancelled_filenames = {};

6798

bool quit_now = false;

6799

int pipefds[2];

6800

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

6801

__attribute__((cleanup(cleanup_close)))

6802

const int read_pipe = pipefds[0];

6803

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

6804

const char question_filename[] = "/nonexistent/question_filename";

6805

g_assert_true(string_set_add(&cancelled_filenames,

6806

question_filename));

6807

__attribute__((nonnull))

6808

void quit_func(const task_context task,

6809

__attribute__((unused)) task_queue *const q){

6810

g_assert_nonnull(task.quit_now);

6811

*task.quit_now = true;

6812

}

6813

task_context task = {

6814

.func=quit_func,

6815

.question_filename=strdup(question_filename),

6816

.quit_now=&quit_now,

6817

.fd=read_pipe,

6818

};

6819

g_assert_nonnull(task.question_filename);

6820

6821

g_assert_true(add_to_queue(queue, task));

6822

6823

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

6824

g_assert_false(quit_now);

6825

6826

/* read_pipe should be closed already */

6827

errno = 0;

6828

bool read_pipe_closed = (close(read_pipe) == -1);

6829

read_pipe_closed &= (errno == EBADF);

6830

g_assert_true(read_pipe_closed);

6831

}

6832

6833

static void test_run_queue_one_task(__attribute__((unused))

6834

test_fixture *fixture,

6835

__attribute__((unused))

6836

gconstpointer user_data){

6837

__attribute__((cleanup(cleanup_queue)))

6838

task_queue *queue = create_queue();

6839

g_assert_nonnull(queue);

6840

__attribute__((cleanup(string_set_clear)))

6841

string_set cancelled_filenames = {};

6842

bool quit_now = false;

6843

6844

__attribute__((nonnull))

6845

void next_run_func(__attribute__((unused))

6846

const task_context task,

6847

task_queue *const q){

6848

q->next_run = 1;

6849

}

6850

6851

task_context task = {

6852

.func=next_run_func,

6853

};

6854

g_assert_true(add_to_queue(queue, task));

6855

6856

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

6857

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

6858

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

6859

}

6860

6861

static void test_run_queue_two_tasks(__attribute__((unused))

6862

test_fixture *fixture,

6863

__attribute__((unused))

6864

gconstpointer user_data){

6865

__attribute__((cleanup(cleanup_queue)))

6866

task_queue *queue = create_queue();

6867

g_assert_nonnull(queue);

6868

queue->next_run = 1;

6869

__attribute__((cleanup(string_set_clear)))

6870

string_set cancelled_filenames = {};

6871

bool quit_now = false;

6872

bool mandos_client_exited = false;

6873

6874

__attribute__((nonnull))

6875

void next_run_func(__attribute__((unused))

6876

const task_context task,

6877

task_queue *const q){

6878

q->next_run = 1;

6879

}

6880

6881

__attribute__((nonnull))

6882

void exited_func(const task_context task,

6883

__attribute__((unused)) task_queue *const q){

6884

*task.mandos_client_exited = true;

6885

}

6886

6887

task_context task1 = {

6888

.func=next_run_func,

6889

};

6890

g_assert_true(add_to_queue(queue, task1));

6891

6892

task_context task2 = {

6893

.func=exited_func,

6894

.mandos_client_exited=&mandos_client_exited,

6895

};

6896

g_assert_true(add_to_queue(queue, task2));

6897

6898

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

6899

g_assert_false(quit_now);

6900

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

6901

g_assert_true(mandos_client_exited);

6902

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

6903

}

6904

6905

static void test_run_queue_two_tasks_quit(__attribute__((unused))

6906

test_fixture *fixture,

6907

__attribute__((unused))

6908

gconstpointer user_data){

6909

__attribute__((cleanup(cleanup_queue)))

6910

task_queue *queue = create_queue();

6911

g_assert_nonnull(queue);

6912

__attribute__((cleanup(string_set_clear)))

6913

string_set cancelled_filenames = {};

6914

bool quit_now = false;

6915

bool mandos_client_exited = false;

6916

bool password_is_read = false;

6917

6918

__attribute__((nonnull))

6919

void set_exited_func(const task_context task,

6920

__attribute__((unused)) task_queue *const q){

6921

*task.mandos_client_exited = true;

6922

*task.quit_now = true;

6923

}

6924

task_context task1 = {

6925

.func=set_exited_func,

6926

.quit_now=&quit_now,

6927

.mandos_client_exited=&mandos_client_exited,

6928

};

6929

g_assert_true(add_to_queue(queue, task1));

6930

6931

__attribute__((nonnull))

6932

void set_read_func(const task_context task,

6933

__attribute__((unused)) task_queue *const q){

6934

*task.quit_now = true;

6935

*task.password_is_read = true;

6936

}

6937

task_context task2 = {

6938

.func=set_read_func,

6939

.quit_now=&quit_now,

6940

.password_is_read=&password_is_read,

6941

};

6942

g_assert_true(add_to_queue(queue, task2));

6943

6944

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

6945

g_assert_true(quit_now);

6946

g_assert_true(mandos_client_exited xor password_is_read);

6947

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

6948

}

6949

6950

static void test_run_queue_two_tasks_cleanup(__attribute__((unused))

6951

test_fixture *fixture,

6952

__attribute__((unused))

6953

gconstpointer user_data){

6954

__attribute__((cleanup(cleanup_queue)))

6955

task_queue *queue = create_queue();

6956

g_assert_nonnull(queue);

6957

__attribute__((cleanup(string_set_clear)))

6958

string_set cancelled_filenames = {};

6959

int pipefds[2];

6960

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

6961

__attribute__((cleanup(cleanup_close)))

6962

const int read_pipe = pipefds[0];

6963

__attribute__((cleanup(cleanup_close)))

6964

const int write_pipe = pipefds[1];

6965

bool quit_now = false;

6966

6967

__attribute__((nonnull))

6968

void read_func(const task_context task,

6969

__attribute__((unused)) task_queue *const q){

6970

*task.quit_now = true;

6971

}

6972

task_context task1 = {

6973

.func=read_func,

6974

.quit_now=&quit_now,

6975

.fd=read_pipe,

6976

};

6977

g_assert_true(add_to_queue(queue, task1));

6978

6979

__attribute__((nonnull))

6980

void write_func(const task_context task,

6981

__attribute__((unused)) task_queue *const q){

6982

*task.quit_now = true;

6983

}

6984

task_context task2 = {

6985

.func=write_func,

6986

.quit_now=&quit_now,

6987

.fd=write_pipe,

6988

};

6989

g_assert_true(add_to_queue(queue, task2));

6990

6991

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

6992

g_assert_true(quit_now);

6993

6994

/* Either read_pipe or write_pipe should be closed already */

6995

errno = 0;

6996

bool close_read_pipe = (close(read_pipe) == -1);

6997

close_read_pipe &= (errno == EBADF);

6998

errno = 0;

6999

bool close_write_pipe = (close(write_pipe) == -1);

7000

close_write_pipe &= (errno == EBADF);

7001

g_assert_true(close_read_pipe xor close_write_pipe);

7002

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

7003

}

7004

7005

static void test_setup_signal_handler(__attribute__((unused))

7006

test_fixture *fixture,

7007

__attribute__((unused))

7008

gconstpointer user_data){

7009

/* Save current SIGCHLD action, whatever it is */

7010

struct sigaction expected_sigchld_action;

7011

g_assert_cmpint(sigaction(SIGCHLD, NULL, &expected_sigchld_action),

7012

==, 0);

7013

7014

/* Act; i.e. run the setup_signal_handler() function */

7015

struct sigaction actual_old_sigchld_action;

7016

g_assert_true(setup_signal_handler(&actual_old_sigchld_action));

7017

7018

/* Check that the function correctly set "actual_old_sigchld_action"

7019

to the same values as the previously saved

7020

"expected_sigchld_action" */

7021

/* Check member sa_handler */

7022

g_assert_true(actual_old_sigchld_action.sa_handler

7023

== expected_sigchld_action.sa_handler);

7024

/* Check member sa_mask */

7025

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

7026

const int expected_old_block_state

7027

= sigismember(&expected_sigchld_action.sa_mask, signum);

7028

g_assert_cmpint(expected_old_block_state, >=, 0);

7029

const int actual_old_block_state

7030

= sigismember(&actual_old_sigchld_action.sa_mask, signum);

7031

g_assert_cmpint(actual_old_block_state, >=, 0);

7032

g_assert_cmpint(actual_old_block_state,

7033

==, expected_old_block_state);

7034

}

7035

/* Check member sa_flags */

7036

g_assert_true((actual_old_sigchld_action.sa_flags

7037

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

7038

== (expected_sigchld_action.sa_flags

7039

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART)));

7040

7041

/* Retrieve the current signal handler for SIGCHLD as set by

7042

setup_signal_handler() */

7043

struct sigaction actual_new_sigchld_action;

7044

g_assert_cmpint(sigaction(SIGCHLD, NULL,

7045

&actual_new_sigchld_action), ==, 0);

7046

/* Check that the signal handler (member sa_handler) is correctly

7047

set to the "handle_sigchld" function */

7048

g_assert_true(actual_new_sigchld_action.sa_handler != SIG_DFL);

7049

g_assert_true(actual_new_sigchld_action.sa_handler != SIG_IGN);

7050

g_assert_true(actual_new_sigchld_action.sa_handler

7051

== handle_sigchld);

7052

/* Check (in member sa_mask) that at least a handful of signals are

7053

actually blocked during the signal handler */

7054

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

7055

int actual_new_block_state;

7056

switch(signum){

7057

case SIGTERM:

7058

case SIGINT:

7059

case SIGQUIT:

7060

case SIGHUP:

7061

actual_new_block_state

7062

= sigismember(&actual_new_sigchld_action.sa_mask, signum);

7063

g_assert_cmpint(actual_new_block_state, ==, 1);

7064

continue;

7065

case SIGKILL: /* non-blockable */

7066

case SIGSTOP: /* non-blockable */

7067

case SIGCHLD: /* always blocked */

7068

default:

7069

continue;

7070

}

7071

}

7072

/* Check member sa_flags */

7073

g_assert_true((actual_new_sigchld_action.sa_flags

7074

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

7075

== (SA_NOCLDSTOP | SA_RESTART));

7076

7077

/* Restore signal handler */

7078

g_assert_cmpint(sigaction(SIGCHLD, &expected_sigchld_action, NULL),

7079

==, 0);

7080

}

7081

7082

static void test_restore_signal_handler(__attribute__((unused))

7083

test_fixture *fixture,

7084

__attribute__((unused))

7085

gconstpointer user_data){

7086

/* Save current SIGCHLD action, whatever it is */

7087

struct sigaction expected_sigchld_action;

7088

g_assert_cmpint(sigaction(SIGCHLD, NULL, &expected_sigchld_action),

7089

==, 0);

7090

/* Since we haven't established a signal handler yet, there should

7091

not be one established. But another test may have relied on

7092

restore_signal_handler() to restore the signal handler, and if

7093

restore_signal_handler() is buggy (which we should be prepared

7094

for in this test) the signal handler may not have been restored

7095

properly; check for this: */

7096

g_assert_true(expected_sigchld_action.sa_handler != handle_sigchld);

7097

7098

/* Establish a signal handler */

7099

struct sigaction sigchld_action = {

7100

.sa_handler=handle_sigchld,

7101

.sa_flags=SA_RESTART | SA_NOCLDSTOP,

7102

};

7103

g_assert_cmpint(sigfillset(&sigchld_action.sa_mask), ==, 0);

7104

g_assert_cmpint(sigaction(SIGCHLD, &sigchld_action, NULL), ==, 0);

7105

7106

/* Act; i.e. run the restore_signal_handler() function */

7107

g_assert_true(restore_signal_handler(&expected_sigchld_action));

7108

7109

/* Retrieve the restored signal handler data */

7110

struct sigaction actual_restored_sigchld_action;

7111

g_assert_cmpint(sigaction(SIGCHLD, NULL,

7112

&actual_restored_sigchld_action), ==, 0);

7113

7114

/* Check that the function correctly restored the signal action, as

7115

saved in "actual_restored_sigchld_action", to the same values as

7116

the previously saved "expected_sigchld_action" */

7117

/* Check member sa_handler */

7118

g_assert_true(actual_restored_sigchld_action.sa_handler

7119

== expected_sigchld_action.sa_handler);

7120

/* Check member sa_mask */

7121

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

7122

const int expected_old_block_state

7123

= sigismember(&expected_sigchld_action.sa_mask, signum);

7124

g_assert_cmpint(expected_old_block_state, >=, 0);

7125

const int actual_restored_block_state

7126

= sigismember(&actual_restored_sigchld_action.sa_mask, signum);

7127

g_assert_cmpint(actual_restored_block_state, >=, 0);

7128

g_assert_cmpint(actual_restored_block_state,

7129

==, expected_old_block_state);

7130

}

7131

/* Check member sa_flags */

7132

g_assert_true((actual_restored_sigchld_action.sa_flags

7133

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

7134

== (expected_sigchld_action.sa_flags

7135

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART)));

7136

}

7137

7138

static void test_block_sigchld(__attribute__((unused))

7139

test_fixture *fixture,

7140

__attribute__((unused))

7141

gconstpointer user_data){

7142

/* Save original signal mask */

7143

sigset_t expected_sigmask;

7144

g_assert_cmpint(pthread_sigmask(-1, NULL, &expected_sigmask),

7145

==, 0);

7146

7147

/* Make sure SIGCHLD is unblocked for this test */

7148

sigset_t sigchld_sigmask;

7149

g_assert_cmpint(sigemptyset(&sigchld_sigmask), ==, 0);

7150

g_assert_cmpint(sigaddset(&sigchld_sigmask, SIGCHLD), ==, 0);

7151

g_assert_cmpint(pthread_sigmask(SIG_UNBLOCK, &sigchld_sigmask,

7152

NULL), ==, 0);

7153

7154

/* Act; i.e. run the block_sigchld() function */

7155

sigset_t actual_old_sigmask;

7156

g_assert_true(block_sigchld(&actual_old_sigmask));

7157

7158

/* Check the actual_old_sigmask; it should be the same as the

7159

previously saved signal mask "expected_sigmask". */

7160

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

7161

const int expected_old_block_state

7162

= sigismember(&expected_sigmask, signum);

7163

g_assert_cmpint(expected_old_block_state, >=, 0);

7164

const int actual_old_block_state

7165

= sigismember(&actual_old_sigmask, signum);

7166

g_assert_cmpint(actual_old_block_state, >=, 0);

7167

g_assert_cmpint(actual_old_block_state,

7168

==, expected_old_block_state);

7169

}

7170

7171

/* Retrieve the newly set signal mask */

7172

sigset_t actual_sigmask;

7173

g_assert_cmpint(pthread_sigmask(-1, NULL, &actual_sigmask), ==, 0);

7174

7175

/* SIGCHLD should be blocked */

7176

g_assert_cmpint(sigismember(&actual_sigmask, SIGCHLD), ==, 1);

7177

7178

/* Restore signal mask */

7179

g_assert_cmpint(pthread_sigmask(SIG_SETMASK, &expected_sigmask,

7180

NULL), ==, 0);

7181

}

7182

7183

static void test_restore_sigmask(__attribute__((unused))

7184

test_fixture *fixture,

7185

__attribute__((unused))

7186

gconstpointer user_data){

7187

/* Save original signal mask */

7188

sigset_t orig_sigmask;

7189

g_assert_cmpint(pthread_sigmask(-1, NULL, &orig_sigmask), ==, 0);

7190

7191

/* Make sure SIGCHLD is blocked for this test */

7192

sigset_t sigchld_sigmask;

7193

g_assert_cmpint(sigemptyset(&sigchld_sigmask), ==, 0);

7194

g_assert_cmpint(sigaddset(&sigchld_sigmask, SIGCHLD), ==, 0);

7195

g_assert_cmpint(pthread_sigmask(SIG_BLOCK, &sigchld_sigmask,

7196

NULL), ==, 0);

7197

7198

/* Act; i.e. run the restore_sigmask() function */

7199

g_assert_true(restore_sigmask(&orig_sigmask));

7200

7201

/* Retrieve the newly restored signal mask */

7202

sigset_t restored_sigmask;

7203

g_assert_cmpint(pthread_sigmask(-1, NULL, &restored_sigmask),

7204

==, 0);

7205

7206

/* Check the restored_sigmask; it should be the same as the

7207

previously saved signal mask "orig_sigmask". */

7208

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

7209

const int orig_block_state = sigismember(&orig_sigmask, signum);

7210

g_assert_cmpint(orig_block_state, >=, 0);

7211

const int restored_block_state = sigismember(&restored_sigmask,

7212

signum);

7213

g_assert_cmpint(restored_block_state, >=, 0);

7214

g_assert_cmpint(restored_block_state, ==, orig_block_state);

7215

}

7216

7217

/* Restore signal mask */

7218

g_assert_cmpint(pthread_sigmask(SIG_SETMASK, &orig_sigmask,

7219

NULL), ==, 0);

7220

}

7221

7222

static void test_parse_arguments_noargs(__attribute__((unused))

7223

test_fixture *fixture,

7224

__attribute__((unused))

7225

gconstpointer user_data){

7226

char *argv[] = {

7227

strdup("prgname"),

7228

NULL };

7229

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7230

7231

char *agent_directory = NULL;

7232

char *helper_directory = NULL;

7233

uid_t user = 0;

7234

gid_t group = 0;

7235

char *mandos_argz = NULL;

7236

size_t mandos_argz_length = 0;

7237

7238

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7239

&helper_directory, &user, &group,

7240

&mandos_argz, &mandos_argz_length));

7241

g_assert_null(agent_directory);

7242

g_assert_null(helper_directory);

7243

g_assert_true(user == 0);

7244

g_assert_true(group == 0);

7245

g_assert_null(mandos_argz);

7246

g_assert_true(mandos_argz_length == 0);

7247

7248

for(char **arg = argv; *arg != NULL; arg++){

7249

free(*arg);

7250

}

7251

}

7252

7253

__attribute__((nonnull))

7254

static bool parse_arguments_devnull(int argc, char *argv[],

7255

const bool exit_failure,

7256

char **agent_directory,

7257

char **helper_directory,

7258

uid_t *const user,

7259

gid_t *const group,

7260

char **mandos_argz,

7261

size_t *mandos_argz_length){

7262

7263

FILE *real_stderr = stderr;

7264

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

7265

g_assert_nonnull(devnull);

7266

stderr = devnull;

7267

7268

const bool ret = parse_arguments(argc, argv, exit_failure,

7269

agent_directory,

7270

helper_directory, user, group,

7271

mandos_argz, mandos_argz_length);

7272

const error_t saved_errno = errno;

7273

7274

stderr = real_stderr;

7275

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

7276

7277

errno = saved_errno;

7278

7279

return ret;

7280

}

7281

7282

static void test_parse_arguments_invalid(__attribute__((unused))

7283

test_fixture *fixture,

7284

__attribute__((unused))

7285

gconstpointer user_data){

7286

char *argv[] = {

7287

strdup("prgname"),

7288

strdup("--invalid"),

7289

NULL };

7290

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7291

7292

char *agent_directory = NULL;

7293

char *helper_directory = NULL;

7294

uid_t user = 0;

7295

gid_t group = 0;

7296

char *mandos_argz = NULL;

7297

size_t mandos_argz_length = 0;

7298

7299

g_assert_false(parse_arguments_devnull(argc, argv, false,

7300

&agent_directory,

7301

&helper_directory, &user,

7302

&group, &mandos_argz,

7303

&mandos_argz_length));

7304

7305

g_assert_true(errno == EINVAL);

7306

g_assert_null(agent_directory);

7307

g_assert_null(helper_directory);

7308

g_assert_null(mandos_argz);

7309

g_assert_true(mandos_argz_length == 0);

7310

7311

for(char **arg = argv; *arg != NULL; arg++){

7312

free(*arg);

7313

}

7314

}

7315

7316

static void test_parse_arguments_long_dir(__attribute__((unused))

7317

test_fixture *fixture,

7318

__attribute__((unused))

7319

gconstpointer user_data){

7320

char *argv[] = {

7321

strdup("prgname"),

7322

strdup("--agent-directory"),

7323

strdup("/tmp"),

7324

NULL };

7325

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7326

7327

__attribute__((cleanup(cleanup_string)))

7328

char *agent_directory = NULL;

7329

char *helper_directory = NULL;

7330

uid_t user = 0;

7331

gid_t group = 0;

7332

__attribute__((cleanup(cleanup_string)))

7333

char *mandos_argz = NULL;

7334

size_t mandos_argz_length = 0;

7335

7336

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7337

&helper_directory, &user, &group,

7338

&mandos_argz, &mandos_argz_length));

7339

7340

g_assert_cmpstr(agent_directory, ==, "/tmp");

7341

g_assert_null(helper_directory);

7342

g_assert_true(user == 0);

7343

g_assert_true(group == 0);

7344

g_assert_null(mandos_argz);

7345

g_assert_true(mandos_argz_length == 0);

7346

7347

for(char **arg = argv; *arg != NULL; arg++){

7348

free(*arg);

7349

}

7350

}

7351

7352

static void test_parse_arguments_short_dir(__attribute__((unused))

7353

test_fixture *fixture,

7354

__attribute__((unused))

7355

gconstpointer user_data){

7356

char *argv[] = {

7357

strdup("prgname"),

7358

strdup("-d"),

7359

strdup("/tmp"),

7360

NULL };

7361

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7362

7363

__attribute__((cleanup(cleanup_string)))

7364

char *agent_directory = NULL;

7365

char *helper_directory = NULL;

7366

uid_t user = 0;

7367

gid_t group = 0;

7368

__attribute__((cleanup(cleanup_string)))

7369

char *mandos_argz = NULL;

7370

size_t mandos_argz_length = 0;

7371

7372

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7373

&helper_directory, &user, &group,

7374

&mandos_argz, &mandos_argz_length));

7375

7376

g_assert_cmpstr(agent_directory, ==, "/tmp");

7377

g_assert_null(helper_directory);

7378

g_assert_true(user == 0);

7379

g_assert_true(group == 0);

7380

g_assert_null(mandos_argz);

7381

g_assert_true(mandos_argz_length == 0);

7382

7383

for(char **arg = argv; *arg != NULL; arg++){

7384

free(*arg);

7385

}

7386

}

7387

7388

static

7389

void test_parse_arguments_helper_directory(__attribute__((unused))

7390

test_fixture *fixture,

7391

__attribute__((unused))

7392

gconstpointer user_data){

7393

char *argv[] = {

7394

strdup("prgname"),

7395

strdup("--helper-directory"),

7396

strdup("/tmp"),

7397

NULL };

7398

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7399

7400

char *agent_directory = NULL;

7401

__attribute__((cleanup(cleanup_string)))

7402

char *helper_directory = NULL;

7403

uid_t user = 0;

7404

gid_t group = 0;

7405

__attribute__((cleanup(cleanup_string)))

7406

char *mandos_argz = NULL;

7407

size_t mandos_argz_length = 0;

7408

7409

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7410

&helper_directory, &user, &group,

7411

&mandos_argz, &mandos_argz_length));

7412

7413

g_assert_cmpstr(helper_directory, ==, "/tmp");

7414

g_assert_null(agent_directory);

7415

g_assert_true(user == 0);

7416

g_assert_true(group == 0);

7417

g_assert_null(mandos_argz);

7418

g_assert_true(mandos_argz_length == 0);

7419

7420

for(char **arg = argv; *arg != NULL; arg++){

7421

free(*arg);

7422

}

7423

}

7424

7425

static

7426

void test_parse_arguments_plugin_helper_dir(__attribute__((unused))

7427

test_fixture *fixture,

7428

__attribute__((unused))

7429

gconstpointer user_data){

7430

char *argv[] = {

7431

strdup("prgname"),

7432

strdup("--plugin-helper-dir"),

7433

strdup("/tmp"),

7434

NULL };

7435

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7436

7437

char *agent_directory = NULL;

7438

__attribute__((cleanup(cleanup_string)))

7439

char *helper_directory = NULL;

7440

uid_t user = 0;

7441

gid_t group = 0;

7442

__attribute__((cleanup(cleanup_string)))

7443

char *mandos_argz = NULL;

7444

size_t mandos_argz_length = 0;

7445

7446

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7447

&helper_directory, &user, &group,

7448

&mandos_argz, &mandos_argz_length));

7449

7450

g_assert_cmpstr(helper_directory, ==, "/tmp");

7451

g_assert_null(agent_directory);

7452

g_assert_true(user == 0);

7453

g_assert_true(group == 0);

7454

g_assert_null(mandos_argz);

7455

g_assert_true(mandos_argz_length == 0);

7456

7457

for(char **arg = argv; *arg != NULL; arg++){

7458

free(*arg);

7459

}

7460

}

7461

7462

static void test_parse_arguments_user(__attribute__((unused))

7463

test_fixture *fixture,

7464

__attribute__((unused))

7465

gconstpointer user_data){

7466

char *argv[] = {

7467

strdup("prgname"),

7468

strdup("--user"),

7469

strdup("1000"),

7470

NULL };

7471

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7472

7473

char *agent_directory = NULL;

7474

__attribute__((cleanup(cleanup_string)))

7475

char *helper_directory = NULL;

7476

uid_t user = 0;

7477

gid_t group = 0;

7478

__attribute__((cleanup(cleanup_string)))

7479

char *mandos_argz = NULL;

7480

size_t mandos_argz_length = 0;

7481

7482

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7483

&helper_directory, &user, &group,

7484

&mandos_argz, &mandos_argz_length));

7485

7486

g_assert_null(helper_directory);

7487

g_assert_null(agent_directory);

7488

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

7489

g_assert_true(group == 0);

7490

g_assert_null(mandos_argz);

7491

g_assert_true(mandos_argz_length == 0);

7492

7493

for(char **arg = argv; *arg != NULL; arg++){

7494

free(*arg);

7495

}

7496

}

7497

7498

static void test_parse_arguments_user_invalid(__attribute__((unused))

7499

test_fixture *fixture,

7500

__attribute__((unused))

7501

gconstpointer

7502

user_data){

7503

char *argv[] = {

7504

strdup("prgname"),

7505

strdup("--user"),

7506

strdup("invalid"),

7507

NULL };

7508

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7509

7510

char *agent_directory = NULL;

7511

__attribute__((cleanup(cleanup_string)))

7512

char *helper_directory = NULL;

7513

uid_t user = 0;

7514

gid_t group = 0;

7515

__attribute__((cleanup(cleanup_string)))

7516

char *mandos_argz = NULL;

7517

size_t mandos_argz_length = 0;

7518

7519

g_assert_false(parse_arguments_devnull(argc, argv, false,

7520

&agent_directory,

7521

&helper_directory, &user,

7522

&group, &mandos_argz,

7523

&mandos_argz_length));

7524

7525

g_assert_null(helper_directory);

7526

g_assert_null(agent_directory);

7527

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

7528

g_assert_true(group == 0);

7529

g_assert_null(mandos_argz);

7530

g_assert_true(mandos_argz_length == 0);

7531

7532

for(char **arg = argv; *arg != NULL; arg++){

7533

free(*arg);

7534

}

7535

}

7536

7537

static

7538

void test_parse_arguments_user_zero_invalid(__attribute__((unused))

7539

test_fixture *fixture,

7540

__attribute__((unused))

7541

gconstpointer user_data){

7542

char *argv[] = {

7543

strdup("prgname"),

7544

strdup("--user"),

7545

strdup("0"),

7546

NULL };

7547

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7548

7549

char *agent_directory = NULL;

7550

__attribute__((cleanup(cleanup_string)))

7551

char *helper_directory = NULL;

7552

uid_t user = 0;

7553

gid_t group = 0;

7554

__attribute__((cleanup(cleanup_string)))

7555

char *mandos_argz = NULL;

7556

size_t mandos_argz_length = 0;

7557

7558

g_assert_false(parse_arguments_devnull(argc, argv, false,

7559

&agent_directory,

7560

&helper_directory, &user,

7561

&group, &mandos_argz,

7562

&mandos_argz_length));

7563

7564

g_assert_null(helper_directory);

7565

g_assert_null(agent_directory);

7566

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

7567

g_assert_true(group == 0);

7568

g_assert_null(mandos_argz);

7569

g_assert_true(mandos_argz_length == 0);

7570

7571

for(char **arg = argv; *arg != NULL; arg++){

7572

free(*arg);

7573

}

7574

}

7575

7576

static void test_parse_arguments_group(__attribute__((unused))

7577

test_fixture *fixture,

7578

__attribute__((unused))

7579

gconstpointer user_data){

7580

char *argv[] = {

7581

strdup("prgname"),

7582

strdup("--group"),

7583

strdup("1000"),

7584

NULL };

7585

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7586

7587

char *agent_directory = NULL;

7588

__attribute__((cleanup(cleanup_string)))

7589

char *helper_directory = NULL;

7590

uid_t user = 0;

7591

gid_t group = 0;

7592

__attribute__((cleanup(cleanup_string)))

7593

char *mandos_argz = NULL;

7594

size_t mandos_argz_length = 0;

7595

7596

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7597

&helper_directory, &user, &group,

7598

&mandos_argz, &mandos_argz_length));

7599

7600

g_assert_null(helper_directory);

7601

g_assert_null(agent_directory);

7602

g_assert_true(user == 0);

7603

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

7604

g_assert_null(mandos_argz);

7605

g_assert_true(mandos_argz_length == 0);

7606

7607

for(char **arg = argv; *arg != NULL; arg++){

7608

free(*arg);

7609

}

7610

}

7611

7612

static void test_parse_arguments_group_invalid(__attribute__((unused))

7613

test_fixture *fixture,

7614

__attribute__((unused))

7615

gconstpointer

7616

user_data){

7617

char *argv[] = {

7618

strdup("prgname"),

7619

strdup("--group"),

7620

strdup("invalid"),

7621

NULL };

7622

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7623

7624

char *agent_directory = NULL;

7625

__attribute__((cleanup(cleanup_string)))

7626

char *helper_directory = NULL;

7627

uid_t user = 0;

7628

gid_t group = 0;

7629

__attribute__((cleanup(cleanup_string)))

7630

char *mandos_argz = NULL;

7631

size_t mandos_argz_length = 0;

7632

7633

g_assert_false(parse_arguments_devnull(argc, argv, false,

7634

&agent_directory,

7635

&helper_directory, &user,

7636

&group, &mandos_argz,

7637

&mandos_argz_length));

7638

7639

g_assert_null(helper_directory);

7640

g_assert_null(agent_directory);

7641

g_assert_true(user == 0);

7642

g_assert_true(group == 0);

7643

g_assert_null(mandos_argz);

7644

g_assert_true(mandos_argz_length == 0);

7645

7646

for(char **arg = argv; *arg != NULL; arg++){

7647

free(*arg);

7648

}

7649

}

7650

7651

static

7652

void test_parse_arguments_group_zero_invalid(__attribute__((unused))

7653

test_fixture *fixture,

7654

__attribute__((unused))

7655

gconstpointer user_data){

7656

char *argv[] = {

7657

strdup("prgname"),

7658

strdup("--group"),

7659

strdup("0"),

7660

NULL };

7661

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7662

7663

char *agent_directory = NULL;

7664

__attribute__((cleanup(cleanup_string)))

7665

char *helper_directory = NULL;

7666

uid_t user = 0;

7667

gid_t group = 0;

7668

__attribute__((cleanup(cleanup_string)))

7669

char *mandos_argz = NULL;

7670

size_t mandos_argz_length = 0;

7671

7672

g_assert_false(parse_arguments_devnull(argc, argv, false,

7673

&agent_directory,

7674

&helper_directory, &user,

7675

&group, &mandos_argz,

7676

&mandos_argz_length));

7677

7678

g_assert_null(helper_directory);

7679

g_assert_null(agent_directory);

7680

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

7681

g_assert_true(group == 0);

7682

g_assert_null(mandos_argz);

7683

g_assert_true(mandos_argz_length == 0);

7684

7685

for(char **arg = argv; *arg != NULL; arg++){

7686

free(*arg);

7687

}

7688

}

7689

7690

static void test_parse_arguments_mandos_noargs(__attribute__((unused))

7691

test_fixture *fixture,

7692

__attribute__((unused))

7693

gconstpointer

7694

user_data){

7695

char *argv[] = {

7696

strdup("prgname"),

7697

strdup("mandos-client"),

7698

NULL };

7699

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7700

7701

__attribute__((cleanup(cleanup_string)))

7702

char *agent_directory = NULL;

7703

__attribute__((cleanup(cleanup_string)))

7704

char *helper_directory = NULL;

7705

uid_t user = 0;

7706

gid_t group = 0;

7707

__attribute__((cleanup(cleanup_string)))

7708

char *mandos_argz = NULL;

7709

size_t mandos_argz_length = 0;

7710

7711

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7712

&helper_directory, &user, &group,

7713

&mandos_argz, &mandos_argz_length));

7714

7715

g_assert_null(agent_directory);

7716

g_assert_null(helper_directory);

7717

g_assert_true(user == 0);

7718

g_assert_true(group == 0);

7719

g_assert_cmpstr(mandos_argz, ==, "mandos-client");

7720

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7721

mandos_argz_length),

7722

==, 1);

7723

7724

for(char **arg = argv; *arg != NULL; arg++){

7725

free(*arg);

7726

}

7727

}

7728

7729

static void test_parse_arguments_mandos_args(__attribute__((unused))

7730

test_fixture *fixture,

7731

__attribute__((unused))

7732

gconstpointer user_data){

7733

char *argv[] = {

7734

strdup("prgname"),

7735

strdup("mandos-client"),

7736

strdup("one"),

7737

strdup("two"),

7738

strdup("three"),

7739

NULL };

7740

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7741

7742

__attribute__((cleanup(cleanup_string)))

7743

char *agent_directory = NULL;

7744

__attribute__((cleanup(cleanup_string)))

7745

char *helper_directory = NULL;

7746

uid_t user = 0;

7747

gid_t group = 0;

7748

__attribute__((cleanup(cleanup_string)))

7749

char *mandos_argz = NULL;

7750

size_t mandos_argz_length = 0;

7751

7752

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7753

&helper_directory, &user, &group,

7754

&mandos_argz, &mandos_argz_length));

7755

7756

g_assert_null(agent_directory);

7757

g_assert_null(helper_directory);

7758

g_assert_true(user == 0);

7759

g_assert_true(group == 0);

7760

char *marg = mandos_argz;

7761

g_assert_cmpstr(marg, ==, "mandos-client");

7762

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7763

g_assert_cmpstr(marg, ==, "one");

7764

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7765

g_assert_cmpstr(marg, ==, "two");

7766

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7767

g_assert_cmpstr(marg, ==, "three");

7768

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7769

mandos_argz_length),

7770

==, 4);

7771

7772

for(char **arg = argv; *arg != NULL; arg++){

7773

free(*arg);

7774

}

7775

}

7776

7777

static void test_parse_arguments_all_args(__attribute__((unused))

7778

test_fixture *fixture,

7779

__attribute__((unused))

7780

gconstpointer user_data){

7781

char *argv[] = {

7782

strdup("prgname"),

7783

strdup("--agent-directory"),

7784

strdup("/tmp"),

7785

strdup("--helper-directory"),

7786

strdup("/var/tmp"),

7787

strdup("--user"),

7788

strdup("1"),

7789

strdup("--group"),

7790

strdup("2"),

7791

strdup("mandos-client"),

7792

strdup("one"),

7793

strdup("two"),

7794

strdup("three"),

7795

NULL };

7796

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7797

7798

__attribute__((cleanup(cleanup_string)))

7799

char *agent_directory = NULL;

7800

__attribute__((cleanup(cleanup_string)))

7801

char *helper_directory = NULL;

7802

uid_t user = 0;

7803

gid_t group = 0;

7804

__attribute__((cleanup(cleanup_string)))

7805

char *mandos_argz = NULL;

7806

size_t mandos_argz_length = 0;

7807

7808

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7809

&helper_directory, &user, &group,

7810

&mandos_argz, &mandos_argz_length));

7811

7812

g_assert_cmpstr(agent_directory, ==, "/tmp");

7813

g_assert_cmpstr(helper_directory, ==, "/var/tmp");

7814

g_assert_true(user == 1);

7815

g_assert_true(group == 2);

7816

char *marg = mandos_argz;

7817

g_assert_cmpstr(marg, ==, "mandos-client");

7818

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7819

g_assert_cmpstr(marg, ==, "one");

7820

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7821

g_assert_cmpstr(marg, ==, "two");

7822

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7823

g_assert_cmpstr(marg, ==, "three");

7824

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7825

mandos_argz_length),

7826

==, 4);

7827

7828

for(char **arg = argv; *arg != NULL; arg++){

7829

free(*arg);

7830

}

7831

}

7832

7833

static void test_parse_arguments_mixed(__attribute__((unused))

7834

test_fixture *fixture,

7835

__attribute__((unused))

7836

gconstpointer user_data){

7837

char *argv[] = {

7838

strdup("prgname"),

7839

strdup("mandos-client"),

7840

strdup("--user"),

7841

strdup("1"),

7842

strdup("one"),

7843

strdup("--agent-directory"),

7844

strdup("/tmp"),

7845

strdup("two"),

7846

strdup("three"),

7847

strdup("--helper-directory=/var/tmp"),

7848

NULL };

7849

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7850

7851

__attribute__((cleanup(cleanup_string)))

7852

char *agent_directory = NULL;

7853

__attribute__((cleanup(cleanup_string)))

7854

char *helper_directory = NULL;

7855

uid_t user = 0;

7856

gid_t group = 0;

7857

__attribute__((cleanup(cleanup_string)))

7858

char *mandos_argz = NULL;

7859

size_t mandos_argz_length = 0;

7860

7861

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7862

&helper_directory, &user, &group,

7863

&mandos_argz, &mandos_argz_length));

7864

7865

g_assert_cmpstr(agent_directory, ==, "/tmp");

7866

g_assert_cmpstr(helper_directory, ==, "/var/tmp");

7867

g_assert_true(user == 1);

7868

g_assert_true(group == 0);

7869

char *marg = mandos_argz;

7870

g_assert_cmpstr(marg, ==, "mandos-client");

7871

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7872

g_assert_cmpstr(marg, ==, "one");

7873

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7874

g_assert_cmpstr(marg, ==, "two");

7875

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7876

g_assert_cmpstr(marg, ==, "three");

7877

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7878

mandos_argz_length),

7879

==, 4);

7880

7881

for(char **arg = argv; *arg != NULL; arg++){

7882

free(*arg);

7883

}

7884

}

7885

7886

/* End of tests section */

7887

7888

/* Test boilerplate section; New tests should be added to the test

7889

suite definition here, in the "run_tests" function.

7890

7891

Finally, this section also contains the should_only_run_tests()

7892

function used by main() for deciding if tests should be run or to

7893

start normally. */

7894

7895

__attribute__((cold))

7896

static bool run_tests(int argc, char *argv[]){

7897

g_test_init(&argc, &argv, NULL);

7898

7899

/* A macro to add a test with no setup or teardown functions */

7900

#define test_add(testpath, testfunc) \

7901

do { \

7902

g_test_add((testpath), test_fixture, NULL, NULL, \

7903

(testfunc), NULL); \

7904

} while(false)

7905

7906

/* Test the signal-related functions first, since some other tests

7907

depend on these functions in their setups and teardowns */

7908

test_add("/signal-handling/setup", test_setup_signal_handler);

7909

test_add("/signal-handling/restore", test_restore_signal_handler);

7910

test_add("/signal-handling/block", test_block_sigchld);

7911

test_add("/signal-handling/restore-sigmask", test_restore_sigmask);

7912

7913

/* Regular non-signal-related tests; these use no setups or

7914

teardowns */

7915

test_add("/parse_arguments/noargs", test_parse_arguments_noargs);

7916

test_add("/parse_arguments/invalid", test_parse_arguments_invalid);

7917

test_add("/parse_arguments/long-dir",

7918

test_parse_arguments_long_dir);

7919

test_add("/parse_arguments/short-dir",

7920

test_parse_arguments_short_dir);

7921

test_add("/parse_arguments/helper-directory",

7922

test_parse_arguments_helper_directory);

7923

test_add("/parse_arguments/plugin-helper-dir",

7924

test_parse_arguments_plugin_helper_dir);

7925

test_add("/parse_arguments/user", test_parse_arguments_user);

7926

test_add("/parse_arguments/user-invalid",

7927

test_parse_arguments_user_invalid);

7928

test_add("/parse_arguments/user-zero-invalid",

7929

test_parse_arguments_user_zero_invalid);

7930

test_add("/parse_arguments/group", test_parse_arguments_group);

7931

test_add("/parse_arguments/group-invalid",

7932

test_parse_arguments_group_invalid);

7933

test_add("/parse_arguments/group-zero-invalid",

7934

test_parse_arguments_group_zero_invalid);

7935

test_add("/parse_arguments/mandos-noargs",

7936

test_parse_arguments_mandos_noargs);

7937

test_add("/parse_arguments/mandos-args",

7938

test_parse_arguments_mandos_args);

7939

test_add("/parse_arguments/all-args",

7940

test_parse_arguments_all_args);

7941

test_add("/parse_arguments/mixed", test_parse_arguments_mixed);

7942

test_add("/queue/create", test_create_queue);

7943

test_add("/queue/add", test_add_to_queue);

7944

test_add("/queue/add/overflow", test_add_to_queue_overflow);

7945

test_add("/queue/has_question/empty",

7946

test_queue_has_question_empty);

7947

test_add("/queue/has_question/false",

7948

test_queue_has_question_false);

7949

test_add("/queue/has_question/true", test_queue_has_question_true);

7950

test_add("/queue/has_question/false2",

7951

test_queue_has_question_false2);

7952

test_add("/queue/has_question/true2",

7953

test_queue_has_question_true2);

7954

test_add("/buffer/cleanup", test_cleanup_buffer);

7955

test_add("/string_set/net-set-contains-nothing",

7956

test_string_set_new_set_contains_nothing);

7957

test_add("/string_set/with-added-string-contains-it",

7958

test_string_set_with_added_string_contains_it);

7959

test_add("/string_set/cleared-does-not-contain-string",

7960

test_string_set_cleared_does_not_contain_str);

7961

test_add("/string_set/swap/one-with-empty",

7962

test_string_set_swap_one_with_empty);

7963

test_add("/string_set/swap/empty-with-one",

7964

test_string_set_swap_empty_with_one);

7965

test_add("/string_set/swap/one-with-one",

7966

test_string_set_swap_one_with_one);

7967

7968

/* A macro to add a test using the setup and teardown functions */

7969

#define test_add_st(path, func) \

7970

do { \

7971

g_test_add((path), test_fixture, NULL, test_setup, (func), \

7972

test_teardown); \

7973

} while(false)

7974

7975

/* Signal-related tests; these use setups and teardowns which

7976

establish, during each test run, a signal handler for, and a

7977

signal mask blocking, the SIGCHLD signal, just like main() */

7978

test_add_st("/wait_for_event/timeout", test_wait_for_event_timeout);

7979

test_add_st("/wait_for_event/event", test_wait_for_event_event);

7980

test_add_st("/wait_for_event/sigchld", test_wait_for_event_sigchld);

7981

test_add_st("/run_queue/zeroes-next-run",

7982

test_run_queue_zeroes_next_run);

7983

test_add_st("/run_queue/clears-cancelled_filenames",

7984

test_run_queue_clears_cancelled_filenames);

7985

test_add_st("/run_queue/skips-cancelled-filenames",

7986

test_run_queue_skips_cancelled_filenames);

7987

test_add_st("/run_queue/one-task", test_run_queue_one_task);

7988

test_add_st("/run_queue/two-tasks", test_run_queue_two_tasks);

7989

test_add_st("/run_queue/two-tasks/quit",

7990

test_run_queue_two_tasks_quit);

7991

test_add_st("/run_queue/two-tasks-cleanup",

7992

test_run_queue_two_tasks_cleanup);

7993

test_add_st("/task-creators/start_mandos_client",

7994

test_start_mandos_client);

7995

test_add_st("/task-creators/start_mandos_client/execv",

7996

test_start_mandos_client_execv);

7997

test_add_st("/task-creators/start_mandos_client/suid/euid",

7998

test_start_mandos_client_suid_euid);

7999

test_add_st("/task-creators/start_mandos_client/suid/egid",

8000

test_start_mandos_client_suid_egid);

8001

test_add_st("/task-creators/start_mandos_client/suid/ruid",

8002

test_start_mandos_client_suid_ruid);

8003

test_add_st("/task-creators/start_mandos_client/suid/rgid",

8004

test_start_mandos_client_suid_rgid);

8005

test_add_st("/task-creators/start_mandos_client/read",

8006

test_start_mandos_client_read);

8007

test_add_st("/task-creators/start_mandos_client/helper-directory",

8008

test_start_mandos_client_helper_directory);

8009

test_add_st("/task-creators/start_mandos_client/sigmask",

8010

test_start_mandos_client_sigmask);

8011

test_add_st("/task/wait_for_mandos_client_exit/badpid",

8012

test_wait_for_mandos_client_exit_badpid);

8013

test_add_st("/task/wait_for_mandos_client_exit/noexit",

8014

test_wait_for_mandos_client_exit_noexit);

8015

test_add_st("/task/wait_for_mandos_client_exit/success",

8016

test_wait_for_mandos_client_exit_success);

8017

test_add_st("/task/wait_for_mandos_client_exit/failure",

8018

test_wait_for_mandos_client_exit_failure);

8019

test_add_st("/task/wait_for_mandos_client_exit/killed",

8020

test_wait_for_mandos_client_exit_killed);

8021

test_add_st("/task/read_mandos_client_output/readerror",

8022

test_read_mandos_client_output_readerror);

8023

test_add_st("/task/read_mandos_client_output/nodata",

8024

test_read_mandos_client_output_nodata);

8025

test_add_st("/task/read_mandos_client_output/eof",

8026

test_read_mandos_client_output_eof);

8027

test_add_st("/task/read_mandos_client_output/once",

8028

test_read_mandos_client_output_once);

8029

test_add_st("/task/read_mandos_client_output/malloc",

8030

test_read_mandos_client_output_malloc);

8031

test_add_st("/task/read_mandos_client_output/append",

8032

test_read_mandos_client_output_append);

8033

test_add_st("/task-creators/add_inotify_dir_watch",

8034

test_add_inotify_dir_watch);

8035

test_add_st("/task-creators/add_inotify_dir_watch/fail",

8036

test_add_inotify_dir_watch_fail);

8037

test_add_st("/task-creators/add_inotify_dir_watch/not-a-directory",

8038

test_add_inotify_dir_watch_nondir);

8039

test_add_st("/task-creators/add_inotify_dir_watch/EAGAIN",

8040

test_add_inotify_dir_watch_EAGAIN);

8041

test_add_st("/task-creators/add_inotify_dir_watch/IN_CLOSE_WRITE",

8042

test_add_inotify_dir_watch_IN_CLOSE_WRITE);

8043

test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_TO",

8044

test_add_inotify_dir_watch_IN_MOVED_TO);

8045

test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_FROM",

8046

test_add_inotify_dir_watch_IN_MOVED_FROM);

8047

test_add_st("/task-creators/add_inotify_dir_watch/IN_EXCL_UNLINK",

8048

test_add_inotify_dir_watch_IN_EXCL_UNLINK);

8049

test_add_st("/task-creators/add_inotify_dir_watch/IN_DELETE",

8050

test_add_inotify_dir_watch_IN_DELETE);

8051

test_add_st("/task/read_inotify_event/readerror",

8052

test_read_inotify_event_readerror);

8053

test_add_st("/task/read_inotify_event/bad-epoll",

8054

test_read_inotify_event_bad_epoll);

8055

test_add_st("/task/read_inotify_event/nodata",

8056

test_read_inotify_event_nodata);

8057

test_add_st("/task/read_inotify_event/eof",

8058

test_read_inotify_event_eof);

8059

test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE",

8060

test_read_inotify_event_IN_CLOSE_WRITE);

8061

test_add_st("/task/read_inotify_event/IN_MOVED_TO",

8062

test_read_inotify_event_IN_MOVED_TO);

8063

test_add_st("/task/read_inotify_event/IN_MOVED_FROM",

8064

test_read_inotify_event_IN_MOVED_FROM);

8065

test_add_st("/task/read_inotify_event/IN_DELETE",

8066

test_read_inotify_event_IN_DELETE);

8067

test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE/badname",

8068

test_read_inotify_event_IN_CLOSE_WRITE_badname);

8069

test_add_st("/task/read_inotify_event/IN_MOVED_TO/badname",

8070

test_read_inotify_event_IN_MOVED_TO_badname);

8071

test_add_st("/task/read_inotify_event/IN_MOVED_FROM/badname",

8072

test_read_inotify_event_IN_MOVED_FROM_badname);

8073

test_add_st("/task/read_inotify_event/IN_DELETE/badname",

8074

test_read_inotify_event_IN_DELETE_badname);

8075

test_add_st("/task/open_and_parse_question/ENOENT",

8076

test_open_and_parse_question_ENOENT);

8077

test_add_st("/task/open_and_parse_question/EIO",

8078

test_open_and_parse_question_EIO);

8079

test_add_st("/task/open_and_parse_question/parse-error",

8080

test_open_and_parse_question_parse_error);

8081

test_add_st("/task/open_and_parse_question/nosocket",

8082

test_open_and_parse_question_nosocket);

8083

test_add_st("/task/open_and_parse_question/badsocket",

8084

test_open_and_parse_question_badsocket);

8085

test_add_st("/task/open_and_parse_question/nopid",

8086

test_open_and_parse_question_nopid);

8087

test_add_st("/task/open_and_parse_question/badpid",

8088

test_open_and_parse_question_badpid);

8089

test_add_st("/task/open_and_parse_question/noexist_pid",

8090

test_open_and_parse_question_noexist_pid);

8091

test_add_st("/task/open_and_parse_question/no-notafter",

8092

test_open_and_parse_question_no_notafter);

8093

test_add_st("/task/open_and_parse_question/bad-notafter",

8094

test_open_and_parse_question_bad_notafter);

8095

test_add_st("/task/open_and_parse_question/notafter-0",

8096

test_open_and_parse_question_notafter_0);

8097

test_add_st("/task/open_and_parse_question/notafter-1",

8098

test_open_and_parse_question_notafter_1);

8099

test_add_st("/task/open_and_parse_question/notafter-1-1",

8100

test_open_and_parse_question_notafter_1_1);

8101

test_add_st("/task/open_and_parse_question/notafter-1-2",

8102

test_open_and_parse_question_notafter_1_2);

8103

test_add_st("/task/open_and_parse_question/equal-notafter",

8104

test_open_and_parse_question_equal_notafter);

8105

test_add_st("/task/open_and_parse_question/late-notafter",

8106

test_open_and_parse_question_late_notafter);

8107

test_add_st("/task/cancel_old_question/0-1-2",

8108

test_cancel_old_question_0_1_2);

8109

test_add_st("/task/cancel_old_question/0-2-1",

8110

test_cancel_old_question_0_2_1);

8111

test_add_st("/task/cancel_old_question/1-2-3",

8112

test_cancel_old_question_1_2_3);

8113

test_add_st("/task/cancel_old_question/1-3-2",

8114

test_cancel_old_question_1_3_2);

8115

test_add_st("/task/cancel_old_question/2-1-3",

8116

test_cancel_old_question_2_1_3);

8117

test_add_st("/task/cancel_old_question/2-3-1",

8118

test_cancel_old_question_2_3_1);

8119

test_add_st("/task/cancel_old_question/3-1-2",

8120

test_cancel_old_question_3_1_2);

8121

test_add_st("/task/cancel_old_question/3-2-1",

8122

test_cancel_old_question_3_2_1);

8123

test_add_st("/task/connect_question_socket/name-too-long",

8124

test_connect_question_socket_name_too_long);

8125

test_add_st("/task/connect_question_socket/connect-fail",

8126

test_connect_question_socket_connect_fail);

8127

test_add_st("/task/connect_question_socket/bad-epoll",

8128

test_connect_question_socket_bad_epoll);

8129

test_add_st("/task/connect_question_socket/usable",

8130

test_connect_question_socket_usable);

8131

test_add_st("/task/send_password_to_socket/client-not-exited",

8132

test_send_password_to_socket_client_not_exited);

8133

test_add_st("/task/send_password_to_socket/password-not-read",

8134

test_send_password_to_socket_password_not_read);

8135

test_add_st("/task/send_password_to_socket/EMSGSIZE",

8136

test_send_password_to_socket_EMSGSIZE);

8137

test_add_st("/task/send_password_to_socket/retry",

8138

test_send_password_to_socket_retry);

8139

test_add_st("/task/send_password_to_socket/bad-epoll",

8140

test_send_password_to_socket_bad_epoll);

8141

test_add_st("/task/send_password_to_socket/null-password",

8142

test_send_password_to_socket_null_password);

8143

test_add_st("/task/send_password_to_socket/empty-password",

8144

test_send_password_to_socket_empty_password);

8145

test_add_st("/task/send_password_to_socket/empty-str-password",

8146

test_send_password_to_socket_empty_str_pass);

8147

test_add_st("/task/send_password_to_socket/text-password",

8148

test_send_password_to_socket_text_password);

8149

test_add_st("/task/send_password_to_socket/binary-password",

8150

test_send_password_to_socket_binary_password);

8151

test_add_st("/task/send_password_to_socket/nuls-in-password",

8152

test_send_password_to_socket_nuls_in_password);

8153

test_add_st("/task-creators/add_existing_questions/ENOENT",

8154

test_add_existing_questions_ENOENT);

8155

test_add_st("/task-creators/add_existing_questions/no-questions",

8156

test_add_existing_questions_no_questions);

8157

test_add_st("/task-creators/add_existing_questions/one-question",

8158

test_add_existing_questions_one_question);

8159

test_add_st("/task-creators/add_existing_questions/two-questions",

8160

test_add_existing_questions_two_questions);

8161

test_add_st("/task-creators/add_existing_questions/non-questions",

8162

test_add_existing_questions_non_questions);

8163

test_add_st("/task-creators/add_existing_questions/both-types",

8164

test_add_existing_questions_both_types);

8165

8166

return g_test_run() == 0;

8167

}

8168

8169

static bool should_only_run_tests(int *argc_p, char **argv_p[]){

8170

GOptionContext *context = g_option_context_new("");

8171

8172

g_option_context_set_help_enabled(context, FALSE);

8173

g_option_context_set_ignore_unknown_options(context, TRUE);

8174

8175

gboolean should_run_tests = FALSE;

8176

GOptionEntry entries[] = {

8177

{ "test", 0, 0, G_OPTION_ARG_NONE,

8178

&should_run_tests, "Run tests", NULL },

8179

{ NULL }

8180

};

8181

g_option_context_add_main_entries(context, entries, NULL);

8182

8183

GError *error = NULL;

8184

8185

if(g_option_context_parse(context, argc_p, argv_p, &error) != TRUE){

8186

g_option_context_free(context);

8187

g_error("Failed to parse options: %s", error->message);

8188

}

8189

8190

g_option_context_free(context);

8191

return should_run_tests != FALSE;

8192

}