/* builder-utils.c

 *

 * Copyright (C) 2015 Red Hat, Inc

 *

 * This file 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 file 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public License

 * along with this program.  If not, see <http://www.gnu.org/licenses/>.

 *

 * Authors:

 *       Alexander Larsson <alexl@redhat.com>

 */

#include "config.h"

#include <stdlib.h>

#include <libelf.h>

#include <gelf.h>

#include <dwarf.h>

#include <sys/mman.h>

#include <sys/uio.h>

#include <stdio.h>

#include <string.h>

#include <glib-unix.h>

#include <gio/gunixfdlist.h>

#include <gio/gunixoutputstream.h>

#include <gio/gunixinputstream.h>

#include "builder-flatpak-utils.h"

#include "builder-utils.h"

G_DEFINE_QUARK (builder-curl-error, builder_curl_error)

G_DEFINE_QUARK (builder-yaml-parse-error, builder_yaml_parse_error)

#ifdef FLATPAK_BUILDER_ENABLE_YAML

#include <yaml.h>

G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (yaml_parser_t, yaml_parser_delete)

G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (yaml_document_t, yaml_document_delete)

#endif

char *

builder_uri_to_filename (const char *uri)

{

  GString *s;

  const char *p;

  s = g_string_new ("");

  for (p = uri; *p != 0; p++)

    {

      if (*p == '/' || *p == ':')

        {

          while (p[1] == '/' || p[1] == ':')

            p++;

          g_string_append_c (s, '_');

        }

      else

        {

          g_string_append_c (s, *p);

        }

    }

  return g_string_free (s, FALSE);

}

static const char *

inplace_basename (const char *path)

{

  const char *last_slash;

  last_slash = strrchr (path, '/');

  if (last_slash)

    path = last_slash + 1;

  return path;

}

/* Adds all matches of path to prefix. There can be multiple, because

 * e.g matching "a/b/c" against "/a" matches both "a/b" and "a/b/c"

 *

 * If pattern starts with a slash, then match on the entire

 * path, otherwise just the basename.

 */

void

flatpak_collect_matches_for_path_pattern (const char *path,

                                          const char *pattern,

                                          const char *add_prefix,

                                          GHashTable *to_remove_ht)

{

  const char *rest;

  if (pattern[0] != '/')

    {

      rest = flatpak_path_match_prefix (pattern, inplace_basename (path));

      if (rest != NULL)

        g_hash_table_insert (to_remove_ht, g_strconcat (add_prefix ? add_prefix : "", path, NULL), GINT_TO_POINTER (1));

    }

  else

    {

      /* Absolute pathname match. This can actually match multiple

       * files, as a prefix match should remove all files below that

       * (in this module) */

      rest = flatpak_path_match_prefix (pattern, path);

      while (rest != NULL)

        {

          const char *slash;

          g_autofree char *prefix = g_strndup (path, rest - path);

          g_hash_table_insert (to_remove_ht, g_strconcat (add_prefix ? add_prefix : "", prefix, NULL), GINT_TO_POINTER (1));

          while (*rest == '/')

            rest++;

          if (*rest == 0)

            break;

          slash = strchr (rest, '/');

          rest = slash ? slash : rest + strlen (rest);

        }

    }

}

gboolean

flatpak_matches_path_pattern (const char *path,

                              const char *pattern)

{

  if (pattern[0] != '/')

    path = inplace_basename (path);

  return flatpak_path_match_prefix (pattern, path) != NULL;

}

gboolean

strip (GError **error,

       ...)

{

  gboolean res;

  va_list ap;

  va_start (ap, error);

  res = flatpak_spawn (NULL, NULL, 0, error, "strip", ap);

  va_end (ap);

  return res;

}

gboolean

eu_strip (GError **error,

          ...)

{

  gboolean res;

  va_list ap;

  va_start (ap, error);

  res = flatpak_spawn (NULL, NULL, 0, error, "eu-strip", ap);

  va_end (ap);

  return res;

}

gboolean

eu_elfcompress (GError **error,

                ...)

