Symbolic name einer DL

tüdelü.. =D ja das is ganz easy, pass auf du machst folgendes...:

Du legst dir eine Initialisierungsfunktion innerhalb dieserm *.so an (wir nennen sie math_Init())

da tust dann alle namen die du kennen lernen willst über eine funktion aus deinem core rein. (sowas wie z.B: addFunction();)
Damit kannst du die speicherstelle dieser funktionen an dein hauptprogramm übergeben in welchem du nun das ganze als pointer in einer doppelt verketteten liste speicherst (da nimmst dir nen index, woran du das teil erkennst, also sozusagen n synonym)

Ich versuche das mal so (C code zur veranschaulichung):

typedef struct functions_ {
char Author[20]; //Author
char Version[10]; //Version
char fname[35]; //Function name
void *dl_handle; //Dynamic Library Handle for our library (libmath.so)
int (*func) (...);
/* kA was du da halt auch immer hast (in dem fall müssten die funktionen halt alle den selben aufruf-parameter haben, aber diese variante is nur ein vorschlag meinerseits */
struct functions_ *next, *prev;
}Functions;

------------------------------------------------------------------------

und eben in deiner .so machst:

int math_equal(...);
int math_multiply(...);

void math_Init(void *dl_handle){ //das was du mit dlopen bekommst
addFunction(dl_handle,"Fritz","0.01","vergleichen",math_equal);
addFunction(dl_handle,"Fritz","0.01","multiplizieren",math_multiply);
....
.......
}

------------------------------------------------------------------------

Somit rufst dann die datei libmath.so mit dlopen(); auf und machst dann dlsym() auf das symbol das DU kennst (so kannst auch bequem im nachhinein sachen hinzufügen) "math_Init" und führst das dann einfach aus...

Damit Initialisiert sich deine *.so dann von selber und du hast danach alle Funktionen in der verketteten liste =D (Da kannst dann auch alle ausgeben, ganz bequem) ... und weiters kann es nicht passieren, dass eine Funktion ausgeführt wird - die es in der *.so nicht mal gibt -> !crash!

... Ich hoffe du hast verstanden was ich dir sagen wollte .. war natürlich kein wirklich richtiger vollständiger Code (also nicht komplett richtig ^^) aber ich würde in diese Richtung gehen =)

Ich hoffe es hilft ... Lg Manuel =)
(vergiss halt nicht das du falls du mehrere .so files hast die handle von jedem speicherst, falls du diese während der laufzeit entladen willst - dlclose();, wennde die handles dann ned im memory hast bist halt am arsch =D)

Jo wie der Title schon sagt... tjo pech sowas ist soweit ich weiß nicht möglich/vorgesehen - kA wie das funktionieren sollte, da in so einer datei funktionen UND variablen eingetragen sind d.h. du könntest nie sagen obs ne variable oder ne funktion is - es sei denn du hast nen speicher worüber du das bestimmen kannst (die liste eben) damit kennst alle symbole UND weißt welche funktionen sind und welche vars sind.

Eine ich aktualisier alles automatisch shice gibts nicht .. es sei denn du sprichstz die funktionen gezielt an (dann kennst aber den namen - da kannst dann gleich jedesmal dlsym machen) - kannst so auch musst aber dann nimmer =P.

Eine *.dll / *.so solltest du immer beschreiben ... mit einer init ... alles andere is sowieso mist (meine meinung)
Ich verwende zb mehrere module wobei ein modul eine datei ist die mehrere funktionen hat ... was bei mir so aussieht:

------------------------------------------------------------------------

#define SERVICE "bs"
#define MODUL "act"
#define MODUL_FILE "bs_act.so"
#define MODUL_VERSION "1.0"
int bs_act(Threads *thread,void* language,int howtosend,char *snick,char *nick,char *param[]);
int bs_act_help(Threads *thread,void* language,int howtosend,char *snick,char *nick,char *param[]);
int bs_act_help_listing(Threads *thread,void* language,int howtosend,char *snick,char *nick,char *param[]);
int orion_Fini(Threads *thread);
/* ************************************************************************************************ */
/**
* @brief Initialize the module in the orion DB
*
* This function loads the module with all its functions into memory, so that it can be used by
* the services. At the same time, important options like access permissions, etc. are loaded.
*
* @param thread The thread-struct (passed from active thread)- holds the threads information
* @param dl_handle The file handle for the .so file
* @return void
*/
MOD_BOOL orion_Init(Threads *thread, void *dl_handle){
ModCo *modul=modul_init(thread,dl_handle,SERVICE,MODUL_FILE,MODUL,"act","act");
addAuthor (thread,modul,"shock (C)%s %s",PROJECTNAME,YEAR);
addVersion(thread,modul,"%s version %s, ModulVersion: %s v%s",PROJECTNAME,VERSION_NUMBER,MODUL,MODUL_VERSION);
addOptions(thread,modul,2,LOGINONLY,OPER_IF_DEFCON);
addAccess (thread,modul,BOTH);
addMODType(thread,modul,CORE);
addCommand(thread,modul,"act",bs_act,is_services_oper,is_services_user,5,5);
addCommand(thread,modul,"help act",bs_act_help,is_services_oper,is_services_user,4,4);
addCommand(thread,modul,"help",bs_act_help_listing,is_services_oper,is_services_user,3,3);
addFinish(thread,modul,orion_Fini);
return MOD_SUCCESS;
}

Das ist meine Init für die datei bs_act.so (so würde ich das eben lösen, in der art halt und wie gsagt so ne ich kenn die datei ohne sie zu analysieren dings is nicht ... der compiler müsste es ja auch analysieren, da gibts auch kein HEY .. da bin ich..) =P

Lg Manuel (viel erfolg)