pidgin: libpurple/protocols/silc/buddy.c comparison

comparison libpurple/protocols/silc/buddy.c @ 18080:bb2e5f6ff2b4

propagate from branch 'im.pidgin.pidgin' (head 5fdf4fa0a7dcefa78c9ec2e7c25b151f1e3acf18) to branch 'im.pidgin.pidgin.2.1.0' (head 1d53de833ec35c1899f24b60e7d79db753917c15)

author	Stu Tomlinson <stu@nosnilmot.com>
date	Sun, 10 Jun 2007 01:46:31 +0000
parents	980a104267da
children	9a96d8711303

comparison

equal deleted inserted replaced

-:c885a9ccd301
+:bb2e5f6ff2b4
 silcpurple_buddy.c
 Author: Pekka Riikonen <priikone@silcnet.org>
-Copyright (C) 2004 Pekka Riikonen
+Copyright (C) 2004 - 2007 Pekka Riikonen
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; version 2 of the License.
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 */
-#include "silcincludes.h"
+#include "silc.h"
 #include "silcclient.h"
 #include "silcpurple.h"
 #include "wb.h"
 /***************************** Key Agreement *********************************/
 static void
 silcpurple_buddy_keyagr(PurpleBlistNode *node, gpointer data);
 static void
 silcpurple_buddy_keyagr_do(PurpleConnection *gc, const char *name,
-			 			 gboolean force_local);
+			   gboolean force_local);
 typedef struct {
 	char *nick;
 	PurpleConnection *gc;
 } *SilcPurpleResolve;
 static void
 silcpurple_buddy_keyagr_resolved(SilcClient client,
-			       SilcClientConnection conn,
+				 SilcClientConnection conn,
-			       SilcClientEntry *clients,
+				 SilcStatus status,
-			       SilcUInt32 clients_count,
+				 SilcDList clients,
-			       void *context)
+				 void *context)
 {
 	PurpleConnection *gc = client->application;
 	SilcPurpleResolve r = context;
 	char tmp[256];
 	silcpurple_buddy_keyagr_do(gc, r->nick, FALSE);
 	silc_free(r->nick);
 	silc_free(r);
 }
-typedef struct {
-	gboolean responder;
-} *SilcPurpleKeyAgr;
 static void
 silcpurple_buddy_keyagr_cb(SilcClient client,
-			 SilcClientConnection conn,
+			   SilcClientConnection conn,
-			 SilcClientEntry client_entry,
+			   SilcClientEntry client_entry,
-			 SilcKeyAgreementStatus status,
+			   SilcKeyAgreementStatus status,
-			 SilcSKEKeyMaterial *key,
+			   SilcSKEKeyMaterial key,
-			 void *context)
+			   void *context)
 {
 	PurpleConnection *gc = client->application;
 	SilcPurple sg = gc->proto_data;
-	SilcPurpleKeyAgr a = context;
 	if (!sg->conn)
 		return;
 	switch (status) {
 			char tmp[128];
 			/* Set the private key for this client */
 			silc_client_del_private_message_key(client, conn, client_entry);
 			silc_client_add_private_message_key_ske(client, conn, client_entry,
-								NULL, NULL, key, a->responder);
+								NULL, NULL, key);
 			silc_ske_free_key_material(key);
 			/* Open IM window */
 			convo = purple_find_conversation_with_account(PURPLE_CONV_TYPE_IM,
-									client_entry->nickname, sg->account);
+								      client_entry->nickname, sg->account);
 			if (convo) {
 				/* we don't have windows in the core anymore...but we may want to
 				 * provide some method for asking the UI to show the window
 				purple_conv_window_show(purple_conversation_get_window(convo));
 				 */
 			} else {
 				convo = purple_conversation_new(PURPLE_CONV_TYPE_IM, sg->account,
-							      client_entry->nickname);
+								client_entry->nickname);
 			}
 			g_snprintf(tmp, sizeof(tmp), "%s [private key]", client_entry->nickname);
 			purple_conversation_set_title(convo, tmp);
 		}
 		break;
 	case SILC_KEY_AGREEMENT_ERROR:
 		purple_notify_error(gc, _("Key Agreement"),
-				  _("Error occurred during key agreement"), NULL);
+				    _("Error occurred during key agreement"), NULL);
 		break;
 	case SILC_KEY_AGREEMENT_FAILURE:
 		purple_notify_error(gc, _("Key Agreement"), _("Key Agreement failed"), NULL);
 		break;
 	case SILC_KEY_AGREEMENT_TIMEOUT:
 		purple_notify_error(gc, _("Key Agreement"),
-				  _("Timeout during key agreement"), NULL);
+				    _("Timeout during key agreement"), NULL);
 		break;
 	case SILC_KEY_AGREEMENT_ABORTED:
 		purple_notify_error(gc, _("Key Agreement"),
-				  _("Key agreement was aborted"), NULL);
+				    _("Key agreement was aborted"), NULL);
 		break;
 	case SILC_KEY_AGREEMENT_ALREADY_STARTED:
 		purple_notify_error(gc, _("Key Agreement"),
-				  _("Key agreement is already started"), NULL);
+				    _("Key agreement is already started"), NULL);
 		break;
 	case SILC_KEY_AGREEMENT_SELF_DENIED:
 		purple_notify_error(gc, _("Key Agreement"),
-				  _("Key agreement cannot be started with yourself"),
+				    _("Key agreement cannot be started with yourself"),
-				  NULL);
+				    NULL);
 		break;
 	default:
 		break;
 	}
