To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to dracut-module/password-agent.c
- browse files at revision 1152
- compare with another revision
- download diff
- download tarball
- view history from revision 1152
- Committer: Teddy Hogeborn
- Date: 2019-08-05 21:14:05 UTC
- Revision ID: teddy@recompile.se-20190805211405-9m6hecekaihpttz9
Override lintian warnings about upgrading from old versions
There are some really things which are imperative that we fix in case
someone were to upgrade from a really old version. We want to keep
these fixes in the postinst maintainer scripts, even though lintian
complains about such old upgrades not being supported by Debian in
general. We prefer the code being there, for the sake of the users.
* debian/mandos-client.lintian-overrides
(maintainer-script-supports-ancient-package-version): New.
debian/mandos.lintian-overrides
(maintainer-script-supports-ancient-package-version): - '' -
There are some really things which are imperative that we fix in case
someone were to upgrade from a really old version. We want to keep
these fixes in the postinst maintainer scripts, even though lintian
complains about such old upgrades not being supported by Debian in
general. We prefer the code being there, for the sake of the users.
* debian/mandos-client.lintian-overrides
(maintainer-script-supports-ancient-package-version): New.
debian/mandos.lintian-overrides
(maintainer-script-supports-ancient-package-version): - '' -
- files removed:
- debian/po/de.po
- files modified:
- .bzrignore
added
removed
dracut-module/password-agent.c
1
/* -*- coding: utf-8; lexical-binding: t -*- */
1
/* -*- mode: c; coding: utf-8; after-save-hook: (lambda () (let* ((find-build-directory (lambda (try-directory &optional base-directory) (let ((base-directory (or base-directory try-directory))) (cond ((equal try-directory "/") base-directory) ((file-readable-p (concat (file-name-as-directory try-directory) "Makefile")) try-directory) ((funcall find-build-directory (directory-file-name (file-name-directory try-directory)) base-directory)))))) (build-directory (funcall find-build-directory (buffer-file-name))) (local-build-directory (if (fboundp 'file-local-name) (file-local-name build-directory) (or (file-remote-p build-directory 'localname) build-directory))) (command (file-relative-name (file-name-sans-extension (buffer-file-name)) build-directory))) (pcase (progn (if (get-buffer "*Test*") (kill-buffer "*Test*")) (process-file-shell-command (let ((qbdir (shell-quote-argument local-build-directory)) (qcmd (shell-quote-argument command))) (format "cd %s && CFLAGS=-Werror make --silent %s && %s --test --verbose" qbdir qcmd qcmd)) nil "*Test*")) (0 (let ((w (get-buffer-window "*Test*"))) (if w (delete-window w)))) (_ (with-current-buffer "*Test*" (compilation-mode) (cd-absolute build-directory)) (display-buffer "*Test*" '(display-buffer-in-side-window)))))); -*- */
2
2
/*
3
3
* Mandos password agent - Simple password agent to run Mandos client
4
4
*
5
* Copyright © 2019-2022 Teddy Hogeborn
6
* Copyright © 2019-2022 Björn Påhlsson
5
* Copyright © 2019 Teddy Hogeborn
6
* Copyright © 2019 Björn Påhlsson
7
7
*
8
8
* This file is part of Mandos.
9
9
*
23
23
* Contact the authors at <mandos@recompile.se>.
24
24
*/
25
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 */
26
#define _GNU_SOURCE
27
#include <inttypes.h> /* uintmax_t, PRIuMAX, PRIdMAX,
28
intmax_t, uint32_t, SCNx32,
29
SCNuMAX, SCNxMAX */
30
#include <stddef.h> /* size_t */
33
31
#include <sys/types.h> /* pid_t, uid_t, gid_t, getuid(),
34
32
getpid() */
35
33
#include <stdbool.h> /* bool, true, false */
42
40
NSIG, sigismember(), SA_ONSTACK,
43
41
SIG_DFL, SIG_IGN, SIGINT, SIGQUIT,
44
42
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
43
#include <stdlib.h> /* EXIT_SUCCESS, EXIT_FAILURE,
53
malloc(), free(), realloc(),
54
setenv(), calloc(), mkdtemp(),
55
mkostemp() */
44
malloc(), free(), strtoumax(),
45
realloc(), setenv(), calloc(),
46
mkdtemp(), mkostemp() */
56
47
#include <iso646.h> /* not, or, and, xor */
57
48
#include <error.h> /* error() */
58
49
#include <sysexits.h> /* EX_USAGE, EX_OSERR, EX_OSFILE */
59
50
#include <errno.h> /* errno, error_t, EACCES,
60
51
ENAMETOOLONG, ENOENT, ENOTDIR,
61
ENOMEM, EEXIST, ECHILD, EPERM,
52
EEXIST, ECHILD, EPERM, ENOMEM,
62
53
EAGAIN, EINTR, ENOBUFS, EADDRINUSE,
63
54
ECONNREFUSED, ECONNRESET,
64
55
ETOOMANYREFS, EMSGSIZE, EBADF,
66
57
#include <string.h> /* strdup(), memcpy(),
67
58
explicit_bzero(), memset(),
68
59
strcmp(), strlen(), strncpy(),
69
memcmp(), basename(), strerror() */
60
memcmp(), basename() */
70
61
#include <argz.h> /* argz_create(), argz_count(),
71
62
argz_extract(), argz_next(),
72
63
argz_add() */
82
73
ARGP_ERR_UNKNOWN, ARGP_KEY_ARGS,
83
74
struct argp, argp_parse(),
84
75
ARGP_NO_EXIT */
85
#include <stdint.h> /* SIZE_MAX, uint32_t */
76
#include <unistd.h> /* uid_t, gid_t, close(), pipe2(),
77
fork(), _exit(), dup2(),
78
STDOUT_FILENO, setresgid(),
79
setresuid(), execv(), ssize_t,
80
read(), dup3(), getuid(), dup(),
81
STDERR_FILENO, pause(), write(),
82
rmdir(), unlink(), getpid() */
86
83
#include <sys/mman.h> /* munlock(), mlock() */
87
84
#include <fcntl.h> /* O_CLOEXEC, O_NONBLOCK, fcntl(),
88
85
F_GETFD, F_GETFL, FD_CLOEXEC,
98
95
IN_EXCL_UNLINK, IN_ONLYDIR,
99
96
struct inotify_event */
100
97
#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() */
98
#include <stdio.h> /* asprintf(), FILE, fopen(),
99
getline(), sscanf(), feof(),
100
ferror(), fclose(), stderr,
101
rename(), fdopen(), fprintf(),
102
fscanf() */
105
103
#include <glib.h> /* GKeyFile, g_key_file_free(), g_key_file_new(),
106
104
GError, g_key_file_load_from_file(),
107
105
G_KEY_FILE_NONE, TRUE, G_FILE_ERROR_NOENT,
112
110
g_assert_null(), g_assert_false(),
113
111
g_assert_cmpint(), g_assert_cmpuint(),
114
112
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(),
113
g_test_init(), g_test_add(), g_test_run(),
114
GOptionContext, g_option_context_new(),
118
115
g_option_context_set_help_enabled(), FALSE,
119
116
g_option_context_set_ignore_unknown_options(),
120
117
gboolean, GOptionEntry, G_OPTION_ARG_NONE,
151
148
mono_microsecs next_run;
152
149
} __attribute__((designated_init)) task_queue;
153
150
154
/* "task_func" - A function type for task functions
151
/* "func_type" - A function type for task functions
155
152
156
153
I.e. functions for the code which runs when a task is run, all have
157
154
this type */
654
651
655
652
__attribute__((nonnull, warn_unused_result))
656
653
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
654
const size_t needed_size = sizeof(task_context)*(queue->length + 1);
665
655
if(needed_size > (queue->allocated)){
666
656
task_context *const new_tasks = realloc(queue->tasks,
871
861
}
872
862
close(pipefds[1]);
873
863
874
if(pid == -1){
875
error(0, errno, "Failed to fork()");
876
close(pipefds[0]);
877
return false;
878
}
879
880
864
if(not add_to_queue(queue, (task_context){
881
865
.func=wait_for_mandos_client_exit,
882
866
.pid=pid,
1098
1082
} ievent_buffer;
1099
1083
struct inotify_event *const ievent = &ievent_buffer.event;
1100
1084
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
1085
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
1086
if(read_length == 0){ /* EOF */
1111
1087
error(0, 0, "Got EOF from inotify fd for directory %s", filename);
1112
1088
*quit_now = true;
1204
1180
bool *const password_is_read = task.password_is_read;
1205
1181
1206
1182
/* 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 */
1183
question file. See <https://www.freedesktop.org/wiki/Software
1184
/systemd/PasswordAgents/> for specification of contents */
1209
1185
__attribute__((nonnull))
1210
1186
void cleanup_g_key_file(GKeyFile **key_file){
1211
1187
if(*key_file != NULL){
1501
1477
not. You may but don't have to include a final NUL byte in
1502
1478
your message.
1503
1479
1504
— <https://systemd.io/PASSWORD_AGENTS/> (Tue, 15 Sep 2020
1505
14:24:20 GMT)
1480
— <https://www.freedesktop.org/wiki/Software/systemd/
1481
PasswordAgents/> (Wed 08 Oct 2014 02:14:28 AM UTC)
1506
1482
*/
1507
1483
send_buffer[0] = '+'; /* Prefix with "+" */
1508
1484
/* Always add an extra NUL */
1513
1489
errno = 0;
1514
1490
ssize_t ssret = send(fd, send_buffer, send_buffer_length,
1515
1491
MSG_NOSIGNAL);
1516
const error_t saved_errno = (ssret < 0) ? errno : 0;
1492
const error_t saved_errno = errno;
1517
1493
#if defined(__GLIBC_PREREQ) and __GLIBC_PREREQ(2, 25)
1518
1494
explicit_bzero(send_buffer, send_buffer_length);
1519
1495
#else
1537
1513
/* Retry, below */
1538
1514
break;
1539
1515
case EMSGSIZE:
1540
error(0, saved_errno, "Password of size %" PRIuMAX
1541
" is too big", (uintmax_t)password->length);
1516
error(0, 0, "Password of size %" PRIuMAX " is too big",
1517
(uintmax_t)password->length);
1542
1518
#if __GNUC__ < 7
1543
1519
/* FALLTHROUGH */
1544
1520
#else
1546
1522
#endif
1547
1523
case 0:
1548
1524
if(ssret >= 0 and ssret < (ssize_t)send_buffer_length){
1549
error(0, 0, "Password only partially sent to socket %s: %"
1550
PRIuMAX " out of %" PRIuMAX " bytes sent", filename,
1551
(uintmax_t)ssret, (uintmax_t)send_buffer_length);
1525
error(0, 0, "Password only partially sent to socket");
1552
1526
}
1553
1527
#if __GNUC__ < 7
1554
1528
/* FALLTHROUGH */
1910
1884
g_assert_true(queue->tasks[0].func == dummy_func);
1911
1885
}
1912
1886
1913
static void test_add_to_queue_overflow(__attribute__((unused))
1914
test_fixture *fixture,
1915
__attribute__((unused))
1916
gconstpointer user_data){
1917
__attribute__((cleanup(cleanup_queue)))
1918
task_queue *queue = create_queue();
1919
g_assert_nonnull(queue);
1920
g_assert_true(queue->length == 0);
1921
queue->length = SIZE_MAX / sizeof(task_context); /* fake max size */
1922
1923
FILE *real_stderr = stderr;
1924
FILE *devnull = fopen("/dev/null", "we");
1925
g_assert_nonnull(devnull);
1926
stderr = devnull;
1927
const bool ret = add_to_queue(queue,
1928
(task_context){ .func=dummy_func });
1929
g_assert_true(errno == ENOMEM);
1930
g_assert_false(ret);
1931
stderr = real_stderr;
1932
g_assert_cmpint(fclose(devnull), ==, 0);
1933
queue->length = 0; /* Restore real size */
1934
}
1935
1936
1887
static void dummy_func(__attribute__((unused))
1937
1888
const task_context task,
1938
1889
__attribute__((unused))
2209
2160
}
2210
2161
exit(EXIT_SUCCESS);
2211
2162
}
2212
if(pid == -1){
2213
error(EXIT_FAILURE, errno, "Failed to fork()");
2214
}
2215
2216
2163
int status;
2217
2164
waitpid(pid, &status, 0);
2218
2165
if(WIFEXITED(status) and (WEXITSTATUS(status) == EXIT_SUCCESS)){
2661
2608
bool password_is_read = false;
2662
2609
const char helper_directory[] = "/nonexistent";
2663
2610
const char *const argv[] = { "/bin/sh", "-c",
2664
"printf %s \"${MANDOSPLUGINHELPERDIR}\"", NULL };
2611
"echo -n ${MANDOSPLUGINHELPERDIR}", NULL };
2665
2612
2666
2613
const bool success = start_mandos_client(queue, epoll_fd,
2667
2614
&mandos_client_exited,
4190
4137
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4191
4138
const size_t ievent_size = (sizeof(struct inotify_event)
4192
4139
+ sizeof(dummy_file_name));
4193
#if defined(__GNUC__) and __GNUC__ >= 11
4194
#pragma GCC diagnostic push
4195
/* ievent is pointing into a struct which is of sufficient size */
4196
#pragma GCC diagnostic ignored "-Wstringop-overread"
4197
#endif
4198
4140
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4199
4141
==, ievent_size);
4200
#if defined(__GNUC__) and __GNUC__ >= 11
4201
#pragma GCC diagnostic pop
4202
#endif
4203
4142
g_assert_cmpint(close(pipefds[1]), ==, 0);
4204
4143
4205
4144
bool quit_now = false;
4293
4232
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4294
4233
const size_t ievent_size = (sizeof(struct inotify_event)
4295
4234
+ sizeof(dummy_file_name));
4296
#if defined(__GNUC__) and __GNUC__ >= 11
4297
#pragma GCC diagnostic push
4298
/* ievent is pointing into a struct which is of sufficient size */
4299
#pragma GCC diagnostic ignored "-Wstringop-overread"
4300
#endif
4301
4235
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4302
4236
==, ievent_size);
4303
#if defined(__GNUC__) and __GNUC__ >= 11
4304
#pragma GCC diagnostic pop
4305
#endif
4306
4237
g_assert_cmpint(close(pipefds[1]), ==, 0);
4307
4238
4308
4239
bool quit_now = false;
4398
4329
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4399
4330
const size_t ievent_size = (sizeof(struct inotify_event)
4400
4331
+ sizeof(dummy_file_name));
4401
#if defined(__GNUC__) and __GNUC__ >= 11
4402
#pragma GCC diagnostic push
4403
/* ievent is pointing into a struct which is of sufficient size */
4404
#pragma GCC diagnostic ignored "-Wstringop-overread"
4405
#endif
4406
4332
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4407
4333
==, ievent_size);
4408
#if defined(__GNUC__) and __GNUC__ >= 11
4409
#pragma GCC diagnostic pop
4410
#endif
4411
4334
g_assert_cmpint(close(pipefds[1]), ==, 0);
4412
4335
4413
4336
bool quit_now = false;
4491
4414
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4492
4415
const size_t ievent_size = (sizeof(struct inotify_event)
4493
4416
+ sizeof(dummy_file_name));
4494
#if defined(__GNUC__) and __GNUC__ >= 11
4495
#pragma GCC diagnostic push
4496
/* ievent is pointing into a struct which is of sufficient size */
4497
#pragma GCC diagnostic ignored "-Wstringop-overread"
4498
#endif
4499
4417
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4500
4418
==, ievent_size);
4501
#if defined(__GNUC__) and __GNUC__ >= 11
4502
#pragma GCC diagnostic pop
4503
#endif
4504
4419
g_assert_cmpint(close(pipefds[1]), ==, 0);
4505
4420
4506
4421
bool quit_now = false;
4583
4498
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4584
4499
const size_t ievent_size = (sizeof(struct inotify_event)
4585
4500
+ sizeof(dummy_file_name));
4586
#if defined(__GNUC__) and __GNUC__ >= 11
4587
#pragma GCC diagnostic push
4588
/* ievent is pointing into a struct which is of sufficient size */
4589
#pragma GCC diagnostic ignored "-Wstringop-overread"
4590
#endif
4591
4501
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4592
4502
==, ievent_size);
4593
#if defined(__GNUC__) and __GNUC__ >= 11
4594
#pragma GCC diagnostic pop
4595
#endif
4596
4503
g_assert_cmpint(close(pipefds[1]), ==, 0);
4597
4504
4598
4505
bool quit_now = false;
4667
4574
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4668
4575
const size_t ievent_size = (sizeof(struct inotify_event)
4669
4576
+ sizeof(dummy_file_name));
4670
#if defined(__GNUC__) and __GNUC__ >= 11
4671
#pragma GCC diagnostic push
4672
/* ievent is pointing into a struct which is of sufficient size */
4673
#pragma GCC diagnostic ignored "-Wstringop-overread"
4674
#endif
4675
4577
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4676
4578
==, ievent_size);
4677
#if defined(__GNUC__) and __GNUC__ >= 11
4678
#pragma GCC diagnostic pop
4679
#endif
4680
4579
g_assert_cmpint(close(pipefds[1]), ==, 0);
4681
4580
4682
4581
bool quit_now = false;
4754
4653
memcpy(ievent->name, dummy_file_name, sizeof(dummy_file_name));
4755
4654
const size_t ievent_size = (sizeof(struct inotify_event)
4756
4655
+ sizeof(dummy_file_name));
4757
#if defined(__GNUC__) and __GNUC__ >= 11
4758
#pragma GCC diagnostic push
4759
/* ievent is pointing into a struct which is of sufficient size */
4760
#pragma GCC diagnostic ignored "-Wstringop-overread"
4761
#endif
4762
4656
g_assert_cmpint(write(pipefds[1], (char *)ievent, ievent_size),
4763
4657
==, ievent_size);
4764
#if defined(__GNUC__) and __GNUC__ >= 11
4765
#pragma GCC diagnostic pop
4766
#endif
4767
4658
g_assert_cmpint(close(pipefds[1]), ==, 0);
4768
4659
4769
4660
bool quit_now = false;
5876
5767
char write_data[PIPE_BUF];
5877
5768
{
5878
5769
/* Construct test password buffer */
5879
/* Start with + since that is what the real protocol uses */
5770
/* Start with + since that is what the real procotol uses */
5880
5771
write_data[0] = '+';
5881
5772
/* Set a special character at string end just to mark the end */
5882
5773
write_data[sizeof(write_data)-2] = 'y';
6034
5925
char *const filename = strdup("/nonexistent/socket");
6035
5926
__attribute__((cleanup(string_set_clear)))
6036
5927
string_set cancelled_filenames = {};
6037
int socketfds[2];
6038
6039
/* Find a message size which triggers EMSGSIZE */
6040
__attribute__((cleanup(cleanup_string)))
6041
char *message_buffer = NULL;
6042
size_t message_size = PIPE_BUF + 1;
6043
for(ssize_t ssret = 0; ssret >= 0; message_size += 1024){
6044
if(message_size >= 1024*1024*1024){ /* 1 GiB */
6045
g_test_skip("Skipping EMSGSIZE test: Will not try 1GiB");
6046
return;
6047
}
6048
message_buffer = realloc(message_buffer, message_size);
6049
if(message_buffer == NULL){
6050
g_test_skip("Skipping EMSGSIZE test");
6051
g_test_message("Failed to malloc() %" PRIuMAX " bytes",
6052
(uintmax_t)message_size);
6053
return;
6054
}
6055
/* Fill buffer with 'x' */
6056
memset(message_buffer, 'x', message_size);
6057
/* Create a new socketpair for each message size to avoid having
6058
to empty the pipe by reading the message to a separate buffer
6059
*/
6060
g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM
6061
| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,
6062
socketfds), ==, 0);
6063
ssret = send(socketfds[1], message_buffer, message_size,
6064
MSG_NOSIGNAL);
6065
error_t saved_errno = errno;
6066
g_assert_cmpint(close(socketfds[0]), ==, 0);
6067
g_assert_cmpint(close(socketfds[1]), ==, 0);
6068
6069
if(ssret < 0){
6070
if(saved_errno != EMSGSIZE) {
6071
g_test_skip("Skipping EMSGSIZE test");
6072
g_test_message("Error on send(%" PRIuMAX " bytes): %s",
6073
(uintmax_t)message_size,
6074
strerror(saved_errno));
6075
return;
6076
}
6077
break;
6078
} else if(ssret != (ssize_t)message_size){
6079
g_test_skip("Skipping EMSGSIZE test");
6080
g_test_message("Partial send(): %" PRIuMAX " of %" PRIdMAX
6081
" bytes", (uintmax_t)ssret,
6082
(intmax_t)message_size);
6083
return;
6084
}
6085
}
6086
g_test_message("EMSGSIZE triggered by %" PRIdMAX " bytes",
6087
(intmax_t)message_size);
6088
6089
buffer password = {
6090
.data=message_buffer,
6091
.length=message_size - 2, /* Compensate for added '+' and NUL */
6092
.allocated=message_size,
5928
const size_t oversized = 1024*1024; /* Limit seems to be 212960 */
5929
__attribute__((cleanup(cleanup_buffer)))
5930
buffer password = {
5931
.data=malloc(oversized),
5932
.length=oversized,
5933
.allocated=oversized,
6093
5934
};
5935
g_assert_nonnull(password.data);
6094
5936
if(mlock(password.data, password.allocated) != 0){
6095
5937
g_assert_true(errno == EPERM or errno == ENOMEM);
6096
5938
}
5939
/* Construct test password buffer */
5940
/* Start with + since that is what the real procotol uses */
5941
password.data[0] = '+';
5942
/* Set a special character at string end just to mark the end */
5943
password.data[oversized-3] = 'y';
5944
/* Set NUL at buffer end, as suggested by the protocol */
5945
password.data[oversized-2] = '\0';
5946
/* Fill rest of password with 'x' */
5947
memset(password.data+1, 'x', oversized-3);
6097
5948
6098
5949
__attribute__((cleanup(cleanup_queue)))
6099
5950
task_queue *queue = create_queue();
6100
5951
g_assert_nonnull(queue);
5952
int socketfds[2];
6101
5953
g_assert_cmpint(socketpair(PF_LOCAL, SOCK_DGRAM
6102
5954
| SOCK_NONBLOCK | SOCK_CLOEXEC, 0,
6103
5955
socketfds), ==, 0);
8010
7862
test_add("/parse_arguments/mixed", test_parse_arguments_mixed);
8011
7863
test_add("/queue/create", test_create_queue);
8012
7864
test_add("/queue/add", test_add_to_queue);
8013
test_add("/queue/add/overflow", test_add_to_queue_overflow);
8014
7865
test_add("/queue/has_question/empty",
8015
7866
test_queue_has_question_empty);
8016
7867
test_add("/queue/has_question/false",
8241
8092
g_option_context_set_help_enabled(context, FALSE);
8242
8093
g_option_context_set_ignore_unknown_options(context, TRUE);
8243
8094
8244
gboolean should_run_tests = FALSE;
8095
gboolean run_tests = FALSE;
8245
8096
GOptionEntry entries[] = {
8246
8097
{ "test", 0, 0, G_OPTION_ARG_NONE,
8247
&should_run_tests, "Run tests", NULL },
8098
&run_tests, "Run tests", NULL },
8248
8099
{ NULL }
8249
8100
};
8250
8101
g_option_context_add_main_entries(context, entries, NULL);
8257
8108
}
8258
8109
8259
8110
g_option_context_free(context);
8260
return should_run_tests != FALSE;
8111
return run_tests != FALSE;
8261
8112
}
8262
8263
/*
8264
Local Variables:
8265
run-tests:
8266
(lambda ()
8267
(if (not (funcall run-tests-in-test-buffer default-directory))
8268
(funcall show-test-buffer-in-test-window)
8269
(funcall remove-test-window)))
8270
run-tests-in-test-buffer:
8271
(lambda (dir)
8272
(with-current-buffer (get-buffer-create "*Test*")
8273
(setq buffer-read-only nil
8274
default-directory dir)
8275
(erase-buffer)
8276
(compilation-mode))
8277
(let ((process-result
8278
(let ((inhibit-read-only t))
8279
(process-file-shell-command
8280
(funcall get-command-line) nil "*Test*"))))
8281
(and (numberp process-result)
8282
(= process-result 0))))
8283
get-command-line:
8284
(lambda ()
8285
(let*
8286
((build-directory
8287
(funcall find-build-directory (buffer-file-name)))
8288
(local-build-directory
8289
(if (fboundp 'file-local-name)
8290
(file-local-name build-directory)
8291
(or (file-remote-p build-directory 'localname)
8292
build-directory)))
8293
(command
8294
(file-relative-name (file-name-sans-extension
8295
(buffer-file-name)) build-directory))
8296
(qbdir (shell-quote-argument local-build-directory))
8297
(qcmd (shell-quote-argument command)))
8298
(format (concat "cd %s && CFLAGS=-Werror make --silent %s"
8299
" && %s --test --verbose") qbdir qcmd qcmd)))
8300
find-build-directory:
8301
(lambda (try-directory &optional base-directory)
8302
(let ((base-directory (or base-directory try-directory)))
8303
(cond ((equal try-directory "/") base-directory)
8304
((file-readable-p
8305
(concat (file-name-as-directory try-directory)
8306
"Makefile")) try-directory)
8307
((funcall find-build-directory
8308
(directory-file-name (file-name-directory
8309
try-directory))
8310
base-directory)))))
8311
show-test-buffer-in-test-window:
8312
(lambda ()
8313
(when (not (get-buffer-window-list "*Test*"))
8314
(setq next-error-last-buffer (get-buffer "*Test*"))
8315
(let* ((side (if (>= (window-width) 146) 'right 'bottom))
8316
(display-buffer-overriding-action
8317
`((display-buffer-in-side-window) (side . ,side)
8318
(window-height . fit-window-to-buffer)
8319
(window-width . fit-window-to-buffer))))
8320
(display-buffer "*Test*"))))
8321
remove-test-window:
8322
(lambda ()
8323
(let ((test-window (get-buffer-window "*Test*")))
8324
(if test-window (delete-window test-window))))
8325
eval: (add-hook 'after-save-hook run-tests 90 t)
8326
End:
8327
*/
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0