1 /* Create simple DB database from textual input.
2 Copyright (C) 1996-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library 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 GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 #include <argp.h>
20 #include <assert.h>
21 #include <ctype.h>
22 #include <errno.h>
23 #include <error.h>
24 #include <fcntl.h>
25 #include <inttypes.h>
26 #include <libintl.h>
27 #include <locale.h>
28 #include <search.h>
29 #include <stdbool.h>
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33 #include <unistd.h>
34 #include <stdint.h>
35 #include <sys/mman.h>
36 #include <sys/param.h>
37 #include <sys/stat.h>
38 #include <sys/uio.h>
39 #include "nss_db/nss_db.h"
40 #include <libc-diag.h>
41
42 /* Get libc version number. */
43 #include "../version.h"
44
45 /* The hashing function we use. */
46 #include "../intl/hash-string.h"
47
48 /* SELinux support. */
49 #ifdef HAVE_SELINUX
50 # include <selinux/label.h>
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. */
61 struct 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;
74 static size_t ndatabases;
75 static size_t nhashentries_total;
76 static size_t valstrlen;
77 static void *valstrtree;
78 static char *valstrtab;
79 static size_t extrastrlen;
80
81 /* Database entry. */
82 struct dbentry
83 {
84 stridx_t validx;
85 uint32_t hashval;
86 char str[0];
87 };
88
89 /* Stored string entry. */
90 struct 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. */
99 static bool any_dbentry;
100
101 /* If non-zero convert key to lower case. */
102 static int to_lowercase;
103
104 /* If non-zero print content of input file, one entry per line. */
105 static int do_undo;
106
107 /* If non-zero do not print informational messages. */
108 static int be_quiet;
109
110 /* Name of output file. */
111 static const char *output_name;
112
113 /* Name and version of program. */
114 static void print_version (FILE *stream, struct argp_state *state);
115 void (*argp_program_version_hook) (FILE *, struct argp_state *) = print_version;
116
117 /* Definitions of arguments for argp functions. */
118 static 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. */
132 static const char doc[] = N_("Create simple database from textual input.");
133
134 /* Strings for arguments in help texts. */
135 static const char args_doc[] = N_("\
136 INPUT-FILE OUTPUT-FILE\n-o OUTPUT-FILE INPUT-FILE\n-u INPUT-FILE");
137
138 /* Prototype for option handler. */
139 static error_t parse_opt (int key, char *arg, struct argp_state *state);
140
141 /* Function to print some extra text in the help message. */
142 static char *more_help (int key, const char *text, void *input);
143
144 /* Data structure to communicate with argp functions. */
145 static 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. */
152 static struct db_option
153 {
154 char dbid;
155 struct db_option *next;
156 } *db_options;
157
158
159 /* Prototypes for local functions. */
160 static int process_input (FILE *input, const char *inname,
161 int to_lowercase, int be_quiet);
162 static int print_database (int fd);
163 static void compute_tables (void);
164 static int write_output (int fd);
165
166 /* SELinux support. */
167 #ifdef HAVE_SELINUX
168 /* Set the SELinux file creation context for the given file. */
169 static void set_file_creation_context (const char *outname, mode_t mode);
170 static 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
181 int
182 main (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. */
330 static error_t
331 parse_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
362 static char *
363 more_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 ("\
371 For 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. */
382 static void
383 print_version (FILE *stream, struct argp_state *state)
384 {
385 fprintf (stream, "makedb %s%s\n", PKGVERSION, VERSION);
386 fprintf (stream, gettext ("\
387 Copyright (C) %s Free Software Foundation, Inc.\n\
388 This is free software; see the source for copying conditions. There is NO\n\
389 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
390 "), "2023");
391 fprintf (stream, gettext ("Written by %s.\n"), "Ulrich Drepper");
392 }
393
394
395 static int
396 dbentry_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
408 static int
409 valstr_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
418 static int
419 process_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
577 static void
578 copy_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. */
591 static int
592 is_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
610 static size_t
611 next_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 static size_t max_chainlength;
623 static char *wp;
624 static size_t nhashentries;
625 static bool copy_string;
626
627 void add_key(const void *nodep, VISIT which, void *arg)
628 {
629 if (which != leaf && which != postorder)
630 return;
631
632 const struct database *db = (const struct database *) arg;
633 const struct dbentry *dbe = *(const struct dbentry **) nodep;
634
635 ptrdiff_t stridx;
636 if (copy_string)
637 {
638 stridx = wp - db->keystrtab;
639 wp = stpcpy (wp, dbe->str) + 1;
640 }
641 else
642 stridx = 0;
643
644 size_t hidx = dbe->hashval % nhashentries;
645 size_t hval2 = 1 + dbe->hashval % (nhashentries - 2);
646 size_t chainlength = 0;
647
648 while (db->hashtable[hidx] != ~((stridx_t) 0))
649 {
650 ++chainlength;
651 if ((hidx += hval2) >= nhashentries)
652 hidx -= nhashentries;
653 }
654
655 db->hashtable[hidx] = ((db->extra_string ? valstrlen : 0)
656 + dbe->validx);
657 db->keyidxtab[hidx] = stridx;
658
659 max_chainlength = MAX (max_chainlength, chainlength);
660 }
661
662 static void
663 compute_tables (void)
664 {
665 valstrtab = xmalloc (roundup (valstrlen + extrastrlen, sizeof (stridx_t)));
666 while ((valstrlen + extrastrlen) % sizeof (stridx_t) != 0)
667 valstrtab[valstrlen++] = '\0';
668 twalk (valstrtree, copy_valstr);
669
670 static struct database *db;
671 for (db = databases; db != NULL; db = db->next)
672 if (db->nentries != 0)
673 {
674 ++ndatabases;
675
676 /* We simply use an odd number large than twice the number of
677 elements to store in the hash table for the size. This gives
678 enough efficiency. */
679 #define TEST_RANGE 30
680 size_t nhashentries_min = next_prime (db->nentries < TEST_RANGE
681 ? db->nentries
682 : db->nentries * 2 - TEST_RANGE);
683 size_t nhashentries_max = MAX (nhashentries_min, db->nentries * 4);
684 size_t nhashentries_best = nhashentries_min;
685 size_t chainlength_best = db->nentries;
686
687 db->hashtable = xmalloc (2 * nhashentries_max * sizeof (stridx_t)
688 + db->keystrlen);
689 db->keyidxtab = db->hashtable + nhashentries_max;
690 db->keystrtab = (char *) (db->keyidxtab + nhashentries_max);
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_r (db->entries, add_key, db);
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_r (db->entries, add_key, db);
729
730 db->nhashentries = nhashentries_best;
731 nhashentries_total += nhashentries_best;
732 }
733 }
734
735
736 static int
737 write_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
817 static int
818 print_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 static void
860 set_file_creation_context (const char *outname, mode_t mode)
861 {
862 static int enabled;
863 static int enforcing;
864 struct selabel_handle *label_hnd = NULL;
865 char* ctx;
866
867 /* Check if SELinux is enabled, and remember. */
868 if (enabled == 0)
869 enabled = is_selinux_enabled () ? 1 : -1;
870 if (enabled < 0)
871 return;
872
873 /* Check if SELinux is enforcing, and remember. */
874 if (enforcing == 0)
875 enforcing = security_getenforce () ? 1 : -1;
876
877 /* Open the file contexts backend. */
878 label_hnd = selabel_open(SELABEL_CTX_FILE, NULL, 0);
879 if (!label_hnd)
880 {
881 error (enforcing > 0 ? EXIT_FAILURE : 0, 0,
882 gettext ("cannot initialize SELinux context"));
883 return;
884 }
885 /* Determine the context which the file should have. */
886 ctx = NULL;
887 if (selabel_lookup(label_hnd, &ctx, outname, S_IFREG | mode) == 0)
888 {
889 if (setfscreatecon (ctx) != 0)
890 error (enforcing > 0 ? EXIT_FAILURE : 0, 0,
891 gettext ("cannot set file creation context for `%s'"),
892 outname);
893
894 freecon (ctx);
895 }
896
897 /* Close the file contexts backend. */
898 selabel_close(label_hnd);
899 }
900
901 static void
902 reset_file_creation_context (void)
903 {
904 setfscreatecon (NULL);
905 }
906 #endif