Merge pull request #14 from Haivision/development

Author: datagutt

.github/workflows/abi.yml

@@ -26,7 +26,7 @@ jobs:
       run: |
         cd gitview_pr
         mkdir _build && cd _build
-        cmake -DCMAKE_BUILD_TYPE=Debug -DENABLE_UNITTESTS=OFF ../
+        cmake -DCMAKE_BUILD_TYPE=Debug ../
     - id: build
       name: Build and dump
       run: |
@@ -81,7 +81,7 @@ jobs:
         fi
         cd gitview_base
         mkdir _build && cd _build
-        cmake -DCMAKE_BUILD_TYPE=Debug -DENABLE_UNITTESTS=OFF ../
+        cmake -DCMAKE_BUILD_TYPE=Debug ../
     - id: build_tag
       name: Build and dump
       if: ${{ success() }}

.github/workflows/cxx11-ubuntu.yaml

@@ -9,16 +9,14 @@ on:
 jobs:
   build:
     name: ubuntu
-    runs-on: ubuntu-22.04
+    runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v3
     - name: configure
       run: |
         mkdir _build && cd _build
         cmake ../ -DCMAKE_COMPILE_WARNING_AS_ERROR=ON -DENABLE_STDCXX_SYNC=ON -DENABLE_ENCRYPTION=ON -DENABLE_UNITTESTS=ON -DENABLE_BONDING=ON -DENABLE_TESTING=ON -DENABLE_EXAMPLES=ON -DENABLE_CODE_COVERAGE=ON -DCMAKE_EXPORT_COMPILE_COMMANDS=ON
     - name: build
-      # That below is likely SonarQube remains, which was removed earlier.
-      #run: cd _build && build-wrapper-linux-x86-64 --out-dir ${{ env.BUILD_WRAPPER_OUT_DIR }} cmake --build .
       run: cd _build && cmake --build .
     - name: test
       run: |

CMakeLists.txt

@@ -469,7 +469,7 @@ if ("${USE_CXX_STD_LIB}" EQUAL 98)
 	# but on Windows we don't support non-C++11 compiling anymore.
 	add_definitions(-DHVU_EXT_INCLUDE_SYNC="../srtcore/srt_sync_cxx98.h")
 else()
-	string(APPEND FEATURE_REPORT "LOGGER_SYNC=std ")
+	string(APPEND FEATURE_REPORT "LOGGER_SYNC=c++std ")
 endif()
 
 # add extra warning flags for gccish compilers
@@ -494,6 +494,7 @@ message(STATUS "WARNING OPTIONS: ${SRT_GCC_WARN}")
 # --------------------------------------------
 # Post-option variable synchronization
 # and option-to-preprocessor-macro transition
+# (Optional features)
 # --------------------------------------------
 
 # Global independet settings
@@ -525,34 +526,6 @@ if (NOT DEFINED SRT_LOG_SLOWDOWN_FREQ_MS)
 endif()
 list(APPEND SRT_EXTRA_CFLAGS "-DSRT_LOG_SLOWDOWN_FREQ_MS=${SRT_LOG_SLOWDOWN_FREQ_MS}")
 
