/mandos/release : revision 237.7.453

1

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

2

/*

3

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

4

*

5

6

7

*

8

* This file is part of Mandos.

9

*

10

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

11

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

12

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

13

* (at your option) any later version.

14

*

15

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

16

* WITHOUT ANY WARRANTY; without even the implied warranty of

17

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

18

* General Public License for more details.

19

*

20

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

21

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

22

*

23

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

24

*/

25

26

#define _GNU_SOURCE

27

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

28

intmax_t, uint32_t, SCNx32,

29

SCNuMAX, SCNxMAX */

30

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

31

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

32

getpid() */

33

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

34

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

35

sigemptyset(), sigaddset(),

36

SIGCHLD, pthread_sigmask(),

37

SIG_BLOCK, SIG_SETMASK, SA_RESTART,

38

SA_NOCLDSTOP, sigfillset(), kill(),

39

SIGTERM, sigdelset(), SIGKILL,

40

NSIG, sigismember(), SA_ONSTACK,

41

SIG_DFL, SIG_IGN, SIGINT, SIGQUIT,

42

SIGHUP, SIGSTOP, SIG_UNBLOCK */

43

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

44

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

45

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

46

mkdtemp(), mkostemp() */

47

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

48

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

49

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

50

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

51

ENAMETOOLONG, ENOENT, EEXIST,

52

ECHILD, EPERM, ENOMEM, EAGAIN,

53

EINTR, ENOBUFS, EADDRINUSE,

54

ECONNREFUSED, ECONNRESET,

55

ETOOMANYREFS, EMSGSIZE, EBADF,

56

EINVAL */

57

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

58

explicit_bzero(), memset(),

59

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

60

memcmp(), basename() */

61

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

62

argz_extract(), argz_next(),

63

argz_add() */

64

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

65

epoll_ctl(), EPOLL_CTL_ADD,

66

struct epoll_event, EPOLLIN,

67

EPOLLRDHUP, EPOLLOUT,

68

epoll_pwait() */

69

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

70

CLOCK_MONOTONIC */

71

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

72

OPTION_ALIAS, struct argp_state,

73

ARGP_ERR_UNKNOWN, ARGP_KEY_ARGS,

74

struct argp, argp_parse(),

75

ARGP_NO_EXIT */

76

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

77

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

78

STDOUT_FILENO, setresgid(),

79

setresuid(), execv(), ssize_t,

80

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

81

STDERR_FILENO, pause(), write(),

82

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

83

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

84

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

85

F_GETFD, F_GETFL, FD_CLOEXEC,

86

open(), O_WRONLY, O_RDONLY */

87

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

88

WEXITSTATUS() */

89

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

90

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

91

IN_CLOEXEC, inotify_add_watch(),

92

IN_CLOSE_WRITE, IN_MOVED_TO,

93

IN_DELETE, struct inotify_event */

94

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

95

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

96

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

97

ferror(), fclose(), stderr,

98

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

99

fscanf() */

100

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

101

GError, g_key_file_load_from_file(),

102

G_KEY_FILE_NONE, TRUE, G_FILE_ERROR_NOENT,

103

g_key_file_get_string(), guint64,

104

g_key_file_get_uint64(),

105

G_KEY_FILE_ERROR_KEY_NOT_FOUND, gconstpointer,

106

g_assert_true(), g_assert_nonnull(),

107

g_assert_null(), g_assert_false(),

108

g_assert_cmpint(), g_assert_cmpuint(),

109

g_test_skip(), g_assert_cmpstr(),

110

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

111

GOptionContext, g_option_context_new(),

112

g_option_context_set_help_enabled(), FALSE,

113

g_option_context_set_ignore_unknown_options(),

114

gboolean, GOptionEntry, G_OPTION_ARG_NONE,

115

g_option_context_add_main_entries(),

116

g_option_context_parse(),

117

g_option_context_free(), g_error() */

118

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

119

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

120

SOCK_DGRAM, SOCK_NONBLOCK,

121

SOCK_CLOEXEC, connect(),

122

struct sockaddr, socklen_t,

123

shutdown(), SHUT_RD, send(),

124

MSG_NOSIGNAL, bind(), recv(),

125

socketpair() */

126

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

127

GLOB_ERR, GLOB_NOSORT, GLOB_MARK,

128

GLOB_ABORTED, GLOB_NOMATCH,

129

GLOB_NOSPACE */

130

131

/* End of includes */

132

133

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

134

135

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

136

typedef uintmax_t mono_microsecs;

137

138

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

139

typedef struct {

140

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

141

size_t length; /* Number of tasks */

142

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

143

size_t allocated;

144

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

145

mono_microsecs next_run;

146

} __attribute__((designated_init)) task_queue;

147

148

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

149

150

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

151

this type */

152

typedef void (task_func) (const struct task_struct,

153

task_queue *const)

154

__attribute__((nonnull));

155

156

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

157

158

Used for the "password" variable */

159

typedef struct {

160

char *data;

161

size_t length;

162

size_t allocated;

163

} __attribute__((designated_init)) buffer;

164

165

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

166

167

Used by the "cancelled_filenames" variable */

168

typedef struct {

169

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

170

size_t argz_len; /* the string_set_* functions */

171

} __attribute__((designated_init)) string_set;

172

173

/* "task_context" - local variables for tasks

174

175

This data structure distinguishes between different tasks which are

176

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

177

task function when each task is run.

178

179

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

180

typedef struct task_struct {

181

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

182

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

183

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

184

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

185

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

186

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

187

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

188

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

189

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

190

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

191

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

192

been cancelled for any reason; tasks pertaining to these question

193

files should not be run */

194

string_set *const cancelled_filenames;

195

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

196

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

197

const mono_microsecs *const current_time;

198

} __attribute__((designated_init)) task_context;

199

200

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

201

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

202

declared in the test section. */

203

__attribute__((warn_unused_result))

204

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

205

__attribute__((warn_unused_result, cold))

206

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

207

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

208

__attribute__((warn_unused_result, malloc))

209

task_queue *create_queue(void);

210

__attribute__((nonnull, warn_unused_result))

211

bool add_to_queue(task_queue *const, const task_context);

212

__attribute__((nonnull))

213

void cleanup_task(const task_context *const);

214

__attribute__((nonnull))

215

void cleanup_queue(task_queue *const *const);

216

__attribute__((pure, nonnull, warn_unused_result))

217

bool queue_has_question(const task_queue *const);

218

__attribute__((nonnull))

219

void cleanup_close(const int *const);

220

__attribute__((nonnull))

221

void cleanup_string(char *const *const);

222

__attribute__((nonnull))

223

void cleanup_buffer(buffer *const);

224

__attribute__((pure, nonnull, warn_unused_result))

225

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

226

__attribute__((nonnull, warn_unused_result))

227

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

228

__attribute__((nonnull))

229

void string_set_clear(string_set *);

230

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

231

__attribute__((nonnull, warn_unused_result))

232

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

233

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

234

const struct sigaction *const,

235

const sigset_t, const char *const,

236

const uid_t, const gid_t,

237

const char *const *const);

238

__attribute__((nonnull))

239

task_func wait_for_mandos_client_exit;

240

__attribute__((nonnull))

241

task_func read_mandos_client_output;

242

__attribute__((warn_unused_result))

243

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

244

buffer *const, const char *const,

245

string_set *, const mono_microsecs *const,

246

bool *const, bool *const);

247

__attribute__((nonnull))

248

task_func read_inotify_event;

249

__attribute__((nonnull))

250

task_func open_and_parse_question;

251

__attribute__((nonnull))

252

task_func cancel_old_question;

253

__attribute__((nonnull))

254

task_func connect_question_socket;

255

__attribute__((nonnull))

256

task_func send_password_to_socket;

257

__attribute__((warn_unused_result))

258

bool add_existing_questions(task_queue *const, const int,

259

buffer *const, string_set *,

260

const mono_microsecs *const,

261

bool *const, bool *const,

262

const char *const);

263

__attribute__((nonnull, warn_unused_result))

264

bool wait_for_event(const int, const mono_microsecs,

265

const mono_microsecs);

266

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

267

bool clear_all_fds_from_epoll_set(const int);

268

mono_microsecs get_current_time(void);

269

__attribute__((nonnull, warn_unused_result))

270

bool setup_signal_handler(struct sigaction *const);

271

__attribute__((nonnull))

272

bool restore_signal_handler(const struct sigaction *const);

273

__attribute__((nonnull, warn_unused_result))

274

bool block_sigchld(sigset_t *const);

275

__attribute__((nonnull))

276

bool restore_sigmask(const sigset_t *const);

277

__attribute__((nonnull))

278

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

279

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

280

281

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

282

283

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

284

285

Code here should be as simple as possible. */

286

287

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

288

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

289

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

290

291

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

292

293

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

294

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

295

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

296

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

297

if(run_tests(argc, argv)){

298

return EXIT_SUCCESS; /* All tests successful */

299

}

300

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

301

}

302

303

__attribute__((cleanup(cleanup_string)))

304

char *agent_directory = NULL;

305

306

__attribute__((cleanup(cleanup_string)))

307

char *helper_directory = NULL;

308

309

uid_t user = 0;

310

gid_t group = 0;

311

312

__attribute__((cleanup(cleanup_string)))

313

char *mandos_argz = NULL;

314

size_t mandos_argz_length = 0;

315

316

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

317

&helper_directory, &user, &group,

318

&mandos_argz, &mandos_argz_length)){

319

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

320

argument to parse_arguments() above, which should make

321

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

322

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

323

}

324

325

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

326

const char default_helper_directory[]

327

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

328

const char *const default_argv[]

329

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

330

331

/* Set variables to default values if unset */

332

if(agent_directory == NULL){

333

agent_directory = strdup(default_agent_directory);

334

if(agent_directory == NULL){

335

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

336

}

337

}

338

if(helper_directory == NULL){

339

helper_directory = strdup(default_helper_directory);

340

if(helper_directory == NULL){

341

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

342

}

343

}

344

if(user == 0){

345

user = 65534; /* nobody */

346

}

347

if(group == 0){

348

group = 65534; /* nogroup */

349

}

350

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

351

default values */

352

if(mandos_argz == NULL){

353

#ifdef __GNUC__

354

#pragma GCC diagnostic push

355

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

356

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

357

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

358

#pragma GCC diagnostic ignored "-Wcast-qual"

359

#endif

360

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

361

&mandos_argz_length);

362

#ifdef __GNUC__

363

#pragma GCC diagnostic pop

364

#endif

365

if(errno != 0){

366

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

367

}

368

}

369

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

370

371

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

372

mandos_argz_length)

373

+ 1) * sizeof(char *));

374

if(mandos_argv == NULL){

375

error_t saved_errno = errno;

376

free(mandos_argz);

377

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

378

}

379

argz_extract(mandos_argz, mandos_argz_length, mandos_argv);

380

381

sigset_t orig_sigmask;

382

if(not block_sigchld(&orig_sigmask)){

383

return EX_OSERR;

384

}

385

386

struct sigaction old_sigchld_action;

387

if(not setup_signal_handler(&old_sigchld_action)){

388

return EX_OSERR;

389

}

390

391

mono_microsecs current_time = 0;

392

393

bool mandos_client_exited = false;

394

bool quit_now = false;

395

__attribute__((cleanup(cleanup_close)))

396

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

397

if(epoll_fd < 0){

398

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

399

}

400

__attribute__((cleanup(cleanup_queue)))

401

task_queue *queue = create_queue();

402

if(queue == NULL){

403

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

404

}

405

406

__attribute__((cleanup(cleanup_buffer)))

407

buffer password = {};

408

bool password_is_read = false;

409

410

__attribute__((cleanup(string_set_clear)))

411

string_set cancelled_filenames = {};

412

413

/* Add tasks to queue */

414

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

415

&quit_now, &password, &password_is_read,

416

&old_sigchld_action, orig_sigmask,

417

helper_directory, user, group,

418

(const char *const *)mandos_argv)){

419

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

420

}

421

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

422

needed anymore */

423

free(mandos_argv);

424

free(mandos_argz);

425

mandos_argz = NULL;

426

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

427

agent_directory, &cancelled_filenames,

428

&current_time, &mandos_client_exited,

429

&password_is_read)){

430

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

431

case EACCES:

432

case ENAMETOOLONG:

433

case ENOENT:

434

return EX_OSFILE;

435

default:

436

return EX_OSERR;

437

}

438

}

439

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

440

&cancelled_filenames, &current_time,

441

&mandos_client_exited,

442

&password_is_read, agent_directory)){

443

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

444

}

445

446

/* Run queue */

447

do {

448

current_time = get_current_time();

449

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

450

const error_t saved_errno = errno;

451

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

452

" events");

453

}

454

455

current_time = get_current_time();

456

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

457

const error_t saved_errno = errno;

458

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

459

}

460

461

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

462

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

463

} while(queue_has_question(queue));

464

465

restore_signal_handler(&old_sigchld_action);

466

restore_sigmask(&orig_sigmask);

467

468

return EXIT_SUCCESS;

469

}

470

471

__attribute__((warn_unused_result))

472

mono_microsecs get_current_time(void){

473

struct timespec currtime;

474

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

475

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

476

return 0;

477

}

478

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

479

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

480

}

481

482

/* End of "main" section */

483

484

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

485

486

__attribute__((nonnull))

487

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

488

char **agent_directory, char **helper_directory,

489

uid_t *const user, gid_t *const group,

490

char **mandos_argz, size_t *mandos_argz_length){

491

492

const struct argp_option options[] = {

493

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

494

.doc="Systemd password agent directory" },

495

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

496

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

497

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

498

.flags=OPTION_HIDDEN | OPTION_ALIAS },

499

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

500

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

501

" user" },

502

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

503

.flags=OPTION_HIDDEN | OPTION_ALIAS },

504

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

505

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

506

" group" },

507

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

508

.flags=OPTION_HIDDEN | OPTION_ALIAS },

509

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

510

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

511

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

512

{ NULL },

513

};

514

515

__attribute__((nonnull(3)))

516

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

517

errno = 0;

518

switch(key){

519

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

520

*agent_directory = strdup(arg);

521

break;

522

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

523

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

524

*helper_directory = strdup(arg);

525

break;

526

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

527

case 130: /* --userid */

528

{

529

char *tmp;

530

uintmax_t tmp_id = 0;

531

errno = 0;

532

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

533

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

534

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

535

return ARGP_ERR_UNKNOWN;

536

}

537

*user = (uid_t)tmp_id;

538

errno = 0;

539

break;

540

}

541

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

542

case 131: /* --groupid */

543

{

544

char *tmp;

545

uintmax_t tmp_id = 0;

546

errno = 0;

547

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

548

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

549

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

550

return ARGP_ERR_UNKNOWN;

551

}

552

*group = (gid_t)tmp_id;

553

errno = 0;

554

break;

555

}

556

case ARGP_KEY_ARGS:

557

/* Copy arguments into argz vector */

558

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

559

mandos_argz_length);

560

default:

561

return ARGP_ERR_UNKNOWN;

562

}

563

return errno;

564

}

565

566

const struct argp argp = {

567

.options=options,

568

.parser=parse_opt,

569

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

570

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

571

" systemd password agent",

572

};

573

574

errno = argp_parse(&argp, argc, argv,

575

exit_failure ? 0 : ARGP_NO_EXIT, NULL, NULL);

576

577

return errno == 0;

578

}

579

580

__attribute__((nonnull, warn_unused_result))

581

bool block_sigchld(sigset_t *const orig_sigmask){

582

sigset_t sigchld_sigmask;

583

if(sigemptyset(&sigchld_sigmask) < 0){

584

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

585

return false;

586

}

587

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

588

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

589

return false;

590

}

591

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

592

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

593

return false;

594

}

595

return true;

596

}

597

598

__attribute__((nonnull, warn_unused_result, const))

599

bool restore_sigmask(const sigset_t *const orig_sigmask){

600

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

601

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

602

return false;

603

}

604

return true;

605

}

606

607

__attribute__((nonnull, warn_unused_result))

608

bool setup_signal_handler(struct sigaction *const old_sigchld_action){

609

struct sigaction sigchld_action = {

610

.sa_handler=handle_sigchld,

611

.sa_flags=SA_RESTART | SA_NOCLDSTOP,

612

};

613

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

614

signals automatically blocked during signal handler */

615

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

616

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

617

return false;

618

}

619

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

620

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

621

return false;

622

}

623

return true;

624

}

625

626

__attribute__((nonnull, warn_unused_result))

627

bool restore_signal_handler(const struct sigaction *const

628

old_sigchld_action){

629

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

630

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

631

return false;

632

}

633

return true;

634

}

635

636

__attribute__((warn_unused_result, malloc))

637

task_queue *create_queue(void){

638

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

639

if(queue){

640

queue->tasks = NULL;

641

queue->length = 0;

642

queue->allocated = 0;

643

queue->next_run = 0;

644

}

645

return queue;

646

}

647

648

__attribute__((nonnull, warn_unused_result))

649

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

650

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

651

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

652

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

653

needed_size);

654

if(new_tasks == NULL){

655

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

656

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

657

return false;

658

}

659

queue->tasks = new_tasks;

660

queue->allocated = needed_size;

661

}

662

/* Using memcpy here is necessary because doing */

663

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

664

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

665

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

666

sizeof(task_context));

667

return true;

668

}

669

670

__attribute__((nonnull))

671

void cleanup_task(const task_context *const task){

672

const error_t saved_errno = errno;

673

/* free and close all task data */

674

free(task->question_filename);

675

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

676

free(task->filename);

677

}

678

if(task->pid > 0){

679

kill(task->pid, SIGTERM);

680

}

681

if(task->fd > 0){

682

close(task->fd);

683

}

684

errno = saved_errno;

685

}

686

687

__attribute__((nonnull))

688

void free_queue(task_queue *const queue){

689

free(queue->tasks);

690

free(queue);

691

}

692

693

__attribute__((nonnull))

694

void cleanup_queue(task_queue *const *const queue){

695

if(*queue == NULL){

696

return;

697

}

698

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

699

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

700

cleanup_task(task);

701

}

702

free_queue(*queue);

703

}

704

705

__attribute__((pure, nonnull, warn_unused_result))

706

bool queue_has_question(const task_queue *const queue){

707

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

708

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

709

return true;

710

}

711

}

712

return false;

713

}

714

715

__attribute__((nonnull))

716

void cleanup_close(const int *const fd){

717

const error_t saved_errno = errno;

718

close(*fd);

719

errno = saved_errno;

720

}

721

722

__attribute__((nonnull))

723

void cleanup_string(char *const *const ptr){

724

free(*ptr);

725

}

726

727

__attribute__((nonnull))

728

void cleanup_buffer(buffer *buf){

729

if(buf->allocated > 0){

730

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

731

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

732

#else

733

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

734

#endif

735

}

736

if(buf->data != NULL){

737

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

738

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

739

}

740

free(buf->data);

741

buf->data = NULL;

742

}

743

buf->length = 0;

744

buf->allocated = 0;

745

}

746

747

__attribute__((pure, nonnull, warn_unused_result))

748

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

749

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

750

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

751

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

752

return true;

753

}

754

}

755

return false;

756

}

757

758

__attribute__((nonnull, warn_unused_result))

759

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

760

if(string_set_contains(*set, str)){

761

return true;

762

}

763

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

764

if(error == 0){

765

return true;

766

}

767

errno = error;

768

return false;

769

}

770

771

__attribute__((nonnull))

772

void string_set_clear(string_set *set){

773

free(set->argz);

774

set->argz = NULL;

775

set->argz_len = 0;

776

}

777

778

__attribute__((nonnull))

779

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

780

/* Swap contents of two string sets */

781

{

782

char *const tmp_argz = set1->argz;

783

set1->argz = set2->argz;

784

set2->argz = tmp_argz;

785

}

786

{

787

const size_t tmp_argz_len = set1->argz_len;

788

set1->argz_len = set2->argz_len;

789

set2->argz_len = tmp_argz_len;

790

}

791

}

792

793

__attribute__((nonnull, warn_unused_result))

794

bool start_mandos_client(task_queue *const queue,

795

const int epoll_fd,

796

bool *const mandos_client_exited,

797

bool *const quit_now, buffer *const password,

798

bool *const password_is_read,

799

const struct sigaction *const

800

old_sigchld_action, const sigset_t sigmask,

801

const char *const helper_directory,

802

const uid_t user, const gid_t group,

803

const char *const *const argv){

804

int pipefds[2];

805

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

806

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

807

return false;

808

}

809

810

const pid_t pid = fork();

811

if(pid == 0){

812

if(not restore_signal_handler(old_sigchld_action)){

813

_exit(EXIT_FAILURE);

814

}

815

if(not restore_sigmask(&sigmask)){

816

_exit(EXIT_FAILURE);

817

}

818

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

819

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

820

_exit(EXIT_FAILURE);

821

}

822

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

823

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

824

_exit(EXIT_FAILURE);

825

}

826

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

827

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

828

_exit(EXIT_FAILURE);

829

}

830

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

831

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

832

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

833

_exit(EXIT_FAILURE);

834

}

835

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

836

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

837

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

838

_exit(EXIT_FAILURE);

839

}

840

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

841

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

842

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

843

_exit(EXIT_FAILURE);

844

}

845

#ifdef __GNUC__

846

#pragma GCC diagnostic push

847

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

848

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

849

#pragma GCC diagnostic ignored "-Wcast-qual"

850

#endif

851

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

852

#ifdef __GNUC__

853

#pragma GCC diagnostic pop

854

#endif

855

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

856

_exit(EXIT_FAILURE);

857

}

858

close(pipefds[1]);

859

860

if(not add_to_queue(queue, (task_context){

861

.func=wait_for_mandos_client_exit,

862

.pid=pid,

863

.mandos_client_exited=mandos_client_exited,

864

.quit_now=quit_now,

865

})){

866

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

867

close(pipefds[0]);

868

return false;

869

}

870

871

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

872

&(struct epoll_event)

873

{ .events=EPOLLIN | EPOLLRDHUP });

874

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

875

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

876

close(pipefds[0]);

877

return false;

878

}

879

880

return add_to_queue(queue, (task_context){

881

.func=read_mandos_client_output,

882

.epoll_fd=epoll_fd,

883

.fd=pipefds[0],

884

.quit_now=quit_now,

885

.password=password,

886

.password_is_read=password_is_read,

887

});

888

}

889

890

__attribute__((nonnull))

891

void wait_for_mandos_client_exit(const task_context task,

892

task_queue *const queue){

893

const pid_t pid = task.pid;

894

bool *const mandos_client_exited = task.mandos_client_exited;

895

bool *const quit_now = task.quit_now;

896

897

int status;

898

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

899

case 0: /* Not exited yet */

900

if(not add_to_queue(queue, task)){

901

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

902

*quit_now = true;

903

}

904

break;

905

case -1: /* Error */

906

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

907

if(errno != ECHILD){

908

kill(pid, SIGTERM);

909

}

910

*quit_now = true;

911

break;

912

default: /* Has exited */

913

*mandos_client_exited = true;

914

if((not WIFEXITED(status))

915

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

916

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

917

*quit_now = true;

918

}

919

}

920

}

921

922

__attribute__((nonnull))

923

void read_mandos_client_output(const task_context task,

924

task_queue *const queue){

925

buffer *const password = task.password;

926

bool *const quit_now = task.quit_now;

927

bool *const password_is_read = task.password_is_read;

928

const int fd = task.fd;

929

const int epoll_fd = task.epoll_fd;

930

931

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

932

if(password->allocated < new_potential_size){

933

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

934

if(new_buffer == NULL){

935

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

936

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

937

*quit_now = true;

938

close(fd);

939

return;

940

}

941

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

942

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

943

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

944

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

945

}

946

}

947

if(password->length > 0){

948

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

949

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

950

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

951

#else

952

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

953

#endif

954

}

955

if(password->data != NULL){

956

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

957

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

958

}

959

free(password->data);

960

}

961

password->data = new_buffer;

962

password->allocated = new_potential_size;

963

}

964

965

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

966

+ password->length, PIPE_BUF);

967

968

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

969

*password_is_read = true;

970

close(fd);

971

return;

972

}

973

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

974

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

975

*quit_now = true;

976

close(fd);

977

return;

978

}

979

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

980

password->length += (size_t)read_length;

981

}

982

983

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

984

available yet */

985

986

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

987

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

988

&(struct epoll_event)

989

{ .events=EPOLLIN | EPOLLRDHUP });

990

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

991

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

992

*quit_now = true;

993

close(fd);

994

return;

995

}

996

997

/* Re-add myself to the queue */

998

if(not add_to_queue(queue, task)){

999

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

1000

*quit_now = true;

1001

close(fd);

1002

}

1003

}

1004

1005

__attribute__((nonnull, warn_unused_result))

1006

bool add_inotify_dir_watch(task_queue *const queue,

1007

const int epoll_fd, bool *const quit_now,

1008

buffer *const password,

1009

const char *const dir,

1010

string_set *cancelled_filenames,

1011

const mono_microsecs *const current_time,

1012

bool *const mandos_client_exited,

1013

bool *const password_is_read){

1014

const int fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);

1015

if(fd == -1){

1016

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

1017

return false;

1018

}

1019

1020

if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE

1021

| IN_MOVED_TO | IN_DELETE)

1022

== -1){

1023

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

1024

return false;

1025

}

1026

1027

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

1028

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

1029

&(struct epoll_event)

1030

{ .events=EPOLLIN | EPOLLRDHUP });

1031

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

1032

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

1033

close(fd);

1034

return false;

1035

}

1036

1037

const task_context read_inotify_event_task = {

1038

.func=read_inotify_event,

1039

.epoll_fd=epoll_fd,

1040

.quit_now=quit_now,

1041

.password=password,

1042

.fd=fd,

1043

.filename=strdup(dir),

1044

.cancelled_filenames=cancelled_filenames,

1045

.current_time=current_time,

1046

.mandos_client_exited=mandos_client_exited,

1047

.password_is_read=password_is_read,

1048

};

1049

if(read_inotify_event_task.filename == NULL){

1050

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

1051

close(fd);

1052

return false;

1053

}

1054

1055

return add_to_queue(queue, read_inotify_event_task);

1056

}

1057

1058

__attribute__((nonnull))

1059

void read_inotify_event(const task_context task,

1060

task_queue *const queue){

1061

const int fd = task.fd;

1062

const int epoll_fd = task.epoll_fd;

1063

char *const filename = task.filename;

1064

bool *quit_now = task.quit_now;

1065

buffer *const password = task.password;

1066

string_set *const cancelled_filenames = task.cancelled_filenames;

1067

const mono_microsecs *const current_time = task.current_time;

1068

bool *const mandos_client_exited = task.mandos_client_exited;

1069

bool *const password_is_read = task.password_is_read;

1070

1071

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

1072

const size_t ievent_size = (sizeof(struct inotify_event)

1073

+ NAME_MAX + 1);

1074

char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];

1075

struct inotify_event *ievent = ((struct inotify_event *)

1076

ievent_buffer);

1077

1078

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

1079

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

1080

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

1081

*quit_now = true;

1082

cleanup_task(&task);

1083

return;

1084

}

1085

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

1086

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

1087

filename);

1088

*quit_now = true;

1089

cleanup_task(&task);

1090

return;

1091

}

1092

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

1093

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

1094

char *question_filename = NULL;

1095

const ssize_t question_filename_length

1096

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

1097

if(question_filename_length < 0){

1098

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

1099

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

1100

} else {

1101

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

1102

if(not add_to_queue(queue, (task_context){

1103

.func=open_and_parse_question,

1104

.epoll_fd=epoll_fd,

1105

.question_filename=question_filename,

1106

.filename=question_filename,

1107

.password=password,

1108

.cancelled_filenames=cancelled_filenames,

1109

.current_time=current_time,

1110

.mandos_client_exited=mandos_client_exited,

1111

.password_is_read=password_is_read,

1112

})){

1113

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

1114

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

1115

} else {

1116

/* Force the added task (open_and_parse_question) to run

1117

immediately */

1118

queue->next_run = 1;

1119

}

1120

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

1121

if(not string_set_add(cancelled_filenames,

1122

question_filename)){

1123

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

1124

" cancelled_questions", question_filename);

1125

*quit_now = true;

1126

free(question_filename);

1127

cleanup_task(&task);

1128

return;

1129

}

1130

free(question_filename);

1131

}

1132

}

1133

}

1134

1135

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

1136

available yet */

1137

1138

/* Re-add myself to the queue */

1139

if(not add_to_queue(queue, task)){

1140

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

1141

" queue", filename);

1142

*quit_now = true;

1143

cleanup_task(&task);

1144

return;

1145

}

1146

1147

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

1148

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

1149

&(struct epoll_event)

1150

{ .events=EPOLLIN | EPOLLRDHUP });

1151

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

1152

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

1153

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

1154

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

1155

one second from now */

1156

if((queue->next_run == 0)

1157

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

1158

queue->next_run = *current_time + 1000000;

1159

}

1160

}

1161

}

1162

1163

__attribute__((nonnull))

1164

void open_and_parse_question(const task_context task,

1165

task_queue *const queue){

1166

__attribute__((cleanup(cleanup_string)))

1167

char *question_filename = task.question_filename;

1168

const int epoll_fd = task.epoll_fd;

1169

buffer *const password = task.password;

1170

string_set *const cancelled_filenames = task.cancelled_filenames;

1171

const mono_microsecs *const current_time = task.current_time;

1172

bool *const mandos_client_exited = task.mandos_client_exited;

1173

bool *const password_is_read = task.password_is_read;

1174

1175

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

1176

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

1177

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

1178

__attribute__((nonnull))

1179

void cleanup_g_key_file(GKeyFile **key_file){

1180

if(*key_file != NULL){

1181

g_key_file_free(*key_file);

1182

}

1183

}

1184

1185

__attribute__((cleanup(cleanup_g_key_file)))

1186

GKeyFile *key_file = g_key_file_new();

1187

if(key_file == NULL){

1188

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

1189

question_filename);

1190

return;

1191

}

1192

GError *glib_error = NULL;

1193

if(g_key_file_load_from_file(key_file, question_filename,

1194

G_KEY_FILE_NONE, &glib_error) != TRUE){

1195

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

1196

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

1197

if(glib_error->code != G_FILE_ERROR_NOENT){

1198

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

1199

question_filename, glib_error->message);

1200

}

1201

return;

1202

}

1203

1204

__attribute__((cleanup(cleanup_string)))

1205

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

1206

"Socket",

1207

&glib_error);

1208

if(socket_name == NULL){

1209

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

1210

question_filename, glib_error->message);

1211

return;

1212

}

1213

1214

if(strlen(socket_name) == 0){

1215

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

1216

question_filename);

1217

return;

1218

}

1219

1220

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

1221

&glib_error);

1222

if(glib_error != NULL){

1223

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

1224

question_filename, glib_error->message);

1225

return;

1226

}

1227

1228

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

1229

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

1230

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

1231

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

1232

return;

1233

}

1234

1235

guint64 notafter = g_key_file_get_uint64(key_file, "Ask",

1236

"NotAfter", &glib_error);

1237

if(glib_error != NULL){

1238

if(glib_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND){

1239

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

1240

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

1241

}

1242

notafter = 0;

1243

}

1244

if(notafter != 0){

1245

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

1246

queue->next_run = notafter;

1247

}

1248

if(*current_time >= notafter){

1249

return;

1250

}

1251

}

1252

1253

const task_context connect_question_socket_task = {

1254

.func=connect_question_socket,

1255

.question_filename=strdup(question_filename),

1256

.epoll_fd=epoll_fd,

1257

.password=password,

1258

.filename=strdup(socket_name),

1259

.cancelled_filenames=task.cancelled_filenames,

1260

.mandos_client_exited=mandos_client_exited,

1261

.password_is_read=password_is_read,

1262

.current_time=current_time,

1263

};

1264

if(connect_question_socket_task.question_filename == NULL

1265

or connect_question_socket_task.filename == NULL

1266

or not add_to_queue(queue, connect_question_socket_task)){

1267

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

1268

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

1269

question_filename);

