[21167d2] | 1 | /***************************************************************************\ |
---|
| 2 | * * |
---|
| 3 | * BitlBee - An IRC to IM gateway * |
---|
| 4 | * Jabber module - I/O stuff (plain, SSL), queues, etc * |
---|
| 5 | * * |
---|
| 6 | * Copyright 2006 Wilmer van der Gaast <wilmer@gaast.net> * |
---|
| 7 | * * |
---|
| 8 | * This program is free software; you can redistribute it and/or modify * |
---|
| 9 | * it under the terms of the GNU General Public License as published by * |
---|
| 10 | * the Free Software Foundation; either version 2 of the License, or * |
---|
| 11 | * (at your option) any later version. * |
---|
| 12 | * * |
---|
| 13 | * This program is distributed in the hope that it will be useful, * |
---|
| 14 | * but WITHOUT ANY WARRANTY; without even the implied warranty of * |
---|
| 15 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * |
---|
| 16 | * GNU General Public License for more details. * |
---|
| 17 | * * |
---|
| 18 | * You should have received a copy of the GNU General Public License along * |
---|
| 19 | * with this program; if not, write to the Free Software Foundation, Inc., * |
---|
| 20 | * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * |
---|
| 21 | * * |
---|
| 22 | \***************************************************************************/ |
---|
| 23 | |
---|
| 24 | #include "jabber.h" |
---|
[42127dc] | 25 | #include "ssl_client.h" |
---|
[21167d2] | 26 | |
---|
| 27 | static gboolean jabber_write_callback( gpointer data, gint fd, b_input_condition cond ); |
---|
[0da65d5] | 28 | static gboolean jabber_write_queue( struct im_connection *ic ); |
---|
[21167d2] | 29 | |
---|
[0da65d5] | 30 | int jabber_write_packet( struct im_connection *ic, struct xt_node *node ) |
---|
[21167d2] | 31 | { |
---|
| 32 | char *buf; |
---|
| 33 | int st; |
---|
| 34 | |
---|
| 35 | buf = xt_to_string( node ); |
---|
[0da65d5] | 36 | st = jabber_write( ic, buf, strlen( buf ) ); |
---|
[21167d2] | 37 | g_free( buf ); |
---|
| 38 | |
---|
| 39 | return st; |
---|
| 40 | } |
---|
| 41 | |
---|
[0da65d5] | 42 | int jabber_write( struct im_connection *ic, char *buf, int len ) |
---|
[21167d2] | 43 | { |
---|
[0da65d5] | 44 | struct jabber_data *jd = ic->proto_data; |
---|
[cc2cb2d] | 45 | gboolean ret; |
---|
[21167d2] | 46 | |
---|
[bb95d43] | 47 | if( jd->flags & JFLAG_XMLCONSOLE ) |
---|
| 48 | { |
---|
| 49 | char *msg; |
---|
| 50 | |
---|
| 51 | msg = g_strdup_printf( "TX: %s", buf ); |
---|
| 52 | imcb_buddy_msg( ic, JABBER_XMLCONSOLE_HANDLE, msg, 0, 0 ); |
---|
| 53 | g_free( msg ); |
---|
| 54 | } |
---|
| 55 | |
---|
[21167d2] | 56 | if( jd->tx_len == 0 ) |
---|
| 57 | { |
---|
| 58 | /* If the queue is empty, allocate a new buffer. */ |
---|
| 59 | jd->tx_len = len; |
---|
| 60 | jd->txq = g_memdup( buf, len ); |
---|
| 61 | |
---|
| 62 | /* Try if we can write it immediately so we don't have to do |
---|
| 63 | it via the event handler. If not, add the handler. (In |
---|
| 64 | most cases it probably won't be necessary.) */ |
---|
[0da65d5] | 65 | if( ( ret = jabber_write_queue( ic ) ) && jd->tx_len > 0 ) |
---|
| 66 | jd->w_inpa = b_input_add( jd->fd, GAIM_INPUT_WRITE, jabber_write_callback, ic ); |
---|
[21167d2] | 67 | } |
---|
| 68 | else |
---|
| 69 | { |
---|
| 70 | /* Just add it to the buffer if it's already filled. The |
---|
| 71 | event handler is already set. */ |
---|
| 72 | jd->txq = g_renew( char, jd->txq, jd->tx_len + len ); |
---|
| 73 | memcpy( jd->txq + jd->tx_len, buf, len ); |
---|
| 74 | jd->tx_len += len; |
---|
[cc2cb2d] | 75 | |
---|
| 76 | /* The return value for write() doesn't necessarily mean |
---|
| 77 | that everything got sent, it mainly means that the |
---|
| 78 | connection (officially) still exists and can still |
---|
| 79 | be accessed without hitting SIGSEGV. IOW: */ |
---|
| 80 | ret = TRUE; |
---|
[21167d2] | 81 | } |
---|
| 82 | |
---|
[cc2cb2d] | 83 | return ret; |
---|
[21167d2] | 84 | } |
---|
| 85 | |
---|
[cc2cb2d] | 86 | /* Splitting up in two separate functions: One to use as a callback and one |
---|
| 87 | to use in the function above to escape from having to wait for the event |
---|
| 88 | handler to call us, if possible. |
---|
| 89 | |
---|
| 90 | Two different functions are necessary because of the return values: The |
---|
| 91 | callback should only return TRUE if the write was successful AND if the |
---|
| 92 | buffer is not empty yet (ie. if the handler has to be called again when |
---|
| 93 | the socket is ready for more data). */ |
---|
[21167d2] | 94 | static gboolean jabber_write_callback( gpointer data, gint fd, b_input_condition cond ) |
---|
| 95 | { |
---|
[0da65d5] | 96 | struct jabber_data *jd = ((struct im_connection *)data)->proto_data; |
---|
[cc2cb2d] | 97 | |
---|
| 98 | return jd->fd != -1 && |
---|
| 99 | jabber_write_queue( data ) && |
---|
| 100 | jd->tx_len > 0; |
---|
| 101 | } |
---|
| 102 | |
---|
[0da65d5] | 103 | static gboolean jabber_write_queue( struct im_connection *ic ) |
---|
[cc2cb2d] | 104 | { |
---|
[0da65d5] | 105 | struct jabber_data *jd = ic->proto_data; |
---|
[21167d2] | 106 | int st; |
---|
| 107 | |
---|
[42127dc] | 108 | if( jd->ssl ) |
---|
| 109 | st = ssl_write( jd->ssl, jd->txq, jd->tx_len ); |
---|
| 110 | else |
---|
| 111 | st = write( jd->fd, jd->txq, jd->tx_len ); |
---|
| 112 | |
---|
[21167d2] | 113 | if( st == jd->tx_len ) |
---|
| 114 | { |
---|
| 115 | /* We wrote everything, clear the buffer. */ |
---|
| 116 | g_free( jd->txq ); |
---|
| 117 | jd->txq = NULL; |
---|
| 118 | jd->tx_len = 0; |
---|
| 119 | |
---|
[cc2cb2d] | 120 | return TRUE; |
---|
[21167d2] | 121 | } |
---|
| 122 | else if( st == 0 || ( st < 0 && !sockerr_again() ) ) |
---|
| 123 | { |
---|
[8d74291] | 124 | /* Set fd to -1 to make sure we won't write to it anymore. */ |
---|
| 125 | closesocket( jd->fd ); /* Shouldn't be necessary after errors? */ |
---|
| 126 | jd->fd = -1; |
---|
| 127 | |
---|
[84b045d] | 128 | imcb_error( ic, "Short write() to server" ); |
---|
[c2fb3809] | 129 | imc_logout( ic, TRUE ); |
---|
[21167d2] | 130 | return FALSE; |
---|
| 131 | } |
---|
| 132 | else if( st > 0 ) |
---|
| 133 | { |
---|
| 134 | char *s; |
---|
| 135 | |
---|
| 136 | s = g_memdup( jd->txq + st, jd->tx_len - st ); |
---|
| 137 | jd->tx_len -= st; |
---|
| 138 | g_free( jd->txq ); |
---|
| 139 | jd->txq = s; |
---|
| 140 | |
---|
[8d74291] | 141 | return TRUE; |
---|
[21167d2] | 142 | } |
---|
| 143 | else |
---|
| 144 | { |
---|
| 145 | /* Just in case we had EINPROGRESS/EAGAIN: */ |
---|
| 146 | |
---|
| 147 | return TRUE; |
---|
| 148 | } |
---|
| 149 | } |
---|
| 150 | |
---|
| 151 | static gboolean jabber_read_callback( gpointer data, gint fd, b_input_condition cond ) |
---|
| 152 | { |
---|
[0da65d5] | 153 | struct im_connection *ic = data; |
---|
| 154 | struct jabber_data *jd = ic->proto_data; |
---|
[21167d2] | 155 | char buf[512]; |
---|
| 156 | int st; |
---|
| 157 | |
---|
[8d74291] | 158 | if( jd->fd == -1 ) |
---|
| 159 | return FALSE; |
---|
| 160 | |
---|
[42127dc] | 161 | if( jd->ssl ) |
---|
| 162 | st = ssl_read( jd->ssl, buf, sizeof( buf ) ); |
---|
| 163 | else |
---|
| 164 | st = read( jd->fd, buf, sizeof( buf ) ); |
---|
| 165 | |
---|
[21167d2] | 166 | if( st > 0 ) |
---|
| 167 | { |
---|
| 168 | /* Parse. */ |
---|
[b56b220] | 169 | if( xt_feed( jd->xt, buf, st ) < 0 ) |
---|
[21167d2] | 170 | { |
---|
[84b045d] | 171 | imcb_error( ic, "XML stream error" ); |
---|
[c2fb3809] | 172 | imc_logout( ic, TRUE ); |
---|
[21167d2] | 173 | return FALSE; |
---|
| 174 | } |
---|
| 175 | |
---|
| 176 | /* Execute all handlers. */ |
---|
[101d84f] | 177 | if( !xt_handle( jd->xt, NULL, 1 ) ) |
---|
[21167d2] | 178 | { |
---|
| 179 | /* Don't do anything, the handlers should have |
---|
[25984f2] | 180 | aborted the connection already. */ |
---|
[21167d2] | 181 | return FALSE; |
---|
| 182 | } |
---|
| 183 | |
---|
[5997488] | 184 | if( jd->flags & JFLAG_STREAM_RESTART ) |
---|
| 185 | { |
---|
| 186 | jd->flags &= ~JFLAG_STREAM_RESTART; |
---|
[0da65d5] | 187 | jabber_start_stream( ic ); |
---|
[5997488] | 188 | } |
---|
| 189 | |
---|
[21167d2] | 190 | /* Garbage collection. */ |
---|
[101d84f] | 191 | xt_cleanup( jd->xt, NULL, 1 ); |
---|
[21167d2] | 192 | |
---|
| 193 | /* This is a bit hackish, unfortunately. Although xmltree |
---|
| 194 | has nifty event handler stuff, it only calls handlers |
---|
| 195 | when nodes are complete. Since the server should only |
---|
| 196 | send an opening <stream:stream> tag, we have to check |
---|
| 197 | this by hand. :-( */ |
---|
| 198 | if( !( jd->flags & JFLAG_STREAM_STARTED ) && jd->xt && jd->xt->root ) |
---|
| 199 | { |
---|
| 200 | if( g_strcasecmp( jd->xt->root->name, "stream:stream" ) == 0 ) |
---|
| 201 | { |
---|
| 202 | jd->flags |= JFLAG_STREAM_STARTED; |
---|
[8d74291] | 203 | |
---|
| 204 | /* If there's no version attribute, assume |
---|
| 205 | this is an old server that can't do SASL |
---|
| 206 | authentication. */ |
---|
[0da65d5] | 207 | if( !sasl_supported( ic ) ) |
---|
[cc2cb2d] | 208 | { |
---|
| 209 | /* If there's no version= tag, we suppose |
---|
| 210 | this server does NOT implement: XMPP 1.0, |
---|
| 211 | SASL and TLS. */ |
---|
[0da65d5] | 212 | if( set_getbool( &ic->acc->set, "tls" ) ) |
---|
[cc2cb2d] | 213 | { |
---|
[84b045d] | 214 | imcb_error( ic, "TLS is turned on for this " |
---|
[cc2cb2d] | 215 | "account, but is not supported by this server" ); |
---|
[c2fb3809] | 216 | imc_logout( ic, FALSE ); |
---|
[cc2cb2d] | 217 | return FALSE; |
---|
| 218 | } |
---|
| 219 | else |
---|
| 220 | { |
---|
[0da65d5] | 221 | return jabber_init_iq_auth( ic ); |
---|
[cc2cb2d] | 222 | } |
---|
| 223 | } |
---|
[21167d2] | 224 | } |
---|
| 225 | else |
---|
| 226 | { |
---|
[84b045d] | 227 | imcb_error( ic, "XML stream error" ); |
---|
[c2fb3809] | 228 | imc_logout( ic, TRUE ); |
---|
[21167d2] | 229 | return FALSE; |
---|
| 230 | } |
---|
| 231 | } |
---|
| 232 | } |
---|
| 233 | else if( st == 0 || ( st < 0 && !sockerr_again() ) ) |
---|
| 234 | { |
---|
[8d74291] | 235 | closesocket( jd->fd ); |
---|
| 236 | jd->fd = -1; |
---|
| 237 | |
---|
[84b045d] | 238 | imcb_error( ic, "Error while reading from server" ); |
---|
[c2fb3809] | 239 | imc_logout( ic, TRUE ); |
---|
[21167d2] | 240 | return FALSE; |
---|
| 241 | } |
---|
| 242 | |
---|
| 243 | /* EAGAIN/etc or a successful read. */ |
---|
| 244 | return TRUE; |
---|
| 245 | } |
---|
| 246 | |
---|
| 247 | gboolean jabber_connected_plain( gpointer data, gint source, b_input_condition cond ) |
---|
| 248 | { |
---|
[0da65d5] | 249 | struct im_connection *ic = data; |
---|
[21167d2] | 250 | |
---|
| 251 | if( source == -1 ) |
---|
| 252 | { |
---|
[84b045d] | 253 | imcb_error( ic, "Could not connect to server" ); |
---|
[c2fb3809] | 254 | imc_logout( ic, TRUE ); |
---|
[21167d2] | 255 | return FALSE; |
---|
| 256 | } |
---|
| 257 | |
---|
[84b045d] | 258 | imcb_log( ic, "Connected to server, logging in" ); |
---|
[21167d2] | 259 | |
---|
[0da65d5] | 260 | return jabber_start_stream( ic ); |
---|
[21167d2] | 261 | } |
---|
| 262 | |
---|
[42127dc] | 263 | gboolean jabber_connected_ssl( gpointer data, void *source, b_input_condition cond ) |
---|
| 264 | { |
---|
[0da65d5] | 265 | struct im_connection *ic = data; |
---|
| 266 | struct jabber_data *jd = ic->proto_data; |
---|
[42127dc] | 267 | |
---|
| 268 | if( source == NULL ) |
---|
| 269 | { |
---|
[c1ed6527] | 270 | /* The SSL connection will be cleaned up by the SSL lib |
---|
| 271 | already, set it to NULL here to prevent a double cleanup: */ |
---|
| 272 | jd->ssl = NULL; |
---|
| 273 | |
---|
[84b045d] | 274 | imcb_error( ic, "Could not connect to server" ); |
---|
[c2fb3809] | 275 | imc_logout( ic, TRUE ); |
---|
[42127dc] | 276 | return FALSE; |
---|
| 277 | } |
---|
| 278 | |
---|
[84b045d] | 279 | imcb_log( ic, "Connected to server, logging in" ); |
---|
[42127dc] | 280 | |
---|
[0da65d5] | 281 | return jabber_start_stream( ic ); |
---|
[42127dc] | 282 | } |
---|
| 283 | |
---|
[21167d2] | 284 | static xt_status jabber_end_of_stream( struct xt_node *node, gpointer data ) |
---|
| 285 | { |
---|
[c2fb3809] | 286 | imc_logout( data, TRUE ); |
---|
[21167d2] | 287 | return XT_ABORT; |
---|
| 288 | } |
---|
| 289 | |
---|
[8d74291] | 290 | static xt_status jabber_pkt_features( struct xt_node *node, gpointer data ) |
---|
| 291 | { |
---|
[0da65d5] | 292 | struct im_connection *ic = data; |
---|
| 293 | struct jabber_data *jd = ic->proto_data; |
---|
[fe7a554] | 294 | struct xt_node *c, *reply; |
---|
[e101506] | 295 | int trytls; |
---|
[8d74291] | 296 | |
---|
[0da65d5] | 297 | trytls = g_strcasecmp( set_getstr( &ic->acc->set, "tls" ), "try" ) == 0; |
---|
[8d74291] | 298 | c = xt_find_node( node->children, "starttls" ); |
---|
[42127dc] | 299 | if( c && !jd->ssl ) |
---|
[8d74291] | 300 | { |
---|
[42127dc] | 301 | /* If the server advertises the STARTTLS feature and if we're |
---|
| 302 | not in a secure connection already: */ |
---|
| 303 | |
---|
| 304 | c = xt_find_node( c->children, "required" ); |
---|
| 305 | |
---|
[0da65d5] | 306 | if( c && ( !trytls && !set_getbool( &ic->acc->set, "tls" ) ) ) |
---|
[e101506] | 307 | { |
---|
[84b045d] | 308 | imcb_error( ic, "Server requires TLS connections, but TLS is turned off for this account" ); |
---|
[c2fb3809] | 309 | imc_logout( ic, FALSE ); |
---|
[e101506] | 310 | |
---|
| 311 | return XT_ABORT; |
---|
| 312 | } |
---|
| 313 | |
---|
[42127dc] | 314 | /* Only run this if the tls setting is set to true or try: */ |
---|
[0da65d5] | 315 | if( ( trytls || set_getbool( &ic->acc->set, "tls" ) ) ) |
---|
[42127dc] | 316 | { |
---|
| 317 | reply = xt_new_node( "starttls", NULL, NULL ); |
---|
[47d3ac4] | 318 | xt_add_attr( reply, "xmlns", XMLNS_TLS ); |
---|
[0da65d5] | 319 | if( !jabber_write_packet( ic, reply ) ) |
---|
[42127dc] | 320 | { |
---|
| 321 | xt_free_node( reply ); |
---|
| 322 | return XT_ABORT; |
---|
| 323 | } |
---|
| 324 | xt_free_node( reply ); |
---|
| 325 | |
---|
| 326 | return XT_HANDLED; |
---|
| 327 | } |
---|
| 328 | } |
---|
[e101506] | 329 | else if( !c && !jd->ssl ) |
---|
[42127dc] | 330 | { |
---|
[e101506] | 331 | /* If the server does not advertise the STARTTLS feature and |
---|
| 332 | we're not in a secure connection already: (Servers have a |
---|
| 333 | habit of not advertising <starttls/> anymore when already |
---|
| 334 | using SSL/TLS. */ |
---|
| 335 | |
---|
[0da65d5] | 336 | if( !trytls && set_getbool( &ic->acc->set, "tls" ) ) |
---|
[e101506] | 337 | { |
---|
[84b045d] | 338 | imcb_error( ic, "TLS is turned on for this account, but is not supported by this server" ); |
---|
[c2fb3809] | 339 | imc_logout( ic, FALSE ); |
---|
[e101506] | 340 | |
---|
| 341 | return XT_ABORT; |
---|
| 342 | } |
---|
[8d74291] | 343 | } |
---|
| 344 | |
---|
[42127dc] | 345 | /* This one used to be in jabber_handlers[], but it has to be done |
---|
| 346 | from here to make sure the TLS session will be initialized |
---|
| 347 | properly before we attempt SASL authentication. */ |
---|
| 348 | if( ( c = xt_find_node( node->children, "mechanisms" ) ) ) |
---|
[0e2d97f] | 349 | { |
---|
[42127dc] | 350 | if( sasl_pkt_mechanisms( c, data ) == XT_ABORT ) |
---|
| 351 | return XT_ABORT; |
---|
[0e2d97f] | 352 | } |
---|
[88591fd] | 353 | /* If the server *SEEMS* to support SASL authentication but doesn't |
---|
| 354 | support it after all, we should try to do authentication the |
---|
| 355 | other way. jabber.com doesn't seem to do SASL while it pretends |
---|
| 356 | to be XMPP 1.0 compliant! */ |
---|
[0da65d5] | 357 | else if( !( jd->flags & JFLAG_AUTHENTICATED ) && sasl_supported( ic ) ) |
---|
[0e2d97f] | 358 | { |
---|
[0da65d5] | 359 | if( !jabber_init_iq_auth( ic ) ) |
---|
[88591fd] | 360 | return XT_ABORT; |
---|
[0e2d97f] | 361 | } |
---|
[42127dc] | 362 | |
---|
[fe7a554] | 363 | if( ( c = xt_find_node( node->children, "bind" ) ) ) |
---|
| 364 | { |
---|
[0da65d5] | 365 | reply = xt_new_node( "bind", NULL, xt_new_node( "resource", set_getstr( &ic->acc->set, "resource" ), NULL ) ); |
---|
[47d3ac4] | 366 | xt_add_attr( reply, "xmlns", XMLNS_BIND ); |
---|
[fe7a554] | 367 | reply = jabber_make_packet( "iq", "set", NULL, reply ); |
---|
[0da65d5] | 368 | jabber_cache_add( ic, reply, jabber_pkt_bind_sess ); |
---|
[fe7a554] | 369 | |
---|
[0da65d5] | 370 | if( !jabber_write_packet( ic, reply ) ) |
---|
[fe7a554] | 371 | return XT_ABORT; |
---|
| 372 | |
---|
| 373 | jd->flags |= JFLAG_WAIT_BIND; |
---|
| 374 | } |
---|
| 375 | |
---|
| 376 | if( ( c = xt_find_node( node->children, "session" ) ) ) |
---|
| 377 | { |
---|
| 378 | reply = xt_new_node( "session", NULL, NULL ); |
---|
[47d3ac4] | 379 | xt_add_attr( reply, "xmlns", XMLNS_SESSION ); |
---|
[fe7a554] | 380 | reply = jabber_make_packet( "iq", "set", NULL, reply ); |
---|
[0da65d5] | 381 | jabber_cache_add( ic, reply, jabber_pkt_bind_sess ); |
---|
[fe7a554] | 382 | |
---|
[0da65d5] | 383 | if( !jabber_write_packet( ic, reply ) ) |
---|
[fe7a554] | 384 | return XT_ABORT; |
---|
| 385 | |
---|
| 386 | jd->flags |= JFLAG_WAIT_SESSION; |
---|
| 387 | } |
---|
| 388 | |
---|
[8d74291] | 389 | /* This flag is already set if we authenticated via SASL, so now |
---|
[fe7a554] | 390 | we can resume the session in the new stream, if we don't have |
---|
| 391 | to bind/initialize the session. */ |
---|
| 392 | if( jd->flags & JFLAG_AUTHENTICATED && ( jd->flags & ( JFLAG_WAIT_BIND | JFLAG_WAIT_SESSION ) ) == 0 ) |
---|
[8d74291] | 393 | { |
---|
[0da65d5] | 394 | if( !jabber_get_roster( ic ) ) |
---|
[8d74291] | 395 | return XT_ABORT; |
---|
| 396 | } |
---|
| 397 | |
---|
| 398 | return XT_HANDLED; |
---|
| 399 | } |
---|
| 400 | |
---|
[42127dc] | 401 | static xt_status jabber_pkt_proceed_tls( struct xt_node *node, gpointer data ) |
---|
| 402 | { |
---|
[0da65d5] | 403 | struct im_connection *ic = data; |
---|
| 404 | struct jabber_data *jd = ic->proto_data; |
---|
[42127dc] | 405 | char *xmlns; |
---|
| 406 | |
---|
| 407 | xmlns = xt_find_attr( node, "xmlns" ); |
---|
| 408 | |
---|
| 409 | /* Just ignore it when it doesn't seem to be TLS-related (is that at |
---|
| 410 | all possible??). */ |
---|
[47d3ac4] | 411 | if( !xmlns || strcmp( xmlns, XMLNS_TLS ) != 0 ) |
---|
[42127dc] | 412 | return XT_HANDLED; |
---|
| 413 | |
---|
| 414 | /* We don't want event handlers to touch our TLS session while it's |
---|
| 415 | still initializing! */ |
---|
| 416 | b_event_remove( jd->r_inpa ); |
---|
| 417 | if( jd->tx_len > 0 ) |
---|
| 418 | { |
---|
| 419 | /* Actually the write queue should be empty here, but just |
---|
| 420 | to be sure... */ |
---|
| 421 | b_event_remove( jd->w_inpa ); |
---|
| 422 | g_free( jd->txq ); |
---|
| 423 | jd->txq = NULL; |
---|
| 424 | jd->tx_len = 0; |
---|
| 425 | } |
---|
| 426 | jd->w_inpa = jd->r_inpa = 0; |
---|
| 427 | |
---|
[84b045d] | 428 | imcb_log( ic, "Converting stream to TLS" ); |
---|
[42127dc] | 429 | |
---|
[0da65d5] | 430 | jd->ssl = ssl_starttls( jd->fd, jabber_connected_ssl, ic ); |
---|
[42127dc] | 431 | |
---|
| 432 | return XT_HANDLED; |
---|
| 433 | } |
---|
| 434 | |
---|
[b56b220] | 435 | static xt_status jabber_pkt_stream_error( struct xt_node *node, gpointer data ) |
---|
| 436 | { |
---|
[0da65d5] | 437 | struct im_connection *ic = data; |
---|
[c2fb3809] | 438 | int allow_reconnect = TRUE; |
---|
[1baaef8] | 439 | struct jabber_error *err; |
---|
[b56b220] | 440 | |
---|
[1baaef8] | 441 | err = jabber_error_parse( node, XMLNS_STREAM_ERROR ); |
---|
[b56b220] | 442 | |
---|
| 443 | /* Tssk... */ |
---|
[1baaef8] | 444 | if( err->code == NULL ) |
---|
[b56b220] | 445 | { |
---|
[84b045d] | 446 | imcb_error( ic, "Unknown stream error reported by server" ); |
---|
[c2fb3809] | 447 | imc_logout( ic, allow_reconnect ); |
---|
[1baaef8] | 448 | jabber_error_free( err ); |
---|
[b56b220] | 449 | return XT_ABORT; |
---|
| 450 | } |
---|
| 451 | |
---|
| 452 | /* We know that this is a fatal error. If it's a "conflict" error, we |
---|
| 453 | should turn off auto-reconnect to make sure we won't get some nasty |
---|
| 454 | infinite loop! */ |
---|
[1baaef8] | 455 | if( strcmp( err->code, "conflict" ) == 0 ) |
---|
[259edd4] | 456 | { |
---|
[84b045d] | 457 | imcb_error( ic, "Account and resource used from a different location" ); |
---|
[c2fb3809] | 458 | allow_reconnect = FALSE; |
---|
[259edd4] | 459 | } |
---|
| 460 | else |
---|
| 461 | { |
---|
[1baaef8] | 462 | imcb_error( ic, "Stream error: %s%s%s", err->code, err->text ? ": " : "", |
---|
| 463 | err->text ? err->text : "" ); |
---|
[259edd4] | 464 | } |
---|
[b56b220] | 465 | |
---|
[1baaef8] | 466 | jabber_error_free( err ); |
---|
[c2fb3809] | 467 | imc_logout( ic, allow_reconnect ); |
---|
[b56b220] | 468 | |
---|
| 469 | return XT_ABORT; |
---|
| 470 | } |
---|
| 471 | |
---|
[bb95d43] | 472 | static xt_status jabber_xmlconsole( struct xt_node *node, gpointer data ) |
---|
| 473 | { |
---|
| 474 | struct im_connection *ic = data; |
---|
| 475 | struct jabber_data *jd = ic->proto_data; |
---|
| 476 | |
---|
| 477 | if( jd->flags & JFLAG_XMLCONSOLE ) |
---|
| 478 | { |
---|
| 479 | char *msg, *pkt; |
---|
| 480 | |
---|
| 481 | pkt = xt_to_string( node ); |
---|
| 482 | msg = g_strdup_printf( "RX: %s", pkt ); |
---|
| 483 | imcb_buddy_msg( ic, JABBER_XMLCONSOLE_HANDLE, msg, 0, 0 ); |
---|
| 484 | g_free( msg ); |
---|
| 485 | g_free( pkt ); |
---|
| 486 | } |
---|
| 487 | |
---|
| 488 | return XT_NEXT; |
---|
| 489 | } |
---|
| 490 | |
---|
[21167d2] | 491 | static const struct xt_handler_entry jabber_handlers[] = { |
---|
[bb95d43] | 492 | { NULL, "stream:stream", jabber_xmlconsole }, |
---|
[21167d2] | 493 | { "stream:stream", "<root>", jabber_end_of_stream }, |
---|
| 494 | { "message", "stream:stream", jabber_pkt_message }, |
---|
| 495 | { "presence", "stream:stream", jabber_pkt_presence }, |
---|
[8d74291] | 496 | { "iq", "stream:stream", jabber_pkt_iq }, |
---|
| 497 | { "stream:features", "stream:stream", jabber_pkt_features }, |
---|
[b56b220] | 498 | { "stream:error", "stream:stream", jabber_pkt_stream_error }, |
---|
[42127dc] | 499 | { "proceed", "stream:stream", jabber_pkt_proceed_tls }, |
---|
[5997488] | 500 | { "challenge", "stream:stream", sasl_pkt_challenge }, |
---|
| 501 | { "success", "stream:stream", sasl_pkt_result }, |
---|
| 502 | { "failure", "stream:stream", sasl_pkt_result }, |
---|
[21167d2] | 503 | { NULL, NULL, NULL } |
---|
| 504 | }; |
---|
| 505 | |
---|
[0da65d5] | 506 | gboolean jabber_start_stream( struct im_connection *ic ) |
---|
[21167d2] | 507 | { |
---|
[0da65d5] | 508 | struct jabber_data *jd = ic->proto_data; |
---|
[21167d2] | 509 | int st; |
---|
| 510 | char *greet; |
---|
| 511 | |
---|
| 512 | /* We'll start our stream now, so prepare everything to receive one |
---|
| 513 | from the server too. */ |
---|
| 514 | xt_free( jd->xt ); /* In case we're RE-starting. */ |
---|
[0da65d5] | 515 | jd->xt = xt_new( ic ); |
---|
[21167d2] | 516 | jd->xt->handlers = (struct xt_handler_entry*) jabber_handlers; |
---|
| 517 | |
---|
[8d74291] | 518 | if( jd->r_inpa <= 0 ) |
---|
[0da65d5] | 519 | jd->r_inpa = b_input_add( jd->fd, GAIM_INPUT_READ, jabber_read_callback, ic ); |
---|
[21167d2] | 520 | |
---|
| 521 | greet = g_strdup_printf( "<?xml version='1.0' ?>" |
---|
| 522 | "<stream:stream to=\"%s\" xmlns=\"jabber:client\" " |
---|
[5997488] | 523 | "xmlns:stream=\"http://etherx.jabber.org/streams\" version=\"1.0\">", jd->server ); |
---|
[21167d2] | 524 | |
---|
[0da65d5] | 525 | st = jabber_write( ic, greet, strlen( greet ) ); |
---|
[21167d2] | 526 | |
---|
| 527 | g_free( greet ); |
---|
| 528 | |
---|
| 529 | return st; |
---|
| 530 | } |
---|
[4a0614e] | 531 | |
---|
[0da65d5] | 532 | void jabber_end_stream( struct im_connection *ic ) |
---|
[4a0614e] | 533 | { |
---|
[0da65d5] | 534 | struct jabber_data *jd = ic->proto_data; |
---|
[4a0614e] | 535 | |
---|
| 536 | /* Let's only do this if the queue is currently empty, otherwise it'd |
---|
| 537 | take too long anyway. */ |
---|
[5bcf70a] | 538 | if( jd->tx_len == 0 ) |
---|
| 539 | { |
---|
| 540 | char eos[] = "</stream:stream>"; |
---|
| 541 | struct xt_node *node; |
---|
[8d74291] | 542 | int st = 1; |
---|
[5bcf70a] | 543 | |
---|
[0da65d5] | 544 | if( ic->flags & OPT_LOGGED_IN ) |
---|
[8d74291] | 545 | { |
---|
| 546 | node = jabber_make_packet( "presence", "unavailable", NULL, NULL ); |
---|
[0da65d5] | 547 | st = jabber_write_packet( ic, node ); |
---|
[8d74291] | 548 | xt_free_node( node ); |
---|
| 549 | } |
---|
[5bcf70a] | 550 | |
---|
| 551 | if( st ) |
---|
[0da65d5] | 552 | jabber_write( ic, eos, strlen( eos ) ); |
---|
[5bcf70a] | 553 | } |
---|
[4a0614e] | 554 | } |
---|