Shared object explicitly calling internal function in itself - c

Question

I have been recoding some libC functions which I incorporated in my Shared Object Library. Some of these functions internally call themselves.
The problem now is when I use dlsym from another program, the function provided by dlsym (which internal use requires an internal function) will call libC's functions instead of those already present which I recoded in my library.
Here is a simple example:
lib.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void *memset(void *s, int c, size_t n)
{
printf("Calling LIB's Memset\n");
for (size_t i = 0; i < n; ++i)
((char *) s)[i] = c;
return s;
}
void *calloc(size_t mnemb, size_t size)
{
size_t sz = mnemb * size;
void *addr = malloc(sz);
printf("Calling LIB's Calloc\n");
memset(addr, 0, sz);
return addr;
}
gcc lib.c -fPIC -shared -o lib.so
main.c
#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>
int main(void)
{
void *handler = dlopen("./lib.so", RTLD_NOW);
void (*_calloc)(size_t, size_t);
if (!handler)
{
printf("Could not open lib\n");
return 1;
}
_calloc = dlsym(handler, "calloc");
if (!_calloc)
{
printf("Could not extract symbol\n");
return 1;
}
_calloc(10, 10);
return 0;
}
gcc main.c -ldl
$ ./a.out
Calling LIB's Calloc
As you can see, only the calloc function coming from the lib is called, the internal memset is not called.
How can I tell in my library to explicitly call its own functions ?
Note: My function have to be called the same way as libC's as it got to work with LD_PRELOAD too.

Answer 1

How can I tell in my library to explicitly call its own functions ?
The best way would probably be to give your own functions distinct names. For example, prefix their names with a consistent prefix: my_strlen, my_printf, etc.. Then use only those names when the library intends to make calls to other functions within. Stupid example:
size_t my_strlen(const char *s) {
return *s ? (1 + my_strlen(s + 1)) : 0;
}
To cause those to be called in place of their namesakes by external callers, interpose wrapper functions. For example:
size_t strlen(const char *s) {
return my_strlen(s);
}
But, again, do not rely on the wrappers inside the library. You could even split the wrappers into a separate library, if you wish.
The idea here is to minimize your exposure to linker games and dynamic linking effects. You cannot completely avoid those when the point is to substitute your own implementations of standard library functions, but in this way you can reduce the scope for them to cause you trouble.