/mandos/trunk : revision 1275

1

/* -*- coding: utf-8; lexical-binding: t -*- */

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 /* pipe2(), O_CLOEXEC, setresgid(),

27

setresuid(), asprintf(), getline(),

28

basename() */

29

#include <inttypes.h> /* uintmax_t, strtoumax(), PRIuMAX,

30

PRIdMAX, intmax_t, uint32_t,

31

SCNx32, SCNuMAX, SCNxMAX */

32

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

33

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

34

getpid() */

35

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

36

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

37

sigemptyset(), sigaddset(),

38

SIGCHLD, pthread_sigmask(),

39

SIG_BLOCK, SIG_SETMASK, SA_RESTART,

40

SA_NOCLDSTOP, sigfillset(), kill(),

41

SIGTERM, sigdelset(), SIGKILL,

42

NSIG, sigismember(), SA_ONSTACK,

43

SIG_DFL, SIG_IGN, SIGINT, SIGQUIT,

44

SIGHUP, SIGSTOP, SIG_UNBLOCK */

45

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

46

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

47

STDOUT_FILENO, setresgid(),

48

setresuid(), execv(), ssize_t,

49

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

50

STDERR_FILENO, pause(), write(),

51

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

52

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

53

malloc(), free(), realloc(),

54

setenv(), calloc(), mkdtemp(),

55

mkostemp() */

56

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

57

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

58

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

59

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

60

ENAMETOOLONG, ENOENT, ENOTDIR,

61

ENOMEM, EEXIST, ECHILD, EPERM,

62

EAGAIN, EINTR, ENOBUFS, EADDRINUSE,

63

ECONNREFUSED, ECONNRESET,

64

ETOOMANYREFS, EMSGSIZE, EBADF,

65

EINVAL */

66

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

67

explicit_bzero(), memset(),

68

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

69

memcmp(), basename(), strerror() */

70

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

71

argz_extract(), argz_next(),

72

argz_add() */

73

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

74

epoll_ctl(), EPOLL_CTL_ADD,

75

struct epoll_event, EPOLLIN,

76

EPOLLRDHUP, EPOLLOUT,

77

epoll_pwait() */

78

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

79

CLOCK_MONOTONIC */

80

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

81

OPTION_ALIAS, struct argp_state,

82

ARGP_ERR_UNKNOWN, ARGP_KEY_ARGS,

83

struct argp, argp_parse(),

84

ARGP_NO_EXIT */

85

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

86

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

87

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

88

F_GETFD, F_GETFL, FD_CLOEXEC,

89

open(), O_WRONLY, O_NOCTTY,

90

O_RDONLY, O_NOFOLLOW */

91

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

92

WEXITSTATUS() */

93

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

94

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

95

IN_CLOEXEC, inotify_add_watch(),

96

IN_CLOSE_WRITE, IN_MOVED_TO,

97

IN_MOVED_FROM, IN_DELETE,

98

IN_EXCL_UNLINK, IN_ONLYDIR,

99

struct inotify_event */

100

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

101

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

102

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

103

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

104

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

105

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

106

GError, g_key_file_load_from_file(),

107

G_KEY_FILE_NONE, TRUE, G_FILE_ERROR_NOENT,

108

g_key_file_get_string(), guint64,

109

g_key_file_get_uint64(),

110

G_KEY_FILE_ERROR_KEY_NOT_FOUND, gconstpointer,

111

g_assert_true(), g_assert_nonnull(),

112

g_assert_null(), g_assert_false(),

113

g_assert_cmpint(), g_assert_cmpuint(),

114

g_test_skip(), g_assert_cmpstr(),

115

g_test_message(), g_test_init(), g_test_add(),

116

g_test_run(), GOptionContext,

117

g_option_context_new(),

118

g_option_context_set_help_enabled(), FALSE,

119

g_option_context_set_ignore_unknown_options(),

120

gboolean, GOptionEntry, G_OPTION_ARG_NONE,

121

g_option_context_add_main_entries(),

122

g_option_context_parse(),

123

g_option_context_free(), g_error() */

124

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

125

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

126

SOCK_DGRAM, SOCK_NONBLOCK,

127

SOCK_CLOEXEC, connect(),

128

struct sockaddr, socklen_t,

129

shutdown(), SHUT_RD, send(),

130

MSG_NOSIGNAL, bind(), recv(),

131

socketpair() */

132

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

133

GLOB_ERR, GLOB_NOSORT, GLOB_MARK,

134

GLOB_ABORTED, GLOB_NOMATCH,

135

GLOB_NOSPACE */

136

137

/* End of includes */

138

139

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

140

141

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

142

typedef uintmax_t mono_microsecs;

143

144

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

145

typedef struct {

146

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

147

size_t length; /* Number of tasks */

148

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

149

size_t allocated;

150

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

151

mono_microsecs next_run;

152

} __attribute__((designated_init)) task_queue;

153

154

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

155

156

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

157

this type */

158

typedef void (task_func) (const struct task_struct,

159

task_queue *const)

160

__attribute__((nonnull));

161

162

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

163

164

Used for the "password" variable */

165

typedef struct {

166

char *data;

167

size_t length;

168

size_t allocated;

169

} __attribute__((designated_init)) buffer;

170

171

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

172

173

Used by the "cancelled_filenames" variable */

174

typedef struct {

175

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

176

size_t argz_len; /* the string_set_* functions */

177

} __attribute__((designated_init)) string_set;

178

179

/* "task_context" - local variables for tasks

180

181

This data structure distinguishes between different tasks which are

182

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

183

task function when each task is run.

184

185

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

186

typedef struct task_struct {

187

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

188

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

189

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

190

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

191

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

192

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

193

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

194

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

195

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

196

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

197

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

198

been cancelled for any reason; tasks pertaining to these question

199

files should not be run */

200

string_set *const cancelled_filenames;

201

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

202

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

203

const mono_microsecs *const current_time;

204

} __attribute__((designated_init)) task_context;

205

206

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

207

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

208

declared in the test section. */

209

__attribute__((warn_unused_result))

210

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

211

__attribute__((warn_unused_result, cold))

212

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

213

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

214

__attribute__((warn_unused_result, malloc))

215

task_queue *create_queue(void);

216

__attribute__((nonnull, warn_unused_result))

217

bool add_to_queue(task_queue *const, const task_context);

218

__attribute__((nonnull))

219

void cleanup_task(const task_context *const);

220

__attribute__((nonnull))

221

void cleanup_queue(task_queue *const *const);

222

__attribute__((pure, nonnull, warn_unused_result))

223

bool queue_has_question(const task_queue *const);

224

__attribute__((nonnull))

225

void cleanup_close(const int *const);

226

__attribute__((nonnull))

227

void cleanup_string(char *const *const);

228

__attribute__((nonnull))

229

void cleanup_buffer(buffer *const);

230

__attribute__((pure, nonnull, warn_unused_result))

231

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

232

__attribute__((nonnull, warn_unused_result))

233

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

234

__attribute__((nonnull))

235

void string_set_clear(string_set *);

236

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

237

__attribute__((nonnull, warn_unused_result))

238

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

239

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

240

const struct sigaction *const,

241

const sigset_t, const char *const,

242

const uid_t, const gid_t,

243

const char *const *const);

244

__attribute__((nonnull))

245

task_func wait_for_mandos_client_exit;

246

__attribute__((nonnull))

247

task_func read_mandos_client_output;

248

__attribute__((warn_unused_result))

249

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

250

buffer *const, const char *const,

251

string_set *, const mono_microsecs *const,

252

bool *const, bool *const);

253

__attribute__((nonnull))

254

task_func read_inotify_event;

255

__attribute__((nonnull))

256

task_func open_and_parse_question;

257

__attribute__((nonnull))

258

task_func cancel_old_question;

259

__attribute__((nonnull))

260

task_func connect_question_socket;

261

__attribute__((nonnull))

262

task_func send_password_to_socket;

263

__attribute__((warn_unused_result))

264

bool add_existing_questions(task_queue *const, const int,

265

buffer *const, string_set *,

266

const mono_microsecs *const,

267

bool *const, bool *const,

268

const char *const);

269

__attribute__((nonnull, warn_unused_result))

270

bool wait_for_event(const int, const mono_microsecs,

271

const mono_microsecs);

272

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

273

bool clear_all_fds_from_epoll_set(const int);

274

mono_microsecs get_current_time(void);

275

__attribute__((nonnull, warn_unused_result))

276

bool setup_signal_handler(struct sigaction *const);

277

__attribute__((nonnull))

278

bool restore_signal_handler(const struct sigaction *const);

279

__attribute__((nonnull, warn_unused_result))

280

bool block_sigchld(sigset_t *const);

281

__attribute__((nonnull))

282

bool restore_sigmask(const sigset_t *const);

283

__attribute__((nonnull))

284

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

285

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

286

287

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

288

289

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

290

291

Code here should be as simple as possible. */

292

293

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

294

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

295

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

296

297

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

298

299

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

300

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

301

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

302

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

303

if(run_tests(argc, argv)){

304

return EXIT_SUCCESS; /* All tests successful */

305

}

306

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

307

}

308

309

__attribute__((cleanup(cleanup_string)))

310

char *agent_directory = NULL;

311

312

__attribute__((cleanup(cleanup_string)))

313

char *helper_directory = NULL;

314

315

uid_t user = 0;

316

gid_t group = 0;

317

318

__attribute__((cleanup(cleanup_string)))

319

char *mandos_argz = NULL;

320

size_t mandos_argz_length = 0;

321

322

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

323

&helper_directory, &user, &group,

324

&mandos_argz, &mandos_argz_length)){

325

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

326

argument to parse_arguments() above, which should make

327

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

328

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

329

}

330

331

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

332

const char default_helper_directory[]

333

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

334

const char *const default_argv[]

335

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

336

337

/* Set variables to default values if unset */

338

if(agent_directory == NULL){

339

agent_directory = strdup(default_agent_directory);

340

if(agent_directory == NULL){

341

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

342

}

343

}

344

if(helper_directory == NULL){

345

helper_directory = strdup(default_helper_directory);

346

if(helper_directory == NULL){

347

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

348

}

349

}

350

if(user == 0){

351

user = 65534; /* nobody */

352

}

353

if(group == 0){

354

group = 65534; /* nogroup */

355

}

356

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

357

default values */

358

if(mandos_argz == NULL){

359

#ifdef __GNUC__

360

#pragma GCC diagnostic push

361

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

362

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

363

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

364

#pragma GCC diagnostic ignored "-Wcast-qual"

365

#endif

366

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

367

&mandos_argz_length);

368

#ifdef __GNUC__

369

#pragma GCC diagnostic pop

370

#endif

371

if(errno != 0){

372

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

373

}

374

}

375

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

376

377

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

378

mandos_argz_length)

379

+ 1) * sizeof(char *));

380

if(mandos_argv == NULL){

381

error_t saved_errno = errno;

382

free(mandos_argz);

383

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

384

}

385

argz_extract(mandos_argz, mandos_argz_length, mandos_argv);

386

387

sigset_t orig_sigmask;

388

if(not block_sigchld(&orig_sigmask)){

389

return EX_OSERR;

390

}

391

392

struct sigaction old_sigchld_action;

393

if(not setup_signal_handler(&old_sigchld_action)){

394

return EX_OSERR;

395

}

396

397

mono_microsecs current_time = 0;

398

399

bool mandos_client_exited = false;

400

bool quit_now = false;

401

__attribute__((cleanup(cleanup_close)))

402

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

403

if(epoll_fd < 0){

404

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

405

}

406

__attribute__((cleanup(cleanup_queue)))

407

task_queue *queue = create_queue();

408

if(queue == NULL){

409

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

410

}

411

412

__attribute__((cleanup(cleanup_buffer)))

413

buffer password = {};

414

bool password_is_read = false;

415

416

__attribute__((cleanup(string_set_clear)))

417

string_set cancelled_filenames = {};

418

419

/* Add tasks to queue */

420

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

421

&quit_now, &password, &password_is_read,

422

&old_sigchld_action, orig_sigmask,

423

helper_directory, user, group,

424

(const char *const *)mandos_argv)){

425

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

426

}

427

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

428

needed anymore */

429

free(mandos_argv);

430

free(mandos_argz);

431

mandos_argz = NULL;

432

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

433

agent_directory, &cancelled_filenames,

434

&current_time, &mandos_client_exited,

435

&password_is_read)){

436

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

437

case EACCES:

438

case ENAMETOOLONG:

439

case ENOENT:

440

case ENOTDIR:

441

return EX_OSFILE;

442

default:

443

return EX_OSERR;

444

}

445

}

446

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

447

&cancelled_filenames, &current_time,

448

&mandos_client_exited,

449

&password_is_read, agent_directory)){

450

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

451

}

452

453

/* Run queue */

454

do {

455

current_time = get_current_time();

456

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

457

const error_t saved_errno = errno;

458

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

459

" events");

460

}

461

462

current_time = get_current_time();

463

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

464

const error_t saved_errno = errno;

465

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

466

}

467

468

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

469

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

470

} while(queue_has_question(queue));

471

472

restore_signal_handler(&old_sigchld_action);

473

restore_sigmask(&orig_sigmask);

474

475

return EXIT_SUCCESS;

476

}

477

478

__attribute__((warn_unused_result))

479

mono_microsecs get_current_time(void){

480

struct timespec currtime;

481

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

482

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

483

return 0;

484

}

485

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

486

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

487

}

488

489

/* End of "main" section */

490

491

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

492

493

__attribute__((nonnull))

494

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

495

char **agent_directory, char **helper_directory,

496

uid_t *const user, gid_t *const group,

497

char **mandos_argz, size_t *mandos_argz_length){

498

499

const struct argp_option options[] = {

500

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

501

.doc="Systemd password agent directory" },

502

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

503

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

504

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

505

.flags=OPTION_HIDDEN | OPTION_ALIAS },

506

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

507

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

508

" user" },

509

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

510

.flags=OPTION_HIDDEN | OPTION_ALIAS },

511

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

512

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

513

" group" },

514

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

515

.flags=OPTION_HIDDEN | OPTION_ALIAS },

516

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

517

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

518

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

519

{ NULL },

520

};

521

522

__attribute__((nonnull(3)))

523

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

524

errno = 0;

525

switch(key){

526

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

527

*agent_directory = strdup(arg);

528

break;

529

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

530

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

531

*helper_directory = strdup(arg);

532

break;

533

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

534

case 130: /* --userid */

535

{

536

char *tmp;

537

uintmax_t tmp_id = 0;

538

errno = 0;

539

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

540

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

541

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

542

return ARGP_ERR_UNKNOWN;

543

}

544

*user = (uid_t)tmp_id;

545

errno = 0;

546

break;

547

}

548

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

549

case 131: /* --groupid */

550

{

551

char *tmp;

552

uintmax_t tmp_id = 0;

553

errno = 0;

554

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

555

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

556

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

557

return ARGP_ERR_UNKNOWN;

558

}

559

*group = (gid_t)tmp_id;

560

errno = 0;

561

break;

562

}

563

case ARGP_KEY_ARGS:

564

/* Copy arguments into argz vector */

565

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

566

mandos_argz_length);

567

default:

568

return ARGP_ERR_UNKNOWN;

569

}

570

return errno;

571

}

572

573

const struct argp argp = {

574

.options=options,

575

.parser=parse_opt,

576

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

577

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

578

" systemd password agent",

579

};

580

581

errno = argp_parse(&argp, argc, argv,

582

exit_failure ? 0 : ARGP_NO_EXIT, NULL, NULL);

583

584

return errno == 0;

585

}

586

587

__attribute__((nonnull, warn_unused_result))

588

bool block_sigchld(sigset_t *const orig_sigmask){

589

sigset_t sigchld_sigmask;

590

if(sigemptyset(&sigchld_sigmask) < 0){

591

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

592

return false;

593

}

594

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

595

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

596

return false;

597

}

598

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

599

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

600

return false;

601

}

602

return true;

603

}

604

605

__attribute__((nonnull, warn_unused_result, const))

606

bool restore_sigmask(const sigset_t *const orig_sigmask){

607

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

608

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

609

return false;

610

}

611

return true;

612

}

613

614

__attribute__((nonnull, warn_unused_result))

615

bool setup_signal_handler(struct sigaction *const old_sigchld_action){

616

struct sigaction sigchld_action = {

617

.sa_handler=handle_sigchld,

618

.sa_flags=SA_RESTART | SA_NOCLDSTOP,

619

};

620

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

621

signals automatically blocked during signal handler */

622

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

623

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

624

return false;

625

}

626

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

627

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

628

return false;

629

}

630

return true;

631

}

632

633

__attribute__((nonnull, warn_unused_result))

634

bool restore_signal_handler(const struct sigaction *const

635

old_sigchld_action){

636

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

637

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

638

return false;

639

}

640

return true;

641

}

642

643

__attribute__((warn_unused_result, malloc))

644

task_queue *create_queue(void){

645

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

646

if(queue){

647

queue->tasks = NULL;

648

queue->length = 0;

649

queue->allocated = 0;

650

queue->next_run = 0;

651

}

652

return queue;

653

}

654

655

__attribute__((nonnull, warn_unused_result))

656

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

657

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

658

/* overflow */

659

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

660

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

661

errno = ENOMEM;

662

return false;

663

}

664

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

665

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

666

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

667

needed_size);

668

if(new_tasks == NULL){

669

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

670

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

671

return false;

672

}

673

queue->tasks = new_tasks;

674

queue->allocated = needed_size;

675

}

676

/* Using memcpy here is necessary because doing */

677

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

678

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

679

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

680

sizeof(task_context));

681

return true;

682

}

683

684

__attribute__((nonnull))

685

void cleanup_task(const task_context *const task){

686

const error_t saved_errno = errno;

687

/* free and close all task data */

688

free(task->question_filename);

689

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

690

free(task->filename);

691

}

692

if(task->pid > 0){

693

kill(task->pid, SIGTERM);

694

}

695

if(task->fd > 0){

696

close(task->fd);

697

}

698

errno = saved_errno;

699

}

700

701

__attribute__((nonnull))

702

void free_queue(task_queue *const queue){

703

free(queue->tasks);

704

free(queue);

705

}

706

707

__attribute__((nonnull))

708

void cleanup_queue(task_queue *const *const queue){

709

if(*queue == NULL){

710

return;

711

}

712

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

713

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

714

cleanup_task(task);

715

}

716

free_queue(*queue);

717

}

718

719

__attribute__((pure, nonnull, warn_unused_result))

720

bool queue_has_question(const task_queue *const queue){

721

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

722

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

723

return true;

724

}

725

}

726

return false;

727

}

728

729

__attribute__((nonnull))

730

void cleanup_close(const int *const fd){

731

const error_t saved_errno = errno;

732

close(*fd);

733

errno = saved_errno;

734

}

735

736

__attribute__((nonnull))

737

void cleanup_string(char *const *const ptr){

738

free(*ptr);

739

}

740

741

__attribute__((nonnull))

742

void cleanup_buffer(buffer *buf){

743

if(buf->allocated > 0){

744

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

745

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

746

#else

747

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

748

#endif

749

}

750

if(buf->data != NULL){

751

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

752

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

753

}

754

free(buf->data);

755

buf->data = NULL;

756

}

757

buf->length = 0;

758

buf->allocated = 0;

759

}

760

761

__attribute__((pure, nonnull, warn_unused_result))

762

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

763

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

764

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

765

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

766

return true;

767

}

768

}

769

return false;

770

}

771

772

__attribute__((nonnull, warn_unused_result))

773

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

774

if(string_set_contains(*set, str)){

775

return true;

776

}

777

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

778

if(error == 0){

779

return true;

780

}

781

errno = error;

782

return false;

783

}

784

785

__attribute__((nonnull))

786

void string_set_clear(string_set *set){

787

free(set->argz);

788

set->argz = NULL;

789

set->argz_len = 0;

790

}

791

792

__attribute__((nonnull))

793

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

794

/* Swap contents of two string sets */

795

{

796

char *const tmp_argz = set1->argz;

797

set1->argz = set2->argz;

798

set2->argz = tmp_argz;

799

}

800

{

801

const size_t tmp_argz_len = set1->argz_len;

802

set1->argz_len = set2->argz_len;

803

set2->argz_len = tmp_argz_len;

804

}

805

}

806

807

__attribute__((nonnull, warn_unused_result))

808

bool start_mandos_client(task_queue *const queue,

809

const int epoll_fd,

810

bool *const mandos_client_exited,

811

bool *const quit_now, buffer *const password,

812

bool *const password_is_read,

813

const struct sigaction *const

814

old_sigchld_action, const sigset_t sigmask,

815

const char *const helper_directory,

816

const uid_t user, const gid_t group,

817

const char *const *const argv){

818

int pipefds[2];

819

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

820

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

821

return false;

822

}

823

824

const pid_t pid = fork();

825

if(pid == 0){

826

if(not restore_signal_handler(old_sigchld_action)){

827

_exit(EXIT_FAILURE);

828

}

829

if(not restore_sigmask(&sigmask)){

830

_exit(EXIT_FAILURE);

831

}

832

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

833

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

834

_exit(EXIT_FAILURE);

835

}

836

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

837

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

838

_exit(EXIT_FAILURE);

839

}

840

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

841

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

842

_exit(EXIT_FAILURE);

843

}

844

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

845

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

846

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

847

_exit(EXIT_FAILURE);

848

}

849

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

850

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

851

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

852

_exit(EXIT_FAILURE);

853

}

854

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

855

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

856

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

857

_exit(EXIT_FAILURE);

858

}

859

#ifdef __GNUC__

860

#pragma GCC diagnostic push

861

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

862

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

863

#pragma GCC diagnostic ignored "-Wcast-qual"

864

#endif

865

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

866

#ifdef __GNUC__

867

#pragma GCC diagnostic pop

868

#endif

869

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

870

_exit(EXIT_FAILURE);

871

}

872

close(pipefds[1]);

873

874

if(pid == -1){

875

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

876

close(pipefds[0]);

877

return false;

878

}

879

880

if(not add_to_queue(queue, (task_context){

881

.func=wait_for_mandos_client_exit,

882

.pid=pid,

883

.mandos_client_exited=mandos_client_exited,

884

.quit_now=quit_now,

885

})){

886

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

887

close(pipefds[0]);

888

return false;

889

}

890

891

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

892

&(struct epoll_event)

893

{ .events=EPOLLIN | EPOLLRDHUP });

894

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

895

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

896

close(pipefds[0]);

897

return false;

898

}

899

900

return add_to_queue(queue, (task_context){

901

.func=read_mandos_client_output,

902

.epoll_fd=epoll_fd,

903

.fd=pipefds[0],

904

.quit_now=quit_now,

905

.password=password,

906

.password_is_read=password_is_read,

907

});

908

}

909

910

__attribute__((nonnull))

911

void wait_for_mandos_client_exit(const task_context task,

912

task_queue *const queue){

913

const pid_t pid = task.pid;

914

bool *const mandos_client_exited = task.mandos_client_exited;

915

bool *const quit_now = task.quit_now;

916

917

int status;

918

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

919

case 0: /* Not exited yet */

920

if(not add_to_queue(queue, task)){

921

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

922

*quit_now = true;

923

}

924

break;

925

case -1: /* Error */

926

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

927

if(errno != ECHILD){

928

kill(pid, SIGTERM);

929

}

930

*quit_now = true;

931

break;

932

default: /* Has exited */

933

*mandos_client_exited = true;

934

if((not WIFEXITED(status))

935

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

936

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

937

*quit_now = true;

938

}

939

}

940

}

941

942

__attribute__((nonnull))

943

void read_mandos_client_output(const task_context task,

944

task_queue *const queue){

945

buffer *const password = task.password;

946

bool *const quit_now = task.quit_now;

947

bool *const password_is_read = task.password_is_read;

948

const int fd = task.fd;

949

const int epoll_fd = task.epoll_fd;

950

951

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

952

if(password->allocated < new_potential_size){

953

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

954

if(new_buffer == NULL){

955

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

956

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

957

*quit_now = true;

958

close(fd);

959

return;

960

}

961

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

962

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

963

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

964

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

965

}

966

}

967

if(password->length > 0){

968

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

969

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

970

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

971

#else

972

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

973

#endif

974

}

975

if(password->data != NULL){

976

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

977

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

978

}

979

free(password->data);

980

}

981

password->data = new_buffer;

982

password->allocated = new_potential_size;

983

}

984

985

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

986

+ password->length, PIPE_BUF);

987

988

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

989

*password_is_read = true;

990

close(fd);

991

return;

992

}

993

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

994

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

995

*quit_now = true;

996

close(fd);

997

return;

998

}

999

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

1000

password->length += (size_t)read_length;

1001

}

1002

1003

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

1004

available yet */

1005

1006

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

1007

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

1008

&(struct epoll_event)

1009

{ .events=EPOLLIN | EPOLLRDHUP });

1010

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

1011

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

1012

*quit_now = true;

1013

close(fd);

1014

return;

1015

}

1016

1017

/* Re-add myself to the queue */

1018

if(not add_to_queue(queue, task)){

1019

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

1020

*quit_now = true;

1021

close(fd);

1022

}

1023

}

1024

1025

__attribute__((nonnull, warn_unused_result))

1026

bool add_inotify_dir_watch(task_queue *const queue,

1027

const int epoll_fd, bool *const quit_now,

1028

buffer *const password,

1029

const char *const dir,

1030

string_set *cancelled_filenames,

1031

const mono_microsecs *const current_time,

1032

bool *const mandos_client_exited,

1033

bool *const password_is_read){

1034

const int fd = inotify_init1(IN_NONBLOCK | IN_CLOEXEC);

1035

if(fd == -1){

1036

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

1037

return false;

1038

}

1039

1040

if(inotify_add_watch(fd, dir, IN_CLOSE_WRITE | IN_MOVED_TO

1041

| IN_MOVED_FROM| IN_DELETE | IN_EXCL_UNLINK

1042

| IN_ONLYDIR)

1043

== -1){

1044

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

1045

return false;

1046

}

1047

1048

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

1049

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

1050

&(struct epoll_event)

1051

{ .events=EPOLLIN | EPOLLRDHUP });

1052

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

1053

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

1054

close(fd);

1055

return false;

1056

}

1057

1058

const task_context read_inotify_event_task = {

1059

.func=read_inotify_event,

1060

.epoll_fd=epoll_fd,

1061

.quit_now=quit_now,

1062

.password=password,

1063

.fd=fd,

1064

.filename=strdup(dir),

1065

.cancelled_filenames=cancelled_filenames,

1066

.current_time=current_time,

1067

.mandos_client_exited=mandos_client_exited,

1068

.password_is_read=password_is_read,

1069

};

1070

if(read_inotify_event_task.filename == NULL){

1071

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

1072

close(fd);

1073

return false;

1074

}

1075

1076

return add_to_queue(queue, read_inotify_event_task);

1077

}

1078

1079

__attribute__((nonnull))

1080

void read_inotify_event(const task_context task,

1081

task_queue *const queue){

1082

const int fd = task.fd;

1083

const int epoll_fd = task.epoll_fd;

1084

char *const filename = task.filename;

1085

bool *quit_now = task.quit_now;

1086

buffer *const password = task.password;

1087

string_set *const cancelled_filenames = task.cancelled_filenames;

1088

const mono_microsecs *const current_time = task.current_time;

1089

bool *const mandos_client_exited = task.mandos_client_exited;

1090

bool *const password_is_read = task.password_is_read;

1091

1092

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

1093

const size_t ievent_size = (sizeof(struct inotify_event)

1094

+ NAME_MAX + 1);

1095

struct {

1096

struct inotify_event event;

1097

char name_buffer[NAME_MAX + 1];

1098

} ievent_buffer;

1099

struct inotify_event *const ievent = &ievent_buffer.event;

1100

1101

#if defined(__GNUC__) and __GNUC__ >= 7

1102

#pragma GCC diagnostic push

1103

/* ievent is pointing into a struct which is of sufficient size */

1104

#pragma GCC diagnostic ignored "-Wstringop-overflow"

1105

#endif

1106

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

1107

#if defined(__GNUC__) and __GNUC__ >= 7

1108

#pragma GCC diagnostic pop

1109

#endif

1110

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

1111

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

1112

*quit_now = true;

1113

cleanup_task(&task);

1114

return;

1115

}

1116

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

1117

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

1118

filename);

1119

*quit_now = true;

1120

cleanup_task(&task);

1121

return;

1122

}

1123

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

1124

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

1125

char *question_filename = NULL;

1126

const ssize_t question_filename_length

1127

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

1128

if(question_filename_length < 0){

1129

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

1130

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

1131

} else {

1132

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

1133

if(not add_to_queue(queue, (task_context){

1134

.func=open_and_parse_question,

1135

.epoll_fd=epoll_fd,

1136

.question_filename=question_filename,

1137

.filename=question_filename,

1138

.password=password,

1139

.cancelled_filenames=cancelled_filenames,

1140

.current_time=current_time,

1141

.mandos_client_exited=mandos_client_exited,

1142

.password_is_read=password_is_read,

1143

})){

1144

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

1145

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

1146

} else {

1147

/* Force the added task (open_and_parse_question) to run

1148

immediately */

1149

queue->next_run = 1;

1150

}

1151

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

1152

if(not string_set_add(cancelled_filenames,

1153

question_filename)){

1154

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

1155

" cancelled_questions", question_filename);

1156

*quit_now = true;

1157

free(question_filename);

1158

cleanup_task(&task);

1159

return;

1160

}

1161

free(question_filename);

1162

}

1163

}

1164

}

1165

1166

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

1167

available yet */

1168

1169

/* Re-add myself to the queue */

1170

if(not add_to_queue(queue, task)){

1171

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

1172

" queue", filename);

1173

*quit_now = true;

1174

cleanup_task(&task);

1175

return;

1176

}

1177

1178

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

1179

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

1180

&(struct epoll_event)

1181

{ .events=EPOLLIN | EPOLLRDHUP });

1182

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

1183

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

1184

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

1185

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

1186

one second from now */

1187

if((queue->next_run == 0)

1188

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

1189

queue->next_run = *current_time + 1000000;

1190

}

1191

}

1192

}

1193

1194

__attribute__((nonnull))

1195

void open_and_parse_question(const task_context task,

1196

task_queue *const queue){

1197

__attribute__((cleanup(cleanup_string)))

1198

char *question_filename = task.question_filename;

1199

const int epoll_fd = task.epoll_fd;

1200

buffer *const password = task.password;

1201

string_set *const cancelled_filenames = task.cancelled_filenames;

1202

const mono_microsecs *const current_time = task.current_time;

1203

bool *const mandos_client_exited = task.mandos_client_exited;

1204

bool *const password_is_read = task.password_is_read;

1205

1206

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

1207

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

1208

specification of contents */

1209

__attribute__((nonnull))

1210

void cleanup_g_key_file(GKeyFile **key_file){

1211

if(*key_file != NULL){

1212

g_key_file_free(*key_file);

1213

}

1214

}

1215

1216

__attribute__((cleanup(cleanup_g_key_file)))

1217

GKeyFile *key_file = g_key_file_new();

1218

if(key_file == NULL){

1219

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

1220

question_filename);

1221

return;

1222

}

1223

GError *glib_error = NULL;

1224

if(g_key_file_load_from_file(key_file, question_filename,

1225

G_KEY_FILE_NONE, &glib_error) != TRUE){

1226

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

1227

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

1228

if(glib_error->code != G_FILE_ERROR_NOENT){

1229

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

1230

question_filename, glib_error->message);

1231

}

1232

return;

1233

}

1234

1235

__attribute__((cleanup(cleanup_string)))

1236

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

1237

"Socket",

1238

&glib_error);

1239

if(socket_name == NULL){

1240

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

1241

question_filename, glib_error->message);

1242

return;

1243

}

1244

1245

if(strlen(socket_name) == 0){

1246

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

1247

question_filename);

1248

return;

1249

}

1250

1251

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

1252

&glib_error);

1253

if(glib_error != NULL){

1254

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

1255

question_filename, glib_error->message);

1256

return;

1257

}

1258

1259

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

1260

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

1261

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

1262

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

1263

return;

1264

}

1265

1266

guint64 notafter = g_key_file_get_uint64(key_file, "Ask",

1267

"NotAfter", &glib_error);

1268

if(glib_error != NULL){

1269

if(glib_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND){

1270

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

1271

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

1272

}

1273

notafter = 0;

1274

}

1275

if(notafter != 0){

1276

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

1277

queue->next_run = notafter;

1278

}

1279

if(*current_time >= notafter){

1280

return;

1281

}

1282

}

1283

1284

const task_context connect_question_socket_task = {

1285

.func=connect_question_socket,

1286

.question_filename=strdup(question_filename),

1287

.epoll_fd=epoll_fd,

1288

.password=password,

1289

.filename=strdup(socket_name),

1290

.cancelled_filenames=task.cancelled_filenames,

1291

.mandos_client_exited=mandos_client_exited,

1292

.password_is_read=password_is_read,

1293

.current_time=current_time,

1294

};

1295

if(connect_question_socket_task.question_filename == NULL

1296

or connect_question_socket_task.filename == NULL

1297

or not add_to_queue(queue, connect_question_socket_task)){

1298

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

1299

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

1300

question_filename);

1301

cleanup_task(&connect_question_socket_task);

1302

return;

1303

}

1304

/* Force the added task (connect_question_socket) to run

1305

immediately */

1306

queue->next_run = 1;

1307

1308

if(notafter > 0){

1309

char *const dup_filename = strdup(question_filename);

1310

const task_context cancel_old_question_task = {

1311

.func=cancel_old_question,

1312

.question_filename=dup_filename,

1313

.notafter=notafter,

1314

.filename=dup_filename,

1315

.cancelled_filenames=cancelled_filenames,

1316

.current_time=current_time,

1317

};

1318

if(cancel_old_question_task.question_filename == NULL

1319

or not add_to_queue(queue, cancel_old_question_task)){

1320

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

1321

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

1322

cleanup_task(&cancel_old_question_task);

1323

return;

1324

}

1325

}

1326

}

1327

1328

__attribute__((nonnull))

1329

void cancel_old_question(const task_context task,

1330

task_queue *const queue){

1331

char *const question_filename = task.question_filename;

1332

string_set *const cancelled_filenames = task.cancelled_filenames;

1333

const mono_microsecs notafter = task.notafter;

1334

const mono_microsecs *const current_time = task.current_time;

1335

1336

if(*current_time >= notafter){

1337

if(not string_set_add(cancelled_filenames, question_filename)){

1338

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

1339

question_filename);

1340

}

1341

cleanup_task(&task);

1342

return;

1343

}

1344

1345

if(not add_to_queue(queue, task)){

1346

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

1347

"%s to queue", question_filename);

1348

cleanup_task(&task);

1349

return;

1350

}

1351

1352

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

1353

queue->next_run = notafter;

1354

}

1355

}

1356

1357

__attribute__((nonnull))

1358

void connect_question_socket(const task_context task,

1359

task_queue *const queue){

1360

char *const question_filename = task.question_filename;

1361

char *const filename = task.filename;

1362

const int epoll_fd = task.epoll_fd;

1363

buffer *const password = task.password;

1364

string_set *const cancelled_filenames = task.cancelled_filenames;

1365

bool *const mandos_client_exited = task.mandos_client_exited;

1366

bool *const password_is_read = task.password_is_read;

1367

const mono_microsecs *const current_time = task.current_time;

1368

1369

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

1370

1371

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

1372

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

1373

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

1374

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

1375

if(not string_set_add(cancelled_filenames, question_filename)){

1376

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

1377

question_filename);

1378

}

