/*
- client.c
+ client.c
Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2002 Pekka Riikonen
+ Copyright (C) 1997 - 2003 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
static bool silc_client_packet_parse(SilcPacketParserContext *parser_context,
void *context);
-static void silc_client_packet_parse_type(SilcClient client,
+static void silc_client_packet_parse_type(SilcClient client,
SilcSocketConnection sock,
SilcPacketContext *packet);
void silc_client_resolve_auth_method(bool success,
the client. The `application' is application specific user data pointer
and caller must free it. */
-SilcClient silc_client_alloc(SilcClientOperations *ops,
+SilcClient silc_client_alloc(SilcClientOperations *ops,
SilcClientParams *params,
void *application,
const char *version_string)
new_client->internal = silc_calloc(1, sizeof(*new_client->internal));
new_client->internal->ops = ops;
- new_client->internal->params =
+ new_client->internal->params =
silc_calloc(1, sizeof(*new_client->internal->params));
if (!version_string)
version_string = silc_version_string;
silc_client_protocols_register();
/* Initialize the scheduler */
- client->schedule =
+ client->schedule =
silc_schedule_init(client->internal->params->task_max ?
client->internal->params->task_max : 200, client);
if (!client->schedule)
connection to the connection table and returns a pointer to it. A client
can have multiple connections to multiple servers. Every connection must
be added to the client using this function. User data `context' may
- be sent as argument. This function is normally used only if the
+ be sent as argument. This function is normally used only if the
application performed the connecting outside the library. The library
however may use this internally. */
return conn;
}
- client->internal->conns =
+ client->internal->conns =
silc_realloc(client->internal->conns, sizeof(*client->internal->conns)
* (client->internal->conns_count + 1));
client->internal->conns[client->internal->conns_count] = conn;
silc_free(conn->internal->rekey);
if (conn->internal->active_session) {
- conn->sock->user_data = NULL;
+ if (conn->sock)
+ conn->sock->user_data = NULL;
silc_client_ftp_session_free(conn->internal->active_session);
conn->internal->active_session = NULL;
}
int i;
if (!client->internal->sockets) {
- client->internal->sockets =
+ client->internal->sockets =
silc_calloc(1, sizeof(*client->internal->sockets));
client->internal->sockets[0] = silc_socket_dup(sock);
client->internal->sockets_count = 1;
}
}
- client->internal->sockets =
- silc_realloc(client->internal->sockets,
+ client->internal->sockets =
+ silc_realloc(client->internal->sockets,
sizeof(*client->internal->sockets) *
(client->internal->sockets_count + 1));
- client->internal->sockets[client->internal->sockets_count] =
+ client->internal->sockets[client->internal->sockets_count] =
silc_socket_dup(sock);
client->internal->sockets_count++;
}
}
}
-static int
+static int
silc_client_connect_to_server_internal(SilcClientInternalConnectContext *ctx)
{
int sock;
/* Register task that will receive the async connect and will
read the result. */
- ctx->task = silc_schedule_task_add(ctx->client->schedule, sock,
+ ctx->task = silc_schedule_task_add(ctx->client->schedule, sock,
silc_client_connect_to_server_start,
- (void *)ctx, 0, 0,
+ (void *)ctx, 0, 0,
SILC_TASK_FD,
SILC_TASK_PRI_NORMAL);
silc_schedule_set_listen_fd(ctx->client->schedule, sock, SILC_TASK_WRITE,
}
/* Connects to remote server. This is the main routine used to connect
- to SILC server. Returns -1 on error and the created socket otherwise.
+ to SILC server. Returns -1 on error and the created socket otherwise.
The `context' is user context that is saved into the SilcClientConnection
that is created after the connection is created. Note that application
may handle the connecting process outside the library. If this is the
case then this function is not used at all. When the connecting is
done the `connect' client operation is called. */
-bool silc_client_connect_to_server(SilcClient client,
- SilcClientConnectionParams *params,
- int port, char *host, void *context)
+int silc_client_connect_to_server(SilcClient client,
+ SilcClientConnectionParams *params,
+ int port, char *host, void *context)
{
SilcClientInternalConnectContext *ctx;
SilcClientConnection conn;
conn = silc_client_add_connection(client, params, host, port, context);
- client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_AUDIT,
+ client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_AUDIT,
"Connecting to port %d of server %s", port, host);
/* Allocate internal context for connection process. This is
/* Perform key exchange protocol. silc_client_connect_to_server_final
will be called after the protocol is finished. */
- silc_protocol_alloc(SILC_PROTOCOL_CLIENT_KEY_EXCHANGE,
+ silc_protocol_alloc(SILC_PROTOCOL_CLIENT_KEY_EXCHANGE,
&protocol, (void *)proto_ctx,
silc_client_connect_to_server_second);
if (!protocol) {
conn->sock->protocol = protocol;
/* Register the connection for network input and output. This sets
- that scheduler will listen for incoming packets for this connection
+ that scheduler will listen for incoming packets for this connection
and sets that outgoing packets may be sent to this connection as well.
- However, this doesn't set the scheduler for outgoing traffic, it will
+ However, this doesn't set the scheduler for outgoing traffic, it will
be set separately by calling SILC_CLIENT_SET_CONNECTION_FOR_OUTPUT,
later when outgoing data is available. */
context = (void *)client;
silc_socket_alloc(fd, SILC_SOCKET_TYPE_SERVER, (void *)conn, &conn->sock);
/* Sometimes when doing quick reconnects the new socket may be same as
- the old one and there might be pending stuff for the old socket.
+ the old one and there might be pending stuff for the old socket.
If new one is same then those pending sutff might cause problems.
Make sure they do not do that. */
silc_schedule_task_del_by_fd(client->schedule, fd);
SILC_TASK_CALLBACK(silc_client_connect_failure)
{
- SilcClientKEInternalContext *ctx =
+ SilcClientKEInternalContext *ctx =
(SilcClientKEInternalContext *)context;
SilcClient client = (SilcClient)ctx->client;
- client->internal->ops->connected(client, ctx->sock->user_data,
+ client->internal->ops->connected(client, ctx->sock->user_data,
SILC_CLIENT_CONN_ERROR);
if (ctx->packet)
silc_packet_context_free(ctx->packet);
(SilcClientConnAuthInternalContext *)context;
SilcClient client = (SilcClient)ctx->client;
- client->internal->ops->connected(client, ctx->sock->user_data,
+ client->internal->ops->connected(client, ctx->sock->user_data,
SILC_CLIENT_CONN_ERROR);
silc_free(ctx);
}
client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_ERROR,
"Could not connect to server %s: %s",
ctx->host, strerror(opt));
- client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_AUDIT,
- "Connecting to port %d of server %s resumed",
+ client->internal->ops->say(client, conn, SILC_CLIENT_MESSAGE_AUDIT,
+ "Connecting to port %d of server %s resumed",
ctx->port, ctx->host);
/* Unregister old connection try */
/* Notify application of failure */
client->internal->ops->connected(client, conn, SILC_CLIENT_CONN_ERROR);
- silc_client_del_connection(client, conn);
}
return;
}
silc_client_start_key_exchange(client, conn, fd);
}
-/* Second part of the connecting to the server. This executed
+/* Second part of the connecting to the server. This executed
authentication protocol. */
SILC_TASK_CALLBACK(silc_client_connect_to_server_second)
{
SilcProtocol protocol = (SilcProtocol)context;
- SilcClientKEInternalContext *ctx =
+ SilcClientKEInternalContext *ctx =
(SilcClientKEInternalContext *)protocol->context;
SilcClient client = (SilcClient)ctx->client;
SilcSocketConnection sock = NULL;
/* Resolve the authentication method to be used in this connection. The
completion callback is called after the application has resolved
the authentication method. */
- client->internal->ops->get_auth_method(client, sock->user_data,
+ client->internal->ops->get_auth_method(client, sock->user_data,
sock->hostname,
- sock->port,
+ sock->port,
silc_client_resolve_auth_method,
proto_ctx);
}
/* Authentication method resolving callback. Application calls this function
- after we've called the client->internal->ops->get_auth_method
+ after we've called the client->internal->ops->get_auth_method
client operation to resolve the authentication method. We will continue
the executiong of the protocol in this function. */
if (success && auth_data && auth_data_len) {
/* Passphrase must be UTF-8 encoded, if it isn't encode it */
- if (auth_meth == SILC_AUTH_PASSWORD &&
+ if (auth_meth == SILC_AUTH_PASSWORD &&
!silc_utf8_valid(auth_data, auth_data_len)) {
int payload_len = 0;
unsigned char *autf8 = NULL;
- payload_len = silc_utf8_encoded_len(auth_data, auth_data_len,
+ payload_len = silc_utf8_encoded_len(auth_data, auth_data_len,
SILC_STRING_ASCII);
autf8 = silc_calloc(payload_len, sizeof(*autf8));
- auth_data_len = silc_utf8_encode(auth_data, auth_data_len,
+ auth_data_len = silc_utf8_encode(auth_data, auth_data_len,
SILC_STRING_ASCII, autf8, payload_len);
auth_data = autf8;
}
}
/* Allocate the authenteication protocol and execute it. */
- silc_protocol_alloc(SILC_PROTOCOL_CLIENT_CONNECTION_AUTH,
- &proto_ctx->sock->protocol, (void *)proto_ctx,
+ silc_protocol_alloc(SILC_PROTOCOL_CLIENT_CONNECTION_AUTH,
+ &proto_ctx->sock->protocol, (void *)proto_ctx,
silc_client_connect_to_server_final);
/* Execute the protocol */
SILC_TASK_CALLBACK(silc_client_connect_to_server_final)
{
SilcProtocol protocol = (SilcProtocol)context;
- SilcClientConnAuthInternalContext *ctx =
+ SilcClientConnAuthInternalContext *ctx =
(SilcClientConnAuthInternalContext *)protocol->context;
SilcClient client = (SilcClient)ctx->client;
SilcClientConnection conn = (SilcClientConnection)ctx->sock->user_data;
/* Send the packet */
silc_client_packet_send(client, ctx->sock, SILC_PACKET_RESUME_CLIENT,
- NULL, 0, NULL, NULL,
+ NULL, 0, NULL, NULL,
packet->data, packet->len, TRUE);
silc_buffer_free(packet);
silc_buffer_free(auth);
/* Send NEW_CLIENT packet to the server. We will become registered
to the SILC network after sending this packet and we will receive
client ID from the server. */
- packet = silc_buffer_alloc(2 + 2 + strlen(client->username) +
+ packet = silc_buffer_alloc(2 + 2 + strlen(client->username) +
strlen(client->realname));
silc_buffer_pull_tail(packet, SILC_BUFFER_END(packet));
silc_buffer_format(packet,
/* Send the packet */
silc_client_packet_send(client, ctx->sock, SILC_PACKET_NEW_CLIENT,
- NULL, 0, NULL, NULL,
+ NULL, 0, NULL, NULL,
packet->data, packet->len, TRUE);
silc_buffer_free(packet);
}
/* Register re-key timeout */
conn->internal->rekey->timeout = client->internal->params->rekey_secs;
conn->internal->rekey->context = (void *)client;
- silc_schedule_task_add(client->schedule, conn->sock->sock,
+ silc_schedule_task_add(client->schedule, conn->sock->sock,
silc_client_rekey_callback,
(void *)conn->sock, conn->internal->rekey->timeout, 0,
SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
is used directly only in special cases. Normal cases should use
silc_server_packet_send. Returns < 0 on error. */
-bool silc_client_packet_send_real(SilcClient client,
+int silc_client_packet_send_real(SilcClient client,
SilcSocketConnection sock,
bool force_send)
{
if (ret != -2)
return ret;
- /* Mark that there is some outgoing data available for this connection.
+ /* Mark that there is some outgoing data available for this connection.
This call sets the connection both for input and output (the input
- is set always and this call keeps the input setting, actually).
+ is set always and this call keeps the input setting, actually).
Actual data sending is performed by silc_client_packet_process. */
SILC_CLIENT_SET_CONNECTION_FOR_OUTPUT(client->schedule, sock->sock);
/* Error */
if (ret == -1)
return;
-
+
/* The packet has been sent and now it is time to set the connection
- back to only for input. When there is again some outgoing data
- available for this connection it will be set for output as well.
+ back to only for input. When there is again some outgoing data
+ available for this connection it will be set for output as well.
This call clears the output setting and sets it only for input. */
SILC_CLIENT_SET_CONNECTION_FOR_INPUT(client->schedule, fd);
SILC_UNSET_OUTBUF_PENDING(sock);
ret = silc_packet_receive(sock);
if (ret < 0)
return;
-
+
/* EOF */
if (ret == 0) {
SILC_LOG_DEBUG(("Read EOF"));
silc_client_close_connection_real(client, sock, conn);
return;
}
-
+
SILC_LOG_DEBUG(("EOF from connection %d", sock->sock));
if (sock == conn->sock && sock->type != SILC_SOCKET_TYPE_CLIENT)
client->internal->ops->disconnected(client, conn, 0, NULL);
/* Process the packet. This will call the parser that will then
decrypt and parse the packet. */
if (sock->type != SILC_SOCKET_TYPE_UNKNOWN)
- silc_packet_receive_process(sock, FALSE, conn->internal->receive_key,
+ silc_packet_receive_process(sock, FALSE, conn->internal->receive_key,
conn->internal->hmac_receive,
conn->internal->psn_receive,
silc_client_packet_parse, client);
else
- silc_packet_receive_process(sock, FALSE, NULL, NULL, 0,
+ silc_packet_receive_process(sock, FALSE, NULL, NULL, 0,
silc_client_packet_parse, client);
}
}
silc_free(parser_context);
return FALSE;
}
-
+
/* If protocol for this connection is key exchange or rekey then we'll
process all packets synchronously, since there might be packets in
queue that we are not able to decrypt without first processing the
packets before them. */
- if ((ret == SILC_PACKET_REKEY || ret == SILC_PACKET_REKEY_DONE) ||
- (sock->protocol && sock->protocol->protocol &&
- (sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_KEY_EXCHANGE ||
- sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY))) {
+ if (sock->protocol && sock->protocol->protocol &&
+ (sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_KEY_EXCHANGE ||
+ sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY)) {
/* Parse the incoming packet type */
silc_client_packet_parse_type(client, sock, packet);
the `conn->internal->receive_key' might have become valid by processing
the previous packet */
if (sock->type != SILC_SOCKET_TYPE_UNKNOWN)
- silc_packet_receive_process(sock, FALSE, conn->internal->receive_key,
+ silc_packet_receive_process(sock, FALSE, conn->internal->receive_key,
conn->internal->hmac_receive,
conn->internal->psn_receive,
silc_client_packet_parse, client);
else
- silc_packet_receive_process(sock, FALSE, NULL, NULL, 0,
+ silc_packet_receive_process(sock, FALSE, NULL, NULL, 0,
silc_client_packet_parse, client);
-
+
return FALSE;
}
/* Parses the packet type and calls what ever routines the packet type
requires. This is done for all incoming packets. */
-void silc_client_packet_parse_type(SilcClient client,
+void silc_client_packet_parse_type(SilcClient client,
SilcSocketConnection sock,
SilcPacketContext *packet)
{
case SILC_PACKET_FAILURE:
/*
- * Failure received for some protocol. Set the protocol state to
+ * Failure received for some protocol. Set the protocol state to
* error and call the protocol callback. This fill cause error on
* protocol and it will call the final callback.
*/
case SILC_PACKET_NOTIFY:
/*
- * Received notify message
+ * Received notify message
*/
silc_client_notify_by_server(client, sock, packet);
break;
break;
case SILC_PACKET_KEY_EXCHANGE:
- if (sock->protocol && sock->protocol->protocol &&
+ if (sock->protocol && sock->protocol->protocol &&
sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_KEY_EXCHANGE) {
- SilcClientKEInternalContext *proto_ctx =
+ SilcClientKEInternalContext *proto_ctx =
(SilcClientKEInternalContext *)sock->protocol->context;
proto_ctx->packet = silc_packet_context_dup(packet);
break;
case SILC_PACKET_KEY_EXCHANGE_1:
- if (sock->protocol && sock->protocol->protocol &&
+ if (sock->protocol && sock->protocol->protocol &&
(sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_KEY_EXCHANGE ||
sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY)) {
if (sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY) {
- SilcClientRekeyInternalContext *proto_ctx =
+ SilcClientRekeyInternalContext *proto_ctx =
(SilcClientRekeyInternalContext *)sock->protocol->context;
-
+
if (proto_ctx->packet)
silc_packet_context_free(proto_ctx->packet);
-
+
proto_ctx->packet = silc_packet_context_dup(packet);
/* Let the protocol handle the packet */
silc_protocol_execute(sock->protocol, client->schedule, 0, 0);
} else {
- SilcClientKEInternalContext *proto_ctx =
+ SilcClientKEInternalContext *proto_ctx =
(SilcClientKEInternalContext *)sock->protocol->context;
-
+
if (proto_ctx->packet)
silc_packet_context_free(proto_ctx->packet);
-
+
proto_ctx->packet = silc_packet_context_dup(packet);
proto_ctx->dest_id_type = packet->src_id_type;
proto_ctx->dest_id = silc_id_str2id(packet->src_id, packet->src_id_len,
packet->src_id_type);
if (!proto_ctx->dest_id)
break;
-
+
/* Let the protocol handle the packet */
silc_protocol_execute(sock->protocol, client->schedule, 0, 0);
}
break;
case SILC_PACKET_KEY_EXCHANGE_2:
- if (sock->protocol && sock->protocol->protocol &&
+ if (sock->protocol && sock->protocol->protocol &&
(sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_KEY_EXCHANGE ||
sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY)) {
if (sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY) {
- SilcClientRekeyInternalContext *proto_ctx =
+ SilcClientRekeyInternalContext *proto_ctx =
(SilcClientRekeyInternalContext *)sock->protocol->context;
-
+
if (proto_ctx->packet)
silc_packet_context_free(proto_ctx->packet);
-
+
proto_ctx->packet = silc_packet_context_dup(packet);
/* Let the protocol handle the packet */
silc_protocol_execute(sock->protocol, client->schedule, 0, 0);
} else {
- SilcClientKEInternalContext *proto_ctx =
+ SilcClientKEInternalContext *proto_ctx =
(SilcClientKEInternalContext *)sock->protocol->context;
-
+
if (proto_ctx->packet)
silc_packet_context_free(proto_ctx->packet);
if (proto_ctx->dest_id)
packet->src_id_type);
if (!proto_ctx->dest_id)
break;
-
+
/* Let the protocol handle the packet */
silc_protocol_execute(sock->protocol, client->schedule, 0, 0);
}
{
/*
* Received new ID from server. This packet is received at
- * the connection to the server. New ID is also received when
+ * the connection to the server. New ID is also received when
* user changes nickname but in that case the new ID is received
* as command reply and not as this packet type.
*/
case SILC_PACKET_REKEY_DONE:
SILC_LOG_DEBUG(("Re-key done packet"));
- if (sock->protocol && sock->protocol->protocol &&
+ if (sock->protocol && sock->protocol->protocol &&
sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY) {
- SilcClientRekeyInternalContext *proto_ctx =
+ SilcClientRekeyInternalContext *proto_ctx =
(SilcClientRekeyInternalContext *)sock->protocol->context;
-
+
if (proto_ctx->packet)
silc_packet_context_free(proto_ctx->packet);
-
+
proto_ctx->packet = silc_packet_context_dup(packet);
/* Let the protocol handle the packet */
silc_protocol_execute(sock->protocol, client->schedule, 0, 0);
else
/* Let the protocol handle the packet */
- silc_protocol_execute(sock->protocol, client->schedule,
+ silc_protocol_execute(sock->protocol, client->schedule,
0, 100000);
} else {
SILC_LOG_ERROR(("Received Re-key done packet but no re-key "
will be derived from sock argument. Otherwise the valid arguments sent
are used. */
-void silc_client_packet_send(SilcClient client,
+void silc_client_packet_send(SilcClient client,
SilcSocketConnection sock,
- SilcPacketType type,
+ SilcPacketType type,
void *dst_id,
SilcIdType dst_id_type,
SilcCipher cipher,
SilcHmac hmac,
- unsigned char *data,
- SilcUInt32 data_len,
+ unsigned char *data,
+ SilcUInt32 data_len,
bool force_send)
{
SilcPacketContext packetdata;
/* Set the packet context pointers */
packetdata.flags = 0;
packetdata.type = type;
- if (sock->user_data &&
+ if (sock->user_data &&
((SilcClientConnection)sock->user_data)->local_id_data) {
packetdata.src_id = ((SilcClientConnection)sock->user_data)->local_id_data;
- packetdata.src_id_len =
+ packetdata.src_id_len =
silc_id_get_len(((SilcClientConnection)sock->user_data)->local_id,
SILC_ID_CLIENT);
- } else {
+ } else {
packetdata.src_id = silc_calloc(SILC_ID_CLIENT_LEN, sizeof(unsigned char));
packetdata.src_id_len = SILC_ID_CLIENT_LEN;
}
packetdata.dst_id_type = SILC_ID_NONE;
}
data_len = SILC_PACKET_DATALEN(data_len, (SILC_PACKET_HEADER_LEN +
- packetdata.src_id_len +
+ packetdata.src_id_len +
packetdata.dst_id_len));
- packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
+ packetdata.truelen = data_len + SILC_PACKET_HEADER_LEN +
packetdata.src_id_len + packetdata.dst_id_len;
if (type == SILC_PACKET_CONNECTION_AUTH)
SILC_PACKET_PADLEN_MAX(packetdata.truelen, block_len, packetdata.padlen);
SILC_PACKET_PADLEN(packetdata.truelen, block_len, packetdata.padlen);
/* Create the outgoing packet */
- if (!silc_packet_assemble(&packetdata, client->rng, cipher, hmac, sock,
+ if (!silc_packet_assemble(&packetdata, client->rng, cipher, hmac, sock,
data, data_len, (const SilcBuffer)&packet)) {
SILC_LOG_ERROR(("Error assembling packet"));
return;
/* Encrypt the packet */
if (cipher)
- silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&packet,
+ silc_packet_encrypt(cipher, hmac, sequence, (SilcBuffer)&packet,
packet.len);
SILC_LOG_HEXDUMP(("Packet (%d), len %d", sequence, packet.len),
void silc_client_packet_queue_purge(SilcClient client,
SilcSocketConnection sock)
{
- if (sock && SILC_IS_OUTBUF_PENDING(sock) &&
+ if (sock && SILC_IS_OUTBUF_PENDING(sock) &&
(SILC_IS_DISCONNECTED(sock) == FALSE)) {
silc_packet_send(sock, TRUE);
- SILC_CLIENT_SET_CONNECTION_FOR_INPUT(client->schedule, sock->sock);
SILC_UNSET_OUTBUF_PENDING(sock);
+ SILC_CLIENT_SET_CONNECTION_FOR_INPUT(client->schedule, sock->sock);
silc_buffer_clear(sock->outbuf);
}
}
/* Closes connection to remote end. Free's all allocated data except
- for some information such as nickname etc. that are valid at all time.
+ for some information such as nickname etc. that are valid at all time.
If the `sock' is NULL then the conn->sock will be used. If `sock' is
provided it will be checked whether the sock and `conn->sock' are the
same (they can be different, ie. a socket can use `conn' as its
if (!sock)
sock = conn->sock;
+ if (!sock) {
+ if (del && conn)
+ silc_client_del_connection(client, conn);
+ return;
+ }
+
/* We won't listen for this connection anymore */
silc_schedule_unset_listen_fd(client->schedule, sock->sock);
/* Cancel any active protocol */
if (sock->protocol) {
- if (sock->protocol->protocol->type ==
+ if (sock->protocol->protocol->type ==
SILC_PROTOCOL_CLIENT_KEY_EXCHANGE ||
- sock->protocol->protocol->type ==
+ sock->protocol->protocol->type ==
SILC_PROTOCOL_CLIENT_CONNECTION_AUTH) {
sock->protocol->state = SILC_PROTOCOL_STATE_ERROR;
silc_protocol_execute_final(sock->protocol, client->schedule);
silc_client_close_connection_real(client, NULL, conn);
}
-/* Called when we receive disconnection packet from server. This
+/* Called when we receive disconnection packet from server. This
closes our end properly and displays the reason of the disconnection
on the screen. */
silc_client_close_connection_real(client, sock, sock->user_data);
}
-/* Called when we receive disconnection packet from server. This
+/* Called when we receive disconnection packet from server. This
closes our end properly and displays the reason of the disconnection
on the screen. */
SILC_SET_DISCONNECTED(sock);
/* Close connection through scheduler. */
- silc_schedule_task_add(client->schedule, sock->sock,
+ silc_schedule_task_add(client->schedule, sock->sock,
silc_client_disconnected_by_server_later,
- client, 0, 1, SILC_TASK_TIMEOUT,
+ client, 0, 1, SILC_TASK_TIMEOUT,
SILC_TASK_PRI_NORMAL);
}
-/* Received error message from server. Display it on the screen.
+/* Received error message from server. Display it on the screen.
We don't take any action what so ever of the error message. */
void silc_client_error_by_server(SilcClient client,
char *msg;
msg = silc_memdup(message->data, message->len);
- client->internal->ops->say(client, sock->user_data,
+ client->internal->ops->say(client, sock->user_data,
SILC_CLIENT_MESSAGE_AUDIT, msg);
silc_free(msg);
}
SilcClientConnection conn = (SilcClientConnection)context;
SilcClient client = conn->client;
if (client)
- silc_client_command_send(client, conn, SILC_COMMAND_NICK,
- ++conn->cmd_ident, 1, 1,
+ silc_client_command_send(client, conn, SILC_COMMAND_NICK,
+ ++conn->cmd_ident, 1, 1,
client->nickname, strlen(client->nickname));
}
/* Issue INFO command to fetch the real server name and server
information and other stuff. */
silc_client_command_register(client, SILC_COMMAND_INFO, NULL, NULL,
- silc_client_command_reply_info_i, 0,
+ silc_client_command_reply_info_i, 0,
++conn->cmd_ident);
sidp = silc_id_payload_encode(conn->remote_id, SILC_ID_SERVER);
silc_client_command_send(client, conn, SILC_COMMAND_INFO,
conn->local_entry);
silc_free(conn->local_id);
}
-
+
/* Save the new ID */
if (conn->local_id_data)
conn->local_entry->id = conn->local_id;
conn->local_entry->valid = TRUE;
if (!conn->local_entry->channels)
- conn->local_entry->channels = silc_hash_table_alloc(1, silc_hash_ptr,
+ conn->local_entry->channels = silc_hash_table_alloc(1, silc_hash_ptr,
NULL, NULL,
- NULL, NULL, NULL,
+ NULL, NULL, NULL,
TRUE);
/* Put it to the ID cache */
silc_idcache_add(conn->internal->client_cache,
- strdup(conn->nickname), conn->local_id,
+ strdup(conn->nickname), conn->local_id,
(void *)conn->local_entry, 0, NULL);
if (connecting) {
/* Issue IDENTIFY command for itself to get resolved hostname
correctly from server. */
silc_client_command_register(client, SILC_COMMAND_IDENTIFY, NULL, NULL,
- silc_client_command_reply_identify_i, 0,
+ silc_client_command_reply_identify_i, 0,
++conn->cmd_ident);
sidp = silc_id_payload_encode(conn->local_entry->id, SILC_ID_CLIENT);
silc_client_command_send(client, conn, SILC_COMMAND_IDENTIFY,
/* Issue INFO command to fetch the real server name and server
information and other stuff. */
silc_client_command_register(client, SILC_COMMAND_INFO, NULL, NULL,
- silc_client_command_reply_info_i, 0,
+ silc_client_command_reply_info_i, 0,
++conn->cmd_ident);
sidp = silc_id_payload_encode(conn->remote_id, SILC_ID_SERVER);
silc_client_command_send(client, conn, SILC_COMMAND_INFO,
is replaced from ID cache with the new one. If the old ID entry is only
updated, then this fucntion needs not to be called. */
-void silc_client_replace_from_channels(SilcClient client,
+void silc_client_replace_from_channels(SilcClient client,
SilcClientConnection conn,
SilcClientEntry old,
SilcClientEntry new)
/* Replace client entry */
silc_hash_table_del(chu->client->channels, chu->channel);
silc_hash_table_del(chu->channel->user_list, chu->client);
-
+
chu->client = new;
silc_hash_table_add(chu->channel->user_list, chu->client, chu);
silc_hash_table_add(chu->client->channels, chu->channel, chu);
SILC_LOG_DEBUG(("Start"));
+ /* If rekey protocol is active already wait for it to finish */
+ if (sock->protocol && sock->protocol->protocol &&
+ sock->protocol->protocol->type == SILC_PROTOCOL_CLIENT_REKEY)
+ return;
+
/* Allocate internal protocol context. This is sent as context
to the protocol. */
proto_ctx = silc_calloc(1, sizeof(*proto_ctx));
proto_ctx->sock = silc_socket_dup(sock);
proto_ctx->responder = FALSE;
proto_ctx->pfs = conn->internal->rekey->pfs;
-
+
/* Perform rekey protocol. Will call the final callback after the
protocol is over. */
- silc_protocol_alloc(SILC_PROTOCOL_CLIENT_REKEY,
+ silc_protocol_alloc(SILC_PROTOCOL_CLIENT_REKEY,
&protocol, proto_ctx, silc_client_rekey_final);
sock->protocol = protocol;
-
+
/* Run the protocol */
silc_protocol_execute(protocol, client->schedule, 0, 0);
-
- /* Re-register re-key timeout */
- silc_schedule_task_add(client->schedule, sock->sock,
- silc_client_rekey_callback,
- context, conn->internal->rekey->timeout, 0,
- SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
}
/* The final callback for the REKEY protocol. This will actually take the
(SilcClientRekeyInternalContext *)protocol->context;
SilcClient client = (SilcClient)ctx->client;
SilcSocketConnection sock = ctx->sock;
+ SilcClientConnection conn = (SilcClientConnection)sock->user_data;
SILC_LOG_DEBUG(("Start"));
go to the network before we quit the protocol. */
silc_client_packet_queue_purge(client, sock);
+ /* Re-register re-key timeout */
+ if (ctx->responder == FALSE)
+ silc_schedule_task_add(client->schedule, sock->sock,
+ silc_client_rekey_callback,
+ sock, conn->internal->rekey->timeout, 0,
+ SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
+
/* Cleanup */
silc_protocol_free(protocol);
sock->protocol = NULL;
if (ret == -1)
auth_meth = SILC_AUTH_NONE;
- /* Call the request callback to notify application for received
+ /* Call the request callback to notify application for received
authentication method information. */
if (conn->internal->connauth->callback)
(*conn->internal->connauth->callback)(client, conn, auth_meth,
conn->internal->connauth = NULL;
}
-/* Timeout task callback called if the server does not reply to our
+/* Timeout task callback called if the server does not reply to our
connection authentication method request in the specified time interval. */
SILC_TASK_CALLBACK(silc_client_request_authentication_method_timeout)
The `callback' with `context' will be called after the server has
replied back with the current authentication method. */
-void
+void
silc_client_request_authentication_method(SilcClient client,
SilcClientConnection conn,
SilcConnectionAuthRequest callback,
SILC_STR_UI_SHORT(SILC_SOCKET_TYPE_CLIENT),
SILC_STR_UI_SHORT(SILC_AUTH_NONE),
SILC_STR_END);
- silc_client_packet_send(client, conn->sock,
+ silc_client_packet_send(client, conn->sock,
SILC_PACKET_CONNECTION_AUTH_REQUEST,
- NULL, 0, NULL, NULL,
+ NULL, 0, NULL, NULL,
packet->data, packet->len, FALSE);
silc_buffer_free(packet);
/* Register a timeout in case server does not reply anything back. */
connauth->timeout =
- silc_schedule_task_add(client->schedule, conn->sock->sock,
+ silc_schedule_task_add(client->schedule, conn->sock->sock,
silc_client_request_authentication_method_timeout,
- conn,
+ conn,
client->internal->params->connauth_request_secs, 0,
SILC_TASK_TIMEOUT, SILC_TASK_PRI_NORMAL);
}
projects / silc.git / blobdiff