LinuxQuestions.org
Help answer threads with 0 replies.
Go Back   LinuxQuestions.org > Forums > Linux Forums > Linux - Newbie
User Name
Password
Linux - Newbie This Linux forum is for members that are new to Linux.
Just starting out and have a question? If it is not in the man pages or the how-to's this is the place!

Notices


Reply
  Search this Thread
Old 11-15-2012, 01:41 PM   #1
Eddy25
LQ Newbie
 
Registered: Nov 2012
Posts: 4

Rep: Reputation: Disabled
Need help with a script


Hi; I'm trying to execute this script by typing : "sh repack-zImage.sh -u" in terminal. The zImage file is in the same working directory as the script.
But I'm getting the following error :
# sh repack-zImage.sh -u
repack-zImage.sh: 99: Syntax error: "(" unexpected
What am i doing wrong. Help please;
ps: other persons said they haven't had any problem when executing the script exactly the same way i'm doing. Very strange for me...
The script:

Code:
#!/bin/bash

version="Version 6,  by mizch <hcz@hczim.de>
Time-stamp: <2011-05-03 20:14:30 hcz>

Please refer to the thread on http://www.xda-developers.com for
questions and remarks about this program."

# Copyright (C) 2011 by Heike C. Zimmerer <hcz@hczim.de>
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, version 3 of the License. For
# details see <http://www.gnu.org/licenses/>.


### Preparation:
# You should have received cpio_set0 along with this program.
# Copy it into /usr/local/bin.
#
# The program will run without this (and emit an info message about
# using the normal cpio).  However, the compession result of the
# initramfs will be smaller and consistent if you use it.


### What the program does:
usage(){
    echo "\
Usage: $pname [-v] -u|-p|-z [<file name, default: zImage>]
Function: [Un]Pack a zImage (for modification, mainly of the initramfs)
Opts:
   -u         unpack an Image
   -p         pack an image from a directory structure created by
              a previous unpack
   -z         create <file name>.tar from <file name> (simple tar, nothing fancy)
   --version  print version info
   --help     print this help
   Play with the following three options to get best compression results:
   -s         use standard cpio (default: uses cpio_set0 if available)
   -g         use gen_init_cpio instead of cpio/cpio_set0 (ignores -s)
   -r         don't reorder initramfs according to the original layout
 
Debugging:
   -v     verbose (show commands and results as they are executed)
   -x     script debug (set -x)

   Options to help nail down which modified part causes booting to fail.
   Lower numbers override higher numbered options:
   -1     Use original piggy.gz+piggy_trailer
   -2     Use original piggy.gz
   -3     Use original piggy
   -4     Use original initramfs(_gz)+part3
   -5     Use original initramfs_cpio"
    exit $1
}


### Graphical display of the unpack process:
#
#  Each of the indented items on the same level is derived from the
#  single item one level higher.
#
#  zImage
# (split)
#   +---- decompression_code
#   +---- piggy.gz+piggy_trailer
#       (split)
#          +---- piggy.gz
#          |  (gunzip)
#          |      +---- piggy
#          |      ===== either (compressed initramfs) ====
#          |             |
#          |          (split via gunzip limits)
#          |             +---- kernel.img
#          |             +---- initramfs_gz+part3
#          |                  (split)
#          |                    +---- initramfs.cpio.gz
#          |                    |   (gunzip)
#          |                    |      +---- initramfs.cpio
#          |                    |           (cpio -i)
#          |                    |             +---- initramfs/
#          |                    +---- padding3
#          |                    +---- part3
#          |      ===== or (uncompressed initramfs) =====
#          |             |
#          |          (split at "0707")
#          |             +---- kernel.img
#          |             +---- initramfs+part3
#          |                  (split after "TRAILER!!!")
#          |                    +---- initramfs.cpio
#          |                    |    (cpio -i)
#          |                    |     +---- initramfs/
#          |                    +---- padding3
#          |                    +---- part3
#          +---- padding_piggy
#          +---- piggy_trailer
#
#

pname="${0##*/}"
args=("$@")
cur_dir="$(pwd)"

# file names:
decompression_code="decompression_code"
piggy_gz_piggy_trailer="piggy.gz+piggy_trailer"
piggy="piggy"
piggy_gz="piggy.gz"
padding_piggy="padding_piggy"
piggy_trailer="piggy_trailer"
ramfs_gz_part3="initramfs.cpio+part3"
ramfs_cpio_gz="initramfs.cpio.gz"
padding3="padding3"
part3="part3"
kernel_img="kernel.img"
ramfs_cpio="initramfs.cpio"
ramfs_dir="initramfs"
sizes="sizes"
ramfs_part3="ramfs+part3"
ramfs_list="initramfs_list"
cpio_t="cpio-t"


