diff options
42 files changed, 1450 insertions, 1200 deletions
diff --git a/CMakeLists.txt b/CMakeLists.txt index e55470b4..bd13b7eb 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -29,12 +29,12 @@ cmake_minimum_required(VERSION 3.13) project(nng C) include(CheckCCompilerFlag) -include(CMakeDependentOption) include(GNUInstallDirs) set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) include(NNGHelpers) +include(NNGOptions) set(CMAKE_C_STANDARD 99) set(CMAKE_INSTALL_RPATH_USE_LINK_PATH TRUE) @@ -66,22 +66,9 @@ message(STATUS "Configuring for NNG version ${NNG_ABI_VERSION}") # User-defined options. -option(BUILD_SHARED_LIBS "Build shared library" ${BUILD_SHARED_LIBS}) - -if (CMAKE_CROSSCOMPILING) - set(NNG_NATIVE_BUILD OFF) -else () - set(NNG_NATIVE_BUILD ON) -endif () - -# We only build command line tools and tests if we are not in a -# cross-compile situation. Cross-compiling users who still want to -# build these must enable them explicitly. Some of these switches -# must be enabled rather early as we use their values later. -option(NNG_TESTS "Build and run tests." ${NNG_NATIVE_BUILD}) -option(NNG_TOOLS "Build extra tools." ${NNG_NATIVE_BUILD}) -option(NNG_ENABLE_NNGCAT "Enable building nngcat utility." ${NNG_TOOLS}) -option(NNG_ENABLE_COVERAGE "Enable coverage reporting." OFF) +# This prefix is appended to by subdirectories, so that each test +# gets named based on where it is in the tree. +set(NNG_TEST_PREFIX nng) # Enable access to private APIs for our own use. add_definitions(-DNNG_PRIVATE) @@ -108,16 +95,6 @@ target_compile_definitions(nng_testing PUBLIC NNG_STATIC_LIB NNG_TEST_LIB NNG_PR add_library(nng_private INTERFACE) target_compile_definitions(nng_private INTERFACE NNG_PRIVATE) -# Eliding deprecated functionality can be used to build a slimmed down -# version of the library, or alternatively to test for application -# preparedness for expected feature removals (in the next major release.) -# Applications can also set the NNG_ELIDE_DEPRECATED preprocessor symbol -# before including <nng/nng.h> -- this will prevent declarations from -# being exposed to applications, but it will not affect their ABI -# availability for existing compiled applications. -# Note: Currently this breaks the test suite, so we only do it -# for the public library. -option(NNG_ELIDE_DEPRECATED "Elide deprecated functionality." OFF) if (NNG_ELIDE_DEPRECATED) target_compile_definitions(nng, NNG_ELIDE_DEPRECATED) endif() @@ -137,11 +114,7 @@ if (NOT WIN32) mark_as_advanced(NNG_SETSTACKSIZE) endif () -option(NNG_ENABLE_STATS "Enable statistics" ON) -if (NNG_ENABLE_STATS) - add_definitions(-DNNG_ENABLE_STATS) -endif () -mark_as_advanced(NNG_ENABLE_STATS) +nng_defines_if(NNG_ENABLE_STATS NNG_ENABLE_STATS) if (NNG_RESOLV_CONCURRENCY) add_definitions(-DNNG_RESOLV_CONCURRENCY=${NNG_RESOLV_CONCURRENCY}) @@ -269,6 +242,10 @@ else () set(NNG_PLATFORM_POSIX ON) endif () +if (NNG_ENABLE_TLS) + add_definitions(-DNNG_SUPP_TLS) +endif () + if (NNG_TESTS) enable_testing() set(all_tests, "") @@ -287,12 +264,6 @@ if (NNG_ENABLE_NNGCAT) add_subdirectory(tools/nngcat) endif () -option(NNG_ENABLE_TLS "Enable TLS protocol" OFF) -if (NNG_ENABLE_TLS) - add_definitions(-DNNG_SUPP_TLS) - set(NNG_SUPP_TLS ON) -endif () - add_subdirectory(docs/man) set(CPACK_PACKAGE_NAME ${PROJECT_NAME}) diff --git a/cmake/NNGHelpers.cmake b/cmake/NNGHelpers.cmake index 6544a97b..d7596827 100644 --- a/cmake/NNGHelpers.cmake +++ b/cmake/NNGHelpers.cmake @@ -98,8 +98,8 @@ function(nng_test NAME) ${PROJECT_SOURCE_DIR}/tests ${PROJECT_SOURCE_DIR}/src ${PROJECT_SOURCE_DIR}/include) - add_test(NAME ${PROJECT_NAME}.${NAME} COMMAND ${NAME} -t) - set_tests_properties(${PROJECT_NAME}.${NAME} PROPERTIES TIMEOUT 180) + add_test(NAME ${NNG_TEST_PREFIX}.${NAME} COMMAND ${NAME} -t -v) + set_tests_properties(${NNG_TEST_PREFIX}.${NAME} PROPERTIES TIMEOUT 180) endif () endfunction() @@ -111,8 +111,8 @@ function(nng_test_if COND NAME) ${PROJECT_SOURCE_DIR}/tests ${PROJECT_SOURCE_DIR}/src ${PROJECT_SOURCE_DIR}/include) - add_test(NAME ${PROJECT_NAME}.${NAME} COMMAND ${NAME} -t) - set_tests_properties(${PROJECT_NAME}.${NAME} PROPERTIES TIMEOUT 180) + add_test(NAME ${NNG_TEST_PREFIX}.${NAME} COMMAND ${NAME} -t -v) + set_tests_properties(${NNG_TEST_PREFIX}.${NAME} PROPERTIES TIMEOUT 180) endif () endfunction() @@ -153,3 +153,7 @@ function(nng_check_struct_member STR MEM HDR DEF) target_compile_definitions(nng_private INTERFACE ${DEF}=1) endif () endfunction(nng_check_struct_member) + +macro(nng_directory DIR) + set(NNG_TEST_PREFIX ${NNG_TEST_PREFIX}.${DIR}) +endmacro(nng_directory)
\ No newline at end of file diff --git a/cmake/NNGOptions.cmake b/cmake/NNGOptions.cmake new file mode 100644 index 00000000..b8067bca --- /dev/null +++ b/cmake/NNGOptions.cmake @@ -0,0 +1,140 @@ +# +# Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> +# +# This software is supplied under the terms of the MIT License, a +# copy of which should be located in the distribution where this +# file was obtained (LICENSE.txt). A copy of the license may also be +# found online at https://opensource.org/licenses/MIT. +# + +# NNG Options. These are user configurable knobs. + +include(CMakeDependentOption) + +if (CMAKE_CROSSCOMPILING) + set(NNG_NATIVE_BUILD OFF) +else () + set(NNG_NATIVE_BUILD ON) +endif () + +# Global options. +option(BUILD_SHARED_LIBS "Build shared library" ${BUILD_SHARED_LIBS}) + +# We only build command line tools and tests if we are not in a +# cross-compile situation. Cross-compiling users who still want to +# build these must enable them explicitly. Some of these switches +# must be enabled rather early as we use their values later. +option(NNG_TESTS "Build and run tests." ${NNG_NATIVE_BUILD}) +option(NNG_TOOLS "Build extra tools." ${NNG_NATIVE_BUILD}) +option(NNG_ENABLE_NNGCAT "Enable building nngcat utility." ${NNG_TOOLS}) +option(NNG_ENABLE_COVERAGE "Enable coverage reporting." OFF) +# Eliding deprecated functionality can be used to build a slimmed down +# version of the library, or alternatively to test for application +# preparedness for expected feature removals (in the next major release.) +# Applications can also set the NNG_ELIDE_DEPRECATED preprocessor symbol +# before including <nng/nng.h> -- this will prevent declarations from +# being exposed to applications, but it will not affect their ABI +# availability for existing compiled applications. +# Note: Currently this breaks the test suite, so we only do it +# for the public library. +option(NNG_ELIDE_DEPRECATED "Elide deprecated functionality." OFF) + +option(NNG_ENABLE_STATS "Enable statistics." ON) +mark_as_advanced(NNG_ENABLE_STATS) + +# Protocols. +option (NNG_PROTO_BUS0 "Enable BUSv0 protocol." ON) +mark_as_advanced(NNG_PROTO_BUS0) + +option (NNG_PROTO_PAIR0 "Enable PAIRv0 protocol." ON) +mark_as_advanced(NNG_PROTO_PAIR0) + +option (NNG_PROTO_PAIR1 "Enable PAIRv1 protocol." ON) +mark_as_advanced(NNG_PROTO_PAIR1) + +option (NNG_PROTO_PUSH0 "Enable PUSHv0 protocol." ON) +mark_as_advanced(NNG_PROTO_PUSH0) + +option (NNG_PROTO_PULL0 "Enable PULLv0 protocol." ON) +mark_as_advanced(NNG_PROTO_PULL0) + +option (NNG_PROTO_PUB0 "Enable PUBv0 protocol." ON) +mark_as_advanced(NNG_PROTO_PUB0) + +option (NNG_PROTO_SUB0 "Enable SUBv0 protocol." ON) +mark_as_advanced(NNG_PROTO_SUB0) + +option(NNG_PROTO_REQ0 "Enable REQv0 protocol." ON) +mark_as_advanced(NNG_PROTO_REQ0) + +option(NNG_PROTO_REP0 "Enable REPv0 protocol." ON) +mark_as_advanced(NNG_PROTO_REP0) + +option (NNG_PROTO_RESPONDENT0 "Enable RESPONDENTv0 protocol." ON) +mark_as_advanced(NNG_PROTO_RESPONDENT0) + +option (NNG_PROTO_SURVEYOR0 "Enable SURVEYORv0 protocol." ON) +mark_as_advanced(NNG_PROTO_SURVEYOR0) + +# TLS support. + +# Enabling TLS is required to enable support for the TLS transport +# and WSS. It does require a 3rd party TLS engine to be selected. +option(NNG_ENABLE_TLS "Enable TLS support." OFF) +if (NNG_ENABLE_TLS) + set(NNG_SUPP_TLS ON) +endif () + +if (NNG_ENABLE_TLS) + set(NNG_TLS_ENGINES mbed wolf none) + # We assume Mbed for now. (Someday replaced perhaps with Bear.) + set(NNG_TLS_ENGINE mbed CACHE STRING "TLS engine to use.") + set_property(CACHE NNG_TLS_ENGINE PROPERTY STRINGS ${NNG_TLS_ENGINES}) +else () + set(NNG_TLS_ENGINE none) +endif () + +# HTTP API support. +option (NNG_ENABLE_HTTP "Enable HTTP API." ON) +if (NNG_ENABLE_HTTP) + set(NNG_SUPP_HTTP ON) +endif() +mark_as_advanced(NNG_ENABLE_HTTP) + +# +# Transport Options. +# + +option (NNG_TRANSPORT_INPROC "Enable inproc transport." ON) +mark_as_advanced(NNG_TRANSPORT_INPROC) + +option (NNG_TRANSPORT_IPC "Enable IPC transport." ON) +mark_as_advanced(NNG_TRANSPORT_IPC) + +# TCP transport +option (NNG_TRANSPORT_TCP "Enable TCP transport." ON) +mark_as_advanced(NNG_TRANSPORT_TCP) + +# TLS transport +option (NNG_TRANSPORT_TLS "Enable TLS transport." ON) +mark_as_advanced(NNG_TRANSPORT_TLS) + +# WebSocket +option (NNG_TRANSPORT_WS "Enable WebSocket transport." ON) +mark_as_advanced(NNG_TRANSPORT_WS) + +CMAKE_DEPENDENT_OPTION(NNG_TRANSPORT_WSS "Enable WSS transport." ON + "NNG_ENABLE_TLS" OFF) +mark_as_advanced(NNG_TRANSPORT_WSS) + +# ZeroTier +option (NNG_TRANSPORT_ZEROTIER "Enable ZeroTier transport (requires libzerotiercore)." OFF) +mark_as_advanced(NNG_TRANSPORT_ZEROTIER) + +if (NNG_TRANSPORT_WS OR NNG_TRANSPORT_WSS) + # Make sure things we *MUST* have are enabled. + set(NNG_SUPP_WEBSOCKET ON) + set(NNG_SUPP_HTTP ON) + set(NNG_SUPP_BASE64 ON) + set(NNG_SUPP_SHA1 ON) +endif() diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 57e6596c..5e0170a3 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -11,30 +11,16 @@ nng_sources(nng.c nng_legacy.c) nng_headers(nng/nng.h) - target_include_directories(nng PRIVATE ${PROJECT_SOURCE_DIR}/src) target_include_directories(nng_testing PRIVATE ${PROJECT_SOURCE_DIR}/src) add_subdirectory(core) -add_subdirectory(platform/windows) -add_subdirectory(platform/posix) +add_subdirectory(platform) add_subdirectory(compat/nanomsg) -add_subdirectory(protocol/bus0) -add_subdirectory(protocol/pair0) -add_subdirectory(protocol/pair1) -add_subdirectory(protocol/pipeline0) -add_subdirectory(protocol/pubsub0) -add_subdirectory(protocol/reqrep0) -add_subdirectory(protocol/survey0) - -add_subdirectory(transport/inproc) -add_subdirectory(transport/ipc) -add_subdirectory(transport/tcp) -add_subdirectory(transport/tls) -add_subdirectory(transport/ws) -add_subdirectory(transport/zerotier) +add_subdirectory(protocol) +add_subdirectory(transport) add_subdirectory(supplemental/base64) add_subdirectory(supplemental/http) diff --git a/src/compat/nanomsg/CMakeLists.txt b/src/compat/nanomsg/CMakeLists.txt index 5e70e749..953eabad 100644 --- a/src/compat/nanomsg/CMakeLists.txt +++ b/src/compat/nanomsg/CMakeLists.txt @@ -9,4 +9,6 @@ nng_sources(nn.c) +set(NNG_TEST_PREFIX ${NNG_TEST_PREFIX}.compat.nanomsg) + nng_test(compat_tcp_test)
\ No newline at end of file diff --git a/src/core/CMakeLists.txt b/src/core/CMakeLists.txt index 9ecc46f8..2c954938 100644 --- a/src/core/CMakeLists.txt +++ b/src/core/CMakeLists.txt @@ -8,6 +8,7 @@ # # Core. +nng_directory(core) nng_check_sym(strlcpy string.h NNG_HAVE_STRLCPY) nng_check_sym(strnlen string.h NNG_HAVE_STRNLEN) @@ -75,3 +76,11 @@ nng_sources( url.c url.h ) + +nng_test(aio_test) +nng_test(buf_size_test) +nng_test(errors_test) +nng_test(id_test) +nng_test(reconnect_test) +nng_test(sock_test) +nng_test(url_test) diff --git a/tests/aio.c b/src/core/aio_test.c index 0fe665b1..787b6149 100644 --- a/tests/aio.c +++ b/src/core/aio_test.c @@ -1,5 +1,5 @@ // -// Copyright 2019 Staysail Systems, Inc. <info@staysail.tech> +// Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a @@ -17,20 +17,20 @@ #include "acutest.h" #include "testutil.h" -void -cbdone(void *p) +static void +cb_done(void *p) { (*(int *) p)++; } -void -sleepdone(void *arg) +static void +sleep_done(void *arg) { *(nng_time *) arg = nng_clock(); } -void -cancelfn(nng_aio *aio, void *arg, int rv) +static void +cancel(nng_aio *aio, void *arg, int rv) { *(int *) arg = rv; nng_aio_finish(aio, rv); @@ -39,46 +39,46 @@ cancelfn(nng_aio *aio, void *arg, int rv) void test_sleep(void) { - nng_time start = 0; + nng_time start; nng_time end = 0; - nng_aio *saio; + nng_aio *aio; - TEST_NNG_PASS(nng_aio_alloc(&saio, sleepdone, &end)); + TEST_NNG_PASS(nng_aio_alloc(&aio, sleep_done, &end)); start = nng_clock(); - nng_sleep_aio(200, saio); - nng_aio_wait(saio); - TEST_NNG_PASS(nng_aio_result(saio)); + nng_sleep_aio(200, aio); + nng_aio_wait(aio); + TEST_NNG_PASS(nng_aio_result(aio)); TEST_CHECK(end != 0); TEST_CHECK((end - start) >= 200); TEST_CHECK((end - start) <= 1000); TEST_CHECK((nng_clock() - start) >= 200); TEST_CHECK((nng_clock() - start) <= 1000); - nng_aio_free(saio); + nng_aio_free(aio); } void test_sleep_timeout(void) { - nng_time start = 0; + nng_time start; nng_time end = 0; - nng_aio *saio; + nng_aio *aio; - TEST_CHECK(nng_aio_alloc(&saio, sleepdone, &end) == 0); - nng_aio_set_timeout(saio, 100); + TEST_CHECK(nng_aio_alloc(&aio, sleep_done, &end) == 0); + nng_aio_set_timeout(aio, 100); start = nng_clock(); - nng_sleep_aio(2000, saio); - nng_aio_wait(saio); - TEST_NNG_FAIL(nng_aio_result(saio), NNG_ETIMEDOUT); + nng_sleep_aio(2000, aio); + nng_aio_wait(aio); + TEST_NNG_FAIL(nng_aio_result(aio), NNG_ETIMEDOUT); TEST_CHECK(end != 0); TEST_CHECK((end - start) >= 100); TEST_CHECK((end - start) <= 1000); TEST_CHECK((nng_clock() - start) >= 100); TEST_CHECK((nng_clock() - start) <= 1000); - nng_aio_free(saio); + nng_aio_free(aio); } void -test_insane_niov(void) +test_insane_nio(void) { nng_aio *aio; nng_iov iov; @@ -96,7 +96,7 @@ test_provider_cancel(void) // We fake an empty provider that does not do anything. TEST_NNG_PASS(nng_aio_alloc(&aio, NULL, NULL)); TEST_CHECK(nng_aio_begin(aio) == true); - nng_aio_defer(aio, cancelfn, &rv); + nng_aio_defer(aio, cancel, &rv); nng_aio_cancel(aio); nng_aio_wait(aio); TEST_CHECK(rv == NNG_ECANCELED); @@ -111,7 +111,7 @@ test_consumer_cancel(void) int done = 0; TEST_CHECK(nng_pair1_open(&s1) == 0); - TEST_CHECK(nng_aio_alloc(&a, cbdone, &done) == 0); + TEST_CHECK(nng_aio_alloc(&a, cb_done, &done) == 0); nng_aio_set_timeout(a, NNG_DURATION_INFINITE); nng_recv_aio(s1, a); @@ -129,10 +129,10 @@ test_traffic(void) { nng_socket s1; nng_socket s2; - nng_aio * txaio; - nng_aio * rxaio; - int txdone = 0; - int rxdone = 0; + nng_aio * tx_aio; + nng_aio * rx_aio; + int tx_done = 0; + int rx_done = 0; nng_msg * m; char * addr = "inproc://traffic"; @@ -142,37 +142,37 @@ test_traffic(void) TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0)); TEST_NNG_PASS(nng_dial(s2, addr, NULL, 0)); - TEST_NNG_PASS(nng_aio_alloc(&rxaio, cbdone, &rxdone)); - TEST_NNG_PASS(nng_aio_alloc(&txaio, cbdone, &txdone)); + TEST_NNG_PASS(nng_aio_alloc(&rx_aio, cb_done, &rx_done)); + TEST_NNG_PASS(nng_aio_alloc(&tx_aio, cb_done, &tx_done)); - nng_aio_set_timeout(rxaio, 1000); - nng_aio_set_timeout(txaio, 1000); + nng_aio_set_timeout(rx_aio, 1000); + nng_aio_set_timeout(tx_aio, 1000); TEST_NNG_PASS(nng_msg_alloc(&m, 0)); TEST_NNG_PASS(nng_msg_append(m, "hello", strlen("hello"))); - nng_recv_aio(s2, rxaio); + nng_recv_aio(s2, rx_aio); - nng_aio_set_msg(txaio, m); - nng_send_aio(s1, txaio); + nng_aio_set_msg(tx_aio, m); + nng_send_aio(s1, tx_aio); - nng_aio_wait(txaio); - nng_aio_wait(rxaio); + nng_aio_wait(tx_aio); + nng_aio_wait(rx_aio); - TEST_NNG_PASS(nng_aio_result(rxaio)); - TEST_NNG_PASS(nng_aio_result(txaio)); + TEST_NNG_PASS(nng_aio_result(rx_aio)); + TEST_NNG_PASS(nng_aio_result(tx_aio)); - TEST_CHECK((m = nng_aio_get_msg(rxaio)) != NULL); + TEST_CHECK((m = nng_aio_get_msg(rx_aio)) != NULL); TEST_CHECK(nng_msg_len(m) == strlen("hello")); TEST_CHECK(memcmp(nng_msg_body(m), "hello", strlen("hello")) == 0); nng_msg_free(m); - TEST_CHECK(rxdone == 1); - TEST_CHECK(txdone == 1); + TEST_CHECK(rx_done == 1); + TEST_CHECK(tx_done == 1); - nng_aio_free(rxaio); - nng_aio_free(txaio); + nng_aio_free(rx_aio); + nng_aio_free(tx_aio); TEST_NNG_PASS(nng_close(s1)); TEST_NNG_PASS(nng_close(s2)); } @@ -185,7 +185,7 @@ test_explicit_timeout(void) int done = 0; TEST_NNG_PASS(nng_pair1_open(&s)); - TEST_NNG_PASS(nng_aio_alloc(&a, cbdone, &done)); + TEST_NNG_PASS(nng_aio_alloc(&a, cb_done, &done)); nng_aio_set_timeout(a, 40); nng_recv_aio(s, a); nng_aio_wait(a); @@ -203,8 +203,8 @@ test_inherited_timeout(void) int done = 0; TEST_NNG_PASS(nng_pair1_open(&s)); - TEST_NNG_PASS(nng_aio_alloc(&a, cbdone, &done)); - TEST_NNG_PASS(nng_setopt_ms(s, NNG_OPT_RECVTIMEO, 40)); + TEST_NNG_PASS(nng_aio_alloc(&a, cb_done, &done)); + TEST_NNG_PASS(nng_socket_set_ms(s, NNG_OPT_RECVTIMEO, 40)); nng_recv_aio(s, a); nng_aio_wait(a); TEST_CHECK(done == 1); @@ -221,7 +221,7 @@ test_zero_timeout(void) int done = 0; TEST_NNG_PASS(nng_pair1_open(&s)); - TEST_NNG_PASS(nng_aio_alloc(&a, cbdone, &done)); + TEST_NNG_PASS(nng_aio_alloc(&a, cb_done, &done)); nng_aio_set_timeout(a, NNG_DURATION_ZERO); nng_recv_aio(s, a); nng_aio_wait(a); @@ -234,7 +234,7 @@ test_zero_timeout(void) TEST_LIST = { { "sleep", test_sleep }, { "sleep timeout", test_sleep_timeout }, - { "insane niov", test_insane_niov }, + { "insane nio", test_insane_nio }, { "provider cancel", test_provider_cancel }, { "consumer cancel", test_consumer_cancel }, { "traffic", test_traffic }, diff --git a/tests/bufsz.c b/src/core/buf_size_test.c index 4f62905d..172cb1f0 100644 --- a/tests/bufsz.c +++ b/src/core/buf_size_test.c @@ -1,5 +1,5 @@ // -// Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> +// Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a @@ -8,7 +8,6 @@ // found online at https://opensource.org/licenses/MIT. // - #include <nng/nng.h> #include <nng/protocol/pair1/pair.h> #include <nng/supplemental/util/platform.h> @@ -16,6 +15,7 @@ #include <nng/compat/nanomsg/nn.h> #include "acutest.h" +#include "testutil.h" void test_buffer_options(void) @@ -38,28 +38,29 @@ test_buffer_options(void) // Can't receive a size into zero bytes. sz = 0; - TEST_CHECK(nng_getopt(s1, opt, &val, &sz) == NNG_EINVAL); + TEST_NNG_FAIL(nng_socket_get(s1, opt, &val, &sz), NNG_EINVAL); // Can set a valid size - TEST_CHECK(nng_setopt_int(s1, opt, 1234) == 0); - TEST_CHECK(nng_getopt_int(s1, opt, &val) == 0); + TEST_NNG_PASS(nng_socket_set_int(s1, opt, 1234)); + TEST_NNG_PASS(nng_socket_get_int(s1, opt, &val)); TEST_CHECK(val == 1234); val = 0; sz = sizeof(val); - TEST_CHECK(nng_getopt(s1, opt, &val, &sz) == 0); + TEST_NNG_PASS(nng_socket_get(s1, opt, &val, &sz)); TEST_CHECK(val == 1234); TEST_CHECK(sz == sizeof(val)); // Can't set a negative size - TEST_CHECK(nng_setopt_int(s1, opt, -5) == NNG_EINVAL); + TEST_NNG_FAIL(nng_socket_set_int(s1, opt, -5), NNG_EINVAL); // Can't pass a buf too small for size sz = sizeof(val) - 1; val = 1; - TEST_CHECK(nng_setopt(s1, opt, &val, sz) == NNG_EINVAL); + TEST_NNG_FAIL(nng_socket_set(s1, opt, &val, sz), NNG_EINVAL); // Buffer sizes are limited to sane levels - TEST_CHECK(nng_setopt_int(s1, opt, 0x100000) == NNG_EINVAL); + TEST_NNG_FAIL( + nng_socket_set_int(s1, opt, 0x100000), NNG_EINVAL); } TEST_CHECK(nng_close(s1) == 0); } @@ -85,32 +86,34 @@ test_buffer_legacy(void) int cnt; int os = (int) s1.id; size_t sz; - int nnopt = legacy[i]; + int nno = legacy[i]; TEST_CASE(opt); sz = sizeof(cnt); - TEST_CHECK(nng_setopt_int(s1, opt, 10) == 0); + TEST_NNG_PASS(nng_socket_set_int(s1, opt, 10)); TEST_CHECK( - nn_getsockopt(os, NN_SOL_SOCKET, nnopt, &cnt, &sz) == 0); + nn_getsockopt(os, NN_SOL_SOCKET, nno, &cnt, &sz) == 0); TEST_CHECK(cnt == 10240); // 1k multiple cnt = 1; TEST_CHECK( - nn_setsockopt(os, NN_SOL_SOCKET, nnopt, &cnt, sz) == 0); - TEST_CHECK(nn_getsockopt(os, NN_SOL_SOCKET, nnopt, &cnt, &sz) == 0); + nn_setsockopt(os, NN_SOL_SOCKET, nno, &cnt, sz) == 0); + TEST_CHECK( + nn_getsockopt(os, NN_SOL_SOCKET, nno, &cnt, &sz) == 0); TEST_CHECK(cnt == 1024); // round up! - TEST_CHECK(nng_getopt_int(s1, opt, &cnt) == 0); + TEST_NNG_PASS(nng_socket_get_int(s1, opt, &cnt)); TEST_CHECK(cnt == 1); - TEST_CHECK(nn_setsockopt(os, NN_SOL_SOCKET, nnopt, &cnt, 100) == -1); + TEST_CHECK( + nn_setsockopt(os, NN_SOL_SOCKET, nno, &cnt, 100) == -1); TEST_CHECK(nn_errno() == EINVAL); } - TEST_CHECK(nng_close(s1) == 0); + TEST_NNG_PASS(nng_close(s1)); } TEST_LIST = { - { "buffer options", test_buffer_options }, - { "buffer legacy", test_buffer_legacy }, - { NULL, NULL }, + { "buffer options", test_buffer_options }, + { "buffer legacy", test_buffer_legacy }, + { NULL, NULL }, }; diff --git a/src/core/errors_test.c b/src/core/errors_test.c new file mode 100644 index 00000000..4e50467c --- /dev/null +++ b/src/core/errors_test.c @@ -0,0 +1,46 @@ +// +// Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> +// +// This software is supplied under the terms of the MIT License, a +// copy of which should be located in the distribution where this +// file was obtained (LICENSE.txt). A copy of the license may also be +// found online at https://opensource.org/licenses/MIT. +// + +#include <errno.h> +#include <string.h> + +#include <nng/nng.h> + +#include <acutest.h> +#include <testutil.h> + +static void +test_known_errors(void) +{ + + TEST_STREQUAL(nng_strerror(NNG_ECLOSED), "Object closed"); + TEST_STREQUAL(nng_strerror(NNG_ETIMEDOUT), "Timed out"); +} + +static void +test_unknown_errors(void) +{ + for (unsigned i = 1; i < 0x1000000; i = i * 2 + 100) { + TEST_CHECK(nng_strerror(i) != NULL); + } +} + +static void +test_system_errors(void) +{ + TEST_STREQUAL(nng_strerror(NNG_ESYSERR + ENOENT), strerror(ENOENT)); + TEST_STREQUAL(nng_strerror(NNG_ESYSERR + EINVAL), strerror(EINVAL)); +} + +TEST_LIST = { + { "known errors", test_known_errors }, + { "unknown errors", test_unknown_errors }, + { "system errors", test_system_errors }, + { NULL, NULL }, +}; diff --git a/tests/id.c b/src/core/id_test.c index e8944547..8312b5cc 100644 --- a/tests/id.c +++ b/src/core/id_test.c @@ -10,7 +10,7 @@ #include "acutest.h" #include "testutil.h" -#include "core/idhash.h" +#include "idhash.h" void test_basic(void) diff --git a/tests/reconnect.c b/src/core/reconnect_test.c index 317f1bec..669261c9 100644 --- a/tests/reconnect.c +++ b/src/core/reconnect_test.c @@ -30,8 +30,8 @@ test_dial_before_listen(void) TEST_NNG_PASS(nng_push0_open(&push)); TEST_NNG_PASS(nng_pull0_open(&pull)); - TEST_NNG_PASS(nng_setopt_ms(pull, NNG_OPT_RECONNMINT, 10)); - TEST_NNG_PASS(nng_setopt_ms(pull, NNG_OPT_RECONNMAXT, 10)); + TEST_NNG_PASS(nng_socket_set_ms(pull, NNG_OPT_RECONNMINT, 10)); + TEST_NNG_PASS(nng_socket_set_ms(pull, NNG_OPT_RECONNMAXT, 10)); TEST_NNG_PASS(nng_dial(pull, addr, NULL, NNG_FLAG_NONBLOCK)); testutil_sleep(100); @@ -57,8 +57,8 @@ test_reconnect(void) TEST_NNG_PASS(nng_push0_open(&push)); TEST_NNG_PASS(nng_pull0_open(&pull)); - TEST_NNG_PASS(nng_setopt_ms(pull, NNG_OPT_RECONNMINT, 10)); - TEST_NNG_PASS(nng_setopt_ms(pull, NNG_OPT_RECONNMAXT, 10)); + TEST_NNG_PASS(nng_socket_set_ms(pull, NNG_OPT_RECONNMINT, 10)); + TEST_NNG_PASS(nng_socket_set_ms(pull, NNG_OPT_RECONNMAXT, 10)); TEST_NNG_PASS(nng_dial(pull, addr, NULL, NNG_FLAG_NONBLOCK)); testutil_sleep(100); @@ -92,8 +92,8 @@ test_reconnect_pipe(void) TEST_NNG_PASS(nng_push0_open(&push)); TEST_NNG_PASS(nng_pull0_open(&pull)); - TEST_NNG_PASS(nng_setopt_ms(pull, NNG_OPT_RECONNMINT, 10)); - TEST_NNG_PASS(nng_setopt_ms(pull, NNG_OPT_RECONNMAXT, 10)); + TEST_NNG_PASS(nng_socket_set_ms(pull, NNG_OPT_RECONNMINT, 10)); + TEST_NNG_PASS(nng_socket_set_ms(pull, NNG_OPT_RECONNMAXT, 10)); TEST_NNG_PASS(nng_dial(pull, addr, NULL, NNG_FLAG_NONBLOCK)); testutil_sleep(100); @@ -135,8 +135,8 @@ test_reconnect_back_off_zero(void) TEST_NNG_PASS(nng_pull0_open(&pull)); // redial every 10 ms. - TEST_NNG_PASS(nng_setopt_ms(push, NNG_OPT_RECONNMAXT, 0)); - TEST_NNG_PASS(nng_setopt_ms(push, NNG_OPT_RECONNMINT, 10)); + TEST_NNG_PASS(nng_socket_set_ms(push, NNG_OPT_RECONNMAXT, 0)); + TEST_NNG_PASS(nng_socket_set_ms(push, NNG_OPT_RECONNMINT, 10)); TEST_NNG_PASS(nng_dial(push, addr, NULL, NNG_FLAG_NONBLOCK)); // Start up the dialer first. It should keep retrying every 10 ms. diff --git a/src/core/sock_test.c b/src/core/sock_test.c new file mode 100644 index 00000000..ab557632 --- /dev/null +++ b/src/core/sock_test.c @@ -0,0 +1,685 @@ +// +// Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> +// Copyright 2018 Capitar IT Group BV <info@capitar.com> +// +// This software is supplied under the terms of the MIT License, a +// copy of which should be located in the distribution where this +// file was obtained (LICENSE.txt). A copy of the license may also be +// found online at https://opensource.org/licenses/MIT. +// + +#include <string.h> + +#include <nng/nng.h> +#include <nng/protocol/pair1/pair.h> +#include <nng/supplemental/util/platform.h> + +#include "acutest.h" +#include "testutil.h" + +void +test_recv_timeout(void) +{ + nng_socket s1; + uint64_t now; + nng_msg * msg = NULL; + + TEST_NNG_PASS(nng_pair_open(&s1)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 10)); + now = testutil_clock(); + TEST_NNG_FAIL(nng_recvmsg(s1, &msg, 0), NNG_ETIMEDOUT); + TEST_CHECK(msg == NULL); + TEST_CHECK(testutil_clock() >= (now + 9)); + TEST_CHECK(testutil_clock() < (now + 500)); + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_recv_nonblock(void) +{ + nng_socket s1; + uint64_t now; + nng_msg * msg = NULL; + + TEST_NNG_PASS(nng_pair1_open(&s1)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 10)); + now = testutil_clock(); + TEST_NNG_FAIL(nng_recvmsg(s1, &msg, NNG_FLAG_NONBLOCK), NNG_EAGAIN); + TEST_CHECK(msg == NULL); + TEST_CHECK(testutil_clock() < (now + 500)); + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_send_timeout(void) +{ + nng_socket s1; + uint64_t now; + nng_msg * msg; + + TEST_NNG_PASS(nng_msg_alloc(&msg, 0)); + TEST_NNG_PASS(nng_pair_open(&s1)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 100)); + now = testutil_clock(); + TEST_NNG_FAIL(nng_sendmsg(s1, msg, 0), NNG_ETIMEDOUT); + TEST_CHECK(testutil_clock() >= (now + 9)); + TEST_CHECK(testutil_clock() < (now + 500)); + nng_msg_free(msg); + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_send_nonblock(void) +{ + nng_socket s1; + uint64_t now; + nng_msg * msg; + + TEST_NNG_PASS(nng_msg_alloc(&msg, 0)); + TEST_NNG_PASS(nng_pair1_open(&s1)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 500)); + now = testutil_clock(); + TEST_NNG_FAIL(nng_sendmsg(s1, msg, NNG_FLAG_NONBLOCK), NNG_EAGAIN); + TEST_CHECK(testutil_clock() < (now + 100)); + TEST_NNG_PASS(nng_close(s1)); + nng_msg_free(msg); +} + +void +test_readonly_options(void) +{ + nng_socket s1; + TEST_NNG_PASS(nng_pair1_open(&s1)); + TEST_NNG_FAIL( + nng_socket_set_int(s1, NNG_OPT_RECVFD, 0), NNG_EREADONLY); + TEST_NNG_FAIL( + nng_socket_set_int(s1, NNG_OPT_SENDFD, 0), NNG_EREADONLY); + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_socket_base(void) +{ + nng_socket s1 = NNG_SOCKET_INITIALIZER; + + TEST_CHECK(nng_socket_id(s1) < 0); + TEST_NNG_PASS(nng_pair1_open(&s1)); + TEST_CHECK(nng_socket_id(s1) > 0); + + // Cannot set bogus options + TEST_NNG_FAIL(nng_socket_set_bool(s1, "BAD_OPT", false), NNG_ENOTSUP); + + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_socket_name(void) +{ + nng_socket s1; + char name[128]; // 64 is max + char * str; + long id; + char * end; + size_t sz; + + sz = sizeof(name); + TEST_NNG_PASS(nng_pair_open(&s1)); + TEST_NNG_PASS(nng_socket_get(s1, NNG_OPT_SOCKNAME, name, &sz)); + TEST_CHECK(sz > 0 && sz < 64); + TEST_CHECK(sz == strlen(name) + 1); + id = strtol(name, &end, 10); + TEST_CHECK(id == (long) s1.id); + TEST_CHECK(end != NULL && *end == '\0'); + + TEST_NNG_PASS(nng_socket_set(s1, NNG_OPT_SOCKNAME, "hello", 6)); + sz = sizeof(name); + TEST_NNG_PASS(nng_socket_get(s1, NNG_OPT_SOCKNAME, name, &sz)); + TEST_CHECK(sz == 6); + TEST_STREQUAL(name, "hello"); + + memset(name, 'A', 64); + name[64] = '\0'; + + // strings must be NULL terminated + TEST_NNG_FAIL( + nng_socket_set(s1, NNG_OPT_SOCKNAME, name, 5), NNG_EINVAL); + + TEST_NNG_PASS(nng_socket_get_string(s1, NNG_OPT_SOCKNAME, &str)); + TEST_ASSERT(str != NULL); + TEST_CHECK(strlen(str) == 5); + TEST_STREQUAL(str, "hello"); + nng_strfree(str); + + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_socket_name_oversize(void) +{ + nng_socket s1; + char name[256]; // 64 is max + size_t sz = sizeof(name); + + memset(name, 'A', sz); + TEST_NNG_PASS(nng_pair_open(&s1)); + + TEST_NNG_FAIL( + nng_socket_set(s1, NNG_OPT_SOCKNAME, name, sz), NNG_EINVAL); + name[sz - 1] = '\0'; + TEST_NNG_FAIL( + nng_socket_set(s1, NNG_OPT_SOCKNAME, name, sz), NNG_EINVAL); + + strcpy(name, "hello"); + TEST_NNG_PASS(nng_socket_set(s1, NNG_OPT_SOCKNAME, name, sz)); + sz = sizeof(name); + memset(name, 'B', sz); + TEST_NNG_PASS(nng_getopt(s1, NNG_OPT_SOCKNAME, name, &sz)); + TEST_CHECK(sz == 6); + TEST_STREQUAL(name, "hello"); + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_send_recv(void) +{ + nng_socket s1; + nng_socket s2; + int len; + size_t sz; + nng_duration to = 3000; // 3 seconds + char * buf; + char * a = "inproc://t1"; + + TEST_NNG_PASS(nng_pair1_open(&s1)); + TEST_NNG_PASS(nng_pair1_open(&s2)); + + TEST_NNG_PASS(nng_socket_set_int(s1, NNG_OPT_RECVBUF, 1)); + TEST_NNG_PASS(nng_socket_get_int(s1, NNG_OPT_RECVBUF, &len)); + TEST_CHECK(len == 1); + + TEST_NNG_PASS(nng_socket_set_int(s1, NNG_OPT_SENDBUF, 1)); + TEST_NNG_PASS(nng_socket_set_int(s2, NNG_OPT_SENDBUF, 1)); + + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, to)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, to)); + TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, to)); + TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, to)); + + TEST_NNG_PASS(nng_listen(s1, a, NULL, 0)); + TEST_NNG_PASS(nng_dial(s2, a, NULL, 0)); + + TEST_NNG_PASS(nng_send(s1, "abc", 4, 0)); + TEST_NNG_PASS(nng_recv(s2, &buf, &sz, NNG_FLAG_ALLOC)); + TEST_CHECK(buf != NULL); + TEST_CHECK(sz == 4); + TEST_CHECK(memcmp(buf, "abc", 4) == 0); + nng_free(buf, sz); + + TEST_NNG_PASS(nng_close(s1)); + TEST_NNG_PASS(nng_close(s2)); +} + +void +test_send_recv_zero_length(void) +{ + nng_socket s1; + nng_socket s2; + int len; + size_t sz; + nng_duration to = 3000; // 3 seconds + char * buf; + char * a = "inproc://send-recv-zero-length"; + + TEST_NNG_PASS(nng_pair1_open(&s1)); + TEST_NNG_PASS(nng_pair1_open(&s2)); + + TEST_NNG_PASS(nng_socket_set_int(s1, NNG_OPT_RECVBUF, 1)); + TEST_NNG_PASS(nng_getopt_int(s1, NNG_OPT_RECVBUF, &len)); + TEST_CHECK(len == 1); + + TEST_NNG_PASS(nng_socket_set_int(s1, NNG_OPT_SENDBUF, 1)); + TEST_NNG_PASS(nng_socket_set_int(s2, NNG_OPT_SENDBUF, 1)); + + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, to)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, to)); + TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, to)); + TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, to)); + + TEST_NNG_PASS(nng_listen(s1, a, NULL, 0)); + TEST_NNG_PASS(nng_dial(s2, a, NULL, 0)); + + TEST_NNG_PASS(nng_send(s1, "", 0, 0)); + TEST_NNG_PASS(nng_recv(s2, &buf, &sz, NNG_FLAG_ALLOC)); + TEST_CHECK(buf == NULL); + TEST_CHECK(sz == 0); + nng_free(buf, sz); + + TEST_NNG_PASS(nng_close(s1)); + TEST_NNG_PASS(nng_close(s2)); +} + +void +test_connection_refused(void) +{ + nng_socket s1; + + TEST_NNG_PASS(nng_pair1_open(&s1)); + TEST_NNG_FAIL(nng_dial(s1, "inproc://no", NULL, 0), NNG_ECONNREFUSED); + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_late_connection(void) +{ + char * buf; + size_t sz; + nng_socket s1; + nng_socket s2; + char * a = "inproc://asy"; + + TEST_NNG_PASS(nng_pair1_open(&s1)); + TEST_NNG_PASS(nng_pair1_open(&s2)); + + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECONNMINT, 10)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECONNMAXT, 10)); + + TEST_NNG_PASS(nng_dial(s1, a, NULL, NNG_FLAG_NONBLOCK)); + TEST_NNG_PASS(nng_listen(s2, a, NULL, 0)); + nng_msleep(100); + TEST_NNG_PASS(nng_send(s1, "abc", 4, 0)); + TEST_NNG_PASS(nng_recv(s2, &buf, &sz, NNG_FLAG_ALLOC)); + TEST_CHECK(sz == 4); + TEST_CHECK(memcmp(buf, "abc", 4) == 0); + nng_free(buf, sz); + + TEST_NNG_PASS(nng_close(s1)); + TEST_NNG_PASS(nng_close(s2)); +} + +void +test_address_busy(void) +{ + char * a = "inproc://eaddrinuse"; + nng_listener l = NNG_LISTENER_INITIALIZER; + nng_dialer d = NNG_DIALER_INITIALIZER; + nng_socket s1; + nng_socket s2; + + TEST_NNG_PASS(nng_pair1_open(&s1)); + TEST_NNG_PASS(nng_pair1_open(&s2)); + + TEST_CHECK(nng_listener_id(l) < 0); + TEST_NNG_PASS(nng_listen(s1, a, &l, 0)); + TEST_CHECK(nng_listener_id(l) > 0); + + // Cannot start another one. + TEST_NNG_FAIL(nng_listen(s1, a, NULL, 0), NNG_EADDRINUSE); + + // We can't restart it -- it's already running + TEST_NNG_FAIL(nng_listener_start(l, 0), NNG_ESTATE); + + // We can connect to it. + TEST_CHECK(nng_dialer_id(d) < 0); + TEST_NNG_PASS(nng_dial(s2, a, &d, 0)); + TEST_CHECK(nng_dialer_id(d) > 0); + + TEST_NNG_PASS(nng_close(s1)); + TEST_NNG_PASS(nng_close(s2)); +} + +void +test_endpoint_types(void) +{ + nng_socket s1; + nng_dialer d = NNG_DIALER_INITIALIZER; + nng_listener l = NNG_LISTENER_INITIALIZER; + nng_dialer d2; + nng_listener l2; + char * a = "inproc://mumble..."; + bool b; + + TEST_NNG_PASS(nng_pair1_open(&s1)); + + TEST_CHECK(nng_dialer_id(d) < 0); + TEST_NNG_PASS(nng_dialer_create(&d, s1, a)); + TEST_CHECK(nng_dialer_id(d) > 0); + + // Forge a listener + l2.id = nng_dialer_id(d); + TEST_NNG_FAIL(nng_listener_get_bool(l2, NNG_OPT_RAW, &b), NNG_ENOENT); + TEST_NNG_FAIL(nng_listener_close(l2), NNG_ENOENT); + TEST_NNG_PASS(nng_dialer_close(d)); + + TEST_CHECK(nng_listener_id(l) < 0); + TEST_NNG_PASS(nng_listener_create(&l, s1, a)); + TEST_CHECK(nng_listener_id(l) > 0); + + // Forge a dialer + d2.id = nng_listener_id(l); + TEST_NNG_FAIL(nng_dialer_get_bool(d2, NNG_OPT_RAW, &b), NNG_ENOENT); + TEST_NNG_FAIL(nng_dialer_close(d2), NNG_ENOENT); + TEST_NNG_PASS(nng_listener_close(l)); + + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_bad_url(void) +{ + nng_socket s1; + + TEST_NNG_PASS(nng_pair1_open(&s1)); + TEST_NNG_FAIL(nng_dial(s1, "bogus://1", NULL, 0), NNG_ENOTSUP); + TEST_NNG_FAIL(nng_listen(s1, "bogus://2", NULL, 0), NNG_ENOTSUP); + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_url_option(void) +{ + nng_socket s1; + char url[NNG_MAXADDRLEN]; + nng_listener l; + nng_dialer d; + size_t sz; + + TEST_NNG_PASS(nng_pair1_open(&s1)); + + // Listener + TEST_NNG_PASS(nng_listener_create(&l, s1, "inproc://url1")); + memset(url, 0, sizeof(url)); + sz = sizeof(url); + TEST_NNG_PASS(nng_listener_get(l, NNG_OPT_URL, url, &sz)); + TEST_STREQUAL(url, "inproc://url1"); + TEST_NNG_FAIL( + nng_listener_set(l, NNG_OPT_URL, url, sz), NNG_EREADONLY); + sz = sizeof(url); + + // Dialer + TEST_NNG_PASS(nng_dialer_create(&d, s1, "inproc://url2")); + TEST_NNG_PASS(nng_dialer_get(d, NNG_OPT_URL, url, &sz)); + TEST_STREQUAL(url, "inproc://url2"); + TEST_NNG_FAIL(nng_dialer_set(d, NNG_OPT_URL, url, sz), NNG_EREADONLY); + + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_listener_options(void) +{ + nng_socket s1; + nng_listener l; + size_t sz; + + TEST_NNG_PASS(nng_pair1_open(&s1)); + +#ifndef NNG_ELIDE_DEPRECATED + // Create a listener with the specified options + TEST_NNG_PASS(nng_socket_set_size(s1, NNG_OPT_RECVMAXSZ, 543)); + TEST_NNG_PASS(nng_listener_create(&l, s1, "inproc://listener_opts")); + TEST_NNG_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &sz)); + TEST_CHECK(sz == 543); + + // Verify endpoint overrides + TEST_NNG_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 678)); + TEST_NNG_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &sz)); + TEST_CHECK(sz == 678); + TEST_NNG_PASS(nng_socket_get_size(s1, NNG_OPT_RECVMAXSZ, &sz)); + TEST_CHECK(sz == 543); + + // And socket overrides again + TEST_NNG_PASS(nng_socket_set_size(s1, NNG_OPT_RECVMAXSZ, 911)); + TEST_NNG_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &sz)); + TEST_CHECK(sz == 911); +#else + TEST_NNG_PASS(nng_listener_create(&l, s1, "inproc://listener_opts")); + TEST_NNG_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 678)); + TEST_NNG_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &sz)); + TEST_CHECK(sz == 678); +#endif + + // Cannot set invalid options + TEST_NNG_FAIL(nng_listener_set_size(l, "BAD_OPT", 1), NNG_ENOTSUP); + TEST_NNG_FAIL( + nng_listener_set_bool(l, NNG_OPT_RECVMAXSZ, true), NNG_EBADTYPE); + TEST_NNG_FAIL( + nng_listener_set(l, NNG_OPT_RECVMAXSZ, &sz, 1), NNG_EINVAL); + + // Cannot set inappropriate options + TEST_NNG_FAIL( + nng_listener_set_string(l, NNG_OPT_SOCKNAME, "1"), NNG_ENOTSUP); + + TEST_NNG_FAIL( + nng_listener_set_bool(l, NNG_OPT_RAW, true), NNG_ENOTSUP); + TEST_NNG_FAIL( + nng_listener_set_ms(l, NNG_OPT_RECONNMINT, 1), NNG_ENOTSUP); + TEST_NNG_FAIL(nng_listener_set_string(l, NNG_OPT_SOCKNAME, "bogus"), + NNG_ENOTSUP); + + // Read only options + TEST_NNG_FAIL(nng_listener_set_string(l, NNG_OPT_URL, "inproc://junk"), + NNG_EREADONLY); + + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_dialer_options(void) +{ + nng_socket s1; + nng_dialer d; + size_t sz; + + TEST_NNG_PASS(nng_pair1_open(&s1)); + +#ifndef NNG_ELIDE_DEPRECATED + // NOTE: This test will fail if eliding deprecated behavior. + // Create a dialer with the specified options + TEST_NNG_PASS(nng_socket_set_size(s1, NNG_OPT_RECVMAXSZ, 543)); + TEST_NNG_PASS(nng_dialer_create(&d, s1, "inproc://dialer_opts")); + TEST_NNG_PASS(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &sz)); + TEST_CHECK(sz == 543); + + // Verify endpoint overrides + TEST_NNG_PASS(nng_dialer_set_size(d, NNG_OPT_RECVMAXSZ, 678)); + TEST_NNG_PASS(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &sz)); + TEST_CHECK(sz == 678); + TEST_NNG_PASS(nng_socket_get_size(s1, NNG_OPT_RECVMAXSZ, &sz)); + TEST_CHECK(sz == 543); + + // And socket overrides again + TEST_NNG_PASS(nng_socket_set_size(s1, NNG_OPT_RECVMAXSZ, 911)); + TEST_NNG_PASS(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &sz)); + TEST_CHECK(sz == 911); +#else + TEST_NNG_PASS(nng_dialer_create(&d, s1, "inproc://dialer_opts")); + TEST_NNG_PASS(nng_dialer_set_size(d, NNG_OPT_RECVMAXSZ, 678)); + TEST_NNG_PASS(nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &sz)); + TEST_CHECK(sz == 678); +#endif + + // Cannot set invalid options + TEST_NNG_FAIL(nng_dialer_set_size(d, "BAD_OPT", 1), NNG_ENOTSUP); + TEST_NNG_FAIL( + nng_dialer_set_bool(d, NNG_OPT_RECVMAXSZ, true), NNG_EBADTYPE); + TEST_NNG_FAIL( + nng_dialer_set(d, NNG_OPT_RECVMAXSZ, &sz, 1), NNG_EINVAL); + + // Cannot set inappropriate options + TEST_NNG_FAIL( + nng_dialer_set_string(d, NNG_OPT_SOCKNAME, "1"), NNG_ENOTSUP); + TEST_NNG_FAIL(nng_dialer_set_bool(d, NNG_OPT_RAW, true), NNG_ENOTSUP); + TEST_NNG_FAIL(nng_dialer_set_ms(d, NNG_OPT_SENDTIMEO, 1), NNG_ENOTSUP); + TEST_NNG_FAIL( + nng_dialer_set_string(d, NNG_OPT_SOCKNAME, "bogus"), NNG_ENOTSUP); + + // Read only options + TEST_NNG_FAIL(nng_dialer_set_string(d, NNG_OPT_URL, "inproc://junk"), + NNG_EREADONLY); + + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_endpoint_absent_options(void) +{ + size_t s; + int i; + nng_duration t; + bool b; + nng_dialer d; + nng_listener l; + d.id = 1999; + l.id = 1999; + + TEST_NNG_FAIL( + nng_dialer_set_size(d, NNG_OPT_RECVMAXSZ, 10), NNG_ENOENT); + TEST_NNG_FAIL( + nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 10), NNG_ENOENT); + + TEST_NNG_FAIL(nng_dialer_get_bool(d, NNG_OPT_RAW, &b), NNG_ENOENT); + TEST_NNG_FAIL(nng_listener_get_bool(l, NNG_OPT_RAW, &b), NNG_ENOENT); + + TEST_NNG_FAIL( + nng_dialer_get_size(d, NNG_OPT_RECVMAXSZ, &s), NNG_ENOENT); + TEST_NNG_FAIL( + nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &s), NNG_ENOENT); + + TEST_NNG_FAIL(nng_dialer_get_int(d, NNG_OPT_RAW, &i), NNG_ENOENT); + TEST_NNG_FAIL(nng_listener_get_int(l, NNG_OPT_RAW, &i), NNG_ENOENT); + + TEST_NNG_FAIL(nng_dialer_get_ms(d, NNG_OPT_RECVTIMEO, &t), NNG_ENOENT); + TEST_NNG_FAIL( + nng_listener_get_ms(l, NNG_OPT_SENDTIMEO, &t), NNG_ENOENT); +} + +void +test_timeout_options(void) +{ + nng_socket s1; + nng_duration to; + size_t sz; + + char *cases[] = { + NNG_OPT_RECVTIMEO, + NNG_OPT_SENDTIMEO, + NNG_OPT_RECONNMAXT, + NNG_OPT_RECONNMINT, + NULL, + }; + + TEST_NNG_PASS(nng_pair1_open(&s1)); + for (int i = 0; cases[i] != NULL; i++) { + bool b; + TEST_CASE(cases[i]); + + // Can't receive a duration into zero bytes. + sz = 0; + TEST_NNG_FAIL( + nng_socket_get(s1, cases[i], &to, &sz), NNG_EINVAL); + + // Type mismatches + TEST_NNG_FAIL( + nng_socket_get_bool(s1, cases[i], &b), NNG_EBADTYPE); + sz = 1; + TEST_NNG_FAIL( + nng_socket_get(s1, cases[i], &b, &sz), NNG_EINVAL); + + // Can set a valid duration + TEST_NNG_PASS(nng_socket_set_ms(s1, cases[i], 1234)); + TEST_NNG_PASS(nng_socket_get_ms(s1, cases[i], &to)); + TEST_CHECK(to == 1234); + + to = 0; + sz = sizeof(to); + TEST_NNG_PASS(nng_socket_get(s1, cases[i], &to, &sz)); + TEST_CHECK(to == 1234); + TEST_CHECK(sz == sizeof(to)); + + // Can't set a negative duration + TEST_NNG_FAIL(nng_socket_set_ms(s1, cases[i], -5), NNG_EINVAL); + + // Can't pass a buf too small for duration + sz = sizeof(to) - 1; + to = 1; + TEST_NNG_FAIL( + nng_socket_set(s1, cases[i], &to, sz), NNG_EINVAL); + } + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_size_options(void) +{ + nng_socket s1; + size_t val; + size_t sz; + char * opt; + + char *cases[] = { + NNG_OPT_RECVMAXSZ, + NULL, + }; + + TEST_NNG_PASS(nng_pair1_open(&s1)); + for (int i = 0; (opt = cases[i]) != NULL; i++) { + TEST_CASE(opt); + + // Can't receive a size into zero bytes. + sz = 0; + TEST_NNG_FAIL(nng_socket_get(s1, opt, &val, &sz), NNG_EINVAL); + + // Can set a valid duration + TEST_NNG_PASS(nng_socket_set_size(s1, opt, 1234)); + TEST_NNG_PASS(nng_socket_get_size(s1, opt, &val)); + TEST_CHECK(val == 1234); + + val = 0; + sz = sizeof(val); + TEST_NNG_PASS(nng_socket_get(s1, opt, &val, &sz)); + TEST_CHECK(val == 1234); + TEST_CHECK(sz == sizeof(val)); + + // Can't pass a buf too small for size + sz = sizeof(val) - 1; + val = 1; + TEST_NNG_FAIL(nng_socket_set(s1, opt, &val, sz), NNG_EINVAL); + + // We limit the limit to 4GB. Clear it if you want to + // ship more than 4GB at a time. +#if defined(_WIN64) || defined(_LP64) + val = 0x10000u; + val <<= 30u; + TEST_NNG_FAIL(nng_socket_set_size(s1, opt, val), NNG_EINVAL); + TEST_NNG_PASS(nng_socket_get_size(s1, opt, &val)); + TEST_CHECK(val == 1234); +#endif + } + TEST_NNG_PASS(nng_close(s1)); +} + +TEST_LIST = { + { "recv timeout", test_recv_timeout }, + { "recv non-block", test_recv_nonblock }, + { "send timeout", test_send_timeout }, + { "send non-block", test_send_nonblock }, + { "read only options", test_readonly_options }, + { "socket base", test_socket_base }, + { "socket name", test_socket_name }, + { "socket name oversize", test_socket_name_oversize }, + { "send recv", test_send_recv }, + { "send recv zero length", test_send_recv_zero_length }, + { "connection refused", test_connection_refused }, + { "late connection", test_late_connection }, + { "address busy", test_address_busy }, + { "bad url", test_bad_url }, + { "url option", test_url_option }, + { "listener options", test_listener_options }, + { "dialer options", test_dialer_options }, + { "timeout options", test_timeout_options }, + { "size options", test_size_options }, + { "endpoint absent options", test_endpoint_absent_options }, + { "endpoint types", test_endpoint_types }, + + { NULL, NULL }, +}; diff --git a/tests/url.c b/src/core/url_test.c index 847b7df3..847b7df3 100644 --- a/tests/url.c +++ b/src/core/url_test.c diff --git a/src/platform/CMakeLists.txt b/src/platform/CMakeLists.txt new file mode 100644 index 00000000..2b2288e1 --- /dev/null +++ b/src/platform/CMakeLists.txt @@ -0,0 +1,17 @@ +# +# Copyright 2020 Staysail Systems, Inc. <info@staystail.tech> +# +# This software is supplied under the terms of the MIT License, a +# copy of which should be located in the distribution where this +# file was obtained (LICENSE.txt). A copy of the license may also be +# found online at https://opensource.org/licenses/MIT. +# + +# Platforms. +nng_directory(platform) + +add_subdirectory(posix) +add_subdirectory(windows) + +nng_test(platform_test) +nng_test(resolver_test)
\ No newline at end of file diff --git a/tests/platform.c b/src/platform/platform_test.c index 228baf5e..e7dcabaa 100644 --- a/tests/platform.c +++ b/src/platform/platform_test.c @@ -15,7 +15,7 @@ #include "acutest.h" -struct addarg { +struct add_arg { int cnt; nng_mtx *mx; nng_cv * cv; @@ -24,7 +24,7 @@ struct addarg { void add(void *arg) { - struct addarg *aa = arg; + struct add_arg *aa = arg; nng_mtx_lock(aa->mx); aa->cnt++; @@ -105,9 +105,9 @@ test_mutex(void) void test_thread(void) { - nng_thread * thr; - int rv; - struct addarg aa; + nng_thread * thr; + int rv; + struct add_arg aa; TEST_CHECK(nng_mtx_alloc(&aa.mx) == 0); TEST_CHECK(nng_cv_alloc(&aa.cv, aa.mx) == 0); @@ -122,11 +122,11 @@ test_thread(void) } void -test_condvar(void) +test_cond_var(void) { nng_thread * thr; int rv; - struct addarg aa; + struct add_arg aa; TEST_CHECK(nng_mtx_alloc(&aa.mx) == 0); TEST_CHECK(nng_cv_alloc(&aa.cv, aa.mx) == 0); @@ -175,7 +175,7 @@ TEST_LIST = { { "clock", test_clock }, { "mutex", test_mutex }, { "thread", test_thread }, - { "condvar", test_condvar }, + { "cond var", test_cond_var }, { "random", test_random }, { NULL, NULL }, }; diff --git a/src/platform/posix/posix_file.c b/src/platform/posix/posix_file.c index 5d918d6b..d5fb5016 100644 --- a/src/platform/posix/posix_file.c +++ b/src/platform/posix/posix_file.c @@ -1,5 +1,5 @@ // -// Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> +// Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // // This software is supplied under the terms of the MIT License, a @@ -323,15 +323,12 @@ nni_plat_temp_dir(void) char * nni_plat_join_dir(const char *prefix, const char *suffix) { - char * newdir; - size_t len; + char *result; - len = strlen(prefix) + strlen(suffix) + 2; - newdir = nni_alloc(strlen(prefix) + strlen(suffix) + 2); - if (newdir != NULL) { - (void) snprintf(newdir, len, "%s/%s", prefix, suffix); + if (nni_asprintf(&result, "%s/%s", prefix, suffix) == 0) { + return (result); } - return (newdir); + return (NULL); } #endif // NNG_PLATFORM_POSIX diff --git a/tests/resolv.c b/src/platform/resolver_test.c index 43168cdb..43168cdb 100644 --- a/tests/resolv.c +++ b/src/platform/resolver_test.c diff --git a/src/protocol/CMakeLists.txt b/src/protocol/CMakeLists.txt new file mode 100644 index 00000000..fd480523 --- /dev/null +++ b/src/protocol/CMakeLists.txt @@ -0,0 +1,20 @@ +# +# Copyright 2020 Staysail Systems, Inc. <info@staystail.tech> +# +# This software is supplied under the terms of the MIT License, a +# copy of which should be located in the distribution where this +# file was obtained (LICENSE.txt). A copy of the license may also be +# found online at https://opensource.org/licenses/MIT. +# + +# Protocols. +nng_directory(protocol) + +add_subdirectory(bus0) +add_subdirectory(pair0) +add_subdirectory(pair1) +add_subdirectory(pipeline0) +add_subdirectory(pubsub0) +add_subdirectory(reqrep0) +add_subdirectory(survey0) + diff --git a/src/protocol/bus0/CMakeLists.txt b/src/protocol/bus0/CMakeLists.txt index 1115e2ec..01c0b05b 100644 --- a/src/protocol/bus0/CMakeLists.txt +++ b/src/protocol/bus0/CMakeLists.txt @@ -1,5 +1,5 @@ # -# Copyright 2019 Staysail Systems, Inc. <info@staysail.tech> +# Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> # Copyright 2018 Capitar IT Group BV <info@capitar.com> # # This software is supplied under the terms of the MIT License, a @@ -9,9 +9,10 @@ # # Bus protocol -option (NNG_PROTO_BUS0 "Enable BUSv0 protocol." ON) -mark_as_advanced(NNG_PROTO_BUS0) +nng_directory(bus0) nng_sources_if(NNG_PROTO_BUS0 bus.c) nng_headers_if(NNG_PROTO_BUS0 nng/protocol/bus0/bus.h) -nng_defines_if(NNG_PROTO_BUS0 NNG_HAVE_BUS0)
\ No newline at end of file +nng_defines_if(NNG_PROTO_BUS0 NNG_HAVE_BUS0) + +nng_test(bug1247_test)
\ No newline at end of file diff --git a/tests/bug1247.c b/src/protocol/bus0/bug1247_test.c index 6f418f53..6f418f53 100644 --- a/tests/bug1247.c +++ b/src/protocol/bus0/bug1247_test.c diff --git a/src/protocol/pair0/CMakeLists.txt b/src/protocol/pair0/CMakeLists.txt index c3da1b07..b12583ab 100644 --- a/src/protocol/pair0/CMakeLists.txt +++ b/src/protocol/pair0/CMakeLists.txt @@ -1,5 +1,5 @@ # -# Copyright 2019 Staysail Systems, Inc. <info@staysail.tech> +# Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> # Copyright 2018 Capitar IT Group BV <info@capitar.com> # # This software is supplied under the terms of the MIT License, a @@ -9,8 +9,7 @@ # # PAIRv0 protocol -option (NNG_PROTO_PAIR0 "Enable PAIRv0 protocol." ON) -mark_as_advanced(NNG_PROTO_PAIR0) +nng_directory(pair0) nng_sources_if(NNG_PROTO_PAIR0 pair.c) nng_headers_if(NNG_PROTO_PAIR0 nng/protocol/pair0/pair.h) diff --git a/src/protocol/pair1/CMakeLists.txt b/src/protocol/pair1/CMakeLists.txt index f586fabe..12e12607 100644 --- a/src/protocol/pair1/CMakeLists.txt +++ b/src/protocol/pair1/CMakeLists.txt @@ -9,12 +9,12 @@ # # PAIRv1 protocol -option (NNG_PROTO_PAIR1 "Enable PAIRv1 protocol." ON) -mark_as_advanced(NNG_PROTO_PAIR1) +nng_directory(pair1) # XXX: break pair1_poly into an ifdef. nng_sources_if(NNG_PROTO_PAIR1 pair.c pair1_poly.c) nng_headers_if(NNG_PROTO_PAIR1 nng/protocol/pair1/pair.h) nng_defines_if(NNG_PROTO_PAIR1 NNG_HAVE_PAIR1) + nng_test(pair1_test) nng_test(pair1_poly_test)
\ No newline at end of file diff --git a/src/protocol/pipeline0/CMakeLists.txt b/src/protocol/pipeline0/CMakeLists.txt index 0e211cf5..4f591450 100644 --- a/src/protocol/pipeline0/CMakeLists.txt +++ b/src/protocol/pipeline0/CMakeLists.txt @@ -9,11 +9,7 @@ # # Pipeline protocol -option (NNG_PROTO_PUSH0 "Enable PUSHv0 protocol." ON) -mark_as_advanced(NNG_PROTO_PUSH0) - -option (NNG_PROTO_PULL0 "Enable PULLv0 protocol." ON) -mark_as_advanced(NNG_PROTO_PULL0) +nng_directory(pipeline0) nng_sources_if(NNG_PROTO_PUSH0 push.c) nng_headers_if(NNG_PROTO_PUSH0 nng/protocol/pipeline0/push.h) diff --git a/src/protocol/pubsub0/CMakeLists.txt b/src/protocol/pubsub0/CMakeLists.txt index 8687de4e..160b7462 100644 --- a/src/protocol/pubsub0/CMakeLists.txt +++ b/src/protocol/pubsub0/CMakeLists.txt @@ -9,11 +9,7 @@ # # Pub/Sub protocol -option (NNG_PROTO_PUB0 "Enable PUBv0 protocol." ON) -mark_as_advanced(NNG_PROTO_PUB0) - -option (NNG_PROTO_SUB0 "Enable SUBv0 protocol." ON) -mark_as_advanced(NNG_PROTO_SUB0) +nng_directory(pubsub0) nng_sources_if(NNG_PROTO_PUB0 pub.c) nng_headers_if(NNG_PROTO_PUB0 nng/protocol/pubsub0/pub.h) diff --git a/src/protocol/reqrep0/CMakeLists.txt b/src/protocol/reqrep0/CMakeLists.txt index 46eb7abf..a3cecfd0 100644 --- a/src/protocol/reqrep0/CMakeLists.txt +++ b/src/protocol/reqrep0/CMakeLists.txt @@ -9,11 +9,7 @@ # # Req/Rep protocol -option(NNG_PROTO_REQ0 "Enable REQv0 protocol." ON) -mark_as_advanced(NNG_PROTO_REQ0) - -option(NNG_PROTO_REP0 "Enable REPv0 protocol." ON) -mark_as_advanced(NNG_PROTO_REP0) +nng_directory(reqrep0) nng_sources_if(NNG_PROTO_REQ0 req.c xreq.c) nng_headers_if(NNG_PROTO_REQ0 nng/protocol/reqrep0/req.h) diff --git a/src/protocol/survey0/CMakeLists.txt b/src/protocol/survey0/CMakeLists.txt index 6b3c8277..b5daca41 100644 --- a/src/protocol/survey0/CMakeLists.txt +++ b/src/protocol/survey0/CMakeLists.txt @@ -9,11 +9,7 @@ # # Surveyor/Respondent protocol -option (NNG_PROTO_RESPONDENT0 "Enable RESPONDENTv0 protocol." ON) -mark_as_advanced(NNG_PROTO_RESPONDENT0) - -option (NNG_PROTO_SURVEYOR0 "Enable SURVEYORv0 protocol." ON) -mark_as_advanced(NNG_PROTO_SURVEYOR0) +nng_directory(survey0) nng_sources_if(NNG_PROTO_SURVEYOR0 survey.c xsurvey.c) nng_headers_if(NNG_PROTO_SURVEYOR0 nng/protocol/survey0/survey.h) diff --git a/src/supplemental/websocket/wssfile_test.c b/src/supplemental/websocket/wssfile_test.c index 8a0f95b2..3f69cadc 100644 --- a/src/supplemental/websocket/wssfile_test.c +++ b/src/supplemental/websocket/wssfile_test.c @@ -137,7 +137,7 @@ init_listener_wss_file(nng_listener l) nni_strfree(pth); } -void +static void test_invalid_verify(void) { uint16_t port = testutil_next_port(); @@ -180,14 +180,14 @@ test_invalid_verify(void) TEST_NNG_PASS(nng_close(s2)); } -void +static void test_no_verify(void) { nng_socket s1; nng_socket s2; nng_listener l; nng_dialer d; - char addr[NNG_MAXADDRLEN]; + char addr[64]; nng_msg * msg; nng_pipe p; bool b; @@ -232,7 +232,7 @@ test_no_verify(void) TEST_NNG_PASS(nng_close(s2)); } -void +static void test_verify_works(void) { nng_socket s1; @@ -280,7 +280,7 @@ test_verify_works(void) TEST_NNG_PASS(nng_close(s2)); } -void +static void test_cert_file_not_present(void) { nng_socket s1; diff --git a/src/transport/CMakeLists.txt b/src/transport/CMakeLists.txt new file mode 100644 index 00000000..add8a9c9 --- /dev/null +++ b/src/transport/CMakeLists.txt @@ -0,0 +1,19 @@ +# +# Copyright 2020 Staysail Systems, Inc. <info@staystail.tech> +# +# This software is supplied under the terms of the MIT License, a +# copy of which should be located in the distribution where this +# file was obtained (LICENSE.txt). A copy of the license may also be +# found online at https://opensource.org/licenses/MIT. +# + +# Transports. +nng_directory(transport) + +add_subdirectory(inproc) +add_subdirectory(ipc) +add_subdirectory(tcp) +add_subdirectory(tls) +add_subdirectory(ws) +add_subdirectory(zerotier) + diff --git a/src/transport/inproc/CMakeLists.txt b/src/transport/inproc/CMakeLists.txt index e440fe31..317686bb 100644 --- a/src/transport/inproc/CMakeLists.txt +++ b/src/transport/inproc/CMakeLists.txt @@ -1,5 +1,5 @@ # -# Copyright 2019 Staysail Systems, Inc. <info@staysail.tech> +# Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> # Copyright 2018 Capitar IT Group BV <info@capitar.com> # # This software is supplied under the terms of the MIT License, a @@ -9,8 +9,7 @@ # # inproc protocol -option (NNG_TRANSPORT_INPROC "Enable inproc transport." ON) -mark_as_advanced(NNG_TRANSPORT_INPROC) +nng_directory(inproc) nng_sources_if(NNG_TRANSPORT_INPROC inproc.c) nng_headers_if(NNG_TRANSPORT_INPROC nng/transport/inproc/inproc.h) diff --git a/src/transport/ipc/CMakeLists.txt b/src/transport/ipc/CMakeLists.txt index 00e81d54..c9927f75 100644 --- a/src/transport/ipc/CMakeLists.txt +++ b/src/transport/ipc/CMakeLists.txt @@ -9,8 +9,7 @@ # # ipc protocol -option (NNG_TRANSPORT_IPC "Enable IPC transport." ON) -mark_as_advanced(NNG_TRANSPORT_IPC) +nng_directory(ipc) nng_sources_if(NNG_TRANSPORT_IPC ipc.c) nng_headers_if(NNG_TRANSPORT_IPC nng/transport/ipc/ipc.h) diff --git a/src/transport/ipc/ipc_test.c b/src/transport/ipc/ipc_test.c index 7bf3d2ec..3240b21d 100644 --- a/src/transport/ipc/ipc_test.c +++ b/src/transport/ipc/ipc_test.c @@ -1,5 +1,6 @@ // // Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> +// Copyright 2018 Cody Piersall <cody.piersall@gmail.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this @@ -107,27 +108,24 @@ test_ipc_listener_perms(void) TEST_NNG_PASS(nng_listener_create(&l, s, addr)); #ifdef _WIN32 - TEST_NNG_FAIL( - nng_listener_setopt_int(l, NNG_OPT_IPC_PERMISSIONS, 0444), + TEST_NNG_FAIL(nng_listener_set_int(l, NNG_OPT_IPC_PERMISSIONS, 0444), NNG_ENOTSUP); #else path = &addr[strlen("ipc://")]; // Attempt to set invalid permissions fails. TEST_NNG_FAIL( - nng_listener_setopt_int(l, NNG_OPT_IPC_PERMISSIONS, S_IFREG), + nng_listener_set_int(l, NNG_OPT_IPC_PERMISSIONS, S_IFREG), NNG_EINVAL); - TEST_NNG_PASS( - nng_listener_setopt_int(l, NNG_OPT_IPC_PERMISSIONS, 0444)); + TEST_NNG_PASS(nng_listener_set_int(l, NNG_OPT_IPC_PERMISSIONS, 0444)); TEST_NNG_PASS(nng_listener_start(l, 0)); TEST_CHECK(stat(path, &st) == 0); TEST_CHECK((st.st_mode & 0777) == 0444); // Now that it's running, we cannot set it. TEST_NNG_FAIL( - nng_listener_setopt_int(l, NNG_OPT_IPC_PERMISSIONS, 0644), - NNG_EBUSY); + nng_listener_set_int(l, NNG_OPT_IPC_PERMISSIONS, 0644), NNG_EBUSY); #endif TEST_NNG_PASS(nng_close(s)); @@ -146,19 +144,19 @@ test_ipc_listener_properties(void) TEST_NNG_PASS(nng_pair0_open(&s)); TEST_NNG_PASS(nng_listen(s, addr, &l, 0)); - TEST_NNG_PASS(nng_listener_getopt_sockaddr(l, NNG_OPT_LOCADDR, &sa)); + TEST_NNG_PASS(nng_listener_get_addr(l, NNG_OPT_LOCADDR, &sa)); TEST_CHECK(sa.s_ipc.sa_family == NNG_AF_IPC); TEST_STREQUAL(sa.s_ipc.sa_path, addr + strlen("ipc://")); - TEST_NNG_FAIL(nng_listener_setopt(l, NNG_OPT_LOCADDR, &sa, sizeof(sa)), + TEST_NNG_FAIL(nng_listener_set(l, NNG_OPT_LOCADDR, &sa, sizeof(sa)), NNG_EREADONLY); z = 8192; - TEST_NNG_PASS(nng_listener_setopt_size(l, NNG_OPT_RECVMAXSZ, z)); + TEST_NNG_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, z)); z = 0; - TEST_NNG_PASS(nng_listener_getopt_size(l, NNG_OPT_RECVMAXSZ, &z)); + TEST_NNG_PASS(nng_listener_get_size(l, NNG_OPT_RECVMAXSZ, &z)); TEST_CHECK(z == 8192); TEST_NNG_FAIL( - nng_listener_setopt_bool(l, NNG_OPT_RAW, true), NNG_ENOTSUP); + nng_listener_set_bool(l, NNG_OPT_RAW, true), NNG_ENOTSUP); TEST_NNG_PASS(nng_close(s)); } @@ -242,10 +240,10 @@ test_abstract_auto_bind(void) TEST_NNG_PASS(nng_pair0_open(&s1)); TEST_NNG_PASS(nng_pair0_open(&s2)); - TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, 1000)); - TEST_NNG_PASS(nng_setopt_ms(s2, NNG_OPT_SENDTIMEO, 1000)); - TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, 1000)); - TEST_NNG_PASS(nng_setopt_ms(s2, NNG_OPT_RECVTIMEO, 1000)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 1000)); + TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, 1000)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 1000)); + TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, 1000)); TEST_NNG_PASS(nng_listen(s1, addr, &l, 0)); TEST_NNG_PASS(nng_listener_get_addr(l, NNG_OPT_LOCADDR, &sa)); @@ -287,8 +285,8 @@ test_abstract_too_long(void) TEST_ASSERT(strlen(addr) == 255); TEST_NNG_PASS(nng_pair0_open(&s1)); - TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, 1000)); - TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, 1000)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 1000)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 1000)); TEST_NNG_FAIL(nng_listen(s1, addr, NULL, 0), NNG_EADDRINVAL); TEST_NNG_FAIL( nng_dial(s1, addr, NULL, NNG_FLAG_NONBLOCK), NNG_EADDRINVAL); @@ -317,10 +315,10 @@ test_abstract_null(void) TEST_NNG_PASS(nng_pair0_open(&s1)); TEST_NNG_PASS(nng_pair0_open(&s2)); - TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, 1000)); - TEST_NNG_PASS(nng_setopt_ms(s2, NNG_OPT_SENDTIMEO, 1000)); - TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, 1000)); - TEST_NNG_PASS(nng_setopt_ms(s2, NNG_OPT_RECVTIMEO, 1000)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 1000)); + TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, 1000)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 1000)); + TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, 1000)); TEST_NNG_PASS(nng_listen(s1, addr, &l, 0)); TEST_NNG_PASS(nng_listener_get_addr(l, NNG_OPT_LOCADDR, &sa)); @@ -372,10 +370,10 @@ test_unix_alias(void) TEST_NNG_PASS(nng_pair0_open(&s1)); TEST_NNG_PASS(nng_pair0_open(&s2)); - TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, 1000)); - TEST_NNG_PASS(nng_setopt_ms(s2, NNG_OPT_SENDTIMEO, 1000)); - TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, 1000)); - TEST_NNG_PASS(nng_setopt_ms(s2, NNG_OPT_RECVTIMEO, 1000)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 1000)); + TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_SENDTIMEO, 1000)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_RECVTIMEO, 1000)); + TEST_NNG_PASS(nng_socket_set_ms(s2, NNG_OPT_RECVTIMEO, 1000)); TEST_NNG_PASS(nng_listen(s1, addr1, NULL, 0)); TEST_NNG_PASS(nng_dial(s2, addr2, NULL, 0)); diff --git a/src/transport/tcp/CMakeLists.txt b/src/transport/tcp/CMakeLists.txt index f3daa0a4..d6022329 100644 --- a/src/transport/tcp/CMakeLists.txt +++ b/src/transport/tcp/CMakeLists.txt @@ -1,5 +1,5 @@ # -# Copyright 2019 Staysail Systems, Inc. <info@staysail.tech> +# Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> # Copyright 2018 Capitar IT Group BV <info@capitar.com> # # This software is supplied under the terms of the MIT License, a @@ -9,9 +9,9 @@ # # TCP protocol -option (NNG_TRANSPORT_TCP "Enable TCP transport." ON) -mark_as_advanced(NNG_TRANSPORT_TCP) +nng_directory(tcp) nng_sources_if(NNG_TRANSPORT_TCP tcp.c) nng_headers_if(NNG_TRANSPORT_TCP nng/transport/tcp/tcp.h) -nng_defines_if(NNG_TRANSPORT_TCP NNG_TRANSPORT_TCP)
\ No newline at end of file +nng_defines_if(NNG_TRANSPORT_TCP NNG_TRANSPORT_TCP) +nng_test(tcp_test)
\ No newline at end of file diff --git a/src/transport/tcp/tcp_test.c b/src/transport/tcp/tcp_test.c new file mode 100644 index 00000000..88b77ab4 --- /dev/null +++ b/src/transport/tcp/tcp_test.c @@ -0,0 +1,304 @@ +// +// Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> +// Copyright 2018 Capitar IT Group BV <info@capitar.com> +// Copyright 2018 Devolutions <info@devolutions.net> +// Copyright 2018 Cody Piersall <cody.piersall@gmail.com> +// +// This software is supplied under the terms of the MIT License, a +// copy of which should be located in the distribution where this +// file was obtained (LICENSE.txt). A copy of the license may also be +// found online at https://opensource.org/licenses/MIT. +// + +#include <nng/nng.h> +#include <nng/protocol/pair0/pair.h> +#include <nng/supplemental/util/platform.h> + +#include <acutest.h> +#include <testutil.h> + +// TCP tests. + +static void +test_tcp_wild_card_connect_fail(void) +{ + nng_socket s; + char addr[NNG_MAXADDRLEN]; + + TEST_NNG_PASS(nng_pair0_open(&s)); + (void) snprintf( + addr, sizeof(addr), "tcp://*:%u", testutil_next_port()); + TEST_NNG_FAIL(nng_dial(s, addr, NULL, 0), NNG_EADDRINVAL); + TEST_NNG_PASS(nng_close(s)); +} + +void +test_tcp_wild_card_bind(void) +{ + nng_socket s1; + nng_socket s2; + char addr[NNG_MAXADDRLEN]; + uint16_t port; + + port = testutil_next_port(); + + TEST_NNG_PASS(nng_pair0_open(&s1)); + TEST_NNG_PASS(nng_pair0_open(&s2)); + (void) snprintf(addr, sizeof(addr), "tcp4://*:%u", port); + TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0)); + // reset port back one + (void) snprintf(addr, sizeof(addr), "tcp://127.0.0.1:%u", port); + TEST_NNG_PASS(nng_dial(s2, addr, NULL, 0)); + TEST_NNG_PASS(nng_close(s2)); + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_tcp_local_address_connect(void) +{ + + nng_socket s1; + nng_socket s2; + char addr[NNG_MAXADDRLEN]; + uint16_t port; + + TEST_NNG_PASS(nng_pair0_open(&s1)); + TEST_NNG_PASS(nng_pair0_open(&s2)); + port = testutil_next_port(); + (void) snprintf(addr, sizeof(addr), "tcp://127.0.0.1:%u", port); + TEST_NNG_PASS(nng_listen(s1, addr, NULL, 0)); + // reset port back one + (void) snprintf( + addr, sizeof(addr), "tcp://127.0.0.1;127.0.0.1:%u", port); + TEST_NNG_PASS(nng_dial(s2, addr, NULL, 0)); + TEST_NNG_PASS(nng_close(s2)); + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_tcp_port_zero_bind(void) +{ + nng_socket s1; + nng_socket s2; + nng_sockaddr sa; + nng_listener l; + char * addr; + + TEST_NNG_PASS(nng_pair0_open(&s1)); + TEST_NNG_PASS(nng_pair_open(&s2)); + TEST_NNG_PASS(nng_listen(s1, "tcp://127.0.0.1:0", &l, 0)); + TEST_NNG_PASS(nng_listener_get_string(l, NNG_OPT_URL, &addr)); + TEST_CHECK(memcmp(addr, "tcp://", 6) == 0); + TEST_NNG_PASS(nng_listener_get_addr(l, NNG_OPT_LOCADDR, &sa)); + TEST_CHECK(sa.s_in.sa_family == NNG_AF_INET); + TEST_CHECK(sa.s_in.sa_port != 0); + TEST_CHECK(sa.s_in.sa_addr = testutil_htonl(0x7f000001)); + TEST_NNG_PASS(nng_dial(s2, addr, NULL, 0)); + nng_strfree(addr); + TEST_NNG_PASS(nng_close(s2)); + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_tcp_bad_local_interface(void) +{ + nng_socket s1; + + TEST_NNG_PASS(nng_pair0_open(&s1)); + TEST_NNG_FAIL(nng_dial(s1, "tcp://bogus1;127.0.0.1:80", NULL, 0), + NNG_EADDRINVAL); + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_tcp_non_local_address(void) +{ + nng_socket s1; + + TEST_NNG_PASS(nng_pair0_open(&s1)); + TEST_NNG_FAIL(nng_dial(s1, "tcp://8.8.8.8;127.0.0.1:80", NULL, 0), + NNG_EADDRINVAL); + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_tcp_malformed_address(void) +{ + nng_socket s1; + + TEST_NNG_PASS(nng_pair0_open(&s1)); + TEST_NNG_FAIL( + nng_dial(s1, "tcp://127.0.0.1", NULL, 0), NNG_EADDRINVAL); + TEST_NNG_FAIL( + nng_dial(s1, "tcp://127.0.0.1.32", NULL, 0), NNG_EADDRINVAL); + TEST_NNG_FAIL( + nng_dial(s1, "tcp://127.0.x.1.32", NULL, 0), NNG_EADDRINVAL); + TEST_NNG_FAIL( + nng_listen(s1, "tcp://127.0.0.1.32", NULL, 0), NNG_EADDRINVAL); + TEST_NNG_FAIL( + nng_listen(s1, "tcp://127.0.x.1.32", NULL, 0), NNG_EADDRINVAL); + TEST_NNG_PASS(nng_close(s1)); +} + +void +test_tcp_no_delay_option(void) +{ + nng_socket s; + nng_dialer d; + nng_listener l; + bool v; + int x; + char addr[64]; + + testutil_scratch_addr("tcp", sizeof(addr), addr); + + TEST_NNG_PASS(nng_pair0_open(&s)); +#ifndef NNG_ELIDE_DEPRECATED + TEST_NNG_PASS(nng_socket_get_bool(s, NNG_OPT_TCP_NODELAY, &v)); + TEST_CHECK(v == true); +#endif + TEST_NNG_PASS(nng_dialer_create(&d, s, addr)); + TEST_NNG_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_NODELAY, &v)); + TEST_CHECK(v == true); + TEST_NNG_PASS(nng_dialer_set_bool(d, NNG_OPT_TCP_NODELAY, false)); + TEST_NNG_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_NODELAY, &v)); + TEST_CHECK(v == false); + TEST_NNG_FAIL( + nng_dialer_get_int(d, NNG_OPT_TCP_NODELAY, &x), NNG_EBADTYPE); + x = 0; + TEST_NNG_FAIL( + nng_dialer_set_int(d, NNG_OPT_TCP_NODELAY, x), NNG_EBADTYPE); + // This assumes sizeof (bool) != sizeof (int) + if (sizeof(bool) != sizeof(int)) { + TEST_NNG_FAIL( + nng_dialer_set(d, NNG_OPT_TCP_NODELAY, &x, sizeof(x)), + NNG_EINVAL); + } + + TEST_NNG_PASS(nng_listener_create(&l, s, addr)); + TEST_NNG_PASS(nng_listener_get_bool(l, NNG_OPT_TCP_NODELAY, &v)); + TEST_CHECK(v == true); + x = 0; + TEST_NNG_FAIL( + nng_listener_set_int(l, NNG_OPT_TCP_NODELAY, x), NNG_EBADTYPE); + // This assumes sizeof (bool) != sizeof (int) + TEST_NNG_FAIL(nng_listener_set(l, NNG_OPT_TCP_NODELAY, &x, sizeof(x)), + NNG_EINVAL); + + TEST_NNG_PASS(nng_dialer_close(d)); + TEST_NNG_PASS(nng_listener_close(l)); + + // Make sure socket wide defaults apply. +#ifndef NNG_ELIDE_DEPRECATED + TEST_NNG_PASS(nng_socket_set_bool(s, NNG_OPT_TCP_NODELAY, true)); + v = false; + TEST_NNG_PASS(nng_socket_get_bool(s, NNG_OPT_TCP_NODELAY, &v)); + TEST_CHECK(v == true); + TEST_NNG_PASS(nng_socket_set_bool(s, NNG_OPT_TCP_NODELAY, false)); + TEST_NNG_PASS(nng_dialer_create(&d, s, addr)); + TEST_NNG_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_NODELAY, &v)); + TEST_CHECK(v == false); +#endif + TEST_NNG_PASS(nng_close(s)); +} + +void +test_tcp_keep_alive_option(void) +{ + nng_socket s; + nng_dialer d; + nng_listener l; + bool v; + int x; + char addr[64]; + + testutil_scratch_addr("tcp", sizeof(addr), addr); + TEST_NNG_PASS(nng_pair0_open(&s)); +#ifndef NNG_ELIDE_DEPRECATED + TEST_NNG_PASS(nng_socket_get_bool(s, NNG_OPT_TCP_KEEPALIVE, &v)); + TEST_CHECK(v == false); +#endif + TEST_NNG_PASS(nng_dialer_create(&d, s, addr)); + TEST_NNG_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_KEEPALIVE, &v)); + TEST_CHECK(v == false); + TEST_NNG_PASS(nng_dialer_set_bool(d, NNG_OPT_TCP_KEEPALIVE, true)); + TEST_NNG_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_KEEPALIVE, &v)); + TEST_CHECK(v == true); + TEST_NNG_FAIL( + nng_dialer_get_int(d, NNG_OPT_TCP_KEEPALIVE, &x), NNG_EBADTYPE); + x = 1; + TEST_NNG_FAIL( + nng_dialer_set_int(d, NNG_OPT_TCP_KEEPALIVE, x), NNG_EBADTYPE); + + TEST_NNG_PASS(nng_listener_create(&l, s, addr)); + TEST_NNG_PASS(nng_listener_get_bool(l, NNG_OPT_TCP_KEEPALIVE, &v)); + TEST_CHECK(v == false); + x = 1; + TEST_NNG_FAIL( + nng_listener_set_int(l, NNG_OPT_TCP_KEEPALIVE, x), NNG_EBADTYPE); + + TEST_NNG_PASS(nng_dialer_close(d)); + TEST_NNG_PASS(nng_listener_close(l)); + + // Make sure socket wide defaults apply. +#ifndef NNG_ELIDE_DEPRECATED + TEST_NNG_PASS(nng_socket_set_bool(s, NNG_OPT_TCP_KEEPALIVE, false)); + v = true; + TEST_NNG_PASS(nng_socket_get_bool(s, NNG_OPT_TCP_KEEPALIVE, &v)); + TEST_CHECK(v == false); + TEST_NNG_PASS(nng_socket_set_bool(s, NNG_OPT_TCP_KEEPALIVE, true)); + TEST_NNG_PASS(nng_dialer_create(&d, s, addr)); + TEST_NNG_PASS(nng_dialer_get_bool(d, NNG_OPT_TCP_KEEPALIVE, &v)); + TEST_CHECK(v == true); +#endif + TEST_NNG_PASS(nng_close(s)); +} + +void +test_tcp_recv_max(void) +{ + char msg[256]; + char buf[256]; + nng_socket s0; + nng_socket s1; + nng_listener l; + size_t sz; + char addr[64]; + + testutil_scratch_addr("tcp", sizeof(addr), addr); + + TEST_NNG_PASS(nng_pair0_open(&s0)); + TEST_NNG_PASS(nng_socket_set_ms(s0, NNG_OPT_RECVTIMEO, 100)); + TEST_NNG_PASS(nng_socket_set_size(s0, NNG_OPT_RECVMAXSZ, 200)); + TEST_NNG_PASS(nng_listener_create(&l, s0, addr)); + TEST_NNG_PASS(nng_socket_get_size(s0, NNG_OPT_RECVMAXSZ, &sz)); + TEST_CHECK(sz == 200); + TEST_NNG_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 100)); + TEST_NNG_PASS(nng_listener_start(l, 0)); + + TEST_NNG_PASS(nng_pair0_open(&s1)); + TEST_NNG_PASS(nng_dial(s1, addr, NULL, 0)); + TEST_NNG_PASS(nng_send(s1, msg, 95, 0)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 100)); + TEST_NNG_PASS(nng_recv(s0, buf, &sz, 0)); + TEST_CHECK(sz == 95); + TEST_NNG_PASS(nng_send(s1, msg, 150, 0)); + TEST_NNG_FAIL(nng_recv(s0, buf, &sz, 0), NNG_ETIMEDOUT); + TEST_NNG_PASS(nng_close(s0)); + TEST_NNG_PASS(nng_close(s1)); +} + +TEST_LIST = { + + { "tcp wild card connect fail", test_tcp_wild_card_connect_fail }, + { "tcp wild card bind", test_tcp_wild_card_bind }, + { "tcp port zero bind", test_tcp_port_zero_bind }, + { "tcp local address connect", test_tcp_local_address_connect }, + { "tcp bad local interface", test_tcp_bad_local_interface }, + { "tcp non-local address", test_tcp_non_local_address }, + { "tcp malformed address", test_tcp_malformed_address }, + { "tcp no delay option", test_tcp_no_delay_option }, + { "tcp keep alive option", test_tcp_keep_alive_option }, + { "tcp recv max", test_tcp_recv_max }, + { NULL, NULL }, +};
\ No newline at end of file diff --git a/src/transport/tls/CMakeLists.txt b/src/transport/tls/CMakeLists.txt index d77a67cd..82f24c79 100644 --- a/src/transport/tls/CMakeLists.txt +++ b/src/transport/tls/CMakeLists.txt @@ -9,8 +9,7 @@ # # TLS transport -option (NNG_TRANSPORT_TLS "Enable TLS transport." ON) -mark_as_advanced(NNG_TRANSPORT_TLS) +nng_directory(tls) nng_sources_if(NNG_TRANSPORT_TLS tls.c) nng_headers_if(NNG_TRANSPORT_TLS nng/transport/tls/tls.h) diff --git a/src/transport/ws/CMakeLists.txt b/src/transport/ws/CMakeLists.txt index 8d8b5965..6e409b43 100644 --- a/src/transport/ws/CMakeLists.txt +++ b/src/transport/ws/CMakeLists.txt @@ -9,19 +9,9 @@ # # WebSocket transport -option (NNG_TRANSPORT_WS "Enable WebSocket transport." ON) -mark_as_advanced(NNG_TRANSPORT_WS) - -CMAKE_DEPENDENT_OPTION(NNG_TRANSPORT_WSS "Enable WSS transport" ON - "NNG_ENABLE_TLS" OFF) -mark_as_advanced(NNG_TRANSPORT_WSS) +nng_directory(ws) if (NNG_TRANSPORT_WS OR NNG_TRANSPORT_WSS) - # Make sure things we *MUST* have are enabled. - set(NNG_SUPP_WEBSOCKET ON PARENT_SCOPE) - set(NNG_SUPP_HTTP ON PARENT_SCOPE) - set(NNG_SUPP_BASE64 ON PARENT_SCOPE) - set(NNG_SUPP_SHA1 ON PARENT_SCOPE) set(WS_ON ON) endif() diff --git a/src/transport/ws/ws_test.c b/src/transport/ws/ws_test.c index 3a6e7fdf..f8f122a1 100644 --- a/src/transport/ws/ws_test.c +++ b/src/transport/ws/ws_test.c @@ -1,5 +1,6 @@ // // Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> +// Copyright 2018 Cody Piersall <cody.piersall@gmail.com> // // This software is supplied under the terms of the MIT License, a // copy of which should be located in the distribution where this @@ -60,18 +61,18 @@ test_wild_card_port(void) TEST_NNG_PASS(nng_pair0_open(&s6)); TEST_NNG_PASS(nng_listen(s1, "ws://127.0.0.1:0/one", &l1, 0)); TEST_NNG_PASS( - nng_listener_getopt_int(l1, NNG_OPT_TCP_BOUND_PORT, &port1)); + nng_listener_get_int(l1, NNG_OPT_TCP_BOUND_PORT, &port1)); TEST_CHECK(port1 != 0); snprintf(ws_url, sizeof(ws_url), "ws4://127.0.0.1:%d/two", port1); TEST_NNG_PASS(nng_listen(s2, ws_url, &l2, 0)); TEST_NNG_PASS( - nng_listener_getopt_int(l2, NNG_OPT_TCP_BOUND_PORT, &port2)); + nng_listener_get_int(l2, NNG_OPT_TCP_BOUND_PORT, &port2)); TEST_CHECK(port1 != 0); TEST_CHECK(port1 == port2); // Now try a different wild card port. TEST_NNG_PASS(nng_listen(s3, "ws4://127.0.0.1:0/three", &l3, 0)); TEST_NNG_PASS( - nng_listener_getopt_int(l3, NNG_OPT_TCP_BOUND_PORT, &port3)); + nng_listener_get_int(l3, NNG_OPT_TCP_BOUND_PORT, &port3)); TEST_CHECK(port3 != 0); TEST_CHECK(port3 != port1); @@ -141,10 +142,45 @@ test_empty_host(void) TEST_NNG_PASS(nng_close(s2)); } +void +test_ws_recv_max(void) +{ + char msg[256]; + char buf[256]; + nng_socket s0; + nng_socket s1; + nng_listener l; + size_t sz; + char addr[64]; + + testutil_scratch_addr("ws", sizeof(addr), addr); + + TEST_NNG_PASS(nng_pair0_open(&s0)); + TEST_NNG_PASS(nng_socket_set_ms(s0, NNG_OPT_RECVTIMEO, 100)); + TEST_NNG_PASS(nng_socket_set_size(s0, NNG_OPT_RECVMAXSZ, 200)); + TEST_NNG_PASS(nng_listener_create(&l, s0, addr)); + TEST_NNG_PASS(nng_socket_get_size(s0, NNG_OPT_RECVMAXSZ, &sz)); + TEST_CHECK(sz == 200); + TEST_NNG_PASS(nng_listener_set_size(l, NNG_OPT_RECVMAXSZ, 100)); + TEST_NNG_PASS(nng_listener_start(l, 0)); + + TEST_NNG_PASS(nng_pair0_open(&s1)); + TEST_NNG_PASS(nng_dial(s1, addr, NULL, 0)); + TEST_NNG_PASS(nng_send(s1, msg, 95, 0)); + TEST_NNG_PASS(nng_socket_set_ms(s1, NNG_OPT_SENDTIMEO, 100)); + TEST_NNG_PASS(nng_recv(s0, buf, &sz, 0)); + TEST_CHECK(sz == 95); + TEST_NNG_PASS(nng_send(s1, msg, 150, 0)); + TEST_NNG_FAIL(nng_recv(s0, buf, &sz, 0), NNG_ETIMEDOUT); + TEST_NNG_PASS(nng_close(s0)); + TEST_NNG_PASS(nng_close(s1)); +} + TEST_LIST = { { "ws url path filters", test_ws_url_path_filters }, { "ws wild card port", test_wild_card_port }, { "ws wild card host", test_wild_card_host }, { "ws empty host", test_empty_host }, + { "ws recv max", test_ws_recv_max }, { NULL, NULL }, };
\ No newline at end of file diff --git a/src/transport/zerotier/CMakeLists.txt b/src/transport/zerotier/CMakeLists.txt index 167a98c0..903b7f56 100644 --- a/src/transport/zerotier/CMakeLists.txt +++ b/src/transport/zerotier/CMakeLists.txt @@ -13,6 +13,8 @@ option (NNG_TRANSPORT_ZEROTIER "Enable ZeroTier transport (requires libzerotiercore)." OFF) mark_as_advanced(NNG_TRANSPORT_ZEROTIER) +nng_directory(zerotier) + if (NNG_TRANSPORT_ZEROTIER) # NB: As we wind up linking libzerotiercore.a into the application, diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index aa7260ac..a662d495 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -124,19 +124,7 @@ else () endmacro(add_nng_test3) endif () -nng_test(aio) -nng_test(bufsz) -nng_test(bug1247) -nng_test(id) -nng_test(platform) -nng_test(reconnect) -nng_test(resolv) -nng_test(sock) -nng_test(url) - - add_nng_test(device 5) -add_nng_test(errors 2) add_nng_test(files 5) add_nng_test1(httpclient 60 NNG_SUPP_HTTP) add_nng_test1(httpserver 30 NNG_SUPP_HTTP) @@ -152,7 +140,6 @@ add_nng_test(options 5) add_nng_test(pipe 5) add_nng_test(pollfd 5) add_nng_test(scalability 20 ON) -add_nng_test(set_recvmaxsize 2) add_nng_test1(stats 5 NNG_ENABLE_STATS) add_nng_test(synch 5) add_nng_test(tls 60) diff --git a/tests/errors.c b/tests/errors.c deleted file mode 100644 index 0cade6a4..00000000 --- a/tests/errors.c +++ /dev/null @@ -1,33 +0,0 @@ -// -// Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> -// -// This software is supplied under the terms of the MIT License, a -// copy of which should be located in the distribution where this -// file was obtained (LICENSE.txt). A copy of the license may also be -// found online at https://opensource.org/licenses/MIT. -// - -#include <errno.h> -#include <string.h> - -#include <nng/nng.h> - -#include "convey.h" - -TestMain("Error messages work", { - Convey("Known errors work", { - So(strcmp(nng_strerror(NNG_ECLOSED), "Object closed") == 0); - So(strcmp(nng_strerror(NNG_ETIMEDOUT), "Timed out") == 0); - }); - Convey("We always get a valid error", { - for (unsigned i = 1; i < 0x1000000; i = i * 2 + 100) { - So(nng_strerror(i) != NULL); - } - }); - Convey("System errors work", { - So(strcmp(nng_strerror(NNG_ESYSERR + ENOENT), - strerror(ENOENT)) == 0); - So(strcmp(nng_strerror(NNG_ESYSERR + EINVAL), - strerror(EINVAL)) == 0); - }); -}) diff --git a/tests/set_recvmaxsize.c b/tests/set_recvmaxsize.c deleted file mode 100644 index 70d9d700..00000000 --- a/tests/set_recvmaxsize.c +++ /dev/null @@ -1,48 +0,0 @@ -// Copyright 2018 Cody Piersall <cody.piersall@gmail.com> -// -// This software is supplied under the terms of the MIT License, a -// copy of which should be located in the distribution where this -// file was obtained (LICENSE.txt). A copy of the license may also be -// found online at https://opensource.org/licenses/MIT. -// - -#include "convey.h" - -#include <nng/nng.h> -#include <nng/protocol/pair1/pair.h> - -#define SNDBUFSIZE 150 -#define RCVBUFSIZE 200 - -const char *addrs[] = { - "tcp://127.0.0.1:43895", - "ws://127.0.0.1:43897", -}; - -TestMain("recvmaxsize", { - // we don't actually care what the content of the message is. - char msg[SNDBUFSIZE]; - char rcvbuf[RCVBUFSIZE]; - size_t rcvsize = RCVBUFSIZE; - nng_socket s0; - nng_socket s1; - nng_listener l; - int numproto = sizeof addrs / sizeof *addrs; - Convey("recvmaxsize can be set after listening", { - for (int i = 0; i < numproto; i++) { - const char *addr = addrs[i]; - So(nng_pair1_open(&s0) == 0); - So(nng_setopt_ms(s0, NNG_OPT_RECVTIMEO, 100) == 0); - So(nng_setopt_size(s0, NNG_OPT_RECVMAXSZ, 200) == 0); - So(nng_listen(s0, addr, &l, 0) == 0); - So(nng_setopt_size(s0, NNG_OPT_RECVMAXSZ, 100) == 0); - - So(nng_pair1_open(&s1) == 0); - So(nng_dial(s1, addr, NULL, 0) == 0); - So(nng_send(s1, msg, 150, 0) == 0); - So(nng_recv(s0, rcvbuf, &rcvsize, 0) == NNG_ETIMEDOUT); - So(nng_close(s0) == 0); - So(nng_close(s1) == 0); - } - }); -}) diff --git a/tests/sock.c b/tests/sock.c deleted file mode 100644 index 7b19f378..00000000 --- a/tests/sock.c +++ /dev/null @@ -1,666 +0,0 @@ -// -// Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> -// Copyright 2018 Capitar IT Group BV <info@capitar.com> -// -// This software is supplied under the terms of the MIT License, a -// copy of which should be located in the distribution where this -// file was obtained (LICENSE.txt). A copy of the license may also be -// found online at https://opensource.org/licenses/MIT. -// - -#include <string.h> - -#include <nng/nng.h> -#include <nng/protocol/pair1/pair.h> -#include <nng/supplemental/util/platform.h> - -#include "acutest.h" -#include "testutil.h" - -void -test_recv_timeout(void) -{ - nng_socket s1; - uint64_t now; - nng_msg * msg = NULL; - - TEST_CHECK(nng_pair_open(&s1) == 0); - TEST_CHECK(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, 10) == 0); - now = testutil_clock(); - TEST_CHECK(nng_recvmsg(s1, &msg, 0) == NNG_ETIMEDOUT); - TEST_CHECK(msg == NULL); - TEST_CHECK(testutil_clock() >= (now + 9)); - TEST_CHECK(testutil_clock() < (now + 500)); - TEST_CHECK(nng_close(s1) == 0); -} - -void -test_recv_nonblock(void) -{ - nng_socket s1; - uint64_t now; - nng_msg * msg = NULL; - - TEST_CHECK(nng_pair1_open(&s1) == 0); - TEST_CHECK(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, 10) == 0); - now = testutil_clock(); - TEST_CHECK(nng_recvmsg(s1, &msg, NNG_FLAG_NONBLOCK) == NNG_EAGAIN); - TEST_CHECK(msg == NULL); - TEST_CHECK(testutil_clock() < (now + 500)); - TEST_CHECK(nng_close(s1) == 0); -} - -void -test_send_timeout(void) -{ - nng_socket s1; - uint64_t now; - nng_msg * msg; - - TEST_CHECK(nng_msg_alloc(&msg, 0) == 0); - TEST_CHECK(nng_pair_open(&s1) == 0); - TEST_CHECK(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, 100) == 0); - now = testutil_clock(); - TEST_CHECK(nng_sendmsg(s1, msg, 0) == NNG_ETIMEDOUT); - TEST_CHECK(testutil_clock() >= (now + 9)); - TEST_CHECK(testutil_clock() < (now + 500)); - nng_msg_free(msg); - TEST_CHECK(nng_close(s1) == 0); -} - -void -test_send_nonblock(void) -{ - nng_socket s1; - uint64_t now; - nng_msg * msg; - - TEST_CHECK(nng_msg_alloc(&msg, 0) == 0); - TEST_CHECK(nng_pair1_open(&s1) == 0); - TEST_CHECK(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, 500) == 0); - now = testutil_clock(); - TEST_CHECK(nng_sendmsg(s1, msg, NNG_FLAG_NONBLOCK) == NNG_EAGAIN); - TEST_CHECK(testutil_clock() < (now + 100)); - TEST_CHECK(nng_close(s1) == 0); - nng_msg_free(msg); -} - -void -test_readonly_options(void) -{ - nng_socket s1; - TEST_CHECK(nng_pair1_open(&s1) == 0); - TEST_CHECK(nng_setopt_int(s1, NNG_OPT_RECVFD, 0) == NNG_EREADONLY); - TEST_CHECK(nng_setopt_int(s1, NNG_OPT_SENDFD, 0) == NNG_EREADONLY); - TEST_CHECK(nng_close(s1) == 0); -} - -void -test_socket_base(void) -{ - nng_socket s1 = NNG_SOCKET_INITIALIZER; - - TEST_CHECK(nng_socket_id(s1) < 0); - TEST_CHECK(nng_pair1_open(&s1) == 0); - TEST_CHECK(nng_socket_id(s1) > 0); - - // Cannot set bogus options - TEST_CHECK(nng_setopt_bool(s1, "BAD_OPT", false) == NNG_ENOTSUP); - - TEST_CHECK(nng_close(s1) == 0); -} - -void -test_socket_name(void) -{ - nng_socket s1; - char name[128]; // 64 is max - char * str; - long id; - char * end; - size_t sz; - - sz = sizeof(name); - TEST_CHECK(nng_pair_open(&s1) == 0); - TEST_CHECK(nng_getopt(s1, NNG_OPT_SOCKNAME, name, &sz) == 0); - TEST_CHECK(sz > 0 && sz < 64); - TEST_CHECK(sz == strlen(name) + 1); - id = strtol(name, &end, 10); - TEST_CHECK(id == (long) s1.id); - TEST_CHECK(end != NULL && *end == '\0'); - - TEST_CHECK(nng_setopt(s1, NNG_OPT_SOCKNAME, "hello", 6) == 0); - sz = sizeof(name); - TEST_CHECK(nng_getopt(s1, NNG_OPT_SOCKNAME, name, &sz) == 0); - TEST_CHECK(sz == 6); - TEST_CHECK(strcmp(name, "hello") == 0); - - memset(name, 'A', 64); - name[64] = '\0'; - - // strings must be NULL terminated - TEST_CHECK(nng_setopt(s1, NNG_OPT_SOCKNAME, name, 5) == NNG_EINVAL); - - TEST_CHECK(nng_getopt_string(s1, NNG_OPT_SOCKNAME, &str) == 0); - TEST_ASSERT(str != NULL); - TEST_CHECK(strlen(str) == 5); - TEST_CHECK(strcmp(str, "hello") == 0); - nng_strfree(str); - - TEST_CHECK(nng_close(s1) == 0); -} - -void -test_socket_name_oversize(void) -{ - nng_socket s1; - char name[256]; // 64 is max - size_t sz = sizeof(name); - - memset(name, 'A', sz); - TEST_CHECK(nng_pair_open(&s1) == 0); - - TEST_CHECK(nng_setopt(s1, NNG_OPT_SOCKNAME, name, sz) == NNG_EINVAL); - name[sz - 1] = '\0'; - TEST_CHECK(nng_setopt(s1, NNG_OPT_SOCKNAME, name, sz) == NNG_EINVAL); - - strcpy(name, "hello"); - TEST_CHECK(nng_setopt(s1, NNG_OPT_SOCKNAME, name, sz) == 0); - sz = sizeof(name); - memset(name, 'B', sz); - TEST_CHECK(nng_getopt(s1, NNG_OPT_SOCKNAME, name, &sz) == 0); - TEST_CHECK(sz == 6); - TEST_CHECK(strcmp(name, "hello") == 0); - - TEST_CHECK(nng_close(s1) == 0); -} - -void -test_send_recv(void) -{ - nng_socket s1; - nng_socket s2; - int len; - size_t sz; - nng_duration to = 3000; // 3 seconds - char * buf; - char * a = "inproc://t1"; - - TEST_CHECK(nng_pair1_open(&s1) == 0); - TEST_CHECK(nng_pair1_open(&s2) == 0); - - TEST_CHECK(nng_setopt_int(s1, NNG_OPT_RECVBUF, 1) == 0); - TEST_CHECK(nng_getopt_int(s1, NNG_OPT_RECVBUF, &len) == 0); - TEST_CHECK(len == 1); - - TEST_CHECK(nng_setopt_int(s1, NNG_OPT_SENDBUF, 1) == 0); - TEST_CHECK(nng_setopt_int(s2, NNG_OPT_SENDBUF, 1) == 0); - - TEST_CHECK(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, to) == 0); - TEST_CHECK(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, to) == 0); - TEST_CHECK(nng_setopt_ms(s2, NNG_OPT_SENDTIMEO, to) == 0); - TEST_CHECK(nng_setopt_ms(s2, NNG_OPT_RECVTIMEO, to) == 0); - - TEST_CHECK(nng_listen(s1, a, NULL, 0) == 0); - TEST_CHECK(nng_dial(s2, a, NULL, 0) == 0); - - TEST_CHECK(nng_send(s1, "abc", 4, 0) == 0); - TEST_CHECK(nng_recv(s2, &buf, &sz, NNG_FLAG_ALLOC) == 0); - TEST_CHECK(buf != NULL); - TEST_CHECK(sz == 4); - TEST_CHECK(memcmp(buf, "abc", 4) == 0); - nng_free(buf, sz); - - TEST_CHECK(nng_close(s1) == 0); - TEST_CHECK(nng_close(s2) == 0); -} - -void -test_send_recv_zero_length(void) -{ - nng_socket s1; - nng_socket s2; - int len; - size_t sz; - nng_duration to = 3000; // 3 seconds - char * buf; - char * a = "inproc://send-recv-zero-length"; - - TEST_NNG_PASS(nng_pair1_open(&s1)); - TEST_NNG_PASS(nng_pair1_open(&s2)); - - TEST_NNG_PASS(nng_setopt_int(s1, NNG_OPT_RECVBUF, 1)); - TEST_NNG_PASS(nng_getopt_int(s1, NNG_OPT_RECVBUF, &len)); - TEST_CHECK(len == 1); - - TEST_NNG_PASS(nng_setopt_int(s1, NNG_OPT_SENDBUF, 1)); - TEST_NNG_PASS(nng_setopt_int(s2, NNG_OPT_SENDBUF, 1)); - - TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_SENDTIMEO, to)); - TEST_NNG_PASS(nng_setopt_ms(s1, NNG_OPT_RECVTIMEO, to)); - TEST_NNG_PASS(nng_setopt_ms(s2, NNG_OPT_SENDTIMEO, to)); - TEST_NNG_PASS(nng_setopt_ms(s2, NNG_OPT_RECVTIMEO, to)); - - TEST_NNG_PASS(nng_listen(s1, a, NULL, 0)); - TEST_NNG_PASS(nng_dial(s2, a, NULL, 0)); - - TEST_NNG_PASS(nng_send(s1, "", 0, 0)); - TEST_NNG_PASS(nng_recv(s2, &buf, &sz, NNG_FLAG_ALLOC)); - TEST_CHECK(buf == NULL); - TEST_CHECK(sz == 0); - nng_free(buf, sz); - - TEST_NNG_PASS(nng_close(s1)); - TEST_NNG_PASS(nng_close(s2)); -} - -void -test_connection_refused(void) -{ - nng_socket s1; - - TEST_CHECK(nng_pair1_open(&s1) == 0); - TEST_CHECK(nng_dial(s1, "inproc://no", NULL, 0) == NNG_ECONNREFUSED); - TEST_CHECK(nng_close(s1) == 0); -} - -void -test_late_connection(void) -{ - char * buf; - size_t sz; - nng_socket s1; - nng_socket s2; - char * a = "inproc://asy"; - - TEST_CHECK(nng_pair1_open(&s1) == 0); - TEST_CHECK(nng_pair1_open(&s2) == 0); - - TEST_CHECK(nng_setopt_ms(s1, NNG_OPT_RECONNMINT, 10) == 0); - TEST_CHECK(nng_setopt_ms(s1, NNG_OPT_RECONNMAXT, 10) == 0); - - TEST_CHECK(nng_dial(s1, a, NULL, NNG_FLAG_NONBLOCK) == 0); - TEST_CHECK(nng_listen(s2, a, NULL, 0) == 0); - nng_msleep(100); - TEST_CHECK(nng_send(s1, "abc", 4, 0) == 0); - TEST_CHECK(nng_recv(s2, &buf, &sz, NNG_FLAG_ALLOC) == 0); - TEST_CHECK(sz == 4); - TEST_CHECK(memcmp(buf, "abc", 4) == 0); - nng_free(buf, sz); - - TEST_CHECK(nng_close(s1) == 0); - TEST_CHECK(nng_close(s2) == 0); -} - -void -test_address_busy(void) -{ - char * a = "inproc://eaddrinuse"; - nng_listener l = NNG_LISTENER_INITIALIZER; - nng_dialer d = NNG_DIALER_INITIALIZER; - nng_socket s1; - nng_socket s2; - - TEST_CHECK(nng_pair1_open(&s1) == 0); - TEST_CHECK(nng_pair1_open(&s2) == 0); - - TEST_CHECK(nng_listener_id(l) < 0); - TEST_CHECK(nng_listen(s1, a, &l, 0) == 0); - TEST_CHECK(nng_listener_id(l) > 0); - - // Cannot start another one. - TEST_CHECK(nng_listen(s1, a, NULL, 0) == NNG_EADDRINUSE); - - // We can't restart it -- it's already running - TEST_CHECK(nng_listener_start(l, 0) == NNG_ESTATE); - - // We can connect to it. - TEST_CHECK(nng_dialer_id(d) < 0); - TEST_CHECK(nng_dial(s2, a, &d, 0) == 0); - TEST_CHECK(nng_dialer_id(d) > 0); - - TEST_CHECK(nng_close(s1) == 0); - TEST_CHECK(nng_close(s2) == 0); -} - -void -test_endpoint_types(void) -{ - nng_socket s1; - nng_dialer d = NNG_DIALER_INITIALIZER; - nng_listener l = NNG_LISTENER_INITIALIZER; - nng_dialer d2; - nng_listener l2; - char * a = "inproc://mumble..."; - bool b; - - TEST_CHECK(nng_pair1_open(&s1) == 0); - - TEST_CHECK(nng_dialer_id(d) < 0); - TEST_CHECK(nng_dialer_create(&d, s1, a) == 0); - TEST_CHECK(nng_dialer_id(d) > 0); - - // Forge a listener - l2.id = nng_dialer_id(d); - TEST_CHECK( - nng_listener_getopt_bool(l2, NNG_OPT_RAW, &b) == NNG_ENOENT); - TEST_CHECK(nng_listener_close(l2) == NNG_ENOENT); - TEST_CHECK(nng_dialer_close(d) == 0); - - TEST_CHECK(nng_listener_id(l) < 0); - TEST_CHECK(nng_listener_create(&l, s1, a) == 0); - TEST_CHECK(nng_listener_id(l) > 0); - - // Forge a dialer - d2.id = nng_listener_id(l); - TEST_CHECK(nng_dialer_getopt_bool(d2, NNG_OPT_RAW, &b) == NNG_ENOENT); - TEST_CHECK(nng_dialer_close(d2) == NNG_ENOENT); - TEST_CHECK(nng_listener_close(l) == 0); - - TEST_CHECK(nng_close(s1) == 0); -} - -void -test_bad_url(void) -{ - nng_socket s1; - - TEST_CHECK(nng_pair1_open(&s1) == 0); - TEST_CHECK(nng_dial(s1, "bogus://1", NULL, 0) == NNG_ENOTSUP); - TEST_CHECK(nng_listen(s1, "bogus://2", NULL, 0) == NNG_ENOTSUP); - TEST_CHECK(nng_close(s1) == 0); -} - -void -test_url_option(void) -{ - nng_socket s1; - char url[NNG_MAXADDRLEN]; - nng_listener l; - nng_dialer d; - size_t sz; - - TEST_CHECK(nng_pair1_open(&s1) == 0); - - // Listener - TEST_CHECK(nng_listener_create(&l, s1, "inproc://url1") == 0); - memset(url, 0, sizeof(url)); - sz = sizeof(url); - TEST_CHECK(nng_listener_getopt(l, NNG_OPT_URL, url, &sz) == 0); - TEST_CHECK(strcmp(url, "inproc://url1") == 0); - TEST_CHECK( - nng_listener_setopt(l, NNG_OPT_URL, url, sz) == NNG_EREADONLY); - sz = sizeof(url); - - // Dialer - TEST_CHECK(nng_dialer_create(&d, s1, "inproc://url2") == 0); - TEST_CHECK(nng_dialer_getopt(d, NNG_OPT_URL, url, &sz) == 0); - TEST_CHECK(strcmp(url, "inproc://url2") == 0); - TEST_CHECK( - nng_dialer_setopt(d, NNG_OPT_URL, url, sz) == NNG_EREADONLY); - - nng_close(s1); -} - -void -test_listener_options(void) -{ - nng_socket s1; - nng_listener l; - size_t sz; - - TEST_CHECK(nng_pair1_open(&s1) == 0); - - // Create a listener with the specified options - TEST_CHECK(nng_setopt_size(s1, NNG_OPT_RECVMAXSZ, 543) == 0); - TEST_CHECK(nng_listener_create(&l, s1, "inproc://listener_opts") == 0); - TEST_CHECK(nng_listener_getopt_size(l, NNG_OPT_RECVMAXSZ, &sz) == 0); - TEST_CHECK(sz == 543); - - // Verify endpoint overrides - TEST_CHECK(nng_listener_setopt_size(l, NNG_OPT_RECVMAXSZ, 678) == 0); - TEST_CHECK(nng_listener_getopt_size(l, NNG_OPT_RECVMAXSZ, &sz) == 0); - TEST_CHECK(sz == 678); - TEST_CHECK(nng_getopt_size(s1, NNG_OPT_RECVMAXSZ, &sz) == 0); - TEST_CHECK(sz == 543); - - // And socket overrides again - TEST_CHECK(nng_setopt_size(s1, NNG_OPT_RECVMAXSZ, 911) == 0); - TEST_CHECK(nng_listener_getopt_size(l, NNG_OPT_RECVMAXSZ, &sz) == 0); - TEST_CHECK(sz == 911); - - // Cannot set invalid options - TEST_CHECK(nng_listener_setopt_size(l, "BAD_OPT", 1) == NNG_ENOTSUP); - TEST_CHECK(nng_listener_setopt_bool(l, NNG_OPT_RECVMAXSZ, true) == - NNG_EBADTYPE); - TEST_CHECK( - nng_listener_setopt(l, NNG_OPT_RECVMAXSZ, &sz, 1) == NNG_EINVAL); - - // Cannot set inappropriate options - TEST_CHECK(nng_listener_setopt_string(l, NNG_OPT_SOCKNAME, "1") == - NNG_ENOTSUP); - TEST_CHECK( - nng_listener_setopt_bool(l, NNG_OPT_RAW, true) == NNG_ENOTSUP); - TEST_CHECK( - nng_listener_setopt_ms(l, NNG_OPT_RECONNMINT, 1) == NNG_ENOTSUP); - TEST_CHECK(nng_listener_setopt_string(l, NNG_OPT_SOCKNAME, "bogus") == - NNG_ENOTSUP); - - // Read only options - TEST_CHECK(nng_listener_setopt_string( - l, NNG_OPT_URL, "inproc://junk") == NNG_EREADONLY); - - TEST_CHECK(nng_close(s1) == 0); -} - -void -test_dialer_options(void) -{ - nng_socket s1; - nng_dialer d; - size_t sz; - - TEST_CHECK(nng_pair1_open(&s1) == 0); - - // Create a listener with the specified options - TEST_CHECK(nng_setopt_size(s1, NNG_OPT_RECVMAXSZ, 543) == 0); - TEST_CHECK(nng_dialer_create(&d, s1, "inproc://dialer_opts") == 0); - TEST_CHECK(nng_dialer_getopt_size(d, NNG_OPT_RECVMAXSZ, &sz) == 0); - TEST_CHECK(sz == 543); - - // Verify endpoint overrides - TEST_CHECK(nng_dialer_setopt_size(d, NNG_OPT_RECVMAXSZ, 678) == 0); - TEST_CHECK(nng_dialer_getopt_size(d, NNG_OPT_RECVMAXSZ, &sz) == 0); - TEST_CHECK(sz == 678); - TEST_CHECK(nng_getopt_size(s1, NNG_OPT_RECVMAXSZ, &sz) == 0); - TEST_CHECK(sz == 543); - - // And socket overrides again - TEST_CHECK(nng_setopt_size(s1, NNG_OPT_RECVMAXSZ, 911) == 0); - TEST_CHECK(nng_dialer_getopt_size(d, NNG_OPT_RECVMAXSZ, &sz) == 0); - TEST_CHECK(sz == 911); - - // Cannot set invalid options - TEST_CHECK(nng_dialer_setopt_size(d, "BAD_OPT", 1) == NNG_ENOTSUP); - TEST_CHECK(nng_dialer_setopt_bool(d, NNG_OPT_RECVMAXSZ, true) == - NNG_EBADTYPE); - TEST_CHECK( - nng_dialer_setopt(d, NNG_OPT_RECVMAXSZ, &sz, 1) == NNG_EINVAL); - - // Cannot set inappropriate options - TEST_CHECK( - nng_dialer_setopt_string(d, NNG_OPT_SOCKNAME, "1") == NNG_ENOTSUP); - TEST_CHECK( - nng_dialer_setopt_bool(d, NNG_OPT_RAW, true) == NNG_ENOTSUP); - TEST_CHECK( - nng_dialer_setopt_ms(d, NNG_OPT_SENDTIMEO, 1) == NNG_ENOTSUP); - TEST_CHECK(nng_dialer_setopt_string(d, NNG_OPT_SOCKNAME, "bogus") == - NNG_ENOTSUP); - - // Read only options - TEST_CHECK(nng_dialer_setopt_string(d, NNG_OPT_URL, "inproc://junk") == - NNG_EREADONLY); - - TEST_CHECK(nng_close(s1) == 0); -} - -void -test_endpoint_absent_options(void) -{ - size_t s; - int i; - nng_duration t; - bool b; - nng_dialer d; - nng_listener l; - d.id = 1999; - l.id = 1999; - - TEST_CHECK( - nng_dialer_setopt_size(d, NNG_OPT_RECVMAXSZ, 10) == NNG_ENOENT); - TEST_CHECK( - nng_listener_setopt_size(l, NNG_OPT_RECVMAXSZ, 10) == NNG_ENOENT); - - TEST_CHECK(nng_dialer_getopt_bool(d, NNG_OPT_RAW, &b) == NNG_ENOENT); - TEST_CHECK(nng_listener_getopt_bool(l, NNG_OPT_RAW, &b) == NNG_ENOENT); - - TEST_CHECK( - nng_dialer_getopt_size(d, NNG_OPT_RECVMAXSZ, &s) == NNG_ENOENT); - TEST_CHECK( - nng_listener_getopt_size(l, NNG_OPT_RECVMAXSZ, &s) == NNG_ENOENT); - - TEST_CHECK(nng_dialer_getopt_int(d, NNG_OPT_RAW, &i) == NNG_ENOENT); - TEST_CHECK(nng_listener_getopt_int(l, NNG_OPT_RAW, &i) == NNG_ENOENT); - - TEST_CHECK( - nng_dialer_getopt_ms(d, NNG_OPT_RECVTIMEO, &t) == NNG_ENOENT); - TEST_CHECK( - nng_listener_getopt_ms(l, NNG_OPT_SENDTIMEO, &t) == NNG_ENOENT); -} - -void -test_timeout_options(void) -{ - nng_socket s1; - nng_duration to; - size_t sz; - - char *cases[] = { - NNG_OPT_RECVTIMEO, - NNG_OPT_SENDTIMEO, - NNG_OPT_RECONNMAXT, - NNG_OPT_RECONNMINT, - NULL, - }; - - TEST_CHECK(nng_pair1_open(&s1) == 0); - for (int i = 0; cases[i] != NULL; i++) { - bool b; - TEST_CASE(cases[i]); - - // Can't receive a duration into zero bytes. - sz = 0; - TEST_CHECK(nng_getopt(s1, cases[i], &to, &sz) == NNG_EINVAL); - - // Type mismatches - TEST_CHECK(nng_getopt_bool(s1, cases[i], &b) == NNG_EBADTYPE); - sz = 1; - TEST_CHECK(nng_getopt(s1, cases[i], &b, &sz) == NNG_EINVAL); - - // Can set a valid duration - TEST_CHECK(nng_setopt_ms(s1, cases[i], 1234) == 0); - TEST_CHECK(nng_getopt_ms(s1, cases[i], &to) == 0); - TEST_CHECK(to == 1234); - - to = 0; - sz = sizeof(to); - TEST_CHECK(nng_getopt(s1, cases[i], &to, &sz) == 0); - TEST_CHECK(to == 1234); - TEST_CHECK(sz == sizeof(to)); - - // Can't set a negative duration - TEST_CHECK(nng_setopt_ms(s1, cases[i], -5) == NNG_EINVAL); - - // Can't pass a buf too small for duration - sz = sizeof(to) - 1; - to = 1; - TEST_CHECK(nng_setopt(s1, cases[i], &to, sz) == NNG_EINVAL); - } - TEST_CHECK(nng_close(s1) == 0); -} - -void -test_size_options(void) -{ - nng_socket s1; - size_t val; - size_t sz; - char * opt; - - char *cases[] = { - NNG_OPT_RECVMAXSZ, - NULL, - }; - - TEST_CHECK(nng_pair1_open(&s1) == 0); - for (int i = 0; (opt = cases[i]) != NULL; i++) { - TEST_CASE(opt); - - // Can't receive a size into zero bytes. - sz = 0; - TEST_CHECK(nng_getopt(s1, opt, &val, &sz) == NNG_EINVAL); - - // Can set a valid duration - TEST_CHECK(nng_setopt_size(s1, opt, 1234) == 0); - TEST_CHECK(nng_getopt_size(s1, opt, &val) == 0); - TEST_CHECK(val == 1234); - - val = 0; - sz = sizeof(val); - TEST_CHECK(nng_getopt(s1, opt, &val, &sz) == 0); - TEST_CHECK(val == 1234); - TEST_CHECK(sz == sizeof(val)); - - // Can't pass a buf too small for size - sz = sizeof(val) - 1; - val = 1; - TEST_CHECK(nng_setopt(s1, opt, &val, sz) == NNG_EINVAL); - - // We limit the limit to 4GB. Clear it if you want to - // ship more than 4GB at a time. -#if defined(_WIN64) || defined(_LP64) - val = 0x10000u; - val <<= 30u; - TEST_CHECK(nng_setopt_size(s1, opt, val) == NNG_EINVAL); - TEST_CHECK(nng_getopt_size(s1, opt, &val) == 0); - TEST_CHECK(val == 1234); -#endif - } - TEST_CHECK(nng_close(s1) == 0); -} - -TEST_LIST = { - { "recv timeout", test_recv_timeout }, - { "recv non-block", test_recv_nonblock }, - { "send timeout", test_send_timeout }, - { "send non-block", test_send_nonblock }, - { "read only options", test_readonly_options }, - { "socket base", test_socket_base }, - { "socket name", test_socket_name }, - { "socket name oversize", test_socket_name_oversize }, - { "send recv", test_send_recv }, - { "send recv zero length", test_send_recv_zero_length }, - { "connection refused", test_connection_refused }, - { "late connection", test_late_connection }, - { "address busy", test_address_busy }, - { "bad url", test_bad_url }, - { "url option", test_url_option }, - { "listener options", test_listener_options }, - { "dialer options", test_dialer_options }, - { "timeout options", test_timeout_options }, - { "size options", test_size_options }, - { "endpoint absent options", test_endpoint_absent_options }, - { "endpoint types", test_endpoint_types }, - - { NULL, NULL }, -}; diff --git a/tests/tcp.c b/tests/tcp.c index 1288af01..eecc148a 100644 --- a/tests/tcp.c +++ b/tests/tcp.c @@ -1,5 +1,5 @@ // -// Copyright 2018 Staysail Systems, Inc. <info@staysail.tech> +// Copyright 2020 Staysail Systems, Inc. <info@staysail.tech> // Copyright 2018 Capitar IT Group BV <info@capitar.com> // Copyright 2018 Devolutions <info@devolutions.net> // @@ -63,205 +63,5 @@ check_props_v4(nng_msg *msg) TestMain("TCP Transport", { trantest_test_extended("tcp://127.0.0.1:%u", check_props_v4); - Convey("We cannot connect to wild cards", { - nng_socket s; - char addr[NNG_MAXADDRLEN]; - - So(nng_pair_open(&s) == 0); - Reset({ nng_close(s); }); - trantest_next_address(addr, "tcp://*:%u"); - So(nng_dial(s, addr, NULL, 0) == NNG_EADDRINVAL); - }); - - Convey("We can bind to wild card", { - nng_socket s1; - nng_socket s2; - char addr[NNG_MAXADDRLEN]; - - So(nng_pair_open(&s1) == 0); - So(nng_pair_open(&s2) == 0); - Reset({ - nng_close(s2); - nng_close(s1); - }); - trantest_next_address(addr, "tcp4://*:%u"); - So(nng_listen(s1, addr, NULL, 0) == 0); - // reset port back one - trantest_prev_address(addr, "tcp://127.0.0.1:%u"); - So(nng_dial(s2, addr, NULL, 0) == 0); - }); - - Convey("We can bind to port zero", { - nng_socket s1; - nng_socket s2; - nng_sockaddr sa; - nng_listener l; - char * addr; - - So(nng_pair_open(&s1) == 0); - So(nng_pair_open(&s2) == 0); - Reset({ - nng_close(s2); - nng_close(s1); - }); - So(nng_listen(s1, "tcp://127.0.0.1:0", &l, 0) == 0); - So(nng_listener_getopt_string(l, NNG_OPT_URL, &addr) == 0); - So(memcmp(addr, "tcp://", 6) == 0); - So(nng_listener_getopt_sockaddr(l, NNG_OPT_LOCADDR, &sa) == 0); - So(sa.s_in.sa_family == NNG_AF_INET); - So(sa.s_in.sa_port != 0); - So(sa.s_in.sa_addr = htonl(0x7f000001)); - So(nng_dial(s2, addr, NULL, 0) == 0); - nng_strfree(addr); - }); - - Convey("We can use local interface to connect", { - nng_socket s1; - nng_socket s2; - char addr[NNG_MAXADDRLEN]; - - So(nng_pair_open(&s1) == 0); - So(nng_pair_open(&s2) == 0); - Reset({ - nng_close(s2); - nng_close(s1); - }); - trantest_next_address(addr, "tcp://127.0.0.1:%u"); - So(nng_listen(s1, addr, NULL, 0) == 0); - // reset port back one - trantest_prev_address(addr, "tcp://127.0.0.1;127.0.0.1:%u"); - So(nng_dial(s2, addr, NULL, 0) == 0); - }); - - Convey("Botched local interfaces fail resonably", { - nng_socket s1; - - So(nng_pair_open(&s1) == 0); - Reset({ nng_close(s1); }); - So(nng_dial(s1, "tcp://1x.2;127.0.0.1:80", NULL, 0) == - NNG_EADDRINVAL); - }); - - Convey("Can't specify address that isn't ours", { - nng_socket s1; - - So(nng_pair_open(&s1) == 0); - Reset({ nng_close(s1); }); - So(nng_dial(s1, "tcp://8.8.8.8;127.0.0.1:80", NULL, 0) == - NNG_EADDRINVAL); - }); - - Convey("Malformed TCP addresses do not panic", { - nng_socket s1; - - So(nng_pair_open(&s1) == 0); - Reset({ nng_close(s1); }); - So(nng_dial(s1, "tcp://127.0.0.1", NULL, 0) == NNG_EADDRINVAL); - So(nng_dial(s1, "tcp://127.0.0.1.32", NULL, 0) == - NNG_EADDRINVAL); - So(nng_dial(s1, "tcp://127.0.x.1.32", NULL, 0) == - NNG_EADDRINVAL); - So(nng_listen(s1, "tcp://127.0.0.1.32", NULL, 0) == - NNG_EADDRINVAL); - So(nng_listen(s1, "tcp://127.0.x.1.32", NULL, 0) == - NNG_EADDRINVAL); - }); - - Convey("No delay option", { - nng_socket s; - nng_dialer d; - nng_listener l; - bool v; - int x; - - So(nng_pair_open(&s) == 0); - Reset({ nng_close(s); }); - So(nng_getopt_bool(s, NNG_OPT_TCP_NODELAY, &v) == 0); - So(v == true); - So(nng_dialer_create(&d, s, "tcp://127.0.0.1:4999") == 0); - So(nng_dialer_getopt_bool(d, NNG_OPT_TCP_NODELAY, &v) == 0); - So(v == true); - So(nng_dialer_setopt_bool(d, NNG_OPT_TCP_NODELAY, false) == 0); - So(nng_dialer_getopt_bool(d, NNG_OPT_TCP_NODELAY, &v) == 0); - So(v == false); - So(nng_dialer_getopt_int(d, NNG_OPT_TCP_NODELAY, &x) == - NNG_EBADTYPE); - x = 0; - So(nng_dialer_setopt_int(d, NNG_OPT_TCP_NODELAY, x) == - NNG_EBADTYPE); - // This assumes sizeof (bool) != sizeof (int) - So(nng_dialer_setopt(d, NNG_OPT_TCP_NODELAY, &x, sizeof(x)) == - NNG_EINVAL); - - So(nng_listener_create(&l, s, "tcp://127.0.0.1:4999") == 0); - So(nng_listener_getopt_bool(l, NNG_OPT_TCP_NODELAY, &v) == 0); - So(v == true); - x = 0; - So(nng_listener_setopt_int(l, NNG_OPT_TCP_NODELAY, x) == - NNG_EBADTYPE); - // This assumes sizeof (bool) != sizeof (int) - So(nng_listener_setopt( - l, NNG_OPT_TCP_NODELAY, &x, sizeof(x)) == NNG_EINVAL); - - nng_dialer_close(d); - nng_listener_close(l); - - // Make sure socket wide defaults apply. - So(nng_setopt_bool(s, NNG_OPT_TCP_NODELAY, true) == 0); - v = false; - So(nng_getopt_bool(s, NNG_OPT_TCP_NODELAY, &v) == 0); - So(v == true); - So(nng_setopt_bool(s, NNG_OPT_TCP_NODELAY, false) == 0); - So(nng_dialer_create(&d, s, "tcp://127.0.0.1:4999") == 0); - So(nng_dialer_getopt_bool(d, NNG_OPT_TCP_NODELAY, &v) == 0); - So(v == false); - }); - - Convey("Keepalive option", { - nng_socket s; - nng_dialer d; - nng_listener l; - bool v; - int x; - - So(nng_pair_open(&s) == 0); - Reset({ nng_close(s); }); - So(nng_getopt_bool(s, NNG_OPT_TCP_KEEPALIVE, &v) == 0); - So(v == false); - So(nng_dialer_create(&d, s, "tcp://127.0.0.1:4999") == 0); - So(nng_dialer_getopt_bool(d, NNG_OPT_TCP_KEEPALIVE, &v) == 0); - So(v == false); - So(nng_dialer_setopt_bool(d, NNG_OPT_TCP_KEEPALIVE, true) == - 0); - So(nng_dialer_getopt_bool(d, NNG_OPT_TCP_KEEPALIVE, &v) == 0); - So(v == true); - So(nng_dialer_getopt_int(d, NNG_OPT_TCP_KEEPALIVE, &x) == - NNG_EBADTYPE); - x = 1; - So(nng_dialer_setopt_int(d, NNG_OPT_TCP_KEEPALIVE, x) == - NNG_EBADTYPE); - - So(nng_listener_create(&l, s, "tcp://127.0.0.1:4999") == 0); - So(nng_listener_getopt_bool(l, NNG_OPT_TCP_KEEPALIVE, &v) == - 0); - So(v == false); - x = 1; - So(nng_listener_setopt_int(l, NNG_OPT_TCP_KEEPALIVE, x) == - NNG_EBADTYPE); - - nng_dialer_close(d); - nng_listener_close(l); - - // Make sure socket wide defaults apply. - So(nng_setopt_bool(s, NNG_OPT_TCP_KEEPALIVE, false) == 0); - v = true; - So(nng_getopt_bool(s, NNG_OPT_TCP_KEEPALIVE, &v) == 0); - So(v == false); - So(nng_setopt_bool(s, NNG_OPT_TCP_KEEPALIVE, true) == 0); - So(nng_dialer_create(&d, s, "tcp://127.0.0.1:4999") == 0); - So(nng_dialer_getopt_bool(d, NNG_OPT_TCP_KEEPALIVE, &v) == 0); - So(v == true); - }); - nng_fini(); }) |