new: implement more pool stuff, start working on package functions

src/mptp/client.c

@@ -0,0 +1,128 @@
+#include "../../include/error.h"
+#include "../../include/mptp.h"
+#include "../../include/util.h"
+
+#include <arpa/inet.h>
+#include <stdbool.h>
+#include <string.h>
+#include <errno.h>
+
+int lm_mptp_client_connect(char *addr, uint16_t port) {
+  struct sockaddr saddr;
+  int             sock;
+
+  bzero(&saddr, sizeof(saddr));
+
+  if ((sock = lm_mptp_socket(addr, port, &saddr)) < 0)
+    return -1;
+
+  struct timeval timeout;
+  bzero(&timeout, sizeof(timeout));
+
+  timeout.tv_sec  = MPTP_TIMEOUT;
+  timeout.tv_usec = 0;
+
+  if (setsockopt(sock, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(timeout)) < 0) {
+    lm_error_set(LM_ERR_MPTPSetsockopt);
+    lm_mptp_close(sock);
+    return -1;
+  }
+
+  if (connect(sock, &saddr, sizeof(saddr)) < 0) {
+    lm_mptp_close(sock);
+    lm_error_set(LM_ERR_MPTPConnectFail);
+    return -1;
+  }
+
+  return sock;
+}
+
+bool lm_mptp_client_verify(lm_mptp_t *packet) {
+  if (!lm_mptp_verify(packet))
+    return false;
+
+  if (MPTP_IS_REQUEST(packet)) {
+    lm_error_set(LM_ERR_MPTPNotResponse);
+    return false;
+  }
+
+  if (packet->header.host_size != 0) {
+    lm_error_set(LM_ERR_MPTPBadHost);
+    return false;
+  }
+
+  return true;
+}
+
+bool lm_mptp_client_send(int sock, lm_mptp_t *packet) {
+  if (NULL == packet) {
+    lm_error_set(LM_ERR_ArgNULL);
+    return false;
+  }
+
+  if (MPTP_FLAGS_VERSION(packet) != MPTP_VERSION_SUPPORTED) {
+    lm_error_set(LM_ERR_MPTPBadVersion);
+    return false;
+  }
+
+  if (packet->header.data_size > MPTP_DATA_MAX) {
+    lm_error_set(LM_ERR_MPTPBadData);
+    return false;
+  }
+
+  if (packet->header.host_size > MPTP_HOST_MAX || packet->header.host_size <= 0) {
+    lm_error_set(LM_ERR_MPTPBadHost);
+    return false;
+  }
+
+  char    buffer[sizeof(packet->header) + packet->header.host_size + packet->header.data_size];
+  ssize_t total = sizeof(buffer), used = 0;
+
+  packet->header.flags = htons(packet->header.flags);
+
+  copy_to_buffer(buffer, &packet->header, sizeof(packet->header), &total, &used);
+  copy_to_buffer(buffer, packet->host, packet->header.host_size, &total, &used);
+  copy_to_buffer(buffer, packet->data, packet->header.data_size, &total, &used);
+
+  if (send(sock, buffer, sizeof(buffer), 0) < 0) {
+    lm_error_set(LM_ERR_MPTPSendFail);
+    return false;
+  }
+
+  return true;
+}
+
+bool lm_mptp_client_recv(int sock, lm_mptp_t *packet) {
+  if (NULL == packet) {
+    lm_error_set(LM_ERR_ArgNULL);
+    return false;
+  }
+
+  char    buffer[sizeof(packet->header) + MPTP_HOST_MAX + MPTP_DATA_MAX];
+  ssize_t total = sizeof(buffer), used = 0;
+
+  bzero(buffer, sizeof(buffer));
+  bzero(packet, sizeof(lm_mptp_t));
+
+  if (recv(sock, buffer, sizeof(buffer), 0) < 0) {
+    if (ETIMEDOUT == errno || EAGAIN == errno) {
+      lm_error_set(LM_ERR_MPTPTimeout);
+      return false;
+    }
+    lm_error_set(LM_ERR_MPTPRecvFail);
+    return false;
+  }
+
+  copy_from_buffer(&packet->header, buffer, sizeof(packet->header), &total, &used);
+  packet->header.flags = ntohs(packet->header.flags);
+  // packet->header.host_size  = ntohs(packet->header.host_size);
+  // packet->header.data_size  = ntohs(packet->header.data_size);
+
+  if (packet->header.host_size <= MPTP_HOST_MAX)
+    copy_from_buffer(&packet->host, buffer, packet->header.host_size, &total, &used);
+
+  if (packet->header.data_size <= MPTP_DATA_MAX)
+    copy_from_buffer(&packet->data, buffer, packet->header.data_size, &total, &used);
+
+  return true;
+}

src/mptp/mptp.c