-if (NOT ENABLE_STDCXX_SYNC)
-	if (ENABLE_MONOTONIC_CLOCK)
-		# Require monotonic clock, unless it's explicitly set OFF
-		list(PREPEND CMAKE_REQUIRED_LIBRARIES "${CMAKE_THREAD_LIBS_INIT}")
-
-		# Note: pthread_condattr_setclock doesn't exist on some systems, at least
-		# old versions of Android (__ANDROID_API__ < 21) are known to not provide it
-		check_symbol_exists(pthread_condattr_setclock "pthread.h" HAVE_PTHREAD_CONDATTR_SETCLOCK)
-		test_requires_clock_gettime(HAVE_MONOTONIC_CLOCK_GETTIME MONOTONIC_CLOCK_LINKLIB)
-		if (NOT HAVE_MONOTONIC_CLOCK_GETTIME OR NOT HAVE_PTHREAD_CONDATTR_SETCLOCK)
-			message(FATAL_ERROR "Your platform does not support CLOCK_MONOTONIC. Build with -DENABLE_MONOTONIC_CLOCK=OFF.")
-		endif()
-		if (NOT MONOTONIC_CLOCK_LINKLIB STREQUAL "")
-			set (WITH_EXTRALIBS "${WITH_EXTRALIBS} ${MONOTONIC_CLOCK_LINKLIB}")
-		endif()
-		add_definitions(-DSRT_ENABLE_MONOTONIC_CLOCK=1)
-		string(APPEND FEATURE_REPORT "SYNC=POSIX CLOCK=MONOTONIC ")
-		message(STATUS "SYNC LIBRARY: POSIX, MONOTONIC CLOCK: ON")
-	else()
-		string(APPEND FEATURE_REPORT "SYNC=POSIX CLOCK=SYSTEM ")
-		message(WARNING
-"ENABLE_MONOTONIC_CLOCK is OFF. This is dangerous.
-SRT may malfunction, if the system time is changed during transmission.")
-	endif()
-else()
-		string(APPEND FEATURE_REPORT "SYNC=C++std ")
-endif()
-
 if (USE_GNUSTL)
 	pkg_check_modules (GNUSTL REQUIRED gnustl)
 	link_directories(${GNUSTL_LIBRARY_DIRS})
@@ -673,6 +646,7 @@ endif()
 if (LINUX)
 # This is an option supported only on Linux
 	add_definitions(-DSRT_ENABLE_BINDTODEVICE)
+	string(APPEND FEATURE_REPORT "BINDTODEVICE=ON ")
 endif()
 
 if (USE_STATIC_LIBSTDCXX)
@@ -698,20 +672,71 @@ else ()
 	message(STATUS "Threads: cmake-default: ${PTHREAD_LIBRARY}")
 endif()
 
-# To avoid the need for other judgments when ENABLE_STDCXX_SYNC is OFF in the future, this is a separate conditional statement.
-if (NOT ENABLE_STDCXX_SYNC AND ENABLE_MONOTONIC_CLOCK)
+# Check the feature of PTHREAD providing pthread_atfork function.
+# Regardless of the current thread support library, this is a function
+# called as a callback at fork() call. This is required so that SRT
+# library can be used with applications that do fork().
+
+if (NOT MICROSOFT AND NOT MINGW)
+	# Do not enforce pthread library in case of MICROSOFT
+	# because it dosn't need fork() support (even if someone
+	# might want to try to compile for Windows with pthreads).
+
 	list(PREPEND CMAKE_REQUIRED_LIBRARIES "${PTHREAD_LIBRARY}")
 	unset(CMAKE_REQUIRED_QUIET)
-	check_symbol_exists(pthread_condattr_setclock "pthread.h" HAVE_PTHREAD_CONDATTR_SETCLOCK)
-	message(STATUS "Checking pthread_condattr_setclock: '${HAVE_PTHREAD_CONDATTR_SETCLOCK}'")
-	if ("${HAVE_PTHREAD_CONDATTR_SETCLOCK}" STREQUAL "1")
-		string(APPEND FEATURE_REPORT "PTHREAD_COND_CLOCK=monotonic ")
-		add_definitions(-DHAVE_PTHREAD_CONDATTR_SETCLOCK=1)
-	else ()
-		string(APPEND FEATURE_REPORT "PTHREAD_COND_CLOCK=system ")
-		message(WARNING "NOT FOUND pthread_cond_timedwait. pthread_cond_timedwait will use system clock. Recommended -DENABLE_STDCXX_SYNC=ON")
+
+	check_symbol_exists(pthread_atfork "pthread.h" HAVE_PTHREAD_ATFORK)
+	if ("${HAVE_PTHREAD_ATFORK}" STREQUAL "1")
+		add_definitions(-DHAVE_PTHREAD_ATFORK=1)
+		string(APPEND FEATURE_REPORT "ATFORK=ON ")
 	endif ()
-endif ()
+endif()
+
+if (NOT ENABLE_STDCXX_SYNC)
+	if (ENABLE_MONOTONIC_CLOCK)
+		# Require monotonic clock, unless it's explicitly set OFF
+		list(PREPEND CMAKE_REQUIRED_LIBRARIES "${CMAKE_THREAD_LIBS_INIT}")
+
+		# Note: pthread_condattr_setclock doesn't exist on some systems, at least
+		# old versions of Android (__ANDROID_API__ < 21) are known to not provide it
+		check_symbol_exists(pthread_condattr_setclock "pthread.h" HAVE_PTHREAD_CONDATTR_SETCLOCK)
+		test_requires_clock_gettime(HAVE_MONOTONIC_CLOCK_GETTIME MONOTONIC_CLOCK_LINKLIB)
+		if (NOT HAVE_MONOTONIC_CLOCK_GETTIME OR NOT HAVE_PTHREAD_CONDATTR_SETCLOCK)
+			message(FATAL_ERROR "Your platform does not support CLOCK_MONOTONIC. Build with -DENABLE_MONOTONIC_CLOCK=OFF.")
+		endif()
+		if (NOT MONOTONIC_CLOCK_LINKLIB STREQUAL "")
+			set (WITH_EXTRALIBS "${WITH_EXTRALIBS} ${MONOTONIC_CLOCK_LINKLIB}")
+		endif()
+		add_definitions(-DSRT_ENABLE_MONOTONIC_CLOCK=1)
+		string(APPEND FEATURE_REPORT "SYNC=POSIX CLOCK=monotonic ")
+		message(STATUS "SYNC LIBRARY: POSIX, MONOTONIC CLOCK: ON")
+
+		# Add-unique not supported in cmake, use unload version
+		list(FIND CMAKE_REQUIRED_QUIET "${PTHREAD_LIBRARY}" HAVE_ALREADY)
+		if (NOT HAVE_ALREADY)
+			list(PREPEND CMAKE_REQUIRED_LIBRARIES "${PTHREAD_LIBRARY}")
+		endif()
+		unset(CMAKE_REQUIRED_QUIET)
+		check_symbol_exists(pthread_condattr_setclock "pthread.h" HAVE_PTHREAD_CONDATTR_SETCLOCK)
+		message(STATUS "Checking pthread_condattr_setclock: '${HAVE_PTHREAD_CONDATTR_SETCLOCK}'")
+		if ("${HAVE_PTHREAD_CONDATTR_SETCLOCK}" STREQUAL "1")
+			string(APPEND FEATURE_REPORT "PTHREAD_COND_CLOCK=monotonic ")
+			add_definitions(-DHAVE_PTHREAD_CONDATTR_SETCLOCK=1)
+		else ()
+			string(APPEND FEATURE_REPORT "PTHREAD_COND_CLOCK=system ")
+			message(WARNING "NOT FOUND pthread_cond_timedwait. pthread_cond_timedwait will use system clock. Recommended -DENABLE_STDCXX_SYNC=ON")
+		endif ()
+
+	else()
+		string(APPEND FEATURE_REPORT "SYNC=POSIX CLOCK=SYSTEM PTHREAD_COND_CLOCK=system ")
+		message(WARNING
+"ENABLE_MONOTONIC_CLOCK is OFF. This is dangerous.
+SRT may malfunction, if the system time is changed during transmission.")
+	endif()
+else()
+	string(APPEND FEATURE_REPORT "SYNC=C++std ")
+endif()
+
 
 # When you use crosscompiling, you have to take care that PKG_CONFIG_PATH
 # and CMAKE_PREFIX_PATH are set properly.

docs/API/API-functions.md

@@ -2968,13 +2968,13 @@ associated with the last error. The system error is:
 const char* srt_strerror(int code, int errnoval);
 ```
 
-Returns a string message that represents a given SRT error code and possibly the
-`errno` value, if not 0.
+Returns a string message that represents a given SRT error code.
 
-**NOTE:** *This function isn't thread safe. It uses a static variable to hold the
-error description. There's no problem with using it in a multithreaded environment,
-as long as only one thread in the whole application calls this function at the
-moment*
+**NOTE:** *The `errnoval` parameter is ignored. This function's old version
+was intended to get both the SRT error description and system error description,
+but this requires resolution of the reentrancy problem and dynamic strings.
+For getting the error description for a system error, you need to use the
+`strerror` function or some of its reentrant version.*
 
 
 [:arrow_up:   Back to List of Functions & Structures](#srt-api-functions)

examples/fork-test/Makefile

@@ -0,0 +1,9 @@
+TARGETS=srt_server srt_client
+
+all: $(TARGETS)
+
+%: %.c
+	$(CC) $< `pkg-config --cflags --libs srt` -o `basename $< .c`
+
+clean:
+	rm -f $(TARGETS)

examples/fork-test/README.md

@@ -0,0 +1,7 @@
+The `srt_server` and `srt_client` apps should be compiled using
+external installation of SRT (e.g. in the local directory), each
+one as a single program. This is not compiled as a part of SRT.
+
+If you want to use a local installation, simply set `PKG_CONFIG_PATH`
+environment variable to point to the local installation directory with
+"lib/pkgconfig" or "lib64/pkgconfig" suffix.

examples/fork-test/srt_client.c

@@ -0,0 +1,55 @@
+#include <srt/srt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <arpa/inet.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#define SERVER_IP "127.0.0.1"
+#define SERVER_PORT 9000
+int main() {
+    if (srt_startup() != 0) {
+        fprintf(stderr, "Error initializing SRT.\n");
+        return 1;
+    }
+    SRTSOCKET client_sock = srt_create_socket();
+    if (client_sock == SRT_INVALID_SOCK) {
+        fprintf(stderr, "Error creating a socket: %s\n", srt_getlasterror_str());
+        return 1;
+    }
+    struct sockaddr_in sa;
+    memset(&sa, 0, sizeof sa);
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(SERVER_PORT);
+    inet_pton(AF_INET, SERVER_IP, &sa.sin_addr);
+    if (srt_connect(client_sock, (struct sockaddr*)&sa, sizeof(sa)) == SRT_ERROR) {
+        fprintf(stderr, "Error: srt_connect: %s\n", srt_getlasterror_str());
+        return 1;
+    }
+    printf("Connected to SRT server %s:%d\n", SERVER_IP, SERVER_PORT);
+    const char* message = "Hello from SRT client!";
+    int bytes = srt_send(client_sock, message, strlen(message));
+    if (bytes == SRT_ERROR) {
+        fprintf(stderr, "Sending error: %s\n", srt_getlasterror_str());
+    } else {
+        printf("Message sent: %s\n", message);
+    }
+
+    while (1)
+    {
+        char buffer[1500];
+        int nb = srt_recv(client_sock, buffer, sizeof(buffer));
+        if (nb <= 0)
+        {
+            printf("Closed from the server !\n");
+            srt_close(client_sock);
+            break;
+        }
+        buffer[nb] = 0;
+        printf("Server has sent: %s\n", buffer);
+    }
+    srt_cleanup();
+    return 0;
+}
+

examples/fork-test/srt_server.c

@@ -0,0 +1,118 @@
+#include <srt/srt.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <pthread.h>
+#define PORT 9000
+
+int run(char *command) {
+    pid_t pid = fork();
+    if (pid < 0) {
+        perror("fork (intermediate)");
+        exit(EXIT_FAILURE);
+    }
+    if (pid > 0) {
+        // Parent process
+        printf("[GRANDPARENT %d] waiting for grand-child process pid=%d to finish...\n",
+                             getpid(),                               pid);
+        waitpid(pid, NULL, 0);  // Wait for intermediate child
+        printf("[GRANDPARENT] returning\n");
+        return 0;
+    }
+    // Intermediate process
+    //srt_cleanup();
+    if (setsid() < 0) {
+        perror("setsid");
+        exit(EXIT_FAILURE);
+    }
+    pid_t grandchild_pid = fork();
+    if (grandchild_pid < 0) {
+        perror("fork (grandchild)");
+        exit(EXIT_FAILURE);
+    }
+    if (grandchild_pid > 0) {
+        printf("[PARENT %d] waiting for 10s with child process pid=%d ...\n",
+                        getpid(),                                  grandchild_pid);
+        // Intermediate process exits immediately
+        sleep(10);
+        printf("[PARENT] exitting\n");
+        exit(0);
+    }
+    // Grandchild process
+    // Redirect stdin to /dev/null
+    printf("[CHILD %d] Preparing descriptors...\n", getpid());
+    int devnull = open("/dev/null", O_RDONLY);
+    if (devnull >= 0) {
+        dup2(devnull, STDIN_FILENO);
+        close(devnull);
+    } else {
+        perror("open /dev/null");
+    }
+    // Redirect stdout to stderr
+    dup2(STDERR_FILENO, STDOUT_FILENO);
+    // Execute the command
+    printf("[CHILD] Executing process '%s'...\n", command);
+    execl("/bin/sh", "sh", "-c", command, (char *)NULL);
+    // If execl fails
+    perror("execl");
+    exit(EXIT_FAILURE);
+}
+
+int main() {
+    if (srt_startup() != 0) {
+        fprintf(stderr, "Error initializing SRT.\n");
+        return 1;
+    }
+
+    SRTSOCKET serv_sock = srt_create_socket();
+    if (serv_sock == SRT_INVALID_SOCK) {
+        fprintf(stderr, "Error creating SRT socket: %s\n", srt_getlasterror_str());
+        return 1;
+    }
+    struct sockaddr_in sa;
+    memset(&sa, 0, sizeof sa);
+    sa.sin_family = AF_INET;
+    sa.sin_port = htons(PORT);
+    sa.sin_addr.s_addr = INADDR_ANY;
+    if (srt_bind(serv_sock, (struct sockaddr*)&sa, sizeof sa) == SRT_ERROR) {
+        fprintf(stderr, "Error: srt_bind: %s\n", srt_getlasterror_str());
+        return 1;
+    }
+    if (srt_listen(serv_sock, 5) == SRT_ERROR) {
+        fprintf(stderr, "Error: srt_listen: %s\n", srt_getlasterror_str());
+        return 1;
+    }
+    printf("SRT server is listening on port %d...\n", PORT);
+    struct sockaddr_in client_addr;
+    int addr_len = sizeof(client_addr);
+    SRTSOCKET client_sock = srt_accept(serv_sock, (struct sockaddr*)&client_addr, &addr_len);
+    if (client_sock == SRT_INVALID_SOCK) {
+        fprintf(stderr, "Error: srt_accept: %s\n", srt_getlasterror_str());
+        return 1;
+    }
+    printf("Client connected via SRT !\n");
+    char buffer[1500];
+    int bytes = srt_recv(client_sock, buffer, sizeof(buffer));
+    if (bytes > 0) {
+        buffer[bytes] = '\0';
+        printf("Message received: %s\n", buffer);
+        const char resp [] = "We read you!";
+        srt_send(client_sock, resp, (sizeof resp)-1);
+    } else {
+        printf("Error: reading from srt_recv: %s.\n", srt_getlasterror_str());
+    }
+    run("date > /tmp/res");
+    printf("Server: sleep(1)\n");
+    sleep(1);
+    // Nettoyage
+    printf("Server: closing SRT sockets\n");
+    srt_close(client_sock);
+    srt_close(serv_sock);
+    printf("Server: cleanup\n");
+    srt_cleanup();
+    printf("Server: exit\n");
+    return 0;
+}