1270

cleanup_task(&connect_question_socket_task);

1271

return;

1272

}

1273

/* Force the added task (connect_question_socket) to run

1274

immediately */

1275

queue->next_run = 1;

1276

1277

if(notafter > 0){

1278

char *const dup_filename = strdup(question_filename);

1279

const task_context cancel_old_question_task = {

1280

.func=cancel_old_question,

1281

.question_filename=dup_filename,

1282

.notafter=notafter,

1283

.filename=dup_filename,

1284

.cancelled_filenames=cancelled_filenames,

1285

.current_time=current_time,

1286

};

1287

if(cancel_old_question_task.question_filename == NULL

1288

or not add_to_queue(queue, cancel_old_question_task)){

1289

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

1290

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

1291

cleanup_task(&cancel_old_question_task);

1292

return;

1293

}

1294

}

1295

}

1296

1297

__attribute__((nonnull))

1298

void cancel_old_question(const task_context task,

1299

task_queue *const queue){

1300

char *const question_filename = task.question_filename;

1301

string_set *const cancelled_filenames = task.cancelled_filenames;

1302

const mono_microsecs notafter = task.notafter;

1303

const mono_microsecs *const current_time = task.current_time;

1304

1305

if(*current_time >= notafter){

1306

if(not string_set_add(cancelled_filenames, question_filename)){

1307

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

1308

question_filename);

1309

}

1310

cleanup_task(&task);

1311

return;

1312

}

1313

1314

if(not add_to_queue(queue, task)){

1315

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

1316

"%s to queue", question_filename);

1317

cleanup_task(&task);

1318

return;

1319

}

1320

1321

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

1322

queue->next_run = notafter;

1323

}

1324

}

1325

1326

__attribute__((nonnull))

1327

void connect_question_socket(const task_context task,

1328

task_queue *const queue){

1329

char *const question_filename = task.question_filename;

1330

char *const filename = task.filename;

1331

const int epoll_fd = task.epoll_fd;

1332

buffer *const password = task.password;

1333

string_set *const cancelled_filenames = task.cancelled_filenames;

1334

bool *const mandos_client_exited = task.mandos_client_exited;

1335

bool *const password_is_read = task.password_is_read;

1336

const mono_microsecs *const current_time = task.current_time;

1337

1338

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

1339

1340

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

1341

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

1342

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

1343

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

1344

if(not string_set_add(cancelled_filenames, question_filename)){

1345

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

1346

question_filename);

1347

}

1348

cleanup_task(&task);

1349

return;

1350

}

1351

1352

const int fd = socket(PF_LOCAL, SOCK_DGRAM

1353

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

1354

if(fd < 0){

1355

error(0, errno,

1356

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

1357

if(not add_to_queue(queue, task)){

1358

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

1359

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

1360

filename);

1361

cleanup_task(&task);

1362

} else {

1363

/* Force the added task (connect_question_socket) to run

1364

immediately */

1365

queue->next_run = 1;

1366

}

1367

return;

1368

}

1369

1370

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

1371

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

1372

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

1373

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

1374

if(not add_to_queue(queue, task)){

1375

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

1376

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

1377

filename);

1378

cleanup_task(&task);

1379

} else {

1380

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

1381

at most one second from now */

1382

if((queue->next_run == 0)

1383

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

1384

queue->next_run = *current_time + 1000000;

1385

}

1386

}

1387

return;

1388

}

1389

1390

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

1391

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

1392

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

1393

filename);

1394

}

1395

1396

/* Add the fd to the epoll set */

1397

if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

1398

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

1399

!= 0){

1400

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

1401

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

1402

if(not add_to_queue(queue, task)){

1403

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

1404

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

1405

filename);

1406

cleanup_task(&task);

1407

} else {

1408

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

1409

at most one second from now */

1410

if((queue->next_run == 0)

1411

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

1412

queue->next_run = *current_time + 1000000;

1413

}

1414

}

1415

return;

1416

}

1417

1418

/* add task send_password_to_socket to queue */

1419

const task_context send_password_to_socket_task = {

1420

.func=send_password_to_socket,

1421

.question_filename=question_filename,

1422

.filename=filename,

1423

.epoll_fd=epoll_fd,

1424

.fd=fd,

1425

.password=password,

1426

.cancelled_filenames=cancelled_filenames,

1427

.mandos_client_exited=mandos_client_exited,

1428

.password_is_read=password_is_read,

1429

.current_time=current_time,

1430

};

1431

1432

if(not add_to_queue(queue, send_password_to_socket_task)){

1433

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

1434

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

1435

question_filename, filename);

1436

cleanup_task(&send_password_to_socket_task);

1437

}

1438

}

1439

1440

__attribute__((nonnull))

1441

void send_password_to_socket(const task_context task,

1442

task_queue *const queue){

1443

char *const question_filename=task.question_filename;

1444

char *const filename=task.filename;

1445

const int epoll_fd=task.epoll_fd;

1446

const int fd=task.fd;

1447

buffer *const password=task.password;

1448

string_set *const cancelled_filenames=task.cancelled_filenames;

1449

bool *const mandos_client_exited = task.mandos_client_exited;

1450

bool *const password_is_read = task.password_is_read;

1451

const mono_microsecs *const current_time = task.current_time;

1452

1453

if(*mandos_client_exited and *password_is_read){

1454

1455

const size_t send_buffer_length = password->length + 2;

1456

char *send_buffer = malloc(send_buffer_length);

1457

if(send_buffer == NULL){

1458

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

1459

} else {

1460

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

1461

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

1462

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

1463

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

1464

" buffer");

1465

}

1466

}

1467

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

1468

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

1469

depending on whether the password entry was successful or

1470

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

1471

your message.

1472

1473

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

1474

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

1475

*/

1476

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

1477

/* Always add an extra NUL */

1478

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

1479

if(password->length > 0){

1480

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

1481

}

1482

errno = 0;

1483

ssize_t ssret = send(fd, send_buffer, send_buffer_length,

1484

MSG_NOSIGNAL);

1485

const error_t saved_errno = errno;

1486

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

1487

explicit_bzero(send_buffer, send_buffer_length);

1488

#else

1489

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

1490

#endif

1491

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

1492

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

1493

}

1494

free(send_buffer);

1495

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

1496

switch(saved_errno){

1497

case EINTR:

1498

case ENOBUFS:

1499

case ENOMEM:

1500

case EADDRINUSE:

1501

case ECONNREFUSED:

1502

case ECONNRESET:

1503

case ENOENT:

1504

case ETOOMANYREFS:

1505

case EAGAIN:

1506

/* Retry, below */

1507

break;

1508

case EMSGSIZE:

1509

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

1510

(uintmax_t)password->length);

1511

#if __GNUC__ < 7

1512

/* FALLTHROUGH */

1513

#else

1514

__attribute__((fallthrough));

1515

#endif

1516

case 0:

1517

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

1518

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

1519

}

1520

#if __GNUC__ < 7

1521

/* FALLTHROUGH */

1522

#else

1523

__attribute__((fallthrough));

1524

#endif

1525

default:

1526

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

1527

filename);

1528

if(not string_set_add(cancelled_filenames,

1529

question_filename)){

1530

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

1531

question_filename);

1532

}

1533

cleanup_task(&task);

1534

return;

1535

}

1536

} else {

1537

/* Success */

1538

cleanup_task(&task);

1539

return;

1540

}

1541

}

1542

}

1543

1544

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

1545

1546

if(not add_to_queue(queue, task)){

1547

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

1548

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

1549

filename);

1550

cleanup_task(&task);

1551

}

1552

1553

/* Add the fd to the epoll set */

1554

if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

1555

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

1556

!= 0){

1557

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

1558

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

1559

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

1560

most one second from now */

1561

if((queue->next_run == 0)

1562

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

1563

queue->next_run = *current_time + 1000000;

1564

}

1565

}

1566

}

1567

1568

__attribute__((warn_unused_result))

1569

bool add_existing_questions(task_queue *const queue,

1570

const int epoll_fd,

1571

buffer *const password,

1572

string_set *cancelled_filenames,

1573

const mono_microsecs *const current_time,

1574

bool *const mandos_client_exited,

1575

bool *const password_is_read,

1576

const char *const dirname){

1577

__attribute__((cleanup(cleanup_string)))

1578

char *dir_pattern = NULL;

1579

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

1580

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

1581

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

1582

dirname);

1583

return false;

1584

}

1585

__attribute__((cleanup(globfree)))

1586

glob_t question_filenames = {};

1587

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

1588

NULL, &question_filenames)){

1589

case GLOB_ABORTED:

1590

default:

1591

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

1592

return false;

1593

case GLOB_NOMATCH:

1594

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

1595

return false;

1596

case GLOB_NOSPACE:

1597

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

1598

" names in %s", dirname);

1599

#if __GNUC__ < 7

1600

/* FALLTHROUGH */

1601

#else

1602

__attribute__((fallthrough));

1603

#endif

1604

case 0:

1605

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

1606

char *const question_filename = strdup(question_filenames

1607

.gl_pathv[i]);

1608

const task_context task = {

1609

.func=open_and_parse_question,

1610

.epoll_fd=epoll_fd,

1611

.question_filename=question_filename,

1612

.filename=question_filename,

1613

.password=password,

1614

.cancelled_filenames=cancelled_filenames,

1615

.current_time=current_time,

1616

.mandos_client_exited=mandos_client_exited,

1617

.password_is_read=password_is_read,

1618

};

1619

1620

if(question_filename == NULL

1621

or not add_to_queue(queue, task)){

1622

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

1623

" file %s to queue",

1624

question_filenames.gl_pathv[i]);

1625

free(question_filename);

1626

} else {

1627

queue->next_run = 1;

1628

}

1629

}

1630

return true;

1631

}

1632

}

1633

1634

__attribute__((nonnull, warn_unused_result))

1635

bool wait_for_event(const int epoll_fd,

1636

const mono_microsecs queue_next_run,

1637

const mono_microsecs current_time){

1638

__attribute__((const))

1639

int milliseconds_to_wait(const mono_microsecs currtime,

1640

const mono_microsecs nextrun){

1641

if(currtime >= nextrun){

1642

return 0;

1643

}

1644

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

1645

if(wait_time_ms > (uintmax_t)INT_MAX){

1646

return INT_MAX;

1647

}

1648

return (int)wait_time_ms;

1649

}

1650

1651

const int wait_time_ms = milliseconds_to_wait(current_time,

1652

queue_next_run);

1653

1654

/* Prepare unblocking of SIGCHLD during epoll_pwait */

1655

sigset_t temporary_unblocked_sigmask;

1656

/* Get current signal mask */

1657

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

1658

return false;

1659

}

1660

/* Remove SIGCHLD from the signal mask */

1661

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

1662

return false;

1663

}

1664

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

1665

int ret = epoll_pwait(epoll_fd, events,

1666

sizeof(events) / sizeof(struct epoll_event),

1667

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

1668

&temporary_unblocked_sigmask);

1669

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

1670

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

1671

" ...", epoll_fd,

1672

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

1673

return false;

1674

}

1675

return clear_all_fds_from_epoll_set(epoll_fd);

1676

}

1677

1678

bool clear_all_fds_from_epoll_set(const int epoll_fd){

1679

/* Create a new empty epoll set */

1680

__attribute__((cleanup(cleanup_close)))

1681

const int new_epoll_fd = epoll_create1(EPOLL_CLOEXEC);

1682

if(new_epoll_fd < 0){

1683

return false;

1684

}

1685

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

1686

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

1687

return false;

1688

}

1689

return true;

1690

}

1691

1692

__attribute__((nonnull, warn_unused_result))

1693

bool run_queue(task_queue **const queue,

1694

string_set *const cancelled_filenames,

1695

bool *const quit_now){

1696

1697

task_queue *new_queue = create_queue();

1698

if(new_queue == NULL){

1699

return false;

1700

}

1701

1702

__attribute__((cleanup(string_set_clear)))

1703

string_set old_cancelled_filenames = {};

1704

string_set_swap(cancelled_filenames, &old_cancelled_filenames);

1705

1706

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

1707

loop in case we aborted in the middle */

1708

size_t i;

1709

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

1710

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

1711

const char *const question_filename = task->question_filename;

1712

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

1713

if(question_filename != NULL

1714

and string_set_contains(old_cancelled_filenames,

1715

question_filename)){

1716

cleanup_task(task);

1717

continue;

1718

}

1719

task->func(*task, new_queue);

1720

}

1721

1722

if(*quit_now){

1723

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

1724

remaining tasks in the current queue */

1725

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

1726

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

1727

}

1728

free_queue(*queue);

1729

*queue = new_queue;

1730

new_queue = NULL;

1731

return false;

1732

}

1733

free_queue(*queue);

1734

*queue = new_queue;

1735

new_queue = NULL;

1736

1737

return true;

1738

}

1739

1740

/* End of regular code section */

1741

1742

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

1743

1744

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

1745

teardown functions */

1746

typedef struct {

1747

struct sigaction orig_sigaction;

1748

sigset_t orig_sigmask;

1749

} test_fixture;

1750

1751

static void test_setup(test_fixture *fixture,

1752

__attribute__((unused))

1753

gconstpointer user_data){

1754

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

1755

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

1756

}

1757

1758

static void test_teardown(test_fixture *fixture,

1759

__attribute__((unused))

1760

gconstpointer user_data){

1761

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

1762

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

1763

}

1764

1765

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

1766

__attribute__((pure, nonnull, warn_unused_result))

1767

static task_context *find_matching_task(const task_queue *const queue,

1768

const task_context task){

1769

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

1770

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

1771

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

1772

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

1773

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

1774

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

1775

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

1776

1777

/* task_func *const func */

1778

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

1779

continue;

1780

}

1781

/* char *const question_filename; */

1782

if(task.question_filename != NULL

1783

and (current_task->question_filename == NULL

1784

or strcmp(current_task->question_filename,

1785

task.question_filename) != 0)){

1786

continue;

1787

}

1788

/* const pid_t pid; */

1789

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

1790

continue;

1791

}

1792

/* const int epoll_fd; */

1793

if(task.epoll_fd != 0

1794

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

1795

continue;

1796

}

1797

/* bool *const quit_now; */

1798

if(task.quit_now != NULL

1799

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

1800

continue;

1801

}

1802

/* const int fd; */

1803

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

1804

continue;

1805

}

1806

/* bool *const mandos_client_exited; */

1807

if(task.mandos_client_exited != NULL

1808

and current_task->mandos_client_exited

1809

!= task.mandos_client_exited){

1810

continue;

1811

}

1812

/* buffer *const password; */

1813

if(task.password != NULL

1814

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

1815

continue;

1816

}

1817

/* bool *const password_is_read; */

1818

if(task.password_is_read != NULL

1819

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

1820

continue;

1821

}

1822

/* char *filename; */

1823

if(task.filename != NULL

1824

and (current_task->filename == NULL

1825

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

1826

continue;

1827

}

1828

/* string_set *const cancelled_filenames; */

1829

if(task.cancelled_filenames != NULL

1830

and current_task->cancelled_filenames

1831

!= task.cancelled_filenames){

1832

continue;

1833

}

1834

/* const mono_microsecs notafter; */

1835

if(task.notafter != 0

1836

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

1837

continue;

1838

}

1839

/* const mono_microsecs *const current_time; */

1840

if(task.current_time != NULL

1841

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

1842

continue;

1843

}

1844

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

1845

return current_task;

1846

}

1847

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

1848

return NULL;

1849

}

1850

1851

static void test_create_queue(__attribute__((unused))

1852

test_fixture *fixture,

1853

__attribute__((unused))

1854

gconstpointer user_data){

1855

__attribute__((cleanup(cleanup_queue)))

1856

task_queue *const queue = create_queue();

1857

g_assert_nonnull(queue);

1858

g_assert_null(queue->tasks);

1859

g_assert_true(queue->length == 0);

1860

g_assert_true(queue->next_run == 0);

1861

}

1862

1863

static task_func dummy_func;

1864

1865

static void test_add_to_queue(__attribute__((unused))

1866

test_fixture *fixture,

1867

__attribute__((unused))

1868

gconstpointer user_data){

1869

__attribute__((cleanup(cleanup_queue)))

1870

task_queue *queue = create_queue();

1871

g_assert_nonnull(queue);

1872

1873

g_assert_true(add_to_queue(queue,

1874

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

1875

g_assert_true(queue->length == 1);

1876

g_assert_nonnull(queue->tasks);

1877

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

1878

}

1879

1880

static void dummy_func(__attribute__((unused))

1881

const task_context task,

1882

__attribute__((unused))

1883

task_queue *const queue){

1884

}

1885

1886

static void test_queue_has_question_empty(__attribute__((unused))

1887

test_fixture *fixture,

1888

__attribute__((unused))

1889

gconstpointer user_data){

1890

__attribute__((cleanup(cleanup_queue)))

1891

task_queue *queue = create_queue();

1892

g_assert_nonnull(queue);

1893

g_assert_false(queue_has_question(queue));

1894

}

1895

1896

static void test_queue_has_question_false(__attribute__((unused))

1897

test_fixture *fixture,

1898

__attribute__((unused))

1899

gconstpointer user_data){

1900

__attribute__((cleanup(cleanup_queue)))

1901

task_queue *queue = create_queue();

1902

g_assert_nonnull(queue);

1903

g_assert_true(add_to_queue(queue,

1904

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

1905

g_assert_false(queue_has_question(queue));

1906

}

1907

1908

static void test_queue_has_question_true(__attribute__((unused))

1909

test_fixture *fixture,

1910

__attribute__((unused))

1911

gconstpointer user_data){

1912

__attribute__((cleanup(cleanup_queue)))

1913

task_queue *queue = create_queue();

1914

g_assert_nonnull(queue);

1915

char *const question_filename

1916

= strdup("/nonexistent/question_filename");

1917

g_assert_nonnull(question_filename);

1918

task_context task = {

1919

.func=dummy_func,

1920

.question_filename=question_filename,

1921

};

1922

g_assert_true(add_to_queue(queue, task));

1923

g_assert_true(queue_has_question(queue));

1924

}

1925

1926

static void test_queue_has_question_false2(__attribute__((unused))

1927

test_fixture *fixture,

1928

__attribute__((unused))

1929

gconstpointer user_data){

1930

__attribute__((cleanup(cleanup_queue)))

1931

task_queue *queue = create_queue();

1932

g_assert_nonnull(queue);

1933

task_context task = { .func=dummy_func };

1934

g_assert_true(add_to_queue(queue, task));

1935

g_assert_true(add_to_queue(queue, task));

1936

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

1937

g_assert_false(queue_has_question(queue));

1938

}

1939

1940

static void test_queue_has_question_true2(__attribute__((unused))

1941

test_fixture *fixture,

1942

__attribute__((unused))

1943

gconstpointer user_data){

1944

__attribute__((cleanup(cleanup_queue)))

1945

task_queue *queue = create_queue();

1946

g_assert_nonnull(queue);

1947

task_context task1 = { .func=dummy_func };

1948

g_assert_true(add_to_queue(queue, task1));

1949

char *const question_filename

1950

= strdup("/nonexistent/question_filename");

1951

g_assert_nonnull(question_filename);

1952

task_context task2 = {

1953

.func=dummy_func,

1954

.question_filename=question_filename,

1955

};

1956

g_assert_true(add_to_queue(queue, task2));

1957

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

1958

g_assert_true(queue_has_question(queue));

1959

}

1960

1961

static void test_cleanup_buffer(__attribute__((unused))

1962

test_fixture *fixture,

1963

__attribute__((unused))

1964

gconstpointer user_data){

1965

buffer buf = {};

1966

1967

const size_t buffersize = 10;

1968

1969

buf.data = malloc(buffersize);

1970

g_assert_nonnull(buf.data);

1971

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

1972

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

1973

}

1974

1975

cleanup_buffer(&buf);

1976

g_assert_null(buf.data);

1977

}

1978

1979

static

1980

void test_string_set_new_set_contains_nothing(__attribute__((unused))

1981

test_fixture *fixture,

1982

__attribute__((unused))

1983

gconstpointer

1984

user_data){

1985

__attribute__((cleanup(string_set_clear)))

1986

string_set set = {};

1987

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

1988

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

1989

}

1990

1991

static void

1992

test_string_set_with_added_string_contains_it(__attribute__((unused))

1993

test_fixture *fixture,

1994

__attribute__((unused))

1995

gconstpointer

1996

user_data){

1997

__attribute__((cleanup(string_set_clear)))

1998

string_set set = {};

1999

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

2000

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

2001

}

2002

2003

static void

2004

test_string_set_cleared_does_not_contain_str(__attribute__((unused))

2005

test_fixture *fixture,

2006

__attribute__((unused))

2007

gconstpointer user_data){

2008

__attribute__((cleanup(string_set_clear)))

2009

string_set set = {};

2010

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

2011

string_set_clear(&set);

2012

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

2013

}

2014

2015

static

2016

void test_string_set_swap_one_with_empty(__attribute__((unused))

2017

test_fixture *fixture,

2018

__attribute__((unused))

2019

gconstpointer user_data){

2020

__attribute__((cleanup(string_set_clear)))

2021

string_set set1 = {};

2022

__attribute__((cleanup(string_set_clear)))

2023

string_set set2 = {};

2024

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

2025

string_set_swap(&set1, &set2);

2026

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

2027

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

2028

}

2029

2030

static

2031

void test_string_set_swap_empty_with_one(__attribute__((unused))

2032

test_fixture *fixture,

2033

__attribute__((unused))

2034

gconstpointer user_data){

2035

__attribute__((cleanup(string_set_clear)))

2036

string_set set1 = {};

2037

__attribute__((cleanup(string_set_clear)))

2038

string_set set2 = {};

2039

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

2040

string_set_swap(&set1, &set2);

2041

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

2042

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

2043

}

2044

2045

static void test_string_set_swap_one_with_one(__attribute__((unused))

2046

test_fixture *fixture,

2047

__attribute__((unused))

2048

gconstpointer

2049

user_data){

2050

__attribute__((cleanup(string_set_clear)))

2051

string_set set1 = {};

2052

__attribute__((cleanup(string_set_clear)))

2053

string_set set2 = {};

2054

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

2055

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

2056

string_set_swap(&set1, &set2);

2057

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

2058

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

2059

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

2060

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

2061

}

2062

2063

static bool fd_has_cloexec_and_nonblock(const int);

2064

2065

static bool epoll_set_contains(int, int, uint32_t);

2066

2067

static void test_start_mandos_client(test_fixture *fixture,

2068

__attribute__((unused))

2069

gconstpointer user_data){

2070

2071

bool mandos_client_exited = false;

2072

bool quit_now = false;

2073

__attribute__((cleanup(cleanup_close)))

2074

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2075

g_assert_cmpint(epoll_fd, >=, 0);

2076

__attribute__((cleanup(cleanup_queue)))

2077

task_queue *queue = create_queue();

2078

g_assert_nonnull(queue);

2079

buffer password = {};

2080

bool password_is_read = false;

2081

const char helper_directory[] = "/nonexistent";

2082

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

2083

2084

g_assert_true(start_mandos_client(queue, epoll_fd,

2085

&mandos_client_exited, &quit_now,

2086

&password, &password_is_read,

2087

&fixture->orig_sigaction,

2088

fixture->orig_sigmask,

2089

helper_directory, 0, 0, argv));

2090

2091

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

2092

2093

const task_context *const added_wait_task

2094

= find_matching_task(queue, (task_context){

2095

.func=wait_for_mandos_client_exit,

2096

.mandos_client_exited=&mandos_client_exited,

2097

.quit_now=&quit_now,

2098

});

2099

g_assert_nonnull(added_wait_task);

2100

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

2101

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

2102

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

2103

2104

const task_context *const added_read_task

2105

= find_matching_task(queue, (task_context){

2106

.func=read_mandos_client_output,

2107

.epoll_fd=epoll_fd,

2108

.password=&password,

2109

.password_is_read=&password_is_read,

2110

.quit_now=&quit_now,

2111

});

2112

g_assert_nonnull(added_read_task);

2113

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

2114

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

2115

g_assert_true(epoll_set_contains(epoll_fd, added_read_task->fd,

2116

EPOLLIN | EPOLLRDHUP));

2117

}

2118

2119

static bool fd_has_cloexec_and_nonblock(const int fd){

2120

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

2121

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

2122

return ((socket_fd_flags >= 0)

2123

and (socket_fd_flags & FD_CLOEXEC)

2124

and (socket_file_flags >= 0)

2125

and (socket_file_flags & O_NONBLOCK));

2126

}

2127

2128

__attribute__((const))

2129

bool is_privileged(void){

2130

uid_t user = getuid() + 1;

2131

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

2132

user++;

2133

}

2134

gid_t group = getuid() + 1;

2135

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

2136

group++;

2137

}

2138

const pid_t pid = fork();

2139

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

2140

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

2141

if(errno != EPERM){

2142

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

2143

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

2144

}

2145

exit(EXIT_FAILURE);

2146

}

2147

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

2148

if(errno != EPERM){

2149

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

2150

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

2151

}

2152

exit(EXIT_FAILURE);

2153

}

2154

exit(EXIT_SUCCESS);

2155

}

2156

int status;

2157

waitpid(pid, &status, 0);

2158

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

2159

return true;

2160

}

2161

return false;

2162

}

2163

2164

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

2165

/* Only scan for events in this eventmask */

2166

const uint32_t eventmask = EPOLLIN | EPOLLOUT | EPOLLRDHUP;

2167

__attribute__((cleanup(cleanup_string)))

2168

char *fdinfo_name = NULL;

2169

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

2170

g_assert_cmpint(ret, >, 0);

2171

g_assert_nonnull(fdinfo_name);

2172

2173

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

2174

g_assert_nonnull(fdinfo);

2175

uint32_t reported_events;

2176

buffer line = {};

2177

int found_fd = -1;

2178

2179

do {

2180

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

2181

break;

2182

}

2183

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

2184

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

2185

&found_fd, &reported_events) == 2){

2186

if(found_fd == fd){

2187

break;

2188

}

2189

}

2190

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

2191

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

2192

free(line.data);

2193

if(found_fd != fd){

2194

return false;

2195

}

2196

2197

if(events == 0){

2198

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

2199

return true;

2200

}

2201

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

2202

}

2203

2204

static void test_start_mandos_client_execv(test_fixture *fixture,

2205

__attribute__((unused))

2206

gconstpointer user_data){

2207

bool mandos_client_exited = false;

2208

bool quit_now = false;

2209

__attribute__((cleanup(cleanup_close)))

2210

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2211

g_assert_cmpint(epoll_fd, >=, 0);

2212

__attribute__((cleanup(cleanup_queue)))

2213

task_queue *queue = create_queue();

2214

g_assert_nonnull(queue);

2215

__attribute__((cleanup(cleanup_buffer)))

2216

buffer password = {};

2217

const char helper_directory[] = "/nonexistent";

2218

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

2219

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

2220

2221

{

2222

__attribute__((cleanup(cleanup_close)))

2223

const int devnull_fd = open("/dev/null", O_WRONLY | O_CLOEXEC);

2224

g_assert_cmpint(devnull_fd, >=, 0);

2225

__attribute__((cleanup(cleanup_close)))

2226

const int real_stderr_fd = dup(STDERR_FILENO);

2227

g_assert_cmpint(real_stderr_fd, >=, 0);

2228

dup2(devnull_fd, STDERR_FILENO);

2229

2230

const bool success = start_mandos_client(queue, epoll_fd,

2231

&mandos_client_exited,

2232

&quit_now,

2233

&password,

2234

(bool[]){false},

2235

&fixture->orig_sigaction,

2236

fixture->orig_sigmask,

2237

helper_directory, 0, 0,

2238

argv);

2239

dup2(real_stderr_fd, STDERR_FILENO);

2240

g_assert_true(success);

2241

}

2242

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

2243

2244

struct timespec starttime, currtime;

2245

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

2246

do {

2247

queue->next_run = 0;

2248

string_set cancelled_filenames = {};

2249

2250

{

2251

__attribute__((cleanup(cleanup_close)))

2252

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

2253

O_WRONLY | O_CLOEXEC);

2254

g_assert_cmpint(devnull_fd, >=, 0);

2255

__attribute__((cleanup(cleanup_close)))

2256

const int real_stderr_fd = dup(STDERR_FILENO);

2257

g_assert_cmpint(real_stderr_fd, >=, 0);

2258

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

2259

dup2(devnull_fd, STDERR_FILENO);

2260

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

2261

&quit_now);

2262

dup2(real_stderr_fd, STDERR_FILENO);

2263

if(not success){

2264

break;

2265

}

2266

}

2267

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

2268

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

2269

and (not quit_now)

2270

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

2271

2272

g_assert_true(quit_now);

2273

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

2274

g_assert_true(mandos_client_exited);

2275

}

2276

2277

static void test_start_mandos_client_suid_euid(test_fixture *fixture,

2278

__attribute__((unused))

2279

gconstpointer

2280

user_data){

2281

if(not is_privileged()){

2282

g_test_skip("Not privileged");

2283

return;

2284

}

2285

2286

bool mandos_client_exited = false;

2287

bool quit_now = false;

2288

__attribute__((cleanup(cleanup_close)))

2289

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2290

g_assert_cmpint(epoll_fd, >=, 0);

2291

__attribute__((cleanup(cleanup_queue)))

2292

task_queue *queue = create_queue();

2293

g_assert_nonnull(queue);

2294

__attribute__((cleanup(cleanup_buffer)))

2295

buffer password = {};

2296

bool password_is_read = false;

2297

const char helper_directory[] = "/nonexistent";

2298

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

2299

uid_t user = 1000;

2300

gid_t group = 1001;

2301

2302

const bool success = start_mandos_client(queue, epoll_fd,

2303

&mandos_client_exited,

2304

&quit_now, &password,

2305

&password_is_read,

2306

&fixture->orig_sigaction,

2307

fixture->orig_sigmask,

2308

helper_directory, user,

2309

group, argv);

2310

g_assert_true(success);

2311

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

2312

2313

struct timespec starttime, currtime;

2314

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

2315

do {

2316

queue->next_run = 0;

2317

string_set cancelled_filenames = {};

2318

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

2319

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

2320

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

2321

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

2322

and (not quit_now)

2323

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

2324

2325

g_assert_false(quit_now);

2326

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

2327

g_assert_true(mandos_client_exited);

2328

2329

g_assert_true(password_is_read);

2330

g_assert_nonnull(password.data);

2331

2332

uintmax_t id;

2333

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

2334

==, 1);

2335

g_assert_true((uid_t)id == id);

2336

2337

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

2338

}

2339

2340

static void test_start_mandos_client_suid_egid(test_fixture *fixture,

2341

__attribute__((unused))

2342

gconstpointer

2343

user_data){

2344

if(not is_privileged()){

2345

g_test_skip("Not privileged");

2346

return;

2347

}

2348

2349

bool mandos_client_exited = false;

2350

bool quit_now = false;

2351

__attribute__((cleanup(cleanup_close)))

2352

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2353

g_assert_cmpint(epoll_fd, >=, 0);

2354

__attribute__((cleanup(cleanup_queue)))

2355

task_queue *queue = create_queue();

2356

g_assert_nonnull(queue);

2357

__attribute__((cleanup(cleanup_buffer)))

2358

buffer password = {};

2359

bool password_is_read = false;

2360

const char helper_directory[] = "/nonexistent";

2361

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

2362

uid_t user = 1000;

2363

gid_t group = 1001;

2364

2365

const bool success = start_mandos_client(queue, epoll_fd,

2366

&mandos_client_exited,

2367

&quit_now, &password,

2368

&password_is_read,

2369

&fixture->orig_sigaction,

2370

fixture->orig_sigmask,

2371

helper_directory, user,

2372

group, argv);

2373

g_assert_true(success);

2374

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

2375

2376

struct timespec starttime, currtime;

2377

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

2378

do {

2379

queue->next_run = 0;

2380

string_set cancelled_filenames = {};

2381

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

2382

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

2383

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

2384

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

2385

and (not quit_now)

2386

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

2387

2388

g_assert_false(quit_now);

2389

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

2390

g_assert_true(mandos_client_exited);

2391

2392

g_assert_true(password_is_read);

2393

g_assert_nonnull(password.data);

2394

2395

uintmax_t id;

2396

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

2397

==, 1);

2398

g_assert_true((gid_t)id == id);

2399

2400

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

2401

}