cpio="cpio_set0"

# We dup2 stderr to 3 so an error path is always available (even
# during commands where stderr is redirected to /dev/null).  If option
# -v is set, we dup2 sterr to 9 also so commands (and some of their
# results if redirected to &9) are printed also.
exec 9>/dev/null                # kill diagnostic ouput (will be >&2 if -v)
exec 3>&2                       # an always open error channel

#
########### Start of functions
#

# Emit an error message and abort
fatal(){
    # Syntax: fatal <string ...>
    # Output error message, then abort
    echo >&3
    echo >&3 "$pname: $*"
    kill $$
    exit 1
}

# Execute a command, displaying the command if -v:
cmd(){
    # Syntax: cmd <command> <args...>
    # Execute <command>, echo command line if -v
    echo >&9 "$*"
    "$@"
}

# Execute a required command, displaying the command if -v, abort on
# error:
rqd(){
    # Syntax: cmd <command> <args...>
    # Execute <command>, echo commandline if -v, abort on error
    cmd "$@" || fatal "$* failed."
}

relpath(){
    # Syntax: relpath <absolute_path>
    # Function: print a path below $cur_dir as relative path on stdout
    if [ "${1#$cur_dir}" != "$1" ]; then
        echo -n ".${1#$cur_dir}"
    else   # not below cur_dir
        echo -n "$1"
    fi
}

findByteSequence(){
    # Syntax: findByteSequence <fname> [<string, default: gzip header>]
    # Returns: position (offset) on stdout, empty string if nothing found
    file="$1"
    local opt
    if [ "$2" = "lzma" ]; then
        srch=$'\x5d....\xff\xff\xff\xff\xff'
        opt=
    else
        srch="${2:-$'\x1f\x8b\x08'}" # Default: search for gzip header
        opt="-F"
    fi
    pos=$(LC_ALL=C grep $opt -a --byte-offset -m 1 --only-matching -e "$srch" -- "$file")
    echo ${pos%%:*}
}

getFileSize(){
    # Syntax: getFileSize <file>
    # Returns size of the file on stdout.
    # Aborts if file doesn't exist.
    rqd stat -c %s "$1"
}

recordPackingFileSize()(
    # Syntax: recordPackingFileSize <file-var> ...
    #
    # dump out a file size from the packing directory for debugging.
    # Note that the whole function is running in a subshell, so we can
    # cd here.
    rqd cd "$packing"
    for file in "$@"; do
        eval local fnam=\$$file
        local size=$(getFileSize "$fnam")
        printf 'size_%s=%d	# %#x\n' $file $size $size  
    done >> "$sizes"
)

recordFileSize(){
    # Syntax: recordFileSize <file-var> ...
    # Dump a file size from the current directory into $sizes for
    # later sourcing as a shell script.
    for file in "$@"; do
        eval local fnam=\$$file
        local size=$(getFileSize "$fnam")
        printf 'size_%s=%d	# %#x\n' $file $size $size  
    done >> "$sizes"
}

recordVars(){
    # Syntax dumpVar <var-name>
    # Dumps var into file $sizes for later sourcing as a shell script
    for var in "$@"; do
        eval printf '"%s=\"%s\"\n"' $var \$$var \$$var  
    done >> "$sizes"
}

checkNUL(){
    # Syntax: checkNUL file offset
    # Returns true (0) if byte there is 0x0.
    [ "$(rqd 2>/dev/null dd if="$1" skip=$2 bs=1 count=1)" = $'\0' ]
}

