#! /bin/bash

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

# Copyright (c) 2003-2005,2007-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

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

[ -f $(dirname $0)/../rpm/config.sh ] || exit 0

source $(dirname $0)/../rpm/config.sh

source $(dirname $0)/wd-functions.sh

set -o pipefail

have_arch_patches=false

fuzz="-F0"

case "$IBS_PROJECT" in

SUSE:SLE-9*)

	fuzz=

	have_arch_patches=true

esac

usage() {

    cat <

SYNOPSIS: $0 [-qv] [--symbol=...] [--dir=...]

          [--fast] [--rapid] [stop-before-patch-name] [--vanilla] [--fuzz=NUM]

          [--patch-dir=PATH] [--build-dir=PATH] [--config=ARCH-FLAVOR [--kabi]]

          [--ctags] [--cscope] [--etags] [--skip-reverse] [--dry-run]

  The --build-dir option supports internal shell aliases, like ~, and variable

  expansion when the variables are properly escaped.  Environment variables

  and the following list of internal variables are permitted:

  \$PATCH_DIR:		The expanded source tree

  \$SRCVERSION:		The current linux source tarball version

  \$TAG:			The current tag or branch of this repo

  \$EXT:			A string expanded from current \$EXTRA_SYMBOLS

  With --config=ARCH-FLAVOR, these have values. Otherwise they are empty.

  \$CONFIG:		The current ARCH-FLAVOR.

  \$CONFIG_ARCH:		The current ARCH.

  \$CONFIG_FLAVOR:	The current FLAVOR.

  The --no-quilt option will still create quilt-style backups for each

  file that is modified but the backups will be removed if the patch

  is successful. This can be fast because the new files may be created

  and removed before writeback occurs so they only exist in memory. A

  failed patch will be rolled back and the caller will be able to diagnose it.

  The --fast option will concatenate all the patches to be applied and

  call patch just once. This is even faster than --no-quilt but if any

  of the component patches fail to apply the tree will not be rolled

  back.

  The --rapid option will use rapidquilt to apply patches.

  The --dry-run option only works with --fast and --rapid.

  The --signing-key option specifies a pathname for a key to be used for

  module signing and for signing the kernel for use with UEFI Secure Boot.

  When used with stop-before-patch-name, both --fast and --no-quilt

  will set up a quilt environment for the remaining patches.

END

    exit 1

}

apply_rapid_patches() {

    printf "%s\n" ${PATCHES_BEFORE[@]} >> $PATCH_DIR/series

    rapidquilt push -a -d $PATCH_DIR -p $PWD $fuzz $DRY_RUN

    status=$?

}

apply_fast_patches() {

    echo "[ Fast-applying ${#PATCHES_BEFORE[@]} patches. ${#PATCHES_AFTER[@]} remain. ]"

    LAST_LOG=$(echo "${PATCHES_BEFORE[@]}" | xargs cat | \

        patch -d $PATCH_DIR -p1 -E $fuzz --force --no-backup-if-mismatch \

		-s $DRY_RUN 2>&1)

    STATUS=$?

    if [ $STATUS -ne 0 ]; then

        echo "$LAST_LOG" >> $PATCH_LOG

        [ -n "$QUIET" ] && echo "$LAST_LOG"

        echo "All-in-one patch failed (not rolled back)."

        echo "Logfile: $PATCH_LOG"

        status=1

    fi

}

SKIPPED_PATCHES=

# Patch kernel normally

