?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merged default into xdg-dirs
[pidgin-git.git] / libpurple / account.c
blobbcbaa5a74d6242665602a9faf78a9954cec5468c
1 /* purple
2 *
3 * Purple is the legal property of its developers, whose names are too numerous
4 * to list here. Please refer to the COPYRIGHT file distributed with this
5 * source distribution.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
20 */
21 #include "internal.h"
22 #include "glibcompat.h"
23
24 #include "accounts.h"
25 #include "core.h"
26 #include "dbus-maybe.h"
27 #include "debug.h"
28 #include "network.h"
29 #include "notify.h"
30 #include "pounce.h"
31 #include "prefs.h"
32 #include "request.h"
33 #include "server.h"
34 #include "signals.h"
35 #include "util.h"
36
37 #define PURPLE_ACCOUNT_GET_PRIVATE(obj) \
38 (G_TYPE_INSTANCE_GET_PRIVATE((obj), PURPLE_TYPE_ACCOUNT, PurpleAccountPrivate))
39
40 typedef struct
41 {
42 char *username; /* The username. */
43 char *alias; /* How you appear to yourself. */
44 char *password; /* The account password. */
45 char *user_info; /* User information. */
46
47 char *buddy_icon_path; /* The buddy icon's non-cached path. */
48
49 gboolean remember_pass; /* Remember the password. */
50
51 /*
52 * TODO: After a GObject representing a protocol is ready, use it
53 * here instead of the protocol ID.
54 */
55 char *protocol_id; /* The ID of the protocol. */
56
57 PurpleConnection *gc; /* The connection handle. */
58 gboolean disconnecting; /* The account is currently disconnecting */
59
60 GHashTable *settings; /* Protocol-specific settings. */
61 GHashTable *ui_settings; /* UI-specific settings. */
62
63 PurpleProxyInfo *proxy_info; /* Proxy information. This will be set */
64 /* to NULL when the account inherits */
65 /* proxy settings from global prefs. */
66
67 /*
68 * TODO: Instead of linked lists for permit and deny, use a data
69 * structure that allows fast lookups AND decent performance when
70 * iterating through all items. Fast lookups should help performance
71 * for protocols like MSN, where all your buddies exist in your permit
72 * list therefore the permit list is large. Possibly GTree or
73 * GHashTable.
74 */
75 GSList *permit; /* Permit list. */
76 GSList *deny; /* Deny list. */
77 PurpleAccountPrivacyType privacy_type; /* The permit/deny setting. */
78
79 GList *status_types; /* Status types. */
80
81 PurplePresence *presence; /* Presence. */
82 PurpleLog *system_log; /* The system log */
83
84 PurpleAccountRegistrationCb registration_cb;
85 void *registration_cb_user_data;
86
87 PurpleConnectionErrorInfo *current_error; /* Errors */
88 } PurpleAccountPrivate;
89
90 typedef struct
91 {
92 char *ui;
93 GValue value;
94
95 } PurpleAccountSetting;
96
97 typedef struct
98 {
99 PurpleAccountRequestType type;
100 PurpleAccount *account;
101 void *ui_handle;
102 char *user;
103 gpointer userdata;
104 PurpleAccountRequestAuthorizationCb auth_cb;
105 PurpleAccountRequestAuthorizationCb deny_cb;
106 guint ref;
107 } PurpleAccountRequestInfo;
108
109 typedef struct
110 {
111 PurpleCallback cb;
112 gpointer data;
113 } PurpleCallbackBundle;
114
115 /* GObject Property enums */
116 enum
117 {
118 PROP_0,
119 PROP_USERNAME,
120 PROP_PRIVATE_ALIAS,
121 PROP_ENABLED,
122 PROP_CONNECTION,
123 PROP_PROTOCOL_ID,
124 PROP_USER_INFO,
125 PROP_BUDDY_ICON_PATH,
126 PROP_REMEMBER_PASSWORD,
127 PROP_CHECK_MAIL,
128 PROP_LAST
129 };
130
131 static GObjectClass *parent_class = NULL;
132 static GParamSpec *properties[PROP_LAST];
133 static GList *handles = NULL;
134
135 /***************
136 * Account API *
137 ***************/
138 void
139 purple_account_set_register_callback(PurpleAccount *account, PurpleAccountRegistrationCb cb, void *user_data)
140 {
141 PurpleAccountPrivate *priv;
142
143 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
144
145 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
146
147 priv->registration_cb = cb;
148 priv->registration_cb_user_data = user_data;
149 }
150
151 static void
152 purple_account_register_got_password_cb(PurpleAccount *account,
153 const gchar *password, GError *error, gpointer data)
154 {
155 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
156
157 _purple_connection_new(account, TRUE, password);
158 }
159
160 void
161 purple_account_register(PurpleAccount *account)
162 {
163 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
164
165 purple_debug_info("account", "Registering account %s\n",
166 purple_account_get_username(account));
167
168 purple_keyring_get_password(account,
169 purple_account_register_got_password_cb, NULL);
170 }
171
172 static void
173 purple_account_unregister_got_password_cb(PurpleAccount *account,
174 const gchar *password, GError *error, gpointer data)
175 {
176 PurpleCallbackBundle *cbb = data;
177 PurpleAccountUnregistrationCb cb;
178
179 cb = (PurpleAccountUnregistrationCb)cbb->cb;
180 _purple_connection_new_unregister(account, password, cb, cbb->data);
181
182 g_free(cbb);
183 }
184
185 struct register_completed_closure
186 {
187 PurpleAccount *account;
188 gboolean succeeded;
189 };
190
191 static gboolean
192 purple_account_register_completed_cb(gpointer data)
193 {
194 struct register_completed_closure *closure = data;
195 PurpleAccountPrivate *priv;
196
197 priv = PURPLE_ACCOUNT_GET_PRIVATE(closure->account);
198
199 if (priv->registration_cb)
200 (priv->registration_cb)(closure->account, closure->succeeded,
201 priv->registration_cb_user_data);
202
203 g_object_unref(closure->account);
204 g_free(closure);
205
206 return FALSE;
207 }
208
209 void
210 purple_account_register_completed(PurpleAccount *account, gboolean succeeded)
211 {
212 struct register_completed_closure *closure;
213
214 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
215
216 closure = g_new0(struct register_completed_closure, 1);
217 closure->account = g_object_ref(account);
218 closure->succeeded = succeeded;
219
220 g_timeout_add(0, purple_account_register_completed_cb, closure);
221 }
222
223 void
224 purple_account_unregister(PurpleAccount *account, PurpleAccountUnregistrationCb cb, void *user_data)
225 {
226 PurpleCallbackBundle *cbb;
227
228 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
229
230 purple_debug_info("account", "Unregistering account %s\n",
231 purple_account_get_username(account));
232
233 cbb = g_new0(PurpleCallbackBundle, 1);
234 cbb->cb = PURPLE_CALLBACK(cb);
235 cbb->data = user_data;
236
237 purple_keyring_get_password(account,
238 purple_account_unregister_got_password_cb, cbb);
239 }
240
241 static void
242 request_password_ok_cb(PurpleAccount *account, PurpleRequestFields *fields)
243 {
244 const char *entry;
245 gboolean remember;
246
247 entry = purple_request_fields_get_string(fields, "password");
248 remember = purple_request_fields_get_bool(fields, "remember");
249
250 if (!entry || !*entry)
251 {
252 purple_notify_error(account, NULL,
253 _("Password is required to sign on."), NULL,
254 purple_request_cpar_from_account(account));
255 return;
256 }
257
258 purple_account_set_remember_password(account, remember);
259
260 purple_account_set_password(account, entry, NULL, NULL);
261 _purple_connection_new(account, FALSE, entry);
262 }
263
264 static void
265 request_password_cancel_cb(PurpleAccount *account, PurpleRequestFields *fields)
266 {
267 /* Disable the account as the user has cancelled connecting */
268 purple_account_set_enabled(account, purple_core_get_ui(), FALSE);
269 }
270
271
272 void
273 purple_account_request_password(PurpleAccount *account, GCallback ok_cb,
274 GCallback cancel_cb, void *user_data)
275 {
276 gchar *primary;
277 const gchar *username;
278 PurpleRequestFieldGroup *group;
279 PurpleRequestField *field;
280 PurpleRequestFields *fields;
281
282 /* Close any previous password request windows */
283 purple_request_close_with_handle(account);
284
285 username = purple_account_get_username(account);
286 primary = g_strdup_printf(_("Enter password for %s (%s)"), username,
287 purple_account_get_protocol_name(account));
288
289 fields = purple_request_fields_new();
290 group = purple_request_field_group_new(NULL);
291 purple_request_fields_add_group(fields, group);
292
293 field = purple_request_field_string_new("password", _("Enter Password"), NULL, FALSE);
294 purple_request_field_string_set_masked(field, TRUE);
295 purple_request_field_set_required(field, TRUE);
296 purple_request_field_group_add_field(group, field);
297
298 field = purple_request_field_bool_new("remember", _("Save password"), FALSE);
299 purple_request_field_group_add_field(group, field);
300
301 purple_request_fields(account, NULL, primary, NULL, fields, _("OK"),
302 ok_cb, _("Cancel"), cancel_cb,
303 purple_request_cpar_from_account(account), user_data);
304 g_free(primary);
305 }
306
307 static void
308 purple_account_connect_got_password_cb(PurpleAccount *account,
309 const gchar *password, GError *error, gpointer data)
310 {
311 PurpleProtocol *protocol = data;
312
313 if ((password == NULL || *password == '\0') &&
314 !(purple_protocol_get_options(protocol) & OPT_PROTO_NO_PASSWORD) &&
315 !(purple_protocol_get_options(protocol) & OPT_PROTO_PASSWORD_OPTIONAL))
316 purple_account_request_password(account,
317 G_CALLBACK(request_password_ok_cb),
318 G_CALLBACK(request_password_cancel_cb), account);
319 else
320 _purple_connection_new(account, FALSE, password);
321 }
322
323 void
324 purple_account_connect(PurpleAccount *account)
325 {
326 const char *username;
327 PurpleProtocol *protocol;
328 PurpleAccountPrivate *priv;
329
330 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
331
332 username = purple_account_get_username(account);
333
334 if (!purple_account_get_enabled(account, purple_core_get_ui())) {
335 purple_debug_info("account",
336 "Account %s not enabled, not connecting.\n",
337 username);
338 return;
339 }
340
341 protocol = purple_protocols_find(purple_account_get_protocol_id(account));
342 if (protocol == NULL) {
343 gchar *message;
344
345 message = g_strdup_printf(_("Missing protocol for %s"), username);
346 purple_notify_error(account, _("Connection Error"), message,
347 NULL, purple_request_cpar_from_account(account));
348 g_free(message);
349 return;
350 }
351
352 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
353
354 purple_debug_info("account", "Connecting to account %s.\n", username);
355
356 if (priv->password != NULL) {
357 purple_account_connect_got_password_cb(account,
358 priv->password, NULL, protocol);
359 } else {
360 purple_keyring_get_password(account,
361 purple_account_connect_got_password_cb, protocol);
362 }
363 }
364
365 void
366 purple_account_disconnect(PurpleAccount *account)
367 {
368 PurpleConnection *gc;
369 PurpleAccountPrivate *priv;
370 const char *username;
371
372 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
373 g_return_if_fail(!purple_account_is_disconnecting(account));
374 g_return_if_fail(!purple_account_is_disconnected(account));
375
376 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
377
378 username = purple_account_get_username(account);
379 purple_debug_info("account", "Disconnecting account %s (%p)\n",
380 username ? username : "(null)", account);
381
382 priv->disconnecting = TRUE;
383
384 gc = purple_account_get_connection(account);
385 g_object_unref(gc);
386 purple_account_set_connection(account, NULL);
387
388 priv->disconnecting = FALSE;
389 }
390
391 gboolean
392 purple_account_is_disconnecting(const PurpleAccount *account)
393 {
394 PurpleAccountPrivate *priv;
395
396 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), TRUE);
397
398 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
399 return priv->disconnecting;
400 }
401
402 void
403 purple_account_notify_added(PurpleAccount *account, const char *remote_user,
404 const char *id, const char *alias,
405 const char *message)
406 {
407 PurpleAccountUiOps *ui_ops;
408
409 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
410 g_return_if_fail(remote_user != NULL);
411
412 ui_ops = purple_accounts_get_ui_ops();
413
414 if (ui_ops != NULL && ui_ops->notify_added != NULL)
415 ui_ops->notify_added(account, remote_user, id, alias, message);
416 }
417
418 void
419 purple_account_request_add(PurpleAccount *account, const char *remote_user,
420 const char *id, const char *alias,
421 const char *message)
422 {
423 PurpleAccountUiOps *ui_ops;
424
425 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
426 g_return_if_fail(remote_user != NULL);
427
428 ui_ops = purple_accounts_get_ui_ops();
429
430 if (ui_ops != NULL && ui_ops->request_add != NULL)
431 ui_ops->request_add(account, remote_user, id, alias, message);
432 }
433
434 static PurpleAccountRequestInfo *
435 purple_account_request_info_unref(PurpleAccountRequestInfo *info)
436 {
437 if (--info->ref)
438 return info;
439
440 /* TODO: This will leak info->user_data, but there is no callback to just clean that up */
441 g_free(info->user);
442 g_free(info);
443 return NULL;
444 }
445
446 static void
447 purple_account_request_close_info(PurpleAccountRequestInfo *info)
448 {
449 PurpleAccountUiOps *ops;
450
451 ops = purple_accounts_get_ui_ops();
452
453 if (ops != NULL && ops->close_account_request != NULL)
454 ops->close_account_request(info->ui_handle);
455
456 purple_account_request_info_unref(info);
457 }
458
459 void
460 purple_account_request_close_with_account(PurpleAccount *account)
461 {
462 GList *l, *l_next;
463
464 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
465
466 for (l = handles; l != NULL; l = l_next) {
467 PurpleAccountRequestInfo *info = l->data;
468
469 l_next = l->next;
470
471 if (info->account == account) {
472 handles = g_list_remove(handles, info);
473 purple_account_request_close_info(info);
474 }
475 }
476 }
477
478 void
479 purple_account_request_close(void *ui_handle)
480 {
481 GList *l, *l_next;
482
483 g_return_if_fail(ui_handle != NULL);
484
485 for (l = handles; l != NULL; l = l_next) {
486 PurpleAccountRequestInfo *info = l->data;
487
488 l_next = l->next;
489
490 if (info->ui_handle == ui_handle) {
491 handles = g_list_remove(handles, info);
492 purple_account_request_close_info(info);
493 }
494 }
495 }
496
497 static void
498 request_auth_cb(const char *message, void *data)
499 {
500 PurpleAccountRequestInfo *info = data;
501
502 handles = g_list_remove(handles, info);
503
504 if (info->auth_cb != NULL)
505 info->auth_cb(message, info->userdata);
506
507 purple_signal_emit(purple_accounts_get_handle(),
508 "account-authorization-granted", info->account, info->user, message);
509
510 purple_account_request_info_unref(info);
511 }
512
513 static void
514 request_deny_cb(const char *message, void *data)
515 {
516 PurpleAccountRequestInfo *info = data;
517
518 handles = g_list_remove(handles, info);
519
520 if (info->deny_cb != NULL)
521 info->deny_cb(message, info->userdata);
522
523 purple_signal_emit(purple_accounts_get_handle(),
524 "account-authorization-denied", info->account, info->user, message);
525
526 purple_account_request_info_unref(info);
527 }
528
529 void *
530 purple_account_request_authorization(PurpleAccount *account, const char *remote_user,
531 const char *id, const char *alias, const char *message, gboolean on_list,
532 PurpleAccountRequestAuthorizationCb auth_cb, PurpleAccountRequestAuthorizationCb deny_cb, void *user_data)
533 {
534 PurpleAccountUiOps *ui_ops;
535 PurpleAccountRequestInfo *info;
536 int plugin_return;
537 char *response = NULL;
538
539 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
540 g_return_val_if_fail(remote_user != NULL, NULL);
541
542 ui_ops = purple_accounts_get_ui_ops();
543
544 plugin_return = GPOINTER_TO_INT(
545 purple_signal_emit_return_1(
546 purple_accounts_get_handle(),
547 "account-authorization-requested",
548 account, remote_user, message, &response
549 ));
550
551 switch (plugin_return)
552 {
553 case PURPLE_ACCOUNT_RESPONSE_IGNORE:
554 g_free(response);
555 return NULL;
556 case PURPLE_ACCOUNT_RESPONSE_ACCEPT:
557 if (auth_cb != NULL)
558 auth_cb(response, user_data);
559 g_free(response);
560 return NULL;
561 case PURPLE_ACCOUNT_RESPONSE_DENY:
562 if (deny_cb != NULL)
563 deny_cb(response, user_data);
564 g_free(response);
565 return NULL;
566 }
567
568 g_free(response);
569
570 if (ui_ops != NULL && ui_ops->request_authorize != NULL) {
571 info = g_new0(PurpleAccountRequestInfo, 1);
572 info->type = PURPLE_ACCOUNT_REQUEST_AUTHORIZATION;
573 info->account = account;
574 info->auth_cb = auth_cb;
575 info->deny_cb = deny_cb;
576 info->userdata = user_data;
577 info->user = g_strdup(remote_user);
578 info->ref = 2; /* We hold an extra ref to make sure info remains valid
579 if any of the callbacks are called synchronously. We
580 unref it after the function call */
581
582 info->ui_handle = ui_ops->request_authorize(account, remote_user, id, alias, message,
583 on_list, request_auth_cb, request_deny_cb, info);
584
585 info = purple_account_request_info_unref(info);
586 if (info) {
587 handles = g_list_append(handles, info);
588 return info->ui_handle;
589 }
590 }
591
592 return NULL;
593 }
594
595 static void
596 change_password_cb(PurpleAccount *account, PurpleRequestFields *fields)
597 {
598 const char *orig_pass, *new_pass_1, *new_pass_2;
599
600 orig_pass = purple_request_fields_get_string(fields, "password");
601 new_pass_1 = purple_request_fields_get_string(fields, "new_password_1");
602 new_pass_2 = purple_request_fields_get_string(fields, "new_password_2");
603
604 if (g_utf8_collate(new_pass_1, new_pass_2))
605 {
606 purple_notify_error(account, NULL,
607 _("New passwords do not match."), NULL,
608 purple_request_cpar_from_account(account));
609
610 return;
611 }
612
613 if ((purple_request_fields_is_field_required(fields, "password") &&
614 (orig_pass == NULL || *orig_pass == '\0')) ||
615 (purple_request_fields_is_field_required(fields, "new_password_1") &&
616 (new_pass_1 == NULL || *new_pass_1 == '\0')) ||
617 (purple_request_fields_is_field_required(fields, "new_password_2") &&
618 (new_pass_2 == NULL || *new_pass_2 == '\0')))
619 {
620 purple_notify_error(account, NULL,
621 _("Fill out all fields completely."), NULL,
622 purple_request_cpar_from_account(account));
623 return;
624 }
625
626 purple_account_change_password(account, orig_pass, new_pass_1);
627 }
628
629 void
630 purple_account_request_change_password(PurpleAccount *account)
631 {
632 PurpleRequestFields *fields;
633 PurpleRequestFieldGroup *group;
634 PurpleRequestField *field;
635 PurpleConnection *gc;
636 PurpleProtocol *protocol = NULL;
637 char primary[256];
638
639 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
640 g_return_if_fail(purple_account_is_connected(account));
641
642 gc = purple_account_get_connection(account);
643 if (gc != NULL)
644 protocol = purple_connection_get_protocol(gc);
645
646 fields = purple_request_fields_new();
647
648 group = purple_request_field_group_new(NULL);
649 purple_request_fields_add_group(fields, group);
650
651 field = purple_request_field_string_new("password", _("Original password"),
652 NULL, FALSE);
653 purple_request_field_string_set_masked(field, TRUE);
654 if (!protocol || !(purple_protocol_get_options(protocol) & OPT_PROTO_PASSWORD_OPTIONAL))
655 purple_request_field_set_required(field, TRUE);
656 purple_request_field_group_add_field(group, field);
657
658 field = purple_request_field_string_new("new_password_1",
659 _("New password"),
660 NULL, FALSE);
661 purple_request_field_string_set_masked(field, TRUE);
662 if (!protocol || !(purple_protocol_get_options(protocol) & OPT_PROTO_PASSWORD_OPTIONAL))
663 purple_request_field_set_required(field, TRUE);
664 purple_request_field_group_add_field(group, field);
665
666 field = purple_request_field_string_new("new_password_2",
667 _("New password (again)"),
668 NULL, FALSE);
669 purple_request_field_string_set_masked(field, TRUE);
670 if (!protocol || !(purple_protocol_get_options(protocol) & OPT_PROTO_PASSWORD_OPTIONAL))
671 purple_request_field_set_required(field, TRUE);
672 purple_request_field_group_add_field(group, field);
673
674 g_snprintf(primary, sizeof(primary), _("Change password for %s"),
675 purple_account_get_username(account));
676
677 /* I'm sticking this somewhere in the code: bologna */
678
679 purple_request_fields(purple_account_get_connection(account), NULL,
680 primary, _("Please enter your current password and your new "
681 "password."), fields, _("OK"), G_CALLBACK(change_password_cb),
682 _("Cancel"), NULL, purple_request_cpar_from_account(account),
683 account);
684 }
685
686 static void
687 set_user_info_cb(PurpleAccount *account, const char *user_info)
688 {
689 PurpleConnection *gc;
690
691 purple_account_set_user_info(account, user_info);
692 gc = purple_account_get_connection(account);
693 purple_serv_set_info(gc, user_info);
694 }
695
696 void
697 purple_account_request_change_user_info(PurpleAccount *account)
698 {
699 PurpleConnection *gc;
700 char primary[256];
701
702 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
703 g_return_if_fail(purple_account_is_connected(account));
704
705 gc = purple_account_get_connection(account);
706
707 g_snprintf(primary, sizeof(primary),
708 _("Change user information for %s"),
709 purple_account_get_username(account));
710
711 purple_request_input(gc, _("Set User Info"), primary, NULL,
712 purple_account_get_user_info(account),
713 TRUE, FALSE, ((gc != NULL) &&
714 (purple_connection_get_flags(gc) & PURPLE_CONNECTION_FLAG_HTML) ? "html" : NULL),
715 _("Save"), G_CALLBACK(set_user_info_cb),
716 _("Cancel"), NULL,
717 purple_request_cpar_from_account(account),
718 account);
719 }
720
721 void
722 purple_account_set_username(PurpleAccount *account, const char *username)
723 {
724 PurpleBlistUiOps *blist_ops;
725 PurpleAccountPrivate *priv;
726
727 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
728
729 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
730
731 g_free(priv->username);
732 priv->username = g_strdup(username);
733
734 g_object_notify_by_pspec(G_OBJECT(account), properties[PROP_USERNAME]);
735
736 purple_accounts_schedule_save();
737
738 /* if the name changes, we should re-write the buddy list
739 * to disk with the new name */
740 blist_ops = purple_blist_get_ui_ops();
741 if (blist_ops != NULL && blist_ops->save_account != NULL)
742 blist_ops->save_account(account);
743 }
744
745 void
746 purple_account_set_password(PurpleAccount *account, const gchar *password,
747 PurpleKeyringSaveCallback cb, gpointer data)
748 {
749 PurpleAccountPrivate *priv;
750
751 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
752
753 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
754
755 purple_str_wipe(priv->password);
756 priv->password = g_strdup(password);
757
758 purple_accounts_schedule_save();
759
760 if (!purple_account_get_remember_password(account)) {
761 purple_debug_info("account",
762 "Password for %s set, not sent to keyring.\n",
763 purple_account_get_username(account));
764
765 if (cb != NULL)
766 cb(account, NULL, data);
767 } else {
768 purple_keyring_set_password(account, password, cb, data);
769 }
770 }
771
772 void
773 purple_account_set_private_alias(PurpleAccount *account, const char *alias)
774 {
775 PurpleAccountPrivate *priv;
776
777 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
778
779 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
780
781 /*
782 * Do nothing if alias and priv->alias are both NULL. Or if
783 * they're the exact same string.
784 */
785 if (alias == priv->alias)
786 return;
787
788 if ((!alias && priv->alias) || (alias && !priv->alias) ||
789 g_utf8_collate(priv->alias, alias))
790 {
791 char *old = priv->alias;
792
793 priv->alias = g_strdup(alias);
794 g_object_notify_by_pspec(G_OBJECT(account),
795 properties[PROP_PRIVATE_ALIAS]);
796 purple_signal_emit(purple_accounts_get_handle(), "account-alias-changed",
797 account, old);
798 g_free(old);
799
800 purple_accounts_schedule_save();
801 }
802 }
803
804 void
805 purple_account_set_user_info(PurpleAccount *account, const char *user_info)
806 {
807 PurpleAccountPrivate *priv;
808
809 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
810
811 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
812
813 g_free(priv->user_info);
814 priv->user_info = g_strdup(user_info);
815
816 g_object_notify_by_pspec(G_OBJECT(account), properties[PROP_USER_INFO]);
817
818 purple_accounts_schedule_save();
819 }
820
821 void purple_account_set_buddy_icon_path(PurpleAccount *account, const char *path)
822 {
823 PurpleAccountPrivate *priv;
824
825 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
826
827 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
828
829 g_free(priv->buddy_icon_path);
830 priv->buddy_icon_path = g_strdup(path);
831
832 g_object_notify_by_pspec(G_OBJECT(account),
833 properties[PROP_BUDDY_ICON_PATH]);
834
835 purple_accounts_schedule_save();
836 }
837
838 void
839 purple_account_set_protocol_id(PurpleAccount *account, const char *protocol_id)
840 {
841 PurpleAccountPrivate *priv;
842
843 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
844 g_return_if_fail(protocol_id != NULL);
845
846 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
847
848 g_free(priv->protocol_id);
849 priv->protocol_id = g_strdup(protocol_id);
850
851 g_object_notify_by_pspec(G_OBJECT(account), properties[PROP_PROTOCOL_ID]);
852
853 purple_accounts_schedule_save();
854 }
855
856 void
857 purple_account_set_connection(PurpleAccount *account, PurpleConnection *gc)
858 {
859 PurpleAccountPrivate *priv;
860
861 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
862
863 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
864 priv->gc = gc;
865
866 g_object_notify_by_pspec(G_OBJECT(account), properties[PROP_CONNECTION]);
867 }
868
869 void
870 purple_account_set_remember_password(PurpleAccount *account, gboolean value)
871 {
872 PurpleAccountPrivate *priv;
873
874 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
875
876 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
877 priv->remember_pass = value;
878
879 g_object_notify_by_pspec(G_OBJECT(account),
880 properties[PROP_REMEMBER_PASSWORD]);
881
882 purple_accounts_schedule_save();
883 }
884
885 void
886 purple_account_set_check_mail(PurpleAccount *account, gboolean value)
887 {
888 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
889
890 purple_account_set_bool(account, "check-mail", value);
891
892 g_object_notify_by_pspec(G_OBJECT(account), properties[PROP_CHECK_MAIL]);
893 }
894
895 void
896 purple_account_set_enabled(PurpleAccount *account, const char *ui,
897 gboolean value)
898 {
899 PurpleConnection *gc;
900 PurpleAccountPrivate *priv;
901 gboolean was_enabled = FALSE;
902
903 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
904 g_return_if_fail(ui != NULL);
905
906 was_enabled = purple_account_get_enabled(account, ui);
907
908 purple_account_set_ui_bool(account, ui, "auto-login", value);
909 gc = purple_account_get_connection(account);
910
911 if(was_enabled && !value)
912 purple_signal_emit(purple_accounts_get_handle(), "account-disabled", account);
913 else if(!was_enabled && value)
914 purple_signal_emit(purple_accounts_get_handle(), "account-enabled", account);
915
916 g_object_notify_by_pspec(G_OBJECT(account), properties[PROP_ENABLED]);
917
918 if ((gc != NULL) && (_purple_connection_wants_to_die(gc)))
919 return;
920
921 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
922
923 if (value && purple_presence_is_online(priv->presence))
924 purple_account_connect(account);
925 else if (!value && !purple_account_is_disconnected(account))
926 purple_account_disconnect(account);
927 }
928
929 void
930 purple_account_set_proxy_info(PurpleAccount *account, PurpleProxyInfo *info)
931 {
932 PurpleAccountPrivate *priv;
933
934 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
935
936 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
937
938 if (priv->proxy_info != NULL)
939 purple_proxy_info_destroy(priv->proxy_info);
940
941 priv->proxy_info = info;
942
943 purple_accounts_schedule_save();
944 }
945
946 void
947 purple_account_set_privacy_type(PurpleAccount *account, PurpleAccountPrivacyType privacy_type)
948 {
949 PurpleAccountPrivate *priv;
950
951 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
952
953 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
954 priv->privacy_type = privacy_type;
955 }
956
957 void
958 purple_account_set_status_types(PurpleAccount *account, GList *status_types)
959 {
960 PurpleAccountPrivate *priv;
961
962 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
963
964 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
965
966 /* Out with the old... */
967 if (priv->status_types != NULL)
968 {
969 g_list_foreach(priv->status_types, (GFunc)purple_status_type_destroy, NULL);
970 g_list_free(priv->status_types);
971 }
972
973 /* In with the new... */
974 priv->status_types = status_types;
975 }
976
977 void
978 purple_account_set_status(PurpleAccount *account, const char *status_id,
979 gboolean active, ...)
980 {
981 GList *attrs = NULL;
982 const gchar *id;
983 gpointer data;
984 va_list args;
985
986 va_start(args, active);
987 while ((id = va_arg(args, const char *)) != NULL)
988 {
989 attrs = g_list_append(attrs, (char *)id);
990 data = va_arg(args, void *);
991 attrs = g_list_append(attrs, data);
992 }
993 purple_account_set_status_list(account, status_id, active, attrs);
994 g_list_free(attrs);
995 va_end(args);
996 }
997
998 void
999 purple_account_set_status_list(PurpleAccount *account, const char *status_id,
1000 gboolean active, GList *attrs)
1001 {
1002 PurpleStatus *status;
1003
1004 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
1005 g_return_if_fail(status_id != NULL);
1006
1007 status = purple_account_get_status(account, status_id);
1008 if (status == NULL)
1009 {
1010 purple_debug_error("account",
1011 "Invalid status ID '%s' for account %s (%s)\n",
1012 status_id, purple_account_get_username(account),
1013 purple_account_get_protocol_id(account));
1014 return;
1015 }
1016
1017 if (active || purple_status_is_independent(status))
1018 purple_status_set_active_with_attrs_list(status, active, attrs);
1019
1020 /*
1021 * Our current statuses are saved to accounts.xml (so that when we
1022 * reconnect, we go back to the previous status).
1023 */
1024 purple_accounts_schedule_save();
1025 }
1026
1027 struct public_alias_closure
1028 {
1029 PurpleAccount *account;
1030 gpointer failure_cb;
1031 };
1032
1033 static gboolean
1034 set_public_alias_unsupported(gpointer data)
1035 {
1036 struct public_alias_closure *closure = data;
1037 PurpleSetPublicAliasFailureCallback failure_cb = closure->failure_cb;
1038
1039 failure_cb(closure->account,
1040 _("This protocol does not support setting a public alias."));
1041
1042 g_object_unref(closure->account);
1043 g_free(closure);
1044
1045 return FALSE;
1046 }
1047
1048 void
1049 purple_account_set_public_alias(PurpleAccount *account,
1050 const char *alias, PurpleSetPublicAliasSuccessCallback success_cb,
1051 PurpleSetPublicAliasFailureCallback failure_cb)
1052 {
1053 PurpleConnection *gc;
1054 PurpleProtocol *protocol = NULL;
1055
1056 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
1057 g_return_if_fail(purple_account_is_connected(account));
1058
1059 gc = purple_account_get_connection(account);
1060 protocol = purple_connection_get_protocol(gc);
1061
1062 if (PURPLE_PROTOCOL_IMPLEMENTS(protocol, SERVER_IFACE, set_public_alias))
1063 purple_protocol_server_iface_set_public_alias(protocol, gc, alias, success_cb, failure_cb);
1064 else if (failure_cb) {
1065 struct public_alias_closure *closure =
1066 g_new0(struct public_alias_closure, 1);
1067 closure->account = g_object_ref(account);
1068 closure->failure_cb = failure_cb;
1069 g_timeout_add(0, set_public_alias_unsupported, closure);
1070 }
1071 }
1072
1073 static gboolean
1074 get_public_alias_unsupported(gpointer data)
1075 {
1076 struct public_alias_closure *closure = data;
1077 PurpleGetPublicAliasFailureCallback failure_cb = closure->failure_cb;
1078
1079 failure_cb(closure->account,
1080 _("This protocol does not support fetching the public alias."));
1081
1082 g_object_unref(closure->account);
1083 g_free(closure);
1084
1085 return FALSE;
1086 }
1087
1088 void
1089 purple_account_get_public_alias(PurpleAccount *account,
1090 PurpleGetPublicAliasSuccessCallback success_cb,
1091 PurpleGetPublicAliasFailureCallback failure_cb)
1092 {
1093 PurpleConnection *gc;
1094 PurpleProtocol *protocol = NULL;
1095
1096 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
1097 g_return_if_fail(purple_account_is_connected(account));
1098
1099 gc = purple_account_get_connection(account);
1100 protocol = purple_connection_get_protocol(gc);
1101
1102 if (PURPLE_PROTOCOL_IMPLEMENTS(protocol, SERVER_IFACE, get_public_alias))
1103 purple_protocol_server_iface_get_public_alias(protocol, gc, success_cb, failure_cb);
1104 else if (failure_cb) {
1105 struct public_alias_closure *closure =
1106 g_new0(struct public_alias_closure, 1);
1107 closure->account = g_object_ref(account);
1108 closure->failure_cb = failure_cb;
1109 g_timeout_add(0, get_public_alias_unsupported, closure);
1110 }
1111 }
1112
1113 gboolean
1114 purple_account_get_silence_suppression(const PurpleAccount *account)
1115 {
1116 return purple_account_get_bool(account, "silence-suppression", FALSE);
1117 }
1118
1119 void
1120 purple_account_set_silence_suppression(PurpleAccount *account, gboolean value)
1121 {
1122 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
1123
1124 purple_account_set_bool(account, "silence-suppression", value);
1125 }
1126
1127 static void
1128 delete_setting(void *data)
1129 {
1130 PurpleAccountSetting *setting = (PurpleAccountSetting *)data;
1131
1132 g_free(setting->ui);
1133 g_value_unset(&setting->value);
1134
1135 g_free(setting);
1136 }
1137
1138 void
1139 purple_account_clear_settings(PurpleAccount *account)
1140 {
1141 PurpleAccountPrivate *priv;
1142
1143 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
1144
1145 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1146 g_hash_table_destroy(priv->settings);
1147
1148 priv->settings = g_hash_table_new_full(g_str_hash, g_str_equal,
1149 g_free, delete_setting);
1150 }
1151
1152 void
1153 purple_account_remove_setting(PurpleAccount *account, const char *setting)
1154 {
1155 PurpleAccountPrivate *priv;
1156
1157 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
1158 g_return_if_fail(setting != NULL);
1159
1160 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1161
1162 g_hash_table_remove(priv->settings, setting);
1163 }
1164
1165 void
1166 purple_account_set_int(PurpleAccount *account, const char *name, int value)
1167 {
1168 PurpleAccountSetting *setting;
1169 PurpleAccountPrivate *priv;
1170
1171 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
1172 g_return_if_fail(name != NULL);
1173
1174 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1175
1176 setting = g_new0(PurpleAccountSetting, 1);
1177
1178 g_value_init(&setting->value, G_TYPE_INT);
1179 g_value_set_int(&setting->value, value);
1180
1181 g_hash_table_insert(priv->settings, g_strdup(name), setting);
1182
1183 purple_accounts_schedule_save();
1184 }
1185
1186 void
1187 purple_account_set_string(PurpleAccount *account, const char *name,
1188 const char *value)
1189 {
1190 PurpleAccountSetting *setting;
1191 PurpleAccountPrivate *priv;
1192
1193 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
1194 g_return_if_fail(name != NULL);
1195
1196 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1197
1198 setting = g_new0(PurpleAccountSetting, 1);
1199
1200 g_value_init(&setting->value, G_TYPE_STRING);
1201 g_value_set_string(&setting->value, value);
1202
1203 g_hash_table_insert(priv->settings, g_strdup(name), setting);
1204
1205 purple_accounts_schedule_save();
1206 }
1207
1208 void
1209 purple_account_set_bool(PurpleAccount *account, const char *name, gboolean value)
1210 {
1211 PurpleAccountSetting *setting;
1212 PurpleAccountPrivate *priv;
1213
1214 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
1215 g_return_if_fail(name != NULL);
1216
1217 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1218
1219 setting = g_new0(PurpleAccountSetting, 1);
1220
1221 g_value_init(&setting->value, G_TYPE_BOOLEAN);
1222 g_value_set_boolean(&setting->value, value);
1223
1224 g_hash_table_insert(priv->settings, g_strdup(name), setting);
1225
1226 purple_accounts_schedule_save();
1227 }
1228
1229 static GHashTable *
1230 get_ui_settings_table(PurpleAccount *account, const char *ui)
1231 {
1232 GHashTable *table;
1233 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1234
1235 table = g_hash_table_lookup(priv->ui_settings, ui);
1236
1237 if (table == NULL) {
1238 table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
1239 delete_setting);
1240 g_hash_table_insert(priv->ui_settings, g_strdup(ui), table);
1241 }
1242
1243 return table;
1244 }
1245
1246 void
1247 purple_account_set_ui_int(PurpleAccount *account, const char *ui,
1248 const char *name, int value)
1249 {
1250 PurpleAccountSetting *setting;
1251 GHashTable *table;
1252
1253 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
1254 g_return_if_fail(ui != NULL);
1255 g_return_if_fail(name != NULL);
1256
1257 setting = g_new0(PurpleAccountSetting, 1);
1258
1259 setting->ui = g_strdup(ui);
1260 g_value_init(&setting->value, G_TYPE_INT);
1261 g_value_set_int(&setting->value, value);
1262
1263 table = get_ui_settings_table(account, ui);
1264
1265 g_hash_table_insert(table, g_strdup(name), setting);
1266
1267 purple_accounts_schedule_save();
1268 }
1269
1270 void
1271 purple_account_set_ui_string(PurpleAccount *account, const char *ui,
1272 const char *name, const char *value)
1273 {
1274 PurpleAccountSetting *setting;
1275 GHashTable *table;
1276
1277 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
1278 g_return_if_fail(ui != NULL);
1279 g_return_if_fail(name != NULL);
1280
1281 setting = g_new0(PurpleAccountSetting, 1);
1282
1283 setting->ui = g_strdup(ui);
1284 g_value_init(&setting->value, G_TYPE_STRING);
1285 g_value_set_string(&setting->value, value);
1286
1287 table = get_ui_settings_table(account, ui);
1288
1289 g_hash_table_insert(table, g_strdup(name), setting);
1290
1291 purple_accounts_schedule_save();
1292 }
1293
1294 void
1295 purple_account_set_ui_bool(PurpleAccount *account, const char *ui,
1296 const char *name, gboolean value)
1297 {
1298 PurpleAccountSetting *setting;
1299 GHashTable *table;
1300
1301 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
1302 g_return_if_fail(ui != NULL);
1303 g_return_if_fail(name != NULL);
1304
1305 setting = g_new0(PurpleAccountSetting, 1);
1306
1307 setting->ui = g_strdup(ui);
1308 g_value_init(&setting->value, G_TYPE_BOOLEAN);
1309 g_value_set_boolean(&setting->value, value);
1310
1311 table = get_ui_settings_table(account, ui);
1312
1313 g_hash_table_insert(table, g_strdup(name), setting);
1314
1315 purple_accounts_schedule_save();
1316 }
1317
1318 static PurpleConnectionState
1319 purple_account_get_state(const PurpleAccount *account)
1320 {
1321 PurpleConnection *gc;
1322
1323 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), PURPLE_CONNECTION_DISCONNECTED);
1324
1325 gc = purple_account_get_connection(account);
1326 if (!gc)
1327 return PURPLE_CONNECTION_DISCONNECTED;
1328
1329 return purple_connection_get_state(gc);
1330 }
1331
1332 gboolean
1333 purple_account_is_connected(const PurpleAccount *account)
1334 {
1335 return (purple_account_get_state(account) == PURPLE_CONNECTION_CONNECTED);
1336 }
1337
1338 gboolean
1339 purple_account_is_connecting(const PurpleAccount *account)
1340 {
1341 return (purple_account_get_state(account) == PURPLE_CONNECTION_CONNECTING);
1342 }
1343
1344 gboolean
1345 purple_account_is_disconnected(const PurpleAccount *account)
1346 {
1347 return (purple_account_get_state(account) == PURPLE_CONNECTION_DISCONNECTED);
1348 }
1349
1350 const char *
1351 purple_account_get_username(const PurpleAccount *account)
1352 {
1353 PurpleAccountPrivate *priv;
1354
1355 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
1356
1357 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1358 return priv->username;
1359 }
1360
1361 static void
1362 purple_account_get_password_got(PurpleAccount *account,
1363 const gchar *password, GError *error, gpointer data)
1364 {
1365 PurpleCallbackBundle *cbb = data;
1366 PurpleKeyringReadCallback cb;
1367 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1368
1369 purple_debug_info("account",
1370 "Read password for account %s from async keyring.\n",
1371 purple_account_get_username(account));
1372
1373 purple_str_wipe(priv->password);
1374 priv->password = g_strdup(password);
1375
1376 cb = (PurpleKeyringReadCallback)cbb->cb;
1377 if (cb != NULL)
1378 cb(account, password, error, cbb->data);
1379
1380 g_free(cbb);
1381 }
1382
1383 void
1384 purple_account_get_password(PurpleAccount *account,
1385 PurpleKeyringReadCallback cb, gpointer data)
1386 {
1387 PurpleAccountPrivate *priv;
1388
1389 if (account == NULL) {
1390 cb(NULL, NULL, NULL, data);
1391 return;
1392 }
1393
1394 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1395
1396 if (priv->password != NULL) {
1397 purple_debug_info("account",
1398 "Reading password for account %s from cache.\n",
1399 purple_account_get_username(account));
1400 cb(account, priv->password, NULL, data);
1401 } else {
1402 PurpleCallbackBundle *cbb = g_new0(PurpleCallbackBundle, 1);
1403 cbb->cb = PURPLE_CALLBACK(cb);
1404 cbb->data = data;
1405
1406 purple_debug_info("account",
1407 "Reading password for account %s from async keyring.\n",
1408 purple_account_get_username(account));
1409 purple_keyring_get_password(account,
1410 purple_account_get_password_got, cbb);
1411 }
1412 }
1413
1414 const char *
1415 purple_account_get_private_alias(const PurpleAccount *account)
1416 {
1417 PurpleAccountPrivate *priv;
1418
1419 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
1420
1421 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1422 return priv->alias;
1423 }
1424
1425 const char *
1426 purple_account_get_user_info(const PurpleAccount *account)
1427 {
1428 PurpleAccountPrivate *priv;
1429
1430 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
1431
1432 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1433 return priv->user_info;
1434 }
1435
1436 const char *
1437 purple_account_get_buddy_icon_path(const PurpleAccount *account)
1438 {
1439 PurpleAccountPrivate *priv;
1440
1441 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
1442
1443 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1444 return priv->buddy_icon_path;
1445 }
1446
1447 const char *
1448 purple_account_get_protocol_id(const PurpleAccount *account)
1449 {
1450 PurpleAccountPrivate *priv;
1451
1452 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
1453
1454 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1455 return priv->protocol_id;
1456 }
1457
1458 const char *
1459 purple_account_get_protocol_name(const PurpleAccount *account)
1460 {
1461 PurpleProtocol *p;
1462
1463 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
1464
1465 p = purple_protocols_find(purple_account_get_protocol_id(account));
1466
1467 return (p && purple_protocol_get_name(p) ?
1468 _(purple_protocol_get_name(p)) : _("Unknown"));
1469 }
1470
1471 PurpleConnection *
1472 purple_account_get_connection(const PurpleAccount *account)
1473 {
1474 PurpleAccountPrivate *priv;
1475
1476 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
1477
1478 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1479 return priv->gc;
1480 }
1481
1482 const gchar *
1483 purple_account_get_name_for_display(const PurpleAccount *account)
1484 {
1485 PurpleBuddy *self = NULL;
1486 PurpleConnection *gc = NULL;
1487 const gchar *name = NULL, *username = NULL, *displayname = NULL;
1488
1489 name = purple_account_get_private_alias(account);
1490
1491 if (name) {
1492 return name;
1493 }
1494
1495 username = purple_account_get_username(account);
1496 self = purple_blist_find_buddy((PurpleAccount *)account, username);
1497
1498 if (self) {
1499 const gchar *calias= purple_buddy_get_contact_alias(self);
1500
1501 /* We don't want to return the buddy name if the buddy/contact
1502 * doesn't have an alias set. */
1503 if (!purple_strequal(username, calias)) {
1504 return calias;
1505 }
1506 }
1507
1508 gc = purple_account_get_connection(account);
1509 displayname = purple_connection_get_display_name(gc);
1510
1511 if (displayname) {
1512 return displayname;
1513 }
1514
1515 return username;
1516 }
1517
1518 gboolean
1519 purple_account_get_remember_password(const PurpleAccount *account)
1520 {
1521 PurpleAccountPrivate *priv;
1522
1523 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), FALSE);
1524
1525 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1526 return priv->remember_pass;
1527 }
1528
1529 gboolean
1530 purple_account_get_check_mail(const PurpleAccount *account)
1531 {
1532 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), FALSE);
1533
1534 return purple_account_get_bool(account, "check-mail", FALSE);
1535 }
1536
1537 gboolean
1538 purple_account_get_enabled(const PurpleAccount *account, const char *ui)
1539 {
1540 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), FALSE);
1541 g_return_val_if_fail(ui != NULL, FALSE);
1542
1543 return purple_account_get_ui_bool(account, ui, "auto-login", FALSE);
1544 }
1545
1546 PurpleProxyInfo *
1547 purple_account_get_proxy_info(const PurpleAccount *account)
1548 {
1549 PurpleAccountPrivate *priv;
1550
1551 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
1552
1553 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1554 return priv->proxy_info;
1555 }
1556
1557 PurpleAccountPrivacyType
1558 purple_account_get_privacy_type(const PurpleAccount *account)
1559 {
1560 PurpleAccountPrivate *priv;
1561
1562 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), PURPLE_ACCOUNT_PRIVACY_ALLOW_ALL);
1563
1564 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1565 return priv->privacy_type;
1566 }
1567
1568 gboolean
1569 purple_account_privacy_permit_add(PurpleAccount *account, const char *who,
1570 gboolean local_only)
1571 {
1572 GSList *l;
1573 char *name;
1574 PurpleBuddy *buddy;
1575 PurpleBlistUiOps *blist_ops;
1576 PurpleAccountPrivate *priv;
1577 PurpleAccountUiOps *ui_ops = purple_accounts_get_ui_ops();
1578
1579 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), FALSE);
1580 g_return_val_if_fail(who != NULL, FALSE);
1581
1582 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1583 name = g_strdup(purple_normalize(account, who));
1584
1585 for (l = priv->permit; l != NULL; l = l->next) {
1586 if (g_str_equal(name, l->data))
1587 /* This buddy already exists */
1588 break;
1589 }
1590
1591 if (l != NULL)
1592 {
1593 /* This buddy already exists, so bail out */
1594 g_free(name);
1595 return FALSE;
1596 }
1597
1598 priv->permit = g_slist_append(priv->permit, name);
1599
1600 if (!local_only && purple_account_is_connected(account))
1601 purple_serv_add_permit(purple_account_get_connection(account), who);
1602
1603 if (ui_ops != NULL && ui_ops->permit_added != NULL)
1604 ui_ops->permit_added(account, who);
1605
1606 blist_ops = purple_blist_get_ui_ops();
1607 if (blist_ops != NULL && blist_ops->save_account != NULL)
1608 blist_ops->save_account(account);
1609
1610 /* This lets the UI know a buddy has had its privacy setting changed */
1611 buddy = purple_blist_find_buddy(account, name);
1612 if (buddy != NULL) {
1613 purple_signal_emit(purple_blist_get_handle(),
1614 "buddy-privacy-changed", buddy);
1615 }
1616 return TRUE;
1617 }
1618
1619 gboolean
1620 purple_account_privacy_permit_remove(PurpleAccount *account, const char *who,
1621 gboolean local_only)
1622 {
1623 GSList *l;
1624 const char *name;
1625 PurpleBuddy *buddy;
1626 char *del;
1627 PurpleBlistUiOps *blist_ops;
1628 PurpleAccountPrivate *priv;
1629 PurpleAccountUiOps *ui_ops = purple_accounts_get_ui_ops();
1630
1631 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), FALSE);
1632 g_return_val_if_fail(who != NULL, FALSE);
1633
1634 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1635 name = purple_normalize(account, who);
1636
1637 for (l = priv->permit; l != NULL; l = l->next) {
1638 if (g_str_equal(name, l->data))
1639 /* We found the buddy we were looking for */
1640 break;
1641 }
1642
1643 if (l == NULL)
1644 /* We didn't find the buddy we were looking for, so bail out */
1645 return FALSE;
1646
1647 /* We should not free l->data just yet. There can be occasions where
1648 * l->data == who. In such cases, freeing l->data here can cause crashes
1649 * later when who is used. */
1650 del = l->data;
1651 priv->permit = g_slist_delete_link(priv->permit, l);
1652
1653 if (!local_only && purple_account_is_connected(account))
1654 purple_serv_rem_permit(purple_account_get_connection(account), who);
1655
1656 if (ui_ops != NULL && ui_ops->permit_removed != NULL)
1657 ui_ops->permit_removed(account, who);
1658
1659 blist_ops = purple_blist_get_ui_ops();
1660 if (blist_ops != NULL && blist_ops->save_account != NULL)
1661 blist_ops->save_account(account);
1662
1663 buddy = purple_blist_find_buddy(account, name);
1664 if (buddy != NULL) {
1665 purple_signal_emit(purple_blist_get_handle(),
1666 "buddy-privacy-changed", buddy);
1667 }
1668 g_free(del);
1669 return TRUE;
1670 }
1671
1672 gboolean
1673 purple_account_privacy_deny_add(PurpleAccount *account, const char *who,
1674 gboolean local_only)
1675 {
1676 GSList *l;
1677 char *name;
1678 PurpleBuddy *buddy;
1679 PurpleBlistUiOps *blist_ops;
1680 PurpleAccountPrivate *priv;
1681 PurpleAccountUiOps *ui_ops = purple_accounts_get_ui_ops();
1682
1683 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), FALSE);
1684 g_return_val_if_fail(who != NULL, FALSE);
1685
1686 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1687 name = g_strdup(purple_normalize(account, who));
1688
1689 for (l = priv->deny; l != NULL; l = l->next) {
1690 if (g_str_equal(name, l->data))
1691 /* This buddy already exists */
1692 break;
1693 }
1694
1695 if (l != NULL)
1696 {
1697 /* This buddy already exists, so bail out */
1698 g_free(name);
1699 return FALSE;
1700 }
1701
1702 priv->deny = g_slist_append(priv->deny, name);
1703
1704 if (!local_only && purple_account_is_connected(account))
1705 purple_serv_add_deny(purple_account_get_connection(account), who);
1706
1707 if (ui_ops != NULL && ui_ops->deny_added != NULL)
1708 ui_ops->deny_added(account, who);
1709
1710 blist_ops = purple_blist_get_ui_ops();
1711 if (blist_ops != NULL && blist_ops->save_account != NULL)
1712 blist_ops->save_account(account);
1713
1714 buddy = purple_blist_find_buddy(account, name);
1715 if (buddy != NULL) {
1716 purple_signal_emit(purple_blist_get_handle(),
1717 "buddy-privacy-changed", buddy);
1718 }
1719 return TRUE;
1720 }
1721
1722 gboolean
1723 purple_account_privacy_deny_remove(PurpleAccount *account, const char *who,
1724 gboolean local_only)
1725 {
1726 GSList *l;
1727 const char *normalized;
1728 char *name;
1729 PurpleBuddy *buddy;
1730 PurpleBlistUiOps *blist_ops;
1731 PurpleAccountPrivate *priv;
1732 PurpleAccountUiOps *ui_ops = purple_accounts_get_ui_ops();
1733
1734 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), FALSE);
1735 g_return_val_if_fail(who != NULL, FALSE);
1736
1737 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1738 normalized = purple_normalize(account, who);
1739
1740 for (l = priv->deny; l != NULL; l = l->next) {
1741 if (g_str_equal(normalized, l->data))
1742 /* We found the buddy we were looking for */
1743 break;
1744 }
1745
1746 if (l == NULL)
1747 /* We didn't find the buddy we were looking for, so bail out */
1748 return FALSE;
1749
1750 buddy = purple_blist_find_buddy(account, normalized);
1751
1752 name = l->data;
1753 priv->deny = g_slist_delete_link(priv->deny, l);
1754
1755 if (!local_only && purple_account_is_connected(account))
1756 purple_serv_rem_deny(purple_account_get_connection(account), name);
1757
1758 if (ui_ops != NULL && ui_ops->deny_removed != NULL)
1759 ui_ops->deny_removed(account, who);
1760
1761 if (buddy != NULL) {
1762 purple_signal_emit(purple_blist_get_handle(),
1763 "buddy-privacy-changed", buddy);
1764 }
1765
1766 g_free(name);
1767
1768 blist_ops = purple_blist_get_ui_ops();
1769 if (blist_ops != NULL && blist_ops->save_account != NULL)
1770 blist_ops->save_account(account);
1771
1772 return TRUE;
1773 }
1774
1775 /*
1776 * This makes sure your permit list contains all buddies from your
1777 * buddy list and ONLY buddies from your buddy list.
1778 */
1779 static void
1780 add_all_buddies_to_permit_list(PurpleAccount *account, gboolean local)
1781 {
1782 GSList *list;
1783 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1784
1785 /* Remove anyone in the permit list who is not in the buddylist */
1786 for (list = priv->permit; list != NULL; ) {
1787 char *person = list->data;
1788 list = list->next;
1789 if (!purple_blist_find_buddy(account, person))
1790 purple_account_privacy_permit_remove(account, person, local);
1791 }
1792
1793 /* Now make sure everyone in the buddylist is in the permit list */
1794 list = purple_blist_find_buddies(account, NULL);
1795 while (list != NULL)
1796 {
1797 PurpleBuddy *buddy = list->data;
1798 const gchar *name = purple_buddy_get_name(buddy);
1799
1800 if (!g_slist_find_custom(priv->permit, name, (GCompareFunc)g_utf8_collate))
1801 purple_account_privacy_permit_add(account, name, local);
1802 list = g_slist_delete_link(list, list);
1803 }
1804 }
1805
1806 void
1807 purple_account_privacy_allow(PurpleAccount *account, const char *who)
1808 {
1809 GSList *list;
1810 PurpleAccountPrivacyType type = purple_account_get_privacy_type(account);
1811 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1812
1813 switch (type) {
1814 case PURPLE_ACCOUNT_PRIVACY_ALLOW_ALL:
1815 return;
1816 case PURPLE_ACCOUNT_PRIVACY_ALLOW_USERS:
1817 purple_account_privacy_permit_add(account, who, FALSE);
1818 break;
1819 case PURPLE_ACCOUNT_PRIVACY_DENY_USERS:
1820 purple_account_privacy_deny_remove(account, who, FALSE);
1821 break;
1822 case PURPLE_ACCOUNT_PRIVACY_DENY_ALL:
1823 {
1824 /* Empty the allow-list. */
1825 const char *norm = purple_normalize(account, who);
1826 for (list = priv->permit; list != NULL;) {
1827 char *person = list->data;
1828 list = list->next;
1829 if (!purple_strequal(norm, person))
1830 purple_account_privacy_permit_remove(account, person, FALSE);
1831 }
1832 purple_account_privacy_permit_add(account, who, FALSE);
1833 purple_account_set_privacy_type(account, PURPLE_ACCOUNT_PRIVACY_ALLOW_USERS);
1834 }
1835 break;
1836 case PURPLE_ACCOUNT_PRIVACY_ALLOW_BUDDYLIST:
1837 if (!purple_blist_find_buddy(account, who)) {
1838 add_all_buddies_to_permit_list(account, FALSE);
1839 purple_account_privacy_permit_add(account, who, FALSE);
1840 purple_account_set_privacy_type(account, PURPLE_ACCOUNT_PRIVACY_ALLOW_USERS);
1841 }
1842 break;
1843 default:
1844 g_return_if_reached();
1845 }
1846
1847 /* Notify the server if the privacy setting was changed */
1848 if (type != purple_account_get_privacy_type(account) && purple_account_is_connected(account))
1849 purple_serv_set_permit_deny(purple_account_get_connection(account));
1850 }
1851
1852 void
1853 purple_account_privacy_deny(PurpleAccount *account, const char *who)
1854 {
1855 GSList *list;
1856 PurpleAccountPrivacyType type = purple_account_get_privacy_type(account);
1857 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1858
1859 switch (type) {
1860 case PURPLE_ACCOUNT_PRIVACY_ALLOW_ALL:
1861 {
1862 /* Empty the deny-list. */
1863 const char *norm = purple_normalize(account, who);
1864 for (list = priv->deny; list != NULL; ) {
1865 char *person = list->data;
1866 list = list->next;
1867 if (!purple_strequal(norm, person))
1868 purple_account_privacy_deny_remove(account, person, FALSE);
1869 }
1870 purple_account_privacy_deny_add(account, who, FALSE);
1871 purple_account_set_privacy_type(account, PURPLE_ACCOUNT_PRIVACY_DENY_USERS);
1872 }
1873 break;
1874 case PURPLE_ACCOUNT_PRIVACY_ALLOW_USERS:
1875 purple_account_privacy_permit_remove(account, who, FALSE);
1876 break;
1877 case PURPLE_ACCOUNT_PRIVACY_DENY_USERS:
1878 purple_account_privacy_deny_add(account, who, FALSE);
1879 break;
1880 case PURPLE_ACCOUNT_PRIVACY_DENY_ALL:
1881 break;
1882 case PURPLE_ACCOUNT_PRIVACY_ALLOW_BUDDYLIST:
1883 if (purple_blist_find_buddy(account, who)) {
1884 add_all_buddies_to_permit_list(account, FALSE);
1885 purple_account_privacy_permit_remove(account, who, FALSE);
1886 purple_account_set_privacy_type(account, PURPLE_ACCOUNT_PRIVACY_ALLOW_USERS);
1887 }
1888 break;
1889 default:
1890 g_return_if_reached();
1891 }
1892
1893 /* Notify the server if the privacy setting was changed */
1894 if (type != purple_account_get_privacy_type(account) && purple_account_is_connected(account))
1895 purple_serv_set_permit_deny(purple_account_get_connection(account));
1896 }
1897
1898 GSList *
1899 purple_account_privacy_get_permitted(PurpleAccount *account)
1900 {
1901 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1902
1903 g_return_val_if_fail(priv != NULL, NULL);
1904
1905 return priv->permit;
1906 }
1907
1908 GSList *
1909 purple_account_privacy_get_denied(PurpleAccount *account)
1910 {
1911 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1912
1913 g_return_val_if_fail(priv != NULL, NULL);
1914
1915 return priv->deny;
1916 }
1917
1918 gboolean
1919 purple_account_privacy_check(PurpleAccount *account, const char *who)
1920 {
1921 GSList *list;
1922 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1923
1924 switch (purple_account_get_privacy_type(account)) {
1925 case PURPLE_ACCOUNT_PRIVACY_ALLOW_ALL:
1926 return TRUE;
1927
1928 case PURPLE_ACCOUNT_PRIVACY_DENY_ALL:
1929 return FALSE;
1930
1931 case PURPLE_ACCOUNT_PRIVACY_ALLOW_USERS:
1932 who = purple_normalize(account, who);
1933 for (list=priv->permit; list!=NULL; list=list->next) {
1934 if (g_str_equal(who, list->data))
1935 return TRUE;
1936 }
1937 return FALSE;
1938
1939 case PURPLE_ACCOUNT_PRIVACY_DENY_USERS:
1940 who = purple_normalize(account, who);
1941 for (list=priv->deny; list!=NULL; list=list->next) {
1942 if (g_str_equal(who, list->data))
1943 return FALSE;
1944 }
1945 return TRUE;
1946
1947 case PURPLE_ACCOUNT_PRIVACY_ALLOW_BUDDYLIST:
1948 return (purple_blist_find_buddy(account, who) != NULL);
1949
1950 default:
1951 g_return_val_if_reached(TRUE);
1952 }
1953 }
1954
1955 PurpleStatus *
1956 purple_account_get_active_status(const PurpleAccount *account)
1957 {
1958 PurpleAccountPrivate *priv;
1959
1960 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
1961
1962 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1963 return purple_presence_get_active_status(priv->presence);
1964 }
1965
1966 PurpleStatus *
1967 purple_account_get_status(const PurpleAccount *account, const char *status_id)
1968 {
1969 PurpleAccountPrivate *priv;
1970
1971 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
1972 g_return_val_if_fail(status_id != NULL, NULL);
1973
1974 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
1975
1976 return purple_presence_get_status(priv->presence, status_id);
1977 }
1978
1979 PurpleStatusType *
1980 purple_account_get_status_type(const PurpleAccount *account, const char *id)
1981 {
1982 GList *l;
1983
1984 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
1985 g_return_val_if_fail(id != NULL, NULL);
1986
1987 for (l = purple_account_get_status_types(account); l != NULL; l = l->next)
1988 {
1989 PurpleStatusType *status_type = (PurpleStatusType *)l->data;
1990
1991 if (purple_strequal(purple_status_type_get_id(status_type), id))
1992 return status_type;
1993 }
1994
1995 return NULL;
1996 }
1997
1998 PurpleStatusType *
1999 purple_account_get_status_type_with_primitive(const PurpleAccount *account, PurpleStatusPrimitive primitive)
2000 {
2001 GList *l;
2002
2003 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
2004
2005 for (l = purple_account_get_status_types(account); l != NULL; l = l->next)
2006 {
2007 PurpleStatusType *status_type = (PurpleStatusType *)l->data;
2008
2009 if (purple_status_type_get_primitive(status_type) == primitive)
2010 return status_type;
2011 }
2012
2013 return NULL;
2014 }
2015
2016 PurplePresence *
2017 purple_account_get_presence(const PurpleAccount *account)
2018 {
2019 PurpleAccountPrivate *priv;
2020
2021 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
2022
2023 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2024 return priv->presence;
2025 }
2026
2027 gboolean
2028 purple_account_is_status_active(const PurpleAccount *account,
2029 const char *status_id)
2030 {
2031 PurpleAccountPrivate *priv;
2032
2033 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), FALSE);
2034 g_return_val_if_fail(status_id != NULL, FALSE);
2035
2036 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2037
2038 return purple_presence_is_status_active(priv->presence, status_id);
2039 }
2040
2041 GList *
2042 purple_account_get_status_types(const PurpleAccount *account)
2043 {
2044 PurpleAccountPrivate *priv;
2045
2046 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
2047
2048 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2049 return priv->status_types;
2050 }
2051
2052 int
2053 purple_account_get_int(const PurpleAccount *account, const char *name,
2054 int default_value)
2055 {
2056 PurpleAccountSetting *setting;
2057 PurpleAccountPrivate *priv;
2058
2059 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), default_value);
2060 g_return_val_if_fail(name != NULL, default_value);
2061
2062 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2063
2064 setting = g_hash_table_lookup(priv->settings, name);
2065
2066 if (setting == NULL)
2067 return default_value;
2068
2069 g_return_val_if_fail(G_VALUE_HOLDS_INT(&setting->value), default_value);
2070
2071 return g_value_get_int(&setting->value);
2072 }
2073
2074 const char *
2075 purple_account_get_string(const PurpleAccount *account, const char *name,
2076 const char *default_value)
2077 {
2078 PurpleAccountSetting *setting;
2079 PurpleAccountPrivate *priv;
2080
2081 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), default_value);
2082 g_return_val_if_fail(name != NULL, default_value);
2083
2084 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2085
2086 setting = g_hash_table_lookup(priv->settings, name);
2087
2088 if (setting == NULL)
2089 return default_value;
2090
2091 g_return_val_if_fail(G_VALUE_HOLDS_STRING(&setting->value), default_value);
2092
2093 return g_value_get_string(&setting->value);
2094 }
2095
2096 gboolean
2097 purple_account_get_bool(const PurpleAccount *account, const char *name,
2098 gboolean default_value)
2099 {
2100 PurpleAccountSetting *setting;
2101 PurpleAccountPrivate *priv;
2102
2103 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), default_value);
2104 g_return_val_if_fail(name != NULL, default_value);
2105
2106 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2107
2108 setting = g_hash_table_lookup(priv->settings, name);
2109
2110 if (setting == NULL)
2111 return default_value;
2112
2113 g_return_val_if_fail(G_VALUE_HOLDS_BOOLEAN(&setting->value), default_value);
2114
2115 return g_value_get_boolean(&setting->value);
2116 }
2117
2118 int
2119 purple_account_get_ui_int(const PurpleAccount *account, const char *ui,
2120 const char *name, int default_value)
2121 {
2122 PurpleAccountSetting *setting;
2123 PurpleAccountPrivate *priv;
2124 GHashTable *table;
2125
2126 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), default_value);
2127 g_return_val_if_fail(ui != NULL, default_value);
2128 g_return_val_if_fail(name != NULL, default_value);
2129
2130 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2131
2132 if ((table = g_hash_table_lookup(priv->ui_settings, ui)) == NULL)
2133 return default_value;
2134
2135 if ((setting = g_hash_table_lookup(table, name)) == NULL)
2136 return default_value;
2137
2138 g_return_val_if_fail(G_VALUE_HOLDS_INT(&setting->value), default_value);
2139
2140 return g_value_get_int(&setting->value);
2141 }
2142
2143 const char *
2144 purple_account_get_ui_string(const PurpleAccount *account, const char *ui,
2145 const char *name, const char *default_value)
2146 {
2147 PurpleAccountSetting *setting;
2148 PurpleAccountPrivate *priv;
2149 GHashTable *table;
2150
2151 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), default_value);
2152 g_return_val_if_fail(ui != NULL, default_value);
2153 g_return_val_if_fail(name != NULL, default_value);
2154
2155 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2156
2157 if ((table = g_hash_table_lookup(priv->ui_settings, ui)) == NULL)
2158 return default_value;
2159
2160 if ((setting = g_hash_table_lookup(table, name)) == NULL)
2161 return default_value;
2162
2163 g_return_val_if_fail(G_VALUE_HOLDS_STRING(&setting->value), default_value);
2164
2165 return g_value_get_string(&setting->value);
2166 }
2167
2168 gboolean
2169 purple_account_get_ui_bool(const PurpleAccount *account, const char *ui,
2170 const char *name, gboolean default_value)
2171 {
2172 PurpleAccountSetting *setting;
2173 PurpleAccountPrivate *priv;
2174 GHashTable *table;
2175
2176 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), default_value);
2177 g_return_val_if_fail(ui != NULL, default_value);
2178 g_return_val_if_fail(name != NULL, default_value);
2179
2180 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2181
2182 if ((table = g_hash_table_lookup(priv->ui_settings, ui)) == NULL)
2183 return default_value;
2184
2185 if ((setting = g_hash_table_lookup(table, name)) == NULL)
2186 return default_value;
2187
2188 g_return_val_if_fail(G_VALUE_HOLDS_BOOLEAN(&setting->value), default_value);
2189
2190 return g_value_get_boolean(&setting->value);
2191 }
2192
2193 gpointer
2194 purple_account_get_ui_data(const PurpleAccount *account)
2195 {
2196 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
2197
2198 return account->ui_data;
2199 }
2200
2201 void
2202 purple_account_set_ui_data(PurpleAccount *account, gpointer ui_data)
2203 {
2204 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
2205
2206 account->ui_data = ui_data;
2207 }
2208
2209 PurpleLog *
2210 purple_account_get_log(PurpleAccount *account, gboolean create)
2211 {
2212 PurpleAccountPrivate *priv;
2213
2214 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), NULL);
2215
2216 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2217
2218 if(!priv->system_log && create){
2219 PurplePresence *presence;
2220 int login_time;
2221 GDateTime *dt;
2222
2223 presence = purple_account_get_presence(account);
2224 login_time = purple_presence_get_login_time(presence);
2225 if (login_time != 0) {
2226 dt = g_date_time_new_from_unix_local(login_time);
2227 } else {
2228 dt = g_date_time_new_now_local();
2229 }
2230
2231 priv->system_log = purple_log_new(PURPLE_LOG_SYSTEM,
2232 purple_account_get_username(account),
2233 account, NULL, dt);
2234 g_date_time_unref(dt);
2235 }
2236
2237 return priv->system_log;
2238 }
2239
2240 void
2241 purple_account_destroy_log(PurpleAccount *account)
2242 {
2243 PurpleAccountPrivate *priv;
2244
2245 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
2246
2247 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2248
2249 if(priv->system_log){
2250 purple_log_free(priv->system_log);
2251 priv->system_log = NULL;
2252 }
2253 }
2254
2255 void
2256 purple_account_add_buddy(PurpleAccount *account, PurpleBuddy *buddy, const char *message)
2257 {
2258 PurpleProtocol *protocol = NULL;
2259 PurpleConnection *gc;
2260
2261 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
2262 g_return_if_fail(PURPLE_IS_BUDDY(buddy));
2263
2264 gc = purple_account_get_connection(account);
2265 if (gc != NULL)
2266 protocol = purple_connection_get_protocol(gc);
2267
2268 if (protocol != NULL)
2269 purple_protocol_server_iface_add_buddy(protocol, gc, buddy,
2270 purple_buddy_get_group(buddy), message);
2271 }
2272
2273 void
2274 purple_account_add_buddies(PurpleAccount *account, GList *buddies, const char *message)
2275 {
2276 PurpleProtocol *protocol = NULL;
2277 PurpleConnection *gc = purple_account_get_connection(account);
2278
2279 if (gc != NULL)
2280 protocol = purple_connection_get_protocol(gc);
2281
2282 if (protocol) {
2283 GList *cur, *groups = NULL;
2284
2285 /* Make a list of what group each buddy is in */
2286 for (cur = buddies; cur != NULL; cur = cur->next) {
2287 PurpleBuddy *buddy = cur->data;
2288 groups = g_list_append(groups, purple_buddy_get_group(buddy));
2289 }
2290
2291 if (PURPLE_PROTOCOL_IMPLEMENTS(protocol, SERVER_IFACE, add_buddies))
2292 purple_protocol_server_iface_add_buddies(protocol, gc, buddies, groups, message);
2293 else if (PURPLE_PROTOCOL_IMPLEMENTS(protocol, SERVER_IFACE, add_buddy)) {
2294 GList *curb = buddies, *curg = groups;
2295
2296 while ((curb != NULL) && (curg != NULL)) {
2297 purple_protocol_server_iface_add_buddy(protocol, gc, curb->data, curg->data, message);
2298 curb = curb->next;
2299 curg = curg->next;
2300 }
2301 }
2302
2303 g_list_free(groups);
2304 }
2305 }
2306
2307 void
2308 purple_account_remove_buddy(PurpleAccount *account, PurpleBuddy *buddy,
2309 PurpleGroup *group)
2310 {
2311 PurpleProtocol *protocol = NULL;
2312 PurpleConnection *gc = purple_account_get_connection(account);
2313
2314 if (gc != NULL)
2315 protocol = purple_connection_get_protocol(gc);
2316
2317 if (protocol)
2318 purple_protocol_server_iface_remove_buddy(protocol, gc, buddy, group);
2319 }
2320
2321 void
2322 purple_account_remove_buddies(PurpleAccount *account, GList *buddies, GList *groups)
2323 {
2324 PurpleProtocol *protocol = NULL;
2325 PurpleConnection *gc = purple_account_get_connection(account);
2326
2327 if (gc != NULL)
2328 protocol = purple_connection_get_protocol(gc);
2329
2330 if (protocol) {
2331 if (PURPLE_PROTOCOL_IMPLEMENTS(protocol, SERVER_IFACE, remove_buddies))
2332 purple_protocol_server_iface_remove_buddies(protocol, gc, buddies, groups);
2333 else {
2334 GList *curb = buddies;
2335 GList *curg = groups;
2336 while ((curb != NULL) && (curg != NULL)) {
2337 purple_account_remove_buddy(account, curb->data, curg->data);
2338 curb = curb->next;
2339 curg = curg->next;
2340 }
2341 }
2342 }
2343 }
2344
2345 void
2346 purple_account_remove_group(PurpleAccount *account, PurpleGroup *group)
2347 {
2348 PurpleProtocol *protocol = NULL;
2349 PurpleConnection *gc = purple_account_get_connection(account);
2350
2351 if (gc != NULL)
2352 protocol = purple_connection_get_protocol(gc);
2353
2354 if (protocol)
2355 purple_protocol_server_iface_remove_group(protocol, gc, group);
2356 }
2357
2358 void
2359 purple_account_change_password(PurpleAccount *account, const char *orig_pw,
2360 const char *new_pw)
2361 {
2362 PurpleProtocol *protocol = NULL;
2363 PurpleConnection *gc = purple_account_get_connection(account);
2364
2365 purple_account_set_password(account, new_pw, NULL, NULL);
2366
2367 if (gc != NULL)
2368 protocol = purple_connection_get_protocol(gc);
2369
2370 if (protocol)
2371 purple_protocol_server_iface_change_passwd(protocol, gc, orig_pw, new_pw);
2372 }
2373
2374 gboolean purple_account_supports_offline_message(PurpleAccount *account, PurpleBuddy *buddy)
2375 {
2376 PurpleConnection *gc;
2377 PurpleProtocol *protocol = NULL;
2378
2379 g_return_val_if_fail(PURPLE_IS_ACCOUNT(account), FALSE);
2380 g_return_val_if_fail(PURPLE_IS_BUDDY(buddy), FALSE);
2381
2382 gc = purple_account_get_connection(account);
2383 if (gc == NULL)
2384 return FALSE;
2385
2386 protocol = purple_connection_get_protocol(gc);
2387
2388 if (!protocol)
2389 return FALSE;
2390 return purple_protocol_client_iface_offline_message(protocol, buddy);
2391 }
2392
2393 void
2394 _purple_account_set_current_error(PurpleAccount *account,
2395 PurpleConnectionErrorInfo *new_err)
2396 {
2397 PurpleConnectionErrorInfo *old_err;
2398 PurpleAccountPrivate *priv;
2399
2400 g_return_if_fail(PURPLE_IS_ACCOUNT(account));
2401 priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2402
2403 old_err = priv->current_error;
2404
2405 if(new_err == old_err)
2406 return;
2407
2408 priv->current_error = new_err;
2409
2410 purple_signal_emit(purple_accounts_get_handle(),
2411 "account-error-changed",
2412 account, old_err, new_err);
2413 purple_accounts_schedule_save();
2414
2415 if(old_err)
2416 g_free(old_err->description);
2417
2418 PURPLE_DBUS_UNREGISTER_POINTER(old_err);
2419 g_free(old_err);
2420 }
2421
2422 const PurpleConnectionErrorInfo *
2423 purple_account_get_current_error(PurpleAccount *account)
2424 {
2425 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2426
2427 return priv->current_error;
2428 }
2429
2430 void
2431 purple_account_clear_current_error(PurpleAccount *account)
2432 {
2433 _purple_account_set_current_error(account, NULL);
2434 }
2435
2436 static PurpleXmlNode *
2437 status_attribute_to_xmlnode(const PurpleStatus *status, const PurpleStatusType *type,
2438 const PurpleStatusAttribute *attr)
2439 {
2440 PurpleXmlNode *node;
2441 const char *id;
2442 char *value = NULL;
2443 PurpleStatusAttribute *default_attr;
2444 GValue *default_value;
2445 GType attr_type;
2446 GValue *attr_value;
2447
2448 id = purple_status_attribute_get_id(attr);
2449 g_return_val_if_fail(id, NULL);
2450
2451 attr_value = purple_status_get_attr_value(status, id);
2452 g_return_val_if_fail(attr_value, NULL);
2453 attr_type = G_VALUE_TYPE(attr_value);
2454
2455 /*
2456 * If attr_value is a different type than it should be
2457 * then don't write it to the file.
2458 */
2459 default_attr = purple_status_type_get_attr(type, id);
2460 default_value = purple_status_attribute_get_value(default_attr);
2461 if (attr_type != G_VALUE_TYPE(default_value))
2462 return NULL;
2463
2464 /*
2465 * If attr_value is the same as the default for this status
2466 * then there is no need to write it to the file.
2467 */
2468 if (attr_type == G_TYPE_STRING)
2469 {
2470 const char *string_value = g_value_get_string(attr_value);
2471 const char *default_string_value = g_value_get_string(default_value);
2472 if (purple_strequal(string_value, default_string_value))
2473 return NULL;
2474 value = g_strdup(g_value_get_string(attr_value));
2475 }
2476 else if (attr_type == G_TYPE_INT)
2477 {
2478 int int_value = g_value_get_int(attr_value);
2479 if (int_value == g_value_get_int(default_value))
2480 return NULL;
2481 value = g_strdup_printf("%d", int_value);
2482 }
2483 else if (attr_type == G_TYPE_BOOLEAN)
2484 {
2485 gboolean boolean_value = g_value_get_boolean(attr_value);
2486 if (boolean_value == g_value_get_boolean(default_value))
2487 return NULL;
2488 value = g_strdup(boolean_value ?
2489 "true" : "false");
2490 }
2491 else
2492 {
2493 return NULL;
2494 }
2495
2496 g_return_val_if_fail(value, NULL);
2497
2498 node = purple_xmlnode_new("attribute");
2499
2500 purple_xmlnode_set_attrib(node, "id", id);
2501 purple_xmlnode_set_attrib(node, "value", value);
2502
2503 g_free(value);
2504
2505 return node;
2506 }
2507
2508 static PurpleXmlNode *
2509 status_attrs_to_xmlnode(const PurpleStatus *status)
2510 {
2511 PurpleStatusType *type = purple_status_get_status_type(status);
2512 PurpleXmlNode *node, *child;
2513 GList *attrs, *attr;
2514
2515 node = purple_xmlnode_new("attributes");
2516
2517 attrs = purple_status_type_get_attrs(type);
2518 for (attr = attrs; attr != NULL; attr = attr->next)
2519 {
2520 child = status_attribute_to_xmlnode(status, type, (const PurpleStatusAttribute *)attr->data);
2521 if (child)
2522 purple_xmlnode_insert_child(node, child);
2523 }
2524
2525 return node;
2526 }
2527
2528 static PurpleXmlNode *
2529 status_to_xmlnode(const PurpleStatus *status)
2530 {
2531 PurpleXmlNode *node, *child;
2532
2533 node = purple_xmlnode_new("status");
2534 purple_xmlnode_set_attrib(node, "type", purple_status_get_id(status));
2535 if (purple_status_get_name(status) != NULL)
2536 purple_xmlnode_set_attrib(node, "name", purple_status_get_name(status));
2537 purple_xmlnode_set_attrib(node, "active", purple_status_is_active(status) ? "true" : "false");
2538
2539 child = status_attrs_to_xmlnode(status);
2540 purple_xmlnode_insert_child(node, child);
2541
2542 return node;
2543 }
2544
2545 static PurpleXmlNode *
2546 statuses_to_xmlnode(const PurplePresence *presence)
2547 {
2548 PurpleXmlNode *node, *child;
2549 GList *statuses;
2550 PurpleStatus *status;
2551
2552 node = purple_xmlnode_new("statuses");
2553
2554 statuses = purple_presence_get_statuses(presence);
2555 for (; statuses != NULL; statuses = statuses->next)
2556 {
2557 status = statuses->data;
2558 if (purple_status_type_is_saveable(purple_status_get_status_type(status)))
2559 {
2560 child = status_to_xmlnode(status);
2561 purple_xmlnode_insert_child(node, child);
2562 }
2563 }
2564
2565 return node;
2566 }
2567
2568 static PurpleXmlNode *
2569 proxy_settings_to_xmlnode(PurpleProxyInfo *proxy_info)
2570 {
2571 PurpleXmlNode *node, *child;
2572 PurpleProxyType proxy_type;
2573 const char *value;
2574 int int_value;
2575 char buf[21];
2576
2577 proxy_type = purple_proxy_info_get_proxy_type(proxy_info);
2578
2579 node = purple_xmlnode_new("proxy");
2580
2581 child = purple_xmlnode_new_child(node, "type");
2582 purple_xmlnode_insert_data(child,
2583 (proxy_type == PURPLE_PROXY_USE_GLOBAL ? "global" :
2584 proxy_type == PURPLE_PROXY_NONE ? "none" :
2585 proxy_type == PURPLE_PROXY_HTTP ? "http" :
2586 proxy_type == PURPLE_PROXY_SOCKS4 ? "socks4" :
2587 proxy_type == PURPLE_PROXY_SOCKS5 ? "socks5" :
2588 proxy_type == PURPLE_PROXY_TOR ? "tor" :
2589 proxy_type == PURPLE_PROXY_USE_ENVVAR ? "envvar" : "unknown"), -1);
2590
2591 if ((value = purple_proxy_info_get_host(proxy_info)) != NULL)
2592 {
2593 child = purple_xmlnode_new_child(node, "host");
2594 purple_xmlnode_insert_data(child, value, -1);
2595 }
2596
2597 if ((int_value = purple_proxy_info_get_port(proxy_info)) != 0)
2598 {
2599 g_snprintf(buf, sizeof(buf), "%d", int_value);
2600 child = purple_xmlnode_new_child(node, "port");
2601 purple_xmlnode_insert_data(child, buf, -1);
2602 }
2603
2604 if ((value = purple_proxy_info_get_username(proxy_info)) != NULL)
2605 {
2606 child = purple_xmlnode_new_child(node, "username");
2607 purple_xmlnode_insert_data(child, value, -1);
2608 }
2609
2610 if ((value = purple_proxy_info_get_password(proxy_info)) != NULL)
2611 {
2612 child = purple_xmlnode_new_child(node, "password");
2613 purple_xmlnode_insert_data(child, value, -1);
2614 }
2615
2616 return node;
2617 }
2618
2619 static PurpleXmlNode *
2620 current_error_to_xmlnode(PurpleConnectionErrorInfo *err)
2621 {
2622 PurpleXmlNode *node, *child;
2623 char type_str[3];
2624
2625 node = purple_xmlnode_new("current_error");
2626
2627 if(err == NULL)
2628 return node;
2629
2630 /* It doesn't make sense to have transient errors persist across a
2631 * restart.
2632 */
2633 if(!purple_connection_error_is_fatal (err->type))
2634 return node;
2635
2636 child = purple_xmlnode_new_child(node, "type");
2637 g_snprintf(type_str, sizeof(type_str), "%u", err->type);
2638 purple_xmlnode_insert_data(child, type_str, -1);
2639
2640 child = purple_xmlnode_new_child(node, "description");
2641 if(err->description) {
2642 char *utf8ized = purple_utf8_try_convert(err->description);
2643 if(utf8ized == NULL)
2644 utf8ized = purple_utf8_salvage(err->description);
2645 purple_xmlnode_insert_data(child, utf8ized, -1);
2646 g_free(utf8ized);
2647 }
2648
2649 return node;
2650 }
2651
2652 static void
2653 setting_to_xmlnode(gpointer key, gpointer value, gpointer user_data)
2654 {
2655 const char *name;
2656 PurpleAccountSetting *setting;
2657 PurpleXmlNode *node, *child;
2658 char buf[21];
2659
2660 name = (const char *)key;
2661 setting = (PurpleAccountSetting *)value;
2662 node = (PurpleXmlNode *)user_data;
2663
2664 child = purple_xmlnode_new_child(node, "setting");
2665 purple_xmlnode_set_attrib(child, "name", name);
2666
2667 if (G_VALUE_HOLDS_INT(&setting->value)) {
2668 purple_xmlnode_set_attrib(child, "type", "int");
2669 g_snprintf(buf, sizeof(buf), "%d", g_value_get_int(&setting->value));
2670 purple_xmlnode_insert_data(child, buf, -1);
2671 }
2672 else if (G_VALUE_HOLDS_STRING(&setting->value) && g_value_get_string(&setting->value) != NULL) {
2673 purple_xmlnode_set_attrib(child, "type", "string");
2674 purple_xmlnode_insert_data(child, g_value_get_string(&setting->value), -1);
2675 }
2676 else if (G_VALUE_HOLDS_BOOLEAN(&setting->value)) {
2677 purple_xmlnode_set_attrib(child, "type", "bool");
2678 g_snprintf(buf, sizeof(buf), "%d", g_value_get_boolean(&setting->value));
2679 purple_xmlnode_insert_data(child, buf, -1);
2680 }
2681 }
2682
2683 static void
2684 ui_setting_to_xmlnode(gpointer key, gpointer value, gpointer user_data)
2685 {
2686 const char *ui;
2687 GHashTable *table;
2688 PurpleXmlNode *node, *child;
2689
2690 ui = (const char *)key;
2691 table = (GHashTable *)value;
2692 node = (PurpleXmlNode *)user_data;
2693
2694 if (g_hash_table_size(table) > 0)
2695 {
2696 child = purple_xmlnode_new_child(node, "settings");
2697 purple_xmlnode_set_attrib(child, "ui", ui);
2698 g_hash_table_foreach(table, setting_to_xmlnode, child);
2699 }
2700 }
2701
2702 PurpleXmlNode *
2703 _purple_account_to_xmlnode(PurpleAccount *account)
2704 {
2705 PurpleXmlNode *node, *child;
2706 const char *tmp;
2707 PurplePresence *presence;
2708 PurpleProxyInfo *proxy_info;
2709 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2710
2711 node = purple_xmlnode_new("account");
2712
2713 child = purple_xmlnode_new_child(node, "protocol");
2714 purple_xmlnode_insert_data(child, purple_account_get_protocol_id(account), -1);
2715
2716 child = purple_xmlnode_new_child(node, "name");
2717 purple_xmlnode_insert_data(child, purple_account_get_username(account), -1);
2718
2719 if (purple_account_get_remember_password(account))
2720 {
2721 const char *keyring_id = NULL;
2722 const char *mode = NULL;
2723 char *data = NULL;
2724 GError *error = NULL;
2725 GDestroyNotify destroy = NULL;
2726 gboolean exported = purple_keyring_export_password(account,
2727 &keyring_id, &mode, &data, &error, &destroy);
2728
2729 if (error != NULL) {
2730 purple_debug_error("account",
2731 "Failed to export password for account %s: %s.\n",
2732 purple_account_get_username(account),
2733 error->message);
2734 } else if (exported) {
2735 child = purple_xmlnode_new_child(node, "password");
2736 if (keyring_id != NULL)
2737 purple_xmlnode_set_attrib(child, "keyring_id", keyring_id);
2738 if (mode != NULL)
2739 purple_xmlnode_set_attrib(child, "mode", mode);
2740 if (data != NULL)
2741 purple_xmlnode_insert_data(child, data, -1);
2742
2743 if (destroy != NULL)
2744 destroy(data);
2745 }
2746 }
2747
2748 if ((tmp = purple_account_get_private_alias(account)) != NULL)
2749 {
2750 child = purple_xmlnode_new_child(node, "alias");
2751 purple_xmlnode_insert_data(child, tmp, -1);
2752 }
2753
2754 if ((presence = purple_account_get_presence(account)) != NULL)
2755 {
2756 child = statuses_to_xmlnode(presence);
2757 purple_xmlnode_insert_child(node, child);
2758 }
2759
2760 if ((tmp = purple_account_get_user_info(account)) != NULL)
2761 {
2762 /* TODO: Do we need to call purple_str_strip_char(tmp, '\r') here? */
2763 child = purple_xmlnode_new_child(node, "user-info");
2764 purple_xmlnode_insert_data(child, tmp, -1);
2765 }
2766
2767 if (g_hash_table_size(priv->settings) > 0)
2768 {
2769 child = purple_xmlnode_new_child(node, "settings");
2770 g_hash_table_foreach(priv->settings, setting_to_xmlnode, child);
2771 }
2772
2773 if (g_hash_table_size(priv->ui_settings) > 0)
2774 {
2775 g_hash_table_foreach(priv->ui_settings, ui_setting_to_xmlnode, node);
2776 }
2777
2778 if ((proxy_info = purple_account_get_proxy_info(account)) != NULL)
2779 {
2780 child = proxy_settings_to_xmlnode(proxy_info);
2781 purple_xmlnode_insert_child(node, child);
2782 }
2783
2784 child = current_error_to_xmlnode(priv->current_error);
2785 purple_xmlnode_insert_child(node, child);
2786
2787 return node;
2788 }
2789
2790 /****************
2791 * GObject Code *
2792 ****************/
2793
2794 /* Set method for GObject properties */
2795 static void
2796 purple_account_set_property(GObject *obj, guint param_id, const GValue *value,
2797 GParamSpec *pspec)
2798 {
2799 PurpleAccount *account = PURPLE_ACCOUNT(obj);
2800
2801 switch (param_id) {
2802 case PROP_USERNAME:
2803 purple_account_set_username(account, g_value_get_string(value));
2804 break;
2805 case PROP_PRIVATE_ALIAS:
2806 purple_account_set_private_alias(account, g_value_get_string(value));
2807 break;
2808 case PROP_ENABLED:
2809 purple_account_set_enabled(account, purple_core_get_ui(),
2810 g_value_get_boolean(value));
2811 break;
2812 case PROP_CONNECTION:
2813 purple_account_set_connection(account, g_value_get_object(value));
2814 break;
2815 case PROP_PROTOCOL_ID:
2816 purple_account_set_protocol_id(account, g_value_get_string(value));
2817 break;
2818 case PROP_USER_INFO:
2819 purple_account_set_user_info(account, g_value_get_string(value));
2820 break;
2821 case PROP_BUDDY_ICON_PATH:
2822 purple_account_set_buddy_icon_path(account,
2823 g_value_get_string(value));
2824 break;
2825 case PROP_REMEMBER_PASSWORD:
2826 purple_account_set_remember_password(account,
2827 g_value_get_boolean(value));
2828 break;
2829 case PROP_CHECK_MAIL:
2830 purple_account_set_check_mail(account, g_value_get_boolean(value));
2831 break;
2832 default:
2833 G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
2834 break;
2835 }
2836 }
2837
2838 /* Get method for GObject properties */
2839 static void
2840 purple_account_get_property(GObject *obj, guint param_id, GValue *value,
2841 GParamSpec *pspec)
2842 {
2843 PurpleAccount *account = PURPLE_ACCOUNT(obj);
2844
2845 switch (param_id) {
2846 case PROP_USERNAME:
2847 g_value_set_string(value, purple_account_get_username(account));
2848 break;
2849 case PROP_PRIVATE_ALIAS:
2850 g_value_set_string(value, purple_account_get_private_alias(account));
2851 break;
2852 case PROP_ENABLED:
2853 g_value_set_boolean(value, purple_account_get_enabled(account,
2854 purple_core_get_ui()));
2855 break;
2856 case PROP_CONNECTION:
2857 g_value_set_object(value, purple_account_get_connection(account));
2858 break;
2859 case PROP_PROTOCOL_ID:
2860 g_value_set_string(value, purple_account_get_protocol_id(account));
2861 break;
2862 case PROP_USER_INFO:
2863 g_value_set_string(value, purple_account_get_user_info(account));
2864 break;
2865 case PROP_BUDDY_ICON_PATH:
2866 g_value_set_string(value,
2867 purple_account_get_buddy_icon_path(account));
2868 break;
2869 case PROP_REMEMBER_PASSWORD:
2870 g_value_set_boolean(value,
2871 purple_account_get_remember_password(account));
2872 break;
2873 case PROP_CHECK_MAIL:
2874 g_value_set_boolean(value, purple_account_get_check_mail(account));
2875 break;
2876 default:
2877 G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
2878 break;
2879 }
2880 }
2881
2882 /* GObject initialization function */
2883 static void purple_account_init(GTypeInstance *instance, gpointer klass)
2884 {
2885 PurpleAccount *account = PURPLE_ACCOUNT(instance);
2886 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2887
2888 priv->settings = g_hash_table_new_full(g_str_hash, g_str_equal,
2889 g_free, delete_setting);
2890 priv->ui_settings = g_hash_table_new_full(g_str_hash, g_str_equal,
2891 g_free, (GDestroyNotify)g_hash_table_destroy);
2892 priv->system_log = NULL;
2893
2894 priv->privacy_type = PURPLE_ACCOUNT_PRIVACY_ALLOW_ALL;
2895
2896 PURPLE_DBUS_REGISTER_POINTER(account, PurpleAccount);
2897 }
2898
2899 /* Called when done constructing */
2900 static void
2901 purple_account_constructed(GObject *object)
2902 {
2903 PurpleAccount *account = PURPLE_ACCOUNT(object);
2904 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2905 gchar *username, *protocol_id;
2906 PurpleProtocol *protocol = NULL;
2907 PurpleStatusType *status_type;
2908
2909 parent_class->constructed(object);
2910
2911 g_object_get(object,
2912 "username", &username,
2913 "protocol-id", &protocol_id,
2914 NULL);
2915
2916 purple_signal_emit(purple_accounts_get_handle(), "account-created",
2917 account);
2918
2919 protocol = purple_protocols_find(protocol_id);
2920 if (protocol == NULL) {
2921 g_free(username);
2922 g_free(protocol_id);
2923 return;
2924 }
2925
2926 purple_account_set_status_types(account,
2927 purple_protocol_class_status_types(protocol, account));
2928
2929 priv->presence = PURPLE_PRESENCE(purple_account_presence_new(account));
2930
2931 status_type = purple_account_get_status_type_with_primitive(account,
2932 PURPLE_STATUS_AVAILABLE);
2933 if (status_type != NULL)
2934 purple_presence_set_status_active(priv->presence,
2935 purple_status_type_get_id(status_type),
2936 TRUE);
2937 else
2938 purple_presence_set_status_active(priv->presence,
2939 "offline",
2940 TRUE);
2941
2942 g_free(username);
2943 g_free(protocol_id);
2944 }
2945
2946 /* GObject dispose function */
2947 static void
2948 purple_account_dispose(GObject *object)
2949 {
2950 PurpleAccount *account = PURPLE_ACCOUNT(object);
2951 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2952
2953 if (!purple_account_is_disconnected(account))
2954 purple_account_disconnect(account);
2955
2956 if (priv->presence) {
2957 g_object_unref(priv->presence);
2958 priv->presence = NULL;
2959 }
2960
2961 parent_class->dispose(object);
2962 }
2963
2964 /* GObject finalize function */
2965 static void
2966 purple_account_finalize(GObject *object)
2967 {
2968 GList *l;
2969 PurpleAccount *account = PURPLE_ACCOUNT(object);
2970 PurpleAccountPrivate *priv = PURPLE_ACCOUNT_GET_PRIVATE(account);
2971
2972 purple_debug_info("account", "Destroying account %p\n", account);
2973 purple_signal_emit(purple_accounts_get_handle(), "account-destroying",
2974 account);
2975
2976 for (l = purple_conversations_get_all(); l != NULL; l = l->next)
2977 {
2978 PurpleConversation *conv = (PurpleConversation *)l->data;
2979
2980 if (purple_conversation_get_account(conv) == account)
2981 purple_conversation_set_account(conv, NULL);
2982 }
2983
2984 purple_account_set_status_types(account, NULL);
2985
2986 if (priv->proxy_info)
2987 purple_proxy_info_destroy(priv->proxy_info);
2988
2989 if(priv->system_log)
2990 purple_log_free(priv->system_log);
2991
2992 PURPLE_DBUS_UNREGISTER_POINTER(priv->current_error);
2993 if (priv->current_error) {
2994 g_free(priv->current_error->description);
2995 g_free(priv->current_error);
2996 }
2997
2998 g_free(priv->username);
2999 g_free(priv->alias);
3000 purple_str_wipe(priv->password);
3001 g_free(priv->user_info);
3002 g_free(priv->buddy_icon_path);
3003 g_free(priv->protocol_id);
3004
3005 g_hash_table_destroy(priv->settings);
3006 g_hash_table_destroy(priv->ui_settings);
3007
3008 while (priv->deny) {
3009 g_free(priv->deny->data);
3010 priv->deny = g_slist_delete_link(priv->deny, priv->deny);
3011 }
3012
3013 while (priv->permit) {
3014 g_free(priv->permit->data);
3015 priv->permit = g_slist_delete_link(priv->permit, priv->permit);
3016 }
3017
3018 PURPLE_DBUS_UNREGISTER_POINTER(account);
3019
3020 parent_class->finalize(object);
3021 }
3022
3023 /* Class initializer function */
3024 static void
3025 purple_account_class_init(PurpleAccountClass *klass)
3026 {
3027 GObjectClass *obj_class = G_OBJECT_CLASS(klass);
3028
3029 parent_class = g_type_class_peek_parent(klass);
3030
3031 obj_class->dispose = purple_account_dispose;
3032 obj_class->finalize = purple_account_finalize;
3033 obj_class->constructed = purple_account_constructed;
3034
3035 /* Setup properties */
3036 obj_class->get_property = purple_account_get_property;
3037 obj_class->set_property = purple_account_set_property;
3038
3039 g_type_class_add_private(klass, sizeof(PurpleAccountPrivate));
3040
3041 properties[PROP_USERNAME] = g_param_spec_string("username", "Username",
3042 "The username for the account.", NULL,
3043 G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS);
3044
3045 properties[PROP_PRIVATE_ALIAS] = g_param_spec_string("private-alias",
3046 "Private Alias",
3047 "The private alias for the account.", NULL,
3048 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
3049
3050 properties[PROP_USER_INFO] = g_param_spec_string("user-info",
3051 "User information",
3052 "Detailed user information for the account.", NULL,
3053 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
3054
3055 properties[PROP_BUDDY_ICON_PATH] = g_param_spec_string("buddy-icon-path",
3056 "Buddy icon path",
3057 "Path to the buddyicon for the account.", NULL,
3058 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
3059
3060 properties[PROP_ENABLED] = g_param_spec_boolean("enabled", "Enabled",
3061 "Whether the account is enabled or not.", FALSE,
3062 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
3063
3064 properties[PROP_REMEMBER_PASSWORD] = g_param_spec_boolean(
3065 "remember-password", "Remember password",
3066 "Whether to remember and store the password for this account.",
3067 FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
3068
3069 properties[PROP_CHECK_MAIL] = g_param_spec_boolean("check-mail",
3070 "Check mail",
3071 "Whether to check mails for this account.", FALSE,
3072 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
3073
3074 properties[PROP_CONNECTION] = g_param_spec_object("connection",
3075 "Connection",
3076 "The connection for the account.", PURPLE_TYPE_CONNECTION,
3077 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
3078
3079 properties[PROP_PROTOCOL_ID] = g_param_spec_string("protocol-id",
3080 "Protocol ID",
3081 "ID of the protocol that is responsible for the account.", NULL,
3082 G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY |
3083 G_PARAM_STATIC_STRINGS);
3084
3085 g_object_class_install_properties(obj_class, PROP_LAST, properties);
3086 }
3087
3088 GType
3089 purple_account_get_type(void)
3090 {
3091 static GType type = 0;
3092
3093 if(type == 0) {
3094 static const GTypeInfo info = {
3095 sizeof(PurpleAccountClass),
3096 NULL,
3097 NULL,
3098 (GClassInitFunc)purple_account_class_init,
3099 NULL,
3100 NULL,
3101 sizeof(PurpleAccount),
3102 0,
3103 (GInstanceInitFunc)purple_account_init,
3104 NULL,
3105 };
3106
3107 type = g_type_register_static(G_TYPE_OBJECT,
3108 "PurpleAccount",
3109 &info, 0);
3110 }
3111
3112 return type;
3113 }
3114
3115 PurpleAccount *
3116 purple_account_new(const char *username, const char *protocol_id)
3117 {
3118 PurpleAccount *account;
3119
3120 g_return_val_if_fail(username != NULL, NULL);
3121 g_return_val_if_fail(protocol_id != NULL, NULL);
3122
3123 account = purple_accounts_find(username, protocol_id);
3124
3125 if (account != NULL)
3126 return account;
3127
3128 account = g_object_new(PURPLE_TYPE_ACCOUNT,
3129 "username", username,
3130 "protocol-id", protocol_id,
3131 NULL);
3132
3133 return account;
3134 }
Git mirror of Pidgin's Mercurial repository