demo version

demo/camera_client/dependencies/libvisiontransfer/visiontransfer/networking.cpp

@@ -0,0 +1,158 @@
+/*******************************************************************************
+ * Copyright (c) 2021 Nerian Vision GmbH
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *******************************************************************************/
+
+#include "visiontransfer/networking.h"
+#include "visiontransfer/exceptions.h"
+#include <cstring>
+#include <fcntl.h>
+
+using namespace std;
+using namespace visiontransfer;
+using namespace visiontransfer::internal;
+
+namespace visiontransfer {
+namespace internal {
+
+void Networking::initNetworking() {
+#ifdef _WIN32
+    // In windows, we first have to initialize winsock
+    WSADATA wsaData;
+    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
+        throw TransferException("WSAStartup failed!");
+    }
+#endif
+}
+
+addrinfo* Networking::resolveAddress(const char* address, const char* service) {
+    addrinfo hints;
+    memset(&hints, 0, sizeof(hints));
+    hints.ai_family = AF_INET; // Use IPv4
+    hints.ai_socktype = SOCK_STREAM;
+    hints.ai_flags = 0;
+    hints.ai_protocol = 0;
+
+    addrinfo* addressInfo = nullptr;
+
+    if(getaddrinfo(address, service, &hints, &addressInfo) != 0 || addressInfo == nullptr) {
+        TransferException ex("Error resolving address: " + string(strerror(errno)));
+        throw ex;
+    }
+
+    if(addressInfo->ai_addrlen != sizeof(sockaddr_in)) {
+        throw TransferException("Illegal address length");
+    }
+
+    return addressInfo;
+}
+
+SOCKET Networking::connectTcpSocket(const addrinfo* address) {
+    SOCKET sock = ::socket(address->ai_family, address->ai_socktype,
+        address->ai_protocol);
+    if(sock == INVALID_SOCKET) {
+        TransferException ex("Error creating socket: " + string(strerror(errno)));
+        throw ex;
+    }
+
+    if(connect(sock, address->ai_addr, static_cast<int>(address->ai_addrlen)) < 0) {
+        TransferException ex("Error connection to destination address: " + string(strerror(errno)));
+        throw ex;
+    }
+
+    return sock;
+}
+
+void Networking::setSocketTimeout(SOCKET socket, int timeoutMillisec) {
+#ifdef _WIN32
+    unsigned int timeout = timeoutMillisec;
+#else
+    struct timeval timeout;
+    timeout.tv_sec = timeoutMillisec/1000;
+    timeout.tv_usec = timeoutMillisec*1000;
+#endif
+
+    setsockopt(socket, SOL_SOCKET, SO_RCVTIMEO, reinterpret_cast<char*>(&timeout), sizeof(timeout));
+    setsockopt(socket, SOL_SOCKET, SO_SNDTIMEO, reinterpret_cast<char*>(&timeout), sizeof(timeout));
+}
+
+void Networking::closeSocket(SOCKET& socket) {
+    setSocketBlocking(socket, false);
+    shutdown(socket, SHUT_WR);
+
+    // Receive remaining data
+    char buffer[1024];
+    for(int i=0; i<3; i++) {
+        int received = recv(socket, buffer, sizeof(buffer), 0);
+        if(received <= 0) {
+            break;
+        }
+    }
+
+    close(socket);
+    socket = INVALID_SOCKET;
+}
+
+void Networking::setSocketBlocking(SOCKET socket, bool blocking) {
+#ifdef _WIN32
+    unsigned long on = (blocking ? 0 : 1);
+    ioctlsocket(socket, FIONBIO, &on);
+#else
+    int flags = fcntl(socket, F_GETFL, 0);
+    if(flags != -1) {
+        if(blocking) {
+            flags &= ~O_NONBLOCK;
+        } else {
+            flags |= O_NONBLOCK;
+        }
+        fcntl(socket, F_SETFL, flags);
+    }
+#endif
+}
+
+void Networking::enableReuseAddress(SOCKET socket, bool reuse) {
+    int enable = reuse ? 1 : 0;
+    setsockopt(socket, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*>(&enable), sizeof(int));
+}
+
+void Networking::bindSocket(SOCKET socket, const addrinfo* addressInfo) {
+    if (::bind(socket, addressInfo->ai_addr, static_cast<int>(addressInfo->ai_addrlen)) < 0)  {
+        TransferException ex("Error binding socket: " + string(strerror(errno)));
+        throw ex;
+    }
+}
+
+SOCKET Networking::acceptConnection(SOCKET socket, sockaddr_in& remoteAddress) {
+    socklen_t clientAddressLength = sizeof(sockaddr_in);
+
+    SOCKET newSocket = accept(socket, reinterpret_cast<sockaddr *>(&remoteAddress),
+        &clientAddressLength);
+
+    if(clientAddressLength != sizeof(sockaddr_in)) {
+        throw TransferException("Received network address with invalid length");
+    }
+
+    if(newSocket == INVALID_SOCKET) {
+        if(errno == EWOULDBLOCK || errno == ETIMEDOUT) {
+            // No connection
+            return INVALID_SOCKET;
+        } else {
+            TransferException ex("Error accepting connection: " + string(strerror(errno)));
+            throw ex;
+        }
+    }
+
+    return newSocket;
+}
+
+}} // namespace
+