1 /* Copyright (c) 2020-2023 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published
6 by the Free Software Foundation; version 2 of the License, or
7 (at your option) any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, see <https://www.gnu.org/licenses/>. */
16
17 /* cachedumper - dump a human-readable representation of a cache file. */
18
19 #include <ctype.h>
20 #include <stdio.h>
21 #include <fcntl.h>
22 #include <unistd.h>
23 #include <libintl.h>
24 #include <sys/types.h>
25 #include <sys/stat.h>
26 #include <sys/mman.h>
27 #include <arpa/inet.h>
28 #include <getopt.h>
29 #include <sys/param.h>
30
31 #include "nscd.h"
32 #include "dbg_log.h"
33
34 static void *the_cache;
35
36 #define NO_REF ((ref_t) -1)
37
38 /* Given a chunk of raw data CP of length LEN, print it in a hopefully
39 user-readable format, including colorizing non-readable characters.
40 STR prefixes it, if non-NULL. If LEN is -1, CP is
41 NUL-terminated. */
42 unsigned char *
43 data_string (unsigned char *cp, const char *str, int len)
44 {
45 int oops = 0;
46 unsigned char *cpe = cp + len;
47 printf ("%s", str);
48 while (len == -1 || cp < cpe)
49 {
50 if (isgraph (*cp))
51 putchar (*cp);
52 else
53 printf ("\033[%dm<%02x>\033[0m", *cp % 6 + 31, *cp);
54 if (len == -1 && *cp == 0)
55 return cp + 1;
56
57 ++cp;
58 if (++oops > 1000)
59 break;
60 }
61 return cp;
62 }
63
64 void
65 nscd_print_cache (const char *name)
66 {
67 struct stat st;
68 int fd;
69 int i;
70
71 if (stat (name, &st) < 0)
72 {
73 perror (name);
74 exit (1);
75 }
76
77 fd = open (name, O_RDONLY);
78
79 the_cache = mmap (NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
80
81 struct database_pers_head *dps = (struct database_pers_head *) the_cache;
82
83 /* Shortcut for "print the cache offset (address) of X in the
84 cache". */
85 #define A(x) (int) ((char *) &(x) - (char *) the_cache)
86
87 /* Common code for "print field DPS->F, it's offset, and contents". */
88 #define DPS(f) printf("%08x: %24s : %10d %08x\n", A (dps->f), #f, (int) dps->f, (int) dps->f);
89
90 if (debug_level > 0)
91 {
92 DPS (version);
93 DPS (header_size);
94 DPS (gc_cycle);
95 DPS (nscd_certainly_running);
96 DPS (timestamp);
97 DPS (module);
98 DPS (data_size);
99 DPS (first_free);
100 DPS (nentries);
101 DPS (maxnentries);
102 DPS (maxnsearched);
103 DPS (poshit);
104 DPS (neghit);
105 DPS (posmiss);
106 DPS (negmiss);
107 DPS (rdlockdelayed);
108 DPS (wrlockdelayed);
109 DPS (addfailed);
110 printf ("\n");
111 }
112
113
114 char *data = (char *) &dps->array[roundup (dps->module,
115 ALIGN / sizeof (ref_t))];
116
117 /* Loop through each entry in the hash table, which is of size
118 dps->module. Raw data is stored after the hash table in the
119 cache file. */
120 for (i = 0; i < dps->module; i++)
121 {
122 ref_t r = dps->array[i];
123 if (r == NO_REF)
124 continue;
125
126 if (debug_level > 2)
127 printf ("hash[%4d] = 0x%x\n", i, r);
128
129 while (r != NO_REF)
130 {
131 struct hashentry *here = (struct hashentry *) (data + r);
132
133 unsigned char *key = (unsigned char *) data + here->key;
134
135 printf ("\n%08x: type %s key %p \"", A (*here),
136 serv2str[here->type], key);
137
138 data_string (key, "", here->len);
139
140 struct datahead *dh = (struct datahead *) (data + here->packet);
141 printf ("\" (len:%ld) Data %08lx\n", (long) here->len,
142 (long unsigned int) ((char *) dh - (char *) the_cache));
143
144 if (debug_level > 0)
145 {
146 /* Common code for printing fields in struct DATAHEAD DH. */
147 #define DH(f) printf ("%08x; %24s : %10d %08x\n", A (dh->f), #f, (int) dh->f, (int) dh->f);
148 DH (allocsize);
149 DH (recsize);
150 DH (timeout);
151 DH (notfound);
152 DH (nreloads);
153 DH (usable);
154 DH (unused);
155 DH (ttl);
156 }
157
158 unsigned char *cp = (unsigned char *) (&dh->data[0]);
159 unsigned char *cpe =
160 (unsigned char *) (&dh->data[0]) + dh->allocsize;
161
162
163 int i;
164 uint32_t *grplens;
165
166 if (debug_level > 1)
167 {
168 data_string (cp, _(" - all data: "), cpe - cp);
169 printf ("\n");
170 }
171
172 /* These two are common to all responses. */
173 printf ("V%d F%d",
174 dh->data[0].pwdata.version, dh->data[0].pwdata.found);
175
176 /* Shortcut for the common case where we iterate through
177 fixed-length strings stored in the data portion of the
178 cache. CP is updated to point to the next string. */
179 #define DSTR(str, l) cp = data_string (cp, str, l)
180
181 switch (here->type)
182 {
183 case GETPWBYNAME:
184 case GETPWBYUID:
185 {
186 pw_response_header *pw = &(dh->data[0].pwdata);
187 cp += sizeof (*pw);
188 DSTR (" name ", pw->pw_name_len);
189 DSTR (" passwd ", pw->pw_passwd_len);
190 printf (" uid %d gid %d", pw->pw_uid, pw->pw_gid);
191 DSTR (" gecos ", pw->pw_gecos_len);
192 DSTR (" dir ", pw->pw_dir_len);
193 DSTR (" shell ", pw->pw_shell_len);
194 DSTR (" byuid ", -1);
195 DSTR (" key ", -1);
196 printf ("\n");
197 }
198 break;
199
200 case GETGRBYNAME:
201 case GETGRBYGID:
202 {
203 gr_response_header *gr = &(dh->data[0].grdata);
204 cp += sizeof (*gr);
205 grplens = (uint32_t *) cp;
206 cp += gr->gr_mem_cnt * sizeof (uint32_t);
207 DSTR (" name ", gr->gr_name_len);
208 DSTR (" passwd ", gr->gr_passwd_len);
209 printf (" gid %d members %d [ ", (int) gr->gr_gid,
210 (int) gr->gr_mem_cnt);
211 for (i = 0; i < gr->gr_mem_cnt; i++)
212 DSTR (" ", grplens[i]);
213 DSTR (" ] bygid ", -1);
214 DSTR (" key ", -1);
215 printf ("\n");
216 }
217 break;
218
219 case GETHOSTBYADDR:
220 case GETHOSTBYADDRv6:
221 case GETHOSTBYNAME:
222 case GETHOSTBYNAMEv6:
223 {
224 hst_response_header *hst = &(dh->data[0].hstdata);
225 printf (" addrtype %d error %d", hst->h_addrtype, hst->error);
226 cp += sizeof (*hst);
227 DSTR (" name ", hst->h_name_len);
228 uint32_t *aliases_len = (uint32_t *) cp;
229 cp += hst->h_aliases_cnt * sizeof (uint32_t);
230 uint32_t *addrs = (uint32_t *) cp;
231 cp += hst->h_length * hst->h_addr_list_cnt;
232
233 if (hst->h_aliases_cnt)
234 {
235 printf (" aliases [");
236 for (i = 0; i < hst->h_aliases_cnt; i++)
237 DSTR (" ", aliases_len[i]);
238 printf (" ]");
239 }
240 if (hst->h_addr_list_cnt)
241 {
242 char buf[INET6_ADDRSTRLEN];
243 printf (" addresses [");
244 for (i = 0; i < hst->h_addr_list_cnt; i++)
245 {
246 inet_ntop (hst->h_addrtype, addrs, buf, sizeof (buf));
247 printf (" %s", buf);
248 addrs += hst->h_length;
249 }
250 printf (" ]");
251 }
252
253 printf ("\n");
254 }
255 break;
256
257 case GETAI:
258 {
259 ai_response_header *ai = &(dh->data[0].aidata);
260 printf (" naddrs %ld addrslen %ld canonlen %ld error %d [",
261 (long) ai->naddrs, (long) ai->addrslen,
262 (long) ai->canonlen, ai->error);
263 cp += sizeof (*ai);
264 unsigned char *addrs = cp;
265 unsigned char *families = cp + ai->addrslen;
266 cp = families + ai->naddrs;
267 char buf[INET6_ADDRSTRLEN];
268
269 for (i = 0; i < ai->naddrs; i++)
270 {
271 switch (*families)
272 {
273 case AF_INET:
274 inet_ntop (*families, addrs, buf, sizeof (buf));
275 printf (" %s", buf);
276 addrs += 4;
277 break;
278 case AF_INET6:
279 inet_ntop (*families, addrs, buf, sizeof (buf));
280 printf (" %s", buf);
281 addrs += 16;
282 break;
283 }
284 families++;
285 }
286 DSTR (" ] canon ", ai->canonlen);
287 DSTR (" key ", -1);
288 printf ("\n");
289 }
290 break;
291
292 case INITGROUPS:
293 {
294 initgr_response_header *ig = &(dh->data[0].initgrdata);
295 printf (" nresults %d groups [", (int) ig->ngrps);
296 cp += sizeof (*ig);
297 grplens = (uint32_t *) cp;
298 cp += ig->ngrps * sizeof (uint32_t);
299 for (i = 0; i < ig->ngrps; i++)
300 printf (" %d", grplens[i]);
301 DSTR (" ] key ", -1);
302 printf ("\n");
303 }
304 break;
305
306 case GETSERVBYNAME:
307 case GETSERVBYPORT:
308 {
309 serv_response_header *serv = &(dh->data[0].servdata);
310 printf (" alias_cnt %ld port %d (stored as %d)",
311 (long) serv->s_aliases_cnt,
312 ((serv->s_port & 0xff00) >> 8) | ((serv->
313 s_port & 0xff) <<
314 8), serv->s_port);
315 cp += sizeof (*serv);
316 DSTR (" name ", serv->s_name_len);
317 DSTR (" proto ", serv->s_proto_len);
318 if (serv->s_aliases_cnt)
319 {
320 uint32_t *alias_len = (uint32_t *) cp;
321 printf (" aliases [");
322 cp += sizeof (uint32_t) * serv->s_aliases_cnt;
323 for (i = 0; i < serv->s_aliases_cnt; i++)
324 DSTR (" ", alias_len[i]);
325 printf (" ]");
326 }
327 printf ("\n");
328 }
329 break;
330
331 case GETNETGRENT:
332 {
333 netgroup_response_header *ng = &(dh->data[0].netgroupdata);
334 printf (" nresults %d len %d\n",
335 (int) ng->nresults, (int) ng->result_len);
336 cp += sizeof (*ng);
337 for (i = 0; i < ng->nresults; i++)
338 {
339 DSTR (" (", -1);
340 DSTR (",", -1);
341 DSTR (",", -1);
342 printf (")");
343 }
344 printf ("\n");
345 }
346 break;
347
348 case INNETGR:
349 {
350 innetgroup_response_header *ing =
351 &(dh->data[0].innetgroupdata);
352 printf (" result %d\n", ing->result);
353 }
354 break;
355
356 default:
357 break;
358 }
359
360 if (debug_level > 2 && cp && cp < cpe)
361 {
362 printf (_(" - remaining data %p: "), cp);
363 data_string (cp, "", cpe - cp);
364 printf ("\n");
365 }
366
367
368 r = here->next;
369 }
370 }
371
372 munmap (the_cache, st.st_size);
373
374 exit (0);
375 }