# We can tell from the magic number where the start of a gzipped
# section is.  We cannot tell its exact end.  We could only know the
# end if we could get at the kernel's zeropage variables - which we
# can't since their position varies between versions and
# architectures.  The following function separates the gzipped part
# from trailing bytes (which can be possibly garbage, but who knows?)
# via successive aproximation.
gunzipWithTrailer(){
    # Syntax gunzipWithTrailer <file> <gzip name, sans .gz> <padding> <trailer>
    #
    # <file>: the input file 
    # <gzip name, sans .gz>, <padding>, <trailer>: 
    #   The output files.  For the gzipped part, both the
    #   compressed and the uncompressed output is generated, so we have
    #   4 output files.
    local file="$1"
    local gz_result="$2.gz"
    local result="$2"
    local padding="$3"
    local trailer="$4"
    local tmpfile="/tmp/gunzipWithTrailer.$$.gz"
    local original_size=$(getFileSize "$file")
    local d=$(( (original_size+1) / 2))
    local direction fini at_min=0
    local results_at_min=()
    local size=$d
    local at_min=0
    echo "Separating gzipped part from trailer in '$(relpath "$file")'"
    echo -n "Trying size: $size"
    while :; do
        rqd dd if="$file" of="$tmpfile" bs=$size count=1 2>/dev/null
        cmd gunzip >/dev/null 2>&1 -c "$tmpfile"
        res=$?
        if [ "$d" -eq 1 ]; then
            : $((at_min++))
            results_at_min[$size]=1
            [ "$at_min" -gt 3 ] && break
        fi
        d=$(((d+1)/2))
        case $res in
                # 1: too small
            1) size=$((size+d)); direction="↑";;
                # 2: trailing garbage
            2) size=$((size-d)); direction="↓";;
                # OK
            0) break;;
            *) fatal "gunzip returned $res while checking '$(relpath "$file")'";;
        esac
        echo -n "  $size"
    done
    if [ "$at_min" -gt 3 ]; then
        echo -e "\ngunzip result is oscillating between 'too small' and 'too large' at size: ${!results_at_min[*]}"
        echo -n "Trying lower nearby values:  "
        fini=
        for ((d=1; d < 30; d++)); do
            : $((size--))
            echo -n "  $size"
            rqd dd if="$file" of="$tmpfile" bs=$size count=1 2>/dev/null
            if cmd gunzip >/dev/null 2>&1 -c "$tmpfile"; then
                echo -n " - OK"
                fini=1
                break
            fi
        done
        [ -z "$fini" ] && fatal 'oscillating gunzip result, giving up.'
    fi
    # We've found the end of the gzipped part.  This is not the real
    # end since gzip allows for some trailing padding to be appended
    # before it barfs.  First, go back until we find a non-null
    # character:
    echo -ne "\npadding check (may take some time): "
    real_end=$((size-1))
    while checkNUL "$file" $real_end; do
        : $((real_end--))
    done
    # Second, try if gunzip still succeeds.  If not, add trailing
    # null(s) until it succeeds:
    while :; do
        rqd dd if="$file" of="$tmpfile" bs=$real_end count=1 2>/dev/null
        gunzip >/dev/null 2>&1 -c "$tmpfile"
        case $? in
            # 1: too small
            1) : $((real_end++));;
            *) break;;
        esac
    done
    real_next_start=$size
    # Now, skip NULs forward until we reach a non-null byte.  This is
    # considered as being the start of the next part.
    while checkNUL "$file" $real_next_start; do
        : $((real_next_start++))
    done
    echo $((real_next_start - real_end))
    echo
    rm "$tmpfile"
    # Using the numbers we got so far, create the output files which
    # reflect the parts we've found so far:
    rqd dd 2>&9 if="$file" of="$gz_result" bs=$real_end count=1
    rqd dd 2>&9 if="$file" of="$padding" skip=$real_end bs=1 count=$((real_next_start - real_end))
    rqd dd 2>&9 if="$file" of="$trailer" bs=$real_next_start skip=1
    rqd gunzip -c "$gz_result" > "$result"
}

# See the comment for gunzipWithTrailer (above) for what this function
# does:
unlzmaWithTrailer(){
    # Syntax unlzmaWithTrailer <file> <gzip name, sans .gz> <padding> <trailer>
    #
    # <file>: the input file 
    # <gzip name, sans .gz>, <padding>, <trailer>: 
    #   The output files.  For the lzma'd part, both the
    #   compressed and the uncompressed output is generated, so we have
    #   4 output files.
    local file="$1"
    local gz_result="$2.gz"
    local result="$2"
    local padding="$3"
    local trailer="$4"
    local tmpfile="/tmp/unlzmaWithTrailer.$$.gz"
    local original_size=$(getFileSize "$file")
    local d=$(( (original_size+1) / 2))
    local direction fini at_min=0
    local results_at_min=()
    local size=$d
    local at_min=
    echo "Separating lzma'd part from trailer in '$(relpath "$file")'"
    echo -n "Trying size: $size"
    while :; do
        rqd dd if="$file" of="$tmpfile" bs=$size count=1 2>/dev/null
        cmd unlzma >/dev/null 2>&1 -S '' -c "$tmpfile"
        res=$?
        if [ "$d" -eq 1 ] && [ "$res" -eq 1 ]; then
            at_min=yes          # we're 1 below the result
        fi
        d=$(((d+1)/2))
        case $res in
                # 1: too small
            1) size=$((size+d)); direction="↑";;
                # 0: too large (or OK if d==1)
            0) if [ "$at_min" ]; then
                  break
               fi
               size=$((size-d)); direction="↓";;
            *) fatal "unlzma returned $res while checking '$(relpath "$file")'";;
        esac
        echo -n "  $size"
    done
    # Now, skip NULs forward until we reach a non-null byte.  This is
    # considered as being the start of the next part.
    echo
    echo -n "Detecting padding: "
    real_end="$size"
    real_next_start="$size"
    while checkNUL "$file" $real_next_start; do
        : $((real_next_start++))
    done
    echo $((real_next_start - real_end))
    echo
    rm "$tmpfile"
    # Using the numbers we got so far, create the output files which
    # reflect the parts we've found so far:
    rqd dd 2>&9 if="$file" of="$gz_result" bs=$real_end count=1
    rqd dd 2>&9 if="$file" of="$padding" skip=$real_end bs=1 count=$((real_next_start - real_end))
    rqd dd 2>&9 if="$file" of="$trailer" bs=$real_next_start skip=1
    rqd unlzma -c -S '' "$gz_result" > "$result"
}

