int ldap_connection_init(struct ldap_client *client,
const struct ldap_client_settings *set,
struct ldap_connection **conn_r, const char **error_r)
{
i_assert(set->uri != NULL);
if (set->require_ssl &&
!set->start_tls &&
strncmp("ldaps://",set->uri,8) != 0) {
*error_r = t_strdup_printf("ldap_connection_init(uri=%s) failed: %s", set->uri,
"uri does not start with ldaps and ssl required without start TLS");
return -1;
}
pool_t pool = pool_alloconly_create("ldap connection", 1024);
struct ldap_connection *conn = p_new(pool, struct ldap_connection, 1);
conn->pool = pool;
conn->client = client;
conn->set = *set;
/* deep copy relevant strings */
conn->set.uri = p_strdup(pool, set->uri);
conn->set.bind_dn = p_strdup(pool, set->bind_dn);
if (set->password != NULL) {
conn->set.password = p_strdup(pool, set->password);
ber_str2bv(conn->set.password, strlen(conn->set.password), 0, &(conn->cred));
}
/* cannot use these */
conn->ssl_set.ca = NULL;
conn->ssl_set.key_password = NULL;
conn->ssl_set.cert_username_field = NULL;
conn->ssl_set.crypto_device = NULL;
if (set->ssl_set != NULL) {
/* keep in sync with ldap_connection_have_settings() */
conn->set.ssl_set = &conn->ssl_set;
conn->ssl_set.protocols = p_strdup(pool, set->ssl_set->protocols);
conn->ssl_set.cipher_list = p_strdup(pool, set->ssl_set->cipher_list);
conn->ssl_set.ca_file = p_strdup(pool, set->ssl_set->ca_file);
conn->ssl_set.cert = p_strdup(pool, set->ssl_set->cert);
conn->ssl_set.key = p_strdup(pool, set->ssl_set->key);
}
i_assert(ldap_connection_have_settings(conn, set));
if (ldap_connection_setup(conn, error_r) < 0) {
ldap_connection_deinit(&conn);
return -1;
}
p_array_init(&(conn->request_array), conn->pool, 10);
conn->request_queue = aqueue_init(&(conn->request_array.arr));
*conn_r = conn;
return 0;
}
static struct dsync_mailbox_tree_bfs_iter *
dsync_mailbox_tree_bfs_iter_init(struct dsync_mailbox_tree *tree)
{
struct dsync_mailbox_tree_bfs_iter *iter;
iter = i_new(struct dsync_mailbox_tree_bfs_iter, 1);
iter->tree = tree;
i_array_init(&iter->queue_arr, 32);
iter->queue = aqueue_init(&iter->queue_arr.arr);
iter->cur = tree->root.first_child;
return iter;
}
static char const* test_aqueue(void) {
Aqueue aq;
Aqueue* const p = &aq;
aqueue_init(p, sizeof(int), MAX_CAPACITY, NULL);
MIN_UNIT_ASSERT("aqueue_init is wrong.", aqueue_is_empty(p) == true);
MIN_UNIT_ASSERT("aqueue_init is wrong.", aqueue_get_capacity(p) == MAX_CAPACITY);
MIN_UNIT_ASSERT("aqueue_init is wrong.", aqueue_get_size(p) == 0);
for (int i = 0; i < MAX_CAPACITY; i++) {
aqueue_insert(p, &i);
MIN_UNIT_ASSERT("aqueue_insert is wrong.", aqueue_get(int, p) == 0);
}
MIN_UNIT_ASSERT("aqueue_insert result is wrong.", aqueue_get_size(p) == MAX_CAPACITY);
for (int i = 0; i < MAX_CAPACITY; i++) {
int* t = (int*)aqueue_get_first(p);
MIN_UNIT_ASSERT("aqueue_get is wrong.", *t == i);
aqueue_delete_first(p);
}
MIN_UNIT_ASSERT("aqueue_delete_first is wrong", aqueue_is_empty(p) == true);
aqueue_destruct(p);
aqueue_init(p, sizeof(char*), MAX_CAPACITY, release_str);
for (int i = 0; i < STR_NUM; i++) {
aqueue_insert(p, &sample_str_data[i]);
MIN_UNIT_ASSERT("aqueue_insert is wrong", 0 == strcmp(sample_str_data[0], aqueue_get(char const*, p)));
}
MIN_UNIT_ASSERT("aqueue_insert result is wrong.", aqueue_get_size(p) == STR_NUM);
MIN_UNIT_ASSERT("aqueue_insert result is wrong.", aqueue_is_empty(p) == false);
aqueue_destruct(p);
MIN_UNIT_ASSERT("aqueue_destruct is wrong.", p->data != NULL);
printf("All Test Passed.\n");
return NULL;
}
struct worker_connection *
worker_connection_create(const char *socket_path,
indexer_status_callback_t *callback)
{
struct worker_connection *conn;
conn = i_new(struct worker_connection, 1);
conn->refcount = 1;
conn->socket_path = i_strdup(socket_path);
conn->callback = callback;
conn->fd = -1;
i_array_init(&conn->request_contexts, 32);
conn->request_queue = aqueue_init(&conn->request_contexts.arr);
return conn;
}
static const char *test_aqueue2(unsigned int initial_size)
{
ARRAY(unsigned int) aqueue_array;
unsigned int i, j, k;
for (i = 0; i < N_ELEMENTS(aqueue_input); i++) {
for (k = 0; k < N_ELEMENTS(aqueue_input); k++) {
struct aqueue *aqueue;
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++) {
aqueue_append(aqueue, &aqueue_input[j]);
if (aqueue_count(aqueue) != j + 1) {
return t_strdup_printf("Wrong count after append %u vs %u)",
aqueue_count(aqueue), j + 1);
}
if (!aqueue_is_ok(aqueue, UINT_MAX))
return "Invalid data after append";
}
if (k != 0 && i < k) {
aqueue_delete(aqueue, i);
if (aqueue_count(aqueue) != k - 1)
return "Wrong count after delete";
if (!aqueue_is_ok(aqueue, i))
return "Invalid data after delete";
}
aqueue_clear(aqueue);
if (aqueue_count(aqueue) != 0)
return "aqueue_clear() broken";
aqueue_deinit(&aqueue);
}
}
return NULL;
}
