Patching method

1/1

---
 toolchain/patch-kernel.sh |  159 +++++++++++++++++++++++++++++---------------
 1 files changed, 105 insertions(+), 54 deletions(-)
index 76cb9f7..0492e01 100755
@@ -1,66 +1,117 @@
-#! /bin/bash
-# A little script I whipped up to make it easy to
-# patch source trees and have sane error handling
-# -Erik
-#
-# (c) 2002 Erik Andersen <[email protected]>
+#!/bin/bash
 
-# Set directories from arguments, or use defaults.
-targetdir=${1-.}
-patchdir=${2-../kernel-patches}
-shift 2
-patchpattern=${@-*}
+# function apply_patch patch_file
+# this function no more deal with directory case since it is managed
+# in an upper layer
+function apply_patch {
+apply="patch -p1 -E -d"
+#if [ ! -e "${1}" ] ; then
+#	echo "${1} is not a file"
+#	exit 1
+#fi
 
-if [ ! -d "${targetdir}" ] ; then
-    echo "Aborting.  '${targetdir}' is not a directory."
-    exit 1
+case "${1}" in
+*\.tar\.gz$|*\.tgz$|*\.tar\.bz$|*\.tar\.bz2$|*\.tbz$|*\.tbz2$)
+	echo "Error with ${1}";
+	echo "Archives into a directory or another archive is not supported";
+	return 1;
+	;;
+*\.gz$)
+	type="gzip"; uncomp="gunzip -dc"; ;;
+*\.bz$)
+	type="bzip"; uncomp="bunzip -dc"; ;;
+*\.bz2$)
+	type="bzip2"; uncomp="bunzip2 -dc"; ;;
+*\.zip$)
+	type="zip"; uncomp="unzip -d"; ;;
+*\.Z$)
+	type="compress"; uncomp="uncompress -c"; ;;
+*\.diff*)
+	type="diff"; uncomp="cat"; ;;
+*\.patch*)
+	type="patch"; uncomp="cat"; ;;
+*)
+	echo "Unsupported format file for ${1}, skip it";
+	return 0;
+	;;
+esac
+
+echo ""
+echo "Applying ${1} using ${type}: "
+echo ${1} | cat >> ${builddir}/.applied_patches_list
+${uncomp} ${1} | ${apply} ${builddir}
+if [ $? != 0 ] ; then
+	echo "Patch failed! Please fix ${1}!"
+	return 1
 fi
+}
+
+
+# entry point
+builddir=${1}
+patchdir=${2}
+shift 2
+patchlist=${@}
+patchesdir="${builddir}/../$(basename $builddir)-patches"
+
+# check directories
 if [ ! -d "${patchdir}" ] ; then
-    echo "Aborting.  '${patchdir}' is not a directory."
-    exit 1
+	echo "Aborting: ${patchdir} is not a directory."
+	exit 1
 fi
-    
-for i in `cd ${patchdir}; ls -d ${patchpattern} 2> /dev/null` ; do 
-    apply="patch -p1 -E -d"
-    uncomp_parm=""
-    if [ -d "${patchdir}/$i" ] ; then
-	type="directory overlay"
-	uncomp="tar cf - --exclude=.svn --no-anchored -C"
-	uncomp_parm="."
-	apply="tar xvf - -C"
-    else case "$i" in
-	*.gz)
-	type="gzip"; uncomp="gunzip -dc"; ;; 
-	*.bz)
-	type="bzip"; uncomp="bunzip -dc"; ;; 
-	*.bz2)
-	type="bzip2"; uncomp="bunzip2 -dc"; ;; 
-	*.zip)
-	type="zip"; uncomp="unzip -d"; ;; 
-	*.Z)
-	type="compress"; uncomp="uncompress -c"; ;; 
-	*.tgz)
-	type="tar gzip"; uncomp="gunzip -dc"; apply="tar xvf - -C"; ;; 
-	*.tar)
-	type="tar"; uncomp="cat"; apply="tar xvf - -C"; ;; 
-	*)
-	type="plaintext"; uncomp="cat"; ;; 
-    esac fi
-    echo ""
-    echo "Applying ${i} using ${type}: " 
-	echo ${i} | cat >> ${targetdir}/.applied_patches_list
-    ${uncomp} ${patchdir}/${i} ${uncomp_parm} | ${apply} ${targetdir} 
-    if [ $? != 0 ] ; then
-        echo "Patch failed!  Please fix $i!"
+if [ ! -d "${builddir}" ] ; then
+	echo "Aborting: ${builddir} is not a directory."
 	exit 1
-    fi
+fi
+
+# parse patch list, extract archives, apply patches
+for i in $patchlist ; do
+	# for remote files, directory is buildroot dl dir
+	#if echo $i | grep -q -E "^http://|^ftp://" ; then
+	#	patchdir=$patchdir
+	#else
+	#	patchdir=$(dirname $i)
+	#fi
+	patch_path="${patchdir}/${i}"
+	# three cases: directory, archive, file patch (compressed or not)
+	# directory
+	if [ -d "${patch_path}" ] ; then
+		for p in $(ls ${patch_path}) ; do
+			apply_patch "${patch_path}/${p}" || exit 1
+		done
+	# archive
+	elif echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$|tar\.gz$|tgz$" ; then
+		mkdir "${patchesdir}"
+		# extract archive
+		if echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$" ; then
+			tar_options="-xjf"
+		else
+			tar_options="-xzf"
+		fi
+		tar -C ${patchesdir} --strip-components=1 ${tar_options} ${patch_path}
+		# apply patches from the archive
+		#echo ${patchesdir}
+		#find ${patchesdir} | sort
+		for p in $(find ${patchesdir} | sort) ; do
+			apply_patch "${p}" || { rm -rf "${patchesdir}" ; exit 1; }
+		done
+		rm -rf "${patchesdir}"
+	# file which is not an archive
+	else
+		# we can have regex into patch name as package*.patch.arm that's
+		# why using ls
+		for p in $(ls -d ${patch_path} 2> /dev/null) ; do
+			apply_patch "${p}" || exit 1
+		done
+	fi
 done
 
-# Check for rejects...
-if [ "`find $targetdir/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
+# check for rejects...
+if [ "`find ${builddir}/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
     echo "Aborting.  Reject files found."
     exit 1
 fi
 
-# Remove backup files
-find $targetdir/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+# remove backup files
+find ${builddir}/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+

1.7.5
Bye, Peter Korsgaard
Thomas Petazzoni, Free Electrons
Kernel, drivers, real-time and embedded Linux
development, consulting, training and support.
http://free-electrons.com
---
 toolchain/patch-kernel.sh |  154 +++++++++++++++++++++++++++++----------------
 1 files changed, 100 insertions(+), 54 deletions(-)
index 76cb9f7..408a9a7 100755
@@ -1,66 +1,112 @@
-#! /bin/bash
-# A little script I whipped up to make it easy to
-# patch source trees and have sane error handling
-# -Erik
-#
-# (c) 2002 Erik Andersen <[email protected]>
+#!/bin/bash
 
-# Set directories from arguments, or use defaults.
-targetdir=${1-.}
-patchdir=${2-../kernel-patches}
-shift 2
-patchpattern=${@-*}
+# function apply_patch patch_file
+# this function no more deal with directory case since it is managed
+# in an upper layer
+function apply_patch {
+apply="patch -p1 -E -d"
 
-if [ ! -d "${targetdir}" ] ; then
-    echo "Aborting.  '${targetdir}' is not a directory."
-    exit 1
+case "${1}" in
+*\.tar\.gz|*\.tgz|*\.tar\.bz|*\.tar\.bz2|*\.tbz|*\.tbz2)
+	echo "Error with ${1}";
+	echo "Archives into a directory or another archive is not supported";
+	return 1;
+	;;
+*\.gz)
+	type="gzip"; uncomp="gunzip -dc"; ;;
+*\.bz)
+	type="bzip"; uncomp="bunzip -dc"; ;;
+*\.bz2)
+	type="bzip2"; uncomp="bunzip2 -dc"; ;;
+*\.zip)
+	type="zip"; uncomp="unzip -d"; ;;
+*\.Z)
+	type="compress"; uncomp="uncompress -c"; ;;
+*\.diff*)
+	type="diff"; uncomp="cat"; ;;
+# '*' at the end is needed for patch.arm for example
+*\.patch*)
+	type="patch"; uncomp="cat"; ;;
+*)
+	echo "Unsupported format file for ${1}, skip it";
+	return 0;
+	;;
+esac
+
+echo ""
+echo "Applying ${1} using ${type}: "
+echo ${1} | cat >> ${builddir}/.applied_patches_list
+${uncomp} ${1} | ${apply} ${builddir}
+if [ $? != 0 ] ; then
+	echo "Patch failed! Please fix ${1}!"
+	return 1
 fi
+}
+
+# entry point
+builddir=${1}
+patchdir=${2}
+shift 2
+patchlist=${@}
+patchesdir="${builddir}/../$(basename $builddir)-patches"
+
+# check directories
 if [ ! -d "${patchdir}" ] ; then
-    echo "Aborting.  '${patchdir}' is not a directory."
-    exit 1
+	echo "Aborting: ${patchdir} is not a directory."
+	exit 1
 fi