apply_one_patch() {

    echo "[ $PATCH ]"

    echo "[ $PATCH ]" >> $PATCH_LOG

    backup_dir=$PATCH_DIR/.pc/$PATCH

    LAST_LOG=$(patch -d $PATCH_DIR --backup --prefix=$backup_dir/ -p1 -E $fuzz \

            --no-backup-if-mismatch --force < $PATCH 2>&1)

    STATUS=$?

    if [ $STATUS -ne 0 ]; then

        restore_files $backup_dir $PATCH_DIR

        if $SKIP_REVERSE; then

            patch -R -d $PATCH_DIR -p1 -E $fuzz --force --dry-run \

                    < $PATCH > /dev/null 2>&1

            ST=$?

            if [ $ST -eq 0 ]; then

                LAST_LOG="[ skipped: can be reverse-applied ]"

                [ -n "$QUIET" ] && echo "$LAST_LOG"

                STATUS=0

                SKIPPED_PATCHES="$SKIPPED_PATCHES $PATCH"

                PATCH="# $PATCH"

                remove_rejects $backup_dir $PATCH_DIR

            fi

        fi

        # Backup directory is no longer needed

        rm -rf $backup_dir

    else

        if $QUILT; then

            echo "$PATCH" >> $PATCH_DIR/.pc/applied-patches

        fi

    fi

    if ! $QUILT; then

        rm -rf $PATCH_DIR/.pc/

    fi

    echo "$LAST_LOG" >> $PATCH_LOG

    [ -z "$QUIET" ] && echo "$LAST_LOG"

    if [ $STATUS -ne 0 ]; then

        [ -n "$QUIET" ] && echo "$LAST_LOG"

        echo "Patch $PATCH failed (rolled back)."

        echo "Logfile: $PATCH_LOG"

        status=1

        return 1

    else

        echo "$SERIES_PFX$PATCH" >> $PATCH_DIR/series

    fi

    return 0

}

apply_patches() {

    for ((n=0; n<${#PATCHES_BEFORE[@]}; n++)); do

        PATCH=${PATCHES_BEFORE[n]}

        if [ ! -r "$PATCH" ]; then

            echo "Patch $PATCH not found."

            status=1

            break

        fi

        apply_one_patch || break

    done

}

apply_rest_patches() {

    STEP_BY_STEP=1

    echo "Stopping before ${PATCHES[0]}"

    for ((n=0; n<${#PATCHES[@]}; n++)); do

        PATCH=${PATCHES[n]}

        if [ ! -r "$PATCH" ]; then

            echo "Patch $PATCH not found."

            status=1

            break

        fi

        if [ -n "$STEP_BY_STEP" ]; then

            while true; do

                echo -n "Continue ([y]es/[n]o/yes to [a]ll)?"

                read YESNO

                case $YESNO in

                    ([yYjJsS])

                        break

                        ;;

                    ([nN])

                        break 2 # break out of outer loop

                        ;;

                    ([aA])

                        unset STEP_BY_STEP

                        break

                        ;;

                esac

            done

        fi

        apply_one_patch || break

    done

}

show_skipped() {

    if [ -n "$SKIPPED_PATCHES" ]; then

	echo "The following patches were skipped and can be removed from series.conf:"

	for p in $SKIPPED_PATCHES; do

	    echo "$p"

	done

    fi

}

# Allow to pass in default arguments via SEQUENCE_PATCH_ARGS.

set -- $SEQUENCE_PATCH_ARGS "$@"

if $have_arch_patches; then

	arch_opt="arch:"

else

	arch_opt=""

fi

options="$(getopt -o qvd:F: --long quilt,no-quilt,$arch_opt,symbol:,dir:,combine,fast,rapid,vanilla,fuzz:,patch-dir:,build-dir:,config:,kabi,ctags,cscope,etags,skip-reverse,dry-run,signing-key: -- "$@")"

if [ $? -ne 0 ]

then

    usage

fi

eval set -- "$options"

QUIET=1

EXTRA_SYMBOLS=

QUILT=true

FAST=

RAPID=

VANILLA=false

SP_BUILD_DIR=

CONFIG=

CONFIG_ARCH=

CONFIG_FLAVOR=

KABI=false

CTAGS=false

CSCOPE=false

ETAGS=false

SKIP_REVERSE=false

DRY_RUN=

SIGNING_KEY=

while true; do

    case "$1" in

    	-q)

	    QUIET=1

	    ;;

    	-v)

	    QUIET=

	    ;;

	--quilt)

	    QUILT=true

	    ;;

	--no-quilt)

	    QUILT=false

	    ;;

	--combine)

	    # ignored

	    ;;

       	--fast)

	    FAST=1

	    ;;

	--rapid)

	    RAPID=1

	    ;;

	--arch)

	    export PATCH_ARCH=$2

	    shift

	    ;;

	--symbol)

	    EXTRA_SYMBOLS="$EXTRA_SYMBOLS $2"

	    shift

	    ;;

	-d|--dir)

	    SCRATCH_AREA=$2

	    shift

	    ;;

	--vanilla)

	    VANILLA=true

	    ;;

	-F|--fuzz)

	    fuzz="-F$2"

	    shift

	    ;;

        --patch-dir)

            PATCH_DIR=$2

            shift

            ;;

	--build-dir)

	    SP_BUILD_DIR="$2"

	    shift

	    ;;

	--config)

	    CONFIG="$2"

	    shift

	    ;;

	--kabi)

	    KABI=true

	    ;;

	--ctags)

	    CTAGS=true

	    ;;

	--cscope)

	    CSCOPE=true

	    ;;

	--etags)

	    ETAGS=true

	    ;;

	--skip-reverse)

	    SKIP_REVERSE=true

	    ;;

	--dry-run)

	    DRY_RUN=--dry-run

	    ;;

	--signing-key)

            SIGNING_KEY="$2"

            shift

            ;;

	--)

	    shift

	    break ;;

	*)

	    usage ;;

    esac

    shift

