Mercurial > dovecot > original-hg > dovecot-1.2

changeset 7079:d45c3058b91a HEAD

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Renamed queue to aqueue ("array queue") because struct queue already exists in Solaris.
author Timo Sirainen <tss@iki.fi>
date Tue, 01 Jan 2008 18:48:09 +0200
parents 4e3c7037c2ca
children 19bd363bcf5d
files src/auth/db-ldap.c src/auth/db-ldap.h src/lib/Makefile.am src/lib/aqueue.c src/lib/aqueue.h src/lib/queue.c src/lib/queue.h src/tests/test-lib.c
diffstat 8 files changed, 215 insertions(+), 213 deletions(-) [+]
line wrap: on
line diff
--- a/src/auth/db-ldap.c	Sun Dec 30 17:08:29 2007 +0200
+++ b/src/auth/db-ldap.c	Tue Jan 01 18:48:09 2008 +0200
@@ -8,7 +8,7 @@
 #include "ioloop.h"
 #include "array.h"
 #include "hash.h"
-#include "queue.h"
+#include "aqueue.h"
 #include "str.h"
 #include "var-expand.h"
 #include "settings.h"
@@ -273,7 +273,7 @@
 static bool db_ldap_request_queue_next(struct ldap_connection *conn)
 {
 	struct ldap_request *const *requestp, *request;
-	unsigned int queue_size = queue_count(conn->request_queue);
+	unsigned int queue_size = aqueue_count(conn->request_queue);
 	int ret = -1;
 
 	if (conn->pending_count == queue_size) {
@@ -289,8 +289,8 @@
 		return FALSE;
 
 	requestp = array_idx(&conn->request_array,
-			     queue_idx(conn->request_queue,
-				       conn->pending_count));
+			     aqueue_idx(conn->request_queue,
+					conn->pending_count));
 	request = *requestp;
 
 	if (conn->pending_count > 0 &&
@@ -336,7 +336,7 @@
 		return FALSE;
 	} else {
 		/* broken request, remove from queue */
-		queue_delete_tail(conn->request_queue);
+		aqueue_delete_tail(conn->request_queue);
 		request->callback(conn, request, NULL);
 		return TRUE;
 	}
@@ -349,7 +349,7 @@
 	request->create_time = ioloop_time;
 
 	if (conn->request_queue->full &&
-	    queue_count(conn->request_queue) >= DB_LDAP_MAX_QUEUE_SIZE) {
+	    aqueue_count(conn->request_queue) >= DB_LDAP_MAX_QUEUE_SIZE) {
 		/* Queue is full already, fail this request */
 		auth_request_log_error(request->auth_request, "ldap",
 				       "Request queue is full");
@@ -357,7 +357,7 @@
 		return;
 	}
 
-	queue_append(conn->request_queue, &request);
+	aqueue_append(conn->request_queue, &request);
 	(void)db_ldap_request_queue_next(conn);
 }
 
@@ -405,9 +405,9 @@
 	struct ldap_request *const *requestp, *request;
 	time_t diff;
 
