#ifndef FD_SETSIZE
#define FD_SETSIZE 11000
#endif
#include "lib/lib.h"
#include <pth.h>
#ifdef HAVE_SSL
#include <ssl.h>
#endif
#define VERSION "1.4.3.1"
typedef enum { p_NONE, p_NORM, p_XDB, p_LOG, p_ROUTE } ptype;
typedef enum { o_PRECOND, o_COND, o_PREDELIVER, o_DELIVER } order;
typedef enum { r_UNREG, r_NONE, r_PASS, r_LAST, r_ERR, r_DONE } result;
typedef struct instance_struct *instance, _instance;
typedef struct dpacket_struct
{
char *host;
jid id;
ptype type;
pool p;
xmlnode x;
} *dpacket, _dpacket;
typedef result (*phandler)(instance id, dpacket p, void *arg);
typedef struct handel_struct
{
pool p;
phandler f;
void *arg;
order o;
struct handel_struct *next;
} *handel, _handel;
struct instance_struct
{
char *id;
pool p;
xmlnode x;
ptype type;
handel hds;
};
typedef result (*cfhandler)(instance id, xmlnode x, void *arg);
typedef result (*beathandler)(void *arg);
void register_config(char *node, cfhandler f, void *arg);
void register_instance(instance i, char *host);
void unregister_instance(instance i, char *host);
void register_phandler(instance id, order o, phandler f, void *arg);
void register_beat(int freq, beathandler f, void *arg);
typedef void(*shutdown_func)(void*arg);
void register_shutdown(shutdown_func f,void *arg);
dpacket dpacket_new(xmlnode x);
dpacket dpacket_copy(dpacket p);
void deliver(dpacket p, instance i);
void deliver_fail(dpacket p, char *err);
void deliver_instance(instance i, dpacket p);
instance deliver_hostcheck(char *host);
#define MAX_LOG_SIZE 1024
extern int debug_flag;
int get_debug_flag(void);
void set_debug_flag(int v);
extern int syslog_flag;
int get_syslog_flag(void);
void set_syslog_flag(int v);
#define log_syslog if(get_syslog_flag()) syslog
#ifdef __CYGWIN__
#define log_debug if(get_debug_flag()) debug_log
#else
#define log_debug if(debug_flag) debug_log
#endif
void debug_log(char *zone, const char *msgfmt, ...);
void log_notice(char *host, const char *msgfmt, ...);
void log_warn(char *host, const char *msgfmt, ...);
void log_alert(char *host, const char *msgfmt, ...);
#define log_error log_alert
void logger(char *type, char *host, char *message, int type_priority);
void log_record(char *id, char *type, char *action, const char *msgfmt, ...);
extern int jabberd__signalflag;
void jabberd_signal(void);
typedef struct xdbcache_struct
{
instance i;
int id;
char *ns;
int set;
char *act;
char *match;
xmlnode data;
jid owner;
int sent;
int preblock;
pth_cond_t cond;
pth_mutex_t mutex;
struct xdbcache_struct *prev;
struct xdbcache_struct *next;
} *xdbcache, _xdbcache;
xdbcache xdb_cache(instance i);
xmlnode xdb_get(xdbcache xc, jid owner, char *ns);
int xdb_act(xdbcache xc, jid owner, char *ns, char *act, char *match, xmlnode data);
int xdb_set(xdbcache xc, jid owner, char *ns, xmlnode data);
#define SERROR_NAMESPACE "<stream:error>Invalid namespace specified.</stream:error>"
#define SERROR_INVALIDHOST "<stream:error>Invalid hostname used.</stream:error>"
#define MTQ_THREADS 10
typedef void (*mtq_callback)(void *arg);
typedef struct mtqueue_struct
{
struct mth_struct *t;
pth_msgport_t mp;
int routed;
} *mtq, _mtq;
typedef struct mth_struct
{
mtq q;
pth_msgport_t mp;
pool p;
pth_t id;
int busy;
} *mth, _mth;
mtq mtq_new(pool p);
void mtq_send(mtq q, pool p, mtq_callback f, void *arg);
typedef enum { queue_XMLNODE, queue_CDATA } mio_queue_type;
typedef struct mio_wb_q_st
{
pth_message_t head;
pool p;
mio_queue_type type;
xmlnode x;
void *data;
void *cur;
int len;
struct mio_wb_q_st *next;
} _mio_wbq,*mio_wbq;
struct mio_handlers_st;
typedef enum { state_ACTIVE, state_CLOSE } mio_state;
typedef enum { type_LISTEN, type_NORMAL, type_NUL, type_HTTP } mio_type;
typedef struct mio_st
{
pool p;
int fd;
mio_type type;
mio_state state;
mio_wbq queue;
mio_wbq tail;
struct mio_st *prev,*next;
void *cb_arg;
void *cb;
struct mio_handlers_st *mh;
xstream xs;
XML_Parser parser;
int root;
xmlnode stacknode;
void *ssl;
long max_stanza_bytes;
long max_message_bytes;
int message;
long bytes_read;
struct karma k;
int rated;
jlimit rate;
char *ip;
} *mio, _mio;
typedef ssize_t (*mio_read_func) (mio m, void* buf, size_t count);
typedef ssize_t (*mio_write_func) (mio m, const void* buf, size_t count);
typedef void (*mio_parser_func) (mio m, const void* buf, size_t bufsz);
typedef int (*mio_accept_func) (mio m, struct sockaddr* serv_addr, socklen_t* addrlen);
typedef int (*mio_connect_func) (mio m, struct sockaddr* serv_addr, socklen_t addrlen);
typedef struct mio_handlers_st
{
pool p;
mio_read_func read;
mio_write_func write;
mio_accept_func accept;
mio_parser_func parser;
} _mio_handlers, *mio_handlers;
#define MIO_READ_FUNC pth_read
#define MIO_WRITE_FUNC pth_write
#define MIO_ACCEPT_FUNC pth_accept
#define MIO_CONNECT_FUNC pth_connect
ssize_t _mio_raw_read(mio m, void *buf, size_t count);
ssize_t _mio_raw_write(mio m, void *buf, size_t count);
int _mio_raw_accept(mio m, struct sockaddr* serv_addr, socklen_t* addrlen);
void _mio_raw_parser(mio m, const void *buf, size_t bufsz);
int _mio_raw_connect(mio m, struct sockaddr* serv_addr, socklen_t addrlen);
#define MIO_RAW_READ (mio_read_func)&_mio_raw_read
#define MIO_RAW_WRITE (mio_write_func)&_mio_raw_write
#define MIO_RAW_ACCEPT (mio_accept_func)&_mio_raw_accept
#define MIO_RAW_CONNECT (mio_connect_func)&_mio_raw_connect
#define MIO_RAW_PARSER (mio_parser_func)&_mio_raw_parser
void _mio_xml_parser(mio m, const void *buf, size_t bufsz);
#define MIO_XML_PARSER (mio_parser_func)&_mio_xml_parser
#define MIO_LISTEN_RAW NULL, mio_handlers_new(NULL, NULL, NULL)
#define MIO_CONNECT_RAW NULL, mio_handlers_new(NULL, NULL, NULL)
#define MIO_LISTEN_XML NULL, mio_handlers_new(NULL, NULL, MIO_XML_PARSER)
#define MIO_CONNECT_XML NULL, mio_handlers_new(NULL, NULL, MIO_XML_PARSER)
void mio_ssl_init (xmlnode x);
void _mio_ssl_cleanup (void *arg);
ssize_t _mio_ssl_read (mio m, void *buf, size_t count);
ssize_t _mio_ssl_write (mio m, const void* buf, size_t count);
int _mio_ssl_accept (mio m, struct sockaddr* serv_addr, socklen_t* addrlen);
int _mio_ssl_connect (mio m, struct sockaddr* serv_addr, socklen_t addrlen);
#define MIO_SSL_READ _mio_ssl_read
#define MIO_SSL_WRITE _mio_ssl_write
#define MIO_SSL_ACCEPT _mio_ssl_accept
#define MIO_SSL_CONNECT _mio_ssl_connect
mio_handlers mio_handlers_new(mio_read_func rf, mio_write_func wf, mio_parser_func pf);
void mio_handlers_free(mio_handlers mh);
void mio_set_handlers(mio m, mio_handlers mh);
#define MIO_NEW 0
#define MIO_BUFFER 1
#define MIO_XML_ROOT 2
#define MIO_XML_NODE 3
#define MIO_CLOSED 4
#define MIO_ERROR 5
typedef void (*mio_std_cb)(mio m, int state, void *arg);
typedef void (*mio_xml_cb)(mio m, int state, void *arg, xmlnode x);
typedef void (*mio_raw_cb)(mio m, int state, void *arg, char *buffer,int bufsz);
typedef void (*mio_ssl_cb)(mio m, int state, void *arg, char *buffer,int bufsz);
void mio_init(void);
void mio_stop(void);
mio mio_new(int fd, void *cb, void *cb_arg, mio_handlers mh);
mio mio_reset(mio m, void *cb, void *arg);
void mio_close(mio m);
void mio_write(mio m,xmlnode x, char *buffer, int len);
void mio_karma(mio m, int val, int max, int inc, int dec, int penalty, int restore);
void mio_karma2(mio m, struct karma *k);
void mio_rate(mio m, int rate_time, int max_points);
void mio_stanza_limits(mio m, long max_stanza, long max_msg);
xmlnode mio_cleanup(mio m);
void mio_connect(char *host, int port, void *cb, void *cb_arg, int timeout, mio_connect_func f, mio_handlers mh);
mio mio_listen(int port, char *sourceip, void *cb, void *cb_arg, mio_accept_func f, mio_handlers mh);
#define mio_pool(m) (m->p)
#define mio_ip(m) (m->ip)