#! /bin/bash

#############################################################################

# Copyright (c) 2006-2009 Novell, Inc.

# All Rights Reserved.

#

# This program is free software; you can redistribute it and/or

# modify it under the terms of version 2 of the GNU General Public License as

# published by the Free Software Foundation.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.   See the

# GNU General Public License for more details.

#

# You should have received a copy of the GNU General Public License

# along with this program; if not, contact Novell, Inc.

#

# To contact Novell about this file by physical or electronic mail,

# you may find current contact information at www.novell.com

#############################################################################

usage() {

    echo "USAGE: ${0##*/} [--(no-)symvers|--(no-)symsets|--(no-)symtypes] [--filter <filter>] rpm ..."

    echo -n "The default is"

    $do_symvers  && echo -n " --symvers"  || echo -n " --no-symvers"

    $do_symsets  && echo -n " --symsets"  || echo -n " --no-symsets"

    $do_symtypes && echo -n " --symtypes" || echo -n " --no-symtypes"

    echo

}

symsets_are_equal() {

    local a=$1 b=$2

    cmp -s <(tar tfz $a | sed -e 's:.*/::' | sort) \

	   <(tar tfz $b | sed -e 's:.*/::' | sort)

}

filters2re() {

    local f tail res sep

    if test -z "$tail"; then

        tail='/[^/]*$'

    fi

    for f in "$@"; do

        case "$f" in

        *\*)

            f="${f%\*}"

            f="^\.?$f"

            ;;

        *)

            f="^\.?$f$tail"

        esac

        res="$res$sep$f"

        sep="|"

    done

    echo "$res"

}

merge_dirs() {

    local old=$1 new=$2

    find "$old" "$new" -type f -printf '%P\n' | sort -u \

	>"$tmpdir/all"

    while read f; do

	if cmp -s "$old/$f" "$new/$f"; then

	    continue

	fi

	if ! echo "$f" | grep -Eq "$re"; then

	    continue

	fi

	if test -e "$new/$f"; then

	    cp "$new/$f" "$old/$f"

	    echo "$f added to $target"

	else

	    rm "$old/$f"

	    echo "$f removed from $target"

	fi

    done <"$tmpdir/all"

}

