libpurple/protocols/jabber/jabber.h

   1 /**
   2  * @file jabber.h
   3  *
   4  * purple
   5  *
   6  * Purple is the legal property of its developers, whose names are too numerous
   7  * to list here.  Please refer to the COPYRIGHT file distributed with this
   8  * source distribution.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  23  */
  24
  25 #ifndef PURPLE_JABBER_JABBER_H
  26 #define PURPLE_JABBER_JABBER_H
  27
  28 typedef enum {
  29         JABBER_CAP_NONE           = 0,
  30 /*      JABBER_CAP_XHTML          = 1 << 0, */
  31 /*      JABBER_CAP_COMPOSING      = 1 << 1, */
  32         JABBER_CAP_SI             = 1 << 2,
  33         JABBER_CAP_SI_FILE_XFER   = 1 << 3,
  34         JABBER_CAP_BYTESTREAMS    = 1 << 4,
  35         JABBER_CAP_IBB            = 1 << 5,
  36         JABBER_CAP_CHAT_STATES    = 1 << 6,
  37         JABBER_CAP_IQ_SEARCH      = 1 << 7,
  38         JABBER_CAP_IQ_REGISTER    = 1 << 8,
  39
  40         /* Google Talk extensions:
  41          * https://developers.google.com/talk/jep_extensions/extensions
  42          */
  43         JABBER_CAP_GMAIL_NOTIFY   = 1 << 9,
  44         JABBER_CAP_GOOGLE_ROSTER  = 1 << 10,
  45
  46         JABBER_CAP_PING                   = 1 << 11,
  47         JABBER_CAP_ADHOC                  = 1 << 12,
  48         JABBER_CAP_BLOCKING       = 1 << 13,
  49
  50         JABBER_CAP_ITEMS          = 1 << 14,
  51         JABBER_CAP_ROSTER_VERSIONING = 1 << 15,
  52
  53         JABBER_CAP_RETRIEVED      = 1 << 31
  54 } JabberCapabilities;
  55
  56 typedef struct _JabberStream JabberStream;
  57
  58 #include <libxml/parser.h>
  59 #include <glib.h>
  60 #include <gmodule.h>
  61 #include <gio/gio.h>
  62
  63 #include "attention.h"
  64 #include "circularbuffer.h"
  65 #include "connection.h"
  66 #include "http.h"
  67 #include "media.h"
  68 #include "mediamanager.h"
  69 #include "protocol.h"
  70 #include "roomlist.h"
  71 #include "sslconn.h"
  72
  73 #include "namespaces.h"
  74
  75 #include "auth.h"
  76 #include "iq.h"
  77 #include "jutil.h"
  78 #include "xmlnode.h"
  79 #include "buddy.h"
  80 #include "bosh.h"
  81
  82 #ifdef HAVE_CYRUS_SASL
  83 #include <sasl/sasl.h>
  84 #endif
  85
  86 #define CAPS0115_NODE "https://pidgin.im/"
  87
  88 #define JABBER_TYPE_PROTOCOL             (jabber_protocol_get_type())
  89 #define JABBER_PROTOCOL(obj)             (G_TYPE_CHECK_INSTANCE_CAST((obj), JABBER_TYPE_PROTOCOL, JabberProtocol))
  90 #define JABBER_PROTOCOL_CLASS(klass)     (G_TYPE_CHECK_CLASS_CAST((klass), JABBER_TYPE_PROTOCOL, JabberProtocolClass))
  91 #define JABBER_IS_PROTOCOL(obj)          (G_TYPE_CHECK_INSTANCE_TYPE((obj), JABBER_TYPE_PROTOCOL))
  92 #define JABBER_IS_PROTOCOL_CLASS(klass)  (G_TYPE_CHECK_CLASS_TYPE((klass), JABBER_TYPE_PROTOCOL))
  93 #define JABBER_PROTOCOL_GET_CLASS(obj)   (G_TYPE_INSTANCE_GET_CLASS((obj), JABBER_TYPE_PROTOCOL, JabberProtocolClass))
  94
  95 #define JABBER_DEFAULT_REQUIRE_TLS    "require_starttls"
  96
  97 /* Index into attention_types list */
  98 #define JABBER_BUZZ 0
  99
 100 typedef enum {
 101         JABBER_STREAM_OFFLINE,
 102         JABBER_STREAM_CONNECTING,
 103         JABBER_STREAM_INITIALIZING,
 104         JABBER_STREAM_INITIALIZING_ENCRYPTION,
 105         JABBER_STREAM_AUTHENTICATING,
 106         JABBER_STREAM_POST_AUTH,
 107         JABBER_STREAM_CONNECTED
 108 } JabberStreamState;
 109
 110 typedef struct
 111 {
 112         PurpleProtocol parent;
 113 } JabberProtocol;
 114
 115 typedef struct
 116 {
 117         PurpleProtocolClass parent_class;
 118 } JabberProtocolClass;
 119
 120 struct _JabberStream
 121 {
 122         int fd;
 123         guint inpa;
 124
 125         GCancellable *cancellable;
 126
 127         xmlParserCtxt *context;
 128         PurpleXmlNode *current;
 129
 130         struct {
 131                 guint8 major;
 132                 guint8 minor;
 133         } protocol_version;
 134
 135         JabberSaslMech *auth_mech;
 136         gpointer auth_mech_data;
 137
 138         /**
 139          * The header from the opening <stream/> tag.  This being NULL is treated
 140          * as a special condition in the parsing code (signifying the next
 141          * stanza started is an opening stream tag), and its being missing on
 142          * the stream header is treated as a fatal error.
 143          */
 144         char *stream_id;
 145         JabberStreamState state;
 146
 147         GHashTable *buddies;
 148
 149         /*
 150          * This boolean was added to eliminate a heinous bug where we would
 151          * get into a loop with the server and move a buddy back and forth
 152          * from one group to another.
 153          *
 154          * The sequence goes something like this:
 155          * 1. Our resource and another resource both approve an authorization
 156          *    request at the exact same time.  We put the buddy in group A and
 157          *    the other resource put the buddy in group B.
 158          * 2. The server receives the roster add for group B and sends us a
 159          *    roster push.
 160          * 3. We receive this roster push and modify our local blist.  This
 161          *    triggers us to send a roster add for group B.
 162          * 4. The server recieves our earlier roster add for group A and sends
 163          *    us a roster push.
 164          * 5. We receive this roster push and modify our local blist.  This
 165          *    triggers us to send a roster add for group A.
 166          * 6. The server receives our earlier roster add for group B and sends
 167          *    us a roster push.
 168          * (repeat steps 3 through 6 ad infinitum)
 169          *
 170          * This boolean is used to short-circuit the sending of a roster add
 171          * when we receive a roster push.
 172          *
 173          * See these bug reports:
 174          * https://trac.adium.im/ticket/8834
 175          * https://developer.pidgin.im/ticket/5484
 176          * https://developer.pidgin.im/ticket/6188
 177          */
 178         gboolean currently_parsing_roster_push;
 179
 180         GHashTable *chats;
 181         GList *chat_servers;
 182         PurpleRoomlist *roomlist;
 183         GList *user_directories;
 184
 185         GHashTable *iq_callbacks;
 186         int next_id;
 187
 188         GList *bs_proxies;
 189         GList *oob_file_transfers;
 190         GList *file_transfers;
 191
 192         time_t idle;
 193         time_t old_idle;
 194
 195         JabberID *user;
 196         JabberBuddy *user_jb;
 197
 198         PurpleConnection *gc;
 199         PurpleSslConnection *gsc;
 200
 201         gboolean registration;
 202
 203         char *initial_avatar_hash;
 204         char *avatar_hash;
 205         GSList *pending_avatar_requests;
 206
 207         GSList *pending_buddy_info_requests;
 208
 209         PurpleCircularBuffer *write_buffer;
 210         guint writeh;
 211
 212         gboolean reinit;
 213
 214         JabberCapabilities server_caps;
 215         gboolean googletalk;
 216         char *server_name;
 217
 218         char *gmail_last_time;
 219         char *gmail_last_tid;
 220
 221         char *serverFQDN;
 222
 223 #ifdef HAVE_CYRUS_SASL
 224         sasl_conn_t *sasl;
 225         sasl_callback_t *sasl_cb;
 226         sasl_secret_t *sasl_secret;
 227         const char *current_mech;
 228         int auth_fail_count;
 229
 230         int sasl_state;
 231         int sasl_maxbuf;
 232         GString *sasl_mechs;
 233
 234         gchar *sasl_password;
 235 #endif
 236
 237         gboolean unregistration;
 238         PurpleAccountUnregistrationCb unregistration_cb;
 239         void *unregistration_user_data;
 240
 241         gboolean vcard_fetched;
 242         /* Timer at login to push updated avatar */
 243         guint vcard_timer;
 244
 245         /* Entity Capabilities hash */
 246         char *caps_hash;
 247
 248         /* does the local server support PEP? */
 249         gboolean pep;
 250
 251         /* Is Buzz enabled? */
 252         gboolean allowBuzz;
 253
 254         /* A list of JabberAdHocCommands supported by the server */
 255         GList *commands;
 256
 257         /* last presence update to check for differences */
 258         JabberBuddyState old_state;
 259         char *old_msg;
 260         int old_priority;
 261         char *old_avatarhash;
 262
 263         /* same for user tune */
 264         char *old_artist;
 265         char *old_title;
 266         char *old_source;
 267         char *old_uri;
 268         int old_length;
 269         char *old_track;
 270
 271         char *certificate_CN;
 272
 273         /* A purple timeout tag for the keepalive */
 274         guint keepalive_timeout;
 275         guint max_inactivity;
 276         guint inactivity_timer;
 277         guint conn_close_timeout;
 278
 279         PurpleJabberBOSHConnection *bosh;
 280
 281         PurpleHttpConnectionSet *http_conns;
 282
 283         /* keep a hash table of JingleSessions */
 284         GHashTable *sessions;
 285
 286         /* maybe this should only be present when USE_VV? */
 287         gchar *stun_ip;
 288         int stun_port;
 289
 290         /* stuff for Google's relay handling */
 291         gchar *google_relay_token;
 292         gchar *google_relay_host;
 293 };
 294
 295 typedef gboolean (JabberFeatureEnabled)(JabberStream *js, const gchar *namespace);
 296
 297 typedef struct
 298 {
 299         gchar *namespace;
 300         JabberFeatureEnabled *is_enabled;
 301 } JabberFeature;
 302
 303 typedef struct
 304 {
 305         gchar *category;
 306         gchar *type;
 307         gchar *name;
 308         gchar *lang;
 309 } JabberIdentity;
 310
 311 typedef struct {
 312         char *jid;
 313         char *host;
 314         guint16 port;
 315         char *zeroconf;
 316 } JabberBytestreamsStreamhost;
 317
 318 /* what kind of additional features as returned from disco#info are supported? */
 319 extern GList *jabber_features;
 320 /* A sorted list of identities advertised.  Use jabber_add_identity to add
 321  * so it remains sorted.
 322  */
 323 extern GList *jabber_identities;
 324
 325 /**
 326  * Returns the GType for the JabberProtocol object.
 327  */
 328 G_MODULE_EXPORT GType jabber_protocol_get_type(void);
 329
 330 void jabber_stream_features_parse(JabberStream *js, PurpleXmlNode *packet);
 331 void jabber_process_packet(JabberStream *js, PurpleXmlNode **packet);
 332 void jabber_send(JabberStream *js, PurpleXmlNode *data);
 333 void jabber_send_raw(JabberStream *js, const char *data, int len);
 334 void jabber_send_signal_cb(PurpleConnection *pc, PurpleXmlNode **packet,
 335                            gpointer unused);
 336
 337 void jabber_stream_set_state(JabberStream *js, JabberStreamState state);
 338
 339 void jabber_register_parse(JabberStream *js, const char *from,
 340                            JabberIqType type, const char *id, PurpleXmlNode *query);
 341 void jabber_register_start(JabberStream *js);
 342
 343 char *jabber_get_next_id(JabberStream *js);
 344
 345 /** Parse an error into a human-readable string and optionally a disconnect
 346  *  reason.
 347  *  @param js     the stream on which the error occurred.
 348  *  @param packet the error packet
 349  *  @param reason where to store the disconnection reason, or @c NULL if you
 350  *                don't care or you don't intend to close the connection.
 351  */
 352 char *jabber_parse_error(JabberStream *js, PurpleXmlNode *packet, PurpleConnectionError *reason);
 353
 354 /**
 355  * Add a feature to the list of features advertised via disco#info.  If you
 356  * call this while accounts are connected, Bad Things(TM) will happen because
 357  * the Entity Caps hash will be out-of-date (which should be fixed :/)
 358  *
 359  * @param namespace The namespace of the feature
 360  * @param cb        A callback determining whether or not this feature
 361  *                  will advertised; may be NULL.
 362  */
 363 void jabber_add_feature(const gchar *namespace, JabberFeatureEnabled cb);
 364 void jabber_remove_feature(const gchar *namespace);
 365
 366 /** Adds an identity to this jabber library instance. For list of valid values
 367  * visit the website of the XMPP Registrar
 368  * (http://xmpp.org/registrar/disco-categories.html#client)
 369  *
 370  * Like with jabber_add_feature, if you call this while accounts are connected,
 371  * Bad Things will happen.
 372  *
 373  *  @param category the category of the identity.
 374  *  @param type the type of the identity.
 375  *  @param language the language localization of the name. Can be NULL.
 376  *  @param name the name of the identity.
 377  */
 378 void jabber_add_identity(const gchar *category, const gchar *type, const gchar *lang, const gchar *name);
 379
 380 /**
 381  * GCompareFunc for JabberIdentity structs.
 382  */
 383 gint jabber_identity_compare(gconstpointer a, gconstpointer b);
 384
 385 /**
 386  * Returns true if this connection is over a secure (SSL) stream. Use this
 387  * instead of checking js->gsc because BOSH stores its PurpleSslConnection
 388  * members in its own data structure.
 389  */
 390 gboolean jabber_stream_is_ssl(JabberStream *js);
 391
 392 /**
 393  * Restart the "we haven't sent anything in a while and should send
 394  * something or the server will kick us off" timer (obviously
 395  * called when sending something.  It's exposed for BOSH.)
 396  */
 397 void jabber_stream_restart_inactivity_timer(JabberStream *js);
 398
 399 /** Protocol functions */
 400 const char *jabber_list_icon(PurpleAccount *a, PurpleBuddy *b);
 401 const char* jabber_list_emblem(PurpleBuddy *b);
 402 char *jabber_status_text(PurpleBuddy *b);
 403 void jabber_tooltip_text(PurpleBuddy *b, PurpleNotifyUserInfo *user_info, gboolean full);
 404 GList *jabber_status_types(PurpleAccount *account);
 405 void jabber_login(PurpleAccount *account);
 406 void jabber_close(PurpleConnection *gc);
 407 void jabber_idle_set(PurpleConnection *gc, int idle);
 408 void jabber_blocklist_parse_push(JabberStream *js, const char *from,
 409                                  JabberIqType type, const char *id,
 410                                  PurpleXmlNode *child);
 411 void jabber_request_block_list(JabberStream *js);
 412 void jabber_add_deny(PurpleConnection *gc, const char *who);
 413 void jabber_rem_deny(PurpleConnection *gc, const char *who);
 414 void jabber_keepalive(PurpleConnection *gc);
 415 void jabber_register_gateway(JabberStream *js, const char *gateway);
 416 void jabber_register_account(PurpleAccount *account);
 417 void jabber_unregister_account(PurpleAccount *account, PurpleAccountUnregistrationCb cb, void *user_data);
 418 gboolean jabber_send_attention(PurpleProtocolAttention *attn, PurpleConnection *gc, const char *username, guint code);
 419 GList *jabber_attention_types(PurpleProtocolAttention *attn, PurpleAccount *account);
 420 void jabber_convo_closed(PurpleConnection *gc, const char *who);
 421 PurpleChat *jabber_find_blist_chat(PurpleAccount *account, const char *name);
 422 gboolean jabber_offline_message(const PurpleBuddy *buddy);
 423 int jabber_protocol_send_raw(PurpleConnection *gc, const char *buf, int len);
 424 GList *jabber_get_actions(PurpleConnection *gc);
 425
 426 gboolean jabber_audio_enabled(JabberStream *js, const char *unused);
 427 gboolean jabber_video_enabled(JabberStream *js, const char *unused);
 428 gboolean jabber_initiate_media(PurpleAccount *account, const char *who,
 429                 PurpleMediaSessionType type);
 430 PurpleMediaCaps jabber_get_media_caps(PurpleAccount *account, const char *who);
 431 gboolean jabber_can_receive_file(PurpleProtocolXfer *xfer, PurpleConnection *gc, const gchar *who);
 432
 433 #endif /* PURPLE_JABBER_JABBER_H */