static void ssl_manager_delete_cb(GtkWidget *widget,
gpointer data)
{
SSLCertificate *cert;
int val;
GtkTreeIter iter;
GtkTreeModel *model;
cert = gtkut_tree_view_get_selected_pointer(
GTK_TREE_VIEW(manager.certlist), SSL_MANAGER_CERT,
&model, NULL, &iter);
if (!cert)
return;
val = alertpanel_full(_("Delete certificate"),
_("Do you really want to delete this certificate?"),
GTK_STOCK_CANCEL, GTK_STOCK_DELETE, NULL, ALERTFOCUS_FIRST,
FALSE, NULL, ALERT_WARNING);
if (val != G_ALERTALTERNATE)
return;
ssl_certificate_delete_from_disk(cert);
ssl_certificate_destroy(cert);
gtk_list_store_remove(GTK_LIST_STORE(model), &iter);
}
static void ssl_manager_delete_cb(GtkWidget *widget,
gpointer data)
{
SSLCertificate *cert;
int val;
GtkTreeIter sel;
GtkTreeModel *model;
if (!gtk_tree_selection_get_selected(gtk_tree_view_get_selection
(GTK_TREE_VIEW(manager.certlist)),
&model, &sel))
return;
gtk_tree_model_get(model, &sel,
SSL_MANAGER_CERT, &cert,
-1);
if (!cert)
return;
val = alertpanel_full(_("Delete certificate"),
_("Do you really want to delete this certificate?"),
GTK_STOCK_CANCEL, GTK_STOCK_DELETE, NULL, FALSE,
NULL, ALERT_WARNING, G_ALERTDEFAULT);
if (val != G_ALERTALTERNATE)
return;
ssl_certificate_delete_from_disk(cert);
ssl_certificate_destroy(cert);
gtk_list_store_remove(GTK_LIST_STORE(model), &sel);
}
AlertValue alertpanel(const gchar *title,
const gchar *message,
const gchar *button1_label,
const gchar *button2_label,
const gchar *button3_label,
AlertFocus focus)
{
return alertpanel_full(title, message, button1_label, button2_label,
button3_label, focus, FALSE, NULL, ALERT_QUESTION);
}
AlertValue alertpanel(const gchar *title,
const gchar *message,
const gchar *button1_label,
const gchar *button2_label,
const gchar *button3_label)
{
return alertpanel_full(title, message, ALERT_QUESTION, G_ALERTDEFAULT,
FALSE,
button1_label, button2_label, button3_label);
}
void sslcertwindow_show_cert(SSLCertificate *cert)
{
GtkWidget *cert_widget = cert_presenter(cert);
gchar *buf;
buf = g_strdup_printf(_("SSL certificate for %s"), cert->host);
alertpanel_full(buf, NULL, GTK_STOCK_CLOSE, NULL, NULL,
FALSE, cert_widget, ALERT_NOTICE, G_ALERTDEFAULT);
g_free(buf);
}
AlertValue alertpanel_with_widget(const gchar *title,
const gchar *message,
const gchar *button1_label,
const gchar *button2_label,
const gchar *button3_label,
AlertFocus focus,
gboolean can_disable,
GtkWidget *widget)
{
return alertpanel_full(title, message, button1_label,
button2_label, button3_label, focus,
can_disable, widget, ALERT_QUESTION);
}
static void unsubscribe_newsgroup_cb(GtkAction *action, gpointer data)
{
FolderView *folderview = (FolderView *)data;
FolderItem *item;
gchar *name;
gchar *message;
gchar *old_id;
AlertValue avalue;
MainWindow *mainwin = mainwindow_get_mainwindow();
if (!folderview->selected) return;
item = folderview_get_selected_item(folderview);
cm_return_if_fail(item != NULL);
if (mainwin->lock_count || news_folder_locked(item->folder))
return;
cm_return_if_fail(item->folder != NULL);
cm_return_if_fail(FOLDER_TYPE(item->folder) == F_NEWS);
cm_return_if_fail(item->folder->account != NULL);
old_id = folder_item_get_identifier(item);
name = trim_string(item->path, 32);
message = g_strdup_printf(_("Really unsubscribe newsgroup '%s'?"), name);
avalue = alertpanel_full(_("Unsubscribe newsgroup"), message,
GTK_STOCK_CANCEL, _("_Unsubscribe"), NULL,
ALERTFOCUS_FIRST, FALSE, NULL, ALERT_WARNING);
g_free(message);
g_free(name);
if (avalue != G_ALERTALTERNATE) return;
if (item == folderview_get_opened_item(folderview)) {
summary_clear_all(folderview->summaryview);
folderview_close_opened(folderview, TRUE);
}
if(item->folder->klass->remove_folder(item->folder, item) < 0) {
folder_item_scan(item);
alertpanel_error(_("Can't remove the folder '%s'."), name);
g_free(old_id);
return;
}
folder_write_list();
prefs_filtering_delete_path(old_id);
g_free(old_id);
}
/**
* Test whether we can move off file page.
* \return <i>TRUE</i> if OK to move off page.
*/
static gboolean exp_ldif_move_file( void ) {
gchar *sFile, *msg, *reason;
gboolean errFlag = FALSE;
AlertValue aval;
sFile = gtk_editable_get_chars( GTK_EDITABLE(expldif_dlg.entryLdif), 0, -1 );
g_strstrip( sFile );
gtk_entry_set_text( GTK_ENTRY(expldif_dlg.entryLdif), sFile );
exportldif_parse_filespec( _exportCtl_, sFile );
/* Test that something was supplied */
if( *sFile == '\0'|| strlen( sFile ) < 1 ) {
gtk_widget_grab_focus( expldif_dlg.entryLdif );
errFlag = TRUE;
}
g_free( sFile );
if( errFlag ) return FALSE;
/* Test for directory */
if( g_file_test(_exportCtl_->dirOutput,
G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR) ) {
return TRUE;
}
/* Prompt to create */
msg = g_strdup_printf( _(
"LDIF Output Directory '%s'\n" \
"does not exist. OK to create new directory?" ),
_exportCtl_->dirOutput );
aval = alertpanel( _("Create Directory" ),
msg, GTK_STOCK_NO, GTK_STOCK_YES, NULL );
g_free( msg );
if( aval != G_ALERTALTERNATE ) return FALSE;
/* Create directory */
if( ! exportldif_create_dir( _exportCtl_ ) ) {
reason = exportldif_get_create_msg( _exportCtl_ );
msg = g_strdup_printf( _(
"Could not create output directory for LDIF file:\n%s" ),
reason );
aval = alertpanel_full(_("Failed to Create Directory"), msg,
GTK_STOCK_CLOSE, NULL, NULL, FALSE,
NULL, ALERT_ERROR, G_ALERTDEFAULT);
g_free( msg );
return FALSE;
}
return TRUE;
}
static gboolean sslcertwindow_ask_expired_cert(SSLCertificate *cert)
{
gchar *buf, *sig_status;
AlertValue val;
GtkWidget *vbox;
GtkWidget *label;
GtkWidget *button;
GtkWidget *cert_widget;
gchar *invalid_str = sslcertwindow_get_invalid_str(cert);
const gchar *title;
vbox = gtk_vbox_new(FALSE, 5);
buf = g_strdup_printf(_("Certificate for %s is expired.\n%sDo you want to continue?"), cert->host, invalid_str);
g_free(invalid_str);
label = gtk_label_new(buf);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
g_free(buf);
sig_status = ssl_certificate_check_signer(cert->x509_cert, cert->status);
if (sig_status==NULL)
sig_status = g_strdup(_("Correct"));
buf = g_strdup_printf(_("Signature status: %s"), sig_status);
label = gtk_label_new(buf);
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);
g_free(buf);
g_free(sig_status);
button = gtk_expander_new_with_mnemonic(_("_View certificate"));
gtk_box_pack_start(GTK_BOX(vbox), button, FALSE, FALSE, 0);
cert_widget = cert_presenter(cert);
gtk_container_add(GTK_CONTAINER(button), cert_widget);
if (!ssl_certificate_check_subject_cn(cert))
title = _("SSL certificate is invalid and expired");
else
title = _("SSL certificate is expired");
val = alertpanel_full(title, NULL,
_("_Cancel connection"), _("_Accept"), NULL,
FALSE, vbox, ALERT_QUESTION, G_ALERTDEFAULT);
return (val == G_ALERTALTERNATE);
}
static void cache_clean_button_clicked_cb(GtkButton *button, gpointer data)
{
GtkLabel *label = (GtkLabel *) data;
gint val = 0;
AvatarCleanupResult *acr;
guint misses;
val = alertpanel_full(_("Clear icon cache"),
_("Are you sure you want to remove all cached avatar icons?"),
GTK_STOCK_NO, GTK_STOCK_YES, NULL, FALSE,
NULL, ALERT_WARNING, G_ALERTDEFAULT);
if (val != G_ALERTALTERNATE)
return;
debug_print("cleaning missing cache");
misses = g_hash_table_size(libravatarmisses);
g_hash_table_remove_all(libravatarmisses);
debug_print("cleaning disk cache");
acr = libravatar_cache_clean();
if (acr == NULL) {
alertpanel_error(_("Not enough memory for operation"));
return;
}
if (acr->e_stat == 0 && acr->e_unlink == 0) {
alertpanel_notice(_("Icon cache successfully cleared:\n"
"• %u missing entries removed.\n"
"• %u files removed."),
misses, acr->removed);
gtk_label_set_markup(label,
_("<span color=\"#006400\">Icon cache succesfully cleared!</span>"));
}
else {
alertpanel_warning(_("Errors clearing icon cache:\n"
"• %u missing entries removed.\n"
"• %u files removed.\n"
"• %u files failed to be read.\n"
"• %u files couldn't be removed."),
misses, acr->removed, acr->e_stat, acr->e_unlink);
gtk_label_set_markup(label,
_("<span color=\"red\">Error clearing icon cache.</span>"));
}
gtk_widget_set_sensitive(GTK_WIDGET(button), FALSE);
g_free(acr);
}
/**
* Test whether we can move off file page.
* \return <i>TRUE</i> if OK to move off page.
*/
static gboolean exp_html_move_file( void ) {
gchar *sFile, *msg, *reason;
AlertValue aval;
sFile = gtk_editable_get_chars( GTK_EDITABLE(exphtml_dlg.entryHtml), 0, -1 );
g_strchug( sFile ); g_strchomp( sFile );
gtk_entry_set_text( GTK_ENTRY(exphtml_dlg.entryHtml), sFile );
exporthtml_parse_filespec( _exportCtl_, sFile );
g_free( sFile );
/* Test for directory */
if( exporthtml_test_dir( _exportCtl_ ) ) {
return TRUE;
}
/* Prompt to create */
msg = g_strdup_printf( _(
"HTML Output Directory '%s'\n" \
"does not exist. OK to create new directory?" ),
_exportCtl_->dirOutput );
aval = alertpanel( _("Create Directory" ),
msg, GTK_STOCK_NO, GTK_STOCK_YES, NULL );
g_free( msg );
if( aval != G_ALERTALTERNATE ) return FALSE;
/* Create directory */
if( ! exporthtml_create_dir( _exportCtl_ ) ) {
reason = exporthtml_get_create_msg( _exportCtl_ );
msg = g_strdup_printf( _(
"Could not create output directory for HTML file:\n%s" ),
reason );
aval = alertpanel_full(_("Failed to Create Directory"), msg,
GTK_STOCK_CLOSE, NULL, NULL, FALSE,
NULL, ALERT_ERROR, G_ALERTDEFAULT);
g_free( msg );
return FALSE;
}
return TRUE;
}
/*!
*\brief display an error with a View Log button
*
*/
void alertpanel_error_log(const gchar *format, ...)
{
va_list args;
int val;
MainWindow *mainwin;
gchar buf[ALERT_PANEL_BUFSIZE];
va_start(args, format);
g_vsnprintf(buf, sizeof(buf), format, args);
va_end(args);
strretchomp(buf);
mainwin = mainwindow_get_mainwindow();
if (mainwin && mainwin->logwin) {
mainwindow_clear_error(mainwin);
val = alertpanel_full(_("Error"), buf, GTK_STOCK_CLOSE,
_("_View log"), NULL, ALERTFOCUS_FIRST, FALSE, NULL,
ALERT_ERROR);
if (val == G_ALERTALTERNATE)
log_window_show(mainwin->logwin);
} else
alertpanel_error("%s", buf);
}
gchar *old_id;
item = folderview_get_selected_item(folderview);
g_return_if_fail(item != NULL);
g_return_if_fail(item->path != NULL);
g_return_if_fail(item->folder != NULL);
opened = folderview_get_opened_item(folderview);
name = trim_string(item->name, 32);
AUTORELEASE_STR(name, {g_free(name); return;});
message = g_strdup_printf
(_("All folders and messages under '%s' will be permanently deleted. "
"Recovery will not be possible.\n\n"
"Do you really want to delete?"), name);
avalue = alertpanel_full(_("Delete folder"), message,
GTK_STOCK_CANCEL, GTK_STOCK_DELETE, NULL, ALERTFOCUS_FIRST, FALSE,
NULL, ALERT_WARNING);
g_free(message);
if (avalue != G_ALERTALTERNATE) return;
old_id = folder_item_get_identifier(item);
if (item == opened ||
folder_is_child_of(item, opened)) {
summary_clear_all(folderview->summaryview);
folderview_close_opened(folderview, TRUE);
}
if (item->folder->klass->remove_folder(item->folder, item) < 0) {
folder_item_scan(item);
alertpanel_error(_("Can't remove the folder '%s'."), name);
static void prefs_themes_btn_install_clicked_cb(GtkWidget *widget, gpointer data)
{
gchar *filename, *source;
gchar *themeinfo, *themename;
gchar *alert_title = NULL;
CopyInfo *cinfo;
AlertValue val = 0;
ThemesData *tdata = prefs_themes_data;
filename = filesel_select_file_open_folder(_("Select theme folder"), NULL);
if (filename == NULL)
return;
if (filename[strlen(filename) - 1] != G_DIR_SEPARATOR)
filename = g_strconcat(filename, G_DIR_SEPARATOR_S, NULL);
else
filename = g_strdup(filename);
cinfo = g_new0(CopyInfo, 1);
source = g_path_get_dirname(filename);
themename = g_path_get_basename(source);
debug_print("Installing '%s' theme from %s\n", themename, filename);
themeinfo = g_strconcat(source, G_DIR_SEPARATOR_S, THEMEINFO_FILE, NULL);
alert_title = g_strdup_printf(_("Install theme '%s'"), themename);
if (file_exist(themeinfo, FALSE) == FALSE) {
val = alertpanel(alert_title,
_("This folder doesn't seem to be a theme folder.\nInstall anyway?"),
GTK_STOCK_NO, GTK_STOCK_YES, NULL);
if (G_ALERTALTERNATE != val)
goto end_inst;
}
if (superuser_p ()) {
val = alertpanel(alert_title,
_("Do you want to install theme for all users?"),
GTK_STOCK_NO, GTK_STOCK_YES, NULL);
switch (val) {
case G_ALERTALTERNATE:
cinfo->dest = stock_pixmap_get_system_theme_dir_for_theme(
themename);
break;
case G_ALERTDEFAULT:
break;
default:
goto end_inst;
}
}
g_free(alert_title);
if (cinfo->dest == NULL) {
cinfo->dest = g_strconcat(get_rc_dir(), G_DIR_SEPARATOR_S,
PIXMAP_THEME_DIR, G_DIR_SEPARATOR_S,
themename, NULL);
}
if (TRUE == is_dir_exist(cinfo->dest)) {
AlertValue val = alertpanel_full(_("Theme exists"),
_("A theme with the same name is\nalready installed in this location.\n\n"
"Do you want to replace it?"),
GTK_STOCK_CANCEL, _("Overwrite"), NULL, FALSE,
NULL, ALERT_WARNING, G_ALERTDEFAULT);
if (val == G_ALERTALTERNATE) {
if (remove_dir_recursive(cinfo->dest) < 0) {
alertpanel_error(_("Couldn't delete the old theme in %s."), cinfo->dest);
goto end_inst;
}
} else {
goto end_inst;
}
}
if (0 != make_dir_hier(cinfo->dest)) {
alertpanel_error(_("Couldn't create destination directory %s."), cinfo->dest);
goto end_inst;
}
prefs_themes_foreach_file(source, prefs_themes_file_install, cinfo);
if (cinfo->status == NULL) {
GList *insted;
/* update interface to show newly installed theme */
prefs_themes_get_themes_and_names(tdata);
insted = g_list_find_custom(tdata->themes,
(gpointer)(cinfo->dest),
(GCompareFunc)strcmp2);
if (NULL != insted) {
alertpanel_notice(_("Theme installed successfully."));
tdata->displayed = (gchar *)(insted->data);
prefs_themes_set_themes_menu(GTK_COMBO_BOX(tdata->page->op_menu), tdata);
prefs_themes_display_global_stats(tdata);
prefs_themes_get_theme_info(tdata);
}
else
alertpanel_error(_("Failed installing theme"));
}
else
alertpanel_error(_("File %s failed\nwhile installing theme."), cinfo->status);
end_inst:
g_free(cinfo->dest);
g_free(filename);
g_free(source);
g_free(themeinfo);
g_free(cinfo);
g_free(themename);
}
void sgpgme_init()
{
gchar *ctype_locale = NULL, *messages_locale = NULL;
gchar *ctype_utf8_locale = NULL, *messages_utf8_locale = NULL;
gpgme_engine_info_t engineInfo;
if (gpgme_check_version("1.0.0")) {
#ifdef LC_CTYPE
debug_print("setting gpgme CTYPE locale\n");
#ifdef G_OS_WIN32
ctype_locale = g_win32_getlocale();
#else
ctype_locale = g_strdup(setlocale(LC_CTYPE, NULL));
#endif
if (ctype_locale) {
debug_print("setting gpgme CTYPE locale to: %s\n", ctype_locale);
if (strchr(ctype_locale, '.'))
*(strchr(ctype_locale, '.')) = '\0';
else if (strchr(ctype_locale, '@'))
*(strchr(ctype_locale, '@')) = '\0';
ctype_utf8_locale = g_strconcat(ctype_locale, ".UTF-8", NULL);
debug_print("setting gpgme locale to UTF8: %s\n", ctype_utf8_locale ? ctype_utf8_locale : "NULL");
gpgme_set_locale(NULL, LC_CTYPE, ctype_utf8_locale);
debug_print("done\n");
g_free(ctype_utf8_locale);
g_free(ctype_locale);
} else {
debug_print("couldn't set gpgme CTYPE locale\n");
}
#endif
#ifdef LC_MESSAGES
debug_print("setting gpgme MESSAGES locale\n");
#ifdef G_OS_WIN32
messages_locale = g_win32_getlocale();
#else
messages_locale = g_strdup(setlocale(LC_MESSAGES, NULL));
#endif
if (messages_locale) {
debug_print("setting gpgme MESSAGES locale to: %s\n", messages_locale);
if (strchr(messages_locale, '.'))
*(strchr(messages_locale, '.')) = '\0';
else if (strchr(messages_locale, '@'))
*(strchr(messages_locale, '@')) = '\0';
messages_utf8_locale = g_strconcat(messages_locale, ".UTF-8", NULL);
debug_print("setting gpgme locale to UTF8: %s\n", messages_utf8_locale ? messages_utf8_locale : "NULL");
gpgme_set_locale(NULL, LC_MESSAGES, messages_utf8_locale);
debug_print("done\n");
g_free(messages_utf8_locale);
g_free(messages_locale);
} else {
debug_print("couldn't set gpgme MESSAGES locale\n");
}
#endif
if (!gpgme_get_engine_info(&engineInfo)) {
while (engineInfo) {
debug_print("GpgME Protocol: %s\n"
"Version: %s (req %s)\n"
"Executable: %s\n",
gpgme_get_protocol_name(engineInfo->protocol) ? gpgme_get_protocol_name(engineInfo->protocol):"???",
engineInfo->version ? engineInfo->version:"???",
engineInfo->req_version ? engineInfo->req_version:"???",
engineInfo->file_name ? engineInfo->file_name:"???");
if (engineInfo->protocol == GPGME_PROTOCOL_OpenPGP
&& gpgme_engine_check_version(engineInfo->protocol) !=
GPG_ERR_NO_ERROR) {
if (engineInfo->file_name && !engineInfo->version) {
alertpanel_error(_("Gpgme protocol '%s' is unusable: "
"Engine '%s' isn't installed properly."),
gpgme_get_protocol_name(engineInfo->protocol),
engineInfo->file_name);
} else if (engineInfo->file_name && engineInfo->version
&& engineInfo->req_version) {
alertpanel_error(_("Gpgme protocol '%s' is unusable: "
"Engine '%s' version %s is installed, "
"but version %s is required.\n"),
gpgme_get_protocol_name(engineInfo->protocol),
engineInfo->file_name,
engineInfo->version,
engineInfo->req_version);
} else {
alertpanel_error(_("Gpgme protocol '%s' is unusable "
"(unknown problem)"),
gpgme_get_protocol_name(engineInfo->protocol));
}
}
engineInfo = engineInfo->next;
}
}
} else {
sgpgme_disable_all();
if (prefs_gpg_get_config()->gpg_warning) {
AlertValue val;
val = alertpanel_full
(_("Warning"),
_("GnuPG is not installed properly, or needs "
"to be upgraded.\n"
"OpenPGP support disabled."),
GTK_STOCK_CLOSE, NULL, NULL, TRUE, NULL,
ALERT_WARNING, G_ALERTDEFAULT);
if (val & G_ALERTDISABLE)
prefs_gpg_get_config()->gpg_warning = FALSE;
}
}
}
static IncState inc_pop3_session_do(IncSession *session)
{
Pop3Session *pop3_session = POP3_SESSION(session->session);
IncProgressDialog *inc_dialog = (IncProgressDialog *)session->data;
gchar *server;
gchar *account_name;
gushort port;
gchar *buf;
debug_print("getting new messages of account %s...\n",
pop3_session->ac_prefs->account_name);
pop3_session->ac_prefs->last_pop_login_time = time(NULL);
buf = g_strdup_printf(_("%s: Retrieving new messages"),
pop3_session->ac_prefs->recv_server);
gtk_window_set_title(GTK_WINDOW(inc_dialog->dialog->window), buf);
g_free(buf);
server = pop3_session->ac_prefs->recv_server;
account_name = pop3_session->ac_prefs->account_name;
#ifdef USE_GNUTLS
port = pop3_session->ac_prefs->set_popport ?
pop3_session->ac_prefs->popport :
pop3_session->ac_prefs->ssl_pop == SSL_TUNNEL ? 995 : 110;
SESSION(pop3_session)->ssl_type = pop3_session->ac_prefs->ssl_pop;
if (pop3_session->ac_prefs->ssl_pop != SSL_NONE)
SESSION(pop3_session)->nonblocking =
pop3_session->ac_prefs->use_nonblocking_ssl;
#else
if (pop3_session->ac_prefs->ssl_pop != SSL_NONE) {
if (alertpanel_full(_("Insecure connection"),
_("This connection is configured to be secured "
"using SSL, but SSL 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, FALSE, NULL, ALERT_WARNING,
G_ALERTDEFAULT) != G_ALERTALTERNATE)
return INC_CANCEL;
}
port = pop3_session->ac_prefs->set_popport ?
pop3_session->ac_prefs->popport : 110;
#endif
buf = g_strdup_printf(_("Account '%s': Connecting to POP3 server: %s:%d..."),
account_name, server, port);
statuswindow_print_all("%s", buf);
log_message(LOG_PROTOCOL, "%s\n", buf);
progress_dialog_set_label(inc_dialog->dialog, buf);
GTK_EVENTS_FLUSH();
g_free(buf);
session_set_timeout(SESSION(pop3_session),
prefs_common.io_timeout_secs * 1000);
if (session_connect(SESSION(pop3_session), server, port) < 0) {
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);
}
alertpanel_error(_("Can't connect to POP3 server: %s:%d"),
server, port);
manage_window_focus_out(inc_dialog->dialog->window, NULL, NULL);
} else {
log_error(LOG_PROTOCOL, _("Can't connect to POP3 server: %s:%d\n"),
server, port);
}
session->inc_state = INC_CONNECT_ERROR;
statuswindow_pop_all();
return INC_CONNECT_ERROR;
}
while (session_is_running(SESSION(pop3_session)) &&
session->inc_state != INC_CANCEL)
gtk_main_iteration();
if (session->inc_state == INC_SUCCESS) {
switch (pop3_session->error_val) {
case PS_SUCCESS:
switch (SESSION(pop3_session)->state) {
case SESSION_ERROR:
if (pop3_session->state == POP3_READY)
session->inc_state = INC_CONNECT_ERROR;
else
session->inc_state = INC_ERROR;
break;
case SESSION_EOF:
session->inc_state = INC_EOF;
break;
case SESSION_TIMEOUT:
session->inc_state = INC_TIMEOUT;
break;
default:
session->inc_state = INC_SUCCESS;
break;
}
break;
case PS_AUTHFAIL:
session->inc_state = INC_AUTH_FAILED;
break;
case PS_IOERR:
session->inc_state = INC_IO_ERROR;
break;
case PS_SOCKET:
session->inc_state = INC_SOCKET_ERROR;
break;
case PS_LOCKBUSY:
session->inc_state = INC_LOCKED;
break;
default:
session->inc_state = INC_ERROR;
break;
}
}
session_disconnect(SESSION(pop3_session));
statusbar_pop_all();
return session->inc_state;
}
gint lock_mbox(const gchar *base, LockType type)
{
#ifdef G_OS_UNIX
gint retval = 0;
if (type == LOCK_FILE) {
gchar *lockfile, *locklink;
gint retry = 0;
FILE *lockfp;
lockfile = g_strdup_printf("%s.%d", base, getpid());
if ((lockfp = g_fopen(lockfile, "wb")) == NULL) {
FILE_OP_ERROR(lockfile, "fopen");
g_warning("can't create lock file %s\n", lockfile);
g_warning("use 'flock' instead of 'file' if possible.\n");
g_free(lockfile);
return -1;
}
if (fprintf(lockfp, "%d\n", getpid()) < 0) {
FILE_OP_ERROR(lockfile, "fprintf");
g_free(lockfile);
fclose(lockfp);
return -1;
}
if (fclose(lockfp) == EOF) {
FILE_OP_ERROR(lockfile, "fclose");
g_free(lockfile);
return -1;
}
locklink = g_strconcat(base, ".lock", NULL);
while (link(lockfile, locklink) < 0) {
FILE_OP_ERROR(lockfile, "link");
if (retry >= 5) {
g_warning("can't create %s\n", lockfile);
claws_unlink(lockfile);
g_free(lockfile);
return -1;
}
if (retry == 0)
g_warning("mailbox is owned by another"
" process, waiting...\n");
retry++;
sleep(5);
}
claws_unlink(lockfile);
g_free(lockfile);
} else if (type == LOCK_FLOCK) {
gint lockfd;
gboolean fcntled = FALSE;
#if HAVE_FCNTL_H && !defined(G_OS_WIN32)
struct flock fl;
fl.l_type = F_WRLCK;
fl.l_whence = SEEK_SET;
fl.l_start = 0;
fl.l_len = 0;
#endif
#if HAVE_FLOCK
if ((lockfd = g_open(base, O_RDWR, 0)) < 0) {
#else
if ((lockfd = g_open(base, O_RDWR, 0)) < 0) {
#endif
FILE_OP_ERROR(base, "open");
return -1;
}
#if HAVE_FCNTL_H && !defined(G_OS_WIN32)
if (fcntl(lockfd, F_SETLK, &fl) == -1) {
g_warning("can't fnctl %s (%s)", base, strerror(errno));
return -1;
} else {
fcntled = TRUE;
}
#endif
#if HAVE_FLOCK
if (flock(lockfd, LOCK_EX|LOCK_NB) < 0 && !fcntled) {
perror("flock");
#else
#if HAVE_LOCKF
if (lockf(lockfd, F_TLOCK, 0) < 0 && !fcntled) {
perror("lockf");
#else
{
#endif
#endif /* HAVE_FLOCK */
g_warning("can't lock %s\n", base);
if (close(lockfd) < 0)
perror("close");
return -1;
}
retval = lockfd;
} else {
g_warning("invalid lock type\n");
return -1;
}
return retval;
#else
return -1;
#endif /* G_OS_UNIX */
}
gint unlock_mbox(const gchar *base, gint fd, LockType type)
{
if (type == LOCK_FILE) {
gchar *lockfile;
lockfile = g_strconcat(base, ".lock", NULL);
if (claws_unlink(lockfile) < 0) {
FILE_OP_ERROR(lockfile, "unlink");
g_free(lockfile);
return -1;
}
g_free(lockfile);
return 0;
} else if (type == LOCK_FLOCK) {
gboolean fcntled = FALSE;
#if HAVE_FCNTL_H && !defined(G_OS_WIN32)
struct flock fl;
fl.l_type = F_UNLCK;
fl.l_whence = SEEK_SET;
fl.l_start = 0;
fl.l_len = 0;
if (fcntl(fd, F_SETLK, &fl) == -1) {
g_warning("can't fnctl %s", base);
} else {
fcntled = TRUE;
}
#endif
#if HAVE_FLOCK
if (flock(fd, LOCK_UN) < 0 && !fcntled) {
perror("flock");
#else
#if HAVE_LOCKF
if (lockf(fd, F_ULOCK, 0) < 0 && !fcntled) {
perror("lockf");
#else
{
#endif
#endif /* HAVE_FLOCK */
g_warning("can't unlock %s\n", base);
if (close(fd) < 0)
perror("close");
return -1;
}
if (close(fd) < 0) {
perror("close");
return -1;
}
return 0;
}
g_warning("invalid lock type\n");
return -1;
}
gint copy_mbox(gint srcfd, const gchar *dest)
{
FILE *dest_fp;
ssize_t n_read;
gchar buf[BUFSIZ];
gboolean err = FALSE;
int save_errno = 0;
if (srcfd < 0) {
return -1;
}
if ((dest_fp = g_fopen(dest, "wb")) == NULL) {
FILE_OP_ERROR(dest, "fopen");
return -1;
}
if (change_file_mode_rw(dest_fp, dest) < 0) {
FILE_OP_ERROR(dest, "chmod");
g_warning("can't change file mode\n");
}
while ((n_read = read(srcfd, buf, sizeof(buf))) > 0) {
if (n_read == -1 && errno != 0) {
save_errno = errno;
break;
}
if (fwrite(buf, 1, n_read, dest_fp) < n_read) {
g_warning("writing to %s failed.\n", dest);
fclose(dest_fp);
claws_unlink(dest);
return -1;
}
}
if (save_errno != 0) {
g_warning("error %d reading mbox: %s\n", save_errno,
strerror(save_errno));
err = TRUE;
}
if (fclose(dest_fp) == EOF) {
FILE_OP_ERROR(dest, "fclose");
err = TRUE;
}
if (err) {
claws_unlink(dest);
return -1;
}
return 0;
}
void empty_mbox(const gchar *mbox)
{
FILE *fp;
if ((fp = g_fopen(mbox, "wb")) == NULL) {
FILE_OP_ERROR(mbox, "fopen");
g_warning("can't truncate mailbox to zero.\n");
return;
}
fclose(fp);
}
gint export_list_to_mbox(GSList *mlist, const gchar *mbox)
/* return values: -2 skipped, -1 error, 0 OK */
{
GSList *cur;
MsgInfo *msginfo;
FILE *msg_fp;
FILE *mbox_fp;
gchar buf[BUFFSIZE];
int err = 0;
gint msgs = 1, total = g_slist_length(mlist);
if (g_file_test(mbox, G_FILE_TEST_EXISTS) == TRUE) {
if (alertpanel_full(_("Overwrite mbox file"),
_("This file already exists. Do you want to overwrite it?"),
GTK_STOCK_CANCEL, _("Overwrite"), NULL, FALSE,
NULL, ALERT_WARNING, G_ALERTDEFAULT)
!= G_ALERTALTERNATE) {
return -2;
}
}
if ((mbox_fp = g_fopen(mbox, "wb")) == NULL) {
FILE_OP_ERROR(mbox, "fopen");
alertpanel_error(_("Could not create mbox file:\n%s\n"), mbox);
return -1;
}
#ifdef HAVE_FGETS_UNLOCKED
flockfile(mbox_fp);
#endif
statuswindow_print_all(_("Exporting to mbox..."));
for (cur = mlist; cur != NULL; cur = cur->next) {
int len;
gchar buft[BUFFSIZE];
msginfo = (MsgInfo *)cur->data;
msg_fp = procmsg_open_message(msginfo);
if (!msg_fp) {
continue;
}
#ifdef HAVE_FGETS_UNLOCKED
flockfile(msg_fp);
#endif
strncpy2(buf,
msginfo->from ? msginfo->from :
cur_account && cur_account->address ?
cur_account->address : "unknown",
sizeof(buf));
extract_address(buf);
if (fprintf(mbox_fp, "From %s %s",
buf, ctime_r(&msginfo->date_t, buft)) < 0) {
err = -1;
#ifdef HAVE_FGETS_UNLOCKED
funlockfile(msg_fp);
#endif
fclose(msg_fp);
goto out;
}
buf[0] = '\0';
/* write email to mboxrc */
while (SC_FGETS(buf, sizeof(buf), msg_fp) != NULL) {
/* quote any From, >From, >>From, etc., according to mbox format specs */
int offset;
offset = 0;
/* detect leading '>' char(s) */
while ((buf[offset] == '>')) {
offset++;
}
if (!strncmp(buf+offset, "From ", 5)) {
if (SC_FPUTC('>', mbox_fp) == EOF) {
err = -1;
#ifdef HAVE_FGETS_UNLOCKED
funlockfile(msg_fp);
#endif
fclose(msg_fp);
goto out;
}
}
if (SC_FPUTS(buf, mbox_fp) == EOF) {
err = -1;
#ifdef HAVE_FGETS_UNLOCKED
funlockfile(msg_fp);
#endif
fclose(msg_fp);
goto out;
}
}
/* force last line to end w/ a newline */
len = strlen(buf);
if (len > 0) {
len--;
if ((buf[len] != '\n') && (buf[len] != '\r')) {
if (SC_FPUTC('\n', mbox_fp) == EOF) {
err = -1;
#ifdef HAVE_FGETS_UNLOCKED
funlockfile(msg_fp);
#endif
fclose(msg_fp);
goto out;
}
}
}
/* add a trailing empty line */
if (SC_FPUTC('\n', mbox_fp) == EOF) {
err = -1;
#ifdef HAVE_FGETS_UNLOCKED
funlockfile(msg_fp);
#endif
fclose(msg_fp);
goto out;
}
#ifdef HAVE_FGETS_UNLOCKED
funlockfile(msg_fp);
#endif
fclose(msg_fp);
statusbar_progress_all(msgs++,total, 500);
if (msgs%500 == 0)
GTK_EVENTS_FLUSH();
}
out:
statusbar_progress_all(0,0,0);
statuswindow_pop_all();
#ifdef HAVE_FGETS_UNLOCKED
funlockfile(mbox_fp);
#endif
fclose(mbox_fp);
return err;
}
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 gboolean sslcertwindow_ask_changed_cert(SSLCertificate *old_cert, SSLCertificate *new_cert)
{
GtkWidget *old_cert_widget = cert_presenter(old_cert);
GtkWidget *new_cert_widget = cert_presenter(new_cert);
GtkWidget *vbox;
gchar *buf, *sig_status;
GtkWidget *vbox2;
GtkWidget *label;
GtkWidget *button;
AlertValue val;
gchar *invalid_str = sslcertwindow_get_invalid_str(new_cert);
const gchar *title;
vbox = gtk_vbox_new(FALSE, 5);
label = gtk_label_new(_("New certificate:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_end(GTK_BOX(vbox), new_cert_widget, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), label, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), gtk_hseparator_new(), TRUE, TRUE, 0);
label = gtk_label_new(_("Known certificate:"));
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_end(GTK_BOX(vbox), old_cert_widget, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), label, TRUE, TRUE, 0);
gtk_widget_show_all(vbox);
vbox2 = gtk_vbox_new(FALSE, 5);
buf = g_strdup_printf(_("Certificate for %s has changed.\n%sDo you want to accept it?"), new_cert->host, invalid_str);
g_free(invalid_str);
label = gtk_label_new(buf);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox2), label, TRUE, TRUE, 0);
g_free(buf);
sig_status = ssl_certificate_check_signer(new_cert->x509_cert, new_cert->status);
if (sig_status==NULL)
sig_status = g_strdup(_("Correct"));
buf = g_strdup_printf(_("Signature status: %s"), sig_status);
label = gtk_label_new(buf);
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_box_pack_start(GTK_BOX(vbox2), label, TRUE, TRUE, 0);
g_free(buf);
g_free(sig_status);
button = gtk_expander_new_with_mnemonic(_("_View certificates"));
gtk_box_pack_start(GTK_BOX(vbox2), button, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(button), vbox);
if (!ssl_certificate_check_subject_cn(new_cert))
title = _("SSL certificate changed and is invalid");
else
title = _("SSL certificate changed");
val = alertpanel_full(title, NULL,
_("_Cancel connection"), _("_Accept and save"), NULL,
FALSE, vbox2, ALERT_WARNING, G_ALERTDEFAULT);
return (val == G_ALERTALTERNATE);
}
static Session *news_session_new_for_folder(Folder *folder)
{
Session *session;
PrefsAccount *ac;
const gchar *userid = NULL;
gchar *passwd = NULL;
gushort port;
int r;
cm_return_val_if_fail(folder != NULL, NULL);
cm_return_val_if_fail(folder->account != NULL, NULL);
ac = folder->account;
#ifdef USE_GNUTLS
port = ac->set_nntpport ? ac->nntpport
: ac->ssl_nntp ? NNTPS_PORT : NNTP_PORT;
session = news_session_new(folder, ac->nntp_server, port, userid, passwd,
ac->ssl_nntp);
#else
if (ac->ssl_nntp != SSL_NONE) {
if (alertpanel_full(_("Insecure connection"),
_("This connection is configured to be secured "
"using SSL, but SSL 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, FALSE, NULL, ALERT_WARNING,
G_ALERTDEFAULT) != G_ALERTALTERNATE)
return NULL;
}
port = ac->set_nntpport ? ac->nntpport : NNTP_PORT;
session = news_session_new(folder, ac->nntp_server, port, userid, passwd);
#endif
if (ac->use_nntp_auth && ac->userid && ac->userid[0]) {
userid = ac->userid;
if (password_get(userid, ac->nntp_server, "nntp", port, &passwd)) {
/* NOP */;
} else if ((passwd = passwd_store_get_account(ac->account_id,
PWS_ACCOUNT_RECV)) == NULL) {
passwd = input_dialog_query_password_keep(ac->nntp_server,
userid,
&(ac->session_passwd));
}
}
if (session != NULL)
r = nntp_threaded_mode_reader(folder);
else
r = NEWSNNTP_ERROR_CONNECTION_REFUSED;
if (r != NEWSNNTP_NO_ERROR) {
if (r == NEWSNNTP_WARNING_REQUEST_AUTHORIZATION_USERNAME) {
/*
FIX ME when libetpan implements 480 to indicate authorization
is required to use this capability. Libetpan treats a 480 as a
381 which is clearly wrong.
RFC 4643 section 2.
Response code 480
Generic response
Meaning: command unavailable until the client
has authenticated itself.
*/
/* if the server does not advertise the capability MODE-READER,
we normally should not send MODE READER. However this can't
hurt: a transit-only server returns 502 and closes the cnx.
Ref.: http://tools.ietf.org/html/rfc3977#section-5.3
*/
log_error(LOG_PROTOCOL, _("Libetpan does not support return code 480 "
"so for now we choose to continue\n"));
}
else if (r == NEWSNNTP_ERROR_UNEXPECTED_RESPONSE) {
/* if the server does not advertise the capability MODE-READER,
we normally should not send MODE READER. However this can't
hurt: a transit-only server returns 502 and closes the cnx.
Ref.: http://tools.ietf.org/html/rfc3977#section-5.3
*/
log_error(LOG_PROTOCOL, _("Mode reader failed, continuing nevertheless\n"));
}
else {
/* An error state bail out */
log_error(LOG_PROTOCOL, _("Error creating session with %s:%d\n"), ac->nntp_server, port);
if (session != NULL)
session_destroy(SESSION(session));
g_free(passwd);
if (ac->session_passwd) {
g_free(ac->session_passwd);
ac->session_passwd = NULL;
}
return NULL;
}
}
if ((session != NULL) && ac->use_nntp_auth) { /* FIXME: && ac->use_nntp_auth_onconnect */
if (nntp_threaded_login(folder, userid, passwd) !=
NEWSNNTP_NO_ERROR) {
log_error(LOG_PROTOCOL, _("Error authenticating to %s:%d...\n"), ac->nntp_server, port);
session_destroy(SESSION(session));
g_free(passwd);
if (ac->session_passwd) {
g_free(ac->session_passwd);
ac->session_passwd = NULL;
}
return NULL;
}
}
g_free(passwd);
return session;
}
gchar *old_id;
item = folderview_get_selected_item(folderview);
g_return_if_fail(item != NULL);
g_return_if_fail(item->path != NULL);
g_return_if_fail(item->folder != NULL);
opened = folderview_get_opened_item(folderview);
name = trim_string(item->name, 32);
AUTORELEASE_STR(name, {g_free(name); return;});
message = g_strdup_printf
(_("All folders and messages under '%s' will be permanently deleted. "
"Recovery will not be possible.\n\n"
"Do you really want to delete?"), name);
avalue = alertpanel_full(_("Delete folder"), message,
GTK_STOCK_CANCEL, GTK_STOCK_DELETE, NULL, FALSE,
NULL, ALERT_WARNING, G_ALERTDEFAULT);
g_free(message);
if (avalue != G_ALERTALTERNATE) return;
old_id = folder_item_get_identifier(item);
if (item == opened ||
folder_is_child_of(item, opened)) {
summary_clear_all(folderview->summaryview);
folderview_close_opened(folderview, TRUE);
}
if (item->folder->klass->remove_folder(item->folder, item) < 0) {
folder_item_scan(item);
alertpanel_error(_("Can't remove the folder '%s'."), name);
static void mimeview_view_file(const gchar *filename, MimeInfo *partinfo,
const gchar *cmdline)
{
const gchar *cmd = NULL;
gchar buf[BUFFSIZE];
if (!cmdline) {
#ifdef G_OS_WIN32
DWORD dwtype;
if (g_file_test(filename, G_FILE_TEST_IS_EXECUTABLE) ||
str_has_suffix_case(filename, ".scr") ||
str_has_suffix_case(filename, ".pif") ||
GetBinaryType(filename, &dwtype)) {
alertpanel_full
(_("Opening executable file"),
_("This is an executable file. Opening executable file is restricted for security.\n"
"If you want to launch it, save it to somewhere and make sure it is not an virus or something like a malicious program."),
ALERT_WARNING, G_ALERTDEFAULT, FALSE,
GTK_STOCK_OK, NULL, NULL);
return;
}
execute_open_file(filename, partinfo->content_type);
return;
#elif defined(__APPLE__)
if (g_file_test(filename, G_FILE_TEST_IS_EXECUTABLE) ||
str_has_suffix_case(filename, ".py") ||
str_has_suffix_case(filename, ".rb") ||
str_has_suffix_case(filename, ".sh")) {
alertpanel_full
(_("Opening executable file"),
_("This is an executable file. Opening executable file is restricted for security.\n"
"If you want to launch it, save it to somewhere and make sure it is not an virus or something like a malicious program."),
ALERT_WARNING, G_ALERTDEFAULT, FALSE,
GTK_STOCK_OK, NULL, NULL);
return;
}
execute_open_file(filename, partinfo->content_type);
return;
#else
if (MIME_IMAGE == partinfo->mime_type)
cmd = prefs_common.mime_image_viewer;
else if (MIME_AUDIO == partinfo->mime_type)
cmd = prefs_common.mime_audio_player;
else if (MIME_TEXT_HTML == partinfo->mime_type)
cmd = prefs_common.uri_cmd;
if (!cmd) {
if (prefs_common.mime_cmd) {
if (str_find_format_times
(prefs_common.mime_cmd, 's') == 2) {
g_snprintf(buf, sizeof(buf),
prefs_common.mime_cmd,
partinfo->content_type,
"%s");
cmd = buf;
} else
cmd = prefs_common.mime_cmd;
} else {
procmime_execute_open_file
(filename, partinfo->content_type);
return;
}
}
#endif
} else
cmd = cmdline;
if (cmd && str_find_format_times(cmd, 's') == 1) {
gchar *cmdbuf;
cmdbuf = g_strdup_printf(cmd, filename);
execute_command_line(cmdbuf, TRUE);
g_free(cmdbuf);
} else if (cmd)
g_warning("MIME viewer command line is invalid: '%s'", cmd);
}