comparison libpurple/protocols/zephyr/zephyr.c @ 32672:3828a61c44da

A boring and large patch so I can merge heads.

32671:0e69949b3e61

static gchar *zephyr_recv_convert(PurpleConnection *gc, gchar *string)
{
	gchar *utf8;
	GError *err = NULL;
	zephyr_account *zephyr = gc->proto_data;
	if (g_utf8_validate(string, -1, NULL)) {
		return g_strdup(string);
	} else {
		utf8 = g_convert(string, -1, "UTF-8", zephyr->encoding, NULL, NULL, &err);
		if (err) {

	}
}

static void handle_message(PurpleConnection *gc,ZNotice_t notice)
{
	zephyr_account* zephyr = gc->proto_data;

	if (!g_ascii_strcasecmp(notice.z_class, LOGIN_CLASS)) {
		/* well, we'll be updating in 20 seconds anyway, might as well ignore this. */
	} else if (!g_ascii_strcasecmp(notice.z_class, LOCATE_CLASS)) {
		if (!g_ascii_strcasecmp(notice.z_opcode, LOCATE_LOCATE)) {

			/* XXX add real error reporting */
			if (ZParseLocations(&notice, NULL, &nlocs, &user) != ZERR_NONE)
				return;

			if ((b = purple_find_buddy(gc->account, user)) == NULL) {
				char* stripped_user = zephyr_strip_local_realm(zephyr,user);
				b = purple_find_buddy(gc->account,stripped_user);
				g_free(stripped_user);
			}

			bname = b ? purple_buddy_get_name(b) : NULL;
			if ((b && pending_zloc(zephyr,bname)) || pending_zloc(zephyr,user)) {

				purple_notify_userinfo(gc, (b ? bname : user),
						     user_info, NULL, NULL);
				purple_notify_user_info_destroy(user_info);
			} else {
				if (nlocs>0)
					purple_prpl_got_user_status(gc->account, b ? bname : user, "available", NULL);
				else
					purple_prpl_got_user_status(gc->account, b ? bname : user, "offline", NULL);
			}

			g_free(user);
		}
	} else {

				serv_got_im(gc, stripped_sender, buf3, flags, time(NULL));

		} else {
			zephyr_triple *zt1, *zt2;
			gchar *send_inst_utf8;
			zephyr_account *zephyr = gc->proto_data;
			zt1 = new_triple(zephyr,notice.z_class, notice.z_class_inst, notice.z_recipient);
			zt2 = find_sub_by_triple(zephyr,zt1);
			if (!zt2) {
				/* This is a server supplied subscription */
				zephyr->subscrips = g_slist_append(zephyr->subscrips, new_triple(zephyr,zt1->class,zt1->instance,zt1->recipient));

					send_inst_utf8 = g_strdup(stripped_sender);
				}
			}

			gconv1 = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT,
														 zt2->name, gc->account);
			gcc = purple_conversation_get_chat_data(gconv1);
#ifndef INET_ADDRSTRLEN
#define INET_ADDRSTRLEN 16
#endif
			if (!purple_conv_chat_find_user(gcc, stripped_sender)) {

}

static gint check_notify_tzc(gpointer data)
{
	PurpleConnection *gc = (PurpleConnection *)data;
	zephyr_account* zephyr = gc->proto_data;
	parse_tree *newparsetree = read_from_tzc(zephyr);
	if (newparsetree != NULL) {
		gchar *spewtype;
		if ( (spewtype =  tree_child(find_node(newparsetree,"tzcspew"),2)->contents) ) {
			if (!g_ascii_strncasecmp(spewtype,"message",7)) {

				int nlocs = 0;
				parse_tree *locations;
				gchar *locval;
				user = tree_child(find_node(newparsetree,"user"),2)->contents;

				if ((b = purple_find_buddy(gc->account, user)) == NULL) {
					gchar *stripped_user = zephyr_strip_local_realm(zephyr,user);
					b = purple_find_buddy(gc->account, stripped_user);
					g_free(stripped_user);
				}
				locations = find_node(newparsetree,"locations");
				locval = tree_child(tree_child(tree_child(tree_child(locations,2),0),0),2)->contents;

					purple_notify_userinfo(gc, b ? bname : user,
							     user_info, NULL, NULL);
					purple_notify_user_info_destroy(user_info);
				} else {
					if (nlocs>0)
						purple_prpl_got_user_status(gc->account, b ? bname : user, "available", NULL);
					else
						purple_prpl_got_user_status(gc->account, b ? bname : user, "offline", NULL);
				}
			}
			else if (!g_ascii_strncasecmp(spewtype,"subscribed",10)) {
			}
			else if (!g_ascii_strncasecmp(spewtype,"start",5)) {

static gint check_loc(gpointer data)
{
	GSList *buddies;
	ZLocations_t locations;
	PurpleConnection *gc = data;
	zephyr_account *zephyr = gc->proto_data;
	PurpleAccount *account = purple_connection_get_account(gc);
	int numlocs;
	int one = 1;

	for (buddies = purple_find_buddies(account, NULL); buddies;

static gint check_loc(gpointer data)
{
	GSList *buddies;
	ZAsyncLocateData_t ald;
	PurpleConnection *gc = (PurpleConnection *)data;
	zephyr_account *zephyr = gc->proto_data;
	PurpleAccount *account = purple_connection_get_account(gc);

	if (use_zeph02(zephyr)) {
		ald.user = NULL;
		memset(&(ald.uid), 0, sizeof(ZUnique_Id_t));

	filename = g_strconcat(purple_home_dir(), "/.anyone", NULL);
	if ((fd = g_fopen(filename, "r")) != NULL) {
		while (fgets(buff, BUFSIZ, fd)) {
			strip_comments(buff);
			if (buff[0]) {
				if (!(b = purple_find_buddy(gc->account, buff))) {
					char *stripped_user = zephyr_strip_local_realm(zephyr,buff);
					purple_debug_info("zephyr","stripped_user %s\n",stripped_user);
					if (!(b = purple_find_buddy(gc->account,stripped_user))){
						b = purple_buddy_new(gc->account, stripped_user, NULL);
						purple_blist_add_buddy(b, NULL, g, NULL);
					}
					g_free(stripped_user);
				}
			}

	gboolean read_anyone;
	gboolean read_zsubs;
	gchar *exposure;

	gc = purple_account_get_connection(account);
	read_anyone = purple_account_get_bool(gc->account,"read_anyone",TRUE);
	read_zsubs = purple_account_get_bool(gc->account,"read_zsubs",TRUE);
	exposure = (gchar *)purple_account_get_string(gc->account, "exposure_level", EXPOSE_REALMVIS);

#ifdef WIN32
	username = purple_account_get_username(account);
#endif
	gc->flags |= PURPLE_CONNECTION_AUTO_RESP | PURPLE_CONNECTION_HTML | PURPLE_CONNECTION_NO_BGCOLOR | PURPLE_CONNECTION_NO_URLDESC;
	gc->proto_data = zephyr=g_new0(zephyr_account,1);

	zephyr->account = account;

	/* Make sure that the exposure (visibility) is set to a sane value */
	zephyr->exposure=g_strdup(normalize_zephyr_exposure(exposure));

	if (purple_account_get_bool(gc->account,"use_tzc",0)) {
		zephyr->connection_type = PURPLE_ZEPHYR_TZC;
	} else {
		zephyr->connection_type = PURPLE_ZEPHYR_KRB4;
	}

	zephyr->encoding = (char *)purple_account_get_string(gc->account, "encoding", ZEPHYR_FALLBACK_CHARSET);
	purple_connection_update_progress(gc, _("Connecting"), 0, 8);

	/* XXX z_call_s should actually try to report the com_err determined error */
	if (use_tzc(zephyr)) {
		pid_t pid;

			exit(-1);
		}
		if (pid == 0) {
			unsigned int i=0;
			gboolean found_ps = FALSE;
			gchar ** tzc_cmd_array = g_strsplit(purple_account_get_string(gc->account,"tzc_command","/usr/bin/tzc -e %s")," ",0);
			if (close(1) == -1) {
				exit(-1);
			}
			if (dup2(zephyr->fromtzc[1], 1) == -1) {
				exit(-1);

						zephyr->username = g_strdup_printf("%s",username);
						if ((realm = strchr(username,'@')))
							zephyr->realm = g_strdup_printf("%s",realm+1);
						else {
							realm = (gchar *)purple_account_get_string(gc->account,"realm","");
							if (!*realm) {
								realm = "local-realm";
							}
							zephyr->realm = g_strdup(realm);
							g_strlcpy(__Zephyr_realm, (const char*)zephyr->realm, REALM_SZ-1);

		gchar* realm;
		z_call_s(ZInitialize(), "Couldn't initialize zephyr");
		z_call_s(ZOpenPort(&(zephyr->port)), "Couldn't open port");
		z_call_s(ZSetLocation((char *)zephyr->exposure), "Couldn't set location");

		realm = (gchar *)purple_account_get_string(gc->account,"realm","");
		if (!*realm) {
			realm = ZGetRealm();
		}
		zephyr->realm = g_strdup(realm);
		g_strlcpy(__Zephyr_realm, (const char*)zephyr->realm, REALM_SZ-1);

	zephyr_inithosts(zephyr);

	if (zephyr_subscribe_to(zephyr,"MESSAGE","PERSONAL",zephyr->username,NULL) != ZERR_NONE) {
		/* XXX don't translate this yet. It could be written better */
		/* XXX error messages could be handled with more detail */
		purple_notify_error(account->gc, NULL,
				  "Unable to subscribe to messages", "Unable to subscribe to initial messages");
		return;
	}

	purple_connection_set_state(gc, PURPLE_CONNECTED);

static void zephyr_close(PurpleConnection * gc)
{
	GList *l;
	GSList *s;
	zephyr_account *zephyr = gc->proto_data;
	pid_t tzc_pid = zephyr->tzc_pid;

	l = zephyr->pending_zloc_names;
	while (l) {
		g_free((char *)l->data);
		l = l->next;
	}
	g_list_free(zephyr->pending_zloc_names);

	if (purple_account_get_bool(gc->account, "write_anyone", FALSE))
		write_anyone(zephyr);

	if (purple_account_get_bool(gc->account, "write_zsubs", FALSE))
		write_zsubs(zephyr);

	s = zephyr->subscrips;
	while (s) {
		free_triple((zephyr_triple *) s->data);

	const char *sig;
	PurpleConversation *gconv1;
	PurpleConvChat *gcc;
	char *inst;
	char *recipient;
	zephyr_account *zephyr = gc->proto_data;

	zt = find_sub_by_id(zephyr,id);
	if (!zt)
		/* this should never happen. */
		return -EINVAL;

	sig = zephyr_get_signature();

	gconv1 = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, zt->name,
												 gc->account);
	gcc = purple_conversation_get_chat_data(gconv1);

	if (!(inst = (char *)purple_conv_chat_get_topic(gcc)))
		inst = g_strdup("PERSONAL");

static int zephyr_send_im(PurpleConnection * gc, const char *who, const char *im, PurpleMessageFlags flags)
{
	const char *sig;
	zephyr_account *zephyr = gc->proto_data;
	if (flags & PURPLE_MESSAGE_AUTO_RESP)
		sig = "Automated reply:";
	else {
		sig = zephyr_get_signature();
	}

	gc = purple_account_get_connection(account);
	if (gc == NULL)
		return NULL;

	tmp = local_zephyr_normalize(gc->proto_data, who);

	if (strlen(tmp) >= sizeof(buf)) {
		g_free(tmp);
		return NULL;
	}

}

static void zephyr_zloc(PurpleConnection *gc, const char *who)
{
	ZAsyncLocateData_t ald;
	zephyr_account *zephyr = gc->proto_data;
	gchar* normalized_who = local_zephyr_normalize(zephyr,who);

	if (use_zeph02(zephyr)) {
		if (ZRequestLocations(normalized_who, &ald, UNACKED, ZAUTH) == ZERR_NONE) {
			zephyr->pending_zloc_names = g_list_append(zephyr->pending_zloc_names,

}

static void zephyr_set_status(PurpleAccount *account, PurpleStatus *status) {
	size_t len;
	size_t result;
	zephyr_account *zephyr = purple_account_get_connection(account)->proto_data;
	PurpleStatusPrimitive primitive = purple_status_type_get_primitive(purple_status_get_type(status));

	if (zephyr->away) {
		g_free(zephyr->away);
		zephyr->away=NULL;

	/*	ZSubscription_t sub; */
	zephyr_triple *zt1, *zt2;
	const char *classname;
	const char *instname;
	const char *recip;
	zephyr_account *zephyr=gc->proto_data;
	classname = g_hash_table_lookup(data, "class");
	instname = g_hash_table_lookup(data, "instance");
	recip = g_hash_table_lookup(data, "recipient");

}

static void zephyr_chat_leave(PurpleConnection * gc, int id)
{
	zephyr_triple *zt;
	zephyr_account *zephyr = gc->proto_data;
	zt = find_sub_by_id(zephyr,id);

	if (zt) {
		zt->open = FALSE;
		zt->id = ++(zephyr->last_id);

	return "zephyr";
}

static unsigned int zephyr_send_typing(PurpleConnection *gc, const char *who, PurpleTypingState state) {
	gchar *recipient;
	zephyr_account *zephyr = gc->proto_data;
	if (use_tzc(zephyr))
		return 0;

	if (state == PURPLE_NOT_TYPING)
		return 0;

{
	zephyr_triple *zt;
	PurpleConversation *gconv;
	PurpleConvChat *gcc;
	gchar *topic_utf8;
	zephyr_account* zephyr = gc->proto_data;
	char *sender = (char *)zephyr->username;

	zt = find_sub_by_id(zephyr,id);
	/* find_sub_by_id can return NULL */
	if (!zt)
		return;
	gconv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, zt->name,
												gc->account);
	gcc = purple_conversation_get_chat_data(gconv);

	topic_utf8 = zephyr_recv_convert(gc,(gchar *)topic);
	purple_conv_chat_set_topic(gcc,sender,topic_utf8);
	g_free(topic_utf8);

static PurpleCmdRet zephyr_purple_cmd_msg(PurpleConversation *conv,
				      const char *cmd, char **args, char **error, void *data)
{
	char *recipient;
	zephyr_account *zephyr = purple_conversation_get_gc(conv)->proto_data;
	if (!g_ascii_strcasecmp(args[0],"*"))
		return PURPLE_CMD_RET_FAILED;  /* "*" is not a valid argument */
	else
		recipient = local_zephyr_normalize(zephyr,args[0]);

}

static PurpleCmdRet zephyr_purple_cmd_zlocate(PurpleConversation *conv,
					  const char *cmd, char **args, char **error, void *data)
{
	zephyr_zloc(purple_conversation_get_gc(conv),args[0]);
	return PURPLE_CMD_RET_OK;
}

static PurpleCmdRet zephyr_purple_cmd_instance(PurpleConversation *conv,
					   const char *cmd, char **args, char **error, void *data)

	/* Currently it sets the instance with leading spaces and
	 * all. This might not be the best thing to do, though having
	 * one word isn't ideal either.	 */

	PurpleConvChat *gcc = purple_conversation_get_chat_data(conv);
	int id = gcc->id;
	const char* instance = args[0];
	zephyr_chat_set_topic(purple_conversation_get_gc(conv),id,instance);
	return PURPLE_CMD_RET_OK;
}

static PurpleCmdRet zephyr_purple_cmd_joinchat_cir(PurpleConversation *conv,
					       const char *cmd, char **args, char **error, void *data)

	/* Join a new zephyr chat */
	GHashTable *triple = g_hash_table_new(NULL,NULL);
	g_hash_table_insert(triple,"class",args[0]);
	g_hash_table_insert(triple,"instance",args[1]);
	g_hash_table_insert(triple,"recipient",args[2]);
	zephyr_join_chat(purple_conversation_get_gc(conv),triple);
	return PURPLE_CMD_RET_OK;
}

static PurpleCmdRet zephyr_purple_cmd_zi(PurpleConversation *conv,
				     const char *cmd, char **args, char **error, void *data)
{
	/* args = instance, message */
	zephyr_account *zephyr = purple_conversation_get_gc(conv)->proto_data;
	if ( zephyr_send_message(zephyr,"message",args[0],"",args[1],zephyr_get_signature(),""))
		return PURPLE_CMD_RET_OK;
	else
		return PURPLE_CMD_RET_FAILED;
}

static PurpleCmdRet zephyr_purple_cmd_zci(PurpleConversation *conv,
				      const char *cmd, char **args, char **error, void *data)
{
	/* args = class, instance, message */
	zephyr_account *zephyr = purple_conversation_get_gc(conv)->proto_data;
	if ( zephyr_send_message(zephyr,args[0],args[1],"",args[2],zephyr_get_signature(),""))
		return PURPLE_CMD_RET_OK;
	else
		return PURPLE_CMD_RET_FAILED;
}

static PurpleCmdRet zephyr_purple_cmd_zcir(PurpleConversation *conv,
				       const char *cmd, char **args, char **error, void *data)
{
	/* args = class, instance, recipient, message */
	zephyr_account *zephyr = purple_conversation_get_gc(conv)->proto_data;
	if ( zephyr_send_message(zephyr,args[0],args[1],args[2],args[3],zephyr_get_signature(),""))
		return PURPLE_CMD_RET_OK;
	else
		return PURPLE_CMD_RET_FAILED;
}

static PurpleCmdRet zephyr_purple_cmd_zir(PurpleConversation *conv,
				      const char *cmd, char **args, char **error, void *data)
{
	/* args = instance, recipient, message */
	zephyr_account *zephyr = purple_conversation_get_gc(conv)->proto_data;
	if ( zephyr_send_message(zephyr,"message",args[0],args[1],args[2],zephyr_get_signature(),""))
		return PURPLE_CMD_RET_OK;
	else
		return PURPLE_CMD_RET_FAILED;
}

static PurpleCmdRet zephyr_purple_cmd_zc(PurpleConversation *conv,
				     const char *cmd, char **args, char **error, void *data)
{
	/* args = class, message */
	zephyr_account *zephyr = purple_conversation_get_gc(conv)->proto_data;
	if ( zephyr_send_message(zephyr,args[0],"PERSONAL","",args[1],zephyr_get_signature(),""))
		return PURPLE_CMD_RET_OK;
	else
		return PURPLE_CMD_RET_FAILED;
}

static int zephyr_resubscribe(PurpleConnection *gc)
{
	/* Resubscribe to the in-memory list of subscriptions and also
	   unsubscriptions*/
	zephyr_account *zephyr = gc->proto_data;
	GSList *s = zephyr->subscrips;
	zephyr_triple *zt;
	while (s) {
		zt = s->data;
		/* XXX We really should care if this fails */

static void zephyr_action_get_subs_from_server(PurplePluginAction *action)
{
	PurpleConnection *gc = (PurpleConnection *) action->context;
	zephyr_account *zephyr = gc->proto_data;
	gchar *title;
	int retval, nsubs, one,i;
	ZSubscription_t subs;
	if (use_zeph02(zephyr)) {
		GString* subout = g_string_new("Subscription list<br>");

}

static PurplePlugin *my_protocol = NULL;

static PurplePluginProtocolInfo prpl_info = {
	OPT_PROTO_CHAT_TOPIC | OPT_PROTO_NO_PASSWORD,
	NULL,					/* ??? user_splits */
	NULL,					/* ??? protocol_options */
	NO_BUDDY_ICONS,
	zephyr_list_icon,

	NULL,					/* chat_whisper -- No "whispering"*/
	zephyr_chat_send,		/* chat_send */
	NULL,					/* keepalive -- Not necessary*/
	NULL,					/* register_user -- Not supported*/
	NULL,					/* XXX get_cb_info */
	NULL,					/* get_cb_away */
	NULL,					/* alias_buddy */
	NULL,					/* group_buddy */
	NULL,					/* rename_group */
	NULL,					/* buddy_free */
	NULL,					/* convo_closed */

	NULL,					/* roomlist_room_serialize */

	NULL,
	NULL,
	NULL,
	sizeof(PurplePluginProtocolInfo),       /* struct_size */
	NULL,					/* get_account_text_table */
	NULL,					/* initate_media */
	NULL,					/* get_media_caps */
	NULL,					/* get_moods */
	NULL,					/* set_public_alias */
	NULL,					/* get_public_alias */
	NULL,					/* add_buddy_with_invite */
	NULL					/* add_buddies_with_invite */
};

static PurplePluginInfo info = {
	PURPLE_PLUGIN_MAGIC,
	PURPLE_MAJOR_VERSION,

32672:3828a61c44da

static gchar *zephyr_recv_convert(PurpleConnection *gc, gchar *string)
{
	gchar *utf8;
	GError *err = NULL;
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	if (g_utf8_validate(string, -1, NULL)) {
		return g_strdup(string);
	} else {
		utf8 = g_convert(string, -1, "UTF-8", zephyr->encoding, NULL, NULL, &err);
		if (err) {

	}
}

static void handle_message(PurpleConnection *gc,ZNotice_t notice)
{
	zephyr_account* zephyr = purple_connection_get_protocol_data(gc);

	if (!g_ascii_strcasecmp(notice.z_class, LOGIN_CLASS)) {
		/* well, we'll be updating in 20 seconds anyway, might as well ignore this. */
	} else if (!g_ascii_strcasecmp(notice.z_class, LOCATE_CLASS)) {
		if (!g_ascii_strcasecmp(notice.z_opcode, LOCATE_LOCATE)) {

			/* XXX add real error reporting */
			if (ZParseLocations(&notice, NULL, &nlocs, &user) != ZERR_NONE)
				return;

			if ((b = purple_find_buddy(purple_connection_get_account(gc), user)) == NULL) {
				char* stripped_user = zephyr_strip_local_realm(zephyr,user);
				b = purple_find_buddy(purple_connection_get_account(gc),stripped_user);
				g_free(stripped_user);
			}

			bname = b ? purple_buddy_get_name(b) : NULL;
			if ((b && pending_zloc(zephyr,bname)) || pending_zloc(zephyr,user)) {

				purple_notify_userinfo(gc, (b ? bname : user),
						     user_info, NULL, NULL);
				purple_notify_user_info_destroy(user_info);
			} else {
				if (nlocs>0)
					purple_prpl_got_user_status(purple_connection_get_account(gc), b ? bname : user, "available", NULL);
				else
					purple_prpl_got_user_status(purple_connection_get_account(gc), b ? bname : user, "offline", NULL);
			}

			g_free(user);
		}
	} else {

				serv_got_im(gc, stripped_sender, buf3, flags, time(NULL));

		} else {
			zephyr_triple *zt1, *zt2;
			gchar *send_inst_utf8;
			zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
			zt1 = new_triple(zephyr,notice.z_class, notice.z_class_inst, notice.z_recipient);
			zt2 = find_sub_by_triple(zephyr,zt1);
			if (!zt2) {
				/* This is a server supplied subscription */
				zephyr->subscrips = g_slist_append(zephyr->subscrips, new_triple(zephyr,zt1->class,zt1->instance,zt1->recipient));

					send_inst_utf8 = g_strdup(stripped_sender);
				}
			}

			gconv1 = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT,
														 zt2->name, purple_connection_get_account(gc));
			gcc = purple_conversation_get_chat_data(gconv1);
#ifndef INET_ADDRSTRLEN
#define INET_ADDRSTRLEN 16
#endif
			if (!purple_conv_chat_find_user(gcc, stripped_sender)) {

}

static gint check_notify_tzc(gpointer data)
{
	PurpleConnection *gc = (PurpleConnection *)data;
	zephyr_account* zephyr = purple_connection_get_protocol_data(gc);
	parse_tree *newparsetree = read_from_tzc(zephyr);
	if (newparsetree != NULL) {
		gchar *spewtype;
		if ( (spewtype =  tree_child(find_node(newparsetree,"tzcspew"),2)->contents) ) {
			if (!g_ascii_strncasecmp(spewtype,"message",7)) {

				int nlocs = 0;
				parse_tree *locations;
				gchar *locval;
				user = tree_child(find_node(newparsetree,"user"),2)->contents;

				if ((b = purple_find_buddy(purple_connection_get_account(gc), user)) == NULL) {
					gchar *stripped_user = zephyr_strip_local_realm(zephyr,user);
					b = purple_find_buddy(purple_connection_get_account(gc), stripped_user);
					g_free(stripped_user);
				}
				locations = find_node(newparsetree,"locations");
				locval = tree_child(tree_child(tree_child(tree_child(locations,2),0),0),2)->contents;

					purple_notify_userinfo(gc, b ? bname : user,
							     user_info, NULL, NULL);
					purple_notify_user_info_destroy(user_info);
				} else {
					if (nlocs>0)
						purple_prpl_got_user_status(purple_connection_get_account(gc), b ? bname : user, "available", NULL);
					else
						purple_prpl_got_user_status(purple_connection_get_account(gc), b ? bname : user, "offline", NULL);
				}
			}
			else if (!g_ascii_strncasecmp(spewtype,"subscribed",10)) {
			}
			else if (!g_ascii_strncasecmp(spewtype,"start",5)) {

static gint check_loc(gpointer data)
{
	GSList *buddies;
	ZLocations_t locations;
	PurpleConnection *gc = data;
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	PurpleAccount *account = purple_connection_get_account(gc);
	int numlocs;
	int one = 1;

	for (buddies = purple_find_buddies(account, NULL); buddies;

static gint check_loc(gpointer data)
{
	GSList *buddies;
	ZAsyncLocateData_t ald;
	PurpleConnection *gc = (PurpleConnection *)data;
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	PurpleAccount *account = purple_connection_get_account(gc);

	if (use_zeph02(zephyr)) {
		ald.user = NULL;
		memset(&(ald.uid), 0, sizeof(ZUnique_Id_t));

	filename = g_strconcat(purple_home_dir(), "/.anyone", NULL);
	if ((fd = g_fopen(filename, "r")) != NULL) {
		while (fgets(buff, BUFSIZ, fd)) {
			strip_comments(buff);
			if (buff[0]) {
				if (!(b = purple_find_buddy(purple_connection_get_account(gc), buff))) {
					char *stripped_user = zephyr_strip_local_realm(zephyr,buff);
					purple_debug_info("zephyr","stripped_user %s\n",stripped_user);
					if (!(b = purple_find_buddy(purple_connection_get_account(gc),stripped_user))){
						b = purple_buddy_new(purple_connection_get_account(gc), stripped_user, NULL);
						purple_blist_add_buddy(b, NULL, g, NULL);
					}
					g_free(stripped_user);
				}
			}

	gboolean read_anyone;
	gboolean read_zsubs;
	gchar *exposure;

	gc = purple_account_get_connection(account);
	read_anyone = purple_account_get_bool(purple_connection_get_account(gc),"read_anyone",TRUE);
	read_zsubs = purple_account_get_bool(purple_connection_get_account(gc),"read_zsubs",TRUE);
	exposure = (gchar *)purple_account_get_string(purple_connection_get_account(gc), "exposure_level", EXPOSE_REALMVIS);

#ifdef WIN32
	username = purple_account_get_username(account);
#endif
	purple_connection_set_flags(gc, PURPLE_CONNECTION_AUTO_RESP | PURPLE_CONNECTION_HTML | PURPLE_CONNECTION_NO_BGCOLOR | PURPLE_CONNECTION_NO_URLDESC);
	zephyr = g_new0(zephyr_account, 1);
	purple_connection_set_protocol_data(gc, zephyr);

	zephyr->account = account;

	/* Make sure that the exposure (visibility) is set to a sane value */
	zephyr->exposure=g_strdup(normalize_zephyr_exposure(exposure));

	if (purple_account_get_bool(purple_connection_get_account(gc),"use_tzc",0)) {
		zephyr->connection_type = PURPLE_ZEPHYR_TZC;
	} else {
		zephyr->connection_type = PURPLE_ZEPHYR_KRB4;
	}

	zephyr->encoding = (char *)purple_account_get_string(purple_connection_get_account(gc), "encoding", ZEPHYR_FALLBACK_CHARSET);
	purple_connection_update_progress(gc, _("Connecting"), 0, 8);

	/* XXX z_call_s should actually try to report the com_err determined error */
	if (use_tzc(zephyr)) {
		pid_t pid;

			exit(-1);
		}
		if (pid == 0) {
			unsigned int i=0;
			gboolean found_ps = FALSE;
			gchar ** tzc_cmd_array = g_strsplit(purple_account_get_string(purple_connection_get_account(gc),"tzc_command","/usr/bin/tzc -e %s")," ",0);
			if (close(1) == -1) {
				exit(-1);
			}
			if (dup2(zephyr->fromtzc[1], 1) == -1) {
				exit(-1);

						zephyr->username = g_strdup_printf("%s",username);
						if ((realm = strchr(username,'@')))
							zephyr->realm = g_strdup_printf("%s",realm+1);
						else {
							realm = (gchar *)purple_account_get_string(purple_connection_get_account(gc),"realm","");
							if (!*realm) {
								realm = "local-realm";
							}
							zephyr->realm = g_strdup(realm);
							g_strlcpy(__Zephyr_realm, (const char*)zephyr->realm, REALM_SZ-1);

		gchar* realm;
		z_call_s(ZInitialize(), "Couldn't initialize zephyr");
		z_call_s(ZOpenPort(&(zephyr->port)), "Couldn't open port");
		z_call_s(ZSetLocation((char *)zephyr->exposure), "Couldn't set location");

		realm = (gchar *)purple_account_get_string(purple_connection_get_account(gc),"realm","");
		if (!*realm) {
			realm = ZGetRealm();
		}
		zephyr->realm = g_strdup(realm);
		g_strlcpy(__Zephyr_realm, (const char*)zephyr->realm, REALM_SZ-1);

	zephyr_inithosts(zephyr);

	if (zephyr_subscribe_to(zephyr,"MESSAGE","PERSONAL",zephyr->username,NULL) != ZERR_NONE) {
		/* XXX don't translate this yet. It could be written better */
		/* XXX error messages could be handled with more detail */
		purple_notify_error(purple_account_get_connection(account), NULL,
				  "Unable to subscribe to messages", "Unable to subscribe to initial messages");
		return;
	}

	purple_connection_set_state(gc, PURPLE_CONNECTED);

static void zephyr_close(PurpleConnection * gc)
{
	GList *l;
	GSList *s;
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	pid_t tzc_pid = zephyr->tzc_pid;

	l = zephyr->pending_zloc_names;
	while (l) {
		g_free((char *)l->data);
		l = l->next;
	}
	g_list_free(zephyr->pending_zloc_names);

	if (purple_account_get_bool(purple_connection_get_account(gc), "write_anyone", FALSE))
		write_anyone(zephyr);

	if (purple_account_get_bool(purple_connection_get_account(gc), "write_zsubs", FALSE))
		write_zsubs(zephyr);

	s = zephyr->subscrips;
	while (s) {
		free_triple((zephyr_triple *) s->data);

	const char *sig;
	PurpleConversation *gconv1;
	PurpleConvChat *gcc;
	char *inst;
	char *recipient;
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);

	zt = find_sub_by_id(zephyr,id);
	if (!zt)
		/* this should never happen. */
		return -EINVAL;

	sig = zephyr_get_signature();

	gconv1 = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, zt->name,
												 purple_connection_get_account(gc));
	gcc = purple_conversation_get_chat_data(gconv1);

	if (!(inst = (char *)purple_conv_chat_get_topic(gcc)))
		inst = g_strdup("PERSONAL");

static int zephyr_send_im(PurpleConnection * gc, const char *who, const char *im, PurpleMessageFlags flags)
{
	const char *sig;
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	if (flags & PURPLE_MESSAGE_AUTO_RESP)
		sig = "Automated reply:";
	else {
		sig = zephyr_get_signature();
	}

	gc = purple_account_get_connection(account);
	if (gc == NULL)
		return NULL;

	tmp = local_zephyr_normalize(purple_connection_get_protocol_data(gc), who);

	if (strlen(tmp) >= sizeof(buf)) {
		g_free(tmp);
		return NULL;
	}

}

static void zephyr_zloc(PurpleConnection *gc, const char *who)
{
	ZAsyncLocateData_t ald;
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	gchar* normalized_who = local_zephyr_normalize(zephyr,who);

	if (use_zeph02(zephyr)) {
		if (ZRequestLocations(normalized_who, &ald, UNACKED, ZAUTH) == ZERR_NONE) {
			zephyr->pending_zloc_names = g_list_append(zephyr->pending_zloc_names,

}

static void zephyr_set_status(PurpleAccount *account, PurpleStatus *status) {
	size_t len;
	size_t result;
	PurpleConnection *gc = purple_account_get_connection(account);
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	PurpleStatusPrimitive primitive = purple_status_type_get_primitive(purple_status_get_type(status));

	if (zephyr->away) {
		g_free(zephyr->away);
		zephyr->away=NULL;

	/*	ZSubscription_t sub; */
	zephyr_triple *zt1, *zt2;
	const char *classname;
	const char *instname;
	const char *recip;
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	classname = g_hash_table_lookup(data, "class");
	instname = g_hash_table_lookup(data, "instance");
	recip = g_hash_table_lookup(data, "recipient");

}

static void zephyr_chat_leave(PurpleConnection * gc, int id)
{
	zephyr_triple *zt;
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	zt = find_sub_by_id(zephyr,id);

	if (zt) {
		zt->open = FALSE;
		zt->id = ++(zephyr->last_id);

	return "zephyr";
}

static unsigned int zephyr_send_typing(PurpleConnection *gc, const char *who, PurpleTypingState state) {
	gchar *recipient;
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	if (use_tzc(zephyr))
		return 0;

	if (state == PURPLE_NOT_TYPING)
		return 0;

{
	zephyr_triple *zt;
	PurpleConversation *gconv;
	PurpleConvChat *gcc;
	gchar *topic_utf8;
	zephyr_account* zephyr = purple_connection_get_protocol_data(gc);
	char *sender = (char *)zephyr->username;

	zt = find_sub_by_id(zephyr,id);
	/* find_sub_by_id can return NULL */
	if (!zt)
		return;
	gconv = purple_find_conversation_with_account(PURPLE_CONV_TYPE_CHAT, zt->name,
												purple_connection_get_account(gc));
	gcc = purple_conversation_get_chat_data(gconv);

	topic_utf8 = zephyr_recv_convert(gc,(gchar *)topic);
	purple_conv_chat_set_topic(gcc,sender,topic_utf8);
	g_free(topic_utf8);

static PurpleCmdRet zephyr_purple_cmd_msg(PurpleConversation *conv,
				      const char *cmd, char **args, char **error, void *data)
{
	char *recipient;
	PurpleConnection *gc = purple_conversation_get_connection(conv);
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);;
	if (!g_ascii_strcasecmp(args[0],"*"))
		return PURPLE_CMD_RET_FAILED;  /* "*" is not a valid argument */
	else
		recipient = local_zephyr_normalize(zephyr,args[0]);

}

static PurpleCmdRet zephyr_purple_cmd_zlocate(PurpleConversation *conv,
					  const char *cmd, char **args, char **error, void *data)
{
	zephyr_zloc(purple_conversation_get_connection(conv),args[0]);
	return PURPLE_CMD_RET_OK;
}

static PurpleCmdRet zephyr_purple_cmd_instance(PurpleConversation *conv,
					   const char *cmd, char **args, char **error, void *data)

	/* Currently it sets the instance with leading spaces and
	 * all. This might not be the best thing to do, though having
	 * one word isn't ideal either.	 */

	PurpleConvChat *gcc = purple_conversation_get_chat_data(conv);
	const char* instance = args[0];
	zephyr_chat_set_topic(purple_conversation_get_connection(conv),purple_conv_chat_get_id(gcc),instance);
	return PURPLE_CMD_RET_OK;
}

static PurpleCmdRet zephyr_purple_cmd_joinchat_cir(PurpleConversation *conv,
					       const char *cmd, char **args, char **error, void *data)

	/* Join a new zephyr chat */
	GHashTable *triple = g_hash_table_new(NULL,NULL);
	g_hash_table_insert(triple,"class",args[0]);
	g_hash_table_insert(triple,"instance",args[1]);
	g_hash_table_insert(triple,"recipient",args[2]);
	zephyr_join_chat(purple_conversation_get_connection(conv),triple);
	return PURPLE_CMD_RET_OK;
}

static PurpleCmdRet zephyr_purple_cmd_zi(PurpleConversation *conv,
				     const char *cmd, char **args, char **error, void *data)
{
	/* args = instance, message */
	PurpleConnection *gc = purple_conversation_get_connection(conv);
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	if ( zephyr_send_message(zephyr,"message",args[0],"",args[1],zephyr_get_signature(),""))
		return PURPLE_CMD_RET_OK;
	else
		return PURPLE_CMD_RET_FAILED;
}

static PurpleCmdRet zephyr_purple_cmd_zci(PurpleConversation *conv,
				      const char *cmd, char **args, char **error, void *data)
{
	/* args = class, instance, message */
	PurpleConnection *gc = purple_conversation_get_connection(conv);
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	if ( zephyr_send_message(zephyr,args[0],args[1],"",args[2],zephyr_get_signature(),""))
		return PURPLE_CMD_RET_OK;
	else
		return PURPLE_CMD_RET_FAILED;
}

static PurpleCmdRet zephyr_purple_cmd_zcir(PurpleConversation *conv,
				       const char *cmd, char **args, char **error, void *data)
{
	/* args = class, instance, recipient, message */
	PurpleConnection *gc = purple_conversation_get_connection(conv);
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	if ( zephyr_send_message(zephyr,args[0],args[1],args[2],args[3],zephyr_get_signature(),""))
		return PURPLE_CMD_RET_OK;
	else
		return PURPLE_CMD_RET_FAILED;
}

static PurpleCmdRet zephyr_purple_cmd_zir(PurpleConversation *conv,
				      const char *cmd, char **args, char **error, void *data)
{
	/* args = instance, recipient, message */
	PurpleConnection *gc = purple_conversation_get_connection(conv);
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	if ( zephyr_send_message(zephyr,"message",args[0],args[1],args[2],zephyr_get_signature(),""))
		return PURPLE_CMD_RET_OK;
	else
		return PURPLE_CMD_RET_FAILED;
}

static PurpleCmdRet zephyr_purple_cmd_zc(PurpleConversation *conv,
				     const char *cmd, char **args, char **error, void *data)
{
	/* args = class, message */
	PurpleConnection *gc = purple_conversation_get_connection(conv);
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	if ( zephyr_send_message(zephyr,args[0],"PERSONAL","",args[1],zephyr_get_signature(),""))
		return PURPLE_CMD_RET_OK;
	else
		return PURPLE_CMD_RET_FAILED;
}

static int zephyr_resubscribe(PurpleConnection *gc)
{
	/* Resubscribe to the in-memory list of subscriptions and also
	   unsubscriptions*/
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	GSList *s = zephyr->subscrips;
	zephyr_triple *zt;
	while (s) {
		zt = s->data;
		/* XXX We really should care if this fails */

static void zephyr_action_get_subs_from_server(PurplePluginAction *action)
{
	PurpleConnection *gc = (PurpleConnection *) action->context;
	zephyr_account *zephyr = purple_connection_get_protocol_data(gc);
	gchar *title;
	int retval, nsubs, one,i;
	ZSubscription_t subs;
	if (use_zeph02(zephyr)) {
		GString* subout = g_string_new("Subscription list<br>");

}

static PurplePlugin *my_protocol = NULL;

static PurplePluginProtocolInfo prpl_info = {
	sizeof(PurplePluginProtocolInfo),       /* struct_size */
	OPT_PROTO_CHAT_TOPIC | OPT_PROTO_NO_PASSWORD,
	NULL,					/* ??? user_splits */
	NULL,					/* ??? protocol_options */
	NO_BUDDY_ICONS,
	zephyr_list_icon,

	NULL,					/* chat_whisper -- No "whispering"*/
	zephyr_chat_send,		/* chat_send */
	NULL,					/* keepalive -- Not necessary*/
	NULL,					/* register_user -- Not supported*/
	NULL,					/* XXX get_cb_info */
	NULL,					/* alias_buddy */
	NULL,					/* group_buddy */
	NULL,					/* rename_group */
	NULL,					/* buddy_free */
	NULL,					/* convo_closed */

	NULL,					/* roomlist_room_serialize */

	NULL,
	NULL,
	NULL,
	NULL,					/* get_account_text_table */
	NULL,					/* initate_media */
	NULL,					/* get_media_caps */
	NULL,					/* get_moods */
	NULL,					/* set_public_alias */
	NULL					/* get_public_alias */
};

static PurplePluginInfo info = {
	PURPLE_PLUGIN_MAGIC,
	PURPLE_MAJOR_VERSION,