libisoburn/frontend/sh_on_named_pipes.sh

305 lines
7.8 KiB
Bash
Raw Normal View History

#!/bin/bash
#
# Demo of a shell frontend that communicates with a xorriso slave via
# two named pipes.
#
# This script creates two named pipes and starts xorriso with command
# -named_pipes_loop cleanup /tmp/xorriso_stdin_pipe_$$ xorriso_stdin_pipe_$$ -
# Its main loop prompts the user for commands, sends them to xorriso,
# receives the replies, and parses them by xorriso command
# -msg_op parse_silently. The resulting words are printed to stdout.
#
# xorriso removes the two pipes when it finishes execution of -named_pipes_loop
# regularly. (E.g. because of commands -end or -rollback_end or because of
# name loop control message "end_named_pipe_loop".)
# The vanishing of the pipe files tells this script that xorriso is gone.
#
#
# Copyright (C) 2013
# Thomas Schmitt <scdbackup@gmx.net>, libburnia-project.org
# Provided under BSD license: Use, modify, and distribute as you like.
#
# What xorriso program to use
xorriso=xorriso
if test o"$1" = o"-xorriso"
then
xorriso="$2"
fi
# Version of xorriso and minimum requirement by this script
export xorriso_version=
export xorriso_version_req=1.3.1
# Info about the xorriso slave process
export xorriso_is_running=0
export xorriso_pid=0
export xorriso_will_end=0
# Will be set to 1 before this script ends normally
export normal_end=0
# ---------------- An interpreter for quoted xorriso replies ----------------
# xorriso commands like -lsl wrap filenames into quotation marks in order
# to unambiguously represent any character byte except the 0-byte.
# This piece of code parses input strings into words by letting xorriso
# command -msg_op "parse_silently" do the hard work.
# The input strings should be composed by concatenating input lines with
# newline characters between them. Begin by submitting a single line (without
# newline at its end) and retry with an appended further line, if
# xorriso_parse
# returns 1. See below xorriso_cmd_and_handle_result() for an example.
# The parsed reply words.
# Valid are reply_array[0] to reply_array[reply_count-1)]
export reply_array
export reply_count
# Interpret reply of -msg_op parse
xorriso_recv_parse_reply() {
reply_count=0
unset reply_array
export reply_array
ret=-1
read ret
if test "$ret" -lt 0 -o -z "$ret"
then
echo "Unexpected text as first reply line of -msg_op parse" >&2
xorriso_is_running=0
return 2
fi
test "$ret" = 0 && return "1"
read num_strings
string_count=0
while true
do
test "$string_count" -ge "$num_strings" && break
read num_lines
line_count=0
acc=
while true
do
test "$line_count" -ge "$num_lines" && break
read line
test "$line_count" -gt 0 && acc="$acc"$'\n'
acc="$acc""$line"
line_count=$(($line_count + 1))
done
reply_array["$string_count"]="$acc"
string_count=$(($string_count + 1))
done
reply_count="$num_strings"
return 0
}
# Parse a quoted multi-line string into words
xorriso_parse() {
# $1 : The string which shall be parsed
# $2 : The number of concatenated input lines (= number of newlines + 1)
# return: 0= array is valid , 1= line incomplete , 2= other error
test "$xorriso_is_running" = 0 && return 1
xorriso_send_cmd "msg_op parse_silently "'"'"'' '' 0 0 $2"'"'$'\n'"$1" || \
return 2
xorriso_recv_parse_reply <"$result_pipe" || xorriso_is_running=0
ret=$?
test "$xorriso_is_running" = 0 && ret=2
return "$ret"
}
# ------------- End of interpreter for quoted xorriso replies --------------
# Send one or more command lines to xorriso
xorriso_send_cmd() {
# $1 : the lines to send
# >>> is it possible to have a timeout on echo ?
if test -p "$cmd_pipe"
then
echo -E "$1" >"$cmd_pipe"
else
xorriso_is_running=0
return 1
fi
}
# Make filenames safe for transport by wrapping them in quotes and
# escaping quotes in their text
xorriso_esc() {
echo -n "'"
echo -n "$1" | sed -e "s/'/'"'"'"'"'"'"'/g"
echo -n "'"
}
# A handler function for xorriso_cmd_and_handle_result
xorriso_reply_to_stdout() {
echo "${reply_array[*]}"
}
# Let a handler inspect the result lines of a xorriso command line
xorriso_cmd_and_handle_result() {
# $1: handler command word and possibly argument words
# $2: command line for xorriso
if test "$xorriso_is_running" = 0
then
return 1
fi
handler="$1"
xorriso_send_cmd "$2" || return 1
res=$(cat "$result_pipe")
ret=$?
if test "$xorriso_will_end" = 1 -o "$xorriso_is_running" = 0 -o "$ret" -ne 0
then
test -n "$res" && echo -n "$res"
xorriso_is_running=0
test "$ret" = 0 || return 1
return 0
fi
test -z "$res" && return 0
echo "$res" | \
while read line
do
line_count=1
while true
do
xorriso_parse "$line" "$line_count"
ret=$?
test "$ret" = 0 && break
if test "$ret" = 2
then
return 1
fi
read addon
line="$line"$'\n'"$addon"
line_count=$(expr "$line_count" + 1)
done
# One can now make use of reply_array[0...(reply_count-1)]
$handler
done
return 0
}
# Execute -version and let xorriso_version_handler interpret reply
xorriso_check_version() {
lookfor='^xorriso version : '
xorriso_version=$("$xorriso" -version 2>/dev/null | grep "$lookfor" | \
sed -e "s/${lookfor}//")
ret=$?
if test "$ret" -ne 0 -o "$xorriso_version" = ""
then
echo "SORRY: Program run '${xorriso}' -version did not yield a result." >&2
echo >&2
exit 2
fi
smallest=$((echo "$xorriso_version_req" ; echo "$xorriso_version" ) | \
sort | head -1)
test "$smallest" = "$xorriso_version_req" && return 0
echo "SORRY: xorriso version too old: ${xorriso_version} . Need at least xorriso-${xorriso_version_req} ." >&2
echo >&2
exit 2
}
# To be executed on exit
xorriso_cleanup() {
send_end_cmd=0
if test -p "$cmd_pipe" -a "$xorriso_is_running" = 1
then
if test "$normal_end" = 0
then
echo "Checking whether xorriso is still running ..." >&2
set -x
# Give xorriso time to abort
sleep 1
if ps | grep '^'"$xorriso_pid" >/dev/null
then
# >>> try to further confirm xorriso identity
send_end_cmd=1
fi
else
send_end_cmd=1
fi
fi
test "$normal_end" = 0 && set -x
if test "$send_end_cmd" = 1
then
echo "Sending xorriso an -end command ..." >&2
xorriso_send_cmd "end" && \
test -p "$result_pipe" && cat "$result_pipe" >/dev/null
fi
test -p "$cmd_pipe" && rm "$cmd_pipe"
test -p "$result_pipe" && rm "$result_pipe"
}
# ---------------------------------- main ---------------------------------
# Choose pipe names
export cmd_pipe=/tmp/xorriso_stdin_pipe_$$
export result_pipe=/tmp/xorriso_stdout_pipe_$$
# Check the program whether it is modern enough
xorriso_check_version "$xorriso"
# Prepare for then end of this script
trap xorriso_cleanup EXIT
# Create the pipes and start xorriso
mknod "$cmd_pipe" p
mknod "$result_pipe" p
"$xorriso" -abort_on NEVER -for_backup \
-named_pipe_loop cleanup:buffered "$cmd_pipe" "$result_pipe" "-" &
xorriso_pid=$!
xorriso_is_running=1
# Get a sign of life from xorriso before issuing the loop prompt
xorriso_cmd_and_handle_result xorriso_reply_to_stdout \
"print_info 'xorriso process ${xorriso_pid} started by $0'"
echo >&2
# Now get commands from the user, send them to xorriso and display them
# via the simple handler xorriso_reply_to_stdout()
while test "$xorriso_is_running" = 1
do
if test -p "$cmd_pipe"
then
echo -n "xorriso> " >&2
else
echo "$0 : Lost contact to xorriso process $xorriso_pid" >&2
xorriso_is_running=0
break
fi
read line
if echo "$line" | grep '^-*end$' >/dev/null
then
break
fi
if echo "$line" | grep '^-*rollback_end$' >/dev/null
then
xorriso_will_end=1
fi
xorriso_cmd_and_handle_result xorriso_reply_to_stdout "$line"
done
# Prevent set -x in the exit handler
normal_end=1