mirror of
https://repo.or.cz/socat.git
synced 2024-12-22 15:32:35 +00:00
7790 lines
222 KiB
Bash
Executable file
7790 lines
222 KiB
Bash
Executable file
#! /bin/bash
|
|
# $Id: test.sh,v 1.134 2007/03/06 21:06:20 gerhard Exp $
|
|
# Copyright Gerhard Rieger 2001-2007
|
|
# Published under the GNU General Public License V.2, see file COPYING
|
|
|
|
# perform lots of tests on socat
|
|
|
|
# this script uses functions; you need a shell that supports them
|
|
|
|
# you can pass general options to socat via $OPTS
|
|
|
|
#set -vx
|
|
|
|
withroot=0 # perform privileged tests even if not run by root
|
|
#PATH=$PATH:/opt/freeware/bin
|
|
#PATH=$PATH:/usr/local/ssl/bin
|
|
#OPENSSL_RAND="-rand /dev/egd-pool"
|
|
#SOCAT_EGD="egd=/dev/egd-pool"
|
|
MISCDELAY=1
|
|
[ -z "$SOCAT" ] && SOCAT="./socat"
|
|
[ -z "$PROCAN" ] && PROCAN="./procan"
|
|
[ -z "$FILAN" ] && FILAN="./filan"
|
|
opts="-t0.1 $OPTS"
|
|
export SOCAT_OPTS="$opts"
|
|
#debug="1"
|
|
debug=
|
|
TESTS="$@"
|
|
INTERFACE=eth0; # not used for function tests
|
|
MCINTERFACE=lo # !!! Linux only
|
|
#LOCALHOST=192.168.58.1
|
|
#LOCALHOST=localhost
|
|
LOCALHOST=127.0.0.1
|
|
LOCALHOST6=[::1]
|
|
PROTO=$((192+RANDOM/1024))
|
|
PORT=12002
|
|
SOURCEPORT=2002
|
|
CAT=cat
|
|
OD_C="od -c"
|
|
# time in microseconds to wait in some situations
|
|
MICROS=100000
|
|
if ! type usleep >/dev/null 2>&1; then
|
|
usleep () {
|
|
local n="$1"
|
|
# older bashes do not accept $1 here:
|
|
sleep $(((n+999999)/1000000))
|
|
}
|
|
fi
|
|
#USLEEP=usleep
|
|
F_n="%3d" # format string for test numbers
|
|
LANG=C
|
|
LANGUAGE=C # knoppix
|
|
UNAME=`uname`
|
|
case "$UNAME" in
|
|
HP-UX|OSF1)
|
|
echo "$SOCAT -u stdin stdout" >cat.sh
|
|
chmod a+x cat.sh
|
|
CAT=./cat.sh
|
|
;;
|
|
*)
|
|
CAT=cat
|
|
;;
|
|
esac
|
|
|
|
case "$UNAME" in
|
|
#HP-UX)
|
|
# # on HP-UX, the default options (below) hang some tests (former 14, 15)
|
|
# PTYOPTS=
|
|
# PTYOPTS2=
|
|
# ;;
|
|
*)
|
|
PTYOPTS="echo=0,opost=0"
|
|
PTYOPTS2="raw,echo=0"
|
|
;;
|
|
esac
|
|
|
|
# non-root users might miss ifconfig in their path
|
|
case "$UNAME" in
|
|
AIX) IFCONFIG=/usr/sbin/ifconfig ;;
|
|
FreeBSD) IFCONFIG=/sbin/ifconfig ;;
|
|
HP-UX) IFCONFIG=/usr/sbin/ifconfig ;;
|
|
Linux) IFCONFIG=/sbin/ifconfig ;;
|
|
NetBSD)IFCONFIG=/sbin/ifconfig ;;
|
|
OpenBSD)IFCONFIG=/sbin/ifconfig ;;
|
|
OSF1) IFCONFIG=/sbin/ifconfig ;;
|
|
SunOS) IFCONFIG=/sbin/ifconfig ;;
|
|
#*) IFCONFIG=/sbin/ifconfig ;;
|
|
esac
|
|
|
|
# for some tests we need a second local IPv4 address
|
|
case "$UNAME" in
|
|
Linux)
|
|
BROADCASTIF=eth0
|
|
SECONDADDR=127.0.0.2
|
|
BCADDR=127.255.255.255
|
|
BCIFADDR=$($IFCONFIG $BROADCASTIF |grep 'inet ' |awk '{print($2);}' |cut -d: -f2) ;;
|
|
FreeBSD|NetBSD|OpenBSD)
|
|
MAINIF=$($IFCONFIG -a |grep '^[a-z]' |head -1 |cut -d: -f1)
|
|
BROADCASTIF="$MAINIF"
|
|
SECONDADDR=$($IFCONFIG $BROADCASTIF |grep 'inet ' |awk '{print($2);}')
|
|
BCIFADDR="$SECONDADDR"
|
|
BCADDR=$($IFCONFIG $BROADCASTIF |grep 'broadcast ' |sed 's/.*broadcast/broadcast/' |awk '{print($2);}') ;;
|
|
HP-UX)
|
|
MAINIF=lan0 # might use "netstat -ni" for this
|
|
BROADCASTIF="$MAINIF"
|
|
SECONDADDR=$($IFCONFIG $MAINIF |tail -n 1 |awk '{print($2);}')
|
|
BCADDR=$($IFCONFIG $BROADCASTIF |grep 'broadcast ' |sed 's/.*broadcast/broadcast/' |awk '{print($2);}') ;;
|
|
SunOS)
|
|
#BROADCASTIF=hme0
|
|
BROADCASTIF=eri0
|
|
SECONDADDR=$($IFCONFIG $BROADCASTIF |grep 'inet ' |awk '{print($2);}')
|
|
BCIFADDR="$SECONDADDR"
|
|
BCADDR=$($IFCONFIG $BROADCASTIF |grep 'broadcast ' |sed 's/.*broadcast/broadcast/' |awk '{print($2);}') ;;
|
|
#AIX|FreeBSD|Solaris)
|
|
*)
|
|
SECONDADDR=$(expr "$($IFCONFIG -a |grep 'inet ' |fgrep -v ' 127.0.0.1 '| head -n 1)" : '.*inet \([0-9.]*\) .*')
|
|
;;
|
|
esac
|
|
|
|
# for some tests we need a second local IPv6 address
|
|
case "$UNAME" in
|
|
*)
|
|
SECONDIP6ADDR=$(expr "$($IFCONFIG -a |grep 'inet6 ' |fgrep -v ' ::1/128 '| head -n 1)" : '.*inet \([0-9.]*\) .*')
|
|
;;
|
|
esac
|
|
if [ -z "$SECONDIP6ADDR" ]; then
|
|
case "$TESTS" in
|
|
*%root2%*) $IFCONFIG eth0 ::2/128
|
|
esac
|
|
fi
|
|
|
|
TRUE=$(which true)
|
|
#E=-e # Linux
|
|
if [ $(echo "x\c") = "x" ]; then E=""
|
|
elif [ $(echo -e "x\c") = "x" ]; then E="-e"
|
|
else
|
|
echo "cannot suppress trailing newline on echo" >&2
|
|
exit 1
|
|
fi
|
|
ECHO="echo $E"
|
|
PRINTF="printf"
|
|
|
|
case "$TERM" in
|
|
vt100|vt320|linux|xterm|cons25|dtterm|aixterm|sun-color)
|
|
# there are different behaviours of printf (and echo)
|
|
# on some systems, echo behaves different than printf...
|
|
if [ $($PRINTF "\0101") = "A" ]; then
|
|
RED="\0033[31m"
|
|
GREEN="\0033[32m"
|
|
YELLOW="\0033[33m"
|
|
if [ "$UNAME" = SunOS ]; then
|
|
NORMAL="\0033[30m"
|
|
else
|
|
NORMAL="\0033[39m"
|
|
fi
|
|
else
|
|
RED="\033[31m"
|
|
GREEN="\033[32m"
|
|
YELLOW="\033[33m"
|
|
if [ "$UNAME" = SunOS ]; then
|
|
NORMAL="\033[30m"
|
|
else
|
|
NORMAL="\033[39m"
|
|
fi
|
|
fi
|
|
OK="${GREEN}OK${NORMAL}"
|
|
FAILED="${RED}FAILED${NORMAL}"
|
|
NO_RESULT="${YELLOW}NO RESULT${NORMAL}"
|
|
;;
|
|
*) OK="OK"
|
|
FAILED="FAILED"
|
|
NO_RESULT="NO RESULT"
|
|
;;
|
|
esac
|
|
|
|
|
|
if [ -x /usr/xpg4/bin/id ]; then
|
|
# SunOS has rather useless tools in its default path
|
|
PATH="/usr/xpg4/bin:$PATH"
|
|
fi
|
|
|
|
[ -z "$TESTS" ] && TESTS="consistency functions filan"
|
|
# use '%' as separation char
|
|
TESTS="%$(echo "$TESTS" |tr ' ' '%')%"
|
|
|
|
[ -z "$USER" ] && USER="$LOGNAME" # HP-UX
|
|
if [ -z "$TMPDIR" ]; then
|
|
if [ -z "$TMP" ]; then
|
|
TMP=/tmp
|
|
fi
|
|
TMPDIR="$TMP"
|
|
fi
|
|
TD="$TMPDIR/$USER/$$"; td="$TD"
|
|
rm -rf "$TD" || (echo "cannot rm $TD" >&2; exit 1)
|
|
mkdir -p "$TD"
|
|
#trap "rm -r $TD" 0 3
|
|
|
|
echo "using temp directory $TD"
|
|
|
|
case "$TESTS" in
|
|
*%consistency%*)
|
|
# test if addresses are sorted alphabetically:
|
|
$ECHO "testing if address array is sorted...\c"
|
|
TF="$TD/socat-q"
|
|
IFS="$($ECHO ' \n\t')"
|
|
$SOCAT -? |sed '1,/address-head:/ d' |egrep 'groups=' |while IFS="$IFS:" read x y; do echo "$x"; done >"$TF"
|
|
$SOCAT -? |sed '1,/address-head:/ d' |egrep 'groups=' |while IFS="$IFS:" read x y; do echo "$x"; done |LC_ALL=C sort |diff "$TF" - >"$TF-diff"
|
|
if [ -s "$TF-diff" ]; then
|
|
$ECHO "\n*** address array is not sorted. Wrong entries:" >&2
|
|
cat "$TD/socat-q-diff" >&2
|
|
else
|
|
echo " ok"
|
|
fi
|
|
#/bin/rm "$TF"
|
|
#/bin/rm "$TF-diff"
|
|
esac
|
|
|
|
case "$TESTS" in
|
|
*%consistency%*)
|
|
# test if address options array ("optionnames") is sorted alphabetically:
|
|
$ECHO "testing if address options are sorted...\c"
|
|
TF="$TD/socat-qq"
|
|
$SOCAT -??? |sed '1,/opt:/ d' |egrep 'groups=' |awk '{print($1);}' >"$TF"
|
|
$SOCAT -??? |sed '1,/opt:/ d' |egrep 'groups=' |awk '{print($1);}' |LC_ALL=C sort |diff "$TF" - >"$TF-diff"
|
|
if [ -s "$TF-diff" ]; then
|
|
$ECHO "\n*** option array is not sorted. Wrong entries:" >&2
|
|
cat "$TD/socat-qq-diff" >&2
|
|
else
|
|
echo " ok"
|
|
fi
|
|
/bin/rm "$TF"
|
|
/bin/rm "$TF-diff"
|
|
esac
|
|
|
|
#==============================================================================
|
|
case "$TESTS" in
|
|
*%options%*)
|
|
|
|
# inquire which options are available
|
|
OPTS_ANY=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*ANY' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_BLK=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*BLK' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_CHILD=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*CHILD' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_CHR=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*CHR' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_DEVICE=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*DEVICE' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_EXEC=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*EXEC' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_FD=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*FD' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_FIFO=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*FIFO' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_FORK=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*FORK' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_LISTEN=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*LISTEN' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_NAMED=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*NAMED' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_OPEN=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*OPEN[^S]' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_PARENT=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*PARENT' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_READLINE=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*READLINE' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_RETRY=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*RETRY' |awk '{print($1);}' |grep -v forever|xargs echo |tr ' ' ',')
|
|
OPTS_RANGE=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*RANGE' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_FILE=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*REG' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_UNIX=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*UNIX' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_SOCKET=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*SOCKET' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_TERMIOS=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*TERMIOS' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_IP4=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*IP4' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_IP6=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*IP6' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_TCP=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*TCP' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_UDP=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*UDP' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_SOCKS4=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*SOCKS4' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_PROCESS=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*PROCESS' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_OPENSSL=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*OPENSSL' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_PTY=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*PTY' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_HTTP=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*HTTP' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
OPTS_APPL=$($SOCAT -?? |sed '1,/opt:/ d' |egrep 'groups=([A-Z]+,)*APPL' |awk '{print($1);}' |xargs echo |tr ' ' ',')
|
|
|
|
# find user ids to setown to; non-root only can setown to itself
|
|
if [ $(id -u) = 0 ]; then
|
|
# up to now, it is not a big problem when these do not exist
|
|
_UID=nobody
|
|
_GID=staff
|
|
else
|
|
_UID=$(id -u)
|
|
_GID=$(id -g)
|
|
fi
|
|
|
|
# some options require values; here we try to replace these bare options with
|
|
# valid forms.
|
|
filloptionvalues() {
|
|
local OPTS=",$1,"
|
|
#
|
|
case "$OPTS" in
|
|
*,umask,*) OPTS=$(echo "$OPTS" |sed "s/,umask,/,umask=0026,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,user,*) OPTS=$(echo "$OPTS" |sed "s/,user,/,user=$_UID,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,user-early,*) OPTS=$(echo "$OPTS" |sed "s/,user-early,/,user-early=$_UID,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,user-late,*) OPTS=$(echo "$OPTS" |sed "s/,user-late,/,user-late=$_UID,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,owner,*) OPTS=$(echo "$OPTS" |sed "s/,owner,/,owner=$_UID,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,uid,*) OPTS=$(echo "$OPTS" |sed "s/,uid,/,uid=$_UID,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,uid-l,*) OPTS=$(echo "$OPTS" |sed "s/,uid-l,/,uid-l=$_UID,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,setuid,*) OPTS=$(echo "$OPTS" |sed "s/,setuid,/,setuid=$_UID,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,group,*) OPTS=$(echo "$OPTS" |sed "s/,group,/,group=$_GID,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,group-early,*) OPTS=$(echo "$OPTS" |sed "s/,group-early,/,group-early=$_GID,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,group-late,*) OPTS=$(echo "$OPTS" |sed "s/,group-late,/,group-late=$_GID,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,gid,*) OPTS=$(echo "$OPTS" |sed "s/,gid,/,gid=$_GID,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,gid-l,*) OPTS=$(echo "$OPTS" |sed "s/,gid-l,/,gid-l=$_GID,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,setgid,*) OPTS=$(echo "$OPTS" |sed "s/,setgid,/,setgid=$_GID,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,mode,*) OPTS=$(echo "$OPTS" |sed "s/,mode,/,mode=0700,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,perm,*) OPTS=$(echo "$OPTS" |sed "s/,perm,/,perm=0700,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,perm-early,*) OPTS=$(echo "$OPTS" |sed "s/,perm-early,/,perm-early=0700,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,perm-late,*) OPTS=$(echo "$OPTS" |sed "s/,perm-late,/,perm-late=0700,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,path,*) OPTS=$(echo "$OPTS" |sed "s/,path,/,path=.,/g");;
|
|
esac
|
|
# SOCKET
|
|
case "$OPTS" in
|
|
*,bind,*) OPTS=$(echo "$OPTS" |sed "s/,bind,/,bind=:,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,linger,*) OPTS=$(echo "$OPTS" |sed "s/,linger,/,linger=2,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,rcvtimeo,*) OPTS=$(echo "$OPTS" |sed "s/,rcvtimeo,/,rcvtimeo=1,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,sndtimeo,*) OPTS=$(echo "$OPTS" |sed "s/,sndtimeo,/,sndtimeo=1,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,connect-timeout,*) OPTS=$(echo "$OPTS" |sed "s/,connect-timeout,/,connect-timeout=1,/g");;
|
|
esac
|
|
# IP
|
|
case "$OPTS" in
|
|
*,ipoptions,*) OPTS=$(echo "$OPTS" |sed "s|,ipoptions,|,ipoptions=x01,|g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,pf,*) OPTS=$(echo "$OPTS" |sed "s|,pf,|,pf=ip4,|g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,range,*) OPTS=$(echo "$OPTS" |sed "s|,range,|,range=127.0.0.1/32,|g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,if,*) OPTS=$(echo "$OPTS" |sed "s/,if,/,if=$INTERFACE,/g");;
|
|
esac
|
|
# PTY
|
|
case "$OPTS" in
|
|
*,pty-intervall,*) OPTS=$(echo "$OPTS" |sed "s/,pty-intervall,/,pty-intervall=$INTERFACE,/g");;
|
|
esac
|
|
# RETRY
|
|
case "$OPTS" in
|
|
*,intervall,*) OPTS=$(echo "$OPTS" |sed "s/,intervall,/,intervall=1,/g");;
|
|
esac
|
|
# READLINE
|
|
case "$OPTS" in
|
|
*,history,*) OPTS=$(echo "$OPTS" |sed "s/,history,/,history=.history,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,noecho,*) OPTS=$(echo "$OPTS" |sed "s/,noecho,/,noecho=password,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,prompt,*) OPTS=$(echo "$OPTS" |sed "s/,prompt,/,prompt=CMD,/g");;
|
|
esac
|
|
# IPAPP
|
|
case "$OPTS" in
|
|
*,sp,*) OPTS=$(echo "$OPTS" |sed "s/,sp,/,sp=$SOURCEPORT,/g");;
|
|
esac
|
|
# OPENSSL
|
|
case "$OPTS" in
|
|
*,ciphers,*) OPTS=$(echo "$OPTS" |sed "s/,ciphers,/,ciphers=NULL,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,method,*) OPTS=$(echo "$OPTS" |sed "s/,method,/,method=SSLv3,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,cafile,*) OPTS=$(echo "$OPTS" |sed "s/,cafile,/,cafile=/tmp/hugo,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,capath,*) OPTS=$(echo "$OPTS" |sed "s/,capath,/,capath=/tmp/hugo,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,cert,*) OPTS=$(echo "$OPTS" |sed "s/,cert,/,cert=/tmp/hugo,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,key,*) OPTS=$(echo "$OPTS" |sed "s/,key,/,key=/tmp/hugo,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,dh,*) OPTS=$(echo "$OPTS" |sed "s/,dh,/,dh=/tmp/hugo,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,egd,*) OPTS=$(echo "$OPTS" |sed "s/,egd,/,egd=/tmp/hugo,/g");;
|
|
esac
|
|
# PROXY
|
|
case "$OPTS" in
|
|
*,proxyauth,*) OPTS=$(echo "$OPTS" |sed "s/,proxyauth,/,proxyauth=user:pass,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,proxyport,*) OPTS=$(echo "$OPTS" |sed "s/,proxyport,/,proxyport=3128,/g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,link,*) OPTS=$(echo "$OPTS" |sed "s/,link,/,link=testlink,/g");;
|
|
esac
|
|
# TCP-WRAPPERS
|
|
case "$OPTS" in
|
|
*,allow-table,*) OPTS=$(echo "$OPTS" |sed "s|,allow-table,|,allow-table=/tmp/hugo,|g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,deny-table,*) OPTS=$(echo "$OPTS" |sed "s|,deny-table,|,deny-table=/tmp/hugo,|g");;
|
|
esac
|
|
case "$OPTS" in
|
|
*,tcpwrap-dir,*) OPTS=$(echo "$OPTS" |sed "s|,tcpwrap-dir,|,tcpwrap-dir=/tmp,|g");;
|
|
esac
|
|
echo $OPTS >&2
|
|
expr "$OPTS" : ',\(.*\),'
|
|
}
|
|
# OPTS_FIFO: nothing yet
|
|
|
|
# OPTS_CHR: nothing yet
|
|
|
|
# OPTS_BLK: nothing yet
|
|
|
|
# OPTS_REG: nothing yet
|
|
|
|
OPTS_SOCKET=",$OPTS_SOCKET,"
|
|
OPTS_SOCKET=$(expr "$OPTS_SOCKET" : ',\(.*\),')
|
|
|
|
N=1
|
|
#------------------------------------------------------------------------------
|
|
|
|
#method=open
|
|
#METHOD=$(echo "$method" |tr a-z A-Z)
|
|
#TEST="$METHOD on file accepts all its options"
|
|
# echo "### $TEST"
|
|
#TF=$TD/file$N
|
|
#DA="$(date)"
|
|
#OPTGROUPS=$($SOCAT -? |fgrep " $method:" |sed 's/.*=//')
|
|
#for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
# eval "OPTG=\$OPTS_$(echo $g |tr a-z- A-Z_)";
|
|
# OPTS="$OPTS,$OPTG";
|
|
#done
|
|
##echo $OPTS
|
|
#
|
|
#for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
# echo testing if $METHOD accepts option $o
|
|
# touch $TF
|
|
# $SOCAT $opts -!!$method:$TF,$o /dev/null,ignoreof </dev/null
|
|
# rm -f $TF
|
|
#done
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test openssl connect
|
|
|
|
#set -vx
|
|
if true; then
|
|
#if false; then
|
|
#opts="-s -d -d -d -d"
|
|
pid=$!
|
|
for addr in openssl; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
# echo OPTGROUPS=$OPTGROUPS
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
echo $OPTS
|
|
openssl s_server -www -accept $PORT || echo "cannot start s_server" >&2 &
|
|
pid=$!
|
|
sleep 1
|
|
#waittcp4port $PORT
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
# echo $SOCAT $opts /dev/null $addr:$LOCALHOST:$PORT,$o
|
|
$SOCAT $opts /dev/null $addr:$LOCALHOST:$PORT,$o
|
|
done
|
|
kill $pid
|
|
done
|
|
kill $pid 2>/dev/null
|
|
opts=
|
|
PORT=$((PORT+1))
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test proxy connect
|
|
|
|
#set -vx
|
|
if true; then
|
|
#if false; then
|
|
#opts="-s -d -d -d -d"
|
|
pid=$!
|
|
for addr in proxy; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
# echo OPTGROUPS=$OPTGROUPS
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
echo $OPTS
|
|
# prepare dummy server
|
|
$SOCAT tcp-l:$PORT,reuseaddr,crlf exec:"/bin/bash proxyecho.sh" || echo "cannot start proxyecho.sh" >&2 &
|
|
pid=$!
|
|
sleep 1
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
# echo $SOCAT $opts /dev/null $addr:$LOCALHOST:127.0.0.1:$PORT,$o
|
|
$SOCAT $opts /dev/null $addr:$LOCALHOST:127.0.0.1:$((PORT+1)),proxyport=$PORT,$o
|
|
done
|
|
kill $pid 2>/dev/null
|
|
done
|
|
kill $pid 2>/dev/null
|
|
opts=
|
|
PORT=$((PORT+2))
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test tcp4
|
|
|
|
#set -vx
|
|
if true; then
|
|
#if false; then
|
|
#opts="-s -d -d -d -d"
|
|
$SOCAT $opts tcp4-listen:$PORT,reuseaddr,fork,$o echo </dev/null &
|
|
pid=$!
|
|
for addr in tcp4; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
# echo OPTGROUPS=$OPTGROUPS
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
$SOCAT $opts /dev/null $addr:$LOCALHOST:$PORT,$o
|
|
done
|
|
done
|
|
kill $pid 2>/dev/null
|
|
opts=
|
|
PORT=$((PORT+1))
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test udp4-connect
|
|
|
|
#set -vx
|
|
if true; then
|
|
#if false; then
|
|
#opts="-s -d -d -d -d"
|
|
$SOCAT $opts udp4-listen:$PORT,fork,$o echo </dev/null &
|
|
pid=$!
|
|
for addr in udp4-connect; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
# echo OPTGROUPS=$OPTGROUPS
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
$SOCAT $opts /dev/null $addr:$LOCALHOST:$PORT,$o
|
|
done
|
|
done
|
|
kill $pid 2>/dev/null
|
|
opts=
|
|
PORT=$((PORT+1))
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test tcp4-listen
|
|
|
|
#set -vx
|
|
if true; then
|
|
#if false; then
|
|
#opts="-s -d -d -d -d"
|
|
for addr in tcp4-listen; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
$SOCAT $opts $ADDR:$PORT,reuseaddr,$o echo </dev/null &
|
|
pid=$!
|
|
$SOCAT /dev/null tcp4:$LOCALHOST:$PORT 2>/dev/null
|
|
kill $pid 2>/dev/null
|
|
done
|
|
done
|
|
opts=
|
|
PORT=$((PORT+1))
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test udp4-listen
|
|
|
|
#set -vx
|
|
if true; then
|
|
#if false; then
|
|
#opts="-s -d -d -d -d"
|
|
for addr in udp4-listen; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
$SOCAT $opts $ADDR:$PORT,reuseaddr,$o echo </dev/null &
|
|
pid=$!
|
|
$SOCAT /dev/null udp4:$LOCALHOST:$PORT 2>/dev/null
|
|
kill $pid 2>/dev/null
|
|
done
|
|
done
|
|
opts=
|
|
PORT=$((PORT+1))
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test udp4-sendto
|
|
|
|
#set -vx
|
|
if true; then
|
|
#if false; then
|
|
#opts="-s -d -d -d -d"
|
|
$SOCAT $opts udp4-recv:$PORT,fork,$o echo </dev/null &
|
|
pid=$!
|
|
for addr in udp4-sendto; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
# echo OPTGROUPS=$OPTGROUPS
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
$SOCAT $opts /dev/null $addr:$LOCALHOST:$PORT,$o
|
|
done
|
|
done
|
|
kill $pid 2>/dev/null
|
|
opts=
|
|
PORT=$((PORT+1))
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test udp4-datagram
|
|
|
|
#set -vx
|
|
if true; then
|
|
#if false; then
|
|
#opts="-s -d -d -d -d"
|
|
#$SOCAT $opts udp4-recvfrom:$PORT,fork,$o echo </dev/null &
|
|
#pid=$!
|
|
for addr in udp4-datagram; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
# echo OPTGROUPS=$OPTGROUPS
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
$SOCAT $opts /dev/null $addr:$LOCALHOST:$PORT,$o
|
|
done
|
|
done
|
|
#kill $pid 2>/dev/null
|
|
opts=
|
|
PORT=$((PORT+1))
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test udp4-recv
|
|
|
|
#set -vx
|
|
if true; then
|
|
#if false; then
|
|
#opts="-s -d -d -d -d"
|
|
for addr in udp4-recv; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
$SOCAT $opts $ADDR:$PORT,reuseaddr,$o echo </dev/null &
|
|
pid=$!
|
|
$SOCAT /dev/null udp4:$LOCALHOST:$PORT 2>/dev/null
|
|
kill $pid 2>/dev/null
|
|
done
|
|
done
|
|
opts=
|
|
PORT=$((PORT+1))
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test udp4-recvfrom
|
|
|
|
#set -vx
|
|
if true; then
|
|
#if false; then
|
|
#opts="-s -d -d -d -d"
|
|
for addr in udp4-recvfrom; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
$SOCAT $opts $ADDR:$PORT,reuseaddr,$o echo </dev/null &
|
|
pid=$!
|
|
$SOCAT /dev/null udp4:$LOCALHOST:$PORT 2>/dev/null
|
|
kill $pid 2>/dev/null
|
|
done
|
|
done
|
|
opts=
|
|
PORT=$((PORT+1))
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test ip4-sendto
|
|
|
|
#set -vx
|
|
if true; then
|
|
#if false; then
|
|
#opts="-s -d -d -d -d"
|
|
$SOCAT $opts ip4-recv:$PORT,fork,$o echo </dev/null &
|
|
pid=$!
|
|
for addr in ip4-sendto; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
# echo OPTGROUPS=$OPTGROUPS
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
$SOCAT $opts /dev/null $addr:$LOCALHOST:$PORT,$o
|
|
done
|
|
done
|
|
kill $pid 2>/dev/null
|
|
opts=
|
|
PORT=$((PORT+1))
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test ip4-recv
|
|
|
|
#set -vx
|
|
if true; then
|
|
#if false; then
|
|
#opts="-s -d -d -d -d"
|
|
for addr in ip4-recv; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
$SOCAT $opts $ADDR:$PORT,reuseaddr,$o echo </dev/null &
|
|
pid=$!
|
|
$SOCAT /dev/null ip4-sendto:$LOCALHOST:$PORT 2>/dev/null
|
|
kill $pid 2>/dev/null
|
|
done
|
|
done
|
|
opts=
|
|
PORT=$((PORT+1))
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test ip4-recvfrom
|
|
|
|
#set -vx
|
|
if true; then
|
|
#if false; then
|
|
#opts="-s -d -d -d -d"
|
|
for addr in ip4-recvfrom; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
$SOCAT $opts $ADDR:$PORT,reuseaddr,$o echo </dev/null &
|
|
pid=$!
|
|
$SOCAT /dev/null ip4-sendto:$LOCALHOST:$PORT 2>/dev/null
|
|
kill $pid 2>/dev/null
|
|
done
|
|
done
|
|
opts=
|
|
PORT=$((PORT+1))
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test READLINE
|
|
|
|
if true; then
|
|
#if false; then
|
|
#opts="-s -d -d -d -d"
|
|
for addr in readline; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
TS=$TD/script$N
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr " |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
# for o in bs0; do
|
|
echo "testing if $ADDR accepts option $o"
|
|
echo "$SOCAT $opts readline,$o /dev/null" >$TS
|
|
chmod u+x $TS
|
|
$SOCAT /dev/null,ignoreeof exec:$TS,pty
|
|
#stty sane
|
|
done
|
|
#reset 1>&0 2>&0
|
|
done
|
|
opts=
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# unnamed pipe
|
|
#if false; then
|
|
if true; then
|
|
for addr in pipe; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="unnamed $ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |egrep " $addr[^:]" |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo testing if unnamed $ADDR accepts option $o
|
|
$SOCAT $opts $addr,$o /dev/null </dev/null
|
|
done
|
|
done
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test addresses on files
|
|
|
|
N=1
|
|
#if false; then
|
|
if true; then
|
|
for addr in create; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR on new file accepts all its options"
|
|
echo "### $TEST"
|
|
TF=$TD/file$N
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo testing if $ADDR accepts option $o
|
|
rm -f $TF
|
|
$SOCAT $opts -!!$addr:$TF,$o /dev/null,ignoreof </dev/null
|
|
rm -f $TF
|
|
done
|
|
done
|
|
fi
|
|
#------------------------------------------------------------------------------
|
|
|
|
#if false; then
|
|
if true; then
|
|
for addr in exec system; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
|
|
TEST="$ADDR with socketpair accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTGROUPS=$(echo $OPTGROUPS |sed -e 's/,FIFO,/,/g' -e 's/,TERMIOS,/,/g' -e 's/,PTY,/,/g')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
OPTS=$(echo $OPTS|sed -e 's/,pipes,/,/g' -e 's/,pty,/,/g' -e 's/,openpty,/,/g' -e 's/,ptmx,/,/g' -e 's/,nofork,/,/g')
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo testing if $ADDR with socketpair accepts option $o
|
|
$SOCAT $opts $addr:$TRUE,$o /dev/null,ignoreof </dev/null
|
|
done
|
|
|
|
TEST="$ADDR with pipes accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTGROUPS=$(echo $OPTGROUPS |sed -e 's/,TERMIOS,/,/g' -e 's/,PTY,/,/g' -e 's/,SOCKET,/,/g' -e 's/,UNIX//g')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
# flock tends to hang, so dont test it
|
|
OPTS=$(echo $OPTS|sed -e 's/,pipes,/,/g' -e 's/,pty,/,/g' -e 's/,openpty,/,/g' -e 's/,ptmx,/,/g' -e 's/,nofork,/,/g' -e 's/,flock,/,/g')
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo testing if $ADDR with pipes accepts option $o
|
|
$SOCAT $opts $addr:$TRUE,pipes,$o /dev/null,ignoreof </dev/null
|
|
done
|
|
|
|
TEST="$ADDR with pty accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTGROUPS=$(echo $OPTGROUPS |sed -e 's/,FIFO,/,/g' -e 's/,SOCKET,/,/g' -e 's/,UNIX//g')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
OPTS=$(echo $OPTS|sed -e 's/,pipes,/,/g' -e 's/,pty,/,/g' -e 's/,openpty,/,/g' -e 's/,ptmx,/,/g' -e 's/,nofork,/,/g')
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo testing if $ADDR with pty accepts option $o
|
|
$SOCAT $opts $addr:$TRUE,pty,$o /dev/null,ignoreof </dev/null
|
|
done
|
|
|
|
TEST="$ADDR with nofork accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTGROUPS=$(echo $OPTGROUPS |sed -e 's/,FIFO,/,/g' -e 's/,PTY,/,/g' -e 's/,TERMIOS,/,/g' -e 's/,SOCKET,/,/g' -e 's/,UNIX//g')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
OPTS=$(echo $OPTS|sed -e 's/,pipes,/,/g' -e 's/,pty,/,/g' -e 's/,openpty,/,/g' -e 's/,ptmx,/,/g' -e 's/,nofork,/,/g')
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo testing if $ADDR with nofork accepts option $o
|
|
$SOCAT /dev/null $opts $addr:$TRUE,nofork,$o </dev/null
|
|
done
|
|
|
|
done
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
#if false; then
|
|
if true; then
|
|
for addr in fd; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
TF=$TD/file$N
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR (to file) accepts option $o"
|
|
rm -f $TF
|
|
$SOCAT $opts -u /dev/null $addr:3,$o 3>$TF
|
|
done
|
|
done
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test OPEN address
|
|
|
|
#! test it on pipe, device, new file
|
|
|
|
N=1
|
|
#if false; then
|
|
if true; then
|
|
for addr in open; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR on file accepts all its options"
|
|
echo "### $TEST"
|
|
TF=$TD/file$N
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo testing if $ADDR on file accepts option $o
|
|
touch $TF
|
|
$SOCAT $opts -!!$addr:$TF,$o /dev/null,ignoreof </dev/null
|
|
rm -f $TF
|
|
done
|
|
done
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test GOPEN address on files, sockets, pipes, devices
|
|
|
|
N=1
|
|
#if false; then
|
|
if true; then
|
|
for addr in gopen; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
|
|
TEST="$ADDR on new file accepts all its options"
|
|
echo "### $TEST"
|
|
TF=$TD/file$N
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTGROUPS=$(echo $OPTGROUPS |sed -e 's/,SOCKET,/,/g' -e 's/,UNIX//g')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo testing if $ADDR on new file accepts option $o
|
|
rm -f $TF
|
|
$SOCAT $opts -!!$addr:$TF,$o /dev/null,ignoreof </dev/null
|
|
rm -f $TF
|
|
done
|
|
|
|
TEST="$ADDR on existing file accepts all its options"
|
|
echo "### $TEST"
|
|
TF=$TD/file$N
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTGROUPS=$(echo $OPTGROUPS |sed -e 's/,SOCKET,/,/g' -e 's/,UNIX//g')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo testing if $ADDR on existing file accepts option $o
|
|
rm -f $TF; touch $TF
|
|
$SOCAT $opts -!!$addr:$TF,$o /dev/null,ignoreof </dev/null
|
|
rm -f $TF
|
|
done
|
|
|
|
TEST="$ADDR on existing pipe accepts all its options"
|
|
echo "### $TEST"
|
|
TF=$TD/pipe$N
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTGROUPS=$(echo $OPTGROUPS |sed -e 's/,REG,/,/g' -e 's/,SOCKET,/,/g' -e 's/,UNIX//g')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo testing if $ADDR on named pipe accepts option $o
|
|
rm -f $TF; mkfifo $TF
|
|
$SOCAT $opts $addr:$TF,$o,nonblock /dev/null </dev/null
|
|
rm -f $TF
|
|
done
|
|
|
|
TEST="$ADDR on existing socket accepts all its options"
|
|
echo "### $TEST"
|
|
TF=$TD/sock$N
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTGROUPS=$(echo $OPTGROUPS |sed -e 's/,REG,/,/g' -e 's/,OPEN,/,/g')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo testing if $ADDR on socket accepts option $o
|
|
rm -f $TF; $SOCAT - UNIX-L:$TF & pid=$!
|
|
$SOCAT $opts -!!$addr:$TF,$o /dev/null,ignoreof </dev/null
|
|
kill $pid 2>/dev/null
|
|
rm -f $TF
|
|
done
|
|
|
|
if [ $(id -u) -eq 0 ]; then
|
|
TEST="$ADDR on existing device accepts all its options"
|
|
echo "### $TEST"
|
|
TF=$TD/null
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTGROUPS=$(echo $OPTGROUPS |sed -e 's/,REG,/,/g' -e 's/,OPEN,/,/g')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo testing if $ADDR on existing device accepts option $o
|
|
rm -f $TF; mknod $TF c 1 3
|
|
$SOCAT $opts -!!$addr:$TF,$o /dev/null,ignoreof </dev/null
|
|
done
|
|
else
|
|
TEST="$ADDR on existing device accepts all its options"
|
|
echo "### $TEST"
|
|
TF=/dev/null
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTGROUPS=$(echo $OPTGROUPS |sed -e 's/,REG,/,/g' -e 's/,OPEN,/,/g')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo testing if $ADDR on existing device accepts option $o
|
|
$SOCAT $opts -!!$addr:$TF,$o /dev/null,ignoreof </dev/null
|
|
done
|
|
fi
|
|
|
|
done
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test named pipe
|
|
|
|
N=1
|
|
#if false; then
|
|
if true; then
|
|
for addr in pipe; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR on file accepts all its options"
|
|
echo "### $TEST"
|
|
TF=$TD/pipe$N
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo testing if named $ADDR accepts option $o
|
|
rm -f $TF
|
|
# blocks with rdonly, wronly
|
|
case "$o" in rdonly|wronly) o="$o,nonblock" ;; esac
|
|
$SOCAT $opts $addr:$TF,$o /dev/null </dev/null
|
|
rm -f $TF
|
|
done
|
|
done
|
|
fi
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test STDIO
|
|
|
|
#! test different stream types
|
|
|
|
#if false; then
|
|
if true; then
|
|
for addr in stdio; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr" |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR (/dev/null, stdout) accepts option $o"
|
|
$SOCAT $opts $addr,$o /dev/null,ignoreof </dev/null
|
|
done
|
|
done
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test STDIN
|
|
|
|
#if false; then
|
|
if true; then
|
|
for addr in stdin; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr " |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR (/dev/null) accepts option $o"
|
|
$SOCAT $opts -u $addr,$o /dev/null </dev/null
|
|
done
|
|
done
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
# test STDOUT, STDERR
|
|
|
|
if true; then
|
|
#if false; then
|
|
for addr in stdout stderr; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr " |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
$SOCAT $opts -u /dev/null $addr,$o
|
|
done
|
|
done
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
# REQUIRES ROOT
|
|
|
|
if [ "$withroot" ]; then
|
|
for addr in ip4; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
$SOCAT $opts $addr:127.0.0.1:200 /dev/null,ignoreof </dev/null
|
|
done
|
|
done
|
|
fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
# REQUIRES ROOT
|
|
|
|
if [ "$withroot" ]; then
|
|
for addr in ip6; do
|
|
ADDR=$(echo "$addr" |tr a-z A-Z)
|
|
TEST="$ADDR accepts all its options"
|
|
echo "### $TEST"
|
|
OPTGROUPS=$($SOCAT -? |fgrep " $addr:" |sed 's/.*=//')
|
|
OPTS=
|
|
for g in $(echo $OPTGROUPS |tr ',' ' '); do
|
|
eval "OPTG=\$OPTS_$(echo $g |tr a-z A-Z)";
|
|
OPTS="$OPTS,$OPTG";
|
|
done
|
|
#echo $OPTS
|
|
for o in $(filloptionvalues $OPTS|tr ',' ' '); do
|
|
echo "testing if $ADDR accepts option $o"
|
|
$SOCAT $opts $addr:[::1]:200 /dev/null,ignoreof </dev/null
|
|
done
|
|
done
|
|
fi
|
|
|
|
#==============================================================================
|
|
|
|
#TEST="stdio accepts all options of GROUP_ANY"
|
|
#echo "### $TEST"
|
|
#CMD="$SOCAT $opts -,$OPTS_ANY /dev/null"
|
|
#$CMD
|
|
#if [ $? = 0 ]; then
|
|
# echo "... test $N ($TEST) succeeded"
|
|
## echo "CMD=$CMD"
|
|
#else
|
|
# echo "*** test $N ($TEST) FAILED"
|
|
# echo "CMD=$CMD"
|
|
#fi
|
|
#
|
|
#N=$((N+1))
|
|
##------------------------------------------------------------------------------
|
|
#
|
|
#TEST="exec accepts all options of GROUP_ANY and GROUP_SOCKET"
|
|
#echo "### $TEST"
|
|
#CMD="$SOCAT $opts exec:$TRUE,$OPTS_ANY,$OPTS_SOCKET /dev/null"
|
|
#$CMD
|
|
#if [ $? = 0 ]; then
|
|
# echo "... test $N ($TEST) succeeded"
|
|
## echo "CMD=$CMD"
|
|
#else
|
|
# echo "*** test $N ($TEST) FAILED"
|
|
# echo "CMD=$CMD"
|
|
#fi
|
|
|
|
#------------------------------------------------------------------------------
|
|
|
|
esac
|
|
|
|
#==============================================================================
|
|
|
|
N=1
|
|
numOK=0
|
|
numFAIL=0
|
|
numCANT=0
|
|
|
|
#==============================================================================
|
|
# test if selected socat features work ("FUNCTIONS")
|
|
|
|
testecho () {
|
|
local num="$1"
|
|
local title="$2"
|
|
local arg1="$3"; [ -z "$arg1" ] && arg1="-"
|
|
local arg2="$4"; [ -z "$arg2" ] && arg2="echo"
|
|
local opts="$5"
|
|
local T="$6"; [ -z "$T" ] && T=0
|
|
local tf="$td/test$N.stdout"
|
|
local te="$td/test$N.stderr"
|
|
local tdiff="$td/test$N.diff"
|
|
local da="$(date)"
|
|
#local cmd="$SOCAT $opts $arg1 $arg2"
|
|
#$ECHO "testing $title (test $num)... \c"
|
|
$PRINTF "test $F_n %s... " $num "$title"
|
|
#echo "$da" |$cmd >"$tf" 2>"$te"
|
|
#set -vx
|
|
(echo "$da"; sleep $T) |$SOCAT $opts "$arg1" "$arg2" >"$tf" 2>"$te" &
|
|
export rc1=$!
|
|
#sleep 5 && kill $rc1 2>/dev/null &
|
|
# rc2=$!
|
|
wait $rc1
|
|
# kill $rc2 2>/dev/null
|
|
#set +vx
|
|
if [ "$?" != 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$SOCAT $opts $arg1 $arg2"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
elif echo "$da" |diff - "$tf" >"$tdiff" 2>&1; then
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
else
|
|
$PRINTF "$FAILED:\n"
|
|
echo "$SOCAT $opts $arg1 $arg2"
|
|
cat "$te"
|
|
echo diff:
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
fi
|
|
}
|
|
|
|
# test if call to od and throughput of data works - with graceful shutdown and
|
|
# flush of od buffers
|
|
testod () {
|
|
local num="$1"
|
|
local title="$2"
|
|
local arg1="$3"; [ -z "$arg1" ] && arg1="-"
|
|
local arg2="$4"; [ -z "$arg2" ] && arg2="echo"
|
|
local opts="$5"
|
|
local T="$6"; [ -z "$T" ] && T=0
|
|
local tf="$td/test$N.stdout"
|
|
local te="$td/test$N.stderr"
|
|
local tdiff="$td/test$N.diff"
|
|
local dain="$(date)"
|
|
local daout="$(echo "$dain" |od -c)"
|
|
$PRINTF "test $F_n %s... " $num "$title"
|
|
(echo "$dain"; sleep $T) |$SOCAT $opts "$arg1" "$arg2" >"$tf" 2>"$te"
|
|
if [ "$?" != 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$SOCAT $opts $arg1 $arg2"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
elif echo "$daout" |diff - "$tf" >"$tdiff" 2>&1; then
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
else
|
|
$PRINTF "$FAILED: diff:\n"
|
|
echo "$SOCAT $opts $arg1 $arg2"
|
|
cat "$te"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
fi
|
|
}
|
|
|
|
# test if the socat executable has these address types compiled in
|
|
# print the first missing address type
|
|
testaddrs () {
|
|
local a A;
|
|
for a in $@; do
|
|
A=$(echo "$a" |tr 'a-z-' 'A-Z_')
|
|
if $SOCAT -V |grep "#define WITH_$A 1\$" >/dev/null; then
|
|
shift
|
|
continue
|
|
fi
|
|
echo "$a"
|
|
return 1
|
|
done
|
|
return 0
|
|
}
|
|
|
|
# test if the socat executable has these options compiled in
|
|
# print the first missing option
|
|
testoptions () {
|
|
local a A;
|
|
for a in $@; do
|
|
A=$(echo "$a" |tr 'a-z' 'A-Z')
|
|
if $SOCAT -??? |grep "[^a-z0-9-]$a[^a-z0-9-]" >/dev/null; then
|
|
shift
|
|
continue
|
|
fi
|
|
echo "$a"
|
|
return 1
|
|
done
|
|
return 0
|
|
}
|
|
|
|
unset HAVENOT_IP4
|
|
# check if an IP4 loopback interface exists
|
|
runsip4 () {
|
|
[ -n "$HAVENOT_IP4" ] && return $HAVENOT_IP4
|
|
local l
|
|
case "$UNAME" in
|
|
AIX) l=$($IFCONFIG lo0 |fgrep 'inet 127.0.0.1 ') ;;
|
|
FreeBSD) l=$($IFCONFIG lo0 |fgrep 'inet 127.0.0.1 ') ;;
|
|
HP-UX) l=$($IFCONFIG lo0 |fgrep 'inet 127.0.0.1 ') ;;
|
|
Linux) l=$($IFCONFIG |fgrep 'inet addr:127.0.0.1 ') ;;
|
|
NetBSD)l=$($IFCONFIG -a |fgrep 'inet 127.0.0.1 ');;
|
|
OpenBSD)l=$($IFCONFIG -a |fgrep 'inet 127.0.0.1 ');;
|
|
OSF1) l=$($IFCONFIG -a |grep ' inet ') ;;
|
|
SunOS) l=$($IFCONFIG -a |grep 'inet ') ;;
|
|
# *) l=$($IFCONFIG -a |grep ' ::1[^:0-9A-Fa-f]') ;;
|
|
esac
|
|
[ -z "$l" ] && return 1
|
|
# existence of interface might not suffice, check for routeability:
|
|
case "$UNAME" in
|
|
Darwin) ping -c 1 127.0.0.1; l="$?" ;;
|
|
Linux) ping -c 1 127.0.0.1; l="$?" ;;
|
|
*) if [ -n "$l" ]; then l=0; else l=1; fi ;;
|
|
esac
|
|
HAVENOT_IP4=$l
|
|
return $l;
|
|
}
|
|
|
|
unset HAVENOT_IP6
|
|
# check if an IP6 loopback interface exists
|
|
runsip6 () {
|
|
[ -n "$HAVENOT_IP6" ] && return $HAVENOT_IP6
|
|
local l
|
|
case "$UNAME" in
|
|
AIX) l=$(/usr/sbin/ifconfig lo0 |grep 'inet6 ::1/0') ;;
|
|
HP-UX) l=$(/usr/sbin/ifconfig lo0 |grep ' inet6 ') ;;
|
|
Linux) l=$(/sbin/ifconfig |grep 'inet6 addr: ::1/') ;;
|
|
NetBSD)l=$(/sbin/ifconfig -a |grep 'inet6 ::1 ');;
|
|
OSF1) l=$(/sbin/ifconfig -a |grep ' inet6 ') ;;
|
|
SunOS) l=$(/sbin/ifconfig -a |grep 'inet6 ') ;;
|
|
*) l=$(/sbin/ifconfig -a |grep ' ::1[^:0-9A-Fa-f]') ;;
|
|
esac
|
|
[ -z "$l" ] && return 1
|
|
# existence of interface might not suffice, check for routeability:
|
|
case "$UNAME" in
|
|
Darwin) ping -c 1 ::1; l="$?" ;;
|
|
Linux) ping6 -c 1 ::1; l="$?" ;;
|
|
*) if [ -n "$l" ]; then l=0; else l=1; fi ;;
|
|
esac
|
|
HAVENOT_IP6=$l
|
|
return $l;
|
|
}
|
|
|
|
# wait until an IP4 protocol is ready
|
|
waitip4proto () {
|
|
local proto="$1"
|
|
local logic="$2" # 0..wait until free; 1..wait until listening
|
|
local timeout="$3"
|
|
local l
|
|
[ "$logic" ] || logic=1
|
|
[ "$timeout" ] || timeout=5
|
|
while [ $timeout -gt 0 ]; do
|
|
case "$UNAME" in
|
|
Linux) l=$(netstat -n -w -l |grep '^raw .* .*[0-9*]:'$proto' [ ]*0\.0\.0\.0:\*') ;;
|
|
# FreeBSD) l=$(netstat -an |grep '^raw4[6 ] .*[0-9*]\.'$proto' .* \*\.\*') ;;
|
|
# NetBSD) l=$(netstat -an |grep '^raw .*[0-9*]\.'$proto' [ ]* \*\.\*') ;;
|
|
# OpenBSD) l=$(netstat -an |grep '^raw .*[0-9*]\.'$proto' [ ]* \*\.\*') ;;
|
|
# Darwin) case "$(uname -r)" in
|
|
# [1-5]*) l=$(netstat -an |grep '^raw.* .*[0-9*]\.'$proto' .* \*\.\*') ;;
|
|
# *) l=$(netstat -an |grep '^raw4.* .*[0-9*]\.'$proto' .* \*\.\* .*') ;;
|
|
# esac ;;
|
|
AIX) # does not seem to show raw sockets in netstat
|
|
sleep 1; return 0 ;;
|
|
# SunOS) l=$(netstat -an -f inet -P raw |grep '.*[1-9*]\.'$proto' [ ]*Idle') ;;
|
|
# HP-UX) l=$(netstat -an |grep '^raw 0 0 .*[0-9*]\.'$proto' .* \*\.\* ') ;;
|
|
# OSF1) l=$(/usr/sbin/netstat -an |grep '^raw 0 0 .*[0-9*]\.'$proto' [ ]*\*\.\*') ;;
|
|
*) #l=$(netstat -an |grep -i 'raw .*[0-9*][:.]'$proto' ') ;;
|
|
sleep 1; return 0 ;;
|
|
esac
|
|
[ \( \( $logic -ne 0 \) -a -n "$l" \) -o \
|
|
\( \( $logic -eq 0 \) -a -z "$l" \) ] && return 0
|
|
sleep 1
|
|
timeout=$((timeout-1))
|
|
done
|
|
|
|
$ECHO "!protocol $proto timed out! \c" >&2
|
|
return 1
|
|
}
|
|
|
|
# we need this misleading function name for canonical reasons
|
|
waitip4port () {
|
|
waitip4proto "$1" "$2" "$3"
|
|
}
|
|
|
|
# wait until an IP6 protocol is ready
|
|
waitip6proto () {
|
|
local proto="$1"
|
|
local logic="$2" # 0..wait until free; 1..wait until listening
|
|
local timeout="$3"
|
|
local l
|
|
[ "$logic" ] || logic=1
|
|
[ "$timeout" ] || timeout=5
|
|
while [ $timeout -gt 0 ]; do
|
|
case "$UNAME" in
|
|
Linux) l=$(netstat -n -w -l |grep '^raw .* .*:[0-9*]*:'$proto' [ ]*:::\*') ;;
|
|
# FreeBSD) l=$(netstat -an |grep '^raw4[6 ] .*[0-9*]\.'$proto' .* \*\.\*') ;;
|
|
# NetBSD) l=$(netstat -an |grep '^raw .*[0-9*]\.'$proto' [ ]* \*\.\*') ;;
|
|
# OpenBSD) l=$(netstat -an |grep '^raw .*[0-9*]\.'$proto' [ ]* \*\.\*') ;;
|
|
# Darwin) case "$(uname -r)" in
|
|
# [1-5]*) l=$(netstat -an |grep '^raw.* .*[0-9*]\.'$proto' .* \*\.\*') ;;
|
|
# *) l=$(netstat -an |grep '^raw4.* .*[0-9*]\.'$proto' .* \*\.\* .*') ;;
|
|
# esac ;;
|
|
AIX) # does not seem to show raw sockets in netstat
|
|
sleep 1; return 0 ;;
|
|
# SunOS) l=$(netstat -an -f inet -P raw |grep '.*[1-9*]\.'$proto' [ ]*Idle') ;;
|
|
# HP-UX) l=$(netstat -an |grep '^raw 0 0 .*[0-9*]\.'$proto' .* \*\.\* ') ;;
|
|
# OSF1) l=$(/usr/sbin/netstat -an |grep '^raw 0 0 .*[0-9*]\.'$proto' [ ]*\*\.\*') ;;
|
|
*) #l=$(netstat -an |grep -i 'raw .*[0-9*][:.]'$proto' ') ;;
|
|
sleep 1; return 0 ;;
|
|
esac
|
|
[ \( \( $logic -ne 0 \) -a -n "$l" \) -o \
|
|
\( \( $logic -eq 0 \) -a -z "$l" \) ] && return 0
|
|
sleep 1
|
|
timeout=$((timeout-1))
|
|
done
|
|
|
|
$ECHO "!protocol $proto timed out! \c" >&2
|
|
return 1
|
|
}
|
|
|
|
# we need this misleading function name for canonical reasons
|
|
waitip6port () {
|
|
waitip6proto "$1" "$2" "$3"
|
|
}
|
|
|
|
# wait until a TCP4 listen port is ready
|
|
waittcp4port () {
|
|
local port="$1"
|
|
local logic="$2" # 0..wait until free; 1..wait until listening
|
|
local timeout="$3"
|
|
local l
|
|
[ "$logic" ] || logic=1
|
|
[ "$timeout" ] || timeout=5
|
|
while [ $timeout -gt 0 ]; do
|
|
case "$UNAME" in
|
|
Linux) l=$(netstat -n -t -l |grep '^tcp .* .*[0-9*]:'$port' .* LISTEN') ;;
|
|
FreeBSD) l=$(netstat -an |grep '^tcp4.* .*[0-9*]\.'$port' .* \*\.\* .* LISTEN') ;;
|
|
NetBSD) l=$(netstat -an |grep '^tcp .* .*[0-9*]\.'$port' [ ]* \*\.\* [ ]* LISTEN.*') ;;
|
|
Darwin) case "$(uname -r)" in
|
|
[1-5]*) l=$(netstat -an |grep '^tcp.* .*[0-9*]\.'$port' .* \*\.\* .* LISTEN') ;;
|
|
*) l=$(netstat -an |grep '^tcp4.* .*[0-9*]\.'$port' .* \*\.\* .* LISTEN') ;;
|
|
esac ;;
|
|
AIX) l=$(netstat -an |grep '^tcp[^6] 0 0 .*[*0-9]\.'$port' .* LISTEN$') ;;
|
|
SunOS) l=$(netstat -an -f inet -P tcp |grep '.*[1-9*]\.'$port' .*\* 0 .* LISTEN') ;;
|
|
HP-UX) l=$(netstat -an |grep '^tcp 0 0 .*[0-9*]\.'$port' .* LISTEN$') ;;
|
|
OSF1) l=$(/usr/sbin/netstat -an |grep '^tcp 0 0 .*[0-9*]\.'$port' [ ]*\*\.\* [ ]*LISTEN') ;;
|
|
CYGWIN*) l=$(netstat -an -p TCP |grep '^ TCP [0-9.]*:'$port' .* LISTENING') ;;
|
|
*) l=$(netstat -an |grep -i 'tcp .*[0-9*][:.]'$port' .* listen') ;;
|
|
esac
|
|
[ \( \( $logic -ne 0 \) -a -n "$l" \) -o \
|
|
\( \( $logic -eq 0 \) -a -z "$l" \) ] && return 0
|
|
sleep 1
|
|
timeout=$((timeout-1))
|
|
done
|
|
|
|
$ECHO "!port $port timed out! \c" >&2
|
|
return 1
|
|
}
|
|
|
|
# wait until a UDP4 port is ready
|
|
waitudp4port () {
|
|
local port="$1"
|
|
local logic="$2" # 0..wait until free; 1..wait until listening
|
|
local timeout="$3"
|
|
local l
|
|
[ "$logic" ] || logic=1
|
|
[ "$timeout" ] || timeout=5
|
|
while [ $timeout -gt 0 ]; do
|
|
case "$UNAME" in
|
|
Linux) l=$(netstat -n -u -l |grep '^udp .* .*[0-9*]:'$port' [ ]*0\.0\.0\.0:\*') ;;
|
|
FreeBSD) l=$(netstat -an |grep '^udp4[6 ] .*[0-9*]\.'$port' .* \*\.\*') ;;
|
|
NetBSD) l=$(netstat -an |grep '^udp .*[0-9*]\.'$port' [ ]* \*\.\*') ;;
|
|
OpenBSD) l=$(netstat -an |grep '^udp .*[0-9*]\.'$port' [ ]* \*\.\*') ;;
|
|
Darwin) case "$(uname -r)" in
|
|
[1-5]*) l=$(netstat -an |grep '^udp.* .*[0-9*]\.'$port' .* \*\.\*') ;;
|
|
*) l=$(netstat -an |grep '^udp4.* .*[0-9*]\.'$port' .* \*\.\* .*') ;;
|
|
esac ;;
|
|
AIX) l=$(netstat -an |grep '^udp[4 ] 0 0 .*[*0-9]\.'$port' .* \*\.\*[ ]*$') ;;
|
|
SunOS) l=$(netstat -an -f inet -P udp |grep '.*[1-9*]\.'$port' [ ]*Idle') ;;
|
|
HP-UX) l=$(netstat -an |grep '^udp 0 0 .*[0-9*]\.'$port' .* \*\.\* ') ;;
|
|
OSF1) l=$(/usr/sbin/netstat -an |grep '^udp 0 0 .*[0-9*]\.'$port' [ ]*\*\.\*') ;;
|
|
*) l=$(netstat -an |grep -i 'udp .*[0-9*][:.]'$port' ') ;;
|
|
esac
|
|
[ \( \( $logic -ne 0 \) -a -n "$l" \) -o \
|
|
\( \( $logic -eq 0 \) -a -z "$l" \) ] && return 0
|
|
sleep 1
|
|
timeout=$((timeout-1))
|
|
done
|
|
|
|
$ECHO "!port $port timed out! \c" >&2
|
|
return 1
|
|
}
|
|
|
|
# wait until a tcp6 listen port is ready
|
|
waittcp6port () {
|
|
local port="$1"
|
|
local logic="$2" # 0..wait until free; 1..wait until listening
|
|
local timeout="$3"
|
|
local l
|
|
[ "$logic" ] || logic=1
|
|
[ "$timeout" ] || timeout=5
|
|
while [ $timeout -gt 0 ]; do
|
|
case "$UNAME" in
|
|
Linux) l=$(netstat -an |grep '^tcp[6 ] .* [0-9a-f:]*:'$port' .* LISTEN') ;;
|
|
FreeBSD) l=$(netstat -an |grep -i 'tcp[46][6 ] .*[0-9*][:.]'$port' .* listen') ;;
|
|
NetBSD) l=$(netstat -an |grep '^tcp6 .*[0-9*]\.'$port' [ ]* \*\.\*') ;;
|
|
OpenBSD) l=$(netstat -an |grep -i 'tcp6 .*[0-9*][:.]'$port' .* listen') ;;
|
|
AIX) l=$(netstat -an |grep '^tcp[6 ] 0 0 .*[*0-9]\.'$port' .* LISTEN$') ;;
|
|
SunOS) l=$(netstat -an -f inet6 -P tcp |grep '.*[1-9*]\.'$port' .*\* [ ]* 0 .* LISTEN') ;;
|
|
#OSF1) l=$(/usr/sbin/netstat -an |grep '^tcp6 0 0 .*[0-9*]\.'$port' [ ]*\*\.\* [ ]*LISTEN') /*?*/;;
|
|
*) l=$(netstat -an |grep -i 'tcp6 .*:'$port' .* listen') ;;
|
|
esac
|
|
[ \( \( $logic -ne 0 \) -a -n "$l" \) -o \
|
|
\( \( $logic -eq 0 \) -a -z "$l" \) ] && return 0
|
|
sleep 1
|
|
timeout=$((timeout-1))
|
|
done
|
|
|
|
$ECHO "!port $port timed out! \c" >&2
|
|
return 1
|
|
}
|
|
|
|
# wait until a UDP6 port is ready
|
|
waitudp6port () {
|
|
local port="$1"
|
|
local logic="$2" # 0..wait until free; 1..wait until listening
|
|
local timeout="$3"
|
|
local l
|
|
[ "$logic" ] || logic=1
|
|
[ "$timeout" ] || timeout=5
|
|
while [ $timeout -gt 0 ]; do
|
|
case "$UNAME" in
|
|
Linux) l=$(netstat -an |grep '^udp[6 ] .* .*[0-9*:]:'$port' [ ]*:::\*') ;;
|
|
FreeBSD) l=$(netstat -an |egrep '^udp(6|46) .*[0-9*]\.'$port' .* \*\.\*') ;;
|
|
NetBSD) l=$(netstat -an |grep '^udp6 .* \*\.'$port' [ ]* \*\.\*') ;;
|
|
OpenBSD) l=$(netstat -an |grep '^udp6 .*[0-9*]\.'$port' [ ]* \*\.\*') ;;
|
|
#Darwin) l=$(netstat -an |grep '^udp6.* .*[0-9*]\.'$port' .* \*\.\* ') ;;
|
|
AIX) l=$(netstat -an |grep '^udp[6 ] 0 0 .*[*0-9]\.'$port' .* \*\.\*[ ]*$') ;;
|
|
SunOS) l=$(netstat -an -f inet6 -P udp |grep '.*[1-9*]\.'$port' [ ]*Idle') ;;
|
|
#HP-UX) l=$(netstat -an |grep '^udp 0 0 .*[0-9*]\.'$port' ') ;;
|
|
#OSF1) l=$(/usr/sbin/netstat -an |grep '^udp6 0 0 .*[0-9*]\.'$port' [ ]*\*\.\*') ;;
|
|
*) l=$(netstat -an |grep -i 'udp .*[0-9*][:.]'$port' ') ;;
|
|
esac
|
|
[ \( \( $logic -ne 0 \) -a -n "$l" \) -o \
|
|
\( \( $logic -eq 0 \) -a -z "$l" \) ] && return 0
|
|
sleep 1
|
|
timeout=$((timeout-1))
|
|
done
|
|
|
|
$ECHO "!port $port timed out! \c" >&2
|
|
return 1
|
|
}
|
|
|
|
# wait until a filesystem entry exists
|
|
waitfile () {
|
|
local crit=-e
|
|
case "X$1" in X-*) crit="$1"; shift ;; esac
|
|
local file="$1"
|
|
local logic="$2" # 0..wait until gone; 1..wait until exists (default)
|
|
local timeout="$3"
|
|
[ "$logic" ] || logic=1
|
|
[ "$timeout" ] || timeout=5
|
|
while [ $timeout -gt 0 ]; do
|
|
if [ \( \( $logic -ne 0 \) -a $crit "$file" \) -o \
|
|
\( \( $logic -eq 0 \) -a ! $crit "$file" \) ]; then
|
|
return 0
|
|
fi
|
|
sleep 1
|
|
timeout=$((timeout-1))
|
|
done
|
|
|
|
echo "file $file timed out" >&2
|
|
return 1
|
|
}
|
|
|
|
# generate a test certificate and key
|
|
gentestcert () {
|
|
local name="$1"
|
|
if [ -f $name.key -a -f $name.crt -a -f $name.pem ]; then return; fi
|
|
openssl genrsa $OPENSSL_RAND -out $name.key 768 >/dev/null 2>&1
|
|
openssl req -new -config testcert.conf -key $name.key -x509 -out $name.crt >/dev/null 2>&1
|
|
cat $name.key $name.crt >$name.pem
|
|
}
|
|
|
|
# generate a test DSA key and certificate
|
|
gentestdsacert () {
|
|
local name="$1"
|
|
if [ -f $name.key -a -f $name.crt -a -f $name.pem ]; then return; fi
|
|
openssl dsaparam -out $name-dsa.pem 512 >/dev/null 2>&1
|
|
openssl dhparam -dsaparam -out $name-dh.pem 512 >/dev/null 2>&1
|
|
openssl req -newkey dsa:$name-dsa.pem -keyout $name.key -nodes -x509 -config testcert.conf -out $name.crt >/dev/null 2>&1
|
|
cat $name-dsa.pem $name-dh.pem $name.key $name.crt >$name.pem
|
|
}
|
|
|
|
|
|
NAME=UNISTDIO
|
|
case "$TESTS " in
|
|
*%functions%*|*%stdio%*|*%$NAME%*)
|
|
TEST="$NAME: unidirectional throughput from stdin to stdout"
|
|
testecho "$N" "$TEST" "stdin" "stdout" "$opts -u"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UNPIPESTDIO
|
|
case "$TESTS" in
|
|
*%functions%*|*%stdio%*|*%$NAME%*)
|
|
TEST="$NAME: stdio with simple echo via internal pipe"
|
|
testecho "$N" "$TEST" "stdio" "pipe" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UNPIPESHORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%stdio%*|*%$NAME%*)
|
|
TEST="$NAME: short form of stdio ('-') with simple echo via internal pipe"
|
|
testecho "$N" "$TEST" "-" "pipe" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=DUALSTDIO
|
|
case "$TESTS" in
|
|
*%functions%*|*%stdio%*|*%$NAME%*)
|
|
TEST="$NAME: splitted form of stdio ('stdin!!stdout') with simple echo via internal pipe"
|
|
testecho "$N" "$TEST" "stdin!!stdout" "pipe" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=DUALSHORTSTDIO
|
|
case "$TESTS" in
|
|
*%functions%*|*%stdio%*|*%$NAME%*)
|
|
TEST="$NAME: short splitted form of stdio ('-!!-') with simple echo via internal pipe"
|
|
testecho "$N" "$TEST" "-!!-" "pipe" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=DUALFDS
|
|
case "$TESTS" in
|
|
*%functions%*|*%fd%*|*%$NAME%*)
|
|
TEST="$NAME: file descriptors with simple echo via internal pipe"
|
|
testecho "$N" "$TEST" "0!!1" "pipe" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=NAMEDPIPE
|
|
case "$TESTS" in
|
|
*%functions%*|*%pipe%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via named pipe"
|
|
# with MacOS, this test hangs if nonblock is not used. Is an OS bug.
|
|
tp="$td/pipe$N"
|
|
# note: the nonblock is required by MacOS 10.1(?), otherwise it hangs (OS bug?)
|
|
testecho "$N" "$TEST" "" "pipe:$tp,nonblock" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=DUALPIPE
|
|
case "$TESTS" in
|
|
*%functions%*|*%pipe%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via named pipe, specified twice"
|
|
tp="$td/pipe$N"
|
|
testecho "$N" "$TEST" "" "pipe:$tp,nonblock!!pipe:$tp" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=FILE
|
|
case "$TESTS" in
|
|
*%functions%*|*%file%*|*%ignoreeof%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via file"
|
|
tf="$td/file$N"
|
|
testecho "$N" "$TEST" "" "$tf,ignoreeof!!$tf" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=EXECSOCKET
|
|
case "$TESTS" in
|
|
*%functions%*|*%exec%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via exec of cat with socketpair"
|
|
testecho "$N" "$TEST" "" "exec:$CAT" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=SYSTEMSOCKET
|
|
case "$TESTS" in
|
|
*%functions%*|*%system%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via system() of cat with socketpair"
|
|
testecho "$N" "$TEST" "" "system:$CAT" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=EXECPIPES
|
|
case "$TESTS" in
|
|
*%functions%*|*%pipe%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via exec of cat with pipes"
|
|
testecho "$N" "$TEST" "" "exec:$CAT,pipes" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=SYSTEMPIPES
|
|
case "$TESTS" in
|
|
*%functions%*|*%pipes%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via system() of cat with pipes"
|
|
testecho "$N" "$TEST" "" "system:$CAT,pipes" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=EXECPTY
|
|
case "$TESTS" in
|
|
*%functions%*|*%exec%*|*%pty%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via exec of cat with pseudo terminal"
|
|
if ! testaddrs pty >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}PTY not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testecho "$N" "$TEST" "" "exec:$CAT,pty,$PTYOPTS" "$opts"
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=SYSTEMPTY
|
|
case "$TESTS" in
|
|
*%functions%*|*%system%*|*%pty%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via system() of cat with pseudo terminal"
|
|
if ! testaddrs pty >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}PTY not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testecho "$N" "$TEST" "" "system:$CAT,pty,$PTYOPTS" "$opts"
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=SYSTEMPIPESFDS
|
|
case "$TESTS" in
|
|
*%functions%*|*%system%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via system() of cat with pipes, non stdio"
|
|
testecho "$N" "$TEST" "" "system:$CAT>&9 <&8,pipes,fdin=8,fdout=9" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=DUALSYSTEMFDS
|
|
case "$TESTS" in
|
|
*%functions%*|*%system%*|*%$NAME%*)
|
|
TEST="$NAME: echo via dual system() of cat"
|
|
testecho "$N" "$TEST" "system:$CAT>&6,fdout=6!!system:$CAT<&7,fdin=7" "" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=EXECSOCKETFLUSH
|
|
case "$TESTS" in
|
|
*%functions%*|*%exec%*|*%$NAME%*)
|
|
TEST="$NAME: call to od via exec with socketpair"
|
|
testod "$N" "$TEST" "" "exec:$OD_C" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=SYSTEMSOCKETFLUSH
|
|
case "$TESTS" in
|
|
*%functions%*|*%system%*|*%$NAME%*)
|
|
TEST="$NAME: call to od via system() with socketpair"
|
|
testod "$N" "$TEST" "" "system:$OD_C" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=EXECPIPESFLUSH
|
|
case "$TESTS" in
|
|
*%functions%*|*%exec%*|*%$NAME%*)
|
|
TEST="$NAME: call to od via exec with pipes"
|
|
testod "$N" "$TEST" "" "exec:$OD_C,pipes" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
## LATER:
|
|
#NAME=SYSTEMPIPESFLUSH
|
|
#case "$TESTS" in
|
|
#*%functions%*|*%system%*|*%$NAME%*)
|
|
#TEST="$NAME: call to od via system() with pipes"
|
|
#testod "$N" "$TEST" "" "system:$OD_C,pipes" "$opts"
|
|
#esac
|
|
#N=$((N+1))
|
|
|
|
|
|
## LATER:
|
|
#NAME=EXECPTYFLUSH
|
|
#case "$TESTS" in
|
|
#*%functions%*|*%exec%*|*%pty%*|*%$NAME%*)
|
|
#TEST="$NAME: call to od via exec with pseudo terminal"
|
|
#if ! testaddrs pty >/dev/null; then
|
|
# $PRINTF "test $F_n $TEST... ${YELLOW}PTY not available${NORMAL}\n" $N
|
|
# numCANT=$((numCANT+1))
|
|
#else
|
|
#testod "$N" "$TEST" "" "exec:$OD_C,pty,$PTYOPTS" "$opts"
|
|
#fi
|
|
#esac
|
|
#N=$((N+1))
|
|
|
|
|
|
## LATER:
|
|
#NAME=SYSTEMPTYFLUSH
|
|
#case "$TESTS" in
|
|
#*%functions%*|*%system%*|*%pty%*|*%$NAME%*)
|
|
#TEST="$NAME: call to od via system() with pseudo terminal"
|
|
#if ! testaddrs pty >/dev/null; then
|
|
# $PRINTF "test $F_n $TEST... ${YELLOW}PTY not available${NORMAL}\n" $N
|
|
# numCANT=$((numCANT+1))
|
|
#else
|
|
#testod "$N" "$TEST" "" "system:$OD_C,pty,$PTYOPTS" "$opts"
|
|
#fi
|
|
#esac
|
|
#N=$((N+1))
|
|
|
|
|
|
## LATER:
|
|
#NAME=SYSTEMPIPESFDSFLUSH
|
|
#case "$TESTS" in
|
|
#*%functions%*|*%system%*|*%$NAME%*)
|
|
#TEST="$NAME: call to od via system() with pipes, non stdio"
|
|
#testod "$N" "$TEST" "" "system:$OD_C>&9 <&8,pipes,fdin=8,fdout=9" "$opts"
|
|
#esac
|
|
#N=$((N+1))
|
|
|
|
|
|
## LATER:
|
|
#NAME=DUALSYSTEMFDSFLUSH
|
|
#case "$TESTS" in
|
|
#*%functions%*|*%system%*|*%$NAME%*)
|
|
#TEST="$NAME: call to od via dual system()"
|
|
#testecho "$N" "$TEST" "system:$OD_C>&6,fdout=6!!system:$CAT<&7,fdin=7" "" "$opts"
|
|
#esac
|
|
#N=$((N+1))
|
|
|
|
|
|
case "$UNAME" in
|
|
Linux) IPPROTO=254 ;;
|
|
Darwin) IPPROTO=255 ;;
|
|
*) IPPROTO=254 ;; # just a guess
|
|
esac
|
|
|
|
NAME=RAWIP4SELF
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip4%*|*%rawip%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via self receiving raw IPv4 protocol"
|
|
if ! feat=$(testaddrs ip4) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testaddrs rawip) >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}RAWIP not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testecho "$N" "$TEST" "" "ip4:127.0.0.1:$IPPROTO" "$opts"
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
NAME=RAWIPX4SELF
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip4%*|*%rawip%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via self receiving raw IP protocol, v4 by target"
|
|
if ! feat=$(testaddrs ip4) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testaddrs rawip) >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}RAWIP not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testecho "$N" "$TEST" "" "ip:127.0.0.1:$IPPROTO" "$opts"
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
NAME=RAWIP6SELF
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip6%*|*%rawip%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via self receiving raw IPv6 protocol"
|
|
if ! feat=$(testaddrs ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testaddrs rawip) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}RAWIP not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testecho "$N" "$TEST" "" "ip6:[::1]:$IPPROTO" "$opts"
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
NAME=RAWIPX6SELF
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip%*|*%ip6%*|*%rawip%*|*%rawip6%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via self receiving raw IP protocol, v6 by target"
|
|
if ! feat=$(testaddrs ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testaddrs rawip) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}RAWIP not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testecho "$N" "$TEST" "" "ip:[::1]:$IPPROTO" "$opts"
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=TCPSELF
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: echo via self connection of TCP IPv4 socket"
|
|
if [ "$UNAME" != Linux ]; then
|
|
#printf "test $F_n $TEST... ${YELLOW}only on Linux${NORMAL}\n" $N
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}only on Linux$NORMAL\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
#ts="127.0.0.1:$tsl"
|
|
testecho "$N" "$TEST" "" "tcp:127.100.0.1:$PORT,sp=$PORT,bind=127.100.0.1,reuseaddr" "$opts"
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDPSELF
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: echo via self connection of UDP IPv4 socket"
|
|
if [ "$UNAME" != Linux ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}only on Linux$NORMAL\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testecho "$N" "$TEST" "" "udp:127.100.0.1:$PORT,sp=$PORT,bind=127.100.0.1" "$opts"
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP6SELF
|
|
case "$TESTS" in
|
|
*%functions%*|*%udp%*|*%udp6%*|*%ip6%*|*%$NAME%*)
|
|
TEST="$NAME: echo via self connection of UDP IPv6 socket"
|
|
if [ "$UNAME" != Linux ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}only on Linux${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs udp ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/file$N"
|
|
testecho "$N" "$TEST" "" "udp6:[::1]:$PORT,sp=$PORT,bind=[::1]" "$opts"
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=DUALUDPSELF
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: echo via two unidirectional UDP IPv4 sockets"
|
|
tf="$td/file$N"
|
|
p1=$PORT
|
|
p2=$((PORT+1))
|
|
testecho "$N" "$TEST" "" "udp:127.0.0.1:$p2,sp=$p1!!udp:127.0.0.1:$p1,sp=$p2" "$opts"
|
|
esac
|
|
PORT=$((PORT+2))
|
|
N=$((N+1))
|
|
|
|
|
|
#function testdual {
|
|
# local
|
|
#}
|
|
|
|
|
|
NAME=UNIXSOCKET
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: echo via connection to UNIX domain socket"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
ts="$td/test$N.socket"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts UNIX-LISTEN:$ts PIPE"
|
|
CMD2="$SOCAT $opts -!!- UNIX:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 </dev/null >$tf 2>"${te}1" &
|
|
bg=$! # background process id
|
|
waitfile "$ts"
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $bg 2>/dev/null
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=TCP4
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip4%*|*%ipapp%*|*%tcp%*|*%$NAME%*)
|
|
TEST="$NAME: echo via connection to TCP V4 socket"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="127.0.0.1:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts TCP4-LISTEN:$tsl,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts stdin!!stdout TCP4:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
waittcp4port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi ;;
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=TCP6
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip6%*|*%ipapp%*|*%tcp%*|*%$NAME%*)
|
|
TEST="$NAME: echo via connection to TCP V6 socket"
|
|
if ! testaddrs tcp ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="[::1]:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts TCP6-listen:$tsl,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts stdin!!stdout TCP6:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid=$! # background process id
|
|
waittcp6port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=TCPX4
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip4%*|*%ipapp%*|*%tcp%*|*%$NAME%*)
|
|
TEST="$NAME: echo via connection to TCP socket, v4 by target"
|
|
if ! testaddrs tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="127.0.0.1:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts TCP-listen:$tsl,pf=ip4,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts stdin!!stdout TCP:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid=$! # background process id
|
|
waittcp4port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=TCPX6
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip6%*|*%ipapp%*|*%tcp%*|*%$NAME%*)
|
|
TEST="$NAME: echo via connection to TCP socket, v6 by target"
|
|
if ! testaddrs tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="[::1]:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts TCP-listen:$tsl,pf=ip6,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts stdin!!stdout TCP:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid=$! # background process id
|
|
waittcp6port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=IPV6ONLY0
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip6%*|*%ipapp%*|*%tcp%*|*%$NAME%*)
|
|
TEST="$NAME: option ipv6-v6only=0 listens on IPv4"
|
|
if ! testaddrs tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testoptions ipv6-v6only); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="127.0.0.1:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts TCP6-listen:$tsl,ipv6-v6only=0,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts stdin!!stdout TCP4:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid=$! # background process id
|
|
waittcp6port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1" "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=IPV6ONLY1
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip6%*|*%ipapp%*|*%tcp%*|*%$NAME%*)
|
|
TEST="$NAME: option ipv6-v6only=1 does not listen on IPv4"
|
|
if ! testaddrs tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testoptions ipv6-v6only); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="127.0.0.1:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts TCP6-listen:$tsl,ipv6-v6only=1,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts stdin!!stdout TCP4:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid=$! # background process id
|
|
waittcp6port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -eq 0 ]; then
|
|
$PRINTF "$FAILED:\n"
|
|
cat "${te}1" "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED:\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=ENV_LISTEN_4
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip6%*|*%ipapp%*|*%tcp%*|*%$NAME%*)
|
|
TEST="$NAME: env SOCAT_DEFAULT_LISTEN_IP for IPv4 preference on listen"
|
|
if ! testaddrs tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testoptions ipv6-v6only); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="127.0.0.1:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts TCP-listen:$tsl,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts stdin!!stdout TCP4:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
SOCAT_DEFAULT_LISTEN_IP=4 $CMD1 >"$tf" 2>"${te}1" &
|
|
pid=$! # background process id
|
|
waittcp4port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1" "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=ENV_LISTEN_6
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip6%*|*%ipapp%*|*%tcp%*|*%$NAME%*)
|
|
TEST="$NAME: env SOCAT_DEFAULT_LISTEN_IP for IPv6 preference on listen"
|
|
if ! testaddrs tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="[::1]:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts TCP-listen:$tsl,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts stdin!!stdout TCP6:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
SOCAT_DEFAULT_LISTEN_IP=6 $CMD1 >"$tf" 2>"${te}1" &
|
|
pid=$! # background process id
|
|
waittcp6port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1" "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=LISTEN_OPTION_4
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip6%*|*%ipapp%*|*%tcp%*|*%$NAME%*)
|
|
TEST="$NAME: option -4 for IPv4 preference on listen"
|
|
if ! testaddrs tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testoptions ipv6-v6only); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="127.0.0.1:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts -4 TCP-listen:$tsl,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts stdin!!stdout TCP4:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
SOCAT_DEFAULT_LISTEN_IP=6 $CMD1 >"$tf" 2>"${te}1" &
|
|
pid=$! # background process id
|
|
waittcp4port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1" "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=LISTEN_OPTION_6
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip6%*|*%ipapp%*|*%tcp%*|*%$NAME%*)
|
|
TEST="$NAME: option -6 for IPv6 preference on listen"
|
|
if ! testaddrs tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="[::1]:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts -6 TCP-listen:$tsl,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts stdin!!stdout TCP6:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
SOCAT_DEFAULT_LISTEN_IP=4 $CMD1 >"$tf" 2>"${te}1" &
|
|
pid=$! # background process id
|
|
waittcp6port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1" "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi # feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=LISTEN_PF_IP4
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip6%*|*%ipapp%*|*%tcp%*|*%$NAME%*)
|
|
TEST="$NAME: pf=4 overrides option -6 on listen"
|
|
if ! testaddrs tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testoptions ipv6-v6only); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="127.0.0.1:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts -6 TCP-listen:$tsl,pf=ip4,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts stdin!!stdout TCP4:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
SOCAT_DEFAULT_LISTEN_IP=6 $CMD1 >"$tf" 2>"${te}1" &
|
|
pid=$! # background process id
|
|
waittcp4port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1" "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=LISTEN_PF_IP6
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip6%*|*%ipapp%*|*%tcp%*|*%$NAME%*)
|
|
TEST="$NAME: pf=6 overrides option -4 on listen"
|
|
if ! testaddrs tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="[::1]:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts -4 TCP-listen:$tsl,pf=ip6,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts stdin!!stdout TCP6:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
SOCAT_DEFAULT_LISTEN_IP=4 $CMD1 >"$tf" 2>"${te}1" &
|
|
pid=$! # background process id
|
|
waittcp6port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1" "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP4STREAM
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip4%*|*%ipapp%*|*%udp%*|*%$NAME%*)
|
|
TEST="$NAME: echo via connection to UDP V4 socket"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="$LOCALHOST:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts UDP4-LISTEN:$tsl,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts - UDP4:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid1=$!
|
|
waitudp4port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
rc2=$?
|
|
kill $pid1 2>/dev/null; wait
|
|
if [ $rc2 -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1" "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
echo "$CMD1 &"
|
|
cat "${te}1"
|
|
echo "$CMD2"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi ;;
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP6STREAM
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip6%*|*%ipapp%*|*%udp%*|*%$NAME%*)
|
|
TEST="$NAME: echo via connection to UDP V6 socket"
|
|
if ! feat=$(testaddrs udp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="$LOCALHOST6:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts UDP6-LISTEN:$tsl,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts - UDP6:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid1=$!
|
|
waitudp6port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
rc2=$?
|
|
kill $pid1 2>/dev/null; wait
|
|
if [ $rc2 -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1" "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # ! testaddrs
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=GOPENFILE
|
|
case "$TESTS" in
|
|
*%functions%*|*%gopen%*|*%file%*|*%ignoreeof%*|*%$NAME%*)
|
|
TEST="$NAME: file opening with gopen"
|
|
tf1="$td/test$N.1.stdout"
|
|
tf2="$td/test$N.2.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
echo "$da" >$tf1
|
|
CMD="$SOCAT $opts $tf1!!/dev/null /dev/null,ignoreeof!!-"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD >"$tf2" 2>"$te"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! diff "$tf1" "$tf2" >"$tdiff"; then
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=GOPENPIPE
|
|
case "$TESTS" in
|
|
*%functions%*|*%gopen%*|*%pipe%*|*%ignoreeof%*|*%$NAME%*)
|
|
TEST="$NAME: pipe opening with gopen for reading"
|
|
tp="$td/pipe$N"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
CMD="$SOCAT $opts $tp!!/dev/null /dev/null,ignoreeof!!$tf"
|
|
printf "test $F_n $TEST... " $N
|
|
#mknod $tp p # no mknod p on FreeBSD
|
|
mkfifo $tp
|
|
$CMD >$tf 2>"$te" &
|
|
#($CMD >$tf 2>"$te" || rm -f "$tp") 2>/dev/null &
|
|
bg=$! # background process id
|
|
usleep $MICROS
|
|
if [ ! -p "$tp" ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
#echo "$da" >"$tp" # might hang forever
|
|
echo "$da" >"$tp" & export pid=$!; (sleep 1; kill $pid 2>/dev/null) &
|
|
# Solaris needs more time:
|
|
sleep 1
|
|
kill "$bg" 2>/dev/null
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
if [ -s "$te" ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
else
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
fi
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi
|
|
wait
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=GOPENUNIXSTREAM
|
|
case "$TESTS" in
|
|
*%functions%*|*%gopen%*|*%unix%*|*%listen%*|*%$NAME%*)
|
|
TEST="$NAME: GOPEN on UNIX stream socket"
|
|
ts="$td/test$N.socket"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da1="test$N $(date) $RANDOM"
|
|
#establish a listening unix socket in background
|
|
SRV="$SOCAT $opts -lpserver UNIX-LISTEN:\"$ts\" PIPE"
|
|
#make a connection
|
|
CMD="$SOCAT $opts - $ts"
|
|
$PRINTF "test $F_n $TEST... " $N
|
|
eval "$SRV 2>${te}s &"
|
|
pids=$!
|
|
waitfile "$ts"
|
|
echo "$da1" |eval "$CMD" >"${tf}1" 2>"${te}1"
|
|
if [ $? -ne 0 ]; then
|
|
kill "$pids" 2>/dev/null
|
|
$PRINTF "$FAILED:\n"
|
|
echo "$SRV &"
|
|
cat "${te}s"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da1" |diff - "${tf}1" >"$tdiff"; then
|
|
kill "$pids" 2>/dev/null
|
|
$PRINTF "$FAILED:\n"
|
|
echo "$SRV &"
|
|
cat "${te}s"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi # !(rc -ne 0)
|
|
wait
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=GOPENUNIXDGRAM
|
|
case "$TESTS" in
|
|
*%functions%*|*%gopen%*|*%unix%*|*%dgram%*|*%$NAME%*)
|
|
TEST="$NAME: GOPEN on UNIX datagram socket"
|
|
ts="$td/test$N.socket"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da1="test$N $(date) $RANDOM"
|
|
#establish a receiving unix socket in background
|
|
SRV="$SOCAT $opts -u -lpserver UNIX-RECV:\"$ts\" file:\"$tf\",create"
|
|
#make a connection
|
|
CMD="$SOCAT $opts -u - $ts"
|
|
$PRINTF "test $F_n $TEST... " $N
|
|
eval "$SRV 2>${te}s &"
|
|
pids=$!
|
|
waitfile "$ts"
|
|
echo "$da1" |eval "$CMD" 2>"${te}1"
|
|
waitfile -s "$tf"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED:\n"
|
|
echo "$SRV &"
|
|
cat "${te}s"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da1" |diff - "${tf}" >"$tdiff"; then
|
|
$PRINTF "$FAILED:\n"
|
|
echo "$SRV &"
|
|
cat "${te}s"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi # !(rc -ne 0)
|
|
kill "$pids" 2>/dev/null
|
|
wait
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
#set -vx
|
|
NAME=IGNOREEOF
|
|
case "$TESTS" in
|
|
*%functions%*|*%ignoreeof%*|*%$NAME%*)
|
|
TEST="$NAME: ignoreeof on file"
|
|
ti="$td/test$N.file"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date) $RANDOM"
|
|
CMD="$SOCAT $opts -u file:\"$ti\",ignoreeof -"
|
|
printf "test $F_n $TEST... " $N
|
|
touch "$ti"
|
|
$CMD >"$tf" 2>"$te" &
|
|
bg=$!
|
|
sleep 1
|
|
echo "$da" >>"$ti"
|
|
sleep 1
|
|
kill $bg 2>/dev/null
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
if [ -s "$te" ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
else
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
fi
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
wait
|
|
esac
|
|
N=$((N+1))
|
|
#set +vx
|
|
|
|
|
|
NAME=EXECIGNOREEOF
|
|
case "$TESTS" in
|
|
*%functions%*|*%ignoreeof%*|*%$NAME%*)
|
|
TEST="$NAME: exec against address with ignoreeof"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
CMD="$SOCAT $opts -lf /dev/null EXEC:$TRUE /dev/null,ignoreeof"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD >"$tf" 2>"$te"
|
|
if [ -s "$te" ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=FAKEPTY
|
|
case "$TESTS" in
|
|
*%functions%*|*%pty%*|*%$NAME%*)
|
|
TEST="$NAME: generation of pty for other processes"
|
|
if ! testaddrs pty >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}PTY not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tt="$td/pty$N"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts pty,link=$tt pipe"
|
|
CMD2="$SOCAT $opts - $tt,$PTYOPTS2"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" &
|
|
pid=$! # background process id
|
|
waitfile "$tt"
|
|
# this hangs on HP-UX, so we use a timeout
|
|
(echo "$da"; sleep 1) |$CMD2 >$tf 2>"${te}2" &
|
|
rc2=$!
|
|
#sleep 5 && kill $rc2 2>/dev/null &
|
|
wait $rc2
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
sleep 1
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=O_TRUNC
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: option o-trunc"
|
|
ff="$td/test$N.file"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
CMD="$SOCAT -u $opts - open:$ff,append,o-trunc"
|
|
printf "test $F_n $TEST... " $N
|
|
rm -f $ff; $ECHO "prefix-\c" >$ff
|
|
if ! echo "$da" |$CMD >$tf 2>"$te" ||
|
|
! echo "$da" |diff - $ff >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=FTRUNCATE
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: option ftruncate"
|
|
ff="$td/test$N.file"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
CMD="$SOCAT -u $opts - open:$ff,append,ftruncate=0"
|
|
printf "test $F_n $TEST... " $N
|
|
rm -f $ff; $ECHO "prefix-\c" >$ff
|
|
if ! echo "$da" |$CMD >$tf 2>"$te" ||
|
|
! echo "$da" |diff - $ff >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=RIGHTTOLEFT
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: unidirectional throughput from stdin to stdout, right to left"
|
|
testecho "$N" "$TEST" "stdout" "stdin" "$opts -U"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=CHILDDEFAULT
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: child process default properties"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
CMD="$SOCAT $opts -u exec:$PROCAN -"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD >$tf 2>$te
|
|
MYPID=`expr "\`grep "process id =" $tf\`" : '[^0-9]*\([0-9]*\).*'`
|
|
MYPPID=`expr "\`grep "process parent id =" $tf\`" : '[^0-9]*\([0-9]*\).*'`
|
|
MYPGID=`expr "\`grep "process group id =" $tf\`" : '[^0-9]*\([0-9]*\).*'`
|
|
MYSID=`expr "\`grep "process session id =" $tf\`" : '[^0-9]*\([0-9]*\).*'`
|
|
#echo "PID=$MYPID, PPID=$MYPPID, PGID=$MYPGID, SID=$MYSID"
|
|
if [ "$MYPID" = "$MYPPID" -o "$MYPID" = "$MYPGID" -o "$MYPID" = "$MYSID" -o \
|
|
"$MYPPID" = "$MYPGID" -o "$MYPPID" = "$MYSID" -o "$MYPGID" = "$MYSID" ];
|
|
then
|
|
$PRINTF "$FAILED:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
numOK=$((numOK+1))
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=CHILDSETSID
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: child process with setsid"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
CMD="$SOCAT $opts -u exec:$PROCAN,setsid -"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD >$tf 2>$te
|
|
MYPID=`grep "process id =" $tf |(expr "\`cat\`" : '[^0-9]*\([0-9]*\).*')`
|
|
MYPPID=`grep "process parent id =" $tf |(expr "\`cat\`" : '[^0-9]*\([0-9]*\).*')`
|
|
MYPGID=`grep "process group id =" $tf |(expr "\`cat\`" : '[^0-9]*\([0-9]*\).*')`
|
|
MYSID=`grep "process session id =" $tf |(expr "\`cat\`" : '[^0-9]*\([0-9]*\).*')`
|
|
#$ECHO "\nPID=$MYPID, PPID=$MYPPID, PGID=$MYPGID, SID=$MYSID"
|
|
# PID, PGID, and SID must be the same
|
|
if [ "$MYPID" = "$MYPPID" -o \
|
|
"$MYPID" != "$MYPGID" -o "$MYPID" != "$MYSID" ];
|
|
then
|
|
$PRINTF "$FAILED\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
numOK=$((numOK+1))
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=MAINSETSID
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: main process with setsid"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
CMD="$SOCAT $opts -U -,setsid exec:$PROCAN"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD >$tf 2>$te
|
|
MYPID=`grep "process id =" $tf |(expr "\`cat\`" : '[^0-9]*\([0-9]*\).*')`
|
|
MYPPID=`grep "process parent id =" $tf |(expr "\`cat\`" : '[^0-9]*\([0-9]*\).*')`
|
|
MYPGID=`grep "process group id =" $tf |(expr "\`cat\`" : '[^0-9]*\([0-9]*\).*')`
|
|
MYSID=`grep "process session id =" $tf |(expr "\`cat\`" : '[^0-9]*\([0-9]*\).*')`
|
|
#$ECHO "\nPID=$MYPID, PPID=$MYPPID, PGID=$MYPGID, SID=$MYSID"
|
|
# PPID, PGID, and SID must be the same
|
|
if [ "$MYPID" = "$MYPPID" -o \
|
|
"$MYPPID" != "$MYPGID" -o "$MYPPID" != "$MYSID" ];
|
|
then
|
|
$PRINTF "$FAILED\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
numOK=$((numOK+1))
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=OPENSSL_TCP4
|
|
case "$TESTS" in
|
|
*%functions%*|*%openssl%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%$NAME%*)
|
|
TEST="$NAME: openssl connect"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! type openssl >/dev/null 2>&1; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}openssl executable not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP/IPv4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
CMD2="$SOCAT $opts exec:'openssl s_server -accept "$PORT" -quiet -cert testsrv.pem' pipe"
|
|
#! CMD="$SOCAT $opts - openssl:$LOCALHOST:$PORT"
|
|
CMD="$SOCAT $opts - openssl:$LOCALHOST:$PORT,pf=ip4,verify=0,$SOCAT_EGD"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>\"${te}1\" &"
|
|
pid=$! # background process id
|
|
waittcp4port $PORT
|
|
echo "$da" |$CMD >$tf 2>"${te}2"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=OPENSSLLISTEN_TCP4
|
|
case "$TESTS" in
|
|
*%functions%*|*%openssl%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%$NAME%*)
|
|
TEST="$NAME: openssl listen"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs listen tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP/IPv4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
CMD2="$SOCAT $opts OPENSSL-LISTEN:$PORT,pf=ip4,reuseaddr,$SOCAT_EGD,cert=testsrv.crt,key=testsrv.key,verify=0 pipe"
|
|
CMD="$SOCAT $opts - openssl:$LOCALHOST:$PORT,pf=ip4,verify=0,$SOCAT_EGD"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>\"${te}1\" &"
|
|
pid=$! # background process id
|
|
waittcp4port $PORT
|
|
echo "$da" |$CMD >$tf 2>"${te}2"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=OPENSSLLISTEN_TCP6
|
|
case "$TESTS" in
|
|
*%functions%*|*%openssl%*|*%tcp%*|*%tcp6%*|*%ip6%*|*%$NAME%*)
|
|
TEST="$NAME: openssl listen"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs listen tcp ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP/IPv6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
CMD2="$SOCAT $opts OPENSSL-LISTEN:$PORT,pf=ip6,reuseaddr,$SOCAT_EGD,cert=testsrv.crt,key=testsrv.key,verify=0 pipe"
|
|
CMD="$SOCAT $opts - openssl:$LOCALHOST6:$PORT,verify=0,$SOCAT_EGD"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>\"${te}1\" &"
|
|
pid=$! # background process id
|
|
waittcp6port $PORT
|
|
echo "$da" |$CMD >$tf 2>"${te}2"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=OPENSSL_SERVERAUTH
|
|
case "$TESTS" in
|
|
*%functions%*|*%openssl%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%$NAME%*)
|
|
TEST="$NAME: openssl server authentication"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs listen tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP/IPv4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
gentestcert testcli
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
CMD2="$SOCAT $opts OPENSSL-LISTEN:$PORT,reuseaddr,$SOCAT_EGD,cert=testsrv.crt,key=testsrv.key,verify=0 pipe"
|
|
CMD="$SOCAT $opts - openssl:$LOCALHOST:$PORT,verify=1,cafile=testsrv.crt,$SOCAT_EGD"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>\"${te}1\" &"
|
|
pid=$! # background process id
|
|
waittcp4port $PORT
|
|
echo "$da" |$CMD >$tf 2>"${te}2"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi # feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=OPENSSL_CLIENTAUTH
|
|
case "$TESTS" in
|
|
*%functions%*|*%openssl%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%$NAME%*)
|
|
TEST="$NAME: openssl client authentication"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs listen tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP/IPv4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
gentestcert testcli
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
CMD2="$SOCAT $opts OPENSSL-LISTEN:$PORT,reuseaddr,verify=1,cert=testsrv.crt,key=testsrv.key,cafile=testcli.crt,$SOCAT_EGD pipe"
|
|
CMD="$SOCAT $opts - openssl:$LOCALHOST:$PORT,verify=0,cert=testcli.crt,key=testcli.key,$SOCAT_EGD"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>\"${te}1\" &"
|
|
pid=$! # background process id
|
|
waittcp4port $PORT
|
|
echo "$da" |$CMD >$tf 2>"${te}2"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi # feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=OPENSSL_FIPS_BOTHAUTH
|
|
case "$TESTS" in
|
|
*%functions%*|*%openssl%*|*%fips%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%$NAME%*)
|
|
TEST="$NAME: OpenSSL+FIPS client and server authentication"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs listen tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP/IPv4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testoptions fips >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL/FIPS not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
OPENSSL_FIPS=1 gentestcert testsrvfips
|
|
OPENSSL_FIPS=1 gentestcert testclifips
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
CMD2="$SOCAT $opts OPENSSL-LISTEN:$PORT,reuseaddr,fips,$SOCAT_EGD,cert=testsrvfips.crt,key=testsrvfips.key,cafile=testclifips.crt pipe"
|
|
CMD="$SOCAT $opts - openssl:$LOCALHOST:$PORT,fips,verify=1,cert=testclifips.crt,key=testclifips.key,cafile=testsrvfips.crt,$SOCAT_EGD"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>\"${te}1\" &"
|
|
pid=$! # background process id
|
|
waittcp4port $PORT
|
|
echo "$da" |$CMD >$tf 2>"${te}2"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi # feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=SOCKS4CONNECT_TCP4
|
|
case "$TESTS" in
|
|
*%functions%*|*%socks%*|*%socks4%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%$NAME%*)
|
|
TEST="$NAME: socks4 connect over TCP/IPv4"
|
|
if ! testaddrs socks4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}SOCKS4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs listen tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP/IPv4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date)" da="$da$($ECHO '\r')"
|
|
# we have a normal tcp echo listening - so the socks header must appear in answer
|
|
CMD2="$SOCAT tcp4-l:$PORT,reuseaddr exec:\"./socks4echo.sh\""
|
|
CMD="$SOCAT $opts - socks4:$LOCALHOST:32.98.76.54:32109,pf=ip4,socksport=$PORT",socksuser="nobody"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>\"${te}1\" &"
|
|
pid=$! # background process id
|
|
waittcp4port $PORT 1
|
|
echo "$da" |$CMD >$tf 2>"${te}2"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi # feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=SOCKS4CONNECT_TCP6
|
|
case "$TESTS" in
|
|
*%functions%*|*%socks%*|*%socks4%*|*%tcp%*|*%tcp6%*|*%ip6%*|*%$NAME%*)
|
|
TEST="$NAME: socks4 connect over TCP/IPv6"
|
|
if ! testaddrs socks4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}SOCKS4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs listen tcp ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP/IPv6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date)" da="$da$($ECHO '\r')"
|
|
# we have a normal tcp echo listening - so the socks header must appear in answer
|
|
CMD2="$SOCAT tcp6-l:$PORT,reuseaddr exec:\"./socks4echo.sh\""
|
|
CMD="$SOCAT $opts - socks4:$LOCALHOST6:32.98.76.54:32109,socksport=$PORT",socksuser="nobody"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>\"${te}1\" &"
|
|
pid=$! # background process id
|
|
waittcp6port $PORT 1
|
|
echo "$da" |$CMD >$tf 2>"${te}2"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi # feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=SOCKS4ACONNECT_TCP4
|
|
case "$TESTS" in
|
|
*%functions%*|*%socks%*|*%socks4a%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%$NAME%*)
|
|
TEST="$NAME: socks4a connect over TCP/IPv4"
|
|
if ! testaddrs socks4a >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}SOCKS4A not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs listen tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP/IPv4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date)" da="$da$($ECHO '\r')"
|
|
# we have a normal tcp echo listening - so the socks header must appear in answer
|
|
CMD2="$SOCAT tcp4-l:$PORT,reuseaddr exec:\"./socks4a-echo.sh\""
|
|
CMD="$SOCAT $opts - socks4a:$LOCALHOST:localhost:32109,pf=ip4,socksport=$PORT",socksuser="nobody"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>\"${te}1\" &"
|
|
pid=$! # background process id
|
|
waittcp4port $PORT 1
|
|
echo "$da" |$CMD >$tf 2>"${te}2"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi # feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=SOCKS4ACONNECT_TCP6
|
|
case "$TESTS" in
|
|
*%functions%*|*%socks%*|*%socks4a%*|*%tcp%*|*%tcp6%*|*%ip6%*|*%$NAME%*)
|
|
TEST="$NAME: socks4a connect over TCP/IPv6"
|
|
if ! testaddrs socks4a >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}SOCKS4A not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs listen tcp ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP/IPv6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date)" da="$da$($ECHO '\r')"
|
|
# we have a normal tcp echo listening - so the socks header must appear in answer
|
|
CMD2="$SOCAT tcp6-l:$PORT,reuseaddr exec:\"./socks4a-echo.sh\""
|
|
CMD="$SOCAT $opts - socks4a:$LOCALHOST6:localhost:32109,socksport=$PORT",socksuser="nobody"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>\"${te}1\" &"
|
|
pid=$! # background process id
|
|
waittcp6port $PORT 1
|
|
echo "$da" |$CMD >$tf 2>"${te}2"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi # feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=PROXYCONNECT_TCP4
|
|
case "$TESTS" in
|
|
*%functions%*|*%proxyconnect%*|*%proxy%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%$NAME%*)
|
|
TEST="$NAME: proxy connect over TCP/IPv4"
|
|
if ! testaddrs proxy >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}PROXY not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs listen tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP/IPv4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ts="$td/test$N.sh"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date)" da="$da$($ECHO '\r')"
|
|
#CMD2="$SOCAT tcp4-l:$PORT,crlf system:\"read; read; $ECHO \\\"HTTP/1.0 200 OK\n\\\"; cat\""
|
|
CMD2="$SOCAT tcp4-l:$PORT,reuseaddr,crlf exec:\"/bin/bash proxyecho.sh\""
|
|
CMD="$SOCAT $opts - proxy:$LOCALHOST:127.0.0.1:1000,pf=ip4,proxyport=$PORT"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>\"${te}2\" &"
|
|
pid=$! # background process id
|
|
waittcp4port $PORT 1
|
|
echo "$da" |$CMD >"$tf" 2>"${te}1"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi # feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=PROXYCONNECT_TCP6
|
|
case "$TESTS" in
|
|
*%functions%*|*%proxyconnect%*|*%proxy%*|*%tcp%*|*%tcp6%*|*%ip6%*|*%$NAME%*)
|
|
TEST="$NAME: proxy connect over TCP/IPv6"
|
|
if ! testaddrs proxy >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}PROXY not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs listen tcp ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP/IPv6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ts="$td/test$N.sh"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date)" da="$da$($ECHO '\r')"
|
|
#CMD2="$SOCAT tcp6-l:$PORT,crlf system:\"read; read; $ECHO \\\"HTTP/1.0 200 OK\n\\\"; cat\""
|
|
CMD2="$SOCAT tcp6-l:$PORT,reuseaddr,crlf exec:\"/bin/bash proxyecho.sh\""
|
|
CMD="$SOCAT $opts - proxy:$LOCALHOST6:127.0.0.1:1000,proxyport=$PORT"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>\"${te}2\" &"
|
|
pid=$! # background process id
|
|
waittcp6port $PORT 1
|
|
echo "$da" |$CMD >"$tf" 2>"${te}1"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi # feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=TCP4NOFORK
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: echo via connection to TCP V4 socket with nofork'ed exec"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="127.0.0.1:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts TCP4-LISTEN:$tsl,reuseaddr exec:$CAT,nofork"
|
|
CMD2="$SOCAT $opts stdin!!stdout TCP4:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
#$CMD1 >"$tf" 2>"${te}1" &
|
|
$CMD1 >/dev/null 2>"${te}1" &
|
|
waittcp4port $tsl
|
|
#usleep $MICROS
|
|
echo "$da" |$CMD2 >"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=EXECCATNOFORK
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via exec of cat with nofork"
|
|
testecho "$N" "$TEST" "" "exec:$CAT,nofork" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=SYSTEMCATNOFORK
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via system() of cat with nofork"
|
|
testecho "$N" "$TEST" "" "system:$CAT,nofork" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=NOFORKSETSID
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via exec() of cat with nofork and setsid"
|
|
testecho "$N" "$TEST" "" "system:$CAT,nofork,setsid" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
#==============================================================================
|
|
#TEST="$NAME: echo via 'connection' to UDP V4 socket"
|
|
#tf="$td/file$N"
|
|
#tsl=65534
|
|
#ts="127.0.0.1:$tsl"
|
|
#da=$(date)
|
|
#$SOCAT UDP-listen:$tsl PIPE &
|
|
#sleep 2
|
|
#echo "$da" |$SOCAT stdin!!stdout UDP:$ts >"$tf"
|
|
#if [ $? -eq 0 ] && echo "$da" |diff "$tf" -; then
|
|
# $ECHO "... test $N succeeded"
|
|
# numOK=$((numOK+1))
|
|
#else
|
|
# $ECHO "*** test $N $FAILED"
|
|
# numFAIL=$((numFAIL+1))
|
|
#fi
|
|
#N=$((N+1))
|
|
#==============================================================================
|
|
# TEST 4 - simple echo via new file
|
|
#N=4
|
|
#tf="$td/file$N"
|
|
#tp="$td/pipe$N"
|
|
#da=$(date)
|
|
#rm -f "$tf.tmp"
|
|
#echo "$da" |$SOCAT - FILE:$tf.tmp,ignoreeof >"$tf"
|
|
#if [ $? -eq 0 ] && echo "$da" |diff "$tf" -; then
|
|
# $ECHO "... test $N succeeded"
|
|
# numOK=$((numOK+1))
|
|
#else
|
|
# $ECHO "*** test $N $FAILED"
|
|
# numFAIL=$((numFAIL+1))
|
|
#fi
|
|
|
|
#==============================================================================
|
|
|
|
NAME=TOTALTIMEOUT
|
|
case "$TESTS" in
|
|
*%functions%*|*%timeout%*|*%$NAME%*)
|
|
TEST="$NAME: socat inactivity timeout"
|
|
if ! true; then
|
|
:
|
|
else
|
|
#set -vx
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date)" da="$da$($ECHO '\r')"
|
|
CMD2="$SOCAT $opts -T 1 tcp4-listen:$PORT,reuseaddr pipe"
|
|
CMD="$SOCAT $opts - tcp4-connect:$LOCALHOST:$PORT"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>${te}1 &"
|
|
pid=$! # background process id
|
|
waittcp4port $PORT 1
|
|
(echo "$da"; sleep 2; echo X) |$CMD >"$tf" 2>"${te}2"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
#set +vx
|
|
fi # feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=IGNOREEOF+TOTALTIMEOUT
|
|
case "$TESTS" in
|
|
*%functions%*|*%timeout%*|*%ignoreeof%*|*%$NAME%*)
|
|
TEST="$NAME: ignoreeof and inactivity timeout"
|
|
if ! true; then
|
|
:
|
|
else
|
|
#set -vx
|
|
ti="$td/test$N.file"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date) $RANDOM"
|
|
CMD="$SOCAT $opts -T 2 -u file:\"$ti\",ignoreeof -"
|
|
printf "test $F_n $TEST... " $N
|
|
touch "$ti"
|
|
$CMD >"$tf" 2>"$te" &
|
|
bg=$! # background process id
|
|
sleep 1
|
|
echo "$da" >>"$ti"
|
|
sleep 4
|
|
echo X >>"$ti"
|
|
sleep 1
|
|
kill $bg 2>/dev/null
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD &"
|
|
cat "$te"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "$te"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
wait
|
|
fi # feats
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=PROXY2SPACES
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: proxy connect accepts status with multiple spaces"
|
|
if ! testaddrs proxy >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}PROXY not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ts="$td/test$N.sh"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date)" da="$da$($ECHO '\r')"
|
|
#CMD2="$SOCAT tcp-l:$PORT,crlf system:\"read; read; $ECHO \\\"HTTP/1.0 200 OK\n\\\"; cat\""
|
|
CMD2="$SOCAT tcp4-l:$PORT,reuseaddr,crlf exec:\"/bin/bash proxyecho.sh -w 2\""
|
|
CMD="$SOCAT $opts - proxy:$LOCALHOST:127.0.0.1:1000,pf=ip4,proxyport=$PORT"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>\"${te}1\" &"
|
|
pid=$! # background process id
|
|
waittcp4port $PORT 1
|
|
echo "$da" |$CMD >"$tf" 2>"${te}2"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi # feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=BUG-UNISTDIO
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: for bug with address options on both stdin/out in unidirectional mode"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
ff="$td/file$N"
|
|
printf "test $F_n $TEST... " $N
|
|
>"$ff"
|
|
#$SOCAT $opts -u /dev/null -,setlk <"$ff" 2>"$te"
|
|
CMD="$SOCAT $opts -u /dev/null -,setlk"
|
|
$CMD <"$ff" 2>"$te"
|
|
if [ "$?" -eq 0 ]; then
|
|
$PRINTF "$OK\n"
|
|
numOK=$((numOK+1))
|
|
else
|
|
if [ "$UNAME" = "Linux" ]; then
|
|
$PRINTF "$FAILED\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "${YELLOW}failed (don't care)${NORMAL}\n"
|
|
numCANT=$((numCANT+1))
|
|
fi
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=SINGLEEXECOUTSOCKETPAIR
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: inheritance of stdout to single exec with socketpair"
|
|
testecho "$N" "$TEST" "-!!exec:cat" "" "$opts" 1
|
|
esac
|
|
N=$((N+1))
|
|
|
|
NAME=SINGLEEXECOUTPIPE
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: inheritance of stdout to single exec with pipe"
|
|
testecho "$N" "$TEST" "-!!exec:cat,pipes" "" "$opts" 1
|
|
esac
|
|
N=$((N+1))
|
|
|
|
NAME=SINGLEEXECOUTPTY
|
|
case "$TESTS" in
|
|
*%functions%*|*%pty%*|*%$NAME%*)
|
|
TEST="$NAME: inheritance of stdout to single exec with pty"
|
|
if ! testaddrs pty >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}PTY not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testecho "$N" "$TEST" "-!!exec:cat,pty,raw" "" "$opts" 1
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
NAME=SINGLEEXECINSOCKETPAIR
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: inheritance of stdin to single exec with socketpair"
|
|
testecho "$N" "$TEST" "exec:cat!!-" "" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
NAME=SINGLEEXECINPIPE
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: inheritance of stdin to single exec with pipe"
|
|
testecho "$N" "$TEST" "exec:cat,pipes!!-" "" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
NAME=SINGLEEXECINPTYDELAY
|
|
case "$TESTS" in
|
|
*%functions%*|*%pty%*|*%$NAME%*)
|
|
TEST="$NAME: inheritance of stdin to single exec with pty, with delay"
|
|
if ! testaddrs pty >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}PTY not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testecho "$N" "$TEST" "exec:cat,pty,raw!!-" "" "$opts" $MISCDELAY
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
NAME=SINGLEEXECINPTY
|
|
case "$TESTS" in
|
|
*%functions%*|*%pty%*|*%$NAME%*)
|
|
TEST="$NAME: inheritance of stdin to single exec with pty"
|
|
if ! testaddrs pty >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}PTY not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testecho "$N" "$TEST" "exec:cat,pty,raw!!-" "" "$opts"
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=READLINE
|
|
#set -vx
|
|
case "$TESTS" in
|
|
*%functions%*|*%pty%*|*%$NAME%*)
|
|
TEST="$NAME: readline with password and sigint"
|
|
if ! feat=$(testaddrs readline pty); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$(echo $feat| tr 'a-z' 'A-Z') not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
SAVEMICS=$MICROS
|
|
#MICROS=2000000
|
|
ts="$td/test$N.sh"
|
|
to="$td/test$N.stdout"
|
|
tpi="$td/test$N.inpipe"
|
|
tpo="$td/test$N.outpipe"
|
|
te="$td/test$N.stderr"
|
|
tr="$td/test$N.ref"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date)" da="$da$($ECHO '\r')"
|
|
# the feature that we really want to test is in the readline.sh script:
|
|
CMD="$SOCAT $opts open:$tpi,nonblock!!open:$tpo exec:\"./readline.sh -nh ./readline-test.sh\",pty,ctty,setsid,raw,echo=0,isig"
|
|
#echo "$CMD" >"$ts"
|
|
#chmod a+x "$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
rm -f "$tpi" "$tpo"
|
|
mkfifo "$tpi"
|
|
touch "$tpo"
|
|
#
|
|
# during development of this test, the following command line succeeded:
|
|
# (sleep 1; $ECHO "user\n\c"; sleep 1; $ECHO "password\c"; sleep 1; $ECHO "\n\c"; sleep 1; $ECHO "test 1\n\c"; sleep 1; $ECHO "\003\c"; sleep 1; $ECHO "test 2\n\c"; sleep 1; $ECHO "exit\n\c"; sleep 1) |$SOCAT -d -d -d -d -lf/tmp/gerhard/debug1 -v -x - exec:'./readline.sh ./readline-test.sh',pty,ctty,setsid,raw,echo=0,isig
|
|
#
|
|
PATH=${SOCAT%socat}:$PATH eval "$CMD 2>$te &"
|
|
pid=$! # background process id
|
|
usleep $MICROS
|
|
|
|
(
|
|
usleep $((3*MICROS))
|
|
$ECHO "user\n\c"
|
|
usleep $MICROS
|
|
$ECHO "password\c"
|
|
usleep $MICROS
|
|
$ECHO "\n\c"
|
|
usleep $MICROS
|
|
$ECHO "test 1\n\c"
|
|
usleep $MICROS
|
|
$ECHO "\003\c"
|
|
usleep $MICROS
|
|
$ECHO "test 2\n\c"
|
|
usleep $MICROS
|
|
$ECHO "exit\n\c"
|
|
usleep $MICROS
|
|
) >"$tpi"
|
|
|
|
#cat >$tr <<EOF
|
|
#readline feature test program
|
|
#Authentication required
|
|
#Username:
|
|
Username: user
|
|
#Password:
|
|
#prog>
|
|
prog> test 1
|
|
#executing test 1
|
|
#prog> ./readline-test.sh got SIGINT
|
|
#
|
|
test 2
|
|
#executing test 2
|
|
#prog>
|
|
prog> exit
|
|
#EOF
|
|
cat >$tr <<EOF
|
|
readline feature test program
|
|
Authentication required
|
|
Username: user
|
|
Password:
|
|
prog> test 1
|
|
executing test 1
|
|
prog> ./readline-test.sh got SIGINT
|
|
test 2
|
|
executing test 2
|
|
prog> exit
|
|
EOF
|
|
|
|
#0 if ! sed 's/.*\r//g' "$tpo" |diff -q "$tr" - >/dev/null 2>&1; then
|
|
#0 if ! sed 's/.*'"$($ECHO '\r\c')"'/</g' "$tpo" |diff -q "$tr" - >/dev/null 2>&1; then
|
|
if ! tr "$($ECHO '\r \c')" "% " <$tpo |sed 's/%$//g' |sed 's/.*%//g' |diff "$tr" - >"$tdiff" 2>&1; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
#kill $pid 2>/dev/null
|
|
MICROS=$SAVEMICS
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=GENDERCHANGER
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: TCP4 \"gender changer\""
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
# this is the server in the protected network that we want to reach
|
|
CMD1="$SOCAT -lpserver $opts tcp4-l:$PORT,reuseaddr,bind=$LOCALHOST echo"
|
|
# this is the double client in the protected network
|
|
CMD2="$SOCAT -lp2client $opts tcp4:$LOCALHOST:$((PORT+1)),retry=10,intervall=1 tcp4:$LOCALHOST:$PORT"
|
|
# this is the double server in the outside network
|
|
CMD3="$SOCAT -lp2server $opts tcp4-l:$((PORT+2)),reuseaddr,bind=$LOCALHOST tcp4-l:$((PORT+1)),reuseaddr,bind=$LOCALHOST"
|
|
# this is the outside client that wants to use the protected server
|
|
CMD4="$SOCAT -lpclient $opts -t1 - tcp4:$LOCALHOST:$((PORT+2))"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD1 2>${te}1 &"
|
|
pid1=$!
|
|
eval "$CMD2 2>${te}2 &"
|
|
pid2=$!
|
|
eval "$CMD3 2>${te}3 &"
|
|
pid3=$!
|
|
waittcp4port $PORT 1 &&
|
|
waittcp4port $((PORT+2)) 1
|
|
sleep 1
|
|
echo "$da" |$CMD4 >$tf 2>"${te}4"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2 &"
|
|
echo "$CMD3 &"
|
|
echo "$CMD4"
|
|
cat "${te}1" "${te}2" "${te}3" "${te}4"
|
|
echo "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2" "${te}3" "${te}4"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid1 $pid2 $pid3 $pid4 2>/dev/null
|
|
wait
|
|
esac
|
|
PORT=$((PORT+3))
|
|
N=$((N+1))
|
|
|
|
|
|
#!
|
|
#PORT=10000
|
|
#!
|
|
NAME=OUTBOUNDIN
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: gender changer via SSL through HTTP proxy, oneshot"
|
|
if ! feat=$(testaddrs openssl proxy); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$(echo $feat |tr 'a-z' 'A-Z') not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
gentestcert testcli
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
# this is the server in the protected network that we want to reach
|
|
CMD1="$SOCAT $opts -lpserver tcp4-l:$PORT,reuseaddr,bind=$LOCALHOST echo"
|
|
# this is the proxy in the protected network that provides a way out
|
|
CMD2="$SOCAT $opts -lpproxy tcp4-l:$((PORT+1)),reuseaddr,bind=$LOCALHOST,fork exec:./proxy.sh"
|
|
# this is our proxy connect wrapper in the protected network
|
|
CMD3="$SOCAT $opts -lpwrapper tcp4-l:$((PORT+2)),reuseaddr,bind=$LOCALHOST,fork proxy:$LOCALHOST:$LOCALHOST:$((PORT+3)),pf=ip4,proxyport=$((PORT+1)),resolve"
|
|
# this is our double client in the protected network using SSL
|
|
#CMD4="$SOCAT $opts -lp2client ssl:$LOCALHOST:$((PORT+2)),pf=ip4,retry=10,intervall=1,cert=testcli.pem,cafile=testsrv.crt,$SOCAT_EGD tcp4:$LOCALHOST:$PORT"
|
|
CMD4="$SOCAT $opts -lp2client ssl:$LOCALHOST:$((PORT+2)),pf=ip4,cert=testcli.pem,cafile=testsrv.crt,$SOCAT_EGD tcp4:$LOCALHOST:$PORT"
|
|
# this is the double server in the outside network
|
|
CMD5="$SOCAT $opts -lp2server -t1 tcp4-l:$((PORT+4)),reuseaddr,bind=$LOCALHOST ssl-l:$((PORT+3)),pf=ip4,reuseaddr,bind=$LOCALHOST,$SOCAT_EGD,cert=testsrv.pem,cafile=testcli.crt"
|
|
# this is the outside client that wants to use the protected server
|
|
CMD6="$SOCAT $opts -lpclient -t5 - tcp4:$LOCALHOST:$((PORT+4))"
|
|
printf "test $F_n $TEST... " $N
|
|
eval "$CMD1 2>${te}1 &"
|
|
pid1=$!
|
|
eval "$CMD2 2>${te}2 &"
|
|
pid2=$!
|
|
eval "$CMD3 2>${te}3 &"
|
|
pid3=$!
|
|
waittcp4port $PORT 1 || $PRINTF "$FAILED: port $PORT\n" >&2 </dev/null
|
|
waittcp4port $((PORT+1)) 1 || $PRINTF "$FAILED: port $((PORT+1))\n" >&2 </dev/null
|
|
waittcp4port $((PORT+2)) 1 || $PRINTF "$FAILED: port $((PORT+2))\n" >&2 </dev/null
|
|
eval "$CMD5 2>${te}5 &"
|
|
pid5=$!
|
|
waittcp4port $((PORT+4)) 1 || $PRINTF "$FAILED: port $((PORT+4))\n" >&2 </dev/null
|
|
echo "$da" |$CMD6 >$tf 2>"${te}6" &
|
|
pid6=$!
|
|
waittcp4port $((PORT+3)) 1 || $PRINTF "$FAILED: port $((PORT+3))\n" >&2 </dev/null
|
|
eval "$CMD4 2>${te}4 &"
|
|
pid4=$!
|
|
wait $pid6
|
|
if ! (echo "$da"; sleep 2) |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
cat "${te}1"
|
|
echo "$CMD2 &"
|
|
cat "${te}2"
|
|
echo "$CMD3 &"
|
|
cat "${te}3"
|
|
echo "$CMD5 &"
|
|
cat "${te}5"
|
|
echo "$CMD6"
|
|
cat "${te}6"
|
|
echo "$CMD4 &"
|
|
cat "${te}4"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2" "${te}3" "${te}4" "${te}5" "${te}6"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid1 $pid2 $pid3 $pid4 $pid5 2>/dev/null
|
|
wait
|
|
fi # feats
|
|
esac
|
|
PORT=$((PORT+5))
|
|
N=$((N+1))
|
|
|
|
|
|
#!
|
|
PORT=$((RANDOM+16184))
|
|
#!
|
|
NAME=INTRANETRIPPER
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: gender changer via SSL through HTTP proxy, daemons"
|
|
if ! feat=$(testaddrs openssl proxy); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$(echo $feat| tr 'a-z' 'A-Z') not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
gentestcert testcli
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da1="test$N.1 $(date) $RANDOM"
|
|
da2="test$N.2 $(date) $RANDOM"
|
|
da3="test$N.3 $(date) $RANDOM"
|
|
# this is the server in the protected network that we want to reach
|
|
CMD1="$SOCAT $opts -lpserver -t1 tcp4-l:$PORT,reuseaddr,bind=$LOCALHOST,fork echo"
|
|
# this is the proxy in the protected network that provides a way out
|
|
CMD2="$SOCAT $opts -lpproxy -t1 tcp4-l:$((PORT+1)),reuseaddr,bind=$LOCALHOST,fork exec:./proxy.sh"
|
|
# this is our proxy connect wrapper in the protected network
|
|
CMD3="$SOCAT $opts -lpwrapper -t3 tcp4-l:$((PORT+2)),reuseaddr,bind=$LOCALHOST,fork proxy:$LOCALHOST:$LOCALHOST:$((PORT+3)),pf=ip4,proxyport=$((PORT+1)),resolve"
|
|
# this is our double client in the protected network using SSL
|
|
CMD4="$SOCAT $opts -lp2client -t3 ssl:$LOCALHOST:$((PORT+2)),retry=10,intervall=1,cert=testcli.pem,cafile=testsrv.crt,verify,fork,$SOCAT_EGD tcp4:$LOCALHOST:$PORT"
|
|
# this is the double server in the outside network
|
|
CMD5="$SOCAT $opts -lp2server -t4 tcp4-l:$((PORT+4)),reuseaddr,bind=$LOCALHOST,fork ssl-l:$((PORT+3)),pf=ip4,reuseaddr,bind=$LOCALHOST,$SOCAT_EGD,cert=testsrv.pem,cafile=testcli.crt,retry=10"
|
|
# this is the outside client that wants to use the protected server
|
|
CMD6="$SOCAT $opts -lpclient -t5 - tcp4:$LOCALHOST:$((PORT+4)),retry=3"
|
|
printf "test $F_n $TEST... " $N
|
|
# start the intranet infrastructure
|
|
eval "$CMD1 2>\"${te}1\" &"
|
|
pid1=$!
|
|
eval "$CMD2 2>\"${te}2\" &"
|
|
pid2=$!
|
|
waittcp4port $PORT 1 || $PRINTF "$FAILED: port $PORT\n" >&2 </dev/null
|
|
waittcp4port $((PORT+1)) 1 || $PRINTF "$FAILED: port $((PORT+1))\n" >&2 </dev/null
|
|
# initiate our internal measures
|
|
eval "$CMD3 2>\"${te}3\" &"
|
|
pid3=$!
|
|
eval "$CMD4 2>\"${te}4\" &"
|
|
pid4=$!
|
|
waittcp4port $((PORT+2)) 1 || $PRINTF "$FAILED: port $((PORT+2))\n" >&2 </dev/null
|
|
# now we start the external daemon
|
|
eval "$CMD5 2>\"${te}5\" &"
|
|
pid5=$!
|
|
waittcp4port $((PORT+4)) 1 || $PRINTF "$FAILED: port $((PORT+4))\n" >&2 </dev/null
|
|
# and this is the outside client:
|
|
echo "$da1" |$CMD6 >${tf}_1 2>"${te}6_1" &
|
|
pid6_1=$!
|
|
echo "$da2" |$CMD6 >${tf}_2 2>"${te}6_2" &
|
|
pid6_2=$!
|
|
echo "$da3" |$CMD6 >${tf}_3 2>"${te}6_3" &
|
|
pid6_3=$!
|
|
wait $pid6_1 $pid6_2 $pid6_3
|
|
#
|
|
(echo "$da1"; sleep 2) |diff - "${tf}_1" >"${tdiff}1"
|
|
(echo "$da2"; sleep 2) |diff - "${tf}_2" >"${tdiff}2"
|
|
(echo "$da3"; sleep 2) |diff - "${tf}_3" >"${tdiff}3"
|
|
if test -s "${tdiff}1" -o -s "${tdiff}2" -o -s "${tdiff}3"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
cat "${te}1"
|
|
echo "$CMD2 &"
|
|
cat "${te}2"
|
|
echo "$CMD3 &"
|
|
cat "${te}3"
|
|
echo "$CMD4 &"
|
|
cat "${te}4"
|
|
echo "$CMD5 &"
|
|
cat "${te}5"
|
|
echo "$CMD6 &"
|
|
cat "${te}6_1"
|
|
cat "${tdiff}1"
|
|
echo "$CMD6 &"
|
|
cat "${te}6_2"
|
|
cat "${tdiff}2"
|
|
echo "$CMD6 &"
|
|
cat "${te}6_3"
|
|
cat "${tdiff}3"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2" "${te}3" "${te}4" "${te}5" ${te}6*; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid1 $pid2 $pid3 $pid4 $pid5 2>/dev/null
|
|
wait
|
|
fi
|
|
esac
|
|
PORT=$((PORT+5))
|
|
N=$((N+1))
|
|
|
|
|
|
# let us test the security features with -s, retry, and fork
|
|
# method: first test without security feature if it works
|
|
# then try with security feature, must fail
|
|
|
|
# test the security features of a server address
|
|
testserversec () {
|
|
local num="$1"
|
|
local title="$2"
|
|
local opts="$3"
|
|
local arg1="$4" # the server address
|
|
local secopt0="$5" # option without security for server, mostly empty
|
|
local secopt1="$6" # the security option for server, to be tested
|
|
local arg2="$7" # the client address
|
|
local ipvers="$8" # IP version, for check of listen port
|
|
local proto="$9" # protocol, for check of listen port
|
|
local port="${10}" # start client when this port is listening
|
|
local expect="${11}" # expected behaviour of client: 0..empty output; -1..error
|
|
local T="${12}"; [ -z "$T" ] && T=0
|
|
local tf="$td/test$N.stdout"
|
|
local te="$td/test$N.stderr"
|
|
local tdiff1="$td/test$N.diff1"
|
|
local tdiff2="$td/test$N.diff2"
|
|
local da="$(date)"
|
|
local stat result
|
|
|
|
$PRINTF "test $F_n %s... " $num "$title"
|
|
#set -vx
|
|
# first: without security
|
|
# start server
|
|
$SOCAT $opts "$arg1,$secopt0" echo 2>"${te}1" &
|
|
spid=$!
|
|
if [ "$port" ] && ! wait${proto}${ipvers}port $port 1; then
|
|
kill $spid 2>/dev/null
|
|
$PRINTF "$NO_RESULT (ph.1 server not working):\n"
|
|
echo "$SOCAT $opts \"$arg1,$secopt0\" echo &"
|
|
cat "${te}1"
|
|
numCANT=$((numCANT+1))
|
|
wait; return
|
|
fi
|
|
# now use client
|
|
(echo "$da"; sleep $T) |$SOCAT $opts - "$arg2" >"$tf" 2>"${te}2"
|
|
stat="$?"
|
|
kill $spid 2>/dev/null
|
|
#killall $SOCAT 2>/dev/null
|
|
if [ "$stat" != 0 ]; then
|
|
$PRINTF "$NO_RESULT (ph.1 function fails): $SOCAT:\n"
|
|
echo "$SOCAT $opts \"$arg1,$secopt0\" echo &"
|
|
cat "${te}1"
|
|
echo "$SOCAT $opts - \"$arg2\""
|
|
cat "${te}2"
|
|
numCANT=$((numCANT+1))
|
|
wait; return
|
|
elif echo "$da" |diff - "$tf" >"$tdiff1" 2>&1; then
|
|
: # function without security is ok, go on
|
|
else
|
|
$PRINTF "$NO_RESULT (ph.1 function fails): diff:\n"
|
|
echo "$SOCAT $opts $arg1,$secopt0 echo &"
|
|
cat "${te}1"
|
|
echo "$SOCAT $opts - $arg2"
|
|
cat "${te}2"
|
|
cat "$tdiff1"
|
|
numCANT=$((numCANT+1))
|
|
wait; return
|
|
fi
|
|
|
|
# then: with security
|
|
if [ "$port" ] && ! wait${proto}${ipvers}port $port 0; then
|
|
$PRINTF "$NO_RESULT (ph.1 port remains in use)\n"
|
|
numCANT=$((numCANT+1))
|
|
wait; return
|
|
fi
|
|
wait
|
|
|
|
#set -vx
|
|
# assemble address w/ security option; on dual, take read part:
|
|
case "$arg1" in
|
|
*!!*) arg="${arg1%!!*},$secopt1!!${arg1#*!!}" ;;
|
|
*) arg="$arg1,$secopt1" ;;
|
|
esac
|
|
# start server
|
|
CMD3="$SOCAT $opts $arg echo"
|
|
$CMD3 2>"${te}3" &
|
|
spid=$!
|
|
if [ "$port" ] && ! wait${proto}${ipvers}port $port 1; then
|
|
kill $spid 2>/dev/null
|
|
$PRINTF "$NO_RESULT (ph.2 server not working)\n"
|
|
wait
|
|
echo "$CMD3"
|
|
cat "${te}3"
|
|
numCANT=$((numCANT+1))
|
|
return
|
|
fi
|
|
# now use client
|
|
(echo "$da"; sleep $T) |$SOCAT $opts - "$arg2" >"$tf" 2>"${te}4"
|
|
stat=$?
|
|
kill $spid 2>/dev/null
|
|
#set +vx
|
|
#killall $SOCAT 2>/dev/null
|
|
if [ "$stat" != 0 ]; then
|
|
result=-1; # socat had error
|
|
elif [ ! -s "$tf" ]; then
|
|
result=0; # empty output
|
|
elif echo "$da" |diff - "$tf" >"$tdiff2" 2>&1; then
|
|
result=1; # output is copy of input
|
|
else
|
|
result=2; # output differs from input
|
|
fi
|
|
if [ X$result != X$expect ]; then
|
|
case X$result in
|
|
X-1) $PRINTF "$NO_RESULT (ph.2 client error): $SOCAT:\n"
|
|
echo "$SOCAT $opts $arg echo"
|
|
cat "${te}3"
|
|
echo "$SOCAT $opts - $arg2"
|
|
cat "${te}4"
|
|
numCANT=$((numCANT+1)) ;;
|
|
X0) $PRINTF "$NO_RESULT (ph.2 diff failed): diff:\n"
|
|
echo "$SOCAT $opts $arg echo"
|
|
cat "${te}3"
|
|
echo "$SOCAT $opts - $arg2"
|
|
cat "${te}4"
|
|
cat "$tdiff2"
|
|
numCANT=$((numCANT+1)) ;;
|
|
X1) $PRINTF "$FAILED: SECURITY BROKEN\n"
|
|
echo "$SOCAT $opts $arg echo"
|
|
cat "${te}3"
|
|
echo "$SOCAT $opts - $arg2"
|
|
cat "${te}4"
|
|
cat "$tdiff2"
|
|
numFAIL=$((numFAIL+1)) ;;
|
|
X2) $PRINTF "$FAILED: diff:\n"
|
|
echo "$SOCAT $opts $arg echo"
|
|
cat "${te}3"
|
|
echo "$SOCAT $opts - $arg2"
|
|
cat "${te}4"
|
|
cat "$tdiff2"
|
|
numFAIL=$((numFAIL+1)) ;;
|
|
esac
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
wait
|
|
#set +vx
|
|
}
|
|
|
|
|
|
NAME=TCP4RANGEBITS
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%range%*|*%$NAME%*)
|
|
TEST="$NAME: security of TCP4-L with RANGE option"
|
|
testserversec "$N" "$TEST" "$opts -s" "tcp4-l:$PORT,reuseaddr,fork,retry=1" "" "range=$SECONDADDR/32" "tcp4:127.0.0.1:$PORT" 4 tcp $PORT 0
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=TCP4RANGEMASK
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%range%*|*%$NAME%*)
|
|
TEST="$NAME: security of TCP4-L with RANGE option"
|
|
if [ "$UNAME" != Linux ]; then
|
|
# we need access to more loopback addresses
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}only on Linux${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testserversec "$N" "$TEST" "$opts -s" "tcp4-l:$PORT,reuseaddr,fork,retry=1" "" "range=127.0.0.0:255.255.0.0" "tcp4:127.1.0.0:$PORT" 4 tcp $PORT 0
|
|
fi ;; # Linux
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=TCP4SOURCEPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%sourceport%*|*%$NAME%*)
|
|
TEST="$NAME: security of TCP4-L with SOURCEPORT option"
|
|
testserversec "$N" "$TEST" "$opts -s" "tcp4-l:$PORT,reuseaddr,fork,retry=1" "" "sp=$PORT" "tcp4:127.0.0.1:$PORT" 4 tcp $PORT 0
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=TCP4LOWPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%lowport%*|*%$NAME%*)
|
|
TEST="$NAME: security of TCP4-L with LOWPORT option"
|
|
testserversec "$N" "$TEST" "$opts -s" "tcp4-l:$PORT,reuseaddr,fork,retry=1" "" "lowport" "tcp4:127.0.0.1:$PORT" 4 tcp $PORT 0
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=TCP4WRAPPERS_ADDR
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%tcpwrap%*|*%$NAME%*)
|
|
TEST="$NAME: security of TCP4-L with TCPWRAP option"
|
|
if ! feat=$(testaddrs tcp ip4 libwrap) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: $SECONDADDR" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
testserversec "$N" "$TEST" "$opts -s" "tcp4-l:$PORT,reuseaddr,fork,retry=1" "" "hosts-allow=$ha,hosts-deny=$hd" "tcp4:127.0.0.1:$PORT" 4 tcp $PORT 0
|
|
fi ;; # feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=TCP4WRAPPERS_NAME
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%tcpwrap%*|*%$NAME%*)
|
|
TEST="$NAME: security of TCP4-L with TCPWRAP option"
|
|
if ! feat=$(testaddrs tcp ip4 libwrap) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: $LOCALHOST" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
testserversec "$N" "$TEST" "$opts -s" "tcp4-l:$PORT,reuseaddr,fork,retry=1" "" "hosts-allow=$ha,hosts-deny=$hd" "tcp4:$SECONDADDR:$PORT" 4 tcp $PORT 0
|
|
fi ;; # feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=TCP6RANGE
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp6%*|*%ip6%*|*%range%*|*%$NAME%*)
|
|
TEST="$NAME: security of TCP6-L with RANGE option"
|
|
if ! feat=$(testaddrs tcp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testserversec "$N" "$TEST" "$opts -s" "tcp6-l:$PORT,reuseaddr,fork,retry=1" "" "range=[::2/128]" "tcp6:[::1]:$PORT" 6 tcp $PORT 0
|
|
fi # feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=TCP6SOURCEPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp6%*|*%ip6%*|*%sourceport%*|*%$NAME%*)
|
|
TEST="$NAME: security of TCP6-L with SOURCEPORT option"
|
|
if ! feat=$(testaddrs tcp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testserversec "$N" "$TEST" "$opts -s" "tcp6-l:$PORT,reuseaddr,fork,retry=1" "" "sp=$PORT" "tcp6:[::1]:$PORT" 6 tcp $PORT 0
|
|
fi # ! feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=TCP6LOWPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp6%*|*%ip6%*|*%lowport%*|*%$NAME%*)
|
|
TEST="$NAME: security of TCP6-L with LOWPORT option"
|
|
if ! feat=$(testaddrs tcp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testserversec "$N" "$TEST" "$opts -s" "tcp6-l:$PORT,reuseaddr,fork,retry=1" "" "lowport" "tcp6:[::1]:$PORT" 6 tcp $PORT 0
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=TCP6TCPWRAP
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp6%*|*%ip6%*|*%tcpwrap%*|*%$NAME%*)
|
|
TEST="$NAME: security of TCP6-L with TCPWRAP option"
|
|
if ! feat=$(testaddrs tcp ip6 libwrap) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: [::2]" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
testserversec "$N" "$TEST" "$opts -s" "tcp6-l:$PORT,reuseaddr,fork,retry=1" "" "hosts-allow=$ha,hosts-deny=$hd" "tcp6:[::1]:$PORT" 6 tcp $PORT 0
|
|
fi # ! feat
|
|
;;
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP4RANGE
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp4%*|*%ip4%*|*%range%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP4-L with RANGE option"
|
|
#testserversec "$N" "$TEST" "$opts -s" "udp4-l:$PORT,reuseaddr,fork" "" "range=$SECONDADDR/32" "udp4:127.0.0.1:$PORT" 4 udp $PORT 0
|
|
testserversec "$N" "$TEST" "$opts -s" "udp4-l:$PORT,reuseaddr" "" "range=$SECONDADDR/32" "udp4:127.0.0.1:$PORT" 4 udp $PORT 0
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP4SOURCEPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp4%*|*%ip4%*|*%sourceport%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP4-L with SOURCEPORT option"
|
|
testserversec "$N" "$TEST" "$opts -s" "udp4-l:$PORT,reuseaddr" "" "sp=$PORT" "udp4:127.0.0.1:$PORT" 4 udp $PORT 0
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP4LOWPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp4%*|*%ip4%*|*%lowport%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP4-L with LOWPORT option"
|
|
testserversec "$N" "$TEST" "$opts -s" "udp4-l:$PORT,reuseaddr" "" "lowport" "udp4:127.0.0.1:$PORT" 4 udp $PORT 0
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP4TCPWRAP
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp4%*|*%ip4%*|*%tcpwrap%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP4-L with TCPWRAP option"
|
|
if ! feat=$(testaddrs udp ip4 libwrap) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: $SECONDADDR" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
testserversec "$N" "$TEST" "$opts -s" "udp4-l:$PORT,reuseaddr,retry=1" "" "tcpwrap-etc=$td" "udp4:127.0.0.1:$PORT" 4 udp $PORT 0
|
|
fi ;; # feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP6RANGE
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp6%*|*%ip6%*|*%range%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP6-L with RANGE option"
|
|
if ! feat=$(testaddrs tcp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
#testserversec "$N" "$TEST" "$opts -s" "udp6-l:$PORT,reuseaddr,fork" "" "range=[::2/128]" "udp6:[::1]:$PORT" 6 udp $PORT 0
|
|
testserversec "$N" "$TEST" "$opts -s" "udp6-l:$PORT,reuseaddr" "" "range=[::2/128]" "udp6:[::1]:$PORT" 6 udp $PORT 0
|
|
fi # ! feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP6SOURCEPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp6%*|*%ip6%*|*%sourceport%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP6-L with SOURCEPORT option"
|
|
if ! feat=$(testaddrs udp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testserversec "$N" "$TEST" "$opts -s" "udp6-l:$PORT,reuseaddr" "" "sp=$PORT" "udp6:[::1]:$PORT" 6 udp $PORT 0
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP6LOWPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp6%*|*%ip6%*|*%lowport%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP6-L with LOWPORT option"
|
|
if ! feat=$(testaddrs udp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testserversec "$N" "$TEST" "$opts -s" "udp6-l:$PORT,reuseaddr" "" "lowport" "udp6:[::1]:$PORT" 6 udp $PORT 0
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP6TCPWRAP
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp6%*|*%ip6%*|*%tcpwrap%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP6-L with TCPWRAP option"
|
|
if ! feat=$(testaddrs tcp ip6 libwrap) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: [::2]" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
testserversec "$N" "$TEST" "$opts -s" "udp6-l:$PORT,reuseaddr" "" "lowport" "udp6:[::1]:$PORT" 6 udp $PORT 0
|
|
fi ;; # feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=OPENSSLTCP4_RANGE
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%openssl%*|*%range%*|*%$NAME%*)
|
|
TEST="$NAME: security of SSL-L over TCP/IPv4 with RANGE option"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
testserversec "$N" "$TEST" "$opts -s" "ssl-l:$PORT,pf=ip4,reuseaddr,fork,retry=1,$SOCAT_EGD,verify=0,cert=testsrv.crt,key=testsrv.key" "" "range=$SECONDADDR/32" "ssl:127.0.0.1:$PORT,cafile=testsrv.crt,$SOCAT_EGD" 4 tcp $PORT -1
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=OPENSSLTCP4_SOURCEPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%openssl%*|*%sourceport%*|*%$NAME%*)
|
|
TEST="$NAME: security of SSL-L with SOURCEPORT option"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
testserversec "$N" "$TEST" "$opts -s" "ssl-l:$PORT,pf=ip4,reuseaddr,fork,retry=1,$SOCAT_EGD,verify=0,cert=testsrv.crt,key=testsrv.key" "" "sp=$PORT" "ssl:127.0.0.1:$PORT,cafile=testsrv.crt,$SOCAT_EGD" 4 tcp $PORT -1
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=OPENSSLTCP4_LOWPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%openssl%*|*%lowport%*|*%$NAME%*)
|
|
TEST="$NAME: security of SSL-L with LOWPORT option"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
testserversec "$N" "$TEST" "$opts -s" "ssl-l:$PORT,pf=ip4,reuseaddr,fork,retry=1,$SOCAT_EGD,verify=0,cert=testsrv.crt,key=testsrv.key" "" "lowport" "ssl:127.0.0.1:$PORT,cafile=testsrv.crt,$SOCAT_EGD" 4 tcp $PORT -1
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=OPENSSLTCP4_TCPWRAP
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%openssl%*|*%tcpwrap%*|*%$NAME%*)
|
|
TEST="$NAME: security of SSL-L with TCPWRAP option"
|
|
if ! feat=$(testaddrs ip4 tcp libwrap openssl); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: $SECONDADDR" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
testserversec "$N" "$TEST" "$opts -s" "ssl-l:$PORT,pf=ip4,reuseaddr,fork,retry=1,$SOCAT_EGD,verify=0,cert=testsrv.crt,key=testsrv.key" "" "tcpwrap-etc=$td" "ssl:127.0.0.1:$PORT,cafile=testsrv.crt,$SOCAT_EGD" 4 tcp $PORT -1
|
|
fi ;; # feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=OPENSSLCERTSERVER
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%openssl%*|*%$NAME%*)
|
|
TEST="$NAME: security of SSL-L with client certificate"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
gentestcert testcli
|
|
testserversec "$N" "$TEST" "$opts -s" "ssl-l:$PORT,pf=ip4,reuseaddr,fork,retry=1,$SOCAT_EGD,verify,cert=testsrv.crt,key=testsrv.key" "cafile=testcli.crt" "cafile=testsrv.crt" "ssl:127.0.0.1:$PORT,cafile=testsrv.crt,cert=testcli.pem,$SOCAT_EGD" 4 tcp $PORT -1
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=OPENSSLCERTCLIENT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%openssl%*|*%$NAME%*)
|
|
TEST="$NAME: security of SSL with server certificate"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
gentestcert testcli
|
|
testserversec "$N" "$TEST" "$opts -s -lu -d" "ssl:$LOCALHOST:$PORT,pf=ip4,fork,retry=2,verify,cert=testcli.pem,$SOCAT_EGD" "cafile=testsrv.crt" "cafile=testcli.crt" "ssl-l:$PORT,pf=ip4,reuseaddr,$SOCAT_EGD,cafile=testcli.crt,cert=testsrv.crt,key=testsrv.key" 4 tcp "" -1
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=OPENSSLTCP6_RANGE
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp6%*|*%ip6%*|*%openssl%*|*%range%*|*%$NAME%*)
|
|
TEST="$NAME: security of SSL-L over TCP/IPv6 with RANGE option"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testaddrs tcp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
testserversec "$N" "$TEST" "$opts -s" "ssl-l:$PORT,pf=ip6,reuseaddr,fork,retry=1,$SOCAT_EGD,verify=0,cert=testsrv.crt,key=testsrv.key" "" "range=[::2/128]" "ssl:[::1]:$PORT,cafile=testsrv.crt,$SOCAT_EGD" 6 tcp $PORT -1
|
|
fi # ! feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=OPENSSLTCP6_SOURCEPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp6%*|*%ip6%*|*%openssl%*|*%sourceport%*|*%$NAME%*)
|
|
TEST="$NAME: security of SSL-L over TCP/IPv6 with SOURCEPORT option"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testaddrs tcp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
testserversec "$N" "$TEST" "$opts -s" "ssl-l:$PORT,pf=ip6,reuseaddr,fork,retry=1,$SOCAT_EGD,verify=0,cert=testsrv.crt,key=testsrv.key" "" "sp=$PORT" "ssl:[::1]:$PORT,cafile=testsrv.crt,$SOCAT_EGD" 6 tcp $PORT -1
|
|
fi # ! feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=OPENSSLTCP6_LOWPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp6%*|*%ip6%*|*%openssl%*|*%lowport%*|*%$NAME%*)
|
|
TEST="$NAME: security of SSL-L over TCP/IPv6 with LOWPORT option"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testaddrs tcp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
testserversec "$N" "$TEST" "$opts -s" "ssl-l:$PORT,pf=ip6,reuseaddr,fork,retry=1,$SOCAT_EGD,verify=0,cert=testsrv.crt,key=testsrv.key" "" "lowport" "ssl:[::1]:$PORT,cafile=testsrv.crt,$SOCAT_EGD" 6 tcp $PORT -1
|
|
fi # ! feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=OPENSSLTCP6_TCPWRAP
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp6%*|*%ip6%*|*%openssl%*|*%tcpwrap%*|*%$NAME%*)
|
|
TEST="$NAME: security of SSL-L over TCP/IPv6 with TCPWRAP option"
|
|
if ! feat=$(testaddrs ip6 tcp libwrap openssl) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: [::2]" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
testserversec "$N" "$TEST" "$opts -s" "ssl-l:$PORT,pf=ip6,reuseaddr,fork,retry=1,$SOCAT_EGD,verify=0,cert=testsrv.crt,key=testsrv.key" "" "tcpwrap-etc=$td" "ssl:[::1]:$PORT,cafile=testsrv.crt,$SOCAT_EGD" 6 tcp $PORT -1
|
|
fi # ! feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=OPENSSL_FIPS_SECURITY
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%openssl%*|*%fips%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%$NAME%*)
|
|
TEST="$NAME: OpenSSL restrictions by FIPS"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testaddrs listen tcp ip4 >/dev/null || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP/IPv4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! testoptions fips >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL/FIPS not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
gentestcert testsrv
|
|
gentestcert testcli
|
|
# openssl client accepts a "normal" certificate only when not in fips mode
|
|
testserversec "$N" "$TEST" "$opts -s" "ssl:$LOCALHOST:$PORT,fork,retry=2,verify,cafile=testsrv.crt" "" "fips" "ssl-l:$PORT,pf=ip4,reuseaddr,cert=testsrv.crt,key=testsrv.key" 4 tcp "" -1
|
|
fi ;; # testaddrs
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UNIEXECEOF
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: give exec'd write-only process a chance to flush (-u)"
|
|
testod "$N" "$TEST" "" exec:'od -c' "$opts -u"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=REVEXECEOF
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: give exec'd write-only process a chance to flush (-U)"
|
|
testod "$N" "$TEST" exec:'od -c' "-" "$opts -U"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=FILANDIR
|
|
case "$TESTS" in
|
|
*%filan%*|*%$NAME%*)
|
|
TEST="$NAME: check type printed for directories"
|
|
te="$td/test$N.stderr"
|
|
printf "test $F_n $TEST... " $N
|
|
type=$($FILAN -f . 2>$te |tail -n 1 |awk '{print($2);}')
|
|
if [ "$type" = "dir" ]; then
|
|
$PRINTF "$OK\n"
|
|
numOK=$((numOK+1))
|
|
else
|
|
$PRINTF "$FAILED\n"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=FILANSOCKET
|
|
case "$TESTS" in
|
|
*%filan%*|*%$NAME%*)
|
|
TEST="$NAME: capability to analyze named unix socket"
|
|
ts="$td/test$N.socket"
|
|
te1="$td/test$N.stderr1" # socat
|
|
te2="$td/test$N.stderr2" # filan
|
|
printf "test $F_n $TEST... " $N
|
|
$SOCAT unix-l:"$ts" /dev/null </dev/null 2>"$te1" &
|
|
spid=$!
|
|
waitfile "$ts" 1
|
|
type=$($FILAN -f "$ts" 2>$te2 |tail -n 1 |awk '{print($2);}')
|
|
if [ "$type" = "socket" ]; then
|
|
$PRINTF "$OK\n"
|
|
numOK=$((numOK+1))
|
|
else
|
|
$PRINTF "$FAILED\n"
|
|
cat "$te1"
|
|
cat "$te2"
|
|
numFAIL=$((numFAIL+1))
|
|
fi
|
|
kill $spid 2>/dev/null
|
|
wait
|
|
;;
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
testptywaitslave () {
|
|
local N="$1"
|
|
local TEST="$2"
|
|
local PTYTYPE="$3" # ptmx or openpty
|
|
local opts="$4"
|
|
|
|
tp="$td/test$N.pty"
|
|
ts="$td/test$N.socket"
|
|
tf="$td/test$N.file"
|
|
tdiff="$td/test$N.diff"
|
|
te1="$td/test$N.stderr1"
|
|
te2="$td/test$N.stderr2"
|
|
te3="$td/test$N.stderr3"
|
|
te4="$td/test$N.stderr4"
|
|
da="test$N.1 $(date) $RANDOM"
|
|
printf "test $F_n $TEST... " $N
|
|
# first generate a pty, then a socket
|
|
($SOCAT $opts -lpsocat1 pty,$PTYTYPE,pty-wait-slave,link="$tp" unix-listen:"$ts" 2>"$te1"; rm -f "$tp") 2>/dev/null &
|
|
pid=$!
|
|
waitfile "$tp"
|
|
# if pty was non-blocking, the socket is active, and socat1 will term
|
|
$SOCAT $opts -T 10 -lpsocat2 file:/dev/null unix-connect:"$ts" 2>"$te2"
|
|
# if pty is blocking, first socat is still active and we get a connection now
|
|
#((echo "$da"; sleep 2) |$SOCAT -lpsocat3 $opts - file:"$tp",$PTYOPTS2 >"$tf" 2>"$te3") &
|
|
( (waitfile "$ts"; echo "$da"; sleep 1) |$SOCAT -lpsocat3 $opts - file:"$tp",$PTYOPTS2 >"$tf" 2>"$te3") &
|
|
waitfile "$ts"
|
|
# but we need an echoer on the socket
|
|
$SOCAT $opts -lpsocat4 unix:"$ts" echo 2>"$te4"
|
|
# now $tf file should contain $da
|
|
#kill $pid 2>/dev/null
|
|
wait
|
|
#
|
|
if echo "$da" |diff - "$tf"> "$tdiff"; then
|
|
$PRINTF "$OK\n"
|
|
numOK=$((numOK+1))
|
|
else
|
|
$PRINTF "${YELLOW}FAILED${NORMAL}\n"
|
|
cat "$te1"
|
|
#cat "$te2" # not of interest
|
|
cat "$te3"
|
|
cat "$te4"
|
|
cat "$tdiff"
|
|
numCANT=$((numCANT+1))
|
|
fi
|
|
}
|
|
|
|
NAME=PTMXWAITSLAVE
|
|
PTYTYPE=ptmx
|
|
case "$TESTS" in
|
|
*%functions%*|*%pty%*|*%$NAME%*)
|
|
TEST="$NAME: test if master pty ($PTYTYPE) waits for slave connection"
|
|
if ! feat=$(testaddrs pty); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$(echo $feat| tr 'a-z' 'A-Z') not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testoptions "$PTYTYPE" pty-wait-slave); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}option $(echo $feat| tr 'a-z' 'A-Z') not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testptywaitslave "$N" "$TEST" "$PTYTYPE" "$opts"
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
NAME=OPENPTYWAITSLAVE
|
|
PTYTYPE=openpty
|
|
case "$TESTS" in
|
|
*%functions%*|*%pty%*|*%$NAME%*)
|
|
TEST="$NAME: test if master pty ($PTYTYPE) waits for slave connection"
|
|
if ! feat=$(testaddrs pty); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$(echo $feat| tr 'a-z' 'A-Z') not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testoptions "$PTYTYPE" pty-wait-slave); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}option $(echo $feat| tr 'a-z' 'A-Z') not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testptywaitslave "$N" "$TEST" "$PTYTYPE" "$opts"
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=CONNECTTIMEOUT
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: test the connect-timeout option"
|
|
if ! feat=$(testaddrs tcp); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$(echo $feat| tr 'a-z' 'A-Z') not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif ! feat=$(testoptions connect-timeout); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$(echo $feat| tr 'a-z' 'A-Z') not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
# we need a hanging connection attempt, guess an address for this
|
|
case "$UNAME" in
|
|
Linux) HANGIP=1.0.0.1 ;;
|
|
*) HANGIP=255.255.255.254 ;;
|
|
esac
|
|
te1="$td/test$N.stderr1"
|
|
tk1="$td/test$N.kill1"
|
|
te2="$td/test$N.stderr2"
|
|
tk2="$td/test$N.kill2"
|
|
$PRINTF "test $F_n $TEST... " $N
|
|
# first, try to make socat hang and see if it can be killed
|
|
#$SOCAT $opts - tcp:$HANGIP:1 >"$te1" 2>&1 </dev/null &
|
|
CMD="$SOCAT $opts - tcp:$HANGIP:1"
|
|
$CMD >"$te1" 2>&1 </dev/null &
|
|
pid1=$!
|
|
sleep 2
|
|
if ! kill $pid1 2>"$tk1"; then
|
|
$PRINTF "${YELLOW}does not hang${NORMAL}\n"
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
# second, set connect-timeout and see if socat exits before kill
|
|
$SOCAT $opts - tcp:$HANGIP:1,connect-timeout=1.0 >"$te2" 2>&1 </dev/null &
|
|
pid2=$!
|
|
sleep 2
|
|
if kill $pid2 2>"$tk2"; then
|
|
$PRINTF "$FAILED\n"
|
|
echo "$CMD"
|
|
cat "$te1"
|
|
cat "$te2"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi
|
|
wait
|
|
fi ;; # testaddrs
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=OPENSSLLISTENDSA
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: openssl listen with DSA certificate"
|
|
if ! testaddrs openssl >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}OPENSSL not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
SRVCERT=testsrvdsa
|
|
gentestdsacert $SRVCERT
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
CMD2="$SOCAT $opts OPENSSL-LISTEN:$PORT,pf=ip4,reuseaddr,$SOCAT_EGD,cert=$SRVCERT.pem,key=$SRVCERT.key,verify=0 pipe"
|
|
CMD="$SOCAT $opts - openssl:$LOCALHOST:$PORT,pf=ip4,verify=0,$SOCAT_EGD"
|
|
$PRINTF "test $F_n $TEST... " $N
|
|
eval "$CMD2 2>\"${te}1\" &"
|
|
pid=$! # background process id
|
|
waittcp4port $PORT
|
|
echo "$da" |$CMD >$tf 2>"${te}2"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
echo "$CMD2 &"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat ${te}1 ${te}2; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null
|
|
wait
|
|
fi ;; # testaddrs
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
# derive signal number from signal name
|
|
# kill -l should provide the info
|
|
signum () {
|
|
if [ ! "$BASH_VERSION" ]; then
|
|
# we expect:
|
|
for i in $(kill -l); do echo $i; done |grep -n -i $1 |cut -d: -f1
|
|
else
|
|
# expect:
|
|
# " 1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL"
|
|
signam="$1"
|
|
kill -l </dev/null |
|
|
while read l; do printf "%s %s\n%s %s\n%s %s\n%s %s\n" $l; done |
|
|
grep -e "SIG$signam\$" |
|
|
cut -d ')' -f 1
|
|
fi
|
|
}
|
|
|
|
# problems with QUIT, INT (are blocked in system() )
|
|
for signam in TERM ILL; do
|
|
NAME=EXITCODESIG$signam
|
|
case "$TESTS" in
|
|
*%functions%*|*%pty%*|*%$NAME%*)
|
|
TEST="$NAME: exit status when dying on SIG$signam"
|
|
if ! feat=$(testaddrs pty); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$(echo $feat |tr a-z A-Z) not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
SIG=$(signum $signam)
|
|
te="$td/test$N.stderr"
|
|
tpp="$td/test$N.ppid"
|
|
tp="$td/test$N.pid"
|
|
$PRINTF "test $F_n $TEST... " $N
|
|
(sleep 1; kill -$SIG $(cat "$tpp")) &
|
|
# a simple "system:echo $PPID..." does not work on NetBSD, OpenBSD
|
|
#$SOCAT $opts echo system:'exec /bin/bash -c "echo \$PPID '">$tpp"'; echo \$$ '">$tp; read x\"",nofork 2>"$te"; stat=$?
|
|
tsh="$td/test$N.sh"
|
|
cat <<EOF >"$tsh"
|
|
#! /bin/bash
|
|
echo \$PPID >"$tpp"
|
|
echo \$\$ >"$tp"
|
|
read x
|
|
EOF
|
|
chmod a+x "$tsh"
|
|
$SOCAT $opts echo system:"exec \"$tsh\"",pty,setsid,nofork 2>"$te"; stat=$?
|
|
sleep 1; kill -INT $(cat $tp)
|
|
wait
|
|
if [ "$stat" -eq $((128+$SIG)) ]; then
|
|
$PRINTF "$OK\n"
|
|
numOK=$((numOK+1))
|
|
else
|
|
$PRINTF "$FAILED\n"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
fi
|
|
wait
|
|
fi ;; # feat
|
|
esac
|
|
N=$((N+1))
|
|
done
|
|
|
|
|
|
NAME=READBYTES
|
|
#set -vx
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: restrict reading from file with bytes option"
|
|
if false; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$(echo $feat| tr 'a-z' 'A-Z') not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tr="$td/test$N.ref"
|
|
ti="$td/test$N.in"
|
|
to="$td/test$N.out"
|
|
te="$td/test$N.err"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date)" da="$da$($ECHO '\r')"
|
|
# the feature that we really want to test is in the readline.sh script:
|
|
CMD="$SOCAT $opts -u open:$ti,readbytes=100 -"
|
|
printf "test $F_n $TEST... " $N
|
|
rm -f "$tf" "$ti" "$to"
|
|
#
|
|
echo "AAAAAAAAAAAAAAAAAAAAAAAA
|
|
AAAAAAAAAAAAAAAAAAAAAAAA
|
|
AAAAAAAAAAAAAAAAAAAAAAAA
|
|
AAAAAAAAAAAAAAAAAAAAAAAA" >"$tr" # 100 bytes
|
|
cat "$tr" "$tr" >"$ti" # 200 bytes
|
|
$CMD >"$to" 2>"$te"
|
|
if ! diff "$tr" "$to" >"$tdiff" 2>&1; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UNIXLISTENFORK
|
|
case "$TESTS" in
|
|
*%functions%*|*%unix%*|*%listen%*|*%fork%*|*%$NAME%*)
|
|
TEST="$NAME: UNIX socket keeps listening after child died"
|
|
if false; then
|
|
:
|
|
else
|
|
ts="$td/test$N.socket"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da1="test$N $(date) $RANDOM"
|
|
da2="test$N $(date) $RANDOM"
|
|
#establish a listening and forking unix socket in background
|
|
SRV="$SOCAT $opts -lpserver UNIX-LISTEN:\"$ts\",fork PIPE"
|
|
#make a first and a second connection
|
|
CLI="$SOCAT $opts -lpclient - UNIX-CONNECT:\"$ts\""
|
|
$PRINTF "test $F_n $TEST... " $N
|
|
eval "$SRV 2>${te}s &"
|
|
pids=$!
|
|
waitfile "$ts"
|
|
echo "$da1" |eval "$CLI" >"${tf}1" 2>"${te}1"
|
|
if [ $? -ne 0 ]; then
|
|
kill "$pids" 2>/dev/null
|
|
$PRINTF "$NO_RESULT (first conn failed):\n"
|
|
echo "$SRV &"
|
|
echo "$CLI"
|
|
cat "${te}s" "${te}1"
|
|
numCANT=$((numCANT+1))
|
|
elif ! echo "$da1" |diff - "${tf}1" >"$tdiff"; then
|
|
kill "$pids" 2>/dev/null
|
|
$PRINTF "$NO_RESULT (first conn failed); diff:\n"
|
|
cat "$tdiff"
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
echo "$da2" |eval "$CLI" >"${tf}2" 2>"${te}2"
|
|
rc="$?"; kill "$pids" 2>/dev/null
|
|
if [ $rc -ne 0 ]; then
|
|
$PRINTF "$FAILED:\n"
|
|
echo "$SRV &"
|
|
echo "$CLI"
|
|
cat "${te}s" "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da2" |diff - "${tf}2" >"$tdiff"; then
|
|
$PRINTF "$FAILED: diff\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
numOK=$((numOK+1))
|
|
fi # !( $? -ne 0)
|
|
fi # !(rc -ne 0)
|
|
wait
|
|
fi # true
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UNIXTOSTREAM
|
|
case "$TESTS" in
|
|
*%functions%*|*%unix%*|*%listen%*|*%$NAME%*)
|
|
TEST="$NAME: generic UNIX client connects to stream socket"
|
|
if false; then
|
|
:
|
|
else
|
|
ts="$td/test$N.socket"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da1="test$N $(date) $RANDOM"
|
|
#establish a listening unix socket in background
|
|
SRV="$SOCAT $opts -lpserver UNIX-LISTEN:\"$ts\" PIPE"
|
|
#make a connection
|
|
CLI="$SOCAT $opts -lpclient - UNIX:\"$ts\""
|
|
$PRINTF "test $F_n $TEST... " $N
|
|
eval "$SRV 2>${te}s &"
|
|
pids=$!
|
|
waitfile "$ts"
|
|
echo "$da1" |eval "$CLI" >"${tf}1" 2>"${te}1"
|
|
if [ $? -ne 0 ]; then
|
|
kill "$pids" 2>/dev/null
|
|
$PRINTF "$FAILED:\n"
|
|
echo "$SRV &"
|
|
echo "$CLI"
|
|
cat "${te}s" "${te}1"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da1" |diff - "${tf}1" >"$tdiff"; then
|
|
kill "$pids" 2>/dev/null
|
|
$PRINTF "$FAILED; diff:\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
numOK=$((numOK+1))
|
|
fi # !(rc -ne 0)
|
|
wait
|
|
fi # true
|
|
wait
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UNIXTODGRAM
|
|
case "$TESTS" in
|
|
*%functions%*|*%unix%*|*%recv%*|*%$NAME%*)
|
|
TEST="$NAME: generic UNIX client connects to datagram socket"
|
|
if false; then
|
|
:
|
|
else
|
|
ts1="$td/test$N.socket1"
|
|
ts2="$td/test$N.socket2"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da1="test$N $(date) $RANDOM"
|
|
#establish a receiving unix datagram socket in background
|
|
SRV="$SOCAT $opts -lpserver UNIX-RECVFROM:\"$ts1\" PIPE"
|
|
#make a connection
|
|
CLI="$SOCAT $opts -lpclient - UNIX:\"$ts1\",bind=\"$ts2\""
|
|
#CLI="$SOCAT $opts -lpclient - UNIX:\"$ts1\""
|
|
$PRINTF "test $F_n $TEST... " $N
|
|
eval "$SRV 2>${te}s &"
|
|
pids=$!
|
|
waitfile "$ts1"
|
|
echo "$da1" |eval "$CLI" >"${tf}1" 2>"${te}1"
|
|
if [ $? -ne 0 ]; then
|
|
kill "$pids" 2>/dev/null
|
|
$PRINTF "$FAILED:\n"
|
|
echo "$SRV &"
|
|
cat "${te}s"
|
|
echo "$CLI"
|
|
cat "${te}1" "${te}1"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da1" |diff - "${tf}1" >"$tdiff"; then
|
|
kill "$pids" 2>/dev/null
|
|
$PRINTF "$FAILED:\n"
|
|
echo "$SRV &"
|
|
cat "${te}s"
|
|
echo "$CLI"
|
|
cat "${te}1"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
numOK=$((numOK+1))
|
|
fi # !(rc -ne 0)
|
|
wait
|
|
fi # true
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=EXECPIPESSTDERR
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: simple echo via exec of cat with pipes,stderr"
|
|
testecho "$N" "$TEST" "" "exec:$CAT,pipes,stderr" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=SIMPLEPARSE
|
|
case "$TESTS" in
|
|
*%functions%*|*%PARSE%*|*%$NAME%*)
|
|
TEST="$NAME: invoke socat from socat"
|
|
testecho "$N" "$TEST" "" exec:"$SOCAT - exec\:$CAT,pipes" "$opts"
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=FULLPARSE
|
|
case "$TESTS" in
|
|
*%functions%*|*%parse%*|*%$NAME%*)
|
|
TEST="$NAME: correctly parse special chars"
|
|
$PRINTF "test $F_n $TEST... " $N
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
# a string where commas are hidden in nesting lexical constructs
|
|
# if they are scanned incorrectly, socat will see an "unknown option"
|
|
dain='(,)[,]{,}","([),])hugo'
|
|
daout='(,)[,]{,},([),])hugo'
|
|
"$SOCAT" $opts -u "exec:echo $dain" - >"$tf" 2>"$te"
|
|
rc=$?
|
|
echo "$daout" |diff "$tf" - >"$tdiff"
|
|
if [ "$rc" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$SOCAT" -u "exec:echo $da" -
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
elif [ -s "$tdiff" ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo diff:
|
|
cat "$tdiff"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
NAME=NESTEDSOCATEXEC
|
|
case "$TESTS" in
|
|
*%parse%*|*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: does lexical analysis work sensibly (exec)"
|
|
testecho "$N" "$TEST" "" "exec:'$SOCAT - exec:$CAT,pipes'" "$opts" 1
|
|
esac
|
|
N=$((N+1))
|
|
|
|
NAME=NESTEDSOCATSYSTEM
|
|
case "$TESTS" in
|
|
*%parse%*|*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: does lexical analysis work sensibly (system)"
|
|
testecho "$N" "$TEST" "" "system:\"$SOCAT - exec:$CAT,pipes\"" "$opts" 1
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=TCP6BYTCP4
|
|
case "$TESTS" in
|
|
*%functions%*|*%tcp%*|*%tcp6%*|*%ip6%*|*%$NAME%*)
|
|
TEST="$NAME: TCP4 mapped into TCP6 address space"
|
|
if ! testaddrs tcp ip6 >/dev/null || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="127.0.0.1:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts TCP6-listen:$tsl,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts stdin!!stdout TCP6:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid=$! # background process id
|
|
waittcp6port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: diff:\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
kill $pid 2>/dev/null; wait
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP4DGRAM
|
|
case "$TESTS" in
|
|
*%functions%*|*%udp%*|*%udp4%*|*%ip4%*|*%dgram%*|*%$NAME%*)
|
|
TEST="$NAME: UDP/IPv4 datagram"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PORT; PORT=$((PORT+1))
|
|
ts1a="127.0.0.1"
|
|
ts1="$ts1a:$ts1p"
|
|
ts2p=$PORT; PORT=$((PORT+1))
|
|
ts2="127.0.0.1:$ts2p"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts UDP4-RECVFROM:$ts1p,reuseaddr,bind=$ts1a PIPE"
|
|
CMD2="$SOCAT $opts - UDP4-SENDTO:$ts1,bind=$ts2"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" &
|
|
pid1="$!"
|
|
waitudp4port $ts1p 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
rc2="$?"
|
|
kill "$pid1" 2>/dev/null; wait;
|
|
if [ "$rc2" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi ;;
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP6DGRAM
|
|
case "$TESTS" in
|
|
*%functions%*|*%udp%*|*%udp6%*|*%ip6%*|*%dgram%*|*%$NAME%*)
|
|
TEST="$NAME: UDP/IPv6 datagram"
|
|
if ! feat=$(testaddrs tcp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PORT; PORT=$((PORT+1))
|
|
tsa="[::1]"
|
|
ts1="$tsa:$ts1p"
|
|
ts2p=$PORT; PORT=$((PORT+1))
|
|
ts2="$tsa:$ts2p"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts UDP6-RECVFROM:$ts1p,reuseaddr,bind=$tsa PIPE"
|
|
CMD2="$SOCAT $opts - UDP6-SENDTO:$ts1,bind=$ts2"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" &
|
|
waitudp6port $ts1p 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat ${te}1 ${te}2; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # ! feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=RAWIP4RECVFROM
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip%*|*%ip4%*|*%rawip%*|*%rawip4%*|*%dgram%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: raw IPv4 datagram"
|
|
if [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PROTO; PROTO=$((PROTO+1))
|
|
ts1a="127.0.0.1"
|
|
ts1="$ts1a:$ts1p"
|
|
ts2a="$SECONDADDR"
|
|
ts2="$ts2a:$ts2p"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts IP4-RECVFROM:$ts1p,reuseaddr,bind=$ts1a PIPE"
|
|
CMD2="$SOCAT $opts - IP4-SENDTO:$ts1,bind=$ts2a"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" &
|
|
pid1=$!
|
|
waitip4proto $ts1p 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
rc2=$?
|
|
kill $pid1 2>/dev/null; wait
|
|
if [ $rc2 -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi # must be root;;
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
if false; then
|
|
NAME=RAWIP6RECVFROM
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip%*|*%ip6%*|*%rawip%*|*%rawip6%*|*%dgram%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: raw IPv6 datagram by self addressing"
|
|
if [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PROTO; PROTO=$((PROTO+1))
|
|
tsa="[::1]"
|
|
ts1="$tsa:$ts1p"
|
|
ts2="$tsa"
|
|
da=$(date)
|
|
#CMD1="$SOCAT $opts IP6-RECVFROM:$ts1p,reuseaddr,bind=$tsa PIPE"
|
|
CMD2="$SOCAT $opts - IP6-SENDTO:$ts1,bind=$ts2"
|
|
printf "test $F_n $TEST... " $N
|
|
#$CMD1 2>"${te}1" &
|
|
waitip6proto $ts1p 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
# echo "$CMD1 &"
|
|
# cat "${te}1"
|
|
echo "$CMD2"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "$te"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi # must be root ;;
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
fi #false
|
|
|
|
|
|
NAME=UNIXDGRAM
|
|
case "$TESTS" in
|
|
*%functions%*|*%unix%*|*%dgram%*|*%$NAME%*)
|
|
TEST="$NAME: UNIX datagram"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1="$td/test$N.socket1"
|
|
ts2="$td/test$N.socket2"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts UNIX-RECVFROM:$ts1,reuseaddr PIPE"
|
|
CMD2="$SOCAT $opts - UNIX-SENDTO:$ts1,bind=$ts2"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" &
|
|
pid1="$!"
|
|
waitfile $ts1 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
rc2=$?
|
|
kill "$pid1" 2>/dev/null; wait
|
|
if [ $rc2 -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
cat "${te}1"
|
|
echo "$CMD2"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi ;;
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP4RECV
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip4%*|*%dgram%*|*%udp%*|*%udp4%*|*%recv%*|*%$NAME%*)
|
|
TEST="$NAME: UDP/IPv4 receive"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PORT; PORT=$((PORT+1))
|
|
ts1a="127.0.0.1"
|
|
ts1="$ts1a:$ts1p"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts -u UDP4-RECV:$ts1p,reuseaddr -"
|
|
CMD2="$SOCAT $opts -u - UDP4-SENDTO:$ts1"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid1="$!"
|
|
waitudp4port $ts1p 1
|
|
echo "$da" |$CMD2 2>>"${te}2"
|
|
rc2="$?"
|
|
#ls -l $tf
|
|
i=0; while [ ! -s "$tf" -a "$i" -lt 10 ]; do usleep 100000; i=$((i+1)); done
|
|
kill "$pid1" 2>/dev/null; wait
|
|
if [ "$rc2" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi ;;
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP6RECV
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip6%*|*%dgram%*|*%udp%*|*%udp6%*|*%recv%*|*%$NAME%*)
|
|
TEST="$NAME: UDP/IPv6 receive"
|
|
if ! feat=$(testaddrs tcp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PORT; PORT=$((PORT+1))
|
|
ts1a="[::1]"
|
|
ts1="$ts1a:$ts1p"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts -u UDP6-RECV:$ts1p,reuseaddr -"
|
|
CMD2="$SOCAT $opts -u - UDP6-SENDTO:$ts1"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid1="$!"
|
|
waitudp6port $ts1p 1
|
|
echo "$da" |$CMD2 2>>"${te}2"
|
|
rc2="$?"
|
|
#ls -l $tf
|
|
i=0; while [ ! -s "$tf" -a "$i" -lt 10 ]; do usleep 100000; i=$((i+1)); done
|
|
kill "$pid1" 2>/dev/null; wait
|
|
if [ "$rc2" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # ! feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=RAWIP4RECV
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip4%*|*%dgram%*|*%rawip%*|*%rawip4%*|*%recv%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: raw IPv4 receive"
|
|
if [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PROTO; PROTO=$((PROTO+1))
|
|
ts1a="127.0.0.1"
|
|
ts1="$ts1a:$ts1p"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts -u IP4-RECV:$ts1p,reuseaddr -"
|
|
CMD2="$SOCAT $opts -u - IP4-SENDTO:$ts1"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid1="$!"
|
|
waitip4proto $ts1p 1
|
|
echo "$da" |$CMD2 2>>"${te}2"
|
|
rc2="$?"
|
|
#ls -l $tf
|
|
i=0; while [ ! -s "$tf" -a "$i" -lt 10 ]; do usleep 100000; i=$((i+1)); done
|
|
kill "$pid1" 2>/dev/null; wait
|
|
if [ "$rc2" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi # must be root ;;
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=RAWIP6RECV
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip6%*|*%dgram%*|*%rawip%*|*%rawip6%*|*%recv%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: raw IPv6 receive"
|
|
if ! feat=$(testaddrs ip6 rawip) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PROTO; PROTO=$((PROTO+1))
|
|
ts1a="[::1]"
|
|
ts1="$ts1a:$ts1p"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts -u IP6-RECV:$ts1p,reuseaddr -"
|
|
CMD2="$SOCAT $opts -u - IP6-SENDTO:$ts1"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid1="$!"
|
|
waitip6proto $ts1p 1
|
|
echo "$da" |$CMD2 2>>"${te}2"
|
|
rc2="$?"
|
|
i=0; while [ ! -s "$tf" -a "$i" -lt 10 ]; do usleep 100000; i=$((i+1)); done
|
|
kill "$pid1" 2>/dev/null; wait
|
|
if [ "$rc2" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi # must be root ;;
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UNIXRECV
|
|
case "$TESTS" in
|
|
*%functions%*|*%unix%*|*%dgram%*|*%recv%*|*%$NAME%*)
|
|
TEST="$NAME: UNIX receive"
|
|
ts="$td/test$N.socket"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1="$ts"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts -u UNIX-RECV:$ts1,reuseaddr -"
|
|
CMD2="$SOCAT $opts -u - UNIX-SENDTO:$ts1"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid1="$!"
|
|
waitfile $ts1 1
|
|
echo "$da" |$CMD2 2>>"${te}2"
|
|
rc2="$?"
|
|
i=0; while [ ! -s "$tf" -a "$i" -lt 10 ]; do usleep 100000; i=$((i+1)); done
|
|
kill "$pid1" 2>/dev/null; wait
|
|
if [ "$rc2" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi ;;
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP4RECVFROM_SOURCEPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp4%*|*%ip4%*|*%sourceport%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP4-RECVFROM with SOURCEPORT option"
|
|
if ! feat=$(testaddrs udp ip4) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testserversec "$N" "$TEST" "$opts -s" "udp4-recvfrom:$PORT,reuseaddr" "" "sp=$PORT" "udp4-sendto:127.0.0.1:$PORT" 4 udp $PORT 0
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP4RECVFROM_LOWPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp4%*|*%ip4%*|*%lowport%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP4-RECVFROM with LOWPORT option"
|
|
if ! feat=$(testaddrs udp ip4) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testserversec "$N" "$TEST" "$opts -s" "udp4-recvfrom:$PORT,reuseaddr" "" "lowport" "udp4-sendto:127.0.0.1:$PORT" 4 udp $PORT 0
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP4RECVFROM_RANGE
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp4%*|*%ip4%*|*%range%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP4-RECVFROM with RANGE option"
|
|
#testserversec "$N" "$TEST" "$opts -s" "udp4-recvfrom:$PORT,reuseaddr,fork" "" "range=$SECONDADDR/32" "udp4-sendto:127.0.0.1:$PORT" 4 udp $PORT 0
|
|
testserversec "$N" "$TEST" "$opts -s" "udp4-recvfrom:$PORT,reuseaddr" "" "range=$SECONDADDR/32" "udp4-sendto:127.0.0.1:$PORT" 4 udp $PORT 0
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP4RECVFROM_TCPWRAP
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp4%*|*%ip4%*|*%tcpwrap%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP4-RECVFROM with TCPWRAP option"
|
|
if ! feat=$(testaddrs ip4 udp libwrap) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: $SECONDADDR" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
#testserversec "$N" "$TEST" "$opts -s" "udp4-recvfrom:$PORT,reuseaddr,fork" "" "tcpwrap=$d" "udp4-sendto:127.0.0.1:$PORT" 4 udp $PORT 0
|
|
testserversec "$N" "$TEST" "$opts -s" "udp4-recvfrom:$PORT,reuseaddr" "" "tcpwrap-etc=$td" "udp4-sendto:127.0.0.1:$PORT" 4 udp $PORT 0
|
|
fi ;; # feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP4RECV_SOURCEPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp4%*|*%ip4%*|*%sourceport%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP4-RECV with SOURCEPORT option"
|
|
if ! feat=$(testaddrs udp ip4) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
PORT1=$PORT; PORT=$((PORT+1))
|
|
PORT2=$PORT; PORT=$((PORT+1))
|
|
PORT3=$PORT
|
|
# we use the forward channel (PORT1) for testing, and have a backward channel
|
|
# (PORT2) to get the data back, so we get the classical echo behaviour
|
|
testserversec "$N" "$TEST" "$opts -s" "udp4-recv:$PORT1,reuseaddr!!udp4-sendto:127.0.0.1:$PORT2" "" "sp=$PORT3" "udp4-recv:$PORT2!!udp4-sendto:127.0.0.1:$PORT1" 4 udp $PORT1 0
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP4RECV_LOWPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp4%*|*%ip4%*|*%lowport%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP4-RECV with LOWPORT option"
|
|
if ! feat=$(testaddrs udp ip4) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
PORT1=$PORT; PORT=$((PORT+1))
|
|
PORT2=$PORT
|
|
# we use the forward channel (PORT1) for testing, and have a backward channel
|
|
# (PORT2) to get the data back, so we get the classical echo behaviour
|
|
testserversec "$N" "$TEST" "$opts -s" "udp4-recv:$PORT1,reuseaddr!!udp4-sendto:127.0.0.1:$PORT2" "" "lowport" "udp4-recv:$PORT2!!udp4-sendto:127.0.0.1:$PORT1" 4 udp $PORT1 0
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP4RECV_RANGE
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp4%*|*%ip4%*|*%range%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP4-RECV with RANGE option"
|
|
if ! feat=$(testaddrs udp ip4) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
PORT1=$PORT; PORT=$((PORT+1))
|
|
PORT2=$PORT
|
|
# we use the forward channel (PORT1) for testing, and have a backward channel
|
|
# (PORT2) to get the data back, so we get the classical echo behaviour
|
|
testserversec "$N" "$TEST" "$opts -s" "udp4-recv:$PORT1,reuseaddr!!udp4-sendto:127.0.0.1:$PORT2" "" "range=$SECONDADDR/32" "udp4-recv:$PORT2!!udp4-sendto:127.0.0.1:$PORT1" 4 udp $PORT1 0
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP4RECV_TCPWRAP
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp4%*|*%ip4%*|*%tcpwrap%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP4-RECV with TCPWRAP option"
|
|
if ! feat=$(testaddrs udp ip4 libwrap) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
PORT1=$PORT; PORT=$((PORT+1))
|
|
PORT2=$PORT
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: $SECONDADDR" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
# we use the forward channel (PORT1) for testing, and have a backward channel
|
|
# (PORT2) to get the data back, so we get the classical echo behaviour
|
|
testserversec "$N" "$TEST" "$opts -s" "udp4-recv:$PORT1,reuseaddr!!udp4-sendto:127.0.0.1:$PORT2" "" "tcpwrap-etc=$td" "udp4-recv:$PORT2!!udp4-sendto:127.0.0.1:$PORT1" 4 udp $PORT1 0
|
|
fi ;; # feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP6RECVFROM_SOURCEPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp6%*|*%ip6%*|*%sourceport%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP6-RECVFROM with SOURCEPORT option"
|
|
if ! feat=$(testaddrs udp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testserversec "$N" "$TEST" "$opts -s" "udp6-recvfrom:$PORT,reuseaddr" "" "sp=$PORT" "udp6-sendto:[::1]:$PORT" 6 udp $PORT 0
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP6RECVFROM_LOWPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp6%*|*%ip6%*|*%lowport%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP6-RECVFROM with LOWPORT option"
|
|
if ! feat=$(testaddrs udp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testserversec "$N" "$TEST" "$opts -s" "udp6-recvfrom:$PORT,reuseaddr" "" "lowport" "udp6-sendto:[::1]:$PORT" 6 udp $PORT 0
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP6RECVFROM_RANGE
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp6%*|*%ip6%*|*%range%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP6-RECVFROM with RANGE option"
|
|
if ! feat=$(testaddrs tcp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}TCP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
#testserversec "$N" "$TEST" "$opts -s" "udp6-recvfrom:$PORT,reuseaddr,fork" "" "range=[::2/128]" "udp6-sendto:[::1]:$PORT" 6 udp $PORT 0
|
|
testserversec "$N" "$TEST" "$opts -s" "udp6-recvfrom:$PORT,reuseaddr" "" "range=[::2/128]" "udp6-sendto:[::1]:$PORT" 6 udp $PORT 0
|
|
fi # ! feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP6RECVFROM_TCPWRAP
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp6%*|*%ip6%*|*%tcpwrap%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP6-RECVFROM with TCPWRAP option"
|
|
if ! feat=$(testaddrs udp ip6 libwrap) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: [::2]" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
testserversec "$N" "$TEST" "$opts -s" "udp6-recvfrom:$PORT,reuseaddr" "" "tcpwrap-etc=$td" "udp6-sendto:[::1]:$PORT" 6 udp $PORT 0
|
|
fi ;; # feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP6RECV_SOURCEPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp6%*|*%ip6%*|*%sourceport%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP6-RECV with SOURCEPORT option"
|
|
if ! feat=$(testaddrs udp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
PORT1=$PORT; PORT=$((PORT+1))
|
|
PORT2=$PORT; PORT=$((PORT+1))
|
|
PORT3=$PORT
|
|
# we use the forward channel (PORT1) for testing, and have a backward channel
|
|
# (PORT2) to get the data back, so we get the classical echo behaviour
|
|
testserversec "$N" "$TEST" "$opts -s" "udp6-recv:$PORT1,reuseaddr!!udp6-sendto:[::1]:$PORT2" "" "sp=$PORT3" "udp6-recv:$PORT2!!udp6-sendto:[::1]:$PORT1" 6 udp $PORT1 0
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP6RECV_LOWPORT
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp6%*|*%ip6%*|*%lowport%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP6-RECV with LOWPORT option"
|
|
if ! feat=$(testaddrs udp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
PORT1=$PORT; PORT=$((PORT+1))
|
|
PORT2=$PORT
|
|
# we use the forward channel (PORT1) for testing, and have a backward channel
|
|
# (PORT2) to get the data back, so we get the classical echo behaviour
|
|
testserversec "$N" "$TEST" "$opts -s" "udp6-recv:$PORT1,reuseaddr!!udp6-sendto:[::1]:$PORT2" "" "lowport" "udp6-recv:$PORT2!!udp6-sendto:[::1]:$PORT1" 6 udp $PORT1 0
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP6RECV_RANGE
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp6%*|*%ip6%*|*%range%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP6-RECV with RANGE option"
|
|
if ! feat=$(testaddrs udp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
PORT1=$PORT; PORT=$((PORT+1))
|
|
PORT2=$PORT
|
|
# we use the forward channel (PORT1) for testing, and have a backward channel
|
|
# (PORT2) to get the data back, so we get the classical echo behaviour
|
|
testserversec "$N" "$TEST" "$opts -s" "udp6-recv:$PORT1,reuseaddr!!udp6-sendto:[::1]:$PORT2" "" "range=[::2/128]" "udp6-recv:$PORT2!!udp6-sendto:[::1]:$PORT1" 6 udp $PORT1 0
|
|
fi
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=UDP6RECV_TCPWRAP
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%udp%*|*%udp6%*|*%ip6%*|*%tcpwrap%*|*%$NAME%*)
|
|
TEST="$NAME: security of UDP6-RECV with TCPWRAP option"
|
|
if ! feat=$(testaddrs udp ip6 libwrap) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: [::2]" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
PORT1=$PORT; PORT=$((PORT+1))
|
|
PORT2=$PORT
|
|
# we use the forward channel (PORT1) for testing, and have a backward channel
|
|
# (PORT2) to get the data back, so we get the classical echo behaviour
|
|
testserversec "$N" "$TEST" "$opts -s" "udp6-recv:$PORT1,reuseaddr!!udp6-sendto:[::1]:$PORT2" "" "tcpwrap-etc=$td" "udp6-recv:$PORT2!!udp6-sendto:[::1]:$PORT1" 6 udp $PORT1 0
|
|
fi ;; # feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=IP4RECVFROM_RANGE
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%ip%*|*%ip4%*|*%range%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: security of IP4-RECVFROM with RANGE option"
|
|
if ! feat=$(testaddrs ip4 rawip) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
#testserversec "$N" "$TEST" "$opts -s" "ip4-recvfrom:$PROTO,reuseaddr,fork" "" "range=$SECONDADDR/32" "ip4-sendto:127.0.0.1:$PROTO" 4 ip $PROTO 0
|
|
testserversec "$N" "$TEST" "$opts -s" "ip4-recvfrom:$PROTO,reuseaddr!!udp4-sendto:127.0.0.1:$PORT" "" "range=$SECONDADDR/32" "udp4-recv:$PORT!!ip4-sendto:127.0.0.1:$PROTO" 4 ip $PROTO 0
|
|
fi # not feats, not root
|
|
esac
|
|
PROTO=$((PROTO+1))
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=IP4RECVFROM_TCPWRAP
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%ip%*|*%ip4%*|*%tcpwrap%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: security of IP4-RECVFROM with TCPWRAP option"
|
|
if ! feat=$(testaddrs ip4 rawip libwrap) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: $SECONDADDR" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
#testserversec "$N" "$TEST" "$opts -s" "ip4-recvfrom:$PROTO,reuseaddr,fork" "" "tcpwrap-etc=$td" "ip4-sendto:127.0.0.1:$PROTO" 4 ip $PROTO 0
|
|
testserversec "$N" "$TEST" "$opts -s" "ip4-recvfrom:$PROTO,reuseaddr!!udp4-sendto:127.0.0.1:$PORT" "" "tcpwrap-etc=$td" "udp4-recv:$PORT!!ip4-sendto:127.0.0.1:$PROTO" 4 ip $PROTO 0
|
|
fi # not feats, not root
|
|
esac
|
|
PROTO=$((PROTO+1))
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=IP4RECV_RANGE
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%ip%*|*%ip4%*|*%range%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: security of IP4-RECV with RANGE option"
|
|
if ! feat=$(testaddrs ip4 rawip) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}IP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
PROTO1=$PROTO; PROTO=$((PROTO+1))
|
|
PROTO2=$PROTO
|
|
# we use the forward channel (PROTO1) for testing, and have a backward channel
|
|
# (PROTO2) to get the data back, so we get the classical echo behaviour
|
|
testserversec "$N" "$TEST" "$opts -s" "ip4-recv:$PROTO1,reuseaddr!!ip4-sendto:127.0.0.1:$PROTO2" "" "range=$SECONDADDR/32" "ip4-recv:$PROTO2!!ip4-sendto:127.0.0.1:$PROTO1" 4 ip $PROTO1 0
|
|
fi # not feats, not root
|
|
esac
|
|
PROTO=$((PROTO+1))
|
|
N=$((N+1))
|
|
|
|
|
|
|
|
NAME=IP4RECV_TCPWRAP
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%ip%*|*%ip4%*|*%tcpwrap%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: security of IP4-RECV with TCPWRAP option"
|
|
if ! feat=$(testaddrs ip4 rawip libwrap) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
PROTO1=$PROTO; PROTO=$((PROTO+1))
|
|
PROTO2=$PROTO
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: $SECONDADDR" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
# we use the forward channel (PROTO1) for testing, and have a backward channel
|
|
# (PROTO2) to get the data back, so we get the classical echo behaviour
|
|
testserversec "$N" "$TEST" "$opts -s" "ip4-recv:$PROTO1,reuseaddr!!ip4-sendto:127.0.0.1:$PROTO2" "" "tcpwrap-etc=$td" "ip4-recv:$PROTO2!!ip4-sendto:127.0.0.1:$PROTO1" 4 ip $PROTO1 0
|
|
fi # not feats, not root
|
|
esac
|
|
PROTO=$((PROTO+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=IP6RECVFROM_RANGE
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%ip%*|*%ip6%*|*%range%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: security of IP6-RECVFROM with RANGE option"
|
|
if ! feat=$(testaddrs ip6 rawip) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
#testserversec "$N" "$TEST" "$opts -s" "ip6-recvfrom:$PROTO,reuseaddr,fork" "" "range=[::2/128]" "ip6-sendto:[::1]:$PROTO" 6 ip $PROTO 0
|
|
testserversec "$N" "$TEST" "$opts -s" "ip6-recvfrom:$PROTO,reuseaddr!!udp6-sendto:[::1]:$PORT" "" "range=[::2/128]" "udp6-recv:$PORT!!ip6-sendto:[::1]:$PROTO" 6 ip $PROTO 0
|
|
fi # not feats, not root
|
|
esac
|
|
PROTO=$((PROTO+1))
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=IP6RECVFROM_TCPWRAP
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%ip%*|*%ip6%*|*%tcpwrap%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: security of IP6-RECVFROM with TCPWRAP option"
|
|
if ! feat=$(testaddrs ip6 rawip libwrap) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: [::2]" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
#testserversec "$N" "$TEST" "$opts -s" "ip6-recvfrom:$PROTO,reuseaddr,fork" "" "tcpwrap-etc=$td" "ip6-sendto:[::1]:$PROTO" 6 ip $PROTO 0
|
|
testserversec "$N" "$TEST" "$opts -s" "ip6-recvfrom:$PROTO,reuseaddr!!udp6-sendto:[::1]:$PORT" "" "tcpwrap-etc=$td" "udp6-recv:$PORT!!ip6-sendto:[::1]:$PROTO" 6 ip $PROTO 0
|
|
fi # not feats, not root
|
|
esac
|
|
PROTO=$((PROTO+1))
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=IP6RECV_RANGE
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%ip%*|*%ip6%*|*%range%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: security of IP6-RECV with RANGE option"
|
|
if ! feat=$(testaddrs ip6 rawip) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}raw IP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
PROTO1=$PROTO; PROTO=$((PROTO+1))
|
|
PROTO2=$PROTO
|
|
# we use the forward channel (PROTO1) for testing, and have a backward channel
|
|
# (PROTO2) to get the data back, so we get the classical echo behaviour
|
|
testserversec "$N" "$TEST" "$opts -s" "ip6-recv:$PROTO1,reuseaddr!!ip6-sendto:[::1]:$PROTO2" "" "range=[::2/128]" "ip6-recv:$PROTO2!!ip6-sendto:[::1]:$PROTO1" 6 ip $PROTO1 0
|
|
fi # not feats, not root
|
|
esac
|
|
PROTO=$((PROTO+1))
|
|
N=$((N+1))
|
|
|
|
NAME=IP6RECV_TCPWRAP
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%ip%*|*%ip6%*|*%tcpwrap%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: security of IP6-RECV with TCPWRAP option"
|
|
if ! feat=$(testaddrs ip6 rawip libwrap) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
PROTO1=$PROTO; PROTO=$((PROTO+1))
|
|
PROTO2=$PROTO
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat: [::2]" >"$ha"
|
|
$ECHO "ALL: ALL" >"$hd"
|
|
# we use the forward channel (PROTO1) for testing, and have a backward channel
|
|
# (PROTO2) to get the data back, so we get the classical echo behaviour
|
|
testserversec "$N" "$TEST" "$opts -s" "ip6-recv:$PROTO1,reuseaddr!!ip6-sendto:[::1]:$PROTO2" "" "tcpwrap-etc=$td" "ip6-recv:$PROTO2!!ip6-sendto:[::1]:$PROTO1" 6 ip $PROTO1 0
|
|
fi # not feats, not root
|
|
esac
|
|
PROTO=$((PROTO+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=O_NOATIME_FILE
|
|
case "$TESTS" in
|
|
*%functions%*|*%open%*|*%noatime%*|*%$NAME%*)
|
|
TEST="$NAME: option O_NOATIME on file"
|
|
# idea: create a file with o-noatime option; one second later create a file
|
|
# without this option (using touch); one second later read from the first file.
|
|
# Then we check which file has the later ATIME stamp. For this check we use
|
|
# "ls -ltu" because it is more portable than "test ... -nt ..."
|
|
if ! testoptions o-noatime >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}o-noatime not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.file"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
$PRINTF "test $F_n $TEST... " $N
|
|
CMD="$SOCAT $opts -u open:\"${tf}1\",o-noatime /dev/null"
|
|
# generate a file
|
|
touch "${tf}1"
|
|
sleep 1
|
|
# generate a reference file
|
|
touch "${tf}2"
|
|
sleep 1
|
|
# read from the first file
|
|
$CMD 2>"$te"
|
|
if [ $? -ne 0 ]; then # command failed
|
|
$PRINTF "${FAILED}:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
# check which file has a later atime stamp
|
|
if [ $(ls -ltu "${tf}1" "${tf}2" |head -1 |sed 's/.* //') != "${tf}2" ];
|
|
then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "$te"; fi
|
|
numOK=$((numOK+1))
|
|
fi # wrong time stamps
|
|
fi # command ok
|
|
fi ;; # not feats
|
|
esac
|
|
N=$((N+1))
|
|
|
|
NAME=O_NOATIME_FD
|
|
case "$TESTS" in
|
|
*%functions%*|*%noatime%*|*%$NAME%*)
|
|
TEST="$NAME: option O_NOATIME on file descriptor"
|
|
# idea: use a fd of a file with o-noatime option; one second later create a file
|
|
# without this option (using touch); one second later read from the first file.
|
|
# Then we check which file has the later ATIME stamp. For this check we use
|
|
# "ls -ltu" because it is more portable than "test ... -nt ..."
|
|
if ! testoptions o-noatime >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}o-noatime not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.file"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da=$(date)
|
|
$PRINTF "test $F_n $TEST... " $N
|
|
touch ${tf}1
|
|
CMD="$SOCAT $opts -u -,o-noatime /dev/null <${tf}1"
|
|
# generate a file, len >= 1
|
|
touch "${tf}1"
|
|
sleep 1
|
|
# generate a reference file
|
|
touch "${tf}2"
|
|
sleep 1
|
|
# read from the first file
|
|
sh -c "$CMD" 2>"$te"
|
|
if [ $? -ne 0 ]; then # command failed
|
|
$PRINTF "${FAILED}:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
# check which file has a later atime stamp
|
|
if [ $(ls -ltu "${tf}1" "${tf}2" |head -1 |sed 's/.* //') != "${tf}2" ];
|
|
then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "$te"; fi
|
|
numOK=$((numOK+1))
|
|
fi # wrong time stamps
|
|
fi # command ok
|
|
fi ;; # not feats
|
|
esac
|
|
N=$((N+1))
|
|
|
|
NAME=EXT2_NOATIME
|
|
case "$TESTS" in
|
|
*%functions%*|*%ext2%*|*%noatime%*|*%$NAME%*)
|
|
TEST="$NAME: extended file system options using ext2fs noatime option"
|
|
# idea: create a file with ext2-noatime option; one second later create a file
|
|
# without this option (using touch); one second later read from the first file.
|
|
# Then we check which file has the later ATIME stamp. For this check we use
|
|
# "ls -ltu" because it is more portable than "test ... -nt ..."
|
|
if ! testoptions ext2-noatime >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}ext2-noatime not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ts="$td/test$N.socket"
|
|
tf="$td/test$N.file"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1="$ts"
|
|
da=$(date)
|
|
$PRINTF "test $F_n $TEST... " $N
|
|
CMD0="$SOCAT $opts -u /dev/null create:\"${tf}1\""
|
|
CMD="$SOCAT $opts -u /dev/null create:\"${tf}1\",ext2-noatime"
|
|
# check if this is a capable FS; lsattr does other things on AIX, thus socat
|
|
$CMD0 2>"${te}0"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "${YELLOW} cannot test${NORMAL}\n"
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
# generate a file with noatime, len >= 1
|
|
$CMD 2>"$te"
|
|
if [ $? -ne 0 ]; then # command failed
|
|
$PRINTF "${YELLOW}impotent file system?${NORMAL}\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
sleep 1
|
|
# generate a reference file
|
|
touch "${tf}2"
|
|
sleep 1
|
|
# read from the first file
|
|
cat "${tf}1" >/dev/null
|
|
# check which file has a later atime stamp
|
|
#if [ $(ls -ltu "${tf}1" "${tf}2" |head -n 1 |awk '{print($8);}') != "${tf}2" ];
|
|
if [ $(ls -ltu "${tf}1" "${tf}2" |head -n 1 |sed "s|.*\\($td.*\\)|\1|g") != "${tf}2" ];
|
|
then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "$te"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi # not impotent
|
|
fi # can test
|
|
fi ;; # not feats
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=COOLWRITE
|
|
case "$TESTS" in
|
|
*%functions%*|*%timeout%*|*%ignoreeof%*|*%$NAME%*)
|
|
TEST="$NAME: option cool-write"
|
|
if ! testoptions cool-write >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}option cool-write not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
#set -vx
|
|
ti="$td/test$N.file"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date) $RANDOM"
|
|
# a reader that will terminate after 1 byte
|
|
CMD1="$SOCAT $opts -u pipe:\"$ti\",readbytes=1 /dev/null"
|
|
CMD="$SOCAT $opts -u - file:\"$ti\",cool-write"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" &
|
|
bg=$! # background process id
|
|
sleep 1
|
|
(echo .; sleep 1; echo) |$CMD 2>"$te"
|
|
rc=$?
|
|
kill $bg 2>/dev/null; wait
|
|
if [ $rc -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD &"
|
|
cat "$te"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "$te"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi # testoptions
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=TCP4ENDCLOSE
|
|
case "$TESTS" in
|
|
*%functions%*|*%ip4%*|*%ipapp%*|*%tcp%*|*%$NAME%*)
|
|
TEST="$NAME: end-close keeps TCP V4 socket open"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
p1=$PORT; PORT=$((PORT+1))
|
|
p2=$PORT
|
|
da1a="$(date) $RANDOM"
|
|
da1b="$(date) $RANDOM"
|
|
CMD1="$SOCAT $opts -u - TCP4-CONNECT:$LOCALHOST:$p1"
|
|
CMD="$SOCAT $opts -U TCP4:$LOCALHOST:$p2,end-close TCP4-LISTEN:$p1,bind=$LOCALHOST,reuseaddr,fork"
|
|
CMD3="$SOCAT $opts -u TCP4-LISTEN:$p2,reuseaddr,bind=$LOCALHOST -"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD3 >"$tf" 2>"${te}3" &
|
|
pid3=$!
|
|
waittcp4port $p2 1
|
|
$CMD 2>"${te}2" &
|
|
pid2=$!
|
|
waittcp4port $p1 1
|
|
echo "$da1a" |$CMD1 2>>"${te}1a"
|
|
echo "$da1b" |$CMD1 2>>"${te}1b"
|
|
sleep 1
|
|
kill "$pid3" "$pid2" 2>/dev/null
|
|
wait
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1a" "${te}1b" "${te}2" "${te}3"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo -e "$da1a\n$da1b" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
cat "${te}1a" "${te}1b" "${te}2" "${te}3"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1a" "${te}1b" "${te}2" "${te}3"; fi
|
|
numOK=$((numOK+1))
|
|
fi ;;
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=EXECENDCLOSE
|
|
case "$TESTS" in
|
|
*%functions%*|*%exec%*|*%$NAME%*)
|
|
TEST="$NAME: end-close keeps EXEC child running"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
ts="$td/test$N.sock"
|
|
tdiff="$td/test$N.diff"
|
|
da1a="$(date) $RANDOM"
|
|
da1b="$(date) $RANDOM"
|
|
CMD1="$SOCAT $opts - UNIX-CONNECT:$ts"
|
|
CMD="$SOCAT -t0.1 $opts EXEC:"$CAT",end-close UNIX-LISTEN:$ts,fork"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD 2>"${te}2" &
|
|
pid2=$!
|
|
waitfile $ts 1
|
|
echo "$da1a" |$CMD1 2>>"${te}1a" >"$tf"
|
|
usleep 100000
|
|
echo "$da1b" |$CMD1 2>>"${te}1b" >>"$tf"
|
|
usleep 100000
|
|
kill "$pid2" 2>/dev/null
|
|
wait
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1a" "${te}1b" "${te}2"
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
elif ! echo -e "$da1a\n$da1b" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
cat "${te}1a" "${te}1b" "${te}2"
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1a" "${te}1b" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi ;;
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=TCP4RANGEMASK
|
|
case "$TESTS" in
|
|
*%functions%*|*%security%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%range%*|*%$NAME%*)
|
|
TEST="$NAME: security of TCP4-L with RANGE option"
|
|
if [ "$UNAME" != Linux ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}only on Linux${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
testserversec "$N" "$TEST" "$opts -s" "tcp4-l:$PORT,reuseaddr,fork,retry=1" "" "range=127.0.0.0:255.255.0.0" "tcp4:127.1.0.0:$PORT" 4 tcp $PORT 0
|
|
fi ;; # Linux
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP6LISTENBIND
|
|
# this tests for a bug in (up to) 1.5.0.0:
|
|
# with upd*-listen, the bind option supported only IPv4
|
|
case "$TESTS" in
|
|
*%functions%*|*%bugs%*|*%ip6%*|*%ipapp%*|*%udp%*|*%$NAME%*)
|
|
TEST="$NAME: UDP6-LISTEN with bind"
|
|
if ! feat=$(testaddrs udp ip6) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}UDP6 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tsl=$PORT
|
|
ts="$LOCALHOST6:$tsl"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts UDP6-LISTEN:$tsl,reuseaddr,bind=$LOCALHOST6 PIPE"
|
|
CMD2="$SOCAT $opts - UDP6:$ts"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid1=$!
|
|
waitudp6port $tsl 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
rc2=$?
|
|
kill $pid1 2>/dev/null; wait
|
|
if [ $rc2 -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1" "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # ! testaddrs
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=TCPWRAPPERS_MULTIOPTS
|
|
# this tests for a bug in 1.5.0.0 that let socat fail when more than one
|
|
# tcp-wrappers related option was specified in one address
|
|
case "$TESTS" in
|
|
*%functions%*|*%bugs%*|*%tcp%*|*%tcp4%*|*%ip4%*|*%tcpwrap%*|*%$NAME%*)
|
|
TEST="$NAME: use of multiple tcpwrapper enabling options"
|
|
if ! feat=$(testaddrs tcp ip4 libwrap) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date) $RANDOM"
|
|
ha="$td/hosts.allow"
|
|
$ECHO "test : ALL : allow" >"$ha"
|
|
CMD1="$SOCAT $opts TCP4-LISTEN:$PORT,reuseaddr,hosts-allow=$a,tcpwrap=test pipe"
|
|
CMD2="$SOCAT $opts - TCP:$LOCALHOST:$PORT"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" &
|
|
waittcp4port $PORT
|
|
echo "$da" |$CMD2 >"$tf" 2>"${te}2"
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=TCPWRAPPERS_TCP6ADDR
|
|
# this tests for a bug in 1.5.0.0 that brought false results with tcp-wrappers
|
|
# and IPv6 when
|
|
case "$TESTS" in
|
|
*%functions%*|*%bugs%*|*%tcp%*|*%tcp6%*|*%ip6%*|*%tcpwrap%*|*%$NAME%*)
|
|
TEST="$NAME: specification of TCP6 address in hosts.allow"
|
|
if ! feat=$(testaddrs tcp ip6 libwrap) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date) $RANDOM"
|
|
ha="$td/hosts.allow"
|
|
hd="$td/hosts.deny"
|
|
$ECHO "socat : [::1] : allow" >"$ha"
|
|
$ECHO "ALL : ALL : deny" >"$hd"
|
|
CMD1="$SOCAT $opts TCP6-LISTEN:$PORT,reuseaddr,tcpwrap-etc=$td pipe"
|
|
CMD2="$SOCAT $opts - TCP6:[::1]:$PORT"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" &
|
|
pid1=$!
|
|
waittcp6port $PORT
|
|
echo "$da" |$CMD2 >"$tf" 2>"${te}2"
|
|
kill $pid1 2>/dev/null; wait
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}1" "${te}2"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # feat
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=UDP4BROADCAST
|
|
case "$TESTS" in
|
|
*%functions%*|*%udp%*|*%udp4%*|*%ip4%*|*%dgram%*|*%broadcast%*|*%$NAME%*)
|
|
TEST="$NAME: UDP/IPv4 broadcast"
|
|
if [ -z "$BCADDR" ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}dont know a broadcast address${NORMAL}\n" $N
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PORT; PORT=$((PORT+1))
|
|
#ts1="$BCADDR/8:$ts1p"
|
|
ts1="$BCADDR:$ts1p"
|
|
ts2p=$PORT; PORT=$((PORT+1))
|
|
ts2="$BCIFADDR:$ts2p"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts UDP4-RECVFROM:$ts1p,reuseaddr,broadcast PIPE"
|
|
#CMD2="$SOCAT $opts - UDP4-BROADCAST:$ts1"
|
|
CMD2="$SOCAT $opts - UDP4-DATAGRAM:$ts1,broadcast"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" &
|
|
pid1="$!"
|
|
waitudp4port $ts1p 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
rc2="$?"
|
|
kill "$pid1" 2>/dev/null; wait;
|
|
if [ "$rc2" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$tut" ]; then
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
fi
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=IP4BROADCAST
|
|
# test a local broadcast of a raw IPv4 protocol.
|
|
# because we receive - in addition to the regular reply - our own broadcast,
|
|
# we use a token XXXX that is changed to YYYY in the regular reply packet.
|
|
case "$TESTS" in
|
|
*%functions%*|*%rawip%*|*%rawip4%*|*%ip4%*|*%dgram%*|*%broadcast%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: raw IPv4 broadcast"
|
|
if ! feat=$(testaddrs ip4 rawip) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}raw IP4 not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ -z "$BCADDR" ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}dont know a broadcast address${NORMAL}\n" $N
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PROTO
|
|
#ts1="$BCADDR/8:$ts1p"
|
|
ts1="$BCADDR:$ts1p"
|
|
ts2p=$ts1p
|
|
ts2="$BCIFADDR"
|
|
da="$(date) $RANDOM XXXX"
|
|
sh="$td/test$N-sed.sh"
|
|
echo 'sed s/XXXX/YYYY/' >"$sh"
|
|
chmod a+x "$sh"
|
|
CMD1="$SOCAT $opts IP4-RECVFROM:$ts1p,reuseaddr,broadcast exec:$sh"
|
|
#CMD2="$SOCAT $opts - IP4-BROADCAST:$ts1"
|
|
CMD2="$SOCAT $opts - IP4-DATAGRAM:$ts1,broadcast"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" &
|
|
pid1="$!"
|
|
waitip4port $ts1p 1
|
|
echo "$da" |$CMD2 2>>"${te}2" |grep -v XXXX >>"$tf"
|
|
rc2="$?"
|
|
kill "$pid1" 2>/dev/null; wait;
|
|
if [ "$rc2" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" | sed 's/XXXX/YYYY/'|diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # not feats, not root
|
|
esac
|
|
PROTO=$((PROTO+1))
|
|
N=$((N+1))
|
|
|
|
|
|
#NAME=UDP4BROADCAST_RANGE
|
|
#case "$TESTS" in
|
|
#*%functions%*|*%security%*|*%udp%*|*%udp4%*|*%ip4%*|*%dgram%*|*%broadcast%*|*%range%*|*%$NAME%*)
|
|
#TEST="$NAME: security of UDP4-BROADCAST with RANGE option"
|
|
#if [ -z "$BCADDR" ]; then
|
|
# $PRINTF "test $F_n $TEST... ${YELLOW}dont know a broadcast address${NORMAL}\n" $N
|
|
#else
|
|
#testserversec "$N" "$TEST" "$opts -s" "UDP4-BROADCAST:$BCADDR/8:$PORT" "" "range=127.1.0.0:255.255.0.0" "udp4:127.1.0.0:$PORT" 4 udp $PORT 0
|
|
#fi ;; # feats
|
|
#esac
|
|
#PORT=$((PORT+1))
|
|
#N=$((N+1))
|
|
|
|
|
|
NAME=UDP4MULTICAST_UNIDIR
|
|
case "$TESTS" in
|
|
*%functions%*|*%udp%*|*%udp4%*|*%ip4%*|*%dgram%*|*%multicast%*|*%$NAME%*)
|
|
TEST="$NAME: UDP/IPv4 multicast, send only"
|
|
if ! feat=$(testaddrs ip4 udp) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PORT; PORT=$((PORT+1))
|
|
ts1a="$SECONDADDR"
|
|
ts1="$ts1a:$ts1p"
|
|
da=$(date)
|
|
CMD1="$SOCAT -u $opts UDP4-RECV:$ts1p,reuseaddr,ip-add-membership=224.255.255.254:$ts1a -"
|
|
CMD2="$SOCAT -u $opts - UDP4-SENDTO:224.255.255.254:$ts1p,bind=$ts1a"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" >"${tf}" &
|
|
pid1="$!"
|
|
waitudp4port $ts1p 1
|
|
echo "$da" |$CMD2 2>>"${te}2"
|
|
rc2="$?"
|
|
usleep $MICROS
|
|
kill "$pid1" 2>/dev/null; wait;
|
|
if [ "$rc2" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # not feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=IP4MULTICAST_UNIDIR
|
|
case "$TESTS" in
|
|
*%functions%*|*%rawip%*|*%ip4%*|*%dgram%*|*%multicast%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: IPv4 multicast"
|
|
if ! feat=$(testaddrs ip4 rawip) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PROTO
|
|
ts1a="$SECONDADDR"
|
|
ts1="$ts1a:$ts1p"
|
|
da=$(date)
|
|
CMD1="$SOCAT -u $opts IP4-RECV:$ts1p,reuseaddr,ip-add-membership=224.255.255.254:$ts1a -"
|
|
CMD2="$SOCAT -u $opts - IP4-SENDTO:224.255.255.254:$ts1p,bind=$ts1a"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" >"${tf}" &
|
|
pid1="$!"
|
|
waitip4proto $ts1p 1
|
|
usleep $MICROS
|
|
echo "$da" |$CMD2 2>>"${te}2"
|
|
rc2="$?"
|
|
usleep $MICROS
|
|
kill "$pid1" 2>/dev/null; wait;
|
|
if [ "$rc2" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # not feats, not root
|
|
esac
|
|
PROTO=$((PROTO+1))
|
|
N=$((N+1))
|
|
|
|
if false; then
|
|
NAME=UDP6MULTICAST_UNIDIR
|
|
case "$TESTS" in
|
|
*%functions%*|*%udp%*|*%udp6%*|*%ip6%*|*%dgram%*|*%multicast%*|*%$NAME%*)
|
|
TEST="$NAME: UDP/IPv6 multicast"
|
|
if ! feat=$(testaddrs ip6 udp) || ! runsip6 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PORT; PORT=$((PORT+1))
|
|
if1="$MCINTERFACE"
|
|
ts1a="[::1]"
|
|
da=$(date)
|
|
CMD1="$SOCAT -u $opts UDP6-RECV:$ts1p,reuseaddr,ipv6-join-group=[ff02::2]:$if1 -"
|
|
CMD2="$SOCAT -u $opts - UDP6-SENDTO:[ff02::2]:$ts1p,bind=$ts1a"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" >"${tf}" &
|
|
pid1="$!"
|
|
waitudp6port $ts1p 1
|
|
echo "$da" |$CMD2 2>>"${te}2"
|
|
rc2="$?"
|
|
usleep $MICROS
|
|
kill "$pid1" 2>/dev/null; wait;
|
|
if [ "$rc2" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # not feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
fi # false
|
|
|
|
NAME=UDP4MULTICAST_BIDIR
|
|
case "$TESTS" in
|
|
*%functions%*|*%udp%*|*%udp4%*|*%ip4%*|*%dgram%*|*%multicast%*|*%$NAME%*)
|
|
TEST="$NAME: UDP/IPv4 multicast, with reply"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PORT; PORT=$((PORT+1))
|
|
ts1a="$SECONDADDR"
|
|
ts1="$ts1a:$ts1p"
|
|
ts2p=$PORT; PORT=$((PORT+1))
|
|
ts2="$BCIFADDR:$ts2p"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts UDP4-RECVFROM:$ts1p,reuseaddr,ip-add-membership=224.255.255.254:$ts1a PIPE"
|
|
#CMD2="$SOCAT $opts - UDP4-MULTICAST:224.255.255.254:$ts1p,bind=$ts1a"
|
|
CMD2="$SOCAT $opts - UDP4-DATAGRAM:224.255.255.254:$ts1p,bind=$ts1a"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" &
|
|
pid1="$!"
|
|
waitudp4port $ts1p 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
rc2="$?"
|
|
kill "$pid1" 2>/dev/null; wait;
|
|
if [ "$rc2" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$tut" ]; then
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
fi
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi ;;
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
NAME=IP4MULTICAST_BIDIR
|
|
case "$TESTS" in
|
|
*%functions%*|*%rawip%*|*%ip4%*|*%dgram%*|*%multicast%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: IPv4 multicast, with reply"
|
|
if ! feat=$(testaddrs ip4 rawip) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1p=$PROTO
|
|
ts1a="$SECONDADDR"
|
|
ts1="$ts1a:$ts1p"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts IP4-RECVFROM:$ts1p,reuseaddr,ip-add-membership=224.255.255.254:$ts1a PIPE"
|
|
#CMD2="$SOCAT $opts - IP4-MULTICAST:224.255.255.254:$ts1p,bind=$ts1a"
|
|
CMD2="$SOCAT $opts - IP4-DATAGRAM:224.255.255.254:$ts1p,bind=$ts1a"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD1 2>"${te}1" &
|
|
pid1="$!"
|
|
waitip4port $ts1p 1
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
rc2="$?"
|
|
kill "$pid1" 2>/dev/null; wait;
|
|
if [ "$rc2" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$tut" ]; then
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
fi
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # not feats, not root
|
|
esac
|
|
PROTO=$((PROTO+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=TUNREAD
|
|
case "$TESTS" in
|
|
*%functions%*|*%tun%*|*%root%*|*%$NAME%*)
|
|
TEST="$NAME: reading data sent through tun interface"
|
|
#idea: create a TUN interface and send a datagram to one of the addresses of
|
|
# its virtual network. On the tunnel side, read the packet and compare its last
|
|
# bytes with the datagram payload
|
|
if ! feat=$(testaddrs ip4 tun) || ! runsip4 >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
elif [ $(id -u) -ne 0 -a "$withroot" -eq 0 ]; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}must be root${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
tl="$td/test$N.lock"
|
|
da="$(date) $RANDOM"
|
|
dalen=$((${#da}+1))
|
|
TUNNET=10.255.255
|
|
CMD1="$SOCAT $opts -u - UDP4-SENDTO:$TUNNET.2:$PORT"
|
|
#CMD="$SOCAT $opts -u -L $tl TUN,ifaddr=$TUNNET.1,netmask=255.255.255.0,iff-up=1 -"
|
|
CMD="$SOCAT $opts -u -L $tl TUN:$TUNNET.1/24,iff-up=1 -"
|
|
printf "test $F_n $TEST... " $N
|
|
$CMD 2>"${te}" |tail --bytes=$dalen >"${tf}" &
|
|
sleep 1
|
|
echo "$da" |$CMD1 2>"${te}1"
|
|
sleep 1
|
|
kill "$(cat $tl)" 2>/dev/null
|
|
wait
|
|
if [ $? -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD &"
|
|
echo "$CMD1"
|
|
cat "${te}" "${te}1"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
cat "${te}" "${te}1"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat "${te}" "${te}1"; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # not feats, not root
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=ABSTRACTSTREAM
|
|
case "$TESTS" in
|
|
*%functions%*|*%unix%*|*%abstract%*|*%connect%*|*%listen%*|*%$NAME%*)
|
|
TEST="$NAME: abstract UNIX stream socket, listen and connect"
|
|
if ! feat=$(testaddrs abstract-unixsocket); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ts="$td/test$N.socket"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
da1="test$N $(date) $RANDOM"
|
|
#establish a listening abstract unix socket
|
|
SRV="$SOCAT $opts -lpserver ABSTRACT-LISTEN:\"$ts\" PIPE"
|
|
#make a connection
|
|
CMD="$SOCAT $opts - ABSTRACT-CONNECT:$ts"
|
|
$PRINTF "test $F_n $TEST... " $N
|
|
touch "$ts" # make a file with same name, so non-abstract fails
|
|
eval "$SRV 2>${te}s &"
|
|
pids=$!
|
|
#waitfile "$ts"
|
|
echo "$da1" |eval "$CMD" >"${tf}1" 2>"${te}1"
|
|
if [ $? -ne 0 ]; then
|
|
kill "$pids" 2>/dev/null
|
|
$PRINTF "$FAILED:\n"
|
|
echo "$SRV &"
|
|
cat "${te}s"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da1" |diff - "${tf}1" >"$tdiff"; then
|
|
kill "$pids" 2>/dev/null
|
|
$PRINTF "$FAILED:\n"
|
|
echo "$SRV &"
|
|
cat "${te}s"
|
|
echo "$CMD"
|
|
cat "${te}1"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi # !(rc -ne 0)
|
|
wait
|
|
fi ;; # not feats
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=ABSTRACTDGRAM
|
|
case "$TESTS" in
|
|
*%functions%*|*%unix%*|*%abstract%*|*%dgram%*|*%$NAME%*)
|
|
TEST="$NAME: abstract UNIX datagram"
|
|
if ! feat=$(testaddrs abstract-unixsocket); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1="$td/test$N.socket1"
|
|
ts2="$td/test$N.socket2"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts ABSTRACT-RECVFROM:$ts1,reuseaddr PIPE"
|
|
#CMD2="$SOCAT $opts - ABSTRACT-SENDTO:$ts1,bind=$ts2"
|
|
CMD2="$SOCAT $opts - ABSTRACT-SENDTO:$ts1,bind=$ts2"
|
|
printf "test $F_n $TEST... " $N
|
|
touch "$ts1" # make a file with same name, so non-abstract fails
|
|
$CMD1 2>"${te}1" &
|
|
pid1="$!"
|
|
echo "$da" |$CMD2 >>"$tf" 2>>"${te}2"
|
|
rc2=$?
|
|
kill "$pid1" 2>/dev/null; wait
|
|
if [ $rc2 -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
cat "${te}1"
|
|
echo "$CMD2"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # not feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=ABSTRACTRECV
|
|
case "$TESTS" in
|
|
*%functions%*|*%unix%*|*%abstract%*|*%dgram%*|*%recv%*|*%$NAME%*)
|
|
TEST="$NAME: abstract UNIX datagram receive"
|
|
if ! feat=$(testaddrs abstract-unixsocket); then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$feat not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
ts="$td/test$N.socket"
|
|
tf="$td/test$N.stdout"
|
|
te="$td/test$N.stderr"
|
|
tdiff="$td/test$N.diff"
|
|
ts1="$ts"
|
|
da=$(date)
|
|
CMD1="$SOCAT $opts -u ABSTRACT-RECV:$ts1,reuseaddr -"
|
|
CMD2="$SOCAT $opts -u - ABSTRACT-SENDTO:$ts1"
|
|
printf "test $F_n $TEST... " $N
|
|
touch "$ts1" # make a file with same name, so non-abstract fails
|
|
$CMD1 >"$tf" 2>"${te}1" &
|
|
pid1="$!"
|
|
#waitfile $ts1 1
|
|
echo "$da" |$CMD2 2>>"${te}2"
|
|
rc2="$?"
|
|
i=0; while [ ! -s "$tf" -a "$i" -lt 10 ]; do usleep 100000; i=$((i+1)); done
|
|
kill "$pid1" 2>/dev/null; wait
|
|
if [ "$rc2" -ne 0 ]; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1 &"
|
|
echo "$CMD2"
|
|
cat "${te}1"
|
|
cat "${te}2"
|
|
numFAIL=$((numFAIL+1))
|
|
elif ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED\n"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi ;; # not feats
|
|
esac
|
|
PORT=$((PORT+1))
|
|
N=$((N+1))
|
|
|
|
|
|
NAME=OPENSSLREAD
|
|
# socat determined availability of data using select(). With openssl, the
|
|
# following situation might occur:
|
|
# a SSL data block with more than 8192 bytes (socat defaults blocksize)
|
|
# arrives; socat calls SSL_read, and the SSL routine reads the complete block.
|
|
# socat then reads 8192 bytes from the SSL layer, the rest remains buffered.
|
|
# If the TCP connection stays idle for some time, the data in the SSL layer
|
|
# keeps there and is not transferred by socat until the socket indicates more
|
|
# data or EOF.
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: socat handles data buffered by openssl"
|
|
#idea: have a socat process (server) that gets an SSL block that is larger than
|
|
# socat transfer block size; keep the socket connection open and kill the
|
|
# server process after a short time; if not the whole data block has been
|
|
# transferred, the test has failed.
|
|
if ! feat=$(testaddrs openssl) >/dev/null; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$(echo $feat| tr 'a-z' 'A-Z') not available${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tf="$td/test$N.out"
|
|
te="$td/test$N.err"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date) $RANDOM"
|
|
SRVCERT=testsrv
|
|
gentestcert "$SRVCERT"
|
|
CMD1="$SOCAT $opts -u -T 1 -b $($ECHO "$da\c" |wc -c) OPENSSL-LISTEN:$PORT,reuseaddr,cert=$SRVCERT.pem,verify=0 -"
|
|
CMD2="$SOCAT $opts -u - OPENSSL-CONNECT:$LOCALHOST:$PORT,verify=0"
|
|
printf "test $F_n $TEST... " $N
|
|
#
|
|
$CMD1 2>"${te}1" >"$tf" &
|
|
pid=$! # background process id
|
|
(echo "$da"; sleep 2) |$CMD2 2>"${te}2"
|
|
if ! echo "$da" |diff - "$tf" >"$tdiff"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD1"
|
|
cat "${te}1"
|
|
echo "$CMD2"
|
|
cat "${te}2"
|
|
cat "$tdiff"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
# test: there is a bug with the readbytes option: when the socket delivered
|
|
# exacly that many bytes as specified with readbytes and the stays idle (no
|
|
# more data, no EOF), socat waits for more data instead of generating EOF on
|
|
# this in put stream.
|
|
NAME=READBYTES_EOF
|
|
#set -vx
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: trigger EOF after that many bytes, even when socket idle"
|
|
#idea: we deliver that many bytes to socat; the process should terminate then.
|
|
# we try to transfer data in the other direction then; if transfer succeeds,
|
|
# the process did not terminate and the bug is still there.
|
|
if false; then
|
|
$PRINTF "test $F_n $TEST... ${YELLOW}$(echo $feat| tr 'a-z' 'A-Z') not avail
|
|
able${NORMAL}\n" $N
|
|
numCANT=$((numCANT+1))
|
|
else
|
|
tr="$td/test$N.ref"
|
|
ti="$td/test$N.in"
|
|
to="$td/test$N.out"
|
|
te="$td/test$N.err"
|
|
tdiff="$td/test$N.diff"
|
|
da="$(date)" da="$da$($ECHO '\r')"
|
|
CMD="$SOCAT $opts system:\"echo A; sleep 2\",readbytes=2!!- -!!/dev/null"
|
|
printf "test $F_n $TEST... " $N
|
|
(sleep 1; echo) |eval "$CMD" >"$to" 2>"$te"
|
|
if test -s "$to"; then
|
|
$PRINTF "$FAILED: $SOCAT:\n"
|
|
echo "$CMD"
|
|
numFAIL=$((numFAIL+1))
|
|
else
|
|
$PRINTF "$OK\n"
|
|
if [ -n "$debug" ]; then cat $te; fi
|
|
numOK=$((numOK+1))
|
|
fi
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
echo "summary: $((N-1)) tests; $numOK ok, $numFAIL failed, $numCANT could not be performed"
|
|
|
|
if [ "$numFAIL" -gt 0 ]; then
|
|
exit 1
|
|
fi
|
|
exit 0
|
|
|
|
#==============================================================================
|
|
|
|
rm -f testsrv.* testcli.* testsrvdsa* testsrvfips* testclifips*
|
|
|
|
# end
|
|
|
|
# too dangerous - run as root and having a shell problem, it might purge your
|
|
# file systems
|
|
#rm -r "$td"
|
|
|
|
# sometimes subprocesses hang; we want to see this
|
|
wait
|
|
|
|
exit
|
|
|
|
# template
|
|
NAME=!!!
|
|
case "$TESTS" in
|
|
*%functions%*|*%$NAME%*)
|
|
TEST="$NAME: !!!"
|
|
printf "test $F_n $TEST... " $N
|
|
!!!
|
|
if [ !!! ]; then
|
|
$PRINTF "$OK\n"
|
|
else
|
|
$PRINTF "$FAILED\n"
|
|
cat "$te"
|
|
fi
|
|
esac
|
|
N=$((N+1))
|
|
|
|
|
|
TEST="$NAME: transferring from one file to another with echo"
|
|
tf1="$td/file$N.input"
|
|
tf2="$td/file$N.output"
|
|
testecho "$N" "$TEST" "" "echo" "$opts"
|
|
|
|
|
|
# MANUAL TESTS
|
|
|
|
# ZOMBIES
|
|
# have httpd on PORT/tcp
|
|
# nice -20 $SOCAT -d tcp-l:24080,fork tcp:$LOCALHOST:PORT
|
|
# i=0; while [ $i -lt 100 ]; do $ECHO 'GET / HTTP/1.0\n' |$SOCAT -t -,ignoreeof tcp:$LOCALHOST:24080 >/dev/null& i=$((i+1)); done
|