Step 1: Build libx2.so (the leaf library, no dependencies)

$ cd /home/mtk/pdir/d2

# Compile the source
$ gcc -g -c -fPIC -Wall modx2.c

# Link into shared library (no -rpath needed — no external deps)
$ gcc -g -shared -o libx2.so modx2.o

Step 2: Build libx1.so (depends on libx2.so in d2)

$ cd /home/mtk/pdir/d1

# Compile the source
$ gcc -g -c -Wall -fPIC modx1.c

# Link into shared library — embed rpath pointing to d2 for libx2.so
$ gcc -g -shared \
    -o libx1.so modx1.o \
    -Wl,-rpath,/home/mtk/pdir/d2 \
    -L/home/mtk/pdir/d2 \
    -lx2

# -rpath,d2  = runtime: dynamic linker looks in d2 for libx2.so
# -L,d2      = link time: linker finds libx2.so in d2 to verify symbols

Step 3: Build the main program (depends on libx1.so in d1)

$ cd /home/mtk/pdir

# Build prog — embed rpath pointing to d1 for libx1.so
$ gcc -g -Wall \
    -o prog prog.c \
    -Wl,-rpath,/home/mtk/pdir/d1 \
    -L/home/mtk/pdir/d1 \
    -lx1

# NOTE: We did NOT specify -lx2 here!
# The linker analyzes libx1.so's rpath and finds libx2.so automatically.

After building, verify the rpath entries and dependency chains:

# Check rpath in the main program
$ objdump -p prog | grep PATH
  RPATH   /home/mtk/pdir/d1    # libx1.so will be sought here at run time

# Check rpath in libx1.so
$ objdump -p d1/libx1.so | grep PATH
  RPATH   /home/mtk/pdir/d2    # libx2.so will be sought here at run time

# Check NEEDED entries in prog (what prog directly depends on)
$ objdump -p prog | grep NEEDED
  NEEDED  libx1.so             # only libx1.so — libx2.so is transitive!

# Check NEEDED entries in libx1.so
$ objdump -p d1/libx1.so | grep NEEDED
  NEEDED  libx2.so

# Use ldd to see the COMPLETE transitive dependency chain
$ ldd prog
  libx1.so  => /home/mtk/pdir/d1/libx1.so  (0x40017000)
  libc.so.6 => /lib/tls/libc.so.6          (0x40024000)
  libx2.so  => /home/mtk/pdir/d2/libx2.so  (0x4014c000)
  /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0x40000000)

# ldd shows ALL transitive dependencies resolved!

#!/bin/bash
# chained_libs.sh — builds prog → libx1.so → libx2.so chain

set -e
BASE=/tmp/chained_demo
D1=$BASE/d1
D2=$BASE/d2

mkdir -p $D1 $D2 $BASE

# ---- Source: modx2.c (leaf library) ----
cat > $D2/modx2.c << 'EOF'
#include <stdio.h>

void x2(void) {
    printf("[libx2] x2() called — leaf function\n");
}
EOF

# ---- Source: modx1.c (middle library, calls x2) ----
cat > $D1/modx1.c << 'EOF'
#include <stdio.h>

extern void x2(void);  // from libx2.so

void x1(void) {
    printf("[libx1] x1() called, now calling x2...\n");
    x2();
}
EOF

# ---- Source: prog.c (main program, calls x1 only) ----
cat > $BASE/prog.c << 'EOF'
#include <stdio.h>

extern void x1(void);  // from libx1.so

int main(void) {
    printf("[prog] Starting...\n");
    x1();
    printf("[prog] Done.\n");
    return 0;
}
EOF

echo "=== Step 1: Build libx2.so in $D2 ==="
cd $D2
gcc -g -c -fPIC -Wall modx2.c
gcc -g -shared -o libx2.so modx2.o
ls -la libx2.so

echo ""
echo "=== Step 2: Build libx1.so in $D1 (depends on libx2.so) ==="
cd $D1
gcc -g -c -fPIC -Wall modx1.c
gcc -g -shared \
    -o libx1.so modx1.o \
    -Wl,-rpath,$D2 \
    -L$D2 -lx2

