/**

 * @file jabber.h

 *

 * purple

 *

 * Copyright (C) 2003 Nathan Walp <faceprint@faceprint.com>

 *

 * 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., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA

 */

#ifndef PURPLE_JABBER_H_

#define PURPLE_JABBER_H_

typedef enum {

	JABBER_CAP_NONE           = 0,

/*	JABBER_CAP_XHTML          = 1 << 0, */

/*	JABBER_CAP_COMPOSING      = 1 << 1, */

	JABBER_CAP_SI             = 1 << 2,

	JABBER_CAP_SI_FILE_XFER   = 1 << 3,

	JABBER_CAP_BYTESTREAMS    = 1 << 4,

	JABBER_CAP_IBB            = 1 << 5,

	JABBER_CAP_CHAT_STATES    = 1 << 6,

	JABBER_CAP_IQ_SEARCH      = 1 << 7,

	JABBER_CAP_IQ_REGISTER    = 1 << 8,

	/* Google Talk extensions:

	 * http://code.google.com/apis/talk/jep_extensions/extensions.html

	 */

	JABBER_CAP_GMAIL_NOTIFY   = 1 << 9,

	JABBER_CAP_GOOGLE_ROSTER  = 1 << 10,

	JABBER_CAP_PING			  = 1 << 11,

	JABBER_CAP_ADHOC		  = 1 << 12,

	JABBER_CAP_BLOCKING       = 1 << 13,

	JABBER_CAP_ITEMS          = 1 << 14,

	JABBER_CAP_RETRIEVED      = 1 << 31

} JabberCapabilities;

typedef struct _JabberStream JabberStream;

#include <libxml/parser.h>

#include <glib.h>

#include "circbuffer.h"

#include "connection.h"

#include "dnsquery.h"

#include "dnssrv.h"

#include "media.h"

#include "mediamanager.h"

#include "roomlist.h"

#include "sslconn.h"

#include "iq.h"

#include "jutil.h"

#include "xmlnode.h"

#include "buddy.h"

#include "bosh.h"

#ifdef HAVE_CYRUS_SASL

#include <sasl/sasl.h>

#endif

#define CAPS0115_NODE "http://pidgin.im/"

/* Index into attention_types list */

#define JABBER_BUZZ 0

extern PurplePlugin *jabber_plugin;

typedef enum {

	JABBER_STREAM_OFFLINE,

	JABBER_STREAM_CONNECTING,

	JABBER_STREAM_INITIALIZING,

	JABBER_STREAM_INITIALIZING_ENCRYPTION,

	JABBER_STREAM_AUTHENTICATING,

	JABBER_STREAM_REINITIALIZING,

	JABBER_STREAM_CONNECTED

} JabberStreamState;

struct _JabberStream

{

	int fd;

	PurpleSrvQueryData *srv_query_data;

	xmlParserCtxt *context;

	xmlnode *current;

	enum {

		JABBER_PROTO_0_9,

		JABBER_PROTO_1_0

	} protocol_version;

	enum {

		JABBER_AUTH_UNKNOWN,

		JABBER_AUTH_DIGEST_MD5,

		JABBER_AUTH_PLAIN,

		JABBER_AUTH_IQ_AUTH,

		JABBER_AUTH_CYRUS

	} auth_type;

	char *stream_id;

	JabberStreamState state;

	/* SASL authentication */

	char *expected_rspauth;

	GHashTable *buddies;

	/*

	 * This boolean was added to eliminate a heinous bug where we would

	 * get into a loop with the server and move a buddy back and forth

	 * from one group to another.

	 *

	 * The sequence goes something like this:

	 * 1. Our resource and another resource both approve an authorization

	 *    request at the exact same time.  We put the buddy in group A and

	 *    the other resource put the buddy in group B.

	 * 2. The server receives the roster add for group B and sends us a

	 *    roster push.

	 * 3. We receive this roster push and modify our local blist.  This

	 *    triggers us to send a roster add for group B.

	 * 4. The server recieves our earlier roster add for group A and sends

	 *    us a roster push.

	 * 5. We receive this roster push and modify our local blist.  This

	 *    triggers us to send a roster add for group A.

	 * 6. The server receives our earlier roster add for group B and sends

	 *    us a roster push.

	 * (repeat steps 3 through 6 ad infinitum)

	 *

	 * This boolean is used to short-circuit the sending of a roster add

	 * when we receive a roster push.

	 *

	 * See these bug reports:

	 * http://trac.adiumx.com/ticket/8834

	 * http://developer.pidgin.im/ticket/5484

	 * http://developer.pidgin.im/ticket/6188

	 */