-    
-for i in `cd ${patchdir}; ls -d ${patchpattern} 2> /dev/null` ; do 
-    apply="patch -p1 -E -d"
-    uncomp_parm=""
-    if [ -d "${patchdir}/$i" ] ; then
-	type="directory overlay"
-	uncomp="tar cf - --exclude=.svn --no-anchored -C"
-	uncomp_parm="."
-	apply="tar xvf - -C"
-    else case "$i" in
-	*.gz)
-	type="gzip"; uncomp="gunzip -dc"; ;; 
-	*.bz)
-	type="bzip"; uncomp="bunzip -dc"; ;; 
-	*.bz2)
-	type="bzip2"; uncomp="bunzip2 -dc"; ;; 
-	*.zip)
-	type="zip"; uncomp="unzip -d"; ;; 
-	*.Z)
-	type="compress"; uncomp="uncompress -c"; ;; 
-	*.tgz)
-	type="tar gzip"; uncomp="gunzip -dc"; apply="tar xvf - -C"; ;; 
-	*.tar)
-	type="tar"; uncomp="cat"; apply="tar xvf - -C"; ;; 
-	*)
-	type="plaintext"; uncomp="cat"; ;; 
-    esac fi
-    echo ""
-    echo "Applying ${i} using ${type}: " 
-	echo ${i} | cat >> ${targetdir}/.applied_patches_list
-    ${uncomp} ${patchdir}/${i} ${uncomp_parm} | ${apply} ${targetdir} 
-    if [ $? != 0 ] ; then
-        echo "Patch failed!  Please fix $i!"
+if [ ! -d "${builddir}" ] ; then
+	echo "Aborting: ${builddir} is not a directory."
 	exit 1
-    fi
+fi
+
+# go to the patch directory because $patchlist is interpreted when doing
+# for i in $patchlist
+pushd ${patchdir}
+index=0
+for i in $patchlist ; do
+	patchlist_interpreted[${index}]="$i"
+	index=`expr ${index} + 1`
+	echo patchlist_interpreted[${index}]=$i
 done
+popd
 
-# Check for rejects...
-if [ "`find $targetdir/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
+for index in "${!patchlist_interpreted[@]}" ; do
+	file="${patchlist_interpreted[${index}]}"
+	patch_path="${patchdir}/${file}"
+	# three cases: directory, archive, file patch (compressed or not)
+	# directory
+	if [ -d "${patch_path}" ] ; then
+		for p in $(ls ${patch_path}) ; do
+			apply_patch "${patch_path}/${p}" || exit 1
+		done
+	# archive
+	elif echo $file | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$|tar\.gz$|tgz$" ; then
+		mkdir "${patchesdir}"
+		# extract archive
+		if echo $file | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$" ; then
+			tar_options="-xjf"
+		else
+			tar_options="-xzf"
+		fi
+		tar -C ${patchesdir} --strip-components=1 ${tar_options} ${patch_path}
+		# apply patches from the archive
+		for p in $(find ${patchesdir} | sort) ; do
+			apply_patch "${p}" || { rm -rf "${patchesdir}" ; exit 1; }
+		done
+		rm -rf "${patchesdir}"
+	# file which is not an archive
+	else
+		apply_patch "${patch_path}" || exit 1
+	fi
+done
+
+# check for rejects...
+if [ "`find ${builddir}/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
     echo "Aborting.  Reject files found."
     exit 1
 fi
 
-# Remove backup files
-find $targetdir/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+# remove backup files
+find ${builddir}/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+

1.7.0.4
---
 toolchain/patch-kernel.sh |  154 +++++++++++++++++++++++++++++----------------
 1 files changed, 100 insertions(+), 54 deletions(-)
index 76cb9f7..408a9a7 100755
@@ -1,66 +1,112 @@
-#! /bin/bash
-# A little script I whipped up to make it easy to
-# patch source trees and have sane error handling
-# -Erik
-#
-# (c) 2002 Erik Andersen <[email protected]>
+#!/bin/bash
 
-# Set directories from arguments, or use defaults.
-targetdir=${1-.}
-patchdir=${2-../kernel-patches}
-shift 2
-patchpattern=${@-*}
+# function apply_patch patch_file
+# this function no more deal with directory case since it is managed
+# in an upper layer
+function apply_patch {
+apply="patch -p1 -E -d"
 
-if [ ! -d "${targetdir}" ] ; then
-    echo "Aborting.  '${targetdir}' is not a directory."
-    exit 1
+case "${1}" in
+*\.tar\.gz|*\.tgz|*\.tar\.bz|*\.tar\.bz2|*\.tbz|*\.tbz2)
+	echo "Error with ${1}";
+	echo "Archives into a directory or another archive is not supported";
+	return 1;
+	;;
+*\.gz)
+	type="gzip"; uncomp="gunzip -dc"; ;;
+*\.bz)
+	type="bzip"; uncomp="bunzip -dc"; ;;
+*\.bz2)
+	type="bzip2"; uncomp="bunzip2 -dc"; ;;
+*\.zip)
+	type="zip"; uncomp="unzip -d"; ;;
+*\.Z)
+	type="compress"; uncomp="uncompress -c"; ;;
+*\.diff*)
+	type="diff"; uncomp="cat"; ;;
+# '*' at the end is needed for patch.arm for example
+*\.patch*)
+	type="patch"; uncomp="cat"; ;;
+*)
+	echo "Unsupported format file for ${1}, skip it";
+	return 0;
+	;;
+esac
+
+echo ""
+echo "Applying ${1} using ${type}: "
+echo ${1} | cat >> ${builddir}/.applied_patches_list
+${uncomp} ${1} | ${apply} ${builddir}
+if [ $? != 0 ] ; then
+	echo "Patch failed! Please fix ${1}!"
+	return 1
 fi
+}
+
+# entry point
+builddir=${1}
+patchdir=${2}
+shift 2
+patchlist=${@}
+patchesdir="${builddir}/../$(basename $builddir)-patches"
+
+# check directories
 if [ ! -d "${patchdir}" ] ; then
-    echo "Aborting.  '${patchdir}' is not a directory."
-    exit 1
+	echo "Aborting: ${patchdir} is not a directory."
+	exit 1
 fi
-    
-for i in `cd ${patchdir}; ls -d ${patchpattern} 2> /dev/null` ; do 
-    apply="patch -p1 -E -d"
-    uncomp_parm=""
-    if [ -d "${patchdir}/$i" ] ; then
-	type="directory overlay"
-	uncomp="tar cf - --exclude=.svn --no-anchored -C"
-	uncomp_parm="."
-	apply="tar xvf - -C"
-    else case "$i" in
-	*.gz)
-	type="gzip"; uncomp="gunzip -dc"; ;; 
-	*.bz)
-	type="bzip"; uncomp="bunzip -dc"; ;; 
-	*.bz2)
-	type="bzip2"; uncomp="bunzip2 -dc"; ;; 
-	*.zip)
-	type="zip"; uncomp="unzip -d"; ;; 
-	*.Z)
-	type="compress"; uncomp="uncompress -c"; ;; 
-	*.tgz)
-	type="tar gzip"; uncomp="gunzip -dc"; apply="tar xvf - -C"; ;; 
-	*.tar)
-	type="tar"; uncomp="cat"; apply="tar xvf - -C"; ;; 
-	*)
-	type="plaintext"; uncomp="cat"; ;; 
-    esac fi
-    echo ""
-    echo "Applying ${i} using ${type}: " 
-	echo ${i} | cat >> ${targetdir}/.applied_patches_list
-    ${uncomp} ${patchdir}/${i} ${uncomp_parm} | ${apply} ${targetdir} 
-    if [ $? != 0 ] ; then
-        echo "Patch failed!  Please fix $i!"
+if [ ! -d "${builddir}" ] ; then
+	echo "Aborting: ${builddir} is not a directory."
 	exit 1
-    fi
+fi
+
+# go to the patch directory because $patchlist is interpreted when doing
+# for i in $patchlist
+pushd ${patchdir}
+index=0
+for i in $patchlist ; do
+	patchlist_interpreted[${index}]="$i"
+	index=`expr ${index} + 1`
+	echo patchlist_interpreted[${index}]=$i
 done
+popd
 