padTo(){
    # Syntax: padTo <file> <size>
    # Pads <file> to <size> with trailung 0x0s
    # Does nothing if file matches size.
    # Aborts if <file> too large for the operation.
    local size=$(getFileSize "$1")
    local tmp="/tmp/$pname.$$.zeroes"
    if [ "$size" -eq "$2" ]; then
        echo  "$(relpath "$1"): size matches ($size)"
    elif [ "$size" -gt "$2" ]; then
        fatal "Size of '$(relpath "$1")' too large ($size > $2) (+$((size - $2)))"
    else
        echo "Padding '$(relpath "$1")' to $2 bytes (+$(($2 - size)))"
        rqd dd 2>&9 if=/dev/zero of="$tmp" count=1 bs=$(($2 - size))
        rqd cat "$tmp" >> "$1"
        rqd rm -f "$tmp"
    fi
}

padToMod(){
    # Syntax: padTo <modulo> <file>
    # Pads <file> until (size mod <modulo>) == 0.
    local modulo=$1
    local file="$2"
    local size=$(getFileSize "$file")
    local rest=$((size % modulo))
    if [ "$rest" -ne 0 ]; then
        padTo "$file" $((size + modulo - rest))
    fi
}

buildZImageTar(){
    # Syntax: buildZImageTar <path>
    # Generates tarred file from <path> into the same directory.
    # The file in the archive doesn't contain the path.
    # Also copies the result to /home/Shared if it detects
    # that it is running at home.
    local dir="${1%/*}"/
    [ "$dir" = "$1/" ]  && dir="$(pwd)/"
    (
        cd "$dir"
        rqd tar  cf zImage.tar zImage
    )
    echo "Generated file: '$(relpath "${dir}$zImage.tar")'"
    if [ "$HOSTNAME:$USER" = "Xelzbrot:hcz" ]; then
        cp "${dir}zImage.tar" /home/Shared
        echo "also copied to '/home/Shared'."
    fi
}

