/common/home/bel/bella/lnx/exports/build/current/all/sys-tools/ix-lib/ix_tools_i.h

#ifndef IX_TOOLS_I_H
#define IX_TOOLS_I_H

#include <pthread.h>
#include <netinet/in.h>
#include <netdb.h> 
#include <values.h>
#include <limits.h>
#include <sys/time.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include "ix_tools.h"

#ifdef DEBUG
#define VERBOSEDEBUG
#endif

#define min(a,b) ((a)<(b)?(a):(b))
#define max(a,b) ((a)>(b)?(a):(b))

/*-----------------------------------------------------------------
 * internal verbosity level
 */
typedef enum {     
        I_IX_V_LOG    = 0x00,
  I_IX_V_ALERT  = 0x01,
  I_IX_V_ERROR   = 0x002, 
  I_IX_V_DISP    = 0x004,
        I_IX_V_TIMER            = 0x008,
        I_IX_V_MSG     = 0x010,
        I_IX_V_EV      = 0x020,
        I_IX_V_THREAD  = 0x040,
        I_IX_V_FD      = 0x080,
  I_IX_V_SHM      = 0x100,
        I_IX_V_SIG      = 0x200,
  I_IX_V_ALL     = 0xFFFFFFFF
} i_ix_verbose_e;


#define IX_EV_MAX        0xFFFF

#define IX_VMS_EVCLUSTER_SIZE 32

// max number of events
#define IX_MAX_EVENTS 288
// user available events
// IX_MAX_USER_EVENTS must be multiple of IX_VMS_EVCLUSTER_SIZE
#define IX_MAX_USER_EVENTS 128
// 
// 0 .. IX_MAX_USER_EVENTS - 1         for user usage
// IX_MAX_USER_EVENTS .. IX_ADM_EVENTS for usage
// IX_MAX_ADM_EVENTS .. IX_MAX_EVENTS for internal usage
#define IX_MAX_ADM_EVENTS 256

// first internal event
#define IX_SYS_EVENT0  IX_MAX_ADM_EVENTS
// #define IX_SYS_EVENT1 IX_SYS_EVENT0+1
/*
 * IX_SYS_EVENT0 : main message queue
 * IX_SYS_EVENT1 : ....
 */

#define IX_VMS_EVCLUSTER_MAX (IX_MAX_USER_EVENTS/IX_VMS_EVCLUSTER_SIZE)


// max event listener per event
#define IX_MAX_EVENT_LISTENER 256

// max number of parallel timers
#define MAX_TIMER_POOL 512

// max shared mem sections
#define IX_MAX_SHM 16

// range of dynamic ports
#define IX_PORT_START 50000
#define IX_PORT_END   65535

// max number of connections of tcp-clients to server
#define MAX_TCP_CLIENT_POOL 300

// max number of tcp-server connections
#define MAX_TCP_SERVER_POOL 256

// max number of surveyed file descriptors
#define IX_MAX_FD 256

// ID of ix connections
#define IX_CONN_ID    0x4958 // IX

// ID of net connection packet
#define IX_NET_CONN_ID 0x434E  // CN

// ID of data connection packet
#define IX_DATA_CONN_ID 0x4344  // CD

// maximum queue count of pending connections to be accepted (for listen call)
#define IX_SOCKET_LISTEN_QUEUE 8

// when connection is refused we try again
//
// retry count to connect 
#define IX_SOCKET_CONNECT_RETRY 3

// wait time in microseconds before connect again
#define IX_SOCKET_CONNECT_MICROSEC_WAIT 3000

// timeout for send,reply,receive mechanism per TCP
#define IX_SEND_TIO 10

// max length of net packet
#define IX_MAX_NET_MSG_LEN (1024*32)

// highest signal we process
#define IX_MAX_SIGNAL 32

//#define IX_MAX_APPL_NAME_LEN 256

// ID of net packets to identify
#define IX_NET_ID 0x5800

// max number of user hooks
#define IX_MAX_USER_HOOK 16

// version of net packet
#define IX_NET_V1 0x0001

// we test for endian type
#define IX_LBE 0xFF00   // test for little or big endian