-# Check for rejects...
-if [ "`find $targetdir/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
+for index in "${!patchlist_interpreted[@]}" ; do
+	file="${patchlist_interpreted[${index}]}"
+	patch_path="${patchdir}/${file}"
+	# three cases: directory, archive, file patch (compressed or not)
+	# directory
+	if [ -d "${patch_path}" ] ; then
+		for p in $(ls ${patch_path}) ; do
+			apply_patch "${patch_path}/${p}" || exit 1
+		done
+	# archive
+	elif echo $file | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$|tar\.gz$|tgz$" ; then
+		mkdir "${patchesdir}"
+		# extract archive
+		if echo $file | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$" ; then
+			tar_options="-xjf"
+		else
+			tar_options="-xzf"
+		fi
+		tar -C ${patchesdir} --strip-components=1 ${tar_options} ${patch_path}
+		# apply patches from the archive
+		for p in $(find ${patchesdir} | sort) ; do
+			apply_patch "${p}" || { rm -rf "${patchesdir}" ; exit 1; }
+		done
+		rm -rf "${patchesdir}"
+	# file which is not an archive
+	else

+		apply_patch "${patch_path}" || exit 1
+	fi
+done
+
+# check for rejects...
+if [ "`find ${builddir}/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
     echo "Aborting.  Reject files found."
     exit 1
 fi
 

-# Remove backup files
-find $targetdir/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+# remove backup files
+find ${builddir}/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+

---
  toolchain/patch-kernel.sh |  154 +++++++++++++++++++++++++++++----------------
  1 files changed, 100 insertions(+), 54 deletions(-)
index 76cb9f7..408a9a7 100755
@@ -1,66 +1,112 @@
-#! /bin/bash
-# A little script I whipped up to make it easy to
-# patch source trees and have sane error handling
-# -Erik
-#
-# (c) 2002 Erik Andersen<[email protected]>
+#!/bin/bash
 
-# Set directories from arguments, or use defaults.
-targetdir=${1-.}
-patchdir=${2-../kernel-patches}
-shift 2
-patchpattern=${@-*}
+# function apply_patch patch_file
+# this function no more deal with directory case since it is managed
+# in an upper layer
+function apply_patch {
+apply="patch -p1 -E -d"
 
-if [ ! -d "${targetdir}" ] ; then
-    echo "Aborting.  '${targetdir}' is not a directory."
-    exit 1
+case "${1}" in
+*\.tar\.gz|*\.tgz|*\.tar\.bz|*\.tar\.bz2|*\.tbz|*\.tbz2)
+	echo "Error with ${1}";
+	echo "Archives into a directory or another archive is not supported";
+	return 1;
+	;;
+*\.gz)
+	type="gzip"; uncomp="gunzip -dc"; ;;
+*\.bz)
+	type="bzip"; uncomp="bunzip -dc"; ;;
+*\.bz2)
+	type="bzip2"; uncomp="bunzip2 -dc"; ;;
+*\.zip)
+	type="zip"; uncomp="unzip -d"; ;;
+*\.Z)
+	type="compress"; uncomp="uncompress -c"; ;;
+*\.diff*)
+	type="diff"; uncomp="cat"; ;;
+# '*' at the end is needed for patch.arm for example
+*\.patch*)
+	type="patch"; uncomp="cat"; ;;
+*)
+	echo "Unsupported format file for ${1}, skip it";
+	return 0;
+	;;
+esac
+
+echo ""
+echo "Applying ${1} using ${type}: "
+echo ${1} | cat>>  ${builddir}/.applied_patches_list
+${uncomp} ${1} | ${apply} ${builddir}
+if [ $? != 0 ] ; then
+	echo "Patch failed! Please fix ${1}!"
+	return 1
  fi
+}
+
+# entry point
+builddir=${1}
+patchdir=${2}
+shift 2
+patchlist=${@}
+patchesdir="${builddir}/../$(basename $builddir)-patches"
+
+# check directories
  if [ ! -d "${patchdir}" ] ; then
-    echo "Aborting.  '${patchdir}' is not a directory."
-    exit 1
+	echo "Aborting: ${patchdir} is not a directory."
+	exit 1
  fi
-
-for i in `cd ${patchdir}; ls -d ${patchpattern} 2>  /dev/null` ; do
-    apply="patch -p1 -E -d"
-    uncomp_parm=""
-    if [ -d "${patchdir}/$i" ] ; then
-	type="directory overlay"
-	uncomp="tar cf - --exclude=.svn --no-anchored -C"
-	uncomp_parm="."
-	apply="tar xvf - -C"
-    else case "$i" in
-	*.gz)
-	type="gzip"; uncomp="gunzip -dc"; ;;
-	*.bz)
-	type="bzip"; uncomp="bunzip -dc"; ;;
-	*.bz2)
-	type="bzip2"; uncomp="bunzip2 -dc"; ;;
-	*.zip)
-	type="zip"; uncomp="unzip -d"; ;;
-	*.Z)
-	type="compress"; uncomp="uncompress -c"; ;;
-	*.tgz)
-	type="tar gzip"; uncomp="gunzip -dc"; apply="tar xvf - -C"; ;;
-	*.tar)
-	type="tar"; uncomp="cat"; apply="tar xvf - -C"; ;;
-	*)
-	type="plaintext"; uncomp="cat"; ;;
-    esac fi
-    echo ""
-    echo "Applying ${i} using ${type}: "
-	echo ${i} | cat>>  ${targetdir}/.applied_patches_list
-    ${uncomp} ${patchdir}/${i} ${uncomp_parm} | ${apply} ${targetdir}
-    if [ $? != 0 ] ; then
-        echo "Patch failed!  Please fix $i!"
+if [ ! -d "${builddir}" ] ; then
+	echo "Aborting: ${builddir} is not a directory."
  	exit 1
-    fi
+fi
+
+# go to the patch directory because $patchlist is interpreted when doing
+# for i in $patchlist
+pushd ${patchdir}
+index=0
+for i in $patchlist ; do
+	patchlist_interpreted[${index}]="$i"
+	index=`expr ${index} + 1`
+	echo patchlist_interpreted[${index}]=$i
  done
+popd
 
-# Check for rejects...
-if [ "`find $targetdir/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
+for index in "${!patchlist_interpreted[@]}" ; do
+	file="${patchlist_interpreted[${index}]}"
+	patch_path="${patchdir}/${file}"
+	# three cases: directory, archive, file patch (compressed or not)
+	# directory
+	if [ -d "${patch_path}" ] ; then
+		for p in $(ls ${patch_path}) ; do
+			apply_patch "${patch_path}/${p}" || exit 1
+		done
+	# archive
+	elif echo $file | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$|tar\.gz$|tgz$" ; then
+		mkdir "${patchesdir}"
+		# extract archive
+		if echo $file | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$" ; then
+			tar_options="-xjf"
+		else
+			tar_options="-xzf"
+		fi
+		tar -C ${patchesdir} --strip-components=1 ${tar_options} ${patch_path}
+		# apply patches from the archive
+		for p in $(find ${patchesdir} | sort) ; do
+			apply_patch "${p}" || { rm -rf "${patchesdir}" ; exit 1; }
+		done
+		rm -rf "${patchesdir}"
+	# file which is not an archive
+	else

+		apply_patch "${patch_path}" || exit 1
+	fi
+done
+
+# check for rejects...
+if [ "`find ${builddir}/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
      echo "Aborting.  Reject files found."
      exit 1
  fi
 

-# Remove backup files
-find $targetdir/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+# remove backup files
+find ${builddir}/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+

---
 support/scripts/apply-patches.sh |  159 +++++++++++++++++++++++++-------------
 1 files changed, 105 insertions(+), 54 deletions(-)
index 1aef47e..0492e01 100755
@@ -1,66 +1,117 @@
-#! /bin/bash
-# A little script I whipped up to make it easy to
-# patch source trees and have sane error handling
-# -Erik
-#
-# (c) 2002 Erik Andersen <[email protected]>
+#!/bin/bash
 
-# Set directories from arguments, or use defaults.
-targetdir=${1-.}
-patchdir=${2-../kernel-patches}
-shift 2
-patchpattern=${@-*}
+# function apply_patch patch_file
+# this function no more deal with directory case since it is managed
+# in an upper layer
+function apply_patch {
+apply="patch -p1 -E -d"
+#if [ ! -e "${1}" ] ; then
+#	echo "${1} is not a file"
+#	exit 1
+#fi
 
-if [ ! -d "${targetdir}" ] ; then
-    echo "Aborting.  '${targetdir}' is not a directory."
-    exit 1
+case "${1}" in
+*\.tar\.gz$|*\.tgz$|*\.tar\.bz$|*\.tar\.bz2$|*\.tbz$|*\.tbz2$)
+	echo "Error with ${1}";
+	echo "Archives into a directory or another archive is not supported";
+	return 1;
+	;;
+*\.gz$)
+	type="gzip"; uncomp="gunzip -dc"; ;;
+*\.bz$)
+	type="bzip"; uncomp="bunzip -dc"; ;;
+*\.bz2$)
+	type="bzip2"; uncomp="bunzip2 -dc"; ;;
+*\.zip$)
+	type="zip"; uncomp="unzip -d"; ;;
+*\.Z$)
+	type="compress"; uncomp="uncompress -c"; ;;
+*\.diff*)
+	type="diff"; uncomp="cat"; ;;
+*\.patch*)
+	type="patch"; uncomp="cat"; ;;
+*)
+	echo "Unsupported format file for ${1}, skip it";
+	return 0;
+	;;
+esac
+
+echo ""
+echo "Applying ${1} using ${type}: "
+echo ${1} | cat >> ${builddir}/.applied_patches_list
+${uncomp} ${1} | ${apply} ${builddir}
+if [ $? != 0 ] ; then
+	echo "Patch failed! Please fix ${1}!"
+	return 1
 fi
+}
+
+
+# entry point
+builddir=${1}
+patchdir=${2}
+shift 2
+patchlist=${@}
+patchesdir="${builddir}/../$(basename $builddir)-patches"
+
+# check directories
 if [ ! -d "${patchdir}" ] ; then
-    echo "Aborting.  '${patchdir}' is not a directory."
-    exit 1
+	echo "Aborting: ${patchdir} is not a directory."
+	exit 1
 fi
-    
-for i in `cd ${patchdir}; ls -d ${patchpattern} 2> /dev/null` ; do 
-    apply="patch -g0 -p1 -E -d"
-    uncomp_parm=""
-    if [ -d "${patchdir}/$i" ] ; then
-	type="directory overlay"
-	uncomp="tar cf - --exclude=.svn --no-anchored -C"
-	uncomp_parm="."
-	apply="tar xvf - -C"
-    else case "$i" in
-	*.gz)
-	type="gzip"; uncomp="gunzip -dc"; ;; 
-	*.bz)
-	type="bzip"; uncomp="bunzip -dc"; ;; 
-	*.bz2)
-	type="bzip2"; uncomp="bunzip2 -dc"; ;; 
-	*.zip)
-	type="zip"; uncomp="unzip -d"; ;; 
-	*.Z)
-	type="compress"; uncomp="uncompress -c"; ;; 
-	*.tgz)
-	type="tar gzip"; uncomp="gunzip -dc"; apply="tar xvf - -C"; ;; 
-	*.tar)
-	type="tar"; uncomp="cat"; apply="tar xvf - -C"; ;; 
-	*)
-	type="plaintext"; uncomp="cat"; ;; 
-    esac fi
-    echo ""
-    echo "Applying ${i} using ${type}: " 
-	echo ${i} | cat >> ${targetdir}/.applied_patches_list
-    ${uncomp} ${patchdir}/${i} ${uncomp_parm} | ${apply} ${targetdir} 
-    if [ $? != 0 ] ; then
-        echo "Patch failed!  Please fix $i!"
+if [ ! -d "${builddir}" ] ; then
+	echo "Aborting: ${builddir} is not a directory."
 	exit 1
