libpurple/connection.c

   1 /**
   2  * @file connection.c Connection API
   3  * @ingroup core
   4  */
   5
   6 /* purple
   7  *
   8  * Purple is the legal property of its developers, whose names are too numerous
   9  * to list here.  Please refer to the COPYRIGHT file distributed with this
  10  * source distribution.
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  25  */
  26 #define _PURPLE_CONNECTION_C_
  27
  28 #include "internal.h"
  29 #include "account.h"
  30 #include "blist.h"
  31 #include "connection.h"
  32 #include "dbus-maybe.h"
  33 #include "debug.h"
  34 #include "log.h"
  35 #include "notify.h"
  36 #include "prefs.h"
  37 #include "proxy.h"
  38 #include "request.h"
  39 #include "server.h"
  40 #include "signals.h"
  41 #include "util.h"
  42
  43 #define KEEPALIVE_INTERVAL 30
  44
  45 static GList *connections = NULL;
  46 static GList *connections_connecting = NULL;
  47 static PurpleConnectionUiOps *connection_ui_ops = NULL;
  48
  49 static int connections_handle;
  50
  51 static gboolean
  52 send_keepalive(gpointer data)
  53 {
  54         PurpleConnection *gc = data;
  55         PurplePluginProtocolInfo *prpl_info;
  56
  57         /* Only send keep-alives if we haven't heard from the
  58          * server in a while.
  59          */
  60         if ((time(NULL) - gc->last_received) < KEEPALIVE_INTERVAL)
  61                 return TRUE;
  62
  63         prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
  64         if (prpl_info->keepalive)
  65                 prpl_info->keepalive(gc);
  66
  67         return TRUE;
  68 }
  69
  70 static void
  71 update_keepalive(PurpleConnection *gc, gboolean on)
  72 {
  73         PurplePluginProtocolInfo *prpl_info = NULL;
  74
  75         if (gc != NULL && gc->prpl != NULL)
  76                 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
  77
  78         if (!prpl_info || !prpl_info->keepalive)
  79                 return;
  80
  81         if (on && !gc->keepalive)
  82         {
  83                 purple_debug_info("connection", "Activating keepalive.\n");
  84                 gc->keepalive = purple_timeout_add_seconds(KEEPALIVE_INTERVAL, send_keepalive, gc);
  85         }
  86         else if (!on && gc->keepalive > 0)
  87         {
  88                 purple_debug_info("connection", "Deactivating keepalive.\n");
  89                 purple_timeout_remove(gc->keepalive);
  90                 gc->keepalive = 0;
  91         }
  92 }
  93
  94 void
  95 purple_connection_new(PurpleAccount *account, gboolean regist, const char *password)
  96 {
  97         _purple_connection_new(account, regist, password);
  98 }
  99
 100 void
 101 _purple_connection_new(PurpleAccount *account, gboolean regist, const char *password)
 102 {
 103         PurpleConnection *gc;
 104         PurplePlugin *prpl;
 105         PurplePluginProtocolInfo *prpl_info;
 106
 107         g_return_if_fail(account != NULL);
 108
 109         if (!purple_account_is_disconnected(account))
 110                 return;
 111
 112         prpl = purple_find_prpl(purple_account_get_protocol_id(account));
 113
 114         if (prpl != NULL)
 115                 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
 116         else {
 117                 gchar *message;
 118
 119                 message = g_strdup_printf(_("Missing protocol plugin for %s"),
 120                         purple_account_get_username(account));
 121                 purple_notify_error(NULL, regist ? _("Registration Error") :
 122                                                   _("Connection Error"), message, NULL);
 123                 g_free(message);
 124                 return;
 125         }
 126
 127         if (regist)
 128         {
 129                 if (prpl_info->register_user == NULL)
 130                         return;
 131         }
 132         else
 133         {
 134                 if (((password == NULL) || (*password == '\0')) &&
 135                         !(prpl_info->options & OPT_PROTO_NO_PASSWORD) &&
 136                         !(prpl_info->options & OPT_PROTO_PASSWORD_OPTIONAL))
 137                 {
 138                         purple_debug_error("connection", "Can not connect to account %s without "
 139                                                          "a password.\n", purple_account_get_username(account));
 140                         return;
 141                 }
 142         }
 143
 144         gc = g_new0(PurpleConnection, 1);
 145         PURPLE_DBUS_REGISTER_POINTER(gc, PurpleConnection);
 146
 147         gc->prpl = prpl;
 148         if ((password != NULL) && (*password != '\0'))
 149                 gc->password = g_strdup(password);
 150         purple_connection_set_account(gc, account);
 151         purple_connection_set_state(gc, PURPLE_CONNECTING);
 152         connections = g_list_append(connections, gc);
 153         purple_account_set_connection(account, gc);
 154
 155         purple_signal_emit(purple_connections_get_handle(), "signing-on", gc);
 156
 157         if (regist)
 158         {
 159                 purple_debug_info("connection", "Registering.  gc = %p\n", gc);
 160
 161                 /* set this so we don't auto-reconnect after registering */
 162                 gc->wants_to_die = TRUE;
 163
 164                 prpl_info->register_user(account);
 165         }
 166         else
 167         {
 168                 purple_debug_info("connection", "Connecting. gc = %p\n", gc);
 169
 170                 purple_signal_emit(purple_accounts_get_handle(), "account-connecting", account);
 171                 prpl_info->login(account);
 172         }
 173 }
 174 void
 175 purple_connection_new_unregister(PurpleAccount *account, const char *password, PurpleAccountUnregistrationCb cb, void *user_data)
 176 {
 177         _purple_connection_new_unregister(account, password, cb, user_data);
 178 }
 179
 180 void
 181 _purple_connection_new_unregister(PurpleAccount *account, const char *password, PurpleAccountUnregistrationCb cb, void *user_data)
 182 {
 183         /* Lots of copy/pasted code to avoid API changes. You might want to integrate that into the previous function when posssible. */
 184         PurpleConnection *gc;
 185         PurplePlugin *prpl;
 186         PurplePluginProtocolInfo *prpl_info;
 187
 188         g_return_if_fail(account != NULL);
 189
 190         prpl = purple_find_prpl(purple_account_get_protocol_id(account));
 191
 192         if (prpl != NULL)
 193                 prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(prpl);
 194         else {
 195                 gchar *message;
 196
 197                 message = g_strdup_printf(_("Missing protocol plugin for %s"),
 198                                                                   purple_account_get_username(account));
 199                 purple_notify_error(NULL, _("Unregistration Error"), message, NULL);
 200                 g_free(message);
 201                 return;
 202         }
 203
 204         if (!purple_account_is_disconnected(account)) {
 205                 prpl_info->unregister_user(account, cb, user_data);
 206                 return;
 207         }
 208
 209         if (((password == NULL) || (*password == '\0')) &&
 210                 !(prpl_info->options & OPT_PROTO_NO_PASSWORD) &&
 211                 !(prpl_info->options & OPT_PROTO_PASSWORD_OPTIONAL))
 212         {
 213                 purple_debug_error("connection", "Can not connect to account %s without "
 214                                                    "a password.\n", purple_account_get_username(account));
 215                 return;
 216         }
 217
 218         gc = g_new0(PurpleConnection, 1);
 219         PURPLE_DBUS_REGISTER_POINTER(gc, PurpleConnection);
 220
 221         gc->prpl = prpl;
 222         if ((password != NULL) && (*password != '\0'))
 223                 gc->password = g_strdup(password);
 224         purple_connection_set_account(gc, account);
 225         purple_connection_set_state(gc, PURPLE_CONNECTING);
 226         connections = g_list_append(connections, gc);
 227         purple_account_set_connection(account, gc);
 228
 229         purple_signal_emit(purple_connections_get_handle(), "signing-on", gc);
 230
 231         purple_debug_info("connection", "Unregistering.  gc = %p\n", gc);
 232
 233         prpl_info->unregister_user(account, cb, user_data);
 234 }
 235
 236 void
 237 purple_connection_destroy(PurpleConnection *gc)
 238 {
 239         _purple_connection_destroy(gc);
 240 }
 241
 242 void
 243 _purple_connection_destroy(PurpleConnection *gc)
 244 {
 245         PurpleAccount *account;
 246         GSList *buddies;
 247         PurplePluginProtocolInfo *prpl_info = NULL;
 248         gboolean remove = FALSE;
 249
 250         g_return_if_fail(gc != NULL);
 251
 252         account = purple_connection_get_account(gc);
 253
 254         purple_debug_info("connection", "Disconnecting connection %p\n", gc);
 255
 256         if (purple_connection_get_state(gc) != PURPLE_CONNECTING)
 257                 remove = TRUE;
 258
 259         purple_signal_emit(purple_connections_get_handle(), "signing-off", gc);
 260
 261         while (gc->buddy_chats)
 262         {
 263                 PurpleConversation *b = gc->buddy_chats->data;
 264
 265                 gc->buddy_chats = g_slist_remove(gc->buddy_chats, b);
 266                 purple_conv_chat_left(PURPLE_CONV_CHAT(b));
 267         }
 268
 269         update_keepalive(gc, FALSE);
 270
 271         purple_proxy_connect_cancel_with_handle(gc);
 272
 273         prpl_info = PURPLE_PLUGIN_PROTOCOL_INFO(gc->prpl);
 274         if (prpl_info->close)
 275                 (prpl_info->close)(gc);
 276
 277         /* Clear out the proto data that was freed in the prpl close method*/
 278         buddies = purple_find_buddies(account, NULL);
 279         while (buddies != NULL) {
 280                 PurpleBuddy *buddy = buddies->data;
 281                 purple_buddy_set_protocol_data(buddy, NULL);
 282                 buddies = g_slist_delete_link(buddies, buddies);
 283         }
 284
 285         connections = g_list_remove(connections, gc);
 286
 287         purple_connection_set_state(gc, PURPLE_DISCONNECTED);
 288
 289         if (remove)
 290                 purple_blist_remove_account(account);
 291
 292         purple_signal_emit(purple_connections_get_handle(), "signed-off", gc);
 293
 294         purple_account_request_close_with_account(account);
 295         purple_request_close_with_handle(gc);
 296         purple_notify_close_with_handle(gc);
 297
 298         purple_debug_info("connection", "Destroying connection %p\n", gc);
 299
 300         purple_account_set_connection(account, NULL);
 301
 302         g_free(gc->password);
 303         g_free(gc->display_name);
 304
 305         if (gc->disconnect_timeout > 0)
 306                 purple_timeout_remove(gc->disconnect_timeout);
 307
 308         PURPLE_DBUS_UNREGISTER_POINTER(gc);
 309         g_free(gc);
 310 }
 311
 312 /*
 313  * d:)->-<
 314  *
 315  * d:O-\-<
 316  *
 317  * d:D-/-<
 318  *
 319  * d8D->-< DANCE!
 320  */
 321
 322 void
 323 purple_connection_set_state(PurpleConnection *gc, PurpleConnectionState state)
 324 {
 325         PurpleConnectionUiOps *ops;
 326
 327         g_return_if_fail(gc != NULL);
 328
 329         if (gc->state == state)
 330                 return;
 331
 332         gc->state = state;
 333
 334         ops = purple_connections_get_ui_ops();
 335
 336         if (gc->state == PURPLE_CONNECTING) {
 337                 connections_connecting = g_list_append(connections_connecting, gc);
 338         }
 339         else {
 340                 connections_connecting = g_list_remove(connections_connecting, gc);
 341         }
 342
 343         if (gc->state == PURPLE_CONNECTED) {
 344                 PurpleAccount *account;
 345                 PurplePresence *presence;
 346
 347                 account = purple_connection_get_account(gc);
 348                 presence = purple_account_get_presence(account);
 349
 350                 /* Set the time the account came online */
 351                 purple_presence_set_login_time(presence, time(NULL));
 352
 353                 if (purple_prefs_get_bool("/purple/logging/log_system"))
 354                 {
 355                         PurpleLog *log = purple_account_get_log(account, TRUE);
 356
 357                         if (log != NULL)
 358                         {
 359                                 char *msg = g_strdup_printf(_("+++ %s signed on"),
 360                                                                                         purple_account_get_username(account));
 361                                 purple_log_write(log, PURPLE_MESSAGE_SYSTEM,
 362                                                            purple_account_get_username(account),
 363                                                            purple_presence_get_login_time(presence),
 364                                                            msg);
 365                                 g_free(msg);
 366                         }
 367                 }
 368
 369                 if (ops != NULL && ops->connected != NULL)
 370                         ops->connected(gc);
 371
 372                 purple_blist_add_account(account);
 373
 374                 purple_signal_emit(purple_connections_get_handle(), "signed-on", gc);
 375
 376                 serv_set_permit_deny(gc);
 377
 378                 update_keepalive(gc, TRUE);
 379         }
 380         else if (gc->state == PURPLE_DISCONNECTED) {
 381                 PurpleAccount *account = purple_connection_get_account(gc);
 382
 383                 if (purple_prefs_get_bool("/purple/logging/log_system"))
 384                 {
 385                         PurpleLog *log = purple_account_get_log(account, FALSE);
 386
 387                         if (log != NULL)
 388                         {
 389                                 char *msg = g_strdup_printf(_("+++ %s signed off"),
 390                                                                                         purple_account_get_username(account));
 391                                 purple_log_write(log, PURPLE_MESSAGE_SYSTEM,
 392                                                            purple_account_get_username(account), time(NULL),
 393                                                            msg);
 394                                 g_free(msg);
 395                         }
 396                 }
 397
 398                 purple_account_destroy_log(account);
 399
 400                 if (ops != NULL && ops->disconnected != NULL)
 401                         ops->disconnected(gc);
 402         }
 403 }
 404
 405 void
 406 purple_connection_set_account(PurpleConnection *gc, PurpleAccount *account)
 407 {
 408         g_return_if_fail(gc != NULL);
 409         g_return_if_fail(account != NULL);
 410
 411         gc->account = account;
 412 }
 413
 414 void
 415 purple_connection_set_display_name(PurpleConnection *gc, const char *name)
 416 {
 417         g_return_if_fail(gc != NULL);
 418
 419         g_free(gc->display_name);
 420         gc->display_name = g_strdup(name);
 421 }
 422
 423 void
 424 purple_connection_set_protocol_data(PurpleConnection *connection, void *proto_data) {
 425         g_return_if_fail(connection != NULL);
 426
 427         connection->proto_data = proto_data;
 428 }
 429
 430 PurpleConnectionState
 431 purple_connection_get_state(const PurpleConnection *gc)
 432 {
 433         g_return_val_if_fail(gc != NULL, PURPLE_DISCONNECTED);
 434
 435         return gc->state;
 436 }
 437
 438 PurpleAccount *
 439 purple_connection_get_account(const PurpleConnection *gc)
 440 {
 441         g_return_val_if_fail(gc != NULL, NULL);
 442
 443         return gc->account;
 444 }
 445
 446 PurplePlugin *
 447 purple_connection_get_prpl(const PurpleConnection *gc)
 448 {
 449         g_return_val_if_fail(gc != NULL, NULL);
 450
 451         return gc->prpl;
 452 }
 453
 454 const char *
 455 purple_connection_get_password(const PurpleConnection *gc)
 456 {
 457         g_return_val_if_fail(gc != NULL, NULL);
 458
 459         return gc->password ? gc->password : gc->account->password;
 460 }
 461
 462 const char *
 463 purple_connection_get_display_name(const PurpleConnection *gc)
 464 {
 465         g_return_val_if_fail(gc != NULL, NULL);
 466
 467         return gc->display_name;
 468 }
 469
 470 void *
 471 purple_connection_get_protocol_data(const PurpleConnection *connection) {
 472         g_return_val_if_fail(connection != NULL, NULL);
 473
 474         return connection->proto_data;
 475 }
 476
 477 void
 478 purple_connection_update_progress(PurpleConnection *gc, const char *text,
 479                                                                 size_t step, size_t count)
 480 {
 481         PurpleConnectionUiOps *ops;
 482
 483         g_return_if_fail(gc   != NULL);
 484         g_return_if_fail(text != NULL);
 485         g_return_if_fail(step < count);
 486         g_return_if_fail(count > 1);
 487
 488         ops = purple_connections_get_ui_ops();
 489
 490         if (ops != NULL && ops->connect_progress != NULL)
 491                 ops->connect_progress(gc, text, step, count);
 492 }
 493
 494 void
 495 purple_connection_notice(PurpleConnection *gc, const char *text)
 496 {
 497         PurpleConnectionUiOps *ops;
 498
 499         g_return_if_fail(gc   != NULL);
 500         g_return_if_fail(text != NULL);
 501
 502         ops = purple_connections_get_ui_ops();
 503
 504         if (ops != NULL && ops->notice != NULL)
 505                 ops->notice(gc, text);
 506 }
 507
 508 static gboolean
 509 purple_connection_disconnect_cb(gpointer data)
 510 {
 511         PurpleAccount *account;
 512         PurpleConnection *gc;
 513         char *password;
 514
 515         account = data;
 516         gc = purple_account_get_connection(account);
 517
 518         gc->disconnect_timeout = 0;
 519
 520         password = g_strdup(purple_account_get_password(account));
 521         purple_account_disconnect(account);
 522         purple_account_set_password(account, password);
 523         g_free(password);
 524
 525         return FALSE;
 526 }
 527
 528 void
 529 purple_connection_error(PurpleConnection *gc, const char *text)
 530 {
 531         /* prpls that have not been updated to use disconnection reasons will
 532          * be setting wants_to_die before calling this function, so choose
 533          * PURPLE_CONNECTION_ERROR_OTHER_ERROR (which is fatal) if it's true,
 534          * and PURPLE_CONNECTION_ERROR_NETWORK_ERROR (which isn't) if not.  See
 535          * the documentation in connection.h.
 536          */
 537         PurpleConnectionError reason = gc->wants_to_die
 538                                      ? PURPLE_CONNECTION_ERROR_OTHER_ERROR
 539                                      : PURPLE_CONNECTION_ERROR_NETWORK_ERROR;
 540         purple_connection_error_reason (gc, reason, text);
 541 }
 542
 543 void
 544 purple_connection_error_reason (PurpleConnection *gc,
 545                                 PurpleConnectionError reason,
 546                                 const char *description)
 547 {
 548         PurpleConnectionUiOps *ops;
 549
 550         g_return_if_fail(gc   != NULL);
 551         /* This sanity check relies on PURPLE_CONNECTION_ERROR_OTHER_ERROR
 552          * being the last member of the PurpleConnectionError enum in
 553          * connection.h; if other reasons are added after it, this check should
 554          * be updated.
 555          */
 556         if (reason > PURPLE_CONNECTION_ERROR_OTHER_ERROR) {
 557                 purple_debug_error("connection",
 558                         "purple_connection_error_reason: reason %u isn't a "
 559                         "valid reason\n", reason);
 560                 reason = PURPLE_CONNECTION_ERROR_OTHER_ERROR;
 561         }
 562
 563         if (description == NULL) {
 564                 purple_debug_error("connection", "purple_connection_error_reason called with NULL description\n");
 565                 description = _("Unknown error");
 566         }
 567
 568         /* If we've already got one error, we don't need any more */
 569         if (gc->disconnect_timeout > 0)
 570                 return;
 571
 572         gc->wants_to_die = purple_connection_error_is_fatal (reason);
 573
 574         purple_debug_info("connection", "Connection error on %p (reason: %u description: %s)\n",
 575                           gc, reason, description);
 576
 577         ops = purple_connections_get_ui_ops();
 578
 579         if (ops != NULL)
 580         {
 581                 if (ops->report_disconnect_reason != NULL)
 582                         ops->report_disconnect_reason (gc, reason, description);
 583                 if (ops->report_disconnect != NULL)
 584                         ops->report_disconnect (gc, description);
 585         }
 586
 587         purple_signal_emit(purple_connections_get_handle(), "connection-error",
 588                 gc, reason, description);
 589
 590         gc->disconnect_timeout = purple_timeout_add(0, purple_connection_disconnect_cb,
 591                         purple_connection_get_account(gc));
 592 }
 593
 594 void
 595 purple_connection_ssl_error (PurpleConnection *gc,
 596                              PurpleSslErrorType ssl_error)
 597 {
 598         PurpleConnectionError reason;
 599
 600         switch (ssl_error) {
 601                 case PURPLE_SSL_HANDSHAKE_FAILED:
 602                         reason = PURPLE_CONNECTION_ERROR_ENCRYPTION_ERROR;
 603                         break;
 604                 case PURPLE_SSL_CONNECT_FAILED:
 605                         reason = PURPLE_CONNECTION_ERROR_NETWORK_ERROR;
 606                         break;
 607                 case PURPLE_SSL_CERTIFICATE_INVALID:
 608                         /* TODO: maybe PURPLE_SSL_* should be more specific? */
 609                         reason = PURPLE_CONNECTION_ERROR_CERT_OTHER_ERROR;
 610                         break;
 611                 default:
 612                         g_assert_not_reached ();
 613                         reason = PURPLE_CONNECTION_ERROR_CERT_OTHER_ERROR;
 614         }
 615
 616         purple_connection_error_reason (gc, reason,
 617                 purple_ssl_strerror(ssl_error));
 618 }
 619
 620 gboolean
 621 purple_connection_error_is_fatal (PurpleConnectionError reason)
 622 {
 623         switch (reason)
 624         {
 625                 case PURPLE_CONNECTION_ERROR_NETWORK_ERROR:
 626                 case PURPLE_CONNECTION_ERROR_ENCRYPTION_ERROR:
 627                         return FALSE;
 628                 case PURPLE_CONNECTION_ERROR_INVALID_USERNAME:
 629                 case PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED:
 630                 case PURPLE_CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE:
 631                 case PURPLE_CONNECTION_ERROR_NO_SSL_SUPPORT:
 632                 case PURPLE_CONNECTION_ERROR_NAME_IN_USE:
 633                 case PURPLE_CONNECTION_ERROR_INVALID_SETTINGS:
 634                 case PURPLE_CONNECTION_ERROR_OTHER_ERROR:
 635                 case PURPLE_CONNECTION_ERROR_CERT_NOT_PROVIDED:
 636                 case PURPLE_CONNECTION_ERROR_CERT_UNTRUSTED:
 637                 case PURPLE_CONNECTION_ERROR_CERT_EXPIRED:
 638                 case PURPLE_CONNECTION_ERROR_CERT_NOT_ACTIVATED:
 639                 case PURPLE_CONNECTION_ERROR_CERT_HOSTNAME_MISMATCH:
 640                 case PURPLE_CONNECTION_ERROR_CERT_FINGERPRINT_MISMATCH:
 641                 case PURPLE_CONNECTION_ERROR_CERT_SELF_SIGNED:
 642                 case PURPLE_CONNECTION_ERROR_CERT_OTHER_ERROR:
 643                         return TRUE;
 644                 default:
 645                         g_return_val_if_reached(TRUE);
 646         }
 647 }
 648
 649 void
 650 purple_connections_disconnect_all(void)
 651 {
 652         GList *l;
 653         PurpleConnection *gc;
 654
 655         while ((l = purple_connections_get_all()) != NULL) {
 656                 gc = l->data;
 657                 gc->wants_to_die = TRUE;
 658                 purple_account_disconnect(gc->account);
 659         }
 660 }
 661
 662 GList *
 663 purple_connections_get_all(void)
 664 {
 665         return connections;
 666 }
 667
 668 GList *
 669 purple_connections_get_connecting(void)
 670 {
 671         return connections_connecting;
 672 }
 673
 674 void
 675 purple_connections_set_ui_ops(PurpleConnectionUiOps *ops)
 676 {
 677         connection_ui_ops = ops;
 678 }
 679
 680 PurpleConnectionUiOps *
 681 purple_connections_get_ui_ops(void)
 682 {
 683         return connection_ui_ops;
 684 }
 685
 686 void
 687 purple_connections_init(void)
 688 {
 689         void *handle = purple_connections_get_handle();
 690
 691         purple_signal_register(handle, "signing-on",
 692                                                  purple_marshal_VOID__POINTER, NULL, 1,
 693                                                  purple_value_new(PURPLE_TYPE_SUBTYPE,
 694                                                                                 PURPLE_SUBTYPE_CONNECTION));
 695
 696         purple_signal_register(handle, "signed-on",
 697                                                  purple_marshal_VOID__POINTER, NULL, 1,
 698                                                  purple_value_new(PURPLE_TYPE_SUBTYPE,
 699                                                                                 PURPLE_SUBTYPE_CONNECTION));
 700
 701         purple_signal_register(handle, "signing-off",
 702                                                  purple_marshal_VOID__POINTER, NULL, 1,
 703                                                  purple_value_new(PURPLE_TYPE_SUBTYPE,
 704                                                                                 PURPLE_SUBTYPE_CONNECTION));
 705
 706         purple_signal_register(handle, "signed-off",
 707                                                  purple_marshal_VOID__POINTER, NULL, 1,
 708                                                  purple_value_new(PURPLE_TYPE_SUBTYPE,
 709                                                                                 PURPLE_SUBTYPE_CONNECTION));
 710
 711         purple_signal_register(handle, "connection-error",
 712                                purple_marshal_VOID__POINTER_INT_POINTER, NULL, 3,
 713                                purple_value_new(PURPLE_TYPE_SUBTYPE,
 714                                                 PURPLE_SUBTYPE_CONNECTION),
 715                                purple_value_new(PURPLE_TYPE_ENUM),
 716                                purple_value_new(PURPLE_TYPE_STRING));
 717
 718 }
 719
 720 void
 721 purple_connections_uninit(void)
 722 {
 723         purple_signals_unregister_by_instance(purple_connections_get_handle());
 724 }
 725
 726 void *
 727 purple_connections_get_handle(void)
 728 {
 729         return &connections_handle;
 730 }