serval-dna/tests/msp

#!/bin/bash

# Tests for stream connections
#
# Copyright 2012 Serval Project, Inc.
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.


source "${0%/*}/../testframework.sh"
source "${0%/*}/../testdefs.sh"

_simulator() {
   # TODO timeout & failure reporting?
   $servald_build_root/simulator <&8 >$SIM_OUT
}
start_simulator() {
  SIM_IN="$PWD/SIM_IN"
  SIM_OUT="$PWD/SIM_OUT"
  mkfifo "$SIM_IN"
  exec 8<>"$SIM_IN"
  fork %simulator _simulator
}
simulator_command() {
  tfw_log "$@"
  assert_fork_is_running %simulator
  echo "$@" >> "$SIM_IN"
}

setup_common() {
   setup_servald
   assert_no_servald_processes
   start_simulator
   simulator_command create "net1" "$SERVALD_VAR/dummy1/"
   simulator_command up "net1"
}

finally() {
   simulator_command quit
   fork_wait %simulator
}

teardown() {
   stop_all_servald_servers
   kill_all_servald_processes
   assert_no_servald_processes
   report_all_servald_servers
}

configure_servald_server() {
   create_single_identity
   add_servald_interface
   executeOk_servald config \
      set debug.mdprequests on \
      set debug.msp on \
      set log.console.level DEBUG \
      set log.console.show_time on
}

doc_connect_fail="Timeout when the connection isn't reachable"
setup_connect_fail() {
   setup_common
   set_instance +B
   create_single_identity
   start_servald_instances +A
}
test_connect_fail() {
   set_instance +A
   execute --exit-status=1 --timeout=20 $servald msp connect $SIDB 512 <<EOF
Hello from the client
EOF
   tfw_cat --stderr
}

doc_hello="Simple Hello World"
setup_hello() {
   setup_common
   start_servald_instances +A +B
}
server_hello() {
   executeOk_servald --timeout=20 msp listen 512 <<EOF
Hello from the server
EOF
   assertStdoutGrep --matches=1 "^Hello from the client$"
   assertStderrGrep --matches=1 " Connection with .* closed gracefully$"
   tfw_cat --stderr
}
test_hello() {
   set_instance +A
   fork %listen server_hello
   set_instance +B
   executeOk_servald --timeout=20 msp connect $SIDA 512 <<EOF
Hello from the client
EOF
   assertStdoutGrep --matches=1 "^Hello from the server$"
   assertStderrGrep --matches=1 " Connection with .* closed gracefully$"
   fork_wait %listen
}

doc_client_no_data="Client connection with no data"
setup_client_no_data() {
   setup_common
   create_file file1 64000
   start_servald_instances +A +B
}
server_client_no_data() {
   executeOk_servald --timeout=20 msp listen 512 <file1
   assertStderrGrep --matches=1 " Connection with .* closed gracefully$"
   tfw_cat --stderr
}
test_client_no_data() {
   set_instance +A
   fork %listen server_client_no_data
   set_instance +B
   executeOk_servald --timeout=20 msp connect $SIDA 512 <<EOF
EOF
   assertStderrGrep --matches=1 " Connection with .* closed gracefully$"
   tfw_cat --stderr
   assert diff file1 "$TFWSTDOUT"
   fork_wait %listen
}

doc_server_no_data="Server sends no data"
setup_server_no_data() {
   setup_common
   create_file file1 64000
   start_servald_instances +A +B
}
server_server_no_data() {
   executeOk_servald --timeout=20 msp listen 512 <<EOF
EOF
   assertStderrGrep --matches=1 " Connection with .* closed gracefully$"
   tfw_cat --stderr
   assert diff file1 "$TFWSTDOUT"
}
test_server_no_data() {
   set_instance +A
   fork %listen server_server_no_data
   set_instance +B
   executeOk_servald --timeout=20 msp connect $SIDA 512 <file1
   assertStderrGrep --matches=1 " Connection with .* closed gracefully$"
   tfw_cat --stderr
   fork_wait %listen
}

doc_keep_alive="Keep the connection alive with no data"
setup_keep_alive() {
   setup_common
   start_servald_instances +A +B
}
listen_pipe() {
   executeOk_servald msp listen 512 < <(echo "START" && sleep 20 && echo "END")
   assertStderrGrep --matches=1 " Connection with .* closed gracefully$"
   tfw_cat --stdout --stderr
}
connect_pipe() {
   executeOk_servald msp connect $1 512 < <(echo "START" && sleep 20 && echo "END")
   assertStderrGrep --matches=1 " Connection with .* closed gracefully$"
   tfw_cat --stdout --stderr
}
test_keep_alive() {
   set_instance +A
   fork %listen listen_pipe
   set_instance +B
   fork %connect connect_pipe $SIDA
   fork_wait %listen %connect
}

