diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/Makefile.am | 39 | ||||
| -rw-r--r-- | src/config.h | 94 | ||||
| -rw-r--r-- | src/cvtendian.h | 48 | ||||
| -rw-r--r-- | src/gettext.h | 271 | ||||
| -rw-r--r-- | src/libr-backends.h | 22 | ||||
| -rw-r--r-- | src/libr-bfd.c | 533 | ||||
| -rw-r--r-- | src/libr-bfd.h | 40 | ||||
| -rw-r--r-- | src/libr-elf.c | 412 | ||||
| -rw-r--r-- | src/libr-elf.h | 24 | ||||
| -rw-r--r-- | src/libr-gtk.c | 443 | ||||
| -rw-r--r-- | src/libr-gtk.h | 55 | ||||
| -rw-r--r-- | src/libr-i18n.c | 84 | ||||
| -rw-r--r-- | src/libr-i18n.h | 14 | ||||
| -rw-r--r-- | src/libr-icons.c | 643 | ||||
| -rw-r--r-- | src/libr-icons.h | 201 | ||||
| -rw-r--r-- | src/libr-internal.h | 34 | ||||
| -rw-r--r-- | src/libr-link.h | 26 | ||||
| -rw-r--r-- | src/libr-ro.c | 351 | ||||
| -rw-r--r-- | src/libr-ro.h | 62 | ||||
| -rw-r--r-- | src/libr.c | 489 | ||||
| -rw-r--r-- | src/libr.h | 416 | ||||
| -rw-r--r-- | src/onecanvas.c | 446 | ||||
| -rw-r--r-- | src/onecanvas.h | 6 | ||||
| -rw-r--r-- | src/tempfiles.c | 317 | ||||
| -rw-r--r-- | src/tempfiles.h | 13 |
25 files changed, 5083 insertions, 0 deletions
diff --git a/src/Makefile.am b/src/Makefile.am new file mode 100644 index 0000000..5fbf00b --- /dev/null +++ b/src/Makefile.am @@ -0,0 +1,39 @@ +libr_la_includedir = $(includedir)/libr +LIBTOOL_DEPS = @LIBTOOL_DEPS@ + +INCLUDES = \ + -D__LIBR_BACKEND_@BACKEND_NAME@__ \ + -D__LIBR_BUILD__ \ + @LIBGLADE_CFLAGS@ \ + @BACKEND_CFLAGS@ \ + @EXTRA_CFLAGS@ + +lib_LTLIBRARIES = \ + libr.la + +libr_la_SOURCES = \ + libr-@LIBR_BACKEND@.c \ + tempfiles.c \ + onecanvas.c \ + libr-icons.c \ + libr-i18n.c \ + libr-gtk.c \ + libr.c + +libr_la_include_HEADERS = \ + gettext.h \ + libr-icons.h \ + libr-i18n.h \ + libr-gtk.h \ + libr.h + +libr_la_LIBADD = \ + @BACKEND_LIBS@ \ + @EXTRA_LIBS@ + +# If not in a fakeroot environment then run ldconfig +install: install-am + @if [ ! -n "${FAKEROOTKEY}" ]; then \ + echo "Regenerating system dependencies..."; \ + ldconfig; \ + fi diff --git a/src/config.h b/src/config.h new file mode 100644 index 0000000..a51743e --- /dev/null +++ b/src/config.h @@ -0,0 +1,94 @@ +/* config.h. Generated from config.h.in by configure. */ +/* config.h.in. Generated from configure.ac by autoheader. */ + +/* Define to 1 if translation of program messages to the user's native + language is requested. */ +#define ENABLE_NLS 1 + +/* Define to 1 if you have the MacOS X function CFLocaleCopyCurrent in the + CoreFoundation framework. */ +/* #undef HAVE_CFLOCALECOPYCURRENT */ + +/* Define to 1 if you have the MacOS X function CFPreferencesCopyAppValue in + the CoreFoundation framework. */ +/* #undef HAVE_CFPREFERENCESCOPYAPPVALUE */ + +/* Define if the GNU dcgettext() function is already present or preinstalled. + */ +#define HAVE_DCGETTEXT 1 + +/* Define to 1 if you have the <dlfcn.h> header file. */ +#define HAVE_DLFCN_H 1 + +/* Define if the GNU gettext() function is already present or preinstalled. */ +#define HAVE_GETTEXT 1 + +/* Define if you have the iconv() function and it works. */ +/* #undef HAVE_ICONV */ + +/* Define to 1 if you have the <inttypes.h> header file. */ +#define HAVE_INTTYPES_H 1 + +/* Define to 1 if you have the <math.h> header file. */ +#define HAVE_MATH_H 1 + +/* Define to 1 if you have the <memory.h> header file. */ +#define HAVE_MEMORY_H 1 + +/* Define to 1 if you have the <pthread.h> header file. */ +#define HAVE_PTHREAD_H 1 + +/* Define to 1 if you have the <stdint.h> header file. */ +#define HAVE_STDINT_H 1 + +/* Define to 1 if you have the <stdlib.h> header file. */ +#define HAVE_STDLIB_H 1 + +/* Define to 1 if you have the <strings.h> header file. */ +#define HAVE_STRINGS_H 1 + +/* Define to 1 if you have the <string.h> header file. */ +#define HAVE_STRING_H 1 + +/* Define to 1 if you have the <sys/stat.h> header file. */ +#define HAVE_SYS_STAT_H 1 + +/* Define to 1 if you have the <sys/types.h> header file. */ +#define HAVE_SYS_TYPES_H 1 + +/* Define to 1 if you have the <unistd.h> header file. */ +#define HAVE_UNISTD_H 1 + +/* Define to 1 if you have the <zlib.h> header file. */ +#define HAVE_ZLIB_H 1 + +/* Define to the sub-directory in which libtool stores uninstalled libraries. + */ +#define LT_OBJDIR ".libs/" + +/* Name of package */ +#define PACKAGE "libr" + +/* Define to the address where bug reports for this package should be sent. */ +#define PACKAGE_BUGREPORT "" + +/* Define to the full name of this package. */ +#define PACKAGE_NAME "" + +/* Define to the full name and version of this package. */ +#define PACKAGE_STRING "" + +/* Define to the one symbol short name of this package. */ +#define PACKAGE_TARNAME "" + +/* Define to the home page for this package. */ +#define PACKAGE_URL "" + +/* Define to the version of this package. */ +#define PACKAGE_VERSION "" + +/* Define to 1 if you have the ANSI C header files. */ +#define STDC_HEADERS 1 + +/* Version number of package */ +#define VERSION "0.4.0" diff --git a/src/cvtendian.h b/src/cvtendian.h new file mode 100644 index 0000000..d69158b --- /dev/null +++ b/src/cvtendian.h @@ -0,0 +1,48 @@ +#ifndef __CVTENDIAN_H +#define __CVTENDIAN_H + +/* Support for swapping bytes (endian conversion) */ +#include <byteswap.h> + +/* For obtaining the host endian type */ +#include <endian.h> +#if (__BYTE_ORDER == __LITTLE_ENDIAN) +# define HOST_ENDIAN ELFDATA2LSB +#elif (__BYTE_ORDER == __BIG_ENDIAN) +# define HOST_ENDIAN ELFDATA2MSB +#else +# error "Failed to detect host endian type" +#endif + +/* + * Convert the endian of a parameter + */ +static int ConvertEndian(void *ptr, int bytes) +{ + switch(bytes) + { + case 2: + { + uint16_t *value = (uint16_t *) ptr; + + *value = bswap_16(*value); + } return 1; + case 4: + { + uint32_t *value = (uint32_t *) ptr; + + *value = bswap_32(*value); + } return 1; + case 8: + { + uint64_t *value = (uint64_t *) ptr; + + *value = bswap_64(*value); + } return 1; + default: + break; + } + return 0; +} + +#endif /* __CVTENDIAN_H */ diff --git a/src/gettext.h b/src/gettext.h new file mode 100644 index 0000000..209921e --- /dev/null +++ b/src/gettext.h @@ -0,0 +1,271 @@ +/* Convenience header for conditional use of GNU <libintl.h>. + Copyright (C) 1995-1998, 2000-2002, 2004-2006 Free Software Foundation, Inc. + + 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 + Library 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, + USA. */ + +#ifndef _LIBGETTEXT_H +#define _LIBGETTEXT_H 1 + +/* NLS can be disabled through the configure --disable-nls option. */ +#if ENABLE_NLS + +/* Get declarations of GNU message catalog functions. */ +# include <libintl.h> + +/* You can set the DEFAULT_TEXT_DOMAIN macro to specify the domain used by + the gettext() and ngettext() macros. This is an alternative to calling + textdomain(), and is useful for libraries. */ +# ifdef DEFAULT_TEXT_DOMAIN +# undef gettext +# define gettext(Msgid) \ + dgettext (DEFAULT_TEXT_DOMAIN, Msgid) +# undef ngettext +# define ngettext(Msgid1, Msgid2, N) \ + dngettext (DEFAULT_TEXT_DOMAIN, Msgid1, Msgid2, N) +# endif + +#else + +/* Solaris /usr/include/locale.h includes /usr/include/libintl.h, which + chokes if dcgettext is defined as a macro. So include it now, to make + later inclusions of <locale.h> a NOP. We don't include <libintl.h> + as well because people using "gettext.h" will not include <libintl.h>, + and also including <libintl.h> would fail on SunOS 4, whereas <locale.h> + is OK. */ +#if defined(__sun) +# include <locale.h> +#endif + +/* Many header files from the libstdc++ coming with g++ 3.3 or newer include + <libintl.h>, which chokes if dcgettext is defined as a macro. So include + it now, to make later inclusions of <libintl.h> a NOP. */ +#if defined(__cplusplus) && defined(__GNUG__) && (__GNUC__ >= 3) +# include <cstdlib> +# if (__GLIBC__ >= 2) || _GLIBCXX_HAVE_LIBINTL_H +# include <libintl.h> +# endif +#endif + +/* Disabled NLS. + The casts to 'const char *' serve the purpose of producing warnings + for invalid uses of the value returned from these functions. + On pre-ANSI systems without 'const', the config.h file is supposed to + contain "#define const". */ +# define gettext(Msgid) ((const char *) (Msgid)) +# define dgettext(Domainname, Msgid) ((void) (Domainname), gettext (Msgid)) +# define dcgettext(Domainname, Msgid, Category) \ + ((void) (Category), dgettext (Domainname, Msgid)) +# define ngettext(Msgid1, Msgid2, N) \ + ((N) == 1 \ + ? ((void) (Msgid2), (const char *) (Msgid1)) \ + : ((void) (Msgid1), (const char *) (Msgid2))) +# define dngettext(Domainname, Msgid1, Msgid2, N) \ + ((void) (Domainname), ngettext (Msgid1, Msgid2, N)) +# define dcngettext(Domainname, Msgid1, Msgid2, N, Category) \ + ((void) (Category), dngettext(Domainname, Msgid1, Msgid2, N)) +# define textdomain(Domainname) ((const char *) (Domainname)) +# define bindtextdomain(Domainname, Dirname) \ + ((void) (Domainname), (const char *) (Dirname)) +# define bind_textdomain_codeset(Domainname, Codeset) \ + ((void) (Domainname), (const char *) (Codeset)) + +#endif + +/* A pseudo function call that serves as a marker for the automated + extraction of messages, but does not call gettext(). The run-time + translation is done at a different place in the code. + The argument, String, should be a literal string. Concatenated strings + and other string expressions won't work. + The macro's expansion is not parenthesized, so that it is suitable as + initializer for static 'char[]' or 'const char[]' variables. */ +#define gettext_noop(String) String + +/* The separator between msgctxt and msgid in a .mo file. */ +#define GETTEXT_CONTEXT_GLUE "\004" + +/* Pseudo function calls, taking a MSGCTXT and a MSGID instead of just a + MSGID. MSGCTXT and MSGID must be string literals. MSGCTXT should be + short and rarely need to change. + The letter 'p' stands for 'particular' or 'special'. */ +#ifdef DEFAULT_TEXT_DOMAIN +# define pgettext(Msgctxt, Msgid) \ + pgettext_aux (DEFAULT_TEXT_DOMAIN, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, LC_MESSAGES) +#else +# define pgettext(Msgctxt, Msgid) \ + pgettext_aux (NULL, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, LC_MESSAGES) +#endif +#define dpgettext(Domainname, Msgctxt, Msgid) \ + pgettext_aux (Domainname, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, LC_MESSAGES) +#define dcpgettext(Domainname, Msgctxt, Msgid, Category) \ + pgettext_aux (Domainname, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, Category) +#ifdef DEFAULT_TEXT_DOMAIN +# define npgettext(Msgctxt, Msgid, MsgidPlural, N) \ + npgettext_aux (DEFAULT_TEXT_DOMAIN, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, MsgidPlural, N, LC_MESSAGES) +#else +# define npgettext(Msgctxt, Msgid, MsgidPlural, N) \ + npgettext_aux (NULL, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, MsgidPlural, N, LC_MESSAGES) +#endif +#define dnpgettext(Domainname, Msgctxt, Msgid, MsgidPlural, N) \ + npgettext_aux (Domainname, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, MsgidPlural, N, LC_MESSAGES) +#define dcnpgettext(Domainname, Msgctxt, Msgid, MsgidPlural, N, Category) \ + npgettext_aux (Domainname, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, MsgidPlural, N, Category) + +#ifdef __GNUC__ +__inline +#else +#ifdef __cplusplus +inline +#endif +#endif +static const char * +pgettext_aux (const char *domain, + const char *msg_ctxt_id, const char *msgid, + int category) +{ + const char *translation = dcgettext (domain, msg_ctxt_id, category); + if (translation == msg_ctxt_id) + return msgid; + else + return translation; +} + +#ifdef __GNUC__ +__inline +#else +#ifdef __cplusplus +inline +#endif +#endif +static const char * +npgettext_aux (const char *domain, + const char *msg_ctxt_id, const char *msgid, + const char *msgid_plural, unsigned long int n, + int category) +{ + const char *translation = + dcngettext (domain, msg_ctxt_id, msgid_plural, n, category); + if (translation == msg_ctxt_id || translation == msgid_plural) + return (n == 1 ? msgid : msgid_plural); + else + return translation; +} + +/* The same thing extended for non-constant arguments. Here MSGCTXT and MSGID + can be arbitrary expressions. But for string literals these macros are + less efficient than those above. */ + +#include <string.h> + +#define _LIBGETTEXT_HAVE_VARIABLE_SIZE_ARRAYS \ + (((__GNUC__ >= 3 || __GNUG__ >= 2) && !__STRICT_ANSI__) \ + /* || __STDC_VERSION__ >= 199901L */ ) + +#if !_LIBGETTEXT_HAVE_VARIABLE_SIZE_ARRAYS +#include <stdlib.h> +#endif + +#define pgettext_expr(Msgctxt, Msgid) \ + dcpgettext_expr (NULL, Msgctxt, Msgid, LC_MESSAGES) +#define dpgettext_expr(Domainname, Msgctxt, Msgid) \ + dcpgettext_expr (Domainname, Msgctxt, Msgid, LC_MESSAGES) + +#ifdef __GNUC__ +__inline +#else +#ifdef __cplusplus +inline +#endif +#endif +static const char * +dcpgettext_expr (const char *domain, + const char *msgctxt, const char *msgid, + int category) +{ + size_t msgctxt_len = strlen (msgctxt) + 1; + size_t msgid_len = strlen (msgid) + 1; + const char *translation; +#if _LIBGETTEXT_HAVE_VARIABLE_SIZE_ARRAYS + char msg_ctxt_id[msgctxt_len + msgid_len]; +#else + char buf[1024]; + char *msg_ctxt_id = + (msgctxt_len + msgid_len <= sizeof (buf) + ? buf + : (char *) malloc (msgctxt_len + msgid_len)); + if (msg_ctxt_id != NULL) +#endif + { + memcpy (msg_ctxt_id, msgctxt, msgctxt_len - 1); + msg_ctxt_id[msgctxt_len - 1] = '\004'; + memcpy (msg_ctxt_id + msgctxt_len, msgid, msgid_len); + translation = dcgettext (domain, msg_ctxt_id, category); +#if !_LIBGETTEXT_HAVE_VARIABLE_SIZE_ARRAYS + if (msg_ctxt_id != buf) + free (msg_ctxt_id); +#endif + if (translation != msg_ctxt_id) + return translation; + } + return msgid; +} + +#define npgettext_expr(Msgctxt, Msgid, MsgidPlural, N) \ + dcnpgettext_expr (NULL, Msgctxt, Msgid, MsgidPlural, N, LC_MESSAGES) +#define dnpgettext_expr(Domainname, Msgctxt, Msgid, MsgidPlural, N) \ + dcnpgettext_expr (Domainname, Msgctxt, Msgid, MsgidPlural, N, LC_MESSAGES) + +#ifdef __GNUC__ +__inline +#else +#ifdef __cplusplus +inline +#endif +#endif +static const char * +dcnpgettext_expr (const char *domain, + const char *msgctxt, const char *msgid, + const char *msgid_plural, unsigned long int n, + int category) +{ + size_t msgctxt_len = strlen (msgctxt) + 1; + size_t msgid_len = strlen (msgid) + 1; + const char *translation; +#if _LIBGETTEXT_HAVE_VARIABLE_SIZE_ARRAYS + char msg_ctxt_id[msgctxt_len + msgid_len]; +#else + char buf[1024]; + char *msg_ctxt_id = + (msgctxt_len + msgid_len <= sizeof (buf) + ? buf + : (char *) malloc (msgctxt_len + msgid_len)); + if (msg_ctxt_id != NULL) +#endif + { + memcpy (msg_ctxt_id, msgctxt, msgctxt_len - 1); + msg_ctxt_id[msgctxt_len - 1] = '\004'; + memcpy (msg_ctxt_id + msgctxt_len, msgid, msgid_len); + translation = dcngettext (domain, msg_ctxt_id, msgid_plural, n, category); +#if !_LIBGETTEXT_HAVE_VARIABLE_SIZE_ARRAYS + if (msg_ctxt_id != buf) + free (msg_ctxt_id); +#endif + if (!(translation == msg_ctxt_id || translation == msgid_plural)) + return translation; + } + return (n == 1 ? msgid : msgid_plural); +} + +#endif /* _LIBGETTEXT_H */ diff --git a/src/libr-backends.h b/src/libr-backends.h new file mode 100644 index 0000000..a0cd59c --- /dev/null +++ b/src/libr-backends.h @@ -0,0 +1,22 @@ +#ifndef __LIBR_BACKENDS_H +#define __LIBR_BACKENDS_H + +/* + * All of the backend functions are explicitly declared internal to prevent any custom backend + * from leaving out one of these critical functions. + */ +INTERNAL_FN libr_intstatus add_section(libr_file *file_handle, char *resource_name, libr_section **retscn); +INTERNAL_FN void *data_pointer(libr_section *scn, libr_data *data); +INTERNAL_FN size_t data_size(libr_section *scn, libr_data *data); +INTERNAL_FN libr_intstatus find_section(libr_file *file_handle, char *section, libr_section **retscn); +INTERNAL_FN libr_data *get_data(libr_file *file_handle, libr_section *scn); +INTERNAL_FN void initialize_backend(void); +INTERNAL_FN libr_data *new_data(libr_file *file_handle, libr_section *scn); +INTERNAL_FN libr_section *next_section(libr_file *file_handle, libr_section *scn); +INTERNAL_FN libr_intstatus remove_section(libr_file *file_handle, libr_section *scn); +INTERNAL_FN char *section_name(libr_file *file_handle, libr_section *scn); +INTERNAL_FN libr_intstatus set_data(libr_file *file_handle, libr_section *scn, libr_data *data, off_t offset, char *buffer, size_t size); +INTERNAL_FN libr_intstatus open_handles(libr_file *file_handle, char *filename, libr_access_t access); +INTERNAL_FN void write_output(libr_file *file_handle); + +#endif /* __LIBR_BACKENDS_H */ diff --git a/src/libr-bfd.c b/src/libr-bfd.c new file mode 100644 index 0000000..c4bc8b1 --- /dev/null +++ b/src/libr-bfd.c @@ -0,0 +1,533 @@ +/* + * + * Copyright (c) 2008-2011 Erich Hoover + * + * libr libbfd Backend - Add resources into ELF binaries using libbfd + * + * *** PLEASE READ THE README FILE FOR LICENSE DETAILS SPECIFIC TO THIS FILE *** + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser 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 + * + * To provide feedback, report bugs, or otherwise contact me: + * ehoover at mines dot edu + * + */ + +/* Include compile-time parameters */ +#include "config.h" + +#include "libr.h" +#include "libr-internal.h" + +/* File access */ +#include <fcntl.h> + +/* Safe rename requires some errno() knowledge */ +#include <errno.h> + +#include <sys/stat.h> +#include <string.h> +#include <unistd.h> +#include <stdlib.h> +#include <stdio.h> + +/* + * Build the libr_file handle for processing with libbfd + */ +libr_intstatus open_handles(libr_file *file_handle, char *filename, libr_access_t access) +{ + bfd *handle = NULL; + + handle = bfd_openr(filename, "default"); + if(!handle) + RETURN(LIBR_ERROR_OPENFAILED, "Failed to open input file"); + if(!bfd_check_format(handle, bfd_object)) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: not a libbfd object"); + if(bfd_get_flavour(handle) != bfd_target_elf_flavour) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: not an ELF file"); + bfd_set_error(bfd_error_no_error); + file_handle->filename = filename; + file_handle->bfd_read = handle; + file_handle->access = access; + if(access == LIBR_READ_WRITE) + { + struct stat file_stat; + int fd; + + /* Check for write permission on the file */ + fd = open(filename, O_WRONLY); + if(fd == ERROR) + RETURN(LIBR_ERROR_WRITEPERM, "No write permission for file"); + close(fd); + /* Obtain the access mode of the input file */ + if(stat(filename, &file_stat) == ERROR) + RETURN(LIBR_ERROR_NOSIZE, "Failed to obtain file size"); + file_handle->filemode = file_stat.st_mode; + file_handle->fileowner = file_stat.st_uid; + file_handle->filegroup = file_stat.st_gid; + /* Open a temporary file with the same settings as the input file */ + strcpy(file_handle->tempfile, LIBR_TEMPFILE); + file_handle->fd_handle = mkstemp(file_handle->tempfile); + handle = bfd_openw(file_handle->tempfile, bfd_get_target(file_handle->bfd_read)); + if(!bfd_set_format(handle, bfd_get_format(file_handle->bfd_read))) + RETURN(LIBR_ERROR_SETFORMAT, "Failed to set output file format to input file format"); + if(!bfd_set_arch_mach(handle, bfd_get_arch(file_handle->bfd_read), bfd_get_mach(file_handle->bfd_read))) + RETURN(LIBR_ERROR_SETARCH, "Failed to set output file architecture to input file architecture"); + /* twice needed ? */ + if(!bfd_set_format(handle, bfd_get_format(file_handle->bfd_read))) + RETURN(LIBR_ERROR_SETFORMAT, "Failed to set output file format to input file format"); + file_handle->bfd_write = handle; + } + else + { + file_handle->fd_handle = 0; + file_handle->bfd_write = NULL; + } + RETURN_OK; +} + +/* + * Check to see if a symbol should be kept + */ +int keep_symbol(libr_section *sections, libr_section *chkscn) +{ + libr_section *scn; + + /* Check that the section is publicly exposed */ + for(scn = sections; scn != NULL; scn = scn->next) + { + if(scn == chkscn) + { + /* if it is, and has size zero, then it was marked for deletion */ + if(bfd_get_section_size(chkscn) == 0) + return false; + return true; + } + } + return true; +} + +/* + * Remove the symbol corresponding to a deleted section + */ +void remove_sections(libr_section *sections, void *symtab_buffer, long *symtab_count) +{ + asymbol **symtab = (asymbol **) symtab_buffer; + long i, cnt = *symtab_count; + + for(i=0;i<cnt;i++) + { + libr_section *chkscn = NULL; + asymbol *symbol = symtab[i]; + + if(symbol != NULL) + chkscn = bfd_get_section(symbol); + if(chkscn != NULL && !keep_symbol(sections, chkscn)) + { + /* remove the symbol from the table */ + asymbol **tmp = (asymbol **) malloc(sizeof(asymbol *) * (cnt-(i+1))); + memcpy(&tmp[0], &symtab[i+1], sizeof(asymbol *) * (cnt-(i+1))); + memcpy(&symtab[i], &tmp[0], sizeof(asymbol *) * (cnt-(i+1))); + free(tmp); + cnt--; + } + } + *symtab_count = cnt; +} + +int setup_sections(bfd *ihandle, bfd *ohandle) +{ + libr_section *iscn, *oscn; + bfd_vma vma; + + for(iscn = ihandle->sections; iscn != NULL; iscn = iscn->next) + { + if(bfd_get_section_size(iscn) == 0) + { + continue; /* Section has been marked for deletion */ + } + /* Use SEC_LINKER_CREATED to ask the libbfd backend to take care of configuring the section */ + + // Keep the ARM_ATTRIBUTES section type intact on armhf systems + // If this is not done, readelf -A will not print any architecture information for the modified library, + // and ldd will report that the library cannot be found + if (strcmp(iscn->name, ".ARM.attributes") == 0) + { + oscn = bfd_make_section_anyway_with_flags(ohandle, iscn->name, iscn->flags); + } + else + { + oscn = bfd_make_section_anyway_with_flags(ohandle, iscn->name, iscn->flags | SEC_LINKER_CREATED); + } + if(oscn == NULL) + { + printf("failed to create out section: %s\n", bfd_errmsg(bfd_get_error())); + return false; + } + if(!bfd_set_section_size(ohandle, oscn, iscn->size)) + { + printf("failed to set data size: %s\n", bfd_errmsg(bfd_get_error())); + return false; + } + vma = bfd_section_vma(ihandle, iscn); + if(!bfd_set_section_vma(ohandle, oscn, vma)) + { + printf("failed to set virtual memory address: %s\n", bfd_errmsg(bfd_get_error())); + return false; + } + oscn->lma = iscn->lma; + if(!bfd_set_section_alignment(ohandle, oscn, bfd_section_alignment(ihandle, iscn))) + { + printf("failed to compute section alignment: %s\n", bfd_errmsg(bfd_get_error())); + return false; + } + oscn->entsize = iscn->entsize; + iscn->output_section = oscn; + iscn->output_offset = vma; + if(!bfd_copy_private_section_data(ihandle, iscn, ohandle, oscn)) + { + printf("failed to compute section alignment: %s\n", bfd_errmsg(bfd_get_error())); + return false; + } + } + return true; +} + +/* + * Go through the rather complicated process of using libbfd to build the output file + */ +int build_output(libr_file *file_handle) +{ + void *symtab_buffer = NULL, *reloc_buffer = NULL, *buffer = NULL; + bfd_size_type symtab_size, reloc_size, size; + bfd *ohandle = file_handle->bfd_write; + bfd *ihandle = file_handle->bfd_read; + long symtab_count, reloc_count; + libr_section *iscn, *oscn; + + if(!bfd_set_start_address(ohandle, bfd_get_start_address(ihandle))) + { + printf("failed to set start address: %s\n", bfd_errmsg(bfd_get_error())); + return false; + } + if(!bfd_set_file_flags(ohandle, bfd_get_file_flags(ihandle))) + { + printf("failed to set file flags: %s\n", bfd_errmsg(bfd_get_error())); + return false; + } + /* Setup the sections in the output file */ + if(!setup_sections(ihandle, ohandle)) + return false; /* error already printed */ + if(!bfd_copy_private_header_data(ihandle, ohandle)) + { + printf("failed to copy header: %s\n", bfd_errmsg(bfd_get_error())); + return false; /* failed to create section */ + } + /* Get the old symbol table */ + if((bfd_get_file_flags(ihandle) & HAS_SYMS) == 0) + { + printf("file has no symbol table: %s\n", bfd_errmsg(bfd_get_error())); + return false; + } + symtab_size = bfd_get_symtab_upper_bound(ihandle); + if((signed)symtab_size < 0) + { + printf("failed to get symbol table size: %s\n", bfd_errmsg(bfd_get_error())); + return false; + } + symtab_buffer = malloc(symtab_size); + symtab_count = bfd_canonicalize_symtab(ihandle, symtab_buffer); + if(symtab_count < 0) + { + printf("failed to get symbol table number of entries: %s\n", bfd_errmsg(bfd_get_error())); + return false; + } + /* Tweak the symbol table to remove sections that no-longer exist */ + remove_sections(ihandle->sections, symtab_buffer, &symtab_count); + bfd_set_symtab(ohandle, symtab_buffer, symtab_count); + /* Actually copy section data */ + for(iscn = ihandle->sections; iscn != NULL; iscn = iscn->next) + { + size = bfd_get_section_size(iscn); + if(size == 0) + continue; /* Section has been marked for deletion */ + oscn = iscn->output_section; + reloc_size = bfd_get_reloc_upper_bound(ihandle, iscn); + if(reloc_size == 0) + bfd_set_reloc(ohandle, oscn, NULL, 0); + else + { + reloc_buffer = malloc(reloc_size); + reloc_count = bfd_canonicalize_reloc(ihandle, iscn, reloc_buffer, symtab_buffer); + bfd_set_reloc(ohandle, oscn, reloc_buffer, reloc_count); + } + + if(bfd_get_section_flags(ihandle, iscn) & SEC_HAS_CONTENTS) + { + /* NOTE: if the section is just being copied then do that, otherwise grab + * the user data for the section (stored previously by set_data) + */ + if(iscn->userdata == NULL) + { + buffer = malloc(size); + if(!bfd_get_section_contents(ihandle, iscn, buffer, 0, size)) + { + printf("failed to get section contents: %s\n", bfd_errmsg(bfd_get_error())); + free(buffer); + return false; + } + } + else + buffer = iscn->userdata; + if(!bfd_set_section_contents(ohandle, oscn, buffer, 0, size)) + { + printf("failed to set section contents: %s\n", bfd_errmsg(bfd_get_error())); + free(buffer); + return false; + } + free(buffer); + if(!bfd_copy_private_section_data(ihandle, iscn, ohandle, oscn)) + { + printf("failed to copy private section data: %s\n", bfd_errmsg(bfd_get_error())); + return false; + } + } + } + if(!bfd_copy_private_bfd_data(ihandle, ohandle)) + { + printf("failed to copy private data: %s\n", bfd_errmsg(bfd_get_error())); + return false; + } + return true; +} + +/* + * Perform a cross-device safe rename + */ +int safe_rename(const char *old, const char *new) +{ + char buffer[1024]; + FILE *in, *out; + int read; + + in = fopen(old, "r"); + if(!in) + return -1; + out = fopen(new, "w"); + if(!out) + return -1; + while(!feof(in) && !ferror(in)) + { + read = fread(buffer, 1, sizeof(buffer), in); + fwrite(buffer, read, 1, out); + } + fclose(in); + fclose(out); + if(ferror(in)) + { + remove(new); + return -1; + } + return remove(old); +} + +/* + * Write the output file using the libbfd method + */ +void write_output(libr_file *file_handle) +{ + int write_ok = false; + + if(file_handle->bfd_write != NULL) + { + write_ok = true; + if(!build_output(file_handle)) + { + printf("failed to build output file.\n"); + write_ok = false; + } + if(!bfd_close(file_handle->bfd_write)) + { + printf("failed to close write handle.\n"); + write_ok = false; + } + if(file_handle->fd_handle != 0 && close(file_handle->fd_handle)) + { + write_ok = false; + printf("failed to close write file descriptor.\n"); + } + } + /* The read handle must be closed last since it is used in the write process */ + if(!bfd_close(file_handle->bfd_read)) + printf("failed to close read handle.\n"); + /* Copy the temporary output over the input */ + if(write_ok) + { + if(rename(file_handle->tempfile, file_handle->filename) < 0) + { + if(errno != EXDEV || safe_rename(file_handle->tempfile, file_handle->filename) < 0) + printf("failed to rename output file: %m\n"); + } + if(chmod(file_handle->filename, file_handle->filemode) < 0) + printf("failed to set file mode.\n"); + if(chown(file_handle->filename, file_handle->fileowner, file_handle->filegroup) < 0) + printf("failed to set file ownership.\n"); + } +} + +/* + * Find a named section from the ELF file using libbfd + */ +libr_intstatus find_section(libr_file *file_handle, char *section_name, libr_section **retscn) +{ + libr_section *scn; + + for(scn = file_handle->bfd_read->sections; scn != NULL; scn = scn->next) + { + if(strcmp(scn->name, section_name) == 0) + { + *retscn = scn; + RETURN_OK; + } + } + RETURN(LIBR_ERROR_NOSECTION, "ELF resource section not found"); +} + +/* + * Obtain the data from a section using libbfd + */ +libr_data *get_data(libr_file *file_handle, libr_section *scn) +{ + libr_data *data = malloc(scn->size); + + if(!bfd_get_section_contents(file_handle->bfd_read, scn, data, 0, scn->size)) + { + free(data); + data = NULL; + } + scn->userdata = data; + return data; +} + +/* + * Create new data for a section using libbfd + */ +libr_data *new_data(libr_file *file_handle, libr_section *scn) +{ + /* NOTE: expanding data is handled by set_data for libbfd */ + if(scn->userdata != NULL) + return scn->userdata; + scn->size = 0; + scn->userdata = malloc(0); + return scn->userdata; +} + +/* + * Create new data for a section using libbfd (at least, do so memory-wise) + */ +libr_intstatus set_data(libr_file *file_handle, libr_section *scn, libr_data *data, off_t offset, char *buffer, size_t size) +{ + char *intbuffer = NULL; + + /* special case: clear buffer */ + if(buffer == NULL) + { + scn->size = 0; + if(scn->userdata != NULL) + free(scn->userdata); + RETURN_OK; + } + /* normal case: add new data to the buffer */ + scn->size = offset + size; + scn->userdata = realloc(data, scn->size); + if(scn->userdata == NULL) + RETURN(LIBR_ERROR_MEMALLOC, "Failed to allocate memory for data"); + intbuffer = scn->userdata; + memcpy(&intbuffer[offset], buffer, size); + RETURN_OK; +} + +/* + * Create a new section using libbfd + */ +libr_intstatus add_section(libr_file *file_handle, char *resource_name, libr_section **retscn) +{ + libr_section *scn = NULL; + + scn = bfd_make_section(file_handle->bfd_read, resource_name); + if(scn == NULL) + RETURN(LIBR_ERROR_NEWSECTION, "Failed to create new section"); + if(!bfd_set_section_flags(file_handle->bfd_read, scn, SEC_HAS_CONTENTS | SEC_DATA | SEC_IN_MEMORY)) + RETURN(LIBR_ERROR_SETFLAGS, "Failed to set flags for section"); + *retscn = scn; + RETURN_OK; +} + +/* + * Remove a section and eliminate it from the ELF string table using libbfd + */ +libr_intstatus remove_section(libr_file *file_handle, libr_section *scn) +{ + scn->size = 0; + RETURN_OK; +} + +/* + * Return the pointer to the actual data in the section + */ +void *data_pointer(libr_section *scn, libr_data *data) +{ + return data; +} + +/* + * Return the size of the data in the section + */ +size_t data_size(libr_section *scn, libr_data *data) +{ + return scn->size; +} + +/* + * Return the next section in the ELF file + */ +libr_section *next_section(libr_file *file_handle, libr_section *scn) +{ + /* get the first section */ + if(scn == NULL) + { + if(file_handle->bfd_read == NULL) + return NULL; + return file_handle->bfd_read->sections; + } + return scn->next; +} + +/* + * Return the name of a section + */ +char *section_name(libr_file *file_handle, libr_section *scn) +{ + return (char *) scn->name; +} + +/* + * Initialize libbfd + */ +void initialize_backend(void) +{ + bfd_init(); +} + diff --git a/src/libr-bfd.h b/src/libr-bfd.h new file mode 100644 index 0000000..7b6ea3e --- /dev/null +++ b/src/libr-bfd.h @@ -0,0 +1,40 @@ +#ifndef __LIBR_BFD_H +#define __LIBR_BFD_H + +#include "config.h" + +#include <sys/types.h> +#include <stdint.h> +#include <bfd.h> + +#if BFD_HOST_64BIT_LONG + #if defined(__i386) + #error "Using incorrect binutils header file for architecture." + #endif +#else + #if defined(__amd64) + #error "Using incorrect binutils header file for architecture." + #endif +#endif + +#ifndef DOXYGEN_SHOULD_SKIP_THIS + +typedef struct _libr_file { + int fd_handle; + bfd *bfd_read; + bfd *bfd_write; + char *filename; + mode_t filemode; + uid_t fileowner; + gid_t filegroup; + char tempfile[LIBR_TEMPFILE_LEN]; + libr_access_t access; +} libr_file; + +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + +/* for a clean internal API */ +typedef asection libr_section; +typedef void libr_data; + +#endif /* __LIBR_BFD_H */ diff --git a/src/libr-elf.c b/src/libr-elf.c new file mode 100644 index 0000000..be2daae --- /dev/null +++ b/src/libr-elf.c @@ -0,0 +1,412 @@ +/* + * + * Copyright (c) 2008 Erich Hoover + * + * libr libelf Backend - Add resources into ELF binaries using libelf + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 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 + * + * To provide feedback, report bugs, or otherwise contact me: + * ehoover at mines dot edu + * + */ + +/* Include compile-time parameters */ +#include "config.h" + +#include "libr.h" + +#include <sys/stat.h> +#include <string.h> +#include <unistd.h> +#include <stdlib.h> +#include <stdio.h> +#include <fcntl.h> + +//#define MANUAL_LAYOUT true + +extern void libr_set_error(libr_intstatus error); + +/* + * Write the output file using libelf + */ +void write_output(libr_file *file_handle) +{ + /* Update the ELF file on the disk */ + if(elf_update(file_handle->elf_handle, ELF_C_NULL) < 0) + { + printf("elf_update() failed: %s.", elf_errmsg(-1)); + return; + } + if(elf_update(file_handle->elf_handle, ELF_C_WRITE) < 0) + { + printf("elf_update() failed: %s.", elf_errmsg(-1)); + return; + } + /* Close the handles */ + elf_end(file_handle->elf_handle); + close(file_handle->fd_handle); +} + +/* + * Return the size of the file represented by the file descriptor + */ +off_t file_size(int fd) +{ + struct stat file_stat; + + if(fstat(fd, &file_stat) == ERROR) + return ERROR; + return file_stat.st_size; +} + +/* + * Open the handles for working with the file using libelf + */ +libr_intstatus open_handles(libr_file *file_handle, char *filename, libr_access_t access) +{ + const int elf_access[2] = {ELF_C_READ, ELF_C_RDWR}; + const int fd_access[2] = {O_RDONLY, O_RDWR}; + Elf *e = NULL; + int fd = 0; + + if((fd = open(filename, fd_access[access], 0)) < 0) + RETURN(LIBR_ERROR_OPENFAILED, "Failed to open input file"); + if((e = elf_begin(fd, elf_access[access], NULL)) == NULL) + RETURN(LIBR_ERROR_BEGINFAILED, "Failed to open ELF file: %s.", elf_errmsg(-1)); + if(elf_kind(e) != ELF_K_ELF) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format"); + + file_handle->access = access; + file_handle->fd_handle = fd; + file_handle->elf_handle = e; + file_handle->file_size = file_size(fd); + file_handle->version = EV_CURRENT; /* This should probably match the rest of the file */ + RETURN_OK; +} + +/* + * Expand a section + * (Only used when manually controlling ELF layout) + */ +#ifdef MANUAL_LAYOUT +libr_intstatus expand_section(Elf *e, Elf_Scn *scn, size_t size, int reset) +{ + size_t offset = 0, delta = 0; + Elf_Scn *tmpscn = NULL; + GElf_Shdr shdr; + + if(gelf_getshdr(scn, &shdr) != &shdr) + RETURN(LIBR_INTERROR_GETSHDR, "Failed to obtain ELF header: %s", elf_errmsg(-1)); + if(reset) + { + delta = (size-shdr.sh_size); + shdr.sh_size = size; + } + else + { + delta = size; + shdr.sh_size += size; + } + offset = shdr.sh_offset; + if(gelf_update_shdr(scn, &shdr) < 0) + RETURN(LIBR_ERROR_UPDATE, "Failed to perform dynamic update: %s.", elf_errmsg(-1)); + if(elf_update(e, ELF_C_NULL) < 0) + RETURN(LIBR_ERROR_UPDATE, "Failed to perform dynamic update: %s.", elf_errmsg(-1)); + /* Update any section that follows this one data-wise */ +/* +****** This does not work yet + while((tmpscn = elf_nextscn(e, tmpscn)) != NULL) + { + if(tmpscn == scn) + continue; + if(gelf_getshdr(tmpscn, &shdr) != &shdr) + return LIBR_INTERROR_GETSHDR; + if(offset < shdr.sh_offset) + { + if((name = elf_strptr(e, ehdr.e_shstrndx, shdr.sh_name)) == NULL) + RETURN(LIBR_ERROR_STRPTR, "Failed to obtain section string pointer: %s.", elf_errmsg(-1)); + shdr.sh_offset += delta; + if(gelf_update_shdr(tmpscn, &shdr) < 0) + RETURN(LIBR_ERROR_UPDATE, "Failed to perform dynamic update: %s.", elf_errmsg(-1)); + if(elf_update(e, ELF_C_NULL) < 0) + RETURN(LIBR_ERROR_UPDATE, "Failed to perform dynamic update: %s.", elf_errmsg(-1)); + } + } +*/ + return LIBR_OK; +} +#endif /* MANUAL_LAYOUT */ + +/* + * Obtain the data from a section using libelf + */ +libr_data *get_data(libr_file *file_handle, libr_section *scn) +{ + return elf_getdata(scn, NULL); +} + +/* + * Create new data for a section using libelf + */ +libr_data *new_data(libr_file *file_handle, libr_section *scn) +{ + return elf_newdata(scn); +} + +/* + * Set data for a section using libelf (not written yet) + */ +libr_intstatus set_data(libr_file *file_handle, libr_section *scn, libr_data *data, off_t offset, char *buffer, size_t size) +{ + data->d_align = 1; + data->d_off = offset; + data->d_buf = buffer; + data->d_type = ELF_T_BYTE; + data->d_size = size; + data->d_version = file_handle->version; +#ifdef MANUAL_LAYOUT + if(expand_section(file_handle->elf_handle, scn, data->d_size, true) != LIBR_OK) + RETURN(LIBR_ERROR_EXPANDSECTION, "Failed to expand section"); +#else + if(elf_update(file_handle->elf_handle, ELF_C_NULL) < 0) + RETURN(LIBR_ERROR_UPDATE, "Failed to perform dynamic update: %s.", elf_errmsg(-1)); + if(elf_update(file_handle->elf_handle, ELF_C_WRITE) < 0) + RETURN(LIBR_ERROR_UPDATE, "Failed to perform dynamic update: %s.", elf_errmsg(-1)); +#endif /* MANUAL_LAYOUT */ + RETURN_OK; +} + +/* + * Find a named section from the ELF file using libelf + */ +libr_intstatus find_section(libr_file *file_handle, char *section, libr_section **retscn) +{ + Elf *e = file_handle->elf_handle; + Elf_Scn *scn = NULL; + char *name = NULL; + GElf_Ehdr ehdr; + GElf_Shdr shdr; + uintmax_t si; + + if(gelf_getehdr(e, &ehdr) == NULL) + RETURN(LIBR_ERROR_GETEHDR, "Failed to obtain ELF header: %s", elf_errmsg(-1)); + while((scn = elf_nextscn(e, scn)) != NULL) + { + if(gelf_getshdr(scn, &shdr) != &shdr) + RETURN(LIBR_ERROR_GETSHDR, "Failed to obtain ELF section header: %s", elf_errmsg(-1)); + if((name = elf_strptr(e, ehdr.e_shstrndx, shdr.sh_name)) == NULL) + RETURN(LIBR_ERROR_STRPTR, "Failed to obtain section string pointer: %s.", elf_errmsg(-1)); + + si = (uintmax_t) elf_ndxscn(scn); +/* +printf("%d: %s (%d %d)\n", (long) si, name, (long) shdr.sh_offset, (long) shdr.sh_size); +*/ + if(strcmp(name, section) == 0) + { + *retscn = scn; + RETURN_OK; + } + } + RETURN(LIBR_ERROR_NOSECTION, "ELF resource section not found"); +} + +/* + * Add a new section and create a name for it in the ELF string table using libelf + */ +libr_intstatus add_section(libr_file *file_handle, char *section, Elf_Scn **retscn) +{ + Elf_Scn *scn = NULL, *strscn = NULL; + Elf *e = file_handle->elf_handle; +#ifdef MANUAL_LAYOUT + size_t tblsize = 0; +#endif /* MANUAL_LAYOUT */ + Elf_Data *data; + GElf_Ehdr ehdr; + GElf_Shdr shdr; + + if(gelf_getehdr(e, &ehdr) == NULL) + RETURN(LIBR_ERROR_GETEHDR, "Failed to obtain ELF header: %s", elf_errmsg(-1)); + /* TODO: Support creating a string table for objects that don't have one */ + if(!ehdr.e_shstrndx) + RETURN(LIBR_ERROR_NOTABLE, "No ELF string table"); + strscn = elf_getscn(e, ehdr.e_shstrndx); + if(strscn == NULL) + RETURN(LIBR_ERROR_TABLE, "Failed to open string table: %s.", elf_errmsg(-1)); + data = elf_newdata(strscn); + if(data == NULL) + RETURN(LIBR_ERROR_NEWDATA, "Failed to create data for section"); + data->d_align = 1; + +#ifdef MANUAL_LAYOUT +{ + GElf_Shdr strshdr; + + if(gelf_getshdr(strscn, &strshdr) != &strshdr) + RETURN(LIBR_ERROR_GETSHDR, "Failed to obtain ELF section header: %s", elf_errmsg(-1)); + data->d_off = strshdr.sh_size; +#endif /* MANUAL_LAYOUT */ + + data->d_size = (size_t) strlen(section)+1; + data->d_type = ELF_T_BYTE; + data->d_buf = section; + data->d_version = file_handle->version; + +#ifdef MANUAL_LAYOUT + if(expand_section(e, strscn, data->d_size, false) != LIBR_OK) + return false; +} +#else + /* Update the internal offset information */ + if(elf_update(e, ELF_C_NULL) < 0) + RETURN(LIBR_ERROR_UPDATE, "Failed to perform dynamic update: %s.", elf_errmsg(-1)); +#endif /* MANUAL_LAYOUT */ + + /* seek to the end of the section data */ + if((scn = elf_newscn(e)) == NULL) + RETURN(LIBR_ERROR_NEWSECTION, "Failed to create new section"); + if(gelf_getshdr(scn, &shdr) != &shdr) + RETURN(LIBR_ERROR_GETSHDR, "Failed to obtain ELF section header: %s", elf_errmsg(-1)); + shdr.sh_addralign = 1; +#ifdef MANUAL_LAYOUT + shdr.sh_offset = file_handle->file_size; +#endif /* MANUAL_LAYOUT */ + shdr.sh_size = 0; + shdr.sh_name = data->d_off; + shdr.sh_type = SHT_NOTE; /* TODO: Does "NOTE" type fit best? */ + shdr.sh_flags = SHF_WRITE; + shdr.sh_entsize = 0; + if(gelf_update_shdr(scn, &shdr) < 0) + RETURN(LIBR_ERROR_UPDATE, "Failed to perform dynamic update: %s.", elf_errmsg(-1)); + *retscn = scn; + RETURN_OK; +} + +/* + * Remove a section and eliminate it from the ELF string table using libelf + */ +libr_intstatus remove_section(libr_file *file_handle, libr_section *scn) +{ + unsigned int table_size, str_size; + char *buffer = NULL, *tmp = NULL; + Elf *e = file_handle->elf_handle; + int remaining_size; + Elf_Scn *strscn; + Elf_Data *data; + GElf_Ehdr ehdr; + GElf_Shdr shdr; + + if(gelf_getehdr(e, &ehdr) == NULL) + RETURN(LIBR_ERROR_GETEHDR, "Failed to obtain ELF header: %s", elf_errmsg(-1)); + /* Grab the string table */ + if(!ehdr.e_shstrndx) + RETURN(LIBR_ERROR_NOTABLE, "No ELF string table"); + strscn = elf_getscn(e, ehdr.e_shstrndx); + if(strscn == NULL) + RETURN(LIBR_ERROR_TABLE, "Failed to open string table: %s.", elf_errmsg(-1)); + if((data = elf_getdata(strscn, NULL)) == NULL) + RETURN(LIBR_ERROR_GETDATA, "Failed to obtain data of section"); + /* Find where the section name is in the string table */ + if(gelf_getshdr(scn, &shdr) != &shdr) + RETURN(LIBR_ERROR_GETSHDR, "Failed to obtain ELF section header: %s", elf_errmsg(-1)); + table_size = data->d_size; + buffer = (char *) data->d_buf; + /* Excise the string from the table */ + str_size = strlen(&buffer[shdr.sh_name])+1; + remaining_size = table_size-(shdr.sh_name+str_size); + if(remaining_size < 0) + RETURN(LIBR_ERROR_SIZEMISMATCH, "Section's data size does not make sense"); + if(remaining_size > 0) + { + /* If there is data after our icon entry in the table then it must be moved before resizing + * NOTE: Using memcpy with overlapping addresses is not allowed, use temporary buffer. + */ + tmp = (char *) malloc(remaining_size); + memcpy(tmp, &buffer[shdr.sh_name+str_size], remaining_size); + memcpy(&buffer[shdr.sh_name], tmp, remaining_size); + free(tmp); + } + data->d_size -= str_size; + /* Update the internal offset information */ + if(elf_update(e, ELF_C_NULL) < 0) + RETURN(LIBR_ERROR_UPDATE, "Failed to perform dynamic update: %s.", elf_errmsg(-1)); +#ifdef MANUAL_LAYOUT +{ + GElf_Shdr strshdr; + + if(gelf_getshdr(strscn, &strshdr) != &strshdr) + RETURN(LIBR_ERROR_GETSHDR, "Failed to obtain ELF section header: %s", elf_errmsg(-1)); + strshdr.sh_size -= str_size; + if(gelf_update_shdr(strscn, &strshdr) < 0) + RETURN(LIBR_ERROR_UPDATE, "Failed to perform dynamic update: %s.", elf_errmsg(-1)); +} +#endif /* MANUAL_LAYOUT */ + + /* Clear the section itself and update the offsets */ + if(elfx_remscn(e, scn) == 0) + RETURN(LIBR_ERROR_REMOVESECTION, "Failed to remove section: %s.", elf_errmsg(-1)); + RETURN_OK; +} + +/* + * Return the pointer to the actual data in the section + */ +void *data_pointer(libr_section *scn, libr_data *data) +{ + return data->d_buf; +} + +/* + * Return the size of the data in the section + */ +size_t data_size(libr_section *scn, libr_data *data) +{ + return data->d_size; +} + +/* + * Return the next section in the ELF file + */ +libr_section *next_section(libr_file *file_handle, libr_section *scn) +{ + return elf_nextscn(file_handle->elf_handle, scn); +} + +/* + * Retrieve the name of a section + */ +char *section_name(libr_file *file_handle, libr_section *scn) +{ + char *name = NULL; + GElf_Shdr shdr; + GElf_Ehdr ehdr; + + if(gelf_getehdr(file_handle->elf_handle, &ehdr) == NULL) + return NULL; + if(gelf_getshdr(scn, &shdr) != &shdr) + return NULL; + if((name = elf_strptr(file_handle->elf_handle, ehdr.e_shstrndx, shdr.sh_name)) == NULL) + return NULL; + return strdup(name); +} + +/* + * Initialize the libelf backend + */ +void initialize_backend(void) +{ + if(elf_version(EV_CURRENT) == EV_NONE) + return; //errx(EX_SOFTWARE, "ELF library initialization failed: %s", elf_errmsg(-1)); +} diff --git a/src/libr-elf.h b/src/libr-elf.h new file mode 100644 index 0000000..4c632e8 --- /dev/null +++ b/src/libr-elf.h @@ -0,0 +1,24 @@ +#ifndef __LIBR_ELF_H +#define __LIBR_ELF_H + +/* Handle ELF files */ +#include <libelf.h> +#include <gelf.h> + +#ifndef DOXYGEN_SHOULD_SKIP_THIS + +typedef struct _libr_file { + int fd_handle; + Elf *elf_handle; + size_t file_size; + libr_access_t access; + unsigned int version; +} libr_file; + +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + +/* for a clean internal API */ +typedef Elf_Scn libr_section; +typedef Elf_Data libr_data; + +#endif /* __LIBR_ELF_H */ diff --git a/src/libr-gtk.c b/src/libr-gtk.c new file mode 100644 index 0000000..f746aa8 --- /dev/null +++ b/src/libr-gtk.c @@ -0,0 +1,443 @@ +/* + * + * Copyright (c) 2008-2009 Erich Hoover + * + * libr GTK support - Convenience functions for using resources in GTK applications + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 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 + * + * To provide feedback, report bugs, or otherwise contact me: + * ehoover at mines dot edu + * + */ + +/* Include compile-time parameters */ +#include "config.h" + +#include "libr.h" +#include "libr-gtk.h" +#include "libr-icons.h" +#include "tempfiles.h" + +/* For loading GTK/GDK images */ +#include <gdk-pixbuf/gdk-pixbuf.h> +#include <glib.h> + +/* For loading GLADE files */ +#include <glade/glade.h> + +/* For loading GTK+ Builder files */ +#include <gtk/gtk.h> + +/* For malloc/free */ +#include <stdlib.h> + +/* For string handling */ +#include <string.h> + +typedef gchar * (*GladeFileCallback)(GladeXML *, const gchar *, guint *); +GladeFileCallback glade_set_file_callback(GladeFileCallback callback, gpointer user_data); + +/* Use weak binding for all glade and GTK+ requirements */ +#pragma weak glade_set_file_callback + +#pragma weak gtk_window_set_default_icon_list +#pragma weak gdk_pixbuf_loader_get_pixbuf +#pragma weak gtk_builder_add_from_string +#pragma weak gdk_pixbuf_loader_set_size +#pragma weak g_type_check_instance_cast +#pragma weak gtk_builder_add_from_file +#pragma weak glade_xml_new_from_buffer +#pragma weak gdk_pixbuf_loader_write +#pragma weak gdk_pixbuf_loader_close +#pragma weak gdk_pixbuf_loader_new +#pragma weak g_signal_connect_data +#pragma weak g_signal_connect +#pragma weak gtk_builder_new +#pragma weak g_object_unref +#pragma weak glade_xml_new +#pragma weak g_list_append +#pragma weak glade_init +#pragma weak gtk_init +#pragma weak g_free + +#define GLADE_SECTION ".glade" +#define BUILDER_SECTION ".ui" + +/* + * Handle the resource request from libglade + */ +gchar *libr_glade_read_resource(GladeXML *gladefile, const gchar *filename, guint *size, gpointer user_data) +{ + return libr_malloc((libr_file *) user_data, (char *) filename, (size_t *) size); +} + +/* + * Handle the resource request from GtkBuilder + */ +gboolean libr_gtk_read_resource(GtkBuilder *builder, const gchar *filename, gchar **data, gsize *size, GError **error, gpointer user_data) +{ + if(data == NULL) + return FALSE; + *data = libr_malloc((libr_file *) user_data, (char *) filename, (size_t *) size); + if(*data == NULL) + return FALSE; + return TRUE; +} + +/* + * Load the libglade resource appropriately for the currently installed version + * (AKA, hurray hacks!) + */ +GladeXML *libr_new_glade(libr_file *handle, char *gladefile, size_t gladefile_size) +{ + if(glade_set_file_callback) /* The not-yet (ever?) existing way */ + { + /* Register a callback for libglade to load our resources */ + if(glade_set_file_callback((GladeFileCallback) libr_glade_read_resource, handle) != NULL) + printf("warning: over-wrote an application callback!\n"); + /* Initialize libglade almost as usual, just use a buffer instead of a file */ + return glade_xml_new_from_buffer(gladefile, gladefile_size, NULL, NULL); + } + else /* The hacky way */ + { + char *glade_file[PATH_MAX]; + GladeXML *ret = NULL; + char *temp_folder; + + temp_folder = libr_extract_resources(handle); + if(temp_folder == NULL) + return NULL; + strcpy((char*)glade_file, temp_folder); + strcat((char*)glade_file, "/"); + strcat((char*)glade_file, GLADE_SECTION); + ret = glade_xml_new((char*)glade_file, NULL, NULL); + if(ret == NULL) + cleanup_folder(temp_folder); + else + register_folder_cleanup(temp_folder); + return ret; + } +} + +/* + * Load the GtkBuilder resource appropriately for the currently installed version + * (AKA, hurray hacks!) + */ +int libr_new_builder(libr_file *handle, char *builderfile, size_t builderfile_size, GtkBuilder *builder) +{ + /* Register a callback for GtkBuilder to load our resources */ + if(g_signal_connect(builder, "load-resource", (GCallback) libr_gtk_read_resource, handle)) + { + /* Initialize GtkBuilder almost as usual, just use a buffer instead of a file */ + if(gtk_builder_add_from_string(builder, builderfile, builderfile_size, NULL) == 0) + return false; + return true; + } + else /* The hacky way */ + { + char *builder_file[PATH_MAX]; + char *temp_folder; + int ret = false; + + temp_folder = libr_extract_resources(handle); + if(temp_folder == NULL) + return false; + strcpy((char*)builder_file, temp_folder); + strcat((char*)builder_file, "/"); + strcat((char*)builder_file, BUILDER_SECTION); + ret = gtk_builder_add_from_file(builder, (char*)builder_file, NULL); + if(ret == 0) + cleanup_folder(temp_folder); + else + register_folder_cleanup(temp_folder); + g_free(temp_folder); + return (ret != 0); + } +} + +/* + * Return a GTK icon list + */ +EXPORT_FN IconList *libr_gtk_iconlist(libr_file *handle) +{ + int sizes[] = {16, 32, 48, 96, 128}; + IconList *icons = NULL; + GdkPixbuf *icon = NULL; + int sizes_len = 5, i; + + if(handle == NULL) + { + /* Must pass a file handle to obtain the icons from */ + return NULL; + } + if(gtk_init == NULL) + { + /* GTK+ was not linked with the application */ + return false; + } + /* Go through the list of GTK "required" image sizes and build the icons */ + for(i=0;i<sizes_len;i++) + { + libr_icon *icon_handle = libr_icon_geticon_bysize(handle, sizes[i]); + GdkPixbufLoader *stream = gdk_pixbuf_loader_new(); + char *iconfile = NULL; + size_t iconfile_size; + + if(icon_handle == NULL) + { + /* Failed to find an icon */ + printf("Failed to find an icon\n"); + continue; + } + iconfile = libr_icon_malloc(icon_handle, &iconfile_size); + if(iconfile == NULL) + { + /* Failed to obtain embedded icon */ + continue; + } + libr_icon_close(icon_handle); + /* TODO: Use the "size-prepared" signal to properly scale the width and height +void user_function (GdkPixbufLoader *loader, gint width, gint height, gpointer user_data) + */ + gdk_pixbuf_loader_set_size(stream, sizes[i], sizes[i]); + if(!gdk_pixbuf_loader_write(stream, (unsigned char *)iconfile, iconfile_size, NULL)) + { + /* Failed to process image */ + continue; + } + if(!gdk_pixbuf_loader_close(stream, NULL)) + { + /* Failed to create image */ + continue; + } + icon = gdk_pixbuf_loader_get_pixbuf(stream); + if(icon == NULL) + { + /* Failed to convert image to pixbuf */ + continue; + } + icons = g_list_append(icons, icon); + } + return icons; +} + +/* + * Shared GtkBuilder resource loading + */ +GtkBuilder *libr_gtk_load_internal(libr_file *handle, char *resource_name) +{ + GtkBuilder *builder = NULL; + size_t builder_length; + char *builder_data; + + /* Obtain the GtkBuilder XML definition */ + builder_data = libr_malloc(handle, resource_name, &builder_length); + if(builder_data == NULL) + { + /* Failed to obtain embedded GtkBuilder definition file */ + goto failed; + } + /* Setup the GtkBuilder environment */ + builder = gtk_builder_new(); + if(builder == NULL) + goto failed; + if(!libr_new_builder(handle, builder_data, builder_length, builder)) + { + /* Failed to build interface from resource file */ + g_object_unref(G_OBJECT(builder)); + goto failed; + } +failed: + free(builder_data); + return builder; +} + +/* + * Load the requested GtkBuilder resource and any applicable icons + */ +EXPORT_FN int libr_gtk_load(BuilderHandle **gtk_ret, char *resource_name) +{ + libr_file *handle; + int ret = false; + + if(gtk_ret == NULL) + { + /* Why on earth would you call this without obtaining the handle to the resource? */ + return false; + } + if(gtk_builder_new == NULL) + { + /* GtkBuilder was not linked with the application */ + return false; + } + /* Obtain the handle to the executable */ + if((handle = libr_open(NULL, LIBR_READ)) == NULL) + { + /* "Failed to open this executable (%s) for resources", progname() */ + return false; + } + register_internal_handle(handle); + *gtk_ret = libr_gtk_load_internal(handle, resource_name); + if(*gtk_ret == NULL) + goto failed; + ret = true; +failed: + if(!ret) + libr_close(handle); + return ret; +} + +/* + * Automatically load the ".ui" GtkBuilder resource and any applicable icons + */ +EXPORT_FN int libr_gtk_autoload(BuilderHandle **gtk_ret, IconList **icons_ret, int set_default_icon) +{ + GList *icons = NULL; + libr_file *handle; + int ret = false; + + if(gtk_ret == NULL) + { + /* Why on earth would you call this without obtaining the handle to the resource? */ + return false; + } + if(gtk_builder_new == NULL) + { + /* GtkBuilder was not linked with the application */ + return false; + } + /* Obtain the handle to the executable */ + if((handle = libr_open(NULL, LIBR_READ)) == NULL) + { + /* "Failed to open this executable (%s) for resources", progname() */ + return false; + } + register_internal_handle(handle); + /* Obtain the icons from the ELF binary */ + icons = libr_gtk_iconlist(handle); + /* Set the embedded icons as the default icon list (if requested) */ + if(icons != NULL && set_default_icon) + gtk_window_set_default_icon_list(icons); + *gtk_ret = libr_gtk_load_internal(handle, BUILDER_SECTION); + if(*gtk_ret == NULL) + goto failed; + if(icons_ret) + *icons_ret = icons; + ret = true; +failed: + if(!ret) + libr_close(handle); + return ret; +} + +/* + * Shared libglade resource loading + */ +GladeXML *libr_glade_load_internal(libr_file *handle, char *resource_name) +{ + GladeXML *glade = NULL; + size_t glade_length; + char *glade_data; + + /* Obtain the GLADE XML definition */ + glade_data = libr_malloc(handle, resource_name, &glade_length); + if(glade_data == NULL) + { + /* Failed to obtain embedded glade file */ + goto failed; + } + /* Initialize libglade appropriate for the available version */ + glade = libr_new_glade(handle, glade_data, glade_length); + if(glade == NULL) + { + /* Failed to initialize embedded glade file */ + goto failed; + } +failed: + free(glade_data); + return glade; +} + +/* + * Load the requested libglade resource and any applicable icons + */ +EXPORT_FN int libr_glade_load(GladeHandle **glade_ret, char *resource_name) +{ + libr_file *handle; + int ret = false; + + if(glade_ret == NULL) + { + /* Why on earth would you call this without obtaining the handle to the resource? */ + return false; + } + if(glade_init == NULL) + { + /* libglade was not linked with the application */ + return false; + } + /* Obtain the handle to the executable */ + if((handle = libr_open(NULL, LIBR_READ)) == NULL) + { + /* "Failed to open this executable (%s) for resources", progname() */ + return false; + } + register_internal_handle(handle); + *glade_ret = libr_glade_load_internal(handle, resource_name); + if(*glade_ret == NULL) + goto failed; + ret = true; +failed: + if(!ret) + libr_close(handle); + return ret; +} + +/* + * Automatically load the ".glade" resource and any applicable icons + */ +EXPORT_FN int libr_glade_autoload(GladeHandle **glade_ret, IconList **icons_ret, int set_default_icon) +{ + libr_file *handle = NULL; + GList *icons = NULL; + + if(glade_ret == NULL) + { + /* Why on earth would you call this without obtaining the handle to the resource? */ + return false; + } + if(glade_init == NULL) + { + /* libglade was not linked with the application */ + return false; + } + /* Obtain the handle to the executable */ + if((handle = libr_open(NULL, LIBR_READ)) == NULL) + { + /* "Failed to open this executable (%s) for resources", progname() */ + return false; + } + register_internal_handle(handle); + icons = libr_gtk_iconlist(handle); + /* Set the embedded icons as the default icon list (if requested) */ + if(icons != NULL && set_default_icon) + gtk_window_set_default_icon_list(icons); + /* Return the libglade and icon handles for the application */ + *glade_ret = libr_glade_load_internal(handle, GLADE_SECTION); + if(icons_ret) + *icons_ret = icons; + return true; +} diff --git a/src/libr-gtk.h b/src/libr-gtk.h new file mode 100644 index 0000000..fa6ba1b --- /dev/null +++ b/src/libr-gtk.h @@ -0,0 +1,55 @@ +/* + * + * Copyright (c) 2008 Erich Hoover + * + * libr-gtk - Convenience support for GTK+ + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 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 + * + * To provide feedback, report bugs, or otherwise contact me: + * ehoover at mines dot edu + * + */ + +#ifndef __LIBR_GTK_H +#define __LIBR_GTK_H + +#include "libr.h" + +#ifndef GLADE_H + typedef void GladeHandle; +#else + typedef GladeXML GladeHandle; +#endif +#ifndef __GTK_BUILDER_H__ + typedef void BuilderHandle; +#else + typedef GtkBuilder BuilderHandle; +#endif +#ifndef __G_LIB_H__ + typedef void IconList; +#else + typedef GList IconList; +#endif + +/* GTK Convenience API */ +IconList *libr_gtk_iconlist(libr_file *handle); +int libr_gtk_autoload(BuilderHandle **gtk_ret, IconList **icons_ret, int set_default_icon); +int libr_gtk_load(BuilderHandle **gtk_ret, char *resource_name); +int libr_glade_autoload(GladeHandle **glade_ret, IconList **icons_ret, int set_default_icon); +int libr_glade_load(GladeHandle **glade_ret, char *resource_name); + +#endif /* __LIBR_GTK_H */ + diff --git a/src/libr-i18n.c b/src/libr-i18n.c new file mode 100644 index 0000000..25e5664 --- /dev/null +++ b/src/libr-i18n.c @@ -0,0 +1,84 @@ +/* + * + * Copyright (c) 2009 Erich Hoover + * + * libr i18n - Add language resources into ELF binaries + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 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 + * + * To provide feedback, report bugs, or otherwise contact me: + * ehoover at mines dot edu + * + */ + +/* Include compile-time parameters */ +#include "config.h" + +#include "libr-i18n.h" +#include "tempfiles.h" + +/* Internationalization support */ +#include <locale.h> + +/* For string handling */ +#include <string.h> +#include <stdio.h> + +/* + * Extract the internationalization resources from the binary + * and setup gettext with the extracted folder. + */ +EXPORT_FN int libr_i18n_load(libr_file *handle, const char *domain) +{ + char *temp_folder; + int ret = true; + + temp_folder = libr_extract_resources(handle); + if(temp_folder == NULL) + return false; + if(!setlocale(LC_ALL, "")) + ret = false; + if(!bindtextdomain(domain, temp_folder)) + ret = false; + if(!textdomain(domain)) + ret = false; + if(!ret) + cleanup_folder(temp_folder); + else + register_folder_cleanup(temp_folder); + return ret; +} + +EXPORT_FN int libr_i18n_autoload(const char *domain) +{ + libr_file *handle; + + /* Obtain the handle to the executable */ + if((handle = libr_open(NULL, LIBR_READ)) == NULL) + { + /* "Failed to open this executable (%s) for resources", progname() */ + return false; + } + /* Obtain the language files from the ELF binary */ + if(!libr_i18n_load(handle, domain)) + { + /* "Failed to load language resources!" */ + goto failed; + } + +failed: + libr_close(handle); + return true; +} diff --git a/src/libr-i18n.h b/src/libr-i18n.h new file mode 100644 index 0000000..5b61546 --- /dev/null +++ b/src/libr-i18n.h @@ -0,0 +1,14 @@ +#ifndef __LIBR_I18N_H +#define __LIBR_I18N_H + +#include "libr.h" +#include "gettext.h" + +#define _(string) gettext(string) +/* for strings used in structures (must manually call gettext!): */ +#define N_(string) (string) + +int libr_i18n_autoload(const char *domain); +int libr_i18n_load(libr_file *handle, const char *domain); + +#endif /* __LIBR_I18N_H */ diff --git a/src/libr-icons.c b/src/libr-icons.c new file mode 100644 index 0000000..18dc536 --- /dev/null +++ b/src/libr-icons.c @@ -0,0 +1,643 @@ +/* + * + * Copyright (c) 2008-2011 Erich Hoover + * + * libr icons - Add icon resources into ELF binaries + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 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 + * + * To provide feedback, report bugs, or otherwise contact me: + * ehoover at mines dot edu + * + */ + +/* Include compile-time parameters */ +#include "config.h" + +#include "libr-icons.h" + +/* For "one canvas" SVG documents */ +#include "onecanvas.h" + +/* For string manipulation */ +#include <stdlib.h> +#include <string.h> +#include <stdio.h> +#include <ctype.h> + +/* For handling files */ +#include <sys/stat.h> + +/* For C99 number types */ +#include <stdint.h> + +#define ICON_SECTION ".icon" +#define TERM_LEN 1 + +#define OFFSET_ENTRIES 0 +#define OFFSET_GUID OFFSET_ENTRIES+sizeof(uint32_t) + +#if defined(__i386) + #define ID12FORMAT "%012llx" +#elif defined(__x86_64) + #define ID12FORMAT "%012lx" +#else + #define ID12FORMAT "%012lx" + #warning "string formatting may be incorrect on this architecture." +#endif + +#ifndef DOXYGEN_SHOULD_SKIP_THIS + +typedef uint32_t ID8; +typedef uint16_t ID4; +typedef struct {uint64_t p:48;} __attribute__((__packed__)) ID12; + +typedef struct { + ID8 g1; + ID4 g2; + ID4 g3; + ID4 g4; + ID12 g5; +} __attribute__((__packed__)) UUID; + +typedef struct { + char *name; + size_t offset; + size_t entry_size; + libr_icontype_t type; + unsigned int icon_size; +} iconentry; + +typedef struct{ + size_t size; + char *buffer; + iconentry entry; +} iconlist; + +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + +/* + * Decode a UUID to its binary representation + * + * NOTE: The last 12-bit parameter cannot be obtained using (uint64_t *) with + * some versions of GCC using some optimization levels. This problem is very + * frustrating to debug, so I do not recommend playing with it yourself. + */ +UUID guid_decode(char *guid) +{ + UUID id = {0x00000000, 0x0000, 0x0000, 0x0000, {0x000000000000} }; + uint64_t tmp12; + + sscanf(guid, "%08x-%04hx-%04hx-%04hx-" ID12FORMAT, &id.g1, &id.g2, &id.g3, &id.g4, &tmp12); + id.g5.p = tmp12; + return id; +} + +/* + * Return the size of the file represented by the file stream + */ +off_t fsize(FILE *handle) +{ + struct stat file_stat; + + if(fstat(fileno(handle), &file_stat) == ERROR) + return ERROR; + return file_stat.st_size; +} + +/* + * Create a new icon handle + */ +libr_icon *new_icon_handle(libr_icontype_t type, unsigned int icon_size, char *buffer, size_t buffer_size) +{ + libr_icon *icon_handle = (libr_icon *) malloc(sizeof(libr_icon)); + + icon_handle->type = type; + icon_handle->buffer = buffer; + icon_handle->icon_size = icon_size; + icon_handle->buffer_size = buffer_size; + return icon_handle; +} + +/* + * Obtain an existing icon resource list + */ +int get_iconlist(libr_file *file_handle, iconlist *icons) +{ + if(icons == NULL) + { + /* Need to be able to return SOMETHING */ + return false; + } + /* Obtain the icon resource list */ + icons->buffer = libr_malloc(file_handle, ICON_SECTION, &(icons->size)); + if(icons->buffer == NULL) + return false; + return true; +} + +/* + * Get the next entry in an icon resource list + */ +iconentry *get_nexticon(iconlist *icons, iconentry *last_entry) +{ + size_t i; + + /* The icon list is needed both for the data buffer and for a call-specific iconentry instance */ + if(icons == NULL) + return NULL; + /* If this is the first call (last_entry == NULL) then return the first entry */ + if(last_entry == NULL) + icons->entry.offset = sizeof(uint32_t)+sizeof(UUID); + else + icons->entry.offset += icons->entry.entry_size; + /* Check to see if we've run out of entries */ + if(icons->entry.offset >= icons->size) + return NULL; + i = icons->entry.offset; + memcpy(&(icons->entry.entry_size), &(icons->buffer[i]), sizeof(uint32_t)); + i += sizeof(uint32_t); + icons->entry.type = icons->buffer[i]; + i += sizeof(unsigned char); + switch(icons->entry.type) + { + case LIBR_SVG: + icons->entry.icon_size = 0; + icons->entry.name = &(icons->buffer[i]); + break; + case LIBR_PNG: + memcpy(&(icons->entry.icon_size), &(icons->buffer[i]), sizeof(uint32_t)); + i += sizeof(uint32_t); + icons->entry.name = &(icons->buffer[i]); + break; + default: + /* Invalid entry type */ + return NULL; + } + return &(icons->entry); +} + +/* + * Free an icon handle + */ +EXPORT_FN int libr_icon_close(libr_icon *icon) +{ + if(icon == NULL) + return false; + if(icon->buffer == NULL) + return false; + free(icon->buffer); + free(icon); + return true; +} + +/* + * Read an icon resource from an ELF file by name + */ +EXPORT_FN libr_icon *libr_icon_geticon_byname(libr_file *handle, char *icon_name) +{ + iconentry *entry = NULL; + libr_icon *icon = NULL; + size_t buffer_size = 0; + unsigned int icon_size; + libr_icontype_t type; + char *buffer = NULL; + int inlist = false; + iconlist icons; + + if(!get_iconlist(handle, &icons)) + { + /* Failed to obtain a list of ELF icons */ + return NULL; + } + /* Look for the icon name in the entry list */ + while((entry = get_nexticon(&icons, entry)) != NULL) + { + if(!strcmp(entry->name, icon_name)) + { + type = entry->type; + icon_size = entry->icon_size; + inlist = true; + break; + } + } + if(!inlist) + { + /* Could not find icon name in the list of icons */ + return false; + } + /* Get the icon from the ELF binary */ + if(!libr_size(handle, icon_name, &buffer_size)) + { + /* Failed to obtain ELF icon size */ + return NULL; + } + /* Allocate memory for the icon */ + buffer = (char *) malloc(buffer_size); + if(buffer == NULL) + { + /* Failed to allocate memory for icon */ + return NULL; + } + /* Get the compressed icon from the ELF file */ + if(!libr_read(handle, icon_name, buffer)) + { + /* Failed to obtain ELF icon */ + goto geticon_byname_complete; + } + icon = new_icon_handle(type, icon_size, buffer, buffer_size); + +geticon_byname_complete: + if(icon == NULL) + free(buffer); + return icon; +} + +/* + * Read an icon resource from an ELF file by the square icon size + */ +EXPORT_FN libr_icon *libr_icon_geticon_bysize(libr_file *handle, unsigned int iconsize) +{ + unsigned int closest_id = 0, i = 0, j = 0; + int found_png = false, found_svg = false; + unsigned long closest_size = 0; + iconentry *entry = NULL; + iconlist icons; + + if(!get_iconlist(handle, &icons)) + { + /* Failed to obtain a list of ELF icons */ + return NULL; + } + /* Look for the closest size match, ignore SVG in case there are multiple icons */ + while((entry = get_nexticon(&icons, entry)) != NULL) + { + if(entry->type == LIBR_SVG) + found_svg = true; + if(entry->type == LIBR_PNG) + { + if(j == 0) + { + closest_size = entry->icon_size; + found_png = true; + } + if(abs(iconsize-entry->icon_size) < closest_size) + { + closest_size = entry->icon_size; + closest_id = i; + } + j++; + } + i++; + } + /* If any PNG files were found then use the file if: + * 1) There are no SVG files <OR> + * 2) The PNG is an EXACT size match + */ + if(found_png) + { + i=0; + entry = NULL; + while((entry = get_nexticon(&icons, entry)) != NULL) + { + if(i == closest_id) + { + if(entry->icon_size == iconsize || !found_svg) + return libr_icon_geticon_byname(handle, entry->name); + break; + } + i++; + } + } + /* Otherwise use the SVG (provided that there is one) */ + if(found_svg) + { + entry = NULL; + while((entry = get_nexticon(&icons, entry)) != NULL) + { + if(entry->type == LIBR_SVG) + { + libr_icon *icon = libr_icon_geticon_byname(handle, entry->name); + if (icon) { + libr_icon *icon_onecanvas; + char *buffer; + + /* should we report the requested size for SVG? */ + icon->icon_size = iconsize; + + /* if the SVG is a "one canvas" document then extract the correctly sized icon */ + if((buffer = onecanvas_geticon_bysize(icon->buffer, iconsize)) != NULL) + { + libr_icon_close(icon); + icon_onecanvas = new_icon_handle(LIBR_SVG, iconsize, buffer, strlen(buffer)); + return icon_onecanvas; + } + } + return icon; + } + } + } + /* Give up */ + return NULL; +} + +/* + * Obtains the icon UUID for the ELF file + */ +EXPORT_FN int libr_icon_getuuid(libr_file *handle, char *uuid) +{ + UUID id = {0x00000000, 0x0000, 0x0000, 0x0000, {0x000000000000} }; + iconlist icons; + + if(!get_iconlist(handle, &icons)) + { + /* Failed to obtain the list of ELF icons */ + return false; + } + /* Now store the GUID to the return string */ + memcpy(&id, &(icons.buffer[OFFSET_GUID]), sizeof(UUID)); + snprintf(uuid, GUIDSTR_LENGTH, "%08x-%04hx-%04hx-%04hx-" ID12FORMAT "\n", id.g1, id.g2, id.g3, id.g4, (uint64_t) id.g5.p); + free(icons.buffer); + return true; +} +EXPORT_FN int libr_icon_getguid(libr_file *handle, char *uuid) ALIAS_FN(libr_icon_getuuid); + +/* + * Allocate a buffer containing the data of an icon + */ +EXPORT_FN char *libr_icon_malloc(libr_icon *icon, size_t *size) +{ + char *iconfile = NULL; + + if(size == NULL) + { + /* No return size passed */ + return NULL; + } + if(!libr_icon_size(icon, size)) + { + /* Failed to obtain embedded icon file size */ + return NULL; + } + iconfile = (char *) malloc(*size); + if(!libr_icon_read(icon, iconfile)) + { + /* Failed to obtain embedded icon file */ + free(iconfile); + return NULL; + } + return iconfile; +} + +/* + * Create an icon resource to represent a file on the hard disk + */ +EXPORT_FN libr_icon *libr_icon_newicon_byfile(libr_icontype_t type, unsigned int icon_size, char *icon_file) +{ + libr_icon *icon_handle = NULL; + size_t len, buffer_size = 0; + char *buffer = NULL; + FILE *handle = NULL; + + /* Open a handle to the icon file */ + if((handle = fopen(icon_file, "r")) == NULL) + { + /* Failed to open icon file */ + return NULL; + } + /* Get the size of the icon file */ + if((buffer_size = fsize(handle)) == ERROR) + { + /* Failed to obtain the icon's file size */ + return NULL; + } + /* Allocate a buffer for the uncompressed icon */ + buffer = (char *) malloc(buffer_size); + if(buffer == NULL) + { + /* Failed to allocate a buffer for the icon data */ + return NULL; + } + /* Read the uncompressed image from the disk */ + if((len = fread(buffer, 1, buffer_size, handle)) <= 0) + { + /* Failed to read icon from disk */ + goto newicon_complete; + } + fclose(handle); + if(len != buffer_size) + { + /* Failed to read the entire icon */ + goto newicon_complete; + } + /* Allocate the icon handle */ + icon_handle = new_icon_handle(type, icon_size, buffer, buffer_size); + +newicon_complete: + if(icon_handle == NULL) + free(buffer); + return icon_handle; +} + +/* + * Copy the icon resource into a buffer + */ +EXPORT_FN int libr_icon_read(libr_icon *icon, char *buffer) +{ + if(icon == NULL) + return false; + memcpy(buffer, icon->buffer, icon->buffer_size); + return true; +} + +/* + * Get the memory size of an icon resource + */ +EXPORT_FN int libr_icon_size(libr_icon *icon, size_t *size) +{ + if(icon == NULL) + return false; + *size = icon->buffer_size; + return true; +} + +/* + * Save the icon resource to a file + */ +EXPORT_FN int libr_icon_save(libr_icon *icon, char *filename) +{ + FILE *file = NULL; + int ret = false; + size_t len; + + if(icon == NULL) + return false; + /* Open the file to store the image */ + if((file = fopen(filename, "w")) == NULL) + { + /* Failed to open file to write the icon */ + return false; + } + /* Store the uncompressed icon to disk */ + if((len = fwrite(icon->buffer, 1, icon->buffer_size, file)) <= 0) + { + /* Failed to write output file */ + goto saveicon_complete; + } + if(len != icon->buffer_size) + { + /* Did not write the entire file */ + goto saveicon_complete; + } + ret = true; + +saveicon_complete: + /* Close remaining resources */ + fclose(file); + return ret; +} + +/* + * Sets the icon GUID for the ELF file + */ +EXPORT_FN int libr_icon_setuuid(libr_file *handle, char *guid) +{ + int ret = false; + iconlist icons; + UUID id; + int i; + + /* First check the GUID string */ + for(i=0;i<strlen(guid);i++) + { + if(!isxdigit(guid[i])) + { + if(guid[i] == '-' && (i == 8 || i == 13 || i == 18 || i == 23)) + continue; + /* not a valid GUID string */ + return false; + } + } + id = guid_decode(guid); + /* Now check existing resources */ + if(!get_iconlist(handle, &icons)) + { + /* No icons exist in the file, create a new icon section with the GUID */ + uint32_t entries = 0; + + icons.size = sizeof(uint32_t)+sizeof(UUID); + icons.buffer = (char *) malloc(icons.size); + memcpy(&(icons.buffer[OFFSET_ENTRIES]), &entries, sizeof(uint32_t)); + } + /* Set the GUID and write the resource */ + if(!libr_write(handle, ICON_SECTION, icons.buffer, icons.size, LIBR_UNCOMPRESSED, LIBR_OVERWRITE)) + { + /* failed to write icon resource */ + goto setguid_complete; + } + ret = true; + +setguid_complete: + free(icons.buffer); + return ret; +} +EXPORT_FN int libr_icon_setguid(libr_file *handle, char *uuid) ALIAS_FN(libr_icon_setuuid); + +/* + * Add an icon resource to an ELF file + */ +EXPORT_FN int libr_icon_write(libr_file *handle, libr_icon *icon, char *icon_name, libr_overwrite_t overwrite) +{ + size_t entry_size, i; + iconentry *entry = NULL; + iconlist icons; + int ret = false; + + /* Check to make sure the user did not make a poor name choice */ + if(!strcmp(icon_name, ICON_SECTION)) + { + /* ".icon" is a reserved section name */ + return false; + + } + /* Check to make sure the file supports icon resources */ + if(!get_iconlist(handle, &icons)) + { + /* A GUID must be set first */ + return false; + } + /* First add the icon as a new named section */ + if(!libr_write(handle, icon_name, icon->buffer, icon->buffer_size, LIBR_COMPRESSED, overwrite)) + { + /* Failed to add the icon as a resource */ + goto writeicon_complete; + } + /* Look to see if the icon already has an entry */ + while((entry = get_nexticon(&icons, entry)) != NULL) + { + if(!strcmp(entry->name, icon_name)) + { + ret = true; + goto writeicon_complete; + } + } + /* Now add the icon to the list of icon resources in the ".icon" section */ + switch(icon->type) + { + case LIBR_SVG: + entry_size = sizeof(uint32_t)+sizeof(unsigned char)+strlen(icon_name)+TERM_LEN; + break; + case LIBR_PNG: + entry_size = sizeof(uint32_t)+sizeof(unsigned char)+sizeof(uint32_t)+strlen(icon_name)+TERM_LEN; + break; + default: + /* Unhandled icon type */ + goto writeicon_complete; + } + icons.buffer = (char *) realloc(icons.buffer, icons.size+entry_size); + if(icons.buffer == NULL) + { + /* Failed to expand memory size */ + goto writeicon_complete; + } + i = icons.size; + memcpy(&(icons.buffer[i]), &entry_size, sizeof(uint32_t)); + i+=sizeof(uint32_t); + icons.buffer[i] = icon->type; + i+=sizeof(unsigned char); + if(icon->type == LIBR_PNG) + { + memcpy(&(icons.buffer[i]), &icon->icon_size, sizeof(uint32_t)); + i+=sizeof(uint32_t); + } + memcpy(&(icons.buffer[i]), icon_name, strlen(icon_name)); + i+=strlen(icon_name); + icons.buffer[i] = '\0'; + icons.size += entry_size; + if(i != (icons.size-1)) + printf("Really dangerous, buffer size mismatch!\n"); + /* Write the updated icon table */ + if(!libr_write(handle, ICON_SECTION, icons.buffer, icons.size, LIBR_UNCOMPRESSED, LIBR_OVERWRITE)) + { + /* failed to write icon resource */ + goto writeicon_complete; + } + ret = true; + +writeicon_complete: + if(icons.buffer) + free(icons.buffer); + return ret; +} diff --git a/src/libr-icons.h b/src/libr-icons.h new file mode 100644 index 0000000..779fef3 --- /dev/null +++ b/src/libr-icons.h @@ -0,0 +1,201 @@ +/* + * + * Copyright (c) 2008-2010 Erich Hoover + * + * libr-icons - Handle icon resources in ELF binaries + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 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 + * + * To provide feedback, report bugs, or otherwise contact me: + * ehoover at mines dot edu + * + */ + +#ifndef __LIBR_ICONS_H +#define __LIBR_ICONS_H + +#include "libr.h" + +typedef enum { + LIBR_SVG = 0, + LIBR_PNG = 1 +} libr_icontype_t; + +#define UUIDSTR_LENGTH 37 +#define GUIDSTR_LENGTH UUIDSTR_LENGTH + +#ifdef __LIBR_BUILD__ + typedef struct { + char *buffer; + size_t buffer_size; + libr_icontype_t type; + unsigned int icon_size; + } libr_icon; +#else + typedef void libr_icon; +#endif + +/************************************************************************* + * libr Icon API + *************************************************************************/ + +/** + * @page libr_icon_close Release an icon resource handle. + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>int libr_icon_close(libr_icon *icon);</b> + * + * @section DESCRIPTION + * Release the icon resource allocated by a call to + * <b>libr_icon_geticon_byid</b>(3), <b>libr_icon_geticon_byname</b>(3), + * <b>libr_icon_geticon_bysize</b>(3), <b>libr_icon_newicon_byfile</b>(3), + * or <b>libr_icon_newicon_frombuffer</b>(3). + * + * @param icon The icon handle to release. + * @return Returns 1 on success, 0 on failure. + * + * @section SA SEE ALSO + * <b>libr_icon_geticon_byid</b>(3), <b>libr_icon_geticon_byname</b>(3), + * <b>libr_icon_geticon_bysize</b>(3), <b>libr_icon_newicon_byfile</b>(3), + * <b>libr_icon_newicon_frombuffer</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +int libr_icon_close(libr_icon *icon); + +/* +libr_icon *libr_icon_geticon_byid(libr_file *handle, unsigned int iconid); +*/ + +/** + * @page libr_icon_geticon_byname Retrieve an icon resource from an ELF + * binary (by the icon resource's name). + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>libr_icon *libr_icon_geticon_byname(libr_file *handle, char *iconname);</b> + * + * @section DESCRIPTION + * Return a resource handle to an icon stored in a libr-compatible ELF + * binary. When this handle is no-longer needed it must be unallocated + * using <b>libr_icon_close</b>(3). + * + * @param handle A handle returned by <b>libr_open</b>(3). + * @param iconname The exact name of the resource to return. + * @return Returns a handle on success, NULL on failure. + * + * @section SA SEE ALSO + * <b>libr_open</b>(3), <b>libr_icon_close</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +libr_icon *libr_icon_geticon_byname(libr_file *handle, char *iconname); + +/** + * @page libr_icon_geticon_bysize Retrieve an icon resource from an ELF + * binary (by the desired icon size). + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>libr_icon *libr_icon_geticon_bysize(libr_file *handle, unsigned int iconsize);</b> + * + * @section DESCRIPTION + * Return a resource handle to the closest requested size icon stored + * in a libr-compatible ELF binary. When this handle is no-longer + * needed it must be unallocated using <b>libr_icon_close</b>(3). + * + * @param handle A handle returned by <b>libr_open</b>(3). + * @param iconsize The size of the resource to return, use 0 + * to request an SVG icon. + * @return Returns a handle on success, NULL on failure. + * + * @section SA SEE ALSO + * <b>libr_open</b>(3), <b>libr_icon_close</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +libr_icon *libr_icon_geticon_bysize(libr_file *handle, unsigned int iconsize); + +/** + * @page libr_icon_getuuid Retrieve the UUID of an application. + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>int libr_icon_getuuid(libr_file *handle, char *uuid);</b> + * + * @section DESCRIPTION + * Returns the icon UUID corresponding to the ELF binary in hex notation + * (XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX), which requires a 37 character + * buffer (36 data characters and a NULL terminator). + * + * @param handle A handle returned by <b>libr_open</b>(3). + * @param uuid A buffer to store the UUID of the application. + * @return Returns 1 on success, 0 on failure. + * + * @section SA SEE ALSO + * <b>libr_open</b>(3), <b>libr_icon_close</b>(3), + * <b>libr_icon_setuuid</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +int libr_icon_getuuid(libr_file *handle, char *uuid); +DEPRECATED_FN int libr_icon_getguid(libr_file *handle, char *uuid); + +char *libr_icon_malloc(libr_icon *icon, size_t *size); +/* +libr_icon *libr_icon_newicon_frombuffer(libr_icontype_t type, int iconsize, char *buffer, size_t size); +*/ +libr_icon *libr_icon_newicon_byfile(libr_icontype_t type, unsigned int iconsize, char *iconfile); +/* +unsigned int libr_icon_num(libr_file *handle); +*/ +int libr_icon_read(libr_icon *icon, char *buffer); +int libr_icon_size(libr_icon *icon, size_t *size); +int libr_icon_save(libr_icon *icon, char *filename); + +/** + * @page libr_icon_setuuid Write a UUID into an application binary. + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>int libr_icon_setuuid(libr_file *handle, char *uuid);</b> + * + * @section DESCRIPTION + * Sets the icon UUID corresponding to the ELF binary in hex notation + * (XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX), which requires a 37 character + * buffer (36 data characters and a NULL terminator). + * + * @param handle A handle returned by <b>libr_open</b>(3). + * @param uuid A UUID to set for the application, can be generated by + * the terminal program "uuid". + * @return Returns 1 on success, 0 on failure. + * + * @section SA SEE ALSO + * <b>libr_open</b>(3), <b>libr_icon_close</b>(3), + * <b>libr_icon_getuuid</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +int libr_icon_setuuid(libr_file *handle, char *uuid); +DEPRECATED_FN int libr_icon_setguid(libr_file *handle, char *guid); +int libr_icon_write(libr_file *handle, libr_icon *icon, char *iconname, libr_overwrite_t overwrite); + +#endif /* __LIBR_ICONS_H */ diff --git a/src/libr-internal.h b/src/libr-internal.h new file mode 100644 index 0000000..f7008a4 --- /dev/null +++ b/src/libr-internal.h @@ -0,0 +1,34 @@ +#ifndef __LIBR_INTERNAL_H +#define __LIBR_INTERNAL_H + +#define false 0 +#define true 1 +#define ERROR -1 +#define EXPORT_FN __attribute__((visibility ("protected"))) +#define INTERNAL_FN __attribute__ ((visibility ("internal"))) +#define LIBR_TEMPFILE "/tmp/libr-temp.XXXXXX" +#define LIBR_TEMPFILE_LEN 22 + +#ifndef DOXYGEN_SHOULD_SKIP_THIS + +typedef struct { + char *message; + libr_status status; + const char *function; +} libr_intstatus; + +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + +struct _libr_file; + +void libr_set_error(libr_intstatus error); +libr_intstatus make_status(const char *function, libr_status code, char *message, ...); +/* Only called directly by cleanup routine, all other calls should be through libr_close */ +void libr_close_internal(struct _libr_file *file_handle); + +#define SET_ERROR(code,...) make_status(__FUNCTION__, code, __VA_ARGS__) +#define RETURN(code,...) return SET_ERROR(code, __VA_ARGS__) +#define RETURN_OK return SET_ERROR(LIBR_OK, NULL) +#define PUBLIC_RETURN(code,message) {SET_ERROR(code, message); return (code == LIBR_OK);} + +#endif /* __LIBR_INTERNAL_H */ diff --git a/src/libr-link.h b/src/libr-link.h new file mode 100644 index 0000000..b1bdb54 --- /dev/null +++ b/src/libr-link.h @@ -0,0 +1,26 @@ +#ifndef __LIBR_LINK_H +#define __LIBR_LINK_H + +#ifndef DOXYGEN_SHOULD_SKIP_THIS + +typedef struct { + void **symbol; + char *name; +} symbol_table; + +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + +#define SYMBOL_TABLE(tbl, ...) \ +const symbol_table tbl[] = { \ + __VA_ARGS__ \ + {NULL, NULL} \ +} + +#define OVERRIDE_SYMBOL(a) FN_##a +#define SYMBOL(sym) {(void **)&FN_##sym, #sym} +#define DEFINE_SYMBOL(ret, fn, ...) ret (*OVERRIDE_SYMBOL(fn))(__VA_ARGS__) +#define LOAD_SYMBOLS(lib, tbl) load_symbols(lib, tbl, sizeof(tbl)/sizeof(symbol_table)) + +int load_symbols(const char *library, const symbol_table *table, int entries); + +#endif /* __LIBR_LINK_H */ diff --git a/src/libr-ro.c b/src/libr-ro.c new file mode 100644 index 0000000..c3de28d --- /dev/null +++ b/src/libr-ro.c @@ -0,0 +1,351 @@ +/* + * + * Copyright (c) 2009 Erich Hoover + * Copyright (c) 2008-2009 Martin Rosenau + * + * libr read-only Backend - Read resources from ELF binaries + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 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 + * + * To provide feedback, report bugs, or otherwise contact me: + * ehoover at mines dot edu + * + */ + +/* Include compile-time parameters */ +#include "config.h" + +#include "libr.h" +#include "libr-internal.h" + +/* malloc/free */ +#include <stdlib.h> + +/* For memory byte-wise compare */ +#include <string.h> + +/* For endian conversion */ +#include "cvtendian.h" + +#define RETURN_UNSUPPORTED RETURN(LIBR_ERROR_UNSUPPORTED, "The read-only backend does not support this operation"); + +#ifndef DOXYGEN_SHOULD_SKIP_THIS + +typedef struct { + unsigned char magic[4]; + eClass byte_size; + eEncoding endian; + unsigned char version; + unsigned char padding[9]; +} ElfPreHeader; + +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + +#define ELF_HALF(b) sizeof(uint16_t) +#define ELF_WORD(b) sizeof(uint32_t) +#define ELF_XWORD(b) ((b == ELFCLASS32) ? sizeof(uint32_t) : sizeof(uint64_t)) +#define ELF_ADDR(b) ELF_XWORD(b) +#define ELF_OFF(b) ELF_XWORD(b) + +/* ELF Header Offsets */ +#define HDROFF_TYPE(b) sizeof(ElfPreHeader) /* ElfXX_Half e_type; */ +#define HDROFF_MACHINE(b) HDROFF_TYPE(b)+ELF_HALF(b) /* ElfXX_Half e_machine; */ +#define HDROFF_VERSION(b) HDROFF_MACHINE(b)+ELF_HALF(b) /* ElfXX_Word e_version; */ +#define HDROFF_ENTRY(b) HDROFF_VERSION(b)+ELF_WORD(b) /* ElfXX_Addr e_entry; */ +#define HDROFF_PHOFF(b) HDROFF_ENTRY(b)+ELF_ADDR(b) /* ElfXX_Off e_phoff; */ +#define HDROFF_SHOFF(b) HDROFF_PHOFF(b)+ELF_OFF(b) /* ElfXX_Off e_shoff; */ +#define HDROFF_FLAGS(b) HDROFF_SHOFF(b)+ELF_OFF(b) /* ElfXX_Word e_flags; */ +#define HDROFF_EHSIZE(b) HDROFF_FLAGS(b)+ELF_WORD(b) /* ElfXX_Half e_ehsize; */ +#define HDROFF_PHENTSIZE(b) HDROFF_EHSIZE(b)+ELF_HALF(b) /* ElfXX_Half e_phentsize; */ +#define HDROFF_PHNUM(b) HDROFF_PHENTSIZE(b)+ELF_HALF(b) /* ElfXX_Half e_phnum; */ +#define HDROFF_SHENTSIZE(b) HDROFF_PHNUM(b)+ELF_HALF(b) /* ElfXX_Half e_shentsize; */ +#define HDROFF_SHNUM(b) HDROFF_SHENTSIZE(b)+ELF_HALF(b) /* ElfXX_Half e_shnum; */ +#define HDROFF_SHSTRNDX(b) HDROFF_SHNUM(b)+ELF_HALF(b) /* ElfXX_Half e_shstrndx; */ + +/* ELF Section Offsets */ +#define SECOFF_NAME(b) 0 /* ElfXX_Word sh_name; */ +#define SECOFF_TYPE(b) SECOFF_NAME(b)+ELF_WORD(b) /* ElfXX_Word sh_type; */ +#define SECOFF_FLAGS(b) SECOFF_TYPE(b)+ELF_WORD(b) /* ElfXX_XWord sh_flags; */ +#define SECOFF_ADDR(b) SECOFF_FLAGS(b)+ELF_XWORD(b) /* ElfXX_Addr sh_addr; */ +#define SECOFF_OFFSET(b) SECOFF_ADDR(b)+ELF_ADDR(b) /* ElfXX_Off sh_offset; */ +#define SECOFF_SIZE(b) SECOFF_OFFSET(b)+ELF_OFF(b) /* ElfXX_XWord sh_size; */ +#define SECOFF_LINK(b) SECOFF_SIZE(b)+ELF_XWORD(b) /* ElfXX_Word sh_link; */ +#define SECOFF_INFO(b) SECOFF_LINK(b)+ELF_WORD(b) /* ElfXX_Word sh_info; */ +#define SECOFF_ADDRALIGN SECOFF_INFO(b)+ELF_WORD(b) /* ElfXX_XWord sh_addralign; */ +#define SECOFF_ENTSIZE SECOFF_ADDRALIGN(b)+ELF_XWORD(b) /* ElfXX_XWord sh_entsize; */ + +/* + * Safely read a parameter from the ELF binary + */ +static int read_param(FILE *handle, void *result, size_t bytes, eClass endian) +{ + if(fread(result, 1, bytes, handle) != bytes) + return 0; + if(ferror(handle)) + return 0; + if(endian != HOST_ENDIAN && !ConvertEndian(result, bytes)) + return 0; + return 1; +} + +/* + * The read-only backend requires no initialization + */ +void initialize_backend(void) +{ + if(sizeof(ElfPreHeader) != 16) + fprintf(stderr, "WARNING: Your compiler did not properly pack important structures!\n"); +} + +/* + * The read-only backend cannot write an output file + */ +void write_output(libr_file *file_handle) {} + +/* + * The read-only backend cannot add sections + */ +libr_intstatus add_section(libr_file *file_handle, char *resource_name, libr_section **retscn) +{ + RETURN_UNSUPPORTED; +} + +/* + * Return the name of a section + */ +char *section_name(libr_file *file_handle, libr_section *scn) +{ + if(scn == NULL) + return NULL; + return scn->name; +} + +/* + * Return the pointer to the actual data in the section + */ +void *data_pointer(libr_section *scn, libr_data *data) +{ + return (void *) data; +} + +/* + * Return the size of the data in the section + */ +size_t data_size(libr_section *scn, libr_data *data) +{ + return scn->size; +} + +/* + * Find the resource stored in the ELF binary + */ +libr_intstatus find_section(libr_file *file_handle, char *section, libr_section **retscn) +{ + char *test_name; + int i; + + for(i=0; i<file_handle->total_sections; i++) + { + test_name = section_name(file_handle, &(file_handle->secdata[i])); + if(test_name != NULL && strcmp(test_name, section) == 0) + break; + } + if(i >= file_handle->total_sections) + RETURN(LIBR_ERROR_NOSECTION, "ELF resource section not found"); + + /* Found the resource, hurray! */ + *retscn = &(file_handle->secdata[i]); + RETURN_OK; +} + +/* + * Read the section from the ELF binary + */ +libr_data *get_data(libr_file *file_handle, libr_section *scn) +{ + FILE *handle = file_handle->handle; + libr_data *data = NULL; + size_t n; + + fseek(handle, scn->data_offset, SEEK_SET); + data = (libr_data *) malloc(scn->size); + n = fread(data, 1, scn->size, handle); + if(n == 0) + goto failed; /* Empty section? */ + if(ferror(handle)) + goto failed; + + /* Succeeded in reading the data */ + return data; +failed: + free(data); + return NULL; +} + +/* + * UNSUPORTED BY BACKEND: Create a new data section + */ +libr_data *new_data(libr_file *file_handle, libr_section *scn) +{ + return NULL; +} + +/* + * Find the next section given a section pointer + */ +libr_section *next_section(libr_file *file_handle, libr_section *scn) +{ + int total_sections = file_handle->total_sections; + libr_section *test_scn = NULL; + int i; + + if(total_sections == 0) + return NULL; + /* Requesting the first section */ + if(scn == NULL) + { + i = 0; + /* Do not return an empty section */ + while(test_scn == NULL || test_scn->size == 0) + { + if(i > total_sections) + return NULL; + test_scn = &(file_handle->secdata[i++]); + } + return test_scn; + } + /* Return the next section given a section pointer */ + for(i=0; i<total_sections; i++) + { + test_scn = &(file_handle->secdata[i]); + + if(test_scn == scn && (i+1) < total_sections) + { + libr_section *next_scn = &(file_handle->secdata[i+1]); + + /* Returning empty sections is pointless */ + if(next_scn->size != 0) + return next_scn; + } + } + return NULL; +} + +/* + * UNSUPORTED BY BACKEND: Remove a section + */ +libr_intstatus remove_section(libr_file *file_handle, libr_section *scn) +{ + RETURN_UNSUPPORTED; +} + +/* + * UNSUPORTED BY BACKEND: Set the data for a section + */ +libr_intstatus set_data(libr_file *file_handle, libr_section *scn, libr_data *data, off_t offset, char *buffer, size_t size) +{ + RETURN_UNSUPPORTED; +} + +/* + * Open a handle to the ELF binary (provided that read-only access is requested) + */ +libr_intstatus open_handles(libr_file *file_handle, char *filename, libr_access_t access) +{ + const char elf_magic[] = {'\x7F','E','L','F'}; + uint16_t total_sections, sh_size, strings_sec; + ElfPreHeader file_info; + libr_section *secdata; + FILE *handle = NULL; + uint64_t sh_offset; + unsigned long i; + + if(access == LIBR_READ_WRITE) + RETURN_UNSUPPORTED; + handle = fopen(filename, "rb"); + if(!handle) + RETURN(LIBR_ERROR_OPENFAILED, "Failed to open input file"); + if(fread(&file_info, 1, sizeof(ElfPreHeader), handle) != sizeof(ElfPreHeader)) + RETURN(LIBR_ERROR_WRONGFORMAT, "Failed to read pre-header bytes from input file"); + if(memcmp(file_info.magic, elf_magic, sizeof(elf_magic)) != 0) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: not an ELF binary"); + + /* Confirm processor (byte size) and packing (endian) */ + if(!enum_valid(file_info.byte_size, ELFCLASS)) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: invalid byte size"); + if(!enum_valid(file_info.endian, ELFDATA)) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: invalid endian type"); + + /* Get the file offset to the Section Header tables */ + fseek(handle, HDROFF_SHOFF(file_info.byte_size), SEEK_SET); + if(!read_param(handle, &sh_offset, ELF_OFF(file_info.byte_size), file_info.endian)) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read section header offset"); + /* Get the size of the Section Header tables */ + fseek(handle, HDROFF_SHENTSIZE(file_info.byte_size), SEEK_SET); + if(!read_param(handle, &sh_size, ELF_HALF(file_info.byte_size), file_info.endian)) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read section header size"); + /* Get the total number of sections */ + fseek(handle, HDROFF_SHNUM(file_info.byte_size), SEEK_SET); + if(!read_param(handle, &total_sections, ELF_HALF(file_info.byte_size), file_info.endian)) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read total number of sections"); + /* Get the ID of the "strings" section */ + fseek(handle, HDROFF_SHSTRNDX(file_info.byte_size), SEEK_SET); + if(!read_param(handle, &strings_sec, ELF_HALF(file_info.byte_size), file_info.endian)) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read string section ID"); + if(strings_sec >= total_sections) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: invalid string section ID"); + secdata = (libr_section *) malloc(sizeof(libr_section)*total_sections); + + /* Load section information */ + for(i=0; i<total_sections; i++) + { + long sec_start = sh_offset+sh_size*i; + + /* Grab the offset in the string table to the name of the section */ + fseek(handle, sec_start+SECOFF_NAME(file_info.byte_size), SEEK_SET); + if(!read_param(handle, &(secdata[i].name_offset), ELF_WORD(file_info.byte_size), file_info.endian)) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read section name offset"); + /* Grab the offset to the data for the section */ + fseek(handle, sec_start+SECOFF_OFFSET(file_info.byte_size), SEEK_SET); + if(!read_param(handle, &(secdata[i].data_offset), ELF_OFF(file_info.byte_size), file_info.endian)) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read section data offset"); + /* Grab the size of the data for the section */ + fseek(handle, sec_start+SECOFF_SIZE(file_info.byte_size), SEEK_SET); + if(!read_param(handle, &(secdata[i].size), ELF_XWORD(file_info.byte_size), file_info.endian)) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read section size"); + } + /* Locate the name offset within the "strings" section and load the string */ + for(i=0; i<total_sections; i++) + { + long stringsec_start = secdata[strings_sec].data_offset; + size_t n; + + fseek(handle, stringsec_start+secdata[i].name_offset, SEEK_SET); + n = fread(secdata[i].name, 1, ELFSTRING_MAX-1, handle); + if(ferror(handle)) + RETURN(LIBR_ERROR_WRONGFORMAT, "Invalid input file format: failed to read string"); + secdata[i].name[n] = '\0'; + } + + /* Hold onto the important parameters */ + file_handle->secdata = secdata; + file_handle->total_sections = total_sections; + file_handle->endian = file_info.endian; + file_handle->byte_size = file_info.byte_size; + file_handle->handle = handle; + file_handle->filename = filename; + file_handle->access = access; + RETURN_OK; +} diff --git a/src/libr-ro.h b/src/libr-ro.h new file mode 100644 index 0000000..8b8e41a --- /dev/null +++ b/src/libr-ro.h @@ -0,0 +1,62 @@ +#ifndef __LIBRRO_H +#define __LIBRRO_H + +/* For file handle support */ +#include <stdio.h> + +/* For integer types with set bit-sizes */ +#include <stdint.h> + +/* + * NOTE: Packing the enum uses the smallest number of bytes + * possible to represent the value. This packing does not + * guarantee that a "short enum" will be 8 bits, however, + * for the small enumerations in the ELF specification this + * IS the case (no enum requires more than 8 bits). + */ +#define SHORT_ENUM __attribute__ ((__packed__)) + +/* Type of byte-packing (endian) */ +typedef enum SHORT_ENUM { + ELFDATANONE, /* Invalid */ + ELFDATA2LSB, /* Least Significant Byte First */ + ELFDATA2MSB, /* Most Significant Byte First */ + ELFDATAMAX, /* Invalid */ +} eEncoding; + +/* Type of target processor */ +typedef enum SHORT_ENUM { + ELFCLASSNONE, /* Invalid */ + ELFCLASS32, /* 32-bit Field Alignment */ + ELFCLASS64, /* 64-bit Field Alignment */ + ELFCLASSMAX, /* Invalid */ +} eClass; + +#ifndef DOXYGEN_SHOULD_SKIP_THIS + +#define ELFSTRING_MAX 200 +typedef struct _libr_section { + uint64_t size; + uint64_t data_offset; + uint32_t name_offset; + char name[ELFSTRING_MAX]; +} libr_section; + +typedef struct _libr_file { + FILE *handle; + char *filename; + eEncoding endian; + eClass byte_size; + libr_access_t access; + libr_section *secdata; + unsigned long total_sections; +} libr_file; + +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + +/* for a clean internal API */ +typedef void libr_data; + +#define enum_valid(val, name) (val > name##NONE && val < name##MAX) + +#endif /* __LIBRRO_H */ diff --git a/src/libr.c b/src/libr.c new file mode 100644 index 0000000..d038594 --- /dev/null +++ b/src/libr.c @@ -0,0 +1,489 @@ +/* + * + * Copyright (c) 2008-2009 Erich Hoover + * + * libr - Add resources into ELF binaries + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 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 + * + * To provide feedback, report bugs, or otherwise contact me: + * ehoover at mines dot edu + * + */ + +/* Include compile-time parameters */ +#include "config.h" + +#include "libr.h" +#include "tempfiles.h" + +/* Obtain file information */ +#include <sys/stat.h> +#include <stdlib.h> +#include <stdio.h> + +/* Compress files */ +#include <zlib.h> +#include <math.h> /* for ceil */ + +/* Handle strings and variable arguments*/ +#include <string.h> +#include <stdarg.h> + +/* For C99 number types */ +#include <stdint.h> + +/* Handle status codes for multiple threads */ +#include <pthread.h> + +#define SPEC_VERSION '1' +#define OFFSET_TYPE ((unsigned long) 4) +#define OFFSET_UNCOMPRESSED ((unsigned long) OFFSET_TYPE+sizeof(unsigned char)) +#define OFFSET_UNCOMPRESSED_SIZE ((unsigned long) OFFSET_TYPE+sizeof(unsigned char)) +#define OFFSET_COMPRESSED ((unsigned long) OFFSET_UNCOMPRESSED_SIZE+sizeof(uint32_t)) + +#if 0 + extern const char * __progname_full; + #define progpath() (char *) __progname_full +#endif +#define getself() ((char *) "/proc/self/exe") + +pthread_key_t error_key; + +/* + * Free the error status code/message structure + * (called on thread destruction or when a new code is set) + */ +void free_error_key(void *_m) +{ + libr_intstatus *error = (libr_intstatus *) _m; + + if(error != NULL) + { + /* Free the error structure */ + if(error->message != NULL) + free(error->message); + free(error); + } +} + +/* + * Set the error code and message for retrieval + */ +void libr_set_error(libr_intstatus error) +{ + static int thread_key_initialized = false; + libr_intstatus *status = NULL; + + if(!thread_key_initialized) + { + if(pthread_key_create(&error_key, free_error_key) != 0) + return; /* a serious pthread-related error occurred */ + if(pthread_setspecific(error_key, NULL) != 0) + return; /* a serious pthread-related error occurred */ + thread_key_initialized = true; + } + free_error_key(pthread_getspecific(error_key)); + status = (libr_intstatus *) malloc(sizeof(libr_intstatus)); + memcpy(status, &error, sizeof(libr_intstatus)); + if(pthread_setspecific(error_key, (void *) status) != 0) + return; /* a serious pthread-related error occurred */ +} + +/* + * Make an internal status passing structure, set the error code with this status + * if the status is not LIBR_OK. + */ +libr_intstatus make_status(const char *function, libr_status code, char *message, ...) +{ + libr_intstatus status = {NULL, code, function}; + va_list args; + + if(message != NULL) + { + status.message = (char *) malloc(1024); + va_start(args, message); + vsnprintf(status.message, 1024, message, args); + va_end(args); + } + + libr_set_error(status); + return status; +} + +/* + * Make sure that the section is libr-compatible + */ +libr_intstatus section_ok(libr_section *scn, libr_data *data) +{ + char required_header[5], test_header[4] = {'R', 'E', 'S', SPEC_VERSION}; + void *ptr = data_pointer(scn, data); + size_t size = data_size(scn, data); + + if(ptr == NULL || size < sizeof(required_header)) + RETURN(LIBR_ERROR_NOTRESOURCE, "Not a valid libr-resource"); + memcpy(required_header, ptr, sizeof(required_header)); + if(strncmp(required_header, test_header, sizeof(test_header)) != 0) + RETURN(LIBR_ERROR_NOTRESOURCE, "Not a valid libr-resource"); + RETURN_OK; +} + +/* + * Remove a resourcefrom the ELF binary handle + */ +EXPORT_FN int libr_clear(libr_file *file_handle, char *resource_name) +{ + libr_data *data = NULL; + libr_section *scn = NULL; + + /* Ensure valid inputs */ + if(file_handle == NULL || resource_name == NULL) + PUBLIC_RETURN(LIBR_ERROR_INVALIDPARAMS, "Invalid parameters passed to function"); + if(file_handle->access != LIBR_READ_WRITE) + PUBLIC_RETURN(LIBR_ERROR_NOPERM, "Open handle with LIBR_READ_WRITE access"); + /* Find the section containing the icon */ + if(find_section(file_handle, resource_name, &scn).status != LIBR_OK) + return false; /* error already set */ + /* Get the section data (interested in header) */ + if((data = get_data(file_handle, scn)) == NULL) + PUBLIC_RETURN(LIBR_ERROR_GETDATA, "Failed to obtain data of section"); + /* Confirm that this resource is libr-compatible */ + if(section_ok(scn, data).status != LIBR_OK) + return false; /* error already set */ + /* Clear the data resource */ + if(set_data(file_handle, scn, data, 0, NULL, 0).status != LIBR_OK) + return false; /* error already set */ + /* Remove the section */ + if(remove_section(file_handle, scn).status != LIBR_OK) + return false; /* error already set */ + return true; +} + +/* + * Close the specified ELF binary handle + */ +EXPORT_FN void libr_close(libr_file *file_handle) +{ + unregister_handle_cleanup(file_handle); + libr_close_internal(file_handle); +} +/* Only called directly by cleanup routine, all other calls should be through libr_close */ +void libr_close_internal(libr_file *file_handle) +{ + write_output(file_handle); + free(file_handle); +} + +/* + * Return the last error message for the active thread + */ +EXPORT_FN char *libr_errmsg(void) +{ + libr_intstatus *error = (libr_intstatus *) pthread_getspecific(error_key); + + if(error == NULL) + return NULL; + return error->message; +} + +/* + * Return the last error code for the active thread (or LIBR_OK for no error) + */ +EXPORT_FN libr_status libr_errno(void) +{ + libr_intstatus *error = (libr_intstatus *) pthread_getspecific(error_key); + + if(error == NULL) /* Nothing has happened yet */ + return LIBR_OK; + return error->status; +} + +/* + * Return the name of a libr-compatible resource + */ +EXPORT_FN char *libr_list(libr_file *file_handle, unsigned int resourceid) +{ + libr_section *scn = NULL; + libr_data *data = NULL; + int i = 0; + + while((scn = next_section(file_handle, scn)) != NULL) + { + /* Get the section data (interested in header) */ + if((data = get_data(file_handle, scn)) == NULL) + return NULL; + if(section_ok(scn, data).status == LIBR_OK) + { + if(i == resourceid) + return strdup(section_name(file_handle, scn)); + i++; + } + } + return NULL; +} + +/* + * Allocate a buffer containing the data of a resource + */ +EXPORT_FN char *libr_malloc(libr_file *file_handle, char *resource_name, size_t *size) +{ + char *buffer = NULL; + size_t size_local; + + if(size == NULL) + size = &size_local; + if(!libr_size(file_handle, resource_name, size)) + return NULL; /* error already set */ + buffer = (char *) malloc(*size); + if(!libr_read(file_handle, resource_name, buffer)) + { + free(buffer); + return NULL; /* error already set */ + } + return buffer; +} + +/* + * Open the specified ELF binary (caller if filename is NULL) + */ +EXPORT_FN libr_file *libr_open(char *filename, libr_access_t access) +{ + libr_file *file_handle = NULL; + static int initialized = false; + + if(!initialized) + { + if(strncmp(zlibVersion(), ZLIB_VERSION, 1) != 0) + { + SET_ERROR(LIBR_ERROR_ZLIBINIT, "zlib library initialization failed"); + return NULL; + } + initialize_backend(); + initialized = true; + } + + if(filename == NULL) + filename = getself(); + file_handle = (libr_file *) malloc(sizeof(libr_file)); + memset(file_handle, 0, sizeof(libr_file)); + if(open_handles(file_handle, filename, access).status != LIBR_OK) + { + /* failed to open file for processing, error already set */ + free(file_handle); + file_handle = NULL; + } + /* Cleanup handles automatically when libr exits memory */ + if(file_handle != NULL) + register_handle_cleanup(file_handle); + return file_handle; +} + +/* + * Read a resource from the specified ELF binary handle + */ +EXPORT_FN int libr_read(libr_file *file_handle, char *resource_name, char *buffer) +{ + unsigned long uncompressed_size = 0, compressed_size = 0; + char *data_buffer = NULL; + libr_section *scn = NULL; + libr_data *data = NULL; + libr_type_t type; + + /* Find the section containing the icon */ + if(find_section(file_handle, resource_name, &scn).status != LIBR_OK) + return false; /* error already set */ + /* Get the section data (interested in header) */ + if((data = get_data(file_handle, scn)) == NULL) + PUBLIC_RETURN(LIBR_ERROR_GETDATA, "Failed to obtain data of section"); + /* Confirm that this resource is libr-compatible */ + if(section_ok(scn, data).status != LIBR_OK) + return false; /* error already set */ + data_buffer = (char *) data_pointer(scn, data); + /* Get the size of the data resource */ + type = (libr_type_t) data_buffer[OFFSET_TYPE]; + switch(type) + { + case LIBR_UNCOMPRESSED: + { if(data_size(scn, data)-OFFSET_UNCOMPRESSED < 0) + PUBLIC_RETURN(LIBR_ERROR_SIZEMISMATCH, "Section's data size does not make sense"); + uncompressed_size = data_size(scn, data)-OFFSET_UNCOMPRESSED; + memcpy(buffer, &data_buffer[OFFSET_UNCOMPRESSED], uncompressed_size); + } break; + case LIBR_COMPRESSED: + { + uint32_t size_temp; + + memcpy(&size_temp, &data_buffer[OFFSET_UNCOMPRESSED_SIZE], sizeof(uint32_t)); + uncompressed_size = size_temp; + compressed_size = data_size(scn, data)-OFFSET_COMPRESSED; + if(uncompress((unsigned char *)buffer, &uncompressed_size, (unsigned char *)&data_buffer[OFFSET_COMPRESSED], compressed_size) != Z_OK) + PUBLIC_RETURN(LIBR_ERROR_UNCOMPRESS, "Failed to uncompress resource data"); + } break; + default: + PUBLIC_RETURN(LIBR_ERROR_INVALIDTYPE, "Invalid data storage type specified"); + } + return true; +} + +/* + * Retrieve the number of libr-compatible resources + */ +EXPORT_FN unsigned int libr_resources(libr_file *file_handle) +{ + libr_section *scn = NULL; + libr_data *data = NULL; + int i = 0; + + while((scn = next_section(file_handle, scn)) != NULL) + { + if((data = get_data(file_handle, scn)) == NULL) + continue; + if(section_ok(scn, data).status == LIBR_OK) + i++; + } + return i; +} + +/* + * Get the size of a resource from the specified ELF binary handle + */ +EXPORT_FN int libr_size(libr_file *file_handle, char *resource_name, size_t *retsize) +{ + char *data_buffer = NULL; + libr_section *scn = NULL; + libr_data *data = NULL; + unsigned long size = 0; + libr_type_t type; + + /* Find the section containing the icon */ + if(find_section(file_handle, resource_name, &scn).status != LIBR_OK) + return false; /* error already set */ + /* Get the section data (interested in header) */ + if((data = get_data(file_handle, scn)) == NULL) + PUBLIC_RETURN(LIBR_ERROR_GETDATA, "Failed to obtain data of section"); + /* Confirm that this resource is libr-compatible */ + if(section_ok(scn, data).status != LIBR_OK) + return false; /* error already set */ + data_buffer = (char *) data_pointer(scn, data); + /* Get the size of the data resource */ + type = (libr_type_t) data_buffer[OFFSET_TYPE]; + switch(type) + { + case LIBR_UNCOMPRESSED: + { + size_t full_size = data_size(scn, data); + + if(full_size-OFFSET_UNCOMPRESSED < 0) + PUBLIC_RETURN(LIBR_ERROR_SIZEMISMATCH, "Section's data size does not make sense"); + size = full_size - OFFSET_UNCOMPRESSED; + } break; + case LIBR_COMPRESSED: + { + memcpy(&size, &data_buffer[OFFSET_UNCOMPRESSED_SIZE], sizeof(uint32_t)); + } break; + default: + PUBLIC_RETURN(LIBR_ERROR_INVALIDTYPE, "Invalid data storage type specified"); + } + *retsize = size; + return true; +} + +/* + * Write a resource to the specified ELF binary handle + */ +EXPORT_FN int libr_write(libr_file *file_handle, char *resource_name, char *buffer, size_t size, libr_type_t type, libr_overwrite_t overwrite) +{ + char header[9] = {'R', 'E', 'S', SPEC_VERSION}; + unsigned int header_size = 4; + libr_section *scn = NULL; + libr_data *data = NULL; + libr_intstatus ret; + + /* Ensure valid inputs */ + if(file_handle == NULL || resource_name == NULL || buffer == NULL) + PUBLIC_RETURN(LIBR_ERROR_INVALIDPARAMS, "Invalid parameters passed to function"); + if(file_handle->access != LIBR_READ_WRITE) + PUBLIC_RETURN(LIBR_ERROR_NOPERM, "Open handle with LIBR_READ_WRITE access"); + /* Get the section if it already exists */ + ret = find_section(file_handle, resource_name, &scn); + if(ret.status == LIBR_OK) + { + /* If the section exists (and overwrite is not specified) then fail */ + if(!overwrite) + PUBLIC_RETURN(LIBR_ERROR_OVERWRITE, "Section already exists, over-write not specified"); + /* Grab the existing data section for overwriting */ + if((data = get_data(file_handle, scn)) == NULL) + PUBLIC_RETURN(LIBR_ERROR_GETDATA, "Failed to obtain data of section"); + } + else if(ret.status == LIBR_ERROR_NOSECTION) + { + /* Create a new section named "resource_name" */ + if(add_section(file_handle, resource_name, &scn).status != LIBR_OK) + return false; /* error already set */ + /* Create a data segment to store the compressed image */ + if((data = new_data(file_handle, scn)) == NULL) + PUBLIC_RETURN(LIBR_ERROR_NEWDATA, "Failed to create data for section"); + } + else + return false; /* error already set */ + + header[header_size++] = (char) type; + switch(type) + { + case LIBR_UNCOMPRESSED: + /* Do nothing, just stick the data in */ + break; + case LIBR_COMPRESSED: + { + char *compressed_buffer = NULL, *uncompressed_buffer = buffer; + unsigned long compressed_size = 0, uncompressed_size = size; + uint32_t size_temp; + + /* Store the uncompressed size to the header */ + size_temp = uncompressed_size; + memcpy(&header[header_size], &size_temp, sizeof(uint32_t)); + header_size += sizeof(uint32_t); + /* Compress the data for storage */ + compressed_size = ceil((uncompressed_size+12)*1.1); + compressed_buffer = (char *) malloc(compressed_size); + if(compress((unsigned char *)compressed_buffer, &compressed_size, (unsigned char *)uncompressed_buffer, uncompressed_size) != Z_OK) + { + free(compressed_buffer); + PUBLIC_RETURN(LIBR_ERROR_COMPRESS, "Failed to compress resource data"); + } + /* From here on treat the compressed buffer as the data */ + buffer = compressed_buffer; + size = compressed_size; + } break; + default: + PUBLIC_RETURN(LIBR_ERROR_INVALIDTYPE, "Invalid data storage type specified"); + } + /* Store the resource header data */ + if(set_data(file_handle, scn, data, 0, &header[0], header_size).status != LIBR_OK) + return false; /* error already set */ + /* Create a data segment to store the post-header data + * NOTE: For existing files the data of the section is represented as a continuous stream + * (so calling elf_getdata now WILL NOT return the post-header data) + */ + if((data = new_data(file_handle, scn)) == NULL) + PUBLIC_RETURN(LIBR_ERROR_NEWDATA, "Failed to create data for section"); + /* Store the actual user data to the section */ + if(set_data(file_handle, scn, data, header_size, buffer, size).status != LIBR_OK) + return false; /* error already set */ + /* Close compression resources */ + if(type == LIBR_COMPRESSED) + free(buffer); + return true; +} diff --git a/src/libr.h b/src/libr.h new file mode 100644 index 0000000..b1aa1d7 --- /dev/null +++ b/src/libr.h @@ -0,0 +1,416 @@ +/* + * + * Copyright (c) 2008-2011 Erich Hoover + * + * libr - Add resources into ELF binaries + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 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 + * + * To provide feedback, report bugs, or otherwise contact me: + * ehoover at mines dot edu + * + */ + +#ifndef __LIBR_H +#define __LIBR_H + +#include <sys/types.h> + +#define DEPRECATED_FN __attribute__ ((deprecated)) +#define ALIAS_FN(fn) __attribute__ ((weak, alias (#fn))) + +/** + * @addtogroup libr_status libr_status + * @brief Enumeration of possible libr status values. + * @{ + * \#include <libr.h> + */ +/** Possible libr status values */ +typedef enum { + LIBR_OK = 0, /**< Success */ + LIBR_ERROR_GETEHDR = -1, /**< Failed to obtain ELF header: */ + LIBR_ERROR_NOTABLE = -2, /**< No ELF string table */ + LIBR_ERROR_TABLE = -3, /**< Failed to open string table: */ + LIBR_ERROR_GETDATA = -4, /**< Failed to obtain data of section */ + LIBR_ERROR_GETSHDR = -5, /**< Failed to obtain ELF section header: */ + LIBR_ERROR_SIZEMISMATCH = -6, /**< Section's data size does not make sense */ + LIBR_ERROR_UPDATE = -7, /**< Failed to perform dynamic update: */ + LIBR_ERROR_NEWSECTION = -8, /**< Failed to create new section */ + LIBR_ERROR_NEWDATA = -9, /**< Failed to create data for section */ + LIBR_ERROR_REMOVESECTION = -10, /**< Failed to remove section: */ + LIBR_ERROR_NOSECTION = -11, /**< ELF resource section not found */ + LIBR_ERROR_STRPTR = -12, /**< Failed to obtain section string pointer: */ + LIBR_ERROR_NOTRESOURCE = -13, /**< Not a valid libr-resource */ + LIBR_ERROR_EXPANDSECTION = -14, /**< Failed to expand section */ + LIBR_ERROR_WRONGFORMAT = -15, /**< Invalid input file format */ + LIBR_ERROR_SETFLAGS = -16, /**< Failed to set flags for section */ + LIBR_ERROR_NOPERM = -17, /**< Open handle with LIBR_READ_WRITE access */ + LIBR_ERROR_NOSIZE = -18, /**< Failed to obtain file size */ + LIBR_ERROR_SETFORMAT = -19, /**< Failed to set output file format to input file format */ + LIBR_ERROR_SETARCH = -20, /**< Failed to set output file architecture to input file architecture */ + LIBR_ERROR_OVERWRITE = -21, /**< Section already exists, over-write not specified */ + LIBR_ERROR_COMPRESS = -22, /**< Failed to compress resource data */ + LIBR_ERROR_INVALIDTYPE = -23, /**< Invalid data storage type specified */ + LIBR_ERROR_MEMALLOC = -24, /**< Failed to allocate memory for data */ + LIBR_ERROR_INVALIDPARAMS = -25, /**< Invalid parameters passed to function */ + LIBR_ERROR_UNCOMPRESS = -26, /**< Failed to uncompress resource data */ + LIBR_ERROR_ZLIBINIT = -27, /**< zlib library initialization failed */ + LIBR_ERROR_OPENFAILED = -28, /**< Failed to open input file */ + LIBR_ERROR_BEGINFAILED = -29, /**< Failed to open ELF file: */ + LIBR_ERROR_WRITEPERM = -30, /**< No write permission for file */ + LIBR_ERROR_UNSUPPORTED = -31, /**< The requested operation is not supported by the backend */ +} libr_status; +/** + * @} + */ + +typedef enum { + LIBR_READ = 0, + LIBR_READ_WRITE = 1, +} libr_access_t; + +typedef enum { + LIBR_UNCOMPRESSED = 0, + LIBR_COMPRESSED = 1 +} libr_type_t; + +typedef enum { + LIBR_NOOVERWRITE = 0, + LIBR_OVERWRITE = 1 +} libr_overwrite_t; + +#ifdef __LIBR_BUILD__ + #include "libr-internal.h" + #if __LIBR_BACKEND_libbfd__ + #include "libr-bfd.h" + #elif __LIBR_BACKEND_libelf__ + #include "libr-elf.h" + #elif __LIBR_BACKEND_readonly__ + #include "libr-ro.h" + #else /* LIBR_BACKEND */ + #error "Unhandled backend" + #endif /* LIBR_BACKEND */ + #include "libr-backends.h" +#else + struct _libr_file; + typedef struct _libr_file libr_file; +#endif /* __LIBR_BUILD__ */ + +/************************************************************************* + * libr Resource Management API + *************************************************************************/ + +/** + * @page libr_clear Remove a resource from an ELF executable. + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>int libr_clear(libr_file *handle, char *resourcename);</b> + * + * @section DESCRIPTION + * Removes a libr-compatible resource from an ELF executable. The handle + * must be opened using <b>libr_open</b>(3) with either <b>LIBR_WRITE</b> + * or <b>LIBR_READ_WRITE</b> access in order to remove a resource. + * + * Please note that resource removal does not occur until the handle is + * closed using <b>libr_close</b>(3). + * + * @param handle A handle returned by <b>libr_open</b>(3). + * @param resourcename The name of the libr-compatible resource to remove. + * + * @section SA SEE ALSO + * <b>libr_open</b>(3), <b>libr_close</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +int libr_clear(libr_file *handle, char *resourcename); + +/** + * @page libr_close Close a handle to an ELF executable. + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>void libr_close(libr_file *handle);</b> + * + * @section DESCRIPTION + * Handles opened with <b>libr_open</b>(3) should be closed with + * <b>libr_close</b>() when they are no-longer needed by the calling + * application. + * + * @param handle The handle to close. + * + * @section SA SEE ALSO + * <b>libr_open</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +void libr_close(libr_file *handle); + +/** + * @page libr_errmsg Return a detailed description of the last + * libr-related error. + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>char *libr_errmsg(void);</b> + * + * @section DESCRIPTION + * Returns a detailed string describing the last error encountered by + * the libr resource library. The string is an internal error + * description, so it should not be freed. + * + * If no errors have been encountered then NULL is returned. + * + * @section SA SEE ALSO + * <b>libr_errno</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +char *libr_errmsg(void); + +/** + * @page libr_errno Return a status code describing the last + * libr-related error. + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>libr_status libr_errno(void);</b> + * + * @section DESCRIPTION + * Returns a code corresponding to the last error encountered by + * the libr resource library. For a detailed description of possible + * return values see <b>libr_status</b>(3). + * + * To get a user-readable string corresponding to the last error the + * <b>libr_errmsg</b>(3) function should be used instead. + * + * If no errors have been encountered then <b>LIBR_OK</b> is returned. + * + * @section SA SEE ALSO + * <b>libr_errmsg</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +libr_status libr_errno(void); + +/** + * @page libr_list Obtain the name of a libr ELF resource (by index). + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>char *libr_list(libr_file *file_handle, unsigned int resourceid);</b> + * + * @section DESCRIPTION + * Returns the name of a libr-compatible resource stored in an ELF binary + * corresponding to the given resource index. The index value ranges from + * 0 to the value returned by <b>libr_resources</b>(3), which returns the + * total number of libr-compatible resources stored in the ELF binary. + * + * @param handle A handle returned by <b>libr_open</b>(3). + * @param resourceid The index of the libr-compatible resource for which + * the name will be returned. + * + * @return Returns a string containing the name of the resource section. This + * string is allocated when the function is called, so it <i>must be + * unallocated</i> with a call to <b>free</b>(3) when it is no-longer + * needed. NULL is returned on failure. + * + * @section SA SEE ALSO + * <b>libr_open</b>(3), <b>free</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +char *libr_list(libr_file *file_handle, unsigned int resourceid); + +/** + * @page libr_malloc Obtain the data corresponding to a libr ELF resource. + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>char *libr_malloc(libr_file *handle, char *resourcename, size_t *size);</b> + * + * @section DESCRIPTION + * Returns the contents of a libr-compatible resource stored in an ELF binary + * corresponding to the given resource name. + * + * @param handle A handle returned by <b>libr_open</b>(3). + * @param resourcename The name of the libr-compatible resource for which + * the data will be returned. + * @param size A pointer for storing the length of the data contained in the + * the resource. May be NULL. + * + * @return Returns NULL on failure, the pointer to a buffer containing the data + * for the resource on success. When the buffer is no-longer used it must + * be unallocated using a call to <b>free</b>(3). + * + * @section SA SEE ALSO + * <b>libr_open</b>(3), <b>free</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +char *libr_malloc(libr_file *handle, char *resourcename, size_t *size); + +/** + * @page libr_open Open an ELF executable file for resource management. + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>libr_file *libr_open(char *filename, libr_access_t access);</b> + * + * @section DESCRIPTION + * <b>libr_open</b>() can be used on any ELF executable, however, + * <b>libr_open</b>() called with <b>LIBR_READ</b> access is only useful + * for executables that already contain libr-compatible stored resources. + * + * An application can easily access its own resources by passing NULL for + * the filename and requesting <b>LIBR_READ</b> access. For the obvious + * reason that an actively-open application cannot edit itself, the + * calling binary may only request <b>LIBR_READ</b> access. + * + * @param filename ELF executable to manage. Pass a NULL pointer as the + * filename in order to access the calling binary (<b>LIBR_READ</b> + * access only) @param access Requested access type (<b>LIBR_READ</b>, + * <b>LIBR_WRITE</b>, <b>LIBR_READ_WRITE</b>), the valid operations for + * the returned handle will be restricted based upon the requested access. + * @return Returns a libr file handle on success, NULL on failure. The + * handle should be freed with <b>libr_close</b>(3) when no-longer used. + * + * @section SA SEE ALSO + * <b>libr_close</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +libr_file *libr_open(char *filename, libr_access_t access); + +/** + * @page libr_read Read out the contents of a libr ELF resource. + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>int libr_read(libr_file *handle, char *resourcename, char *buffer);</b> + * + * @section WARNING + * This function does not allocate memory for the buffer, so the buffer must + * be large enough to fit the resource data. For this reason it is suggested + * that <b>libr_malloc</b>(3) be used in preference over this function. + * + * @section DESCRIPTION + * Reads the contents of a resource embedded in an ELF binary, the resource + * must be compatible with the libr specification. + * + * @param handle A handle returned by <b>libr_open</b>(3). + * @return Returns 1 on success, 0 on failure. + * + * @section SA SEE ALSO + * <b>libr_open</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +int libr_read(libr_file *handle, char *resourcename, char *buffer); + +/** + * @page libr_resources Returns the number of resources contained in + * the ELF binary. + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>unsigned int libr_resources(libr_file *handle);</b> + * + * @section DESCRIPTION + * Returns the total number of libr-compatible resources contained + * in the ELF binary. Intended to be used with <b>libr_list</b>(3) + * to return the full list of resources contained in the binary. + * + * @param handle A handle returned by <b>libr_open</b>(3). + * @return The total number of libr resources in the binary. + * + * @section SA SEE ALSO + * <b>libr_open</b>(3), <b>libr_list</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +unsigned int libr_resources(libr_file *handle); + +/** + * @page libr_size Returns the uncompressed size of a libr resource. + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>int libr_size(libr_file *handle, char *resourcename, size_t *size);</b> + * + * @section DESCRIPTION + * Obtain the total number of bytes consumed by the uncompressed + * version of the specific libr-resource. Intended to be used with + * <b>libr_read</b>(3) in order to allocate a large enough buffer + * for the resource. + * + * @param handle A handle returned by <b>libr_open</b>(3). + * @param resourcename The name of the resource for which the + * size of the data section will be returned. + * @param size A pointer for storing the size of the data section. + * This pointer cannot be NULL. + * @return Returns 1 on success, 0 on failure. + * + * @section SA SEE ALSO + * <b>libr_open</b>(3), <b>libr_read</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +int libr_size(libr_file *handle, char *resourcename, size_t *size); + +/** + * @page libr_write Adds a libr resource to an ELF binary. + * @section SYNOPSIS + * \#include <libr.h> + * + * <b>int libr_write(libr_file *handle, char *resourcename, char *buffer, size_t size, libr_type_t type, libr_overwrite_t overwrite);</b> + * + * @section DESCRIPTION + * Adds a libr-compatible resource into the ELF binary. The handle + * must be opened using <b>libr_open</b>(3) with either <b>LIBR_WRITE</b> + * or <b>LIBR_READ_WRITE</b> access in order to add a resource. + * + * @param handle A handle returned by <b>libr_open</b>(3). + * @param resourcename The name of the resource to create. + * @param buffer A string containing the data of the resource. + * @param size The total size of the buffer. + * @param type The method which should be used for storing the + * data (either <b>LIBR_UNCOMPRESSED</b> or + * <b>LIBR_COMPRESSED</b>). + * @param overwrite Whether overwriting an existing resource + * should be permitted (either <b>LIBR_NOOVERWRITE</b> or + * <b>LIBR_OVERWRITE</b>). + * @return Returns 1 on success, 0 on failure. + * + * @section SA SEE ALSO + * <b>libr_open</b>(3) + * + * @section AUTHOR + * Erich Hoover <ehoover@mines.edu> + */ +int libr_write(libr_file *handle, char *resourcename, char *buffer, size_t size, libr_type_t type, libr_overwrite_t overwrite); + +#endif /* __LIBR_H */ + diff --git a/src/onecanvas.c b/src/onecanvas.c new file mode 100644 index 0000000..e53ece7 --- /dev/null +++ b/src/onecanvas.c @@ -0,0 +1,446 @@ +/* + * + * Copyright (c) 2010 Erich Hoover + * + * libr "one canvas" - Handle multiple icons stored in a single "one canvas" + * SVG document. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 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 + * + * To provide feedback, report bugs, or otherwise contact me: + * ehoover at mines dot edu + * + */ + +#include <stdio.h> +#include <string.h> +#include <math.h> +#include <stdlib.h> +#include <time.h> + +#define FALSE 0 +#define TRUE 1 + +typedef struct { + double x; + double y; + double width; + double height; + int icon_width; + int icon_height; +} IconSVG; + +typedef enum { + STATUS_FINDSVG, + STATUS_FINDMETADATA, + STATUS_FINDPUBLISHER_START, + STATUS_FINDPUBLISHER_STOP, + STATUS_FINDHIDDEN, + STATUS_FINDBOUNDS, + STATUS_FAILED, + STATUS_DONE, +} eStatus; + +typedef struct { + IconSVG **iconlist; + int iconlist_num; + eStatus status; + + char *hidden_stop; + char *hidden_start; + char *publisher_stop; + char *publisher_start; + char *coordinate_stop; + char *coordinate_start; +} OneCanvasIconInfo; + +/* + * Find the start of the next XML tag (search for '<') + */ +static inline char *xml_nextTag(char *c) +{ + c++; + if(c == NULL) + return NULL; + return strchr(c, '<'); +} + +/* + * Pull out the name/type of a tag. + */ +static inline char *xml_getTagName(char *c) +{ + char *tag_end = NULL, *tag_space, *tag_close, *tag_feed, *tag_line; + static char tagname[20]; + int tag_len; + + if(++c == NULL) + return NULL; + tag_space = strchr(c, ' '); + tag_close = strchr(c, '>'); + tag_feed = strchr(c, '\r'); + tag_line = strchr(c, '\n'); + if(tag_space) + tag_end = tag_space; + if(tag_close && tag_end > tag_close) + tag_end = tag_close; + if(tag_feed && tag_end > tag_feed) + tag_end = tag_feed; + if(tag_line && tag_end > tag_line) + tag_end = tag_line; + if(!tag_end) + return NULL; + tag_len = tag_end - c; + tag_len = tag_len > 19 ? 19 : tag_len; + strncpy(tagname, c, tag_len); + tagname[tag_len] = '\0'; + return tagname; +} + +/* + * Find the position in the string corresponding to a particular named attribute. + */ +static inline char *xml_getTagAttributePtr(char *c, char *attrname) +{ + char *end, *name; + int found; + + if(++c == NULL) + return NULL; + end = strchr(c, '>'); + while(c < end) + { + int name_len; + char *equal; + + equal = c = strchr(c, '='); + if(c == NULL) + break; + c++; + name = equal; + while(name[0] != ' ' && name[0] != '\t' && name[0] != '\n') + name--; + name++; /* don't include the space */ + name_len = equal-name; + if(name_len != strlen(attrname)) + continue; + if(strncasecmp(attrname, name, name_len) == 0) + { + found = TRUE; + break; + } + } + if(!found) + return NULL; + return c-strlen(attrname)-1; +} + +/* + * Return the value of an XML tag's named attribute. + */ +static inline char *xml_getTagAttribute(char *c, char *attrname) +{ + char *data_end; + int data_len; + char *attr; + + c = xml_getTagAttributePtr(c, attrname); + if(c == NULL) + return NULL; + c+=strlen(attrname); /* skip the name */ + c+=2; /* skip the equals sign and the quote */ + data_end = strchr(c, '"'); + data_len = data_end - c; + attr = (char *) malloc(data_len+1); + strncpy(attr, c, data_len); + attr[data_len] = '\0'; + return attr; +} + +/* + * Find the value of an XML tag attribute and convert it to a number. + */ +static inline double xml_getTagAttributeFloat(char *c, char *attrname) +{ + char *value = xml_getTagAttribute(c, attrname); + double ret; + + if(!value) + return nan("nan"); + sscanf(value, "%lf", &ret); + free(value); + return ret; +} + +/* + * Match the beginning an XML tag by "id" (preferred) or Inkscape's + * label (undesireable but acceptable). + */ +static inline char *xml_idMatchStart(char *stream_pos, char *layer_name) +{ + char *id_acceptable = xml_getTagAttribute(stream_pos, "inkscape:label"); + char *id_preferred = xml_getTagAttribute(stream_pos, "id"); + + if(id_preferred && strncasecmp(id_preferred, layer_name, strlen(layer_name)) == 0) + { + free(id_acceptable); + return id_preferred; + } + if(id_acceptable && strncasecmp(id_acceptable, layer_name, strlen(layer_name)) == 0) + { + free(id_preferred); + return id_acceptable; + } + free(id_acceptable); + free(id_preferred); + return NULL; +} + +/* + * Match the entirety of an XML tag by "id" (preferred) or Inkscape's + * label (undesireable but acceptable). + */ +static inline int xml_idMatch(char *stream_pos, char *layer_name) +{ + char *id_acceptable = xml_getTagAttribute(stream_pos, "inkscape:label"); + char *id_preferred = xml_getTagAttribute(stream_pos, "id"); + int ret = FALSE; + + if((id_preferred && strcasecmp(id_preferred, layer_name) == 0) + || (id_acceptable && strcasecmp(id_acceptable, layer_name) == 0)) + ret = TRUE; + free(id_acceptable); + free(id_preferred); + return ret; +} + +/* + * Strip all the XML tags from a string and return only the data not + * contained within any tags. + */ +static inline char *xml_stripTags(char *data, int len) +{ + char *ret = (char *) malloc(len+1); + char *tag_left, *tag_right; + + memcpy(ret, data, len+1); + ret[len] = '\0'; + while((tag_left = strchr(ret, '<')) != NULL) + { + tag_right = strchr(ret, '>'); + memmove(tag_left, tag_right+1, strlen(ret)-(tag_right-ret)); + } + return ret; +} + +/* + * Return the information for all of the icons within a "one-canvas" + * data stream. + */ +OneCanvasIconInfo onecanvas_geticons(char *stream) +{ + eStatus status = STATUS_FINDSVG; + unsigned int stream_size = 0; + OneCanvasIconInfo info; + char *publisher = NULL; + char *stream_pos; + int i; + + memset(&info, 0, sizeof(info)); + stream_pos = stream; + while(stream_pos) + { + char *name = xml_getTagName(stream_pos); + + if(!name) + { + stream_pos = xml_nextTag(stream_pos); + continue; + } + switch(status) + { + case STATUS_FINDSVG: + { + if(strcasecmp(name, "svg") == 0) + { + info.coordinate_start = xml_getTagAttributePtr(stream_pos, "x"); + info.coordinate_stop = xml_getTagAttributePtr(stream_pos, "viewBox"); + if(info.coordinate_start == NULL || info.coordinate_stop == NULL) + { + status = STATUS_FAILED; + break; + } + info.coordinate_stop = strchr(info.coordinate_stop, '"')+1; + info.coordinate_stop = strchr(info.coordinate_stop, '"')+1; + status = STATUS_FINDMETADATA; + } + } break; + case STATUS_FINDMETADATA: + { + if(strcasecmp(name, "metadata") == 0) + { + status = STATUS_FINDPUBLISHER_START; + } + else if(strcasecmp(name, "/svg") == 0) + { + status = STATUS_FAILED; + } + } break; + case STATUS_FINDPUBLISHER_START: + { + if(strcasecmp(name, "dc:publisher") == 0) + { + status = STATUS_FINDPUBLISHER_STOP; + info.publisher_start = stream_pos + strlen("<dc:publisher>"); + } + else if(strcasecmp(name, "/metadata") == 0) + { + status = STATUS_FAILED; + } + } break; + case STATUS_FINDPUBLISHER_STOP: + { + if(strcasecmp(name, "/dc:publisher") == 0) + { + info.publisher_stop = stream_pos; + publisher = xml_stripTags(info.publisher_start, info.publisher_stop-info.publisher_start); + if(strcasecmp(publisher, "one-canvas") == 0) + status = STATUS_FINDHIDDEN; + else + status = STATUS_FAILED; + } + else if(strcasecmp(name, "/metadata") == 0) + { + status = STATUS_FAILED; + } + } break; + case STATUS_FINDHIDDEN: + { + if(strcasecmp(name, "g") == 0) + { + if(xml_idMatch(stream_pos, "hidden")) + { + char *style_start; + + info.hidden_start = stream_pos; + info.hidden_stop = info.hidden_start; + style_start = xml_getTagAttributePtr(stream_pos, "style"); + if(style_start) + { + info.hidden_start = style_start; + info.hidden_stop = strchr(style_start, '"')+1; + info.hidden_stop = strchr(info.hidden_stop, '"')+1; + } + else + { + info.hidden_start += strlen("<g "); + info.hidden_stop += strlen("<g "); + } + status = STATUS_FINDBOUNDS; + } + } + } break; + case STATUS_FINDBOUNDS: + { + if(strcasecmp(name, "rect") == 0) + { + char *layer_name = xml_idMatchStart(stream_pos, "iconlayer-"); + + if(layer_name != NULL) + { + IconSVG *icon = (IconSVG *) malloc(sizeof(IconSVG)); + + icon->x = xml_getTagAttributeFloat(stream_pos, "x"); + icon->y = xml_getTagAttributeFloat(stream_pos, "y"); + icon->width = xml_getTagAttributeFloat(stream_pos, "width"); + icon->height = xml_getTagAttributeFloat(stream_pos, "height"); + sscanf(layer_name, "iconlayer-%dx%d", &(icon->icon_width), &(icon->icon_height)); + free(layer_name); + status = STATUS_FINDBOUNDS; + info.iconlist = (IconSVG **) realloc(info.iconlist, (info.iconlist_num+1)*sizeof(IconSVG *)); + info.iconlist[info.iconlist_num] = icon; + info.iconlist_num++; + } + } + else if(strcasecmp(name, "/g") == 0) + { + status = STATUS_DONE; + } + } break; + default: + break; + } + if(status == STATUS_DONE || status == STATUS_FAILED) + break; + stream_pos = xml_nextTag(stream_pos); + } + free(publisher); + info.status = status; + return info; +} + +/* + * Obtain a single icon from the "one-canvas" stream corresponding + * to a particular icon size. + */ +char *onecanvas_geticon_bysize(char *icon_data, int requested_size) +{ + OneCanvasIconInfo info = onecanvas_geticons(icon_data); + char *ret = NULL; + int i; + + if(info.status == STATUS_DONE && info.iconlist_num > 0) + { + int closest_diff = abs(info.iconlist[0]->icon_width - requested_size); + int tocoord_length, topubl_length, tohidden_length; + int icon_id = 0; + IconSVG *icon; + int ret_max; + + for(i=0;i<info.iconlist_num;i++) + { + int size_diff = abs(info.iconlist[i]->icon_width - requested_size); + + if(size_diff < closest_diff) + { + closest_diff = size_diff; + icon_id = i; + } + } + icon = info.iconlist[icon_id]; + /* Note: 200 characters is a very generous over estimate for the data we add in */ + ret_max = strlen(icon_data)+1+200; + ret = (char *) malloc(ret_max); + tocoord_length = info.coordinate_start-icon_data; + snprintf(ret, ret_max, "%.*s", tocoord_length, icon_data); + /* Output the coordinates of the icon */ + snprintf(&ret[strlen(ret)], ret_max-strlen(ret), "\nx=\"0px\"\ny=\"0px\"\n"); + snprintf(&ret[strlen(ret)], ret_max-strlen(ret), "width=\"%d\"\n", icon->icon_width); + snprintf(&ret[strlen(ret)], ret_max-strlen(ret), "height=\"%d\"\n", icon->icon_height); + snprintf(&ret[strlen(ret)], ret_max-strlen(ret), "viewBox=\"%lf %lf %lf %lf\"\n", icon->x, icon->y, icon->width, icon->height); + topubl_length = info.publisher_start-info.coordinate_stop; + snprintf(&ret[strlen(ret)], ret_max-strlen(ret), "%.*s", topubl_length, info.coordinate_stop); + /* Hide the "hidden" layer */ + tohidden_length = info.hidden_start-info.publisher_stop; + snprintf(&ret[strlen(ret)], ret_max-strlen(ret), "%.*s", tohidden_length, info.publisher_stop); + snprintf(&ret[strlen(ret)], ret_max-strlen(ret), "\ndisplay=\"none\"\n"); + /* Output the rest of the document */ + snprintf(&ret[strlen(ret)], ret_max-strlen(ret), "%s", info.hidden_stop); + } + for(i=0;i<info.iconlist_num;i++) + free(info.iconlist[i]); + free(info.iconlist); + return ret; +}
\ No newline at end of file diff --git a/src/onecanvas.h b/src/onecanvas.h new file mode 100644 index 0000000..e201417 --- /dev/null +++ b/src/onecanvas.h @@ -0,0 +1,6 @@ +#ifndef __ONECANVAS_H +#define __ONECANVAS_H + +char *onecanvas_geticon_bysize(char *icon_data, int requested_size); + +#endif /* __ONECANVAS_H */ diff --git a/src/tempfiles.c b/src/tempfiles.c new file mode 100644 index 0000000..edf72a1 --- /dev/null +++ b/src/tempfiles.c @@ -0,0 +1,317 @@ +/* + * + * Copyright (c) 2009 Erich Hoover + * + * libr temp files - Handle temporary files and handles that require cleanup + * when libr closes. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation; either version 2.1 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 + * + * To provide feedback, report bugs, or otherwise contact me: + * ehoover at mines dot edu + * + */ + +#include "tempfiles.h" + +/* For malloc/free and mkdtemp */ +#include <stdlib.h> + +/* For string handling */ +#include <string.h> +#include <stdio.h> + +/* For directory cleanup */ +#include <unistd.h> +#include <dirent.h> + +/* For directory creation */ +#include <sys/stat.h> +#include <sys/types.h> +#include <errno.h> + +#ifndef FALSE +#define FALSE 0 +#endif +#ifndef TRUE +#define TRUE 1 +#endif + +#ifndef DOXYGEN_SHOULD_SKIP_THIS + +/* Hold on to folder names for cleanup when libr is removed from memory */ +typedef struct CLEANUPFOLDER { + char *folder; + struct CLEANUPFOLDER *next; +} CleanupFolder; +CleanupFolder *folders_to_remove = NULL; + +/* Hold on to libr handles for cleanup when libr is removed from memory */ +typedef struct CLEANUPHANDLE { + int internal; /* do not warn the user about cleaning this handle up */ + libr_file *handle; + struct CLEANUPHANDLE *next; +} CleanupHandle; +CleanupHandle *handles_to_remove = NULL; + +#endif /* DOXYGEN_SHOULD_SKIP_THIS */ + +/* + * Register a folder for cleanup when libr is removed from memory + */ +void register_folder_cleanup(char *temp_folder) +{ + CleanupFolder *folder = malloc(sizeof(CleanupFolder)); + + folder->folder = strdup(temp_folder); + folder->next = NULL; + if(folders_to_remove != NULL) + { + CleanupFolder *f; + + for(f = folders_to_remove; f->next != NULL; f = f->next) {} + f->next = folder; + } + else + folders_to_remove = folder; +} + +/* + * Register a libr handle for cleanup when libr is removed from memory + */ +void register_handle_cleanup(libr_file *handle) +{ + CleanupHandle *h = malloc(sizeof(CleanupHandle)); + + h->handle = handle; + h->internal = FALSE; + h->next = NULL; + if(handles_to_remove != NULL) + { + CleanupHandle *i; + + for(i = handles_to_remove; i->next != NULL; i = i->next) {} + i->next = h; + } + else + handles_to_remove = h; +} + +/* + * Remove a libr handle from the cleanup list + */ +void unregister_handle_cleanup(libr_file *handle) +{ + CleanupHandle *i, *last = NULL; + int found = FALSE; + + if(handles_to_remove == NULL) + { + printf("Unregistering handle with no list of cleanup handles!\n"); + return; + } + for(i = handles_to_remove; i != NULL; last = i, i = i->next) + { + if(i->handle == handle) + { + if(last == NULL) + handles_to_remove = i->next; + else + last->next = i->next; + free(i); + found = TRUE; + break; + } + } + if(!found) + printf("Could not find handle to remove from cleanup list!\n"); +} + +/* + * Flag a handle as internal (do not warn about unsafe cleanup) + */ +void register_internal_handle(libr_file *handle) +{ + int found = FALSE; + CleanupHandle *i; + + if(handles_to_remove == NULL) + { + printf("No cleanup list!\n"); + return; + } + for(i = handles_to_remove; i != NULL; i = i->next) + { + if(i->handle == handle) + { + i->internal = TRUE; + found = TRUE; + break; + } + } + if(!found) + printf("Could not find handle in cleanup list!\n"); +} + +/* + * Cleanup a temporary folder used to hack the inability to load resources from a buffer + */ +void cleanup_folder(char *temp_folder) +{ + char *filepath = (char *) malloc(PATH_MAX); + DIR *dir = opendir(temp_folder); + struct dirent *file; + + while((file = readdir(dir)) != NULL) + { + char *filename = file->d_name; + + /* Do not delete "self" or "parent" directory entries */ + if(!strcmp(filename, ".") || !strcmp(filename, "..")) + continue; + /* But delete anything else */ + strcpy(filepath, temp_folder); + strcat(filepath, "/"); + strcat(filepath, filename); + if(file->d_type == DT_DIR) + cleanup_folder(filepath); + else + { + if(unlink(filepath)) + printf("libr failed to cleanup '%s' in temporary folder: %m\n", filename); + } + } + free(filepath); + closedir(dir); + if(rmdir(temp_folder) != 0) + printf("libr failed to remove temporary folder: %m\n"); +} + +/* + * Perform cleanup when libr is removed from memory + */ +void do_cleanup(void) __attribute__((destructor)); +void do_cleanup(void) +{ + CleanupFolder *f, *fnext; + CleanupHandle *h, *hnext; + + /* Cleanup folders */ + for(f = folders_to_remove; f != NULL; f = fnext) + { + folders_to_remove = NULL; + fnext = f->next; + cleanup_folder(f->folder); + free(f->folder); + free(f); + } + /* Cleanup handles */ + for(h = handles_to_remove; h != NULL; h = hnext) + { + handles_to_remove = NULL; + hnext = h->next; + /* Unless the handle was created internally then warn the developer to cleanup their act */ + if(!h->internal) + printf("Warning: Application did not cleanup resource handle: %p\n", h->handle); + libr_close_internal(h->handle); + free(h); + } +} + +/* + * Build all the directories required by a resource + * (and construct the output string) + */ +int make_valid_path(char *out_path, size_t maxpath, char *start_folder, char *resource_name) +{ + char *a, *c = resource_name; + + strcpy(out_path, start_folder); + while((a=strchr(c, '/')) != NULL) + { + strcat(out_path, "/"); + strncat(out_path, c, (size_t) (a-c)); + if(mkdir(out_path, S_IRUSR|S_IWUSR|S_IXUSR) != 0) + { + if(errno != EEXIST) + { + printf("failed to make directory: %s %m\n", out_path); + return false; + } + } + c = a+1; + } + strcat(out_path, "/"); + strcat(out_path, c); + return true; +} + +/* + * Extract all the resources from the ELF file for use by the resource loader + */ +char *libr_extract_resources(libr_file *handle) +{ + char *temp_mask = strdup(LIBR_TEMPFILE); + char *temp_folder; + int i = 0; + + temp_folder = mkdtemp(temp_mask); + if(temp_folder == NULL) + { + /* failed to extract ELF resources, could not create a temporary path */ + goto failed; + } + /* If this library cannot dynamically load resources then pull out all the resources to a temporary directory */ + for(i=0;i<libr_resources(handle);i++) + { + char *resource_name = libr_list(handle, i); + char *file_path[PATH_MAX]; + size_t resource_size; + FILE *file_handle; + char *resource; + + resource = libr_malloc(handle, resource_name, &resource_size); + if(!make_valid_path((char *)file_path, sizeof(file_path), temp_folder, resource_name)) + { + /* failed to build the path required by a resource */ + cleanup_folder(temp_folder); + temp_folder = NULL; + goto failed; + } + file_handle = fopen((const char *) file_path, "w"); + if(file_handle == NULL) + { + /* failed to extract ELF resources, could not write to temporary path */ + cleanup_folder(temp_folder); + temp_folder = NULL; + goto failed; + } + /* if the resource is empty then fwrite will fail */ + if( (resource_size != 0) && (fwrite(resource, resource_size, 1, file_handle) != 1) ) + { + /* failed to extract ELF resources, temporary path out of space? */ + cleanup_folder(temp_folder); + temp_folder = NULL; + goto failed; + } + fclose(file_handle); + free(resource); + } +failed: + if(temp_folder != NULL) + temp_folder = strdup(temp_folder); + free(temp_mask); + return temp_folder; +} diff --git a/src/tempfiles.h b/src/tempfiles.h new file mode 100644 index 0000000..5b9b0bc --- /dev/null +++ b/src/tempfiles.h @@ -0,0 +1,13 @@ +#ifndef __TEMPFILES_H +#define __TEMPFILES_H + +#include "libr.h" + +void cleanup_folder(char *temp_folder); +void register_handle_cleanup(libr_file *handle); +void unregister_handle_cleanup(libr_file *handle); +void register_internal_handle(libr_file *handle); +void register_folder_cleanup(char *temp_folder); +char *libr_extract_resources(libr_file *handle); + +#endif /* __TEMPFILES_H */ |