echo "rpath in libx1.so:"
objdump -p $D1/libx1.so | grep -E 'RPATH|NEEDED'

echo ""
echo "=== Step 3: Build prog (depends on libx1.so only) ==="
cd $BASE
gcc -g -Wall \
    -o prog prog.c \
    -Wl,-rpath,$D1 \
    -L$D1 -lx1

echo ""
echo "rpath in prog:"
objdump -p $BASE/prog | grep -E 'RPATH|NEEDED'

echo ""
echo "=== ldd — complete transitive dependencies ==="
ldd $BASE/prog

echo ""
echo "=== Running prog ==="
$BASE/prog

#!/bin/bash
# broken_chain.sh — shows failure when rpath is missing from libx1.so

BASE=/tmp/broken_chain_demo
D1=$BASE/d1
D2=$BASE/d2
mkdir -p $D1 $D2 $BASE

# (same source files as before)
# ... setup source files ...

echo "=== Build libx2.so (same as before) ==="
cd $D2
gcc -g -c -fPIC -Wall modx2.c
gcc -g -shared -o libx2.so modx2.o

echo ""
echo "=== Build libx1.so WITHOUT embedding rpath for libx2 ==="
cd $D1
gcc -g -c -fPIC -Wall modx1.c
# Note: NO -Wl,-rpath here! Only -L for link time.
gcc -g -shared \
    -o libx1.so modx1.o \
    -L$D2 -lx2
# This builds successfully, because -L finds libx2.so at link time.

echo ""
echo "=== Build prog ==="
cd $BASE
gcc -g -Wall \
    -o prog prog.c \
    -Wl,-rpath,$D1 \
    -L$D1 -lx1

echo ""
echo "=== ldd — libx2.so cannot be found! ==="
ldd $BASE/prog
# You will see:  libx2.so => not found

echo ""
echo "=== Running prog — should fail ==="
$BASE/prog 2>&1 || echo ""
echo "ERROR: libx2.so not found because libx1.so has no rpath for d2!"
echo ""
echo "=== Fix: set LD_LIBRARY_PATH as workaround ==="
LD_LIBRARY_PATH=$D2 $BASE/prog && echo "Worked with LD_LIBRARY_PATH"

/* modx2.c — libx2.so: leaf library (no dependencies) */
#include <stdio.h>
#include <string.h>

/* Returns the length of a string — our "low level" utility */
int string_length(const char *s) {
    return (int)strlen(s);
}

void x2_print_info(void) {
    printf("[libx2] version 1.0, directory: d2\n");
}

/* modx1.c — libx1.so: middle library (depends on libx2.so) */
#include <stdio.h>

/* Declarations from libx2.so */
extern int string_length(const char *s);
extern void x2_print_info(void);

/* x1 is the function exposed to the main program */
void x1_process(const char *msg) {
    printf("[libx1] Processing message: %s\n", msg);
    printf("[libx1] Message length (via libx2): %d\n", string_length(msg));
    x2_print_info();
}

/* prog.c — main program (depends on libx1.so only) */
#include <stdio.h>

/* Declaration from libx1.so */
extern void x1_process(const char *msg);

int main(void) {
    printf("[prog] Program started\n");
    x1_process("Hello from EmbeddedPathashala!");
    x1_process("Linux Shared Libraries");
    printf("[prog] Program finished\n");
    return 0;
}
/*
 * Build chain:
 *   gcc -g -c -fPIC modx2.c
 *   gcc -g -shared -o d2/libx2.so modx2.o
 *
 *   gcc -g -c -fPIC modx1.c
 *   gcc -g -shared -o d1/libx1.so modx1.o \
 *       -Wl,-rpath,$(pwd)/d2 -L$(pwd)/d2 -lx2
 *
 *   gcc -g -o prog prog.c \
 *       -Wl,-rpath,$(pwd)/d1 -L$(pwd)/d1 -lx1
 */