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

#ifndef IX_TOOLS_H
#define IX_TOOLS_H

#include <sys/time.h>
#include <netinet/in.h>

#ifdef  __cplusplus
extern "C" {
#endif


#define IX_PATH_ENV "IX_PATH"
#define IX_PATH "/var/ix"

#define IX_GLOBAL_PATH_ENV "IX_GLOBAL_PATH"
#define IX_GLOBAL_PATH "/var/ix/global"

#define IX_SEM  "sem"
 
#define IX_TABLE_ENV "IX_TABLE_PATH"  
#define IX_TABLE "table"




/***********************************************************************
 * logging, ix_log.c
***********************************************************************/
 
typedef enum {     
        IX_V_LOG    = 0x000,
  IX_V_ERROR   = 0x001, 
  IX_V_PLAIN   = 0x80000000,
  IX_V_ALL     = 0xFFFFFFFF
} ix_verbose_e;

void ix_log( unsigned long flag, char *text, ... );


void ix_log_level( unsigned long int mask );

unsigned long int ix_log_getlevel( void );

void ix_log_name( char *name );

void ix_log_node( int node );

void ix_log_sys( int flag );

int ix_log_getsys( void );


typedef struct ix_log_s ix_log_t;

ix_log_t *ix_logfac_new( char *facility, unsigned long int errlevel );

void ix_logfac_free( ix_log_t *plog );

void ix_logfac_log( ix_log_t *plog, unsigned long flag, char *text, ... );

void ix_logfac_level( ix_log_t *plog, unsigned long int mask );

unsigned long int ix_logfac_getlevel( ix_log_t *plog );

int ix_log_mask64( uint64_t v,  char *buffer, int len );

int ix_log_mask32( uint32_t v,  char *buffer, int len );

int ix_snprint( char *buffer, size_t buflen, char *str );

int ix_hexnprint( char *buf, size_t buflen, 
    unsigned char *byte, size_t len );


/***********************************************************************
 * socket and connect, socket_tools.c 
***********************************************************************/


int ix_make_udp_socket ( int port);

int ix_make_tcp_socket (int port);

int ix_make_tcp_dyn_socket ( int *port);

int ix_connect_remote( int socket, struct in_addr *addr, unsigned short port );

int ix_socket_join_multicast( int socket, struct in_addr addr );

/***********************************************************************
 * lists, ix_list.c
***********************************************************************/


typedef int  (*IX_LIST_CMP_FCT) (const void *, const void *);

typedef int  (*IX_LIST_TRAVERSE_FCT) (const void *,  void *);


typedef struct ix_list_s ix_list_t;

typedef struct ix_list_s ix_queue_t;

typedef struct ix_list_s ix_stack_t;

ix_list_t *ix_list_new( IX_LIST_CMP_FCT cmp, void *mem, size_t size);

int ix_list_lock( ix_list_t *plist );
int ix_list_unlock( ix_list_t *plist );

void *ix_list_search( ix_list_t *plist, void *ptr);

int   ix_list_delete( ix_list_t *plist, void *ptr );

int   ix_list_delete_ret( ix_list_t *plist, void *ptr, void **ret );

int   ix_list_free( ix_list_t *plist );

int   ix_list_sort( ix_list_t *plist );

int   ix_list_insert( ix_list_t *plist, void *ptr );

int   ix_list_add( ix_list_t *plist, void *ptr, void **pret );

void *ix_list_first( ix_list_t *plist );

void *ix_list_head( ix_list_t *plist ); 

void *ix_list_tail( ix_list_t *plist ); 

void *ix_list_last( ix_list_t *plist ); 

int   ix_list_count( ix_list_t *plist );

int   ix_list_overrun( ix_list_t *plist );

int   ix_list_fills( ix_list_t *plist );


int ix_list_traverse( ix_list_t *plist, IX_LIST_TRAVERSE_FCT fct, void *arg  );

int ix_list_traverse_del( ix_list_t *plist, IX_LIST_TRAVERSE_FCT fct, 
    void *arg  );

#define ix_stack_new( b,c ) ix_list_new( NULL, (b), (c) )
#define ix_stack_free(a) ix_list_free((a))
#define ix_stack_push  ix_list_insert
#define ix_stack_pop  ix_list_last

#define ix_queue_new( b,c ) ix_list_new( NULL, (b), (c) )
#define ix_queue_free(a) ix_list_free((a))
#define ix_queue_add ix_list_add
#define ix_queue_insert ix_list_insert
#define ix_queue_eat ix_list_first





/***********************************************************************
 * hash functions
 ***********************************************************************/

typedef struct ix_hash_s  ix_hash_t;

typedef struct 
{
  char *key;
  void *data;
} ix_entry_t;

ix_hash_t * ix_hash_new( int nel );

void ix_hash_free( ix_hash_t *ph );

int ix_hash_add( ix_hash_t *ph, char *key, void *data, void **retdata );

void * ix_hash_find( ix_hash_t *ph, char *key );

/***********************************************************************
 * Ring buffer
***********************************************************************/

typedef struct ix_rb_s   ix_rb_t;

typedef enum
{
   IX_RB_DEFAULT,      
   IX_RB_KEEP,         
} ix_rb_e;

ix_rb_t *ix_rb_new( size_t len, int flag );

int ix_rb_read( ix_rb_t *prb, char *buf, int len );

int ix_rb_write( ix_rb_t *prb, char *buf, int len );

void ix_rb_free( ix_rb_t *prb );

int ix_rb_no( ix_rb_t *prb );


/***********************************************************************
 * coding helper functions
 ***********************************************************************/
// a part of a muli-part message buffer
struct ix_xfer_entry_s
{
  unsigned long off;
  unsigned long len;
};

typedef struct ix_xfer_entry_s ix_xfer_entry_t;

#define ix_xfer_off(__p) ((unsigned long)(__p))

// set address and length of an entry
#define ix_xfer_set(x,data,xlen) \
{\
    (x)->off = ix_xfer_off(data);\
    (x)->len = (xlen);\
}

// get the length of a xfer entry
#define ix_xfer_getlen(x) ((x)->len)

/*
 * code the entries to buffer 
 */
int ix_xfer_encode( unsigned char *buf, int len, ix_xfer_entry_t *pe, 
    unsigned long ne );
/*
 * decode buffer to xfer entries
 */
int ix_xfer_decode( unsigned char *buf, unsigned long len, 
    ix_xfer_entry_t *pe, unsigned long ne, unsigned long *ne_read);



/***********************************************************************
 * Table key look up
***********************************************************************/

#define IX_KEY_LEN 54

#define IX_DATA_LEN 447

int ix_key_sizeofkey(void);

int ix_key_sizeofdata(void);

int ix_key_env_get( char *key, char *buffer, int bufferlen );

int ix_key_env_set( char *key, char *buffer );

int ix_key_env_unset( char *key );

int ix_key_file_get( char *path, char *key, char *buffer, int bufferlen,
    int *pflag );
int ix_key_file_set( char *path, char *key, char *buffer, int flag );

int ix_key_file_unset( char *path, char *key );

int ix_key_file_clear( char *path );
/*
 * if table eq NULL use key_env..
 * else use key_env_...
 * return length of data
 */
int ix_key_info_set( char *key, char *table, char *buffer );
int ix_key_info_unset( char *key, char *table );
int ix_key_info_get( char *key, char *table, 
    char *buffer, int bufferlen );
int ix_key_info_clear( char *table );



/*
 * ix_tools.c 
 */

/***********************************************************************
 * toggle endian
***********************************************************************/
int16_t te16( int16_t s, int flag );
int32_t te32( int32_t i, int flag );
int64_t te64( int64_t l, int flag );
float tefloat( float in, int flag );
double tedouble( double in, int flag );
/***********************************************************************
 * some misc utility functions
***********************************************************************/
int ix_daemon( char *dir );

void *memdup( void *src, size_t len );

char *ix_path(void);

char *ix_stralloc( char *s, int len );

char *ix_strncpy( char *d, char *s, int len );

#define IX_SPAWN_DEFAULT 0

#define IX_SPAWN_SESSION 1

pid_t ix_spawn( char *cmd, int opt, int f[3], char *env[] );


int ix_getpidof( char *proc, pid_t pid[], int maxpid );

int  ix_read_block( int fd, void *buffer, int len, int tio );

int  ix_write_block( int sd, void *buffer, int len, int tio );
/***********************************************************************
 * crtical sections
***********************************************************************/
 /* with ix_evs_new(), see ix_evs_add(), ix_evs_isset().  */

typedef struct ix_cs_s ix_cs_t;

typedef enum
{
   IX_CS_FAST,      
   IX_CS_RECURSIVE, 
   IX_CS_ERROR,     
} ix_cs_e;

ix_cs_t * ix_cs_new( ix_cs_e cs_type );

int ix_cs_enter( ix_cs_t *pcs );

int ix_cs_tryenter( ix_cs_t *pcs );

int ix_cs_leave( ix_cs_t *pcs );

int ix_cs_free( ix_cs_t *pcs );
/**********************************************************************
 * Events
 *********************************************************************/
 /* with ix_evs_new(), see ix_evs_add(), ix_evs_isset().  */

#define IX_EV_DEFAULT    0x00
#define IX_EV_MANUAL     0x01
#define IX_EV_CUMULATIVE 0x02
#define IX_EV_INIT       0x04

typedef struct ix_event_s ix_event_t;

//struct ix_evl_s;
typedef struct ix_evl_s ix_evl_t;

typedef int ( * IX_EVENT_HOOK_FCT)( ix_event_t *pev );

ix_event_t *ix_event_new( int id, int flag, void *userdata );

ix_event_t *ix_event_i_new( int flags, void *userdata );

int ix_event_set_hook( IX_EVENT_HOOK_FCT hook );

int ix_event_free( ix_event_t *pe );

ix_event_t* ix_event_get( int id );

int ix_event_id( ix_event_t *pev );


int ix_event_set( ix_event_t *pe );

int ix_event_check( ix_event_t *pe );

int ix_event_isset( ix_event_t *pe );

int ix_event_reset( ix_event_t *pe );

/*
 * so far only internal usage 
 */
int ix_event_add_evl( ix_event_t *pe, struct ix_evl_s *pevl );
int ix_event_del_evl( ix_event_t *pe, struct ix_evl_s *pevl );

void *ix_event_data( ix_event_t *pe );

void *ix_event_set_data( ix_event_t *pe, void *userdata );

int ix_event_getnewid(void);

#define IX_EV(id) ix_event_get((id))

#define IX_ID(pev) ix_event_id((pev))

/***********************************************************************
* semaphore
***********************************************************************/

typedef enum
{
  IX_SEM_LOCAL  = 0x01, 
  IX_SEM_GLOBAL = 0x02,
  IX_SEM_FD     = 0x03  
} ix_sem_e;

typedef struct  ix_sem_s ix_sem_t;

ix_sem_t *ix_sem_new( int id, ix_sem_e mode );

int ix_sem_v( ix_sem_t *psem ); 

int ix_sem_p( ix_sem_t *psem ); 

int ix_sem_free( ix_sem_t *psem );
/***********************************************************************
 * Condition
***********************************************************************/
struct ix_cond_s
{
  pthread_mutex_t mut;
  pthread_cond_t cond;
  int wait;
};

typedef struct ix_cond_s ix_cond_t;

typedef int  (*IX_COND_CHECK_FCT) (void *);

typedef int  (*IX_COND_SET_FCT) (void *);

int ix_cond_init( ix_cond_t *psync );

int ix_cond_is_wait( ix_cond_t *psync );

int ix_cond_wait( ix_cond_t *psync, int sec, IX_COND_CHECK_FCT cond_check, void *arg );

void ix_cond_set( ix_cond_t *psync, IX_COND_SET_FCT cond_set, void *arg );

/***********************************************************************
 * Shared Mem
***********************************************************************/

typedef struct ix_shm_s ix_shm_t;

typedef enum
{
IX_SHM_CRMP  = 0x01,         
IX_SHM_MP    = 0x02          
} ix_shm_type_e;

ix_shm_t *ix_shm_new( char *shm_name, void *adr, int len, ix_shm_type_e flag );
ix_shm_t *ix_shm_new_sv( char *shm_name, void *adr, int len, ix_shm_type_e flag );

void ix_shm_free( ix_shm_t *psm );
void ix_shm_free_sv( ix_shm_t *psm );

int ix_shm_adr( ix_shm_t *psm, void **padr, int *plen );

ix_shm_t *ix_shm_get( char *name );

/***********************************************************************
 * file descriptors
***********************************************************************/

typedef struct ix_fd_s ix_fd_t;

typedef enum
{
  IX_FD_U = 0x00, 
  IX_FD_R = 0x01, 
  IX_FD_W = 0x02, 
  IX_FD_E = 0x04  
} ix_fd_type_e;

typedef int ( * IX_FD_FCT)( void *userdata, ix_fd_type_e type );

ix_fd_t *ix_fd_new( ix_event_t *pev, int fd, int flag, IX_FD_FCT cb, 
    void *userdata );

int ix_fd_free( ix_fd_t *pfd );

/***********************************************************************
 * signals
***********************************************************************/

typedef int ( * IX_SIGNAL_FCT)( int signal, void *userdata );

typedef struct ix_signal_s ix_signal_t;


ix_signal_t *ix_signal_new( ix_event_t *pev, int signal, IX_SIGNAL_FCT cb, 
    void *userdata );

int ix_signal_free( ix_signal_t *psig );

/***********************************************************************
 * Event Sets
 **********************************************************************/

typedef struct ix_evs_s ix_evs_t;

ix_evs_t *ix_evs_new();

int ix_evs_free( ix_evs_t *pevs );

int  ix_evs_wait( ix_evs_t *mask, ix_evs_t *result, int msec );

ix_event_t * ix_evs_add( ix_evs_t *pevs, ix_event_t * pev );

int ix_evs_isset( ix_evs_t *pevs, ix_event_t *pev );
 
ix_event_t * ix_evs_rem( ix_evs_t *pevs, ix_event_t * pev);

ix_event_t * ix_evs_pop( ix_evs_t *pevs );

int ix_evs_clear( ix_evs_t *pevs );
/***********************************************************************
 * VMS convenience calls 
 * utility functions to cover some vms-specific event-handling functions
 ***********************************************************************/

/*
 * Description:
 * waits forever for events whose bits are set in  mask 0-31
 * the cluster is set by evn which is event-number 0-127
 * Returns:
 * 0: OK some events are set
 * -1: error
 */
int  ix_event_cluster_wait( ix_evs_t *pevs, int evn, unsigned int mask );


/*
 * Description:
 * checks if any event events 0-31 in mask are set, the cluster
 * is specified by event-number evn 0 - 127
 * Returns:
 * 1: set
 * 0: not set
 */
int ix_event_cluster_isset( int evn, unsigned int mask  );

/*
 * Description:
 * returns status of all events in a event-cluster which is specified by
 * event-number evn
 * Returns:
 * >0: ok evn was set
 * 0: ok evn was not set
 * <0: Error
 */
int ix_event_cluster_read( int evn, unsigned int *state  );

/*
 * Description:
 * sets event with number evn
 * Returns:
 * 0: OK
 * <0: Error
 */
int ix_event_cluster_set( int evn );


/***********************************************************************
 * threads
***********************************************************************/

typedef void * ( * IX_START_FCT)(void *);

typedef void  ( * IX_EXIT_FCT)(void *pt);

typedef struct ix_thread_s ix_thread_t;


ix_thread_t *ix_thread_new( IX_START_FCT sfct, IX_EXIT_FCT efct, 
                            void *parg, char *name );

int ix_thread_stop( ix_thread_t *pt );


void ix_thread_exit( ix_thread_t *pt );

void ix_thread_free( ix_thread_t *pt );


void *ix_thread_getarg( ix_thread_t *pt );

char *ix_thread_getname( ix_thread_t *pt );

/***********************************************************************
 * application
***********************************************************************/
/*
 * not used
 */
typedef struct ix_appl_s ix_appl_t;

/***********************************************************************
 *  timer
***********************************************************************/

typedef enum
{
IX_TIMER_ABSOLUTE =  0x20,
IX_TIMER_PERIODIC  = 0x40,
IX_TIMER_ONESHOT  =  0x80,
IX_TIMER_NORMAL  =   0x100
} ix_timer_type_e;

typedef struct ix_timer_s ix_timer_t;

typedef struct itimerval ix_timer_val_t;


int ix_timer_val_init( ix_timer_val_t *ptv, int v_sec, int v_usec,
    int i_sec, int i_usec );

void ix_get_timenow( struct timeval *ptv );

struct timeval ix_timer_add( struct timeval *pt1, struct timeval *pt2 );

ix_timer_t *ix_timer_new( ix_event_t *pev, ix_timer_type_e type, 
    unsigned long userid, void (*cb)(void *parg), void *parg, 
    //struct itimerval *pitv );
    ix_timer_val_t *pitv );

int ix_timer_free( ix_timer_t *pt );

int ix_timer_cancel( ix_timer_t *pt );

int ix_timer_restart( ix_timer_t *pt, ix_event_t *pev, ix_timer_type_e type, 
    //struct itimerval *pitv );
    ix_timer_val_t *pitv );

int ix_timer_id_free( unsigned long id );

/***********************************************************************
 *  buffer object
***********************************************************************/

typedef struct
{
  union
  {
  unsigned char *pbuf;  
  long long int align;
  };
  unsigned int buflen;        
  unsigned int len;           
} ix_buffer_t;

ix_buffer_t *ix_buffer_new( unsigned char *pbuf, unsigned int len );

int ix_buffer_resize( ix_buffer_t *pb, unsigned int len );

unsigned char * ix_buffer_reset( ix_buffer_t *pb );

unsigned char * ix_buffer_renew( ix_buffer_t *pb );

int ix_buffer_add( ix_buffer_t *pb, char *padr, size_t len );

int ix_buffer_len( ix_buffer_t *pb );

unsigned char * ix_buffer_freeadr( ix_buffer_t *pb, unsigned int *pfree );

unsigned char * ix_buffer_adr( ix_buffer_t *pb );


void  ix_buffer_free( ix_buffer_t *pb );

/***********************************************************************
 * message queue
***********************************************************************/

typedef struct ix_msg_queue_s ix_msg_queue_t;

ix_msg_queue_t * ix_msg_queue_new( ix_event_t *pev );

ix_msg_queue_t * ix_msg_queue_size_new( ix_event_t *pev, size_t size );

int ix_msg_queue_overrun( ix_msg_queue_t *pmq );

int ix_msg_queue_count( ix_msg_queue_t *pmq );

void ix_msg_queue_free( ix_msg_queue_t *pmq );

void *ix_msg_queue_eat( ix_msg_queue_t *pmq );

int ix_msg_queue_add( ix_msg_queue_t *pmq, void *pb, void **pret );
/***********************************************************************
 * queued IO
***********************************************************************/
typedef struct ix_qio_s ix_qio_t;

typedef enum
{
  IX_QIO_MAXLEN = 0x01,
  IX_QIO_DELIM = 0x02
} ix_qio_ctrl_e;

typedef union
{
  int maxlen;
  char *delim;
} ix_qio_ctrl_t;

typedef enum
{
  IX_QIO_HOOK_BUFFER_REUSE  = 0x01,
  IX_QIO_HOOK_BUFFER_LOCKED = 0x02,
  IX_QIO_HOOK_ERROR = 0xF0000
} ix_qio_hook_e;

typedef ix_qio_hook_e ( *IX_QIO_SAVE_FCT )( unsigned char *input, int len, void *userarg );

ix_qio_t * ix_qio_new( int  fd, int ctrl_tag, ix_qio_ctrl_t ctrl_info,
    size_t maxlen );

int ix_qio_reopen(ix_qio_t *pqio, int fd );

int ix_qio_receive( ix_qio_t *pqio, IX_QIO_SAVE_FCT save_fct, void *userarg );

int ix_qio_msg( ix_qio_t *pqio, ix_msg_queue_t *pmq );

ix_msg_queue_t * ix_qio_getmsg( ix_qio_t *pqio );

int ix_qio_issetup( ix_qio_t *pqio );

int ix_qio_isvalid( ix_qio_t *pqio );

int ix_qio_getfd( ix_qio_t *pqio );

void ix_qio_free( ix_qio_t *pqio );

/***********************************************************************
 * net messages
***********************************************************************/

#define IX_PROCNAME_LEN 12

typedef struct
{
  struct in_addr addr;   
  unsigned short nport;  
  char proc[IX_PROCNAME_LEN]; 
  unsigned int   nnode;  
} ix_adr_t;

int ix_adr_init( ix_adr_t *padr, char *hostip, unsigned short hport );

int ix_adr_initin( ix_adr_t *padr, void *ip, unsigned short hport );

int ix_adr_ip( ix_adr_t *padr, char *ip, int len );

int ix_adr_port( ix_adr_t *padr );

int ix_adr_getip( ix_adr_t *padr, void *ip );

int ix_adr_getnode( ix_adr_t *padr );

char *ix_adr_getproc( ix_adr_t *padr );

char *ix_adr_getnodeproc( ix_adr_t *padr, char *buf, int buflen );


int ix_adr_str( ix_adr_t *padr, char *str, int len );

char *ix_adr_str2( ix_adr_t *padr, char *str, int len );


int ix_adr_hostandport( ix_adr_t *padr, char *str, int len );

void ix_adr_proc( ix_adr_t *padr, char *proc, int node );


/***********************************************************************
 * NET packet
***********************************************************************/

typedef struct ix_netinfo_s
{
  int flag;              
  int socket;            
} ix_netinfo_t; 

typedef struct ix_net_s ix_net_t;

ix_net_t *ix_net_new(  char *tohost, unsigned short toport );

void ix_net_free(  ix_net_t *pnet );

int ix_net_setto( ix_net_t *pnet, ix_adr_t *toadr );

typedef int( * IX_SERVER_DISCONNECT_FCT)( ix_adr_t *padr, int fd );


int ix_net_setcb( ix_net_t *pnet, IX_SERVER_DISCONNECT_FCT cb );

int ix_net_event( ix_net_t *pnet, unsigned int evid );

int ix_net_trigger( ix_net_t *pnet, unsigned int evid );

int ix_net_send( ix_net_t *pnet );

int ix_tcp_packet( int sd, ix_net_t *pnet );


int ix_udp_msg( ix_net_t *pnet, unsigned char *buf, int buflen );

int ix_tcp_msg( ix_net_t *pnet, unsigned char *buf, int buflen );

int ix_send( ix_net_t *pnet, unsigned char *buf, int buflen, ix_net_t *preply);

ix_buffer_t  *ix_net_getmsg( ix_net_t *pnet );

ix_adr_t  *ix_net_getfrom( ix_net_t *pnet );

ix_adr_t  *ix_net_getto( ix_net_t *pnet );

ix_netinfo_t  *ix_net_getinfo( ix_net_t *pnet );

int  ix_net_setinfo( ix_net_t *pnet, ix_netinfo_t *pinfo );

int ix_net_tef( ix_net_t *pnet );

/***********************************************************************
 * utilities
***********************************************************************/



int ix_set_name( char *proc_name );

char *ix_get_name( void );

int ix_set_node( int node );

int ix_get_node( void );


/**************************************************************************
 * Server-application-context
 **************************************************************************/

typedef struct ix_tcp_client_s ix_tcp_client_t;

int ix_connect_udp( unsigned short myport );

int ix_connect_tcp( int myport );

int ix_tcp_get_port( void );

ix_adr_t *ix_tcp_client_getsender( ix_tcp_client_t *pcl );

int ix_tcp_client_getfd( ix_tcp_client_t *pcl );

int ix_tcp_client_isdata( ix_tcp_client_t *pcl );


int ix_tcp_client_cs_enter( ix_tcp_client_t *pcl );

int ix_tcp_client_cs_leave( ix_tcp_client_t *pcl );

int ix_tcp_client_setuserdata( ix_tcp_client_t *pcl, void *data );

void *ix_tcp_client_getuserdata( ix_tcp_client_t *pcl );

int ix_tcp_client_rm_byfd( int fd );

int ix_tcp_client_rm( ix_tcp_client_t *ptcp );


#define IX_TCP_CLIENT_PERMANENT 0

int ix_tcp_client_set_timeout_byfd( int fd, int timeout );

int ix_tcp_client_set_timeout( ix_tcp_client_t *ptcp, int timeout );


typedef int ( *IX_AST_PACKET_FCT)( ix_net_t *pnet );

int ix_ast_receive( IX_AST_PACKET_FCT fct );

int ix_ast_add_hook( int key, IX_AST_PACKET_FCT hook );

ix_net_t *ix_receive(void);


typedef int ( * IX_CLIENT_CONNECT_FCT)( ix_tcp_client_t *pcl );

int ix_set_client_connect_cb( IX_CLIENT_CONNECT_FCT cb );


typedef int ( * IX_CLIENT_REPLY_FCT)( ix_tcp_client_t *pcl, 
    unsigned char *sendbuf, int sendbuflen, unsigned char *replybuf, int replybuflen );
int ix_set_client_reply_cb( IX_CLIENT_REPLY_FCT cb );

typedef int ( * IX_CLIENT_DATA_FCT)( ix_tcp_client_t *pcl );

int ix_set_client_data_cb( IX_CLIENT_DATA_FCT cb );


typedef int( * IX_CLIENT_DISCONNECT_FCT)( ix_tcp_client_t *pcl );

int ix_set_client_disconnect_cb( IX_CLIENT_DISCONNECT_FCT cb );

int ix_set_server_disconnect_cb( IX_SERVER_DISCONNECT_FCT cb );


int ix_open_data( struct in_addr *addr, unsigned short port );


int ix_init( void );

#ifdef  __cplusplus
}
#endif


#endif

---