2402

2403

static void test_start_mandos_client_suid_ruid(test_fixture *fixture,

2404

__attribute__((unused))

2405

gconstpointer

2406

user_data){

2407

if(not is_privileged()){

2408

g_test_skip("Not privileged");

2409

return;

2410

}

2411

2412

bool mandos_client_exited = false;

2413

bool quit_now = false;

2414

__attribute__((cleanup(cleanup_close)))

2415

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2416

g_assert_cmpint(epoll_fd, >=, 0);

2417

__attribute__((cleanup(cleanup_queue)))

2418

task_queue *queue = create_queue();

2419

g_assert_nonnull(queue);

2420

__attribute__((cleanup(cleanup_buffer)))

2421

buffer password = {};

2422

bool password_is_read = false;

2423

const char helper_directory[] = "/nonexistent";

2424

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

2425

NULL };

2426

uid_t user = 1000;

2427

gid_t group = 1001;

2428

2429

const bool success = start_mandos_client(queue, epoll_fd,

2430

&mandos_client_exited,

2431

&quit_now, &password,

2432

&password_is_read,

2433

&fixture->orig_sigaction,

2434

fixture->orig_sigmask,

2435

helper_directory, user,

2436

group, argv);

2437

g_assert_true(success);

2438

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

2439

2440

struct timespec starttime, currtime;

2441

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

2442

do {

2443

queue->next_run = 0;

2444

string_set cancelled_filenames = {};

2445

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

2446

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

2447

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

2448

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

2449

and (not quit_now)

2450

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

2451

2452

g_assert_false(quit_now);

2453

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

2454

g_assert_true(mandos_client_exited);

2455

2456

g_assert_true(password_is_read);

2457

g_assert_nonnull(password.data);

2458

2459

uintmax_t id;

2460

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

2461

==, 1);

2462

g_assert_true((uid_t)id == id);

2463

2464

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

2465

}

2466

2467

static void test_start_mandos_client_suid_rgid(test_fixture *fixture,

2468

__attribute__((unused))

2469

gconstpointer

2470

user_data){

2471

if(not is_privileged()){

2472

g_test_skip("Not privileged");

2473

return;

2474

}

2475

2476

bool mandos_client_exited = false;

2477

bool quit_now = false;

2478

__attribute__((cleanup(cleanup_close)))

2479

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2480

g_assert_cmpint(epoll_fd, >=, 0);

2481

__attribute__((cleanup(cleanup_queue)))

2482

task_queue *queue = create_queue();

2483

g_assert_nonnull(queue);

2484

__attribute__((cleanup(cleanup_buffer)))

2485

buffer password = {};

2486

bool password_is_read = false;

2487

const char helper_directory[] = "/nonexistent";

2488

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

2489

NULL };

2490

uid_t user = 1000;

2491

gid_t group = 1001;

2492

2493

const bool success = start_mandos_client(queue, epoll_fd,

2494

&mandos_client_exited,

2495

&quit_now, &password,

2496

&password_is_read,

2497

&fixture->orig_sigaction,

2498

fixture->orig_sigmask,

2499

helper_directory, user,

2500

group, argv);

2501

g_assert_true(success);

2502

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

2503

2504

struct timespec starttime, currtime;

2505

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

2506

do {

2507

queue->next_run = 0;

2508

string_set cancelled_filenames = {};

2509

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

2510

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

2511

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

2512

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

2513

and (not quit_now)

2514

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

2515

2516

g_assert_false(quit_now);

2517

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

2518

g_assert_true(mandos_client_exited);

2519

2520

g_assert_true(password_is_read);

2521

g_assert_nonnull(password.data);

2522

2523

uintmax_t id;

2524

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

2525

==, 1);

2526

g_assert_true((gid_t)id == id);

2527

2528

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

2529

}

2530

2531

static void test_start_mandos_client_read(test_fixture *fixture,

2532

__attribute__((unused))

2533

gconstpointer user_data){

2534

bool mandos_client_exited = false;

2535

bool quit_now = false;

2536

__attribute__((cleanup(cleanup_close)))

2537

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2538

g_assert_cmpint(epoll_fd, >=, 0);

2539

__attribute__((cleanup(cleanup_queue)))

2540

task_queue *queue = create_queue();

2541

g_assert_nonnull(queue);

2542

__attribute__((cleanup(cleanup_buffer)))

2543

buffer password = {};

2544

bool password_is_read = false;

2545

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

2546

const char helper_directory[] = "/nonexistent";

2547

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

2548

NULL };

2549

2550

const bool success = start_mandos_client(queue, epoll_fd,

2551

&mandos_client_exited,

2552

&quit_now, &password,

2553

&password_is_read,

2554

&fixture->orig_sigaction,

2555

fixture->orig_sigmask,

2556

helper_directory, 0, 0,

2557

argv);

2558

g_assert_true(success);

2559

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

2560

2561

struct timespec starttime, currtime;

2562

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

2563

do {

2564

queue->next_run = 0;

2565

string_set cancelled_filenames = {};

2566

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

2567

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

2568

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

2569

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

2570

and (not quit_now)

2571

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

2572

2573

g_assert_false(quit_now);

2574

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

2575

g_assert_true(mandos_client_exited);

2576

2577

g_assert_true(password_is_read);

2578

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

2579

sizeof(dummy_test_password)-1);

2580

g_assert_nonnull(password.data);

2581

g_assert_cmpint(memcmp(dummy_test_password, password.data,

2582

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

2583

}

2584

2585

static

2586

void test_start_mandos_client_helper_directory(test_fixture *fixture,

2587

__attribute__((unused))

2588

gconstpointer

2589

user_data){

2590

bool mandos_client_exited = false;

2591

bool quit_now = false;

2592

__attribute__((cleanup(cleanup_close)))

2593

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2594

g_assert_cmpint(epoll_fd, >=, 0);

2595

__attribute__((cleanup(cleanup_queue)))

2596

task_queue *queue = create_queue();

2597

g_assert_nonnull(queue);

2598

__attribute__((cleanup(cleanup_buffer)))

2599

buffer password = {};

2600

bool password_is_read = false;

2601

const char helper_directory[] = "/nonexistent";

2602

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

2603

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

2604

2605

const bool success = start_mandos_client(queue, epoll_fd,

2606

&mandos_client_exited,

2607

&quit_now, &password,

2608

&password_is_read,

2609

&fixture->orig_sigaction,

2610

fixture->orig_sigmask,

2611

helper_directory, 0, 0,

2612

argv);

2613

g_assert_true(success);

2614

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

2615

2616

struct timespec starttime, currtime;

2617

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

2618

do {

2619

queue->next_run = 0;

2620

string_set cancelled_filenames = {};

2621

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

2622

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

2623

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

2624

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

2625

and (not quit_now)

2626

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

2627

2628

g_assert_false(quit_now);

2629

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

2630

g_assert_true(mandos_client_exited);

2631

2632

g_assert_true(password_is_read);

2633

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

2634

sizeof(helper_directory)-1);

2635

g_assert_nonnull(password.data);

2636

g_assert_cmpint(memcmp(helper_directory, password.data,

2637

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

2638

}

2639

2640

__attribute__((nonnull, warn_unused_result))

2641

static bool proc_status_sigblk_to_sigset(const char *const,

2642

sigset_t *const);

2643

2644

static void test_start_mandos_client_sigmask(test_fixture *fixture,

2645

__attribute__((unused))

2646

gconstpointer user_data){

2647

bool mandos_client_exited = false;

2648

bool quit_now = false;

2649

__attribute__((cleanup(cleanup_close)))

2650

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2651

g_assert_cmpint(epoll_fd, >=, 0);

2652

__attribute__((cleanup(cleanup_queue)))

2653

task_queue *queue = create_queue();

2654

g_assert_nonnull(queue);

2655

__attribute__((cleanup(cleanup_buffer)))

2656

buffer password = {};

2657

bool password_is_read = false;

2658

const char helper_directory[] = "/nonexistent";

2659

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

2660

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

2661

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

2662

2663

g_assert_true(start_mandos_client(queue, epoll_fd,

2664

&mandos_client_exited, &quit_now,

2665

&password, &password_is_read,

2666

&fixture->orig_sigaction,

2667

fixture->orig_sigmask,

2668

helper_directory, 0, 0, argv));

2669

2670

struct timespec starttime, currtime;

2671

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

2672

do {

2673

queue->next_run = 0;

2674

string_set cancelled_filenames = {};

2675

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

2676

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

2677

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

2678

} while((not (mandos_client_exited and password_is_read))

2679

and (not quit_now)

2680

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

2681

g_assert_true(mandos_client_exited);

2682

g_assert_true(password_is_read);

2683

2684

sigset_t parsed_sigmask;

2685

g_assert_true(proc_status_sigblk_to_sigset(password.data,

2686

&parsed_sigmask));

2687

2688

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

2689

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

2690

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

2691

g_assert_true(has_signal);

2692

} else {

2693

g_assert_false(has_signal);

2694

}

2695

}

2696

}

2697

2698

__attribute__((nonnull, warn_unused_result))

2699

static bool proc_status_sigblk_to_sigset(const char *const sigblk,

2700

sigset_t *const sigmask){

2701

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

2702

uintmax_t scanned_sigmask;

2703

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

2704

return false;

2705

}

2706

if(sigemptyset(sigmask) != 0){

2707

return false;

2708

}

2709

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

2710

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

2711

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

2712

return false;

2713

}

2714

}

2715

}

2716

return true;

2717

}

2718

2719

static void run_task_with_stderr_to_dev_null(const task_context task,

2720

task_queue *const queue);

2721

2722

static

2723

void test_wait_for_mandos_client_exit_badpid(__attribute__((unused))

2724

test_fixture *fixture,

2725

__attribute__((unused))

2726

gconstpointer user_data){

2727

2728

bool mandos_client_exited = false;

2729

bool quit_now = false;

2730

2731

__attribute__((cleanup(cleanup_queue)))

2732

task_queue *queue = create_queue();

2733

g_assert_nonnull(queue);

2734

const task_context task = {

2735

.func=wait_for_mandos_client_exit,

2736

.pid=1,

2737

.mandos_client_exited=&mandos_client_exited,

2738

.quit_now=&quit_now,

2739

};

2740

run_task_with_stderr_to_dev_null(task, queue);

2741

2742

g_assert_false(mandos_client_exited);

2743

g_assert_true(quit_now);

2744

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

2745

}

2746

2747

static void run_task_with_stderr_to_dev_null(const task_context task,

2748

task_queue *const queue){

2749

FILE *real_stderr = stderr;

2750

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

2751

g_assert_nonnull(devnull);

2752

2753

stderr = devnull;

2754

task.func(task, queue);

2755

stderr = real_stderr;

2756

2757

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

2758

}

2759

2760

static

2761

void test_wait_for_mandos_client_exit_noexit(test_fixture *fixture,

2762

__attribute__((unused))

2763

gconstpointer user_data){

2764

bool mandos_client_exited = false;

2765

bool quit_now = false;

2766

2767

pid_t create_eternal_process(void){

2768

const pid_t pid = fork();

2769

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

2770

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

2771

_exit(EXIT_FAILURE);

2772

}

2773

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

2774

_exit(EXIT_FAILURE);

2775

}

2776

while(true){

2777

pause();

2778

}

2779

}

2780

return pid;

2781

}

2782

pid_t pid = create_eternal_process();

2783

g_assert_true(pid != -1);

2784

2785

__attribute__((cleanup(cleanup_queue)))

2786

task_queue *queue = create_queue();

2787

g_assert_nonnull(queue);

2788

const task_context task = {

2789

.func=wait_for_mandos_client_exit,

2790

.pid=pid,

2791

.mandos_client_exited=&mandos_client_exited,

2792

.quit_now=&quit_now,

2793

};

2794

task.func(task, queue);

2795

2796

g_assert_false(mandos_client_exited);

2797

g_assert_false(quit_now);

2798

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

2799

2800

g_assert_nonnull(find_matching_task(queue, (task_context){

2801

.func=wait_for_mandos_client_exit,

2802

.pid=task.pid,

2803

.mandos_client_exited=&mandos_client_exited,

2804

.quit_now=&quit_now,

2805

}));

2806

}

2807

2808

static

2809

void test_wait_for_mandos_client_exit_success(test_fixture *fixture,

2810

__attribute__((unused))

2811

gconstpointer

2812

user_data){

2813

bool mandos_client_exited = false;

2814

bool quit_now = false;

2815

2816

pid_t create_successful_process(void){

2817

const pid_t pid = fork();

2818

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

2819

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

2820

_exit(EXIT_FAILURE);

2821

}

2822

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

2823

_exit(EXIT_FAILURE);

2824

}

2825

exit(EXIT_SUCCESS);

2826

}

2827

return pid;

2828

}

2829

const pid_t pid = create_successful_process();

2830

g_assert_true(pid != -1);

2831

2832

__attribute__((cleanup(cleanup_queue)))

2833

task_queue *queue = create_queue();

2834

g_assert_nonnull(queue);

2835

const task_context initial_task = {

2836

.func=wait_for_mandos_client_exit,

2837

.pid=pid,

2838

.mandos_client_exited=&mandos_client_exited,

2839

.quit_now=&quit_now,

2840

};

2841

g_assert_true(add_to_queue(queue, initial_task));

2842

2843

struct timespec starttime, currtime;

2844

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

2845

__attribute__((cleanup(cleanup_close)))

2846

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2847

do {

2848

queue->next_run = 0;

2849

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

2850

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

2851

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

2852

} while((not mandos_client_exited)

2853

and (not quit_now)

2854

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

2855

2856

g_assert_true(mandos_client_exited);

2857

g_assert_false(quit_now);

2858

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

2859

}

2860

2861

static

2862

void test_wait_for_mandos_client_exit_failure(test_fixture *fixture,

2863

__attribute__((unused))

2864

gconstpointer

2865

user_data){

2866

bool mandos_client_exited = false;

2867

bool quit_now = false;

2868

2869

pid_t create_failing_process(void){

2870

const pid_t pid = fork();

2871

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

2872

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

2873

_exit(EXIT_FAILURE);

2874

}

2875

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

2876

_exit(EXIT_FAILURE);

2877

}

2878

exit(EXIT_FAILURE);

2879

}

2880

return pid;

2881

}

2882

const pid_t pid = create_failing_process();

2883

g_assert_true(pid != -1);

2884

2885

__attribute__((cleanup(string_set_clear)))

2886

string_set cancelled_filenames = {};

2887

__attribute__((cleanup(cleanup_close)))

2888

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2889

g_assert_cmpint(epoll_fd, >=, 0);

2890

__attribute__((cleanup(cleanup_queue)))

2891

task_queue *queue = create_queue();

2892

g_assert_nonnull(queue);

2893

g_assert_true(add_to_queue(queue, (task_context){

2894

.func=wait_for_mandos_client_exit,

2895

.pid=pid,

2896

.mandos_client_exited=&mandos_client_exited,

2897

.quit_now=&quit_now,

2898

}));

2899

2900

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

2901

2902

__attribute__((cleanup(cleanup_close)))

2903

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

2904

O_WRONLY | O_CLOEXEC);

2905

g_assert_cmpint(devnull_fd, >=, 0);

2906

__attribute__((cleanup(cleanup_close)))

2907

const int real_stderr_fd = dup(STDERR_FILENO);

2908

g_assert_cmpint(real_stderr_fd, >=, 0);

2909

2910

struct timespec starttime, currtime;

2911

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

2912

do {

2913

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

2914

dup2(devnull_fd, STDERR_FILENO);

2915

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

2916

&quit_now);

2917

dup2(real_stderr_fd, STDERR_FILENO);

2918

if(not success){

2919

break;

2920

}

2921

2922

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

2923

} while((not mandos_client_exited)

2924

and (not quit_now)

2925

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

2926

2927

g_assert_true(quit_now);

2928

g_assert_true(mandos_client_exited);

2929

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

2930

}

2931

2932

static

2933

void test_wait_for_mandos_client_exit_killed(test_fixture *fixture,

2934

__attribute__((unused))

2935

gconstpointer user_data){

2936

bool mandos_client_exited = false;

2937

bool quit_now = false;

2938

2939

pid_t create_killed_process(void){

2940

const pid_t pid = fork();

2941

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

2942

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

2943

_exit(EXIT_FAILURE);

2944

}

2945

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

2946

_exit(EXIT_FAILURE);

2947

}

2948

while(true){

2949

pause();

2950

}

2951

}

2952

kill(pid, SIGKILL);

2953

return pid;

2954

}

2955

const pid_t pid = create_killed_process();

2956

g_assert_true(pid != -1);

2957

2958

__attribute__((cleanup(string_set_clear)))

2959

string_set cancelled_filenames = {};

2960

__attribute__((cleanup(cleanup_close)))

2961

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2962

g_assert_cmpint(epoll_fd, >=, 0);

2963

__attribute__((cleanup(cleanup_queue)))

2964

task_queue *queue = create_queue();

2965

g_assert_nonnull(queue);

2966

g_assert_true(add_to_queue(queue, (task_context){

2967

.func=wait_for_mandos_client_exit,

2968

.pid=pid,

2969

.mandos_client_exited=&mandos_client_exited,

2970

.quit_now=&quit_now,

2971

}));

2972

2973

__attribute__((cleanup(cleanup_close)))

2974

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

2975

O_WRONLY | O_CLOEXEC);

2976

g_assert_cmpint(devnull_fd, >=, 0);

2977

__attribute__((cleanup(cleanup_close)))

2978

const int real_stderr_fd = dup(STDERR_FILENO);

2979

g_assert_cmpint(real_stderr_fd, >=, 0);

2980

2981

struct timespec starttime, currtime;

2982

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

2983

do {

2984

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

2985

dup2(devnull_fd, STDERR_FILENO);

2986

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

2987

&quit_now);

2988

dup2(real_stderr_fd, STDERR_FILENO);

2989

if(not success){

2990

break;

2991

}

2992

2993

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

2994

} while((not mandos_client_exited)

2995

and (not quit_now)

2996

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

2997

2998

g_assert_true(mandos_client_exited);

2999

g_assert_true(quit_now);

3000

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

3001

}

3002

3003

static bool epoll_set_does_not_contain(int, int);

3004

3005

static

3006

void test_read_mandos_client_output_readerror(__attribute__((unused))

3007

test_fixture *fixture,

3008

__attribute__((unused))

3009

gconstpointer

3010

user_data){

3011

__attribute__((cleanup(cleanup_close)))

3012

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3013

g_assert_cmpint(epoll_fd, >=, 0);

3014

3015

__attribute__((cleanup(cleanup_buffer)))

3016

buffer password = {};

3017

3018

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

3019

const int fd = open("/proc/self/mem", O_RDONLY | O_CLOEXEC);

3020

3021

bool password_is_read = false;

3022

bool quit_now = false;

3023

__attribute__((cleanup(cleanup_queue)))

3024

task_queue *queue = create_queue();

3025

g_assert_nonnull(queue);

3026

3027

task_context task = {

3028

.func=read_mandos_client_output,

3029

.epoll_fd=epoll_fd,

3030

.fd=fd,

3031

.password=&password,

3032

.password_is_read=&password_is_read,

3033

.quit_now=&quit_now,

3034

};

3035

run_task_with_stderr_to_dev_null(task, queue);

3036

g_assert_false(password_is_read);

3037

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

3038

g_assert_true(quit_now);

3039

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

3040

3041

g_assert_true(epoll_set_does_not_contain(epoll_fd, fd));

3042

3043

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

3044

}

3045

3046

static bool epoll_set_does_not_contain(int epoll_fd, int fd){

3047

return not epoll_set_contains(epoll_fd, fd, 0);

3048

}

3049

3050

static

3051

void test_read_mandos_client_output_nodata(__attribute__((unused))

3052

test_fixture *fixture,

3053

__attribute__((unused))

3054

gconstpointer user_data){

3055

__attribute__((cleanup(cleanup_close)))

3056

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3057

g_assert_cmpint(epoll_fd, >=, 0);

3058

3059

int pipefds[2];

3060

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

3061

3062

__attribute__((cleanup(cleanup_buffer)))

3063

buffer password = {};

3064

3065

bool password_is_read = false;

3066

bool quit_now = false;

3067

__attribute__((cleanup(cleanup_queue)))

3068

task_queue *queue = create_queue();

3069

g_assert_nonnull(queue);

3070

3071

task_context task = {

3072

.func=read_mandos_client_output,

3073

.epoll_fd=epoll_fd,

3074

.fd=pipefds[0],

3075

.password=&password,

3076

.password_is_read=&password_is_read,

3077

.quit_now=&quit_now,

3078

};

3079

task.func(task, queue);

3080

g_assert_false(password_is_read);

3081

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

3082

g_assert_false(quit_now);

3083

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

3084

3085

g_assert_nonnull(find_matching_task(queue, (task_context){

3086

.func=read_mandos_client_output,

3087

.epoll_fd=epoll_fd,

3088

.fd=pipefds[0],

3089

.password=&password,

3090

.password_is_read=&password_is_read,

3091

.quit_now=&quit_now,

3092

}));

3093

3094

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3095

EPOLLIN | EPOLLRDHUP));

3096

3097

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

3098

}

3099

3100

static void test_read_mandos_client_output_eof(__attribute__((unused))

3101

test_fixture *fixture,

3102

__attribute__((unused))

3103

gconstpointer

3104

user_data){

3105

__attribute__((cleanup(cleanup_close)))

3106

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3107

g_assert_cmpint(epoll_fd, >=, 0);

3108

3109

int pipefds[2];

3110

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

3111

g_assert_cmpint(close(pipefds[1]), ==, 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_true(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, ==, 0);

3135

3136

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

3137

3138

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

3139

}

3140

3141

static

3142

void test_read_mandos_client_output_once(__attribute__((unused))

3143

test_fixture *fixture,

3144

__attribute__((unused))

3145

gconstpointer user_data){

3146

__attribute__((cleanup(cleanup_close)))

3147

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3148

g_assert_cmpint(epoll_fd, >=, 0);

3149

3150

int pipefds[2];

3151

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

3152

3153

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

3154

/* Start with a pre-allocated buffer */

3155

__attribute__((cleanup(cleanup_buffer)))

3156

buffer password = {

3157

.data=malloc(sizeof(dummy_test_password)),

3158

.length=0,

3159

.allocated=sizeof(dummy_test_password),

3160

};

3161

g_assert_nonnull(password.data);

3162

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

3163

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

3164

}

3165

3166

bool password_is_read = false;

3167

bool quit_now = false;

3168

__attribute__((cleanup(cleanup_queue)))

3169

task_queue *queue = create_queue();

3170

g_assert_nonnull(queue);

3171

3172

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3173

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

3174

sizeof(dummy_test_password)),

3175

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

3176

3177

task_context task = {

3178

.func=read_mandos_client_output,

3179

.epoll_fd=epoll_fd,

3180

.fd=pipefds[0],

3181

.password=&password,

3182

.password_is_read=&password_is_read,

3183

.quit_now=&quit_now,

3184

};

3185

task.func(task, queue);

3186

3187

g_assert_false(password_is_read);

3188

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

3189

(int)sizeof(dummy_test_password));

3190

g_assert_nonnull(password.data);

3191

g_assert_cmpint(memcmp(password.data, dummy_test_password,

3192

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

3193

3194

g_assert_false(quit_now);

3195

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

3196

3197

g_assert_nonnull(find_matching_task(queue, (task_context){

3198

.func=read_mandos_client_output,

3199

.epoll_fd=epoll_fd,

3200

.fd=pipefds[0],

3201

.password=&password,

3202

.password_is_read=&password_is_read,

3203

.quit_now=&quit_now,

3204

}));

3205

3206

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3207

EPOLLIN | EPOLLRDHUP));

3208

3209

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

3210

}

3211

3212

static

3213

void test_read_mandos_client_output_malloc(__attribute__((unused))

3214

test_fixture *fixture,

3215

__attribute__((unused))

3216

gconstpointer user_data){

3217

__attribute__((cleanup(cleanup_close)))

3218

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3219

g_assert_cmpint(epoll_fd, >=, 0);

3220

3221

int pipefds[2];

3222

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

3223

3224

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

3225

/* Start with an empty buffer */

3226

__attribute__((cleanup(cleanup_buffer)))

3227

buffer password = {};

3228

3229

bool password_is_read = false;

3230

bool quit_now = false;

3231

__attribute__((cleanup(cleanup_queue)))

3232

task_queue *queue = create_queue();

3233

g_assert_nonnull(queue);

3234

3235

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3236

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

3237

sizeof(dummy_test_password)),

3238

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

3239

3240

task_context task = {

3241

.func=read_mandos_client_output,

3242

.epoll_fd=epoll_fd,

3243

.fd=pipefds[0],

3244

.password=&password,

3245

.password_is_read=&password_is_read,

3246

.quit_now=&quit_now,

3247

};

3248

task.func(task, queue);

3249

3250

g_assert_false(password_is_read);

3251

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

3252

(int)sizeof(dummy_test_password));

3253

g_assert_nonnull(password.data);

3254

g_assert_cmpint(memcmp(password.data, dummy_test_password,

3255

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

3256

3257

g_assert_false(quit_now);

3258

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

3259

3260

g_assert_nonnull(find_matching_task(queue, (task_context){

3261

.func=read_mandos_client_output,

3262

.epoll_fd=epoll_fd,

3263

.fd=pipefds[0],

3264

.password=&password,

3265

.password_is_read=&password_is_read,

3266

.quit_now=&quit_now,

3267

}));

3268

3269

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3270

EPOLLIN | EPOLLRDHUP));

3271

3272

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

3273

}

3274

3275

static

3276

void test_read_mandos_client_output_append(__attribute__((unused))

3277

test_fixture *fixture,

3278

__attribute__((unused))

3279

gconstpointer user_data){

3280

__attribute__((cleanup(cleanup_close)))

3281

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3282

g_assert_cmpint(epoll_fd, >=, 0);

3283

3284

int pipefds[2];

3285

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

3286

3287

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

3288

__attribute__((cleanup(cleanup_buffer)))

3289

buffer password = {

3290

.data=malloc(PIPE_BUF),

3291

.length=PIPE_BUF,

3292

.allocated=PIPE_BUF,

3293

};

3294

g_assert_nonnull(password.data);

3295

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

3296

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

3297

}

3298

3299

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

3300

char password_expected[PIPE_BUF];

3301

memcpy(password_expected, password.data, PIPE_BUF);

3302

3303

bool password_is_read = false;

3304

bool quit_now = false;

3305

__attribute__((cleanup(cleanup_queue)))

3306

task_queue *queue = create_queue();

3307

g_assert_nonnull(queue);

3308

3309

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3310

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

3311

sizeof(dummy_test_password)),

3312

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

3313

3314

task_context task = {

3315

.func=read_mandos_client_output,

3316

.epoll_fd=epoll_fd,

3317

.fd=pipefds[0],

3318

.password=&password,

3319

.password_is_read=&password_is_read,

3320

.quit_now=&quit_now,

3321

};

3322

task.func(task, queue);

3323

3324

g_assert_false(password_is_read);

3325

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

3326

PIPE_BUF + sizeof(dummy_test_password));

3327

g_assert_nonnull(password.data);

3328

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

3329

==, 0);

3330

g_assert_cmpint(memcmp(password.data + PIPE_BUF,

3331

dummy_test_password,

3332

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

3333

g_assert_false(quit_now);

3334

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

3335

3336

g_assert_nonnull(find_matching_task(queue, (task_context){

3337

.func=read_mandos_client_output,

3338

.epoll_fd=epoll_fd,

3339

.fd=pipefds[0],

3340

.password=&password,

3341

.password_is_read=&password_is_read,

3342

.quit_now=&quit_now,

3343

}));

3344

3345

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3346

EPOLLIN | EPOLLRDHUP));

3347

}

3348

3349

static char *make_temporary_directory(void);

3350

3351

static void test_add_inotify_dir_watch(__attribute__((unused))

3352

test_fixture *fixture,

3353

__attribute__((unused))

3354

gconstpointer user_data){

3355

__attribute__((cleanup(cleanup_close)))

3356

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3357

g_assert_cmpint(epoll_fd, >=, 0);

3358

__attribute__((cleanup(cleanup_queue)))

3359

task_queue *queue = create_queue();

3360

g_assert_nonnull(queue);

3361

__attribute__((cleanup(string_set_clear)))

3362

string_set cancelled_filenames = {};

3363

const mono_microsecs current_time = 0;

3364

3365

bool quit_now = false;

3366

buffer password = {};

3367

bool mandos_client_exited = false;

3368

bool password_is_read = false;

3369

3370

__attribute__((cleanup(cleanup_string)))

3371

char *tempdir = make_temporary_directory();

3372

g_assert_nonnull(tempdir);

3373

3374

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3375

&password, tempdir,

3376

&cancelled_filenames,

3377

&current_time,

3378

&mandos_client_exited,

3379

&password_is_read));

3380

3381

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

3382

3383

const task_context *const added_read_task

3384

= find_matching_task(queue, (task_context){

3385

.func=read_inotify_event,

3386

.epoll_fd=epoll_fd,

3387

.quit_now=&quit_now,

3388

.password=&password,

3389

.filename=tempdir,

3390

.cancelled_filenames=&cancelled_filenames,

3391

.current_time=&current_time,

3392

.mandos_client_exited=&mandos_client_exited,

3393

.password_is_read=&password_is_read,

3394

});

3395

g_assert_nonnull(added_read_task);

3396

3397

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

3398

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3399

g_assert_true(epoll_set_contains(added_read_task->epoll_fd,

3400

added_read_task->fd,

3401

EPOLLIN | EPOLLRDHUP));

3402

3403

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

3404

}

3405

3406

static char *make_temporary_directory(void){

3407

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

3408

g_assert_nonnull(name);

3409

char *result = mkdtemp(name);

3410

if(result == NULL){

3411

free(name);

3412

}

3413

return result;

3414

}

3415

3416

static void test_add_inotify_dir_watch_fail(__attribute__((unused))

3417

test_fixture *fixture,

3418

__attribute__((unused))

3419

gconstpointer user_data){

3420

__attribute__((cleanup(cleanup_close)))

3421

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3422

g_assert_cmpint(epoll_fd, >=, 0);

3423

__attribute__((cleanup(cleanup_queue)))

3424

task_queue *queue = create_queue();

3425

g_assert_nonnull(queue);

3426

__attribute__((cleanup(string_set_clear)))

3427

string_set cancelled_filenames = {};

3428

const mono_microsecs current_time = 0;

3429

3430

bool quit_now = false;

3431

buffer password = {};

3432

bool mandos_client_exited = false;

3433

bool password_is_read = false;

3434

3435

const char nonexistent_dir[] = "/nonexistent";

3436

3437

FILE *real_stderr = stderr;

3438

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

3439

g_assert_nonnull(devnull);

3440

stderr = devnull;

3441

g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3442

&password, nonexistent_dir,

3443

&cancelled_filenames,

3444

&current_time,

3445

&mandos_client_exited,

3446

&password_is_read));

3447

stderr = real_stderr;

3448

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

3449

3450

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

3451

}

3452

3453

