static-toolbox/build/lib.sh

#!/bin/bash
GIT_OPENSSL="https://github.com/drwetter/openssl-pm-snapshot.git"
GIT_BINUTILS_GDB="https://github.com/bminor/binutils-gdb.git"
GIT_READLINE="https://git.savannah.gnu.org/git/readline.git"
GIT_NCURSES="https://github.com/ThomasDickey/ncurses-snapshots.git"
GIT_LIBPCAP="https://github.com/the-tcpdump-group/libpcap.git"

BUILD_DIRECTORY="/build"
OUTPUT_DIRECTORY="/output"
GCC_OPTS="-static -fPIC"
GXX_OPTS="-static -static-libstdc++ -fPIC"
TMP_DIR=$(mktemp -dt building_lib.XXXXXX)
trap "rm -rf ${TMP_DIR}" EXIT TERM

# The init function that has to
# be called before running any
# other function. Should be used
# to configure the building env.
init_lib(){
    CURRENT_ARCH="$1"
    if [ ! -d "$BUILD_DIRECTORY" ];then
        mkdir -p $BUILD_DIRECTORY
    fi
    if [ ! -d "$OUTPUT_DIRECTORY" ];then
        mkdir -p $OUTPUT_DIRECTORY
    fi
}

# Set a HTTP proxy for fetching
# software via HTTP and Git.
set_http_proxy(){
    proxy=$1
    export http_proxy="$proxy"
    export https_proxy="$proxy"
    git config --global http.proxy "$proxy"
}

# Return a host triple for the
# selected architecture.
get_host_triple(){
    local host
    if [ "$CURRENT_ARCH" == "x86" ];then
        host="i686-linux-musl"
    elif [ "$CURRENT_ARCH" == "x86_64" ];then
        host="x86_64-linux-musl"
    elif [ "$CURRENT_ARCH" == "armhf" ];then
        host="arm-linux-musleabihf"
    elif [ "$CURRENT_ARCH" == "aarch64" ];then
        host="aarch64-linux-musl"
    elif [ "$CURRENT_ARCH" == "ppc32" ];then
        host="powerpc-linux-musl"
    elif [ "$CURRENT_ARCH" == "ppc64" ];then
        host="powerpc64-linux-musl"
    fi
    echo $host
}

# Fetch and extract a resource via
# HTTP or clone a Git repository.
fetch(){
    if [ "$#" -ne 3 ];then
        echo "fetch() requires a source, destination and method."
        echo "Example: fetch http://github.com/test.git /build/test git"
        exit 1
    fi
    source=$1
    shift
    destination=$1
    shift
    method=$@
    # TODO: check if $source is a valid URL
    if [ -d "$destination" ] || [ -f "$destination" ];then
        echo "Destination ${destination} already exists, skipping."
        return
    fi
    if [ "${method,,}" == "http" ];then
        cd /tmp || { echo "Could not cd to /tmp"; exit 1; }
        headers=$(mktemp headers.XXXXXX)
        curl -L -D "$headers" -sOJ "$source"
        filename=$(cat "$headers" | grep -o -E 'filename=.*$' | sed -e 's/filename=//')
        filename=$(trim "$filename")
        extract "$filename" "$destination"
        trap "rm -rf ${headers} /tmp/'${filename}'" EXIT TERM
    elif [ "${method,,}" == "git" ];then
        git clone "$source" "$destination"
    else
        echo "Invalid method ${method}"
        exit 1
    fi
}

# Extract an archive to a
# destination directory.
extract(){
    if [ "$#" -ne 2 ];then
        echo "extract() requires a source and destination."
        exit 1
    fi
    source=$1
    destination=$2
    if [ ! -d "$destination" ];then
        mkdir -p "$destination"
    fi
    if [ -f "$source" ] ; then
      case $source in
        *.tar.bz2)   tar xjf "$source" -C "$destination" --strip-components 1  ;;  
        *.tar.gz)    tar xzf "$source" -C "$destination" --strip-components 1  ;;  
        *.tar.xz)    tar xvfJ "$source" -C "$destination" --strip-components 1 ;;  
        *.tar)       tar xf "$source" -C "$destination" --strip-components 1   ;;  
        *.tbz2)      tar xjf "$source" -C "$destination" --strip-components 1  ;;  
        *.tgz)       tar xzf "$source" -C "$destination" --strip-components 1  ;;  
        *)     echo "'${source}' cannot be extracted via extract()" ;;
         esac
     else
         echo "'${source}' is not a valid file"
     fi  
}

