X-Git-Url: http://git.silcnet.org/gitweb/?p=silc.git;a=blobdiff_plain;f=lib%2Fsilcclient%2Fclient.c;h=9fc554bf5568f91e2d7e4033da3446747e861a33;hp=745cb698b52daf343e7233769ab7df0f770f7c00;hb=413da0f8686910f5e627393157566ae729ca99c4;hpb=050bd9d9e5d843220f3f393a18ab5011622237b9 diff --git a/lib/silcclient/client.c b/lib/silcclient/client.c index 745cb698..9fc554bf 100644 --- a/lib/silcclient/client.c +++ b/lib/silcclient/client.c @@ -1,10 +1,10 @@ /* - client.c + client.c Author: Pekka Riikonen - 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 @@ -30,7 +30,7 @@ SILC_TASK_CALLBACK(silc_client_rekey_final); 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, @@ -43,7 +43,7 @@ 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) @@ -55,7 +55,7 @@ SilcClient silc_client_alloc(SilcClientOperations *ops, 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; @@ -142,7 +142,7 @@ bool silc_client_init(SilcClient client) 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) @@ -211,7 +211,7 @@ static void silc_client_entry_destructor(SilcIDCache cache, 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. */ @@ -255,7 +255,7 @@ silc_client_add_connection(SilcClient client, 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; @@ -328,7 +328,8 @@ void silc_client_del_connection(SilcClient client, SilcClientConnection 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; } @@ -360,7 +361,7 @@ void silc_client_add_socket(SilcClient client, SilcSocketConnection sock) 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; @@ -374,11 +375,11 @@ void silc_client_add_socket(SilcClient client, SilcSocketConnection sock) } } - 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++; } @@ -401,7 +402,7 @@ void silc_client_del_socket(SilcClient client, SilcSocketConnection sock) } } -static int +static int silc_client_connect_to_server_internal(SilcClientInternalConnectContext *ctx) { int sock; @@ -415,9 +416,9 @@ silc_client_connect_to_server_internal(SilcClientInternalConnectContext *ctx) /* 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, @@ -429,16 +430,16 @@ silc_client_connect_to_server_internal(SilcClientInternalConnectContext *ctx) } /* 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; @@ -449,7 +450,7 @@ bool silc_client_connect_to_server(SilcClient client, 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 @@ -504,7 +505,7 @@ static void silc_client_start_key_exchange_cb(SilcSocketConnection sock, /* 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) { @@ -517,9 +518,9 @@ static void silc_client_start_key_exchange_cb(SilcSocketConnection sock, 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; @@ -548,7 +549,7 @@ void silc_client_start_key_exchange(SilcClient 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); @@ -566,11 +567,11 @@ void silc_client_start_key_exchange(SilcClient client, 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); @@ -586,7 +587,7 @@ SILC_TASK_CALLBACK(silc_client_connect_failure_auth) (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); } @@ -612,8 +613,8 @@ SILC_TASK_CALLBACK(silc_client_connect_to_server_start) 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 */ @@ -636,7 +637,6 @@ SILC_TASK_CALLBACK(silc_client_connect_to_server_start) /* Notify application of failure */ client->internal->ops->connected(client, conn, SILC_CLIENT_CONN_ERROR); - silc_client_del_connection(client, conn); } return; } @@ -648,13 +648,13 @@ SILC_TASK_CALLBACK(silc_client_connect_to_server_start) 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; @@ -714,15 +714,15 @@ SILC_TASK_CALLBACK(silc_client_connect_to_server_second) /* 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. */ @@ -743,14 +743,14 @@ void silc_client_resolve_auth_method(bool success, 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; } @@ -760,8 +760,8 @@ void silc_client_resolve_auth_method(bool success, } /* 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 */ @@ -776,7 +776,7 @@ void silc_client_resolve_auth_method(bool success, 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; @@ -829,7 +829,7 @@ SILC_TASK_CALLBACK(silc_client_connect_to_server_final) /* 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); @@ -839,7 +839,7 @@ SILC_TASK_CALLBACK(silc_client_connect_to_server_final) /* 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, @@ -853,7 +853,7 @@ SILC_TASK_CALLBACK(silc_client_connect_to_server_final) /* 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); } @@ -866,7 +866,7 @@ SILC_TASK_CALLBACK(silc_client_connect_to_server_final) /* 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); @@ -899,7 +899,7 @@ SILC_TASK_CALLBACK(silc_client_connect_to_server_final) 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) { @@ -919,9 +919,9 @@ bool silc_client_packet_send_real(SilcClient client, 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); @@ -967,10 +967,10 @@ SILC_TASK_CALLBACK_GLOBAL(silc_client_packet_process) /* 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); @@ -985,7 +985,7 @@ SILC_TASK_CALLBACK_GLOBAL(silc_client_packet_process) ret = silc_packet_receive(sock); if (ret < 0) return; - + /* EOF */ if (ret == 0) { SILC_LOG_DEBUG(("Read EOF")); @@ -998,7 +998,7 @@ SILC_TASK_CALLBACK_GLOBAL(silc_client_packet_process) 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); @@ -1009,12 +1009,12 @@ SILC_TASK_CALLBACK_GLOBAL(silc_client_packet_process) /* 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); } } @@ -1045,15 +1045,14 @@ static bool silc_client_packet_parse(SilcPacketParserContext *parser_context, 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); @@ -1064,14 +1063,14 @@ static bool silc_client_packet_parse(SilcPacketParserContext *parser_context, 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; } @@ -1085,7 +1084,7 @@ static bool silc_client_packet_parse(SilcPacketParserContext *parser_context, /* 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) { @@ -1113,7 +1112,7 @@ void silc_client_packet_parse_type(SilcClient client, 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. */ @@ -1125,7 +1124,7 @@ void silc_client_packet_parse_type(SilcClient client, case SILC_PACKET_NOTIFY: /* - * Received notify message + * Received notify message */ silc_client_notify_by_server(client, sock, packet); break; @@ -1182,9 +1181,9 @@ void silc_client_packet_parse_type(SilcClient client, 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); @@ -1203,35 +1202,35 @@ void silc_client_packet_parse_type(SilcClient client, 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); } @@ -1242,25 +1241,25 @@ void silc_client_packet_parse_type(SilcClient client, 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) @@ -1271,7 +1270,7 @@ void silc_client_packet_parse_type(SilcClient client, 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); } @@ -1285,7 +1284,7 @@ void silc_client_packet_parse_type(SilcClient client, { /* * 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. */ @@ -1325,15 +1324,15 @@ void silc_client_packet_parse_type(SilcClient client, 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 */ @@ -1341,7 +1340,7 @@ void silc_client_packet_parse_type(SilcClient client, 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 " @@ -1375,15 +1374,15 @@ void silc_client_packet_parse_type(SilcClient client, 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; @@ -1424,13 +1423,13 @@ void silc_client_packet_send(SilcClient client, /* 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; } @@ -1445,9 +1444,9 @@ void silc_client_packet_send(SilcClient client, 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); @@ -1455,7 +1454,7 @@ void silc_client_packet_send(SilcClient client, 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; @@ -1463,7 +1462,7 @@ void silc_client_packet_send(SilcClient client, /* 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), @@ -1495,17 +1494,17 @@ bool silc_client_send_packet(SilcClient client, 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 @@ -1528,6 +1527,12 @@ void silc_client_close_connection_real(SilcClient client, 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); @@ -1539,9 +1544,9 @@ void silc_client_close_connection_real(SilcClient client, /* 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); @@ -1570,7 +1575,7 @@ void silc_client_close_connection(SilcClient client, 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. */ @@ -1586,7 +1591,7 @@ SILC_TASK_CALLBACK(silc_client_disconnected_by_server_later) 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. */ @@ -1618,13 +1623,13 @@ void silc_client_disconnected_by_server(SilcClient client, 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, @@ -1634,7 +1639,7 @@ 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); } @@ -1646,8 +1651,8 @@ SILC_TASK_CALLBACK(silc_client_send_auto_nick) 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)); } @@ -1672,7 +1677,7 @@ static void silc_client_resume_session_cb(SilcClient client, /* 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, @@ -1707,7 +1712,7 @@ void silc_client_receive_new_id(SilcClient client, conn->local_entry); silc_free(conn->local_id); } - + /* Save the new ID */ if (conn->local_id_data) @@ -1728,14 +1733,14 @@ void silc_client_receive_new_id(SilcClient client, 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) { @@ -1744,7 +1749,7 @@ void silc_client_receive_new_id(SilcClient client, /* 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, @@ -1766,7 +1771,7 @@ void silc_client_receive_new_id(SilcClient client, /* 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, @@ -1807,7 +1812,7 @@ void silc_client_remove_from_channels(SilcClient client, 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) @@ -1820,7 +1825,7 @@ void silc_client_replace_from_channels(SilcClient client, /* 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); @@ -1860,6 +1865,11 @@ SILC_TASK_CALLBACK_GLOBAL(silc_client_rekey_callback) 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)); @@ -1867,21 +1877,15 @@ SILC_TASK_CALLBACK_GLOBAL(silc_client_rekey_callback) 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 @@ -1894,6 +1898,7 @@ SILC_TASK_CALLBACK(silc_client_rekey_final) (SilcClientRekeyInternalContext *)protocol->context; SilcClient client = (SilcClient)ctx->client; SilcSocketConnection sock = ctx->sock; + SilcClientConnection conn = (SilcClientConnection)sock->user_data; SILC_LOG_DEBUG(("Start")); @@ -1916,6 +1921,13 @@ SILC_TASK_CALLBACK(silc_client_rekey_final) 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; @@ -1952,7 +1964,7 @@ void silc_client_connection_auth_request(SilcClient client, 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, @@ -1964,7 +1976,7 @@ void silc_client_connection_auth_request(SilcClient client, 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) @@ -1992,7 +2004,7 @@ 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, @@ -2018,17 +2030,17 @@ silc_client_request_authentication_method(SilcClient client, 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); }