1 /*
2 * ProFTPD - FTP server testsuite
3 * Copyright (c) 2016-2017 The ProFTPD Project team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA.
18 *
19 * As a special exemption, The ProFTPD Project team and other respective
20 * copyright holders give permission to link this program with OpenSSL, and
21 * distribute the resulting executable, without including the source code for
22 * OpenSSL in the source distribution.
23 */
24
25 /* Error API tests */
26
27 #include "tests.h"
28 #include "error.h"
29
30 static pool *p = NULL;
31
set_up(void)32 static void set_up(void) {
33 if (p == NULL) {
34 p = permanent_pool = make_sub_pool(NULL);
35 }
36
37 if (getenv("TEST_VERBOSE") != NULL) {
38 pr_trace_set_levels("error", 1, 20);
39 }
40 }
41
tear_down(void)42 static void tear_down(void) {
43 if (getenv("TEST_VERBOSE") != NULL) {
44 pr_trace_set_levels("error", 0, 0);
45 }
46
47 if (p) {
48 destroy_pool(p);
49 p = permanent_pool = NULL;
50 }
51 }
52
get_errnum(pool * err_pool,int xerrno)53 static const char *get_errnum(pool *err_pool, int xerrno) {
54 char errnum[32];
55 memset(errnum, '\0', sizeof(errnum));
56 snprintf(errnum, sizeof(errnum)-1, "%d", xerrno);
57 return pstrdup(err_pool, errnum);
58 }
59
get_uid(pool * err_pool)60 static const char *get_uid(pool *err_pool) {
61 char uid[32];
62 memset(uid, '\0', sizeof(uid));
63 snprintf(uid, sizeof(uid)-1, "%lu", (unsigned long) geteuid());
64 return pstrdup(err_pool, uid);
65 }
66
get_gid(pool * err_pool)67 static const char *get_gid(pool *err_pool) {
68 char gid[32];
69 memset(gid, '\0', sizeof(gid));
70 snprintf(gid, sizeof(gid)-1, "%lu", (unsigned long) getegid());
71 return pstrdup(err_pool, gid);
72 }
73
START_TEST(error_create_test)74 START_TEST (error_create_test) {
75 pr_error_t *err;
76
77 err = pr_error_create(NULL, 0);
78 fail_unless(err == NULL, "Failed handle null arguments");
79 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
80 strerror(errno), errno);
81
82 err = pr_error_create(p, -1);
83 fail_unless(err == NULL, "Failed handle negative errno");
84 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
85 strerror(errno), errno);
86
87 err = pr_error_create(p, 0);
88 fail_unless(err != NULL, "Failed allocate error: %s", strerror(errno));
89 pr_error_destroy(err);
90 }
91 END_TEST
92
START_TEST(error_destroy_test)93 START_TEST (error_destroy_test) {
94 pr_error_t *err;
95 int xerrno = 77;
96
97 err = pr_error_create(p, 0);
98 fail_unless(err != NULL, "Failed allocate error: %s", strerror(errno));
99
100 /* Make sure that pr_error_destroy() preserves the existing errno value. */
101 errno = xerrno;
102 pr_error_destroy(NULL);
103 pr_error_destroy(err);
104
105 fail_unless(errno == xerrno, "Expected errno %d, got %d", xerrno, errno);
106 }
107 END_TEST
108
START_TEST(error_get_who_test)109 START_TEST (error_get_who_test) {
110 int res, xerrno;
111 uid_t err_uid = -1, uid;
112 gid_t err_gid = -1, gid;
113 pr_error_t *err = NULL;
114
115 uid = geteuid();
116 gid = getegid();
117
118 res = pr_error_get_who(NULL, NULL, NULL);
119 fail_unless(res < 0, "Failed to handle null error");
120 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
121 strerror(errno), errno);
122
123 xerrno = EACCES;
124 err = pr_error_create(p, xerrno);
125 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
126
127 res = pr_error_get_who(err, NULL, NULL);
128 fail_unless(res < 0, "Failed to handle null uid_t pointer");
129 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
130 strerror(errno), errno);
131
132 res = pr_error_get_who(err, &err_uid, NULL);
133 fail_unless(res == 0, "Failed to get error identity: %s", strerror(errno));
134 fail_unless(err_uid == uid, "Expected %lu, got %lu", (unsigned long) uid,
135 (unsigned long) err_uid);
136
137 err_uid = -1;
138
139 res = pr_error_get_who(err, NULL, &err_gid);
140 fail_unless(res == 0, "Failed to get error identity: %s", strerror(errno));
141 fail_unless(err_gid == gid, "Expected %lu, got %lu", (unsigned long) gid,
142 (unsigned long) err_gid);
143
144 err_gid = -1;
145
146 res = pr_error_get_who(err, &err_uid, &err_gid);
147 fail_unless(res == 0, "Failed to get error identity: %s", strerror(errno));
148 fail_unless(err_uid == uid, "Expected %lu, got %lu", (unsigned long) uid,
149 (unsigned long) err_uid);
150 fail_unless(err_gid == gid, "Expected %lu, got %lu", (unsigned long) gid,
151 (unsigned long) err_gid);
152
153 pr_error_destroy(err);
154 }
155 END_TEST
156
START_TEST(error_set_why_test)157 START_TEST (error_set_why_test) {
158 int res;
159 pr_error_t *err;
160
161 mark_point();
162 res = pr_error_set_why(NULL, NULL);
163 fail_unless(res < 0, "Failed to handle null arguments");
164 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
165 strerror(errno), errno);
166
167 err = pr_error_create(p, 1);
168 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
169
170 res = pr_error_set_why(err, NULL);
171 fail_unless(res < 0, "Failed to handle null why");
172 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
173 strerror(errno), errno);
174
175 res = pr_error_set_why(err, "because I wanted to");
176 fail_unless(res == 0, "Failed to set why: %s", strerror(errno));
177
178 pr_error_destroy(err);
179 }
180 END_TEST
181
START_TEST(error_set_where_test)182 START_TEST (error_set_where_test) {
183 int res;
184 pr_error_t *err;
185
186 mark_point();
187 res = pr_error_set_where(NULL, NULL, NULL, 0);
188 fail_unless(res < 0, "Failed to handle null arguments");
189 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
190 strerror(errno), errno);
191
192 err = pr_error_create(p, 1);
193 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
194
195 res = pr_error_set_where(err, NULL, NULL, 0);
196 fail_unless(res == 0, "Failed to set where: %s", strerror(errno));
197
198 pr_error_destroy(err);
199 }
200 END_TEST
201
START_TEST(error_set_what_test)202 START_TEST (error_set_what_test) {
203 int res;
204 pr_error_t *err;
205
206 mark_point();
207 res = pr_error_set_what(NULL, NULL);
208 fail_unless(res < 0, "Failed to handle null arguments");
209 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
210 strerror(errno), errno);
211
212 err = pr_error_create(p, 1);
213 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
214
215 res = pr_error_set_what(err, NULL);
216 fail_unless(res < 0, "Failed to handle null what");
217 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
218 strerror(errno), errno);
219
220 res = pr_error_set_what(err, "testing");
221 fail_unless(res == 0, "Failed to set what: %s", strerror(errno));
222
223 pr_error_destroy(err);
224 }
225 END_TEST
226
START_TEST(error_explainer_test)227 START_TEST (error_explainer_test) {
228 module m;
229 const char *name;
230 pr_error_explainer_t *explainer;
231 int res;
232
233 /* Unregister with none registered -- ENOENT */
234
235 mark_point();
236 res = pr_error_unregister_explainer(NULL, NULL, NULL);
237 fail_unless(res < 0, "Failed to handle null arguments");
238 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
239 strerror(errno), errno);
240
241 name = "testing";
242 res = pr_error_unregister_explainer(p, NULL, name);
243 fail_unless(res < 0, "Failed to handle no registered explainers");
244 fail_unless(errno == ENOENT, "Expected ENOENT (%d), got %s (%d)", ENOENT,
245 strerror(errno), errno);
246
247 memset(&m, 0, sizeof(m));
248 m.name = "error";
249
250 res = pr_error_unregister_explainer(p, &m, NULL);
251 fail_unless(res < 0, "Failed to handle no registered explainers");
252 fail_unless(errno == ENOENT, "Expected ENOENT (%d), got %s (%d)", ENOENT,
253 strerror(errno), errno);
254
255 res = pr_error_unregister_explainer(p, &m, name);
256 fail_unless(res < 0, "Failed to handle no registered explainers");
257 fail_unless(errno == ENOENT, "Expected ENOENT (%d), got %s (%d)", ENOENT,
258 strerror(errno), errno);
259
260 res = pr_error_use_explainer(p, NULL, NULL);
261 fail_unless(res < 0, "Failed to handle no registered explainers");
262 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
263 strerror(errno), errno);
264
265 explainer = pr_error_register_explainer(NULL, NULL, NULL);
266 fail_unless(explainer == NULL, "Failed to handle null pool argument");
267 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
268 strerror(errno), errno);
269
270 explainer = pr_error_register_explainer(p, NULL, NULL);
271 fail_unless(explainer == NULL, "Failed to handle null name argument");
272 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
273 strerror(errno), errno);
274
275 explainer = pr_error_register_explainer(p, &m, name);
276 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
277 name, strerror(errno));
278
279 explainer = pr_error_register_explainer(p, &m, name);
280 fail_unless(explainer == NULL, "Failed to handle duplicate registration");
281 fail_unless(errno == EEXIST, "Expected EEXIST (%d), got %s (%d)", EEXIST,
282 strerror(errno), errno);
283
284 res = pr_error_unregister_explainer(p, &m, name);
285 fail_unless(res == 0, "Failed to handle unregister '%s' explainer: %s",
286 name, strerror(errno));
287
288 res = pr_error_unregister_explainer(p, &m, name);
289 fail_unless(res < 0, "Failed to handle no registered explainers");
290 fail_unless(errno == ENOENT, "Expected ENOENT (%d), got %s (%d)", ENOENT,
291 strerror(errno), errno);
292
293 explainer = pr_error_register_explainer(p, &m, name);
294 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
295 name, strerror(errno));
296
297 res = pr_error_unregister_explainer(p, NULL, name);
298 fail_unless(res == 0, "Failed to handle unregister '%s' explainer: %s",
299 name, strerror(errno));
300
301 explainer = pr_error_register_explainer(p, &m, name);
302 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
303 name, strerror(errno));
304
305 res = pr_error_unregister_explainer(p, &m, NULL);
306 fail_unless(res == 0, "Failed to handle unregister module explainer: %s",
307 strerror(errno));
308
309 /* Selecting the explainer to use. */
310
311 explainer = pr_error_register_explainer(p, &m, name);
312 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
313 name, strerror(errno));
314
315 res = pr_error_use_explainer(p, &m, NULL);
316 fail_unless(res < 0, "Failed to handle null name argument");
317 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
318 strerror(errno), errno);
319
320 res = pr_error_use_explainer(p, &m, "foobar");
321 fail_unless(res < 0, "Used 'foobar' explainer unexpectedly");
322 fail_unless(errno == ENOENT, "Expected ENOENT (%d), got %s (%d)", ENOENT,
323 strerror(errno), errno);
324
325 res = pr_error_use_explainer(p, &m, name);
326 fail_unless(res == 0, "Failed to use '%s' explainer: %s", name,
327 strerror(errno));
328
329 /* Use already-selected explainers */
330 res = pr_error_use_explainer(p, &m, name);
331 fail_unless(res == 0, "Failed to use '%s' explainer: %s", name,
332 strerror(errno));
333
334 res = pr_error_unregister_explainer(p, &m, name);
335 fail_unless(res == 0, "Failed to handle unregister module explainer: %s",
336 strerror(errno));
337 }
338 END_TEST
339
START_TEST(error_strerror_minimal_test)340 START_TEST (error_strerror_minimal_test) {
341 int format = PR_ERROR_FORMAT_USE_MINIMAL, xerrno;
342 pr_error_t *err;
343 const char *res, *expected, *what;
344
345 pr_error_use_formats(PR_ERROR_FORMAT_DEFAULT);
346
347 xerrno = errno = ENOENT;
348 expected = strerror(xerrno);
349 res = pr_error_strerror(NULL, format);
350 fail_unless(res != NULL, "Failed to handle null error: %s", strerror(errno));
351 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
352 res);
353
354 err = pr_error_create(p, xerrno);
355 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
356
357 res = pr_error_strerror(err, -1);
358 fail_unless(res != NULL, "Failed to handle invalid format: %s",
359 strerror(errno));
360 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
361 res);
362
363 expected = pstrcat(p, "No such file or directory [ENOENT (",
364 get_errnum(p, xerrno), ")]", NULL);
365 res = pr_error_strerror(err, format);
366 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
367 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
368 res);
369
370 pr_error_use_formats(format);
371 expected = pstrcat(p, "No such file or directory [ENOENT (",
372 get_errnum(p, xerrno), ")]", NULL);
373 res = pr_error_strerror(err, 0);
374 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
375 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
376 res);
377
378 pr_error_destroy(err);
379 xerrno = 0;
380
381 err = pr_error_create(p, xerrno);
382 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
383
384 expected = "Success [EOK (0)]";
385 res = pr_error_strerror(err, format);
386 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
387 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
388 res);
389
390 pr_error_destroy(err);
391
392 /* We want to test what happens when we use an invalid errno value. */
393 xerrno = INT_MAX - 786;
394
395 err = pr_error_create(p, xerrno);
396 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
397
398 expected = pstrcat(p, strerror(xerrno), " [<unknown/unsupported error> (",
399 get_errnum(p, xerrno), ")]", NULL);
400 res = pr_error_strerror(err, format);
401 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
402 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
403 res);
404
405 pr_error_destroy(err);
406 xerrno = ENOSYS;
407
408 err = pr_error_create(p, xerrno);
409 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
410
411 what = "test";
412 pr_error_set_what(err, what);
413
414 expected = pstrcat(p, what, " failed with \"", strerror(xerrno), " [ENOSYS (",
415 get_errnum(p, xerrno), ")]\"", NULL);
416 res = pr_error_strerror(err, format);
417 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
418 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
419 res);
420
421 pr_error_destroy(err);
422
423 err = pr_error_create(p, xerrno);
424 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
425
426 what = "test2";
427 pr_error_set_what(err, what);
428
429 expected = pstrcat(p, what, " failed with \"", strerror(xerrno),
430 " [ENOSYS (", get_errnum(p, xerrno), ")]\"", NULL);
431 res = pr_error_strerror(err, format);
432 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
433 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
434 res);
435
436 pr_error_destroy(err);
437 pr_error_use_formats(PR_ERROR_FORMAT_DEFAULT);
438 }
439 END_TEST
440
START_TEST(error_strerror_terse_test)441 START_TEST (error_strerror_terse_test) {
442 int format = PR_ERROR_FORMAT_USE_TERSE, xerrno;
443 pr_error_t *err;
444 const char *res, *expected, *what;
445
446 pr_error_use_formats(PR_ERROR_FORMAT_USE_TERSE);
447
448 xerrno = errno = ENOENT;
449 expected = strerror(xerrno);
450 res = pr_error_strerror(NULL, format);
451 fail_unless(res != NULL, "Failed to handle null error: %s", strerror(errno));
452 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
453 res);
454
455 err = pr_error_create(p, xerrno);
456 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
457
458 res = pr_error_strerror(err, -1);
459 fail_unless(res != NULL, "Failed to handle invalid format: %s",
460 strerror(errno));
461 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
462 res);
463
464 expected = pstrdup(p, "No such file or directory");
465 res = pr_error_strerror(err, format);
466 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
467 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
468 res);
469
470 pr_error_destroy(err);
471
472 err = pr_error_create(p, xerrno);
473 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
474
475 what = "test2";
476 pr_error_set_what(err, what);
477
478 expected = pstrcat(p, what, " failed with \"", strerror(xerrno),
479 " [ENOENT (", get_errnum(p, xerrno), ")]\"", NULL);
480 res = pr_error_strerror(err, format);
481 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
482 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
483 res);
484
485 pr_error_destroy(err);
486 pr_error_use_formats(PR_ERROR_FORMAT_DEFAULT);
487 }
488 END_TEST
489
START_TEST(error_strerror_detailed_test)490 START_TEST (error_strerror_detailed_test) {
491 int format = PR_ERROR_FORMAT_USE_DETAILED, xerrno, res2, error_details;
492 pr_error_t *err;
493 const char *res, *expected, *what, *why;
494
495 pr_error_use_formats(PR_ERROR_FORMAT_DEFAULT);
496
497 xerrno = errno = ENOENT;
498 expected = strerror(xerrno);
499 res = pr_error_strerror(NULL, format);
500 fail_unless(res != NULL, "Failed to handle null error: %s", strerror(errno));
501 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
502 res);
503
504 err = pr_error_create(p, xerrno);
505 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
506
507 res = pr_error_strerror(err, -1);
508 fail_unless(res != NULL, "Failed to handle invalid format: %s",
509 strerror(errno));
510 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
511 res);
512
513 /* no what */
514 expected = pstrcat(p, "in API, UID ", get_uid(p), ", GID ", get_gid(p),
515 " failed with \"", strerror(xerrno),
516 " [ENOENT (", get_errnum(p, xerrno), ")]\"", NULL);
517 res = pr_error_strerror(err, format);
518 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
519 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
520 res);
521
522 /* Exercise the "lineno = 0" code path. */
523 res2 = pr_error_set_where(err, NULL, __FILE__, 0);
524 fail_unless(res2 == 0, "Failed to set error where: %s", strerror(errno));
525
526 expected = pstrcat(p, "in API [api/error.c], UID ", get_uid(p),
527 ", GID ", get_gid(p), " failed with \"", strerror(xerrno),
528 " [ENOENT (", get_errnum(p, xerrno), ")]\"", NULL);
529 res = pr_error_strerror(err, format);
530 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
531 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
532 res);
533
534 res2 = pr_error_set_where(err, NULL, __FILE__, __LINE__);
535 fail_unless(res2 == 0, "Failed to set error where: %s", strerror(errno));
536
537 expected = pstrcat(p, "in API [api/error.c:534], UID ", get_uid(p),
538 ", GID ", get_gid(p), " failed with \"", strerror(xerrno),
539 " [ENOENT (", get_errnum(p, xerrno), ")]\"", NULL);
540 res = pr_error_strerror(err, format);
541 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
542 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
543 res);
544
545 /* Disable use of the module name. */
546 error_details = pr_error_use_details(PR_ERROR_DETAILS_DEFAULT);
547 error_details &= ~PR_ERROR_DETAILS_USE_MODULE;
548 (void) pr_error_use_details(error_details);
549
550 expected = pstrcat(p, "in api/error.c:534, UID ", get_uid(p), ", GID ",
551 get_gid(p), " failed with \"", strerror(xerrno),
552 " [ENOENT (", get_errnum(p, xerrno), ")]\"", NULL);
553 res = pr_error_strerror(err, format);
554 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
555 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
556 res);
557
558 /* Disable use of the file location. */
559 error_details &= ~PR_ERROR_DETAILS_USE_FILE;
560 (void) pr_error_use_details(error_details);
561
562 /* We have no who, no where, no why, no what. Expect the default/fallback,
563 * then.
564 */
565 expected = strerror(xerrno);
566 res = pr_error_strerror(err, format);
567 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
568 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
569 res);
570
571 what = "test";
572 res2 = pr_error_set_what(err, what);
573 fail_unless(res2 == 0, "Failed to set what '%s': %s", what,
574 strerror(errno));
575
576 expected = pstrcat(p, "UID ", get_uid(p), ", GID ", get_gid(p),
577 " attempting to ", what, " failed with \"", strerror(xerrno), " [ENOENT (",
578 get_errnum(p, xerrno), ")]\"", NULL);
579 res = pr_error_strerror(err, format);
580 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
581 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
582 res);
583
584 session.user = "foo";
585
586 /* Since the error's user is set at time of creation, we need to make
587 * a new error for these tests.
588 */
589 pr_error_destroy(err);
590 err = pr_error_create(p, xerrno);
591 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
592
593 (void) pr_error_set_where(err, NULL, __FILE__, __LINE__);
594 (void) pr_error_set_what(err, what);
595
596 expected = pstrcat(p, "user ", session.user, " (UID ", get_uid(p),
597 ", GID ", get_gid(p), ") via ftp attempting to ", what,
598 " failed with \"No such file or directory [ENOENT (",
599 get_errnum(p, xerrno), ")]\"", NULL);
600 res = pr_error_strerror(err, format);
601 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
602 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
603 res);
604
605 /* Disable use of names. */
606 error_details |= (PR_ERROR_DETAILS_USE_MODULE|PR_ERROR_DETAILS_USE_FILE);
607 error_details &= ~PR_ERROR_DETAILS_USE_NAMES;
608 (void) pr_error_use_details(error_details);
609
610 expected = pstrcat(p, "in API [api/error.c:593], UID ", get_uid(p),
611 ", GID ", get_gid(p), " via ftp attempting to ", what,
612 " failed with \"", strerror(xerrno), " [ENOENT (",
613 get_errnum(p, xerrno), ")]\"", NULL);
614 res = pr_error_strerror(err, format);
615 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
616 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
617 res);
618
619 /* Enable use of names, disable use of IDs. */
620 error_details |= PR_ERROR_DETAILS_USE_NAMES;
621 error_details &= ~PR_ERROR_DETAILS_USE_IDS;
622 (void) pr_error_use_details(error_details);
623
624 expected = pstrcat(p, "in API [api/error.c:593], user ", session.user,
625 " via ftp attempting to ", what, " failed with \"", strerror(xerrno),
626 " [ENOENT (", get_errnum(p, xerrno), ")]\"", NULL);
627 res = pr_error_strerror(err, format);
628 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
629 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
630 res);
631
632 /* Enable use of IDs, disable use of protocol. */
633 error_details |= PR_ERROR_DETAILS_USE_IDS;
634 error_details &= ~PR_ERROR_DETAILS_USE_PROTOCOL;
635 (void) pr_error_use_details(error_details);
636
637 expected = pstrcat(p, "in API [api/error.c:593], user ", session.user,
638 " (UID ", get_uid(p), ", GID ", get_gid(p), ") attempting to ", what,
639 " failed with \"", strerror(xerrno), " [ENOENT (",
640 get_errnum(p, xerrno), ")]\"", NULL);
641 res = pr_error_strerror(err, format);
642 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
643 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
644 res);
645
646 /* Enable everything */
647 error_details = PR_ERROR_DETAILS_DEFAULT;
648 (void) pr_error_use_details(error_details);
649
650 why = "test a function";
651 res2 = pr_error_set_why(err, why);
652 fail_unless(res2 == 0, "Failed to set why: %s", strerror(errno));
653
654 expected = pstrcat(p, "in API [api/error.c:593], user ", session.user,
655 " (UID ", get_uid(p), ", GID ", get_gid(p), ") via ftp wanted to ", why,
656 " but ", what, " failed with \"", strerror(xerrno), " [ENOENT (",
657 get_errnum(p, xerrno), ")]\"", NULL);
658 res = pr_error_strerror(err, 0);
659 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
660 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
661 res);
662
663 pr_error_destroy(err);
664 pr_error_use_details(PR_ERROR_DETAILS_DEFAULT);
665 }
666 END_TEST
667
test_explainer(pool * err_pool,int xerrno,const char * path,int flags,mode_t mode,const char ** args)668 static const char *test_explainer(pool *err_pool, int xerrno,
669 const char *path, int flags, mode_t mode, const char **args) {
670 *args = pstrcat(err_pool, "path = '", path,
671 "', flags = O_RDONLY, mode = 0755", NULL);
672 return pstrdup(err_pool, "test mode is not real");
673 }
674
START_TEST(error_strerror_detailed_explained_test)675 START_TEST (error_strerror_detailed_explained_test) {
676 int xerrno, res2;
677 pr_error_t *err;
678 pr_error_explainer_t *explainer;
679 const char *res, *expected, *what, *why;
680 module m;
681
682 session.user = "foo";
683
684 xerrno = ENOENT;
685 err = pr_error_create(p, xerrno);
686 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
687
688 what = "test";
689 res2 = pr_error_set_what(err, what);
690 fail_unless(res2 == 0, "Failed to set what: %s", strerror(errno));
691
692 why = "demonstrate an error explanation";
693 res2 = pr_error_set_why(err, why);
694 fail_unless(res2 == 0, "Failed to set why: %s", strerror(errno));
695
696 memset(&m, 0, sizeof(m));
697 m.name = "error";
698
699 res2 = pr_error_set_where(err, &m, __FILE__, __LINE__);
700 fail_unless(res2 == 0, "Failed to set where: %s", strerror(errno));
701
702 explainer = pr_error_register_explainer(p, &m, "error");
703 explainer->explain_open = test_explainer;
704
705 res2 = pr_error_explain_open(err, "path", O_RDONLY, 0755);
706 fail_unless(res2 == 0, "Failed to explain error: %s", strerror(errno));
707
708 expected = pstrcat(p, "in mod_", m.name, " [api/error.c:699], user ",
709 session.user, " (UID ", get_uid(p), ", GID ",
710 get_gid(p), ") via ftp wanted to ", why,
711 " but open() using path = 'path', flags = O_RDONLY, mode = 0755 "
712 "failed with \"", strerror(xerrno), " [ENOENT (", get_errnum(p, xerrno),
713 ")]\" because test mode is not real", NULL);
714 res = pr_error_strerror(err, 0);
715 fail_unless(res != NULL, "Failed to format error: %s", strerror(errno));
716 fail_unless(strcmp(res, expected) == 0, "Expected '%s', got '%s'", expected,
717 res);
718
719 (void) pr_error_unregister_explainer(p, &m, NULL);
720 pr_error_destroy(err);
721 }
722 END_TEST
723
724 static int test_explain_return_eperm = FALSE;
725
726 /* accept */
test_explain_accept(pool * err_pool,int xerrno,int fd,struct sockaddr * addr,socklen_t * addr_len,const char ** args)727 static const char *test_explain_accept(pool *err_pool, int xerrno, int fd,
728 struct sockaddr *addr, socklen_t *addr_len, const char **args) {
729
730 if (test_explain_return_eperm == TRUE) {
731 errno = EPERM;
732 return NULL;
733 }
734
735 return pstrdup(err_pool, "it was not meant to be");
736 }
737
START_TEST(error_explain_accept_test)738 START_TEST (error_explain_accept_test) {
739 int res, xerrno;
740 pr_error_t *err;
741 pr_error_explainer_t *explainer;
742 module m;
743 const char *name;
744
745 res = pr_error_explain_accept(NULL, -1, NULL, NULL);
746 fail_unless(res < 0, "Failed to handle null error");
747 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
748 strerror(errno), errno);
749
750 xerrno = EINVAL;
751 err = pr_error_create(p, xerrno);
752 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
753
754 res = pr_error_explain_accept(err, -1, NULL, NULL);
755 fail_unless(res < 0, "Failed to handle null explainer");
756 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
757 strerror(errno), errno);
758
759 memset(&m, 0, sizeof(m));
760 m.name = "error";
761 name = "testsuite";
762
763 explainer = pr_error_register_explainer(p, &m, name);
764 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
765 name, strerror(errno));
766
767 res = pr_error_explain_accept(err, -1, NULL, NULL);
768 fail_unless(res < 0, "Unexpectedly explained error");
769 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
770 strerror(errno), errno);
771
772 explainer->explain_accept = test_explain_accept;
773 test_explain_return_eperm = TRUE;
774
775 res = pr_error_explain_accept(err, -1, NULL, NULL);
776 fail_unless(res < 0, "Unexpectedly explained error");
777 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
778 strerror(errno), errno);
779
780 test_explain_return_eperm = FALSE;
781 res = pr_error_explain_accept(err, -1, NULL, NULL);
782 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
783
784 res = pr_error_unregister_explainer(p, &m, name);
785 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
786 strerror(errno));
787
788 pr_error_destroy(err);
789 }
790 END_TEST
791
792 /* bind */
test_explain_bind(pool * err_pool,int xerrno,int fd,const struct sockaddr * addr,socklen_t addr_len,const char ** args)793 static const char *test_explain_bind(pool *err_pool, int xerrno, int fd,
794 const struct sockaddr *addr, socklen_t addr_len, const char **args) {
795
796 if (test_explain_return_eperm == TRUE) {
797 errno = EPERM;
798 return NULL;
799 }
800
801 return pstrdup(err_pool, "it was not meant to be");
802 }
803
START_TEST(error_explain_bind_test)804 START_TEST (error_explain_bind_test) {
805 int res, xerrno;
806 pr_error_t *err;
807 pr_error_explainer_t *explainer;
808 module m;
809 const char *name;
810
811 res = pr_error_explain_bind(NULL, -1, NULL, 0);
812 fail_unless(res < 0, "Failed to handle null error");
813 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
814 strerror(errno), errno);
815
816 xerrno = EINVAL;
817 err = pr_error_create(p, xerrno);
818 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
819
820 res = pr_error_explain_bind(err, -1, NULL, 0);
821 fail_unless(res < 0, "Unexpectedly explained error");
822 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
823 strerror(errno), errno);
824
825 memset(&m, 0, sizeof(m));
826 m.name = "error";
827 name = "testsuite";
828
829 explainer = pr_error_register_explainer(p, &m, name);
830 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
831 name, strerror(errno));
832
833 res = pr_error_explain_bind(err, -1, NULL, 0);
834 fail_unless(res < 0, "Unexpectedly explained error");
835 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
836 strerror(errno), errno);
837
838 explainer->explain_bind = test_explain_bind;
839 test_explain_return_eperm = TRUE;
840
841 res = pr_error_explain_bind(err, -1, NULL, 0);
842 fail_unless(res < 0, "Unexpectedly explained error");
843 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
844 strerror(errno), errno);
845
846 test_explain_return_eperm = FALSE;
847 res = pr_error_explain_bind(err, -1, NULL, 0);
848 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
849
850 res = pr_error_unregister_explainer(p, &m, name);
851 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
852 strerror(errno));
853
854 pr_error_destroy(err);
855 }
856 END_TEST
857
858 /* chdir */
test_explain_chdir(pool * err_pool,int xerrno,const char * path,const char ** args)859 static const char *test_explain_chdir(pool *err_pool, int xerrno,
860 const char *path, const char **args) {
861
862 if (test_explain_return_eperm == TRUE) {
863 errno = EPERM;
864 return NULL;
865 }
866
867 return pstrdup(err_pool, "it was not meant to be");
868 }
869
START_TEST(error_explain_chdir_test)870 START_TEST (error_explain_chdir_test) {
871 int res, xerrno;
872 pr_error_t *err;
873 pr_error_explainer_t *explainer;
874 module m;
875 const char *name;
876
877 res = pr_error_explain_chdir(NULL, NULL);
878 fail_unless(res < 0, "Failed to handle null error");
879 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
880 strerror(errno), errno);
881
882 xerrno = EINVAL;
883 err = pr_error_create(p, xerrno);
884 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
885
886 res = pr_error_explain_chdir(err, NULL);
887 fail_unless(res < 0, "Unexpectedly explained error");
888 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
889 strerror(errno), errno);
890
891 memset(&m, 0, sizeof(m));
892 m.name = "error";
893 name = "testsuite";
894
895 explainer = pr_error_register_explainer(p, &m, name);
896 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
897 name, strerror(errno));
898
899 res = pr_error_explain_chdir(err, NULL);
900 fail_unless(res < 0, "Unexpectedly explained error");
901 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
902 strerror(errno), errno);
903
904 explainer->explain_chdir = test_explain_chdir;
905 test_explain_return_eperm = TRUE;
906
907 res = pr_error_explain_chdir(err, NULL);
908 fail_unless(res < 0, "Unexpectedly explained error");
909 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
910 strerror(errno), errno);
911
912 test_explain_return_eperm = FALSE;
913 res = pr_error_explain_chdir(err, NULL);
914 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
915
916 res = pr_error_unregister_explainer(p, &m, name);
917 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
918 strerror(errno));
919
920 pr_error_destroy(err);
921 }
922 END_TEST
923
924 /* chmod */
test_explain_chmod(pool * err_pool,int xerrno,const char * path,mode_t mode,const char ** args)925 static const char *test_explain_chmod(pool *err_pool, int xerrno,
926 const char *path, mode_t mode, const char **args) {
927
928 if (test_explain_return_eperm == TRUE) {
929 errno = EPERM;
930 return NULL;
931 }
932
933 return pstrdup(err_pool, "it was not meant to be");
934 }
935
START_TEST(error_explain_chmod_test)936 START_TEST (error_explain_chmod_test) {
937 int res, xerrno;
938 pr_error_t *err;
939 pr_error_explainer_t *explainer;
940 module m;
941 const char *name;
942
943 res = pr_error_explain_chmod(NULL, NULL, 0);
944 fail_unless(res < 0, "Failed to handle null error");
945 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
946 strerror(errno), errno);
947
948 xerrno = EINVAL;
949 err = pr_error_create(p, xerrno);
950 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
951
952 res = pr_error_explain_chmod(err, NULL, 0);
953 fail_unless(res < 0, "Unexpectedly explained error");
954 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
955 strerror(errno), errno);
956
957 memset(&m, 0, sizeof(m));
958 m.name = "error";
959 name = "testsuite";
960
961 explainer = pr_error_register_explainer(p, &m, name);
962 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
963 name, strerror(errno));
964
965 res = pr_error_explain_chmod(err, NULL, 0);
966 fail_unless(res < 0, "Unexpectedly explained error");
967 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
968 strerror(errno), errno);
969
970 explainer->explain_chmod = test_explain_chmod;
971 test_explain_return_eperm = TRUE;
972
973 res = pr_error_explain_chmod(err, NULL, 0);
974 fail_unless(res < 0, "Unexpectedly explained error");
975 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
976 strerror(errno), errno);
977
978 test_explain_return_eperm = FALSE;
979 res = pr_error_explain_chmod(err, NULL, 0);
980 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
981
982 res = pr_error_unregister_explainer(p, &m, name);
983 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
984 strerror(errno));
985
986 pr_error_destroy(err);
987 }
988 END_TEST
989
990 /* chown */
test_explain_chown(pool * err_pool,int xerrno,const char * path,uid_t uid,gid_t gid,const char ** args)991 static const char *test_explain_chown(pool *err_pool, int xerrno,
992 const char *path, uid_t uid, gid_t gid, const char **args) {
993
994 if (test_explain_return_eperm == TRUE) {
995 errno = EPERM;
996 return NULL;
997 }
998
999 return pstrdup(err_pool, "it was not meant to be");
1000 }
1001
START_TEST(error_explain_chown_test)1002 START_TEST (error_explain_chown_test) {
1003 int res, xerrno;
1004 pr_error_t *err;
1005 pr_error_explainer_t *explainer;
1006 module m;
1007 const char *name;
1008
1009 res = pr_error_explain_chown(NULL, NULL, -1, -1);
1010 fail_unless(res < 0, "Failed to handle null error");
1011 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1012 strerror(errno), errno);
1013
1014 xerrno = EINVAL;
1015 err = pr_error_create(p, xerrno);
1016 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1017
1018 res = pr_error_explain_chown(err, NULL, -1, -1);
1019 fail_unless(res < 0, "Unexpectedly explained error");
1020 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1021 strerror(errno), errno);
1022
1023 memset(&m, 0, sizeof(m));
1024 m.name = "error";
1025 name = "testsuite";
1026
1027 explainer = pr_error_register_explainer(p, &m, name);
1028 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1029 name, strerror(errno));
1030
1031 res = pr_error_explain_chown(err, NULL, -1, -1);
1032 fail_unless(res < 0, "Unexpectedly explained error");
1033 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1034 strerror(errno), errno);
1035
1036 explainer->explain_chown = test_explain_chown;
1037 test_explain_return_eperm = TRUE;
1038
1039 res = pr_error_explain_chown(err, NULL, -1, -1);
1040 fail_unless(res < 0, "Unexpectedly explained error");
1041 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1042 strerror(errno), errno);
1043
1044 test_explain_return_eperm = FALSE;
1045 res = pr_error_explain_chown(err, NULL, -1, -1);
1046 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1047
1048 res = pr_error_unregister_explainer(p, &m, name);
1049 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1050 strerror(errno));
1051
1052 pr_error_destroy(err);
1053 }
1054 END_TEST
1055
1056 /* chroot */
test_explain_chroot(pool * err_pool,int xerrno,const char * path,const char ** args)1057 static const char *test_explain_chroot(pool *err_pool, int xerrno,
1058 const char *path, const char **args) {
1059
1060 if (test_explain_return_eperm == TRUE) {
1061 errno = EPERM;
1062 return NULL;
1063 }
1064
1065 return pstrdup(err_pool, "it was not meant to be");
1066 }
1067
START_TEST(error_explain_chroot_test)1068 START_TEST (error_explain_chroot_test) {
1069 int res, xerrno;
1070 pr_error_t *err;
1071 pr_error_explainer_t *explainer;
1072 module m;
1073 const char *name;
1074
1075 res = pr_error_explain_chroot(NULL, NULL);
1076 fail_unless(res < 0, "Failed to handle null error");
1077 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1078 strerror(errno), errno);
1079
1080 xerrno = EINVAL;
1081 err = pr_error_create(p, xerrno);
1082 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1083
1084 res = pr_error_explain_chroot(err, NULL);
1085 fail_unless(res < 0, "Unexpectedly explained error");
1086 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1087 strerror(errno), errno);
1088
1089 memset(&m, 0, sizeof(m));
1090 m.name = "error";
1091 name = "testsuite";
1092
1093 explainer = pr_error_register_explainer(p, &m, name);
1094 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1095 name, strerror(errno));
1096
1097 res = pr_error_explain_chroot(err, NULL);
1098 fail_unless(res < 0, "Unexpectedly explained error");
1099 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1100 strerror(errno), errno);
1101
1102 explainer->explain_chroot = test_explain_chroot;
1103 test_explain_return_eperm = TRUE;
1104
1105 res = pr_error_explain_chroot(err, NULL);
1106 fail_unless(res < 0, "Unexpectedly explained error");
1107 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1108 strerror(errno), errno);
1109
1110 test_explain_return_eperm = FALSE;
1111 res = pr_error_explain_chroot(err, NULL);
1112 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1113
1114 res = pr_error_unregister_explainer(p, &m, name);
1115 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1116 strerror(errno));
1117
1118 pr_error_destroy(err);
1119 }
1120 END_TEST
1121
1122 /* close */
test_explain_close(pool * err_pool,int xerrno,int fd,const char ** args)1123 static const char *test_explain_close(pool *err_pool, int xerrno, int fd,
1124 const char **args) {
1125
1126 if (test_explain_return_eperm == TRUE) {
1127 errno = EPERM;
1128 return NULL;
1129 }
1130
1131 return pstrdup(err_pool, "it was not meant to be");
1132 }
1133
START_TEST(error_explain_close_test)1134 START_TEST (error_explain_close_test) {
1135 int res, xerrno;
1136 pr_error_t *err;
1137 pr_error_explainer_t *explainer;
1138 module m;
1139 const char *name;
1140
1141 res = pr_error_explain_close(NULL, -1);
1142 fail_unless(res < 0, "Failed to handle null error");
1143 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1144 strerror(errno), errno);
1145
1146 xerrno = EINVAL;
1147 err = pr_error_create(p, xerrno);
1148 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1149
1150 res = pr_error_explain_close(err, -1);
1151 fail_unless(res < 0, "Unexpectedly explained error");
1152 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1153 strerror(errno), errno);
1154
1155 memset(&m, 0, sizeof(m));
1156 m.name = "error";
1157 name = "testsuite";
1158
1159 explainer = pr_error_register_explainer(p, &m, name);
1160 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1161 name, strerror(errno));
1162
1163 res = pr_error_explain_close(err, -1);
1164 fail_unless(res < 0, "Unexpectedly explained error");
1165 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1166 strerror(errno), errno);
1167
1168 explainer->explain_close = test_explain_close;
1169 test_explain_return_eperm = TRUE;
1170
1171 res = pr_error_explain_close(err, -1);
1172 fail_unless(res < 0, "Unexpectedly explained error");
1173 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1174 strerror(errno), errno);
1175
1176 test_explain_return_eperm = FALSE;
1177 res = pr_error_explain_close(err, -1);
1178 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1179
1180 res = pr_error_unregister_explainer(p, &m, name);
1181 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1182 strerror(errno));
1183
1184 pr_error_destroy(err);
1185 }
1186 END_TEST
1187
1188 /* closedir */
test_explain_closedir(pool * err_pool,int xerrno,void * dirh,const char ** args)1189 static const char *test_explain_closedir(pool *err_pool, int xerrno,
1190 void *dirh, const char **args) {
1191
1192 if (test_explain_return_eperm == TRUE) {
1193 errno = EPERM;
1194 return NULL;
1195 }
1196
1197 return pstrdup(err_pool, "it was not meant to be");
1198 }
1199
START_TEST(error_explain_closedir_test)1200 START_TEST (error_explain_closedir_test) {
1201 int res, xerrno;
1202 pr_error_t *err;
1203 pr_error_explainer_t *explainer;
1204 module m;
1205 const char *name;
1206
1207 res = pr_error_explain_closedir(NULL, NULL);
1208 fail_unless(res < 0, "Failed to handle null error");
1209 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1210 strerror(errno), errno);
1211
1212 xerrno = EINVAL;
1213 err = pr_error_create(p, xerrno);
1214 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1215
1216 res = pr_error_explain_closedir(err, NULL);
1217 fail_unless(res < 0, "Unexpectedly explained error");
1218 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1219 strerror(errno), errno);
1220
1221 memset(&m, 0, sizeof(m));
1222 m.name = "error";
1223 name = "testsuite";
1224
1225 explainer = pr_error_register_explainer(p, &m, name);
1226 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1227 name, strerror(errno));
1228
1229 res = pr_error_explain_closedir(err, NULL);
1230 fail_unless(res < 0, "Unexpectedly explained error");
1231 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1232 strerror(errno), errno);
1233
1234 explainer->explain_closedir = test_explain_closedir;
1235 test_explain_return_eperm = TRUE;
1236
1237 res = pr_error_explain_closedir(err, NULL);
1238 fail_unless(res < 0, "Unexpectedly explained error");
1239 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1240 strerror(errno), errno);
1241
1242 test_explain_return_eperm = FALSE;
1243 res = pr_error_explain_closedir(err, NULL);
1244 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1245
1246 res = pr_error_unregister_explainer(p, &m, name);
1247 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1248 strerror(errno));
1249
1250 pr_error_destroy(err);
1251 }
1252 END_TEST
1253
1254 /* connect */
test_explain_connect(pool * err_pool,int xerrno,int fd,const struct sockaddr * addr,socklen_t addr_len,const char ** args)1255 static const char *test_explain_connect(pool *err_pool, int xerrno, int fd,
1256 const struct sockaddr *addr, socklen_t addr_len, const char **args) {
1257
1258 if (test_explain_return_eperm == TRUE) {
1259 errno = EPERM;
1260 return NULL;
1261 }
1262
1263 return pstrdup(err_pool, "it was not meant to be");
1264 }
1265
START_TEST(error_explain_connect_test)1266 START_TEST (error_explain_connect_test) {
1267 int res, xerrno;
1268 pr_error_t *err;
1269 pr_error_explainer_t *explainer;
1270 module m;
1271 const char *name;
1272
1273 res = pr_error_explain_connect(NULL, -1, NULL, 0);
1274 fail_unless(res < 0, "Failed to handle null error");
1275 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1276 strerror(errno), errno);
1277
1278 xerrno = EINVAL;
1279 err = pr_error_create(p, xerrno);
1280 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1281
1282 res = pr_error_explain_connect(err, -1, NULL, 0);
1283 fail_unless(res < 0, "Unexpectedly explained error");
1284 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1285 strerror(errno), errno);
1286
1287 memset(&m, 0, sizeof(m));
1288 m.name = "error";
1289 name = "testsuite";
1290
1291 explainer = pr_error_register_explainer(p, &m, name);
1292 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1293 name, strerror(errno));
1294
1295 res = pr_error_explain_connect(err, -1, NULL, 0);
1296 fail_unless(res < 0, "Unexpectedly explained error");
1297 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1298 strerror(errno), errno);
1299
1300 explainer->explain_connect = test_explain_connect;
1301 test_explain_return_eperm = TRUE;
1302
1303 res = pr_error_explain_connect(err, -1, NULL, 0);
1304 fail_unless(res < 0, "Unexpectedly explained error");
1305 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1306 strerror(errno), errno);
1307
1308 test_explain_return_eperm = FALSE;
1309 res = pr_error_explain_connect(err, -1, NULL, 0);
1310 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1311
1312 res = pr_error_unregister_explainer(p, &m, name);
1313 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1314 strerror(errno));
1315
1316 pr_error_destroy(err);
1317 }
1318 END_TEST
1319
1320 /* fchmod */
test_explain_fchmod(pool * err_pool,int xerrno,int fd,mode_t mode,const char ** args)1321 static const char *test_explain_fchmod(pool *err_pool, int xerrno, int fd,
1322 mode_t mode, const char **args) {
1323
1324 if (test_explain_return_eperm == TRUE) {
1325 errno = EPERM;
1326 return NULL;
1327 }
1328
1329 return pstrdup(err_pool, "it was not meant to be");
1330 }
1331
START_TEST(error_explain_fchmod_test)1332 START_TEST (error_explain_fchmod_test) {
1333 int res, xerrno;
1334 pr_error_t *err;
1335 pr_error_explainer_t *explainer;
1336 module m;
1337 const char *name;
1338
1339 res = pr_error_explain_fchmod(NULL, -1, 0);
1340 fail_unless(res < 0, "Failed to handle null error");
1341 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1342 strerror(errno), errno);
1343
1344 xerrno = EINVAL;
1345 err = pr_error_create(p, xerrno);
1346 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1347
1348 res = pr_error_explain_fchmod(err, -1, 0);
1349 fail_unless(res < 0, "Unexpectedly explained error");
1350 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1351 strerror(errno), errno);
1352
1353 memset(&m, 0, sizeof(m));
1354 m.name = "error";
1355 name = "testsuite";
1356
1357 explainer = pr_error_register_explainer(p, &m, name);
1358 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1359 name, strerror(errno));
1360
1361 res = pr_error_explain_fchmod(err, -1, 0);
1362 fail_unless(res < 0, "Unexpectedly explained error");
1363 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1364 strerror(errno), errno);
1365
1366 explainer->explain_fchmod = test_explain_fchmod;
1367 test_explain_return_eperm = TRUE;
1368
1369 res = pr_error_explain_fchmod(err, -1, 0);
1370 fail_unless(res < 0, "Unexpectedly explained error");
1371 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1372 strerror(errno), errno);
1373
1374 test_explain_return_eperm = FALSE;
1375 res = pr_error_explain_fchmod(err, -1, 0);
1376 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1377
1378 res = pr_error_unregister_explainer(p, &m, name);
1379 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1380 strerror(errno));
1381
1382 pr_error_destroy(err);
1383 }
1384 END_TEST
1385
1386 /* fchown */
test_explain_fchown(pool * err_pool,int xerrno,int fd,uid_t uid,gid_t gid,const char ** args)1387 static const char *test_explain_fchown(pool *err_pool, int xerrno, int fd,
1388 uid_t uid, gid_t gid, const char **args) {
1389
1390 if (test_explain_return_eperm == TRUE) {
1391 errno = EPERM;
1392 return NULL;
1393 }
1394
1395 return pstrdup(err_pool, "it was not meant to be");
1396 }
1397
START_TEST(error_explain_fchown_test)1398 START_TEST (error_explain_fchown_test) {
1399 int res, xerrno;
1400 pr_error_t *err;
1401 pr_error_explainer_t *explainer;
1402 module m;
1403 const char *name;
1404
1405 res = pr_error_explain_fchown(NULL, -1, -1, -1);
1406 fail_unless(res < 0, "Failed to handle null error");
1407 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1408 strerror(errno), errno);
1409
1410 xerrno = EINVAL;
1411 err = pr_error_create(p, xerrno);
1412 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1413
1414 res = pr_error_explain_fchown(err, -1, -1, -1);
1415 fail_unless(res < 0, "Unexpectedly explained error");
1416 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1417 strerror(errno), errno);
1418
1419 memset(&m, 0, sizeof(m));
1420 m.name = "error";
1421 name = "testsuite";
1422
1423 explainer = pr_error_register_explainer(p, &m, name);
1424 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1425 name, strerror(errno));
1426
1427 res = pr_error_explain_fchown(err, -1, -1, -1);
1428 fail_unless(res < 0, "Unexpectedly explained error");
1429 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1430 strerror(errno), errno);
1431
1432 explainer->explain_fchown = test_explain_fchown;
1433 test_explain_return_eperm = TRUE;
1434
1435 res = pr_error_explain_fchown(err, -1, -1, -1);
1436 fail_unless(res < 0, "Unexpectedly explained error");
1437 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1438 strerror(errno), errno);
1439
1440 test_explain_return_eperm = FALSE;
1441 res = pr_error_explain_fchown(err, -1, -1, -1);
1442 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1443
1444 res = pr_error_unregister_explainer(p, &m, name);
1445 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1446 strerror(errno));
1447
1448 pr_error_destroy(err);
1449 }
1450 END_TEST
1451
1452 /* fclose */
test_explain_fclose(pool * err_pool,int xerrno,FILE * fh,const char ** args)1453 static const char *test_explain_fclose(pool *err_pool, int xerrno, FILE *fh,
1454 const char **args) {
1455
1456 if (test_explain_return_eperm == TRUE) {
1457 errno = EPERM;
1458 return NULL;
1459 }
1460
1461 return pstrdup(err_pool, "it was not meant to be");
1462 }
1463
START_TEST(error_explain_fclose_test)1464 START_TEST (error_explain_fclose_test) {
1465 int res, xerrno;
1466 pr_error_t *err;
1467 pr_error_explainer_t *explainer;
1468 module m;
1469 const char *name;
1470
1471 res = pr_error_explain_fclose(NULL, NULL);
1472 fail_unless(res < 0, "Failed to handle null error");
1473 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1474 strerror(errno), errno);
1475
1476 xerrno = EINVAL;
1477 err = pr_error_create(p, xerrno);
1478 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1479
1480 res = pr_error_explain_fclose(err, NULL);
1481 fail_unless(res < 0, "Unexpectedly explained error");
1482 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1483 strerror(errno), errno);
1484
1485 memset(&m, 0, sizeof(m));
1486 m.name = "error";
1487 name = "testsuite";
1488
1489 explainer = pr_error_register_explainer(p, &m, name);
1490 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1491 name, strerror(errno));
1492
1493 res = pr_error_explain_fclose(err, NULL);
1494 fail_unless(res < 0, "Unexpectedly explained error");
1495 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1496 strerror(errno), errno);
1497
1498 explainer->explain_fclose = test_explain_fclose;
1499 test_explain_return_eperm = TRUE;
1500
1501 res = pr_error_explain_fclose(err, NULL);
1502 fail_unless(res < 0, "Unexpectedly explained error");
1503 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1504 strerror(errno), errno);
1505
1506 test_explain_return_eperm = FALSE;
1507 res = pr_error_explain_fclose(err, NULL);
1508 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1509
1510 res = pr_error_unregister_explainer(p, &m, name);
1511 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1512 strerror(errno));
1513
1514 pr_error_destroy(err);
1515 }
1516 END_TEST
1517
1518 /* fcntl */
test_explain_fcntl(pool * err_pool,int xerrno,int fd,int op,long arg,const char ** args)1519 static const char *test_explain_fcntl(pool *err_pool, int xerrno, int fd,
1520 int op, long arg, const char **args) {
1521
1522 if (test_explain_return_eperm == TRUE) {
1523 errno = EPERM;
1524 return NULL;
1525 }
1526
1527 return pstrdup(err_pool, "it was not meant to be");
1528 }
1529
START_TEST(error_explain_fcntl_test)1530 START_TEST (error_explain_fcntl_test) {
1531 int res, xerrno;
1532 pr_error_t *err;
1533 pr_error_explainer_t *explainer;
1534 module m;
1535 const char *name;
1536
1537 res = pr_error_explain_fcntl(NULL, -1, -1, -1);
1538 fail_unless(res < 0, "Failed to handle null error");
1539 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1540 strerror(errno), errno);
1541
1542 xerrno = EINVAL;
1543 err = pr_error_create(p, xerrno);
1544 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1545
1546 res = pr_error_explain_fcntl(err, -1, -1, -1);
1547 fail_unless(res < 0, "Unexpectedly explained error");
1548 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1549 strerror(errno), errno);
1550
1551 memset(&m, 0, sizeof(m));
1552 m.name = "error";
1553 name = "testsuite";
1554
1555 explainer = pr_error_register_explainer(p, &m, name);
1556 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1557 name, strerror(errno));
1558
1559 res = pr_error_explain_fcntl(err, -1, -1, -1);
1560 fail_unless(res < 0, "Unexpectedly explained error");
1561 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1562 strerror(errno), errno);
1563
1564 explainer->explain_fcntl = test_explain_fcntl;
1565 test_explain_return_eperm = TRUE;
1566
1567 res = pr_error_explain_fcntl(err, -1, -1, -1);
1568 fail_unless(res < 0, "Unexpectedly explained error");
1569 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1570 strerror(errno), errno);
1571
1572 test_explain_return_eperm = FALSE;
1573 res = pr_error_explain_fcntl(err, -1, -1, -1);
1574 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1575
1576 res = pr_error_unregister_explainer(p, &m, name);
1577 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1578 strerror(errno));
1579
1580 pr_error_destroy(err);
1581 }
1582 END_TEST
1583
1584 /* fdopen */
test_explain_fdopen(pool * err_pool,int xerrno,int fd,const char * mode,const char ** args)1585 static const char *test_explain_fdopen(pool *err_pool, int xerrno, int fd,
1586 const char *mode, const char **args) {
1587
1588 if (test_explain_return_eperm == TRUE) {
1589 errno = EPERM;
1590 return NULL;
1591 }
1592
1593 return pstrdup(err_pool, "it was not meant to be");
1594 }
1595
START_TEST(error_explain_fdopen_test)1596 START_TEST (error_explain_fdopen_test) {
1597 int res, xerrno;
1598 pr_error_t *err;
1599 pr_error_explainer_t *explainer;
1600 module m;
1601 const char *name;
1602
1603 res = pr_error_explain_fdopen(NULL, -1, NULL);
1604 fail_unless(res < 0, "Failed to handle null error");
1605 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1606 strerror(errno), errno);
1607
1608 xerrno = EINVAL;
1609 err = pr_error_create(p, xerrno);
1610 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1611
1612 res = pr_error_explain_fdopen(err, -1, NULL);
1613 fail_unless(res < 0, "Unexpectedly explained error");
1614 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1615 strerror(errno), errno);
1616
1617 memset(&m, 0, sizeof(m));
1618 m.name = "error";
1619 name = "testsuite";
1620
1621 explainer = pr_error_register_explainer(p, &m, name);
1622 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1623 name, strerror(errno));
1624
1625 res = pr_error_explain_fdopen(err, -1, NULL);
1626 fail_unless(res < 0, "Unexpectedly explained error");
1627 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1628 strerror(errno), errno);
1629
1630 explainer->explain_fdopen = test_explain_fdopen;
1631 test_explain_return_eperm = TRUE;
1632
1633 res = pr_error_explain_fdopen(err, -1, NULL);
1634 fail_unless(res < 0, "Unexpectedly explained error");
1635 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1636 strerror(errno), errno);
1637
1638 test_explain_return_eperm = FALSE;
1639 res = pr_error_explain_fdopen(err, -1, NULL);
1640 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1641
1642 res = pr_error_unregister_explainer(p, &m, name);
1643 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1644 strerror(errno));
1645
1646 pr_error_destroy(err);
1647 }
1648 END_TEST
1649
1650 /* flock */
test_explain_flock(pool * err_pool,int xerrno,int fd,int op,const char ** args)1651 static const char *test_explain_flock(pool *err_pool, int xerrno, int fd,
1652 int op, const char **args) {
1653
1654 if (test_explain_return_eperm == TRUE) {
1655 errno = EPERM;
1656 return NULL;
1657 }
1658
1659 return pstrdup(err_pool, "it was not meant to be");
1660 }
1661
START_TEST(error_explain_flock_test)1662 START_TEST (error_explain_flock_test) {
1663 int res, xerrno;
1664 pr_error_t *err;
1665 pr_error_explainer_t *explainer;
1666 module m;
1667 const char *name;
1668
1669 res = pr_error_explain_flock(NULL, -1, -1);
1670 fail_unless(res < 0, "Failed to handle null error");
1671 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1672 strerror(errno), errno);
1673
1674 xerrno = EINVAL;
1675 err = pr_error_create(p, xerrno);
1676 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1677
1678 res = pr_error_explain_flock(err, -1, -1);
1679 fail_unless(res < 0, "Unexpectedly explained error");
1680 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1681 strerror(errno), errno);
1682
1683 memset(&m, 0, sizeof(m));
1684 m.name = "error";
1685 name = "testsuite";
1686
1687 explainer = pr_error_register_explainer(p, &m, name);
1688 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1689 name, strerror(errno));
1690
1691 res = pr_error_explain_flock(err, -1, -1);
1692 fail_unless(res < 0, "Unexpectedly explained error");
1693 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1694 strerror(errno), errno);
1695
1696 explainer->explain_flock = test_explain_flock;
1697 test_explain_return_eperm = TRUE;
1698
1699 res = pr_error_explain_flock(err, -1, -1);
1700 fail_unless(res < 0, "Unexpectedly explained error");
1701 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1702 strerror(errno), errno);
1703
1704 test_explain_return_eperm = FALSE;
1705 res = pr_error_explain_flock(err, -1, -1);
1706 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1707
1708 res = pr_error_unregister_explainer(p, &m, name);
1709 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1710 strerror(errno));
1711
1712 pr_error_destroy(err);
1713 }
1714 END_TEST
1715
1716 /* fopen */
test_explain_fopen(pool * err_pool,int xerrno,const char * path,const char * mode,const char ** args)1717 static const char *test_explain_fopen(pool *err_pool, int xerrno,
1718 const char *path, const char *mode, const char **args) {
1719
1720 if (test_explain_return_eperm == TRUE) {
1721 errno = EPERM;
1722 return NULL;
1723 }
1724
1725 return pstrdup(err_pool, "it was not meant to be");
1726 }
1727
START_TEST(error_explain_fopen_test)1728 START_TEST (error_explain_fopen_test) {
1729 int res, xerrno;
1730 pr_error_t *err;
1731 pr_error_explainer_t *explainer;
1732 module m;
1733 const char *name;
1734
1735 res = pr_error_explain_fopen(NULL, NULL, NULL);
1736 fail_unless(res < 0, "Failed to handle null error");
1737 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1738 strerror(errno), errno);
1739
1740 xerrno = EINVAL;
1741 err = pr_error_create(p, xerrno);
1742 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1743
1744 res = pr_error_explain_fopen(err, NULL, NULL);
1745 fail_unless(res < 0, "Unexpectedly explained error");
1746 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1747 strerror(errno), errno);
1748
1749 memset(&m, 0, sizeof(m));
1750 m.name = "error";
1751 name = "testsuite";
1752
1753 explainer = pr_error_register_explainer(p, &m, name);
1754 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1755 name, strerror(errno));
1756
1757 res = pr_error_explain_fopen(err, NULL, NULL);
1758 fail_unless(res < 0, "Unexpectedly explained error");
1759 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1760 strerror(errno), errno);
1761
1762 explainer->explain_fopen = test_explain_fopen;
1763 test_explain_return_eperm = TRUE;
1764
1765 res = pr_error_explain_fopen(err, NULL, NULL);
1766 fail_unless(res < 0, "Unexpectedly explained error");
1767 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1768 strerror(errno), errno);
1769
1770 test_explain_return_eperm = FALSE;
1771 res = pr_error_explain_fopen(err, NULL, NULL);
1772 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1773
1774 res = pr_error_unregister_explainer(p, &m, name);
1775 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1776 strerror(errno));
1777
1778 pr_error_destroy(err);
1779 }
1780 END_TEST
1781
1782 /* fork */
test_explain_fork(pool * err_pool,int xerrno,const char ** args)1783 static const char *test_explain_fork(pool *err_pool, int xerrno,
1784 const char **args) {
1785
1786 if (test_explain_return_eperm == TRUE) {
1787 errno = EPERM;
1788 return NULL;
1789 }
1790
1791 return pstrdup(err_pool, "it was not meant to be");
1792 }
1793
START_TEST(error_explain_fork_test)1794 START_TEST (error_explain_fork_test) {
1795 int res, xerrno;
1796 pr_error_t *err;
1797 pr_error_explainer_t *explainer;
1798 module m;
1799 const char *name;
1800
1801 res = pr_error_explain_fork(NULL);
1802 fail_unless(res < 0, "Failed to handle null error");
1803 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1804 strerror(errno), errno);
1805
1806 xerrno = EINVAL;
1807 err = pr_error_create(p, xerrno);
1808 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1809
1810 res = pr_error_explain_fork(err);
1811 fail_unless(res < 0, "Unexpectedly explained error");
1812 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1813 strerror(errno), errno);
1814
1815 memset(&m, 0, sizeof(m));
1816 m.name = "error";
1817 name = "testsuite";
1818
1819 explainer = pr_error_register_explainer(p, &m, name);
1820 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1821 name, strerror(errno));
1822
1823 res = pr_error_explain_fork(err);
1824 fail_unless(res < 0, "Unexpectedly explained error");
1825 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1826 strerror(errno), errno);
1827
1828 explainer->explain_fork = test_explain_fork;
1829 test_explain_return_eperm = TRUE;
1830
1831 res = pr_error_explain_fork(err);
1832 fail_unless(res < 0, "Unexpectedly explained error");
1833 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1834 strerror(errno), errno);
1835
1836 test_explain_return_eperm = FALSE;
1837 res = pr_error_explain_fork(err);
1838 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1839
1840 res = pr_error_unregister_explainer(p, &m, name);
1841 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1842 strerror(errno));
1843
1844 pr_error_destroy(err);
1845 }
1846 END_TEST
1847
1848 /* fstat */
test_explain_fstat(pool * err_pool,int xerrno,int fd,struct stat * st,const char ** args)1849 static const char *test_explain_fstat(pool *err_pool, int xerrno, int fd,
1850 struct stat *st, const char **args) {
1851
1852 if (test_explain_return_eperm == TRUE) {
1853 errno = EPERM;
1854 return NULL;
1855 }
1856
1857 return pstrdup(err_pool, "it was not meant to be");
1858 }
1859
START_TEST(error_explain_fstat_test)1860 START_TEST (error_explain_fstat_test) {
1861 int res, xerrno;
1862 pr_error_t *err;
1863 pr_error_explainer_t *explainer;
1864 module m;
1865 const char *name;
1866
1867 res = pr_error_explain_fstat(NULL, -1, NULL);
1868 fail_unless(res < 0, "Failed to handle null error");
1869 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1870 strerror(errno), errno);
1871
1872 xerrno = EINVAL;
1873 err = pr_error_create(p, xerrno);
1874 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1875
1876 res = pr_error_explain_fstat(err, -1, NULL);
1877 fail_unless(res < 0, "Unexpectedly explained error");
1878 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1879 strerror(errno), errno);
1880
1881 memset(&m, 0, sizeof(m));
1882 m.name = "error";
1883 name = "testsuite";
1884
1885 explainer = pr_error_register_explainer(p, &m, name);
1886 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1887 name, strerror(errno));
1888
1889 res = pr_error_explain_fstat(err, -1, NULL);
1890 fail_unless(res < 0, "Unexpectedly explained error");
1891 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1892 strerror(errno), errno);
1893
1894 explainer->explain_fstat = test_explain_fstat;
1895 test_explain_return_eperm = TRUE;
1896
1897 res = pr_error_explain_fstat(err, -1, NULL);
1898 fail_unless(res < 0, "Unexpectedly explained error");
1899 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1900 strerror(errno), errno);
1901
1902 test_explain_return_eperm = FALSE;
1903 res = pr_error_explain_fstat(err, -1, NULL);
1904 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1905
1906 res = pr_error_unregister_explainer(p, &m, name);
1907 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1908 strerror(errno));
1909
1910 pr_error_destroy(err);
1911 }
1912 END_TEST
1913
1914 /* fstatfs */
test_explain_fstatfs(pool * err_pool,int xerrno,int fd,void * stfs,const char ** args)1915 static const char *test_explain_fstatfs(pool *err_pool, int xerrno, int fd,
1916 void *stfs, const char **args) {
1917
1918 if (test_explain_return_eperm == TRUE) {
1919 errno = EPERM;
1920 return NULL;
1921 }
1922
1923 return pstrdup(err_pool, "it was not meant to be");
1924 }
1925
START_TEST(error_explain_fstatfs_test)1926 START_TEST (error_explain_fstatfs_test) {
1927 int res, xerrno;
1928 pr_error_t *err;
1929 pr_error_explainer_t *explainer;
1930 module m;
1931 const char *name;
1932
1933 res = pr_error_explain_fstatfs(NULL, -1, NULL);
1934 fail_unless(res < 0, "Failed to handle null error");
1935 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
1936 strerror(errno), errno);
1937
1938 xerrno = EINVAL;
1939 err = pr_error_create(p, xerrno);
1940 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
1941
1942 res = pr_error_explain_fstatfs(err, -1, NULL);
1943 fail_unless(res < 0, "Unexpectedly explained error");
1944 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1945 strerror(errno), errno);
1946
1947 memset(&m, 0, sizeof(m));
1948 m.name = "error";
1949 name = "testsuite";
1950
1951 explainer = pr_error_register_explainer(p, &m, name);
1952 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
1953 name, strerror(errno));
1954
1955 res = pr_error_explain_fstatfs(err, -1, NULL);
1956 fail_unless(res < 0, "Unexpectedly explained error");
1957 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
1958 strerror(errno), errno);
1959
1960 explainer->explain_fstatfs = test_explain_fstatfs;
1961 test_explain_return_eperm = TRUE;
1962
1963 res = pr_error_explain_fstatfs(err, -1, NULL);
1964 fail_unless(res < 0, "Unexpectedly explained error");
1965 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
1966 strerror(errno), errno);
1967
1968 test_explain_return_eperm = FALSE;
1969 res = pr_error_explain_fstatfs(err, -1, NULL);
1970 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
1971
1972 res = pr_error_unregister_explainer(p, &m, name);
1973 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
1974 strerror(errno));
1975
1976 pr_error_destroy(err);
1977 }
1978 END_TEST
1979
1980 /* fstatvfs */
test_explain_fstatvfs(pool * err_pool,int xerrno,int fd,void * stfs,const char ** args)1981 static const char *test_explain_fstatvfs(pool *err_pool, int xerrno, int fd,
1982 void *stfs, const char **args) {
1983
1984 if (test_explain_return_eperm == TRUE) {
1985 errno = EPERM;
1986 return NULL;
1987 }
1988
1989 return pstrdup(err_pool, "it was not meant to be");
1990 }
1991
START_TEST(error_explain_fstatvfs_test)1992 START_TEST (error_explain_fstatvfs_test) {
1993 int res, xerrno;
1994 pr_error_t *err;
1995 pr_error_explainer_t *explainer;
1996 module m;
1997 const char *name;
1998
1999 res = pr_error_explain_fstatvfs(NULL, -1, NULL);
2000 fail_unless(res < 0, "Failed to handle null error");
2001 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2002 strerror(errno), errno);
2003
2004 xerrno = EINVAL;
2005 err = pr_error_create(p, xerrno);
2006 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2007
2008 res = pr_error_explain_fstatvfs(err, -1, NULL);
2009 fail_unless(res < 0, "Unexpectedly explained error");
2010 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2011 strerror(errno), errno);
2012
2013 memset(&m, 0, sizeof(m));
2014 m.name = "error";
2015 name = "testsuite";
2016
2017 explainer = pr_error_register_explainer(p, &m, name);
2018 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2019 name, strerror(errno));
2020
2021 res = pr_error_explain_fstatvfs(err, -1, NULL);
2022 fail_unless(res < 0, "Unexpectedly explained error");
2023 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2024 strerror(errno), errno);
2025
2026 explainer->explain_fstatvfs = test_explain_fstatvfs;
2027 test_explain_return_eperm = TRUE;
2028
2029 res = pr_error_explain_fstatvfs(err, -1, NULL);
2030 fail_unless(res < 0, "Unexpectedly explained error");
2031 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2032 strerror(errno), errno);
2033
2034 test_explain_return_eperm = FALSE;
2035 res = pr_error_explain_fstatvfs(err, -1, NULL);
2036 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2037
2038 res = pr_error_unregister_explainer(p, &m, name);
2039 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2040 strerror(errno));
2041
2042 pr_error_destroy(err);
2043 }
2044 END_TEST
2045
2046 /* fsync */
test_explain_fsync(pool * err_pool,int xerrno,int fd,const char ** args)2047 static const char *test_explain_fsync(pool *err_pool, int xerrno, int fd,
2048 const char **args) {
2049
2050 if (test_explain_return_eperm == TRUE) {
2051 errno = EPERM;
2052 return NULL;
2053 }
2054
2055 return pstrdup(err_pool, "it was not meant to be");
2056 }
2057
START_TEST(error_explain_fsync_test)2058 START_TEST (error_explain_fsync_test) {
2059 int res, xerrno;
2060 pr_error_t *err;
2061 pr_error_explainer_t *explainer;
2062 module m;
2063 const char *name;
2064
2065 res = pr_error_explain_fsync(NULL, -1);
2066 fail_unless(res < 0, "Failed to handle null error");
2067 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2068 strerror(errno), errno);
2069
2070 xerrno = EINVAL;
2071 err = pr_error_create(p, xerrno);
2072 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2073
2074 res = pr_error_explain_fsync(err, -1);
2075 fail_unless(res < 0, "Unexpectedly explained error");
2076 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2077 strerror(errno), errno);
2078
2079 memset(&m, 0, sizeof(m));
2080 m.name = "error";
2081 name = "testsuite";
2082
2083 explainer = pr_error_register_explainer(p, &m, name);
2084 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2085 name, strerror(errno));
2086
2087 res = pr_error_explain_fsync(err, -1);
2088 fail_unless(res < 0, "Unexpectedly explained error");
2089 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2090 strerror(errno), errno);
2091
2092 explainer->explain_fsync = test_explain_fsync;
2093 test_explain_return_eperm = TRUE;
2094
2095 res = pr_error_explain_fsync(err, -1);
2096 fail_unless(res < 0, "Unexpectedly explained error");
2097 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2098 strerror(errno), errno);
2099
2100 test_explain_return_eperm = FALSE;
2101 res = pr_error_explain_fsync(err, -1);
2102 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2103
2104 res = pr_error_unregister_explainer(p, &m, name);
2105 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2106 strerror(errno));
2107
2108 pr_error_destroy(err);
2109 }
2110 END_TEST
2111
2112 /* ftruncate */
test_explain_ftruncate(pool * err_pool,int xerrno,int fd,off_t len,const char ** args)2113 static const char *test_explain_ftruncate(pool *err_pool, int xerrno, int fd,
2114 off_t len, const char **args) {
2115
2116 if (test_explain_return_eperm == TRUE) {
2117 errno = EPERM;
2118 return NULL;
2119 }
2120
2121 return pstrdup(err_pool, "it was not meant to be");
2122 }
2123
START_TEST(error_explain_ftruncate_test)2124 START_TEST (error_explain_ftruncate_test) {
2125 int res, xerrno;
2126 pr_error_t *err;
2127 pr_error_explainer_t *explainer;
2128 module m;
2129 const char *name;
2130
2131 res = pr_error_explain_ftruncate(NULL, -1, 0);
2132 fail_unless(res < 0, "Failed to handle null error");
2133 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2134 strerror(errno), errno);
2135
2136 xerrno = EINVAL;
2137 err = pr_error_create(p, xerrno);
2138 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2139
2140 res = pr_error_explain_ftruncate(err, -1, 0);
2141 fail_unless(res < 0, "Unexpectedly explained error");
2142 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2143 strerror(errno), errno);
2144
2145 memset(&m, 0, sizeof(m));
2146 m.name = "error";
2147 name = "testsuite";
2148
2149 explainer = pr_error_register_explainer(p, &m, name);
2150 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2151 name, strerror(errno));
2152
2153 res = pr_error_explain_ftruncate(err, -1, 0);
2154 fail_unless(res < 0, "Unexpectedly explained error");
2155 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2156 strerror(errno), errno);
2157
2158 explainer->explain_ftruncate = test_explain_ftruncate;
2159 test_explain_return_eperm = TRUE;
2160
2161 res = pr_error_explain_ftruncate(err, -1, 0);
2162 fail_unless(res < 0, "Unexpectedly explained error");
2163 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2164 strerror(errno), errno);
2165
2166 test_explain_return_eperm = FALSE;
2167 res = pr_error_explain_ftruncate(err, -1, 0);
2168 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2169
2170 res = pr_error_unregister_explainer(p, &m, name);
2171 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2172 strerror(errno));
2173
2174 pr_error_destroy(err);
2175 }
2176 END_TEST
2177
2178 /* futimes */
test_explain_futimes(pool * err_pool,int xerrno,int fd,const struct timeval * tvs,const char ** args)2179 static const char *test_explain_futimes(pool *err_pool, int xerrno, int fd,
2180 const struct timeval *tvs, const char **args) {
2181
2182 if (test_explain_return_eperm == TRUE) {
2183 errno = EPERM;
2184 return NULL;
2185 }
2186
2187 return pstrdup(err_pool, "it was not meant to be");
2188 }
2189
START_TEST(error_explain_futimes_test)2190 START_TEST (error_explain_futimes_test) {
2191 int res, xerrno;
2192 pr_error_t *err;
2193 pr_error_explainer_t *explainer;
2194 module m;
2195 const char *name;
2196
2197 res = pr_error_explain_futimes(NULL, -1, NULL);
2198 fail_unless(res < 0, "Failed to handle null error");
2199 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2200 strerror(errno), errno);
2201
2202 xerrno = EINVAL;
2203 err = pr_error_create(p, xerrno);
2204 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2205
2206 res = pr_error_explain_futimes(err, -1, NULL);
2207 fail_unless(res < 0, "Unexpectedly explained error");
2208 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2209 strerror(errno), errno);
2210
2211 memset(&m, 0, sizeof(m));
2212 m.name = "error";
2213 name = "testsuite";
2214
2215 explainer = pr_error_register_explainer(p, &m, name);
2216 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2217 name, strerror(errno));
2218
2219 res = pr_error_explain_futimes(err, -1, NULL);
2220 fail_unless(res < 0, "Unexpectedly explained error");
2221 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2222 strerror(errno), errno);
2223
2224 explainer->explain_futimes = test_explain_futimes;
2225 test_explain_return_eperm = TRUE;
2226
2227 res = pr_error_explain_futimes(err, -1, NULL);
2228 fail_unless(res < 0, "Unexpectedly explained error");
2229 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2230 strerror(errno), errno);
2231
2232 test_explain_return_eperm = FALSE;
2233 res = pr_error_explain_futimes(err, -1, NULL);
2234 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2235
2236 res = pr_error_unregister_explainer(p, &m, name);
2237 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2238 strerror(errno));
2239
2240 pr_error_destroy(err);
2241 }
2242 END_TEST
2243
2244 /* getaddrinfo */
test_explain_getaddrinfo(pool * err_pool,int xerrno,const char * name,const char * service,const struct addrinfo * hints,struct addrinfo ** res,const char ** args)2245 static const char *test_explain_getaddrinfo(pool *err_pool, int xerrno,
2246 const char *name, const char *service, const struct addrinfo *hints,
2247 struct addrinfo **res, const char **args) {
2248
2249 if (test_explain_return_eperm == TRUE) {
2250 errno = EPERM;
2251 return NULL;
2252 }
2253
2254 return pstrdup(err_pool, "it was not meant to be");
2255 }
2256
START_TEST(error_explain_getaddrinfo_test)2257 START_TEST (error_explain_getaddrinfo_test) {
2258 int res, xerrno;
2259 pr_error_t *err;
2260 pr_error_explainer_t *explainer;
2261 module m;
2262 const char *name;
2263
2264 res = pr_error_explain_getaddrinfo(NULL, NULL, NULL, NULL, NULL);
2265 fail_unless(res < 0, "Failed to handle null error");
2266 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2267 strerror(errno), errno);
2268
2269 xerrno = EINVAL;
2270 err = pr_error_create(p, xerrno);
2271 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2272
2273 res = pr_error_explain_getaddrinfo(err, NULL, NULL, NULL, NULL);
2274 fail_unless(res < 0, "Unexpectedly explained error");
2275 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2276 strerror(errno), errno);
2277
2278 memset(&m, 0, sizeof(m));
2279 m.name = "error";
2280 name = "testsuite";
2281
2282 explainer = pr_error_register_explainer(p, &m, name);
2283 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2284 name, strerror(errno));
2285
2286 res = pr_error_explain_getaddrinfo(err, NULL, NULL, NULL, NULL);
2287 fail_unless(res < 0, "Unexpectedly explained error");
2288 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2289 strerror(errno), errno);
2290
2291 explainer->explain_getaddrinfo = test_explain_getaddrinfo;
2292 test_explain_return_eperm = TRUE;
2293
2294 res = pr_error_explain_getaddrinfo(err, NULL, NULL, NULL, NULL);
2295 fail_unless(res < 0, "Unexpectedly explained error");
2296 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2297 strerror(errno), errno);
2298
2299 test_explain_return_eperm = FALSE;
2300 res = pr_error_explain_getaddrinfo(err, NULL, NULL, NULL, NULL);
2301 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2302
2303 res = pr_error_unregister_explainer(p, &m, name);
2304 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2305 strerror(errno));
2306
2307 pr_error_destroy(err);
2308 }
2309 END_TEST
2310
2311 /* gethostbyname */
test_explain_gethostbyname(pool * err_pool,int xerrno,const char * name,const char ** args)2312 static const char *test_explain_gethostbyname(pool *err_pool, int xerrno,
2313 const char *name, const char **args) {
2314
2315 if (test_explain_return_eperm == TRUE) {
2316 errno = EPERM;
2317 return NULL;
2318 }
2319
2320 return pstrdup(err_pool, "it was not meant to be");
2321 }
2322
START_TEST(error_explain_gethostbyname_test)2323 START_TEST (error_explain_gethostbyname_test) {
2324 int res, xerrno;
2325 pr_error_t *err;
2326 pr_error_explainer_t *explainer;
2327 module m;
2328 const char *name;
2329
2330 res = pr_error_explain_gethostbyname(NULL, NULL);
2331 fail_unless(res < 0, "Failed to handle null error");
2332 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2333 strerror(errno), errno);
2334
2335 xerrno = EINVAL;
2336 err = pr_error_create(p, xerrno);
2337 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2338
2339 res = pr_error_explain_gethostbyname(err, NULL);
2340 fail_unless(res < 0, "Unexpectedly explained error");
2341 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2342 strerror(errno), errno);
2343
2344 memset(&m, 0, sizeof(m));
2345 m.name = "error";
2346 name = "testsuite";
2347
2348 explainer = pr_error_register_explainer(p, &m, name);
2349 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2350 name, strerror(errno));
2351
2352 res = pr_error_explain_gethostbyname(err, NULL);
2353 fail_unless(res < 0, "Unexpectedly explained error");
2354 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2355 strerror(errno), errno);
2356
2357 explainer->explain_gethostbyname = test_explain_gethostbyname;
2358 test_explain_return_eperm = TRUE;
2359
2360 res = pr_error_explain_gethostbyname(err, NULL);
2361 fail_unless(res < 0, "Unexpectedly explained error");
2362 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2363 strerror(errno), errno);
2364
2365 test_explain_return_eperm = FALSE;
2366 res = pr_error_explain_gethostbyname(err, NULL);
2367 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2368
2369 res = pr_error_unregister_explainer(p, &m, name);
2370 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2371 strerror(errno));
2372
2373 pr_error_destroy(err);
2374 }
2375 END_TEST
2376
2377 /* gethostbyname2 */
test_explain_gethostbyname2(pool * err_pool,int xerrno,const char * name,int family,const char ** args)2378 static const char *test_explain_gethostbyname2(pool *err_pool, int xerrno,
2379 const char *name, int family, const char **args) {
2380
2381 if (test_explain_return_eperm == TRUE) {
2382 errno = EPERM;
2383 return NULL;
2384 }
2385
2386 return pstrdup(err_pool, "it was not meant to be");
2387 }
2388
START_TEST(error_explain_gethostbyname2_test)2389 START_TEST (error_explain_gethostbyname2_test) {
2390 int res, xerrno;
2391 pr_error_t *err;
2392 pr_error_explainer_t *explainer;
2393 module m;
2394 const char *name;
2395
2396 res = pr_error_explain_gethostbyname2(NULL, NULL, 0);
2397 fail_unless(res < 0, "Failed to handle null error");
2398 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2399 strerror(errno), errno);
2400
2401 xerrno = EINVAL;
2402 err = pr_error_create(p, xerrno);
2403 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2404
2405 res = pr_error_explain_gethostbyname2(err, NULL, 0);
2406 fail_unless(res < 0, "Unexpectedly explained error");
2407 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2408 strerror(errno), errno);
2409
2410 memset(&m, 0, sizeof(m));
2411 m.name = "error";
2412 name = "testsuite";
2413
2414 explainer = pr_error_register_explainer(p, &m, name);
2415 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2416 name, strerror(errno));
2417
2418 res = pr_error_explain_gethostbyname2(err, NULL, 0);
2419 fail_unless(res < 0, "Unexpectedly explained error");
2420 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2421 strerror(errno), errno);
2422
2423 explainer->explain_gethostbyname2 = test_explain_gethostbyname2;
2424 test_explain_return_eperm = TRUE;
2425
2426 res = pr_error_explain_gethostbyname2(err, NULL, 0);
2427 fail_unless(res < 0, "Unexpectedly explained error");
2428 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2429 strerror(errno), errno);
2430
2431 test_explain_return_eperm = FALSE;
2432 res = pr_error_explain_gethostbyname2(err, NULL, 0);
2433 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2434
2435 res = pr_error_unregister_explainer(p, &m, name);
2436 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2437 strerror(errno));
2438
2439 pr_error_destroy(err);
2440 }
2441 END_TEST
2442
2443 /* gethostname */
test_explain_gethostname(pool * err_pool,int xerrno,char * buf,size_t sz,const char ** args)2444 static const char *test_explain_gethostname(pool *err_pool, int xerrno,
2445 char *buf, size_t sz, const char **args) {
2446
2447 if (test_explain_return_eperm == TRUE) {
2448 errno = EPERM;
2449 return NULL;
2450 }
2451
2452 return pstrdup(err_pool, "it was not meant to be");
2453 }
2454
START_TEST(error_explain_gethostname_test)2455 START_TEST (error_explain_gethostname_test) {
2456 int res, xerrno;
2457 pr_error_t *err;
2458 pr_error_explainer_t *explainer;
2459 module m;
2460 const char *name;
2461
2462 res = pr_error_explain_gethostname(NULL, NULL, 0);
2463 fail_unless(res < 0, "Failed to handle null error");
2464 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2465 strerror(errno), errno);
2466
2467 xerrno = EINVAL;
2468 err = pr_error_create(p, xerrno);
2469 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2470
2471 res = pr_error_explain_gethostname(err, NULL, 0);
2472 fail_unless(res < 0, "Unexpectedly explained error");
2473 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2474 strerror(errno), errno);
2475
2476 memset(&m, 0, sizeof(m));
2477 m.name = "error";
2478 name = "testsuite";
2479
2480 explainer = pr_error_register_explainer(p, &m, name);
2481 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2482 name, strerror(errno));
2483
2484 res = pr_error_explain_gethostname(err, NULL, 0);
2485 fail_unless(res < 0, "Unexpectedly explained error");
2486 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2487 strerror(errno), errno);
2488
2489 explainer->explain_gethostname = test_explain_gethostname;
2490 test_explain_return_eperm = TRUE;
2491
2492 res = pr_error_explain_gethostname(err, NULL, 0);
2493 fail_unless(res < 0, "Unexpectedly explained error");
2494 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2495 strerror(errno), errno);
2496
2497 test_explain_return_eperm = FALSE;
2498 res = pr_error_explain_gethostname(err, NULL, 0);
2499 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2500
2501 res = pr_error_unregister_explainer(p, &m, name);
2502 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2503 strerror(errno));
2504
2505 pr_error_destroy(err);
2506 }
2507 END_TEST
2508
2509 /* getnameinfo */
test_explain_getnameinfo(pool * err_pool,int xerrno,const struct sockaddr * addr,socklen_t addr_len,char * host,size_t host_len,char * service,size_t service_len,int flags,const char ** args)2510 static const char *test_explain_getnameinfo(pool *err_pool, int xerrno,
2511 const struct sockaddr *addr, socklen_t addr_len,
2512 char *host, size_t host_len, char *service, size_t service_len, int flags,
2513 const char **args) {
2514
2515 if (test_explain_return_eperm == TRUE) {
2516 errno = EPERM;
2517 return NULL;
2518 }
2519
2520 return pstrdup(err_pool, "it was not meant to be");
2521 }
2522
START_TEST(error_explain_getnameinfo_test)2523 START_TEST (error_explain_getnameinfo_test) {
2524 int res, xerrno;
2525 pr_error_t *err;
2526 pr_error_explainer_t *explainer;
2527 module m;
2528 const char *name;
2529
2530 res = pr_error_explain_getnameinfo(NULL, NULL, 0, NULL, 0, NULL, 0, 0);
2531 fail_unless(res < 0, "Failed to handle null error");
2532 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2533 strerror(errno), errno);
2534
2535 xerrno = EINVAL;
2536 err = pr_error_create(p, xerrno);
2537 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2538
2539 res = pr_error_explain_getnameinfo(err, NULL, 0, NULL, 0, NULL, 0, 0);
2540 fail_unless(res < 0, "Unexpectedly explained error");
2541 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2542 strerror(errno), errno);
2543
2544 memset(&m, 0, sizeof(m));
2545 m.name = "error";
2546 name = "testsuite";
2547
2548 explainer = pr_error_register_explainer(p, &m, name);
2549 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2550 name, strerror(errno));
2551
2552 res = pr_error_explain_getnameinfo(err, NULL, 0, NULL, 0, NULL, 0, 0);
2553 fail_unless(res < 0, "Unexpectedly explained error");
2554 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2555 strerror(errno), errno);
2556
2557 explainer->explain_getnameinfo = test_explain_getnameinfo;
2558 test_explain_return_eperm = TRUE;
2559
2560 res = pr_error_explain_getnameinfo(err, NULL, 0, NULL, 0, NULL, 0, 0);
2561 fail_unless(res < 0, "Unexpectedly explained error");
2562 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2563 strerror(errno), errno);
2564
2565 test_explain_return_eperm = FALSE;
2566 res = pr_error_explain_getnameinfo(err, NULL, 0, NULL, 0, NULL, 0, 0);
2567 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2568
2569 res = pr_error_unregister_explainer(p, &m, name);
2570 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2571 strerror(errno));
2572
2573 pr_error_destroy(err);
2574 }
2575 END_TEST
2576
2577 /* getpeername */
test_explain_getpeername(pool * err_pool,int xerrno,int fd,struct sockaddr * addr,socklen_t * addr_len,const char ** args)2578 static const char *test_explain_getpeername(pool *err_pool, int xerrno,
2579 int fd, struct sockaddr *addr, socklen_t *addr_len, const char **args) {
2580
2581 if (test_explain_return_eperm == TRUE) {
2582 errno = EPERM;
2583 return NULL;
2584 }
2585
2586 return pstrdup(err_pool, "it was not meant to be");
2587 }
2588
START_TEST(error_explain_getpeername_test)2589 START_TEST (error_explain_getpeername_test) {
2590 int res, xerrno;
2591 pr_error_t *err;
2592 pr_error_explainer_t *explainer;
2593 module m;
2594 const char *name;
2595
2596 res = pr_error_explain_getpeername(NULL, -1, NULL, 0);
2597 fail_unless(res < 0, "Failed to handle null error");
2598 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2599 strerror(errno), errno);
2600
2601 xerrno = EINVAL;
2602 err = pr_error_create(p, xerrno);
2603 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2604
2605 res = pr_error_explain_getpeername(err, -1, NULL, 0);
2606 fail_unless(res < 0, "Unexpectedly explained error");
2607 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2608 strerror(errno), errno);
2609
2610 memset(&m, 0, sizeof(m));
2611 m.name = "error";
2612 name = "testsuite";
2613
2614 explainer = pr_error_register_explainer(p, &m, name);
2615 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2616 name, strerror(errno));
2617
2618 res = pr_error_explain_getpeername(err, -1, NULL, 0);
2619 fail_unless(res < 0, "Unexpectedly explained error");
2620 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2621 strerror(errno), errno);
2622
2623 explainer->explain_getpeername = test_explain_getpeername;
2624 test_explain_return_eperm = TRUE;
2625
2626 res = pr_error_explain_getpeername(err, -1, NULL, 0);
2627 fail_unless(res < 0, "Unexpectedly explained error");
2628 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2629 strerror(errno), errno);
2630
2631 test_explain_return_eperm = FALSE;
2632 res = pr_error_explain_getpeername(err, -1, NULL, 0);
2633 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2634
2635 res = pr_error_unregister_explainer(p, &m, name);
2636 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2637 strerror(errno));
2638
2639 pr_error_destroy(err);
2640 }
2641 END_TEST
2642
2643 /* getrlimit */
test_explain_getrlimit(pool * err_pool,int xerrno,int resource,struct rlimit * rlim,const char ** args)2644 static const char *test_explain_getrlimit(pool *err_pool, int xerrno,
2645 int resource, struct rlimit *rlim, const char **args) {
2646
2647 if (test_explain_return_eperm == TRUE) {
2648 errno = EPERM;
2649 return NULL;
2650 }
2651
2652 return pstrdup(err_pool, "it was not meant to be");
2653 }
2654
START_TEST(error_explain_getrlimit_test)2655 START_TEST (error_explain_getrlimit_test) {
2656 int res, xerrno;
2657 pr_error_t *err;
2658 pr_error_explainer_t *explainer;
2659 module m;
2660 const char *name;
2661
2662 res = pr_error_explain_getrlimit(NULL, -1, NULL);
2663 fail_unless(res < 0, "Failed to handle null error");
2664 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2665 strerror(errno), errno);
2666
2667 xerrno = EINVAL;
2668 err = pr_error_create(p, xerrno);
2669 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2670
2671 res = pr_error_explain_getrlimit(err, -1, NULL);
2672 fail_unless(res < 0, "Unexpectedly explained error");
2673 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2674 strerror(errno), errno);
2675
2676 memset(&m, 0, sizeof(m));
2677 m.name = "error";
2678 name = "testsuite";
2679
2680 explainer = pr_error_register_explainer(p, &m, name);
2681 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2682 name, strerror(errno));
2683
2684 res = pr_error_explain_getrlimit(err, -1, NULL);
2685 fail_unless(res < 0, "Unexpectedly explained error");
2686 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2687 strerror(errno), errno);
2688
2689 explainer->explain_getrlimit = test_explain_getrlimit;
2690 test_explain_return_eperm = TRUE;
2691
2692 res = pr_error_explain_getrlimit(err, -1, NULL);
2693 fail_unless(res < 0, "Unexpectedly explained error");
2694 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2695 strerror(errno), errno);
2696
2697 test_explain_return_eperm = FALSE;
2698 res = pr_error_explain_getrlimit(err, -1, NULL);
2699 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2700
2701 res = pr_error_unregister_explainer(p, &m, name);
2702 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2703 strerror(errno));
2704
2705 pr_error_destroy(err);
2706 }
2707 END_TEST
2708
2709 /* getsockname */
test_explain_getsockname(pool * err_pool,int xerrno,int fd,struct sockaddr * addr,socklen_t * addr_len,const char ** args)2710 static const char *test_explain_getsockname(pool *err_pool, int xerrno,
2711 int fd, struct sockaddr *addr, socklen_t *addr_len, const char **args) {
2712
2713 if (test_explain_return_eperm == TRUE) {
2714 errno = EPERM;
2715 return NULL;
2716 }
2717
2718 return pstrdup(err_pool, "it was not meant to be");
2719 }
2720
START_TEST(error_explain_getsockname_test)2721 START_TEST (error_explain_getsockname_test) {
2722 int res, xerrno;
2723 pr_error_t *err;
2724 pr_error_explainer_t *explainer;
2725 module m;
2726 const char *name;
2727
2728 res = pr_error_explain_getsockname(NULL, -1, NULL, NULL);
2729 fail_unless(res < 0, "Failed to handle null error");
2730 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2731 strerror(errno), errno);
2732
2733 xerrno = EINVAL;
2734 err = pr_error_create(p, xerrno);
2735 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2736
2737 res = pr_error_explain_getsockname(err, -1, NULL, NULL);
2738 fail_unless(res < 0, "Unexpectedly explained error");
2739 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2740 strerror(errno), errno);
2741
2742 memset(&m, 0, sizeof(m));
2743 m.name = "error";
2744 name = "testsuite";
2745
2746 explainer = pr_error_register_explainer(p, &m, name);
2747 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2748 name, strerror(errno));
2749
2750 res = pr_error_explain_getsockname(err, -1, NULL, NULL);
2751 fail_unless(res < 0, "Unexpectedly explained error");
2752 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2753 strerror(errno), errno);
2754
2755 explainer->explain_getsockname = test_explain_getsockname;
2756 test_explain_return_eperm = TRUE;
2757
2758 res = pr_error_explain_getsockname(err, -1, NULL, NULL);
2759 fail_unless(res < 0, "Unexpectedly explained error");
2760 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2761 strerror(errno), errno);
2762
2763 test_explain_return_eperm = FALSE;
2764 res = pr_error_explain_getsockname(err, -1, NULL, NULL);
2765 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2766
2767 res = pr_error_unregister_explainer(p, &m, name);
2768 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2769 strerror(errno));
2770
2771 pr_error_destroy(err);
2772 }
2773 END_TEST
2774
2775 /* getsockopt */
test_explain_getsockopt(pool * err_pool,int xerrno,int fd,int level,int option,void * val,socklen_t * valsz,const char ** args)2776 static const char *test_explain_getsockopt(pool *err_pool, int xerrno,
2777 int fd, int level, int option, void *val, socklen_t *valsz,
2778 const char **args) {
2779
2780 if (test_explain_return_eperm == TRUE) {
2781 errno = EPERM;
2782 return NULL;
2783 }
2784
2785 return pstrdup(err_pool, "it was not meant to be");
2786 }
2787
START_TEST(error_explain_getsockopt_test)2788 START_TEST (error_explain_getsockopt_test) {
2789 int res, xerrno;
2790 pr_error_t *err;
2791 pr_error_explainer_t *explainer;
2792 module m;
2793 const char *name;
2794
2795 res = pr_error_explain_getsockopt(NULL, -1, -1, -1, NULL, NULL);
2796 fail_unless(res < 0, "Failed to handle null error");
2797 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2798 strerror(errno), errno);
2799
2800 xerrno = EINVAL;
2801 err = pr_error_create(p, xerrno);
2802 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2803
2804 res = pr_error_explain_getsockopt(err, -1, -1, -1, NULL, NULL);
2805 fail_unless(res < 0, "Unexpectedly explained error");
2806 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2807 strerror(errno), errno);
2808
2809 memset(&m, 0, sizeof(m));
2810 m.name = "error";
2811 name = "testsuite";
2812
2813 explainer = pr_error_register_explainer(p, &m, name);
2814 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2815 name, strerror(errno));
2816
2817 res = pr_error_explain_getsockopt(err, -1, -1, -1, NULL, NULL);
2818 fail_unless(res < 0, "Unexpectedly explained error");
2819 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2820 strerror(errno), errno);
2821
2822 explainer->explain_getsockopt = test_explain_getsockopt;
2823 test_explain_return_eperm = TRUE;
2824
2825 res = pr_error_explain_getsockopt(err, -1, -1, -1, NULL, NULL);
2826 fail_unless(res < 0, "Unexpectedly explained error");
2827 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2828 strerror(errno), errno);
2829
2830 test_explain_return_eperm = FALSE;
2831 res = pr_error_explain_getsockopt(err, -1, -1, -1, NULL, NULL);
2832 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2833
2834 res = pr_error_unregister_explainer(p, &m, name);
2835 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2836 strerror(errno));
2837
2838 pr_error_destroy(err);
2839 }
2840 END_TEST
2841
2842 /* lchown */
test_explain_lchown(pool * err_pool,int xerrno,const char * path,uid_t uid,gid_t gid,const char ** args)2843 static const char *test_explain_lchown(pool *err_pool, int xerrno,
2844 const char *path, uid_t uid, gid_t gid, const char **args) {
2845
2846 if (test_explain_return_eperm == TRUE) {
2847 errno = EPERM;
2848 return NULL;
2849 }
2850
2851 return pstrdup(err_pool, "it was not meant to be");
2852 }
2853
START_TEST(error_explain_lchown_test)2854 START_TEST (error_explain_lchown_test) {
2855 int res, xerrno;
2856 pr_error_t *err;
2857 pr_error_explainer_t *explainer;
2858 module m;
2859 const char *name;
2860
2861 res = pr_error_explain_lchown(NULL, NULL, -1, -1);
2862 fail_unless(res < 0, "Failed to handle null error");
2863 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2864 strerror(errno), errno);
2865
2866 xerrno = EINVAL;
2867 err = pr_error_create(p, xerrno);
2868 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2869
2870 res = pr_error_explain_lchown(err, NULL, -1, -1);
2871 fail_unless(res < 0, "Unexpectedly explained error");
2872 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2873 strerror(errno), errno);
2874
2875 memset(&m, 0, sizeof(m));
2876 m.name = "error";
2877 name = "testsuite";
2878
2879 explainer = pr_error_register_explainer(p, &m, name);
2880 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2881 name, strerror(errno));
2882
2883 res = pr_error_explain_lchown(err, NULL, -1, -1);
2884 fail_unless(res < 0, "Unexpectedly explained error");
2885 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2886 strerror(errno), errno);
2887
2888 explainer->explain_lchown = test_explain_lchown;
2889 test_explain_return_eperm = TRUE;
2890
2891 res = pr_error_explain_lchown(err, NULL, -1, -1);
2892 fail_unless(res < 0, "Unexpectedly explained error");
2893 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2894 strerror(errno), errno);
2895
2896 test_explain_return_eperm = FALSE;
2897 res = pr_error_explain_lchown(err, NULL, -1, -1);
2898 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2899
2900 res = pr_error_unregister_explainer(p, &m, name);
2901 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2902 strerror(errno));
2903
2904 pr_error_destroy(err);
2905 }
2906 END_TEST
2907
2908 /* link */
test_explain_link(pool * err_pool,int xerrno,const char * target_path,const char * link_path,const char ** args)2909 static const char *test_explain_link(pool *err_pool, int xerrno,
2910 const char *target_path, const char *link_path, const char **args) {
2911
2912 if (test_explain_return_eperm == TRUE) {
2913 errno = EPERM;
2914 return NULL;
2915 }
2916
2917 return pstrdup(err_pool, "it was not meant to be");
2918 }
2919
START_TEST(error_explain_link_test)2920 START_TEST (error_explain_link_test) {
2921 int res, xerrno;
2922 pr_error_t *err;
2923 pr_error_explainer_t *explainer;
2924 module m;
2925 const char *name;
2926
2927 res = pr_error_explain_link(NULL, NULL, NULL);
2928 fail_unless(res < 0, "Failed to handle null error");
2929 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2930 strerror(errno), errno);
2931
2932 xerrno = EINVAL;
2933 err = pr_error_create(p, xerrno);
2934 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
2935
2936 res = pr_error_explain_link(err, NULL, NULL);
2937 fail_unless(res < 0, "Unexpectedly explained error");
2938 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2939 strerror(errno), errno);
2940
2941 memset(&m, 0, sizeof(m));
2942 m.name = "error";
2943 name = "testsuite";
2944
2945 explainer = pr_error_register_explainer(p, &m, name);
2946 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
2947 name, strerror(errno));
2948
2949 res = pr_error_explain_link(err, NULL, NULL);
2950 fail_unless(res < 0, "Unexpectedly explained error");
2951 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
2952 strerror(errno), errno);
2953
2954 explainer->explain_link = test_explain_link;
2955 test_explain_return_eperm = TRUE;
2956
2957 res = pr_error_explain_link(err, NULL, NULL);
2958 fail_unless(res < 0, "Unexpectedly explained error");
2959 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
2960 strerror(errno), errno);
2961
2962 test_explain_return_eperm = FALSE;
2963 res = pr_error_explain_link(err, NULL, NULL);
2964 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
2965
2966 res = pr_error_unregister_explainer(p, &m, name);
2967 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
2968 strerror(errno));
2969
2970 pr_error_destroy(err);
2971 }
2972 END_TEST
2973
2974 /* listen */
test_explain_listen(pool * err_pool,int xerrno,int fd,int backlog,const char ** args)2975 static const char *test_explain_listen(pool *err_pool, int xerrno, int fd,
2976 int backlog, const char **args) {
2977
2978 if (test_explain_return_eperm == TRUE) {
2979 errno = EPERM;
2980 return NULL;
2981 }
2982
2983 return pstrdup(err_pool, "it was not meant to be");
2984 }
2985
START_TEST(error_explain_listen_test)2986 START_TEST (error_explain_listen_test) {
2987 int res, xerrno;
2988 pr_error_t *err;
2989 pr_error_explainer_t *explainer;
2990 module m;
2991 const char *name;
2992
2993 res = pr_error_explain_listen(NULL, -1, -1);
2994 fail_unless(res < 0, "Failed to handle null error");
2995 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
2996 strerror(errno), errno);
2997
2998 xerrno = EINVAL;
2999 err = pr_error_create(p, xerrno);
3000 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3001
3002 res = pr_error_explain_listen(err, -1, -1);
3003 fail_unless(res < 0, "Unexpectedly explained error");
3004 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3005 strerror(errno), errno);
3006
3007 memset(&m, 0, sizeof(m));
3008 m.name = "error";
3009 name = "testsuite";
3010
3011 explainer = pr_error_register_explainer(p, &m, name);
3012 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3013 name, strerror(errno));
3014
3015 res = pr_error_explain_listen(err, -1, -1);
3016 fail_unless(res < 0, "Unexpectedly explained error");
3017 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3018 strerror(errno), errno);
3019
3020 explainer->explain_listen = test_explain_listen;
3021 test_explain_return_eperm = TRUE;
3022
3023 res = pr_error_explain_listen(err, -1, -1);
3024 fail_unless(res < 0, "Unexpectedly explained error");
3025 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3026 strerror(errno), errno);
3027
3028 test_explain_return_eperm = FALSE;
3029 res = pr_error_explain_listen(err, -1, -1);
3030 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3031
3032 res = pr_error_unregister_explainer(p, &m, name);
3033 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3034 strerror(errno));
3035
3036 pr_error_destroy(err);
3037 }
3038 END_TEST
3039
3040 /* lseek */
test_explain_lseek(pool * err_pool,int xerrno,int fd,off_t offset,int whence,const char ** args)3041 static const char *test_explain_lseek(pool *err_pool, int xerrno, int fd,
3042 off_t offset, int whence, const char **args) {
3043
3044 if (test_explain_return_eperm == TRUE) {
3045 errno = EPERM;
3046 return NULL;
3047 }
3048
3049 return pstrdup(err_pool, "it was not meant to be");
3050 }
3051
START_TEST(error_explain_lseek_test)3052 START_TEST (error_explain_lseek_test) {
3053 int res, xerrno;
3054 pr_error_t *err;
3055 pr_error_explainer_t *explainer;
3056 module m;
3057 const char *name;
3058
3059 res = pr_error_explain_lseek(NULL, -1, 0, -1);
3060 fail_unless(res < 0, "Failed to handle null error");
3061 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3062 strerror(errno), errno);
3063
3064 xerrno = EINVAL;
3065 err = pr_error_create(p, xerrno);
3066 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3067
3068 res = pr_error_explain_lseek(err, -1, 0, -1);
3069 fail_unless(res < 0, "Unexpectedly explained error");
3070 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3071 strerror(errno), errno);
3072
3073 memset(&m, 0, sizeof(m));
3074 m.name = "error";
3075 name = "testsuite";
3076
3077 explainer = pr_error_register_explainer(p, &m, name);
3078 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3079 name, strerror(errno));
3080
3081 res = pr_error_explain_lseek(err, -1, 0, -1);
3082 fail_unless(res < 0, "Unexpectedly explained error");
3083 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3084 strerror(errno), errno);
3085
3086 explainer->explain_lseek = test_explain_lseek;
3087 test_explain_return_eperm = TRUE;
3088
3089 res = pr_error_explain_lseek(err, -1, 0, -1);
3090 fail_unless(res < 0, "Unexpectedly explained error");
3091 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3092 strerror(errno), errno);
3093
3094 test_explain_return_eperm = FALSE;
3095 res = pr_error_explain_lseek(err, -1, 0, -1);
3096 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3097
3098 res = pr_error_unregister_explainer(p, &m, name);
3099 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3100 strerror(errno));
3101
3102 pr_error_destroy(err);
3103 }
3104 END_TEST
3105
3106 /* lstat */
test_explain_lstat(pool * err_pool,int xerrno,const char * path,struct stat * st,const char ** args)3107 static const char *test_explain_lstat(pool *err_pool, int xerrno,
3108 const char *path, struct stat *st, const char **args) {
3109
3110 if (test_explain_return_eperm == TRUE) {
3111 errno = EPERM;
3112 return NULL;
3113 }
3114
3115 return pstrdup(err_pool, "it was not meant to be");
3116 }
3117
START_TEST(error_explain_lstat_test)3118 START_TEST (error_explain_lstat_test) {
3119 int res, xerrno;
3120 pr_error_t *err;
3121 pr_error_explainer_t *explainer;
3122 module m;
3123 const char *name;
3124
3125 res = pr_error_explain_lstat(NULL, NULL, NULL);
3126 fail_unless(res < 0, "Failed to handle null error");
3127 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3128 strerror(errno), errno);
3129
3130 xerrno = EINVAL;
3131 err = pr_error_create(p, xerrno);
3132 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3133
3134 res = pr_error_explain_lstat(err, NULL, NULL);
3135 fail_unless(res < 0, "Unexpectedly explained error");
3136 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3137 strerror(errno), errno);
3138
3139 memset(&m, 0, sizeof(m));
3140 m.name = "error";
3141 name = "testsuite";
3142
3143 explainer = pr_error_register_explainer(p, &m, name);
3144 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3145 name, strerror(errno));
3146
3147 res = pr_error_explain_lstat(err, NULL, NULL);
3148 fail_unless(res < 0, "Unexpectedly explained error");
3149 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3150 strerror(errno), errno);
3151
3152 explainer->explain_lstat = test_explain_lstat;
3153 test_explain_return_eperm = TRUE;
3154
3155 res = pr_error_explain_lstat(err, NULL, NULL);
3156 fail_unless(res < 0, "Unexpectedly explained error");
3157 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3158 strerror(errno), errno);
3159
3160 test_explain_return_eperm = FALSE;
3161 res = pr_error_explain_lstat(err, NULL, NULL);
3162 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3163
3164 res = pr_error_unregister_explainer(p, &m, name);
3165 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3166 strerror(errno));
3167
3168 pr_error_destroy(err);
3169 }
3170 END_TEST
3171
3172 /* mkdir */
test_explain_mkdir(pool * err_pool,int xerrno,const char * path,mode_t mode,const char ** args)3173 static const char *test_explain_mkdir(pool *err_pool, int xerrno,
3174 const char *path, mode_t mode, const char **args) {
3175
3176 if (test_explain_return_eperm == TRUE) {
3177 errno = EPERM;
3178 return NULL;
3179 }
3180
3181 return pstrdup(err_pool, "it was not meant to be");
3182 }
3183
START_TEST(error_explain_mkdir_test)3184 START_TEST (error_explain_mkdir_test) {
3185 int res, xerrno;
3186 pr_error_t *err;
3187 pr_error_explainer_t *explainer;
3188 module m;
3189 const char *name;
3190
3191 res = pr_error_explain_mkdir(NULL, NULL, 0);
3192 fail_unless(res < 0, "Failed to handle null error");
3193 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3194 strerror(errno), errno);
3195
3196 xerrno = EINVAL;
3197 err = pr_error_create(p, xerrno);
3198 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3199
3200 res = pr_error_explain_mkdir(err, NULL, 0);
3201 fail_unless(res < 0, "Unexpectedly explained error");
3202 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3203 strerror(errno), errno);
3204
3205 memset(&m, 0, sizeof(m));
3206 m.name = "error";
3207 name = "testsuite";
3208
3209 explainer = pr_error_register_explainer(p, &m, name);
3210 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3211 name, strerror(errno));
3212
3213 res = pr_error_explain_mkdir(err, NULL, 0);
3214 fail_unless(res < 0, "Unexpectedly explained error");
3215 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3216 strerror(errno), errno);
3217
3218 explainer->explain_mkdir = test_explain_mkdir;
3219 test_explain_return_eperm = TRUE;
3220
3221 res = pr_error_explain_mkdir(err, NULL, 0);
3222 fail_unless(res < 0, "Unexpectedly explained error");
3223 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3224 strerror(errno), errno);
3225
3226 test_explain_return_eperm = FALSE;
3227 res = pr_error_explain_mkdir(err, NULL, 0);
3228 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3229
3230 res = pr_error_unregister_explainer(p, &m, name);
3231 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3232 strerror(errno));
3233
3234 pr_error_destroy(err);
3235 }
3236 END_TEST
3237
3238 /* mkdtemp */
test_explain_mkdtemp(pool * err_pool,int xerrno,char * tmpl,const char ** args)3239 static const char *test_explain_mkdtemp(pool *err_pool, int xerrno,
3240 char *tmpl, const char **args) {
3241
3242 if (test_explain_return_eperm == TRUE) {
3243 errno = EPERM;
3244 return NULL;
3245 }
3246
3247 return pstrdup(err_pool, "it was not meant to be");
3248 }
3249
START_TEST(error_explain_mkdtemp_test)3250 START_TEST (error_explain_mkdtemp_test) {
3251 int res, xerrno;
3252 pr_error_t *err;
3253 pr_error_explainer_t *explainer;
3254 module m;
3255 const char *name;
3256
3257 res = pr_error_explain_mkdtemp(NULL, NULL);
3258 fail_unless(res < 0, "Failed to handle null error");
3259 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3260 strerror(errno), errno);
3261
3262 xerrno = EINVAL;
3263 err = pr_error_create(p, xerrno);
3264 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3265
3266 res = pr_error_explain_mkdtemp(err, NULL);
3267 fail_unless(res < 0, "Unexpectedly explained error");
3268 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3269 strerror(errno), errno);
3270
3271 memset(&m, 0, sizeof(m));
3272 m.name = "error";
3273 name = "testsuite";
3274
3275 explainer = pr_error_register_explainer(p, &m, name);
3276 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3277 name, strerror(errno));
3278
3279 res = pr_error_explain_mkdtemp(err, NULL);
3280 fail_unless(res < 0, "Unexpectedly explained error");
3281 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3282 strerror(errno), errno);
3283
3284 explainer->explain_mkdtemp = test_explain_mkdtemp;
3285 test_explain_return_eperm = TRUE;
3286
3287 res = pr_error_explain_mkdtemp(err, NULL);
3288 fail_unless(res < 0, "Unexpectedly explained error");
3289 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3290 strerror(errno), errno);
3291
3292 test_explain_return_eperm = FALSE;
3293 res = pr_error_explain_mkdtemp(err, NULL);
3294 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3295
3296 res = pr_error_unregister_explainer(p, &m, name);
3297 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3298 strerror(errno));
3299
3300 pr_error_destroy(err);
3301 }
3302 END_TEST
3303
3304 /* mkstemp */
test_explain_mkstemp(pool * err_pool,int xerrno,char * tmpl,const char ** args)3305 static const char *test_explain_mkstemp(pool *err_pool, int xerrno,
3306 char *tmpl, const char **args) {
3307
3308 if (test_explain_return_eperm == TRUE) {
3309 errno = EPERM;
3310 return NULL;
3311 }
3312
3313 return pstrdup(err_pool, "it was not meant to be");
3314 }
3315
START_TEST(error_explain_mkstemp_test)3316 START_TEST (error_explain_mkstemp_test) {
3317 int res, xerrno;
3318 pr_error_t *err;
3319 pr_error_explainer_t *explainer;
3320 module m;
3321 const char *name;
3322
3323 res = pr_error_explain_mkstemp(NULL, NULL);
3324 fail_unless(res < 0, "Failed to handle null error");
3325 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3326 strerror(errno), errno);
3327
3328 xerrno = EINVAL;
3329 err = pr_error_create(p, xerrno);
3330 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3331
3332 res = pr_error_explain_mkstemp(err, NULL);
3333 fail_unless(res < 0, "Unexpectedly explained error");
3334 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3335 strerror(errno), errno);
3336
3337 memset(&m, 0, sizeof(m));
3338 m.name = "error";
3339 name = "testsuite";
3340
3341 explainer = pr_error_register_explainer(p, &m, name);
3342 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3343 name, strerror(errno));
3344
3345 res = pr_error_explain_mkstemp(err, NULL);
3346 fail_unless(res < 0, "Unexpectedly explained error");
3347 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3348 strerror(errno), errno);
3349
3350 explainer->explain_mkstemp = test_explain_mkstemp;
3351 test_explain_return_eperm = TRUE;
3352
3353 res = pr_error_explain_mkstemp(err, NULL);
3354 fail_unless(res < 0, "Unexpectedly explained error");
3355 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3356 strerror(errno), errno);
3357
3358 test_explain_return_eperm = FALSE;
3359 res = pr_error_explain_mkstemp(err, NULL);
3360 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3361
3362 res = pr_error_unregister_explainer(p, &m, name);
3363 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3364 strerror(errno));
3365
3366 pr_error_destroy(err);
3367 }
3368 END_TEST
3369
3370 /* open */
test_explain_open(pool * err_pool,int xerrno,const char * path,int flags,mode_t mode,const char ** args)3371 static const char *test_explain_open(pool *err_pool, int xerrno,
3372 const char *path, int flags, mode_t mode, const char **args) {
3373
3374 if (test_explain_return_eperm == TRUE) {
3375 errno = EPERM;
3376 return NULL;
3377 }
3378
3379 return pstrdup(err_pool, "it was not meant to be");
3380 }
3381
START_TEST(error_explain_open_test)3382 START_TEST (error_explain_open_test) {
3383 int res, xerrno;
3384 pr_error_t *err;
3385 pr_error_explainer_t *explainer;
3386 module m;
3387 const char *name;
3388
3389 res = pr_error_explain_open(NULL, NULL, 0, 0);
3390 fail_unless(res < 0, "Failed to handle null error");
3391 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3392 strerror(errno), errno);
3393
3394 xerrno = EINVAL;
3395 err = pr_error_create(p, xerrno);
3396 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3397
3398 res = pr_error_explain_open(err, NULL, 0, 0);
3399 fail_unless(res < 0, "Unexpectedly explained error");
3400 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3401 strerror(errno), errno);
3402
3403 memset(&m, 0, sizeof(m));
3404 m.name = "error";
3405 name = "testsuite";
3406
3407 explainer = pr_error_register_explainer(p, &m, name);
3408 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3409 name, strerror(errno));
3410
3411 res = pr_error_explain_open(err, NULL, 0, 0);
3412 fail_unless(res < 0, "Unexpectedly explained error");
3413 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3414 strerror(errno), errno);
3415
3416 explainer->explain_open = test_explain_open;
3417 test_explain_return_eperm = TRUE;
3418
3419 res = pr_error_explain_open(err, NULL, 0, 0);
3420 fail_unless(res < 0, "Unexpectedly explained error");
3421 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3422 strerror(errno), errno);
3423
3424 test_explain_return_eperm = FALSE;
3425 res = pr_error_explain_open(err, NULL, 0, 0);
3426 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3427
3428 res = pr_error_unregister_explainer(p, &m, name);
3429 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3430 strerror(errno));
3431
3432 pr_error_destroy(err);
3433 }
3434 END_TEST
3435
3436 /* opendir */
test_explain_opendir(pool * err_pool,int xerrno,const char * path,const char ** args)3437 static const char *test_explain_opendir(pool *err_pool, int xerrno,
3438 const char *path, const char **args) {
3439
3440 if (test_explain_return_eperm == TRUE) {
3441 errno = EPERM;
3442 return NULL;
3443 }
3444
3445 return pstrdup(err_pool, "it was not meant to be");
3446 }
3447
START_TEST(error_explain_opendir_test)3448 START_TEST (error_explain_opendir_test) {
3449 int res, xerrno;
3450 pr_error_t *err;
3451 pr_error_explainer_t *explainer;
3452 module m;
3453 const char *name;
3454
3455 res = pr_error_explain_opendir(NULL, NULL);
3456 fail_unless(res < 0, "Failed to handle null error");
3457 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3458 strerror(errno), errno);
3459
3460 xerrno = EINVAL;
3461 err = pr_error_create(p, xerrno);
3462 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3463
3464 res = pr_error_explain_opendir(err, NULL);
3465 fail_unless(res < 0, "Unexpectedly explained error");
3466 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3467 strerror(errno), errno);
3468
3469 memset(&m, 0, sizeof(m));
3470 m.name = "error";
3471 name = "testsuite";
3472
3473 explainer = pr_error_register_explainer(p, &m, name);
3474 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3475 name, strerror(errno));
3476
3477 res = pr_error_explain_opendir(err, NULL);
3478 fail_unless(res < 0, "Unexpectedly explained error");
3479 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3480 strerror(errno), errno);
3481
3482 explainer->explain_opendir = test_explain_opendir;
3483 test_explain_return_eperm = TRUE;
3484
3485 res = pr_error_explain_opendir(err, NULL);
3486 fail_unless(res < 0, "Unexpectedly explained error");
3487 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3488 strerror(errno), errno);
3489
3490 test_explain_return_eperm = FALSE;
3491 res = pr_error_explain_opendir(err, NULL);
3492 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3493
3494 res = pr_error_unregister_explainer(p, &m, name);
3495 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3496 strerror(errno));
3497
3498 pr_error_destroy(err);
3499 }
3500 END_TEST
3501
3502 /* read */
test_explain_read(pool * err_pool,int xerrno,int fd,void * buf,size_t sz,const char ** args)3503 static const char *test_explain_read(pool *err_pool, int xerrno, int fd,
3504 void *buf, size_t sz, const char **args) {
3505
3506 if (test_explain_return_eperm == TRUE) {
3507 errno = EPERM;
3508 return NULL;
3509 }
3510
3511 return pstrdup(err_pool, "it was not meant to be");
3512 }
3513
START_TEST(error_explain_read_test)3514 START_TEST (error_explain_read_test) {
3515 int res, xerrno;
3516 pr_error_t *err;
3517 pr_error_explainer_t *explainer;
3518 module m;
3519 const char *name;
3520
3521 res = pr_error_explain_read(NULL, -1, NULL, 0);
3522 fail_unless(res < 0, "Failed to handle null error");
3523 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3524 strerror(errno), errno);
3525
3526 xerrno = EINVAL;
3527 err = pr_error_create(p, xerrno);
3528 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3529
3530 res = pr_error_explain_read(err, -1, NULL, 0);
3531 fail_unless(res < 0, "Unexpectedly explained error");
3532 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3533 strerror(errno), errno);
3534
3535 memset(&m, 0, sizeof(m));
3536 m.name = "error";
3537 name = "testsuite";
3538
3539 explainer = pr_error_register_explainer(p, &m, name);
3540 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3541 name, strerror(errno));
3542
3543 res = pr_error_explain_read(err, -1, NULL, 0);
3544 fail_unless(res < 0, "Unexpectedly explained error");
3545 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3546 strerror(errno), errno);
3547
3548 explainer->explain_read = test_explain_read;
3549 test_explain_return_eperm = TRUE;
3550
3551 res = pr_error_explain_read(err, -1, NULL, 0);
3552 fail_unless(res < 0, "Unexpectedly explained error");
3553 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3554 strerror(errno), errno);
3555
3556 test_explain_return_eperm = FALSE;
3557 res = pr_error_explain_read(err, -1, NULL, 0);
3558 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3559
3560 res = pr_error_unregister_explainer(p, &m, name);
3561 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3562 strerror(errno));
3563
3564 pr_error_destroy(err);
3565 }
3566 END_TEST
3567
3568 /* readdir */
test_explain_readdir(pool * err_pool,int xerrno,void * dirh,const char ** args)3569 static const char *test_explain_readdir(pool *err_pool, int xerrno, void *dirh,
3570 const char **args) {
3571
3572 if (test_explain_return_eperm == TRUE) {
3573 errno = EPERM;
3574 return NULL;
3575 }
3576
3577 return pstrdup(err_pool, "it was not meant to be");
3578 }
3579
START_TEST(error_explain_readdir_test)3580 START_TEST (error_explain_readdir_test) {
3581 int res, xerrno;
3582 pr_error_t *err;
3583 pr_error_explainer_t *explainer;
3584 module m;
3585 const char *name;
3586
3587 res = pr_error_explain_readdir(NULL, NULL);
3588 fail_unless(res < 0, "Failed to handle null error");
3589 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3590 strerror(errno), errno);
3591
3592 xerrno = EINVAL;
3593 err = pr_error_create(p, xerrno);
3594 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3595
3596 res = pr_error_explain_readdir(err, NULL);
3597 fail_unless(res < 0, "Unexpectedly explained error");
3598 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3599 strerror(errno), errno);
3600
3601 memset(&m, 0, sizeof(m));
3602 m.name = "error";
3603 name = "testsuite";
3604
3605 explainer = pr_error_register_explainer(p, &m, name);
3606 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3607 name, strerror(errno));
3608
3609 res = pr_error_explain_readdir(err, NULL);
3610 fail_unless(res < 0, "Unexpectedly explained error");
3611 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3612 strerror(errno), errno);
3613
3614 explainer->explain_readdir = test_explain_readdir;
3615 test_explain_return_eperm = TRUE;
3616
3617 res = pr_error_explain_readdir(err, NULL);
3618 fail_unless(res < 0, "Unexpectedly explained error");
3619 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3620 strerror(errno), errno);
3621
3622 test_explain_return_eperm = FALSE;
3623 res = pr_error_explain_readdir(err, NULL);
3624 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3625
3626 res = pr_error_unregister_explainer(p, &m, name);
3627 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3628 strerror(errno));
3629
3630 pr_error_destroy(err);
3631 }
3632 END_TEST
3633
3634 /* readlink */
test_explain_readlink(pool * err_pool,int xerrno,const char * path,char * buf,size_t sz,const char ** args)3635 static const char *test_explain_readlink(pool *err_pool, int xerrno,
3636 const char *path, char *buf, size_t sz, const char **args) {
3637
3638 if (test_explain_return_eperm == TRUE) {
3639 errno = EPERM;
3640 return NULL;
3641 }
3642
3643 return pstrdup(err_pool, "it was not meant to be");
3644 }
3645
START_TEST(error_explain_readlink_test)3646 START_TEST (error_explain_readlink_test) {
3647 int res, xerrno;
3648 pr_error_t *err;
3649 pr_error_explainer_t *explainer;
3650 module m;
3651 const char *name;
3652
3653 res = pr_error_explain_readlink(NULL, NULL, NULL, 0);
3654 fail_unless(res < 0, "Failed to handle null error");
3655 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3656 strerror(errno), errno);
3657
3658 xerrno = EINVAL;
3659 err = pr_error_create(p, xerrno);
3660 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3661
3662 res = pr_error_explain_readlink(err, NULL, NULL, 0);
3663 fail_unless(res < 0, "Unexpectedly explained error");
3664 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3665 strerror(errno), errno);
3666
3667 memset(&m, 0, sizeof(m));
3668 m.name = "error";
3669 name = "testsuite";
3670
3671 explainer = pr_error_register_explainer(p, &m, name);
3672 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3673 name, strerror(errno));
3674
3675 res = pr_error_explain_readlink(err, NULL, NULL, 0);
3676 fail_unless(res < 0, "Unexpectedly explained error");
3677 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3678 strerror(errno), errno);
3679
3680 explainer->explain_readlink = test_explain_readlink;
3681 test_explain_return_eperm = TRUE;
3682
3683 res = pr_error_explain_readlink(err, NULL, NULL, 0);
3684 fail_unless(res < 0, "Unexpectedly explained error");
3685 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3686 strerror(errno), errno);
3687
3688 test_explain_return_eperm = FALSE;
3689 res = pr_error_explain_readlink(err, NULL, NULL, 0);
3690 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3691
3692 res = pr_error_unregister_explainer(p, &m, name);
3693 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3694 strerror(errno));
3695
3696 pr_error_destroy(err);
3697 }
3698 END_TEST
3699
3700 /* readv */
test_explain_readv(pool * err_pool,int xerrno,int fd,const struct iovec * iov,int iov_len,const char ** args)3701 static const char *test_explain_readv(pool *err_pool, int xerrno, int fd,
3702 const struct iovec *iov, int iov_len, const char **args) {
3703
3704 if (test_explain_return_eperm == TRUE) {
3705 errno = EPERM;
3706 return NULL;
3707 }
3708
3709 return pstrdup(err_pool, "it was not meant to be");
3710 }
3711
START_TEST(error_explain_readv_test)3712 START_TEST (error_explain_readv_test) {
3713 int res, xerrno;
3714 pr_error_t *err;
3715 pr_error_explainer_t *explainer;
3716 module m;
3717 const char *name;
3718
3719 res = pr_error_explain_readv(NULL, -1, NULL, 0);
3720 fail_unless(res < 0, "Failed to handle null error");
3721 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3722 strerror(errno), errno);
3723
3724 xerrno = EINVAL;
3725 err = pr_error_create(p, xerrno);
3726 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3727
3728 res = pr_error_explain_readv(err, -1, NULL, 0);
3729 fail_unless(res < 0, "Unexpectedly explained error");
3730 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3731 strerror(errno), errno);
3732
3733 memset(&m, 0, sizeof(m));
3734 m.name = "error";
3735 name = "testsuite";
3736
3737 explainer = pr_error_register_explainer(p, &m, name);
3738 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3739 name, strerror(errno));
3740
3741 res = pr_error_explain_readv(err, -1, NULL, 0);
3742 fail_unless(res < 0, "Unexpectedly explained error");
3743 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3744 strerror(errno), errno);
3745
3746 explainer->explain_readv = test_explain_readv;
3747 test_explain_return_eperm = TRUE;
3748
3749 res = pr_error_explain_readv(err, -1, NULL, 0);
3750 fail_unless(res < 0, "Unexpectedly explained error");
3751 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3752 strerror(errno), errno);
3753
3754 test_explain_return_eperm = FALSE;
3755 res = pr_error_explain_readv(err, -1, NULL, 0);
3756 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3757
3758 res = pr_error_unregister_explainer(p, &m, name);
3759 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3760 strerror(errno));
3761
3762 pr_error_destroy(err);
3763 }
3764 END_TEST
3765
3766 /* rename */
test_explain_rename(pool * err_pool,int xerrno,const char * old_path,const char * new_path,const char ** args)3767 static const char *test_explain_rename(pool *err_pool, int xerrno,
3768 const char *old_path, const char *new_path, const char **args) {
3769
3770 if (test_explain_return_eperm == TRUE) {
3771 errno = EPERM;
3772 return NULL;
3773 }
3774
3775 return pstrdup(err_pool, "it was not meant to be");
3776 }
3777
START_TEST(error_explain_rename_test)3778 START_TEST (error_explain_rename_test) {
3779 int res, xerrno;
3780 pr_error_t *err;
3781 pr_error_explainer_t *explainer;
3782 module m;
3783 const char *name;
3784
3785 res = pr_error_explain_rename(NULL, NULL, NULL);
3786 fail_unless(res < 0, "Failed to handle null error");
3787 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3788 strerror(errno), errno);
3789
3790 xerrno = EINVAL;
3791 err = pr_error_create(p, xerrno);
3792 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3793
3794 res = pr_error_explain_rename(err, NULL, NULL);
3795 fail_unless(res < 0, "Unexpectedly explained error");
3796 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3797 strerror(errno), errno);
3798
3799 memset(&m, 0, sizeof(m));
3800 m.name = "error";
3801 name = "testsuite";
3802
3803 explainer = pr_error_register_explainer(p, &m, name);
3804 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3805 name, strerror(errno));
3806
3807 res = pr_error_explain_rename(err, NULL, NULL);
3808 fail_unless(res < 0, "Unexpectedly explained error");
3809 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3810 strerror(errno), errno);
3811
3812 explainer->explain_rename = test_explain_rename;
3813 test_explain_return_eperm = TRUE;
3814
3815 res = pr_error_explain_rename(err, NULL, NULL);
3816 fail_unless(res < 0, "Unexpectedly explained error");
3817 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3818 strerror(errno), errno);
3819
3820 test_explain_return_eperm = FALSE;
3821 res = pr_error_explain_rename(err, NULL, NULL);
3822 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3823
3824 res = pr_error_unregister_explainer(p, &m, name);
3825 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3826 strerror(errno));
3827
3828 pr_error_destroy(err);
3829 }
3830 END_TEST
3831
3832 /* rmdir */
test_explain_rmdir(pool * err_pool,int xerrno,const char * path,const char ** args)3833 static const char *test_explain_rmdir(pool *err_pool, int xerrno,
3834 const char *path, const char **args) {
3835
3836 if (test_explain_return_eperm == TRUE) {
3837 errno = EPERM;
3838 return NULL;
3839 }
3840
3841 return pstrdup(err_pool, "it was not meant to be");
3842 }
3843
START_TEST(error_explain_rmdir_test)3844 START_TEST (error_explain_rmdir_test) {
3845 int res, xerrno;
3846 pr_error_t *err;
3847 pr_error_explainer_t *explainer;
3848 module m;
3849 const char *name;
3850
3851 res = pr_error_explain_rmdir(NULL, NULL);
3852 fail_unless(res < 0, "Failed to handle null error");
3853 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3854 strerror(errno), errno);
3855
3856 xerrno = EINVAL;
3857 err = pr_error_create(p, xerrno);
3858 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3859
3860 res = pr_error_explain_rmdir(err, NULL);
3861 fail_unless(res < 0, "Unexpectedly explained error");
3862 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3863 strerror(errno), errno);
3864
3865 memset(&m, 0, sizeof(m));
3866 m.name = "error";
3867 name = "testsuite";
3868
3869 explainer = pr_error_register_explainer(p, &m, name);
3870 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3871 name, strerror(errno));
3872
3873 res = pr_error_explain_rmdir(err, NULL);
3874 fail_unless(res < 0, "Unexpectedly explained error");
3875 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3876 strerror(errno), errno);
3877
3878 explainer->explain_rmdir = test_explain_rmdir;
3879 test_explain_return_eperm = TRUE;
3880
3881 res = pr_error_explain_rmdir(err, NULL);
3882 fail_unless(res < 0, "Unexpectedly explained error");
3883 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3884 strerror(errno), errno);
3885
3886 test_explain_return_eperm = FALSE;
3887 res = pr_error_explain_rmdir(err, NULL);
3888 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3889
3890 res = pr_error_unregister_explainer(p, &m, name);
3891 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3892 strerror(errno));
3893
3894 pr_error_destroy(err);
3895 }
3896 END_TEST
3897
3898 /* setegid */
test_explain_setegid(pool * err_pool,int xerrno,gid_t egid,const char ** args)3899 static const char *test_explain_setegid(pool *err_pool, int xerrno,
3900 gid_t egid, const char **args) {
3901
3902 if (test_explain_return_eperm == TRUE) {
3903 errno = EPERM;
3904 return NULL;
3905 }
3906
3907 return pstrdup(err_pool, "it was not meant to be");
3908 }
3909
START_TEST(error_explain_setegid_test)3910 START_TEST (error_explain_setegid_test) {
3911 int res, xerrno;
3912 pr_error_t *err;
3913 pr_error_explainer_t *explainer;
3914 module m;
3915 const char *name;
3916
3917 res = pr_error_explain_setegid(NULL, -1);
3918 fail_unless(res < 0, "Failed to handle null error");
3919 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3920 strerror(errno), errno);
3921
3922 xerrno = EINVAL;
3923 err = pr_error_create(p, xerrno);
3924 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3925
3926 res = pr_error_explain_setegid(err, -1);
3927 fail_unless(res < 0, "Unexpectedly explained error");
3928 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3929 strerror(errno), errno);
3930
3931 memset(&m, 0, sizeof(m));
3932 m.name = "error";
3933 name = "testsuite";
3934
3935 explainer = pr_error_register_explainer(p, &m, name);
3936 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
3937 name, strerror(errno));
3938
3939 res = pr_error_explain_setegid(err, -1);
3940 fail_unless(res < 0, "Unexpectedly explained error");
3941 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3942 strerror(errno), errno);
3943
3944 explainer->explain_setegid = test_explain_setegid;
3945 test_explain_return_eperm = TRUE;
3946
3947 res = pr_error_explain_setegid(err, -1);
3948 fail_unless(res < 0, "Unexpectedly explained error");
3949 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
3950 strerror(errno), errno);
3951
3952 test_explain_return_eperm = FALSE;
3953 res = pr_error_explain_setegid(err, -1);
3954 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
3955
3956 res = pr_error_unregister_explainer(p, &m, name);
3957 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
3958 strerror(errno));
3959
3960 pr_error_destroy(err);
3961 }
3962 END_TEST
3963
3964 /* seteuid */
test_explain_seteuid(pool * err_pool,int xerrno,uid_t euid,const char ** args)3965 static const char *test_explain_seteuid(pool *err_pool, int xerrno,
3966 uid_t euid, const char **args) {
3967
3968 if (test_explain_return_eperm == TRUE) {
3969 errno = EPERM;
3970 return NULL;
3971 }
3972
3973 return pstrdup(err_pool, "it was not meant to be");
3974 }
3975
START_TEST(error_explain_seteuid_test)3976 START_TEST (error_explain_seteuid_test) {
3977 int res, xerrno;
3978 pr_error_t *err;
3979 pr_error_explainer_t *explainer;
3980 module m;
3981 const char *name;
3982
3983 res = pr_error_explain_seteuid(NULL, -1);
3984 fail_unless(res < 0, "Failed to handle null error");
3985 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
3986 strerror(errno), errno);
3987
3988 xerrno = EINVAL;
3989 err = pr_error_create(p, xerrno);
3990 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
3991
3992 res = pr_error_explain_seteuid(err, -1);
3993 fail_unless(res < 0, "Unexpectedly explained error");
3994 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
3995 strerror(errno), errno);
3996
3997 memset(&m, 0, sizeof(m));
3998 m.name = "error";
3999 name = "testsuite";
4000
4001 explainer = pr_error_register_explainer(p, &m, name);
4002 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4003 name, strerror(errno));
4004
4005 res = pr_error_explain_seteuid(err, -1);
4006 fail_unless(res < 0, "Unexpectedly explained error");
4007 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4008 strerror(errno), errno);
4009
4010 explainer->explain_seteuid = test_explain_seteuid;
4011 test_explain_return_eperm = TRUE;
4012
4013 res = pr_error_explain_seteuid(err, -1);
4014 fail_unless(res < 0, "Unexpectedly explained error");
4015 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4016 strerror(errno), errno);
4017
4018 test_explain_return_eperm = FALSE;
4019 res = pr_error_explain_seteuid(err, -1);
4020 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4021
4022 res = pr_error_unregister_explainer(p, &m, name);
4023 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4024 strerror(errno));
4025
4026 pr_error_destroy(err);
4027 }
4028 END_TEST
4029
4030 /* setgid */
test_explain_setgid(pool * err_pool,int xerrno,gid_t gid,const char ** args)4031 static const char *test_explain_setgid(pool *err_pool, int xerrno,
4032 gid_t gid, const char **args) {
4033
4034 if (test_explain_return_eperm == TRUE) {
4035 errno = EPERM;
4036 return NULL;
4037 }
4038
4039 return pstrdup(err_pool, "it was not meant to be");
4040 }
4041
START_TEST(error_explain_setgid_test)4042 START_TEST (error_explain_setgid_test) {
4043 int res, xerrno;
4044 pr_error_t *err;
4045 pr_error_explainer_t *explainer;
4046 module m;
4047 const char *name;
4048
4049 res = pr_error_explain_setgid(NULL, -1);
4050 fail_unless(res < 0, "Failed to handle null error");
4051 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4052 strerror(errno), errno);
4053
4054 xerrno = EINVAL;
4055 err = pr_error_create(p, xerrno);
4056 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4057
4058 res = pr_error_explain_setgid(err, -1);
4059 fail_unless(res < 0, "Unexpectedly explained error");
4060 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4061 strerror(errno), errno);
4062
4063 memset(&m, 0, sizeof(m));
4064 m.name = "error";
4065 name = "testsuite";
4066
4067 explainer = pr_error_register_explainer(p, &m, name);
4068 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4069 name, strerror(errno));
4070
4071 res = pr_error_explain_setgid(err, -1);
4072 fail_unless(res < 0, "Unexpectedly explained error");
4073 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4074 strerror(errno), errno);
4075
4076 explainer->explain_setgid = test_explain_setgid;
4077 test_explain_return_eperm = TRUE;
4078
4079 res = pr_error_explain_setgid(err, -1);
4080 fail_unless(res < 0, "Unexpectedly explained error");
4081 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4082 strerror(errno), errno);
4083
4084 test_explain_return_eperm = FALSE;
4085 res = pr_error_explain_setgid(err, -1);
4086 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4087
4088 res = pr_error_unregister_explainer(p, &m, name);
4089 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4090 strerror(errno));
4091
4092 pr_error_destroy(err);
4093 }
4094 END_TEST
4095
4096 /* setregid */
test_explain_setregid(pool * err_pool,int xerrno,gid_t rgid,gid_t egid,const char ** args)4097 static const char *test_explain_setregid(pool *err_pool, int xerrno,
4098 gid_t rgid, gid_t egid, const char **args) {
4099
4100 if (test_explain_return_eperm == TRUE) {
4101 errno = EPERM;
4102 return NULL;
4103 }
4104
4105 return pstrdup(err_pool, "it was not meant to be");
4106 }
4107
START_TEST(error_explain_setregid_test)4108 START_TEST (error_explain_setregid_test) {
4109 int res, xerrno;
4110 pr_error_t *err;
4111 pr_error_explainer_t *explainer;
4112 module m;
4113 const char *name;
4114
4115 res = pr_error_explain_setregid(NULL, -1, -1);
4116 fail_unless(res < 0, "Failed to handle null error");
4117 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4118 strerror(errno), errno);
4119
4120 xerrno = EINVAL;
4121 err = pr_error_create(p, xerrno);
4122 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4123
4124 res = pr_error_explain_setregid(err, -1, -1);
4125 fail_unless(res < 0, "Unexpectedly explained error");
4126 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4127 strerror(errno), errno);
4128
4129 memset(&m, 0, sizeof(m));
4130 m.name = "error";
4131 name = "testsuite";
4132
4133 explainer = pr_error_register_explainer(p, &m, name);
4134 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4135 name, strerror(errno));
4136
4137 res = pr_error_explain_setregid(err, -1, -1);
4138 fail_unless(res < 0, "Unexpectedly explained error");
4139 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4140 strerror(errno), errno);
4141
4142 explainer->explain_setregid = test_explain_setregid;
4143 test_explain_return_eperm = TRUE;
4144
4145 res = pr_error_explain_setregid(err, -1, -1);
4146 fail_unless(res < 0, "Unexpectedly explained error");
4147 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4148 strerror(errno), errno);
4149
4150 test_explain_return_eperm = FALSE;
4151 res = pr_error_explain_setregid(err, -1, -1);
4152 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4153
4154 res = pr_error_unregister_explainer(p, &m, name);
4155 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4156 strerror(errno));
4157
4158 pr_error_destroy(err);
4159 }
4160 END_TEST
4161
4162 /* setresgid */
test_explain_setresgid(pool * err_pool,int xerrno,gid_t rgid,gid_t egid,gid_t sgid,const char ** args)4163 static const char *test_explain_setresgid(pool *err_pool, int xerrno,
4164 gid_t rgid, gid_t egid, gid_t sgid, const char **args) {
4165
4166 if (test_explain_return_eperm == TRUE) {
4167 errno = EPERM;
4168 return NULL;
4169 }
4170
4171 return pstrdup(err_pool, "it was not meant to be");
4172 }
4173
START_TEST(error_explain_setresgid_test)4174 START_TEST (error_explain_setresgid_test) {
4175 int res, xerrno;
4176 pr_error_t *err;
4177 pr_error_explainer_t *explainer;
4178 module m;
4179 const char *name;
4180
4181 res = pr_error_explain_setresgid(NULL, -1, -1, -1);
4182 fail_unless(res < 0, "Failed to handle null error");
4183 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4184 strerror(errno), errno);
4185
4186 xerrno = EINVAL;
4187 err = pr_error_create(p, xerrno);
4188 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4189
4190 res = pr_error_explain_setresgid(err, -1, -1, -1);
4191 fail_unless(res < 0, "Unexpectedly explained error");
4192 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4193 strerror(errno), errno);
4194
4195 memset(&m, 0, sizeof(m));
4196 m.name = "error";
4197 name = "testsuite";
4198
4199 explainer = pr_error_register_explainer(p, &m, name);
4200 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4201 name, strerror(errno));
4202
4203 res = pr_error_explain_setresgid(err, -1, -1, -1);
4204 fail_unless(res < 0, "Unexpectedly explained error");
4205 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4206 strerror(errno), errno);
4207
4208 explainer->explain_setresgid = test_explain_setresgid;
4209 test_explain_return_eperm = TRUE;
4210
4211 res = pr_error_explain_setresgid(err, -1, -1, -1);
4212 fail_unless(res < 0, "Unexpectedly explained error");
4213 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4214 strerror(errno), errno);
4215
4216 test_explain_return_eperm = FALSE;
4217 res = pr_error_explain_setresgid(err, -1, -1, -1);
4218 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4219
4220 res = pr_error_unregister_explainer(p, &m, name);
4221 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4222 strerror(errno));
4223
4224 pr_error_destroy(err);
4225 }
4226 END_TEST
4227
4228 /* setresuid */
test_explain_setresuid(pool * err_pool,int xerrno,uid_t ruid,uid_t euid,uid_t suid,const char ** args)4229 static const char *test_explain_setresuid(pool *err_pool, int xerrno,
4230 uid_t ruid, uid_t euid, uid_t suid, const char **args) {
4231
4232 if (test_explain_return_eperm == TRUE) {
4233 errno = EPERM;
4234 return NULL;
4235 }
4236
4237 return pstrdup(err_pool, "it was not meant to be");
4238 }
4239
START_TEST(error_explain_setresuid_test)4240 START_TEST (error_explain_setresuid_test) {
4241 int res, xerrno;
4242 pr_error_t *err;
4243 pr_error_explainer_t *explainer;
4244 module m;
4245 const char *name;
4246
4247 res = pr_error_explain_setresuid(NULL, -1, -1, -1);
4248 fail_unless(res < 0, "Failed to handle null error");
4249 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4250 strerror(errno), errno);
4251
4252 xerrno = EINVAL;
4253 err = pr_error_create(p, xerrno);
4254 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4255
4256 res = pr_error_explain_setresuid(err, -1, -1, -1);
4257 fail_unless(res < 0, "Unexpectedly explained error");
4258 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4259 strerror(errno), errno);
4260
4261 memset(&m, 0, sizeof(m));
4262 m.name = "error";
4263 name = "testsuite";
4264
4265 explainer = pr_error_register_explainer(p, &m, name);
4266 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4267 name, strerror(errno));
4268
4269 res = pr_error_explain_setresuid(err, -1, -1, -1);
4270 fail_unless(res < 0, "Unexpectedly explained error");
4271 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4272 strerror(errno), errno);
4273
4274 explainer->explain_setresuid = test_explain_setresuid;
4275 test_explain_return_eperm = TRUE;
4276
4277 res = pr_error_explain_setresuid(err, -1, -1, -1);
4278 fail_unless(res < 0, "Unexpectedly explained error");
4279 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4280 strerror(errno), errno);
4281
4282 test_explain_return_eperm = FALSE;
4283 res = pr_error_explain_setresuid(err, -1, -1, -1);
4284 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4285
4286 res = pr_error_unregister_explainer(p, &m, name);
4287 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4288 strerror(errno));
4289
4290 pr_error_destroy(err);
4291 }
4292 END_TEST
4293
4294 /* setreuid */
test_explain_setreuid(pool * err_pool,int xerrno,uid_t ruid,uid_t euid,const char ** args)4295 static const char *test_explain_setreuid(pool *err_pool, int xerrno,
4296 uid_t ruid, uid_t euid, const char **args) {
4297
4298 if (test_explain_return_eperm == TRUE) {
4299 errno = EPERM;
4300 return NULL;
4301 }
4302
4303 return pstrdup(err_pool, "it was not meant to be");
4304 }
4305
START_TEST(error_explain_setreuid_test)4306 START_TEST (error_explain_setreuid_test) {
4307 int res, xerrno;
4308 pr_error_t *err;
4309 pr_error_explainer_t *explainer;
4310 module m;
4311 const char *name;
4312
4313 res = pr_error_explain_setreuid(NULL, -1, -1);
4314 fail_unless(res < 0, "Failed to handle null error");
4315 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4316 strerror(errno), errno);
4317
4318 xerrno = EINVAL;
4319 err = pr_error_create(p, xerrno);
4320 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4321
4322 res = pr_error_explain_setreuid(err, -1, -1);
4323 fail_unless(res < 0, "Unexpectedly explained error");
4324 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4325 strerror(errno), errno);
4326
4327 memset(&m, 0, sizeof(m));
4328 m.name = "error";
4329 name = "testsuite";
4330
4331 explainer = pr_error_register_explainer(p, &m, name);
4332 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4333 name, strerror(errno));
4334
4335 res = pr_error_explain_setreuid(err, -1, -1);
4336 fail_unless(res < 0, "Unexpectedly explained error");
4337 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4338 strerror(errno), errno);
4339
4340 explainer->explain_setreuid = test_explain_setreuid;
4341 test_explain_return_eperm = TRUE;
4342
4343 res = pr_error_explain_setreuid(err, -1, -1);
4344 fail_unless(res < 0, "Unexpectedly explained error");
4345 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4346 strerror(errno), errno);
4347
4348 test_explain_return_eperm = FALSE;
4349 res = pr_error_explain_setreuid(err, -1, -1);
4350 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4351
4352 res = pr_error_unregister_explainer(p, &m, name);
4353 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4354 strerror(errno));
4355
4356 pr_error_destroy(err);
4357 }
4358 END_TEST
4359
4360 /* setrlimit */
test_explain_setrlimit(pool * err_pool,int xerrno,int resource,const struct rlimit * rlim,const char ** args)4361 static const char *test_explain_setrlimit(pool *err_pool, int xerrno,
4362 int resource, const struct rlimit *rlim, const char **args) {
4363
4364 if (test_explain_return_eperm == TRUE) {
4365 errno = EPERM;
4366 return NULL;
4367 }
4368
4369 return pstrdup(err_pool, "it was not meant to be");
4370 }
4371
START_TEST(error_explain_setrlimit_test)4372 START_TEST (error_explain_setrlimit_test) {
4373 int res, xerrno;
4374 pr_error_t *err;
4375 pr_error_explainer_t *explainer;
4376 module m;
4377 const char *name;
4378
4379 res = pr_error_explain_setrlimit(NULL, -1, NULL);
4380 fail_unless(res < 0, "Failed to handle null error");
4381 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4382 strerror(errno), errno);
4383
4384 xerrno = EINVAL;
4385 err = pr_error_create(p, xerrno);
4386 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4387
4388 res = pr_error_explain_setrlimit(err, -1, NULL);
4389 fail_unless(res < 0, "Unexpectedly explained error");
4390 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4391 strerror(errno), errno);
4392
4393 memset(&m, 0, sizeof(m));
4394 m.name = "error";
4395 name = "testsuite";
4396
4397 explainer = pr_error_register_explainer(p, &m, name);
4398 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4399 name, strerror(errno));
4400
4401 res = pr_error_explain_setrlimit(err, -1, NULL);
4402 fail_unless(res < 0, "Unexpectedly explained error");
4403 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4404 strerror(errno), errno);
4405
4406 explainer->explain_setrlimit = test_explain_setrlimit;
4407 test_explain_return_eperm = TRUE;
4408
4409 res = pr_error_explain_setrlimit(err, -1, NULL);
4410 fail_unless(res < 0, "Unexpectedly explained error");
4411 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4412 strerror(errno), errno);
4413
4414 test_explain_return_eperm = FALSE;
4415 res = pr_error_explain_setrlimit(err, -1, NULL);
4416 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4417
4418 res = pr_error_unregister_explainer(p, &m, name);
4419 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4420 strerror(errno));
4421
4422 pr_error_destroy(err);
4423 }
4424 END_TEST
4425
4426 /* setsockopt */
test_explain_setsockopt(pool * err_pool,int xerrno,int fd,int level,int option,const void * val,socklen_t valsz,const char ** args)4427 static const char *test_explain_setsockopt(pool *err_pool, int xerrno, int fd,
4428 int level, int option, const void *val, socklen_t valsz,
4429 const char **args) {
4430
4431 if (test_explain_return_eperm == TRUE) {
4432 errno = EPERM;
4433 return NULL;
4434 }
4435
4436 return pstrdup(err_pool, "it was not meant to be");
4437 }
4438
START_TEST(error_explain_setsockopt_test)4439 START_TEST (error_explain_setsockopt_test) {
4440 int res, xerrno;
4441 pr_error_t *err;
4442 pr_error_explainer_t *explainer;
4443 module m;
4444 const char *name;
4445
4446 res = pr_error_explain_setsockopt(NULL, -1, -1, -1, NULL, 0);
4447 fail_unless(res < 0, "Failed to handle null error");
4448 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4449 strerror(errno), errno);
4450
4451 xerrno = EINVAL;
4452 err = pr_error_create(p, xerrno);
4453 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4454
4455 res = pr_error_explain_setsockopt(err, -1, -1, -1, NULL, 0);
4456 fail_unless(res < 0, "Unexpectedly explained error");
4457 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4458 strerror(errno), errno);
4459
4460 memset(&m, 0, sizeof(m));
4461 m.name = "error";
4462 name = "testsuite";
4463
4464 explainer = pr_error_register_explainer(p, &m, name);
4465 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4466 name, strerror(errno));
4467
4468 res = pr_error_explain_setsockopt(err, -1, -1, -1, NULL, 0);
4469 fail_unless(res < 0, "Unexpectedly explained error");
4470 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4471 strerror(errno), errno);
4472
4473 explainer->explain_setsockopt = test_explain_setsockopt;
4474 test_explain_return_eperm = TRUE;
4475
4476 res = pr_error_explain_setsockopt(err, -1, -1, -1, NULL, 0);
4477 fail_unless(res < 0, "Unexpectedly explained error");
4478 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4479 strerror(errno), errno);
4480
4481 test_explain_return_eperm = FALSE;
4482 res = pr_error_explain_setsockopt(err, -1, -1, -1, NULL, 0);
4483 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4484
4485 res = pr_error_unregister_explainer(p, &m, name);
4486 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4487 strerror(errno));
4488
4489 pr_error_destroy(err);
4490 }
4491 END_TEST
4492
4493 /* setuid */
test_explain_setuid(pool * err_pool,int xerrno,uid_t uid,const char ** args)4494 static const char *test_explain_setuid(pool *err_pool, int xerrno,
4495 uid_t uid, const char **args) {
4496
4497 if (test_explain_return_eperm == TRUE) {
4498 errno = EPERM;
4499 return NULL;
4500 }
4501
4502 return pstrdup(err_pool, "it was not meant to be");
4503 }
4504
START_TEST(error_explain_setuid_test)4505 START_TEST (error_explain_setuid_test) {
4506 int res, xerrno;
4507 pr_error_t *err;
4508 pr_error_explainer_t *explainer;
4509 module m;
4510 const char *name;
4511
4512 res = pr_error_explain_setuid(NULL, -1);
4513 fail_unless(res < 0, "Failed to handle null error");
4514 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4515 strerror(errno), errno);
4516
4517 xerrno = EINVAL;
4518 err = pr_error_create(p, xerrno);
4519 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4520
4521 res = pr_error_explain_setuid(err, -1);
4522 fail_unless(res < 0, "Unexpectedly explained error");
4523 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4524 strerror(errno), errno);
4525
4526 memset(&m, 0, sizeof(m));
4527 m.name = "error";
4528 name = "testsuite";
4529
4530 explainer = pr_error_register_explainer(p, &m, name);
4531 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4532 name, strerror(errno));
4533
4534 res = pr_error_explain_setuid(err, -1);
4535 fail_unless(res < 0, "Unexpectedly explained error");
4536 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4537 strerror(errno), errno);
4538
4539 explainer->explain_setuid = test_explain_setuid;
4540 test_explain_return_eperm = TRUE;
4541
4542 res = pr_error_explain_setuid(err, -1);
4543 fail_unless(res < 0, "Unexpectedly explained error");
4544 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4545 strerror(errno), errno);
4546
4547 test_explain_return_eperm = FALSE;
4548 res = pr_error_explain_setuid(err, -1);
4549 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4550
4551 res = pr_error_unregister_explainer(p, &m, name);
4552 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4553 strerror(errno));
4554
4555 pr_error_destroy(err);
4556 }
4557 END_TEST
4558
4559 /* socket */
test_explain_socket(pool * err_pool,int xerrno,int domain,int type,int proto,const char ** args)4560 static const char *test_explain_socket(pool *err_pool, int xerrno,
4561 int domain, int type, int proto, const char **args) {
4562
4563 if (test_explain_return_eperm == TRUE) {
4564 errno = EPERM;
4565 return NULL;
4566 }
4567
4568 return pstrdup(err_pool, "it was not meant to be");
4569 }
4570
START_TEST(error_explain_socket_test)4571 START_TEST (error_explain_socket_test) {
4572 int res, xerrno;
4573 pr_error_t *err;
4574 pr_error_explainer_t *explainer;
4575 module m;
4576 const char *name;
4577
4578 res = pr_error_explain_socket(NULL, -1, -1, -1);
4579 fail_unless(res < 0, "Failed to handle null error");
4580 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4581 strerror(errno), errno);
4582
4583 xerrno = EINVAL;
4584 err = pr_error_create(p, xerrno);
4585 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4586
4587 res = pr_error_explain_socket(err, -1, -1, -1);
4588 fail_unless(res < 0, "Unexpectedly explained error");
4589 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4590 strerror(errno), errno);
4591
4592 memset(&m, 0, sizeof(m));
4593 m.name = "error";
4594 name = "testsuite";
4595
4596 explainer = pr_error_register_explainer(p, &m, name);
4597 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4598 name, strerror(errno));
4599
4600 res = pr_error_explain_socket(err, -1, -1, -1);
4601 fail_unless(res < 0, "Unexpectedly explained error");
4602 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4603 strerror(errno), errno);
4604
4605 explainer->explain_socket = test_explain_socket;
4606 test_explain_return_eperm = TRUE;
4607
4608 res = pr_error_explain_socket(err, -1, -1, -1);
4609 fail_unless(res < 0, "Unexpectedly explained error");
4610 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4611 strerror(errno), errno);
4612
4613 test_explain_return_eperm = FALSE;
4614 res = pr_error_explain_socket(err, -1, -1, -1);
4615 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4616
4617 res = pr_error_unregister_explainer(p, &m, name);
4618 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4619 strerror(errno));
4620
4621 pr_error_destroy(err);
4622 }
4623 END_TEST
4624
4625 /* stat */
test_explain_stat(pool * err_pool,int xerrno,const char * path,struct stat * st,const char ** args)4626 static const char *test_explain_stat(pool *err_pool, int xerrno,
4627 const char *path, struct stat *st, const char **args) {
4628
4629 if (test_explain_return_eperm == TRUE) {
4630 errno = EPERM;
4631 return NULL;
4632 }
4633
4634 return pstrdup(err_pool, "it was not meant to be");
4635 }
4636
START_TEST(error_explain_stat_test)4637 START_TEST (error_explain_stat_test) {
4638 int res, xerrno;
4639 pr_error_t *err;
4640 pr_error_explainer_t *explainer;
4641 module m;
4642 const char *name;
4643
4644 res = pr_error_explain_stat(NULL, NULL, NULL);
4645 fail_unless(res < 0, "Failed to handle null error");
4646 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4647 strerror(errno), errno);
4648
4649 xerrno = EINVAL;
4650 err = pr_error_create(p, xerrno);
4651 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4652
4653 res = pr_error_explain_stat(err, NULL, NULL);
4654 fail_unless(res < 0, "Unexpectedly explained error");
4655 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4656 strerror(errno), errno);
4657
4658 memset(&m, 0, sizeof(m));
4659 m.name = "error";
4660 name = "testsuite";
4661
4662 explainer = pr_error_register_explainer(p, &m, name);
4663 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4664 name, strerror(errno));
4665
4666 res = pr_error_explain_stat(err, NULL, NULL);
4667 fail_unless(res < 0, "Unexpectedly explained error");
4668 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4669 strerror(errno), errno);
4670
4671 explainer->explain_stat = test_explain_stat;
4672 test_explain_return_eperm = TRUE;
4673
4674 res = pr_error_explain_stat(err, NULL, NULL);
4675 fail_unless(res < 0, "Unexpectedly explained error");
4676 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4677 strerror(errno), errno);
4678
4679 test_explain_return_eperm = FALSE;
4680 res = pr_error_explain_stat(err, NULL, NULL);
4681 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4682
4683 res = pr_error_unregister_explainer(p, &m, name);
4684 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4685 strerror(errno));
4686
4687 pr_error_destroy(err);
4688 }
4689 END_TEST
4690
4691 /* statfs */
test_explain_statfs(pool * err_pool,int xerrno,const char * path,void * stfs,const char ** args)4692 static const char *test_explain_statfs(pool *err_pool, int xerrno,
4693 const char *path, void *stfs, const char **args) {
4694
4695 if (test_explain_return_eperm == TRUE) {
4696 errno = EPERM;
4697 return NULL;
4698 }
4699
4700 return pstrdup(err_pool, "it was not meant to be");
4701 }
4702
START_TEST(error_explain_statfs_test)4703 START_TEST (error_explain_statfs_test) {
4704 int res, xerrno;
4705 pr_error_t *err;
4706 pr_error_explainer_t *explainer;
4707 module m;
4708 const char *name;
4709
4710 res = pr_error_explain_statfs(NULL, NULL, NULL);
4711 fail_unless(res < 0, "Failed to handle null error");
4712 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4713 strerror(errno), errno);
4714
4715 xerrno = EINVAL;
4716 err = pr_error_create(p, xerrno);
4717 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4718
4719 res = pr_error_explain_statfs(err, NULL, NULL);
4720 fail_unless(res < 0, "Unexpectedly explained error");
4721 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4722 strerror(errno), errno);
4723
4724 memset(&m, 0, sizeof(m));
4725 m.name = "error";
4726 name = "testsuite";
4727
4728 explainer = pr_error_register_explainer(p, &m, name);
4729 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4730 name, strerror(errno));
4731
4732 res = pr_error_explain_statfs(err, NULL, NULL);
4733 fail_unless(res < 0, "Unexpectedly explained error");
4734 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4735 strerror(errno), errno);
4736
4737 explainer->explain_statfs = test_explain_statfs;
4738 test_explain_return_eperm = TRUE;
4739
4740 res = pr_error_explain_statfs(err, NULL, NULL);
4741 fail_unless(res < 0, "Unexpectedly explained error");
4742 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4743 strerror(errno), errno);
4744
4745 test_explain_return_eperm = FALSE;
4746 res = pr_error_explain_statfs(err, NULL, NULL);
4747 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4748
4749 res = pr_error_unregister_explainer(p, &m, name);
4750 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4751 strerror(errno));
4752
4753 pr_error_destroy(err);
4754 }
4755 END_TEST
4756
4757 /* statvfs */
test_explain_statvfs(pool * err_pool,int xerrno,const char * path,void * stfs,const char ** args)4758 static const char *test_explain_statvfs(pool *err_pool, int xerrno,
4759 const char *path, void *stfs, const char **args) {
4760
4761 if (test_explain_return_eperm == TRUE) {
4762 errno = EPERM;
4763 return NULL;
4764 }
4765
4766 return pstrdup(err_pool, "it was not meant to be");
4767 }
4768
START_TEST(error_explain_statvfs_test)4769 START_TEST (error_explain_statvfs_test) {
4770 int res, xerrno;
4771 pr_error_t *err;
4772 pr_error_explainer_t *explainer;
4773 module m;
4774 const char *name;
4775
4776 res = pr_error_explain_statvfs(NULL, NULL, NULL);
4777 fail_unless(res < 0, "Failed to handle null error");
4778 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4779 strerror(errno), errno);
4780
4781 xerrno = EINVAL;
4782 err = pr_error_create(p, xerrno);
4783 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4784
4785 res = pr_error_explain_statvfs(err, NULL, NULL);
4786 fail_unless(res < 0, "Unexpectedly explained error");
4787 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4788 strerror(errno), errno);
4789
4790 memset(&m, 0, sizeof(m));
4791 m.name = "error";
4792 name = "testsuite";
4793
4794 explainer = pr_error_register_explainer(p, &m, name);
4795 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4796 name, strerror(errno));
4797
4798 res = pr_error_explain_statvfs(err, NULL, NULL);
4799 fail_unless(res < 0, "Unexpectedly explained error");
4800 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4801 strerror(errno), errno);
4802
4803 explainer->explain_statvfs = test_explain_statvfs;
4804 test_explain_return_eperm = TRUE;
4805
4806 res = pr_error_explain_statvfs(err, NULL, NULL);
4807 fail_unless(res < 0, "Unexpectedly explained error");
4808 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4809 strerror(errno), errno);
4810
4811 test_explain_return_eperm = FALSE;
4812 res = pr_error_explain_statvfs(err, NULL, NULL);
4813 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4814
4815 res = pr_error_unregister_explainer(p, &m, name);
4816 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4817 strerror(errno));
4818
4819 pr_error_destroy(err);
4820 }
4821 END_TEST
4822
4823 /* symlink */
test_explain_symlink(pool * err_pool,int xerrno,const char * target_path,const char * link_path,const char ** args)4824 static const char *test_explain_symlink(pool *err_pool, int xerrno,
4825 const char *target_path, const char *link_path, const char **args) {
4826
4827 if (test_explain_return_eperm == TRUE) {
4828 errno = EPERM;
4829 return NULL;
4830 }
4831
4832 return pstrdup(err_pool, "it was not meant to be");
4833 }
4834
START_TEST(error_explain_symlink_test)4835 START_TEST (error_explain_symlink_test) {
4836 int res, xerrno;
4837 pr_error_t *err;
4838 pr_error_explainer_t *explainer;
4839 module m;
4840 const char *name;
4841
4842 res = pr_error_explain_symlink(NULL, NULL, NULL);
4843 fail_unless(res < 0, "Failed to handle null error");
4844 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4845 strerror(errno), errno);
4846
4847 xerrno = EINVAL;
4848 err = pr_error_create(p, xerrno);
4849 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4850
4851 res = pr_error_explain_symlink(err, NULL, NULL);
4852 fail_unless(res < 0, "Unexpectedly explained error");
4853 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4854 strerror(errno), errno);
4855
4856 memset(&m, 0, sizeof(m));
4857 m.name = "error";
4858 name = "testsuite";
4859
4860 explainer = pr_error_register_explainer(p, &m, name);
4861 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4862 name, strerror(errno));
4863
4864 res = pr_error_explain_symlink(err, NULL, NULL);
4865 fail_unless(res < 0, "Unexpectedly explained error");
4866 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4867 strerror(errno), errno);
4868
4869 explainer->explain_symlink = test_explain_symlink;
4870 test_explain_return_eperm = TRUE;
4871
4872 res = pr_error_explain_symlink(err, NULL, NULL);
4873 fail_unless(res < 0, "Unexpectedly explained error");
4874 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4875 strerror(errno), errno);
4876
4877 test_explain_return_eperm = FALSE;
4878 res = pr_error_explain_symlink(err, NULL, NULL);
4879 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4880
4881 res = pr_error_unregister_explainer(p, &m, name);
4882 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4883 strerror(errno));
4884
4885 pr_error_destroy(err);
4886 }
4887 END_TEST
4888
4889 /* truncate */
test_explain_truncate(pool * err_pool,int xerrno,const char * path,off_t len,const char ** args)4890 static const char *test_explain_truncate(pool *err_pool, int xerrno,
4891 const char *path, off_t len, const char **args) {
4892
4893 if (test_explain_return_eperm == TRUE) {
4894 errno = EPERM;
4895 return NULL;
4896 }
4897
4898 return pstrdup(err_pool, "it was not meant to be");
4899 }
4900
START_TEST(error_explain_truncate_test)4901 START_TEST (error_explain_truncate_test) {
4902 int res, xerrno;
4903 pr_error_t *err;
4904 pr_error_explainer_t *explainer;
4905 module m;
4906 const char *name;
4907
4908 res = pr_error_explain_truncate(NULL, NULL, 0);
4909 fail_unless(res < 0, "Failed to handle null error");
4910 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4911 strerror(errno), errno);
4912
4913 xerrno = EINVAL;
4914 err = pr_error_create(p, xerrno);
4915 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4916
4917 res = pr_error_explain_truncate(err, NULL, 0);
4918 fail_unless(res < 0, "Unexpectedly explained error");
4919 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4920 strerror(errno), errno);
4921
4922 memset(&m, 0, sizeof(m));
4923 m.name = "error";
4924 name = "testsuite";
4925
4926 explainer = pr_error_register_explainer(p, &m, name);
4927 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4928 name, strerror(errno));
4929
4930 res = pr_error_explain_truncate(err, NULL, 0);
4931 fail_unless(res < 0, "Unexpectedly explained error");
4932 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4933 strerror(errno), errno);
4934
4935 explainer->explain_truncate = test_explain_truncate;
4936 test_explain_return_eperm = TRUE;
4937
4938 res = pr_error_explain_truncate(err, NULL, 0);
4939 fail_unless(res < 0, "Unexpectedly explained error");
4940 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
4941 strerror(errno), errno);
4942
4943 test_explain_return_eperm = FALSE;
4944 res = pr_error_explain_truncate(err, NULL, 0);
4945 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
4946
4947 res = pr_error_unregister_explainer(p, &m, name);
4948 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
4949 strerror(errno));
4950
4951 pr_error_destroy(err);
4952 }
4953 END_TEST
4954
4955 /* unlink */
test_explain_unlink(pool * err_pool,int xerrno,const char * path,const char ** args)4956 static const char *test_explain_unlink(pool *err_pool, int xerrno,
4957 const char *path, const char **args) {
4958
4959 if (test_explain_return_eperm == TRUE) {
4960 errno = EPERM;
4961 return NULL;
4962 }
4963
4964 return pstrdup(err_pool, "it was not meant to be");
4965 }
4966
START_TEST(error_explain_unlink_test)4967 START_TEST (error_explain_unlink_test) {
4968 int res, xerrno;
4969 pr_error_t *err;
4970 pr_error_explainer_t *explainer;
4971 module m;
4972 const char *name;
4973
4974 res = pr_error_explain_unlink(NULL, NULL);
4975 fail_unless(res < 0, "Failed to handle null error");
4976 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
4977 strerror(errno), errno);
4978
4979 xerrno = EINVAL;
4980 err = pr_error_create(p, xerrno);
4981 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
4982
4983 res = pr_error_explain_unlink(err, NULL);
4984 fail_unless(res < 0, "Unexpectedly explained error");
4985 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4986 strerror(errno), errno);
4987
4988 memset(&m, 0, sizeof(m));
4989 m.name = "error";
4990 name = "testsuite";
4991
4992 explainer = pr_error_register_explainer(p, &m, name);
4993 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
4994 name, strerror(errno));
4995
4996 res = pr_error_explain_unlink(err, NULL);
4997 fail_unless(res < 0, "Unexpectedly explained error");
4998 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
4999 strerror(errno), errno);
5000
5001 explainer->explain_unlink = test_explain_unlink;
5002 test_explain_return_eperm = TRUE;
5003
5004 res = pr_error_explain_unlink(err, NULL);
5005 fail_unless(res < 0, "Unexpectedly explained error");
5006 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
5007 strerror(errno), errno);
5008
5009 test_explain_return_eperm = FALSE;
5010 res = pr_error_explain_unlink(err, NULL);
5011 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
5012
5013 res = pr_error_unregister_explainer(p, &m, name);
5014 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
5015 strerror(errno));
5016
5017 pr_error_destroy(err);
5018 }
5019 END_TEST
5020
5021 /* utimes */
test_explain_utimes(pool * err_pool,int xerrno,const char * path,const struct timeval * tvs,const char ** args)5022 static const char *test_explain_utimes(pool *err_pool, int xerrno,
5023 const char *path, const struct timeval *tvs, const char **args) {
5024
5025 if (test_explain_return_eperm == TRUE) {
5026 errno = EPERM;
5027 return NULL;
5028 }
5029
5030 return pstrdup(err_pool, "it was not meant to be");
5031 }
5032
START_TEST(error_explain_utimes_test)5033 START_TEST (error_explain_utimes_test) {
5034 int res, xerrno;
5035 pr_error_t *err;
5036 pr_error_explainer_t *explainer;
5037 module m;
5038 const char *name;
5039
5040 res = pr_error_explain_utimes(NULL, NULL, NULL);
5041 fail_unless(res < 0, "Failed to handle null error");
5042 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
5043 strerror(errno), errno);
5044
5045 xerrno = EINVAL;
5046 err = pr_error_create(p, xerrno);
5047 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
5048
5049 res = pr_error_explain_utimes(err, NULL, NULL);
5050 fail_unless(res < 0, "Unexpectedly explained error");
5051 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
5052 strerror(errno), errno);
5053
5054 memset(&m, 0, sizeof(m));
5055 m.name = "error";
5056 name = "testsuite";
5057
5058 explainer = pr_error_register_explainer(p, &m, name);
5059 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
5060 name, strerror(errno));
5061
5062 res = pr_error_explain_utimes(err, NULL, NULL);
5063 fail_unless(res < 0, "Unexpectedly explained error");
5064 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
5065 strerror(errno), errno);
5066
5067 explainer->explain_utimes = test_explain_utimes;
5068 test_explain_return_eperm = TRUE;
5069
5070 res = pr_error_explain_utimes(err, NULL, NULL);
5071 fail_unless(res < 0, "Unexpectedly explained error");
5072 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
5073 strerror(errno), errno);
5074
5075 test_explain_return_eperm = FALSE;
5076 res = pr_error_explain_utimes(err, NULL, NULL);
5077 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
5078
5079 res = pr_error_unregister_explainer(p, &m, name);
5080 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
5081 strerror(errno));
5082
5083 pr_error_destroy(err);
5084 }
5085 END_TEST
5086
5087 /* write */
test_explain_write(pool * err_pool,int xerrno,int fd,const void * buf,size_t sz,const char ** args)5088 static const char *test_explain_write(pool *err_pool, int xerrno, int fd,
5089 const void *buf, size_t sz, const char **args) {
5090
5091 if (test_explain_return_eperm == TRUE) {
5092 errno = EPERM;
5093 return NULL;
5094 }
5095
5096 return pstrdup(err_pool, "it was not meant to be");
5097 }
5098
START_TEST(error_explain_write_test)5099 START_TEST (error_explain_write_test) {
5100 int res, xerrno;
5101 pr_error_t *err;
5102 pr_error_explainer_t *explainer;
5103 module m;
5104 const char *name;
5105
5106 res = pr_error_explain_write(NULL, -1, NULL, 0);
5107 fail_unless(res < 0, "Failed to handle null error");
5108 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
5109 strerror(errno), errno);
5110
5111 xerrno = EINVAL;
5112 err = pr_error_create(p, xerrno);
5113 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
5114
5115 res = pr_error_explain_write(err, -1, NULL, 0);
5116 fail_unless(res < 0, "Unexpectedly explained error");
5117 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
5118 strerror(errno), errno);
5119
5120 memset(&m, 0, sizeof(m));
5121 m.name = "error";
5122 name = "testsuite";
5123
5124 explainer = pr_error_register_explainer(p, &m, name);
5125 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
5126 name, strerror(errno));
5127
5128 res = pr_error_explain_write(err, -1, NULL, 0);
5129 fail_unless(res < 0, "Unexpectedly explained error");
5130 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
5131 strerror(errno), errno);
5132
5133 explainer->explain_write = test_explain_write;
5134 test_explain_return_eperm = TRUE;
5135
5136 res = pr_error_explain_write(err, -1, NULL, 0);
5137 fail_unless(res < 0, "Unexpectedly explained error");
5138 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
5139 strerror(errno), errno);
5140
5141 test_explain_return_eperm = FALSE;
5142 res = pr_error_explain_write(err, -1, NULL, 0);
5143 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
5144
5145 res = pr_error_unregister_explainer(p, &m, name);
5146 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
5147 strerror(errno));
5148
5149 pr_error_destroy(err);
5150 }
5151 END_TEST
5152
5153 /* writev */
test_explain_writev(pool * err_pool,int xerrno,int fd,const struct iovec * iov,int iov_len,const char ** args)5154 static const char *test_explain_writev(pool *err_pool, int xerrno, int fd,
5155 const struct iovec *iov, int iov_len, const char **args) {
5156
5157 if (test_explain_return_eperm == TRUE) {
5158 errno = EPERM;
5159 return NULL;
5160 }
5161
5162 return pstrdup(err_pool, "it was not meant to be");
5163 }
5164
START_TEST(error_explain_writev_test)5165 START_TEST (error_explain_writev_test) {
5166 int res, xerrno;
5167 pr_error_t *err;
5168 pr_error_explainer_t *explainer;
5169 module m;
5170 const char *name;
5171
5172 res = pr_error_explain_writev(NULL, -1, NULL, 0);
5173 fail_unless(res < 0, "Failed to handle null error");
5174 fail_unless(errno == EINVAL, "Expected EINVAL (%d), got %s (%d)", EINVAL,
5175 strerror(errno), errno);
5176
5177 xerrno = EINVAL;
5178 err = pr_error_create(p, xerrno);
5179 fail_unless(err != NULL, "Failed to allocate error: %s", strerror(errno));
5180
5181 res = pr_error_explain_writev(err, -1, NULL, 0);
5182 fail_unless(res < 0, "Unexpectedly explained error");
5183 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
5184 strerror(errno), errno);
5185
5186 memset(&m, 0, sizeof(m));
5187 m.name = "error";
5188 name = "testsuite";
5189
5190 explainer = pr_error_register_explainer(p, &m, name);
5191 fail_unless(explainer != NULL, "Failed to register '%s' explainer: %s",
5192 name, strerror(errno));
5193
5194 res = pr_error_explain_writev(err, -1, NULL, 0);
5195 fail_unless(res < 0, "Unexpectedly explained error");
5196 fail_unless(errno == ENOSYS, "Expected ENOSYS (%d), got %s (%d)", ENOSYS,
5197 strerror(errno), errno);
5198
5199 explainer->explain_writev = test_explain_writev;
5200 test_explain_return_eperm = TRUE;
5201
5202 res = pr_error_explain_writev(err, -1, NULL, 0);
5203 fail_unless(res < 0, "Unexpectedly explained error");
5204 fail_unless(errno == EPERM, "Expected EPERM (%d), got %s (%d)", EPERM,
5205 strerror(errno), errno);
5206
5207 test_explain_return_eperm = FALSE;
5208 res = pr_error_explain_writev(err, -1, NULL, 0);
5209 fail_unless(res == 0, "Failed to explain error: %s", strerror(errno));
5210
5211 res = pr_error_unregister_explainer(p, &m, name);
5212 fail_unless(res == 0, "Failed to unregister '%s' explainer: %s", name,
5213 strerror(errno));
5214
5215 pr_error_destroy(err);
5216 }
5217 END_TEST
5218
tests_get_error_suite(void)5219 Suite *tests_get_error_suite(void) {
5220 Suite *suite;
5221 TCase *testcase;
5222
5223 suite = suite_create("error");
5224 testcase = tcase_create("base");
5225
5226 tcase_add_checked_fixture(testcase, set_up, tear_down);
5227
5228 tcase_add_test(testcase, error_create_test);
5229 tcase_add_test(testcase, error_destroy_test);
5230 tcase_add_test(testcase, error_get_who_test);
5231 tcase_add_test(testcase, error_set_why_test);
5232 tcase_add_test(testcase, error_set_where_test);
5233 tcase_add_test(testcase, error_set_what_test);
5234 tcase_add_test(testcase, error_explainer_test);
5235 tcase_add_test(testcase, error_strerror_minimal_test);
5236 tcase_add_test(testcase, error_strerror_terse_test);
5237 tcase_add_test(testcase, error_strerror_detailed_test);
5238 tcase_add_test(testcase, error_strerror_detailed_explained_test);
5239
5240 tcase_add_test(testcase, error_explain_accept_test);
5241 tcase_add_test(testcase, error_explain_bind_test);
5242 tcase_add_test(testcase, error_explain_chdir_test);
5243 tcase_add_test(testcase, error_explain_chmod_test);
5244 tcase_add_test(testcase, error_explain_chown_test);
5245 tcase_add_test(testcase, error_explain_chroot_test);
5246 tcase_add_test(testcase, error_explain_close_test);
5247 tcase_add_test(testcase, error_explain_closedir_test);
5248 tcase_add_test(testcase, error_explain_connect_test);
5249 tcase_add_test(testcase, error_explain_fchmod_test);
5250 tcase_add_test(testcase, error_explain_fchown_test);
5251 tcase_add_test(testcase, error_explain_fclose_test);
5252 tcase_add_test(testcase, error_explain_fcntl_test);
5253 tcase_add_test(testcase, error_explain_fdopen_test);
5254 tcase_add_test(testcase, error_explain_flock_test);
5255 tcase_add_test(testcase, error_explain_fopen_test);
5256 tcase_add_test(testcase, error_explain_fork_test);
5257 tcase_add_test(testcase, error_explain_fstat_test);
5258 tcase_add_test(testcase, error_explain_fstatfs_test);
5259 tcase_add_test(testcase, error_explain_fstatvfs_test);
5260 tcase_add_test(testcase, error_explain_fsync_test);
5261 tcase_add_test(testcase, error_explain_ftruncate_test);
5262 tcase_add_test(testcase, error_explain_futimes_test);
5263 tcase_add_test(testcase, error_explain_getaddrinfo_test);
5264 tcase_add_test(testcase, error_explain_gethostbyname_test);
5265 tcase_add_test(testcase, error_explain_gethostbyname2_test);
5266 tcase_add_test(testcase, error_explain_gethostname_test);
5267 tcase_add_test(testcase, error_explain_getnameinfo_test);
5268 tcase_add_test(testcase, error_explain_getpeername_test);
5269 tcase_add_test(testcase, error_explain_getrlimit_test);
5270 tcase_add_test(testcase, error_explain_getsockname_test);
5271 tcase_add_test(testcase, error_explain_getsockopt_test);
5272 tcase_add_test(testcase, error_explain_lchown_test);
5273 tcase_add_test(testcase, error_explain_link_test);
5274 tcase_add_test(testcase, error_explain_listen_test);
5275 tcase_add_test(testcase, error_explain_lseek_test);
5276 tcase_add_test(testcase, error_explain_lstat_test);
5277 tcase_add_test(testcase, error_explain_mkdir_test);
5278 tcase_add_test(testcase, error_explain_mkdtemp_test);
5279 tcase_add_test(testcase, error_explain_mkstemp_test);
5280 tcase_add_test(testcase, error_explain_open_test);
5281 tcase_add_test(testcase, error_explain_opendir_test);
5282 tcase_add_test(testcase, error_explain_read_test);
5283 tcase_add_test(testcase, error_explain_readdir_test);
5284 tcase_add_test(testcase, error_explain_readlink_test);
5285 tcase_add_test(testcase, error_explain_readv_test);
5286 tcase_add_test(testcase, error_explain_rename_test);
5287 tcase_add_test(testcase, error_explain_rmdir_test);
5288 tcase_add_test(testcase, error_explain_setegid_test);
5289 tcase_add_test(testcase, error_explain_seteuid_test);
5290 tcase_add_test(testcase, error_explain_setgid_test);
5291 tcase_add_test(testcase, error_explain_setregid_test);
5292 tcase_add_test(testcase, error_explain_setresgid_test);
5293 tcase_add_test(testcase, error_explain_setresuid_test);
5294 tcase_add_test(testcase, error_explain_setreuid_test);
5295 tcase_add_test(testcase, error_explain_setrlimit_test);
5296 tcase_add_test(testcase, error_explain_setsockopt_test);
5297 tcase_add_test(testcase, error_explain_setuid_test);
5298 tcase_add_test(testcase, error_explain_socket_test);
5299 tcase_add_test(testcase, error_explain_stat_test);
5300 tcase_add_test(testcase, error_explain_statfs_test);
5301 tcase_add_test(testcase, error_explain_statvfs_test);
5302 tcase_add_test(testcase, error_explain_symlink_test);
5303 tcase_add_test(testcase, error_explain_truncate_test);
5304 tcase_add_test(testcase, error_explain_unlink_test);
5305 tcase_add_test(testcase, error_explain_utimes_test);
5306 tcase_add_test(testcase, error_explain_write_test);
5307 tcase_add_test(testcase, error_explain_writev_test);
5308
5309 suite_add_tcase(suite, testcase);
5310 return suite;
5311 }
5312