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;
}