-	while (queue_count(conn->request_queue) > 0 && max_count > 0) {
+	while (aqueue_count(conn->request_queue) > 0 && max_count > 0) {
 		requestp = array_idx(&conn->request_array,
-				     queue_idx(conn->request_queue, 0));
+				     aqueue_idx(conn->request_queue, 0));
 		request = *requestp;
 
 		diff = ioloop_time - request->create_time;
@@ -415,7 +415,7 @@
 			break;
 
 		/* timed out, abort */
-		queue_delete_tail(conn->request_queue);
+		aqueue_delete_tail(conn->request_queue);
 
 		if (request->msgid != -1) {
 			i_assert(conn->pending_count > 0);
@@ -446,10 +446,10 @@
 		return;
 	}
 
-	count = queue_count(conn->request_queue);
+	count = aqueue_count(conn->request_queue);
 	requests = count == 0 ? NULL : array_idx(&conn->request_array, 0);
 	for (i = 0; i < count; i++) {
-		request = requests[queue_idx(conn->request_queue, i)];
+		request = requests[aqueue_idx(conn->request_queue, i)];
 		if (request->msgid == msgid)
 			break;
 		if (request->msgid == -1) {
@@ -469,7 +469,7 @@
 	}
 	i_assert(conn->pending_count > 0);
 	conn->pending_count--;
-	queue_delete(conn->request_queue, i);
+	aqueue_delete(conn->request_queue, i);
 
 	ret = ldap_result2error(conn->ld, res, 0);
 	if (ret != LDAP_SUCCESS && request->type == LDAP_REQUEST_TYPE_SEARCH) {
@@ -529,7 +529,7 @@
 	} else if (ldap_get_errno(conn) != LDAP_SERVER_DOWN) {
 		i_error("LDAP: ldap_result() failed: %s", ldap_get_error(conn));
 		ldap_conn_reconnect(conn);
-	} else if (queue_count(conn->request_queue) > 0 ||
+	} else if (aqueue_count(conn->request_queue) > 0 ||
 		   ioloop_time - conn->last_reply_stamp <
 		   				DB_LDAP_IDLE_RECONNECT_SECS) {
 		i_error("LDAP: Connection lost to LDAP server, reconnecting");
@@ -718,7 +718,7 @@
 			       DB_LDAP_REQUEST_DISCONNECT_TIMEOUT_SECS,
 			       FALSE, "LDAP server not connected");
 
-	if (queue_count(conn->request_queue) == 0) {
+	if (aqueue_count(conn->request_queue) == 0) {
 		/* no requests left, remove this timeout handler */
 		timeout_remove(&conn->to);
 	}
@@ -735,7 +735,7 @@
 	if (conn->pending_count != 0) {
 		requests = array_idx(&conn->request_array, 0);
 		for (i = 0; i < conn->pending_count; i++) {
-			request = requests[queue_idx(conn->request_queue, i)];
+			request = requests[aqueue_idx(conn->request_queue, i)];
 
 			i_assert(request->msgid != -1);
 			request->msgid = -1;
@@ -752,7 +752,7 @@
 	}
 	conn->fd = -1;
 
-	if (queue_count(conn->request_queue) == 0) {
+	if (aqueue_count(conn->request_queue) == 0) {
 		if (conn->to != NULL)
 			timeout_remove(&conn->to);
 	} else if (conn->to == NULL) {
@@ -1084,7 +1084,7 @@
 	conn->set.ldap_scope = scope2str(conn->set.scope);
 
 	i_array_init(&conn->request_array, DB_LDAP_MAX_QUEUE_SIZE);
-	conn->request_queue = queue_init(&conn->request_array.arr);
+	conn->request_queue = aqueue_init(&conn->request_array.arr);
 
 	conn->next = ldap_connections;
         ldap_connections = conn;
@@ -1114,7 +1114,7 @@
 	i_assert(conn->to == NULL);
 
 	array_free(&conn->request_array);
-	queue_deinit(&conn->request_queue);
+	aqueue_deinit(&conn->request_queue);
 
 	if (conn->pass_attr_map != NULL)
 		hash_destroy(&conn->pass_attr_map);
--- a/src/auth/db-ldap.h	Sun Dec 30 17:08:29 2007 +0200
+++ b/src/auth/db-ldap.h	Tue Jan 01 18:48:09 2008 +0200
@@ -121,7 +121,7 @@
 
 	/* Request queue contains sent requests at tail (msgid != -1) and
 	   queued requests at head (msgid == -1). */
-	struct queue *request_queue;
+	struct aqueue *request_queue;
 	ARRAY_DEFINE(request_array, struct ldap_request *);
 	/* Number of messages in queue with msgid != -1 */
 	unsigned int pending_count;
--- a/src/lib/Makefile.am	Sun Dec 30 17:08:29 2007 +0200
+++ b/src/lib/Makefile.am	Tue Jan 01 18:48:09 2008 +0200
@@ -9,6 +9,7 @@
 	perl $(srcdir)/unicodemap.pl < UnicodeData.txt > $@
 
 liblib_a_SOURCES = \
+	aqueue.c \
 	backtrace-string.c \
 	base64.c \
 	bsearch-insert-pos.c \
@@ -77,7 +78,6 @@
 	primes.c \
 	printf-format-fix.c \
 	process-title.c \
-	queue.c \
 	randgen.c \
 	read-full.c \
 	restrict-access.c \
@@ -104,6 +104,7 @@
 	write-full.c
 
 headers = \
+	aqueue.h \
 	array.h \
 	array-decl.h \
 	backtrace-string.h \
@@ -160,7 +161,6 @@
 	primes.h \
 	printf-format-fix.h \
 	process-title.h \
-	queue.h \
 	randgen.h \
 	read-full.h \
 	restrict-access.h \
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/lib/aqueue.c	Tue Jan 01 18:48:09 2008 +0200
@@ -0,0 +1,124 @@
+/* Copyright (c) 2003-2007 Dovecot authors, see the included COPYING file */
+
+#include "lib.h"
+#include "array.h"
+#include "aqueue.h"
+
+struct aqueue *aqueue_init(struct array *array)
+{
+	struct aqueue *aqueue;
+
+	aqueue = i_new(struct aqueue, 1);
+	aqueue->arr = array;
+	aqueue->area_size = buffer_get_size(aqueue->arr->buffer) /
+		aqueue->arr->element_size;
+	i_assert(aqueue->area_size > 0);
+	return aqueue;
+}
+
+void aqueue_deinit(struct aqueue **_aqueue)
+{
+	struct aqueue *aqueue = *_aqueue;
+
+	*_aqueue = NULL;
+	i_free(aqueue);
+}
+
+static void aqueue_grow(struct aqueue *aqueue)
+{
+	unsigned int orig_area_size, count;
+
+	i_assert(aqueue->full && aqueue->head == aqueue->tail);
+
+	orig_area_size = aqueue->area_size;
+	(void)array_append_space_i(aqueue->arr);
+	aqueue->area_size = buffer_get_size(aqueue->arr->buffer) /
+		aqueue->arr->element_size;
+	i_assert(orig_area_size < aqueue->area_size);
+
+	count = I_MIN(aqueue->area_size - orig_area_size, aqueue->head);
+	array_copy(aqueue->arr, orig_area_size, aqueue->arr, 0, count);
+	if (count < aqueue->area_size - orig_area_size)
+		aqueue->head = orig_area_size + count;
+	else {
+		array_copy(aqueue->arr, 0, aqueue->arr, count,
+			   aqueue->head - count);
+		aqueue->head -= count;
+	}
+
+	i_assert(aqueue->head != aqueue->tail);
+	aqueue->full = FALSE;
+}
+
+void aqueue_append(struct aqueue *aqueue, const void *data)
+{
+	if (aqueue->full) {
+		aqueue_grow(aqueue);
+		i_assert(!aqueue->full);
+	}
+
+	array_idx_set_i(aqueue->arr, aqueue->head, data);
+	aqueue->head = (aqueue->head + 1) % aqueue->area_size;
+	aqueue->full = aqueue->head == aqueue->tail;
+}
+
+void aqueue_delete(struct aqueue *aqueue, unsigned int n)
+{
+	unsigned int idx, count = aqueue_count(aqueue);
+
+	i_assert(n < count);
+
+	aqueue->full = FALSE;
+	if (n == 0) {
+		/* optimized deletion from tail */
+		aqueue->tail = (aqueue->tail + 1) % aqueue->area_size;
+		return;
+	}
+	if (n == count-1) {
+		/* optimized deletion from head */
+		aqueue->head = (aqueue->head + aqueue->area_size - 1) %
+			aqueue->area_size;
+		return;
+	}
+
+	idx = aqueue_idx(aqueue, n);
+	if ((n < count/2 || idx > aqueue->head) && idx > aqueue->tail) {
+		/* move tail forward.
+		   ..tail##idx##head.. or ##head..tail##idx## */
+		array_copy(aqueue->arr, aqueue->tail + 1,
+			   aqueue->arr, aqueue->tail,
+			   idx - aqueue->tail);
+		aqueue->tail++;
+		i_assert(aqueue->tail < aqueue->area_size);
+	} else {
+		/* move head backward.
+		   ..tail##idx##head.. or ##idx##head..tail## */
+		i_assert(idx < aqueue->head);
+		array_copy(aqueue->arr, idx,
+			   aqueue->arr, idx + 1,
+			   aqueue->head - idx);
+		aqueue->head = (aqueue->head + aqueue->area_size - 1) %
+			aqueue->area_size;
+	}
+	i_assert(aqueue->head < aqueue->area_size &&
+		 aqueue->head != aqueue->tail);
+}
+
+void aqueue_delete_tail(struct aqueue *aqueue)
+{
+	aqueue_delete(aqueue, 0);
+}
+
+void aqueue_clear(struct aqueue *aqueue)
+{
+	aqueue->head = aqueue->tail = 0;
+	aqueue->full = FALSE;
+}
+
+unsigned int aqueue_count(const struct aqueue *aqueue)
+{
+	unsigned int area_size = aqueue->area_size;
+
+	return aqueue->full ? area_size :
+		(area_size - aqueue->tail + aqueue->head) % area_size;
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/lib/aqueue.h	Tue Jan 01 18:48:09 2008 +0200
@@ -0,0 +1,41 @@
+#ifndef AQUEUE_H
+#define AQUEUE_H
+
+/* Dynamically growing queue. Use the array directly to access the data,
+   for example:
+
+   count = queue_count(queue);
+   for (i = 0; i < count; i++) {
+     data = array[queue_idx(i)];
+   }
+*/
+
+struct aqueue {
+	struct array *arr;
+	unsigned int head, tail, area_size;
+	bool full;
+};
+
+struct aqueue *aqueue_init(struct array *array);
+void aqueue_deinit(struct aqueue **aqueue);
+
+/* Append item to head */
+void aqueue_append(struct aqueue *aqueue, const void *data);
+/* Delete last item from tail */
+void aqueue_delete_tail(struct aqueue *aqueue);
+/* Remove item from n'th position */
+void aqueue_delete(struct aqueue *aqueue, unsigned int n);
+/* Clear the entire aqueue */
+void aqueue_clear(struct aqueue *aqueue);
+
+/* Returns the number of items in aqueue. */
+unsigned int aqueue_count(const struct aqueue *aqueue);
+
+/* Returns array index of n'th element in aqueue. */
+static inline unsigned int
+aqueue_idx(const struct aqueue *aqueue, unsigned int n)
+{
+	return (aqueue->tail + n) % aqueue->area_size;
+}
+
+#endif
--- a/src/lib/queue.c	Sun Dec 30 17:08:29 2007 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,123 +0,0 @@
-/* Copyright (c) 2003-2007 Dovecot authors, see the included COPYING file */
-
-#include "lib.h"
-#include "array.h"
-#include "queue.h"
-
-struct queue *queue_init(struct array *array)
-{
-	struct queue *queue;
-
-	queue = i_new(struct queue, 1);
-	queue->arr = array;
-	queue->area_size =
-		buffer_get_size(queue->arr->buffer) / queue->arr->element_size;
-	i_assert(queue->area_size > 0);
-	return queue;
-}
-
-void queue_deinit(struct queue **_queue)
-{
-	struct queue *queue = *_queue;
-
-	*_queue = NULL;
-	i_free(queue);
-}
-
-static void queue_grow(struct queue *queue)
-{
-	unsigned int orig_area_size, count;
-
-	i_assert(queue->full && queue->head == queue->tail);
-
-	orig_area_size = queue->area_size;
-	(void)array_append_space_i(queue->arr);
-	queue->area_size =
-		buffer_get_size(queue->arr->buffer) / queue->arr->element_size;
-	i_assert(orig_area_size < queue->area_size);
-
-	count = I_MIN(queue->area_size - orig_area_size, queue->head);
-	array_copy(queue->arr, orig_area_size, queue->arr, 0, count);
-	if (count < queue->area_size - orig_area_size)
-		queue->head = orig_area_size + count;
-	else {
-		array_copy(queue->arr, 0, queue->arr, count,
-			   queue->head - count);
-		queue->head -= count;
-	}
-
-	i_assert(queue->head != queue->tail);
-	queue->full = FALSE;
-}
-
-void queue_append(struct queue *queue, const void *data)
-{
-	if (queue->full) {
-		queue_grow(queue);
-		i_assert(!queue->full);
-	}
-
-	array_idx_set_i(queue->arr, queue->head, data);
-	queue->head = (queue->head + 1) % queue->area_size;
-	queue->full = queue->head == queue->tail;
-}
-
-void queue_delete(struct queue *queue, unsigned int n)
-{
-	unsigned int idx, count = queue_count(queue);
-
-	i_assert(n < count);
-
-	queue->full = FALSE;
-	if (n == 0) {
-		/* optimized deletion from tail */
-		queue->tail = (queue->tail + 1) % queue->area_size;
-		return;
-	}
-	if (n == count-1) {
-		/* optimized deletion from head */
-		queue->head = (queue->head + queue->area_size - 1) %
-			queue->area_size;
-		return;
-	}
-
-	idx = queue_idx(queue, n);
-	if ((n < count/2 || idx > queue->head) && idx > queue->tail) {
-		/* move tail forward.
-		   ..tail##idx##head.. or ##head..tail##idx## */
-		array_copy(queue->arr, queue->tail + 1,
-			   queue->arr, queue->tail,
-			   idx - queue->tail);
-		queue->tail++;
-		i_assert(queue->tail < queue->area_size);
-	} else {
-		/* move head backward.
-		   ..tail##idx##head.. or ##idx##head..tail## */
-		i_assert(idx < queue->head);
-		array_copy(queue->arr, idx,
-			   queue->arr, idx + 1,
-			   queue->head - idx);
-		queue->head = (queue->head + queue->area_size - 1) %
-			queue->area_size;
-	}
-	i_assert(queue->head < queue->area_size && queue->head != queue->tail);
-}
-
-void queue_delete_tail(struct queue *queue)
-{
-	queue_delete(queue, 0);
-}
-
-void queue_clear(struct queue *queue)
-{
-	queue->head = queue->tail = 0;
-	queue->full = FALSE;
-}
-
-unsigned int queue_count(const struct queue *queue)
-{
-	unsigned int area_size = queue->area_size;
-
-	return queue->full ? area_size :
-		(area_size - queue->tail + queue->head) % area_size;
-}
--- a/src/lib/queue.h	Sun Dec 30 17:08:29 2007 +0200
+++ /dev/null	Thu Jan 01 00:00:00 1970 +0000
@@ -1,40 +0,0 @@
-#ifndef QUEUE_H
-#define QUEUE_H
-
-/* Dynamically growing queue. Use the array directly to access the data,
-   for example:
-
-   count = queue_count(queue);
-   for (i = 0; i < count; i++) {
-     data = array[queue_idx(i)];
-   }
-*/
-
-struct queue {
-	struct array *arr;
-	unsigned int head, tail, area_size;
-	bool full;
-};
-
-struct queue *queue_init(struct array *array);
-void queue_deinit(struct queue **queue);
-
-/* Append item to head */
-void queue_append(struct queue *queue, const void *data);
-/* Delete last item from tail */
-void queue_delete_tail(struct queue *queue);
-/* Remove item from n'th position */
-void queue_delete(struct queue *queue, unsigned int n);
-/* Clear the entire queue */
-void queue_clear(struct queue *queue);
-
-/* Returns the number of items in queue. */
-unsigned int queue_count(const struct queue *queue);
-
-/* Returns array index of n'th element in queue. */
-static inline unsigned int queue_idx(const struct queue *queue, unsigned int n)
-{
-	return (queue->tail + n) % queue->area_size;
-}
-
-#endif
--- a/src/tests/test-lib.c	Sun Dec 30 17:08:29 2007 +0200
+++ b/src/tests/test-lib.c	Tue Jan 01 18:48:09 2008 +0200
@@ -5,7 +5,7 @@
 #include "str.h"
 #include "base64.h"
 #include "bsearch-insert-pos.h"
-#include "queue.h"
+#include "aqueue.h"
 #include "seq-range-array.h"
 #include "str-sanitize.h"
 
@@ -124,14 +124,14 @@
 	}
 }
 
-static bool queue_is_ok(struct queue *queue, unsigned int deleted_n)
+static bool aqueue_is_ok(struct aqueue *aqueue, unsigned int deleted_n)
 {
 	const unsigned int *p;
 	unsigned int n, i, count;
 
-	count = queue_count(queue);
+	count = aqueue_count(aqueue);
 	for (i = 0, n = 1; i < count; i++, n++) {
-		p = array_idx_i(queue->arr, queue_idx(queue, i));
+		p = array_idx_i(aqueue->arr, aqueue_idx(aqueue, i));
 		if (i == deleted_n)
 			n++;
 		if (*p != n)
@@ -140,54 +140,54 @@
 	return TRUE;
 }
 
-static const unsigned int queue_input[] = { 1, 2, 3, 4, 5, 6 };
-static const char *test_queue2(unsigned int initial_size)
+static const unsigned int aqueue_input[] = { 1, 2, 3, 4, 5, 6 };
+static const char *test_aqueue2(unsigned int initial_size)
 {
-	ARRAY_DEFINE(queue_array, unsigned int);
+	ARRAY_DEFINE(aqueue_array, unsigned int);
 	unsigned int i, j, k;
-	struct queue *queue;
+	struct aqueue *aqueue;
 
-	for (i = 0; i < N_ELEMENTS(queue_input); i++) {
-		for (k = 0; k < N_ELEMENTS(queue_input); k++) {
-			t_array_init(&queue_array, initial_size);
-			queue = queue_init(&queue_array.arr);
-			queue->head = queue->tail = initial_size - 1;
+	for (i = 0; i < N_ELEMENTS(aqueue_input); i++) {
+		for (k = 0; k < N_ELEMENTS(aqueue_input); k++) {
+			t_array_init(&aqueue_array, initial_size);
+			aqueue = aqueue_init(&aqueue_array.arr);
+			aqueue->head = aqueue->tail = initial_size - 1;
 			for (j = 0; j < k; j++) {
-				queue_append(queue, &queue_input[j]);
-				if (queue_count(queue) != j + 1) {
+				aqueue_append(aqueue, &aqueue_input[j]);
+				if (aqueue_count(aqueue) != j + 1) {
 					return t_strdup_printf("Wrong count after append %u vs %u)",
-							       queue_count(queue), j + 1);
+							       aqueue_count(aqueue), j + 1);
 				}
-				if (!queue_is_ok(queue, -1U))
+				if (!aqueue_is_ok(aqueue, -1U))
 					return "Invalid data after append";
 			}
 
 			if (k != 0 && i < k) {
-				queue_delete(queue, i);
-				if (queue_count(queue) != k - 1)
+				aqueue_delete(aqueue, i);
+				if (aqueue_count(aqueue) != k - 1)
 					return "Wrong count after delete";
-				if (!queue_is_ok(queue, i))
+				if (!aqueue_is_ok(aqueue, i))
 					return "Invalid data after delete";
 			}
 		}
 	}
-	queue_clear(queue);
-	if (queue_count(queue) != 0)
-		return "queue_clear() broken";
+	aqueue_clear(aqueue);
+	if (aqueue_count(aqueue) != 0)
+		return "aqueue_clear() broken";
 	return NULL;
 }
 
-static void test_queue(void)
+static void test_aqueue(void)
 {
 	unsigned int i;
 	const char *reason = NULL;
 
-	for (i = 1; i <= N_ELEMENTS(queue_input) + 1 && reason == NULL; i++) {
+	for (i = 1; i <= N_ELEMENTS(aqueue_input) + 1 && reason == NULL; i++) {
 		T_FRAME(
-			reason = test_queue2(i);
+			reason = test_aqueue2(i);
 		);
 	}
-	test_out_reason("queue", reason == NULL, reason);
+	test_out_reason("aqueue", reason == NULL, reason);
 }
 
 static void test_seq_range_array(void)
@@ -274,7 +274,7 @@
 		test_base64_encode,
 		test_base64_decode,
 		test_bsearch_insert_pos,
-		test_queue,
+		test_aqueue,
 		test_seq_range_array,
 		test_str_sanitize,