reorderInitramfsList(){
    # This is some black magic to get about the same compression
    # result as the original initramfs.cpio.  We reorder the files in
    # our initramfs (which is to be created) so that they appear in
    # the same order as in the original initramfs.
    #
    # Syntax: reorderInitramfsList <initramfs_list_file> <reordering_template_file>
    #
    # Reorders <initramfs_list_file> so that enries are in the order
    # given by <reordering_template_file> (which comes from cpio -t).
    # Files in <initramfs_list_file> but not in
    # <reordering_template_file> are moved in sorted order to the end.
    # Comments and empty lines are discarded.  The result is written
    # to <initramfs_list_file>.

    #echo >&2 "Reordering initramfs list"
    initramfs_list_file="$1"
    reordering_template_file="$2"
    declare -A ramfs_entries    # make it an associative array
    while read line; do
        set -- $line
        [ $# -eq 0 ] && continue # skip empty lines
        [[ "$1" = \#* ]] && continue # skip comments
        ramfs_entries["$2"]="$line"  # else remember line, indexed by path
    done < "$initramfs_list_file"
    echo "# reordered ramfs entries" > "$initramfs_list_file"
    # now spit the lines out in the order given by the reordering_template_file:
    while read path; do
        echo "${ramfs_entries["$path"]}"
        unset ramfs_entries["$path"] # remove written lines from the array
    done < "$reordering_template_file" >> "$initramfs_list_file"
    # if there are any files left, append them in sorted order so directories
    # come first:
    for line in "${ramfs_entries[@]}"; do
        echo "$line"
    done \
    | sort >> "$initramfs_list_file"
}

pack(){
    if ! find >/dev/null 2>&1 "$unpacked" "$unpacked/$ramfs" "$unpacked/$sizes" -maxdepth 0; then
        fatal "\
This does not look like a directory where a
previous unpack has been done."
    fi
      
    # create packing direcory
    rqd mkdir -p "$packing"

    sizes="$packing/sizes"
    echo "# Packing sizes" > "$sizes"

    # cd to unpacking directory (original and modified parts)
    rqd cd "$unpacked"
    # read in file size at the time of unpicking
    rqd source sizes

    if [ "$opt_1" ]; then
        rqd cp "$piggy_gz_piggy_trailer" "$packing"
    else
        if [ "$opt_2" ]; then
            rqd cp "$piggy_gz" "$packing"
        else
            if [ "$opt_3" ]; then
                rqd cp "$piggy" "$packing"
                compress_list=("$packing/$piggy") # compress it as a single file
            else
                if [ "$opt_4" ]; then
                    rqd cp "$ramfs_gz_part3" "$packing"
                else
                    if [ "$opt_5" ]; then
                        rqd cp "$ramfs_cpio" "$packing"
                    else
                        echo "Generating initramfs"
                        if ! which >/dev/null "$cpio"; then
                            if [ -n "$compressed" ]; then
                                echo "Info: '$cpio' not found, using normal cpio."
                                echo " This only means that your compressed initramfs will be slightly larger"
                                echo " and its size will differ from invocation to invocation."
                            fi
                            cpio="cpio"
                        fi
                        for ftime in "" "-a" "-m"; do
                            find "$ramfs_dir" -exec touch $ftime -d @0 {} \;
                        done
                        rqd gen_initramfs_list.sh -u squash -g squash "$ramfs_dir" > "$packing/$ramfs_list"
                        cp "$packing/$ramfs_list" "$packing/$ramfs_list.orig"
                        if [ -z "$opt_r" ]; then
                            # reorder so files are arranged as in original initramfs:
                            reorderInitramfsList "$packing/$ramfs_list" "$cpio_t"
                        else
                            # sort so directories come before their content:
                            sort < "$cpio_t" > "$packing/$cpio_t.sorted"
                            reorderInitramfsList "$packing/$ramfs_list" "packing/$cpio_t.sorted"
                        fi
                        if [ -z "$opt_g" ]; then
                            # No -g:  Use our own cpio routine
                            (
                                rqd cd "$ramfs_dir"
                                # extract the file names from our
                                # (possibly reordered) initramfs list
                                # and pass them to cpio:
                                while read line; do
                                    set -- $line
                                    [ $# -eq 0 ] && continue # skip empty lines
                                    [[ "$1" = \#* ]] && continue # skip comments
                                    echo "${2#/}"
                                done < "$packing/$ramfs_list" \
                                | rqd "$cpio" -H newc -R root:root -o  > "$packing/$ramfs_cpio"
                            )
                        else
                            # -g set: use gen_init_cpio (from kernel tree)
                            rqd gen_init_cpio "$packing/$ramfs_list" > "$packing/$ramfs_cpio"
                        fi
                        recordPackingFileSize ramfs_cpio
                    fi  # opt_5
                    
                    if [ "$compressed" = "gz" ]; then
                        echo "Creating gzip compressed initramfs"
                        rqd gzip -8 < "$packing/$ramfs_cpio" > "$packing/$ramfs_cpio_gz"
                        padTo "$packing/$ramfs_cpio_gz" "$((size_ramfs_cpio_gz + size_padding3))"
                        rqd cat "$packing/$ramfs_cpio_gz" "$part3" > "$packing/$ramfs_gz_part3"
                        recordPackingFileSize ramfs_cpio_gz ramfs_gz_part3
                    elif [ "$compressed" = "lzma" ]; then
                        echo "Creating lzma compressed initramfs"
                        rqd lzma -9  < "$packing/$ramfs_cpio" > "$packing/$ramfs_cpio_gz"
                        padTo "$packing/$ramfs_cpio_gz" "$((size_ramfs_cpio_gz + size_padding3))"
                        rqd cat "$packing/$ramfs_cpio_gz" "$part3" > "$packing/$ramfs_gz_part3"
                        recordPackingFileSize ramfs_cpio_gz ramfs_gz_part3
                    else
                        echo "initramfs is not compressed"
                    fi
                fi  # opt_4

                echo "Assembling piggy"
                if [ -n "$compressed" ]; then
                    rqd cat "$kernel_img" "$packing/$ramfs_gz_part3" > "$packing/$piggy"
                    compress_list=("$packing/$piggy") # compress it as a single file
                else
                    #touch "$packing/$padding3"
                    #padTo "$packing/$padding3" "$size_padding3"
                    padTo "$packing/$ramfs_cpio" $((size_ramfs_cpio + size_padding3))
                    # compress parts seperately (yields better compression results):
                    cat  "$kernel_img" "$packing/$ramfs_cpio" "$part3" > "$packing/$piggy"
                    recordPackingFileSize "piggy"
                    compress_list=("$packing/$piggy")
                fi
            fi  # opt_3
            echo "Creating piggy.gz"
            target_size=$((size_piggy_gz + size_padding_piggy))
            # At first, use gzip -9 for compressing since it delivers
            # better results with zImages most of the time:            
            rqd gzip -n -9 -c  "${compress_list[@]}" > "$packing/$piggy_gz"
            size1=$(getFileSize "$packing/$piggy_gz")
            if [  "$size1" -gt "$target_size" ]; then
                # too large.  Try if we can get better results with
                # gzip -8.  If not, barf and abort:
                rqd gzip -8 -n -c "${compress_list[@]}" > "$packing/$piggy_gz"
                size2=$(getFileSize "$packing/$piggy_gz")
                if [  "$size2" -gt "$target_size" ]; then
                    fatal "\
piggy.gz too large (gzip -9: +$((size1-target_size)), gzip -8: +$((size2-target_size)))
You might want to try a different combination of the -g, -r and -s options."
                fi
            fi
            padTo "$packing/$piggy_gz" "$((size_piggy_gz + size_padding_piggy))"
            recordPackingFileSize "piggy_gz"
        fi  # opt_2
        echo "Assembling $zImage"
        rqd cat "$packing/$piggy_gz" "$piggy_trailer" > "$packing/$piggy_gz_piggy_trailer"
    fi   # opt_1
    rqd cat "$decompression_code" "$packing/$piggy_gz_piggy_trailer" \
        > "$packing/$zImage"
    echo "Successfully created '$(relpath "$packing/$zImage")'"
    recordPackingFileSize zImage
    buildZImageTar "$packing/$zImage"
}

unpack()(
    [ -d "$unpacked" ] && echo "\
Warning: there is aready an unpacking directory.  If you have files added on 
your own there, the  repacking result may not reflect the result of the 
current unpacking process."
    rqd mkdir -p "$unpacked"
    rqd cd "$unpacked"
    sizes="$unpacked/sizes"
    echo "# Unpacking sizes" > "$sizes"

    piggy_start=$(findByteSequence "$cur_dir/$zImage")
    if [ -z "$piggy_start" ]; then
        fatal "Can't find a gzip header in file '$zImage'"
    fi
    
    rqd dd 2>&9 if="$cur_dir/$zImage" bs="$piggy_start" count=1 of="$decompression_code"
    rqd dd 2>&9 if="$cur_dir/$zImage" bs="$piggy_start" skip=1 of="$piggy_gz_piggy_trailer"
    recordFileSize decompression_code piggy_gz_piggy_trailer

    gunzipWithTrailer  "$piggy_gz_piggy_trailer" \
        "$piggy" "$padding_piggy" "$piggy_trailer"

    recordFileSize "piggy" "piggy_gz" "padding_piggy" "piggy_trailer"

    ramfs_gz_start=$( findByteSequence "$piggy" lzma)
    if [ -n "$ramfs_gz_start" ]; then
        echo "Found lzma compressed ramdisk."
        compressed=lzma
    else
        ramfs_gz_start=$( findByteSequence "$piggy")
        if [ -n "$ramfs_gz_start" ]; then
            echo "Found gzip compressed ramdisk."
            compressed=gz
        fi
    fi
    if [ "$compressed" ]; then
        rqd dd 2>&9 if="$piggy" of="$kernel_img" bs="$ramfs_gz_start" count=1
        rqd dd 2>&9 if="$piggy" of="$ramfs_gz_part3" bs="$ramfs_gz_start" skip=1
        if [ "$compressed" = "gz" ]; then
            rqd gunzipWithTrailer "$ramfs_gz_part3" "$ramfs_cpio" "$padding3" "$part3"
        else
            rqd unlzmaWithTrailer "$ramfs_gz_part3" "$ramfs_cpio" "$padding3" "$part3"
        fi
        recordFileSize "kernel_img" "ramfs_cpio_gz" "padding3" "ramfs_gz_part3" "ramfs_cpio" "part3"
        recordVars compressed

    else
        echo "Found uncompressed ramdisk."
        compressed=""

        initrd_start=$(findByteSequence "$piggy" "0707")
        [ -z "$initrd_start" ] && fatal "Cannot find cpio header"
        rqd dd 2>&9 if="$piggy" of="$kernel_img" bs="$initrd_start" count=1
        rqd dd 2>&9 if="$piggy" of="$ramfs_part3" bs="$initrd_start" skip=1

        initrd_end=$(findByteSequence "$ramfs_part3" "TRAILER!!!")
        [ -z "$initrd_end" ] && fatal "Cannot find cpio trailer"
        initrd_end=$((initrd_end + 10)) # skip trailer length
        initrd_end=$(( (initrd_end | 0x1ff) + 1)) # round up to block size (512)
        rqd dd 2>&9 if="$ramfs_part3" of="$ramfs_cpio" bs="$initrd_end" count=1

        real_next_start=$initrd_end
        echo -n "Detecting padding (may take some time): "
        while checkNUL "$ramfs_part3" $real_next_start; do
            : $((real_next_start++))
        done
        padding3_len=$((real_next_start - initrd_end))
        echo $padding3_len
        rqd dd 2>&9 if="$ramfs_part3" of="$padding3" skip="$initrd_end" count="$padding3_len" bs=1 
        rqd dd 2>&9 if="$ramfs_part3" of="$part3" bs="$real_next_start" skip=1

        recordFileSize "kernel_img" "padding3" "ramfs_part3" "ramfs_cpio" "part3"
        recordVars compressed
    fi
    echo "Unpacking initramfs"
    rqd cpio -t < "$ramfs_cpio" > "$cpio_t"
    rqd mkdir -p "$ramfs_dir"
    (
        rqd cd "$ramfs_dir"
        rqd cpio -i -m --no-absolute-filenames -d -u < "../$ramfs_cpio"
    )
    echo
    echo "Success."
    echo "The unpacked files and the initramfs directory are in '$(relpath "$unpacked")'."
)

#### start of main program
while getopts xv12345sgrpuhtz-: argv; do
    case $argv in
        p|u|z|1|2|3|4|5|t|r|g) eval opt_$argv=1;;
        v) exec 9>&2; opt_v=1;;
        s) cpio="cpio";;
        x) set -x;;
        -) if [ "$OPTARG" = "version" ]; then
              echo "$pname $version"
              exit 0
           else
              usage
           fi;;
        h|-) usage;;
        *) fatal "Illegal option";;
    esac