-    fi
+fi
+
+# parse patch list, extract archives, apply patches
+for i in $patchlist ; do
+	# for remote files, directory is buildroot dl dir
+	#if echo $i | grep -q -E "^http://|^ftp://" ; then
+	#	patchdir=$patchdir
+	#else
+	#	patchdir=$(dirname $i)
+	#fi
+	patch_path="${patchdir}/${i}"
+	# three cases: directory, archive, file patch (compressed or not)
+	# directory
+	if [ -d "${patch_path}" ] ; then
+		for p in $(ls ${patch_path}) ; do
+			apply_patch "${patch_path}/${p}" || exit 1
+		done
+	# archive
+	elif echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$|tar\.gz$|tgz$" ; then
+		mkdir "${patchesdir}"
+		# extract archive
+		if echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$" ; then
+			tar_options="-xjf"
+		else
+			tar_options="-xzf"
+		fi
+		tar -C ${patchesdir} --strip-components=1 ${tar_options} ${patch_path}
+		# apply patches from the archive
+		#echo ${patchesdir}
+		#find ${patchesdir} | sort
+		for p in $(find ${patchesdir} | sort) ; do
+			apply_patch "${p}" || { rm -rf "${patchesdir}" ; exit 1; }
+		done
+		rm -rf "${patchesdir}"
+	# file which is not an archive
+	else
+		# we can have regex into patch name as package*.patch.arm that's
+		# why using ls
+		for p in $(ls -d ${patch_path} 2> /dev/null) ; do
+			apply_patch "${p}" || exit 1
+		done
+	fi
 done
 
-# Check for rejects...
-if [ "`find $targetdir/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
+# check for rejects...
+if [ "`find ${builddir}/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
     echo "Aborting.  Reject files found."
     exit 1
 fi
 
-# Remove backup files
-find $targetdir/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+# remove backup files
+find ${builddir}/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+

1.7.5.4
index 1aef47e..0492e01 100755

@@ -1,66 +1,117 @@
-#! /bin/bash
-# A little script I whipped up to make it easy to
-# patch source trees and have sane error handling
-# -Erik
-#
-# (c) 2002 Erik Andersen <[email protected]>
+#!/bin/bash

-# Set directories from arguments, or use defaults.
-targetdir=${1-.}
-patchdir=${2-../kernel-patches}
-shift 2
-patchpattern=${@-*}
+# function apply_patch patch_file
+# this function no more deal with directory case since it is managed
+# in an upper layer
+function apply_patch {
+apply="patch -p1 -E -d"
+#if [ ! -e "${1}" ] ; then
+# ? ? ?echo "${1} is not a file"
+# ? ? ?exit 1
+#fi
 
-if [ ! -d "${targetdir}" ] ; then
- ? ?echo "Aborting. ?'${targetdir}' is not a directory."
- ? ?exit 1
+case "${1}" in
+*\.tar\.gz$|*\.tgz$|*\.tar\.bz$|*\.tar\.bz2$|*\.tbz$|*\.tbz2$)
+ ? ? ? echo "Error with ${1}";
+ ? ? ? echo "Archives into a directory or another archive is not supported";
+ ? ? ? return 1;
+ ? ? ? ;;
+*\.gz$)
+ ? ? ? type="gzip"; uncomp="gunzip -dc"; ;;
+*\.bz$)
+ ? ? ? type="bzip"; uncomp="bunzip -dc"; ;;
+*\.bz2$)
+ ? ? ? type="bzip2"; uncomp="bunzip2 -dc"; ;;
+*\.zip$)
+ ? ? ? type="zip"; uncomp="unzip -d"; ;;
+*\.Z$)
+ ? ? ? type="compress"; uncomp="uncompress -c"; ;;
+*\.diff*)
+ ? ? ? type="diff"; uncomp="cat"; ;;
+*\.patch*)
+ ? ? ? type="patch"; uncomp="cat"; ;;
+*)
+ ? ? ? echo "Unsupported format file for ${1}, skip it";
+ ? ? ? return 0;
+ ? ? ? ;;
+esac
+
+echo ""
+echo "Applying ${1} using ${type}: "
+echo ${1} | cat >> ${builddir}/.applied_patches_list
+${uncomp} ${1} | ${apply} ${builddir}
+if [ $? != 0 ] ; then
+ ? ? ? echo "Patch failed! Please fix ${1}!"
+ ? ? ? return 1

+}
+
+
+# entry point
+builddir=${1}
+patchdir=${2}
+shift 2
+patchlist=${@}
+patchesdir="${builddir}/../$(basename $builddir)-patches"
+
+# check directories

-
-for i in `cd ${patchdir}; ls -d ${patchpattern} 2> /dev/null` ; do
- ? ?apply="patch -g0 -p1 -E -d"
- ? ?uncomp_parm=""
- ? ?if [ -d "${patchdir}/$i" ] ; then
- ? ? ? type="directory overlay"
- ? ? ? uncomp="tar cf - --exclude=.svn --no-anchored -C"
- ? ? ? uncomp_parm="."
- ? ? ? apply="tar xvf - -C"
- ? ?else case "$i" in
- ? ? ? *.gz)
- ? ? ? type="gzip"; uncomp="gunzip -dc"; ;;
- ? ? ? *.bz)
- ? ? ? type="bzip"; uncomp="bunzip -dc"; ;;
- ? ? ? *.bz2)
- ? ? ? type="bzip2"; uncomp="bunzip2 -dc"; ;;
- ? ? ? *.zip)
- ? ? ? type="zip"; uncomp="unzip -d"; ;;
- ? ? ? *.Z)
- ? ? ? type="compress"; uncomp="uncompress -c"; ;;
- ? ? ? *.tgz)
- ? ? ? type="tar gzip"; uncomp="gunzip -dc"; apply="tar xvf - -C"; ;;
- ? ? ? *.tar)
- ? ? ? type="tar"; uncomp="cat"; apply="tar xvf - -C"; ;;
- ? ? ? *)
- ? ? ? type="plaintext"; uncomp="cat"; ;;
- ? ?esac fi
- ? ?echo ""
- ? ?echo "Applying ${i} using ${type}: "
- ? ? ? echo ${i} | cat >> ${targetdir}/.applied_patches_list
- ? ?${uncomp} ${patchdir}/${i} ${uncomp_parm} | ${apply} ${targetdir}
- ? ?if [ $? != 0 ] ; then
- ? ? ? ?echo "Patch failed! ?Please fix $i!"
+if [ ! -d "${builddir}" ] ; then
+ ? ? ? echo "Aborting: ${builddir} is not a directory."

+fi
+
+# parse patch list, extract archives, apply patches
+for i in $patchlist ; do
+ ? ? ? # for remote files, directory is buildroot dl dir
+ ? ? ? #if echo $i | grep -q -E "^http://|^ftp://" ; then
+ ? ? ? # ? ? ? patchdir=$patchdir
+ ? ? ? #else
+ ? ? ? # ? ? ? patchdir=$(dirname $i)
+ ? ? ? #fi
+ ? ? ? patch_path="${patchdir}/${i}"
+ ? ? ? # three cases: directory, archive, file patch (compressed or not)
+ ? ? ? # directory
+ ? ? ? if [ -d "${patch_path}" ] ; then
+ ? ? ? ? ? ? ? for p in $(ls ${patch_path}) ; do
+ ? ? ? ? ? ? ? ? ? ? ? apply_patch "${patch_path}/${p}" || exit 1
+ ? ? ? ? ? ? ? done
+ ? ? ? # archive
+ ? ? ? elif echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$|tar\.gz$|tgz$" ; then
+ ? ? ? ? ? ? ? mkdir "${patchesdir}"
+ ? ? ? ? ? ? ? # extract archive
+ ? ? ? ? ? ? ? if echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$" ; then
+ ? ? ? ? ? ? ? ? ? ? ? tar_options="-xjf"
+ ? ? ? ? ? ? ? else
+ ? ? ? ? ? ? ? ? ? ? ? tar_options="-xzf"
+ ? ? ? ? ? ? ? fi
+ ? ? ? ? ? ? ? tar -C ${patchesdir} --strip-components=1 ${tar_options} ${patch_path}
+ ? ? ? ? ? ? ? # apply patches from the archive
+ ? ? ? ? ? ? ? #echo ${patchesdir}
+ ? ? ? ? ? ? ? #find ${patchesdir} | sort
+ ? ? ? ? ? ? ? for p in $(find ${patchesdir} | sort) ; do
+ ? ? ? ? ? ? ? ? ? ? ? apply_patch "${p}" || { rm -rf "${patchesdir}" ; exit 1; }
+ ? ? ? ? ? ? ? done
+ ? ? ? ? ? ? ? rm -rf "${patchesdir}"
+ ? ? ? # file which is not an archive
+ ? ? ? else
+ ? ? ? ? ? ? ? # we can have regex into patch name as package*.patch.arm that's
+ ? ? ? ? ? ? ? # why using ls
+ ? ? ? ? ? ? ? for p in $(ls -d ${patch_path} 2> /dev/null) ; do
+ ? ? ? ? ? ? ? ? ? ? ? apply_patch "${p}" || exit 1
+ ? ? ? ? ? ? ? done
+ ? ? ? fi

