RoboidControl-cpp/Windows/WindowsParticipant.cpp

#include "WindowsParticipant.h"

#if defined(_WIN32) || defined(_WIN64)
#include <winsock2.h>
#include <ws2tcpip.h>
#pragma comment(lib, "ws2_32.lib")

#elif defined(__unix__) || defined(__APPLE__)
#include <arpa/inet.h>
#include <fcntl.h>  // For fcntl
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>
#endif

namespace RoboidControl {
namespace Windows {

void LocalParticipant::Setup(int localPort, const char* remoteIpAddress, int remotePort) {
#if defined(_WIN32) || defined(_WIN64)

  // Create a UDP socket
#if defined(_WIN32) || defined(_WIN64)
  // Windows-specific Winsock initialization
  WSADATA wsaData;
  if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {
    std::cerr << "WSAStartup failed" << std::endl;
    return;
  }
#endif

#if defined(_WIN32) || defined(_WIN64)
  this->sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
#elif defined(__unix__) || defined(__APPLE__)
  this->sock = socket(AF_INET, SOCK_DGRAM, 0);
#endif

  if (this->sock < 0) {
    std::cerr << "Error creating socket" << std::endl;
    return;
  }

// Set the socket to non-blocking mode
#if defined(_WIN32) || defined(_WIN64)
  u_long mode = 1;  // 1 to enable non-blocking socket
  ioctlsocket(this->sock, FIONBIO, &mode);
#elif defined(__unix__) || defined(__APPLE__)
  int flags = fcntl(this->sock, F_GETFL, 0);
  fcntl(this->sock, F_SETFL, flags | O_NONBLOCK);
#endif

  if (remotePort != 0) {
    // Set up the address to send to
    memset(&remote_addr, 0, sizeof(remote_addr));
    remote_addr.sin_family = AF_INET;
    remote_addr.sin_port = htons((u_short)remotePort);
    if (inet_pton(AF_INET, remoteIpAddress, &remote_addr.sin_addr) <= 0) {
      std::cerr << "Invalid address" << std::endl;
#if defined(_WIN32) || defined(_WIN64)
      closesocket(sock);
      WSACleanup();
#elif defined(__unix__) || defined(__APPLE__)
      close(sock);
#endif
      return;
    }
  }

  // Set up the receiving address
  memset(&server_addr, 0, sizeof(server_addr));
  server_addr.sin_family = AF_INET;
  server_addr.sin_port = htons((u_short)localPort);
  if (inet_pton(AF_INET, "0.0.0.0", &server_addr.sin_addr) <= 0) {
    std::cerr << "Invalid address" << std::endl;
#if defined(_WIN32) || defined(_WIN64)
    closesocket(sock);
    WSACleanup();
#elif defined(__unix__) || defined(__APPLE__)
    close(sock);
#endif
    return;
  }

  // Bind the socket to the specified port
  if (bind(this->sock, (const struct sockaddr*)&server_addr, sizeof(server_addr)) < 0) {
    std::cerr << "Bind failed" << std::endl;
#if defined(_WIN32) || defined(_WIN64)
    closesocket(sock);
    WSACleanup();
#elif defined(__unix__) || defined(__APPLE__)
    close(sock);
#endif
  }

#endif
}

void LocalParticipant::Receive() {
#if defined(_WIN32) || defined(_WIN64)
  // char ip_str[INET_ADDRSTRLEN];
  // inet_ntop(AF_INET, &(server_addr.sin_addr), ip_str, INET_ADDRSTRLEN);
  // std::cout << this->name << " Receive on " << ip_str << ":"
  //           << ntohs(server_addr.sin_port) << "\n";

  sockaddr_in client_addr;
#if defined(_WIN32) || defined(_WIN64)
  int len = sizeof(client_addr);
#elif defined(__unix__) || defined(__APPLE__)
  socklen_t len = sizeof(client_addr);
#endif
  int packetSize = recvfrom(this->sock, buffer, sizeof(buffer), 0, (struct sockaddr*)&client_addr, &len);
  // std::cout << "received data " << packetSize << "\n";
  if (packetSize < 0) {
#if defined(_WIN32) || defined(_WIN64)
    int error_code = WSAGetLastError();  // Get the error code on Windows
    if (error_code != WSAEWOULDBLOCK)
      std::cerr << "recvfrom failed with error: " << error_code << std::endl;
#else
    // std::cerr << "recvfrom failed with error: " << packetSize << std::endl;
#endif
  } else if (packetSize > 0) {
    char sender_ipAddress[INET_ADDRSTRLEN];
    inet_ntop(AF_INET, &(client_addr.sin_addr), sender_ipAddress, INET_ADDRSTRLEN);
    unsigned int sender_port = ntohs(client_addr.sin_port);

    ReceiveData(packetSize, sender_ipAddress, sender_port);
    // RoboidControl::LocalParticipant* remoteParticipant = this->GetParticipant(sender_ipAddress, sender_port);
    // if (remoteParticipant == nullptr) {
    //   remoteParticipant = this->AddParticipant(sender_ipAddress, sender_port);
    //   // std::cout << "New sender " << sender_ipAddress << ":"
    //   //           << sender_port << "\n";
    //   // std::cout << "New remote participant " <<
    //   // remoteParticipant->ipAddress
    //   // << ":"
    //   //           << remoteParticipant->port << " "
    //   //           << (int)remoteParticipant->networkId << "\n";
    // }

    // ReceiveData(packetSize, remoteParticipant);
  }
#endif
}

bool LocalParticipant::Send(Participant* remoteParticipant, int bufferSize) {
#if defined(_WIN32) || defined(_WIN64)
  char ip_str[INET_ADDRSTRLEN];
  inet_ntop(AF_INET, &(remote_addr.sin_addr), ip_str, INET_ADDRSTRLEN);
  std::cout << "Send to " << ip_str << ":" << ntohs(remote_addr.sin_port) << "\n";
  int sent_bytes = sendto(sock, this->buffer, bufferSize, 0, (struct sockaddr*)&remote_addr, sizeof(remote_addr));
#if defined(_WIN32) || defined(_WIN64)
  if (sent_bytes <= SOCKET_ERROR) {
    int error_code = WSAGetLastError();  // Get the error code on Windows
    std::cerr << "sendto failed with error: " << error_code << std::endl;
    closesocket(sock);
    WSACleanup();
    return false;
  }
#elif defined(__unix__) || defined(__APPLE__)
  if (sent_bytes < 0) {
    std::cerr << "sendto failed with error: " << sent_bytes << std::endl;
    close(sock);
    return false;
  }
#endif
#endif
  return true;
}

bool LocalParticipant::Publish(IMessage* msg) {
#if defined(_WIN32) || defined(_WIN64)
  int bufferSize = msg->Serialize(this->buffer);
  if (bufferSize <= 0)
    return true;

  char ip_str[INET_ADDRSTRLEN];
  inet_ntop(AF_INET, &(broadcast_addr.sin_addr), ip_str, INET_ADDRSTRLEN);
  std::cout << "Publish to " << ip_str << ":" << ntohs(broadcast_addr.sin_port) << "\n";
  int sent_bytes = sendto(sock, this->buffer, bufferSize, 0, (struct sockaddr*)&broadcast_addr, sizeof(broadcast_addr));
#if defined(_WIN32) || defined(_WIN64)
  if (sent_bytes <= SOCKET_ERROR) {
    int error_code = WSAGetLastError();  // Get the error code on Windows
    std::cerr << "sendto failed with error: " << error_code << std::endl;
    closesocket(sock);
    WSACleanup();
    return false;
  }
#elif defined(__unix__) || defined(__APPLE__)
  if (sent_bytes < 0) {
    std::cerr << "sendto failed with error: " << sent_bytes << std::endl;
    close(sock);
    return false;
  }
#endif
#endif
  return true;
}

}  // namespace Windows
}  // namespace RoboidControl