{

  gboolean res;

  va_list ap;

  va_start (ap, error);

  res = flatpak_spawn (NULL, NULL, 0, error, "eu-elfcompress", ap);

  va_end (ap);

  return res;

}

static gboolean

elf_has_symtab (Elf *elf)

{

  Elf_Scn *scn;

  GElf_Shdr shdr;

  scn = NULL;

  while ((scn = elf_nextscn (elf, scn)) != NULL)

    {

      if (gelf_getshdr (scn, &shdr) == NULL)

        continue;

      if (shdr.sh_type != SHT_SYMTAB)

        continue;

      return TRUE;

    }

  return FALSE;

}

gboolean

is_elf_file (const char *path,

             gboolean   *is_shared,

             gboolean   *is_stripped)

{

  g_autofree char *filename = g_path_get_basename (path);

  struct stat stbuf;

  if (lstat (path, &stbuf) == -1)

    return FALSE;

  if (!S_ISREG (stbuf.st_mode))

    return FALSE;

  /* Self-extracting .zip files can be ELF-executables, but shouldn't be

     treated like them - for example, stripping them breaks their

     operation */

  if (g_str_has_suffix (filename, ".zip"))

    return FALSE;

  if ((strstr (filename, ".so.") != NULL ||

       g_str_has_suffix (filename, ".so")) ||

      (stbuf.st_mode & 0111) != 0)

    {

      glnx_fd_close int fd = -1;

      fd = open (path, O_RDONLY | O_NOFOLLOW | O_CLOEXEC);

      if (fd >= 0)

        {

          Elf *elf;

          GElf_Ehdr ehdr;

          gboolean res = FALSE;

          if (elf_version (EV_CURRENT) == EV_NONE )

            return FALSE;

          elf = elf_begin (fd, ELF_C_READ, NULL);

          if (elf == NULL)

            return FALSE;

          if (elf_kind (elf) == ELF_K_ELF &&

              gelf_getehdr (elf, &ehdr))

            {

              if (is_shared)

                *is_shared = ehdr.e_type == ET_DYN;

              if (is_stripped)

                *is_stripped = !elf_has_symtab (elf);

              res = TRUE;

            }

          elf_end (elf);

          return res;

        }

    }

  return FALSE;

}

gboolean

directory_is_empty (const char *path)

{

  GDir *dir;

  gboolean empty;

  dir = g_dir_open (path, 0, NULL);

  if (g_dir_read_name (dir) == NULL)

    empty = TRUE;

  else

    empty = FALSE;

  g_dir_close (dir);

  return empty;

}

static gboolean

migrate_locale_dir (GFile      *source_dir,

                    GFile      *separate_dir,

                    const char *subdir,

                    GError    **error)

{

  g_autoptr(GFileEnumerator) dir_enum = NULL;

  GFileInfo *next;

  GError *temp_error = NULL;

  dir_enum = g_file_enumerate_children (source_dir, "standard::name,standard::type",

                                        G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS,

                                        NULL, NULL);

  if (!dir_enum)

    return TRUE;

  while ((next = g_file_enumerator_next_file (dir_enum, NULL, &temp_error)))

    {

      g_autoptr(GFileInfo) child_info = next;

      g_autoptr(GFile) locale_subdir = NULL;

      if (g_file_info_get_file_type (child_info) == G_FILE_TYPE_DIRECTORY)

        {

          g_autoptr(GFile) child = NULL;

          const char *name = g_file_info_get_name (child_info);

          g_autofree char *language = g_strdup (name);

          g_autofree char *relative = NULL;

          g_autofree char *target = NULL;

          char *c;

          c = strchr (language, '@');

          if (c != NULL)

            *c = 0;

          c = strchr (language, '_');

          if (c != NULL)

            *c = 0;

          c = strchr (language, '.');

          if (c != NULL)

            *c = 0;

          /* We ship english and C locales always */

          if (strcmp (language, "C") == 0 ||

              strcmp (language, "en") == 0)

            continue;

          child = g_file_get_child (source_dir, g_file_info_get_name (child_info));

          relative = g_build_filename (language, subdir, name, NULL);

          locale_subdir = g_file_resolve_relative_path (separate_dir, relative);

          if (!flatpak_mkdir_p (locale_subdir, NULL, error))

            return FALSE;

          if (!flatpak_cp_a (child, locale_subdir,

                             FLATPAK_CP_FLAGS_MERGE | FLATPAK_CP_FLAGS_MOVE,

                             NULL, NULL, error))

            return FALSE;

          target = g_build_filename ("../../share/runtime/locale", relative, NULL);

          if (!g_file_make_symbolic_link (child, target,

                                          NULL, error))

            return FALSE;

        }

    }

  if (temp_error != NULL)

    {

      g_propagate_error (error, temp_error);

      return FALSE;

    }

  return TRUE;

}