-# Check for rejects...
-if [ "`find $targetdir/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
+# check for rejects...
+if [ "`find ${builddir}/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then

-# Remove backup files
-find $targetdir/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+# remove backup files
+find ${builddir}/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+
--

index 1aef47e..0492e01 100755
@@ -1,66 +1,117 @@
-#! /bin/bash
-# A little script I whipped up to make it easy to
-# patch source trees and have sane error handling
-# -Erik
-#

-# (c) 2002 Erik Andersen <[email protected]>
+#!/bin/bash

-# Set directories from arguments, or use defaults.
-targetdir=${1-.}
-patchdir=${2-../kernel-patches}
-shift 2
-patchpattern=${@-*}
+# function apply_patch patch_file
+# this function no more deal with directory case since it is managed
+# in an upper layer
+function apply_patch {
+apply="patch -p1 -E -d"
+#if [ ! -e "${1}" ] ; then
+# ? ? ?echo "${1} is not a file"
+# ? ? ?exit 1
+#fi
 
-if [ ! -d "${targetdir}" ] ; then
- ? ?echo "Aborting. ?'${targetdir}' is not a directory."
- ? ?exit 1
+case "${1}" in
+*\.tar\.gz$|*\.tgz$|*\.tar\.bz$|*\.tar\.bz2$|*\.tbz$|*\.tbz2$)
+ ? ? ? echo "Error with ${1}";
+ ? ? ? echo "Archives into a directory or another archive is not supported";
+ ? ? ? return 1;
+ ? ? ? ;;
+*\.gz$)
+ ? ? ? type="gzip"; uncomp="gunzip -dc"; ;;
+*\.bz$)
+ ? ? ? type="bzip"; uncomp="bunzip -dc"; ;;
+*\.bz2$)
+ ? ? ? type="bzip2"; uncomp="bunzip2 -dc"; ;;
+*\.zip$)
+ ? ? ? type="zip"; uncomp="unzip -d"; ;;
+*\.Z$)
+ ? ? ? type="compress"; uncomp="uncompress -c"; ;;
+*\.diff*)
+ ? ? ? type="diff"; uncomp="cat"; ;;
+*\.patch*)
+ ? ? ? type="patch"; uncomp="cat"; ;;
+*)
+ ? ? ? echo "Unsupported format file for ${1}, skip it";
+ ? ? ? return 0;
+ ? ? ? ;;
+esac
+
+echo ""
+echo "Applying ${1} using ${type}: "
+echo ${1} | cat >> ${builddir}/.applied_patches_list
+${uncomp} ${1} | ${apply} ${builddir}
+if [ $? != 0 ] ; then
+ ? ? ? echo "Patch failed! Please fix ${1}!"
+ ? ? ? return 1

+}
+
+
+# entry point
+builddir=${1}
+patchdir=${2}
+shift 2
+patchlist=${@}
+patchesdir="${builddir}/../$(basename $builddir)-patches"
+
+# check directories

-
-for i in `cd ${patchdir}; ls -d ${patchpattern} 2> /dev/null` ; do
- ? ?apply="patch -g0 -p1 -E -d"
- ? ?uncomp_parm=""
- ? ?if [ -d "${patchdir}/$i" ] ; then
- ? ? ? type="directory overlay"
- ? ? ? uncomp="tar cf - --exclude=.svn --no-anchored -C"
- ? ? ? uncomp_parm="."
- ? ? ? apply="tar xvf - -C"
- ? ?else case "$i" in
- ? ? ? *.gz)
- ? ? ? type="gzip"; uncomp="gunzip -dc"; ;;
- ? ? ? *.bz)
- ? ? ? type="bzip"; uncomp="bunzip -dc"; ;;
- ? ? ? *.bz2)
- ? ? ? type="bzip2"; uncomp="bunzip2 -dc"; ;;
- ? ? ? *.zip)
- ? ? ? type="zip"; uncomp="unzip -d"; ;;
- ? ? ? *.Z)
- ? ? ? type="compress"; uncomp="uncompress -c"; ;;
- ? ? ? *.tgz)
- ? ? ? type="tar gzip"; uncomp="gunzip -dc"; apply="tar xvf - -C"; ;;
- ? ? ? *.tar)
- ? ? ? type="tar"; uncomp="cat"; apply="tar xvf - -C"; ;;
- ? ? ? *)
- ? ? ? type="plaintext"; uncomp="cat"; ;;
- ? ?esac fi
- ? ?echo ""
- ? ?echo "Applying ${i} using ${type}: "
- ? ? ? echo ${i} | cat >> ${targetdir}/.applied_patches_list
- ? ?${uncomp} ${patchdir}/${i} ${uncomp_parm} | ${apply} ${targetdir}
- ? ?if [ $? != 0 ] ; then
- ? ? ? ?echo "Patch failed! ?Please fix $i!"
+if [ ! -d "${builddir}" ] ; then
+ ? ? ? echo "Aborting: ${builddir} is not a directory."

+fi
+
+# parse patch list, extract archives, apply patches
+for i in $patchlist ; do
+ ? ? ? # for remote files, directory is buildroot dl dir
+ ? ? ? #if echo $i | grep -q -E "^http://|^ftp://" ; then
+ ? ? ? # ? ? ? patchdir=$patchdir
+ ? ? ? #else
+ ? ? ? # ? ? ? patchdir=$(dirname $i)
+ ? ? ? #fi
+ ? ? ? patch_path="${patchdir}/${i}"
+ ? ? ? # three cases: directory, archive, file patch (compressed or not)
+ ? ? ? # directory
+ ? ? ? if [ -d "${patch_path}" ] ; then
+ ? ? ? ? ? ? ? for p in $(ls ${patch_path}) ; do
+ ? ? ? ? ? ? ? ? ? ? ? apply_patch "${patch_path}/${p}" || exit 1
+ ? ? ? ? ? ? ? done
+ ? ? ? # archive
+ ? ? ? elif echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$|tar\.gz$|tgz$" ; then
+ ? ? ? ? ? ? ? mkdir "${patchesdir}"
+ ? ? ? ? ? ? ? # extract archive
+ ? ? ? ? ? ? ? if echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$" ; then
+ ? ? ? ? ? ? ? ? ? ? ? tar_options="-xjf"
+ ? ? ? ? ? ? ? else
+ ? ? ? ? ? ? ? ? ? ? ? tar_options="-xzf"
+ ? ? ? ? ? ? ? fi
+ ? ? ? ? ? ? ? tar -C ${patchesdir} --strip-components=1 ${tar_options} ${patch_path}
+ ? ? ? ? ? ? ? # apply patches from the archive
+ ? ? ? ? ? ? ? #echo ${patchesdir}
+ ? ? ? ? ? ? ? #find ${patchesdir} | sort
+ ? ? ? ? ? ? ? for p in $(find ${patchesdir} | sort) ; do
+ ? ? ? ? ? ? ? ? ? ? ? apply_patch "${p}" || { rm -rf "${patchesdir}" ; exit 1; }
+ ? ? ? ? ? ? ? done
+ ? ? ? ? ? ? ? rm -rf "${patchesdir}"
+ ? ? ? # file which is not an archive
+ ? ? ? else
+ ? ? ? ? ? ? ? # we can have regex into patch name as package*.patch.arm that's
+ ? ? ? ? ? ? ? # why using ls
+ ? ? ? ? ? ? ? for p in $(ls -d ${patch_path} 2> /dev/null) ; do
+ ? ? ? ? ? ? ? ? ? ? ? apply_patch "${p}" || exit 1
+ ? ? ? ? ? ? ? done
+ ? ? ? fi

-# Check for rejects...
-if [ "`find $targetdir/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
+# check for rejects...
+if [ "`find ${builddir}/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then

-# Remove backup files
-find $targetdir/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+# remove backup files
+find ${builddir}/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+
--

index 1aef47e..0492e01 100755
@@ -1,66 +1,117 @@
-#! /bin/bash
-# A little script I whipped up to make it easy to
-# patch source trees and have sane error handling
-# -Erik
-#

-# (c) 2002 Erik Andersen <[email protected]>
+#!/bin/bash

-# Set directories from arguments, or use defaults.
-targetdir=${1-.}
-patchdir=${2-../kernel-patches}
-shift 2
-patchpattern=${@-*}
+# function apply_patch patch_file
+# this function no more deal with directory case since it is managed
+# in an upper layer
+function apply_patch {
+apply="patch -p1 -E -d"
+#if [ ! -e "${1}" ] ; then
+# ? ? ?echo "${1} is not a file"
+# ? ? ?exit 1
+#fi
 
-if [ ! -d "${targetdir}" ] ; then
- ? ?echo "Aborting. ?'${targetdir}' is not a directory."
- ? ?exit 1
+case "${1}" in
+*\.tar\.gz$|*\.tgz$|*\.tar\.bz$|*\.tar\.bz2$|*\.tbz$|*\.tbz2$)
+ ? ? ? echo "Error with ${1}";
+ ? ? ? echo "Archives into a directory or another archive is not supported";
+ ? ? ? return 1;
+ ? ? ? ;;
+*\.gz$)
+ ? ? ? type="gzip"; uncomp="gunzip -dc"; ;;
+*\.bz$)
+ ? ? ? type="bzip"; uncomp="bunzip -dc"; ;;
+*\.bz2$)
+ ? ? ? type="bzip2"; uncomp="bunzip2 -dc"; ;;
+*\.zip$)
+ ? ? ? type="zip"; uncomp="unzip -d"; ;;
+*\.Z$)
+ ? ? ? type="compress"; uncomp="uncompress -c"; ;;
+*\.diff*)
+ ? ? ? type="diff"; uncomp="cat"; ;;
+*\.patch*)
+ ? ? ? type="patch"; uncomp="cat"; ;;
+*)
+ ? ? ? echo "Unsupported format file for ${1}, skip it";
+ ? ? ? return 0;
+ ? ? ? ;;
+esac
+
+echo ""
+echo "Applying ${1} using ${type}: "
+echo ${1} | cat >> ${builddir}/.applied_patches_list
+${uncomp} ${1} | ${apply} ${builddir}
+if [ $? != 0 ] ; then
+ ? ? ? echo "Patch failed! Please fix ${1}!"
+ ? ? ? return 1

