X-Git-Url: http://git.silcnet.org/gitweb/?p=silc.git;a=blobdiff_plain;f=lib%2Fsilccore%2Fsilcpacket.c;h=2c01e6dd65fb1886d7723e83b081dff1a82e54e0;hp=ff6fdee6e8aa9ad526d2501b0a2db3c8a66c8c4f;hb=1cc9af890006b0181913d4f84909442744476745;hpb=57473153b7fa6fcb0cdb55cba4f455cabfa21937 diff --git a/lib/silccore/silcpacket.c b/lib/silccore/silcpacket.c index ff6fdee6..2c01e6dd 100644 --- a/lib/silccore/silcpacket.c +++ b/lib/silccore/silcpacket.c @@ -4,7 +4,7 @@ Author: Pekka Riikonen - Copyright (C) 1997 - 2007 Pekka Riikonen + Copyright (C) 1997 - 2008 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 @@ -40,7 +40,7 @@ struct SilcPacketEngineStruct { SilcMutex lock; /* Engine lock */ SilcRng rng; /* RNG for engine */ SilcHashTable contexts; /* Per scheduler contexts */ - SilcPacketCallbacks *callbacks; /* Packet callbacks */ + const SilcPacketCallbacks *callbacks; /* Packet callbacks */ void *callback_context; /* Context for callbacks */ SilcList streams; /* All streams in engine */ SilcList packet_pool; /* Free list for received packets */ @@ -51,7 +51,7 @@ struct SilcPacketEngineStruct { /* Packet processor context */ typedef struct SilcPacketProcessStruct { SilcPacketType *types; /* Packets to process */ - SilcPacketCallbacks *callbacks; /* Callbacks or NULL */ + const SilcPacketCallbacks *callbacks; /* Callbacks or NULL */ void *callback_context; SilcInt32 priority; /* Priority */ } *SilcPacketProcess; @@ -306,7 +306,7 @@ static inline SilcBool silc_packet_stream_read(SilcPacketStream ps, inbuf = silc_dlist_get(ps->sc->inbufs); if (!inbuf) { /* Allocate new data input buffer */ - inbuf = silc_buffer_alloc(SILC_PACKET_DEFAULT_SIZE * 31); + inbuf = silc_buffer_alloc(SILC_PACKET_DEFAULT_SIZE * 65); if (!inbuf) { silc_mutex_unlock(ps->lock); return FALSE; @@ -336,7 +336,6 @@ static inline SilcBool silc_packet_stream_read(SilcPacketStream ps, silc_mutex_unlock(ps->lock); if (ret == -1) { /* Cannot read now, do it later. */ - silc_buffer_pull(inbuf, silc_buffer_len(inbuf)); return FALSE; } @@ -394,7 +393,6 @@ static inline SilcBool silc_packet_stream_read(SilcPacketStream ps, if (ret == -1) { /* Cannot read now, do it later. */ - silc_buffer_pull(inbuf, silc_buffer_len(inbuf)); return FALSE; } @@ -542,7 +540,7 @@ static void silc_packet_engine_context_destr(void *key, void *context, SilcPacketEngine silc_packet_engine_start(SilcRng rng, SilcBool router, - SilcPacketCallbacks *callbacks, + const SilcPacketCallbacks *callbacks, void *callback_context) { SilcPacketEngine engine; @@ -623,6 +621,60 @@ void silc_packet_engine_stop(SilcPacketEngine engine) silc_free(engine); } +static const char * const packet_error[] = { + "Cannot read from stream", + "Cannot write to stream", + "Packet MAC failed", + "Packet decryption failed", + "Unknown SID", + "Packet is malformed", + "System out of memory", +}; + +/* Return packet error string */ + +const char *silc_packet_error_string(SilcPacketError error) +{ + if (error < SILC_PACKET_ERR_READ || error > SILC_PACKET_ERR_NO_MEMORY) + return ""; + return packet_error[error]; +} + +/* Return list of packet streams in the engine */ + +SilcDList silc_packet_engine_get_streams(SilcPacketEngine engine) +{ + SilcDList list; + SilcPacketStream ps; + + list = silc_dlist_init(); + if (!list) + return NULL; + + silc_mutex_lock(engine->lock); + silc_list_start(engine->streams); + while ((ps = silc_list_get(engine->streams))) { + silc_packet_stream_ref(ps); + silc_dlist_add(list, ps); + } + silc_mutex_unlock(engine->lock); + + return list; +} + +/* Free list returned by silc_packet_engine_get_streams */ + +void silc_packet_engine_free_streams_list(SilcDList streams) +{ + SilcPacketStream ps; + + silc_dlist_start(streams); + while ((ps = silc_dlist_get(streams))) + silc_packet_stream_unref(ps); + + silc_dlist_uninit(streams); +} + /* Create new packet stream */ SilcPacketStream silc_packet_stream_create(SilcPacketEngine engine, @@ -669,20 +721,20 @@ SilcPacketStream silc_packet_stream_create(SilcPacketEngine engine, (void *)&ps->sc)) { ps->sc = silc_calloc(1, sizeof(*ps->sc)); if (!ps->sc) { - silc_packet_stream_destroy(ps); silc_mutex_unlock(engine->lock); + silc_packet_stream_destroy(ps); return NULL; } ps->sc->engine = engine; ps->sc->schedule = schedule; /* Allocate data input buffer */ - inbuf = silc_buffer_alloc(SILC_PACKET_DEFAULT_SIZE * 31); + inbuf = silc_buffer_alloc(SILC_PACKET_DEFAULT_SIZE * 65); if (!inbuf) { silc_free(ps->sc); ps->sc = NULL; - silc_packet_stream_destroy(ps); silc_mutex_unlock(engine->lock); + silc_packet_stream_destroy(ps); return NULL; } silc_buffer_reset(inbuf); @@ -692,8 +744,8 @@ SilcPacketStream silc_packet_stream_create(SilcPacketEngine engine, silc_buffer_free(inbuf); silc_free(ps->sc); ps->sc = NULL; - silc_packet_stream_destroy(ps); silc_mutex_unlock(engine->lock); + silc_packet_stream_destroy(ps); return NULL; } silc_dlist_add(ps->sc->inbufs, inbuf); @@ -704,8 +756,8 @@ SilcPacketStream silc_packet_stream_create(SilcPacketEngine engine, silc_dlist_del(ps->sc->inbufs, inbuf); silc_free(ps->sc); ps->sc = NULL; - silc_packet_stream_destroy(ps); silc_mutex_unlock(engine->lock); + silc_packet_stream_destroy(ps); return NULL; } } @@ -731,6 +783,8 @@ SilcPacketStream silc_packet_stream_create(SilcPacketEngine engine, return NULL; } + SILC_LOG_DEBUG(("Created packet stream %p", ps)); + return ps; } @@ -831,8 +885,12 @@ void silc_packet_stream_destroy(SilcPacketStream stream) return; if (silc_atomic_sub_int8(&stream->refcnt, 1) > 0) { + if (stream->destroyed) + return; stream->destroyed = TRUE; + SILC_LOG_DEBUG(("Marking packet stream %p destroyed", stream)); + /* Close the underlaying stream */ if (!stream->udp && stream->stream) silc_stream_close(stream->stream); @@ -843,17 +901,18 @@ void silc_packet_stream_destroy(SilcPacketStream stream) if (!stream->udp) { /* Delete from engine */ - engine = stream->sc->engine; - silc_mutex_lock(engine->lock); - silc_list_del(engine->streams, stream); - - /* Remove per scheduler context, if it is not used anymore */ if (stream->sc) { + engine = stream->sc->engine; + silc_mutex_lock(engine->lock); + silc_list_del(engine->streams, stream); + + /* Remove per scheduler context, if it is not used anymore */ stream->sc->stream_count--; if (!stream->sc->stream_count) silc_hash_table_del(engine->contexts, stream->sc->schedule); + + silc_mutex_unlock(engine->lock); } - silc_mutex_unlock(engine->lock); /* Destroy the underlaying stream */ if (stream->stream) @@ -862,8 +921,9 @@ void silc_packet_stream_destroy(SilcPacketStream stream) /* Delete from UDP remote hash table */ char tuple[64]; engine = stream->sc->engine; - silc_snprintf(tuple, sizeof(tuple), "%d%s", stream->remote_udp->remote_port, - stream->remote_udp->remote_ip); + silc_snprintf(tuple, sizeof(tuple), "%d%s", + stream->remote_udp->remote_port, + stream->remote_udp->remote_ip); silc_mutex_lock(engine->lock); silc_hash_table_del(engine->udp_remote, tuple); silc_mutex_unlock(engine->lock); @@ -917,6 +977,13 @@ void silc_packet_stream_destroy(SilcPacketStream stream) silc_free(stream); } +/* Return TRUE if the stream is valid */ + +SilcBool silc_packet_stream_is_valid(SilcPacketStream stream) +{ + return stream->destroyed == FALSE; +} + /* Marks as router stream */ void silc_packet_stream_set_router(SilcPacketStream stream) @@ -934,7 +1001,7 @@ void silc_packet_stream_set_iv_included(SilcPacketStream stream) /* Links `callbacks' to `stream' for specified packet types */ static SilcBool silc_packet_stream_link_va(SilcPacketStream stream, - SilcPacketCallbacks *callbacks, + const SilcPacketCallbacks *callbacks, void *callback_context, int priority, va_list ap) { @@ -1012,7 +1079,7 @@ static SilcBool silc_packet_stream_link_va(SilcPacketStream stream, /* Links `callbacks' to `stream' for specified packet types */ SilcBool silc_packet_stream_link(SilcPacketStream stream, - SilcPacketCallbacks *callbacks, + const SilcPacketCallbacks *callbacks, void *callback_context, int priority, ...) { @@ -1030,7 +1097,7 @@ SilcBool silc_packet_stream_link(SilcPacketStream stream, /* Unlinks `callbacks' from `stream'. */ void silc_packet_stream_unlink(SilcPacketStream stream, - SilcPacketCallbacks *callbacks, + const SilcPacketCallbacks *callbacks, void *callback_context) { SilcPacketProcess p; @@ -1260,11 +1327,11 @@ SilcBool silc_packet_set_ids(SilcPacketStream stream, if (!src_id && !dst_id) return FALSE; - SILC_LOG_DEBUG(("Setting new IDs to packet stream")); - silc_mutex_lock(stream->lock); if (src_id) { + SILC_LOG_DEBUG(("Setting source ID to packet stream %p", stream)); + silc_free(stream->src_id); if (!silc_id_id2str(src_id, src_id_type, tmp, sizeof(tmp), &len)) { silc_mutex_unlock(stream->lock); @@ -1280,6 +1347,8 @@ SilcBool silc_packet_set_ids(SilcPacketStream stream, } if (dst_id) { + SILC_LOG_DEBUG(("Setting destination ID to packet stream %p", stream)); + silc_free(stream->dst_id); if (!silc_id_id2str(dst_id, dst_id_type, tmp, sizeof(tmp), &len)) { silc_mutex_unlock(stream->lock); @@ -1299,6 +1368,31 @@ SilcBool silc_packet_set_ids(SilcPacketStream stream, return TRUE; } +/* Return IDs from the packet stream */ + +SilcBool silc_packet_get_ids(SilcPacketStream stream, + SilcBool *src_id_set, SilcID *src_id, + SilcBool *dst_id_set, SilcID *dst_id) +{ + if (src_id && stream->src_id) + if (!silc_id_str2id2(stream->src_id, stream->src_id_len, + stream->src_id_type, src_id)) + return FALSE; + + if (stream->src_id && src_id_set) + *src_id_set = TRUE; + + if (dst_id && stream->dst_id) + if (!silc_id_str2id2(stream->dst_id, stream->dst_id_len, + stream->dst_id_type, dst_id)) + return FALSE; + + if (stream->dst_id && dst_id_set) + *dst_id_set = TRUE; + + return TRUE; +} + /* Adds Security ID (SID) */ SilcBool silc_packet_set_sid(SilcPacketStream stream, SilcUInt8 sid) @@ -1378,14 +1472,6 @@ static inline void silc_packet_send_ctr_increment(SilcPacketStream stream, unsigned char *iv = silc_cipher_get_iv(cipher); SilcUInt32 pc1, pc2; - /* Increment 64-bit packet counter */ - SILC_GET32_MSB(pc1, iv + 4); - SILC_GET32_MSB(pc2, iv + 8); - if (++pc2 == 0) - ++pc1; - SILC_PUT32_MSB(pc1, iv + 4); - SILC_PUT32_MSB(pc2, iv + 8); - /* Reset block counter */ memset(iv + 12, 0, 4); @@ -1396,11 +1482,24 @@ static inline void silc_packet_send_ctr_increment(SilcPacketStream stream, ret_iv[1] = ret_iv[0] + iv[4]; ret_iv[2] = ret_iv[0] ^ ret_iv[1]; ret_iv[3] = ret_iv[0] + ret_iv[2]; - SILC_PUT32_MSB(pc2, ret_iv + 4); + + /* Increment 32-bit packet counter */ + SILC_GET32_MSB(pc1, iv + 8); + pc1++; + SILC_PUT32_MSB(pc1, ret_iv + 4); + SILC_LOG_HEXDUMP(("IV"), ret_iv, 8); /* Set new nonce to counter block */ - memcpy(iv + 4, ret_iv, 4); + memcpy(iv + 4, ret_iv, 8); + } else { + /* Increment 64-bit packet counter */ + SILC_GET32_MSB(pc1, iv + 4); + SILC_GET32_MSB(pc2, iv + 8); + if (++pc2 == 0) + ++pc1; + SILC_PUT32_MSB(pc1, iv + 4); + SILC_PUT32_MSB(pc2, iv + 8); } SILC_LOG_HEXDUMP(("Counter Block"), iv, 16); @@ -1467,10 +1566,8 @@ static inline SilcBool silc_packet_send_raw(SilcPacketStream stream, type and flags, and calculate correct length. Private messages with private keys and channel messages are special packets as their payload is encrypted already. */ - if ((type == SILC_PACKET_PRIVATE_MESSAGE && - flags & SILC_PACKET_FLAG_PRIVMSG_KEY) || - type == SILC_PACKET_CHANNEL_MESSAGE) { - + if (type == SILC_PACKET_PRIVATE_MESSAGE && + flags & SILC_PACKET_FLAG_PRIVMSG_KEY) { /* Padding is calculated from header + IDs */ if (!ctr) SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN + src_id_len + dst_id_len + @@ -1479,8 +1576,26 @@ static inline SilcBool silc_packet_send_raw(SilcPacketStream stream, /* Length to encrypt, header + IDs + padding. */ enclen = (SILC_PACKET_HEADER_LEN + src_id_len + dst_id_len + padlen + psnlen); - } else { + } else if (type == SILC_PACKET_CHANNEL_MESSAGE) { + if (stream->sc->engine->local_is_router && stream->is_router) { + /* Channel messages between routers are encrypted as normal packets. + Padding is calculated from true length of the packet. */ + if (!ctr) + SILC_PACKET_PADLEN(truelen + psnlen, block_len, padlen); + + enclen += padlen + psnlen; + } else { + /* Padding is calculated from header + IDs */ + if (!ctr) + SILC_PACKET_PADLEN((SILC_PACKET_HEADER_LEN + src_id_len + dst_id_len + + psnlen), block_len, padlen); + + /* Length to encrypt, header + IDs + padding. */ + enclen = (SILC_PACKET_HEADER_LEN + src_id_len + dst_id_len + + padlen + psnlen); + } + } else { /* Padding is calculated from true length of the packet */ if (flags & SILC_PACKET_FLAG_LONG_PAD) SILC_PACKET_PADLEN_MAX(truelen + psnlen, block_len, padlen); @@ -1867,8 +1982,8 @@ static inline SilcBool silc_packet_parse(SilcPacket packet) silc_buffer_len(buffer)), buffer->head, silc_buffer_headlen(buffer) + silc_buffer_len(buffer)); - SILC_LOG_DEBUG(("Incoming packet type: %d (%s)", packet->type, - silc_get_packet_name(packet->type))); + SILC_LOG_DEBUG(("Incoming packet type: %d (%s), flags %d", packet->type, + silc_get_packet_name(packet->type), packet->flags)); return TRUE; } @@ -2225,7 +2340,7 @@ silc_packet_wait_packet_receive(SilcPacketEngine engine, void *stream_context); /* Packet waiting callbacks */ -static SilcPacketCallbacks silc_packet_wait_cbs = +static const SilcPacketCallbacks silc_packet_wait_cbs = { silc_packet_wait_packet_receive, NULL, NULL }; @@ -2235,6 +2350,9 @@ typedef struct { SilcMutex wait_lock; SilcCond wait_cond; SilcList packet_queue; + unsigned char id[28]; + unsigned int id_type : 2; + unsigned int id_len : 5; unsigned int stopped : 1; } *SilcPacketWait; @@ -2249,6 +2367,13 @@ silc_packet_wait_packet_receive(SilcPacketEngine engine, { SilcPacketWait pw = callback_context; + /* If source ID is specified check for it */ + if (pw->id_len) { + if (pw->id_type != packet->src_id_type || + memcmp(pw->id, packet->src_id, pw->id_len)) + return FALSE; + } + /* Signal the waiting thread for a new packet */ silc_mutex_lock(pw->wait_lock); @@ -2267,7 +2392,8 @@ silc_packet_wait_packet_receive(SilcPacketEngine engine, /* Initialize packet waiting */ -void *silc_packet_wait_init(SilcPacketStream stream, ...) +void *silc_packet_wait_init(SilcPacketStream stream, + const SilcID *source_id, ...) { SilcPacketWait pw; SilcBool ret; @@ -2289,7 +2415,7 @@ void *silc_packet_wait_init(SilcPacketStream stream, ...) } /* Link to the packet stream for the requested packet types */ - va_start(ap, stream); + va_start(ap, source_id); ret = silc_packet_stream_link_va(stream, &silc_packet_wait_cbs, pw, 10000000, ap); va_end(ap); @@ -2303,6 +2429,14 @@ void *silc_packet_wait_init(SilcPacketStream stream, ...) /* Initialize packet queue */ silc_list_init(pw->packet_queue, struct SilcPacketStruct, next); + if (source_id) { + SilcUInt32 id_len; + silc_id_id2str(SILC_ID_GET_ID(*source_id), source_id->type, pw->id, + sizeof(pw->id), &id_len); + pw->id_type = source_id->type; + pw->id_len = id_len; + } + return (void *)pw; } @@ -2318,6 +2452,7 @@ void silc_packet_wait_uninit(void *waiter, SilcPacketStream stream) pw->stopped = TRUE; silc_cond_broadcast(pw->wait_cond); silc_mutex_unlock(pw->wait_lock); + silc_thread_yield(); /* Re-acquire lock and free resources */ silc_mutex_lock(pw->wait_lock); @@ -2394,7 +2529,7 @@ typedef struct { } *SilcPacketWrapperStream; /* Packet wrapper callbacks */ -static SilcPacketCallbacks silc_packet_wrap_cbs = +static const SilcPacketCallbacks silc_packet_wrap_cbs = { silc_packet_wrap_packet_receive, NULL, NULL }; @@ -2506,7 +2641,7 @@ int silc_packet_wrap_write(SilcStream stream, const unsigned char *data, SilcPacketWrapperStream pws = stream; SilcBool ret = FALSE; - /* Call decoder if set */ + /* Call encoder if set */ if (pws->coder) { silc_buffer_reset(pws->encbuf); ret = pws->coder(stream, SILC_STREAM_CAN_WRITE, pws->encbuf, @@ -2637,7 +2772,7 @@ SilcStream silc_packet_stream_wrap(SilcPacketStream stream, if (pws->blocking) { /* Blocking mode. Use packet waiter to do the thing. */ - pws->waiter = silc_packet_wait_init(pws->stream, pws->type, -1); + pws->waiter = silc_packet_wait_init(pws->stream, NULL, pws->type, -1); if (!pws->waiter) { silc_free(pws); return NULL;