//  message types for internal communication through pipe
#define IX_INTERN_ID 0x5849
#define IX_TIMER_NEW 0x4E54
#define IX_TIMER_DEL 0x4454
#define IX_CONNECT 0x4343
#define IX_FD      0x4643
#define IX_SIGNAL  0x4743
#define IX_CLIENT_RM  0x4843
#define IX_SERVER_ACTION  0x4943

// timer flags
#define IX_TIMER_INIT     0x00
#define IX_TIMER_ACTIVE   0x01
#define IX_TIMER_SYSTEM   0x02

// intervall in sec of internal ix timer
#define IX_SYSTIMER_SEC 1

// client inactivity timeout in secs (after that server closes connection)
//#define IX_CLIENT_TIMEOUT 3600
#define IX_CLIENT_TIMEOUT 300

// timeout for write in secs
#define IX_WRITE_TIMEOUT 4

// timeout to receive replies in seconds
#define IX_REPLY_TIMEOUT 8

// timeout to sync server actions with dispatcher
#define IX_SERVER_ACTION_TIMEOUT 2

//#define IX_MAX_SHM_KEY 6

// max number of threads
#define MAX_THREAD_POOL 512

// max number of messages in message queues
#define IX_MSG_MAX 512

// max size of hostname
#define IX_HOST_NAME_MAX 64

#define IX_SEM_FN "SEM_GROUP"

// critical section
struct ix_cs_s
{
    pthread_mutex_t mt;
};
int ix_cs_init( ix_cs_t *pcs, ix_cs_e cs_type );

#define IX_SEM_UNLOCK 0x00
#define IX_SEM_LOCK 0x01
#define IX_SEM_POLLNO 3
// semaphore
struct ix_sem_s
{
  int id;        // id of sem
  int fd;     // descriptor of lock file
  char fn[PATH_MAX]; // name of lock file
  int state;  // wait, locked, unlocked
  int mode;   // IX_SEM_LOCAL, _GLOBAL, _FD
  // not used so far
  ix_event_t *pev; // event to trigger when available
  int group;     //  group id of sem
  ix_cs_t cs;
}; 

struct ix_fd_s
{
  int fd;
  ix_event_t *pev;
  int flag;
  ix_cs_t cs;
  IX_FD_FCT cb;
  void *userdata;
};

// event listener
struct ix_evl_s
{
  pthread_cond_t cond;
  pthread_mutex_t mut;
  int id;
};

// event set
struct ix_evs_s 
{
  int no;
  ix_event_t *ev[IX_MAX_EVENTS];
  int evl_init;
  ix_evl_t evl; // to each mask we associate a listener
};

// event
struct ix_event_s
{
    unsigned long id_intern;
    int type;    
    int set;        // counter
    int id;         // set by user
    ix_cs_t cs;
    ix_list_t *listener;
    ix_list_t *appl_listener;
    void *userdata;
}; 

// thread
struct  ix_thread_s
{
  pthread_t pth;
  pthread_attr_t attr;
  char name[64];
  IX_START_FCT sfct;
  IX_EXIT_FCT efct;
  void *parg;
  pthread_key_t *pkey;
  int exit_flag;
  int init;
  struct ix_thread_s *pme;
};

// application
struct ix_appl_s 
{
  int socketfd;
  int state;
  struct in_addr hostaddr;
  unsigned short applport;
  char hostname[PATH_MAX];
  char applname[PATH_MAX];
};

// timer
struct ix_timer_s 
{
  unsigned long  id;         // id of timer to make compare function unique
  unsigned long  userid;     // user supplied id
  ix_event_t  *pev;      // event to trigger when timer expires
  ix_cs_t     cs;
  int   flag;            // type and state of timer
  struct timeval tv;     // time when timer fires
  struct timeval tv_per; // period of periodic timer
  void (*pcb) ();        // user supplied call back
  void *parg;            // argument for call back function
};

// message queue
struct ix_msg_queue_s
{
  ix_queue_t *pq;
  ix_event_t *pev;
};

struct ix_qio_s
{
  int fd;
  int ctrl_tag;
  ix_qio_ctrl_t ctrl;
  IX_QIO_SAVE_FCT save_fct;
  void *userarg;
  ix_msg_queue_t *pmq;
  ix_buffer_t *pbuf;
  int len;
  ix_cs_t cs;
  ix_fd_t *pfd;
  int status;
};


typedef struct
{
  int key;
  IX_AST_PACKET_FCT user_hook;
} hook_entry_t;

