kc3-lang/kc3/socket/socket_facts.c

Branch - branch -marshallmasterpdfv0.1- tag -v0.1.9v0.1.8v0.1.7v0.1.6v0.1.5v0.1.4v0.1.3v0.1.2v0.1.15v0.1.14v0.1.13v0.1.12v0.1.11v0.1.10v0.1.1v0.1.0v0HTTPd-v0.2.0HTTPd-v0.1.1HTTPd-v0.1.0v0.1.16

• Show log

  Commit

• Hash : bb3d880e
  Author : Thomas de Grivel
  Date : 2026-01-05T21:46:43
  

  pthread: cannot copy a pthread_rwlock_t nor a pthread_mutex_t they have to be initialized in-place. added a self pointer for consistency.
  

Download

• socket/socket_facts.c

• /* kc3
   * Copyright from 2022 to 2025 kmx.io <contact@kmx.io>
   *
   * Permission is hereby granted to use this software granted the above
   * copyright notice and this permission paragraph are included in all
   * copies and substantial portions of this software.
   *
   * THIS SOFTWARE IS PROVIDED "AS-IS" WITHOUT ANY GUARANTEE OF
   * PURPOSE AND PERFORMANCE. IN NO EVENT WHATSOEVER SHALL THE
   * AUTHOR BE CONSIDERED LIABLE FOR THE USE AND PERFORMANCE OF
   * THIS SOFTWARE.
   */
  #include <sys/socket.h>
  #include "../libkc3/alloc.h"
  #include "../libkc3/assert.h"
  #include "../libkc3/buf.h"
  #include "../libkc3/env.h"
  #include "../libkc3/env_fork.h"
  #include "../libkc3/fact.h"
  #include "../libkc3/facts.h"
  #include "../libkc3/io.h"
  #include "../libkc3/log.h"
  #include "../libkc3/marshall.h"
  #include "../libkc3/marshall_read.h"
  #include "socket.h"
  #include "socket_buf.h"
  #include "socket_facts.h"
  
  bool * kc3_socket_facts_close (s_facts *facts, bool *dest)
  {
    assert(dest);
    *dest = socket_facts_close(facts) ? true : false;
    return dest;
  }
  
  bool * kc3_socket_facts_accept (s_facts *facts, t_socket *server,
                                  bool *dest)
  {
    assert(dest);
    *dest = socket_facts_accept(facts, server) ? true : false;
    return dest;
  }
  
  bool * kc3_socket_facts_open (s_facts *facts, const s_str *host,
                                const s_str *service, bool *dest)
  {
    assert(dest);
    *dest = socket_facts_open(facts, host, service) ? true : false;
    return dest;
  }
  
  void socket_facts_clean (s_socket_facts *sf)
  {
    assert(sf);
    marshall_clean(&sf->marshall);
    socket_buf_clean(&sf->socket);
  }
  
  s_facts * socket_facts_close (s_facts *facts)
  {
    s_log_hook *hook;
    s_socket_facts_listener *listener;
    s_log_hook *next;
    s_socket_facts *sf;
    pthread_t thread;
    assert(facts);
    if (! facts->log)
      return facts;
    hook = facts->log->hooks;
    while (hook) {
      next = hook->next;
      if (hook->f == socket_facts_hook) {
        sf = hook->context;
        sf->running = false;
        sf->hook = NULL;
        thread = sf->thread;
        shutdown(sf->socket.sockfd, SHUT_RDWR);
        socket_close(&sf->socket.sockfd);
        log_hook_remove(facts->log, hook);
        pthread_join(thread, NULL);
      }
      else if (hook->f == socket_facts_listener_hook) {
        listener = hook->context;
        listener->running = false;
        listener->hook = NULL;
        thread = listener->thread;
        shutdown(listener->client.sockfd, SHUT_RDWR);
        socket_close(&listener->client.sockfd);
        log_hook_remove(facts->log, hook);
        pthread_join(thread, NULL);
      }
      hook = next;
    }
    return facts;
  }
  
  void socket_facts_hook (void *context, e_fact_action action,
                          const s_fact *fact)
  {
    s_socket_facts *sf;
    assert(context);
    assert(fact);
    sf = context;
    marshall_u8(&sf->marshall, false, action);
    marshall_fact(&sf->marshall, false, fact);
    marshall_to_buf(&sf->marshall, sf->socket.buf_rw.w);
  }
  
  void socket_facts_listener_hook (void *context, e_fact_action action,
                                   const s_fact *fact)
  {
    s_socket_facts_listener *listener;
    assert(context);
    assert(fact);
    listener = context;
    marshall_u8(&listener->marshall, false, action);
    marshall_fact(&listener->marshall, false, fact);
    marshall_to_buf(&listener->marshall, listener->client.buf_rw.w);
  }
  
  void * socket_facts_open_thread (void *arg)
  {
    u8 action;
    bool b;
    s_fact fact = {0};
    s_marshall_read *mr;
    s_socket_facts *sf;
    sf = arg;
    env_global_set(sf->env);
    mr = &sf->marshall_read;
    sf->running = true;
    while (sf->running) {
      if (! marshall_read_header(mr))
        break;
      if (! marshall_read_chunk(mr)) {
        err_puts("socket_facts_open_thread: marshall_read_chunk");
        break;
      }
      if (! marshall_read_u8(mr, false, &action)) {
        err_puts("socket_facts_open_thread: marshall_read_u8");
        break;
      }
      if (! marshall_read_fact(mr, false, &fact)) {
        err_puts("socket_facts_open_thread: marshall_read_fact");
        break;
      }
      switch (action) {
      case FACT_ACTION_ADD:
        facts_add_fact(sf->facts, &fact);
        break;
      case FACT_ACTION_REMOVE:
        facts_remove_fact(sf->facts, &fact, &b);
        break;
      default:
        break;
      }
      fact_clean_all(&fact);
      marshall_read_reset_chunk(mr);
    }
    if (sf->hook)
      log_hook_remove(sf->facts->log, sf->hook);
    marshall_read_clean(mr);
    env_fork_delete(sf->env);
    socket_facts_clean(sf);
    free(sf);
    return NULL;
  }
  
  s_socket_facts * socket_facts_init (s_socket_facts *sf,
                                      const s_str *host,
                                      const s_str *service)
  {
    assert(sf);
    assert(host);
    assert(service);
    *sf = (s_socket_facts) {0};
    if (! socket_buf_init_connect(&sf->socket, host, service))
      return NULL;
    if (! marshall_init(&sf->marshall)) {
      socket_buf_clean(&sf->socket);
      return NULL;
    }
    return sf;
  }
  
  s_facts * socket_facts_accept (s_facts *facts, t_socket *server)
  {
    s_socket_facts_listener *listener;
    assert(facts);
    assert(server);
    listener = alloc(sizeof(s_socket_facts_listener));
    if (! listener)
      return NULL;
    listener->env = env_fork_new(env_global());
    if (! listener->env) {
      free(listener);
      return NULL;
    }
    listener->facts = facts;
    if (! socket_buf_init_accept(&listener->client, server)) {
      err_puts("socket_facts_accept: socket_buf_init_accept");
      free(listener);
      return NULL;
    }
    if (! marshall_read_init_buf(&listener->marshall_read,
                                 listener->client.buf_rw.r)) {
      err_puts("socket_facts_accept: marshall_read_init_buf");
      socket_buf_clean(&listener->client);
      free(listener);
      return NULL;
    }
    if (! marshall_init(&listener->marshall)) {
      err_puts("socket_facts_accept: marshall_init");
      marshall_read_clean(&listener->marshall_read);
      socket_buf_clean(&listener->client);
      free(listener);
      return NULL;
    }
    if (pthread_create(&listener->thread, NULL,
                       socket_facts_listen_thread, listener)) {
      err_puts("socket_facts_accept: pthread_create");
      marshall_clean(&listener->marshall);
      marshall_read_clean(&listener->marshall_read);
      socket_buf_clean(&listener->client);
      free(listener);
      return NULL;
    }
    return facts;
  }
  
  void * socket_facts_listen_thread (void *arg)
  {
    u8 action;
    bool b;
    s_fact fact = {0};
    s_socket_facts_listener *listener;
    s_marshall_read *mr;
    listener = arg;
    env_global_set(listener->env);
    mr = &listener->marshall_read;
    if (! listener->facts->log) {
      err_puts("socket_facts_listen_thread: listener facts log is NULL");
      return NULL;
    }
    listener->hook = log_hook_add(listener->facts->log,
                                  socket_facts_listener_hook, listener);
    if (! listener->hook) {
      err_puts("socket_facts_listen_thread: log_hook_add");
      return NULL;
    }
    listener->running = true;
    while (listener->running) {
      if (! marshall_read_header(mr))
        break;
      if (! marshall_read_chunk(mr)) {
        err_puts("socket_facts_listen_thread: marshall_read_chunk");
        break;
      }
      if (! marshall_read_u8(mr, false, &action)) {
        err_puts("socket_facts_listen_thread: marshall_read_u8");
        break;
      }
      if (! marshall_read_fact(mr, false, &fact)) {
        err_puts("socket_facts_listen_thread: marshall_read_fact");
        break;
      }
      switch (action) {
      case FACT_ACTION_ADD:
        facts_add_fact(listener->facts, &fact);
        break;
      case FACT_ACTION_REMOVE:
        facts_remove_fact(listener->facts, &fact, &b);
        break;
      default:
        err_write_1("socket_facts_listen_thread: invalid action: ");
        err_inspect_u8_decimal(action);
        err_write_1("\n");
        break;
      }
      fact_clean_all(&fact);
      marshall_read_reset_chunk(mr);
    }
    if (listener->hook)
      log_hook_remove(listener->facts->log, listener->hook);
    marshall_read_clean(mr);
    marshall_clean(&listener->marshall);
    socket_buf_clean(&listener->client);
    env_fork_delete(listener->env);
    free(listener);
    return NULL;
  }
  
  s_facts * socket_facts_open (s_facts *facts, const s_str *host,
                               const s_str *service)
  {
    s_socket_facts *sf;
    assert(facts);
    assert(host);
    assert(service);
    if (! facts->log)
      return NULL;
    sf = alloc(sizeof(s_socket_facts));
    if (! sf)
      return NULL;
    if (! socket_facts_init(sf, host, service)) {
      free(sf);
      return NULL;
    }
    sf->facts = facts;
    sf->env = env_fork_new(env_global());
    if (! sf->env) {
      socket_facts_clean(sf);
      free(sf);
      return NULL;
    }
    if (! marshall_read_init_buf(&sf->marshall_read,
                                 sf->socket.buf_rw.r)) {
      env_fork_delete(sf->env);
      socket_facts_clean(sf);
      free(sf);
      return NULL;
    }
    if (pthread_create(&sf->thread, NULL,
                       socket_facts_open_thread, sf)) {
      marshall_read_clean(&sf->marshall_read);
      env_fork_delete(sf->env);
      socket_facts_clean(sf);
      free(sf);
      return NULL;
    }
    sf->hook = log_hook_add(facts->log, socket_facts_hook, sf);
    if (! sf->hook) {
      marshall_read_clean(&sf->marshall_read);
      env_fork_delete(sf->env);
      socket_facts_clean(sf);
      free(sf);
      return NULL;
    }
    return facts;
  }
  

Download