@@ -0,0 +1,175 @@
+#include "../../include/error.h"
+#include "../../include/mptp.h"
+#include "../../include/url.h"
+
+#include <stdbool.h>
+#include <string.h>
+#include <unistd.h>
+
+bool lm_mptp_init(lm_mptp_t *packet, bool is_request, uint8_t code, bool is_last) {
+  packet->header.flags     = 0;
+  packet->header.data_size = 0;
+  packet->header.host_size = 0;
+
+  bzero(packet->data, MPTP_DATA_MAX);
+  bzero(packet->host, MPTP_HOST_MAX);
+
+  if (code > MPTP_CODE_MAX) {
+    lm_error_set(LM_ERR_MPTPBadCode);
+    return false;
+  }
+
+  packet->header.flags |= (MPTP_VERSION_SUPPORTED << 8);
+
+  if (is_request)
+    packet->header.flags |= (MPTP_REQUEST << 7);
+  else
+    packet->header.flags |= (MPTP_RESPONSE << 7);
+
+  packet->header.flags |= (code << 4);
+
+  if (is_last || is_request)
+    packet->header.flags |= (1 << 3);
+  else
+    packet->header.flags |= (0 << 3);
+
+  return true;
+}
+
+bool lm_mptp_verify(lm_mptp_t *packet) {
+  if (NULL == packet) {
+    lm_error_set(LM_ERR_ArgNULL);
+    return false;
+  }
+
+  if (MPTP_FLAGS_VERSION(packet) != MPTP_VERSION_SUPPORTED) {
+    lm_error_set(LM_ERR_MPTPBadVersion);
+    return false;
+  }
+
+  if (packet->header.data_size > MPTP_DATA_MAX || packet->header.data_size < 0) {
+    lm_error_set(LM_ERR_MPTPBadData);
+    return false;
+  }
+
+  if (MPTP_FLAGS_CODE(packet) > MPTP_CODE_MAX || MPTP_FLAGS_CODE(packet) < 0) {
+    lm_error_set(LM_ERR_MPTPBadCode);
+    return false;
+  }
+
+  return true;
+}
+
+int lm_mptp_socket(char *addr, uint16_t port, struct sockaddr *saddr) {
+  if (NULL == addr || NULL == saddr) {
+    lm_error_set(LM_ERR_ArgNULL);
+    return -1;
+  }
+
+  struct addrinfo hints, *res, *cur;
+  int             sock = 0, status = 0, family = -1;
+
+  bzero(&hints, sizeof(hints));
+  hints.ai_family   = AF_UNSPEC;
+  hints.ai_socktype = SOCK_DGRAM;
+
+  if ((status = getaddrinfo(addr, NULL, &hints, &res)) < 0) {
+    lm_error_set(LM_ERR_MPTPHostFail);
+    return -1;
+  }
+
+  for (cur = res; cur != NULL; cur = cur->ai_next) {
+    switch (cur->ai_family) {
+    case AF_INET:
+      family                   = cur->ai_family;
+      struct sockaddr_in *ipv4 = (struct sockaddr_in *)cur->ai_addr;
+      ipv4->sin_port           = htons(port);
+
+      memcpy(saddr, cur->ai_addr, sizeof(struct sockaddr));
+      break;
+
+    case AF_INET6:
+      family                    = cur->ai_family;
+      struct sockaddr_in6 *ipv6 = (struct sockaddr_in6 *)cur->ai_addr;
+      ipv6->sin6_port           = htons(port);
+
+      memcpy(saddr, cur->ai_addr, sizeof(struct sockaddr));
+      break;
+    }
+
+    if (family != -1)
+      break;
+  }
+
+  freeaddrinfo(res);
+
+  if (family == -1) {
+    lm_error_set(LM_ERR_MPTPHostFail);
+    return -1;
+  }
+
+  if ((sock = socket(family, SOCK_DGRAM, IPPROTO_UDP)) < 0) {
+    lm_error_set(LM_ERR_MPTPSocketFail);
+    return -1;
+  }
+
+  return sock;
+}
+
+void lm_mptp_close(int sock) {
+  close(sock);
+}
+
+bool lm_mptp_set_host(lm_mptp_t *packet, char *host) {
+  size_t size = strlen(host);
+  if (size > MPTP_HOST_MAX || size < 0) {
+    lm_error_set(LM_ERR_MPTPBadHost);
+    return false;
+  }
+
+  // do NOT copy the NULL terminator
+  packet->header.host_size = size;
+  memcpy(packet->host, host, size);
+  return true;
+}
+
+bool lm_mptp_get_host(lm_mptp_t *packet, char *host) {
+  if (packet->header.host_size > MPTP_HOST_MAX || packet->header.host_size < 0) {
+    host = NULL;
+    lm_error_set(LM_ERR_BadHost);
+    return false;
+  }
+
+  memcpy(host, packet->host, packet->header.host_size);
+  host[packet->header.host_size] = 0;
+  return true;
+}
+
+bool lm_mptp_set_data(lm_mptp_t *packet, char *data, size_t size) {
+  if (size > MPTP_DATA_MAX || size < 0) {
+    lm_error_set(LM_ERR_MPTPBadData);
+    return false;
+  }
+
+  packet->header.data_size = size;
+  mempcpy(packet->data, data, size);
+  return true;
+}
+
+bool lm_mptp_get_data(lm_mptp_t *packet, char *data) {
+  if (packet->header.data_size > MPTP_DATA_MAX || packet->header.data_size < 0) {
+    data = NULL;
+    lm_error_set(LM_ERR_BadHost);
+    return false;
+  }
+
+  memcpy(data, packet->data, packet->header.data_size);
+  data[packet->header.data_size] = 0;
+  return true;
+}
+
+void lm_mptp_copy(lm_mptp_t *dst, lm_mptp_t *src) {
+  memcpy(&dst->header, &src->header, sizeof(dst->header));
+  memcpy(&dst->host, &src->data, sizeof(src->host));
+  memcpy(&dst->data, &src->data, sizeof(src->data));
+}