1379

cleanup_task(&task);

1380

return;

1381

}

1382

1383

const int fd = socket(PF_LOCAL, SOCK_DGRAM

1384

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

1385

if(fd < 0){

1386

error(0, errno,

1387

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

1388

if(not add_to_queue(queue, task)){

1389

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

1390

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

1391

filename);

1392

cleanup_task(&task);

1393

} else {

1394

/* Force the added task (connect_question_socket) to run

1395

immediately */

1396

queue->next_run = 1;

1397

}

1398

return;

1399

}

1400

1401

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

1402

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

1403

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

1404

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

1405

if(not add_to_queue(queue, task)){

1406

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

1407

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

1408

filename);

1409

cleanup_task(&task);

1410

} else {

1411

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

1412

at most one second from now */

1413

if((queue->next_run == 0)

1414

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

1415

queue->next_run = *current_time + 1000000;

1416

}

1417

}

1418

return;

1419

}

1420

1421

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

1422

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

1423

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

1424

filename);

1425

}

1426

1427

/* Add the fd to the epoll set */

1428

if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

1429

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

1430

!= 0){

1431

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

1432

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

1433

if(not add_to_queue(queue, task)){

1434

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

1435

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

1436

filename);

1437

cleanup_task(&task);

1438

} else {

1439

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

1440

at most one second from now */

1441

if((queue->next_run == 0)

1442

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

1443

queue->next_run = *current_time + 1000000;

1444

}

1445

}

1446

return;

1447

}

1448

1449

/* add task send_password_to_socket to queue */

1450

const task_context send_password_to_socket_task = {

1451

.func=send_password_to_socket,

1452

.question_filename=question_filename,

1453

.filename=filename,

1454

.epoll_fd=epoll_fd,

1455

.fd=fd,

1456

.password=password,

1457

.cancelled_filenames=cancelled_filenames,

1458

.mandos_client_exited=mandos_client_exited,

1459

.password_is_read=password_is_read,

1460

.current_time=current_time,

1461

};

1462

1463

if(not add_to_queue(queue, send_password_to_socket_task)){

1464

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

1465

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

1466

question_filename, filename);

1467

cleanup_task(&send_password_to_socket_task);

1468

}

1469

}

1470

1471

__attribute__((nonnull))

1472

void send_password_to_socket(const task_context task,

1473

task_queue *const queue){

1474

char *const question_filename=task.question_filename;

1475

char *const filename=task.filename;

1476

const int epoll_fd=task.epoll_fd;

1477

const int fd=task.fd;

1478

buffer *const password=task.password;

1479

string_set *const cancelled_filenames=task.cancelled_filenames;

1480

bool *const mandos_client_exited = task.mandos_client_exited;

1481

bool *const password_is_read = task.password_is_read;

1482

const mono_microsecs *const current_time = task.current_time;

1483

1484

if(*mandos_client_exited and *password_is_read){

1485

1486

const size_t send_buffer_length = password->length + 2;

1487

char *send_buffer = malloc(send_buffer_length);

1488

if(send_buffer == NULL){

1489

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

1490

} else {

1491

#if defined(__GNUC__) and __GNUC__ >= 5

1492

#pragma GCC diagnostic push

1493

/* mlock() does not access the memory */

1494

#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"

1495

#endif

1496

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

1497

#if defined(__GNUC__) and __GNUC__ >= 5

1498

#pragma GCC diagnostic pop

1499

#endif

1500

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

1501

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

1502

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

1503

" buffer");

1504

}

1505

}

1506

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

1507

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

1508

depending on whether the password entry was successful or

1509

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

1510

your message.

1511

1512

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

1513

14:24:20 GMT)

1514

*/

1515

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

1516

/* Always add an extra NUL */

1517

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

1518

if(password->length > 0){

1519

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

1520

}

1521

errno = 0;

1522

ssize_t ssret = send(fd, send_buffer, send_buffer_length,

1523

MSG_NOSIGNAL);

1524

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

1525

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

1526

explicit_bzero(send_buffer, send_buffer_length);

1527

#else

1528

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

1529

#endif

1530

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

1531

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

1532

}

1533

free(send_buffer);

1534

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

1535

switch(saved_errno){

1536

case EINTR:

1537

case ENOBUFS:

1538

case ENOMEM:

1539

case EADDRINUSE:

1540

case ECONNREFUSED:

1541

case ECONNRESET:

1542

case ENOENT:

1543

case ETOOMANYREFS:

1544

case EAGAIN:

1545

/* Retry, below */

1546

break;

1547

case EMSGSIZE:

1548

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

1549

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

1550

#if __GNUC__ < 7

1551

/* FALLTHROUGH */

1552

#else

1553

__attribute__((fallthrough));

1554

#endif

1555

case 0:

1556

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

1557

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

1558

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

1559

(uintmax_t)ssret, (uintmax_t)send_buffer_length);

1560

}

1561

#if __GNUC__ < 7

1562

/* FALLTHROUGH */

1563

#else

1564

__attribute__((fallthrough));

1565

#endif

1566

default:

1567

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

1568

filename);

1569

if(not string_set_add(cancelled_filenames,

1570

question_filename)){

1571

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

1572

question_filename);

1573

}

1574

cleanup_task(&task);

1575

return;

1576

}

1577

} else {

1578

/* Success */

1579

cleanup_task(&task);

1580

return;

1581

}

1582

}

1583

}

1584

1585

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

1586

1587

if(not add_to_queue(queue, task)){

1588

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

1589

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

1590

filename);

1591

cleanup_task(&task);

1592

}

1593

1594

/* Add the fd to the epoll set */

1595

if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fd,

1596

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

1597

!= 0){

1598

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

1599

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

1600

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

1601

most one second from now */

1602

if((queue->next_run == 0)

1603

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

1604

queue->next_run = *current_time + 1000000;

1605

}

1606

}

1607

}

1608

1609

__attribute__((warn_unused_result))

1610

bool add_existing_questions(task_queue *const queue,

1611

const int epoll_fd,

1612

buffer *const password,

1613

string_set *cancelled_filenames,

1614

const mono_microsecs *const current_time,

1615

bool *const mandos_client_exited,

1616

bool *const password_is_read,

1617

const char *const dirname){

1618

__attribute__((cleanup(cleanup_string)))

1619

char *dir_pattern = NULL;

1620

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

1621

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

1622

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

1623

dirname);

1624

return false;

1625

}

1626

__attribute__((cleanup(globfree)))

1627

glob_t question_filenames = {};

1628

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

1629

NULL, &question_filenames)){

1630

case GLOB_ABORTED:

1631

default:

1632

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

1633

return false;

1634

case GLOB_NOMATCH:

1635

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

1636

return false;

1637

case GLOB_NOSPACE:

1638

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

1639

" names in %s", dirname);

1640

#if __GNUC__ < 7

1641

/* FALLTHROUGH */

1642

#else

1643

__attribute__((fallthrough));

1644

#endif

1645

case 0:

1646

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

1647

char *const question_filename = strdup(question_filenames

1648

.gl_pathv[i]);

1649

const task_context task = {

1650

.func=open_and_parse_question,

1651

.epoll_fd=epoll_fd,

1652

.question_filename=question_filename,

1653

.filename=question_filename,

1654

.password=password,

1655

.cancelled_filenames=cancelled_filenames,

1656

.current_time=current_time,

1657

.mandos_client_exited=mandos_client_exited,

1658

.password_is_read=password_is_read,

1659

};

1660

1661

if(question_filename == NULL

1662

or not add_to_queue(queue, task)){

1663

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

1664

" file %s to queue",

1665

question_filenames.gl_pathv[i]);

1666

free(question_filename);

1667

} else {

1668

queue->next_run = 1;

1669

}

1670

}

1671

return true;

1672

}

1673

}

1674

1675

__attribute__((nonnull, warn_unused_result))

1676

bool wait_for_event(const int epoll_fd,

1677

const mono_microsecs queue_next_run,

1678

const mono_microsecs current_time){

1679

__attribute__((const))

1680

int milliseconds_to_wait(const mono_microsecs currtime,

1681

const mono_microsecs nextrun){

1682

if(currtime >= nextrun){

1683

return 0;

1684

}

1685

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

1686

if(wait_time_ms > (uintmax_t)INT_MAX){

1687

return INT_MAX;

1688

}

1689

return (int)wait_time_ms;

1690

}

1691

1692

const int wait_time_ms = milliseconds_to_wait(current_time,

1693

queue_next_run);

1694

1695

/* Prepare unblocking of SIGCHLD during epoll_pwait */

1696

sigset_t temporary_unblocked_sigmask;

1697

/* Get current signal mask */

1698

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

1699

return false;

1700

}

1701

/* Remove SIGCHLD from the signal mask */

1702

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

1703

return false;

1704

}

1705

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

1706

int ret = epoll_pwait(epoll_fd, events,

1707

sizeof(events) / sizeof(struct epoll_event),

1708

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

1709

&temporary_unblocked_sigmask);

1710

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

1711

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

1712

" ...", epoll_fd,

1713

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

1714

return false;

1715

}

1716

return clear_all_fds_from_epoll_set(epoll_fd);

1717

}

1718

1719

bool clear_all_fds_from_epoll_set(const int epoll_fd){

1720

/* Create a new empty epoll set */

1721

__attribute__((cleanup(cleanup_close)))

1722

const int new_epoll_fd = epoll_create1(EPOLL_CLOEXEC);

1723

if(new_epoll_fd < 0){

1724

return false;

1725

}

1726

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

1727

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

1728

return false;

1729

}

1730

return true;

1731

}

1732

1733

__attribute__((nonnull, warn_unused_result))

1734

bool run_queue(task_queue **const queue,

1735

string_set *const cancelled_filenames,

1736

bool *const quit_now){

1737

1738

task_queue *new_queue = create_queue();

1739

if(new_queue == NULL){

1740

return false;

1741

}

1742

1743

__attribute__((cleanup(string_set_clear)))

1744

string_set old_cancelled_filenames = {};

1745

string_set_swap(cancelled_filenames, &old_cancelled_filenames);

1746

1747

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

1748

loop in case we aborted in the middle */

1749

size_t i;

1750

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

1751

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

1752

const char *const question_filename = task->question_filename;

1753

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

1754

if(question_filename != NULL

1755

and string_set_contains(old_cancelled_filenames,

1756

question_filename)){

1757

cleanup_task(task);

1758

continue;

1759

}

1760

task->func(*task, new_queue);

1761

}

1762

1763

if(*quit_now){

1764

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

1765

remaining tasks in the current queue */

1766

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

1767

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

1768

}

1769

free_queue(*queue);

1770

*queue = new_queue;

1771

new_queue = NULL;

1772

return false;

1773

}

1774

free_queue(*queue);

1775

*queue = new_queue;

1776

new_queue = NULL;

1777

1778

return true;

1779

}

1780

1781

/* End of regular code section */

1782

1783

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

1784

1785

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

1786

teardown functions */

1787

typedef struct {

1788

struct sigaction orig_sigaction;

1789

sigset_t orig_sigmask;

1790

} test_fixture;

1791

1792

static void test_setup(test_fixture *fixture,

1793

__attribute__((unused))

1794

gconstpointer user_data){

1795

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

1796

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

1797

}

1798

1799

static void test_teardown(test_fixture *fixture,

1800

__attribute__((unused))

1801

gconstpointer user_data){

1802

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

1803

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

1804

}

1805

1806

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

1807

__attribute__((pure, nonnull, warn_unused_result))

1808

static task_context *find_matching_task(const task_queue *const queue,

1809

const task_context task){

1810

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

1811

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

1812

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

1813

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

1814

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

1815

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

1816

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

1817

1818

/* task_func *const func */

1819

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

1820

continue;

1821

}

1822

/* char *const question_filename; */

1823

if(task.question_filename != NULL

1824

and (current_task->question_filename == NULL

1825

or strcmp(current_task->question_filename,

1826

task.question_filename) != 0)){

1827

continue;

1828

}

1829

/* const pid_t pid; */

1830

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

1831

continue;

1832

}

1833

/* const int epoll_fd; */

1834

if(task.epoll_fd != 0

1835

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

1836

continue;

1837

}

1838

/* bool *const quit_now; */

1839

if(task.quit_now != NULL

1840

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

1841

continue;

1842

}

1843

/* const int fd; */

1844

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

1845

continue;

1846

}

1847

/* bool *const mandos_client_exited; */

1848

if(task.mandos_client_exited != NULL

1849

and current_task->mandos_client_exited

1850

!= task.mandos_client_exited){

1851

continue;

1852

}

1853

/* buffer *const password; */

1854

if(task.password != NULL

1855

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

1856

continue;

1857

}

1858

/* bool *const password_is_read; */

1859

if(task.password_is_read != NULL

1860

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

1861

continue;

1862

}

1863

/* char *filename; */

1864

if(task.filename != NULL

1865

and (current_task->filename == NULL

1866

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

1867

continue;

1868

}

1869

/* string_set *const cancelled_filenames; */

1870

if(task.cancelled_filenames != NULL

1871

and current_task->cancelled_filenames

1872

!= task.cancelled_filenames){

1873

continue;

1874

}

1875

/* const mono_microsecs notafter; */

1876

if(task.notafter != 0

1877

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

1878

continue;

1879

}

1880

/* const mono_microsecs *const current_time; */

1881

if(task.current_time != NULL

1882

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

1883

continue;

1884

}

1885

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

1886

return current_task;

1887

}

1888

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

1889

return NULL;

1890

}

1891

1892

static void test_create_queue(__attribute__((unused))

1893

test_fixture *fixture,

1894

__attribute__((unused))

1895

gconstpointer user_data){

1896

__attribute__((cleanup(cleanup_queue)))

1897

task_queue *const queue = create_queue();

1898

g_assert_nonnull(queue);

1899

g_assert_null(queue->tasks);

1900

g_assert_true(queue->length == 0);

1901

g_assert_true(queue->next_run == 0);

1902

}

1903

1904

static task_func dummy_func;

1905

1906

static void test_add_to_queue(__attribute__((unused))

1907

test_fixture *fixture,

1908

__attribute__((unused))

1909

gconstpointer user_data){

1910

__attribute__((cleanup(cleanup_queue)))

1911

task_queue *queue = create_queue();

1912

g_assert_nonnull(queue);

1913

1914

g_assert_true(add_to_queue(queue,

1915

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

1916

g_assert_true(queue->length == 1);

1917

g_assert_nonnull(queue->tasks);

1918

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

1919

}

1920

1921

static void test_add_to_queue_overflow(__attribute__((unused))

1922

test_fixture *fixture,

1923

__attribute__((unused))

1924

gconstpointer user_data){

1925

__attribute__((cleanup(cleanup_queue)))

1926

task_queue *queue = create_queue();

1927

g_assert_nonnull(queue);

1928

g_assert_true(queue->length == 0);

1929

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

1930

1931

FILE *real_stderr = stderr;

1932

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

1933

g_assert_nonnull(devnull);

1934

stderr = devnull;

1935

const bool ret = add_to_queue(queue,

1936

(task_context){ .func=dummy_func });

1937

g_assert_true(errno == ENOMEM);

1938

g_assert_false(ret);

1939

stderr = real_stderr;

1940

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

1941

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

1942

}

1943

1944

static void dummy_func(__attribute__((unused))

1945

const task_context task,

1946

__attribute__((unused))

1947

task_queue *const queue){

1948

}

1949

1950

static void test_queue_has_question_empty(__attribute__((unused))

1951

test_fixture *fixture,

1952

__attribute__((unused))

1953

gconstpointer user_data){

1954

__attribute__((cleanup(cleanup_queue)))

1955

task_queue *queue = create_queue();

1956

g_assert_nonnull(queue);

1957

g_assert_false(queue_has_question(queue));

1958

}

1959

1960

static void test_queue_has_question_false(__attribute__((unused))

1961

test_fixture *fixture,

1962

__attribute__((unused))

1963

gconstpointer user_data){

1964

__attribute__((cleanup(cleanup_queue)))

1965

task_queue *queue = create_queue();

1966

g_assert_nonnull(queue);

1967

g_assert_true(add_to_queue(queue,

1968

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

1969

g_assert_false(queue_has_question(queue));

1970

}

1971

1972

static void test_queue_has_question_true(__attribute__((unused))

1973

test_fixture *fixture,

1974

__attribute__((unused))

1975

gconstpointer user_data){

1976

__attribute__((cleanup(cleanup_queue)))

1977

task_queue *queue = create_queue();

1978

g_assert_nonnull(queue);

1979

char *const question_filename

1980

= strdup("/nonexistent/question_filename");

1981

g_assert_nonnull(question_filename);

1982

task_context task = {

1983

.func=dummy_func,

1984

.question_filename=question_filename,

1985

};

1986

g_assert_true(add_to_queue(queue, task));

1987

g_assert_true(queue_has_question(queue));

1988

}

1989

1990

static void test_queue_has_question_false2(__attribute__((unused))

1991

test_fixture *fixture,

1992

__attribute__((unused))

1993

gconstpointer user_data){

1994

__attribute__((cleanup(cleanup_queue)))

1995

task_queue *queue = create_queue();

1996

g_assert_nonnull(queue);

1997

task_context task = { .func=dummy_func };

1998

g_assert_true(add_to_queue(queue, task));

1999

g_assert_true(add_to_queue(queue, task));

2000

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

2001

g_assert_false(queue_has_question(queue));

2002

}

2003

2004

static void test_queue_has_question_true2(__attribute__((unused))

2005

test_fixture *fixture,

2006

__attribute__((unused))

2007

gconstpointer user_data){

2008

__attribute__((cleanup(cleanup_queue)))

2009

task_queue *queue = create_queue();

2010

g_assert_nonnull(queue);

2011

task_context task1 = { .func=dummy_func };

2012

g_assert_true(add_to_queue(queue, task1));

2013

char *const question_filename

2014

= strdup("/nonexistent/question_filename");

2015

g_assert_nonnull(question_filename);

2016

task_context task2 = {

2017

.func=dummy_func,

2018

.question_filename=question_filename,

2019

};

2020

g_assert_true(add_to_queue(queue, task2));

2021

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

2022

g_assert_true(queue_has_question(queue));

2023

}

2024

2025

static void test_cleanup_buffer(__attribute__((unused))

2026

test_fixture *fixture,

2027

__attribute__((unused))

2028

gconstpointer user_data){

2029

buffer buf = {};

2030

2031

const size_t buffersize = 10;

2032

2033

buf.data = malloc(buffersize);

2034

g_assert_nonnull(buf.data);

2035

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

2036

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

2037

}

2038

2039

cleanup_buffer(&buf);

2040

g_assert_null(buf.data);

2041

}

2042

2043

static

2044

void test_string_set_new_set_contains_nothing(__attribute__((unused))

2045

test_fixture *fixture,

2046

__attribute__((unused))

2047

gconstpointer

2048

user_data){

2049

__attribute__((cleanup(string_set_clear)))

2050

string_set set = {};

2051

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

2052

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

2053

}

2054

2055

static void

2056

test_string_set_with_added_string_contains_it(__attribute__((unused))

2057

test_fixture *fixture,

2058

__attribute__((unused))

2059

gconstpointer

2060

user_data){

2061

__attribute__((cleanup(string_set_clear)))

2062

string_set set = {};

2063

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

2064

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

2065

}

2066

2067

static void

2068

test_string_set_cleared_does_not_contain_str(__attribute__((unused))

2069

test_fixture *fixture,

2070

__attribute__((unused))

2071

gconstpointer user_data){

2072

__attribute__((cleanup(string_set_clear)))

2073

string_set set = {};

2074

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

2075

string_set_clear(&set);

2076

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

2077

}

2078

2079

static

2080

void test_string_set_swap_one_with_empty(__attribute__((unused))

2081

test_fixture *fixture,

2082

__attribute__((unused))

2083

gconstpointer user_data){

2084

__attribute__((cleanup(string_set_clear)))

2085

string_set set1 = {};

2086

__attribute__((cleanup(string_set_clear)))

2087

string_set set2 = {};

2088

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

2089

string_set_swap(&set1, &set2);

2090

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

2091

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

2092

}

2093

2094

static

2095

void test_string_set_swap_empty_with_one(__attribute__((unused))

2096

test_fixture *fixture,

2097

__attribute__((unused))

2098

gconstpointer user_data){

2099

__attribute__((cleanup(string_set_clear)))

2100

string_set set1 = {};

2101

__attribute__((cleanup(string_set_clear)))

2102

string_set set2 = {};

2103

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

2104

string_set_swap(&set1, &set2);

2105

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

2106

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

2107

}

2108

2109

static void test_string_set_swap_one_with_one(__attribute__((unused))

2110

test_fixture *fixture,

2111

__attribute__((unused))

2112

gconstpointer

2113

user_data){

2114

__attribute__((cleanup(string_set_clear)))

2115

string_set set1 = {};

2116

__attribute__((cleanup(string_set_clear)))

2117

string_set set2 = {};

2118

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

2119

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

2120

string_set_swap(&set1, &set2);

2121

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

2122

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

2123

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

2124

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

2125

}

2126

2127

static bool fd_has_cloexec_and_nonblock(const int);

2128

2129

static bool epoll_set_contains(int, int, uint32_t);

2130

2131

static void test_start_mandos_client(test_fixture *fixture,

2132

__attribute__((unused))

2133

gconstpointer user_data){

2134

2135

bool mandos_client_exited = false;

2136

bool quit_now = false;

2137

__attribute__((cleanup(cleanup_close)))

2138

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2139

g_assert_cmpint(epoll_fd, >=, 0);

2140

__attribute__((cleanup(cleanup_queue)))

2141

task_queue *queue = create_queue();

2142

g_assert_nonnull(queue);

2143

buffer password = {};

2144

bool password_is_read = false;

2145

const char helper_directory[] = "/nonexistent";

2146

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

2147

2148

g_assert_true(start_mandos_client(queue, epoll_fd,

2149

&mandos_client_exited, &quit_now,

2150

&password, &password_is_read,

2151

&fixture->orig_sigaction,

2152

fixture->orig_sigmask,

2153

helper_directory, 0, 0, argv));

2154

2155

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

2156

2157

const task_context *const added_wait_task

2158

= find_matching_task(queue, (task_context){

2159

.func=wait_for_mandos_client_exit,

2160

.mandos_client_exited=&mandos_client_exited,

2161

.quit_now=&quit_now,

2162

});

2163

g_assert_nonnull(added_wait_task);

2164

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

2165

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

2166

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

2167

2168

const task_context *const added_read_task

2169

= find_matching_task(queue, (task_context){

2170

.func=read_mandos_client_output,

2171

.epoll_fd=epoll_fd,

2172

.password=&password,

2173

.password_is_read=&password_is_read,

2174

.quit_now=&quit_now,

2175

});

2176

g_assert_nonnull(added_read_task);

2177

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

2178

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

2179

g_assert_true(epoll_set_contains(epoll_fd, added_read_task->fd,

2180

EPOLLIN | EPOLLRDHUP));

2181

}

2182

2183

static bool fd_has_cloexec_and_nonblock(const int fd){

2184

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

2185

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

2186

return ((socket_fd_flags >= 0)

2187

and (socket_fd_flags & FD_CLOEXEC)

2188

and (socket_file_flags >= 0)

2189

and (socket_file_flags & O_NONBLOCK));

2190

}

2191

2192

__attribute__((const))

2193

bool is_privileged(void){

2194

uid_t user = getuid() + 1;

2195

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

2196

user++;

2197

}

2198

gid_t group = getuid() + 1;

2199

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

2200

group++;

2201

}

2202

const pid_t pid = fork();

2203

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

2204

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

2205

if(errno != EPERM){

2206

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

2207

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

2208

}

2209

exit(EXIT_FAILURE);

2210

}

2211

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

2212

if(errno != EPERM){

2213

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

2214

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

2215

}

2216

exit(EXIT_FAILURE);

2217

}

2218

exit(EXIT_SUCCESS);

2219

}

2220

if(pid == -1){

2221

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

2222

}

2223

2224

int status;

2225

waitpid(pid, &status, 0);

2226

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

2227

return true;

2228

}

2229

return false;

2230

}

2231

2232

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

2233

/* Only scan for events in this eventmask */

2234

const uint32_t eventmask = EPOLLIN | EPOLLOUT | EPOLLRDHUP;

2235

__attribute__((cleanup(cleanup_string)))

2236

char *fdinfo_name = NULL;

2237

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

2238

g_assert_cmpint(ret, >, 0);

2239

g_assert_nonnull(fdinfo_name);

2240

2241

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

2242

g_assert_nonnull(fdinfo);

2243

uint32_t reported_events;

2244

buffer line = {};

2245

int found_fd = -1;

2246

2247

do {

2248

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

2249

break;

2250

}

2251

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

2252

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

2253

&found_fd, &reported_events) == 2){

2254

if(found_fd == fd){

2255

break;

2256

}

2257

}

2258

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

2259

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

2260

free(line.data);

2261

if(found_fd != fd){

2262

return false;

2263

}

2264

2265

if(events == 0){

2266

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

2267

return true;

2268

}

2269

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

2270

}

2271

2272

static void test_start_mandos_client_execv(test_fixture *fixture,

2273

__attribute__((unused))

2274

gconstpointer user_data){

2275

bool mandos_client_exited = false;

2276

bool quit_now = false;

2277

__attribute__((cleanup(cleanup_close)))

2278

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2279

g_assert_cmpint(epoll_fd, >=, 0);

2280

__attribute__((cleanup(cleanup_queue)))

2281

task_queue *queue = create_queue();

2282

g_assert_nonnull(queue);

2283

__attribute__((cleanup(cleanup_buffer)))

2284

buffer password = {};

2285

const char helper_directory[] = "/nonexistent";

2286

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

2287

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

2288

2289

{

2290

__attribute__((cleanup(cleanup_close)))

2291

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

2292

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2293

g_assert_cmpint(devnull_fd, >=, 0);

2294

__attribute__((cleanup(cleanup_close)))

2295

const int real_stderr_fd = dup(STDERR_FILENO);

2296

g_assert_cmpint(real_stderr_fd, >=, 0);

2297

dup2(devnull_fd, STDERR_FILENO);

2298

2299

const bool success = start_mandos_client(queue, epoll_fd,

2300

&mandos_client_exited,

2301

&quit_now,

2302

&password,

2303

(bool[]){false},

2304

&fixture->orig_sigaction,

2305

fixture->orig_sigmask,

2306

helper_directory, 0, 0,

2307

argv);

2308

dup2(real_stderr_fd, STDERR_FILENO);

2309

g_assert_true(success);

2310

}

2311

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

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

2319

{

2320

__attribute__((cleanup(cleanup_close)))

2321

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

2322

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2323

g_assert_cmpint(devnull_fd, >=, 0);

2324

__attribute__((cleanup(cleanup_close)))

2325

const int real_stderr_fd = dup(STDERR_FILENO);

2326

g_assert_cmpint(real_stderr_fd, >=, 0);

2327

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

2328

dup2(devnull_fd, STDERR_FILENO);

2329

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

2330

&quit_now);

2331

dup2(real_stderr_fd, STDERR_FILENO);

2332

if(not success){

2333

break;

2334

}

2335

}

2336

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

2337

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

2338

and (not quit_now)

2339

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

2340

2341

g_assert_true(quit_now);

2342

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

2343

g_assert_true(mandos_client_exited);

2344

}

2345

2346

static void test_start_mandos_client_suid_euid(test_fixture *fixture,

2347

__attribute__((unused))

2348

gconstpointer

2349

user_data){

2350

if(not is_privileged()){

2351

g_test_skip("Not privileged");

2352

return;

2353

}

2354

2355

bool mandos_client_exited = false;

2356

bool quit_now = false;

2357

__attribute__((cleanup(cleanup_close)))

2358

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2359

g_assert_cmpint(epoll_fd, >=, 0);

2360

__attribute__((cleanup(cleanup_queue)))

2361

task_queue *queue = create_queue();

2362

g_assert_nonnull(queue);

2363

__attribute__((cleanup(cleanup_buffer)))

2364

buffer password = {};

2365

bool password_is_read = false;

2366

const char helper_directory[] = "/nonexistent";

2367

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

2368

uid_t user = 1000;

2369

gid_t group = 1001;

2370

2371

const bool success = start_mandos_client(queue, epoll_fd,

2372

&mandos_client_exited,

2373

&quit_now, &password,

2374

&password_is_read,

2375

&fixture->orig_sigaction,

2376

fixture->orig_sigmask,

2377

helper_directory, user,

2378

group, argv);

2379

g_assert_true(success);

2380

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

2381

2382

struct timespec starttime, currtime;

2383

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

2384

do {

2385

queue->next_run = 0;

2386

string_set cancelled_filenames = {};

2387

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

2388

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

2389

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

2390

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

2391

and (not quit_now)

2392

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

2393

2394

g_assert_false(quit_now);

2395

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

2396

g_assert_true(mandos_client_exited);

2397

2398

g_assert_true(password_is_read);

2399

g_assert_nonnull(password.data);

2400

2401

uintmax_t id;

2402

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

2403

==, 1);

2404

g_assert_true((uid_t)id == id);

2405

2406

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

2407

}

2408

2409

static void test_start_mandos_client_suid_egid(test_fixture *fixture,

2410

__attribute__((unused))

2411

gconstpointer

2412

user_data){

2413

if(not is_privileged()){

2414

g_test_skip("Not privileged");

2415

return;

2416

}

2417

2418

bool mandos_client_exited = false;

2419

bool quit_now = false;

2420

__attribute__((cleanup(cleanup_close)))

2421

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2422

g_assert_cmpint(epoll_fd, >=, 0);

2423

__attribute__((cleanup(cleanup_queue)))

2424

task_queue *queue = create_queue();

2425

g_assert_nonnull(queue);

2426

__attribute__((cleanup(cleanup_buffer)))

2427

buffer password = {};

2428

bool password_is_read = false;

2429

const char helper_directory[] = "/nonexistent";

2430

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

2431

uid_t user = 1000;

2432

gid_t group = 1001;

2433

2434

const bool success = start_mandos_client(queue, epoll_fd,

2435

&mandos_client_exited,

2436

&quit_now, &password,

2437

&password_is_read,

2438

&fixture->orig_sigaction,

2439

fixture->orig_sigmask,

2440

helper_directory, user,

2441

group, argv);

2442

g_assert_true(success);

2443

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

2444

2445

struct timespec starttime, currtime;

2446

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

2447

do {

2448

queue->next_run = 0;

2449

string_set cancelled_filenames = {};

2450

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

2451

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

2452

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

2453

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

2454

and (not quit_now)

2455

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

2456

2457

g_assert_false(quit_now);

2458

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

2459

g_assert_true(mandos_client_exited);

2460

2461

g_assert_true(password_is_read);

2462

g_assert_nonnull(password.data);

2463

2464

uintmax_t id;

2465

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

2466

==, 1);

2467

g_assert_true((gid_t)id == id);

2468

2469

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

2470

}

2471

2472

static void test_start_mandos_client_suid_ruid(test_fixture *fixture,

2473

__attribute__((unused))

2474

gconstpointer

2475

user_data){

2476

if(not is_privileged()){

2477

g_test_skip("Not privileged");

2478

return;

2479

}

2480

2481

bool mandos_client_exited = false;

2482

bool quit_now = false;

2483

__attribute__((cleanup(cleanup_close)))

2484

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2485

g_assert_cmpint(epoll_fd, >=, 0);

2486

__attribute__((cleanup(cleanup_queue)))

2487

task_queue *queue = create_queue();

2488

g_assert_nonnull(queue);

2489

__attribute__((cleanup(cleanup_buffer)))

2490

buffer password = {};

2491

bool password_is_read = false;

2492

const char helper_directory[] = "/nonexistent";

2493

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

2494

NULL };

2495

uid_t user = 1000;

2496

gid_t group = 1001;

2497

2498

const bool success = start_mandos_client(queue, epoll_fd,

2499

&mandos_client_exited,

2500

&quit_now, &password,

2501

&password_is_read,

2502

&fixture->orig_sigaction,

2503

fixture->orig_sigmask,

2504

helper_directory, user,

2505

group, argv);

2506

g_assert_true(success);

2507

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

2508

2509

struct timespec starttime, currtime;

2510

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

2511

do {

2512

queue->next_run = 0;

2513

string_set cancelled_filenames = {};

2514

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

2515

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

2516

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

2517

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

2518

and (not quit_now)

2519

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

2520

2521

g_assert_false(quit_now);

2522

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

2523

g_assert_true(mandos_client_exited);

2524

2525

g_assert_true(password_is_read);

2526

g_assert_nonnull(password.data);

2527

2528

uintmax_t id;

2529

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

2530

==, 1);

2531

g_assert_true((uid_t)id == id);

2532

2533

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

2534

}

2535

2536

static void test_start_mandos_client_suid_rgid(test_fixture *fixture,

2537

__attribute__((unused))

2538

gconstpointer

2539

user_data){

2540

if(not is_privileged()){

2541

g_test_skip("Not privileged");

2542

return;

2543

}

2544

2545

bool mandos_client_exited = false;

2546

bool quit_now = false;

2547

__attribute__((cleanup(cleanup_close)))

2548

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2549

g_assert_cmpint(epoll_fd, >=, 0);

2550

__attribute__((cleanup(cleanup_queue)))

2551

task_queue *queue = create_queue();

2552

g_assert_nonnull(queue);

2553

__attribute__((cleanup(cleanup_buffer)))

2554

buffer password = {};

2555

bool password_is_read = false;

2556

const char helper_directory[] = "/nonexistent";

2557

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

2558

NULL };

2559

uid_t user = 1000;

2560

gid_t group = 1001;

2561

2562

const bool success = start_mandos_client(queue, epoll_fd,

2563

&mandos_client_exited,

2564

&quit_now, &password,

2565

&password_is_read,

2566

&fixture->orig_sigaction,

2567

fixture->orig_sigmask,

2568

helper_directory, user,

2569

group, argv);

2570

g_assert_true(success);

2571

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

2572

2573

struct timespec starttime, currtime;

2574

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

2575

do {

2576

queue->next_run = 0;

2577

string_set cancelled_filenames = {};

2578

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

2579

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

2580

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

2581

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

2582

and (not quit_now)

2583

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

2584

2585

g_assert_false(quit_now);

2586

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

2587

g_assert_true(mandos_client_exited);

2588

2589

g_assert_true(password_is_read);

2590

g_assert_nonnull(password.data);

2591

2592

uintmax_t id;

2593

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

2594

==, 1);

2595

g_assert_true((gid_t)id == id);

2596

2597

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

2598

}

2599

2600

static void test_start_mandos_client_read(test_fixture *fixture,

2601

__attribute__((unused))

2602

gconstpointer user_data){

2603

bool mandos_client_exited = false;

2604

bool quit_now = false;

2605

__attribute__((cleanup(cleanup_close)))

2606

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2607

g_assert_cmpint(epoll_fd, >=, 0);

2608

__attribute__((cleanup(cleanup_queue)))

2609

task_queue *queue = create_queue();

2610

g_assert_nonnull(queue);

2611

__attribute__((cleanup(cleanup_buffer)))

2612

buffer password = {};

2613

bool password_is_read = false;

2614

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

2615

const char helper_directory[] = "/nonexistent";

2616

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

2617

NULL };

