diff --git a/pakfire/pakfire.nm b/pakfire/pakfire.nm index ffd9cbc23..b16f07918 100644 --- a/pakfire/pakfire.nm +++ b/pakfire/pakfire.nm @@ -5,7 +5,7 @@ name = pakfire version = 0.9.27 -release = 1 +release = 2 maintainer = Michael Tremer groups = System/Packaging @@ -24,23 +24,16 @@ build requires autoconf automake - beecrypt-devel - elfutils-devel gettext-devel intltool libcap-devel libsolv-devel >= 0.0.0-4 - popt-devel python-devel systemd-devel systemd-units xz-devel end - # libgomp was broken in earlier releases. - requires += gcc >= 4.6.2-4 - requires += beecrypt >= 4.2.1-2 - prepare_cmds # Generate the build system, if this was not a release # tarball. @@ -95,6 +88,7 @@ packages requires # For --rpm-requires. bash >= 4.2-7 + debugedit %{name} = %{thisver} quality-agent = %{thisver} diff --git a/pakfire/patches/0001-Remove-shipped-version-of-debugedit.patch b/pakfire/patches/0001-Remove-shipped-version-of-debugedit.patch new file mode 100644 index 000000000..676f2109a --- /dev/null +++ b/pakfire/patches/0001-Remove-shipped-version-of-debugedit.patch @@ -0,0 +1,4576 @@ +From 559d80aa112c785fd2068ca09c5516d47ceabfe1 Mon Sep 17 00:00:00 2001 +From: Michael Tremer +Date: Wed, 26 Oct 2016 23:42:57 +0100 +Subject: [PATCH] Remove shipped version of debugedit + +We are now shipping this as a seperate package so that +we can update it easier. + +Signed-off-by: Michael Tremer +--- + .gitignore | 2 - + Makefile.am | 19 - + configure.ac | 22 - + src/debugedit/debugedit.c | 1688 -------------------------------------- + src/debugedit/hashtab.c | 523 ------------ + src/debugedit/hashtab.h | 143 ---- + src/debugedit/rpmiotypes.h | 653 --------------- + src/debugedit/rpmsw.h | 157 ---- + src/debugedit/rpmtag.h | 1243 ---------------------------- + src/scripts/extract-debuginfo.in | 2 +- + 10 files changed, 1 insertion(+), 4451 deletions(-) + delete mode 100644 src/debugedit/debugedit.c + delete mode 100644 src/debugedit/hashtab.c + delete mode 100644 src/debugedit/hashtab.h + delete mode 100644 src/debugedit/rpmiotypes.h + delete mode 100644 src/debugedit/rpmsw.h + delete mode 100644 src/debugedit/rpmtag.h + +diff --git a/.gitignore b/.gitignore +index 8fce8f6..293e999 100644 +--- a/.gitignore ++++ b/.gitignore +@@ -1,6 +1,5 @@ + /Makefile + /build-aux +-/debugedit + /libtool + /missing + /contrib/pakfire.nm +@@ -9,7 +8,6 @@ + /src/scripts/extract-debuginfo + /src/systemd/*.service + /tmp +-/tools/debugedit + *.py[co] + /*.tar.bz2 + /*.tar.gz +diff --git a/Makefile.am b/Makefile.am +index 28dd954..bf7e42f 100644 +--- a/Makefile.am ++++ b/Makefile.am +@@ -244,25 +244,6 @@ libpakfire_preload_la_LIBADD = \ + + # ------------------------------------------------------------------------------ + +-libexec_PROGRAMS += \ +- debugedit +- +-debugedit_SOURCES = \ +- src/debugedit/debugedit.c \ +- src/debugedit/hashtab.c \ +- src/debugedit/hashtab.h \ +- src/debugedit/rpmiotypes.h \ +- src/debugedit/rpmsw.h \ +- src/debugedit/rpmtag.h +- +-debugedit_LDADD = \ +- $(AM_CFLAGS) \ +- $(BEECRYPT_LIBS) \ +- $(ELF_LIBS) \ +- $(POPT_LIBS) +- +-# ------------------------------------------------------------------------------ +- + scripts_SCRIPTS = \ + src/scripts/extract-debuginfo \ + src/scripts/quality-agent +diff --git a/configure.ac b/configure.ac +index 4030541..1e188e7 100644 +--- a/configure.ac ++++ b/configure.ac +@@ -103,12 +103,6 @@ AM_PATH_PYTHON([2.7]) + + save_LIBS="$LIBS" + +-# beecrypt +-LIBS= +-AC_SEARCH_LIBS([hashFunctionContextInit], [beecrypt], [], [AC_MSG_ERROR([*** beecrypt library not found])]) +-BEECRYPT_LIBS="$LIBS" +-AC_SUBST(BEECRYPT_LIBS) +- + # libdl + LIBS= + AC_SEARCH_LIBS([dlsym], [dl], [], [AC_MSG_ERROR([*** Dynamic linking loader library not found])]) +@@ -123,22 +117,6 @@ AC_SEARCH_LIBS([cap_init], [cap], [], [AC_MSG_ERROR([*** POSIX caps library not + CAP_LIBS="$LIBS" + AC_SUBST(CAP_LIBS) + +-# libelf +-AC_CHECK_HEADERS([libelf.h gelf.h], [], [AC_MSG_ERROR([*** libelf headers not found])]) +- +-LIBS= +-AC_SEARCH_LIBS([gelf_getvernaux], [elf], [], [AC_MSG_ERROR([*** libelf library not found])]) +-ELF_LIBS="$LIBS" +-AC_SUBST(ELF_LIBS) +- +-# libpopt +-AC_CHECK_HEADERS([popt.h], [], [AC_MSG_ERROR([*** libpopt headers not found])]) +- +-LIBS= +-AC_SEARCH_LIBS([poptGetContext], [popt], [], [AC_MSG_ERROR([*** libpopt library not found])]) +-POPT_LIBS="$LIBS" +-AC_SUBST(POPT_LIBS) +- + # libsolv + AC_CHECK_HEADERS([solv/solvversion.h], [], [AC_MSG_ERROR([*** libsolv headers not found])]) + +diff --git a/src/debugedit/debugedit.c b/src/debugedit/debugedit.c +deleted file mode 100644 +index 75b48f0..0000000 +--- a/src/debugedit/debugedit.c ++++ /dev/null +@@ -1,1688 +0,0 @@ +-/* Copyright (C) 2001, 2002, 2003, 2005, 2007, 2009 Red Hat, Inc. +- Written by Alexander Larsson , 2002 +- Based on code by Jakub Jelinek , 2001. +- +- This program is free software; you can redistribute it and/or modify +- it under the terms of the GNU General Public License as published by +- the Free Software Foundation; either version 2, or (at your option) +- any later version. +- +- This program is distributed in the hope that it will be useful, +- but WITHOUT ANY WARRANTY; without even the implied warranty of +- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +- GNU General Public License for more details. +- +- You should have received a copy of the GNU General Public License +- along with this program; if not, write to the Free Software Foundation, +- Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +- +-/* Needed for libelf */ +-#define _FILE_OFFSET_BITS 64 +- +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +-#include +- +-#include +- +-/* some defines taken from the dwarf standard */ +- +-#define DW_TAG_compile_unit 0x11 +- +-#define DW_AT_name 0x03 +-#define DW_AT_stmt_list 0x10 +-#define DW_AT_comp_dir 0x1b +- +-#define DW_FORM_addr 0x01 +-#define DW_FORM_block2 0x03 +-#define DW_FORM_block4 0x04 +-#define DW_FORM_data2 0x05 +-#define DW_FORM_data4 0x06 +-#define DW_FORM_data8 0x07 +-#define DW_FORM_string 0x08 +-#define DW_FORM_block 0x09 +-#define DW_FORM_block1 0x0a +-#define DW_FORM_data1 0x0b +-#define DW_FORM_flag 0x0c +-#define DW_FORM_sdata 0x0d +-#define DW_FORM_strp 0x0e +-#define DW_FORM_udata 0x0f +-#define DW_FORM_ref_addr 0x10 +-#define DW_FORM_ref1 0x11 +-#define DW_FORM_ref2 0x12 +-#define DW_FORM_ref4 0x13 +-#define DW_FORM_ref8 0x14 +-#define DW_FORM_ref_udata 0x15 +-#define DW_FORM_indirect 0x16 +- +-#include +-#include "hashtab.h" +-#include "rpmtag.h" +- +-#define DW_TAG_partial_unit 0x3c +-#define DW_FORM_sec_offset 0x17 +-#define DW_FORM_exprloc 0x18 +-#define DW_FORM_flag_present 0x19 +-#define DW_FORM_ref_sig8 0x20 +- +-char *base_dir = NULL; +-char *dest_dir = NULL; +-char *list_file = NULL; +-int list_file_fd = -1; +-int do_build_id = 0; +- +-typedef struct +-{ +- Elf *elf; +- GElf_Ehdr ehdr; +- Elf_Scn **scn; +- const char *filename; +- int lastscn; +- GElf_Shdr shdr[0]; +-} DSO; +- +-typedef struct +-{ +- unsigned char *ptr; +- rpmuint32_t addend; +-} REL; +- +-#define read_uleb128(ptr) ({ \ +- unsigned int ret = 0; \ +- unsigned int c; \ +- int shift = 0; \ +- do \ +- { \ +- c = *ptr++; \ +- ret |= (c & 0x7f) << shift; \ +- shift += 7; \ +- } while (c & 0x80); \ +- \ +- if (shift >= 35) \ +- ret = UINT_MAX; \ +- ret; \ +-}) +- +-static rpmuint16_t (*do_read_16) (unsigned char *ptr); +-static rpmuint32_t (*do_read_32) (unsigned char *ptr); +-static void (*write_32) (unsigned char *ptr, GElf_Addr val); +- +-static int ptr_size; +-static int cu_version; +- +-static inline rpmuint16_t +-buf_read_ule16 (unsigned char *data) +-{ +- return data[0] | (data[1] << 8); +-} +- +-static inline rpmuint16_t +-buf_read_ube16 (unsigned char *data) +-{ +- return data[1] | (data[0] << 8); +-} +- +-static inline rpmuint32_t +-buf_read_ule32 (unsigned char *data) +-{ +- return data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24); +-} +- +-static inline rpmuint32_t +-buf_read_ube32 (unsigned char *data) +-{ +- return data[3] | (data[2] << 8) | (data[1] << 16) | (data[0] << 24); +-} +- +-static const char * +-strptr (DSO *dso, int sec, off_t offset) +-{ +- Elf_Scn *scn; +- Elf_Data *data; +- +- scn = dso->scn[sec]; +- if (offset >= 0 && (GElf_Addr) offset < dso->shdr[sec].sh_size) +- { +- data = NULL; +- while ((data = elf_rawdata (scn, data)) != NULL) +- { +- if (data->d_buf +- && offset >= data->d_off +- && offset < data->d_off + (off_t)data->d_size) +- return (const char *) data->d_buf + (offset - data->d_off); +- } +- } +- +- return NULL; +-} +- +- +-#define read_1(ptr) *ptr++ +- +-#define read_16(ptr) ({ \ +- rpmuint16_t ret = do_read_16 (ptr); \ +- ptr += 2; \ +- ret; \ +-}) +- +-#define read_32(ptr) ({ \ +- rpmuint32_t ret = do_read_32 (ptr); \ +- ptr += 4; \ +- ret; \ +-}) +- +-REL *relptr, *relend; +-int reltype; +- +-#define do_read_32_relocated(ptr) ({ \ +- rpmuint32_t dret = do_read_32 (ptr); \ +- if (relptr) \ +- { \ +- while (relptr < relend && relptr->ptr < ptr) \ +- ++relptr; \ +- if (relptr < relend && relptr->ptr == ptr) \ +- { \ +- if (reltype == SHT_REL) \ +- dret += relptr->addend; \ +- else \ +- dret = relptr->addend; \ +- } \ +- } \ +- dret; \ +-}) +- +-#define read_32_relocated(ptr) ({ \ +- rpmuint32_t ret = do_read_32_relocated (ptr); \ +- ptr += 4; \ +- ret; \ +-}) +- +-static void +-dwarf2_write_le32 (unsigned char *p, GElf_Addr val) +-{ +- rpmuint32_t v = (rpmuint32_t) val; +- +- p[0] = v; +- p[1] = v >> 8; +- p[2] = v >> 16; +- p[3] = v >> 24; +-} +- +- +-static void +-dwarf2_write_be32 (unsigned char *p, GElf_Addr val) +-{ +- rpmuint32_t v = (rpmuint32_t) val; +- +- p[3] = v; +- p[2] = v >> 8; +- p[1] = v >> 16; +- p[0] = v >> 24; +-} +- +-static struct +- { +- const char *name; +- unsigned char *data; +- Elf_Data *elf_data; +- size_t size; +- int sec, relsec; +- } debug_sections[] = +- { +-#define DEBUG_INFO 0 +-#define DEBUG_ABBREV 1 +-#define DEBUG_LINE 2 +-#define DEBUG_ARANGES 3 +-#define DEBUG_PUBNAMES 4 +-#define DEBUG_PUBTYPES 5 +-#define DEBUG_MACINFO 6 +-#define DEBUG_LOC 7 +-#define DEBUG_STR 8 +-#define DEBUG_FRAME 9 +-#define DEBUG_RANGES 10 +-#define DEBUG_TYPES 11 +-#define DEBUG_MACRO 12 +- { ".debug_info", NULL, NULL, 0, 0, 0 }, +- { ".debug_abbrev", NULL, NULL, 0, 0, 0 }, +- { ".debug_line", NULL, NULL, 0, 0, 0 }, +- { ".debug_aranges", NULL, NULL, 0, 0, 0 }, +- { ".debug_pubnames", NULL, NULL, 0, 0, 0 }, +- { ".debug_pubtypes", NULL, NULL, 0, 0, 0 }, +- { ".debug_macinfo", NULL, NULL, 0, 0, 0 }, +- { ".debug_loc", NULL, NULL, 0, 0, 0 }, +- { ".debug_str", NULL, NULL, 0, 0, 0 }, +- { ".debug_frame", NULL, NULL, 0, 0, 0 }, +- { ".debug_ranges", NULL, NULL, 0, 0, 0 }, +- { ".debug_types", NULL, NULL, 0, 0, 0 }, +- { ".debug_macro", NULL, NULL, 0, 0, 0 }, +- { NULL, NULL, NULL, 0, 0, 0 } +- }; +- +-struct abbrev_attr +- { +- unsigned int attr; +- unsigned int form; +- }; +- +-struct abbrev_tag +- { +- unsigned int entry; +- unsigned int tag; +- int nattr; +- struct abbrev_attr attr[0]; +- }; +- +-static hashval_t +-abbrev_hash (const void *p) +-{ +- struct abbrev_tag *t = (struct abbrev_tag *)p; +- +- return t->entry; +-} +- +-static int +-abbrev_eq (const void *p, const void *q) +-{ +- struct abbrev_tag *t1 = (struct abbrev_tag *)p; +- struct abbrev_tag *t2 = (struct abbrev_tag *)q; +- +- return t1->entry == t2->entry; +-} +- +-static void +-abbrev_del (void *p) +-{ +- free (p); +-} +- +-static htab_t +-read_abbrev (DSO *dso, unsigned char *ptr) +-{ +- htab_t h = htab_try_create (50, abbrev_hash, abbrev_eq, abbrev_del); +- unsigned int attr, form; +- struct abbrev_tag *t; +- int size; +- void **slot; +- +- if (h == NULL) +- { +-no_memory: +- error (0, ENOMEM, "%s: Could not read .debug_abbrev", dso->filename); +- if (h) +- htab_delete (h); +- return NULL; +- } +- +- while ((attr = read_uleb128 (ptr)) != 0) +- { +- size = 10; +- t = malloc (sizeof (*t) + size * sizeof (struct abbrev_attr)); +- if (t == NULL) +- goto no_memory; +- t->entry = attr; +- t->nattr = 0; +- slot = htab_find_slot (h, t, INSERT); +- if (slot == NULL) +- { +- free (t); +- goto no_memory; +- } +- if (*slot != NULL) +- { +- error (0, 0, "%s: Duplicate DWARF abbreviation %d", dso->filename, +- t->entry); +- free (t); +- htab_delete (h); +- return NULL; +- } +- t->tag = read_uleb128 (ptr); +- ++ptr; /* skip children flag. */ +- while ((attr = read_uleb128 (ptr)) != 0) +- { +- if (t->nattr == size) +- { +- size += 10; +- t = realloc (t, sizeof (*t) + size * sizeof (struct abbrev_attr)); +- if (t == NULL) +- goto no_memory; +- } +- form = read_uleb128 (ptr); +- if (form == 2 +- || (form > DW_FORM_flag_present && form != DW_FORM_ref_sig8)) +- { +- error (0, 0, "%s: Unknown DWARF DW_FORM_%d", dso->filename, form); +- htab_delete (h); +- return NULL; +- } +- +- t->attr[t->nattr].attr = attr; +- t->attr[t->nattr++].form = form; +- } +- if (read_uleb128 (ptr) != 0) +- { +- error (0, 0, "%s: DWARF abbreviation does not end with 2 zeros", +- dso->filename); +- htab_delete (h); +- return NULL; +- } +- *slot = t; +- } +- +- return h; +-} +- +-#define IS_DIR_SEPARATOR(c) ((c)=='/') +- +-static char * +-canonicalize_path (const char *s, char *d) +-{ +- char *rv = d; +- const char *sroot; +- char *droot; +- +- if (IS_DIR_SEPARATOR (*s)) +- { +- *d++ = *s++; +- if (IS_DIR_SEPARATOR (*s) && !IS_DIR_SEPARATOR (s[1])) +- { +- /* Special case for "//foo" meaning a Posix namespace +- escape. */ +- *d++ = *s++; +- } +- while (IS_DIR_SEPARATOR (*s)) +- s++; +- } +- droot = d; +- sroot = s; +- +- while (*s) +- { +- /* At this point, we're always at the beginning of a path +- segment. */ +- +- if (s[0] == '.' && (s[1] == 0 || IS_DIR_SEPARATOR (s[1]))) +- { +- s++; +- if (*s) +- while (IS_DIR_SEPARATOR (*s)) +- ++s; +- } +- +- else if (s[0] == '.' && s[1] == '.' +- && (s[2] == 0 || IS_DIR_SEPARATOR (s[2]))) +- { +- char *pre = d - 1; /* includes slash */ +- while (droot < pre && IS_DIR_SEPARATOR (*pre)) +- pre--; +- if (droot <= pre && ! IS_DIR_SEPARATOR (*pre)) +- { +- while (droot < pre && ! IS_DIR_SEPARATOR (*pre)) +- pre--; +- /* pre now points to the slash */ +- if (droot < pre) +- pre++; +- if (pre + 3 == d && pre[0] == '.' && pre[1] == '.') +- { +- *d++ = *s++; +- *d++ = *s++; +- } +- else +- { +- d = pre; +- s += 2; +- if (*s) +- while (IS_DIR_SEPARATOR (*s)) +- s++; +- } +- } +- else +- { +- *d++ = *s++; +- *d++ = *s++; +- } +- } +- else +- { +- while (*s && ! IS_DIR_SEPARATOR (*s)) +- *d++ = *s++; +- } +- +- if (IS_DIR_SEPARATOR (*s)) +- { +- *d++ = *s++; +- while (IS_DIR_SEPARATOR (*s)) +- s++; +- } +- } +- while (droot < d && IS_DIR_SEPARATOR (d[-1])) +- --d; +- if (d == rv) +- *d++ = '.'; +- *d = 0; +- +- return rv; +-} +- +-static int +-has_prefix (const char *str, +- const char *prefix) +-{ +- size_t str_len; +- size_t prefix_len; +- +- str_len = strlen (str); +- prefix_len = strlen (prefix); +- +- if (str_len < prefix_len) +- return 0; +- +- return strncmp (str, prefix, prefix_len) == 0; +-} +- +-static int +-edit_dwarf2_line (DSO *dso, rpmuint32_t off, char *comp_dir, int phase) +-{ +- unsigned char *ptr = debug_sections[DEBUG_LINE].data, *dir; +- unsigned char **dirt; +- unsigned char *endsec = ptr + debug_sections[DEBUG_LINE].size; +- unsigned char *endcu, *endprol; +- unsigned char opcode_base; +- rpmuint32_t value, dirt_cnt; +- size_t comp_dir_len = strlen (comp_dir); +- size_t abs_file_cnt = 0, abs_dir_cnt = 0; +- +- if (phase != 0) +- return 0; +- +- ptr += off; +- +- endcu = ptr + 4; +- endcu += read_32 (ptr); +- if (endcu == ptr + 0xffffffff) +- { +- error (0, 0, "%s: 64-bit DWARF not supported", dso->filename); +- return 1; +- } +- +- if (endcu > endsec) +- { +- error (0, 0, "%s: .debug_line CU does not fit into section", +- dso->filename); +- return 1; +- } +- +- value = read_16 (ptr); +- if (value != 2 && value != 3 && value != 4) +- { +- error (0, 0, "%s: DWARF version %d unhandled", dso->filename, +- value); +- return 1; +- } +- +- endprol = ptr + 4; +- endprol += read_32 (ptr); +- if (endprol > endcu) +- { +- error (0, 0, "%s: .debug_line CU prologue does not fit into CU", +- dso->filename); +- return 1; +- } +- +- opcode_base = ptr[4 + (value >= 4)]; +- ptr = dir = ptr + 4 + (value >= 4) + opcode_base; +- +- /* dir table: */ +- value = 1; +- while (*ptr != 0) +- { +- ptr = (unsigned char *) strchr ((char *)ptr, 0) + 1; +- ++value; +- } +- +- dirt = (unsigned char **) alloca (value * sizeof (unsigned char *)); +- dirt[0] = (unsigned char *) "."; +- dirt_cnt = 1; +- ptr = dir; +- while (*ptr != 0) +- { +- dirt[dirt_cnt++] = ptr; +- ptr = (unsigned char *) strchr ((char *)ptr, 0) + 1; +- } +- ptr++; +- +- /* file table: */ +- while (*ptr != 0) +- { +- char *s, *file; +- size_t file_len, dir_len; +- +- file = (char *) ptr; +- ptr = (unsigned char *) strchr ((char *)ptr, 0) + 1; +- value = read_uleb128 (ptr); +- +- if (value >= dirt_cnt) +- { +- error (0, 0, "%s: Wrong directory table index %u", +- dso->filename, value); +- return 1; +- } +- file_len = strlen (file); +- dir_len = strlen ((char *)dirt[value]); +- s = malloc (comp_dir_len + 1 + file_len + 1 + dir_len + 1); +- if (s == NULL) +- { +- error (0, ENOMEM, "%s: Reading file table", dso->filename); +- return 1; +- } +- if (*file == '/') +- { +- memcpy (s, file, file_len + 1); +- if (dest_dir && has_prefix (file, base_dir)) +- ++abs_file_cnt; +- } +- else if (*dirt[value] == '/') +- { +- memcpy (s, dirt[value], dir_len); +- s[dir_len] = '/'; +- memcpy (s + dir_len + 1, file, file_len + 1); +- } +- else +- { +- char *p = s; +- if (comp_dir_len != 0) +- { +- memcpy (s, comp_dir, comp_dir_len); +- s[comp_dir_len] = '/'; +- p += comp_dir_len + 1; +- } +- memcpy (p, dirt[value], dir_len); +- p[dir_len] = '/'; +- memcpy (p + dir_len + 1, file, file_len + 1); +- } +- canonicalize_path (s, s); +- if (list_file_fd != -1) +- { +- char *p = NULL; +- if (base_dir == NULL) +- p = s; +- else if (has_prefix (s, base_dir)) +- p = s + strlen (base_dir); +- else if (has_prefix (s, dest_dir)) +- p = s + strlen (dest_dir); +- +- if (p) +- { +- size_t size = strlen (p) + 1; +- while (size > 0) +- { +- ssize_t ret = write (list_file_fd, p, size); +- if (ret == -1) +- break; +- size -= ret; +- p += ret; +- } +- } +- } +- +- free (s); +- +- read_uleb128 (ptr); +- read_uleb128 (ptr); +- } +- ++ptr; +- +- if (dest_dir) +- { +- unsigned char *srcptr, *buf = NULL; +- size_t base_len = strlen (base_dir); +- size_t dest_len = strlen (dest_dir); +- size_t shrank = 0; +- +- if (dest_len == base_len) +- abs_file_cnt = 0; +- if (abs_file_cnt) +- { +- srcptr = buf = malloc (ptr - dir); +- memcpy (srcptr, dir, ptr - dir); +- ptr = dir; +- } +- else +- ptr = srcptr = dir; +- while (*srcptr != 0) +- { +- size_t len = strlen ((char *)srcptr) + 1; +- const unsigned char *readptr = srcptr; +- +- if (*srcptr == '/' && has_prefix ((char *)srcptr, base_dir)) +- { +- if (dest_len < base_len) +- ++abs_dir_cnt; +- memcpy (ptr, dest_dir, dest_len); +- ptr += dest_len; +- readptr += base_len; +- } +- srcptr += len; +- +- shrank += srcptr - readptr; +- canonicalize_path ((char *)readptr, (char *)ptr); +- len = strlen ((char *)ptr) + 1; +- shrank -= len; +- ptr += len; +- +- elf_flagdata (debug_sections[DEBUG_STR].elf_data, +- ELF_C_SET, ELF_F_DIRTY); +- } +- +- if (shrank > 0) +- { +- if (--shrank == 0) +- error (EXIT_FAILURE, 0, +- "canonicalization unexpectedly shrank by one character"); +- else +- { +- memset (ptr, 'X', shrank); +- ptr += shrank; +- *ptr++ = '\0'; +- } +- } +- +- if (abs_dir_cnt + abs_file_cnt != 0) +- { +- size_t len = (abs_dir_cnt + abs_file_cnt) * (base_len - dest_len); +- +- if (len == 1) +- error (EXIT_FAILURE, 0, "-b arg has to be either the same length as -d arg, or more than 1 char shorter"); +- memset (ptr, 'X', len - 1); +- ptr += len - 1; +- *ptr++ = '\0'; +- } +- *ptr++ = '\0'; +- ++srcptr; +- +- while (*srcptr != 0) +- { +- size_t len = strlen ((char *)srcptr) + 1; +- +- if (*srcptr == '/' && has_prefix ((char *)srcptr, base_dir)) +- { +- memcpy (ptr, dest_dir, dest_len); +- if (dest_len < base_len) +- { +- memmove (ptr + dest_len, srcptr + base_len, +- len - base_len); +- ptr += dest_len - base_len; +- } +- elf_flagdata (debug_sections[DEBUG_STR].elf_data, +- ELF_C_SET, ELF_F_DIRTY); +- } +- else if (ptr != srcptr) +- memmove (ptr, srcptr, len); +- srcptr += len; +- ptr += len; +- dir = srcptr; +- read_uleb128 (srcptr); +- read_uleb128 (srcptr); +- read_uleb128 (srcptr); +- if (ptr != dir) +- memmove (ptr, dir, srcptr - dir); +- ptr += srcptr - dir; +- } +- *ptr = '\0'; +- free (buf); +- } +- return 0; +-} +- +- +- +-static unsigned char * +-edit_attributes (DSO *dso, unsigned char *ptr, struct abbrev_tag *t, int phase) +-{ +- int i; +- rpmuint32_t list_offs; +- int found_list_offs; +- char *comp_dir; +- +- comp_dir = NULL; +- list_offs = 0; +- found_list_offs = 0; +- for (i = 0; i < t->nattr; ++i) +- { +- rpmuint32_t form = t->attr[i].form; +- size_t len = 0; +- size_t base_len, dest_len; +- +- +- while (1) +- { +- if (t->attr[i].attr == DW_AT_stmt_list) +- { +- if (form == DW_FORM_data4 +- || form == DW_FORM_sec_offset) +- { +- list_offs = do_read_32_relocated (ptr); +- found_list_offs = 1; +- } +- } +- +- if (t->attr[i].attr == DW_AT_comp_dir) +- { +- if ( form == DW_FORM_string ) +- { +- free (comp_dir); +- comp_dir = strdup ((char *)ptr); +- +- if (phase == 1 && dest_dir && has_prefix ((char *)ptr, base_dir)) +- { +- base_len = strlen (base_dir); +- dest_len = strlen (dest_dir); +- +- memcpy (ptr, dest_dir, dest_len); +- if (dest_len < base_len) +- { +- memset(ptr + dest_len, '/', +- base_len - dest_len); +- +- } +- elf_flagdata (debug_sections[DEBUG_INFO].elf_data, +- ELF_C_SET, ELF_F_DIRTY); +- } +- } +- +- else if (form == DW_FORM_strp && +- debug_sections[DEBUG_STR].data) +- { +- char *dir; +- +- dir = (char *) debug_sections[DEBUG_STR].data +- + do_read_32_relocated (ptr); +- +- free (comp_dir); +- comp_dir = strdup (dir); +- +- if (phase == 1 && dest_dir && has_prefix (dir, base_dir)) +- { +- base_len = strlen (base_dir); +- dest_len = strlen (dest_dir); +- +- memcpy (dir, dest_dir, dest_len); +- if (dest_len < base_len) +- { +- memmove (dir + dest_len, dir + base_len, +- strlen (dir + base_len) + 1); +- } +- elf_flagdata (debug_sections[DEBUG_STR].elf_data, +- ELF_C_SET, ELF_F_DIRTY); +- } +- } +- } +- else if ((t->tag == DW_TAG_compile_unit +- || t->tag == DW_TAG_partial_unit) +- && t->attr[i].attr == DW_AT_name +- && form == DW_FORM_strp +- && debug_sections[DEBUG_STR].data) +- { +- char *name; +- +- name = (char *) debug_sections[DEBUG_STR].data +- + do_read_32_relocated (ptr); +- if (*name == '/' && comp_dir == NULL) +- { +- char *enddir = strrchr (name, '/'); +- +- if (enddir != name) +- { +- comp_dir = malloc (enddir - name + 1); +- memcpy (comp_dir, name, enddir - name); +- comp_dir [enddir - name] = '\0'; +- } +- else +- comp_dir = strdup ("/"); +- } +- +- if (phase == 1 && dest_dir && has_prefix (name, base_dir)) +- { +- base_len = strlen (base_dir); +- dest_len = strlen (dest_dir); +- +- memcpy (name, dest_dir, dest_len); +- if (dest_len < base_len) +- { +- memmove (name + dest_len, name + base_len, +- strlen (name + base_len) + 1); +- } +- elf_flagdata (debug_sections[DEBUG_STR].elf_data, +- ELF_C_SET, ELF_F_DIRTY); +- } +- } +- +- switch (form) +- { +- case DW_FORM_ref_addr: +- if (cu_version == 2) +- ptr += ptr_size; +- else +- ptr += 4; +- break; +- case DW_FORM_flag_present: +- break; +- case DW_FORM_addr: +- ptr += ptr_size; +- break; +- case DW_FORM_ref1: +- case DW_FORM_flag: +- case DW_FORM_data1: +- ++ptr; +- break; +- case DW_FORM_ref2: +- case DW_FORM_data2: +- ptr += 2; +- break; +- case DW_FORM_ref4: +- case DW_FORM_data4: +- case DW_FORM_sec_offset: +- ptr += 4; +- break; +- case DW_FORM_ref8: +- case DW_FORM_data8: +- case DW_FORM_ref_sig8: +- ptr += 8; +- break; +- case DW_FORM_sdata: +- case DW_FORM_ref_udata: +- case DW_FORM_udata: +- read_uleb128 (ptr); +- break; +- case DW_FORM_strp: +- ptr += 4; +- break; +- case DW_FORM_string: +- ptr = (unsigned char *) strchr ((char *)ptr, '\0') + 1; +- break; +- case DW_FORM_indirect: +- form = read_uleb128 (ptr); +- continue; +- case DW_FORM_block1: +- len = *ptr++; +- break; +- case DW_FORM_block2: +- len = read_16 (ptr); +- form = DW_FORM_block1; +- break; +- case DW_FORM_block4: +- len = read_32 (ptr); +- form = DW_FORM_block1; +- break; +- case DW_FORM_block: +- case DW_FORM_exprloc: +- len = read_uleb128 (ptr); +- form = DW_FORM_block1; +- assert (len < UINT_MAX); +- break; +- default: +- error (0, 0, "%s: Unknown DWARF DW_FORM_%d", dso->filename, +- form); +- return NULL; +- } +- +- if (form == DW_FORM_block1) +- ptr += len; +- +- break; +- } +- } +- +- /* Ensure the CU current directory will exist even if only empty. Source +- filenames possibly located in its parent directories refer relatively to +- it and the debugger (GDB) cannot safely optimize out the missing +- CU current dir subdirectories. */ +- if (comp_dir && list_file_fd != -1) +- { +- char *p; +- size_t size; +- +- if (base_dir && has_prefix (comp_dir, base_dir)) +- p = comp_dir + strlen (base_dir); +- else if (dest_dir && has_prefix (comp_dir, dest_dir)) +- p = comp_dir + strlen (dest_dir); +- else +- p = comp_dir; +- +- size = strlen (p) + 1; +- while (size > 0) +- { +- ssize_t ret = write (list_file_fd, p, size); +- if (ret == -1) +- break; +- size -= ret; +- p += ret; +- } +- } +- +- if (found_list_offs && comp_dir) +- edit_dwarf2_line (dso, list_offs, comp_dir, phase); +- +- free (comp_dir); +- +- return ptr; +-} +- +-static int +-rel_cmp (const void *a, const void *b) +-{ +- REL *rela = (REL *) a, *relb = (REL *) b; +- +- if (rela->ptr < relb->ptr) +- return -1; +- +- if (rela->ptr > relb->ptr) +- return 1; +- +- return 0; +-} +- +-static int +-edit_dwarf2 (DSO *dso) +-{ +- Elf_Data *data; +- Elf_Scn *scn; +- int i, j; +- +- for (i = 0; debug_sections[i].name; ++i) +- { +- debug_sections[i].data = NULL; +- debug_sections[i].size = 0; +- debug_sections[i].sec = 0; +- debug_sections[i].relsec = 0; +- } +- ptr_size = 0; +- +- for (i = 1; i < dso->ehdr.e_shnum; ++i) +- if (! (dso->shdr[i].sh_flags & (SHF_ALLOC | SHF_WRITE | SHF_EXECINSTR)) +- && dso->shdr[i].sh_size) +- { +- const char *name = strptr (dso, dso->ehdr.e_shstrndx, +- dso->shdr[i].sh_name); +- +- if (strncmp (name, ".debug_", sizeof (".debug_") - 1) == 0) +- { +- for (j = 0; debug_sections[j].name; ++j) +- if (strcmp (name, debug_sections[j].name) == 0) +- { +- if (debug_sections[j].data) +- { +- error (0, 0, "%s: Found two copies of %s section", +- dso->filename, name); +- return 1; +- } +- +- scn = dso->scn[i]; +- data = elf_rawdata (scn, NULL); +- assert (data != NULL && data->d_buf != NULL); +- assert (elf_rawdata (scn, data) == NULL); +- assert (data->d_off == 0); +- assert (data->d_size == dso->shdr[i].sh_size); +- debug_sections[j].data = data->d_buf; +- debug_sections[j].elf_data = data; +- debug_sections[j].size = data->d_size; +- debug_sections[j].sec = i; +- break; +- } +- +- if (debug_sections[j].name == NULL) +- { +- error (0, 0, "%s: Unknown debugging section %s", +- dso->filename, name); +- } +- } +- else if (dso->ehdr.e_type == ET_REL +- && ((dso->shdr[i].sh_type == SHT_REL +- && strncmp (name, ".rel.debug_", +- sizeof (".rel.debug_") - 1) == 0) +- || (dso->shdr[i].sh_type == SHT_RELA +- && strncmp (name, ".rela.debug_", +- sizeof (".rela.debug_") - 1) == 0))) +- { +- for (j = 0; debug_sections[j].name; ++j) +- if (strcmp (name + sizeof (".rel") - 1 +- + (dso->shdr[i].sh_type == SHT_RELA), +- debug_sections[j].name) == 0) +- { +- debug_sections[j].relsec = i; +- break; +- } +- } +- } +- +- if (dso->ehdr.e_ident[EI_DATA] == ELFDATA2LSB) +- { +- do_read_16 = buf_read_ule16; +- do_read_32 = buf_read_ule32; +- write_32 = dwarf2_write_le32; +- } +- else if (dso->ehdr.e_ident[EI_DATA] == ELFDATA2MSB) +- { +- do_read_16 = buf_read_ube16; +- do_read_32 = buf_read_ube32; +- write_32 = dwarf2_write_be32; +- } +- else +- { +- error (0, 0, "%s: Wrong ELF data enconding", dso->filename); +- return 1; +- } +- +- if (debug_sections[DEBUG_INFO].data != NULL) +- { +- unsigned char *ptr, *endcu, *endsec; +- rpmuint32_t value; +- htab_t abbrev; +- struct abbrev_tag tag, *t; +- int phase; +- REL *relbuf = NULL; +- +- if (debug_sections[DEBUG_INFO].relsec) +- { +- int ndx, maxndx; +- GElf_Rel rel; +- GElf_Rela rela; +- GElf_Sym sym; +- GElf_Addr base = dso->shdr[debug_sections[DEBUG_INFO].sec].sh_addr; +- Elf_Data *symdata = NULL; +- int rtype; +- +- i = debug_sections[DEBUG_INFO].relsec; +- scn = dso->scn[i]; +- data = elf_getdata (scn, NULL); +- assert (data != NULL && data->d_buf != NULL); +- assert (elf_getdata (scn, data) == NULL); +- assert (data->d_off == 0); +- assert (data->d_size == dso->shdr[i].sh_size); +- maxndx = dso->shdr[i].sh_size / dso->shdr[i].sh_entsize; +- relbuf = malloc (maxndx * sizeof (REL)); +- reltype = dso->shdr[i].sh_type; +- if (relbuf == NULL) +- error (1, errno, "%s: Could not allocate memory", dso->filename); +- +- symdata = elf_getdata (dso->scn[dso->shdr[i].sh_link], NULL); +- assert (symdata != NULL && symdata->d_buf != NULL); +- assert (elf_getdata (dso->scn[dso->shdr[i].sh_link], symdata) +- == NULL); +- assert (symdata->d_off == 0); +- assert (symdata->d_size +- == dso->shdr[dso->shdr[i].sh_link].sh_size); +- +- for (ndx = 0, relend = relbuf; ndx < maxndx; ++ndx) +- { +- if (dso->shdr[i].sh_type == SHT_REL) +- { +- gelf_getrel (data, ndx, &rel); +- rela.r_offset = rel.r_offset; +- rela.r_info = rel.r_info; +- rela.r_addend = 0; +- } +- else +- gelf_getrela (data, ndx, &rela); +- gelf_getsym (symdata, ELF64_R_SYM (rela.r_info), &sym); +- /* Relocations against section symbols are uninteresting +- in REL. */ +- if (dso->shdr[i].sh_type == SHT_REL && sym.st_value == 0) +- continue; +- /* Only consider relocations against .debug_str, .debug_line +- and .debug_abbrev. */ +- if (sym.st_shndx != debug_sections[DEBUG_STR].sec +- && sym.st_shndx != debug_sections[DEBUG_LINE].sec +- && sym.st_shndx != debug_sections[DEBUG_ABBREV].sec) +- continue; +- rela.r_addend += sym.st_value; +- rtype = ELF64_R_TYPE (rela.r_info); +- switch (dso->ehdr.e_machine) +- { +- case EM_SPARC: +- case EM_SPARC32PLUS: +- case EM_SPARCV9: +- if (rtype != R_SPARC_32 && rtype != R_SPARC_UA32) +- goto fail; +- break; +- case EM_386: +- if (rtype != R_386_32) +- goto fail; +- break; +- case EM_PPC: +- case EM_PPC64: +- if (rtype != R_PPC_ADDR32 && rtype != R_PPC_UADDR32) +- goto fail; +- break; +- case EM_S390: +- if (rtype != R_390_32) +- goto fail; +- break; +- case EM_IA_64: +- if (rtype != R_IA64_SECREL32LSB) +- goto fail; +- break; +- case EM_X86_64: +- if (rtype != R_X86_64_32) +- goto fail; +- break; +- case EM_ALPHA: +- if (rtype != R_ALPHA_REFLONG) +- goto fail; +- break; +- default: +- fail: +- error (1, 0, "%s: Unhandled relocation %d in .debug_info section", +- dso->filename, rtype); +- } +- relend->ptr = debug_sections[DEBUG_INFO].data +- + (rela.r_offset - base); +- relend->addend = rela.r_addend; +- ++relend; +- } +- if (relbuf == relend) +- { +- free (relbuf); +- relbuf = NULL; +- relend = NULL; +- } +- else +- qsort (relbuf, relend - relbuf, sizeof (REL), rel_cmp); +- } +- +- for (phase = 0; phase < 2; phase++) +- { +- ptr = debug_sections[DEBUG_INFO].data; +- relptr = relbuf; +- endsec = ptr + debug_sections[DEBUG_INFO].size; +- while (ptr < endsec) +- { +- if (ptr + 11 > endsec) +- { +- error (0, 0, "%s: .debug_info CU header too small", +- dso->filename); +- return 1; +- } +- +- endcu = ptr + 4; +- endcu += read_32 (ptr); +- if (endcu == ptr + 0xffffffff) +- { +- error (0, 0, "%s: 64-bit DWARF not supported", dso->filename); +- return 1; +- } +- +- if (endcu > endsec) +- { +- error (0, 0, "%s: .debug_info too small", dso->filename); +- return 1; +- } +- +- cu_version = read_16 (ptr); +- if (cu_version != 2 && cu_version != 3 && cu_version != 4) +- { +- error (0, 0, "%s: DWARF version %d unhandled", dso->filename, +- cu_version); +- return 1; +- } +- +- value = read_32_relocated (ptr); +- if (value >= debug_sections[DEBUG_ABBREV].size) +- { +- if (debug_sections[DEBUG_ABBREV].data == NULL) +- error (0, 0, "%s: .debug_abbrev not present", dso->filename); +- else +- error (0, 0, "%s: DWARF CU abbrev offset too large", +- dso->filename); +- return 1; +- } +- +- if (ptr_size == 0) +- { +- ptr_size = read_1 (ptr); +- if (ptr_size != 4 && ptr_size != 8) +- { +- error (0, 0, "%s: Invalid DWARF pointer size %d", +- dso->filename, ptr_size); +- return 1; +- } +- } +- else if (read_1 (ptr) != ptr_size) +- { +- error (0, 0, "%s: DWARF pointer size differs between CUs", +- dso->filename); +- return 1; +- } +- +- abbrev = read_abbrev (dso, +- debug_sections[DEBUG_ABBREV].data + value); +- if (abbrev == NULL) +- return 1; +- +- while (ptr < endcu) +- { +- tag.entry = read_uleb128 (ptr); +- if (tag.entry == 0) +- continue; +- t = htab_find_with_hash (abbrev, &tag, tag.entry); +- if (t == NULL) +- { +- error (0, 0, "%s: Could not find DWARF abbreviation %d", +- dso->filename, tag.entry); +- htab_delete (abbrev); +- return 1; +- } +- +- ptr = edit_attributes (dso, ptr, t, phase); +- if (ptr == NULL) +- break; +- } +- +- htab_delete (abbrev); +- } +- } +- free (relbuf); +- } +- +- return 0; +-} +- +-static struct poptOption optionsTable[] = { +- { "base-dir", 'b', POPT_ARG_STRING, &base_dir, 0, +- "base build directory of objects", NULL }, +- { "dest-dir", 'd', POPT_ARG_STRING, &dest_dir, 0, +- "directory to rewrite base-dir into", NULL }, +- { "list-file", 'l', POPT_ARG_STRING, &list_file, 0, +- "file where to put list of source and header file names", NULL }, +- { "build-id", 'i', POPT_ARG_NONE, &do_build_id, 0, +- "recompute build ID note and print ID on stdout", NULL }, +- POPT_AUTOHELP +- { NULL, 0, 0, NULL, 0, NULL, NULL } +-}; +- +-static DSO * +-fdopen_dso (int fd, const char *name) +-{ +- Elf *elf = NULL; +- GElf_Ehdr ehdr; +- int i; +- DSO *dso = NULL; +- +- elf = elf_begin (fd, ELF_C_RDWR_MMAP, NULL); +- if (elf == NULL) +- { +- error (0, 0, "cannot open ELF file: %s", elf_errmsg (-1)); +- goto error_out; +- } +- +- if (elf_kind (elf) != ELF_K_ELF) +- { +- error (0, 0, "\"%s\" is not an ELF file", name); +- goto error_out; +- } +- +- if (gelf_getehdr (elf, &ehdr) == NULL) +- { +- error (0, 0, "cannot get the ELF header: %s", +- elf_errmsg (-1)); +- goto error_out; +- } +- +- if (ehdr.e_type != ET_DYN && ehdr.e_type != ET_EXEC && ehdr.e_type != ET_REL) +- { +- error (0, 0, "\"%s\" is not a shared library", name); +- goto error_out; +- } +- +- /* Allocate DSO structure. Leave place for additional 20 new section +- headers. */ +- dso = (DSO *) +- malloc (sizeof(DSO) + (ehdr.e_shnum + 20) * sizeof(GElf_Shdr) +- + (ehdr.e_shnum + 20) * sizeof(Elf_Scn *)); +- if (!dso) +- { +- error (0, ENOMEM, "Could not open DSO"); +- goto error_out; +- } +- +- elf_flagelf (elf, ELF_C_SET, ELF_F_LAYOUT); +- +- memset (dso, 0, sizeof(DSO)); +- dso->elf = elf; +- dso->ehdr = ehdr; +- dso->scn = (Elf_Scn **) &dso->shdr[ehdr.e_shnum + 20]; +- +- for (i = 0; i < ehdr.e_shnum; ++i) +- { +- dso->scn[i] = elf_getscn (elf, i); +- gelf_getshdr (dso->scn[i], dso->shdr + i); +- } +- +- dso->filename = (const char *) strdup (name); +- return dso; +- +-error_out: +- if (dso) +- { +- free ((char *) dso->filename); +- free (dso); +- } +- if (elf) +- elf_end (elf); +- if (fd != -1) +- close (fd); +- return NULL; +-} +- +-/* Compute a fresh build ID bit-string from the editted file contents. */ +-static void +-handle_build_id (DSO *dso, Elf_Data *build_id, +- size_t build_id_offset, size_t build_id_size) +-{ +- hashFunctionContext ctx; +- const hashFunction *hf = NULL; +- int i = hashFunctionCount (); +- +- while (i-- > 0) +- { +- hf = hashFunctionGet (i); +- if (hf != NULL && hf->digestsize == build_id_size) +- break; +- } +- if (hf == NULL) +- { +- fprintf (stderr, "Cannot handle %Zu-byte build ID\n", build_id_size); +- exit (1); +- } +- +- if (elf_update (dso->elf, ELF_C_NULL) < 0) +- { +- fprintf (stderr, "Failed to update file: %s\n", +- elf_errmsg (elf_errno ())); +- exit (1); +- } +- +- /* Clear the old bits so they do not affect the new hash. */ +- memset ((char *) build_id->d_buf + build_id_offset, 0, build_id_size); +- +- hashFunctionContextInit (&ctx, hf); +- +- /* Slurp the relevant header bits and section contents and feed them +- into the hash function. The only bits we ignore are the offset +- fields in ehdr and shdrs, since the semantically identical ELF file +- could be written differently if it doesn't change the phdr layout. +- We always use the GElf (i.e. Elf64) formats for the bits to hash +- since it is convenient. It doesn't matter whether this is an Elf32 +- or Elf64 object, only that we are consistent in what bits feed the +- hash so it comes out the same for the same file contents. */ +- { +- auto inline void process (const void *data, size_t size); +- auto inline void process (const void *data, size_t size) +- { +- memchunk chunk = { .data = (void *) data, .size = size }; +- hashFunctionContextUpdateMC (&ctx, &chunk); +- } +- union +- { +- GElf_Ehdr ehdr; +- GElf_Phdr phdr; +- GElf_Shdr shdr; +- } u; +- Elf_Data x = { .d_version = EV_CURRENT, .d_buf = &u }; +- +- x.d_type = ELF_T_EHDR; +- x.d_size = sizeof u.ehdr; +- u.ehdr = dso->ehdr; +- u.ehdr.e_phoff = u.ehdr.e_shoff = 0; +- if (elf64_xlatetom (&x, &x, dso->ehdr.e_ident[EI_DATA]) == NULL) +- { +- bad: +- fprintf (stderr, "Failed to compute header checksum: %s\n", +- elf_errmsg (elf_errno ())); +- exit (1); +- } +- +- x.d_type = ELF_T_PHDR; +- x.d_size = sizeof u.phdr; +- for (i = 0; i < dso->ehdr.e_phnum; ++i) +- { +- if (gelf_getphdr (dso->elf, i, &u.phdr) == NULL) +- goto bad; +- if (elf64_xlatetom (&x, &x, dso->ehdr.e_ident[EI_DATA]) == NULL) +- goto bad; +- process (x.d_buf, x.d_size); +- } +- +- x.d_type = ELF_T_SHDR; +- x.d_size = sizeof u.shdr; +- for (i = 0; i < dso->ehdr.e_shnum; ++i) +- if (dso->scn[i] != NULL) +- { +- u.shdr = dso->shdr[i]; +- u.shdr.sh_offset = 0; +- if (elf64_xlatetom (&x, &x, dso->ehdr.e_ident[EI_DATA]) == NULL) +- goto bad; +- process (x.d_buf, x.d_size); +- +- if (u.shdr.sh_type != SHT_NOBITS) +- { +- Elf_Data *d = elf_rawdata (dso->scn[i], NULL); +- if (d == NULL) +- goto bad; +- process (d->d_buf, d->d_size); +- } +- } +- } +- +- hashFunctionContextDigest (&ctx, (byte *) build_id->d_buf + build_id_offset); +- hashFunctionContextFree (&ctx); +- +- elf_flagdata (build_id, ELF_C_SET, ELF_F_DIRTY); +- +- /* Now format the build ID bits in hex to print out. */ +- { +- const rpmuint8_t * id = (rpmuint8_t *)build_id->d_buf + build_id_offset; +- char hex[build_id_size * 2 + 1]; +- int n = snprintf (hex, 3, "%02" PRIx8, id[0]); +- assert (n == 2); +- for (i = 1; i < (int)build_id_size; ++i) +- { +- n = snprintf (&hex[i * 2], 3, "%02" PRIx8, id[i]); +- assert (n == 2); +- } +- puts (hex); +- } +-} +- +-int +-main (int argc, char *argv[]) +-{ +- DSO *dso; +- int fd, i; +- const char *file; +- poptContext optCon; /* context for parsing command-line options */ +- int nextopt; +- const char **args; +- struct stat stat_buf; +- char *p; +- Elf_Data *build_id = NULL; +- size_t build_id_offset = 0, build_id_size = 0; +- +- optCon = poptGetContext("debugedit", argc, (const char **)argv, optionsTable, 0); +- +- while ((nextopt = poptGetNextOpt (optCon)) > 0 || nextopt == POPT_ERROR_BADOPT) +- /* do nothing */ ; +- +- if (nextopt != -1) +- { +- fprintf (stderr, "Error on option %s: %s.\nRun '%s --help' to see a full list of available command line options.\n", +- poptBadOption (optCon, 0), +- poptStrerror (nextopt), +- argv[0]); +- exit (1); +- } +- +- args = poptGetArgs (optCon); +- if (args == NULL || args[0] == NULL || args[1] != NULL) +- { +- poptPrintHelp(optCon, stdout, 0); +- exit (1); +- } +- +- if (dest_dir != NULL) +- { +- if (base_dir == NULL) +- { +- fprintf (stderr, "You must specify a base dir if you specify a dest dir\n"); +- exit (1); +- } +- if (strlen (dest_dir) > strlen (base_dir)) +- { +- fprintf (stderr, "Only dest dir longer than base dir not supported\n"); +- exit (1); +- } +- } +- +- /* Make sure there are trailing slashes in dirs */ +- if (base_dir != NULL && base_dir[strlen (base_dir)-1] != '/') +- { +- p = malloc (strlen (base_dir) + 2); +- strcpy (p, base_dir); +- strcat (p, "/"); +- free (base_dir); +- base_dir = p; +- } +- if (dest_dir != NULL && dest_dir[strlen (dest_dir)-1] != '/') +- { +- p = malloc (strlen (dest_dir) + 2); +- strcpy (p, dest_dir); +- strcat (p, "/"); +- free (dest_dir); +- dest_dir = p; +- } +- +- if (list_file != NULL) +- { +- list_file_fd = open (list_file, O_WRONLY|O_CREAT|O_APPEND, 0644); +- } +- +- file = args[0]; +- +- if (elf_version(EV_CURRENT) == EV_NONE) +- { +- fprintf (stderr, "library out of date\n"); +- exit (1); +- } +- +- if (stat(file, &stat_buf) < 0) +- { +- fprintf (stderr, "Failed to open input file '%s': %s\n", file, strerror(errno)); +- exit (1); +- } +- +- /* Make sure we can read and write */ +- chmod (file, stat_buf.st_mode | S_IRUSR | S_IWUSR); +- +- fd = open (file, O_RDWR); +- if (fd < 0) +- { +- fprintf (stderr, "Failed to open input file '%s': %s\n", file, strerror(errno)); +- exit (1); +- } +- +- dso = fdopen_dso (fd, file); +- if (dso == NULL) +- exit (1); +- +- for (i = 1; i < dso->ehdr.e_shnum; i++) +- { +- const char *name; +- +- switch (dso->shdr[i].sh_type) +- { +- case SHT_PROGBITS: +- case SHT_MIPS_DWARF: +- name = strptr (dso, dso->ehdr.e_shstrndx, dso->shdr[i].sh_name); +- /* TODO: Handle stabs */ +-#if 0 +- if (strcmp (name, ".stab") == 0) +- edit_stabs (dso, i); +-#endif +- if (strcmp (name, ".debug_info") == 0) +- edit_dwarf2 (dso); +- +- break; +- case SHT_NOTE: +- if (do_build_id +- && build_id == NULL && (dso->shdr[i].sh_flags & SHF_ALLOC)) +- { +- /* Look for a build-ID note here. */ +- Elf_Data *data = elf_rawdata (elf_getscn (dso->elf, i), NULL); +- Elf32_Nhdr nh; +- Elf_Data dst = +- { +- .d_version = EV_CURRENT, .d_type = ELF_T_NHDR, +- .d_buf = &nh, .d_size = sizeof nh +- }; +- Elf_Data src = dst; +- src.d_buf = data->d_buf; +- assert (sizeof (Elf32_Nhdr) == sizeof (Elf64_Nhdr)); +- while ((char *) data->d_buf + data->d_size - +- (char *) src.d_buf > (int) sizeof nh +- && elf32_xlatetom (&dst, &src, dso->ehdr.e_ident[EI_DATA])) +- { +- Elf32_Word len = sizeof nh + nh.n_namesz; +- len = (len + 3) & ~3; +- +- if (nh.n_namesz == sizeof "GNU" && nh.n_type == 3 +- && !memcmp ((char *) src.d_buf + sizeof nh, "GNU", sizeof "GNU")) +- { +- build_id = data; +- build_id_offset = (char *) src.d_buf + len - +- (char *) data->d_buf; +- build_id_size = nh.n_descsz; +- break; +- } +- +- len += nh.n_descsz; +- len = (len + 3) & ~3; +- src.d_buf = (char *) src.d_buf + len; +- } +- } +- break; +- default: +- break; +- } +- } +- +- if (do_build_id && build_id != NULL) +- handle_build_id (dso, build_id, build_id_offset, build_id_size); +- +- if (elf_update (dso->elf, ELF_C_WRITE) < 0) +- { +- fprintf (stderr, "Failed to write file: %s\n", elf_errmsg (elf_errno())); +- exit (1); +- } +- if (elf_end (dso->elf) < 0) +- { +- fprintf (stderr, "elf_end failed: %s\n", elf_errmsg (elf_errno())); +- exit (1); +- } +- close (fd); +- +- /* Restore old access rights */ +- chmod (file, stat_buf.st_mode); +- +- poptFreeContext (optCon); +- +- return 0; +-} +diff --git a/src/debugedit/hashtab.c b/src/debugedit/hashtab.c +deleted file mode 100644 +index e498545..0000000 +--- a/src/debugedit/hashtab.c ++++ /dev/null +@@ -1,523 +0,0 @@ +-/* An expandable hash tables datatype. +- Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc. +- Contributed by Vladimir Makarov (vmakarov@cygnus.com). +- +-This file is part of the libiberty library. +-Libiberty is free software; you can redistribute it and/or +-modify it under the terms of the GNU Library General Public +-License as published by the Free Software Foundation; either +-version 2 of the License, or (at your option) any later version. +- +-Libiberty is distributed in the hope that it will be useful, +-but WITHOUT ANY WARRANTY; without even the implied warranty of +-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +-Library General Public License for more details. +- +-You should have received a copy of the GNU Library General Public +-License along with libiberty; see the file COPYING.LIB. If +-not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +-Boston, MA 02111-1307, USA. */ +- +-/* This package implements basic hash table functionality. It is possible +- to search for an entry, create an entry and destroy an entry. +- +- Elements in the table are generic pointers. +- +- The size of the table is not fixed; if the occupancy of the table +- grows too high the hash table will be expanded. +- +- The abstract data implementation is based on generalized Algorithm D +- from Knuth's book "The art of computer programming". Hash table is +- expanded by creation of new hash table and transferring elements from +- the old table to the new table. */ +- +-#include +-#include +-#include +-#include +-#include "hashtab.h" +- +-/* This macro defines reserved value for empty table entry. */ +- +-#define EMPTY_ENTRY ((void *) 0) +- +-/* This macro defines reserved value for table entry which contained +- a deleted element. */ +- +-#define DELETED_ENTRY ((void *) 1) +- +-static unsigned long higher_prime_number (unsigned long); +-static hashval_t hash_pointer (const void *); +-static int eq_pointer (const void *, const void *); +-static int htab_expand (htab_t); +-static void **find_empty_slot_for_expand (htab_t, hashval_t); +- +-/* At some point, we could make these be NULL, and modify the +- hash-table routines to handle NULL specially; that would avoid +- function-call overhead for the common case of hashing pointers. */ +-htab_hash htab_hash_pointer = hash_pointer; +-htab_eq htab_eq_pointer = eq_pointer; +- +-/* The following function returns a nearest prime number which is +- greater than N, and near a power of two. */ +- +-static unsigned long +-higher_prime_number (n) +- unsigned long n; +-{ +- /* These are primes that are near, but slightly smaller than, a +- power of two. */ +- static unsigned long primes[] = { +- (unsigned long) 2, +- (unsigned long) 7, +- (unsigned long) 13, +- (unsigned long) 31, +- (unsigned long) 61, +- (unsigned long) 127, +- (unsigned long) 251, +- (unsigned long) 509, +- (unsigned long) 1021, +- (unsigned long) 2039, +- (unsigned long) 4093, +- (unsigned long) 8191, +- (unsigned long) 16381, +- (unsigned long) 32749, +- (unsigned long) 65521, +- (unsigned long) 131071, +- (unsigned long) 262139, +- (unsigned long) 524287, +- (unsigned long) 1048573, +- (unsigned long) 2097143, +- (unsigned long) 4194301, +- (unsigned long) 8388593, +- (unsigned long) 16777213, +- (unsigned long) 33554393, +- (unsigned long) 67108859, +- (unsigned long) 134217689, +- (unsigned long) 268435399, +- (unsigned long) 536870909, +- (unsigned long) 1073741789, +- (unsigned long) 2147483647, +- /* 4294967291L */ +- ((unsigned long) 2147483647) + ((unsigned long) 2147483644), +- }; +- +- unsigned long* low = &primes[0]; +- unsigned long* high = &primes[sizeof(primes) / sizeof(primes[0])]; +- +- while (low != high) +- { +- unsigned long* mid = low + (high - low) / 2; +- if (n > *mid) +- low = mid + 1; +- else +- high = mid; +- } +- +- /* If we've run out of primes, abort. */ +- if (n > *low) +- { +- fprintf (stderr, "Cannot find prime bigger than %lu\n", n); +- abort (); +- } +- +- return *low; +-} +- +-/* Returns a hash code for P. */ +- +-static hashval_t +-hash_pointer (p) +- const void * p; +-{ +- return (hashval_t) ((long)p >> 3); +-} +- +-/* Returns non-zero if P1 and P2 are equal. */ +- +-static int +-eq_pointer (p1, p2) +- const void * p1; +- const void * p2; +-{ +- return p1 == p2; +-} +- +-/* This function creates table with length slightly longer than given +- source length. The created hash table is initiated as empty (all the +- hash table entries are EMPTY_ENTRY). The function returns the created +- hash table. Memory allocation may fail; it may return NULL. */ +- +-htab_t +-htab_try_create (size, hash_f, eq_f, del_f) +- size_t size; +- htab_hash hash_f; +- htab_eq eq_f; +- htab_del del_f; +-{ +- htab_t result; +- +- size = higher_prime_number (size); +- result = (htab_t) calloc (1, sizeof (struct htab)); +- if (result == NULL) +- return NULL; +- +- result->entries = (void **) calloc (size, sizeof (void *)); +- if (result->entries == NULL) +- { +- free (result); +- return NULL; +- } +- +- result->size = size; +- result->hash_f = hash_f; +- result->eq_f = eq_f; +- result->del_f = del_f; +- result->return_allocation_failure = 1; +- return result; +-} +- +-/* This function frees all memory allocated for given hash table. +- Naturally the hash table must already exist. */ +- +-void +-htab_delete (htab) +- htab_t htab; +-{ +- int i; +- +- if (htab->del_f) +- for (i = htab->size - 1; i >= 0; i--) +- if (htab->entries[i] != EMPTY_ENTRY +- && htab->entries[i] != DELETED_ENTRY) +- (*htab->del_f) (htab->entries[i]); +- +- free (htab->entries); +- free (htab); +-} +- +-/* This function clears all entries in the given hash table. */ +- +-void +-htab_empty (htab) +- htab_t htab; +-{ +- int i; +- +- if (htab->del_f) +- for (i = htab->size - 1; i >= 0; i--) +- if (htab->entries[i] != EMPTY_ENTRY +- && htab->entries[i] != DELETED_ENTRY) +- (*htab->del_f) (htab->entries[i]); +- +- memset (htab->entries, 0, htab->size * sizeof (void *)); +-} +- +-/* Similar to htab_find_slot, but without several unwanted side effects: +- - Does not call htab->eq_f when it finds an existing entry. +- - Does not change the count of elements/searches/collisions in the +- hash table. +- This function also assumes there are no deleted entries in the table. +- HASH is the hash value for the element to be inserted. */ +- +-static void ** +-find_empty_slot_for_expand (htab, hash) +- htab_t htab; +- hashval_t hash; +-{ +- size_t size = htab->size; +- hashval_t hash2 = 1 + hash % (size - 2); +- unsigned int index = hash % size; +- +- for (;;) +- { +- void **slot = htab->entries + index; +- +- if (*slot == EMPTY_ENTRY) +- return slot; +- else if (*slot == DELETED_ENTRY) +- abort (); +- +- index += hash2; +- if (index >= size) +- index -= size; +- } +-} +- +-/* The following function changes size of memory allocated for the +- entries and repeatedly inserts the table elements. The occupancy +- of the table after the call will be about 50%. Naturally the hash +- table must already exist. Remember also that the place of the +- table entries is changed. If memory allocation failures are allowed, +- this function will return zero, indicating that the table could not be +- expanded. If all goes well, it will return a non-zero value. */ +- +-static int +-htab_expand (htab) +- htab_t htab; +-{ +- void **oentries; +- void **olimit; +- void **p; +- +- oentries = htab->entries; +- olimit = oentries + htab->size; +- +- htab->size = higher_prime_number (htab->size * 2); +- +- if (htab->return_allocation_failure) +- { +- void **nentries = (void **) calloc (htab->size, sizeof (void **)); +- if (nentries == NULL) +- return 0; +- htab->entries = nentries; +- } +- +- htab->n_elements -= htab->n_deleted; +- htab->n_deleted = 0; +- +- p = oentries; +- do +- { +- void * x = *p; +- +- if (x != EMPTY_ENTRY && x != DELETED_ENTRY) +- { +- void **q = find_empty_slot_for_expand (htab, (*htab->hash_f) (x)); +- +- *q = x; +- } +- +- p++; +- } +- while (p < olimit); +- +- free (oentries); +- return 1; +-} +- +-/* This function searches for a hash table entry equal to the given +- element. It cannot be used to insert or delete an element. */ +- +-void * +-htab_find_with_hash (htab, element, hash) +- htab_t htab; +- const void * element; +- hashval_t hash; +-{ +- unsigned int index; +- hashval_t hash2; +- size_t size; +- void * entry; +- +- htab->searches++; +- size = htab->size; +- index = hash % size; +- +- entry = htab->entries[index]; +- if (entry == EMPTY_ENTRY +- || (entry != DELETED_ENTRY && (*htab->eq_f) (entry, element))) +- return entry; +- +- hash2 = 1 + hash % (size - 2); +- +- for (;;) +- { +- htab->collisions++; +- index += hash2; +- if (index >= size) +- index -= size; +- +- entry = htab->entries[index]; +- if (entry == EMPTY_ENTRY +- || (entry != DELETED_ENTRY && (*htab->eq_f) (entry, element))) +- return entry; +- } +-} +- +-/* Like htab_find_slot_with_hash, but compute the hash value from the +- element. */ +- +-void * +-htab_find (htab, element) +- htab_t htab; +- const void * element; +-{ +- return htab_find_with_hash (htab, element, (*htab->hash_f) (element)); +-} +- +-/* This function searches for a hash table slot containing an entry +- equal to the given element. To delete an entry, call this with +- INSERT = 0, then call htab_clear_slot on the slot returned (possibly +- after doing some checks). To insert an entry, call this with +- INSERT = 1, then write the value you want into the returned slot. +- When inserting an entry, NULL may be returned if memory allocation +- fails. */ +- +-void ** +-htab_find_slot_with_hash (htab, element, hash, insert) +- htab_t htab; +- const void * element; +- hashval_t hash; +- enum insert_option insert; +-{ +- void **first_deleted_slot; +- unsigned int index; +- hashval_t hash2; +- size_t size; +- +- if (insert == INSERT && htab->size * 3 <= htab->n_elements * 4 +- && htab_expand (htab) == 0) +- return NULL; +- +- size = htab->size; +- hash2 = 1 + hash % (size - 2); +- index = hash % size; +- +- htab->searches++; +- first_deleted_slot = NULL; +- +- for (;;) +- { +- void * entry = htab->entries[index]; +- if (entry == EMPTY_ENTRY) +- { +- if (insert == NO_INSERT) +- return NULL; +- +- htab->n_elements++; +- +- if (first_deleted_slot) +- { +- *first_deleted_slot = EMPTY_ENTRY; +- return first_deleted_slot; +- } +- +- return &htab->entries[index]; +- } +- +- if (entry == DELETED_ENTRY) +- { +- if (!first_deleted_slot) +- first_deleted_slot = &htab->entries[index]; +- } +- else if ((*htab->eq_f) (entry, element)) +- return &htab->entries[index]; +- +- htab->collisions++; +- index += hash2; +- if (index >= size) +- index -= size; +- } +-} +- +-/* Like htab_find_slot_with_hash, but compute the hash value from the +- element. */ +- +-void ** +-htab_find_slot (htab, element, insert) +- htab_t htab; +- const void * element; +- enum insert_option insert; +-{ +- return htab_find_slot_with_hash (htab, element, (*htab->hash_f) (element), +- insert); +-} +- +-/* This function deletes an element with the given value from hash +- table. If there is no matching element in the hash table, this +- function does nothing. */ +- +-void +-htab_remove_elt (htab, element) +- htab_t htab; +- void * element; +-{ +- void **slot; +- +- slot = htab_find_slot (htab, element, NO_INSERT); +- if (*slot == EMPTY_ENTRY) +- return; +- +- if (htab->del_f) +- (*htab->del_f) (*slot); +- +- *slot = DELETED_ENTRY; +- htab->n_deleted++; +-} +- +-/* This function clears a specified slot in a hash table. It is +- useful when you've already done the lookup and don't want to do it +- again. */ +- +-void +-htab_clear_slot (htab, slot) +- htab_t htab; +- void **slot; +-{ +- if (slot < htab->entries || slot >= htab->entries + htab->size +- || *slot == EMPTY_ENTRY || *slot == DELETED_ENTRY) +- abort (); +- +- if (htab->del_f) +- (*htab->del_f) (*slot); +- +- *slot = DELETED_ENTRY; +- htab->n_deleted++; +-} +- +-/* This function scans over the entire hash table calling +- CALLBACK for each live entry. If CALLBACK returns false, +- the iteration stops. INFO is passed as CALLBACK's second +- argument. */ +- +-void +-htab_traverse (htab, callback, info) +- htab_t htab; +- htab_trav callback; +- void * info; +-{ +- void **slot = htab->entries; +- void **limit = slot + htab->size; +- +- do +- { +- void * x = *slot; +- +- if (x != EMPTY_ENTRY && x != DELETED_ENTRY) +- if (!(*callback) (slot, info)) +- break; +- } +- while (++slot < limit); +-} +- +-/* Return the current size of given hash table. */ +- +-size_t +-htab_size (htab) +- htab_t htab; +-{ +- return htab->size; +-} +- +-/* Return the current number of elements in given hash table. */ +- +-size_t +-htab_elements (htab) +- htab_t htab; +-{ +- return htab->n_elements - htab->n_deleted; +-} +- +-/* Return the fraction of fixed collisions during all work with given +- hash table. */ +- +-double +-htab_collisions (htab) +- htab_t htab; +-{ +- if (htab->searches == 0) +- return 0.0; +- +- return (double) htab->collisions / (double) htab->searches; +-} +diff --git a/src/debugedit/hashtab.h b/src/debugedit/hashtab.h +deleted file mode 100644 +index 9ed18ae..0000000 +--- a/src/debugedit/hashtab.h ++++ /dev/null +@@ -1,143 +0,0 @@ +-/* An expandable hash tables datatype. +- Copyright (C) 1999, 2000 Free Software Foundation, Inc. +- Contributed by Vladimir Makarov (vmakarov@cygnus.com). +- +-This program is free software; you can redistribute it and/or modify +-it under the terms of the GNU General Public License as published by +-the Free Software Foundation; either version 2 of the License, or +-(at your option) any later version. +- +-This program is distributed in the hope that it will be useful, +-but WITHOUT ANY WARRANTY; without even the implied warranty of +-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +-GNU General Public License for more details. +- +-You should have received a copy of the GNU General Public License +-along with this program; if not, write to the Free Software +-Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ +- +-/* This package implements basic hash table functionality. It is possible +- to search for an entry, create an entry and destroy an entry. +- +- Elements in the table are generic pointers. +- +- The size of the table is not fixed; if the occupancy of the table +- grows too high the hash table will be expanded. +- +- The abstract data implementation is based on generalized Algorithm D +- from Knuth's book "The art of computer programming". Hash table is +- expanded by creation of new hash table and transferring elements from +- the old table to the new table. */ +- +-#ifndef __HASHTAB_H__ +-#define __HASHTAB_H__ +- +-#ifdef __cplusplus +-extern "C" { +-#endif /* __cplusplus */ +- +-/* The type for a hash code. */ +-typedef unsigned int hashval_t; +- +-/* Callback function pointer types. */ +- +-/* Calculate hash of a table entry. */ +-typedef hashval_t (*htab_hash) (const void *); +- +-/* Compare a table entry with a possible entry. The entry already in +- the table always comes first, so the second element can be of a +- different type (but in this case htab_find and htab_find_slot +- cannot be used; instead the variants that accept a hash value +- must be used). */ +-typedef int (*htab_eq) (const void *, const void *); +- +-/* Cleanup function called whenever a live element is removed from +- the hash table. */ +-typedef void (*htab_del) (void *); +- +-/* Function called by htab_traverse for each live element. The first +- arg is the slot of the element (which can be passed to htab_clear_slot +- if desired), the second arg is the auxiliary pointer handed to +- htab_traverse. Return 1 to continue scan, 0 to stop. */ +-typedef int (*htab_trav) (void **, void *); +- +-/* Hash tables are of the following type. The structure +- (implementation) of this type is not needed for using the hash +- tables. All work with hash table should be executed only through +- functions mentioned below. */ +- +-struct htab +-{ +- /* Pointer to hash function. */ +- htab_hash hash_f; +- +- /* Pointer to comparison function. */ +- htab_eq eq_f; +- +- /* Pointer to cleanup function. */ +- htab_del del_f; +- +- /* Table itself. */ +- void **entries; +- +- /* Current size (in entries) of the hash table */ +- size_t size; +- +- /* Current number of elements including also deleted elements */ +- size_t n_elements; +- +- /* Current number of deleted elements in the table */ +- size_t n_deleted; +- +- /* The following member is used for debugging. Its value is number +- of all calls of `htab_find_slot' for the hash table. */ +- unsigned int searches; +- +- /* The following member is used for debugging. Its value is number +- of collisions fixed for time of work with the hash table. */ +- unsigned int collisions; +- +- /* This is non-zero if we are allowed to return NULL for function calls +- that allocate memory. */ +- int return_allocation_failure; +-}; +- +-typedef struct htab *htab_t; +- +-/* An enum saying whether we insert into the hash table or not. */ +-enum insert_option {NO_INSERT, INSERT}; +- +-/* The prototypes of the package functions. */ +- +-/* This function is like htab_create, but may return NULL if memory +- allocation fails, and also signals that htab_find_slot_with_hash and +- htab_find_slot are allowed to return NULL when inserting. */ +-extern htab_t htab_try_create (size_t, htab_hash, htab_eq, htab_del); +-extern void htab_delete (htab_t); +-extern void htab_empty (htab_t); +- +-extern void *htab_find (htab_t, const void *); +-extern void **htab_find_slot (htab_t, const void *, enum insert_option); +-extern void *htab_find_with_hash (htab_t, const void *, hashval_t); +-extern void **htab_find_slot_with_hash (htab_t, const void *, hashval_t, +- enum insert_option); +-extern void htab_clear_slot (htab_t, void **); +-extern void htab_remove_elt (htab_t, void *); +- +-extern void htab_traverse (htab_t, htab_trav, void *); +- +-extern size_t htab_size (htab_t); +-extern size_t htab_elements (htab_t); +-extern double htab_collisions (htab_t); +- +-/* A hash function for pointers. */ +-extern htab_hash htab_hash_pointer; +- +-/* An equality function for pointers. */ +-extern htab_eq htab_eq_pointer; +- +-#ifdef __cplusplus +-} +-#endif /* __cplusplus */ +- +-#endif /* __HASHTAB_H */ +diff --git a/src/debugedit/rpmiotypes.h b/src/debugedit/rpmiotypes.h +deleted file mode 100644 +index 04891a1..0000000 +--- a/src/debugedit/rpmiotypes.h ++++ /dev/null +@@ -1,653 +0,0 @@ +-#ifndef _H_RPMIOTYPES_ +-#define _H_RPMIOTYPES_ +- +-/** \ingroup rpmio +- * \file rpmio/rpmiotypes.h +- */ +- +-/** \ingroup rpmio +- * RPM return codes. +- */ +-typedef enum rpmRC_e { +- RPMRC_OK = 0, /*!< Generic success code */ +- RPMRC_NOTFOUND = 1, /*!< Generic not found code. */ +- RPMRC_FAIL = 2, /*!< Generic failure code. */ +- RPMRC_NOTTRUSTED = 3, /*!< Signature is OK, but key is not trusted. */ +- RPMRC_NOKEY = 4 /*!< Public key is unavailable. */ +-} rpmRC; +- +-/** \ingroup rpmio +- * Private int typedefs to avoid C99 portability issues. +- */ +-typedef /*@unsignedintegraltype@*/ unsigned char rpmuint8_t; +-typedef /*@unsignedintegraltype@*/ unsigned short rpmuint16_t; +-typedef /*@unsignedintegraltype@*/ unsigned int rpmuint32_t; +-typedef /*@unsignedintegraltype@*/ unsigned long long rpmuint64_t; +- +-/** \ingroup rpmio +- */ +-typedef /*@signedintegraltype@*/ int rpmint32_t; +- +-/** +- */ +-typedef /*@refcounted@*/ struct rpmioItem_s * rpmioItem; +-struct rpmioItem_s { +-/*@null@*/ +- void *use; /*!< use count -- return to pool when zero */ +-/*@kept@*/ /*@null@*/ +- void *pool; /*!< pool (or NULL if malloc'd) */ +-#if defined(__LCLINT__) +-/*@refs@*/ +- int nrefs; /*!< (unused) keep splint happy */ +-#endif +-}; +- +-/** +- */ +-typedef struct rpmioPool_s * rpmioPool; +- +-/** \ingroup rpmio +- */ +-typedef /*@abstract@*/ /*@refcounted@*/ struct rpmiob_s * rpmiob; +- +-/** \ingroup rpmio +- */ +-/*@unchecked@*/ +-extern size_t _rpmiob_chunk; +- +-/** \ingroup rpmio +- */ +-typedef struct rpmioP_s { +- char * str; +- char * next; +- const char ** av; +- int ac; +-} * rpmioP; +- +-/** \ingroup rpmpgp +- */ +-typedef /*@abstract@*/ struct DIGEST_CTX_s * DIGEST_CTX; +- +-/** \ingroup rpmpgp +- */ +-typedef /*@abstract@*/ struct pgpPkt_s * pgpPkt; +- +-/** \ingroup rpmpgp +- */ +-typedef /*@abstract@*/ /*@refcounted@*/ struct pgpDig_s * pgpDig; +- +-/** \ingroup rpmpgp +- */ +-typedef /*@abstract@*/ struct pgpDigParams_s * pgpDigParams; +- +-/** \ingroup rpmpgp +- */ +-typedef rpmuint8_t pgpKeyID_t[8]; +- +-/** \ingroup rpmpgp +- */ +-typedef rpmuint8_t pgpTime_t[4]; +- +-/** \ingroup rpmpgp +- * Bit(s) to control digest and signature verification. +- */ +-typedef enum pgpVSFlags_e { +- RPMVSF_DEFAULT = 0, +- RPMVSF_NOHDRCHK = (1 << 0), +- RPMVSF_NEEDPAYLOAD = (1 << 1), +- /* bit(s) 2-7 unused */ +- RPMVSF_NOSHA1HEADER = (1 << 8), +- RPMVSF_NOMD5HEADER = (1 << 9), /* unimplemented */ +- RPMVSF_NODSAHEADER = (1 << 10), +- RPMVSF_NORSAHEADER = (1 << 11), +- /* bit(s) 12-15 unused */ +- RPMVSF_NOSHA1 = (1 << 16), /* unimplemented */ +- RPMVSF_NOMD5 = (1 << 17), +- RPMVSF_NODSA = (1 << 18), +- RPMVSF_NORSA = (1 << 19) +- /* bit(s) 20-31 unused */ +-} pgpVSFlags; +- +-#define _RPMVSF_NODIGESTS \ +- ( RPMVSF_NOSHA1HEADER | \ +- RPMVSF_NOMD5HEADER | \ +- RPMVSF_NOSHA1 | \ +- RPMVSF_NOMD5 ) +- +-#define _RPMVSF_NOSIGNATURES \ +- ( RPMVSF_NODSAHEADER | \ +- RPMVSF_NORSAHEADER | \ +- RPMVSF_NODSA | \ +- RPMVSF_NORSA ) +- +-#define _RPMVSF_NOHEADER \ +- ( RPMVSF_NOSHA1HEADER | \ +- RPMVSF_NOMD5HEADER | \ +- RPMVSF_NODSAHEADER | \ +- RPMVSF_NORSAHEADER ) +- +-#define _RPMVSF_NOPAYLOAD \ +- ( RPMVSF_NOSHA1 | \ +- RPMVSF_NOMD5 | \ +- RPMVSF_NODSA | \ +- RPMVSF_NORSA ) +- +-/*@-redef@*/ /* LCL: ??? */ +-typedef /*@abstract@*/ const void * fnpyKey; +-/*@=redef@*/ +- +-/** +- * Bit(s) to identify progress callbacks. +- */ +-typedef enum rpmCallbackType_e { +- RPMCALLBACK_UNKNOWN = 0, +- RPMCALLBACK_INST_PROGRESS = (1 << 0), +- RPMCALLBACK_INST_START = (1 << 1), +- RPMCALLBACK_INST_OPEN_FILE = (1 << 2), +- RPMCALLBACK_INST_CLOSE_FILE = (1 << 3), +- RPMCALLBACK_TRANS_PROGRESS = (1 << 4), +- RPMCALLBACK_TRANS_START = (1 << 5), +- RPMCALLBACK_TRANS_STOP = (1 << 6), +- RPMCALLBACK_UNINST_PROGRESS = (1 << 7), +- RPMCALLBACK_UNINST_START = (1 << 8), +- RPMCALLBACK_UNINST_STOP = (1 << 9), +- RPMCALLBACK_REPACKAGE_PROGRESS = (1 << 10), +- RPMCALLBACK_REPACKAGE_START = (1 << 11), +- RPMCALLBACK_REPACKAGE_STOP = (1 << 12), +- RPMCALLBACK_UNPACK_ERROR = (1 << 13), +- RPMCALLBACK_CPIO_ERROR = (1 << 14), +- RPMCALLBACK_SCRIPT_ERROR = (1 << 15) +-} rpmCallbackType; +- +-/** +- */ +-typedef void * rpmCallbackData; +- +-/** \ingroup rpmpgp +- * 9.4. Hash Algorithms +- * +-\verbatim +- ID Algorithm Text Name +- -- --------- ---- ---- +- 1 - MD5 "MD5" +- 2 - SHA-1 "SHA1" +- 3 - RIPE-MD/160 "RIPEMD160" +- 4 - Reserved for double-width SHA (experimental) +- 5 - MD2 "MD2" +- 6 - Reserved for TIGER/192 "TIGER192" +- 7 - Reserved for HAVAL (5 pass, 160-bit) "HAVAL-5-160" +- 100 to 110 - Private/Experimental algorithm. +-\endverbatim +- * +- * Implementations MUST implement SHA-1. Implementations SHOULD +- * implement MD5. +- * @todo Add SHA256. +- */ +-typedef enum pgpHashAlgo_e { +- PGPHASHALGO_ERROR = -1, +- PGPHASHALGO_NONE = 0, +- PGPHASHALGO_MD5 = 1, /*!< MD5 */ +- PGPHASHALGO_SHA1 = 2, /*!< SHA-1 */ +- PGPHASHALGO_RIPEMD160 = 3, /*!< RIPEMD-160 */ +- PGPHASHALGO_MD2 = 5, /*!< MD2 */ +- PGPHASHALGO_TIGER192 = 6, /*!< TIGER-192 */ +- PGPHASHALGO_HAVAL_5_160 = 7, /*!< HAVAL-5-160 */ +- PGPHASHALGO_SHA256 = 8, /*!< SHA-256 */ +- PGPHASHALGO_SHA384 = 9, /*!< SHA-384 */ +- PGPHASHALGO_SHA512 = 10, /*!< SHA-512 */ +- PGPHASHALGO_SHA224 = 11, /*!< SHA-224 */ +- +- PGPHASHALGO_MD4 = 104, /*!< (private) MD4 */ +- PGPHASHALGO_RIPEMD128 = 105, /*!< (private) RIPEMD-128 */ +- PGPHASHALGO_CRC32 = 106, /*!< (private) CRC-32 */ +- PGPHASHALGO_ADLER32 = 107, /*!< (private) ADLER-32 */ +- PGPHASHALGO_CRC64 = 108, /*!< (private) CRC-64 */ +- PGPHASHALGO_JLU32 = 109, /*!< (private) Jenkins lookup3.c */ +- +- PGPHASHALGO_RIPEMD256 = 111, /*!< (private) RIPEMD-256 */ +- PGPHASHALGO_RIPEMD320 = 112, /*!< (private) RIPEMD-320 */ +- PGPHASHALGO_SALSA10 = 113, /*!< (private) SALSA-10 */ +- PGPHASHALGO_SALSA20 = 114, /*!< (private) SALSA-20 */ +- +- PGPHASHALGO_MD6_224 = 128+0,/*!< (private) MD6-224 */ +- PGPHASHALGO_MD6_256 = 128+1,/*!< (private) MD6-256 */ +- PGPHASHALGO_MD6_384 = 128+2,/*!< (private) MD6-384 */ +- PGPHASHALGO_MD6_512 = 128+3,/*!< (private) MD6-512 */ +- +- PGPHASHALGO_CUBEHASH_224 = 136+0,/*!< (private) CUBEHASH-224 */ +- PGPHASHALGO_CUBEHASH_256 = 136+1,/*!< (private) CUBEHASH-256 */ +- PGPHASHALGO_CUBEHASH_384 = 136+2,/*!< (private) CUBEHASH-384 */ +- PGPHASHALGO_CUBEHASH_512 = 136+3,/*!< (private) CUBEHASH-512 */ +- +- PGPHASHALGO_KECCAK_224 = 144+0,/*!< (private) KECCAK-224 */ +- PGPHASHALGO_KECCAK_256 = 144+1,/*!< (private) KECCAK-256 */ +- PGPHASHALGO_KECCAK_384 = 144+2,/*!< (private) KECCAK-384 */ +- PGPHASHALGO_KECCAK_512 = 144+3,/*!< (private) KECCAK-384 */ +- +- PGPHASHALGO_ECHO_224 = 148+0,/*!< (private) ECHO-224 */ +- PGPHASHALGO_ECHO_256 = 148+1,/*!< (private) ECHO-256 */ +- PGPHASHALGO_ECHO_384 = 148+2,/*!< (private) ECHO-384 */ +- PGPHASHALGO_ECHO_512 = 148+3,/*!< (private) ECHO-384 */ +- +- PGPHASHALGO_EDONR_224 = 152+0,/*!< (private) EDON-R-224 */ +- PGPHASHALGO_EDONR_256 = 152+1,/*!< (private) EDON-R-256 */ +- PGPHASHALGO_EDONR_384 = 152+2,/*!< (private) EDON-R-384 */ +- PGPHASHALGO_EDONR_512 = 152+3,/*!< (private) EDON-R-512 */ +- +- PGPHASHALGO_FUGUE_224 = 156+0,/*!< (private) FUGUE-224 */ +- PGPHASHALGO_FUGUE_256 = 156+1,/*!< (private) FUGUE-256 */ +- PGPHASHALGO_FUGUE_384 = 156+2,/*!< (private) FUGUE-384 */ +- PGPHASHALGO_FUGUE_512 = 156+3,/*!< (private) FUGUE-512 */ +- +- PGPHASHALGO_SKEIN_224 = 160+0,/*!< (private) SKEIN-224 */ +- PGPHASHALGO_SKEIN_256 = 160+1,/*!< (private) SKEIN-256 */ +- PGPHASHALGO_SKEIN_384 = 160+2,/*!< (private) SKEIN-384 */ +- PGPHASHALGO_SKEIN_512 = 160+3,/*!< (private) SKEIN-512 */ +- PGPHASHALGO_SKEIN_1024 = 160+4,/*!< (private) SKEIN-1024 */ +- +- PGPHASHALGO_BMW_224 = 168+0,/*!< (private) BMW-224 */ +- PGPHASHALGO_BMW_256 = 168+1,/*!< (private) BMW-256 */ +- PGPHASHALGO_BMW_384 = 168+2,/*!< (private) BMW-384 */ +- PGPHASHALGO_BMW_512 = 168+3,/*!< (private) BMW-512 */ +- +- PGPHASHALGO_SHABAL_224 = 176+0,/*!< (private) SHABAL-224 */ +- PGPHASHALGO_SHABAL_256 = 176+1,/*!< (private) SHABAL-256 */ +- PGPHASHALGO_SHABAL_384 = 176+2,/*!< (private) SHABAL-384 */ +- PGPHASHALGO_SHABAL_512 = 176+3,/*!< (private) SHABAL-512 */ +- +- PGPHASHALGO_SHAVITE3_224 = 180+0,/*!< (private) SHAVITE3-224 */ +- PGPHASHALGO_SHAVITE3_256 = 180+1,/*!< (private) SHAVITE3-256 */ +- PGPHASHALGO_SHAVITE3_384 = 180+2,/*!< (private) SHAVITE3-384 */ +- PGPHASHALGO_SHAVITE3_512 = 180+3,/*!< (private) SHAVITE3-512 */ +- +- PGPHASHALGO_BLAKE_224 = 184+0,/*!< (private) BLAKE-224 */ +- PGPHASHALGO_BLAKE_256 = 184+1,/*!< (private) BLAKE-256 */ +- PGPHASHALGO_BLAKE_384 = 184+2,/*!< (private) BLAKE-384 */ +- PGPHASHALGO_BLAKE_512 = 184+3,/*!< (private) BLAKE-512 */ +- +- PGPHASHALGO_TIB3_224 = 192+0,/*!< (private) TIB3-224 */ +- PGPHASHALGO_TIB3_256 = 192+1,/*!< (private) TIB3-256 */ +- PGPHASHALGO_TIB3_384 = 192+2,/*!< (private) TIB3-384 */ +- PGPHASHALGO_TIB3_512 = 192+3,/*!< (private) TIB3-512 */ +- +- PGPHASHALGO_SIMD_224 = 200+0,/*!< (private) SIMD-224 */ +- PGPHASHALGO_SIMD_256 = 200+1,/*!< (private) SIMD-256 */ +- PGPHASHALGO_SIMD_384 = 200+2,/*!< (private) SIMD-384 */ +- PGPHASHALGO_SIMD_512 = 200+3,/*!< (private) SIMD-512 */ +- +- PGPHASHALGO_ARIRANG_224 = 208+0,/*!< (private) ARIRANG-224 */ +- PGPHASHALGO_ARIRANG_256 = 208+1,/*!< (private) ARIRANG-256 */ +- PGPHASHALGO_ARIRANG_384 = 208+2,/*!< (private) ARIRANG-384 */ +- PGPHASHALGO_ARIRANG_512 = 208+3,/*!< (private) ARIRANG-512 */ +- +- PGPHASHALGO_LANE_224 = 212+0,/*!< (private) LANE-224 */ +- PGPHASHALGO_LANE_256 = 212+1,/*!< (private) LANE-256 */ +- PGPHASHALGO_LANE_384 = 212+2,/*!< (private) LANE-384 */ +- PGPHASHALGO_LANE_512 = 212+3,/*!< (private) LANE-512 */ +- +- PGPHASHALGO_LUFFA_224 = 216+0,/*!< (private) LUFFA-224 */ +- PGPHASHALGO_LUFFA_256 = 216+1,/*!< (private) LUFFA-256 */ +- PGPHASHALGO_LUFFA_384 = 216+2,/*!< (private) LUFFA-384 */ +- PGPHASHALGO_LUFFA_512 = 216+3,/*!< (private) LUFFA-512 */ +- +- PGPHASHALGO_CHI_224 = 224+0,/*!< (private) CHI-224 */ +- PGPHASHALGO_CHI_256 = 224+1,/*!< (private) CHI-256 */ +- PGPHASHALGO_CHI_384 = 224+2,/*!< (private) CHI-384 */ +- PGPHASHALGO_CHI_512 = 224+3,/*!< (private) CHI-512 */ +- +- PGPHASHALGO_JH_224 = 232+0,/*!< (private) JH-224 */ +- PGPHASHALGO_JH_256 = 232+1,/*!< (private) JH-256 */ +- PGPHASHALGO_JH_384 = 232+2,/*!< (private) JH-384 */ +- PGPHASHALGO_JH_512 = 232+3,/*!< (private) JH-512 */ +- +- PGPHASHALGO_GROESTL_224 = 240+0,/*!< (private) GROESTL-224 */ +- PGPHASHALGO_GROESTL_256 = 240+1,/*!< (private) GROESTL-256 */ +- PGPHASHALGO_GROESTL_384 = 240+2,/*!< (private) GROESTL-384 */ +- PGPHASHALGO_GROESTL_512 = 240+3,/*!< (private) GROESTL-512 */ +- +- PGPHASHALGO_HAMSI_224 = 248+0,/*!< (private) HAMSI-224 */ +- PGPHASHALGO_HAMSI_256 = 248+1,/*!< (private) HAMSI-256 */ +- PGPHASHALGO_HAMSI_384 = 248+2,/*!< (private) HAMSI-384 */ +- PGPHASHALGO_HAMSI_512 = 248+3,/*!< (private) HAMSI-512 */ +- +-} pgpHashAlgo; +- +-/** \ingroup rpmpgp +- * Bit(s) to control digest operation. +- */ +-typedef enum rpmDigestFlags_e { +- RPMDIGEST_NONE = 0, +-} rpmDigestFlags; +- +-#if defined(_RPMIOB_INTERNAL) +-/** \ingroup rpmio +- */ +-struct rpmiob_s{ +- struct rpmioItem_s _item; /*!< usage mutex and pool identifier. */ +- rpmuint8_t * b; /*!< data octects. */ +- size_t blen; /*!< no. of octets used. */ +- size_t allocated; /*!< no. of octets allocated. */ +-#if defined(__LCLINT__) +-/*@refs@*/ +- int nrefs; /*!< (unused) keep splint happy */ +-#endif +-}; +-#endif +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/** \ingroup rpmpgp +- * Return digest algorithm identifier. +- * @param ctx digest context +- * @return digest hash algorithm identifier +- */ +-pgpHashAlgo rpmDigestAlgo(DIGEST_CTX ctx) +- /*@*/; +- +-/** \ingroup rpmpgp +- * Return digest flags. +- * @param ctx digest context +- * @return digest flags +- */ +-rpmDigestFlags rpmDigestF(DIGEST_CTX ctx) +- /*@*/; +- +-/** \ingroup rpmpgp +- * Return digest name. +- * @param ctx digest context +- * @return digest name +- */ +-/*@observer@*/ +-const char * rpmDigestName(DIGEST_CTX ctx) +- /*@*/; +- +-/** \ingroup rpmpgp +- * Return digest ASN1 oid string. +- * Values from PKCS#1 v2.1 (aka RFC-3447). +- * @param ctx digest context +- * @return digest ASN1 oid string +- */ +-/*@observer@*/ /*@null@*/ +-const char * rpmDigestASN1(DIGEST_CTX ctx) +- /*@*/; +- +-/** \ingroup rpmpgp +- * Duplicate a digest context. +- * @param octx existing digest context +- * @return duplicated digest context +- */ +-/*@only@*/ +-DIGEST_CTX rpmDigestDup(DIGEST_CTX octx) +- /*@*/; +- +-/** \ingroup rpmpgp +- * Initialize digest. +- * Set bit count to 0 and buffer to mysterious initialization constants. +- * @param hashalgo type of digest +- * @param flags bit(s) to control digest operation +- * @return digest context +- */ +-/*@only@*/ /*@null@*/ +-DIGEST_CTX rpmDigestInit(pgpHashAlgo hashalgo, rpmDigestFlags flags) +- /*@*/; +- +-/** \ingroup rpmpgp +- * Update context with next plain text buffer. +- * @param ctx digest context +- * @param data next data buffer +- * @param len no. bytes of data +- * @return 0 on success +- */ +-int rpmDigestUpdate(/*@null@*/ DIGEST_CTX ctx, const void * data, size_t len) +- /*@modifies ctx @*/; +- +-/** \ingroup rpmpgp +- * Return digest and destroy context. +- * +- * @param ctx digest context +- * @retval *datap digest +- * @retval *lenp no. bytes of digest +- * @param asAscii return digest as ascii string? +- * @return 0 on success +- */ +-int rpmDigestFinal(/*@only@*/ /*@null@*/ DIGEST_CTX ctx, +- /*@null@*/ /*@out@*/ void * datap, +- /*@null@*/ /*@out@*/ size_t * lenp, int asAscii) +- /*@modifies *datap, *lenp @*/; +- +-/** \ingroup rpmpgp +- * +- * Compute key material and add to digest context. +- * @param ctx digest context +- * @param key HMAC key (NULL does digest instead) +- * @param keylen HMAC key length(bytes) (0 uses strlen(key)) +- * @return 0 on success +- */ +-int rpmHmacInit(DIGEST_CTX ctx, const void * key, size_t keylen) +- /*@*/; +- +-/** \ingroup rpmio +- */ +-typedef void * (*rpmCallbackFunction) +- (/*@null@*/ const void * h, +- const rpmCallbackType what, +- const rpmuint64_t amount, +- const rpmuint64_t total, +- /*@null@*/ fnpyKey key, +- /*@null@*/ rpmCallbackData data) +- /*@globals internalState@*/ +- /*@modifies internalState@*/; +- +-#if !defined(SWIG) +-/** \ingroup rpmio +- * Wrapper to free(3), hides const compilation noise, permit NULL, return NULL. +- * @param p memory to free +- * @return NULL always +- */ +-#if defined(WITH_DMALLOC) +-#define _free(p) ((p) != NULL ? free((void *)(p)) : (void)0, NULL) +-#else +-/*@unused@*/ static inline /*@null@*/ +-void * _free(/*@only@*/ /*@null@*/ /*@out@*/ const void * p) +- /*@modifies p @*/ +-{ +- if (p != NULL) free((void *)p); +- return NULL; +-} +-#endif +-#endif +- +-/*@unused@*/ static inline int xislower(int c) /*@*/ { +- return (c >= (int)'a' && c <= (int)'z'); +-} +-/*@unused@*/ static inline int xisupper(int c) /*@*/ { +- return (c >= (int)'A' && c <= (int)'Z'); +-} +-/*@unused@*/ static inline int xisalpha(int c) /*@*/ { +- return (xislower(c) || xisupper(c)); +-} +-/*@unused@*/ static inline int xisdigit(int c) /*@*/ { +- return (c >= (int)'0' && c <= (int)'9'); +-} +-/*@unused@*/ static inline int xisalnum(int c) /*@*/ { +- return (xisalpha(c) || xisdigit(c)); +-} +-/*@unused@*/ static inline int xisblank(int c) /*@*/ { +- return (c == (int)' ' || c == (int)'\t'); +-} +-/*@unused@*/ static inline int xisspace(int c) /*@*/ { +- return (xisblank(c) || c == (int)'\n' || c == (int)'\r' || c == (int)'\f' || c == (int)'\v'); +-} +-/*@unused@*/ static inline int xiscntrl(int c) /*@*/ { +- return (c < (int)' '); +-} +-/*@unused@*/ static inline int xisascii(int c) /*@*/ { +- return ((c & 0x80) != 0x80); +-} +-/*@unused@*/ static inline int xisprint(int c) /*@*/ { +- return (c >= (int)' ' && xisascii(c)); +-} +-/*@unused@*/ static inline int xisgraph(int c) /*@*/ { +- return (c > (int)' ' && xisascii(c)); +-} +-/*@unused@*/ static inline int xispunct(int c) /*@*/ { +- return (xisgraph(c) && !xisalnum(c)); +-} +- +-/*@unused@*/ static inline int xtolower(int c) /*@*/ { +- return ((xisupper(c)) ? (c | ('a' - 'A')) : c); +-} +-/*@unused@*/ static inline int xtoupper(int c) /*@*/ { +- return ((xislower(c)) ? (c & ~('a' - 'A')) : c); +-} +- +-/** \ingroup rpmio +- * Locale insensitive strcasecmp(3). +- */ +-int xstrcasecmp(const char * s1, const char * s2) /*@*/; +- +-/** \ingroup rpmio +- * Locale insensitive strncasecmp(3). +- */ +-int xstrncasecmp(const char *s1, const char * s2, size_t n) /*@*/; +- +-/** \ingroup rpmio +- * Force encoding of string. +- */ +-/*@only@*/ /*@null@*/ +-const char * xstrtolocale(/*@only@*/ const char *str) +- /*@modifies *str @*/; +- +-/** +- * Unreference a I/O buffer instance. +- * @param iob hash table +- * @return NULL if free'd +- */ +-/*@unused@*/ /*@null@*/ +-rpmiob rpmiobUnlink (/*@killref@*/ /*@null@*/ rpmiob iob) +- /*@globals fileSystem @*/ +- /*@modifies iob, fileSystem @*/; +-#define rpmiobUnlink(_iob) \ +- ((rpmiob)rpmioUnlinkPoolItem((rpmioItem)(_iob), __FUNCTION__, __FILE__, __LINE__)) +- +-/** +- * Reference a I/O buffer instance. +- * @param iob I/O buffer +- * @return new I/O buffer reference +- */ +-/*@unused@*/ /*@newref@*/ /*@null@*/ +-rpmiob rpmiobLink (/*@null@*/ rpmiob iob) +- /*@globals fileSystem @*/ +- /*@modifies iob, fileSystem @*/; +-#define rpmiobLink(_iob) \ +- ((rpmiob)rpmioLinkPoolItem((rpmioItem)(_iob), __FUNCTION__, __FILE__, __LINE__)) +- +-/** +- * Destroy a I/O buffer instance. +- * @param iob I/O buffer +- * @return NULL on last dereference +- */ +-/*@null@*/ +-rpmiob rpmiobFree( /*@killref@*/ rpmiob iob) +- /*@globals fileSystem @*/ +- /*@modifies iob, fileSystem @*/; +-#define rpmiobFree(_iob) \ +- ((rpmiob)rpmioFreePoolItem((rpmioItem)(_iob), __FUNCTION__, __FILE__, __LINE__)) +- +-/** +- * Create an I/O buffer. +- * @param len no. of octets to allocate +- * @return new I/O buffer +- */ +-/*@newref@*/ /*@null@*/ +-rpmiob rpmiobNew(size_t len) +- /*@globals fileSystem @*/ +- /*@modifies fileSystem @*/; +- +-/** +- * Empty an I/O buffer. +- * @param iob I/O buffer +- * @return I/O buffer +- */ +-rpmiob rpmiobEmpty(/*@returned@*/ rpmiob iob) +- /*@modifies iob @*/; +- +-/** +- * Trim trailing white space. +- * @param iob I/O buffer +- * @return I/O buffer +- */ +-rpmiob rpmiobRTrim(/*@returned@*/ rpmiob iob) +- /*@modifies iob @*/; +- +-/** +- * Append string to I/O buffer. +- * @param iob I/O buffer +- * @param s string +- * @param nl append NL? +- * @return I/O buffer +- */ +-rpmiob rpmiobAppend(/*@returned@*/ rpmiob iob, const char * s, size_t nl) +- /*@modifies iob @*/; +- +-/** +- * Return I/O buffer. +- * @param iob I/O buffer +- * @return I/O buffer (as octets) +- */ +-rpmuint8_t * rpmiobBuf(rpmiob iob) +- /*@*/; +- +-/** +- * Return I/O buffer (as string). +- * @param iob I/O buffer +- * @return I/O buffer (as string) +- */ +-char * rpmiobStr(rpmiob iob) +- /*@*/; +- +-/** +- * Return I/O buffer len. +- * @param iob I/O buffer +- * @return I/O buffer length +- */ +-size_t rpmiobLen(rpmiob iob) +- /*@*/; +- +-#if defined(_RPMIOB_INTERNAL) +-/** +- * Read an entire file into a buffer. +- * @param fn file name to read +- * @retval *iobp I/O buffer +- * @return 0 on success +- */ +-int rpmiobSlurp(const char * fn, rpmiob * iobp) +- /*@globals h_errno, fileSystem, internalState @*/ +- /*@modifies *iobp, fileSystem, internalState @*/; +-#endif +- +-/** +- * Destroy a rpmioP object. +- * @param P parser state +- * @return NULL +- */ +-/*@null@*/ +-rpmioP rpmioPFree(/*@only@*/ /*@null@*/ rpmioP P) +- /*@modifies P @*/; +- +-/** +- * Parse next command out of a string incrementally. +- * @param *Pptr parser state +- * @param str string to parse +- * @return RPMRC_OK on success +- */ +-rpmRC rpmioParse(rpmioP *Pptr, const char * str) +- /*@modifies *Pptr @*/; +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif /* _H_RPMIOTYPES_ */ +diff --git a/src/debugedit/rpmsw.h b/src/debugedit/rpmsw.h +deleted file mode 100644 +index 9023d0b..0000000 +--- a/src/debugedit/rpmsw.h ++++ /dev/null +@@ -1,157 +0,0 @@ +-#ifndef H_RPMSW +-#define H_RPMSW +- +-/** \ingroup rpmio +- * \file rpmio/rpmsw.h +- */ +- +-/** \ingroup rpmio +- */ +-typedef unsigned long int rpmtime_t; +- +-/** \ingroup rpmio +- */ +-typedef struct rpmsw_s * rpmsw; +- +-/** \ingroup rpmio +- */ +-typedef struct rpmop_s * rpmop; +- +-/** \ingroup rpmio +- */ +-struct rpmsw_s { +- union { +- struct timeval tv; +- unsigned long long int ticks; +- unsigned long int tocks[2]; +- } u; +-}; +- +-/** \ingroup rpmio +- * Cumulative statistics for an operation. +- */ +-struct rpmop_s { +- struct rpmsw_s begin; /*!< Starting time stamp. */ +- int count; /*!< Number of operations. */ +- unsigned long long bytes; /*!< Number of bytes transferred. */ +- rpmtime_t usecs; /*!< Number of ticks. */ +-}; +- +-/*@unchecked@*/ +-extern int _rpmsw_stats; +- +-/** \ingroup rpmio +- * Indices for timestamps. +- */ +-typedef enum rpmswOpX_e { +- RPMSW_OP_TOTAL = 0, +- RPMSW_OP_CHECK = 1, +- RPMSW_OP_ORDER = 2, +- RPMSW_OP_FINGERPRINT = 3, +- RPMSW_OP_REPACKAGE = 4, +- RPMSW_OP_INSTALL = 5, +- RPMSW_OP_ERASE = 6, +- RPMSW_OP_SCRIPTLETS = 7, +- RPMSW_OP_COMPRESS = 8, +- RPMSW_OP_UNCOMPRESS = 9, +- RPMSW_OP_DIGEST = 10, +- RPMSW_OP_SIGNATURE = 11, +- RPMSW_OP_DBADD = 12, +- RPMSW_OP_DBREMOVE = 13, +- RPMSW_OP_DBGET = 14, +- RPMSW_OP_DBPUT = 15, +- RPMSW_OP_DBDEL = 16, +- RPMSW_OP_READHDR = 17, +- RPMSW_OP_HDRLOAD = 18, +- RPMSW_OP_HDRGET = 19, +- RPMSW_OP_DEBUG = 20, +- RPMSW_OP_MAX = 20 +-} rpmswOpX; +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/** Return benchmark time stamp. +- * @param *sw time stamp +- * @return 0 on success +- */ +-/*@-exportlocal@*/ +-/*@null@*/ +-rpmsw rpmswNow(/*@returned@*/ rpmsw sw) +- /*@globals internalState @*/ +- /*@modifies sw, internalState @*/; +-/*@=exportlocal@*/ +- +-/** Return benchmark time stamp difference. +- * @param *end end time stamp +- * @param *begin begin time stamp +- * @return difference in micro-seconds +- */ +-/*@-exportlocal@*/ +-rpmtime_t rpmswDiff(/*@null@*/ rpmsw end, /*@null@*/ rpmsw begin) +- /*@*/; +-/*@=exportlocal@*/ +- +-/** Return benchmark time stamp overhead. +- * @return overhead in micro-seconds +- */ +-/*@-exportlocal@*/ +-rpmtime_t rpmswInit(void) +- /*@globals internalState @*/ +- /*@modifies internalState @*/; +-/*@=exportlocal@*/ +- +-/** \ingroup rpmio +- * Enter timed operation. +- * @param op operation statistics +- * @param rc -1 clears usec counter +- * @return 0 always +- */ +-int rpmswEnter(/*@null@*/ rpmop op, ssize_t rc) +- /*@globals internalState @*/ +- /*@modifies *op, internalState @*/; +- +-/** \ingroup rpmio +- * Exit timed operation. +- * @param op operation statistics +- * @param rc per-operation data (e.g. bytes transferred) +- * @return cumulative usecs for operation +- */ +-rpmtime_t rpmswExit(/*@null@*/ rpmop op, ssize_t rc) +- /*@globals internalState @*/ +- /*@modifies op, internalState @*/; +- +-/** \ingroup rpmio +- * Sum statistic counters. +- * @param to result statistics +- * @param from operation statistics +- * @return cumulative usecs for operation +- */ +-rpmtime_t rpmswAdd(/*@null@*/ rpmop to, /*@null@*/ rpmop from) +- /*@modifies to @*/; +- +-/** \ingroup rpmio +- * Subtract statistic counters. +- * @param to result statistics +- * @param from operation statistics +- * @return cumulative usecs for operation +- */ +-rpmtime_t rpmswSub(rpmop to, rpmop from) +- /*@modifies to @*/; +- +-/** \ingroup rpmio +- * Print operation statistics. +- * @param name operation name +- * @param op operation statistics +- * @param fp file handle (NULL uses stderr) +- */ +-void rpmswPrint(const char * name, /*@null@*/ rpmop op, /*@null@*/ FILE * fp) +- /*@globals fileSystem @*/ +- /*@modifies fp, fileSystem @*/; +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif /* H_RPMSW */ +diff --git a/src/debugedit/rpmtag.h b/src/debugedit/rpmtag.h +deleted file mode 100644 +index 36e24c8..0000000 +--- a/src/debugedit/rpmtag.h ++++ /dev/null +@@ -1,1243 +0,0 @@ +-#ifndef H_RPMTAG +-#define H_RPMTAG +- +-/** \ingroup header +- * \file rpmdb/rpmtag.h +- */ +- +-#include "rpmiotypes.h" +-#include "rpmsw.h" +- +-#ifdef __cplusplus +-extern "C" { +-#endif +- +-/** \ingroup header +- */ +-typedef const char * errmsg_t; +- +-/** \ingroup header +- */ +-typedef /*@abstract@*/ /*@refcounted@*/ struct headerToken_s * Header; +- +-/** \ingroup header +- * The basic types of data in tags from headers. +- */ +-enum rpmTagType_e { +- /* RPM_NULL_TYPE = 0 - never been used. */ +- /* RPM_CHAR_TYPE = 1 - never been used, same as RPM_UINT8_TYPE. */ +- RPM_UINT8_TYPE = 2, +- RPM_UINT16_TYPE = 3, +- RPM_UINT32_TYPE = 4, +- RPM_UINT64_TYPE = 5, +- RPM_STRING_TYPE = 6, +- RPM_BIN_TYPE = 7, +- RPM_STRING_ARRAY_TYPE = 8, +- RPM_I18NSTRING_TYPE = 9 +- /* RPM_ASN1_TYPE = 10 - never been used. */ +- /* RPM_OPENPGP_TYPE= 11 - never been used. */ +-}; +-#define RPM_MIN_TYPE 2 +-#define RPM_MAX_TYPE 9 +-#define RPM_MASK_TYPE 0x0000ffff +- +-/** \ingroup header +- */ +-typedef enum rpmTagType_e rpmTagType; /*!< tag data type. */ +- +-/** \ingroup header +- */ +-typedef union rpmDataType_u rpmTagData; /*!< tag data. */ +- +-/** \ingroup header +- */ +-typedef rpmuint32_t rpmTagCount; /*!< tag data element count. */ +- +-/** \ingroup header +- */ +-typedef struct _HE_s * HE_t; /*!< tag container. */ +- +-/** \ingroup header +- */ +-/*@-typeuse -fielduse@*/ +-#if !defined(SWIG) +-union rpmDataType_u { +-/*@null@*/ +- void * ptr; +- rpmuint8_t * ui8p; /*!< RPM_UINT8_TYPE | RPM_CHAR_TYPE */ +- rpmuint16_t * ui16p; /*!< RPM_UINT16_TYPE */ +- rpmuint32_t * ui32p; /*!< RPM_UINT32_TYPE */ +- rpmuint64_t * ui64p; /*!< RPM_UINT64_TYPE */ +-/*@relnull@*/ +- const char * str; /*!< RPM_STRING_TYPE */ +- unsigned char * blob; /*!< RPM_BIN_TYPE */ +- const char ** argv; /*!< RPM_STRING_ARRAY_TYPE */ +- HE_t he; +-}; +-#endif +-/*@=typeuse =fielduse@*/ +- +-/*@=typeuse =fielduse@*/ +-/** \ingroup header +- */ +-/*@-enummemuse -typeuse @*/ +-typedef enum rpmSubTagType_e { +- RPM_REGION_TYPE = -10, +- RPM_BIN_ARRAY_TYPE = -11, +- RPM_XREF_TYPE = -12 +-} rpmSubTagType; +-/*@=enummemuse =typeuse @*/ +- +-/** \ingroup header +- * Identify how to return the header data type. +- */ +-/*@-enummemuse -typeuse @*/ +-typedef enum rpmTagReturnType_e { +- RPM_ANY_RETURN_TYPE = 0, +- RPM_SCALAR_RETURN_TYPE = 0x00010000, +- RPM_ARRAY_RETURN_TYPE = 0x00020000, +- RPM_MAPPING_RETURN_TYPE = 0x00040000, +- /* 0x00080000 */ +- RPM_PROBE_RETURN_TYPE = 0x00100000, +- RPM_TREE_RETURN_TYPE = 0x00200000, +- RPM_OPENPGP_RETURN_TYPE = 0x00400000, +- RPM_X509_RETURN_TYPE = 0x00800000, +- RPM_ASN1_RETURN_TYPE = 0x01000000, +- RPM_OPAQUE_RETURN_TYPE = 0x10000000, +- RPM_MASK_RETURN_TYPE = 0xffff0000 +-} rpmTagReturnType; +-/*@=enummemuse =typeuse @*/ +- +-/** +- * Header private tags. +- * @note General use tags should start at 1000 (RPM's tag space starts there). +- */ +-#define HEADER_IMAGE 61 +-#define HEADER_SIGNATURES 62 +-#define HEADER_IMMUTABLE 63 +-#define HEADER_REGIONS 64 +-#define HEADER_I18NTABLE 100 +-#define HEADER_SIGBASE 256 +-#define HEADER_TAGBASE 1000 +- +-/** \ingroup header +- */ +-typedef /*@abstract@*/ struct headerIterator_s * HeaderIterator; +- +-/** \ingroup header +- */ +-typedef /*@abstract@*/ struct headerTagIndices_s * headerTagIndices; +- +-/** \ingroup header +- */ +-typedef /*@abstract@*/ const struct headerSprintfExtension_s * headerSprintfExtension; +- +-/** +- * Pseudo-tags used by the rpmdb and rpmgi iterator API's. +- */ +-#define RPMDBI_PACKAGES 0 /* Installed package headers. */ +-#define RPMDBI_DEPENDS 1 /* Dependency resolution cache. */ +- /* (obsolete) RPMDBI_LABEL was 2 */ +-#define RPMDBI_ADDED 3 /* Added package headers. */ +-#define RPMDBI_REMOVED 4 /* Removed package headers. */ +-#define RPMDBI_AVAILABLE 5 /* Available package headers. */ +-#define RPMDBI_HDLIST 6 /* (rpmgi) Header list. */ +-#define RPMDBI_ARGLIST 7 /* (rpmgi) Argument list. */ +-#define RPMDBI_FTSWALK 8 /* (rpmgi) File tree walk. */ +-#define RPMDBI_SEQNO 9 /* Sequence numbers. */ +-#define RPMDBI_BTREE 10 /* (development) Generic DB_BTREE. */ +-#define RPMDBI_HASH 11 /* (development) Generic DB_HASH. */ +-#define RPMDBI_QUEUE 12 /* (development) Generic DB_QUEUE. */ +-#define RPMDBI_RECNO 13 /* (development) Generic DB_RECNO. */ +-#define RPMDBI_REPACKAGES 14 /* Re-packaged package paths. */ +-#define RPMDBI_REPOSITORY 15 /* Repository URI's. */ +- +-/** \ingroup header +- * Tags identify data in package headers. +- * @note tags should not have value 0! +- */ +-enum rpmTag_e { +- +- RPMTAG_HEADERIMAGE = HEADER_IMAGE, /*!< internal Current image. */ +- RPMTAG_HEADERSIGNATURES = HEADER_SIGNATURES, /*!< internal Signatures. */ +- RPMTAG_HEADERIMMUTABLE = HEADER_IMMUTABLE, /*!< x Original image. */ +-/*@-enummemuse@*/ +- RPMTAG_HEADERREGIONS = HEADER_REGIONS, /*!< internal Regions. */ +- +- RPMTAG_HEADERI18NTABLE = HEADER_I18NTABLE, /*!< s[] I18N string locales. */ +-/*@=enummemuse@*/ +- +-/* Retrofit (and uniqify) signature tags for use by tagName() and rpmQuery. */ +-/* the md5 sum was broken *twice* on big endian machines */ +-/* XXX 2nd underscore prevents tagTable generation */ +- RPMTAG_SIG_BASE = HEADER_SIGBASE, +- RPMTAG_SIGSIZE = RPMTAG_SIG_BASE+1, /* i */ +- RPMTAG_SIGLEMD5_1 = RPMTAG_SIG_BASE+2, /* internal - obsolete */ +- RPMTAG_SIGPGP = RPMTAG_SIG_BASE+3, /* x */ +- RPMTAG_SIGLEMD5_2 = RPMTAG_SIG_BASE+4, /* x internal - obsolete */ +- RPMTAG_SIGMD5 = RPMTAG_SIG_BASE+5, /* x */ +-#define RPMTAG_PKGID RPMTAG_SIGMD5 /* x */ +- RPMTAG_SIGGPG = RPMTAG_SIG_BASE+6, /* x */ +- RPMTAG_SIGPGP5 = RPMTAG_SIG_BASE+7, /* internal - obsolete */ +- +- RPMTAG_BADSHA1_1 = RPMTAG_SIG_BASE+8, /* internal - obsolete */ +- RPMTAG_BADSHA1_2 = RPMTAG_SIG_BASE+9, /* internal - obsolete */ +- RPMTAG_PUBKEYS = RPMTAG_SIG_BASE+10, /* s[] */ +- RPMTAG_DSAHEADER = RPMTAG_SIG_BASE+11, /* x */ +- RPMTAG_RSAHEADER = RPMTAG_SIG_BASE+12, /* x */ +- RPMTAG_SHA1HEADER = RPMTAG_SIG_BASE+13, /* s */ +-#define RPMTAG_HDRID RPMTAG_SHA1HEADER /* s */ +- +- RPMTAG_NAME = 1000, /* s */ +-#define RPMTAG_N RPMTAG_NAME /* s */ +- RPMTAG_VERSION = 1001, /* s */ +-#define RPMTAG_V RPMTAG_VERSION /* s */ +- RPMTAG_RELEASE = 1002, /* s */ +-#define RPMTAG_R RPMTAG_RELEASE /* s */ +- RPMTAG_EPOCH = 1003, /* i */ +-#define RPMTAG_E RPMTAG_EPOCH /* i */ +- RPMTAG_SUMMARY = 1004, /* s{} */ +- RPMTAG_DESCRIPTION = 1005, /* s{} */ +- RPMTAG_BUILDTIME = 1006, /* i */ +- RPMTAG_BUILDHOST = 1007, /* s */ +- RPMTAG_INSTALLTIME = 1008, /* i[] */ +- RPMTAG_SIZE = 1009, /* i */ +- RPMTAG_DISTRIBUTION = 1010, /* s */ +- RPMTAG_VENDOR = 1011, /* s */ +- RPMTAG_GIF = 1012, /* x */ +- RPMTAG_XPM = 1013, /* x */ +- RPMTAG_LICENSE = 1014, /* s */ +- RPMTAG_PACKAGER = 1015, /* s */ +- RPMTAG_GROUP = 1016, /* s{} */ +-/*@-enummemuse@*/ +- RPMTAG_CHANGELOG = 1017, /* s[] internal */ +-/*@=enummemuse@*/ +- RPMTAG_SOURCE = 1018, /* s[] */ +- RPMTAG_PATCH = 1019, /* s[] */ +- RPMTAG_URL = 1020, /* s */ +- RPMTAG_OS = 1021, /* s legacy used int */ +- RPMTAG_ARCH = 1022, /* s legacy used int */ +- RPMTAG_PREIN = 1023, /* s */ +- RPMTAG_POSTIN = 1024, /* s */ +- RPMTAG_PREUN = 1025, /* s */ +- RPMTAG_POSTUN = 1026, /* s */ +- RPMTAG_OLDFILENAMES = 1027, /* s[] obsolete */ +- RPMTAG_FILESIZES = 1028, /* i[] */ +- RPMTAG_FILESTATES = 1029, /* c[] */ +- RPMTAG_FILEMODES = 1030, /* h[] */ +- RPMTAG_FILEUIDS = 1031, /* i[] internal */ +- RPMTAG_FILEGIDS = 1032, /* i[] internal */ +- RPMTAG_FILERDEVS = 1033, /* h[] */ +- RPMTAG_FILEMTIMES = 1034, /* i[] */ +- RPMTAG_FILEDIGESTS = 1035, /* s[] */ +-#define RPMTAG_FILEMD5S RPMTAG_FILEDIGESTS /* s[] */ +- RPMTAG_FILELINKTOS = 1036, /* s[] */ +- RPMTAG_FILEFLAGS = 1037, /* i[] */ +-/*@-enummemuse@*/ +- RPMTAG_ROOT = 1038, /* internal - obsolete */ +-/*@=enummemuse@*/ +- RPMTAG_FILEUSERNAME = 1039, /* s[] */ +- RPMTAG_FILEGROUPNAME = 1040, /* s[] */ +-/*@-enummemuse@*/ +- RPMTAG_EXCLUDE = 1041, /* internal - obsolete */ +- RPMTAG_EXCLUSIVE = 1042, /* internal - obsolete */ +-/*@=enummemuse@*/ +- RPMTAG_ICON = 1043, /* x */ +- RPMTAG_SOURCERPM = 1044, /* s */ +- RPMTAG_FILEVERIFYFLAGS = 1045, /* i[] */ +- RPMTAG_ARCHIVESIZE = 1046, /* i */ +- RPMTAG_PROVIDENAME = 1047, /* s[] */ +-#define RPMTAG_PROVIDES RPMTAG_PROVIDENAME /* s[] */ +-#define RPMTAG_P RPMTAG_PROVIDENAME /* s[] */ +- RPMTAG_REQUIREFLAGS = 1048, /* i[] */ +- RPMTAG_REQUIRENAME = 1049, /* s[] */ +-#define RPMTAG_REQUIRES RPMTAG_REQUIRENAME /* s[] */ +- RPMTAG_REQUIREVERSION = 1050, /* s[] */ +- RPMTAG_NOSOURCE = 1051, /* i internal */ +- RPMTAG_NOPATCH = 1052, /* i internal */ +- RPMTAG_CONFLICTFLAGS = 1053, /* i[] */ +- RPMTAG_CONFLICTNAME = 1054, /* s[] */ +-#define RPMTAG_CONFLICTS RPMTAG_CONFLICTNAME /* s[] */ +-#define RPMTAG_C RPMTAG_CONFLICTNAME /* s[] */ +- RPMTAG_CONFLICTVERSION = 1055, /* s[] */ +- RPMTAG_DEFAULTPREFIX = 1056, /* s internal - deprecated */ +- RPMTAG_BUILDROOT = 1057, /* s internal */ +- RPMTAG_INSTALLPREFIX = 1058, /* s internal - deprecated */ +- RPMTAG_EXCLUDEARCH = 1059, /* s[] */ +- RPMTAG_EXCLUDEOS = 1060, /* s[] */ +- RPMTAG_EXCLUSIVEARCH = 1061, /* s[] */ +- RPMTAG_EXCLUSIVEOS = 1062, /* s[] */ +- RPMTAG_AUTOREQPROV = 1063, /* s internal */ +- RPMTAG_RPMVERSION = 1064, /* s */ +- RPMTAG_TRIGGERSCRIPTS = 1065, /* s[] */ +- RPMTAG_TRIGGERNAME = 1066, /* s[] */ +- RPMTAG_TRIGGERVERSION = 1067, /* s[] */ +- RPMTAG_TRIGGERFLAGS = 1068, /* i[] */ +- RPMTAG_TRIGGERINDEX = 1069, /* i[] */ +- RPMTAG_VERIFYSCRIPT = 1079, /* s */ +- RPMTAG_CHANGELOGTIME = 1080, /* i[] */ +- RPMTAG_CHANGELOGNAME = 1081, /* s[] */ +- RPMTAG_CHANGELOGTEXT = 1082, /* s[] */ +-/*@-enummemuse@*/ +- RPMTAG_BROKENMD5 = 1083, /* internal - obsolete */ +-/*@=enummemuse@*/ +- RPMTAG_PREREQ = 1084, /* internal */ +- RPMTAG_PREINPROG = 1085, /* s */ +- RPMTAG_POSTINPROG = 1086, /* s */ +- RPMTAG_PREUNPROG = 1087, /* s */ +- RPMTAG_POSTUNPROG = 1088, /* s */ +- RPMTAG_BUILDARCHS = 1089, /* s[] */ +- RPMTAG_OBSOLETENAME = 1090, /* s[] */ +-#define RPMTAG_OBSOLETES RPMTAG_OBSOLETENAME /* s[] */ +-#define RPMTAG_O RPMTAG_OBSOLETENAME /* s[] */ +- RPMTAG_VERIFYSCRIPTPROG = 1091, /* s */ +- RPMTAG_TRIGGERSCRIPTPROG = 1092, /* s[] */ +- RPMTAG_DOCDIR = 1093, /* internal */ +- RPMTAG_COOKIE = 1094, /* s */ +- RPMTAG_FILEDEVICES = 1095, /* i[] */ +- RPMTAG_FILEINODES = 1096, /* i[] */ +- RPMTAG_FILELANGS = 1097, /* s[] */ +- RPMTAG_PREFIXES = 1098, /* s[] */ +- RPMTAG_INSTPREFIXES = 1099, /* s[] */ +- RPMTAG_TRIGGERIN = 1100, /* internal */ +- RPMTAG_TRIGGERUN = 1101, /* internal */ +- RPMTAG_TRIGGERPOSTUN = 1102, /* internal */ +- RPMTAG_AUTOREQ = 1103, /* internal */ +- RPMTAG_AUTOPROV = 1104, /* internal */ +-/*@-enummemuse@*/ +- RPMTAG_CAPABILITY = 1105, /* i legacy - obsolete */ +-/*@=enummemuse@*/ +- RPMTAG_SOURCEPACKAGE = 1106, /* i legacy - obsolete */ +-/*@-enummemuse@*/ +- RPMTAG_OLDORIGFILENAMES = 1107, /* internal - obsolete */ +-/*@=enummemuse@*/ +- RPMTAG_BUILDPREREQ = 1108, /* internal */ +- RPMTAG_BUILDREQUIRES = 1109, /* internal */ +- RPMTAG_BUILDCONFLICTS = 1110, /* internal */ +-/*@-enummemuse@*/ +- RPMTAG_BUILDMACROS = 1111, /* s[] srpms only */ +-/*@=enummemuse@*/ +- RPMTAG_PROVIDEFLAGS = 1112, /* i[] */ +- RPMTAG_PROVIDEVERSION = 1113, /* s[] */ +- RPMTAG_OBSOLETEFLAGS = 1114, /* i[] */ +- RPMTAG_OBSOLETEVERSION = 1115, /* s[] */ +- RPMTAG_DIRINDEXES = 1116, /* i[] */ +- RPMTAG_BASENAMES = 1117, /* s[] */ +- RPMTAG_DIRNAMES = 1118, /* s[] */ +- RPMTAG_ORIGDIRINDEXES = 1119, /* i[] relocation */ +- RPMTAG_ORIGBASENAMES = 1120, /* s[] relocation */ +- RPMTAG_ORIGDIRNAMES = 1121, /* s[] relocation */ +- RPMTAG_OPTFLAGS = 1122, /* s */ +- RPMTAG_DISTURL = 1123, /* s */ +- RPMTAG_PAYLOADFORMAT = 1124, /* s */ +- RPMTAG_PAYLOADCOMPRESSOR = 1125, /* s */ +- RPMTAG_PAYLOADFLAGS = 1126, /* s */ +- RPMTAG_INSTALLCOLOR = 1127, /* i transaction color when installed */ +- RPMTAG_INSTALLTID = 1128, /* i[] */ +- RPMTAG_REMOVETID = 1129, /* i[] */ +-/*@-enummemuse@*/ +- RPMTAG_SHA1RHN = 1130, /* internal - obsolete */ +-/*@=enummemuse@*/ +- RPMTAG_RHNPLATFORM = 1131, /* s deprecated */ +- RPMTAG_PLATFORM = 1132, /* s */ +- RPMTAG_PATCHESNAME = 1133, /* s[] deprecated placeholder (SuSE) */ +- RPMTAG_PATCHESFLAGS = 1134, /* i[] deprecated placeholder (SuSE) */ +- RPMTAG_PATCHESVERSION = 1135, /* s[] deprecated placeholder (SuSE) */ +- RPMTAG_CACHECTIME = 1136, /* i rpmcache(8) only */ +- RPMTAG_CACHEPKGPATH = 1137, /* s rpmcache(8) only */ +- RPMTAG_CACHEPKGSIZE = 1138, /* i rpmcache(8) only */ +- RPMTAG_CACHEPKGMTIME = 1139, /* i rpmcache(8) only */ +- RPMTAG_FILECOLORS = 1140, /* i[] */ +- RPMTAG_FILECLASS = 1141, /* i[] */ +- RPMTAG_CLASSDICT = 1142, /* s[] */ +- RPMTAG_FILEDEPENDSX = 1143, /* i[] */ +- RPMTAG_FILEDEPENDSN = 1144, /* i[] */ +- RPMTAG_DEPENDSDICT = 1145, /* i[] */ +- RPMTAG_SOURCEPKGID = 1146, /* x */ +- RPMTAG_FILECONTEXTS = 1147, /* s[] */ +- RPMTAG_FSCONTEXTS = 1148, /* s[] extension */ +- RPMTAG_RECONTEXTS = 1149, /* s[] extension */ +- RPMTAG_POLICIES = 1150, /* s[] selinux *.te policy file. */ +- RPMTAG_PRETRANS = 1151, /* s */ +- RPMTAG_POSTTRANS = 1152, /* s */ +- RPMTAG_PRETRANSPROG = 1153, /* s */ +- RPMTAG_POSTTRANSPROG = 1154, /* s */ +- RPMTAG_DISTTAG = 1155, /* s */ +- RPMTAG_SUGGESTSNAME = 1156, /* s[] extension */ +-#define RPMTAG_SUGGESTS RPMTAG_SUGGESTSNAME /* s[] */ +- RPMTAG_SUGGESTSVERSION = 1157, /* s[] extension */ +- RPMTAG_SUGGESTSFLAGS = 1158, /* i[] extension */ +- RPMTAG_ENHANCESNAME = 1159, /* s[] extension placeholder */ +-#define RPMTAG_ENHANCES RPMTAG_ENHANCESNAME /* s[] */ +- RPMTAG_ENHANCESVERSION = 1160, /* s[] extension placeholder */ +- RPMTAG_ENHANCESFLAGS = 1161, /* i[] extension placeholder */ +- RPMTAG_PRIORITY = 1162, /* i[] extension placeholder */ +- RPMTAG_CVSID = 1163, /* s */ +-#define RPMTAG_SVNID RPMTAG_CVSID /* s */ +- RPMTAG_BLINKPKGID = 1164, /* s[] */ +- RPMTAG_BLINKHDRID = 1165, /* s[] */ +- RPMTAG_BLINKNEVRA = 1166, /* s[] */ +- RPMTAG_FLINKPKGID = 1167, /* s[] */ +- RPMTAG_FLINKHDRID = 1168, /* s[] */ +- RPMTAG_FLINKNEVRA = 1169, /* s[] */ +- RPMTAG_PACKAGEORIGIN = 1170, /* s */ +- RPMTAG_TRIGGERPREIN = 1171, /* internal */ +- RPMTAG_BUILDSUGGESTS = 1172, /* internal */ +- RPMTAG_BUILDENHANCES = 1173, /* internal */ +- RPMTAG_SCRIPTSTATES = 1174, /* i[] scriptlet exit codes */ +- RPMTAG_SCRIPTMETRICS = 1175, /* i[] scriptlet execution times */ +- RPMTAG_BUILDCPUCLOCK = 1176, /* i */ +- RPMTAG_FILEDIGESTALGOS = 1177, /* i[] */ +- RPMTAG_VARIANTS = 1178, /* s[] */ +- RPMTAG_XMAJOR = 1179, /* i */ +- RPMTAG_XMINOR = 1180, /* i */ +- RPMTAG_REPOTAG = 1181, /* s */ +- RPMTAG_KEYWORDS = 1182, /* s[] */ +- RPMTAG_BUILDPLATFORMS = 1183, /* s[] */ +- RPMTAG_PACKAGECOLOR = 1184, /* i */ +- RPMTAG_PACKAGEPREFCOLOR = 1185, /* i (unimplemented) */ +- RPMTAG_XATTRSDICT = 1186, /* s[] (unimplemented) */ +- RPMTAG_FILEXATTRSX = 1187, /* i[] (unimplemented) */ +- RPMTAG_DEPATTRSDICT = 1188, /* s[] (unimplemented) */ +- RPMTAG_CONFLICTATTRSX = 1189, /* i[] (unimplemented) */ +- RPMTAG_OBSOLETEATTRSX = 1190, /* i[] (unimplemented) */ +- RPMTAG_PROVIDEATTRSX = 1191, /* i[] (unimplemented) */ +- RPMTAG_REQUIREATTRSX = 1192, /* i[] (unimplemented) */ +- RPMTAG_BUILDPROVIDES = 1193, /* internal */ +- RPMTAG_BUILDOBSOLETES = 1194, /* internal */ +- RPMTAG_DBINSTANCE = 1195, /* i */ +- RPMTAG_NVRA = 1196, /* s */ +- RPMTAG_FILEPATHS = 1197, /* s[] */ +- RPMTAG_ORIGPATHS = 1198, /* s[] */ +- RPMTAG_RPMLIBVERSION = 1199, /* i */ +- RPMTAG_RPMLIBTIMESTAMP = 1200, /* i */ +- RPMTAG_RPMLIBVENDOR = 1201, /* i */ +- RPMTAG_CLASS = 1202, /* s arbitrary */ +- RPMTAG_TRACK = 1203, /* s internal arbitrary */ +- RPMTAG_TRACKPROG = 1204, /* s internal arbitrary */ +- RPMTAG_SANITYCHECK = 1205, /* s */ +- RPMTAG_SANITYCHECKPROG = 1206, /* s */ +- RPMTAG_FILESTAT = 1207, /* s[] stat(2) from metadata extension*/ +- RPMTAG_STAT = 1208, /* s[] stat(2) from disk extension */ +- RPMTAG_ORIGINTID = 1209, /* i[] */ +- RPMTAG_ORIGINTIME = 1210, /* i[] */ +- RPMTAG_HEADERSTARTOFF = 1211, /* l */ +- RPMTAG_HEADERENDOFF = 1212, /* l */ +- RPMTAG_PACKAGETIME = 1213, /* l */ +- RPMTAG_PACKAGESIZE = 1214, /* l */ +- RPMTAG_PACKAGEDIGEST = 1215, /* s */ +- RPMTAG_PACKAGESTAT = 1216, /* x */ +- RPMTAG_PACKAGEBASEURL = 1217, /* s */ +- RPMTAG_DISTEPOCH = 1218, /* s */ +-#define RPMTAG_D RPMTAG_DISTEPOCH /* s */ +- +- RPMTAG_CONFLICTYAMLENTRY = 1219, /* s[] */ +- RPMTAG_OBSOLETEYAMLENTRY = 1220, /* s[] */ +- RPMTAG_PROVIDEYAMLENTRY = 1221, /* s[] */ +- RPMTAG_REQUIREYAMLENTRY = 1222, /* s[] */ +- +- RPMTAG_FILEDIGESTALGO = 5011, /* i file checksum algorithm */ +- RPMTAG_BUGURL = 5012, /* s */ +- +-/*@-enummemuse@*/ +- RPMTAG_FIRSTFREE_TAG, /*!< internal */ +-/*@=enummemuse@*/ +- +- RPMTAG_PACKAGETRANSFLAGS = 0x4efaafd9, /* s[] arbitrary */ +- RPMTAG_PACKAGEDEPFLAGS = 0x748a8314, /* s[] arbitrary */ +- +- RPMTAG_BUILDPREPPROG = 0x4ba37c9e, /* s[] arbitrary */ +- RPMTAG_BUILDPREP = 0x799c0b4d, /* s[] arbitrary */ +- RPMTAG_BUILDBUILDPROG = 0x6fb46014, /* s[] arbitrary */ +- RPMTAG_BUILDBUILD = 0x5bae1a5a, /* s[] arbitrary */ +- RPMTAG_BUILDINSTALLPROG = 0x70d4ab6f, /* s[] arbitrary */ +- RPMTAG_BUILDINSTALL = 0x567f5983, /* s[] arbitrary */ +- RPMTAG_BUILDCHECKPROG = 0x488a60ce, /* s[] arbitrary */ +- RPMTAG_BUILDCHECK = 0x7f3b97b5, /* s[] arbitrary */ +- RPMTAG_BUILDCLEANPROG = 0x42c93d41, /* s[] arbitrary */ +- RPMTAG_BUILDCLEAN = 0x566042bf, /* s[] arbitrary */ +- +- RPMTAG_LASTARBITRARY_TAG = 0x80000000 /*!< internal */ +-}; +- +-#define RPMTAG_EXTERNAL_TAG 1000000 +- +-/** \ingroup signature +- * Tags found in signature header from package. +- */ +-enum rpmSigTag_e { +- RPMSIGTAG_SIZE = 1000, /*!< internal Header+Payload size in bytes. */ +- RPMSIGTAG_LEMD5_1 = 1001, /*!< internal Broken MD5, take 1 @deprecated legacy. */ +- RPMSIGTAG_PGP = 1002, /*!< internal PGP 2.6.3 signature. */ +- RPMSIGTAG_LEMD5_2 = 1003, /*!< internal Broken MD5, take 2 @deprecated legacy. */ +- RPMSIGTAG_MD5 = 1004, /*!< internal MD5 signature. */ +- RPMSIGTAG_GPG = 1005, /*!< internal GnuPG signature. */ +- RPMSIGTAG_PGP5 = 1006, /*!< internal PGP5 signature @deprecated legacy. */ +- RPMSIGTAG_PAYLOADSIZE = 1007,/*!< internal uncompressed payload size in bytes. */ +- RPMSIGTAG_BADSHA1_1 = RPMTAG_BADSHA1_1, /*!< internal Broken SHA1, take 1. */ +- RPMSIGTAG_BADSHA1_2 = RPMTAG_BADSHA1_2, /*!< internal Broken SHA1, take 2. */ +- RPMSIGTAG_SHA1 = RPMTAG_SHA1HEADER, /*!< internal sha1 header digest. */ +- RPMSIGTAG_DSA = RPMTAG_DSAHEADER, /*!< internal DSA header signature. */ +- RPMSIGTAG_RSA = RPMTAG_RSAHEADER, /*!< internal RSA header signature. */ +- RPMSIGTAG_PADDING = 0x3fffffff /*!< signature header padding */ +-}; +- +-/** \ingroup header +- */ +-typedef enum rpmTag_e rpmTag; +- +-/** \ingroup header +- */ +-typedef enum rpmSigTag_e rpmSigTag; +- +-/** \ingroup header +- */ +-/*@-typeuse -fielduse@*/ +-#if !defined(SWIG) +-struct _HE_s { +- rpmTag tag; +- rpmTagType t; +-/*@owned@*/ /*@null@*/ +- rpmTagData p; +- rpmTagCount c; +- int ix; +- unsigned int freeData : 1; +- unsigned int avail : 1; +- unsigned int append : 1; +-}; +-#endif +- +-/** +- */ +-typedef struct _HE_s HE_s; +- +-/** \ingroup rpmdb +- */ +-typedef struct tagStore_s * tagStore_t; +- +-/** +- */ +-typedef /*@abstract@*/ const struct headerTagTableEntry_s * headerTagTableEntry; +- +-#if defined(_RPMTAG_INTERNAL) +-/** +- */ +-/** \ingroup header +- * Associate tag names with numeric values. +- */ +-#if !defined(SWIG) +-struct headerTagTableEntry_s { +-/*@observer@*/ /*@relnull@*/ +- const char * name; /*!< Tag name. */ +- rpmTag val; /*!< Tag numeric value. */ +- rpmTagType type; /*!< Tag type. */ +-}; +-#endif +- +-/** +- */ +-struct tagStore_s { +-/*@only@*/ +- const char * str; /*!< Tag string (might be arbitrary). */ +- rpmTag tag; /*!< Tag number. */ +- rpmiob iob; /*!< Tag contents. */ +-}; +-#endif /* _RPMTAG_INTERNAL */ +- +-/** +- * Automatically generated table of tag name/value pairs. +- */ +-/*@-redecl@*/ +-/*@observer@*/ /*@unchecked@*/ +-extern headerTagTableEntry rpmTagTable; +-/*@=redecl@*/ +- +-/** +- * Number of entries in rpmTagTable. +- */ +-/*@-redecl@*/ +-/*@unchecked@*/ +-extern int rpmTagTableSize; +- +-/*@unchecked@*/ +-extern headerTagIndices rpmTags; +-/*@=redecl@*/ +- +-#if defined(_RPMTAG_INTERNAL) +-/** +- */ +-#if !defined(SWIG) +-struct headerTagIndices_s { +-/*@relnull@*/ +- int (*loadIndex) (headerTagTableEntry ** ipp, size_t * np, +- int (*cmp) (const void * avp, const void * bvp)) +- /*@ modifies *ipp, *np */; /*!< Load sorted tag index. */ +-/*@relnull@*/ +- headerTagTableEntry * byName; /*!< rpmTag's sorted by name. */ +- size_t byNameSize; /*!< No. of entries. */ +- int (*byNameCmp) (const void * avp, const void * bvp) +- /*@*/; /*!< Compare entries by name. */ +- rpmTag (*tagValue) (const char * name) +- /*@*/; /*!< Return value from name. */ +-/*@relnull@*/ +- headerTagTableEntry * byValue; /*!< rpmTag's sorted by value. */ +- size_t byValueSize; /*!< No. of entries. */ +- int (*byValueCmp) (const void * avp, const void * bvp) +- /*@*/; /*!< Compare entries by value. */ +- const char * (*tagName) (rpmTag value) +- /*@*/; /*!< Return name from value. */ +- rpmTag (*tagType) (rpmTag value) +- /*@*/; /*!< Return type from value. */ +- size_t nameBufLen; /*!< No. bytes allocated for nameBuf. */ +-/*@relnull@*/ +- const char ** aTags; /*!< Arbitrary tags array (ARGV_t) */ +-/*@owned@*/ /*@null@*/ +- char * nameBuf; /* Name buffer. */ +-/*@only@*/ +- char * (*tagCanonicalize) (const char * s) +- /*@*/; /*!< Canonicalize arbitrary string. */ +- rpmTag (*tagGenerate) (const char * s) +- /*@*/; /*!< Generate tag from string. */ +-}; +-#endif +-#endif /* _RPMTAG_INTERNAL */ +- +-/** +- * Return tag name from value. +- * @param tag tag value +- * @return tag name, "(unknown)" on not found +- */ +-/*@observer@*/ +-const char * tagName(rpmTag tag) +- /*@*/; +- +-/** +- * Return tag data type from value. +- * @todo Return rpmTagType-like, not unsigned int. There's no clear typedef yet. +- * @param tag tag value +- * @return tag data type, 0 on not found. +- */ +-unsigned int tagType(rpmTag tag) +- /*@*/; +- +-/** +- * Return tag value from name. +- * @param tagstr name of tag +- * @return tag value, 0xffffffff on not found +- */ +-rpmTag tagValue(const char * tagstr) +- /*@*/; +- +-/** +- * Canonicalize a rpmTag string. +- * @param s string +- * @return canonicalized string +- */ +-/*@only@*/ +-char * tagCanonicalize(const char * s) +- /*@*/; +- +-/** +- * Generate a tag from arbitrary string. +- * @param s string +- * @return generated tag value +- */ +-rpmTag tagGenerate(const char * s) +- /*@*/; +- +-/** +- * Free memory in header tag indices. +- * @param _rpmTags header tag indices (NULL uses rpmTags) +- */ +-void tagClean(/*@null@*/ headerTagIndices _rpmTags) +- /*@globals rpmTags @*/ +- /*@modifies _rpmTags, rpmTags @*/; +- +-/** +- * Destroy tagStore array. +- * @param dbiTags dbi tag storage +- * @param dbiNTags no. of dbi tags +- * @return NULL always +- */ +-/*@null@*/ +-tagStore_t tagStoreFree(/*@only@*//*@null@*/tagStore_t dbiTags, size_t dbiNTags) +- /*@modifies dbiTags @*/; +- +-#if defined(_RPMTAG_INTERNAL) +-/** \ingroup header +- */ +-typedef enum headerSprintfExtensionType_e { +- HEADER_EXT_LAST = 0, /*!< End of extension chain. */ +- HEADER_EXT_FORMAT, /*!< headerTagFormatFunction() extension */ +- HEADER_EXT_MORE, /*!< Chain to next table. */ +- HEADER_EXT_TAG /*!< headerTagTagFunction() extension */ +-} headerSprintfExtensionType; +- +-/** \ingroup header +- * HEADER_EXT_TAG format function prototype. +- * +- * @param he tag container +- * @param av parameter array (or NULL) +- * @return formatted string +- */ +-typedef /*only@*/ char * (*headerTagFormatFunction) (HE_t he, /*@null@*/ const char ** av) +- /*@modifies he @*/; +- +-/** \ingroup header +- * HEADER_EXT_FORMAT format function prototype. +- * This is allowed to fail, which indicates the tag doesn't exist. +- * +- * @param h header +- * @retval he tag container +- * @return 0 on success +- */ +-typedef int (*headerTagTagFunction) (Header h, HE_t he) +- /*@modifies he @*/; +- +-/** \ingroup header +- * Define header tag output formats. +- */ +-#if !defined(SWIG) +-struct headerSprintfExtension_s { +- headerSprintfExtensionType type; /*!< Type of extension. */ +-/*@observer@*/ /*@null@*/ +- const char * name; /*!< Name of extension. */ +- union { +-/*@observer@*/ /*@null@*/ +- void * generic; /*!< Private extension. */ +- headerTagFormatFunction fmtFunction; /*!< HEADER_EXT_TAG extension. */ +- headerTagTagFunction tagFunction; /*!< HEADER_EXT_FORMAT extension. */ +- headerSprintfExtension * more; /*!< Chained table extension. */ +- } u; +-}; +-#endif +-#endif /* _RPMTAG_INTERNAL */ +- +-/** \ingroup header +- * Supported default header tag output formats. +- */ +-/*@unchecked@*/ /*@observer@*/ +-extern headerSprintfExtension headerDefaultFormats; +- +-/** \ingroup header +- * Supported default header extension/tag output formats. +- */ +-/*@unchecked@*/ /*@observer@*/ +-extern headerSprintfExtension headerCompoundFormats; +- +-/** +- * Display list of tags that can be used in --queryformat. +- * @param fp file handle to use for display (NULL uses stdout) +- * @param _rpmTagTable rpm tag table (NULL uses rpmTagTable) +- * @param _rpmHeaderFormats rpm tag extensions & formats (NULL uses headerCompoundFormats) +- */ +-void rpmDisplayQueryTags(/*@null@*/ FILE * fp, +- /*@null@*/ headerTagTableEntry _rpmTagTable, +- /*@null@*/ headerSprintfExtension _rpmHeaderFormats) +- /*@globals fileSystem, internalState @*/ +- /*@modifies *fp, fileSystem, internalState @*/; +- +-/** \ingroup header +- * Return formatted output string from header tags. +- * The returned string must be free()d. +- * +- * @param h header +- * @param fmt format to use +- * @param tags array of tag name/value/type triples (NULL uses default) +- * @param exts formatting extensions chained table (NULL uses default) +- * @retval errmsg error message (if any) +- * @return formatted output string (malloc'ed) +- */ +-/*@only@*/ /*@null@*/ +-char * headerSprintf(Header h, const char * fmt, +- /*@null@*/ headerTagTableEntry tags, +- /*@null@*/ headerSprintfExtension exts, +- /*@null@*/ /*@out@*/ errmsg_t * errmsg) +- /*@globals headerCompoundFormats, fileSystem, internalState @*/ +- /*@modifies h, *errmsg, fileSystem, internalState @*/; +- +-/** \ingroup header +- * Retrieve extension or tag value from a header. +- * +- * @param h header +- * @param he tag container +- * @param flags tag retrieval flags +- * @return 1 on success, 0 on failure +- */ +-int headerGet(Header h, HE_t he, unsigned int flags) +- /*@globals internalState @*/ +- /*@modifies he, internalState @*/; +-#define HEADERGET_NOEXTENSION (1 << 0) /*!< Extension search disabler. */ +-#define HEADERGET_NOI18NSTRING (1 << 1) /*!< Return i18n strings as argv. */ +- +-/** \ingroup header +- * Add or append tag container to header. +- * +- * @param h header +- * @param he tag container +- * @param flags (unused) +- * @return 1 on success, 0 on failure +- */ +-/*@mayexit@*/ +-int headerPut(Header h, HE_t he, /*@unused@*/ unsigned int flags) +- /*@modifies h @*/; +- +-/** \ingroup header +- * Remove tag container from header. +- * +- * @param h header +- * @param he tag container +- * @param flags (unused) +- * @return 1 on success, 0 on failure +- */ +-/*@mayexit@*/ +-int headerDel(Header h, HE_t he, /*@unused@*/ unsigned int flags) +- /*@modifies h @*/; +- +-/** \ingroup header +- * Modify tag container in header. +- * If there are multiple entries with this tag, the first one gets replaced. +- * @param h header +- * @param he tag container +- * @param flags (unused) +- * @return 1 on success, 0 on failure +- */ +-int headerMod(Header h, HE_t he, /*@unused@*/ unsigned int flags) +- /*@modifies h @*/; +- +-/** \ingroup header +- * Destroy header tag container iterator. +- * @param hi header tag container iterator +- * @return NULL always +- */ +-/*@null@*/ +-HeaderIterator headerFini(/*@only@*/ HeaderIterator hi) +- /*@globals fileSystem @*/ +- /*@modifies hi, fileSystem */; +- +-/** \ingroup header +- * Create header tag iterator. +- * @param h header +- * @return header tag iterator +- */ +-HeaderIterator headerInit(Header h) +- /*@globals fileSystem @*/ +- /*@modifies h, fileSystem */; +- +-/** \ingroup header +- * Return next tag from header. +- * @param hi header tag iterator +- * @param he tag container +- * @param flags (unused) +- * @return 1 on success, 0 on failure +- */ +-int headerNext(HeaderIterator hi, HE_t he, /*@unused@*/ unsigned int flags) +- /*@globals internalState @*/ +- /*@modifies hi, he, internalState @*/; +- +-/** \ingroup header +- * Reference a header instance. +- * @param h header +- * @return referenced header instance +- */ +-Header headerLink(Header h) +- /*@modifies h @*/; +-#define headerLink(_h) \ +- ((Header)rpmioLinkPoolItem((rpmioItem)(_h), __FUNCTION__, __FILE__, __LINE__)) +- +-/** \ingroup header +- * Dereference a header instance. +- * @param h header +- * @return NULL on last dereference +- */ +-/*@null@*/ +-Header headerUnlink(/*@killref@*/ /*@null@*/ Header h) +- /*@modifies h @*/; +-#define headerUnlink(_h) \ +- ((Header)rpmioUnlinkPoolItem((rpmioItem)(_h), __FUNCTION__, __FILE__, __LINE__)) +- +-/** \ingroup header +- * Dereference a header instance. +- * @param h header +- * @return NULL on last dereference +- */ +-/*@null@*/ +-Header headerFree(/*@killref@*/ /*@null@*/ Header h) +- /*@modifies h @*/; +-#define headerFree(_h) \ +- ((Header)rpmioFreePoolItem((rpmioItem)(_h), __FUNCTION__, __FILE__, __LINE__)) +- +-/** \ingroup header +- * Create new (empty) header instance. +- * @return header +- */ +-Header headerNew(void) +- /*@globals fileSystem @*/ +- /*@modifies fileSystem @*/; +- +-/** \ingroup header +- * Return size of on-disk header representation in bytes. +- * @param h header +- * @return size of on-disk header +- */ +-size_t headerSizeof(/*@null@*/ Header h) +- /*@modifies h @*/; +- +-/** \ingroup header +- * headerUnload. +- * @param h header +- * @retval *lenp no. bytes in unloaded header blob +- * @return unloaded header blob (NULL on error) +- */ +-/*@only@*/ /*@null@*/ +-void * headerUnload(Header h, /*@out@*/ /*@null@*/ size_t * lenp) +- /*@globals internalState @*/ +- /*@modifies h, *lenp, internalState @*/; +- +-/** \ingroup header +- * Convert header to on-disk representation, and then reload. +- * This is used to insure that all header data is in a single +- * contiguous memory allocation. +- * @param h header (with pointers) +- * @param tag region tag +- * @return on-disk header (with offsets) +- */ +-/*@null@*/ +-Header headerReload(/*@only@*/ Header h, int tag) +- /*@globals fileSystem, internalState @*/ +- /*@modifies h, fileSystem, internalState @*/; +- +-/** \ingroup header +- * Duplicate a header. +- * @param h header +- * @return new header instance +- */ +-/*@null@*/ +-Header headerCopy(Header h) +- /*@globals fileSystem, internalState @*/ +- /*@modifies h, fileSystem, internalState @*/; +- +-/** \ingroup header +- * Convert header to in-memory representation. +- * @param uh on-disk header blob (i.e. with offsets) +- * @return header +- */ +-/*@null@*/ +-Header headerLoad(/*@kept@*/ void * uh) +- /*@globals fileSystem, internalState @*/ +- /*@modifies uh, fileSystem, internalState @*/; +- +-/** \ingroup header +- * Make a copy and convert header to in-memory representation. +- * @param uh on-disk header blob (i.e. with offsets) +- * @return header +- */ +-/*@null@*/ +-Header headerCopyLoad(const void * uh) +- /*@globals fileSystem, internalState @*/ +- /*@modifies fileSystem, internalState @*/; +- +-/** \ingroup header +- * Check if tag is in header. +- * @param h header +- * @param tag tag +- * @return 1 on success, 0 on failure +- */ +-int headerIsEntry(/*@null@*/ Header h, rpmTag tag) +- /*@*/; +- +-/** \ingroup header +- * Add locale specific tag to header. +- * A NULL lang is interpreted as the C locale. Here are the rules: +- * \verbatim +- * - If the tag isn't in the header, it's added with the passed string +- * as new value. +- * - If the tag occurs multiple times in entry, which tag is affected +- * by the operation is undefined. +- * - If the tag is in the header w/ this language, the entry is +- * *replaced* (like headerModifyEntry()). +- * \endverbatim +- * This function is intended to just "do the right thing". If you need +- * more fine grained control use headerAddEntry() and headerModifyEntry(). +- * +- * @param h header +- * @param tag tag +- * @param string tag value +- * @param lang locale +- * @return 1 on success, 0 on failure +- */ +-int headerAddI18NString(Header h, rpmTag tag, const char * string, +- const char * lang) +- /*@modifies h @*/; +- +-/** \ingroup header +- * Duplicate tag values from one header into another. +- * @param headerFrom source header +- * @param headerTo destination header +- * @param tagstocopy array of tags that are copied +- */ +-void headerCopyTags(Header headerFrom, Header headerTo, rpmTag * tagstocopy) +- /*@globals internalState @*/ +- /*@modifies headerTo, internalState @*/; +- +-/** \ingroup header +- * Return header magic. +- * @param h header +- * @param *magicp magic array +- * @param *nmagicp no. bytes of magic +- * @return 0 always +- */ +-int headerGetMagic(/*@null@*/ Header h, unsigned char **magicp, size_t *nmagicp) +- /*@modifies *magicp, *nmagicp @*/; +- +-/** \ingroup header +- * Store header magic. +- * @param h header +- * @param magic magic array +- * @param nmagic no. bytes of magic +- * @return 0 always +- */ +-int headerSetMagic(/*@null@*/ Header h, unsigned char * magic, size_t nmagic) +- /*@modifies h @*/; +- +-/** \ingroup header +- * Return header origin (e.g path or URL). +- * @param h header +- * @return header origin +- */ +-/*@observer@*/ /*@null@*/ +-const char * headerGetOrigin(/*@null@*/ Header h) +- /*@*/; +- +-/** \ingroup header +- * Store header origin (e.g path or URL). +- * @param h header +- * @param origin new header origin +- * @return 0 always +- */ +-int headerSetOrigin(/*@null@*/ Header h, const char * origin) +- /*@modifies h @*/; +- +-/** \ingroup header +- * Return header parent identifier (e.g parent's NVRA). +- * @param h header +- * @return header parent +- */ +-/*@observer@*/ /*@null@*/ +-const char * headerGetParent(/*@null@*/ Header h) +- /*@*/; +- +-/** \ingroup header +- * Store header parent (e.g parent's NVRA). +- * @param h header +- * @param parent new header parent +- * @return 0 always +- */ +-int headerSetParent(/*@null@*/ Header h, const char * parent) +- /*@modifies h @*/; +- +-/** \ingroup header +- * Return header base URL (e.g path or URL). +- * @param h header +- * @return header origin +- */ +-/*@observer@*/ /*@null@*/ +-const char * headerGetBaseURL(/*@null@*/ Header h) +- /*@*/; +- +-/** \ingroup header +- * Store header base URL (e.g path or URL). +- * @param h header +- * @param baseurl new header baseurl +- * @return 0 always +- */ +-int headerSetBaseURL(/*@null@*/ Header h, const char * baseurl) +- /*@modifies h @*/; +- +-/** \ingroup header +- * Return header stat(2) buffer (of origin *.rpm file). +- * @param h header +- * @return header stat(2) buffer +- */ +-struct stat * headerGetStatbuf(/*@null@*/ Header h) +- /*@*/; +- +-/** \ingroup header +- * Copy into header stat(2) buffer (of origin *.rpm file). +- * @param h header +- * @param st new header stat(2) buffer +- * @return 0 always +- */ +-int headerSetStatbuf(/*@null@*/ Header h, struct stat * st) +- /*@modifies h @*/; +- +-/** \ingroup header +- * Return digest of origin *.rpm file. +- * @param h header +- * @return header digest +- */ +-/*@null@*/ +-const char * headerGetDigest(/*@null@*/ Header h) +- /*@*/; +- +-/** \ingroup header +- * Store digest of origin *.rpm file. +- * @param h header +- * @param st new header digest +- * @return 0 always +- */ +-int headerSetDigest(/*@null@*/ Header h, const char * digest) +- /*@modifies h @*/; +- +-/** \ingroup header +- * Return rpmdb pointer. +- * @param h header +- * @return rpmdb pointer +- */ +-/*@null@*/ +-void * headerGetRpmdb(/*@null@*/ Header h) +- /*@*/; +- +-/** \ingroup header +- * Store rpmdb pointer. +- * @param h header +- * @param rpmdb new rpmdb pointer (or NULL to unset) +- * @return NULL always +- */ +-/*@null@*/ +-void * headerSetRpmdb(/*@null@*/ Header h, /*@null@*/ void * rpmdb) +- /*@modifies h @*/; +- +-/** \ingroup header +- * Return header instance (if from rpmdb). +- * @param h header +- * @return header instance +- */ +-uint32_t headerGetInstance(/*@null@*/ Header h) +- /*@*/; +- +-/** \ingroup header +- * Store header instance (e.g path or URL). +- * @param h header +- * @param instance new header instance +- * @return 0 always +- */ +-uint32_t headerSetInstance(/*@null@*/ Header h, uint32_t instance) +- /*@modifies h @*/; +- +-/** \ingroup header +- * Return header starting byte offset. +- * @param h header +- * @return header starting byte offset +- */ +-rpmuint32_t headerGetStartOff(/*@null@*/ Header h) +- /*@*/; +- +-/** \ingroup header +- * Store header starting byte offset. +- * @param h header +- * @param startoff new header starting byte offset +- * @return 0 always +- */ +-rpmuint32_t headerSetStartOff(/*@null@*/ Header h, rpmuint32_t startoff) +- /*@modifies h @*/; +- +-/** \ingroup header +- * Return header ending byte offset. +- * @param h header +- * @return header ending byte offset +- */ +-rpmuint32_t headerGetEndOff(/*@null@*/ Header h) +- /*@*/; +- +-/** \ingroup header +- * Store header ending byte offset. +- * @param h header +- * @param startoff new header ending byte offset +- * @return 0 always +- */ +-rpmuint32_t headerSetEndOff(/*@null@*/ Header h, rpmuint32_t endoff) +- /*@modifies h @*/; +- +-/** \ingroup header +- * Return header stats accumulator structure. +- * @param h header +- * @param opx per-header accumulator index (aka rpmtsOpX) +- * @return per-header accumulator pointer +- */ +-/*@null@*/ +-void * headerGetStats(Header h, int opx) +- /*@*/; +- +-/** +- * Define per-header macros. +- * @param h header +- * @return 0 always +- */ +-int headerMacrosLoad(Header h) +- /*@globals internalState @*/ +- /*@modifies internalState @*/; +- +-/** +- * Define per-header macros. +- * @param h header +- * @return 0 always +- */ +-int headerMacrosUnload(Header h) +- /*@globals internalState @*/ +- /*@modifies internalState @*/; +- +-/** \ingroup header +- * Return name, epoch, version, release, arch strings from header. +- * @param h header +- * @retval *np name pointer (or NULL) +- * @retval *ep epoch pointer (or NULL) +- * @retval *vp version pointer (or NULL) +- * @retval *rp release pointer (or NULL) +- * @retval *ap arch pointer (or NULL) +- * @return 0 always +- */ +-int headerNEVRA(Header h, +- /*@null@*/ /*@out@*/ const char ** np, +- /*@null@*/ /*@out@*/ /*@unused@*/ const char ** ep, +- /*@null@*/ /*@out@*/ const char ** vp, +- /*@null@*/ /*@out@*/ const char ** rp, +- /*@null@*/ /*@out@*/ const char ** ap) +- /*@globals internalState @*/ +- /*@modifies h, *np, *vp, *rp, *ap, internalState @*/; +- +-/** +- * Return header color. +- * @param h header +- * @return header color +- */ +-rpmuint32_t hGetColor(Header h) +- /*@globals internalState @*/ +- /*@modifies h, internalState @*/; +- +-/** \ingroup header +- * Translate and merge legacy signature tags into header. +- * @todo Remove headerSort() through headerInitIterator() modifies sig. +- * @param h header +- * @param sigh signature header +- */ +-void headerMergeLegacySigs(Header h, const Header sigh) +- /*@globals fileSystem, internalState @*/ +- /*@modifies h, sigh, fileSystem, internalState @*/; +- +-/** \ingroup header +- * Regenerate signature header. +- * @todo Remove headerSort() through headerInitIterator() modifies h. +- * @param h header +- * @param noArchiveSize don't copy archive size tag (pre rpm-4.1) +- * @return regenerated signature header +- */ +-Header headerRegenSigHeader(const Header h, int noArchiveSize) +- /*@globals fileSystem, internalState @*/ +- /*@modifies h, fileSystem, internalState @*/; +- +-#ifdef __cplusplus +-} +-#endif +- +-#endif /* H_RPMTAG */ +diff --git a/src/scripts/extract-debuginfo.in b/src/scripts/extract-debuginfo.in +index 4746df2..c258ed1 100644 +--- a/src/scripts/extract-debuginfo.in ++++ b/src/scripts/extract-debuginfo.in +@@ -193,7 +193,7 @@ find "$BUILDROOT" ! -path "${debugdir}/*.debug" -type f \ + fi + + echo " Extracting debug info from ${f#${BUILDROOT}}" +- id=$(@libexecdir@/debugedit -i \ ++ id=$(debugedit -i \ + -b "${SOURCEDIR}" \ + -d /usr/src/debug \ + -l "${SOURCEFILE}" \ +-- +2.7.4 +