[core] remove apr-util from tree

src/include/private/switch_apr_pvt.h

@@ -52,6 +52,17 @@
 
 #include <apr_portable.h>
 
+typedef struct switch_apr_queue_t switch_apr_queue_t;
+apr_status_t switch_apr_queue_create(switch_apr_queue_t **q, unsigned int queue_capacity, apr_pool_t *a);
+apr_status_t switch_apr_queue_push(switch_apr_queue_t *queue, void *data);
+apr_status_t switch_apr_queue_trypush(switch_apr_queue_t *queue, void *data);
+unsigned int switch_apr_queue_size(switch_apr_queue_t *queue);
+apr_status_t switch_apr_queue_pop(switch_apr_queue_t *queue, void **data);
+apr_status_t switch_apr_queue_pop_timeout(switch_apr_queue_t *queue, void **data, apr_interval_time_t timeout);
+apr_status_t switch_apr_queue_trypop(switch_apr_queue_t *queue, void **data);
+apr_status_t switch_apr_queue_interrupt_all(switch_apr_queue_t *queue);
+apr_status_t switch_apr_queue_term(switch_apr_queue_t *queue);
+
 #endif // __SWITCH_APR_PVT_H__
 
 /* For Emacs:

src/include/switch_apr.h

@@ -587,7 +587,7 @@ SWITCH_DECLARE(switch_status_t) switch_md5_string(char digest_str[SWITCH_MD5_DIG
  */
 
 /** Opaque structure used for queue API */
-	 typedef struct apr_queue_t switch_queue_t;
+	 typedef struct switch_apr_queue_t switch_queue_t;
 
 /**
  * create a FIFO queue

src/switch_apr.c

@@ -36,6 +36,7 @@
 #include <switch_private.h>
 #endif
 #include "private/switch_core_pvt.h"
+#include "private/switch_apr_pvt.h"
 
 /* apr headers*/
 #include <apr.h>
@@ -70,17 +71,14 @@
 /* apr_vformatter_buff_t definition*/
 #include <apr_lib.h>
 
-/* apr-util headers */
-#include <apr_queue.h>
-#include <apr_uuid.h>
 #if (defined(HAVE_LIBMD5) || defined(HAVE_LIBMD) || defined(HAVE_MD5INIT))
 #include <md5.h>
 #elif defined(HAVE_LIBCRYPTO)
 #include <openssl/md5.h>
-#else
-#include <apr_md5.h>
 #endif
 
+#include <uuid/uuid.h>
+
 /* apr stubs */
 
 SWITCH_DECLARE(int) switch_status_is_timeup(int status)
