¿Por qué y cómo se pueden ejecutar algunas bibliotecas compartidas, como si fueran ejecutables?

Esa biblioteca tiene un main() función o punto de entrada equivalente, y se compiló de tal manera que es útil como ejecutable y como objeto compartido.

Aquí hay una sugerencia sobre cómo hacer esto, aunque no funciona para mí.

Aquí hay otra respuesta a una pregunta similar sobre S.O, que descaradamente plagiaré, modificaré y agregaré un poco de explicación.

Primero, la fuente de nuestra biblioteca de ejemplo, test.c :

#include <stdio.h>                  

void sayHello (char *tag) {         
    printf("%s: Hello!\n", tag);    
}                                   

int main (int argc, char *argv[]) { 
    sayHello(argv[0]);              
    return 0;                       
}                   

Compile eso:

gcc -fPIC -pie -o libtest.so test.c -Wl,-E

Aquí, estamos compilando una biblioteca compartida (-fPIC ), pero diciéndole al enlazador que es un ejecutable normal (-pie ) y hacer exportable su tabla de símbolos (-Wl,-E ), de modo que se pueda vincular de forma útil.

Y, aunque file dirá que es un objeto compartido, funciona como un ejecutable:

> ./libtest.so 
./libtest.so: Hello!

Ahora tenemos que ver si realmente se puede vincular dinámicamente. Un programa de ejemplo, program.c :

#include <stdio.h>

extern void sayHello (char*);

int main (int argc, char *argv[]) {
    puts("Test program.");
    sayHello(argv[0]);
    return 0;
}

Usando extern nos ahorra tener que crear un encabezado. Ahora compila eso:

gcc program.c -L. -ltest

Antes de que podamos ejecutarlo, necesitamos agregar la ruta de libtest.so para el cargador dinámico:

export LD_LIBRARY_PATH=./

Ahora:

> ./a.out
Test program.
./a.out: Hello!

Y ldd a.out mostrará el enlace a libtest.so .

Tenga en cuenta que dudo que así sea como se compila realmente glibc, ya que probablemente no sea tan portátil como glibc en sí (ver man gcc con respecto al -fPIC y -pie interruptores), pero demuestra el mecanismo básico. Para conocer los detalles reales, tendría que consultar el archivo MAKE de origen.

Busquemos una respuesta en un repositorio glibc aleatorio en GitHub. Esta versión proporciona un "banner" en el archivo version.c .

En el mismo archivo hay algunos puntos interesantes:el __libc_print_version función que imprime el texto en stdout y el __libc_main (void) símbolo que está documentado como el punto de entrada. Entonces, este símbolo se llama cuando se ejecuta la biblioteca.

Entonces, ¿cómo sabe exactamente el enlazador o el compilador que esta es la función de punto de entrada?

Sumerjámonos en el archivo MAKE. En las banderas del enlazador hay una interesante:

# Give libc.so an entry point and make it directly runnable itself.
LDFLAGS-c.so += -e __libc_main

Este es el indicador del enlazador para establecer el punto de entrada a la biblioteca. Al crear una biblioteca, puede proporcionar el -e function_name marca para que el enlazador habilite un comportamiento ejecutable. ¿Qué hace realmente? Miremos el manual (algo desactualizado pero aún válido):

the `-e' entry command-line option;
the ENTRY(symbol) command in a linker control script;
the value of the symbol start, if present;
the address of the first byte of the .text section, if present;
The address 0.