START	usr.bin/nc	2024-08-25T04:59:48Z

==== 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
Listening on 127.0.0.1 33364
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 24984
Connection to 127.0.0.1 33364 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 33364
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 24984
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 33364 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 26870
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 19293
Connection to ::1 26870 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 26870
grep 'Connection received on ::1 ' server.err
Connection received on ::1 19293
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 26870 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 14666
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 14666 port [tcp/*] succeeded!
Connection received on localhost 17917
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 14666
grep 'Connection received on localhost ' server.err
Connection received on localhost 17917
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 14666 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 12478
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 localhost 12983
Connection to ::1 12478 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 localhost ' server.err
Listening on localhost 12478
grep 'Connection received on localhost ' server.err
Connection received on localhost 12983
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 12478 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 24100
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 23581
Connection to localhost (127.0.0.1) 24100 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 24100
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 23581
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 24100 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 15343
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 7558
Connection to localhost (::1) 15343 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 15343
grep 'Connection received on ::1 ' server.err
Connection received on ::1 7558
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (::1) 15343 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 5237
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 5237: 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 12155
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 12155: 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 37551
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 35604
Connection to 127.0.0.1 37551 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 37551
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 35604
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 37551 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 37551

==== 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 7611
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 44800
Connection to 127.0.0.1 7611 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 7611
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 44800
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 7611 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`$"
4379 netcat-regress
Listening on 127.0.0.1 42023
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 4137
Connection to 127.0.0.1 42023 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 42023 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 10537
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 24625
Connection to 127.0.0.1 10537 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: Sun Aug 25 06:59:50 2024
Valid Until: Tue Sep 24 06:59:50 2024
Cert Hash: SHA256:477afd0635f84472746c9aa7f98f870e320834a4a43f66b2b277100e7cdad70d
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 10537
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 24625
# 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 10537 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 10906
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 30802
Connection to ::1 10906 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: Sun Aug 25 06:59:50 2024
Valid Until: Tue Sep 24 06:59:50 2024
Cert Hash: SHA256:e925986c3d02e56bd3084691442b74a6e6a0bbd4a606c83dcaad63c8eaa029eb
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 10906
grep 'Connection received on ::1 ' server.err
Connection received on ::1 30802
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 10906 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 47863
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 26458
Connection to localhost (127.0.0.1) 47863 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: Sun Aug 25 06:59:51 2024
Valid Until: Tue Sep 24 06:59:51 2024
Cert Hash: SHA256:b6f04b199fc851c62134ab51d8fbfdc7775f537d1b44667e8bb5da22b7a38bd6
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 47863
grep 'Connection received on localhost ' server.err
Connection received on localhost 26458
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 47863 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 18924
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 14471
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 18924
grep 'Connection received on localhost ' server.err
Connection received on localhost 14471
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 20614
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 received on 127.0.0.1 28498
Connection to 127.0.0.1 20614 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: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Sun Aug 25 06:59:51 2024
Valid Until: Tue Sep 24 06:59:51 2024
Cert Hash: SHA256:b6f04b199fc851c62134ab51d8fbfdc7775f537d1b44667e8bb5da22b7a38bd6
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 20614
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 28498
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 20614 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 36739
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 31171
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 36739
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 31171
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 36739 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 7166
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 1060
Connection to localhost (127.0.0.1) 7166 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: Sun Aug 25 06:59:51 2024
Valid Until: Tue Sep 24 06:59:51 2024
Cert Hash: SHA256:b6f04b199fc851c62134ab51d8fbfdc7775f537d1b44667e8bb5da22b7a38bd6
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 7166
grep 'Connection received on localhost ' server.err
Connection received on localhost 1060
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 7166 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:b6f04b199fc851c62134ab51d8fbfdc7775f537d1b44667e8bb5da22b7a38bd6

==== 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 1167
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 6483
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 1167
grep 'Connection received on localhost ' server.err
Connection received on localhost 6483
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 1167 port [tcp/*] succeeded!
grep 'peer certificate is not SHA256:' client.err
netcat-regress: peer certificate is not SHA256:715970b2ee31ed8354978657fc55690e5f7958aae9e4aab66744b19f54f1bf69
! 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 40142
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 7665
Connection to localhost (127.0.0.1) 40142 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: Sun Aug 25 06:59:51 2024
Valid Until: Tue Sep 24 06:59:51 2024
Cert Hash: SHA256:b6f04b199fc851c62134ab51d8fbfdc7775f537d1b44667e8bb5da22b7a38bd6
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: Sun Aug 25 06:59:55 2024
Valid Until: Tue Sep 24 06:59:55 2024
Cert Hash: SHA256:6eb7c0527ca2b8249964c7642465481ec8301a2cd9229ce4895270599fc04c3d
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 40142
grep 'Connection received on localhost ' server.err
Connection received on localhost 7665
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 40142 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 5419
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 47292
Connection to localhost (127.0.0.1) 5419 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: Sun Aug 25 06:59:51 2024
Valid Until: Tue Sep 24 06:59:51 2024
Cert Hash: SHA256:b6f04b199fc851c62134ab51d8fbfdc7775f537d1b44667e8bb5da22b7a38bd6
grep 'Listening on localhost ' server.err
Listening on localhost 5419
grep 'Connection received on localhost ' server.err
Connection received on localhost 47292
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 5419 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 26578
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 2682
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 26578
grep 'Connection received on localhost ' server.err
Connection received on localhost 2682
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 26578 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 35699
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 4953
Connection to localhost (127.0.0.1) 35699 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
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Sun Aug 25 06:59:51 2024
Valid Until: Tue Sep 24 06:59:51 2024
Cert Hash: SHA256:b6f04b199fc851c62134ab51d8fbfdc7775f537d1b44667e8bb5da22b7a38bd6
Valid From: Sun Aug 25 06:59:55 2024
Valid Until: Tue Sep 24 06:59:55 2024
Cert Hash: SHA256:6eb7c0527ca2b8249964c7642465481ec8301a2cd9229ce4895270599fc04c3d
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 35699
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 4953
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 35699 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 22406
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 32771
Connection to localhost (127.0.0.1) 22406 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: Sun Aug 25 06:59:51 2024
Valid Until: Tue Sep 24 06:59:51 2024
Cert Hash: SHA256:b6f04b199fc851c62134ab51d8fbfdc7775f537d1b44667e8bb5da22b7a38bd6
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: Sun Aug 25 06:59:55 2024
Valid Until: Tue Sep 24 06:59:55 2024
Cert Hash: SHA256:6eb7c0527ca2b8249964c7642465481ec8301a2cd9229ce4895270599fc04c3d
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 22406
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 32771
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 22406 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 2937
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 45919
Connection to localhost (127.0.0.1) 2937 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: Sun Aug 25 06:59:51 2024
Valid Until: Tue Sep 24 06:59:51 2024
Cert Hash: SHA256:b6f04b199fc851c62134ab51d8fbfdc7775f537d1b44667e8bb5da22b7a38bd6
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: Sun Aug 25 06:59:55 2024
Valid Until: Tue Sep 24 06:59:55 2024
Cert Hash: SHA256:6eb7c0527ca2b8249964c7642465481ec8301a2cd9229ce4895270599fc04c3d
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 2937
grep 'Connection received on localhost ' server.err
Connection received on localhost 45919
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 2937 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 43079
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 8286
Connection to localhost (127.0.0.1) 43079 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 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: Sun Aug 25 06:59:51 2024
Valid Until: Tue Sep 24 06:59:51 2024
Cert Hash: SHA256:b6f04b199fc851c62134ab51d8fbfdc7775f537d1b44667e8bb5da22b7a38bd6
Valid From: Sun Aug 25 06:59:55 2024
Valid Until: Tue Sep 24 06:59:55 2024
Cert Hash: SHA256:6eb7c0527ca2b8249964c7642465481ec8301a2cd9229ce4895270599fc04c3d
netcat-regress: peer certificate is not SHA256:715970b2ee31ed8354978657fc55690e5f7958aae9e4aab66744b19f54f1bf69
nc localhost `cat server.port` 2>/dev/null || :
grep 'Listening on localhost ' server.err
Listening on localhost 43079
grep 'Connection received on localhost ' server.err
Connection received on localhost 8286
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 43079 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:715970b2ee31ed8354978657fc55690e5f7958aae9e4aab66744b19f54f1bf69
! 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 40672
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 17437
Connection to localhost (127.0.0.1) 40672 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: Sun Aug 25 06:59:51 2024
Valid Until: Tue Sep 24 06:59:51 2024
Cert Hash: SHA256:b6f04b199fc851c62134ab51d8fbfdc7775f537d1b44667e8bb5da22b7a38bd6
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 40672
grep 'Connection received on localhost ' server.err
Connection received on localhost 17437
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 40672 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 12823
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 19696
Connection to 127.0.0.1 12823 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: Sun Aug 25 06:59:50 2024
Valid Until: Tue Sep 24 06:59:50 2024
Cert Hash: SHA256:477afd0635f84472746c9aa7f98f870e320834a4a43f66b2b277100e7cdad70d
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 12823
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 19696
# 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 12823 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 12823

==== 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 41399
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 29008
Connection to 127.0.0.1 41399 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: Sun Aug 25 06:59:50 2024
Valid Until: Tue Sep 24 06:59:50 2024
Cert Hash: SHA256:477afd0635f84472746c9aa7f98f870e320834a4a43f66b2b277100e7cdad70d
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 41399
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 29008
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 41399 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`$"
87479 netcat-regress
Listening on 127.0.0.1 34515
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 9598
Connection to 127.0.0.1 34515 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: Sun Aug 25 06:59:50 2024
Valid Until: Tue Sep 24 06:59:50 2024
Cert Hash: SHA256:477afd0635f84472746c9aa7f98f870e320834a4a43f66b2b277100e7cdad70d
# 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 34515 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 30748
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 19751
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 30748
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 19751

==== 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 45363
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 33252
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Bound on ::1 ' server.err
Bound on ::1 45363
grep 'Connection received on ::1 ' server.err
Connection received on ::1 33252

==== 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 16083
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 25890
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 16083
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 25890

==== 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 37574
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 7811
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Bound on localhost ' server.err
Bound on localhost 37574
grep 'Connection received on localhost ' server.err
Connection received on localhost 7811

==== 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 43705
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 34307
grep '^greeting$' client.out
greeting
grep '^command$' server.out
command
grep 'Bound on localhost ' server.err
Bound on localhost 43705
grep 'Connection received on localhost ' server.err
Connection received on localhost 34307

==== 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 19948
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 19948
# 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`$"
87862 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 21693
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 47239
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 21693
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 47239
# 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 21693

==== 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$"
56992 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.nAZRlUtkmg
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.vDYBVRsgwV
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.NcFeaJxCJy
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$"
10842 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.x7CjfPS3rI
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 /usr/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 /usr/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 /usr/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 40973
./client-tcp -r greeting -s command 127.0.0.1 `cat server.port` >client.port
peer: 127.0.0.1 3727
>>> greeting
sock: 127.0.0.1 3727
peer: 127.0.0.1 40973
<<< 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 13379
./client-tcp -r greeting -E -s command -N 127.0.0.1 `cat server.port` >client.port
sock: 127.0.0.1 31643
peer: 127.0.0.1 13379
peer: 127.0.0.1 31643
>>> 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 47850
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 37338
sock: 127.0.0.1 37338
peer: 127.0.0.1 47850
<<< 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 47850
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 37338

==== 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 11159
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 20883
sock: 127.0.0.1 20883
peer: 127.0.0.1 11159
<<< 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 11159
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 20883

==== 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 39810
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 48683
sock: 127.0.0.1 48683
peer: 127.0.0.1 39810
>>> 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 39810
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 48683

==== 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
Listening on 127.0.0.1 15488
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 44786
sock: 127.0.0.1 44786
peer: 127.0.0.1 15488
<<< 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 15488
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 44786

==== 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 7525
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 18754
sock: 127.0.0.1 18754
peer: 127.0.0.1 7525
>>> 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 7525
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 18754

==== 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 43752
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 4727
>>> greeting
Connection to 127.0.0.1 43752 port [tcp/*] succeeded!
<<< 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 43752 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 9312
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 48646
>>> greeting
Connection to 127.0.0.1 9312 port [tcp/*] succeeded!
<<< 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 9312 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 21708
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 21708 port [tcp/*] succeeded!
peer: 127.0.0.1 13977
<<< 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 21708 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 45530
# 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 2024
Connection to 127.0.0.1 45530 port [tcp/*] succeeded!
>>> 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 45530 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 31995
# 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
Connection to 127.0.0.1 31995 port [tcp/*] succeeded!
peer: 127.0.0.1 22941
<<< 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 31995 port [tcp/*] succeeded!

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

PASS	usr.bin/nc	Duration 0m12.34s