native_connection.c

Go to the documentation of this file.

/**
 * @file
 * @brief Wraps accepted sockets with transport metadata and provides connection IO and lifecycle helpers.
 */
 
#include "native_connection.h"
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#ifdef _WIN32
#include <winsock2.h>
#include <ws2tcpip.h>
#define native_connection_close_socket closesocket
#define native_connection_shutdown_socket(fd) shutdown((SOCKET)(fd), SD_BOTH)
#define native_connection_recv(fd, buffer, len) recv((SOCKET)(fd), (char *)(buffer), (int)(len), 0)
#define native_connection_send(fd, buffer, len) send((SOCKET)(fd), (const char *)(buffer), (int)(len), 0)
#else
#include <arpa/inet.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/un.h>
#include <unistd.h>
#define native_connection_close_socket close
#define native_connection_shutdown_socket(fd) shutdown((fd), SHUT_RDWR)
#define native_connection_recv(fd, buffer, len) recv((fd), (buffer), (len), 0)
#define native_connection_send(fd, buffer, len) send((fd), (buffer), (len), 0)
#endif
 
#define NATIVE_CONNECTION_IO_TIMEOUT_SECONDS 15
 
#ifdef _WIN32
#define native_connection_strdup _strdup
#else
#define native_connection_strdup strdup
#endif
 
static char *native_connection_format_sockaddr(const struct sockaddr *addr, socklen_t addr_len) {
  char buffer[512];
  if (addr == NULL) {
    return native_connection_strdup("unknown");
  }
  if (addr->sa_family == AF_INET && addr_len >= (socklen_t)sizeof(struct sockaddr_in)) {
    const struct sockaddr_in *in = (const struct sockaddr_in *)addr;
    char ip[INET_ADDRSTRLEN];
    if (inet_ntop(AF_INET, &in->sin_addr, ip, sizeof(ip)) == NULL) {
      return native_connection_strdup("tcp");
    }
    snprintf(buffer, sizeof(buffer), "%s:%u", ip, (unsigned int)ntohs(in->sin_port));
    return native_connection_strdup(buffer);
  }
#ifndef _WIN32
  if (addr->sa_family == AF_UNIX && addr_len >= (socklen_t)sizeof(struct sockaddr_un)) {
    const struct sockaddr_un *un = (const struct sockaddr_un *)addr;
    if (un->sun_path[0] != '\0') {
      return native_connection_strdup(un->sun_path);
    }
    return native_connection_strdup("unix");
  }
#endif
  return native_connection_strdup("unknown");
}
 
static NativeTransportType native_connection_detect_transport(int fd) {
  struct sockaddr_storage addr;
  socklen_t addr_len = (socklen_t)sizeof(addr);
  memset(&addr, 0, sizeof(addr));
  if (getsockname(fd, (struct sockaddr *)&addr, &addr_len) != 0) {
    return NATIVE_TRANSPORT_UNKNOWN;
  }
  if (addr.ss_family == AF_INET) {
    return NATIVE_TRANSPORT_TCP;
  }
#ifndef _WIN32
  if (addr.ss_family == AF_UNIX) {
    return NATIVE_TRANSPORT_UNIX;
  }
#endif
  return NATIVE_TRANSPORT_UNKNOWN;
}
 
static void native_connection_apply_timeouts(int fd) {
#ifdef _WIN32
  DWORD timeout_ms = NATIVE_CONNECTION_IO_TIMEOUT_SECONDS * 1000U;
  setsockopt((SOCKET)fd, SOL_SOCKET, SO_RCVTIMEO, (const char *)&timeout_ms, sizeof(timeout_ms));
  setsockopt((SOCKET)fd, SOL_SOCKET, SO_SNDTIMEO, (const char *)&timeout_ms, sizeof(timeout_ms));
#else
  struct timeval timeout;
  timeout.tv_sec = NATIVE_CONNECTION_IO_TIMEOUT_SECONDS;
  timeout.tv_usec = 0;
  setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
  setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout));
#endif
}
 
