static int imap_initialize(mailmessage * msg_info)
{
mailmessage * ancestor;
int r;
char key[PATH_MAX];
char * uid;
mailimap * imap;
ancestor = mailmessage_new();
if (ancestor == NULL)
return MAIL_ERROR_MEMORY;
r = mailmessage_init(ancestor, get_ancestor_session(msg_info),
imap_message_driver,
msg_info->msg_index, 0);
if (r != MAIL_NO_ERROR) {
mailmessage_free(ancestor);
return r;
}
imap = get_imap_session(msg_info);
snprintf(key, PATH_MAX, "%u-%u",
imap->imap_selection_info->sel_uidvalidity, msg_info->msg_index);
uid = strdup(key);
if (uid == NULL) {
mailmessage_free(ancestor);
return MAIL_ERROR_MEMORY;
}
msg_info->msg_data = ancestor;
msg_info->msg_uid = uid;
return MAIL_NO_ERROR;
}
static int fetch_registered_part(struct mailprivacy * privacy,
int (* fetch_section)(mailmessage *, struct mailmime *,
char **, size_t *),
struct mailmime * mime,
char ** result, size_t * result_len)
{
mailmessage * dummy_msg;
int res;
char * content;
size_t content_len;
int r;
dummy_msg = mime_message_init(NULL);
if (dummy_msg == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
r = mime_message_set_tmpdir(dummy_msg, privacy->tmp_dir);
if (r != MAIL_NO_ERROR) {
res = MAIL_ERROR_MEMORY;
goto free_msg;
}
r = fetch_section(dummy_msg, mime, &content, &content_len);
if (r != MAIL_NO_ERROR) {
res = r;
goto free_msg;
}
r = register_result_mmapstr(privacy, content);
if (r != MAIL_NO_ERROR) {
res = r;
goto free_fetch;
}
mailmessage_free(dummy_msg);
* result = content;
* result_len = content_len;
return MAIL_NO_ERROR;
free_fetch:
mailmessage_fetch_result_free(dummy_msg, content);
free_msg:
mailmessage_free(dummy_msg);
err:
return res;
}
mailmessage * mime_message_init(struct mailmime * mime)
{
mailmessage * msg;
int r;
msg = mailmessage_new();
if (msg == NULL)
goto err;
r = mailmessage_init(msg, NULL, mime_message_driver, 0, 0);
if (r != MAIL_NO_ERROR)
goto free;
if (mime != NULL) {
mailmime_free(msg->msg_mime);
msg->msg_mime = mime;
}
return msg;
free:
mailmessage_free(msg);
err:
return NULL;
}
static int feeddriver_get_messages_list(mailsession * session,
struct mailmessage_list ** result)
{
unsigned int i;
struct feed_session_state_data * data;
unsigned int count;
struct mailmessage_list * msg_list;
carray * tab;
int res;
int r;
update(session);
data = get_data(session);
if (data->feed_error != MAIL_NO_ERROR) {
res = data->feed_error;
goto err;
}
count = newsfeed_item_list_get_count(data->feed_session);
tab = carray_new(count);
if (tab == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
fprintf(stderr, "count: %i\n", count);
for(i = 0 ; i < count ; i ++) {
struct newsfeed_item * item;
mailmessage * msg;
item = newsfeed_get_item(data->feed_session, i);
msg = feed_item_to_message(session, i, item);
r = carray_add(tab, msg, NULL);
if (r < 0) {
res = MAIL_ERROR_MEMORY;
goto free_tab;
}
}
msg_list = mailmessage_list_new(tab);
if (msg_list == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_tab;
}
* result = msg_list;
return MAIL_NO_ERROR;
free_tab:
for(i = 0 ; i < carray_count(tab) ; i ++) {
mailmessage * msg;
msg = carray_get(tab, i);
mailmessage_free(msg);
}
err:
return res;
}
mailmessage * data_message_init(char * data, size_t len)
{
struct generic_message_t * msg_data;
mailmessage * msg;
int r;
struct mailimf_fields * fields;
msg = mailmessage_new();
if (msg == NULL)
goto err;
r = mailmessage_init(msg, NULL, data_message_driver, 0, len);
if (r < 0)
goto free;
msg_data = msg->msg_data;
msg_data->msg_fetched = 1;
msg_data->msg_message = data;
msg_data->msg_length = len;
r = mailmessage_generic_fetch_envelope(msg, &fields);
if (r != MAIL_NO_ERROR)
goto free;
msg->msg_fields = fields;
return msg;
free:
mailmessage_free(msg);
err:
return NULL;
}
static int get_message(mailsession * session,
uint32_t num, mailmessage ** result)
{
mailmessage * msg;
int r;
size_t size;
char key[PATH_MAX];
struct db_session_state_data * data;
struct mail_cache_db * maildb;
int res;
data = get_data(session);
r = mail_cache_db_open_lock(data->db_filename, &maildb);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto err;
}
msg = mailmessage_new();
if (msg == NULL) {
res = MAIL_ERROR_MEMORY;
goto close_db;
}
size = 0;
snprintf(key, sizeof(key), "%lu", (unsigned long) num);
r = mail_cache_db_get_size(maildb, key, strlen(key), &size);
/* ignore error */
r = mailmessage_init(msg, session, db_message_driver,
num, size);
if (r != MAIL_NO_ERROR) {
mailmessage_free(msg);
res = r;
goto close_db;
}
mail_cache_db_close_unlock(data->db_filename, maildb);
return MAIL_NO_ERROR;
close_db:
mail_cache_db_close_unlock(data->db_filename, maildb);
err:
return res;
}
void mail_flags_store_clear(struct mail_flags_store * flags_store)
{
unsigned int i;
for(i = 0 ; i < carray_count(flags_store->fls_tab) ; i ++) {
chashdatum key;
mailmessage * msg;
msg = carray_get(flags_store->fls_tab, i);
key.data = &msg->msg_index;
key.len = sizeof(msg->msg_index);
chash_delete(flags_store->fls_hash, &key, NULL);
mailmessage_free(msg);
}
carray_set_size(flags_store->fls_tab, 0);
}
static int nntpdriver_cached_get_message(mailsession * session,
uint32_t num, mailmessage ** result)
{
mailmessage * msg_info;
int r;
msg_info = mailmessage_new();
if (msg_info == NULL)
return MAIL_ERROR_MEMORY;
r = mailmessage_init(msg_info, session, nntp_cached_message_driver, num, 0);
if (r != MAIL_NO_ERROR) {
mailmessage_free(msg_info);
return r;
}
* result = msg_info;
return MAIL_NO_ERROR;
}
static int folder_message_unref(struct folder_ref_info * ref_info,
mailmessage * msg)
{
struct message_ref_elt * msg_ref;
int count;
msg_ref = folder_info_get_msg_ref(ref_info, msg);
if (msg_ref->ref_count == 0) {
#ifdef ETPAN_APP_DEBUG
ETPAN_APP_DEBUG((engine_app, "** BUG detected negative ref count !"));
#endif
}
count = message_unref(msg_ref);
if (count == 0) {
folder_message_remove(ref_info, msg);
mailmessage_free(msg);
}
return count;
}
int nntp_get_messages_list(mailsession * nntp_session,
mailsession * session,
mailmessage_driver * driver,
struct mailmessage_list ** result)
{
carray * tab;
struct mailmessage_list * env_list;
uint32_t i;
int res;
int r;
struct nntp_session_state_data * data;
struct newsnntp_group_info * group_info;
uint32_t max;
unsigned int cur;
data = session_get_data(nntp_session);
if (data->nntp_group_name == NULL) {
res = MAIL_ERROR_BAD_STATE;
goto err;
}
r = nntpdriver_select_folder(nntp_session, data->nntp_group_name);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
group_info = data->nntp_group_info;
if (group_info == NULL) {
res = MAIL_ERROR_BAD_STATE;
goto err;
}
max = group_info->grp_first;
if (data->nntp_max_articles != 0) {
if (group_info->grp_last - data->nntp_max_articles + 1 > max)
max = group_info->grp_last - data->nntp_max_articles + 1;
}
tab = carray_new(128);
if (tab == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
for(i = max ; i <= group_info->grp_last ; i++) {
mailmessage * msg;
msg = mailmessage_new();
if (msg == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_list;
}
r = mailmessage_init(msg, session, driver, i, 0);
if (r != MAIL_NO_ERROR) {
mailmessage_free(msg);
res = r;
goto free_list;
}
r = carray_add(tab, msg, NULL);
if (r < 0) {
mailmessage_free(msg);
res = MAIL_ERROR_MEMORY;
goto free_list;
}
}
env_list = mailmessage_list_new(tab);
if (env_list == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_list;
}
* result = env_list;
return MAIL_NO_ERROR;
free_list:
for(cur = 0 ; cur < carray_count(tab) ; cur ++)
mailmessage_free(carray_get(tab, cur));
carray_free(tab);
err:
return res;
}
int main(int argc, char ** argv)
{
int r;
int driver;
char * server;
int port;
int connection_type;
char * user;
char * password;
int auth_type;
char * path;
char * cache_directory;
char * flags_directory;
struct mailstorage * storage;
int cached;
struct mailfolder * folder;
/* get options */
r = parse_options(argc, argv,
&driver, &server, &port, &connection_type,
&user, &password, &auth_type,
&path, &cache_directory, &flags_directory);
cached = (cache_directory != NULL);
/* build the storage structure */
storage = mailstorage_new(NULL);
if (storage == NULL) {
printf("error initializing storage\n");
goto free_opt;
}
r = init_storage(storage, driver, server, port, connection_type,
user, password, auth_type, path, cache_directory, flags_directory);
if (r != MAIL_NO_ERROR) {
printf("error initializing storage\n");
goto free_opt;
}
/* get the folder structure */
folder = mailfolder_new(storage, path, NULL);
if (folder == NULL) {
printf("error initializing folder\n");
goto free_storage;
}
r = mailfolder_connect(folder);
if (r != MAIL_NO_ERROR) {
printf("error initializing folder\n");
goto free_folder;
}
while (optind < argc) {
mailmessage * msg;
uint32_t msg_num;
struct mailmime * mime;
msg_num = strtoul(argv[optind], NULL, 10);
r = mailsession_get_message(folder->fld_session, msg_num, &msg);
if (r != MAIL_NO_ERROR) {
printf("** message %i not found ** - %s\n", msg_num,
maildriver_strerror(r));
optind ++;
continue;
}
r = mailmessage_get_bodystructure(msg, &mime);
if (r != MAIL_NO_ERROR) {
printf("** message %i not found - %s **\n", msg_num,
maildriver_strerror(r));
mailmessage_free(msg);
optind ++;
continue;
}
r = etpan_fetch_mime(stdout, msg, mime);
mailmessage_free(msg);
optind ++;
}
mailfolder_free(folder);
mailstorage_free(storage);
if (server != NULL)
free(server);
if (user != NULL)
free(user);
if (password != NULL)
free(password);
if (path != NULL)
free(path);
if (cache_directory != NULL)
free(cache_directory);
if (flags_directory != NULL)
free(flags_directory);
return 0;
free_folder:
mailfolder_free(folder);
free_storage:
mailstorage_free(storage);
free_opt:
if (server != NULL)
free(server);
if (user != NULL)
free(user);
if (password != NULL)
free(password);
if (path != NULL)
free(path);
if (cache_directory != NULL)
free(cache_directory);
if (flags_directory != NULL)
free(flags_directory);
return -1;
}
static int get_message_by_uid(mailsession * session,
const char * uid, mailmessage ** result)
{
int r;
struct maildir * md;
int res;
mailmessage * msg;
char * msg_filename;
struct stat stat_info;
md = get_maildir_session(session);
/* update maildir data */
r = maildir_update(md);
if (r != MAILDIR_NO_ERROR) {
res = maildirdriver_maildir_error_to_mail_error(r);
goto err;
}
msg_filename = maildir_message_get(md, uid);
if (msg_filename == NULL) {
res = MAIL_ERROR_INVAL;
goto err;
}
r = stat(msg_filename, &stat_info);
free(msg_filename);
if (r < 0) {
res = MAIL_ERROR_INVAL;
goto err;
}
/* create message */
msg = mailmessage_new();
if (msg == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
r = mailmessage_init(msg, session, maildir_message_driver,
0, stat_info.st_size);
if (r != MAIL_NO_ERROR) {
mailmessage_free(msg);
res = r;
goto err;
}
msg->msg_uid = strdup(uid);
if (msg->msg_uid == NULL) {
mailmessage_free(msg);
res = r;
goto err;
}
* result = msg;
return MAIL_NO_ERROR;
err:
return res;
}
int mail_flags_store_set(struct mail_flags_store * flags_store,
mailmessage * msg)
{
chashdatum key;
chashdatum value;
unsigned int indx;
int res;
int r;
mailmessage * new_msg;
if (msg->msg_flags == NULL) {
res = MAIL_NO_ERROR;
goto err;
}
/* duplicate needed message info */
new_msg = mailmessage_build(msg);
if (new_msg == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
key.data = &new_msg->msg_index;
key.len = sizeof(new_msg->msg_index);
r = chash_get(flags_store->fls_hash, &key, &value);
if (r == 0) {
mailmessage * old_msg;
indx = * (unsigned int *) value.data;
old_msg = carray_get(flags_store->fls_tab, indx);
mailmessage_free(old_msg);
}
else {
r = carray_set_size(flags_store->fls_tab,
carray_count(flags_store->fls_tab) + 1);
if (r != 0) {
res = MAIL_ERROR_MEMORY;
goto err;
}
indx = carray_count(flags_store->fls_tab) - 1;
}
carray_set(flags_store->fls_tab, indx, new_msg);
value.data = &indx;
value.len = sizeof(indx);
r = chash_set(flags_store->fls_hash, &key, &value, NULL);
if (r < 0) {
carray_delete(flags_store->fls_tab, indx);
res = MAIL_ERROR_MEMORY;
goto free;
}
return MAIL_NO_ERROR;
free:
mailmessage_free(new_msg);
err:
return res;
}
static void imap_uninitialize(mailmessage * msg_info)
{
mailmessage_free(get_ancestor(msg_info));
msg_info->msg_data = NULL;
}
static int folder_update_msg_list(struct folder_ref_info * ref_info,
struct mailmessage_list ** p_new_msg_list,
struct mailmessage_list ** p_lost_msg_list)
{
int r;
int res;
struct mailmessage_list * new_env_list;
unsigned int i;
carray * lost_msg_tab;
struct mailmessage_list * lost_msg_list;
unsigned int free_start_index;
chashiter * iter;
unsigned int lost_count;
r = mailfolder_get_messages_list(ref_info->folder, &new_env_list);
if (r != MAIL_NO_ERROR) {
res = r;
goto err;
}
for(iter = chash_begin(ref_info->msg_hash) ; iter != NULL ;
iter = chash_next(ref_info->msg_hash, iter)) {
struct message_ref_elt * msg_ref;
chashdatum data;
chash_value(iter, &data);
msg_ref = data.data;
msg_ref->lost = 1;
}
lost_count = chash_count(ref_info->msg_hash);
for(i = 0 ; i < carray_count(new_env_list->msg_tab) ; i ++) {
mailmessage * msg;
mailmessage * old_msg;
msg = carray_get(new_env_list->msg_tab, i);
if (msg->msg_uid == NULL)
continue;
old_msg = folder_info_get_msg_by_uid(ref_info, msg->msg_uid);
if (old_msg != NULL) {
struct message_ref_elt * msg_ref;
/* replace old message */
old_msg->msg_index = msg->msg_index;
carray_set(new_env_list->msg_tab, i, old_msg);
mailmessage_free(msg);
msg_ref = folder_info_get_msg_ref(ref_info, old_msg);
msg_ref->lost = 0;
lost_count --;
}
else {
/* set new message */
r = folder_message_add(ref_info, msg);
if (r != MAIL_NO_ERROR) {
free_start_index = i;
res = r;
goto free_remaining;
}
}
}
/* build the table of lost messages */
lost_msg_tab = carray_new(lost_count);
if (lost_msg_tab == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_env_list;
}
carray_set_size(lost_msg_tab, lost_count);
i = 0;
for(iter = chash_begin(ref_info->msg_hash) ; iter != NULL ;
iter = chash_next(ref_info->msg_hash, iter)) {
struct message_ref_elt * msg_ref;
chashdatum key;
chashdatum value;
mailmessage * msg;
chash_key(iter, &key);
memcpy(&msg, key.data, sizeof(msg));
chash_value(iter, &value);
msg_ref = value.data;
if (msg_ref->lost) {
carray_set(lost_msg_tab, i, msg);
i ++;
}
}
lost_msg_list = mailmessage_list_new(lost_msg_tab);
if (lost_msg_list == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_lost_msg_tab;
}
/* reference messages */
for(i = 0 ; i < carray_count(new_env_list->msg_tab) ; i ++) {
mailmessage * msg;
msg = carray_get(new_env_list->msg_tab, i);
folder_message_ref(ref_info, msg);
}
* p_new_msg_list = new_env_list;
* p_lost_msg_list = lost_msg_list;
return MAIL_NO_ERROR;
free_lost_msg_tab:
carray_free(lost_msg_tab);
free_env_list:
for(i = 0 ; i < carray_count(new_env_list->msg_tab) ; i ++) {
mailmessage * msg;
struct message_ref_elt * msg_ref;
msg = carray_get(new_env_list->msg_tab, i);
msg_ref = folder_info_get_msg_ref(ref_info, msg);
if (msg_ref != NULL) {
if (msg_ref->ref_count == 0)
folder_message_remove(ref_info, msg);
}
}
carray_set_size(new_env_list->msg_tab, 0);
mailmessage_list_free(new_env_list);
goto err;
free_remaining:
for(i = 0 ; i < carray_count(new_env_list->msg_tab) ; i ++) {
mailmessage * msg;
struct message_ref_elt * msg_ref;
msg = carray_get(new_env_list->msg_tab, i);
msg_ref = folder_info_get_msg_ref(ref_info, msg);
if (msg_ref != NULL) {
if (msg_ref->ref_count == 0)
folder_message_remove(ref_info, msg);
}
}
for(i = free_start_index ; i < carray_count(new_env_list->msg_tab) ; i ++) {
mailmessage * msg;
msg = carray_get(new_env_list->msg_tab, i);
mailmessage_free(msg);
}
carray_set_size(new_env_list->msg_tab, 0);
mailmessage_list_free(new_env_list);
err:
return res;
}
static int
nntpdriver_get_envelopes_list(mailsession * session,
struct mailmessage_list * env_list)
{
newsnntp * nntp;
int r;
struct nntp_session_state_data * data;
clist * list;
int done;
clistiter * cur;
uint32_t first_seq;
unsigned int i;
nntp = get_nntp_session(session);
data = get_data(session);
if (data->nntp_group_info == NULL)
return MAIL_ERROR_BAD_STATE;
first_seq = data->nntp_group_info->grp_first;
if (carray_count(env_list->msg_tab) > 0) {
mailmessage * msg;
msg = carray_get(env_list->msg_tab, 0);
first_seq = msg->msg_index;
}
if (carray_count(env_list->msg_tab) > 0) {
i = carray_count(env_list->msg_tab) - 1;
while (1) {
mailmessage * msg;
msg = carray_get(env_list->msg_tab, i);
if (msg->msg_fields != NULL) {
first_seq = msg->msg_index + 1;
break;
}
if (i == 0)
break;
i --;
}
}
if (first_seq > data->nntp_group_info->grp_last) {
list = NULL;
}
else {
done = FALSE;
do {
r = newsnntp_xover_range(nntp, first_seq,
data->nntp_group_info->grp_last, &list);
switch (r) {
case NEWSNNTP_ERROR_REQUEST_AUTHORIZATION_USERNAME:
r = nntpdriver_authenticate_user(session);
if (r != MAIL_NO_ERROR)
return r;
break;
case NEWSNNTP_WARNING_REQUEST_AUTHORIZATION_PASSWORD:
r = nntpdriver_authenticate_password(session);
if (r != MAIL_NO_ERROR)
return r;
break;
case NEWSNNTP_NO_ERROR:
done = TRUE;
break;
default:
return nntpdriver_nntp_error_to_mail_error(r);
}
}
while (!done);
}
#if 0
i = 0;
j = 0;
if (list != NULL) {
for(cur = clist_begin(list) ; cur != NULL ; cur = clist_next(cur)) {
struct newsnntp_xover_resp_item * item;
struct mailimf_fields * fields;
item = clist_content(cur);
while (i < carray_count(env_list->msg_tab)) {
mailmessage * info;
info = carray_get(env_list->msg_tab, i);
if (item->ovr_article == info->msg_index) {
if (info->fields == NULL) {
r = xover_resp_to_fields(item, &fields);
if (r == MAIL_NO_ERROR) {
info->fields = fields;
}
info->size = item->ovr_size;
carray_set(env_list->msg_tab, j, info);
j ++;
i ++;
break;
}
else {
carray_set(env_list->msg_tab, j, info);
j ++;
}
}
else {
if (info->fields != NULL) {
carray_set(env_list->msg_tab, j, info);
j ++;
}
else {
if (info->flags != NULL) {
info->flags->flags &= ~MAIL_FLAG_NEW;
info->flags->flags |= MAIL_FLAG_SEEN | MAIL_FLAG_DELETED;
mailmessage_check(info);
}
mailmessage_free(info);
carray_set(env_list->msg_tab, i, NULL);
}
}
i ++;
}
}
}
while (i < carray_count(env_list->msg_tab)) {
mailmessage * info;
info = carray_get(env_list->msg_tab, i);
if (info->fields != NULL) {
carray_set(env_list->msg_tab, j, info);
j ++;
}
else {
if (info->flags != NULL) {
info->flags->flags &= ~MAIL_FLAG_NEW;
info->flags->flags |= MAIL_FLAG_SEEN | MAIL_FLAG_DELETED;
mailmessage_check(info);
}
mailmessage_free(info);
carray_set(env_list->msg_tab, i, NULL);
}
i ++;
}
r = carray_set_size(env_list->msg_tab, j);
if (r < 0) {
if (list != NULL)
newsnntp_xover_resp_list_free(list);
return MAIL_ERROR_MEMORY;
}
#endif
i = 0;
if (list != NULL) {
for(cur = clist_begin(list) ; cur != NULL ; cur = clist_next(cur)) {
struct newsnntp_xover_resp_item * item;
struct mailimf_fields * fields;
item = clist_content(cur);
while (i < carray_count(env_list->msg_tab)) {
mailmessage * info;
info = carray_get(env_list->msg_tab, i);
if (item->ovr_article == info->msg_index) {
if (info->msg_fields == NULL) {
fields = NULL;
r = xover_resp_to_fields(item, &fields);
if (r == MAIL_NO_ERROR) {
info->msg_fields = fields;
}
info->msg_size = item->ovr_size;
i ++;
break;
}
}
#if 0
else if ((info->fields == NULL) && (info->flags != NULL)) {
info->flags->flags &= ~MAIL_FLAG_NEW;
info->flags->flags |= MAIL_FLAG_CANCELLED;
mailmessage_check(info);
}
#endif
i ++;
}
}
}
#if 0
while (i < env_list->msg_tab->len) {
mailmessage * info;
info = carray_get(env_list->msg_tab, i);
if ((info->fields == NULL) && (info->flags != NULL)) {
info->flags->flags &= ~MAIL_FLAG_NEW;
info->flags->flags |= MAIL_FLAG_CANCELLED;
mailmessage_check(info);
}
i ++;
}
#endif
if (list != NULL)
newsnntp_xover_resp_list_free(list);
return MAIL_NO_ERROR;
}
static int get_messages_list(mailsession * session,
struct mailmessage_list ** result)
{
int r;
char key[PATH_MAX];
struct mail_cache_db * maildb;
struct db_session_state_data * data;
int res;
carray * msglist;
unsigned int i;
carray * msgtab;
struct mailmessage_list * driver_msglist;
data = get_data(session);
r = mail_cache_db_open_lock(data->db_filename, &maildb);
if (r < 0) {
res = MAIL_ERROR_FILE;
goto err;
}
r = db_get_message_list(maildb, &msglist);
if (r != MAIL_NO_ERROR) {
res = r;
goto close_db;
}
msgtab = carray_new(16);
if (msgtab == NULL) {
res = MAIL_ERROR_MEMORY;
goto close_db;
}
for(i = 0 ; i < carray_count(msglist) ; i ++) {
uint32_t msg_num;
uint32_t * pmsg_num;
mailmessage * msg;
size_t size;
pmsg_num = carray_get(msglist, i);
msg_num = * pmsg_num;
free(pmsg_num);
carray_set(msglist, i, NULL);
snprintf(key, sizeof(key), "%lu", (unsigned long) msg_num);
r = mail_cache_db_get_size(maildb, key, strlen(key), &size);
if (r < 0) {
continue;
}
msg = mailmessage_new();
if (msg == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_list;
}
r = mailmessage_init(msg, session, db_message_driver,
msg_num, size);
if (r != MAIL_NO_ERROR) {
mailmessage_free(msg);
res = r;
goto free_list;
}
r = carray_add(msgtab, msg, NULL);
if (r < 0) {
mailmessage_free(msg);
res = MAIL_ERROR_MEMORY;
goto free_list;
}
}
carray_free(msglist);
driver_msglist = mailmessage_list_new(msgtab);
if (driver_msglist == NULL) {
res = MAIL_ERROR_MEMORY;
goto free_list;
}
mail_cache_db_close_unlock(data->db_filename, maildb);
* result = driver_msglist;
return MAIL_NO_ERROR;
free_list:
for(i = 0 ; i < carray_count(msgtab) ; i ++) {
mailmessage * msg;
msg = carray_get(msgtab, i);
mailmessage_free(msg);
}
carray_free(msgtab);
for(i = 0 ; i < carray_count(msglist) ; i ++) {
uint32_t * msg;
msg = carray_get(msglist, i);
if (msg != NULL)
free(msg);
}
carray_free(msglist);
close_db:
mail_cache_db_close_unlock(data->db_filename, maildb);
err:
return res;
}
int mailprivacy_get_mime(struct mailprivacy * privacy,
int check_privacy, int reencode,
char * content, size_t content_len,
struct mailmime ** result_mime)
{
struct mailmime * mime;
mailmessage * msg;
int r;
int res;
#if 0
int check_privacy;
check_privacy = (privacy != NULL);
#endif
/*
use message data driver, get bodystructure and
convert all the data part in MAILMIME_SINGLE to files.
*/
msg = data_message_init(content, content_len);
if (msg == NULL) {
res = MAIL_ERROR_MEMORY;
goto err;
}
#if 0
if (msg->mime == NULL) {
if (check_privacy) {
r = mailprivacy_msg_get_bodystructure(privacy, msg, &mime);
}
else {
/*
don't use etpan_msg_get_bodystructure because it is not useful
and to avoid loops due to security part
*/
r = mailmessage_get_bodystructure(msg, &mime);
}
}
else {
mime = msg->mime;
}
#endif
if (check_privacy)
r = mailprivacy_msg_get_bodystructure(privacy, msg, &mime);
else
r = mailmessage_get_bodystructure(msg, &mime);
if (r != MAIL_NO_ERROR) {
res = r;
goto free_msg;
}
/*
should be done so that the MIME structure need not to be unregistered.
*/
mailprivacy_recursive_unregister_mime(privacy, mime);
r = recursive_replace_single_parts(privacy, mime, reencode);
if (r != MAIL_NO_ERROR) {
res = r;
goto clear_mime;
}
data_message_detach_mime(msg);
#if 0
if (check_privacy)
mailprivacy_msg_flush(privacy, msg);
else
mailmessage_flush(msg);
#endif
mailprivacy_msg_flush(privacy, msg);
mailmessage_free(msg);
* result_mime = mime;
return MAIL_NO_ERROR;
clear_mime:
mailprivacy_mime_clear(mime);
mailprivacy_msg_flush(privacy, msg);
free_msg:
mailmessage_free(msg);
err:
return res;
}
int main(int argc, char ** argv)
{
char * content;
size_t length;
mailmessage * msg;
int r;
struct mailprivacy * privacy;
struct mailmime * mime;
int col;
privacy = mailprivacy_new("/Users/hoa/tmp", 1);
if (privacy == NULL) {
goto err;
}
r = mailprivacy_gnupg_init(privacy);
if (r != MAIL_NO_ERROR) {
goto free_privacy;
}
r = mailprivacy_smime_init(privacy);
mailprivacy_smime_set_cert_dir(privacy,
"/Users/hoa/LibEtPan/libetpan/tests/keys/cert");
mailprivacy_smime_set_CA_dir(privacy,
"/Users/hoa/LibEtPan/libetpan/tests/keys/ca");
mailprivacy_smime_set_private_keys_dir(privacy,
"/Users/hoa/LibEtPan/libetpan/tests/keys/private");
mailprivacy_gnupg_set_encryption_id(privacy, "xxxx@xxxx", "coin");
mailprivacy_smime_set_encryption_id(privacy, "xxxx@xxxx", "coin");
if (argc < 2) {
fprintf(stderr, "syntax: decrypt [message]\n");
goto done_gpg;
}
r = get_content_of_file(argv[1], &content, &length);
if (r < 0) {
fprintf(stderr, "file not found %s\n", argv[1]);
goto done_gpg;
}
msg = data_message_init(content, length);
if (msg == NULL) {
fprintf(stderr, "unexpected error\n");
goto free_content;
}
r = mailprivacy_msg_get_bodystructure(privacy, msg, &mime);
if (r != MAIL_NO_ERROR) {
fprintf(stderr, "unexpected error\n");
goto free_content;
}
mailmime_write(stdout, &col, mime);
{
clist * id_list;
clistiter * iter;
id_list = mailprivacy_gnupg_encryption_id_list(privacy, msg);
if (id_list != NULL) {
for(iter = clist_begin(id_list) ; iter != NULL ; iter = clist_next(iter)) {
char * str;
str = clist_content(iter);
fprintf(stderr, "%s\n", str);
}
}
}
{
clist * id_list;
clistiter * iter;
id_list = mailprivacy_smime_encryption_id_list(privacy, msg);
if (id_list != NULL) {
for(iter = clist_begin(id_list) ; iter != NULL ; iter = clist_next(iter)) {
char * str;
str = clist_content(iter);
fprintf(stderr, "%s\n", str);
}
}
}
mailprivacy_gnupg_encryption_id_list_clear(privacy, msg);
mailmessage_free(msg);
free(content);
mailprivacy_smime_done(privacy);
mailprivacy_gnupg_done(privacy);
mailprivacy_free(privacy);
exit(EXIT_SUCCESS);
free_content:
free(content);
done_gpg:
mailprivacy_gnupg_done(privacy);
free_privacy:
mailprivacy_free(privacy);
err:
exit(EXIT_FAILURE);
}