# Remove leading and
# trailing whitespaces.
trim(){
    local var="$*"
    var="${var#"${var%%[![:space:]]*}"}"
    var="${var%"${var##*[![:space:]]}"}"   
    echo -n "$var"
}

# Determine the version of
# a binary after building.
get_version(){
    local cmd="$1"
    if [ -z "$cmd" ];then
        echo "Please provide a command to determine the version" >&2
        echo "Example: /build/test --version | awk '{print \$2}'" >&2
        exit 1
    fi
    local version="-"
    if [ "$CURRENT_ARCH" == "armhf" ];then
        if which qemu-arm 1>&2 2>/dev/null;then
            cmd="qemu-arm ${cmd}"
            version+=$(eval "$cmd")
        else
            echo "qemu-arm not found, skipping ARMHF version checks." >&2
        fi
    elif [ "$CURRENT_ARCH" == "aarch64" ];then
        if which qemu-aarch64 1>&2 2>/dev/null;then
            cmd="qemu-aarch64 ${cmd}"
            version+=$(eval "$cmd")
        else
            echo "qemu-aarch64 not found, skipping AARCH64 version checks." >&2
        fi
    elif [ "$CURRENT_ARCH" == "ppc32" ];then
        if which qemu-ppc 1>&2 2>/dev/null;then
            cmd="qemu-ppc ${cmd}"
            version+=$(eval "$cmd")
        else
            echo "qemu-ppc not found, skipping ppc32 version checks." >&2
        fi
    elif [ "$CURRENT_ARCH" == "ppc64" ];then
        if which qemu-ppc64 1>&2 2>/dev/null;then
            cmd="qemu-ppc64 ${cmd}"
            version+=$(eval "$cmd")
        else
            echo "qemu-ppc64 not found, skipping ppc64 version checks." >&2
        fi
    else
        version+=$(eval "$cmd")
    fi
    if [ "$version" == "-" ];then
        version+="${CURRENT_ARCH}"
    else
        version+="-${CURRENT_ARCH}"
    fi
    echo "$version"
}

lib_create_tmp_dir(){
    local tmp_dir=$(mktemp -dt -p ${TMP_DIR} tmpdir.XXXXXX)
    echo "$tmp_dir"
}

lib_check_lib_arch(){
    lib=$1
    if [ ! -f "$lib" ];then
        echo ""
        return
    fi
    local tmp_dir=$(lib_create_tmp_dir)
    cp "$lib" "$tmp_dir"
    bash -c "cd ${tmp_dir}; ar x $(basename ${lib})"
    local output=$(find "${tmp_dir}" -name "*.o" -exec file {} \;)
    if echo "$output" | grep -q "Intel 80386";then
        echo "Arch of ${lib} is x86" >&2
        echo "x86"
    elif echo "$output" | grep -q "x86-64";then
        echo "Arch of ${lib} is x86_64" >&2
        echo "x86_64"
    elif echo "$output" | grep -q "ARM aarch64";then
        echo "Arch of ${lib} is armhf" >&2
        echo "armhf"
    elif echo "$output" | grep -q "ARM,";then
        echo "Arch of ${lib} is aarch64" >&2
        echo "aarch64"
    else
        echo "Could not determine arch of library ${lib}" >&2
        echo ""
    fi
}

lib_build_openssl(){
    local version=$1
    fetch "$GIT_OPENSSL" "${BUILD_DIRECTORY}/openssl" git
    cd "${BUILD_DIRECTORY}/openssl" || { echo "Cannot cd to ${BUILD_DIRECTORY}/openssl"; exit 1; }
    if [ -n "$version" ];then
        git checkout "$version" || echo "Version ${version} not found, continuing with master."
    fi
    if [ -f "${BUILD_DIRECTORY}/openssl/libssl.a" ];then
        lib_arch=$(lib_check_lib_arch "${BUILD_DIRECTORY}/openssl/libssl.a")
        if [ "$lib_arch" != "$CURRENT_ARCH" ];then
            echo "Rebuild for current arch"
            git clean -fdx || true
        else
            echo "[+] OpenSSL already available for current arch, skipping building"
            return
        fi
    fi
    local openssl_arch
    if [ "${CURRENT_ARCH}" == "x86" ] ||
        [ "${CURRENT_ARCH}" == "armhf" ];then
        openssl_arch="linux-generic32"
    elif [ "${CURRENT_ARCH}" == "x86_64" ];then
        openssl_arch="linux-x86_64"
    elif [ "${CURRENT_ARCH}" == "aarch64" ];then
        openssl_arch="linux-generic64"
    elif [ "${CURRENT_ARCH}" == "ppc32" ];then
        openssl_arch="linux-ppc"
    elif [ "${CURRENT_ARCH}" == "ppc64" ];then
        openssl_arch="linux-ppc"
    fi
    CFLAGS="${GCC_OPTS}" \
        ./Configure \
            no-shared \
            "$openssl_arch"
    make -j4
    echo "[+] Finished building OpenSSL ${CURRENT_ARCH}"
}

lib_build_zlib(){
    fetch "$GIT_BINUTILS_GDB" "${BUILD_DIRECTORY}/binutils-gdb" git
    cd "${BUILD_DIRECTORY}/binutils-gdb/zlib" || { echo "Cannot cd to ${BUILD_DIRECTORY}/binutils-gdb/zlib"; exit 1; }
    git clean -fdx
    CC="gcc ${GCC_OPTS}" \
        CXX="g++ ${GXX_OPTS}" \
        /bin/bash ./configure \
            --host="$(get_host_triple)" \
            --enable-static
    make -j4
    echo "[+] Finished building zlib ${CURRENT_ARCH}"
}

lib_build_readline(){
    fetch "$GIT_READLINE" "${BUILD_DIRECTORY}/readline" git
    cd "${BUILD_DIRECTORY}/readline" || { echo "Cannot cd to ${BUILD_DIRECTORY}/readline"; exit 1; }
    git clean -fdx
    CFLAGS="${GCC_OPTS}" \
        CXXFLAGS="${GXX_OPTS}" \
        ./configure \
            --host="$(get_host_triple)" \
            --disable-shared \
            --enable-static
    make -j4
    echo "[+] Finished building readline ${CURRENT_ARCH}"
}

lib_build_ncurses(){
    fetch "$GIT_NCURSES" "${BUILD_DIRECTORY}/ncurses" git
    cd "${BUILD_DIRECTORY}/ncurses" || { echo "Cannot cd to ${BUILD_DIRECTORY}/ncurses"; exit 1; }
    git clean -fdx
    git checkout v6_2

    CMD="CFLAGS=\"${GCC_OPTS}\" "
    CMD+="CXXFLAGS=\"${GXX_OPTS}\" "
    CMD+="./configure --host=$(get_host_triple) --disable-shared --enable-static"
    if [ "$CURRENT_ARCH"!="x86" -a "$CURRENT_ARCH"!="x86_64" ];then
        CMD+=" --with-build-cc=/x86_64-linux-musl-cross/bin/x86_64-linux-musl-gcc"
    fi
    eval "$CMD"
    make -j4
    echo "[+] Finished building ncurses ${CURRENT_ARCH}"
}

lib_build_libpcap(){
    fetch "$GIT_LIBPCAP" "${BUILD_DIRECTORY}/libpcap" git
    cd "${BUILD_DIRECTORY}/libpcap" || { echo "Cannot cd to ${BUILD_DIRECTORY}/libpcap"; exit 1; }
    git clean -fdx
    git checkout libpcap-1.9.1
    CFLAGS="${GCC_OPTS}" \
        CXXFLAGS="${GXX_OPTS}" \
        ./configure \
            --host="$(get_host_triple)" \
            --with-pcap=linux \
            --disable-shared \
            --enable-static
    make -j4
    echo "[+] Finished building libpcap ${CURRENT_ARCH}"
}