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