done
shift $((OPTIND-1))
zImage="${1:-zImage}"
unpacked="$cur_dir/${zImage}_unpacked"
packing="$cur_dir/${zImage}_packing"
shift
if [ -n "$*" ]; then
    fatal "Excess arguments: '$*'"
fi

if [ -n "$opt_z" ]; then
    buildZImageTar "$zImage"
fi
if [ -n "$opt_u" ]; then
    [ -f "$zImage" ] || fatal "file '$zImage': not found"
    unpack
fi
if [ -n "$opt_p" ]; then
    pack
fi
#if [ -n "$opt_t" ]; then        # for testing
#    reorderInitramfsList "$packing/$ramfs_list" "$unpacked/$cpio_t"
#fi
if [ -z "$opt_p$opt_u$opt_z$opt_t" ]; then
    echo >&2 "$pname: Need at least one of -u, -p, or -z."
    echo >&2 "$pname: Type '$pname --help' for usage info."
    exit 1
fi

exit
 
Old 11-15-2012, 03:24 PM   #2
markush
Senior Member
 
Registered: Apr 2007
Location: Germany
Distribution: Slackware
Posts: 3,979

Rep: Reputation: 850Reputation: 850Reputation: 850Reputation: 850Reputation: 850Reputation: 850Reputation: 850
Hello Eddy25, welcome to LQ,

