Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2009 Pekka Riikonen
+ Copyright (C) 1997 - 2014 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
(s)->stream_context); \
} while(0)
-static SilcBool silc_packet_dispatch(SilcPacket packet);
+static SilcBool silc_packet_dispatch(SilcPacket packet,
+ SilcPacketReceiveCb ignore_handler);
static void silc_packet_read_process(SilcPacketStream stream);
static inline SilcBool silc_packet_send_raw(SilcPacketStream stream,
SilcPacketType type,
silc_mutex_lock(stream->lock);
if (!stream->destroyed)
- silc_packet_dispatch(packet);
+ silc_packet_dispatch(packet, NULL);
silc_mutex_unlock(stream->lock);
silc_packet_stream_unref(stream);
}
if (packet) {
/* Inject packet to the new stream */
- packet->stream = ps;
- silc_packet_stream_ref(ps);
- silc_schedule_task_add_timeout(silc_stream_get_schedule(stream->stream),
- silc_packet_stream_inject_packet, packet,
- 0, 0);
+ silc_packet_stream_inject(ps, packet);
}
return ps;
}
+/* Inject packet to packet stream */
+
+SilcBool silc_packet_stream_inject(SilcPacketStream stream,
+ SilcPacket packet)
+{
+ packet->stream = stream;
+ silc_packet_stream_ref(stream);
+ return !!silc_schedule_task_add_timeout(
+ silc_stream_get_schedule(stream->stream),
+ silc_packet_stream_inject_packet, packet,
+ 0, 0);
+}
+
/* Destroy packet stream */
void silc_packet_stream_destroy(SilcPacketStream stream)
/* Get packet pointer from the outgoing buffer */
if (silc_unlikely(!silc_packet_send_prepare(stream, truelen + padlen + ivlen
+ psnlen, hmac, &packet))) {
+ SILC_LOG_ERROR(("Error preparing for packet sending"));
silc_mutex_unlock(stream->lock);
return FALSE;
}
SILC_STR_DATA(data, data_len),
SILC_STR_END);
if (silc_unlikely(i < 0)) {
+ SILC_LOG_ERROR(("Error encoding outgoing packet"));
silc_mutex_unlock(stream->lock);
return FALSE;
}
/* Dispatch packet to application. Called with stream->lock locked.
Returns FALSE if the stream was destroyed while dispatching a packet. */
-static SilcBool silc_packet_dispatch(SilcPacket packet)
+static SilcBool silc_packet_dispatch(SilcPacket packet,
+ SilcPacketReceiveCb ignore_handler)
{
SilcPacketStream stream = packet->stream;
SilcPacketProcess p;
} else {
/* Send specific types */
for (pt = p->types; *pt; pt++) {
- if (*pt != packet->type)
+ if (*pt != packet->type ||
+ ignore_handler == p->callbacks->packet_receive)
continue;
SILC_LOG_DEBUG(("Dispatching packet to %p callbacks", p->callbacks));
silc_mutex_unlock(stream->lock);
}
if (silc_buffer_len(inbuf) < paddedlen + ivlen + mac_len) {
- SILC_LOG_DEBUG(("Received partial packet, waiting for the rest "
- "(%d bytes)",
+ SILC_LOG_DEBUG(("Received partial packet (%d %s flags:%x normal:%d "
+ "len:%u paddedlen:%u), waiting for the rest (%d bytes)",
+ type, silc_get_packet_name(type), flags,
+ normal, packetlen, paddedlen,
paddedlen + mac_len - silc_buffer_len(inbuf)));
memset(tmp, 0, sizeof(tmp));
silc_dlist_del(stream->sc->inbufs, inbuf);
}
/* Dispatch the packet to application */
- if (!silc_packet_dispatch(packet))
+ if (!silc_packet_dispatch(packet, NULL))
break;
}
SilcList in_queue;
SilcPacketType type;
SilcPacketFlags flags;
+ void *src_id;
+ void *dst_id;
+ SilcIdType src_id_type;
+ SilcIdType dst_id_type;
unsigned int closed : 1;
unsigned int blocking : 1;
unsigned int read_more : 1;
void *stream_context)
{
SilcPacketWrapperStream pws = callback_context;
+ SilcID id;
if (pws->closed || !pws->callback)
return FALSE;
+ /* If dst_id was set, the incoming packet must use that id as its
+ source id. This will not work if the id is channel id because
+ the source is never the channel id, but will work with other ids. */
+ if ((pws->dst_id && pws->dst_id_type != SILC_ID_CHANNEL)) {
+ silc_id_str2id2(packet->src_id, packet->src_id_len,
+ packet->src_id_type, &id);
+ if (!SILC_ID_COMPARE_TYPE(pws->dst_id, SILC_ID_GET_ID(id),
+ packet->src_id_len)) {
+ SILC_LOG_DEBUG(("Packet is not from wanted sender"));
+ return FALSE;
+ }
+ }
+
silc_mutex_lock(pws->lock);
silc_list_add(pws->in_queue, packet);
silc_mutex_unlock(pws->lock);
{
SilcPacketWrapperStream pws = stream;
SilcPacket packet;
- SilcBool read_more = FALSE;
+ SilcBool read_more = FALSE, ret = TRUE;
int len;
if (pws->closed)
/* Call decoder if set */
if (pws->coder && !pws->read_more)
- pws->coder(stream, SILC_STREAM_CAN_READ, &packet->buffer,
- pws->coder_context);
+ ret = pws->coder(stream, SILC_STREAM_CAN_READ, &packet->buffer,
+ pws->coder_context);
+
+ if (!ret) {
+ /* If error occurred during decoding (or handler doesn't want this
+ packet), we'll reprocess this packet and try to give it to some
+ other handler that may want it. For this stream nothing was
+ received. */
+ silc_packet_dispatch(packet, silc_packet_wrap_packet_receive);
+ return -1;
+ }
len = silc_buffer_len(&packet->buffer);
if (len > buf_len) {
SilcUInt32 data_len)
{
SilcPacketWrapperStream pws = stream;
- SilcBool ret = FALSE;
+ SilcBool ret = TRUE;
- /* Call encoder if set */
- if (pws->coder) {
- silc_buffer_reset(pws->encbuf);
- ret = pws->coder(stream, SILC_STREAM_CAN_WRITE, pws->encbuf,
- pws->coder_context);
+ if (!pws->coder) {
+ if (!silc_packet_send_ext(pws->stream, pws->type, pws->flags,
+ pws->src_id_type, pws->src_id,
+ pws->dst_id_type, pws->dst_id,
+ data, data_len, NULL, NULL))
+ return -2;
+ return data_len;
}
+ silc_buffer_reset(pws->encbuf);
+ if (!silc_buffer_enlarge(pws->encbuf, data_len + 16))
+ return -2;
+ silc_buffer_pull(pws->encbuf, 16); /* Room for adding headers */
+ silc_buffer_put(pws->encbuf, data, data_len);
+
+ ret = pws->coder(stream, SILC_STREAM_CAN_WRITE, pws->encbuf,
+ pws->coder_context);
+
/* Send the SILC packet */
if (ret) {
- if (!silc_packet_send_va(pws->stream, pws->type, pws->flags,
- SILC_STR_DATA(silc_buffer_data(pws->encbuf),
- silc_buffer_len(pws->encbuf)),
- SILC_STR_DATA(data, data_len),
- SILC_STR_END))
- return -2;
- } else {
- if (!silc_packet_send(pws->stream, pws->type, pws->flags, data, data_len))
+ if (!silc_packet_send_ext(pws->stream, pws->type, pws->flags,
+ pws->src_id_type, pws->src_id,
+ pws->dst_id_type, pws->dst_id,
+ silc_buffer_datalen(pws->encbuf),
+ NULL, NULL))
return -2;
+ return data_len;
}
- return data_len;
+ /* Error */
+ return -2;
}
/* Close stream */
SilcSchedule silc_packet_wrap_get_schedule(SilcStream stream)
{
- return NULL;
+ SilcPacketWrapperStream pws = stream;
+ return silc_stream_get_schedule(pws->stream->stream);
}
/* Wraps packet stream into SilcStream. */
SilcPacketType type,
SilcPacketFlags flags,
SilcBool blocking_mode,
+ SilcIdType src_id_type, void *src_id,
+ SilcIdType dst_id_type, void *dst_id,
SilcPacketWrapCoder coder,
void *context)
{
pws->coder = coder;
pws->coder_context = context;
+ if (src_id) {
+ pws->src_id = silc_id_dup(src_id, src_id_type);
+ if (!pws->src_id) {
+ silc_free(pws);
+ return NULL;
+ }
+ pws->src_id_type = src_id_type;
+ }
+
+ if (dst_id) {
+ pws->dst_id = silc_id_dup(dst_id, dst_id_type);
+ if (!pws->dst_id) {
+ silc_free(pws);
+ return NULL;
+ }
+ pws->dst_id_type = dst_id_type;
+ }
+
/* Allocate small amount for encoder buffer. */
if (pws->coder)
pws->encbuf = silc_buffer_alloc(8);
Author: Pekka Riikonen <priikone@silcnet.org>
- Copyright (C) 1997 - 2009 Pekka Riikonen
+ Copyright (C) 1997 - 2014 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
SilcUInt16 remote_port,
SilcPacket packet);
+/****f* silccore/SilcPacketAPI/silc_packet_stream_inject
+ *
+ * SYNOPSIS
+ *
+ * SilcBool silc_packet_stream_inject(SilcPacketStream stream,
+ * SilcPacket packet);
+ *
+ * DESCRIPTION
+ *
+ * This function can be used to inject the `packet' to the given
+ * packet `stream'. The packet will appear in the packet stream's
+ * packet handler(s). If this returns FALSE the packet was not
+ * injected.
+ *
+ ***/
+SilcBool silc_packet_stream_inject(SilcPacketStream stream,
+ SilcPacket packet);
+
/****f* silccore/SilcPacketAPI/silc_packet_stream_destroy
*
* SYNOPSIS
*
* DESCRIPTION
*
- * The encoder/decoder callback for silc_packet_stream_wrap. If the
- * `status' is SILC_STREAM_CAN_WRITE then additional data can be added
- * to `buffer'. It is added before the data that is written with
- * silc_stream_write. The silc_buffer_enlarge should be called to verify
- * there is enough room in `buffer' before adding data to it. The `buffer'
- * must not be freed.
+ * The encoder/decoder callback for silc_packet_stream_wrap.
*
- * If the `status' is SILC_STREAM_CAN_READ then data from the `buffer'
- * may be read before it is passed to readed when silc_stream_read is
- * called. The `buffer' may be advanced also to hide data in it.
+ * If the `status' is SILC_STREAM_CAN_WRITE then additional data can
+ * be added to `buffer' which contains the data that is being written
+ * to the stream. There is at least 16 bytes of free space in head
+ * space of the buffer in case new headers need to be added.
+ * The silc_buffer_enlarge should be called to verify that there is
+ * enough room before adding data to it. The `buffer' must not be freed.
+ * If the return value is FALSE the encoding failed and the packet is
+ * not sent at all and the stream will receive error. Return TRUE if
+ * the encoding succeeded.
*
- * This function returns FALSE in case of error.
+ * If the `status' is SILC_STREAM_CAN_READ then data from the `buffer'
+ * may be read before it is passed to reader when silc_stream_read is
+ * called. The `buffer' may be advanced also to hide data in it. If
+ * return value is FALSE the decoding failed (or the packet is ignored)
+ * and the packet will not be processed by the wrapped packet stream.
+ * If there are other packet streams wanting the same packet, they will
+ * get it, and if not the packet will drop. Return TRUE if decoding
+ * succeeded.
*
***/
typedef SilcBool (*SilcPacketWrapCoder)(SilcStream stream,
* SilcPacketType type,
* SilcPacketFlags flags,
* SilcBool blocking_mode,
+ * SilcIdType src_id_type, void *src_id,
+ * SilcIdType dst_id_type, void *dst_id,
* SilcPacketWrapCoder coder,
* void *context);
*
* once returns one complete SILC packet data payload (which is of type of
* `type').
*
+ * If src_id and/or dst_id are set they will be used as the ids in the
+ * sent SILC packets. If the dst_id is set then the stream will receive
+ * packets only originating from that id.
+ *
* The `coder' is optional encoder/decoder callback which the packet engine
* will call if it is non-NULL. It can be used to encode additional data
* into each packet when silc_stream_write is called or decode data before
SilcPacketType type,
SilcPacketFlags flags,
SilcBool blocking_mode,
+ SilcIdType src_id_type, void *src_id,
+ SilcIdType dst_id_type, void *dst_id,
SilcPacketWrapCoder coder,
void *context);
projects / silc.git / commitdiff