示例#1
0
#include <libelf.h>
#include <stdbool.h>
#include <string.h>
#include <sys/param.h>

#include "libelfP.h"
#include "elf-knowledge.h"

#ifndef LIBELFBITS
# define LIBELFBITS 32
#endif



static int
ELFW(default_ehdr,LIBELFBITS) (Elf *elf, ElfW2(LIBELFBITS,Ehdr) *ehdr,
			       size_t shnum, int *change_bop)
{
  /* Always write the magic bytes.  */
  if (memcmp (&ehdr->e_ident[EI_MAG0], ELFMAG, SELFMAG) != 0)
    {
      memcpy (&ehdr->e_ident[EI_MAG0], ELFMAG, SELFMAG);
      elf->state.ELFW(elf,LIBELFBITS).ehdr_flags |= ELF_F_DIRTY;
    }

  /* Always set the file class.  */
  update_if_changed (ehdr->e_ident[EI_CLASS], ELFW(ELFCLASS,LIBELFBITS),
		     elf->state.ELFW(elf,LIBELFBITS).ehdr_flags);

  /* Set the data encoding if necessary.  */
  if (unlikely (ehdr->e_ident[EI_DATA] == ELFDATANONE))
int
internal_function
__elfw2(LIBELFBITS,updatemmap) (Elf *elf, int change_bo, size_t shnum)
{
    bool previous_scn_changed = false;

    /* We need the ELF header several times.  */
    ElfW2(LIBELFBITS,Ehdr) *ehdr = elf->state.ELFW(elf,LIBELFBITS).ehdr;

    /* Write out the ELF header.  */
    if ((elf->state.ELFW(elf,LIBELFBITS).ehdr_flags | elf->flags) & ELF_F_DIRTY)
    {
        /* If the type sizes should be different at some time we have to
        rewrite this code.  */
        assert (sizeof (ElfW2(LIBELFBITS,Ehdr))
                == elf_typesize (LIBELFBITS, ELF_T_EHDR, 1));

        if (unlikely (change_bo))
        {
            /* Today there is only one version of the ELF header.  */
#if EV_NUM != 2
            xfct_t fctp;
            fctp = __elf_xfctstom[__libelf_version - 1][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_EHDR];
#else
# undef fctp
# define fctp __elf_xfctstom[0][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_EHDR]
#endif

            /* Do the real work.  */
            (*fctp) ((char *) elf->map_address + elf->start_offset, ehdr,
                     sizeof (ElfW2(LIBELFBITS,Ehdr)), 1);
        }
        else if (elf->map_address + elf->start_offset != ehdr)
            memcpy (elf->map_address + elf->start_offset, ehdr,
                    sizeof (ElfW2(LIBELFBITS,Ehdr)));

        elf->state.ELFW(elf,LIBELFBITS).ehdr_flags &= ~ELF_F_DIRTY;

        /* We start writing sections after the ELF header only if there is
        no program header.  */
        previous_scn_changed = elf->state.ELFW(elf,LIBELFBITS).phdr == NULL;
    }

    size_t phnum;
    if (unlikely (__elf_getphdrnum_rdlock (elf, &phnum) != 0))
        return -1;

    /* Write out the program header table.  */
    if (elf->state.ELFW(elf,LIBELFBITS).phdr != NULL
            && ((elf->state.ELFW(elf,LIBELFBITS).phdr_flags | elf->flags)
                & ELF_F_DIRTY))
    {
        /* If the type sizes should be different at some time we have to
        rewrite this code.  */
        assert (sizeof (ElfW2(LIBELFBITS,Phdr))
                == elf_typesize (LIBELFBITS, ELF_T_PHDR, 1));

        /* Maybe the user wants a gap between the ELF header and the program
        header.  */
        if (ehdr->e_phoff > ehdr->e_ehsize)
            memset (elf->map_address + elf->start_offset + ehdr->e_ehsize,
                    __libelf_fill_byte, ehdr->e_phoff - ehdr->e_ehsize);

        if (unlikely (change_bo))
        {
            /* Today there is only one version of the ELF header.  */
#if EV_NUM != 2
            xfct_t fctp;
            fctp = __elf_xfctstom[__libelf_version - 1][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_PHDR];
#else
# undef fctp
# define fctp __elf_xfctstom[0][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_PHDR]
#endif

            /* Do the real work.  */
            (*fctp) (elf->map_address + elf->start_offset + ehdr->e_phoff,
                     elf->state.ELFW(elf,LIBELFBITS).phdr,
                     sizeof (ElfW2(LIBELFBITS,Phdr)) * phnum, 1);
        }
        else
            memcpy (elf->map_address + elf->start_offset + ehdr->e_phoff,
                    elf->state.ELFW(elf,LIBELFBITS).phdr,
                    sizeof (ElfW2(LIBELFBITS,Phdr)) * phnum);

        elf->state.ELFW(elf,LIBELFBITS).phdr_flags &= ~ELF_F_DIRTY;

        /* We modified the program header.  Maybe this created a gap so
        we have to write fill bytes, if necessary.  */
        previous_scn_changed = true;
    }

    /* From now on we have to keep track of the last position to eventually
       fill the gaps with the prescribed fill byte.  */
    char *last_position = ((char *) elf->map_address + elf->start_offset
                           + MAX (elf_typesize (LIBELFBITS, ELF_T_EHDR, 1),
                                  ehdr->e_phoff)
                           + elf_typesize (LIBELFBITS, ELF_T_PHDR, phnum));

    /* Write all the sections.  Well, only those which are modified.  */
    if (shnum > 0)
    {
        if (unlikely (shnum > SIZE_MAX / sizeof (Elf_Scn *)))
            return 1;

        Elf_ScnList *list = &elf->state.ELFW(elf,LIBELFBITS).scns;
        Elf_Scn **scns = (Elf_Scn **) malloc (shnum * sizeof (Elf_Scn *));
        if (unlikely (scns == NULL))
        {
            __libelf_seterrno (ELF_E_NOMEM);
            return -1;
        }
        char *const shdr_start = ((char *) elf->map_address + elf->start_offset
                                  + ehdr->e_shoff);
        char *const shdr_end = shdr_start + ehdr->e_shnum * ehdr->e_shentsize;

#if EV_NUM != 2
        xfct_t shdr_fctp = __elf_xfctstom[__libelf_version - 1][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_SHDR];
#else
# undef shdr_fctp
# define shdr_fctp __elf_xfctstom[0][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][ELF_T_SHDR]
#endif
#define shdr_dest ((ElfW2(LIBELFBITS,Shdr) *) shdr_start)

        /* Get all sections into the array and sort them.  */
        sort_sections (scns, list);

        /* We possibly have to copy the section header data because moving
        the sections might overwrite the data.  */
        for (size_t cnt = 0; cnt < shnum; ++cnt)
        {
            Elf_Scn *scn = scns[cnt];

            if (!elf->state.ELFW(elf,LIBELFBITS).shdr_malloced
                    && (scn->shdr_flags & ELF_F_MALLOCED) == 0
                    && scn->shdr.ELFW(e,LIBELFBITS) != &shdr_dest[scn->index])
            {
                assert ((char *) elf->map_address + elf->start_offset
                        < (char *) scn->shdr.ELFW(e,LIBELFBITS));
                assert ((char *) scn->shdr.ELFW(e,LIBELFBITS)
                        < ((char *) elf->map_address + elf->start_offset
                           + elf->maximum_size));

                void *p = malloc (sizeof (ElfW2(LIBELFBITS,Shdr)));
                if (unlikely (p == NULL))
                {
                    __libelf_seterrno (ELF_E_NOMEM);
                    return -1;
                }
                scn->shdr.ELFW(e,LIBELFBITS)
                    = memcpy (p, scn->shdr.ELFW(e,LIBELFBITS),
                              sizeof (ElfW2(LIBELFBITS,Shdr)));
            }

            /* If the file is mmaped and the original position of the
               section in the file is lower than the new position we
               need to save the section content since otherwise it is
               overwritten before it can be copied.  If there are
               multiple data segments in the list only the first can be
               from the file.  */
            if (((char *) elf->map_address + elf->start_offset
                    <= (char  *) scn->data_list.data.d.d_buf)
                    && ((char *) scn->data_list.data.d.d_buf
                        < ((char *) elf->map_address + elf->start_offset
                           + elf->maximum_size))
                    && (((char *) elf->map_address + elf->start_offset
                         + scn->shdr.ELFW(e,LIBELFBITS)->sh_offset)
                        > (char *) scn->data_list.data.d.d_buf))
            {
                void *p = malloc (scn->data_list.data.d.d_size);
                if (unlikely (p == NULL))
                {
                    __libelf_seterrno (ELF_E_NOMEM);
                    return -1;
                }
                scn->data_list.data.d.d_buf = scn->data_base
                                              = memcpy (p, scn->data_list.data.d.d_buf,
                                                        scn->data_list.data.d.d_size);
            }
        }

        /* Iterate over all the section in the order in which they
        appear in the output file.  */
        for (size_t cnt = 0; cnt < shnum; ++cnt)
        {
            Elf_Scn *scn = scns[cnt];
            if (scn->index == 0)
            {
                /* The dummy section header entry.  It should not be
                possible to mark this "section" as dirty.  */
                assert ((scn->flags & ELF_F_DIRTY) == 0);
                continue;
            }

            ElfW2(LIBELFBITS,Shdr) *shdr = scn->shdr.ELFW(e,LIBELFBITS);
            if (shdr->sh_type == SHT_NOBITS)
                goto next;

            char *scn_start = ((char *) elf->map_address
                               + elf->start_offset + shdr->sh_offset);
            Elf_Data_List *dl = &scn->data_list;
            bool scn_changed = false;

            void fill_mmap (size_t offset)
            {
                size_t written = 0;

                if (last_position < shdr_start)
                {
                    written = MIN (scn_start + offset - last_position,
                                   shdr_start - last_position);

                    memset (last_position, __libelf_fill_byte, written);
                }

                if (last_position + written != scn_start + offset
                        && shdr_end < scn_start + offset)
                {
                    char *fill_start = MAX (shdr_end, scn_start);
                    memset (fill_start, __libelf_fill_byte,
                            scn_start + offset - fill_start);
                }
            }

            if (scn->data_list_rear != NULL)
                do
                {
                    assert (dl->data.d.d_off >= 0);
                    assert ((GElf_Off) dl->data.d.d_off <= shdr->sh_size);
                    assert (dl->data.d.d_size <= (shdr->sh_size
                                                  - (GElf_Off) dl->data.d.d_off));

                    /* If there is a gap, fill it.  */
                    if (scn_start + dl->data.d.d_off > last_position
                            && (dl->data.d.d_off == 0
                                || ((scn->flags | dl->flags | elf->flags)
                                    & ELF_F_DIRTY) != 0))
                    {
                        fill_mmap (dl->data.d.d_off);
                        last_position = scn_start + dl->data.d.d_off;
                    }

                    if ((scn->flags | dl->flags | elf->flags) & ELF_F_DIRTY)
                    {
                        /* Let it go backward if the sections use a bogus
                           layout with overlaps.  We'll overwrite the stupid
                           user's section data with the latest one, rather than
                           crashing.  */

                        last_position = scn_start + dl->data.d.d_off;

                        if (unlikely (change_bo))
                        {
#if EV_NUM != 2
                            xfct_t fctp;
                            fctp = __elf_xfctstom[__libelf_version - 1][dl->data.d.d_version - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][dl->data.d.d_type];
#else
# undef fctp
# define fctp __elf_xfctstom[0][EV_CURRENT - 1][ELFW(ELFCLASS, LIBELFBITS) - 1][dl->data.d.d_type]
#endif

                            /* Do the real work.  */
                            (*fctp) (last_position, dl->data.d.d_buf,
                                     dl->data.d.d_size, 1);

                            last_position += dl->data.d.d_size;
                        }
                        else if (dl->data.d.d_size != 0)
                            last_position = mempcpy (last_position,
                                                     dl->data.d.d_buf,
                                                     dl->data.d.d_size);

                        scn_changed = true;
                    }
                    else
                        last_position += dl->data.d.d_size;

                    assert (scn_start + dl->data.d.d_off + dl->data.d.d_size
                            == last_position);

                    dl->flags &= ~ELF_F_DIRTY;

                    dl = dl->next;
                }
                while (dl != NULL);
            else
            {
                /* If the previous section (or the ELF/program
                header) changed we might have to fill the gap.  */
                if (scn_start > last_position && previous_scn_changed)
                    fill_mmap (0);

                /* We have to trust the existing section header information.  */
                last_position = scn_start + shdr->sh_size;
            }


            previous_scn_changed = scn_changed;
next:
            scn->flags &= ~ELF_F_DIRTY;
        }

        /* Fill the gap between last section and section header table if
        necessary.  */
        if ((elf->flags & ELF_F_DIRTY)
                && last_position < ((char *) elf->map_address + elf->start_offset
                                    + ehdr->e_shoff))
            memset (last_position, __libelf_fill_byte,
                    (char *) elf->map_address + elf->start_offset + ehdr->e_shoff
                    - last_position);

        /* Write the section header table entry if necessary.  */
        for (size_t cnt = 0; cnt < shnum; ++cnt)
        {
            Elf_Scn *scn = scns[cnt];

            if ((scn->shdr_flags | elf->flags) & ELF_F_DIRTY)
            {
                if (unlikely (change_bo))
                    (*shdr_fctp) (&shdr_dest[scn->index],
                                  scn->shdr.ELFW(e,LIBELFBITS),
                                  sizeof (ElfW2(LIBELFBITS,Shdr)), 1);
                else
                    memcpy (&shdr_dest[scn->index],
                            scn->shdr.ELFW(e,LIBELFBITS),
                            sizeof (ElfW2(LIBELFBITS,Shdr)));

                /* If we previously made a copy of the section header
                entry we now have to adjust the pointer again so
                 point to new place in the mapping.  */
                if (!elf->state.ELFW(elf,LIBELFBITS).shdr_malloced
                        && (scn->shdr_flags & ELF_F_MALLOCED) == 0
                        && scn->shdr.ELFW(e,LIBELFBITS) != &shdr_dest[scn->index])
                {
                    free (scn->shdr.ELFW(e,LIBELFBITS));
                    scn->shdr.ELFW(e,LIBELFBITS) = &shdr_dest[scn->index];
                }

                scn->shdr_flags &= ~ELF_F_DIRTY;
            }
        }
        free (scns);
    }