jabberd.h

Go to the documentation of this file.

/*
 * Copyrights
 * 
 * Portions created by or assigned to Jabber.com, Inc. are 
 * Copyright (c) 1999-2002 Jabber.com, Inc.  All Rights Reserved.  Contact
 * information for Jabber.com, Inc. is available at http://www.jabber.com/.
 *
 * Portions Copyright (c) 1998-1999 Jeremie Miller.
 *
 * Portions Copyright (c) 2006-2007 Matthias Wimmer
 *
 * This file is part of jabberd14.
 *
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * License, or (at your option) any later version.
 *
 * This software is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this software; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
 * 02110-1301, USA.
 *
 */

#ifdef HAVE_CONFIG_H
#   include <config.h>
#endif

#include <jabberdlib.h>
#include <gnutls/gnutls.h>
#include <gnutls/x509.h>

#ifdef HAVE_GNUTLS_EXTRA
#  include <gnutls/extra.h>
#  include <gnutls/openpgp.h>
#endif

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;

typedef void (*register_notify)(instance i, const char *destination, int is_register, void *arg);

typedef struct register_notifier_struct {
    register_notify callback;   
    void *arg;                  
    struct register_notifier_struct *next;      
} *register_notifier, _register_notifier;

struct instance_struct
{
    char *id;   
    pool p;
    xmlnode x;  
    ptype type; 
    handel hds; 
    register_notifier routing_update_callbacks; 
    std::map<std::string, void*>* module_init_funcs;    
};

typedef result (*cfhandler)(instance id, xmlnode x, void *arg);

typedef result (*beathandler)(void *arg);

/*** public functions for base modules ***/
void register_config(pool p, char *node, cfhandler f, void *arg); /* register a function to handle that node in the config file */
void register_instance(instance i, char const* host); /* associate an id with a hostname for that packet type */
void unregister_instance(instance i, char const* host); /* disassociate an id with a hostname for that packet type */
void register_routing_update_callback(instance i, register_notify f, void *arg); 
void register_phandler(instance id, order o, phandler f, void *arg); /* register a function to handle delivery for this instance */
void register_beat(int freq, beathandler f, void *arg); /* register the function to be called from the heartbeat, freq is how often, <= 0 is ignored */
typedef void(*shutdown_func)(void*arg);
void register_shutdown(shutdown_func f,void *arg); /* register to be notified when the server is shutting down */

dpacket dpacket_new(xmlnode x); /* create a new delivery packet from source xml */
dpacket dpacket_copy(dpacket p); /* copy a packet (and it's flags) */
void deliver(dpacket p, instance i); /* deliver packet from sending instance */
void deliver_fail(dpacket p, const char *err); /* bounce a packet intelligently */
void deliver_instance(instance i, dpacket p); /* deliver packet TO the instance, if the result != r_DONE, you have to handle the packet! */
instance deliver_hostcheck(char const* host); /* util that returns the instance handling this hostname for normal packets */
bool deliver_is_uplink(instance i); // checks if an instance is configured to be the uplink
std::set<Glib::ustring> deliver_routed_hosts(ptype type, instance i);

/*** global logging/signal symbols ***/
#define LOGT_LEGACY 1
#define LOGT_DELIVER 2
#define LOGT_REGISTER 4
#define LOGT_STATUS 8
#define LOGT_EVENT 16
#define LOGT_CONFIG 32
#define LOGT_DYNAMIC 64
#define LOGT_IO 128
#define LOGT_INIT 256
#define LOGT_EXECFLOW 512
#define LOGT_CLEANUP 1024
#define LOGT_STRANGE 2048
#define LOGT_XML 4096
#define LOGT_THREAD 8192
#define LOGT_STORAGE 16384
#define LOGT_AUTH 32768
#define LOGT_SESSION 65536
#define LOGT_ROSTER 131072
#define LOGT_BYTES 262144

int log_get_facility(char const* facility);
int log_get_level(char const* level);
#define MAX_LOG_SIZE 1024
extern int debug_flag;
inline int get_debug_flag(void);
void set_debug_flag(int v);
void set_cmdline_debug_flag(int v);
void set_debug_facility(int facility);
#ifdef __CYGWIN__
#define log_debug if(get_debug_flag()&1) debug_log
#define log_debug2 if(get_debug_flag()) debug_log2
#else
#define log_debug if(debug_flag&1) debug_log
#define log_debug2 if(debug_flag) debug_log2
#endif
void debug_log(char const* zone, char const* msgfmt, ...);
void debug_log2(char const* zone, int type, char const* msgfmt, ...);
void log_notice(char const* host, char const* msgfmt, ...);
void log_warn(char const* host, char const* msgfmt, ...);
void log_alert(char const* host, char const* msgfmt, ...);
#define log_error log_alert
void logger(char const* type, char const* host, char const* message); /* actually creates and delivers the log message */
void log_record(char const* id, char const* type, char const* action, char const* msgfmt, ...); /* for generic logging support, like log_record("jer@jabber.org","session","end","...") */
void log_generic(char const* logtype, char const* id, char const* type, char const* action, char const* msgfmt, ...);