-	silc_free(a);
 }
 static void
 silcpurple_buddy_keyagr_do(PurpleConnection *gc, const char *name,
-			 gboolean force_local)
+			   gboolean force_local)
 {
 	SilcPurple sg = gc->proto_data;
-	SilcClientEntry *clients;
+	SilcDList clients;
-	SilcUInt32 clients_count;
+	SilcClientEntry client_entry;
+	SilcClientConnectionParams params;
 	char *local_ip = NULL, *remote_ip = NULL;
 	gboolean local = TRUE;
-	char *nickname;
+	SilcSocket sock;
-	SilcPurpleKeyAgr a;
 	if (!sg->conn || !name)
 		return;
-	if (!silc_parse_userfqdn(name, &nickname, NULL))
-		return;
 	/* Find client entry */
-	clients = silc_client_get_clients_local(sg->client, sg->conn, nickname, name,
+	clients = silc_client_get_clients_local(sg->client, sg->conn, name,
-						&clients_count);
+						FALSE);
 	if (!clients) {
 		/* Resolve unknown user */
 		SilcPurpleResolve r = silc_calloc(1, sizeof(*r));
 		if (!r)
 			return;
 		r->nick = g_strdup(name);
 		r->gc = gc;
-		silc_client_get_clients(sg->client, sg->conn, nickname, NULL,
+		silc_client_get_clients(sg->client, sg->conn, name, NULL,
 					silcpurple_buddy_keyagr_resolved, r);
-		silc_free(nickname);
+		return;
-		return;
+	}
-	}
+	silc_socket_stream_get_info(silc_packet_stream_get_stream(sg->conn->stream),
+				    &sock, NULL, NULL, NULL);
 	/* Resolve the local IP from the outgoing socket connection.  We resolve
 	   it to check whether we have a private range IP address or public IP
 	   address.  If we have public then we will assume that we are not behind
 	   NAT and will provide automatically the point of connection to the
 	   assume that we are chatting in LAN and will provide the point of
 	   connection.
 	   Naturally this algorithm does not always get things right. */
-	if (silc_net_check_local_by_sock(sg->conn->sock->sock, NULL, &local_ip)) {
+	if (silc_net_check_local_by_sock(sock, NULL, &local_ip)) {
 		/* Check if the IP is private */
 		if (!force_local && silcpurple_ip_is_private(local_ip)) {
 			local = FALSE;
 			/* Local IP is private, resolve the remote server IP to see whether
 			   we are talking to Internet or just on LAN. */
-			if (silc_net_check_host_by_sock(sg->conn->sock->sock, NULL,
+			if (silc_net_check_host_by_sock(sock, NULL,
 							&remote_ip))
 				if (silcpurple_ip_is_private(remote_ip))
 					/* We assume we are in LAN.  Let's provide
 					   the connection point. */
 					local = TRUE;
 		local = TRUE;
 	if (local && !local_ip)
 		local_ip = silc_net_localip();
-	a = silc_calloc(1, sizeof(*a));
+	silc_dlist_start(clients);
-	if (!a)
+	client_entry = silc_dlist_get(clients);
-		return;
-	a->responder = local;
+	memset(&params, 0, sizeof(params));
+	params.timeout_secs = 60;
+	if (local)
+	  /* Provide connection point */
+	  params.local_ip = local_ip;
 	/* Send the key agreement request */
-	silc_client_send_key_agreement(sg->client, sg->conn, clients[0],
+	silc_client_send_key_agreement(sg->client, sg->conn, client_entry,
-				       local ? local_ip : NULL, NULL, 0, 60,
+				       &params, sg->public_key,
-				       silcpurple_buddy_keyagr_cb, a);
+				       sg->private_key,
+				       silcpurple_buddy_keyagr_cb, NULL);
 	silc_free(local_ip);
 	silc_free(remote_ip);
-	silc_free(clients);
+	silc_client_list_free(sg->client, sg->conn, clients);
 }
 typedef struct {
 	SilcClient client;
 	SilcClientConnection conn;
 } *SilcPurpleKeyAgrAsk;
 static void
 silcpurple_buddy_keyagr_request_cb(SilcPurpleKeyAgrAsk a, gint id)
 {
-	SilcPurpleKeyAgr ai;
 	SilcClientEntry client_entry;
+	SilcClientConnectionParams params;
 	if (id != 1)
 		goto out;
 	/* Get the client entry. */
 	client_entry = silc_client_get_client_by_id(a->client, a->conn,
 						    &a->client_id);
 	if (!client_entry) {
 		purple_notify_error(a->client->application, _("Key Agreement"),
-				  _("The remote user is not present in the network any more"),
+				    _("The remote user is not present in the network any more"),
-				  NULL);
+				    NULL);
 		goto out;
 	}
 	/* If the hostname was provided by the requestor perform the key agreement
 	   now.  Otherwise, we will send him a request to connect to us. */
 	if (a->hostname) {
-		ai = silc_calloc(1, sizeof(*ai));
+		memset(&params, 0, sizeof(params));
-		if (!ai)
+		params.timeout_secs = 60;
-			goto out;
+		silc_client_perform_key_agreement(a->client, a->conn,
-		ai->responder = FALSE;
+						  client_entry, &params,
-		silc_client_perform_key_agreement(a->client, a->conn, client_entry,
+						  a->conn->public_key,
+						  a->conn->private_key,
 						  a->hostname, a->port,
-						  silcpurple_buddy_keyagr_cb, ai);
+						  silcpurple_buddy_keyagr_cb, NULL);
 	} else {
 		/* Send request.  Force us as the point of connection since requestor
 		   did not provide the point of connection. */
 		silcpurple_buddy_keyagr_do(a->client->application,
-					 client_entry->nickname, TRUE);
+					   client_entry->nickname, TRUE);
 	}
 out:
 	silc_free(a->hostname);
 	silc_free(a);
 }
 void silcpurple_buddy_keyagr_request(SilcClient client,
-				   SilcClientConnection conn,
+				     SilcClientConnection conn,
-				   SilcClientEntry client_entry,
+				     SilcClientEntry client_entry,
-				   const char *hostname, SilcUInt16 port)
+				     const char *hostname, SilcUInt16 port,
+				     SilcUInt16 protocol)
 {
 	char tmp[128], tmp2[128];
 	SilcPurpleKeyAgrAsk a;
 	PurpleConnection *gc = client->application;
+	/* For now Pidgin don't support UDP key agreement */
+	if (protocol == 1)
+	  return;
 	g_snprintf(tmp, sizeof(tmp),
 		   _("Key agreement request received from %s. Would you like to "
 		     "perform the key agreement?"), client_entry->nickname);
 	if (hostname)
 	a = silc_calloc(1, sizeof(*a));
 	if (!a)
 		return;
 	a->client = client;
 	a->conn = conn;
-	a->client_id = *client_entry->id;
+	a->client_id = client_entry->id;
 	if (hostname)
 		a->hostname = strdup(hostname);
 	a->port = port;
 	purple_request_action(client->application, _("Key Agreement Request"), tmp,
-			    hostname ? tmp2 : NULL, 1, gc->account, client_entry->nickname,
+			      hostname ? tmp2 : NULL, 1, gc->account, client_entry->nickname,
-				NULL, a, 2, _("Yes"), G_CALLBACK(silcpurple_buddy_keyagr_request_cb),
+			      NULL, a, 2, _("Yes"), G_CALLBACK(silcpurple_buddy_keyagr_request_cb),
-			    _("No"), G_CALLBACK(silcpurple_buddy_keyagr_request_cb));
+			      _("No"), G_CALLBACK(silcpurple_buddy_keyagr_request_cb));
 }
 static void
 silcpurple_buddy_keyagr(PurpleBlistNode *node, gpointer data)
 {
 silcpurple_buddy_resetkey(PurpleBlistNode *node, gpointer data)
 {
 	PurpleBuddy *b;
 	PurpleConnection *gc;
 SilcPurple sg;
-	char *nickname;
+	SilcDList clients;
-	SilcClientEntry *clients;
-	SilcUInt32 clients_count;
 	g_return_if_fail(PURPLE_BLIST_NODE_IS_BUDDY(node));
 	b = (PurpleBuddy *) node;
 	gc = purple_account_get_connection(b->account);
 	sg = gc->proto_data;
-	if (!silc_parse_userfqdn(b->name, &nickname, NULL))
-		return;
 	/* Find client entry */
 	clients = silc_client_get_clients_local(sg->client, sg->conn,
-						nickname, b->name,
+						b->name, FALSE);
-						&clients_count);
+	if (!clients)
-	if (!clients) {
+		return;
-		silc_free(nickname);
-		return;
+	silc_dlist_start(clients);
-	}
-	clients[0]->prv_resp = FALSE;
 	silc_client_del_private_message_key(sg->client, sg->conn,
-					    clients[0]);
+					    silc_dlist_get(clients));
-	silc_free(clients);
+	silc_client_list_free(sg->client, sg->conn, clients);
-	silc_free(nickname);
 }
 typedef struct {
 	SilcClient client;
 	SilcClientConnection conn;
 	/* Get the client entry. */
 	client_entry = silc_client_get_client_by_id(p->client, p->conn,
 						    &p->client_id);
 	if (!client_entry) {
 		purple_notify_error(p->client->application, _("IM With Password"),
-				  _("The remote user is not present in the network any more"),
+				    _("The remote user is not present in the network any more"),
-				  NULL);
+				    NULL);
 		silc_free(p);
 		return;
 	}
 	/* Set the private message key */
 	silc_client_del_private_message_key(p->client, p->conn,
 					    client_entry);
 	silc_client_add_private_message_key(p->client, p->conn,
 					    client_entry, NULL, NULL,
 					    (unsigned char *)passphrase,
-					    strlen(passphrase), FALSE,
+					    strlen(passphrase));
-					    client_entry->prv_resp);
-	if (!client_entry->prv_resp)
-		silc_client_send_private_message_key_request(p->client,
-							     p->conn,
-							     client_entry);
 silc_free(p);
 }
 static void
 silcpurple_buddy_privkey_resolved(SilcClient client,
-				SilcClientConnection conn,
+				  SilcClientConnection conn,
-				SilcClientEntry *clients,
+				  SilcStatus status,
-				SilcUInt32 clients_count,
+				  SilcDList clients,
-				void *context)
+				  void *context)
 {
 	char tmp[256];
 	if (!clients) {
 		g_snprintf(tmp, sizeof(tmp),
 static void
 silcpurple_buddy_privkey(PurpleConnection *gc, const char *name)
 {
 	SilcPurple sg = gc->proto_data;
-	char *nickname;
 	SilcPurplePrivkey p;
-	SilcClientEntry *clients;
+	SilcDList clients;
-	SilcUInt32 clients_count;
+	SilcClientEntry client_entry;
 	if (!name)
-		return;
-	if (!silc_parse_userfqdn(name, &nickname, NULL))
 		return;
 	/* Find client entry */
 	clients = silc_client_get_clients_local(sg->client, sg->conn,
-						nickname, name,
+						name, FALSE);
-						&clients_count);
 	if (!clients) {
-		silc_client_get_clients(sg->client, sg->conn, nickname, NULL,
+		silc_client_get_clients(sg->client, sg->conn, name, NULL,
 					silcpurple_buddy_privkey_resolved,
 					g_strdup(name));
-		silc_free(nickname);
+		return;
-		return;
+	}
-	}
+	silc_dlist_start(clients);
+	client_entry = silc_dlist_get(clients);
 	p = silc_calloc(1, sizeof(*p));
 	if (!p)
 		return;
 	p->client = sg->client;
 	p->conn = sg->conn;
-	p->client_id = *clients[0]->id;
+	p->client_id = client_entry->id;
 	purple_request_input(gc, _("IM With Password"), NULL,
 	                     _("Set IM Password"), NULL, FALSE, TRUE, NULL,
 	                     _("OK"), G_CALLBACK(silcpurple_buddy_privkey_cb),
 	                     _("Cancel"), G_CALLBACK(silcpurple_buddy_privkey_cb),
 	                     gc->account, NULL, NULL, p);
-	silc_free(clients);
+	silc_client_list_free(sg->client, sg->conn, clients);
-	silc_free(nickname);
 }
 static void
 silcpurple_buddy_privkey_menu(PurpleBlistNode *node, gpointer data)
 {
 } *SilcPurpleBuddyGetkey;
 static void
 silcpurple_buddy_getkey(PurpleConnection *gc, const char *name);
-static void
+static SilcBool
-silcpurple_buddy_getkey_cb(SilcPurpleBuddyGetkey g,
+silcpurple_buddy_getkey_cb(SilcClient client, SilcClientConnection conn,
-			 SilcClientCommandReplyContext cmd)
+			   SilcCommand command, SilcStatus status,
+			   SilcStatus error, void *context, va_list ap)
 {
 	SilcClientEntry client_entry;
-	unsigned char *pk;
+	SilcPurpleBuddyGetkey g = context;
-	SilcUInt32 pk_len;
+	if (status != SILC_STATUS_OK) {
+		purple_notify_error(g->client->application, _("Get Public Key"),
+				  _("The remote user is not present in the network any more"),
+				  NULL);
+		silc_free(g);
+		return FALSE;
+	}
 	/* Get the client entry. */
 	client_entry = silc_client_get_client_by_id(g->client, g->conn,
 						    &g->client_id);
 	if (!client_entry) {
 		purple_notify_error(g->client->application, _("Get Public Key"),
 				  _("The remote user is not present in the network any more"),
 				  NULL);
 		silc_free(g);
-		return;
+		return FALSE;
 	}
 	if (!client_entry->public_key) {
 		silc_free(g);
-		return;
+		return FALSE;
 	}
 	/* Now verify the public key */
-	pk = silc_pkcs_public_key_encode(client_entry->public_key, &pk_len);
 	silcpurple_verify_public_key(g->client, g->conn, client_entry->nickname,
-				   SILC_SOCKET_TYPE_CLIENT,
+				     SILC_CONN_CLIENT, client_entry->public_key,
-				   pk, pk_len, SILC_SKE_PK_TYPE_SILC,
+				     NULL, NULL);
-				   NULL, NULL);
-	silc_free(pk);
 	silc_free(g);
+	return TRUE;
 }
 static void
 silcpurple_buddy_getkey_resolved(SilcClient client,
-			       SilcClientConnection conn,
+				 SilcClientConnection conn,
-			       SilcClientEntry *clients,
+				 SilcStatus status,
-			       SilcUInt32 clients_count,
+				 SilcDList clients,
-			       void *context)
+				 void *context)
 {
 	char tmp[256];
 	if (!clients) {
 		g_snprintf(tmp, sizeof(tmp),
 			   _("User %s is not present in the network"),
 			   (const char *)context);
 		purple_notify_error(client->application, _("Get Public Key"),
-				  _("Cannot fetch the public key"), tmp);
+				    _("Cannot fetch the public key"), tmp);
 		g_free(context);
 		return;
 	}
 	silcpurple_buddy_getkey(client->application, context);
 silcpurple_buddy_getkey(PurpleConnection *gc, const char *name)
 {
 	SilcPurple sg = gc->proto_data;
 	SilcClient client = sg->client;
 	SilcClientConnection conn = sg->conn;
-	SilcClientEntry *clients;
+	SilcClientEntry client_entry;
-	SilcUInt32 clients_count;
+	SilcDList clients;
 	SilcPurpleBuddyGetkey g;
-	char *nickname;
+	SilcUInt16 cmd_ident;
 	if (!name)
 		return;
-	if (!silc_parse_userfqdn(name, &nickname, NULL))
-		return;
 	/* Find client entry */
-	clients = silc_client_get_clients_local(client, conn, nickname, name,
+	clients = silc_client_get_clients_local(client, conn, name, FALSE);
-						&clients_count);
 	if (!clients) {
-		silc_client_get_clients(client, conn, nickname, NULL,
+		silc_client_get_clients(client, conn, name, NULL,
 					silcpurple_buddy_getkey_resolved,
 					g_strdup(name));
-		silc_free(nickname);
+		return;
-		return;
+	}
-	}
+	silc_dlist_start(clients);
+	client_entry = silc_dlist_get(clients);
 	/* Call GETKEY */
 	g = silc_calloc(1, sizeof(*g));
 	if (!g)
 		return;
 	g->client = client;
 	g->conn = conn;
-	g->client_id = *clients[0]->id;
+	g->client_id = client_entry->id;
-	silc_client_command_call(client, conn, NULL, "GETKEY",
+	cmd_ident = silc_client_command_call(client, conn, NULL, "GETKEY",
-				 clients[0]->nickname, NULL);
+					     client_entry->nickname, NULL);
-	silc_client_command_pending(conn, SILC_COMMAND_GETKEY,
+	silc_client_command_pending(conn, SILC_COMMAND_GETKEY, cmd_ident,
-				    conn->cmd_ident,
+				    silcpurple_buddy_getkey_cb, g);
-				    (SilcCommandCb)silcpurple_buddy_getkey_cb, g);
+	silc_client_list_free(client, conn, clients);
-	silc_free(clients);
-	silc_free(nickname);
 }
 static void
 silcpurple_buddy_getkey_menu(PurpleBlistNode *node, gpointer data)
 {
 	b = (PurpleBuddy *) node;
 	gc = purple_account_get_connection(b->account);
 	sg = gc->proto_data;
 	pkfile = purple_blist_node_get_string(node, "public-key");
-	if (!silc_pkcs_load_public_key(pkfile, &public_key, SILC_PKCS_FILE_PEM) &&
+	if (!silc_pkcs_load_public_key(pkfile, &public_key)) {
-	    !silc_pkcs_load_public_key(pkfile, &public_key, SILC_PKCS_FILE_BIN)) {
 		purple_notify_error(gc,
 				  _("Show Public Key"),
 				  _("Could not load public key"), NULL);
 		return;
 	}
 	SilcClientConnection conn;
 	SilcClientID client_id;
 	PurpleBuddy *b;
 	unsigned char *offline_pk;
 	SilcUInt32 offline_pk_len;
+	SilcPublicKey public_key;
 	unsigned int offline        : 1;
 	unsigned int pubkey_search  : 1;
 	unsigned int init           : 1;
 } *SilcPurpleBuddyRes;
 static void
 silcpurple_add_buddy_ask_pk_cb(SilcPurpleBuddyRes r, gint id);
 static void
 silcpurple_add_buddy_resolved(SilcClient client,
-			    SilcClientConnection conn,
+			      SilcClientConnection conn,
-			    SilcClientEntry *clients,
+			      SilcStatus status,
-			    SilcUInt32 clients_count,
+			      SilcDList clients,
-			    void *context);
+			      void *context);
 void silcpurple_get_info(PurpleConnection *gc, const char *who)
 {
 	SilcPurple sg = gc->proto_data;
 	SilcClient client = sg->client;
 {
 	char tmp[512];
 	g_snprintf(tmp, sizeof(tmp), _("The %s buddy is not trusted"),
 		   r->b->name);
 	purple_notify_error(r->client->application, _("Add Buddy"), tmp,
-			  _("You cannot receive buddy notifications until you "
+			    _("You cannot receive buddy notifications until you "
-			    "import his/her public key.  You can use the Get Public Key "
+			      "import his/her public key.  You can use the Get Public Key "
-			    "command to get the public key."));
+			      "command to get the public key."));
 	purple_prpl_got_user_status(purple_buddy_get_account(r->b), purple_buddy_get_name(r->b), SILCPURPLE_STATUS_ID_OFFLINE, NULL);
 }
 static void