+}
+
+
+# entry point
+builddir=${1}
+patchdir=${2}
+shift 2
+patchlist=${@}
+patchesdir="${builddir}/../$(basename $builddir)-patches"
+
+# check directories

-
-for i in `cd ${patchdir}; ls -d ${patchpattern} 2> /dev/null` ; do
- ? ?apply="patch -g0 -p1 -E -d"
- ? ?uncomp_parm=""
- ? ?if [ -d "${patchdir}/$i" ] ; then
- ? ? ? type="directory overlay"
- ? ? ? uncomp="tar cf - --exclude=.svn --no-anchored -C"
- ? ? ? uncomp_parm="."
- ? ? ? apply="tar xvf - -C"
- ? ?else case "$i" in
- ? ? ? *.gz)
- ? ? ? type="gzip"; uncomp="gunzip -dc"; ;;
- ? ? ? *.bz)
- ? ? ? type="bzip"; uncomp="bunzip -dc"; ;;
- ? ? ? *.bz2)
- ? ? ? type="bzip2"; uncomp="bunzip2 -dc"; ;;
- ? ? ? *.zip)
- ? ? ? type="zip"; uncomp="unzip -d"; ;;
- ? ? ? *.Z)
- ? ? ? type="compress"; uncomp="uncompress -c"; ;;
- ? ? ? *.tgz)
- ? ? ? type="tar gzip"; uncomp="gunzip -dc"; apply="tar xvf - -C"; ;;
- ? ? ? *.tar)
- ? ? ? type="tar"; uncomp="cat"; apply="tar xvf - -C"; ;;
- ? ? ? *)
- ? ? ? type="plaintext"; uncomp="cat"; ;;
- ? ?esac fi
- ? ?echo ""
- ? ?echo "Applying ${i} using ${type}: "
- ? ? ? echo ${i} | cat >> ${targetdir}/.applied_patches_list
- ? ?${uncomp} ${patchdir}/${i} ${uncomp_parm} | ${apply} ${targetdir}
- ? ?if [ $? != 0 ] ; then
- ? ? ? ?echo "Patch failed! ?Please fix $i!"
+if [ ! -d "${builddir}" ] ; then
+ ? ? ? echo "Aborting: ${builddir} is not a directory."

+fi
+
+# parse patch list, extract archives, apply patches
+for i in $patchlist ; do
+ ? ? ? # for remote files, directory is buildroot dl dir
+ ? ? ? #if echo $i | grep -q -E "^http://|^ftp://" ; then
+ ? ? ? # ? ? ? patchdir=$patchdir
+ ? ? ? #else
+ ? ? ? # ? ? ? patchdir=$(dirname $i)
+ ? ? ? #fi
+ ? ? ? patch_path="${patchdir}/${i}"
+ ? ? ? # three cases: directory, archive, file patch (compressed or not)
+ ? ? ? # directory
+ ? ? ? if [ -d "${patch_path}" ] ; then
+ ? ? ? ? ? ? ? for p in $(ls ${patch_path}) ; do
+ ? ? ? ? ? ? ? ? ? ? ? apply_patch "${patch_path}/${p}" || exit 1
+ ? ? ? ? ? ? ? done
+ ? ? ? # archive
+ ? ? ? elif echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$|tar\.gz$|tgz$" ; then
+ ? ? ? ? ? ? ? mkdir "${patchesdir}"
+ ? ? ? ? ? ? ? # extract archive
+ ? ? ? ? ? ? ? if echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$" ; then
+ ? ? ? ? ? ? ? ? ? ? ? tar_options="-xjf"
+ ? ? ? ? ? ? ? else
+ ? ? ? ? ? ? ? ? ? ? ? tar_options="-xzf"
+ ? ? ? ? ? ? ? fi
+ ? ? ? ? ? ? ? tar -C ${patchesdir} --strip-components=1 ${tar_options} ${patch_path}
+ ? ? ? ? ? ? ? # apply patches from the archive
+ ? ? ? ? ? ? ? #echo ${patchesdir}
+ ? ? ? ? ? ? ? #find ${patchesdir} | sort
+ ? ? ? ? ? ? ? for p in $(find ${patchesdir} | sort) ; do
+ ? ? ? ? ? ? ? ? ? ? ? apply_patch "${p}" || { rm -rf "${patchesdir}" ; exit 1; }
+ ? ? ? ? ? ? ? done
+ ? ? ? ? ? ? ? rm -rf "${patchesdir}"
+ ? ? ? # file which is not an archive
+ ? ? ? else
+ ? ? ? ? ? ? ? # we can have regex into patch name as package*.patch.arm that's
+ ? ? ? ? ? ? ? # why using ls
+ ? ? ? ? ? ? ? for p in $(ls -d ${patch_path} 2> /dev/null) ; do
+ ? ? ? ? ? ? ? ? ? ? ? apply_patch "${p}" || exit 1
+ ? ? ? ? ? ? ? done
+ ? ? ? fi

-# Check for rejects...
-if [ "`find $targetdir/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
+# check for rejects...
+if [ "`find ${builddir}/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then

-# Remove backup files
-find $targetdir/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+# remove backup files
+find ${builddir}/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+
--

---
 support/scripts/apply-patches.sh |  135 +++++++++++++++++++++++++-------------
 1 files changed, 89 insertions(+), 46 deletions(-)
index 1aef47e..2a25606 100755
@@ -5,62 +5,105 @@
 #
 # (c) 2002 Erik Andersen <[email protected]>
 
-# Set directories from arguments, or use defaults.
-targetdir=${1-.}
-patchdir=${2-../kernel-patches}
-shift 2
-patchpattern=${@-*}
+# function apply_patch patch_file
+# This function no more deals with directory case since it is managed
+# in an upper layer
+function apply_patch {
+apply="patch -p1 -E -d"
 
-if [ ! -d "${targetdir}" ] ; then
-    echo "Aborting.  '${targetdir}' is not a directory."
-    exit 1
+case "${1}" in
+*\.tar\.gz$|*\.tgz$|*\.tar\.bz$|*\.tar\.bz2$|*\.tbz$|*\.tbz2$)
+	echo "Error with ${1}";
+	echo "Archives into a directory or another archive is not supported";
+	return 1;
+	;;
+*\.gz$)
+	type="gzip"; uncomp="gunzip -dc"; ;;
+*\.bz$)
+	type="bzip"; uncomp="bunzip -dc"; ;;
+*\.bz2$)
+	type="bzip2"; uncomp="bunzip2 -dc"; ;;
+*\.zip$)
+	type="zip"; uncomp="unzip -d"; ;;
+*\.Z$)
+	type="compress"; uncomp="uncompress -c"; ;;
+*\.diff*)
+	type="diff"; uncomp="cat"; ;;
+*\.patch*)
+	type="patch"; uncomp="cat"; ;;
+*)
+	echo "Unsupported format file for ${1}, skip it";
+	return 0;
+	;;
+esac
+
+echo ""
+echo "Applying ${1} using ${type}: "
+echo ${1} | cat >> ${builddir}/.applied_patches_list
+${uncomp} ${1} | ${apply} ${builddir}
+if [ $? != 0 ] ; then
+	echo "Patch failed! Please fix ${1}!"
+	return 1
 fi
+}
+
+
+# Entry point
+builddir=${1}
+patchdir=${2}
+shift 2
+patchlist=${@}
+patchesdir="${builddir}/../$(basename $builddir)-patches"
+
+# Check directories
 if [ ! -d "${patchdir}" ] ; then
-    echo "Aborting.  '${patchdir}' is not a directory."
-    exit 1
+	echo "Aborting: ${patchdir} is not a directory."
+	exit 1
 fi
-    
-for i in `cd ${patchdir}; ls -d ${patchpattern} 2> /dev/null` ; do 
-    apply="patch -g0 -p1 -E -d"
-    uncomp_parm=""
-    if [ -d "${patchdir}/$i" ] ; then
-	type="directory overlay"
-	uncomp="tar cf - --exclude=.svn --no-anchored -C"
-	uncomp_parm="."
-	apply="tar xvf - -C"
-    else case "$i" in
-	*.gz)
-	type="gzip"; uncomp="gunzip -dc"; ;; 
-	*.bz)
-	type="bzip"; uncomp="bunzip -dc"; ;; 
-	*.bz2)
-	type="bzip2"; uncomp="bunzip2 -dc"; ;; 
-	*.zip)
-	type="zip"; uncomp="unzip -d"; ;; 
-	*.Z)
-	type="compress"; uncomp="uncompress -c"; ;; 
-	*.tgz)
-	type="tar gzip"; uncomp="gunzip -dc"; apply="tar xvf - -C"; ;; 
-	*.tar)
-	type="tar"; uncomp="cat"; apply="tar xvf - -C"; ;; 
-	*)
-	type="plaintext"; uncomp="cat"; ;; 
-    esac fi
-    echo ""
-    echo "Applying ${i} using ${type}: " 
-	echo ${i} | cat >> ${targetdir}/.applied_patches_list
-    ${uncomp} ${patchdir}/${i} ${uncomp_parm} | ${apply} ${targetdir} 
-    if [ $? != 0 ] ; then
-        echo "Patch failed!  Please fix $i!"
+if [ ! -d "${builddir}" ] ; then
+	echo "Aborting: ${builddir} is not a directory."
 	exit 1