2618

2619

const bool success = start_mandos_client(queue, epoll_fd,

2620

&mandos_client_exited,

2621

&quit_now, &password,

2622

&password_is_read,

2623

&fixture->orig_sigaction,

2624

fixture->orig_sigmask,

2625

helper_directory, 0, 0,

2626

argv);

2627

g_assert_true(success);

2628

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

2629

2630

struct timespec starttime, currtime;

2631

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

2632

do {

2633

queue->next_run = 0;

2634

string_set cancelled_filenames = {};

2635

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

2636

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

2637

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

2638

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

2639

and (not quit_now)

2640

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

2641

2642

g_assert_false(quit_now);

2643

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

2644

g_assert_true(mandos_client_exited);

2645

2646

g_assert_true(password_is_read);

2647

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

2648

sizeof(dummy_test_password)-1);

2649

g_assert_nonnull(password.data);

2650

g_assert_cmpint(memcmp(dummy_test_password, password.data,

2651

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

2652

}

2653

2654

static

2655

void test_start_mandos_client_helper_directory(test_fixture *fixture,

2656

__attribute__((unused))

2657

gconstpointer

2658

user_data){

2659

bool mandos_client_exited = false;

2660

bool quit_now = false;

2661

__attribute__((cleanup(cleanup_close)))

2662

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2663

g_assert_cmpint(epoll_fd, >=, 0);

2664

__attribute__((cleanup(cleanup_queue)))

2665

task_queue *queue = create_queue();

2666

g_assert_nonnull(queue);

2667

__attribute__((cleanup(cleanup_buffer)))

2668

buffer password = {};

2669

bool password_is_read = false;

2670

const char helper_directory[] = "/nonexistent";

2671

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

2672

"printf %s \"${MANDOSPLUGINHELPERDIR}\"", NULL };

2673

2674

const bool success = start_mandos_client(queue, epoll_fd,

2675

&mandos_client_exited,

2676

&quit_now, &password,

2677

&password_is_read,

2678

&fixture->orig_sigaction,

2679

fixture->orig_sigmask,

2680

helper_directory, 0, 0,

2681

argv);

2682

g_assert_true(success);

2683

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

2684

2685

struct timespec starttime, currtime;

2686

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

2687

do {

2688

queue->next_run = 0;

2689

string_set cancelled_filenames = {};

2690

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

2691

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

2692

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

2693

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

2694

and (not quit_now)

2695

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

2696

2697

g_assert_false(quit_now);

2698

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

2699

g_assert_true(mandos_client_exited);

2700

2701

g_assert_true(password_is_read);

2702

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

2703

sizeof(helper_directory)-1);

2704

g_assert_nonnull(password.data);

2705

g_assert_cmpint(memcmp(helper_directory, password.data,

2706

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

2707

}

2708

2709

__attribute__((nonnull, warn_unused_result))

2710

static bool proc_status_sigblk_to_sigset(const char *const,

2711

sigset_t *const);

2712

2713

static void test_start_mandos_client_sigmask(test_fixture *fixture,

2714

__attribute__((unused))

2715

gconstpointer user_data){

2716

bool mandos_client_exited = false;

2717

bool quit_now = false;

2718

__attribute__((cleanup(cleanup_close)))

2719

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2720

g_assert_cmpint(epoll_fd, >=, 0);

2721

__attribute__((cleanup(cleanup_queue)))

2722

task_queue *queue = create_queue();

2723

g_assert_nonnull(queue);

2724

__attribute__((cleanup(cleanup_buffer)))

2725

buffer password = {};

2726

bool password_is_read = false;

2727

const char helper_directory[] = "/nonexistent";

2728

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

2729

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

2730

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

2731

2732

g_assert_true(start_mandos_client(queue, epoll_fd,

2733

&mandos_client_exited, &quit_now,

2734

&password, &password_is_read,

2735

&fixture->orig_sigaction,

2736

fixture->orig_sigmask,

2737

helper_directory, 0, 0, argv));

2738

2739

struct timespec starttime, currtime;

2740

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

2741

do {

2742

queue->next_run = 0;

2743

string_set cancelled_filenames = {};

2744

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

2745

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

2746

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

2747

} while((not (mandos_client_exited and password_is_read))

2748

and (not quit_now)

2749

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

2750

g_assert_true(mandos_client_exited);

2751

g_assert_true(password_is_read);

2752

2753

sigset_t parsed_sigmask;

2754

g_assert_true(proc_status_sigblk_to_sigset(password.data,

2755

&parsed_sigmask));

2756

2757

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

2758

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

2759

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

2760

g_assert_true(has_signal);

2761

} else {

2762

g_assert_false(has_signal);

2763

}

2764

}

2765

}

2766

2767

__attribute__((nonnull, warn_unused_result))

2768

static bool proc_status_sigblk_to_sigset(const char *const sigblk,

2769

sigset_t *const sigmask){

2770

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

2771

uintmax_t scanned_sigmask;

2772

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

2773

return false;

2774

}

2775

if(sigemptyset(sigmask) != 0){

2776

return false;

2777

}

2778

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

2779

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

2780

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

2781

return false;

2782

}

2783

}

2784

}

2785

return true;

2786

}

2787

2788

static void run_task_with_stderr_to_dev_null(const task_context task,

2789

task_queue *const queue);

2790

2791

static

2792

void test_wait_for_mandos_client_exit_badpid(__attribute__((unused))

2793

test_fixture *fixture,

2794

__attribute__((unused))

2795

gconstpointer user_data){

2796

2797

bool mandos_client_exited = false;

2798

bool quit_now = false;

2799

2800

__attribute__((cleanup(cleanup_queue)))

2801

task_queue *queue = create_queue();

2802

g_assert_nonnull(queue);

2803

const task_context task = {

2804

.func=wait_for_mandos_client_exit,

2805

.pid=1,

2806

.mandos_client_exited=&mandos_client_exited,

2807

.quit_now=&quit_now,

2808

};

2809

run_task_with_stderr_to_dev_null(task, queue);

2810

2811

g_assert_false(mandos_client_exited);

2812

g_assert_true(quit_now);

2813

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

2814

}

2815

2816

static void run_task_with_stderr_to_dev_null(const task_context task,

2817

task_queue *const queue){

2818

FILE *real_stderr = stderr;

2819

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

2820

g_assert_nonnull(devnull);

2821

2822

stderr = devnull;

2823

task.func(task, queue);

2824

stderr = real_stderr;

2825

2826

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

2827

}

2828

2829

static

2830

void test_wait_for_mandos_client_exit_noexit(test_fixture *fixture,

2831

__attribute__((unused))

2832

gconstpointer user_data){

2833

bool mandos_client_exited = false;

2834

bool quit_now = false;

2835

2836

pid_t create_eternal_process(void){

2837

const pid_t pid = fork();

2838

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

2839

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

2840

_exit(EXIT_FAILURE);

2841

}

2842

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

2843

_exit(EXIT_FAILURE);

2844

}

2845

while(true){

2846

pause();

2847

}

2848

}

2849

return pid;

2850

}

2851

pid_t pid = create_eternal_process();

2852

g_assert_true(pid != -1);

2853

2854

__attribute__((cleanup(cleanup_queue)))

2855

task_queue *queue = create_queue();

2856

g_assert_nonnull(queue);

2857

const task_context task = {

2858

.func=wait_for_mandos_client_exit,

2859

.pid=pid,

2860

.mandos_client_exited=&mandos_client_exited,

2861

.quit_now=&quit_now,

2862

};

2863

task.func(task, queue);

2864

2865

g_assert_false(mandos_client_exited);

2866

g_assert_false(quit_now);

2867

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

2868

2869

g_assert_nonnull(find_matching_task(queue, (task_context){

2870

.func=wait_for_mandos_client_exit,

2871

.pid=task.pid,

2872

.mandos_client_exited=&mandos_client_exited,

2873

.quit_now=&quit_now,

2874

}));

2875

}

2876

2877

static

2878

void test_wait_for_mandos_client_exit_success(test_fixture *fixture,

2879

__attribute__((unused))

2880

gconstpointer

2881

user_data){

2882

bool mandos_client_exited = false;

2883

bool quit_now = false;

2884

2885

pid_t create_successful_process(void){

2886

const pid_t pid = fork();

2887

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

2888

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

2889

_exit(EXIT_FAILURE);

2890

}

2891

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

2892

_exit(EXIT_FAILURE);

2893

}

2894

exit(EXIT_SUCCESS);

2895

}

2896

return pid;

2897

}

2898

const pid_t pid = create_successful_process();

2899

g_assert_true(pid != -1);

2900

2901

__attribute__((cleanup(cleanup_queue)))

2902

task_queue *queue = create_queue();

2903

g_assert_nonnull(queue);

2904

const task_context initial_task = {

2905

.func=wait_for_mandos_client_exit,

2906

.pid=pid,

2907

.mandos_client_exited=&mandos_client_exited,

2908

.quit_now=&quit_now,

2909

};

2910

g_assert_true(add_to_queue(queue, initial_task));

2911

2912

struct timespec starttime, currtime;

2913

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

2914

__attribute__((cleanup(cleanup_close)))

2915

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2916

do {

2917

queue->next_run = 0;

2918

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

2919

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

2920

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

2921

} while((not mandos_client_exited)

2922

and (not quit_now)

2923

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

2924

2925

g_assert_true(mandos_client_exited);

2926

g_assert_false(quit_now);

2927

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

2928

}

2929

2930

static

2931

void test_wait_for_mandos_client_exit_failure(test_fixture *fixture,

2932

__attribute__((unused))

2933

gconstpointer

2934

user_data){

2935

bool mandos_client_exited = false;

2936

bool quit_now = false;

2937

2938

pid_t create_failing_process(void){

2939

const pid_t pid = fork();

2940

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

2941

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

2942

_exit(EXIT_FAILURE);

2943

}

2944

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

2945

_exit(EXIT_FAILURE);

2946

}

2947

exit(EXIT_FAILURE);

2948

}

2949

return pid;

2950

}

2951

const pid_t pid = create_failing_process();

2952

g_assert_true(pid != -1);

2953

2954

__attribute__((cleanup(string_set_clear)))

2955

string_set cancelled_filenames = {};

2956

__attribute__((cleanup(cleanup_close)))

2957

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

2958

g_assert_cmpint(epoll_fd, >=, 0);

2959

__attribute__((cleanup(cleanup_queue)))

2960

task_queue *queue = create_queue();

2961

g_assert_nonnull(queue);

2962

g_assert_true(add_to_queue(queue, (task_context){

2963

.func=wait_for_mandos_client_exit,

2964

.pid=pid,

2965

.mandos_client_exited=&mandos_client_exited,

2966

.quit_now=&quit_now,

2967

}));

2968

2969

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

2970

2971

__attribute__((cleanup(cleanup_close)))

2972

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

2973

O_WRONLY | O_CLOEXEC | O_NOCTTY);

2974

g_assert_cmpint(devnull_fd, >=, 0);

2975

__attribute__((cleanup(cleanup_close)))

2976

const int real_stderr_fd = dup(STDERR_FILENO);

2977

g_assert_cmpint(real_stderr_fd, >=, 0);

2978

2979

struct timespec starttime, currtime;

2980

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

2981

do {

2982

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

2983

dup2(devnull_fd, STDERR_FILENO);

2984

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

2985

&quit_now);

2986

dup2(real_stderr_fd, STDERR_FILENO);

2987

if(not success){

2988

break;

2989

}

2990

2991

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

2992

} while((not mandos_client_exited)

2993

and (not quit_now)

2994

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

2995

2996

g_assert_true(quit_now);

2997

g_assert_true(mandos_client_exited);

2998

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

2999

}

3000

3001

static

3002

void test_wait_for_mandos_client_exit_killed(test_fixture *fixture,

3003

__attribute__((unused))

3004

gconstpointer user_data){

3005

bool mandos_client_exited = false;

3006

bool quit_now = false;

3007

3008

pid_t create_killed_process(void){

3009

const pid_t pid = fork();

3010

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

3011

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

3012

_exit(EXIT_FAILURE);

3013

}

3014

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

3015

_exit(EXIT_FAILURE);

3016

}

3017

while(true){

3018

pause();

3019

}

3020

}

3021

kill(pid, SIGKILL);

3022

return pid;

3023

}

3024

const pid_t pid = create_killed_process();

3025

g_assert_true(pid != -1);

3026

3027

__attribute__((cleanup(string_set_clear)))

3028

string_set cancelled_filenames = {};

3029

__attribute__((cleanup(cleanup_close)))

3030

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3031

g_assert_cmpint(epoll_fd, >=, 0);

3032

__attribute__((cleanup(cleanup_queue)))

3033

task_queue *queue = create_queue();

3034

g_assert_nonnull(queue);

3035

g_assert_true(add_to_queue(queue, (task_context){

3036

.func=wait_for_mandos_client_exit,

3037

.pid=pid,

3038

.mandos_client_exited=&mandos_client_exited,

3039

.quit_now=&quit_now,

3040

}));

3041

3042

__attribute__((cleanup(cleanup_close)))

3043

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

3044

O_WRONLY | O_CLOEXEC, O_NOCTTY);

3045

g_assert_cmpint(devnull_fd, >=, 0);

3046

__attribute__((cleanup(cleanup_close)))

3047

const int real_stderr_fd = dup(STDERR_FILENO);

3048

g_assert_cmpint(real_stderr_fd, >=, 0);

3049

3050

struct timespec starttime, currtime;

3051

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

3052

do {

3053

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

3054

dup2(devnull_fd, STDERR_FILENO);

3055

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

3056

&quit_now);

3057

dup2(real_stderr_fd, STDERR_FILENO);

3058

if(not success){

3059

break;

3060

}

3061

3062

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

3063

} while((not mandos_client_exited)

3064

and (not quit_now)

3065

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

3066

3067

g_assert_true(mandos_client_exited);

3068

g_assert_true(quit_now);

3069

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

3070

}

3071

3072

static bool epoll_set_does_not_contain(int, int);

3073

3074

static

3075

void test_read_mandos_client_output_readerror(__attribute__((unused))

3076

test_fixture *fixture,

3077

__attribute__((unused))

3078

gconstpointer

3079

user_data){

3080

__attribute__((cleanup(cleanup_close)))

3081

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3082

g_assert_cmpint(epoll_fd, >=, 0);

3083

3084

__attribute__((cleanup(cleanup_buffer)))

3085

buffer password = {};

3086

3087

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

3088

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

3089

O_RDONLY | O_CLOEXEC | O_NOCTTY);

3090

3091

bool password_is_read = false;

3092

bool quit_now = false;

3093

__attribute__((cleanup(cleanup_queue)))

3094

task_queue *queue = create_queue();

3095

g_assert_nonnull(queue);

3096

3097

task_context task = {

3098

.func=read_mandos_client_output,

3099

.epoll_fd=epoll_fd,

3100

.fd=fd,

3101

.password=&password,

3102

.password_is_read=&password_is_read,

3103

.quit_now=&quit_now,

3104

};

3105

run_task_with_stderr_to_dev_null(task, queue);

3106

g_assert_false(password_is_read);

3107

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

3108

g_assert_true(quit_now);

3109

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

3110

3111

g_assert_true(epoll_set_does_not_contain(epoll_fd, fd));

3112

3113

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

3114

}

3115

3116

static bool epoll_set_does_not_contain(int epoll_fd, int fd){

3117

return not epoll_set_contains(epoll_fd, fd, 0);

3118

}

3119

3120

static

3121

void test_read_mandos_client_output_nodata(__attribute__((unused))

3122

test_fixture *fixture,

3123

__attribute__((unused))

3124

gconstpointer user_data){

3125

__attribute__((cleanup(cleanup_close)))

3126

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3127

g_assert_cmpint(epoll_fd, >=, 0);

3128

3129

int pipefds[2];

3130

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

3131

3132

__attribute__((cleanup(cleanup_buffer)))

3133

buffer password = {};

3134

3135

bool password_is_read = false;

3136

bool quit_now = false;

3137

__attribute__((cleanup(cleanup_queue)))

3138

task_queue *queue = create_queue();

3139

g_assert_nonnull(queue);

3140

3141

task_context task = {

3142

.func=read_mandos_client_output,

3143

.epoll_fd=epoll_fd,

3144

.fd=pipefds[0],

3145

.password=&password,

3146

.password_is_read=&password_is_read,

3147

.quit_now=&quit_now,

3148

};

3149

task.func(task, queue);

3150

g_assert_false(password_is_read);

3151

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

3152

g_assert_false(quit_now);

3153

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

3154

3155

g_assert_nonnull(find_matching_task(queue, (task_context){

3156

.func=read_mandos_client_output,

3157

.epoll_fd=epoll_fd,

3158

.fd=pipefds[0],

3159

.password=&password,

3160

.password_is_read=&password_is_read,

3161

.quit_now=&quit_now,

3162

}));

3163

3164

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3165

EPOLLIN | EPOLLRDHUP));

3166

3167

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

3168

}

3169

3170

static void test_read_mandos_client_output_eof(__attribute__((unused))

3171

test_fixture *fixture,

3172

__attribute__((unused))

3173

gconstpointer

3174

user_data){

3175

__attribute__((cleanup(cleanup_close)))

3176

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3177

g_assert_cmpint(epoll_fd, >=, 0);

3178

3179

int pipefds[2];

3180

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

3181

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

3182

3183

__attribute__((cleanup(cleanup_buffer)))

3184

buffer password = {};

3185

3186

bool password_is_read = false;

3187

bool quit_now = false;

3188

__attribute__((cleanup(cleanup_queue)))

3189

task_queue *queue = create_queue();

3190

g_assert_nonnull(queue);

3191

3192

task_context task = {

3193

.func=read_mandos_client_output,

3194

.epoll_fd=epoll_fd,

3195

.fd=pipefds[0],

3196

.password=&password,

3197

.password_is_read=&password_is_read,

3198

.quit_now=&quit_now,

3199

};

3200

task.func(task, queue);

3201

g_assert_true(password_is_read);

3202

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

3203

g_assert_false(quit_now);

3204

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

3205

3206

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

3207

3208

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

3209

}

3210

3211

static

3212

void test_read_mandos_client_output_once(__attribute__((unused))

3213

test_fixture *fixture,

3214

__attribute__((unused))

3215

gconstpointer user_data){

3216

__attribute__((cleanup(cleanup_close)))

3217

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3218

g_assert_cmpint(epoll_fd, >=, 0);

3219

3220

int pipefds[2];

3221

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

3222

3223

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

3224

/* Start with a pre-allocated buffer */

3225

__attribute__((cleanup(cleanup_buffer)))

3226

buffer password = {

3227

.data=malloc(sizeof(dummy_test_password)),

3228

.length=0,

3229

.allocated=sizeof(dummy_test_password),

3230

};

3231

g_assert_nonnull(password.data);

3232

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

3233

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

3234

}

3235

3236

bool password_is_read = false;

3237

bool quit_now = false;

3238

__attribute__((cleanup(cleanup_queue)))

3239

task_queue *queue = create_queue();

3240

g_assert_nonnull(queue);

3241

3242

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3243

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

3244

sizeof(dummy_test_password)),

3245

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

3246

3247

task_context task = {

3248

.func=read_mandos_client_output,

3249

.epoll_fd=epoll_fd,

3250

.fd=pipefds[0],

3251

.password=&password,

3252

.password_is_read=&password_is_read,

3253

.quit_now=&quit_now,

3254

};

3255

task.func(task, queue);

3256

3257

g_assert_false(password_is_read);

3258

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

3259

(int)sizeof(dummy_test_password));

3260

g_assert_nonnull(password.data);

3261

g_assert_cmpint(memcmp(password.data, dummy_test_password,

3262

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

3263

3264

g_assert_false(quit_now);

3265

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

3266

3267

g_assert_nonnull(find_matching_task(queue, (task_context){

3268

.func=read_mandos_client_output,

3269

.epoll_fd=epoll_fd,

3270

.fd=pipefds[0],

3271

.password=&password,

3272

.password_is_read=&password_is_read,

3273

.quit_now=&quit_now,

3274

}));

3275

3276

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3277

EPOLLIN | EPOLLRDHUP));

3278

3279

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

3280

}

3281

3282

static

3283

void test_read_mandos_client_output_malloc(__attribute__((unused))

3284

test_fixture *fixture,

3285

__attribute__((unused))

3286

gconstpointer user_data){

3287

__attribute__((cleanup(cleanup_close)))

3288

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3289

g_assert_cmpint(epoll_fd, >=, 0);

3290

3291

int pipefds[2];

3292

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

3293

3294

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

3295

/* Start with an empty buffer */

3296

__attribute__((cleanup(cleanup_buffer)))

3297

buffer password = {};

3298

3299

bool password_is_read = false;

3300

bool quit_now = false;

3301

__attribute__((cleanup(cleanup_queue)))

3302

task_queue *queue = create_queue();

3303

g_assert_nonnull(queue);

3304

3305

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3306

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

3307

sizeof(dummy_test_password)),

3308

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

3309

3310

task_context task = {

3311

.func=read_mandos_client_output,

3312

.epoll_fd=epoll_fd,

3313

.fd=pipefds[0],

3314

.password=&password,

3315

.password_is_read=&password_is_read,

3316

.quit_now=&quit_now,

3317

};

3318

task.func(task, queue);

3319

3320

g_assert_false(password_is_read);

3321

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

3322

(int)sizeof(dummy_test_password));

3323

g_assert_nonnull(password.data);

3324

g_assert_cmpint(memcmp(password.data, dummy_test_password,

3325

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

3326

3327

g_assert_false(quit_now);

3328

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

3329

3330

g_assert_nonnull(find_matching_task(queue, (task_context){

3331

.func=read_mandos_client_output,

3332

.epoll_fd=epoll_fd,

3333

.fd=pipefds[0],

3334

.password=&password,

3335

.password_is_read=&password_is_read,

3336

.quit_now=&quit_now,

3337

}));

3338

3339

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3340

EPOLLIN | EPOLLRDHUP));

3341

3342

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

3343

}

3344

3345

static

3346

void test_read_mandos_client_output_append(__attribute__((unused))

3347

test_fixture *fixture,

3348

__attribute__((unused))

3349

gconstpointer user_data){

3350

__attribute__((cleanup(cleanup_close)))

3351

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3352

g_assert_cmpint(epoll_fd, >=, 0);

3353

3354

int pipefds[2];

3355

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

3356

3357

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

3358

__attribute__((cleanup(cleanup_buffer)))

3359

buffer password = {

3360

.data=malloc(PIPE_BUF),

3361

.length=PIPE_BUF,

3362

.allocated=PIPE_BUF,

3363

};

3364

g_assert_nonnull(password.data);

3365

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

3366

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

3367

}

3368

3369

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

3370

char password_expected[PIPE_BUF];

3371

memcpy(password_expected, password.data, PIPE_BUF);

3372

3373

bool password_is_read = false;

3374

bool quit_now = false;

3375

__attribute__((cleanup(cleanup_queue)))

3376

task_queue *queue = create_queue();

3377

g_assert_nonnull(queue);

3378

3379

g_assert_true(sizeof(dummy_test_password) <= PIPE_BUF);

3380

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

3381

sizeof(dummy_test_password)),

3382

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

3383

3384

task_context task = {

3385

.func=read_mandos_client_output,

3386

.epoll_fd=epoll_fd,

3387

.fd=pipefds[0],

3388

.password=&password,

3389

.password_is_read=&password_is_read,

3390

.quit_now=&quit_now,

3391

};

3392

task.func(task, queue);

3393

3394

g_assert_false(password_is_read);

3395

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

3396

PIPE_BUF + sizeof(dummy_test_password));

3397

g_assert_nonnull(password.data);

3398

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

3399

==, 0);

3400

g_assert_cmpint(memcmp(password.data + PIPE_BUF,

3401

dummy_test_password,

3402

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

3403

g_assert_false(quit_now);

3404

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

3405

3406

g_assert_nonnull(find_matching_task(queue, (task_context){

3407

.func=read_mandos_client_output,

3408

.epoll_fd=epoll_fd,

3409

.fd=pipefds[0],

3410

.password=&password,

3411

.password_is_read=&password_is_read,

3412

.quit_now=&quit_now,

3413

}));

3414

3415

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

3416

EPOLLIN | EPOLLRDHUP));

3417

}

3418

3419

static char *make_temporary_directory(void);

3420

3421

static void test_add_inotify_dir_watch(__attribute__((unused))

3422

test_fixture *fixture,

3423

__attribute__((unused))

3424

gconstpointer user_data){

3425

__attribute__((cleanup(cleanup_close)))

3426

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3427

g_assert_cmpint(epoll_fd, >=, 0);

3428

__attribute__((cleanup(cleanup_queue)))

3429

task_queue *queue = create_queue();

3430

g_assert_nonnull(queue);

3431

__attribute__((cleanup(string_set_clear)))

3432

string_set cancelled_filenames = {};

3433

const mono_microsecs current_time = 0;

3434

3435

bool quit_now = false;

3436

buffer password = {};

3437

bool mandos_client_exited = false;

3438

bool password_is_read = false;

3439

3440

__attribute__((cleanup(cleanup_string)))

3441

char *tempdir = make_temporary_directory();

3442

g_assert_nonnull(tempdir);

3443

3444

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3445

&password, tempdir,

3446

&cancelled_filenames,

3447

&current_time,

3448

&mandos_client_exited,

3449

&password_is_read));

3450

3451

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

3452

3453

const task_context *const added_read_task

3454

= find_matching_task(queue, (task_context){

3455

.func=read_inotify_event,

3456

.epoll_fd=epoll_fd,

3457

.quit_now=&quit_now,

3458

.password=&password,

3459

.filename=tempdir,

3460

.cancelled_filenames=&cancelled_filenames,

3461

.current_time=&current_time,

3462

.mandos_client_exited=&mandos_client_exited,

3463

.password_is_read=&password_is_read,

3464

});

3465

g_assert_nonnull(added_read_task);

3466

3467

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

3468

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3469

g_assert_true(epoll_set_contains(added_read_task->epoll_fd,

3470

added_read_task->fd,

3471

EPOLLIN | EPOLLRDHUP));

3472

3473

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

3474

}

3475

3476

static char *make_temporary_directory(void){

3477

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

3478

g_assert_nonnull(name);

3479

char *result = mkdtemp(name);

3480

if(result == NULL){

3481

free(name);

3482

}

3483

return result;

3484

}

3485

3486

static void test_add_inotify_dir_watch_fail(__attribute__((unused))

3487

test_fixture *fixture,

3488

__attribute__((unused))

3489

gconstpointer user_data){

3490

__attribute__((cleanup(cleanup_close)))

3491

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3492

g_assert_cmpint(epoll_fd, >=, 0);

3493

__attribute__((cleanup(cleanup_queue)))

3494

task_queue *queue = create_queue();

3495

g_assert_nonnull(queue);

3496

__attribute__((cleanup(string_set_clear)))

3497

string_set cancelled_filenames = {};

3498

const mono_microsecs current_time = 0;

3499

3500

bool quit_now = false;

3501

buffer password = {};

3502

bool mandos_client_exited = false;

3503

bool password_is_read = false;

3504

3505

const char nonexistent_dir[] = "/nonexistent";

3506

3507

FILE *real_stderr = stderr;

3508

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

3509

g_assert_nonnull(devnull);

3510

stderr = devnull;

3511

g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3512

&password, nonexistent_dir,

3513

&cancelled_filenames,

3514

&current_time,

3515

&mandos_client_exited,

3516

&password_is_read));

3517

stderr = real_stderr;

3518

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

3519

3520

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

3521

}

3522

3523

static void test_add_inotify_dir_watch_nondir(__attribute__((unused))

3524

test_fixture *fixture,

3525

__attribute__((unused))

3526

gconstpointer

3527

user_data){

3528

__attribute__((cleanup(cleanup_close)))

3529

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3530

g_assert_cmpint(epoll_fd, >=, 0);

3531

__attribute__((cleanup(cleanup_queue)))

3532

task_queue *queue = create_queue();

3533

g_assert_nonnull(queue);

3534

__attribute__((cleanup(string_set_clear)))

3535

string_set cancelled_filenames = {};

3536

const mono_microsecs current_time = 0;

3537

3538

bool quit_now = false;

3539

buffer password = {};

3540

bool mandos_client_exited = false;

3541

bool password_is_read = false;

3542

3543

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

3544

3545

FILE *real_stderr = stderr;

3546

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

3547

g_assert_nonnull(devnull);

3548

stderr = devnull;

3549

g_assert_false(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3550

&password, not_a_directory,

3551

&cancelled_filenames,

3552

&current_time,

3553

&mandos_client_exited,

3554

&password_is_read));

3555

stderr = real_stderr;

3556

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

3557

3558

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

3559

}

3560

3561

static void test_add_inotify_dir_watch_EAGAIN(__attribute__((unused))

3562

test_fixture *fixture,

3563

__attribute__((unused))

3564

gconstpointer

3565

user_data){

3566

__attribute__((cleanup(cleanup_close)))

3567

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3568

g_assert_cmpint(epoll_fd, >=, 0);

3569

__attribute__((cleanup(cleanup_queue)))

3570

task_queue *queue = create_queue();

3571

g_assert_nonnull(queue);

3572

__attribute__((cleanup(string_set_clear)))

3573

string_set cancelled_filenames = {};

3574

const mono_microsecs current_time = 0;

3575

3576

bool quit_now = false;

3577

buffer password = {};

3578

bool mandos_client_exited = false;

3579

bool password_is_read = false;

3580

3581

__attribute__((cleanup(cleanup_string)))

3582

char *tempdir = make_temporary_directory();

3583

g_assert_nonnull(tempdir);

3584

3585

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3586

&password, tempdir,

3587

&cancelled_filenames,

3588

&current_time,

3589

&mandos_client_exited,

3590

&password_is_read));

3591

3592

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

3593

3594

const task_context *const added_read_task

3595

= find_matching_task(queue,

3596

(task_context){ .func=read_inotify_event });

3597

g_assert_nonnull(added_read_task);

3598

3599

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

3600

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3601

3602

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

3603

const size_t ievent_size = (sizeof(struct inotify_event)

3604

+ NAME_MAX + 1);

3605

struct inotify_event *ievent = malloc(ievent_size);

3606

g_assert_nonnull(ievent);

3607

3608

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

3609

-1);

3610

g_assert_cmpint(errno, ==, EAGAIN);

3611

3612

free(ievent);

3613

3614

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

3615

}

3616

3617

static char *make_temporary_file_in_directory(const char

3618

*const dir);

3619

3620

static

3621

void test_add_inotify_dir_watch_IN_CLOSE_WRITE(__attribute__((unused))

3622

test_fixture *fixture,

3623

__attribute__((unused))

3624

gconstpointer

3625

user_data){

3626

__attribute__((cleanup(cleanup_close)))

3627

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3628

g_assert_cmpint(epoll_fd, >=, 0);

3629

__attribute__((cleanup(cleanup_queue)))

3630

task_queue *queue = create_queue();

3631

g_assert_nonnull(queue);

3632

__attribute__((cleanup(string_set_clear)))

3633

string_set cancelled_filenames = {};

3634

const mono_microsecs current_time = 0;

3635

3636

bool quit_now = false;

3637

buffer password = {};

3638

bool mandos_client_exited = false;

3639

bool password_is_read = false;

3640

3641

__attribute__((cleanup(cleanup_string)))

3642

char *tempdir = make_temporary_directory();

3643

g_assert_nonnull(tempdir);

3644

3645

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3646

&password, tempdir,

3647

&cancelled_filenames,

3648

&current_time,

3649

&mandos_client_exited,

3650

&password_is_read));

3651

3652

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

3653

3654

const task_context *const added_read_task

3655

= find_matching_task(queue,

3656

(task_context){ .func=read_inotify_event });

3657

g_assert_nonnull(added_read_task);

3658

3659

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

3660

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3661

3662

__attribute__((cleanup(cleanup_string)))

3663

char *filename = make_temporary_file_in_directory(tempdir);

3664

g_assert_nonnull(filename);

3665

3666

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

3667

const size_t ievent_size = (sizeof(struct inotify_event)

3668

+ NAME_MAX + 1);

3669

struct inotify_event *ievent = malloc(ievent_size);

3670

g_assert_nonnull(ievent);

3671

3672

ssize_t read_size = 0;

3673

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

3674

3675

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

3676

g_assert_true(ievent->mask & IN_CLOSE_WRITE);

3677

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

3678

3679

free(ievent);

3680

3681

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

3682

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

3683

}

3684

3685

static char *make_temporary_prefixed_file_in_directory(const char

3686

*const prefix,

3687

const char

3688

*const dir){

3689

char *filename = NULL;

3690

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

3691

>, 0);

3692

g_assert_nonnull(filename);

3693

const int fd = mkostemp(filename, O_CLOEXEC);

3694

g_assert_cmpint(fd, >=, 0);

3695

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

3696

return filename;

3697

}

3698

3699

static char *make_temporary_file_in_directory(const char

3700

*const dir){

3701

return make_temporary_prefixed_file_in_directory("temp", dir);

3702

}

3703

3704

static

3705

void test_add_inotify_dir_watch_IN_MOVED_TO(__attribute__((unused))

3706

test_fixture *fixture,

3707

__attribute__((unused))

3708

gconstpointer user_data){

3709

__attribute__((cleanup(cleanup_close)))

3710

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3711

g_assert_cmpint(epoll_fd, >=, 0);

3712

__attribute__((cleanup(cleanup_queue)))

3713

task_queue *queue = create_queue();

3714

g_assert_nonnull(queue);

3715

__attribute__((cleanup(string_set_clear)))

3716

string_set cancelled_filenames = {};

3717

const mono_microsecs current_time = 0;

3718

3719

bool quit_now = false;

3720

buffer password = {};

3721

bool mandos_client_exited = false;

3722

bool password_is_read = false;

3723

3724

__attribute__((cleanup(cleanup_string)))

3725

char *watchdir = make_temporary_directory();

3726

g_assert_nonnull(watchdir);

3727

3728

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3729

&password, watchdir,

3730

&cancelled_filenames,

3731

&current_time,

3732

&mandos_client_exited,

3733

&password_is_read));

3734

3735

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

3736

3737

const task_context *const added_read_task

3738

= find_matching_task(queue,

3739

(task_context){ .func=read_inotify_event });

3740

g_assert_nonnull(added_read_task);

3741

3742

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

3743

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3744

3745

char *sourcedir = make_temporary_directory();

3746

g_assert_nonnull(sourcedir);

3747

3748

__attribute__((cleanup(cleanup_string)))

3749

char *filename = make_temporary_file_in_directory(sourcedir);

3750

g_assert_nonnull(filename);

3751

3752

__attribute__((cleanup(cleanup_string)))

3753

char *targetfilename = NULL;

3754

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

3755

basename(filename)), >, 0);

3756

g_assert_nonnull(targetfilename);

3757

3758

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

3759

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

3760

free(sourcedir);

3761

3762

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

3763