doc_forward="Forward TCP connections to a remote server"
setup_forward() {
   setup_common
   start_servald_instances +A +B
}
client_forward() {
   executeOk --timeout=20 $servald msp connect --once --forward=$1 $2 512
   assertStderrGrep --matches=1 " Connection with .* closed gracefully$"
   tfw_cat --stdout --stderr
}
test_forward() {
   set_instance +A
   fork %listen server_hello
   set_instance +B
   fork %connect client_forward 2048 $SIDA
   sleep 1
   executeOk nc -v 127.0.0.1 2048 < <(echo "Hello from the client")
   assertStdoutGrep --matches=1 "^Hello from the server$"
   fork_wait %listen %connect
}

doc_tcp_tunnel="Tunnel a tcp connection"
setup_tcp_tunnel() {
   setup_common
   start_servald_instances +A +B
}
server_forward() {
   executeOk_servald msp listen --once --forward=$1 512
   assertStderrGrep --matches=1 " Connection with .* closed gracefully$"
   tfw_cat --stderr
}
nc_listen() {
   execute nc -v -l $1 < <(echo "Hello from the server")
   tfw_cat --stdout --stderr
}

test_tcp_tunnel() {
   fork %listen nc_listen 6000
   set_instance +A
   fork %server server_forward 6000
   set_instance +B
   fork %client client_forward 6001 $SIDA
   sleep 1
   executeOk nc -v 127.0.0.1 6001 < <(echo "Hello from the client")
   assertStdoutGrep --matches=1 "^Hello from the server$"
   fork_wait %listen %server %client
}

doc_slow_unreliable="Transfer 1MB over an unreliable link"
setup_slow_unreliable() {
   configure_servald_server() {
      create_single_identity
      add_servald_interface
      executeOk_servald config \
         set log.console.level DEBUG \
         set log.console.show_time on
   }
   setup_common
   # TODO, reduce link quality & improve MSP protocol to better utilise available bandwidth
   simulator_command set "net1" \
        "latency" "10" \
        "drop_packets" "10"
   dd if=/dev/urandom of=file1 bs=1k count=1k 2>&1
   start_servald_instances +A +B
}
slow_listen() {
   #note, must redirect stdin so we can indicate EOF
   executeOk_servald --stdout-file=file2 msp listen 512 < <(sleep 1)
   assertStderrGrep --matches=1 " Connection with .* closed gracefully$"
   tfw_cat --stderr
}
test_slow_unreliable() {
   set_instance +A
   fork %listen slow_listen
   set_instance +B
   executeOk_servald msp connect $SIDA 512 < file1
   assertStderrGrep --matches=1 " Connection with .* closed gracefully$"
   tfw_log "execution time (ms); $realtime_ms"
   tfw_cat --stderr
   fork_wait %listen
   assert diff file1 file2
}

doc_refused="TCP connection refused on forwarded stream"
setup_refused(){
   setup_common
   start_servald_instances +A +B
}
server_refused(){
   executeOk $servald msp listen --once --forward=4001 512
   assertStderrGrep --matches=1 " Connection refused"
   tfw_cat --stderr
}
test_refused(){
   set_instance +A
   fork %listen server_refused
   set_instance +B
   executeOk_servald msp connect $SIDA 512 < <(echo "Hello")
   assertStderrGrep --matches=1 " Connection with .* closed suddenly$"
   tfw_cat --stdout --stderr
   fork_wait %listen
}

doc_terminate="Terminate a connection mid stream"
setup_terminate() {
   setup_common
   start_servald_instances +A +B
}
client_terminate() {
   executeOk_servald msp connect --once --forward=3001 $SIDA 512
   assertStderrGrep --matches=1 " Connection with .* closed suddenly$"
   tfw_cat --stdout --stderr
}
server_terminate() {
   executeOk_servald msp listen 512 < <(dd if=/dev/urandom bs=1k count=500 | hexdump -C)
   assertStderrGrep --matches=1 " Connection with .* closed suddenly$"
   tfw_cat --stdout --stderr
}
test_terminate() {
   set_instance +A
   fork %msplisten server_terminate
   set_instance +B
   fork %mspconnect client_terminate
   sleep 1
# todo capture nc output nicely, while still being able to terminate it
   fork %ncconnect nc -v 127.0.0.1 3001
   fork_terminate %ncconnect
   fork_wait %msplisten %mspconnect %ncconnect
}

runTests "$@"