done

unset LIMIT

if [ $# -ge 1 ]; then

    LIMIT=$1

    shift

fi

if ! [ -z "$DRY_RUN" -o -n "$FAST" -o -n "$RAPID" ]; then

    echo "--dry-run requires --fast or --rapid"

    exit 1

fi

if test -z "$CONFIG"; then

	if test "$VANILLA_ONLY" = 1 || $VANILLA; then

		CONFIG=$(uname -m)-vanilla

	else

		machine=$(uname -m)

		# XXX: We could use scripts/arch-symbols here, but it is

		# not unified among branches and has weird behavior in some

		case "$machine" in

		i?86)

			machine=i386

			;;

		aarch64)

			machine=arm64

			;;

		esac

		if test -e "config/$machine/smp"; then

			CONFIG=$machine-smp

		elif test -e "config/$machine/pae"; then

			CONFIG=$machine-pae

		elif test -e "config/$machine/azure"; then

			CONFIG=$machine-azure

		elif test -e "config/$machine/default"; then

			CONFIG=$machine-default

		elif test -n "$VARIANT" -a -e "config/$machine/${VARIANT#-}"; then

			CONFIG=$machine$VARIANT

		else

			# Try other architectures and assume the user is able

			# to cross-compile

			for machine in ${machine/ppc64le/ppc64} \

				${machine/ppc64/ppc64le} x86_64 \

				ppc64 ppc64le arm64 s390x; do

				if test -e "config/$machine/default"; then

					CONFIG=$machine-default

					break

				fi

			done

		fi

		if test -z "$CONFIG"; then

			echo "Cannot determine default config for arch $machine"

		fi

	fi

fi

