void worker_connection_request(struct worker_connection *conn,
const struct indexer_request *request,
void *context)
{
i_assert(worker_connection_is_connected(conn));
i_assert(context != NULL);
i_assert(request->index || request->optimize);
if (conn->request_username == NULL)
conn->request_username = i_strdup(request->username);
else {
i_assert(strcmp(conn->request_username,
request->username) == 0);
}
aqueue_append(conn->request_queue, &context);
T_BEGIN {
string_t *str = t_str_new(128);
str_append_tabescaped(str, request->username);
str_append_c(str, '\t');
str_append_tabescaped(str, request->mailbox);
str_append_c(str, '\t');
if (request->session_id != NULL)
str_append_tabescaped(str, request->session_id);
str_printfa(str, "\t%u\t", request->max_recent_msgs);
if (request->index)
str_append_c(str, 'i');
if (request->optimize)
str_append_c(str, 'o');
str_append_c(str, '\n');
o_stream_nsend(conn->output, str_data(str), str_len(str));
} T_END;
}
void ldap_connection_queue_request(struct ldap_connection *conn, struct ldap_op_queue_entry *req)
{
req->msgid = -1;
req->conn = conn;
aqueue_append(conn->request_queue, &req);
if (req->timeout_secs > 0)
req->to_abort = timeout_add(req->timeout_secs * 1000, ldap_connection_abort_request, req);
ldap_connection_send_next(conn);
}
static bool
dsync_mailbox_tree_bfs_iter_next(struct dsync_mailbox_tree_bfs_iter *iter,
struct dsync_mailbox_node **node_r)
{
struct dsync_mailbox_node *const *nodep;
if (iter->cur == NULL) {
if (aqueue_count(iter->queue) == 0)
return FALSE;
nodep = array_idx(&iter->queue_arr, aqueue_idx(iter->queue, 0));
iter->cur = *nodep;
aqueue_delete_tail(iter->queue);
}
*node_r = iter->cur;
if (iter->cur->first_child != NULL)
aqueue_append(iter->queue, &iter->cur->first_child);
iter->cur = iter->cur->next;
return TRUE;
}
static void
auth_request_handle_failure(struct auth_request *request, const char *reply)
{
struct auth_request_handler *handler = request->handler;
if (request->in_delayed_failure_queue) {
/* we came here from flush_failures() */
handler->callback(reply, handler->context);
return;
}
/* remove the request from requests-list */
auth_request_ref(request);
auth_request_handler_remove(handler, request);
if (auth_fields_exists(request->extra_fields, "nodelay")) {
/* passdb specifically requested not to delay the reply. */
handler->callback(reply, handler->context);
auth_request_unref(&request);
return;
}
/* failure. don't announce it immediately to avoid
a) timing attacks, b) flooding */
request->in_delayed_failure_queue = TRUE;
handler->refcount++;
if (auth_penalty != NULL) {
auth_penalty_update(auth_penalty, request,
request->last_penalty + 1);
}
auth_request_refresh_last_access(request);
aqueue_append(auth_failures, &request);
if (to_auth_failures == NULL) {
to_auth_failures =
timeout_add_short(AUTH_FAILURE_DELAY_CHECK_MSECS,
auth_failure_timeout, (void *)NULL);
}
}
static
int ldap_connection_connect(struct ldap_connection *conn)
{
const char *error;
int fd;
Sockbuf *sb;
bool finished;
if (conn->conn == NULL) {
/* try to reconnect after disconnection */
if (ldap_connection_setup(conn, &error) < 0)
i_error("%s", error);
}
pool_t pool = pool_alloconly_create(MEMPOOL_GROWING "ldap bind", 128);
struct ldap_op_queue_entry *req = p_new(pool, struct ldap_op_queue_entry, 1);
req->pool = pool;
req->internal_response_cb = ldap_connection_connect_parse;
req->timeout_secs = conn->set.timeout_secs;
if (ldap_connect_next_message(conn, req, &finished) != LDAP_SUCCESS ||
conn->conn == NULL) {
pool_unref(&pool);
return -1;
}
conn->pending++;
aqueue_append(conn->request_queue, &req);
/* start timeout */
if (req->timeout_secs > 0)
req->to_abort = timeout_add(req->timeout_secs * 1000, ldap_connection_abort_request, req);
ldap_get_option(conn->conn, LDAP_OPT_SOCKBUF, &sb);
ber_sockbuf_ctrl(sb, LBER_SB_OPT_GET_FD, &fd);
conn->io = io_add(fd, IO_READ, ldap_connection_read_more, conn);
if (conn->set.max_idle_time_secs > 0)
conn->to_disconnect = timeout_add(conn->set.max_idle_time_secs * 1000, ldap_connection_kill, conn);
return 0;
}
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;
}