add_symsets() {

    set -- $tmpdir/boot/symsets-*

    if [ $# -eq 0 ]; then

	echo "No symsets file found in $rpm" >&2

	status=1

	return

    fi

    local re=$(tail='\.[0-9a-f]*(\.fake)?$' filters2re "${filters[@]//\//_}")

    for symsets in "$@"; do

	flavor=${symsets%.tar.gz}

	flavor=${flavor##*-}

	target=kabi/$arch/symsets-$flavor.tar.gz

	if [ -e $target ] && symsets_are_equal "$symsets" $target; then

	    echo "$target is unchanged"

	    continue

	fi

	if $opt_dry_run; then

	    echo "$target added"

	    continue

	fi

	mkdir -p ${target%/*}

	if test -z "${filters[*]}"; then

	    cp "$symsets" $target

	else

	    rm -rf "$tmpdir/symsets"

	    mkdir "$tmpdir/symsets"

	    tar xzf "$target" -C "$tmpdir/symsets"

	    old=$(echo "$tmpdir/symsets"/*)

	    mkdir "$tmpdir/symsets/new"

	    tar xzf "$symsets" -C "$tmpdir/symsets/new" --strip-components=1

	    new="$tmpdir/symsets/new"

	    merge_dirs "$old" "$new"

	    tar czf "$target" -C "$tmpdir/symsets" "${old##*/}"

	fi

	echo "$target added"

    done

}

unpack_symtypes() {

    local dir="$1"

    rpm/modversions --unpack "$dir"

}

pack_symtypes() {

    local dir="$1"

    rpm/modversions --pack --ext .symref "$dir"

}

unpack_symvers() {

    local dir="$1" csum sym mod rest last=

    mkdir -p "$dir"

    sort -k 3 | while read csum sym mod rest; do

	    if test "$last" != "$mod"; then

		    mkdir -p "$dir/${mod%/*}"

		    exec 3>"$dir/$mod.symvers"

		    last=$mod

	    fi

	    echo -ne "$csum\\t$sym\\t$mod" >&3

	    if test -n "$rest"; then

		    echo -ne "\\t$rest" >&3

	    fi

	    echo >&3

    done

    exec 3>&-

}

pack_symvers() {

    local dir="$1"

    find "$dir" -type f | xargs cat | sort -k 2

}

add_flat_files() {

    local type=$1

    set -- $tmpdir/boot/$type-*.gz

    if [ $# -eq 0 ]; then

        set -- $tmpdir/usr/src/linux-*-obj/*/*/Module.$type

    fi

    if [ $# -eq 0 ]; then

	echo "No $type file found in $rpm" >&2

	status=1

	return

    fi

    local file flavor target

    local re=$(filters2re "${filters[@]}")

    for file; do

        case "$file" in

        *.gz)

            gzip -cd "$file" > "${file%.gz}"

            file=${file%.gz}

            ;;

        esac

        case "$file" in

        $tmpdir/boot/*)

            flavor=${file##*-}

            ;;

        $tmpdir/usr/src/*/Module.symvers)

            flavor=${file##*-obj/}

            flavor=${flavor#*/}

            flavor=${flavor%/Module.symvers}

            ;;

        esac

	target=kabi/$arch/$type-$flavor

	if cmp -s "$file" "$target"; then

	    echo "$target is unchanged"

	    continue

	fi

	if $opt_dry_run; then

	    echo "$target added"

	    continue

	fi

	mkdir -p "${target%/*}"

	if test -z "${filters[*]}"; then

	    cp "$file" "$target"

	else

	    rm -rf "$tmpdir/$type"

	    mkdir -p "$tmpdir/$type"/{old,new}

	    old="$tmpdir/$type/old"

	    new="$tmpdir/$type/new"

	    unpack_$type "$old" <"$target" &

	    unpack_$type "$new" <"$file" &

	    wait

	    merge_dirs "$old" "$new"

	    pack_$type "$old" >"$target"

	fi

	echo "$target added"

    done

}

unpack_iso()

{

    local iso=$1 file name

    isoinfo -R -f -i "$iso" | grep -E '/kernel-[^/]*-([2-9]|[1-9][0-9]+)\.[0-9][^/]*\.rpm$' |

    while read file; do

        name=${file##*/}

        case "$name" in

        kernel-source-* | kernel-syms-* | kernel-*-debug* | kernel-*-man-*| \

        kernel-firmware-* | kernel-coverage-* | kernel-docs-* | \

        kernel-*-extra* | *src.rpm)

            continue

        esac

        isoinfo -R -i "$iso" -x "$file" >"$tmpdir/$name"

        echo "$tmpdir/$name"

    done

}

query_rpm()

{

    local rpm=$1

    exec 3< <(rpm -qp --qf '%{NAME}\n%{ARCH}\n%{VERSION}\n%{RELEASE}' "$rpm")

    read name <&3

    read arch <&3

    read version <&3

    read release <&3

    exec 3<&-

}

. rpm/config.sh

case "$IBS_PROJECT" in

SUSE:SLE-9*)

    do_symvers=true

    do_symsets=false

    do_symtypes=false

    ;;

SUSE:SLE-10-SP[012]*)

    do_symvers=true

    do_symsets=true

    do_symtypes=false

    ;;

SUSE:SLE-10* | SUSE:SLE-11*)

    do_symvers=true

    do_symsets=true

    do_symtypes=true

    ;;

*)

    do_symvers=true

    do_symsets=false

    do_symtypes=true

    ;;

esac

options="$(getopt -o h --long symvers,no-symvers,symsets,no-symsets,symtypes,no-symtypes,dry-run,filter:,help -- "$@")"

if [ $? -ne 0 ]; then

    usage >&2

    exit 1

fi

eval set -- "$options"

opt_dry_run=false

filters=()