static void test_add_inotify_dir_watch_EAGAIN(__attribute__((unused))

3454

test_fixture *fixture,

3455

__attribute__((unused))

3456

gconstpointer

3457

user_data){

3458

__attribute__((cleanup(cleanup_close)))

3459

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3460

g_assert_cmpint(epoll_fd, >=, 0);

3461

__attribute__((cleanup(cleanup_queue)))

3462

task_queue *queue = create_queue();

3463

g_assert_nonnull(queue);

3464

__attribute__((cleanup(string_set_clear)))

3465

string_set cancelled_filenames = {};

3466

const mono_microsecs current_time = 0;

3467

3468

bool quit_now = false;

3469

buffer password = {};

3470

bool mandos_client_exited = false;

3471

bool password_is_read = false;

3472

3473

__attribute__((cleanup(cleanup_string)))

3474

char *tempdir = make_temporary_directory();

3475

g_assert_nonnull(tempdir);

3476

3477

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3478

&password, tempdir,

3479

&cancelled_filenames,

3480

&current_time,

3481

&mandos_client_exited,

3482

&password_is_read));

3483

3484

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

3485

3486

const task_context *const added_read_task

3487

= find_matching_task(queue,

3488

(task_context){ .func=read_inotify_event });

3489

g_assert_nonnull(added_read_task);

3490

3491

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

3492

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3493

3494

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

3495

const size_t ievent_size = (sizeof(struct inotify_event)

3496

+ NAME_MAX + 1);

3497

struct inotify_event *ievent = malloc(ievent_size);

3498

g_assert_nonnull(ievent);

3499

3500

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

3501

-1);

3502

g_assert_cmpint(errno, ==, EAGAIN);

3503

3504

free(ievent);

3505

3506

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

3507

}

3508

3509

static char *make_temporary_file_in_directory(const char

3510

*const dir);

3511

3512

static

3513

void test_add_inotify_dir_watch_IN_CLOSE_WRITE(__attribute__((unused))

3514

test_fixture *fixture,

3515

__attribute__((unused))

3516

gconstpointer

3517

user_data){

3518

__attribute__((cleanup(cleanup_close)))

3519

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3520

g_assert_cmpint(epoll_fd, >=, 0);

3521

__attribute__((cleanup(cleanup_queue)))

3522

task_queue *queue = create_queue();

3523

g_assert_nonnull(queue);

3524

__attribute__((cleanup(string_set_clear)))

3525

string_set cancelled_filenames = {};

3526

const mono_microsecs current_time = 0;

3527

3528

bool quit_now = false;

3529

buffer password = {};

3530

bool mandos_client_exited = false;

3531

bool password_is_read = false;

3532

3533

__attribute__((cleanup(cleanup_string)))

3534

char *tempdir = make_temporary_directory();

3535

g_assert_nonnull(tempdir);

3536

3537

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3538

&password, tempdir,

3539

&cancelled_filenames,

3540

&current_time,

3541

&mandos_client_exited,

3542

&password_is_read));

3543

3544

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

3545

3546

const task_context *const added_read_task

3547

= find_matching_task(queue,

3548

(task_context){ .func=read_inotify_event });

3549

g_assert_nonnull(added_read_task);

3550

3551

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

3552

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3553

3554

__attribute__((cleanup(cleanup_string)))

3555

char *filename = make_temporary_file_in_directory(tempdir);

3556

g_assert_nonnull(filename);

3557

3558

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

3559

const size_t ievent_size = (sizeof(struct inotify_event)

3560

+ NAME_MAX + 1);

3561

struct inotify_event *ievent = malloc(ievent_size);

3562

g_assert_nonnull(ievent);

3563

3564

ssize_t read_size = 0;

3565

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

3566

3567

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

3568

g_assert_true(ievent->mask & IN_CLOSE_WRITE);

3569

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

3570

3571

free(ievent);

3572

3573

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

3574

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

3575

}

3576

3577

static char *make_temporary_prefixed_file_in_directory(const char

3578

*const prefix,

3579

const char

3580

*const dir){

3581

char *filename = NULL;

3582

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

3583

>, 0);

3584

g_assert_nonnull(filename);

3585

const int fd = mkostemp(filename, O_CLOEXEC);

3586

g_assert_cmpint(fd, >=, 0);

3587

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

3588

return filename;

3589

}

3590

3591

static char *make_temporary_file_in_directory(const char

3592

*const dir){

3593

return make_temporary_prefixed_file_in_directory("temp", dir);

3594

}

3595

3596

static

3597

void test_add_inotify_dir_watch_IN_MOVED_TO(__attribute__((unused))

3598

test_fixture *fixture,

3599

__attribute__((unused))

3600

gconstpointer user_data){

3601

__attribute__((cleanup(cleanup_close)))

3602

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3603

g_assert_cmpint(epoll_fd, >=, 0);

3604

__attribute__((cleanup(cleanup_queue)))

3605

task_queue *queue = create_queue();

3606

g_assert_nonnull(queue);

3607

__attribute__((cleanup(string_set_clear)))

3608

string_set cancelled_filenames = {};

3609

const mono_microsecs current_time = 0;

3610

3611

bool quit_now = false;

3612

buffer password = {};

3613

bool mandos_client_exited = false;

3614

bool password_is_read = false;

3615

3616

__attribute__((cleanup(cleanup_string)))

3617

char *watchdir = make_temporary_directory();

3618

g_assert_nonnull(watchdir);

3619

3620

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3621

&password, watchdir,

3622

&cancelled_filenames,

3623

&current_time,

3624

&mandos_client_exited,

3625

&password_is_read));

3626

3627

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

3628

3629

const task_context *const added_read_task

3630

= find_matching_task(queue,

3631

(task_context){ .func=read_inotify_event });

3632

g_assert_nonnull(added_read_task);

3633

3634

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

3635

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3636

3637

char *sourcedir = make_temporary_directory();

3638

g_assert_nonnull(sourcedir);

3639

3640

__attribute__((cleanup(cleanup_string)))

3641

char *filename = make_temporary_file_in_directory(sourcedir);

3642

g_assert_nonnull(filename);

3643

3644

__attribute__((cleanup(cleanup_string)))

3645

char *targetfilename = NULL;

3646

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

3647

basename(filename)), >, 0);

3648

g_assert_nonnull(targetfilename);

3649

3650

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

3651

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

3652

free(sourcedir);

3653

3654

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

3655

const size_t ievent_size = (sizeof(struct inotify_event)

3656

+ NAME_MAX + 1);

3657

struct inotify_event *ievent = malloc(ievent_size);

3658

g_assert_nonnull(ievent);

3659

3660

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

3661

3662

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

3663

g_assert_true(ievent->mask & IN_MOVED_TO);

3664

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

3665

3666

free(ievent);

3667

3668

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

3669

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

3670

}

3671

3672

static

3673

void test_add_inotify_dir_watch_IN_DELETE(__attribute__((unused))

3674

test_fixture *fixture,

3675

__attribute__((unused))

3676

gconstpointer user_data){

3677

__attribute__((cleanup(cleanup_close)))

3678

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3679

g_assert_cmpint(epoll_fd, >=, 0);

3680

__attribute__((cleanup(cleanup_queue)))

3681

task_queue *queue = create_queue();

3682

g_assert_nonnull(queue);

3683

__attribute__((cleanup(string_set_clear)))

3684

string_set cancelled_filenames = {};

3685

const mono_microsecs current_time = 0;

3686

3687

bool quit_now = false;

3688

buffer password = {};

3689

bool mandos_client_exited = false;

3690

bool password_is_read = false;

3691

3692

__attribute__((cleanup(cleanup_string)))

3693

char *tempdir = make_temporary_directory();

3694

g_assert_nonnull(tempdir);

3695

3696

__attribute__((cleanup(cleanup_string)))

3697

char *tempfile = make_temporary_file_in_directory(tempdir);

3698

g_assert_nonnull(tempfile);

3699

3700

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3701

&password, tempdir,

3702

&cancelled_filenames,

3703

&current_time,

3704

&mandos_client_exited,

3705

&password_is_read));

3706

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

3707

3708

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

3709

3710

const task_context *const added_read_task

3711

= find_matching_task(queue,

3712

(task_context){ .func=read_inotify_event });

3713

g_assert_nonnull(added_read_task);

3714

3715

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

3716

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3717

3718

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

3719

const size_t ievent_size = (sizeof(struct inotify_event)

3720

+ NAME_MAX + 1);

3721

struct inotify_event *ievent = malloc(ievent_size);

3722

g_assert_nonnull(ievent);

3723

3724

ssize_t read_size = 0;

3725

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

3726

3727

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

3728

g_assert_true(ievent->mask & IN_DELETE);

3729

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

3730

3731

free(ievent);

3732

3733

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

3734

}

3735

3736

static void test_read_inotify_event_readerror(__attribute__((unused))

3737

test_fixture *fixture,

3738

__attribute__((unused))

3739

gconstpointer

3740

user_data){

3741

__attribute__((cleanup(cleanup_close)))

3742

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3743

g_assert_cmpint(epoll_fd, >=, 0);

3744

const mono_microsecs current_time = 0;

3745

3746

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

3747

const int fd = open("/proc/self/mem", O_RDONLY | O_CLOEXEC);

3748

3749

bool quit_now = false;

3750

__attribute__((cleanup(cleanup_queue)))

3751

task_queue *queue = create_queue();

3752

g_assert_nonnull(queue);

3753

3754

task_context task = {

3755

.func=read_inotify_event,

3756

.epoll_fd=epoll_fd,

3757

.fd=fd,

3758

.quit_now=&quit_now,

3759

.filename=strdup("/nonexistent"),

3760

.cancelled_filenames = &(string_set){},

3761

.notafter=0,

3762

.current_time=&current_time,

3763

};

3764

g_assert_nonnull(task.filename);

3765

run_task_with_stderr_to_dev_null(task, queue);

3766

g_assert_true(quit_now);

3767

g_assert_true(queue->next_run == 0);

3768

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

3769

3770

g_assert_true(epoll_set_does_not_contain(epoll_fd, fd));

3771

3772

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

3773

}

3774

3775

static void test_read_inotify_event_bad_epoll(__attribute__((unused))

3776

test_fixture *fixture,

3777

__attribute__((unused))

3778

gconstpointer

3779

user_data){

3780

const mono_microsecs current_time = 17;

3781

3782

int pipefds[2];

3783

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

3784

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

3785

3786

bool quit_now = false;

3787

buffer password = {};

3788

bool mandos_client_exited = false;

3789

bool password_is_read = false;

3790

__attribute__((cleanup(cleanup_queue)))

3791

task_queue *queue = create_queue();

3792

g_assert_nonnull(queue);

3793

3794

task_context task = {

3795

.func=read_inotify_event,

3796

.epoll_fd=epoll_fd,

3797

.fd=pipefds[0],

3798

.quit_now=&quit_now,

3799

.password=&password,

3800

.filename=strdup("/nonexistent"),

3801

.cancelled_filenames = &(string_set){},

3802

.notafter=0,

3803

.current_time=&current_time,

3804

.mandos_client_exited=&mandos_client_exited,

3805

.password_is_read=&password_is_read,

3806

};

3807

g_assert_nonnull(task.filename);

3808

run_task_with_stderr_to_dev_null(task, queue);

3809

3810

g_assert_nonnull(find_matching_task(queue, task));

3811

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

3812

3813

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

3814

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

3815

}

3816

3817

static void test_read_inotify_event_nodata(__attribute__((unused))

3818

test_fixture *fixture,

3819

__attribute__((unused))

3820

gconstpointer user_data){

3821

__attribute__((cleanup(cleanup_close)))

3822

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3823

g_assert_cmpint(epoll_fd, >=, 0);

3824

const mono_microsecs current_time = 0;

3825

3826

int pipefds[2];

3827

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

3828

3829

bool quit_now = false;

3830

buffer password = {};

3831

bool mandos_client_exited = false;

3832

bool password_is_read = false;

3833

__attribute__((cleanup(cleanup_queue)))

3834

task_queue *queue = create_queue();

3835

g_assert_nonnull(queue);

3836

3837

task_context task = {

3838

.func=read_inotify_event,

3839

.epoll_fd=epoll_fd,

3840

.fd=pipefds[0],

3841

.quit_now=&quit_now,

3842

.password=&password,

3843

.filename=strdup("/nonexistent"),

3844

.cancelled_filenames = &(string_set){},

3845

.notafter=0,

3846

.current_time=&current_time,

3847

.mandos_client_exited=&mandos_client_exited,

3848

.password_is_read=&password_is_read,

3849

};

3850

g_assert_nonnull(task.filename);

3851

task.func(task, queue);

3852

g_assert_false(quit_now);

3853

g_assert_true(queue->next_run == 0);

3854

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

3855

3856

g_assert_nonnull(find_matching_task(queue, (task_context){

3857

.func=read_inotify_event,

3858

.epoll_fd=epoll_fd,

3859

.fd=pipefds[0],

3860

.quit_now=&quit_now,

3861

.password=&password,

3862

.filename=task.filename,

3863

.cancelled_filenames=task.cancelled_filenames,

3864

.current_time=&current_time,

3865

.mandos_client_exited=&mandos_client_exited,

3866

.password_is_read=&password_is_read,

3867

}));

3868

3869

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3870

EPOLLIN | EPOLLRDHUP));

3871

3872

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

3873

}

3874

3875

static void test_read_inotify_event_eof(__attribute__((unused))

3876

test_fixture *fixture,

3877

__attribute__((unused))

3878

gconstpointer user_data){

3879

__attribute__((cleanup(cleanup_close)))

3880

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3881

g_assert_cmpint(epoll_fd, >=, 0);

3882

const mono_microsecs current_time = 0;

3883

3884

int pipefds[2];

3885

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

3886

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

3887

3888

bool quit_now = false;

3889

buffer password = {};

3890

__attribute__((cleanup(cleanup_queue)))

3891

task_queue *queue = create_queue();

3892

g_assert_nonnull(queue);

3893

3894

task_context task = {

3895

.func=read_inotify_event,

3896

.epoll_fd=epoll_fd,

3897

.fd=pipefds[0],

3898

.quit_now=&quit_now,

3899

.password=&password,

3900

.filename=strdup("/nonexistent"),

3901

.cancelled_filenames = &(string_set){},

3902

.notafter=0,

3903

.current_time=&current_time,

3904

};

3905

run_task_with_stderr_to_dev_null(task, queue);

3906

g_assert_true(quit_now);

3907

g_assert_true(queue->next_run == 0);

3908

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

3909

3910

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

3911

3912

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

3913

}

3914

3915

static

3916

void test_read_inotify_event_IN_CLOSE_WRITE(__attribute__((unused))

3917

test_fixture *fixture,

3918

__attribute__((unused))

3919

gconstpointer user_data){

3920

__attribute__((cleanup(cleanup_close)))

3921

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3922

g_assert_cmpint(epoll_fd, >=, 0);

3923

const mono_microsecs current_time = 0;

3924

3925

int pipefds[2];

3926

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

3927

3928

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

3929

const size_t ievent_max_size = (sizeof(struct inotify_event)

3930

+ NAME_MAX + 1);

3931

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

3932

char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];

3933

struct inotify_event *ievent = ((struct inotify_event *)

3934

ievent_buffer);

3935

3936

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

3937

ievent->mask = IN_CLOSE_WRITE;

3938

ievent->len = sizeof(dummy_file_name);

3939

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

3940

const size_t ievent_size = (sizeof(struct inotify_event)

3941

+ sizeof(dummy_file_name));

3942

g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),

3943

==, ievent_size);

3944

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

3945

3946

bool quit_now = false;

3947

buffer password = {};

3948

bool mandos_client_exited = false;

3949

bool password_is_read = false;

3950

__attribute__((cleanup(cleanup_queue)))

3951

task_queue *queue = create_queue();

3952

g_assert_nonnull(queue);

3953

3954

task_context task = {

3955

.func=read_inotify_event,

3956

.epoll_fd=epoll_fd,

3957

.fd=pipefds[0],

3958

.quit_now=&quit_now,

3959

.password=&password,

3960

.filename=strdup("/nonexistent"),

3961

.cancelled_filenames = &(string_set){},

3962

.notafter=0,

3963

.current_time=&current_time,

3964

.mandos_client_exited=&mandos_client_exited,

3965

.password_is_read=&password_is_read,

3966

};

3967

task.func(task, queue);

3968

g_assert_false(quit_now);

3969

g_assert_true(queue->next_run != 0);

3970

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

3971

3972

g_assert_nonnull(find_matching_task(queue, (task_context){

3973

.func=read_inotify_event,

3974

.epoll_fd=epoll_fd,

3975

.fd=pipefds[0],

3976

.quit_now=&quit_now,

3977

.password=&password,

3978

.filename=task.filename,

3979

.cancelled_filenames=task.cancelled_filenames,

3980

.current_time=&current_time,

3981

.mandos_client_exited=&mandos_client_exited,

3982

.password_is_read=&password_is_read,

3983

}));

3984

3985

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3986

EPOLLIN | EPOLLRDHUP));

3987

3988

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

3989

3990

__attribute__((cleanup(cleanup_string)))

3991

char *filename = NULL;

3992

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

3993

dummy_file_name), >, 0);

3994

g_assert_nonnull(filename);

3995

g_assert_nonnull(find_matching_task(queue, (task_context){

3996

.func=open_and_parse_question,

3997

.epoll_fd=epoll_fd,

3998

.filename=filename,

3999

.question_filename=filename,

4000

.password=&password,

4001

.cancelled_filenames=task.cancelled_filenames,

4002

.current_time=&current_time,

4003

.mandos_client_exited=&mandos_client_exited,

4004

.password_is_read=&password_is_read,

4005

}));

4006

}

4007

4008

static

4009

void test_read_inotify_event_IN_MOVED_TO(__attribute__((unused))

4010

test_fixture *fixture,

4011

__attribute__((unused))

4012

gconstpointer user_data){

4013

__attribute__((cleanup(cleanup_close)))

4014

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4015

g_assert_cmpint(epoll_fd, >=, 0);

4016

const mono_microsecs current_time = 0;

4017

4018

int pipefds[2];

4019

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

4020

4021

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

4022

const size_t ievent_max_size = (sizeof(struct inotify_event)

4023

+ NAME_MAX + 1);

4024

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4025

char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];

4026

struct inotify_event *ievent = ((struct inotify_event *)

4027

ievent_buffer);

4028

4029

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

4030

ievent->mask = IN_MOVED_TO;

4031

ievent->len = sizeof(dummy_file_name);

4032

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

4033

const size_t ievent_size = (sizeof(struct inotify_event)

4034

+ sizeof(dummy_file_name));

4035

g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),

4036

==, ievent_size);

4037

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

4038

4039

bool quit_now = false;

4040

buffer password = {};

4041

bool mandos_client_exited = false;

4042

bool password_is_read = false;

4043

__attribute__((cleanup(cleanup_queue)))

4044

task_queue *queue = create_queue();

4045

g_assert_nonnull(queue);

4046

4047

task_context task = {

4048

.func=read_inotify_event,

4049

.epoll_fd=epoll_fd,

4050

.fd=pipefds[0],

4051

.quit_now=&quit_now,

4052

.password=&password,

4053

.filename=strdup("/nonexistent"),

4054

.cancelled_filenames = &(string_set){},

4055

.notafter=0,

4056

.current_time=&current_time,

4057

.mandos_client_exited=&mandos_client_exited,

4058

.password_is_read=&password_is_read,

4059

};

4060

task.func(task, queue);

4061

g_assert_false(quit_now);

4062

g_assert_true(queue->next_run != 0);

4063

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

4064

4065

g_assert_nonnull(find_matching_task(queue, (task_context){

4066

.func=read_inotify_event,

4067

.epoll_fd=epoll_fd,

4068

.fd=pipefds[0],

4069

.quit_now=&quit_now,

4070

.password=&password,

4071

.filename=task.filename,

4072

.cancelled_filenames=task.cancelled_filenames,

4073

.current_time=&current_time,

4074

.mandos_client_exited=&mandos_client_exited,

4075

.password_is_read=&password_is_read,

4076

}));

4077

4078

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4079

EPOLLIN | EPOLLRDHUP));

4080

4081

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

4082

4083

__attribute__((cleanup(cleanup_string)))

4084

char *filename = NULL;

4085

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

4086

dummy_file_name), >, 0);

4087

g_assert_nonnull(filename);

4088

g_assert_nonnull(find_matching_task(queue, (task_context){

4089

.func=open_and_parse_question,

4090

.epoll_fd=epoll_fd,

4091

.filename=filename,

4092

.question_filename=filename,

4093

.password=&password,

4094

.cancelled_filenames=task.cancelled_filenames,

4095

.current_time=&current_time,

4096

.mandos_client_exited=&mandos_client_exited,

4097

.password_is_read=&password_is_read,

4098

}));

4099

}

4100

4101

static void test_read_inotify_event_IN_DELETE(__attribute__((unused))

4102

test_fixture *fixture,

4103

__attribute__((unused))

4104

gconstpointer

4105

user_data){

4106

__attribute__((cleanup(cleanup_close)))

4107

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4108

g_assert_cmpint(epoll_fd, >=, 0);

4109

__attribute__((cleanup(string_set_clear)))

4110

string_set cancelled_filenames = {};

4111

const mono_microsecs current_time = 0;

4112

4113

int pipefds[2];

4114

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

4115

4116

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

4117

const size_t ievent_max_size = (sizeof(struct inotify_event)

4118

+ NAME_MAX + 1);

4119

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4120

char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];

4121

struct inotify_event *ievent = ((struct inotify_event *)

4122

ievent_buffer);

4123

4124

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

4125

ievent->mask = IN_DELETE;

4126

ievent->len = sizeof(dummy_file_name);

4127

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

4128

const size_t ievent_size = (sizeof(struct inotify_event)

4129

+ sizeof(dummy_file_name));

4130

g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),

4131

==, ievent_size);

4132

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

4133

4134

bool quit_now = false;

4135

buffer password = {};

4136

bool mandos_client_exited = false;

4137

bool password_is_read = false;

4138

__attribute__((cleanup(cleanup_queue)))

4139

task_queue *queue = create_queue();

4140

g_assert_nonnull(queue);

4141

4142

task_context task = {

4143

.func=read_inotify_event,

4144

.epoll_fd=epoll_fd,

4145

.fd=pipefds[0],

4146

.quit_now=&quit_now,

4147

.password=&password,

4148

.filename=strdup("/nonexistent"),

4149

.cancelled_filenames=&cancelled_filenames,

4150

.current_time=&current_time,

4151

.mandos_client_exited=&mandos_client_exited,

4152

.password_is_read=&password_is_read,

4153

};

4154

task.func(task, queue);

4155

g_assert_false(quit_now);

4156

g_assert_true(queue->next_run == 0);

4157

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

4158

4159

g_assert_nonnull(find_matching_task(queue, (task_context){

4160

.func=read_inotify_event,

4161

.epoll_fd=epoll_fd,

4162

.fd=pipefds[0],

4163

.quit_now=&quit_now,

4164

.password=&password,

4165

.filename=task.filename,

4166

.cancelled_filenames=&cancelled_filenames,

4167

.current_time=&current_time,

4168

.mandos_client_exited=&mandos_client_exited,

4169

.password_is_read=&password_is_read,

4170

}));

4171

4172

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4173

EPOLLIN | EPOLLRDHUP));

4174

4175

__attribute__((cleanup(cleanup_string)))

4176

char *filename = NULL;

4177

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

4178

dummy_file_name), >, 0);

4179

g_assert_nonnull(filename);

4180

g_assert_true(string_set_contains(*task.cancelled_filenames,

4181

filename));

4182

}

4183

4184

static void

4185

test_read_inotify_event_IN_CLOSE_WRITE_badname(__attribute__((unused))

4186

test_fixture *fixture,

4187

__attribute__((unused))

4188

gconstpointer

4189

user_data){

4190

__attribute__((cleanup(cleanup_close)))

4191

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4192

g_assert_cmpint(epoll_fd, >=, 0);

4193

const mono_microsecs current_time = 0;

4194

4195

int pipefds[2];

4196

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

4197

4198

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

4199

const size_t ievent_max_size = (sizeof(struct inotify_event)

4200

+ NAME_MAX + 1);

4201

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4202

char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];

4203

struct inotify_event *ievent = ((struct inotify_event *)

4204

ievent_buffer);

4205

4206

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

4207

ievent->mask = IN_CLOSE_WRITE;

4208

ievent->len = sizeof(dummy_file_name);

4209

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

4210

const size_t ievent_size = (sizeof(struct inotify_event)

4211

+ sizeof(dummy_file_name));

4212

g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),

4213

==, ievent_size);

4214

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

4215

4216

bool quit_now = false;

4217

buffer password = {};

4218

bool mandos_client_exited = false;

4219

bool password_is_read = false;

4220

__attribute__((cleanup(cleanup_queue)))

4221

task_queue *queue = create_queue();

4222

g_assert_nonnull(queue);

4223

4224

task_context task = {

4225

.func=read_inotify_event,

4226

.epoll_fd=epoll_fd,

4227

.fd=pipefds[0],

4228

.quit_now=&quit_now,

4229

.password=&password,

4230

.filename=strdup("/nonexistent"),

4231

.cancelled_filenames = &(string_set){},

4232

.notafter=0,

4233

.current_time=&current_time,

4234

.mandos_client_exited=&mandos_client_exited,

4235

.password_is_read=&password_is_read,

4236

};

4237

task.func(task, queue);

4238

g_assert_false(quit_now);

4239

g_assert_true(queue->next_run == 0);

4240

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

4241

4242

g_assert_nonnull(find_matching_task(queue, (task_context){

4243

.func=read_inotify_event,

4244

.epoll_fd=epoll_fd,

4245

.fd=pipefds[0],

4246

.quit_now=&quit_now,

4247

.password=&password,

4248

.filename=task.filename,

4249

.cancelled_filenames=task.cancelled_filenames,

4250

.current_time=&current_time,

4251

.mandos_client_exited=&mandos_client_exited,

4252

.password_is_read=&password_is_read,

4253

}));

4254

4255

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4256

EPOLLIN | EPOLLRDHUP));

4257

}

4258

4259

static void

4260

test_read_inotify_event_IN_MOVED_TO_badname(__attribute__((unused))

4261

test_fixture *fixture,

4262

__attribute__((unused))

4263

gconstpointer user_data){

4264

__attribute__((cleanup(cleanup_close)))

4265

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4266

g_assert_cmpint(epoll_fd, >=, 0);

4267

const mono_microsecs current_time = 0;

4268

4269

int pipefds[2];

4270

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

4271

4272

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

4273

const size_t ievent_max_size = (sizeof(struct inotify_event)

4274

+ NAME_MAX + 1);

4275

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4276

char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];

4277

struct inotify_event *ievent = ((struct inotify_event *)

4278

ievent_buffer);

4279

4280

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

4281

ievent->mask = IN_MOVED_TO;

4282

ievent->len = sizeof(dummy_file_name);

4283

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

4284

const size_t ievent_size = (sizeof(struct inotify_event)

4285

+ sizeof(dummy_file_name));

4286

g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),

4287

==, ievent_size);

4288

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

4289

4290

bool quit_now = false;

4291

buffer password = {};

4292

bool mandos_client_exited = false;

4293

bool password_is_read = false;

4294

__attribute__((cleanup(cleanup_queue)))

4295

task_queue *queue = create_queue();

4296

g_assert_nonnull(queue);

4297

4298

task_context task = {

4299

.func=read_inotify_event,

4300

.epoll_fd=epoll_fd,

4301

.fd=pipefds[0],

4302

.quit_now=&quit_now,

4303

.password=&password,

4304

.filename=strdup("/nonexistent"),

4305

.cancelled_filenames = &(string_set){},

4306

.notafter=0,

4307

.current_time=&current_time,

4308

.mandos_client_exited=&mandos_client_exited,

4309

.password_is_read=&password_is_read,

4310

};

4311

task.func(task, queue);

4312

g_assert_false(quit_now);

4313

g_assert_true(queue->next_run == 0);

4314

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

4315

4316

g_assert_nonnull(find_matching_task(queue, (task_context){

4317

.func=read_inotify_event,

4318

.epoll_fd=epoll_fd,

4319

.fd=pipefds[0],

4320

.quit_now=&quit_now,

4321

.password=&password,

4322

.filename=task.filename,

4323

.cancelled_filenames=task.cancelled_filenames,

4324

.current_time=&current_time,

4325

.mandos_client_exited=&mandos_client_exited,

4326

.password_is_read=&password_is_read,

4327

}));

4328

4329

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4330

EPOLLIN | EPOLLRDHUP));

4331

}

4332

4333

static

4334

void test_read_inotify_event_IN_DELETE_badname(__attribute__((unused))

4335

test_fixture *fixture,

4336

__attribute__((unused))

4337

gconstpointer

4338

user_data){

4339

__attribute__((cleanup(cleanup_close)))

4340

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4341

g_assert_cmpint(epoll_fd, >=, 0);

4342

__attribute__((cleanup(string_set_clear)))

4343

string_set cancelled_filenames = {};

4344

const mono_microsecs current_time = 0;

4345

4346

int pipefds[2];

4347

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

4348

4349

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

4350

const size_t ievent_max_size = (sizeof(struct inotify_event)

4351

+ NAME_MAX + 1);

4352

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4353

char ievent_buffer[sizeof(struct inotify_event) + NAME_MAX + 1];

4354

struct inotify_event *ievent = ((struct inotify_event *)

4355

ievent_buffer);

4356

4357

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

4358

ievent->mask = IN_DELETE;

4359

ievent->len = sizeof(dummy_file_name);

4360

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

4361

const size_t ievent_size = (sizeof(struct inotify_event)

4362

+ sizeof(dummy_file_name));

4363

g_assert_cmpint(write(pipefds[1], ievent_buffer, ievent_size),

4364

==, ievent_size);

4365

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

4366

4367

bool quit_now = false;

4368

buffer password = {};

4369

bool mandos_client_exited = false;

4370

bool password_is_read = false;

4371

__attribute__((cleanup(cleanup_queue)))

4372

task_queue *queue = create_queue();

4373

g_assert_nonnull(queue);

4374

4375

task_context task = {

4376

.func=read_inotify_event,

4377

.epoll_fd=epoll_fd,

4378

.fd=pipefds[0],

4379

.quit_now=&quit_now,

4380

.password=&password,

4381

.filename=strdup("/nonexistent"),

4382

.cancelled_filenames=&cancelled_filenames,

4383

.current_time=&current_time,

4384

.mandos_client_exited=&mandos_client_exited,

4385

.password_is_read=&password_is_read,

4386

};

4387

task.func(task, queue);

4388

g_assert_false(quit_now);

4389

g_assert_true(queue->next_run == 0);

4390

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

4391

4392

g_assert_nonnull(find_matching_task(queue, (task_context){

4393

.func=read_inotify_event,

4394

.epoll_fd=epoll_fd,

4395

.fd=pipefds[0],

4396

.quit_now=&quit_now,

4397

.password=&password,

4398

.filename=task.filename,

4399

.cancelled_filenames=&cancelled_filenames,

4400

.current_time=&current_time,

4401

.mandos_client_exited=&mandos_client_exited,

4402

.password_is_read=&password_is_read,

4403

}));

4404

4405

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4406

EPOLLIN | EPOLLRDHUP));

4407

4408

__attribute__((cleanup(cleanup_string)))

4409

char *filename = NULL;

4410

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

4411

dummy_file_name), >, 0);

4412

g_assert_nonnull(filename);

4413

g_assert_false(string_set_contains(cancelled_filenames, filename));

4414

}

4415

4416

static

4417

void test_open_and_parse_question_ENOENT(__attribute__((unused))

4418

test_fixture *fixture,

4419

__attribute__((unused))

4420

gconstpointer user_data){

4421

__attribute__((cleanup(cleanup_close)))

4422

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4423

g_assert_cmpint(epoll_fd, >=, 0);

4424

__attribute__((cleanup(string_set_clear)))

4425

string_set cancelled_filenames = {};

4426

bool mandos_client_exited = false;

4427

bool password_is_read = false;

4428

__attribute__((cleanup(cleanup_queue)))

4429

task_queue *queue = create_queue();

4430

g_assert_nonnull(queue);

4431

4432

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

4433

g_assert_nonnull(filename);

4434

task_context task = {

4435

.func=open_and_parse_question,

4436

.question_filename=filename,

4437

.epoll_fd=epoll_fd,

4438

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

4439

.filename=filename,

4440

.cancelled_filenames=&cancelled_filenames,

4441

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

4442

.mandos_client_exited=&mandos_client_exited,

4443

.password_is_read=&password_is_read,

4444

};

4445

task.func(task, queue);

4446

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

4447

}

