static void test_seq_range_array_remove_nth(void) { ARRAY_TYPE(seq_range) range; const struct seq_range *r; test_begin("seq_range_array_remove_nth()"); t_array_init(&range, 8); seq_range_array_add_range(&range, 1, 5); seq_range_array_add(&range, 7); seq_range_array_add_range(&range, 10,20); test_assert(array_count(&range) == 3); seq_range_array_remove_nth(&range, 0, 2); r = array_idx(&range, 0); test_assert(r->seq1 == 3 && r->seq2 == 5); seq_range_array_remove_nth(&range, 1, 4); r = array_idx(&range, 0); test_assert(r->seq1 == 3 && r->seq2 == 3); r = array_idx(&range, 1); test_assert(r->seq1 == 11 && r->seq2 == 20); seq_range_array_remove_nth(&range, 5, (uint32_t)-1); r = array_idx(&range, 1); test_assert(r->seq1 == 11 && r->seq2 == 14); test_assert(array_count(&range) == 2); test_end(); }
int acl_rights_update_import(struct acl_rights_update *update, const char *id, const char *const *rights, const char **error_r) { ARRAY_TYPE(const_string) dest_rights, dest_neg_rights, *dest; unsigned int i, j; if (acl_identifier_parse(id, &update->rights) < 0) { *error_r = t_strdup_printf("Invalid ID: %s", id); return -1; } if (rights == NULL) { update->modify_mode = ACL_MODIFY_MODE_CLEAR; update->neg_modify_mode = ACL_MODIFY_MODE_CLEAR; return 0; } t_array_init(&dest_rights, 8); t_array_init(&dest_neg_rights, 8); for (i = 0; rights[i] != NULL; i++) { const char *right = rights[i]; if (right[0] != '-') dest = &dest_rights; else { right++; dest = &dest_neg_rights; } if (strcmp(right, "all") != 0) { if (*right == ':') { /* non-standard right */ right++; array_append(dest, &right, 1); } else if (is_standard_right(right)) { array_append(dest, &right, 1); } else { *error_r = t_strdup_printf("Invalid right '%s'", right); return -1; } } else { for (j = 0; all_mailbox_rights[j] != NULL; j++) array_append(dest, &all_mailbox_rights[j], 1); } } if (array_count(&dest_rights) > 0) { array_append_zero(&dest_rights); update->rights.rights = array_idx(&dest_rights, 0); } else if (update->modify_mode == ACL_MODIFY_MODE_REPLACE) { update->modify_mode = ACL_MODIFY_MODE_CLEAR; } if (array_count(&dest_neg_rights) > 0) { array_append_zero(&dest_neg_rights); update->rights.neg_rights = array_idx(&dest_neg_rights, 0); } else if (update->neg_modify_mode == ACL_MODIFY_MODE_REPLACE) { update->neg_modify_mode = ACL_MODIFY_MODE_CLEAR; } return 0; }
void io_loop_handler_run_internal(struct ioloop *ioloop) { struct ioloop_handler_context *ctx = ioloop->handler_context; struct epoll_event *events; const struct epoll_event *event; struct io_list *list; struct io_file *io; struct timeval tv; unsigned int events_count; int msecs, ret, i, j; bool call; /* get the time left for next timeout task */ msecs = io_loop_get_wait_time(ioloop, &tv); events = array_get_modifiable(&ctx->events, &events_count); if (ioloop->io_files != NULL && events_count > ctx->deleted_count) { ret = epoll_wait(ctx->epfd, events, events_count, msecs); if (ret < 0 && errno != EINTR) i_fatal("epoll_wait(): %m"); } else { /* no I/Os, but we should have some timeouts. just wait for them. */ i_assert(msecs >= 0); usleep(msecs*1000); ret = 0; } /* execute timeout handlers */ io_loop_handle_timeouts(ioloop); if (!ioloop->running) return; for (i = 0; i < ret; i++) { /* io_loop_handle_add() may cause events array reallocation, so we have use array_idx() */ event = array_idx(&ctx->events, i); list = event->data.ptr; for (j = 0; j < IOLOOP_IOLIST_IOS_PER_FD; j++) { io = list->ios[j]; if (io == NULL) continue; call = FALSE; if ((event->events & (EPOLLHUP | EPOLLERR)) != 0) call = TRUE; else if ((io->io.condition & IO_READ) != 0) call = (event->events & EPOLLIN) != 0; else if ((io->io.condition & IO_WRITE) != 0) call = (event->events & EPOLLOUT) != 0; else if ((io->io.condition & IO_ERROR) != 0) call = (event->events & IO_EPOLL_ERROR) != 0; if (call) io_loop_call_io(&io->io); } } }
void smtp_server_command_fail(struct smtp_server_command *cmd, unsigned int status, const char *enh_code, const char *fmt, ...) { unsigned int i; va_list args; i_assert(status / 100 > 2); va_start(args, fmt); if (cmd->replies_expected == 1) { smtp_server_reply_indexv(&cmd->context, 0, status, enh_code, fmt, args); } else for (i = 0; i < cmd->replies_expected; i++) { bool sent = FALSE; if (array_is_created(&cmd->replies)) { const struct smtp_server_reply *reply = array_idx(&cmd->replies, i); sent = reply->sent; } /* send the same reply for all */ if (!sent) { va_list args_copy; VA_COPY(args_copy, args); smtp_server_reply_indexv(&cmd->context, i, status, enh_code, fmt, args_copy); va_end(args_copy); } } va_end(args); }
rstatus_t conf_server_each_transform(void *elem, void *data) { struct string *group = elem; struct array *server = data; struct server *s; s = array_push(server); ASSERT(s != NULL); s->idx = array_idx(server, s); s->owner = NULL; string_init(&s->pname); s->name = *group;/* ref */ string_init(&s->addrstr); s->port = 0; s->weight = 1; memset(&s->info, 0, sizeof(s->info)); s->ns_conn_q = 0; TAILQ_INIT(&s->s_conn_q); s->timer = NULL; s->status = 0; log_debug(LOG_VERB, "transform to server %"PRIu32" '%.*s'", s->idx, group->len, group->data); return NC_OK; }
int sieve_stringlist_read_all (struct sieve_stringlist *strlist, pool_t pool, const char * const **list_r) { if ( strlist->read_all == NULL ) { ARRAY(const char *) items; string_t *item; int ret; sieve_stringlist_reset(strlist); p_array_init(&items, pool, 4); item = NULL; while ( (ret=sieve_stringlist_next_item(strlist, &item)) > 0 ) { const char *stritem = p_strdup(pool, str_c(item)); array_append(&items, &stritem, 1); } (void)array_append_space(&items); *list_r = array_idx(&items, 0); return ( ret < 0 ? -1 : 1 ); } return strlist->read_all(strlist, pool, list_r); }
static void exec_child(struct master_service_connection *conn, const char *const *args) { unsigned int i, socket_count; if (dup2(conn->fd, STDIN_FILENO) < 0) i_fatal("dup2() failed: %m"); if (dup2(conn->fd, STDOUT_FILENO) < 0) i_fatal("dup2() failed: %m"); /* close all fds */ socket_count = master_service_get_socket_count(master_service); for (i = 0; i < socket_count; i++) { if (close(MASTER_LISTEN_FD_FIRST + i) < 0) i_error("close(listener) failed: %m"); } if (close(MASTER_STATUS_FD) < 0) i_error("close(status) failed: %m"); if (close(conn->fd) < 0) i_error("close(conn->fd) failed: %m"); for (; *args != NULL; args++) array_append(&exec_args, args, 1); array_append_zero(&exec_args); env_clean(); args = array_idx(&exec_args, 0); execvp_const(args[0], args); }
static void ldap_connection_abort_request(struct ldap_op_queue_entry *req) { struct ldap_result res; /* too bad */ if (req->to_abort != NULL) timeout_remove(&req->to_abort); if (req->msgid > -1) ldap_abandon_ext(req->conn->conn, req->msgid, NULL, NULL); memset(&res, 0, sizeof(res)); res.openldap_ret = LDAP_TIMEOUT; res.error_string = "Aborting LDAP request after timeout"; if (req->result_callback != NULL) req->result_callback(&res, req->result_callback_ctx); unsigned int n = aqueue_count(req->conn->request_queue); for (unsigned int i = 0; i < n; i++) { struct ldap_op_queue_entry *const *reqp = array_idx(&(req->conn->request_array), aqueue_idx(req->conn->request_queue, i)); if (req == *reqp) { aqueue_delete(req->conn->request_queue, i); ldap_connection_request_destroy(&req); return; } } i_unreached(); }
int mail_index_sync_keywords_reset(struct mail_index_sync_map_ctx *ctx, const struct mail_transaction_header *hdr, const struct mail_transaction_keyword_reset *r) { struct mail_index_map *map = ctx->view->map; struct mail_index_record *rec; const struct mail_index_ext *ext; const struct mail_transaction_keyword_reset *end; uint32_t ext_map_idx, seq1, seq2; if (!mail_index_map_lookup_ext(map, MAIL_INDEX_EXT_KEYWORDS, &ext_map_idx)) { /* nothing to do */ return 1; } ext = array_idx(&map->extensions, ext_map_idx); end = CONST_PTR_OFFSET(r, hdr->size); for (; r != end; r++) { if (!mail_index_lookup_seq_range(ctx->view, r->uid1, r->uid2, &seq1, &seq2)) continue; mail_index_modseq_reset_keywords(ctx->modseq_ctx, seq1, seq2); for (; seq1 <= seq2; seq1++) { rec = MAIL_INDEX_REC_AT_SEQ(map, seq1); memset(PTR_OFFSET(rec, ext->record_offset), 0, ext->record_size); } } return 1; }
uint32_t imapc_msgmap_rseq_to_uid(struct imapc_msgmap *msgmap, uint32_t rseq) { const uint32_t *uidp; uidp = array_idx(&msgmap->uids, rseq-1); return *uidp; }
static void mirror_get_remote_cmd_line(const char *const *argv, const char *const **cmd_args_r) { ARRAY_TYPE(const_string) cmd_args; unsigned int i; const char *p; i_assert(argv[0] != NULL); t_array_init(&cmd_args, 16); for (i = 0; argv[i] != NULL; i++) { p = argv[i]; array_append(&cmd_args, &p, 1); } if (legacy_dsync) { /* we're executing dsync */ p = "server"; } else { /* we're executing doveadm */ p = "dsync-server"; } array_append(&cmd_args, &p, 1); array_append_zero(&cmd_args); *cmd_args_r = array_idx(&cmd_args, 0); }
static void worker_connection_disconnect(struct worker_connection *conn) { unsigned int i, count = aqueue_count(conn->request_queue); if (conn->fd != -1) { io_remove(&conn->io); i_stream_destroy(&conn->input); o_stream_destroy(&conn->output); if (close(conn->fd) < 0) i_error("close(%s) failed: %m", conn->socket_path); conn->fd = -1; } /* cancel any pending requests */ if (count > 0) { i_error("Indexer worker disconnected, " "discarding %u requests for %s", count, conn->request_username); } /* conn->callback() can try to destroy us */ conn->refcount++; for (i = 0; i < count; i++) { void *const *contextp = array_idx(&conn->request_contexts, aqueue_idx(conn->request_queue, 0)); void *context = *contextp; aqueue_delete_tail(conn->request_queue); conn->callback(-1, context); } i_free_and_null(conn->request_username); worker_connection_unref(conn); }
rstatus_t conf_server_each_transform(void *elem, void *data) { struct conf_server *cs = elem; struct array *server = data; struct server *s; ASSERT(cs->valid); s = array_push(server); ASSERT(s != NULL); s->idx = array_idx(server, s); s->owner = NULL; s->pname = cs->pname; s->name = cs->name; s->port = (uint16_t)cs->port; s->weight = (uint32_t)cs->weight; s->family = cs->info.family; s->addrlen = cs->info.addrlen; s->addr = (struct sockaddr *)&cs->info.addr; s->ns_conn_q = 0; TAILQ_INIT(&s->s_conn_q); s->next_retry = 0LL; s->failure_count = 0; log_debug(LOG_VERB, "transform to server %"PRIu32" '%.*s'", s->idx, s->pname.len, s->pname.data); return NC_OK; }
static int worker_connection_input_line(struct worker_connection *conn, const char *line) { void *const *contextp, *context; int percentage; if (aqueue_count(conn->request_queue) == 0) { i_error("Input from worker without pending requests: %s", line); return -1; } if (str_to_int(line, &percentage) < 0 || percentage < -1 || percentage > 100) { i_error("Invalid input from worker: %s", line); return -1; } contextp = array_idx(&conn->request_contexts, aqueue_idx(conn->request_queue, 0)); context = *contextp; if (percentage < 0 || percentage == 100) { /* the request is finished */ aqueue_delete_tail(conn->request_queue); if (aqueue_count(conn->request_queue) == 0) i_free_and_null(conn->request_username); } conn->callback(percentage, context); return 0; }
static void ext_reset_update_atomic(struct mail_index_transaction *t, uint32_t ext_id, uint32_t expected_reset_id) { const struct mail_index_ext *map_ext; struct mail_transaction_ext_reset *reset; uint32_t idx, reset_id; if (!mail_index_map_get_ext_idx(t->view->index->map, ext_id, &idx)) { /* new extension */ reset_id = 1; } else { map_ext = array_idx(&t->view->index->map->extensions, idx); reset_id = map_ext->reset_id + 1; } if (reset_id != expected_reset_id) { /* ignore this extension update */ mail_index_ext_set_reset_id(t, ext_id, 0); return; } if (reset_id == 0) reset_id++; array_idx_set(&t->ext_reset_ids, ext_id, &reset_id); /* reseting existing data is optional */ if (array_is_created(&t->ext_resets)) { reset = array_idx_modifiable(&t->ext_resets, ext_id); if (reset->new_reset_id == (uint32_t)-1) reset->new_reset_id = reset_id; } }
void ldap_connection_kill(struct ldap_connection *conn) { if (conn->io != NULL) io_remove_closed(&(conn->io)); if (conn->to_disconnect != NULL) timeout_remove(&(conn->to_disconnect)); if (conn->to_reconnect != NULL) timeout_remove(&(conn->to_reconnect)); if (conn->request_queue != NULL) { unsigned int n = aqueue_count(conn->request_queue); for (unsigned int i = 0; i < n; i++) { struct ldap_op_queue_entry *const *reqp = array_idx(&(conn->request_array), aqueue_idx(conn->request_queue, i)); if ((*reqp)->msgid > -1) ldap_abandon_ext(conn->conn, (*reqp)->msgid, NULL, NULL); (*reqp)->msgid = -1; } } if (conn->conn != NULL) { ldap_unbind_ext(conn->conn, NULL, NULL); ldap_memfree(conn->scred); } conn->conn = NULL; conn->state = LDAP_STATE_DISCONNECT; }
static void imapc_sync_index_keyword(struct imapc_sync_context *ctx, const struct mail_index_sync_rec *sync_rec) { string_t *str = t_str_new(128); const char *const *kw_p; char change_char; switch (sync_rec->type) { case MAIL_INDEX_SYNC_TYPE_KEYWORD_ADD: change_char = '+'; break; case MAIL_INDEX_SYNC_TYPE_KEYWORD_REMOVE: change_char = '-'; break; default: i_unreached(); } str_printfa(str, "UID STORE %u:%u %cFLAGS (", sync_rec->uid1, sync_rec->uid2, change_char); kw_p = array_idx(ctx->keywords, sync_rec->keyword_idx); str_append(str, *kw_p); str_append_c(str, ')'); imapc_sync_cmd(ctx, str_c(str)); }
static bool proxy_client_worker_next_reply(struct proxy_client_dsync_worker *worker, const char *line) { const struct proxy_client_request *requests; struct proxy_client_request request; bool ret = TRUE; i_assert(worker->msg_get_data.input == NULL); if (aqueue_count(worker->request_queue) == 0) { i_error("Unexpected reply from server: %s", line); proxy_client_fail(worker); return FALSE; } requests = array_idx(&worker->request_array, 0); request = requests[aqueue_idx(worker->request_queue, 0)]; aqueue_delete_tail(worker->request_queue); switch (request.type) { case PROXY_CLIENT_REQUEST_TYPE_COPY: ret = proxy_client_worker_next_copy(worker, &request, line); break; case PROXY_CLIENT_REQUEST_TYPE_GET: ret = proxy_client_worker_next_msg_get(worker, &request, line); break; case PROXY_CLIENT_REQUEST_TYPE_FINISH: proxy_client_worker_next_finish(worker, &request, line); break; } return ret; }
static rstatus_t dnode_peer_add_node(struct server_pool *sp, struct node *node) { rstatus_t status; struct array *peers = &sp->peers; struct server *s = array_push(peers); s->owner = sp; uint32_t i,nelem; s->idx = array_idx(peers, s); //log_debug(LOG_VERB, "node rack_name : '%.*s'", node->rack.len, node->rack.data); //log_debug(LOG_VERB, "node dc_name : '%.*s'", node->dc.len, node->dc.data); //log_debug(LOG_VERB, "node address : '%.*s'", node->pname.len, node->pname.data); //log_debug(LOG_VERB, "node ip : '%.*s'", node->name.len, node->name.data); string_copy(&s->pname, node->pname.data, node->pname.len); string_copy(&s->name, node->name.data, node->name.len); string_copy(&s->rack, node->rack.data, node->rack.len); string_copy(&s->dc, node->dc.data, node->dc.len); s->port = (uint16_t) node->port; s->is_local = node->is_local; s->state = node->state; s->processed = 0; array_init(&s->tokens, 1, sizeof(struct dyn_token)); struct dyn_token *src_token = &node->token; struct dyn_token *dst_token = array_push(&s->tokens); copy_dyn_token(src_token, dst_token); struct sockinfo *info = dn_alloc(sizeof(*info)); //need to free this dn_resolve(&s->name, s->port, info); s->family = info->family; s->addrlen = info->addrlen; s->addr = (struct sockaddr *)&info->addr; //TODOs: fix this by copying, not reference s->ns_conn_q = 0; TAILQ_INIT(&s->s_conn_q); s->next_retry = 0LL; s->failure_count = 0; s->is_seed = node->is_seed; log_debug(LOG_VERB, "add a node to peer %"PRIu32" '%.*s'", s->idx, s->pname.len, s->pname.data); dnode_peer_relink_conn_owner(sp); status = dnode_peer_pool_run(sp); if (status != DN_OK) return status; status = dnode_peer_each_preconnect(s, NULL); return status; }
int pop3c_sync_get_uidls(struct pop3c_mailbox *mbox) { ARRAY_TYPE(const_string) uidls; struct istream *input; const char *error, *cline; char *line, *p; unsigned int seq, line_seq; if (mbox->msg_uidls != NULL) return 0; if ((pop3c_client_get_capabilities(mbox->client) & POP3C_CAPABILITY_UIDL) == 0) { mail_storage_set_error(mbox->box.storage, MAIL_ERROR_NOTPOSSIBLE, "UIDLs not supported by server"); return -1; } if (pop3c_client_cmd_stream(mbox->client, "UIDL\r\n", &input, &error) < 0) { mail_storage_set_critical(mbox->box.storage, "UIDL failed: %s", error); return -1; } mbox->uidl_pool = pool_alloconly_create("POP3 UIDLs", 1024*32); p_array_init(&uidls, mbox->uidl_pool, 64); seq = 0; while ((line = i_stream_read_next_line(input)) != NULL) { seq++; p = strchr(line, ' '); if (p == NULL) { mail_storage_set_critical(mbox->box.storage, "Invalid UIDL line: %s", line); break; } *p++ = '\0'; if (str_to_uint(line, &line_seq) < 0 || line_seq != seq) { mail_storage_set_critical(mbox->box.storage, "Unexpected UIDL seq: %s != %u", line, seq); break; } cline = p_strdup(mbox->uidl_pool, p); array_append(&uidls, &cline, 1); } i_stream_destroy(&input); if (line != NULL) { pool_unref(&mbox->uidl_pool); return -1; } if (seq == 0) { /* make msg_uidls non-NULL */ array_append_zero(&uidls); } mbox->msg_uidls = array_idx(&uidls, 0); mbox->msg_count = seq; return 0; }
int main(int argc, char *argv[]) { ARRAY_TYPE(const_string) aenvs; const char *binary; const char *const *envs; int c, i; master_service = master_service_init("script", 0, &argc, &argv, "+e:"); t_array_init(&aenvs, 16); while ((c = master_getopt(master_service)) > 0) { switch (c) { case 'e': envs = t_strsplit_spaces(optarg,", \t"); while (*envs != NULL) { array_append(&aenvs, envs, 1); envs++; } break; default: return FATAL_DEFAULT; } } argc -= optind; argv += optind; array_append_zero(&aenvs); accepted_envs = p_strarray_dup(default_pool, array_idx(&aenvs, 0)); master_service_init_log(master_service, "script: "); if (argv[0] == NULL) i_fatal("Missing script path"); restrict_access_by_env(RESTRICT_ACCESS_FLAG_ALLOW_ROOT, NULL); restrict_access_allow_coredumps(TRUE); master_service_init_finish(master_service); master_service_set_service_count(master_service, 1); if (argv[0][0] == '/') binary = argv[0]; else binary = t_strconcat(PKG_LIBEXECDIR"/", argv[0], NULL); i_array_init(&exec_args, argc + 16); array_append(&exec_args, &binary, 1); for (i = 1; i < argc; i++) { const char *arg = argv[i]; array_append(&exec_args, &arg, 1); } master_service_run(master_service, client_connected); array_free(&exec_args); i_free(accepted_envs); master_service_deinit(&master_service); return 0; }
static void ldap_connection_send_next(struct ldap_connection *conn) { unsigned int i = 0, n; struct ldap_op_queue_entry *req; if (conn->to_reconnect != NULL) timeout_remove(&(conn->to_reconnect)); if (conn->state == LDAP_STATE_DISCONNECT) { if (ldap_connection_connect(conn) == -1) conn->to_reconnect = timeout_add(1000, ldap_connection_send_next, conn); return; } if (conn->state != LDAP_STATE_CONNECT) { return; } if (conn->pending > 10) return; /* try again later */ req = NULL; /* get next request */ n = aqueue_count(conn->request_queue); for(i=0; i < n; i++) { struct ldap_op_queue_entry *const *reqp = array_idx(&(conn->request_array), aqueue_idx(conn->request_queue, i)); if ((*reqp)->msgid > -1) break; req = *reqp; } i--; /* nothing to actually send */ if (req == NULL) return; i_assert(req->msgid == -1); const char *error; int ret; if ((ret = req->send_request_cb(conn, req, &error)) != LDAP_SUCCESS) { /* did not succeed */ struct ldap_result res; memset(&res, 0, sizeof(res)); res.openldap_ret = ret; if (req->result_callback != NULL) req->result_callback(&res, req->result_callback_ctx); ldap_connection_request_destroy(&req); aqueue_delete(conn->request_queue, i); } else conn->pending++; }
static void doveadm_print_flow_print(const char *value) { const struct doveadm_print_flow_header *hdr = array_idx(&ctx->headers, ctx->header_idx); if ((hdr->flags & DOVEADM_PRINT_HEADER_FLAG_HIDE_TITLE) == 0) printf("%s=", hdr->title); printf("%s", value); flow_next_hdr(); }
struct priorityq_item *priorityq_peek(struct priorityq *pq) { struct priorityq_item *const *items; if (array_count(&pq->items) == 0) return NULL; items = array_idx(&pq->items, 0); return items[0]; }
void sieve_jumplist_resolve(struct sieve_jumplist *jlist) { unsigned int i; for ( i = 0; i < array_count(&jlist->jumps); i++ ) { const sieve_size_t *jump = array_idx(&jlist->jumps, i); sieve_binary_resolve_offset(jlist->block, *jump); } }
void io_loop_handler_run_internal(struct ioloop *ioloop) { struct ioloop_handler_context *ctx = ioloop->handler_context; struct kevent *events; const struct kevent *event; struct timeval tv; struct timespec ts; struct io_file *io; unsigned int events_count; int ret, i, msecs; /* get the time left for next timeout task */ msecs = io_loop_get_wait_time(ioloop, &tv); ts.tv_sec = tv.tv_sec; ts.tv_nsec = tv.tv_usec * 1000; /* wait for events */ events = array_get_modifiable(&ctx->events, &events_count); if (events_count > 0) { ret = kevent (ctx->kq, NULL, 0, events, events_count, &ts); if (ret < 0 && errno != EINTR) i_panic("kevent() failed: %m"); } else { if (msecs < 0) i_panic("BUG: No IOs or timeouts set. Not waiting for infinity."); usleep(msecs * 1000); ret = 0; } /* reference all IOs */ for (i = 0; i < ret; i++) { io = (void *)events[i].udata; i_assert(io->refcount > 0); io->refcount++; } /* execute timeout handlers */ io_loop_handle_timeouts(ioloop); for (i = 0; i < ret; i++) { /* io_loop_handle_add() may cause events array reallocation, so we have use array_idx() */ event = array_idx(&ctx->events, i); io = (void *)event->udata; /* callback is NULL if io_remove() was already called */ if (io->io.callback != NULL) io_loop_call_io(&io->io); i_assert(io->refcount > 0); if (--io->refcount == 0) i_free(io); } }
const char *auth_fields_find(struct auth_fields *fields, const char *key) { const struct auth_field *field; unsigned int idx; if (!auth_fields_find_idx(fields, key, &idx)) return NULL; field = array_idx(&fields->fields, idx); return field->value == NULL ? "" : field->value; }
static bool thread_node_has_ancestor(struct mail_thread_cache *cache, const struct mail_thread_node *node, const struct mail_thread_node *ancestor) { while (node != ancestor) { if (node->parent_idx == 0) return FALSE; node = array_idx(&cache->thread_nodes, node->parent_idx); } return TRUE; }
bool index_sort_list_next(struct mail_search_sort_program *program, uint32_t *seq_r) { const uint32_t *seqp; if (program->iter_idx == array_count(&program->seqs)) return FALSE; seqp = array_idx(&program->seqs, program->iter_idx++); *seq_r = *seqp; return TRUE; }
const void *sieve_generator_extension_get_context (struct sieve_generator *gentr, const struct sieve_extension *ext) { void * const *ctx; if ( ext->id < 0 || ext->id >= (int) array_count(&gentr->ext_contexts) ) return NULL; ctx = array_idx(&gentr->ext_contexts, (unsigned int) ext->id); return *ctx; }