dlopen: detect undefined symbols with cyclic dependencies - c

Question

I have a handful of shared libraries with cyclic dependencies, which I want to load with dlopen. To do this, I call dlopen with the RTLD_LAZY | RTLD_GLOBAL flags.
This works fine.
Now, I want to check that all symbols in all shared libraries are fully resolved, and I therefore call dlopen again with RTLD_NOW, this should fail if all symbols can not be resolved.
At least, this is how I understand the man page:
However, a subsequent dlopen() call that loads the same shared object with
RTLD_NOW may force symbol resolution for a shared object earlier loaded with
RTLD_LAZY.
Here is a simple example which illustrates my problem:
main.h
#include <stdio.h>
#include <dlfcn.h>
#include <stdlib.h>
#include "h.h"
#define CNT 3
static const char *libs[CNT] = {"./liba.so", "./libb.so", "./libc.so"};
typedef int (*f_ptr)();
int main() {
void *h[CNT];
f_ptr f[CNT];
for (int i = 0; i < CNT; i++) {
printf("dlopen: %s\n", libs[i]);
h[i] = dlopen(libs[i], RTLD_LAZY | RTLD_GLOBAL);
if (!h[i]) {
fprintf(stderr, "%d %s: %s\n", __LINE__, libs[i], dlerror());
exit(EXIT_FAILURE);
}
}
for (int i = 0; i < CNT; i++) {
printf("dlopen again: %s\n", libs[i]);
void *xx = dlopen(libs[i], RTLD_NOW | RTLD_GLOBAL);
if (!xx) {
fprintf(stderr, "%d %s: %s\n", __LINE__, libs[i], dlerror());
dlclose(h[i]);
h[i] = 0;
} else {
dlclose(xx);
}
}
for (int i = 0; i < CNT; i++) {
if (h[i]) {
f[i] = (int (*)())dlsym(h[i], "init");
if (!f[i]) {
fprintf(stderr, "%d %s: %s\n", __LINE__, libs[i], dlerror());
exit(EXIT_FAILURE);
}
}
}
for (int i = 0; i < CNT; i++) {
if (f[i]) {
printf("%s %08d\n", libs[i], f[i]());
}
}
return 0;
}
a.c
#include "h.h"
int init() { return 1 + b_(); }
int a_() { return 10; }
b.c
#include "h.h"
int init() { return 100 + a_(); }
int b_() { return 1000; }
c.c
#include "h.h"
int init() { return 10000 + x_(); }
int c_() { return 100000; }
h.h
int init();
int a_();
int b_();
int x_();
CMakeLists.txt
project(xx)
add_library(a SHARED a.c)
add_library(b SHARED b.c)
add_library(c SHARED c.c)
add_executable(main main.c)
target_link_libraries(main dl)
Compile and run:
$ mkdir b && cd b && cmake .. && make && ./main
...
[100%] Built target b
dlopen: ./liba.so
dlopen: ./libb.so
dlopen: ./libc.so
dlopen again: ./liba.so
dlopen again: ./libb.so
dlopen again: ./libc.so
./liba.so 00001001
./libb.so 00000110
./main: symbol lookup error: ./libc.so: undefined symbol: x_
How can I detect that libc.so could not be fully loaded - before calling a
symbol that cause it to crash?

Answer 1

Ideally you'd want to put the burden of symbol cross-matching on static linker as suggested by others (via --no-allow-shlib-undefined) rather than delaying it to startup. Now it's a bit complicated for cyclic dependencies but Solaris (of which Linux shlibs are a bleak copy) has come with a clever solution - shlib filters. The idea is that you link against dummy shlibs which export equally dummy symbols and have the same sonames as final production libraries. These are of course only used at link time to verify dependencies.
As a side note, I'm pretty sure that generation of dummy libs can be automated, something like the following:
build lib without --no-allow-shlib-undefined
use readelf or whatever to extract exported symbols
generate a dummy C (or asm) file which defines empty stubs for symbols from previous item
build lib and voila - you've built your first filter
Hm, this sounds like a nice mini-project for this evening.