feat: 32bit

debug st_info
strcmp
2024-10-25 12:36:52 +02:00 · 2024-10-21 17:13:46 +02:00 · 2024-10-20 20:55:07 +02:00 · 2024-10-20 20:10:21 +02:00 · 2024-10-20 20:09:55 +02:00 · 2024-10-15 16:26:28 +02:00
11 changed files with 674 additions and 102 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,5 +1,8 @@
 # ft_nm
+out.all
 ft_nm
+a
+b

 # libft
 inc/libft.h
--- a/3
+++ b/3
@ -5,6 +5,7 @@ SRC_FILES = main.c \
 			header.c \
 			ident.c \
 			nm.c \
+			nm32.c \
 			fetch.c \
 			ft_printf.c \

@ -22,7 +23,7 @@ OBJ = $(addprefix $(OBJ_DIR), $(OBJ_FILES))

 CC = gcc
 
-CFLAGS = -Wall -Werror -Wextra
+CFLAGS = -Wall -Werror -Wextra -g3

 LIB_NAME = libft

--- a/inc/ft_nm.h
+++ b/inc/ft_nm.h
@ -15,6 +15,34 @@
 # define FT_NM_SUCCESS 0
 # define FT_NM_FAILURE -1

+typedef enum e_verbosity {
+	ALL,
+	DEFAULT_VERBOSITY,
+	GLOBAL,
+	UNDEFINED
+} t_verbosity;
+
+typedef enum e_ordering {
+	DEFAULT_ORDERING,
+	REVERSE,
+	NOSORT
+} t_ordering;
+
+typedef struct s_entry {
+	t_verbosity verbosity;
+	char *string;
+	char *symbol;
+} t_entry;
+
+typedef struct s_env {
+	char *bin_name;
+	t_verbosity verbosity;
+	t_ordering ordering;
+	t_list *list;
+	int list_len;
+	bool has_multiple_files;
+} t_env;
+
 typedef struct s_mapped_file {
 	void *ptr;
 	off_t size;
@ -26,10 +54,18 @@ void ft_nm_error(const char *path);
 int check_ident(unsigned char ident[EI_NIDENT]);
 void *fetch(t_mapped_file mapped_file, size_t offset, size_t fetch_size);

-int nm32(t_mapped_file mapped_file);
+int nm32(t_mapped_file mapped_file, char *path, t_verbosity verbosity, t_ordering ordering);
+int get_header32(t_mapped_file mapped_file, Elf32_Ehdr *header);

-int nm64(t_mapped_file mapped_file);
+int nm64(t_mapped_file mapped_file, char *path, t_verbosity verbosity, t_ordering ordering);
 int get_header64(t_mapped_file mapped_file, Elf64_Ehdr *header);

+int strcmp_nm(void *a, void *b);
+int reverse(void *a, void *b);
+int nosort(void *a, void *b);
+void put_entry(void *data);
+
+char ft_get_hex_digit(char c);
+
 #endif

--- a/2
+++ b/2
@ -1 +1 @@
-Subproject commit 1ab0cdf1acf97db0cb8d90940c96a6f1ccb3a7af
+Subproject commit e846b98fcda5878a1d4d9de8f422dec09b97456c
--- a/src/ft_printf.c
+++ b/src/ft_printf.c
@ -1,5 +1,13 @@
 #include "ft_nm.h"

+char ft_get_hex_digit(char c) {
+	if (c > 9) {
+		return c + 'W';
+	} else {
+		return c + '0';
+	}
+}
+
 void ft_print_hex_digit(char c) {
 	if (c > 9) {
 		ft_putchar(c + 'W');
@ -48,6 +56,9 @@ void ft_printf(const char *format, ...) {
 			case 'P':
 				ft_putstr("                ");
 				break;
+			default:
+				ft_putchar(format[i]);
+				break;
 		}
 	}
 	va_end(ap);
--- a/src/header.c
+++ b/src/header.c
@ -9,3 +9,12 @@ int get_header64(t_mapped_file mapped_file, Elf64_Ehdr *header) {
 	return FT_NM_SUCCESS;
 }

+int get_header32(t_mapped_file mapped_file, Elf32_Ehdr *header) {
+	void *header_ptr = fetch(mapped_file, 0, 52);
+	if (!header_ptr) {
+		return FT_NM_FAILURE;
+	}
+	ft_memcpy(header, header_ptr, 52);
+	return FT_NM_SUCCESS;
+}
+
--- a/src/main.c
+++ b/src/main.c
@ -1,62 +1,148 @@
 #include "ft_nm.h"

-int main(int ac, char **av) {
-	char *path = ft_strdup("a.out");
-
-	if (ac > 1) {
-		free(path);
-		path = ft_strdup(av[1]);
+void help(char *bin_name) {
+	ft_printf("sss", "Usage: ", bin_name, " [option(s)] [file(s)]\n");
+	ft_putstr(
+			" List symbols in [file(s)] (a.out by default).\n"
+			" The options are:\n"
+			"  -a Display debugger-only symbols\n"
+			"  -g Display only external symbols\n"
+			"  -p Do not sort the symbols\n"
+			"  -r Reverse the sense of the sort\n"
+			"  -u Display only undefined symbols\n"
+			"  -h Display this information\n");
+	ft_printf("ss", bin_name, ": supported targets: elf64-x86-64 elf32-x86-64\n");
+	ft_putstr("Report bugs to gaetanbrochard@protonmail.com\n");
 }

+int parse_options(char *options, t_env *env, bool *use_options) {
+	int len = ft_strlen(options);
+	if (len == 2 && options[1] == '-') {
+		*use_options = false;
+		return 0;
+	}
+	for (int i = 1; i < len; i++) {
+		switch (options[i]) {
+			case 'h':
+				help(env->bin_name);
+				return -2;
+				break;
+			case 'a':
+				if (env->verbosity < ALL || env->verbosity == DEFAULT_VERBOSITY)
+					env->verbosity = ALL;
+				break;
+			case 'g':
+				if (env->verbosity < GLOBAL)
+					env->verbosity = GLOBAL;
+				break;
+			case 'u':
+				if (env->verbosity < UNDEFINED)
+					env->verbosity = UNDEFINED;
+				break;
+			case 'r':
+				if (env->ordering < REVERSE)
+					env->ordering = REVERSE;
+				break;
+			case 'p':
+				if (env->ordering < NOSORT)
+					env->ordering = NOSORT;
+				break;
+			default:
+				return -1;
+		}
+	}
+	return 0;
+}
+
+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++) {
+		if (ft_strlen(av[i]) > 0 && av[i][0] == '-' && use_options) {
+			int ret = parse_options(av[i], env, &use_options);
+			if (ret != 0)
+				return ret;
+		} else {
+			if (env->list_len == 0) {
+				env->list = ft_lstnew(av[i], ft_strlen(av[i]) + 1);
+			} else {
+				ft_lstadd_back(&env->list, ft_lstnew(av[i], ft_strlen(av[i]) + 1));
+			}
+			env->list_len++;
+		}
+	}
+	return 0;
+}
+
+int nm(char *path, t_verbosity verbosity, t_ordering ordering) {
 	int fd = open(path, O_RDONLY);
 	if (fd == -1) {
 		ft_nm_error(path);
-		free(path);
-		exit (EXIT_FAILURE);
 	}

 	struct stat stat;
 	if (fstat(fd, &stat) == -1) {
 		ft_nm_error(path);
-		free(path);
-		exit (EXIT_FAILURE);
 	}

 	t_mapped_file mapped_file;

-//	ft_printf("sds", "file size: ", stat.st_size, "\n");
 	mapped_file.ptr = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
 	mapped_file.size = stat.st_size;
 	if (mapped_file.ptr != MAP_FAILED) {
 		void *ident_ptr = fetch(mapped_file, 0, EI_NIDENT);
 		unsigned char ident[EI_NIDENT];
 		if (!ident_ptr) {
-			ft_printf("sss", "ft_nm: ", path, ": file format not recognized\n");
-			free(path);
-			exit(EXIT_FAILURE);
+			ft_printf("sss", "nm: ", path, ": file format not recognized\n");
+			return 0;
+
 		}
 		ft_memcpy(ident, ident_ptr, EI_NIDENT);
 		if (check_ident(ident) == FT_NM_FAILURE) {
-			ft_printf("sss", "ft_nm: ", path, ": file format not recognized\n");
-			free(path);
-			exit(EXIT_FAILURE);
+			ft_printf("sss", "nm: ", path, ": file format not recognized\n");
+			return 0;
 		}
 		if (ident[EI_CLASS] == ELFCLASS32) {
-			if (nm32(mapped_file) == FT_NM_FAILURE) {
-				ft_printf("sss", "ft_nm: ", path, ": file format not recognized\n");
-				free(path);
-				exit(EXIT_FAILURE);
+			if (nm32(mapped_file, path, verbosity, ordering) == FT_NM_FAILURE) {
+				ft_printf("sss", "nm: ", path, ": file format not recognized\n");
+				return 0;
 			}
 		}
 		else if (ident[EI_CLASS] == ELFCLASS64) {
-			if (nm64(mapped_file) == FT_NM_FAILURE) {
-				ft_printf("sss", "ft_nm: ", path, ": file format not recognized\n");
-				free(path);
-				exit(EXIT_FAILURE);
+			if (nm64(mapped_file, path, verbosity, ordering) == FT_NM_FAILURE) {
+				ft_printf("sss", "nm: ", path, ": file format not recognized\n");
+				return 0;
 			}
 		}
 	}
-	free(path);
 	return 0;
 }

+int main(int ac, char **av) {
+	t_env env;
+	env.verbosity = DEFAULT_VERBOSITY;
+	env.ordering = DEFAULT_ORDERING;
+	env.list_len = 0;
+	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_len = 1;
+	}
+	if (error) {
+		return error;
+	}
+	if (env.list_len == 1) {
+		nm(env.list->content, env.verbosity, env.ordering);
+		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;
+	}
+	return 0;
+}
--- a/src/nm.c
+++ b/src/nm.c
@ -4,11 +4,14 @@ 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) {
-	//	ppp(sym, sec);
+char *get_sym_char(Elf64_Sym sym, Elf64_Shdr sec, int *tool) {
 	//	if ((sec.sh_flags & SHF_COMPRESSED) == SHF_COMPRESSED) {
 	//		return ("N");
 	//	}
+	*tool = 0;
+	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) {
 			return ("a");
@ -137,73 +140,71 @@ char *get_sym_char(Elf64_Sym sym, Elf64_Shdr sec) {
 			return ("W");
 		}
 	}
-	// if section name starts with .debug....
-	// return ("N");
 	return ("n");
 }

-int nm64(t_mapped_file mapped_file) {
+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;
 	}
-	/*	printf("Header:\n");
-		printf("Version: %d\n", header.e_version);
-		printf("Entry point: %ld\n", header.e_entry);
-		printf("Program header offset: ");
-		fflush(stdout);
-		ft_printf("X", header.e_phoff);
-		ft_putchar('\n');
-		printf("Section header offset: ");
-		fflush(stdout);
-		ft_printf("X", header.e_shoff);
-		ft_putchar('\n');
-		printf("Header size: %d\n", header.e_ehsize);
-		printf("Program header entry size: %d\n", header.e_phentsize);
-		printf("Program header num: %d\n", header.e_phnum);
-		printf("Section header entry size: %d\n", header.e_shentsize);
-		printf("Section header num: %d\n", header.e_shnum);
-		printf("Section header string table index: %d\n", header.e_shstrndx);
-		*/
-	/*
-	   for (int i = 0; i < header.e_phnum; i++) {
-	   uint64_t addr = header.e_phoff + header.e_phentsize * i;
-	   Elf64_Phdr phstr;
-	   ft_memcpy(&phstr, mapped_file.ptr + addr, header.e_phentsize);
-	   ft_printf("X", phstr.p_offset);
-	   ft_putchar('\n');
-	   char *str = ft_strdup(mapped_file.ptr + phstr.p_offset + 1);
-	   ft_putstr(str);
-	   ft_putchar('\n');
-	   }
-	   */
 	uint64_t addr = header.e_shoff + header.e_shentsize * header.e_shstrndx;
-	//ft_printf("sX", "addr: ", addr);
 	Elf64_Shdr shstrtb;
-	ft_memcpy(&shstrtb, mapped_file.ptr + addr, header.e_shentsize);
-	//ft_printf("sX", "offset: ", shstrtb.sh_offset);
+	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;
-		ft_memcpy(&sh, mapped_file.ptr + addr, header.e_shentsize);
+		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;
-			ft_memcpy(&strtab, mapped_file.ptr + addr2, header.e_shentsize);
-			//			ft_printf("sdsds", "SYMTAB Size: ", sh.sh_size, " Entity size: ", sh.sh_entsize, "\n");
+			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') {
+				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;
-				ft_memcpy(&sym, mapped_file.ptr + sh.sh_offset + j, sh.sh_entsize);
-				//				printf("st_shndx: %d\n", sym.st_shndx);
+				sym = *(Elf64_Sym *)fetch(mapped_file, sh.sh_offset + j, sh.sh_entsize);
 				if (sym.st_shndx < header.e_shnum) {
-					ft_memcpy(&sec, mapped_file.ptr + header.e_shoff + header.e_shentsize * sym.st_shndx, header.e_shentsize);
+					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) {
-					ft_memcpy(&shdr, mapped_file.ptr + header.e_shoff + header.e_shentsize * sym.st_shndx, header.e_shentsize);
+					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);
 				} else {
 					sec_str = ft_strdup("");
@ -214,44 +215,130 @@ int nm64(t_mapped_file mapped_file) {
 				else {
 					str = sec_str;
 				}
-				//if (str[ft_strlen(str) - 1] == 'c') {
-				/*
-				*/
-				//}
-				char *sym_char = ft_strdup(get_sym_char(sym, sec));
-				if (ft_strnstr(sec_str, ".debug", 6) && ft_strequ(sym_char, "n")) {
+				// 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.st_value) {
-					ft_printf("X s ss", sym.st_value, sym_char, str, "\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] == '.')
+					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;
+				if (sym_char[0] == 'w' || sym_char[0] == 'U')
+					entry->verbosity = UNDEFINED;
+				if (entry->verbosity >= verbosity) {
+					// ici on genere la string a afficher
+					//					      pad ' ' symchar ' '       symbol name          \n  \0
+					size_t entry_string_len = 16 + 1 +   1   + 1 + ft_strlen(entry->symbol) + 1 + 1;
+					entry->string = (char *)malloc(sizeof(char) * entry_string_len);
+					if (!entry->string)
+						return FT_NM_FAILURE;
+					entry->string[entry_string_len - 1] = '\0';
+					entry->string[entry_string_len - 2] = '\n';
+					entry->string[16] = ' ';
+					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, "@@")) {
+						for (char i = 15; i >= 0; i--) {
+							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")) {
-						ft_printf("X s ss", sym.st_value, sym_char, str, "\n");
+
+							for (char i = 15; i >= 0; i--) {
+								entry->string[15 - i] = ft_get_hex_digit((sym.st_value >> i * 4) & 0xF);
+							}
 						} else {
-						//ft_printf("P s ss", sym_char, mapped_file.ptr + strtab.sh_offset + sym.st_name, "\n");
-						ft_printf("P s ss", sym_char, str, "\n");
+							for (int i = 0; i < 16; i++)
+								entry->string[i] = ' ';
 						}
 					}
+					free(sym_char);
+					// ensuite un switch ordering avec un ft_lstinsert (pointeur sur fonction serait plus opti mais osef)
+					switch (ordering) {
+						case NOSORT:
+							ft_rbt_insert(&tree, ft_rbt_new((void *)entry, sizeof(t_entry)), &nosort);
+							break;
+						case REVERSE:
+							ft_rbt_insert(&tree, ft_rbt_new((void *)entry, sizeof(t_entry)), &reverse);
+							break;
+						case DEFAULT_ORDERING:
+							ft_rbt_insert(&tree, ft_rbt_new((void *)entry, sizeof(t_entry)), &strcmp_nm);
+							break;
+					}
+					// pas de bst oops :D
 					fflush(stdout);
 				}
 			}
-		/*ft_printf("X", sh.sh_offset);
-		  ft_putchar('\n');
-		  ft_printf("X", sh.sh_name);
-		  ft_putchar('\n');*/
+		}
 		char *str = ft_strdup(mapped_file.ptr + shstrtb.sh_offset + sh.sh_name);
-		//ft_putstr(str);
-		//		ft_printf("x x x ss", sh.sh_name, sh.sh_offset, addr, str, "\n");
 		free(str);
-		//ft_putchar('\n');
+	}
+	// ici on affiche tout ou no symbols en cas de list vide
+	if (tree) {
+		ft_putrbt(tree, &put_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);
@ -273,11 +360,6 @@ void print_section(Elf64_Shdr sec) {
 	fflush(stdout);
 }

-int nm32(t_mapped_file mapped_file) {
-	(void)mapped_file;
-	return FT_NM_SUCCESS;
-}
-
 void ppp(Elf64_Sym sym, Elf64_Shdr sec) {
 	print_symbol(sym);
 	print_section(sec);
--- a/src/nm32.c
+++ b/src/nm32.c
@ -0,0 +1,272 @@
+#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");
+	//	}
+	*tool = 0;
+	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) {
+			return ("a");
+		}
+		else if (ELF32_ST_BIND(sym.st_info) == STB_GLOBAL) {
+			return ("A");
+		}
+	}
+	if (ELF32_ST_BIND(sym.st_info) == STB_GNU_UNIQUE) {
+		return ("u");
+	}
+	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) {
+			return ("t");
+		}
+		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) {
+			return ("b");
+		}
+		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) {
+			return ("d");
+		}
+		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) {
+			return ("d");
+		}
+		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) {
+			return ("d");
+		}
+		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) {
+			return ("d");
+		}
+		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) {
+			return ("d");
+		}
+		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) {
+			return ("r");
+		}
+		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) {
+			return ("r");
+		}
+		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) {
+			return ("c");
+		}
+		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) {
+			return ("u");
+		}
+		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) {
+				return ("v");
+			}
+			else {
+				return ("V");
+			}
+		} else {
+			if (sec.sh_type == SHT_NULL) {
+				return ("w");
+			}
+			else {
+				return ("W");
+			}
+		}
+	}
+	if (ELF32_ST_BIND(sym.st_info) == STB_WEAK) {
+		if (sec.sh_type == SHT_NULL) {
+			return ("w");
+		}
+		else {
+			return ("W");
+		}
+	}
+	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') {
+				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);
+				} else {
+					sec_str = ft_strdup("");
+				}
+				if (sym.st_name) {
+					str = ft_strdup(mapped_file.ptr + strtab.sh_offset + sym.st_name);
+				}
+				else {
+					str = 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] == '.')
+					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;
+				if (sym_char[0] == 'w' || sym_char[0] == 'U')
+					entry->verbosity = UNDEFINED;
+				if (entry->verbosity >= verbosity) {
+					// ici on genere la string a afficher
+					//					      pad ' ' symchar ' '       symbol name          \n  \0
+					size_t entry_string_len = 8 + 1 +   1   + 1 + ft_strlen(entry->symbol) + 1 + 1;
+					entry->string = (char *)malloc(sizeof(char) * entry_string_len);
+					if (!entry->string)
+						return FT_NM_FAILURE;
+					entry->string[entry_string_len - 1] = '\0';
+					entry->string[entry_string_len - 2] = '\n';
+					entry->string[8] = ' ';
+					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, "@@")) {
+						for (char i = 7; i >= 0; i--) {
+							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);
+							}
+						} else {
+							for (int i = 0; i < 8; i++)
+								entry->string[i] = ' ';
+						}
+					}
+					free(sym_char);
+					// ensuite un switch ordering avec un ft_lstinsert (pointeur sur fonction serait plus opti mais osef)
+					switch (ordering) {
+						case NOSORT:
+							ft_rbt_insert(&tree, ft_rbt_new((void *)entry, sizeof(t_entry)), &nosort);
+							break;
+						case REVERSE:
+							ft_rbt_insert(&tree, ft_rbt_new((void *)entry, sizeof(t_entry)), &reverse);
+							break;
+						case DEFAULT_ORDERING:
+							ft_rbt_insert(&tree, ft_rbt_new((void *)entry, sizeof(t_entry)), &strcmp_nm);
+							break;
+					}
+					// pas de bst oops :D
+					fflush(stdout);
+				}
+			}
+		}
+		char *str = ft_strdup(mapped_file.ptr + shstrtb.sh_offset + sh.sh_name);
+		free(str);
+	}
+	// ici on affiche tout ou no symbols en cas de list vide
+	if (tree) {
+		ft_putrbt(tree, &put_entry);
+	} else {
+		ft_printf("sss", "nm: ", path, ": no symbols\n");
+	}
+	return FT_NM_SUCCESS;
+}
--- a/src/old_main.c
+++ b/src/old_main.c
@ -0,0 +1,62 @@
+#include "ft_nm.h"
+
+int main(int ac, char **av) {
+	char *path = ft_strdup("a.out");
+
+	if (ac > 1) {
+		free(path);
+		path = ft_strdup(av[1]);
+	}
+
+	int fd = open(path, O_RDONLY);
+	if (fd == -1) {
+		ft_nm_error(path);
+		free(path);
+		exit (EXIT_FAILURE);
+	}
+
+	struct stat stat;
+	if (fstat(fd, &stat) == -1) {
+		ft_nm_error(path);
+		free(path);
+		exit (EXIT_FAILURE);
+	}
+
+	t_mapped_file mapped_file;
+
+//	ft_printf("sds", "file size: ", stat.st_size, "\n");
+	mapped_file.ptr = mmap(NULL, stat.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
+	mapped_file.size = stat.st_size;
+	if (mapped_file.ptr != MAP_FAILED) {
+		void *ident_ptr = fetch(mapped_file, 0, EI_NIDENT);
+		unsigned char ident[EI_NIDENT];
+		if (!ident_ptr) {
+			ft_printf("sss", "nm: ", path, ": file format not recognized\n");
+			free(path);
+			exit(EXIT_FAILURE);
+		}
+		ft_memcpy(ident, ident_ptr, EI_NIDENT);
+		if (check_ident(ident) == FT_NM_FAILURE) {
+			ft_printf("sss", "nm: ", path, ": file format not recognized\n");
+			free(path);
+			exit(EXIT_FAILURE);
+		}
+		if (ident[EI_CLASS] == ELFCLASS32) {
+			if (nm32(mapped_file) == FT_NM_FAILURE) {
+				ft_printf("sss", "nm: ", path, ": file format not recognized\n");
+				free(path);
+				exit(EXIT_FAILURE);
+			}
+		}
+		else if (ident[EI_CLASS] == ELFCLASS64) {
+			if (nm64(mapped_file) == FT_NM_FAILURE) {
+				ft_printf("sss", "nm: ", path, ": file format not recognized\n");
+				free(path);
+				exit(EXIT_FAILURE);
+			}
+		}
+	}
+	free(path);
+	return 0;
+}
+
--- a/unit_test.sh
+++ b/unit_test.sh
@ -0,0 +1,10 @@
+#!/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
Author	SHA1	Message	Date
gbrochar	bf21c93f1f	feat: 32bit	2024-10-25 12:36:52 +02:00
gbrochar	91510dc86f	debug st_info	2024-10-21 17:13:46 +02:00
gbrochar	3bbb476505	strcmp	2024-10-20 20:55:07 +02:00
gbrochar	32760601af	feat: use rb_tree to have faster results	2024-10-20 20:10:21 +02:00
gbrochar	6b31743c38	chore(libft): rb tree	2024-10-20 20:09:55 +02:00
gbrochar	d1e1384dce	chore(libft): update	2024-10-15 16:26:28 +02:00
gbrochar	0451a89dce	feat: basic flags	2024-10-14 21:56:32 +02:00
gbrochar	1a78d07f27	feat: multiple files managment	2024-10-13 19:13:00 +02:00