if test -n "$CONFIG"; then

	CONFIG_ARCH=${CONFIG%%-*}

	CONFIG_FLAVOR=${CONFIG##*-}

	if [ "$CONFIG" = "$CONFIG_ARCH" -o "$CONFIG" = "$CONFIG_FLAVOR" -o \

			-z "$CONFIG_ARCH" -o -z "$CONFIG_FLAVOR" ]; then

		echo "Invalid config spec: --config=ARCH-FLAVOR is expected."

		usage

	fi

fi

if [ $# -ne 0 ]; then

    usage

fi

# We need at least 2.7 now due to kselftests-kmp-default requiring

# selftests with the need to ensure scripts are execuable.

PATCH_VERSION_REQ="2.7"

PATCH_VERSION_REQ_LD_VERSION=$(echo $PATCH_VERSION_REQ | scripts/ld-version.sh)

PATCH_VERSION=$(patch --version | head -1 | awk '{print $3}')

PATCH_VERSION_LD=$(echo $PATCH_VERSION | scripts/ld-version.sh)

if [ $PATCH_VERSION_LD -lt $PATCH_VERSION_REQ_LD_VERSION ]; then

	echo "$0 requires at least patch version $PATCH_VERSION_REQ"

	exit 1

fi

# Check SCRATCH_AREA.

if [ -z "$SCRATCH_AREA" ]; then

    echo "SCRATCH_AREA not defined (defaulting to \"tmp\")"

    SCRATCH_AREA=tmp

fi

if [ ! -d "$SCRATCH_AREA" ]; then

    if ! mkdir -p $SCRATCH_AREA; then

	echo "creating scratch dir $SCRATCH_AREA failed"

	exit 1

    fi

fi

[ "${SCRATCH_AREA:0:1}" != "/" ] \

    && SCRATCH_AREA="$PWD/$SCRATCH_AREA"

TMPDIR=$SCRATCH_AREA

export TMPDIR

ORIG_DIR=$SCRATCH_AREA/linux-$SRCVERSION.orig

TAG=$(get_branch_name)

TAG=${TAG//\//_}

TAG=${TAG//\#/_}

if $VANILLA; then

	TAG=${TAG}-vanilla

fi

PATCH_LOG=$SCRATCH_AREA/patch-$SRCVERSION${TAG:+-$TAG}.log

# Check series.conf.

if [ ! -r series.conf ]; then

    echo "Configuration file \`series.conf' not found"

    exit 1

fi

if $have_arch_patches; then

    if [ -z "$ARCH_SYMBOLS" ]; then

        if [ -x ./arch-symbols ]; then

            ARCH_SYMBOLS=./arch-symbols

        elif [ -x scripts/arch-symbols ]; then

            ARCH_SYMBOLS=scripts/arch-symbols

        else

            echo "Cannot locate \`arch-symbols' script (export ARCH_SYMBOLS)"

            exit 1

        fi

    else

        if [ ! -x "$ARCH_SYMBOLS" ]; then

            echo "Cannot execute \`arch-symbols' script"

            exit 1

        fi

    fi

    SYMBOLS=$($ARCH_SYMBOLS)

    if [ -z "$SYMBOLS" ]; then

        echo "Unsupported architecture \`$ARCH'" >&2

        exit 1

    fi

echo "Architecture symbol(s): $SYMBOLS"

fi

if [ -s extra-symbols ]; then

	EXTRA_SYMBOLS="$EXTRA_SYMBOLS $(cat extra-symbols)"

fi

if [ -n "$EXTRA_SYMBOLS" ]; then

    EXTRA_SYMBOLS=${EXTRA_SYMBOLS# }

    echo "Extra symbols: $EXTRA_SYMBOLS"

    SYMBOLS="$SYMBOLS $EXTRA_SYMBOLS"

fi

EXT=${EXTRA_SYMBOLS// /-}

EXT=${EXT//\//}

if test -z "$PATCH_DIR"; then

    PATCH_DIR=$SCRATCH_AREA/linux-$SRCVERSION${TAG:+-$TAG}${EXT:+-}$EXT

fi

if [ -n "$SP_BUILD_DIR" ]; then

    # This allows alias (~) and variable expansion

    SP_BUILD_DIR=$(eval echo "$SP_BUILD_DIR")

else

    SP_BUILD_DIR="$PATCH_DIR"

fi

if [ -z "$DRY_RUN" ]; then

    echo "Creating tree in $PATCH_DIR"

    # Clean up from previous run

    rm -f "$PATCH_LOG"

    if [ -e $PATCH_DIR ]; then

	echo "Cleaning up from previous run"

	rm -rf $PATCH_DIR

    fi

fi

# Create fresh $SCRATCH_AREA/linux-$SRCVERSION.

if ! [ -d $ORIG_DIR ]; then

    unpack_tarball "$SRCVERSION" "$ORIG_DIR" "$URL"

    find $ORIG_DIR -type f | xargs chmod a-w,a+r

fi

if $VANILLA; then

	PATCHES=( $(scripts/guards $SYMBOLS < series.conf | grep -E '^patches\.(kernel\.org|rpmify)/') )

else

	PATCHES=( $(scripts/guards $SYMBOLS < series.conf) )

fi

# Check if patch $LIMIT exists

if [ -n "$LIMIT" ]; then

    for ((n=0; n<${#PATCHES[@]}; n++)); do

	if [ "$LIMIT" = - ]; then

	    LIMIT=${PATCHES[n]}

	    break

	fi

	case "${PATCHES[n]}" in

	$LIMIT|*/$LIMIT)

	    LIMIT=${PATCHES[n]}

	    break

	    ;;

	esac

    done

    if [ -n "$LIMIT" ] && ((n == ${#PATCHES[@]})); then

	echo "No patch \`$LIMIT' found."

	exit 1

    fi

    PATCHES_BEFORE=()

    for ((m=0; m

	PATCHES_BEFORE[m]=${PATCHES[m]}

    done

    PATCHES_AFTER=()

    for ((m=n; m<${#PATCHES[@]}; m++)); do

	PATCHES_AFTER[m-n]=${PATCHES[m]}

    done

else

    PATCHES_BEFORE=( "${PATCHES[@]}" )

    PATCHES_AFTER=()

fi

# Helper function to restore files backed up by patch. This is

# faster than doing a --dry-run first.

restore_files() {

    local backup_dir=$1 patch_dir=$2 file

    local -a remove restore

    if [ -d $backup_dir ]; then

	pushd $backup_dir > /dev/null

	for file in $(find . -type f) ; do

	    if [ -s "$file" ]; then

		restore[${#restore[@]}]="$file"

	    else

		remove[${#remove[@]}]="$file"

	    fi

	done

	#echo "Restore: ${restore[@]}"

	[ ${#restore[@]} -ne 0 ] \

	    && printf "%s\n" "${restore[@]}" \

		| xargs cp -f --parents --target $patch_dir

	cd $patch_dir

	#echo "Remove: ${remove[@]}"

	[ ${#remove[@]} -ne 0 ] \

	    && printf "%s\n" "${remove[@]}" | xargs rm -f

	popd > /dev/null

    fi

}

# Helper function to remove stray .rej files.

remove_rejects() {

    local backup_dir=$1 patch_dir=$2 file

    local -a remove

    if [ -d $backup_dir ]; then

	pushd $backup_dir > /dev/null

	for file in $(find . -type f) ; do

	    if [ -f "$patch_dir/$file.rej" ]; then

		remove[${#remove[@]}]="$file.rej"

	    fi

	done

	cd $patch_dir

	#echo "Remove rejects: ${remove[@]}"

	[ ${#remove[@]} -ne 0 ] \

	    && printf "%s\n" "${remove[@]}" | xargs rm -f

	popd > /dev/null

    fi

}

if [ -z "$DRY_RUN" ]; then

    # Create hardlinked source tree

    echo "Linking from $ORIG_DIR"

    cp -rld $ORIG_DIR $PATCH_DIR

    # create a relative symlink

    ln -snf ${PATCH_DIR#$SCRATCH_AREA/} $SCRATCH_AREA/current

else

    PATCH_DIR="$ORIG_DIR"

fi

echo -e "# Symbols: $SYMBOLS\n#" > $PATCH_DIR/series

SERIES_PFX=

if ! $QUILT; then

    SERIES_PFX="# "

fi

if [ -z "$DRY_RUN" ]; then

    mkdir $PATCH_DIR/.pc

    echo 2 > $PATCH_DIR/.pc/.version

fi

if [ -n "$FAST" ]; then

    apply_fast_patches

elif [ -n "$RAPID" ]; then

    apply_rapid_patches

else

    apply_patches

fi

PATCHES=( ${PATCHES_AFTER[@]} )

if ! $QUILT && [ -z "$FAST$RAPID" ]; then

    apply_rest_patches

fi

if [ -n "$DRY_RUN" ]; then

    exit $status

fi

if [ -n "$EXTRA_SYMBOLS" ]; then

    echo "$EXTRA_SYMBOLS" > $PATCH_DIR/extra-symbols

fi

if ! $QUILT; then

    rm $PATCH_DIR/series

fi

ln -s $PWD $PATCH_DIR/patches

ln -s patches/scripts/{refresh_patch,run_oldconfig}.sh $PATCH_DIR/

if $VANILLA; then

	touch "$PATCH_DIR/.is_vanilla"

fi

if $QUILT; then

    [ -r $HOME/.quiltrc ] && . $HOME/.quiltrc

    [ ${QUILT_PATCHES-patches} != patches ] \

        && ln -s $PWD $PATCH_DIR/${QUILT_PATCHES-patches}

fi

echo "[ Tree: $PATCH_DIR ]"

if test "$SP_BUILD_DIR" != "$PATCH_DIR"; then

    mkdir -p "$SP_BUILD_DIR"

    echo "[ Build Dir: $SP_BUILD_DIR ]"

    rm -f "$SP_BUILD_DIR/source"

    rm -f "$SP_BUILD_DIR/patches"

    ln -sf "$PATCH_DIR" "$SP_BUILD_DIR/source"

    ln -sf "source/patches" "$SP_BUILD_DIR/patches"

    cat > $PATCH_DIR/GNUmakefile <

ifeq (\$(filter tags TAGS cscope gtags, \$(MAKECMDGOALS)),)

ifndef KBUILD_OUTPUT

KBUILD_OUTPUT=$SP_BUILD_DIR

endif

endif

include Makefile

EOF

fi

# If there are any remaining patches, add them to the series so

# they can be fixed up with quilt (or similar).

if [ -n "${PATCHES[*]}" ]; then

    ( IFS=$'\n' ; echo "${PATCHES[*]}" ) >> $PATCH_DIR/series

fi

show_skipped

if test "0$status" -ne 0; then

    exit $status

fi

if test -e supported.conf; then

    echo "[ Generating Module.supported ]"

    scripts/guards --list --with-guards < supported.conf | \

    awk '

	    /\+external / {

		    print $(NF) " external";

		    next;

	    }

	    /^-/ {

		    print $(NF) " no";

		    next;

	    }

	    {

		    print $(NF);

	    }

    ' > "$SP_BUILD_DIR/Module.supported"

fi

if test -n "$CONFIG"; then

    if test -e "config/$CONFIG_ARCH/$CONFIG_FLAVOR"; then

	echo "[ Copying config/$CONFIG_ARCH/$CONFIG_FLAVOR ]"

	if ! grep -q CONFIG_MMU= "config/$CONFIG_ARCH/$CONFIG_FLAVOR"; then

	    if [ "$CONFIG_ARCH" = "i386" ]; then

		config_base="config/$CONFIG_ARCH/pae"

	    else

		config_base="config/$CONFIG_ARCH/default"

	    fi

	    scripts/config-merge "$config_base" \

				 "config/$CONFIG_ARCH/$CONFIG_FLAVOR" \

				 > "$SP_BUILD_DIR/.config"

	else

	    cp -a "config/$CONFIG_ARCH/$CONFIG_FLAVOR" "$SP_BUILD_DIR/.config"

	fi

    else

	echo "[ Config $CONFIG does not exist. ]"

    fi

    if $KABI; then

	if [ ! -x rpm/modversions ]; then

	    echo "[ This branch does not support the modversions kABI mechanism. Skipping. ]"

	elif [ -e "kabi/$CONFIG_ARCH/symtypes-$CONFIG_FLAVOR" ]; then

	    echo "[ Expanding kABI references for $CONFIG ]"

	    rpm/modversions --unpack "$SP_BUILD_DIR" < \

		"kabi/$CONFIG_ARCH/symtypes-$CONFIG_FLAVOR"

	else

	    echo "[ No kABI references for $CONFIG ]"

	fi

    fi

    if test -f ${PATCH_DIR}/scripts/kconfig/Makefile && \

       grep -q syncconfig ${PATCH_DIR}/scripts/kconfig/Makefile; then

        syncconfig="syncconfig"

    else

        syncconfig="silentoldconfig"

    fi

    test "$SP_BUILD_DIR" != "$PATCH_DIR" && \

	make -C $PATCH_DIR O=$SP_BUILD_DIR -s $syncconfig

fi

filter_fingerprints() {

    grep 'SHA1 Fingerprint' | sed -e 's/SHA1 Fingerprint.//' | \

        tr -d ' :' | tr a-z A-Z

}

cert_fingerprint() {

    local cert=$1

    openssl x509 -fingerprint -noout -in "$cert" | filter_fingerprints

}

cert_fingerprint8() {

    local cert=$1

    cert_fingerprint "$cert" | cut -b 1-8

}

cert_signature_algo() {

    local cert=$1

    # openssl doesn't have a way to just show the algo

    openssl x509 -noout -text -in "$cert" | grep 'Signature Algorithm' | \

        tr -d ' ' | uniq |  cut -d ':' -f 2

}

get_config_option() {

    local config=$1

    local option=$2

    sed -n "/^CONFIG_$option=/s///p" "$config" |tr -d '"' | tail -1

}

set_config_option() {

    local config=$1

    local option=$2

    local value=$3

    sed -i -e "/^CONFIG_$option=/s;=.*;=$value;" "$config"

}

set_config_option_string() {

    local config=$1

    local option=$2

    local value=$3

    set_config_option "$config" "$option" "\"$value\""

}

copy_signing_key() {

    local cert=$1

    echo "[ Copying signing key $SIGNING_KEY ]"

    if ! test -f "$cert"; then

        echo "*** ERROR: Signing key $cert does not exist"

        return

    fi

    keyexts=$(openssl x509 -in $cert -ext keyUsage,extendedKeyUsage -noout)

    if ! echo $keyexts | grep -q "Code Signing"; then

        echo "*** WARNING: Signing key must have extendedKeyUsage=codeSigning" \

             "to be used to sign kernel for Secure Boot" >&2

    fi

    if ! echo $keyexts | grep -q "Digital Signature"; then

        echo "*** WARNING: Signing key must have keyUsage=digitalSignature" \

             "to be used to sign modules" >&2

    fi

    mkdir -p "$SP_BUILD_DIR/certs"

    certname="$(cert_fingerprint8 "$cert").pem"

    cp "$cert" "$SP_BUILD_DIR/certs/$certname"

    if test -z "$CONFIG"; then

        echo "*** WARNING: signing key copied to certs/$certname but" \

             "no config available to enable"

        return

    fi

    local config="$SP_BUILD_DIR/.config"

    # Check for algo compatibility

    config_algo="$(get_config_option $config MODULE_SIG_HASH)"

    if test -z "$config_algo"; then

        echo "*** WARNING: Module signing is disabled in active config"

        return

    fi

    cert_algo=$(cert_signature_algo $cert)

    cert_algo=${cert_algo%%WithRSAEncryption}

    if test "$config_algo" != "$cert_algo"; then

        echo "*** WARNING: Signing key uses hash algo '$cert_algo' but" \

             " kernel config uses '$config_algo'"

    fi

    set_config_option_string $config MODULE_SIG_KEY "certs/$certname"

}

if test -n "$SIGNING_KEY"; then

    copy_signing_key $SIGNING_KEY

fi

# Some archs we use for the config do not exist or have a different name in the

# kernl source tree

case $CONFIG_ARCH in

	s390x) TAGS_ARCH=s390 ;;

	ppc64|ppc64le) TAGS_ARCH=powerpc ;;

	*) TAGS_ARCH=$CONFIG_ARCH ;;

esac

if $CTAGS; then

    if ctags --version > /dev/null; then

	echo "[ Generating ctags (this may take a while)]"

	ARCH=$TAGS_ARCH make -s --no-print-directory -C "$PATCH_DIR" O="$SP_BUILD_DIR" tags

    else

	echo "[ Could not generate ctags: ctags not found ]"

    fi

fi

if $CSCOPE; then

    if cscope -V 2> /dev/null; then

	echo "[ Generating cscope db (this may take a while)]"

	ARCH=$TAGS_ARCH make -s --no-print-directory -C "$PATCH_DIR" O="$SP_BUILD_DIR" cscope

    else

	echo "[ Could not generate cscope db: cscope not found ]"

    fi

fi

if $ETAGS; then

    if etags --version > /dev/null; then

	echo "[ Generating etags (this may take a while)]"

	ARCH=$TAGS_ARCH make -s --no-print-directory -C "$PATCH_DIR" O="$SP_BUILD_DIR" TAGS

    else

	echo "[ Could not generate etags: etags not found ]"

    fi

fi