From 97a1e25702622aca5fab8c89b5d2d3e019ea5d79 Mon Sep 17 00:00:00 2001 From: Pekka Riikonen Date: Sun, 3 Dec 2006 21:04:31 +0000 Subject: [PATCH] Added UDP connected and connectionless stream support. Added silc_packet_stream_set_remote and silc_packet_stream_get_sender. --- lib/silccore/silcpacket.c | 499 +++++++++++++++++++++++++++++--------- lib/silccore/silcpacket.h | 68 +++++- 2 files changed, 452 insertions(+), 115 deletions(-) diff --git a/lib/silccore/silcpacket.c b/lib/silccore/silcpacket.c index 39ca67c4..05ca279d 100644 --- a/lib/silccore/silcpacket.c +++ b/lib/silccore/silcpacket.c @@ -33,10 +33,11 @@ struct SilcPacketEngineStruct { SilcList streams; /* All streams in engine */ SilcList packet_pool; /* Free list for received packets */ SilcMutex lock; /* Engine lock */ + SilcHashTable udp_remote; /* UDP remote streams, or NULL */ SilcBool local_is_router; }; -/* Packet procesor context */ +/* Packet processor context */ typedef struct SilcPacketProcessStruct { SilcInt32 priority; /* Priority */ SilcPacketType *types; /* Packets to process */ @@ -44,13 +45,20 @@ typedef struct SilcPacketProcessStruct { void *callback_context; } *SilcPacketProcess; +/* UDP remote stream tuple */ +typedef struct { + char *remote_ip; /* Remote IP address */ + SilcUInt16 remote_port; /* Remote port */ +} *SilcPacketRemoteUDP; + /* Packet stream */ struct SilcPacketStreamStruct { struct SilcPacketStreamStruct *next; SilcPacketEngine engine; /* Packet engine */ SilcStream stream; /* Underlaying stream */ SilcMutex lock; /* Stream lock */ - SilcDList process; /* Packet processors, it set */ + SilcDList process; /* Packet processors, or NULL */ + SilcPacketRemoteUDP remote_udp; /* UDP remote stream tuple, or NULL */ void *stream_context; /* Stream context */ SilcBufferStruct inbuf; /* In buffer */ SilcBufferStruct outbuf; /* Out buffer */ @@ -63,6 +71,7 @@ struct SilcPacketStreamStruct { SilcUInt32 send_psn; /* Sending sequence */ SilcUInt32 receive_psn; /* Receiving sequence */ SilcAtomic8 refcnt; /* Reference counter */ + SilcUInt8 sid; /* Security ID, set if IV included */ unsigned int src_id_len : 6; unsigned int src_id_type : 2; unsigned int dst_id_len : 6; @@ -70,7 +79,7 @@ struct SilcPacketStreamStruct { unsigned int is_router : 1; /* Set if router stream */ unsigned int destroyed : 1; /* Set if destroyed */ unsigned int iv_included : 1; /* Set if IV included */ - SilcUInt8 sid; /* Security ID, set if IV included */ + unsigned int udp : 1; /* UDP remote stream */ }; /* Initial size of stream buffers */ @@ -147,109 +156,260 @@ do { \ static void silc_packet_read_process(SilcPacketStream stream); -/* Our stream IO notifier callback. */ +/* Write data to the stream. Must be called with ps->lock locked. Unlocks + the lock inside this function. */ -static void silc_packet_stream_io(SilcStream stream, SilcStreamStatus status, - void *context) +static inline SilcBool silc_packet_stream_write(SilcPacketStream ps) { - SilcPacketStream ps = context; - int ret; + SilcStream stream; + SilcBool connected; + int i; - silc_mutex_lock(ps->lock); + if (ps->udp) + stream = ((SilcPacketStream)ps->stream)->stream; + else + stream = ps->stream; + + if (ps->udp && silc_socket_stream_is_udp(stream, &connected)) { + if (!connected) { + /* Connectionless UDP stream */ + while (silc_buffer_len(&ps->outbuf) > 0) { + i = silc_net_udp_send(stream, ps->remote_udp->remote_ip, + ps->remote_udp->remote_port, + ps->outbuf.data, silc_buffer_len(&ps->outbuf)); + if (i == -2) { + /* Error */ + silc_buffer_reset(&ps->outbuf); + silc_mutex_unlock(ps->lock); + SILC_PACKET_CALLBACK_ERROR(ps, SILC_PACKET_ERR_WRITE); + return FALSE; + } - if (ps->destroyed) { - silc_mutex_unlock(ps->lock); - return; + if (i == -1) { + /* Cannot write now, write later. */ + silc_mutex_unlock(ps->lock); + return TRUE; + } + + /* Wrote data */ + silc_buffer_pull(&ps->outbuf, i); + } + + silc_buffer_reset(&ps->outbuf); + silc_mutex_unlock(ps->lock); + + return TRUE; + } } - switch (status) { + /* Write the data to the stream */ + while (silc_buffer_len(&ps->outbuf) > 0) { + i = silc_stream_write(stream, ps->outbuf.data, + silc_buffer_len(&ps->outbuf)); + if (i == 0) { + /* EOS */ + silc_buffer_reset(&ps->outbuf); + silc_mutex_unlock(ps->lock); + SILC_PACKET_CALLBACK_EOS(ps); + return FALSE; + } - case SILC_STREAM_CAN_WRITE: - if (!silc_buffer_headlen(&ps->outbuf)) { + if (i == -2) { + /* Error */ + silc_buffer_reset(&ps->outbuf); silc_mutex_unlock(ps->lock); - return; + SILC_PACKET_CALLBACK_ERROR(ps, SILC_PACKET_ERR_WRITE); + return FALSE; } - SILC_LOG_DEBUG(("Writing pending data to stream")); + if (i == -1) { + /* Cannot write now, write later. */ + silc_mutex_unlock(ps->lock); + return TRUE; + } - /* Write pending data to stream */ - while (silc_buffer_len(&ps->outbuf) > 0) { - ret = silc_stream_write(ps->stream, ps->outbuf.data, - silc_buffer_len(&ps->outbuf)); - if (ret == 0) { - /* EOS */ - silc_buffer_reset(&ps->outbuf); - silc_mutex_unlock(ps->lock); - SILC_PACKET_CALLBACK_EOS(ps); - return; - } + /* Wrote data */ + silc_buffer_pull(&ps->outbuf, i); + } + + silc_buffer_reset(&ps->outbuf); + silc_mutex_unlock(ps->lock); + + return TRUE; +} + +/* Reads data from stream. Must be called with the ps->lock locked. If this + returns FALSE the lock has been unlocked. If this returns packet stream + to `ret_ps' its lock has been acquired and `ps' lock has been unlocked. + It is returned if the stream is UDP and remote UDP stream exists for + the sender of the packet. */ +static inline SilcBool silc_packet_stream_read(SilcPacketStream ps, + SilcPacketStream *ret_ps) +{ + SilcStream stream; + SilcBool connected; + int ret; + + stream = ps->stream; + + /* Make sure we have fair amount of free space in inbuf */ + if (silc_buffer_taillen(&ps->inbuf) < SILC_PACKET_DEFAULT_SIZE) + if (!silc_buffer_realloc(&ps->inbuf, silc_buffer_truelen(&ps->inbuf) + + SILC_PACKET_DEFAULT_SIZE * 2)) { + silc_mutex_unlock(ps->lock); + SILC_PACKET_CALLBACK_ERROR(ps, SILC_PACKET_ERR_NO_MEMORY); + return FALSE; + } + + if (silc_socket_stream_is_udp(stream, &connected)) { + if (!connected) { + /* Connectionless UDP stream, read one UDP packet */ + char remote_ip[64], tuple[64]; + int remote_port; + SilcPacketStream remote; + + ret = silc_net_udp_receive(stream, remote_ip, sizeof(remote_ip), + &remote_port, ps->inbuf.tail, + silc_buffer_taillen(&ps->inbuf)); if (ret == -2) { /* Error */ - silc_buffer_reset(&ps->outbuf); + silc_buffer_reset(&ps->inbuf); silc_mutex_unlock(ps->lock); - SILC_PACKET_CALLBACK_ERROR(ps, SILC_PACKET_ERR_WRITE); - return; + SILC_PACKET_CALLBACK_ERROR(ps, SILC_PACKET_ERR_READ); + return FALSE; } if (ret == -1) { - /* Cannot write now, write later. */ + /* Cannot read now, do it later. */ + silc_buffer_pull(&ps->inbuf, silc_buffer_len(&ps->inbuf)); silc_mutex_unlock(ps->lock); - return; + return FALSE; } - /* Wrote data */ - silc_buffer_pull(&ps->outbuf, ret); + /* See if remote packet stream exist for this sender */ + snprintf(tuple, sizeof(tuple), "%d%s", remote_port, remote_ip); + silc_mutex_lock(ps->engine->lock); + if (silc_hash_table_find(ps->engine->udp_remote, tuple, NULL, + (void *)&remote)) { + /* Found packet stream for this sender, copy the packet */ + silc_mutex_unlock(ps->engine->lock); + + SILC_LOG_DEBUG(("UDP packet from %s:%d for stream %p", + remote_ip, remote_port, remote)); + + silc_mutex_lock(remote->lock); + if (ret > silc_buffer_taillen(&remote->inbuf)) + if (!silc_buffer_realloc(&remote->inbuf, ret)) { + silc_mutex_unlock(remote->lock); + silc_mutex_unlock(ps->lock); + SILC_PACKET_CALLBACK_ERROR(ps, SILC_PACKET_ERR_NO_MEMORY); + return FALSE; + } + + silc_buffer_put_tail(&remote->inbuf, ps->inbuf.tail, ret); + silc_buffer_pull_tail(&remote->inbuf, ret); + *ret_ps = remote; + + silc_buffer_reset(&ps->inbuf); + silc_mutex_unlock(ps->lock); + return TRUE; + } + silc_mutex_unlock(ps->engine->lock); + + /* Unknown sender */ + if (!ps->remote_udp) { + ps->remote_udp = silc_calloc(1, sizeof(*ps->remote_udp)); + if (!ps->remote_udp) { + silc_mutex_unlock(ps->lock); + SILC_PACKET_CALLBACK_ERROR(ps, SILC_PACKET_ERR_NO_MEMORY); + return FALSE; + } + } + + /* Save sender IP and port */ + ps->remote_udp->remote_ip = strdup(remote_ip); + ps->remote_udp->remote_port = remote_port; + + silc_buffer_pull_tail(&ps->inbuf, ret); + return TRUE; } + } - silc_buffer_reset(&ps->outbuf); + /* Read data from the stream */ + ret = silc_stream_read(ps->stream, ps->inbuf.tail, + silc_buffer_taillen(&ps->inbuf)); + if (ret == 0) { + /* EOS */ + silc_buffer_reset(&ps->inbuf); silc_mutex_unlock(ps->lock); - break; + SILC_PACKET_CALLBACK_EOS(ps); + return FALSE; + } - case SILC_STREAM_CAN_READ: - SILC_LOG_DEBUG(("Reading data from stream")); + if (ret == -2) { + /* Error */ + silc_buffer_reset(&ps->inbuf); + silc_mutex_unlock(ps->lock); + SILC_PACKET_CALLBACK_ERROR(ps, SILC_PACKET_ERR_READ); + return FALSE; + } - /* Make sure we have fair amount of free space in inbuf */ - if (silc_buffer_taillen(&ps->inbuf) < SILC_PACKET_DEFAULT_SIZE) - if (!silc_buffer_realloc(&ps->inbuf, silc_buffer_truelen(&ps->inbuf) + - SILC_PACKET_DEFAULT_SIZE * 2)) { - silc_mutex_unlock(ps->lock); - return; - } + if (ret == -1) { + /* Cannot read now, do it later. */ + silc_buffer_pull(&ps->inbuf, silc_buffer_len(&ps->inbuf)); + silc_mutex_unlock(ps->lock); + return FALSE; + } - /* Read data from stream */ - ret = silc_stream_read(ps->stream, ps->inbuf.tail, - silc_buffer_taillen(&ps->inbuf)); + silc_buffer_pull_tail(&ps->inbuf, ret); + return TRUE; +} - if (ret == 0) { - /* EOS */ - silc_buffer_reset(&ps->inbuf); - silc_mutex_unlock(ps->lock); - SILC_PACKET_CALLBACK_EOS(ps); - return; - } +/* Our stream IO notifier callback. */ - if (ret == -2) { - /* Error */ - silc_buffer_reset(&ps->inbuf); +static void silc_packet_stream_io(SilcStream stream, SilcStreamStatus status, + void *context) +{ + SilcPacketStream remote = NULL, ps = context; + + silc_mutex_lock(ps->lock); + + if (ps->destroyed) { + silc_mutex_unlock(ps->lock); + return; + } + + switch (status) { + + case SILC_STREAM_CAN_WRITE: + SILC_LOG_DEBUG(("Writing pending data to stream")); + + if (!silc_buffer_headlen(&ps->outbuf)) { silc_mutex_unlock(ps->lock); - SILC_PACKET_CALLBACK_ERROR(ps, SILC_PACKET_ERR_READ); return; } - if (ret == -1) { - /* Cannot read now, do it later. */ - silc_buffer_pull(&ps->inbuf, silc_buffer_len(&ps->inbuf)); - silc_mutex_unlock(ps->lock); + /* Write pending data to stream */ + silc_packet_stream_write(ps); + break; + + case SILC_STREAM_CAN_READ: + SILC_LOG_DEBUG(("Reading data from stream")); + + /* Read data from stream */ + if (!silc_packet_stream_read(ps, &remote)) return; - } /* Now process the data */ - silc_buffer_pull_tail(&ps->inbuf, ret); - silc_packet_read_process(ps); - - silc_mutex_unlock(ps->lock); + if (!remote) { + silc_packet_read_process(ps); + silc_mutex_unlock(ps->lock); + } else { + silc_packet_read_process(remote); + silc_mutex_unlock(remote->lock); + } break; default: @@ -303,6 +463,14 @@ static SilcPacket silc_packet_alloc(SilcPacketEngine engine) return packet; } +/* UDP remote stream hash table destructor */ + +static void silc_packet_engine_hash_destr(void *key, void *context, + void *user_context) +{ + silc_free(key); +} + /******************************** Packet API ********************************/ @@ -340,12 +508,16 @@ silc_packet_engine_start(SilcRng rng, SilcBool router, silc_list_init(engine->packet_pool, struct SilcPacketStruct, next); for (i = 0; i < 5; i++) { packet = silc_calloc(1, sizeof(*packet)); - if (!packet) + if (!packet) { + silc_packet_engine_stop(engine); return NULL; + } tmp = silc_malloc(SILC_PACKET_DEFAULT_SIZE); - if (!tmp) + if (!tmp) { + silc_packet_engine_stop(engine); return NULL; + } silc_buffer_set(&packet->buffer, tmp, SILC_PACKET_DEFAULT_SIZE); silc_buffer_reset(&packet->buffer); @@ -392,32 +564,130 @@ SilcPacketStream silc_packet_stream_create(SilcPacketEngine engine, ps->engine = engine; ps->stream = stream; silc_atomic_init8(&ps->refcnt, 1); + silc_mutex_alloc(&ps->lock); /* Allocate buffers */ tmp = silc_malloc(SILC_PACKET_DEFAULT_SIZE); - if (!tmp) + if (!tmp) { + silc_packet_stream_destroy(ps); return NULL; + } silc_buffer_set(&ps->inbuf, tmp, SILC_PACKET_DEFAULT_SIZE); silc_buffer_reset(&ps->inbuf); tmp = silc_malloc(SILC_PACKET_DEFAULT_SIZE); - if (!tmp) + if (!tmp) { + silc_packet_stream_destroy(ps); return NULL; + } silc_buffer_set(&ps->outbuf, tmp, SILC_PACKET_DEFAULT_SIZE); silc_buffer_reset(&ps->outbuf); /* Initialize packet procesors list */ ps->process = silc_dlist_init(); + if (!ps->process) { + silc_packet_stream_destroy(ps); + return NULL; + } /* Set IO notifier callback */ silc_stream_set_notifier(ps->stream, schedule, silc_packet_stream_io, ps); - silc_mutex_alloc(&ps->lock); - /* Add to engine */ silc_mutex_lock(engine->lock); silc_list_add(engine->streams, ps); silc_mutex_unlock(engine->lock); + /* If this is UDP stream, allocate UDP remote stream hash table */ + if (!engine->udp_remote && silc_socket_stream_is_udp(stream, NULL)) + engine->udp_remote = silc_hash_table_alloc(0, silc_hash_string, NULL, + silc_hash_string_compare, NULL, + silc_packet_engine_hash_destr, + NULL, TRUE); + + return ps; +} + +/* Add new remote packet stream for UDP packet streams */ + +SilcPacketStream silc_packet_stream_add_remote(SilcPacketStream stream, + const char *remote_ip, + SilcUInt16 remote_port) +{ + SilcPacketEngine engine = stream->engine; + SilcPacketStream ps; + char *tuple; + void *tmp; + + SILC_LOG_DEBUG(("Adding UDP remote %s:%d to packet stream %p", + remote_ip, remote_port, stream)); + + if (!stream || !remote_ip || !remote_port) + return NULL; + + if (!silc_socket_stream_is_udp(stream->stream, NULL)) { + SILC_LOG_ERROR(("Stream is not UDP stream, cannot add remote IP")); + return NULL; + } + + ps = silc_calloc(1, sizeof(*ps)); + if (!ps) + return NULL; + + ps->engine = engine; + silc_atomic_init8(&ps->refcnt, 1); + silc_mutex_alloc(&ps->lock); + + /* Set the UDP packet stream as underlaying stream */ + silc_packet_stream_ref(stream); + ps->stream = (SilcStream)stream; + ps->udp = TRUE; + + /* Allocate buffers */ + tmp = silc_malloc(SILC_PACKET_DEFAULT_SIZE); + if (!tmp) { + silc_packet_stream_destroy(ps); + return NULL; + } + silc_buffer_set(&ps->inbuf, tmp, SILC_PACKET_DEFAULT_SIZE); + silc_buffer_reset(&ps->inbuf); + tmp = silc_malloc(SILC_PACKET_DEFAULT_SIZE); + if (!tmp) { + silc_packet_stream_destroy(ps); + return NULL; + } + silc_buffer_set(&ps->outbuf, tmp, SILC_PACKET_DEFAULT_SIZE); + silc_buffer_reset(&ps->outbuf); + + /* Initialize packet procesors list */ + ps->process = silc_dlist_init(); + if (!ps->process) { + silc_packet_stream_destroy(ps); + return NULL; + } + + /* Add to engine with this IP and port pair */ + tuple = silc_format("%d%s", remote_port, remote_ip); + silc_mutex_lock(engine->lock); + if (!tuple || !silc_hash_table_add(engine->udp_remote, tuple, ps)) { + silc_mutex_unlock(engine->lock); + silc_packet_stream_destroy(ps); + return NULL; + } + silc_mutex_unlock(engine->lock); + + /* Save remote IP and port pair */ + ps->remote_udp = silc_calloc(1, sizeof(*ps->remote_udp)); + if (!ps->remote_udp) { + silc_packet_stream_destroy(ps); + return NULL; + } + ps->remote_udp->remote_port = remote_port; + ps->remote_udp->remote_ip = strdup(remote_ip); + if (!ps->remote_udp->remote_ip) { + silc_packet_stream_destroy(ps); + return NULL; + } + return ps; } @@ -435,10 +705,30 @@ void silc_packet_stream_destroy(SilcPacketStream stream) SILC_LOG_DEBUG(("Destroying packet stream %p", stream)); - /* Delete from engine */ - silc_mutex_lock(stream->engine->lock); - silc_list_del(stream->engine->streams, stream); - silc_mutex_unlock(stream->engine->lock); + if (!stream->udp) { + /* Delete from engine */ + silc_mutex_lock(stream->engine->lock); + silc_list_del(stream->engine->streams, stream); + silc_mutex_unlock(stream->engine->lock); + + /* Destroy the underlaying stream */ + if (stream->stream) + silc_stream_destroy(stream->stream); + } else { + /* Delete from UDP remote hash table */ + char tuple[64]; + snprintf(tuple, sizeof(tuple), "%d%s", stream->remote_udp->remote_port, + stream->remote_udp->remote_ip); + silc_mutex_lock(stream->engine->lock); + silc_hash_table_del(stream->engine->udp_remote, tuple); + silc_mutex_unlock(stream->engine->lock); + + silc_free(stream->remote_udp->remote_ip); + silc_free(stream->remote_udp); + + /* Unreference the underlaying packet stream */ + silc_packet_stream_unref((SilcPacketStream)stream->stream); + } /* Clear and free buffers */ silc_buffer_clear(&stream->inbuf); @@ -448,9 +738,6 @@ void silc_packet_stream_destroy(SilcPacketStream stream) /* XXX */ - /* Destroy the underlaying stream */ - silc_stream_destroy(stream->stream); - silc_atomic_uninit8(&stream->refcnt); silc_dlist_uninit(stream->process); silc_mutex_free(stream->lock); @@ -599,6 +886,21 @@ void silc_packet_stream_unlink(SilcPacketStream stream, silc_packet_stream_unref(stream); } +/* Return packet sender IP and port for UDP packet stream */ + +SilcBool silc_packet_stream_get_sender(SilcPacketStream stream, + const char **sender_ip, + SilcUInt16 *sender_port) +{ + if (!stream->remote_udp) + return FALSE; + + *sender_ip = stream->remote_udp->remote_ip; + *sender_port = stream->remote_udp->remote_port; + + return TRUE; +} + /* Reference packet stream */ void silc_packet_stream_ref(SilcPacketStream stream) @@ -1023,38 +1325,7 @@ static SilcBool silc_packet_send_raw(SilcPacketStream stream, } /* Write the packet to the stream */ - while (silc_buffer_len(&stream->outbuf) > 0) { - i = silc_stream_write(stream->stream, stream->outbuf.data, - silc_buffer_len(&stream->outbuf)); - if (i == 0) { - /* EOS */ - silc_buffer_reset(&stream->outbuf); - silc_mutex_unlock(stream->lock); - SILC_PACKET_CALLBACK_EOS(stream); - return FALSE; - } - - if (i == -2) { - /* Error */ - silc_buffer_reset(&stream->outbuf); - silc_mutex_unlock(stream->lock); - SILC_PACKET_CALLBACK_ERROR(stream, SILC_PACKET_ERR_WRITE); - return FALSE; - } - - if (i == -1) { - /* Cannot write now, write later. */ - silc_mutex_unlock(stream->lock); - return TRUE; - } - - /* Wrote data */ - silc_buffer_pull(&stream->outbuf, i); - } - silc_buffer_reset(&stream->outbuf); - - silc_mutex_unlock(stream->lock); - return TRUE; + return silc_packet_stream_write(stream); } /* Sends a packet */ diff --git a/lib/silccore/silcpacket.h b/lib/silccore/silcpacket.h index 89d0da9b..86f7a764 100644 --- a/lib/silccore/silcpacket.h +++ b/lib/silccore/silcpacket.h @@ -388,7 +388,7 @@ void silc_packet_engine_stop(SilcPacketEngine engine); * Create new packet stream and use the `stream' as underlaying stream. * Usually the `stream' would be a socket stream, but it can be any * stream. After this function returns, packets can immediately be - * sent to or received from the stream. + * sent to and received from the stream. * * NOTES * @@ -406,6 +406,52 @@ SilcPacketStream silc_packet_stream_create(SilcPacketEngine engine, SilcSchedule schedule, SilcStream stream); +/****f* silccore/SilcPacketAPI/silc_packet_stream_shared_create + * + * SYNOPSIS + * + * SilcPacketStream silc_packet_stream_add_remote(SilcPacketStream stream, + * const char *remote_ip, + * SilcUInt16 remote_port); + * + * DESCRIPTION + * + * This function is used to add remote receivers in packet stream `stream' + * that has UDP/IP socket stream as the underlaying stream. This function + * cannot be used with other type of streams. This returns new packet + * stream context that can be used to send to and receive packets from + * the specified remote IP and remote port, or NULL on error. The `stream' + * is the actual stream that is used to send and receive the data. + * + * When the parent `stream' receives packets from remote IP address + * and port that does not have its own remote packet stream, it returns + * the packet to the packet callback set for `stream'. The sender's + * IP address and port can then be retrieved by using the + * silc_packet_stream_get_sender function and to create new packet + * stream by calling this function. After that, all packets from that + * IP address and port will be received by the new packet stream. + * + * This interface is for connectionless UDP streams. If it is possible + * to create connected stream it should be done for performance reasons. + * + * EXAMPLE + * + * // Create parent packet stream, it can receive packets from anywhere + * listener = silc_net_udp_connect("0.0.0.0", 500, NULL, 0, schedule); + * parent = silc_packet_stream_create(engine, schedule, listener); + * + * ... + * // Received a packet to the parent stream, get the sender information. + * silc_packet_stream_get_sender(parent, &ip, &port); + * + * // Create new packet stream for this remote location. + * remote = silc_packet_stream_set_remote(parent, ip, port); + * + ***/ +SilcPacketStream silc_packet_stream_add_remote(SilcPacketStream stream, + const char *remote_ip, + SilcUInt16 remote_port); + /****f* silccore/SilcPacketAPI/silc_packet_stream_destroy * * SYNOPSIS @@ -560,6 +606,26 @@ void silc_packet_stream_unlink(SilcPacketStream stream, SilcPacketCallbacks *callbacks, void *callback_context); +/****f* silccore/SilcPacketAPI/silc_packet_stream_get_sender + * + * SYNOPSIS + * + * SilcBool silc_packet_stream_get_sender(SilcPacketStream stream, + * const char **sender_ip, + * SilcUInt16 *sender_port); + * + * DESCRIPTION + * + * Returns the packet sender's IP address and port from UDP packet stream + * indicated by `stream'. This can be called only from the packet + * callback to retrieve the information of the packet's sender. Returns + * FALSE if the information is not available. + * + ***/ +SilcBool silc_packet_stream_get_sender(SilcPacketStream stream, + const char **sender_ip, + SilcUInt16 *sender_port); + /****f* silccore/SilcPacketAPI/silc_packet_stream_ref * * SYNOPSIS -- 2.24.0