-    fi
+fi
+
+# Parse patch list, extract archives, apply patches
+for i in $patchlist ; do
+	patch_path="${patchdir}/${i}"
+	# three cases: directory, archive, file patch (compressed or not)
+	# directory
+	if [ -d "${patch_path}" ] ; then
+		for p in $(ls ${patch_path}) ; do
+			apply_patch "${patch_path}/${p}" || exit 1
+		done
+	# archive
+	elif echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$|tar\.gz$|tgz$" ; then
+		mkdir "${patchesdir}"
+		# extract archive
+		if echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$" ; then
+			tar_options="-xjf"
+		else
+			tar_options="-xzf"
+		fi
+		tar -C ${patchesdir} --strip-components=1 ${tar_options} ${patch_path}
+		# apply patches from the archive
+		for p in $(find ${patchesdir} | sort) ; do
+			apply_patch "${p}" || { rm -rf "${patchesdir}" ; exit 1; }
+		done
+		rm -rf "${patchesdir}"
+	# file which is not an archive
+	else
+		# we can have regex into patch name as package*.patch.arm that's
+		# why using ls
+		for p in $(ls -d ${patch_path} 2> /dev/null) ; do
+			apply_patch "${p}" || exit 1
+		done
+	fi
 done
 
 # Check for rejects...
-if [ "`find $targetdir/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
+if [ "`find ${builddir}/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
     echo "Aborting.  Reject files found."
     exit 1
 fi
 
 # Remove backup files
-find $targetdir/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+find ${builddir}/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;

1.7.5.4
---
 support/scripts/apply-patches.sh |  135 +++++++++++++++++++++++++-------------
 1 files changed, 89 insertions(+), 46 deletions(-)
index 1aef47e..2a25606 100755
@@ -5,62 +5,105 @@
 #

 # (c) 2002 Erik Andersen <[email protected]>
 
-# Set directories from arguments, or use defaults.
-targetdir=${1-.}
-patchdir=${2-../kernel-patches}
-shift 2
-patchpattern=${@-*}
+# function apply_patch patch_file
+# This function no more deals with directory case since it is managed
+# in an upper layer

+function apply_patch {

+apply="patch -p1 -E -d"

-if [ ! -d "${targetdir}" ] ; then
-    echo "Aborting.  '${targetdir}' is not a directory."
-    exit 1
+case "${1}" in
+*\.tar\.gz$|*\.tgz$|*\.tar\.bz$|*\.tar\.bz2$|*\.tbz$|*\.tbz2$)
+	echo "Error with ${1}";
+	echo "Archives into a directory or another archive is not supported";
+	return 1;

+	;;
+*\.gz$)
+	type="gzip"; uncomp="gunzip -dc"; ;;
+*\.bz$)
+	type="bzip"; uncomp="bunzip -dc"; ;;
+*\.bz2$)
+	type="bzip2"; uncomp="bunzip2 -dc"; ;;
+*\.zip$)
+	type="zip"; uncomp="unzip -d"; ;;
+*\.Z$)
+	type="compress"; uncomp="uncompress -c"; ;;
+*\.diff*)
+	type="diff"; uncomp="cat"; ;;
+*\.patch*)

+	type="patch"; uncomp="cat"; ;;
+*)
+	echo "Unsupported format file for ${1}, skip it";
+	return 0;
+	;;
+esac
+
+echo ""
+echo "Applying ${1} using ${type}: "
+echo ${1} | cat >> ${builddir}/.applied_patches_list

+${uncomp} ${1} | ${apply} ${builddir}

+if [ $? != 0 ] ; then
+	echo "Patch failed! Please fix ${1}!"
+	return 1
 fi
+}
+
+
+# Entry point
+builddir=${1}
+patchdir=${2}

+shift 2
+patchlist=${@}

+patchesdir="${builddir}/../$(basename $builddir)-patches"

+
+# Check directories
 if [ ! -d "${patchdir}" ] ; then
-    echo "Aborting.  '${patchdir}' is not a directory."
-    exit 1
+	echo "Aborting: ${patchdir} is not a directory."
+	exit 1

 fi
-    
-for i in `cd ${patchdir}; ls -d ${patchpattern} 2> /dev/null` ; do 
-    apply="patch -g0 -p1 -E -d"
-    uncomp_parm=""
-    if [ -d "${patchdir}/$i" ] ; then
-	type="directory overlay"
-	uncomp="tar cf - --exclude=.svn --no-anchored -C"
-	uncomp_parm="."
-	apply="tar xvf - -C"
-    else case "$i" in
-	*.gz)
-	type="gzip"; uncomp="gunzip -dc"; ;; 
-	*.bz)
-	type="bzip"; uncomp="bunzip -dc"; ;; 
-	*.bz2)
-	type="bzip2"; uncomp="bunzip2 -dc"; ;; 
-	*.zip)
-	type="zip"; uncomp="unzip -d"; ;; 
-	*.Z)
-	type="compress"; uncomp="uncompress -c"; ;; 
-	*.tgz)
-	type="tar gzip"; uncomp="gunzip -dc"; apply="tar xvf - -C"; ;; 
-	*.tar)
-	type="tar"; uncomp="cat"; apply="tar xvf - -C"; ;; 
-	*)
-	type="plaintext"; uncomp="cat"; ;; 
-    esac fi
-    echo ""
-    echo "Applying ${i} using ${type}: " 
-	echo ${i} | cat >> ${targetdir}/.applied_patches_list
-    ${uncomp} ${patchdir}/${i} ${uncomp_parm} | ${apply} ${targetdir} 
-    if [ $? != 0 ] ; then
-        echo "Patch failed!  Please fix $i!"
+if [ ! -d "${builddir}" ] ; then
+	echo "Aborting: ${builddir} is not a directory."
 	exit 1
-    fi
+fi
+
+# Parse patch list, extract archives, apply patches
+for i in $patchlist ; do

+	patch_path="${patchdir}/${i}"
+	# three cases: directory, archive, file patch (compressed or not)
+	# directory
+	if [ -d "${patch_path}" ] ; then
+		for p in $(ls ${patch_path}) ; do
+			apply_patch "${patch_path}/${p}" || exit 1
+		done
+	# archive
+	elif echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$|tar\.gz$|tgz$" ; then
+		mkdir "${patchesdir}"

+		# extract archive
+		if echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$" ; then
+			tar_options="-xjf"
+		else
+			tar_options="-xzf"
+		fi
+		tar -C ${patchesdir} --strip-components=1 ${tar_options} ${patch_path}

+		# apply patches from the archive
+		for p in $(find ${patchesdir} | sort) ; do
+			apply_patch "${p}" || { rm -rf "${patchesdir}" ; exit 1; }
+		done
+		rm -rf "${patchesdir}"

+	# file which is not an archive
+	else
+		# we can have regex into patch name as package*.patch.arm that's

+		# why using ls
+		for p in $(ls -d ${patch_path} 2> /dev/null) ; do
+			apply_patch "${p}" || exit 1
+		done
+	fi
 done
 
 # Check for rejects...

-if [ "`find $targetdir/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
+if [ "`find ${builddir}/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
     echo "Aborting.  Reject files found."
     exit 1
 fi
 
 # Remove backup files
-find $targetdir/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+find ${builddir}/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
 

Arnout Vandecappelle                               arnout at mind be
Senior Embedded Software Architect                 +32-16-286540
Essensium/Mind                                     http://www.mind.be
G.Geenslaan 9, 3001 Leuven, Belgium                BE 872 984 063 RPR Leuven
LinkedIn profile: http://www.linkedin.com/in/arnoutvandecappelle
GPG fingerprint:  7CB5 E4CC 6C2E EFD4 6E3D A754 F963 ECAB 2450 2F1F
---
 support/scripts/apply-patches.sh |  135 +++++++++++++++++++++++++-------------
 1 files changed, 89 insertions(+), 46 deletions(-)
index 1aef47e..2a25606 100755
@@ -5,62 +5,105 @@
 #
 # (c) 2002 Erik Andersen <[email protected]>
 

-# Set directories from arguments, or use defaults.
-targetdir=${1-.}
-patchdir=${2-../kernel-patches}
-shift 2
-patchpattern=${@-*}
+# function apply_patch patch_file
+# This function no more deals with directory case since it is managed
+# in an upper layer

+function apply_patch {

+apply="patch -p1 -E -d"

-if [ ! -d "${targetdir}" ] ; then
-    echo "Aborting.  '${targetdir}' is not a directory."
-    exit 1
+case "${1}" in
+*\.tar\.gz$|*\.tgz$|*\.tar\.bz$|*\.tar\.bz2$|*\.tbz$|*\.tbz2$)
+	echo "Error with ${1}";
+	echo "Archives into a directory or another archive is not supported";
+	return 1;

+	;;
+*\.gz$)
+	type="gzip"; uncomp="gunzip -dc"; ;;
+*\.bz$)
+	type="bzip"; uncomp="bunzip -dc"; ;;
+*\.bz2$)
+	type="bzip2"; uncomp="bunzip2 -dc"; ;;
+*\.zip$)
+	type="zip"; uncomp="unzip -d"; ;;
+*\.Z$)
+	type="compress"; uncomp="uncompress -c"; ;;
+*\.diff*)
+	type="diff"; uncomp="cat"; ;;
+*\.patch*)
+	type="patch"; uncomp="cat"; ;;
+*)
+	echo "Unsupported format file for ${1}, skip it";
+	return 0;

