conn = sconn->conn;
if (conn) {
- /* Match found. Use the configured authentication method */
+ /* Match found. Use the configured authentication method. Take only
+ the passphrase, since for public key auth we automatically use
+ our local key pair. */
if (conn->passphrase) {
- if (conn->publickey && !server->config->prefer_passphrase_auth) {
- proto_ctx->auth_data = conn->publickey;
- proto_ctx->auth_data_len = 0;
+ if (conn->publickeys && !server->config->prefer_passphrase_auth) {
proto_ctx->auth_meth = SILC_AUTH_PUBLIC_KEY;
} else {
proto_ctx->auth_data = strdup(conn->passphrase);
proto_ctx->auth_data_len = strlen(conn->passphrase);
proto_ctx->auth_meth = SILC_AUTH_PASSWORD;
}
- } else if (conn->publickey) {
- proto_ctx->auth_data = conn->publickey;
- proto_ctx->auth_data_len = 0;
+ } else if (conn->publickeys) {
proto_ctx->auth_meth = SILC_AUTH_PUBLIC_KEY;
} else {
proto_ctx->auth_meth = SILC_AUTH_NONE;
SilcBuffer packet;
SilcServerHBContext hb_context;
unsigned char *id_string;
- uint32 id_len;
+ SilcUInt32 id_len;
SilcIDListData idata;
SilcServerConfigConnParams *param;
SILC_ROUTER, ctx->dest_id, NULL, sock);
if (!id_entry) {
silc_free(ctx->dest_id);
+ SILC_LOG_ERROR(("Cannot add new server entry to cache"));
silc_server_disconnect_remote(server, sock, "Server closed connection: "
"Authentication failed");
goto out;
later when outgoing data is available. */
SILC_REGISTER_CONNECTION_FOR_IO(sock->sock);
- SILC_LOG_INFO(("Incoming connection from %s (%s)", sock->hostname,
+ SILC_LOG_INFO(("Incoming connection %s (%s)", sock->hostname,
sock->ip));
port = server->sockets[server->sock]->port; /* Listenning port */
SilcServerHBContext hb_context;
SilcUnknownEntry entry = (SilcUnknownEntry)sock->user_data;
void *id_entry;
- uint32 hearbeat_timeout = server->config->param.keepalive_secs;
- uint32 num_sockets;
+ SilcUInt32 hearbeat_timeout = server->config->param.keepalive_secs;
+ SilcUInt32 num_sockets;
SILC_LOG_DEBUG(("Start"));
entry->data.last_receive = time(NULL);
- num_sockets = silc_server_num_sockets_by_ip(server, sock->ip);
+ num_sockets = silc_server_num_sockets_by_ip(server, sock->ip,
+ ctx->conn_type);
switch (ctx->conn_type) {
case SILC_SOCKET_TYPE_CLIENT:
{
SilcClientEntry client;
SilcServerConfigClient *conn = ctx->cconfig;
- uint32 max_per_host = server->config->param.connections_max_per_host;
+ SilcUInt32 max_per_host = server->config->param.connections_max_per_host;
/* Check for maximum connections limit */
if (conn->param) {
if (conn->param->connections_max &&
server->stat.my_clients >= conn->param->connections_max) {
+ SILC_LOG_INFO(("Server is full, closing %s (%s) connection",
+ sock->hostname, sock->ip));
silc_server_disconnect_remote(server, sock,
"Server closed connection: "
"Server is full, try again later");
max_per_host = conn->param->connections_max_per_host;
}
- if (num_sockets > max_per_host) {
+ if (num_sockets >= max_per_host) {
+ SILC_LOG_INFO(("Too many connections from %s (%s), closing connection",
+ sock->hostname, sock->ip));
silc_server_disconnect_remote(server, sock,
"Server closed connection: "
"Too many connections from your host");
}
SILC_LOG_DEBUG(("Remote host is client"));
- SILC_LOG_INFO(("Connection from %s (%s) is client", sock->hostname,
+ SILC_LOG_INFO(("Connection %s (%s) is client", sock->hostname,
sock->ip));
/* Add the client to the client ID cache. The nickname and Client ID
bool backup_local = FALSE;
bool backup_router = FALSE;
char *backup_replace_ip = NULL;
- uint16 backup_replace_port = 0;
+ SilcUInt16 backup_replace_port = 0;
SilcServerConfigServer *sconn = ctx->sconfig;
SilcServerConfigRouter *rconn = ctx->rconfig;
- uint32 max_per_host = server->config->param.connections_max_per_host;
+ SilcUInt32 max_per_host = server->config->param.connections_max_per_host;
if (ctx->conn_type == SILC_SOCKET_TYPE_ROUTER && rconn) {
if (rconn->param) {
/* Check for maximum connections limit */
if (sconn->param->connections_max &&
server->stat.my_servers >= sconn->param->connections_max) {
+ SILC_LOG_INFO(("Server is full, closing %s (%s) connection",
+ sock->hostname, sock->ip));
silc_server_disconnect_remote(server, sock,
"Server closed connection: "
"Server is full, try again later");
backup_router = sconn->backup_router;
}
- if (num_sockets > max_per_host) {
+ if (num_sockets >= max_per_host) {
+ SILC_LOG_INFO(("Too many connections from %s (%s), closing connection",
+ sock->hostname, sock->ip));
silc_server_disconnect_remote(server, sock,
"Server closed connection: "
"Too many connections from your host");
ctx->conn_type == SILC_SOCKET_TYPE_SERVER ?
"server" : (backup_router ?
"backup router" : "router")));
- SILC_LOG_INFO(("Connection from %s (%s) is %s", sock->hostname,
+ SILC_LOG_INFO(("Connection s (%s) is %s", sock->hostname,
sock->ip, ctx->conn_type == SILC_SOCKET_TYPE_SERVER ?
"server" : (backup_router ?
"backup router" : "router")));
SilcIDListData idata;
SilcCipher cipher = NULL;
SilcHmac hmac = NULL;
- uint32 sequence = 0;
+ SilcUInt32 sequence = 0;
int ret;
if (!sock)
/* If connection is disconnecting or disconnected we will ignore
what we read. */
if (SILC_IS_DISCONNECTING(sock) || SILC_IS_DISCONNECTED(sock)) {
- SILC_LOG_DEBUG(("Ignoring read data from disonnected connection"));
+ SILC_LOG_DEBUG(("Ignoring read data from disconnected connection"));
return;
}
/* Creates connection to a remote router. */
void silc_server_create_connection(SilcServer server,
- const char *remote_host, uint32 port)
+ const char *remote_host, SilcUInt32 port)
{
SilcServerConnection sconn;
if (!sock)
return;
+ SILC_LOG_ERROR(("No response from %s (%s), Connection timeout",
+ sock->hostname, sock->ip));
+
/* If we have protocol active we must assure that we call the protocol's
final callback so that all the memory is freed. */
if (sock->protocol) {
bool silc_server_create_channel_key(SilcServer server,
SilcChannelEntry channel,
- uint32 key_len)
+ SilcUInt32 key_len)
{
int i;
unsigned char channel_key[32], hash[32];
- uint32 len;
+ SilcUInt32 len;
SILC_LOG_DEBUG(("Generating channel key"));
SilcChannelKeyPayload payload = NULL;
SilcChannelID *id = NULL;
unsigned char *tmp, hash[32];
- uint32 tmp_len;
+ SilcUInt32 tmp_len;
char *cipher;
SILC_LOG_DEBUG(("Start"));
}
static SilcBuffer
-silc_server_announce_encode_notify(SilcNotifyType notify, uint32 argc, ...)
+silc_server_announce_encode_notify(SilcNotifyType notify, SilcUInt32 argc, ...)
{
va_list ap;
SilcBuffer p;
SilcBuffer *channels,
SilcBuffer *channel_users,
SilcBuffer **channel_users_modes,
- uint32 *channel_users_modes_c,
+ SilcUInt32 *channel_users_modes_c,
SilcBuffer **channel_topics,
SilcChannelID ***channel_ids,
unsigned long creation_time)
SilcIDCacheEntry id_cache;
SilcChannelEntry channel;
unsigned char *cid;
- uint32 id_len;
- uint16 name_len;
+ SilcUInt32 id_len;
+ SilcUInt16 name_len;
int len;
int i = *channel_users_modes_c;
bool announce;
SilcBuffer channels = NULL, channel_users = NULL;
SilcBuffer *channel_users_modes = NULL;
SilcBuffer *channel_topics = NULL;
- uint32 channel_users_modes_c = 0;
+ SilcUInt32 channel_users_modes_c = 0;
SilcChannelID **channel_ids = NULL;
SILC_LOG_DEBUG(("Announcing channels and channel users"));
SilcChannelEntry channel,
SilcBuffer *user_list,
SilcBuffer *mode_list,
- uint32 *user_count)
+ SilcUInt32 *user_count)
{
SilcChannelClientEntry chl;
SilcHashTableList htl;
SilcBuffer client_id_list;
SilcBuffer client_mode_list;
SilcBuffer idp;
- uint32 list_count = 0, len = 0;
+ SilcUInt32 list_count = 0, len = 0;
silc_hash_table_list(channel->user_list, &htl);
while (silc_hash_table_get(&htl, NULL, (void *)&chl))
SilcClientID *noadd,
SilcBuffer user_list,
SilcBuffer mode_list,
- uint32 user_count)
+ SilcUInt32 user_count)
{
int i;
- uint16 idp_len;
- uint32 mode;
+ SilcUInt16 idp_len;
+ SilcUInt32 mode;
SilcClientID *client_id;
SilcClientEntry client;
SilcIDCacheEntry cache;
SilcSocketConnection silc_server_get_client_route(SilcServer server,
unsigned char *id_data,
- uint32 id_len,
+ SilcUInt32 id_len,
SilcClientID *client_id,
SilcIDListData *idata)
{
SilcChannelClientEntry chl;
SilcHashTableList htl;
unsigned char *cid;
- uint32 id_len;
- uint16 name_len;
+ SilcUInt32 id_len;
+ SilcUInt16 name_len;
int len;
silc_hash_table_list(client->channels, &htl);
projects / silc.git / blobdiff