const size_t ievent_size = (sizeof(struct inotify_event)

3764

+ NAME_MAX + 1);

3765

struct inotify_event *ievent = malloc(ievent_size);

3766

g_assert_nonnull(ievent);

3767

3768

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

3769

3770

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

3771

g_assert_true(ievent->mask & IN_MOVED_TO);

3772

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

3773

3774

free(ievent);

3775

3776

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

3777

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

3778

}

3779

3780

static

3781

void test_add_inotify_dir_watch_IN_MOVED_FROM(__attribute__((unused))

3782

test_fixture *fixture,

3783

__attribute__((unused))

3784

gconstpointer

3785

user_data){

3786

__attribute__((cleanup(cleanup_close)))

3787

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3788

g_assert_cmpint(epoll_fd, >=, 0);

3789

__attribute__((cleanup(cleanup_queue)))

3790

task_queue *queue = create_queue();

3791

g_assert_nonnull(queue);

3792

__attribute__((cleanup(string_set_clear)))

3793

string_set cancelled_filenames = {};

3794

const mono_microsecs current_time = 0;

3795

3796

bool quit_now = false;

3797

buffer password = {};

3798

bool mandos_client_exited = false;

3799

bool password_is_read = false;

3800

3801

__attribute__((cleanup(cleanup_string)))

3802

char *tempdir = make_temporary_directory();

3803

g_assert_nonnull(tempdir);

3804

3805

__attribute__((cleanup(cleanup_string)))

3806

char *tempfilename = make_temporary_file_in_directory(tempdir);

3807

g_assert_nonnull(tempfilename);

3808

3809

__attribute__((cleanup(cleanup_string)))

3810

char *targetdir = make_temporary_directory();

3811

g_assert_nonnull(targetdir);

3812

3813

__attribute__((cleanup(cleanup_string)))

3814

char *targetfilename = NULL;

3815

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

3816

basename(tempfilename)), >, 0);

3817

g_assert_nonnull(targetfilename);

3818

3819

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3820

&password, tempdir,

3821

&cancelled_filenames,

3822

&current_time,

3823

&mandos_client_exited,

3824

&password_is_read));

3825

3826

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

3827

3828

const task_context *const added_read_task

3829

= find_matching_task(queue,

3830

(task_context){ .func=read_inotify_event });

3831

g_assert_nonnull(added_read_task);

3832

3833

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

3834

const size_t ievent_size = (sizeof(struct inotify_event)

3835

+ NAME_MAX + 1);

3836

struct inotify_event *ievent = malloc(ievent_size);

3837

g_assert_nonnull(ievent);

3838

3839

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

3840

3841

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

3842

g_assert_true(ievent->mask & IN_MOVED_FROM);

3843

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

3844

3845

free(ievent);

3846

3847

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

3848

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

3849

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

3850

}

3851

3852

static

3853

void test_add_inotify_dir_watch_IN_DELETE(__attribute__((unused))

3854

test_fixture *fixture,

3855

__attribute__((unused))

3856

gconstpointer user_data){

3857

__attribute__((cleanup(cleanup_close)))

3858

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3859

g_assert_cmpint(epoll_fd, >=, 0);

3860

__attribute__((cleanup(cleanup_queue)))

3861

task_queue *queue = create_queue();

3862

g_assert_nonnull(queue);

3863

__attribute__((cleanup(string_set_clear)))

3864

string_set cancelled_filenames = {};

3865

const mono_microsecs current_time = 0;

3866

3867

bool quit_now = false;

3868

buffer password = {};

3869

bool mandos_client_exited = false;

3870

bool password_is_read = false;

3871

3872

__attribute__((cleanup(cleanup_string)))

3873

char *tempdir = make_temporary_directory();

3874

g_assert_nonnull(tempdir);

3875

3876

__attribute__((cleanup(cleanup_string)))

3877

char *tempfile = make_temporary_file_in_directory(tempdir);

3878

g_assert_nonnull(tempfile);

3879

3880

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3881

&password, tempdir,

3882

&cancelled_filenames,

3883

&current_time,

3884

&mandos_client_exited,

3885

&password_is_read));

3886

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

3887

3888

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

3889

3890

const task_context *const added_read_task

3891

= find_matching_task(queue,

3892

(task_context){ .func=read_inotify_event });

3893

g_assert_nonnull(added_read_task);

3894

3895

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

3896

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3897

3898

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

3899

const size_t ievent_size = (sizeof(struct inotify_event)

3900

+ NAME_MAX + 1);

3901

struct inotify_event *ievent = malloc(ievent_size);

3902

g_assert_nonnull(ievent);

3903

3904

ssize_t read_size = 0;

3905

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

3906

3907

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

3908

g_assert_true(ievent->mask & IN_DELETE);

3909

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

3910

3911

free(ievent);

3912

3913

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

3914

}

3915

3916

static

3917

void test_add_inotify_dir_watch_IN_EXCL_UNLINK(__attribute__((unused))

3918

test_fixture *fixture,

3919

__attribute__((unused))

3920

gconstpointer

3921

user_data){

3922

__attribute__((cleanup(cleanup_close)))

3923

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3924

g_assert_cmpint(epoll_fd, >=, 0);

3925

__attribute__((cleanup(cleanup_queue)))

3926

task_queue *queue = create_queue();

3927

g_assert_nonnull(queue);

3928

__attribute__((cleanup(string_set_clear)))

3929

string_set cancelled_filenames = {};

3930

const mono_microsecs current_time = 0;

3931

3932

bool quit_now = false;

3933

buffer password = {};

3934

bool mandos_client_exited = false;

3935

bool password_is_read = false;

3936

3937

__attribute__((cleanup(cleanup_string)))

3938

char *tempdir = make_temporary_directory();

3939

g_assert_nonnull(tempdir);

3940

3941

__attribute__((cleanup(cleanup_string)))

3942

char *tempfile = make_temporary_file_in_directory(tempdir);

3943

g_assert_nonnull(tempfile);

3944

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

3945

| O_NOFOLLOW);

3946

g_assert_cmpint(tempfile_fd, >, 2);

3947

3948

g_assert_true(add_inotify_dir_watch(queue, epoll_fd, &quit_now,

3949

&password, tempdir,

3950

&cancelled_filenames,

3951

&current_time,

3952

&mandos_client_exited,

3953

&password_is_read));

3954

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

3955

3956

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

3957

3958

const task_context *const added_read_task

3959

= find_matching_task(queue,

3960

(task_context){ .func=read_inotify_event });

3961

g_assert_nonnull(added_read_task);

3962

3963

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

3964

g_assert_true(fd_has_cloexec_and_nonblock(added_read_task->fd));

3965

3966

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

3967

const size_t ievent_size = (sizeof(struct inotify_event)

3968

+ NAME_MAX + 1);

3969

struct inotify_event *ievent = malloc(ievent_size);

3970

g_assert_nonnull(ievent);

3971

3972

ssize_t read_size = 0;

3973

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

3974

3975

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

3976

g_assert_true(ievent->mask & IN_DELETE);

3977

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

3978

3979

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

3980

3981

/* IN_EXCL_UNLINK should make the closing of the previously unlinked

3982

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

3983

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

3984

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

3985

g_assert_true(errno == EAGAIN);

3986

3987

free(ievent);

3988

3989

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

3990

}

3991

3992

static void test_read_inotify_event_readerror(__attribute__((unused))

3993

test_fixture *fixture,

3994

__attribute__((unused))

3995

gconstpointer

3996

user_data){

3997

__attribute__((cleanup(cleanup_close)))

3998

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

3999

g_assert_cmpint(epoll_fd, >=, 0);

4000

const mono_microsecs current_time = 0;

4001

4002

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

4003

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

4004

O_RDONLY | O_CLOEXEC | O_NOCTTY);

4005

4006

bool quit_now = false;

4007

__attribute__((cleanup(cleanup_queue)))

4008

task_queue *queue = create_queue();

4009

g_assert_nonnull(queue);

4010

4011

task_context task = {

4012

.func=read_inotify_event,

4013

.epoll_fd=epoll_fd,

4014

.fd=fd,

4015

.quit_now=&quit_now,

4016

.filename=strdup("/nonexistent"),

4017

.cancelled_filenames = &(string_set){},

4018

.notafter=0,

4019

.current_time=&current_time,

4020

};

4021

g_assert_nonnull(task.filename);

4022

run_task_with_stderr_to_dev_null(task, queue);

4023

g_assert_true(quit_now);

4024

g_assert_true(queue->next_run == 0);

4025

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

4026

4027

g_assert_true(epoll_set_does_not_contain(epoll_fd, fd));

4028

4029

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

4030

}

4031

4032

static void test_read_inotify_event_bad_epoll(__attribute__((unused))

4033

test_fixture *fixture,

4034

__attribute__((unused))

4035

gconstpointer

4036

user_data){

4037

const mono_microsecs current_time = 17;

4038

4039

int pipefds[2];

4040

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

4041

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

4042

4043

bool quit_now = false;

4044

buffer password = {};

4045

bool mandos_client_exited = false;

4046

bool password_is_read = false;

4047

__attribute__((cleanup(cleanup_queue)))

4048

task_queue *queue = create_queue();

4049

g_assert_nonnull(queue);

4050

4051

task_context task = {

4052

.func=read_inotify_event,

4053

.epoll_fd=epoll_fd,

4054

.fd=pipefds[0],

4055

.quit_now=&quit_now,

4056

.password=&password,

4057

.filename=strdup("/nonexistent"),

4058

.cancelled_filenames = &(string_set){},

4059

.notafter=0,

4060

.current_time=&current_time,

4061

.mandos_client_exited=&mandos_client_exited,

4062

.password_is_read=&password_is_read,

4063

};

4064

g_assert_nonnull(task.filename);

4065

run_task_with_stderr_to_dev_null(task, queue);

4066

4067

g_assert_nonnull(find_matching_task(queue, task));

4068

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

4069

4070

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

4071

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

4072

}

4073

4074

static void test_read_inotify_event_nodata(__attribute__((unused))

4075

test_fixture *fixture,

4076

__attribute__((unused))

4077

gconstpointer user_data){

4078

__attribute__((cleanup(cleanup_close)))

4079

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4080

g_assert_cmpint(epoll_fd, >=, 0);

4081

const mono_microsecs current_time = 0;

4082

4083

int pipefds[2];

4084

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

4085

4086

bool quit_now = false;

4087

buffer password = {};

4088

bool mandos_client_exited = false;

4089

bool password_is_read = false;

4090

__attribute__((cleanup(cleanup_queue)))

4091

task_queue *queue = create_queue();

4092

g_assert_nonnull(queue);

4093

4094

task_context task = {

4095

.func=read_inotify_event,

4096

.epoll_fd=epoll_fd,

4097

.fd=pipefds[0],

4098

.quit_now=&quit_now,

4099

.password=&password,

4100

.filename=strdup("/nonexistent"),

4101

.cancelled_filenames = &(string_set){},

4102

.notafter=0,

4103

.current_time=&current_time,

4104

.mandos_client_exited=&mandos_client_exited,

4105

.password_is_read=&password_is_read,

4106

};

4107

g_assert_nonnull(task.filename);

4108

task.func(task, queue);

4109

g_assert_false(quit_now);

4110

g_assert_true(queue->next_run == 0);

4111

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

4112

4113

g_assert_nonnull(find_matching_task(queue, (task_context){

4114

.func=read_inotify_event,

4115

.epoll_fd=epoll_fd,

4116

.fd=pipefds[0],

4117

.quit_now=&quit_now,

4118

.password=&password,

4119

.filename=task.filename,

4120

.cancelled_filenames=task.cancelled_filenames,

4121

.current_time=&current_time,

4122

.mandos_client_exited=&mandos_client_exited,

4123

.password_is_read=&password_is_read,

4124

}));

4125

4126

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4127

EPOLLIN | EPOLLRDHUP));

4128

4129

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

4130

}

4131

4132

static void test_read_inotify_event_eof(__attribute__((unused))

4133

test_fixture *fixture,

4134

__attribute__((unused))

4135

gconstpointer user_data){

4136

__attribute__((cleanup(cleanup_close)))

4137

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4138

g_assert_cmpint(epoll_fd, >=, 0);

4139

const mono_microsecs current_time = 0;

4140

4141

int pipefds[2];

4142

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

4143

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

4144

4145

bool quit_now = false;

4146

buffer password = {};

4147

__attribute__((cleanup(cleanup_queue)))

4148

task_queue *queue = create_queue();

4149

g_assert_nonnull(queue);

4150

4151

task_context task = {

4152

.func=read_inotify_event,

4153

.epoll_fd=epoll_fd,

4154

.fd=pipefds[0],

4155

.quit_now=&quit_now,

4156

.password=&password,

4157

.filename=strdup("/nonexistent"),

4158

.cancelled_filenames = &(string_set){},

4159

.notafter=0,

4160

.current_time=&current_time,

4161

};

4162

run_task_with_stderr_to_dev_null(task, queue);

4163

g_assert_true(quit_now);

4164

g_assert_true(queue->next_run == 0);

4165

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

4166

4167

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

4168

4169

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

4170

}

4171

4172

static

4173

void test_read_inotify_event_IN_CLOSE_WRITE(__attribute__((unused))

4174

test_fixture *fixture,

4175

__attribute__((unused))

4176

gconstpointer user_data){

4177

__attribute__((cleanup(cleanup_close)))

4178

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4179

g_assert_cmpint(epoll_fd, >=, 0);

4180

const mono_microsecs current_time = 0;

4181

4182

int pipefds[2];

4183

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

4184

4185

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

4186

const size_t ievent_max_size = (sizeof(struct inotify_event)

4187

+ NAME_MAX + 1);

4188

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4189

struct {

4190

struct inotify_event event;

4191

char name_buffer[NAME_MAX + 1];

4192

} ievent_buffer;

4193

struct inotify_event *const ievent = &ievent_buffer.event;

4194

4195

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

4196

ievent->mask = IN_CLOSE_WRITE;

4197

ievent->len = sizeof(dummy_file_name);

4198

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

4199

const size_t ievent_size = (sizeof(struct inotify_event)

4200

+ sizeof(dummy_file_name));

4201

#if defined(__GNUC__) and __GNUC__ >= 11

4202

#pragma GCC diagnostic push

4203

/* ievent is pointing into a struct which is of sufficient size */

4204

#pragma GCC diagnostic ignored "-Wstringop-overread"

4205

#endif

4206

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

4207

==, ievent_size);

4208

#if defined(__GNUC__) and __GNUC__ >= 11

4209

#pragma GCC diagnostic pop

4210

#endif

4211

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

4212

4213

bool quit_now = false;

4214

buffer password = {};

4215

bool mandos_client_exited = false;

4216

bool password_is_read = false;

4217

__attribute__((cleanup(cleanup_queue)))

4218

task_queue *queue = create_queue();

4219

g_assert_nonnull(queue);

4220

4221

task_context task = {

4222

.func=read_inotify_event,

4223

.epoll_fd=epoll_fd,

4224

.fd=pipefds[0],

4225

.quit_now=&quit_now,

4226

.password=&password,

4227

.filename=strdup("/nonexistent"),

4228

.cancelled_filenames = &(string_set){},

4229

.notafter=0,

4230

.current_time=&current_time,

4231

.mandos_client_exited=&mandos_client_exited,

4232

.password_is_read=&password_is_read,

4233

};

4234

task.func(task, queue);

4235

g_assert_false(quit_now);

4236

g_assert_true(queue->next_run != 0);

4237

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

4238

4239

g_assert_nonnull(find_matching_task(queue, (task_context){

4240

.func=read_inotify_event,

4241

.epoll_fd=epoll_fd,

4242

.fd=pipefds[0],

4243

.quit_now=&quit_now,

4244

.password=&password,

4245

.filename=task.filename,

4246

.cancelled_filenames=task.cancelled_filenames,

4247

.current_time=&current_time,

4248

.mandos_client_exited=&mandos_client_exited,

4249

.password_is_read=&password_is_read,

4250

}));

4251

4252

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4253

EPOLLIN | EPOLLRDHUP));

4254

4255

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

4256

4257

__attribute__((cleanup(cleanup_string)))

4258

char *filename = NULL;

4259

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

4260

dummy_file_name), >, 0);

4261

g_assert_nonnull(filename);

4262

g_assert_nonnull(find_matching_task(queue, (task_context){

4263

.func=open_and_parse_question,

4264

.epoll_fd=epoll_fd,

4265

.filename=filename,

4266

.question_filename=filename,

4267

.password=&password,

4268

.cancelled_filenames=task.cancelled_filenames,

4269

.current_time=&current_time,

4270

.mandos_client_exited=&mandos_client_exited,

4271

.password_is_read=&password_is_read,

4272

}));

4273

}

4274

4275

static

4276

void test_read_inotify_event_IN_MOVED_TO(__attribute__((unused))

4277

test_fixture *fixture,

4278

__attribute__((unused))

4279

gconstpointer user_data){

4280

__attribute__((cleanup(cleanup_close)))

4281

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4282

g_assert_cmpint(epoll_fd, >=, 0);

4283

const mono_microsecs current_time = 0;

4284

4285

int pipefds[2];

4286

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

4287

4288

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

4289

const size_t ievent_max_size = (sizeof(struct inotify_event)

4290

+ NAME_MAX + 1);

4291

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4292

struct {

4293

struct inotify_event event;

4294

char name_buffer[NAME_MAX + 1];

4295

} ievent_buffer;

4296

struct inotify_event *const ievent = &ievent_buffer.event;

4297

4298

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

4299

ievent->mask = IN_MOVED_TO;

4300

ievent->len = sizeof(dummy_file_name);

4301

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

4302

const size_t ievent_size = (sizeof(struct inotify_event)

4303

+ sizeof(dummy_file_name));

4304

#if defined(__GNUC__) and __GNUC__ >= 11

4305

#pragma GCC diagnostic push

4306

/* ievent is pointing into a struct which is of sufficient size */

4307

#pragma GCC diagnostic ignored "-Wstringop-overread"

4308

#endif

4309

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

4310

==, ievent_size);

4311

#if defined(__GNUC__) and __GNUC__ >= 11

4312

#pragma GCC diagnostic pop

4313

#endif

4314

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

4315

4316

bool quit_now = false;

4317

buffer password = {};

4318

bool mandos_client_exited = false;

4319

bool password_is_read = false;

4320

__attribute__((cleanup(cleanup_queue)))

4321

task_queue *queue = create_queue();

4322

g_assert_nonnull(queue);

4323

4324

task_context task = {

4325

.func=read_inotify_event,

4326

.epoll_fd=epoll_fd,

4327

.fd=pipefds[0],

4328

.quit_now=&quit_now,

4329

.password=&password,

4330

.filename=strdup("/nonexistent"),

4331

.cancelled_filenames = &(string_set){},

4332

.notafter=0,

4333

.current_time=&current_time,

4334

.mandos_client_exited=&mandos_client_exited,

4335

.password_is_read=&password_is_read,

4336

};

4337

task.func(task, queue);

4338

g_assert_false(quit_now);

4339

g_assert_true(queue->next_run != 0);

4340

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

4341

4342

g_assert_nonnull(find_matching_task(queue, (task_context){

4343

.func=read_inotify_event,

4344

.epoll_fd=epoll_fd,

4345

.fd=pipefds[0],

4346

.quit_now=&quit_now,

4347

.password=&password,

4348

.filename=task.filename,

4349

.cancelled_filenames=task.cancelled_filenames,

4350

.current_time=&current_time,

4351

.mandos_client_exited=&mandos_client_exited,

4352

.password_is_read=&password_is_read,

4353

}));

4354

4355

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4356

EPOLLIN | EPOLLRDHUP));

4357

4358

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

4359

4360

__attribute__((cleanup(cleanup_string)))

4361

char *filename = NULL;

4362

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

4363

dummy_file_name), >, 0);

4364

g_assert_nonnull(filename);

4365

g_assert_nonnull(find_matching_task(queue, (task_context){

4366

.func=open_and_parse_question,

4367

.epoll_fd=epoll_fd,

4368

.filename=filename,

4369

.question_filename=filename,

4370

.password=&password,

4371

.cancelled_filenames=task.cancelled_filenames,

4372

.current_time=&current_time,

4373

.mandos_client_exited=&mandos_client_exited,

4374

.password_is_read=&password_is_read,

4375

}));

4376

}

4377

4378

static

4379

void test_read_inotify_event_IN_MOVED_FROM(__attribute__((unused))

4380

test_fixture *fixture,

4381

__attribute__((unused))

4382

gconstpointer user_data){

4383

__attribute__((cleanup(cleanup_close)))

4384

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4385

g_assert_cmpint(epoll_fd, >=, 0);

4386

__attribute__((cleanup(string_set_clear)))

4387

string_set cancelled_filenames = {};

4388

const mono_microsecs current_time = 0;

4389

4390

int pipefds[2];

4391

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

4392

4393

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

4394

const size_t ievent_max_size = (sizeof(struct inotify_event)

4395

+ NAME_MAX + 1);

4396

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4397

struct {

4398

struct inotify_event event;

4399

char name_buffer[NAME_MAX + 1];

4400

} ievent_buffer;

4401

struct inotify_event *const ievent = &ievent_buffer.event;

4402

4403

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

4404

ievent->mask = IN_MOVED_FROM;

4405

ievent->len = sizeof(dummy_file_name);

4406

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

4407

const size_t ievent_size = (sizeof(struct inotify_event)

4408

+ sizeof(dummy_file_name));

4409

#if defined(__GNUC__) and __GNUC__ >= 11

4410

#pragma GCC diagnostic push

4411

/* ievent is pointing into a struct which is of sufficient size */

4412

#pragma GCC diagnostic ignored "-Wstringop-overread"

4413

#endif

4414

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

4415

==, ievent_size);

4416

#if defined(__GNUC__) and __GNUC__ >= 11

4417

#pragma GCC diagnostic pop

4418

#endif

4419

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

4420

4421

bool quit_now = false;

4422

buffer password = {};

4423

bool mandos_client_exited = false;

4424

bool password_is_read = false;

4425

__attribute__((cleanup(cleanup_queue)))

4426

task_queue *queue = create_queue();

4427

g_assert_nonnull(queue);

4428

4429

task_context task = {

4430

.func=read_inotify_event,

4431

.epoll_fd=epoll_fd,

4432

.fd=pipefds[0],

4433

.quit_now=&quit_now,

4434

.password=&password,

4435

.filename=strdup("/nonexistent"),

4436

.cancelled_filenames=&cancelled_filenames,

4437

.current_time=&current_time,

4438

.mandos_client_exited=&mandos_client_exited,

4439

.password_is_read=&password_is_read,

4440

};

4441

task.func(task, queue);

4442

g_assert_false(quit_now);

4443

g_assert_true(queue->next_run == 0);

4444

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

4445

4446

g_assert_nonnull(find_matching_task(queue, (task_context){

4447

.func=read_inotify_event,

4448

.epoll_fd=epoll_fd,

4449

.fd=pipefds[0],

4450

.quit_now=&quit_now,

4451

.password=&password,

4452

.filename=task.filename,

4453

.cancelled_filenames=&cancelled_filenames,

4454

.current_time=&current_time,

4455

.mandos_client_exited=&mandos_client_exited,

4456

.password_is_read=&password_is_read,

4457

}));

4458

4459

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4460

EPOLLIN | EPOLLRDHUP));

4461

4462

__attribute__((cleanup(cleanup_string)))

4463

char *filename = NULL;

4464

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

4465

dummy_file_name), >, 0);

4466

g_assert_nonnull(filename);

4467

g_assert_true(string_set_contains(*task.cancelled_filenames,

4468

filename));

4469

}

4470

4471

static void test_read_inotify_event_IN_DELETE(__attribute__((unused))

4472

test_fixture *fixture,

4473

__attribute__((unused))

4474

gconstpointer

4475

user_data){

4476

__attribute__((cleanup(cleanup_close)))

4477

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4478

g_assert_cmpint(epoll_fd, >=, 0);

4479

__attribute__((cleanup(string_set_clear)))

4480

string_set cancelled_filenames = {};

4481

const mono_microsecs current_time = 0;

4482

4483

int pipefds[2];

4484

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

4485

4486

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

4487

const size_t ievent_max_size = (sizeof(struct inotify_event)

4488

+ NAME_MAX + 1);

4489

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4490

struct {

4491

struct inotify_event event;

4492

char name_buffer[NAME_MAX + 1];

4493

} ievent_buffer;

4494

struct inotify_event *const ievent = &ievent_buffer.event;

4495

4496

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

4497

ievent->mask = IN_DELETE;

4498

ievent->len = sizeof(dummy_file_name);

4499

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

4500

const size_t ievent_size = (sizeof(struct inotify_event)

4501

+ sizeof(dummy_file_name));

4502

#if defined(__GNUC__) and __GNUC__ >= 11

4503

#pragma GCC diagnostic push

4504

/* ievent is pointing into a struct which is of sufficient size */

4505

#pragma GCC diagnostic ignored "-Wstringop-overread"

4506

#endif

4507

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

4508

==, ievent_size);

4509

#if defined(__GNUC__) and __GNUC__ >= 11

4510

#pragma GCC diagnostic pop

4511

#endif

4512

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

4513

4514

bool quit_now = false;

4515

buffer password = {};

4516

bool mandos_client_exited = false;

4517

bool password_is_read = false;

4518

__attribute__((cleanup(cleanup_queue)))

4519

task_queue *queue = create_queue();

4520

g_assert_nonnull(queue);

4521

4522

task_context task = {

4523

.func=read_inotify_event,

4524

.epoll_fd=epoll_fd,

4525

.fd=pipefds[0],

4526

.quit_now=&quit_now,

4527

.password=&password,

4528

.filename=strdup("/nonexistent"),

4529

.cancelled_filenames=&cancelled_filenames,

4530

.current_time=&current_time,

4531

.mandos_client_exited=&mandos_client_exited,

4532

.password_is_read=&password_is_read,

4533

};

4534

task.func(task, queue);

4535

g_assert_false(quit_now);

4536

g_assert_true(queue->next_run == 0);

4537

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

4538

4539

g_assert_nonnull(find_matching_task(queue, (task_context){

4540

.func=read_inotify_event,

4541

.epoll_fd=epoll_fd,

4542

.fd=pipefds[0],

4543

.quit_now=&quit_now,

4544

.password=&password,

4545

.filename=task.filename,

4546

.cancelled_filenames=&cancelled_filenames,

4547

.current_time=&current_time,

4548

.mandos_client_exited=&mandos_client_exited,

4549

.password_is_read=&password_is_read,

4550

}));

4551

4552

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4553

EPOLLIN | EPOLLRDHUP));

4554

4555

__attribute__((cleanup(cleanup_string)))

4556

char *filename = NULL;

4557

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

4558

dummy_file_name), >, 0);

4559

g_assert_nonnull(filename);

4560

g_assert_true(string_set_contains(*task.cancelled_filenames,

4561

filename));

4562

}

4563

4564

static void

4565

test_read_inotify_event_IN_CLOSE_WRITE_badname(__attribute__((unused))

4566

test_fixture *fixture,

4567

__attribute__((unused))

4568

gconstpointer

4569

user_data){

4570

__attribute__((cleanup(cleanup_close)))

4571

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4572

g_assert_cmpint(epoll_fd, >=, 0);

4573

const mono_microsecs current_time = 0;

4574

4575

int pipefds[2];

4576

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

4577

4578

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

4579

const size_t ievent_max_size = (sizeof(struct inotify_event)

4580

+ NAME_MAX + 1);

4581

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4582

struct {

4583

struct inotify_event event;

4584

char name_buffer[NAME_MAX + 1];

4585

} ievent_buffer;

4586

struct inotify_event *const ievent = &ievent_buffer.event;

4587

4588

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

4589

ievent->mask = IN_CLOSE_WRITE;

4590

ievent->len = sizeof(dummy_file_name);

4591

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

4592

const size_t ievent_size = (sizeof(struct inotify_event)

4593

+ sizeof(dummy_file_name));

4594

#if defined(__GNUC__) and __GNUC__ >= 11

4595

#pragma GCC diagnostic push

4596

/* ievent is pointing into a struct which is of sufficient size */

4597

#pragma GCC diagnostic ignored "-Wstringop-overread"

4598

#endif

4599

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

4600

==, ievent_size);

4601

#if defined(__GNUC__) and __GNUC__ >= 11

4602

#pragma GCC diagnostic pop

4603

#endif

4604

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

4605

4606

bool quit_now = false;

4607

buffer password = {};

4608

bool mandos_client_exited = false;

4609

bool password_is_read = false;

4610

__attribute__((cleanup(cleanup_queue)))

4611

task_queue *queue = create_queue();

4612

g_assert_nonnull(queue);

4613

4614

task_context task = {

4615

.func=read_inotify_event,

4616

.epoll_fd=epoll_fd,

4617

.fd=pipefds[0],

4618

.quit_now=&quit_now,

4619

.password=&password,

4620

.filename=strdup("/nonexistent"),

4621

.cancelled_filenames = &(string_set){},

4622

.notafter=0,

4623

.current_time=&current_time,

4624

.mandos_client_exited=&mandos_client_exited,

4625

.password_is_read=&password_is_read,

4626

};

4627

task.func(task, queue);

4628

g_assert_false(quit_now);

4629

g_assert_true(queue->next_run == 0);

4630

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

4631

4632

g_assert_nonnull(find_matching_task(queue, (task_context){

4633

.func=read_inotify_event,

4634

.epoll_fd=epoll_fd,

4635

.fd=pipefds[0],

4636

.quit_now=&quit_now,

4637

.password=&password,

4638

.filename=task.filename,

4639

.cancelled_filenames=task.cancelled_filenames,

4640

.current_time=&current_time,

4641

.mandos_client_exited=&mandos_client_exited,

4642

.password_is_read=&password_is_read,

4643

}));

4644

4645

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4646

EPOLLIN | EPOLLRDHUP));

4647

}

4648

4649

static void

4650

test_read_inotify_event_IN_MOVED_TO_badname(__attribute__((unused))

4651

test_fixture *fixture,

4652

__attribute__((unused))

4653

gconstpointer user_data){

4654

__attribute__((cleanup(cleanup_close)))

4655

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4656

g_assert_cmpint(epoll_fd, >=, 0);

4657

const mono_microsecs current_time = 0;

4658

4659

int pipefds[2];

4660

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

4661

4662

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

4663

const size_t ievent_max_size = (sizeof(struct inotify_event)

4664

+ NAME_MAX + 1);

4665

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4666

struct {

4667

struct inotify_event event;

4668

char name_buffer[NAME_MAX + 1];

4669

} ievent_buffer;

4670

struct inotify_event *const ievent = &ievent_buffer.event;

4671

4672

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

4673

ievent->mask = IN_MOVED_TO;

4674

ievent->len = sizeof(dummy_file_name);

4675

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

4676

const size_t ievent_size = (sizeof(struct inotify_event)

4677

+ sizeof(dummy_file_name));

4678

#if defined(__GNUC__) and __GNUC__ >= 11

4679

#pragma GCC diagnostic push

4680

/* ievent is pointing into a struct which is of sufficient size */

4681

#pragma GCC diagnostic ignored "-Wstringop-overread"

4682

#endif

4683

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

4684

==, ievent_size);

4685

#if defined(__GNUC__) and __GNUC__ >= 11

4686

#pragma GCC diagnostic pop

4687

#endif

4688

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

4689

4690

bool quit_now = false;

4691

buffer password = {};

4692

bool mandos_client_exited = false;

4693

bool password_is_read = false;

4694

__attribute__((cleanup(cleanup_queue)))

4695

task_queue *queue = create_queue();

4696

g_assert_nonnull(queue);

4697

4698

task_context task = {

4699

.func=read_inotify_event,

4700

.epoll_fd=epoll_fd,

4701

.fd=pipefds[0],

4702

.quit_now=&quit_now,

4703

.password=&password,

4704

.filename=strdup("/nonexistent"),

4705

.cancelled_filenames = &(string_set){},

4706

.notafter=0,

4707

.current_time=&current_time,

4708

.mandos_client_exited=&mandos_client_exited,

4709

.password_is_read=&password_is_read,

4710

};

4711

task.func(task, queue);

4712

g_assert_false(quit_now);

4713

g_assert_true(queue->next_run == 0);

4714

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

4715

4716

g_assert_nonnull(find_matching_task(queue, (task_context){

4717

.func=read_inotify_event,

4718

.epoll_fd=epoll_fd,

4719

.fd=pipefds[0],

4720

.quit_now=&quit_now,

4721

.password=&password,

4722

.filename=task.filename,

4723

.cancelled_filenames=task.cancelled_filenames,

4724

.current_time=&current_time,

4725

.mandos_client_exited=&mandos_client_exited,

4726

.password_is_read=&password_is_read,

4727

}));

4728

4729

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4730

EPOLLIN | EPOLLRDHUP));

4731

}

4732

4733

static void

4734

test_read_inotify_event_IN_MOVED_FROM_badname(__attribute__((unused))

4735

test_fixture *fixture,

4736

__attribute__((unused))

4737

gconstpointer

4738

user_data){

4739

__attribute__((cleanup(cleanup_close)))

4740

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4741

g_assert_cmpint(epoll_fd, >=, 0);

4742

__attribute__((cleanup(string_set_clear)))

4743

string_set cancelled_filenames = {};

4744

const mono_microsecs current_time = 0;

4745

4746

int pipefds[2];

4747

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

4748

4749

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

4750

const size_t ievent_max_size = (sizeof(struct inotify_event)

4751

+ NAME_MAX + 1);

4752

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4753

struct {

4754

struct inotify_event event;

4755

char name_buffer[NAME_MAX + 1];

4756

} ievent_buffer;

4757

struct inotify_event *const ievent = &ievent_buffer.event;

4758

4759

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

4760

ievent->mask = IN_MOVED_FROM;

4761

ievent->len = sizeof(dummy_file_name);

4762

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

4763

const size_t ievent_size = (sizeof(struct inotify_event)

4764

+ sizeof(dummy_file_name));

4765

#if defined(__GNUC__) and __GNUC__ >= 11

4766

#pragma GCC diagnostic push

4767

/* ievent is pointing into a struct which is of sufficient size */

4768

#pragma GCC diagnostic ignored "-Wstringop-overread"

4769

#endif

4770

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

4771

==, ievent_size);

4772

#if defined(__GNUC__) and __GNUC__ >= 11

4773

#pragma GCC diagnostic pop

4774

#endif

4775

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

4776

4777

bool quit_now = false;

4778

buffer password = {};

4779

bool mandos_client_exited = false;

4780

bool password_is_read = false;

4781

__attribute__((cleanup(cleanup_queue)))

4782

task_queue *queue = create_queue();

4783

g_assert_nonnull(queue);

4784

4785

task_context task = {

4786

.func=read_inotify_event,

4787

.epoll_fd=epoll_fd,

4788

.fd=pipefds[0],

4789

.quit_now=&quit_now,

4790

.password=&password,

4791

.filename=strdup("/nonexistent"),

4792

.cancelled_filenames=&cancelled_filenames,

4793

.current_time=&current_time,

4794

.mandos_client_exited=&mandos_client_exited,

4795

.password_is_read=&password_is_read,

4796

};

4797

task.func(task, queue);

4798

g_assert_false(quit_now);

4799

