[git.ipfire.org] IPFire 3.x development tree branch, master, updated. a3b04653dc27b4d24b59a65c2ef5a94d9f5eb854

This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "IPFire 3.x development tree".

The branch, master has been updated via a3b04653dc27b4d24b59a65c2ef5a94d9f5eb854 (commit) via 501028b5582d04979522170329f5185beffc4303 (commit) via b8b4576449f20282f2fdb9a43fc18a19a038bdc0 (commit) from 8db6df934338535beafaca34cc7a268f421c4397 (commit)

Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below.

- Log ----------------------------------------------------------------- commit a3b04653dc27b4d24b59a65c2ef5a94d9f5eb854 Author: Michael Tremer michael.tremer@ipfire.org Date: Thu Oct 27 09:57:46 2016 +0100

gcc: Default to DWARF4 for debugging info

GCC already defaults to DWARF4, so this block that changes defaults is not required any more.

Signed-off-by: Michael Tremer michael.tremer@ipfire.org

commit 501028b5582d04979522170329f5185beffc4303 Author: Michael Tremer michael.tremer@ipfire.org Date: Wed Oct 26 23:58:56 2016 +0100

pakfire: Remove debugedit

debugedit was shipped with pakfire before and is now a standalone package.

Signed-off-by: Michael Tremer michael.tremer@ipfire.org

commit b8b4576449f20282f2fdb9a43fc18a19a038bdc0 Author: Michael Tremer michael.tremer@ipfire.org Date: Wed Oct 26 23:58:19 2016 +0100

debugedit: New package

Stripped from RPM5 and built as a standalone version

Signed-off-by: Michael Tremer michael.tremer@ipfire.org

-----------------------------------------------------------------------

Summary of changes: makedepend/makedepend.nm => debugedit/debugedit.nm | 25 +- debugedit/patches/debugedit-5.3.5-DWARF-4.patch | 129 + debugedit/update/Makefile | 11 + debugedit/update/README | 1 + debugedit/update/update.sh | 58 + gcc/gcc.nm | 9 +- pakfire/pakfire.nm | 10 +- .../0001-Remove-shipped-version-of-debugedit.patch | 4576 ++++++++++++++++++++ 8 files changed, 4792 insertions(+), 27 deletions(-) copy makedepend/makedepend.nm => debugedit/debugedit.nm (57%) create mode 100644 debugedit/patches/debugedit-5.3.5-DWARF-4.patch create mode 100644 debugedit/update/Makefile create mode 100644 debugedit/update/README create mode 100644 debugedit/update/update.sh create mode 100644 pakfire/patches/0001-Remove-shipped-version-of-debugedit.patch

