/*

 *  This program 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 program 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 program; if not, write to the Free Software

 *  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

 *

 *  Jabber

 *  Copyright (C) 1998-1999 The Jabber Team http://jabber.org/

 */

#include <string.h>

#include <stdlib.h>

#include <sys/types.h>

#include <stdio.h>

#include <setjmp.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <errno.h>

#include <signal.h>

#include <stdarg.h>

#include <syslog.h>

#include <strings.h>

#include <unistd.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <netdb.h>

#include <arpa/inet.h>

#include <ctype.h>

#include <time.h>

#include "libxode.h"

#include "../connwrap/connwrap.h"

#ifndef INCL_JABBER_H

#define INCL_JABBER_H

#ifdef __cplusplus

extern "C" {

#endif

/* --------------------------------------------------------- */

/*                                                           */

/* JID structures & constants                                */

/*                                                           */

/* --------------------------------------------------------- */

#define JID_RESOURCE 1

#define JID_USER     2

#define JID_SERVER   4

typedef struct jid_struct

{

    pool               p;

    char*              resource;

    char*              user;

    char*              server;

    char*              full;

    struct jid_struct *next; /* for lists of jids */

} *jid;

jid     jid_new(pool p, char *idstr);          /* Creates a jabber id from the idstr */

void    jid_set(jid id, char *str, int item);  /* Individually sets jid components */

char*   jid_full(jid id);                      /* Builds a string type=user/resource@server from the jid data */

int     jid_cmp(jid a, jid b);                 /* Compares two jid's, returns 0 for perfect match */

int     jid_cmpx(jid a, jid b, int parts);     /* Compares just the parts specified as JID_|JID_ */

jid     jid_append(jid a, jid b);              /* Appending b to a (list), no dups */

xmlnode jid_xres(jid id);                      /* Returns xmlnode representation of the resource?query=string */

xmlnode jid_nodescan(jid id, xmlnode x);       /* Scans the children of the node for a matching jid attribute */

jid     jid_user(jid a);                       /* returns the same jid but just of the user@host part */

/* --------------------------------------------------------- */

/*                                                           */

/* JPacket structures & constants                            */

/*                                                           */

/* --------------------------------------------------------- */

#define JPACKET_UNKNOWN   0x00

#define JPACKET_MESSAGE   0x01

#define JPACKET_PRESENCE  0x02

#define JPACKET_IQ        0x04

#define JPACKET_S10N      0x08

#define JPACKET__UNKNOWN      0

#define JPACKET__NONE         1

#define JPACKET__ERROR        2

#define JPACKET__CHAT         3

#define JPACKET__GROUPCHAT    4

#define JPACKET__GET          5

#define JPACKET__SET          6

#define JPACKET__RESULT       7

#define JPACKET__SUBSCRIBE    8

#define JPACKET__SUBSCRIBED   9

#define JPACKET__UNSUBSCRIBE  10

#define JPACKET__UNSUBSCRIBED 11

#define JPACKET__AVAILABLE    12

#define JPACKET__UNAVAILABLE  13

#define JPACKET__PROBE        14

#define JPACKET__HEADLINE     15

#define JPACKET__INVISIBLE    16

typedef struct jpacket_struct

{

    unsigned char type;             /**< stanza type (JPACKET_*) */

    int           subtype;          /**< subtype of a stanza */

    int           flag;             /**< used by the session manager to flag messages, that are read from offline storage */

    void*         aux1;             /**< pointer to data passed around with a jpacket, multiple use inside jsm */

    xmlnode       x;                /**< xmlnode containing the stanza inside the jpacket */

    jid           to;               /**< destination of the stanza */

    jid           from;             /**< source address for the stanza */

    char*         iqns;             /**< pointer to the namespace inside an IQ stanza */

    xmlnode       iq;               /**< "content" of an iq stanza, pointer to the element in its own namespace */

    pool          p;                /**< memory pool used for this stanza */

} *jpacket, _jpacket;

jpacket jpacket_new(xmlnode x);     /* Creates a jabber packet from the xmlnode */

jpacket jpacket_reset(jpacket p);   /* Resets the jpacket values based on the xmlnode */

int     jpacket_subtype(jpacket p); /* Returns the subtype value (looks at xmlnode for it) */

/* --------------------------------------------------------- */

/*                                                           */

/* Presence Proxy DB structures & constants                  */

/*                                                           */

/* --------------------------------------------------------- */

typedef struct ppdb_struct

{

    jid     id;                /* entry data */

    int     pri;

    xmlnode x;

    struct ppdb_struct* user;  /* linked list for user@server */

    pool                p;     /* db-level data */

    struct ppdb_struct* next;

} _ppdb, *ppdb;

ppdb    ppdb_insert(ppdb db, jid id, xmlnode x); /* Inserts presence into the proxy */

xmlnode ppdb_primary(ppdb db, jid id);           /* Fetches the matching primary presence for the id */

void    ppdb_free(ppdb db);                      /* Frees the db and all entries */

xmlnode ppdb_get(ppdb db, jid id);               /* Called successively to return each presence xmlnode */

						 /*   for the id and children, returns NULL at the end */

/* --------------------------------------------------------- */

/*                                                           */

/* Simple Jabber Rate limit functions                        */

/*                                                           */

/* --------------------------------------------------------- */

typedef struct jlimit_struct

{

    char *key;

    int start;

    int points;

    int maxt, maxp;

    pool p;

} *jlimit, _jlimit;

jlimit jlimit_new(int maxt, int maxp);

void jlimit_free(jlimit r);

int jlimit_check(jlimit r, char *key, int points);

/* --------------------------------------------------------- */

/*                                                           */

/* Error structures & constants                              */

/*                                                           */

/* --------------------------------------------------------- */

typedef struct terror_struct

{

    int  code;

    char msg[64];

} terror;

#define TERROR_BAD           (terror){400,"Bad Request"}

#define TERROR_AUTH          (terror){401,"Unauthorized"}

#define TERROR_PAY           (terror){402,"Payment Required"}

#define TERROR_FORBIDDEN     (terror){403,"Forbidden"}

#define TERROR_NOTFOUND      (terror){404,"Not Found"}

#define TERROR_NOTALLOWED    (terror){405,"Not Allowed"}

#define TERROR_NOTACCEPTABLE (terror){406,"Not Acceptable"}

#define TERROR_REGISTER      (terror){407,"Registration Required"}

#define TERROR_REQTIMEOUT    (terror){408,"Request Timeout"}

#define TERROR_CONFLICT      (terror){409,"Conflict"}

#define TERROR_INTERNAL   (terror){500,"Internal Server Error"}

#define TERROR_NOTIMPL    (terror){501,"Not Implemented"}

#define TERROR_EXTERNAL   (terror){502,"Remote Server Error"}

#define TERROR_UNAVAIL    (terror){503,"Service Unavailable"}

#define TERROR_EXTTIMEOUT (terror){504,"Remote Server Timeout"}

#define TERROR_DISCONNECTED (terror){510,"Disconnected"}

/* we define this to signal that we support xterror */

#define HAS_XTERROR

typedef struct xterror_struct

{

    int  code;

    char msg[256];

    char type[9];

    char condition[64];

} xterror;

#define XTERROR_BAD		(xterror){400,"Bad Request","modify","bad-request"}

#define XTERROR_CONFLICT	(xterror){409,"Conflict","cancel","conflict"}

#define XTERROR_NOTIMPL		(xterror){501,"Not Implemented","cancel","feature-not-implemented"}

#define XTERROR_FORBIDDEN	(xterror){403,"Forbidden","auth","forbidden"}

#define XTERROR_GONE		(xterror){302,"Gone","modify","gone"}

#define XTERROR_INTERNAL	(xterror){500,"Internal Server Error","wait","internal-server-error"}

#define XTERROR_NOTFOUND	(xterror){404,"Not Found","cancel","item-not-found"}

#define XTERROR_JIDMALFORMED	(xterror){400,"Bad Request","modify","jid-malformed"}

#define XTERROR_NOTACCEPTABLE	(xterror){406,"Not Acceptable","modify","not-acceptable"}

#define XTERROR_NOTALLOWED	(xterror){405,"Not Allowed","cancel","not-allowed"}

#define XTERROR_AUTH		(xterror){401,"Unauthorized","auth","not-authorized"}

#define XTERROR_PAY		(xterror){402,"Payment Required","auth","payment-required"}

#define XTERROR_RECIPIENTUNAVAIL (xterror){404,"Receipient Is Unavailable","wait","recipient-unavailable"}

#define XTERROR_REDIRECT	(xterror){302,"Redirect","modify","redirect"}

#define XTERROR_REGISTER	(xterror){407,"Registration Required","auth","registration-required"}

#define XTERROR_REMOTENOTFOUND	(xterror){404,"Remote Server Not Found","cancel","remote-server-not-found"}

#define XTERROR_REMOTETIMEOUT	(xterror){504,"Remote Server Timeout","wait","remote-server-timeout"}

#define XTERROR_RESCONSTRAINT	(xterror){500,"Resource Constraint","wait","resource-constraint"}

#define XTERROR_UNAVAIL		(xterror){503,"Service Unavailable","cancel","service-unavailable"}

#define XTERROR_SUBSCRIPTIONREQ	(xterror){407,"Subscription Required","auth","subscription-required"}

#define XTERROR_UNDEF_CANCEL	(xterror){500,NULL,"cancel","undefined-condition"}

#define XTERROR_UNDEF_CONTINUE	(xterror){500,NULL,"continue","undefined-condition"}

#define XTERROR_UNDEF_MODIFY	(xterror){500,NULL,"modify","undefined-condition"}

#define XTERROR_UNDEF_AUTH	(xterror){500,NULL,"auth","undefined-condition"}

#define XTERROR_UNDEF_WAIT	(xterror){500,NULL,"wait","undefined-condition"}

#define XTERROR_UNEXPECTED	(xterror){400,"Unexpected Request","wait","unexpected-request"}

#define XTERROR_REQTIMEOUT	(xterror){408,"Request Timeout","wait","remote-server-timeout"}

#define XTERROR_EXTERNAL	(xterror){502,"Remote Server Error","wait","service-unavailable"}

#define XTERROR_EXTTIMEOUT	(xterror){504,"Remote Server Timeout","wait","remote-server-timeout"}

#define XTERROR_DISCONNECTED	(xterror){510,"Disconnected","cancel","service-unavailable"}

/* --------------------------------------------------------- */

/*                                                           */

/* Namespace constants                                       */

/*                                                           */

/* --------------------------------------------------------- */

#define NSCHECK(x,n) (j_strcmp(xmlnode_get_attrib(x,"xmlns"),n) == 0)

#define NS_CLIENT    "jabber:client"

#define NS_SERVER    "jabber:server"

#define NS_DIALBACK  "jabber:server:dialback"

#define NS_AUTH      "jabber:iq:auth"

#define NS_AUTH_CRYPT "jabber:iq:auth:crypt"

#define NS_REGISTER  "jabber:iq:register"

#define NS_ROSTER    "jabber:iq:roster"

#define NS_OFFLINE   "jabber:x:offline"

#define NS_AGENT     "jabber:iq:agent"

#define NS_AGENTS    "jabber:iq:agents"

#define NS_DELAY     "jabber:x:delay"

#define NS_VERSION   "jabber:iq:version"

#define NS_TIME      "jabber:iq:time"

#define NS_VCARD     "vcard-temp"

#define NS_PRIVATE   "jabber:iq:private"

#define NS_SEARCH    "jabber:iq:search"

#define NS_OOB       "jabber:iq:oob"

#define NS_XOOB      "jabber:x:oob"

#define NS_ADMIN     "jabber:iq:admin"

#define NS_FILTER    "jabber:iq:filter"

#define NS_AUTH_0K   "jabber:iq:auth:0k"

#define NS_BROWSE    "jabber:iq:browse"

#define NS_EVENT     "jabber:x:event"

#define NS_CONFERENCE "jabber:iq:conference"

#define NS_SIGNED    "jabber:x:signed"

#define NS_ENCRYPTED "jabber:x:encrypted"

#define NS_GATEWAY   "jabber:iq:gateway"

#define NS_LAST      "jabber:iq:last"

#define NS_ENVELOPE  "jabber:x:envelope"

#define NS_EXPIRE    "jabber:x:expire"

#define NS_XHTML     "http://www.w3.org/1999/xhtml"

#define NS_DISCO_INFO "http://jabber.org/protocol/disco#info"

#define NS_DISCO_ITEMS "http://jabber.org/protocol/disco#items"

#define NS_IQ_AUTH    "http://jabber.org/features/iq-auth"

#define NS_REGISTER_FEATURE "http://jabber.org/features/iq-register"

#define NS_CAPS       "http://jabber.org/protocol/caps"

#define NS_CHATSTATES "http://jabber.org/protocol/chatstates"

#define NS_COMMANDS   "http://jabber.org/protocol/commands"

#define NS_MUC        "http://jabber.org/protocol/muc"

#define NS_XDBGINSERT "jabber:xdb:ginsert"

#define NS_XDBNSLIST  "jabber:xdb:nslist"

#define NS_XMPP_STANZAS "urn:ietf:params:xml:ns:xmpp-stanzas"

#define NS_XMPP_TLS  "urn:ietf:params:xml:ns:xmpp-tls"

#define NS_XMPP_STREAMS "urn:ietf:params:xml:ns:xmpp-streams"

#define NS_PING      "urn:xmpp:ping"

#define NS_JABBERD_STOREDPRESENCE "http://jabberd.org/ns/storedpresence"

#define NS_JABBERD_HISTORY "http://jabberd.org/ns/history"

/* --------------------------------------------------------- */

/*                                                           */

/* Message Types                                             */

/*                                                           */

/* --------------------------------------------------------- */

#define TMSG_NORMAL     "normal"

#define TMSG_ERROR      "error"

#define TMSG_CHAT       "chat"

#define TMSG_GROUPCHAT  "groupchat"

#define TMSG_HEADLINE   "headline"

/* --------------------------------------------------------- */

/*                                                           */

/* JUtil functions                                           */

/*                                                           */

/* --------------------------------------------------------- */

xmlnode jutil_presnew(int type, char *to, char *status); /* Create a skeleton presence packet */

xmlnode jutil_iqnew(int type, char *ns);                 /* Create a skeleton iq packet */

xmlnode jutil_msgnew(char *type, char *to, char *subj, char *body);

							 /* Create a skeleton message packet */

xmlnode jutil_header(char* xmlns, char* server);         /* Create a skeleton stream packet */

int     jutil_priority(xmlnode x);                       /* Determine priority of this packet */

void    jutil_tofrom(xmlnode x);                         /* Swaps to/from fields on a packet */

xmlnode jutil_iqresult(xmlnode x);                       /* Generate a skeleton iq/result, given a iq/query */

char*   jutil_timestamp(void);                           /* Get stringified timestamp */

void    jutil_error(xmlnode x, terror E);                /* Append an <error> node to x */

void    jutil_delay(xmlnode msg, char *reason);          /* Append a delay packet to msg */

char*   jutil_regkey(char *key, char *seed);             /* pass a seed to generate a key, pass the key again to validate (returns it) */

/* --------------------------------------------------------- */

/*                                                           */

/* JConn structures & functions                              */

/*                                                           */

/* --------------------------------------------------------- */

#define JCONN_STATE_OFF       0

#define JCONN_STATE_CONNECTED 1

#define JCONN_STATE_ON        2

#define JCONN_STATE_AUTH      3

#define JCONN_STATE_CONNECTING 4

typedef struct jconn_struct

{

    /* Core structure */

    pool        p;          /* Memory allocation pool */

    int         state;      /* Connection state flag */

    int         cw_state;   /* Low level connection state flag */

    int         fd;         /* Connection file descriptor */

    char        *server;    /* The server we'll connect too */

    int         port;

    int         ssl;

    jid         user;       /* User info */

    char        *pass;      /* User passwd */

    /* Stream stuff */

    int         id;         /* id counter for jab_getid() function */

    char        idbuf[9];   /* temporary storage for jab_getid() */

    char        *sid;       /* stream id from server, for digest auth */

    XML_Parser  parser;     /* Parser instance */

    xmlnode     current;    /* Current node in parsing instance.. */

    /* Event callback ptrs */

    void (*on_state)(struct jconn_struct *j, int state);

    void (*on_packet)(struct jconn_struct *j, jpacket p);

    void (*logger)(struct jconn_struct *j, int inout, const char *p);

} *jconn, jconn_struct;

typedef void (*jconn_state_h)(jconn j, int state);

typedef void (*jconn_packet_h)(jconn j, jpacket p);

typedef void (*jconn_logger)(jconn j, int inout, const char *p);

jconn jab_new(char *user, char *pass, char *server, int port, int ssl);

void jab_delete(jconn j);

void jab_state_handler(jconn j, jconn_state_h h);

void jab_packet_handler(jconn j, jconn_packet_h h);

void jab_logger(jconn j, jconn_logger h);

void jab_start(jconn j);

void jab_stop(jconn j);

int jab_getfd(jconn j);

jid jab_getjid(jconn j);

char *jab_getsid(jconn j);

char *jab_getid(jconn j);

void jab_send(jconn j, xmlnode x);

void jab_send_raw(jconn j, const char *str);

void jab_recv(jconn j);

void jab_poll(jconn j, int timeout);

char *jab_auth(jconn j);

int   jab_auth_mcabber(jconn j, xmlnode x);

char *jab_reg(jconn j);

#ifdef __cplusplus

}

#endif

#endif  /* INCL_JABBER_H */