robsd-exec: timeout 3600s
+ . /usr/local/libexec/robsd/util-regress.sh
+ config_load
+ << "EOF" 
+ _err=0
+ _env=REGRESS_FAIL_EARLY=no
+ config_value regress-usr.bin/nc-env
+ 2> /dev/null 
+ _env=REGRESS_FAIL_EARLY=no GOCACHE=/tmp
+ _make=make -C /home/src/regress/usr.bin/nc REGRESS_FAIL_EARLY=no GOCACHE=/tmp
+ config_value regress-usr.bin/nc-targets
+ regress_root usr.bin/nc
+ export SUDO
+ unpriv -c staff build exec make -C /home/src/regress/usr.bin/nc REGRESS_FAIL_EARLY=no GOCACHE=/tmp regress
==== run-tcp ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep: server.err: No such file or directory
Listening on 127.0.0.1 7097
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection to 127.0.0.1 7097 port [tcp/*] succeeded!
Connection received on 127.0.0.1 38658
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 7097
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 38658
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 7097 port [tcp/*] succeeded!

==== run-tcp6 ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -n -v -l ::1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on ::1 35050
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -n -v ::1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on ::1 23671
Connection to ::1 35050 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on ::1 ' server.err
Listening on ::1 35050
grep 'Connection received on ::1 ' server.err
Connection received on ::1 23671
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 35050 port [tcp/*] succeeded!

==== run-tcp-localhost-server ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -4 -v -l localhost 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on localhost 40219
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection to 127.0.0.1 40219 port [tcp/*] succeeded!
Connection received on localhost 15863
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on localhost ' server.err
Listening on localhost 40219
grep 'Connection received on localhost ' server.err
Connection received on localhost 15863
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 40219 port [tcp/*] succeeded!

==== run-tcp6-localhost-server ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -6 -v -l localhost 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on localhost 8681
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -n -v ::1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection to ::1 8681 port [tcp/*] succeeded!
Connection received on localhost 32766
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on localhost ' server.err
Listening on localhost 8681
grep 'Connection received on localhost ' server.err
Connection received on localhost 32766
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 8681 port [tcp/*] succeeded!

==== run-tcp-localhost-client ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 8954
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -4 -v localhost `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on 127.0.0.1 37478
grep: client.err: No such file or directory
Connection to localhost (127.0.0.1) 8954 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 8954
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 37478
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 8954 port [tcp/*] succeeded!

==== run-tcp6-localhost-client ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -n -v -l ::1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on ::1 24550
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -6 -v localhost `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on ::1 17164
Connection to localhost (::1) 24550 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on ::1 ' server.err
Listening on ::1 24550
grep 'Connection received on ::1 ' server.err
Connection received on ::1 17164
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (::1) 24550 port [tcp/*] succeeded!

==== run-tcp-bad-localhost-server ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
! ./netcat-regress -4 -v -l ::1 0 >server.out 2>server.err
grep 'non-recoverable failure in name resolution' server.err
netcat-regress: getaddrinfo: non-recoverable failure in name resolution

==== run-tcp6-bad-localhost-server ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
! ./netcat-regress -6 -v -l 127.0.0.0 0 >server.out 2>server.err
grep 'no address associated with name' server.err
netcat-regress: getaddrinfo: no address associated with name

==== run-tcp-bad-localhost-client ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 35282
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
! ./netcat-regress -4 -v ::1 `cat server.port` >client.out 2>client.err
grep 'non-recoverable failure in name resolution' client.err
netcat-regress: getaddrinfo for host "::1" port 35282: non-recoverable failure in name resolution

==== run-tcp6-bad-localhost-client ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 13090
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
! ./netcat-regress -6 -v 127.0.0.1 `cat server.port` >client.out 2>client.err
grep 'no address associated with name' client.err
netcat-regress: getaddrinfo for host "127.0.0.1" port 13090: no address associated with name

==== run-tcp-sleep ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 14675
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on 127.0.0.1 6811
Connection to 127.0.0.1 14675 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 14675
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 6811
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 14675 port [tcp/*] succeeded!
# netcat waits for the other side to terminate, check it is sleeping
let timeout=`date +%s`+5;  while ps -xww -o comm,stat | grep -q 'netcat-regress .*R';  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
ps -xww -o comm,stat,args | grep '^netcat-regress .*S.* -v -l 127'
netcat-regress          Sp     ./netcat-regress -n -v -l 127.0.0.1 0
ps -xww -o comm,stat,args | grep '^netcat-regress .*S.* -v 127'
netcat-regress          Sp     ./netcat-regress -n -v 127.0.0.1 14675

==== run-tcp-keep ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -k -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 39263
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on 127.0.0.1 17232
Connection to 127.0.0.1 39263 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 39263
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 17232
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 39263 port [tcp/*] succeeded!
# kill client and reconnect with a new one
:> server.err
pkill -l -f "^./netcat-regress .* 127.0.0.1 `cat server.port`$"
96048 netcat-regress
Listening on 127.0.0.1 25163
rm -f client.{out,err}
:> server.out
# server closes the listen socket and binds a new one with new port
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on 127.0.0.1 14737
Connection to 127.0.0.1 25163 port [tcp/*] succeeded!
# server sends only one greeting, do not wait for a second one
let timeout=`date +%s`+5;  until grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
! grep 'greeting' client.out
# truncation of log results in NUL bytes, do not match ^
grep 'command$' server.out
Binary file server.out matches
grep 'Listening on 127.0.0.1 ' server.err
Binary file server.err matches
grep 'Connection received on 127.0.0.1 ' server.err
Binary file server.err matches
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 25163 port [tcp/*] succeeded!

==== run-tls ====
openssl req -batch -new  -subj /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1/  -nodes -newkey rsa -keyout 127.0.0.1.key -x509 -out 127.0.0.1.crt
Generating a 2048 bit RSA private key
.
........................................................
writing new private key to '127.0.0.1.key'
-----
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -c -C 127.0.0.1.crt -K 127.0.0.1.key -n -v -l 127.0.0.1 0  2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 16291
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -c -R 127.0.0.1.crt -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on 127.0.0.1 8318
Connection to 127.0.0.1 16291 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Valid From: Tue Nov 12 03:00:31 2024
Valid Until: Thu Dec 12 03:00:31 2024
Cert Hash: SHA256:06b6e2c109030d668303ef35d6ece9f864250692b43b055c6bee4a2af3c01870
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 16291
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 8318
# XXX success message should be issued after TLS handshake
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 16291 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=127.0.0.1' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
grep 'Issuer: .*/OU=server/CN=127.0.0.1' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1

==== run-tls6 ====
openssl req -batch -new  -subj /L=OpenBSD/O=netcat-regress/OU=server/CN=::1/  -nodes -newkey rsa -keyout 1.key -x509 -out 1.crt
Generating a 2048 bit RSA private key
..................
................
writing new private key to '1.key'
-----
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -c -C 1.crt -K 1.key -n -v -l ::1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on ::1 42980
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -c -R 1.crt -n -v ::1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on ::1 46157
Connection to ::1 42980 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host ::1
Peer name: ::1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=::1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=::1
Valid From: Tue Nov 12 03:00:32 2024
Valid Until: Thu Dec 12 03:00:32 2024
Cert Hash: SHA256:18fc639e4afe2a2bb5b0bd5901da063a30dda8ad455617d940ec28058758ce20
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on ::1 ' server.err
Listening on ::1 42980
grep 'Connection received on ::1 ' server.err
Connection received on ::1 46157
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 42980 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=::1' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=::1
grep 'Issuer: .*/OU=server/CN=::1' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=::1

==== run-tls-localhost ====
openssl req -batch -new  -subj /L=OpenBSD/O=netcat-regress/OU=ca/CN=root/  -nodes -newkey rsa -keyout ca.key -x509 -out ca.crt
Generating a 2048 bit RSA private key
....................
.........................................
writing new private key to 'ca.key'
-----
openssl req -batch -new  -subj /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost/  -nodes -newkey rsa -keyout server.key -out server.req
Generating a 2048 bit RSA private key
........................
.....
writing new private key to 'server.key'
-----
openssl x509 -CAcreateserial -CAkey ca.key -CA ca.crt  -req -in server.req -out server.crt
Signature ok
subject=/L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -c -C server.crt -K server.key -v -l localhost 0  2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on localhost 2944
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -c -R ca.crt -v localhost `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on localhost 29758
Connection to localhost (127.0.0.1) 2944 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 12 03:00:33 2024
Valid Until: Thu Dec 12 03:00:33 2024
Cert Hash: SHA256:ccbab9ccb0da5eb39f890464d44fb02b7ad4f8f0bb0788eb31094fde22f74c68
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on localhost ' server.err
Listening on localhost 2944
grep 'Connection received on localhost ' server.err
Connection received on localhost 29758
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 2944 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=localhost' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root

==== run-tls-bad-ca ====
openssl req -batch -new  -subj /L=OpenBSD/O=netcat-regress/OU=ca/CN=root/  -nodes -newkey rsa -keyout fake-ca.key -x509 -out fake-ca.crt
Generating a 2048 bit RSA private key
.
...................
writing new private key to 'fake-ca.key'
-----
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -c -C server.crt -K server.key -v -l localhost 0  2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on localhost 30598
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# the client uses the wrong root ca to verify the server cert
! ./netcat-regress -c -R fake-ca.crt -v localhost `cat server.port` >client.out 2>client.err
Connection received on localhost 2850
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
netcat-regress: tls handshake failed (handshake failed: error:02FFF020:system library:func(4095):Broken pipe)
grep 'Listening on localhost ' server.err
Listening on localhost 30598
grep 'Connection received on localhost ' server.err
Connection received on localhost 2850
grep 'certificate verification failed' client.err
netcat-regress: tls handshake failed (certificate verification failed: certificate signature failure)
! grep 'greeting' client.out
! grep 'command' server.out

==== run-tls-name ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -c -C server.crt -K server.key -n -v -l 127.0.0.1 0  2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 40051
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -c -e localhost -R ca.crt -n -v 127.0.0.1 `cat server.port`  2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection to 127.0.0.1 40051 port [tcp/*] succeeded!
Connection received on 127.0.0.1 47488
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host 127.0.0.1
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 12 03:00:33 2024
Valid Until: Thu Dec 12 03:00:33 2024
Cert Hash: SHA256:ccbab9ccb0da5eb39f890464d44fb02b7ad4f8f0bb0788eb31094fde22f74c68
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 40051
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 47488
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 40051 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=localhost' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root

==== run-tls-bad-name ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -c -C server.crt -K server.key -n -v -l 127.0.0.1 0  2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 34738
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# the common name in server.crt is localhost, not 127.0.0.1
! ./netcat-regress -c -e 127.0.0.1 -R ca.crt -n -v 127.0.0.1 `cat server.port` >client.out 2>client.err
Connection received on 127.0.0.1 4875
netcat-regress: tls read failed (read failed: error:02FFF036:system library:func(4095):Connection reset by peer)
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 34738
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 4875
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 34738 port [tcp/*] succeeded!
grep "name \`127.0.0.1\' not present in server certificate" client.err
netcat-regress: tls handshake failed (name `127.0.0.1' not present in server certificate)
! grep 'greeting' client.out
! grep 'command' server.out

==== run-tls-hash ====
openssl x509 -in server.crt -outform der | sha256 | sed s/^/SHA256:/ >server.hash
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -c -C server.crt -K server.key -v -l localhost 0  2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on localhost 29877
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# check that the server presents certificate with correct hash
rm -f client.err; echo command | ./netcat-regress -c -H `cat server.hash` -R ca.crt -v localhost `cat server.port`  2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on localhost 45285
Connection to localhost (127.0.0.1) 29877 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 12 03:00:33 2024
Valid Until: Thu Dec 12 03:00:33 2024
Cert Hash: SHA256:ccbab9ccb0da5eb39f890464d44fb02b7ad4f8f0bb0788eb31094fde22f74c68
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on localhost ' server.err
Listening on localhost 29877
grep 'Connection received on localhost ' server.err
Connection received on localhost 45285
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 29877 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=localhost' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
grep 'Cert Hash: SHA256:' client.err
Cert Hash: SHA256:ccbab9ccb0da5eb39f890464d44fb02b7ad4f8f0bb0788eb31094fde22f74c68

==== run-tls-bad-hash ====
openssl x509 -in ca.crt -outform der | sha256 | sed s/^/SHA256:/ >ca.hash
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -c -C server.crt -K server.key -v -l localhost 0  2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on localhost 16905
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# server presents certificate with server.hash, ca.hash is wrong
! ./netcat-regress -c -H `cat ca.hash` -R ca.crt -v localhost `cat server.port`  >client.out 2>client.err
Connection received on localhost 31701
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep 'Listening on localhost ' server.err
Listening on localhost 16905
grep 'Connection received on localhost ' server.err
Connection received on localhost 31701
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 16905 port [tcp/*] succeeded!
grep 'peer certificate is not SHA256:' client.err
netcat-regress: peer certificate is not SHA256:ddbfdcc260821c2511bc018d64cb0ecb80c3773336e4ed6b31fc50259b793d3b
! grep 'greeting' client.out
! grep 'command' server.out

==== run-tls-client ====
openssl req -batch -new  -subj /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost/  -nodes -newkey rsa -keyout client.key -out client.req
Generating a 2048 bit RSA private key
.............................
.........................................
writing new private key to 'client.key'
-----
openssl x509 -CAcreateserial -CAkey ca.key -CA ca.crt  -req -in client.req -out client.crt
Signature ok
subject=/L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# use client certificate and validate at server
rm -f server.err; echo greeting | ./netcat-regress -c -R ca.crt -C server.crt -K server.key -v -l  localhost 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on localhost 18321
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -c -R ca.crt -C client.crt -K client.key -v  localhost `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on localhost 9286
Connection to localhost (127.0.0.1) 18321 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 12 03:00:38 2024
Valid Until: Thu Dec 12 03:00:38 2024
Cert Hash: SHA256:31386378107a3a04b9ba2c8568398804a207003b94bd1d6f3cf37ae349fec26b
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 12 03:00:33 2024
Valid Until: Thu Dec 12 03:00:33 2024
Cert Hash: SHA256:ccbab9ccb0da5eb39f890464d44fb02b7ad4f8f0bb0788eb31094fde22f74c68
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on localhost ' server.err
Listening on localhost 18321
grep 'Connection received on localhost ' server.err
Connection received on localhost 9286
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 18321 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=localhost' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
grep 'Subject: .*/OU=client/CN=localhost' server.err
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' server.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root

==== run-tls-bad-client ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# require client certificate at server
rm -f server.err; echo greeting | ./netcat-regress -c -T clientcert -R ca.crt -C server.crt -K server.key  -v -l localhost 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on localhost 33384
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# client does not provide certificate
rm -f client.err; echo command | ./netcat-regress -c -R ca.crt -v localhost `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on localhost 3577
Connection to localhost (127.0.0.1) 33384 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
netcat-regress: No client certificate provided
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 12 03:00:33 2024
Valid Until: Thu Dec 12 03:00:33 2024
Cert Hash: SHA256:ccbab9ccb0da5eb39f890464d44fb02b7ad4f8f0bb0788eb31094fde22f74c68
grep 'Listening on localhost ' server.err
Listening on localhost 33384
grep 'Connection received on localhost ' server.err
Connection received on localhost 3577
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 33384 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=localhost' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
grep 'No client certificate provided' server.err
netcat-regress: No client certificate provided
! grep 'greeting' client.out
! grep 'command' server.out

==== run-tls-client-bad-ca ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# the server uses the wrong root ca to verify the client cert
rm -f server.err; echo greeting | ./netcat-regress -c -R fake-ca.crt -C server.crt -K server.key -v -l  localhost 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on localhost 16570
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
! ./netcat-regress -c -R ca.crt -C client.crt -K client.key -v  localhost `cat server.port` >client.out 2>client.err
Connection received on localhost 32067
netcat-regress: tls handshake failed (handshake failed: error:04FFF06A:rsa routines:CRYPTO_internal:block type is not 01)
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
nc localhost `cat server.port` 2>/dev/null || :
grep 'Listening on localhost ' server.err
Listening on localhost 16570
grep 'Connection received on localhost ' server.err
Connection received on localhost 32067
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 16570 port [tcp/*] succeeded!
# XXX no specific error message for bogus ca
egrep  'CRYPTO_internal:(block type is not 01|data too large for modulus)' server.err
netcat-regress: tls handshake failed (handshake failed: error:04FFF06A:rsa routines:CRYPTO_internal:block type is not 01)
! grep 'greeting' client.out
! grep 'command' server.out

==== run-tls-client-name ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# check client certificate name at server
rm -f server.err; echo greeting | ./netcat-regress -c -e localhost -R ca.crt -C server.crt -K server.key  -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 33784
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -4 -c -R ca.crt -C client.crt -K client.key -v  localhost `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on 127.0.0.1 21834
Connection to localhost (127.0.0.1) 33784 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host 127.0.0.1
Peer name: localhost
Valid From: Tue Nov 12 03:00:33 2024
Valid Until: Thu Dec 12 03:00:33 2024
Cert Hash: SHA256:ccbab9ccb0da5eb39f890464d44fb02b7ad4f8f0bb0788eb31094fde22f74c68
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 12 03:00:38 2024
Valid Until: Thu Dec 12 03:00:38 2024
Cert Hash: SHA256:31386378107a3a04b9ba2c8568398804a207003b94bd1d6f3cf37ae349fec26b
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 33784
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 21834
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 33784 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=localhost' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
grep 'Subject: .*/OU=client/CN=localhost' server.err
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' server.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root

==== run-tls-client-bad-name ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# client certificate is for localhost, check with 127.0.0.1 should fail
rm -f server.err; echo greeting | ./netcat-regress -c -e 127.0.0.1 -R ca.crt -C server.crt -K server.key  -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 38815
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# client does not see any problem, TLS handshake works, wait for exit
rm -f client.err; echo command | ./netcat-regress -4 -c -R ca.crt -C client.crt -K client.key -v  localhost `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on 127.0.0.1 15823
Connection to localhost (127.0.0.1) 38815 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 12 03:00:33 2024
Valid Until: Thu Dec 12 03:00:33 2024
Cert Hash: SHA256:ccbab9ccb0da5eb39f890464d44fb02b7ad4f8f0bb0788eb31094fde22f74c68
Valid From: Tue Nov 12 03:00:38 2024
Valid Until: Thu Dec 12 03:00:38 2024
Cert Hash: SHA256:31386378107a3a04b9ba2c8568398804a207003b94bd1d6f3cf37ae349fec26b
netcat-regress: name (127.0.0.1) not found in client cert
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 38815
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 15823
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 38815 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=localhost' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
grep 'Subject: .*/OU=client/CN=localhost' server.err
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' server.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
grep 'name (127.0.0.1) not found in client cert' server.err
netcat-regress: name (127.0.0.1) not found in client cert
! grep 'greeting' client.out
! grep 'command' server.out

==== run-tls-client-hash ====
openssl x509 -in client.crt -outform der | sha256 | sed s/^/SHA256:/ >client.hash
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# check client certificate hash at server
rm -f server.err; echo greeting | ./netcat-regress -c -H `cat client.hash` -R ca.crt  -C server.crt -K server.key -v -l localhost 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on localhost 10339
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -c -R ca.crt -C client.crt -K client.key -v  localhost `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on localhost 28960
Connection to localhost (127.0.0.1) 10339 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 12 03:00:33 2024
Valid Until: Thu Dec 12 03:00:33 2024
Cert Hash: SHA256:ccbab9ccb0da5eb39f890464d44fb02b7ad4f8f0bb0788eb31094fde22f74c68
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 12 03:00:38 2024
Valid Until: Thu Dec 12 03:00:38 2024
Cert Hash: SHA256:31386378107a3a04b9ba2c8568398804a207003b94bd1d6f3cf37ae349fec26b
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on localhost ' server.err
Listening on localhost 10339
grep 'Connection received on localhost ' server.err
Connection received on localhost 28960
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 10339 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=localhost' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
grep 'Subject: .*/OU=client/CN=localhost' server.err
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' server.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root

==== run-tls-client-bad-hash ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# client presents certificate with client.hash, ca.hash is wrong
rm -f server.err; echo greeting | ./netcat-regress -c -H `cat ca.hash` -R ca.crt  -C server.crt -K server.key -v -l localhost 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on localhost 18905
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# client does not see any problem, TLS handshake works, wait for exit
rm -f client.err; echo command | ./netcat-regress -c -R ca.crt -C client.crt -K client.key -v  localhost `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on localhost 38269
Connection to localhost (127.0.0.1) 18905 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 12 03:00:38 2024
Valid Until: Thu Dec 12 03:00:38 2024
Cert Hash: SHA256:31386378107a3a04b9ba2c8568398804a207003b94bd1d6f3cf37ae349fec26b
netcat-regress: peer certificate is not SHA256:ddbfdcc260821c2511bc018d64cb0ecb80c3773336e4ed6b31fc50259b793d3b
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 12 03:00:33 2024
Valid Until: Thu Dec 12 03:00:33 2024
Cert Hash: SHA256:ccbab9ccb0da5eb39f890464d44fb02b7ad4f8f0bb0788eb31094fde22f74c68
nc localhost `cat server.port` 2>/dev/null || :
grep 'Listening on localhost ' server.err
Listening on localhost 18905
grep 'Connection received on localhost ' server.err
Connection received on localhost 38269
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 18905 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=localhost' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
grep 'Subject: .*/OU=client/CN=localhost' server.err
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' server.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
grep 'peer certificate is not SHA256:' server.err
netcat-regress: peer certificate is not SHA256:ddbfdcc260821c2511bc018d64cb0ecb80c3773336e4ed6b31fc50259b793d3b
! grep 'greeting' client.out
! grep 'command' server.out

==== run-tls-client-no-hash ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# check client certificate hash at server if available
rm -f server.err; echo greeting | ./netcat-regress -c -H `cat client.hash` -R ca.crt  -C server.crt -K server.key -v -l localhost 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on localhost 44756
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# client provides no certificate
rm -f client.err; echo command | ./netcat-regress -c -R ca.crt -v localhost `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on localhost 8297
Connection to localhost (127.0.0.1) 44756 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 12 03:00:33 2024
Valid Until: Thu Dec 12 03:00:33 2024
Cert Hash: SHA256:ccbab9ccb0da5eb39f890464d44fb02b7ad4f8f0bb0788eb31094fde22f74c68
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
# client certificate and hash is optional, transfer is successful
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on localhost ' server.err
Listening on localhost 44756
grep 'Connection received on localhost ' server.err
Connection received on localhost 8297
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 44756 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=localhost' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
grep 'Issuer: .*/OU=ca/CN=root' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
# non existing hash is not checked
! grep 'Cert Hash: SHA256:' server.err

==== run-tls-sleep ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -c -C 127.0.0.1.crt -K 127.0.0.1.key -n -v -l 127.0.0.1 0  2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 30905
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -c -R 127.0.0.1.crt -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on 127.0.0.1 44439
Connection to 127.0.0.1 30905 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Valid From: Tue Nov 12 03:00:31 2024
Valid Until: Thu Dec 12 03:00:31 2024
Cert Hash: SHA256:06b6e2c109030d668303ef35d6ece9f864250692b43b055c6bee4a2af3c01870
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 30905
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 44439
# XXX success message should be issued after TLS handshake
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 30905 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=127.0.0.1' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
grep 'Issuer: .*/OU=server/CN=127.0.0.1' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
# netcat waits for the other side to terminate, check it is sleeping
let timeout=`date +%s`+5;  while ps -xww -o comm,stat | grep -q 'netcat-regress .*R';  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
ps -xww -o comm,stat,args | grep '^netcat-regress .*S.* -v -l 127'
netcat-regress          Sp     ./netcat-regress -c -C 127.0.0.1.crt -K 127.0.0.1.key -n -v -l 127.0.0.1 0
ps -xww -o comm,stat,args | grep '^netcat-regress .*S.* -v 127'
netcat-regress          Sp     ./netcat-regress -c -R 127.0.0.1.crt -n -v 127.0.0.1 30905

==== run-tls-keep ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -k -c -C 127.0.0.1.crt -K 127.0.0.1.key -n -v -l  127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 43335
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -c -R 127.0.0.1.crt -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on 127.0.0.1 36289
Connection to 127.0.0.1 43335 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Valid From: Tue Nov 12 03:00:31 2024
Valid Until: Thu Dec 12 03:00:31 2024
Cert Hash: SHA256:06b6e2c109030d668303ef35d6ece9f864250692b43b055c6bee4a2af3c01870
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 43335
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 36289
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 43335 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=127.0.0.1' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
grep 'Issuer: .*/OU=server/CN=127.0.0.1' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
# kill client and reconnect with a new one
:> server.err
pkill -l -f "^./netcat-regress .* 127.0.0.1 `cat server.port`$"
65506 netcat-regress
Listening on 127.0.0.1 32965
rm -f client.{out,err}
:> server.out
# server closes the listen socket and binds a new one with new port
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -c -R 127.0.0.1.crt -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on 127.0.0.1 10466
Connection to 127.0.0.1 32965 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Valid From: Tue Nov 12 03:00:31 2024
Valid Until: Thu Dec 12 03:00:31 2024
Cert Hash: SHA256:06b6e2c109030d668303ef35d6ece9f864250692b43b055c6bee4a2af3c01870
# server sends only one greeting, do not wait for a second one
let timeout=`date +%s`+5;  until grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
! grep 'greeting' client.out
# truncation of log results in NUL bytes, do not match ^
grep 'command$' server.out
Binary file server.out matches
grep 'Listening on 127.0.0.1 ' server.err
Binary file server.err matches
grep 'Connection received on 127.0.0.1 ' server.err
Binary file server.err matches
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 32965 port [tcp/*] succeeded!
grep 'Subject: .*/OU=server/CN=127.0.0.1' client.err
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
grep 'Issuer: .*/OU=server/CN=127.0.0.1' client.err
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1

==== run-udp ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -u -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Bound on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on 127.0.0.1 2226
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# the -v option would cause udptest() to write additional X
rm -f client.err; echo command | ./netcat-regress -u -n 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on 127.0.0.1 21154
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Bound on 127.0.0.1 ' server.err
Bound on 127.0.0.1 2226
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 21154

==== run-udp6 ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -u -n -v -l ::1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Bound on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on ::1 25417
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# the -v option would cause udptest() to write additional X
rm -f client.err; echo command | ./netcat-regress -u -n ::1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on ::1 47588
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Bound on ::1 ' server.err
Bound on ::1 25417
grep 'Connection received on ::1 ' server.err
Connection received on ::1 47588

==== run-udp-probe ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -u -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Bound on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on 127.0.0.1 33498
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -u -v -n 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on 127.0.0.1 3385
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Bound on 127.0.0.1 ' server.err
Bound on 127.0.0.1 33498
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 3385

==== run-udp-localhost ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -u -4 -v -l localhost 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Bound on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on localhost 36825
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# the -v option would cause udptest() to write additional X
rm -f client.err; echo command | ./netcat-regress -u -4 localhost `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on localhost 31516
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Bound on localhost ' server.err
Bound on localhost 36825
grep 'Connection received on localhost ' server.err
Connection received on localhost 31516

==== run-udp6-localhost ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -u -6 -v -l localhost 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Bound on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on localhost 2360
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# the -v option would cause udptest() to write additional X
rm -f client.err; echo command | ./netcat-regress -u -6 localhost `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on localhost 46632
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Bound on localhost ' server.err
Bound on localhost 2360
grep 'Connection received on localhost ' server.err
Connection received on localhost 46632

==== run-udp-keep ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -k -u -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Bound on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on 127.0.0.1 6773
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# the -v option causes udptest() to write additional X
rm -f client.err; echo command | ./netcat-regress -u -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
# server does not connect, nothing reaches the client
let timeout=`date +%s`+5;  until grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
! grep 'greeting' client.out
grep '^command$' server.out
command
grep 'Bound on 127.0.0.1 ' server.err
Bound on 127.0.0.1 6773
# client does not connect
! grep 'Connection received on ' server.err
# kill client and reconnect with a new one
:> server.err
pkill -l -f "^./netcat-regress .* 127.0.0.1 `cat server.port`$"
21375 netcat-regress
rm -f client.{out,err}
:> server.out
rm -f client.err; echo command | ./netcat-regress -u -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
! grep 'greeting' client.out
# truncation of log results in NUL bytes, do not match ^
grep 'command$' server.out
Binary file server.out matches
# server keeps socket and does not bind again
! grep 'Bound on ' server.err
# client does not connect
! grep 'Connection received on ' server.err

==== run-udp-sleep ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -u -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Bound on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on 127.0.0.1 46894
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# the -v option would cause udptest() to write additional X
rm -f client.err; echo command | ./netcat-regress -u -n 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on 127.0.0.1 18570
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Bound on 127.0.0.1 ' server.err
Bound on 127.0.0.1 46894
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 18570
# netcat waits for the other side to terminate, check it is sleeping
let timeout=`date +%s`+5;  while ps -xww -o comm,stat | grep -q 'netcat-regress .*R';  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
ps -xww -o comm,stat,args | grep '^netcat-regress .*S.* -v -l 127'
netcat-regress          Sp     ./netcat-regress -u -n -v -l 127.0.0.1 0
ps -xww -o comm,stat,args | grep '^netcat-regress .*S.* -n 127'
netcat-regress          Sp     ./netcat-regress -u -n 127.0.0.1 46894

==== run-unix ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.sock
rm -f server.err; echo greeting | ./netcat-regress -U -n -v -l server.sock 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on server.sock
Listening on server.sock
rm -f client.err; echo command | ./netcat-regress -U -n -v server.sock 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on server.sock
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
# XXX message Bound and Listening is redundant
grep 'Bound on server.sock$' server.err
Bound on server.sock
grep 'Listening on server.sock$' server.err
Listening on server.sock
grep 'Connection received on server.sock$' server.err
Connection received on server.sock
# XXX message succeeded is missing
! grep 'Connection to server.sock .* succeeded!' client.err

==== run-unix-namelookup ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.sock
rm -f server.err; echo greeting | ./netcat-regress -U -v -l server.sock 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on server.sock
Listening on server.sock
rm -f client.err; echo command | ./netcat-regress -U -v server.sock 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on server.sock
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
# XXX message Bound and Listening is redundant
grep 'Bound on server.sock$' server.err
Bound on server.sock
grep 'Listening on server.sock$' server.err
Listening on server.sock
grep 'Connection received on server.sock$' server.err
Connection received on server.sock
# XXX message succeeded is missing
! grep 'Connection to server.sock .* succeeded!' client.err

==== run-unix-probe ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.sock
rm -f server.err; echo greeting | ./netcat-regress -U -n -v -l server.sock 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on server.sock
Listening on server.sock
# connect and close immediately, check if socket is listening
./netcat-regress -N -U -v server.sock </dev/null >client.out 2>client.err
Connection received on server.sock
# XXX message Bound and Listening is redundant
grep 'Bound on server.sock$' server.err
Bound on server.sock
grep 'Listening on server.sock$' server.err
Listening on server.sock
grep 'Connection received on server.sock$' server.err
Connection received on server.sock
# XXX message succeeded is missing
! grep 'Connection to server.sock .* succeeded!' client.err
# server accepts one connection, second connection should be refused
! ./netcat-regress -N -U -v server.sock </dev/null >client.out 2>client.err
grep 'server.sock: Connection refused' client.err
netcat-regress: server.sock: Connection refused
# connection to non existing socket file should fail
rm server.sock
! ./netcat-regress -N -U -v server.sock </dev/null >client.out 2>client.err
grep 'server.sock: No such file or directory' client.err
netcat-regress: server.sock: No such file or directory

==== run-unix-keep ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.sock
rm -f server.err; echo greeting | ./netcat-regress -k -U -n -v -l server.sock 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on server.sock
Listening on server.sock
rm -f client.err; echo command | ./netcat-regress -U -n -v server.sock 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on server.sock
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
# XXX message Bound and Listening is redundant
grep 'Bound on server.sock$' server.err
Bound on server.sock
grep 'Listening on server.sock$' server.err
Listening on server.sock
grep 'Connection received on server.sock$' server.err
Connection received on server.sock
# XXX message succeeded is missing
! grep 'Connection to server.sock .* succeeded!' client.err
# kill client and reconnect with a new one
:> server.err
pkill -l -f "^./netcat-regress .* -v server.sock$"
94105 netcat-regress
rm -f client.{out,err}
:> server.out
rm -f client.err; echo command | ./netcat-regress -U -n -v server.sock 2>&1 >client.out | tee client.err &
# server sends only one greeting, do not wait for a second one
let timeout=`date +%s`+5;  until grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on server.sock
! grep 'greeting' client.out
# truncation of log results in NUL bytes, do not match ^
grep 'command$' server.out
Binary file server.out matches
grep 'Connection received on server.sock$' server.err
Binary file server.err matches
# XXX message succeeded is missing
! grep 'Connection to server.sock .* succeeded!' client.err

==== run-unix-dgram ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f {client,server}.sock
rm -f server.err; echo greeting | ./netcat-regress -U -u -n -v -l server.sock 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Bound on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on server.sock
rm -f client.err; echo command | ./netcat-regress -U -u -n -v server.sock 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on /tmp/nc.pLN2tG0Ra9
Connection received on server.sock
let timeout=`date +%s`+5;  until grep -q 'Bound on ' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Bound on server.sock$' server.err
Bound on server.sock
grep 'Connection received on server.sock$' server.err
Connection received on server.sock
# XXX message succeeded is missing
! grep 'Connection to server.sock .* succeeded!' client.err

==== run-unix-dgram-namelookup ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f {client,server}.sock
rm -f server.err; echo greeting | ./netcat-regress -U -u -v -l server.sock 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Bound on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on server.sock
rm -f client.err; echo command | ./netcat-regress -U -u -v server.sock 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on /tmp/nc.tyCXV3oxSK
Connection received on server.sock
let timeout=`date +%s`+5;  until grep -q 'Bound on ' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Bound on server.sock$' server.err
Bound on server.sock
grep 'Connection received on server.sock$' server.err
Connection received on server.sock
# XXX message succeeded is missing
! grep 'Connection to server.sock .* succeeded!' client.err

==== run-unix-dgram-clientsock ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f {client,server}.sock
rm -f server.err; echo greeting | ./netcat-regress -U -u -n -v -l server.sock 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Bound on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on server.sock
rm -f client.err; echo command | ./netcat-regress -U -u -n -v -s client.sock server.sock 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out && grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on client.sock
Connection received on server.sock
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Bound on server.sock$' server.err
Bound on server.sock
grep 'Connection received on server.sock$' server.err
Connection received on server.sock
# XXX message succeeded is missing
! grep 'Connection to server.sock .* succeeded!' client.err

==== run-unix-dgram-keep ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f {client,server}.sock
rm -f server.err; echo greeting | ./netcat-regress -k -U -u -n -v -l server.sock 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Bound on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on server.sock
rm -f client.err; echo command | ./netcat-regress -U -u -n -v server.sock 2>&1 >client.out | tee client.err &
# server does not connect, nothing reaches the client
let timeout=`date +%s`+5;  until grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on /tmp/nc.iQ1GAifgIv
let timeout=`date +%s`+5;  until grep -q 'Bound on ' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
! grep 'greeting' client.out
grep '^command$' server.out
command
grep 'Bound on server.sock$' server.err
Bound on server.sock
# client does not connect
! grep 'Connection received on ' server.err
# XXX message succeeded is missing
! grep 'Connection to server.sock .* succeeded!' client.err
# kill client and reconnect with a new one
:> server.err
pkill -l -f "^./netcat-regress .* -v server.sock$"
88096 netcat-regress
rm -f client.{out,err}
:> server.out
rm -f client.err; echo command | ./netcat-regress -U -u -n -v server.sock 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Bound on /tmp/nc.ZdiXzg70MO
let timeout=`date +%s`+5;  until grep -q 'Bound on ' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
! grep 'greeting' client.out
# truncation of log results in NUL bytes, do not match ^
grep 'command$' server.out
Binary file server.out matches
# server keeps socket and does not bind again
! grep 'Bound on ' server.err
# client does not connect
! grep 'Connection received on ' server.err
# XXX message succeeded is missing
! grep 'Connection to 127.0.0.1 .* succeeded!' client.err

==== run-tcp-test ====
cc -O2 -pipe  -Wall -Wpointer-arith -Wuninitialized -Wstrict-prototypes -Wmissing-prototypes -Wunused -Wsign-compare -Wshadow  -MD -MP  -c /home/src/regress/usr.bin/nc/server-tcp.c
cc -O2 -pipe  -Wall -Wpointer-arith -Wuninitialized -Wstrict-prototypes -Wmissing-prototypes -Wunused -Wsign-compare -Wshadow  -MD -MP  -c /home/src/regress/usr.bin/nc/util.c
cc   -o server-tcp server-tcp.o util.o 
cc -O2 -pipe  -Wall -Wpointer-arith -Wuninitialized -Wstrict-prototypes -Wmissing-prototypes -Wunused -Wsign-compare -Wshadow  -MD -MP  -c /home/src/regress/usr.bin/nc/client-tcp.c
cc   -o client-tcp client-tcp.o util.o 
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# test the test tools
./server-tcp -s greeting -r command 127.0.0.1 0 >server.port
sock: 127.0.0.1 26350
./client-tcp -r greeting -s command 127.0.0.1 `cat server.port` >client.port
sock: 127.0.0.1 40374
peer: 127.0.0.1 26350
peer: 127.0.0.1 40374
>>> greeting
<<< greeting
>>> command
<<< command

==== run-tcp-test-shutdown ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# test the test tools
./server-tcp -s greeting -N -r command -E 127.0.0.1 0 >server.port
sock: 127.0.0.1 16586
./client-tcp -r greeting -E -s command -N 127.0.0.1 `cat server.port` >client.port
peer: 127.0.0.1 10812
sock: 127.0.0.1 10812
peer: 127.0.0.1 16586
>>> greeting
<<< greeting
<<< EOF
>>> command
<<< command
<<< EOF

==== run-tcp-server ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 3962
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# test client read from netcat, then send line and exit
./client-tcp -r greeting -s command 127.0.0.1 `cat server.port` >client.port
Connection received on 127.0.0.1 48893
sock: 127.0.0.1 48893
peer: 127.0.0.1 3962
<<< greeting
>>> command
let timeout=`date +%s`+5;  until grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^command$' server.out
command
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 3962
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 48893

==== run-tcp-server-eof ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 27401
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# test client read from netcat, then send line, shutdown, wait for eof
./client-tcp -r greeting -s command -N -E 127.0.0.1 `cat server.port` >client.port
Connection received on 127.0.0.1 39186
sock: 127.0.0.1 39186
peer: 127.0.0.1 27401
<<< greeting
>>> command
<<< EOF
let timeout=`date +%s`+5;  until grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^command$' server.out
command
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 27401
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 39186

==== run-tcp-server-reverse-eof ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 12030
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# test client send to netcat, shutdown, then read line, wait for eof
./client-tcp -s command -N -r greeting -E 127.0.0.1 `cat server.port` >client.port
Connection received on 127.0.0.1 18711
sock: 127.0.0.1 18711
peer: 127.0.0.1 12030
>>> command
<<< greeting
<<< EOF
let timeout=`date +%s`+5;  until grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^command$' server.out
command
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 12030
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 18711

==== run-tcp-server-shutdown-eof ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# netcat calls shutdown on output after EOF on input
rm -f server.err; echo greeting | ./netcat-regress -N -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep: server.err: No such file or directory
Listening on 127.0.0.1 43123
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# test client read from netcat, then send line, wait for eof, shutdown
./client-tcp -r greeting -s command -E -N 127.0.0.1 `cat server.port` >client.port
Connection received on 127.0.0.1 13759
sock: 127.0.0.1 13759
peer: 127.0.0.1 43123
<<< greeting
>>> command
<<< EOF
let timeout=`date +%s`+5;  until grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^command$' server.out
command
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 43123
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 13759

==== run-tcp-server-shutdown-reverse-eof ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# netcat calls shutdown on output after EOF on input
rm -f server.err; echo greeting | ./netcat-regress -N -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 2580
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
# test client send to netcat, shutdown, then read line, wait for eof
./client-tcp -s command -N -r greeting -E 127.0.0.1 `cat server.port` >client.port
Connection received on 127.0.0.1 8696
sock: 127.0.0.1 8696
peer: 127.0.0.1 2580
>>> command
<<< greeting
<<< EOF
let timeout=`date +%s`+5;  until grep -q 'command' server.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^command$' server.out
command
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 2580
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 8696

==== run-tcp-client ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# test server send to netcat, then read line and exit
./server-tcp -s greeting -r command 127.0.0.1 0 >server.port
sock: 127.0.0.1 36217
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection to 127.0.0.1 36217 port [tcp/*] succeeded!
peer: 127.0.0.1 38607
>>> greeting
<<< command
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 36217 port [tcp/*] succeeded!

==== run-tcp-client-eof ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# test server send to netcat, shutdown, then read line, wait for eof
./server-tcp -s greeting -N -r command -E 127.0.0.1 0 >server.port
sock: 127.0.0.1 41596
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection to 127.0.0.1 41596 port [tcp/*] succeeded!
peer: 127.0.0.1 14550
>>> greeting
<<< command
<<< EOF
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 41596 port [tcp/*] succeeded!

==== run-tcp-client-reverse-eof ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# test server read from netcat, then read line, wait for eof, shutdown
./server-tcp -r command -s greeting -E -N 127.0.0.1 0 >server.port
sock: 127.0.0.1 12853
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
peer: 127.0.0.1 28541
Connection to 127.0.0.1 12853 port [tcp/*] succeeded!
<<< command
>>> greeting
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 12853 port [tcp/*] succeeded!

==== run-tcp-client-shutdown-eof ====
pkill netcat-regress || true
<<< EOF
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# test server send to netcat, shutdown, then read line, wait for eof
./server-tcp -s greeting -N -r command -E 127.0.0.1 0 >server.port
sock: 127.0.0.1 48487
# netcat calls shutdown on output after EOF on input
rm -f client.err; echo command | ./netcat-regress -N -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
peer: 127.0.0.1 30936
>>> greeting
<<< command
Connection to 127.0.0.1 48487 port [tcp/*] succeeded!
<<< EOF
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 48487 port [tcp/*] succeeded!

==== run-tcp-client-shutdown-reverse-eof ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# test server read from netcat, wait for eof, then read line, shutdown
./server-tcp -r command -E -s greeting -N 127.0.0.1 0 >server.port
sock: 127.0.0.1 23450
# netcat calls shutdown on output after EOF on input
rm -f client.err; echo command | ./netcat-regress -N -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
peer: 127.0.0.1 13142
Connection to 127.0.0.1 23450 port [tcp/*] succeeded!
<<< command
<<< EOF
>>> greeting
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 23450 port [tcp/*] succeeded!

==== cleanup ====
pkill netcat-regress || true