the errormessage means that there is in line 99 of the script anything wrong with a paranthesis. I've copied the script in an editor, there is no parenthesis in line 99 (or before line 99)

Are you sure that the script you are executing is the same that you posted here?

Markus
 
Old 11-15-2012, 03:32 PM   #3
Eddy25
LQ Newbie
 
Registered: Nov 2012
Posts: 4

Original Poster
Rep: Reputation: Disabled
Quote:
Originally Posted by markush View Post
Hello Eddy25, welcome to LQ,

the errormessage means that there is in line 99 of the script anything wrong with a paranthesis. I've copied the script in an editor, there is no parenthesis in line 99 (or before line 99)

Are you sure that the script you are executing is the same that you posted here?

Markus
Yes it is the same i posted here.
I have juste made a copy / past.
 
Old 11-15-2012, 03:33 PM   #4
markush
Senior Member
 
Registered: Apr 2007
Location: Germany
Distribution: Slackware
Posts: 3,979

Rep: Reputation: 850Reputation: 850Reputation: 850Reputation: 850Reputation: 850Reputation: 850Reputation: 850
Well, where can I get such a zImage file in order to test it here?

Markus
 
Old 11-15-2012, 04:03 PM   #5
Eddy25
LQ Newbie
 
Registered: Nov 2012
Posts: 4