// internal receive 
typedef struct
{
  IX_AST_PACKET_FCT hook_fct;
  ix_cs_t cs;
  int blocked;
  hook_entry_t hook[IX_MAX_USER_HOOK];
  int hook_count;
} ix_receive_t;


// net packet
typedef enum 
{
  IX_NET_MIN       = 0x00,
  IX_NET_EVENT     = 0x01,
  IX_NET_MSGUNCONF = 0x02,
  IX_NET_SEND      = 0x05,
  IX_NET_REPLY     = 0x06,
  IX_NET_NOTACK    = 0x07,
  IX_NET_ERROR     = 0xFF,
  IX_NET_MAX,
  IX_NET_VAL = 0xFFFF
} ix_net_type_e;

typedef struct ix_hdr_s 
{
  unsigned short id;     // id in network order
  unsigned short lbe;    // 0xFF00  in host order to test endian type 
                         // intel: least significant byte first
                         // network: most significant byte first
                         // receiver checks: 0xFF00 == lbe 
                         // if neq: byte order has to be changed in msg
  unsigned short type;   // type  in host order
  unsigned int   len;    // length in host order
  unsigned short port;   // port in network order the packet really comes from
                         // filled after packet is received
} ix_hdr_t;

struct ix_net_s
{
  ix_hdr_t hdr;
  ix_adr_t from;
  ix_adr_t to;
  ix_netinfo_t info;
  union 
  {
  IX_SERVER_DISCONNECT_FCT disconn_cb;
  long long int align;
  };
  ix_buffer_t b;
  unsigned char msg[IX_MAX_NET_MSG_LEN];
};

typedef unsigned int ix_cluster_t;

typedef struct
{
  unsigned short ix_id;            // in net order
  unsigned short conn_id;         // in net order
} ix_conn_t;


#define IX_TCP_INIT          0x00
#define IX_TCP_CONNECTED     0x01
#define IX_NET_CONNECTED     0x02
#define IX_DATA_CONNECTED    0x04
// #define IX_TCP_DATA          0x02

//typedef struct ix_tcp_client_s
struct ix_tcp_client_s
{
  int fd;               // file descriptor of connected client socket
  ix_adr_t adr;         // host adress and host port the request comes from
  int state;
  ix_net_t *pnet;       // dynamic actual buffer
  time_t access_time;   // last acces time from client
  int timeout;          // if gt 0, client is removed after timeout sec of inactivity
  ix_cs_t cs;           // critical section to allow synchronized use of userdata
  void *userdata;       // this is for userdata available between calls of callback

  int header_f;         // flag that header in reply is read
  int len;              // length of buffer filled
  char *buffer;         // buffer to store reply in
};



typedef int( * IX_SERVER_READ_FCT)( void *ps );

typedef enum
{
  IX_SERVER_INIT = 0x00,
  IX_SERVER_ERROR = 0x01,
  IX_SERVER_SENT = 0x02

} ix_server_state_e;

typedef struct ix_tcp_server_s
{
  int fd;               // file descriptor of connected server socket
  ix_adr_t adr;         // host adress and host port we connect to
  struct ix_cs_s cs;         // critical section for access server
  struct ix_cs_s socket_cs;  // critical section for using socket
  ix_net_t *pnet;       //  buffer to write reply to
  int shared;
  int state;
  ix_cond_t sync;       // the condition to trigger when reply received
  IX_SERVER_DISCONNECT_FCT disconn_cb; // callback if server disonnects

  int header_f;         // flag that header in reply is read
  int len;              // length of buffer filled
  char *buffer;         // buffer to store reply in
} ix_tcp_server_t;

struct ix_signal_s 
{
  int signal;
  ix_event_t *pev;
  void *userdata;
  IX_SIGNAL_FCT cb;
};

int rm_tcp_server( ix_tcp_server_t *ps );

