annotate src/protocols/novell/novell.c @ 10132:f55a64945e77

[gaim-migrate @ 11196] Patch 1037487, from Evan Schoenberg to show more conversation errors in the actually conversation window instead of in a pop-up error window. Thanks Evan! committer: Tailor Script <[e-mail]>

 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 "version.h"
34 
35 #define DEFAULT_PORT			8300
36 #define NOVELL_CONNECT_STEPS	4
37 #define NM_ROOT_FOLDER_NAME "GroupWise Messenger"
38 
39 static GaimPlugin *my_protocol = NULL;
40 
41 static gboolean
42 _is_disconnect_error(NMERR_T err);
43 
44 static gboolean
45 _check_for_disconnect(NMUser * user, NMERR_T err);
46 
47 static void
48 _send_message(NMUser * user, NMMessage * message);
49 
50 static void
51 _update_buddy_status(GaimBuddy * buddy, int status, int gmt);
52 
53 static void
54 _remove_gaim_buddies(NMUser * user);
55 
56 static void
57 _add_contacts_to_gaim_blist(NMUser * user, NMFolder * folder);
58 
59 static void
60 _add_gaim_buddies(NMUser * user);
61 
62 static void
63 _sync_contact_list(NMUser *user);
64 
65 static void
66 _sync_privacy_lists(NMUser *user);
67 
68 static void
69 _show_info(GaimConnection * gc, NMUserRecord * user_record);
70 
71 const char *
72 _get_conference_name(int id);
73 
74 /*******************************************************************************
75  * Response callbacks
76  *******************************************************************************/
77 
78 /* Handle login response */
79 static void
80 _login_resp_cb(NMUser * user, NMERR_T ret_code,
81 			   gpointer resp_data, gpointer user_data)
82 {
83 	GaimConnection *gc;
84 	const char *alias;
85 	NMERR_T rc;
86 
87 	if (user == NULL)
88 		return;
89 
90 	gc = gaim_account_get_connection(user->client_data);
91 	if (gc == NULL)
92 		return;
93 
94 	if (ret_code == NM_OK) {
95 
96 		/* Set alias for user if not set (use Full Name) */
97 		alias = gaim_account_get_alias(user->client_data);
98 		if (alias == NULL || *alias == '\0') {
99 			alias = nm_user_record_get_full_name(user->user_record);
100 
101 			if (alias)
102 				gaim_account_set_alias(user->client_data, alias);
103 		}
104 
105 		/* Tell Gaim that we are connected */
106 		gaim_connection_set_state(gc, GAIM_CONNECTED);
107 		serv_finish_login(gc);
108 
109 		_sync_contact_list(user);
110 
111 		rc = nm_send_set_status(user, NM_STATUS_AVAILABLE, NULL, NULL, NULL,
112 								NULL);
113 		_check_for_disconnect(user, rc);
114 
115 	} else {
116 
117 		char *err = g_strdup_printf(_("Login failed (%s)."),
118 					    nm_error_to_string (ret_code));
119 
120 		gaim_connection_error(gc, err);
121 		g_free(err);
122 
123 	}
124 }
125 
126 /* Handle getstatus response*/
127 static void
128 _get_status_resp_cb(NMUser * user, NMERR_T ret_code,
129 					gpointer resp_data, gpointer user_data)
130 {
131 	GaimBuddy *buddy;
132 	GSList *buddies;
133 	GSList *bnode;
134 	NMUserRecord *user_record = (NMUserRecord *) resp_data;
135 	int status;
136 
137 	if (user == NULL || user_record == NULL)
138 		return;
139 
140 	if (ret_code == NM_OK) {
141 
142 		/* Find all Gaim buddies and update their statuses */
143 		const char *name = nm_user_record_get_display_id(user_record);
144 
145 		if (name) {
146 			buddies = gaim_find_buddies((GaimAccount *) user->client_data, name);
147 			for (bnode = buddies; bnode; bnode = bnode->next) {
148 				buddy = (GaimBuddy *) bnode->data;
149 				if (buddy) {
150 					status = nm_user_record_get_status(user_record);
151 					_update_buddy_status(buddy, status, time(0));
152 				}
153 			}
154 		}
155 
156 	} else {
157 
158 		gaim_debug(GAIM_DEBUG_INFO, "novell",
159 				   "_get_status_resp_cb(): rc = 0x%X\n", ret_code);
160 
161 	}
162 }
163 
164 /* Show an error if the rename failed */
165 static void
166 _rename_contact_resp_cb(NMUser * user, NMERR_T ret_code,
167 						gpointer resp_data, gpointer user_data)
168 {
169 	if (ret_code != NM_OK) {
170 		gaim_debug(GAIM_DEBUG_INFO, "novell",
171 				   "_rename_contact_resp_cb(): rc = 0x%X\n", ret_code);
172 	}
173 }
174 
175 /* Handle the getdetails response and send the message */
176 static void
177 _get_details_resp_send_msg(NMUser * user, NMERR_T ret_code,
178 						   gpointer resp_data, gpointer user_data)
179 {
180 	GaimConversation *gconv;
181 	GaimConnection *gc;
182 	NMUserRecord *user_record = NULL;
183 	NMContact *cntct = NULL;
184 	NMConference *conf;
185 	NMMessage *msg = user_data;
186 	const char *dn = NULL;
187 	const char *name;
188 
189 	if (user == NULL || msg == NULL)
190 		return;
191 
192 	if (ret_code == NM_OK) {
193 		user_record = (NMUserRecord *) resp_data;
194 		if (user_record) {
195 
196 			/* Set the title for the conversation */
197 			gconv =	gaim_find_conversation_with_account(nm_user_record_get_display_id(user_record),
198 														(GaimAccount *) user->client_data);
199 			if (gconv) {
200 
201 				dn = nm_user_record_get_dn(user_record);
202 				if (dn) {
203 					cntct = nm_find_contact(user, dn);
204 				}
205 
206 				if (cntct) {
207 					gaim_conversation_set_title(gconv,
208 												nm_contact_get_display_name(cntct));
209 				} else {
210 
211 					/* Not in the contact list, try to user full name */
212 					name = (char *) nm_user_record_get_full_name(user_record);
213 					if (name)
214 						gaim_conversation_set_title(gconv, name);
215 				}
216 			}
217 
218 			/* Add the user record to particpant list */
219 			conf = nm_message_get_conference(msg);
220 			if (conf) {
221 				nm_conference_add_participant(conf, user_record);
222 				_send_message(user, msg);
223 			}
224 		}
225 
226 	} else {
227 
228 		gc = gaim_account_get_connection(user->client_data);
229 		if (gc != NULL) {
230 			char *err = g_strdup_printf(_("Unable to send message."
231 										  " Could not get details for user (%s)."),
232 						    nm_error_to_string (ret_code));
233 
234 			gaim_notify_error(gc, NULL, err, NULL);
235 			g_free(err);
236 		}
237 
238 		if (msg)
239 			nm_release_message(msg);
240 	}
241 }
242 
243 /* Set up the new GaimBuddy based on the response from getdetails */
244 static void
245 _get_details_resp_setup_buddy(NMUser * user, NMERR_T ret_code,
246 							  gpointer resp_data, gpointer user_data)
247 {
248 	NMUserRecord *user_record;
249 	NMContact *contact;
250 	GaimBuddy *buddy;
251 	const char *alias;
252 	NMERR_T rc = NM_OK;
253 
254 	if (user == NULL || resp_data == NULL || user_data == NULL)
255 		return;
256 
257 	contact = user_data;
258 
259 	if (ret_code == NM_OK) {
260 		user_record = resp_data;
261 
262 		buddy = nm_contact_get_data(contact);
263 
264 		nm_contact_set_user_record(contact, user_record);
265 
266 		/* Set the display id */
267 		gaim_blist_rename_buddy(buddy,
268 								nm_user_record_get_display_id(user_record));
269 
270 		alias = gaim_buddy_get_alias(buddy);
271 		if (alias == NULL || *alias == '\0' || (strcmp(alias, buddy->name) == 0)) {
272 			gaim_blist_alias_buddy(buddy,
273 								   nm_user_record_get_full_name(user_record));
274 
275 			/* Tell the server about the new display name */
276 			rc = nm_send_rename_contact(user, contact,
277 										nm_user_record_get_full_name(user_record),
278 										NULL, NULL);
279 			_check_for_disconnect(user, rc);
280 
281 		}
282 
283 
284 		/* Get initial status for the buddy */
285 		rc = nm_send_get_status(user, resp_data, _get_status_resp_cb, NULL);
286 		_check_for_disconnect(user, rc);
287 
288 /*		nm_release_contact(contact);*/
289 
290 	}
291 
292 	if (contact)
293 		nm_release_contact(contact);
294 }
295 
296 /* Add the new contact into the GaimBuddy list */
297 static void
298 _create_contact_resp_cb(NMUser * user, NMERR_T ret_code,
299 						gpointer resp_data, gpointer user_data)
300 {
301 	NMContact *tmp_contact = (NMContact *) user_data;
302 	NMContact *new_contact = NULL;
303 	NMFolder *folder = NULL;
304 	GaimGroup *group;
305 	GaimBuddy *buddy;
306 	const char *folder_name = NULL;
307 	NMERR_T rc = NM_OK;
308 
309 	if (user == NULL)
310 		return;
311 
312 	if (ret_code == NM_OK) {
313 
314 		new_contact = (NMContact *) resp_data;
315 		if (new_contact == NULL || tmp_contact == NULL)
316 			return;
317 
318 		/* Get the userid and folder name for the new contact */
319 		folder = nm_find_folder_by_id(user,
320 									  nm_contact_get_parent_id(new_contact));
321 		if (folder) {
322 			folder_name = nm_folder_get_name(folder);
323 		}
324 
325 		if (*folder_name == '\0')
326 			folder_name = NM_ROOT_FOLDER_NAME;
327 
328 		/* Re-add the buddy now that we got the okay from the server */
329 		if (folder_name && (group = gaim_find_group(folder_name))) {
330 
331 			const char *alias = nm_contact_get_display_name(tmp_contact);
332 			const char *display_id = nm_contact_get_display_id(new_contact);
333 
334 			if (display_id == NULL)
335 				display_id = nm_contact_get_dn(new_contact);
336 
337 			if (alias && strcmp(alias, display_id)) {
338 
339 				/* The user requested an alias, tell the server about it. */
340 				rc = nm_send_rename_contact(user, new_contact, alias,
341 											_rename_contact_resp_cb, NULL);
342 				_check_for_disconnect(user, rc);
343 
344 			} else {
345 
346 				alias = "";
347 
348 			}
349 
350 			/* Add it to the gaim buddy list if it is not there */
351 			buddy = gaim_find_buddy_in_group(user->client_data, display_id, group);
352 			if (buddy == NULL) {
353 				buddy = gaim_buddy_new(user->client_data, display_id, alias);
354 				gaim_blist_add_buddy(buddy, NULL, group, NULL);
355 			}
356 
357 			/* Save the new buddy as part of the contact object */
358 			nm_contact_set_data(new_contact, (gpointer) buddy);
359 
360 			/* We need details for the user before we can setup the
361 			 * new Gaim buddy. We always call this because the
362 			 * 'createcontact' response fields do not always contain
363 			 * everything that we need.
364 			 */
365 			nm_contact_add_ref(new_contact);
366 
367 			rc = nm_send_get_details(user, nm_contact_get_dn(new_contact),
368 									 _get_details_resp_setup_buddy, new_contact);
369 			_check_for_disconnect(user, rc);
370 
371 		}
372 
373 	} else {
374 		GaimConnection *gc = gaim_account_get_connection(user->client_data);
375 		const char *name = nm_contact_get_dn(tmp_contact);
376 		char *err;
377 
378 		err =
379 			g_strdup_printf(_("Unable to add %s to your buddy list (%s)."),
380 					name, nm_error_to_string (ret_code));
381 		gaim_notify_error(gc, NULL, err, NULL);
382 		g_free(err);
383 
384 	}
385 
386 	if (tmp_contact)
387 		nm_release_contact(tmp_contact);
388 }
389 
390 /* Show an error if we failed to send the message */
391 static void
392 _send_message_resp_cb(NMUser * user, NMERR_T ret_code,
393 					  gpointer resp_data, gpointer user_data)
394 {
395 	GaimConnection *gc;
396 	char *err = NULL;
397 
398 	if (user == NULL)
399 		return;
400 
401 	if (ret_code != NM_OK) {
402 		gc = gaim_account_get_connection(user->client_data);
403 
404 		/* TODO: Improve this! message to who or for what conference? */
405 		err = g_strdup_printf(_("Unable to send message (%s)."),
406 				      nm_error_to_string (ret_code));
407 		gaim_notify_error(gc, NULL, err, NULL);
408 		g_free(err);
409 	}
410 }
411 
412 /* Show an error if the remove failed */
413 static void
414 _remove_contact_resp_cb(NMUser * user, NMERR_T ret_code,
415 						gpointer resp_data, gpointer user_data)
416 {
417 	if (ret_code != NM_OK) {
418 		/* TODO: Display an error? */
419 
420 		gaim_debug(GAIM_DEBUG_INFO, "novell",
421 				   "_remove_contact_resp_cb(): rc = 0x%x\n", ret_code);
422 	}
423 }
424 
425 /* Show an error if the remove failed */
426 static void
427 _remove_folder_resp_cb(NMUser * user, NMERR_T ret_code,
428 					   gpointer resp_data, gpointer user_data)
429 {
430 	if (ret_code != NM_OK) {
431 		/* TODO: Display an error? */
432 
433 		gaim_debug(GAIM_DEBUG_INFO, "novell",
434 				   "_remove_folder_resp_cb(): rc = 0x%x\n", ret_code);
435 	}
436 }
437 
438 /* Show an error if the move failed */
439 static void
440 _move_contact_resp_cb(NMUser * user, NMERR_T ret_code,
441 					  gpointer resp_data, gpointer user_data)
442 {
443 	if (ret_code != NM_OK) {
444 		/* TODO: Display an error? */
445 
446 		gaim_debug(GAIM_DEBUG_INFO, "novell",
447 				   "_move_contact_resp_cb(): rc = 0x%x\n", ret_code);
448 	}
449 }
450 
451 /* Show an error if the rename failed */
452 static void
453 _rename_folder_resp_cb(NMUser * user, NMERR_T ret_code,
454 					   gpointer resp_data, gpointer user_data)
455 {
456 	if (ret_code != NM_OK) {
457 		/* TODO: Display an error? */
458 
459 		gaim_debug(GAIM_DEBUG_INFO, "novell",
460 				   "_rename_folder_resp_cb(): rc = 0x%x\n", ret_code);
461 	}
462 }
463 
464 static void
465 _sendinvite_resp_cb(NMUser *user, NMERR_T ret_code,
466 					gpointer resp_data, gpointer user_data)
467 {
468 	char *err;
469 	GaimConnection *gc;
470 
471 	if (user == NULL)
472 		return;
473 
474 	if (ret_code != NM_OK) {
475 		gc = gaim_account_get_connection(user->client_data);
476 		err = g_strdup_printf(_("Unable to invite user (%s)."), nm_error_to_string(ret_code));
477 		gaim_notify_error(gc, NULL, err, NULL);
478 		g_free(err);
479 
480 		gaim_debug(GAIM_DEBUG_INFO, "novell",
481 				   "_sendinvite_resp_cb(): rc = 0x%x\n", ret_code);
482 	}
483 
484 }
485 
486 /* If the createconf was successful attempt to send the message,
487  * otherwise display an error message to the user.
488  */
489 static void
490 _createconf_resp_send_msg(NMUser * user, NMERR_T ret_code,
491 						  gpointer resp_data, gpointer user_data)
492 {
493 	NMConference *conf;
494 	NMMessage *msg = user_data;
495 
496 	if (user == NULL || msg == NULL)
497 		return;
498 
499 	if (ret_code == NM_OK) {
500 		_send_message(user, msg);
501 	} else {
502 
503 		if ((conf = nm_message_get_conference(msg))) {
504 
505 			GaimConnection *gc = gaim_account_get_connection(user->client_data);
506 			const char *name = NULL;
507 			char *err;
508 			NMUserRecord *ur;
509 
510 			ur = nm_conference_get_participant(conf, 0);
511 			if (ur)
512 				name = nm_user_record_get_userid(ur);
513 
514 			if (name)
515 				err = g_strdup_printf(_("Unable to send message to %s."
516 										" Could not create the conference (%s)."),
517 						      name,
518 						      nm_error_to_string (ret_code));
519 			else
520 				err = g_strdup_printf(_("Unable to send message."
521 										" Could not create the conference (%s)."),
522 						      nm_error_to_string (ret_code));
523 
524 			gaim_notify_error(gc, NULL, err, NULL);
525 			g_free(err);
526 		}
527 
528 		if (msg)
529 			nm_release_message(msg);
530 	}
531 }
532 
533 /* Move contact to newly created folder */
534 static void
535 _create_folder_resp_move_contact(NMUser * user, NMERR_T ret_code,
536 								 gpointer resp_data, gpointer user_data)
537 {
538 	NMContact *contact = user_data;
539 	NMFolder *new_folder;
540 	char *folder_name = resp_data;
541 	NMERR_T rc = NM_OK;
542 
543 	if (user == NULL || folder_name == NULL || contact == NULL) {
544 
545 		if (folder_name)
546 			g_free(folder_name);
547 
548 		return;
549 	}
550 
551 	if (ret_code == NM_OK || ret_code == NMERR_DUPLICATE_FOLDER) {
552 		new_folder = nm_find_folder(user, folder_name);
553 		if (new_folder) {
554 
555 			/* Tell the server to move the contact to the new folder */
556 /*			rc = nm_send_move_contact(user, contact, new_folder,
557 			_move_contact_resp_cb, NULL); */
558 
559 			rc = nm_send_create_contact(user, new_folder, contact,
560 										NULL, NULL);
561 
562 			_check_for_disconnect(user, rc);
563 
564 		}
565 	} else {
566 		GaimConnection *gc = gaim_account_get_connection(user->client_data);
567 		char *err = g_strdup_printf(_("Unable to move user %s"
568 									  " to folder %s in the server side list."
569 									  " Error while creating folder (%s)."),
570 					    nm_contact_get_dn(contact),
571 					    folder_name,
572 					    nm_error_to_string (ret_code));
573 
574 		gaim_notify_error(gc, NULL, err, NULL);
575 		g_free(err);
576 	}
577 
578 	if (folder_name)
579 		g_free(folder_name);
580 }
581 
582 /* Add contact to newly create folder */
583 static void
584 _create_folder_resp_add_contact(NMUser * user, NMERR_T ret_code,
585 								gpointer resp_data, gpointer user_data)
586 {
587 	NMContact *contact = (NMContact *) user_data;
588 	NMFolder *folder;
589 	char *folder_name = (char *) resp_data;
590 	NMERR_T rc = NM_OK;
591 
592 	if (user == NULL || folder_name == NULL || contact == NULL) {
593 
594 		if (contact)
595 			nm_release_contact(contact);
596 
597 		if (folder_name)
598 			g_free(folder_name);
599 
600 		return;
601 	}
602 
603 	if (ret_code == NM_OK || ret_code == NMERR_DUPLICATE_FOLDER) {
604 		folder = nm_find_folder(user, folder_name);
605 		if (folder) {
606 
607 			rc = nm_send_create_contact(user, folder, contact,
608 										_create_contact_resp_cb, contact);
609 			_check_for_disconnect(user, rc);
610 		}
611 	} else {
612 		GaimConnection *gc = gaim_account_get_connection(user->client_data);
613 		const char *name = nm_contact_get_dn(contact);
614 		char *err =
615 			g_strdup_printf(_("Unable to add %s to your buddy list."
616 					  " Error creating folder in server side list (%s)."),
617 					name, nm_error_to_string (ret_code));
618 
619 		gaim_notify_error(gc, NULL, err, NULL);
620 
621 		nm_release_contact(contact);
622 		g_free(err);
623 	}
624 
625 	g_free(folder_name);
626 }
627 
628 static void
629 _join_conf_resp_cb(NMUser * user, NMERR_T ret_code,
630 				   gpointer resp_data, gpointer user_data)
631 {
632 	GaimConversation *chat;
633 	GaimConnection *gc;
634 	NMUserRecord *ur;
635 	NMConference *conference = user_data;
636 	const char *name, *conf_name;
637 	int i, count;
638 
639 	if (user == NULL || conference == NULL)
640 		return;
641 
642 	gc = gaim_account_get_connection(user->client_data);
643 
644 	if (ret_code == NM_OK) {
645 		conf_name = _get_conference_name(++user->conference_count);
646 		chat = serv_got_joined_chat(gc, user->conference_count, conf_name);
647 		if (chat) {
648 
649 			nm_conference_set_data(conference, (gpointer) chat);
650 
651 			count = nm_conference_get_participant_count(conference);
652 			for (i = 0; i < count; i++) {
653 				ur = nm_conference_get_participant(conference, i);
654 				if (ur) {
655 					name = nm_user_record_get_display_id(ur);
656 					gaim_conv_chat_add_user(GAIM_CONV_CHAT(chat), name, NULL, 
657 											GAIM_CBFLAGS_NONE, TRUE);
658 				}
659 			}
660 		}
661 	}
662 }
663 
664 /* Show info returned by getdetails */
665 static void
666 _get_details_resp_show_info(NMUser * user, NMERR_T ret_code,
667 							gpointer resp_data, gpointer user_data)
668 {
669 	GaimConnection *gc;
670 	NMUserRecord *user_record;
671 	char *name;
672 	char *err;
673 
674 	if (user == NULL)
675 		return;
676 
677 	name = user_data;
678 
679 	if (ret_code == NM_OK) {
680 		user_record = (NMUserRecord *) resp_data;
681 		if (user_record) {
682 			_show_info(gaim_account_get_connection(user->client_data),
683 					   user_record);
684 		}
685 	} else {
686 		gc = gaim_account_get_connection(user->client_data);
687 		err =
688 			g_strdup_printf(_("Could not get details for user %s (%s)."),
689 					name, nm_error_to_string (ret_code));
690 		gaim_notify_error(gc, NULL, err, NULL);
691 		g_free(err);
692 	}
693 
694 	if (name)
695 		g_free(name);
696 }
697 
698 /* Handle get details response add to privacy list */
699 static void
700 _get_details_resp_add_privacy_item(NMUser *user, NMERR_T ret_code,
701 								   gpointer resp_data, gpointer user_data)
702 {
703 	GaimConnection *gc;
704 	NMUserRecord *user_record = resp_data;
705 	char *err;
706 	gboolean allowed = GPOINTER_TO_INT(user_data);
707 	const char *display_id;
708 
709 	if (user == NULL)
710 		return;
711 
712 	gc = gaim_account_get_connection(user->client_data);
713 	display_id = nm_user_record_get_display_id(user_record);
714 
715 	if (ret_code == NM_OK) {
716 
717 		if (allowed) {
718 
719 			if (!g_slist_find_custom(gc->account->permit,
720 									 display_id, (GCompareFunc)nm_utf8_strcasecmp)) {
721 				gaim_privacy_permit_add(gc->account, display_id, TRUE);
722 			}
723 
724 		} else {
725 
726 			if (!g_slist_find_custom(gc->account->permit,
727 									 display_id, (GCompareFunc)nm_utf8_strcasecmp)) {
728 				gaim_privacy_deny_add(gc->account, display_id, TRUE);
729 			}
730 		}
731 
732 	} else {
733 
734 		err = g_strdup_printf(_("Unable to add user to privacy list (%s)."),
735 							  nm_error_to_string(ret_code));
736 		gaim_notify_error(gc, NULL, err, NULL);
737 		g_free(err);
738 
739 	}
740 }
741 
742 /* Handle response to create privacy item request */
743 static void
744 _create_privacy_item_deny_resp_cb(NMUser *user, NMERR_T ret_code,
745 								  gpointer resp_data, gpointer user_data)
746 {
747 	GaimConnection *gc;
748 	NMUserRecord *user_record;
749 	char *who = user_data;
750 	char *err;
751 	NMERR_T rc = NM_OK;
752 	const char *display_id = NULL;
753 
754 	if (user == NULL)
755 		return;
756 
757 	gc = gaim_account_get_connection(user->client_data);
758 
759 	if (ret_code == NM_OK) {
760 
761 		user_record = nm_find_user_record(user, who);
762 		if (user_record)
763 			display_id = nm_user_record_get_display_id(user_record);
764 
765 		if (display_id) {
766 
767 			if (!g_slist_find_custom(gc->account->deny,
768 									 display_id, (GCompareFunc)nm_utf8_strcasecmp)) {
769 
770 				gaim_privacy_deny_add(gc->account, display_id, TRUE);
771 			}
772 
773 		} else {
774 			rc = nm_send_get_details(user, who,
775 									 _get_details_resp_add_privacy_item,
776 									 (gpointer)FALSE);
777 			_check_for_disconnect(user, rc);
778 		}
779 	} else {
780 
781 		err = g_strdup_printf(_("Unable to add %s to deny list (%s)."),
782 							  who, nm_error_to_string(ret_code));
783 		gaim_notify_error(gc, NULL, err, NULL);
784 		g_free(err);
785 
786 	}
787 
788 	if (who)
789 		g_free(who);
790 
791 }
792 
793 /* Handle response to create privacy item request */
794 static void
795 _create_privacy_item_permit_resp_cb(NMUser *user, NMERR_T ret_code,
796 									gpointer resp_data, gpointer user_data)
797 {
798 	GaimConnection *gc;
799 	NMUserRecord *user_record;
800 	char *who = user_data;
801 	char *err;
802 	NMERR_T rc = NM_OK;
803 	const char *display_id = NULL;
804 
805 	if (user == NULL)
806 		return;
807 
808 	gc = gaim_account_get_connection(user->client_data);
809 
810 	if (ret_code == NM_OK) {
811 
812 		user_record = nm_find_user_record(user, who);
813 		if (user_record)
814 			display_id = nm_user_record_get_display_id(user_record);
815 
816 		if (display_id) {
817 
818 			if (!g_slist_find_custom(gc->account->permit,
819 									 display_id,
820 									 (GCompareFunc)nm_utf8_strcasecmp)) {
821 
822 				gaim_privacy_permit_add(gc->account, display_id, TRUE);
823 			}
824 
825 		} else {
826 			rc = nm_send_get_details(user, who,
827 									 _get_details_resp_add_privacy_item,
828 									 (gpointer)TRUE);
829 			_check_for_disconnect(user, rc);
830 		}
831 
832 	} else {
833 
834 		err = g_strdup_printf(_("Unable to add %s to permit list (%s)."), who,
835 							  nm_error_to_string(ret_code));
836 		gaim_notify_error(gc, NULL, err, NULL);
837 		g_free(err);
838 
839 	}
840 
841 	if (who)
842 		g_free(who);
843 }
844 
845 static void
846 _get_details_send_privacy_create(NMUser *user, NMERR_T ret_code,
847 								 gpointer resp_data, gpointer user_data)
848 {
849 	NMERR_T rc = NM_OK;
850 	GaimConnection *gc;
851 	NMUserRecord *user_record = resp_data;
852 	char *err;
853 	gboolean allowed = GPOINTER_TO_INT(user_data);
854 	const char *dn, *display_id;
855 
856 	if (user == NULL)
857 		return;
858 
859 	gc = gaim_account_get_connection(user->client_data);
860 	dn = nm_user_record_get_dn(user_record);
861 	display_id = nm_user_record_get_display_id(user_record);
862 
863 	if (ret_code == NM_OK) {
864 
865 		if (allowed) {
866 			rc = nm_send_create_privacy_item(user, dn, TRUE,
867 											 _create_privacy_item_permit_resp_cb,
868 											 g_strdup(display_id));
869 			_check_for_disconnect(user, rc);
870 
871 		} else {
872 			rc = nm_send_create_privacy_item(user, dn, FALSE,
873 											 _create_privacy_item_deny_resp_cb,
874 											 g_strdup(display_id));
875 			_check_for_disconnect(user, rc);
876 		}
877 
878 	} else {
879 
880 		err = g_strdup_printf(_("Unable to add user to privacy list (%s)."),
881 							  nm_error_to_string(ret_code));
882 		gaim_notify_error(gc, NULL, err, NULL);
883 		g_free(err);
884 
885 	}
886 }
887 
888 static void
889 _remove_privacy_item_resp_cb(NMUser *user, NMERR_T ret_code,
890 									gpointer resp_data, gpointer user_data)
891 {
892 	GaimConnection *gc;
893 	char *who = user_data;
894 	char *err;
895 
896 	if (user == NULL)
897 		return;
898 
899 	if (ret_code != NM_OK) {
900 
901 		gc = gaim_account_get_connection(user->client_data);
902 		err = g_strdup_printf(_("Unable to remove %s from privacy list (%s)."), who,
903 							  nm_error_to_string(ret_code));
904 		gaim_notify_error(gc, NULL, err, NULL);
905 		g_free(err);
906 	}
907 
908 	if (who)
909 		g_free(who);
910 }
911 
912 static void
913 _set_privacy_default_resp_cb(NMUser *user, NMERR_T ret_code,
914 									gpointer resp_data, gpointer user_data)
915 {
916 	GaimConnection *gc;
917 	char *err;
918 
919 	if (user == NULL)
920 		return;
921 
922 	if (ret_code != NM_OK) {
923 
924 		gc = gaim_account_get_connection(user->client_data);
925 		err = g_strdup_printf(_("Unable to change server side privacy settings (%s)."),
926 							  nm_error_to_string(ret_code));
927 		gaim_notify_error(gc, NULL, err, NULL);
928 		g_free(err);
929 
930 	}
931 }
932 
933 /* Handle get details response add to privacy list */
934 static void
935 _get_details_resp_send_invite(NMUser *user, NMERR_T ret_code,
936 							  gpointer resp_data, gpointer user_data)
937 {
938 	NMERR_T rc = NM_OK;
939 	GaimConnection *gc;
940 	NMUserRecord *user_record = resp_data;
941 	char *err;
942 	const char *display_id;
943 	GSList *cnode;
944 	NMConference *conference;
945 	gpointer chat;
946 	long id = (long) user_data;
947 
948 	if (user == NULL)
949 		return;
950 
951 	gc = gaim_account_get_connection(user->client_data);
952 	display_id = nm_user_record_get_display_id(user_record);
953 
954 	if (ret_code == NM_OK) {
955 
956 		for (cnode = user->conferences; cnode != NULL; cnode = cnode->next) {
957 			conference = cnode->data;
958 			if (conference && (chat = nm_conference_get_data(conference))) {
959 				if (gaim_conv_chat_get_id(GAIM_CONV_CHAT(chat)) == id) {
960 					rc = nm_send_conference_invite(user, conference, user_record,
961 												   NULL, _sendinvite_resp_cb, NULL);
962 					_check_for_disconnect(user, rc);
963 					break;
964 				}
965 			}
966 		}
967 
968 	} else {
969 
970 		err = g_strdup_printf(_("Unable to invite user (%s)."), nm_error_to_string(ret_code));
971 		gaim_notify_error(gc, NULL, err, NULL);
972 		g_free(err);
973 
974 	}
975 }
976 
977 static void
978 _createconf_resp_send_invite(NMUser * user, NMERR_T ret_code,
979 							  gpointer resp_data, gpointer user_data)
980 {
981 	NMERR_T rc = NM_OK;
982 	NMConference *conference = resp_data;
983 	NMUserRecord *user_record = user_data;
984 	GaimConnection *gc;
985 	char *err;
986 
987 	if (user == NULL)
988 		return;
989 
990 
991 
992 	if (ret_code == NM_OK) {
993 		rc = nm_send_conference_invite(user, conference, user_record,
994 									   NULL, _sendinvite_resp_cb, NULL);
995 		_check_for_disconnect(user, rc);
996 	} else {
997 		err = g_strdup_printf(_("Unable to create conference (%s)."), nm_error_to_string(ret_code));
998 		gc = gaim_account_get_connection(user->client_data);
999 		gaim_notify_error(gc, NULL, err, NULL);
000 		g_free(err);
001 	}
002 }
003 
004 /*******************************************************************************
005  * Helper functions
006  ******************************************************************************/
007 
008 static char *
009 _user_agent_string()
010 {
011 
012 #if !defined(_WIN32)
013 
014 	const char *sysname = "";
015 	const char *release = "";
016 	const char *template = "Gaim/%s (%s; %s)";
017 	struct utsname u;
018 
019 	if (uname(&u) == 0) {
020 		sysname = u.sysname;
021 		release = u.release;
022 	} else {
023 		sysname = "Linux";
024 		release = "Unknown";
025 	}
026 
027 	return g_strdup_printf(template, VERSION, sysname, release);
028 
029 #else
030 
031 	const char *sysname = "";
032 	const char *template = "Gaim/%s (%s; %d.%d)";
033 	OSVERSIONINFO os_info;
034 	SYSTEM_INFO sys_info;
035 
036 	os_info.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
037 	GetVersionEx(&os_info);
038 	GetSystemInfo(&sys_info);
039 
040 	if (os_info.dwPlatformId == VER_PLATFORM_WIN32_NT)  {
041 		switch (os_info.dwMajorVersion) {
042 			case 3:
043 			case 4:
044 				sysname = "Windows NT";
045 				break;
046 			case 5:
047 				switch (os_info.dwMinorVersion) {
048 					case 0:
049 						sysname = "Windows 2000";
050 						break;
051 					case 1:
052 						sysname = "Windows XP";
053 						break;
054 					case 2:
055 						sysname = "Windows Server 2003";
056 						break;
057 					default:
058 						sysname = "Windows";
059 						break;
060 				}
061 				break;
062 			default:
063 				sysname = "Windows";
064 				break;
065 		}
066 
067 	}	else if (os_info.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
068 		switch (os_info.dwMinorVersion) {
069 			case 0:
070 				sysname = "Windows 95";
071 				break;
072 			case 10:
073 				sysname = "Windows 98";
074 				break;
075 			case 90:
076 				sysname = "Windows ME";
077 				break;
078 			default:
079 				sysname = "Windows";
080 				break;
081 		}
082 	} else {
083 		sysname = "Windows";
084 	}
085 
086 	return g_strdup_printf(template, VERSION, sysname,
087 						   os_info.dwMajorVersion, os_info.dwMinorVersion);
088 
089 #endif
090 
091 
092 }
093 
094 static gboolean
095 _is_disconnect_error(NMERR_T err)
096 {
097 	return (err == NMERR_TCP_WRITE ||
098 			err == NMERR_TCP_READ || err == NMERR_PROTOCOL);
099 }
100 
101 static gboolean
102 _check_for_disconnect(NMUser * user, NMERR_T err)
103 {
104 	GaimConnection *gc = gaim_account_get_connection(user->client_data);
105 
106 	if (_is_disconnect_error(err)) {
107 
108 		gaim_connection_error(gc, _("Error communicating with server."
109 									" Closing connection."));
110 		return TRUE;
111 
112 	}
113 
114 	return FALSE;
115 }
116 
117 /* Check to see if the conference is instantiated, if so send the message.
118  * If not send the create conference -- the response handler for the createconf
119  * will call this function again.
120  */
121 static void
122 _send_message(NMUser * user, NMMessage * message)
123 {
124 	NMConference *conf;
125 	NMERR_T rc = NM_OK;
126 
127 	conf = nm_message_get_conference(message);
128 	if (conf) {
129 		/* We have a conference make sure that the
130 		   server knows about it already. */
131 		if (nm_conference_is_instantiated(conf)) {
132 
133 			/* We have everything that we need...finally! */
134 			rc = nm_send_message(user, message, _send_message_resp_cb);
135 			_check_for_disconnect(user, rc);
136 
137 			nm_release_message(message);
138 
139 		} else {
140 			rc = nm_send_create_conference(user, conf, _createconf_resp_send_msg, message);
141 			_check_for_disconnect(user, rc);
142 		}
143 	}
144 }
145 
146 /* Update the status of the given buddy in the Gaim buddy list */
147 static void
148 _update_buddy_status(GaimBuddy * buddy, int status, int gmt)
149 {
150 #if 0
151 	GaimConnection *gc = gaim_account_get_connection(buddy->account);
152 	int gstatus = status << 1;
153 	int idle = 0;
154 	gboolean loggedin = TRUE;
155 
156 	switch (status) {
157 		case NM_STATUS_AVAILABLE:
158 			/*nothing to do */
159 			break;
160 		case NM_STATUS_AWAY:
161 		case NM_STATUS_BUSY:
162 			gstatus |= UC_UNAVAILABLE;
163 			break;
164 		case NM_STATUS_OFFLINE:
165 			loggedin = FALSE;
166 			gstatus |= UC_UNAVAILABLE;
167 			break;
168 		case NM_STATUS_AWAY_IDLE:
169 			idle = gmt;
170 			gstatus |= UC_UNAVAILABLE;
171 			break;
172 		default:
173 			gstatus |= UC_UNAVAILABLE;
174 			loggedin = FALSE;
175 			break;
176 	}
177 
178 	gaim_prpl_user_status(account, buddy->name,
179 						  (loggedin ? "online" : "offline"), NULL);
180 	if (time_idle > 0)
181 		gaim_prpl_got_user_idle(account, buddy->name, TRUE, idle);
182 	else
183 		gaim_prpl_got_user_idle(account, buddy->name, FALSE, 0);
184 #endif
185 }
186 
187 /* Iterate through the cached Gaim buddy list and remove buddies
188  * that are not in the server side list.
189  */
190 static void
191 _remove_gaim_buddies(NMUser *user)
192 {
193 	GaimBlistNode *gnode;
194 	GaimBlistNode *cnode;
195 	GaimBlistNode *bnode;
196 	GaimGroup *group;
197 	GaimBuddy *buddy;
198 	GaimBuddyList *blist;
199 	GSList *rem_list = NULL;
200 	GSList *l;
201 	NMFolder *folder = NULL;
202 	const char *gname = NULL;
203 
204 	if ((blist = gaim_get_blist())) {
205 		for (gnode = blist->root; gnode; gnode = gnode->next) {
206 			if (!GAIM_BLIST_NODE_IS_GROUP(gnode))
207 				continue;
208 			group = (GaimGroup *) gnode;
209 			for (cnode = gnode->child; cnode; cnode = cnode->next) {
210 				if (!GAIM_BLIST_NODE_IS_CONTACT(cnode))
211 					continue;
212 				for (bnode = cnode->child; bnode; bnode = bnode->next) {
213 					if (!GAIM_BLIST_NODE_IS_BUDDY(bnode))
214 						continue;
215 					buddy = (GaimBuddy *) bnode;
216 					if (buddy->account == user->client_data) {
217 						gname = group->name;
218 						if (strcmp(group->name, NM_ROOT_FOLDER_NAME) == 0)
219 							gname = "";
220 						folder = nm_find_folder(user, gname);
221 						if (folder == NULL ||
222 							!nm_folder_find_contact_by_display_id(folder, buddy->name)) {
223 							rem_list = g_slist_append(rem_list, buddy);
224 						}
225 					}
226 				}
227 			}
228 		}
229 
230 		if (rem_list) {
231 			for (l = rem_list; l; l = l->next) {
232 				gaim_blist_remove_buddy(l->data);
233 			}
234 			g_slist_free(rem_list);
235 		}
236 	}
237 }
238 
239 /* Add all of the contacts in the given folder to the Gaim buddy list */
240 static void
241 _add_contacts_to_gaim_blist(NMUser * user, NMFolder * folder)
242 {
243 	NMUserRecord *user_record = NULL;
244 	NMContact *contact = NULL;
245 	GaimBuddy *buddy = NULL;
246 	GaimGroup *group;
247 	NMERR_T cnt = 0, i;
248 	const char *text = NULL;
249 	const char *name = NULL;
250 	const char *fname = NULL;
251 	int status = 0;
252 
253 	/* If this is the root folder give it a name. Gaim does not have the concept of
254 	 * a root folder.
255 	 */
256 	fname = nm_folder_get_name(folder);
257 	if (fname == NULL || *fname == '\0') {
258 		fname = NM_ROOT_FOLDER_NAME;
259 	}
260 
261 	/* Does the Gaim group exist already? */
262 	group = gaim_find_group(fname);
263 	if (group == NULL) {
264 		group = gaim_group_new(fname);
265 		gaim_blist_add_group(group, NULL);
266 	}
267 
268 	/* Get each contact for this folder */
269 	cnt = nm_folder_get_contact_count(folder);
270 	for (i = 0; i < cnt; i++) {
271 		contact = nm_folder_get_contact(folder, i);
272 		if (contact) {
273 
274 			name = nm_contact_get_display_id(contact);
275 			if (name) {
276 
277 				buddy = gaim_find_buddy_in_group(user->client_data, name, group);
278 				if (buddy == NULL) {
279 					/* Add it to the gaim buddy list */
280 					buddy = gaim_buddy_new(user->client_data,
281 										   name,
282 										   nm_contact_get_display_name(contact));
283 
284 					gaim_blist_add_buddy(buddy, NULL, group, NULL);
285 				}
286 
287 				/* Set the initial status for the buddy */
288 				user_record = nm_contact_get_user_record(contact);
289 				if (user_record) {
290 					status = nm_user_record_get_status(user_record);
291 					text = nm_user_record_get_status_text(user_record);
292 				}
293 				_update_buddy_status(buddy, status, time(0));
294 
295 				/* Save the new buddy as part of the contact object */
296 				nm_contact_set_data(contact, (gpointer) buddy);
297 			}
298 
299 		} else {
300 			/* NULL contact. This should not happen, but
301 			 * let's break out of the loop.
302 			 */
303 			break;
304 		}
305 	}
306 }
307 
308 /* Add all of the server side contacts to the Gaim buddy list. */
309 static void
310 _add_gaim_buddies(NMUser * user)
311 {
312 	int cnt = 0, i;
313 	NMFolder *root_folder = NULL;
314 	NMFolder *folder = NULL;
315 
316 	root_folder = nm_get_root_folder(user);
317 	if (root_folder) {
318 
319 		/* Add sub-folders and contacts to sub-folders...
320 		 * iterate throught the sub-folders in reverse order
321 		 * because Gaim adds the folders to the front -- so we
322 		 * want to add the first folder last
323 		 */
324 		cnt = nm_folder_get_subfolder_count(root_folder);
325 		for (i = cnt-1; i >= 0; i--) {
326 			folder = nm_folder_get_subfolder(root_folder, i);
327 			if (folder) {
328 				_add_contacts_to_gaim_blist(user, folder);
329 			}
330 		}
331 
332 		/* Add contacts for the root folder */
333 		_add_contacts_to_gaim_blist(user, root_folder);
334 	}
335 }
336 
337 static void
338 _sync_contact_list(NMUser *user)
339 {
340 	/* Remove all buddies from the local list that are
341 	 * not in the server side list and add all buddies
342 	 * from the server side list that are not in
343 	 * the local list
344 	 */
345 	_remove_gaim_buddies(user);
346 	_add_gaim_buddies(user);
347 	user->clist_synched = TRUE;
348 }
349 
350 static void
351 _sync_privacy_lists(NMUser *user)
352 {
353 	GSList *node = NULL, *rem_list = NULL;
354 	GaimConnection *gc;
355 	const char *name, *dn;
356 	NMUserRecord *user_record;
357 
358 	if (user == NULL)
359 		return;
360 
361 	gc = gaim_account_get_connection(user->client_data);
362 	if (gc == NULL)
363 		return;
364 
365 	/* Set the Gaim privacy setting */
366 	if (user->default_deny) {
367 		if (user->allow_list == NULL) {
368 			gc->account->perm_deny = GAIM_PRIVACY_DENY_ALL;
369 		} else {
370 			gc->account->perm_deny = GAIM_PRIVACY_ALLOW_USERS;
371 		}
372 	} else {
373 		if (user->deny_list == NULL) {
374 			gc->account->perm_deny = GAIM_PRIVACY_ALLOW_ALL;
375 		} else {
376 			gc->account->perm_deny = GAIM_PRIVACY_DENY_USERS;
377 		}
378 	}
379 
380 	/* Add stuff */
381 	for (node = user->allow_list; node; node = node->next) {
382 		user_record = nm_find_user_record(user, (char *)node->data);
383 		if (user_record)
384 			name = nm_user_record_get_display_id(user_record);
385 		else
386 			name =(char *)node->data;
387 
388 		if (!g_slist_find_custom(gc->account->permit,
389 								 name, (GCompareFunc)nm_utf8_strcasecmp)) {
390 			gaim_privacy_permit_add(gc->account, name , TRUE);
391 		}
392 	}
393 
394 	for (node = user->deny_list; node; node = node->next) {
395 		user_record = nm_find_user_record(user, (char *)node->data);
396 		if (user_record)
397 			name = nm_user_record_get_display_id(user_record);
398 		else
399 			name =(char *)node->data;
400 
401 		if (!g_slist_find_custom(gc->account->deny,
402 								 name, (GCompareFunc)nm_utf8_strcasecmp)) {
403 			gaim_privacy_deny_add(gc->account, name, TRUE);
404 		}
405 	}
406 
407 
408 	/*  Remove stuff */
409 	for (node = gc->account->permit; node; node = node->next) {
410 		dn = nm_lookup_dn(user, (char *)node->data);
411 		if (dn != NULL &&
412 			!g_slist_find_custom(user->allow_list,
413 								 dn, (GCompareFunc)nm_utf8_strcasecmp)) {
414 			rem_list = g_slist_append(rem_list, node->data);
415 		}
416 	}
417 
418 	if (rem_list) {
419 		for (node = rem_list; node; node = node->next) {
420 			gaim_privacy_permit_remove(gc->account, (char *)node->data, TRUE);
421 		}
422 		g_free(rem_list);
423 		rem_list = NULL;
424 	}
425 
426 	for (node = gc->account->deny; node; node = node->next) {
427 		dn = nm_lookup_dn(user, (char *)node->data);
428 		if (dn != NULL &&
429 			!g_slist_find_custom(user->deny_list,
430 								 dn, (GCompareFunc)nm_utf8_strcasecmp)) {
431 			rem_list = g_slist_append(rem_list, node->data);
432 		}
433 	}
434 
435 	if (rem_list) {
436 		for (node = rem_list; node; node = node->next) {
437 			gaim_privacy_deny_remove(gc->account, (char *)node->data, TRUE);
438 		}
439 		g_slist_free(rem_list);
440 	}
441 }
442 
443  /* Map known property tags to user-friendly strings */
444 static const char *
445 _map_property_tag(const char *tag)
446 {
447 	if (tag == NULL) return NULL;
448 
449 	if (strcmp(tag, "telephoneNumber") == 0)
450 		return _("Telephone Number");
451 	else if (strcmp(tag, "L") == 0)
452 		return _("Location");
453 	else if (strcmp(tag, "OU") == 0)
454 		return _("Department");
455 	else if (strcmp(tag, "personalTitle") == 0)
456 		return _("Personal Title");
457 	else if (strcmp(tag, "Title") == 0)
458 		return _("Title");
459 	else if (strcmp(tag, "mailstop") == 0)
460 		return _("Mailstop");
461 	else if (strcmp(tag, "Internet EMail Address") == 0)
462 		return _("Email Address");
463 	else
464 		return tag;
465 }
466 
467 /* Display a dialog box showing the properties for the given user record */
468 static void
469 _show_info(GaimConnection * gc, NMUserRecord * user_record)
470 {
471 	GString *info_text;
472 	int count, i;
473 	NMProperty *property;
474 	const char *tag, *value;
475 
476 	info_text = g_string_new("");
477 
478 	tag = _("User ID");
479 	value = nm_user_record_get_userid(user_record);
480 	if (value) {
481 		g_string_append_printf(info_text, "<b>%s:</b> %s<br>", tag, value);
482 	}
483 
484 /*	tag = _("DN");
485 	value = nm_user_record_get_dn(user_record);
486 	if (value) {
487 	g_string_append_printf(info_text, "<b>%s:</b> %s<br>",
488 	tag, value);
489 	}
490 */
491 
492 	tag = _("Full name");
493 	value = nm_user_record_get_full_name(user_record);
494 	if (value) {
495 		g_string_append_printf(info_text, "<b>%s:</b> %s<br>", tag, value);
496 	}
497 
498 	count = nm_user_record_get_property_count(user_record);
499 	for (i = 0; i < count; i++) {
500 		property = nm_user_record_get_property(user_record, i);
501 		if (property) {
502 			tag = _map_property_tag(nm_property_get_tag(property));
503 			value = nm_property_get_value(property);
504 			if (tag && value) {
505 				g_string_append_printf(info_text, "<b>%s:</b> %s<br>",
506 									   tag, value);
507 			}
508 			nm_release_property(property);
509 		}
510 	}
511 
512 	gaim_notify_userinfo(gc, nm_user_record_get_userid(user_record), NULL,
513 						 _("User Properties"), NULL, info_text->str,
514 						 NULL, NULL);
515 
516 	g_string_free(info_text, TRUE);
517 }
518 
519 /* Send a join conference, the first item in the parms list is the
520  * NMUser object and the second item is the conference to join.
521  * This callback is passed to gaim_request_action when we ask the
522  * user if they want to join the conference.
523  */
524 static void
525 _join_conference_cb(GSList * parms)
526 {
527 	NMUser *user;
528 	NMConference *conference;
529 	NMERR_T rc = NM_OK;
530 
531 	if (parms == NULL || g_slist_length(parms) != 2)
532 		return;
533 
534 	user = g_slist_nth_data(parms, 0);
535 	conference = g_slist_nth_data(parms, 1);
536 
537 	if (user && conference) {
538 		rc = nm_send_join_conference(user, conference,
539 									 _join_conf_resp_cb, conference);
540 		_check_for_disconnect(user, rc);
541 	}
542 
543 	g_slist_free(parms);
544 }
545 
546 /* Send a reject conference, the first item in the parms list is the
547  * NMUser object and the second item is the conference to reject.
548  * This callback is passed to gaim_request_action when we ask the
549  * user if they want to joing the conference.
550  */
551 static void
552 _reject_conference_cb(GSList * parms)
553 {
554 	NMUser *user;
555 	NMConference *conference;
556 	NMERR_T rc = NM_OK;
557 
558 	if (parms == NULL || g_slist_length(parms) != 2)
559 		return;
560 
561 	user = g_slist_nth_data(parms, 0);
562 	conference = g_slist_nth_data(parms, 1);
563 
564 	if (user && conference) {
565 		rc = nm_send_reject_conference(user, conference, NULL, NULL);
566 		_check_for_disconnect(user, rc);
567 	}
568 
569 	g_slist_free(parms);
570 }
571 
572 static void
573 _initiate_conference_cb(GaimBlistNode *node, gpointer ignored)
574 {
575 	GaimBuddy *buddy;
576 	GaimConnection *gc;
577 
578 	NMUser *user;
579 	const char *conf_name;
580 	GaimConversation *chat = NULL;
581 	NMUserRecord *user_record;
582 	NMConference *conference;
583 
584 	g_return_if_fail(GAIM_BLIST_NODE_IS_BUDDY(node));
585 
586 	buddy = (GaimBuddy *) node;
587 	gc = gaim_account_get_connection(buddy->account);
588 
589 	user = gc->proto_data;
590 	if (user == NULL)
591 		return;
592 
593 	/* We should already have a userrecord for the buddy */
594 	user_record = nm_find_user_record(user, buddy->name);
595 	if (user_record == NULL)
596 		return;
597 
598 	conf_name = _get_conference_name(++user->conference_count);
599 	chat = serv_got_joined_chat(gc, user->conference_count, conf_name);
600 	if (chat) {
601 
602 		conference = nm_create_conference(NULL);
603 		nm_conference_set_data(conference, (gpointer) chat);
604 		nm_send_create_conference(user, conference, _createconf_resp_send_invite, user_record);
605 		nm_release_conference(conference);
606 	}
607 }
608 
609 const char *
610 _get_conference_name(int id)
611 {
612 	static char *name = NULL;
613 
614 	if (name)
615 		g_free(name);
616 
617 	name = g_strdup_printf(_("GroupWise Conference %d"), id);
618 
619 	return name;
620 }
621 
622 void
623 _show_privacy_locked_error(GaimConnection *gc, NMUser *user)
624 {
625 	char *err;
626 
627 	err = g_strdup_printf(_("Unable to change server side privacy settings (%s)."),
628 						  nm_error_to_string(NMERR_ADMIN_LOCKED));
629 	gaim_notify_error(gc, NULL, err, NULL);
630 	g_free(err);
631 }
632 
633 /*******************************************************************************
634  * Connect and recv callbacks
635  ******************************************************************************/
636 
637 static void
638 novell_ssl_connect_error(GaimSslConnection * gsc,
639 						 GaimSslErrorType error, gpointer data)
640 {
641 	gaim_connection_error((GaimConnection *)data,
642 						  _("Unable to make SSL connection to server."));
643 }
644 
645 static void
646 novell_ssl_recv_cb(gpointer data, GaimSslConnection * gsc,
647 				   GaimInputCondition condition)
648 {
649 	GaimConnection *gc = data;
650 	NMUser *user;
651 	NMERR_T rc;
652 
653 	if (gc == NULL)
654 		return;
655 
656 	user = gc->proto_data;
657 	if (user == NULL)
658 		return;
659 
660 	rc = nm_process_new_data(user);
661 	if (rc != NM_OK) {
662 
663 		if (_is_disconnect_error(rc)) {
664 
665 			gaim_connection_error(gc,
666 								  _("Error communicating with server."
667 									" Closing connection."));
668 		} else {
669 
670 			char *error;
671 
672 			error = g_strdup_printf(_("Error processing event or response (%s)."),
673 									nm_error_to_string (rc));
674 			gaim_notify_error(gc, NULL, error, NULL);
675 			g_free(error);
676 
677 		}
678 
679 	}
680 }
681 
682 static void
683 novell_ssl_connected_cb(gpointer data, GaimSslConnection * gsc,
684 						GaimInputCondition cond)
685 {
686 	GaimConnection *gc = data;
687 	NMUser *user;
688 	NMConn *conn;
689 	NMERR_T rc = 0;
690 	const char *pwd = NULL;
691 	const char *my_addr = NULL;
692 	char *ua = NULL;
693 
694 	if (gc == NULL || gsc == NULL)
695 		return;
696 
697 	user = gc->proto_data;
698 	if ((user == NULL) || (conn = user->conn) == NULL)
699 		return;
700 
701 	conn->ssl_conn = g_new0(NMSSLConn, 1);
702 	conn->ssl_conn->data = gsc;
703 	conn->ssl_conn->read = (nm_ssl_read_cb) gaim_ssl_read;
704 	conn->ssl_conn->write = (nm_ssl_write_cb) gaim_ssl_write;
705 
706 	gaim_connection_update_progress(gc, _("Authenticating..."),
707 									2, NOVELL_CONNECT_STEPS);
708 
709 	my_addr = gaim_network_get_my_ip(gsc->fd);
710 	pwd = gaim_account_get_password(user->client_data);
711 	ua = _user_agent_string();
712 
713 	rc = nm_send_login(user, pwd, my_addr, ua, _login_resp_cb, NULL);
714 	if (rc == NM_OK) {
715 		conn->connected = TRUE;
716 		gaim_ssl_input_add(gsc, novell_ssl_recv_cb, gc);
717 	} else {
718 		gaim_connection_error(gc, _("Unable to connect to server."));
719 	}
720 
721 	gaim_connection_update_progress(gc, _("Waiting for response..."),
722 									3, NOVELL_CONNECT_STEPS);
723 
724 	g_free(ua);
725 }
726 
727 /*******************************************************************************
728  * Event callback and event handlers
729  ******************************************************************************/
730 
731 static void
732 _evt_receive_message(NMUser * user, NMEvent * event)
733 {
734 	NMUserRecord *user_record = NULL;
735 	NMContact *contact = NULL;
736 	GaimConversation *gconv;
737 	NMConference *conference;
738 	GaimConvImFlags imflags;
739 	char *text = NULL;
740 
741 	text = g_markup_escape_text(nm_event_get_text(event), -1);
742 
743 	conference = nm_event_get_conference(event);
744 	if (conference) {
745 
746 		GaimConversation *chat = nm_conference_get_data(conference);
747 
748 		/* Is this a single person 'conversation' or a conference? */
749 		if (chat == NULL && nm_conference_get_participant_count(conference) == 1) {
750 
751 			user_record = nm_find_user_record(user, nm_event_get_source(event));
752 			if (user_record) {
753 
754 				imflags = 0;
755 				if (nm_event_get_type(event) == NMEVT_RECEIVE_AUTOREPLY)
756 					imflags |= GAIM_CONV_IM_AUTO_RESP;
757 
758 				serv_got_im(gaim_account_get_connection(user->client_data),
759 							nm_user_record_get_display_id(user_record),
760 							text, imflags,
761 							nm_event_get_gmt(event));
762 
763 				gconv =	gaim_find_conversation_with_account(
764 					nm_user_record_get_display_id(user_record),
765 					(GaimAccount *) user->client_data);
766 				if (gconv) {
767 
768 					contact = nm_find_contact(user, nm_event_get_source(event));
769 					if (contact) {
770 
771 						gaim_conversation_set_title(
772 							gconv, nm_contact_get_display_name(contact));
773 
774 
775 					} else {
776 
777 						const char *name =
778 							nm_user_record_get_full_name(user_record);
779 
780 						if (name == NULL)
781 							name = nm_user_record_get_userid(user_record);
782 
783 						gaim_conversation_set_title(gconv, name);
784 					}
785 
786 				}
787 
788 			} else {
789 				/* this should not happen, see the event code.
790 				 * the event code will get the contact details from
791 				 * the server if it does not have them before calling
792 				 * the event callback.
793 				 */
794 			}
795 
796 		} else if (chat) {
797 
798 			/* get the contact for send if we have one */
799 			NMContact *contact = nm_find_contact(user,
800 												 nm_event_get_source(event));
801 
802 			/* get the user record for the sender */
803 			user_record = nm_find_user_record(user, nm_event_get_source(event));
804 			if (user_record) {
805 				const char *name = nm_contact_get_display_name(contact);
806 
807 				if (name == NULL) {
808 					name = nm_user_record_get_full_name(user_record);
809 					if (name == NULL)
810 						name = nm_user_record_get_display_id(user_record);
811 				}
812 
813 				serv_got_chat_in(gaim_account_get_connection(user->client_data),
814 								 gaim_conv_chat_get_id(GAIM_CONV_CHAT(chat)),
815 								 name, 0, text, nm_event_get_gmt(event));
816 			}
817 		}
818 	}
819 
820 	g_free(text);
821 }
822 
823 static void
824 _evt_conference_left(NMUser * user, NMEvent * event)
825 {
826 	GaimConversation *chat;
827 	NMConference *conference;
828 
829 	conference = nm_event_get_conference(event);
830 	if (conference) {
831 		chat = nm_conference_get_data(conference);
832 		if (chat) {
833 			NMUserRecord *ur = nm_find_user_record(user,
834 												   nm_event_get_source(event));
835 
836 			if (ur)
837 				gaim_conv_chat_remove_user(GAIM_CONV_CHAT(chat),
838 										   nm_user_record_get_display_id(ur),
839 										   NULL);
840 		}
841 	}
842 }
843 
844 static void
845 _evt_conference_invite_notify(NMUser * user, NMEvent * event)
846 {
847 	GaimConversation *gconv;
848 	NMConference *conference;
849 	NMUserRecord *user_record = NULL;
850 	char *str = NULL;
851 
852 	user_record = nm_find_user_record(user, nm_event_get_source(event));
853 	conference = nm_event_get_conference(event);
854 	if (user_record && conference) {
855 		gconv = nm_conference_get_data(conference);
856 		str = g_strdup_printf(_("%s has been invited to this conversation."),
857 							  nm_user_record_get_display_id(user_record));
858 		gaim_conversation_write(gconv, NULL, str,
859 								GAIM_MESSAGE_SYSTEM, time(NULL));
860 		g_free(str);
861 	}
862 }
863 
864 static void
865 _evt_conference_invite(NMUser * user, NMEvent * event)
866 {
867 	NMUserRecord *ur;
868 	GSList *parms = NULL;
869 	const char *title = NULL;
870 	const char *secondary = NULL;
871 	const char *name = NULL;
872 	char *primary = NULL;
873 	time_t gmt;
874 
875 	ur = nm_find_user_record(user, nm_event_get_source(event));
876 	if (ur)
877 		name = nm_user_record_get_full_name(ur);
878 
879 	if (name == NULL)
880 		name = nm_event_get_source(event);
881 
882 	gmt = nm_event_get_gmt(event);
883 	title = _("Invitation to Conversation");
884 	primary = g_strdup_printf(_("Invitation from: %s\n\nSent: %s"),
885 							  name, asctime(localtime(&gmt)));
886 	secondary = _("Would you like to join the conversation?");
887 
888 	/* Set up parms list for the callbacks
889 	 * We need to send the NMUser object and
890 	 * the NMConference object to the callbacks
891 	 */
892 	parms = NULL;
893 	parms = g_slist_append(parms, user);
894 	parms = g_slist_append(parms, nm_event_get_conference(event));
895 
896 	/* Prompt the user */
897 	gaim_request_action(NULL, title, primary, secondary, 
898 						GAIM_DEFAULT_ACTION_NONE, parms, 2,
899 						_("Yes"), G_CALLBACK(_join_conference_cb),
900 						_("No"), G_CALLBACK(_reject_conference_cb));
901 
902 	g_free(primary);
903 }
904 
905 
906 static void
907 _evt_conference_joined(NMUser * user, NMEvent * event)
908 {
909 	GaimConversation *chat = NULL;
910 	GaimConnection *gc;
911 	NMConference *conference = NULL;
912 	NMUserRecord *ur = NULL;
913 	const char *name;
914 	const char *conf_name;
915 
916 	gc = gaim_account_get_connection(user->client_data);
917 	if (gc == NULL)
918 		return;
919 
920 	conference = nm_event_get_conference(event);
921 	if (conference) {
922 		chat = nm_conference_get_data(conference);
923 		if (nm_conference_get_participant_count(conference) == 2 && chat == NULL) {
924 			ur = nm_conference_get_participant(conference, 0);
925 			if (ur) {
926 				conf_name = _get_conference_name(++user->conference_count);
927 				chat =
928 					serv_got_joined_chat(gc, user->conference_count, conf_name);
929 				if (chat) {
930 
931 					nm_conference_set_data(conference, (gpointer) chat);
932 
933 					name = nm_user_record_get_display_id(ur);
934 					gaim_conv_chat_add_user(GAIM_CONV_CHAT(chat), name, NULL, 
935 											GAIM_CBFLAGS_NONE, TRUE);
936 
937 				}
938 			}
939 		}
940 
941 		if (chat != NULL) {
942 			ur = nm_find_user_record(user, nm_event_get_source(event));
943 			if (ur) {
944 				name = nm_user_record_get_display_id(ur);
945 				if (!gaim_conv_chat_find_user(GAIM_CONV_CHAT(chat), name)) {
946 					gaim_conv_chat_add_user(GAIM_CONV_CHAT(chat), name, NULL, 
947 											GAIM_CBFLAGS_NONE, TRUE);
948 				}
949 			}
950 		}
951 	}
952 }
953 
954 static void
955 _evt_status_change(NMUser * user, NMEvent * event)
956 {
957 	GaimBuddy *buddy = NULL;
958 	GSList *buddies;
959 	GSList *bnode;
960 	NMUserRecord *user_record;
961 	const char *display_id;
962 	int status;
963 
964 	user_record = nm_event_get_user_record(event);
965 	if (user_record) {
966 
967 		/* Retrieve new status */
968 		status = nm_user_record_get_status(user_record);
969 
970 		/* Update status for buddy in all folders */
971 		display_id = nm_user_record_get_display_id(user_record);
972 		buddies = gaim_find_buddies(user->client_data, display_id);
973 		for (bnode = buddies; bnode; bnode = bnode->next) {
974 			buddy = (GaimBuddy *) bnode->data;
975 			if (buddy) {
976 				_update_buddy_status(buddy, status, nm_event_get_gmt(event));
977 			}
978 		}
979 
980 		g_slist_free(buddies);
981 
982 	}
983 }
984 
985 static void
986 _evt_user_disconnect(NMUser * user, NMEvent * event)
987 {
988 	GaimConnection *gc;
989 
990 	gc = gaim_account_get_connection((GaimAccount *) user->client_data);
991 	if (gc)
992 		gaim_connection_error(gc, _("You have been logged out because you"
993 									" logged in at another workstation."));
994 }
995 
996 static void
997 _evt_user_typing(NMUser * user, NMEvent * event)
998 {
999 	GaimConnection *gc;
000 	NMUserRecord *user_record = NULL;
001 
002 	gc = gaim_account_get_connection((GaimAccount *) user->client_data);
003 	if (gc) {
004 		user_record = nm_find_user_record(user, nm_event_get_source(event));
005 		if (user_record) {
006 			serv_got_typing(gc, nm_user_record_get_display_id(user_record),
007 							30, GAIM_TYPING);
008 		}
009 	}
010 }
011 
012 static void
013 _evt_user_not_typing(NMUser * user, NMEvent * event)
014 {
015 	GaimConnection *gc;
016 	NMUserRecord *user_record;
017 
018 	gc = gaim_account_get_connection((GaimAccount *) user->client_data);
019 	if (gc) {
020 		user_record = nm_find_user_record(user, nm_event_get_source(event));
021 		if (user_record) {
022 			serv_got_typing_stopped(gc,
023 									nm_user_record_get_display_id(user_record));
024 		}
025 	}
026 }
027 
028 static void
029 _evt_undeliverable_status(NMUser * user, NMEvent * event)
030 {
031 	NMUserRecord *ur;
032 	GaimConversation *gconv;
033 	char *str;
034 
035 	ur = nm_find_user_record(user, nm_event_get_source(event));
036 	if (ur) {
037 		gconv =
038 			gaim_find_conversation_with_account(nm_user_record_get_display_id(ur),
039 												user->client_data);
040 		if (gconv) {
041 			const char *name = nm_user_record_get_full_name(ur);
042 
043 			if (name == NULL) {
044 				name = nm_user_record_get_display_id(ur);
045 			}
046 			str = g_strdup_printf(_("%s appears to be offline and did not receive"
047 									" the message that you just sent."), name);
048 			gaim_conversation_write(gconv, NULL, str,
049 									GAIM_MESSAGE_SYSTEM, time(NULL));
050 			g_free(str);
051 		}
052 	}
053 }
054 
055 static void
056 _event_callback(NMUser * user, NMEvent * event)
057 {
058 	if (user == NULL || event == NULL)
059 		return;
060 
061 	switch (nm_event_get_type(event)) {
062 		case NMEVT_STATUS_CHANGE:
063 			_evt_status_change(user, event);
064 			break;
065 		case NMEVT_RECEIVE_AUTOREPLY:
066 		case NMEVT_RECEIVE_MESSAGE:
067 			_evt_receive_message(user, event);
068 			break;
069 		case NMEVT_USER_DISCONNECT:
070 			_evt_user_disconnect(user, event);
071 			break;
072 		case NMEVT_USER_TYPING:
073 			_evt_user_typing(user, event);
074 			break;
075 		case NMEVT_USER_NOT_TYPING:
076 			_evt_user_not_typing(user, event);
077 			break;
078 		case NMEVT_SERVER_DISCONNECT:
079 			/* Nothing to do? */
080 			break;
081 		case NMEVT_INVALID_RECIPIENT:
082 			break;
083 		case NMEVT_UNDELIVERABLE_STATUS:
084 			_evt_undeliverable_status(user, event);
085 			break;
086 		case NMEVT_CONFERENCE_INVITE_NOTIFY:
087 			/* Someone else has been invited to join a
088 			 * conference that we are currently a part of
089 			 */
090 			_evt_conference_invite_notify(user, event);
091 			break;
092 		case NMEVT_CONFERENCE_INVITE:
093 			/* We have been invited to join a conference */
094 			_evt_conference_invite(user, event);
095 			break;
096 		case NMEVT_CONFERENCE_JOINED:
097 			/* Some one has joined a conference that we
098 			 * are a part of
099 			 */
100 			_evt_conference_joined(user, event);
101 			break;
102 		case NMEVT_CONFERENCE_LEFT:
103 			/* Someone else has left a conference that we
104 			 * are currently a part of
105 			 */
106 			_evt_conference_left(user, event);
107 			break;
108 		default:
109 			gaim_debug(GAIM_DEBUG_INFO, "novell",
110 					   "_event_callback(): unhandled event, %d\n",
111 					   nm_event_get_type(event));
112 			break;
113 	}
114 }
115 
116 /*******************************************************************************
117  * Prpl Ops
118  ******************************************************************************/
119 
120 static void
121 novell_login(GaimAccount * account)
122 {
123 	GaimConnection *gc;
124 	NMUser *user = NULL;
125 	const char *server;
126 	const char *name;
127 	int port;
128 
129 	if (account == NULL)
130 		return;
131 
132 	gc = gaim_account_get_connection(account);
133 	if (gc == NULL)
134 		return;
135 
136 	server = gaim_account_get_string(account, "server", NULL);
137 	if (server == NULL || *server == '\0') {
138 
139 		/* TODO: Would be nice to prompt if not set!
140 		 *  gaim_request_fields(gc, _("Server Address"),...);
141 		 */
142 
143 		/* ...but for now just error out with a nice message. */
144 		gaim_connection_error(gc, _("Unable to connect to server."
145 									" Please enter the address of the server"
146 									" you wish to connect to."));
147 		return;
148 	}
149 
150 	port = gaim_account_get_int(account, "port", DEFAULT_PORT);
151 	name = gaim_account_get_username(account);
152 
153 	user = nm_initialize_user(name, server, port, account, _event_callback);
154 	if (user) {
155 		/* save user */
156 		gc->proto_data = user;
157 
158 		/* connect to the server */
159 		gaim_connection_update_progress(gc, _("Connecting"),
160 										1, NOVELL_CONNECT_STEPS);
161 
162 		user->conn->use_ssl = TRUE;
163 		if (gaim_ssl_connect(user->client_data, user->conn->addr,
164 							 user->conn->port, novell_ssl_connected_cb,
165 							 novell_ssl_connect_error, gc) == NULL) {
166 			gaim_connection_error(gc, _("Error."
167 										" SSL support is not installed."));
168 		}
169 	}
170 }
171 
172 static void
173 novell_close(GaimConnection * gc)
174 {
175 	NMUser *user;
176 	NMConn *conn;
177 
178 	if (gc == NULL)
179 		return;
180 
181 	user = gc->proto_data;
182 	if (user) {
183 		conn = user->conn;
184 		if (conn && conn->ssl_conn) {
185 			gaim_ssl_close(user->conn->ssl_conn->data);
186 		}
187 		nm_deinitialize_user(user);
188 	}
189 	gc->proto_data = NULL;
190 }
191 
192 static int
193 novell_send_im(GaimConnection * gc, const char *name,
194 			   const char *message_body, GaimConvImFlags flags)
195 {
196 	NMUserRecord *user_record = NULL;
197 	NMConference *conf = NULL;
198 	NMMessage *message;
199 	NMUser *user;
200 	const char *dn = NULL;
201 	gboolean done = TRUE, created_conf = FALSE;
202 	NMERR_T rc = NM_OK;
203 
204 	if (gc == NULL || name == NULL ||
205 		message_body == NULL || *message_body == '\0')
206 		return 0;
207 
208 	user = gc->proto_data;
209 	if (user == NULL)
210 		return 0;
211 
212 	/* Create a new message */
213 	message = nm_create_message(message_body);
214 
215 	/* Need to get the DN for the buddy so we can look up the convo */
216 	dn = nm_lookup_dn(user, name);
217 
218 	/* Do we already know about the sender? */
219 	user_record = nm_find_user_record(user, dn);
220 	if (user_record) {
221 
222 		/* Do we already have an instantiated conference? */
223 		conf = nm_find_conversation(user, dn);
224 		if (conf == NULL) {
225 
226 			/* If not, create a blank conference */
227 			conf = nm_create_conference(NULL);
228 			created_conf = TRUE;
229 
230 			nm_conference_add_participant(conf, user_record);
231 		}
232 
233 		nm_message_set_conference(message, conf);
234 
235 		/* Make sure conference is instatiated */
236 		if (!nm_conference_is_instantiated(conf)) {
237 
238 			/* It is not, so send the createconf. We will
239 			 * have to finish sending the message when we
240 			 * get the response with the new conference guid.
241 			 */
242 			rc = nm_send_create_conference(user, conf, _createconf_resp_send_msg, message);
243 			_check_for_disconnect(user, rc);
244 
245 			done = FALSE;
246 		}
247 
248 	} else {
249 
250 		/* If we don't have details for the user, then we don't have
251 		 * a conference yet. So create one and send the getdetails
252 		 * to the server. We will have to finish sending the message
253 		 * when we get the response from the server.
254 		 */
255 		conf = nm_create_conference(NULL);
256 		created_conf = TRUE;
257 
258 		nm_message_set_conference(message, conf);
259 
260 		rc = nm_send_get_details(user, name, _get_details_resp_send_msg, message);
261 		_check_for_disconnect(user, rc);
262 
263 		done = FALSE;
264 	}
265 
266 	if (done) {
267 
268 		/* Did we find everything we needed? */
269 		rc = nm_send_message(user, message, _send_message_resp_cb);
270 		_check_for_disconnect(user, rc);
271 
272 		nm_release_message(message);
273 	}
274 
275 	if (created_conf && conf)
276 		nm_release_conference(conf);
277 
278 	return 1;
279 }
280 
281 static int
282 novell_send_typing(GaimConnection * gc, const char *name, int typing)
283 {
284 	NMConference *conf = NULL;
285 	NMUser *user;
286 	const char *dn = NULL;
287 	NMERR_T rc = NM_OK;
288 
289 	if (gc == NULL || name == NULL)
290 		return -1;
291 
292 	user = gc->proto_data;
293 	if (user == NULL)
294 		return -1;
295 
296 	/* Need to get the DN for the buddy so we can look up the convo */
297 	dn = nm_lookup_dn(user, name);
298 	if (dn) {
299 
300 		/* Now find the conference in our list */
301 		conf = nm_find_conversation(user, dn);
302 		if (conf) {
303 
304 			rc = nm_send_typing(user, conf,
305 								((typing == GAIM_TYPING) ? TRUE : FALSE), NULL);
306 			_check_for_disconnect(user, rc);
307 
308 		}
309 
310 	}
311 
312 	return 0;
313 }
314 
315 static void
316 novell_convo_closed(GaimConnection * gc, const char *who)
317 {
318 	NMUser *user;
319 	NMConference *conf;
320 	const char *dn;
321 	NMERR_T rc = NM_OK;
322 
323 	if (gc == NULL || who == NULL)
324 		return;
325 
326 	user = gc->proto_data;
327 	if (user && (dn = nm_lookup_dn(user, who))) {
328 		conf = nm_find_conversation(user, dn);
329 		if (conf) {
330 			rc = nm_send_leave_conference(user, conf, NULL, NULL);
331 			_check_for_disconnect(user, rc);
332 		}
333 	}
334 }
335 
336 static void
337 novell_chat_leave(GaimConnection * gc, int id)
338 {
339 	NMConference *conference;
340 	NMUser *user;
341 	GaimConversation *chat;
342 	GSList *cnode;
343 	NMERR_T rc = NM_OK;
344 
345 	if (gc == NULL)
346 		return;
347 
348 	user = gc->proto_data;
349 	if (user == NULL)
350 		return;
351 
352 	for (cnode = user->conferences; cnode != NULL; cnode = cnode->next) {
353 		conference = cnode->data;
354 		if (conference && (chat = nm_conference_get_data(conference))) {
355 			if (gaim_conv_chat_get_id(GAIM_CONV_CHAT(chat)) == id) {
356 				rc = nm_send_leave_conference(user, conference, NULL, NULL);
357 				_check_for_disconnect(user, rc);
358 				break;
359 			}
360 		}
361 	}
362 
363 	serv_got_chat_left(gc, id);
364 }
365 
366 void
367 novell_chat_invite(GaimConnection *gc, int id,
368 				   const char *message, const char *who)
369 {
370 	NMConference *conference;
371 	NMUser *user;
372 	GaimConversation *chat;
373 	GSList *cnode;
374 	NMERR_T rc = NM_OK;
375 	NMUserRecord *user_record = NULL;
376 
377 	if (gc == NULL)
378 		return;
379 
380 	user = gc->proto_data;
381 	if (user == NULL)
382 		return;
383 
384 	user_record = nm_find_user_record(user, who);
385 	if (user_record == NULL) {
386 		rc = nm_send_get_details(user, who, _get_details_resp_send_invite, GINT_TO_POINTER(id));
387 		_check_for_disconnect(user, rc);
388 		return;
389 	}
390 
391 	for (cnode = user->conferences; cnode != NULL; cnode = cnode->next) {
392 		conference = cnode->data;
393 		if (conference && (chat = nm_conference_get_data(conference))) {
394 			if (gaim_conv_chat_get_id(GAIM_CONV_CHAT(chat)) == id) {
395 				rc = nm_send_conference_invite(user, conference, user_record,
396 											   message, _sendinvite_resp_cb, NULL);
397 				_check_for_disconnect(user, rc);
398 				break;
399 			}
400 		}
401 	}
402 }
403 
404 static int
405 novell_chat_send(GaimConnection * gc, int id, const char *text)
406 {
407 	NMConference *conference;
408 	GaimConversation *chat;
409 	GSList *cnode;
410 	NMMessage *message;
411 	NMUser *user;
412 	NMERR_T rc = NM_OK;
413 	const char *name;
414 	char *str;
415 
416 	if (gc == NULL || text == NULL)
417 		return -1;
418 
419 	user = gc->proto_data;
420 	if (user == NULL)
421 		return -1;
422 
423 	message = nm_create_message(text);
424 
425 	for (cnode = user->conferences; cnode != NULL; cnode = cnode->next) {
426 		conference = cnode->data;
427 		if (conference && (chat = nm_conference_get_data(conference))) {
428 			if (gaim_conv_chat_get_id(GAIM_CONV_CHAT(chat)) == id) {
429 
430 				nm_message_set_conference(message, conference);
431 
432 				/* check to see if the conference is instatiated yet */
433 				if (!nm_conference_is_instantiated(conference)) {
434 					nm_message_add_ref(message);
435 					nm_send_create_conference(user, conference, _createconf_resp_send_msg, message);
436 				} else {
437 					rc = nm_send_message(user, message, _send_message_resp_cb);
438 				}
439 
440 				nm_release_message(message);
441 
442 				if (!_check_for_disconnect(user, rc)) {
443 
444 					/* Use the account alias if it is set */
445 					name = gaim_account_get_alias(user->client_data);
446 					if (name == NULL || *name == '\0') {
447 
448 						/* If there is no account alias, try full name */
449 						name = nm_user_record_get_full_name(user->user_record);
450 						if (name == NULL || *name == '\0') {
451 
452 							/* Fall back to the username that we are signed in with */
453 							name = gaim_account_get_username(user->client_data);
454 						}
455 					}
456 
457 					serv_got_chat_in(gc, id, name, 0, text, time(NULL));
458 					return 0;
459 				} else
460 					return -1;
461 
462 			}
463 		}
464 	}
465 
466 
467 	/* The conference was not found, must be closed */
468 	chat = gaim_find_chat(gc, id);
469 	if (chat) {
470 		str = g_strdup_printf(_("This conference has been closed."
471 								" No more messages can be sent."));
472 		gaim_conversation_write(chat, NULL, str, GAIM_MESSAGE_SYSTEM, time(NULL));
473 		g_free(str);
474 	}
475 
476 	if (message)
477 		nm_release_message(message);
478 
479 	return -1;
480 }
481 
482 static void
483 novell_add_buddy(GaimConnection * gc, GaimBuddy *buddy, GaimGroup * group)
484 {
485 	NMFolder *folder = NULL;
486 	NMContact *contact;
487 	NMUser *user;
488 	NMERR_T rc = NM_OK;
489 	const char *alias, *gname;
490 
491 	if (gc == NULL || buddy == NULL || group == NULL)
492 		return;
493 
494 	user = (NMUser *) gc->proto_data;
495 	if (user == NULL)
496 		return;
497 
498 	/* If we haven't synched the contact list yet, ignore
499 	 * the add_buddy calls. Server side list is the master.
500 	 */
501 	if (!user->clist_synched)
502 		return;
503 
504 	contact = nm_create_contact();
505 	nm_contact_set_dn(contact, buddy->name);
506 
507 	/* Remove the GaimBuddy (we will add it back after adding it
508 	 * to the server side list). Save the alias if there is one.
509 	 */
510 	alias = gaim_buddy_get_alias(buddy);
511 	if (alias && strcmp(alias, buddy->name))
512 		nm_contact_set_display_name(contact, alias);
513 
514 	gaim_blist_remove_buddy(buddy);
515 	buddy = NULL;
516 
517 	if (strcmp(group->name, NM_ROOT_FOLDER_NAME) == 0) {
518 		gname = "";
519 	} else {
520 		gname = group->name;
521 	}
522 
523 	folder = nm_find_folder(user, gname);
524 	if (folder) {
525 
526 		/* We have everything that we need, so send the createcontact */
527 		rc = nm_send_create_contact(user, folder, contact,
528 									_create_contact_resp_cb, contact);
529 
530 	} else {
531 
532 		/* Need to create the folder before we can add the contact */
533 		rc = nm_send_create_folder(user, gname,
534 								   _create_folder_resp_add_contact, contact);
535 	}
536 
537 	_check_for_disconnect(user, rc);
538 
539 }
540 
541 static void
542 novell_remove_buddy(GaimConnection *gc, GaimBuddy *buddy, GaimGroup *group)
543 {
544 	NMContact *contact;
545 	NMFolder *folder;
546 	NMUser *user;
547 	const char *dn, *gname;
548 	NMERR_T rc = NM_OK;
549 
550 	if (gc == NULL || buddy == NULL || group == NULL)
551 		return;
552 
553 	user = (NMUser *) gc->proto_data;
554 	if (user && (dn = nm_lookup_dn(user, buddy->name))) {
555 		if (strcmp(group->name, NM_ROOT_FOLDER_NAME) == 0) {
556 			gname = "";
557 		} else {
558 			gname = group->name;
559 		}
560 		folder = nm_find_folder(user, gname);
561 		if (folder) {
562 			contact = nm_folder_find_contact(folder, dn);
563 			if (contact) {
564 
565 				/* Remove the buddy from the contact */
566 				nm_contact_set_data(contact, NULL);
567 
568 				/* Tell the server to remove the contact */
569 				rc = nm_send_remove_contact(user, folder, contact,
570 											_remove_contact_resp_cb, NULL);
571 				_check_for_disconnect(user, rc);
572 			}
573 		}
574 	}
575 }
576 
577 static void
578 novell_remove_group(GaimConnection * gc, GaimGroup *group)
579 {
580 	NMUser *user;
581 	NMERR_T rc = NM_OK;
582 
583 	if (gc == NULL || group == NULL)
584 		return;
585 
586 	user = (NMUser *) gc->proto_data;
587 	if (user) {
588 		NMFolder *folder = nm_find_folder(user, group->name);
589 
590 		if (folder) {
591 			rc = nm_send_remove_folder(user, folder,
592 									   _remove_folder_resp_cb, NULL);
593 			_check_for_disconnect(user, rc);
594 		}
595 	}
596 }
597 
598 static void
599 novell_alias_buddy(GaimConnection * gc, const char *name, const char *alias)
600 {
601 	NMContact *contact;
602 	NMUser *user;
603 	GList *contacts = NULL;
604 	GList *cnode = NULL;
605 	const char *dn = NULL, *fname = NULL;
606 	NMERR_T rc = NM_OK;
607 
608 	if (gc == NULL || name == NULL || alias == NULL)
609 		return;
610 
611 	user = (NMUser *) gc->proto_data;
612 	if (user && (dn = nm_lookup_dn(user, name))) {
613 
614 		/* Alias all of instances of the contact */
615 		contacts = nm_find_contacts(user, dn);
616 		for (cnode = contacts; cnode != NULL; cnode = cnode->next) {
617 			contact = (NMContact *) cnode->data;
618 			if (contact) {
619 				GaimGroup *group = NULL;
620 				GaimBuddy *buddy;
621 				NMFolder *folder;
622 
623 				/* Alias the Gaim buddy? */
624 				folder = nm_find_folder_by_id(user,
625 											  nm_contact_get_parent_id(contact));
626 				if (folder) {
627 					fname = nm_folder_get_name(folder);
628 					if (*fname == '\0') {
629 						fname = NM_ROOT_FOLDER_NAME;
630 					}
631 					group = gaim_find_group(fname);
632 				}
633 
634 				if (group) {
635 					buddy = gaim_find_buddy_in_group(user->client_data,
636 													 name, group);
637 					if (buddy && strcmp(buddy->alias, alias))
638 						gaim_blist_alias_buddy(buddy, alias);
639 				}
640 
641 				/* Tell the server to alias the contact */
642 				rc = nm_send_rename_contact(user, contact, alias,
643 											_rename_contact_resp_cb, NULL);
644 				_check_for_disconnect(user, rc);
645 			}
646 		}
647 		if (contacts)
648 			g_list_free(contacts);
649 	}
650 }
651 
652 static void
653 novell_group_buddy(GaimConnection * gc,
654 				   const char *name, const char *old_group_name,
655 				   const char *new_group_name)
656 {
657 	NMFolder *old_folder;
658 	NMFolder *new_folder;
659 	NMContact *contact;
660 	NMUser *user;
661 	const char *dn;
662 	NMERR_T rc = NM_OK;
663 
664 	if (gc == NULL || name == NULL ||
665 		old_group_name == NULL || new_group_name == NULL)
666 		return;
667 
668 	user = (NMUser *) gc->proto_data;
669 	if (user && (dn = nm_lookup_dn(user, name))) {
670 
671 		/* Find the old folder */
672 		if (strcmp(old_group_name, NM_ROOT_FOLDER_NAME) == 0) {
673 			old_folder = nm_get_root_folder(user);
674 			if (nm_folder_find_contact(old_folder, dn) == NULL)
675 				old_folder = nm_find_folder(user, old_group_name);
676 		} else {
677 			old_folder = nm_find_folder(user, old_group_name);
678 		}
679 
680 		if (old_folder && (contact = nm_folder_find_contact(old_folder, dn))) {
681 
682 			/* Find the new folder */
683 			new_folder = nm_find_folder(user, new_group_name);
684 			if (new_folder == NULL) {
685 				if (strcmp(new_group_name, NM_ROOT_FOLDER_NAME) == 0)
686 					new_folder = nm_get_root_folder(user);
687 			}
688 
689 			if (new_folder) {
690 
691 				/* Tell the server to move the contact to the new folder */
692 				rc = nm_send_move_contact(user, contact, new_folder,
693 										  _move_contact_resp_cb, NULL);
694 
695 			} else {
696 
697 				nm_contact_add_ref(contact);
698 
699 				/* Remove the old contact first */
700 				nm_send_remove_contact(user, old_folder, contact,
701 									   _remove_contact_resp_cb, NULL);
702 
703 				/* New folder does not exist yet, so create it  */
704 				rc = nm_send_create_folder(user, new_group_name,
705 										   _create_folder_resp_move_contact,
706 										   contact);
707 			}
708 
709 			_check_for_disconnect(user, rc);
710 		}
711 	}
712 }
713 
714 static void
715 novell_rename_group(GaimConnection * gc, const char *old_name,
716 					GaimGroup *group, GList *moved_buddies)
717 {
718 	NMERR_T rc = NM_OK;
719 	NMFolder *folder;
720 	NMUser *user;
721 
722 	if (gc == NULL || old_name == NULL || group == NULL || moved_buddies == NULL) {
723 		return;
724 	}
725 
726 	user = gc->proto_data;
727 	if (user) {
728 		/* Does new folder exist already? */
729 		if (nm_find_folder(user, group->name)) {
730 			/* gaim_blist_rename_group() adds the buddies
731 			 * to the new group and removes the old group...
732 			 * so there is nothing more to do here.
733 			 */
734 			return;
735 		}
736 
737 		if (strcmp(old_name, NM_ROOT_FOLDER_NAME) == 0) {
738 			/* Can't rename the root folder ... need to revisit this */
739 			return;
740 		}
741 
742 		folder = nm_find_folder(user, old_name);
743 		if (folder) {
744 			rc = nm_send_rename_folder(user, folder, group->name,
745 									   _rename_folder_resp_cb, NULL);
746 			_check_for_disconnect(user, rc);
747 		}
748 	}
749 }
750 
751 static void
752 novell_list_emblems(GaimBuddy * buddy, const char **se, const char **sw, const char **nw, const char **ne)
753 {
754 	int status = buddy->uc >> 1;
755 
756 	switch (status) {
757 		case NM_STATUS_AVAILABLE:
758 			*se = "";
759 			break;
760 		case NM_STATUS_AWAY:
761 			*se = "away";
762 			break;
763 		case NM_STATUS_BUSY:
764 			*se = "occupied";
765 			break;
766 		case NM_STATUS_UNKNOWN:
767 			*se = "error";
768 			break;
769 	}
770 }
771 
772 static const char *
773 novell_list_icon(GaimAccount * account, GaimBuddy * buddy)
774 {
775 	return "novell";
776 }
777 
778 static char *
779 novell_tooltip_text(GaimBuddy * buddy)
780 {
781 	NMUserRecord *user_record = NULL;
782 	GaimConnection *gc;
783 	NMUser *user;
784 	int status = 0;
785 	char *ret_text = NULL;
786 	const char *status_str = NULL;
787 	const char *text = NULL;
788 
789 	if (buddy == NULL)
790 		return "";
791 
792 	gc = gaim_account_get_connection(buddy->account);
793 	if (gc == NULL || (user = gc->proto_data) == NULL)
794 		return "";
795 
796 	if (GAIM_BUDDY_IS_ONLINE(buddy)) {
797 		user_record = nm_find_user_record(user, buddy->name);
798 		if (user_record) {
799 			status = nm_user_record_get_status(user_record);
800 			text = nm_user_record_get_status_text(user_record);
801 			/* No custom text, so default it ... */
802 			switch (status) {
803 				case NM_STATUS_AVAILABLE:
804 					status_str = _("Available");
805 					break;
806 				case NM_STATUS_AWAY:
807 					status_str = _("Away");
808 					break;
809 				case NM_STATUS_BUSY:
810 					status_str = _("Busy");
811 					break;
812 				case NM_STATUS_AWAY_IDLE:
813 					status_str = _("Idle");
814 					break;
815 				case NM_STATUS_OFFLINE:
816 					status_str = _("Offline");
817 					break;
818 				default:
819 					status_str = _("Unknown");
820 					break;
821 			}
822 
823 			if (text)
824 				ret_text = g_strdup_printf("\n<b>%s:</b> %s"
825 										   "\n<b>%s:</b> %s",
826 										   _("Status"), status_str,
827 										   _("Message"), text);
828 			else
829 				ret_text = g_strdup_printf("\n<b>%s:</b> %s",
830 										   _("Status"), status_str);
831 		}
832 	}
833 
834 	return ret_text;
835 }
836 
837 static void
838 novell_set_idle(GaimConnection * gc, int time)
839 {
840 	NMUser *user;
841 	NMERR_T rc = NM_OK;
842 
843 	if (gc == NULL)
844 		return;
845 
846 	user = gc->proto_data;
847 	if (user == NULL)
848 		return;
849 
850 	if (time > 0)
851 		rc = nm_send_set_status(user, NM_STATUS_AWAY_IDLE, NULL, NULL, NULL,
852 								NULL);
853 	else
854 		rc = nm_send_set_status(user, NM_STATUS_AVAILABLE, NULL, NULL, NULL,
855 								NULL);
856 
857 	_check_for_disconnect(user, rc);
858 }
859 
860 static void
861 novell_get_info(GaimConnection * gc, const char *name)
862 {
863 	NMUserRecord *user_record;
864 	NMUser *user;
865 	NMERR_T rc;
866 
867 	if (gc == NULL || name == NULL)
868 		return;
869 
870 	user = (NMUser *) gc->proto_data;
871 	if (user) {
872 
873 		user_record = nm_find_user_record(user, name);
874 		if (user_record) {
875 
876 			_show_info(gc, user_record);
877 
878 		} else {
879 
880 			rc = nm_send_get_details(user, name,
881 									 _get_details_resp_show_info, g_strdup(name));
882 
883 			_check_for_disconnect(user, rc);
884 
885 		}
886 
887 	}
888 }
889 
890 static char *
891 novell_status_text(GaimBuddy * buddy)
892 {
893 	const char *text = NULL;
894 	const char *dn = NULL;
895 
896 	if (buddy && buddy->account) {
897 		GaimConnection *gc = gaim_account_get_connection(buddy->account);
898 
899 		if (gc && gc->proto_data) {
900 			NMUser *user = gc->proto_data;
901 
902 			dn = nm_lookup_dn(user, buddy->name);
903 			if (dn) {
904 				NMUserRecord *user_record = nm_find_user_record(user, dn);
905 
906 				if (user_record) {
907 					text = nm_user_record_get_status_text(user_record);
908 					if (text)
909 						return g_strdup(text);
910 				}
911 			}
912 		}
913 	}
914 
915 	return NULL;
916 }
917 #if 0
918 static GList *
919 novell_away_states(GaimConnection * gc)
920 {
921 	GList *m = NULL;
922 
923 	m = g_list_append(m, _("Available"));
924 	m = g_list_append(m, _("Away"));
925 	m = g_list_append(m, _("Busy"));
926 	m = g_list_append(m, _("Appear Offline"));
927 	m = g_list_append(m, GAIM_AWAY_CUSTOM);
928 
929 	return m;
930 }
931 
932 static void
933 novell_set_away(GaimConnection * gc, const char *state, const char *msg)
934 {
935 	NMUser *user;
936 	NMSTATUS_T status = NM_STATUS_AVAILABLE;
937 	NMERR_T rc = NM_OK;
938 	char *text = NULL;
939 	char *tmp = NULL;
940 	char *p = NULL;
941 
942 	if (gc == NULL)
943 		return;
944 
945 	user = gc->proto_data;
946 	if (user == NULL)
947 		return;
948 
949 	if (gc->away) {
950 		g_free(gc->away);
951 		gc->away = NULL;
952 	}
953 
954 	if (msg != NULL) {
955 		status = NM_STATUS_AWAY;
956 		gc->away = g_strdup("");
957 
958 		/* Don't want newlines in status text */
959 		tmp = g_strdup(msg);
960 		if ((p = strchr(tmp, '\n'))) {
961 			*p = '\0';
962 		}
963 
964 		/* Truncate the status text if necessary */
965 		text = g_strdup(tmp);
966 		if (g_utf8_strlen(tmp, -1) > 60) {
967 			g_utf8_strncpy(text, tmp, 60);
968 			strcat(text, "...");
969 		}
970 
971 		g_free(tmp);
972 
973 	} else if (state) {
974 		if (!strcmp(state, _("Available"))) {
975 			status = NM_STATUS_AVAILABLE;
976 		} else if (!strcmp(state, _("Away"))) {
977 			status = NM_STATUS_AWAY;
978 			gc->away = g_strdup("");
979 		} else if (!strcmp(state, _("Busy"))) {
980 			status = NM_STATUS_BUSY;
981 			gc->away = g_strdup("");
982 		} else if (!strcmp(state, _("Appear Offline"))) {
983 			status = NM_STATUS_OFFLINE;
984 			gc->away = g_strdup("");
985 		} else {
986 			status = NM_STATUS_AVAILABLE;
987 			g_free(gc->away);
988 			gc->away = NULL;
989 		}
990 	} else if (gc->is_idle) {
991 		status = NM_STATUS_AWAY_IDLE;
992 	} else {
993 		status = NM_STATUS_AVAILABLE;
994 	}
995 
996 	rc = nm_send_set_status(user, status, text, msg, NULL, NULL);
997 	_check_for_disconnect(user, rc);
998 
999 	if (text)
000 		g_free(text);
001 }
002 #endif
003 static void
004 novell_add_permit(GaimConnection *gc, const char *who)
005 {
006 	NMUser *user;
007 	NMERR_T rc = NM_OK;
008 	const char *name = who;
009 
010 	if (gc == NULL || who == NULL)
011 		return;
012 
013 	user = gc->proto_data;
014 	if (user == NULL)
015 		return;
016 
017 	/* Remove first -- we will add it back in when we get
018 	 * the okay from the server
019 	 */
020 	gaim_privacy_permit_remove(gc->account, who, TRUE);
021 
022 	if (nm_user_is_privacy_locked(user)) {
023 		_show_privacy_locked_error(gc, user);
024 		_sync_privacy_lists(user);
025 		return;
026 	}
027 
028 	/* Work around for problem with un-typed, dotted contexts */
029 	if (strchr(who, '.')) {
030 		const char *dn = nm_lookup_dn(user, who);
031 		if (dn == NULL) {
032 			rc = nm_send_get_details(user, who, _get_details_send_privacy_create,
033 									 (gpointer)TRUE);
034 			_check_for_disconnect(user, rc);
035 			return;
036 		} else {
037 			name = dn;
038 		}
039 	}
040 
041 	rc = nm_send_create_privacy_item(user, name, TRUE,
042 									 _create_privacy_item_permit_resp_cb,
043 									 g_strdup(who));
044 	_check_for_disconnect(user, rc);
045 }
046 
047 static void
048 novell_add_deny(GaimConnection *gc, const char *who)
049 {
050 	NMUser *user;
051 	NMERR_T rc = NM_OK;
052 	const char *name = who;
053 
054 	if (gc == NULL || who == NULL)
055 		return;
056 
057 	user = gc->proto_data;
058 	if (user == NULL)
059 		return;
060 
061 	/* Remove first -- we will add it back in when we get
062 	 * the okay from the server
063 	 */
064 	gaim_privacy_deny_remove(gc->account, who, TRUE);
065 
066 	if (nm_user_is_privacy_locked(user)) {
067 		_show_privacy_locked_error(gc, user);
068 		_sync_privacy_lists(user);
069 		return;
070 	}
071 
072 	/* Work around for problem with un-typed, dotted contexts */
073 	if (strchr(who, '.')) {
074 		const char *dn = nm_lookup_dn(user, who);
075 		if (dn == NULL) {
076 			rc = nm_send_get_details(user, who, _get_details_send_privacy_create,
077 									 (gpointer)FALSE);
078 			_check_for_disconnect(user, rc);
079 			return;
080 		} else {
081 			name = dn;
082 		}
083 	}
084 
085 	rc = nm_send_create_privacy_item(user, name, FALSE,
086 									 _create_privacy_item_deny_resp_cb,
087 									 g_strdup(who));
088 	_check_for_disconnect(user, rc);
089 }
090 
091 static void
092 novell_rem_permit(GaimConnection *gc, const char *who)
093 {
094 	NMUser *user;
095 	NMERR_T rc = NM_OK;
096 	const char *dn = NULL;
097 
098 	if (gc == NULL || who == NULL)
099 		return;
100 
101 	user = gc->proto_data;
102 	if (user == NULL)
103 		return;
104 
105 	if (nm_user_is_privacy_locked(user)) {
106 		_show_privacy_locked_error(gc, user);
107 		_sync_privacy_lists(user);
108 		return;
109 	}
110 
111 	dn = nm_lookup_dn(user, who);
112 	if (dn == NULL)
113 		dn = who;
114 
115 	rc = nm_send_remove_privacy_item(user, dn, TRUE,
116 									 _remove_privacy_item_resp_cb,
117 									 g_strdup(who));
118 	_check_for_disconnect(user, rc);
119 }
120 
121 static void
122 novell_rem_deny(GaimConnection *gc, const char *who)
123 {
124 	NMUser *user;
125 	NMERR_T rc = NM_OK;
126 	const char *dn = NULL;
127 
128 	if (gc == NULL || who == NULL)
129 		return;
130 
131 	user = gc->proto_data;
132 	if (user == NULL)
133 		return;
134 
135 	if (nm_user_is_privacy_locked(user)) {
136 		_show_privacy_locked_error(gc, user);
137 		_sync_privacy_lists(user);
138 		return;
139 	}
140 
141 	dn = nm_lookup_dn(user, who);
142 	if (dn == NULL)
143 		dn = who;
144 
145 	rc = nm_send_remove_privacy_item(user, dn, FALSE,
146 									 _remove_privacy_item_resp_cb,
147 									 g_strdup(who));
148 	_check_for_disconnect(user, rc);
149 }
150 
151 static void
152 novell_set_permit_deny(GaimConnection *gc)
153 {
154 	NMERR_T rc = NM_OK;
155 	const char *dn, *name = NULL;
156 	NMUserRecord *user_record = NULL;
157 	GSList *node = NULL, *copy = NULL;
158 	NMUser *user;
159 	int i, j, num_contacts, num_folders;
160 	NMContact *contact;
161 	NMFolder *folder = NULL;
162 
163 	if (gc == NULL)
164 		return;
165 
166 	user = gc->proto_data;
167 	if (user == NULL)
168 		return;
169 
170 	if (user->privacy_synched == FALSE) {
171 		_sync_privacy_lists(user);
172 		user->privacy_synched = TRUE;
173 		return;
174 	}
175 
176 	if (nm_user_is_privacy_locked(user)) {
177 		_show_privacy_locked_error(gc, user);
178 		_sync_privacy_lists(user);
179 		return;
180 	}
181 
182 	switch (gc->account->perm_deny) {
183 
184 		case GAIM_PRIVACY_ALLOW_ALL:
185 			rc = nm_send_set_privacy_default(user, FALSE,
186 											 _set_privacy_default_resp_cb, NULL);
187 			_check_for_disconnect(user, rc);
188 
189 			/* clear server side deny list */
190 			if (rc == NM_OK) {
191 				copy = g_slist_copy(user->deny_list);
192 				for (node = copy; node && node->data; node = node->next) {
193 					rc = nm_send_remove_privacy_item(user, (const char *)node->data,
194 													 FALSE, NULL, NULL);
195 					if (_check_for_disconnect(user, rc))
196 						break;
197 				}
198 				g_slist_free(copy);
199 				g_slist_free(user->deny_list);
200 				user->deny_list = NULL;
201 			}
202 			break;
203 
204 		case GAIM_PRIVACY_DENY_ALL:
205 			rc = nm_send_set_privacy_default(user, TRUE,
206 											 _set_privacy_default_resp_cb, NULL);
207 			_check_for_disconnect(user, rc);
208 
209 			/* clear server side allow list */
210 			if (rc == NM_OK) {
211 				copy = g_slist_copy(user->allow_list);
212 				for (node = copy; node && node->data; node = node->next) {
213 					rc = nm_send_remove_privacy_item(user, (const char *)node->data,
214 													 TRUE, NULL, NULL);
215 					if (_check_for_disconnect(user, rc))
216 						break;
217 				}
218 				g_slist_free(copy);
219 				g_slist_free(user->allow_list);
220 				user->allow_list = NULL;
221 			}
222 			break;
223 
224 		case GAIM_PRIVACY_ALLOW_USERS:
225 
226 			rc = nm_send_set_privacy_default(user, TRUE,
227 											 _set_privacy_default_resp_cb, NULL);
228 			_check_for_disconnect(user, rc);
229 
230 			/* sync allow lists */
231 			if (rc == NM_OK) {
232 
233 				for (node = user->allow_list; node; node = node->next) {
234 					user_record = nm_find_user_record(user, (char *)node->data);
235 					if (user_record) {
236 						name = nm_user_record_get_display_id(user_record);
237 
238 						if (!g_slist_find_custom(gc->account->permit,
239 												 name, (GCompareFunc)nm_utf8_strcasecmp)) {
240 							gaim_privacy_permit_add(gc->account, name , TRUE);
241 						}
242 					}
243 				}
244 
245 				for (node = gc->account->permit; node; node = node->next) {
246 					name = NULL;
247 					dn = nm_lookup_dn(user, (char *)node->data);
248 					if (dn) {
249 						user_record = nm_find_user_record(user, dn);
250 						name = nm_user_record_get_display_id(user_record);
251 
252 						if (!g_slist_find_custom(user->allow_list,
253 												 dn, (GCompareFunc)nm_utf8_strcasecmp)) {
254 							rc = nm_send_create_privacy_item(user, dn, TRUE,
255 															 _create_privacy_item_deny_resp_cb,
256 															 g_strdup(dn));
257 						}
258 					} else {
259 						gaim_privacy_permit_remove(gc->account, (char *)node->data, TRUE);
260 					}
261 				}
262 			}
263 			break;
264 
265 		case GAIM_PRIVACY_DENY_USERS:
266 
267 			/* set to default allow */
268 			rc = nm_send_set_privacy_default(user, FALSE,
269 											 _set_privacy_default_resp_cb, NULL);
270 			_check_for_disconnect(user, rc);
271 
272 			/* sync deny lists */
273 			if (rc == NM_OK) {
274 
275 				for (node = user->deny_list; node; node = node->next) {
276 					user_record = nm_find_user_record(user, (char *)node->data);
277 					if (user_record) {
278 						name = nm_user_record_get_display_id(user_record);
279 
280 						if (!g_slist_find_custom(gc->account->deny,
281 												 name, (GCompareFunc)nm_utf8_strcasecmp)) {
282 							gaim_privacy_deny_add(gc->account, name , TRUE);
283 						}
284 					}
285 				}
286 
287 				for (node = gc->account->deny; node; node = node->next) {
288 
289 					name = NULL;
290 					dn = nm_lookup_dn(user, (char *)node->data);
291 					if (dn) {
292 						user_record = nm_find_user_record(user, dn);
293 						name = nm_user_record_get_display_id(user_record);
294 
295 						if (!g_slist_find_custom(user->deny_list,
296 												 dn, (GCompareFunc)nm_utf8_strcasecmp)) {
297 							rc = nm_send_create_privacy_item(user, dn, FALSE,
298 															 _create_privacy_item_deny_resp_cb,
299 															 g_strdup(name));
300 						}
301 					} else {
302 						gaim_privacy_deny_remove(gc->account, (char *)node->data, TRUE);
303 					}
304 				}
305 
306 			}
307 			break;
308 
309 		case GAIM_PRIVACY_ALLOW_BUDDYLIST:
310 
311 			/* remove users from allow list that are not in buddy list */
312 			copy = g_slist_copy(user->allow_list);
313 			for (node = copy; node && node->data; node = node->next) {
314 				if (!nm_find_contacts(user, node->data)) {
315 					rc = nm_send_remove_privacy_item(user, (const char *)node->data,
316 													 TRUE, NULL, NULL);
317 					if (_check_for_disconnect(user, rc))
318 						return;
319 				}
320 			}
321 			g_slist_free(copy);
322 
323 			/* add all buddies to allow list */
324 			num_contacts = nm_folder_get_contact_count(user->root_folder);
325 			for (i = 0; i < num_contacts; i++) {
326 				contact = nm_folder_get_contact(user->root_folder, i);
327 				dn = nm_contact_get_dn(contact);
328 				if (dn && !g_slist_find_custom(user->allow_list,
329 											   dn, (GCompareFunc)nm_utf8_strcasecmp))
330 				{
331 					rc = nm_send_create_privacy_item(user, dn, TRUE,
332 													 _create_privacy_item_deny_resp_cb,
333 													 g_strdup(dn));
334 					if (_check_for_disconnect(user, rc))
335 						return;
336 				}
337 
338 			}
339 
340 			num_folders = nm_folder_get_subfolder_count(user->root_folder);
341 			for (i = 0; i < num_folders; i++) {
342 				folder = nm_folder_get_subfolder(user->root_folder, i);
343 				num_contacts = nm_folder_get_contact_count(folder);
344 				for (j = 0; j < num_contacts; j++) {
345 					contact = nm_folder_get_contact(folder, j);
346 					dn = nm_contact_get_dn(contact);
347 					if (dn && !g_slist_find_custom(user->allow_list,
348 												   dn, (GCompareFunc)nm_utf8_strcasecmp))
349 					{
350 						rc = nm_send_create_privacy_item(user, dn, TRUE,
351 														 _create_privacy_item_deny_resp_cb,
352 														 g_strdup(dn));
353 						if (_check_for_disconnect(user, rc))
354 							return;
355 					}
356 				}
357 			}
358 
359 			/* set to default deny */
360 			rc = nm_send_set_privacy_default(user, TRUE,
361 											 _set_privacy_default_resp_cb, NULL);
362 			if (_check_for_disconnect(user, rc))
363 				break;
364 
365 			break;
366 	}
367 }
368 
369 static GList *
370 novell_blist_node_menu(GaimBlistNode *node)
371 {
372 	GList *list = NULL;
373 	GaimBlistNodeAction *act;
374 
375 	if(GAIM_BLIST_NODE_IS_BUDDY(node)) {
376 		act = gaim_blist_node_action_new(_("Initiate _Chat"),
377 				_initiate_conference_cb, NULL);
378 		list = g_list_append(list, act);
379 	}
380 
381 	return list;
382 }
383 
384 static void
385 novell_keepalive(GaimConnection *gc)
386 {
387 	NMUser *user;
388 	NMERR_T rc = NM_OK;
389 
390 	if (gc == NULL)
391 		return;
392 
393 	user = gc->proto_data;
394 	if (user == NULL)
395 		return;
396 
397 	rc = nm_send_keepalive(user, NULL, NULL);
398 	_check_for_disconnect(user, rc);
399 }
400 
401 static GaimPluginProtocolInfo prpl_info = {
402 	0,
403 	NULL,						/* user_splits */
404 	NULL,						/* protocol_options */
405 	NO_BUDDY_ICONS,				/* icon_spec */
406 	novell_list_icon,			/* list_icon */
407 	novell_list_emblems,		/* list_emblems */
408 	novell_status_text,			/* status_text */
409 	novell_tooltip_text,		/* tooltip_text */
410 	/*novell_away_states*/NULL,			/* away_states */
411 	novell_blist_node_menu,		/* blist_node_menu */
412 	NULL,						/* chat_info */
413 	NULL,						/* chat_info_defaults */
414 	novell_login,				/* login */
415 	novell_close,				/* close */
416 	novell_send_im,				/* send_im */
417 	NULL,						/* set_info */
418 	novell_send_typing,			/* send_typing */
419 	novell_get_info,			/* get_info */
420 	/*novell_set_away*/ NULL,			/* set_away */
421 	novell_set_idle,			/* set_idle */
422 	NULL,						/* change_passwd */
423 	novell_add_buddy,			/* add_buddy */
424 	NULL,						/* add_buddies */
425 	novell_remove_buddy,		/* remove_buddy */
426 	NULL,						/* remove_buddies */
427 	novell_add_permit,			/* add_permit */
428 	novell_add_deny,			/* add_deny */
429 	novell_rem_permit,			/* rem_permit */
430 	novell_rem_deny,			/* rem_deny */
431 	novell_set_permit_deny,		/* set_permit_deny */
432 	NULL,						/* warn */
433 	NULL,						/* join_chat */
434 	NULL,						/* reject_chat */
435 	NULL,					/* get_chat_name */
436 	novell_chat_invite,			/* chat_invite */
437 	novell_chat_leave,			/* chat_leave */
438 	NULL,						/* chat_whisper */
439 	novell_chat_send,			/* chat_send */
440 	novell_keepalive,			/* keepalive */
441 	NULL,						/* register_user */
442 	NULL,						/* get_cb_info */
443 	NULL,						/* get_cb_away */
444 	novell_alias_buddy,			/* alias_buddy */
445 	novell_group_buddy,			/* group_buddy */
446 	novell_rename_group,		/* rename_group */
447 	NULL,						/* buddy_free */
448 	novell_convo_closed,		/* convo_closed */
449 	NULL,						/* normalize */
450 	NULL,						/* set_buddy_icon */
451 	novell_remove_group,		/* remove_group */
452 	NULL,						/* get_cb_real_name */
453 	NULL,						/* set_chat_topic */
454 	NULL,						/* find_blist_chat */
455 	NULL,						/* roomlist_get_list */
456 	NULL,						/* roomlist_cancel */
457 	NULL,						/* roomlist_expand_category */
458 	NULL,						/* can_receive_file */
459 	NULL						/* send_file */
460 };
461 
462 static GaimPluginInfo info = {
463 	GAIM_PLUGIN_MAGIC,
464 	GAIM_MAJOR_VERSION,
465 	GAIM_MINOR_VERSION,
466 	GAIM_PLUGIN_PROTOCOL,			/**< type           */
467 	NULL,					/**< ui_requirement */
468 	0,					/**< flags          */
469 	NULL,					/**< dependencies   */
470 	GAIM_PRIORITY_DEFAULT,			/**< priority       */
471 	"prpl-novell",				/**< id             */
472 	"GroupWise",				/**< name           */
473 	VERSION,				/**< version        */
474 	/**  summary        */
475 	N_("Novell GroupWise Messenger Protocol Plugin"),
476 	/**  description    */
477 	N_("Novell GroupWise Messenger Protocol Plugin"),
478 	NULL,					/**< author         */
479 	GAIM_WEBSITE,				/**< homepage       */
480 
481 	NULL,					/**< load           */
482 	NULL,					/**< unload         */
483 	NULL,					/**< destroy        */
484 
485 	NULL,					/**< ui_info        */
486 	&prpl_info,				/**< extra_info     */
487 	NULL,
488 	NULL
489 };
490 
491 static void
492 init_plugin(GaimPlugin * plugin)
493 {
494 	GaimAccountOption *option;
495 
496 	option = gaim_account_option_string_new(_("Server address"), "server", NULL);
497 	prpl_info.protocol_options =
498 		g_list_append(prpl_info.protocol_options, option);
499 
500 	option = gaim_account_option_int_new(_("Server port"), "port", DEFAULT_PORT);
501 	prpl_info.protocol_options =
502 		g_list_append(prpl_info.protocol_options, option);
503 
504 	my_protocol = plugin;
505 }
506 
507 GAIM_INIT_PLUGIN(novell, init_plugin, info);