START	usr.bin/nc	2024-05-25T04:58:12Z

==== 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 32861
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 40553
Connection to 127.0.0.1 32861 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 32861
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 40553
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 32861 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 47264
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 23651
Connection to ::1 47264 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 47264
grep 'Connection received on ::1 ' server.err
Connection received on ::1 23651
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 47264 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 34009
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 1748
Connection to 127.0.0.1 34009 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 34009
grep 'Connection received on localhost ' server.err
Connection received on localhost 1748
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 34009 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 24428
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -n -v ::1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on localhost 1960
Connection to ::1 24428 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 24428
grep 'Connection received on localhost ' server.err
Connection received on localhost 1960
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 24428 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 41056
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 46499
Connection to localhost (127.0.0.1) 41056 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 41056
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 46499
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 41056 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 29368
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 38186
Connection to localhost (::1) 29368 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 29368
grep 'Connection received on ::1 ' server.err
Connection received on ::1 38186
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (::1) 29368 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 10414
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 10414: 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 29600
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 29600: 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 15484
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 43104
Connection to 127.0.0.1 15484 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 15484
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 43104
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 15484 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 15484

==== 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 10893
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 26656
Connection to 127.0.0.1 10893 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 10893
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 26656
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 10893 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`$"
49144 netcat-regress
Listening on 127.0.0.1 28358
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 25677
Connection to 127.0.0.1 28358 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 28358 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 10704
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 36056
Connection to 127.0.0.1 10704 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: Sat May 25 06:58:15 2024
Valid Until: Mon Jun 24 06:58:15 2024
Cert Hash: SHA256:6ba22b84d892261cdbed088d405d7fc0abebc7c6184d10c05db6ceca87fc1d24
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 10704
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 36056
# 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 10704 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 14538
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -c -R 1.crt -n -v ::1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection received on ::1 28980
Connection to ::1 14538 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 ::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: Sat May 25 06:58:16 2024
Valid Until: Mon Jun 24 06:58:16 2024
Cert Hash: SHA256:288690df84518f3f7d28916e35c2f58f69b1c3fa7197e20056c2eeff504595a6
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 14538
grep 'Connection received on ::1 ' server.err
Connection received on ::1 28980
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 14538 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 18302
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 5055
Connection to localhost (127.0.0.1) 18302 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: Sat May 25 06:58:17 2024
Valid Until: Mon Jun 24 06:58:17 2024
Cert Hash: SHA256:36c674f6099875500491fd2064d33ddac9d1c4bc5735b484800756be4e092b9f
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 18302
grep 'Connection received on localhost ' server.err
Connection received on localhost 5055
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 18302 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 15209
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 27920
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 15209
grep 'Connection received on localhost ' server.err
Connection received on localhost 27920
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 38156
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 38311
Connection to 127.0.0.1 38156 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: Sat May 25 06:58:17 2024
Valid Until: Mon Jun 24 06:58:17 2024
Cert Hash: SHA256:36c674f6099875500491fd2064d33ddac9d1c4bc5735b484800756be4e092b9f
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 38156
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 38311
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 38156 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 38880
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 19703
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 38880
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 19703
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 38880 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 9158
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 41636
Connection to localhost (127.0.0.1) 9158 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: Sat May 25 06:58:17 2024
Valid Until: Mon Jun 24 06:58:17 2024
Cert Hash: SHA256:36c674f6099875500491fd2064d33ddac9d1c4bc5735b484800756be4e092b9f
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 9158
grep 'Connection received on localhost ' server.err
Connection received on localhost 41636
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 9158 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:36c674f6099875500491fd2064d33ddac9d1c4bc5735b484800756be4e092b9f

==== 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 35046
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 39151
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 35046
grep 'Connection received on localhost ' server.err
Connection received on localhost 39151
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 35046 port [tcp/*] succeeded!
grep 'peer certificate is not SHA256:' client.err
netcat-regress: peer certificate is not SHA256:40c0bcf9724d4ea031d3971ccdb316dfd861d85689e894a31238a71823c6c86c
! 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 26935
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 30397
Connection to localhost (127.0.0.1) 26935 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
Valid From: Sat May 25 06:58:17 2024
Valid Until: Mon Jun 24 06:58:17 2024
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Cert Hash: SHA256:36c674f6099875500491fd2064d33ddac9d1c4bc5735b484800756be4e092b9f
Valid From: Sat May 25 06:58:20 2024
Valid Until: Mon Jun 24 06:58:20 2024
Cert Hash: SHA256:d66abf5f86ed0cac1de0b730be3d0e624df3f0b2f8880f5d8c1f9883ef7f6d31
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 26935
grep 'Connection received on localhost ' server.err
Connection received on localhost 30397
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 26935 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 23913
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 14937
Connection to localhost (127.0.0.1) 23913 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: Sat May 25 06:58:17 2024
Valid Until: Mon Jun 24 06:58:17 2024
Cert Hash: SHA256:36c674f6099875500491fd2064d33ddac9d1c4bc5735b484800756be4e092b9f
grep 'Listening on localhost ' server.err
Listening on localhost 23913
grep 'Connection received on localhost ' server.err
Connection received on localhost 14937
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 23913 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 35760
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 35461
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 35760
grep 'Connection received on localhost ' server.err
Connection received on localhost 35461
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 35760 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 16689
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 34747
Connection to localhost (127.0.0.1) 16689 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: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Sat May 25 06:58:17 2024
Valid Until: Mon Jun 24 06:58:17 2024
Cert Hash: SHA256:36c674f6099875500491fd2064d33ddac9d1c4bc5735b484800756be4e092b9f
Valid From: Sat May 25 06:58:20 2024
Valid Until: Mon Jun 24 06:58:20 2024
Cert Hash: SHA256:d66abf5f86ed0cac1de0b730be3d0e624df3f0b2f8880f5d8c1f9883ef7f6d31
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 16689
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 34747
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 16689 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 4710
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 15985
Connection to localhost (127.0.0.1) 4710 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: Sat May 25 06:58:17 2024
Valid Until: Mon Jun 24 06:58:17 2024
Cert Hash: SHA256:36c674f6099875500491fd2064d33ddac9d1c4bc5735b484800756be4e092b9f
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: Sat May 25 06:58:20 2024
Valid Until: Mon Jun 24 06:58:20 2024
Cert Hash: SHA256:d66abf5f86ed0cac1de0b730be3d0e624df3f0b2f8880f5d8c1f9883ef7f6d31
netcat-regress: name (127.0.0.1) not found in client cert
grep 'Listening on 127.0.0.1 ' server.err
Listening on 127.0.0.1 4710
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 15985
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 4710 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 17214
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 12436
Connection to localhost (127.0.0.1) 17214 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: Sat May 25 06:58:17 2024
Valid Until: Mon Jun 24 06:58:17 2024
Cert Hash: SHA256:36c674f6099875500491fd2064d33ddac9d1c4bc5735b484800756be4e092b9f
Valid From: Sat May 25 06:58:20 2024
Valid Until: Mon Jun 24 06:58:20 2024
Cert Hash: SHA256:d66abf5f86ed0cac1de0b730be3d0e624df3f0b2f8880f5d8c1f9883ef7f6d31
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 17214
grep 'Connection received on localhost ' server.err
Connection received on localhost 12436
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 17214 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 16682
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 49063
Connection to localhost (127.0.0.1) 16682 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
TLS handshake negotiated TLSv1.3/TLS_CHACHA20_POLY1305_SHA256 with host localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
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: Sat May 25 06:58:20 2024
Valid Until: Mon Jun 24 06:58:20 2024
Valid From: Sat May 25 06:58:17 2024
Cert Hash: SHA256:d66abf5f86ed0cac1de0b730be3d0e624df3f0b2f8880f5d8c1f9883ef7f6d31
Valid Until: Mon Jun 24 06:58:17 2024
Cert Hash: SHA256:36c674f6099875500491fd2064d33ddac9d1c4bc5735b484800756be4e092b9f
netcat-regress: peer certificate is not SHA256:40c0bcf9724d4ea031d3971ccdb316dfd861d85689e894a31238a71823c6c86c
netcat-regress: tls read failed (read failed: error:02FFF036:system library:func(4095):Connection reset by peer)
nc localhost `cat server.port` 2>/dev/null || :
grep 'Listening on localhost ' server.err
Listening on localhost 16682
grep 'Connection received on localhost ' server.err
Connection received on localhost 49063
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 16682 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:40c0bcf9724d4ea031d3971ccdb316dfd861d85689e894a31238a71823c6c86c
! 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 34621
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 13785
Connection to localhost (127.0.0.1) 34621 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: Sat May 25 06:58:17 2024
Valid Until: Mon Jun 24 06:58:17 2024
Cert Hash: SHA256:36c674f6099875500491fd2064d33ddac9d1c4bc5735b484800756be4e092b9f
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 34621
grep 'Connection received on localhost ' server.err
Connection received on localhost 13785
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 34621 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 20683
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 17203
Connection to 127.0.0.1 20683 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: Sat May 25 06:58:15 2024
Valid Until: Mon Jun 24 06:58:15 2024
Cert Hash: SHA256:6ba22b84d892261cdbed088d405d7fc0abebc7c6184d10c05db6ceca87fc1d24
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 20683
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 17203
# 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 20683 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 20683

==== 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 26223
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 6269
Connection to 127.0.0.1 26223 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: Sat May 25 06:58:15 2024
Valid Until: Mon Jun 24 06:58:15 2024
Cert Hash: SHA256:6ba22b84d892261cdbed088d405d7fc0abebc7c6184d10c05db6ceca87fc1d24
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 26223
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 6269
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 26223 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`$"
66008 netcat-regress
Listening on 127.0.0.1 34685
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 43274
Connection to 127.0.0.1 34685 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: Sat May 25 06:58:15 2024
Valid Until: Mon Jun 24 06:58:15 2024
Cert Hash: SHA256:6ba22b84d892261cdbed088d405d7fc0abebc7c6184d10c05db6ceca87fc1d24
# 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 34685 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 29705
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 29841
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 29705
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 29841

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

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

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

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

