gbrochar
/
ft_nm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: gbrochar:refacto
Branches Tags
gbrochar:main
gbrochar:correc
gbrochar:refacto
gbrochar:master
gbrochar:rsa
..
compare: gbrochar:main
Branches Tags
gbrochar:main
gbrochar:correc
gbrochar:refacto
gbrochar:master
gbrochar:rsa

5 Commits
refacto ... main

Author SHA1 Message Date
gbrochar 71c9d7703f last fix 2024-10-28 14:01:34 +01:00
gbrochar 88ed6d1ad9 fix bugs for correc 2024-10-28 13:56:33 +01:00
gbrochar 6c42540095 fix leaks 32bit 2024-10-25 14:51:59 +02:00
gbrochar 7983e97be3 fix leaks and clean 2024-10-25 14:47:21 +02:00
gbrochar df05b33dce clean 2024-10-25 12:42:39 +02:00
8 changed files with 277 additions and 301 deletions
Show Stats Expand all files Collapse all files

1
Makefile
View File

@ -8,6 +8,7 @@ SRC_FILES = main.c \
nm32.c \
fetch.c \
ft_printf.c \
tree.c \
INC_FILES = ft_nm.h \

1
inc/ft_nm.h
View File

@ -64,6 +64,7 @@ int strcmp_nm(void *a, void *b);
int reverse(void *a, void *b);
int nosort(void *a, void *b);
void put_entry(void *data);
void free_entry(void *data);
char ft_get_hex_digit(char c);

2
libft

@ -1 +1 @@
Subproject commit e846b98fcda5878a1d4d9de8f422dec09b97456c
Subproject commit cf6bb620300d5f003f28a23733e43b057370b906

35
src/main.c
View File

