ev_mgr.h

Go to the documentation of this file.

#ifndef EV_MGR_H
#define EV_MGR_H

#include <unistd.h>
#include <pthread.h>

#include <ev.h>

#include "config/opt.h"
#include "config/conf.h"
#include "utils/utils.h"

#include "hotkeys.h"
#include "modules/vpn.h"
#include "modules/cque.h"
#include "modules/teodb.h"
#include "modules/stream.h"
#include "modules/metric.h"
#include "modules/net_tcp.h"
#include "modules/net_tun.h"
#include "modules/net_term.h"
#include "modules/tcp_proxy.h"
#include "modules/l0-server.h"
#include "modules/log_reader.h"
#include "modules/async_calls.h"
#include "modules/logging_server.h"
#include "modules/logging_client.h"

extern const char *null_str;
#define NULL_STR (void*) null_str

#define CHECK_EVENTS_AFTER 11.5

enum EventManagerStatus {
  kEventMgrStopped = 0,
  kEventMgrRunning = 1
};

typedef enum ksnetEvMgrEvents {

    EV_K_STARTED,       // #0  Calls immediately after event manager starts

    EV_K_STOPPED_BEFORE,// #1  Calls before event manager stopped

    EV_K_STOPPED,       // #2  Calls after event manager stopped

    EV_K_CONNECTED,     // #3  New peer connected to host

    EV_K_DISCONNECTED,  // #4  A peer was disconnected from host

    EV_K_RECEIVED,      // #5  This host Received a data
    EV_K_RECEIVED_WRONG,

    EV_K_RECEIVED_ACK,  
    EV_K_IDLE,          
    EV_K_TIMER,         

    EV_K_HOTKEY,        
    EV_K_USER,          
    EV_K_ASYNC,         

    EV_K_TERM_STARTED,  // #13 After terminal started (in place to define commands

    EV_K_CQUE_CALLBACK,             // #14 Teonet Callback QUEUE event

    EV_K_STREAM_CONNECTED,          
    EV_K_STREAM_CONNECT_TIMEOUT,    
    EV_K_STREAM_DISCONNECTED,       
    EV_K_STREAM_DATA,               

    EV_K_SUBSCRIBE,                 
    EV_K_SUBSCRIBED,                

    EV_K_L0_CONNECTED,              
    EV_K_L0_DISCONNECTED,           
    EV_K_L0_NEW_VISIT,              

    EV_H_HWS_EVENT,                 

    EV_U_RECEIVED,                  

    EV_D_SET,                       

    EV_A_INTERVAL,                  // #27 Angular interval event happened

    EV_K_LOGGING,                   
 
    EV_K_LOG_READER,                

    EV_K_APP_USER = 0x8000          

} ksnetEvMgrEvents;

typedef struct ksnetEvMgrAppParam {

    int app_argc;
    const char **app_argv;
    const char **app_descr;

} ksnetEvMgrAppParam;



typedef struct ksnetEvMgrClass {

    // Pointers to Modules classes
    void *km; 
    ksnCoreClass *kc;  
    ksnetHotkeysClass *kh; 
    ksnVpnClass *kvpn; 
    ksnTcpClass *kt; 
    ksnLNullClass *kl; 
    ksnTCPProxyClass *tp; 
    ksnTunClass *ktun; 
    ksnTermClass *kter; 
    ksnCQueClass *kq; 
    ksnTDBClass *kf; 
    ksnStreamClass *ks; 

    teonet_cfg teo_cfg; 

    teoLoggingServerClass *ls; 
    teoLoggingClientClass *lc; 
    
    teoLogReaderClass *lr; 

    teoAsyncClass *ta;  

    teoMetricClass *tm; 

    int runEventMgr; 
    uint32_t timer_val; 
    uint32_t idle_count; 
    uint32_t idle_activity_count; 
    void (*event_cb)(struct ksnetEvMgrClass *ke, ksnetEvMgrEvents event, void *data, size_t data_len, void *user_data);
    struct ev_loop *ev_loop; 

    // Event Manager Watchers
    ev_idle idle_w;         
    ev_idle idle_activity_w;
    ev_timer timer_w;       
    ev_async sig_async_w;   
    ev_idle idle_async_w;   

    double custom_timer_interval;   
    double last_custom_timer;       

    PblList* async_queue;   
    pthread_mutex_t async_mutex; 
    pthread_mutex_t printf_mutex; 

    size_t net_idx; 
    void *n_prev; 
    void *n_next; 
    size_t net_count; 

    // Define signals watchers
    ev_signal sigint_w;  
    ev_signal sigterm_w; 
    ev_signal sigsegv_w; 
    ev_signal sigabrt_w; 
    #ifndef HAVE_MINGW
    ev_signal sigquit_w; 
    ev_signal sigkill_w; 
    ev_signal sigstop_w; 
    #endif

    void *user_data; 
    void *teo_class; 

    struct cli_def *cli;

    int argc;         
    char** argv;      

    char *app_type;     
    char *app_version;  

    bool is_rhost;      

} ksnetEvMgrClass;