Original Poster
Rep: Reputation: Disabled
Quote:
Originally Posted by markush View Post
Well, where can I get such a zImage file in order to test it here?

Markus
I have it. It's a 5,7 MB file extracted from a Galaxy phone firmware.
Tell me please how can i send it to you.
Thanks a lot for helping..
 
Old 11-15-2012, 04:04 PM   #6
markush
Senior Member
 
Registered: Apr 2007
Location: Germany
Distribution: Slackware
Posts: 3,979

Rep: Reputation: 850Reputation: 850Reputation: 850Reputation: 850Reputation: 850Reputation: 850Reputation: 850
You don't need to send it, I'll search for such a file in the internet.

Markus
 
Old 11-15-2012, 04:07 PM   #7
colucix
LQ Guru
 
Registered: Sep 2003
Location: Bologna
Distribution: CentOS 6.5 OpenSuSE 12.3
Posts: 10,509

Rep: Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976
What if you run it as:
Code:
bash repack-zImage.sh -u
or make it executable and run it as:
Code:
./repack-zImage.sh -u
I suspect the problem is in
Code:
args=("$@")
since arrays are not available in compatibility mode, by invoking bash as sh.
 
1 members found this post helpful.
Old 11-15-2012, 04:26 PM   #8
Eddy25
LQ Newbie
 
Registered: Nov 2012
Posts: 4

Original Poster
Rep: Reputation: Disabled
Quote:
Originally Posted by colucix View Post
What if you run it as:
Code:
bash repack-zImage.sh -u
or make it executable and run it as:
Code:
./repack-zImage.sh -u
I suspect the problem is in
Code:
args=("$@")
since arrays are not available in compatibility mode, by invoking bash as sh.
WOW It worked by using bash instead of sh like you proposed.
Thanks very much...
Just for my own learning what is the difference between sh and bash instructions.
 
Old 11-15-2012, 04:44 PM   #9
colucix
LQ Guru
 
Registered: Sep 2003
Location: Bologna
Distribution: CentOS 6.5 OpenSuSE 12.3
Posts: 10,509

Rep: Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976Reputation: 1976
Basically when invoked as sh, bash enters in POSIX mode and many of the bashisms not strictly conformal to the POSIX standard are not available. You can find more details here and here.
 
  


Reply


Thread Tools Search this Thread
Search this Thread:

Advanced Search

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is Off
HTML code is Off



Similar Threads
Thread Thread Starter Forum Replies Last Post
Shell script/Perl Script to remove the string until it finds special character '_' pooppp Programming 1 07-13-2012 02:03 AM
Shell script, Perl script, command or utility to convert Binary to text Perseus Programming 26 07-12-2012 07:00 AM
[SOLVED] bash and xterm: how make apps started by and for a script persist when script terminates porphyry5 Linux - General 4 06-15-2011 02:27 PM
[SOLVED] Script question: create a shell script in kde to log in on a server with ssh c4719929 Linux - Newbie 1 01-31-2011 04:05 AM
How to get full path to script file inside script itself? And in case of sym links? maggus Linux - Newbie 3 05-28-2009 09:40 AM


All times are GMT -5. The time now is 06:59 PM.

Main Menu
Advertisement
My LQ
Write for LQ
LinuxQuestions.org is looking for people interested in writing Editorials, Articles, Reviews, and more. If you'd like to contribute content, let us know.
Main Menu
Syndicate
RSS1  Latest Threads
RSS1  LQ News
Twitter: @linuxquestions
Facebook: linuxquestions Google+: linuxquestions
Open Source Consulting | Domain Registration