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", "Cannot 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", "Cannot 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                 purple_signal_emit_return_1(purple_connections_get_handle(), "autojoin", gc);
 376
 377                 serv_set_permit_deny(gc);
 378
 379                 update_keepalive(gc, TRUE);
 380         }
 381         else if (gc->state == PURPLE_DISCONNECTED) {
 382                 PurpleAccount *account = purple_connection_get_account(gc);
 383
 384                 if (purple_prefs_get_bool("/purple/logging/log_system"))
 385                 {
 386                         PurpleLog *log = purple_account_get_log(account, FALSE);
 387
 388                         if (log != NULL)
 389                         {
 390                                 char *msg = g_strdup_printf(_("+++ %s signed off"),
 391                                                                                         purple_account_get_username(account));
 392                                 purple_log_write(log, PURPLE_MESSAGE_SYSTEM,
 393                                                            purple_account_get_username(account), time(NULL),
 394                                                            msg);
 395                                 g_free(msg);
 396                         }
 397                 }
 398
 399                 purple_account_destroy_log(account);
 400
 401                 if (ops != NULL && ops->disconnected != NULL)
 402                         ops->disconnected(gc);
 403         }
 404 }
 405
 406 void
 407 purple_connection_set_account(PurpleConnection *gc, PurpleAccount *account)
 408 {
 409         g_return_if_fail(gc != NULL);
 410         g_return_if_fail(account != NULL);
 411
 412         gc->account = account;
 413 }
 414
 415 void
 416 purple_connection_set_display_name(PurpleConnection *gc, const char *name)
 417 {
 418         g_return_if_fail(gc != NULL);
 419
 420         g_free(gc->display_name);
 421         gc->display_name = g_strdup(name);
 422 }
 423
 424 void
 425 purple_connection_set_protocol_data(PurpleConnection *connection, void *proto_data) {
 426         g_return_if_fail(connection != NULL);
 427
 428         connection->proto_data = proto_data;
 429 }
 430
 431 PurpleConnectionState
 432 purple_connection_get_state(const PurpleConnection *gc)
 433 {
 434         g_return_val_if_fail(gc != NULL, PURPLE_DISCONNECTED);
 435
 436         return gc->state;
 437 }
 438
 439 PurpleAccount *
 440 purple_connection_get_account(const PurpleConnection *gc)
 441 {
 442         g_return_val_if_fail(gc != NULL, NULL);
 443
 444         return gc->account;
 445 }
 446
 447 PurplePlugin *
 448 purple_connection_get_prpl(const PurpleConnection *gc)
 449 {
 450         g_return_val_if_fail(gc != NULL, NULL);
 451
 452         return gc->prpl;
 453 }
 454
 455 const char *
 456 purple_connection_get_password(const PurpleConnection *gc)
 457 {
 458         g_return_val_if_fail(gc != NULL, NULL);
 459
 460         return gc->password ? gc->password : gc->account->password;
 461 }
 462
 463 const char *
 464 purple_connection_get_display_name(const PurpleConnection *gc)
 465 {
 466         g_return_val_if_fail(gc != NULL, NULL);
 467
 468         return gc->display_name;
 469 }
 470
 471 void *
 472 purple_connection_get_protocol_data(const PurpleConnection *connection) {
 473         g_return_val_if_fail(connection != NULL, NULL);
 474
 475         return connection->proto_data;
 476 }
 477
 478 void
 479 purple_connection_update_progress(PurpleConnection *gc, const char *text,
 480                                                                 size_t step, size_t count)
 481 {
 482         PurpleConnectionUiOps *ops;
 483
 484         g_return_if_fail(gc   != NULL);
 485         g_return_if_fail(text != NULL);
 486         g_return_if_fail(step < count);
 487         g_return_if_fail(count > 1);
 488
 489         ops = purple_connections_get_ui_ops();
 490
 491         if (ops != NULL && ops->connect_progress != NULL)
 492                 ops->connect_progress(gc, text, step, count);
 493 }
 494
 495 void
 496 purple_connection_notice(PurpleConnection *gc, const char *text)
 497 {
 498         PurpleConnectionUiOps *ops;
 499
 500         g_return_if_fail(gc   != NULL);
 501         g_return_if_fail(text != NULL);
 502
 503         ops = purple_connections_get_ui_ops();
 504
 505         if (ops != NULL && ops->notice != NULL)
 506                 ops->notice(gc, text);
 507 }
 508
 509 static gboolean
 510 purple_connection_disconnect_cb(gpointer data)
 511 {
 512         PurpleAccount *account;
 513         PurpleConnection *gc;
 514         char *password;
 515
 516         account = data;
 517         gc = purple_account_get_connection(account);
 518
 519         if (gc != NULL)
 520                 gc->disconnect_timeout = 0;
 521
 522         password = g_strdup(purple_account_get_password(account));
 523         purple_account_disconnect(account);
 524         purple_account_set_password(account, password);
 525         g_free(password);
 526
 527         return FALSE;
 528 }
 529
 530 void
 531 purple_connection_error(PurpleConnection *gc, const char *text)
 532 {
 533         /* prpls that have not been updated to use disconnection reasons will
 534          * be setting wants_to_die before calling this function, so choose
 535          * PURPLE_CONNECTION_ERROR_OTHER_ERROR (which is fatal) if it's true,
 536          * and PURPLE_CONNECTION_ERROR_NETWORK_ERROR (which isn't) if not.  See
 537          * the documentation in connection.h.
 538          */
 539         PurpleConnectionError reason = gc->wants_to_die
 540                                      ? PURPLE_CONNECTION_ERROR_OTHER_ERROR
 541                                      : PURPLE_CONNECTION_ERROR_NETWORK_ERROR;
 542         purple_connection_error_reason (gc, reason, text);
 543 }
 544
 545 void
 546 purple_connection_error_reason (PurpleConnection *gc,
 547                                 PurpleConnectionError reason,
 548                                 const char *description)
 549 {
 550         PurpleConnectionUiOps *ops;
 551
 552         g_return_if_fail(gc   != NULL);
 553         /* This sanity check relies on PURPLE_CONNECTION_ERROR_OTHER_ERROR
 554          * being the last member of the PurpleConnectionError enum in
 555          * connection.h; if other reasons are added after it, this check should
 556          * be updated.
 557          */
 558         if (reason > PURPLE_CONNECTION_ERROR_OTHER_ERROR) {
 559                 purple_debug_error("connection",
 560                         "purple_connection_error_reason: reason %u isn't a "
 561                         "valid reason\n", reason);
 562                 reason = PURPLE_CONNECTION_ERROR_OTHER_ERROR;
 563         }
 564
 565         if (description == NULL) {
 566                 purple_debug_error("connection", "purple_connection_error_reason called with NULL description\n");
 567                 description = _("Unknown error");
 568         }
 569
 570         /* If we've already got one error, we don't need any more */
 571         if (gc->disconnect_timeout > 0)
 572                 return;
 573
 574         gc->wants_to_die = purple_connection_error_is_fatal (reason);
 575
 576         purple_debug_info("connection", "Connection error on %p (reason: %u description: %s)\n",
 577                           gc, reason, description);
 578
 579         ops = purple_connections_get_ui_ops();
 580
 581         if (ops != NULL)
 582         {
 583                 if (ops->report_disconnect_reason != NULL)
 584                         ops->report_disconnect_reason (gc, reason, description);
 585                 if (ops->report_disconnect != NULL)
 586                         ops->report_disconnect (gc, description);
 587         }
 588
 589         purple_signal_emit(purple_connections_get_handle(), "connection-error",
 590                 gc, reason, description);
 591
 592         gc->disconnect_timeout = purple_timeout_add(0, purple_connection_disconnect_cb,
 593                         purple_connection_get_account(gc));
 594 }
 595
 596 void
 597 purple_connection_ssl_error (PurpleConnection *gc,
 598                              PurpleSslErrorType ssl_error)
 599 {
 600         PurpleConnectionError reason;
 601
 602         switch (ssl_error) {
 603                 case PURPLE_SSL_HANDSHAKE_FAILED:
 604                         reason = PURPLE_CONNECTION_ERROR_ENCRYPTION_ERROR;
 605                         break;
 606                 case PURPLE_SSL_CONNECT_FAILED:
 607                         reason = PURPLE_CONNECTION_ERROR_NETWORK_ERROR;
 608                         break;
 609                 case PURPLE_SSL_CERTIFICATE_INVALID:
 610                         /* TODO: maybe PURPLE_SSL_* should be more specific? */
 611                         reason = PURPLE_CONNECTION_ERROR_CERT_OTHER_ERROR;
 612                         break;
 613                 default:
 614                         g_assert_not_reached ();
 615                         reason = PURPLE_CONNECTION_ERROR_CERT_OTHER_ERROR;
 616         }
 617
 618         purple_connection_error_reason (gc, reason,
 619                 purple_ssl_strerror(ssl_error));
 620 }
 621
 622 gboolean
 623 purple_connection_error_is_fatal (PurpleConnectionError reason)
 624 {
 625         switch (reason)
 626         {
 627                 case PURPLE_CONNECTION_ERROR_NETWORK_ERROR:
 628                 case PURPLE_CONNECTION_ERROR_ENCRYPTION_ERROR:
 629                         return FALSE;
 630                 case PURPLE_CONNECTION_ERROR_INVALID_USERNAME:
 631                 case PURPLE_CONNECTION_ERROR_AUTHENTICATION_FAILED:
 632                 case PURPLE_CONNECTION_ERROR_AUTHENTICATION_IMPOSSIBLE:
 633                 case PURPLE_CONNECTION_ERROR_NO_SSL_SUPPORT:
 634                 case PURPLE_CONNECTION_ERROR_NAME_IN_USE:
 635                 case PURPLE_CONNECTION_ERROR_INVALID_SETTINGS:
 636                 case PURPLE_CONNECTION_ERROR_OTHER_ERROR:
 637                 case PURPLE_CONNECTION_ERROR_CERT_NOT_PROVIDED:
 638                 case PURPLE_CONNECTION_ERROR_CERT_UNTRUSTED:
 639                 case PURPLE_CONNECTION_ERROR_CERT_EXPIRED:
 640                 case PURPLE_CONNECTION_ERROR_CERT_NOT_ACTIVATED:
 641                 case PURPLE_CONNECTION_ERROR_CERT_HOSTNAME_MISMATCH:
 642                 case PURPLE_CONNECTION_ERROR_CERT_FINGERPRINT_MISMATCH:
 643                 case PURPLE_CONNECTION_ERROR_CERT_SELF_SIGNED:
 644                 case PURPLE_CONNECTION_ERROR_CERT_OTHER_ERROR:
 645                         return TRUE;
 646                 default:
 647                         g_return_val_if_reached(TRUE);
 648         }
 649 }
 650
 651 void
 652 purple_connections_disconnect_all(void)
 653 {
 654         GList *l;
 655         PurpleConnection *gc;
 656
 657         while ((l = purple_connections_get_all()) != NULL) {
 658                 gc = l->data;
 659                 gc->wants_to_die = TRUE;
 660                 purple_account_disconnect(gc->account);
 661         }
 662 }
 663
 664 GList *
 665 purple_connections_get_all(void)
 666 {
 667         return connections;
 668 }
 669
 670 GList *
 671 purple_connections_get_connecting(void)
 672 {
 673         return connections_connecting;
 674 }
 675
 676 void
 677 purple_connections_set_ui_ops(PurpleConnectionUiOps *ops)
 678 {
 679         connection_ui_ops = ops;
 680 }
 681
 682 PurpleConnectionUiOps *
 683 purple_connections_get_ui_ops(void)
 684 {
 685         return connection_ui_ops;
 686 }
 687
 688 void
 689 purple_connections_init(void)
 690 {
 691         void *handle = purple_connections_get_handle();
 692
 693         purple_signal_register(handle, "signing-on",
 694                                                  purple_marshal_VOID__POINTER, NULL, 1,
 695                                                  purple_value_new(PURPLE_TYPE_SUBTYPE,
 696                                                                                 PURPLE_SUBTYPE_CONNECTION));
 697
 698         purple_signal_register(handle, "signed-on",
 699                                                  purple_marshal_VOID__POINTER, NULL, 1,
 700                                                  purple_value_new(PURPLE_TYPE_SUBTYPE,
 701                                                                                 PURPLE_SUBTYPE_CONNECTION));
 702
 703         purple_signal_register(handle, "signing-off",
 704                                                  purple_marshal_VOID__POINTER, NULL, 1,
 705                                                  purple_value_new(PURPLE_TYPE_SUBTYPE,
 706                                                                                 PURPLE_SUBTYPE_CONNECTION));
 707
 708         purple_signal_register(handle, "signed-off",
 709                                                  purple_marshal_VOID__POINTER, NULL, 1,
 710                                                  purple_value_new(PURPLE_TYPE_SUBTYPE,
 711                                                                                 PURPLE_SUBTYPE_CONNECTION));
 712
 713         purple_signal_register(handle, "connection-error",
 714                                purple_marshal_VOID__POINTER_INT_POINTER, NULL, 3,
 715                                purple_value_new(PURPLE_TYPE_SUBTYPE,
 716                                                 PURPLE_SUBTYPE_CONNECTION),
 717                                purple_value_new(PURPLE_TYPE_ENUM),
 718                                purple_value_new(PURPLE_TYPE_STRING));
 719
 720         purple_signal_register(handle, "autojoin",
 721                                purple_marshal_BOOLEAN__POINTER, NULL, 1,
 722                                purple_value_new(PURPLE_TYPE_SUBTYPE,
 723                                                 PURPLE_SUBTYPE_CONNECTION));
 724
 725 }
 726
 727 void
 728 purple_connections_uninit(void)
 729 {
 730         purple_signals_unregister_by_instance(purple_connections_get_handle());
 731 }
 732
 733 void *
 734 purple_connections_get_handle(void)
 735 {
 736         return &connections_handle;
 737 }