# output.
#
function parse_options {
- cmdline=
- cmdline1=
- cmdline2=
+ # Each command line argument will be written to its own file within the
+ # request package.
+ argc=1
+ arg_subst=
while test $# != 0
do
- advance_p=0
+ advance=0
dash_seen=0
# Start of a new token.
- first_token=$1
- until test $advance_p != 0
+ first_token="$1"
+ until test $advance != 0
do
# Identify the next option
first_char=`expr "$first_token" : '\(.\).*'`
test "X$long_option" != "X" || long_option=`expr "$first_token" : '--\(.*\)'`
case $long_option in
ssl)
- process_ssl $first_token
+ process_ssl "$first_token"
;;
server)
- process_server $first_token
+ process_server "$first_token"
;;
*)
- # An unknown or unimportant option.
- # Ignore it, but pass it on to the server.
- cmdline2="$cmdline2 $first_token"
+ # An unknown or unimportant option. Ignore it.
;;
esac
- advance_p=$(($advance_p + 1))
+ advance=$(($advance + 1))
break
fi
# It's not a lone dash, or a long option, so it's a short option string.
# then it could be the name of the script file.
if test "X$e_script" = "X" -a "X$script_file" = "X"; then
script_file="$first_token"
- cmdline1="$cmdline2"
- cmdline2=
- elif test "$first_char" != "'"; then
- cmdline2="$cmdline2 '$first_token'"
- else
- cmdline2="$cmdline2 $first_token"
+ script_file_argc=$argc
fi
- advance_p=$(($advance_p + 1))
+ advance=$(($advance + 1))
break
fi
fi
# We are at the start of an option. Look at the first character.
case $first_char in
a)
- get_arg $first_token $2
- process_a $stap_arg
+ get_arg $first_token "$2"
+ process_a "$stap_arg"
;;
B)
- get_arg $first_token $2
- cmdline2="${cmdline2} -$first_char '$stap_arg'"
+ get_arg $first_token "$2"
;;
c)
get_arg $first_token "$2"
process_c "$stap_arg"
;;
D)
- get_arg $first_token $2
- cmdline2="${cmdline2} -$first_char '$stap_arg'"
+ get_arg $first_token "$2"
;;
e)
get_arg $first_token "$2"
process_e "$stap_arg"
;;
I)
- get_arg $first_token $2
- process_I $stap_arg
+ get_arg $first_token "$2"
+ process_I "$stap_arg"
;;
k)
keep_temps=1
;;
l)
- get_arg $first_token $2
- cmdline2="${cmdline2} -$first_char '$stap_arg'"
+ get_arg $first_token "$2"
p_phase=2
;;
L)
- get_arg $first_token $2
- cmdline2="${cmdline2} -$first_char '$stap_arg'"
+ get_arg $first_token "$2"
p_phase=2
;;
m)
- get_arg $first_token $2
- process_m $stap_arg
+ get_arg $first_token "$2"
+ process_m "$stap_arg"
;;
o)
- get_arg $first_token $2
- process_o $stap_arg
+ get_arg $first_token "$2"
+ process_o "$stap_arg"
;;
p)
- get_arg $first_token $2
- process_p $stap_arg
+ get_arg $first_token "$2"
+ process_p "$stap_arg"
;;
r)
- get_arg $first_token $2
- process_r $stap_arg
+ get_arg $first_token "$2"
+ process_r "$stap_arg"
;;
R)
- get_arg $first_token $2
- process_R $stap_arg
+ get_arg $first_token "$2"
+ process_R "$stap_arg"
;;
s)
- get_arg $first_token $2
- cmdline2="${cmdline2} -$first_char '$stap_arg'"
+ get_arg $first_token "$2"
;;
S)
- get_arg $first_token $2
- cmdline2="${cmdline2} -$first_char '$stap_arg'"
+ get_arg $first_token "$2"
;;
v)
v_level=$(($v_level + 1))
;;
x)
- get_arg $first_token $2
- cmdline2="${cmdline2} -$first_char '$stap_arg'"
+ get_arg $first_token "$2"
;;
*)
- # An unknown or unimportant flag. Ignore it, but pass it on to the server.
+ # An unknown or unimportant flag.
;;
esac
- if test $advance_p = 0; then
+ if test $advance = 0; then
# Just another flag character. Consume it.
- cmdline2="$cmdline2 -$first_char"
first_token=`expr "$first_token" : '.\(.*\)'`
if test "X$first_token" = "X"; then
- advance_p=$(($advance_p + 1))
+ advance=$(($advance + 1))
fi
fi
done
# Consume the arguments we just processed.
- while test $advance_p != 0
+ while test $advance != 0
do
+ # Place the argument is a numbered file within our temp
+ # directory.
+ # o We don't write a newline at the end, since newline could be
+ # part of the argument.
+ # o We add an X to the beginning of the file
+ # in order to avoid having 'echo' interpret the output as
+ # its own option. We then remove the X.
+ # There must be a better way.
+ echo -n "X$1" > "$tmpdir_client/argv$argc"
+ sed -i "s|^X||" "$tmpdir_client/argv$argc"
+
+ # Does the final argument file contain client-side data
+ # which must be changed to server-side data?
+ if test "X$arg_subst" != "X" -a $advance = 1; then
+ sed -i "s|$stap_arg|$arg_subst|" "$tmpdir_client/argv$argc"
+ arg_subst=
+ fi
+
+ # Get the next argument.
shift
- advance_p=$(($advance_p - 1))
+ argc=$(($argc + 1))
+ advance=$(($advance - 1))
done
done
# If the script file was given and it's not '-', then replace it with its
- # client-temp-name in the command string.
+ # client-temp-name in its argument file.
if test "X$script_file" != "X"; then
local local_name
if test "$script_file" != "-"; then
local_name=`generate_client_temp_name "$script_file"`
else
- local_name="$script_file"
+ local_name="-"
fi
- cmdline="$cmdline1 'script/$local_name' $cmdline2"
- else
- cmdline="$cmdline2"
+ echo "script/$local_name" > "$tmpdir_client/argv$script_file_argc"
fi
# Processing based on final options settings
# We must have at least one usable certificate database.
test "X$local_ssl_dbs" != "X " -o "X$public_ssl_dbs" != "X" || \
fatal "No usable certificate databases found"
-
- # We can use any server if the phase is less than 4
- # But don't for now....
- #if test $p_phase -lt 4; then
- # find_all="--all"
- #fi
}
# function: get_arg FIRSTWORD SECONDWORD
# Advance to the next token, if the first one is exhausted.
if test "X$first" = "X"; then
- shift
- advance_p=$(($advance_p + 1))
- first=$1
+ advance=$(($advance + 1))
+ first="$2"
fi
stap_arg="$first"
- test "X$first" != "X" && advance_p=$(($advance_p + 1))
+ test "X$first" != "X" && advance=$(($advance + 1))
}
# function: process_ssl ARGUMENT
test "X$db" != "X" || \
fatal "Missing argument to --ssl"
- check_db $db || return
+ check_db "$db" || return
additional_local_ssl_dbs="$additional_local_ssl_dbs $db"
}
# Process the -c flag.
function process_c {
c_cmd="$1"
- cmdline2="${cmdline2} -c"
- test "X$c_cmd" != "X" && cmdline2="${cmdline2} '$c_cmd'"
}
# function: process_e ARGUMENT
# which may have already been identified.
if test "X$e_script" = "X"; then
e_script="$1"
- if test "X$script_file" != "X"; then
- cmdline2="$cmdline1 '$script_file' $cmdline2"
- cmdline1=
- script_file=
- fi
+ script_file=
fi
- cmdline2="${cmdline2} -e '$1'"
}
# function: process_I ARGUMENT
#
# Process the -I flag.
function process_I {
- local local_name=`include_file_or_directory tapsets $1`
- test "X$local_name" != "X" || return
- cmdline2="${cmdline2} -I 'tapsets/$local_name'"
+ test "X$1" = "X" && return
+ arg_subst=tapsets/`include_file_or_directory tapsets "$1"`
}
# function: process_m ARGUMENT
function process_m {
module_name="$1"
m_name="$1"
- cmdline2="${cmdline2} -m '$1'"
}
# function: process_o ARGUMENT
# Process the -o flag.
function process_o {
stdout_redirection="$1"
- cmdline2="${cmdline2} -o '$1'"
}
# function: process_p ARGUMENT
#
# Process the -p flag.
function process_p {
- p_phase=$1
- cmdline2="${cmdline2} -p '$1'"
+ p_phase="$1"
}
# function: process_r ARGUMENT
local first_char=`expr "$1" : '\(.\).*'`
if test "$first_char" = "/"; then # fully specified path
- kernel_build_tree=$1
+ kernel_build_tree="$1"
version_file_name="$kernel_build_tree/include/config/kernel.release"
# The file include/config/kernel.release within the
# build tree is used to pull out the version information
- release=`cat $version_file_name 2>/dev/null`
+ release=`cat "$version_file_name" 2>/dev/null`
if test "X$release" = "X"; then
fatal "Missing $version_file_name"
return
fi
else
# kernel release specified directly
- release=$1
+ release="$1"
fi
if test "X$release" != "X$uname_r"; then
- uname_r=$release
+ uname_r="$release"
find_all="--all"
fi
}
# Process the -a flag.
function process_a {
if test "X$1" != "X$arch"; then
- arch=$1
+ arch="$1"
find_all="--all"
fi
}
#
# Process the -R flag.
function process_R {
- local local_name=`include_file_or_directory runtime $1`
- test "X$local_name" != "X" || return
- cmdline2="${cmdline2} -R 'runtime/$local_name'"
+ test "X$1" = "X" && return
+ arg_subst=runtime/`include_file_or_directory runtime "$1"`
}
# function: include_file_or_directory PREFIX NAME
# directory, but only if the file or directory exists.
local local_name=`generate_client_temp_name "$2"`
echo "$local_name"
- test -e /$local_name || return
+ test -e "/$local_name" || return
local local_dirname=`dirname "$local_name"`
mkdir -p "$tmpdir_client/$1/$local_dirname" || \
fi
# Add the necessary info to special files in our temporary directory.
- echo "cmdline: $cmdline" > cmdline
echo "sysinfo: `client_sysinfo`" > sysinfo
}
zip_client=$tmpdir_env/`mktemp $tmpdir_client_base.zip.XXXXXX` || \
fatal "Cannot create temporary file " $zip_client
- (rm $zip_client && zip -r $zip_client $tmpdir_client_base > /dev/null) || \
+ cd $tmpdir_client
+ (rm -f $zip_client && zip -r $zip_client * > /dev/null) || \
fatal "zip of request tree, $tmpdir_client, failed"
}
unzip -d $tmpdir_server $zip_server > /dev/null || \
fatal "Cannot unpack server response, $zip_server"
- # Check the contents of the expanded directory. It should contain a
- # single directory whose name matches $stap_tmpdir_prefix_server.??????
- local num_files=`ls $tmpdir_server | wc -l`
- test $num_files = 1 || \
- fatal "Wrong number of files in server's temp directory"
- test -d $tmpdir_server/$stap_tmpdir_prefix_server.?????? || \
- fatal "`ls $tmpdir_server` does not match the expected name or is not a directory"
- # Move the contents of the directory down one level.
- mv $tmpdir_server/$stap_tmpdir_prefix_server.??????/* $tmpdir_server
- rm -fr $tmpdir_server/$stap_tmpdir_prefix_server.??????
-
# Check the contents of the directory. It should contain:
# 1) a file called stdout
# 2) a file called stderr
test -f $tmpdir_server/rc || \
fatal "`pwd`/$tmpdir_server/rc does not exist or is not a regular file"
- # See if there is a systemtap temp directory
+ # See if there is a systemtap temp directory. There should be at least an empty one.
+ # ls -l $tmpdir_server
tmpdir_stap=`cd $tmpdir_server && ls | grep stap......\$ 2>/dev/null`
if test "X$tmpdir_stap" != "X"; then
test -d $tmpdir_server/$tmpdir_stap || \
test $EUID = 0 && chown $EUID:$EUID $tmpdir_stap
fi
fi
+
+ if test $keep_temps = 0; then
+ # Remove the output line due to the synthetic server-side -k
+ sed -i "/^Keeping temporary directory.*/ d" $tmpdir_server/stderr
+ fi
}
# function: find_and_connect_to_server
# Remember which ssl certificate database was used to authenticate the chosen
# server.
ssl_db=`${stap_pkglibexecdir}stap-find-servers $find_all | choose_server`
- test "X$ssl_db" != "X" && return
+ if test "X$ssl_db" != "X"; then
+ rm -f $tmpdir_client/connect
+ return
+ fi
num_servers=`${stap_pkglibexecdir}stap-find-servers $find_all | wc -l`
fi
if test $num_servers = 0; then
+ rm -f $tmpdir_client/connect
fatal "Unable to find a server"
fi
cat $tmpdir_client/connect >&2
+ rm -f $tmpdir_client/connect
fatal "Unable to connect to a server"
}
# echo the name of the ssl certificate database used to successfully authenticate
# the server.
function send_receive {
- local server=$1
- local port=$2
+ local server="$1"
+ local port="$2"
# The server must match the dns name on the certificate
# and must be 'localhost' if the server is on the local host.
#
# Check the security of the given database directory.
function check_db {
- local dir=$1
- local euid=$2
- local user=$3
+ local dir="$1"
+ local euid="$2"
+ local user="$3"
local rc=0
# Check that we have been given a directory
#
# Check the security of the given database file.
function check_db_file {
- local file=$1
+ local file="$1"
local rc=0
# Check that we have been given a file
git://sourceware.org / systemtap.git / commitdiff