gboolean

builder_migrate_locale_dirs (GFile   *root_dir,

                             GError **error)

{

  g_autoptr(GFile) separate_dir = NULL;

  g_autoptr(GFile) lib_locale_dir = NULL;

  g_autoptr(GFile) share_locale_dir = NULL;

  lib_locale_dir = g_file_resolve_relative_path (root_dir, "lib/locale");

  share_locale_dir = g_file_resolve_relative_path (root_dir, "share/locale");

  separate_dir = g_file_resolve_relative_path (root_dir, "share/runtime/locale");

  if (!migrate_locale_dir (lib_locale_dir, separate_dir, "lib", error))

    return FALSE;

  if (!migrate_locale_dir (share_locale_dir, separate_dir, "share", error))

    return FALSE;

  return TRUE;

}

#ifdef FLATPAK_BUILDER_ENABLE_YAML

static JsonNode *

parse_yaml_node_to_json (yaml_document_t *doc, yaml_node_t *node)

{

  JsonNode *json = json_node_alloc ();

  const char *scalar = NULL;

  g_autoptr(JsonArray) array = NULL;

  g_autoptr(JsonObject) object = NULL;

  yaml_node_item_t *item = NULL;

  yaml_node_pair_t *pair = NULL;

  switch (node->type)

    {

    case YAML_NO_NODE:

      json_node_init_null (json);

      break;

    case YAML_SCALAR_NODE:

      scalar = (gchar *) node->data.scalar.value;

      if (node->data.scalar.style == YAML_PLAIN_SCALAR_STYLE)

        {

          if (strcmp (scalar, "true") == 0)

            {

              json_node_init_boolean (json, TRUE);

              break;

            }

          else if (strcmp (scalar, "false") == 0)

            {

              json_node_init_boolean (json, FALSE);

              break;

            }

          else if (strcmp (scalar, "null") == 0)

            {

              json_node_init_null (json);

              break;

            }

          if (*scalar != '\0')

            {

              gchar *endptr;

              gint64 num = g_ascii_strtoll (scalar, &endptr, 10);

              if (*endptr == '\0')

                {

                  json_node_init_int (json, num);

                  break;

                }

              // Make sure that N.N, N., and .N (where N is a digit) are picked up as numbers.

              else if (*endptr == '.' && (endptr != scalar || endptr[1] != '\0'))

                {

                  g_ascii_strtoll (endptr + 1, &endptr, 10);

                  if (*endptr == '\0')

                    g_warning ("%zu:%zu: '%s' will be parsed as a number by many YAML parsers",

                               node->start_mark.line + 1, node->start_mark.column + 1, scalar);

                }

            }

        }

      json_node_init_string (json, scalar);

      break;

    case YAML_SEQUENCE_NODE:

      array = json_array_new ();

      for (item = node->data.sequence.items.start; item < node->data.sequence.items.top; item++)

        {

          yaml_node_t *child = yaml_document_get_node (doc, *item);

          if (child != NULL)

            json_array_add_element (array, parse_yaml_node_to_json (doc, child));

        }

      json_node_init_array (json, array);

      break;

    case YAML_MAPPING_NODE:

      object = json_object_new ();

      for (pair = node->data.mapping.pairs.start; pair < node->data.mapping.pairs.top; pair++)

        {

          yaml_node_t *key = yaml_document_get_node (doc, pair->key);

          yaml_node_t *value = yaml_document_get_node (doc, pair->value);

          g_warn_if_fail (key->type == YAML_SCALAR_NODE);

          json_object_set_member (object, (gchar *) key->data.scalar.value,

                                  parse_yaml_node_to_json (doc, value));

        }

      json_node_init_object (json, object);

      break;

    }

  return json;

}