4448

4449

static void test_open_and_parse_question_EIO(__attribute__((unused))

4450

test_fixture *fixture,

4451

__attribute__((unused))

4452

gconstpointer user_data){

4453

__attribute__((cleanup(cleanup_close)))

4454

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4455

g_assert_cmpint(epoll_fd, >=, 0);

4456

__attribute__((cleanup(string_set_clear)))

4457

string_set cancelled_filenames = {};

4458

buffer password = {};

4459

bool mandos_client_exited = false;

4460

bool password_is_read = false;

4461

__attribute__((cleanup(cleanup_queue)))

4462

task_queue *queue = create_queue();

4463

g_assert_nonnull(queue);

4464

const mono_microsecs current_time = 0;

4465

4466

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

4467

task_context task = {

4468

.func=open_and_parse_question,

4469

.question_filename=filename,

4470

.epoll_fd=epoll_fd,

4471

.password=&password,

4472

.filename=filename,

4473

.cancelled_filenames=&cancelled_filenames,

4474

.current_time=&current_time,

4475

.mandos_client_exited=&mandos_client_exited,

4476

.password_is_read=&password_is_read,

4477

};

4478

run_task_with_stderr_to_dev_null(task, queue);

4479

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

4480

}

4481

4482

static void

4483

test_open_and_parse_question_parse_error(__attribute__((unused))

4484

test_fixture *fixture,

4485

__attribute__((unused))

4486

gconstpointer user_data){

4487

__attribute__((cleanup(cleanup_close)))

4488

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4489

g_assert_cmpint(epoll_fd, >=, 0);

4490

__attribute__((cleanup(string_set_clear)))

4491

string_set cancelled_filenames = {};

4492

__attribute__((cleanup(cleanup_queue)))

4493

task_queue *queue = create_queue();

4494

g_assert_nonnull(queue);

4495

4496

__attribute__((cleanup(cleanup_string)))

4497

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

4498

g_assert_nonnull(tempfilename);

4499

int tempfile = mkostemp(tempfilename, O_CLOEXEC);

4500

g_assert_cmpint(tempfile, >, 0);

4501

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

4502

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

4503

==, sizeof(bad_data));

4504

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

4505

4506

char *const filename = strdup(tempfilename);

4507

g_assert_nonnull(filename);

4508

task_context task = {

4509

.func=open_and_parse_question,

4510

.question_filename=filename,

4511

.epoll_fd=epoll_fd,

4512

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

4513

.filename=filename,

4514

.cancelled_filenames=&cancelled_filenames,

4515

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

4516

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

4517

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

4518

};

4519

run_task_with_stderr_to_dev_null(task, queue);

4520

4521

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

4522

4523

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

4524

}

4525

4526

static

4527

void test_open_and_parse_question_nosocket(__attribute__((unused))

4528

test_fixture *fixture,

4529

__attribute__((unused))

4530

gconstpointer user_data){

4531

__attribute__((cleanup(cleanup_close)))

4532

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4533

g_assert_cmpint(epoll_fd, >=, 0);

4534

__attribute__((cleanup(string_set_clear)))

4535

string_set cancelled_filenames = {};

4536

__attribute__((cleanup(cleanup_queue)))

4537

task_queue *queue = create_queue();

4538

g_assert_nonnull(queue);

4539

4540

__attribute__((cleanup(cleanup_string)))

4541

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

4542

g_assert_nonnull(tempfilename);

4543

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4544

g_assert_cmpint(questionfile, >, 0);

4545

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

4546

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

4547

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

4548

4549

char *const filename = strdup(tempfilename);

4550

g_assert_nonnull(filename);

4551

task_context task = {

4552

.func=open_and_parse_question,

4553

.question_filename=filename,

4554

.epoll_fd=epoll_fd,

4555

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

4556

.filename=filename,

4557

.cancelled_filenames=&cancelled_filenames,

4558

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

4559

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

4560

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

4561

};

4562

run_task_with_stderr_to_dev_null(task, queue);

4563

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

4564

4565

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

4566

}

4567

4568

static

4569

void test_open_and_parse_question_badsocket(__attribute__((unused))

4570

test_fixture *fixture,

4571

__attribute__((unused))

4572

gconstpointer user_data){

4573

__attribute__((cleanup(cleanup_close)))

4574

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4575

g_assert_cmpint(epoll_fd, >=, 0);

4576

__attribute__((cleanup(string_set_clear)))

4577

string_set cancelled_filenames = {};

4578

__attribute__((cleanup(cleanup_queue)))

4579

task_queue *queue = create_queue();

4580

g_assert_nonnull(queue);

4581

4582

__attribute__((cleanup(cleanup_string)))

4583

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

4584

g_assert_nonnull(tempfilename);

4585

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4586

g_assert_cmpint(questionfile, >, 0);

4587

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

4588

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

4589

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

4590

4591

char *const filename = strdup(tempfilename);

4592

g_assert_nonnull(filename);

4593

task_context task = {

4594

.func=open_and_parse_question,

4595

.question_filename=filename,

4596

.epoll_fd=epoll_fd,

4597

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

4598

.filename=filename,

4599

.cancelled_filenames=&cancelled_filenames,

4600

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

4601

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

4602

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

4603

};

4604

run_task_with_stderr_to_dev_null(task, queue);

4605

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

4606

4607

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

4608

}

4609

4610

static

4611

void test_open_and_parse_question_nopid(__attribute__((unused))

4612

test_fixture *fixture,

4613

__attribute__((unused))

4614

gconstpointer user_data){

4615

__attribute__((cleanup(cleanup_close)))

4616

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4617

g_assert_cmpint(epoll_fd, >=, 0);

4618

__attribute__((cleanup(string_set_clear)))

4619

string_set cancelled_filenames = {};

4620

__attribute__((cleanup(cleanup_queue)))

4621

task_queue *queue = create_queue();

4622

g_assert_nonnull(queue);

4623

4624

__attribute__((cleanup(cleanup_string)))

4625

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

4626

g_assert_nonnull(tempfilename);

4627

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4628

g_assert_cmpint(questionfile, >, 0);

4629

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

4630

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

4631

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

4632

4633

char *const filename = strdup(tempfilename);

4634

g_assert_nonnull(filename);

4635

task_context task = {

4636

.func=open_and_parse_question,

4637

.question_filename=filename,

4638

.epoll_fd=epoll_fd,

4639

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

4640

.filename=filename,

4641

.cancelled_filenames=&cancelled_filenames,

4642

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

4643

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

4644

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

4645

};

4646

run_task_with_stderr_to_dev_null(task, queue);

4647

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

4648

4649

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

4650

}

4651

4652

static

4653

void test_open_and_parse_question_badpid(__attribute__((unused))

4654

test_fixture *fixture,

4655

__attribute__((unused))

4656

gconstpointer user_data){

4657

__attribute__((cleanup(cleanup_close)))

4658

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4659

g_assert_cmpint(epoll_fd, >=, 0);

4660

__attribute__((cleanup(string_set_clear)))

4661

string_set cancelled_filenames = {};

4662

__attribute__((cleanup(cleanup_queue)))

4663

task_queue *queue = create_queue();

4664

g_assert_nonnull(queue);

4665

4666

__attribute__((cleanup(cleanup_string)))

4667

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

4668

g_assert_nonnull(tempfilename);

4669

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4670

g_assert_cmpint(questionfile, >, 0);

4671

FILE *qf = fdopen(questionfile, "w");

4672

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=\n"),

4673

>, 0);

4674

g_assert_cmpint(fclose(qf), ==, 0);

4675

4676

char *const filename = strdup(tempfilename);

4677

g_assert_nonnull(filename);

4678

task_context task = {

4679

.func=open_and_parse_question,

4680

.question_filename=filename,

4681

.epoll_fd=epoll_fd,

4682

.password=(buffer[]){{}},

4683

.filename=filename,

4684

.cancelled_filenames=&cancelled_filenames,

4685

.current_time=(mono_microsecs[]){0},

4686

.mandos_client_exited=(bool[]){false},

4687

.password_is_read=(bool[]){false},

4688

};

4689

run_task_with_stderr_to_dev_null(task, queue);

4690

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4691

4692

g_assert_cmpint(unlink(tempfilename), ==, 0);

4693

}

4694

4695

static void

4696

test_open_and_parse_question_noexist_pid(__attribute__((unused))

4697

test_fixture *fixture,

4698

__attribute__((unused))

4699

gconstpointer user_data){

4700

__attribute__((cleanup(cleanup_close)))

4701

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4702

g_assert_cmpint(epoll_fd, >=, 0);

4703

__attribute__((cleanup(string_set_clear)))

4704

string_set cancelled_filenames = {};

4705

buffer password = {};

4706

bool mandos_client_exited = false;

4707

bool password_is_read = false;

4708

__attribute__((cleanup(cleanup_queue)))

4709

task_queue *queue = create_queue();

4710

g_assert_nonnull(queue);

4711

const mono_microsecs current_time = 0;

4712

4713

/* Find value of sysctl kernel.pid_max */

4714

uintmax_t pid_max = 0;

4715

FILE *sysctl_pid_max = fopen("/proc/sys/kernel/pid_max", "r");

4716

g_assert_nonnull(sysctl_pid_max);

4717

g_assert_cmpint(fscanf(sysctl_pid_max, "%" PRIuMAX, &pid_max),

4718

==, 1);

4719

g_assert_cmpint(fclose(sysctl_pid_max), ==, 0);

4720

4721

pid_t nonexisting_pid = ((pid_t)pid_max)+1;

4722

g_assert_true(nonexisting_pid > 0); /* Overflow check */

4723

4724

__attribute__((cleanup(cleanup_string)))

4725

char *tempfilename = strdup("/tmp/mandosXXXXXX");

4726

g_assert_nonnull(tempfilename);

4727

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4728

g_assert_cmpint(questionfile, >, 0);

4729

FILE *qf = fdopen(questionfile, "w");

4730

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

4731

PRIuMAX"\n", (uintmax_t)nonexisting_pid),

4732

>, 0);

4733

g_assert_cmpint(fclose(qf), ==, 0);

4734

4735

char *const question_filename = strdup(tempfilename);

4736

g_assert_nonnull(question_filename);

4737

task_context task = {

4738

.func=open_and_parse_question,

4739

.question_filename=question_filename,

4740

.epoll_fd=epoll_fd,

4741

.password=&password,

4742

.filename=question_filename,

4743

.cancelled_filenames=&cancelled_filenames,

4744

.current_time=&current_time,

4745

.mandos_client_exited=&mandos_client_exited,

4746

.password_is_read=&password_is_read,

4747

};

4748

run_task_with_stderr_to_dev_null(task, queue);

4749

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4750

4751

g_assert_cmpint(unlink(tempfilename), ==, 0);

4752

}

4753

4754

static void

4755

test_open_and_parse_question_no_notafter(__attribute__((unused))

4756

test_fixture *fixture,

4757

__attribute__((unused))

4758

gconstpointer user_data){

4759

__attribute__((cleanup(cleanup_close)))

4760

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4761

g_assert_cmpint(epoll_fd, >=, 0);

4762

__attribute__((cleanup(string_set_clear)))

4763

string_set cancelled_filenames = {};

4764

buffer password = {};

4765

bool mandos_client_exited = false;

4766

bool password_is_read = false;

4767

__attribute__((cleanup(cleanup_queue)))

4768

task_queue *queue = create_queue();

4769

g_assert_nonnull(queue);

4770

const mono_microsecs current_time = 0;

4771

4772

__attribute__((cleanup(cleanup_string)))

4773

char *tempfilename = strdup("/tmp/mandosXXXXXX");

4774

g_assert_nonnull(tempfilename);

4775

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4776

g_assert_cmpint(questionfile, >, 0);

4777

FILE *qf = fdopen(questionfile, "w");

4778

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

4779

PRIuMAX "\n", (uintmax_t)getpid()), >, 0);

4780

g_assert_cmpint(fclose(qf), ==, 0);

4781

4782

char *const filename = strdup(tempfilename);

4783

g_assert_nonnull(filename);

4784

task_context task = {

4785

.func=open_and_parse_question,

4786

.question_filename=filename,

4787

.epoll_fd=epoll_fd,

4788

.password=&password,

4789

.filename=filename,

4790

.cancelled_filenames=&cancelled_filenames,

4791

.current_time=&current_time,

4792

.mandos_client_exited=&mandos_client_exited,

4793

.password_is_read=&password_is_read,

4794

};

4795

task.func(task, queue);

4796

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

4797

4798

__attribute__((cleanup(cleanup_string)))

4799

char *socket_filename = strdup("/nonexistent");

4800

g_assert_nonnull(socket_filename);

4801

g_assert_nonnull(find_matching_task(queue, (task_context){

4802

.func=connect_question_socket,

4803

.question_filename=tempfilename,

4804

.filename=socket_filename,

4805

.epoll_fd=epoll_fd,

4806

.password=&password,

4807

.current_time=&current_time,

4808

.mandos_client_exited=&mandos_client_exited,

4809

.password_is_read=&password_is_read,

4810

}));

4811

4812

g_assert_true(queue->next_run != 0);

4813

4814

g_assert_cmpint(unlink(tempfilename), ==, 0);

4815

}

4816

4817

static void

4818

test_open_and_parse_question_bad_notafter(__attribute__((unused))

4819

test_fixture *fixture,

4820

__attribute__((unused))

4821

gconstpointer user_data){

4822

__attribute__((cleanup(cleanup_close)))

4823

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4824

g_assert_cmpint(epoll_fd, >=, 0);

4825

__attribute__((cleanup(string_set_clear)))

4826

string_set cancelled_filenames = {};

4827

buffer password = {};

4828

bool mandos_client_exited = false;

4829

bool password_is_read = false;

4830

__attribute__((cleanup(cleanup_queue)))

4831

task_queue *queue = create_queue();

4832

g_assert_nonnull(queue);

4833

const mono_microsecs current_time = 0;

4834

4835

__attribute__((cleanup(cleanup_string)))

4836

char *tempfilename = strdup("/tmp/mandosXXXXXX");

4837

g_assert_nonnull(tempfilename);

4838

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4839

g_assert_cmpint(questionfile, >, 0);

4840

FILE *qf = fdopen(questionfile, "w");

4841

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

4842

PRIuMAX "\nNotAfter=\n",

4843

(uintmax_t)getpid()), >, 0);

4844

g_assert_cmpint(fclose(qf), ==, 0);

4845

4846

char *const filename = strdup(tempfilename);

4847

g_assert_nonnull(filename);

4848

task_context task = {

4849

.func=open_and_parse_question,

4850

.question_filename=filename,

4851

.epoll_fd=epoll_fd,

4852

.password=&password,

4853

.filename=filename,

4854

.cancelled_filenames=&cancelled_filenames,

4855

.current_time=&current_time,

4856

.mandos_client_exited=&mandos_client_exited,

4857

.password_is_read=&password_is_read,

4858

};

4859

run_task_with_stderr_to_dev_null(task, queue);

4860

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

4861

4862

__attribute__((cleanup(cleanup_string)))

4863

char *socket_filename = strdup("/nonexistent");

4864

g_assert_nonnull(find_matching_task(queue, (task_context){

4865

.func=connect_question_socket,

4866

.question_filename=tempfilename,

4867

.filename=socket_filename,

4868

.epoll_fd=epoll_fd,

4869

.password=&password,

4870

.current_time=&current_time,

4871

.mandos_client_exited=&mandos_client_exited,

4872

.password_is_read=&password_is_read,

4873

}));

4874

g_assert_true(queue->next_run != 0);

4875

4876

g_assert_cmpint(unlink(tempfilename), ==, 0);

4877

}

4878

4879

static

4880

void assert_open_and_parse_question_with_notafter(const mono_microsecs

4881

current_time,

4882

const mono_microsecs

4883

notafter,

4884

const mono_microsecs

4885

next_queue_run){

4886

__attribute__((cleanup(cleanup_close)))

4887

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4888

g_assert_cmpint(epoll_fd, >=, 0);

4889

__attribute__((cleanup(string_set_clear)))

4890

string_set cancelled_filenames = {};

4891

buffer password = {};

4892

bool mandos_client_exited = false;

4893

bool password_is_read = false;

4894

__attribute__((cleanup(cleanup_queue)))

4895

task_queue *queue = create_queue();

4896

g_assert_nonnull(queue);

4897

queue->next_run = next_queue_run;

4898

4899

__attribute__((cleanup(cleanup_string)))

4900

char *tempfilename = strdup("/tmp/mandosXXXXXX");

4901

g_assert_nonnull(tempfilename);

4902

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

4903

g_assert_cmpint(questionfile, >, 0);

4904

FILE *qf = fdopen(questionfile, "w");

4905

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

4906

PRIuMAX "\nNotAfter=%" PRIuMAX "\n",

4907

(uintmax_t)getpid(), notafter), >, 0);

4908

g_assert_cmpint(fclose(qf), ==, 0);

4909

4910

char *const filename = strdup(tempfilename);

4911

g_assert_nonnull(filename);

4912

task_context task = {

4913

.func=open_and_parse_question,

4914

.question_filename=filename,

4915

.epoll_fd=epoll_fd,

4916

.password=&password,

4917

.filename=filename,

4918

.cancelled_filenames=&cancelled_filenames,

4919

.current_time=&current_time,

4920

.mandos_client_exited=&mandos_client_exited,

4921

.password_is_read=&password_is_read,

4922

};

4923

task.func(task, queue);

4924

4925

if(queue->length >= 1){

4926

__attribute__((cleanup(cleanup_string)))

4927

char *socket_filename = strdup("/nonexistent");

4928

g_assert_nonnull(find_matching_task(queue, (task_context){

4929

.func=connect_question_socket,

4930

.filename=socket_filename,

4931

.epoll_fd=epoll_fd,

4932

.password=&password,

4933

.current_time=&current_time,

4934

.cancelled_filenames=&cancelled_filenames,

4935

.mandos_client_exited=&mandos_client_exited,

4936

.password_is_read=&password_is_read,

4937

}));

4938

g_assert_true(queue->next_run != 0);

4939

}

4940

4941

if(notafter == 0){

4942

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

4943

} else if(current_time >= notafter) {

4944

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4945

} else {

4946

g_assert_nonnull(find_matching_task(queue, (task_context){

4947

.func=cancel_old_question,

4948

.question_filename=tempfilename,

4949

.filename=tempfilename,

4950

.notafter=notafter,

4951

.cancelled_filenames=&cancelled_filenames,

4952

.current_time=&current_time,

4953

}));

4954

}

4955

g_assert_true(queue->next_run == 1);

4956

4957

g_assert_cmpint(unlink(tempfilename), ==, 0);

4958

}

4959

4960

static void

4961

test_open_and_parse_question_notafter_0(__attribute__((unused))

4962

test_fixture *fixture,

4963

__attribute__((unused))

4964

gconstpointer user_data){

4965

/* current_time, notafter, next_queue_run */

4966

assert_open_and_parse_question_with_notafter(0, 0, 0);

4967

}

4968

4969

static void

4970

test_open_and_parse_question_notafter_1(__attribute__((unused))

4971

test_fixture *fixture,

4972

__attribute__((unused))

4973

gconstpointer user_data){

4974

/* current_time, notafter, next_queue_run */

4975

assert_open_and_parse_question_with_notafter(0, 1, 0);

4976

}

4977

4978

static void

4979

test_open_and_parse_question_notafter_1_1(__attribute__((unused))

4980

test_fixture *fixture,

4981

__attribute__((unused))

4982

gconstpointer user_data){

4983

/* current_time, notafter, next_queue_run */

4984

assert_open_and_parse_question_with_notafter(0, 1, 1);

4985

}

4986

4987

static void

4988

test_open_and_parse_question_notafter_1_2(__attribute__((unused))

4989

test_fixture *fixture,

4990

__attribute__((unused))

4991

gconstpointer user_data){

4992

/* current_time, notafter, next_queue_run */

4993

assert_open_and_parse_question_with_notafter(0, 1, 2);

4994

}

4995

4996

static void

4997

test_open_and_parse_question_equal_notafter(__attribute__((unused))

4998

test_fixture *fixture,

4999

__attribute__((unused))

5000

gconstpointer user_data){

5001

/* current_time, notafter, next_queue_run */

5002

assert_open_and_parse_question_with_notafter(1, 1, 0);

5003

}

5004

5005

static void

5006

test_open_and_parse_question_late_notafter(__attribute__((unused))

5007

test_fixture *fixture,

5008

__attribute__((unused))

5009

gconstpointer user_data){

5010

/* current_time, notafter, next_queue_run */

5011

assert_open_and_parse_question_with_notafter(2, 1, 0);

5012

}

5013

5014

static void assert_cancel_old_question_param(const mono_microsecs

5015

next_queue_run,

5016

const mono_microsecs

5017

notafter,

5018

const mono_microsecs

5019

current_time,

5020

const mono_microsecs

5021

next_set_to){

5022

__attribute__((cleanup(string_set_clear)))

5023

string_set cancelled_filenames = {};

5024

__attribute__((cleanup(cleanup_queue)))

5025

task_queue *queue = create_queue();

5026

g_assert_nonnull(queue);

5027

queue->next_run = next_queue_run;

5028

5029

char *const question_filename = strdup("/nonexistent");

5030

g_assert_nonnull(question_filename);

5031

task_context task = {

5032

.func=cancel_old_question,

5033

.question_filename=question_filename,

5034

.filename=question_filename,

5035

.notafter=notafter,

5036

.cancelled_filenames=&cancelled_filenames,

5037

.current_time=&current_time,

5038

};

5039

task.func(task, queue);

5040

5041

if(current_time >= notafter){

5042

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5043

g_assert_true(string_set_contains(cancelled_filenames,

5044

"/nonexistent"));

5045

} else {

5046

g_assert_nonnull(find_matching_task(queue, (task_context){

5047

.func=cancel_old_question,

5048

.question_filename=question_filename,

5049

.filename=question_filename,

5050

.notafter=notafter,

5051

.cancelled_filenames=&cancelled_filenames,

5052

.current_time=&current_time,

5053

}));

5054

5055

g_assert_false(string_set_contains(cancelled_filenames,

5056

question_filename));

5057

}

5058

g_assert_cmpuint((unsigned int)queue->next_run, ==,

5059

(unsigned int)next_set_to);

5060

}

5061

5062

static void test_cancel_old_question_0_1_2(__attribute__((unused))

5063

test_fixture *fixture,

5064

__attribute__((unused))

5065

gconstpointer user_data){

5066

/* next_queue_run unset,

5067

cancellation should happen because time has come,

5068

next_queue_run should be unchanged */

5069

/* next_queue_run, notafter, current_time, next_set_to */

5070

assert_cancel_old_question_param(0, 1, 2, 0);

5071

}

5072

5073

static void test_cancel_old_question_0_2_1(__attribute__((unused))

5074

test_fixture *fixture,

5075

__attribute__((unused))

5076

gconstpointer user_data){

5077

/* If next_queue_run is 0, meaning unset, and notafter is 2,

5078

and current_time is not yet notafter or greater,

5079

update value of next_queue_run to value of notafter */

5080

/* next_queue_run, notafter, current_time, next_set_to */

5081

assert_cancel_old_question_param(0, 2, 1, 2);

5082

}

5083

5084

static void test_cancel_old_question_1_2_3(__attribute__((unused))

5085

test_fixture *fixture,

5086

__attribute__((unused))

5087

gconstpointer user_data){

5088

/* next_queue_run 1,

5089

cancellation should happen because time has come,

5090

next_queue_run should be unchanged */

5091

/* next_queue_run, notafter, current_time, next_set_to */

5092

assert_cancel_old_question_param(1, 2, 3, 1);

5093

}

5094

5095

static void test_cancel_old_question_1_3_2(__attribute__((unused))

5096

test_fixture *fixture,

5097

__attribute__((unused))

5098

gconstpointer user_data){

5099

/* If next_queue_run is set,

5100

and current_time is not yet notafter or greater,

5101

and notafter is larger than next_queue_run

5102

next_queue_run should be unchanged */

5103

/* next_queue_run, notafter, current_time, next_set_to */

5104

assert_cancel_old_question_param(1, 3, 2, 1);

5105

}

5106

5107

static void test_cancel_old_question_2_1_3(__attribute__((unused))

5108

test_fixture *fixture,

5109

__attribute__((unused))

5110

gconstpointer user_data){

5111

/* next_queue_run 2,

5112

cancellation should happen because time has come,

5113

next_queue_run should be unchanged */

5114

/* next_queue_run, notafter, current_time, next_set_to */

5115

assert_cancel_old_question_param(2, 1, 3, 2);

5116

}

5117

5118

static void test_cancel_old_question_2_3_1(__attribute__((unused))

5119

test_fixture *fixture,

5120

__attribute__((unused))

5121

gconstpointer user_data){

5122

/* If next_queue_run is set,

5123

and current_time is not yet notafter or greater,

5124

and notafter is larger than next_queue_run

5125

next_queue_run should be unchanged */

5126

/* next_queue_run, notafter, current_time, next_set_to */

5127

assert_cancel_old_question_param(2, 3, 1, 2);

5128

}

5129

5130

static void test_cancel_old_question_3_1_2(__attribute__((unused))

5131

test_fixture *fixture,

5132

__attribute__((unused))

5133

gconstpointer user_data){

5134

/* next_queue_run 3,

5135

cancellation should happen because time has come,

5136

next_queue_run should be unchanged */

5137

/* next_queue_run, notafter, current_time, next_set_to */

5138

assert_cancel_old_question_param(3, 1, 2, 3);

5139

}

5140

5141

static void test_cancel_old_question_3_2_1(__attribute__((unused))

5142

test_fixture *fixture,

5143

__attribute__((unused))

5144

gconstpointer user_data){

5145

/* If next_queue_run is set,

5146

and current_time is not yet notafter or greater,

5147

and notafter is smaller than next_queue_run

5148

update value of next_queue_run to value of notafter */

5149

/* next_queue_run, notafter, current_time, next_set_to */

5150

assert_cancel_old_question_param(3, 2, 1, 2);

5151

}

5152

5153

static void

5154

test_connect_question_socket_name_too_long(__attribute__((unused))

5155

test_fixture *fixture,

5156

__attribute__((unused))

5157

gconstpointer user_data){

5158

__attribute__((cleanup(cleanup_close)))

5159

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5160

g_assert_cmpint(epoll_fd, >=, 0);

5161

const char question_filename[] = "/nonexistent/question";

5162

__attribute__((cleanup(string_set_clear)))

5163

string_set cancelled_filenames = {};

5164

__attribute__((cleanup(cleanup_queue)))

5165

task_queue *queue = create_queue();

5166

g_assert_nonnull(queue);

5167

__attribute__((cleanup(cleanup_string)))

5168

char *tempdir = make_temporary_directory();

5169

g_assert_nonnull(tempdir);

5170

struct sockaddr_un unix_socket = { .sun_family=AF_LOCAL };

5171

char socket_name[sizeof(unix_socket.sun_path)];

5172

memset(socket_name, 'x', sizeof(socket_name));

5173

socket_name[sizeof(socket_name)-1] = '\0';

5174

char *filename = NULL;

5175

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5176

>, 0);

5177

g_assert_nonnull(filename);

5178

5179

task_context task = {

5180

.func=connect_question_socket,

5181

.question_filename=strdup(question_filename),

5182

.epoll_fd=epoll_fd,

5183

.password=(buffer[]){{}},

5184

.filename=filename,

5185

.cancelled_filenames=&cancelled_filenames,

5186

.mandos_client_exited=(bool[]){false},

5187

.password_is_read=(bool[]){false},

5188

.current_time=(mono_microsecs[]){0},

5189

};

5190

g_assert_nonnull(task.question_filename);

5191

run_task_with_stderr_to_dev_null(task, queue);

5192

5193

g_assert_true(string_set_contains(cancelled_filenames,

5194

question_filename));

5195

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5196

g_assert_true(queue->next_run == 0);

5197

5198

g_assert_cmpint(rmdir(tempdir), ==, 0);

5199

}

5200

5201

static

5202

void test_connect_question_socket_connect_fail(__attribute__((unused))

5203

test_fixture *fixture,

5204

__attribute__((unused))

5205

gconstpointer

5206

user_data){

5207

__attribute__((cleanup(cleanup_close)))

5208

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5209

g_assert_cmpint(epoll_fd, >=, 0);

5210

const char question_filename[] = "/nonexistent/question";

5211

__attribute__((cleanup(string_set_clear)))

5212

string_set cancelled_filenames = {};

5213

const mono_microsecs current_time = 3;

5214

__attribute__((cleanup(cleanup_queue)))

5215

task_queue *queue = create_queue();

5216

g_assert_nonnull(queue);

5217

__attribute__((cleanup(cleanup_string)))

5218

char *tempdir = make_temporary_directory();

5219

g_assert_nonnull(tempdir);

5220

char socket_name[] = "nonexistent";

5221

char *filename = NULL;

5222

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5223

>, 0);

5224

g_assert_nonnull(filename);

5225

5226

task_context task = {

5227

.func=connect_question_socket,

5228

.question_filename=strdup(question_filename),

5229

.epoll_fd=epoll_fd,

5230

.password=(buffer[]){{}},

5231

.filename=filename,

5232

.cancelled_filenames=&cancelled_filenames,

5233

.mandos_client_exited=(bool[]){false},

5234

.password_is_read=(bool[]){false},

5235

.current_time=&current_time,

5236

};

5237

g_assert_nonnull(task.question_filename);

5238

run_task_with_stderr_to_dev_null(task, queue);

5239

5240

g_assert_nonnull(find_matching_task(queue, task));

5241

5242

g_assert_false(string_set_contains(cancelled_filenames,

5243

question_filename));

5244

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5245

g_assert_true(queue->next_run == 1000000 + current_time);

5246

5247

g_assert_cmpint(rmdir(tempdir), ==, 0);

5248

}

5249

5250

static

5251

void test_connect_question_socket_bad_epoll(__attribute__((unused))

5252

test_fixture *fixture,

5253

__attribute__((unused))

5254

gconstpointer user_data){

5255

__attribute__((cleanup(cleanup_close)))

5256

const int epoll_fd = open("/dev/null", O_WRONLY | O_CLOEXEC);

5257

__attribute__((cleanup(cleanup_string)))

5258

char *const question_filename = strdup("/nonexistent/question");

5259

g_assert_nonnull(question_filename);

5260

__attribute__((cleanup(string_set_clear)))

5261

string_set cancelled_filenames = {};

5262

const mono_microsecs current_time = 5;

5263

__attribute__((cleanup(cleanup_queue)))

5264

task_queue *queue = create_queue();

5265

g_assert_nonnull(queue);

5266

__attribute__((cleanup(cleanup_string)))

5267

char *tempdir = make_temporary_directory();

5268

g_assert_nonnull(tempdir);

5269

__attribute__((cleanup(cleanup_close)))

5270

const int sock_fd = socket(PF_LOCAL, SOCK_DGRAM

5271

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

5272

g_assert_cmpint(sock_fd, >=, 0);

5273

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

5274

const char socket_name[] = "socket_name";

5275

__attribute__((cleanup(cleanup_string)))

5276

char *filename = NULL;

5277

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5278

>, 0);

5279

g_assert_nonnull(filename);

5280

g_assert_cmpint((int)strlen(filename), <,

5281

(int)sizeof(sock_name.sun_path));

5282

strncpy(sock_name.sun_path, filename, sizeof(sock_name.sun_path));

5283

sock_name.sun_path[sizeof(sock_name.sun_path)-1] = '\0';

5284

g_assert_cmpint((int)bind(sock_fd, (struct sockaddr *)&sock_name,

5285

(socklen_t)SUN_LEN(&sock_name)), >=, 0);

5286

task_context task = {

5287

.func=connect_question_socket,

5288

.question_filename=strdup(question_filename),

5289

.epoll_fd=epoll_fd,

5290

.password=(buffer[]){{}},

5291

.filename=strdup(filename),

5292

.cancelled_filenames=&cancelled_filenames,

5293

.mandos_client_exited=(bool[]){false},

5294

.password_is_read=(bool[]){false},

5295

.current_time=&current_time,

5296

};

5297

g_assert_nonnull(task.question_filename);

5298

run_task_with_stderr_to_dev_null(task, queue);

5299

5300

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5301

const task_context *const added_task

5302

= find_matching_task(queue, task);

5303

g_assert_nonnull(added_task);

5304

g_assert_true(queue->next_run == 1000000 + current_time);

5305

5306

g_assert_cmpint(unlink(filename), ==, 0);

5307

g_assert_cmpint(rmdir(tempdir), ==, 0);

5308

}

