void silc_client_send_key_agreement(SilcClient client,
SilcClientConnection conn,
SilcClientEntry client_entry,
- char *hostname,
+ const char *hostname,
+ const char *bindhost,
int port,
uint32 timeout_secs,
SilcKeyAgreementCallback completion,
if (client_entry->ke)
return;
- /* Create the listener if hostname and port was provided */
+ /* Create the listener if hostname and port was provided.
+ * also, use bindhost if it was specified.
+ */
+
if (hostname) {
ke = silc_calloc(1, sizeof(*ke));
- ke->fd = silc_net_create_server(port, hostname);
+
+ if (bindhost)
+ ke->fd = silc_net_create_server(port, bindhost);
+ else
+ ke->fd = silc_net_create_server(port, hostname);
if (ke->fd < 0) {
client->ops->say(client, conn, SILC_CLIENT_MESSAGE_ERROR,
"Cannot create listener on %s on port %d: %s",
- hostname, port, strerror(errno));
+ (bindhost) ? bindhost:hostname, port, strerror(errno));
completion(client, conn, client_entry, SILC_KEY_AGREEMENT_FAILURE,
NULL, context);
silc_free(ke);
+
return;
}
will not start the key exchange protocol within the specified
timeout. */
ke->timeout = silc_schedule_task_add(client->schedule, 0,
- silc_client_key_agreement_timeout,
- (void *)ke, timeout_secs, 0,
- SILC_TASK_TIMEOUT, SILC_TASK_PRI_LOW);
+ silc_client_key_agreement_timeout,
+ (void *)ke, timeout_secs, 0,
+ SILC_TASK_TIMEOUT, SILC_TASK_PRI_LOW);
}
/* Encode the key agreement payload */
silc_client_packet_send(client, sock, SILC_PACKET_KEY_AGREEMENT,
client_entry->id, SILC_ID_CLIENT, NULL, NULL,
buffer->data, buffer->len, FALSE);
- silc_free(buffer);
+ silc_buffer_free(buffer);
+
}
static int
int sock;
/* Create connection to server asynchronously */
- sock = silc_net_create_connection_async(ctx->port, ctx->host);
+ sock = silc_net_create_connection_async(NULL, ctx->port, ctx->host);
if (sock < 0)
return -1;
/* Register task that will receive the async connect and will
read the result. */
ctx->task = silc_schedule_task_add(ctx->client->schedule, sock,
- silc_client_perform_key_agreement_start,
- (void *)ctx, 0, 0,
- SILC_TASK_FD,
- SILC_TASK_PRI_NORMAL);
+ silc_client_perform_key_agreement_start,
+ (void *)ctx, 0, 0,
+ SILC_TASK_FD,
+ SILC_TASK_PRI_NORMAL);
silc_schedule_set_listen_fd(ctx->client->schedule, sock, SILC_TASK_WRITE);
ctx->sock = sock;
assert(client_entry);
if (client_entry->ke) {
+ SilcClientKeyAgreement ke;
+
if (client_entry->ke->sock) {
silc_client_del_socket(client_entry->ke->client, client_entry->ke->sock);
silc_socket_free(client_entry->ke->sock);
}
- client_entry->ke = NULL;
silc_schedule_task_del_by_fd(client->schedule, client_entry->ke->fd);
if (client_entry->ke->timeout)
silc_schedule_task_del(client->schedule,
- client_entry->ke->timeout);
- silc_free(client_entry->ke);
+ client_entry->ke->timeout);
+ ke = client_entry->ke;
+ client_entry->ke = NULL;
+ ke->completion(client, conn, client_entry,
+ SILC_KEY_AGREEMENT_ABORTED, NULL, ke->context);
+ silc_free(ke);
}
}
goto out;
/* Parse the key agreement payload */
- payload = silc_key_agreement_payload_parse(packet->buffer);
+ payload = silc_key_agreement_payload_parse(packet->buffer->data,
+ packet->buffer->len);
if (!payload)
goto out;