What is an SO file?

The .so file, short for Shared Object, is a format used on Unix-based systems, like Linux, for shared libraries. Shared libraries are collections of routines and functions compiled into a single file, allowing different programs to access and execute the code within them without having to recompile or duplicate the code for each program. Think of it as a modular code component that any compatible program can tap into when it needs specific functionalities.

Purpose of .so Files

The .so files serve a similar purpose to .dll (Dynamic Link Library) files on Windows. They help reduce redundancy by storing shared code separately from executables, leading to several benefits:

  • Memory Efficiency: Since multiple programs can share a single instance of an .so file in memory, this conserves resources, particularly RAM.
  • Modularity: They allow for modular program structures where components can be updated or modified independently of the main program.
  • Easier Maintenance: Updating a shared library automatically benefits all programs that depend on it, reducing the need for individual updates.

How to create SO file?

To create a .so file, you typically compile source code in C or C++ with special compiler flags. Here’s how to do it:

  1. Write the Source Code: Start by writing the functions or routines that you intend to share across multiple applications. This could be a collection of math functions, data processing utilities, or other reusable modules.

  2. Compile with Shared Library Flags: When compiling, you’ll need to include the -fPIC (Position Independent Code) flag, which allows the code to be dynamically loaded at runtime, and the -shared flag to produce a shared object.

    Here’s an example using gcc:

gcc -fPIC -shared -o libexample.so example.c
  • -fPIC creates position-independent code, essential for shared libraries.
  • -shared tells the compiler to output a shared library rather than an executable.
  1. Naming Convention: It’s standard to prefix shared libraries with lib (e.g., libexample.so). This helps the system locate the library when linking it to applications.

How to use SO files in Programs?

Once you have a .so file, it’s ready to be linked with other programs. Here’s how to use it:

  1. Compile with Linker Option: To link your program with the shared library, use the -l option followed by the library’s name without the lib prefix and .so suffix.
gcc main.c -L/path/to/library -lexample -o main
  • -L specifies the directory where the compiler can find libexample.so.
  • -lexample links the program with libexample.so.
  1. Run the Program: For the program to find the .so file at runtime, the library path should be added to the system’s library path (LD_LIBRARY_PATH):
export LD_LIBRARY_PATH=/path/to/library:$LD_LIBRARY_PATH
./main

Loading .so Files Dynamically

Sometimes, programs need to load shared libraries at runtime rather than linking them during compilation. This is common in plugins or modules. To achieve this, Unix-based systems use functions such as dlopen, dlsym, and dlclose:

  • dlopen: Loads the library dynamically.
  • dlsym: Retrieves the address of a function or variable within the library.
  • dlclose: Closes the library when it’s no longer needed.

Here’s a simple example:

#include <dlfcn.h>
#include <stdio.h>

int main() {
    void *handle = dlopen("./libexample.so", RTLD_LAZY);
    if (!handle) {
        fprintf(stderr, "%s\n", dlerror());
        return 1;
    }

    void (*function_name)() = dlsym(handle, "function_name");
    (*function_name)();

    dlclose(handle);
    return 0;
}

How to open SO file?

Opening a .so file directly isn’t the same as executing or running a regular application file because .so files are libraries designed to be accessed by programs rather than run by themselves.

To open or inspect a .so (shared library) file, here are some quick methods:

  1. View Symbols: Use nm -D /path/to/library.so or objdump -T /path/to/library.so to list functions and variables within the library.

  2. Check Dependencies: Run ldd /path/to/library.so to see which other libraries this .so file relies on.

  3. Load in a Program: Use dlopen in a C/C++ program to load the library at runtime and access its functions dynamically.

  4. Inspect with Hex Editor: Open with a hex editor (e.g., hexedit) to see the raw binary data.

  5. Detailed Structure: Use readelf -h /path/to/library.so for an in-depth look at the ELF file structure.