-silcpurple_add_buddy_save(bool success, void *context)
+silcpurple_add_buddy_save(SilcBool success, void *context)
 {
 	SilcPurpleBuddyRes r = context;
 	PurpleBuddy *b = r->b;
-	SilcClient client = r->client;
 	SilcClientEntry client_entry;
 	SilcAttributePayload attr;
 	SilcAttribute attribute;
 	SilcVCardStruct vcard;
-	SilcAttributeObjMime message, extension;
+	SilcMime message = NULL, extension = NULL;
 #ifdef SILC_ATTRIBUTE_USER_ICON
-	SilcAttributeObjMime usericon;
+	SilcMime usericon = NULL;
 #endif
 	SilcAttributeObjPk serverpk, usersign, serversign;
 	gboolean usign_success = TRUE, ssign_success = TRUE;
 	char filename[512], filename2[512], *fingerprint = NULL, *tmp;
 	SilcUInt32 len;
+	SilcHash hash;
 	int i;
 	if (!success) {
 		/* The user did not trust the public key. */
 		silcpurple_add_buddy_pk_no(r);
+		silc_free(r->offline_pk);
+		if (r->public_key)
+		  silc_pkcs_public_key_free(r->public_key);
 		silc_free(r);
 		return;
 	}
 	if (r->offline) {
 			   silcpurple_silcdir(), fingerprint);
 		purple_blist_node_set_string((PurpleBlistNode *)b, "public-key", filename);
 		purple_prpl_got_user_status(purple_buddy_get_account(r->b), purple_buddy_get_name(r->b), SILCPURPLE_STATUS_ID_OFFLINE, NULL);
 		silc_free(fingerprint);
 		silc_free(r->offline_pk);
+		if (r->public_key)
+		  silc_pkcs_public_key_free(r->public_key);
 		silc_free(r);
 		return;
 	}
 	/* Get the client entry. */
 	client_entry = silc_client_get_client_by_id(r->client, r->conn,
 						    &r->client_id);
 	if (!client_entry) {
+		silc_free(r->offline_pk);
+		silc_pkcs_public_key_free(r->public_key);
+		if (r->public_key)
+		  silc_pkcs_public_key_free(r->public_key);
 		silc_free(r);
 		return;
 	}
 	memset(&vcard, 0, sizeof(vcard));
