datasrc.h

Go to the documentation of this file.

/*
 *
 *    Copyright CAPLIN Systems Ltd 2000-2007
 *
 *
 *    $Author: andys $
 *    $DateTime: 2018/09/14 13:21:19 $
 *    $Change: 311850 $
 *    $Id: //CDev/V-7_1/datasrc/src/datasrc.h#13 $
 *
 *
 */

#ifdef __cplusplus
extern "C" {
#endif


#ifndef __DATASRC_H__
#define __DATASRC_H__


#undef DATASRC_MAJOR_VERSION
#undef DATASRC_MINOR_VERSION
#undef DATASRC_PATCH_VERSION

#define DATASRC_MAJOR_VERSION 7
#define DATASRC_MINOR_VERSION 1
#define DATASRC_PATCH_VERSION 5


#include <stdio.h>
#include <stdlib.h>

#ifdef WIN32

#include <winsock2.h>
#include <windows.h>
#include <time.h>
#include <ws2tcpip.h>
#include <direct.h>
#include <io.h>
#include <mswsock.h>

#else /* ! WIN32 */

#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <sys/ioctl.h>
#include <net/if.h>
#include <sys/uio.h>
#include <sys/timeb.h>
#include <utime.h>

#endif /* ! WIN32 */

#include <limits.h>
#include <sys/stat.h>
#include <string.h>
#include <fcntl.h>
#include <stdarg.h>
#include <errno.h>



#define EXIT_CODE_NML           0
#define EXIT_CODE_CFG           1
#define EXIT_CODE_LOG           2
#define EXIT_CODE_NET           3
#define EXIT_CODE_SYS           4
#define EXIT_CODE_LIC           5
#define EXIT_CODE_SIG           6
#define EXIT_CODE_SVC           7
#define EXIT_CODE_SSL           8
#define EXIT_CODE_JVM           9

/* Reserve codes for binary start-up issues */
#define EXIT_CODE_BIN_MISSING          10
#define EXIT_CODE_BIN_NOT_EXEC         11
#define EXIT_CODE_BIN_EXIT AFTER_FORK  12
#define EXIT_CODE_BIN_BAD_ARCH        126

/* Reserve an exit code for Java DataSource blade errors */
#define EXIT_CODE_JAVA_DATASOURCE_ERROR 201

#define EXIT_CODE_GRACEFUL              202

#ifndef WIN32
#ifndef DATASRCAPI
#define DATASRCAPI
#endif
#else /* WIN32 */
#ifndef DATASRCAPI
#ifndef DATASRC_EXPORT
#define DATASRCAPI _declspec(dllimport)
#else
#define DATASRCAPI _declspec(dllexport)
#endif
#endif
#endif /* WIN32 */


/* Provide some protection for variadic arguments */
#ifdef __GNUC__
#define PRINTF(fmt,arg) __attribute__ ((__format__ (__printf__, (fmt), (arg))))
#else
#define PRINTF(fmt,arg)
#endif


/* Types */

#ifndef WIN32
typedef int                   sock_t;

#define INVALID_SOCKET        -1

#define SOCKET_ERROR          -1
#else /* WIN32 */

typedef SOCKET                sock_t;
#include <inttypes.h>
#endif /* WIN32 */

typedef struct _ds_peer_set   ds_set_t;

typedef uint64_t ds_bitfield_t;

typedef struct _ds_data       ds_data_t;

typedef struct _ds_field      ds_field_t;

typedef struct _ds_delay      ds_delay_t;


typedef struct _config_ctx    ds_config_ctx_t;

typedef struct _ds_log        ds_log_t;

typedef void (*recv_update_t)(int peer, ds_data_t *pkt);

typedef void (*recv_replay_t)(int peer, ds_data_t *pkt, time_t tm);

typedef void (*recv_nodata_t)(int peer, char *subject, unsigned short flags);

typedef void (*recv_peer_status_t)(int peer, int status, int val, void *data);

typedef void (*recv_request_t)(int peer, int count, char **subjects, unsigned short flags);

typedef void (*recv_discard_t)(int peer, int count, char **subjects, unsigned short flags);

typedef void (*recv_object_status_t)(int peer, char *subject, int status, unsigned short code, char *msgstr);

typedef void (*recv_service_status_t)(char *service, int status);


typedef void (*recv_map_t)(int peer, char *from, char *to);


typedef struct
  {
     char                  *application_name;      
     char                  *application_root;      
     char                  *log_root;              
     unsigned short                flags;                 
     unsigned short                type;                  
     recv_request_t         recv_request;          
     recv_discard_t         recv_discard;          
     recv_update_t          recv_update;           
     recv_nodata_t          recv_nodata;           
     recv_peer_status_t     recv_peer_status;      
     recv_object_status_t   recv_object_status;    
     recv_service_status_t  recv_service_status;   
     recv_map_t             recv_map;              
     void                 (*exit_func)(int exit_code, char *msg); 
     char                  *logfile;               
     ds_log_t              *log;                   
  }
ds_init_t;

#define DS_INITIALISER \
   { \
      NULL, /* application_name */ \
      NULL, /* application_root */ \
      NULL, /* log_root */ \
      0,    /* flags */ \
      0,    /* type */ \
      NULL, /* recv_request */ \
      NULL, /* recv_discard */ \
      NULL, /* recv_update */ \
      NULL, /* recv_nodata */ \
      NULL, /* recv_peer_status */ \
      NULL, /* recv_object_status */ \
      NULL, /* recv_service_status */ \
      NULL, /* recv_map */ \
      NULL, /* exit_func */ \
      NULL, /* logfile */ \
      NULL, /* log */ \
   }


/* datasrc */

DATASRCAPI void                ds_reserve_std_fds(void);
DATASRCAPI void                ds_config_init(const char *file, int argc, char **argv);
DATASRCAPI int                 ds_init(ds_init_t *init, int argc, char **argv);
DATASRCAPI void                ds_thread_init(int event_module, int flags);
DATASRCAPI char               *ds_filename_expand(const char *format, char *buffer, size_t bufsize);
DATASRCAPI ds_log_t           *ds_get_event_log(void);


/* ds5 */


typedef struct _ds5_namespace_s ds5_namespace_t;

struct _ds5_namespace_s
  {
     void   (*free)(ds5_namespace_t *nspace);

     int    (*match)(ds5_namespace_t *nspace, const char *subject);


     char  *(*describe)(ds5_namespace_t *nspace, char *buf, size_t buflen);

  };


DATASRCAPI ds5_namespace_t    *ds5_create_prefix_namespace(const char *prefix);

DATASRCAPI ds5_namespace_t    *ds5_create_globbed_namespace(const char *globbed);
DATASRCAPI ds5_namespace_t    *ds5_create_regex_namespace(const char *expr);
DATASRCAPI int                 ds5_regex_namespace_add_expr(ds5_namespace_t *nspace, const char *expr, int exclude);


/* Macros for convenience */

#define ds5_namespace_match(nspace, subject)  nspace->match(nspace, subject)

#define ds5_namespace_free(nspace)  nspace->free(nspace)





typedef struct _ds5_publisher_s ds5_publisher_t;







typedef struct
  {
     void  (*receive_request)(void *context, int peer, const char *subject);

     void  (*receive_discard)(void *context, int peer, const char *subject);
  }
ds5_dataprovider_t;


DATASRCAPI ds5_publisher_t    *ds5_create_active_publisher(ds5_namespace_t *nspace, ds5_dataprovider_t *provider, void *context);
DATASRCAPI ds5_publisher_t    *ds5_create_compatibility_publisher(ds5_namespace_t *nspace, ds5_dataprovider_t *provider, void *context);
DATASRCAPI ds5_publisher_t    *ds5_create_broadcast_publisher(ds5_namespace_t *nspace);

DATASRCAPI void        ds5_publish_to_subscribed_peers_no_free(ds5_publisher_t *pub, ds_data_t *dsdata);
DATASRCAPI void        ds5_publish_to_subscribed_peers(ds5_publisher_t *pub, ds_data_t *dsdata);
DATASRCAPI void        ds5_publish_response(ds5_publisher_t *pub, ds_data_t *dsdata);
DATASRCAPI void        ds5_publish_response_no_free(ds5_publisher_t *pub, ds_data_t *dsdata);
DATASRCAPI void        ds5_publish_status(ds5_publisher_t *pub, const char *subject, int status, const char *message);
DATASRCAPI void        ds5_publish_status_all(ds5_publisher_t *pub, int status, const char *message);
DATASRCAPI void        ds5_publish_subject_error(ds5_publisher_t *publisher, const char *subject, int flags);
DATASRCAPI void        ds5_publish_to_peer(ds5_publisher_t *publisher, int peernum, ds_data_t *dsdata);
DATASRCAPI void        ds5_publish_to_peer_no_free(ds5_publisher_t *publisher, int peernum, ds_data_t *dsdata);
DATASRCAPI void        ds5_publish_subject_map(ds5_publisher_t *publisher, const char *subject, const char *mapped_to, int flags);


typedef struct
  {
     void  (*service_status)(void *context, const char *service_name, int state);

     void  (*peer_status)(void *context, int peer_index, const char *peer_name, int state);
  }
ds5_connectionlistener_t;


typedef struct _ds5_subscription_s ds5_subscription_t;


typedef struct
  {
     void (*record_updated)(void *context, ds5_subscription_t *sub, int peer, ds_data_t *dsdata);

     void (*record_type2_updated)(void *context, ds5_subscription_t *sub, int peer, ds_data_t *dsdata);

     void (*record_type3_updated)(void *context, ds5_subscription_t *sub, int peer, ds_data_t *dsdata);

     void (*container_updated)(void *context, ds5_subscription_t *sub, int peer, ds_data_t *dsdata);

     void (*permission_updated)(void *context, ds5_subscription_t *sub, int peer, ds_data_t *dsdata);

     void (*news_updated)(void *context, ds5_subscription_t *sub, int peer, ds_data_t *dsdata);

     void (*news_story_updated)(void *context, ds5_subscription_t *sub, int peer, ds_data_t *dsdata);

     void (*page_updated)(void *context, ds5_subscription_t *sub, int peer, ds_data_t *dsdata);

     void (*unknown_subject_type_updated)(void *context, ds5_subscription_t *sub, int peer, ds_data_t *dsdata);


     void (*subscription_error)(void *context, ds5_subscription_t *sub, int peer, const char *subject, short flags);

     void (*subscription_status)(void *context, ds5_subscription_t *sub, int peer, const char *subject, int status, const char *message);
  }
ds5_subscriptionlistener_t;





DATASRCAPI void                ds5_config_init(const char *configfile, int argc, char **argv);
DATASRCAPI int                 ds5_init(int argc, char **argv);
DATASRCAPI void                ds5_add_connectionlistener(ds5_connectionlistener_t  *connection_listener, void *context);




DATASRCAPI ds5_subscription_t *ds5_create_broadcast_subscription(ds5_namespace_t *nspace, ds5_subscriptionlistener_t *listener, void *context);
DATASRCAPI ds5_subscription_t *ds5_create_active_subscription(const char *subject, ds5_subscriptionlistener_t *listener, void *context);
DATASRCAPI void                ds5_unsubscribe(ds5_subscription_t *sub);



/* config */


#define DS_OFFSET(t,m)       ((void *)&((t *)0)->m)

#define DS_CONFIG_BOOL         0x0001

#define DS_CONFIG_INT          0x0002

#define DS_CONFIG_FLOAT        0x0003

#define DS_CONFIG_STR          0x0004

#define DS_CONFIG_CHAR         0x0005

#define DS_CONFIG_FUNC         0x0006

#define DS_CONFIG_FILE         0x0007

#define DS_CONFIG_GROUP        0x0010
#define DS_CONFIG_GROUP_END    0x0011
#define DS_CONFIG_SECTION      0x0020
#define DS_CONFIG_SECTION_END  0x0021

#define DS_CONFIG_JAVA         0x0080

#define DS_CONFIG_ARRAY        0x0100

#define DS_CONFIG_INT_ARRAY    (DS_CONFIG_ARRAY|DS_CONFIG_INT)

#define DS_CONFIG_FLOAT_ARRAY  (DS_CONFIG_ARRAY|DS_CONFIG_FLOAT)


#define DS_CONFIG_STR_ARRAY    (DS_CONFIG_ARRAY|DS_CONFIG_STR)

#define DS_CONFIG_CHAR_ARRAY   (DS_CONFIG_ARRAY|DS_CONFIG_CHAR)

#define DS_CONFIG_STRICT       0x0200

#define DS_CONFIG_DEPRECATED   0x0400


typedef struct
  {
     char               *name;           
     double              value;          
     char               *docstring;      
  }
ds_config_enum_t;


typedef void      (*ds_config_func)(char *name, int num, char **values);


DATASRCAPI ds_config_ctx_t    *ds_config_new_ctx(void);
DATASRCAPI void                ds_config_free_ctx(ds_config_ctx_t *ctx);
DATASRCAPI ds_config_ctx_t    *ds_config_set_ctx(ds_config_ctx_t *ctx);
DATASRCAPI void                ds_config_add_search(const char *path);
DATASRCAPI void                ds_config_add_file(const char *file);
DATASRCAPI void                ds_config_add_optional_file(const char *file);
DATASRCAPI void                ds_config_add_option(char opt, const char *longopt, const char *help, int type, void *value);
DATASRCAPI void                ds_config_add_bounded_option(char sopt,const char *longopt, const char *help, int type, void *value, void *min, void *max);
DATASRCAPI void                ds_config_add_option_enum(char opt,const char *longopt, const char *help, int type, void *value, ds_config_enum_t *enums);
DATASRCAPI void                ds_config_add_bounded_option_enum(char sopt,const char *longopt, const char *help, int type, void *value, ds_config_enum_t *enums, void *min, void *max);
DATASRCAPI void                ds_config_add_array_option(const char *longopt, const char *help, int type, void *value, int *num);
DATASRCAPI void                ds_config_add_bounded_array_option(const char *longopt,const char *help, int type, void *value, int *num, void *min, void *max);
DATASRCAPI void                ds_config_add_array_option_enum(const char *longopt,const char *help, int type, void *value, int *num, ds_config_enum_t *enums);
DATASRCAPI void                ds_config_add_bounded_array_option_enum(const char *longopt,const char *help, int type, void *value, int *num, ds_config_enum_t *enums, void *min, void *max);
DATASRCAPI void                ds_config_del_option(const char *longopt);
DATASRCAPI void                ds_config_add_group(const char *longopt, const char *help, void *base, void *def, size_t size, int *num);
DATASRCAPI  void               ds_config_add_group_with_info(const char *longopt, const char *help, void *base, void *def, size_t size, int *num, int file_offset, int line_offset);
DATASRCAPI void                ds_config_end_group(const char *longopt,const  char *help);
DATASRCAPI void                ds_config_add_section(const char *longopt,const  char *help);
DATASRCAPI void                ds_config_end_section(const char *longopt,const  char *help);
DATASRCAPI void                ds_config_parse_files(void);
DATASRCAPI void                ds_config_parse_args(int argc, char **argv, int *retargc);
DATASRCAPI int                 ds_config_parse_file(const char *unresolved_filename);
DATASRCAPI void                ds_config_list_options(void);
DATASRCAPI void                ds_config_list_values(void);
DATASRCAPI int                 ds_config_get_enum(const char *value, ds_config_enum_t *enums);
DATASRCAPI void                ds_config_add_error_message_fmt(const char *fmt,...) PRINTF(1,2);
DATASRCAPI void                ds_config_add_config_reading_message_fmt(const char *fmt,...) PRINTF(1,2);
DATASRCAPI void                ds_config_add_error_message(const char *msg);
DATASRCAPI char               *ds_config_get_filename(void);
DATASRCAPI int                 ds_config_get_linenumber(void);
DATASRCAPI void                ds_config_set_test(const char *tag, char **value);
DATASRCAPI void                ds_config_del_test(const char *tag);
DATASRCAPI void                ds_config_set_option(const char *name, const char *value);


/* event */


typedef unsigned long            ds_reltime_t;

typedef struct _ds_timed_event   ds_timed_event_t;


typedef struct _ds_io_event      ds_except_event_t;



typedef struct _ds_io_event      ds_read_event_t;


typedef struct _ds_io_event      ds_write_event_t;


typedef struct _ds_io_event      ds_generic_event_t;


typedef int                    (*ds_io_event_cb)(sock_t sock, int val, void *data);

typedef int                    (*ds_timed_event_cb)(int id, int val, void *data);


#define DOUBLE_TO_RELTIME(r,d) r = ((int)(d) << 9) + ((int)(((d) - (int)(d)) * 1000000) >> 11);
#define TIMEVAL_TO_RELTIME(r,tv) r = ((tv).tv_sec << 9) + ((tv).tv_usec >> 11);


DATASRCAPI ds_timed_event_t   *ds_add_timed_event(int id, double delay, ds_timed_event_cb cb, int val, void *data);
DATASRCAPI ds_read_event_t    *ds_add_read_event(sock_t fd, ds_io_event_cb cb, int val, void *data);
DATASRCAPI ds_write_event_t   *ds_add_write_event(sock_t fd, ds_io_event_cb cb, int val, void *data);
DATASRCAPI ds_except_event_t  *ds_add_except_event(sock_t fd, ds_io_event_cb cb, int val, void *data);

DATASRCAPI int                 ds_del_timed_event(ds_timed_event_t *ev);
DATASRCAPI int                 ds_del_read_event(ds_read_event_t *ev);
DATASRCAPI int                 ds_del_write_event(ds_write_event_t *ev);
DATASRCAPI int                 ds_del_except_event(ds_except_event_t *ev);

DATASRCAPI int                 ds_del_timed_event_free_data(ds_timed_event_t *ev, void (*free_data)(int, void *));
DATASRCAPI int                 ds_del_read_event_free_data(ds_read_event_t *ev, void (*free_data)(int, void *));
DATASRCAPI int                 ds_del_write_event_free_data(ds_write_event_t *ev, void (*free_data)(int, void *));
DATASRCAPI int                 ds_del_except_event_free_data(ds_except_event_t *ev, void (*free_data)(int, void *));

DATASRCAPI void                ds_timed_event_set_callback(ds_timed_event_t *ev, ds_timed_event_cb cb, int val, void *data);
DATASRCAPI double              ds_timed_event_get_fire_time(ds_timed_event_t *ev);
DATASRCAPI void                ds_read_event_set_callback(ds_read_event_t *ev, ds_io_event_cb cb, int val, void *data);
DATASRCAPI void                ds_write_event_set_callback(ds_write_event_t *ev, ds_io_event_cb cb, int val, void *data);

DATASRCAPI void                ds_set_timed_delay(ds_timed_event_t *ev, double delay);
DATASRCAPI void                ds_set_timed_delay_next(ds_timed_event_t *ev, double delay);

DATASRCAPI void                ds_loop(void);
DATASRCAPI void                ds_stop(void);

DATASRCAPI ds_reltime_t        ds_get_relative_time(void);
DATASRCAPI time_t              ds_get_time(void);
DATASRCAPI struct tm          *ds_gmtime(void);
DATASRCAPI struct tm          *ds_localtime(void);
DATASRCAPI int                 ds_get_gmt_offset(time_t t);
DATASRCAPI char               *ds_get_timezone(char *buf, int len);

DATASRCAPI ds_timed_event_t   *ds_add_periodic_event(int starttime, int period, int id, ds_timed_event_cb cb, int val, void *data);
DATASRCAPI ds_timed_event_t   *ds_add_periodic_event_from_time(time_t then, int starttime, int period, int id, ds_timed_event_cb cb, int val, void *data);
DATASRCAPI int                 ds_check_periodic_event(int period, ds_timed_event_t **tev);


/* cache */

#define DS_CACHE_DATASRC -1

DATASRCAPI void                ds_cache_add_object(char *subject);


/* daemon */


DATASRCAPI void                ds_daemon_redirect(void);
DATASRCAPI int                 ds_daemon_disabled(void);


/* fields */


#define DS_FIELDS_SEPARATOR     -65536

#define DS_FIELDS_NOT_DEFINED  (-2147483647 - 1)

DATASRCAPI int                 ds_fields_max(void);
DATASRCAPI int                 ds_fields_add(int num, const char *name, int flags, int dp, const char *fmt);
DATASRCAPI int                 ds_fields_numbyname(const char *name);
DATASRCAPI char               *ds_fields_namebynum(int num);
DATASRCAPI int                 ds_fields_indexbyname(const char *name);
DATASRCAPI int                 ds_fields_indexbynum(int num);
DATASRCAPI int                 ds_fields_numbyindex(int index);
DATASRCAPI char               *ds_fields_namebyindex(int index);
DATASRCAPI char               *ds_fields_rttpnumbyindex(int index);
DATASRCAPI int                 ds_fields_getflags(int index);
DATASRCAPI int                 ds_fields_getdp(int index);



/* log */

#define DS_LOG_CONFIG          0
#define DS_LOG_ALWAYS          1

#define DS_LOG_CRIT            2

#define DS_LOG_ERROR           3

#define DS_LOG_NOTIFY          4

#define DS_LOG_WARN            5

#define DS_LOG_INFO            6

#define DS_LOG_DEBUG           7

#define DS_LOG_FINER           8

#define DS_LOG_FINEST          9

#define DS_LOG_MONITOR       128

#define DS_LOG_TERMINAL      256

#define DS_LOG_SYSLOG        512
#define DS_LOG_FILEONLY     1024
#define DS_LOG_NO_MONITOR   2048

typedef void (*ds_loglevelchange_t)(ds_log_t *log, int new_level);

typedef void (*ds_logcycled_t)(ds_log_t *log);




DATASRCAPI ds_log_t           *ds_new_log(const char *name,const char *logname);
DATASRCAPI ds_log_t           *ds_new_level_log(const char *name, const char *logname, ds_loglevelchange_t change_cb);
DATASRCAPI ds_log_t           *ds_new_headed_log(const char *name, const char *logname, const char *header);
DATASRCAPI void                ds_free_log(ds_log_t *log);
DATASRCAPI void                ds_write(ds_log_t *log, void *data, size_t len);
#ifndef WIN32
DATASRCAPI void                ds_writev(ds_log_t *log, struct iovec *vector, int count);
#endif
DATASRCAPI void                ds_printf(ds_log_t *log, const char *fmt, ...) PRINTF(2,3);
DATASRCAPI void                ds_printf_time(ds_log_t *log, const char *fmt, ...) PRINTF(2,3);
DATASRCAPI void                ds_printf_time_ap(ds_log_t *log, const char *extra, const char *fmt, va_list ap);
DATASRCAPI void                ds_syslog(ds_log_t *log, int priority, const char *fmt, ...) PRINTF(3,4);
DATASRCAPI void                ds_cycle_all_logs(const char *suffix, long maxsize);
DATASRCAPI int                 ds_cycle_log(ds_log_t *log, const char *suffix, long maxsize);
DATASRCAPI char               *ds_log_getfilename(ds_log_t *log);
DATASRCAPI int                 ds_debug_level(const char *text);
DATASRCAPI char               *ds_debug_string(int level);
DATASRCAPI char               *ds_debug_config_string(int level);
DATASRCAPI void                ds_log(ds_log_t *log, int level, const char *fmt,...) PRINTF(3,4);
DATASRCAPI int                 ds_log_set_log_level(ds_log_t *log, const char *level);
DATASRCAPI void                ds_log_change_level_callback(ds_log_t *log, ds_loglevelchange_t change_cb);
DATASRCAPI ds_logcycled_t      ds_log_cycled_callback(ds_log_t *log, ds_logcycled_t cycle_cb);
DATASRCAPI int                 ds_log_get_level(ds_log_t *log);
DATASRCAPI int                 ds_log_flush(ds_log_t *log);


/* lty_chain */


DATASRCAPI void                ds_add_latency_chain(ds_data_t *dsdata, char suffix, struct timespec *tp);

DATASRCAPI void                ds_add_latency_chain2(ds_data_t *dsdata, char suffix, struct timespec tp, char suffix2, struct timespec *tp2);

DATASRCAPI void                ds_add_latency_initial_timestamp(ds_data_t *dsdata);

/* monitor */


#define   TYPE_NONE         0

#define   TYPE_BINARY       1

#define   TYPE_STRING       2

#define   TYPE_SHORT        3

#define   TYPE_USHORT       4

#define   TYPE_LONG         5

#define   TYPE_ULONG        6

#define   TYPE_LLONG        7

#define   TYPE_ULLONG       8

#define   TYPE_DOUBLE       9

#define   TYPE_TIMESTAMP    10

#define   TYPE_BOOLEAN      11

#define   TYPE_RELATION     20

#define   TYPE_SUBSCRIPTION 21


#define   TYPE_PRIMITIVE_MASK         31

#define   TYPE_ARRAY       32

#define   TYPE_ACTIVE      64

#define   TYPE_ACTIVE2    128

#define   TYPE_METHOD     256

#define   TYPE_KEY        512

#define   TYPE_HIERARCHY 1024

#define  TYPE_OPTIONAL   2048


typedef struct  {
   size_t  size;                
   union  _ds_mondata_value {
      void     *b;
      char    **c;
      int16_t   *s;
      uint16_t  *us;
      int32_t   *l;
      uint32_t  *ul;
      int64_t   *ll;
      uint64_t  *ull;
      double    *d;
     } data;                     
  }
ds_array_t;

typedef struct
  {
      char  *propertyname;        
      int    datatype;            
      union _ds_mondata_value2
        {
            void      *active_ptr;   /* Do not set used by monitoring API */
            char      *c;
            int16_t    s;
            uint16_t   us;           /* Also used for TYPE_BOOLEAN */
            int32_t    l;
            uint32_t   ul;           /* Also used for TYPE_TIMESTAMP */
            int64_t    ll;
            uint64_t   ull;
            double     d;
            ds_array_t array;
        }
      data;                   
   }
ds_monitor_t;


typedef struct
  {
     int          typeflags;         
     char        *name;              
     char        *description;       
     char        *docstring;         
  }
ds_arguments_t;


typedef ds_monitor_t *(*ds_monitor_method_cb)(char *templatename, char *key, char *property, int argc, char *argv[]);

typedef ds_monitor_t *(*ds_monitor_active_cb)(char *templatename, char *key, char *propertyname);



typedef struct
  {
     char   *username;        
     char   *password;        
     char   *ipaddress;       
  }
ds_monauth_t;

typedef int  (*ds_monitor_authenticator_t)(ds_monauth_t *credentials);



DATASRCAPI char               *ds_monitor_module_name(void);


DATASRCAPI void                ds_monitor_add_server_type(const char *type, const char *root);
DATASRCAPI void                ds_monitor_start_template(const char *templatename, const char *description);
DATASRCAPI void                ds_monitor_add_template_member(const char *templatename, const char *propertyname, const char *description, int typeflags, ds_arguments_t *args, void *ptr);
DATASRCAPI void                ds_monitor_add_template_relation(const char *templatename, const char *propertyname, const char *targettemplate, const char *description, int thisend_multiple, int thatend_multiple);
DATASRCAPI void                ds_monitor_add_template_subscription(const char *templatename, const char *propertyname, const char *targettemplate, const char *description, const char *singleton, ds_monitor_active_cb callback_fn);


DATASRCAPI void                ds_monitor_add_relation(const char *templatename, const char *key, const char *propertyname, const char *targetkey);
DATASRCAPI void                ds_monitor_del_relation(const char *templatename, const char *key, const char *propertyname, const char *targetkey);

DATASRCAPI void                ds_monitor_add_subscription(const char *templatename, const char *key, const char *propertyname, const char *value);
DATASRCAPI void                ds_monitor_del_subscription(const char *templatename, const char *key, const char *propertyname, const char *value);

DATASRCAPI void                ds_monitor_end_template(const char *templatename);

DATASRCAPI void                ds_monitor_create_group(const char *templatename, const char *key, const char *brief, const char *description);
DATASRCAPI void                ds_monitor_delete_group(const char *templatename, const char *key);



DATASRCAPI void                ds_monitor_update(const char *templatename, const char *key, ds_monitor_t *mondata);
DATASRCAPI void                ds_monitor_update_string(const char *templatename, const char *key, const char *propertyname, const char *value);
DATASRCAPI void                ds_monitor_update_ushort(const char *templatename, const char *key, const char *propertyname, uint16_t);
DATASRCAPI void                ds_monitor_update_short(const char *templatename, const char *key, const char *propertyname, int16_t value);
DATASRCAPI void                ds_monitor_update_ulong(const char *templatename, const char *key, const char *propertyname, uint32_t value);
DATASRCAPI void                ds_monitor_update_long(const char *templatename,const char *key, const char *propertyname, int32_t value);
DATASRCAPI void                ds_monitor_update_ullong(const char *templatename, const char *key, const char *propertyname, uint64_t value);
DATASRCAPI void                ds_monitor_update_llong(const char *templatename, const char *key, const char *propertyname, int64_t value);
DATASRCAPI void                ds_monitor_update_double(const char *templatename, const char *key, const char *propertyname, double value);
DATASRCAPI void                ds_monitor_update_timestamp(const char *templatename, const char *key, const char *propertyname, int64_t value);
DATASRCAPI void                ds_monitor_update_boolean(const char *templatename, const char *key, const char *propertyname, uint8_t value);



DATASRCAPI ds_monitor_t       *ds_monitor_new(const char *propertyname, int type, int datasize, const void *datum);
DATASRCAPI ds_monitor_t       *ds_monitor_new_array(const char *propertyname, int type);
DATASRCAPI void                ds_monitor_add_data(ds_monitor_t *data, const void *datum);
DATASRCAPI void                ds_monitor_free(ds_monitor_t *data);        /* Needed by plugin */

DATASRCAPI void                ds_monitor_free_data(ds_monitor_t *data);


DATASRCAPI ds_monitor_t       *ds_monitor_new_string(const char *templatename, const char *key, const char *propertyname, const char *value);
DATASRCAPI ds_monitor_t       *ds_monitor_new_ushort(const char *templatename, const char *key, const char *propertyname, uint16_t value);
DATASRCAPI ds_monitor_t       *ds_monitor_new_short(const char *templatename, const char *key, const char *propertyname, int16_t value);
DATASRCAPI ds_monitor_t       *ds_monitor_new_ulong(const char *templatename, const char *key, const char *propertyname, uint32_t value);
DATASRCAPI ds_monitor_t       *ds_monitor_new_long(const char *templatename,const char *key, const char *propertyname, int32_t value);
DATASRCAPI ds_monitor_t       *ds_monitor_new_ullong(const char *templatename, const char *key, const char *propertyname, uint64_t value);
DATASRCAPI ds_monitor_t       *ds_monitor_new_llong(const char *templatename, const char *key, const char *propertyname, int64_t value);
DATASRCAPI ds_monitor_t       *ds_monitor_new_double(const char *templatename, const char *key, const char *propertyname, double value);
DATASRCAPI ds_monitor_t       *ds_monitor_new_timestamp(const char *templatename, const char *key, const char *propertyname, int64_t value);
DATASRCAPI ds_monitor_t       *ds_monitor_new_boolean(const char *templatename, const char *key, const char *propertyname, uint8_t value);


DATASRCAPI ds_monitor_authenticator_t ds_monitor_set_auth(ds_monitor_authenticator_t authenticator);


/* net */


DATASRCAPI sock_t              ds_listen_socket(const char *addr, int port, int backlog);
DATASRCAPI sock_t              ds_accept_socket(sock_t fd);
DATASRCAPI sock_t              ds_multicast_listen_socket(const char *p_interface, const char *addr, int port);
DATASRCAPI sock_t              ds_udp_listen_socket(const char *p_interface, int port);
DATASRCAPI sock_t              ds_client_socket(const char *serv, unsigned short port);
DATASRCAPI sock_t              ds_client_socket_nonblocking(const char *serv, unsigned short port);
DATASRCAPI int                 ds_udp_send(const char *data, int len, const char *addr, int port);
DATASRCAPI int                 ds_udp_sendto(const char *data, int len, struct sockaddr_storage *serv_addr);
DATASRCAPI sock_t              ds_udp_client_socket(const char *addr, int port, struct sockaddr_storage *serv_addr);
DATASRCAPI int                 ds_udp_bind_client_socket(sock_t sock, const char *addr, int port);
DATASRCAPI char               *ds_interface_address(const char *ifname);
DATASRCAPI void                ds_setnonblocking(sock_t fd);
DATASRCAPI char               *ds_getnameinfo(const struct sockaddr_storage *addr, char *buf, size_t buflen);
DATASRCAPI int                 ds_compare_sockaddr(struct sockaddr_storage *sa, struct sockaddr_storage *sb);
DATASRCAPI int                 ds_pipe(sock_t fds[2]);
DATASRCAPI int                 ds_check_subnet(const char *s_address, const char *s_network, const char *s_netmask);
DATASRCAPI struct sockaddr_storage *ds_gethostsockaddr(const char *name, struct sockaddr_storage *populate);
DATASRCAPI struct addrinfo         *ds_gethostsockaddrs(const char *name);



/* Message Types */

#define DS_MSG_CONNECT           0x0100

#define DS_MSG_DISCONNECT        0x0200
#define DS_MSG_STATUS            0x0400


/* Peer Types */

#define DS_T_USERMASK            0x00ff

#define DS_T_ACTIVE              0x0001

#define DS_T_CONTRIB             0x0002

#define DS_T_MSG                 0x0100


/* Peer Flags */

#define DS_F_USERMASK            0x00ff

#define F_SENDFROMSEQ            0x0001

#define F_SENDFROMFIELD          0x0002


#define F_RECVAUTOREPLAY         0x0004


#define F_NOCONNECT              0x0008

#define F_RECONNECT              0x0100
#define F_FAILOVER               0x0200


/* No Data Flags */

#define F_NODATAMASK             0x000f

#define F_NOTFOUND               0x0001

#define F_READDENY               0x0002

#define F_WRITEDENY              0x0003

#define F_DELETEOBJECT           0x0004

#define F_UNAVAILABLE            0x0005
#define F_STATUS                 0x0006



#define F_IGNOREREQTIMEOUT           0x0008

/* Object Types */

#define DS_PAGE_TYPE             221

#define DS_RECORD_TYPE           222

#define DS_RECORD_TYPE2          225

#define DS_RECORD_TYPE3          226

#define DS_NEWS_TYPE             223

#define DS_STORY_TYPE            224

#define DS_CONTAINER_TYPE        228

#define DS_PERMISSION_TYPE       230

#define DS_GENERIC_TYPE          231


/* Data Flags */

#define F_CREATEOBJECT           0x0010

#define F_CREATEPARENT           0x0020
#define F_PERSISTENT             0x0040
#define F_CREATEDATA             0x0080

#define F_CLEAR_PERM             0x0400

#define F_FILTER_PERM            0x0800

#define F_AUTHGLOBAL             0x0100

#define F_CLEAR_TYPE3            0x0100

#define F_FILTER_TYPE3           0x0200

#define F_CLEAR_TYPE2            0x0400

#define F_FILTER_TYPE2           0x0800

#ifdef __DARWIN_NULL
#undef F_NOCACHE
#endif
#define F_NOCACHE                0x0400

#define F_DELETE_HEADLINE        0x0100

#define F_CHANGE_HEADLINE        0x0200

#define F_IMAGE                  0x1000

#define F_NONACTIVE              0x2000

#define F_AUTHUPDATE             0x4000


#define F_CONSTITUENT_NOAUTH     0x4000

#define F_CHANGEDFIELDS          0x8000

/* Field Data Types */

#define FLOAT32_TYPE             1
#define FLOAT64_TYPE             2
#define INT8_TYPE                3
#define INT16_TYPE               4
#define INT32_TYPE               5
#define INT64_TYPE               6


/* Object request flags */

#define DS_REQUEST_FAILOVER      1

#define DS_REQUEST_CACHE         4



/* Object Status Flags */

#define S_INFO                   0x0000

#define S_STALE                  0x0001

#define S_NOTSTALE               0x0004

#define S_UPDCLR                 0x0100

#define S_FAILOVER               0x1101 /* Failover implies S_STALE|S_UPDCLR */


#define OBJ_STATUS_INFO          0x0000

#define OBJ_STATUS_OK            0x0001

#define OBJ_STATUS_STALE         0x0002


#define OBJ_STATUS_LIMITED       0x0008


#define OBJ_STATUS_NOTMAPPED     0x0010

#define SVC_STATUS_OK            0x0001

#define SVC_STATUS_DOWN          0x0002

#define SVC_STATUS_LIMITED       0x0008


/* Field Macros */
#define DS_MAX_BITFIELD    (sizeof(ds_bitfield_t)*8)

#define DS_BITFIELD_SET(n,p)     *(p) |= (1ULL << (n))
#define DS_BITFIELD_CLR(n,p)     *(p) &= ~(1ULL << (n))
#define DS_BITFIELD_ISSET(n,p)   (*(p) & (1ULL << (n)))
#define DS_BITFIELD_ZERO(p)      *(p) = 0
#define DS_BITFIELD_NONZERO(p)    memset((char *)(p), 0xffffffff, sizeof(*(p)))

/* Peer set functions and macros */

DATASRCAPI int           ds_iszero(ds_set_t *p);
DATASRCAPI void          ds_or(ds_set_t *p1, ds_set_t *p2, ds_set_t *o);
DATASRCAPI void          ds_and(ds_set_t *p1, ds_set_t *p2, ds_set_t *a);
DATASRCAPI int           ds_and_iszero(ds_set_t *p1, ds_set_t *p2);
DATASRCAPI int           ds_and3_iszero(ds_set_t *p1, ds_set_t *p2, ds_set_t *p3);
DATASRCAPI int           ds_isequal(ds_set_t *p1, ds_set_t *p2);

#define DS_MAX_PEERS        1024

#define DS_MIN_PEER         0

#define DS_INTERNAL_DATASRC 1023

typedef uint32_t    dsset_element_t;

#define DS_NUMBITS            (sizeof(dsset_element_t) * 8)
#define DS_NUM_ELEMS          (DS_MAX_PEERS+DS_NUMBITS-1)/DS_NUMBITS
#define DS_NUM_BYTES          (DS_NUM_ELEMS * sizeof(dsset_element_t))

struct _ds_peer_set
  {
     dsset_element_t  bits[DS_NUM_ELEMS];
  };

#define DS_SET(n,p)     ((p)->bits[(n)/DS_NUMBITS] |= ((unsigned)1 << ((n) % DS_NUMBITS)))

#define DS_CLR(n,p)     ((p)->bits[(n)/DS_NUMBITS] &= ~((unsigned)1 << ((n) % DS_NUMBITS)))

#define DS_ISSET(n,p)   ((p)->bits[(n)/DS_NUMBITS] & ((unsigned)1 << ((n) % DS_NUMBITS)))

#define DS_ZERO(p)      memset((char *)(p)->bits, 0, DS_NUM_BYTES)

#define DS_NONZERO(p)   memset((char *)(p)->bits, 0xff, DS_NUM_BYTES)

#define DS_ISZERO(p)   ds_iszero(p)

#define DS_AND(p1, p2, a)   ds_and(p1, p2, a)

#define DS_OR(p1, p2, o)   ds_or(p1, p2, o)

#define DS_AND_ISZERO(p1, p2) ds_and_iszero(p1, p2)

#define DS_AND3_ISZERO(p1, p2, p3) ds_and3_iszero(p1, p2, p3)

#define DS_ISEQUAL(p1, p2) ds_isequal(p1, p2)

DATASRCAPI ds_data_t          *ds_init_data(const char *subject, unsigned short type, unsigned short flags);
DATASRCAPI void                ds_set_subject(ds_data_t *data, const char *subject);

DATASRCAPI void                ds_add_data(ds_data_t *data, int32_t fieldnum, const char *value);
DATASRCAPI void                ds_add_data_fmt(ds_data_t *data, int32_t fieldnum, const char *fmt, ...);
DATASRCAPI void                ds_add_data_str(ds_data_t *data, int32_t fieldnum, const char *value);
DATASRCAPI void                ds_add_data_float32(ds_data_t *data, int32_t fieldnum, float value);
DATASRCAPI void                ds_add_data_float64(ds_data_t *data, int32_t fieldnum, double value);
DATASRCAPI void                ds_add_data_int8(ds_data_t *data, int32_t fieldnum, int8_t value);
DATASRCAPI void                ds_add_data_int16(ds_data_t *data, int32_t fieldnum, int16_t value);
DATASRCAPI void                ds_add_data_int32(ds_data_t *data, int32_t fieldnum, int32_t value);
DATASRCAPI void                ds_add_data_int64(ds_data_t *data, int32_t fieldnum, int64_t value);
DATASRCAPI void                ds_add_data_char(ds_data_t *data, int32_t fieldnum, char value);

DATASRCAPI ds_data_t          *ds_clone_data(ds_data_t *data);

#define                        ds_add_data_short(d,f,v)      ds_add_data_int16(d,f,v)
#define                        ds_add_data_int(d,f,v)        ds_add_data_int32(d,f,v)
#define                        ds_add_data_long(d,f,v)       ds_add_data_int32(d,f,v)
#define                        ds_add_data_float(d,f,v)      ds_add_data_float32(d,f,v)
#define                        ds_add_data_double(d,f,v)     ds_add_data_float64(d,f,v)

DATASRCAPI void                ds_send_data(ds_data_t *data);
DATASRCAPI void                ds_send_data_to_peer(int peer, ds_data_t *data);
DATASRCAPI void                ds_send_data_no_free(ds_data_t *data);
DATASRCAPI void                ds_send_data_to_peer_no_free(int peer, ds_data_t *data);
DATASRCAPI void                ds_send_nodata(const char *subject, unsigned short flags);
DATASRCAPI void                ds_send_nodata_to_peer(int peer, const char *subject, unsigned short flags);
DATASRCAPI void                ds_free_data(ds_data_t *data);
DATASRCAPI void                ds_send_status(const char *subject, unsigned short flags, unsigned short code, const char *msgstr);
DATASRCAPI void                ds_send_status_to_peer(int peer,const char *subject, unsigned short flags, unsigned short code, const char *msgstr);
DATASRCAPI void                ds_send_data_direct(ds_data_t *data);
DATASRCAPI void                ds_send_nodata_direct(const char *subject, unsigned short flags);
DATASRCAPI void                ds_send_status_direct(const char *subject, unsigned short flags, unsigned short code, const char *msgstr);

DATASRCAPI void                ds_send_map_to_peer(int peer, const char *subject, const char *mapped, unsigned short flags);
DATASRCAPI void                ds_send_map(const char *subject, const char *mapped, unsigned short flags);


typedef void (*ds_delay_send_cb)(void *context, ds_data_t *dsdata);

DATASRCAPI ds_delay_t         *ds_new_delay(double delay_time, char *prefix, double batch_time);
DATASRCAPI ds_delay_t         *ds_new_delay_with_callback(double delay_time, char *prefix, double batch_time, void *callback_param, ds_delay_send_cb callback_func);
DATASRCAPI void                ds_delay_data(ds_delay_t *delay, ds_data_t *dsdata);

DATASRCAPI int32_t             ds_add_record_str(ds_data_t *data, const char *field, const char *value);
DATASRCAPI int32_t             ds_add_record_int(ds_data_t *data,const  char *field, int value);
DATASRCAPI int32_t             ds_add_record_char(ds_data_t *data,const  char *field, char value);
DATASRCAPI int32_t             ds_add_record_float(ds_data_t *data,const  char *field, double value);
DATASRCAPI int32_t             ds_add_record_fmt(ds_data_t *data,const char *field, const char *fmt, ...);

DATASRCAPI ds_data_t          *ds_init_page(const char *subject, int rows, int cols, const char *type, unsigned short flags);
DATASRCAPI void                ds_add_page_row(ds_data_t *data, int row, int col, const char *str);
DATASRCAPI void                ds_add_page_field(ds_data_t *data, int32_t fieldnum, const char *value);
DATASRCAPI void                ds_add_page_field_by_name(ds_data_t *data, const char *field, const char *value);

DATASRCAPI ds_data_t          *ds_init_news(const char *subject, unsigned short flags);
DATASRCAPI void                ds_add_news_headline(ds_data_t *data, const char *headline);
DATASRCAPI void                ds_add_news_storycode(ds_data_t *data, const char *story);
DATASRCAPI void                ds_add_news_datetime(ds_data_t *data, const char *datestr);
DATASRCAPI void                ds_add_news_authstr(ds_data_t *data, const char *authstr);
DATASRCAPI void                ds_add_news_product_code(ds_data_t *data, const char *code);
DATASRCAPI void                ds_add_news_topic_code(ds_data_t *data, const char *code);
DATASRCAPI void                ds_add_news_company_code(ds_data_t *data, const char *code);
DATASRCAPI void                ds_add_news_user_code(ds_data_t *data, int codenum, const char *code);
DATASRCAPI void                ds_add_news_field(ds_data_t *dsdata, const char *fieldname, const char *value);

DATASRCAPI ds_data_t          *ds_init_container(const char *subject, const unsigned short flags);
DATASRCAPI void                ds_add_container_symbol_and_request(ds_data_t *data, const char *symbol, const int request);
DATASRCAPI void                ds_add_container_symbol(ds_data_t *data, const char *symbol);
DATASRCAPI void                ds_add_container_symbol_at_position(ds_data_t *data, int position, const char *symbol);
DATASRCAPI void                ds_remove_container_symbol(ds_data_t *data, const char *symbol);
DATASRCAPI void                ds_cleardown_container_with_prefix(ds_data_t *data, const char *prefix);

DATASRCAPI ds_data_t          *ds_init_permission(const char *subject, const char *key, unsigned short flags);
DATASRCAPI void                ds_add_permission_key(ds_data_t *data, const char *key);

DATASRCAPI void                ds_add_binary(ds_data_t *data, int32_t fieldnum, char *value, int len, char type);
DATASRCAPI void                ds_add_binary_float32(ds_data_t *data, int32_t fieldnum, float value);
DATASRCAPI void                ds_add_binary_float64(ds_data_t *data, int32_t fieldnum, double value);
DATASRCAPI void                ds_add_binary_int8(ds_data_t *data, int32_t fieldnum, int8_t value);
DATASRCAPI void                ds_add_binary_int16(ds_data_t *data, int32_t fieldnum, int16_t value);
DATASRCAPI void                ds_add_binary_int32(ds_data_t *data, int32_t fieldnum, int32_t value);
DATASRCAPI void                ds_add_binary_int64(ds_data_t *data, int32_t fieldnum, int64_t value);
DATASRCAPI void                ds_add_binary_uint8(ds_data_t *data, int32_t fieldnum, uint8_t value);
DATASRCAPI void                ds_add_binary_uint16(ds_data_t *data, int32_t fieldnum, uint16_t value);
DATASRCAPI void                ds_add_binary_uint32(ds_data_t *data, int32_t fieldnum, uint32_t value);
DATASRCAPI void                ds_add_binary_uint64(ds_data_t *data, int32_t fieldnum, uint64_t value);
DATASRCAPI void                ds_add_binary_string(ds_data_t *data, int32_t fieldnum, char *value);
DATASRCAPI void                ds_add_binary_opaque(ds_data_t *data, int32_t fieldnum, char *value, int len);
DATASRCAPI void                ds_add_binary_time(ds_data_t *data, int32_t fieldnum, time_t value);
DATASRCAPI void                ds_add_binary_time_millis(ds_data_t *data, int32_t fieldnum, int64_t value);
DATASRCAPI void                ds_add_binary_timeval(ds_data_t *data, int32_t fieldnum, struct timeval value);
DATASRCAPI void                ds_add_binary_timespec(ds_data_t *data, int32_t fieldnum, struct timespec value);

#define                        ds_add_binary_char(d,f,v)         ds_add_binary_int8(d,f,v);
#define                        ds_add_binary_short(d,f,v)        ds_add_binary_int16(d,f,v);
#define                        ds_add_binary_int(d,f,v)          ds_add_binary_int32(d,f,v);
#define                        ds_add_binary_long(d,f,v)         ds_add_binary_int32(d,f,v);
#define                        ds_add_binary_float(d,f,v)        ds_add_binary_float32(d,f,v);
#define                        ds_add_binary_double(d,f,v)       ds_add_binary_float64(d,f,v);
#define                        ds_add_binary_time_micros(d,f,v)  ds_add_binary_timeval(d,f,v);
#define                        ds_add_binary_time_nanos(d,f,v)   ds_add_binary_timespec(d,f,v);


#define NEWS_HEADLINE_FIELDNUM         0

#define NEWS_STORYCODE_FIELDNUM        1

#define NEWS_DATETIME_FIELDNUM         2

#define NEWS_AUTHSTR_FIELDNUM          5

#define NEWS_PRODUCT_CODE_FIELDNUM     100

#define NEWS_TOPIC_CODE_FIELDNUM       101

#define NEWS_COMPANY_CODE_FIELDNUM     102

#define NEWS_USER_CODE_FIELDNUM        200

#define NEWS_USER_CODE_MAX             10

#define NEWS_SIZE_FIELDNUM             300
#define NEWS_REASON_FIELDNUM           301

#define NEWS_REQ_SEARCH                1000
#define NEWS_REQ_STORYCODE             1001
#define NEWS_REQ_DATE_TO               1002
#define NEWS_REQ_DATE_FROM             1003
#define NEWS_REQ_FLAGS                 1004

#define NEWS_GENERIC_FIELDNUM          1024

/* peer */


DATASRCAPI extern int          ds_num_peers;


DATASRCAPI int                 ds_peer_details(int peer, char **name);
DATASRCAPI int                 ds_peer_host_details(int peer, char **addr);
DATASRCAPI int                 ds_peer_id(int peer);
DATASRCAPI char               *ds_peer_name(int peer);
DATASRCAPI int                 ds_peer_flags(int peer);
DATASRCAPI int                 ds_peer_local_type(int peer);
DATASRCAPI int                 ds_peer_type(int peer);
DATASRCAPI int                 ds_peer_up(int peer);
DATASRCAPI void                ds_peer_add_extra_handshake_data(int peer, const char *data);
DATASRCAPI int                 ds_peer_all_type(int flag);

DATASRCAPI void                ds_set_status_down(void);
DATASRCAPI void                ds_set_status_down_to_peer(int peer);
DATASRCAPI void                ds_set_status_msg(unsigned short msgid, const char *msgstr);
DATASRCAPI void                ds_set_status_msg_to_peer(int peer, unsigned short msgid, const char *msgstr);
DATASRCAPI void                ds_set_status_up(void);
DATASRCAPI void                ds_set_status_up_to_peer(int peer);
DATASRCAPI int                 ds_peer_by_label(const char *label);
DATASRCAPI int                 ds_peer_by_local_label(const char *label);
DATASRCAPI char               *ds_peer_label_byindex(int index);
DATASRCAPI int                 ds_peer_enabled_state(int peer);

/* pkt */

struct _ds_data
  {
     unsigned short             seq;       
     unsigned short             flags;     
     unsigned short             type;      
     char                      *subject;   
     unsigned short             count;     
     ds_field_t                *fields;    
     time_t                     time;
  };

struct _ds_field
  {
     int32_t             fieldnum;  
     int32_t             len;       
     char               *value;     
     unsigned short      flags;     
  };


/* replay */


DATASRCAPI void                ds_replay(recv_replay_t callback);
DATASRCAPI int                 ds_replay_from_file(recv_replay_t callback, char *filename);
DATASRCAPI void                ds_replay_from_log(recv_replay_t callback, ds_log_t *log);
DATASRCAPI void                ds_replay_by_time(time_t t, recv_replay_t callback);
DATASRCAPI int                 ds_replay_by_time_from_file(time_t t, recv_replay_t callback, char *filename);
DATASRCAPI void                ds_replay_by_time_from_log(time_t t, recv_replay_t callback, ds_log_t *log);
DATASRCAPI void                ds_replay_by_field(int fieldnum, char *value, recv_replay_t callback);
DATASRCAPI int                 ds_replay_by_field_from_file(int fieldnum, char *value, recv_replay_t callback, char *filename);
DATASRCAPI void                ds_replay_by_field_from_log(int fieldnum, char *value, recv_replay_t callback, ds_log_t *log);


/* udp */


typedef struct _ds_udp_event   ds_udp_event_t;

typedef int                  (*ds_udp_event_cb)(int argc, char *argv[],  int val, void *data);


DATASRCAPI ds_udp_event_t     *ds_add_udp_event(const char *command, ds_udp_event_cb cb, int val, void *data);
DATASRCAPI void                ds_del_udp_event(ds_udp_event_t *event);

DATASRCAPI void                ds_udpsignal_send(const char *message);
DATASRCAPI void                ds_udpsignal_send_argv(const char *message, char *argv[]);

/* Deprecated methods of handling udp commands */
DATASRCAPI int                 ds_udpsignal_addjob(const char *cmd,void (*fn)(int argc,char *argv[]), const char *description);
DATASRCAPI int                 ds_udpsignal_deljob(const char *cmd, void (*fn)(int argc, char *argv[]));


/* misc */

DATASRCAPI void          ds_set_productname(const char *name);

/* advmap */

DATASRCAPI char               *ds_request_object(const char *name);
DATASRCAPI char               *ds_request_object_with_flags(const char *name,int flags);
DATASRCAPI int                 ds_request_objects(int count, char **obs, char ***services);
DATASRCAPI int                 ds_request_objects_with_flags(int count, char **obs, int flags, char ***services);
DATASRCAPI void                ds_discard_object(const char *name);
DATASRCAPI void                ds_discard_objects(int count, char **obs);
DATASRCAPI char *              ds_get_service(const char *name);
DATASRCAPI int                 ds_send_contribution(ds_data_t *dsdata);
DATASRCAPI int                 ds_get_num_services(void);
DATASRCAPI int                 ds_get_service_by_index(int index, char **name_ptr);
DATASRCAPI int                 ds_object_available(const char *name);
DATASRCAPI int                 ds_object_can_contrib(const char *name);
DATASRCAPI void                ds_purge_object(const char *name);
DATASRCAPI int                 ds_required_services_status(char *buf, size_t buflen);
DATASRCAPI int                 ds_get_service_type(const char *servicename);
DATASRCAPI int                 ds_get_is_contrib_source(const char *name, int peer);

DATASRCAPI int                 ds_set_request_hint(const char *name, int num,  char **hints);
DATASRCAPI char              **ds_get_request_hints(const char *name, int *ret);
DATASRCAPI void                ds_set_object_data(const char *name, void *data);
DATASRCAPI void               *ds_get_object_data(const char *name);

/* signature */
DATASRCAPI int                ds_signature_check(char *key_id, char *token);
DATASRCAPI int                ds_signature_verify_username(char *expected_username, char *token);

#define DS_SIGNATURE_OK                  0

#define DS_SIGNATURE_INVALID_TOKEN       1

#define DS_SIGNATURE_UNKNOWN_KEYID       2

#define DS_SIGNATURE_ALREADY_USED        3
#endif /* __DATASRC_H__ */

#ifdef __cplusplus
}  /* extern "C" */
#endif