Mercurial > pidgin.yaz
annotate src/protocols/novell/novell.c @ 12216:4d3119205a33
[gaim-migrate @ 14518]
Remove GaimConvImFlags and GaimConvChatFlags - use GaimMessageFlags
everywhere instead.
Add a new GAIM_MESSAGE_IMAGES flag, and set it when sending a message
containing images.
When sending a message, the core will now always send "html" to the prpls,
just like it expects to receive html from the prpls for received messages.
This will allow text prpls such as SILC to support IM images and differentiate
them from user input. Previously gaim_unescape_html() was used before passing
the message to the prpl, now the prpl does this itself if it needs it.
I think I updated all the prpls correctly, but I'm not so sure about sametime.
committer: Tailor Script <tailor@pidgin.im>
author | Stu Tomlinson <stu@nosnilmot.com> |
---|---|
date | Thu, 24 Nov 2005 20:47:46 +0000 |
parents | cbebda5f019c |
children | b1d06ade0e10 |
rev | line source |
---|---|
8675 | 1 /* |
2 * novell.c | |
3 * | |
8933 | 4 * Copyright (c) 2004 Novell, Inc. All Rights Reserved. |
5 * | |
6 * This program is free software; you can redistribute it and/or modify | |
7 * it under the terms of the GNU General Public License as published by | |
8 * the Free Software Foundation; version 2 of the License. | |
8675 | 9 * |
8933 | 10 * This program is distributed in the hope that it will be useful, |
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
13 * GNU General Public License for more details. | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
14 * |
8933 | 15 * You should have received a copy of the GNU General Public License |
16 * along with this program; if not, write to the Free Software | |
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
8675 | 18 * |
19 */ | |
20 | |
21 #include "internal.h" | |
22 #include "accountopt.h" | |
23 #include "debug.h" | |
24 #include "prpl.h" | |
25 #include "server.h" | |
26 #include "nmuser.h" | |
27 #include "notify.h" | |
28 #include "util.h" | |
29 #include "sslconn.h" | |
30 #include "request.h" | |
31 #include "network.h" | |
8933 | 32 #include "privacy.h" |
10762 | 33 #include "status.h" |
9943 | 34 #include "version.h" |
8675 | 35 |
36 #define DEFAULT_PORT 8300 | |
37 #define NOVELL_CONNECT_STEPS 4 | |
9651 | 38 #define NM_ROOT_FOLDER_NAME "GroupWise Messenger" |
8675 | 39 |
40 static GaimPlugin *my_protocol = NULL; | |
41 | |
42 static gboolean | |
43 _is_disconnect_error(NMERR_T err); | |
44 | |
45 static gboolean | |
46 _check_for_disconnect(NMUser * user, NMERR_T err); | |
47 | |
48 static void | |
49 _send_message(NMUser * user, NMMessage * message); | |
50 | |
51 static void | |
52 _update_buddy_status(GaimBuddy * buddy, int status, int gmt); | |
53 | |
54 static void | |
55 _remove_gaim_buddies(NMUser * user); | |
56 | |
57 static void | |
58 _add_contacts_to_gaim_blist(NMUser * user, NMFolder * folder); | |
59 | |
60 static void | |
61 _add_gaim_buddies(NMUser * user); | |
62 | |
63 static void | |
8933 | 64 _sync_contact_list(NMUser *user); |
65 | |
66 static void | |
67 _sync_privacy_lists(NMUser *user); | |
68 | |
69 static void | |
8675 | 70 _show_info(GaimConnection * gc, NMUserRecord * user_record); |
71 | |
8933 | 72 const char * |
73 _get_conference_name(int id); | |
74 | |
8675 | 75 /******************************************************************************* |
76 * Response callbacks | |
77 *******************************************************************************/ | |
78 | |
79 /* Handle login response */ | |
80 static void | |
81 _login_resp_cb(NMUser * user, NMERR_T ret_code, | |
82 gpointer resp_data, gpointer user_data) | |
83 { | |
84 GaimConnection *gc; | |
85 const char *alias; | |
86 NMERR_T rc; | |
87 | |
88 if (user == NULL) | |
89 return; | |
90 | |
91 gc = gaim_account_get_connection(user->client_data); | |
92 if (gc == NULL) | |
93 return; | |
94 | |
95 if (ret_code == NM_OK) { | |
96 | |
97 /* Set alias for user if not set (use Full Name) */ | |
98 alias = gaim_account_get_alias(user->client_data); | |
99 if (alias == NULL || *alias == '\0') { | |
100 alias = nm_user_record_get_full_name(user->user_record); | |
101 | |
102 if (alias) | |
103 gaim_account_set_alias(user->client_data, alias); | |
104 } | |
105 | |
106 /* Tell Gaim that we are connected */ | |
107 gaim_connection_set_state(gc, GAIM_CONNECTED); | |
108 | |
9360 | 109 _sync_contact_list(user); |
110 | |
8675 | 111 rc = nm_send_set_status(user, NM_STATUS_AVAILABLE, NULL, NULL, NULL, |
112 NULL); | |
113 _check_for_disconnect(user, rc); | |
114 | |
115 } else { | |
116 | |
8933 | 117 char *err = g_strdup_printf(_("Login failed (%s)."), |
118 nm_error_to_string (ret_code)); | |
8675 | 119 |
120 gaim_connection_error(gc, err); | |
121 g_free(err); | |
122 | |
123 } | |
124 } | |
125 | |
126 /* Handle getstatus response*/ | |
127 static void | |
128 _get_status_resp_cb(NMUser * user, NMERR_T ret_code, | |
129 gpointer resp_data, gpointer user_data) | |
130 { | |
131 GaimBuddy *buddy; | |
132 GSList *buddies; | |
133 GSList *bnode; | |
134 NMUserRecord *user_record = (NMUserRecord *) resp_data; | |
135 int status; | |
136 | |
137 if (user == NULL || user_record == NULL) | |
138 return; | |
139 | |
140 if (ret_code == NM_OK) { | |
141 | |
142 /* Find all Gaim buddies and update their statuses */ | |
143 const char *name = nm_user_record_get_display_id(user_record); | |
144 | |
145 if (name) { | |
146 buddies = gaim_find_buddies((GaimAccount *) user->client_data, name); | |
147 for (bnode = buddies; bnode; bnode = bnode->next) { | |
148 buddy = (GaimBuddy *) bnode->data; | |
149 if (buddy) { | |
150 status = nm_user_record_get_status(user_record); | |
151 _update_buddy_status(buddy, status, time(0)); | |
152 } | |
153 } | |
12126
35c4797c5c57
[gaim-migrate @ 14426]
Richard Laager <rlaager@wiktel.com>
parents:
11972
diff
changeset
|
154 g_slist_free(buddies); |
8675 | 155 } |
156 | |
157 } else { | |
158 | |
159 gaim_debug(GAIM_DEBUG_INFO, "novell", | |
160 "_get_status_resp_cb(): rc = 0x%X\n", ret_code); | |
161 | |
162 } | |
163 } | |
164 | |
165 /* Show an error if the rename failed */ | |
166 static void | |
167 _rename_contact_resp_cb(NMUser * user, NMERR_T ret_code, | |
168 gpointer resp_data, gpointer user_data) | |
169 { | |
170 if (ret_code != NM_OK) { | |
171 gaim_debug(GAIM_DEBUG_INFO, "novell", | |
172 "_rename_contact_resp_cb(): rc = 0x%X\n", ret_code); | |
173 } | |
174 } | |
175 | |
176 /* Handle the getdetails response and send the message */ | |
177 static void | |
178 _get_details_resp_send_msg(NMUser * user, NMERR_T ret_code, | |
179 gpointer resp_data, gpointer user_data) | |
180 { | |
181 GaimConversation *gconv; | |
182 GaimConnection *gc; | |
183 NMUserRecord *user_record = NULL; | |
184 NMContact *cntct = NULL; | |
185 NMConference *conf; | |
186 NMMessage *msg = user_data; | |
187 const char *dn = NULL; | |
188 const char *name; | |
189 | |
190 if (user == NULL || msg == NULL) | |
191 return; | |
192 | |
193 if (ret_code == NM_OK) { | |
194 user_record = (NMUserRecord *) resp_data; | |
195 if (user_record) { | |
196 | |
197 /* Set the title for the conversation */ | |
11338 | 198 /* XXX - Should this be GAIM_CONV_TYPE_IM? */ |
199 gconv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_ANY, | |
10246 | 200 nm_user_record_get_display_id(user_record), |
8675 | 201 (GaimAccount *) user->client_data); |
202 if (gconv) { | |
203 | |
204 dn = nm_user_record_get_dn(user_record); | |
205 if (dn) { | |
206 cntct = nm_find_contact(user, dn); | |
207 } | |
208 | |
209 if (cntct) { | |
210 gaim_conversation_set_title(gconv, | |
211 nm_contact_get_display_name(cntct)); | |
212 } else { | |
213 | |
214 /* Not in the contact list, try to user full name */ | |
215 name = (char *) nm_user_record_get_full_name(user_record); | |
216 if (name) | |
217 gaim_conversation_set_title(gconv, name); | |
218 } | |
219 } | |
220 | |
221 /* Add the user record to particpant list */ | |
222 conf = nm_message_get_conference(msg); | |
223 if (conf) { | |
224 nm_conference_add_participant(conf, user_record); | |
225 _send_message(user, msg); | |
226 } | |
227 } | |
228 | |
229 } else { | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
230 |
8675 | 231 gc = gaim_account_get_connection(user->client_data); |
232 if (gc != NULL) { | |
233 char *err = g_strdup_printf(_("Unable to send message." | |
8933 | 234 " Could not get details for user (%s)."), |
235 nm_error_to_string (ret_code)); | |
8675 | 236 |
237 gaim_notify_error(gc, NULL, err, NULL); | |
238 g_free(err); | |
239 } | |
240 | |
241 if (msg) | |
242 nm_release_message(msg); | |
243 } | |
244 } | |
245 | |
246 /* Set up the new GaimBuddy based on the response from getdetails */ | |
247 static void | |
248 _get_details_resp_setup_buddy(NMUser * user, NMERR_T ret_code, | |
249 gpointer resp_data, gpointer user_data) | |
250 { | |
251 NMUserRecord *user_record; | |
252 NMContact *contact; | |
253 GaimBuddy *buddy; | |
254 const char *alias; | |
255 NMERR_T rc = NM_OK; | |
256 | |
257 if (user == NULL || resp_data == NULL || user_data == NULL) | |
258 return; | |
259 | |
260 contact = user_data; | |
261 | |
262 if (ret_code == NM_OK) { | |
263 user_record = resp_data; | |
264 | |
265 buddy = nm_contact_get_data(contact); | |
266 | |
267 nm_contact_set_user_record(contact, user_record); | |
268 | |
269 /* Set the display id */ | |
270 gaim_blist_rename_buddy(buddy, | |
271 nm_user_record_get_display_id(user_record)); | |
272 | |
9620 | 273 alias = gaim_buddy_get_alias(buddy); |
9679 | 274 if (alias == NULL || *alias == '\0' || (strcmp(alias, buddy->name) == 0)) { |
8675 | 275 gaim_blist_alias_buddy(buddy, |
276 nm_user_record_get_full_name(user_record)); | |
277 | |
278 /* Tell the server about the new display name */ | |
279 rc = nm_send_rename_contact(user, contact, | |
280 nm_user_record_get_full_name(user_record), | |
281 NULL, NULL); | |
282 _check_for_disconnect(user, rc); | |
283 | |
284 } | |
285 | |
286 | |
287 /* Get initial status for the buddy */ | |
288 rc = nm_send_get_status(user, resp_data, _get_status_resp_cb, NULL); | |
289 _check_for_disconnect(user, rc); | |
290 | |
291 /* nm_release_contact(contact);*/ | |
292 | |
293 } | |
294 | |
295 if (contact) | |
296 nm_release_contact(contact); | |
297 } | |
298 | |
299 /* Add the new contact into the GaimBuddy list */ | |
300 static void | |
301 _create_contact_resp_cb(NMUser * user, NMERR_T ret_code, | |
302 gpointer resp_data, gpointer user_data) | |
303 { | |
304 NMContact *tmp_contact = (NMContact *) user_data; | |
305 NMContact *new_contact = NULL; | |
306 NMFolder *folder = NULL; | |
307 GaimGroup *group; | |
308 GaimBuddy *buddy; | |
309 const char *folder_name = NULL; | |
310 NMERR_T rc = NM_OK; | |
311 | |
312 if (user == NULL) | |
313 return; | |
314 | |
315 if (ret_code == NM_OK) { | |
316 | |
317 new_contact = (NMContact *) resp_data; | |
318 if (new_contact == NULL || tmp_contact == NULL) | |
319 return; | |
320 | |
321 /* Get the userid and folder name for the new contact */ | |
322 folder = nm_find_folder_by_id(user, | |
323 nm_contact_get_parent_id(new_contact)); | |
324 if (folder) { | |
325 folder_name = nm_folder_get_name(folder); | |
326 } | |
327 | |
9651 | 328 if (*folder_name == '\0') |
329 folder_name = NM_ROOT_FOLDER_NAME; | |
330 | |
8675 | 331 /* Re-add the buddy now that we got the okay from the server */ |
332 if (folder_name && (group = gaim_find_group(folder_name))) { | |
333 | |
334 const char *alias = nm_contact_get_display_name(tmp_contact); | |
335 const char *display_id = nm_contact_get_display_id(new_contact); | |
336 | |
337 if (display_id == NULL) | |
338 display_id = nm_contact_get_dn(new_contact); | |
339 | |
340 if (alias && strcmp(alias, display_id)) { | |
341 | |
342 /* The user requested an alias, tell the server about it. */ | |
343 rc = nm_send_rename_contact(user, new_contact, alias, | |
344 _rename_contact_resp_cb, NULL); | |
345 _check_for_disconnect(user, rc); | |
346 | |
347 } else { | |
348 | |
349 alias = ""; | |
350 | |
351 } | |
352 | |
353 /* Add it to the gaim buddy list if it is not there */ | |
354 buddy = gaim_find_buddy_in_group(user->client_data, display_id, group); | |
355 if (buddy == NULL) { | |
356 buddy = gaim_buddy_new(user->client_data, display_id, alias); | |
357 gaim_blist_add_buddy(buddy, NULL, group, NULL); | |
358 } | |
359 | |
360 /* Save the new buddy as part of the contact object */ | |
361 nm_contact_set_data(new_contact, (gpointer) buddy); | |
362 | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
363 /* We need details for the user before we can setup the |
8675 | 364 * new Gaim buddy. We always call this because the |
365 * 'createcontact' response fields do not always contain | |
366 * everything that we need. | |
367 */ | |
368 nm_contact_add_ref(new_contact); | |
369 | |
370 rc = nm_send_get_details(user, nm_contact_get_dn(new_contact), | |
371 _get_details_resp_setup_buddy, new_contact); | |
372 _check_for_disconnect(user, rc); | |
373 | |
374 } | |
375 | |
376 } else { | |
377 GaimConnection *gc = gaim_account_get_connection(user->client_data); | |
378 const char *name = nm_contact_get_dn(tmp_contact); | |
379 char *err; | |
380 | |
381 err = | |
8933 | 382 g_strdup_printf(_("Unable to add %s to your buddy list (%s)."), |
383 name, nm_error_to_string (ret_code)); | |
8675 | 384 gaim_notify_error(gc, NULL, err, NULL); |
385 g_free(err); | |
386 | |
387 } | |
388 | |
389 if (tmp_contact) | |
390 nm_release_contact(tmp_contact); | |
391 } | |
392 | |
393 /* Show an error if we failed to send the message */ | |
394 static void | |
395 _send_message_resp_cb(NMUser * user, NMERR_T ret_code, | |
396 gpointer resp_data, gpointer user_data) | |
397 { | |
398 GaimConnection *gc; | |
399 char *err = NULL; | |
400 | |
401 if (user == NULL) | |
402 return; | |
403 | |
404 if (ret_code != NM_OK) { | |
405 gc = gaim_account_get_connection(user->client_data); | |
406 | |
407 /* TODO: Improve this! message to who or for what conference? */ | |
8933 | 408 err = g_strdup_printf(_("Unable to send message (%s)."), |
409 nm_error_to_string (ret_code)); | |
8675 | 410 gaim_notify_error(gc, NULL, err, NULL); |
411 g_free(err); | |
412 } | |
413 } | |
414 | |
415 /* Show an error if the remove failed */ | |
416 static void | |
417 _remove_contact_resp_cb(NMUser * user, NMERR_T ret_code, | |
418 gpointer resp_data, gpointer user_data) | |
419 { | |
420 if (ret_code != NM_OK) { | |
421 /* TODO: Display an error? */ | |
422 | |
423 gaim_debug(GAIM_DEBUG_INFO, "novell", | |
424 "_remove_contact_resp_cb(): rc = 0x%x\n", ret_code); | |
425 } | |
426 } | |
427 | |
428 /* Show an error if the remove failed */ | |
429 static void | |
430 _remove_folder_resp_cb(NMUser * user, NMERR_T ret_code, | |
431 gpointer resp_data, gpointer user_data) | |
432 { | |
433 if (ret_code != NM_OK) { | |
434 /* TODO: Display an error? */ | |
435 | |
436 gaim_debug(GAIM_DEBUG_INFO, "novell", | |
437 "_remove_folder_resp_cb(): rc = 0x%x\n", ret_code); | |
438 } | |
439 } | |
440 | |
441 /* Show an error if the move failed */ | |
442 static void | |
443 _move_contact_resp_cb(NMUser * user, NMERR_T ret_code, | |
444 gpointer resp_data, gpointer user_data) | |
445 { | |
446 if (ret_code != NM_OK) { | |
447 /* TODO: Display an error? */ | |
448 | |
449 gaim_debug(GAIM_DEBUG_INFO, "novell", | |
450 "_move_contact_resp_cb(): rc = 0x%x\n", ret_code); | |
451 } | |
452 } | |
453 | |
454 /* Show an error if the rename failed */ | |
455 static void | |
456 _rename_folder_resp_cb(NMUser * user, NMERR_T ret_code, | |
457 gpointer resp_data, gpointer user_data) | |
458 { | |
459 if (ret_code != NM_OK) { | |
460 /* TODO: Display an error? */ | |
461 | |
462 gaim_debug(GAIM_DEBUG_INFO, "novell", | |
463 "_rename_folder_resp_cb(): rc = 0x%x\n", ret_code); | |
464 } | |
465 } | |
466 | |
8933 | 467 static void |
468 _sendinvite_resp_cb(NMUser *user, NMERR_T ret_code, | |
469 gpointer resp_data, gpointer user_data) | |
470 { | |
471 char *err; | |
472 GaimConnection *gc; | |
473 | |
474 if (user == NULL) | |
475 return; | |
476 | |
477 if (ret_code != NM_OK) { | |
478 gc = gaim_account_get_connection(user->client_data); | |
479 err = g_strdup_printf(_("Unable to invite user (%s)."), nm_error_to_string(ret_code)); | |
480 gaim_notify_error(gc, NULL, err, NULL); | |
481 g_free(err); | |
482 | |
483 gaim_debug(GAIM_DEBUG_INFO, "novell", | |
484 "_sendinvite_resp_cb(): rc = 0x%x\n", ret_code); | |
485 } | |
486 | |
487 } | |
488 | |
8675 | 489 /* If the createconf was successful attempt to send the message, |
490 * otherwise display an error message to the user. | |
491 */ | |
492 static void | |
493 _createconf_resp_send_msg(NMUser * user, NMERR_T ret_code, | |
494 gpointer resp_data, gpointer user_data) | |
495 { | |
496 NMConference *conf; | |
497 NMMessage *msg = user_data; | |
498 | |
499 if (user == NULL || msg == NULL) | |
500 return; | |
501 | |
502 if (ret_code == NM_OK) { | |
503 _send_message(user, msg); | |
504 } else { | |
505 | |
506 if ((conf = nm_message_get_conference(msg))) { | |
507 | |
508 GaimConnection *gc = gaim_account_get_connection(user->client_data); | |
509 const char *name = NULL; | |
510 char *err; | |
511 NMUserRecord *ur; | |
512 | |
513 ur = nm_conference_get_participant(conf, 0); | |
514 if (ur) | |
515 name = nm_user_record_get_userid(ur); | |
516 | |
517 if (name) | |
518 err = g_strdup_printf(_("Unable to send message to %s." | |
8933 | 519 " Could not create the conference (%s)."), |
520 name, | |
521 nm_error_to_string (ret_code)); | |
8675 | 522 else |
523 err = g_strdup_printf(_("Unable to send message." | |
8933 | 524 " Could not create the conference (%s)."), |
525 nm_error_to_string (ret_code)); | |
8675 | 526 |
527 gaim_notify_error(gc, NULL, err, NULL); | |
528 g_free(err); | |
529 } | |
530 | |
531 if (msg) | |
532 nm_release_message(msg); | |
533 } | |
534 } | |
535 | |
536 /* Move contact to newly created folder */ | |
537 static void | |
538 _create_folder_resp_move_contact(NMUser * user, NMERR_T ret_code, | |
539 gpointer resp_data, gpointer user_data) | |
540 { | |
541 NMContact *contact = user_data; | |
542 NMFolder *new_folder; | |
543 char *folder_name = resp_data; | |
544 NMERR_T rc = NM_OK; | |
545 | |
546 if (user == NULL || folder_name == NULL || contact == NULL) { | |
547 | |
548 if (folder_name) | |
549 g_free(folder_name); | |
550 | |
551 return; | |
552 } | |
553 | |
8933 | 554 if (ret_code == NM_OK || ret_code == NMERR_DUPLICATE_FOLDER) { |
8675 | 555 new_folder = nm_find_folder(user, folder_name); |
556 if (new_folder) { | |
557 | |
558 /* Tell the server to move the contact to the new folder */ | |
559 /* rc = nm_send_move_contact(user, contact, new_folder, | |
560 _move_contact_resp_cb, NULL); */ | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
561 |
8675 | 562 rc = nm_send_create_contact(user, new_folder, contact, |
563 NULL, NULL); | |
564 | |
565 _check_for_disconnect(user, rc); | |
566 | |
567 } | |
568 } else { | |
569 GaimConnection *gc = gaim_account_get_connection(user->client_data); | |
570 char *err = g_strdup_printf(_("Unable to move user %s" | |
571 " to folder %s in the server side list." | |
8933 | 572 " Error while creating folder (%s)."), |
573 nm_contact_get_dn(contact), | |
574 folder_name, | |
575 nm_error_to_string (ret_code)); | |
8675 | 576 |
577 gaim_notify_error(gc, NULL, err, NULL); | |
578 g_free(err); | |
579 } | |
580 | |
581 if (folder_name) | |
582 g_free(folder_name); | |
583 } | |
584 | |
585 /* Add contact to newly create folder */ | |
586 static void | |
587 _create_folder_resp_add_contact(NMUser * user, NMERR_T ret_code, | |
588 gpointer resp_data, gpointer user_data) | |
589 { | |
590 NMContact *contact = (NMContact *) user_data; | |
591 NMFolder *folder; | |
592 char *folder_name = (char *) resp_data; | |
593 NMERR_T rc = NM_OK; | |
594 | |
595 if (user == NULL || folder_name == NULL || contact == NULL) { | |
596 | |
597 if (contact) | |
598 nm_release_contact(contact); | |
599 | |
600 if (folder_name) | |
601 g_free(folder_name); | |
602 | |
603 return; | |
604 } | |
605 | |
8933 | 606 if (ret_code == NM_OK || ret_code == NMERR_DUPLICATE_FOLDER) { |
8675 | 607 folder = nm_find_folder(user, folder_name); |
608 if (folder) { | |
609 | |
610 rc = nm_send_create_contact(user, folder, contact, | |
611 _create_contact_resp_cb, contact); | |
612 _check_for_disconnect(user, rc); | |
613 } | |
614 } else { | |
615 GaimConnection *gc = gaim_account_get_connection(user->client_data); | |
616 const char *name = nm_contact_get_dn(contact); | |
617 char *err = | |
618 g_strdup_printf(_("Unable to add %s to your buddy list." | |
8933 | 619 " Error creating folder in server side list (%s)."), |
620 name, nm_error_to_string (ret_code)); | |
8675 | 621 |
622 gaim_notify_error(gc, NULL, err, NULL); | |
623 | |
624 nm_release_contact(contact); | |
625 g_free(err); | |
626 } | |
627 | |
628 g_free(folder_name); | |
629 } | |
630 | |
631 static void | |
632 _join_conf_resp_cb(NMUser * user, NMERR_T ret_code, | |
633 gpointer resp_data, gpointer user_data) | |
634 { | |
635 GaimConversation *chat; | |
636 GaimConnection *gc; | |
637 NMUserRecord *ur; | |
638 NMConference *conference = user_data; | |
8933 | 639 const char *name, *conf_name; |
8675 | 640 int i, count; |
641 | |
642 if (user == NULL || conference == NULL) | |
643 return; | |
644 | |
645 gc = gaim_account_get_connection(user->client_data); | |
646 | |
647 if (ret_code == NM_OK) { | |
8933 | 648 conf_name = _get_conference_name(++user->conference_count); |
8675 | 649 chat = serv_got_joined_chat(gc, user->conference_count, conf_name); |
650 if (chat) { | |
651 | |
652 nm_conference_set_data(conference, (gpointer) chat); | |
653 | |
654 count = nm_conference_get_participant_count(conference); | |
655 for (i = 0; i < count; i++) { | |
656 ur = nm_conference_get_participant(conference, i); | |
657 if (ur) { | |
658 name = nm_user_record_get_display_id(ur); | |
9846 | 659 gaim_conv_chat_add_user(GAIM_CONV_CHAT(chat), name, NULL, |
660 GAIM_CBFLAGS_NONE, TRUE); | |
8675 | 661 } |
662 } | |
663 } | |
664 } | |
665 } | |
666 | |
667 /* Show info returned by getdetails */ | |
668 static void | |
669 _get_details_resp_show_info(NMUser * user, NMERR_T ret_code, | |
670 gpointer resp_data, gpointer user_data) | |
671 { | |
672 GaimConnection *gc; | |
673 NMUserRecord *user_record; | |
674 char *name; | |
675 char *err; | |
676 | |
677 if (user == NULL) | |
678 return; | |
679 | |
680 name = user_data; | |
681 | |
682 if (ret_code == NM_OK) { | |
683 user_record = (NMUserRecord *) resp_data; | |
684 if (user_record) { | |
685 _show_info(gaim_account_get_connection(user->client_data), | |
686 user_record); | |
687 } | |
688 } else { | |
689 gc = gaim_account_get_connection(user->client_data); | |
690 err = | |
8933 | 691 g_strdup_printf(_("Could not get details for user %s (%s)."), |
692 name, nm_error_to_string (ret_code)); | |
8675 | 693 gaim_notify_error(gc, NULL, err, NULL); |
694 g_free(err); | |
695 } | |
696 | |
697 if (name) | |
698 g_free(name); | |
699 } | |
700 | |
8933 | 701 /* Handle get details response add to privacy list */ |
702 static void | |
703 _get_details_resp_add_privacy_item(NMUser *user, NMERR_T ret_code, | |
704 gpointer resp_data, gpointer user_data) | |
705 { | |
706 GaimConnection *gc; | |
707 NMUserRecord *user_record = resp_data; | |
708 char *err; | |
10112 | 709 gboolean allowed = GPOINTER_TO_INT(user_data); |
8933 | 710 const char *display_id; |
711 | |
712 if (user == NULL) | |
713 return; | |
714 | |
715 gc = gaim_account_get_connection(user->client_data); | |
716 display_id = nm_user_record_get_display_id(user_record); | |
717 | |
718 if (ret_code == NM_OK) { | |
719 | |
720 if (allowed) { | |
721 | |
722 if (!g_slist_find_custom(gc->account->permit, | |
723 display_id, (GCompareFunc)nm_utf8_strcasecmp)) { | |
724 gaim_privacy_permit_add(gc->account, display_id, TRUE); | |
725 } | |
726 | |
727 } else { | |
728 | |
729 if (!g_slist_find_custom(gc->account->permit, | |
730 display_id, (GCompareFunc)nm_utf8_strcasecmp)) { | |
731 gaim_privacy_deny_add(gc->account, display_id, TRUE); | |
732 } | |
733 } | |
734 | |
735 } else { | |
736 | |
737 err = g_strdup_printf(_("Unable to add user to privacy list (%s)."), | |
738 nm_error_to_string(ret_code)); | |
739 gaim_notify_error(gc, NULL, err, NULL); | |
740 g_free(err); | |
741 | |
742 } | |
743 } | |
744 | |
745 /* Handle response to create privacy item request */ | |
746 static void | |
747 _create_privacy_item_deny_resp_cb(NMUser *user, NMERR_T ret_code, | |
748 gpointer resp_data, gpointer user_data) | |
749 { | |
750 GaimConnection *gc; | |
751 NMUserRecord *user_record; | |
752 char *who = user_data; | |
753 char *err; | |
754 NMERR_T rc = NM_OK; | |
755 const char *display_id = NULL; | |
756 | |
757 if (user == NULL) | |
758 return; | |
759 | |
760 gc = gaim_account_get_connection(user->client_data); | |
761 | |
762 if (ret_code == NM_OK) { | |
763 | |
764 user_record = nm_find_user_record(user, who); | |
765 if (user_record) | |
766 display_id = nm_user_record_get_display_id(user_record); | |
767 | |
768 if (display_id) { | |
769 | |
770 if (!g_slist_find_custom(gc->account->deny, | |
771 display_id, (GCompareFunc)nm_utf8_strcasecmp)) { | |
772 | |
773 gaim_privacy_deny_add(gc->account, display_id, TRUE); | |
774 } | |
775 | |
776 } else { | |
777 rc = nm_send_get_details(user, who, | |
778 _get_details_resp_add_privacy_item, | |
779 (gpointer)FALSE); | |
780 _check_for_disconnect(user, rc); | |
781 } | |
782 } else { | |
783 | |
784 err = g_strdup_printf(_("Unable to add %s to deny list (%s)."), | |
785 who, nm_error_to_string(ret_code)); | |
786 gaim_notify_error(gc, NULL, err, NULL); | |
787 g_free(err); | |
788 | |
789 } | |
790 | |
791 if (who) | |
792 g_free(who); | |
793 | |
794 } | |
795 | |
796 /* Handle response to create privacy item request */ | |
797 static void | |
798 _create_privacy_item_permit_resp_cb(NMUser *user, NMERR_T ret_code, | |
799 gpointer resp_data, gpointer user_data) | |
800 { | |
801 GaimConnection *gc; | |
802 NMUserRecord *user_record; | |
803 char *who = user_data; | |
804 char *err; | |
805 NMERR_T rc = NM_OK; | |
806 const char *display_id = NULL; | |
807 | |
808 if (user == NULL) | |
809 return; | |
810 | |
811 gc = gaim_account_get_connection(user->client_data); | |
812 | |
813 if (ret_code == NM_OK) { | |
814 | |
815 user_record = nm_find_user_record(user, who); | |
816 if (user_record) | |
817 display_id = nm_user_record_get_display_id(user_record); | |
818 | |
819 if (display_id) { | |
820 | |
821 if (!g_slist_find_custom(gc->account->permit, | |
822 display_id, | |
823 (GCompareFunc)nm_utf8_strcasecmp)) { | |
824 | |
825 gaim_privacy_permit_add(gc->account, display_id, TRUE); | |
826 } | |
827 | |
828 } else { | |
829 rc = nm_send_get_details(user, who, | |
830 _get_details_resp_add_privacy_item, | |
831 (gpointer)TRUE); | |
832 _check_for_disconnect(user, rc); | |
833 } | |
834 | |
835 } else { | |
836 | |
837 err = g_strdup_printf(_("Unable to add %s to permit list (%s)."), who, | |
838 nm_error_to_string(ret_code)); | |
839 gaim_notify_error(gc, NULL, err, NULL); | |
840 g_free(err); | |
841 | |
842 } | |
843 | |
844 if (who) | |
845 g_free(who); | |
846 } | |
847 | |
848 static void | |
849 _get_details_send_privacy_create(NMUser *user, NMERR_T ret_code, | |
850 gpointer resp_data, gpointer user_data) | |
851 { | |
852 NMERR_T rc = NM_OK; | |
853 GaimConnection *gc; | |
854 NMUserRecord *user_record = resp_data; | |
855 char *err; | |
10112 | 856 gboolean allowed = GPOINTER_TO_INT(user_data); |
8933 | 857 const char *dn, *display_id; |
858 | |
859 if (user == NULL) | |
860 return; | |
861 | |
862 gc = gaim_account_get_connection(user->client_data); | |
863 dn = nm_user_record_get_dn(user_record); | |
864 display_id = nm_user_record_get_display_id(user_record); | |
865 | |
866 if (ret_code == NM_OK) { | |
867 | |
868 if (allowed) { | |
869 rc = nm_send_create_privacy_item(user, dn, TRUE, | |
870 _create_privacy_item_permit_resp_cb, | |
871 g_strdup(display_id)); | |
872 _check_for_disconnect(user, rc); | |
873 | |
874 } else { | |
875 rc = nm_send_create_privacy_item(user, dn, FALSE, | |
876 _create_privacy_item_deny_resp_cb, | |
877 g_strdup(display_id)); | |
878 _check_for_disconnect(user, rc); | |
879 } | |
880 | |
881 } else { | |
882 | |
883 err = g_strdup_printf(_("Unable to add user to privacy list (%s)."), | |
884 nm_error_to_string(ret_code)); | |
885 gaim_notify_error(gc, NULL, err, NULL); | |
886 g_free(err); | |
887 | |
888 } | |
889 } | |
890 | |
891 static void | |
892 _remove_privacy_item_resp_cb(NMUser *user, NMERR_T ret_code, | |
893 gpointer resp_data, gpointer user_data) | |
894 { | |
895 GaimConnection *gc; | |
896 char *who = user_data; | |
897 char *err; | |
898 | |
899 if (user == NULL) | |
900 return; | |
901 | |
902 if (ret_code != NM_OK) { | |
903 | |
904 gc = gaim_account_get_connection(user->client_data); | |
905 err = g_strdup_printf(_("Unable to remove %s from privacy list (%s)."), who, | |
906 nm_error_to_string(ret_code)); | |
907 gaim_notify_error(gc, NULL, err, NULL); | |
908 g_free(err); | |
909 } | |
910 | |
911 if (who) | |
912 g_free(who); | |
913 } | |
914 | |
915 static void | |
916 _set_privacy_default_resp_cb(NMUser *user, NMERR_T ret_code, | |
917 gpointer resp_data, gpointer user_data) | |
918 { | |
919 GaimConnection *gc; | |
920 char *err; | |
921 | |
922 if (user == NULL) | |
923 return; | |
924 | |
925 if (ret_code != NM_OK) { | |
926 | |
927 gc = gaim_account_get_connection(user->client_data); | |
928 err = g_strdup_printf(_("Unable to change server side privacy settings (%s)."), | |
929 nm_error_to_string(ret_code)); | |
930 gaim_notify_error(gc, NULL, err, NULL); | |
931 g_free(err); | |
932 | |
933 } | |
934 } | |
935 | |
936 /* Handle get details response add to privacy list */ | |
937 static void | |
938 _get_details_resp_send_invite(NMUser *user, NMERR_T ret_code, | |
939 gpointer resp_data, gpointer user_data) | |
940 { | |
941 NMERR_T rc = NM_OK; | |
942 GaimConnection *gc; | |
943 NMUserRecord *user_record = resp_data; | |
944 char *err; | |
945 const char *display_id; | |
946 GSList *cnode; | |
947 NMConference *conference; | |
948 gpointer chat; | |
949 long id = (long) user_data; | |
950 | |
951 if (user == NULL) | |
952 return; | |
953 | |
954 gc = gaim_account_get_connection(user->client_data); | |
955 display_id = nm_user_record_get_display_id(user_record); | |
956 | |
957 if (ret_code == NM_OK) { | |
958 | |
959 for (cnode = user->conferences; cnode != NULL; cnode = cnode->next) { | |
960 conference = cnode->data; | |
961 if (conference && (chat = nm_conference_get_data(conference))) { | |
962 if (gaim_conv_chat_get_id(GAIM_CONV_CHAT(chat)) == id) { | |
963 rc = nm_send_conference_invite(user, conference, user_record, | |
964 NULL, _sendinvite_resp_cb, NULL); | |
965 _check_for_disconnect(user, rc); | |
966 break; | |
967 } | |
968 } | |
969 } | |
970 | |
971 } else { | |
972 | |
973 err = g_strdup_printf(_("Unable to invite user (%s)."), nm_error_to_string(ret_code)); | |
974 gaim_notify_error(gc, NULL, err, NULL); | |
975 g_free(err); | |
976 | |
977 } | |
978 } | |
979 | |
980 static void | |
981 _createconf_resp_send_invite(NMUser * user, NMERR_T ret_code, | |
982 gpointer resp_data, gpointer user_data) | |
983 { | |
984 NMERR_T rc = NM_OK; | |
985 NMConference *conference = resp_data; | |
986 NMUserRecord *user_record = user_data; | |
987 GaimConnection *gc; | |
988 char *err; | |
989 | |
990 if (user == NULL) | |
991 return; | |
992 | |
993 | |
994 | |
995 if (ret_code == NM_OK) { | |
996 rc = nm_send_conference_invite(user, conference, user_record, | |
997 NULL, _sendinvite_resp_cb, NULL); | |
998 _check_for_disconnect(user, rc); | |
999 } else { | |
1000 err = g_strdup_printf(_("Unable to create conference (%s)."), nm_error_to_string(ret_code)); | |
1001 gc = gaim_account_get_connection(user->client_data); | |
1002 gaim_notify_error(gc, NULL, err, NULL); | |
1003 g_free(err); | |
1004 } | |
1005 } | |
1006 | |
8675 | 1007 /******************************************************************************* |
1008 * Helper functions | |
1009 ******************************************************************************/ | |
1010 | |
1011 static char * | |
1012 _user_agent_string() | |
1013 { | |
1014 | |
1015 #if !defined(_WIN32) | |
1016 | |
1017 const char *sysname = ""; | |
1018 const char *release = ""; | |
1019 const char *template = "Gaim/%s (%s; %s)"; | |
1020 struct utsname u; | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
1021 |
8675 | 1022 if (uname(&u) == 0) { |
1023 sysname = u.sysname; | |
1024 release = u.release; | |
1025 } else { | |
1026 sysname = "Linux"; | |
1027 release = "Unknown"; | |
1028 } | |
1029 | |
1030 return g_strdup_printf(template, VERSION, sysname, release); | |
1031 | |
1032 #else | |
1033 | |
1034 const char *sysname = ""; | |
1035 const char *template = "Gaim/%s (%s; %d.%d)"; | |
1036 OSVERSIONINFO os_info; | |
1037 SYSTEM_INFO sys_info; | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
1038 |
8675 | 1039 os_info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); |
1040 GetVersionEx(&os_info); | |
1041 GetSystemInfo(&sys_info); | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
1042 |
8675 | 1043 if (os_info.dwPlatformId == VER_PLATFORM_WIN32_NT) { |
1044 switch (os_info.dwMajorVersion) { | |
1045 case 3: | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
1046 case 4: |
8675 | 1047 sysname = "Windows NT"; |
1048 break; | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
1049 case 5: |
8675 | 1050 switch (os_info.dwMinorVersion) { |
1051 case 0: | |
1052 sysname = "Windows 2000"; | |
1053 break; | |
1054 case 1: | |
1055 sysname = "Windows XP"; | |
1056 break; | |
1057 case 2: | |
1058 sysname = "Windows Server 2003"; | |
1059 break; | |
1060 default: | |
1061 sysname = "Windows"; | |
1062 break; | |
1063 } | |
1064 break; | |
1065 default: | |
1066 sysname = "Windows"; | |
1067 break; | |
1068 } | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
1069 |
8675 | 1070 } else if (os_info.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) { |
1071 switch (os_info.dwMinorVersion) { | |
1072 case 0: | |
1073 sysname = "Windows 95"; | |
1074 break; | |
1075 case 10: | |
1076 sysname = "Windows 98"; | |
1077 break; | |
1078 case 90: | |
1079 sysname = "Windows ME"; | |
1080 break; | |
1081 default: | |
1082 sysname = "Windows"; | |
1083 break; | |
1084 } | |
1085 } else { | |
1086 sysname = "Windows"; | |
1087 } | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
1088 |
8675 | 1089 return g_strdup_printf(template, VERSION, sysname, |
1090 os_info.dwMajorVersion, os_info.dwMinorVersion); | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
1091 |
8675 | 1092 #endif |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
1093 |
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
1094 |
8675 | 1095 } |
1096 | |
1097 static gboolean | |
1098 _is_disconnect_error(NMERR_T err) | |
1099 { | |
1100 return (err == NMERR_TCP_WRITE || | |
1101 err == NMERR_TCP_READ || err == NMERR_PROTOCOL); | |
1102 } | |
1103 | |
1104 static gboolean | |
1105 _check_for_disconnect(NMUser * user, NMERR_T err) | |
1106 { | |
1107 GaimConnection *gc = gaim_account_get_connection(user->client_data); | |
1108 | |
1109 if (_is_disconnect_error(err)) { | |
1110 | |
1111 gaim_connection_error(gc, _("Error communicating with server." | |
1112 " Closing connection.")); | |
1113 return TRUE; | |
1114 | |
1115 } | |
1116 | |
1117 return FALSE; | |
1118 } | |
1119 | |
1120 /* Check to see if the conference is instantiated, if so send the message. | |
1121 * If not send the create conference -- the response handler for the createconf | |
1122 * will call this function again. | |
1123 */ | |
1124 static void | |
1125 _send_message(NMUser * user, NMMessage * message) | |
1126 { | |
1127 NMConference *conf; | |
1128 NMERR_T rc = NM_OK; | |
1129 | |
1130 conf = nm_message_get_conference(message); | |
1131 if (conf) { | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
1132 /* We have a conference make sure that the |
8675 | 1133 server knows about it already. */ |
1134 if (nm_conference_is_instantiated(conf)) { | |
1135 | |
1136 /* We have everything that we need...finally! */ | |
1137 rc = nm_send_message(user, message, _send_message_resp_cb); | |
1138 _check_for_disconnect(user, rc); | |
1139 | |
1140 nm_release_message(message); | |
1141 | |
1142 } else { | |
8933 | 1143 rc = nm_send_create_conference(user, conf, _createconf_resp_send_msg, message); |
8675 | 1144 _check_for_disconnect(user, rc); |
1145 } | |
1146 } | |
1147 } | |
1148 | |
11971 | 1149 /* |
1150 * Update the status of the given buddy in the Gaim buddy list | |
1151 * TODO: This needs testing. And we need to tell the core the | |
1152 * away message for the person. | |
1153 */ | |
8675 | 1154 static void |
11971 | 1155 _update_buddy_status(GaimBuddy * buddy, int novellstatus, int gmt) |
8675 | 1156 { |
11971 | 1157 GaimAccount *account; |
1158 const char *status_id; | |
8675 | 1159 int idle = 0; |
9927 | 1160 gboolean loggedin = TRUE; |
8675 | 1161 |
11971 | 1162 account = buddy->account; |
1163 | |
1164 switch (novellstatus) { | |
8675 | 1165 case NM_STATUS_AVAILABLE: |
11971 | 1166 status_id = "available"; |
8675 | 1167 break; |
1168 case NM_STATUS_AWAY: | |
11971 | 1169 status_id = "away"; |
1170 break; | |
8675 | 1171 case NM_STATUS_BUSY: |
11971 | 1172 status_id = "busy"; |
8675 | 1173 break; |
1174 case NM_STATUS_OFFLINE: | |
11971 | 1175 status_id = "appearoffline"; |
9927 | 1176 loggedin = FALSE; |
8675 | 1177 break; |
1178 case NM_STATUS_AWAY_IDLE: | |
11971 | 1179 status_id = "away"; |
8675 | 1180 idle = gmt; |
1181 break; | |
1182 default: | |
11971 | 1183 status_id = "away"; |
9927 | 1184 loggedin = FALSE; |
8675 | 1185 break; |
1186 } | |
1187 | |
11971 | 1188 gaim_prpl_got_user_status(account, buddy->name, |
1189 status_id, NULL); | |
1190 gaim_prpl_got_user_idle(account, buddy->name, | |
1191 (novellstatus == NM_STATUS_AWAY_IDLE), idle); | |
8675 | 1192 } |
1193 | |
8933 | 1194 /* Iterate through the cached Gaim buddy list and remove buddies |
1195 * that are not in the server side list. | |
8675 | 1196 */ |
1197 static void | |
8933 | 1198 _remove_gaim_buddies(NMUser *user) |
8675 | 1199 { |
1200 GaimBlistNode *gnode; | |
1201 GaimBlistNode *cnode; | |
1202 GaimBlistNode *bnode; | |
1203 GaimGroup *group; | |
1204 GaimBuddy *buddy; | |
1205 GaimBuddyList *blist; | |
1206 GSList *rem_list = NULL; | |
1207 GSList *l; | |
8933 | 1208 NMFolder *folder = NULL; |
9651 | 1209 const char *gname = NULL; |
8675 | 1210 |
1211 if ((blist = gaim_get_blist())) { | |
1212 for (gnode = blist->root; gnode; gnode = gnode->next) { | |
1213 if (!GAIM_BLIST_NODE_IS_GROUP(gnode)) | |
1214 continue; | |
1215 group = (GaimGroup *) gnode; | |
1216 for (cnode = gnode->child; cnode; cnode = cnode->next) { | |
1217 if (!GAIM_BLIST_NODE_IS_CONTACT(cnode)) | |
1218 continue; | |
1219 for (bnode = cnode->child; bnode; bnode = bnode->next) { | |
1220 if (!GAIM_BLIST_NODE_IS_BUDDY(bnode)) | |
1221 continue; | |
1222 buddy = (GaimBuddy *) bnode; | |
1223 if (buddy->account == user->client_data) { | |
9651 | 1224 gname = group->name; |
1225 if (strcmp(group->name, NM_ROOT_FOLDER_NAME) == 0) | |
1226 gname = ""; | |
1227 folder = nm_find_folder(user, gname); | |
8933 | 1228 if (folder == NULL || |
1229 !nm_folder_find_contact_by_display_id(folder, buddy->name)) { | |
1230 rem_list = g_slist_append(rem_list, buddy); | |
1231 } | |
8675 | 1232 } |
1233 } | |
1234 } | |
1235 } | |
1236 | |
1237 if (rem_list) { | |
1238 for (l = rem_list; l; l = l->next) { | |
1239 gaim_blist_remove_buddy(l->data); | |
1240 } | |
1241 g_slist_free(rem_list); | |
1242 } | |
1243 } | |
1244 } | |
1245 | |
1246 /* Add all of the contacts in the given folder to the Gaim buddy list */ | |
1247 static void | |
1248 _add_contacts_to_gaim_blist(NMUser * user, NMFolder * folder) | |
1249 { | |
1250 NMUserRecord *user_record = NULL; | |
1251 NMContact *contact = NULL; | |
1252 GaimBuddy *buddy = NULL; | |
8782
5a2b5e4abf3a
[gaim-migrate @ 9544]
Christian Hammond <chipx86@chipx86.com>
parents:
8781
diff
changeset
|
1253 GaimGroup *group; |
8675 | 1254 NMERR_T cnt = 0, i; |
1255 const char *text = NULL; | |
1256 const char *name = NULL; | |
9651 | 1257 const char *fname = NULL; |
8675 | 1258 int status = 0; |
1259 | |
9651 | 1260 /* If this is the root folder give it a name. Gaim does not have the concept of |
1261 * a root folder. | |
1262 */ | |
1263 fname = nm_folder_get_name(folder); | |
1264 if (fname == NULL || *fname == '\0') { | |
1265 fname = NM_ROOT_FOLDER_NAME; | |
1266 } | |
1267 | |
8933 | 1268 /* Does the Gaim group exist already? */ |
9651 | 1269 group = gaim_find_group(fname); |
8933 | 1270 if (group == NULL) { |
9651 | 1271 group = gaim_group_new(fname); |
8933 | 1272 gaim_blist_add_group(group, NULL); |
1273 } | |
1274 | |
8675 | 1275 /* Get each contact for this folder */ |
1276 cnt = nm_folder_get_contact_count(folder); | |
1277 for (i = 0; i < cnt; i++) { | |
1278 contact = nm_folder_get_contact(folder, i); | |
1279 if (contact) { | |
1280 | |
1281 name = nm_contact_get_display_id(contact); | |
1282 if (name) { | |
8933 | 1283 |
1284 buddy = gaim_find_buddy_in_group(user->client_data, name, group); | |
1285 if (buddy == NULL) { | |
1286 /* Add it to the gaim buddy list */ | |
1287 buddy = gaim_buddy_new(user->client_data, | |
1288 name, | |
1289 nm_contact_get_display_name(contact)); | |
1290 | |
1291 gaim_blist_add_buddy(buddy, NULL, group, NULL); | |
8675 | 1292 } |
1293 | |
1294 /* Set the initial status for the buddy */ | |
1295 user_record = nm_contact_get_user_record(contact); | |
1296 if (user_record) { | |
1297 status = nm_user_record_get_status(user_record); | |
1298 text = nm_user_record_get_status_text(user_record); | |
1299 } | |
1300 _update_buddy_status(buddy, status, time(0)); | |
1301 | |
1302 /* Save the new buddy as part of the contact object */ | |
1303 nm_contact_set_data(contact, (gpointer) buddy); | |
1304 } | |
1305 | |
1306 } else { | |
1307 /* NULL contact. This should not happen, but | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
1308 * let's break out of the loop. |
8675 | 1309 */ |
1310 break; | |
1311 } | |
1312 } | |
1313 } | |
1314 | |
1315 /* Add all of the server side contacts to the Gaim buddy list. */ | |
1316 static void | |
1317 _add_gaim_buddies(NMUser * user) | |
1318 { | |
9651 | 1319 int cnt = 0, i; |
8675 | 1320 NMFolder *root_folder = NULL; |
1321 NMFolder *folder = NULL; | |
1322 | |
1323 root_folder = nm_get_root_folder(user); | |
1324 if (root_folder) { | |
1325 | |
9651 | 1326 /* Add sub-folders and contacts to sub-folders... |
1327 * iterate throught the sub-folders in reverse order | |
1328 * because Gaim adds the folders to the front -- so we | |
1329 * want to add the first folder last | |
1330 */ | |
8675 | 1331 cnt = nm_folder_get_subfolder_count(root_folder); |
9651 | 1332 for (i = cnt-1; i >= 0; i--) { |
8675 | 1333 folder = nm_folder_get_subfolder(root_folder, i); |
1334 if (folder) { | |
1335 _add_contacts_to_gaim_blist(user, folder); | |
1336 } | |
1337 } | |
1338 | |
1339 /* Add contacts for the root folder */ | |
1340 _add_contacts_to_gaim_blist(user, root_folder); | |
1341 } | |
1342 } | |
1343 | |
8933 | 1344 static void |
1345 _sync_contact_list(NMUser *user) | |
1346 { | |
1347 /* Remove all buddies from the local list that are | |
1348 * not in the server side list and add all buddies | |
1349 * from the server side list that are not in | |
1350 * the local list | |
1351 */ | |
1352 _remove_gaim_buddies(user); | |
1353 _add_gaim_buddies(user); | |
9360 | 1354 user->clist_synched = TRUE; |
8933 | 1355 } |
1356 | |
1357 static void | |
1358 _sync_privacy_lists(NMUser *user) | |
1359 { | |
1360 GSList *node = NULL, *rem_list = NULL; | |
1361 GaimConnection *gc; | |
1362 const char *name, *dn; | |
1363 NMUserRecord *user_record; | |
1364 | |
1365 if (user == NULL) | |
1366 return; | |
1367 | |
1368 gc = gaim_account_get_connection(user->client_data); | |
1369 if (gc == NULL) | |
1370 return; | |
1371 | |
1372 /* Set the Gaim privacy setting */ | |
1373 if (user->default_deny) { | |
1374 if (user->allow_list == NULL) { | |
1375 gc->account->perm_deny = GAIM_PRIVACY_DENY_ALL; | |
1376 } else { | |
1377 gc->account->perm_deny = GAIM_PRIVACY_ALLOW_USERS; | |
1378 } | |
1379 } else { | |
1380 if (user->deny_list == NULL) { | |
1381 gc->account->perm_deny = GAIM_PRIVACY_ALLOW_ALL; | |
1382 } else { | |
1383 gc->account->perm_deny = GAIM_PRIVACY_DENY_USERS; | |
1384 } | |
1385 } | |
1386 | |
1387 /* Add stuff */ | |
1388 for (node = user->allow_list; node; node = node->next) { | |
1389 user_record = nm_find_user_record(user, (char *)node->data); | |
1390 if (user_record) | |
1391 name = nm_user_record_get_display_id(user_record); | |
1392 else | |
1393 name =(char *)node->data; | |
1394 | |
1395 if (!g_slist_find_custom(gc->account->permit, | |
1396 name, (GCompareFunc)nm_utf8_strcasecmp)) { | |
1397 gaim_privacy_permit_add(gc->account, name , TRUE); | |
1398 } | |
1399 } | |
1400 | |
1401 for (node = user->deny_list; node; node = node->next) { | |
1402 user_record = nm_find_user_record(user, (char *)node->data); | |
1403 if (user_record) | |
1404 name = nm_user_record_get_display_id(user_record); | |
1405 else | |
1406 name =(char *)node->data; | |
1407 | |
1408 if (!g_slist_find_custom(gc->account->deny, | |
1409 name, (GCompareFunc)nm_utf8_strcasecmp)) { | |
1410 gaim_privacy_deny_add(gc->account, name, TRUE); | |
1411 } | |
1412 } | |
1413 | |
1414 | |
1415 /* Remove stuff */ | |
1416 for (node = gc->account->permit; node; node = node->next) { | |
1417 dn = nm_lookup_dn(user, (char *)node->data); | |
1418 if (dn != NULL && | |
1419 !g_slist_find_custom(user->allow_list, | |
1420 dn, (GCompareFunc)nm_utf8_strcasecmp)) { | |
1421 rem_list = g_slist_append(rem_list, node->data); | |
1422 } | |
1423 } | |
1424 | |
1425 if (rem_list) { | |
1426 for (node = rem_list; node; node = node->next) { | |
1427 gaim_privacy_permit_remove(gc->account, (char *)node->data, TRUE); | |
1428 } | |
1429 g_free(rem_list); | |
1430 rem_list = NULL; | |
1431 } | |
1432 | |
1433 for (node = gc->account->deny; node; node = node->next) { | |
1434 dn = nm_lookup_dn(user, (char *)node->data); | |
1435 if (dn != NULL && | |
1436 !g_slist_find_custom(user->deny_list, | |
1437 dn, (GCompareFunc)nm_utf8_strcasecmp)) { | |
1438 rem_list = g_slist_append(rem_list, node->data); | |
1439 } | |
1440 } | |
1441 | |
1442 if (rem_list) { | |
1443 for (node = rem_list; node; node = node->next) { | |
1444 gaim_privacy_deny_remove(gc->account, (char *)node->data, TRUE); | |
1445 } | |
1446 g_slist_free(rem_list); | |
1447 } | |
1448 } | |
1449 | |
9820 | 1450 /* Map known property tags to user-friendly strings */ |
1451 static const char * | |
1452 _map_property_tag(const char *tag) | |
1453 { | |
1454 if (tag == NULL) return NULL; | |
1455 | |
1456 if (strcmp(tag, "telephoneNumber") == 0) | |
1457 return _("Telephone Number"); | |
1458 else if (strcmp(tag, "L") == 0) | |
1459 return _("Location"); | |
1460 else if (strcmp(tag, "OU") == 0) | |
1461 return _("Department"); | |
1462 else if (strcmp(tag, "personalTitle") == 0) | |
1463 return _("Personal Title"); | |
1464 else if (strcmp(tag, "Title") == 0) | |
1465 return _("Title"); | |
1466 else if (strcmp(tag, "mailstop") == 0) | |
1467 return _("Mailstop"); | |
1468 else if (strcmp(tag, "Internet EMail Address") == 0) | |
1469 return _("Email Address"); | |
1470 else | |
1471 return tag; | |
1472 } | |
1473 | |
8675 | 1474 /* Display a dialog box showing the properties for the given user record */ |
1475 static void | |
1476 _show_info(GaimConnection * gc, NMUserRecord * user_record) | |
1477 { | |
1478 GString *info_text; | |
1479 int count, i; | |
1480 NMProperty *property; | |
1481 const char *tag, *value; | |
1482 | |
1483 info_text = g_string_new(""); | |
1484 | |
9820 | 1485 tag = _("User ID"); |
8675 | 1486 value = nm_user_record_get_userid(user_record); |
1487 if (value) { | |
9820 | 1488 g_string_append_printf(info_text, "<b>%s:</b> %s<br>", tag, value); |
8675 | 1489 } |
1490 | |
1491 /* tag = _("DN"); | |
1492 value = nm_user_record_get_dn(user_record); | |
1493 if (value) { | |
9820 | 1494 g_string_append_printf(info_text, "<b>%s:</b> %s<br>", |
8675 | 1495 tag, value); |
1496 } | |
1497 */ | |
1498 | |
1499 tag = _("Full name"); | |
1500 value = nm_user_record_get_full_name(user_record); | |
1501 if (value) { | |
9820 | 1502 g_string_append_printf(info_text, "<b>%s:</b> %s<br>", tag, value); |
8675 | 1503 } |
1504 | |
1505 count = nm_user_record_get_property_count(user_record); | |
1506 for (i = 0; i < count; i++) { | |
1507 property = nm_user_record_get_property(user_record, i); | |
1508 if (property) { | |
9820 | 1509 tag = _map_property_tag(nm_property_get_tag(property)); |
8675 | 1510 value = nm_property_get_value(property); |
1511 if (tag && value) { | |
9820 | 1512 g_string_append_printf(info_text, "<b>%s:</b> %s<br>", |
8675 | 1513 tag, value); |
1514 } | |
1515 nm_release_property(property); | |
1516 } | |
1517 } | |
1518 | |
11531
bf763a1b2454
[gaim-migrate @ 13780]
Luke Schierer <lschiere@pidgin.im>
parents:
11522
diff
changeset
|
1519 gaim_notify_userinfo(gc, nm_user_record_get_userid(user_record), |
11533
c9b815aeddc1
[gaim-migrate @ 13782]
Richard Laager <rlaager@wiktel.com>
parents:
11531
diff
changeset
|
1520 info_text->str, NULL, NULL); |
8675 | 1521 |
1522 g_string_free(info_text, TRUE); | |
1523 } | |
1524 | |
1525 /* Send a join conference, the first item in the parms list is the | |
1526 * NMUser object and the second item is the conference to join. | |
1527 * This callback is passed to gaim_request_action when we ask the | |
1528 * user if they want to join the conference. | |
1529 */ | |
1530 static void | |
1531 _join_conference_cb(GSList * parms) | |
1532 { | |
1533 NMUser *user; | |
1534 NMConference *conference; | |
1535 NMERR_T rc = NM_OK; | |
1536 | |
1537 if (parms == NULL || g_slist_length(parms) != 2) | |
1538 return; | |
1539 | |
1540 user = g_slist_nth_data(parms, 0); | |
1541 conference = g_slist_nth_data(parms, 1); | |
1542 | |
1543 if (user && conference) { | |
1544 rc = nm_send_join_conference(user, conference, | |
1545 _join_conf_resp_cb, conference); | |
1546 _check_for_disconnect(user, rc); | |
1547 } | |
1548 | |
1549 g_slist_free(parms); | |
1550 } | |
1551 | |
1552 /* Send a reject conference, the first item in the parms list is the | |
1553 * NMUser object and the second item is the conference to reject. | |
1554 * This callback is passed to gaim_request_action when we ask the | |
1555 * user if they want to joing the conference. | |
1556 */ | |
1557 static void | |
1558 _reject_conference_cb(GSList * parms) | |
1559 { | |
1560 NMUser *user; | |
1561 NMConference *conference; | |
1562 NMERR_T rc = NM_OK; | |
1563 | |
1564 if (parms == NULL || g_slist_length(parms) != 2) | |
1565 return; | |
1566 | |
1567 user = g_slist_nth_data(parms, 0); | |
1568 conference = g_slist_nth_data(parms, 1); | |
1569 | |
1570 if (user && conference) { | |
1571 rc = nm_send_reject_conference(user, conference, NULL, NULL); | |
1572 _check_for_disconnect(user, rc); | |
1573 } | |
1574 | |
1575 g_slist_free(parms); | |
1576 } | |
1577 | |
8933 | 1578 static void |
9030 | 1579 _initiate_conference_cb(GaimBlistNode *node, gpointer ignored) |
8933 | 1580 { |
9030 | 1581 GaimBuddy *buddy; |
1582 GaimConnection *gc; | |
1583 | |
8933 | 1584 NMUser *user; |
1585 const char *conf_name; | |
1586 GaimConversation *chat = NULL; | |
1587 NMUserRecord *user_record; | |
1588 NMConference *conference; | |
1589 | |
9030 | 1590 g_return_if_fail(GAIM_BLIST_NODE_IS_BUDDY(node)); |
1591 | |
1592 buddy = (GaimBuddy *) node; | |
1593 gc = gaim_account_get_connection(buddy->account); | |
1594 | |
8933 | 1595 user = gc->proto_data; |
1596 if (user == NULL) | |
1597 return; | |
1598 | |
1599 /* We should already have a userrecord for the buddy */ | |
9030 | 1600 user_record = nm_find_user_record(user, buddy->name); |
8933 | 1601 if (user_record == NULL) |
1602 return; | |
1603 | |
1604 conf_name = _get_conference_name(++user->conference_count); | |
1605 chat = serv_got_joined_chat(gc, user->conference_count, conf_name); | |
1606 if (chat) { | |
1607 | |
1608 conference = nm_create_conference(NULL); | |
1609 nm_conference_set_data(conference, (gpointer) chat); | |
1610 nm_send_create_conference(user, conference, _createconf_resp_send_invite, user_record); | |
1611 nm_release_conference(conference); | |
1612 } | |
1613 } | |
1614 | |
1615 const char * | |
1616 _get_conference_name(int id) | |
1617 { | |
1618 static char *name = NULL; | |
1619 | |
1620 if (name) | |
1621 g_free(name); | |
1622 | |
1623 name = g_strdup_printf(_("GroupWise Conference %d"), id); | |
1624 | |
1625 return name; | |
1626 } | |
1627 | |
1628 void | |
1629 _show_privacy_locked_error(GaimConnection *gc, NMUser *user) | |
1630 { | |
1631 char *err; | |
1632 | |
1633 err = g_strdup_printf(_("Unable to change server side privacy settings (%s)."), | |
1634 nm_error_to_string(NMERR_ADMIN_LOCKED)); | |
1635 gaim_notify_error(gc, NULL, err, NULL); | |
1636 g_free(err); | |
1637 } | |
1638 | |
8675 | 1639 /******************************************************************************* |
1640 * Connect and recv callbacks | |
1641 ******************************************************************************/ | |
1642 | |
1643 static void | |
1644 novell_ssl_connect_error(GaimSslConnection * gsc, | |
1645 GaimSslErrorType error, gpointer data) | |
1646 { | |
1647 gaim_connection_error((GaimConnection *)data, | |
1648 _("Unable to make SSL connection to server.")); | |
1649 } | |
1650 | |
1651 static void | |
1652 novell_ssl_recv_cb(gpointer data, GaimSslConnection * gsc, | |
1653 GaimInputCondition condition) | |
1654 { | |
1655 GaimConnection *gc = data; | |
1656 NMUser *user; | |
1657 NMERR_T rc; | |
1658 | |
1659 if (gc == NULL) | |
1660 return; | |
1661 | |
1662 user = gc->proto_data; | |
1663 if (user == NULL) | |
1664 return; | |
1665 | |
1666 rc = nm_process_new_data(user); | |
1667 if (rc != NM_OK) { | |
1668 | |
1669 if (_is_disconnect_error(rc)) { | |
8933 | 1670 |
8675 | 1671 gaim_connection_error(gc, |
1672 _("Error communicating with server." | |
1673 " Closing connection.")); | |
1674 } else { | |
1675 | |
1676 char *error; | |
1677 | |
8933 | 1678 error = g_strdup_printf(_("Error processing event or response (%s)."), |
1679 nm_error_to_string (rc)); | |
8675 | 1680 gaim_notify_error(gc, NULL, error, NULL); |
1681 g_free(error); | |
1682 | |
1683 } | |
1684 | |
1685 } | |
1686 } | |
1687 | |
1688 static void | |
1689 novell_ssl_connected_cb(gpointer data, GaimSslConnection * gsc, | |
1690 GaimInputCondition cond) | |
1691 { | |
1692 GaimConnection *gc = data; | |
1693 NMUser *user; | |
1694 NMConn *conn; | |
1695 NMERR_T rc = 0; | |
1696 const char *pwd = NULL; | |
1697 const char *my_addr = NULL; | |
1698 char *ua = NULL; | |
1699 | |
1700 if (gc == NULL || gsc == NULL) | |
1701 return; | |
1702 | |
1703 user = gc->proto_data; | |
1704 if ((user == NULL) || (conn = user->conn) == NULL) | |
1705 return; | |
1706 | |
1707 conn->ssl_conn = g_new0(NMSSLConn, 1); | |
1708 conn->ssl_conn->data = gsc; | |
1709 conn->ssl_conn->read = (nm_ssl_read_cb) gaim_ssl_read; | |
1710 conn->ssl_conn->write = (nm_ssl_write_cb) gaim_ssl_write; | |
1711 | |
1712 gaim_connection_update_progress(gc, _("Authenticating..."), | |
1713 2, NOVELL_CONNECT_STEPS); | |
1714 | |
8838 | 1715 my_addr = gaim_network_get_my_ip(gsc->fd); |
10740 | 1716 pwd = gaim_connection_get_password(gc); |
8675 | 1717 ua = _user_agent_string(); |
1718 | |
1719 rc = nm_send_login(user, pwd, my_addr, ua, _login_resp_cb, NULL); | |
1720 if (rc == NM_OK) { | |
1721 conn->connected = TRUE; | |
1722 gaim_ssl_input_add(gsc, novell_ssl_recv_cb, gc); | |
1723 } else { | |
1724 gaim_connection_error(gc, _("Unable to connect to server.")); | |
1725 } | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
1726 |
8675 | 1727 gaim_connection_update_progress(gc, _("Waiting for response..."), |
1728 3, NOVELL_CONNECT_STEPS); | |
1729 | |
1730 g_free(ua); | |
1731 } | |
1732 | |
1733 /******************************************************************************* | |
1734 * Event callback and event handlers | |
1735 ******************************************************************************/ | |
1736 | |
1737 static void | |
1738 _evt_receive_message(NMUser * user, NMEvent * event) | |
1739 { | |
1740 NMUserRecord *user_record = NULL; | |
1741 NMContact *contact = NULL; | |
1742 GaimConversation *gconv; | |
1743 NMConference *conference; | |
12216 | 1744 GaimMessageFlags flags; |
9268 | 1745 char *text = NULL; |
1746 | |
1747 text = g_markup_escape_text(nm_event_get_text(event), -1); | |
8675 | 1748 |
1749 conference = nm_event_get_conference(event); | |
1750 if (conference) { | |
1751 | |
1752 GaimConversation *chat = nm_conference_get_data(conference); | |
1753 | |
1754 /* Is this a single person 'conversation' or a conference? */ | |
1755 if (chat == NULL && nm_conference_get_participant_count(conference) == 1) { | |
1756 | |
1757 user_record = nm_find_user_record(user, nm_event_get_source(event)); | |
1758 if (user_record) { | |
1759 | |
12216 | 1760 flags = 0; |
8675 | 1761 if (nm_event_get_type(event) == NMEVT_RECEIVE_AUTOREPLY) |
12216 | 1762 flags |= GAIM_MESSAGE_AUTO_RESP; |
8675 | 1763 |
1764 serv_got_im(gaim_account_get_connection(user->client_data), | |
1765 nm_user_record_get_display_id(user_record), | |
12216 | 1766 text, flags, |
8675 | 1767 nm_event_get_gmt(event)); |
1768 | |
11338 | 1769 gconv = gaim_find_conversation_with_account(GAIM_CONV_TYPE_IM, |
8675 | 1770 nm_user_record_get_display_id(user_record), |
1771 (GaimAccount *) user->client_data); | |
1772 if (gconv) { | |
1773 | |
1774 contact = nm_find_contact(user, nm_event_get_source(event)); | |
1775 if (contact) { | |
1776 | |
1777 gaim_conversation_set_title( | |
9268 | 1778 gconv, nm_contact_get_display_name(contact)); |
8675 | 1779 |
1780 | |
1781 } else { | |
1782 | |
1783 const char *name = | |
1784 nm_user_record_get_full_name(user_record); | |
1785 | |
1786 if (name == NULL) | |
1787 name = nm_user_record_get_userid(user_record); | |
1788 | |
1789 gaim_conversation_set_title(gconv, name); | |
1790 } | |
1791 | |
1792 } | |
1793 | |
1794 } else { | |
1795 /* this should not happen, see the event code. | |
1796 * the event code will get the contact details from | |
1797 * the server if it does not have them before calling | |
1798 * the event callback. | |
1799 */ | |
1800 } | |
1801 | |
1802 } else if (chat) { | |
1803 | |
1804 /* get the contact for send if we have one */ | |
1805 NMContact *contact = nm_find_contact(user, | |
1806 nm_event_get_source(event)); | |
1807 | |
1808 /* get the user record for the sender */ | |
1809 user_record = nm_find_user_record(user, nm_event_get_source(event)); | |
1810 if (user_record) { | |
1811 const char *name = nm_contact_get_display_name(contact); | |
1812 | |
1813 if (name == NULL) { | |
1814 name = nm_user_record_get_full_name(user_record); | |
1815 if (name == NULL) | |
1816 name = nm_user_record_get_display_id(user_record); | |
1817 } | |
1818 | |
1819 serv_got_chat_in(gaim_account_get_connection(user->client_data), | |
1820 gaim_conv_chat_get_id(GAIM_CONV_CHAT(chat)), | |
9268 | 1821 name, 0, text, nm_event_get_gmt(event)); |
8675 | 1822 } |
1823 } | |
1824 } | |
9268 | 1825 |
1826 g_free(text); | |
8675 | 1827 } |
1828 | |
1829 static void | |
1830 _evt_conference_left(NMUser * user, NMEvent * event) | |
1831 { | |
1832 GaimConversation *chat; | |
1833 NMConference *conference; | |
1834 | |
1835 conference = nm_event_get_conference(event); | |
1836 if (conference) { | |
1837 chat = nm_conference_get_data(conference); | |
1838 if (chat) { | |
1839 NMUserRecord *ur = nm_find_user_record(user, | |
1840 nm_event_get_source(event)); | |
1841 | |
1842 if (ur) | |
1843 gaim_conv_chat_remove_user(GAIM_CONV_CHAT(chat), | |
1844 nm_user_record_get_display_id(ur), | |
1845 NULL); | |
1846 } | |
1847 } | |
1848 } | |
1849 | |
1850 static void | |
8933 | 1851 _evt_conference_invite_notify(NMUser * user, NMEvent * event) |
1852 { | |
1853 GaimConversation *gconv; | |
1854 NMConference *conference; | |
1855 NMUserRecord *user_record = NULL; | |
1856 char *str = NULL; | |
1857 | |
1858 user_record = nm_find_user_record(user, nm_event_get_source(event)); | |
1859 conference = nm_event_get_conference(event); | |
1860 if (user_record && conference) { | |
1861 gconv = nm_conference_get_data(conference); | |
1862 str = g_strdup_printf(_("%s has been invited to this conversation."), | |
1863 nm_user_record_get_display_id(user_record)); | |
1864 gaim_conversation_write(gconv, NULL, str, | |
1865 GAIM_MESSAGE_SYSTEM, time(NULL)); | |
1866 g_free(str); | |
1867 } | |
1868 } | |
1869 | |
1870 static void | |
8675 | 1871 _evt_conference_invite(NMUser * user, NMEvent * event) |
1872 { | |
1873 NMUserRecord *ur; | |
11246 | 1874 GaimConnection *gc; |
8675 | 1875 GSList *parms = NULL; |
1876 const char *title = NULL; | |
1877 const char *secondary = NULL; | |
1878 const char *name = NULL; | |
1879 char *primary = NULL; | |
1880 time_t gmt; | |
1881 | |
1882 ur = nm_find_user_record(user, nm_event_get_source(event)); | |
1883 if (ur) | |
1884 name = nm_user_record_get_full_name(ur); | |
1885 | |
1886 if (name == NULL) | |
1887 name = nm_event_get_source(event); | |
1888 | |
1889 gmt = nm_event_get_gmt(event); | |
1890 title = _("Invitation to Conversation"); | |
1891 primary = g_strdup_printf(_("Invitation from: %s\n\nSent: %s"), | |
1892 name, asctime(localtime(&gmt))); | |
1893 secondary = _("Would you like to join the conversation?"); | |
1894 | |
1895 /* Set up parms list for the callbacks | |
1896 * We need to send the NMUser object and | |
1897 * the NMConference object to the callbacks | |
1898 */ | |
1899 parms = NULL; | |
1900 parms = g_slist_append(parms, user); | |
1901 parms = g_slist_append(parms, nm_event_get_conference(event)); | |
1902 | |
1903 /* Prompt the user */ | |
11246 | 1904 gc = gaim_account_get_connection(user->client_data); |
1905 gaim_request_action(gc, title, primary, secondary, | |
10116 | 1906 GAIM_DEFAULT_ACTION_NONE, parms, 2, |
8675 | 1907 _("Yes"), G_CALLBACK(_join_conference_cb), |
1908 _("No"), G_CALLBACK(_reject_conference_cb)); | |
1909 | |
1910 g_free(primary); | |
1911 } | |
1912 | |
1913 | |
1914 static void | |
1915 _evt_conference_joined(NMUser * user, NMEvent * event) | |
1916 { | |
1917 GaimConversation *chat = NULL; | |
1918 GaimConnection *gc; | |
1919 NMConference *conference = NULL; | |
1920 NMUserRecord *ur = NULL; | |
1921 const char *name; | |
8933 | 1922 const char *conf_name; |
8675 | 1923 |
1924 gc = gaim_account_get_connection(user->client_data); | |
1925 if (gc == NULL) | |
1926 return; | |
1927 | |
1928 conference = nm_event_get_conference(event); | |
1929 if (conference) { | |
1930 chat = nm_conference_get_data(conference); | |
1931 if (nm_conference_get_participant_count(conference) == 2 && chat == NULL) { | |
1932 ur = nm_conference_get_participant(conference, 0); | |
1933 if (ur) { | |
8933 | 1934 conf_name = _get_conference_name(++user->conference_count); |
8675 | 1935 chat = |
1936 serv_got_joined_chat(gc, user->conference_count, conf_name); | |
1937 if (chat) { | |
1938 | |
1939 nm_conference_set_data(conference, (gpointer) chat); | |
1940 | |
1941 name = nm_user_record_get_display_id(ur); | |
9846 | 1942 gaim_conv_chat_add_user(GAIM_CONV_CHAT(chat), name, NULL, |
1943 GAIM_CBFLAGS_NONE, TRUE); | |
8675 | 1944 |
1945 } | |
1946 } | |
1947 } | |
1948 | |
1949 if (chat != NULL) { | |
1950 ur = nm_find_user_record(user, nm_event_get_source(event)); | |
1951 if (ur) { | |
1952 name = nm_user_record_get_display_id(ur); | |
9554 | 1953 if (!gaim_conv_chat_find_user(GAIM_CONV_CHAT(chat), name)) { |
9846 | 1954 gaim_conv_chat_add_user(GAIM_CONV_CHAT(chat), name, NULL, |
1955 GAIM_CBFLAGS_NONE, TRUE); | |
8933 | 1956 } |
8675 | 1957 } |
1958 } | |
1959 } | |
1960 } | |
1961 | |
1962 static void | |
1963 _evt_status_change(NMUser * user, NMEvent * event) | |
1964 { | |
1965 GaimBuddy *buddy = NULL; | |
1966 GSList *buddies; | |
1967 GSList *bnode; | |
1968 NMUserRecord *user_record; | |
1969 const char *display_id; | |
1970 int status; | |
1971 | |
1972 user_record = nm_event_get_user_record(event); | |
1973 if (user_record) { | |
1974 | |
1975 /* Retrieve new status */ | |
1976 status = nm_user_record_get_status(user_record); | |
1977 | |
1978 /* Update status for buddy in all folders */ | |
1979 display_id = nm_user_record_get_display_id(user_record); | |
1980 buddies = gaim_find_buddies(user->client_data, display_id); | |
1981 for (bnode = buddies; bnode; bnode = bnode->next) { | |
1982 buddy = (GaimBuddy *) bnode->data; | |
1983 if (buddy) { | |
1984 _update_buddy_status(buddy, status, nm_event_get_gmt(event)); | |
1985 } | |
1986 } | |
1987 | |
1988 g_slist_free(buddies); | |
1989 | |
1990 } | |
1991 } | |
1992 | |
1993 static void | |
1994 _evt_user_disconnect(NMUser * user, NMEvent * event) | |
1995 { | |
1996 GaimConnection *gc; | |
1997 | |
1998 gc = gaim_account_get_connection((GaimAccount *) user->client_data); | |
1999 if (gc) | |
2000 gaim_connection_error(gc, _("You have been logged out because you" | |
2001 " logged in at another workstation.")); | |
2002 } | |
2003 | |
2004 static void | |
2005 _evt_user_typing(NMUser * user, NMEvent * event) | |
2006 { | |
2007 GaimConnection *gc; | |
2008 NMUserRecord *user_record = NULL; | |
2009 | |
2010 gc = gaim_account_get_connection((GaimAccount *) user->client_data); | |
2011 if (gc) { | |
2012 user_record = nm_find_user_record(user, nm_event_get_source(event)); | |
2013 if (user_record) { | |
2014 serv_got_typing(gc, nm_user_record_get_display_id(user_record), | |
2015 30, GAIM_TYPING); | |
2016 } | |
2017 } | |
2018 } | |
2019 | |
2020 static void | |
2021 _evt_user_not_typing(NMUser * user, NMEvent * event) | |
2022 { | |
2023 GaimConnection *gc; | |
2024 NMUserRecord *user_record; | |
2025 | |
2026 gc = gaim_account_get_connection((GaimAccount *) user->client_data); | |
2027 if (gc) { | |
2028 user_record = nm_find_user_record(user, nm_event_get_source(event)); | |
2029 if (user_record) { | |
2030 serv_got_typing_stopped(gc, | |
2031 nm_user_record_get_display_id(user_record)); | |
2032 } | |
2033 } | |
2034 } | |
2035 | |
2036 static void | |
2037 _evt_undeliverable_status(NMUser * user, NMEvent * event) | |
2038 { | |
2039 NMUserRecord *ur; | |
2040 GaimConversation *gconv; | |
2041 char *str; | |
2042 | |
2043 ur = nm_find_user_record(user, nm_event_get_source(event)); | |
2044 if (ur) { | |
11338 | 2045 /* XXX - Should this be GAIM_CONV_TYPE_IM? */ |
8675 | 2046 gconv = |
11338 | 2047 gaim_find_conversation_with_account(GAIM_CONV_TYPE_ANY, |
10246 | 2048 nm_user_record_get_display_id(ur), |
8675 | 2049 user->client_data); |
2050 if (gconv) { | |
2051 const char *name = nm_user_record_get_full_name(ur); | |
2052 | |
2053 if (name == NULL) { | |
2054 name = nm_user_record_get_display_id(ur); | |
2055 } | |
2056 str = g_strdup_printf(_("%s appears to be offline and did not receive" | |
2057 " the message that you just sent."), name); | |
2058 gaim_conversation_write(gconv, NULL, str, | |
2059 GAIM_MESSAGE_SYSTEM, time(NULL)); | |
2060 g_free(str); | |
2061 } | |
2062 } | |
2063 } | |
2064 | |
2065 static void | |
2066 _event_callback(NMUser * user, NMEvent * event) | |
2067 { | |
2068 if (user == NULL || event == NULL) | |
2069 return; | |
2070 | |
2071 switch (nm_event_get_type(event)) { | |
2072 case NMEVT_STATUS_CHANGE: | |
2073 _evt_status_change(user, event); | |
2074 break; | |
2075 case NMEVT_RECEIVE_AUTOREPLY: | |
2076 case NMEVT_RECEIVE_MESSAGE: | |
2077 _evt_receive_message(user, event); | |
2078 break; | |
2079 case NMEVT_USER_DISCONNECT: | |
2080 _evt_user_disconnect(user, event); | |
2081 break; | |
2082 case NMEVT_USER_TYPING: | |
2083 _evt_user_typing(user, event); | |
2084 break; | |
2085 case NMEVT_USER_NOT_TYPING: | |
2086 _evt_user_not_typing(user, event); | |
2087 break; | |
2088 case NMEVT_SERVER_DISCONNECT: | |
2089 /* Nothing to do? */ | |
2090 break; | |
2091 case NMEVT_INVALID_RECIPIENT: | |
2092 break; | |
2093 case NMEVT_UNDELIVERABLE_STATUS: | |
2094 _evt_undeliverable_status(user, event); | |
2095 break; | |
2096 case NMEVT_CONFERENCE_INVITE_NOTIFY: | |
2097 /* Someone else has been invited to join a | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
2098 * conference that we are currently a part of |
8675 | 2099 */ |
8933 | 2100 _evt_conference_invite_notify(user, event); |
8675 | 2101 break; |
2102 case NMEVT_CONFERENCE_INVITE: | |
2103 /* We have been invited to join a conference */ | |
2104 _evt_conference_invite(user, event); | |
2105 break; | |
2106 case NMEVT_CONFERENCE_JOINED: | |
2107 /* Some one has joined a conference that we | |
2108 * are a part of | |
2109 */ | |
2110 _evt_conference_joined(user, event); | |
2111 break; | |
2112 case NMEVT_CONFERENCE_LEFT: | |
2113 /* Someone else has left a conference that we | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
2114 * are currently a part of |
8675 | 2115 */ |
2116 _evt_conference_left(user, event); | |
2117 break; | |
2118 default: | |
2119 gaim_debug(GAIM_DEBUG_INFO, "novell", | |
2120 "_event_callback(): unhandled event, %d\n", | |
2121 nm_event_get_type(event)); | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
2122 break; |
8675 | 2123 } |
2124 } | |
2125 | |
2126 /******************************************************************************* | |
2127 * Prpl Ops | |
2128 ******************************************************************************/ | |
2129 | |
2130 static void | |
11837 | 2131 novell_login(GaimAccount * account) |
8675 | 2132 { |
2133 GaimConnection *gc; | |
2134 NMUser *user = NULL; | |
2135 const char *server; | |
2136 const char *name; | |
2137 int port; | |
2138 | |
2139 if (account == NULL) | |
2140 return; | |
2141 | |
2142 gc = gaim_account_get_connection(account); | |
2143 if (gc == NULL) | |
2144 return; | |
2145 | |
2146 server = gaim_account_get_string(account, "server", NULL); | |
2147 if (server == NULL || *server == '\0') { | |
2148 | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
2149 /* TODO: Would be nice to prompt if not set! |
8675 | 2150 * gaim_request_fields(gc, _("Server Address"),...); |
2151 */ | |
2152 | |
2153 /* ...but for now just error out with a nice message. */ | |
2154 gaim_connection_error(gc, _("Unable to connect to server." | |
2155 " Please enter the address of the server" | |
2156 " you wish to connect to.")); | |
2157 return; | |
2158 } | |
2159 | |
2160 port = gaim_account_get_int(account, "port", DEFAULT_PORT); | |
2161 name = gaim_account_get_username(account); | |
2162 | |
2163 user = nm_initialize_user(name, server, port, account, _event_callback); | |
2164 if (user) { | |
2165 /* save user */ | |
2166 gc->proto_data = user; | |
2167 | |
2168 /* connect to the server */ | |
2169 gaim_connection_update_progress(gc, _("Connecting"), | |
2170 1, NOVELL_CONNECT_STEPS); | |
2171 | |
2172 user->conn->use_ssl = TRUE; | |
2173 if (gaim_ssl_connect(user->client_data, user->conn->addr, | |
2174 user->conn->port, novell_ssl_connected_cb, | |
2175 novell_ssl_connect_error, gc) == NULL) { | |
2176 gaim_connection_error(gc, _("Error." | |
2177 " SSL support is not installed.")); | |
2178 } | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
2179 } |
8675 | 2180 } |
2181 | |
2182 static void | |
2183 novell_close(GaimConnection * gc) | |
2184 { | |
2185 NMUser *user; | |
2186 NMConn *conn; | |
2187 | |
2188 if (gc == NULL) | |
2189 return; | |
2190 | |
2191 user = gc->proto_data; | |
2192 if (user) { | |
2193 conn = user->conn; | |
9651 | 2194 if (conn && conn->ssl_conn) { |
2195 gaim_ssl_close(user->conn->ssl_conn->data); | |
8675 | 2196 } |
2197 nm_deinitialize_user(user); | |
2198 } | |
2199 gc->proto_data = NULL; | |
2200 } | |
2201 | |
2202 static int | |
2203 novell_send_im(GaimConnection * gc, const char *name, | |
12216 | 2204 const char *message_body, GaimMessageFlags flags) |
8675 | 2205 { |
2206 NMUserRecord *user_record = NULL; | |
2207 NMConference *conf = NULL; | |
2208 NMMessage *message; | |
2209 NMUser *user; | |
2210 const char *dn = NULL; | |
12216 | 2211 char *plain; |
8675 | 2212 gboolean done = TRUE, created_conf = FALSE; |
2213 NMERR_T rc = NM_OK; | |
2214 | |
2215 if (gc == NULL || name == NULL || | |
2216 message_body == NULL || *message_body == '\0') | |
2217 return 0; | |
2218 | |
2219 user = gc->proto_data; | |
2220 if (user == NULL) | |
2221 return 0; | |
2222 | |
2223 /* Create a new message */ | |
12216 | 2224 plain = gaim_unescape_html(message_body); |
2225 message = nm_create_message(plain); | |
2226 g_free(plain); | |
8675 | 2227 |
2228 /* Need to get the DN for the buddy so we can look up the convo */ | |
2229 dn = nm_lookup_dn(user, name); | |
2230 | |
2231 /* Do we already know about the sender? */ | |
2232 user_record = nm_find_user_record(user, dn); | |
2233 if (user_record) { | |
2234 | |
2235 /* Do we already have an instantiated conference? */ | |
2236 conf = nm_find_conversation(user, dn); | |
2237 if (conf == NULL) { | |
2238 | |
2239 /* If not, create a blank conference */ | |
2240 conf = nm_create_conference(NULL); | |
2241 created_conf = TRUE; | |
2242 | |
2243 nm_conference_add_participant(conf, user_record); | |
2244 } | |
2245 | |
2246 nm_message_set_conference(message, conf); | |
2247 | |
2248 /* Make sure conference is instatiated */ | |
2249 if (!nm_conference_is_instantiated(conf)) { | |
2250 | |
2251 /* It is not, so send the createconf. We will | |
2252 * have to finish sending the message when we | |
2253 * get the response with the new conference guid. | |
2254 */ | |
8933 | 2255 rc = nm_send_create_conference(user, conf, _createconf_resp_send_msg, message); |
8675 | 2256 _check_for_disconnect(user, rc); |
2257 | |
2258 done = FALSE; | |
2259 } | |
2260 | |
2261 } else { | |
2262 | |
2263 /* If we don't have details for the user, then we don't have | |
2264 * a conference yet. So create one and send the getdetails | |
2265 * to the server. We will have to finish sending the message | |
2266 * when we get the response from the server. | |
2267 */ | |
2268 conf = nm_create_conference(NULL); | |
2269 created_conf = TRUE; | |
2270 | |
2271 nm_message_set_conference(message, conf); | |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
2272 |
8675 | 2273 rc = nm_send_get_details(user, name, _get_details_resp_send_msg, message); |
2274 _check_for_disconnect(user, rc); | |
2275 | |
2276 done = FALSE; | |
2277 } | |
2278 | |
2279 if (done) { | |
2280 | |
2281 /* Did we find everything we needed? */ | |
2282 rc = nm_send_message(user, message, _send_message_resp_cb); | |
2283 _check_for_disconnect(user, rc); | |
2284 | |
2285 nm_release_message(message); | |
2286 } | |
2287 | |
2288 if (created_conf && conf) | |
2289 nm_release_conference(conf); | |
2290 | |
2291 return 1; | |
2292 } | |
2293 | |
2294 static int | |
2295 novell_send_typing(GaimConnection * gc, const char *name, int typing) | |
2296 { | |
2297 NMConference *conf = NULL; | |
2298 NMUser *user; | |
2299 const char *dn = NULL; | |
2300 NMERR_T rc = NM_OK; | |
2301 | |
2302 if (gc == NULL || name == NULL) | |
2303 return -1; | |
2304 | |
2305 user = gc->proto_data; | |
2306 if (user == NULL) | |
2307 return -1; | |
2308 | |
2309 /* Need to get the DN for the buddy so we can look up the convo */ | |
2310 dn = nm_lookup_dn(user, name); | |
2311 if (dn) { | |
2312 | |
2313 /* Now find the conference in our list */ | |
2314 conf = nm_find_conversation(user, dn); | |
2315 if (conf) { | |
2316 | |
2317 rc = nm_send_typing(user, conf, | |
2318 ((typing == GAIM_TYPING) ? TRUE : FALSE), NULL); | |
2319 _check_for_disconnect(user, rc); | |
2320 | |
2321 } | |
2322 | |
2323 } | |
2324 | |
2325 return 0; | |
2326 } | |
2327 | |
2328 static void | |
2329 novell_convo_closed(GaimConnection * gc, const char *who) | |
2330 { | |
2331 NMUser *user; | |
2332 NMConference *conf; | |
2333 const char *dn; | |
2334 NMERR_T rc = NM_OK; | |
2335 | |
2336 if (gc == NULL || who == NULL) | |
2337 return; | |
2338 | |
2339 user = gc->proto_data; | |
2340 if (user && (dn = nm_lookup_dn(user, who))) { | |
2341 conf = nm_find_conversation(user, dn); | |
2342 if (conf) { | |
2343 rc = nm_send_leave_conference(user, conf, NULL, NULL); | |
2344 _check_for_disconnect(user, rc); | |
2345 } | |
2346 } | |
2347 } | |
2348 | |
2349 static void | |
2350 novell_chat_leave(GaimConnection * gc, int id) | |
2351 { | |
2352 NMConference *conference; | |
2353 NMUser *user; | |
2354 GaimConversation *chat; | |
2355 GSList *cnode; | |
2356 NMERR_T rc = NM_OK; | |
2357 | |
2358 if (gc == NULL) | |
2359 return; | |
2360 | |
2361 user = gc->proto_data; | |
2362 if (user == NULL) | |
2363 return; | |
2364 | |
2365 for (cnode = user->conferences; cnode != NULL; cnode = cnode->next) { | |
2366 conference = cnode->data; | |
2367 if (conference && (chat = nm_conference_get_data(conference))) { | |
2368 if (gaim_conv_chat_get_id(GAIM_CONV_CHAT(chat)) == id) { | |
2369 rc = nm_send_leave_conference(user, conference, NULL, NULL); | |
2370 _check_for_disconnect(user, rc); | |
2371 break; | |
2372 } | |
2373 } | |
2374 } | |
2375 | |
2376 serv_got_chat_left(gc, id); | |
2377 } | |
2378 | |
8933 | 2379 void |
2380 novell_chat_invite(GaimConnection *gc, int id, | |
2381 const char *message, const char *who) | |
2382 { | |
2383 NMConference *conference; | |
2384 NMUser *user; | |
2385 GaimConversation *chat; | |
2386 GSList *cnode; | |
2387 NMERR_T rc = NM_OK; | |
2388 NMUserRecord *user_record = NULL; | |
2389 | |
2390 if (gc == NULL) | |
2391 return; | |
2392 | |
2393 user = gc->proto_data; | |
2394 if (user == NULL) | |
2395 return; | |
2396 | |
2397 user_record = nm_find_user_record(user, who); | |
2398 if (user_record == NULL) { | |
10112 | 2399 rc = nm_send_get_details(user, who, _get_details_resp_send_invite, GINT_TO_POINTER(id)); |
8933 | 2400 _check_for_disconnect(user, rc); |
2401 return; | |
2402 } | |
2403 | |
2404 for (cnode = user->conferences; cnode != NULL; cnode = cnode->next) { | |
2405 conference = cnode->data; | |
2406 if (conference && (chat = nm_conference_get_data(conference))) { | |
2407 if (gaim_conv_chat_get_id(GAIM_CONV_CHAT(chat)) == id) { | |
2408 rc = nm_send_conference_invite(user, conference, user_record, | |
2409 message, _sendinvite_resp_cb, NULL); | |
2410 _check_for_disconnect(user, rc); | |
2411 break; | |
2412 } | |
2413 } | |
2414 } | |
2415 } | |
2416 | |
8675 | 2417 static int |
12216 | 2418 novell_chat_send(GaimConnection * gc, int id, const char *text, GaimMessageFlags flags) |
8675 | 2419 { |
2420 NMConference *conference; | |
2421 GaimConversation *chat; | |
2422 GSList *cnode; | |
2423 NMMessage *message; | |
2424 NMUser *user; | |
2425 NMERR_T rc = NM_OK; | |
2426 const char *name; | |
12216 | 2427 char *str, *plain; |
8675 | 2428 |
2429 if (gc == NULL || text == NULL) | |
2430 return -1; | |
2431 | |
2432 user = gc->proto_data; | |
2433 if (user == NULL) | |
2434 return -1; | |
2435 | |
12216 | 2436 plain = gaim_unescape_html(text); |
2437 message = nm_create_message(plain); | |
2438 g_free(plain); | |
8675 | 2439 |
2440 for (cnode = user->conferences; cnode != NULL; cnode = cnode->next) { | |
2441 conference = cnode->data; | |
2442 if (conference && (chat = nm_conference_get_data(conference))) { | |
2443 if (gaim_conv_chat_get_id(GAIM_CONV_CHAT(chat)) == id) { | |
2444 | |
2445 nm_message_set_conference(message, conference); | |
2446 | |
8933 | 2447 /* check to see if the conference is instatiated yet */ |
2448 if (!nm_conference_is_instantiated(conference)) { | |
2449 nm_message_add_ref(message); | |
2450 nm_send_create_conference(user, conference, _createconf_resp_send_msg, message); | |
2451 } else { | |
2452 rc = nm_send_message(user, message, _send_message_resp_cb); | |
2453 } | |
2454 | |
8675 | 2455 nm_release_message(message); |
2456 | |
2457 if (!_check_for_disconnect(user, rc)) { | |
2458 | |
2459 /* Use the account alias if it is set */ | |
2460 name = gaim_account_get_alias(user->client_data); | |
2461 if (name == NULL || *name == '\0') { | |
2462 | |
2463 /* If there is no account alias, try full name */ | |
2464 name = nm_user_record_get_full_name(user->user_record); | |
2465 if (name == NULL || *name == '\0') { | |
2466 | |
2467 /* Fall back to the username that we are signed in with */ | |
2468 name = gaim_account_get_username(user->client_data); | |
2469 } | |
2470 } | |
2471 | |
2472 serv_got_chat_in(gc, id, name, 0, text, time(NULL)); | |
2473 return 0; | |
2474 } else | |
2475 return -1; | |
2476 | |
2477 } | |
2478 } | |
2479 } | |
2480 | |
8933 | 2481 |
8675 | 2482 /* The conference was not found, must be closed */ |
2483 chat = gaim_find_chat(gc, id); | |
2484 if (chat) { | |
2485 str = g_strdup_printf(_("This conference has been closed." | |
2486 " No more messages can be sent.")); | |
2487 gaim_conversation_write(chat, NULL, str, GAIM_MESSAGE_SYSTEM, time(NULL)); | |
2488 g_free(str); | |
2489 } | |
2490 | |
8744 | 2491 if (message) |
2492 nm_release_message(message); | |
2493 | |
8675 | 2494 return -1; |
2495 } | |
2496 | |
2497 static void | |
9285 | 2498 novell_add_buddy(GaimConnection * gc, GaimBuddy *buddy, GaimGroup * group) |
8675 | 2499 { |
2500 NMFolder *folder = NULL; | |
2501 NMContact *contact; | |
2502 NMUser *user; | |
2503 NMERR_T rc = NM_OK; | |
9651 | 2504 const char *alias, *gname; |
9285 | 2505 |
2506 if (gc == NULL || buddy == NULL || group == NULL) | |
8675 | 2507 return; |
2508 | |
2509 user = (NMUser *) gc->proto_data; | |
2510 if (user == NULL) | |
2511 return; | |
2512 | |
9360 | 2513 /* If we haven't synched the contact list yet, ignore |
2514 * the add_buddy calls. Server side list is the master. | |
2515 */ | |
2516 if (!user->clist_synched) | |
2517 return; | |
2518 | |
8675 | 2519 contact = nm_create_contact(); |
9285 | 2520 nm_contact_set_dn(contact, buddy->name); |
8675 | 2521 |
8684
046dd8ef2920
[gaim-migrate @ 9437]
Christian Hammond <chipx86@chipx86.com>
parents:
8676
diff
changeset
|
2522 /* Remove the GaimBuddy (we will add it back after adding it |
8675 | 2523 * to the server side list). Save the alias if there is one. |
2524 */ | |
9620 | 2525 alias = gaim_buddy_get_alias(buddy); |
9285 | 2526 if (alias && strcmp(alias, buddy->name)) |
2527 nm_contact_set_display_name(contact, alias); | |
2528 | |
2529 gaim_blist_remove_buddy(buddy); | |
2530 buddy = NULL; | |
8675 | 2531 |
9651 | 2532 if (strcmp(group->name, NM_ROOT_FOLDER_NAME) == 0) { |
2533 gname = ""; | |
2534 } else { | |
2535 gname = group->name; | |
2536 } | |
2537 | |
2538 folder = nm_find_folder(user, gname); | |
8675 | 2539 if (folder) { |
2540 | |
2541 /* We have everything that we need, so send the createcontact */ | |
2542 rc = nm_send_create_contact(user, folder, contact, | |
2543 _create_contact_resp_cb, contact); | |
2544 | |
2545 } else { | |
2546 | |
2547 /* Need to create the folder before we can add the contact */ | |
9651 | 2548 rc = nm_send_create_folder(user, gname, |
8675 | 2549 _create_folder_resp_add_contact, contact); |
2550 } | |
2551 | |
2552 _check_for_disconnect(user, rc); | |
2553 | |
2554 } | |
2555 | |
2556 static void | |
9360 | 2557 novell_remove_buddy(GaimConnection *gc, GaimBuddy *buddy, GaimGroup *group) |
8675 | 2558 { |
2559 NMContact *contact; | |
2560 NMFolder *folder; | |
2561 NMUser *user; | |
9651 | 2562 const char *dn, *gname; |
8675 | 2563 NMERR_T rc = NM_OK; |
2564 | |
9285 | 2565 if (gc == NULL || buddy == NULL || group == NULL) |
8675 | 2566 return; |
2567 | |
2568 user = (NMUser *) gc->proto_data; | |
9285 | 2569 if (user && (dn = nm_lookup_dn(user, buddy->name))) { |
9651 | 2570 if (strcmp(group->name, NM_ROOT_FOLDER_NAME) == 0) { |
2571 gname = ""; | |
2572 } else { | |
2573 gname = group->name; | |
2574 } | |
2575 folder = nm_find_folder(user, gname); | |
8675 | 2576 if (folder) { |
2577 contact = nm_folder_find_contact(folder, dn); | |
2578 if (contact) { | |
2579 | |
2580 /* Remove the buddy from the contact */ | |
2581 nm_contact_set_data(contact, NULL); | |
2582 | |
2583 /* Tell the server to remove the contact */ | |
2584 rc = nm_send_remove_contact(user, folder, contact, | |
2585 _remove_contact_resp_cb, NULL); | |
2586 _check_for_disconnect(user, rc); | |
2587 } | |
2588 } | |
2589 } | |
2590 } | |
2591 | |
2592 static void | |
9285 | 2593 novell_remove_group(GaimConnection * gc, GaimGroup *group) |
8675 | 2594 { |
2595 NMUser *user; | |
2596 NMERR_T rc = NM_OK; | |
2597 | |
9285 | 2598 if (gc == NULL || group == NULL) |
8675 | 2599 return; |
2600 | |
2601 user = (NMUser *) gc->proto_data; | |
2602 if (user) { | |
9285 | 2603 NMFolder *folder = nm_find_folder(user, group->name); |
8675 | 2604 |
2605 if (folder) { | |
2606 rc = nm_send_remove_folder(user, folder, | |
2607 _remove_folder_resp_cb, NULL); | |
2608 _check_for_disconnect(user, rc); | |
2609 } | |
2610 } | |
2611 } | |
2612 | |
2613 static void | |
2614 novell_alias_buddy(GaimConnection * gc, const char *name, const char *alias) | |
2615 { | |
2616 NMContact *contact; | |
2617 NMUser *user; | |
2618 GList *contacts = NULL; | |
2619 GList *cnode = NULL; | |
9651 | 2620 const char *dn = NULL, *fname = NULL; |
8675 | 2621 NMERR_T rc = NM_OK; |
2622 | |
2623 if (gc == NULL || name == NULL || alias == NULL) | |
2624 return; | |
2625 | |
2626 user = (NMUser *) gc->proto_data; | |
2627 if (user && (dn = nm_lookup_dn(user, name))) { | |
2628 | |
2629 /* Alias all of instances of the contact */ | |
2630 contacts = nm_find_contacts(user, dn); | |
2631 for (cnode = contacts; cnode != NULL; cnode = cnode->next) { | |
2632 contact = (NMContact *) cnode->data; | |
2633 if (contact) { | |
9651 | 2634 GaimGroup *group = NULL; |
8675 | 2635 GaimBuddy *buddy; |
2636 NMFolder *folder; | |
2637 | |
2638 /* Alias the Gaim buddy? */ | |
2639 folder = nm_find_folder_by_id(user, | |
2640 nm_contact_get_parent_id(contact)); | |
9651 | 2641 if (folder) { |
2642 fname = nm_folder_get_name(folder); | |
2643 if (*fname == '\0') { | |
2644 fname = NM_ROOT_FOLDER_NAME; | |
2645 } | |
2646 group = gaim_find_group(fname); | |
2647 } | |
2648 | |
2649 if (group) { | |
8675 | 2650 buddy = gaim_find_buddy_in_group(user->client_data, |
2651 name, group); | |
2652 if (buddy && strcmp(buddy->alias, alias)) | |
2653 gaim_blist_alias_buddy(buddy, alias); | |
2654 } | |
9651 | 2655 |
8675 | 2656 /* Tell the server to alias the contact */ |
2657 rc = nm_send_rename_contact(user, contact, alias, | |
2658 _rename_contact_resp_cb, NULL); | |
2659 _check_for_disconnect(user, rc); | |
2660 } | |
2661 } | |
2662 if (contacts) | |
2663 g_list_free(contacts); | |
2664 } | |
2665 } | |
2666 | |
2667 static void | |
2668 novell_group_buddy(GaimConnection * gc, | |
2669 const char *name, const char *old_group_name, | |
2670 const char *new_group_name) | |
2671 { | |
2672 NMFolder *old_folder; | |
2673 NMFolder *new_folder; | |
2674 NMContact *contact; | |
2675 NMUser *user; | |
2676 const char *dn; | |
2677 NMERR_T rc = NM_OK; | |
2678 | |
2679 if (gc == NULL || name == NULL || | |
2680 old_group_name == NULL || new_group_name == NULL) | |
2681 return; | |
2682 | |
2683 user = (NMUser *) gc->proto_data; | |
2684 if (user && (dn = nm_lookup_dn(user, name))) { | |
2685 | |
2686 /* Find the old folder */ | |
9651 | 2687 if (strcmp(old_group_name, NM_ROOT_FOLDER_NAME) == 0) { |
2688 old_folder = nm_get_root_folder(user); | |
2689 if (nm_folder_find_contact(old_folder, dn) == NULL) | |
2690 old_folder = nm_find_folder(user, old_group_name); | |
2691 } else { | |
2692 old_folder = nm_find_folder(user, old_group_name); | |
2693 } | |
2694 | |
8675 | 2695 if (old_folder && (contact = nm_folder_find_contact(old_folder, dn))) { |
2696 | |
2697 /* Find the new folder */ | |
2698 new_folder = nm_find_folder(user, new_group_name); | |
9651 | 2699 if (new_folder == NULL) { |
2700 if (strcmp(new_group_name, NM_ROOT_FOLDER_NAME) == 0) | |
2701 new_folder = nm_get_root_folder(user); | |
2702 } | |
2703 | |
8675 | 2704 if (new_folder) { |
2705 | |
2706 /* Tell the server to move the contact to the new folder */ | |
2707 rc = nm_send_move_contact(user, contact, new_folder, | |
2708 _move_contact_resp_cb, NULL); | |
2709 | |
2710 } else { | |
2711 | |
2712 nm_contact_add_ref(contact); | |
2713 | |
2714 /* Remove the old contact first */ | |
2715 nm_send_remove_contact(user, old_folder, contact, | |
2716 _remove_contact_resp_cb, NULL); | |
2717 | |
2718 /* New folder does not exist yet, so create it */ | |
2719 rc = nm_send_create_folder(user, new_group_name, | |
2720 _create_folder_resp_move_contact, | |
2721 contact); | |
2722 } | |
2723 | |
2724 _check_for_disconnect(user, rc); | |
2725 } | |
2726 } | |
2727 } | |
2728 | |
2729 static void | |
2730 novell_rename_group(GaimConnection * gc, const char *old_name, | |
9285 | 2731 GaimGroup *group, GList *moved_buddies) |
8675 | 2732 { |
2733 NMERR_T rc = NM_OK; | |
8782
5a2b5e4abf3a
[gaim-migrate @ 9544]
Christian Hammond <chipx86@chipx86.com>
parents:
8781
diff
changeset
|
2734 NMFolder *folder; |
8675 | 2735 NMUser *user; |
2736 | |
9285 | 2737 if (gc == NULL || old_name == NULL || group == NULL || moved_buddies == NULL) { |
8675 | 2738 return; |
2739 } | |
2740 | |
2741 user = gc->proto_data; | |
2742 if (user) { | |
2743 /* Does new folder exist already? */ | |
9285 | 2744 if (nm_find_folder(user, group->name)) { |
9651 | 2745 /* gaim_blist_rename_group() adds the buddies |
2746 * to the new group and removes the old group... | |
2747 * so there is nothing more to do here. | |
8675 | 2748 */ |
2749 return; | |
2750 } | |
2751 | |
9651 | 2752 if (strcmp(old_name, NM_ROOT_FOLDER_NAME) == 0) { |
2753 /* Can't rename the root folder ... need to revisit this */ | |
2754 return; | |
2755 } | |
2756 | |
8782
5a2b5e4abf3a
[gaim-migrate @ 9544]
Christian Hammond <chipx86@chipx86.com>
parents:
8781
diff
changeset
|
2757 folder = nm_find_folder(user, old_name); |
8675 | 2758 if (folder) { |
9285 | 2759 rc = nm_send_rename_folder(user, folder, group->name, |
8675 | 2760 _rename_folder_resp_cb, NULL); |
2761 _check_for_disconnect(user, rc); | |
2762 } | |
2763 } | |
2764 } | |
2765 | |
2766 static void | |
9972 | 2767 novell_list_emblems(GaimBuddy * buddy, const char **se, const char **sw, const char **nw, const char **ne) |
8675 | 2768 { |
11536 | 2769 NMUserRecord *user_record = NULL; |
2770 GaimConnection *gc; | |
2771 NMUser *user; | |
2772 int status = 0; | |
2773 | |
2774 gc = gaim_account_get_connection(buddy->account); | |
2775 | |
2776 if (gc == NULL || (user = gc->proto_data) == NULL) | |
2777 return; | |
2778 | |
2779 user_record = nm_find_user_record(user, buddy->name); | |
2780 | |
2781 if (user_record) | |
2782 status = nm_user_record_get_status(user_record); | |
8675 | 2783 |
2784 switch (status) { | |
2785 case NM_STATUS_AVAILABLE: | |
2786 *se = ""; | |
2787 break; | |
2788 case NM_STATUS_AWAY: | |
2789 *se = "away"; | |
2790 break; | |
2791 case NM_STATUS_BUSY: | |
2792 *se = "occupied"; | |
2793 break; | |
2794 case NM_STATUS_UNKNOWN: | |
2795 *se = "error"; | |
2796 break; | |
2797 } | |
2798 } | |
2799 | |
2800 static const char * | |
2801 novell_list_icon(GaimAccount * account, GaimBuddy * buddy) | |
2802 { | |
2803 return "novell"; | |
2804 } | |
2805 | |
2806 static char * | |
2807 novell_tooltip_text(GaimBuddy * buddy) | |
2808 { | |
2809 NMUserRecord *user_record = NULL; | |
2810 GaimConnection *gc; | |
2811 NMUser *user; | |
2812 int status = 0; | |
2813 char *ret_text = NULL; | |
2814 const char *status_str = NULL; | |
2815 const char *text = NULL; | |
2816 | |
2817 if (buddy == NULL) | |
2818 return ""; | |
2819 | |
2820 gc = gaim_account_get_connection(buddy->account); | |
2821 if (gc == NULL || (user = gc->proto_data) == NULL) | |
2822 return ""; | |
2823 | |
2824 if (GAIM_BUDDY_IS_ONLINE(buddy)) { | |
2825 user_record = nm_find_user_record(user, buddy->name); | |
2826 if (user_record) { | |
2827 status = nm_user_record_get_status(user_record); | |
2828 text = nm_user_record_get_status_text(user_record); | |
2829 /* No custom text, so default it ... */ | |
2830 switch (status) { | |
2831 case NM_STATUS_AVAILABLE: | |
2832 status_str = _("Available"); | |
2833 break; | |
2834 case NM_STATUS_AWAY: | |
2835 status_str = _("Away"); | |
2836 break; | |
2837 case NM_STATUS_BUSY: | |
2838 status_str = _("Busy"); | |
2839 break; | |
2840 case NM_STATUS_AWAY_IDLE: | |
2841 status_str = _("Idle"); | |
2842 break; | |
2843 case NM_STATUS_OFFLINE: | |
2844 status_str = _("Offline"); | |
2845 break; | |
2846 default: | |
2847 status_str = _("Unknown"); | |
2848 break; | |
2849 } | |
2850 | |
2851 if (text) | |
8781 | 2852 ret_text = g_strdup_printf("\n<b>%s:</b> %s" |
2853 "\n<b>%s:</b> %s", | |
2854 _("Status"), status_str, | |
2855 _("Message"), text); | |
8675 | 2856 else |
8781 | 2857 ret_text = g_strdup_printf("\n<b>%s:</b> %s", |
2858 _("Status"), status_str); | |
8675 | 2859 } |
2860 } | |
2861 | |
2862 return ret_text; | |
2863 } | |
2864 | |
2865 static void | |
2866 novell_set_idle(GaimConnection * gc, int time) | |
2867 { | |
2868 NMUser *user; | |
2869 NMERR_T rc = NM_OK; | |
2870 | |
2871 if (gc == NULL) | |
2872 return; | |
2873 | |
2874 user = gc->proto_data; | |
2875 if (user == NULL) | |
2876 return; | |
2877 | |
2878 if (time > 0) | |
2879 rc = nm_send_set_status(user, NM_STATUS_AWAY_IDLE, NULL, NULL, NULL, | |
2880 NULL); | |
2881 else | |
2882 rc = nm_send_set_status(user, NM_STATUS_AVAILABLE, NULL, NULL, NULL, | |
2883 NULL); | |
2884 | |
2885 _check_for_disconnect(user, rc); | |
2886 } | |
2887 | |
2888 static void | |
2889 novell_get_info(GaimConnection * gc, const char *name) | |
2890 { | |
2891 NMUserRecord *user_record; | |
2892 NMUser *user; | |
2893 NMERR_T rc; | |
2894 | |
2895 if (gc == NULL || name == NULL) | |
2896 return; | |
2897 | |
2898 user = (NMUser *) gc->proto_data; | |
2899 if (user) { | |
2900 | |
2901 user_record = nm_find_user_record(user, name); | |
2902 if (user_record) { | |
2903 | |
2904 _show_info(gc, user_record); | |
2905 | |
2906 } else { | |
2907 | |
2908 rc = nm_send_get_details(user, name, | |
2909 _get_details_resp_show_info, g_strdup(name)); | |
2910 | |
2911 _check_for_disconnect(user, rc); | |
2912 | |
2913 } | |
2914 | |
2915 } | |
2916 } | |
2917 | |
2918 static char * | |
2919 novell_status_text(GaimBuddy * buddy) | |
2920 { | |
2921 const char *text = NULL; | |
2922 const char *dn = NULL; | |
2923 | |
2924 if (buddy && buddy->account) { | |
2925 GaimConnection *gc = gaim_account_get_connection(buddy->account); | |
2926 | |
2927 if (gc && gc->proto_data) { | |
2928 NMUser *user = gc->proto_data; | |
2929 | |
2930 dn = nm_lookup_dn(user, buddy->name); | |
2931 if (dn) { | |
2932 NMUserRecord *user_record = nm_find_user_record(user, dn); | |
2933 | |
2934 if (user_record) { | |
2935 text = nm_user_record_get_status_text(user_record); | |
2936 if (text) | |
2937 return g_strdup(text); | |
2938 } | |
2939 } | |
2940 } | |
2941 } | |
2942 | |
2943 return NULL; | |
2944 } | |
10762 | 2945 |
2946 /* | |
2947 * TODO: Someone that uses this protocol needs to verify | |
2948 * that these are correct and work. | |
2949 * | |
2950 * Before the status rewrite, Novell had the following | |
2951 * user-setable statuses: Available, Away, Busy, Appear | |
2952 * Offline and GAIM_AWAY_CUSTOM. Are all of those taken | |
2953 * care of with the statuses below? | |
2954 */ | |
8675 | 2955 static GList * |
10762 | 2956 novell_status_types(GaimAccount *account) |
8675 | 2957 { |
10762 | 2958 GList *status_types = NULL; |
2959 GaimStatusType *type; | |
2960 | |
2961 g_return_val_if_fail(account != NULL, NULL); | |
2962 | |
2963 type = gaim_status_type_new_full(GAIM_STATUS_OFFLINE, "offline", _("Offline"), FALSE, TRUE, FALSE); | |
2964 status_types = g_list_append(status_types, type); | |
2965 | |
11971 | 2966 type = gaim_status_type_new_full(GAIM_STATUS_AVAILABLE, "available", _("Available"), TRUE, TRUE, FALSE); |
10762 | 2967 status_types = g_list_append(status_types, type); |
2968 | |
11971 | 2969 type = gaim_status_type_new_with_attrs(GAIM_STATUS_AWAY, "away", _("Away"), |
2970 TRUE, TRUE, FALSE, | |
2971 "message", _("Message"), gaim_value_new(GAIM_TYPE_STRING), | |
2972 NULL); | |
10762 | 2973 status_types = g_list_append(status_types, type); |
2974 | |
11971 | 2975 type = gaim_status_type_new_full(GAIM_STATUS_UNAVAILABLE, "busy", _("Busy"), TRUE, TRUE, FALSE); |
2976 status_types = g_list_append(status_types, type); | |
2977 | |
2978 type = gaim_status_type_new_full(GAIM_STATUS_HIDDEN, "appearoffline", _("Appear Offline"), TRUE, TRUE, FALSE); | |
10762 | 2979 status_types = g_list_append(status_types, type); |
2980 | |
2981 return status_types; | |
8675 | 2982 } |
2983 | |
2984 static void | |
10762 | 2985 novell_set_status(GaimAccount *account, GaimStatus *status) |
2986 { | |
11971 | 2987 GaimConnection *gc; |
10762 | 2988 gboolean connected; |
11972 | 2989 GaimPresence *presence; |
10762 | 2990 GaimStatusType *type; |
11971 | 2991 GaimStatusPrimitive primitive; |
2992 NMUser *user; | |
2993 NMSTATUS_T novellstatus = NM_STATUS_AVAILABLE; | |
2994 NMERR_T rc = NM_OK; | |
2995 const char *msg = NULL; | |
2996 char *text = NULL; | |
10762 | 2997 |
2998 connected = gaim_account_is_connected(account); | |
11972 | 2999 presence = gaim_status_get_presence(status); |
10762 | 3000 type = gaim_status_get_type(status); |
3001 primitive = gaim_status_type_get_primitive(type); | |
3002 | |
3003 /* | |
3004 * We don't have any independent statuses, so we don't need to | |
3005 * do anything when a status is deactivated (because another | |
3006 * status is about to be activated). | |
3007 */ | |
3008 if (!gaim_status_is_active(status)) | |
3009 return; | |
3010 | |
11718 | 3011 if (!connected) |
3012 return; | |
3013 | |
11971 | 3014 gc = gaim_account_get_connection(account); |
8675 | 3015 user = gc->proto_data; |
3016 if (user == NULL) | |
3017 return; | |
3018 | |
11971 | 3019 if (primitive == GAIM_STATUS_AVAILABLE) { |
3020 novellstatus = NM_STATUS_AVAILABLE; | |
3021 } else if (primitive == GAIM_STATUS_AWAY) { | |
3022 novellstatus = NM_STATUS_AWAY; | |
3023 | |
3024 msg = gaim_status_get_attr_string(status, "message"); | |
3025 | |
3026 if ((msg != NULL) && (*msg != '\0')) { | |
3027 /* Truncate the status text if necessary */ | |
3028 /* | |
3029 * TODO: I think this might not be correctly | |
3030 * NULL-terminated..? And what if the string is | |
3031 * 61 characters? Buffer overflow? | |
3032 */ | |
3033 text = g_strdup(msg); | |
3034 if (g_utf8_strlen(msg, -1) > 60) { | |
3035 g_utf8_strncpy(text, msg, 60); | |
3036 strcat(text, "..."); | |
3037 } | |
3038 | |
3039 /* Don't want newlines in status text */ | |
3040 gaim_util_chrreplace(text, '\n', ' '); | |
8675 | 3041 } |
3042 | |
11971 | 3043 } else if (primitive == GAIM_STATUS_UNAVAILABLE) { |
3044 novellstatus = NM_STATUS_BUSY; | |
3045 } else if (primitive == GAIM_STATUS_HIDDEN) { | |
3046 novellstatus = NM_STATUS_OFFLINE; | |
11972 | 3047 } else if (gaim_presence_is_idle(presence)) { |
11971 | 3048 novellstatus = NM_STATUS_AWAY_IDLE; |
8675 | 3049 } else { |
11971 | 3050 novellstatus = NM_STATUS_AVAILABLE; |
8675 | 3051 } |
3052 | |
11971 | 3053 rc = nm_send_set_status(user, novellstatus, text, msg, NULL, NULL); |
8675 | 3054 _check_for_disconnect(user, rc); |
3055 | |
3056 if (text) | |
3057 g_free(text); | |
3058 } | |
10762 | 3059 |
8933 | 3060 static void |
3061 novell_add_permit(GaimConnection *gc, const char *who) | |
3062 { | |
3063 NMUser *user; | |
3064 NMERR_T rc = NM_OK; | |
3065 const char *name = who; | |
3066 | |
3067 if (gc == NULL || who == NULL) | |
3068 return; | |
3069 | |
3070 user = gc->proto_data; | |
3071 if (user == NULL) | |
3072 return; | |
3073 | |
3074 /* Remove first -- we will add it back in when we get | |
3075 * the okay from the server | |
3076 */ | |
3077 gaim_privacy_permit_remove(gc->account, who, TRUE); | |
3078 | |
3079 if (nm_user_is_privacy_locked(user)) { | |
3080 _show_privacy_locked_error(gc, user); | |
3081 _sync_privacy_lists(user); | |
3082 return; | |
3083 } | |
3084 | |
3085 /* Work around for problem with un-typed, dotted contexts */ | |
3086 if (strchr(who, '.')) { | |
3087 const char *dn = nm_lookup_dn(user, who); | |
3088 if (dn == NULL) { | |
3089 rc = nm_send_get_details(user, who, _get_details_send_privacy_create, | |
3090 (gpointer)TRUE); | |
3091 _check_for_disconnect(user, rc); | |
3092 return; | |
3093 } else { | |
3094 name = dn; | |
3095 } | |
3096 } | |
3097 | |
3098 rc = nm_send_create_privacy_item(user, name, TRUE, | |
3099 _create_privacy_item_permit_resp_cb, | |
3100 g_strdup(who)); | |
3101 _check_for_disconnect(user, rc); | |
3102 } | |
3103 | |
3104 static void | |
3105 novell_add_deny(GaimConnection *gc, const char *who) | |
3106 { | |
3107 NMUser *user; | |
3108 NMERR_T rc = NM_OK; | |
3109 const char *name = who; | |
3110 | |
3111 if (gc == NULL || who == NULL) | |
3112 return; | |
3113 | |
3114 user = gc->proto_data; | |
3115 if (user == NULL) | |
3116 return; | |
3117 | |
3118 /* Remove first -- we will add it back in when we get | |
3119 * the okay from the server | |
3120 */ | |
3121 gaim_privacy_deny_remove(gc->account, who, TRUE); | |
3122 | |
3123 if (nm_user_is_privacy_locked(user)) { | |
3124 _show_privacy_locked_error(gc, user); | |
3125 _sync_privacy_lists(user); | |
3126 return; | |
3127 } | |
3128 | |
3129 /* Work around for problem with un-typed, dotted contexts */ | |
3130 if (strchr(who, '.')) { | |
3131 const char *dn = nm_lookup_dn(user, who); | |
3132 if (dn == NULL) { | |
3133 rc = nm_send_get_details(user, who, _get_details_send_privacy_create, | |
3134 (gpointer)FALSE); | |
3135 _check_for_disconnect(user, rc); | |
3136 return; | |
3137 } else { | |
3138 name = dn; | |
3139 } | |
3140 } | |
3141 | |
3142 rc = nm_send_create_privacy_item(user, name, FALSE, | |
3143 _create_privacy_item_deny_resp_cb, | |
3144 g_strdup(who)); | |
3145 _check_for_disconnect(user, rc); | |
3146 } | |
3147 | |
3148 static void | |
3149 novell_rem_permit(GaimConnection *gc, const char *who) | |
3150 { | |
3151 NMUser *user; | |
3152 NMERR_T rc = NM_OK; | |
3153 const char *dn = NULL; | |
3154 | |
3155 if (gc == NULL || who == NULL) | |
3156 return; | |
3157 | |
3158 user = gc->proto_data; | |
3159 if (user == NULL) | |
3160 return; | |
3161 | |
3162 if (nm_user_is_privacy_locked(user)) { | |
3163 _show_privacy_locked_error(gc, user); | |
3164 _sync_privacy_lists(user); | |
3165 return; | |
3166 } | |
3167 | |
3168 dn = nm_lookup_dn(user, who); | |
3169 if (dn == NULL) | |
3170 dn = who; | |
3171 | |
3172 rc = nm_send_remove_privacy_item(user, dn, TRUE, | |
3173 _remove_privacy_item_resp_cb, | |
3174 g_strdup(who)); | |
3175 _check_for_disconnect(user, rc); | |
3176 } | |
3177 | |
3178 static void | |
3179 novell_rem_deny(GaimConnection *gc, const char *who) | |
3180 { | |
3181 NMUser *user; | |
3182 NMERR_T rc = NM_OK; | |
3183 const char *dn = NULL; | |
3184 | |
3185 if (gc == NULL || who == NULL) | |
3186 return; | |
3187 | |
3188 user = gc->proto_data; | |
3189 if (user == NULL) | |
3190 return; | |
3191 | |
3192 if (nm_user_is_privacy_locked(user)) { | |
3193 _show_privacy_locked_error(gc, user); | |
3194 _sync_privacy_lists(user); | |
3195 return; | |
3196 } | |
3197 | |
3198 dn = nm_lookup_dn(user, who); | |
3199 if (dn == NULL) | |
3200 dn = who; | |
3201 | |
3202 rc = nm_send_remove_privacy_item(user, dn, FALSE, | |
3203 _remove_privacy_item_resp_cb, | |
3204 g_strdup(who)); | |
3205 _check_for_disconnect(user, rc); | |
3206 } | |
3207 | |
3208 static void | |
3209 novell_set_permit_deny(GaimConnection *gc) | |
3210 { | |
3211 NMERR_T rc = NM_OK; | |
3212 const char *dn, *name = NULL; | |
3213 NMUserRecord *user_record = NULL; | |
3214 GSList *node = NULL, *copy = NULL; | |
3215 NMUser *user; | |
3216 int i, j, num_contacts, num_folders; | |
3217 NMContact *contact; | |
3218 NMFolder *folder = NULL; | |
3219 | |
3220 if (gc == NULL) | |
3221 return; | |
3222 | |
3223 user = gc->proto_data; | |
3224 if (user == NULL) | |
3225 return; | |
3226 | |
9268 | 3227 if (user->privacy_synched == FALSE) { |
3228 _sync_privacy_lists(user); | |
3229 user->privacy_synched = TRUE; | |
8933 | 3230 return; |
3231 } | |
3232 | |
3233 if (nm_user_is_privacy_locked(user)) { | |
3234 _show_privacy_locked_error(gc, user); | |
3235 _sync_privacy_lists(user); | |
3236 return; | |
3237 } | |
3238 | |
3239 switch (gc->account->perm_deny) { | |
3240 | |
3241 case GAIM_PRIVACY_ALLOW_ALL: | |
3242 rc = nm_send_set_privacy_default(user, FALSE, | |
3243 _set_privacy_default_resp_cb, NULL); | |
3244 _check_for_disconnect(user, rc); | |
3245 | |
3246 /* clear server side deny list */ | |
3247 if (rc == NM_OK) { | |
3248 copy = g_slist_copy(user->deny_list); | |
3249 for (node = copy; node && node->data; node = node->next) { | |
3250 rc = nm_send_remove_privacy_item(user, (const char *)node->data, | |
3251 FALSE, NULL, NULL); | |
3252 if (_check_for_disconnect(user, rc)) | |
3253 break; | |
3254 } | |
3255 g_slist_free(copy); | |
3256 g_slist_free(user->deny_list); | |
3257 user->deny_list = NULL; | |
3258 } | |
3259 break; | |
3260 | |
3261 case GAIM_PRIVACY_DENY_ALL: | |
3262 rc = nm_send_set_privacy_default(user, TRUE, | |
3263 _set_privacy_default_resp_cb, NULL); | |
3264 _check_for_disconnect(user, rc); | |
3265 | |
3266 /* clear server side allow list */ | |
3267 if (rc == NM_OK) { | |
3268 copy = g_slist_copy(user->allow_list); | |
3269 for (node = copy; node && node->data; node = node->next) { | |
3270 rc = nm_send_remove_privacy_item(user, (const char *)node->data, | |
3271 TRUE, NULL, NULL); | |
3272 if (_check_for_disconnect(user, rc)) | |
3273 break; | |
3274 } | |
3275 g_slist_free(copy); | |
3276 g_slist_free(user->allow_list); | |
3277 user->allow_list = NULL; | |
3278 } | |
3279 break; | |
3280 | |
3281 case GAIM_PRIVACY_ALLOW_USERS: | |
3282 | |
3283 rc = nm_send_set_privacy_default(user, TRUE, | |
3284 _set_privacy_default_resp_cb, NULL); | |
3285 _check_for_disconnect(user, rc); | |
3286 | |
3287 /* sync allow lists */ | |
3288 if (rc == NM_OK) { | |
3289 | |
3290 for (node = user->allow_list; node; node = node->next) { | |
3291 user_record = nm_find_user_record(user, (char *)node->data); | |
3292 if (user_record) { | |
3293 name = nm_user_record_get_display_id(user_record); | |
3294 | |
3295 if (!g_slist_find_custom(gc->account->permit, | |
3296 name, (GCompareFunc)nm_utf8_strcasecmp)) { | |
3297 gaim_privacy_permit_add(gc->account, name , TRUE); | |
3298 } | |
3299 } | |
3300 } | |
3301 | |
3302 for (node = gc->account->permit; node; node = node->next) { | |
3303 name = NULL; | |
3304 dn = nm_lookup_dn(user, (char *)node->data); | |
3305 if (dn) { | |
3306 user_record = nm_find_user_record(user, dn); | |
3307 name = nm_user_record_get_display_id(user_record); | |
3308 | |
3309 if (!g_slist_find_custom(user->allow_list, | |
3310 dn, (GCompareFunc)nm_utf8_strcasecmp)) { | |
3311 rc = nm_send_create_privacy_item(user, dn, TRUE, | |
3312 _create_privacy_item_deny_resp_cb, | |
3313 g_strdup(dn)); | |
3314 } | |
3315 } else { | |
3316 gaim_privacy_permit_remove(gc->account, (char *)node->data, TRUE); | |
3317 } | |
3318 } | |
3319 } | |
3320 break; | |
3321 | |
3322 case GAIM_PRIVACY_DENY_USERS: | |
3323 | |
3324 /* set to default allow */ | |
3325 rc = nm_send_set_privacy_default(user, FALSE, | |
3326 _set_privacy_default_resp_cb, NULL); | |
3327 _check_for_disconnect(user, rc); | |
3328 | |
3329 /* sync deny lists */ | |
3330 if (rc == NM_OK) { | |
3331 | |
3332 for (node = user->deny_list; node; node = node->next) { | |
3333 user_record = nm_find_user_record(user, (char *)node->data); | |
3334 if (user_record) { | |
3335 name = nm_user_record_get_display_id(user_record); | |
3336 | |
3337 if (!g_slist_find_custom(gc->account->deny, | |
3338 name, (GCompareFunc)nm_utf8_strcasecmp)) { | |
3339 gaim_privacy_deny_add(gc->account, name , TRUE); | |
3340 } | |
3341 } | |
3342 } | |
3343 | |
3344 for (node = gc->account->deny; node; node = node->next) { | |
3345 | |
3346 name = NULL; | |
3347 dn = nm_lookup_dn(user, (char *)node->data); | |
3348 if (dn) { | |
3349 user_record = nm_find_user_record(user, dn); | |
3350 name = nm_user_record_get_display_id(user_record); | |
3351 | |
3352 if (!g_slist_find_custom(user->deny_list, | |
3353 dn, (GCompareFunc)nm_utf8_strcasecmp)) { | |
3354 rc = nm_send_create_privacy_item(user, dn, FALSE, | |
3355 _create_privacy_item_deny_resp_cb, | |
3356 g_strdup(name)); | |
3357 } | |
3358 } else { | |
3359 gaim_privacy_deny_remove(gc->account, (char *)node->data, TRUE); | |
3360 } | |
3361 } | |
3362 | |
3363 } | |
3364 break; | |
3365 | |
3366 case GAIM_PRIVACY_ALLOW_BUDDYLIST: | |
3367 | |
3368 /* remove users from allow list that are not in buddy list */ | |
3369 copy = g_slist_copy(user->allow_list); | |
3370 for (node = copy; node && node->data; node = node->next) { | |
3371 if (!nm_find_contacts(user, node->data)) { | |
3372 rc = nm_send_remove_privacy_item(user, (const char *)node->data, | |
3373 TRUE, NULL, NULL); | |
3374 if (_check_for_disconnect(user, rc)) | |
3375 return; | |
3376 } | |
3377 } | |
3378 g_slist_free(copy); | |
3379 | |
3380 /* add all buddies to allow list */ | |
3381 num_contacts = nm_folder_get_contact_count(user->root_folder); | |
3382 for (i = 0; i < num_contacts; i++) { | |
3383 contact = nm_folder_get_contact(user->root_folder, i); | |
3384 dn = nm_contact_get_dn(contact); | |
3385 if (dn && !g_slist_find_custom(user->allow_list, | |
3386 dn, (GCompareFunc)nm_utf8_strcasecmp)) | |
3387 { | |
3388 rc = nm_send_create_privacy_item(user, dn, TRUE, | |
3389 _create_privacy_item_deny_resp_cb, | |
3390 g_strdup(dn)); | |
3391 if (_check_for_disconnect(user, rc)) | |
3392 return; | |
3393 } | |
3394 | |
3395 } | |
3396 | |
3397 num_folders = nm_folder_get_subfolder_count(user->root_folder); | |
3398 for (i = 0; i < num_folders; i++) { | |
3399 folder = nm_folder_get_subfolder(user->root_folder, i); | |
3400 num_contacts = nm_folder_get_contact_count(folder); | |
3401 for (j = 0; j < num_contacts; j++) { | |
3402 contact = nm_folder_get_contact(folder, j); | |
3403 dn = nm_contact_get_dn(contact); | |
3404 if (dn && !g_slist_find_custom(user->allow_list, | |
3405 dn, (GCompareFunc)nm_utf8_strcasecmp)) | |
3406 { | |
3407 rc = nm_send_create_privacy_item(user, dn, TRUE, | |
3408 _create_privacy_item_deny_resp_cb, | |
3409 g_strdup(dn)); | |
3410 if (_check_for_disconnect(user, rc)) | |
3411 return; | |
3412 } | |
3413 } | |
3414 } | |
3415 | |
3416 /* set to default deny */ | |
3417 rc = nm_send_set_privacy_default(user, TRUE, | |
3418 _set_privacy_default_resp_cb, NULL); | |
3419 if (_check_for_disconnect(user, rc)) | |
3420 break; | |
3421 | |
3422 break; | |
3423 } | |
3424 } | |
3425 | |
3426 static GList * | |
9030 | 3427 novell_blist_node_menu(GaimBlistNode *node) |
8933 | 3428 { |
3429 GList *list = NULL; | |
9268 | 3430 GaimBlistNodeAction *act; |
9030 | 3431 |
3432 if(GAIM_BLIST_NODE_IS_BUDDY(node)) { | |
3433 act = gaim_blist_node_action_new(_("Initiate _Chat"), | |
10662
54ac161a876e
[gaim-migrate @ 12199]
Etan Reisner <pidgin@unreliablesource.net>
parents:
10401
diff
changeset
|
3434 _initiate_conference_cb, NULL, NULL); |
9030 | 3435 list = g_list_append(list, act); |
3436 } | |
8933 | 3437 |
3438 return list; | |
3439 } | |
3440 | |
9268 | 3441 static void |
3442 novell_keepalive(GaimConnection *gc) | |
3443 { | |
3444 NMUser *user; | |
3445 NMERR_T rc = NM_OK; | |
3446 | |
3447 if (gc == NULL) | |
3448 return; | |
3449 | |
3450 user = gc->proto_data; | |
3451 if (user == NULL) | |
3452 return; | |
3453 | |
3454 rc = nm_send_keepalive(user, NULL, NULL); | |
3455 _check_for_disconnect(user, rc); | |
3456 } | |
3457 | |
8675 | 3458 static GaimPluginProtocolInfo prpl_info = { |
3459 0, | |
9475 | 3460 NULL, /* user_splits */ |
3461 NULL, /* protocol_options */ | |
3462 NO_BUDDY_ICONS, /* icon_spec */ | |
3463 novell_list_icon, /* list_icon */ | |
3464 novell_list_emblems, /* list_emblems */ | |
3465 novell_status_text, /* status_text */ | |
3466 novell_tooltip_text, /* tooltip_text */ | |
10762 | 3467 novell_status_types, /* status_types */ |
9475 | 3468 novell_blist_node_menu, /* blist_node_menu */ |
8675 | 3469 NULL, /* chat_info */ |
9754 | 3470 NULL, /* chat_info_defaults */ |
9475 | 3471 novell_login, /* login */ |
3472 novell_close, /* close */ | |
3473 novell_send_im, /* send_im */ | |
8675 | 3474 NULL, /* set_info */ |
9475 | 3475 novell_send_typing, /* send_typing */ |
3476 novell_get_info, /* get_info */ | |
10762 | 3477 novell_set_status, /* set_status */ |
9475 | 3478 novell_set_idle, /* set_idle */ |
3479 NULL, /* change_passwd */ | |
3480 novell_add_buddy, /* add_buddy */ | |
8675 | 3481 NULL, /* add_buddies */ |
9475 | 3482 novell_remove_buddy, /* remove_buddy */ |
8675 | 3483 NULL, /* remove_buddies */ |
9475 | 3484 novell_add_permit, /* add_permit */ |
3485 novell_add_deny, /* add_deny */ | |
3486 novell_rem_permit, /* rem_permit */ | |
3487 novell_rem_deny, /* rem_deny */ | |
3488 novell_set_permit_deny, /* set_permit_deny */ | |
8675 | 3489 NULL, /* join_chat */ |
9268 | 3490 NULL, /* reject_chat */ |
9917 | 3491 NULL, /* get_chat_name */ |
8933 | 3492 novell_chat_invite, /* chat_invite */ |
9475 | 3493 novell_chat_leave, /* chat_leave */ |
8675 | 3494 NULL, /* chat_whisper */ |
9475 | 3495 novell_chat_send, /* chat_send */ |
3496 novell_keepalive, /* keepalive */ | |
8675 | 3497 NULL, /* register_user */ |
3498 NULL, /* get_cb_info */ | |
9475 | 3499 NULL, /* get_cb_away */ |
3500 novell_alias_buddy, /* alias_buddy */ | |
3501 novell_group_buddy, /* group_buddy */ | |
3502 novell_rename_group, /* rename_group */ | |
8675 | 3503 NULL, /* buddy_free */ |
9475 | 3504 novell_convo_closed, /* convo_closed */ |
11153 | 3505 gaim_normalize_nocase, /* normalize */ |
8675 | 3506 NULL, /* set_buddy_icon */ |
9475 | 3507 novell_remove_group, /* remove_group */ |
3508 NULL, /* get_cb_real_name */ | |
3509 NULL, /* set_chat_topic */ | |
3510 NULL, /* find_blist_chat */ | |
3511 NULL, /* roomlist_get_list */ | |
3512 NULL, /* roomlist_cancel */ | |
3513 NULL, /* roomlist_expand_category */ | |
9473 | 3514 NULL, /* can_receive_file */ |
12143
cbebda5f019c
[gaim-migrate @ 14444]
Richard Laager <rlaager@wiktel.com>
parents:
12126
diff
changeset
|
3515 NULL, /* send_file */ |
cbebda5f019c
[gaim-migrate @ 14444]
Richard Laager <rlaager@wiktel.com>
parents:
12126
diff
changeset
|
3516 NULL /* new_xfer */ |
8675 | 3517 }; |
3518 | |
3519 static GaimPluginInfo info = { | |
9943 | 3520 GAIM_PLUGIN_MAGIC, |
3521 GAIM_MAJOR_VERSION, | |
3522 GAIM_MINOR_VERSION, | |
8993 | 3523 GAIM_PLUGIN_PROTOCOL, /**< type */ |
3524 NULL, /**< ui_requirement */ | |
3525 0, /**< flags */ | |
3526 NULL, /**< dependencies */ | |
3527 GAIM_PRIORITY_DEFAULT, /**< priority */ | |
3528 "prpl-novell", /**< id */ | |
3529 "GroupWise", /**< name */ | |
3530 VERSION, /**< version */ | |
8675 | 3531 /** summary */ |
3532 N_("Novell GroupWise Messenger Protocol Plugin"), | |
3533 /** description */ | |
3534 N_("Novell GroupWise Messenger Protocol Plugin"), | |
8993 | 3535 NULL, /**< author */ |
3536 GAIM_WEBSITE, /**< homepage */ | |
3537 | |
3538 NULL, /**< load */ | |
3539 NULL, /**< unload */ | |
3540 NULL, /**< destroy */ | |
3541 | |
3542 NULL, /**< ui_info */ | |
3543 &prpl_info, /**< extra_info */ | |
3544 NULL, | |
3545 NULL | |
8675 | 3546 }; |
3547 | |
3548 static void | |
3549 init_plugin(GaimPlugin * plugin) | |
3550 { | |
3551 GaimAccountOption *option; | |
3552 | |
3553 option = gaim_account_option_string_new(_("Server address"), "server", NULL); | |
3554 prpl_info.protocol_options = | |
3555 g_list_append(prpl_info.protocol_options, option); | |
3556 | |
3557 option = gaim_account_option_int_new(_("Server port"), "port", DEFAULT_PORT); | |
3558 prpl_info.protocol_options = | |
3559 g_list_append(prpl_info.protocol_options, option); | |
3560 | |
3561 my_protocol = plugin; | |
3562 } | |
3563 | |
3564 GAIM_INIT_PLUGIN(novell, init_plugin, info); |