libmp/src/mptp/client.c

#include "../../include/error.h"
#include "../../include/mptp.h"
#include "../../include/util.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;

  if(!lm_mptp_socket_opts(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);

  pdebug(__func__, "printing the packet dump");
  pdebug_binary(buffer, sizeof(buffer));

  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, strerror(errno));
    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);

  pdebug(__func__, "printing the packet dump");
  pdebug_binary(buffer, sizeof(buffer));

  return true;
}