Fix potential problems caused by socket type mismatch between Linux and Windows

vdm-dev · vdm-dev · commit 26d0553b72cc · 2025-01-20T15:10:52.000+04:00
diff --git a/include/ur_client_library/comm/tcp_server.h b/include/ur_client_library/comm/tcp_server.h
@@ -79,7 +79,7 @@ class TCPServer
    * \param func Function handling the event information. The file descriptor created by the
    * connection event will be passed to the function.
    */
-  void setConnectCallback(std::function<void(const int)> func)
+  void setConnectCallback(std::function<void(const socket_t)> func)
   {
     new_connection_callback_ = func;
   }
@@ -90,7 +90,7 @@ class TCPServer
    * \param func Function handling the event information. The file descriptor created by the
    * connection event will be passed to the function.
    */
-  void setDisconnectCallback(std::function<void(const int)> func)
+  void setDisconnectCallback(std::function<void(const socket_t)> func)
   {
     disconnect_callback_ = func;
   }
@@ -101,7 +101,7 @@ class TCPServer
    * \param func Function handling the event information. The file client's file_descriptor will be
    * passed to the function as well as the actual message received from the client.
    */
-  void setMessageCallback(std::function<void(const int, char*, int)> func)
+  void setMessageCallback(std::function<void(const socket_t, char*, int)> func)
   {
     message_callback_ = func;
   }
@@ -132,7 +132,7 @@ class TCPServer
    *
    * \returns True on success, false otherwise
    */
-  bool write(const int fd, const uint8_t* buf, const size_t buf_len, size_t& written);
+  bool write(const socket_t fd, const uint8_t* buf, const size_t buf_len, size_t& written);
 
   /*!
    * \brief Get the maximum number of clients allowed to connect to this server
@@ -163,10 +163,10 @@ class TCPServer
   //! Handles connection events
   void handleConnect();
 
-  void handleDisconnect(const int fd);
+  void handleDisconnect(const socket_t fd);
 
   //! read data from socket
-  void readData(const int fd);
+  void readData(const socket_t fd);
 
   //! Event handler. Blocks until activity on any client or connection attempt
   void spin();
diff --git a/include/ur_client_library/comm/tcp_socket.h b/include/ur_client_library/comm/tcp_socket.h
@@ -57,9 +57,9 @@ class TCPSocket
   void setupOptions();
 
 protected:
-  static bool open(int socket_fd, struct sockaddr* address, size_t address_len)
+  static bool open(socket_t socket_fd, struct sockaddr* address, size_t address_len)
   {
-    return ::connect(socket_fd, address, address_len) == 0;
+    return ::connect(socket_fd, address, static_cast<socklen_t>(address_len)) == 0;
   }
 
   bool setup(const std::string& host, const int port, const size_t max_num_tries = 0,
@@ -90,7 +90,7 @@ class TCPSocket
    *
    * \returns The file descriptor of the socket
    */
-  int getSocketFD()
+  socket_t getSocketFD()
   {
     return socket_fd_;
   }
diff --git a/include/ur_client_library/control/reverse_interface.h b/include/ur_client_library/control/reverse_interface.h
@@ -142,13 +142,13 @@ class ReverseInterface
   setKeepaliveCount(const uint32_t count);
 
 protected:
-  virtual void connectionCallback(const int filedescriptor);
+  virtual void connectionCallback(const socket_t filedescriptor);
 
-  virtual void disconnectionCallback(const int filedescriptor);
+  virtual void disconnectionCallback(const socket_t filedescriptor);
 
-  virtual void messageCallback(const int filedescriptor, char* buffer, int nbytesrecv);
+  virtual void messageCallback(const socket_t filedescriptor, char* buffer, int nbytesrecv);
 
-  int client_fd_;
+  socket_t client_fd_;
   comm::TCPServer server_;
 
   template <typename T>
diff --git a/include/ur_client_library/control/script_command_interface.h b/include/ur_client_library/control/script_command_interface.h
@@ -164,11 +164,11 @@ class ScriptCommandInterface : public ReverseInterface
   }
 
 protected:
-  virtual void connectionCallback(const int filedescriptor) override;
+  virtual void connectionCallback(const socket_t filedescriptor) override;
 