5309

5310

static

5311

void test_connect_question_socket_usable(__attribute__((unused))

5312

test_fixture *fixture,

5313

__attribute__((unused))

5314

gconstpointer user_data){

5315

__attribute__((cleanup(cleanup_close)))

5316

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5317

g_assert_cmpint(epoll_fd, >=, 0);

5318

__attribute__((cleanup(cleanup_string)))

5319

char *const question_filename = strdup("/nonexistent/question");

5320

g_assert_nonnull(question_filename);

5321

__attribute__((cleanup(string_set_clear)))

5322

string_set cancelled_filenames = {};

5323

buffer password = {};

5324

bool mandos_client_exited = false;

5325

bool password_is_read = false;

5326

const mono_microsecs current_time = 0;

5327

__attribute__((cleanup(cleanup_queue)))

5328

task_queue *queue = create_queue();

5329

g_assert_nonnull(queue);

5330

__attribute__((cleanup(cleanup_string)))

5331

char *tempdir = make_temporary_directory();

5332

g_assert_nonnull(tempdir);

5333

__attribute__((cleanup(cleanup_close)))

5334

const int sock_fd = socket(PF_LOCAL, SOCK_DGRAM

5335

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

5336

g_assert_cmpint(sock_fd, >=, 0);

5337

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

5338

const char socket_name[] = "socket_name";

5339

__attribute__((cleanup(cleanup_string)))

5340

char *filename = NULL;

5341

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5342

>, 0);

5343

g_assert_nonnull(filename);

5344

g_assert_cmpint((int)strlen(filename), <,

5345

(int)sizeof(sock_name.sun_path));

5346

strncpy(sock_name.sun_path, filename, sizeof(sock_name.sun_path));

5347

sock_name.sun_path[sizeof(sock_name.sun_path)-1] = '\0';

5348

g_assert_cmpint((int)bind(sock_fd, (struct sockaddr *)&sock_name,

5349

(socklen_t)SUN_LEN(&sock_name)), >=, 0);

5350

task_context task = {

5351

.func=connect_question_socket,

5352

.question_filename=strdup(question_filename),

5353

.epoll_fd=epoll_fd,

5354

.password=&password,

5355

.filename=strdup(filename),

5356

.cancelled_filenames=&cancelled_filenames,

5357

.mandos_client_exited=&mandos_client_exited,

5358

.password_is_read=&password_is_read,

5359

.current_time=&current_time,

5360

};

5361

g_assert_nonnull(task.question_filename);

5362

task.func(task, queue);

5363

5364

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5365

const task_context *const added_task

5366

= find_matching_task(queue, (task_context){

5367

.func=send_password_to_socket,

5368

.question_filename=question_filename,

5369

.filename=filename,

5370

.epoll_fd=epoll_fd,

5371

.password=&password,

5372

.cancelled_filenames=&cancelled_filenames,

5373

.mandos_client_exited=&mandos_client_exited,

5374

.password_is_read=&password_is_read,

5375

.current_time=&current_time,

5376

});

5377

g_assert_nonnull(added_task);

5378

g_assert_cmpint(added_task->fd, >, 0);

5379

5380

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5381

EPOLLOUT));

5382

5383

const int fd = added_task->fd;

5384

g_assert_cmpint(fd, >, 0);

5385

g_assert_true(fd_has_cloexec_and_nonblock(fd));

5386

5387

/* write to fd */

5388

char write_data[PIPE_BUF];

5389

{

5390

/* Construct test password buffer */

5391

/* Start with + since that is what the real procotol uses */

5392

write_data[0] = '+';

5393

/* Set a special character at string end just to mark the end */

5394

write_data[sizeof(write_data)-2] = 'y';

5395

/* Set NUL at buffer end, as suggested by the protocol */

5396

write_data[sizeof(write_data)-1] = '\0';

5397

/* Fill rest of password with 'x' */

5398

memset(write_data+1, 'x', sizeof(write_data)-3);

5399

g_assert_cmpint((int)send(fd, write_data, sizeof(write_data),

5400

MSG_NOSIGNAL), ==, sizeof(write_data));

5401

}

5402

5403

/* read from sock_fd */

5404

char read_data[sizeof(write_data)];

5405

g_assert_cmpint((int)read(sock_fd, read_data, sizeof(read_data)),

5406

==, sizeof(read_data));

5407

5408

g_assert_true(memcmp(write_data, read_data, sizeof(write_data))

5409

== 0);

5410

5411

/* writing to sock_fd should fail */

5412

g_assert_cmpint(send(sock_fd, write_data, sizeof(write_data),

5413

MSG_NOSIGNAL), <, 0);

5414

5415

/* reading from fd should fail */

5416

g_assert_cmpint((int)recv(fd, read_data, sizeof(read_data),

5417

MSG_NOSIGNAL), <, 0);

5418

5419

g_assert_cmpint(unlink(filename), ==, 0);

5420

g_assert_cmpint(rmdir(tempdir), ==, 0);

5421

}

5422

5423

static void

5424

test_send_password_to_socket_client_not_exited(__attribute__((unused))

5425

test_fixture *fixture,

5426

__attribute__((unused))

5427

gconstpointer

5428

user_data){

5429

__attribute__((cleanup(cleanup_close)))

5430

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5431

g_assert_cmpint(epoll_fd, >=, 0);

5432

__attribute__((cleanup(cleanup_string)))

5433

char *const question_filename = strdup("/nonexistent/question");

5434

g_assert_nonnull(question_filename);

5435

__attribute__((cleanup(cleanup_string)))

5436

char *const filename = strdup("/nonexistent/socket");

5437

g_assert_nonnull(filename);

5438

__attribute__((cleanup(string_set_clear)))

5439

string_set cancelled_filenames = {};

5440

buffer password = {};

5441

bool password_is_read = true;

5442

__attribute__((cleanup(cleanup_queue)))

5443

task_queue *queue = create_queue();

5444

g_assert_nonnull(queue);

5445

int socketfds[2];

5446

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5447

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5448

socketfds), ==, 0);

5449

__attribute__((cleanup(cleanup_close)))

5450

const int read_socket = socketfds[0];

5451

const int write_socket = socketfds[1];

5452

task_context task = {

5453

.func=send_password_to_socket,

5454

.question_filename=strdup(question_filename),

5455

.filename=strdup(filename),

5456

.epoll_fd=epoll_fd,

5457

.fd=write_socket,

5458

.password=&password,

5459

.cancelled_filenames=&cancelled_filenames,

5460

.mandos_client_exited=(bool[]){false},

5461

.password_is_read=&password_is_read,

5462

.current_time=(mono_microsecs[]){0},

5463

};

5464

g_assert_nonnull(task.question_filename);

5465

5466

task.func(task, queue);

5467

5468

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5469

5470

const task_context *const added_task

5471

= find_matching_task(queue, task);

5472

g_assert_nonnull(added_task);

5473

g_assert_cmpuint((unsigned int)password.length, ==, 0);

5474

g_assert_true(password_is_read);

5475

5476

g_assert_cmpint(added_task->fd, >, 0);

5477

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5478

EPOLLOUT));

5479

}

5480

5481

static void

5482

test_send_password_to_socket_password_not_read(__attribute__((unused))

5483

test_fixture *fixture,

5484

__attribute__((unused))

5485

gconstpointer

5486

user_data){

5487

__attribute__((cleanup(cleanup_close)))

5488

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5489

g_assert_cmpint(epoll_fd, >=, 0);

5490

__attribute__((cleanup(cleanup_string)))

5491

char *const question_filename = strdup("/nonexistent/question");

5492

g_assert_nonnull(question_filename);

5493

__attribute__((cleanup(cleanup_string)))

5494

char *const filename = strdup("/nonexistent/socket");

5495

__attribute__((cleanup(string_set_clear)))

5496

string_set cancelled_filenames = {};

5497

buffer password = {};

5498

__attribute__((cleanup(cleanup_queue)))

5499

task_queue *queue = create_queue();

5500

g_assert_nonnull(queue);

5501

int socketfds[2];

5502

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5503

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5504

socketfds), ==, 0);

5505

__attribute__((cleanup(cleanup_close)))

5506

const int read_socket = socketfds[0];

5507

const int write_socket = socketfds[1];

5508

task_context task = {

5509

.func=send_password_to_socket,

5510

.question_filename=strdup(question_filename),

5511

.filename=strdup(filename),

5512

.epoll_fd=epoll_fd,

5513

.fd=write_socket,

5514

.password=&password,

5515

.cancelled_filenames=&cancelled_filenames,

5516

.mandos_client_exited=(bool[]){false},

5517

.password_is_read=(bool[]){false},

5518

.current_time=(mono_microsecs[]){0},

5519

};

5520

g_assert_nonnull(task.question_filename);

5521

5522

task.func(task, queue);

5523

5524

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5525

5526

const task_context *const added_task = find_matching_task(queue,

5527

task);

5528

g_assert_nonnull(added_task);

5529

g_assert_cmpuint((unsigned int)password.length, ==, 0);

5530

g_assert_true(queue->next_run == 0);

5531

5532

g_assert_cmpint(added_task->fd, >, 0);

5533

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5534

EPOLLOUT));

5535

}

5536

5537

static

5538

void test_send_password_to_socket_EMSGSIZE(__attribute__((unused))

5539

test_fixture *fixture,

5540

__attribute__((unused))

5541

gconstpointer user_data){

5542

__attribute__((cleanup(cleanup_close)))

5543

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5544

g_assert_cmpint(epoll_fd, >=, 0);

5545

const char question_filename[] = "/nonexistent/question";

5546

char *const filename = strdup("/nonexistent/socket");

5547

__attribute__((cleanup(string_set_clear)))

5548

string_set cancelled_filenames = {};

5549

const size_t oversized = 1024*1024; /* Limit seems to be 212960 */

5550

__attribute__((cleanup(cleanup_buffer)))

5551

buffer password = {

5552

.data=malloc(oversized),

5553

.length=oversized,

5554

.allocated=oversized,

5555

};

5556

g_assert_nonnull(password.data);

5557

if(mlock(password.data, password.allocated) != 0){

5558

g_assert_true(errno == EPERM or errno == ENOMEM);

5559

}

5560

/* Construct test password buffer */

5561

/* Start with + since that is what the real procotol uses */

5562

password.data[0] = '+';

5563

/* Set a special character at string end just to mark the end */

5564

password.data[oversized-3] = 'y';

5565

/* Set NUL at buffer end, as suggested by the protocol */

5566

password.data[oversized-2] = '\0';

5567

/* Fill rest of password with 'x' */

5568

memset(password.data+1, 'x', oversized-3);

5569

5570

__attribute__((cleanup(cleanup_queue)))

5571

task_queue *queue = create_queue();

5572

g_assert_nonnull(queue);

5573

int socketfds[2];

5574

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5575

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5576

socketfds), ==, 0);

5577

__attribute__((cleanup(cleanup_close)))

5578

const int read_socket = socketfds[0];

5579

__attribute__((cleanup(cleanup_close)))

5580

const int write_socket = socketfds[1];

5581

task_context task = {

5582

.func=send_password_to_socket,

5583

.question_filename=strdup(question_filename),

5584

.filename=filename,

5585

.epoll_fd=epoll_fd,

5586

.fd=write_socket,

5587

.password=&password,

5588

.cancelled_filenames=&cancelled_filenames,

5589

.mandos_client_exited=(bool[]){true},

5590

.password_is_read=(bool[]){true},

5591

.current_time=(mono_microsecs[]){0},

5592

};

5593

g_assert_nonnull(task.question_filename);

5594

5595

run_task_with_stderr_to_dev_null(task, queue);

5596

5597

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5598

g_assert_true(string_set_contains(cancelled_filenames,

5599

question_filename));

5600

}

5601

5602

static void test_send_password_to_socket_retry(__attribute__((unused))

5603

test_fixture *fixture,

5604

__attribute__((unused))

5605

gconstpointer

5606

user_data){

5607

__attribute__((cleanup(cleanup_close)))

5608

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5609

g_assert_cmpint(epoll_fd, >=, 0);

5610

__attribute__((cleanup(cleanup_string)))

5611

char *const question_filename = strdup("/nonexistent/question");

5612

g_assert_nonnull(question_filename);

5613

__attribute__((cleanup(cleanup_string)))

5614

char *const filename = strdup("/nonexistent/socket");

5615

g_assert_nonnull(filename);

5616

__attribute__((cleanup(string_set_clear)))

5617

string_set cancelled_filenames = {};

5618

__attribute__((cleanup(cleanup_buffer)))

5619

buffer password = {};

5620

5621

__attribute__((cleanup(cleanup_queue)))

5622

task_queue *queue = create_queue();

5623

g_assert_nonnull(queue);

5624

int socketfds[2];

5625

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5626

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5627

socketfds), ==, 0);

5628

__attribute__((cleanup(cleanup_close)))

5629

const int read_socket = socketfds[0];

5630

const int write_socket = socketfds[1];

5631

/* Close the server side socket to force ECONNRESET on client */

5632

g_assert_cmpint(close(read_socket), ==, 0);

5633

task_context task = {

5634

.func=send_password_to_socket,

5635

.question_filename=strdup(question_filename),

5636

.filename=strdup(filename),

5637

.epoll_fd=epoll_fd,

5638

.fd=write_socket,

5639

.password=&password,

5640

.cancelled_filenames=&cancelled_filenames,

5641

.mandos_client_exited=(bool[]){true},

5642

.password_is_read=(bool[]){true},

5643

.current_time=(mono_microsecs[]){0},

5644

};

5645

g_assert_nonnull(task.question_filename);

5646

5647

task.func(task, queue);

5648

5649

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5650

5651

const task_context *const added_task = find_matching_task(queue,

5652

task);

5653

g_assert_nonnull(added_task);

5654

g_assert_cmpuint((unsigned int)password.length, ==, 0);

5655

5656

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5657

EPOLLOUT));

5658

}

5659

5660

static

5661

void test_send_password_to_socket_bad_epoll(__attribute__((unused))

5662

test_fixture *fixture,

5663

__attribute__((unused))

5664

gconstpointer user_data){

5665

__attribute__((cleanup(cleanup_close)))

5666

const int epoll_fd = open("/dev/null", O_WRONLY | O_CLOEXEC);

5667

__attribute__((cleanup(cleanup_string)))

5668

char *const question_filename = strdup("/nonexistent/question");

5669

g_assert_nonnull(question_filename);

5670

__attribute__((cleanup(cleanup_string)))

5671

char *const filename = strdup("/nonexistent/socket");

5672

g_assert_nonnull(filename);

5673

__attribute__((cleanup(string_set_clear)))

5674

string_set cancelled_filenames = {};

5675

__attribute__((cleanup(cleanup_buffer)))

5676

buffer password = {};

5677

5678

const mono_microsecs current_time = 11;

5679

__attribute__((cleanup(cleanup_queue)))

5680

task_queue *queue = create_queue();

5681

g_assert_nonnull(queue);

5682

int socketfds[2];

5683

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5684

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5685

socketfds), ==, 0);

5686

__attribute__((cleanup(cleanup_close)))

5687

const int read_socket = socketfds[0];

5688

const int write_socket = socketfds[1];

5689

/* Close the server side socket to force ECONNRESET on client */

5690

g_assert_cmpint(close(read_socket), ==, 0);

5691

task_context task = {

5692

.func=send_password_to_socket,

5693

.question_filename=strdup(question_filename),

5694

.filename=strdup(filename),

5695

.epoll_fd=epoll_fd,

5696

.fd=write_socket,

5697

.password=&password,

5698

.cancelled_filenames=&cancelled_filenames,

5699

.mandos_client_exited=(bool[]){true},

5700

.password_is_read=(bool[]){true},

5701

.current_time=&current_time,

5702

};

5703

g_assert_nonnull(task.question_filename);

5704

5705

run_task_with_stderr_to_dev_null(task, queue);

5706

5707

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5708

5709

const task_context *const added_task = find_matching_task(queue,

5710

task);

5711

g_assert_nonnull(added_task);

5712

g_assert_true(queue->next_run == current_time + 1000000);

5713

g_assert_cmpuint((unsigned int)password.length, ==, 0);

5714

}

5715

5716

static void assert_send_password_to_socket_password(buffer password){

5717

__attribute__((cleanup(cleanup_close)))

5718

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5719

g_assert_cmpint(epoll_fd, >=, 0);

5720

char *const question_filename = strdup("/nonexistent/question");

5721

g_assert_nonnull(question_filename);

5722

char *const filename = strdup("/nonexistent/socket");

5723

g_assert_nonnull(filename);

5724

__attribute__((cleanup(string_set_clear)))

5725

string_set cancelled_filenames = {};

5726

5727

__attribute__((cleanup(cleanup_queue)))

5728

task_queue *queue = create_queue();

5729

g_assert_nonnull(queue);

5730

int socketfds[2];

5731

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5732

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5733

socketfds), ==, 0);

5734

__attribute__((cleanup(cleanup_close)))

5735

const int read_socket = socketfds[0];

5736

const int write_socket = socketfds[1];

5737

task_context task = {

5738

.func=send_password_to_socket,

5739

.question_filename=question_filename,

5740

.filename=filename,

5741

.epoll_fd=epoll_fd,

5742

.fd=write_socket,

5743

.password=&password,

5744

.cancelled_filenames=&cancelled_filenames,

5745

.mandos_client_exited=(bool[]){true},

5746

.password_is_read=(bool[]){true},

5747

.current_time=(mono_microsecs[]){0},

5748

};

5749

5750

char *expected_written_data = malloc(password.length + 2);

5751

g_assert_nonnull(expected_written_data);

5752

expected_written_data[0] = '+';

5753

expected_written_data[password.length + 1] = '\0';

5754

if(password.length > 0){

5755

g_assert_nonnull(password.data);

5756

memcpy(expected_written_data + 1, password.data, password.length);

5757

}

5758

5759

task.func(task, queue);

5760

5761

char buf[PIPE_BUF];

5762

g_assert_cmpint((int)read(read_socket, buf, PIPE_BUF), ==,

5763

(int)(password.length + 2));

5764

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5765

5766

g_assert_true(memcmp(expected_written_data, buf,

5767

password.length + 2) == 0);

5768

5769

g_assert_true(epoll_set_does_not_contain(epoll_fd, write_socket));

5770

5771

free(expected_written_data);

5772

}

5773

5774

static void

5775

test_send_password_to_socket_null_password(__attribute__((unused))

5776

test_fixture *fixture,

5777

__attribute__((unused))

5778

gconstpointer user_data){

5779

__attribute__((cleanup(cleanup_buffer)))

5780

buffer password = {};

5781

assert_send_password_to_socket_password(password);

5782

}

5783

5784

static void

5785

test_send_password_to_socket_empty_password(__attribute__((unused))

5786

test_fixture *fixture,

5787

__attribute__((unused))

5788

gconstpointer user_data){

5789

__attribute__((cleanup(cleanup_buffer)))

5790

buffer password = {

5791

.data=malloc(1), /* because malloc(0) may return NULL */

5792

.length=0,

5793

.allocated=0, /* deliberate lie */

5794

};

5795

g_assert_nonnull(password.data);

5796

assert_send_password_to_socket_password(password);

5797

}

5798

5799

static void

5800

test_send_password_to_socket_empty_str_pass(__attribute__((unused))

5801

test_fixture *fixture,

5802

__attribute__((unused))

5803

gconstpointer user_data){

5804

__attribute__((cleanup(cleanup_buffer)))

5805

buffer password = {

5806

.data=strdup(""),

5807

.length=0,

5808

.allocated=1,

5809

};

5810

if(mlock(password.data, password.allocated) != 0){

5811

g_assert_true(errno == EPERM or errno == ENOMEM);

5812

}

5813

assert_send_password_to_socket_password(password);

5814

}

5815

5816

static void

5817

test_send_password_to_socket_text_password(__attribute__((unused))

5818

test_fixture *fixture,

5819

__attribute__((unused))

5820

gconstpointer user_data){

5821

const char dummy_test_password[] = "dummy test password";

5822

__attribute__((cleanup(cleanup_buffer)))

5823

buffer password = {

5824

.data = strdup(dummy_test_password),

5825

.length = strlen(dummy_test_password),

5826

.allocated = sizeof(dummy_test_password),

5827

};

5828

if(mlock(password.data, password.allocated) != 0){

5829

g_assert_true(errno == EPERM or errno == ENOMEM);

5830

}

5831

assert_send_password_to_socket_password(password);

5832

}

5833

5834

static void

5835

test_send_password_to_socket_binary_password(__attribute__((unused))

5836

test_fixture *fixture,

5837

__attribute__((unused))

5838

gconstpointer user_data){

5839

__attribute__((cleanup(cleanup_buffer)))

5840

buffer password = {

5841

.data=malloc(255),

5842

.length=255,

5843

.allocated=255,

5844

};

5845

g_assert_nonnull(password.data);

5846

if(mlock(password.data, password.allocated) != 0){

5847

g_assert_true(errno == EPERM or errno == ENOMEM);

5848

}

5849

char c = 1; /* Start at 1, avoiding NUL */

5850

for(int i=0; i < 255; i++){

5851

password.data[i] = c++;

5852

}

5853

assert_send_password_to_socket_password(password);

5854

}

5855

5856

static void

5857

test_send_password_to_socket_nuls_in_password(__attribute__((unused))

5858

test_fixture *fixture,

5859

__attribute__((unused))

5860

gconstpointer

5861

user_data){

5862

char test_password[] = {'\0', 'a', '\0', 'b', '\0', 'c', '\0'};

5863

__attribute__((cleanup(cleanup_buffer)))

5864

buffer password = {

5865

.data=malloc(sizeof(test_password)),

5866

.length=sizeof(test_password),

5867

.allocated=sizeof(test_password),

5868

};

5869

g_assert_nonnull(password.data);

5870

if(mlock(password.data, password.allocated) !=0){

5871

g_assert_true(errno == EPERM or errno == ENOMEM);

5872

}

5873

memcpy(password.data, test_password, password.allocated);

5874

assert_send_password_to_socket_password(password);

5875

}

5876

5877

static bool assert_add_existing_questions_to_devnull(task_queue

5878

*const,

5879

const int,

5880

buffer *const,

5881

string_set *,

5882

const

5883

mono_microsecs

5884

*const,

5885

bool *const,

5886

bool *const,

5887

const char

5888

*const);

5889

5890

static void test_add_existing_questions_ENOENT(__attribute__((unused))

5891

test_fixture *fixture,

5892

__attribute__((unused))

5893

gconstpointer

5894

user_data){

5895

__attribute__((cleanup(cleanup_queue)))

5896

task_queue *queue = create_queue();

5897

g_assert_nonnull(queue);

5898

__attribute__((cleanup(cleanup_close)))

5899

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5900

g_assert_cmpint(epoll_fd, >=, 0);

5901

__attribute__((cleanup(string_set_clear)))

5902

string_set cancelled_filenames = {};

5903

5904

g_assert_false(assert_add_existing_questions_to_devnull

5905

(queue,

5906

epoll_fd,

5907

(buffer[]){{}}, /* password */

5908

&cancelled_filenames,

5909

(mono_microsecs[]){0}, /* current_time */

5910

(bool[]){false}, /* mandos_client_exited */

5911

(bool[]){false}, /* password_is_read */

5912

"/nonexistent")); /* dirname */

5913

5914

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5915

}

5916

5917

static

5918

bool assert_add_existing_questions_to_devnull(task_queue

5919

*const queue,

5920

const int

5921

epoll_fd,

5922

buffer *const

5923

password,

5924

string_set

5925

*cancelled_filenames,

5926

const mono_microsecs

5927

*const current_time,

5928

bool *const

5929

mandos_client_exited,

5930

bool *const

5931

password_is_read,

5932

const char *const

5933

dirname){

5934

__attribute__((cleanup(cleanup_close)))

5935

const int devnull_fd = open("/dev/null", O_WRONLY | O_CLOEXEC);

5936

g_assert_cmpint(devnull_fd, >=, 0);

5937

__attribute__((cleanup(cleanup_close)))

5938

const int real_stderr_fd = dup(STDERR_FILENO);

5939

g_assert_cmpint(real_stderr_fd, >=, 0);

5940

dup2(devnull_fd, STDERR_FILENO);

5941

const bool ret = add_existing_questions(queue, epoll_fd, password,

5942

cancelled_filenames,

5943

current_time,

5944

mandos_client_exited,

5945

password_is_read, dirname);

5946

dup2(real_stderr_fd, STDERR_FILENO);

5947

return ret;

5948

}

5949

5950

static

5951

void test_add_existing_questions_no_questions(__attribute__((unused))

5952

test_fixture *fixture,

5953

__attribute__((unused))

5954

gconstpointer

5955

user_data){

5956

__attribute__((cleanup(cleanup_queue)))

5957

task_queue *queue = create_queue();

5958

g_assert_nonnull(queue);

5959

__attribute__((cleanup(cleanup_close)))

5960

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5961

g_assert_cmpint(epoll_fd, >=, 0);

5962

__attribute__((cleanup(string_set_clear)))

5963

string_set cancelled_filenames = {};

5964

__attribute__((cleanup(cleanup_string)))

5965

char *tempdir = make_temporary_directory();

5966

g_assert_nonnull(tempdir);

5967

5968

g_assert_false(assert_add_existing_questions_to_devnull

5969

(queue,

5970

epoll_fd,

5971

(buffer[]){{}}, /* password */

5972

&cancelled_filenames,

5973

(mono_microsecs[]){0}, /* current_time */

5974

(bool[]){false}, /* mandos_client_exited */

5975

(bool[]){false}, /* password_is_read */

5976

tempdir));

5977

5978

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5979

5980

g_assert_cmpint(rmdir(tempdir), ==, 0);

5981

}

5982

5983

static char *make_question_file_in_directory(const char *const);

5984

5985

static

5986

void test_add_existing_questions_one_question(__attribute__((unused))

5987

test_fixture *fixture,

5988

__attribute__((unused))

5989

gconstpointer

5990

user_data){

5991

__attribute__((cleanup(cleanup_queue)))

5992

task_queue *queue = create_queue();

5993

g_assert_nonnull(queue);

5994

__attribute__((cleanup(cleanup_close)))

5995

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5996

g_assert_cmpint(epoll_fd, >=, 0);

5997

__attribute__((cleanup(cleanup_buffer)))

5998

buffer password = {};

5999

__attribute__((cleanup(string_set_clear)))

6000

string_set cancelled_filenames = {};

6001

const mono_microsecs current_time = 0;

6002

bool mandos_client_exited = false;

6003

bool password_is_read = false;

6004

__attribute__((cleanup(cleanup_string)))

6005

char *tempdir = make_temporary_directory();

6006

g_assert_nonnull(tempdir);

6007

__attribute__((cleanup(cleanup_string)))

6008

char *question_filename

6009

= make_question_file_in_directory(tempdir);

6010

g_assert_nonnull(question_filename);

6011

6012

g_assert_true(assert_add_existing_questions_to_devnull

6013

(queue,

6014

epoll_fd,

6015

&password,

6016

&cancelled_filenames,

6017

&current_time,

6018

&mandos_client_exited,

6019

&password_is_read,

6020

tempdir));

6021

6022

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6023

6024

g_assert_nonnull(find_matching_task(queue, (task_context){

6025

.func=open_and_parse_question,

6026

.epoll_fd=epoll_fd,

6027

.filename=question_filename,

6028

.question_filename=question_filename,

6029

.password=&password,

6030

.cancelled_filenames=&cancelled_filenames,

6031

.current_time=&current_time,

6032

.mandos_client_exited=&mandos_client_exited,

6033

.password_is_read=&password_is_read,

6034

}));

6035

6036

g_assert_true(queue->next_run == 1);

6037

6038

g_assert_cmpint(unlink(question_filename), ==, 0);

6039

g_assert_cmpint(rmdir(tempdir), ==, 0);

6040

}

6041

6042

static char *make_question_file_in_directory(const char

6043

*const dir){

6044

return make_temporary_prefixed_file_in_directory("ask.", dir);

6045

}

6046

6047

static

6048

void test_add_existing_questions_two_questions(__attribute__((unused))

6049

test_fixture *fixture,

6050

__attribute__((unused))

6051

gconstpointer

6052

user_data){

6053

__attribute__((cleanup(cleanup_queue)))

6054

task_queue *queue = create_queue();

6055

g_assert_nonnull(queue);

6056

__attribute__((cleanup(cleanup_close)))

6057

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6058

g_assert_cmpint(epoll_fd, >=, 0);

6059

__attribute__((cleanup(cleanup_buffer)))

6060

buffer password = {};

6061

__attribute__((cleanup(string_set_clear)))

6062

string_set cancelled_filenames = {};

6063

const mono_microsecs current_time = 0;

6064

bool mandos_client_exited = false;

6065

bool password_is_read = false;

6066

__attribute__((cleanup(cleanup_string)))

6067

char *tempdir = make_temporary_directory();

6068

g_assert_nonnull(tempdir);

6069

__attribute__((cleanup(cleanup_string)))

6070

char *question_filename1

6071

= make_question_file_in_directory(tempdir);

6072

g_assert_nonnull(question_filename1);

6073

__attribute__((cleanup(cleanup_string)))

6074

char *question_filename2

6075

= make_question_file_in_directory(tempdir);

6076

g_assert_nonnull(question_filename2);

6077

6078

g_assert_true(assert_add_existing_questions_to_devnull

6079

(queue,

6080

epoll_fd,

6081

&password,

6082

&cancelled_filenames,

6083

&current_time,

6084

&mandos_client_exited,

6085

&password_is_read,

6086

tempdir));

6087

6088

g_assert_cmpuint((unsigned int)queue->length, ==, 2);

6089

6090

g_assert_true(queue->next_run == 1);

6091

6092

__attribute__((cleanup(string_set_clear)))

6093

string_set seen_questions = {};

6094

6095

bool queue_contains_question_opener(char *const question_filename){

6096

return(find_matching_task(queue, (task_context){

6097

.func=open_and_parse_question,

6098

.epoll_fd=epoll_fd,

6099

.question_filename=question_filename,

6100

.password=&password,

6101

.cancelled_filenames=&cancelled_filenames,

6102

.current_time=&current_time,

6103

.mandos_client_exited=&mandos_client_exited,

6104

.password_is_read=&password_is_read,

6105

}) != NULL);

6106

}

6107

6108

g_assert_true(queue_contains_question_opener(question_filename1));

6109

g_assert_true(queue_contains_question_opener(question_filename2));

6110

6111

g_assert_true(queue->next_run == 1);

6112

6113

g_assert_cmpint(unlink(question_filename1), ==, 0);

6114

g_assert_cmpint(unlink(question_filename2), ==, 0);

6115

g_assert_cmpint(rmdir(tempdir), ==, 0);

6116

}

6117

6118

static void

6119