	gboolean currently_parsing_roster_push;

	GHashTable *chats;

	GList *chat_servers;

	PurpleRoomlist *roomlist;

	GList *user_directories;

	GHashTable *iq_callbacks;

	int next_id;

	GList *bs_proxies;

	GList *oob_file_transfers;

	GList *file_transfers;

	time_t idle;

	time_t old_idle;

	JabberID *user;

	JabberBuddy *user_jb;

	PurpleConnection *gc;

	PurpleSslConnection *gsc;

	gboolean registration;

	char *initial_avatar_hash;

	char *avatar_hash;

	GSList *pending_avatar_requests;

	GSList *pending_buddy_info_requests;

	PurpleCircBuffer *write_buffer;

	guint writeh;

	gboolean reinit;

	JabberCapabilities server_caps;

	gboolean googletalk;

	char *server_name;

	char *gmail_last_time;

	char *gmail_last_tid;

	char *serverFQDN;

	/* OK, this stays at the end of the struct, so plugins can depend

	 * on the rest of the stuff being in the right place

	 */

#ifdef HAVE_CYRUS_SASL

	sasl_conn_t *sasl;

	sasl_callback_t *sasl_cb;

#else /* keep the struct the same size */

	void *sasl;

	void *sasl_cb;

#endif

	/* did someone say something about the end of the struct? */

#ifdef HAVE_CYRUS_SASL

	const char *current_mech;

	int auth_fail_count;

#endif

	int sasl_state;

	int sasl_maxbuf;

	GString *sasl_mechs;

	gboolean unregistration;

	PurpleAccountUnregistrationCb unregistration_cb;

	void *unregistration_user_data;

	gboolean vcard_fetched;

	/* Timer at login to push updated avatar */

	guint vcard_timer;

	/* Entity Capabilities hash */

	char *caps_hash;

	/* does the local server support PEP? */

	gboolean pep;

	/* Is Buzz enabled? */

	gboolean allowBuzz;

	/* A list of JabberAdHocCommands supported by the server */

	GList *commands;

	/* last presence update to check for differences */

	JabberBuddyState old_state;

	char *old_msg;

	int old_priority;

	char *old_avatarhash;

	/* same for user tune */

	char *old_artist;

	char *old_title;

	char *old_source;

	char *old_uri;

	int old_length;

	char *old_track;

	char *certificate_CN;

	/* A purple timeout tag for the keepalive */

	guint keepalive_timeout;

	PurpleSrvResponse *srv_rec;

	guint srv_rec_idx;

	guint max_srv_rec_idx;

	/* BOSH stuff */

	PurpleBOSHConnection *bosh;

	/**

	 * This linked list contains PurpleUtilFetchUrlData structs

	 * for when we lookup buddy icons from a url

	 */

	GSList *url_datas;

	/* keep a hash table of JingleSessions */

	GHashTable *sessions;

	/* maybe this should only be present when USE_VV? */

	gchar *stun_ip;

	int stun_port;

	PurpleDnsQueryData *stun_query;

	/* later add stuff to handle TURN relays... */

};

typedef gboolean (JabberFeatureEnabled)(JabberStream *js, const gchar *namespace);

typedef struct _JabberFeature

{

	gchar *namespace;

	JabberFeatureEnabled *is_enabled;

} JabberFeature;

typedef struct _JabberIdentity

{

	gchar *category;

	gchar *type;

	gchar *name;

	gchar *lang;

} JabberIdentity;

typedef struct _JabberBytestreamsStreamhost {

	char *jid;

	char *host;

	int port;

	char *zeroconf;

} JabberBytestreamsStreamhost;

/* what kind of additional features as returned from disco#info are supported? */

extern GList *jabber_features;

extern GList *jabber_identities;