// global init structure
typedef struct ix_init_s
{
  int done;
  sigset_t sigmask_block;
  char proc_name[PATH_MAX]; // for informational usage: user supplied
                            // process-name
  int node;                 // for informational usage: user supplied id
                            // for host identification
  ix_list_t *ptp;     // Thread pool
  ix_list_t *pti;     // active timer list
  ix_cs_t ev_cs;      // critical section for dealing wiht event[]
  ix_cs_t server_cs; // .. .for dealing with tcpserver:
  ix_cs_t fdcs;   // ...for dealing with filedescriptors
  ix_cs_t initcs;   // ...to avoid ix_init() concurrency faults
  ix_event_t *event[IX_MAX_EVENTS];  // array of max events 
  ix_cluster_t ev_cluster[IX_VMS_EVCLUSTER_MAX];
  int pipe[2]  ;      // internal pipe
  int udp_out;     // udp socket for client output 
  char udp_host[IX_HOST_NAME_MAX]; // our udp host name
  int udp_port;       // our udp port
  int udp_fd;         // udp socket for server input
  char tcp_host[IX_HOST_NAME_MAX]; // our tcp host name
  int tcp_port;       // our tcp port
  int tcp_fd;         // tcp socket for server input
  ix_list_t *ptcpcl;    // list with connected tcp-clients
  ix_list_t *ptcpsl;    // list with connected tcp-servers
  ix_list_t *pfdl;      // list with surveyed fd-descriptors
  fd_set rfds;              // read file descriptor result set
  fd_set wfds;              // write ...
  fd_set efds;              // error ...
  fd_set active_rfds;       // ...........          active set
  fd_set active_wfds;       // ...........          active set
  fd_set active_efds;       // ...........          active set
  int nfds;                 // highest number of fd
  int active_nfds;          // highest number of fd to set
  ix_cs_t fd_cs;      // critical section for dealing with fdsets
  ix_msg_queue_t msg; // main message queue for udp and tcp input messages
  ix_receive_t recv;  // this is for rebuild a special message receive
  int client_timeout; // timeout for idle client in sec
  ix_list_t *pshml;   // list with shared memory sections
  IX_CLIENT_CONNECT_FCT    client_connect_cb; 
  IX_CLIENT_REPLY_FCT      client_reply_cb; 
  IX_CLIENT_DATA_FCT       client_data_cb; 
  IX_CLIENT_DISCONNECT_FCT client_disconnect_cb; 
  IX_SERVER_DISCONNECT_FCT server_disconnect_cb; 
  struct ix_signal_s * signal[IX_MAX_SIGNAL];
  IX_EVENT_HOOK_FCT         event_hook_fct;
} ix_init_t;

void i_ix_log_level( unsigned long flag );
void i_ix_log( i_ix_verbose_e flags, char *text, ... );
void  _ix_evl_signal( ix_evl_t *pevl  );
int  _ix_evl_wait( ix_evl_t *pevl, ix_evs_t *mask, ix_evs_t *set,
    int msec );
inline ix_event_t *_ix_evs_add( ix_evs_t *pevs, ix_event_t *pev );
void  ix_evl_init( ix_evl_t *pevl  );
int start_dispatcher(void);
int snd_timer(void );
int snd_fd( void );
void *dispatch_fct( void  *arg);
int receive_init(void );
int ix_udp_send( ix_net_t *pnet );
int ix_tcp_send( ix_net_t *pnet, ix_net_t *preply );
int snd_connect( void  );
ix_event_t *_ix_event_new( ix_cs_t *pcs, int id, int flags, void *userdata );
int add_selrfd( int fd );
/*
static int add_selwfd( int fd );
static int add_selefd( int fd );
*/
int add_dyn_selrfd( int fd );
int add_dyn_selwfd( int fd );
int add_dyn_selefd( int fd );
int rm_dyn_selrfd( int fd );
int rm_dyn_selwfd( int fd );
int rm_dyn_selefd( int fd );
int init_selfd(void );
int init_fds(void);
//ix_buffer_t *ix_buffer_new( unsigned char *pbuf, size_t len );
int ix_buffer_init( ix_buffer_t *pb, unsigned char *pbuf, size_t len );
//int ix_buffer_resize( ix_buffer_t *pb, size_t len );
//void ix_buffer_free( ix_buffer_t *pb );
int ix_msg_queue_init( ix_msg_queue_t *pmq, ix_event_t *pev );
int ix_msg_queue_size_init( ix_msg_queue_t *pmq, ix_event_t *pev, size_t size );
int fd_comp_fct( const void *pth1, const void *pth2 );
int shm_comp_fct( const void *pshm1, const void *pshm2 ); 



#endif

---