/*! *\brief check for flags (e.g. mark) in prior msgs of current thread * *\param info Current message *\param perm_flags Flags to be checked *\param parentmsgs Hash of prior msgs to avoid loops * *\return gboolean TRUE if perm_flags are found */ gboolean procmsg_msg_has_flagged_parent_real(MsgInfo *info, MsgPermFlags perm_flags, GHashTable *parentmsgs) { MsgInfo *tmp; g_return_val_if_fail(info != NULL, FALSE); if (info != NULL && info->folder != NULL && info->inreplyto != NULL) { tmp = folder_item_get_msginfo_by_msgid(info->folder, info->inreplyto); if (tmp && (tmp->flags.perm_flags & perm_flags)) { procmsg_msginfo_free(tmp); return TRUE; } else if (tmp != NULL) { gboolean result; if (g_hash_table_lookup(parentmsgs, info)) { debug_print("loop detected: %s%c%d\n", folder_item_get_path(info->folder), G_DIR_SEPARATOR, info->msgnum); result = FALSE; } else { g_hash_table_insert(parentmsgs, info, "1"); result = procmsg_msg_has_flagged_parent_real( tmp, perm_flags, parentmsgs); } procmsg_msginfo_free(tmp); return result; } else { return FALSE; } } else return FALSE; }
gint procmsg_save_to_outbox(FolderItem *outbox, const gchar *file, gboolean is_queued) { gint num; MsgInfo *msginfo, *tmp_msginfo; MsgFlags flag = {0, 0}; debug_print("saving sent message...\n"); if (!outbox) outbox = folder_get_default_outbox(); g_return_val_if_fail(outbox != NULL, -1); /* remove queueing headers */ if (is_queued) { gchar tmp[MAXPATHLEN + 1]; g_snprintf(tmp, sizeof(tmp), "%s%ctmpmsg.out.%08x", get_rc_dir(), G_DIR_SEPARATOR, (guint) rand()); if (procmsg_remove_special_headers(file, tmp) !=0) return -1; folder_item_scan(outbox); if ((num = folder_item_add_msg(outbox, tmp, &flag, TRUE)) < 0) { g_warning("can't save message\n"); unlink(tmp); return -1; } } else { folder_item_scan(outbox); if ((num = folder_item_add_msg (outbox, file, &flag, FALSE)) < 0) { g_warning("can't save message\n"); return -1; } return -1; } msginfo = folder_item_get_msginfo(outbox, num); /* refcnt++ */ tmp_msginfo = procmsg_msginfo_get_full_info(msginfo); /* refcnt++ */ if (msginfo != NULL) { procmsg_msginfo_unset_flags(msginfo, ~0, 0); procmsg_msginfo_free(msginfo); /* refcnt-- */ /* tmp_msginfo == msginfo */ if (tmp_msginfo && (msginfo->dispositionnotificationto || msginfo->returnreceiptto)) { procmsg_msginfo_set_flags(msginfo, MSG_RETRCPT_SENT, 0); procmsg_msginfo_free(msginfo); /* refcnt-- */ } } return 0; }
void mimeview_print_part(MimeView *mimeview, MimeInfo *partinfo) { g_return_if_fail(partinfo != NULL); if (!mimeview->messageview->file) return; if (partinfo->mime_type == MIME_MESSAGE_RFC822) { gchar *filename; MsgInfo *msginfo; MsgFlags flags = {0, 0}; filename = procmime_get_tmp_file_name(partinfo); if (procmime_get_part(filename, mimeview->messageview->file, partinfo) < 0) { alertpanel_error (_("Can't save the part of multipart message.")); g_free(filename); return; } msginfo = procheader_parse_file(filename, flags, TRUE); msginfo->file_path = filename; filename = NULL; printing_print_message (msginfo, mimeview->textview->show_all_headers); procmsg_msginfo_free(msginfo); } else if (partinfo->mime_type == MIME_TEXT || partinfo->mime_type == MIME_TEXT_HTML) { printing_print_message_part(mimeview->messageview->msginfo, partinfo); } }
void msgcache_update_msg(MsgCache *cache, MsgInfo *msginfo) { MsgInfo *oldmsginfo, *newmsginfo; g_return_if_fail(cache != NULL); g_return_if_fail(msginfo != NULL); oldmsginfo = g_hash_table_lookup(cache->msgnum_table, &msginfo->msgnum); if (oldmsginfo && oldmsginfo->msgid) g_hash_table_remove(cache->msgid_table, oldmsginfo->msgid); if (oldmsginfo) { g_hash_table_remove(cache->msgnum_table, &oldmsginfo->msgnum); cache->memusage -= procmsg_msginfo_memusage(oldmsginfo); procmsg_msginfo_free(oldmsginfo); } newmsginfo = procmsg_msginfo_new_ref(msginfo); g_hash_table_insert(cache->msgnum_table, &newmsginfo->msgnum, newmsginfo); if(newmsginfo->msgid) g_hash_table_insert(cache->msgid_table, newmsginfo->msgid, newmsginfo); cache->memusage += procmsg_msginfo_memusage(newmsginfo); cache->last_access = time(NULL); debug_print("Cache size: %d messages, %d byte\n", g_hash_table_size(cache->msgnum_table), cache->memusage); return; }
void vcal_view_select_event (const gchar *uid, FolderItem *item, gboolean edit, GCallback block_cb, gpointer block_data) { if (edit) { VCalEvent *event = NULL; event = vcal_manager_load_event(uid); if (event) { vcal_meeting_create(event); vcal_manager_free_event(event); } } else { SummaryView *summaryview = NULL; if (mainwindow_get_mainwindow()) { MsgInfo *info = folder_item_get_msginfo_by_msgid(item, uid); if (info) { summaryview = mainwindow_get_mainwindow()->summaryview; g_signal_handlers_block_by_func(G_OBJECT(summaryview->ctree), G_CALLBACK(block_cb), block_data); summary_select_by_msgnum(summaryview, info->msgnum); summary_display_msg_selected(summaryview, FALSE); procmsg_msginfo_free(&info); g_signal_handlers_unblock_by_func(G_OBJECT(summaryview->ctree), G_CALLBACK(block_cb), block_data); } } } }
void messageview_clear(MessageView *messageview) { procmsg_msginfo_free(messageview->msginfo); messageview->msginfo = NULL; messageview_change_view_type(messageview, MVIEW_TEXT); headerview_clear(messageview->headerview); textview_clear(messageview->textview); mimeview_clear(messageview->mimeview); }
void procmsg_msg_list_free(GSList *mlist) { GSList *cur; MsgInfo *msginfo; for (cur = mlist; cur != NULL; cur = cur->next) { msginfo = (MsgInfo *)cur->data; procmsg_msginfo_free(msginfo); } g_slist_free(mlist); }
/*! *\brief Send messages in queue * *\param queue Queue folder to process *\param save_msgs Unused * *\return Number of messages sent, negative if an error occurred * positive if no error occurred */ gint procmsg_send_queue(FolderItem *queue, gboolean save_msgs) { gint sent = 0, err = 0; GSList *list, *elem; if (!queue) queue = folder_get_default_queue(); g_return_val_if_fail(queue != NULL, -1); folder_item_scan(queue); list = folder_item_get_msg_list(queue); for (elem = list; elem != NULL; elem = elem->next) { gchar *file; MsgInfo *msginfo; msginfo = (MsgInfo *)(elem->data); if (!MSG_IS_LOCKED(msginfo->flags)) { file = folder_item_fetch_msg(queue, msginfo->msgnum); if (file) { if (procmsg_send_message_queue(file) < 0) { g_warning("Sending queued message %d failed.\n", msginfo->msgnum); err++; } else { /* CLAWS: * We save in procmsg_send_message_queue because * we need the destination folder from the queue * header if (save_msgs) procmsg_save_to_outbox (queue->folder->outbox, file, TRUE); */ sent++; folder_item_remove_msg(queue, msginfo->msgnum); } g_free(file); } } /* FIXME: supposedly if only one message is locked, and queue * is being flushed, the following free says something like * "freeing msg ## in folder (nil)". */ procmsg_msginfo_free(msginfo); } return (err != 0 ? -err : sent); }
void procmsg_message_file_list_free(MsgInfoList *file_list) { GSList *cur; MsgFileInfo *fileinfo; for (cur = file_list; cur != NULL; cur = cur->next) { fileinfo = (MsgFileInfo *)cur->data; procmsg_msginfo_free(fileinfo->msginfo); g_free(fileinfo->file); g_free(fileinfo->flags); g_free(fileinfo); } g_slist_free(file_list); }
void procmsg_update_unread_children(MsgInfo *info, gboolean newly_marked) { GSList *children = procmsg_find_children(info); GSList *cur; for (cur = children; cur != NULL; cur = g_slist_next(cur)) { MsgInfo *tmp = (MsgInfo *)cur->data; if(MSG_IS_UNREAD(tmp->flags) && !MSG_IS_IGNORE_THREAD(tmp->flags)) { if(newly_marked) info->folder->unreadmarked_msgs++; else info->folder->unreadmarked_msgs--; folder_item_update(info->folder, F_ITEM_UPDATE_MSGCNT); } procmsg_msginfo_free(tmp); } g_slist_free(children); }
MsgInfo *procmsg_msginfo_get_full_info(MsgInfo *msginfo) { MsgInfo *full_msginfo; gchar *file; if (msginfo == NULL) return NULL; file = procmsg_get_message_file_path(msginfo); if (!file || !is_file_exist(file)) { g_free(file); file = procmsg_get_message_file(msginfo); } if (!file || !is_file_exist(file)) { g_warning("procmsg_msginfo_get_full_info(): can't get message file.\n"); return NULL; } full_msginfo = procheader_parse_file(file, msginfo->flags, TRUE, FALSE); g_free(file); if (!full_msginfo) return NULL; /* CLAWS: make sure we add the missing members; see: * procheader.c::procheader_get_headernames() */ if (!msginfo->xface) msginfo->xface = g_strdup(full_msginfo->xface); if (!msginfo->dispositionnotificationto) msginfo->dispositionnotificationto = g_strdup(full_msginfo->dispositionnotificationto); if (!msginfo->returnreceiptto) msginfo->returnreceiptto = g_strdup (full_msginfo->returnreceiptto); if (!msginfo->partial_recv && full_msginfo->partial_recv) msginfo->partial_recv = g_strdup (full_msginfo->partial_recv); msginfo->total_size = full_msginfo->total_size; if (!msginfo->account_server && full_msginfo->account_server) msginfo->account_server = g_strdup (full_msginfo->account_server); if (!msginfo->account_login && full_msginfo->account_login) msginfo->account_login = g_strdup (full_msginfo->account_login); msginfo->planned_download = full_msginfo->planned_download; procmsg_msginfo_free(full_msginfo); return procmsg_msginfo_new_ref(msginfo); }
GSList *procmsg_find_children (MsgInfo *info) { GSList *children; GSList *all, *cur; g_return_val_if_fail(info!=NULL, NULL); all = folder_item_get_msg_list(info->folder); children = procmsg_find_children_func(info, NULL, all); if (children != NULL) { for (cur = all; cur != NULL; cur = g_slist_next(cur)) { /* this will not free the used pointers created with procmsg_msginfo_new_ref */ procmsg_msginfo_free((MsgInfo *)cur->data); } } g_slist_free(all); return children; }
void msgcache_remove_msg(MsgCache *cache, guint msgnum) { MsgInfo *msginfo; g_return_if_fail(cache != NULL); g_return_if_fail(msgnum > 0); msginfo = (MsgInfo *) g_hash_table_lookup(cache->msgnum_table, &msgnum); if(!msginfo) return; cache->memusage -= procmsg_msginfo_memusage(msginfo); if(msginfo->msgid) g_hash_table_remove(cache->msgid_table, msginfo->msgid); g_hash_table_remove(cache->msgnum_table, &msginfo->msgnum); procmsg_msginfo_free(msginfo); cache->last_access = time(NULL); debug_print("Cache size: %d messages, %d byte\n", g_hash_table_size(cache->msgnum_table), cache->memusage); }
void messageview_destroy(MessageView *messageview) { GtkWidget *textview = GTK_WIDGET_PTR(messageview->mimeview->textview); GtkWidget *imageview = GTK_WIDGET_PTR(messageview->mimeview->imageview); messageview_list = g_list_remove(messageview_list, messageview); headerview_destroy(messageview->headerview); textview_destroy(messageview->textview); mimeview_destroy(messageview->mimeview); procmsg_msginfo_free(messageview->msginfo); if (messageview->window) gtk_widget_destroy(messageview->window); g_free(messageview); gtk_widget_unref(textview); gtk_widget_unref(imageview); }
void procmsg_empty_trash(FolderItem *trash) { FILE *fp; if (trash && trash->total_msgs > 0) { GSList *mlist = folder_item_get_msg_list(trash); GSList *cur; for (cur = mlist ; cur != NULL ; cur = cur->next) { MsgInfo * msginfo = (MsgInfo *) cur->data; if (MSG_IS_LOCKED(msginfo->flags)) continue; if (msginfo->total_size != 0 && msginfo->size != (off_t)msginfo->total_size) partial_mark_for_delete(msginfo); procmsg_msginfo_free(msginfo); } folder_item_remove_all_msg(trash); } }
static void mimeview_reply(MimeView *mimeview, guint action) { MimeInfo *partinfo; gchar *filename; MsgInfo *msginfo; MsgFlags flags = {0, 0}; ComposeMode mode = action; if (!mimeview->opened) return; if (!mimeview->messageview->file) return; partinfo = mimeview_get_selected_part(mimeview); g_return_if_fail(partinfo != NULL); if (partinfo->mime_type != MIME_MESSAGE_RFC822) return; filename = procmime_get_tmp_file_name(partinfo); if (procmime_get_part(filename, mimeview->messageview->file, partinfo) < 0) { alertpanel_error (_("Can't save the part of multipart message.")); g_free(filename); return; } msginfo = procheader_parse_file(filename, flags, TRUE); msginfo->file_path = filename; filename = NULL; if (prefs_common.reply_with_quote) mode |= COMPOSE_WITH_QUOTE; if (mimeview->messageview->mainwin) compose_reply(msginfo, mimeview->messageview->mainwin->summaryview->folder_item, mode, NULL); else compose_reply(msginfo, NULL, mode, NULL); g_unlink(msginfo->file_path); procmsg_msginfo_free(msginfo); }
gint messageview_show(MessageView *messageview, MsgInfo *msginfo, gboolean all_headers) { gchar *file; MimeInfo *mimeinfo; g_return_val_if_fail(msginfo != NULL, -1); mimeinfo = procmime_scan_message(msginfo); if (!mimeinfo) { messageview_change_view_type(messageview, MVIEW_TEXT); textview_show_error(messageview->textview); return -1; } file = procmsg_get_message_file_path(msginfo); if (!file) { g_warning("can't get message file path.\n"); procmime_mimeinfo_free_all(mimeinfo); messageview_change_view_type(messageview, MVIEW_TEXT); textview_show_error(messageview->textview); return -1; } if (messageview->msginfo != msginfo) { procmsg_msginfo_free(messageview->msginfo); messageview->msginfo = procmsg_msginfo_get_full_info(msginfo); if (!messageview->msginfo) messageview->msginfo = procmsg_msginfo_copy(msginfo); } if (messageview->window && msginfo->subject) { gchar *title; title = g_strconcat(msginfo->subject, " - Sylpheed", NULL); gtk_window_set_title(GTK_WINDOW(messageview->window), title); g_free(title); } headerview_show(messageview->headerview, messageview->msginfo); textview_set_all_headers(messageview->textview, all_headers); textview_set_all_headers(messageview->mimeview->textview, all_headers); if (mimeinfo->mime_type != MIME_TEXT && (prefs_common.html_only_as_attach || mimeinfo->mime_type != MIME_TEXT_HTML)) { messageview_change_view_type(messageview, MVIEW_MIME); mimeview_show_message(messageview->mimeview, mimeinfo, file); } else { messageview_change_view_type(messageview, MVIEW_TEXT); textview_show_message(messageview->textview, mimeinfo, file); procmime_mimeinfo_free_all(mimeinfo); } if (messageview->new_window) messageview_set_menu_state(messageview); g_free(file); return 0; }
static gboolean msgcache_msginfo_free_func(gpointer num, gpointer msginfo, gpointer user_data) { procmsg_msginfo_free((MsgInfo *)msginfo); return TRUE; }
gint procmsg_send_message_queue(const gchar *file) { static HeaderEntry qentry[] = {{"S:", NULL, FALSE}, {"SSV:", NULL, FALSE}, {"R:", NULL, FALSE}, {"NG:", NULL, FALSE}, {"MAID:", NULL, FALSE}, {"NAID:", NULL, FALSE}, {"SCF:", NULL, FALSE}, {"RMID:", NULL, FALSE}, {"FMID:", NULL, FALSE}, {"X-Sylpheed-Privacy-System:", NULL, FALSE}, {"X-Sylpheed-Encrypt:", NULL, FALSE}, {"X-Sylpheed-Encrypt-Data:", NULL, FALSE}, {NULL, NULL, FALSE}}; FILE *fp; gint filepos; gint mailval = 0, newsval = 0; gchar *from = NULL; gchar *smtpserver = NULL; GSList *to_list = NULL; GSList *newsgroup_list = NULL; gchar *savecopyfolder = NULL; gchar *replymessageid = NULL; gchar *fwdmessageid = NULL; gchar *privacy_system = NULL; gboolean encrypt = FALSE; gchar *encrypt_data = NULL; gchar buf[BUFFSIZE]; gint hnum; PrefsAccount *mailac = NULL, *newsac = NULL; gboolean save_clear_text = TRUE; gchar *tmp_enc_file = NULL; int local = 0; g_return_val_if_fail(file != NULL, -1); if ((fp = fopen(file, "rb")) == NULL) { FILE_OP_ERROR(file, "fopen"); return -1; } while ((hnum = procheader_get_one_field(buf, sizeof(buf), fp, qentry)) != -1) { gchar *p = buf + strlen(qentry[hnum].name); switch (hnum) { case Q_SENDER: if (from == NULL) from = g_strdup(p); break; case Q_SMTPSERVER: if (smtpserver == NULL) smtpserver = g_strdup(p); break; case Q_RECIPIENTS: to_list = address_list_append(to_list, p); break; case Q_NEWSGROUPS: newsgroup_list = newsgroup_list_append(newsgroup_list, p); break; case Q_MAIL_ACCOUNT_ID: mailac = account_find_from_id(atoi(p)); break; case Q_NEWS_ACCOUNT_ID: newsac = account_find_from_id(atoi(p)); break; case Q_SAVE_COPY_FOLDER: if (savecopyfolder == NULL) savecopyfolder = g_strdup(p); break; case Q_REPLY_MESSAGE_ID: if (replymessageid == NULL) replymessageid = g_strdup(p); break; case Q_FWD_MESSAGE_ID: if (fwdmessageid == NULL) fwdmessageid = g_strdup(p); break; case Q_PRIVACY_SYSTEM: if (privacy_system == NULL) privacy_system = g_strdup(p); break; case Q_ENCRYPT: if (p[0] == '1') encrypt = TRUE; break; case Q_ENCRYPT_DATA: if (encrypt_data == NULL) encrypt_data = g_strdup(p); break; } } filepos = ftell(fp); if (encrypt) { MimeInfo *mimeinfo; save_clear_text = (mailac != NULL && mailac->save_encrypted_as_clear_text); fclose(fp); fp = NULL; mimeinfo = procmime_scan_queue_file(file); if (!privacy_encrypt(privacy_system, mimeinfo, encrypt_data) || (fp = my_tmpfile()) == NULL || procmime_write_mimeinfo(mimeinfo, fp) < 0) { if (fp) fclose(fp); procmime_mimeinfo_free_all(mimeinfo); g_free(from); g_free(smtpserver); slist_free_strings(to_list); g_slist_free(to_list); slist_free_strings(newsgroup_list); g_slist_free(newsgroup_list); g_free(savecopyfolder); g_free(replymessageid); g_free(fwdmessageid); g_free(privacy_system); g_free(encrypt_data); return -1; } rewind(fp); if (!save_clear_text) { gchar *content = NULL; FILE *tmpfp = get_tmpfile_in_dir(get_mime_tmp_dir(), &tmp_enc_file); if (tmpfp) { fclose(tmpfp); content = file_read_stream_to_str(fp); rewind(fp); str_write_to_file(content, tmp_enc_file); g_free(content); } else { g_warning("couldn't get tempfile\n"); } } procmime_mimeinfo_free_all(mimeinfo); filepos = 0; } if (to_list) { debug_print("Sending message by mail\n"); if (!from) { g_warning("Queued message header is broken.\n"); mailval = -1; } else if (mailac && mailac->use_mail_command && mailac->mail_command && (* mailac->mail_command)) { mailval = send_message_local(mailac->mail_command, fp); local = 1; } else { if (!mailac) { mailac = account_find_from_smtp_server(from, smtpserver); if (!mailac) { g_warning("Account not found. " "Using current account...\n"); mailac = cur_account; } } if (mailac) mailval = send_message_smtp(mailac, to_list, fp); else { PrefsAccount tmp_ac; g_warning("Account not found.\n"); memset(&tmp_ac, 0, sizeof(PrefsAccount)); tmp_ac.address = from; tmp_ac.smtp_server = smtpserver; tmp_ac.smtpport = SMTP_PORT; mailval = send_message_smtp(&tmp_ac, to_list, fp); } } } fseek(fp, filepos, SEEK_SET); if (newsgroup_list && (mailval == 0)) { Folder *folder; gchar *tmp = NULL; FILE *tmpfp; /* write to temporary file */ tmp = g_strdup_printf("%s%ctmp%d", g_get_tmp_dir(), G_DIR_SEPARATOR, (gint)file); if ((tmpfp = fopen(tmp, "wb")) == NULL) { FILE_OP_ERROR(tmp, "fopen"); newsval = -1; alertpanel_error(_("Could not create temporary file for news sending.")); } else { if (change_file_mode_rw(tmpfp, tmp) < 0) { FILE_OP_ERROR(tmp, "chmod"); g_warning("can't change file mode\n"); } while ((newsval == 0) && fgets(buf, sizeof(buf), fp) != NULL) { if (fputs(buf, tmpfp) == EOF) { FILE_OP_ERROR(tmp, "fputs"); newsval = -1; alertpanel_error(_("Error when writing temporary file for news sending.")); } } fclose(tmpfp); if (newsval == 0) { debug_print("Sending message by news\n"); folder = FOLDER(newsac->folder); newsval = news_post(folder, tmp); if (newsval < 0) { alertpanel_error(_("Error occurred while posting the message to %s ."), newsac->nntp_server); } } unlink(tmp); } g_free(tmp); } fclose(fp); /* save message to outbox */ if (mailval == 0 && newsval == 0 && savecopyfolder) { FolderItem *outbox; debug_print("saving sent message...\n"); outbox = folder_find_item_from_identifier(savecopyfolder); if (!outbox) outbox = folder_get_default_outbox(); if (save_clear_text || tmp_enc_file == NULL) { procmsg_save_to_outbox(outbox, file, TRUE); } else { procmsg_save_to_outbox(outbox, tmp_enc_file, FALSE); } } if (tmp_enc_file != NULL) { unlink(tmp_enc_file); free(tmp_enc_file); tmp_enc_file = NULL; } if (replymessageid != NULL || fwdmessageid != NULL) { gchar **tokens; FolderItem *item; if (replymessageid != NULL) tokens = g_strsplit(replymessageid, "\x7f", 0); else tokens = g_strsplit(fwdmessageid, "\x7f", 0); item = folder_find_item_from_identifier(tokens[0]); /* check if queued message has valid folder and message id */ if (item != NULL && tokens[2] != NULL) { MsgInfo *msginfo; msginfo = folder_item_get_msginfo(item, atoi(tokens[1])); /* check if referring message exists and has a message id */ if ((msginfo != NULL) && (msginfo->msgid != NULL) && (strcmp(msginfo->msgid, tokens[2]) != 0)) { procmsg_msginfo_free(msginfo); msginfo = NULL; } if (msginfo == NULL) { msginfo = folder_item_get_msginfo_by_msgid(item, tokens[2]); } if (msginfo != NULL) { if (replymessageid != NULL) { procmsg_msginfo_unset_flags(msginfo, MSG_FORWARDED, 0); procmsg_msginfo_set_flags(msginfo, MSG_REPLIED, 0); } else { procmsg_msginfo_unset_flags(msginfo, MSG_REPLIED, 0); procmsg_msginfo_set_flags(msginfo, MSG_FORWARDED, 0); } procmsg_msginfo_free(msginfo); } } g_strfreev(tokens); } g_free(from); g_free(smtpserver); slist_free_strings(to_list); g_slist_free(to_list); slist_free_strings(newsgroup_list); g_slist_free(newsgroup_list); g_free(savecopyfolder); g_free(replymessageid); g_free(fwdmessageid); g_free(privacy_system); g_free(encrypt_data); return (newsval != 0 ? newsval : mailval); }
static gint inc_start(IncProgressDialog *inc_dialog) { IncSession *session; GList *qlist; Pop3Session *pop3_session; IncState inc_state; gint error_num = 0; gint new_msgs = 0; gchar *msg; gchar *fin_msg; FolderItem *processing, *inbox; GSList *msglist, *msglist_element; gboolean cancelled = FALSE; qlist = inc_dialog->queue_list; while (qlist != NULL) { GList *next = qlist->next; session = qlist->data; pop3_session = POP3_SESSION(session->session); pop3_session->user = g_strdup(pop3_session->ac_prefs->userid); if (pop3_session->ac_prefs->passwd) pop3_session->pass = g_strdup(pop3_session->ac_prefs->passwd); else { gchar *pass; if (inc_dialog->show_dialog) manage_window_focus_in (inc_dialog->dialog->window, NULL, NULL); pass = input_dialog_query_password_keep (pop3_session->ac_prefs->recv_server, pop3_session->user, &(pop3_session->ac_prefs->session_passwd)); if (inc_dialog->show_dialog) manage_window_focus_out (inc_dialog->dialog->window, NULL, NULL); if (pass) { pop3_session->pass = pass; } } qlist = next; } #define SET_PIXMAP_AND_TEXT(pix, str) \ { \ progress_dialog_list_set(inc_dialog->dialog, \ inc_dialog->cur_row, \ pix, \ NULL, \ str); \ } for (; inc_dialog->queue_list != NULL && !cancelled; inc_dialog->cur_row++) { session = inc_dialog->queue_list->data; pop3_session = POP3_SESSION(session->session); GSList *filtered, *unfiltered; if (pop3_session->pass == NULL) { SET_PIXMAP_AND_TEXT(okpix, _("Cancelled")); inc_session_destroy(session); inc_dialog->queue_list = g_list_remove(inc_dialog->queue_list, session); continue; } inc_progress_dialog_clear(inc_dialog); progress_dialog_scroll_to_row(inc_dialog->dialog, inc_dialog->cur_row); SET_PIXMAP_AND_TEXT(currentpix, _("Retrieving")); /* begin POP3 session */ inc_state = inc_pop3_session_do(session); switch (inc_state) { case INC_SUCCESS: if (pop3_session->cur_total_num > 0) msg = g_strdup_printf( ngettext("Done (%d message (%s) received)", "Done (%d messages (%s) received)", pop3_session->cur_total_num), pop3_session->cur_total_num, to_human_readable((goffset)pop3_session->cur_total_recv_bytes)); else msg = g_strdup_printf(_("Done (no new messages)")); SET_PIXMAP_AND_TEXT(okpix, msg); g_free(msg); break; case INC_CONNECT_ERROR: SET_PIXMAP_AND_TEXT(errorpix, _("Connection failed")); break; case INC_AUTH_FAILED: SET_PIXMAP_AND_TEXT(errorpix, _("Auth failed")); if (pop3_session->ac_prefs->session_passwd) { g_free(pop3_session->ac_prefs->session_passwd); pop3_session->ac_prefs->session_passwd = NULL; } break; case INC_LOCKED: SET_PIXMAP_AND_TEXT(errorpix, _("Locked")); break; case INC_ERROR: case INC_NO_SPACE: case INC_IO_ERROR: case INC_SOCKET_ERROR: case INC_EOF: SET_PIXMAP_AND_TEXT(errorpix, _("Error")); break; case INC_TIMEOUT: SET_PIXMAP_AND_TEXT(errorpix, _("Timeout")); break; case INC_CANCEL: SET_PIXMAP_AND_TEXT(okpix, _("Cancelled")); if (!inc_dialog->show_dialog) cancelled = TRUE; break; default: break; } if (pop3_session->error_val == PS_AUTHFAIL) { if(!prefs_common.no_recv_err_panel) { if((prefs_common.recv_dialog_mode == RECV_DIALOG_ALWAYS) || ((prefs_common.recv_dialog_mode == RECV_DIALOG_MANUAL) && focus_window)) manage_window_focus_in(inc_dialog->dialog->window, NULL, NULL); } } /* CLAWS: perform filtering actions on dropped message */ /* CLAWS: get default inbox (perhaps per account) */ if (pop3_session->ac_prefs->inbox) { /* CLAWS: get destination folder / mailbox */ inbox = folder_find_item_from_identifier(pop3_session->ac_prefs->inbox); if (!inbox) inbox = folder_get_default_inbox(); } else inbox = folder_get_default_inbox(); /* get list of messages in processing */ processing = folder_get_default_processing(); folder_item_scan(processing); msglist = folder_item_get_msg_list(processing); /* process messages */ folder_item_update_freeze(); procmsg_msglist_filter(msglist, pop3_session->ac_prefs, &filtered, &unfiltered, pop3_session->ac_prefs->filter_on_recv); filtering_move_and_copy_msgs(msglist); if (unfiltered != NULL) folder_item_move_msgs(inbox, unfiltered); for(msglist_element = msglist; msglist_element != NULL; msglist_element = msglist_element->next) { MsgInfo *msginfo = (MsgInfo *)msglist_element->data; procmsg_msginfo_free(msginfo); } folder_item_update_thaw(); g_slist_free(msglist); g_slist_free(filtered); g_slist_free(unfiltered); statusbar_pop_all(); new_msgs += pop3_session->cur_total_num; pop3_write_uidl_list(pop3_session); if (inc_state != INC_SUCCESS && inc_state != INC_CANCEL) { error_num++; if (inc_dialog->show_dialog) manage_window_focus_in (inc_dialog->dialog->window, NULL, NULL); inc_put_error(inc_state, pop3_session); if (inc_dialog->show_dialog) manage_window_focus_out (inc_dialog->dialog->window, NULL, NULL); if (inc_state == INC_NO_SPACE || inc_state == INC_IO_ERROR) break; } folder_item_free_cache(processing, TRUE); inc_session_destroy(session); inc_dialog->queue_list = g_list_remove(inc_dialog->queue_list, session); } #undef SET_PIXMAP_AND_TEXT if (new_msgs > 0) fin_msg = g_strdup_printf(ngettext("Finished (%d new message)", "Finished (%d new messages)", new_msgs), new_msgs); else fin_msg = g_strdup_printf(_("Finished (no new messages)")); progress_dialog_set_label(inc_dialog->dialog, fin_msg); while (inc_dialog->queue_list != NULL) { session = inc_dialog->queue_list->data; inc_session_destroy(session); inc_dialog->queue_list = g_list_remove(inc_dialog->queue_list, session); } if (prefs_common.close_recv_dialog || !inc_dialog->show_dialog) inc_progress_dialog_destroy(inc_dialog); else { gtk_window_set_title(GTK_WINDOW(inc_dialog->dialog->window), fin_msg); gtk_button_set_label(GTK_BUTTON(inc_dialog->dialog->cancel_btn), GTK_STOCK_CLOSE); } g_free(fin_msg); return new_msgs; }
gint proc_mbox(FolderItem *dest, const gchar *mbox, gboolean apply_filter, PrefsAccount *account) /* return values: -1 error, >=0 number of msgs added */ { FILE *mbox_fp; gchar buf[MESSAGEBUFSIZE]; gchar *tmp_file; gint msgs = 0; gint lines; MsgInfo *msginfo; gboolean more; GSList *to_filter = NULL, *filtered = NULL, *unfiltered = NULL, *cur, *to_add = NULL; gboolean printed = FALSE; FolderItem *dropfolder; cm_return_val_if_fail(dest != NULL, -1); cm_return_val_if_fail(mbox != NULL, -1); debug_print("Getting messages from %s into %s...\n", mbox, dest->path); if ((mbox_fp = g_fopen(mbox, "rb")) == NULL) { FILE_OP_ERROR(mbox, "fopen"); alertpanel_error(_("Could not open mbox file:\n%s\n"), mbox); return -1; } /* ignore empty lines on the head */ do { if (fgets(buf, sizeof(buf), mbox_fp) == NULL) { g_warning("can't read mbox file.\n"); fclose(mbox_fp); return -1; } } while (buf[0] == '\n' || buf[0] == '\r'); if (strncmp(buf, "From ", 5) != 0) { g_warning("invalid mbox format: %s\n", mbox); fclose(mbox_fp); return -1; } tmp_file = get_tmp_file(); folder_item_update_freeze(); if (apply_filter) dropfolder = folder_get_default_processing(); else dropfolder = dest; do { FILE *tmp_fp; gint empty_lines; gint msgnum; if (msgs > 0 && msgs%500 == 0) { if (printed) statusbar_pop_all(); statusbar_print_all( ngettext("Importing from mbox... (%d mail imported)", "Importing from mbox... (%d mails imported)", msgs), msgs); printed=TRUE; GTK_EVENTS_FLUSH(); } if ((tmp_fp = g_fopen(tmp_file, "wb")) == NULL) { FILE_OP_ERROR(tmp_file, "fopen"); g_warning("can't open temporary file\n"); fclose(mbox_fp); g_free(tmp_file); return -1; } if (change_file_mode_rw(tmp_fp, tmp_file) < 0) { FILE_OP_ERROR(tmp_file, "chmod"); } empty_lines = 0; lines = 0; /* process all lines from mboxrc file */ while (fgets(buf, sizeof(buf), mbox_fp) != NULL) { int offset; /* eat empty lines */ if (buf[0] == '\n' || buf[0] == '\r') { empty_lines++; continue; } /* From separator or quoted From */ offset = 0; /* detect leading '>' char(s) */ while ((buf[offset] == '>')) { offset++; } if (!strncmp(buf+offset, "From ", 5)) { /* From separator: */ if (offset == 0) { /* expect next mbox item */ break; } /* quoted From: */ /* flush any eaten empty line */ if (empty_lines > 0) { while (empty_lines-- > 0) { FPUTS_TO_TMP_ABORT_IF_FAIL("\n"); } empty_lines = 0; } /* store the unquoted line */ FPUTS_TO_TMP_ABORT_IF_FAIL(buf + 1); continue; } /* other line */ /* flush any eaten empty line */ if (empty_lines > 0) { while (empty_lines-- > 0) { FPUTS_TO_TMP_ABORT_IF_FAIL("\n"); } empty_lines = 0; } /* store the line itself */ FPUTS_TO_TMP_ABORT_IF_FAIL(buf); } /* end of mbox item or end of mbox */ /* flush any eaten empty line (but the last one) */ if (empty_lines > 0) { while (--empty_lines > 0) { FPUTS_TO_TMP_ABORT_IF_FAIL("\n"); } } /* more emails to expect? */ more = !feof(mbox_fp); /* warn if email part is empty (it's the minimum check we can do */ if (lines == 0) { g_warning("malformed mbox: %s: message %d is empty\n", mbox, msgs); fclose(tmp_fp); fclose(mbox_fp); claws_unlink(tmp_file); return -1; } if (fclose(tmp_fp) == EOF) { FILE_OP_ERROR(tmp_file, "fclose"); g_warning("can't write to temporary file\n"); fclose(mbox_fp); claws_unlink(tmp_file); g_free(tmp_file); return -1; } if (apply_filter) { if ((msgnum = folder_item_add_msg(dropfolder, tmp_file, NULL, TRUE)) < 0) { fclose(mbox_fp); claws_unlink(tmp_file); g_free(tmp_file); return -1; } msginfo = folder_item_get_msginfo(dropfolder, msgnum); to_filter = g_slist_prepend(to_filter, msginfo); } else { MsgFileInfo *finfo = g_new0(MsgFileInfo, 1); finfo->file = tmp_file; to_add = g_slist_prepend(to_add, finfo); tmp_file = get_tmp_file(); /* flush every 500 */ if (msgs > 0 && msgs % 500 == 0) { folder_item_add_msgs(dropfolder, to_add, TRUE); procmsg_message_file_list_free(to_add); to_add = NULL; } } msgs++; } while (more); if (printed) statusbar_pop_all(); if (apply_filter) { folder_item_set_batch(dropfolder, FALSE); procmsg_msglist_filter(to_filter, account, &filtered, &unfiltered, TRUE); folder_item_set_batch(dropfolder, TRUE); filtering_move_and_copy_msgs(to_filter); for (cur = filtered; cur; cur = g_slist_next(cur)) { MsgInfo *info = (MsgInfo *)cur->data; procmsg_msginfo_free(info); } unfiltered = g_slist_reverse(unfiltered); if (unfiltered) { folder_item_move_msgs(dest, unfiltered); for (cur = unfiltered; cur; cur = g_slist_next(cur)) { MsgInfo *info = (MsgInfo *)cur->data; procmsg_msginfo_free(info); } } g_slist_free(unfiltered); g_slist_free(filtered); g_slist_free(to_filter); } else if (to_add) { folder_item_add_msgs(dropfolder, to_add, TRUE); procmsg_message_file_list_free(to_add); to_add = NULL; } folder_item_update_thaw(); g_free(tmp_file); fclose(mbox_fp); debug_print("%d messages found.\n", msgs); return msgs; }
gint send_message_smtp_full(PrefsAccount *ac_prefs, GSList *to_list, FILE *fp, gboolean keep_session) { Session *session; SMTPSession *smtp_session; gushort port = 0; gchar buf[BUFFSIZE]; gint ret = 0; gboolean was_inited = FALSE; MsgInfo *tmp_msginfo = NULL; MsgFlags flags = {0, 0}; long fp_pos = 0; gchar spec_from[BUFFSIZE]; ProxyInfo *proxy_info = NULL; cm_return_val_if_fail(ac_prefs != NULL, -1); cm_return_val_if_fail(ac_prefs->address != NULL, -1); cm_return_val_if_fail(ac_prefs->smtp_server != NULL, -1); cm_return_val_if_fail(to_list != NULL, -1); cm_return_val_if_fail(fp != NULL, -1); /* get the From address used, not necessarily the ac_prefs', * because it's editable. */ fp_pos = ftell(fp); if (fp_pos < 0) { perror("ftell"); return -1; } tmp_msginfo = procheader_parse_stream(fp, flags, TRUE, FALSE); if (fseek(fp, fp_pos, SEEK_SET) < 0) { perror("fseek"); return -1; } if (tmp_msginfo && tmp_msginfo->extradata && tmp_msginfo->extradata->resent_from) { strncpy2(spec_from, tmp_msginfo->extradata->resent_from, BUFFSIZE-1); extract_address(spec_from); } else if (tmp_msginfo && tmp_msginfo->from) { strncpy2(spec_from, tmp_msginfo->from, BUFFSIZE-1); extract_address(spec_from); } else { strncpy2(spec_from, ac_prefs->address, BUFFSIZE-1); } if (tmp_msginfo) { procmsg_msginfo_free(&tmp_msginfo); } if (!ac_prefs->session) { /* we can't reuse a previously initialised session */ session = smtp_session_new(ac_prefs); session->ssl_cert_auto_accept = ac_prefs->ssl_certs_auto_accept; smtp_session = SMTP_SESSION(session); if (ac_prefs->set_domain && ac_prefs->domain && strlen(ac_prefs->domain)) { smtp_session->hostname = g_strdup(ac_prefs->domain); } else { smtp_session->hostname = NULL; } #ifdef USE_GNUTLS port = ac_prefs->set_smtpport ? ac_prefs->smtpport : ac_prefs->ssl_smtp == SSL_TUNNEL ? SSMTP_PORT : SMTP_PORT; session->ssl_type = ac_prefs->ssl_smtp; if (ac_prefs->ssl_smtp != SSL_NONE) session->nonblocking = ac_prefs->use_nonblocking_ssl; if (ac_prefs->set_gnutls_priority && ac_prefs->gnutls_priority && strlen(ac_prefs->gnutls_priority)) session->gnutls_priority = g_strdup(ac_prefs->gnutls_priority); session->use_tls_sni = ac_prefs->use_tls_sni; #else if (ac_prefs->ssl_smtp != SSL_NONE) { if (alertpanel_full(_("Insecure connection"), _("This connection is configured to be secured " "using SSL/TLS, but SSL/TLS is not available " "in this build of Claws Mail. \n\n" "Do you want to continue connecting to this " "server? The communication would not be " "secure."), GTK_STOCK_CANCEL, _("Con_tinue connecting"), NULL, ALERTFOCUS_FIRST, FALSE, NULL, ALERT_WARNING) != G_ALERTALTERNATE) { session_destroy(session); return -1; } } port = ac_prefs->set_smtpport ? ac_prefs->smtpport : SMTP_PORT; #endif if (ac_prefs->use_smtp_auth) { smtp_session->forced_auth_type = ac_prefs->smtp_auth_type; if (ac_prefs->smtp_userid && strlen(ac_prefs->smtp_userid)) { smtp_session->user = g_strdup(ac_prefs->smtp_userid); if (password_get(smtp_session->user, ac_prefs->smtp_server, "smtp", port, &(smtp_session->pass))) { /* NOP */; } else if ((smtp_session->pass = passwd_store_get_account(ac_prefs->account_id, PWS_ACCOUNT_SEND)) == NULL) { smtp_session->pass = input_dialog_query_password_keep (ac_prefs->smtp_server, smtp_session->user, &(ac_prefs->session_smtp_passwd)); if (!smtp_session->pass) { session_destroy(session); return -1; } } } else { smtp_session->user = g_strdup(ac_prefs->userid); if (password_get(smtp_session->user, ac_prefs->smtp_server, "smtp", port, &(smtp_session->pass))) { /* NOP */; } else if ((smtp_session->pass = passwd_store_get_account( ac_prefs->account_id, PWS_ACCOUNT_RECV)) == NULL) { smtp_session->pass = input_dialog_query_password_keep (ac_prefs->smtp_server, smtp_session->user, &(ac_prefs->session_smtp_passwd)); if (!smtp_session->pass) { session_destroy(session); return -1; } } } } else { smtp_session->user = NULL; smtp_session->pass = NULL; } send_dialog = send_progress_dialog_create(); send_dialog->session = session; smtp_session->dialog = send_dialog; progress_dialog_list_set(send_dialog->dialog, 0, NULL, ac_prefs->smtp_server, _("Connecting")); if (ac_prefs->pop_before_smtp && (ac_prefs->protocol == A_POP3) && (time(NULL) - ac_prefs->last_pop_login_time) > (60 * ac_prefs->pop_before_smtp_timeout)) { g_snprintf(buf, sizeof(buf), _("Doing POP before SMTP...")); log_message(LOG_PROTOCOL, "%s\n", buf); progress_dialog_set_label(send_dialog->dialog, buf); progress_dialog_list_set_status(send_dialog->dialog, 0, _("POP before SMTP")); GTK_EVENTS_FLUSH(); inc_pop_before_smtp(ac_prefs); } g_snprintf(buf, sizeof(buf), _("Account '%s': Connecting to SMTP server: %s:%d..."), ac_prefs->account_name, ac_prefs->smtp_server, port); progress_dialog_set_label(send_dialog->dialog, buf); log_message(LOG_PROTOCOL, "%s\n", buf); session_set_recv_message_notify(session, send_recv_message, send_dialog); session_set_send_data_progressive_notify (session, send_send_data_progressive, send_dialog); session_set_send_data_notify(session, send_send_data_finished, send_dialog); } else { /* everything is ready to start at MAIL FROM:, just * reinit useful variables. */ session = SESSION(ac_prefs->session); ac_prefs->session = NULL; smtp_session = SMTP_SESSION(session); smtp_session->state = SMTP_HELO; send_dialog = (SendProgressDialog *)smtp_session->dialog; was_inited = TRUE; } /* This has to be initialised for every mail sent */ smtp_session->from = g_strdup(spec_from); smtp_session->to_list = to_list; smtp_session->cur_to = to_list; smtp_session->send_data = (guchar *)get_outgoing_rfc2822_str(fp); smtp_session->send_data_len = strlen((gchar *)smtp_session->send_data); if (ac_prefs->use_proxy && ac_prefs->use_proxy_for_send) { if (ac_prefs->use_default_proxy) { proxy_info = (ProxyInfo *)&(prefs_common.proxy_info); if (proxy_info->use_proxy_auth) proxy_info->proxy_pass = passwd_store_get(PWS_CORE, PWS_CORE_PROXY, PWS_CORE_PROXY_PASS); } else { proxy_info = (ProxyInfo *)&(ac_prefs->proxy_info); if (proxy_info->use_proxy_auth) proxy_info->proxy_pass = passwd_store_get_account(ac_prefs->account_id, PWS_ACCOUNT_PROXY_PASS); } } SESSION(smtp_session)->proxy_info = proxy_info; session_set_timeout(session, prefs_common.io_timeout_secs * 1000); /* connect if necessary */ if (!was_inited && session_connect(session, ac_prefs->smtp_server, port) < 0) { session_destroy(session); send_progress_dialog_destroy(send_dialog); ac_prefs->session = NULL; return -1; } debug_print("send_message_smtp(): begin event loop\n"); if (was_inited) { /* as the server is quiet, start sending ourselves */ smtp_from(smtp_session); } while (session_is_running(session) && send_dialog->cancelled == FALSE && SMTP_SESSION(session)->state != SMTP_MAIL_SENT_OK) gtk_main_iteration(); if (SMTP_SESSION(session)->error_val == SM_AUTHFAIL) { if (ac_prefs->session_smtp_passwd) { g_free(ac_prefs->session_smtp_passwd); ac_prefs->session_smtp_passwd = NULL; } ret = -1; } else if (SMTP_SESSION(session)->state == SMTP_MAIL_SENT_OK) { log_message(LOG_PROTOCOL, "%s\n", _("Mail sent successfully.")); ret = 0; } else if (session->state == SESSION_EOF && SMTP_SESSION(session)->state == SMTP_QUIT) { /* consider EOF right after QUIT successful */ log_warning(LOG_PROTOCOL, "%s\n", _("Connection closed by the remote host.")); ret = 0; } else if (session->state == SESSION_ERROR || session->state == SESSION_EOF || session->state == SESSION_TIMEOUT || SMTP_SESSION(session)->state == SMTP_ERROR || SMTP_SESSION(session)->error_val != SM_OK) ret = -1; else if (send_dialog->cancelled == TRUE) ret = -1; if (ret == -1) { manage_window_focus_in(send_dialog->dialog->window, NULL, NULL); send_put_error(session); manage_window_focus_out(send_dialog->dialog->window, NULL, NULL); } /* if we should close the connection, let's do it. * Close it in case of error, too, as it helps reinitializing things * easier. */ if (!keep_session || ret != 0) { if (session_is_connected(session)) smtp_quit(smtp_session); while (session_is_connected(session) && !send_dialog->cancelled) gtk_main_iteration(); session_destroy(session); ac_prefs->session = NULL; send_progress_dialog_destroy(send_dialog); } else { g_free(smtp_session->from); g_free(smtp_session->send_data); g_free(smtp_session->error_msg); } if (keep_session && ret == 0 && ac_prefs->session == NULL) ac_prefs->session = SMTP_SESSION(session); statusbar_pop_all(); statusbar_verbosity_set(FALSE); return ret; }
static FolderItem *mh_create_folder(Folder *folder, FolderItem *parent, const gchar *name) { gchar *path, *real_name; gchar *fullpath; FolderItem *new_item; gchar *mh_sequences_filename; FILE *mh_sequences_file; cm_return_val_if_fail(folder != NULL, NULL); cm_return_val_if_fail(parent != NULL, NULL); cm_return_val_if_fail(name != NULL, NULL); path = folder_item_get_path(parent); if (!is_dir_exist(path)) if (make_dir_hier(path) != 0) return NULL; real_name = mh_filename_from_utf8(name); fullpath = g_strconcat(path, G_DIR_SEPARATOR_S, real_name, NULL); g_free(real_name); g_free(path); if (to_number(name) > 0) { MsgInfo *info = folder_item_get_msginfo(parent, to_number(name)); if (info != NULL) { gboolean ok = mh_renumber_msg(info); procmsg_msginfo_free(info); if (!ok) { g_free(fullpath); return NULL; } } } if (make_dir(fullpath) < 0) { g_free(fullpath); return NULL; } g_free(fullpath); if (parent->path) path = g_strconcat(parent->path, G_DIR_SEPARATOR_S, name, NULL); else path = g_strdup(name); new_item = folder_item_new(folder, name, path); folder_item_append(parent, new_item); g_free(path); path = folder_item_get_path(new_item); mh_sequences_filename = g_strconcat(path, G_DIR_SEPARATOR_S, ".mh_sequences", NULL); if ((mh_sequences_file = g_fopen(mh_sequences_filename, "a+b")) != NULL) { fclose(mh_sequences_file); } g_free(mh_sequences_filename); g_free(path); return new_item; }
static int partial_uidl_mark_mail(MsgInfo *msginfo, int download) { gchar *path; gchar *pathnew; FILE *fp; FILE *fpnew; gchar buf[POPBUFSIZE]; gchar uidl[POPBUFSIZE]; time_t recv_time; time_t now; gchar partial_recv[POPBUFSIZE]; int err = -1; gchar *filename; MsgInfo *tinfo; gchar *sanitized_uid = NULL; filename = procmsg_get_message_file_path(msginfo); if (!filename) { g_warning("can't get message file path."); return err; } tinfo = procheader_parse_file(filename, msginfo->flags, TRUE, TRUE); if (!tinfo->extradata) { g_free(filename); return err; } sanitized_uid = g_strdup(tinfo->extradata->account_login); subst_for_filename(sanitized_uid); if (!tinfo->extradata->account_server || !tinfo->extradata->account_login || !tinfo->extradata->partial_recv) { goto bail; } path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "uidl", G_DIR_SEPARATOR_S, tinfo->extradata->account_server, "-", sanitized_uid, NULL); if ((fp = g_fopen(path, "rb")) == NULL) { perror("fopen1"); if (ENOENT != errno) FILE_OP_ERROR(path, "fopen"); g_free(path); path = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "uidl-", tinfo->extradata->account_server, "-", tinfo->extradata->account_login, NULL); if ((fp = g_fopen(path, "rb")) == NULL) { if (ENOENT != errno) FILE_OP_ERROR(path, "fopen"); g_free(path); goto bail; } } pathnew = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S, "uidl", G_DIR_SEPARATOR_S, tinfo->extradata->account_server, "-", sanitized_uid, ".new", NULL); g_free(sanitized_uid); if ((fpnew = g_fopen(pathnew, "wb")) == NULL) { perror("fopen2"); fclose(fp); g_free(pathnew); goto bail; } now = time(NULL); while (fgets(buf, sizeof(buf), fp) != NULL) { strretchomp(buf); recv_time = RECV_TIME_NONE; sprintf(partial_recv,"0"); if (sscanf(buf, "%s\t%ld\t%s", uidl, (long int *) &recv_time, partial_recv) < 2) { if (sscanf(buf, "%s", uidl) != 1) continue; else { recv_time = now; } } if (strcmp(tinfo->extradata->partial_recv, uidl)) { if (fprintf(fpnew, "%s\t%ld\t%s\n", uidl, (long int) recv_time, partial_recv) < 0) { FILE_OP_ERROR(pathnew, "fprintf"); fclose(fpnew); fclose(fp); g_free(path); g_free(pathnew); goto bail; } } else { gchar *stat = NULL; if (download == POP3_PARTIAL_DLOAD_DLOAD) { gchar *folder_id = folder_item_get_identifier( msginfo->folder); stat = g_strdup_printf("%s:%d", folder_id, msginfo->msgnum); g_free(folder_id); } else if (download == POP3_PARTIAL_DLOAD_UNKN) stat = g_strdup("1"); else if (download == POP3_PARTIAL_DLOAD_DELE) stat = g_strdup("0"); if (fprintf(fpnew, "%s\t%ld\t%s\n", uidl, (long int) recv_time, stat) < 0) { FILE_OP_ERROR(pathnew, "fprintf"); fclose(fpnew); fclose(fp); g_free(path); g_free(pathnew); goto bail; } g_free(stat); } } if (fclose(fpnew) == EOF) { FILE_OP_ERROR(pathnew, "fclose"); fclose(fp); g_free(path); g_free(pathnew); goto bail; } fclose(fp); move_file(pathnew, path, TRUE); g_free(path); g_free(pathnew); if ((fp = g_fopen(filename,"rb")) == NULL) { perror("fopen3"); goto bail; } pathnew = g_strdup_printf("%s.new", filename); if ((fpnew = g_fopen(pathnew, "wb")) == NULL) { perror("fopen4"); fclose(fp); g_free(pathnew); goto bail; } if (fprintf(fpnew, "SC-Marked-For-Download: %d\n", download) < 0) { FILE_OP_ERROR(pathnew, "fprintf"); fclose(fpnew); fclose(fp); g_free(pathnew); goto bail; } while (fgets(buf, sizeof(buf)-1, fp) != NULL) { if(strlen(buf) > strlen("SC-Marked-For-Download: x\n") && !strncmp(buf, "SC-Marked-For-Download:", strlen("SC-Marked-For-Download:"))) { if (fprintf(fpnew, "%s", buf+strlen("SC-Marked-For-Download: x\n")) < 0) { FILE_OP_ERROR(pathnew, "fprintf"); fclose(fpnew); fclose(fp); g_free(pathnew); goto bail; } continue; } else if (strlen(buf) == strlen("SC-Marked-For-Download: x\n") && !strncmp(buf, "SC-Marked-For-Download:", strlen("SC-Marked-For-Download:"))) { continue; } if (fprintf(fpnew, "%s", buf) < 0) { FILE_OP_ERROR(pathnew, "fprintf"); fclose(fpnew); fclose(fp); g_free(pathnew); goto bail; } } if (fclose(fpnew) == EOF) { FILE_OP_ERROR(pathnew, "fclose"); fclose(fp); g_free(pathnew); goto bail; } fclose(fp); if (rename_force(pathnew, filename) != 0) { g_free(pathnew); goto bail; } g_free(pathnew); msginfo->planned_download = download; msgcache_update_msg(msginfo->folder->cache, msginfo); err = 0; bail: g_free(filename); procmsg_msginfo_free(&tinfo); return err; }