==== 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 37738
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 37738
# 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`$"
90067 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 2967
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 36261
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 2967
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 36261
# 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 2967

==== 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$"
70906 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.kY6nCopr2a
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.B8M3ZVYChU
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.jtbzILEUiq
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$"
34054 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.SnCgV3HBMh
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 45173
./client-tcp -r greeting -s command 127.0.0.1 `cat server.port` >client.port
sock: 127.0.0.1 48838
peer: 127.0.0.1 45173
peer: 127.0.0.1 48838
>>> greeting
<<< greeting
>>> command
<<< command

==== run-tcp-test-shutdown ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
# test the test tools
./server-tcp -s greeting -N -r command -E 127.0.0.1 0 >server.port
sock: 127.0.0.1 18612
./client-tcp -r greeting -E -s command -N 127.0.0.1 `cat server.port` >client.port
peer: 127.0.0.1 15874
>>> greeting
sock: 127.0.0.1 15874
peer: 127.0.0.1 18612
<<< 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 29332
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 33124
sock: 127.0.0.1 33124
peer: 127.0.0.1 29332
<<< 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 29332
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 33124

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

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

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

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

==== 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 22549
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection to 127.0.0.1 22549 port [tcp/*] succeeded!
peer: 127.0.0.1 18174
>>> greeting
<<< command
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 22549 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 43223
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection to 127.0.0.1 43223 port [tcp/*] succeeded!
peer: 127.0.0.1 19776
>>> greeting
<<< command
<<< EOF
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 43223 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 18771
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection to 127.0.0.1 18771 port [tcp/*] succeeded!
peer: 127.0.0.1 28922
<<< 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 18771 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 19611
# netcat calls shutdown on output after EOF on input
rm -f client.err; echo command | ./netcat-regress -N -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection to 127.0.0.1 19611 port [tcp/*] succeeded!
peer: 127.0.0.1 24508
>>> greeting
<<< command
<<< EOF
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 19611 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 26534
# netcat calls shutdown on output after EOF on input
rm -f client.err; echo command | ./netcat-regress -N -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection to 127.0.0.1 26534 port [tcp/*] succeeded!
peer: 127.0.0.1 19983
<<< 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 26534 port [tcp/*] succeeded!

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

PASS	usr.bin/nc	Duration 0m17.81s