1 /* Textual dumping of CTF data.
2 Copyright (C) 2019-2023 Free Software Foundation, Inc.
3
4 This file is part of libctf.
5
6 libctf is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 This program is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
14 See the GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; see the file COPYING. If not see
18 <http://www.gnu.org/licenses/>. */
19
20 #include <ctf-impl.h>
21 #include <string.h>
22
23 #define str_append(s, a) ctf_str_append_noerr (s, a)
24
25 /* One item to be dumped, in string form. */
26
27 typedef struct ctf_dump_item
28 {
29 ctf_list_t cdi_list;
30 char *cdi_item;
31 } ctf_dump_item_t;
32
33 /* Cross-call state for dumping. Basically just enough to track the section in
34 use and a list of return strings. */
35
36 struct ctf_dump_state
37 {
38 ctf_sect_names_t cds_sect;
39 ctf_dict_t *cds_fp;
40 ctf_dump_item_t *cds_current;
41 ctf_list_t cds_items;
42 };
43
44 /* Cross-call state for ctf_dump_member. */
45
46 typedef struct ctf_dump_membstate
47 {
48 char **cdm_str;
49 ctf_dict_t *cdm_fp;
50 const char *cdm_toplevel_indent;
51 } ctf_dump_membstate_t;
52
53 static int
54 ctf_dump_append (ctf_dump_state_t *state, char *str)
55 {
56 ctf_dump_item_t *cdi;
57
58 if ((cdi = malloc (sizeof (struct ctf_dump_item))) == NULL)
59 return (ctf_set_errno (state->cds_fp, ENOMEM));
60
61 cdi->cdi_item = str;
62 ctf_list_append (&state->cds_items, cdi);
63 return 0;
64 }
65
66 static void
67 ctf_dump_free (ctf_dump_state_t *state)
68 {
69 ctf_dump_item_t *cdi, *next_cdi;
70
71 if (state == NULL)
72 return;
73
74 for (cdi = ctf_list_next (&state->cds_items); cdi != NULL;
75 cdi = next_cdi)
76 {
77 free (cdi->cdi_item);
78 next_cdi = ctf_list_next (cdi);
79 free (cdi);
80 }
81 }
82
83 /* Return a dump for a single type, without member info: but do optionally show
84 the type's references. */
85
86 #define CTF_FT_REFS 0x2 /* Print referenced types. */
87 #define CTF_FT_BITFIELD 0x4 /* Print :BITS if a bitfield. */
88 #define CTF_FT_ID 0x8 /* Print "ID: " in front of type IDs. */
89
90 static char *
91 ctf_dump_format_type (ctf_dict_t *fp, ctf_id_t id, int flag)
92 {
93 ctf_id_t new_id;
94 char *str = NULL, *bit = NULL, *buf = NULL;
95
96 ctf_set_errno (fp, 0);
97 new_id = id;
98 do
99 {
100 ctf_encoding_t ep;
101 ctf_arinfo_t ar;
102 int kind, unsliced_kind;
103 ssize_t size, align;
104 const char *nonroot_leader = "";
105 const char *nonroot_trailer = "";
106 const char *idstr = "";
107
108 id = new_id;
109 if (flag == CTF_ADD_NONROOT)
110 {
111 nonroot_leader = "{";
112 nonroot_trailer = "}";
113 }
114
115 buf = ctf_type_aname (fp, id);
116 if (!buf)
117 {
118 if (id == 0 || ctf_errno (fp) == ECTF_NONREPRESENTABLE)
119 {
120 ctf_set_errno (fp, ECTF_NONREPRESENTABLE);
121 str = str_append (str, " (type not represented in CTF)");
122 return str;
123 }
124
125 goto err;
126 }
127
128 if (flag & CTF_FT_ID)
129 idstr = "ID ";
130 if (asprintf (&bit, "%s%s0x%lx: (kind %i) ", nonroot_leader, idstr,
131 id, ctf_type_kind (fp, id)) < 0)
132 goto oom;
133 str = str_append (str, bit);
134 free (bit);
135 bit = NULL;
136
137 if (buf[0] != '\0')
138 str = str_append (str, buf);
139
140 free (buf);
141 buf = NULL;
142
143 unsliced_kind = ctf_type_kind_unsliced (fp, id);
144 kind = ctf_type_kind (fp, id);
145
146 /* Report encodings of everything with an encoding other than enums:
147 base-type enums cannot have a nonzero cte_offset or cte_bits value.
148 (Slices of them can, but they are of kind CTF_K_SLICE.) */
149 if (unsliced_kind != CTF_K_ENUM && ctf_type_encoding (fp, id, &ep) == 0)
150 {
151 if ((ssize_t) ep.cte_bits != ctf_type_size (fp, id) * CHAR_BIT
152 && flag & CTF_FT_BITFIELD)
153 {
154 if (asprintf (&bit, ":%i", ep.cte_bits) < 0)
155 goto oom;
156 str = str_append (str, bit);
157 free (bit);
158 bit = NULL;
159 }
160
161 if ((ssize_t) ep.cte_bits != ctf_type_size (fp, id) * CHAR_BIT
162 || ep.cte_offset != 0)
163 {
164 const char *slice = "";
165
166 if (unsliced_kind == CTF_K_SLICE)
167 slice = "slice ";
168
169 if (asprintf (&bit, " [%s0x%x:0x%x]",
170 slice, ep.cte_offset, ep.cte_bits) < 0)
171 goto oom;
172 str = str_append (str, bit);
173 free (bit);
174 bit = NULL;
175 }
176
177 if (asprintf (&bit, " (format 0x%x)", ep.cte_format) < 0)
178 goto oom;
179 str = str_append (str, bit);
180 free (bit);
181 bit = NULL;
182 }
183
184 size = ctf_type_size (fp, id);
185 if (kind != CTF_K_FUNCTION && size >= 0)
186 {
187 if (asprintf (&bit, " (size 0x%lx)", (unsigned long int) size) < 0)
188 goto oom;
189
190 str = str_append (str, bit);
191 free (bit);
192 bit = NULL;
193 }
194
195 align = ctf_type_align (fp, id);
196 if (align >= 0)
197 {
198 if (asprintf (&bit, " (aligned at 0x%lx)",
199 (unsigned long int) align) < 0)
200 goto oom;
201
202 str = str_append (str, bit);
203 free (bit);
204 bit = NULL;
205 }
206
207 if (nonroot_trailer[0] != 0)
208 str = str_append (str, nonroot_trailer);
209
210 /* Just exit after one iteration if we are not showing the types this type
211 references. */
212 if (!(flag & CTF_FT_REFS))
213 return str;
214
215 /* Keep going as long as this type references another. We consider arrays
216 to "reference" their element type. */
217
218 if (kind == CTF_K_ARRAY)
219 {
220 if (ctf_array_info (fp, id, &ar) < 0)
221 goto err;
222 new_id = ar.ctr_contents;
223 }
224 else
225 new_id = ctf_type_reference (fp, id);
226 if (new_id != CTF_ERR)
227 str = str_append (str, " -> ");
228 }
229 while (new_id != CTF_ERR);
230
231 if (ctf_errno (fp) != ECTF_NOTREF)
232 {
233 free (str);
234 return NULL;
235 }
236
237 return str;
238
239 oom:
240 ctf_set_errno (fp, errno);
241 err:
242 ctf_err_warn (fp, 1, 0, _("cannot format name dumping type 0x%lx"), id);
243 free (buf);
244 free (str);
245 free (bit);
246 return NULL;
247 }
248
249 /* Dump one string field from the file header into the cds_items. */
250 static int
251 ctf_dump_header_strfield (ctf_dict_t *fp, ctf_dump_state_t *state,
252 const char *name, uint32_t value)
253 {
254 char *str;
255 if (value)
256 {
257 if (asprintf (&str, "%s: %s\n", name, ctf_strptr (fp, value)) < 0)
258 goto err;
259 ctf_dump_append (state, str);
260 }
261 return 0;
262
263 err:
264 return (ctf_set_errno (fp, errno));
265 }
266
267 /* Dump one section-offset field from the file header into the cds_items. */
268 static int
269 ctf_dump_header_sectfield (ctf_dict_t *fp, ctf_dump_state_t *state,
270 const char *sect, uint32_t off, uint32_t nextoff)
271 {
272 char *str;
273 if (nextoff - off)
274 {
275 if (asprintf (&str, "%s:\t0x%lx -- 0x%lx (0x%lx bytes)\n", sect,
276 (unsigned long) off, (unsigned long) (nextoff - 1),
277 (unsigned long) (nextoff - off)) < 0)
278 goto err;
279 ctf_dump_append (state, str);
280 }
281 return 0;
282
283 err:
284 return (ctf_set_errno (fp, errno));
285 }
286
287 /* Dump the file header into the cds_items. */
288 static int
289 ctf_dump_header (ctf_dict_t *fp, ctf_dump_state_t *state)
290 {
291 char *str;
292 char *flagstr = NULL;
293 const ctf_header_t *hp = fp->ctf_header;
294 const char *vertab[] =
295 {
296 NULL, "CTF_VERSION_1",
297 "CTF_VERSION_1_UPGRADED_3 (latest format, version 1 type "
298 "boundaries)",
299 "CTF_VERSION_2",
300 "CTF_VERSION_3", NULL
301 };
302 const char *verstr = NULL;
303
304 if (asprintf (&str, "Magic number: 0x%x\n", hp->cth_magic) < 0)
305 goto err;
306 ctf_dump_append (state, str);
307
308 if (hp->cth_version <= CTF_VERSION)
309 verstr = vertab[hp->cth_version];
310
311 if (verstr == NULL)
312 verstr = "(not a valid version)";
313
314 if (asprintf (&str, "Version: %i (%s)\n", hp->cth_version,
315 verstr) < 0)
316 goto err;
317 ctf_dump_append (state, str);
318
319 /* Everything else is only printed if present. */
320
321 /* The flags are unusual in that they represent the ctf_dict_t *in memory*:
322 flags representing compression, etc, are turned off as the file is
323 decompressed. So we store a copy of the flags before they are changed, for
324 the dumper. */
325
326 if (fp->ctf_openflags > 0)
327 {
328 if (asprintf (&flagstr, "%s%s%s%s%s%s%s",
329 fp->ctf_openflags & CTF_F_COMPRESS
330 ? "CTF_F_COMPRESS": "",
331 (fp->ctf_openflags & CTF_F_COMPRESS)
332 && (fp->ctf_openflags & ~CTF_F_COMPRESS)
333 ? ", " : "",
334 fp->ctf_openflags & CTF_F_NEWFUNCINFO
335 ? "CTF_F_NEWFUNCINFO" : "",
336 (fp->ctf_openflags & (CTF_F_COMPRESS | CTF_F_NEWFUNCINFO))
337 && (fp->ctf_openflags & ~(CTF_F_COMPRESS | CTF_F_NEWFUNCINFO))
338 ? ", " : "",
339 fp->ctf_openflags & CTF_F_IDXSORTED
340 ? "CTF_F_IDXSORTED" : "",
341 fp->ctf_openflags & (CTF_F_COMPRESS | CTF_F_NEWFUNCINFO
342 | CTF_F_IDXSORTED)
343 && (fp->ctf_openflags & ~(CTF_F_COMPRESS | CTF_F_NEWFUNCINFO
344 | CTF_F_IDXSORTED))
345 ? ", " : "",
346 fp->ctf_openflags & CTF_F_DYNSTR
347 ? "CTF_F_DYNSTR" : "") < 0)
348 goto err;
349
350 if (asprintf (&str, "Flags: 0x%x (%s)", fp->ctf_openflags, flagstr) < 0)
351 goto err;
352 ctf_dump_append (state, str);
353 }
354
355 if (ctf_dump_header_strfield (fp, state, "Parent label",
356 hp->cth_parlabel) < 0)
357 goto err;
358
359 if (ctf_dump_header_strfield (fp, state, "Parent name", hp->cth_parname) < 0)
360 goto err;
361
362 if (ctf_dump_header_strfield (fp, state, "Compilation unit name",
363 hp->cth_cuname) < 0)
364 goto err;
365
366 if (ctf_dump_header_sectfield (fp, state, "Label section", hp->cth_lbloff,
367 hp->cth_objtoff) < 0)
368 goto err;
369
370 if (ctf_dump_header_sectfield (fp, state, "Data object section",
371 hp->cth_objtoff, hp->cth_funcoff) < 0)
372 goto err;
373
374 if (ctf_dump_header_sectfield (fp, state, "Function info section",
375 hp->cth_funcoff, hp->cth_objtidxoff) < 0)
376 goto err;
377
378 if (ctf_dump_header_sectfield (fp, state, "Object index section",
379 hp->cth_objtidxoff, hp->cth_funcidxoff) < 0)
380 goto err;
381
382 if (ctf_dump_header_sectfield (fp, state, "Function index section",
383 hp->cth_funcidxoff, hp->cth_varoff) < 0)
384 goto err;
385
386 if (ctf_dump_header_sectfield (fp, state, "Variable section",
387 hp->cth_varoff, hp->cth_typeoff) < 0)
388 goto err;
389
390 if (ctf_dump_header_sectfield (fp, state, "Type section",
391 hp->cth_typeoff, hp->cth_stroff) < 0)
392 goto err;
393
394 if (ctf_dump_header_sectfield (fp, state, "String section", hp->cth_stroff,
395 hp->cth_stroff + hp->cth_strlen + 1) < 0)
396 goto err;
397
398 return 0;
399 err:
400 free (flagstr);
401 return (ctf_set_errno (fp, errno));
402 }
403
404 /* Dump a single label into the cds_items. */
405
406 static int
407 ctf_dump_label (const char *name, const ctf_lblinfo_t *info,
408 void *arg)
409 {
410 char *str;
411 char *typestr;
412 ctf_dump_state_t *state = arg;
413
414 if (asprintf (&str, "%s -> ", name) < 0)
415 return (ctf_set_errno (state->cds_fp, errno));
416
417 if ((typestr = ctf_dump_format_type (state->cds_fp, info->ctb_type,
418 CTF_ADD_ROOT | CTF_FT_REFS)) == NULL)
419 {
420 free (str);
421 return 0; /* Swallow the error. */
422 }
423
424 str = str_append (str, typestr);
425 free (typestr);
426
427 ctf_dump_append (state, str);
428 return 0;
429 }
430
431 /* Dump all the object or function entries into the cds_items. */
432
433 static int
434 ctf_dump_objts (ctf_dict_t *fp, ctf_dump_state_t *state, int functions)
435 {
436 const char *name;
437 ctf_id_t id;
438 ctf_next_t *i = NULL;
439 char *str = NULL;
440
441 if ((functions && fp->ctf_funcidx_names)
442 || (!functions && fp->ctf_objtidx_names))
443 str = str_append (str, _("Section is indexed.\n"));
444 else if (fp->ctf_symtab.cts_data == NULL)
445 str = str_append (str, _("No symbol table.\n"));
446
447 while ((id = ctf_symbol_next (fp, &i, &name, functions)) != CTF_ERR)
448 {
449 char *typestr = NULL;
450
451 /* Emit the name, if we know it. No trailing space: ctf_dump_format_type
452 has a leading one. */
453 if (name)
454 {
455 if (asprintf (&str, "%s -> ", name) < 0)
456 goto oom;
457 }
458 else
459 str = xstrdup ("");
460
461 if ((typestr = ctf_dump_format_type (state->cds_fp, id,
462 CTF_ADD_ROOT | CTF_FT_REFS)) == NULL)
463 {
464 ctf_dump_append (state, str);
465 continue; /* Swallow the error. */
466 }
467
468 str = str_append (str, typestr);
469 free (typestr);
470 ctf_dump_append (state, str);
471 continue;
472
473 oom:
474 ctf_set_errno (fp, ENOMEM);
475 ctf_next_destroy (i);
476 return -1;
477 }
478 return 0;
479 }
480
481 /* Dump a single variable into the cds_items. */
482 static int
483 ctf_dump_var (const char *name, ctf_id_t type, void *arg)
484 {
485 char *str;
486 char *typestr;
487 ctf_dump_state_t *state = arg;
488
489 if (asprintf (&str, "%s -> ", name) < 0)
490 return (ctf_set_errno (state->cds_fp, errno));
491
492 if ((typestr = ctf_dump_format_type (state->cds_fp, type,
493 CTF_ADD_ROOT | CTF_FT_REFS)) == NULL)
494 {
495 free (str);
496 return 0; /* Swallow the error. */
497 }
498
499 str = str_append (str, typestr);
500 free (typestr);
501
502 ctf_dump_append (state, str);
503 return 0;
504 }
505
506 /* Dump a single struct/union member into the string in the membstate. */
507 static int
508 ctf_dump_member (const char *name, ctf_id_t id, unsigned long offset,
509 int depth, void *arg)
510 {
511 ctf_dump_membstate_t *state = arg;
512 char *typestr = NULL;
513 char *bit = NULL;
514
515 /* The struct/union itself has already been printed. */
516 if (depth == 0)
517 return 0;
518
519 if (asprintf (&bit, "%s%*s", state->cdm_toplevel_indent, (depth-1)*4, "") < 0)
520 goto oom;
521 *state->cdm_str = str_append (*state->cdm_str, bit);
522 free (bit);
523
524 if ((typestr = ctf_dump_format_type (state->cdm_fp, id,
525 CTF_ADD_ROOT | CTF_FT_BITFIELD
526 | CTF_FT_ID)) == NULL)
527 return -1; /* errno is set for us. */
528
529 if (asprintf (&bit, "[0x%lx] %s: %s\n", offset, name, typestr) < 0)
530 goto oom;
531
532 *state->cdm_str = str_append (*state->cdm_str, bit);
533 free (typestr);
534 free (bit);
535 typestr = NULL;
536 bit = NULL;
537
538 return 0;
539
540 oom:
541 free (typestr);
542 free (bit);
543 return (ctf_set_errno (state->cdm_fp, errno));
544 }
545
546 /* Report the number of digits in the hexadecimal representation of a type
547 ID. */
548
549 static int
550 type_hex_digits (ctf_id_t id)
551 {
552 int i = 0;
553
554 if (id == 0)
555 return 1;
556
557 for (; id > 0; id >>= 4, i++);
558 return i;
559 }
560
561 /* Dump a single type into the cds_items. */
562 static int
563 ctf_dump_type (ctf_id_t id, int flag, void *arg)
564 {
565 char *str;
566 char *indent;
567 ctf_dump_state_t *state = arg;
568 ctf_dump_membstate_t membstate = { &str, state->cds_fp, NULL };
569
570 /* Indent neatly. */
571 if (asprintf (&indent, " %*s", type_hex_digits (id), "") < 0)
572 return (ctf_set_errno (state->cds_fp, ENOMEM));
573
574 /* Dump the type itself. */
575 if ((str = ctf_dump_format_type (state->cds_fp, id,
576 flag | CTF_FT_REFS)) == NULL)
577 goto err;
578 str = str_append (str, "\n");
579
580 membstate.cdm_toplevel_indent = indent;
581
582 /* Member dumping for structs, unions... */
583 if (ctf_type_kind (state->cds_fp, id) == CTF_K_STRUCT
584 || ctf_type_kind (state->cds_fp, id) == CTF_K_UNION)
585 {
586 if ((ctf_type_visit (state->cds_fp, id, ctf_dump_member, &membstate)) < 0)
587 {
588 if (id == 0 || ctf_errno (state->cds_fp) == ECTF_NONREPRESENTABLE)
589 {
590 ctf_dump_append (state, str);
591 return 0;
592 }
593 ctf_err_warn (state->cds_fp, 1, ctf_errno (state->cds_fp),
594 _("cannot visit members dumping type 0x%lx"), id);
595 goto err;
596 }
597 }
598
599 /* ... and enums, for which we dump the first and last few members and skip
600 the ones in the middle. */
601 if (ctf_type_kind (state->cds_fp, id) == CTF_K_ENUM)
602 {
603 int enum_count = ctf_member_count (state->cds_fp, id);
604 ctf_next_t *it = NULL;
605 int i = 0;
606 const char *enumerand;
607 char *bit;
608 int value;
609
610 while ((enumerand = ctf_enum_next (state->cds_fp, id,
611 &it, &value)) != NULL)
612 {
613 i++;
614 if ((i > 5) && (i < enum_count - 4))
615 continue;
616
617 str = str_append (str, indent);
618
619 if (asprintf (&bit, "%s: %i\n", enumerand, value) < 0)
620 {
621 ctf_next_destroy (it);
622 goto oom;
623 }
624 str = str_append (str, bit);
625 free (bit);
626
627 if ((i == 5) && (enum_count > 10))
628 {
629 str = str_append (str, indent);
630 str = str_append (str, "...\n");
631 }
632 }
633 if (ctf_errno (state->cds_fp) != ECTF_NEXT_END)
634 {
635 ctf_err_warn (state->cds_fp, 1, ctf_errno (state->cds_fp),
636 _("cannot visit enumerands dumping type 0x%lx"), id);
637 goto err;
638 }
639 }
640
641 ctf_dump_append (state, str);
642 free (indent);
643
644 return 0;
645
646 err:
647 free (indent);
648 free (str);
649
650 /* Swallow the error: don't cause an error in one type to abort all
651 type dumping. */
652 return 0;
653
654 oom:
655 free (indent);
656 free (str);
657 return ctf_set_errno (state->cds_fp, ENOMEM);
658 }
659
660 /* Dump the string table into the cds_items. */
661
662 static int
663 ctf_dump_str (ctf_dict_t *fp, ctf_dump_state_t *state)
664 {
665 const char *s = fp->ctf_str[CTF_STRTAB_0].cts_strs;
666
667 for (; s < fp->ctf_str[CTF_STRTAB_0].cts_strs +
668 fp->ctf_str[CTF_STRTAB_0].cts_len;)
669 {
670 char *str;
671 if (asprintf (&str, "0x%lx: %s",
672 (unsigned long) (s - fp->ctf_str[CTF_STRTAB_0].cts_strs),
673 s) < 0)
674 return (ctf_set_errno (fp, errno));
675 ctf_dump_append (state, str);
676 s += strlen (s) + 1;
677 }
678
679 return 0;
680 }
681
682 /* Dump a particular section of a CTF file, in textual form. Call with a
683 pointer to a NULL STATE: each call emits a dynamically allocated string
684 containing a description of one entity in the specified section, in order.
685 Only the first call (with a NULL state) may vary SECT. Once the CTF section
686 has been entirely dumped, the call returns NULL and frees and annuls the
687 STATE, ready for another section to be dumped. The returned textual content
688 may span multiple lines: between each call the FUNC is called with one
689 textual line at a time, and should return a suitably decorated line (it can
690 allocate a new one and return it if it likes). */
691
692 char *
693 ctf_dump (ctf_dict_t *fp, ctf_dump_state_t **statep, ctf_sect_names_t sect,
694 ctf_dump_decorate_f *func, void *arg)
695 {
696 char *str;
697 char *line;
698 ctf_dump_state_t *state = NULL;
699
700 if (*statep == NULL)
701 {
702 /* Data collection. Transforming a call-at-a-time iterator into a
703 return-at-a-time iterator in a language without call/cc is annoying. It
704 is easiest to simply collect everything at once and then return it bit
705 by bit. The first call will take (much) longer than otherwise, but the
706 amortized time needed is the same. */
707
708 if ((*statep = malloc (sizeof (struct ctf_dump_state))) == NULL)
709 {
710 ctf_set_errno (fp, ENOMEM);
711 goto end;
712 }
713 state = *statep;
714
715 memset (state, 0, sizeof (struct ctf_dump_state));
716 state->cds_fp = fp;
717 state->cds_sect = sect;
718
719 switch (sect)
720 {
721 case CTF_SECT_HEADER:
722 ctf_dump_header (fp, state);
723 break;
724 case CTF_SECT_LABEL:
725 if (ctf_label_iter (fp, ctf_dump_label, state) < 0)
726 {
727 if (ctf_errno (fp) != ECTF_NOLABELDATA)
728 goto end; /* errno is set for us. */
729 ctf_set_errno (fp, 0);
730 }
731 break;
732 case CTF_SECT_OBJT:
733 if (ctf_dump_objts (fp, state, 0) < 0)
734 goto end; /* errno is set for us. */
735 break;
736 case CTF_SECT_FUNC:
737 if (ctf_dump_objts (fp, state, 1) < 0)
738 goto end; /* errno is set for us. */
739 break;
740 case CTF_SECT_VAR:
741 if (ctf_variable_iter (fp, ctf_dump_var, state) < 0)
742 goto end; /* errno is set for us. */
743 break;
744 case CTF_SECT_TYPE:
745 if (ctf_type_iter_all (fp, ctf_dump_type, state) < 0)
746 goto end; /* errno is set for us. */
747 break;
748 case CTF_SECT_STR:
749 ctf_dump_str (fp, state);
750 break;
751 default:
752 ctf_set_errno (fp, ECTF_DUMPSECTUNKNOWN);
753 goto end;
754 }
755 }
756 else
757 {
758 state = *statep;
759
760 if (state->cds_sect != sect)
761 {
762 ctf_set_errno (fp, ECTF_DUMPSECTCHANGED);
763 goto end;
764 }
765 }
766
767 if (state->cds_current == NULL)
768 state->cds_current = ctf_list_next (&state->cds_items);
769 else
770 state->cds_current = ctf_list_next (state->cds_current);
771
772 if (state->cds_current == NULL)
773 goto end;
774
775 /* Hookery. There is some extra complexity to preserve linefeeds within each
776 item while removing linefeeds at the end. */
777 if (func)
778 {
779 size_t len;
780
781 str = NULL;
782 for (line = state->cds_current->cdi_item; line && *line; )
783 {
784 char *nline = line;
785 char *ret;
786
787 nline = strchr (line, '\n');
788 if (nline)
789 nline[0] = '\0';
790
791 ret = func (sect, line, arg);
792 str = str_append (str, ret);
793 str = str_append (str, "\n");
794 if (ret != line)
795 free (ret);
796
797 if (nline)
798 {
799 nline[0] = '\n';
800 nline++;
801 }
802
803 line = nline;
804 }
805
806 len = strlen (str);
807
808 if (str[len-1] == '\n')
809 str[len-1] = '\0';
810 }
811 else
812 {
813 str = strdup (state->cds_current->cdi_item);
814 if (!str)
815 {
816 ctf_set_errno (fp, ENOMEM);
817 return str;
818 }
819 }
820
821 ctf_set_errno (fp, 0);
822 return str;
823
824 end:
825 ctf_dump_free (state);
826 free (state);
827 ctf_set_errno (fp, 0);
828 *statep = NULL;
829 return NULL;
830 }