Difference in files: diff --git a/debugedit/debugedit.nm b/debugedit/debugedit.nm new file mode 100644 index 0000000..83f67a8 --- /dev/null +++ b/debugedit/debugedit.nm @@ -0,0 +1,38 @@ +############################################################################### +# IPFire.org - An Open Source Firewall Solution # +# Copyright (C) - IPFire Development Team info@ipfire.org # +############################################################################### + +name = debugedit +version = 5.3.5 +release = 1 + +groups = Development/Tools +url = http://www.rpm5.org/ +license = GPLv2 +summary = Standalone version of debugedit + +description + This package contains a standalone version of debugedit from RPM5. +end + +build + requires + beecrypt-devel + elfutils-devel + popt-devel + end + + install + mkdir -pv %{BUILDROOT}%{bindir} + install -v -m 755 debugedit %{BUILDROOT}%{bindir}/debugedit + end +end + +packages + package %{name} + + package %{name}-debuginfo + template DEBUGINFO + end +end diff --git a/debugedit/patches/debugedit-5.3.5-DWARF-4.patch b/debugedit/patches/debugedit-5.3.5-DWARF-4.patch new file mode 100644 index 0000000..3e14061 --- /dev/null +++ b/debugedit/patches/debugedit-5.3.5-DWARF-4.patch @@ -0,0 +1,129 @@ +add DWARF 4 support + +https://bugs.gentoo.org/400663 +https://bugzilla.redhat.com/show_bug.cgi?id=707677 + +--- debugedit-5.3.5/debugedit.c 2011-10-11 05:37:49.000000000 +0200 ++++ debugedit-5.3.5/debugedit.c 2012-01-25 01:27:23.487999039 +0100 +@@ -70,6 +70,10 @@ + #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; +@@ -246,6 +250,7 @@ + #define DEBUG_STR 8 + #define DEBUG_FRAME 9 + #define DEBUG_RANGES 10 ++#define DEBUG_TYPES 11 + { ".debug_info", NULL, NULL, 0, 0, 0 }, + { ".debug_abbrev", NULL, NULL, 0, 0, 0 }, + { ".debug_line", NULL, NULL, 0, 0, 0 }, +@@ -257,6 +262,7 @@ + { ".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 }, + { NULL, NULL, NULL, 0, 0, 0 } + }; + +@@ -349,7 +355,8 @@ + goto no_memory; + } + form = read_uleb128 (ptr); +- if (form == 2 || form > DW_FORM_indirect) ++ 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); +@@ -378,7 +385,6 @@ + canonicalize_path (const char *s, char *d) + { + char *rv = d; +- const char *sroot; + char *droot; + + if (IS_DIR_SEPARATOR (*s)) +@@ -394,7 +400,6 @@ + s++; + } + droot = d; +- sroot = s; + + while (*s) + { +@@ -513,7 +518,7 @@ + } + + value = read_16 (ptr); +- if (value != 2 && value != 3) ++ if (value != 2 && value != 3 && value != 4) + { + error (0, 0, "%s: DWARF version %d unhandled", dso->filename, + value); +@@ -529,8 +534,8 @@ + return 1; + } + +- opcode_base = ptr[4]; +- ptr = dir = ptr + 4 + opcode_base; ++ opcode_base = ptr[4 + (value >= 4)]; ++ ptr = dir = ptr + 4 + (value >= 4) + opcode_base; + + /* dir table: */ + value = 1; +@@ -758,7 +763,8 @@ + { + if (t->attr[i].attr == DW_AT_stmt_list) + { +- if (form == DW_FORM_data4) ++ if (form == DW_FORM_data4 ++ || form == DW_FORM_sec_offset) + { + list_offs = do_read_32_relocated (ptr); + found_list_offs = 1; +@@ -864,6 +870,8 @@ + else + ptr += 4; + break; ++ case DW_FORM_flag_present: ++ break; + case DW_FORM_addr: + ptr += ptr_size; + break; +@@ -878,10 +886,12 @@ + 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: +@@ -910,6 +920,7 @@ + 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); +@@ -1213,7 +1224,7 @@ + } + + cu_version = read_16 (ptr); +- if (cu_version != 2 && cu_version != 3) ++ if (cu_version != 2 && cu_version != 3 && cu_version != 4) + { + error (0, 0, "%s: DWARF version %d unhandled", dso->filename, + cu_version); diff --git a/debugedit/update/Makefile b/debugedit/update/Makefile new file mode 100644 index 0000000..946a128 --- /dev/null +++ b/debugedit/update/Makefile @@ -0,0 +1,11 @@ +CPPFLAGS += -I. +LDLIBS = -lelf -lpopt -lbeecrypt + +all: debugedit + +debugedit: debugedit.o hashtab.o + +clean: + rm -f *.o debugedit + +.PHONY: clean diff --git a/debugedit/update/README b/debugedit/update/README new file mode 100644 index 0000000..2a676ae --- /dev/null +++ b/debugedit/update/README @@ -0,0 +1 @@ +From https://gitweb.gentoo.org/repo/gentoo.git/tree/dev-util/debugedit diff --git a/debugedit/update/update.sh b/debugedit/update/update.sh new file mode 100644 index 0000000..448624b --- /dev/null +++ b/debugedit/update/update.sh @@ -0,0 +1,58 @@ +#!/bin/bash + +DISTDIR=/usr/portage/distfiles +PN=debugedit + +set -e + +echo "Getting updated index" +rm -f index.html +wget -q http://rpm5.org/ + +PV=$(sed -n '/Production:/{n;s:.*RPM ::;s:<.*::;p;q}' index.html) +PV=5.3.5 +echo "Latest upstream version: ${PV}" +rm -f index.html + +P="${PN}-${PV}" +A=${P}.tar.gz + +echo "Fetching latest rpm tarball" +r=rpm-${PV} +wget -nv http://rpm5.org/files/rpm/rpm-$%7BPV%.*%7D/$%7Br%7D.tar.gz + +echo "Unpacking ${r}" +rm -rf ${r} +tar xf ${r}.tar.gz + +echo "Creating ${P}" +rm -rf ${P} +mkdir ${P} +cp Makefile ${r}/tools/{hashtab.?,debugedit.c} ${P}/ +pushd ${P} >/dev/null +more=true +while ${more} ; do + more=false + for h in $(grep '#include' *.[ch] | awk '{print $NF}' | sed 's:[<>"]::g') ; do + [[ ${h} == */* ]] && continue + rh=$(find ../${r} -name ${h##*/}) + if [[ -n ${rh} ]] && [[ ! -e ${rh##*/} ]] ; then + # don't copy glibc includes + if ! grep -qs 'This file is part of the GNU C Library' ${rh} ; then + cp ${rh} ./ + more=true + fi + fi + done +done +popd >/dev/null +tar zcf ${A} ${P} + +echo "Testing build" +pushd ${P} >/dev/null +make -s +popd >/dev/null + +echo "Cleaning up" +rm -rf ${P} ${r} +du -b ${A} diff --git a/gcc/gcc.nm b/gcc/gcc.nm index 1965352..8ec13d9 100644 --- a/gcc/gcc.nm +++ b/gcc/gcc.nm @@ -8,7 +8,7 @@ build_graphite = 1

