1 /*

     2  * Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

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

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

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

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 #include <libelf.h>

    25 #include <stdio.h>

    26 #include <stdlib.h>

    27 

    28 /**

    29  * TODO: This is an intial and crude attempt to access structure

    30  * fields of some ELF structrures. Need to figure out a way to access the

    31  * given field of a given structure instead of writing one shim function

    32  * per access of each of the structure field.

    33  **/

    34 

    35 #define STRINGIFYHELPER(x) #x

    36 #define STRINGIFY(x) STRINGIFYHELPER(x)

    37 #define FUNC_NAME(S, F) set_ ## S ## _ ## F

    38 #define CAST_STRUCT(S, F) ((Elf_ ## S *) structPtr)

    39 #define CAST_STRUCT32(S, F) ((Elf32_ ## S *) structPtr)

    40 #define CAST_STRUCT64(S, F) ((Elf64_ ## S *) structPtr)

    41 #define ACCESS_FIELD(S, F) CAST_STRUCT(S, F)-> F

    42 #define ACCESS_FIELD32(S, F) CAST_STRUCT32(S, F)-> F

    43 #define ACCESS_FIELD64(S, F) CAST_STRUCT64(S, F)-> F

    44 

    45 /*

    46    Example:

    47    SET_TYPE_BASED_FIELD(Ehdr, e_machine, int)

    48    expands to

    49    set_Ehdr_e_machine(int elfclass, void * strPtr, int val) {

    50 }

    51 */

    52 

    53 #define SET_TYPE_BASED_FIELD(S, F, T)                               \

    54     void FUNC_NAME(S, F)(int elfclass, void * structPtr, T val) {   \

    55        if (elfclass == ELFCLASS32)  {                               \

    56            ACCESS_FIELD32(S, F) = val;                    \

    57        } else if (elfclass == ELFCLASS64) {               \

    58            ACCESS_FIELD64(S, F) = val;                    \

    59        } else {                                           \

    60            printf("%s: Unknown ELF Class %d provided\n", STRINGIFY(FUNC_NAME(S, F)), elfclass); \

    61     }  \

    62     return; \

    63 }

    64 

    65 /*

    66    Example:

    67    SET_FIELD(Ehdr, e_machine, int)

    68    expands to

    69    set_Ehdr_e_machine(void * strPtr, int val) {

    70 }

    71 */

    72 

    73 #define SET_FIELD(S, F, T)                               \

    74     void FUNC_NAME(S, F)(void * structPtr, T val) {      \

    75        ACCESS_FIELD(S, F) = val;                         \

    76        return; \

    77 }

    78 

    79 int size_of_Sym(int elfclass) {

    80     if (elfclass == ELFCLASS32)  {

    81         return sizeof(Elf32_Sym);

    82     } else if (elfclass == ELFCLASS64) {

    83         return sizeof(Elf64_Sym);

    84     } else {

    85         printf("Unknown ELF Class %d provided\n", elfclass);

    86     }

    87     return -1;

    88 }

    89 

    90 int size_of_Rela(int elfclass) {

    91     if (elfclass == ELFCLASS32)  {

    92         return sizeof(Elf32_Rela);

    93     } else if (elfclass == ELFCLASS64) {

    94         return sizeof(Elf64_Rela);

    95     } else {

    96         printf("Unknown ELF Class %d provided\n", elfclass);

    97     }

    98     return -1;

    99 }

   100 

   101 int size_of_Rel(int elfclass) {

   102     if (elfclass == ELFCLASS32)  {

   103         return sizeof(Elf32_Rel);

   104     } else if (elfclass == ELFCLASS64) {

   105         return sizeof(Elf64_Rel);

   106     } else {

   107         printf("Unknown ELF Class %d provided\n", elfclass);

   108     }

   109     return -1;

   110 }

   111 

   112 /* ELF Header field access */

   113 

   114 void ehdr_set_data_encoding(void * ehdr, int val)  {

   115     ((Elf32_Ehdr *) ehdr)->e_ident[EI_DATA] = val;

   116     return;

   117 }

   118 

   119 SET_TYPE_BASED_FIELD(Ehdr, e_machine, int)

   120 SET_TYPE_BASED_FIELD(Ehdr, e_type, int)

   121 SET_TYPE_BASED_FIELD(Ehdr, e_version, int)

   122 SET_TYPE_BASED_FIELD(Ehdr, e_shstrndx, int)

   123 

   124 /* Data descriptor field access */

   125 SET_FIELD(Data, d_align, int)

   126 SET_FIELD(Data, d_off, int)

   127 SET_FIELD(Data, d_buf, void*)

   128 SET_FIELD(Data, d_type, int)

   129 SET_FIELD(Data, d_size, int)

   130 SET_FIELD(Data, d_version, int)

   131 

   132 /* Section Header Access functions */

   133 SET_TYPE_BASED_FIELD(Shdr, sh_name, int)

   134 SET_TYPE_BASED_FIELD(Shdr, sh_type, int)

   135 SET_TYPE_BASED_FIELD(Shdr, sh_flags, int)

   136 SET_TYPE_BASED_FIELD(Shdr, sh_entsize, int)

   137 SET_TYPE_BASED_FIELD(Shdr, sh_link, int)

   138 SET_TYPE_BASED_FIELD(Shdr, sh_info, int)

   139 

   140 /* Set the Program Header to be of PH_PHDR type and initialize other

   141    related fields of the program header.

   142 */

   143 void phdr_set_type_self(int elfclass, void * ehdr, void * phdr)  {

   144     if (elfclass == ELFCLASS32) {

   145         Elf32_Ehdr * ehdr32 = (Elf32_Ehdr *) ehdr;

   146         Elf32_Phdr * phdr32 = (Elf32_Phdr *) phdr;

   147         phdr32->p_type = PT_PHDR;

   148         phdr32->p_offset = ehdr32->e_phoff;

   149         phdr32->p_filesz = elf32_fsize(ELF_T_PHDR, 1, EV_CURRENT);

   150     } else if (elfclass == ELFCLASS64) {

   151         Elf64_Ehdr * ehdr64 = (Elf64_Ehdr *) ehdr;

   152         Elf64_Phdr * phdr64 = (Elf64_Phdr *) phdr;

   153         phdr64->p_type = PT_PHDR;

   154         phdr64->p_offset = ehdr64->e_phoff;

   155         phdr64->p_filesz = elf64_fsize(ELF_T_PHDR, 1, EV_CURRENT);

   156     } else {

   157         printf("phdr_set_type_self: Unknown ELF Class %d provided\n", elfclass);

   158     }

   159     return;

   160 }

   161 

   162 /*

   163   Create symbol table entry with given type and binding

   164 */

   165 void * create_sym_entry(int elfclass, int index, int type, int bind,

   166                         int shndx, int size, int value) {

   167   void * symentry = NULL;

   168     if (elfclass == ELFCLASS32) {

   169       Elf32_Sym * sym32 = (Elf32_Sym *) malloc(sizeof(Elf32_Sym));

   170       sym32->st_name = index;

   171       sym32->st_value = value;

   172       sym32->st_size = size;

   173       sym32->st_info = ELF32_ST_INFO(bind, type);

   174       sym32->st_other = 0;  // TODO: Add an argument to get this value ??

   175       sym32->st_shndx = shndx;

   176       symentry = sym32;

   177     } else if (elfclass == ELFCLASS64) {

   178       Elf64_Sym * sym64 = (Elf64_Sym *) malloc(sizeof(Elf64_Sym));

   179       sym64->st_name = index;

   180       sym64->st_value = value;

   181       sym64->st_size = size;

   182       sym64->st_info = ELF64_ST_INFO(bind, type);

   183       sym64->st_other = 0;  // TODO: Add an argument to get this value ??

   184       sym64->st_shndx = shndx;

   185       symentry = sym64;

   186     } else {

   187         printf("create_sym_entry: Unknown ELF Class %d provided\n", elfclass);

   188     }

   189     return (void *) symentry;

   190 }

   191 

   192 // Create a reloc (or reloca entry if argument reloca is non-zero)

   193 void * create_reloc_entry(int elfclass, int roffset, int symtabIdx,

   194                           int relocType, int raddend, int reloca) {

   195   void * relocentry = NULL;

   196   if (elfclass == ELFCLASS32) {

   197     if (reloca) {

   198       Elf32_Rela * rela32 = (Elf32_Rela *) malloc(sizeof(Elf32_Rela));

   199       rela32->r_offset = roffset;

   200       rela32->r_info = ELF32_R_INFO(symtabIdx, relocType);

   201       rela32->r_addend = raddend;

   202       relocentry = rela32;

   203     } else {

   204       Elf32_Rel * rel32 = (Elf32_Rel *) malloc(sizeof(Elf32_Rel));

   205       rel32->r_offset = roffset;

   206       rel32->r_info = ELF32_R_INFO(symtabIdx, relocType);

   207       relocentry = rel32;

   208     }

   209   } else if (elfclass == ELFCLASS64) {

   210     if (reloca) {

   211       Elf64_Rela * rela64 = (Elf64_Rela *) malloc(sizeof(Elf64_Rela));

   212       rela64->r_offset = roffset;

   213       rela64->r_info = ELF64_R_INFO(symtabIdx, relocType);

   214       rela64->r_addend = raddend;

   215       relocentry = rela64;

   216     } else {

   217       Elf64_Rel * rel64 = (Elf64_Rel *) malloc(sizeof(Elf64_Rel));

   218       rel64->r_offset = roffset;

   219       rel64->r_info = ELF64_R_INFO(symtabIdx, relocType);

   220       relocentry = rel64;

   221     }

   222   } else {

   223     printf("create_reloc_entry: Unknown ELF Class %d provided\n", elfclass);

   224   }

   225   return (void *) relocentry;

   226 }