-	memset(&message, 0, sizeof(message));
-	memset(&extension, 0, sizeof(extension));
-#ifdef SILC_ATTRIBUTE_USER_ICON
-	memset(&usericon, 0, sizeof(usericon));
-#endif
 	memset(&serverpk, 0, sizeof(serverpk));
 	memset(&usersign, 0, sizeof(usersign));
 	memset(&serversign, 0, sizeof(serversign));
 	/* Now that we have the public key and we trust it now we
 							       sizeof(vcard)))
 					continue;
 				break;
 			case SILC_ATTRIBUTE_STATUS_MESSAGE:
-				if (!silc_attribute_get_object(attr, (void *)&message,
+				message = silc_mime_alloc();
-							       sizeof(message)))
+				if (!silc_attribute_get_object(attr, (void *)message,
+							       sizeof(*message)))
 					continue;
 				break;
 			case SILC_ATTRIBUTE_EXTENSION:
-				if (!silc_attribute_get_object(attr, (void *)&extension,
+				extension = silc_mime_alloc();
-							       sizeof(extension)))
+				if (!silc_attribute_get_object(attr, (void *)extension,
+							       sizeof(*extension)))
 					continue;
 				break;
 #ifdef SILC_ATTRIBUTE_USER_ICON
 			case SILC_ATTRIBUTE_USER_ICON:
-				if (!silc_attribute_get_object(attr, (void *)&usericon,
+				usericon = silc_mime_alloc();
-							       sizeof(usericon)))
+				if (!silc_attribute_get_object(attr, (void *)usericon,
+							       sizeof(*usericon)))
 					continue;
 				break;
 #endif
 			case SILC_ATTRIBUTE_SERVER_PUBLIC_KEY:
 			}
 		}
 	}
 	/* Verify the attribute signatures */
