1/* Create simple DB database from textual input.
2 Copyright (C) 1996-2021 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public
8 License as published by the Free Software Foundation; either
9 version 2.1 of the License, or (at your option) any later version.
10
11 The GNU C Library is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; if not, see
18 <https://www.gnu.org/licenses/>. */
19
20#include <argp.h>
21#include <assert.h>
22#include <ctype.h>
23#include <errno.h>
24#include <error.h>
25#include <fcntl.h>
26#include <inttypes.h>
27#include <libintl.h>
28#include <locale.h>
29#include <search.h>
30#include <stdbool.h>
31#include <stdio.h>
32#include <stdlib.h>
33#include <string.h>
34#include <unistd.h>
35#include <stdint.h>
36#include <sys/mman.h>
37#include <sys/param.h>
38#include <sys/stat.h>
39#include <sys/uio.h>
40#include "nss_db/nss_db.h"
41#include <libc-diag.h>
42
43/* Get libc version number. */
44#include "../version.h"
45
46/* The hashing function we use. */
47#include "../intl/hash-string.h"
48
49/* SELinux support. */
50#ifdef HAVE_SELINUX
51# include <selinux/selinux.h>
52#endif
53
54#ifndef MAP_POPULATE
55# define MAP_POPULATE 0
56#endif
57
58#define PACKAGE _libc_intl_domainname
59
60/* List of data bases. */
61struct database
62{
63 char dbid;
64 bool extra_string;
65 struct database *next;
66 void *entries;
67 size_t nentries;
68 size_t nhashentries;
69 stridx_t *hashtable;
70 size_t keystrlen;
71 stridx_t *keyidxtab;
72 char *keystrtab;
73} *databases;
74static size_t ndatabases;
75static size_t nhashentries_total;
76static size_t valstrlen;
77static void *valstrtree;
78static char *valstrtab;
79static size_t extrastrlen;
80
81/* Database entry. */
82struct dbentry
83{
84 stridx_t validx;
85 uint32_t hashval;
86 char str[0];
87};
88
89/* Stored string entry. */
90struct valstrentry
91{
92 stridx_t idx;
93 bool extra_string;
94 char str[0];
95};
96
97
98/* True if any entry has been added. */
99static bool any_dbentry;
100
101/* If non-zero convert key to lower case. */
102static int to_lowercase;
103
104/* If non-zero print content of input file, one entry per line. */
105static int do_undo;
106
107/* If non-zero do not print informational messages. */
108static int be_quiet;
109
110/* Name of output file. */
111static const char *output_name;
112
113/* Name and version of program. */
114static void print_version (FILE *stream, struct argp_state *state);
115void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;
116
117/* Definitions of arguments for argp functions. */
118static const struct argp_option options[] =
119{
120 { "fold-case", 'f', NULL, 0, N_("Convert key to lower case") },
121 { "output", 'o', N_("NAME"), 0, N_("Write output to file NAME") },
122 { "quiet", 'q', NULL, 0,
123 N_("Do not print messages while building database") },
124 { "undo", 'u', NULL, 0,
125 N_("Print content of database file, one entry a line") },
126 { "generated", 'g', N_("CHAR"), 0,
127 N_("Generated line not part of iteration") },
128 { NULL, 0, NULL, 0, NULL }
129};
130
131/* Short description of program. */
132static const char doc[] = N_("Create simple database from textual input.");
133
134/* Strings for arguments in help texts. */
135static const char args_doc[] = N_("\
136INPUT-FILE OUTPUT-FILE\n-o OUTPUT-FILE INPUT-FILE\n-u INPUT-FILE");
137
138/* Prototype for option handler. */
139static error_t parse_opt (int key, char *arg, struct argp_state *state);
140
141/* Function to print some extra text in the help message. */
142static char *more_help (int key, const char *text, void *input);
143
144/* Data structure to communicate with argp functions. */
145static struct argp argp =
146{
147 options, parse_opt, args_doc, doc, NULL, more_help
148};
149
150
151/* List of databases which are not part of the iteration table. */
152static struct db_option
153{
154 char dbid;
155 struct db_option *next;
156} *db_options;
157
158
159/* Prototypes for local functions. */
160static int process_input (FILE *input, const char *inname,
161 int to_lowercase, int be_quiet);
162static int print_database (int fd);
163static void compute_tables (void);
164static int write_output (int fd);
165
166/* SELinux support. */
167#ifdef HAVE_SELINUX
168/* Set the SELinux file creation context for the given file. */
169static void set_file_creation_context (const char *outname, mode_t mode);
170static void reset_file_creation_context (void);
171#else
172# define set_file_creation_context(_outname,_mode)
173# define reset_file_creation_context()
174#endif
175
176
177/* External functions. */
178#include <programs/xmalloc.h>
179
180
181int
182main (int argc, char *argv[])
183{
184 const char *input_name;
185 FILE *input_file;
186 int remaining;
187 int mode = 0644;
188
189 /* Set locale via LC_ALL. */
190 setlocale (LC_ALL, "");
191
192 /* Set the text message domain. */
193 textdomain (_libc_intl_domainname);
194
195 /* Initialize local variables. */
196 input_name = NULL;
197
198 /* Parse and process arguments. */
199 argp_parse (&argp, argc, argv, 0, &remaining, NULL);
200
201 /* Determine file names. */
202 if (do_undo || output_name != NULL)
203 {
204 if (remaining + 1 != argc)
205 {
206 wrong_arguments:
207 error (0, 0, gettext ("wrong number of arguments"));
208 argp_help (&argp, stdout, ARGP_HELP_SEE,
209 program_invocation_short_name);
210 exit (1);
211 }
212 input_name = argv[remaining];
213 }
214 else
215 {
216 if (remaining + 2 != argc)
217 goto wrong_arguments;
218
219 input_name = argv[remaining++];
220 output_name = argv[remaining];
221 }
222
223 /* Special handling if we are asked to print the database. */
224 if (do_undo)
225 {
226 int fd = open (input_name, O_RDONLY);
227 if (fd == -1)
228 error (EXIT_FAILURE, errno, gettext ("cannot open database file `%s'"),
229 input_name);
230
231 int status = print_database (fd);
232
233 close (fd);
234
235 return status;
236 }
237
238 /* Open input file. */
239 if (strcmp (input_name, "-") == 0 || strcmp (input_name, "/dev/stdin") == 0)
240 input_file = stdin;
241 else
242 {
243 struct stat64 st;
244
245 input_file = fopen64 (input_name, "r");
246 if (input_file == NULL)
247 error (EXIT_FAILURE, errno, gettext ("cannot open input file `%s'"),
248 input_name);
249
250 /* Get the access rights from the source file. The output file should
251 have the same. */
252 if (fstat64 (fileno (input_file), &st) >= 0)
253 mode = st.st_mode & ACCESSPERMS;
254 }
255
256 /* Start the real work. */
257 int status = process_input (input_file, input_name, to_lowercase, be_quiet);
258
259 /* Close files. */
260 if (input_file != stdin)
261 fclose (input_file);
262
263 /* No need to continue when we did not read the file successfully. */
264 if (status != EXIT_SUCCESS)
265 return status;
266
267 /* Bail out if nothing is to be done. */
268 if (!any_dbentry)
269 {
270 if (be_quiet)
271 return EXIT_SUCCESS;
272 else
273 error (EXIT_SUCCESS, 0, gettext ("no entries to be processed"));
274 }
275
276 /* Compute hash and string tables. */
277 compute_tables ();
278
279 /* Open output file. This must not be standard output so we don't
280 handle "-" and "/dev/stdout" special. */
281 char *tmp_output_name;
282 if (asprintf (&tmp_output_name, "%s.XXXXXX", output_name) == -1)
283 error (EXIT_FAILURE, errno, gettext ("cannot create temporary file name"));
284
285 set_file_creation_context (output_name, mode);
286 int fd = mkstemp (tmp_output_name);
287 reset_file_creation_context ();
288 if (fd == -1)
289 error (EXIT_FAILURE, errno, gettext ("cannot create temporary file"));
290
291 status = write_output (fd);
292
293 if (status == EXIT_SUCCESS)
294 {
295 struct stat64 st;
296
297 if (fstat64 (fd, &st) == 0)
298 {
299 if ((st.st_mode & ACCESSPERMS) != mode)
300 /* We ignore problems with changing the mode. */
301 fchmod (fd, mode);
302 }
303 else
304 {
305 error (0, errno, gettext ("cannot stat newly created file"));
306 status = EXIT_FAILURE;
307 }
308 }
309
310 close (fd);
311
312 if (status == EXIT_SUCCESS)
313 {
314 if (rename (tmp_output_name, output_name) != 0)
315 {
316 error (0, errno, gettext ("cannot rename temporary file"));
317 status = EXIT_FAILURE;
318 goto do_unlink;
319 }
320 }
321 else
322 do_unlink:
323 unlink (tmp_output_name);
324
325 return status;
326}
327
328
329/* Handle program arguments. */
330static error_t
331parse_opt (int key, char *arg, struct argp_state *state)
332{
333 struct db_option *newp;
334
335 switch (key)
336 {
337 case 'f':
338 to_lowercase = 1;
339 break;
340 case 'o':
341 output_name = arg;
342 break;
343 case 'q':
344 be_quiet = 1;
345 break;
346 case 'u':
347 do_undo = 1;
348 break;
349 case 'g':
350 newp = xmalloc (sizeof (*newp));
351 newp->dbid = arg[0];
352 newp->next = db_options;
353 db_options = newp;
354 break;
355 default:
356 return ARGP_ERR_UNKNOWN;
357 }
358 return 0;
359}
360
361
362static char *
363more_help (int key, const char *text, void *input)
364{
365 char *tp = NULL;
366 switch (key)
367 {
368 case ARGP_KEY_HELP_EXTRA:
369 /* We print some extra information. */
370 if (asprintf (&tp, gettext ("\
371For bug reporting instructions, please see:\n\
372%s.\n"), REPORT_BUGS_TO) < 0)
373 return NULL;
374 return tp;
375 default:
376 break;
377 }
378 return (char *) text;
379}
380
381/* Print the version information. */
382static void
383print_version (FILE *stream, struct argp_state *state)
384{
385 fprintf (stream, "makedb %s%s\n", PKGVERSION, VERSION);
386 fprintf (stream, gettext ("\
387Copyright (C) %s Free Software Foundation, Inc.\n\
388This is free software; see the source for copying conditions. There is NO\n\
389warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
390"), "2021");
391 fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
392}
393
394
395static int
396dbentry_compare (const void *p1, const void *p2)
397{
398 const struct dbentry *d1 = (const struct dbentry *) p1;
399 const struct dbentry *d2 = (const struct dbentry *) p2;
400
401 if (d1->hashval != d2->hashval)
402 return d1->hashval < d2->hashval ? -1 : 1;
403
404 return strcmp (d1->str, d2->str);
405}
406
407
408static int
409valstr_compare (const void *p1, const void *p2)
410{
411 const struct valstrentry *d1 = (const struct valstrentry *) p1;
412 const struct valstrentry *d2 = (const struct valstrentry *) p2;
413
414 return strcmp (d1->str, d2->str);
415}
416
417
418static int
419process_input (FILE *input, const char *inname, int to_lowercase, int be_quiet)
420{
421 char *line;
422 size_t linelen;
423 int status;
424 size_t linenr;
425
426 line = NULL;
427 linelen = 0;
428 status = EXIT_SUCCESS;
429 linenr = 0;
430
431 struct database *last_database = NULL;
432
433 while (!feof_unlocked (input))
434 {
435 ssize_t n = getline (&line, &linelen, input);
436 if (n < 0)
437 /* This means end of file or some bug. */
438 break;
439 if (n == 0)
440 /* Short read. Probably interrupted system call. */
441 continue;
442
443 ++linenr;
444
445 if (line[n - 1] == '\n')
446 /* Remove trailing newline. */
447 line[--n] = '\0';
448
449 char *cp = line;
450 while (isspace (*cp))
451 ++cp;
452
453 if (*cp == '#' || *cp == '\0')
454 /* First non-space character in line '#': it's a comment.
455 Also go to the next line if it is empty except for whitespaces. */
456 continue;
457
458 /* Skip over the character indicating the database so that it is not
459 affected by TO_LOWERCASE. */
460 char *key = cp++;
461 while (*cp != '\0' && !isspace (*cp))
462 {
463 if (to_lowercase)
464 *cp = tolower (*cp);
465 ++cp;
466 }
467
468 if (*cp == '\0')
469 /* It's a line without a value field. */
470 continue;
471
472 *cp++ = '\0';
473 size_t keylen = cp - key;
474
475 while (isspace (*cp))
476 ++cp;
477
478 char *data = cp;
479 size_t datalen = (&line[n] - cp) + 1;
480
481 /* Find the database. */
482 if (last_database == NULL || last_database->dbid != key[0])
483 {
484 last_database = databases;
485 while (last_database != NULL && last_database->dbid != key[0])
486 last_database = last_database->next;
487
488 if (last_database == NULL)
489 {
490 last_database = xmalloc (sizeof (*last_database));
491 last_database->dbid = key[0];
492 last_database->extra_string = false;
493 last_database->next = databases;
494 last_database->entries = NULL;
495 last_database->nentries = 0;
496 last_database->keystrlen = 0;
497 databases = last_database;
498
499 struct db_option *runp = db_options;
500 while (runp != NULL)
501 if (runp->dbid == key[0])
502 {
503 last_database->extra_string = true;
504 break;
505 }
506 else
507 runp = runp->next;
508 }
509 }
510
511 /* Skip the database selector. */
512 ++key;
513 --keylen;
514
515 /* Store the data. */
516 struct valstrentry *nentry = xmalloc (sizeof (struct valstrentry)
517 + datalen);
518 if (last_database->extra_string)
519 nentry->idx = extrastrlen;
520 else
521 nentry->idx = valstrlen;
522 nentry->extra_string = last_database->extra_string;
523 memcpy (nentry->str, data, datalen);
524
525 struct valstrentry **fdata = tsearch (nentry, &valstrtree,
526 valstr_compare);
527 if (fdata == NULL)
528 error (EXIT_FAILURE, errno, gettext ("cannot create search tree"));
529
530 if (*fdata != nentry)
531 {
532 /* We can reuse a string. */
533 free (nentry);
534 nentry = *fdata;
535 }
536 else
537 if (last_database->extra_string)
538 extrastrlen += datalen;
539 else
540 valstrlen += datalen;
541
542 /* Store the key. */
543 struct dbentry *newp = xmalloc (sizeof (struct dbentry) + keylen);
544 newp->validx = nentry->idx;
545 newp->hashval = __hash_string (key);
546 memcpy (newp->str, key, keylen);
547
548 struct dbentry **found = tsearch (newp, &last_database->entries,
549 dbentry_compare);
550 if (found == NULL)
551 error (EXIT_FAILURE, errno, gettext ("cannot create search tree"));
552
553 if (*found != newp)
554 {
555 free (newp);
556 if (!be_quiet)
557 error_at_line (0, 0, inname, linenr, gettext ("duplicate key"));
558 continue;
559 }
560
561 ++last_database->nentries;
562 last_database->keystrlen += keylen;
563
564 any_dbentry = true;
565 }
566
567 if (ferror_unlocked (input))
568 {
569 error (0, 0, gettext ("problems while reading `%s'"), inname);
570 status = EXIT_FAILURE;
571 }
572
573 return status;
574}
575
576
577static void
578copy_valstr (const void *nodep, const VISIT which, const int depth)
579{
580 if (which != leaf && which != postorder)
581 return;
582
583 const struct valstrentry *p = *(const struct valstrentry **) nodep;
584
585 strcpy (valstrtab + (p->extra_string ? valstrlen : 0) + p->idx, p->str);
586}
587
588
589/* Determine if the candidate is prime by using a modified trial division
590 algorithm. The candidate must be both odd and greater than 4. */
591static int
592is_prime (size_t candidate)
593{
594 size_t divn = 3;
595 size_t sq = divn * divn;
596
597 assert (candidate > 4 && candidate % 2 != 0);
598
599 while (sq < candidate && candidate % divn != 0)
600 {
601 ++divn;
602 sq += 4 * divn;
603 ++divn;
604 }
605
606 return candidate % divn != 0;
607}
608
609
610static size_t
611next_prime (size_t seed)
612{
613 /* Make sure that we're always greater than 4. */
614 seed = (seed + 4) | 1;
615
616 while (!is_prime (seed))
617 seed += 2;
618
619 return seed;
620}
621
622
623static void
624compute_tables (void)
625{
626 valstrtab = xmalloc (roundup (valstrlen + extrastrlen, sizeof (stridx_t)));
627 while ((valstrlen + extrastrlen) % sizeof (stridx_t) != 0)
628 valstrtab[valstrlen++] = '\0';
629 twalk (valstrtree, copy_valstr);
630
631 static struct database *db;
632 for (db = databases; db != NULL; db = db->next)
633 if (db->nentries != 0)
634 {
635 ++ndatabases;
636
637 /* We simply use an odd number large than twice the number of
638 elements to store in the hash table for the size. This gives
639 enough efficiency. */
640#define TEST_RANGE 30
641 size_t nhashentries_min = next_prime (db->nentries < TEST_RANGE
642 ? db->nentries
643 : db->nentries * 2 - TEST_RANGE);
644 size_t nhashentries_max = MAX (nhashentries_min, db->nentries * 4);
645 size_t nhashentries_best = nhashentries_min;
646 size_t chainlength_best = db->nentries;
647
648 db->hashtable = xmalloc (2 * nhashentries_max * sizeof (stridx_t)
649 + db->keystrlen);
650 db->keyidxtab = db->hashtable + nhashentries_max;
651 db->keystrtab = (char *) (db->keyidxtab + nhashentries_max);
652
653 static size_t max_chainlength;
654 static char *wp;
655 static size_t nhashentries;
656 static bool copy_string;
657
658 void add_key(const void *nodep, const VISIT which, const int depth)
659 {
660 if (which != leaf && which != postorder)
661 return;
662
663 const struct dbentry *dbe = *(const struct dbentry **) nodep;
664
665 ptrdiff_t stridx;
666 if (copy_string)
667 {
668 stridx = wp - db->keystrtab;
669 wp = stpcpy (wp, dbe->str) + 1;
670 }
671 else
672 stridx = 0;
673
674 size_t hidx = dbe->hashval % nhashentries;
675 size_t hval2 = 1 + dbe->hashval % (nhashentries - 2);
676 size_t chainlength = 0;
677
678 while (db->hashtable[hidx] != ~((stridx_t) 0))
679 {
680 ++chainlength;
681 if ((hidx += hval2) >= nhashentries)
682 hidx -= nhashentries;
683 }
684
685 db->hashtable[hidx] = ((db->extra_string ? valstrlen : 0)
686 + dbe->validx);
687 db->keyidxtab[hidx] = stridx;
688
689 max_chainlength = MAX (max_chainlength, chainlength);
690 }
691
692 copy_string = false;
693 nhashentries = nhashentries_min;
694 for (size_t cnt = 0; cnt < TEST_RANGE; ++cnt)
695 {
696 memset (db->hashtable, '\xff', nhashentries * sizeof (stridx_t));
697
698 max_chainlength = 0;
699 wp = db->keystrtab;
700
701 twalk (db->entries, add_key);
702
703 if (max_chainlength == 0)
704 {
705 /* No need to look further, this is as good as it gets. */
706 nhashentries_best = nhashentries;
707 break;
708 }
709
710 if (max_chainlength < chainlength_best)
711 {
712 chainlength_best = max_chainlength;
713 nhashentries_best = nhashentries;
714 }
715
716 nhashentries = next_prime (nhashentries + 1);
717 if (nhashentries > nhashentries_max)
718 break;
719 }
720
721 /* Recompute the best table again, this time fill in the strings. */
722 nhashentries = nhashentries_best;
723 memset (db->hashtable, '\xff',
724 2 * nhashentries_max * sizeof (stridx_t));
725 copy_string = true;
726 wp = db->keystrtab;
727
728 twalk (db->entries, add_key);
729
730 db->nhashentries = nhashentries_best;
731 nhashentries_total += nhashentries_best;
732 }
733}
734
735
736static int
737write_output (int fd)
738{
739 struct nss_db_header *header;
740 uint64_t file_offset = (sizeof (struct nss_db_header)
741 + (ndatabases * sizeof (header->dbs[0])));
742 header = alloca (file_offset);
743
744 header->magic = NSS_DB_MAGIC;
745 header->ndbs = ndatabases;
746 header->valstroffset = file_offset;
747 header->valstrlen = valstrlen;
748
749 size_t filled_dbs = 0;
750 size_t iov_nelts = 2 + ndatabases * 3;
751 struct iovec iov[iov_nelts];
752 iov[0].iov_base = header;
753 iov[0].iov_len = file_offset;
754
755 iov[1].iov_base = valstrtab;
756 iov[1].iov_len = valstrlen + extrastrlen;
757 file_offset += iov[1].iov_len;
758
759 size_t keydataoffset = file_offset + nhashentries_total * sizeof (stridx_t);
760 for (struct database *db = databases; db != NULL; db = db->next)
761 if (db->entries != NULL)
762 {
763 assert (file_offset % sizeof (stridx_t) == 0);
764 assert (filled_dbs < ndatabases);
765
766 header->dbs[filled_dbs].id = db->dbid;
767 memset (header->dbs[filled_dbs].pad, '\0',
768 sizeof (header->dbs[0].pad));
769 header->dbs[filled_dbs].hashsize = db->nhashentries;
770
771 iov[2 + filled_dbs].iov_base = db->hashtable;
772 iov[2 + filled_dbs].iov_len = db->nhashentries * sizeof (stridx_t);
773 header->dbs[filled_dbs].hashoffset = file_offset;
774 file_offset += iov[2 + filled_dbs].iov_len;
775
776 iov[2 + ndatabases + filled_dbs * 2].iov_base = db->keyidxtab;
777 iov[2 + ndatabases + filled_dbs * 2].iov_len
778 = db->nhashentries * sizeof (stridx_t);
779 header->dbs[filled_dbs].keyidxoffset = keydataoffset;
780 keydataoffset += iov[2 + ndatabases + filled_dbs * 2].iov_len;
781
782 iov[3 + ndatabases + filled_dbs * 2].iov_base = db->keystrtab;
783 iov[3 + ndatabases + filled_dbs * 2].iov_len = db->keystrlen;
784 header->dbs[filled_dbs].keystroffset = keydataoffset;
785 keydataoffset += iov[3 + ndatabases + filled_dbs * 2].iov_len;
786
787 ++filled_dbs;
788 }
789
790 assert (filled_dbs == ndatabases);
791 assert (file_offset == (iov[0].iov_len + iov[1].iov_len
792 + nhashentries_total * sizeof (stridx_t)));
793 header->allocate = file_offset;
794
795#if __GNUC_PREREQ (10, 0) && !__GNUC_PREREQ (11, 0)
796 DIAG_PUSH_NEEDS_COMMENT;
797 /* Avoid GCC 10 false positive warning: specified size exceeds maximum
798 object size. */
799 DIAG_IGNORE_NEEDS_COMMENT (10, "-Wstringop-overflow");
800#endif
801
802 assert (iov_nelts <= INT_MAX);
803 if (writev (fd, iov, iov_nelts) != keydataoffset)
804 {
805 error (0, errno, gettext ("failed to write new database file"));
806 return EXIT_FAILURE;
807 }
808
809#if __GNUC_PREREQ (10, 0) && !__GNUC_PREREQ (11, 0)
810 DIAG_POP_NEEDS_COMMENT;
811#endif
812
813 return EXIT_SUCCESS;
814}
815
816
817static int
818print_database (int fd)
819{
820 struct stat64 st;
821 if (fstat64 (fd, &st) != 0)
822 error (EXIT_FAILURE, errno, gettext ("cannot stat database file"));
823
824 const struct nss_db_header *header = mmap (NULL, st.st_size, PROT_READ,
825 MAP_PRIVATE|MAP_POPULATE, fd, 0);
826 if (header == MAP_FAILED)
827 error (EXIT_FAILURE, errno, gettext ("cannot map database file"));
828
829 if (header->magic != NSS_DB_MAGIC)
830 error (EXIT_FAILURE, 0, gettext ("file not a database file"));
831
832 const char *valstrtab = (const char *) header + header->valstroffset;
833
834 for (unsigned int dbidx = 0; dbidx < header->ndbs; ++dbidx)
835 {
836 const stridx_t *stridxtab
837 = ((const stridx_t *) ((const char *) header
838 + header->dbs[dbidx].keyidxoffset));
839 const char *keystrtab
840 = (const char *) header + header->dbs[dbidx].keystroffset;
841 const stridx_t *hashtab
842 = (const stridx_t *) ((const char *) header
843 + header->dbs[dbidx].hashoffset);
844
845 for (uint32_t hidx = 0; hidx < header->dbs[dbidx].hashsize; ++hidx)
846 if (hashtab[hidx] != ~((stridx_t) 0))
847 printf ("%c%s %s\n",
848 header->dbs[dbidx].id,
849 keystrtab + stridxtab[hidx],
850 valstrtab + hashtab[hidx]);
851 }
852
853 return EXIT_SUCCESS;
854}
855
856
857#ifdef HAVE_SELINUX
858
859/* security_context_t and matchpathcon (along with several other symbols) were
860 marked as deprecated by the SELinux API starting from version 3.1. We use
861 them here, but should eventually switch to the newer API. */
862DIAG_PUSH_NEEDS_COMMENT
863DIAG_IGNORE_NEEDS_COMMENT (10, "-Wdeprecated-declarations");
864
865static void
866set_file_creation_context (const char *outname, mode_t mode)
867{
868 static int enabled;
869 static int enforcing;
870 security_context_t ctx;
871
872 /* Check if SELinux is enabled, and remember. */
873 if (enabled == 0)
874 enabled = is_selinux_enabled () ? 1 : -1;
875 if (enabled < 0)
876 return;
877
878 /* Check if SELinux is enforcing, and remember. */
879 if (enforcing == 0)
880 enforcing = security_getenforce () ? 1 : -1;
881
882 /* Determine the context which the file should have. */
883 ctx = NULL;
884 if (matchpathcon (outname, S_IFREG | mode, &ctx) == 0 && ctx != NULL)
885 {
886 if (setfscreatecon (ctx) != 0)
887 error (enforcing > 0 ? EXIT_FAILURE : 0, 0,
888 gettext ("cannot set file creation context for `%s'"),
889 outname);
890
891 freecon (ctx);
892 }
893}
894DIAG_POP_NEEDS_COMMENT
895
896static void
897reset_file_creation_context (void)
898{
899 setfscreatecon (NULL);
900}
901#endif
902