libmp/src/libmp.c

// clang-format off

/*

 * libmp | MatterLinux package management library 
 * MatterLinux 2023-2024 (https://matterlinux.xyz)

 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.

*/

// clang-format on

#include "../include/libmp.h"
#include "../include/error.h"
#include "../include/mptp.h"
#include "../include/pool.h"
#include "../include/thpool.h"
#include "../include/util.h"

#include <libintl.h>
#include <locale.h>
#include <stdlib.h>
#include <string.h>
#include <sys/socket.h>

void lm_ctx_init(lm_ctx_t *ctx) {
  setlocale(LC_ALL, "");
  textdomain("libmp");

  ctx->pools = NULL;
  ctx->data  = NULL;
  ctx->root  = NULL;
  ctx->temp  = NULL;
  ctx->debug = false;
}

lm_pool_t *lm_ctx_pools_add(lm_ctx_t *ctx, char *name, char *url) {
  lm_pool_t *pool = lm_pool_new(name, url);
  if (NULL == pool)
    return false;

  pdebug(ctx, __func__, "pool name is %s", pool->name);
  pdebug(ctx, __func__, "pool URL is %s://%s:%d%s", pool->url.protocol, pool->url.host, pool->url.port, pool->url.path);

  if (NULL == ctx->pools) {
    ctx->pools = pool;
    return pool;
  }

  lm_pool_t *cur = ctx->pools;
  while (NULL != cur) {
    if (NULL == cur->next) {
      cur->next = pool;
      return pool;
    }
    cur = cur->next;
  }

  lm_pool_free(pool);
  return NULL;
}

void lm_ctx_pools_clear(lm_ctx_t *ctx) {
  lm_pool_t *cur = ctx->pools, *prev = NULL;
  while (NULL != cur) {
    prev = cur;
    cur  = cur->next;
    lm_pool_free(prev);
  }

  ctx->pools = NULL;
}

void lm_ctx_pools_test(lm_ctx_t *ctx) {
  lm_pool_t *cur = ctx->pools;
  while (NULL != cur) {
    lm_pool_test(cur);
    if (!cur->available)
      pdebug(ctx, __func__, "%s is not avaliable: %s", cur->name, lm_strerror());
    cur = cur->next;
  }
}

lm_pool_t *lm_ctx_pools_find(lm_ctx_t *ctx, char *name) {
  lm_pool_t *cur = ctx->pools;
  while (NULL != cur) {
    if (eq(cur->name, name))
      return cur;
    cur = cur->next;
  }
  return NULL;
}

lm_pool_t *lm_ctx_pools_by_url(lm_ctx_t *ctx, char *host, char *path) {
  lm_pool_t *cur = ctx->pools;
  while (NULL != cur) {
    if (eq(cur->url.host, host) && eq(cur->url.path, path))
      return cur;
    cur = cur->next;
  }
  return NULL;
}

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

  struct sockaddr saddr;
  char           *host = NULL;
  lm_mptp_t       packet;
  uint16_t        port;
  int             sock;
  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(addr, port)) < 0)
    return false;

  while (lm_mptp_server_recv(sock, &packet, &saddr)) {
    if (!lm_mptp_server_verify(&packet)) {
      pdebug(ctx, __func__, "skipping packet, failed to verify: %s", lm_strerror());
      continue;
    }

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

    if (!lm_mptp_get_data(&packet, path)) {
      pdebug(ctx, __func__, "skipping packet, failed to get path: %s", lm_strerror());
      continue;
    }

    if (!lm_mptp_get_host(&packet, hostname)) {
      pdebug(ctx, __func__, "skipping packet, failed to get hostname: %s", lm_strerror());
      continue;
    }

    lm_pool_t *pool = lm_ctx_pools_by_url(ctx, hostname, path);

    if (NULL == pool) {
      pdebug(ctx, __func__, "unknown pool, closing connection: %s", hostname);
      lm_mptp_init(&packet, false, MPTP_S2C_BRUH, true);
      lm_mptp_server_send(sock, &packet, &saddr);
      continue;
    }

    lm_pool_thread_arg_t *arg = malloc(sizeof(lm_pool_thread_arg_t));

    memcpy(&arg->addr, &saddr, sizeof(struct sockaddr));
    lm_mptp_copy(&arg->packet, &packet);
    arg->sock = sock;

    lm_thpool_add(&tp, lm_pool_serve_thread, arg);
  }

  lm_thpool_stop(&tp);
  return true;
}

void lm_ctx_free(lm_ctx_t *ctx) {
  lm_ctx_pools_clear(ctx);
  return;
}