START	usr.bin/nc	2025-01-29T02:30:01Z

==== 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 42216
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 46741
Connection to 127.0.0.1 42216 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 42216
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 46741
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 42216 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 7192
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 14330
Connection to ::1 7192 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 7192
grep 'Connection received on ::1 ' server.err
Connection received on ::1 14330
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 7192 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 22564
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection to 127.0.0.1 22564 port [tcp/*] succeeded!
Connection received on localhost 23443
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 22564
grep 'Connection received on localhost ' server.err
Connection received on localhost 23443
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 22564 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 45185
sed -E -n 's/(Listening|Bound) on .* //p' server.err >server.port
rm -f client.err; echo command | ./netcat-regress -n -v ::1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Connection to ::1 45185 port [tcp/*] succeeded!
Connection received on localhost 21664
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 45185
grep 'Connection received on localhost ' server.err
Connection received on localhost 21664
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 45185 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 6736
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 3813
Connection to localhost (127.0.0.1) 6736 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 6736
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 3813
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 6736 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 35495
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 21461
Connection to localhost (::1) 35495 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 35495
grep 'Connection received on ::1 ' server.err
Connection received on ::1 21461
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (::1) 35495 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 47614
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 47614: 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 39507
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 39507: 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 3178
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 21349
Connection to 127.0.0.1 3178 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 3178
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 21349
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 3178 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 3178

==== 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 14647
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 21932
Connection to 127.0.0.1 14647 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 14647
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 21932
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 14647 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`$"
76037 netcat-regress
Listening on 127.0.0.1 43767
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 24128
Connection to 127.0.0.1 43767 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 43767 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 8762
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 45173
Connection to 127.0.0.1 8762 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Valid From: Wed Jan 29 03:30:02 2025
Valid Until: Fri Feb 28 03:30:02 2025
Cert Hash: SHA256:7d710a682863c1dcf21196b9fb2f80ac4e7bae68a683dd38b969b865ab50dae1
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 8762
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 45173
# 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 8762 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 14491
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 1427
Connection to ::1 14491 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host ::1
Peer name: ::1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=::1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=::1
Valid From: Wed Jan 29 03:30:03 2025
Valid Until: Fri Feb 28 03:30:03 2025
Cert Hash: SHA256:60d577638529c2a7b44d9a60c24c4418f4b61ed6872d3cd2c098204771beb244
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 14491
grep 'Connection received on ::1 ' server.err
Connection received on ::1 1427
grep 'Connection to ::1 .* succeeded!' client.err
Connection to ::1 14491 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 33843
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 11353
Connection to localhost (127.0.0.1) 33843 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Wed Jan 29 03:30:03 2025
Valid Until: Fri Feb 28 03:30:03 2025
Cert Hash: SHA256:b5ee162c5b222471a6a7ed50d0367ae858953fb4ae566948e1bd09e52456440b
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 33843
grep 'Connection received on localhost ' server.err
Connection received on localhost 11353
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 33843 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 10827
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 28803
netcat-regress: tls handshake failed (handshake failed: error:02FFF020:system library:func(4095):Broken pipe)
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 localhost ' server.err
Listening on localhost 10827
grep 'Connection received on localhost ' server.err
Connection received on localhost 28803
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 6836
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 45364
Connection to 127.0.0.1 6836 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host 127.0.0.1
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Wed Jan 29 03:30:03 2025
Valid Until: Fri Feb 28 03:30:03 2025
Cert Hash: SHA256:b5ee162c5b222471a6a7ed50d0367ae858953fb4ae566948e1bd09e52456440b
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 6836
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 45364
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 6836 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 34321
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 43947
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 34321
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 43947
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 34321 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 47314
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 3143
Connection to localhost (127.0.0.1) 47314 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Wed Jan 29 03:30:03 2025
Valid Until: Fri Feb 28 03:30:03 2025
Cert Hash: SHA256:b5ee162c5b222471a6a7ed50d0367ae858953fb4ae566948e1bd09e52456440b
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 47314
grep 'Connection received on localhost ' server.err
Connection received on localhost 3143
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 47314 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:b5ee162c5b222471a6a7ed50d0367ae858953fb4ae566948e1bd09e52456440b

==== 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 35754
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 46479
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 35754
grep 'Connection received on localhost ' server.err
Connection received on localhost 46479
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 35754 port [tcp/*] succeeded!
grep 'peer certificate is not SHA256:' client.err
netcat-regress: peer certificate is not SHA256:0351cfe8c5765b6e514818817eee8e500714b8ade11b2777a373fb85d7a66169
! 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 40242
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 17817
Connection to localhost (127.0.0.1) 40242 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Wed Jan 29 03:30:03 2025
Valid Until: Fri Feb 28 03:30:03 2025
Cert Hash: SHA256:b5ee162c5b222471a6a7ed50d0367ae858953fb4ae566948e1bd09e52456440b
Valid From: Wed Jan 29 03:30:04 2025
Valid Until: Fri Feb 28 03:30:04 2025
Cert Hash: SHA256:689294145f22b6323c539db9439113e2639a76fddc678494acc5513e7c972256
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 40242
grep 'Connection received on localhost ' server.err
Connection received on localhost 17817
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 40242 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 9455
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 8810
Connection to localhost (127.0.0.1) 9455 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
netcat-regress: No client certificate provided
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Wed Jan 29 03:30:03 2025
Valid Until: Fri Feb 28 03:30:03 2025
Cert Hash: SHA256:b5ee162c5b222471a6a7ed50d0367ae858953fb4ae566948e1bd09e52456440b
grep 'Listening on localhost ' server.err
Listening on localhost 9455
grep 'Connection received on localhost ' server.err
Connection received on localhost 8810
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 9455 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 17787
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 29853
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 17787
grep 'Connection received on localhost ' server.err
Connection received on localhost 29853
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 17787 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 28361
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 33384
Connection to localhost (127.0.0.1) 28361 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host 127.0.0.1
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Wed Jan 29 03:30:03 2025
Valid Until: Fri Feb 28 03:30:03 2025
Cert Hash: SHA256:b5ee162c5b222471a6a7ed50d0367ae858953fb4ae566948e1bd09e52456440b
Valid From: Wed Jan 29 03:30:04 2025
Valid Until: Fri Feb 28 03:30:04 2025
Cert Hash: SHA256:689294145f22b6323c539db9439113e2639a76fddc678494acc5513e7c972256
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 28361
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 33384
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 28361 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 39504
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 24144
Connection to localhost (127.0.0.1) 39504 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Wed Jan 29 03:30:03 2025
Valid Until: Fri Feb 28 03:30:03 2025
Cert Hash: SHA256:b5ee162c5b222471a6a7ed50d0367ae858953fb4ae566948e1bd09e52456440b
Valid From: Wed Jan 29 03:30:04 2025
Valid Until: Fri Feb 28 03:30:04 2025
Cert Hash: SHA256:689294145f22b6323c539db9439113e2639a76fddc678494acc5513e7c972256
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 39504
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 24144
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 39504 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 41893
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 35627
Connection to localhost (127.0.0.1) 41893 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Wed Jan 29 03:30:03 2025
Valid Until: Fri Feb 28 03:30:03 2025
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Cert Hash: SHA256:b5ee162c5b222471a6a7ed50d0367ae858953fb4ae566948e1bd09e52456440b
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Wed Jan 29 03:30:04 2025
Valid Until: Fri Feb 28 03:30:04 2025
Cert Hash: SHA256:689294145f22b6323c539db9439113e2639a76fddc678494acc5513e7c972256
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 41893
grep 'Connection received on localhost ' server.err
Connection received on localhost 35627
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 41893 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 27063
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 35566
Connection to localhost (127.0.0.1) 27063 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=client/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Wed Jan 29 03:30:03 2025
Valid Until: Fri Feb 28 03:30:03 2025
Cert Hash: SHA256:b5ee162c5b222471a6a7ed50d0367ae858953fb4ae566948e1bd09e52456440b
Valid From: Wed Jan 29 03:30:04 2025
Valid Until: Fri Feb 28 03:30:04 2025
Cert Hash: SHA256:689294145f22b6323c539db9439113e2639a76fddc678494acc5513e7c972256
netcat-regress: peer certificate is not SHA256:0351cfe8c5765b6e514818817eee8e500714b8ade11b2777a373fb85d7a66169
nc localhost `cat server.port` 2>/dev/null || :
grep 'Listening on localhost ' server.err
Listening on localhost 27063
grep 'Connection received on localhost ' server.err
Connection received on localhost 35566
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 27063 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:0351cfe8c5765b6e514818817eee8e500714b8ade11b2777a373fb85d7a66169
! 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 38983
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 26283
Connection to localhost (127.0.0.1) 38983 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host localhost
Peer name: localhost
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=localhost
Issuer: /L=OpenBSD/O=netcat-regress/OU=ca/CN=root
Valid From: Wed Jan 29 03:30:03 2025
Valid Until: Fri Feb 28 03:30:03 2025
Cert Hash: SHA256:b5ee162c5b222471a6a7ed50d0367ae858953fb4ae566948e1bd09e52456440b
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 38983
grep 'Connection received on localhost ' server.err
Connection received on localhost 26283
grep 'Connection to localhost .* succeeded!' client.err
Connection to localhost (127.0.0.1) 38983 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 18560
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 46076
Connection to 127.0.0.1 18560 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Valid From: Wed Jan 29 03:30:02 2025
Valid Until: Fri Feb 28 03:30:02 2025
Cert Hash: SHA256:7d710a682863c1dcf21196b9fb2f80ac4e7bae68a683dd38b969b865ab50dae1
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 18560
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 46076
# 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 18560 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 18560

==== 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 36386
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 18264
Connection to 127.0.0.1 36386 port [tcp/*] succeeded!
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Valid From: Wed Jan 29 03:30:02 2025
Valid Until: Fri Feb 28 03:30:02 2025
Cert Hash: SHA256:7d710a682863c1dcf21196b9fb2f80ac4e7bae68a683dd38b969b865ab50dae1
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 36386
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 18264
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 36386 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`$"
95667 netcat-regress
Listening on 127.0.0.1 37642
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 34059
Connection to 127.0.0.1 37642 port [tcp/*] succeeded!
TLS handshake negotiated TLSv1.3/TLS_AES_256_GCM_SHA384 with host 127.0.0.1
Peer name: 127.0.0.1
Subject: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Issuer: /L=OpenBSD/O=netcat-regress/OU=server/CN=127.0.0.1
Valid From: Wed Jan 29 03:30:02 2025
Valid Until: Fri Feb 28 03:30:02 2025
Cert Hash: SHA256:7d710a682863c1dcf21196b9fb2f80ac4e7bae68a683dd38b969b865ab50dae1
let timeout=`date +%s`+5;  until grep -q 'Cert Hash:' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
# 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 37642 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 48295
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 2707
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 48295
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 2707

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

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

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

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

==== 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 7666
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 7666
# 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`$"
17159 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 42575
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 17190
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 42575
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 17190
# 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 42575

==== 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$"
1561 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.deNgyn68tc
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.Jg6I96HErj
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.2tsiHnQ2SY
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$"
34770 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.5QxINssn01
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  -g -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  -g -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  -g -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 29476
./client-tcp -r greeting -s command 127.0.0.1 `cat server.port` >client.port
sock: 127.0.0.1 15792
peer: 127.0.0.1 29476
peer: 127.0.0.1 15792
>>> 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 8017
./client-tcp -r greeting -E -s command -N 127.0.0.1 `cat server.port` >client.port
sock: 127.0.0.1 15805
peer: 127.0.0.1 8017
peer: 127.0.0.1 15805
>>> greeting
<<< greeting
<<< EOF
>>> command
<<< command
<<< EOF

==== run-tcp-server ====
pkill netcat-regress || true
rm -f netcat-regress
# copying global netcat to local name allows to pkill it during cleanup
cp /usr/bin/nc netcat-regress
chmod 755 netcat-regress
rm -f server.err; echo greeting | ./netcat-regress -n -v -l 127.0.0.1 0 2>&1 >server.out | tee server.err &
let timeout=`date +%s`+5;  until grep -q 'Listening on ' server.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
Listening on 127.0.0.1 47657
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 41545
sock: 127.0.0.1 41545
peer: 127.0.0.1 47657
<<< 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 47657
grep 'Connection received on 127.0.0.1 ' server.err
Connection received on 127.0.0.1 41545

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

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

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

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

==== 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 44212
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
peer: 127.0.0.1 39636
Connection to 127.0.0.1>>> greeting
 44212 port [tcp/*] succeeded!
<<< command
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 44212 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 40133
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
peer: 127.0.0.1 10918
>>> greeting
Connection to 127.0.0.1 40133 port [tcp/*] succeeded!
<<< command
<<< EOF
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 40133 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 47205
rm -f client.err; echo command | ./netcat-regress -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
peer: 127.0.0.1 11166
Connection to 127.0.0.1 47205 port [tcp/*] succeeded!
<<< command
>>> greeting
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 47205 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 35777
# netcat calls shutdown on output after EOF on input
rm -f client.err; echo command | ./netcat-regress -N -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
peer: 127.0.0.1 44763
>>> greeting
Connection to 127.0.0.1 35777 port [tcp/*] succeeded!
<<< command
<<< EOF
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 35777 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 29905
# netcat calls shutdown on output after EOF on input
rm -f client.err; echo command | ./netcat-regress -N -n -v 127.0.0.1 `cat server.port` 2>&1 >client.out | tee client.err &
let timeout=`date +%s`+5;  until grep -q 'Connection to .* succeeded' client.err;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
peer: 127.0.0.1 11223
Connection to 127.0.0.1 29905 port [tcp/*] succeeded!
<<< command
<<< EOF
>>> greeting
let timeout=`date +%s`+5;  until grep -q 'greeting' client.out;  do [[ `date +%s` -lt $timeout ]] || { echo timeout; exit 1; }; done
grep '^greeting$' client.out
greeting
grep 'Connection to 127.0.0.1 .* succeeded!' client.err
Connection to 127.0.0.1 29905 port [tcp/*] succeeded!

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

PASS	usr.bin/nc	Duration 0m06.29s