START	usr.bin/nc	2024-11-26T10:00:52Z

==== 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 24000
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 16057
Connection to 127.0.0.1 24000 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 24000
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 16057
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 24000 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 27591
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 17569
Connection to ::1 27591 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 27591
grep 'Connection received on ::1 ' server.err
Connection received on ::1 17569
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 27591 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 28857
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 localhost 11415
Connection to 127.0.0.1 28857 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 28857
grep 'Connection received on localhost ' server.err
Connection received on localhost 11415
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 28857 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 20658
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -n -v ::1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection to ::1 20658 port [tcp/*] succeeded!
Connection received on localhost 35431
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 20658
grep 'Connection received on localhost ' server.err
Connection received on localhost 35431
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 20658 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 45479
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 19914
Connection to localhost (127.0.0.1) 45479 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 45479
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 19914
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 45479 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 26801
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 18907
Connection to localhost (::1) 26801 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 26801
grep 'Connection received on ::1 ' server.err
Connection received on ::1 18907
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (::1) 26801 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 17493
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 17493: 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 30317
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 30317: 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 4000
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 48367
Connection to 127.0.0.1 4000 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 4000
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 48367
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 4000 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 4000

==== 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 3757
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 31146
Connection to 127.0.0.1 3757 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 3757
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 31146
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 3757 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`$"
98579 netcat-regress
Listening on 127.0.0.1 45146
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 40805
Connection to 127.0.0.1 45146 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 45146 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 9053
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 34718
Connection to 127.0.0.1 9053 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_CHACHA20_POLY1305_SHA256 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Valid From: Tue Nov 26 11:00:54 2024
Valid Until: Thu Dec 26 11:00:54 2024
Cert Hash: SHA256:f444ad6ffc74985f89f5ed90189483576277756e6838b25f47c7f4c673fc0f22
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 9053
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 34718
# 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 9053 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 23196
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 to ::1 23196 port [tcp/*] succeeded!
Connection received on ::1 37067
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_CHACHA20_POLY1305_SHA256 with host ::1
Peer name: ::1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=::1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=::1
Valid From: Tue Nov 26 11:00:56 2024
Valid Until: Thu Dec 26 11:00:56 2024
Cert Hash: SHA256:8db32bd7b19aabb984c8f4aabba3de081682ced9882532402e1b93f8761c98c7
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 23196
grep 'Connection received on ::1 ' server.err
Connection received on ::1 37067
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 23196 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 9823
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 48578
Connection to localhost (127.0.0.1) 9823 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_CHACHA20_POLY1305_SHA256 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 26 11:00:57 2024
Valid Until: Thu Dec 26 11:00:57 2024
Cert Hash: SHA256:997849006005e34d898101b8e400e3d6f9c5229e1ee8aa431f5a13275f8d6c81
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 9823
grep 'Connection received on localhost ' server.err
Connection received on localhost 48578
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 9823 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 1671
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 42242
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 1671
grep 'Connection received on localhost ' server.err
Connection received on localhost 42242
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 5224
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 20836
Connection to 127.0.0.1 5224 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_CHACHA20_POLY1305_SHA256 with host 127.0.0.1
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 26 11:00:57 2024
Valid Until: Thu Dec 26 11:00:57 2024
Cert Hash: SHA256:997849006005e34d898101b8e400e3d6f9c5229e1ee8aa431f5a13275f8d6c81
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 5224
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 20836
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 5224 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 28051
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 9387
netcat-regress: tls read failed (read failed: error:02FFF036:system library:func(4095):Connection reset by peer)
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 28051
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 9387
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 28051 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 41520
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 7400
Connection to localhost (127.0.0.1) 41520 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_CHACHA20_POLY1305_SHA256 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 26 11:00:57 2024
Valid Until: Thu Dec 26 11:00:57 2024
Cert Hash: SHA256:997849006005e34d898101b8e400e3d6f9c5229e1ee8aa431f5a13275f8d6c81
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 41520
grep 'Connection received on localhost ' server.err
Connection received on localhost 7400
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 41520 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:997849006005e34d898101b8e400e3d6f9c5229e1ee8aa431f5a13275f8d6c81

==== 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 31114
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 47650
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 31114
grep 'Connection received on localhost ' server.err
Connection received on localhost 47650
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 31114 port [tcp/*] succeeded!
grep 'peer certificate is not SHA256:' client.err
netcat-regress: peer certificate is not SHA256:8f433c25adbd0f36847ba436de5f9ab3af5f49b22982e2a9f2033c7abb05e641
! 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 19092
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 27039
Connection to localhost (127.0.0.1) 19092 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_CHACHA20_POLY1305_SHA256 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_CHACHA20_POLY1305_SHA256 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 26 11:00:57 2024
Valid Until: Thu Dec 26 11:00:57 2024
Cert Hash: SHA256:997849006005e34d898101b8e400e3d6f9c5229e1ee8aa431f5a13275f8d6c81
Valid From: Tue Nov 26 11:01:00 2024
Valid Until: Thu Dec 26 11:01:00 2024
Cert Hash: SHA256:c3c7849d78215cfe8dcfd7a7da58e034aaa0edeb68b0981da6baf687479894ad
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 19092
grep 'Connection received on localhost ' server.err
Connection received on localhost 27039
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 19092 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 28105
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 5493
Connection to localhost (127.0.0.1) 28105 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_CHACHA20_POLY1305_SHA256 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 26 11:00:57 2024
Valid Until: Thu Dec 26 11:00:57 2024
Cert Hash: SHA256:997849006005e34d898101b8e400e3d6f9c5229e1ee8aa431f5a13275f8d6c81
grep 'Listening on localhost ' server.err
Listening on localhost 28105
grep 'Connection received on localhost ' server.err
Connection received on localhost 5493
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 28105 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 32040
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 5990
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 32040
grep 'Connection received on localhost ' server.err
Connection received on localhost 5990
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 32040 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 4853
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 28253
Connection to localhost (127.0.0.1) 4853 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_CHACHA20_POLY1305_SHA256 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 26 11:00:57 2024
Valid Until: Thu Dec 26 11:00:57 2024
Cert Hash: SHA256:997849006005e34d898101b8e400e3d6f9c5229e1ee8aa431f5a13275f8d6c81
TLS handshake negotiated TLSv1.3/TLS_CHACHA20_POLY1305_SHA256 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: Tue Nov 26 11:01:00 2024
Valid Until: Thu Dec 26 11:01:00 2024
Cert Hash: SHA256:c3c7849d78215cfe8dcfd7a7da58e034aaa0edeb68b0981da6baf687479894ad
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 4853
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 28253
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 4853 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 30948
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 36335
Connection to localhost (127.0.0.1) 30948 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_CHACHA20_POLY1305_SHA256 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_CHACHA20_POLY1305_SHA256 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 26 11:00:57 2024
Valid Until: Thu Dec 26 11:00:57 2024
Cert Hash: SHA256:997849006005e34d898101b8e400e3d6f9c5229e1ee8aa431f5a13275f8d6c81
Valid From: Tue Nov 26 11:01:00 2024
Valid Until: Thu Dec 26 11:01:00 2024
Cert Hash: SHA256:c3c7849d78215cfe8dcfd7a7da58e034aaa0edeb68b0981da6baf687479894ad
netcat-regress: name (127.0.0.1) not found in client cert
netcat-regress: tls read failed (read failed: error:02FFF036:system library:func(4095):Connection reset by peer)
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 30948
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 36335
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 30948 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 23087
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 25539
Connection to localhost (127.0.0.1) 23087 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_CHACHA20_POLY1305_SHA256 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_CHACHA20_POLY1305_SHA256 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 26 11:00:57 2024
Valid Until: Thu Dec 26 11:00:57 2024
Cert Hash: SHA256:997849006005e34d898101b8e400e3d6f9c5229e1ee8aa431f5a13275f8d6c81
Valid From: Tue Nov 26 11:01:00 2024
Valid Until: Thu Dec 26 11:01:00 2024
Cert Hash: SHA256:c3c7849d78215cfe8dcfd7a7da58e034aaa0edeb68b0981da6baf687479894ad
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 23087
grep 'Connection received on localhost ' server.err
Connection received on localhost 25539
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 23087 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 47439
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 43124
Connection to localhost (127.0.0.1) 47439 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_CHACHA20_POLY1305_SHA256 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 26 11:00:57 2024
Valid Until: Thu Dec 26 11:00:57 2024
Cert Hash: SHA256:997849006005e34d898101b8e400e3d6f9c5229e1ee8aa431f5a13275f8d6c81
TLS handshake negotiated TLSv1.3/TLS_CHACHA20_POLY1305_SHA256 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 26 11:01:00 2024
Valid Until: Thu Dec 26 11:01:00 2024
Cert Hash: SHA256:c3c7849d78215cfe8dcfd7a7da58e034aaa0edeb68b0981da6baf687479894ad
netcat-regress: peer certificate is not SHA256:8f433c25adbd0f36847ba436de5f9ab3af5f49b22982e2a9f2033c7abb05e641
nc localhost `cat server.port` 2>/dev/null || :
grep 'Listening on localhost ' server.err
Listening on localhost 47439
grep 'Connection received on localhost ' server.err
Connection received on localhost 43124
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 47439 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:8f433c25adbd0f36847ba436de5f9ab3af5f49b22982e2a9f2033c7abb05e641
! 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 18841
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 35778
Connection to localhost (127.0.0.1) 18841 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_CHACHA20_POLY1305_SHA256 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Tue Nov 26 11:00:57 2024
Valid Until: Thu Dec 26 11:00:57 2024
Cert Hash: SHA256:997849006005e34d898101b8e400e3d6f9c5229e1ee8aa431f5a13275f8d6c81
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 18841
grep 'Connection received on localhost ' server.err
Connection received on localhost 35778
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 18841 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 35373
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 15678
Connection to 127.0.0.1 35373 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_CHACHA20_POLY1305_SHA256 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Valid From: Tue Nov 26 11:00:54 2024
Valid Until: Thu Dec 26 11:00:54 2024
Cert Hash: SHA256:f444ad6ffc74985f89f5ed90189483576277756e6838b25f47c7f4c673fc0f22
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 35373
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 15678
# 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 35373 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 35373

==== 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 37861
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 38022
Connection to 127.0.0.1 37861 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_CHACHA20_POLY1305_SHA256 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Valid From: Tue Nov 26 11:00:54 2024
Valid Until: Thu Dec 26 11:00:54 2024
Cert Hash: SHA256:f444ad6ffc74985f89f5ed90189483576277756e6838b25f47c7f4c673fc0f22
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 37861
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 38022
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 37861 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`$"
69387 netcat-regress
Listening on 127.0.0.1 31304
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 37615
Connection to 127.0.0.1 31304 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_CHACHA20_POLY1305_SHA256 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Valid From: Tue Nov 26 11:00:54 2024
Valid Until: Thu Dec 26 11:00:54 2024
Cert Hash: SHA256:f444ad6ffc74985f89f5ed90189483576277756e6838b25f47c7f4c673fc0f22
# 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 31304 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 28731
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 5383
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 28731
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 5383

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

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

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

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

==== 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 31962
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 31962
# 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`$"
86169 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 39634
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 22338
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 39634
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 22338
# 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 39634

==== 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$"
89289 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.gruOkRFfAB
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.7jIIkOfMbj
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.Q0YFnnhIW6
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$"
71504 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.Cykj0Z6kFk
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 16705
./client-tcp -r greeting -s command 127.0.0.1 `cat server.port` >client.port
peer: 127.0.0.1 26723
>>> greeting
sock: 127.0.0.1 26723
peer: 127.0.0.1 16705
<<< 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 46433
./client-tcp -r greeting -E -s command -N 127.0.0.1 `cat server.port` >client.port
peer: 127.0.0.1 13854
>>> greeting
sock: 127.0.0.1 13854
peer: 127.0.0.1 46433
<<< 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 4764
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 5894
sock: 127.0.0.1 5894
peer: 127.0.0.1 4764
<<< 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 4764
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 5894

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

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

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

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

==== 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 20482
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 37617
>>> greeting
Connection to 127.0.0.1 20482 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 20482 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 39979
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 4482
>>> greeting
Connection to 127.0.0.1 39979 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 39979 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 29910
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 3538
Connection to 127.0.0.1 29910 port [tcp/*] succeeded!
<<< command
>>> greeting
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 29910 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 48955
# 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 46047
>>> greeting
Connection to 127.0.0.1 48955 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 48955 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 15412
# 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 20383
Connection to 127.0.0.1 15412 port [tcp/*] succeeded!
<<< command
<<< EOF
>>> greeting
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 15412 port [tcp/*] succeeded!

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

PASS	usr.bin/nc	Duration 0m15.97s