test_add_existing_questions_non_questions(__attribute__((unused))

6120

test_fixture *fixture,

6121

__attribute__((unused))

6122

gconstpointer user_data){

6123

__attribute__((cleanup(cleanup_queue)))

6124

task_queue *queue = create_queue();

6125

g_assert_nonnull(queue);

6126

__attribute__((cleanup(cleanup_close)))

6127

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6128

g_assert_cmpint(epoll_fd, >=, 0);

6129

__attribute__((cleanup(string_set_clear)))

6130

string_set cancelled_filenames = {};

6131

__attribute__((cleanup(cleanup_string)))

6132

char *tempdir = make_temporary_directory();

6133

g_assert_nonnull(tempdir);

6134

__attribute__((cleanup(cleanup_string)))

6135

char *question_filename1

6136

= make_temporary_file_in_directory(tempdir);

6137

g_assert_nonnull(question_filename1);

6138

__attribute__((cleanup(cleanup_string)))

6139

char *question_filename2

6140

= make_temporary_file_in_directory(tempdir);

6141

g_assert_nonnull(question_filename2);

6142

6143

g_assert_false(assert_add_existing_questions_to_devnull

6144

(queue,

6145

epoll_fd,

6146

(buffer[]){{}}, /* password */

6147

&cancelled_filenames,

6148

(mono_microsecs[]){0}, /* current_time */

6149

(bool[]){false}, /* mandos_client_exited */

6150

(bool[]){false}, /* password_is_read */

6151

tempdir));

6152

6153

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6154

6155

g_assert_cmpint(unlink(question_filename1), ==, 0);

6156

g_assert_cmpint(unlink(question_filename2), ==, 0);

6157

g_assert_cmpint(rmdir(tempdir), ==, 0);

6158

}

6159

6160

static void

6161

test_add_existing_questions_both_types(__attribute__((unused))

6162

test_fixture *fixture,

6163

__attribute__((unused))

6164

gconstpointer user_data){

6165

__attribute__((cleanup(cleanup_queue)))

6166

task_queue *queue = create_queue();

6167

g_assert_nonnull(queue);

6168

__attribute__((cleanup(cleanup_close)))

6169

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6170

g_assert_cmpint(epoll_fd, >=, 0);

6171

__attribute__((cleanup(cleanup_buffer)))

6172

buffer password = {};

6173

__attribute__((cleanup(string_set_clear)))

6174

string_set cancelled_filenames = {};

6175

const mono_microsecs current_time = 0;

6176

bool mandos_client_exited = false;

6177

bool password_is_read = false;

6178

__attribute__((cleanup(cleanup_string)))

6179

char *tempdir = make_temporary_directory();

6180

g_assert_nonnull(tempdir);

6181

__attribute__((cleanup(cleanup_string)))

6182

char *tempfilename1 = make_temporary_file_in_directory(tempdir);

6183

g_assert_nonnull(tempfilename1);

6184

__attribute__((cleanup(cleanup_string)))

6185

char *tempfilename2 = make_temporary_file_in_directory(tempdir);

6186

g_assert_nonnull(tempfilename2);

6187

__attribute__((cleanup(cleanup_string)))

6188

char *question_filename

6189

= make_question_file_in_directory(tempdir);

6190

g_assert_nonnull(question_filename);

6191

6192

g_assert_true(assert_add_existing_questions_to_devnull

6193

(queue,

6194

epoll_fd,

6195

&password,

6196

&cancelled_filenames,

6197

&current_time,

6198

&mandos_client_exited,

6199

&password_is_read,

6200

tempdir));

6201

6202

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6203

6204

g_assert_nonnull(find_matching_task(queue, (task_context){

6205

.func=open_and_parse_question,

6206

.epoll_fd=epoll_fd,

6207

.filename=question_filename,

6208

.question_filename=question_filename,

6209

.password=&password,

6210

.cancelled_filenames=&cancelled_filenames,

6211

.current_time=&current_time,

6212

.mandos_client_exited=&mandos_client_exited,

6213

.password_is_read=&password_is_read,

6214

}));

6215

6216

g_assert_true(queue->next_run == 1);

6217

6218

g_assert_cmpint(unlink(tempfilename1), ==, 0);

6219

g_assert_cmpint(unlink(tempfilename2), ==, 0);

6220

g_assert_cmpint(unlink(question_filename), ==, 0);

6221

g_assert_cmpint(rmdir(tempdir), ==, 0);

6222

}

6223

6224

static void test_wait_for_event_timeout(__attribute__((unused))

6225

test_fixture *fixture,

6226

__attribute__((unused))

6227

gconstpointer user_data){

6228

__attribute__((cleanup(cleanup_close)))

6229

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6230

g_assert_cmpint(epoll_fd, >=, 0);

6231

6232

g_assert_true(wait_for_event(epoll_fd, 1, 0));

6233

}

6234

6235

static void test_wait_for_event_event(__attribute__((unused))

6236

test_fixture *fixture,

6237

__attribute__((unused))

6238

gconstpointer user_data){

6239

__attribute__((cleanup(cleanup_close)))

6240

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6241

g_assert_cmpint(epoll_fd, >=, 0);

6242

int pipefds[2];

6243

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

6244

__attribute__((cleanup(cleanup_close)))

6245

const int read_pipe = pipefds[0];

6246

__attribute__((cleanup(cleanup_close)))

6247

const int write_pipe = pipefds[1];

6248

g_assert_cmpint(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, read_pipe,

6249

&(struct epoll_event)

6250

{ .events=EPOLLIN | EPOLLRDHUP }), ==, 0);

6251

g_assert_cmpint((int)write(write_pipe, "x", 1), ==, 1);

6252

6253

g_assert_true(wait_for_event(epoll_fd, 0, 0));

6254

}

6255

6256

static void test_wait_for_event_sigchld(test_fixture *fixture,

6257

__attribute__((unused))

6258

gconstpointer user_data){

6259

const pid_t pid = fork();

6260

if(pid == 0){ /* Child */

6261

if(not restore_signal_handler(&fixture->orig_sigaction)){

6262

_exit(EXIT_FAILURE);

6263

}

6264

if(not restore_sigmask(&fixture->orig_sigmask)){

6265

_exit(EXIT_FAILURE);

6266

}

6267

exit(EXIT_SUCCESS);

6268

}

6269

g_assert_true(pid != -1);

6270

__attribute__((cleanup(cleanup_close)))

6271

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6272

g_assert_cmpint(epoll_fd, >=, 0);

6273

6274

g_assert_true(wait_for_event(epoll_fd, 0, 0));

6275

6276

int status;

6277

g_assert_true(waitpid(pid, &status, 0) == pid);

6278

g_assert_true(WIFEXITED(status));

6279

g_assert_cmpint(WEXITSTATUS(status), ==, EXIT_SUCCESS);

6280

}

6281

6282

static void test_run_queue_zeroes_next_run(__attribute__((unused))

6283

test_fixture *fixture,

6284

__attribute__((unused))

6285

gconstpointer user_data){

6286

__attribute__((cleanup(cleanup_queue)))

6287

task_queue *queue = create_queue();

6288

g_assert_nonnull(queue);

6289

queue->next_run = 1;

6290

__attribute__((cleanup(cleanup_close)))

6291

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6292

__attribute__((cleanup(string_set_clear)))

6293

string_set cancelled_filenames = {};

6294

bool quit_now = false;

6295

6296

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6297

g_assert_false(quit_now);

6298

g_assert_cmpuint((unsigned int)queue->next_run, ==, 0);

6299

}

6300

6301

static

6302

void test_run_queue_clears_cancelled_filenames(__attribute__((unused))

6303

test_fixture *fixture,

6304

__attribute__((unused))

6305

gconstpointer

6306

user_data){

6307

__attribute__((cleanup(cleanup_queue)))

6308

task_queue *queue = create_queue();

6309

g_assert_nonnull(queue);

6310

__attribute__((cleanup(string_set_clear)))

6311

string_set cancelled_filenames = {};

6312

bool quit_now = false;

6313

const char question_filename[] = "/nonexistent/question_filename";

6314

g_assert_true(string_set_add(&cancelled_filenames,

6315

question_filename));

6316

6317

g_assert_true(add_to_queue(queue,

6318

(task_context){ .func=dummy_func }));

6319

6320

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6321

g_assert_false(quit_now);

6322

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6323

g_assert_false(string_set_contains(cancelled_filenames,

6324

question_filename));

6325

}

6326

6327

static

6328

void test_run_queue_skips_cancelled_filenames(__attribute__((unused))

6329

test_fixture *fixture,

6330

__attribute__((unused))

6331

gconstpointer

6332

user_data){

6333

__attribute__((cleanup(cleanup_queue)))

6334

task_queue *queue = create_queue();

6335

g_assert_nonnull(queue);

6336

__attribute__((cleanup(string_set_clear)))

6337

string_set cancelled_filenames = {};

6338

bool quit_now = false;

6339

int pipefds[2];

6340

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

6341

__attribute__((cleanup(cleanup_close)))

6342

const int read_pipe = pipefds[0];

6343

g_assert_cmpint(close(pipefds[1]), ==, 0);

6344

const char question_filename[] = "/nonexistent/question_filename";

6345

g_assert_true(string_set_add(&cancelled_filenames,

6346

question_filename));

6347

__attribute__((nonnull))

6348

void quit_func(const task_context task,

6349

__attribute__((unused)) task_queue *const q){

6350

g_assert_nonnull(task.quit_now);

6351

*task.quit_now = true;

6352

}

6353

task_context task = {

6354

.func=quit_func,

6355

.question_filename=strdup(question_filename),

6356

.quit_now=&quit_now,

6357

.fd=read_pipe,

6358

};

6359

g_assert_nonnull(task.question_filename);

6360

6361

g_assert_true(add_to_queue(queue, task));

6362

6363

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6364

g_assert_false(quit_now);

6365

6366

/* read_pipe should be closed already */

6367

errno = 0;

6368

bool read_pipe_closed = (close(read_pipe) == -1);

6369

read_pipe_closed &= (errno == EBADF);

6370

g_assert_true(read_pipe_closed);

6371

}

6372

6373

static void test_run_queue_one_task(__attribute__((unused))

6374

test_fixture *fixture,

6375

__attribute__((unused))

6376

gconstpointer user_data){

6377

__attribute__((cleanup(cleanup_queue)))

6378

task_queue *queue = create_queue();

6379

g_assert_nonnull(queue);

6380

__attribute__((cleanup(string_set_clear)))

6381

string_set cancelled_filenames = {};

6382

bool quit_now = false;

6383

6384

__attribute__((nonnull))

6385

void next_run_func(__attribute__((unused))

6386

const task_context task,

6387

task_queue *const q){

6388

q->next_run = 1;

6389

}

6390

6391

task_context task = {

6392

.func=next_run_func,

6393

};

6394

g_assert_true(add_to_queue(queue, task));

6395

6396

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6397

g_assert_cmpuint((unsigned int)(queue->next_run), ==, 1);

6398

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6399

}

6400

6401

static void test_run_queue_two_tasks(__attribute__((unused))

6402

test_fixture *fixture,

6403

__attribute__((unused))

6404

gconstpointer user_data){

6405

__attribute__((cleanup(cleanup_queue)))

6406

task_queue *queue = create_queue();

6407

g_assert_nonnull(queue);

6408

queue->next_run = 1;

6409

__attribute__((cleanup(string_set_clear)))

6410

string_set cancelled_filenames = {};

6411

bool quit_now = false;

6412

bool mandos_client_exited = false;

6413

6414

__attribute__((nonnull))

6415

void next_run_func(__attribute__((unused))

6416

const task_context task,

6417

task_queue *const q){

6418

q->next_run = 1;

6419

}

6420

6421

__attribute__((nonnull))

6422

void exited_func(const task_context task,

6423

__attribute__((unused)) task_queue *const q){

6424

*task.mandos_client_exited = true;

6425

}

6426

6427

task_context task1 = {

6428

.func=next_run_func,

6429

};

6430

g_assert_true(add_to_queue(queue, task1));

6431

6432

task_context task2 = {

6433

.func=exited_func,

6434

.mandos_client_exited=&mandos_client_exited,

6435

};

6436

g_assert_true(add_to_queue(queue, task2));

6437

6438

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6439

g_assert_false(quit_now);

6440

g_assert_cmpuint((unsigned int)(queue->next_run), ==, 1);

6441

g_assert_true(mandos_client_exited);

6442

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6443

}

6444

6445

static void test_run_queue_two_tasks_quit(__attribute__((unused))

6446

test_fixture *fixture,

6447

__attribute__((unused))

6448

gconstpointer user_data){

6449

__attribute__((cleanup(cleanup_queue)))

6450

task_queue *queue = create_queue();

6451

g_assert_nonnull(queue);

6452

__attribute__((cleanup(string_set_clear)))

6453

string_set cancelled_filenames = {};

6454

bool quit_now = false;

6455

bool mandos_client_exited = false;

6456

bool password_is_read = false;

6457

6458

__attribute__((nonnull))

6459

void set_exited_func(const task_context task,

6460

__attribute__((unused)) task_queue *const q){

6461

*task.mandos_client_exited = true;

6462

*task.quit_now = true;

6463

}

6464

task_context task1 = {

6465

.func=set_exited_func,

6466

.quit_now=&quit_now,

6467

.mandos_client_exited=&mandos_client_exited,

6468

};

6469

g_assert_true(add_to_queue(queue, task1));

6470

6471

__attribute__((nonnull))

6472

void set_read_func(const task_context task,

6473

__attribute__((unused)) task_queue *const q){

6474

*task.quit_now = true;

6475

*task.password_is_read = true;

6476

}

6477

task_context task2 = {

6478

.func=set_read_func,

6479

.quit_now=&quit_now,

6480

.password_is_read=&password_is_read,

6481

};

6482

g_assert_true(add_to_queue(queue, task2));

6483

6484

g_assert_false(run_queue(&queue, &cancelled_filenames, &quit_now));

6485

g_assert_true(quit_now);

6486

g_assert_true(mandos_client_exited xor password_is_read);

6487

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6488

}

6489

6490

static void test_run_queue_two_tasks_cleanup(__attribute__((unused))

6491

test_fixture *fixture,

6492

__attribute__((unused))

6493

gconstpointer user_data){

6494

__attribute__((cleanup(cleanup_queue)))

6495

task_queue *queue = create_queue();

6496

g_assert_nonnull(queue);

6497

__attribute__((cleanup(string_set_clear)))

6498

string_set cancelled_filenames = {};

6499

int pipefds[2];

6500

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

6501

__attribute__((cleanup(cleanup_close)))

6502

const int read_pipe = pipefds[0];

6503

__attribute__((cleanup(cleanup_close)))

6504

const int write_pipe = pipefds[1];

6505

bool quit_now = false;

6506

6507

__attribute__((nonnull))

6508

void read_func(const task_context task,

6509

__attribute__((unused)) task_queue *const q){

6510

*task.quit_now = true;

6511

}

6512

task_context task1 = {

6513

.func=read_func,

6514

.quit_now=&quit_now,

6515

.fd=read_pipe,

6516

};

6517

g_assert_true(add_to_queue(queue, task1));

6518

6519

__attribute__((nonnull))

6520

void write_func(const task_context task,

6521

__attribute__((unused)) task_queue *const q){

6522

*task.quit_now = true;

6523

}

6524

task_context task2 = {

6525

.func=write_func,

6526

.quit_now=&quit_now,

6527

.fd=write_pipe,

6528

};

6529

g_assert_true(add_to_queue(queue, task2));

6530

6531

g_assert_false(run_queue(&queue, &cancelled_filenames, &quit_now));

6532

g_assert_true(quit_now);

6533

6534

/* Either read_pipe or write_pipe should be closed already */

6535

errno = 0;

6536

bool close_read_pipe = (close(read_pipe) == -1);

6537

close_read_pipe &= (errno == EBADF);

6538

errno = 0;

6539

bool close_write_pipe = (close(write_pipe) == -1);

6540

close_write_pipe &= (errno == EBADF);

6541

g_assert_true(close_read_pipe xor close_write_pipe);

6542

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6543

}

6544

6545

static void test_setup_signal_handler(__attribute__((unused))

6546

test_fixture *fixture,

6547

__attribute__((unused))

6548

gconstpointer user_data){

6549

/* Save current SIGCHLD action, whatever it is */

6550

struct sigaction expected_sigchld_action;

6551

g_assert_cmpint(sigaction(SIGCHLD, NULL, &expected_sigchld_action),

6552

==, 0);

6553

6554

/* Act; i.e. run the setup_signal_handler() function */

6555

struct sigaction actual_old_sigchld_action;

6556

g_assert_true(setup_signal_handler(&actual_old_sigchld_action));

6557

6558

/* Check that the function correctly set "actual_old_sigchld_action"

6559

to the same values as the previously saved

6560

"expected_sigchld_action" */

6561

/* Check member sa_handler */

6562

g_assert_true(actual_old_sigchld_action.sa_handler

6563

== expected_sigchld_action.sa_handler);

6564

/* Check member sa_mask */

6565

for(int signum = 1; signum < NSIG; signum++){

6566

const int expected_old_block_state

6567

= sigismember(&expected_sigchld_action.sa_mask, signum);

6568

g_assert_cmpint(expected_old_block_state, >=, 0);

6569

const int actual_old_block_state

6570

= sigismember(&actual_old_sigchld_action.sa_mask, signum);

6571

g_assert_cmpint(actual_old_block_state, >=, 0);

6572

g_assert_cmpint(actual_old_block_state,

6573

==, expected_old_block_state);

6574

}

6575

/* Check member sa_flags */

6576

g_assert_true((actual_old_sigchld_action.sa_flags

6577

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

6578

== (expected_sigchld_action.sa_flags

6579

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART)));

6580

6581

/* Retrieve the current signal handler for SIGCHLD as set by

6582

setup_signal_handler() */

6583

struct sigaction actual_new_sigchld_action;

6584

g_assert_cmpint(sigaction(SIGCHLD, NULL,

6585

&actual_new_sigchld_action), ==, 0);

6586

/* Check that the signal handler (member sa_handler) is correctly

6587

set to the "handle_sigchld" function */

6588

g_assert_true(actual_new_sigchld_action.sa_handler != SIG_DFL);

6589

g_assert_true(actual_new_sigchld_action.sa_handler != SIG_IGN);

6590

g_assert_true(actual_new_sigchld_action.sa_handler

6591

== handle_sigchld);

6592

/* Check (in member sa_mask) that at least a handful of signals are

6593

actually blocked during the signal handler */

6594

for(int signum = 1; signum < NSIG; signum++){

6595

int actual_new_block_state;

6596

switch(signum){

6597

case SIGTERM:

6598

case SIGINT:

6599

case SIGQUIT:

6600

case SIGHUP:

6601

actual_new_block_state

6602

= sigismember(&actual_new_sigchld_action.sa_mask, signum);

6603

g_assert_cmpint(actual_new_block_state, ==, 1);

6604

continue;

6605

case SIGKILL: /* non-blockable */

6606

case SIGSTOP: /* non-blockable */

6607

case SIGCHLD: /* always blocked */

6608

default:

6609

continue;

6610

}

6611

}

6612

/* Check member sa_flags */

6613

g_assert_true((actual_new_sigchld_action.sa_flags

6614

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

6615

== (SA_NOCLDSTOP | SA_RESTART));

6616

6617

/* Restore signal handler */

6618

g_assert_cmpint(sigaction(SIGCHLD, &expected_sigchld_action, NULL),

6619

==, 0);

6620

}

6621

6622

static void test_restore_signal_handler(__attribute__((unused))

6623

test_fixture *fixture,

6624

__attribute__((unused))

6625

gconstpointer user_data){

6626

/* Save current SIGCHLD action, whatever it is */

6627

struct sigaction expected_sigchld_action;

6628

g_assert_cmpint(sigaction(SIGCHLD, NULL, &expected_sigchld_action),

6629

==, 0);

6630

/* Since we haven't established a signal handler yet, there should

6631

not be one established. But another test may have relied on

6632

restore_signal_handler() to restore the signal handler, and if

6633

restore_signal_handler() is buggy (which we should be prepared

6634

for in this test) the signal handler may not have been restored

6635

properly; check for this: */

6636

g_assert_true(expected_sigchld_action.sa_handler != handle_sigchld);

6637

6638

/* Establish a signal handler */

6639

struct sigaction sigchld_action = {

6640

.sa_handler=handle_sigchld,

6641

.sa_flags=SA_RESTART | SA_NOCLDSTOP,

6642

};

6643

g_assert_cmpint(sigfillset(&sigchld_action.sa_mask), ==, 0);

6644

g_assert_cmpint(sigaction(SIGCHLD, &sigchld_action, NULL), ==, 0);

6645

6646

/* Act; i.e. run the restore_signal_handler() function */

6647

g_assert_true(restore_signal_handler(&expected_sigchld_action));

6648

6649

/* Retrieve the restored signal handler data */

6650

struct sigaction actual_restored_sigchld_action;

6651

g_assert_cmpint(sigaction(SIGCHLD, NULL,

6652

&actual_restored_sigchld_action), ==, 0);

6653

6654

/* Check that the function correctly restored the signal action, as

6655

saved in "actual_restored_sigchld_action", to the same values as

6656

the previously saved "expected_sigchld_action" */

6657

/* Check member sa_handler */

6658

g_assert_true(actual_restored_sigchld_action.sa_handler

6659

== expected_sigchld_action.sa_handler);

6660

/* Check member sa_mask */

6661

for(int signum = 1; signum < NSIG; signum++){

6662

const int expected_old_block_state

6663

= sigismember(&expected_sigchld_action.sa_mask, signum);

6664

g_assert_cmpint(expected_old_block_state, >=, 0);

6665

const int actual_restored_block_state

6666

= sigismember(&actual_restored_sigchld_action.sa_mask, signum);

6667

g_assert_cmpint(actual_restored_block_state, >=, 0);

6668

g_assert_cmpint(actual_restored_block_state,

6669

==, expected_old_block_state);

6670

}

6671

/* Check member sa_flags */

6672

g_assert_true((actual_restored_sigchld_action.sa_flags

6673

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

6674

== (expected_sigchld_action.sa_flags

6675

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART)));

6676

}

6677

6678

static void test_block_sigchld(__attribute__((unused))

6679

test_fixture *fixture,

6680

__attribute__((unused))

6681

gconstpointer user_data){

6682

/* Save original signal mask */

6683

sigset_t expected_sigmask;

6684

g_assert_cmpint(pthread_sigmask(-1, NULL, &expected_sigmask),

6685

==, 0);

6686

6687

/* Make sure SIGCHLD is unblocked for this test */

6688

sigset_t sigchld_sigmask;

6689

g_assert_cmpint(sigemptyset(&sigchld_sigmask), ==, 0);

6690

g_assert_cmpint(sigaddset(&sigchld_sigmask, SIGCHLD), ==, 0);

6691

g_assert_cmpint(pthread_sigmask(SIG_UNBLOCK, &sigchld_sigmask,

6692

NULL), ==, 0);

6693

6694

/* Act; i.e. run the block_sigchld() function */

6695

sigset_t actual_old_sigmask;

6696

g_assert_true(block_sigchld(&actual_old_sigmask));

6697

6698

/* Check the actual_old_sigmask; it should be the same as the

6699

previously saved signal mask "expected_sigmask". */

6700

for(int signum = 1; signum < NSIG; signum++){

6701

const int expected_old_block_state

6702

= sigismember(&expected_sigmask, signum);

6703

g_assert_cmpint(expected_old_block_state, >=, 0);

6704

const int actual_old_block_state

6705

= sigismember(&actual_old_sigmask, signum);

6706

g_assert_cmpint(actual_old_block_state, >=, 0);

6707

g_assert_cmpint(actual_old_block_state,

6708

==, expected_old_block_state);

6709

}

6710

6711

/* Retrieve the newly set signal mask */

6712

sigset_t actual_sigmask;

6713

g_assert_cmpint(pthread_sigmask(-1, NULL, &actual_sigmask), ==, 0);

6714

6715

/* SIGCHLD should be blocked */

6716

g_assert_cmpint(sigismember(&actual_sigmask, SIGCHLD), ==, 1);

6717

6718

/* Restore signal mask */

6719

g_assert_cmpint(pthread_sigmask(SIG_SETMASK, &expected_sigmask,

6720

NULL), ==, 0);

6721

}

6722

6723

static void test_restore_sigmask(__attribute__((unused))

6724

test_fixture *fixture,

6725

__attribute__((unused))

6726

gconstpointer user_data){

6727

/* Save original signal mask */

6728

sigset_t orig_sigmask;

6729

g_assert_cmpint(pthread_sigmask(-1, NULL, &orig_sigmask), ==, 0);

6730

6731

/* Make sure SIGCHLD is blocked for this test */

6732

sigset_t sigchld_sigmask;

6733

g_assert_cmpint(sigemptyset(&sigchld_sigmask), ==, 0);

6734

g_assert_cmpint(sigaddset(&sigchld_sigmask, SIGCHLD), ==, 0);

6735

g_assert_cmpint(pthread_sigmask(SIG_BLOCK, &sigchld_sigmask,

6736

NULL), ==, 0);

6737

6738

/* Act; i.e. run the restore_sigmask() function */

6739

g_assert_true(restore_sigmask(&orig_sigmask));

6740

6741

/* Retrieve the newly restored signal mask */

6742

sigset_t restored_sigmask;

6743

g_assert_cmpint(pthread_sigmask(-1, NULL, &restored_sigmask),

6744

==, 0);

6745

6746

/* Check the restored_sigmask; it should be the same as the

6747

previously saved signal mask "orig_sigmask". */

6748

for(int signum = 1; signum < NSIG; signum++){

6749

const int orig_block_state = sigismember(&orig_sigmask, signum);

6750

g_assert_cmpint(orig_block_state, >=, 0);

6751

const int restored_block_state = sigismember(&restored_sigmask,

6752

signum);

6753

g_assert_cmpint(restored_block_state, >=, 0);

6754

g_assert_cmpint(restored_block_state, ==, orig_block_state);

6755

}

6756

6757

/* Restore signal mask */

6758

g_assert_cmpint(pthread_sigmask(SIG_SETMASK, &orig_sigmask,

6759

NULL), ==, 0);

6760

}

6761

6762

static void test_parse_arguments_noargs(__attribute__((unused))

6763

test_fixture *fixture,

6764

__attribute__((unused))

6765

gconstpointer user_data){

6766

char *argv[] = {

6767

strdup("prgname"),

6768

NULL };

6769

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

6770

6771

char *agent_directory = NULL;

6772

char *helper_directory = NULL;

6773

uid_t user = 0;

6774

gid_t group = 0;

6775

char *mandos_argz = NULL;

6776

size_t mandos_argz_length = 0;

6777

6778

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

6779

&helper_directory, &user, &group,

6780

&mandos_argz, &mandos_argz_length));

6781

g_assert_null(agent_directory);

6782

g_assert_null(helper_directory);

6783

g_assert_true(user == 0);

6784

g_assert_true(group == 0);

6785

g_assert_null(mandos_argz);

6786

g_assert_true(mandos_argz_length == 0);

6787

6788

for(char **arg = argv; *arg != NULL; arg++){

6789

free(*arg);

6790

}

6791

}

6792

6793

__attribute__((nonnull))

6794

static bool parse_arguments_devnull(int argc, char *argv[],

6795

const bool exit_failure,

6796

char **agent_directory,

6797

char **helper_directory,

6798

uid_t *const user,

6799

gid_t *const group,

6800

char **mandos_argz,

6801

size_t *mandos_argz_length){

6802

6803

FILE *real_stderr = stderr;

6804

FILE *devnull = fopen("/dev/null", "we");

6805

g_assert_nonnull(devnull);

6806

stderr = devnull;

6807

6808

const bool ret = parse_arguments(argc, argv, exit_failure,

6809

agent_directory,

6810

helper_directory, user, group,

6811

mandos_argz, mandos_argz_length);

6812

const error_t saved_errno = errno;

6813

6814

stderr = real_stderr;

6815

g_assert_cmpint(fclose(devnull), ==, 0);

6816

6817

errno = saved_errno;

6818

6819

return ret;

6820

}

6821

6822

static void test_parse_arguments_invalid(__attribute__((unused))

6823

test_fixture *fixture,

6824

__attribute__((unused))

6825

gconstpointer user_data){

6826

char *argv[] = {

6827

strdup("prgname"),

6828

strdup("--invalid"),

6829

NULL };

6830

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

6831

6832

char *agent_directory = NULL;

6833

char *helper_directory = NULL;

6834

uid_t user = 0;

6835

gid_t group = 0;

6836

char *mandos_argz = NULL;

6837

size_t mandos_argz_length = 0;

6838

6839

g_assert_false(parse_arguments_devnull(argc, argv, false,

6840

&agent_directory,

6841

&helper_directory, &user,

6842

&group, &mandos_argz,

6843

&mandos_argz_length));

6844

6845

g_assert_true(errno == EINVAL);

6846

g_assert_null(agent_directory);

6847

g_assert_null(helper_directory);

6848

g_assert_null(mandos_argz);

6849

g_assert_true(mandos_argz_length == 0);

6850

6851

for(char **arg = argv; *arg != NULL; arg++){

6852

free(*arg);

6853

}

6854

}

6855

6856

static void test_parse_arguments_long_dir(__attribute__((unused))

6857

test_fixture *fixture,

6858

__attribute__((unused))

6859

gconstpointer user_data){

6860

char *argv[] = {

6861

strdup("prgname"),

6862

strdup("--agent-directory"),

6863

strdup("/tmp"),

6864

NULL };

6865

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

6866

6867

__attribute__((cleanup(cleanup_string)))

6868

char *agent_directory = NULL;

6869

char *helper_directory = NULL;

6870

uid_t user = 0;

6871

gid_t group = 0;

6872

__attribute__((cleanup(cleanup_string)))

6873

char *mandos_argz = NULL;

6874

size_t mandos_argz_length = 0;

6875

6876

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

6877

&helper_directory, &user, &group,

6878

&mandos_argz, &mandos_argz_length));

6879

6880

g_assert_cmpstr(agent_directory, ==, "/tmp");

6881

g_assert_null(helper_directory);

6882

g_assert_true(user == 0);

6883

g_assert_true(group == 0);

6884

g_assert_null(mandos_argz);

6885

g_assert_true(mandos_argz_length == 0);

6886

6887

for(char **arg = argv; *arg != NULL; arg++){

6888

free(*arg);

6889

}

6890

}

6891

6892

static void test_parse_arguments_short_dir(__attribute__((unused))

6893

test_fixture *fixture,

6894

__attribute__((unused))

6895

gconstpointer user_data){

6896

char *argv[] = {

6897

strdup("prgname"),

6898

strdup("-d"),

6899

strdup("/tmp"),

6900

NULL };

6901

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

6902

6903

__attribute__((cleanup(cleanup_string)))

6904

char *agent_directory = NULL;

6905

char *helper_directory = NULL;

6906

uid_t user = 0;

6907

gid_t group = 0;

6908

__attribute__((cleanup(cleanup_string)))

6909

char *mandos_argz = NULL;

6910

size_t mandos_argz_length = 0;

6911

6912

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

6913

&helper_directory, &user, &group,

6914

&mandos_argz, &mandos_argz_length));

6915

6916

g_assert_cmpstr(agent_directory, ==, "/tmp");

6917

g_assert_null(helper_directory);

6918

g_assert_true(user == 0);

6919

g_assert_true(group == 0);

6920

g_assert_null(mandos_argz);

6921

g_assert_true(mandos_argz_length == 0);

6922

6923

for(char **arg = argv; *arg != NULL; arg++){

6924

free(*arg);

6925

}

6926

}

6927

6928

static

6929

void test_parse_arguments_helper_directory(__attribute__((unused))

6930

test_fixture *fixture,

6931

__attribute__((unused))

6932

gconstpointer user_data){

6933

char *argv[] = {

6934

strdup("prgname"),

6935

strdup("--helper-directory"),

6936

strdup("/tmp"),

6937

NULL };

6938

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

6939

6940

char *agent_directory = NULL;

6941

__attribute__((cleanup(cleanup_string)))

6942

char *helper_directory = NULL;

6943

uid_t user = 0;

6944

gid_t group = 0;

6945

__attribute__((cleanup(cleanup_string)))

6946

char *mandos_argz = NULL;

6947

size_t mandos_argz_length = 0;

6948

6949

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

6950

&helper_directory, &user, &group,

6951

&mandos_argz, &mandos_argz_length));