/*** xdb utilities ***/

typedef struct xdbcache_struct {
    instance i;
    int id;
    const char *ns;
    int set; 
    char const* act; 
    char const* match; 
    char const* matchpath; 
    xht namespaces; 
    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, const char *ns); 
int xdb_act(xdbcache xc, jid owner, const char *ns, char *act, char *match, xmlnode data); 
int xdb_act_path(xdbcache xc, jid owner, const char *ns, char const *act, char const* matchpath, xht namespaces, xmlnode data); 
int xdb_set(xdbcache xc, jid owner, const char *ns, xmlnode data); 
/* Error messages */
#define SERROR_NAMESPACE "<stream:error><invalid-namespace xmlns='urn:ietf:params:xml:ns:xmpp-streams'/><text xmlns='urn:ietf:params:xml:ns:xmpp-streams' xml:lang='en'>Invalid namespace specified.</text></stream:error>"
#define SERROR_INVALIDHOST "<stream:error><invalid-from xmlns='urn:ietf:params:xml:ns:xmpp-streams'/><text xmlns='urn:ietf:params:xml:ns:xmpp-streams' xml:lang='en'>Invalid hostname used.</text></stream:error>"

/* ------------------------------------
 * Managed Thread Queue (MTQ) utilities 
 * ------------------------------------*/

/* default waiting threads */
#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); 
/* MIO - Managed I/O - TCP functions */

typedef enum { queue_XMLNODE, queue_CDATA } mio_queue_type;
typedef struct mio_wb_q_st
{
    pth_message_t head;  /* for compatibility */
    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;

/* the mio data type */
typedef enum { state_ACTIVE, state_CLOSE } mio_state;
typedef enum { type_LISTEN, type_NORMAL, type_NUL, type_HTTP } mio_type;

/* standard i/o callback function definition */
struct mio_st;
typedef void (*mio_std_cb)(mio_st* m, int state, void *arg, xmlnode x, char *buffer, int bufsz);

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;                       
    mio_std_cb cb;                      
    struct mio_handlers_st *mh;         
    xstream    xs;   /* XXX kill me, I suck */
    XML_Parser parser;                  
    xmlnode    stacknode;               
    void       *ssl;                    
    struct {
        int     root:1;                 
        int     rated:1;                
        int     reset_stream:1;         
        int     recall_read_when_readable:1;    
        int     recall_read_when_writeable:1;   
        int     recall_write_when_readable:1;   
        int     recall_write_when_writeable:1;  
        int     recall_handshake_when_readable:1; 
        int     recall_handshake_when_writeable:1; 
    } flags;

    struct karma k;                     
    jlimit rate;                        
    char *peer_ip;                      
    uint16_t peer_port;                 
    char *our_ip;                       
    uint16_t our_port;                  
    char *connect_errmsg;               
    char *authed_other_side;            
    xmppd::ns_decl_list* out_ns;        
    xmppd::ns_decl_list* in_root;       
    xmppd::ns_decl_list* in_stanza;     
    const char *root_lang;              
} *mio, _mio;

typedef struct mio_main_st {
    pool p;             
    mio master__list;   
    pth_t t;            
    int shutdown;       
    int zzz[2];         
    int zzz_active;     
    struct karma *k;    
    int rate_t, rate_p; 
    char *bounce_uri;   
} _ios,*ios;

/* MIO SOCKET HANDLERS */
typedef ssize_t (*mio_read_func)        (mio m, void* buf, size_t count);
typedef ssize_t (*mio_write_func)       (mio m, void const* buf, size_t count); 
typedef void    (*mio_parser_func)      (mio m, void const* buf, size_t bufsz);
typedef int     (*mio_accepted_func)    (mio m);
typedef int     (*mio_handshake_func)   (mio m);
typedef void    (*mio_close_func)       (mio m, bool close_read);

typedef struct mio_handlers_st {
    pool  p;
    mio_read_func       read;
    mio_write_func      write;
    mio_accepted_func   accepted;
    mio_parser_func     parser;
    mio_handshake_func  handshake;
    mio_close_func      close;
} _mio_handlers, *mio_handlers; 

/* standard read/write/accept/connect functions */
ssize_t _mio_raw_read(mio m, void *buf, size_t count);
ssize_t _mio_raw_write(mio m, void *buf, size_t count);
void _mio_raw_parser(mio m, const void *buf, size_t bufsz);
#define MIO_RAW_READ     (mio_read_func)&_mio_raw_read
#define MIO_RAW_WRITE    (mio_write_func)&_mio_raw_write
#define MIO_RAW_ACCEPTED (mio_accepted_func)NULL
#define MIO_RAW_PARSER   (mio_parser_func)&_mio_raw_parser

void mio_xml_reset(mio m);
int  mio_xml_starttls(mio m, int originator, const char *identity);
void _mio_xml_parser(mio m, const void *buf, size_t bufsz);
#define MIO_XML_PARSER  (mio_parser_func)&_mio_xml_parser

