This starts to fix the scripts so that they load from /usr/lib/crosutils

common.sh

 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 # Common constants for build scripts
 # This must evaluate properly for both /bin/bash and /bin/sh
 
 # All scripts should die on error unless commands are specifically excepted
 # by prefixing with '!' or surrounded by 'set +e' / 'set -e'.
 # TODO: Re-enable this once shflags is less prone to dying.
 #set -e
 
 # The number of jobs to pass to tools that can run in parallel (such as make
 # and dpkg-buildpackage
-NUM_JOBS=`grep -c "^processor" /proc/cpuinfo`
+NUM_JOBS=$(grep -c "^processor" /proc/cpuinfo)
 
-# Store location of the calling script.
-TOP_SCRIPT_DIR="${TOP_SCRIPT_DIR:-$(dirname $0)}"
+# Make sure we have the location and name of the calling script, using
+# the current value if it is already set.
+SCRIPT_LOCATION=${SCRIPT_LOCATION:-$(dirname "$(readlink -f "$0")")}
+SCRIPT_NAME=${SCRIPT_NAME:-$(basename "$0")}
 
 # Detect whether we're inside a chroot or not
 if [ -e /etc/debian_chroot ]
 then
   INSIDE_CHROOT=1
 else
   INSIDE_CHROOT=0
 fi
 
 # Construct a list of possible locations for the source tree.  This list is
@@ skipping 41 matching lines @@
 
 # Find root of source tree
 get_gclient_root
 
 # Canonicalize the directories for the root dir and the calling script.
 # readlink is part of coreutils and should be present even in a bare chroot.
 # This is better than just using
 #     FOO = "$(cd $FOO ; pwd)"
 # since that leaves symbolic links intact.
 # Note that 'realpath' is equivalent to 'readlink -f'.
-TOP_SCRIPT_DIR=`readlink -f $TOP_SCRIPT_DIR`
-GCLIENT_ROOT=`readlink -f $GCLIENT_ROOT`
+SCRIPT_LOCATION=$(readlink -f $SCRIPT_LOCATION)
+GCLIENT_ROOT=$(readlink -f $GCLIENT_ROOT)
 
 # Other directories should always be pathed down from GCLIENT_ROOT.
 SRC_ROOT="$GCLIENT_ROOT/src"
 SRC_INTERNAL="$GCLIENT_ROOT/src-internal"
 SCRIPTS_DIR="$SRC_ROOT/scripts"
 
 # Load developer's custom settings.  Default location is in scripts dir,
 # since that's available both inside and outside the chroot.  By convention,
 # settings from this file are variables starting with 'CHROMEOS_'
 CHROMEOS_DEV_SETTINGS="${CHROMEOS_DEV_SETTINGS:-$SCRIPTS_DIR/.chromeos_dev}"
-if [ -f $CHROMEOS_DEV_SETTINGS ]
-then
+if [ -f $CHROMEOS_DEV_SETTINGS ]; then
   # Turn on exit-on-error during custom settings processing
-  SAVE_OPTS=`set +o`
+  SAVE_OPTS=$(set +o)
   set -e
 
   # Read settings
   . $CHROMEOS_DEV_SETTINGS
 
   # Restore previous state of exit-on-error
   eval "$SAVE_OPTS"
 fi
 
 # Load shflags
 if [[ -f /usr/lib/shflags ]]; then
   . /usr/lib/shflags
 elif [ -f ./lib/shflags/shflags ]; then
-  . "./lib/shflags/shflags"
+  . ./lib/shflags/shflags
 else
   . "${SRC_ROOT}/scripts/lib/shflags/shflags"
 fi
 
 # Our local mirror
 DEFAULT_CHROMEOS_SERVER=${CHROMEOS_SERVER:-"http://build.chromium.org/mirror"}
 
 # Upstream mirrors and build suites come in 2 flavors
 #   DEV - development chroot, used to build the chromeos image
 #   IMG - bootable image, to run on actual hardware
