Pointer to function seg faulting - c

Question

I'm building a user defined shell. I have an array of pointers to functions -- that is, an array full of shared library functions that can be invoked at any point.
I typedef here
typedef void (*func_ptr)(char **);
func_ptr function;
void *pointers_to_functions[64];
I have debugged and confirmed that my initializations of placing the pointers into the array is working properly, but here's the code for safe measures...
void initialize_built_in(){
void *handle;
char *error;
int i;
for (i = 0; i < 5; i++){
handle = dlopen(builtin_files[i], RTLD_LOCAL | RTLD_LAZY);
if (!handle) {
fprintf(stderr, "%s\n", dlerror());
exit(1);
}
pointers_to_functions[i] = dlsym(handle, builtin_functions[i]);
if ((error = dlerror()) != NULL) {
fprintf(stderr, "%c\n", *error);
exit(1);
}
if (dlclose(handle) < 0) {
fprintf(stderr, "%c\n", *dlerror());
exit(1);
}
}
}
Here's where the seg fault occurs -- when I invoke the function
int execute_built_in(char **argv){
int i;
//scan through the builtin_functions strings to find the correct index of pointers_to_functions - that is, they have the same ordering
for (i = 0; i < sizeof(builtin_functions); i++){
if (!strcmp(argv[0], builtin_functions[i])){
//the index has been found
function = pointers_to_functions[i];
function(argv); //execute function
return 0;
}
}
return -1;
}
My shared library does indeed take argv as a parameter -- so I don't believe this is the problem.
As I said, debugging I see that the array of pointers is filled with addresses. I suppose it could be an incorrect address somehow, but I'm at a brick wall here.
Any ideas?
So I tested the pointer to function call be defining my own function type (void *) in the same file.
func_ptr function;
void *testfunction(char **);
void *pointers_to_functions[64] = {testfunction};
where the function just prints something out to the shell
then I added a condition in the execute_function function to force execution...
for (i = 0; i < sizeof(builtin_functions); i++){
if (i == 0){
function = pointers_to_functions[1];
char *bleh[] = {"bleh"};
function(bleh);
}
if (!strcmp(argv[0], builtin_functions[i])){
//the index has been found
function = pointers_to_functions[i];
function(argv); //execute function
return 0;
}
}
and it works WOOHOO!
So I either have a problem with my dynamic linking, which I can't see. Or with my shared library -- which is unlikely because I've already built successful libraries that work with another shell code of the same project.
So, what's wrong with my dynamic linking?
Here's an example shared library
#include <stdio.h>
#include <unistd.h>
struct NewBuiltIn{
char *CommandName[64];
char *FunctionName[64];
char *AnalyzerName[64];
};
struct NewBuiltIn pluggin_method = {{"cd", "cd", ""}};
void cd(char *argv[]) {
if(chdir(argv[1]) < 0){
printf("There was an error in changing your directory. Please check the path name and retry.\n");
}
}

Answer 1

Your init function is wrong:
you perform a dlclose(handle) which causes all the lib you loaded to be unmapped from memory, and obviously, the functions you expect to call are flying away.
You must keep the lib mapped to memory until you completely finished using the function pointers you stored.
You can probably check this by observing that the address that segfaults actually lies in the library mapped segment (in /proc/your_app_pid/maps)