LIBETPAN_EXPORT
int mailimap_get_section_part_from_body(struct mailimap_body * root_part,
struct mailimap_body * part,
struct mailimap_section_part ** result)
{
struct mailimap_section_part * section_part;
clist * id_list;
int r;
int res;
r = recursive_build_path(root_part, part, &id_list);
if (r != MAILIMAP_NO_ERROR) {
res = r;
goto err;
}
section_part = mailimap_section_part_new(id_list);
if (section_part == NULL) {
res = MAILIMAP_ERROR_MEMORY;
goto free_list;
}
* result = section_part;
return MAILIMAP_NO_ERROR;
free_list:
clist_foreach(id_list, (clist_func) free, NULL);
clist_free(id_list);
err:
return res;
}
LIBETPAN_EXPORT
void mailimf_mailbox_list_free(struct mailimf_mailbox_list * mb_list)
{
clist_foreach(mb_list->mb_list, (clist_func) mailimf_mailbox_free, NULL);
clist_free(mb_list->mb_list);
free(mb_list);
}
LIBETPAN_EXPORT
void mailimf_address_list_free(struct mailimf_address_list * addr_list)
{
clist_foreach(addr_list->ad_list, (clist_func) mailimf_address_free, NULL);
clist_free(addr_list->ad_list);
free(addr_list);
}
static void nntpdriver_uninitialize(mailsession * session)
{
struct nntp_session_state_data * data;
data = get_data(session);
clist_foreach(data->nntp_subscribed_list, (clist_func) free, NULL);
clist_free(data->nntp_subscribed_list);
if (data->nntp_group_info != NULL)
newsnntp_group_free(data->nntp_group_info);
if (data->nntp_group_name != NULL)
free(data->nntp_group_name);
if (data->nntp_userid != NULL)
free(data->nntp_userid);
if (data->nntp_password != NULL)
free(data->nntp_password);
newsnntp_free(data->nntp_session);
free(data);
session->sess_data = NULL;
}
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;
}
static int mhdriver_list_folders(mailsession * session, const char * mb,
struct mail_list ** result)
{
clist * list;
int r;
struct mailmh * mh;
struct mail_list * ml;
mh = get_mh_session(session);
if (mh == NULL)
return MAIL_ERROR_BAD_STATE;
list = clist_new();
if (list == NULL)
return MAIL_ERROR_MEMORY;
r = get_list_folders(mh->mh_main, &list);
if (r != MAIL_NO_ERROR)
return r;
ml = mail_list_new(list);
if (ml == NULL)
goto free;
* result = ml;
return MAIL_NO_ERROR;
free:
clist_foreach(list, (clist_func) free, NULL);
clist_free(list);
return MAIL_ERROR_MEMORY;
}
void mailpop3_capa_free(struct mailpop3_capa * capa)
{
clist_foreach(capa->cap_param, (clist_func) free, NULL);
clist_free(capa->cap_param);
free(capa->cap_name);
free(capa);
}
LIBETPAN_EXPORT
void mailimf_keywords_free(struct mailimf_keywords * keywords)
{
clist_foreach(keywords->kw_list, (clist_func) mailimf_phrase_free, NULL);
clist_free(keywords->kw_list);
free(keywords);
}
LIBETPAN_EXPORT
void mailimf_references_free(struct mailimf_references * references)
{
clist_foreach(references->mid_list,
(clist_func) mailimf_msg_id_free, NULL);
clist_free(references->mid_list);
free(references);
}
LIBETPAN_EXPORT
void mailimf_in_reply_to_free(struct mailimf_in_reply_to * in_reply_to)
{
clist_foreach(in_reply_to->mid_list,
(clist_func) mailimf_msg_id_free, NULL);
clist_free(in_reply_to->mid_list);
free(in_reply_to);
}
LIBETPAN_EXPORT
void mailimf_fields_free(struct mailimf_fields * fields)
{
if (fields->fld_list != NULL) {
clist_foreach(fields->fld_list, (clist_func) mailimf_field_free, NULL);
clist_free(fields->fld_list);
}
free(fields);
}
LIBETPAN_EXPORT
void
mailimap_quota_quota_data_free(struct mailimap_quota_quota_data * data)
{
mailimap_astring_free(data->quotaroot);
clist_foreach(data->quota_list,
(clist_func) &mailimap_quota_quota_resource_free, NULL);
clist_free(data->quota_list);
free(data);
}
LIBETPAN_EXPORT
void
mailimap_quota_complete_data_free(struct mailimap_quota_complete_data * data)
{
mailimap_quota_quotaroot_data_free(data->quotaroot_data);
clist_foreach(data->quota_list,
(clist_func) &mailimap_quota_quota_data_free, NULL);
clist_free(data->quota_list);
free(data);
}
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;
}
static int mailimap_enable_parse(mailstream * fd, MMAPString * buffer,
size_t * indx,
struct mailimap_capability_data ** result,
size_t progr_rate,
progress_function * progr_fun)
{
size_t cur_token;
int r;
int res;
struct mailimap_capability_data * capabilities;
clist * cap_list;
cur_token = * indx;
r = mailimap_token_case_insensitive_parse(fd, buffer, &cur_token, "ENABLED");
if (r != MAILIMAP_NO_ERROR) {
res = r;
goto err;
}
r = mailimap_capability_list_parse(fd, buffer, &cur_token,
&cap_list,
progr_rate, progr_fun);
if (r == MAILIMAP_ERROR_PARSE) {
cap_list = clist_new();
if (cap_list == NULL) {
res = MAILIMAP_ERROR_MEMORY;
goto err;
}
r = MAILIMAP_NO_ERROR;
}
if (r != MAILIMAP_NO_ERROR) {
res = r;
goto err;
}
capabilities = mailimap_capability_data_new(cap_list);
if (capabilities == NULL) {
res = MAILIMAP_ERROR_MEMORY;
goto free_list;
}
* result = capabilities;
* indx = cur_token;
return MAILIMAP_NO_ERROR;
free_list:
if (cap_list) {
clist_foreach(cap_list, (clist_func) mailimap_capability_free, NULL);
clist_free(cap_list);
}
err:
return res;
}
static void test_clist_foreach(void)
{
list_node_t *list = &test_clist;
for (int i = 0; i < TEST_CLIST_LEN; i++) {
clist_rpush(list, &tests_clist_buf[i]);
}
clist_foreach(list, _foreach_test_trampoline);
TEST_ASSERT(_foreach_called == _foreach_abort_after);
_foreach_called = 0;
for (int i = 0; i < TEST_CLIST_LEN; i++) {
_foreach_visited[i] = 0;
}
_foreach_abort_after = (TEST_CLIST_LEN + 1);
clist_foreach(list, _foreach_test_trampoline);
TEST_ASSERT(_foreach_called == TEST_CLIST_LEN);
}
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 mailimap_xgmlabels_parse(mailstream * fd,
MMAPString * buffer, size_t * indx,
clist ** result)
{
size_t cur_token;
clist * list;
int r;
int res;
cur_token = * indx;
r = mailimap_oparenth_parse(fd, buffer, &cur_token);
if (r != MAILIMAP_NO_ERROR) {
res = r;
goto err;
}
r = mailimap_struct_spaced_list_parse(fd, buffer,
&cur_token, &list,
(mailimap_struct_parser * ) mailimap_astring_parse,
(mailimap_struct_destructor * ) mailimap_astring_free,
0, NULL);
if (r == MAILIMAP_ERROR_PARSE) {
list = clist_new();
if (list == NULL) {
res = MAILIMAP_ERROR_MEMORY;
goto err;
}
}
else if (r != MAILIMAP_NO_ERROR) {
res = r;
goto err;
}
r = mailimap_cparenth_parse(fd, buffer, &cur_token);
if (r != MAILIMAP_NO_ERROR) {
res = r;
goto free_list;
}
* indx = cur_token;
* result = list;
return MAILIMAP_NO_ERROR;
free_list:
clist_foreach(list, (clist_func) mailimap_astring_free, NULL);
clist_free(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;
}
static int flags_extension_read(MMAPString * mmapstr, size_t * indx,
clist ** result)
{
clist * list;
int r;
uint32_t count;
uint32_t i;
int res;
r = mailimf_cache_int_read(mmapstr, indx, &count);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
list = clist_new();
if (list == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
for(i = 0 ; i < count ; i++) {
char * str;
r = mailimf_cache_string_read(mmapstr, indx, &str);
if (r != MAIL_NO_ERROR) {
res = r;
goto free_list;
}
r = clist_append(list, str);
if (r < 0) {
free(str);
res = MAIL_ERROR_MEMORY;
goto free_list;
}
}
* result = list;
return MAIL_NO_ERROR;
free_list:
clist_foreach(list, (clist_func) free, NULL);
clist_free(list);
err:
return res;
}
static void mhdriver_uninitialize(mailsession * session)
{
struct mh_session_state_data * data;
data = get_data(session);
if (data->mh_session != NULL)
mailmh_free(data->mh_session);
clist_foreach(data->mh_subscribed_list, (clist_func) free, NULL);
clist_free(data->mh_subscribed_list);
free(data);
session->sess_data = NULL;
}
void at_process_urc(at_dev_t *dev, uint32_t timeout)
{
char buf[AT_BUF_SIZE];
DEBUG("Processing URC (timeout=%" PRIu32 "us)\n", timeout);
ssize_t res;
/* keep reading while received data are shorter than EOL */
while ((res = at_readline(dev, buf, sizeof(buf), true, timeout)) <
(ssize_t)sizeof(AT_RECV_EOL_1 AT_RECV_EOL_2) - 1) {
if (res < 0) {
return;
}
}
clist_foreach(&dev->urc_list, _check_urc, buf);
}
int
mailimap_quota_quota_list_nonempty_parse(mailstream * fd, MMAPString *buffer,
size_t * indx, clist ** result,
size_t progr_rate, progress_function * progr_fun)
{
size_t cur_token;
int r;
int res;
clist * quota_resource_list;
cur_token = * indx;
r = mailimap_oparenth_parse(fd, buffer, &cur_token);
if (r != MAILIMAP_NO_ERROR) {
res = r;
goto err;
}
r = mailimap_struct_spaced_list_parse(fd, buffer,
&cur_token, "a_resource_list,
&mailimap_quota_quota_resource_parse,
(mailimap_struct_destructor *)
&mailimap_quota_quota_resource_free,
progr_rate, progr_fun);
if (r != MAILIMAP_NO_ERROR) {
res = r;
goto err;
}
r = mailimap_cparenth_parse(fd, buffer, &cur_token);
if (r != MAILIMAP_NO_ERROR) {
res = r;
goto quota_list_free;
}
* result = quota_resource_list;
* indx = cur_token;
return MAILIMAP_NO_ERROR;
quota_list_free:
clist_foreach(quota_resource_list,
(clist_func) &mailimap_quota_quota_resource_free, NULL);
clist_free(quota_resource_list);
err:
return res;
}
void xover_resp_item_free(struct newsnntp_xover_resp_item * n)
{
if (n->ovr_subject)
free(n->ovr_subject);
if (n->ovr_author)
free(n->ovr_author);
if (n->ovr_date)
free(n->ovr_date);
if (n->ovr_message_id)
free(n->ovr_message_id);
if (n->ovr_references)
free(n->ovr_references);
clist_foreach(n->ovr_others, (clist_func) free, NULL);
clist_free(n->ovr_others);
free(n);
}
static struct mail_flags * mail_flags_dup(struct mail_flags * flags)
{
clist * list;
struct mail_flags * new_flags;
int r;
clistiter * cur;
list = clist_new();
if (list == NULL) {
goto err;
}
for(cur = clist_begin(flags->fl_extension) ; cur != NULL ;
cur = clist_next(cur)) {
char * ext;
char * original_ext;
original_ext = clist_content(cur);
ext = strdup(original_ext);
if (ext == NULL) {
goto free;
}
r = clist_append(list, ext);
if (r < 0) {
free(ext);
goto free;
}
}
new_flags = mail_flags_new(flags->fl_flags, list);
if (new_flags == NULL) {
goto free;
}
return new_flags;
free:
clist_foreach(list, (clist_func) free, NULL);
clist_free(list);
err:
return NULL;
}
static int generic_flags_read(MMAPString * mmapstr, size_t * indx,
struct mail_flags ** result)
{
clist * ext;
int r;
struct mail_flags * flags;
uint32_t value;
int res;
r = mailimf_cache_int_read(mmapstr, indx, &value);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
ext = NULL;
r = flags_extension_read(mmapstr, indx, &ext);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
flags = mail_flags_new(value, ext);
if (flags == NULL) {
res = r;
goto free;
}
* result = flags;
return MAIL_NO_ERROR;
free:
clist_foreach(ext, (clist_func) free, NULL);
clist_free(ext);
err:
return res;
}
struct mailmime_fields *
mailmime_fields_new_with_version(struct mailmime_mechanism * encoding,
char * id,
char * description,
struct mailmime_disposition * disposition,
struct mailmime_language * language)
{
struct mailmime_field * field;
struct mailmime_fields * fields;
int r;
fields = mailmime_fields_new_with_data(encoding, id, description,
disposition, language);
if (fields == NULL)
goto err;
field = mailmime_field_new(MAILMIME_FIELD_VERSION,
NULL, NULL, NULL, NULL, MIME_VERSION, NULL, NULL, NULL);
if (field == NULL)
goto free;
r = mailmime_fields_add(fields, field);
if (r != MAILIMF_NO_ERROR) {
mailmime_field_detach(field);
mailmime_field_free(field);
goto free;
}
return fields;
free:
clist_foreach(fields->fld_list, (clist_func) mailmime_field_detach, NULL);
mailmime_fields_free(fields);
err:
return NULL;
}
static int fetch_data_xgmlabels_parse(mailstream * fd,
MMAPString * buffer, size_t * indx,
struct mailimap_msg_att_xgmlabels ** result)
{
size_t cur_token;
struct mailimap_msg_att_xgmlabels * att;
clist * label_list;
int r;
cur_token = * indx;
r = mailimap_token_case_insensitive_parse(fd, buffer,
&cur_token, "X-GM-LABELS");
if (r != MAILIMAP_NO_ERROR)
return r;
r = mailimap_space_parse(fd, buffer, &cur_token);
if (r != MAILIMAP_NO_ERROR)
return r;
r = mailimap_xgmlabels_parse(fd, buffer, &cur_token, &label_list);
if (r != MAILIMAP_NO_ERROR)
return r;
att = mailimap_msg_att_xgmlabels_new(label_list);
if (att == NULL) {
clist_foreach(label_list, (clist_func) mailimap_astring_free, NULL);
clist_free(label_list);
return MAILIMAP_ERROR_MEMORY;
}
* indx = cur_token;
* result = att;
return MAILIMAP_NO_ERROR;
}
void mailpop3_capa_resp_free(clist * capa_list)
{
clist_foreach(capa_list, (clist_func) mailpop3_capa_free, NULL);
clist_free(capa_list);
}
static int read_capa_resp(mailpop3 * f, clist ** result)
{
char * line;
int res;
clist * list;
int r;
char * name;
clist * param_list;
list = clist_new();
if (list == NULL) {
res = MAILPOP3_NO_ERROR;
goto err;
}
while (1) {
char * next_token;
char * param;
struct mailpop3_capa * capa;
line = read_line(f);
if (line == NULL) {
res = MAILPOP3_ERROR_STREAM;
goto free_list;
}
if (mailstream_is_end_multiline(line))
break;
next_token = cut_token(line);
name = strdup(line);
if (name == NULL) {
res = MAILPOP3_ERROR_MEMORY;
goto free_list;
}
param_list = clist_new();
if (param_list == NULL) {
res = MAILPOP3_ERROR_MEMORY;
goto free_capa_name;
}
while (next_token != NULL) {
line = next_token;
next_token = cut_token(line);
param = strdup(line);
if (param == NULL) {
res = MAILPOP3_ERROR_MEMORY;
goto free_param_list;
}
r = clist_append(param_list, param);
if (r < 0) {
free(param);
res = MAILPOP3_ERROR_MEMORY;
goto free_param_list;
}
}
capa = mailpop3_capa_new(name, param_list);
if (capa == NULL) {
res = MAILPOP3_ERROR_MEMORY;
goto free_param_list;
}
r = clist_append(list, capa);
if (r < 0) {
mailpop3_capa_free(capa);
res = MAILPOP3_ERROR_MEMORY;
goto free_list;
}
}
* result = list;
return MAILPOP3_NO_ERROR;
free_param_list:
clist_foreach(param_list, (clist_func) free, NULL);
clist_free(param_list);
free_capa_name:
free(name);
free_list:
clist_foreach(list, (clist_func) mailpop3_capa_free, NULL);
clist_free(list);
err:
return res;
}