static JsonNode *

parse_yaml_to_json (const gchar *contents,

                    GError      **error)

{

  if (error)

    *error = NULL;

  g_auto(yaml_parser_t) parser = {0};

  g_auto(yaml_document_t) doc = {{0}};

  if (!yaml_parser_initialize (&parser))

    g_error ("yaml_parser_initialize is out of memory.");

  yaml_parser_set_input_string (&parser, (yaml_char_t *) contents, strlen (contents));

  if (!yaml_parser_load (&parser, &doc))

    {

      g_set_error (error, BUILDER_YAML_PARSE_ERROR, parser.error, "%zu:%zu: %s", parser.problem_mark.line + 1,

                   parser.problem_mark.column + 1, parser.problem);

      return NULL;

    }

  yaml_node_t *root = yaml_document_get_root_node (&doc;;

  if (root == NULL)

    {

      g_set_error (error, BUILDER_YAML_PARSE_ERROR, YAML_PARSER_ERROR,

                   "Document has no root node.");

      return NULL;

    }

  return parse_yaml_node_to_json (&doc, root);

}

#else // FLATPAK_BUILDER_ENABLE_YAML

static JsonNode *

parse_yaml_to_json (const gchar *contents,

                    GError      **error)

{

  g_set_error (error, BUILDER_YAML_PARSE_ERROR, 0, "flatpak-builder was not compiled with YAML support.");

  return NULL;

}

#endif  // FLATPAK_BUILDER_ENABLE_YAML

JsonNode *

builder_json_node_from_data (const char *relpath,

                             const char *contents,

                             GError    **error)

{

  if (g_str_has_suffix (relpath, ".yaml") || g_str_has_suffix (relpath, ".yml"))

    return parse_yaml_to_json (contents, error);

  else

    return json_from_string (contents, error);

}

GObject *

builder_gobject_from_data (GType       gtype,

                           const char *relpath,

                           const char *contents,

                           GError    **error)

{

  g_autoptr(JsonNode) json = builder_json_node_from_data (relpath, contents, error);

  if (json != NULL)

    return json_gobject_deserialize (gtype, json);

  else

    return NULL;

}

/*

 * This code is based on debugedit.c from rpm, which has this copyright:

 *

 *

 * Copyright (C) 2001, 2002, 2003, 2005, 2007, 2009, 2010, 2011 Red Hat, Inc.

 * Written by Alexander Larsson <alexl@redhat.com>, 2002

 * Based on code by Jakub Jelinek <jakub@redhat.com>, 2001.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation; either version 2, or (at your option)

 * any later version.

 *

 * This program is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software Foundation,

 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */

#define DW_TAG_partial_unit 0x3c

#define DW_FORM_sec_offset 0x17

#define DW_FORM_exprloc 0x18

#define DW_FORM_flag_present 0x19

#define DW_FORM_ref_sig8 0x20

/* keep uptodate with changes to debug_sections */

#define DEBUG_INFO 0

#define DEBUG_ABBREV 1

#define DEBUG_LINE 2

#define DEBUG_ARANGES 3

#define DEBUG_PUBNAMES 4

#define DEBUG_PUBTYPES 5

#define DEBUG_MACINFO 6

#define DEBUG_LOC 7

#define DEBUG_STR 8

#define DEBUG_FRAME 9

#define DEBUG_RANGES 10

#define DEBUG_TYPES 11

#define DEBUG_MACRO 12

#define DEBUG_GDB_SCRIPT 13

#define NUM_DEBUG_SECTIONS 14

static const char * debug_section_names[] = {

  ".debug_info",

  ".debug_abbrev",

  ".debug_line",

  ".debug_aranges",

  ".debug_pubnames",

  ".debug_pubtypes",

  ".debug_macinfo",

  ".debug_loc",

  ".debug_str",

  ".debug_frame",

  ".debug_ranges",

  ".debug_types",

  ".debug_macro",

  ".debug_gdb_scripts",

};

typedef struct

{

  unsigned char *data;

  Elf_Data      *elf_data;

  size_t         size;

  int            sec, relsec;

} debug_section_t;

typedef struct

{

  Elf            *elf;

  GElf_Ehdr       ehdr;

  Elf_Scn       **scns;

  const char     *filename;

  int             lastscn;

  debug_section_t debug_sections[NUM_DEBUG_SECTIONS];

  GElf_Shdr      *shdr;

} DebuginfoData;

typedef struct

{

  unsigned char *ptr;

  uint32_t       addend;

} REL;

#define read_uleb128(ptr) ({            \

    unsigned int ret = 0;                 \

    unsigned int c;                       \

    int shift = 0;                        \

    do                                    \

    {                                   \

      c = *ptr++;                       \

      ret |= (c & 0x7f) << shift;       \

      shift += 7;                       \

    } while (c & 0x80);                 \

                                        \

    if (shift >= 35)                      \

      ret = UINT_MAX;                     \

    ret;                                  \

  })

