void test_clist_get_by_id(void) { struct key k1; struct key k2; struct key k3; k1.id = 1; k2.id = 2; k3.id = 3; struct clist list; clist_init(&list, match_function, empty_destroy_function, CLIST_UNSORTED); clist_append(&list, (void *)&k1); clist_append(&list, (void *)&k2); clist_append(&list, (void *)&k3); struct key *data; int ret = clist_get_by_id(&list, (void **)&data, 1); CU_ASSERT(ret == CLIST_TRUE); if (ret==CLIST_TRUE) CU_ASSERT(data->id == 2); ret = clist_get_by_id(&list, (void **)&data, 0); CU_ASSERT(ret == CLIST_TRUE); if (ret==CLIST_TRUE) CU_ASSERT(data->id == 1); clist_get_by_id(&list, (void **)&data, -1); CU_ASSERT(ret == CLIST_TRUE); if (ret==CLIST_TRUE) CU_ASSERT(data->id == 3); clist_destroy(&list); }
static struct mailimf_fields * build_fields(void) { struct mailimf_fields * fields; struct mailimf_field * f; clist * list; struct mailimf_from * from; struct mailimf_to * to; struct mailimf_mailbox * mb; struct mailimf_address * addr; struct mailimf_mailbox_list * mb_list; struct mailimf_address_list * addr_list; clist * fields_list; /* build headers */ fields_list = clist_new(); /* build header 'From' */ list = clist_new(); mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="), strdup("*****@*****.**")); clist_append(list, mb); mb_list = mailimf_mailbox_list_new(list); from = mailimf_from_new(mb_list); f = mailimf_field_new(MAILIMF_FIELD_FROM, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, from, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); clist_append(fields_list, f); /* build header To */ list = clist_new(); mb = mailimf_mailbox_new(strdup("DINH =?iso-8859-1?Q?Vi=EAt_Ho=E0?="), strdup("*****@*****.**")); addr = mailimf_address_new(MAILIMF_ADDRESS_MAILBOX, mb, NULL); clist_append(list, addr); addr_list = mailimf_address_list_new(list); to = mailimf_to_new(addr_list); f = mailimf_field_new(MAILIMF_FIELD_TO, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, to, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL); clist_append(fields_list, f); fields = mailimf_fields_new(fields_list); return fields; }
void test_clist_append_insert_append(void) { #define NUM_ELEMENTS 10 struct clist list; int ret = clist_init(&list, match_function, free_destroy_function, CLIST_UNSORTED); struct key *k = NULL; int ctr = NUM_ELEMENTS; for (; ctr>0; ctr--) { k = (struct key*)malloc(sizeof(struct key)); k->id = ctr; printf("adding id: %i\n", k->id); ret = clist_append(&list, (void *)k); CU_ASSERT(ret==CLIST_TRUE); } for (ctr=NUM_ELEMENTS; ctr>0; ctr--) { k = (struct key*)malloc(sizeof(struct key)); k->id = ctr; printf("adding id: %i\n", k->id); ret = clist_insert(&list, (void *)k, ctr); CU_ASSERT(ret==CLIST_TRUE); } for (ctr=NUM_ELEMENTS; ctr>0; ctr--) { k = (struct key*)malloc(sizeof(struct key)); k->id = ctr; printf("adding id: %i\n", k->id); ret = clist_insert(&list, (void *)k, 0); CU_ASSERT(ret==CLIST_TRUE); } for (ctr=NUM_ELEMENTS; ctr>0; ctr--) { k = (struct key*)malloc(sizeof(struct key)); k->id = ctr; printf("adding id: %i\n", k->id); ret = clist_append(&list, (void *)k); CU_ASSERT(ret==CLIST_TRUE); } struct clist_iterator *it = malloc(sizeof(struct clist_iterator)); ret = clist_get_iterator(&list, it, 0); ret = clist_iterate(&list, it, (void **)&k, 0); CU_ASSERT(ret==CLIST_TRUE); ctr = 0; do { printf("k->id: %i\n", k->id); ctr ++; } while (clist_iterate(&list, it, (void **)&k, 1)==CLIST_TRUE); CU_ASSERT(ctr==NUM_ELEMENTS*4); clist_destroy(&list); }
static void test_shuffle(void) { clist *l = NULL; l = clist_append(l, strdup("one")); l = clist_append(l, strdup("two")); l = clist_append(l, strdup("three")); clist_shuffle(l); // TODO: improve test clist_free_ext(l, free); }
static bool nc_conn_send(struct nc_conn *conn, const char *command, const void *data, size_t data_len) { LOG("attempting to send:[%s] to %s", command, conn->addr_str); /* build wire message */ cstring *msg = message_str(chain->netmagic, command, data, data_len); if (!msg) return false; /* buffer now owns message data */ struct buffer *buf = calloc(1, sizeof(struct buffer)); buf->p = msg->str; buf->len = msg->len; cstr_free(msg, false); /* if write q exists, write_evt will handle output */ if (conn->write_q) { conn->write_q = clist_append(conn->write_q, buf); return true; } /* attempt optimistic write */ ssize_t wrc = write(conn->fd, buf->p, buf->len); if (wrc < 0) { if (errno != EAGAIN && errno != EWOULDBLOCK) { free(buf->p); free(buf); return false; } conn->write_q = clist_append(conn->write_q, buf); goto out_wrstart; } /* message fully sent */ if (wrc == buf->len) { free(buf->p); free(buf); return true; } /* message partially sent; pause read; poll for writable */ conn->write_q = clist_append(conn->write_q, buf); conn->write_partial = wrc; out_wrstart: nc_conn_read_disable(conn); nc_conn_write_enable(conn); return true; }
int mailmime_add_part(struct mailmime * build_info, struct mailmime * part) { int r; if (build_info->mm_type == MAILMIME_MESSAGE) { build_info->mm_data.mm_message.mm_msg_mime = part; part->mm_parent_type = MAILMIME_MESSAGE; part->mm_parent = build_info; } else if (build_info->mm_type == MAILMIME_MULTIPLE) { r = clist_append(build_info->mm_data.mm_multipart.mm_mp_list, part); if (r != 0) return MAILIMF_ERROR_MEMORY; part->mm_parent_type = MAILMIME_MULTIPLE; part->mm_parent = build_info; part->mm_multipart_pos = clist_end(build_info->mm_data.mm_multipart.mm_mp_list); } else { return MAILIMF_ERROR_INVAL; } return MAILIMF_NO_ERROR; }
LIBETPAN_EXPORT struct mailimap_set * mailimap_set_new_single_item(struct mailimap_set_item * item) { struct mailimap_set * set; clist * list; int r; list = clist_new(); if (list == NULL) return NULL; r = clist_append(list, item); if (r < 0) { clist_free(list); return NULL; } set = mailimap_set_new(list); if (set == NULL) { clist_free(list); return NULL; } return set; }
/* PUBLIC */ void index_hint(Topform c) { Topform h = find_equivalent_hint(c, Hints_idx); c->weight = 0; /* this is used in hints degradation to count matches */ if (h != NULL) { /* copy any bsub_hint_wt attrs from rundundant hint to the indexed hint */ h->attributes = copy_int_attribute(c->attributes, h->attributes, Bsub_wt_attr); if (Collect_labels) { /* copy any labels from rundundant hint to the indexed hint */ h->attributes = copy_string_attribute(c->attributes, h->attributes, label_att()); } clist_append(c, Redundant_hints); Redundant_hints_count++; /* printf("redundant hint: "); f_clause(c); printf(" original: "); f_clause(h); */ } else { Active_hints_count++; Hint_id_count++; c->id = Hint_id_count; /* need IDs so that back_subsume() will work */ lindex_update(Hints_idx, c, INSERT); if (Back_demod_hints) index_clause_back_demod(c, Back_demod_idx, INSERT); } } /* index_hint */
static int get_list_folders(struct mailmh_folder * folder, clist ** result) { unsigned int i; clist * list; char * new_filename; int res; int r; list = * result; new_filename = strdup(folder->fl_filename); if (new_filename == NULL) { res = MAIL_ERROR_MEMORY; goto free; } r = mailmh_folder_update(folder); switch (r) { case MAILMH_NO_ERROR: break; default: res = mhdriver_mh_error_to_mail_error(r); free(new_filename); goto free; } r = clist_append(list, new_filename); if (r < 0) { free(new_filename); res = MAIL_ERROR_MEMORY; goto free; } if (folder->fl_subfolders_tab != NULL) { for(i = 0 ; i < carray_count(folder->fl_subfolders_tab) ; i++) { struct mailmh_folder * subfolder; subfolder = carray_get(folder->fl_subfolders_tab, i); r = get_list_folders(subfolder, &list); if (r != MAIL_NO_ERROR) { free(new_filename); res = MAIL_ERROR_MEMORY; goto free; } } } * result = list; free(new_filename); return MAIL_NO_ERROR; free: clist_foreach(list, (clist_func) free, NULL); clist_free(list); return res; }
LIBETPAN_EXPORT int mailfolder_connect(struct mailfolder * folder) { mailsession * session; int res; int r; if (folder->fld_storage == NULL) { res = MAIL_ERROR_INVAL; goto err; } if (folder->fld_storage->sto_session == NULL) { r = mailstorage_connect(folder->fld_storage); if (r != MAIL_NO_ERROR) { res = r; goto err; } } if (folder->fld_session != NULL) { if ((folder->fld_pathname != NULL) && (folder->fld_shared_session)) { if (folder->fld_session->sess_driver->sess_select_folder != NULL) { r = mailsession_select_folder(folder->fld_session, folder->fld_pathname); if (r != MAIL_NO_ERROR) { res = r; goto err; } } } return MAIL_NO_ERROR; } r = mailstorage_get_folder(folder->fld_storage, folder->fld_pathname, &session); if (r != MAIL_NO_ERROR) { res = r; goto err; } folder->fld_session = session; folder->fld_shared_session = (session == folder->fld_storage->sto_session); if (folder->fld_shared_session) { r = clist_append(folder->fld_storage->sto_shared_folders, folder); if (r < 0) { folder->fld_session = NULL; res = MAIL_ERROR_MEMORY; goto err; } folder->fld_pos = clist_end(folder->fld_storage->sto_shared_folders); } return MAIL_NO_ERROR; err: return res; }
static clist * read_group_time_list(newsnntp * f) { char * line; char * group_name; time_t date; char * email; clist * group_time_list; struct newsnntp_group_time * n; int r; group_time_list = clist_new(); if (group_time_list == NULL) goto err; while (1) { char * p; char * remaining; line = read_line(f); if (line == NULL) goto free_list; if (mailstream_is_end_multiline(line)) break; p = cut_token(line); if (p == NULL) continue; date = strtoul(p, &remaining, 10); p = remaining; parse_space(&p); email = p; group_name = line; n = group_time_new(group_name, date, email); if (n == NULL) goto free_list; r = clist_append(group_time_list, n); if (r < 0) { group_time_free(n); goto free_list; } } return group_time_list; free_list: group_time_list_free(group_time_list); err: return NULL; }
static clist * read_distrib_default_value_list(newsnntp * f) { char * line; uint32_t weight; char * group_pattern; char * meaning; clist * distrib_default_value_list; struct newsnntp_distrib_default_value * n; int r; distrib_default_value_list = clist_new(); if (distrib_default_value_list == NULL) goto err; while (1) { char * p; char * remaining; line = read_line(f); if (line == NULL) goto free_list; if (mailstream_is_end_multiline(line)) break; p = line; weight = strtoul(p, &remaining, 10); p = remaining; parse_space(&p); p = cut_token(line); if (p == NULL) continue; meaning = p; group_pattern = line; n = distrib_default_value_new(weight, group_pattern, meaning); if (n == NULL) goto free_list; r = clist_append(distrib_default_value_list, n); if (r < 0) { distrib_default_value_free(n); goto free_list; } } return distrib_default_value_list; free_list: distrib_default_value_list_free(distrib_default_value_list); err: return NULL; }
static void prepare_mime_single(struct mailmime * mime) { struct mailmime_single_fields single_fields; int encoding; int r; if (mime->mm_mime_fields != NULL) { mailmime_single_fields_init(&single_fields, mime->mm_mime_fields, mime->mm_content_type); if (single_fields.fld_encoding != NULL) { encoding = single_fields.fld_encoding->enc_type; switch (encoding) { case MAILMIME_MECHANISM_8BIT: case MAILMIME_MECHANISM_7BIT: case MAILMIME_MECHANISM_BINARY: single_fields.fld_encoding->enc_type = MAILMIME_MECHANISM_QUOTED_PRINTABLE; break; } } else { struct mailmime_mechanism * mechanism; struct mailmime_field * field; mechanism = mailmime_mechanism_new(MAILMIME_MECHANISM_QUOTED_PRINTABLE, NULL); if (mechanism == NULL) return; field = mailmime_field_new(MAILMIME_FIELD_TRANSFER_ENCODING, NULL, mechanism, NULL, NULL, 0, NULL, NULL, NULL); if (field == NULL) { mailmime_mechanism_free(mechanism); return; } r = clist_append(mime->mm_mime_fields->fld_list, field); if (r < 0) { mailmime_field_free(field); return; } } } if (mime->mm_type == MAILMIME_SINGLE) { switch (mime->mm_data.mm_single->dt_encoding) { case MAILMIME_MECHANISM_8BIT: case MAILMIME_MECHANISM_7BIT: case MAILMIME_MECHANISM_BINARY: mime->mm_data.mm_single->dt_encoding = MAILMIME_MECHANISM_QUOTED_PRINTABLE; mime->mm_data.mm_single->dt_encoded = 0; break; } } }
static inline size_t clist_update(gui::control_list_t<T> *list, uint32_t id, T const &state) { size_t index = 0; if (clist_find(list, id, &index)) { list->State[index] = state; return index; } else return clist_append(list, id, state); }
struct mailmime_content * mailmime_content_dup(struct mailmime_content * content) { clist * list; struct mailmime_type * type; int r; struct mailmime_content * dup_content; char * subtype; type = mailmime_type_dup(content->ct_type); if (type == NULL) goto err; subtype = strdup(content->ct_subtype); if (subtype == NULL) goto free_type; list = clist_new(); if (list == NULL) goto free_subtype; if (content->ct_parameters != NULL) { clistiter * cur; for(cur = clist_begin(content->ct_parameters) ; cur != NULL ; cur = clist_next(cur)) { struct mailmime_parameter * param; param = mailmime_parameter_dup(clist_content(cur)); if (param == NULL) goto free_list; r = clist_append(list, param); if (r < 0) { mailmime_parameter_free(param); goto free_list; } } } dup_content = mailmime_content_new(type, subtype, list); if (dup_content == NULL) goto free_list; return dup_content; free_list: clist_foreach(list, (clist_func) mailmime_parameter_free, NULL); free_subtype: free(subtype); free_type: mailmime_type_free(type); err: return NULL; }
void test_clist(void) { /* CU_ASSERT(NULL == ex_path_normalize(NULL)); */ int i = 0; int test_cnt = 10000; clist *list = clist_new(); CU_ASSERT(0 == clist_len(list)); for(i = 0; i < test_cnt; ++i) { clist_append(list, cobj_int_new(i)); } CU_ASSERT(test_cnt == clist_len(list)); CU_ASSERT(false == clist_is_empty(list)); CU_ASSERT(0 == cobj_int_val(clist_at_obj(list, 0))); CU_ASSERT(1 == cobj_int_val(clist_at_obj(list, 1))); CU_ASSERT(test_cnt - 1 == cobj_int_val(clist_at_obj(list, test_cnt - 1))); for(i = 0; i < test_cnt; ++i) { void *obj = clist_pop_front(list); CU_ASSERT(i == cobj_int_val(obj)); cobj_free(obj); } CU_ASSERT(0 == clist_len(list)); CU_ASSERT(true == clist_is_empty(list)); for(i = 0; i < test_cnt; ++i) { clist_append(list, cobj_int_new(i)); } clist_clear(list); CU_ASSERT(0 == clist_len(list)); for(i = 0; i < test_cnt; ++i) { clist_append(list, cobj_int_new(i)); } clist_node *node = NULL; void *obj = NULL; i = 0; clist_foreach_val(list, node, obj) { CU_ASSERT(i == cobj_int_val(obj)); ++i; }
int mailmime_fields_add(struct mailmime_fields * fields, struct mailmime_field * field) { int r; r = clist_append(fields->fld_list, field); if (r < 0) return MAILIMF_ERROR_MEMORY; return MAILIMF_NO_ERROR; }
int mailimap_flag_list_add(struct mailimap_flag_list * flag_list, struct mailimap_flag * f) { int r; r = clist_append(flag_list->fl_list, f); if (r < 0) return MAILIMAP_ERROR_MEMORY; return MAILIMAP_NO_ERROR; }
static Stree stree_insert(Stree s, Topform c) { if (s == NULL) { s = get_stree(); s->weight = c->weight; s->clauses = clist_init("clauses_by_weight"); clist_append(c, s->clauses); } else if (c->weight == s->weight) { clist_append(c, s->clauses); } else if (c->weight < s->weight) s->left = stree_insert(s->left, c); else s->right = stree_insert(s->right, c); s->greatest_id = c->id; /* clauses always inserted with increasing IDs */ s->n++; return s; } /* stree_insert */
int mailimap_set_add(struct mailimap_set * set, struct mailimap_set_item * set_item) { int r; r = clist_append(set->set_list, set_item); if (r < 0) return MAILIMAP_ERROR_MEMORY; return MAILIMAP_NO_ERROR; }
void test_clist_sort(void) { int items[] = {5, 10, 23, 12, 1, 91, 32, 12, 3, 2}; #define NUM_ELEMENTS 10 struct clist list; int ret = clist_init(&list, match_function, free_destroy_function, CLIST_UNSORTED); struct key *k = NULL; int ctr = 0; for (; ctr<NUM_ELEMENTS; ctr++) { k = (struct key*)malloc(sizeof(struct key)); k->id = items[ctr]; printf("adding id: %i\n", k->id); ret = clist_append(&list, (void *)k); CU_ASSERT(ret==CLIST_TRUE); } /*traverse list before sort*/ struct clist_iterator *it = malloc(sizeof(struct clist_iterator)); ret = clist_get_iterator(&list, it, 0); CU_ASSERT(ret==CLIST_TRUE); ret = clist_iterate(&list, it, (void **)&k, 0); CU_ASSERT(ret==CLIST_TRUE); ctr = 0; do { printf("k->id: %i\n", k->id); ctr ++; } while (clist_iterate(&list, it, (void **)&k, 1)==CLIST_TRUE); CU_ASSERT(ctr==NUM_ELEMENTS); clist_qsort(&list, ASCENDING); /*traverse list after sort*/ ret = clist_get_iterator(&list, it, 0); CU_ASSERT(ret==CLIST_TRUE); ret = clist_iterate(&list, it, (void **)&k, 0); CU_ASSERT(ret==CLIST_TRUE); ctr = 0; int prev = k->id;; do { printf("k->id: %i, prev: %i\n", k->id, prev); CU_ASSERT(prev<=k->id); prev = k->id; ctr ++; } while (clist_iterate(&list, it, (void **)&k, 1)==CLIST_TRUE); CU_ASSERT(ctr==NUM_ELEMENTS); free(it); clist_destroy(&list); }
static void __peerman_add(struct peer_manager *peers, struct peer *peer, bool prepend_front) { bn_group(peer->group, &peer->group_len, peer->addr.ip); if (prepend_front) peers->addrlist = clist_prepend(peers->addrlist, peer); else peers->addrlist = clist_append(peers->addrlist, peer); bp_hashtab_put(peers->map_addr, peer->addr.ip, peer); }
static struct mailmime * build_body_text(char * text) { struct mailmime_fields * mime_fields; struct mailmime * mime_sub; struct mailmime_content * content; struct mailmime_parameter * param; int r; /* text/plain part */ mime_fields = mailmime_fields_new_encoding(MAILMIME_MECHANISM_8BIT); if (mime_fields == NULL) { goto err; } content = mailmime_content_new_with_str("text/plain"); if (content == NULL) { goto free_fields; } param = mailmime_param_new_with_data("charset", DEST_CHARSET); if (param == NULL) { goto free_content; } r = clist_append(content->ct_parameters, param); if (r < 0) { mailmime_parameter_free(param); goto free_content; } mime_sub = mailmime_new_empty(content, mime_fields); if (mime_sub == NULL) { goto free_content; } r = mailmime_set_body_text(mime_sub, text, strlen(text)); if (r != MAILIMF_NO_ERROR) { goto free_mime; } return mime_sub; free_mime: mailmime_free(mime_sub); goto err; free_content: mailmime_content_free(content); free_fields: mailmime_fields_free(mime_fields); err: return NULL; }
static int mailprivacy_smime_add_encryption_id(struct mailprivacy * privacy, mailmessage * msg, char * encryption_id) { clist * encryption_id_list; int r; int res; LOCK(); res = -1; encryption_id_list = get_list(privacy, msg); if (encryption_id_list == NULL) { if (encryption_id_hash == NULL) encryption_id_hash = chash_new(CHASH_DEFAULTSIZE, CHASH_COPYKEY); if (encryption_id_hash != NULL) { encryption_id_list = clist_new(); if (encryption_id_list != NULL) { chashdatum key; chashdatum value; key.data = &msg; key.len = sizeof(msg); value.data = encryption_id_list; value.len = 0; r = chash_set(encryption_id_hash, &key, &value, NULL); if (r < 0) clist_free(encryption_id_list); } } } encryption_id_list = get_list(privacy, msg); if (encryption_id_list != NULL) { char * str; str = strdup(encryption_id); if (str != NULL) { r = clist_append(encryption_id_list, str); if (r < 0) { free(str); } else { res = 0; } } } UNLOCK(); return res; }
int mailimap_search_key_multiple_add(struct mailimap_search_key * keys, struct mailimap_search_key * key_item) { int r; r = clist_append(keys->sk_data.sk_multiple, key_item); if (r < 0) return MAILIMAP_ERROR_MEMORY; return MAILIMAP_NO_ERROR; }
LIBETPAN_EXPORT int mailimap_extension_register(struct mailimap_extension_api * extension) { if (mailimap_extension_list == NULL) { mailimap_extension_list = clist_new(); if (mailimap_extension_list == NULL) return MAILIMAP_ERROR_MEMORY; } return clist_append(mailimap_extension_list, extension); }
int mailimap_fetch_type_new_fetch_att_list_add(struct mailimap_fetch_type * fetch_type, struct mailimap_fetch_att * fetch_att) { int r; r = clist_append(fetch_type->ft_data.ft_fetch_att_list, fetch_att); if (r < 0) return MAILIMAP_ERROR_MEMORY; return MAILIMAP_NO_ERROR; }
/*! * \brief add/save a detected constraint to the list in memory * \param pg_constraint_t constraint */ static void db_postgres_constraint_add(pg_constraint_t *c) { if (!pg_constraint) { pg_constraint = c; LM_DBG("adding init constraint [%s][%s][%s]\n", c->database.s, c->table.s, c->unique.s); clist_init(pg_constraint, next, prev); } else { LM_DBG("adding append constraint [%s][%s][%s]\n", c->database.s, c->table.s, c->unique.s); clist_append(pg_constraint, c, next, prev); } }
int maildriver_env_list_to_msg_list_no_flags(struct mailmessage_list * env_list, clist ** result) { clist * msg_list; int r; int res; unsigned int i; msg_list = clist_new(); if (msg_list == NULL) { res = MAIL_ERROR_MEMORY; goto err; } for(i = 0 ; i < carray_count(env_list->msg_tab) ; i ++) { mailmessage * msg; msg = carray_get(env_list->msg_tab, i); if (msg->msg_flags == NULL) { uint32_t * pindex; pindex = malloc(sizeof(* pindex)); if (pindex == NULL) { res = MAIL_ERROR_MEMORY; goto free_msg_list; } * pindex = msg->msg_index; r = clist_append(msg_list, pindex); if (r < 0) { free(pindex); res = MAIL_ERROR_MEMORY; goto free_msg_list; } } } * result = msg_list; return MAIL_NO_ERROR; free_msg_list: clist_foreach(msg_list, (clist_func) free, NULL); clist_free(msg_list); err: return res; }
static int mhdriver_lsub_folders(mailsession * session, const char * mb, struct mail_list ** result) { clist * subscribed; clist * lsub_result; clistiter * cur; struct mail_list * lsub; size_t length; int r; length = strlen(mb); subscribed = get_data(session)->mh_subscribed_list; lsub_result = clist_new(); if (lsub_result == NULL) return MAIL_ERROR_MEMORY; for(cur = clist_begin(subscribed) ; cur != NULL ; cur = clist_next(cur)) { char * cur_mb; char * new_mb; cur_mb = clist_content(cur); if (strncmp(mb, cur_mb, length) == 0) { new_mb = strdup(cur_mb); if (new_mb == NULL) goto free_list; r = clist_append(lsub_result, new_mb); if (r < 0) { free(new_mb); goto free_list; } } } lsub = mail_list_new(lsub_result); if (lsub == NULL) goto free_list; * result = lsub; return MAIL_NO_ERROR; free_list: clist_foreach(lsub_result, (clist_func) free, NULL); clist_free(lsub_result); return MAIL_ERROR_MEMORY; }