@@ skipping 15 matching lines @@
 if [ -d $SRC_ROOT/overlays ]; then
   ALL_BOARDS=$(cd $SRC_ROOT/overlays;ls -1d overlay-* 2>&-|sed 's,overlay-,,g')
 fi
 # Strip CR
 ALL_BOARDS=$(echo $ALL_BOARDS)
 # Set a default BOARD
 #DEFAULT_BOARD=x86-generic # or...
 DEFAULT_BOARD=$(echo $ALL_BOARDS | awk '{print $NF}')
 
 # Enable --fast by default.
-DEFAULT_FAST="${FLAGS_TRUE}"
+DEFAULT_FAST=${FLAGS_TRUE}
 
 # Directory locations inside the dev chroot
 CHROOT_TRUNK_DIR="/home/$USER/trunk"
 
 # Install make for portage ebuilds.  Used by build_image and gmergefs.
 # TODO: Is /usr/local/autotest-chrome still used by anyone?
 DEFAULT_INSTALL_MASK="
   *.a
   *.la
   /etc/init.d
@@ skipping 53 matching lines @@
 case "$(basename $0)" in
   build_image.sh|build_platform_packages.sh|customize_rootfs.sh|make_chroot.sh)
   echo
   echo "$V_REVERSE============================================================"
   echo "===========================  WARNING  ======================"
   echo "============================================================$V_VIDOFF"
   echo
   echo "RUNNING OLD BUILD SYSTEM SCRIPTS. RUN THE PORTAGE-BASED BUILD HERE:"
   echo "http://www.chromium.org/chromium-os/building-chromium-os/portage-based-build"
   echo
-  if [ "$USER" != "chrome-bot" ]
-  then
+  if [ "$USER" != "chrome-bot" ]; then
     read -n1 -p "Press any key to continue using the OLD build system..."
     echo
     echo
   fi
   ;;
 esac
 
 # -----------------------------------------------------------------------------
 # Functions
 
 function setup_board_warning {
   echo
   echo "$V_REVERSE=================  WARNING  ======================$V_VIDOFF"
   echo
   echo "*** No default board detected in " \
     "$GCLIENT_ROOT/src/scripts/.default_board"
   echo "*** Either run setup_board with default flag set"
   echo "*** or echo |board_name| > $GCLIENT_ROOT/src/scripts/.default_board"
   echo
 }
 
 
 # Sets the default board variable for calling script
 function get_default_board {
   DEFAULT_BOARD=
 
   if [ -f "$GCLIENT_ROOT/src/scripts/.default_board" ] ; then
-    DEFAULT_BOARD=`cat "$GCLIENT_ROOT/src/scripts/.default_board"`
+    DEFAULT_BOARD=$(cat "$GCLIENT_ROOT/src/scripts/.default_board")
   fi
 }
 
 
 # Make a package
 function make_pkg_common {
   # Positional parameters from calling script.  :? means "fail if unset".
   set -e
   PKG_BASE=${1:?}
   shift
   set +e
 
   # All packages are built in the chroot
   assert_inside_chroot
 
   # Command line options
   DEFINE_string build_root "$DEFAULT_BUILD_ROOT" "Root of build output"
 
   # Parse command line and update positional args
   FLAGS "$@" || exit 1
   eval set -- "${FLAGS_ARGV}"
 
   # Die on any errors
   set -e
 
   # Make output dir
-  OUT_DIR="$FLAGS_build_root/x86/local_packages"
-  mkdir -p "$OUT_DIR"
+  local out_dir="$FLAGS_build_root/x86/local_packages"
+  mkdir -p "$out_dir"
 
   # Remove previous package from output dir
-  rm -f "$OUT_DIR"/${PKG_BASE}_*.deb
+  rm -f "$out_dir"/${PKG_BASE}_*.deb
 
   # Rebuild the package
-  pushd "$TOP_SCRIPT_DIR"
+  pushd "$SCRIPT_LOCATION"
   rm -f ../${PKG_BASE}_*.deb
   dpkg-buildpackage -b -tc -us -uc -j$NUM_JOBS
-  mv ../${PKG_BASE}_*.deb "$OUT_DIR"
+  mv ../${PKG_BASE}_*.deb "$out_dir"
   rm ../${PKG_BASE}_*.changes
   popd
 }
 
 # Enter a chroot and restart the current script if needed
 function restart_in_chroot_if_needed {
   # NB:  Pass in ARGV:  restart_in_chroot_if_needed "$@"
-  if [ $INSIDE_CHROOT -ne 1 ]
-  then
-    # Equivalent to enter_chroot.sh -- <current command>
+  if [ $INSIDE_CHROOT -ne 1 ]; then
+    local abspath=$(readlink -f "$0")
+    # strip everything up to (and including) /scripts/ from abspath
+    local path_from_scripts="${abspath##*/scripts/}"
     exec $SCRIPTS_DIR/enter_chroot.sh -- \
-      $CHROOT_TRUNK_DIR/src/scripts/$(basename $0) "$@"
+      "$CHROOT_TRUNK_DIR/src/scripts/$path_from_scripts" "$@"
   fi
 }
 
 # Fail unless we're inside the chroot.  This guards against messing up your
 # workstation.
 function assert_inside_chroot {
-  if [ $INSIDE_CHROOT -ne 1 ]
-  then
+  if [ $INSIDE_CHROOT -ne 1 ]; then
     echo "This script must be run inside the chroot.  Run this first:"
     echo "    $SCRIPTS_DIR/enter_chroot.sh"
     exit 1
   fi
 }
 
 # Fail if we're inside the chroot.  This guards against creating or entering
 # nested chroots, among other potential problems.
 function assert_outside_chroot {
-  if [ $INSIDE_CHROOT -ne 0 ]
-  then
+  if [ $INSIDE_CHROOT -ne 0 ]; then
     echo "This script must be run outside the chroot."
     exit 1
   fi
 }
 
 function assert_not_root_user {
-  if [ `id -u` = 0 ]; then
+  if [ $(id -u) = 0 ]; then
     echo "This script must be run as a non-root user."
     exit 1
   fi
 }
 