-  virtual void disconnectionCallback(const int filedescriptor) override;
+  virtual void disconnectionCallback(const socket_t filedescriptor) override;
 
-  virtual void messageCallback(const int filedescriptor, char* buffer, int nbytesrecv) override;
+  virtual void messageCallback(const socket_t filedescriptor, char* buffer, int nbytesrecv) override;
 
 private:
   /*!
diff --git a/include/ur_client_library/control/script_sender.h b/include/ur_client_library/control/script_sender.h
@@ -63,13 +63,13 @@ class ScriptSender
 
   const std::string PROGRAM_REQUEST_ = std::string("request_program\n");
 
-  void connectionCallback(const int filedescriptor);
+  void connectionCallback(const socket_t filedescriptor);
 
-  void disconnectionCallback(const int filedescriptor);
+  void disconnectionCallback(const socket_t filedescriptor);
 
-  void messageCallback(const int filedescriptor, char* buffer);
+  void messageCallback(const socket_t filedescriptor, char* buffer);
 
-  void sendProgram(const int filedescriptor);
+  void sendProgram(const socket_t filedescriptor);
 };
 
 }  // namespace control
diff --git a/include/ur_client_library/control/trajectory_point_interface.h b/include/ur_client_library/control/trajectory_point_interface.h
@@ -145,11 +145,11 @@ class TrajectoryPointInterface : public ReverseInterface
   }
 
 protected:
-  virtual void connectionCallback(const int filedescriptor) override;
+  virtual void connectionCallback(const socket_t filedescriptor) override;
 
-  virtual void disconnectionCallback(const int filedescriptor) override;
+  virtual void disconnectionCallback(const socket_t filedescriptor) override;
 
-  virtual void messageCallback(const int filedescriptor, char* buffer, int nbytesrecv) override;
+  virtual void messageCallback(const socket_t filedescriptor, char* buffer, int nbytesrecv) override;
 
 private:
   std::function<void(TrajectoryResult)> handle_trajectory_end_;
diff --git a/include/ur_client_library/helpers.h b/include/ur_client_library/helpers.h
@@ -52,6 +52,7 @@ static inline pthread_t pthread_self()
 
 static inline int sched_get_priority_max(int policy)
 {
+  (void)policy;
   return THREAD_PRIORITY_TIME_CRITICAL;
 }
 
diff --git a/src/comm/tcp_server.cpp b/src/comm/tcp_server.cpp
@@ -172,8 +172,8 @@ void TCPServer::handleConnect()
 {
   struct sockaddr_storage client_addr;
   socklen_t addrlen = sizeof(client_addr);
-  int client_fd = accept(listen_fd_, (struct sockaddr*)&client_addr, &addrlen);
-  if (client_fd < 0)
+  socket_t client_fd = accept(listen_fd_, (struct sockaddr*)&client_addr, &addrlen);
+  if (client_fd == INVALID_SOCKET)
   {
     std::ostringstream ss;
     ss << "Failed to accept connection request on port  " << port_;
@@ -207,7 +207,7 @@ void TCPServer::spin()
   tempfds_ = masterfds_;
 
   // blocks until activity on any socket from tempfds
-  int sel = select(maxfd_ + 1, &tempfds_, NULL, NULL, NULL);
+  int sel = select(static_cast<int>(maxfd_ + 1), &tempfds_, NULL, NULL, NULL);
   if (sel < 0)
   {
     URCL_LOG_ERROR("select() failed. Shutting down socket event handler.");
@@ -239,7 +239,7 @@ void TCPServer::spin()
   }
 }
 
-void TCPServer::handleDisconnect(const int fd)
+void TCPServer::handleDisconnect(const socket_t fd)
 {
   URCL_LOG_DEBUG("%d disconnected.", fd);
   ur_close(fd);
@@ -259,7 +259,7 @@ void TCPServer::handleDisconnect(const int fd)
   }
 }
 
-void TCPServer::readData(const int fd)
+void TCPServer::readData(const socket_t fd)
 {
   memset(input_buffer_, 0, INPUT_BUFFER_SIZE);  // clear input buffer
   int nbytesrecv = recv(fd, input_buffer_, INPUT_BUFFER_SIZE, 0);
@@ -307,7 +307,7 @@ void TCPServer::start()
   worker_thread_ = std::thread(&TCPServer::worker, this);
 }
 
-bool TCPServer::write(const int fd, const uint8_t* buf, const size_t buf_len, size_t& written)
+bool TCPServer::write(const socket_t fd, const uint8_t* buf, const size_t buf_len, size_t& written)
 {
   written = 0;
 
@@ -316,7 +316,7 @@ bool TCPServer::write(const int fd, const uint8_t* buf, const size_t buf_len, si
   // handle partial sends
   while (written < buf_len)
   {
-    ssize_t sent = ::send(fd, reinterpret_cast<const char*>(buf + written), remaining, 0);
+    ssize_t sent = ::send(fd, reinterpret_cast<const char*>(buf + written), static_cast<socklen_t>(remaining), 0);
 
     if (sent <= 0)
     {
diff --git a/src/comm/tcp_socket.cpp b/src/comm/tcp_socket.cpp
@@ -191,7 +191,7 @@ bool TCPSocket::read(uint8_t* buf, const size_t buf_len, size_t& read)
   if (state_ != SocketState::Connected)
     return false;
 
-  ssize_t res = ::recv(socket_fd_, reinterpret_cast<char*>(buf), buf_len, 0);
+  ssize_t res = ::recv(socket_fd_, reinterpret_cast<char*>(buf), static_cast<const socklen_t>(buf_len), 0);
 
   if (res == 0)
   {
@@ -236,7 +236,7 @@ bool TCPSocket::write(const uint8_t* buf, const size_t buf_len, size_t& written)
   // handle partial sends
   while (written < buf_len)
   {
-    ssize_t sent = ::send(socket_fd_, reinterpret_cast<const char*>(buf + written), remaining, 0);
+    ssize_t sent = ::send(socket_fd_, reinterpret_cast<const char*>(buf + written), static_cast<socklen_t>(remaining), 0);
 
     if (sent <= 0)
     {
diff --git a/src/control/reverse_interface.cpp b/src/control/reverse_interface.cpp
@@ -35,7 +35,7 @@ namespace control
 {
 ReverseInterface::ReverseInterface(uint32_t port, std::function<void(bool)> handle_program_state,
                                    std::chrono::milliseconds step_time)
-  : client_fd_(-1)
+  : client_fd_(INVALID_SOCKET)
   , server_(port)
   , handle_program_state_(handle_program_state)
   , step_time_(step_time)
@@ -54,7 +54,7 @@ bool ReverseInterface::write(const vector6d_t* positions, const comm::ControlMod
                              const RobotReceiveTimeout& robot_receive_timeout)
 {
   const int message_length = 7;
-  if (client_fd_ == -1)
+  if (client_fd_ == INVALID_SOCKET)
   {
     return false;
   }
@@ -115,7 +115,7 @@ bool ReverseInterface::writeTrajectoryControlMessage(const TrajectoryControlMess
                                                      const RobotReceiveTimeout& robot_receive_timeout)
 {
   const int message_length = 3;
-  if (client_fd_ == -1)
+  if (client_fd_ == INVALID_SOCKET)
   {
     return false;
   }
@@ -162,7 +162,7 @@ bool ReverseInterface::writeFreedriveControlMessage(const FreedriveControlMessag
                                                     const RobotReceiveTimeout& robot_receive_timeout)
 {
   const int message_length = 2;
-  if (client_fd_ == -1)
+  if (client_fd_ == INVALID_SOCKET)
   {
     return false;
   }
@@ -212,9 +212,9 @@ void ReverseInterface::setKeepaliveCount(const uint32_t count)
   keep_alive_count_modified_deprecated_ = true;
 }
 
-void ReverseInterface::connectionCallback(const int filedescriptor)
+void ReverseInterface::connectionCallback(const socket_t filedescriptor)
 {
-  if (client_fd_ < 0)
+  if (client_fd_ == INVALID_SOCKET)
   {
     URCL_LOG_INFO("Robot connected to reverse interface. Ready to receive control commands.");
     client_fd_ = filedescriptor;
@@ -227,14 +227,14 @@ void ReverseInterface::connectionCallback(const int filedescriptor)
   }
 }
 
-void ReverseInterface::disconnectionCallback(const int filedescriptor)
+void ReverseInterface::disconnectionCallback(const socket_t filedescriptor)
 {
   URCL_LOG_INFO("Connection to reverse interface dropped.", filedescriptor);
-  client_fd_ = -1;
+  client_fd_ = INVALID_SOCKET;
   handle_program_state_(false);
 }
 
-void ReverseInterface::messageCallback(const int filedescriptor, char* buffer, int nbytesrecv)
+void ReverseInterface::messageCallback(const socket_t filedescriptor, char* buffer, int nbytesrecv)
 {
   URCL_LOG_WARN("Message on ReverseInterface received. The reverse interface currently does not support any message "
                 "handling. This message will be ignored.");
diff --git a/src/control/script_command_interface.cpp b/src/control/script_command_interface.cpp
@@ -227,9 +227,9 @@ bool ScriptCommandInterface::clientConnected()
   return client_connected_;
 }
 
-void ScriptCommandInterface::connectionCallback(const int filedescriptor)
+void ScriptCommandInterface::connectionCallback(const socket_t filedescriptor)
 {
-  if (client_fd_ < 0)
+  if (client_fd_ == INVALID_SOCKET)
   {
     URCL_LOG_DEBUG("Robot connected to ScriptCommandInterface.");
     client_fd_ = filedescriptor;
@@ -242,14 +242,14 @@ void ScriptCommandInterface::connectionCallback(const int filedescriptor)
   }
 }
 
-void ScriptCommandInterface::disconnectionCallback(const int filedescriptor)
+void ScriptCommandInterface::disconnectionCallback(const socket_t filedescriptor)
 {
   URCL_LOG_DEBUG("Connection to ScriptCommandInterface dropped.", filedescriptor);
-  client_fd_ = -1;
+  client_fd_ = INVALID_SOCKET;
   client_connected_ = false;
 }
 
-void ScriptCommandInterface::messageCallback(const int filedescriptor, char* buffer, int nbytesrecv)
+void ScriptCommandInterface::messageCallback(const socket_t filedescriptor, char* buffer, int nbytesrecv)
 {
   if (nbytesrecv == 4)
   {
diff --git a/src/control/script_sender.cpp b/src/control/script_sender.cpp
@@ -41,17 +41,17 @@ ScriptSender::ScriptSender(uint32_t port, const std::string& program)
   server_.start();
 }
 
-void ScriptSender::connectionCallback(const int filedescriptor)
+void ScriptSender::connectionCallback(const socket_t filedescriptor)
 {
   URCL_LOG_DEBUG("New client connected at FD %d.", filedescriptor);
 }
 
-void ScriptSender::disconnectionCallback(const int filedescriptor)
+void ScriptSender::disconnectionCallback(const socket_t filedescriptor)
 {
   URCL_LOG_DEBUG("Client at FD %d disconnected.", filedescriptor);
 }
 
-void ScriptSender::messageCallback(const int filedescriptor, char* buffer)
+void ScriptSender::messageCallback(const socket_t filedescriptor, char* buffer)
 {
   if (std::string(buffer) == PROGRAM_REQUEST_)
   {
@@ -60,7 +60,7 @@ void ScriptSender::messageCallback(const int filedescriptor, char* buffer)
   }
 }
 
-void ScriptSender::sendProgram(const int filedescriptor)
+void ScriptSender::sendProgram(const socket_t filedescriptor)
 {
   size_t len = program_.size();
   const uint8_t* data = reinterpret_cast<const uint8_t*>(program_.c_str());
diff --git a/src/control/trajectory_point_interface.cpp b/src/control/trajectory_point_interface.cpp
@@ -181,9 +181,9 @@ bool TrajectoryPointInterface::writeTrajectorySplinePoint(const vector6d_t* posi
   return server_.write(client_fd_, buffer, sizeof(buffer), written);
 }
 
-void TrajectoryPointInterface::connectionCallback(const int filedescriptor)
+void TrajectoryPointInterface::connectionCallback(const socket_t filedescriptor)
 {
-  if (client_fd_ < 0)
+  if (client_fd_ == INVALID_SOCKET)
   {
     URCL_LOG_DEBUG("Robot connected to trajectory interface.");
     client_fd_ = filedescriptor;
@@ -195,13 +195,13 @@ void TrajectoryPointInterface::connectionCallback(const int filedescriptor)
   }
 }
 
-void TrajectoryPointInterface::disconnectionCallback(const int filedescriptor)
+void TrajectoryPointInterface::disconnectionCallback(const socket_t filedescriptor)
 {
   URCL_LOG_DEBUG("Connection to trajectory interface dropped.", filedescriptor);
   client_fd_ = -1;
 }
 
-void TrajectoryPointInterface::messageCallback(const int filedescriptor, char* buffer, int nbytesrecv)
+void TrajectoryPointInterface::messageCallback(const socket_t filedescriptor, char* buffer, int nbytesrecv)
 {
   if (nbytesrecv == 4)
   {
diff --git a/tests/test_pipeline.cpp b/tests/test_pipeline.cpp
@@ -68,7 +68,7 @@ class PipelineTest : public ::testing::Test
     server_.reset();
   }
 
-  void connectionCallback(const int filedescriptor)
+  void connectionCallback(const socket_t filedescriptor)
   {
     std::lock_guard<std::mutex> lk(connect_mutex_);
     client_fd_ = filedescriptor;
@@ -89,7 +89,7 @@ class PipelineTest : public ::testing::Test
   }
 
   std::unique_ptr<comm::TCPServer> server_;
-  int client_fd_;
+  socket_t client_fd_;
 
   std::unique_ptr<comm::URStream<rtde_interface::RTDEPackage>> stream_;
   std::unique_ptr<rtde_interface::RTDEParser> parser_;
diff --git a/tests/test_producer.cpp b/tests/test_producer.cpp
diff --git a/tests/test_rtde_writer.cpp b/tests/test_rtde_writer.cpp
diff --git a/tests/test_stream.cpp b/tests/test_stream.cpp
diff --git a/tests/test_tcp_server.cpp b/tests/test_tcp_server.cpp
diff --git a/tests/test_tcp_socket.cpp b/tests/test_tcp_socket.cpp

Original file line number	Diff line number	Diff line change
`@@ -57,9 +57,9 @@ class TCPSocket`
`57`	`57`	`void setupOptions();`
`58`	`58`
`59`	`59`	`protected:`
`60`		`- static bool open(int socket_fd, struct sockaddr* address, size_t address_len)`
	`60`	`+ static bool open(socket_t socket_fd, struct sockaddr* address, size_t address_len)`
`61`	`61`	`{`
`62`		`- return ::connect(socket_fd, address, address_len) == 0;`
	`62`	`+ return ::connect(socket_fd, address, static_cast<socklen_t>(address_len)) == 0;`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`bool setup(const std::string& host, const int port, const size_t max_num_tries = 0,`
`@@ -90,7 +90,7 @@ class TCPSocket`
`90`	`90`	`*`
`91`	`91`	`* \returns The file descriptor of the socket`
`92`	`92`	`*/`
`93`		`- int getSocketFD()`
	`93`	`+ socket_t getSocketFD()`
`94`	`94`	`{`
`95`	`95`	`return socket_fd_;`
`96`	`96`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,6 +52,7 @@ static inline pthread_t pthread_self()`
`52`	`52`
`53`	`53`	`static inline int sched_get_priority_max(int policy)`
`54`	`54`	`{`
	`55`	`+ (void)policy;`
`55`	`56`	`return THREAD_PRIORITY_TIME_CRITICAL;`
`56`	`57`	`}`
`57`	`58`
Original file line number	Diff line number	Diff line change
`@@ -172,8 +172,8 @@ void TCPServer::handleConnect()`
`172`	`172`	`{`
`173`	`173`	`struct sockaddr_storage client_addr;`
`174`	`174`	`socklen_t addrlen = sizeof(client_addr);`
`175`		`- int client_fd = accept(listen_fd_, (struct sockaddr*)&client_addr, &addrlen);`
`176`		`- if (client_fd < 0)`
	`175`	`+ socket_t client_fd = accept(listen_fd_, (struct sockaddr*)&client_addr, &addrlen);`
	`176`	`+ if (client_fd == INVALID_SOCKET)`
`177`	`177`	`{`
`178`	`178`	`std::ostringstream ss;`
`179`	`179`	`ss << "Failed to accept connection request on port " << port_;`
`@@ -207,7 +207,7 @@ void TCPServer::spin()`
`207`	`207`	`tempfds_ = masterfds_;`
`208`	`208`
`209`	`209`	`// blocks until activity on any socket from tempfds`
`210`		`- int sel = select(maxfd_ + 1, &tempfds_, NULL, NULL, NULL);`
	`210`	`+ int sel = select(static_cast<int>(maxfd_ + 1), &tempfds_, NULL, NULL, NULL);`
`211`	`211`	`if (sel < 0)`
`212`	`212`	`{`
`213`	`213`	`URCL_LOG_ERROR("select() failed. Shutting down socket event handler.");`
`@@ -239,7 +239,7 @@ void TCPServer::spin()`
`239`	`239`	`}`
`240`	`240`	`}`
`241`	`241`
`242`		`-void TCPServer::handleDisconnect(const int fd)`
	`242`	`+void TCPServer::handleDisconnect(const socket_t fd)`
`243`	`243`	`{`
`244`	`244`	`URCL_LOG_DEBUG("%d disconnected.", fd);`
`245`	`245`	`ur_close(fd);`
`@@ -259,7 +259,7 @@ void TCPServer::handleDisconnect(const int fd)`
`259`	`259`	`}`
`260`	`260`	`}`
`261`	`261`
`262`		`-void TCPServer::readData(const int fd)`
	`262`	`+void TCPServer::readData(const socket_t fd)`
`263`	`263`	`{`
`264`	`264`	`memset(input_buffer_, 0, INPUT_BUFFER_SIZE); // clear input buffer`
`265`	`265`	`int nbytesrecv = recv(fd, input_buffer_, INPUT_BUFFER_SIZE, 0);`
`@@ -307,7 +307,7 @@ void TCPServer::start()`
`307`	`307`	`worker_thread_ = std::thread(&TCPServer::worker, this);`
`308`	`308`	`}`
`309`	`309`
`310`		`-bool TCPServer::write(const int fd, const uint8_t* buf, const size_t buf_len, size_t& written)`
	`310`	`+bool TCPServer::write(const socket_t fd, const uint8_t* buf, const size_t buf_len, size_t& written)`
`311`	`311`	`{`
`312`	`312`	`written = 0;`
`313`	`313`
`@@ -316,7 +316,7 @@ bool TCPServer::write(const int fd, const uint8_t* buf, const size_t buf_len, si`
`316`	`316`	`// handle partial sends`
`317`	`317`	`while (written < buf_len)`
`318`	`318`	`{`
`319`		`- ssize_t sent = ::send(fd, reinterpret_cast<const char*>(buf + written), remaining, 0);`
	`319`	`+ ssize_t sent = ::send(fd, reinterpret_cast<const char*>(buf + written), static_cast<socklen_t>(remaining), 0);`
`320`	`320`
`321`	`321`	`if (sent <= 0)`
`322`	`322`	`{`
Original file line number	Diff line number	Diff line change
`@@ -191,7 +191,7 @@ bool TCPSocket::read(uint8_t* buf, const size_t buf_len, size_t& read)`
`191`	`191`	`if (state_ != SocketState::Connected)`
`192`	`192`	`return false;`
`193`	`193`
`194`		`- ssize_t res = ::recv(socket_fd_, reinterpret_cast<char*>(buf), buf_len, 0);`
	`194`	`+ ssize_t res = ::recv(socket_fd_, reinterpret_cast<char*>(buf), static_cast<const socklen_t>(buf_len), 0);`
`195`	`195`
`196`	`196`	`if (res == 0)`
`197`	`197`	`{`
`@@ -236,7 +236,7 @@ bool TCPSocket::write(const uint8_t* buf, const size_t buf_len, size_t& written)`
`236`	`236`	`// handle partial sends`
`237`	`237`	`while (written < buf_len)`
`238`	`238`	`{`
`239`		`- ssize_t sent = ::send(socket_fd_, reinterpret_cast<const char*>(buf + written), remaining, 0);`
	`239`	`+ ssize_t sent = ::send(socket_fd_, reinterpret_cast<const char*>(buf + written), static_cast<socklen_t>(remaining), 0);`
`240`	`240`
`241`	`241`	`if (sent <= 0)`
`242`	`242`	`{`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ namespace control`
`35`	`35`	`{`
`36`	`36`	`ReverseInterface::ReverseInterface(uint32_t port, std::function<void(bool)> handle_program_state,`
`37`	`37`	`std::chrono::milliseconds step_time)`
`38`		`- : client_fd_(-1)`
	`38`	`+ : client_fd_(INVALID_SOCKET)`
`39`	`39`	`, server_(port)`
`40`	`40`	`, handle_program_state_(handle_program_state)`
`41`	`41`	`, step_time_(step_time)`
`@@ -54,7 +54,7 @@ bool ReverseInterface::write(const vector6d_t* positions, const comm::ControlMod`
`54`	`54`	`const RobotReceiveTimeout& robot_receive_timeout)`
`55`	`55`	`{`
`56`	`56`	`const int message_length = 7;`
`57`		`- if (client_fd_ == -1)`
	`57`	`+ if (client_fd_ == INVALID_SOCKET)`
`58`	`58`	`{`
`59`	`59`	`return false;`
`60`	`60`	`}`
`@@ -115,7 +115,7 @@ bool ReverseInterface::writeTrajectoryControlMessage(const TrajectoryControlMess`
`115`	`115`	`const RobotReceiveTimeout& robot_receive_timeout)`
`116`	`116`	`{`
`117`	`117`	`const int message_length = 3;`
`118`		`- if (client_fd_ == -1)`
	`118`	`+ if (client_fd_ == INVALID_SOCKET)`
`119`	`119`	`{`
`120`	`120`	`return false;`
`121`	`121`	`}`
`@@ -162,7 +162,7 @@ bool ReverseInterface::writeFreedriveControlMessage(const FreedriveControlMessag`
`162`	`162`	`const RobotReceiveTimeout& robot_receive_timeout)`
`163`	`163`	`{`
`164`	`164`	`const int message_length = 2;`
`165`		`- if (client_fd_ == -1)`
	`165`	`+ if (client_fd_ == INVALID_SOCKET)`
`166`	`166`	`{`
`167`	`167`	`return false;`
`168`	`168`	`}`
`@@ -212,9 +212,9 @@ void ReverseInterface::setKeepaliveCount(const uint32_t count)`
`212`	`212`	`keep_alive_count_modified_deprecated_ = true;`
`213`	`213`	`}`
`214`	`214`
`215`		`-void ReverseInterface::connectionCallback(const int filedescriptor)`
	`215`	`+void ReverseInterface::connectionCallback(const socket_t filedescriptor)`
`216`	`216`	`{`
`217`		`- if (client_fd_ < 0)`
	`217`	`+ if (client_fd_ == INVALID_SOCKET)`
`218`	`218`	`{`
`219`	`219`	`URCL_LOG_INFO("Robot connected to reverse interface. Ready to receive control commands.");`
`220`	`220`	`client_fd_ = filedescriptor;`
`@@ -227,14 +227,14 @@ void ReverseInterface::connectionCallback(const int filedescriptor)`
`227`	`227`	`}`
`228`	`228`	`}`
`229`	`229`
`230`		`-void ReverseInterface::disconnectionCallback(const int filedescriptor)`
	`230`	`+void ReverseInterface::disconnectionCallback(const socket_t filedescriptor)`
`231`	`231`	`{`
`232`	`232`	`URCL_LOG_INFO("Connection to reverse interface dropped.", filedescriptor);`
`233`		`- client_fd_ = -1;`
	`233`	`+ client_fd_ = INVALID_SOCKET;`
`234`	`234`	`handle_program_state_(false);`
`235`	`235`	`}`
`236`	`236`
`237`		`-void ReverseInterface::messageCallback(const int filedescriptor, char* buffer, int nbytesrecv)`
	`237`	`+void ReverseInterface::messageCallback(const socket_t filedescriptor, char* buffer, int nbytesrecv)`
`238`	`238`	`{`
`239`	`239`	`URCL_LOG_WARN("Message on ReverseInterface received. The reverse interface currently does not support any message "`
`240`	`240`	`"handling. This message will be ignored.");`