static uint16_t (*do_read_16)(unsigned char *ptr);

static uint32_t (*do_read_32) (unsigned char *ptr);

static int ptr_size;

static int cu_version;

static inline uint16_t

buf_read_ule16 (unsigned char *data)

{

  return data[0] | (data[1] << 8);

}

static inline uint16_t

buf_read_ube16 (unsigned char *data)

{

  return data[1] | (data[0] << 8);

}

static inline uint32_t

buf_read_ule32 (unsigned char *data)

{

  return data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);

}

static inline uint32_t

buf_read_ube32 (unsigned char *data)

{

  return data[3] | (data[2] << 8) | (data[1] << 16) | (data[0] << 24);

}

#define read_1(ptr) *ptr++

#define read_16(ptr) ({                                 \

    uint16_t ret = do_read_16 (ptr);                      \

    ptr += 2;                                             \

    ret;                                                  \

  })

#define read_32(ptr) ({                                 \

    uint32_t ret = do_read_32 (ptr);                      \

    ptr += 4;                                             \

    ret;                                                  \

  })

REL *relptr, *relend;

int reltype;

#define do_read_32_relocated(ptr) ({                    \

    uint32_t dret = do_read_32 (ptr);                     \

    if (relptr)                                           \

    {                                                   \

      while (relptr < relend && relptr->ptr < ptr)      \

        ++relptr;                                       \

      if (relptr < relend && relptr->ptr == ptr)        \

      {                                               \

        if (reltype == SHT_REL)                       \

          dret += relptr->addend;                     \

        else                                          \

          dret = relptr->addend;                      \

      }                                               \

    }                                                   \

    dret;                                                 \

  })

#define read_32_relocated(ptr) ({                       \

    uint32_t ret = do_read_32_relocated (ptr);            \

    ptr += 4;                                             \

    ret;                                                  \

  })

struct abbrev_attr

{

  unsigned int attr;

  unsigned int form;

};

struct abbrev_tag

{

  unsigned int       tag;

  int                nattr;

  struct abbrev_attr attr[0];

};

static GHashTable *

read_abbrev (DebuginfoData *data, unsigned char *ptr)

{

  GHashTable *h;

  unsigned int attr, entry, form;

  struct abbrev_tag *t;

  int size;

  h = g_hash_table_new_full (g_direct_hash, g_direct_equal,

                             NULL, g_free);

  while ((attr = read_uleb128 (ptr)) != 0)

    {

      size = 10;

      entry = attr;

      t = g_malloc (sizeof (*t) + size * sizeof (struct abbrev_attr));

      t->tag = read_uleb128 (ptr);

      t->nattr = 0;

      ++ptr; /* skip children flag.  */

      while ((attr = read_uleb128 (ptr)) != 0)

        {

          if (t->nattr == size)

            {

              size += 10;

              t = g_realloc (t, sizeof (*t) + size * sizeof (struct abbrev_attr));

            }

          form = read_uleb128 (ptr);

          if (form == 2 || (form > DW_FORM_flag_present && form != DW_FORM_ref_sig8))

            g_warning ("%s: Unknown DWARF DW_FORM_%d", data->filename, form);

          t->attr[t->nattr].attr = attr;

          t->attr[t->nattr++].form = form;

        }

      if (read_uleb128 (ptr) != 0)

        g_warning ("%s: DWARF abbreviation does not end with 2 zeros", data->filename);

      g_hash_table_insert (h, GINT_TO_POINTER (entry), t);

    }

  return h;

}