ksnetEvMgrClass* __ke_from_command_class(ksnCommandClass *X);
ksnetEvMgrClass* __ke_from_L0_class(ksnLNullClass *X);
ksnetArpClass* __arp_from_command_class(ksnCommandClass *X);

#define EVENT_MANAGER_OBJECT(X) _Generic((X), \
      ksnCommandClass* : __ke_from_command_class, \
      ksnLNullClass *  : __ke_from_L0_class) (X)

#define ARP_TABLE_OBJECT(X) _Generic((X), \
      ksnCommandClass* : __arp_from_command_class) (X)

typedef void (*event_cb_t)(ksnetEvMgrClass *ke, ksnetEvMgrEvents event,
        void *data, size_t data_len, void *user_data);

typedef struct stdin_idle_data {

    ksnetEvMgrClass *ke;
    void *data;
    ev_io *stdin_w;

} stdin_idle_data;

typedef void (*ksn_event_cb_type)(ksnetEvMgrClass *ke, ksnetEvMgrEvents event, void *data, size_t data_len, void *user_data);

#ifdef  __cplusplus
extern "C" {
#endif


ksnetEvMgrClass *ksnetEvMgrInit(
    int argc, char** argv,
    //void (*event_cb)(ksnetEvMgrClass *ke, ksnetEvMgrEvents event, void *data, size_t data_len, void *user_data),
    ksn_event_cb_type event_cb,
    int options
);
ksnetEvMgrClass *ksnetEvMgrInitPort(
    int argc, char** argv,
    //void (*event_cb)(ksnetEvMgrClass *ke, ksnetEvMgrEvents event, void *data, size_t data_len, void *user_data),
    ksn_event_cb_type event_cb,
    int options,
    int port,
    void *user_data
);
int ksnetEvMgrRun(ksnetEvMgrClass *ke);
int ksnetEvMgrFree(ksnetEvMgrClass *ke, int free_async);
#ifdef TEO_THREAD
int ksnetEvMgrRunThread(ksnetEvMgrClass *ke);
#endif
void ksnetEvMgrStop(ksnetEvMgrClass *ke);
int ksnetEvMgrStatus(ksnetEvMgrClass *ke);
int ksnetEvMgrRestart(int argc, char **argv);
void ksnetEvMgrAsync(ksnetEvMgrClass *ke, void *data, size_t data_len, void *user_data);
double ksnetEvMgrGetTime(ksnetEvMgrClass *ke);
char* ksnetEvMgrGetHostName(ksnetEvMgrClass *ke);
host_info_data *teoGetHostInfo(ksnetEvMgrClass *ke, size_t *hd_len);
void ksnetEvMgrSetCustomTimer(ksnetEvMgrClass *ke, double time_interval);

const char *teoGetLibteonetVersion();
void teoSetAppType(ksnetEvMgrClass *ke, char *type);
void teoSetAppVersion(ksnetEvMgrClass *ke, char *version);
const char *teoGetAppType(ksnetEvMgrClass *ke);
char *teoGetFullAppTypeFromHostInfo(host_info_data *hid);
const char *teoGetAppVersion(ksnetEvMgrClass *ke);
int remove_peer_addr(ksnetEvMgrClass *ke, __CONST_SOCKADDR_ARG addr);
int ksnetAllowAckEvent(ksnetEvMgrClass* ke, int allow);

#ifdef  __cplusplus
}
#endif

#endif  /* EV_MGR_H */