void jabber_stream_features_parse(JabberStream *js, xmlnode *packet);

void jabber_process_packet(JabberStream *js, xmlnode **packet);

void jabber_send(JabberStream *js, xmlnode *data);

void jabber_send_raw(JabberStream *js, const char *data, int len);

void jabber_send_signal_cb(PurpleConnection *pc, xmlnode **packet,

                           gpointer unused);

void jabber_stream_set_state(JabberStream *js, JabberStreamState state);

void jabber_register_parse(JabberStream *js, const char *from,

                           JabberIqType type, const char *id, xmlnode *query);

void jabber_register_start(JabberStream *js);

char *jabber_get_next_id(JabberStream *js);

/** Parse an error into a human-readable string and optionally a disconnect

 *  reason.

 *  @param js     the stream on which the error occurred.

 *  @param packet the error packet

 *  @param reason where to store the disconnection reason, or @c NULL if you

 *                don't care or you don't intend to close the connection.

 */

char *jabber_parse_error(JabberStream *js, xmlnode *packet, PurpleConnectionError *reason);

void jabber_add_feature(const gchar *namespace, JabberFeatureEnabled cb); /* cb may be NULL */

void jabber_remove_feature(const gchar *namespace);

/** Adds an identity to this jabber library instance. For list of valid values visit the

 *	website of the XMPP Registrar ( http://www.xmpp.org/registrar/disco-categories.html#client ).

 *  @param category the category of the identity.

 *  @param type the type of the identity.

 *  @param language the language localization of the name. Can be NULL.

 *  @param name the name of the identity.

 */

void jabber_add_identity(const gchar *category, const gchar *type, const gchar *lang, const gchar *name);

/**

 * Returns true if this connection is over a secure (SSL) stream. Use this

 * instead of checking js->gsc because BOSH stores its PurpleSslConnection

 * members in its own data structure.

 */

gboolean jabber_stream_is_ssl(JabberStream *js);

/** PRPL functions */

const char *jabber_list_icon(PurpleAccount *a, PurpleBuddy *b);

const char* jabber_list_emblem(PurpleBuddy *b);

char *jabber_status_text(PurpleBuddy *b);

void jabber_tooltip_text(PurpleBuddy *b, PurpleNotifyUserInfo *user_info, gboolean full);

GList *jabber_status_types(PurpleAccount *account);

void jabber_login(PurpleAccount *account);

void jabber_close(PurpleConnection *gc);

void jabber_idle_set(PurpleConnection *gc, int idle);

void jabber_blocklist_parse_push(JabberStream *js, const char *from,

                                 JabberIqType type, const char *id,

                                 xmlnode *child);

void jabber_request_block_list(JabberStream *js);

void jabber_add_deny(PurpleConnection *gc, const char *who);

void jabber_rem_deny(PurpleConnection *gc, const char *who);

void jabber_keepalive(PurpleConnection *gc);

void jabber_register_gateway(JabberStream *js, const char *gateway);

void jabber_register_account(PurpleAccount *account);

void jabber_unregister_account(PurpleAccount *account, PurpleAccountUnregistrationCb cb, void *user_data);

gboolean jabber_send_attention(PurpleConnection *gc, const char *username, guint code);

GList *jabber_attention_types(PurpleAccount *account);

void jabber_convo_closed(PurpleConnection *gc, const char *who);

PurpleChat *jabber_find_blist_chat(PurpleAccount *account, const char *name);

gboolean jabber_offline_message(const PurpleBuddy *buddy);

int jabber_prpl_send_raw(PurpleConnection *gc, const char *buf, int len);

GList *jabber_actions(PurplePlugin *plugin, gpointer context);

gboolean jabber_audio_enabled(JabberStream *js, const char *unused);

gboolean jabber_video_enabled(JabberStream *js, const char *unused);

gboolean jabber_initiate_media(PurpleAccount *account, const char *who,

		PurpleMediaSessionType type);

PurpleMediaCaps jabber_get_media_caps(PurpleAccount *account, const char *who);

void jabber_register_commands(void);

void jabber_unregister_commands(void);

void jabber_init_plugin(PurplePlugin *plugin);

void jabber_uninit_plugin(void);

#endif /* PURPLE_JABBER_H_ */