#include "rtsp-address-pool.h"
+GstRTSPAddress *
+gst_rtsp_address_copy (GstRTSPAddress * addr)
+{
+ GstRTSPAddress *copy;
+
+ g_return_val_if_fail (addr != NULL, NULL);
+
+ copy = g_slice_dup (GstRTSPAddress, addr);
+ /* only release to the pool when the original is freed. It's a bit
+ * weird but this will do for now as it avoid us to use refcounting. */
+ copy->pool = NULL;
+ copy->address = g_strdup (copy->address);
+
+ return copy;
+}
+
+static void gst_rtsp_address_pool_release_address (GstRTSPAddressPool * pool,
+ GstRTSPAddress * addr);
+
+void
+gst_rtsp_address_free (GstRTSPAddress * addr)
+{
+ g_return_if_fail (addr != NULL);
+
+ if (addr->pool) {
+ /* unrefs the pool and sets it to NULL */
+ gst_rtsp_address_pool_release_address (addr->pool, addr);
+ }
+ g_free (addr->address);
+ g_slice_free (GstRTSPAddress, addr);
+}
+
+
+G_DEFINE_BOXED_TYPE (GstRTSPAddress, gst_rtsp_address,
+ (GBoxedCopyFunc) gst_rtsp_address_copy,
+ (GBoxedFreeFunc) gst_rtsp_address_free);
+
GST_DEBUG_CATEGORY_STATIC (rtsp_address_pool_debug);
#define GST_CAT_DEFAULT rtsp_address_pool_debug
return pool;
}
+/**
+ * gst_rtsp_address_pool_clear:
+ * @pool: a #GstRTSPAddressPool
+ *
+ * Clear all addresses in @pool. There should be no outstanding
+ * allocations.
+ */
+void
+gst_rtsp_address_pool_clear (GstRTSPAddressPool * pool)
+{
+ GstRTSPAddressPoolPrivate *priv;
+
+ g_return_if_fail (GST_IS_RTSP_ADDRESS_POOL (pool));
+ g_return_if_fail (pool->priv->allocated == NULL);
+
+ priv = pool->priv;
+
+ g_mutex_lock (&priv->lock);
+ g_list_free_full (priv->addresses, (GDestroyNotify) free_range);
+ priv->addresses = NULL;
+ g_mutex_unlock (&priv->lock);
+}
+
static gboolean
fill_address (const gchar * address, guint16 port, Addr * addr)
{
return TRUE;
}
+static gchar *
+get_address_string (Addr * addr)
+{
+ gchar *res;
+ GInetAddress *inet;
+
+ inet = g_inet_address_new_from_bytes (addr->bytes,
+ addr->size == 4 ? G_SOCKET_FAMILY_IPV4 : G_SOCKET_FAMILY_IPV6);
+ res = g_inet_address_to_string (inet);
+ g_object_unref (inet);
+
+ return res;
+}
+
/**
* gst_rtsp_address_pool_add_range:
* @pool: a #GstRTSPAddressPool
* @pool: a #GstRTSPAddressPool
* @flags: flags
* @n_ports: the amount of ports
- * @address: result address
- * @port: result port
- * @ttl: result TTL
*
* Take an address and ports from @pool. @flags can be used to control the
* allocation. @n_ports consecutive ports will be allocated of which the first
* one can be found in @port.
*
- * Returns: a pointer that should be used to release the address with
- * gst_rtsp_address_pool_release_address() after usage or %NULL when no
- * address could be acquired.
+ * Returns: a #GstRTSPAddress that should be freed with gst_rtsp_address_free
+ * after use or %NULL when no address could be acquired.
*/
-gpointer
+GstRTSPAddress *
gst_rtsp_address_pool_acquire_address (GstRTSPAddressPool * pool,
- GstRTSPAddressFlags flags, gint n_ports, gchar ** address,
- guint16 * port, guint8 * ttl)
+ GstRTSPAddressFlags flags, gint n_ports)
{
GstRTSPAddressPoolPrivate *priv;
GList *walk, *next;
AddrRange *result;
+ GstRTSPAddress *addr;
g_return_val_if_fail (GST_IS_RTSP_ADDRESS_POOL (pool), NULL);
g_return_val_if_fail (n_ports > 0, NULL);
- g_return_val_if_fail (address != NULL, NULL);
- g_return_val_if_fail (port != NULL, NULL);
- g_return_val_if_fail (ttl != NULL, NULL);
priv = pool->priv;
result = NULL;
+ addr = NULL;
g_mutex_lock (&priv->lock);
/* go over available ranges */
g_mutex_unlock (&priv->lock);
if (result) {
- GInetAddress *inet;
-
- inet = g_inet_address_new_from_bytes (result->min.bytes,
- result->min.size == 4 ? G_SOCKET_FAMILY_IPV4 : G_SOCKET_FAMILY_IPV6);
-
- *address = g_inet_address_to_string (inet);
- g_object_unref (inet);
-
- *port = result->min.port;
- *ttl = result->ttl;
-
- GST_DEBUG_OBJECT (pool, "got address %s:%u ttl %u", *address, *port, *ttl);
+ addr = g_slice_new0 (GstRTSPAddress);
+ addr->pool = g_object_ref (pool);
+ addr->address = get_address_string (&result->min);
+ addr->n_ports = n_ports;
+ addr->port = result->min.port;
+ addr->ttl = result->ttl;
+ addr->priv = result;
+
+ GST_DEBUG_OBJECT (pool, "got address %s:%u ttl %u", addr->address,
+ addr->port, addr->ttl);
}
- return result;
+
+ return addr;
}
/**
* Release a previously acquired address (with
* gst_rtsp_address_pool_acquire_address()) back into @pool.
*/
-void
-gst_rtsp_address_pool_release_address (GstRTSPAddressPool * pool, gpointer id)
+static void
+gst_rtsp_address_pool_release_address (GstRTSPAddressPool * pool,
+ GstRTSPAddress * addr)
{
GstRTSPAddressPoolPrivate *priv;
GList *find;
+ AddrRange *range;
g_return_if_fail (GST_IS_RTSP_ADDRESS_POOL (pool));
- g_return_if_fail (id != NULL);
+ g_return_if_fail (addr != NULL);
+ g_return_if_fail (addr->pool == pool);
priv = pool->priv;
+ range = addr->priv;
+
+ /* we don't want to free twice */
+ addr->priv = NULL;
+ addr->pool = NULL;
g_mutex_lock (&priv->lock);
- find = g_list_find (priv->allocated, id);
+ find = g_list_find (priv->allocated, range);
if (find == NULL)
goto not_found;
priv->allocated = g_list_delete_link (priv->allocated, find);
/* FIXME, merge and do something clever */
- priv->addresses = g_list_prepend (priv->addresses, id);
+ priv->addresses = g_list_prepend (priv->addresses, range);
g_mutex_unlock (&priv->lock);
+ g_object_unref (pool);
+
return;
/* ERRORS */
not_found:
{
+ g_warning ("Released unknown address %p", addr);
g_mutex_unlock (&priv->lock);
return;
}
}
static void
-dump_range (GstRTSPAddressPool * pool, AddrRange * range)
+dump_range (AddrRange * range, GstRTSPAddressPool * pool)
{
- GInetAddress *inet;
gchar *addr1, *addr2;
- inet = g_inet_address_new_from_bytes (range->min.bytes,
- range->max.size == 4 ? G_SOCKET_FAMILY_IPV4 : G_SOCKET_FAMILY_IPV6);
- addr1 = g_inet_address_to_string (inet);
- g_object_unref (inet);
-
- inet = g_inet_address_new_from_bytes (range->max.bytes,
- range->max.size == 4 ? G_SOCKET_FAMILY_IPV4 : G_SOCKET_FAMILY_IPV6);
- addr2 = g_inet_address_to_string (inet);
- g_object_unref (inet);
-
+ addr1 = get_address_string (&range->min);
+ addr2 = get_address_string (&range->max);
g_print (" address %s-%s, port %u-%u, ttl %u\n", addr1, addr2,
range->min.port, range->max.port, range->ttl);
-
g_free (addr1);
g_free (addr2);
}
+/**
+ * gst_rtsp_address_pool_dump:
+ * @pool: a #GstRTSPAddressPool
+ *
+ * Dump the free and allocated addresses to stdout.
+ */
void
gst_rtsp_address_pool_dump (GstRTSPAddressPool * pool)
{
GstRTSPAddressPoolPrivate *priv;
- GList *walk;
g_return_if_fail (GST_IS_RTSP_ADDRESS_POOL (pool));
g_mutex_lock (&priv->lock);
g_print ("free:\n");
- for (walk = priv->addresses; walk; walk = walk->next) {
- dump_range (pool, (AddrRange *) walk->data);
- }
+ g_list_foreach (priv->addresses, (GFunc) dump_range, pool);
g_print ("allocated:\n");
- for (walk = priv->allocated; walk; walk = walk->next) {
- dump_range (pool, (AddrRange *) walk->data);
- }
+ g_list_foreach (priv->allocated, (GFunc) dump_range, pool);
g_mutex_unlock (&priv->lock);
}
projects / platform / upstream / gstreamer.git / blobdiff