g_assert_true(queue->next_run == 0);

4800

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

4801

4802

g_assert_nonnull(find_matching_task(queue, (task_context){

4803

.func=read_inotify_event,

4804

.epoll_fd=epoll_fd,

4805

.fd=pipefds[0],

4806

.quit_now=&quit_now,

4807

.password=&password,

4808

.filename=task.filename,

4809

.cancelled_filenames=&cancelled_filenames,

4810

.current_time=&current_time,

4811

.mandos_client_exited=&mandos_client_exited,

4812

.password_is_read=&password_is_read,

4813

}));

4814

4815

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4816

EPOLLIN | EPOLLRDHUP));

4817

4818

__attribute__((cleanup(cleanup_string)))

4819

char *filename = NULL;

4820

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

4821

dummy_file_name), >, 0);

4822

g_assert_nonnull(filename);

4823

g_assert_false(string_set_contains(cancelled_filenames, filename));

4824

}

4825

4826

static

4827

void test_read_inotify_event_IN_DELETE_badname(__attribute__((unused))

4828

test_fixture *fixture,

4829

__attribute__((unused))

4830

gconstpointer

4831

user_data){

4832

__attribute__((cleanup(cleanup_close)))

4833

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4834

g_assert_cmpint(epoll_fd, >=, 0);

4835

__attribute__((cleanup(string_set_clear)))

4836

string_set cancelled_filenames = {};

4837

const mono_microsecs current_time = 0;

4838

4839

int pipefds[2];

4840

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

4841

4842

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

4843

const size_t ievent_max_size = (sizeof(struct inotify_event)

4844

+ NAME_MAX + 1);

4845

g_assert_cmpint(ievent_max_size, <=, PIPE_BUF);

4846

struct {

4847

struct inotify_event event;

4848

char name_buffer[NAME_MAX + 1];

4849

} ievent_buffer;

4850

struct inotify_event *const ievent = &ievent_buffer.event;

4851

4852

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

4853

ievent->mask = IN_DELETE;

4854

ievent->len = sizeof(dummy_file_name);

4855

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

4856

const size_t ievent_size = (sizeof(struct inotify_event)

4857

+ sizeof(dummy_file_name));

4858

#if defined(__GNUC__) and __GNUC__ >= 11

4859

#pragma GCC diagnostic push

4860

/* ievent is pointing into a struct which is of sufficient size */

4861

#pragma GCC diagnostic ignored "-Wstringop-overread"

4862

#endif

4863

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

4864

==, ievent_size);

4865

#if defined(__GNUC__) and __GNUC__ >= 11

4866

#pragma GCC diagnostic pop

4867

#endif

4868

g_assert_cmpint(close(pipefds[1]), ==, 0);

4869

4870

bool quit_now = false;

4871

buffer password = {};

4872

bool mandos_client_exited = false;

4873

bool password_is_read = false;

4874

__attribute__((cleanup(cleanup_queue)))

4875

task_queue *queue = create_queue();

4876

g_assert_nonnull(queue);

4877

4878

task_context task = {

4879

.func=read_inotify_event,

4880

.epoll_fd=epoll_fd,

4881

.fd=pipefds[0],

4882

.quit_now=&quit_now,

4883

.password=&password,

4884

.filename=strdup("/nonexistent"),

4885

.cancelled_filenames=&cancelled_filenames,

4886

.current_time=&current_time,

4887

.mandos_client_exited=&mandos_client_exited,

4888

.password_is_read=&password_is_read,

4889

};

4890

task.func(task, queue);

4891

g_assert_false(quit_now);

4892

g_assert_true(queue->next_run == 0);

4893

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

4894

4895

g_assert_nonnull(find_matching_task(queue, (task_context){

4896

.func=read_inotify_event,

4897

.epoll_fd=epoll_fd,

4898

.fd=pipefds[0],

4899

.quit_now=&quit_now,

4900

.password=&password,

4901

.filename=task.filename,

4902

.cancelled_filenames=&cancelled_filenames,

4903

.current_time=&current_time,

4904

.mandos_client_exited=&mandos_client_exited,

4905

.password_is_read=&password_is_read,

4906

}));

4907

4908

g_assert_true(epoll_set_contains(epoll_fd, pipefds[0],

4909

EPOLLIN | EPOLLRDHUP));

4910

4911

__attribute__((cleanup(cleanup_string)))

4912

char *filename = NULL;

4913

g_assert_cmpint(asprintf(&filename, "%s/%s", task.filename,

4914

dummy_file_name), >, 0);

4915

g_assert_nonnull(filename);

4916

g_assert_false(string_set_contains(cancelled_filenames, filename));

4917

}

4918

4919

static

4920

void test_open_and_parse_question_ENOENT(__attribute__((unused))

4921

test_fixture *fixture,

4922

__attribute__((unused))

4923

gconstpointer user_data){

4924

__attribute__((cleanup(cleanup_close)))

4925

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4926

g_assert_cmpint(epoll_fd, >=, 0);

4927

__attribute__((cleanup(string_set_clear)))

4928

string_set cancelled_filenames = {};

4929

bool mandos_client_exited = false;

4930

bool password_is_read = false;

4931

__attribute__((cleanup(cleanup_queue)))

4932

task_queue *queue = create_queue();

4933

g_assert_nonnull(queue);

4934

4935

char *const filename = strdup("/nonexistent");

4936

g_assert_nonnull(filename);

4937

task_context task = {

4938

.func=open_and_parse_question,

4939

.question_filename=filename,

4940

.epoll_fd=epoll_fd,

4941

.password=(buffer[]){{}},

4942

.filename=filename,

4943

.cancelled_filenames=&cancelled_filenames,

4944

.current_time=(mono_microsecs[]){0},

4945

.mandos_client_exited=&mandos_client_exited,

4946

.password_is_read=&password_is_read,

4947

};

4948

task.func(task, queue);

4949

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4950

}

4951

4952

static void test_open_and_parse_question_EIO(__attribute__((unused))

4953

test_fixture *fixture,

4954

__attribute__((unused))

4955

gconstpointer user_data){

4956

__attribute__((cleanup(cleanup_close)))

4957

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4958

g_assert_cmpint(epoll_fd, >=, 0);

4959

__attribute__((cleanup(string_set_clear)))

4960

string_set cancelled_filenames = {};

4961

buffer password = {};

4962

bool mandos_client_exited = false;

4963

bool password_is_read = false;

4964

__attribute__((cleanup(cleanup_queue)))

4965

task_queue *queue = create_queue();

4966

g_assert_nonnull(queue);

4967

const mono_microsecs current_time = 0;

4968

4969

char *filename = strdup("/proc/self/mem");

4970

task_context task = {

4971

.func=open_and_parse_question,

4972

.question_filename=filename,

4973

.epoll_fd=epoll_fd,

4974

.password=&password,

4975

.filename=filename,

4976

.cancelled_filenames=&cancelled_filenames,

4977

.current_time=&current_time,

4978

.mandos_client_exited=&mandos_client_exited,

4979

.password_is_read=&password_is_read,

4980

};

4981

run_task_with_stderr_to_dev_null(task, queue);

4982

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

4983

}

4984

4985

static void

4986

test_open_and_parse_question_parse_error(__attribute__((unused))

4987

test_fixture *fixture,

4988

__attribute__((unused))

4989

gconstpointer user_data){

4990

__attribute__((cleanup(cleanup_close)))

4991

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

4992

g_assert_cmpint(epoll_fd, >=, 0);

4993

__attribute__((cleanup(string_set_clear)))

4994

string_set cancelled_filenames = {};

4995

__attribute__((cleanup(cleanup_queue)))

4996

task_queue *queue = create_queue();

4997

g_assert_nonnull(queue);

4998

4999

__attribute__((cleanup(cleanup_string)))

5000

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5001

g_assert_nonnull(tempfilename);

5002

int tempfile = mkostemp(tempfilename, O_CLOEXEC);

5003

g_assert_cmpint(tempfile, >, 0);

5004

const char bad_data[] = "this is bad syntax\n";

5005

g_assert_cmpint(write(tempfile, bad_data, sizeof(bad_data)),

5006

==, sizeof(bad_data));

5007

g_assert_cmpint(close(tempfile), ==, 0);

5008

5009

char *const filename = strdup(tempfilename);

5010

g_assert_nonnull(filename);

5011

task_context task = {

5012

.func=open_and_parse_question,

5013

.question_filename=filename,

5014

.epoll_fd=epoll_fd,

5015

.password=(buffer[]){{}},

5016

.filename=filename,

5017

.cancelled_filenames=&cancelled_filenames,

5018

.current_time=(mono_microsecs[]){0},

5019

.mandos_client_exited=(bool[]){false},

5020

.password_is_read=(bool[]){false},

5021

};

5022

run_task_with_stderr_to_dev_null(task, queue);

5023

5024

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5025

5026

g_assert_cmpint(unlink(tempfilename), ==, 0);

5027

}

5028

5029

static

5030

void test_open_and_parse_question_nosocket(__attribute__((unused))

5031

test_fixture *fixture,

5032

__attribute__((unused))

5033

gconstpointer user_data){

5034

__attribute__((cleanup(cleanup_close)))

5035

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5036

g_assert_cmpint(epoll_fd, >=, 0);

5037

__attribute__((cleanup(string_set_clear)))

5038

string_set cancelled_filenames = {};

5039

__attribute__((cleanup(cleanup_queue)))

5040

task_queue *queue = create_queue();

5041

g_assert_nonnull(queue);

5042

5043

__attribute__((cleanup(cleanup_string)))

5044

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5045

g_assert_nonnull(tempfilename);

5046

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5047

g_assert_cmpint(questionfile, >, 0);

5048

FILE *qf = fdopen(questionfile, "w");

5049

g_assert_cmpint(fprintf(qf, "[Ask]\nPID=1\n"), >, 0);

5050

g_assert_cmpint(fclose(qf), ==, 0);

5051

5052

char *const filename = strdup(tempfilename);

5053

g_assert_nonnull(filename);

5054

task_context task = {

5055

.func=open_and_parse_question,

5056

.question_filename=filename,

5057

.epoll_fd=epoll_fd,

5058

.password=(buffer[]){{}},

5059

.filename=filename,

5060

.cancelled_filenames=&cancelled_filenames,

5061

.current_time=(mono_microsecs[]){0},

5062

.mandos_client_exited=(bool[]){false},

5063

.password_is_read=(bool[]){false},

5064

};

5065

run_task_with_stderr_to_dev_null(task, queue);

5066

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5067

5068

g_assert_cmpint(unlink(tempfilename), ==, 0);

5069

}

5070

5071

static

5072

void test_open_and_parse_question_badsocket(__attribute__((unused))

5073

test_fixture *fixture,

5074

__attribute__((unused))

5075

gconstpointer user_data){

5076

__attribute__((cleanup(cleanup_close)))

5077

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5078

g_assert_cmpint(epoll_fd, >=, 0);

5079

__attribute__((cleanup(string_set_clear)))

5080

string_set cancelled_filenames = {};

5081

__attribute__((cleanup(cleanup_queue)))

5082

task_queue *queue = create_queue();

5083

g_assert_nonnull(queue);

5084

5085

__attribute__((cleanup(cleanup_string)))

5086

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5087

g_assert_nonnull(tempfilename);

5088

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5089

g_assert_cmpint(questionfile, >, 0);

5090

FILE *qf = fdopen(questionfile, "w");

5091

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=\nPID=1\n"), >, 0);

5092

g_assert_cmpint(fclose(qf), ==, 0);

5093

5094

char *const filename = strdup(tempfilename);

5095

g_assert_nonnull(filename);

5096

task_context task = {

5097

.func=open_and_parse_question,

5098

.question_filename=filename,

5099

.epoll_fd=epoll_fd,

5100

.password=(buffer[]){{}},

5101

.filename=filename,

5102

.cancelled_filenames=&cancelled_filenames,

5103

.current_time=(mono_microsecs[]){0},

5104

.mandos_client_exited=(bool[]){false},

5105

.password_is_read=(bool[]){false},

5106

};

5107

run_task_with_stderr_to_dev_null(task, queue);

5108

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5109

5110

g_assert_cmpint(unlink(tempfilename), ==, 0);

5111

}

5112

5113

static

5114

void test_open_and_parse_question_nopid(__attribute__((unused))

5115

test_fixture *fixture,

5116

__attribute__((unused))

5117

gconstpointer user_data){

5118

__attribute__((cleanup(cleanup_close)))

5119

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5120

g_assert_cmpint(epoll_fd, >=, 0);

5121

__attribute__((cleanup(string_set_clear)))

5122

string_set cancelled_filenames = {};

5123

__attribute__((cleanup(cleanup_queue)))

5124

task_queue *queue = create_queue();

5125

g_assert_nonnull(queue);

5126

5127

__attribute__((cleanup(cleanup_string)))

5128

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5129

g_assert_nonnull(tempfilename);

5130

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5131

g_assert_cmpint(questionfile, >, 0);

5132

FILE *qf = fdopen(questionfile, "w");

5133

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\n"), >, 0);

5134

g_assert_cmpint(fclose(qf), ==, 0);

5135

5136

char *const filename = strdup(tempfilename);

5137

g_assert_nonnull(filename);

5138

task_context task = {

5139

.func=open_and_parse_question,

5140

.question_filename=filename,

5141

.epoll_fd=epoll_fd,

5142

.password=(buffer[]){{}},

5143

.filename=filename,

5144

.cancelled_filenames=&cancelled_filenames,

5145

.current_time=(mono_microsecs[]){0},

5146

.mandos_client_exited=(bool[]){false},

5147

.password_is_read=(bool[]){false},

5148

};

5149

run_task_with_stderr_to_dev_null(task, queue);

5150

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5151

5152

g_assert_cmpint(unlink(tempfilename), ==, 0);

5153

}

5154

5155

static

5156

void test_open_and_parse_question_badpid(__attribute__((unused))

5157

test_fixture *fixture,

5158

__attribute__((unused))

5159

gconstpointer user_data){

5160

__attribute__((cleanup(cleanup_close)))

5161

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5162

g_assert_cmpint(epoll_fd, >=, 0);

5163

__attribute__((cleanup(string_set_clear)))

5164

string_set cancelled_filenames = {};

5165

__attribute__((cleanup(cleanup_queue)))

5166

task_queue *queue = create_queue();

5167

g_assert_nonnull(queue);

5168

5169

__attribute__((cleanup(cleanup_string)))

5170

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5171

g_assert_nonnull(tempfilename);

5172

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5173

g_assert_cmpint(questionfile, >, 0);

5174

FILE *qf = fdopen(questionfile, "w");

5175

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=\n"),

5176

>, 0);

5177

g_assert_cmpint(fclose(qf), ==, 0);

5178

5179

char *const filename = strdup(tempfilename);

5180

g_assert_nonnull(filename);

5181

task_context task = {

5182

.func=open_and_parse_question,

5183

.question_filename=filename,

5184

.epoll_fd=epoll_fd,

5185

.password=(buffer[]){{}},

5186

.filename=filename,

5187

.cancelled_filenames=&cancelled_filenames,

5188

.current_time=(mono_microsecs[]){0},

5189

.mandos_client_exited=(bool[]){false},

5190

.password_is_read=(bool[]){false},

5191

};

5192

run_task_with_stderr_to_dev_null(task, queue);

5193

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5194

5195

g_assert_cmpint(unlink(tempfilename), ==, 0);

5196

}

5197

5198

static void

5199

test_open_and_parse_question_noexist_pid(__attribute__((unused))

5200

test_fixture *fixture,

5201

__attribute__((unused))

5202

gconstpointer user_data){

5203

__attribute__((cleanup(cleanup_close)))

5204

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5205

g_assert_cmpint(epoll_fd, >=, 0);

5206

__attribute__((cleanup(string_set_clear)))

5207

string_set cancelled_filenames = {};

5208

buffer password = {};

5209

bool mandos_client_exited = false;

5210

bool password_is_read = false;

5211

__attribute__((cleanup(cleanup_queue)))

5212

task_queue *queue = create_queue();

5213

g_assert_nonnull(queue);

5214

const mono_microsecs current_time = 0;

5215

5216

/* Find value of sysctl kernel.pid_max */

5217

uintmax_t pid_max = 0;

5218

FILE *sysctl_pid_max = fopen("/proc/sys/kernel/pid_max", "r");

5219

g_assert_nonnull(sysctl_pid_max);

5220

g_assert_cmpint(fscanf(sysctl_pid_max, "%" PRIuMAX, &pid_max),

5221

==, 1);

5222

g_assert_cmpint(fclose(sysctl_pid_max), ==, 0);

5223

5224

pid_t nonexisting_pid = ((pid_t)pid_max)+1;

5225

g_assert_true(nonexisting_pid > 0); /* Overflow check */

5226

5227

__attribute__((cleanup(cleanup_string)))

5228

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5229

g_assert_nonnull(tempfilename);

5230

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5231

g_assert_cmpint(questionfile, >, 0);

5232

FILE *qf = fdopen(questionfile, "w");

5233

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5234

PRIuMAX"\n", (uintmax_t)nonexisting_pid),

5235

>, 0);

5236

g_assert_cmpint(fclose(qf), ==, 0);

5237

5238

char *const question_filename = strdup(tempfilename);

5239

g_assert_nonnull(question_filename);

5240

task_context task = {

5241

.func=open_and_parse_question,

5242

.question_filename=question_filename,

5243

.epoll_fd=epoll_fd,

5244

.password=&password,

5245

.filename=question_filename,

5246

.cancelled_filenames=&cancelled_filenames,

5247

.current_time=&current_time,

5248

.mandos_client_exited=&mandos_client_exited,

5249

.password_is_read=&password_is_read,

5250

};

5251

run_task_with_stderr_to_dev_null(task, queue);

5252

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5253

5254

g_assert_cmpint(unlink(tempfilename), ==, 0);

5255

}

5256

5257

static void

5258

test_open_and_parse_question_no_notafter(__attribute__((unused))

5259

test_fixture *fixture,

5260

__attribute__((unused))

5261

gconstpointer user_data){

5262

__attribute__((cleanup(cleanup_close)))

5263

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5264

g_assert_cmpint(epoll_fd, >=, 0);

5265

__attribute__((cleanup(string_set_clear)))

5266

string_set cancelled_filenames = {};

5267

buffer password = {};

5268

bool mandos_client_exited = false;

5269

bool password_is_read = false;

5270

__attribute__((cleanup(cleanup_queue)))

5271

task_queue *queue = create_queue();

5272

g_assert_nonnull(queue);

5273

const mono_microsecs current_time = 0;

5274

5275

__attribute__((cleanup(cleanup_string)))

5276

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5277

g_assert_nonnull(tempfilename);

5278

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5279

g_assert_cmpint(questionfile, >, 0);

5280

FILE *qf = fdopen(questionfile, "w");

5281

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5282

PRIuMAX "\n", (uintmax_t)getpid()), >, 0);

5283

g_assert_cmpint(fclose(qf), ==, 0);

5284

5285

char *const filename = strdup(tempfilename);

5286

g_assert_nonnull(filename);

5287

task_context task = {

5288

.func=open_and_parse_question,

5289

.question_filename=filename,

5290

.epoll_fd=epoll_fd,

5291

.password=&password,

5292

.filename=filename,

5293

.cancelled_filenames=&cancelled_filenames,

5294

.current_time=&current_time,

5295

.mandos_client_exited=&mandos_client_exited,

5296

.password_is_read=&password_is_read,

5297

};

5298

task.func(task, queue);

5299

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5300

5301

__attribute__((cleanup(cleanup_string)))

5302

char *socket_filename = strdup("/nonexistent");

5303

g_assert_nonnull(socket_filename);

5304

g_assert_nonnull(find_matching_task(queue, (task_context){

5305

.func=connect_question_socket,

5306

.question_filename=tempfilename,

5307

.filename=socket_filename,

5308

.epoll_fd=epoll_fd,

5309

.password=&password,

5310

.current_time=&current_time,

5311

.mandos_client_exited=&mandos_client_exited,

5312

.password_is_read=&password_is_read,

5313

}));

5314

5315

g_assert_true(queue->next_run != 0);

5316

5317

g_assert_cmpint(unlink(tempfilename), ==, 0);

5318

}

5319

5320

static void

5321

test_open_and_parse_question_bad_notafter(__attribute__((unused))

5322

test_fixture *fixture,

5323

__attribute__((unused))

5324

gconstpointer user_data){

5325

__attribute__((cleanup(cleanup_close)))

5326

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5327

g_assert_cmpint(epoll_fd, >=, 0);

5328

__attribute__((cleanup(string_set_clear)))

5329

string_set cancelled_filenames = {};

5330

buffer password = {};

5331

bool mandos_client_exited = false;

5332

bool password_is_read = false;

5333

__attribute__((cleanup(cleanup_queue)))

5334

task_queue *queue = create_queue();

5335

g_assert_nonnull(queue);

5336

const mono_microsecs current_time = 0;

5337

5338

__attribute__((cleanup(cleanup_string)))

5339

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5340

g_assert_nonnull(tempfilename);

5341

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5342

g_assert_cmpint(questionfile, >, 0);

5343

FILE *qf = fdopen(questionfile, "w");

5344

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5345

PRIuMAX "\nNotAfter=\n",

5346

(uintmax_t)getpid()), >, 0);

5347

g_assert_cmpint(fclose(qf), ==, 0);

5348

5349

char *const filename = strdup(tempfilename);

5350

g_assert_nonnull(filename);

5351

task_context task = {

5352

.func=open_and_parse_question,

5353

.question_filename=filename,

5354

.epoll_fd=epoll_fd,

5355

.password=&password,

5356

.filename=filename,

5357

.cancelled_filenames=&cancelled_filenames,

5358

.current_time=&current_time,

5359

.mandos_client_exited=&mandos_client_exited,

5360

.password_is_read=&password_is_read,

5361

};

5362

run_task_with_stderr_to_dev_null(task, queue);

5363

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5364

5365

__attribute__((cleanup(cleanup_string)))

5366

char *socket_filename = strdup("/nonexistent");

5367

g_assert_nonnull(find_matching_task(queue, (task_context){

5368

.func=connect_question_socket,

5369

.question_filename=tempfilename,

5370

.filename=socket_filename,

5371

.epoll_fd=epoll_fd,

5372

.password=&password,

5373

.current_time=&current_time,

5374

.mandos_client_exited=&mandos_client_exited,

5375

.password_is_read=&password_is_read,

5376

}));

5377

g_assert_true(queue->next_run != 0);

5378

5379

g_assert_cmpint(unlink(tempfilename), ==, 0);

5380

}

5381

5382

static

5383

void assert_open_and_parse_question_with_notafter(const mono_microsecs

5384

current_time,

5385

const mono_microsecs

5386

notafter,

5387

const mono_microsecs

5388

next_queue_run){

5389

__attribute__((cleanup(cleanup_close)))

5390

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5391

g_assert_cmpint(epoll_fd, >=, 0);

5392

__attribute__((cleanup(string_set_clear)))

5393

string_set cancelled_filenames = {};

5394

buffer password = {};

5395

bool mandos_client_exited = false;

5396

bool password_is_read = false;

5397

__attribute__((cleanup(cleanup_queue)))

5398

task_queue *queue = create_queue();

5399

g_assert_nonnull(queue);

5400

queue->next_run = next_queue_run;

5401

5402

__attribute__((cleanup(cleanup_string)))

5403

char *tempfilename = strdup("/tmp/mandosXXXXXX");

5404

g_assert_nonnull(tempfilename);

5405

int questionfile = mkostemp(tempfilename, O_CLOEXEC);

5406

g_assert_cmpint(questionfile, >, 0);

5407

FILE *qf = fdopen(questionfile, "w");

5408

g_assert_cmpint(fprintf(qf, "[Ask]\nSocket=/nonexistent\nPID=%"

5409

PRIuMAX "\nNotAfter=%" PRIuMAX "\n",

5410

(uintmax_t)getpid(), notafter), >, 0);

5411

g_assert_cmpint(fclose(qf), ==, 0);

5412

5413

char *const filename = strdup(tempfilename);

5414

g_assert_nonnull(filename);

5415

task_context task = {

5416

.func=open_and_parse_question,

5417

.question_filename=filename,

5418

.epoll_fd=epoll_fd,

5419

.password=&password,

5420

.filename=filename,

5421

.cancelled_filenames=&cancelled_filenames,

5422

.current_time=&current_time,

5423

.mandos_client_exited=&mandos_client_exited,

5424

.password_is_read=&password_is_read,

5425

};

5426

task.func(task, queue);

5427

5428

if(queue->length >= 1){

5429

__attribute__((cleanup(cleanup_string)))

5430

char *socket_filename = strdup("/nonexistent");

5431

g_assert_nonnull(find_matching_task(queue, (task_context){

5432

.func=connect_question_socket,

5433

.filename=socket_filename,

5434

.epoll_fd=epoll_fd,

5435

.password=&password,

5436

.current_time=&current_time,

5437

.cancelled_filenames=&cancelled_filenames,

5438

.mandos_client_exited=&mandos_client_exited,

5439

.password_is_read=&password_is_read,

5440

}));

5441

g_assert_true(queue->next_run != 0);

5442

}

5443

5444

if(notafter == 0){

5445

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5446

} else if(current_time >= notafter) {

5447

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5448

} else {

5449

g_assert_nonnull(find_matching_task(queue, (task_context){

5450

.func=cancel_old_question,

5451

.question_filename=tempfilename,

5452

.filename=tempfilename,

5453

.notafter=notafter,

5454

.cancelled_filenames=&cancelled_filenames,

5455

.current_time=&current_time,

5456

}));

5457

}

5458

g_assert_true(queue->next_run == 1);

5459

5460

g_assert_cmpint(unlink(tempfilename), ==, 0);

5461

}

5462

5463

static void

5464

test_open_and_parse_question_notafter_0(__attribute__((unused))

5465

test_fixture *fixture,

5466

__attribute__((unused))

5467

gconstpointer user_data){

5468

/* current_time, notafter, next_queue_run */

5469

assert_open_and_parse_question_with_notafter(0, 0, 0);

5470

}

5471

5472

static void

5473

test_open_and_parse_question_notafter_1(__attribute__((unused))

5474

test_fixture *fixture,

5475

__attribute__((unused))

5476

gconstpointer user_data){

5477

/* current_time, notafter, next_queue_run */

5478

assert_open_and_parse_question_with_notafter(0, 1, 0);

5479

}

5480

5481

static void

5482

test_open_and_parse_question_notafter_1_1(__attribute__((unused))

5483

test_fixture *fixture,

5484

__attribute__((unused))

5485

gconstpointer user_data){

5486

/* current_time, notafter, next_queue_run */

5487

assert_open_and_parse_question_with_notafter(0, 1, 1);

5488

}

5489

5490

static void

5491

test_open_and_parse_question_notafter_1_2(__attribute__((unused))

5492

test_fixture *fixture,

5493

__attribute__((unused))

5494

gconstpointer user_data){

5495

/* current_time, notafter, next_queue_run */

5496

assert_open_and_parse_question_with_notafter(0, 1, 2);

5497

}

5498

5499

static void

5500

test_open_and_parse_question_equal_notafter(__attribute__((unused))

5501

test_fixture *fixture,

5502

__attribute__((unused))

5503

gconstpointer user_data){

5504

/* current_time, notafter, next_queue_run */

5505

assert_open_and_parse_question_with_notafter(1, 1, 0);

5506

}

5507

5508

static void

5509

test_open_and_parse_question_late_notafter(__attribute__((unused))

5510

test_fixture *fixture,

5511

__attribute__((unused))

5512

gconstpointer user_data){

5513

/* current_time, notafter, next_queue_run */

5514

assert_open_and_parse_question_with_notafter(2, 1, 0);

5515

}

5516

5517

static void assert_cancel_old_question_param(const mono_microsecs

5518

next_queue_run,

5519

const mono_microsecs

5520

notafter,

5521

const mono_microsecs

5522

current_time,

5523

const mono_microsecs

5524

next_set_to){

5525

__attribute__((cleanup(string_set_clear)))

5526

string_set cancelled_filenames = {};

5527

__attribute__((cleanup(cleanup_queue)))

5528

task_queue *queue = create_queue();

5529

g_assert_nonnull(queue);

5530

queue->next_run = next_queue_run;

5531

5532

char *const question_filename = strdup("/nonexistent");

5533

g_assert_nonnull(question_filename);

5534

task_context task = {

5535

.func=cancel_old_question,

5536

.question_filename=question_filename,

5537

.filename=question_filename,

5538

.notafter=notafter,

5539

.cancelled_filenames=&cancelled_filenames,

5540

.current_time=&current_time,

5541

};

5542

task.func(task, queue);

5543

5544

if(current_time >= notafter){

5545

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5546

g_assert_true(string_set_contains(cancelled_filenames,

5547

"/nonexistent"));

5548

} else {

5549

g_assert_nonnull(find_matching_task(queue, (task_context){

5550

.func=cancel_old_question,

5551

.question_filename=question_filename,

5552

.filename=question_filename,

5553

.notafter=notafter,

5554

.cancelled_filenames=&cancelled_filenames,

5555

.current_time=&current_time,

5556

}));

5557

5558

g_assert_false(string_set_contains(cancelled_filenames,

5559

question_filename));

5560

}

5561

g_assert_cmpuint((unsigned int)queue->next_run, ==,

5562

(unsigned int)next_set_to);

5563

}

5564

5565

static void test_cancel_old_question_0_1_2(__attribute__((unused))

5566

test_fixture *fixture,

5567

__attribute__((unused))

5568

gconstpointer user_data){

5569

/* next_queue_run unset,

5570

cancellation should happen because time has come,

5571

next_queue_run should be unchanged */

5572

/* next_queue_run, notafter, current_time, next_set_to */

5573

assert_cancel_old_question_param(0, 1, 2, 0);

5574

}

5575

5576

static void test_cancel_old_question_0_2_1(__attribute__((unused))

5577

test_fixture *fixture,

5578

__attribute__((unused))

5579

gconstpointer user_data){

5580

/* If next_queue_run is 0, meaning unset, and notafter is 2,

5581

and current_time is not yet notafter or greater,

5582

update value of next_queue_run to value of notafter */

5583

/* next_queue_run, notafter, current_time, next_set_to */

5584

assert_cancel_old_question_param(0, 2, 1, 2);

5585

}

5586

5587

static void test_cancel_old_question_1_2_3(__attribute__((unused))

5588

test_fixture *fixture,

5589

__attribute__((unused))

5590

gconstpointer user_data){

5591

/* next_queue_run 1,

5592

cancellation should happen because time has come,

5593

next_queue_run should be unchanged */

5594

/* next_queue_run, notafter, current_time, next_set_to */

5595

assert_cancel_old_question_param(1, 2, 3, 1);

5596

}

5597

5598

static void test_cancel_old_question_1_3_2(__attribute__((unused))

5599

test_fixture *fixture,

5600

__attribute__((unused))

5601

gconstpointer user_data){

5602

/* If next_queue_run is set,

5603

and current_time is not yet notafter or greater,

5604

and notafter is larger than next_queue_run

5605

next_queue_run should be unchanged */

5606

/* next_queue_run, notafter, current_time, next_set_to */

5607

assert_cancel_old_question_param(1, 3, 2, 1);

5608

}

5609

5610

static void test_cancel_old_question_2_1_3(__attribute__((unused))

5611

test_fixture *fixture,

5612

__attribute__((unused))

5613

gconstpointer user_data){

5614

/* next_queue_run 2,

5615

cancellation should happen because time has come,

5616

next_queue_run should be unchanged */

5617

/* next_queue_run, notafter, current_time, next_set_to */

5618

assert_cancel_old_question_param(2, 1, 3, 2);

5619

}

5620

5621

static void test_cancel_old_question_2_3_1(__attribute__((unused))

5622

test_fixture *fixture,

5623

__attribute__((unused))

5624

gconstpointer user_data){

5625

/* If next_queue_run is set,

5626

and current_time is not yet notafter or greater,

5627

and notafter is larger than next_queue_run

5628

next_queue_run should be unchanged */

5629

/* next_queue_run, notafter, current_time, next_set_to */

5630

assert_cancel_old_question_param(2, 3, 1, 2);

5631

}

5632

5633

static void test_cancel_old_question_3_1_2(__attribute__((unused))

5634

test_fixture *fixture,

5635

__attribute__((unused))

5636

gconstpointer user_data){

5637

/* next_queue_run 3,

5638

cancellation should happen because time has come,

5639

next_queue_run should be unchanged */

5640

/* next_queue_run, notafter, current_time, next_set_to */

5641

assert_cancel_old_question_param(3, 1, 2, 3);

5642

}

5643

5644

static void test_cancel_old_question_3_2_1(__attribute__((unused))

5645

test_fixture *fixture,

5646

__attribute__((unused))

5647

gconstpointer user_data){

5648

/* If next_queue_run is set,

5649

and current_time is not yet notafter or greater,

5650

and notafter is smaller than next_queue_run

5651

update value of next_queue_run to value of notafter */

5652

/* next_queue_run, notafter, current_time, next_set_to */

5653

assert_cancel_old_question_param(3, 2, 1, 2);

5654

}

5655

5656

static void

5657

test_connect_question_socket_name_too_long(__attribute__((unused))

5658

test_fixture *fixture,

5659

__attribute__((unused))

5660

gconstpointer user_data){

5661

__attribute__((cleanup(cleanup_close)))

5662

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5663

g_assert_cmpint(epoll_fd, >=, 0);

5664

const char question_filename[] = "/nonexistent/question";

5665

__attribute__((cleanup(string_set_clear)))

5666

string_set cancelled_filenames = {};

5667

__attribute__((cleanup(cleanup_queue)))

5668

task_queue *queue = create_queue();

5669

g_assert_nonnull(queue);

5670

__attribute__((cleanup(cleanup_string)))

5671

char *tempdir = make_temporary_directory();

5672

g_assert_nonnull(tempdir);

5673

struct sockaddr_un unix_socket = { .sun_family=AF_LOCAL };

5674

char socket_name[sizeof(unix_socket.sun_path)];

5675

memset(socket_name, 'x', sizeof(socket_name));

5676

socket_name[sizeof(socket_name)-1] = '\0';

5677

char *filename = NULL;

5678

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5679

>, 0);

5680

g_assert_nonnull(filename);

5681

5682

task_context task = {

5683

.func=connect_question_socket,

5684

.question_filename=strdup(question_filename),

5685

.epoll_fd=epoll_fd,

5686

.password=(buffer[]){{}},

5687

.filename=filename,

5688

.cancelled_filenames=&cancelled_filenames,

5689

.mandos_client_exited=(bool[]){false},

5690

.password_is_read=(bool[]){false},

5691

.current_time=(mono_microsecs[]){0},

5692

};

5693

g_assert_nonnull(task.question_filename);

5694

run_task_with_stderr_to_dev_null(task, queue);

5695

5696

g_assert_true(string_set_contains(cancelled_filenames,

5697

question_filename));

5698

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

5699

g_assert_true(queue->next_run == 0);

5700

5701

g_assert_cmpint(rmdir(tempdir), ==, 0);

5702

}

5703

5704

static

5705

