libelf/elf32_updatefile.c

   1 /* Write changed data structures.
   2    Copyright (C) 2000-2010, 2014 Red Hat, Inc.
   3    This file is part of elfutils.
   4    Written by Ulrich Drepper <drepper@redhat.com>, 2000.
   5
   6    This file is free software; you can redistribute it and/or modify
   7    it under the terms of either
   8
   9      * the GNU Lesser General Public License as published by the Free
  10        Software Foundation; either version 3 of the License, or (at
  11        your option) any later version
  12
  13    or
  14
  15      * the GNU General Public License as published by the Free
  16        Software Foundation; either version 2 of the License, or (at
  17        your option) any later version
  18
  19    or both in parallel, as here.
  20
  21    elfutils is distributed in the hope that it will be useful, but
  22    WITHOUT ANY WARRANTY; without even the implied warranty of
  23    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24    General Public License for more details.
  25
  26    You should have received copies of the GNU General Public License and
  27    the GNU Lesser General Public License along with this program.  If
  28    not, see <http://www.gnu.org/licenses/>.  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 # include <config.h>
  32 #endif
  33
  34 #include <assert.h>
  35 #include <errno.h>
  36 #include <libelf.h>
  37 #include <stdbool.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41 #include <sys/mman.h>
  42 #include <sys/param.h>
  43
  44 #include <system.h>
  45 #include "libelfP.h"
  46
  47
  48 #ifndef LIBELFBITS
  49 # define LIBELFBITS 32
  50 #endif
  51
  52
  53 static int
  54 compare_sections (const void *a, const void *b)
  55 {
  56   const Elf_Scn **scna = (const Elf_Scn **) a;
  57   const Elf_Scn **scnb = (const Elf_Scn **) b;
  58
  59   if ((*scna)->shdr.ELFW(e,LIBELFBITS)->sh_offset
  60       < (*scnb)->shdr.ELFW(e,LIBELFBITS)->sh_offset)
  61     return -1;
  62
  63   if ((*scna)->shdr.ELFW(e,LIBELFBITS)->sh_offset
  64       > (*scnb)->shdr.ELFW(e,LIBELFBITS)->sh_offset)
  65     return 1;
  66
  67   if ((*scna)->shdr.ELFW(e,LIBELFBITS)->sh_size
  68       < (*scnb)->shdr.ELFW(e,LIBELFBITS)->sh_size)
  69     return -1;
  70
  71   if ((*scna)->shdr.ELFW(e,LIBELFBITS)->sh_size
  72       > (*scnb)->shdr.ELFW(e,LIBELFBITS)->sh_size)
  73     return 1;
  74
  75   if ((*scna)->index < (*scnb)->index)
  76     return -1;
  77
  78   if ((*scna)->index > (*scnb)->index)
  79     return 1;
  80
  81   return 0;
  82 }
  83
  84
  85 /* Insert the sections in the list into the provided array and sort
  86    them according to their start offsets.  For sections with equal
  87    start offsets, the size is used; for sections with equal start
  88    offsets and sizes, the section index is used.  Sorting by size
  89    ensures that zero-length sections are processed first, which
  90    is what we want since they do not advance our file writing position.  */
  91 static void
  92 sort_sections (Elf_Scn **scns, Elf_ScnList *list)
  93 {
  94   Elf_Scn **scnp = scns;
  95   do
  96     for (size_t cnt = 0; cnt < list->cnt; ++cnt)
  97       *scnp++ = &list->data[cnt];
  98   while ((list = list->next) != NULL);
  99
 100   qsort (scns, scnp - scns, sizeof (*scns), compare_sections);
 101 }
 102
 103
 104 int
 105 internal_function
 106 __elfw2(LIBELFBITS,updatemmap) (Elf *elf, int change_bo, size_t shnum)
 107 {
 108   bool previous_scn_changed = false;
 109
 110   /* We need the ELF header several times.  */
 111   ElfW2(LIBELFBITS,Ehdr) *ehdr = elf->state.ELFW(elf,LIBELFBITS).ehdr;
 112
 113   /* Write out the ELF header.  */
 114   if ((elf->state.ELFW(elf,LIBELFBITS).ehdr_flags | elf->flags) & ELF_F_DIRTY)
 115     {
 116       /* If the type sizes should be different at some time we have to
 117          rewrite this code.  */
 118       assert (sizeof (ElfW2(LIBELFBITS,Ehdr))
 119               == elf_typesize (LIBELFBITS, ELF_T_EHDR, 1));
 120
 121       if (unlikely (change_bo))
 122         {
 123           /* Today there is only one version of the ELF header.  */
 124 #if EV_NUM != 2
 125           xfct_t fctp;
 126           fctp = __elf_xfctstom[__libelf_version - 1][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_EHDR];
 127 #else
 128 # undef fctp
 129 # define fctp __elf_xfctstom[0][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_EHDR]
 130 #endif
 131
 132           /* Do the real work.  */
 133           (*fctp) ((char *) elf->map_address + elf->start_offset, ehdr,
 134                    sizeof (ElfW2(LIBELFBITS,Ehdr)), 1);
 135         }
 136       else if (elf->map_address + elf->start_offset != ehdr)
 137         memcpy (elf->map_address + elf->start_offset, ehdr,
 138                 sizeof (ElfW2(LIBELFBITS,Ehdr)));
 139
 140       elf->state.ELFW(elf,LIBELFBITS).ehdr_flags &= ~ELF_F_DIRTY;
 141
 142       /* We start writing sections after the ELF header only if there is
 143          no program header.  */
 144       previous_scn_changed = elf->state.ELFW(elf,LIBELFBITS).phdr == NULL;
 145     }
 146
 147   size_t phnum;
 148   if (unlikely (__elf_getphdrnum_rdlock (elf, &phnum) != 0))
 149     return -1;
 150
 151   /* Write out the program header table.  */
 152   if (elf->state.ELFW(elf,LIBELFBITS).phdr != NULL
 153       && ((elf->state.ELFW(elf,LIBELFBITS).phdr_flags | elf->flags)
 154           & ELF_F_DIRTY))
 155     {
 156       /* If the type sizes should be different at some time we have to
 157          rewrite this code.  */
 158       assert (sizeof (ElfW2(LIBELFBITS,Phdr))
 159               == elf_typesize (LIBELFBITS, ELF_T_PHDR, 1));
 160
 161       /* Maybe the user wants a gap between the ELF header and the program
 162          header.  */
 163       if (ehdr->e_phoff > ehdr->e_ehsize)
 164         memset (elf->map_address + elf->start_offset + ehdr->e_ehsize,
 165                 __libelf_fill_byte, ehdr->e_phoff - ehdr->e_ehsize);
 166
 167       if (unlikely (change_bo))
 168         {
 169           /* Today there is only one version of the ELF header.  */
 170 #if EV_NUM != 2
 171           xfct_t fctp;
 172           fctp = __elf_xfctstom[__libelf_version - 1][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_PHDR];
 173 #else
 174 # undef fctp
 175 # define fctp __elf_xfctstom[0][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_PHDR]
 176 #endif
 177
 178           /* Do the real work.  */
 179           (*fctp) (elf->map_address + elf->start_offset + ehdr->e_phoff,
 180                    elf->state.ELFW(elf,LIBELFBITS).phdr,
 181                    sizeof (ElfW2(LIBELFBITS,Phdr)) * phnum, 1);
 182         }
 183       else
 184         memcpy (elf->map_address + elf->start_offset + ehdr->e_phoff,
 185                 elf->state.ELFW(elf,LIBELFBITS).phdr,
 186                 sizeof (ElfW2(LIBELFBITS,Phdr)) * phnum);
 187
 188       elf->state.ELFW(elf,LIBELFBITS).phdr_flags &= ~ELF_F_DIRTY;
 189
 190       /* We modified the program header.  Maybe this created a gap so
 191          we have to write fill bytes, if necessary.  */
 192       previous_scn_changed = true;
 193     }
 194
 195   /* From now on we have to keep track of the last position to eventually
 196      fill the gaps with the prescribed fill byte.  */
 197   char *last_position = ((char *) elf->map_address + elf->start_offset
 198                          + MAX (elf_typesize (LIBELFBITS, ELF_T_EHDR, 1),
 199                                 ehdr->e_phoff)
 200                          + elf_typesize (LIBELFBITS, ELF_T_PHDR, phnum));
 201
 202   /* Write all the sections.  Well, only those which are modified.  */
 203   if (shnum > 0)
 204     {
 205       if (unlikely (shnum > SIZE_MAX / sizeof (Elf_Scn *)))
 206         return 1;
 207
 208       Elf_ScnList *list = &elf->state.ELFW(elf,LIBELFBITS).scns;
 209       Elf_Scn **scns = (Elf_Scn **) alloca (shnum * sizeof (Elf_Scn *));
 210       char *const shdr_start = ((char *) elf->map_address + elf->start_offset
 211                                 + ehdr->e_shoff);
 212       char *const shdr_end = shdr_start + ehdr->e_shnum * ehdr->e_shentsize;
 213
 214 #if EV_NUM != 2
 215       xfct_t shdr_fctp = __elf_xfctstom[__libelf_version - 1][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_SHDR];
 216 #else
 217 # undef shdr_fctp
 218 # define shdr_fctp __elf_xfctstom[0][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_SHDR]
 219 #endif
 220 #define shdr_dest ((ElfW2(LIBELFBITS,Shdr) *) shdr_start)
 221
 222       /* Get all sections into the array and sort them.  */
 223       sort_sections (scns, list);
 224
 225       /* We possibly have to copy the section header data because moving
 226          the sections might overwrite the data.  */
 227       for (size_t cnt = 0; cnt < shnum; ++cnt)
 228         {
 229           Elf_Scn *scn = scns[cnt];
 230
 231           if (!elf->state.ELFW(elf,LIBELFBITS).shdr_malloced
 232               && (scn->shdr_flags & ELF_F_MALLOCED) == 0
 233               && scn->shdr.ELFW(e,LIBELFBITS) != &shdr_dest[scn->index])
 234             {
 235               assert ((char *) elf->map_address + elf->start_offset
 236                       < (char *) scn->shdr.ELFW(e,LIBELFBITS));
 237               assert ((char *) scn->shdr.ELFW(e,LIBELFBITS)
 238                       < ((char *) elf->map_address + elf->start_offset
 239                          + elf->maximum_size));
 240
 241               void *p = alloca (sizeof (ElfW2(LIBELFBITS,Shdr)));
 242               scn->shdr.ELFW(e,LIBELFBITS)
 243                 = memcpy (p, scn->shdr.ELFW(e,LIBELFBITS),
 244                           sizeof (ElfW2(LIBELFBITS,Shdr)));
 245             }
 246
 247           /* If the file is mmaped and the original position of the
 248              section in the file is lower than the new position we
 249              need to save the section content since otherwise it is
 250              overwritten before it can be copied.  If there are
 251              multiple data segments in the list only the first can be
 252              from the file.  */
 253           if (((char *) elf->map_address + elf->start_offset
 254                <= (char  *) scn->data_list.data.d.d_buf)
 255               && ((char *) scn->data_list.data.d.d_buf
 256                   < ((char *) elf->map_address + elf->start_offset
 257                      + elf->maximum_size))
 258               && (((char *) elf->map_address + elf->start_offset
 259                    + scn->shdr.ELFW(e,LIBELFBITS)->sh_offset)
 260                   > (char *) scn->data_list.data.d.d_buf))
 261             {
 262               void *p = malloc (scn->data_list.data.d.d_size);
 263               if (p == NULL)
 264                 {
 265                   __libelf_seterrno (ELF_E_NOMEM);
 266                   return -1;
 267                 }
 268               scn->data_list.data.d.d_buf = scn->data_base
 269                 = memcpy (p, scn->data_list.data.d.d_buf,
 270                           scn->data_list.data.d.d_size);
 271             }
 272         }
 273
 274       /* Iterate over all the section in the order in which they
 275          appear in the output file.  */
 276       for (size_t cnt = 0; cnt < shnum; ++cnt)
 277         {
 278           Elf_Scn *scn = scns[cnt];
 279           if (scn->index == 0)
 280             {
 281               /* The dummy section header entry.  It should not be
 282                  possible to mark this "section" as dirty.  */
 283               assert ((scn->flags & ELF_F_DIRTY) == 0);
 284               continue;
 285             }
 286
 287           ElfW2(LIBELFBITS,Shdr) *shdr = scn->shdr.ELFW(e,LIBELFBITS);
 288           if (shdr->sh_type == SHT_NOBITS)
 289             goto next;
 290
 291           char *scn_start = ((char *) elf->map_address
 292                              + elf->start_offset + shdr->sh_offset);
 293           Elf_Data_List *dl = &scn->data_list;
 294           bool scn_changed = false;
 295
 296           void fill_mmap (size_t offset)
 297           {
 298             size_t written = 0;
 299
 300             if (last_position < shdr_start)
 301               {
 302                 written = MIN (scn_start + offset - last_position,
 303                                shdr_start - last_position);
 304
 305                 memset (last_position, __libelf_fill_byte, written);
 306               }
 307
 308             if (last_position + written != scn_start + offset
 309                 && shdr_end < scn_start + offset)
 310               {
 311                 char *fill_start = MAX (shdr_end, scn_start);
 312                 memset (fill_start, __libelf_fill_byte,
 313                         scn_start + offset - fill_start);
 314               }
 315           }
 316
 317           if (scn->data_list_rear != NULL)
 318             do
 319               {
 320                 assert (dl->data.d.d_off >= 0);
 321                 assert ((GElf_Off) dl->data.d.d_off <= shdr->sh_size);
 322                 assert (dl->data.d.d_size <= (shdr->sh_size
 323                                               - (GElf_Off) dl->data.d.d_off));
 324
 325                 /* If there is a gap, fill it.  */
 326                 if (scn_start + dl->data.d.d_off > last_position
 327                     && (dl->data.d.d_off == 0
 328                         || ((scn->flags | dl->flags | elf->flags)
 329                             & ELF_F_DIRTY) != 0))
 330                   {
 331                     fill_mmap (dl->data.d.d_off);
 332                     last_position = scn_start + dl->data.d.d_off;
 333                   }
 334
 335                 if ((scn->flags | dl->flags | elf->flags) & ELF_F_DIRTY)
 336                   {
 337                     /* Let it go backward if the sections use a bogus
 338                        layout with overlaps.  We'll overwrite the stupid
 339                        user's section data with the latest one, rather than
 340                        crashing.  */
 341
 342                     last_position = scn_start + dl->data.d.d_off;
 343
 344                     if (unlikely (change_bo))
 345                       {
 346 #if EV_NUM != 2
 347                         xfct_t fctp;
 348                         fctp = __elf_xfctstom[__libelf_version - 1][dl->data.d.d_version - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][dl->data.d.d_type];
 349 #else
 350 # undef fctp
 351 # define fctp __elf_xfctstom[0][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][dl->data.d.d_type]
 352 #endif
 353
 354                         /* Do the real work.  */
 355                         (*fctp) (last_position, dl->data.d.d_buf,
 356                                  dl->data.d.d_size, 1);
 357
 358                         last_position += dl->data.d.d_size;
 359                       }
 360                     else
 361                       last_position = mempcpy (last_position,
 362                                                dl->data.d.d_buf,
 363                                                dl->data.d.d_size);
 364
 365                     scn_changed = true;
 366                   }
 367                 else
 368                   last_position += dl->data.d.d_size;
 369
 370                 assert (scn_start + dl->data.d.d_off + dl->data.d.d_size
 371                         == last_position);
 372
 373                 dl->flags &= ~ELF_F_DIRTY;
 374
 375                 dl = dl->next;
 376               }
 377             while (dl != NULL);
 378           else
 379             {
 380               /* If the previous section (or the ELF/program
 381                  header) changed we might have to fill the gap.  */
 382               if (scn_start > last_position && previous_scn_changed)
 383                 fill_mmap (0);
 384
 385               /* We have to trust the existing section header information.  */
 386               last_position = scn_start + shdr->sh_size;
 387             }
 388
 389
 390           previous_scn_changed = scn_changed;
 391         next:
 392           scn->flags &= ~ELF_F_DIRTY;
 393         }
 394
 395       /* Fill the gap between last section and section header table if
 396          necessary.  */
 397       if ((elf->flags & ELF_F_DIRTY)
 398           && last_position < ((char *) elf->map_address + elf->start_offset
 399                               + ehdr->e_shoff))
 400         memset (last_position, __libelf_fill_byte,
 401                 (char *) elf->map_address + elf->start_offset + ehdr->e_shoff
 402                 - last_position);
 403
 404       /* Write the section header table entry if necessary.  */
 405       for (size_t cnt = 0; cnt < shnum; ++cnt)
 406         {
 407           Elf_Scn *scn = scns[cnt];
 408
 409           if ((scn->shdr_flags | elf->flags) & ELF_F_DIRTY)
 410             {
 411               if (unlikely (change_bo))
 412                 (*shdr_fctp) (&shdr_dest[scn->index],
 413                               scn->shdr.ELFW(e,LIBELFBITS),
 414                               sizeof (ElfW2(LIBELFBITS,Shdr)), 1);
 415               else
 416                 memcpy (&shdr_dest[scn->index],
 417                         scn->shdr.ELFW(e,LIBELFBITS),
 418                         sizeof (ElfW2(LIBELFBITS,Shdr)));
 419
 420               /* If we previously made a copy of the section header
 421                  entry we now have to adjust the pointer again so
 422                  point to new place in the mapping.  */
 423               if (!elf->state.ELFW(elf,LIBELFBITS).shdr_malloced
 424                   && (scn->shdr_flags & ELF_F_MALLOCED) == 0)
 425                 scn->shdr.ELFW(e,LIBELFBITS) = &shdr_dest[scn->index];
 426
 427               scn->shdr_flags &= ~ELF_F_DIRTY;
 428             }
 429         }
 430     }
 431
 432   /* That was the last part.  Clear the overall flag.  */
 433   elf->flags &= ~ELF_F_DIRTY;
 434
 435   /* Make sure the content hits the disk.  */
 436   char *msync_start = ((char *) elf->map_address
 437                        + (elf->start_offset & ~(sysconf (_SC_PAGESIZE) - 1)));
 438   char *msync_end = ((char *) elf->map_address
 439                      + elf->start_offset + ehdr->e_shoff
 440                      + ehdr->e_shentsize * shnum);
 441   (void) msync (msync_start, msync_end - msync_start, MS_SYNC);
 442
 443   return 0;
 444 }
 445
 446
 447 /* Size of the buffer we use to generate the blocks of fill bytes.  */
 448 #define FILLBUFSIZE     4096
 449
 450 /* If we have to convert the section buffer contents we have to use
 451    temporary buffer.  Only buffers up to MAX_TMPBUF bytes are allocated
 452    on the stack.  */
 453 #define MAX_TMPBUF      32768
 454
 455
 456 /* Helper function to write out fill bytes.  */
 457 static int
 458 fill (int fd, off_t pos, size_t len, char *fillbuf, size_t *filledp)
 459 {
 460   size_t filled = *filledp;
 461   size_t fill_len = MIN (len, FILLBUFSIZE);
 462
 463   if (unlikely (fill_len > filled) && filled < FILLBUFSIZE)
 464     {
 465       /* Initialize a few more bytes.  */
 466       memset (fillbuf + filled, __libelf_fill_byte, fill_len - filled);
 467       *filledp = filled = fill_len;
 468     }
 469
 470   do
 471     {
 472       /* This many bytes we want to write in this round.  */
 473       size_t n = MIN (filled, len);
 474
 475       if (unlikely ((size_t) pwrite_retry (fd, fillbuf, n, pos) != n))
 476         {
 477           __libelf_seterrno (ELF_E_WRITE_ERROR);
 478           return 1;
 479         }
 480
 481       pos += n;
 482       len -= n;
 483     }
 484   while (len > 0);
 485
 486   return 0;
 487 }
 488
 489
 490 int
 491 internal_function
 492 __elfw2(LIBELFBITS,updatefile) (Elf *elf, int change_bo, size_t shnum)
 493 {
 494   char fillbuf[FILLBUFSIZE];
 495   size_t filled = 0;
 496   bool previous_scn_changed = false;
 497
 498   /* We need the ELF header several times.  */
 499   ElfW2(LIBELFBITS,Ehdr) *ehdr = elf->state.ELFW(elf,LIBELFBITS).ehdr;
 500
 501   /* Write out the ELF header.  */
 502   if ((elf->state.ELFW(elf,LIBELFBITS).ehdr_flags | elf->flags) & ELF_F_DIRTY)
 503     {
 504       ElfW2(LIBELFBITS,Ehdr) tmp_ehdr;
 505       ElfW2(LIBELFBITS,Ehdr) *out_ehdr = ehdr;
 506
 507       /* If the type sizes should be different at some time we have to
 508          rewrite this code.  */
 509       assert (sizeof (ElfW2(LIBELFBITS,Ehdr))
 510               == elf_typesize (LIBELFBITS, ELF_T_EHDR, 1));
 511
 512       if (unlikely (change_bo))
 513         {
 514           /* Today there is only one version of the ELF header.  */
 515 #if EV_NUM != 2
 516           xfct_t fctp;
 517           fctp = __elf_xfctstom[__libelf_version - 1][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_EHDR];
 518 #else
 519 # undef fctp
 520 # define fctp __elf_xfctstom[0][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_EHDR]
 521 #endif
 522
 523           /* Write the converted ELF header in a temporary buffer.  */
 524           (*fctp) (&tmp_ehdr, ehdr, sizeof (ElfW2(LIBELFBITS,Ehdr)), 1);
 525
 526           /* This is the buffer we want to write.  */
 527           out_ehdr = &tmp_ehdr;
 528         }
 529
 530       /* Write out the ELF header.  */
 531       if (unlikely (pwrite_retry (elf->fildes, out_ehdr,
 532                                   sizeof (ElfW2(LIBELFBITS,Ehdr)), 0)
 533                     != sizeof (ElfW2(LIBELFBITS,Ehdr))))
 534         {
 535           __libelf_seterrno (ELF_E_WRITE_ERROR);
 536           return 1;
 537         }
 538
 539       elf->state.ELFW(elf,LIBELFBITS).ehdr_flags &= ~ELF_F_DIRTY;
 540
 541       /* We start writing sections after the ELF header only if there is
 542          no program header.  */
 543       previous_scn_changed = elf->state.ELFW(elf,LIBELFBITS).phdr == NULL;
 544     }
 545
 546   /* If the type sizes should be different at some time we have to
 547      rewrite this code.  */
 548   assert (sizeof (ElfW2(LIBELFBITS,Phdr))
 549           == elf_typesize (LIBELFBITS, ELF_T_PHDR, 1));
 550
 551   size_t phnum;
 552   if (unlikely (__elf_getphdrnum_rdlock (elf, &phnum) != 0))
 553     return -1;
 554
 555   /* Write out the program header table.  */
 556   if (elf->state.ELFW(elf,LIBELFBITS).phdr != NULL
 557       && ((elf->state.ELFW(elf,LIBELFBITS).phdr_flags | elf->flags)
 558           & ELF_F_DIRTY))
 559     {
 560       ElfW2(LIBELFBITS,Phdr) *tmp_phdr = NULL;
 561       ElfW2(LIBELFBITS,Phdr) *out_phdr = elf->state.ELFW(elf,LIBELFBITS).phdr;
 562
 563       /* Maybe the user wants a gap between the ELF header and the program
 564          header.  */
 565       if (ehdr->e_phoff > ehdr->e_ehsize
 566           && unlikely (fill (elf->fildes, ehdr->e_ehsize,
 567                              ehdr->e_phoff - ehdr->e_ehsize, fillbuf, &filled)
 568                        != 0))
 569         return 1;
 570
 571       if (unlikely (change_bo))
 572         {
 573           /* Today there is only one version of the ELF header.  */
 574 #if EV_NUM != 2
 575           xfct_t fctp;
 576           fctp = __elf_xfctstom[__libelf_version - 1][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_PHDR];
 577 #else
 578 # undef fctp
 579 # define fctp __elf_xfctstom[0][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_PHDR]
 580 #endif
 581
 582           /* Allocate sufficient memory.  */
 583           tmp_phdr = (ElfW2(LIBELFBITS,Phdr) *)
 584             malloc (sizeof (ElfW2(LIBELFBITS,Phdr)) * phnum);
 585           if (tmp_phdr == NULL)
 586             {
 587               __libelf_seterrno (ELF_E_NOMEM);
 588               return 1;
 589             }
 590
 591           /* Write the converted ELF header in a temporary buffer.  */
 592           (*fctp) (tmp_phdr, elf->state.ELFW(elf,LIBELFBITS).phdr,
 593                    sizeof (ElfW2(LIBELFBITS,Phdr)) * phnum, 1);
 594
 595           /* This is the buffer we want to write.  */
 596           out_phdr = tmp_phdr;
 597         }
 598
 599       /* Write out the ELF header.  */
 600       size_t phdr_size = sizeof (ElfW2(LIBELFBITS,Phdr)) * phnum;
 601       if (unlikely ((size_t) pwrite_retry (elf->fildes, out_phdr,
 602                                            phdr_size, ehdr->e_phoff)
 603                     != phdr_size))
 604         {
 605           __libelf_seterrno (ELF_E_WRITE_ERROR);
 606           return 1;
 607         }
 608
 609       /* This is a no-op we we have not allocated any memory.  */
 610       free (tmp_phdr);
 611
 612       elf->state.ELFW(elf,LIBELFBITS).phdr_flags &= ~ELF_F_DIRTY;
 613
 614       /* We modified the program header.  Maybe this created a gap so
 615          we have to write fill bytes, if necessary.  */
 616       previous_scn_changed = true;
 617     }
 618
 619   /* From now on we have to keep track of the last position to eventually
 620      fill the gaps with the prescribed fill byte.  */
 621   off_t last_offset;
 622   if (elf->state.ELFW(elf,LIBELFBITS).phdr == NULL)
 623     last_offset = elf_typesize (LIBELFBITS, ELF_T_EHDR, 1);
 624   else
 625     last_offset = (ehdr->e_phoff + sizeof (ElfW2(LIBELFBITS,Phdr)) * phnum);
 626
 627   /* Write all the sections.  Well, only those which are modified.  */
 628   if (shnum > 0)
 629     {
 630       if (unlikely (shnum > SIZE_MAX / (sizeof (Elf_Scn *)
 631                                         + sizeof (ElfW2(LIBELFBITS,Shdr)))))
 632         return 1;
 633
 634       off_t shdr_offset = elf->start_offset + ehdr->e_shoff;
 635 #if EV_NUM != 2
 636       xfct_t shdr_fctp = __elf_xfctstom[__libelf_version - 1][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_SHDR];
 637 #else
 638 # undef shdr_fctp
 639 # define shdr_fctp __elf_xfctstom[0][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_SHDR]
 640 #endif
 641
 642       ElfW2(LIBELFBITS,Shdr) *shdr_data;
 643       if (change_bo || elf->state.ELFW(elf,LIBELFBITS).shdr == NULL
 644           || (elf->flags & ELF_F_DIRTY))
 645         shdr_data = (ElfW2(LIBELFBITS,Shdr) *)
 646           alloca (shnum * sizeof (ElfW2(LIBELFBITS,Shdr)));
 647       else
 648         shdr_data = elf->state.ELFW(elf,LIBELFBITS).shdr;
 649       int shdr_flags = elf->flags;
 650
 651       /* Get all sections into the array and sort them.  */
 652       Elf_ScnList *list = &elf->state.ELFW(elf,LIBELFBITS).scns;
 653       Elf_Scn **scns = (Elf_Scn **) alloca (shnum * sizeof (Elf_Scn *));
 654       sort_sections (scns, list);
 655
 656       for (size_t cnt = 0; cnt < shnum; ++cnt)
 657         {
 658           Elf_Scn *scn = scns[cnt];
 659           if (scn->index == 0)
 660             {
 661               /* The dummy section header entry.  It should not be
 662                  possible to mark this "section" as dirty.  */
 663               assert ((scn->flags & ELF_F_DIRTY) == 0);
 664               goto next;
 665             }
 666
 667           ElfW2(LIBELFBITS,Shdr) *shdr = scn->shdr.ELFW(e,LIBELFBITS);
 668           if (shdr->sh_type == SHT_NOBITS)
 669             goto next;
 670
 671           off_t scn_start = elf->start_offset + shdr->sh_offset;
 672           Elf_Data_List *dl = &scn->data_list;
 673           bool scn_changed = false;
 674
 675           if (scn->data_list_rear != NULL)
 676             do
 677               {
 678                 /* If there is a gap, fill it.  */
 679                 if (scn_start + dl->data.d.d_off > last_offset
 680                     && ((previous_scn_changed && dl->data.d.d_off == 0)
 681                         || ((scn->flags | dl->flags | elf->flags)
 682                             & ELF_F_DIRTY) != 0))
 683                   {
 684                     if (unlikely (fill (elf->fildes, last_offset,
 685                                         (scn_start + dl->data.d.d_off)
 686                                         - last_offset, fillbuf,
 687                                         &filled) != 0))
 688                       return 1;
 689                   }
 690
 691                 if ((scn->flags | dl->flags | elf->flags) & ELF_F_DIRTY)
 692                   {
 693                     char tmpbuf[MAX_TMPBUF];
 694                     void *buf = dl->data.d.d_buf;
 695
 696                     /* Let it go backward if the sections use a bogus
 697                        layout with overlaps.  We'll overwrite the stupid
 698                        user's section data with the latest one, rather than
 699                        crashing.  */
 700
 701                     last_offset = scn_start + dl->data.d.d_off;
 702
 703                     if (unlikely (change_bo))
 704                       {
 705 #if EV_NUM != 2
 706                         xfct_t fctp;
 707                         fctp = __elf_xfctstom[__libelf_version - 1][dl->data.d.d_version - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][dl->data.d.d_type];
 708 #else
 709 # undef fctp
 710 # define fctp __elf_xfctstom[0][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][dl->data.d.d_type]
 711 #endif
 712
 713                         buf = tmpbuf;
 714                         if (dl->data.d.d_size > MAX_TMPBUF)
 715                           {
 716                             buf = malloc (dl->data.d.d_size);
 717                             if (buf == NULL)
 718                               {
 719                                 __libelf_seterrno (ELF_E_NOMEM);
 720                                 return 1;
 721                               }
 722                           }
 723
 724                         /* Do the real work.  */
 725                         (*fctp) (buf, dl->data.d.d_buf, dl->data.d.d_size, 1);
 726                       }
 727
 728                     ssize_t n = pwrite_retry (elf->fildes, buf,
 729                                               dl->data.d.d_size,
 730                                               last_offset);
 731                     if (unlikely ((size_t) n != dl->data.d.d_size))
 732                       {
 733                         if (buf != dl->data.d.d_buf && buf != tmpbuf)
 734                           free (buf);
 735
 736                         __libelf_seterrno (ELF_E_WRITE_ERROR);
 737                         return 1;
 738                       }
 739
 740                     if (buf != dl->data.d.d_buf && buf != tmpbuf)
 741                       free (buf);
 742
 743                     scn_changed = true;
 744                   }
 745
 746                 last_offset += dl->data.d.d_size;
 747
 748                 dl->flags &= ~ELF_F_DIRTY;
 749
 750                 dl = dl->next;
 751               }
 752             while (dl != NULL);
 753           else
 754             {
 755               /* If the previous section (or the ELF/program
 756                  header) changed we might have to fill the gap.  */
 757               if (scn_start > last_offset && previous_scn_changed)
 758                 {
 759                   if (unlikely (fill (elf->fildes, last_offset,
 760                                       scn_start - last_offset, fillbuf,
 761                                       &filled) != 0))
 762                     return 1;
 763                 }
 764
 765               last_offset = scn_start + shdr->sh_size;
 766             }
 767
 768           previous_scn_changed = scn_changed;
 769         next:
 770           /* Collect the section header table information.  */
 771           if (unlikely (change_bo))
 772             (*shdr_fctp) (&shdr_data[scn->index],
 773                           scn->shdr.ELFW(e,LIBELFBITS),
 774                           sizeof (ElfW2(LIBELFBITS,Shdr)), 1);
 775           else if (elf->state.ELFW(elf,LIBELFBITS).shdr == NULL
 776                    || (elf->flags & ELF_F_DIRTY))
 777             memcpy (&shdr_data[scn->index], scn->shdr.ELFW(e,LIBELFBITS),
 778                     sizeof (ElfW2(LIBELFBITS,Shdr)));
 779
 780           shdr_flags |= scn->shdr_flags;
 781           scn->shdr_flags &= ~ELF_F_DIRTY;
 782         }
 783
 784       /* Fill the gap between last section and section header table if
 785          necessary.  */
 786       if ((elf->flags & ELF_F_DIRTY) && last_offset < shdr_offset
 787           && unlikely (fill (elf->fildes, last_offset,
 788                              shdr_offset - last_offset,
 789                              fillbuf, &filled) != 0))
 790         return 1;
 791
 792       /* Write out the section header table.  */
 793       if (shdr_flags & ELF_F_DIRTY
 794           && unlikely ((size_t) pwrite_retry (elf->fildes, shdr_data,
 795                                               sizeof (ElfW2(LIBELFBITS,Shdr))
 796                                               * shnum, shdr_offset)
 797                        != sizeof (ElfW2(LIBELFBITS,Shdr)) * shnum))
 798         {
 799           __libelf_seterrno (ELF_E_WRITE_ERROR);
 800           return 1;
 801         }
 802     }
 803
 804   /* That was the last part.  Clear the overall flag.  */
 805   elf->flags &= ~ELF_F_DIRTY;
 806
 807   return 0;
 808 }