6952

6953

g_assert_cmpstr(helper_directory, ==, "/tmp");

6954

g_assert_null(agent_directory);

6955

g_assert_true(user == 0);

6956

g_assert_true(group == 0);

6957

g_assert_null(mandos_argz);

6958

g_assert_true(mandos_argz_length == 0);

6959

6960

for(char **arg = argv; *arg != NULL; arg++){

6961

free(*arg);

6962

}

6963

}

6964

6965

static

6966

void test_parse_arguments_plugin_helper_dir(__attribute__((unused))

6967

test_fixture *fixture,

6968

__attribute__((unused))

6969

gconstpointer user_data){

6970

char *argv[] = {

6971

strdup("prgname"),

6972

strdup("--plugin-helper-dir"),

6973

strdup("/tmp"),

6974

NULL };

6975

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

6976

6977

char *agent_directory = NULL;

6978

__attribute__((cleanup(cleanup_string)))

6979

char *helper_directory = NULL;

6980

uid_t user = 0;

6981

gid_t group = 0;

6982

__attribute__((cleanup(cleanup_string)))

6983

char *mandos_argz = NULL;

6984

size_t mandos_argz_length = 0;

6985

6986

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

6987

&helper_directory, &user, &group,

6988

&mandos_argz, &mandos_argz_length));

6989

6990

g_assert_cmpstr(helper_directory, ==, "/tmp");

6991

g_assert_null(agent_directory);

6992

g_assert_true(user == 0);

6993

g_assert_true(group == 0);

6994

g_assert_null(mandos_argz);

6995

g_assert_true(mandos_argz_length == 0);

6996

6997

for(char **arg = argv; *arg != NULL; arg++){

6998

free(*arg);

6999

}

7000

}

7001

7002

static void test_parse_arguments_user(__attribute__((unused))

7003

test_fixture *fixture,

7004

__attribute__((unused))

7005

gconstpointer user_data){

7006

char *argv[] = {

7007

strdup("prgname"),

7008

strdup("--user"),

7009

strdup("1000"),

7010

NULL };

7011

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7012

7013

char *agent_directory = NULL;

7014

__attribute__((cleanup(cleanup_string)))

7015

char *helper_directory = NULL;

7016

uid_t user = 0;

7017

gid_t group = 0;

7018

__attribute__((cleanup(cleanup_string)))

7019

char *mandos_argz = NULL;

7020

size_t mandos_argz_length = 0;

7021

7022

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7023

&helper_directory, &user, &group,

7024

&mandos_argz, &mandos_argz_length));

7025

7026

g_assert_null(helper_directory);

7027

g_assert_null(agent_directory);

7028

g_assert_cmpuint((unsigned int)user, ==, 1000);

7029

g_assert_true(group == 0);

7030

g_assert_null(mandos_argz);

7031

g_assert_true(mandos_argz_length == 0);

7032

7033

for(char **arg = argv; *arg != NULL; arg++){

7034

free(*arg);

7035

}

7036

}

7037

7038

static void test_parse_arguments_user_invalid(__attribute__((unused))

7039

test_fixture *fixture,

7040

__attribute__((unused))

7041

gconstpointer

7042

user_data){

7043

char *argv[] = {

7044

strdup("prgname"),

7045

strdup("--user"),

7046

strdup("invalid"),

7047

NULL };

7048

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7049

7050

char *agent_directory = NULL;

7051

__attribute__((cleanup(cleanup_string)))

7052

char *helper_directory = NULL;

7053

uid_t user = 0;

7054

gid_t group = 0;

7055

__attribute__((cleanup(cleanup_string)))

7056

char *mandos_argz = NULL;

7057

size_t mandos_argz_length = 0;

7058

7059

g_assert_false(parse_arguments_devnull(argc, argv, false,

7060

&agent_directory,

7061

&helper_directory, &user,

7062

&group, &mandos_argz,

7063

&mandos_argz_length));

7064

7065

g_assert_null(helper_directory);

7066

g_assert_null(agent_directory);

7067

g_assert_cmpuint((unsigned int)user, ==, 0);

7068

g_assert_true(group == 0);

7069

g_assert_null(mandos_argz);

7070

g_assert_true(mandos_argz_length == 0);

7071

7072

for(char **arg = argv; *arg != NULL; arg++){

7073

free(*arg);

7074

}

7075

}

7076

7077

static

7078

void test_parse_arguments_user_zero_invalid(__attribute__((unused))

7079

test_fixture *fixture,

7080

__attribute__((unused))

7081

gconstpointer user_data){

7082

char *argv[] = {

7083

strdup("prgname"),

7084

strdup("--user"),

7085

strdup("0"),

7086

NULL };

7087

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7088

7089

char *agent_directory = NULL;

7090

__attribute__((cleanup(cleanup_string)))

7091

char *helper_directory = NULL;

7092

uid_t user = 0;

7093

gid_t group = 0;

7094

__attribute__((cleanup(cleanup_string)))

7095

char *mandos_argz = NULL;

7096

size_t mandos_argz_length = 0;

7097

7098

g_assert_false(parse_arguments_devnull(argc, argv, false,

7099

&agent_directory,

7100

&helper_directory, &user,

7101

&group, &mandos_argz,

7102

&mandos_argz_length));

7103

7104

g_assert_null(helper_directory);

7105

g_assert_null(agent_directory);

7106

g_assert_cmpuint((unsigned int)user, ==, 0);

7107

g_assert_true(group == 0);

7108

g_assert_null(mandos_argz);

7109

g_assert_true(mandos_argz_length == 0);

7110

7111

for(char **arg = argv; *arg != NULL; arg++){

7112

free(*arg);

7113

}

7114

}

7115

7116

static void test_parse_arguments_group(__attribute__((unused))

7117

test_fixture *fixture,

7118

__attribute__((unused))

7119

gconstpointer user_data){

7120

char *argv[] = {

7121

strdup("prgname"),

7122

strdup("--group"),

7123

strdup("1000"),

7124

NULL };

7125

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7126

7127

char *agent_directory = NULL;

7128

__attribute__((cleanup(cleanup_string)))

7129

char *helper_directory = NULL;

7130

uid_t user = 0;

7131

gid_t group = 0;

7132

__attribute__((cleanup(cleanup_string)))

7133

char *mandos_argz = NULL;

7134

size_t mandos_argz_length = 0;

7135

7136

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7137

&helper_directory, &user, &group,

7138

&mandos_argz, &mandos_argz_length));

7139

7140

g_assert_null(helper_directory);

7141

g_assert_null(agent_directory);

7142

g_assert_true(user == 0);

7143

g_assert_cmpuint((unsigned int)group, ==, 1000);

7144

g_assert_null(mandos_argz);

7145

g_assert_true(mandos_argz_length == 0);

7146

7147

for(char **arg = argv; *arg != NULL; arg++){

7148

free(*arg);

7149

}

7150

}

7151

7152

static void test_parse_arguments_group_invalid(__attribute__((unused))

7153

test_fixture *fixture,

7154

__attribute__((unused))

7155

gconstpointer

7156

user_data){

7157

char *argv[] = {

7158

strdup("prgname"),

7159

strdup("--group"),

7160

strdup("invalid"),

7161

NULL };

7162

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7163

7164

char *agent_directory = NULL;

7165

__attribute__((cleanup(cleanup_string)))

7166

char *helper_directory = NULL;

7167

uid_t user = 0;

7168

gid_t group = 0;

7169

__attribute__((cleanup(cleanup_string)))

7170

char *mandos_argz = NULL;

7171

size_t mandos_argz_length = 0;

7172

7173

g_assert_false(parse_arguments_devnull(argc, argv, false,

7174

&agent_directory,

7175

&helper_directory, &user,

7176

&group, &mandos_argz,

7177

&mandos_argz_length));

7178

7179

g_assert_null(helper_directory);

7180

g_assert_null(agent_directory);

7181

g_assert_true(user == 0);

7182

g_assert_true(group == 0);

7183

g_assert_null(mandos_argz);

7184

g_assert_true(mandos_argz_length == 0);

7185

7186

for(char **arg = argv; *arg != NULL; arg++){

7187

free(*arg);

7188

}

7189

}

7190

7191

static

7192

void test_parse_arguments_group_zero_invalid(__attribute__((unused))

7193

test_fixture *fixture,

7194

__attribute__((unused))

7195

gconstpointer user_data){

7196

char *argv[] = {

7197

strdup("prgname"),

7198

strdup("--group"),

7199

strdup("0"),

7200

NULL };

7201

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7202

7203

char *agent_directory = NULL;

7204

__attribute__((cleanup(cleanup_string)))

7205

char *helper_directory = NULL;

7206

uid_t user = 0;

7207

gid_t group = 0;

7208

__attribute__((cleanup(cleanup_string)))

7209

char *mandos_argz = NULL;

7210

size_t mandos_argz_length = 0;

7211

7212

g_assert_false(parse_arguments_devnull(argc, argv, false,

7213

&agent_directory,

7214

&helper_directory, &user,

7215

&group, &mandos_argz,

7216

&mandos_argz_length));

7217

7218

g_assert_null(helper_directory);

7219

g_assert_null(agent_directory);

7220

g_assert_cmpuint((unsigned int)group, ==, 0);

7221

g_assert_true(group == 0);

7222

g_assert_null(mandos_argz);

7223

g_assert_true(mandos_argz_length == 0);

7224

7225

for(char **arg = argv; *arg != NULL; arg++){

7226

free(*arg);

7227

}

7228

}

7229

7230

static void test_parse_arguments_mandos_noargs(__attribute__((unused))

7231

test_fixture *fixture,

7232

__attribute__((unused))

7233

gconstpointer

7234

user_data){

7235

char *argv[] = {

7236

strdup("prgname"),

7237

strdup("mandos-client"),

7238

NULL };

7239

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7240

7241

__attribute__((cleanup(cleanup_string)))

7242

char *agent_directory = NULL;

7243

__attribute__((cleanup(cleanup_string)))

7244

char *helper_directory = NULL;

7245

uid_t user = 0;

7246

gid_t group = 0;

7247

__attribute__((cleanup(cleanup_string)))

7248

char *mandos_argz = NULL;

7249

size_t mandos_argz_length = 0;

7250

7251

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7252

&helper_directory, &user, &group,

7253

&mandos_argz, &mandos_argz_length));

7254

7255

g_assert_null(agent_directory);

7256

g_assert_null(helper_directory);

7257

g_assert_true(user == 0);

7258

g_assert_true(group == 0);

7259

g_assert_cmpstr(mandos_argz, ==, "mandos-client");

7260

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7261

mandos_argz_length),

7262

==, 1);

7263

7264

for(char **arg = argv; *arg != NULL; arg++){

7265

free(*arg);

7266

}

7267

}

7268

7269

static void test_parse_arguments_mandos_args(__attribute__((unused))

7270

test_fixture *fixture,

7271

__attribute__((unused))

7272

gconstpointer user_data){

7273

char *argv[] = {

7274

strdup("prgname"),

7275

strdup("mandos-client"),

7276

strdup("one"),

7277

strdup("two"),

7278

strdup("three"),

7279

NULL };

7280

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7281

7282

__attribute__((cleanup(cleanup_string)))

7283

char *agent_directory = NULL;

7284

__attribute__((cleanup(cleanup_string)))

7285

char *helper_directory = NULL;

7286

uid_t user = 0;

7287

gid_t group = 0;

7288

__attribute__((cleanup(cleanup_string)))

7289

char *mandos_argz = NULL;

7290

size_t mandos_argz_length = 0;

7291

7292

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7293

&helper_directory, &user, &group,

7294

&mandos_argz, &mandos_argz_length));

7295

7296

g_assert_null(agent_directory);

7297

g_assert_null(helper_directory);

7298

g_assert_true(user == 0);

7299

g_assert_true(group == 0);

7300

char *marg = mandos_argz;

7301

g_assert_cmpstr(marg, ==, "mandos-client");

7302

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7303

g_assert_cmpstr(marg, ==, "one");

7304

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7305

g_assert_cmpstr(marg, ==, "two");

7306

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7307

g_assert_cmpstr(marg, ==, "three");

7308

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7309

mandos_argz_length),

7310

==, 4);

7311

7312

for(char **arg = argv; *arg != NULL; arg++){

7313

free(*arg);

7314

}

7315

}

7316

7317

static void test_parse_arguments_all_args(__attribute__((unused))

7318

test_fixture *fixture,

7319

__attribute__((unused))

7320

gconstpointer user_data){

7321

char *argv[] = {

7322

strdup("prgname"),

7323

strdup("--agent-directory"),

7324

strdup("/tmp"),

7325

strdup("--helper-directory"),

7326

strdup("/var/tmp"),

7327

strdup("--user"),

7328

strdup("1"),

7329

strdup("--group"),

7330

strdup("2"),

7331

strdup("mandos-client"),

7332

strdup("one"),

7333

strdup("two"),

7334

strdup("three"),

7335

NULL };

7336

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7337

7338

__attribute__((cleanup(cleanup_string)))

7339

char *agent_directory = NULL;

7340

__attribute__((cleanup(cleanup_string)))

7341

char *helper_directory = NULL;

7342

uid_t user = 0;

7343

gid_t group = 0;

7344

__attribute__((cleanup(cleanup_string)))

7345

char *mandos_argz = NULL;

7346

size_t mandos_argz_length = 0;

7347

7348

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7349

&helper_directory, &user, &group,

7350

&mandos_argz, &mandos_argz_length));

7351

7352

g_assert_cmpstr(agent_directory, ==, "/tmp");

7353

g_assert_cmpstr(helper_directory, ==, "/var/tmp");

7354

g_assert_true(user == 1);

7355

g_assert_true(group == 2);

7356

char *marg = mandos_argz;

7357

g_assert_cmpstr(marg, ==, "mandos-client");

7358

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7359

g_assert_cmpstr(marg, ==, "one");

7360

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7361

g_assert_cmpstr(marg, ==, "two");

7362

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7363

g_assert_cmpstr(marg, ==, "three");

7364

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7365

mandos_argz_length),

7366

==, 4);

7367

7368

for(char **arg = argv; *arg != NULL; arg++){

7369

free(*arg);

7370

}

7371

}

7372

7373

static void test_parse_arguments_mixed(__attribute__((unused))

7374

test_fixture *fixture,

7375

__attribute__((unused))

7376

gconstpointer user_data){

7377

char *argv[] = {

7378

strdup("prgname"),

7379

strdup("mandos-client"),

7380

strdup("--user"),

7381

strdup("1"),

7382

strdup("one"),

7383

strdup("--agent-directory"),

7384

strdup("/tmp"),

7385

strdup("two"),

7386

strdup("three"),

7387

strdup("--helper-directory=/var/tmp"),

7388

NULL };

7389

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7390

7391

__attribute__((cleanup(cleanup_string)))

7392

char *agent_directory = NULL;

7393

__attribute__((cleanup(cleanup_string)))

7394

char *helper_directory = NULL;

7395

uid_t user = 0;

7396

gid_t group = 0;

7397

__attribute__((cleanup(cleanup_string)))

7398

char *mandos_argz = NULL;

7399

size_t mandos_argz_length = 0;

7400

7401

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7402

&helper_directory, &user, &group,

7403

&mandos_argz, &mandos_argz_length));

7404

7405

g_assert_cmpstr(agent_directory, ==, "/tmp");

7406

g_assert_cmpstr(helper_directory, ==, "/var/tmp");

7407

g_assert_true(user == 1);

7408

g_assert_true(group == 0);

7409

char *marg = mandos_argz;

7410

g_assert_cmpstr(marg, ==, "mandos-client");

7411

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7412

g_assert_cmpstr(marg, ==, "one");

7413

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7414

g_assert_cmpstr(marg, ==, "two");

7415

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7416

g_assert_cmpstr(marg, ==, "three");

7417

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7418

mandos_argz_length),

7419

==, 4);

7420

7421

for(char **arg = argv; *arg != NULL; arg++){

7422

free(*arg);

7423

}

7424

}

7425

7426

/* End of tests section */

7427

7428

/* Test boilerplate section; New tests should be added to the test

7429

suite definition here, in the "run_tests" function.

7430

7431

Finally, this section also contains the should_only_run_tests()

7432

function used by main() for deciding if tests should be run or to

7433

start normally. */

7434

7435

__attribute__((cold))

7436

static bool run_tests(int argc, char *argv[]){

7437

g_test_init(&argc, &argv, NULL);

7438

7439

/* A macro to add a test with no setup or teardown functions */

7440

#define test_add(testpath, testfunc) \

7441

do { \

7442

g_test_add((testpath), test_fixture, NULL, NULL, \

7443

(testfunc), NULL); \

7444

} while(false)

7445

7446

/* Test the signal-related functions first, since some other tests

7447

depend on these functions in their setups and teardowns */

7448

test_add("/signal-handling/setup", test_setup_signal_handler);

7449

test_add("/signal-handling/restore", test_restore_signal_handler);

7450

test_add("/signal-handling/block", test_block_sigchld);

7451

test_add("/signal-handling/restore-sigmask", test_restore_sigmask);

7452

7453

/* Regular non-signal-related tests; these use no setups or

7454

teardowns */

7455

test_add("/parse_arguments/noargs", test_parse_arguments_noargs);

7456

test_add("/parse_arguments/invalid", test_parse_arguments_invalid);

7457

test_add("/parse_arguments/long-dir",

7458

test_parse_arguments_long_dir);

7459

test_add("/parse_arguments/short-dir",

7460

test_parse_arguments_short_dir);

7461

test_add("/parse_arguments/helper-directory",

7462

test_parse_arguments_helper_directory);

7463

test_add("/parse_arguments/plugin-helper-dir",

7464

test_parse_arguments_plugin_helper_dir);

7465

test_add("/parse_arguments/user", test_parse_arguments_user);

7466

test_add("/parse_arguments/user-invalid",

7467

test_parse_arguments_user_invalid);

7468

test_add("/parse_arguments/user-zero-invalid",

7469

test_parse_arguments_user_zero_invalid);

7470

test_add("/parse_arguments/group", test_parse_arguments_group);

7471

test_add("/parse_arguments/group-invalid",

7472

test_parse_arguments_group_invalid);

7473

test_add("/parse_arguments/group-zero-invalid",

7474

test_parse_arguments_group_zero_invalid);

7475

test_add("/parse_arguments/mandos-noargs",

7476

test_parse_arguments_mandos_noargs);

7477

test_add("/parse_arguments/mandos-args",

7478

test_parse_arguments_mandos_args);

7479

test_add("/parse_arguments/all-args",

7480

test_parse_arguments_all_args);

7481

test_add("/parse_arguments/mixed", test_parse_arguments_mixed);

7482

test_add("/queue/create", test_create_queue);

7483

test_add("/queue/add", test_add_to_queue);

7484

test_add("/queue/has_question/empty",

7485

test_queue_has_question_empty);

7486

test_add("/queue/has_question/false",

7487

test_queue_has_question_false);

7488

test_add("/queue/has_question/true", test_queue_has_question_true);

7489

test_add("/queue/has_question/false2",

7490

test_queue_has_question_false2);

7491

test_add("/queue/has_question/true2",

7492

test_queue_has_question_true2);

7493

test_add("/buffer/cleanup", test_cleanup_buffer);

7494

test_add("/string_set/net-set-contains-nothing",

7495

test_string_set_new_set_contains_nothing);

7496

test_add("/string_set/with-added-string-contains-it",

7497

test_string_set_with_added_string_contains_it);

7498

test_add("/string_set/cleared-does-not-contain-string",

7499

test_string_set_cleared_does_not_contain_str);

7500

test_add("/string_set/swap/one-with-empty",

7501

test_string_set_swap_one_with_empty);

7502

test_add("/string_set/swap/empty-with-one",

7503

test_string_set_swap_empty_with_one);

7504

test_add("/string_set/swap/one-with-one",

7505

test_string_set_swap_one_with_one);

7506

7507

/* A macro to add a test using the setup and teardown functions */

7508

#define test_add_st(path, func) \

7509

do { \

7510

g_test_add((path), test_fixture, NULL, test_setup, (func), \

7511

test_teardown); \

7512

} while(false)

7513

7514

/* Signal-related tests; these use setups and teardowns which

7515

establish, during each test run, a signal handler for, and a

7516

signal mask blocking, the SIGCHLD signal, just like main() */

7517

test_add_st("/wait_for_event/timeout", test_wait_for_event_timeout);

7518

test_add_st("/wait_for_event/event", test_wait_for_event_event);

7519

test_add_st("/wait_for_event/sigchld", test_wait_for_event_sigchld);

7520

test_add_st("/run_queue/zeroes-next-run",

7521

test_run_queue_zeroes_next_run);

7522

test_add_st("/run_queue/clears-cancelled_filenames",

7523

test_run_queue_clears_cancelled_filenames);

7524

test_add_st("/run_queue/skips-cancelled-filenames",

7525

test_run_queue_skips_cancelled_filenames);

7526

test_add_st("/run_queue/one-task", test_run_queue_one_task);

7527

test_add_st("/run_queue/two-tasks", test_run_queue_two_tasks);

7528

test_add_st("/run_queue/two-tasks/quit",

7529

test_run_queue_two_tasks_quit);

7530

test_add_st("/run_queue/two-tasks-cleanup",

7531

test_run_queue_two_tasks_cleanup);

7532

test_add_st("/task-creators/start_mandos_client",

7533

test_start_mandos_client);

7534

test_add_st("/task-creators/start_mandos_client/execv",

7535

test_start_mandos_client_execv);

7536

test_add_st("/task-creators/start_mandos_client/suid/euid",

7537

test_start_mandos_client_suid_euid);

7538

test_add_st("/task-creators/start_mandos_client/suid/egid",

7539

test_start_mandos_client_suid_egid);

7540

test_add_st("/task-creators/start_mandos_client/suid/ruid",

7541

test_start_mandos_client_suid_ruid);

7542

test_add_st("/task-creators/start_mandos_client/suid/rgid",

7543

test_start_mandos_client_suid_rgid);

7544

test_add_st("/task-creators/start_mandos_client/read",

7545

test_start_mandos_client_read);

7546

test_add_st("/task-creators/start_mandos_client/helper-directory",

7547

test_start_mandos_client_helper_directory);

7548

test_add_st("/task-creators/start_mandos_client/sigmask",

7549

test_start_mandos_client_sigmask);

7550

test_add_st("/task/wait_for_mandos_client_exit/badpid",

7551

test_wait_for_mandos_client_exit_badpid);

7552

test_add_st("/task/wait_for_mandos_client_exit/noexit",

7553

test_wait_for_mandos_client_exit_noexit);

7554

test_add_st("/task/wait_for_mandos_client_exit/success",

7555

test_wait_for_mandos_client_exit_success);

7556

test_add_st("/task/wait_for_mandos_client_exit/failure",

7557

test_wait_for_mandos_client_exit_failure);

7558

test_add_st("/task/wait_for_mandos_client_exit/killed",

7559

test_wait_for_mandos_client_exit_killed);

7560

test_add_st("/task/read_mandos_client_output/readerror",

7561

test_read_mandos_client_output_readerror);

7562

test_add_st("/task/read_mandos_client_output/nodata",

7563

test_read_mandos_client_output_nodata);

7564

test_add_st("/task/read_mandos_client_output/eof",

7565

test_read_mandos_client_output_eof);

7566

test_add_st("/task/read_mandos_client_output/once",

7567

test_read_mandos_client_output_once);

7568

test_add_st("/task/read_mandos_client_output/malloc",

7569

test_read_mandos_client_output_malloc);

7570

test_add_st("/task/read_mandos_client_output/append",

7571

test_read_mandos_client_output_append);

7572

test_add_st("/task-creators/add_inotify_dir_watch",

7573

test_add_inotify_dir_watch);

7574

test_add_st("/task-creators/add_inotify_dir_watch/fail",

7575

test_add_inotify_dir_watch_fail);

7576

test_add_st("/task-creators/add_inotify_dir_watch/EAGAIN",

7577

test_add_inotify_dir_watch_EAGAIN);

7578

test_add_st("/task-creators/add_inotify_dir_watch/IN_CLOSE_WRITE",

7579

test_add_inotify_dir_watch_IN_CLOSE_WRITE);

7580

test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_TO",

7581

test_add_inotify_dir_watch_IN_MOVED_TO);

7582

test_add_st("/task-creators/add_inotify_dir_watch/IN_DELETE",

7583

test_add_inotify_dir_watch_IN_DELETE);

7584

test_add_st("/task/read_inotify_event/readerror",

7585

test_read_inotify_event_readerror);

7586

test_add_st("/task/read_inotify_event/bad-epoll",

7587

test_read_inotify_event_bad_epoll);

7588

test_add_st("/task/read_inotify_event/nodata",

7589

test_read_inotify_event_nodata);

7590

test_add_st("/task/read_inotify_event/eof",

7591

test_read_inotify_event_eof);

7592

test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE",

7593

test_read_inotify_event_IN_CLOSE_WRITE);

7594

test_add_st("/task/read_inotify_event/IN_MOVED_TO",

7595

test_read_inotify_event_IN_MOVED_TO);

7596

test_add_st("/task/read_inotify_event/IN_DELETE",

7597

test_read_inotify_event_IN_DELETE);

7598

test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE/badname",

7599

test_read_inotify_event_IN_CLOSE_WRITE_badname);

7600

test_add_st("/task/read_inotify_event/IN_MOVED_TO/badname",

7601

test_read_inotify_event_IN_MOVED_TO_badname);

7602

test_add_st("/task/read_inotify_event/IN_DELETE/badname",

7603

test_read_inotify_event_IN_DELETE_badname);

7604

test_add_st("/task/open_and_parse_question/ENOENT",

7605

test_open_and_parse_question_ENOENT);

7606

test_add_st("/task/open_and_parse_question/EIO",

7607

test_open_and_parse_question_EIO);

7608

test_add_st("/task/open_and_parse_question/parse-error",

7609

test_open_and_parse_question_parse_error);

7610

test_add_st("/task/open_and_parse_question/nosocket",

7611

test_open_and_parse_question_nosocket);

7612

test_add_st("/task/open_and_parse_question/badsocket",

7613

test_open_and_parse_question_badsocket);

7614

test_add_st("/task/open_and_parse_question/nopid",

7615

test_open_and_parse_question_nopid);

7616

test_add_st("/task/open_and_parse_question/badpid",

7617

test_open_and_parse_question_badpid);

7618

test_add_st("/task/open_and_parse_question/noexist_pid",

7619

test_open_and_parse_question_noexist_pid);

7620

test_add_st("/task/open_and_parse_question/no-notafter",

7621

test_open_and_parse_question_no_notafter);

7622

test_add_st("/task/open_and_parse_question/bad-notafter",

7623

test_open_and_parse_question_bad_notafter);

7624

test_add_st("/task/open_and_parse_question/notafter-0",

7625

test_open_and_parse_question_notafter_0);

7626

test_add_st("/task/open_and_parse_question/notafter-1",

7627

test_open_and_parse_question_notafter_1);

7628

test_add_st("/task/open_and_parse_question/notafter-1-1",

7629

test_open_and_parse_question_notafter_1_1);

7630

test_add_st("/task/open_and_parse_question/notafter-1-2",

7631

test_open_and_parse_question_notafter_1_2);

7632

test_add_st("/task/open_and_parse_question/equal-notafter",

7633

test_open_and_parse_question_equal_notafter);

7634

test_add_st("/task/open_and_parse_question/late-notafter",

7635

test_open_and_parse_question_late_notafter);

7636

test_add_st("/task/cancel_old_question/0-1-2",

7637

test_cancel_old_question_0_1_2);

7638

test_add_st("/task/cancel_old_question/0-2-1",

7639

test_cancel_old_question_0_2_1);

7640

test_add_st("/task/cancel_old_question/1-2-3",

7641

test_cancel_old_question_1_2_3);

7642

test_add_st("/task/cancel_old_question/1-3-2",

7643

test_cancel_old_question_1_3_2);

7644

test_add_st("/task/cancel_old_question/2-1-3",

7645

test_cancel_old_question_2_1_3);

7646

test_add_st("/task/cancel_old_question/2-3-1",

7647

test_cancel_old_question_2_3_1);

7648

test_add_st("/task/cancel_old_question/3-1-2",

7649

test_cancel_old_question_3_1_2);

7650

test_add_st("/task/cancel_old_question/3-2-1",

7651

test_cancel_old_question_3_2_1);

7652

test_add_st("/task/connect_question_socket/name-too-long",

7653

test_connect_question_socket_name_too_long);

7654

test_add_st("/task/connect_question_socket/connect-fail",

7655

test_connect_question_socket_connect_fail);

7656

test_add_st("/task/connect_question_socket/bad-epoll",

7657

test_connect_question_socket_bad_epoll);

7658

test_add_st("/task/connect_question_socket/usable",

7659

test_connect_question_socket_usable);

7660

test_add_st("/task/send_password_to_socket/client-not-exited",

7661

test_send_password_to_socket_client_not_exited);

7662

test_add_st("/task/send_password_to_socket/password-not-read",

7663

test_send_password_to_socket_password_not_read);

7664

test_add_st("/task/send_password_to_socket/EMSGSIZE",

7665

test_send_password_to_socket_EMSGSIZE);

7666

test_add_st("/task/send_password_to_socket/retry",

7667

test_send_password_to_socket_retry);

7668

test_add_st("/task/send_password_to_socket/bad-epoll",

7669

test_send_password_to_socket_bad_epoll);

7670

test_add_st("/task/send_password_to_socket/null-password",

7671

test_send_password_to_socket_null_password);

7672

test_add_st("/task/send_password_to_socket/empty-password",

7673

test_send_password_to_socket_empty_password);

7674

test_add_st("/task/send_password_to_socket/empty-str-password",

7675

test_send_password_to_socket_empty_str_pass);

7676

test_add_st("/task/send_password_to_socket/text-password",

7677

test_send_password_to_socket_text_password);

7678

test_add_st("/task/send_password_to_socket/binary-password",

7679

test_send_password_to_socket_binary_password);

7680

test_add_st("/task/send_password_to_socket/nuls-in-password",

7681

test_send_password_to_socket_nuls_in_password);

7682

test_add_st("/task-creators/add_existing_questions/ENOENT",

7683

test_add_existing_questions_ENOENT);

7684

test_add_st("/task-creators/add_existing_questions/no-questions",

7685

test_add_existing_questions_no_questions);

7686

test_add_st("/task-creators/add_existing_questions/one-question",

7687

test_add_existing_questions_one_question);

7688

test_add_st("/task-creators/add_existing_questions/two-questions",

7689

test_add_existing_questions_two_questions);

7690

test_add_st("/task-creators/add_existing_questions/non-questions",

7691

test_add_existing_questions_non_questions);

7692

test_add_st("/task-creators/add_existing_questions/both-types",

7693

test_add_existing_questions_both_types);

7694

7695

return g_test_run() == 0;

7696

}

7697

7698

static bool should_only_run_tests(int *argc_p, char **argv_p[]){

7699

GOptionContext *context = g_option_context_new("");

7700

7701

g_option_context_set_help_enabled(context, FALSE);

7702

g_option_context_set_ignore_unknown_options(context, TRUE);

7703

7704

gboolean run_tests = FALSE;

7705

GOptionEntry entries[] = {

7706

{ "test", 0, 0, G_OPTION_ARG_NONE,

7707

&run_tests, "Run tests", NULL },

7708

{ NULL }

7709

};

7710

g_option_context_add_main_entries(context, entries, NULL);

7711

7712

GError *error = NULL;

7713

7714

if(g_option_context_parse(context, argc_p, argv_p, &error) != TRUE){

7715

g_option_context_free(context);

7716

g_error("Failed to parse options: %s", error->message);

7717

}

7718

7719

g_option_context_free(context);

7720

return run_tests != FALSE;

7721

}