void test_connect_question_socket_connect_fail(__attribute__((unused))

5706

test_fixture *fixture,

5707

__attribute__((unused))

5708

gconstpointer

5709

user_data){

5710

__attribute__((cleanup(cleanup_close)))

5711

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5712

g_assert_cmpint(epoll_fd, >=, 0);

5713

const char question_filename[] = "/nonexistent/question";

5714

__attribute__((cleanup(string_set_clear)))

5715

string_set cancelled_filenames = {};

5716

const mono_microsecs current_time = 3;

5717

__attribute__((cleanup(cleanup_queue)))

5718

task_queue *queue = create_queue();

5719

g_assert_nonnull(queue);

5720

__attribute__((cleanup(cleanup_string)))

5721

char *tempdir = make_temporary_directory();

5722

g_assert_nonnull(tempdir);

5723

char socket_name[] = "nonexistent";

5724

char *filename = NULL;

5725

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5726

>, 0);

5727

g_assert_nonnull(filename);

5728

5729

task_context task = {

5730

.func=connect_question_socket,

5731

.question_filename=strdup(question_filename),

5732

.epoll_fd=epoll_fd,

5733

.password=(buffer[]){{}},

5734

.filename=filename,

5735

.cancelled_filenames=&cancelled_filenames,

5736

.mandos_client_exited=(bool[]){false},

5737

.password_is_read=(bool[]){false},

5738

.current_time=&current_time,

5739

};

5740

g_assert_nonnull(task.question_filename);

5741

run_task_with_stderr_to_dev_null(task, queue);

5742

5743

g_assert_nonnull(find_matching_task(queue, task));

5744

5745

g_assert_false(string_set_contains(cancelled_filenames,

5746

question_filename));

5747

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5748

g_assert_true(queue->next_run == 1000000 + current_time);

5749

5750

g_assert_cmpint(rmdir(tempdir), ==, 0);

5751

}

5752

5753

static

5754

void test_connect_question_socket_bad_epoll(__attribute__((unused))

5755

test_fixture *fixture,

5756

__attribute__((unused))

5757

gconstpointer user_data){

5758

__attribute__((cleanup(cleanup_close)))

5759

const int epoll_fd = open("/dev/null",

5760

O_WRONLY | O_CLOEXEC | O_NOCTTY);

5761

__attribute__((cleanup(cleanup_string)))

5762

char *const question_filename = strdup("/nonexistent/question");

5763

g_assert_nonnull(question_filename);

5764

__attribute__((cleanup(string_set_clear)))

5765

string_set cancelled_filenames = {};

5766

const mono_microsecs current_time = 5;

5767

__attribute__((cleanup(cleanup_queue)))

5768

task_queue *queue = create_queue();

5769

g_assert_nonnull(queue);

5770

__attribute__((cleanup(cleanup_string)))

5771

char *tempdir = make_temporary_directory();

5772

g_assert_nonnull(tempdir);

5773

__attribute__((cleanup(cleanup_close)))

5774

const int sock_fd = socket(PF_LOCAL, SOCK_DGRAM

5775

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

5776

g_assert_cmpint(sock_fd, >=, 0);

5777

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

5778

const char socket_name[] = "socket_name";

5779

__attribute__((cleanup(cleanup_string)))

5780

char *filename = NULL;

5781

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5782

>, 0);

5783

g_assert_nonnull(filename);

5784

g_assert_cmpint((int)strlen(filename), <,

5785

(int)sizeof(sock_name.sun_path));

5786

strncpy(sock_name.sun_path, filename, sizeof(sock_name.sun_path));

5787

sock_name.sun_path[sizeof(sock_name.sun_path)-1] = '\0';

5788

g_assert_cmpint((int)bind(sock_fd, (struct sockaddr *)&sock_name,

5789

(socklen_t)SUN_LEN(&sock_name)), >=, 0);

5790

task_context task = {

5791

.func=connect_question_socket,

5792

.question_filename=strdup(question_filename),

5793

.epoll_fd=epoll_fd,

5794

.password=(buffer[]){{}},

5795

.filename=strdup(filename),

5796

.cancelled_filenames=&cancelled_filenames,

5797

.mandos_client_exited=(bool[]){false},

5798

.password_is_read=(bool[]){false},

5799

.current_time=&current_time,

5800

};

5801

g_assert_nonnull(task.question_filename);

5802

run_task_with_stderr_to_dev_null(task, queue);

5803

5804

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5805

const task_context *const added_task

5806

= find_matching_task(queue, task);

5807

g_assert_nonnull(added_task);

5808

g_assert_true(queue->next_run == 1000000 + current_time);

5809

5810

g_assert_cmpint(unlink(filename), ==, 0);

5811

g_assert_cmpint(rmdir(tempdir), ==, 0);

5812

}

5813

5814

static

5815

void test_connect_question_socket_usable(__attribute__((unused))

5816

test_fixture *fixture,

5817

__attribute__((unused))

5818

gconstpointer user_data){

5819

__attribute__((cleanup(cleanup_close)))

5820

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5821

g_assert_cmpint(epoll_fd, >=, 0);

5822

__attribute__((cleanup(cleanup_string)))

5823

char *const question_filename = strdup("/nonexistent/question");

5824

g_assert_nonnull(question_filename);

5825

__attribute__((cleanup(string_set_clear)))

5826

string_set cancelled_filenames = {};

5827

buffer password = {};

5828

bool mandos_client_exited = false;

5829

bool password_is_read = false;

5830

const mono_microsecs current_time = 0;

5831

__attribute__((cleanup(cleanup_queue)))

5832

task_queue *queue = create_queue();

5833

g_assert_nonnull(queue);

5834

__attribute__((cleanup(cleanup_string)))

5835

char *tempdir = make_temporary_directory();

5836

g_assert_nonnull(tempdir);

5837

__attribute__((cleanup(cleanup_close)))

5838

const int sock_fd = socket(PF_LOCAL, SOCK_DGRAM

5839

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0);

5840

g_assert_cmpint(sock_fd, >=, 0);

5841

struct sockaddr_un sock_name = { .sun_family=AF_LOCAL };

5842

const char socket_name[] = "socket_name";

5843

__attribute__((cleanup(cleanup_string)))

5844

char *filename = NULL;

5845

g_assert_cmpint(asprintf(&filename, "%s/%s", tempdir, socket_name),

5846

>, 0);

5847

g_assert_nonnull(filename);

5848

g_assert_cmpint((int)strlen(filename), <,

5849

(int)sizeof(sock_name.sun_path));

5850

strncpy(sock_name.sun_path, filename, sizeof(sock_name.sun_path));

5851

sock_name.sun_path[sizeof(sock_name.sun_path)-1] = '\0';

5852

g_assert_cmpint((int)bind(sock_fd, (struct sockaddr *)&sock_name,

5853

(socklen_t)SUN_LEN(&sock_name)), >=, 0);

5854

task_context task = {

5855

.func=connect_question_socket,

5856

.question_filename=strdup(question_filename),

5857

.epoll_fd=epoll_fd,

5858

.password=&password,

5859

.filename=strdup(filename),

5860

.cancelled_filenames=&cancelled_filenames,

5861

.mandos_client_exited=&mandos_client_exited,

5862

.password_is_read=&password_is_read,

5863

.current_time=&current_time,

5864

};

5865

g_assert_nonnull(task.question_filename);

5866

task.func(task, queue);

5867

5868

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5869

const task_context *const added_task

5870

= find_matching_task(queue, (task_context){

5871

.func=send_password_to_socket,

5872

.question_filename=question_filename,

5873

.filename=filename,

5874

.epoll_fd=epoll_fd,

5875

.password=&password,

5876

.cancelled_filenames=&cancelled_filenames,

5877

.mandos_client_exited=&mandos_client_exited,

5878

.password_is_read=&password_is_read,

5879

.current_time=&current_time,

5880

});

5881

g_assert_nonnull(added_task);

5882

g_assert_cmpint(added_task->fd, >, 0);

5883

5884

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5885

EPOLLOUT));

5886

5887

const int fd = added_task->fd;

5888

g_assert_cmpint(fd, >, 0);

5889

g_assert_true(fd_has_cloexec_and_nonblock(fd));

5890

5891

/* write to fd */

5892

char write_data[PIPE_BUF];

5893

{

5894

/* Construct test password buffer */

5895

/* Start with + since that is what the real protocol uses */

5896

write_data[0] = '+';

5897

/* Set a special character at string end just to mark the end */

5898

write_data[sizeof(write_data)-2] = 'y';

5899

/* Set NUL at buffer end, as suggested by the protocol */

5900

write_data[sizeof(write_data)-1] = '\0';

5901

/* Fill rest of password with 'x' */

5902

memset(write_data+1, 'x', sizeof(write_data)-3);

5903

g_assert_cmpint((int)send(fd, write_data, sizeof(write_data),

5904

MSG_NOSIGNAL), ==, sizeof(write_data));

5905

}

5906

5907

/* read from sock_fd */

5908

char read_data[sizeof(write_data)];

5909

g_assert_cmpint((int)read(sock_fd, read_data, sizeof(read_data)),

5910

==, sizeof(read_data));

5911

5912

g_assert_true(memcmp(write_data, read_data, sizeof(write_data))

5913

== 0);

5914

5915

/* writing to sock_fd should fail */

5916

g_assert_cmpint(send(sock_fd, write_data, sizeof(write_data),

5917

MSG_NOSIGNAL), <, 0);

5918

5919

/* reading from fd should fail */

5920

g_assert_cmpint((int)recv(fd, read_data, sizeof(read_data),

5921

MSG_NOSIGNAL), <, 0);

5922

5923

g_assert_cmpint(unlink(filename), ==, 0);

5924

g_assert_cmpint(rmdir(tempdir), ==, 0);

5925

}

5926

5927

static void

5928

test_send_password_to_socket_client_not_exited(__attribute__((unused))

5929

test_fixture *fixture,

5930

__attribute__((unused))

5931

gconstpointer

5932

user_data){

5933

__attribute__((cleanup(cleanup_close)))

5934

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5935

g_assert_cmpint(epoll_fd, >=, 0);

5936

__attribute__((cleanup(cleanup_string)))

5937

char *const question_filename = strdup("/nonexistent/question");

5938

g_assert_nonnull(question_filename);

5939

__attribute__((cleanup(cleanup_string)))

5940

char *const filename = strdup("/nonexistent/socket");

5941

g_assert_nonnull(filename);

5942

__attribute__((cleanup(string_set_clear)))

5943

string_set cancelled_filenames = {};

5944

buffer password = {};

5945

bool password_is_read = true;

5946

__attribute__((cleanup(cleanup_queue)))

5947

task_queue *queue = create_queue();

5948

g_assert_nonnull(queue);

5949

int socketfds[2];

5950

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

5951

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

5952

socketfds), ==, 0);

5953

__attribute__((cleanup(cleanup_close)))

5954

const int read_socket = socketfds[0];

5955

const int write_socket = socketfds[1];

5956

task_context task = {

5957

.func=send_password_to_socket,

5958

.question_filename=strdup(question_filename),

5959

.filename=strdup(filename),

5960

.epoll_fd=epoll_fd,

5961

.fd=write_socket,

5962

.password=&password,

5963

.cancelled_filenames=&cancelled_filenames,

5964

.mandos_client_exited=(bool[]){false},

5965

.password_is_read=&password_is_read,

5966

.current_time=(mono_microsecs[]){0},

5967

};

5968

g_assert_nonnull(task.question_filename);

5969

5970

task.func(task, queue);

5971

5972

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

5973

5974

const task_context *const added_task

5975

= find_matching_task(queue, task);

5976

g_assert_nonnull(added_task);

5977

g_assert_cmpuint((unsigned int)password.length, ==, 0);

5978

g_assert_true(password_is_read);

5979

5980

g_assert_cmpint(added_task->fd, >, 0);

5981

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

5982

EPOLLOUT));

5983

}

5984

5985

static void

5986

test_send_password_to_socket_password_not_read(__attribute__((unused))

5987

test_fixture *fixture,

5988

__attribute__((unused))

5989

gconstpointer

5990

user_data){

5991

__attribute__((cleanup(cleanup_close)))

5992

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

5993

g_assert_cmpint(epoll_fd, >=, 0);

5994

__attribute__((cleanup(cleanup_string)))

5995

char *const question_filename = strdup("/nonexistent/question");

5996

g_assert_nonnull(question_filename);

5997

__attribute__((cleanup(cleanup_string)))

5998

char *const filename = strdup("/nonexistent/socket");

5999

__attribute__((cleanup(string_set_clear)))

6000

string_set cancelled_filenames = {};

6001

buffer password = {};

6002

__attribute__((cleanup(cleanup_queue)))

6003

task_queue *queue = create_queue();

6004

g_assert_nonnull(queue);

6005

int socketfds[2];

6006

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6007

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6008

socketfds), ==, 0);

6009

__attribute__((cleanup(cleanup_close)))

6010

const int read_socket = socketfds[0];

6011

const int write_socket = socketfds[1];

6012

task_context task = {

6013

.func=send_password_to_socket,

6014

.question_filename=strdup(question_filename),

6015

.filename=strdup(filename),

6016

.epoll_fd=epoll_fd,

6017

.fd=write_socket,

6018

.password=&password,

6019

.cancelled_filenames=&cancelled_filenames,

6020

.mandos_client_exited=(bool[]){false},

6021

.password_is_read=(bool[]){false},

6022

.current_time=(mono_microsecs[]){0},

6023

};

6024

g_assert_nonnull(task.question_filename);

6025

6026

task.func(task, queue);

6027

6028

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6029

6030

const task_context *const added_task = find_matching_task(queue,

6031

task);

6032

g_assert_nonnull(added_task);

6033

g_assert_cmpuint((unsigned int)password.length, ==, 0);

6034

g_assert_true(queue->next_run == 0);

6035

6036

g_assert_cmpint(added_task->fd, >, 0);

6037

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

6038

EPOLLOUT));

6039

}

6040

6041

static

6042

void test_send_password_to_socket_EMSGSIZE(__attribute__((unused))

6043

test_fixture *fixture,

6044

__attribute__((unused))

6045

gconstpointer user_data){

6046

__attribute__((cleanup(cleanup_close)))

6047

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6048

g_assert_cmpint(epoll_fd, >=, 0);

6049

const char question_filename[] = "/nonexistent/question";

6050

char *const filename = strdup("/nonexistent/socket");

6051

__attribute__((cleanup(string_set_clear)))

6052

string_set cancelled_filenames = {};

6053

int socketfds[2];

6054

6055

/* Find a message size which triggers EMSGSIZE */

6056

__attribute__((cleanup(cleanup_string)))

6057

char *message_buffer = NULL;

6058

size_t message_size = PIPE_BUF + 1;

6059

for(ssize_t ssret = 0; ssret >= 0; message_size += 1024){

6060

if(message_size >= 1024*1024*1024){ /* 1 GiB */

6061

g_test_skip("Skipping EMSGSIZE test: Will not try 1GiB");

6062

return;

6063

}

6064

message_buffer = realloc(message_buffer, message_size);

6065

if(message_buffer == NULL){

6066

g_test_skip("Skipping EMSGSIZE test");

6067

g_test_message("Failed to malloc() %" PRIuMAX " bytes",

6068

(uintmax_t)message_size);

6069

return;

6070

}

6071

/* Fill buffer with 'x' */

6072

memset(message_buffer, 'x', message_size);

6073

/* Create a new socketpair for each message size to avoid having

6074

to empty the pipe by reading the message to a separate buffer

6075

*/

6076

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6077

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6078

socketfds), ==, 0);

6079

ssret = send(socketfds[1], message_buffer, message_size,

6080

MSG_NOSIGNAL);

6081

error_t saved_errno = errno;

6082

g_assert_cmpint(close(socketfds[0]), ==, 0);

6083

g_assert_cmpint(close(socketfds[1]), ==, 0);

6084

6085

if(ssret < 0){

6086

if(saved_errno != EMSGSIZE) {

6087

g_test_skip("Skipping EMSGSIZE test");

6088

g_test_message("Error on send(%" PRIuMAX " bytes): %s",

6089

(uintmax_t)message_size,

6090

strerror(saved_errno));

6091

return;

6092

}

6093

break;

6094

} else if(ssret != (ssize_t)message_size){

6095

g_test_skip("Skipping EMSGSIZE test");

6096

g_test_message("Partial send(): %" PRIuMAX " of %" PRIdMAX

6097

" bytes", (uintmax_t)ssret,

6098

(intmax_t)message_size);

6099

return;

6100

}

6101

}

6102

g_test_message("EMSGSIZE triggered by %" PRIdMAX " bytes",

6103

(intmax_t)message_size);

6104

6105

buffer password = {

6106

.data=message_buffer,

6107

.length=message_size - 2, /* Compensate for added '+' and NUL */

6108

.allocated=message_size,

6109

};

6110

if(mlock(password.data, password.allocated) != 0){

6111

g_assert_true(errno == EPERM or errno == ENOMEM);

6112

}

6113

6114

__attribute__((cleanup(cleanup_queue)))

6115

task_queue *queue = create_queue();

6116

g_assert_nonnull(queue);

6117

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6118

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6119

socketfds), ==, 0);

6120

__attribute__((cleanup(cleanup_close)))

6121

const int read_socket = socketfds[0];

6122

__attribute__((cleanup(cleanup_close)))

6123

const int write_socket = socketfds[1];

6124

task_context task = {

6125

.func=send_password_to_socket,

6126

.question_filename=strdup(question_filename),

6127

.filename=filename,

6128

.epoll_fd=epoll_fd,

6129

.fd=write_socket,

6130

.password=&password,

6131

.cancelled_filenames=&cancelled_filenames,

6132

.mandos_client_exited=(bool[]){true},

6133

.password_is_read=(bool[]){true},

6134

.current_time=(mono_microsecs[]){0},

6135

};

6136

g_assert_nonnull(task.question_filename);

6137

6138

run_task_with_stderr_to_dev_null(task, queue);

6139

6140

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6141

g_assert_true(string_set_contains(cancelled_filenames,

6142

question_filename));

6143

}

6144

6145

static void test_send_password_to_socket_retry(__attribute__((unused))

6146

test_fixture *fixture,

6147

__attribute__((unused))

6148

gconstpointer

6149

user_data){

6150

__attribute__((cleanup(cleanup_close)))

6151

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6152

g_assert_cmpint(epoll_fd, >=, 0);

6153

__attribute__((cleanup(cleanup_string)))

6154

char *const question_filename = strdup("/nonexistent/question");

6155

g_assert_nonnull(question_filename);

6156

__attribute__((cleanup(cleanup_string)))

6157

char *const filename = strdup("/nonexistent/socket");

6158

g_assert_nonnull(filename);

6159

__attribute__((cleanup(string_set_clear)))

6160

string_set cancelled_filenames = {};

6161

__attribute__((cleanup(cleanup_buffer)))

6162

buffer password = {};

6163

6164

__attribute__((cleanup(cleanup_queue)))

6165

task_queue *queue = create_queue();

6166

g_assert_nonnull(queue);

6167

int socketfds[2];

6168

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6169

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6170

socketfds), ==, 0);

6171

__attribute__((cleanup(cleanup_close)))

6172

const int read_socket = socketfds[0];

6173

const int write_socket = socketfds[1];

6174

/* Close the server side socket to force ECONNRESET on client */

6175

g_assert_cmpint(close(read_socket), ==, 0);

6176

task_context task = {

6177

.func=send_password_to_socket,

6178

.question_filename=strdup(question_filename),

6179

.filename=strdup(filename),

6180

.epoll_fd=epoll_fd,

6181

.fd=write_socket,

6182

.password=&password,

6183

.cancelled_filenames=&cancelled_filenames,

6184

.mandos_client_exited=(bool[]){true},

6185

.password_is_read=(bool[]){true},

6186

.current_time=(mono_microsecs[]){0},

6187

};

6188

g_assert_nonnull(task.question_filename);

6189

6190

task.func(task, queue);

6191

6192

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6193

6194

const task_context *const added_task = find_matching_task(queue,

6195

task);

6196

g_assert_nonnull(added_task);

6197

g_assert_cmpuint((unsigned int)password.length, ==, 0);

6198

6199

g_assert_true(epoll_set_contains(epoll_fd, added_task->fd,

6200

EPOLLOUT));

6201

}

6202

6203

static

6204

void test_send_password_to_socket_bad_epoll(__attribute__((unused))

6205

test_fixture *fixture,

6206

__attribute__((unused))

6207

gconstpointer user_data){

6208

__attribute__((cleanup(cleanup_close)))

6209

const int epoll_fd = open("/dev/null",

6210

O_WRONLY | O_CLOEXEC | O_NOCTTY);

6211

__attribute__((cleanup(cleanup_string)))

6212

char *const question_filename = strdup("/nonexistent/question");

6213

g_assert_nonnull(question_filename);

6214

__attribute__((cleanup(cleanup_string)))

6215

char *const filename = strdup("/nonexistent/socket");

6216

g_assert_nonnull(filename);

6217

__attribute__((cleanup(string_set_clear)))

6218

string_set cancelled_filenames = {};

6219

__attribute__((cleanup(cleanup_buffer)))

6220

buffer password = {};

6221

6222

const mono_microsecs current_time = 11;

6223

__attribute__((cleanup(cleanup_queue)))

6224

task_queue *queue = create_queue();

6225

g_assert_nonnull(queue);

6226

int socketfds[2];

6227

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6228

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6229

socketfds), ==, 0);

6230

__attribute__((cleanup(cleanup_close)))

6231

const int read_socket = socketfds[0];

6232

const int write_socket = socketfds[1];

6233

/* Close the server side socket to force ECONNRESET on client */

6234

g_assert_cmpint(close(read_socket), ==, 0);

6235

task_context task = {

6236

.func=send_password_to_socket,

6237

.question_filename=strdup(question_filename),

6238

.filename=strdup(filename),

6239

.epoll_fd=epoll_fd,

6240

.fd=write_socket,

6241

.password=&password,

6242

.cancelled_filenames=&cancelled_filenames,

6243

.mandos_client_exited=(bool[]){true},

6244

.password_is_read=(bool[]){true},

6245

.current_time=&current_time,

6246

};

6247

g_assert_nonnull(task.question_filename);

6248

6249

run_task_with_stderr_to_dev_null(task, queue);

6250

6251

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6252

6253

const task_context *const added_task = find_matching_task(queue,

6254

task);

6255

g_assert_nonnull(added_task);

6256

g_assert_true(queue->next_run == current_time + 1000000);

6257

g_assert_cmpuint((unsigned int)password.length, ==, 0);

6258

}

6259

6260

static void assert_send_password_to_socket_password(buffer password){

6261

__attribute__((cleanup(cleanup_close)))

6262

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6263

g_assert_cmpint(epoll_fd, >=, 0);

6264

char *const question_filename = strdup("/nonexistent/question");

6265

g_assert_nonnull(question_filename);

6266

char *const filename = strdup("/nonexistent/socket");

6267

g_assert_nonnull(filename);

6268

__attribute__((cleanup(string_set_clear)))

6269

string_set cancelled_filenames = {};

6270

6271

__attribute__((cleanup(cleanup_queue)))

6272

task_queue *queue = create_queue();

6273

g_assert_nonnull(queue);

6274

int socketfds[2];

6275

g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM

6276

| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,

6277

socketfds), ==, 0);

6278

__attribute__((cleanup(cleanup_close)))

6279

const int read_socket = socketfds[0];

6280

const int write_socket = socketfds[1];

6281

task_context task = {

6282

.func=send_password_to_socket,

6283

.question_filename=question_filename,

6284

.filename=filename,

6285

.epoll_fd=epoll_fd,

6286

.fd=write_socket,

6287

.password=&password,

6288

.cancelled_filenames=&cancelled_filenames,

6289

.mandos_client_exited=(bool[]){true},

6290

.password_is_read=(bool[]){true},

6291

.current_time=(mono_microsecs[]){0},

6292

};

6293

6294

char *expected_written_data = malloc(password.length + 2);

6295

g_assert_nonnull(expected_written_data);

6296

expected_written_data[0] = '+';

6297

expected_written_data[password.length + 1] = '\0';

6298

if(password.length > 0){

6299

g_assert_nonnull(password.data);

6300

memcpy(expected_written_data + 1, password.data, password.length);

6301

}

6302

6303

task.func(task, queue);

6304

6305

char buf[PIPE_BUF];

6306

g_assert_cmpint((int)read(read_socket, buf, PIPE_BUF), ==,

6307

(int)(password.length + 2));

6308

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6309

6310

g_assert_true(memcmp(expected_written_data, buf,

6311

password.length + 2) == 0);

6312

6313

g_assert_true(epoll_set_does_not_contain(epoll_fd, write_socket));

6314

6315

free(expected_written_data);

6316

}

6317

6318

static void

6319

test_send_password_to_socket_null_password(__attribute__((unused))

6320

test_fixture *fixture,

6321

__attribute__((unused))

6322

gconstpointer user_data){

6323

__attribute__((cleanup(cleanup_buffer)))

6324

buffer password = {};

6325

assert_send_password_to_socket_password(password);

6326

}

6327

6328

static void

6329

test_send_password_to_socket_empty_password(__attribute__((unused))

6330

test_fixture *fixture,

6331

__attribute__((unused))

6332

gconstpointer user_data){

6333

__attribute__((cleanup(cleanup_buffer)))

6334

buffer password = {

6335

.data=malloc(1), /* because malloc(0) may return NULL */

6336

.length=0,

6337

.allocated=0, /* deliberate lie */

6338

};

6339

g_assert_nonnull(password.data);

6340

assert_send_password_to_socket_password(password);

6341

}

6342

6343

static void

6344

test_send_password_to_socket_empty_str_pass(__attribute__((unused))

6345

test_fixture *fixture,

6346

__attribute__((unused))

6347

gconstpointer user_data){

6348

__attribute__((cleanup(cleanup_buffer)))

6349

buffer password = {

6350

.data=strdup(""),

6351

.length=0,

6352

.allocated=1,

6353

};

6354

if(mlock(password.data, password.allocated) != 0){

6355

g_assert_true(errno == EPERM or errno == ENOMEM);

6356

}

6357

assert_send_password_to_socket_password(password);

6358

}

6359

6360

static void

6361

test_send_password_to_socket_text_password(__attribute__((unused))

6362

test_fixture *fixture,

6363

__attribute__((unused))

6364

gconstpointer user_data){

6365

const char dummy_test_password[] = "dummy test password";

6366

__attribute__((cleanup(cleanup_buffer)))

6367

buffer password = {

6368

.data = strdup(dummy_test_password),

6369

.length = strlen(dummy_test_password),

6370

.allocated = sizeof(dummy_test_password),

6371

};

6372

if(mlock(password.data, password.allocated) != 0){

6373

g_assert_true(errno == EPERM or errno == ENOMEM);

6374

}

6375

assert_send_password_to_socket_password(password);

6376

}

6377

6378

static void

6379

test_send_password_to_socket_binary_password(__attribute__((unused))

6380

test_fixture *fixture,

6381

__attribute__((unused))

6382

gconstpointer user_data){

6383

__attribute__((cleanup(cleanup_buffer)))

6384

buffer password = {

6385

.data=malloc(255),

6386

.length=255,

6387

.allocated=255,

6388

};

6389

g_assert_nonnull(password.data);

6390

if(mlock(password.data, password.allocated) != 0){

6391

g_assert_true(errno == EPERM or errno == ENOMEM);

6392

}

6393

char c = 1; /* Start at 1, avoiding NUL */

6394

for(int i=0; i < 255; i++){

6395

password.data[i] = c++;

6396

}

6397

assert_send_password_to_socket_password(password);

6398

}

6399

6400

static void

6401

test_send_password_to_socket_nuls_in_password(__attribute__((unused))

6402

test_fixture *fixture,

6403

__attribute__((unused))

6404

gconstpointer

6405

user_data){

6406

char test_password[] = {'\0', 'a', '\0', 'b', '\0', 'c', '\0'};

6407

__attribute__((cleanup(cleanup_buffer)))

6408

buffer password = {

6409

.data=malloc(sizeof(test_password)),

6410

.length=sizeof(test_password),

6411

.allocated=sizeof(test_password),

6412

};

6413

g_assert_nonnull(password.data);

6414

if(mlock(password.data, password.allocated) !=0){

6415

g_assert_true(errno == EPERM or errno == ENOMEM);

6416

}

6417

memcpy(password.data, test_password, password.allocated);

6418

assert_send_password_to_socket_password(password);

6419

}

6420

6421

static bool assert_add_existing_questions_to_devnull(task_queue

6422

*const,

6423

const int,

6424

buffer *const,

6425

string_set *,

6426

const

6427

mono_microsecs

6428

*const,

6429

bool *const,

6430

bool *const,

6431

const char

6432

*const);

6433

6434

static void test_add_existing_questions_ENOENT(__attribute__((unused))

6435

test_fixture *fixture,

6436

__attribute__((unused))

6437

gconstpointer

6438

user_data){

6439

__attribute__((cleanup(cleanup_queue)))

6440

task_queue *queue = create_queue();

6441

g_assert_nonnull(queue);

6442

__attribute__((cleanup(cleanup_close)))

6443

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6444

g_assert_cmpint(epoll_fd, >=, 0);

6445

__attribute__((cleanup(string_set_clear)))

6446

string_set cancelled_filenames = {};

6447

6448

g_assert_false(assert_add_existing_questions_to_devnull

6449

(queue,

6450

epoll_fd,

6451

(buffer[]){{}}, /* password */

6452

&cancelled_filenames,

6453

(mono_microsecs[]){0}, /* current_time */

6454

(bool[]){false}, /* mandos_client_exited */

6455

(bool[]){false}, /* password_is_read */

6456

"/nonexistent")); /* dirname */

6457

6458

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6459

}

6460

6461

static

6462

bool assert_add_existing_questions_to_devnull(task_queue

6463

*const queue,

6464

const int

6465

epoll_fd,

6466

buffer *const

6467

password,

6468

string_set

6469

*cancelled_filenames,

6470

const mono_microsecs

6471

*const current_time,

6472

bool *const

6473

mandos_client_exited,

6474

bool *const

6475

password_is_read,

6476

const char *const

6477

dirname){

6478

__attribute__((cleanup(cleanup_close)))

6479

const int devnull_fd = open("/dev/null",

6480

O_WRONLY | O_CLOEXEC | O_NOCTTY);

6481

g_assert_cmpint(devnull_fd, >=, 0);

6482

__attribute__((cleanup(cleanup_close)))

6483

const int real_stderr_fd = dup(STDERR_FILENO);

6484

g_assert_cmpint(real_stderr_fd, >=, 0);

6485

dup2(devnull_fd, STDERR_FILENO);

6486

const bool ret = add_existing_questions(queue, epoll_fd, password,

6487

cancelled_filenames,

6488

current_time,

6489

mandos_client_exited,

6490

password_is_read, dirname);

6491

dup2(real_stderr_fd, STDERR_FILENO);

6492

return ret;

6493

}

6494

6495

static

6496

void test_add_existing_questions_no_questions(__attribute__((unused))

6497

test_fixture *fixture,

6498

__attribute__((unused))

6499

gconstpointer

6500

user_data){

6501

__attribute__((cleanup(cleanup_queue)))

6502

task_queue *queue = create_queue();

6503

g_assert_nonnull(queue);

6504

__attribute__((cleanup(cleanup_close)))

6505

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6506

g_assert_cmpint(epoll_fd, >=, 0);

6507

__attribute__((cleanup(string_set_clear)))

6508

string_set cancelled_filenames = {};

6509

__attribute__((cleanup(cleanup_string)))

6510

char *tempdir = make_temporary_directory();

6511

g_assert_nonnull(tempdir);

6512

6513

g_assert_false(assert_add_existing_questions_to_devnull

6514

(queue,

6515

epoll_fd,

6516

(buffer[]){{}}, /* password */

6517

&cancelled_filenames,

6518

(mono_microsecs[]){0}, /* current_time */

6519

(bool[]){false}, /* mandos_client_exited */

6520

(bool[]){false}, /* password_is_read */

6521

tempdir));

6522

6523

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6524

6525

g_assert_cmpint(rmdir(tempdir), ==, 0);

6526

}

6527

6528

static char *make_question_file_in_directory(const char *const);

6529

6530

static

6531

void test_add_existing_questions_one_question(__attribute__((unused))

6532

test_fixture *fixture,

6533

__attribute__((unused))

6534

gconstpointer

6535

user_data){

6536

__attribute__((cleanup(cleanup_queue)))

6537

task_queue *queue = create_queue();

6538

g_assert_nonnull(queue);

6539

__attribute__((cleanup(cleanup_close)))

6540

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6541

g_assert_cmpint(epoll_fd, >=, 0);

6542

__attribute__((cleanup(cleanup_buffer)))

6543

buffer password = {};

6544

__attribute__((cleanup(string_set_clear)))

6545

string_set cancelled_filenames = {};

6546

const mono_microsecs current_time = 0;

6547

bool mandos_client_exited = false;

6548

bool password_is_read = false;

6549

__attribute__((cleanup(cleanup_string)))

6550

char *tempdir = make_temporary_directory();

6551

g_assert_nonnull(tempdir);

6552

__attribute__((cleanup(cleanup_string)))

6553

char *question_filename

6554

= make_question_file_in_directory(tempdir);

6555

g_assert_nonnull(question_filename);

6556

6557

g_assert_true(assert_add_existing_questions_to_devnull

6558

(queue,

6559

epoll_fd,

6560

&password,

6561

&cancelled_filenames,

6562

&current_time,

6563

&mandos_client_exited,

6564

&password_is_read,

6565

tempdir));

6566

6567

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6568

6569

g_assert_nonnull(find_matching_task(queue, (task_context){

6570

.func=open_and_parse_question,

6571

.epoll_fd=epoll_fd,

6572

.filename=question_filename,

6573

.question_filename=question_filename,

6574

.password=&password,

6575

.cancelled_filenames=&cancelled_filenames,

6576

.current_time=&current_time,

6577

.mandos_client_exited=&mandos_client_exited,

6578

.password_is_read=&password_is_read,

6579

}));

6580

6581

g_assert_true(queue->next_run == 1);

6582

6583

g_assert_cmpint(unlink(question_filename), ==, 0);

6584

g_assert_cmpint(rmdir(tempdir), ==, 0);

6585

}

6586

6587

static char *make_question_file_in_directory(const char

6588

*const dir){

6589

return make_temporary_prefixed_file_in_directory("ask.", dir);

6590

}

6591

6592

static

6593

