#!/bin/sh

 # This script will populate the root directory with libs from the sysroot.

 # (C) 2007 Yann E. MORIN

 # Licensed under the GPL v2

 set -e

 # Use the tools discovered by crosstool-NG's ./configure:

 install="@@CT_install@@"

 grep="@@CT_grep@@"

 sed="@@CT_sed@@"

 # Detect where the toolchain is:

 CT_PREFIX_DIR="$(cd "$(dirname "$0")/.."; pwd)"

 CT_GCC="${0%-populate}-gcc"

 CT_READELF="${0%-populate}-readelf"

 CT_CFG_PREFIX_DIR="$("${CT_GCC}" -v 2>&1            \

                      |tr ' ' '\n'                   \

                      |"${grep}" -E -- '--prefix='   \

                      |cut -d = -f 2-

                     )"

 CT_CFG_SYSROOT_DIR="$("${CT_GCC}" -v 2>&1                   \

                       |tr ' ' '\n'                          \

                       |"${grep}" -E -- '--with-sysroot='    \

                       |cut -d = -f 2-

                      )"

 CT_SYSROOT_DIR="$(printf "${CT_CFG_SYSROOT_DIR}\n"                              \

                   |"${sed}" -r -e "s:^${CT_CFG_PREFIX_DIR}:${CT_PREFIX_DIR}:;"  \

                   |"${sed}" -r -e 's,/+,/,g;'                                   \

                  )"

 myname=$(basename "$0")

 doHelp() {

     cat <<_EOF_

 NAME

     $myname - populate the target root file system

 SYNOPSIS

     $myname OPTIONS -s source_root -d destination_root

 DESCRIPTION

     This script will 'populate' your target root file system 'source_root'

     with libraries from the toolchain (eg. libc.so...), storing the result

     into 'dst_dir'.

 OPTIONS

     -s src_dir

         Use 'src_dir' as the un-populated (source) root directory.

     -d dst_dir

         Use 'dst_dir' as the place to put the populated root directory.

         See the -f and -m options, below, on the required (non-)existence

         of this directory.

     -r sysroot_dir

         Use 'sysroot_dir' as the sysroot instead of the toolchain default.

     -l name1[:name2[...]]

         Always add the specified shared library/ies name1, name2... from the

         toolchain (in the sysroot). Actual library names are searched as

         follows (where 'name' is replaced with the given name) in the

         sysroot directory:

           - libname.so

           - name.so

           - name

         If the file is found, then the SONAME of the library is used, and the

         library is copied with that name. If the library was not found, this

         yields an error (unless -f was given).

     -L file

         Read 'file' for a list of shared libraries to always add from the

         toolchain. The file should contain one library name per line; text

         after a # is ignored until the end of the line; spaces are ignored;

         empty lines are ignored. Libraries are searched for as with -l.

     -f  Force execution: if destination directory already exists, it will be

         removed first; if a specified library (above) was not found, continue.

         Note: if using -m and the destination directory already exists, it

         is *not* removed, see below.

     -m  Merge the source root directory with the destination root directory.

         If the latter does not exist, it is created, and -m is ignored.

         If the destination root directory exists, then the content of the

         source root directory is copied in there, and the result is populated

         as usual.

         It can be useful if constructing a rootfs incrementally from many

         smaller source root directories, or if your destination root directory

         is an NFS export that your target mounts as / (and you don't want to

         re-run exportfs -av everytime). USE WITH CARE!

     -v  Be verbose. By default, populate is absolutely silent.

 _EOF_

 }

 CT_ROOT_SRC_DIR=

 CT_ROOT_DST_DIR=

 CT_LIB_LIST=

 CT_LIB_FILE=

 CT_MERGE=

 CT_FORCE=

 CT_PRINTF=:

 OPTIND=1

 while getopts ":s:d:r:l:L:fmvh" CT_OPT; do

     case "${CT_OPT}" in

         s)  CT_ROOT_SRC_DIR="${OPTARG}";;

         d)  CT_ROOT_DST_DIR="${OPTARG}";;

         r)  CT_SYSROOT_DIR="${OPTARG}";;

         l)  CT_LIB_LIST="${CT_LIB_LIST}:${OPTARG}";;

         L)  CT_LIB_FILE="${OPTARG}";;

         f)  CT_FORCE=y;;

         m)  CT_MERGE=y;;

         v)  CT_PRINTF=printf;;

         h)  doHelp

             exit 0

             ;;

         :)  printf "$myname: '-${OPTARG}' takes exactly one argument.\n"

             exit 1

             ;;

         ?)  printf "$myname: unknown option '-${OPTARG}'.\n"

             exit 1

             ;;

     esac

 done

 # Sanity checks

 if [ -z "${CT_ROOT_SRC_DIR}" -o -z "${CT_ROOT_DST_DIR}" ]; then

     doHelp

     exit 1

 fi

 if [ ! -d "${CT_ROOT_SRC_DIR}" ]; then

     printf "$myname: '${CT_ROOT_SRC_DIR}': no such file or directory\n"

     exit 1

 fi

 if [ ! -d "${CT_SYSROOT_DIR}" ]; then

     printf "$myname: '${CT_SYSROOT_DIR}': no such file or directory\n"

     exit 1

 fi

 # If the dest dir does not exist, all is well

 # If merging, we accept an existing dest directory

 # If forcing and not merging, we remove an exiting dest directory

 # If not forcing and not merging, we do not accept an exiting dest directory

 if [ -d "${CT_ROOT_DST_DIR}" ]; then

     case "${CT_FORCE}:${CT_MERGE}" in

         *:y)    ;;

         y:)     rm -rf "${CT_ROOT_DST_DIR}";;

         :)      printf "$myname: '${CT_ROOT_DST_DIR}': already exists\n"

                 exit 1

                 ;;

     esac

 fi

 src_inode=$(ls -1id "${CT_ROOT_SRC_DIR}/." |awk '{ print $1 }')

 dst_inode=$(ls -1id "${CT_ROOT_DST_DIR}/." 2>/dev/null |awk '{ print $1 }')

 if [ "${src_inode}" -eq "$((dst_inode+0))" ]; then

     printf "$myname: source and destination are the same!\n"

     exit 1

 fi

 # Check existence of the forced libraries file

 if [ -n "${CT_LIB_FILE}" -a ! \( -f "${CT_LIB_FILE}" -a -r "${CT_LIB_FILE}" \) ]; then

     printf "$myname: forced libraries file '${CT_LIB_FILE}' not found!\n"

     exit 1

 fi

 # Create the working copy, no issue if already existing

 mkdir -p "${CT_ROOT_DST_DIR}"

 # Make all path absolute

 CT_ROOT_SRC_DIR=$(cd "${CT_ROOT_SRC_DIR}"; pwd)

 CT_ROOT_DST_DIR=$(cd "${CT_ROOT_DST_DIR}"; pwd)

 CT_SYSROOT_DIR=$(cd "${CT_SYSROOT_DIR}"; pwd)

 # Populate the destination directory with files from the source directory

 cd "${CT_ROOT_SRC_DIR}"

 cp -a . "${CT_ROOT_DST_DIR}"

 cd - >/dev/null

 # A function do search for a library

 # Usage: do_add_lib libname

 # returns: 0 if library was found and added, !0 otherwise

 do_add_lib() {

     local libname="$1"

     local true_libname

     local dir

     local mode

     for dir in lib usr/lib; do

         if [ -e "${dir}/${libname}" ]; then

             ${CT_PRINTF} "    already present\n"

             return 0

         fi

     done

     for dir in lib usr/lib; do

         ${CT_PRINTF} "    trying in '%s'" "${dir}"

         libfile="${CT_SYSROOT_DIR}/${dir}/${libname}"

         ${CT_PRINTF} ": '%s'\n" "${libfile}"

         if [ -e "${libfile}" ]; then

             mkdir -p "${dir}"

             true_libname=$("${CT_READELF}" -d "${libfile}"          \

                            |"${grep}" "Library soname:"             \

                            |"${sed}" -r -e 's,.+\[(.+)\] *$,\1,;'   \

                           )

             case "${libfile}" in

                 */ld*)  mode=0755;;

                 *)      mode=0644;;

             esac

             ${CT_PRINTF} "      installing as '%s/%s', mode='%s'\n" "${dir}" "${true_libname}" "${mode}"

             ${install} -m "${mode}" "${libfile}" "${dir}/${true_libname}"

             do_resolve_deps "${dir}/${true_libname}"

             return 0

         fi

     done

     return 1

 }

 # A function to resolve all NEEDED entries for the given file, relative

 # to the working directory (eg. dst_dir)

 # Usage: do_resolve_deps some/where/some/file

 # Returns: 0, meaning all dependencies were found

 # If not all dependencies could be found, exists with error code 1

 # (unless forced)

 do_resolve_deps() {

     local file="${1}"

     local libname

     for libname in $("${CT_READELF}" -d "${file}"                           \

                      |"${grep}" -E '\(NEEDED\)[[:space:]]+Shared library:'  \

                      |"${sed}" -r -e 's,.+\[(.+)\] *$,\1,;'                 \

                     ); do

         [ -n "${libname}" ] || continue

         ${CT_PRINTF} "Searching for '%s' needed by '%s'\n" "${libname}" "${file}"

         if ! do_add_lib "${libname}"; then

             printf "$myname: library '${libname}' not found!\n"

             [ "${CT_FORCE}" = "y" ] || exit 1

         fi

     done

 }

 # We'll work in the copied rootfs

 cd "${CT_ROOT_DST_DIR}"

 # First of, copy the forced libraries into the working copy

 lib_list=

 if [ -n "${CT_LIB_FILE}" ]; then

     lib_list=$("${sed}" -r -e ':loop; s/#.*//;'         \

                            -e 's/[[:space:]]+//g;'      \

                            -e 's/([^:])$/\1:/;'         \

                            -e '/$/N; s/\n//; tloop;'    \

                         "${CT_LIB_FILE}"

               )

 fi

 CT_LIB_LIST=$(printf "${CT_LIB_LIST}:${lib_list}\n"         \

               |"${sed}" -r -e 's/^:+//; s/:+$//; s/:+/ /g;' \

              )

 if [ -n "${CT_LIB_LIST}" ]; then

     for name in ${CT_LIB_LIST}; do

         [ -z "${name}" ] && continue

         found=0

         for libname in "lib${name}.so" "${name}.so" "${name}"; do

             ${CT_PRINTF} "Searching for forced library '%s'\n" "${libname}"

             if do_add_lib "${libname}"; then

                 found=1

                 break

             fi

         done

         if [ ${found} -eq 0 ]; then

             printf "$myname: library '${libname}' not found!\n"

             [ "${CT_FORCE}" = "y" ] || exit 1

         fi

     done

 fi

 # Create a temporary place where to store... temp files.

 rand="$( dd if=/dev/urandom bs=1024 count=1 2>/dev/null \

          |md5sum                                        \

          |awk '{ print $1; }'

        )"

 CT_TMP_DIR="${TMPDIR:-/tmp}/populate-${rand}-${$}"

 ( umask 0077; mkdir "${CT_TMP_DIR}" ) || { printf "Could not create temporary directory\n"; exit 1; }

 trap "rm -rf ${CT_TMP_DIR}" EXIT

 # List all ELF (executables|shared objects)...

 find . -type f -exec file {} \;                                             \

 |"${grep}" -E ': ELF [[:digit:]]+-bit (L|M)SB (executable|shared object),'  \

 |cut -d ":" -f 1                                                            \

 >"${CT_TMP_DIR}/files.list"

 # ... and use that list to find missing dependencies

 while read file; do

     do_resolve_deps "${file}"

 done <"${CT_TMP_DIR}/files.list"

 rm -rf "${CT_TMP_DIR}"

 trap - EXIT

 # OK, we're done. Back off.

 cd - >/dev/null