src/mptp/server.c

@@ -0,0 +1,118 @@
+#include "../../include/error.h"
+#include "../../include/mptp.h"
+#include "../../include/util.h"
+
+#include <arpa/inet.h>
+#include <stdbool.h>
+#include <string.h>
+
+int lm_mptp_server_listen(char *addr, uint16_t port) {
+  struct sockaddr saddr;
+  int             sock;
+
+  bzero(&saddr, sizeof(saddr));
+
+  if ((sock = lm_mptp_socket(addr, port, &saddr)) < 0)
+    return -1;
+
+  if (bind(sock, &saddr, sizeof(struct sockaddr)) < 0) {
+    lm_mptp_close(sock);
+    lm_error_set(LM_ERR_MPTPBindFail);
+    return -1;
+  }
+
+  return sock;
+}
+
+bool lm_mptp_server_verify(lm_mptp_t *packet) {
+  if (!lm_mptp_verify(packet))
+    return false;
+
+  if (!MPTP_IS_REQUEST(packet)) {
+    lm_error_set(LM_ERR_MPTPNotRequest);
+    return false;
+  }
+
+  if (packet->header.host_size > MPTP_HOST_MAX || packet->header.host_size <= 0) {
+    lm_error_set(LM_ERR_MPTPBadHost);
+    return false;
+  }
+
+  if (!MPTP_IS_LAST(packet)) {
+    lm_error_set(LM_ERR_MPTPNotLast);
+    return false;
+  }
+
+  return true;
+}
+
+bool lm_mptp_server_recv(int sock, lm_mptp_t *packet, struct sockaddr *addr) {
+  if (NULL == packet || NULL == addr) {
+    lm_error_set(LM_ERR_ArgNULL);
+    return false;
+  }
+
+  char      buffer[sizeof(packet->header) + MPTP_HOST_MAX + MPTP_DATA_MAX];
+  socklen_t socklen = sizeof(struct sockaddr);
+  ssize_t   total = sizeof(buffer), used = 0;
+
+  bzero(buffer, sizeof(buffer));
+  bzero(packet, sizeof(lm_mptp_t));
+
+  if (recvfrom(sock, buffer, sizeof(buffer), 0, addr, &socklen) <= 0) {
+    lm_error_set(LM_ERR_MPTPRecvFail);
+    return false;
+  }
+
+  copy_from_buffer(&packet->header, buffer, sizeof(packet->header), &total, &used);
+  packet->header.flags = ntohs(packet->header.flags);
+  // packet->header.host_size  = ntohs(packet->header.host_size);
+  // packet->header.data_size  = ntohs(packet->header.data_size);
+
+  if (packet->header.host_size <= MPTP_HOST_MAX)
+    copy_from_buffer(&packet->host, buffer, packet->header.host_size, &total, &used);
+
+  if (packet->header.data_size <= MPTP_DATA_MAX)
+    copy_from_buffer(&packet->data, buffer, packet->header.data_size, &total, &used);
+
+  return true;
+}
+
+bool lm_mptp_server_send(int sock, lm_mptp_t *packet, struct sockaddr *addr) {
+  if (NULL == packet) {
+    lm_error_set(LM_ERR_ArgNULL);
+    return false;
+  }
+
+  if (MPTP_FLAGS_VERSION(packet) != MPTP_VERSION_SUPPORTED) {
+    lm_error_set(LM_ERR_MPTPBadVersion);
+    return false;
+  }
+
+  if (packet->header.data_size > MPTP_DATA_MAX) {
+    lm_error_set(LM_ERR_MPTPBadData);
+    return false;
+  }
+
+  if (packet->header.host_size != 0) {
+    lm_error_set(LM_ERR_MPTPBadHost);
+    return false;
+  }
+
+  socklen_t addrlen = sizeof(struct sockaddr);
+  char      buffer[sizeof(packet->header) + packet->header.host_size + packet->header.data_size];
+  ssize_t   total = sizeof(buffer), used = 0;
+
+  packet->header.flags = htons(packet->header.flags);
+
+  copy_to_buffer(buffer, &packet->header, sizeof(packet->header), &total, &used);
+  copy_to_buffer(buffer, packet->host, packet->header.host_size, &total, &used);
+  copy_to_buffer(buffer, packet->data, packet->header.data_size, &total, &used);
+
+  if (sendto(sock, buffer, sizeof(buffer), 0, addr, addrlen) < 0) {
+    lm_error_set(LM_ERR_MPTPSendFail);
+    return false;
+  }
+
+  return true;
+}