void test_add_existing_questions_two_questions(__attribute__((unused))

6594

test_fixture *fixture,

6595

__attribute__((unused))

6596

gconstpointer

6597

user_data){

6598

__attribute__((cleanup(cleanup_queue)))

6599

task_queue *queue = create_queue();

6600

g_assert_nonnull(queue);

6601

__attribute__((cleanup(cleanup_close)))

6602

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6603

g_assert_cmpint(epoll_fd, >=, 0);

6604

__attribute__((cleanup(cleanup_buffer)))

6605

buffer password = {};

6606

__attribute__((cleanup(string_set_clear)))

6607

string_set cancelled_filenames = {};

6608

const mono_microsecs current_time = 0;

6609

bool mandos_client_exited = false;

6610

bool password_is_read = false;

6611

__attribute__((cleanup(cleanup_string)))

6612

char *tempdir = make_temporary_directory();

6613

g_assert_nonnull(tempdir);

6614

__attribute__((cleanup(cleanup_string)))

6615

char *question_filename1

6616

= make_question_file_in_directory(tempdir);

6617

g_assert_nonnull(question_filename1);

6618

__attribute__((cleanup(cleanup_string)))

6619

char *question_filename2

6620

= make_question_file_in_directory(tempdir);

6621

g_assert_nonnull(question_filename2);

6622

6623

g_assert_true(assert_add_existing_questions_to_devnull

6624

(queue,

6625

epoll_fd,

6626

&password,

6627

&cancelled_filenames,

6628

&current_time,

6629

&mandos_client_exited,

6630

&password_is_read,

6631

tempdir));

6632

6633

g_assert_cmpuint((unsigned int)queue->length, ==, 2);

6634

6635

g_assert_true(queue->next_run == 1);

6636

6637

__attribute__((cleanup(string_set_clear)))

6638

string_set seen_questions = {};

6639

6640

bool queue_contains_question_opener(char *const question_filename){

6641

return(find_matching_task(queue, (task_context){

6642

.func=open_and_parse_question,

6643

.epoll_fd=epoll_fd,

6644

.question_filename=question_filename,

6645

.password=&password,

6646

.cancelled_filenames=&cancelled_filenames,

6647

.current_time=&current_time,

6648

.mandos_client_exited=&mandos_client_exited,

6649

.password_is_read=&password_is_read,

6650

}) != NULL);

6651

}

6652

6653

g_assert_true(queue_contains_question_opener(question_filename1));

6654

g_assert_true(queue_contains_question_opener(question_filename2));

6655

6656

g_assert_true(queue->next_run == 1);

6657

6658

g_assert_cmpint(unlink(question_filename1), ==, 0);

6659

g_assert_cmpint(unlink(question_filename2), ==, 0);

6660

g_assert_cmpint(rmdir(tempdir), ==, 0);

6661

}

6662

6663

static void

6664

test_add_existing_questions_non_questions(__attribute__((unused))

6665

test_fixture *fixture,

6666

__attribute__((unused))

6667

gconstpointer user_data){

6668

__attribute__((cleanup(cleanup_queue)))

6669

task_queue *queue = create_queue();

6670

g_assert_nonnull(queue);

6671

__attribute__((cleanup(cleanup_close)))

6672

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6673

g_assert_cmpint(epoll_fd, >=, 0);

6674

__attribute__((cleanup(string_set_clear)))

6675

string_set cancelled_filenames = {};

6676

__attribute__((cleanup(cleanup_string)))

6677

char *tempdir = make_temporary_directory();

6678

g_assert_nonnull(tempdir);

6679

__attribute__((cleanup(cleanup_string)))

6680

char *question_filename1

6681

= make_temporary_file_in_directory(tempdir);

6682

g_assert_nonnull(question_filename1);

6683

__attribute__((cleanup(cleanup_string)))

6684

char *question_filename2

6685

= make_temporary_file_in_directory(tempdir);

6686

g_assert_nonnull(question_filename2);

6687

6688

g_assert_false(assert_add_existing_questions_to_devnull

6689

(queue,

6690

epoll_fd,

6691

(buffer[]){{}}, /* password */

6692

&cancelled_filenames,

6693

(mono_microsecs[]){0}, /* current_time */

6694

(bool[]){false}, /* mandos_client_exited */

6695

(bool[]){false}, /* password_is_read */

6696

tempdir));

6697

6698

g_assert_cmpuint((unsigned int)queue->length, ==, 0);

6699

6700

g_assert_cmpint(unlink(question_filename1), ==, 0);

6701

g_assert_cmpint(unlink(question_filename2), ==, 0);

6702

g_assert_cmpint(rmdir(tempdir), ==, 0);

6703

}

6704

6705

static void

6706

test_add_existing_questions_both_types(__attribute__((unused))

6707

test_fixture *fixture,

6708

__attribute__((unused))

6709

gconstpointer user_data){

6710

__attribute__((cleanup(cleanup_queue)))

6711

task_queue *queue = create_queue();

6712

g_assert_nonnull(queue);

6713

__attribute__((cleanup(cleanup_close)))

6714

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6715

g_assert_cmpint(epoll_fd, >=, 0);

6716

__attribute__((cleanup(cleanup_buffer)))

6717

buffer password = {};

6718

__attribute__((cleanup(string_set_clear)))

6719

string_set cancelled_filenames = {};

6720

const mono_microsecs current_time = 0;

6721

bool mandos_client_exited = false;

6722

bool password_is_read = false;

6723

__attribute__((cleanup(cleanup_string)))

6724

char *tempdir = make_temporary_directory();

6725

g_assert_nonnull(tempdir);

6726

__attribute__((cleanup(cleanup_string)))

6727

char *tempfilename1 = make_temporary_file_in_directory(tempdir);

6728

g_assert_nonnull(tempfilename1);

6729

__attribute__((cleanup(cleanup_string)))

6730

char *tempfilename2 = make_temporary_file_in_directory(tempdir);

6731

g_assert_nonnull(tempfilename2);

6732

__attribute__((cleanup(cleanup_string)))

6733

char *question_filename

6734

= make_question_file_in_directory(tempdir);

6735

g_assert_nonnull(question_filename);

6736

6737

g_assert_true(assert_add_existing_questions_to_devnull

6738

(queue,

6739

epoll_fd,

6740

&password,

6741

&cancelled_filenames,

6742

&current_time,

6743

&mandos_client_exited,

6744

&password_is_read,

6745

tempdir));

6746

6747

g_assert_cmpuint((unsigned int)queue->length, ==, 1);

6748

6749

g_assert_nonnull(find_matching_task(queue, (task_context){

6750

.func=open_and_parse_question,

6751

.epoll_fd=epoll_fd,

6752

.filename=question_filename,

6753

.question_filename=question_filename,

6754

.password=&password,

6755

.cancelled_filenames=&cancelled_filenames,

6756

.current_time=&current_time,

6757

.mandos_client_exited=&mandos_client_exited,

6758

.password_is_read=&password_is_read,

6759

}));

6760

6761

g_assert_true(queue->next_run == 1);

6762

6763

g_assert_cmpint(unlink(tempfilename1), ==, 0);

6764

g_assert_cmpint(unlink(tempfilename2), ==, 0);

6765

g_assert_cmpint(unlink(question_filename), ==, 0);

6766

g_assert_cmpint(rmdir(tempdir), ==, 0);

6767

}

6768

6769

static void test_wait_for_event_timeout(__attribute__((unused))

6770

test_fixture *fixture,

6771

__attribute__((unused))

6772

gconstpointer user_data){

6773

__attribute__((cleanup(cleanup_close)))

6774

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6775

g_assert_cmpint(epoll_fd, >=, 0);

6776

6777

g_assert_true(wait_for_event(epoll_fd, 1, 0));

6778

}

6779

6780

static void test_wait_for_event_event(__attribute__((unused))

6781

test_fixture *fixture,

6782

__attribute__((unused))

6783

gconstpointer user_data){

6784

__attribute__((cleanup(cleanup_close)))

6785

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6786

g_assert_cmpint(epoll_fd, >=, 0);

6787

int pipefds[2];

6788

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

6789

__attribute__((cleanup(cleanup_close)))

6790

const int read_pipe = pipefds[0];

6791

__attribute__((cleanup(cleanup_close)))

6792

const int write_pipe = pipefds[1];

6793

g_assert_cmpint(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, read_pipe,

6794

&(struct epoll_event)

6795

{ .events=EPOLLIN | EPOLLRDHUP }), ==, 0);

6796

g_assert_cmpint((int)write(write_pipe, "x", 1), ==, 1);

6797

6798

g_assert_true(wait_for_event(epoll_fd, 0, 0));

6799

}

6800

6801

static void test_wait_for_event_sigchld(test_fixture *fixture,

6802

__attribute__((unused))

6803

gconstpointer user_data){

6804

const pid_t pid = fork();

6805

if(pid == 0){ /* Child */

6806

if(not restore_signal_handler(&fixture->orig_sigaction)){

6807

_exit(EXIT_FAILURE);

6808

}

6809

if(not restore_sigmask(&fixture->orig_sigmask)){

6810

_exit(EXIT_FAILURE);

6811

}

6812

exit(EXIT_SUCCESS);

6813

}

6814

g_assert_true(pid != -1);

6815

__attribute__((cleanup(cleanup_close)))

6816

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6817

g_assert_cmpint(epoll_fd, >=, 0);

6818

6819

g_assert_true(wait_for_event(epoll_fd, 0, 0));

6820

6821

int status;

6822

g_assert_true(waitpid(pid, &status, 0) == pid);

6823

g_assert_true(WIFEXITED(status));

6824

g_assert_cmpint(WEXITSTATUS(status), ==, EXIT_SUCCESS);

6825

}

6826

6827

static void test_run_queue_zeroes_next_run(__attribute__((unused))

6828

test_fixture *fixture,

6829

__attribute__((unused))

6830

gconstpointer user_data){

6831

__attribute__((cleanup(cleanup_queue)))

6832

task_queue *queue = create_queue();

6833

g_assert_nonnull(queue);

6834

queue->next_run = 1;

6835

__attribute__((cleanup(cleanup_close)))

6836

const int epoll_fd = epoll_create1(EPOLL_CLOEXEC);

6837

__attribute__((cleanup(string_set_clear)))

6838

string_set cancelled_filenames = {};

6839

bool quit_now = false;

6840

6841

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6842

g_assert_false(quit_now);

6843

g_assert_cmpuint((unsigned int)queue->next_run, ==, 0);

6844

}

6845

6846

static

6847

void test_run_queue_clears_cancelled_filenames(__attribute__((unused))

6848

test_fixture *fixture,

6849

__attribute__((unused))

6850

gconstpointer

6851

user_data){

6852

__attribute__((cleanup(cleanup_queue)))

6853

task_queue *queue = create_queue();

6854

g_assert_nonnull(queue);

6855

__attribute__((cleanup(string_set_clear)))

6856

string_set cancelled_filenames = {};

6857

bool quit_now = false;

6858

const char question_filename[] = "/nonexistent/question_filename";

6859

g_assert_true(string_set_add(&cancelled_filenames,

6860

question_filename));

6861

6862

g_assert_true(add_to_queue(queue,

6863

(task_context){ .func=dummy_func }));

6864

6865

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6866

g_assert_false(quit_now);

6867

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6868

g_assert_false(string_set_contains(cancelled_filenames,

6869

question_filename));

6870

}

6871

6872

static

6873

void test_run_queue_skips_cancelled_filenames(__attribute__((unused))

6874

test_fixture *fixture,

6875

__attribute__((unused))

6876

gconstpointer

6877

user_data){

6878

__attribute__((cleanup(cleanup_queue)))

6879

task_queue *queue = create_queue();

6880

g_assert_nonnull(queue);

6881

__attribute__((cleanup(string_set_clear)))

6882

string_set cancelled_filenames = {};

6883

bool quit_now = false;

6884

int pipefds[2];

6885

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

6886

__attribute__((cleanup(cleanup_close)))

6887

const int read_pipe = pipefds[0];

6888

g_assert_cmpint(close(pipefds[1]), ==, 0);

6889

const char question_filename[] = "/nonexistent/question_filename";

6890

g_assert_true(string_set_add(&cancelled_filenames,

6891

question_filename));

6892

__attribute__((nonnull))

6893

void quit_func(const task_context task,

6894

__attribute__((unused)) task_queue *const q){

6895

g_assert_nonnull(task.quit_now);

6896

*task.quit_now = true;

6897

}

6898

task_context task = {

6899

.func=quit_func,

6900

.question_filename=strdup(question_filename),

6901

.quit_now=&quit_now,

6902

.fd=read_pipe,

6903

};

6904

g_assert_nonnull(task.question_filename);

6905

6906

g_assert_true(add_to_queue(queue, task));

6907

6908

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6909

g_assert_false(quit_now);

6910

6911

/* read_pipe should be closed already */

6912

errno = 0;

6913

bool read_pipe_closed = (close(read_pipe) == -1);

6914

read_pipe_closed &= (errno == EBADF);

6915

g_assert_true(read_pipe_closed);

6916

}

6917

6918

static void test_run_queue_one_task(__attribute__((unused))

6919

test_fixture *fixture,

6920

__attribute__((unused))

6921

gconstpointer user_data){

6922

__attribute__((cleanup(cleanup_queue)))

6923

task_queue *queue = create_queue();

6924

g_assert_nonnull(queue);

6925

__attribute__((cleanup(string_set_clear)))

6926

string_set cancelled_filenames = {};

6927

bool quit_now = false;

6928

6929

__attribute__((nonnull))

6930

void next_run_func(__attribute__((unused))

6931

const task_context task,

6932

task_queue *const q){

6933

q->next_run = 1;

6934

}

6935

6936

task_context task = {

6937

.func=next_run_func,

6938

};

6939

g_assert_true(add_to_queue(queue, task));

6940

6941

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6942

g_assert_cmpuint((unsigned int)(queue->next_run), ==, 1);

6943

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6944

}

6945

6946

static void test_run_queue_two_tasks(__attribute__((unused))

6947

test_fixture *fixture,

6948

__attribute__((unused))

6949

gconstpointer user_data){

6950

__attribute__((cleanup(cleanup_queue)))

6951

task_queue *queue = create_queue();

6952

g_assert_nonnull(queue);

6953

queue->next_run = 1;

6954

__attribute__((cleanup(string_set_clear)))

6955

string_set cancelled_filenames = {};

6956

bool quit_now = false;

6957

bool mandos_client_exited = false;

6958

6959

__attribute__((nonnull))

6960

void next_run_func(__attribute__((unused))

6961

const task_context task,

6962

task_queue *const q){

6963

q->next_run = 1;

6964

}

6965

6966

__attribute__((nonnull))

6967

void exited_func(const task_context task,

6968

__attribute__((unused)) task_queue *const q){

6969

*task.mandos_client_exited = true;

6970

}

6971

6972

task_context task1 = {

6973

.func=next_run_func,

6974

};

6975

g_assert_true(add_to_queue(queue, task1));

6976

6977

task_context task2 = {

6978

.func=exited_func,

6979

.mandos_client_exited=&mandos_client_exited,

6980

};

6981

g_assert_true(add_to_queue(queue, task2));

6982

6983

g_assert_true(run_queue(&queue, &cancelled_filenames, &quit_now));

6984

g_assert_false(quit_now);

6985

g_assert_cmpuint((unsigned int)(queue->next_run), ==, 1);

6986

g_assert_true(mandos_client_exited);

6987

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

6988

}

6989

6990

static void test_run_queue_two_tasks_quit(__attribute__((unused))

6991

test_fixture *fixture,

6992

__attribute__((unused))

6993

gconstpointer user_data){

6994

__attribute__((cleanup(cleanup_queue)))

6995

task_queue *queue = create_queue();

6996

g_assert_nonnull(queue);

6997

__attribute__((cleanup(string_set_clear)))

6998

string_set cancelled_filenames = {};

6999

bool quit_now = false;

7000

bool mandos_client_exited = false;

7001

bool password_is_read = false;

7002

7003

__attribute__((nonnull))

7004

void set_exited_func(const task_context task,

7005

__attribute__((unused)) task_queue *const q){

7006

*task.mandos_client_exited = true;

7007

*task.quit_now = true;

7008

}

7009

task_context task1 = {

7010

.func=set_exited_func,

7011

.quit_now=&quit_now,

7012

.mandos_client_exited=&mandos_client_exited,

7013

};

7014

g_assert_true(add_to_queue(queue, task1));

7015

7016

__attribute__((nonnull))

7017

void set_read_func(const task_context task,

7018

__attribute__((unused)) task_queue *const q){

7019

*task.quit_now = true;

7020

*task.password_is_read = true;

7021

}

7022

task_context task2 = {

7023

.func=set_read_func,

7024

.quit_now=&quit_now,

7025

.password_is_read=&password_is_read,

7026

};

7027

g_assert_true(add_to_queue(queue, task2));

7028

7029

g_assert_false(run_queue(&queue, &cancelled_filenames, &quit_now));

7030

g_assert_true(quit_now);

7031

g_assert_true(mandos_client_exited xor password_is_read);

7032

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

7033

}

7034

7035

static void test_run_queue_two_tasks_cleanup(__attribute__((unused))

7036

test_fixture *fixture,

7037

__attribute__((unused))

7038

gconstpointer user_data){

7039

__attribute__((cleanup(cleanup_queue)))

7040

task_queue *queue = create_queue();

7041

g_assert_nonnull(queue);

7042

__attribute__((cleanup(string_set_clear)))

7043

string_set cancelled_filenames = {};

7044

int pipefds[2];

7045

g_assert_cmpint(pipe2(pipefds, O_CLOEXEC | O_NONBLOCK), ==, 0);

7046

__attribute__((cleanup(cleanup_close)))

7047

const int read_pipe = pipefds[0];

7048

__attribute__((cleanup(cleanup_close)))

7049

const int write_pipe = pipefds[1];

7050

bool quit_now = false;

7051

7052

__attribute__((nonnull))

7053

void read_func(const task_context task,

7054

__attribute__((unused)) task_queue *const q){

7055

*task.quit_now = true;

7056

}

7057

task_context task1 = {

7058

.func=read_func,

7059

.quit_now=&quit_now,

7060

.fd=read_pipe,

7061

};

7062

g_assert_true(add_to_queue(queue, task1));

7063

7064

__attribute__((nonnull))

7065

void write_func(const task_context task,

7066

__attribute__((unused)) task_queue *const q){

7067

*task.quit_now = true;

7068

}

7069

task_context task2 = {

7070

.func=write_func,

7071

.quit_now=&quit_now,

7072

.fd=write_pipe,

7073

};

7074

g_assert_true(add_to_queue(queue, task2));

7075

7076

g_assert_false(run_queue(&queue, &cancelled_filenames, &quit_now));

7077

g_assert_true(quit_now);

7078

7079

/* Either read_pipe or write_pipe should be closed already */

7080

errno = 0;

7081

bool close_read_pipe = (close(read_pipe) == -1);

7082

close_read_pipe &= (errno == EBADF);

7083

errno = 0;

7084

bool close_write_pipe = (close(write_pipe) == -1);

7085

close_write_pipe &= (errno == EBADF);

7086

g_assert_true(close_read_pipe xor close_write_pipe);

7087

g_assert_cmpuint((unsigned int)(queue->length), ==, 0);

7088

}

7089

7090

static void test_setup_signal_handler(__attribute__((unused))

7091

test_fixture *fixture,

7092

__attribute__((unused))

7093

gconstpointer user_data){

7094

/* Save current SIGCHLD action, whatever it is */

7095

struct sigaction expected_sigchld_action;

7096

g_assert_cmpint(sigaction(SIGCHLD, NULL, &expected_sigchld_action),

7097

==, 0);

7098

7099

/* Act; i.e. run the setup_signal_handler() function */

7100

struct sigaction actual_old_sigchld_action;

7101

g_assert_true(setup_signal_handler(&actual_old_sigchld_action));

7102

7103

/* Check that the function correctly set "actual_old_sigchld_action"

7104

to the same values as the previously saved

7105

"expected_sigchld_action" */

7106

/* Check member sa_handler */

7107

g_assert_true(actual_old_sigchld_action.sa_handler

7108

== expected_sigchld_action.sa_handler);

7109

/* Check member sa_mask */

7110

for(int signum = 1; signum < NSIG; signum++){

7111

const int expected_old_block_state

7112

= sigismember(&expected_sigchld_action.sa_mask, signum);

7113

g_assert_cmpint(expected_old_block_state, >=, 0);

7114

const int actual_old_block_state

7115

= sigismember(&actual_old_sigchld_action.sa_mask, signum);

7116

g_assert_cmpint(actual_old_block_state, >=, 0);

7117

g_assert_cmpint(actual_old_block_state,

7118

==, expected_old_block_state);

7119

}

7120

/* Check member sa_flags */

7121

g_assert_true((actual_old_sigchld_action.sa_flags

7122

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

7123

== (expected_sigchld_action.sa_flags

7124

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART)));

7125

7126

/* Retrieve the current signal handler for SIGCHLD as set by

7127

setup_signal_handler() */

7128

struct sigaction actual_new_sigchld_action;

7129

g_assert_cmpint(sigaction(SIGCHLD, NULL,

7130

&actual_new_sigchld_action), ==, 0);

7131

/* Check that the signal handler (member sa_handler) is correctly

7132

set to the "handle_sigchld" function */

7133

g_assert_true(actual_new_sigchld_action.sa_handler != SIG_DFL);

7134

g_assert_true(actual_new_sigchld_action.sa_handler != SIG_IGN);

7135

g_assert_true(actual_new_sigchld_action.sa_handler

7136

== handle_sigchld);

7137

/* Check (in member sa_mask) that at least a handful of signals are

7138

actually blocked during the signal handler */

7139

for(int signum = 1; signum < NSIG; signum++){

7140

int actual_new_block_state;

7141

switch(signum){

7142

case SIGTERM:

7143

case SIGINT:

7144

case SIGQUIT:

7145

case SIGHUP:

7146

actual_new_block_state

7147

= sigismember(&actual_new_sigchld_action.sa_mask, signum);

7148

g_assert_cmpint(actual_new_block_state, ==, 1);

7149

continue;

7150

case SIGKILL: /* non-blockable */

7151

case SIGSTOP: /* non-blockable */

7152

case SIGCHLD: /* always blocked */

7153

default:

7154

continue;

7155

}

7156

}

7157

/* Check member sa_flags */

7158

g_assert_true((actual_new_sigchld_action.sa_flags

7159

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

7160

== (SA_NOCLDSTOP | SA_RESTART));

7161

7162

/* Restore signal handler */

7163

g_assert_cmpint(sigaction(SIGCHLD, &expected_sigchld_action, NULL),

7164

==, 0);

7165

}

7166

7167

static void test_restore_signal_handler(__attribute__((unused))

7168

test_fixture *fixture,

7169

__attribute__((unused))

7170

gconstpointer user_data){

7171

/* Save current SIGCHLD action, whatever it is */

7172

struct sigaction expected_sigchld_action;

7173

g_assert_cmpint(sigaction(SIGCHLD, NULL, &expected_sigchld_action),

7174

==, 0);

7175

/* Since we haven't established a signal handler yet, there should

7176

not be one established. But another test may have relied on

7177

restore_signal_handler() to restore the signal handler, and if

7178

restore_signal_handler() is buggy (which we should be prepared

7179

for in this test) the signal handler may not have been restored

7180

properly; check for this: */

7181

g_assert_true(expected_sigchld_action.sa_handler != handle_sigchld);

7182

7183

/* Establish a signal handler */

7184

struct sigaction sigchld_action = {

7185

.sa_handler=handle_sigchld,

7186

.sa_flags=SA_RESTART | SA_NOCLDSTOP,

7187

};

7188

g_assert_cmpint(sigfillset(&sigchld_action.sa_mask), ==, 0);

7189

g_assert_cmpint(sigaction(SIGCHLD, &sigchld_action, NULL), ==, 0);

7190

7191

/* Act; i.e. run the restore_signal_handler() function */

7192

g_assert_true(restore_signal_handler(&expected_sigchld_action));

7193

7194

/* Retrieve the restored signal handler data */

7195

struct sigaction actual_restored_sigchld_action;

7196

g_assert_cmpint(sigaction(SIGCHLD, NULL,

7197

&actual_restored_sigchld_action), ==, 0);

7198

7199

/* Check that the function correctly restored the signal action, as

7200

saved in "actual_restored_sigchld_action", to the same values as

7201

the previously saved "expected_sigchld_action" */

7202

/* Check member sa_handler */

7203

g_assert_true(actual_restored_sigchld_action.sa_handler

7204

== expected_sigchld_action.sa_handler);

7205

/* Check member sa_mask */

7206

for(int signum = 1; signum < NSIG; signum++){

7207

const int expected_old_block_state

7208

= sigismember(&expected_sigchld_action.sa_mask, signum);

7209

g_assert_cmpint(expected_old_block_state, >=, 0);

7210

const int actual_restored_block_state

7211

= sigismember(&actual_restored_sigchld_action.sa_mask, signum);

7212

g_assert_cmpint(actual_restored_block_state, >=, 0);

7213

g_assert_cmpint(actual_restored_block_state,

7214

==, expected_old_block_state);

7215

}

7216

/* Check member sa_flags */

7217

g_assert_true((actual_restored_sigchld_action.sa_flags

7218

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART))

7219

== (expected_sigchld_action.sa_flags

7220

& (SA_NOCLDSTOP | SA_ONSTACK | SA_RESTART)));

7221

}

7222

7223

static void test_block_sigchld(__attribute__((unused))

7224

test_fixture *fixture,

7225

__attribute__((unused))

7226

gconstpointer user_data){

7227

/* Save original signal mask */

7228

sigset_t expected_sigmask;

7229

g_assert_cmpint(pthread_sigmask(-1, NULL, &expected_sigmask),

7230

==, 0);

7231

7232

/* Make sure SIGCHLD is unblocked for this test */

7233

sigset_t sigchld_sigmask;

7234

g_assert_cmpint(sigemptyset(&sigchld_sigmask), ==, 0);

7235

g_assert_cmpint(sigaddset(&sigchld_sigmask, SIGCHLD), ==, 0);

7236

g_assert_cmpint(pthread_sigmask(SIG_UNBLOCK, &sigchld_sigmask,

7237

NULL), ==, 0);

7238

7239

/* Act; i.e. run the block_sigchld() function */

7240

sigset_t actual_old_sigmask;

7241

g_assert_true(block_sigchld(&actual_old_sigmask));

7242

7243

/* Check the actual_old_sigmask; it should be the same as the

7244

previously saved signal mask "expected_sigmask". */

7245

for(int signum = 1; signum < NSIG; signum++){

7246

const int expected_old_block_state

7247

= sigismember(&expected_sigmask, signum);

7248

g_assert_cmpint(expected_old_block_state, >=, 0);

7249

const int actual_old_block_state

7250

= sigismember(&actual_old_sigmask, signum);

7251

g_assert_cmpint(actual_old_block_state, >=, 0);

7252

g_assert_cmpint(actual_old_block_state,

7253

==, expected_old_block_state);

7254

}

7255

7256

/* Retrieve the newly set signal mask */

7257

sigset_t actual_sigmask;

7258

g_assert_cmpint(pthread_sigmask(-1, NULL, &actual_sigmask), ==, 0);

7259

7260

/* SIGCHLD should be blocked */

7261

g_assert_cmpint(sigismember(&actual_sigmask, SIGCHLD), ==, 1);

7262

7263

/* Restore signal mask */

7264

g_assert_cmpint(pthread_sigmask(SIG_SETMASK, &expected_sigmask,

7265

NULL), ==, 0);

7266

}

7267

7268

static void test_restore_sigmask(__attribute__((unused))

7269

test_fixture *fixture,

7270

__attribute__((unused))

7271

gconstpointer user_data){

7272

/* Save original signal mask */

7273

sigset_t orig_sigmask;

7274

g_assert_cmpint(pthread_sigmask(-1, NULL, &orig_sigmask), ==, 0);

7275

7276

/* Make sure SIGCHLD is blocked for this test */

7277

sigset_t sigchld_sigmask;

7278

g_assert_cmpint(sigemptyset(&sigchld_sigmask), ==, 0);

7279

g_assert_cmpint(sigaddset(&sigchld_sigmask, SIGCHLD), ==, 0);

7280

g_assert_cmpint(pthread_sigmask(SIG_BLOCK, &sigchld_sigmask,

7281

NULL), ==, 0);

7282

7283

/* Act; i.e. run the restore_sigmask() function */

7284

g_assert_true(restore_sigmask(&orig_sigmask));

7285

7286

/* Retrieve the newly restored signal mask */

7287

sigset_t restored_sigmask;

7288

g_assert_cmpint(pthread_sigmask(-1, NULL, &restored_sigmask),

7289

==, 0);

7290

7291

/* Check the restored_sigmask; it should be the same as the

7292

previously saved signal mask "orig_sigmask". */

7293

for(int signum = 1; signum < NSIG; signum++){

7294

const int orig_block_state = sigismember(&orig_sigmask, signum);

7295

g_assert_cmpint(orig_block_state, >=, 0);

7296

const int restored_block_state = sigismember(&restored_sigmask,

7297

signum);

7298

g_assert_cmpint(restored_block_state, >=, 0);

7299

g_assert_cmpint(restored_block_state, ==, orig_block_state);

7300

}

7301

7302

/* Restore signal mask */

7303

g_assert_cmpint(pthread_sigmask(SIG_SETMASK, &orig_sigmask,

7304

NULL), ==, 0);

7305

}

7306

7307

static void test_parse_arguments_noargs(__attribute__((unused))

7308

test_fixture *fixture,

7309

__attribute__((unused))

7310

gconstpointer user_data){

7311

char *argv[] = {

7312

strdup("prgname"),

7313

NULL };

7314

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7315

7316

char *agent_directory = NULL;

7317

char *helper_directory = NULL;

7318

uid_t user = 0;

7319

gid_t group = 0;

7320

char *mandos_argz = NULL;

7321

size_t mandos_argz_length = 0;

7322

7323

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7324

&helper_directory, &user, &group,

7325

&mandos_argz, &mandos_argz_length));

7326

g_assert_null(agent_directory);

7327

g_assert_null(helper_directory);

7328

g_assert_true(user == 0);

7329

g_assert_true(group == 0);

7330

g_assert_null(mandos_argz);

7331

g_assert_true(mandos_argz_length == 0);

7332

7333

for(char **arg = argv; *arg != NULL; arg++){

7334

free(*arg);

7335

}

7336

}

7337

7338

__attribute__((nonnull))

7339

static bool parse_arguments_devnull(int argc, char *argv[],

7340

const bool exit_failure,

7341

char **agent_directory,

7342

char **helper_directory,

7343

uid_t *const user,

7344

gid_t *const group,

7345

char **mandos_argz,

7346

size_t *mandos_argz_length){

7347

7348

FILE *real_stderr = stderr;

7349

FILE *devnull = fopen("/dev/null", "we");

7350

g_assert_nonnull(devnull);

7351

stderr = devnull;

7352

7353

const bool ret = parse_arguments(argc, argv, exit_failure,

7354

agent_directory,

7355

helper_directory, user, group,

7356

mandos_argz, mandos_argz_length);

7357

const error_t saved_errno = errno;

7358

7359

stderr = real_stderr;

7360

g_assert_cmpint(fclose(devnull), ==, 0);

7361

7362

errno = saved_errno;

7363

7364

return ret;

7365

}

7366

7367

static void test_parse_arguments_invalid(__attribute__((unused))

7368

test_fixture *fixture,

7369

__attribute__((unused))

7370

gconstpointer user_data){

7371

char *argv[] = {

7372

strdup("prgname"),

7373

strdup("--invalid"),

7374

NULL };

7375

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7376

7377

char *agent_directory = NULL;

7378

char *helper_directory = NULL;

7379

uid_t user = 0;

7380

gid_t group = 0;

7381

char *mandos_argz = NULL;

7382

size_t mandos_argz_length = 0;

7383

7384

g_assert_false(parse_arguments_devnull(argc, argv, false,

7385

&agent_directory,

7386

&helper_directory, &user,

7387

&group, &mandos_argz,

7388

&mandos_argz_length));

7389

7390

g_assert_true(errno == EINVAL);

7391

g_assert_null(agent_directory);

7392

g_assert_null(helper_directory);

7393

g_assert_null(mandos_argz);

7394

g_assert_true(mandos_argz_length == 0);

7395

7396

for(char **arg = argv; *arg != NULL; arg++){

7397

free(*arg);

7398

}

7399

}

7400

7401

static void test_parse_arguments_long_dir(__attribute__((unused))

7402

test_fixture *fixture,

7403

__attribute__((unused))

7404

gconstpointer user_data){

7405

char *argv[] = {

7406

strdup("prgname"),

7407

strdup("--agent-directory"),

7408

strdup("/tmp"),

7409

NULL };

7410

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7411

7412

__attribute__((cleanup(cleanup_string)))

7413

char *agent_directory = NULL;

7414

char *helper_directory = NULL;

7415

uid_t user = 0;

7416

gid_t group = 0;

7417

__attribute__((cleanup(cleanup_string)))

7418

char *mandos_argz = NULL;

7419

size_t mandos_argz_length = 0;

7420

7421

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7422

&helper_directory, &user, &group,

7423

&mandos_argz, &mandos_argz_length));

7424

7425

g_assert_cmpstr(agent_directory, ==, "/tmp");

7426

g_assert_null(helper_directory);

7427

g_assert_true(user == 0);

7428

g_assert_true(group == 0);

7429

g_assert_null(mandos_argz);

7430

g_assert_true(mandos_argz_length == 0);

7431

7432

for(char **arg = argv; *arg != NULL; arg++){

7433

free(*arg);

7434

}

7435

}

7436

7437

static void test_parse_arguments_short_dir(__attribute__((unused))

7438

test_fixture *fixture,

7439

__attribute__((unused))

7440

gconstpointer user_data){

7441

char *argv[] = {

7442

strdup("prgname"),

7443

strdup("-d"),

7444

strdup("/tmp"),

7445

NULL };

7446

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7447

7448

__attribute__((cleanup(cleanup_string)))

7449

char *agent_directory = NULL;

7450

char *helper_directory = NULL;

7451

uid_t user = 0;

7452

gid_t group = 0;

7453

__attribute__((cleanup(cleanup_string)))

7454

char *mandos_argz = NULL;

7455

size_t mandos_argz_length = 0;

7456

7457

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7458

&helper_directory, &user, &group,

7459

&mandos_argz, &mandos_argz_length));

7460

7461

g_assert_cmpstr(agent_directory, ==, "/tmp");

7462

g_assert_null(helper_directory);

7463

g_assert_true(user == 0);

7464

g_assert_true(group == 0);

7465

g_assert_null(mandos_argz);

7466

g_assert_true(mandos_argz_length == 0);

7467

7468

for(char **arg = argv; *arg != NULL; arg++){

7469

free(*arg);

7470

}

7471

}

7472

7473

static

7474

void test_parse_arguments_helper_directory(__attribute__((unused))

7475

test_fixture *fixture,

7476

__attribute__((unused))

7477

gconstpointer user_data){

7478

char *argv[] = {

7479

strdup("prgname"),

7480

strdup("--helper-directory"),

7481

strdup("/tmp"),

7482

NULL };

7483

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7484

7485

char *agent_directory = NULL;

7486

__attribute__((cleanup(cleanup_string)))

7487

char *helper_directory = NULL;

7488

uid_t user = 0;

7489

gid_t group = 0;

7490

__attribute__((cleanup(cleanup_string)))

7491

char *mandos_argz = NULL;

7492

size_t mandos_argz_length = 0;

7493

7494

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7495

&helper_directory, &user, &group,

7496

&mandos_argz, &mandos_argz_length));

7497

7498

g_assert_cmpstr(helper_directory, ==, "/tmp");

7499

g_assert_null(agent_directory);

7500

g_assert_true(user == 0);

7501

g_assert_true(group == 0);

7502

g_assert_null(mandos_argz);

7503

g_assert_true(mandos_argz_length == 0);

7504

7505

for(char **arg = argv; *arg != NULL; arg++){

7506

free(*arg);

7507

}