@ -57,7 +57,6 @@ int parse_options(char *options, t_env *env, bool *use_options) {
int parse_arguments(int ac, char **av, t_env *env) {
bool use_options = true;
if (ac > 0) {
env->bin_name = ft_strdup(av[0]);
env->bin_name = ft_strdup("nm");
}
for (int i = 1; i < ac; i++) {
@ -84,6 +83,7 @@ int nm(char *path, t_verbosity verbosity, t_ordering ordering) {
}
struct stat stat;
ft_bzero(&stat, sizeof(stat));
if (fstat(fd, &stat) == -1) {
ft_nm_error(path);
}
@ -97,23 +97,31 @@ int nm(char *path, t_verbosity verbosity, t_ordering ordering) {
unsigned char ident[EI_NIDENT];
if (!ident_ptr) {
ft_printf("sss", "nm: ", path, ": file format not recognized\n");
munmap(mapped_file.ptr, mapped_file.size);
close(fd);
return 0;
}
ft_memcpy(ident, ident_ptr, EI_NIDENT);
if (check_ident(ident) == FT_NM_FAILURE) {
ft_printf("sss", "nm: ", path, ": file format not recognized\n");
munmap(mapped_file.ptr, mapped_file.size);
close(fd);
return 0;
}
if (ident[EI_CLASS] == ELFCLASS32) {
if (nm32(mapped_file, path, verbosity, ordering) == FT_NM_FAILURE) {
ft_printf("sss", "nm: ", path, ": file format not recognized\n");
munmap(mapped_file.ptr, mapped_file.size);
close(fd);
return 0;
}
}
else if (ident[EI_CLASS] == ELFCLASS64) {
if (nm64(mapped_file, path, verbosity, ordering) == FT_NM_FAILURE) {
ft_printf("sss", "nm: ", path, ": file format not recognized\n");
munmap(mapped_file.ptr, mapped_file.size);
close(fd);
return 0;
}
}
@ -121,6 +129,17 @@ int nm(char *path, t_verbosity verbosity, t_ordering ordering) {
return 0;
}
void lst_free_func(void *content, size_t content_size) {
(void)content_size;
free(content);
}
void free_env(t_env env) {
ft_lstdel(&(env.list), &lst_free_func);
if (env.bin_name)
free(env.bin_name);
}
int main(int ac, char **av) {
t_env env;
env.verbosity = DEFAULT_VERBOSITY;
@ -129,20 +148,24 @@ int main(int ac, char **av) {
env.list = NULL;
int error = parse_arguments(ac, av, &env);
if (env.list_len == 0) {
env.list = ft_lstnew(ft_strdup("a.out"), 6);
env.list = ft_lstnew("a.out", 6);
env.list_len = 1;
}
if (error) {
free_env(env);
return error;
}
if (env.list_len == 1) {
nm(env.list->content, env.verbosity, env.ordering);
free_env(env);
return 0;
}
while (env.list) {
ft_printf("\ns:\n", env.list->content);
nm(env.list->content, env.verbosity, env.ordering);
env.list = env.list->next;
t_list *tmp = env.list;
while (tmp) {
ft_printf("\ns:\n", tmp->content);
nm(tmp->content, env.verbosity, env.ordering);
tmp = tmp->next;
}
free_env(env);
return 0;
}

301
src/nm.c
View File

@ -1,130 +1,122 @@
#include "ft_nm.h"
void ppp(Elf64_Sym sym, Elf64_Shdr sec);
void print_section(Elf64_Shdr sec);
void print_symbol(Elf64_Sym sym);
char *get_sym_char(Elf64_Sym sym, Elf64_Shdr sec, int *tool) {
// if ((sec.sh_flags & SHF_COMPRESSED) == SHF_COMPRESSED) {
// return ("N");
// }
char *get_sym_char(Elf64_Sym *sym, Elf64_Shdr *sec, int *tool) {
*tool = 0;
if (ELF64_ST_TYPE(sym.st_info) == STT_SECTION) {
if (ELF64_ST_TYPE(sym->st_info) == STT_SECTION) {
*tool = 1;
}
if (sym.st_shndx == SHN_ABS) {
if (ELF64_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sym->st_shndx == SHN_ABS) {
if (ELF64_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("a");
}
else if (ELF64_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF64_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("A");
}
}
if (ELF64_ST_BIND(sym.st_info) == STB_GNU_UNIQUE) {
if (ELF64_ST_BIND(sym->st_info) == STB_GNU_UNIQUE) {
return ("u");
}
if (ELF64_ST_TYPE(sym.st_info) == STT_GNU_IFUNC) {
if (ELF64_ST_TYPE(sym->st_info) == STT_GNU_IFUNC) {
return ("i");
}
if (sec.sh_flags & SHF_EXECINSTR) {
if (ELF64_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_flags & SHF_EXECINSTR) {
if (ELF64_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("t");
}
else if (ELF64_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF64_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("T");
}
}
if (sec.sh_type == SHT_NOBITS) {
if (ELF64_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_type == SHT_NOBITS) {
if (ELF64_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("b");
}
else if (ELF64_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF64_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("B");
}
}
if (sec.sh_type == SHT_PROGBITS && (sec.sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF64_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_type == SHT_PROGBITS && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF64_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("d");
}
else if (ELF64_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF64_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("D");
}
}
if (sec.sh_type == SHT_DYNAMIC && (sec.sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF64_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_type == SHT_DYNAMIC && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF64_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("d");
}
else if (ELF64_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF64_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("D");
}
}
if (sec.sh_type == SHT_INIT_ARRAY && (sec.sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF64_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_type == SHT_INIT_ARRAY && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF64_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("d");
}
else if (ELF64_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF64_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("D");
}
}
if (sec.sh_type == SHT_PREINIT_ARRAY && (sec.sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF64_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_type == SHT_PREINIT_ARRAY && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF64_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("d");
}
else if (ELF64_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF64_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("D");
}
}
if (sec.sh_type == SHT_FINI_ARRAY && (sec.sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF64_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_type == SHT_FINI_ARRAY && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF64_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("d");
}
else if (ELF64_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF64_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("D");
}
}
if (/*sec.sh_type == SHT_PROGBITS &&*/ sec.sh_flags & SHF_ALLOC) {
if (ELF64_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_flags & SHF_ALLOC) {
if (ELF64_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("r");
}
else if (ELF64_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF64_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("R");
}
}
if (sec.sh_type == SHT_NOTE && sec.sh_flags == SHF_ALLOC) {
if (ELF64_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_type == SHT_NOTE && sec->sh_flags == SHF_ALLOC) {
if (ELF64_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("r");
}
else if (ELF64_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF64_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("R");
}
}
if (sym.st_shndx == SHN_COMMON) {
if (ELF64_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sym->st_shndx == SHN_COMMON) {
if (ELF64_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("c");
}
else if (ELF64_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF64_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("C");
}
}
if (sym.st_shndx == SHN_UNDEF) {
//return ("U");
if (ELF64_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sym->st_shndx == SHN_UNDEF) {
if (ELF64_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("u");
}
else if (ELF64_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF64_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("U");
}
}
if (ELF64_ST_BIND(sym.st_info) == STB_WEAK) {
if (ELF64_ST_TYPE(sym.st_info) == STT_OBJECT) {
if (sec.sh_type == SHT_NULL) {
if (ELF64_ST_BIND(sym->st_info) == STB_WEAK) {
if (ELF64_ST_TYPE(sym->st_info) == STT_OBJECT) {
if (sec->sh_type == SHT_NULL) {
return ("v");
}
else {
return ("V");
}
} else {
if (sec.sh_type == SHT_NULL) {
if (sec->sh_type == SHT_NULL) {
return ("w");
}
else {
@ -132,8 +124,8 @@ char *get_sym_char(Elf64_Sym sym, Elf64_Shdr sec, int *tool) {
}
}
}
if (ELF64_ST_BIND(sym.st_info) == STB_WEAK) {
if (sec.sh_type == SHT_NULL) {
if (ELF64_ST_BIND(sym->st_info) == STB_WEAK) {
if (sec->sh_type == SHT_NULL) {
return ("w");
}
else {
@ -143,100 +135,90 @@ char *get_sym_char(Elf64_Sym sym, Elf64_Shdr sec, int *tool) {
return ("n");
}
int strcmp_nm(void *a, void *b) {
t_entry *aa = (t_entry *)a;
t_entry *bb = (t_entry *)b;
char *s1 = aa->symbol;
char *s2 = bb->symbol;
return ft_strcmp(s1, s2);
}
int reverse(void *a, void *b) {
return strcmp_nm(b, a);
}
int nosort(void *a, void *b) {
(void)a;
(void)b;
return 1;
}
void put_entry(void *data) {
t_node *node = (t_node *)data;
t_entry *entry = (t_entry *)node->data;
ft_putstr(entry->string);
}
int nm64(t_mapped_file mapped_file, char *path, t_verbosity verbosity, t_ordering ordering) {
t_root *tree = NULL;
t_entry *entry = (t_entry *)malloc(sizeof(t_entry));
int tool;
if (!entry)
return FT_NM_FAILURE;
Elf64_Ehdr header;
if (get_header64(mapped_file, &header) == FT_NM_FAILURE) {
return FT_NM_FAILURE;
}
uint64_t addr = header.e_shoff + header.e_shentsize * header.e_shstrndx;
Elf64_Shdr shstrtb;
shstrtb = *(Elf64_Shdr *)fetch(mapped_file, addr, header.e_shentsize);
for (int i = 0; i < header.e_shnum; i++) {
uint64_t addr = header.e_shoff + header.e_shentsize * i;
Elf64_Shdr sh;
sh = *(Elf64_Shdr *)fetch(mapped_file, addr, header.e_shentsize);
if (sh.sh_type == SHT_SYMTAB) {
uint64_t addr2 = header.e_shoff + header.e_shentsize * sh.sh_link;
Elf64_Shdr strtab;
strtab = *(Elf64_Shdr *)fetch(mapped_file, addr2, header.e_shentsize);
char first = *(char *)fetch(mapped_file, strtab.sh_offset, 1);
char last = *(char *)fetch(mapped_file, strtab.sh_offset + strtab.sh_size - 1, 1);
if (first != '\0' || last != '\0') {
if (header.e_ehsize != 64) {
return FT_NM_FAILURE;
}
uint64_t addr = header.e_shoff + header.e_shentsize * header.e_shstrndx;
Elf64_Shdr *shstrtb;
if (!(shstrtb = (Elf64_Shdr *)fetch(mapped_file, addr, header.e_shentsize))) {
return FT_NM_FAILURE;
}
t_root *tree = NULL;
t_entry *entry = (t_entry *)malloc(sizeof(t_entry));
if (!entry)
return FT_NM_FAILURE;
int tool;
for (int i = 0; i < header.e_shnum; i++) {
uint64_t addr = header.e_shoff + header.e_shentsize * i;
Elf64_Shdr *sh;
if (!(sh = (Elf64_Shdr *)fetch(mapped_file, addr, header.e_shentsize))) {
free(entry);
return FT_NM_FAILURE;
}
if (sh->sh_type == SHT_SYMTAB) {
uint64_t addr2 = header.e_shoff + header.e_shentsize * sh->sh_link;
Elf64_Shdr *strtab;
if (!(strtab = (Elf64_Shdr *)fetch(mapped_file, addr2, header.e_shentsize))) {
free(entry);
return FT_NM_FAILURE;
}
char *first = (char *)fetch(mapped_file, strtab->sh_offset, 1);
char *last = (char *)fetch(mapped_file, strtab->sh_offset + strtab->sh_size - 1, 1);
if (!first || !last || *first != '\0' || *last != '\0') {
free(entry);
return FT_NM_FAILURE;
}
for (uint64_t j = sh->sh_entsize; j < sh->sh_size; j += sh->sh_entsize) {
Elf64_Sym *sym;
Elf64_Shdr *sec;
if (!(sym = (Elf64_Sym *)fetch(mapped_file, sh->sh_offset + j, sh->sh_entsize))) {
free(entry);
return FT_NM_FAILURE;
}
if (sym->st_shndx < header.e_shnum) {
if (!(sec = (Elf64_Shdr *)fetch(mapped_file, header.e_shoff + header.e_shentsize * sym->st_shndx, header.e_shentsize))) {
free(entry);
return FT_NM_FAILURE;
}
for (uint64_t j = sh.sh_entsize; j < sh.sh_size; j += sh.sh_entsize) {
Elf64_Sym sym;
Elf64_Shdr sec;
sym = *(Elf64_Sym *)fetch(mapped_file, sh.sh_offset + j, sh.sh_entsize);
if (sym.st_shndx < header.e_shnum) {
sec = *(Elf64_Shdr *)fetch(mapped_file, header.e_shoff + header.e_shentsize * sym.st_shndx, header.e_shentsize);
}
char *str;
char *sec_str;
Elf64_Shdr shdr;
if (sym.st_shndx != SHN_ABS) {
shdr = *(Elf64_Shdr *)fetch(mapped_file, header.e_shoff + header.e_shentsize * sym.st_shndx, header.e_shentsize);
sec_str = ft_strdup(mapped_file.ptr + shstrtb.sh_offset + shdr.sh_name);
Elf64_Shdr *shdr;
if (sym->st_shndx != SHN_ABS) {
if (!(shdr = (Elf64_Shdr *)fetch(mapped_file, header.e_shoff + header.e_shentsize * sym->st_shndx, header.e_shentsize))) {
free(entry);
return FT_NM_FAILURE;
}
sec_str = ft_strdup(mapped_file.ptr + shstrtb->sh_offset + shdr->sh_name);
} else {
sec_str = ft_strdup("");
}
if (sym.st_name) {
str = ft_strdup(mapped_file.ptr + strtab.sh_offset + sym.st_name);
if (sym->st_name) {
str = ft_strdup(mapped_file.ptr + strtab->sh_offset + sym->st_name);
}
else {
str = sec_str;
}
if (str != sec_str)
free(sec_str);
// ici la str (le symbole) est bon, on la charge dans le truc, ensuite on genere la vrai string a afficher, avant de sort
entry->symbol = ft_strdup(str);
free(str);
char *sym_char = ft_strdup(get_sym_char(sym, sec, &tool));
//if (entry->symbol[0] == '.' || ft_strnstr(entry->symbol, "lpstub", 6)) {
if (ft_strnstr(entry->symbol, ".debug", 6) && ft_strequ(sym_char, "n")) {
free(sym_char);
sym_char = ft_strdup("N");
}
/*
if (sym_char[0] == 'N') {
ft_putstr(entry->symbol);
ft_putchar(*sym_char);
ft_putchar('\n');
print_symbol(sym);
}*/
// ici le sym char a ete calculer, a partir de la on determine la verbosity
// ici on fait if entry->verbosity >= verbosity, si c'est pas bon on skip toute la suite
entry->verbosity = DEFAULT_VERBOSITY;
if ((sym_char[0] == 'a' && sym.st_info == 4) || sym_char[0] == 'N' || tool == 1)// || entry->symbol[0] == '.')
if ((sym_char[0] == 'a' && sym->st_info == 4) || sym_char[0] == 'N' || tool == 1)
entry->verbosity = ALL;
if (sym_char[0] == 'u' || sym_char[0] == 'v' || sym_char[0] == 'w' || (sym_char[0] >= 'A' && sym_char[0] <= 'Z' && sym_char[0] != 'N'))
entry->verbosity = GLOBAL;
@ -255,15 +237,15 @@ int nm64(t_mapped_file mapped_file, char *path, t_verbosity verbosity, t_orderin
entry->string[17] = sym_char[0];
entry->string[18] = ' ';
ft_memcpy(entry->string + 19, entry->symbol, ft_strlen(entry->symbol));
if (sym.st_value && !ft_strstr(entry->symbol, "@@")) {
if (sym->st_value && !ft_strstr(entry->symbol, "@@")) {
for (char i = 15; i >= 0; i--) {
entry->string[15 - i] = ft_get_hex_digit((sym.st_value >> i * 4) & 0xF);
entry->string[15 - i] = ft_get_hex_digit((sym->st_value >> i * 4) & 0xF);
}
} else {
if (ft_strcmp(sym_char, "U") && ft_strcmp(sym_char, "w") && ft_strcmp(sym_char, "v")) {
for (char i = 15; i >= 0; i--) {
entry->string[15 - i] = ft_get_hex_digit((sym.st_value >> i * 4) & 0xF);
entry->string[15 - i] = ft_get_hex_digit((sym->st_value >> i * 4) & 0xF);
}
} else {
for (int i = 0; i < 16; i++)
@ -283,85 +265,20 @@ int nm64(t_mapped_file mapped_file, char *path, t_verbosity verbosity, t_orderin
ft_rbt_insert(&tree, ft_rbt_new((void *)entry, sizeof(t_entry)), &strcmp_nm);
break;
}
// pas de bst oops :D
fflush(stdout);
} else {
free(entry->symbol);
free(sym_char);
}
}
}
char *str = ft_strdup(mapped_file.ptr + shstrtb.sh_offset + sh.sh_name);
free(str);
}
free(entry);
// ici on affiche tout ou no symbols en cas de list vide
if (tree) {
ft_putrbt(tree, &put_entry);
ft_delrbt(tree, &free_entry);
} else {
ft_printf("sss", "nm: ", path, ": no symbols\n");
}
return FT_NM_SUCCESS;
}
void print_st_info(unsigned char st_info) {
unsigned char type = ELF64_ST_TYPE(st_info);
unsigned char bind = ELF64_ST_BIND(st_info);
if (type == STT_NOTYPE) {
ft_putstr("symbol has no type (STT_NOTYPE)\n");
} else if (type == STT_OBJECT) {
ft_putstr("symbol has object type (STT_OBJECT)\n");
} else if (type == STT_FUNC) {
ft_putstr("symbol has func type (STT_FUNC)\n");
} else if (type == STT_SECTION) {
ft_putstr("symbol has section type (STT_SECTION)\n");
} else if (type == STT_FILE) {
ft_putstr("symbol has file type (STT_FILE)\n");
} else if (type >= STT_LOPROC && type <= STT_HIPROC) {
ft_putnbr(type);
ft_putstr(" reserved for processor-specific semantics (STT_LOPROC <= type <= STT_HIPROC)\n");
} else {
ft_putstr("symbol TYPE unknown (warning: no matching STT_****)\n");
}
if (bind == STB_LOCAL) {
ft_putstr("symbol has local bind (STB_LOCAL)\n");
} else if (bind == STB_GLOBAL) {
ft_putstr("symbol has global bind (STB_GLOBAL)\n");
} else if (bind == STB_WEAK) {
ft_putstr("symbol has weak bind (STB_WEAK)\n");
} else if (bind >= STB_LOPROC && bind <= STB_HIPROC) {
ft_putnbr(bind);
ft_putstr(" reserved for processor-specific semantics (STB_LOPROC <= bind <= STB_HIPROC)\n");
} else {
ft_putstr("symbol BIND unknown (warning: no matching STB_****)\n");
}
}
void print_symbol(Elf64_Sym sym) {
printf("st_name: %d\n", sym.st_name);
printf("st_info: %d\n", sym.st_info);
print_st_info(sym.st_info);
printf("st_other: %d\n", sym.st_other);
printf("st_shndx: %d\n", sym.st_shndx);
// printf("st_value: %ld\n", sym.st_value);
// printf("st_size: %ld\n", sym.st_size);
fflush(stdout);
}
void print_section(Elf64_Shdr sec) {
printf("sh_name : %d\n", sec.sh_name);
printf("sh_type : %d\n", sec.sh_type);
printf("sh_flags : %ld\n", sec.sh_flags);
// printf("sh_addr : %ld\n", sec.sh_addr);
// printf("sh_offset : %ld\n", sec.sh_offset);
// printf("sh_size : %ld\n", sec.sh_size);
printf("sh_link : %d\n", sec.sh_link);
printf("sh_info : %d\n", sec.sh_info);
// printf("sh_addralign : %ld\n", sec.sh_addralign);
// printf("sh_entsize : %ld\n", sec.sh_entsize);
fflush(stdout);
}
void ppp(Elf64_Sym sym, Elf64_Shdr sec) {
print_symbol(sym);
print_section(sec);
}

208
src/nm32.c
View File

@ -1,126 +1,122 @@
#include "ft_nm.h"
char *get_sym_char32(Elf32_Sym sym, Elf32_Shdr sec, int *tool) {
// if ((sec.sh_flags & SHF_COMPRESSED) == SHF_COMPRESSED) {
// return ("N");
// }
char *get_sym_char32(Elf32_Sym *sym, Elf32_Shdr *sec, int *tool) {
*tool = 0;
if (ELF32_ST_TYPE(sym.st_info) == STT_SECTION) {
if (ELF32_ST_TYPE(sym->st_info) == STT_SECTION) {
*tool = 1;
}
if (sym.st_shndx == SHN_ABS) {
if (ELF32_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sym->st_shndx == SHN_ABS) {
if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("a");
}
else if (ELF32_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("A");
}
}
if (ELF32_ST_BIND(sym.st_info) == STB_GNU_UNIQUE) {
if (ELF32_ST_BIND(sym->st_info) == STB_GNU_UNIQUE) {
return ("u");
}
if (ELF32_ST_TYPE(sym.st_info) == STT_GNU_IFUNC) {
if (ELF32_ST_TYPE(sym->st_info) == STT_GNU_IFUNC) {
return ("i");
}
if (sec.sh_flags & SHF_EXECINSTR) {
if (ELF32_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_flags & SHF_EXECINSTR) {
if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("t");
}
else if (ELF32_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("T");
}
}
if (sec.sh_type == SHT_NOBITS) {
if (ELF32_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_type == SHT_NOBITS) {
if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("b");
}
else if (ELF32_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("B");
}
}
if (sec.sh_type == SHT_PROGBITS && (sec.sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF32_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_type == SHT_PROGBITS && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("d");
}
else if (ELF32_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("D");
}
}
if (sec.sh_type == SHT_DYNAMIC && (sec.sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF32_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_type == SHT_DYNAMIC && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("d");
}
else if (ELF32_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("D");
}
}
if (sec.sh_type == SHT_INIT_ARRAY && (sec.sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF32_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_type == SHT_INIT_ARRAY && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("d");
}
else if (ELF32_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("D");
}
}
if (sec.sh_type == SHT_PREINIT_ARRAY && (sec.sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF32_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_type == SHT_PREINIT_ARRAY && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("d");
}
else if (ELF32_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("D");
}
}
if (sec.sh_type == SHT_FINI_ARRAY && (sec.sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF32_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_type == SHT_FINI_ARRAY && (sec->sh_flags & (SHF_ALLOC | SHF_WRITE)) == (SHF_ALLOC | SHF_WRITE)) {
if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("d");
}
else if (ELF32_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("D");
}
}
if (/*sec.sh_type == SHT_PROGBITS &&*/ sec.sh_flags & SHF_ALLOC) {
if (ELF32_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_flags & SHF_ALLOC) {
if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("r");
}
else if (ELF32_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("R");
}
}
if (sec.sh_type == SHT_NOTE && sec.sh_flags == SHF_ALLOC) {
if (ELF32_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sec->sh_type == SHT_NOTE && sec->sh_flags == SHF_ALLOC) {
if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("r");
}
else if (ELF32_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("R");
}
}
if (sym.st_shndx == SHN_COMMON) {
if (ELF32_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sym->st_shndx == SHN_COMMON) {
if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("c");
}
else if (ELF32_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("C");
}
}
if (sym.st_shndx == SHN_UNDEF) {
//return ("U");
if (ELF32_ST_BIND(sym.st_info) == STB_LOCAL) {
if (sym->st_shndx == SHN_UNDEF) {
if (ELF32_ST_BIND(sym->st_info) == STB_LOCAL) {
return ("u");
}
else if (ELF32_ST_BIND(sym.st_info) == STB_GLOBAL) {
else if (ELF32_ST_BIND(sym->st_info) == STB_GLOBAL) {
return ("U");
}
}
if (ELF32_ST_BIND(sym.st_info) == STB_WEAK) {
if (ELF32_ST_TYPE(sym.st_info) == STT_OBJECT) {
if (sec.sh_type == SHT_NULL) {
if (ELF32_ST_BIND(sym->st_info) == STB_WEAK) {
if (ELF32_ST_TYPE(sym->st_info) == STT_OBJECT) {
if (sec->sh_type == SHT_NULL) {
return ("v");
}
else {
return ("V");
}
} else {
if (sec.sh_type == SHT_NULL) {
if (sec->sh_type == SHT_NULL) {
return ("w");
}
else {
@ -128,8 +124,8 @@ char *get_sym_char32(Elf32_Sym sym, Elf32_Shdr sec, int *tool) {
}
}
}
if (ELF32_ST_BIND(sym.st_info) == STB_WEAK) {
if (sec.sh_type == SHT_NULL) {
if (ELF32_ST_BIND(sym->st_info) == STB_WEAK) {
if (sec->sh_type == SHT_NULL) {
return ("w");
}
else {
@ -138,76 +134,91 @@ char *get_sym_char32(Elf32_Sym sym, Elf32_Shdr sec, int *tool) {
}
return ("n");
}
int nm32(t_mapped_file mapped_file, char *path, t_verbosity verbosity, t_ordering ordering) {
t_root *tree = NULL;
t_entry *entry = (t_entry *)malloc(sizeof(t_entry));
int tool;
if (!entry)
return FT_NM_FAILURE;
Elf32_Ehdr header;
if (get_header32(mapped_file, &header) == FT_NM_FAILURE) {
return FT_NM_FAILURE;
}
uint32_t addr = header.e_shoff + header.e_shentsize * header.e_shstrndx;
Elf32_Shdr shstrtb;
shstrtb = *(Elf32_Shdr *)fetch(mapped_file, addr, header.e_shentsize);
for (int i = 0; i < header.e_shnum; i++) {
uint32_t addr = header.e_shoff + header.e_shentsize * i;
Elf32_Shdr sh;
sh = *(Elf32_Shdr *)fetch(mapped_file, addr, header.e_shentsize);
if (sh.sh_type == SHT_SYMTAB) {
uint32_t addr2 = header.e_shoff + header.e_shentsize * sh.sh_link;
Elf32_Shdr strtab;
strtab = *(Elf32_Shdr *)fetch(mapped_file, addr2, header.e_shentsize);
char first = *(char *)fetch(mapped_file, strtab.sh_offset, 1);
char last = *(char *)fetch(mapped_file, strtab.sh_offset + strtab.sh_size - 1, 1);
if (first != '\0' || last != '\0') {
if (header.e_ehsize != 52) {
return FT_NM_FAILURE;
}
uint32_t addr = header.e_shoff + header.e_shentsize * header.e_shstrndx;
Elf32_Shdr *shstrtb;
if (!(shstrtb = (Elf32_Shdr *)fetch(mapped_file, addr, header.e_shentsize))) {
return FT_NM_FAILURE;
}
t_root *tree = NULL;
t_entry *entry = (t_entry *)malloc(sizeof(t_entry));
if (!entry)
return FT_NM_FAILURE;
int tool;
for (int i = 0; i < header.e_shnum; i++) {
uint32_t addr = header.e_shoff + header.e_shentsize * i;
Elf32_Shdr *sh;
if (!(sh = (Elf32_Shdr *)fetch(mapped_file, addr, header.e_shentsize))) {
free(entry);
return FT_NM_FAILURE;
}
if (sh->sh_type == SHT_SYMTAB) {
uint32_t addr2 = header.e_shoff + header.e_shentsize * sh->sh_link;
Elf32_Shdr *strtab;
if (!(strtab = (Elf32_Shdr *)fetch(mapped_file, addr2, header.e_shentsize))) {
free(entry);
return FT_NM_FAILURE;
}
char *first = (char *)fetch(mapped_file, strtab->sh_offset, 1);
char *last = (char *)fetch(mapped_file, strtab->sh_offset + strtab->sh_size - 1, 1);
if (!first || !last || *first != '\0' || *last != '\0') {
free(entry);
return FT_NM_FAILURE;
}
for (uint32_t j = sh->sh_entsize; j < sh->sh_size; j += sh->sh_entsize) {
Elf32_Sym *sym;
Elf32_Shdr *sec;
if (!(sym = (Elf32_Sym *)fetch(mapped_file, sh->sh_offset + j, sh->sh_entsize))) {
free(entry);
return FT_NM_FAILURE;
}
if (sym->st_shndx < header.e_shnum) {
if (!(sec = (Elf32_Shdr *)fetch(mapped_file, header.e_shoff + header.e_shentsize * sym->st_shndx, header.e_shentsize))) {
free(entry);
return FT_NM_FAILURE;
}
for (uint64_t j = sh.sh_entsize; j < sh.sh_size; j += sh.sh_entsize) {
Elf32_Sym sym;
Elf32_Shdr sec;
sym = *(Elf32_Sym *)fetch(mapped_file, sh.sh_offset + j, sh.sh_entsize);
if (sym.st_shndx < header.e_shnum) {
sec = *(Elf32_Shdr *)fetch(mapped_file, header.e_shoff + header.e_shentsize * sym.st_shndx, header.e_shentsize);
}
char *str;
char *sec_str;
Elf32_Shdr shdr;
if (sym.st_shndx != SHN_ABS) {
shdr = *(Elf32_Shdr *)fetch(mapped_file, header.e_shoff + header.e_shentsize * sym.st_shndx, header.e_shentsize);
sec_str = ft_strdup(mapped_file.ptr + shstrtb.sh_offset + shdr.sh_name);
Elf32_Shdr *shdr;
if (sym->st_shndx != SHN_ABS) {
if (!(shdr = (Elf32_Shdr *)fetch(mapped_file, header.e_shoff + header.e_shentsize * sym->st_shndx, header.e_shentsize))) {
free(entry);
return FT_NM_FAILURE;
}
sec_str = ft_strdup(mapped_file.ptr + shstrtb->sh_offset + shdr->sh_name);
} else {
sec_str = ft_strdup("");
}
if (sym.st_name) {
str = ft_strdup(mapped_file.ptr + strtab.sh_offset + sym.st_name);
if (sym->st_name) {
str = ft_strdup(mapped_file.ptr + strtab->sh_offset + sym->st_name);
}
else {
str = sec_str;
}
if (str != sec_str)
free(sec_str);
// ici la str (le symbole) est bon, on la charge dans le truc, ensuite on genere la vrai string a afficher, avant de sort
entry->symbol = ft_strdup(str);
free(str);
char *sym_char = ft_strdup(get_sym_char32(sym, sec, &tool));
//if (entry->symbol[0] == '.' || ft_strnstr(entry->symbol, "lpstub", 6)) {
if (ft_strnstr(entry->symbol, ".debug", 6) && ft_strequ(sym_char, "n")) {
free(sym_char);
sym_char = ft_strdup("N");
}
/*
if (sym_char[0] == 'N') {
ft_putstr(entry->symbol);
ft_putchar(*sym_char);
ft_putchar('\n');
print_symbol(sym);
}*/
// ici le sym char a ete calculer, a partir de la on determine la verbosity
// ici on fait if entry->verbosity >= verbosity, si c'est pas bon on skip toute la suite
entry->verbosity = DEFAULT_VERBOSITY;
if ((sym_char[0] == 'a' && sym.st_info == 4) || sym_char[0] == 'N' || tool == 1)// || entry->symbol[0] == '.')
if ((sym_char[0] == 'a' && sym->st_info == 4) || sym_char[0] == 'N' || tool == 1)
entry->verbosity = ALL;
if (sym_char[0] == 'u' || sym_char[0] == 'v' || sym_char[0] == 'w' || (sym_char[0] >= 'A' && sym_char[0] <= 'Z' && sym_char[0] != 'N'))
entry->verbosity = GLOBAL;
@ -226,15 +237,15 @@ int nm32(t_mapped_file mapped_file, char *path, t_verbosity verbosity, t_orderin
entry->string[9] = sym_char[0];
entry->string[10] = ' ';
ft_memcpy(entry->string + 11, entry->symbol, ft_strlen(entry->symbol));
if (sym.st_value && !ft_strstr(entry->symbol, "@@")) {
if (sym->st_value && !ft_strstr(entry->symbol, "@@")) {
for (char i = 7; i >= 0; i--) {
entry->string[7 - i] = ft_get_hex_digit((sym.st_value >> i * 4) & 0xF);
entry->string[7 - i] = ft_get_hex_digit((sym->st_value >> i * 4) & 0xF);
}
} else {
if (ft_strcmp(sym_char, "U") && ft_strcmp(sym_char, "w") && ft_strcmp(sym_char, "v")) {
for (char i = 7; i >= 0; i--) {
entry->string[7 - i] = ft_get_hex_digit((sym.st_value >> i * 4) & 0xF);
entry->string[7 - i] = ft_get_hex_digit((sym->st_value >> i * 4) & 0xF);
}
} else {
for (int i = 0; i < 8; i++)
@ -254,17 +265,18 @@ int nm32(t_mapped_file mapped_file, char *path, t_verbosity verbosity, t_orderin
ft_rbt_insert(&tree, ft_rbt_new((void *)entry, sizeof(t_entry)), &strcmp_nm);
break;
}
// pas de bst oops :D
fflush(stdout);
} else {
free(entry->symbol);
free(sym_char);
}
}
}
char *str = ft_strdup(mapped_file.ptr + shstrtb.sh_offset + sh.sh_name);
free(str);
}
free(entry);
// ici on affiche tout ou no symbols en cas de list vide
if (tree) {
ft_putrbt(tree, &put_entry);
ft_delrbt(tree, &free_entry);
} else {
ft_printf("sss", "nm: ", path, ": no symbols\n");
}

32
src/tree.c Normal file
View File

@ -0,0 +1,32 @@
#include "ft_nm.h"
int strcmp_nm(void *a, void *b) {
t_entry *aa = (t_entry *)a;
t_entry *bb = (t_entry *)b;
char *s1 = aa->symbol;
char *s2 = bb->symbol;
return ft_strcmp(s1, s2);
}
int reverse(void *a, void *b) {
return strcmp_nm(b, a);
}
int nosort(void *a, void *b) {
(void)a;
(void)b;
return 1;
}
void put_entry(void *data) {
t_node *node = (t_node *)data;
t_entry *entry = (t_entry *)node->data;
ft_putstr(entry->string);
}
void free_entry(void *data) {
t_node *node = (t_node *)data;
t_entry *entry = (t_entry *)node->data;
free(entry->string);
free(entry->symbol);
}

10
unit_test.sh
View File

@ -1,10 +0,0 @@
#!/bin/bash
for file in $1*/**/*
do
if [[ "$file" != *.a ]] ;then
echo $file
./ft_nm $2 $file 2>&1 | cat > a
nm $2 $file 2>&1 | cat > b
diff a b
fi
done