tests/alldts.c

   1 /* Create an ELF file with all the DT_* flags set.
   2    Copyright (C) 2011 Red Hat, Inc.
   3    This file is part of elfutils.
   4    Written by Marek Polacek <mpolacek@redhat.com>, 2011.
   5
   6    This file is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    elfutils is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 # include <config.h>
  21 #endif
  22
  23 #include ELFUTILS_HEADER(ebl)
  24 #include <elf.h>
  25 #include <gelf.h>
  26 #include <fcntl.h>
  27 #include <libelf.h>
  28 #include <stdio.h>
  29 #include <stdio_ext.h>
  30 #include <stdint.h>
  31 #include <stdbool.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <unistd.h>
  35
  36
  37 int
  38 main (void)
  39 {
  40   static const char fname[] = "testfile-alldts";
  41   struct Ebl_Strtab *shst;
  42   struct Ebl_Strent *dynscn;
  43   struct Ebl_Strent *shstrtabse;
  44   const Elf32_Sword dtflags[] =
  45     {
  46       DT_NULL, DT_NEEDED, DT_PLTRELSZ, DT_PLTGOT,
  47       DT_HASH, DT_STRTAB, DT_SYMTAB, DT_RELA,
  48       DT_RELASZ, DT_RELAENT, DT_STRSZ, DT_SYMENT,
  49       DT_INIT, DT_FINI, DT_SONAME, DT_RPATH,
  50       DT_SYMBOLIC, DT_REL, DT_RELSZ, DT_RELENT,
  51       DT_PLTREL, DT_DEBUG, DT_TEXTREL, DT_JMPREL,
  52       DT_BIND_NOW, DT_INIT_ARRAY, DT_FINI_ARRAY,
  53       DT_INIT_ARRAYSZ, DT_FINI_ARRAYSZ, DT_RUNPATH,
  54       DT_FLAGS, DT_ENCODING, DT_PREINIT_ARRAY,
  55       DT_PREINIT_ARRAYSZ, DT_VERSYM, DT_GNU_PRELINKED,
  56       DT_GNU_CONFLICTSZ, DT_GNU_LIBLISTSZ, DT_CHECKSUM,
  57       DT_PLTPADSZ, DT_MOVEENT, DT_MOVESZ, DT_FEATURE_1,
  58       DT_POSFLAG_1, DT_SYMINSZ, DT_SYMINENT, DT_GNU_HASH,
  59       DT_TLSDESC_PLT, DT_TLSDESC_GOT, DT_GNU_CONFLICT,
  60       DT_GNU_LIBLIST, DT_CONFIG, DT_DEPAUDIT, DT_AUDIT,
  61       DT_PLTPAD, DT_MOVETAB, DT_SYMINFO, DT_RELACOUNT,
  62       DT_RELCOUNT, DT_FLAGS_1, DT_VERDEF, DT_VERDEFNUM,
  63       DT_VERNEED, DT_VERNEEDNUM, DT_AUXILIARY, DT_FILTER
  64     };
  65   const int ndtflags = sizeof (dtflags) / sizeof (dtflags[0]);
  66
  67   /* We use no threads here which can interfere with handling a stream.  */
  68   (void) __fsetlocking (stdout, FSETLOCKING_BYCALLER);
  69
  70   /* Open the file.  */
  71   int fd = open64 (fname, O_RDWR | O_CREAT | O_TRUNC, 0666);
  72   if (fd == -1)
  73     {
  74       printf ("cannot open `%s': %m\n", fname);
  75       return 1;
  76     }
  77
  78   /* Tell the library which version are we expecting.  */
  79   elf_version (EV_CURRENT);
  80
  81   /* Create an ELF descriptor.  */
  82   Elf *elf = elf_begin (fd, ELF_C_WRITE, NULL);
  83   if (elf == NULL)
  84     {
  85       printf ("cannot create ELF descriptor: %s\n", elf_errmsg (-1));
  86       return 1;
  87     }
  88
  89   /* Create an ELF header.  */
  90   Elf32_Ehdr *ehdr = elf32_newehdr (elf);
  91   if (ehdr == NULL)
  92     {
  93       printf ("cannot create ELF header: %s\n", elf_errmsg (-1));
  94       return 1;
  95     }
  96
  97   ehdr->e_ident[0] = 42;
  98   ehdr->e_ident[5] = 1;
  99   ehdr->e_ident[6] = 2;
 100   ehdr->e_type = ET_EXEC;
 101   ehdr->e_machine = EM_386;
 102   ehdr->e_version = 1;
 103   ehdr->e_ehsize = 1;
 104   ehdr->e_shnum = 3;
 105
 106   elf_flagehdr (elf, ELF_C_SET, ELF_F_DIRTY);
 107
 108   /* Create the program headers.  */
 109   Elf32_Phdr *phdr = elf32_newphdr (elf, 2);
 110   if (phdr == NULL)
 111     {
 112       printf ("cannot create program headers: %s\n", elf_errmsg (-1));
 113       return 1;
 114     }
 115
 116   phdr[0].p_type = PT_PHDR;
 117   phdr[1].p_type = PT_DYNAMIC;
 118
 119   elf_flagphdr (elf, ELF_C_SET, ELF_F_DIRTY);
 120   shst = ebl_strtabinit (true);
 121
 122   /* Create the .dynamic section.  */
 123   Elf_Scn *scn = elf_newscn (elf);
 124   if (scn == NULL)
 125     {
 126       printf ("cannot create DYNAMIC section: %s\n", elf_errmsg (-1));
 127       return 1;
 128     }
 129
 130   Elf32_Shdr *shdr = elf32_getshdr (scn);
 131   if (shdr == NULL)
 132     {
 133       printf ("cannot get header for DYNAMIC section: %s\n", elf_errmsg (-1));
 134       return 1;
 135     }
 136
 137   dynscn = ebl_strtabadd (shst, ".dynamic", 0);
 138
 139   /* We'll need to know the section offset.  But this will be set up
 140      by elf_update later, so for now just store the address.  */
 141   const Elf32_Off *const dynscn_offset = &shdr->sh_offset;
 142   shdr->sh_type = SHT_DYNAMIC;
 143   shdr->sh_flags = SHF_ALLOC | SHF_WRITE;
 144   shdr->sh_link = SHN_UNDEF;
 145   shdr->sh_info = SHN_UNDEF;
 146   /* This section will start here.  */
 147   shdr->sh_addr = 0x1a0;
 148
 149   /* Create new section data.  */
 150   Elf_Data *data = elf_newdata (scn);
 151   if (data == NULL)
 152     {
 153       printf ("cannot create data for DYNAMIC section: %s\n", elf_errmsg (-1));
 154       return 1;
 155     }
 156
 157   /* Allocate memory for all the .dynamic entries.  */
 158   Elf32_Dyn *dyn = malloc (ndtflags * sizeof (Elf32_Dyn));
 159   if (dyn == NULL)
 160     {
 161       printf ("malloc failed: %m\n");
 162       return 1;
 163     }
 164
 165   /* Now write all the DT_* flags.  */
 166   for (int i = 0; i < ndtflags; ++i)
 167     {
 168       dyn[i].d_tag = dtflags[i];
 169       dyn[i].d_un.d_val = 0xdeadbeef;
 170     }
 171
 172   /* Set the pointer to allocated memory.  */
 173   data->d_buf = dyn;
 174   data->d_type = ELF_T_DYN;
 175   data->d_version = EV_CURRENT;
 176   data->d_size = ndtflags * sizeof (Elf32_Dyn);
 177   data->d_align = 0x8;
 178
 179   /* Create .shstrtab section.  */
 180   scn = elf_newscn (elf);
 181   if (scn == NULL)
 182     {
 183       printf ("cannot create SHSTRTAB section: %s\n", elf_errmsg (-1));
 184       return 1;
 185     }
 186
 187   shdr = elf32_getshdr (scn);
 188   if (shdr == NULL)
 189     {
 190       printf ("cannot get header for SHSTRTAB section: %s\n", elf_errmsg (-1));
 191       return 1;
 192     }
 193
 194   shstrtabse = ebl_strtabadd (shst, ".shstrtab", 0);
 195
 196   shdr->sh_type = SHT_STRTAB;
 197   shdr->sh_flags = 0;
 198   shdr->sh_addr = 0;
 199   shdr->sh_link = SHN_UNDEF;
 200   shdr->sh_info = SHN_UNDEF;
 201   shdr->sh_entsize = 1;
 202
 203   /* We have to store the section index in the ELF header.  */
 204   ehdr->e_shstrndx = elf_ndxscn (scn);
 205
 206   data = elf_newdata (scn);
 207   if (data == NULL)
 208     {
 209       printf ("cannot create data SHSTRTAB section: %s\n", elf_errmsg (-1));
 210       return 1;
 211     }
 212
 213   /* No more sections, finalize the section header string table.  */
 214   ebl_strtabfinalize (shst, data);
 215
 216   elf32_getshdr (elf_getscn (elf, 1))->sh_name = ebl_strtaboffset (dynscn);
 217   shdr->sh_name = ebl_strtaboffset (shstrtabse);
 218
 219   /* Let the library compute the internal structure information.  */
 220   if (elf_update (elf, ELF_C_NULL) < 0)
 221     {
 222       printf ("failure in elf_update(NULL): %s\n", elf_errmsg (-1));
 223       return 1;
 224     }
 225
 226   ehdr = elf32_getehdr (elf);
 227
 228   phdr[0].p_offset = ehdr->e_phoff;
 229   phdr[0].p_vaddr = ehdr->e_phoff;
 230   phdr[0].p_paddr = ehdr->e_phoff;
 231   phdr[0].p_flags = PF_R | PF_X;
 232   phdr[0].p_filesz = ehdr->e_phnum * elf32_fsize (ELF_T_PHDR, 1, EV_CURRENT);
 233   phdr[0].p_memsz = ehdr->e_phnum * elf32_fsize (ELF_T_PHDR, 1, EV_CURRENT);
 234   phdr[0].p_align = sizeof (Elf32_Word);
 235
 236   phdr[1].p_flags = PF_W | PF_R;
 237   phdr[1].p_offset = *dynscn_offset;
 238   /* Set up the start of this segment to equal start address of the
 239      .dynamic section.  */
 240   phdr[1].p_vaddr = 0x1a0;
 241   phdr[1].p_paddr = 0x1a0;
 242   phdr[1].p_align = 2 * sizeof (Elf32_Word);
 243   phdr[1].p_filesz = ndtflags * sizeof (Elf32_Dyn);
 244   phdr[1].p_memsz = ndtflags * sizeof (Elf32_Dyn);
 245
 246   /* Write out the file.  */
 247   if (elf_update (elf, ELF_C_WRITE) < 0)
 248     {
 249       printf ("failure in elf_update(WRITE): %s\n", elf_errmsg (-1));
 250       return 1;
 251     }
 252
 253   /* We don't need the string table anymore.  */
 254   ebl_strtabfree (shst);
 255
 256   /* And the data allocated in the .shstrtab section.  */
 257   free (data->d_buf);
 258
 259   /* All done.  */
 260   if (elf_end (elf) != 0)
 261     {
 262       printf ("failure in elf_end: %s\n", elf_errmsg (-1));
 263       return 1;
 264     }
 265
 266   return 0;
 267 }