7508

}

7509

7510

static

7511

void test_parse_arguments_plugin_helper_dir(__attribute__((unused))

7512

test_fixture *fixture,

7513

__attribute__((unused))

7514

gconstpointer user_data){

7515

char *argv[] = {

7516

strdup("prgname"),

7517

strdup("--plugin-helper-dir"),

7518

strdup("/tmp"),

7519

NULL };

7520

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7521

7522

char *agent_directory = NULL;

7523

__attribute__((cleanup(cleanup_string)))

7524

char *helper_directory = NULL;

7525

uid_t user = 0;

7526

gid_t group = 0;

7527

__attribute__((cleanup(cleanup_string)))

7528

char *mandos_argz = NULL;

7529

size_t mandos_argz_length = 0;

7530

7531

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7532

&helper_directory, &user, &group,

7533

&mandos_argz, &mandos_argz_length));

7534

7535

g_assert_cmpstr(helper_directory, ==, "/tmp");

7536

g_assert_null(agent_directory);

7537

g_assert_true(user == 0);

7538

g_assert_true(group == 0);

7539

g_assert_null(mandos_argz);

7540

g_assert_true(mandos_argz_length == 0);

7541

7542

for(char **arg = argv; *arg != NULL; arg++){

7543

free(*arg);

7544

}

7545

}

7546

7547

static void test_parse_arguments_user(__attribute__((unused))

7548

test_fixture *fixture,

7549

__attribute__((unused))

7550

gconstpointer user_data){

7551

char *argv[] = {

7552

strdup("prgname"),

7553

strdup("--user"),

7554

strdup("1000"),

7555

NULL };

7556

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7557

7558

char *agent_directory = NULL;

7559

__attribute__((cleanup(cleanup_string)))

7560

char *helper_directory = NULL;

7561

uid_t user = 0;

7562

gid_t group = 0;

7563

__attribute__((cleanup(cleanup_string)))

7564

char *mandos_argz = NULL;

7565

size_t mandos_argz_length = 0;

7566

7567

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7568

&helper_directory, &user, &group,

7569

&mandos_argz, &mandos_argz_length));

7570

7571

g_assert_null(helper_directory);

7572

g_assert_null(agent_directory);

7573

g_assert_cmpuint((unsigned int)user, ==, 1000);

7574

g_assert_true(group == 0);

7575

g_assert_null(mandos_argz);

7576

g_assert_true(mandos_argz_length == 0);

7577

7578

for(char **arg = argv; *arg != NULL; arg++){

7579

free(*arg);

7580

}

7581

}

7582

7583

static void test_parse_arguments_user_invalid(__attribute__((unused))

7584

test_fixture *fixture,

7585

__attribute__((unused))

7586

gconstpointer

7587

user_data){

7588

char *argv[] = {

7589

strdup("prgname"),

7590

strdup("--user"),

7591

strdup("invalid"),

7592

NULL };

7593

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7594

7595

char *agent_directory = NULL;

7596

__attribute__((cleanup(cleanup_string)))

7597

char *helper_directory = NULL;

7598

uid_t user = 0;

7599

gid_t group = 0;

7600

__attribute__((cleanup(cleanup_string)))

7601

char *mandos_argz = NULL;

7602

size_t mandos_argz_length = 0;

7603

7604

g_assert_false(parse_arguments_devnull(argc, argv, false,

7605

&agent_directory,

7606

&helper_directory, &user,

7607

&group, &mandos_argz,

7608

&mandos_argz_length));

7609

7610

g_assert_null(helper_directory);

7611

g_assert_null(agent_directory);

7612

g_assert_cmpuint((unsigned int)user, ==, 0);

7613

g_assert_true(group == 0);

7614

g_assert_null(mandos_argz);

7615

g_assert_true(mandos_argz_length == 0);

7616

7617

for(char **arg = argv; *arg != NULL; arg++){

7618

free(*arg);

7619

}

7620

}

7621

7622

static

7623

void test_parse_arguments_user_zero_invalid(__attribute__((unused))

7624

test_fixture *fixture,

7625

__attribute__((unused))

7626

gconstpointer user_data){

7627

char *argv[] = {

7628

strdup("prgname"),

7629

strdup("--user"),

7630

strdup("0"),

7631

NULL };

7632

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7633

7634

char *agent_directory = NULL;

7635

__attribute__((cleanup(cleanup_string)))

7636

char *helper_directory = NULL;

7637

uid_t user = 0;

7638

gid_t group = 0;

7639

__attribute__((cleanup(cleanup_string)))

7640

char *mandos_argz = NULL;

7641

size_t mandos_argz_length = 0;

7642

7643

g_assert_false(parse_arguments_devnull(argc, argv, false,

7644

&agent_directory,

7645

&helper_directory, &user,

7646

&group, &mandos_argz,

7647

&mandos_argz_length));

7648

7649

g_assert_null(helper_directory);

7650

g_assert_null(agent_directory);

7651

g_assert_cmpuint((unsigned int)user, ==, 0);

7652

g_assert_true(group == 0);

7653

g_assert_null(mandos_argz);

7654

g_assert_true(mandos_argz_length == 0);

7655

7656

for(char **arg = argv; *arg != NULL; arg++){

7657

free(*arg);

7658

}

7659

}

7660

7661

static void test_parse_arguments_group(__attribute__((unused))

7662

test_fixture *fixture,

7663

__attribute__((unused))

7664

gconstpointer user_data){

7665

char *argv[] = {

7666

strdup("prgname"),

7667

strdup("--group"),

7668

strdup("1000"),

7669

NULL };

7670

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7671

7672

char *agent_directory = NULL;

7673

__attribute__((cleanup(cleanup_string)))

7674

char *helper_directory = NULL;

7675

uid_t user = 0;

7676

gid_t group = 0;

7677

__attribute__((cleanup(cleanup_string)))

7678

char *mandos_argz = NULL;

7679

size_t mandos_argz_length = 0;

7680

7681

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7682

&helper_directory, &user, &group,

7683

&mandos_argz, &mandos_argz_length));

7684

7685

g_assert_null(helper_directory);

7686

g_assert_null(agent_directory);

7687

g_assert_true(user == 0);

7688

g_assert_cmpuint((unsigned int)group, ==, 1000);

7689

g_assert_null(mandos_argz);

7690

g_assert_true(mandos_argz_length == 0);

7691

7692

for(char **arg = argv; *arg != NULL; arg++){

7693

free(*arg);

7694

}

7695

}

7696

7697

static void test_parse_arguments_group_invalid(__attribute__((unused))

7698

test_fixture *fixture,

7699

__attribute__((unused))

7700

gconstpointer

7701

user_data){

7702

char *argv[] = {

7703

strdup("prgname"),

7704

strdup("--group"),

7705

strdup("invalid"),

7706

NULL };

7707

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7708

7709

char *agent_directory = NULL;

7710

__attribute__((cleanup(cleanup_string)))

7711

char *helper_directory = NULL;

7712

uid_t user = 0;

7713

gid_t group = 0;

7714

__attribute__((cleanup(cleanup_string)))

7715

char *mandos_argz = NULL;

7716

size_t mandos_argz_length = 0;

7717

7718

g_assert_false(parse_arguments_devnull(argc, argv, false,

7719

&agent_directory,

7720

&helper_directory, &user,

7721

&group, &mandos_argz,

7722

&mandos_argz_length));

7723

7724

g_assert_null(helper_directory);

7725

g_assert_null(agent_directory);

7726

g_assert_true(user == 0);

7727

g_assert_true(group == 0);

7728

g_assert_null(mandos_argz);

7729

g_assert_true(mandos_argz_length == 0);

7730

7731

for(char **arg = argv; *arg != NULL; arg++){

7732

free(*arg);

7733

}

7734

}

7735

7736

static

7737

void test_parse_arguments_group_zero_invalid(__attribute__((unused))

7738

test_fixture *fixture,

7739

__attribute__((unused))

7740

gconstpointer user_data){

7741

char *argv[] = {

7742

strdup("prgname"),

7743

strdup("--group"),

7744

strdup("0"),

7745

NULL };

7746

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7747

7748

char *agent_directory = NULL;

7749

__attribute__((cleanup(cleanup_string)))

7750

char *helper_directory = NULL;

7751

uid_t user = 0;

7752

gid_t group = 0;

7753

__attribute__((cleanup(cleanup_string)))

7754

char *mandos_argz = NULL;

7755

size_t mandos_argz_length = 0;

7756

7757

g_assert_false(parse_arguments_devnull(argc, argv, false,

7758

&agent_directory,

7759

&helper_directory, &user,

7760

&group, &mandos_argz,

7761

&mandos_argz_length));

7762

7763

g_assert_null(helper_directory);

7764

g_assert_null(agent_directory);

7765

g_assert_cmpuint((unsigned int)group, ==, 0);

7766

g_assert_true(group == 0);

7767

g_assert_null(mandos_argz);

7768

g_assert_true(mandos_argz_length == 0);

7769

7770

for(char **arg = argv; *arg != NULL; arg++){

7771

free(*arg);

7772

}

7773

}

7774

7775

static void test_parse_arguments_mandos_noargs(__attribute__((unused))

7776

test_fixture *fixture,

7777

__attribute__((unused))

7778

gconstpointer

7779

user_data){

7780

char *argv[] = {

7781

strdup("prgname"),

7782

strdup("mandos-client"),

7783

NULL };

7784

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7785

7786

__attribute__((cleanup(cleanup_string)))

7787

char *agent_directory = NULL;

7788

__attribute__((cleanup(cleanup_string)))

7789

char *helper_directory = NULL;

7790

uid_t user = 0;

7791

gid_t group = 0;

7792

__attribute__((cleanup(cleanup_string)))

7793

char *mandos_argz = NULL;

7794

size_t mandos_argz_length = 0;

7795

7796

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7797

&helper_directory, &user, &group,

7798

&mandos_argz, &mandos_argz_length));

7799

7800

g_assert_null(agent_directory);

7801

g_assert_null(helper_directory);

7802

g_assert_true(user == 0);

7803

g_assert_true(group == 0);

7804

g_assert_cmpstr(mandos_argz, ==, "mandos-client");

7805

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7806

mandos_argz_length),

7807

==, 1);

7808

7809

for(char **arg = argv; *arg != NULL; arg++){

7810

free(*arg);

7811

}

7812

}

7813

7814

static void test_parse_arguments_mandos_args(__attribute__((unused))

7815

test_fixture *fixture,

7816

__attribute__((unused))

7817

gconstpointer user_data){

7818

char *argv[] = {

7819

strdup("prgname"),

7820

strdup("mandos-client"),

7821

strdup("one"),

7822

strdup("two"),

7823

strdup("three"),

7824

NULL };

7825

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7826

7827

__attribute__((cleanup(cleanup_string)))

7828

char *agent_directory = NULL;

7829

__attribute__((cleanup(cleanup_string)))

7830

char *helper_directory = NULL;

7831

uid_t user = 0;

7832

gid_t group = 0;

7833

__attribute__((cleanup(cleanup_string)))

7834

char *mandos_argz = NULL;

7835

size_t mandos_argz_length = 0;

7836

7837

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7838

&helper_directory, &user, &group,

7839

&mandos_argz, &mandos_argz_length));

7840

7841

g_assert_null(agent_directory);

7842

g_assert_null(helper_directory);

7843

g_assert_true(user == 0);

7844

g_assert_true(group == 0);

7845

char *marg = mandos_argz;

7846

g_assert_cmpstr(marg, ==, "mandos-client");

7847

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7848

g_assert_cmpstr(marg, ==, "one");

7849

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7850

g_assert_cmpstr(marg, ==, "two");

7851

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7852

g_assert_cmpstr(marg, ==, "three");

7853

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7854

mandos_argz_length),

7855

==, 4);

7856

7857

for(char **arg = argv; *arg != NULL; arg++){

7858

free(*arg);

7859

}

7860

}

7861

7862

static void test_parse_arguments_all_args(__attribute__((unused))

7863

test_fixture *fixture,

7864

__attribute__((unused))

7865

gconstpointer user_data){

7866

char *argv[] = {

7867

strdup("prgname"),

7868

strdup("--agent-directory"),

7869

strdup("/tmp"),

7870

strdup("--helper-directory"),

7871

strdup("/var/tmp"),

7872

strdup("--user"),

7873

strdup("1"),

7874

strdup("--group"),

7875

strdup("2"),

7876

strdup("mandos-client"),

7877

strdup("one"),

7878

strdup("two"),

7879

strdup("three"),

7880

NULL };

7881

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7882

7883

__attribute__((cleanup(cleanup_string)))

7884

char *agent_directory = NULL;

7885

__attribute__((cleanup(cleanup_string)))

7886

char *helper_directory = NULL;

7887

uid_t user = 0;

7888

gid_t group = 0;

7889

__attribute__((cleanup(cleanup_string)))

7890

char *mandos_argz = NULL;

7891

size_t mandos_argz_length = 0;

7892

7893

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7894

&helper_directory, &user, &group,

7895

&mandos_argz, &mandos_argz_length));

7896

7897

g_assert_cmpstr(agent_directory, ==, "/tmp");

7898

g_assert_cmpstr(helper_directory, ==, "/var/tmp");

7899

g_assert_true(user == 1);

7900

g_assert_true(group == 2);

7901

char *marg = mandos_argz;

7902

g_assert_cmpstr(marg, ==, "mandos-client");

7903

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7904

g_assert_cmpstr(marg, ==, "one");

7905

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7906

g_assert_cmpstr(marg, ==, "two");

7907

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7908

g_assert_cmpstr(marg, ==, "three");

7909

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7910

mandos_argz_length),

7911

==, 4);

7912

7913

for(char **arg = argv; *arg != NULL; arg++){

7914

free(*arg);

7915

}

7916

}

7917

7918

static void test_parse_arguments_mixed(__attribute__((unused))

7919

test_fixture *fixture,

7920

__attribute__((unused))

7921

gconstpointer user_data){

7922

char *argv[] = {

7923

strdup("prgname"),

7924

strdup("mandos-client"),

7925

strdup("--user"),

7926

strdup("1"),

7927

strdup("one"),

7928

strdup("--agent-directory"),

7929

strdup("/tmp"),

7930

strdup("two"),

7931

strdup("three"),

7932

strdup("--helper-directory=/var/tmp"),

7933

NULL };

7934

const int argc = (sizeof(argv) / sizeof(char *)) - 1;

7935

7936

__attribute__((cleanup(cleanup_string)))

7937

char *agent_directory = NULL;

7938

__attribute__((cleanup(cleanup_string)))

7939

char *helper_directory = NULL;

7940

uid_t user = 0;

7941

gid_t group = 0;

7942

__attribute__((cleanup(cleanup_string)))

7943

char *mandos_argz = NULL;

7944

size_t mandos_argz_length = 0;

7945

7946

g_assert_true(parse_arguments(argc, argv, false, &agent_directory,

7947

&helper_directory, &user, &group,

7948

&mandos_argz, &mandos_argz_length));

7949

7950

g_assert_cmpstr(agent_directory, ==, "/tmp");

7951

g_assert_cmpstr(helper_directory, ==, "/var/tmp");

7952

g_assert_true(user == 1);

7953

g_assert_true(group == 0);

7954

char *marg = mandos_argz;

7955

g_assert_cmpstr(marg, ==, "mandos-client");

7956

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7957

g_assert_cmpstr(marg, ==, "one");

7958

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7959

g_assert_cmpstr(marg, ==, "two");

7960

marg = argz_next(mandos_argz, mandos_argz_length, marg);

7961

g_assert_cmpstr(marg, ==, "three");

7962

g_assert_cmpuint((unsigned int)argz_count(mandos_argz,

7963

mandos_argz_length),

7964

==, 4);

7965

7966

for(char **arg = argv; *arg != NULL; arg++){

7967

free(*arg);

7968

}

7969

}

7970

7971

/* End of tests section */

7972

7973

/* Test boilerplate section; New tests should be added to the test

7974

suite definition here, in the "run_tests" function.

7975

7976

Finally, this section also contains the should_only_run_tests()

7977

function used by main() for deciding if tests should be run or to

7978

start normally. */

7979

7980

__attribute__((cold))

7981

static bool run_tests(int argc, char *argv[]){

7982

g_test_init(&argc, &argv, NULL);

7983

7984

/* A macro to add a test with no setup or teardown functions */

7985

#define test_add(testpath, testfunc) \

7986

do { \

7987

g_test_add((testpath), test_fixture, NULL, NULL, \

7988

(testfunc), NULL); \

7989

} while(false)

7990

7991

/* Test the signal-related functions first, since some other tests

7992

depend on these functions in their setups and teardowns */

7993

test_add("/signal-handling/setup", test_setup_signal_handler);

7994

test_add("/signal-handling/restore", test_restore_signal_handler);

7995

test_add("/signal-handling/block", test_block_sigchld);

7996

test_add("/signal-handling/restore-sigmask", test_restore_sigmask);

7997

7998

/* Regular non-signal-related tests; these use no setups or

7999

teardowns */

8000

test_add("/parse_arguments/noargs", test_parse_arguments_noargs);

8001

test_add("/parse_arguments/invalid", test_parse_arguments_invalid);

8002

test_add("/parse_arguments/long-dir",

8003

test_parse_arguments_long_dir);

8004

test_add("/parse_arguments/short-dir",

8005

test_parse_arguments_short_dir);

8006

test_add("/parse_arguments/helper-directory",

8007

test_parse_arguments_helper_directory);

8008

test_add("/parse_arguments/plugin-helper-dir",

8009

test_parse_arguments_plugin_helper_dir);

8010

test_add("/parse_arguments/user", test_parse_arguments_user);

8011

test_add("/parse_arguments/user-invalid",

8012

test_parse_arguments_user_invalid);

8013

test_add("/parse_arguments/user-zero-invalid",

8014

test_parse_arguments_user_zero_invalid);

8015

test_add("/parse_arguments/group", test_parse_arguments_group);

8016

test_add("/parse_arguments/group-invalid",

8017

test_parse_arguments_group_invalid);

8018

test_add("/parse_arguments/group-zero-invalid",

8019

test_parse_arguments_group_zero_invalid);

8020

test_add("/parse_arguments/mandos-noargs",

8021

test_parse_arguments_mandos_noargs);

8022

test_add("/parse_arguments/mandos-args",

8023

test_parse_arguments_mandos_args);

8024

test_add("/parse_arguments/all-args",

8025

test_parse_arguments_all_args);

8026

test_add("/parse_arguments/mixed", test_parse_arguments_mixed);

8027

test_add("/queue/create", test_create_queue);

8028

test_add("/queue/add", test_add_to_queue);

8029

test_add("/queue/add/overflow", test_add_to_queue_overflow);

8030

test_add("/queue/has_question/empty",

8031

test_queue_has_question_empty);

8032

test_add("/queue/has_question/false",

8033

test_queue_has_question_false);

8034

test_add("/queue/has_question/true", test_queue_has_question_true);

8035

test_add("/queue/has_question/false2",

8036

test_queue_has_question_false2);

8037

test_add("/queue/has_question/true2",

8038

test_queue_has_question_true2);

8039

test_add("/buffer/cleanup", test_cleanup_buffer);

8040

test_add("/string_set/net-set-contains-nothing",

8041

test_string_set_new_set_contains_nothing);

8042

test_add("/string_set/with-added-string-contains-it",

8043

test_string_set_with_added_string_contains_it);

8044

test_add("/string_set/cleared-does-not-contain-string",

8045

test_string_set_cleared_does_not_contain_str);

8046

test_add("/string_set/swap/one-with-empty",

8047

test_string_set_swap_one_with_empty);

8048

test_add("/string_set/swap/empty-with-one",

8049

test_string_set_swap_empty_with_one);

8050

test_add("/string_set/swap/one-with-one",

8051

test_string_set_swap_one_with_one);

8052

8053

/* A macro to add a test using the setup and teardown functions */

8054

#define test_add_st(path, func) \

8055

do { \

8056

g_test_add((path), test_fixture, NULL, test_setup, (func), \

8057

test_teardown); \

8058

} while(false)

8059

8060

/* Signal-related tests; these use setups and teardowns which

8061

establish, during each test run, a signal handler for, and a

8062

signal mask blocking, the SIGCHLD signal, just like main() */

8063

test_add_st("/wait_for_event/timeout", test_wait_for_event_timeout);

8064

test_add_st("/wait_for_event/event", test_wait_for_event_event);

8065

test_add_st("/wait_for_event/sigchld", test_wait_for_event_sigchld);

8066

test_add_st("/run_queue/zeroes-next-run",

8067

test_run_queue_zeroes_next_run);

8068

test_add_st("/run_queue/clears-cancelled_filenames",

8069

test_run_queue_clears_cancelled_filenames);

8070

test_add_st("/run_queue/skips-cancelled-filenames",

8071

test_run_queue_skips_cancelled_filenames);

8072

test_add_st("/run_queue/one-task", test_run_queue_one_task);

8073

test_add_st("/run_queue/two-tasks", test_run_queue_two_tasks);

8074

test_add_st("/run_queue/two-tasks/quit",

8075

test_run_queue_two_tasks_quit);

8076

test_add_st("/run_queue/two-tasks-cleanup",

8077

test_run_queue_two_tasks_cleanup);

8078

test_add_st("/task-creators/start_mandos_client",

8079

test_start_mandos_client);

8080

test_add_st("/task-creators/start_mandos_client/execv",

8081

test_start_mandos_client_execv);

8082

test_add_st("/task-creators/start_mandos_client/suid/euid",

8083

test_start_mandos_client_suid_euid);

8084

test_add_st("/task-creators/start_mandos_client/suid/egid",

8085

test_start_mandos_client_suid_egid);

8086

test_add_st("/task-creators/start_mandos_client/suid/ruid",

8087

test_start_mandos_client_suid_ruid);

8088

test_add_st("/task-creators/start_mandos_client/suid/rgid",

8089

test_start_mandos_client_suid_rgid);

8090

test_add_st("/task-creators/start_mandos_client/read",

8091

test_start_mandos_client_read);

8092

test_add_st("/task-creators/start_mandos_client/helper-directory",

8093

test_start_mandos_client_helper_directory);

8094

test_add_st("/task-creators/start_mandos_client/sigmask",

8095

test_start_mandos_client_sigmask);

8096

test_add_st("/task/wait_for_mandos_client_exit/badpid",

8097

test_wait_for_mandos_client_exit_badpid);

8098

test_add_st("/task/wait_for_mandos_client_exit/noexit",

8099

test_wait_for_mandos_client_exit_noexit);

8100

test_add_st("/task/wait_for_mandos_client_exit/success",

8101

test_wait_for_mandos_client_exit_success);

8102

test_add_st("/task/wait_for_mandos_client_exit/failure",

8103

test_wait_for_mandos_client_exit_failure);

8104

test_add_st("/task/wait_for_mandos_client_exit/killed",

8105

test_wait_for_mandos_client_exit_killed);

8106

test_add_st("/task/read_mandos_client_output/readerror",

8107

test_read_mandos_client_output_readerror);

8108

test_add_st("/task/read_mandos_client_output/nodata",

8109

test_read_mandos_client_output_nodata);

8110

test_add_st("/task/read_mandos_client_output/eof",

8111

test_read_mandos_client_output_eof);

8112

test_add_st("/task/read_mandos_client_output/once",

8113

test_read_mandos_client_output_once);

8114

test_add_st("/task/read_mandos_client_output/malloc",

8115

test_read_mandos_client_output_malloc);

8116

test_add_st("/task/read_mandos_client_output/append",

8117

test_read_mandos_client_output_append);

8118

test_add_st("/task-creators/add_inotify_dir_watch",

8119

test_add_inotify_dir_watch);

8120

test_add_st("/task-creators/add_inotify_dir_watch/fail",

8121

test_add_inotify_dir_watch_fail);

8122

test_add_st("/task-creators/add_inotify_dir_watch/not-a-directory",

8123

test_add_inotify_dir_watch_nondir);

8124

test_add_st("/task-creators/add_inotify_dir_watch/EAGAIN",

8125

test_add_inotify_dir_watch_EAGAIN);

8126

test_add_st("/task-creators/add_inotify_dir_watch/IN_CLOSE_WRITE",

8127

test_add_inotify_dir_watch_IN_CLOSE_WRITE);

8128

test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_TO",

8129

test_add_inotify_dir_watch_IN_MOVED_TO);

8130

test_add_st("/task-creators/add_inotify_dir_watch/IN_MOVED_FROM",

8131

test_add_inotify_dir_watch_IN_MOVED_FROM);

8132

test_add_st("/task-creators/add_inotify_dir_watch/IN_EXCL_UNLINK",

8133

test_add_inotify_dir_watch_IN_EXCL_UNLINK);

8134

test_add_st("/task-creators/add_inotify_dir_watch/IN_DELETE",

8135

test_add_inotify_dir_watch_IN_DELETE);

8136

test_add_st("/task/read_inotify_event/readerror",

8137

test_read_inotify_event_readerror);

8138

test_add_st("/task/read_inotify_event/bad-epoll",

8139

test_read_inotify_event_bad_epoll);

8140

test_add_st("/task/read_inotify_event/nodata",

8141

test_read_inotify_event_nodata);

8142

test_add_st("/task/read_inotify_event/eof",

8143

test_read_inotify_event_eof);

8144

test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE",

8145

test_read_inotify_event_IN_CLOSE_WRITE);

8146

test_add_st("/task/read_inotify_event/IN_MOVED_TO",

8147

test_read_inotify_event_IN_MOVED_TO);

8148

test_add_st("/task/read_inotify_event/IN_MOVED_FROM",

8149

test_read_inotify_event_IN_MOVED_FROM);

8150

test_add_st("/task/read_inotify_event/IN_DELETE",

8151

test_read_inotify_event_IN_DELETE);

8152

test_add_st("/task/read_inotify_event/IN_CLOSE_WRITE/badname",

8153

test_read_inotify_event_IN_CLOSE_WRITE_badname);

8154

test_add_st("/task/read_inotify_event/IN_MOVED_TO/badname",

8155

test_read_inotify_event_IN_MOVED_TO_badname);

8156

test_add_st("/task/read_inotify_event/IN_MOVED_FROM/badname",

8157

test_read_inotify_event_IN_MOVED_FROM_badname);

8158

test_add_st("/task/read_inotify_event/IN_DELETE/badname",

8159

test_read_inotify_event_IN_DELETE_badname);

8160

test_add_st("/task/open_and_parse_question/ENOENT",

8161

test_open_and_parse_question_ENOENT);

8162

test_add_st("/task/open_and_parse_question/EIO",

8163

test_open_and_parse_question_EIO);

8164

test_add_st("/task/open_and_parse_question/parse-error",

8165

test_open_and_parse_question_parse_error);

8166

test_add_st("/task/open_and_parse_question/nosocket",

8167

test_open_and_parse_question_nosocket);

8168

test_add_st("/task/open_and_parse_question/badsocket",

8169

test_open_and_parse_question_badsocket);

8170

test_add_st("/task/open_and_parse_question/nopid",

8171

test_open_and_parse_question_nopid);

8172

test_add_st("/task/open_and_parse_question/badpid",

8173

test_open_and_parse_question_badpid);

8174

test_add_st("/task/open_and_parse_question/noexist_pid",

8175

test_open_and_parse_question_noexist_pid);

8176

test_add_st("/task/open_and_parse_question/no-notafter",

8177

test_open_and_parse_question_no_notafter);

8178

test_add_st("/task/open_and_parse_question/bad-notafter",

8179

test_open_and_parse_question_bad_notafter);

8180

test_add_st("/task/open_and_parse_question/notafter-0",

8181

test_open_and_parse_question_notafter_0);

8182

test_add_st("/task/open_and_parse_question/notafter-1",

8183

test_open_and_parse_question_notafter_1);

8184

test_add_st("/task/open_and_parse_question/notafter-1-1",

8185

test_open_and_parse_question_notafter_1_1);

8186

test_add_st("/task/open_and_parse_question/notafter-1-2",

8187

test_open_and_parse_question_notafter_1_2);

8188

test_add_st("/task/open_and_parse_question/equal-notafter",

8189

test_open_and_parse_question_equal_notafter);

8190

test_add_st("/task/open_and_parse_question/late-notafter",

8191

test_open_and_parse_question_late_notafter);

8192

test_add_st("/task/cancel_old_question/0-1-2",

8193

test_cancel_old_question_0_1_2);

8194

test_add_st("/task/cancel_old_question/0-2-1",

8195

test_cancel_old_question_0_2_1);

8196

test_add_st("/task/cancel_old_question/1-2-3",

8197

test_cancel_old_question_1_2_3);

8198

test_add_st("/task/cancel_old_question/1-3-2",

8199

test_cancel_old_question_1_3_2);

8200

test_add_st("/task/cancel_old_question/2-1-3",

8201

test_cancel_old_question_2_1_3);

8202

test_add_st("/task/cancel_old_question/2-3-1",

8203

test_cancel_old_question_2_3_1);

8204

test_add_st("/task/cancel_old_question/3-1-2",

8205

test_cancel_old_question_3_1_2);

8206

test_add_st("/task/cancel_old_question/3-2-1",

8207

test_cancel_old_question_3_2_1);

8208

test_add_st("/task/connect_question_socket/name-too-long",

8209

test_connect_question_socket_name_too_long);

8210

test_add_st("/task/connect_question_socket/connect-fail",

8211

test_connect_question_socket_connect_fail);

8212

test_add_st("/task/connect_question_socket/bad-epoll",

8213

test_connect_question_socket_bad_epoll);

8214

test_add_st("/task/connect_question_socket/usable",

8215

test_connect_question_socket_usable);

8216

test_add_st("/task/send_password_to_socket/client-not-exited",

8217

test_send_password_to_socket_client_not_exited);

8218

test_add_st("/task/send_password_to_socket/password-not-read",

8219

test_send_password_to_socket_password_not_read);

8220

test_add_st("/task/send_password_to_socket/EMSGSIZE",

8221

test_send_password_to_socket_EMSGSIZE);

8222

test_add_st("/task/send_password_to_socket/retry",

8223

test_send_password_to_socket_retry);

8224

test_add_st("/task/send_password_to_socket/bad-epoll",

8225

test_send_password_to_socket_bad_epoll);

8226

test_add_st("/task/send_password_to_socket/null-password",

8227

test_send_password_to_socket_null_password);

8228

test_add_st("/task/send_password_to_socket/empty-password",

8229

test_send_password_to_socket_empty_password);

8230

test_add_st("/task/send_password_to_socket/empty-str-password",

8231

test_send_password_to_socket_empty_str_pass);

8232

test_add_st("/task/send_password_to_socket/text-password",

8233

test_send_password_to_socket_text_password);

8234

test_add_st("/task/send_password_to_socket/binary-password",

8235

test_send_password_to_socket_binary_password);

8236

test_add_st("/task/send_password_to_socket/nuls-in-password",

8237

test_send_password_to_socket_nuls_in_password);

8238

test_add_st("/task-creators/add_existing_questions/ENOENT",

8239

test_add_existing_questions_ENOENT);

8240

test_add_st("/task-creators/add_existing_questions/no-questions",

8241

test_add_existing_questions_no_questions);

8242

test_add_st("/task-creators/add_existing_questions/one-question",

8243

test_add_existing_questions_one_question);

8244

test_add_st("/task-creators/add_existing_questions/two-questions",

8245

test_add_existing_questions_two_questions);

8246

test_add_st("/task-creators/add_existing_questions/non-questions",

8247

test_add_existing_questions_non_questions);

8248

test_add_st("/task-creators/add_existing_questions/both-types",

8249

test_add_existing_questions_both_types);

8250

8251

return g_test_run() == 0;

8252

}

8253

8254

static bool should_only_run_tests(int *argc_p, char **argv_p[]){

8255

GOptionContext *context = g_option_context_new("");

8256

8257

g_option_context_set_help_enabled(context, FALSE);

8258

g_option_context_set_ignore_unknown_options(context, TRUE);

8259

8260

gboolean should_run_tests = FALSE;

8261

GOptionEntry entries[] = {

8262

{ "test", 0, 0, G_OPTION_ARG_NONE,

8263

&should_run_tests, "Run tests", NULL },

8264

{ NULL }

8265

};

8266

g_option_context_add_main_entries(context, entries, NULL);

8267

8268

GError *error = NULL;

8269

8270

if(g_option_context_parse(context, argc_p, argv_p, &error) != TRUE){

8271

g_option_context_free(context);

8272

g_error("Failed to parse options: %s", error->message);

8273

}

8274

8275

g_option_context_free(context);

8276

return should_run_tests != FALSE;

8277

}

8278

8279

/*

8280

Local Variables:

8281

run-tests:

8282

(lambda ()

8283

(if (not (funcall run-tests-in-test-buffer default-directory))

8284

(funcall show-test-buffer-in-test-window)

8285

(funcall remove-test-window)))

8286

run-tests-in-test-buffer:

8287

(lambda (dir)

8288

(with-current-buffer (get-buffer-create "*Test*")

8289

(setq buffer-read-only nil

8290

default-directory dir)

8291

(erase-buffer)

8292

(compilation-mode))

8293

(let ((process-result

8294

(let ((inhibit-read-only t))

8295

(process-file-shell-command

8296

(funcall get-command-line) nil "*Test*"))))

8297

(and (numberp process-result)

8298

(= process-result 0))))

8299

get-command-line:

8300

(lambda ()

8301

(let*

8302

((build-directory

8303

(funcall find-build-directory (buffer-file-name)))

8304

(local-build-directory

8305

(if (fboundp 'file-local-name)

8306

(file-local-name build-directory)

8307

(or (file-remote-p build-directory 'localname)

8308

build-directory)))

8309

(command

8310

(file-relative-name (file-name-sans-extension

8311

(buffer-file-name)) build-directory))

8312

(qbdir (shell-quote-argument local-build-directory))

8313

(qcmd (shell-quote-argument command)))

8314

(format (concat "cd %s && CFLAGS=-Werror make --silent %s"

8315

" && %s --test --verbose") qbdir qcmd qcmd)))

8316

find-build-directory:

8317

(lambda (try-directory &optional base-directory)

8318

(let ((base-directory (or base-directory try-directory)))

8319

(cond ((equal try-directory "/") base-directory)

8320

((file-readable-p

8321

(concat (file-name-as-directory try-directory)

8322

"Makefile")) try-directory)

8323

((funcall find-build-directory

8324

(directory-file-name (file-name-directory

8325

try-directory))

8326

base-directory)))))

8327

show-test-buffer-in-test-window:

8328

(lambda ()

8329

(when (not (get-buffer-window-list "*Test*"))

8330

(setq next-error-last-buffer (get-buffer "*Test*"))

8331

(let* ((side (if (>= (window-width) 146) 'right 'bottom))

8332

(display-buffer-overriding-action

8333

`((display-buffer-in-side-window) (side . ,side)

8334

(window-height . fit-window-to-buffer)

8335

(window-width . fit-window-to-buffer))))

8336

(display-buffer "*Test*"))))

8337

remove-test-window:

8338

(lambda ()

8339

(let ((test-window (get-buffer-window "*Test*")))

8340

(if test-window (delete-window test-window))))

8341

eval: (add-hook 'after-save-hook run-tests 90 t)

8342

End:

8343

*/