name = gcc version = 6.2.0 -release = 2 +release = 3

maintainer = Michael Tremer michael.tremer@ipfire.org groups = Development/Compilers @@ -151,13 +151,6 @@ build sed -i gcc/Makefile.in \ -e "s/-fno-exceptions/& -fno-asynchronous-unwind-tables/"

- # Default to -gdwarf-4 -fno-debug-types-section rather than -gdwarf-2 - sed -i gcc/common.opt \ - -e '/UInteger Var(dwarf_version)/s/Init(2)/Init(4)/' \ - -e '/flag_debug_types_section/s/Init(1)/Init(0)/' \ - -e '/dwarf_record_gcc_switches/s/Init(0)/Init(1)/' \ - -e 's/(may be either 2, 3 or 4; the default version is )2./\14./' - #./contrib/gcc_update --touch end

diff --git a/pakfire/pakfire.nm b/pakfire/pakfire.nm index ffd9cbc..b16f079 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 michael.tremer@ipfire.org 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 0000000..676f210 --- /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 michael.tremer@ipfire.org +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 michael.tremer@ipfire.org +--- + .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 alexl@redhat.com, 2002 +- Based on code by Jakub Jelinek jakub@redhat.com, 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 <assert.h> +-#include <byteswap.h> +-#include <endian.h> +-#include <errno.h> +-#include <error.h> +-#include <limits.h> +-#include <string.h> +-#include <stdlib.h> +-#include <unistd.h> +-#include <sys/types.h> +-#include <sys/stat.h> +-#include <fcntl.h> +-#include <popt.h> +- +-#include <gelf.h> +- +-/* 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 <beecrypt/beecrypt.h> +-#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 <sys/types.h> +-#include <stdlib.h> +-#include <string.h> +-#include <stdio.h> +-#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 +

hooks/post-receive -- IPFire 3.x development tree