/* function helpers */
#define MIO_LISTEN_RAW mio_handlers_new(NULL, NULL, NULL)
#define MIO_CONNECT_RAW mio_handlers_new(NULL, NULL, NULL)
#define MIO_LISTEN_XML mio_handlers_new(NULL, NULL, MIO_XML_PARSER)
#define MIO_CONNECT_XML mio_handlers_new(NULL, NULL, MIO_XML_PARSER)

/* TLS functions */
void    mio_ssl_init     (xmlnode x);
bool    mio_tls_early_init();
int     mio_ssl_starttls (mio m, int originator, const char* identity);
int     mio_ssl_starttls_possible (mio m, const char* identity);
int     mio_ssl_verify(mio m, const char *id_on_xmppAddr);
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_accepted(mio m);
void    mio_tls_get_characteristics(mio m, char* buffer, size_t len);
void    mio_tls_get_certtype(mio m, char* buffer, size_t len);
void    mio_tls_get_compression(mio m, char* buffer, size_t len);
#define MIO_SSL_READ     _mio_ssl_read
#define MIO_SSL_WRITE    _mio_ssl_write
#define MIO_SSL_ACCEPTED _mio_ssl_accepted

int     mio_is_encrypted(mio m);

/* MIO handlers helper functions */
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);

/* callback state flags */
#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

/* Initializes the MIO subsystem */
void mio_init(void);

/* Stops the MIO system */
void mio_stop(void);

/* Create a new mio object from a file descriptor */
mio mio_new(int fd, mio_std_cb cb, void *cb_arg, mio_handlers mh);

/* Reset the callback and argument for an mio object */
void mio_reset(mio m, mio_std_cb cb, void *arg);

/* Request the mio socket be closed */
void mio_close(mio m);

/* Writes an xmlnode to the socket */
void mio_write(mio m, xmlnode stanza, char const* buffer, int len);

/* write the root element to a mio stream */
void mio_write_root(mio m, xmlnode root, int stream_type);

/* Sets the karma values for a socket */
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);

/* Sets connection based rate limits */
void mio_rate(mio m, int rate_time, int max_points);

/* Pops the next xmlnode from the queue, or NULL if no more nodes */
xmlnode mio_cleanup(mio m);

/* Connects to an ip */
void mio_connect(char *host, int port, mio_std_cb cb, void *cb_arg, int timeout, mio_handlers mh);

/* Starts listening on a port/ip, returns NULL if failed to listen */
mio mio_listen(int port, char const* sourceip, mio_std_cb cb, void *cb_arg, mio_handlers mh);

int _mio_write_dump(mio m);

/* some nice api utilities */
#define mio_pool(m) (m->p)
#define mio_ip(m) (m ? m->peer_ip : NULL)
#define mio_connect_errmsg(m) (m->connect_errmsg)

/*-----------------
 * Access controll 
 *-----------------*/

int acl_check_access(xdbcache xdb, const char *function, const jid user);
jid acl_get_users(xdbcache xdb, const char *function);

namespace xmppd {

    /* ******************** Logging ******************** */

    /* forward declaration */
    class logging;

    enum loglevel {
        notice,
        warn,
        error,
        alert
    };

    class logmessage : public std::ostringstream {
        public:
            logmessage(logging& log_entity, loglevel level);

            ~logmessage();

            std::ostream& operator<<(const char* text);

            std::ostream& operator<<(const std::string& text);

            logmessage(const logmessage& orig);

        private:
            logging& log_entity;

            loglevel level;
    };

    class logging {
        public:
            logging(Glib::ustring ident);

            ~logging();

            logmessage level(loglevel level_to_use);
        private:
            void write(loglevel level_to_use, Glib::ustring log_message);

            friend class logmessage;

            Glib::ustring identity;
    };

/*--------------------------
 * OOP-instances base class
 *--------------------------*/

    class instance_base {
        public:
            instance_base(instance i, xmlnode x);

        protected:
            virtual result on_packet(dpacket dp);

            virtual result on_stanza_packet(dpacket dp);

            virtual result on_xdb_packet(dpacket dp);

            virtual result on_log_packet(dpacket dp);

            virtual result on_route_packet(dpacket dp);

            virtual result on_message_stanza(jpacket p);

            virtual result on_presence_stanza(jpacket p);

            virtual result on_iq_stanza(jpacket p);

            virtual result on_subscription_stanza(jpacket p);

            virtual void on_heartbeat();

            void set_heartbeat_interval(int interval);

            void deliver(dpacket p);

            void deliver(xmlnode x);

            void deliver_fail(dpacket p, const std::string& reason_text);

            void bounce_stanza(xmlnode x, xterror xterr);

            std::string get_instance_id();

            logmessage log(loglevel level);

            xmlnode get_instance_config();

        private:
            instance i;

            pointer<logging> logger;

            instance_base(instance_base& ref);

            result beathandler_wrapper();

            static result phandler_helper(instance id, dpacket p, void* arg);

            static result beathandler_helper(void* arg);

            int current_heartbeat_frequency;

            int requested_heartbeat_frequency;
    };
}

---