@@ -1131,7 +1129,7 @@ SWITCH_DECLARE(switch_status_t) switch_socket_create_pollset(switch_pollfd_t **
 SWITCH_DECLARE(void) switch_uuid_format(char *buffer, const switch_uuid_t *uuid)
 {
 #ifndef WIN32
-	apr_uuid_format(buffer, (const apr_uuid_t *) uuid);
+	uuid_unparse_lower(uuid->data, buffer);
 #else
 	RPC_CSTR buf;
 	UuidToString((const UUID *) uuid, &buf);
@@ -1144,7 +1142,7 @@ SWITCH_DECLARE(void) switch_uuid_get(switch_uuid_t *uuid)
 {
 	switch_mutex_lock(runtime.uuid_mutex);
 #ifndef WIN32
-	apr_uuid_get((apr_uuid_t *) uuid);
+	uuid_generate(uuid->data);
 #else
 	UuidCreate((UUID *) uuid);
 #endif
@@ -1154,7 +1152,10 @@ SWITCH_DECLARE(void) switch_uuid_get(switch_uuid_t *uuid)
 SWITCH_DECLARE(switch_status_t) switch_uuid_parse(switch_uuid_t *uuid, const char *uuid_str)
 {
 #ifndef WIN32
-	return apr_uuid_parse((apr_uuid_t *) uuid, uuid_str);
+	if (uuid_parse(uuid_str, uuid->data)) {
+		return SWITCH_STATUS_FALSE;
+	}
+	return SWITCH_STATUS_SUCCESS;
 #else
 	return UuidFromString((RPC_CSTR) uuid_str, (UUID *) uuid);
 #endif
@@ -1179,7 +1180,7 @@ SWITCH_DECLARE(switch_status_t) switch_md5(unsigned char digest[SWITCH_MD5_DIGES
 
 	return SWITCH_STATUS_SUCCESS;
 #else
-	return apr_md5(digest, input, inputLen);
+	return SWITCH_STATUS_NOTIMPL;
 #endif
 }
 
@@ -1207,22 +1208,22 @@ SWITCH_DECLARE(switch_status_t) switch_md5_string(char digest_str[SWITCH_MD5_DIG
 
 SWITCH_DECLARE(switch_status_t) switch_queue_create(switch_queue_t ** queue, unsigned int queue_capacity, switch_memory_pool_t *pool)
 {
-	return apr_queue_create(queue, queue_capacity, pool);
+	return switch_apr_queue_create(queue, queue_capacity, pool);
 }
 
 SWITCH_DECLARE(unsigned int) switch_queue_size(switch_queue_t *queue)
 {
-	return apr_queue_size(queue);
+	return switch_apr_queue_size(queue);
 }
 
 SWITCH_DECLARE(switch_status_t) switch_queue_pop(switch_queue_t *queue, void **data)
 {
-	return apr_queue_pop(queue, data);
+	return switch_apr_queue_pop(queue, data);
 }
 
 SWITCH_DECLARE(switch_status_t) switch_queue_pop_timeout(switch_queue_t *queue, void **data, switch_interval_time_t timeout)
 {
-	return apr_queue_pop_timeout(queue, data, timeout);
+	return switch_apr_queue_pop_timeout(queue, data, timeout);
 }
 
 SWITCH_DECLARE(switch_status_t) switch_queue_push(switch_queue_t *queue, void *data)
@@ -1230,7 +1231,7 @@ SWITCH_DECLARE(switch_status_t) switch_queue_push(switch_queue_t *queue, void *d
 	apr_status_t s;
 
 	do {
-		s = apr_queue_push(queue, data);
+		s = switch_apr_queue_push(queue, data);
 	} while (s == APR_EINTR);
 
 	return s;
@@ -1238,17 +1239,17 @@ SWITCH_DECLARE(switch_status_t) switch_queue_push(switch_queue_t *queue, void *d
 
 SWITCH_DECLARE(switch_status_t) switch_queue_trypop(switch_queue_t *queue, void **data)
 {
-	return apr_queue_trypop(queue, data);
+	return switch_apr_queue_trypop(queue, data);
 }
 
 SWITCH_DECLARE(switch_status_t) switch_queue_interrupt_all(switch_queue_t *queue)
 {
-	return apr_queue_interrupt_all(queue);
+	return switch_apr_queue_interrupt_all(queue);
 }
 
 SWITCH_DECLARE(switch_status_t) switch_queue_term(switch_queue_t *queue)
 {
-	return apr_queue_term(queue);
+	return switch_apr_queue_term(queue);
 }
 
 SWITCH_DECLARE(switch_status_t) switch_queue_trypush(switch_queue_t *queue, void *data)
@@ -1256,7 +1257,7 @@ SWITCH_DECLARE(switch_status_t) switch_queue_trypush(switch_queue_t *queue, void
 	apr_status_t s;
 
 	do {
-		s = apr_queue_trypush(queue, data);
+		s = switch_apr_queue_trypush(queue, data);
 	} while (s == APR_EINTR);
 
 	return s;

src/switch_apr_queue.c

@@ -0,0 +1,441 @@
+/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
+ * applicable.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <apr.h>
+#include <apr_thread_proc.h>
+#include <apr_thread_mutex.h>
+#include <apr_thread_cond.h>
+
+/* 
+ * define this to get debug messages
+ *
+#define QUEUE_DEBUG
+ */
+
+struct switch_apr_queue_t {
+    void              **data;
+    unsigned int        nelts; /**< # elements */
+    unsigned int        in;    /**< next empty location */
+    unsigned int        out;   /**< next filled location */
+    unsigned int        bounds;/**< max size of queue */
+    unsigned int        full_waiters;
+    unsigned int        empty_waiters;
+    apr_thread_mutex_t *one_big_mutex;
+    apr_thread_cond_t  *not_empty;
+    apr_thread_cond_t  *not_full;
+    int                 terminated;
+};
+
+typedef struct switch_apr_queue_t switch_apr_queue_t;
+
+#ifdef QUEUE_DEBUG
+static void Q_DBG(char*msg, switch_apr_queue_t *q) {
+    fprintf(stderr, "%ld\t#%d in %d out %d\t%s\n", 
+                    apr_os_thread_current(),
+                    q->nelts, q->in, q->out,
+                    msg
+                    );
+}
+#else
+#define Q_DBG(x,y) 
+#endif
+
+/**
+ * Detects when the switch_apr_queue_t is full. This utility function is expected
+ * to be called from within critical sections, and is not threadsafe.
+ */
+#define apr_queue_full(queue) ((queue)->nelts == (queue)->bounds)
+
+/**
+ * Detects when the switch_apr_queue_t is empty. This utility function is expected
+ * to be called from within critical sections, and is not threadsafe.
+ */
+#define apr_queue_empty(queue) ((queue)->nelts == 0)
+
+/**
+ * Callback routine that is called to destroy this
+ * switch_apr_queue_t when its pool is destroyed.
+ */
+static apr_status_t queue_destroy(void *data) 
+{
+    switch_apr_queue_t *queue = data;
+
+    /* Ignore errors here, we can't do anything about them anyway. */
+
+    apr_thread_cond_destroy(queue->not_empty);
+    apr_thread_cond_destroy(queue->not_full);
+    apr_thread_mutex_destroy(queue->one_big_mutex);
+
+    return APR_SUCCESS;
+}
+
+/**
+ * Initialize the switch_apr_queue_t.
+ */
+apr_status_t switch_apr_queue_create(switch_apr_queue_t **q, unsigned int queue_capacity, apr_pool_t *a)
+{
+    apr_status_t rv;
+    switch_apr_queue_t *queue;
+    queue = apr_palloc(a, sizeof(switch_apr_queue_t));
+    *q = queue;
+
+    /* nested doesn't work ;( */
+    rv = apr_thread_mutex_create(&queue->one_big_mutex,
+                                 APR_THREAD_MUTEX_UNNESTED,
+                                 a);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    rv = apr_thread_cond_create(&queue->not_empty, a);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    rv = apr_thread_cond_create(&queue->not_full, a);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    /* Set all the data in the queue to NULL */
+    queue->data = apr_palloc(a, queue_capacity * sizeof(void*));
+	if (!queue->data) return APR_ENOMEM;
+	memset(queue->data, 0, queue_capacity * sizeof(void*));
+    queue->bounds = queue_capacity;
+    queue->nelts = 0;
+    queue->in = 0;
+    queue->out = 0;
+    queue->terminated = 0;
+    queue->full_waiters = 0;
+    queue->empty_waiters = 0;
+
+    apr_pool_cleanup_register(a, queue, queue_destroy, apr_pool_cleanup_null);
+
+    return APR_SUCCESS;
+}
+
+/**
+ * Push new data onto the queue. Blocks if the queue is full. Once
+ * the push operation has completed, it signals other threads waiting
+ * in apr_queue_pop() that they may continue consuming sockets.
+ */
+apr_status_t switch_apr_queue_push(switch_apr_queue_t *queue, void *data)
+{
+    apr_status_t rv;
+
+    if (queue->terminated) {
+        return APR_EOF; /* no more elements ever again */
+    }
+
+    rv = apr_thread_mutex_lock(queue->one_big_mutex);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    if (apr_queue_full(queue)) {
+        if (!queue->terminated) {
+            queue->full_waiters++;
+            rv = apr_thread_cond_wait(queue->not_full, queue->one_big_mutex);
+            queue->full_waiters--;
+            if (rv != APR_SUCCESS) {
+                apr_thread_mutex_unlock(queue->one_big_mutex);
+                return rv;
+            }
+        }
+        /* If we wake up and it's still empty, then we were interrupted */
+        if (apr_queue_full(queue)) {
+            Q_DBG("queue full (intr)", queue);
+            rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+            if (rv != APR_SUCCESS) {
+                return rv;
+            }
+            if (queue->terminated) {
+                return APR_EOF; /* no more elements ever again */
+            }
+            else {
+                return APR_EINTR;
+            }
+        }
+    }
+
+    queue->data[queue->in] = data;
+    queue->in = (queue->in + 1) % queue->bounds;
+    queue->nelts++;
+
+    if (queue->empty_waiters) {
+        Q_DBG("sig !empty", queue);
+        rv = apr_thread_cond_signal(queue->not_empty);
+        if (rv != APR_SUCCESS) {
+            apr_thread_mutex_unlock(queue->one_big_mutex);
+            return rv;
+        }
+    }
+
+    rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+    return rv;
+}
+
+/**
+ * Push new data onto the queue. Blocks if the queue is full. Once
+ * the push operation has completed, it signals other threads waiting
+ * in apr_queue_pop() that they may continue consuming sockets.
+ */
+apr_status_t switch_apr_queue_trypush(switch_apr_queue_t *queue, void *data)
+{
+    apr_status_t rv;
+
+    if (queue->terminated) {
+        return APR_EOF; /* no more elements ever again */
+    }
+
+    rv = apr_thread_mutex_lock(queue->one_big_mutex);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    if (apr_queue_full(queue)) {
+        apr_thread_mutex_unlock(queue->one_big_mutex);
+        return APR_EAGAIN;
+    }
+    
+    queue->data[queue->in] = data;
+    queue->in = (queue->in + 1) % queue->bounds;
+    queue->nelts++;
+
+    if (queue->empty_waiters) {
+        Q_DBG("sig !empty", queue);
+        rv  = apr_thread_cond_signal(queue->not_empty);
+        if (rv != APR_SUCCESS) {
+            apr_thread_mutex_unlock(queue->one_big_mutex);
+            return rv;
+        }
+    }
+
+    rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+    return rv;
+}
+
+/**
+ * not thread safe
+ */
+unsigned int switch_apr_queue_size(switch_apr_queue_t *queue) {
+    return queue->nelts;
+}
+
+/**
+ * Retrieves the next item from the queue. If there are no
+ * items available, it will block until one becomes available.
+ * Once retrieved, the item is placed into the address specified by
+ * 'data'.
+ */
+apr_status_t switch_apr_queue_pop(switch_apr_queue_t *queue, void **data)
+{
+    apr_status_t rv;
+
+    if (queue->terminated) {
+        return APR_EOF; /* no more elements ever again */
+    }
+
+    rv = apr_thread_mutex_lock(queue->one_big_mutex);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    /* Keep waiting until we wake up and find that the queue is not empty. */
+    if (apr_queue_empty(queue)) {
+        if (!queue->terminated) {
+            queue->empty_waiters++;
+            rv = apr_thread_cond_wait(queue->not_empty, queue->one_big_mutex);
+            queue->empty_waiters--;
+            if (rv != APR_SUCCESS) {
+                apr_thread_mutex_unlock(queue->one_big_mutex);
+                return rv;
+            }
+        }
+        /* If we wake up and it's still empty, then we were interrupted */
+        if (apr_queue_empty(queue)) {
+            Q_DBG("queue empty (intr)", queue);
+            rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+            if (rv != APR_SUCCESS) {
+                return rv;
+            }
+            if (queue->terminated) {
+                return APR_EOF; /* no more elements ever again */
+            }
+            else {
+                return APR_EINTR;
+            }
+        }
+    } 
+
+    *data = queue->data[queue->out];
+    queue->nelts--;
+
+    queue->out = (queue->out + 1) % queue->bounds;
+    if (queue->full_waiters) {
+        Q_DBG("signal !full", queue);
+        rv = apr_thread_cond_signal(queue->not_full);
+        if (rv != APR_SUCCESS) {
+            apr_thread_mutex_unlock(queue->one_big_mutex);
+            return rv;
+        }
+    }
+
+    rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+    return rv;
+}
+
+/**
+ * Retrieves the next item from the queue. If there are no
+ * items available, it will block until one becomes available, or 
+ * until timeout is elapsed. Once retrieved, the item is placed into
+ * the address specified by'data'.
+ */
+apr_status_t switch_apr_queue_pop_timeout(switch_apr_queue_t *queue, void **data, apr_interval_time_t timeout)
+{
+    apr_status_t rv;
+
+    if (queue->terminated) {
+        return APR_EOF; /* no more elements ever again */
+    }
+
+    rv = apr_thread_mutex_lock(queue->one_big_mutex);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    /* Keep waiting until we wake up and find that the queue is not empty. */
+    if (apr_queue_empty(queue)) {
+        if (!queue->terminated) {
+            queue->empty_waiters++;
+            rv = apr_thread_cond_timedwait(queue->not_empty, queue->one_big_mutex, timeout);
+            queue->empty_waiters--;
+			/* In the event of a timemout, APR_TIMEUP will be returned */
+            if (rv != APR_SUCCESS) {
+                apr_thread_mutex_unlock(queue->one_big_mutex);
+                return rv;
+            }
+        }
+        /* If we wake up and it's still empty, then we were interrupted */
+        if (apr_queue_empty(queue)) {
+            Q_DBG("queue empty (intr)", queue);
+            rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+            if (rv != APR_SUCCESS) {
+                return rv;
+            }
+            if (queue->terminated) {
+                return APR_EOF; /* no more elements ever again */
+            }
+            else {
+                return APR_EINTR;
+            }
+        }
+    } 
+
+    *data = queue->data[queue->out];
+    queue->nelts--;
+
+    queue->out = (queue->out + 1) % queue->bounds;
+    if (queue->full_waiters) {
+        Q_DBG("signal !full", queue);
+        rv = apr_thread_cond_signal(queue->not_full);
+        if (rv != APR_SUCCESS) {
+            apr_thread_mutex_unlock(queue->one_big_mutex);
+            return rv;
+        }
+    }
+
+    rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+    return rv;
+}
+
+
+/**
+ * Retrieves the next item from the queue. If there are no
+ * items available, return APR_EAGAIN.  Once retrieved,
+ * the item is placed into the address specified by 'data'.
+ */
+apr_status_t switch_apr_queue_trypop(switch_apr_queue_t *queue, void **data)
+{
+    apr_status_t rv;
+
+    if (queue->terminated) {
+        return APR_EOF; /* no more elements ever again */
+    }
+
+    rv = apr_thread_mutex_lock(queue->one_big_mutex);
+    if (rv != APR_SUCCESS) {
+        return rv;
+    }
+
+    if (apr_queue_empty(queue)) {
+        apr_thread_mutex_unlock(queue->one_big_mutex);
+        return APR_EAGAIN;
+    } 
+
+    *data = queue->data[queue->out];
+    queue->nelts--;
+
+    queue->out = (queue->out + 1) % queue->bounds;
+    if (queue->full_waiters) {
+        Q_DBG("signal !full", queue);
+        rv = apr_thread_cond_signal(queue->not_full);
+        if (rv != APR_SUCCESS) {
+            apr_thread_mutex_unlock(queue->one_big_mutex);
+            return rv;
+        }
+    }
+
+    rv = apr_thread_mutex_unlock(queue->one_big_mutex);
+    return rv;
+}
+
+apr_status_t switch_apr_queue_interrupt_all(switch_apr_queue_t *queue)
+{
+    apr_status_t rv;
+    Q_DBG("intr all", queue);    
+    if ((rv = apr_thread_mutex_lock(queue->one_big_mutex)) != APR_SUCCESS) {
+        return rv;
+    }
+    apr_thread_cond_broadcast(queue->not_empty);
+    apr_thread_cond_broadcast(queue->not_full);
+
+    if ((rv = apr_thread_mutex_unlock(queue->one_big_mutex)) != APR_SUCCESS) {
+        return rv;
+    }
+
+    return APR_SUCCESS;
+}
+
+apr_status_t switch_apr_queue_term(switch_apr_queue_t *queue)
+{
+    apr_status_t rv;
+
+    if ((rv = apr_thread_mutex_lock(queue->one_big_mutex)) != APR_SUCCESS) {
+        return rv;
+    }
+
+    /* we must hold one_big_mutex when setting this... otherwise,
+     * we could end up setting it and waking everybody up just after a 
+     * would-be popper checks it but right before they block
+     */
+    queue->terminated = 1;
+    if ((rv = apr_thread_mutex_unlock(queue->one_big_mutex)) != APR_SUCCESS) {
+        return rv;
+    }
+    return switch_apr_queue_interrupt_all(queue);
+}
+