while :; do

    arg=$1

    shift

    newval=true

    case "$arg" in

	--no-*)

	    newval=false

	    arg=${arg/--no-/--}

    esac

    case "$arg" in

	--symvers)

            do_symvers=$newval

	    ;;

	--symsets)

            do_symsets=$newval

	    ;;

	--symtypes)

            do_symtypes=$newval

	    ;;

	--dry-run)

	    opt_dry_run=true

	    ;;

	--filter)

	    filters[${#filters[@]}]=${1%/}

	    shift

	    ;;

	-h|--help)

	    usage

	    exit 0

	    ;;

	--)

	    break;

    esac

done

if [ $# -eq 0 ]; then

    usage >&2

    exit 1

fi

tmpdir=$(mktemp -td ${0##*/}.XXXXXX)

trap "rm -rf $tmpdir" EXIT

shopt -s nullglob

echo "Packages to process:"

unset ${!found_rmps_*}

while test $# -gt 0; do

    rpm=$1

    shift

    case "$rpm" in

	*.src.rpm | *.nosrc.rpm | *.noarch.rpm | *.delta.rpm)

	    continue

	    ;;

        *.iso)

            set -- $(unpack_iso "$rpm") "$@"

            continue

            ;;

    esac

    # There may be symlinks as well as regular files. Skip duplicates.

    for file in "${rpms[@]}"; do

	[ "$rpm" -ef "$file" ] && continue 2

    done

    query_rpm "$rpm"

    var=found_rmps_${arch}_${name//-/_}

    eval "$var=\"\$$var $rpm\""

    rpms[${#rpms[@]}]=$rpm

done

for rpm in ${!found_rmps_*}; do

    set -- ${!rpm}

    if [ $# -ne 1 ]; then

	echo "*** Duplicate: ${*##*/}" >&2

	failed=1

    fi

done

[ -z "$failed" ] || exit 1

for rpm in ${!found_rmps_*}; do

    set -- ${!rpm}

    echo ${1##*/}

done

echo

archs_flavors="$(scripts/guards --list < config.conf)"

for rpm in "${rpms[@]}"; do

    query_rpm "$rpm"

    # skip the main package if there is a base subpackage

    base=found_rmps_${arch}_${name//-/_}_base

    if [ -n "${!base}" ]; then

	continue

    fi

    # ... and skip both if there is a -devel subpackage

    devel=found_rmps_${arch}_${name//-/_}

    devel=${devel%_base}_devel

    if [ -n "${!devel}" ]; then

        continue

    fi

    build_arch=$arch

    case "$arch" in

	i?86)

	    arch=i386 ;;

	s390*)

            case "$IBS_PROJECT" in

            SUSE:SLE-9* | SUSE:SLE-10* | SUSE:SLE-11:*)

                arch=s390 ;;

            esac

            ;;

        ppc*)

            case "$IBS_PROJECT" in

            SUSE:SLE-10*)

                arch=powerpc ;;

            esac

            ;;

        aarch64)

            arch=arm64

            ;;

    esac

    flavor=${name#kernel-}

    flavor=${flavor%-base}

    flavor=${flavor%-devel}

    if ! echo "$archs_flavors" | grep -q "$arch/$flavor"; then

	case "$flavor" in

	source | syms | *-extra)

	    ;;

	*)

	    echo "${rpm%%*/}: not a known arch/flavor; skipping" >&2

	    ;;

	esac

	continue

    fi

    echo "[$name-$version-$release.$build_arch.rpm]"

    rm -rf $tmpdir/{boot,usr}

    rpm2cpio "$rpm" \

    | ( cd $tmpdir && cpio -dim --quiet './boot/symvers-*' './boot/symsets-*' \

        './boot/symtypes-*' './usr/src/linux-*-obj/*/*/Module.symvers' )

    if $do_symvers; then

	add_flat_files symvers

    fi

    if $do_symtypes; then

	add_flat_files symtypes

    fi

    if $do_symsets; then

	add_symsets

    fi

done

exit $status

# vim:sw=4 et