+	silc_hash_alloc((const unsigned char *)"sha1", &hash);
 	if (usersign.data) {
-		SilcPKCS pkcs;
 		unsigned char *verifyd;
 		SilcUInt32 verify_len;
-		silc_pkcs_alloc((unsigned char*)"rsa", &pkcs);
 		verifyd = silc_attribute_get_verify_data(client_entry->attrs,
 							 FALSE, &verify_len);
-		if (verifyd && silc_pkcs_public_key_set(pkcs, client_entry->public_key)){
+		if (verifyd && !silc_pkcs_verify(client_entry->public_key,
-			if (!silc_pkcs_verify_with_hash(pkcs, client->sha1hash,
+						 usersign.data,
-							usersign.data,
+						 usersign.data_len,
-							usersign.data_len,
+						 verifyd, verify_len, hash))
-							verifyd, verify_len))
+			usign_success = FALSE;
-				usign_success = FALSE;
-		}
 		silc_free(verifyd);
 	}
-	if (serversign.data && !strcmp(serverpk.type, "silc-rsa")) {
+	if (serversign.data) {
 		SilcPublicKey public_key;
-		SilcPKCS pkcs;
+		SilcPKCSType type = 0;
 		unsigned char *verifyd;
 		SilcUInt32 verify_len;
-		if (silc_pkcs_public_key_decode(serverpk.data, serverpk.data_len,
+		if (!strcmp(serverpk.type, "silc-rsa"))
-						&public_key)) {
+		  type = SILC_PKCS_SILC;
-			silc_pkcs_alloc((unsigned char *)"rsa", &pkcs);
+		else if (!strcmp(serverpk.type, "ssh-rsa"))
+		  type = SILC_PKCS_SSH2;
+		else if (!strcmp(serverpk.type, "x509v3-sign-rsa"))
+		  type = SILC_PKCS_X509V3;
+		else if (!strcmp(serverpk.type, "pgp-sign-rsa"))
+		  type = SILC_PKCS_OPENPGP;
+		if (silc_pkcs_public_key_alloc(type, serverpk.data,
+					       serverpk.data_len,
+					       &public_key)) {
 			verifyd = silc_attribute_get_verify_data(client_entry->attrs,
 								 TRUE, &verify_len);
-			if (verifyd && silc_pkcs_public_key_set(pkcs, public_key)) {
+			if (verifyd && !silc_pkcs_verify(public_key,
-				if (!silc_pkcs_verify_with_hash(pkcs, client->sha1hash,
+							 serversign.data,
-							       serversign.data,
+							 serversign.data_len,
-							       serversign.data_len,
+							 verifyd, verify_len,
-							       verifyd, verify_len))
+							 hash))
-					ssign_success = FALSE;
+				ssign_success = FALSE;
-			}
 			silc_pkcs_public_key_free(public_key);
 			silc_free(verifyd);
 		}
 	}
-	fingerprint = silc_fingerprint(client_entry->fingerprint,
+	fingerprint = silc_fingerprint(client_entry->fingerprint, 20);
-				       client_entry->fingerprint_len);
 	for (i = 0; i < strlen(fingerprint); i++)
 		if (fingerprint[i] == ' ')
 			fingerprint[i] = '_';
 	if (usign_success || ssign_success) {
 			silc_file_writefile(filename2, tmp, len);
 			silc_free(tmp);
 		}
 		/* Save status message */
-		if (message.mime) {
+		if (message) {
 			memset(filename2, 0, sizeof(filename2));
 			g_snprintf(filename2, sizeof(filename2) - 1,
 				   "%s" G_DIR_SEPARATOR_S "status_message.mime",
 				   filename);
-			silc_file_writefile(filename2, (char *)message.mime,
+			tmp = (char *)silc_mime_get_data(message, &len);
-					    message.mime_len);
+			silc_file_writefile(filename2, tmp, len);
+			silc_mime_free(message);
 		}
 		/* Save extension data */
-		if (extension.mime) {
+		if (extension) {
 			memset(filename2, 0, sizeof(filename2));
 			g_snprintf(filename2, sizeof(filename2) - 1,
 				   "%s" G_DIR_SEPARATOR_S "extension.mime",
 				   filename);
-			silc_file_writefile(filename2, (char *)extension.mime,
+			tmp = (char *)silc_mime_get_data(extension, &len);
-					    extension.mime_len);
+			silc_file_writefile(filename2, tmp, len);
+			silc_mime_free(extension);
 		}
 #ifdef SILC_ATTRIBUTE_USER_ICON
 		/* Save user icon */
-		if (usericon.mime) {
+		if (usericon) {
-			SilcMime m = silc_mime_decode(usericon.mime,
+			const char *type = silc_mime_get_field(usericon, "Content-Type");
-						      usericon.mime_len);
+			if (type &&
-			if (m) {
+			    (!strcmp(type, "image/jpeg") ||
-				const char *type = silc_mime_get_field(m, "Content-Type");
+			     !strcmp(type, "image/gif") ||
-				if (!strcmp(type, "image/jpeg") ||
+			     !strcmp(type, "image/bmp") ||
-				    !strcmp(type, "image/gif") ||
+			     !strcmp(type, "image/png"))) {
-				    !strcmp(type, "image/bmp") ||
+				const unsigned char *data;
-				    !strcmp(type, "image/png")) {
+				SilcUInt32 data_len;
-					const unsigned char *data;
+				data = silc_mime_get_data(usericon, &data_len);
-					SilcUInt32 data_len;
+				if (data) {
-					data = silc_mime_get_data(m, &data_len);
+					/* TODO: Check if SILC gives us something to use as the checksum instead */
-					if (data) {
+					purple_buddy_icons_set_for_user(purple_buddy_get_account(r->b), purple_buddy_get_name(r->b), g_memdup(data, data_len), data_len, NULL);
-						/* TODO: Check if SILC gives us something to use as the checksum instead */
-						purple_buddy_icons_set_for_user(purple_buddy_get_account(r->b), purple_buddy_get_name(r->b), g_memdup(data, data_len), data_len, NULL);
-					}
 				}
-				silc_mime_free(m);
 			}
+			silc_mime_free(usericon);
 		}
 #endif
 	}
 	/* Save the public key path to buddy properties, as it is used
 	   changes from the server */
 	g_snprintf(filename2, sizeof(filename2) - 1, "+%s", filename);
 	silc_client_command_call(r->client, r->conn, NULL, "WATCH", "-pubkey",
 				 filename2, NULL);
+	silc_hash_free(hash);
 	silc_free(fingerprint);
+	silc_free(r->offline_pk);
+	if (r->public_key)
+	  silc_pkcs_public_key_free(r->public_key);
 	silc_free(r);
 }
 static void
 silcpurple_add_buddy_ask_import(void *user_data, const char *name)
 {
 	SilcPurpleBuddyRes r = (SilcPurpleBuddyRes)user_data;
-	SilcPublicKey public_key;
 	/* Load the public key */
-	if (!silc_pkcs_load_public_key(name, &public_key, SILC_PKCS_FILE_PEM) &&
+	if (!silc_pkcs_load_public_key(name, &r->public_key)) {
-	    !silc_pkcs_load_public_key(name, &public_key, SILC_PKCS_FILE_BIN)) {
 		silcpurple_add_buddy_ask_pk_cb(r, 0);
 		purple_notify_error(r->client->application,
 				  _("Add Buddy"), _("Could not load public key"), NULL);
 		return;
 	}
 	/* Now verify the public key */
-	r->offline_pk = silc_pkcs_public_key_encode(public_key, &r->offline_pk_len);
+	r->offline_pk = silc_pkcs_public_key_encode(r->public_key, &r->offline_pk_len);
 	silcpurple_verify_public_key(r->client, r->conn, r->b->name,
-				   SILC_SOCKET_TYPE_CLIENT,
+				     SILC_CONN_CLIENT, r->public_key,
-				   r->offline_pk, r->offline_pk_len,
+				     silcpurple_add_buddy_save, r);
-				   SILC_SKE_PK_TYPE_SILC,
-				   silcpurple_add_buddy_save, r);
 }
 static void
 silcpurple_add_buddy_ask_pk_cancel(void *user_data, const char *name)
 {
 		return;
 	}
 	/* Open file selector to select the public key. */
 	purple_request_file(r->client->application, _("Open..."), NULL, FALSE,
-			  G_CALLBACK(silcpurple_add_buddy_ask_import),
+			    G_CALLBACK(silcpurple_add_buddy_ask_import),
-			  G_CALLBACK(silcpurple_add_buddy_ask_pk_cancel),
+			    G_CALLBACK(silcpurple_add_buddy_ask_pk_cancel),
-			  purple_buddy_get_account(r->b), purple_buddy_get_name(r->b), NULL, r);
+			    purple_buddy_get_account(r->b), purple_buddy_get_name(r->b), NULL, r);
 }
 static void
 silcpurple_add_buddy_ask_pk(SilcPurpleBuddyRes r)
 {
 	char tmp[512];
 	g_snprintf(tmp, sizeof(tmp), _("The %s buddy is not present in the network"),
 		   r->b->name);
 	purple_request_action(r->client->application, _("Add Buddy"), tmp,
-			    _("To add the buddy you must import his/her public key. "
+			      _("To add the buddy you must import his/her public key. "
-			      "Press Import to import a public key."), 0,
+				"Press Import to import a public key."), 0,
-				  purple_buddy_get_account(r->b), purple_buddy_get_name(r->b), NULL, r, 2,
+			      purple_buddy_get_account(r->b), purple_buddy_get_name(r->b), NULL, r, 2,
-			    _("Cancel"), G_CALLBACK(silcpurple_add_buddy_ask_pk_cb),
+			      _("Cancel"), G_CALLBACK(silcpurple_add_buddy_ask_pk_cb),
-			    _("_Import..."), G_CALLBACK(silcpurple_add_buddy_ask_pk_cb));
+			      _("_Import..."), G_CALLBACK(silcpurple_add_buddy_ask_pk_cb));
 }
-static void
+static SilcBool
-silcpurple_add_buddy_getkey_cb(SilcPurpleBuddyRes r,
+silcpurple_add_buddy_getkey_cb(SilcClient client, SilcClientConnection conn,
-			     SilcClientCommandReplyContext cmd)
+			       SilcCommand command, SilcStatus status,
-{
+			       SilcStatus error, void *context, va_list ap)
+{
+	SilcPurpleBuddyRes r = context;
 	SilcClientEntry client_entry;
-	unsigned char *pk;
-	SilcUInt32 pk_len;
+	if (status != SILC_STATUS_OK) {
+		/* The buddy is offline/nonexistent. We will require user
+		   to associate a public key with the buddy or the buddy
+		   cannot be added. */
+		r->offline = TRUE;
+		silcpurple_add_buddy_ask_pk(r);
+		return FALSE;
+	}
 	/* Get the client entry. */
 	client_entry = silc_client_get_client_by_id(r->client, r->conn,
 						    &r->client_id);
 	if (!client_entry || !client_entry->public_key) {
 		/* The buddy is offline/nonexistent. We will require user
 		   to associate a public key with the buddy or the buddy
 		   cannot be added. */
 		r->offline = TRUE;
 		silcpurple_add_buddy_ask_pk(r);
-		return;
+		return FALSE;
 	}
 	/* Now verify the public key */
-	pk = silc_pkcs_public_key_encode(client_entry->public_key, &pk_len);
 	silcpurple_verify_public_key(r->client, r->conn, client_entry->nickname,
-				   SILC_SOCKET_TYPE_CLIENT,
+				     SILC_CONN_CLIENT, client_entry->public_key,
-				   pk, pk_len, SILC_SKE_PK_TYPE_SILC,
+				     silcpurple_add_buddy_save, r);
-				   silcpurple_add_buddy_save, r);
+	return TRUE;
-	silc_free(pk);
 }
 static void
 silcpurple_add_buddy_select_cb(SilcPurpleBuddyRes r, PurpleRequestFields *fields)
 {
 	PurpleRequestField *f;
 	const GList *list;
 	SilcClientEntry client_entry;
+	SilcDList clients;
 	f = purple_request_fields_get_field(fields, "list");
 	list = purple_request_field_list_get_selected(f);
 	if (!list) {
 		/* The user did not select any user. */
 		silc_free(r);
 		return;
 	}
 	client_entry = purple_request_field_list_get_data(f, list->data);
-	silcpurple_add_buddy_resolved(r->client, r->conn, &client_entry, 1, r);
+	clients = silc_dlist_init();
+	silc_dlist_add(clients, client_entry);
+	silcpurple_add_buddy_resolved(r->client, r->conn, SILC_STATUS_OK,
+				      clients, r);
+	silc_dlist_uninit(clients);
 }
 static void
 silcpurple_add_buddy_select_cancel(SilcPurpleBuddyRes r, PurpleRequestFields *fields)
 {
 	silcpurple_add_buddy_pk_no(r);
 	silc_free(r);
 }
 static void
-silcpurple_add_buddy_select(SilcPurpleBuddyRes r,
+silcpurple_add_buddy_select(SilcPurpleBuddyRes r, SilcDList clients)
-			  SilcClientEntry *clients,
-			  SilcUInt32 clients_count)
 {
 	PurpleRequestFields *fields;
 	PurpleRequestFieldGroup *g;
 	PurpleRequestField *f;
 	char tmp[512], tmp2[128];
-	int i;
 	char *fingerprint;
+	SilcClientEntry client_entry;
 	fields = purple_request_fields_new();
 	g = purple_request_field_group_new(NULL);
 	f = purple_request_field_list_new("list", NULL);
 	purple_request_field_group_add_field(g, f);
 	purple_request_field_list_set_multi_select(f, FALSE);
 	purple_request_fields_add_group(fields, g);
-	for (i = 0; i < clients_count; i++) {
+	silc_dlist_start(clients);
+	while ((client_entry = silc_dlist_get(clients))) {
 		fingerprint = NULL;
-		if (clients[i]->fingerprint) {
+		if (*client_entry->fingerprint) {
-			fingerprint = silc_fingerprint(clients[i]->fingerprint,
+			fingerprint = silc_fingerprint(client_entry->fingerprint, 20);
-						       clients[i]->fingerprint_len);
 			g_snprintf(tmp2, sizeof(tmp2), "\n%s", fingerprint);
 		}
 		g_snprintf(tmp, sizeof(tmp), "%s - %s (%s@%s)%s",
-			   clients[i]->realname, clients[i]->nickname,
+			   client_entry->realname, client_entry->nickname,
-			   clients[i]->username, clients[i]->hostname ?
+			   client_entry->username, *client_entry->hostname ?
-			   clients[i]->hostname : "",
+			   client_entry->hostname : "",
 			   fingerprint ? tmp2 : "");
-		purple_request_field_list_add(f, tmp, clients[i]);
+		purple_request_field_list_add(f, tmp, client_entry);
 		silc_free(fingerprint);
 	}
 	purple_request_fields(r->client->application, _("Add Buddy"),
-				_("Select correct user"),
+			      _("Select correct user"),
-				r->pubkey_search
+			      r->pubkey_search
-					? _("More than one user was found with the same public key. Select "
+			      ? _("More than one user was found with the same public key. Select "
-						"the correct user from the list to add to the buddy list.")
+				  "the correct user from the list to add to the buddy list.")
-					: _("More than one user was found with the same name. Select "
+			      : _("More than one user was found with the same name. Select "
-						"the correct user from the list to add to the buddy list."),
+				  "the correct user from the list to add to the buddy list."),
-				fields,
+			      fields,
-				_("OK"), G_CALLBACK(silcpurple_add_buddy_select_cb),
+			      _("OK"), G_CALLBACK(silcpurple_add_buddy_select_cb),
-				_("Cancel"), G_CALLBACK(silcpurple_add_buddy_select_cancel),
+			      _("Cancel"), G_CALLBACK(silcpurple_add_buddy_select_cancel),
-				purple_buddy_get_account(r->b), purple_buddy_get_name(r->b), NULL, r);
+			      purple_buddy_get_account(r->b), purple_buddy_get_name(r->b), NULL, r);
 }
 static void
 silcpurple_add_buddy_resolved(SilcClient client,
-			    SilcClientConnection conn,
+			      SilcClientConnection conn,
-			    SilcClientEntry *clients,
+			      SilcStatus status,
-			    SilcUInt32 clients_count,
+			      SilcDList clients,
-			    void *context)
+			      void *context)
 {
 	SilcPurpleBuddyRes r = context;
 	PurpleBuddy *b = r->b;
 	SilcAttributePayload pub;
 	SilcAttributeObjPk userpk;
-	unsigned char *pk;
-	SilcUInt32 pk_len;
 	const char *filename;
+	SilcClientEntry client_entry = NULL;
+	SilcUInt16 cmd_ident;
 	filename = purple_blist_node_get_string((PurpleBlistNode *)b, "public-key");
 	/* If the buddy is offline/nonexistent, we will require user
 	   to associate a public key with the buddy or the buddy
 	   cannot be added. */
-	if (!clients_count) {
+	if (!clients) {
 		if (r->init) {
 			silc_free(r);
 			return;
 		}
 		return;
 	}
 	/* If more than one client was found with nickname, we need to verify
 	   from user which one is the correct. */
-	if (clients_count > 1 && !r->pubkey_search) {
+	if (silc_dlist_count(clients) > 1 && !r->pubkey_search) {
 		if (r->init) {
 			silc_free(r);
 			return;
 		}
-		silcpurple_add_buddy_select(r, clients, clients_count);
+		silcpurple_add_buddy_select(r, clients);
 		return;
 	}
+	silc_dlist_start(clients);
+	client_entry = silc_dlist_get(clients);
 	/* If we searched using public keys and more than one entry was found
 	   the same person is logged on multiple times. */
-	if (clients_count > 1 && r->pubkey_search && b->name) {
+	if (silc_dlist_count(clients) > 1 && r->pubkey_search && b->name) {
 		if (r->init) {
 			/* Find the entry that closest matches to the
 			   buddy nickname. */
-			int i;
+			SilcClientEntry entry;
-			for (i = 0; i < clients_count; i++) {
+			silc_dlist_start(clients);
-				if (!strncasecmp(b->name, clients[i]->nickname,
+			while ((entry = silc_dlist_get(clients))) {
+				if (!strncasecmp(b->name, entry->nickname,
 						 strlen(b->name))) {
-					clients[0] = clients[i];
+					client_entry = entry;
 					break;
 				}
 			}
 		} else {
 			/* Verify from user which one is correct */
-			silcpurple_add_buddy_select(r, clients, clients_count);
+			silcpurple_add_buddy_select(r, clients);
 			return;
 		}
 	}
 	/* The client was found.  Now get its public key and verify
 	   that before adding the buddy. */
 	memset(&userpk, 0, sizeof(userpk));
-	b->proto_data = silc_memdup(clients[0]->id, sizeof(*clients[0]->id));
+	b->proto_data = silc_memdup(&client_entry->id, sizeof(client_entry->id));
-	r->client_id = *clients[0]->id;
+	r->client_id = client_entry->id;
 	/* Get the public key from attributes, if not present then
 	   resolve it with GETKEY unless we have it cached already. */
-	if (clients[0]->attrs && !clients[0]->public_key) {
+	if (client_entry->attrs && !client_entry->public_key) {
-		pub = silcpurple_get_attr(clients[0]->attrs,
+		pub = silcpurple_get_attr(client_entry->attrs,
-					SILC_ATTRIBUTE_USER_PUBLIC_KEY);
+					  SILC_ATTRIBUTE_USER_PUBLIC_KEY);
 		if (!pub || !silc_attribute_get_object(pub, (void *)&userpk,
 						       sizeof(userpk))) {
 			/* Get public key with GETKEY */
-			silc_client_command_call(client, conn, NULL,
+			cmd_ident =
-						 "GETKEY", clients[0]->nickname, NULL);
+			  silc_client_command_call(client, conn, NULL,
+						   "GETKEY", client_entry->nickname, NULL);
 			silc_client_command_pending(conn, SILC_COMMAND_GETKEY,
-						    conn->cmd_ident,
+						    cmd_ident,
-						    (SilcCommandCb)silcpurple_add_buddy_getkey_cb,
+						    silcpurple_add_buddy_getkey_cb,
 						    r);
 			return;
 		}
-		if (!silc_pkcs_public_key_decode(userpk.data, userpk.data_len,
+		if (!silc_pkcs_public_key_alloc(SILC_PKCS_SILC,
-						 &clients[0]->public_key))
+						userpk.data, userpk.data_len,
+						&client_entry->public_key))
 			return;
 		silc_free(userpk.data);
-	} else if (filename && !clients[0]->public_key) {
+	} else if (filename && !client_entry->public_key) {
-		if (!silc_pkcs_load_public_key(filename, &clients[0]->public_key,
+		if (!silc_pkcs_load_public_key(filename, &client_entry->public_key)) {
-					       SILC_PKCS_FILE_PEM) &&
-		    !silc_pkcs_load_public_key(filename, &clients[0]->public_key,
-					       SILC_PKCS_FILE_BIN)) {
 			/* Get public key with GETKEY */
-			silc_client_command_call(client, conn, NULL,
+			cmd_ident =
-						 "GETKEY", clients[0]->nickname, NULL);
+			  silc_client_command_call(client, conn, NULL,
+						   "GETKEY", client_entry->nickname, NULL);
 			silc_client_command_pending(conn, SILC_COMMAND_GETKEY,
-						    conn->cmd_ident,
+						    cmd_ident,
-						    (SilcCommandCb)silcpurple_add_buddy_getkey_cb,
+						    silcpurple_add_buddy_getkey_cb,
 						    r);
 			return;
 		}
-	} else if (!clients[0]->public_key) {
+	} else if (!client_entry->public_key) {
 		/* Get public key with GETKEY */
-		silc_client_command_call(client, conn, NULL,
+		cmd_ident =
-					 "GETKEY", clients[0]->nickname, NULL);
+		  silc_client_command_call(client, conn, NULL,
+					   "GETKEY", client_entry->nickname, NULL);
 		silc_client_command_pending(conn, SILC_COMMAND_GETKEY,
-					    conn->cmd_ident,
+					    cmd_ident,
-					    (SilcCommandCb)silcpurple_add_buddy_getkey_cb,
+					    silcpurple_add_buddy_getkey_cb,
 					    r);
 		return;
 	}
 	/* We have the public key, verify it. */
-	pk = silc_pkcs_public_key_encode(clients[0]->public_key, &pk_len);
+	silcpurple_verify_public_key(client, conn, client_entry->nickname,
-	silcpurple_verify_public_key(client, conn, clients[0]->nickname,
+				     SILC_CONN_CLIENT,
-				   SILC_SOCKET_TYPE_CLIENT,
+				     client_entry->public_key,
-				   pk, pk_len, SILC_SKE_PK_TYPE_SILC,
+				     silcpurple_add_buddy_save, r);
-				   silcpurple_add_buddy_save, r);
-	silc_free(pk);
 }
 static void
 silcpurple_add_buddy_i(PurpleConnection *gc, PurpleBuddy *b, gboolean init)
 {
 	filename = purple_blist_node_get_string((PurpleBlistNode *)b, "public-key");
 	if (filename) {
 		SilcPublicKey public_key;
 		SilcAttributeObjPk userpk;
-		if (!silc_pkcs_load_public_key(filename, &public_key,
+		if (!silc_pkcs_load_public_key(filename, &public_key))
-					       SILC_PKCS_FILE_PEM) &&
-		    !silc_pkcs_load_public_key(filename, &public_key,
-					       SILC_PKCS_FILE_BIN))
 			return;
 		/* Get all attributes, and use the public key to search user */
 		name = NULL;
 		attrs = silc_client_attributes_request(SILC_ATTRIBUTE_USER_INFO,
 	pkfile = purple_blist_node_get_string((PurpleBlistNode *) buddy, "public-key");
 	client_entry = silc_client_get_client_by_id(sg->client,
 						    sg->conn,
 						    buddy->proto_data);
-	if (client_entry && client_entry->send_key) {
+	if (client_entry &&
+	    silc_client_private_message_key_is_set(sg->client,
+						   sg->conn, client_entry)) {
 		act = purple_menu_action_new(_("Reset IM Key"),
 		                           PURPLE_CALLBACK(silcpurple_buddy_resetkey),
 		                           NULL, NULL);
 		m = g_list_append(m, act);
 	} else {
 		act = purple_menu_action_new(_("IM with Key Exchange"),
 		                           PURPLE_CALLBACK(silcpurple_buddy_keyagr),
 		                           NULL, NULL);
 		m = g_list_append(m, act);
 	SilcPurple sg = gc->proto_data;
 	SilcClient client = sg->client;
 	SilcClientConnection conn = sg->conn;
 	SilcMime mime;
 	char type[32];
-	unsigned char *icon;
 	const char *t;
-	SilcAttributeObjMime obj;
 	/* Remove */
 	if (!img) {
 		silc_client_attribute_del(client, conn,
 					  SILC_ATTRIBUTE_USER_ICON, NULL);
 		t = "jpeg";
 	g_snprintf(type, sizeof(type), "image/%s", t);
 	silc_mime_add_field(mime, "Content-Type", type);
 	silc_mime_add_data(mime, purple_imgstore_get_data(img), purple_imgstore_get_size(img));
-	obj.mime = icon = silc_mime_encode(mime, &obj.mime_len);
+	silc_client_attribute_add(client, conn,
-	if (obj.mime)
+				  SILC_ATTRIBUTE_USER_ICON, mime, sizeof(*mime));
-		silc_client_attribute_add(client, conn,
-					  SILC_ATTRIBUTE_USER_ICON, &obj, sizeof(obj));
-	silc_free(icon);
 	silc_mime_free(mime);
 }
 #endif

Mercurial > pidgin

comparison libpurple/protocols/silc/buddy.c @ 18080:bb2e5f6ff2b4