+	;;
+esac
+
+echo ""
+echo "Applying ${1} using ${type}: "
+echo ${1} | cat >> ${builddir}/.applied_patches_list

+${uncomp} ${1} | ${apply} ${builddir}

+if [ $? != 0 ] ; then
+	echo "Patch failed! Please fix ${1}!"
+	return 1
 fi
+}
+
+
+# Entry point
+builddir=${1}
+patchdir=${2}

+shift 2
+patchlist=${@}

+patchesdir="${builddir}/../$(basename $builddir)-patches"

+
+# Check directories
 if [ ! -d "${patchdir}" ] ; then
-    echo "Aborting.  '${patchdir}' is not a directory."
-    exit 1
+	echo "Aborting: ${patchdir} is not a directory."
+	exit 1

 fi
-    
-for i in `cd ${patchdir}; ls -d ${patchpattern} 2> /dev/null` ; do 
-    apply="patch -g0 -p1 -E -d"
-    uncomp_parm=""
-    if [ -d "${patchdir}/$i" ] ; then
-	type="directory overlay"
-	uncomp="tar cf - --exclude=.svn --no-anchored -C"
-	uncomp_parm="."
-	apply="tar xvf - -C"
-    else case "$i" in
-	*.gz)
-	type="gzip"; uncomp="gunzip -dc"; ;; 
-	*.bz)
-	type="bzip"; uncomp="bunzip -dc"; ;; 
-	*.bz2)
-	type="bzip2"; uncomp="bunzip2 -dc"; ;; 
-	*.zip)
-	type="zip"; uncomp="unzip -d"; ;; 
-	*.Z)
-	type="compress"; uncomp="uncompress -c"; ;; 
-	*.tgz)
-	type="tar gzip"; uncomp="gunzip -dc"; apply="tar xvf - -C"; ;; 
-	*.tar)
-	type="tar"; uncomp="cat"; apply="tar xvf - -C"; ;; 
-	*)
-	type="plaintext"; uncomp="cat"; ;; 
-    esac fi
-    echo ""
-    echo "Applying ${i} using ${type}: " 
-	echo ${i} | cat >> ${targetdir}/.applied_patches_list
-    ${uncomp} ${patchdir}/${i} ${uncomp_parm} | ${apply} ${targetdir} 
-    if [ $? != 0 ] ; then
-        echo "Patch failed!  Please fix $i!"
+if [ ! -d "${builddir}" ] ; then
+	echo "Aborting: ${builddir} is not a directory."
 	exit 1
-    fi
+fi
+
+# Parse patch list, extract archives, apply patches
+for i in $patchlist ; do
+	patch_path="${patchdir}/${i}"
+	# three cases: directory, archive, file patch (compressed or not)
+	# directory
+	if [ -d "${patch_path}" ] ; then

+		for p in $(ls ${patch_path}) ; do
+			apply_patch "${patch_path}/${p}" || exit 1
+		done
+	# archive
+	elif echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$|tar\.gz$|tgz$" ; then
+		mkdir "${patchesdir}"

+		# extract archive
+		if echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$" ; then
+			tar_options="-xjf"
+		else
+			tar_options="-xzf"
+		fi
+		tar -C ${patchesdir} --strip-components=1 ${tar_options} ${patch_path}

+		# apply patches from the archive
+		for p in $(find ${patchesdir} | sort) ; do
+			apply_patch "${p}" || { rm -rf "${patchesdir}" ; exit 1; }
+		done
+		rm -rf "${patchesdir}"

+	# file which is not an archive
+	else
+		# we can have regex into patch name as package*.patch.arm that's

+		# why using ls
+		for p in $(ls -d ${patch_path} 2> /dev/null) ; do
+			apply_patch "${p}" || exit 1
+		done
+	fi
 done
 
 # Check for rejects...
-if [ "`find $targetdir/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
+if [ "`find ${builddir}/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
     echo "Aborting.  Reject files found."
     exit 1
 fi
 

 # Remove backup files
-find $targetdir/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
+find ${builddir}/ '(' -name '*.orig' -o -name '.*.orig' ')' -exec rm -f {} \;
 

Arnout Vandecappelle                               arnout at mind be
Senior Embedded Software Architect                 +32-16-286540
Essensium/Mind                                     http://www.mind.be
G.Geenslaan 9, 3001 Leuven, Belgium                BE 872 984 063 RPR Leuven
LinkedIn profile: http://www.linkedin.com/in/arnoutvandecappelle
GPG fingerprint:  7CB5 E4CC 6C2E EFD4 6E3D A754 F963 ECAB 2450 2F1F
-if [ ! -d "${targetdir}" ] ; then
-    echo "Aborting.  '${targetdir}' is not a directory."
-    exit 1
+case "${1}" in
+*\.tar\.gz$|*\.tgz$|*\.tar\.bz$|*\.tar\.bz2$|*\.tbz$|*\.tbz2$)
+	echo "Error with ${1}";
+	echo "Archives into a directory or another archive is not supported";
+	return 1;

+# Entry point
+builddir=${1}
+patchdir=${2}

+		# extract archive
+		if echo $i | grep -q -E "tar\.bz$|tar\.bz2$|tbz$|tbz2$" ; then
+			tar_options="-xjf"
+		else
+			tar_options="-xzf"
+		fi
+		tar -C ${patchesdir} --strip-components=1 ${tar_options} ${patch_path}

Arnout Vandecappelle                               arnout at mind be
Senior Embedded Software Architect                 +32-16-286540
Essensium/Mind                                     http://www.mind.be
G.Geenslaan 9, 3001 Leuven, Belgium                BE 872 984 063 RPR Leuven
LinkedIn profile: http://www.linkedin.com/in/arnoutvandecappelle
GPG fingerprint:  7CB5 E4CC 6C2E EFD4 6E3D A754 F963 ECAB 2450 2F1F
---
 support/scripts/apply-patches.sh |    7 +++++++
 1 files changed, 7 insertions(+), 0 deletions(-)
index 2a25606..a15b5c1 100755
@@ -64,6 +64,13 @@ if [ ! -d "${builddir}" ] ; then
 	echo "Aborting: ${builddir} is not a directory."
 	exit 1
 fi
+# check for rejects because if there are some, even if patches are well
+# applied, at the end it will complain about rejects into buildir
+if [ "`find ${builddir}/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
+    echo "There are remaining rejecting file into ${buildir}, please delete them"
+    exit 1
+fi
+
 
 # Parse patch list, extract archives, apply patches
 for i in $patchlist ; do

1.7.5.4
---
 support/scripts/apply-patches.sh |    7 +++++++
 1 files changed, 7 insertions(+), 0 deletions(-)
index 2a25606..a15b5c1 100755

@@ -64,6 +64,13 @@ if [ ! -d "${builddir}" ] ; then
 	echo "Aborting: ${builddir} is not a directory."
 	exit 1
 fi
+# check for rejects because if there are some, even if patches are well
+# applied, at the end it will complain about rejects into buildir
+if [ "`find ${builddir}/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
+    echo "There are remaining rejecting file into ${buildir}, please delete them"

Arnout Vandecappelle                               arnout at mind be
Senior Embedded Software Architect                 +32-16-286540
Essensium/Mind                                     http://www.mind.be
G.Geenslaan 9, 3001 Leuven, Belgium                BE 872 984 063 RPR Leuven
LinkedIn profile: http://www.linkedin.com/in/arnoutvandecappelle
GPG fingerprint:  7CB5 E4CC 6C2E EFD4 6E3D A754 F963 ECAB 2450 2F1F
---
 support/scripts/apply-patches.sh |    7 +++++++
 1 files changed, 7 insertions(+), 0 deletions(-)
index 0492e01..4dafacb 100755
@@ -63,6 +63,13 @@ if [ ! -d "${builddir}" ] ; then
 	echo "Aborting: ${builddir} is not a directory."
 	exit 1
 fi
+# check for rejects because if there are some, even if patches are well
+# applied, at the end it will complain about rejects into buildir
+if [ "`find ${builddir}/ '(' -name '*.rej' -o -name '.*.rej' ')' -print`" ] ; then
+    echo "There are remaining rejecting file into ${buildir}, please delete them"
+    exit 1
+fi
+
 
 # parse patch list, extract archives, apply patches
 for i in $patchlist ; do

1.7.5.4

Patching method

Ludovic Desroches

Ludovic Desroches

Peter Korsgaard

Thomas Petazzoni

ludovic.desroches at atmel.com

ludovic.desroches at atmel.com

Michael S. Zick

Ludovic Desroches

ludovic.desroches at atmel.com

ludovic.desroches at atmel.com

Thomas De Schampheleire

Ludovic Desroches

Thomas De Schampheleire

ludovic.desroches at atmel.com

ludovic.desroches at atmel.com

Arnout Vandecappelle

Ludovic Desroches

Ludovic Desroches

Arnout Vandecappelle

ludovic.desroches at atmel.com

Arnout Vandecappelle

ludovic.desroches at atmel.com