-# Install a package if it's not already installed
-function install_if_missing {
-  # Positional parameters from calling script.  :? means "fail if unset".
-  PKG_NAME=${1:?}
-  shift
-
-  if [ -z `which $PKG_NAME` ]
-  then
-    echo "Can't find $PKG_NAME; attempting to install it."
-    sudo apt-get --yes --force-yes install $PKG_NAME
-  fi
-}
-
 # Returns true if the input file is whitelisted.
 #
 # $1 - The file to check
 is_whitelisted() {
   local file=$1
   local whitelist="$FLAGS_whitelist"
   test -f "$whitelist" || (echo "Whitelist file missing ($whitelist)" && exit 1)
 
   local checksum=$(md5sum "$file" | awk '{ print $1 }')
   local count=$(sed -e "s/#.*$//" "${whitelist}" | grep -c "$checksum" \
@@ skipping 43 matching lines @@
 }
 
 function die {
   error "$1"
   exit 1
 }
 
 # Retry an emerge command according to $FLAGS_retries
 # The $EMERGE_JOBS flags will only be added the first time the command is run
 function eretry () {
-  local i=
+  local i
   for i in $(seq $FLAGS_retries); do
-    echo Retrying $*
-    $* $EMERGE_JOBS && return 0
+    echo "Retrying $@"
+    "$@" $EMERGE_JOBS && return 0
   done
-  $* && return 0
+  "$@" && return 0
   return 1
 }
 
 # Removes single quotes around parameter
 # Arguments:
 #   $1 - string which optionally has surrounding quotes
 # Returns:
 #   None, but prints the string without quotes.
 function remove_quotes() {
   echo "$1" | sed -e "s/^'//; s/'$//"
@@ skipping 27 matching lines @@
     sudo umount -d -l "${path}" || die "Failed to lazily unmount ${path}"
   fi
 }
 
 # Fixes symlinks that are incorrectly prefixed with the build root ${1}
 # rather than the real running root '/'.
 # TODO(sosa) - Merge setup - cleanup below with this method.
 fix_broken_symlinks() {
   local build_root="${1}"
   local symlinks=$(find "${build_root}/usr/local" -lname "${build_root}/*")
+  local symlink
   for symlink in ${symlinks}; do
     echo "Fixing ${symlink}"
     local target=$(ls -l "${symlink}" | cut -f 2 -d '>')
     # Trim spaces from target (bashism).
     target=${target/ /}
     # Make new target (removes rootfs prefix).
     new_target=$(echo ${target} | sed "s#${build_root}##")
 
     echo "Fixing symlink ${symlink}"
     sudo unlink "${symlink}"
@@ skipping 16 matching lines @@
 
   # If our var target is actually the standard var, we are cleaning up the
   # symlinks (could also check for /usr/local for the dev_image_target).
   if [ ${var_target} = "/var" ]; then
     echo "Cleaning up /usr/local symlinks for ${dev_image_root}"
   else
     echo "Setting up symlinks for /usr/local for ${dev_image_root}"
   fi
 
   # Set up symlinks that should point to ${dev_image_target}.
+  local path
   for path in usr local; do
     if [ -h "${dev_image_root}/${path}" ]; then
       sudo unlink "${dev_image_root}/${path}"
     elif [ -e "${dev_image_root}/${path}" ]; then
       die "${dev_image_root}/${path} should be a symlink if exists"
     fi
     sudo ln -s ${dev_image_target} "${dev_image_root}/${path}"
   done
 
   # Setup var symlink.
@@ skipping 45 matching lines @@
   printf '\000' |
     sudo dd of="$rootfs" seek=$((offset + ro_compat_offset)) \
             conv=notrunc count=1 bs=1
 }
 
 # Get current timestamp. Assumes common.sh runs at startup.
 start_time=$(date +%s)
 
 # Print time elsapsed since start_time.
 print_time_elapsed() {
-  end_time=$(date +%s)
-  elapsed_seconds="$(( $end_time - $start_time ))"
-  minutes="$(( $elapsed_seconds / 60 ))"
-  seconds="$(( $elapsed_seconds % 60 ))"
+  local end_time=$(date +%s)
+  local elapsed_seconds=$(($end_time - $start_time))
+  local minutes=$(($elapsed_seconds / 60))
+  local seconds=$(($elapsed_seconds % 60))
   echo "Elapsed time: ${minutes}m${seconds}s"
 }
 
 # This function is a place to put code to incrementally update the
 # chroot so that users don't need to fully re-make it.  It should
 # be called from scripts that are run _outside_ the chroot.
 #
 # Please put date information so it's easy to keep track of when
 # old hacks can be retired and so that people can detect when a
 # hack triggered when it shouldn't have.
 #
 # ${1} specifies the location of the chroot.
 chroot_hacks_from_outside() {
   # Give args better names.
-  local chroot_dir="${1}"
+  local chroot_dir=$1
 
   # Add root as a sudoer if not already done.
   if ! sudo grep -q '^root ALL=(ALL) ALL$' "${chroot_dir}/etc/sudoers" ; then
     info "Upgrading old chroot (pre 2010-10-19) - adding root to sudoers"
     sudo bash -c "echo root ALL=\(ALL\) ALL >> \"${chroot_dir}/etc/sudoers\""
   fi
 }
 
 # The board and variant command line options can be used in a number of ways
 # to specify the board and variant.  The board can encode both pieces of
 # information separated by underscores.  Or the variant can be passed using
 # the separate variant option.  This function extracts the canonical board and
 # variant information and provides it in the BOARD, VARIANT and BOARD_VARIANT
 # variables.
 get_board_and_variant() {
   local flags_board="${1}"
   local flags_variant="${2}"
 
   BOARD=$(echo "$flags_board" | cut -d '_' -f 1)
   VARIANT=${flags_variant:-$(echo "$flags_board" | cut -s -d '_' -f 2)}
 
   if [ -n "$VARIANT" ]; then
     BOARD_VARIANT="${BOARD}_${VARIANT}"
   else
     BOARD_VARIANT="${BOARD}"
   fi
 }