static void native_connection_populate_endpoint_info(NativeConnection *connection) {
  struct sockaddr_storage peer_addr;
  struct sockaddr_storage local_addr;
  socklen_t peer_len = (socklen_t)sizeof(peer_addr);
  socklen_t local_len = (socklen_t)sizeof(local_addr);
  if (connection == NULL || connection->fd < 0) {
    return;
  }
  memset(&peer_addr, 0, sizeof(peer_addr));
  memset(&local_addr, 0, sizeof(local_addr));
  free(connection->peer_info);
  connection->peer_info = NULL;
  free(connection->local_info);
  connection->local_info = NULL;
  if (getpeername(connection->fd, (struct sockaddr *)&peer_addr, &peer_len) == 0) {
    connection->peer_info = native_connection_format_sockaddr((const struct sockaddr *)&peer_addr, peer_len);
  }
  if (getsockname(connection->fd, (struct sockaddr *)&local_addr, &local_len) == 0) {
    connection->local_info = native_connection_format_sockaddr((const struct sockaddr *)&local_addr, local_len);
  }
  if (connection->peer_info == NULL) {
    connection->peer_info = native_connection_strdup("unknown");
  }
  if (connection->local_info == NULL) {
    connection->local_info = native_connection_strdup("unknown");
  }
}
 
void native_connection_init(NativeConnection *connection) {
  if (connection == NULL) {
    return;
  }
  connection->fd = -1;
  connection->transport_type = NATIVE_TRANSPORT_UNKNOWN;
  connection->peer_info = NULL;
  connection->local_info = NULL;
}
 
void native_connection_reset(NativeConnection *connection) {
  if (connection == NULL) {
    return;
  }
  free(connection->peer_info);
  free(connection->local_info);
  connection->peer_info = NULL;
  connection->local_info = NULL;
  connection->fd = -1;
  connection->transport_type = NATIVE_TRANSPORT_UNKNOWN;
}
 
int native_connection_accept_next(int server_fd, volatile sig_atomic_t *shutdown_requested, NativeConnection *connection) {
  int accepted = -1;
#ifdef _WIN32
  SOCKET socket_value = accept((SOCKET)server_fd, NULL, NULL);
  if (socket_value == INVALID_SOCKET) {
    if (shutdown_requested != NULL && *shutdown_requested) {
      return 0;
    }
    return -1;
  }
  accepted = (int)socket_value;
#else
  accepted = accept(server_fd, NULL, NULL);
  if (accepted == -1) {
    if (shutdown_requested != NULL && *shutdown_requested) {
      return 0;
    }
    return -1;
  }
#endif
  if (connection == NULL) {
    native_connection_close_socket(accepted);
    return -1;
  }
  native_connection_reset(connection);
  native_connection_apply_timeouts(accepted);
  connection->fd = accepted;
  connection->transport_type = native_connection_detect_transport(accepted);
  native_connection_populate_endpoint_info(connection);
  return 1;
}
 
int native_connection_read(NativeConnection *connection, void *buffer, size_t len) {
  if (connection == NULL || connection->fd < 0 || buffer == NULL) {
    return -1;
  }
  return (int)native_connection_recv(connection->fd, buffer, len);
}
 
int native_connection_write(NativeConnection *connection, const void *buffer, size_t len) {
  size_t sent = 0;
  if (connection == NULL || connection->fd < 0 || (buffer == NULL && len > 0)) {
    return -1;
  }
  while (sent < len) {
    int wrote = (int)native_connection_send(connection->fd, (const char *)buffer + sent, len - sent);
    if (wrote <= 0) {
      return -1;
    }
    sent += (size_t)wrote;
  }
  return 0;
}
 
int native_connection_flush(NativeConnection *connection) {
  (void)connection;
  return 0;
}
 
int native_connection_close(NativeConnection *connection) {
  int code = 0;
  if (connection == NULL) {
    return 0;
  }
  if (connection->fd >= 0) {
    code = native_connection_close_socket(connection->fd) == 0 ? 0 : -1;
  }
  native_connection_reset(connection);
  return code;
}
 
int native_connection_shutdown(NativeConnection *connection) {
  if (connection == NULL || connection->fd < 0) {
    return 0;
  }
  return native_connection_shutdown_socket(connection->fd) == 0 ? 0 : -1;
}
 
const char *native_connection_peer_info(const NativeConnection *connection) {
  return connection != NULL && connection->peer_info != NULL ? connection->peer_info : "unknown";
}
 
const char *native_connection_local_info(const NativeConnection *connection) {
  return connection != NULL && connection->local_info != NULL ? connection->local_info : "unknown";
}
 
NativeTransportType native_connection_transport_type(const NativeConnection *connection) {
  return connection != NULL ? connection->transport_type : NATIVE_TRANSPORT_UNKNOWN;
}
 
const char *native_connection_transport_type_name(const NativeConnection *connection) {
  switch (native_connection_transport_type(connection)) {
    case NATIVE_TRANSPORT_TCP:
      return "tcp";
    case NATIVE_TRANSPORT_UNIX:
      return "unix";
    default:
      return "unknown";
  }
}