libmp/src/ctx/serve.c

#include "../../include/thpool.h"
#include "../../include/error.h"
#include "../../include/pool.h"
#include "../../include/util.h"
#include "../../include/ctx.h"

#include <errno.h>
#include <libgen.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>

struct lm_ctx_serve_thread_arg {
  lm_ctx_serve_callback_t callback;
  int             sock;
  struct sockaddr addr;
  lm_ctx_t *ctx;
  void *data;
};

void __lm_ctx_serve_thread(void *_arg) {
  struct lm_ctx_serve_thread_arg *arg = _arg;
  bool success = false;
  lm_mptp_t packet;

  if(!lm_mptp_server_recv(arg->sock, &packet)){
    pdebug(__func__, "%x: failed to receive packet (%s)", arg->addr, lm_strerror());
    return lm_mptp_close(arg->sock);
  }

  if (!lm_mptp_server_verify(&packet)) {
    pdebug(__func__, "%x: closing connection, failed to verify (%s)", arg->addr, lm_strerror());
    return lm_mptp_close(arg->sock);
  }

  char hostname[packet.header.host_size + 1]; // +1 for NULL terminator
  char path[packet.header.data_size + 1], *ppath = path;

  if (!lm_mptp_get_host(&packet, hostname)) {
    pdebug(__func__, "%x: closing connection, failed to get hostname (%s)", arg->addr, lm_strerror());
    goto end;
  }

  if (!lm_mptp_get_data(&packet, path)) {
    pdebug(__func__, "%x: closing connection, failed to get path (%s)", arg->addr, lm_strerror());
    goto end;
  }

  if(MPTP_FLAGS_CODE(&packet) == MPTP_C2S_PULL && (ppath = dirname(path)) == NULL){
    pdebug(__func__, "%x: closing connection, failed to get dirname (%s)", strerror(errno));
    goto end;
  }

  lm_pool_t *pool = lm_ctx_pool_by_url(arg->ctx, hostname, ppath);

  if (NULL == pool) {
    pdebug(__func__, "%x: unknown pool (%s), closing connection", arg->addr, hostname);
    lm_mptp_init(&packet, false, MPTP_S2C_BRUH, true);
    lm_mptp_server_send(arg->sock, &packet);
    goto end;
  }

  if(lm_pool_path_is_empty(pool)){
    pdebug(__func__, "%x: requested pool (%s) have empty paths, closing connection", arg->addr, pool->name);
    lm_mptp_init(&packet, false, MPTP_S2C_BRUH, true);
    lm_mptp_server_send(arg->sock, &packet);
    goto end;
  }

  if(!pool->loaded){
    pdebug(__func__, "%x: requested pool (%s) is not loaded, closing connection", arg->addr, pool->name);
    lm_mptp_init(&packet, false, MPTP_S2C_BRUH, true);
    lm_mptp_server_send(arg->sock, &packet);
    goto end;
  }

  success = true;

  switch (MPTP_FLAGS_CODE(&packet)) {
  // response PING with PONG
  case MPTP_C2S_PING:
    pdebug(__func__, "(%x) PING %s: returning PONG", arg->addr, pool->name);
    lm_mptp_init(&packet, false, MPTP_S2C_PONG, true);
    lm_mptp_server_send(arg->sock, &packet);
    break;

  // when INFO file is requested, send the file
  case MPTP_C2S_INFO:
    pdebug(__func__, "(%x) INFO %s: attempting to send info", arg->addr, pool->name);
    lm_mptp_sendfile(arg->sock, pool->info_file, NULL, NULL);
    break;

  // when LIST file is requested, send the file
  case MPTP_C2S_LIST:
    pdebug(__func__, "(%x) LIST %s: attempting to send list", arg->addr, pool->name);
    lm_mptp_sendfile(arg->sock, pool->list_file, NULL, NULL);
    break;

  // when the request code is PULL, send the requested package archive and
  // requested package signature
  case MPTP_C2S_PULL:
    // PULL request should contain package path,
    // if path (stored in the data field) is empty it's an invalid request
    if(packet.header.data_size <= 0){
      lm_mptp_init(&packet, false, MPTP_S2C_WHAT, true);
      lm_mptp_server_send(arg->sock, &packet);
      break;
    }

    pdebug(__func__, "(%x) PULL %s: attempting to send package archive and signature", arg->addr, pool->name);
    char path[packet.header.data_size + 1], *package = path;

    if(!lm_mptp_get_data(&packet, path)){
      // we should never be able to get here, if we do theres definetly a bug
      pdebug(__func__, "(%x) PULL %s: skipping, failed to get path: %s", arg->addr, pool->name, lm_strerror());
      break;
    }

    // if we can't get the package name, then theres something wrong with the request
    if((package = basename(path)) == NULL){
      lm_mptp_init(&packet, false, MPTP_S2C_WHAT, true);
      lm_mptp_server_send(arg->sock, &packet);
      break;
    }

    size_t package_size = strlen(package);
    char name[package_size+1], version[package_size+1];
    lm_pkg_t *pkg = NULL;

    // if we can't parse the package name, request is invalid
    if(!package_parse(package, name, version)){
      lm_mptp_init(&packet, false, MPTP_S2C_WHAT, true);
      lm_mptp_server_send(arg->sock, &packet);
      break;
    }

    // if the package is not found in the pool, tell the client
    if((pkg = lm_pool_package_find(pool, name, version)) == NULL){
      lm_mptp_init(&packet, false, MPTP_S2C_BRUH, true);
      lm_mptp_server_send(arg->sock, &packet);
      break;
    }

    // send package archive and the signature file
    lm_mptp_sendfile(arg->sock, pkg->archive, NULL, NULL);
    lm_mptp_sendfile(arg->sock, pkg->signature, NULL, NULL);
    break;
  }

end:
  if(success && NULL != arg->callback)
    arg->callback(pool, &packet, &arg->addr, arg->data);
  free(arg);
}

bool lm_ctx_serve(lm_ctx_t *ctx, char *addr, uint8_t threads, lm_ctx_serve_callback_t callback, void *data){
  if (NULL == addr || threads < 0) {
    lm_error_set(LM_ERR_ArgNULL);
    return false;
  }

  char host[strlen(addr)+1];
  struct sockaddr saddr;
  uint16_t        port;
  int             sock = -1, c = -1;
  lm_thpool_t     tp;

  lm_thpool_init(&tp, threads);

  if (!parse_host(addr, host, &port))
    return false;

  if (port == 0) {
    lm_error_set(LM_ERR_NoPort);
    return false;
  }

  if ((sock = lm_mptp_server_listen(host, port)) < 0)
    return false;

  while ((c = lm_mptp_server_accept(sock, &saddr)) != -1) {
    struct lm_ctx_serve_thread_arg *arg = malloc(sizeof(struct lm_ctx_serve_thread_arg));
    memcpy(&arg->addr, &saddr, sizeof(struct sockaddr));

    arg->ctx = ctx;
    arg->callback = callback;
    arg->data = data;
    arg->sock = c;

    pdebug(__func__, "adding new connection to the pool");
    lm_thpool_add(&tp, __lm_ctx_serve_thread, arg);
  }

  lm_thpool_stop(&tp);
  // error set by mptp_server_accept
  return false;
}