#define IS_DIR_SEPARATOR(c) ((c) == '/')

static char *

canonicalize_path (const char *s, char *d)

{

  char *rv = d;

  char *droot;

  if (IS_DIR_SEPARATOR (*s))

    {

      *d++ = *s++;

      if (IS_DIR_SEPARATOR (*s) && !IS_DIR_SEPARATOR (s[1]))

        /* Special case for "//foo" meaning a Posix namespace  escape.  */

        *d++ = *s++;

      while (IS_DIR_SEPARATOR (*s))

        s++;

    }

  droot = d;

  while (*s)

    {

      /* At this point, we're always at the beginning of a path segment.  */

      if (s[0] == '.' && (s[1] == 0 || IS_DIR_SEPARATOR (s[1])))

        {

          s++;

          if (*s)

            while (IS_DIR_SEPARATOR (*s))

              ++s;

        }

      else if (s[0] == '.' && s[1] == '.' &&

               (s[2] == 0 || IS_DIR_SEPARATOR (s[2])))

        {

          char *pre = d - 1; /* includes slash */

          while (droot < pre && IS_DIR_SEPARATOR (*pre))

            pre--;

          if (droot <= pre && !IS_DIR_SEPARATOR (*pre))

            {

              while (droot < pre && !IS_DIR_SEPARATOR (*pre))

                pre--;

              /* pre now points to the slash */

              if (droot < pre)

                pre++;

              if (pre + 3 == d && pre[0] == '.' && pre[1] == '.')

                {

                  *d++ = *s++;

                  *d++ = *s++;

                }

              else

                {

                  d = pre;

                  s += 2;

                  if (*s)

                    while (IS_DIR_SEPARATOR (*s))

                      s++;

                }

            }

          else

            {

              *d++ = *s++;

              *d++ = *s++;

            }

        }

      else

        {

          while (*s && !IS_DIR_SEPARATOR (*s))

            *d++ = *s++;

        }

      if (IS_DIR_SEPARATOR (*s))

        {

          *d++ = *s++;

          while (IS_DIR_SEPARATOR (*s))

            s++;

        }

    }

  while (droot < d && IS_DIR_SEPARATOR (d[-1]))

    --d;

  if (d == rv)

    *d++ = '.';

  *d = 0;

  return rv;

}

static gboolean

handle_dwarf2_line (DebuginfoData *data, uint32_t off, char *comp_dir, GHashTable *files, GError **error)

{

  unsigned char *ptr = data->debug_sections[DEBUG_LINE].data, *dir;

  unsigned char **dirt;

  unsigned char *endsec = ptr + data->debug_sections[DEBUG_LINE].size;

  unsigned char *endcu, *endprol;

  unsigned char opcode_base;

  uint32_t value, dirt_cnt;

  size_t comp_dir_len = !comp_dir ? 0 : strlen (comp_dir);

  /* XXX: RhBug:929365, should we error out instead of ignoring? */

  if (ptr == NULL)

    return TRUE;

  ptr += off;

  endcu = ptr + 4;

  endcu += read_32 (ptr);

  if (endcu == ptr + 0xffffffff)

    return flatpak_fail (error, "%s: 64-bit DWARF not supported", data->filename);

  if (endcu > endsec)

    return flatpak_fail (error, "%s: .debug_line CU does not fit into section", data->filename);

  value = read_16 (ptr);

  if (value != 2 && value != 3 && value != 4)

    return flatpak_fail (error, "%s: DWARF version %d unhandled", data->filename, value);