CamelSession *session;
CamelStream *stream;
const gchar *service_name;
- const gchar *host;
guint16 default_port;
guint16 port;
gchar *socks_host;
gint socks_port;
+ gchar *host;
gint status;
session = camel_service_get_session (CAMEL_SERVICE (service));
network_settings = CAMEL_NETWORK_SETTINGS (settings);
method = camel_network_settings_get_security_method (network_settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
port = camel_network_settings_get_port (network_settings);
service_name = camel_network_service_get_service_name (service, method);
stream = NULL;
}
+ g_free (host);
+
return stream;
}
guint8 *digest;
gsize length;
const gchar *hex;
- const gchar *user;
const gchar *password;
GByteArray *ret = NULL;
guchar ipad[64];
guchar opad[64];
+ gchar *user;
gint i, pw_len;
/* Need to wait for the server */
g_return_val_if_fail (CAMEL_IS_NETWORK_SETTINGS (settings), NULL);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- user = camel_network_settings_get_user (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
g_return_val_if_fail (user != NULL, NULL);
password = camel_service_get_password (service);
camel_sasl_set_authenticated (sasl, TRUE);
+ g_free (user);
+
return ret;
}
struct addrinfo *ai, hints;
const gchar *service_name;
const gchar *password;
- const gchar *host;
- const gchar *user;
+ gchar *host;
+ gchar *user;
/* Need to wait for the server */
if (!token)
g_return_val_if_fail (CAMEL_IS_NETWORK_SETTINGS (settings), NULL);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
- user = camel_network_settings_get_user (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
g_return_val_if_fail (user != NULL, NULL);
if (host == NULL)
- host = "localhost";
+ host = g_strdup ("localhost");
password = camel_service_get_password (service);
g_return_val_if_fail (password != NULL, NULL);
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Server challenge too long (>2048 octets)"));
- return NULL;
+ goto exit;
}
tokens = g_strndup ((gchar *) token->data, token->len);
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Server challenge invalid\n"));
- return NULL;
+ goto exit;
}
if (priv->challenge->qop == QOP_INVALID) {
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Server challenge contained invalid "
"\"Quality of Protection\" token"));
- return NULL;
+ goto exit;
}
memset (&hints, 0, sizeof (hints));
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Server response did not contain "
"authorization data"));
- return NULL;
+ goto exit;
}
rspauth = g_new0 (struct _param, 1);
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Server response contained incomplete "
"authorization data"));
- return NULL;
+ goto exit;
}
compute_response (priv->response, password, FALSE, out);
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Server response does not match"));
camel_sasl_set_authenticated (sasl, TRUE);
-
- return NULL;
+ goto exit;
}
g_free (rspauth->name);
priv->state++;
+exit:
+ g_free (host);
+ g_free (user);
+
return ret;
}
gchar *str;
struct addrinfo *ai, hints;
const gchar *service_name;
- const gchar *host;
- const gchar *user;
+ gchar *host;
+ gchar *user;
priv = CAMEL_SASL_GSSAPI (sasl)->priv;
g_return_val_if_fail (CAMEL_IS_NETWORK_SETTINGS (settings), NULL);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
- user = camel_network_settings_get_user (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
g_return_val_if_fail (user != NULL, NULL);
if (host == NULL)
- host = "localhost";
+ host = g_strdup ("localhost");
switch (priv->state) {
case GSSAPI_STATE_INIT:
ai = camel_getaddrinfo (
host, NULL, &hints, cancellable, error);
if (ai == NULL)
- return NULL;
+ goto exit;
str = g_strdup_printf("%s@%s", service_name, ai->ai_canonname);
camel_freeaddrinfo (ai);
if (major != GSS_S_COMPLETE) {
gssapi_set_exception (major, minor, error);
- return NULL;
+ goto exit;
}
input_token = GSS_C_NO_BUFFER;
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Bad authentication response from server."));
- return NULL;
+ goto exit;
}
inbuf.value = token->data;
goto challenge;
gssapi_set_exception (major, minor, error);
- return NULL;
+ goto exit;
}
challenge = g_byte_array_new ();
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Bad authentication response from server."));
- return NULL;
+ goto exit;
}
inbuf.value = token->data;
major = gss_unwrap (&minor, priv->ctx, &inbuf, &outbuf, &conf_state, &qop);
if (major != GSS_S_COMPLETE) {
gssapi_set_exception (major, minor, error);
- return NULL;
+ goto exit;
}
if (outbuf.length < 4) {
#ifndef HAVE_HEIMDAL_KRB5
gss_release_buffer (&minor, &outbuf);
#endif
- return NULL;
+ goto exit;
}
/* check that our desired security layer is supported */
#ifndef HAVE_HEIMDAL_KRB5
gss_release_buffer (&minor, &outbuf);
#endif
- return NULL;
+ goto exit;
}
inbuf.length = 4 + strlen (user);
if (major != GSS_S_COMPLETE) {
gssapi_set_exception (major, minor, error);
g_free (str);
- return NULL;
+ goto exit;
}
g_free (str);
camel_sasl_set_authenticated (sasl, TRUE);
break;
default:
- return NULL;
+ break;
}
+exit:
+ g_free (host);
+ g_free (user);
+
return challenge;
}
CamelService *service;
GByteArray *buf = NULL;
const gchar *password;
- const gchar *user;
+ gchar *user;
+
+ /* Need to wait for the server */
+ if (token == NULL)
+ return NULL;
priv = CAMEL_SASL_LOGIN (sasl)->priv;
g_return_val_if_fail (CAMEL_IS_NETWORK_SETTINGS (settings), NULL);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- user = camel_network_settings_get_user (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
g_return_val_if_fail (user != NULL, NULL);
password = camel_service_get_password (service);
g_return_val_if_fail (password != NULL, NULL);
- /* Need to wait for the server */
- if (!token)
- return NULL;
-
switch (priv->state) {
case LOGIN_USER:
buf = g_byte_array_new ();
priv->state++;
+ g_free (user);
+
return buf;
}
guchar nonce[8], hash[21], lm_resp[24], nt_resp[24];
GString *domain = NULL;
const gchar *password;
- const gchar *user;
+ const gchar *real_user;
const gchar *cp;
+ gchar *user = NULL;
service = camel_sasl_get_service (sasl);
g_return_val_if_fail (CAMEL_IS_NETWORK_SETTINGS (settings), NULL);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- user = camel_network_settings_get_user (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
g_return_val_if_fail (user != NULL, NULL);
password = camel_service_get_password (service);
g_free (priv->type1_msg);
priv->type1_msg = NULL;
}
- return ret;
+ goto exit;
} else {
gchar *type2;
gchar *string;
g_free (string);
g_free (type2);
}
+
/* On failure, we just return an empty string. Setting the
* GError would cause the providers to abort the whole
* connection, and we want them to ask the user for a password
* and continue. */
g_object_unref (priv->helper_stream);
priv->helper_stream = NULL;
- return ret;
+
+ goto exit;
}
#endif
cp = strchr (user, '\\');
if (cp != NULL) {
domain = g_string_new_len (user, cp - user);
- user = cp + 1;
- }
+ real_user = cp + 1;
+ } else
+ real_user = user;
/* Otherwise, fall back to the domain of the server, if possible */
if (domain == NULL)
ntlm_set_string (ret, NTLM_RESPONSE_DOMAIN_OFFSET,
domain->str, domain->len);
ntlm_set_string (ret, NTLM_RESPONSE_USER_OFFSET,
- user, strlen (user));
+ real_user, strlen (real_user));
ntlm_set_string (ret, NTLM_RESPONSE_HOST_OFFSET,
"UNKNOWN", sizeof ("UNKNOWN") - 1);
ntlm_set_string (ret, NTLM_RESPONSE_LM_RESP_OFFSET,
sizeof (NTLM_REQUEST) - 1);
exit:
+ g_free (user);
+
return ret;
}
CamelService *service;
CamelSaslNTLM *ntlm = CAMEL_SASL_NTLM (sasl);
CamelSaslNTLMPrivate *priv = ntlm->priv;
- const gchar *user;
const gchar *cp;
+ gchar *user;
gchar buf[1024];
gsize s;
gchar *command;
g_return_val_if_fail (CAMEL_IS_NETWORK_SETTINGS (settings), FALSE);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- user = camel_network_settings_get_user (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
g_return_val_if_fail (user != NULL, FALSE);
cp = strchr (user, '\\');
"--use-cached-creds --username '%s'",
NTLM_AUTH_HELPER, user);
}
+
ret = camel_stream_process_connect (
CAMEL_STREAM_PROCESS (stream), command, NULL, error);
+
g_free (command);
+ g_free (user);
+
if (ret) {
g_object_unref (stream);
return FALSE;
}
+
if (camel_stream_write_string (stream, "YR\n", cancellable, error) < 0) {
g_object_unref (stream);
return FALSE;
}
+
s = camel_stream_read (stream, buf, sizeof (buf), cancellable, NULL);
if (s < 4) {
g_object_unref (stream);
return FALSE;
}
+
if (buf[0] != 'Y' || buf[1] != 'R' || buf[2] != ' ' || buf[s - 1] != '\n') {
g_object_unref (stream);
return FALSE;
CamelService *service;
GByteArray *buf = NULL;
const gchar *password;
- const gchar *user;
+ gchar *user;
service = camel_sasl_get_service (sasl);
g_return_val_if_fail (CAMEL_IS_NETWORK_SETTINGS (settings), NULL);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- user = camel_network_settings_get_user (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
g_return_val_if_fail (user != NULL, NULL);
password = camel_service_get_password (service);
camel_sasl_set_authenticated (sasl, TRUE);
+ g_free (user);
+
return buf;
}
CamelURL *url;
CamelProvider *provider;
CamelSettings *settings;
- const gchar *host = NULL;
- const gchar *user = NULL;
- const gchar *path = NULL;
+ gchar *host = NULL;
+ gchar *user = NULL;
+ gchar *path = NULL;
guint16 port = 0;
g_return_val_if_fail (CAMEL_IS_SERVICE (service), NULL);
CamelNetworkSettings *network_settings;
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
port = camel_network_settings_get_port (network_settings);
- user = camel_network_settings_get_user (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
}
if (CAMEL_IS_LOCAL_SETTINGS (settings)) {
CamelLocalSettings *local_settings;
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
}
camel_url_set_protocol (url, provider->protocol);
camel_url_set_user (url, user);
camel_url_set_path (url, path);
+ g_free (host);
+ g_free (user);
+ g_free (path);
+
return url;
}
CamelService *service;
CamelSession *session;
CamelImapResponseType type;
- const gchar *host;
- const gchar *user;
gchar *respbuf;
+ gchar *host;
+ gchar *user;
service = CAMEL_SERVICE (store);
session = camel_service_get_session (service);
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
- user = camel_network_settings_get_user (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
if (camel_imap_store_readline (store, &respbuf, cancellable, error) < 0) {
g_static_rec_mutex_unlock (&store->command_and_response_lock);
- return CAMEL_IMAP_RESPONSE_ERROR;
+ type = CAMEL_IMAP_RESPONSE_ERROR;
+ goto exit;
}
switch (*respbuf) {
type == CAMEL_IMAP_RESPONSE_TAGGED)
g_static_rec_mutex_unlock (&store->command_and_response_lock);
+exit:
+ g_free (host);
+ g_free (user);
+
return type;
}
} else {
CamelService *service;
CamelSettings *settings;
- const gchar *junk_path;
- const gchar *trash_path;
gboolean filter_junk;
gboolean filter_junk_inbox;
gboolean folder_is_junk;
gboolean folder_is_trash;
+ gchar *junk_path;
+ gchar *trash_path;
service = CAMEL_SERVICE (parent);
settings = camel_service_get_settings (service);
- junk_path = camel_imap_settings_get_real_junk_path (
+ junk_path = camel_imap_settings_dup_real_junk_path (
CAMEL_IMAP_SETTINGS (settings));
/* So we can safely compare strings. */
if (junk_path == NULL)
- junk_path = "";
+ junk_path = g_strdup ("");
- trash_path = camel_imap_settings_get_real_trash_path (
+ trash_path = camel_imap_settings_dup_real_trash_path (
CAMEL_IMAP_SETTINGS (settings));
/* So we can safely compare strings. */
if (trash_path == NULL)
- trash_path = "";
+ trash_path = g_strdup ("");
filter_junk = camel_imap_settings_get_filter_junk (
CAMEL_IMAP_SETTINGS (settings));
if (folder_is_junk)
folder->folder_flags |= CAMEL_FOLDER_IS_JUNK;
+
+ g_free (junk_path);
+ g_free (trash_path);
}
imap_folder->search = camel_imap_search_new (folder_dir);
CamelNetworkSettings *network_settings;
CamelSettings *settings;
CamelService *service;
- const gchar *host;
+ gboolean is_google;
+ gchar *host;
g_return_val_if_fail (store != NULL, FALSE);
g_return_val_if_fail (CAMEL_IS_STORE (store), FALSE);
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
- return host != NULL && (
+ is_google =
+ (host != NULL) && (
host_ends_with (host, "gmail.com") ||
host_ends_with (host, "googlemail.com"));
+
+ g_free (host);
+
+ return is_google;
}
static void
gboolean success, is_gmail;
CamelFolder *real_junk = NULL;
CamelFolder *real_trash = NULL;
- const gchar *folder_path;
+ gchar *folder_path;
GError *local_error = NULL;
GPtrArray *matches, *summary, *deleted_uids = NULL, *junked_uids = NULL;
max = summary->len;
/* deleted_uids is NULL when not using real trash */
- folder_path = camel_imap_settings_get_real_trash_path (
+ folder_path = camel_imap_settings_dup_real_trash_path (
CAMEL_IMAP_SETTINGS (settings));
if (folder_path != NULL) {
if ((folder->folder_flags & CAMEL_FOLDER_IS_TRASH) != 0) {
}
}
}
+ g_free (folder_path);
if (real_trash)
deleted_uids = g_ptr_array_new ();
/* junked_uids is NULL when not using real junk */
- folder_path = camel_imap_settings_get_real_junk_path (
+ folder_path = camel_imap_settings_dup_real_junk_path (
CAMEL_IMAP_SETTINGS (settings));
if (folder_path != NULL) {
if ((folder->folder_flags & CAMEL_FOLDER_IS_JUNK) != 0) {
}
}
}
+ g_free (folder_path);
if (real_junk)
junked_uids = g_ptr_array_new ();
CamelStore *parent_store;
CamelImapStore *store;
CamelImapResponse *response;
- const gchar *trash_path;
const gchar *full_name;
+ gchar *trash_path;
gchar *uidset;
gint uid = 0, last = 0, i;
GError *local_error = NULL;
gboolean mark_moved;
+ gboolean success = TRUE;
parent_store = camel_folder_get_parent_store (source);
store = CAMEL_IMAP_STORE (parent_store);
service = CAMEL_SERVICE (parent_store);
settings = camel_service_get_settings (service);
- trash_path = camel_imap_settings_get_real_trash_path (
+ trash_path = camel_imap_settings_dup_real_trash_path (
CAMEL_IMAP_SETTINGS (settings));
mark_moved = is_google_account (parent_store) && trash_path != NULL;
if (local_error != NULL) {
g_propagate_error (error, local_error);
- return FALSE;
- }
+ success = FALSE;
/* There is a real trash folder set, which is not on a google account
* and copied messages should be deleted, thus do not move them into
* a trash folder, but just expunge them, because the copy part of
- * the operation was successful.
- */
- if (trash_path && !mark_moved && delete_originals)
+ * the operation was successful. */
+ } else if (trash_path && !mark_moved && delete_originals)
camel_imap_expunge_uids_only (source, uids, cancellable, NULL);
- return TRUE;
+ g_free (trash_path);
+
+ return success;
}
static gboolean
CamelImapFolder *imap_folder = CAMEL_IMAP_FOLDER (folder);
GPtrArray *fetch_data = NULL, *messages = NULL, *needheaders;
CamelFetchHeadersType fetch_headers;
- const gchar * const *extra_headers;
+ gchar **extra_headers;
guint32 flags, uidval;
gint i, seq, first, size, got;
CamelImapResponseType type;
fetch_headers = camel_imap_settings_get_fetch_headers (
CAMEL_IMAP_SETTINGS (settings));
- extra_headers = camel_imap_settings_get_fetch_headers_extra (
+ extra_headers = camel_imap_settings_dup_fetch_headers_extra (
CAMEL_IMAP_SETTINGS (settings));
if (store->server_level >= IMAP_LEVEL_IMAP4REV1) {
} else
header_spec = g_string_new ("0");
+ g_strfreev (extra_headers);
+
d(printf("Header is : %s", header_spec->str));
/* Figure out if any of the new messages are already cached (which
CamelService *service;
CamelSettings *settings;
CamelImapSettings *imap_settings;
- const gchar *real_path;
gboolean use_real_path;
+ gchar *real_path;
/* XXX This only responds to the service's entire settings object
* being replaced, not when individual settings change. When
settings = camel_service_get_settings (service);
imap_settings = CAMEL_IMAP_SETTINGS (settings);
- real_path = camel_imap_settings_get_real_junk_path (imap_settings);
+ real_path = camel_imap_settings_dup_real_junk_path (imap_settings);
use_real_path = camel_imap_settings_get_use_real_junk_path (imap_settings);
if (use_real_path && real_path != NULL) {
store->flags |= CAMEL_STORE_VJUNK;
}
- real_path = camel_imap_settings_get_real_trash_path (imap_settings);
+ g_free (real_path);
+
+ real_path = camel_imap_settings_dup_real_trash_path (imap_settings);
use_real_path = camel_imap_settings_get_use_real_trash_path (imap_settings);
if (use_real_path && real_path != NULL)
store->flags &= ~CAMEL_STORE_VTRASH;
else
store->flags |= CAMEL_STORE_VTRASH;
+
+ g_free (real_path);
}
static void
CamelNetworkSecurityMethod method;
gboolean force_imap4 = FALSE;
gboolean clean_quit = TRUE;
- const gchar *host;
+ gboolean success = TRUE;
+ gchar *host;
gchar *buf;
tcp_stream = camel_network_service_connect_sync (
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
method = camel_network_settings_get_security_method (network_settings);
store->ostream = tcp_stream;
}
store->connected = FALSE;
+ success = FALSE;
- return FALSE;
+ goto exit;
}
if (!strncmp(buf, "* PREAUTH", 9))
}
store->connected = FALSE;
- return FALSE;
+ success = FALSE;
+
+ goto exit;
}
if (force_imap4) {
}
if (method != CAMEL_NETWORK_SECURITY_METHOD_STARTTLS_ON_STANDARD_PORT)
- return TRUE; /* we're done */
+ goto exit; /* we're done */
/* as soon as we send a STARTTLS command, all hope is lost of a clean QUIT if problems arise */
clean_quit = FALSE;
response = camel_imap_command (store, NULL, cancellable, error, "STARTTLS");
if (!response) {
g_object_unref (store->istream);
+ store->istream = NULL;
+
g_object_unref (store->ostream);
- store->istream = store->ostream = NULL;
- return FALSE;
+ store->ostream = NULL;
+
+ success = FALSE;
+
+ goto exit;
}
camel_imap_response_free_without_processing (store, response);
}
store->connected = FALSE;
+ success = FALSE;
- return FALSE;
+ goto exit;
}
if (store->capabilities & IMAP_CAPABILITY_LOGINDISABLED ) {
goto exception;
}
- return TRUE;
+ goto exit;
exception:
store->connected = FALSE;
- return FALSE;
+ success = FALSE;
+
+exit:
+ g_free (host);
+
+ return success;
}
#ifndef G_OS_WIN32
gchar *full_cmd;
gchar *child_env[7];
const gchar *password;
- const gchar *host;
- const gchar *user;
+ gchar *host;
+ gchar *user;
guint16 port;
memset (&url, 0, sizeof (CamelURL));
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
port = camel_network_settings_get_port (network_settings);
- user = camel_network_settings_get_user (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
camel_url_set_protocol (&url, provider->protocol);
camel_url_set_host (&url, host);
g_free (cmd_copy);
+ g_free (host);
+ g_free (user);
+
cmd_stream = camel_stream_process_new ();
ret = camel_stream_process_connect (
GCancellable *cancellable,
GError **error)
{
-#ifndef G_OS_WIN32
CamelSettings *settings;
- const gchar *shell_command;
+ gchar *shell_command;
gboolean use_shell_command;
+ gboolean success;
settings = camel_service_get_settings (service);
- shell_command = camel_imap_settings_get_shell_command (
+ shell_command = camel_imap_settings_dup_shell_command (
CAMEL_IMAP_SETTINGS (settings));
use_shell_command = camel_imap_settings_get_use_shell_command (
CAMEL_IMAP_SETTINGS (settings));
+#ifndef G_OS_WIN32
if (use_shell_command && shell_command != NULL)
- return connect_to_server_process (
+ success = connect_to_server_process (
service, shell_command, cancellable, error);
+ else
+ success = connect_to_server (service, cancellable, error);
+#else
+ success = connect_to_server (service, cancellable, error);
#endif
- return connect_to_server (service, cancellable, error);
+ g_free (shell_command);
+
+ return success;
}
static gboolean
CamelNetworkSettings *network_settings;
CamelSettings *settings;
CamelSession *session;
- const gchar *mechanism;
- const gchar *host;
+ gchar *mechanism;
+ gchar *host;
+ gboolean success = TRUE;
session = camel_service_get_session (service);
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
- mechanism = camel_network_settings_get_auth_mechanism (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
+ mechanism = camel_network_settings_dup_auth_mechanism (network_settings);
if (store->preauthed) {
if (camel_verbose_debug)
fprintf(stderr, "Server %s has preauthenticated us.\n",
host);
- return TRUE;
+ goto exit;
}
if (mechanism != NULL) {
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("IMAP server %s does not support %s "
"authentication"), host, mechanism);
- return FALSE;
+ success = FALSE;
+ goto exit;
}
}
- return camel_session_authenticate_sync (
+ success = camel_session_authenticate_sync (
session, service, mechanism, cancellable, error);
+
+exit:
+ g_free (host);
+ g_free (mechanism);
+
+ return success;
}
static gboolean
{
CamelNetworkSettings *network_settings;
CamelSettings *settings;
- const gchar *host;
- const gchar *user;
+ gchar *host;
+ gchar *user;
+ gchar *name;
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
- user = camel_network_settings_get_user (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
if (brief)
- return g_strdup_printf (
+ name = g_strdup_printf (
_("IMAP server %s"), host);
else
- return g_strdup_printf (
+ name = g_strdup_printf (
_("IMAP service for %s on %s"), user, host);
+
+ g_free (host);
+ g_free (user);
+
+ return name;
}
static gboolean
CamelNetworkSettings *network_settings;
CamelSettings *settings;
const gchar *password;
- const gchar *user;
+ gchar *user;
password = camel_service_get_password (service);
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- user = camel_network_settings_get_user (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
if (user == NULL) {
g_set_error_literal (
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Authentication password not available"));
+ g_free (user);
return CAMEL_AUTHENTICATION_ERROR;
}
if (response != NULL)
camel_imap_response_free (store, response);
+ g_free (user);
+
goto exit;
}
CamelService *service;
CamelSettings *settings;
CamelFolder *folder = NULL;
- const gchar *trash_path;
const gchar *user_cache_dir;
+ gchar *trash_path;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
user_cache_dir = camel_service_get_user_cache_dir (service);
- trash_path = camel_imap_settings_get_real_trash_path (
+ trash_path = camel_imap_settings_dup_real_trash_path (
CAMEL_IMAP_SETTINGS (settings));
if (trash_path != NULL) {
folder = camel_store_get_folder_sync (
camel_imap_settings_set_real_trash_path (
CAMEL_IMAP_SETTINGS (settings), NULL);
}
+ g_free (trash_path);
if (folder)
return folder;
CamelService *service;
CamelSettings *settings;
CamelFolder *folder = NULL;
- const gchar *junk_path;
const gchar *user_cache_dir;
+ gchar *junk_path;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
user_cache_dir = camel_service_get_user_cache_dir (service);
- junk_path = camel_imap_settings_get_real_junk_path (
+ junk_path = camel_imap_settings_dup_real_junk_path (
CAMEL_IMAP_SETTINGS (settings));
if (junk_path != NULL) {
folder = camel_store_get_folder_sync (
camel_imap_settings_set_real_junk_path (
CAMEL_IMAP_SETTINGS (settings), NULL);
}
+ g_free (junk_path);
if (folder)
return folder;
{
CamelService *service;
CamelSettings *settings;
- const gchar *namespace;
+ gchar *namespace;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
- namespace = camel_imap_settings_get_namespace (
+ namespace = camel_imap_settings_dup_namespace (
CAMEL_IMAP_SETTINGS (settings));
- camel_service_lock (
- CAMEL_SERVICE (store), CAMEL_SERVICE_REC_CONNECT_LOCK);
+ camel_service_lock (service, CAMEL_SERVICE_REC_CONNECT_LOCK);
if (!camel_imap_store_connected (store, error))
goto done;
camel_store_summary_save (CAMEL_STORE_SUMMARY (store->summary));
done:
- camel_service_unlock (
- CAMEL_SERVICE (store), CAMEL_SERVICE_REC_CONNECT_LOCK);
+ camel_service_unlock (service, CAMEL_SERVICE_REC_CONNECT_LOCK);
+
+ g_free (namespace);
}
static CamelFolderInfo *
gint i;
CamelImapStoreNamespace *main_ns, *ns;
gboolean use_subscriptions;
- const gchar *junk_path;
- const gchar *trash_path;
+ gchar *junk_path;
+ gchar *trash_path;
if (camel_debug("imap:folder_info"))
printf("get folder info offline\n");
use_subscriptions = camel_imap_settings_get_use_subscriptions (
CAMEL_IMAP_SETTINGS (settings));
- junk_path = camel_imap_settings_get_real_junk_path (
+ junk_path = camel_imap_settings_dup_real_junk_path (
CAMEL_IMAP_SETTINGS (settings));
/* So we can safely compare strings. */
if (junk_path == NULL)
- junk_path = "";
+ junk_path = g_strdup ("");
- trash_path = camel_imap_settings_get_real_trash_path (
+ trash_path = camel_imap_settings_dup_real_trash_path (
CAMEL_IMAP_SETTINGS (settings));
/* So we can safely compare strings. */
if (trash_path == NULL)
- trash_path = "";
+ trash_path = g_strdup ("");
/* FIXME: obey other flags */
g_ptr_array_free (folders, TRUE);
g_free (name);
+ g_free (junk_path);
+ g_free (trash_path);
+
return fi;
}
gchar *full_cmd;
gchar *child_env[7];
const gchar *password;
- const gchar *host;
- const gchar *user;
+ gchar *host;
+ gchar *user;
guint16 port;
memset (&url, 0, sizeof (CamelURL));
g_return_val_if_fail (password != NULL, FALSE);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
port = camel_network_settings_get_port (network_settings);
- user = camel_network_settings_get_user (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
/* Put full details in the environment, in case the connection
* program needs them */
g_free (cmd_copy);
+ g_free (host);
+ g_free (user);
+
cmd_stream = camel_stream_process_new ();
ret = camel_stream_process_connect (
guchar *token;
gint tok;
CamelIMAPXCommand *ic;
- const gchar *host;
+ gboolean success = TRUE;
+ gchar *host;
GError *local_error = NULL;
#ifndef G_OS_WIN32
gboolean use_shell_command;
- const gchar *command = NULL;
+ gchar *shell_command = NULL;
#endif
service = CAMEL_SERVICE (is->store);
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
method = camel_network_settings_get_security_method (network_settings);
#ifndef G_OS_WIN32
CAMEL_IMAPX_SETTINGS (settings));
if (use_shell_command)
- command = camel_imapx_settings_get_shell_command (
+ shell_command = camel_imapx_settings_dup_shell_command (
CAMEL_IMAPX_SETTINGS (settings));
- if (command != NULL) {
- if (!connect_to_server_process (is, command, &local_error))
- goto exit;
- else
+ if (shell_command != NULL) {
+ gboolean success;
+
+ success = connect_to_server_process (
+ is, shell_command, &local_error);
+
+ g_free (shell_command);
+
+ if (success)
goto connected;
+ else
+ goto exit;
}
#endif
tcp_stream = camel_network_service_connect_sync (
CAMEL_NETWORK_SERVICE (is->store), cancellable, error);
- if (tcp_stream == NULL)
- return FALSE;
+ if (tcp_stream == NULL) {
+ success = FALSE;
+ goto exit;
+ }
is->stream = (CamelIMAPXStream *) camel_imapx_stream_new (tcp_stream);
g_object_unref (tcp_stream);
error, G_IO_ERROR,
G_IO_ERROR_CANCELLED,
"Connection to server cancelled\n");
- return FALSE;
+ success = FALSE;
+ goto exit;
}
tok = camel_imapx_stream_token (is->stream, &token, &len, cancellable, error);
- if (tok < 0)
- return FALSE;
+ if (tok < 0) {
+ success = FALSE;
+ goto exit;
+ }
if (tok == '*') {
imapx_untagged (is, cancellable, error);
break;
}
camel_imapx_stream_ungettoken (is->stream, tok, token, len);
- if (camel_imapx_stream_text (is->stream, &token, cancellable, error))
- return FALSE;
+ if (camel_imapx_stream_text (is->stream, &token, cancellable, error)) {
+ success = FALSE;
+ goto exit;
+ }
e(is->tagprefix, "Got unexpected line before greeting: '%s'\n", token);
g_free (token);
}
}
imapx_command_unref (ic);
- return FALSE;
+ success = FALSE;
+
+ goto exit;
}
imapx_command_unref (ic);
}
is->cinfo = NULL;
}
- return FALSE;
+ success = FALSE;
}
- return TRUE;
+ g_free (host);
+
+ return success;
}
CamelAuthenticationResult
CamelIMAPXCommand *ic;
CamelService *service;
CamelSasl *sasl = NULL;
- const gchar *host;
- const gchar *user;
+ gchar *host;
+ gchar *user;
g_return_val_if_fail (
CAMEL_IS_IMAPX_SERVER (is),
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
- user = camel_network_settings_get_user (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
if (mechanism != NULL) {
if (!g_hash_table_lookup (is->cinfo->auth_types, mechanism)) {
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("IMAP server %s does not support %s "
"authentication"), host, mechanism);
- return CAMEL_AUTHENTICATION_ERROR;
+ result = CAMEL_AUTHENTICATION_ERROR;
+ goto exit;
}
sasl = camel_sasl_new ("imap", mechanism, service);
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("No support for %s authentication"),
mechanism);
- return CAMEL_AUTHENTICATION_ERROR;
+ result = CAMEL_AUTHENTICATION_ERROR;
+ goto exit;
}
}
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Cannot authenticate without a username"));
- return CAMEL_AUTHENTICATION_ERROR;
+ result = CAMEL_AUTHENTICATION_ERROR;
+ goto exit;
}
if (password == NULL) {
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Authentication password not available"));
- return CAMEL_AUTHENTICATION_ERROR;
+ result = CAMEL_AUTHENTICATION_ERROR;
+ goto exit;
}
ic = imapx_command_new (
if (sasl != NULL)
g_object_unref (sasl);
+exit:
+ g_free (host);
+ g_free (user);
+
return result;
}
CamelService *service;
CamelSession *session;
CamelSettings *settings;
- const gchar *mechanism;
+ gchar *mechanism;
gboolean use_idle;
gboolean use_qresync;
session = camel_service_get_session (service);
settings = camel_service_get_settings (service);
- mechanism = camel_network_settings_get_auth_mechanism (
+ mechanism = camel_network_settings_dup_auth_mechanism (
CAMEL_NETWORK_SETTINGS (settings));
use_idle = camel_imapx_settings_get_use_idle (
}
is->state = IMAPX_INITIALISED;
+
+ g_free (mechanism);
+
return TRUE;
exception:
is->cinfo = NULL;
}
+ g_free (mechanism);
+
return FALSE;
}
{
CamelNetworkSettings *network_settings;
CamelSettings *settings;
- const gchar *host;
- const gchar *user;
+ gchar *host;
+ gchar *user;
+ gchar *name;
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
- user = camel_network_settings_get_user (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
if (brief)
- return g_strdup_printf (
+ name = g_strdup_printf (
_("IMAP server %s"), host);
else
- return g_strdup_printf (
+ name = g_strdup_printf (
_("IMAP service for %s on %s"), user, host);
+
+ g_free (host);
+ g_free (user);
+
+ return name;
}
CamelIMAPXServer *
/* get starting point */
if (top[0] == 0) {
- const gchar *namespace = NULL;
+ gchar *namespace = NULL;
if (use_namespace)
- namespace = camel_imapx_settings_get_namespace (
+ namespace = camel_imapx_settings_dup_namespace (
CAMEL_IMAPX_SETTINGS (settings));
if (namespace != NULL) {
top = imapx_store->summary->namespaces->personal->path;
} else
name = g_strdup("");
+
+ g_free (namespace);
} else {
name = camel_imapx_store_summary_full_from_path (imapx_store->summary, top);
if (name == NULL)
{
CamelLocalSettings *local_settings;
CamelSettings *settings;
- const gchar *path;
+ gchar *path;
+ gchar *name;
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
if (brief)
- return g_strdup (path);
+ name = g_strdup (path);
else
- return g_strdup_printf (_("Local mail file %s"), path);
+ name = g_strdup_printf (_("Local mail file %s"), path);
+
+ g_free (path);
+
+ return name;
}
static gboolean
CamelLocalSettings *local_settings;
CamelSettings *settings;
CamelService *service;
- const gchar *path;
+ CamelFolder *folder = NULL;
struct stat st;
+ gchar *path;
service = CAMEL_SERVICE (store);
settings= camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
if (!g_path_is_absolute (path)) {
g_set_error (
error, CAMEL_STORE_ERROR,
CAMEL_STORE_ERROR_NO_FOLDER,
_("Store root %s is not an absolute path"), path);
- return NULL;
+ goto exit;
}
if (g_stat (path, &st) == 0) {
_("Store root %s is not a regular directory"), path);
return NULL;
}
- return (CamelFolder *) 0xdeadbeef;
+ folder = (CamelFolder *) 0xdeadbeef;
+ goto exit;
}
if (errno != ENOENT
g_io_error_from_errno (errno),
_("Cannot get folder: %s: %s"),
path, g_strerror (errno));
- return NULL;
+ goto exit;
}
/* need to create the dir heirarchy */
g_io_error_from_errno (errno),
_("Cannot get folder: %s: %s"),
path, g_strerror (errno));
- return NULL;
+ goto exit;
}
- return (CamelFolder *) 0xdeadbeef;
+ folder = (CamelFolder *) 0xdeadbeef;
+
+exit:
+ g_free (path);
+
+ return folder;
}
static CamelFolderInfo *
CamelService *service;
CamelFolder *folder;
CamelFolderInfo *info = NULL;
- const gchar *path;
- gchar *name;
+ gchar *name = NULL;
+ gchar *path;
struct stat st;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
/* This is a pretty hacky version of create folder, but should basically work */
error, CAMEL_STORE_ERROR,
CAMEL_STORE_ERROR_NO_FOLDER,
_("Store root %s is not an absolute path"), path);
- return NULL;
+ goto exit;
}
if (parent_name)
g_io_error_from_errno (errno),
_("Cannot get folder: %s: %s"),
name, g_strerror (errno));
- g_free (name);
- return NULL;
+ goto exit;
}
g_free (name);
store, name, 0, cancellable, error);
}
+exit:
g_free (name);
+ g_free (path);
return info;
}
CamelService *service;
CamelFolderInfo *fi;
CamelFolder *lf;
- const gchar *path;
+ gchar *str = NULL;
gchar *name;
- gchar *str;
+ gchar *path;
+ gboolean success = TRUE;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
/* remove metadata only */
name = g_build_filename (path, folder_name, NULL);
- str = g_strdup_printf("%s.ibex", name);
+ str = g_strdup_printf ("%s.ibex", name);
if (camel_text_index_remove (str) == -1 && errno != ENOENT && errno != ENOTDIR) {
g_set_error (
error, G_IO_ERROR,
g_io_error_from_errno (errno),
_("Could not delete folder index file '%s': %s"),
str, g_strerror (errno));
- g_free (str);
- g_free (name);
- return FALSE;
+ success = FALSE;
+ goto exit;
}
- g_free (str);
+ g_free (str);
str = NULL;
+
if ((lf = camel_store_get_folder_sync (store, folder_name, 0, cancellable, NULL))) {
CamelObject *object = CAMEL_OBJECT (lf);
const gchar *state_filename;
g_io_error_from_errno (errno),
_("Could not delete folder meta file '%s': %s"),
str, g_strerror (errno));
- g_free (name);
- g_free (str);
- return FALSE;
+ success = FALSE;
+ goto exit;
}
- g_free (str);
- g_free (name);
-
fi = camel_folder_info_new ();
fi->full_name = g_strdup (folder_name);
fi->display_name = g_path_get_basename (folder_name);
camel_store_folder_deleted (store, fi);
camel_folder_info_free (fi);
- return TRUE;
+exit:
+ g_free (name);
+ g_free (path);
+ g_free (str);
+
+ return success;
}
/* default implementation, rename all */
CamelLocalSettings *local_settings;
CamelSettings *settings;
CamelService *service;
- const gchar *path;
gchar *old_basename;
gchar *new_basename;
gchar *newibex;
gchar *oldibex;
+ gchar *path;
+ gboolean success = TRUE;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
old_basename = g_strdup_printf ("%s.ibex", old);
new_basename = g_strdup_printf ("%s.ibex", new);
if (folder)
g_object_unref (folder);
- return TRUE;
+ goto exit;
/* The (f)utility of this recovery effort is quesitonable */
if (folder)
g_object_unref (folder);
- return FALSE;
+ success = FALSE;
+
+exit:
+ g_free (path);
+
+ return success;
}
static gchar *
CamelLocalSettings *local_settings;
CamelSettings *settings;
CamelService *service;
- const gchar *path;
+ gchar *filename;
+ gchar *path;
service = CAMEL_SERVICE (ls);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
+
+ filename = g_build_filename (path, full_name, NULL);
- return g_build_filename (path, full_name, NULL);
+ g_free (path);
+
+ return filename;
}
static gchar *
CamelLocalSettings *local_settings;
CamelSettings *settings;
CamelService *service;
- const gchar *path;
gchar *basename;
gchar *filename;
+ gchar *path;
service = CAMEL_SERVICE (ls);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
basename = g_strconcat (full_name, ext, NULL);
filename = g_build_filename (path, basename, NULL);
g_free (basename);
+ g_free (path);
+
return filename;
}
CamelService *service;
CamelFolder *folder;
CamelFolderInfo *info = NULL;
- const gchar *path;
- gchar *name;
+ gchar *name = NULL;
+ gchar *path;
struct stat st;
/* This is a pretty hacky version of create folder, but should basically work */
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
if (!g_path_is_absolute (path)) {
g_set_error (
error, CAMEL_STORE_ERROR,
CAMEL_STORE_ERROR_NO_FOLDER,
_("Store root %s is not an absolute path"), path);
- return NULL;
+ goto exit;
}
if (g_strstr_len (folder_name, -1, ".")) {
g_set_error (
error, CAMEL_STORE_ERROR,
CAMEL_STORE_ERROR_NO_FOLDER,
- _("Cannot create folder: %s : Folder name cannot contain a dot"), folder_name);
- return NULL;
-
+ _("Cannot create folder: %s: "
+ "Folder name cannot contain a dot"),
+ folder_name);
+ goto exit;
}
if (!g_ascii_strcasecmp (folder_name, "Inbox")) {
error, CAMEL_STORE_ERROR,
CAMEL_STORE_ERROR_NO_FOLDER,
_("Folder %s already exists"), folder_name);
- return NULL;
+ goto exit;
}
if (parent_name && *parent_name) {
g_io_error_from_errno (errno),
_("Cannot get folder: %s: %s"),
name, g_strerror (errno));
- g_free (name);
- return NULL;
+ goto exit;
}
g_free (name);
+ name = NULL;
if (parent_name && *parent_name)
name = g_strdup_printf("%s/%s", parent_name, folder_name);
else
name = g_strdup_printf("%s", folder_name);
- folder = maildir_store_get_folder_sync (store, name, CAMEL_STORE_FOLDER_CREATE, cancellable, error);
+ folder = maildir_store_get_folder_sync (
+ store, name, CAMEL_STORE_FOLDER_CREATE, cancellable, error);
if (folder) {
g_object_unref (folder);
info = CAMEL_STORE_GET_CLASS (store)->get_folder_info_sync (
store, name, 0, cancellable, error);
}
+exit:
g_free (name);
+ g_free (path);
return info;
}
CamelLocalSettings *local_settings;
CamelSettings *settings;
CamelService *service;
- const gchar *path;
gchar *name, *tmp, *cur, *new, *dir_name;
+ gchar *path;
struct stat st;
CamelFolder *folder = NULL;
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
folder_name = md_canon_name (folder_name);
dir_name = maildir_full_name_to_dir_name (folder_name);
+ /* maildir++ directory names start with a '.' */
+ name = g_build_filename (path, dir_name, NULL);
+
+ g_free (dir_name);
+ g_free (path);
+
/* Chain up to parent's get_folder() method. */
store_class = CAMEL_STORE_CLASS (camel_maildir_store_parent_class);
if (!store_class->get_folder_sync (store, dir_name, flags, cancellable, error)) {
- g_free (dir_name);
+ g_free (name);
return NULL;
}
- /* maildir++ directory names start with a '.' */
- name = g_build_filename (path, dir_name, NULL);
- g_free (dir_name);
-
- tmp = g_strdup_printf("%s/tmp", name);
- cur = g_strdup_printf("%s/cur", name);
- new = g_strdup_printf("%s/new", name);
+ tmp = g_strdup_printf ("%s/tmp", name);
+ cur = g_strdup_printf ("%s/cur", name);
+ new = g_strdup_printf ("%s/new", name);
if (!g_ascii_strcasecmp (folder_name, "Inbox")) {
/* special case "." (aka inbox), may need to be created */
CamelLocalSettings *local_settings;
CamelSettings *settings;
CamelService *service;
- const gchar *path;
gchar *name, *tmp, *cur, *new, *dir_name;
+ gchar *path;
struct stat st;
gboolean success = TRUE;
- service = CAMEL_SERVICE (store);
- settings = camel_service_get_settings (service);
-
- local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
-
if (g_ascii_strcasecmp (folder_name, "Inbox") == 0) {
g_set_error (
error, CAMEL_STORE_ERROR,
return FALSE;
}
+ service = CAMEL_SERVICE (store);
+ settings = camel_service_get_settings (service);
+
+ local_settings = CAMEL_LOCAL_SETTINGS (settings);
+ path = camel_local_settings_dup_path (local_settings);
+
/* maildir++ directory names start with a '.' */
dir_name = maildir_full_name_to_dir_name (folder_name);
name = g_build_filename (path, dir_name, NULL);
g_free (dir_name);
- tmp = g_strdup_printf("%s/tmp", name);
- cur = g_strdup_printf("%s/cur", name);
- new = g_strdup_printf("%s/new", name);
+ g_free (path);
+
+ tmp = g_strdup_printf ("%s/tmp", name);
+ cur = g_strdup_printf ("%s/cur", name);
+ new = g_strdup_printf ("%s/new", name);
if (g_stat (name, &st) == -1 || !S_ISDIR (st.st_mode)
|| g_stat (tmp, &st) == -1 || !S_ISDIR (st.st_mode)
CamelService *service;
gchar *folderpath, *dir_name;
CamelFolderSummary *s;
- const gchar *root;
+ gchar *root;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- root = camel_local_settings_get_path (local_settings);
+ root = camel_local_settings_dup_path (local_settings);
/* This should be fast enough not to have to test for INFO_FAST */
dir_name = maildir_full_name_to_dir_name (fi->full_name);
else
folderpath = g_build_filename (root, dir_name, NULL);
+ g_free (root);
+
s = (CamelFolderSummary *) camel_maildir_summary_new (NULL, folderpath, NULL);
if (camel_folder_summary_header_load_from_db (s, store, fi->full_name, NULL)) {
fi->unread = camel_folder_summary_get_unread_count (s);
CamelService *service;
CamelFolderInfo *fi;
gchar *tmp, *cur, *new, *dir_name;
- const gchar *path;
+ gchar *path;
struct stat st;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
g_return_val_if_fail (path != NULL, NULL);
fi = camel_folder_info_new ();
fill_fi (store, fi, flags, cancellable);
+ g_free (path);
+
return fi;
}
CamelLocalSettings *local_settings;
CamelSettings *settings;
CamelService *service;
- const gchar *path;
GPtrArray *folders;
gint res = -1;
DIR *dir;
struct dirent *d;
gchar *meta_path = NULL;
+ gchar *path;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
g_return_val_if_fail (path != NULL, -1);
folders = g_ptr_array_new ();
g_io_error_from_errno (errno),
_("Could not scan folder '%s': %s"),
path, g_strerror (errno));
- goto fail;
+ goto exit;
}
meta_path = maildir_get_meta_path ((CamelLocalStore *) store, ".", "maildir++");
} else
res = -1;
-fail:
+exit:
g_ptr_array_free (folders, TRUE);
+ g_free (path);
+
return res;
}
CamelLocalSettings *local_settings;
CamelSettings *settings;
CamelService *service;
- const gchar *path;
gchar *filename;
gchar *dir_name;
+ gchar *path;
service = CAMEL_SERVICE (ls);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
dir_name = maildir_full_name_to_dir_name (full_name);
filename = g_build_filename (path, dir_name, NULL);
g_free (dir_name);
+ g_free (path);
+
return filename;
}
CamelLocalSettings *local_settings;
CamelSettings *settings;
CamelService *service;
- const gchar *path;
gchar *filename;
gchar *dir_name;
+ gchar *path;
gchar *tmp;
service = CAMEL_SERVICE (ls);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
dir_name = maildir_full_name_to_dir_name (full_name);
tmp = g_build_filename (path, dir_name, NULL);
g_free (tmp);
g_free (dir_name);
+ g_free (path);
+
return filename;
}
CamelService *service;
CamelDList queue = CAMEL_DLIST_INITIALISER (queue);
struct _scan_node *sn;
- const gchar *path;
+ gchar *path;
gchar *tmp;
GHashTable *visited;
struct stat st;
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
visited = g_hash_table_new (scan_hash, scan_equal);
g_io_error_from_errno (errno),
_("Could not scan folder '%s': %s"),
path, g_strerror (errno));
-
- goto fail;
+ goto exit;
}
while ((d = readdir (dir))) {
}
res = 0;
-fail:
+
+exit:
g_hash_table_foreach (visited, scan_free, NULL);
g_hash_table_destroy (visited);
+ g_free (path);
+
return res;
}
CamelFolderInfo *info = NULL;
CamelSettings *settings;
CamelService *service;
- const gchar *root_path;
- gchar *path, *name, *dir;
+ gchar *root_path = NULL;
+ gchar *name = NULL;
+ gchar *path = NULL;
+ gchar *dir;
CamelFolder *folder;
struct stat st;
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- root_path = camel_local_settings_get_path (local_settings);
+ root_path = camel_local_settings_dup_path (local_settings);
local_store = CAMEL_LOCAL_STORE (store);
CAMEL_STORE_ERROR_NO_FOLDER,
_("Store root %s is not an absolute path"),
root_path);
- return NULL;
+ goto exit;
}
if (folder_name[0] == '.' || ignore_file (folder_name, TRUE)) {
g_set_error (
error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
_("Cannot create a folder by this name."));
- return NULL;
+ goto exit;
}
if (parent_name && *parent_name)
g_io_error_from_errno (errno),
_("Cannot create directory '%s': %s."),
dir, g_strerror (errno));
-
- g_free (path);
- g_free (name);
g_free (dir);
-
- return NULL;
+ goto exit;
}
g_free (dir);
_("Cannot create folder: %s: %s"),
path, errno ? g_strerror (errno) :
_("Folder already exists"));
-
- g_free (path);
- g_free (name);
-
- return NULL;
+ goto exit;
}
- g_free (path);
-
folder = CAMEL_STORE_GET_CLASS (store)->get_folder_sync (
store, name, CAMEL_STORE_FOLDER_CREATE, cancellable, error);
if (folder) {
store, name, 0, cancellable, error);
}
+exit:
+ g_free (root_path);
g_free (name);
+ g_free (path);
return info;
}
CamelSettings *settings;
CamelService *service;
const gchar *inptr = full_name;
- const gchar *root_path;
gint subdirs = 0;
+ gchar *root_path;
gchar *path, *p;
service = CAMEL_SERVICE (ls);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- root_path = camel_local_settings_get_path (local_settings);
+ root_path = camel_local_settings_dup_path (local_settings);
g_return_val_if_fail (root_path != NULL, NULL);
while (*inptr != '\0') {
path = g_malloc (strlen (root_path) + (inptr - full_name) + (4 * subdirs) + 1);
p = g_stpcpy (path, root_path);
+ g_free (root_path);
+
inptr = full_name;
while (*inptr != '\0') {
while (!G_IS_DIR_SEPARATOR (*inptr) && *inptr != '\0')
CamelLocalSettings *local_settings;
CamelSettings *settings;
CamelService *service;
- gchar *folderpath;
CamelFolderSummary *s;
- const gchar *path;
+ gchar *folderpath;
+ gchar *path;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
/* This should be fast enough not to have to test for INFO_FAST */
- /* We could: if we have no folder, and FAST isn't specified, perform a full
- * scan of all messages for their status flags. But its probably not worth
- * it as we need to read the top of every file, i.e. very very slow */
+ /* We could: if we have no folder, and FAST isn't specified,
+ * perform a full scan of all messages for their status flags.
+ * But its probably not worth it as we need to read the top of
+ * every file, i.e. very very slow */
folderpath = g_strdup_printf ("%s/%s", path, fi->full_name);
s = (CamelFolderSummary *) camel_mh_summary_new (
}
g_object_unref (s);
g_free (folderpath);
+
+ g_free (path);
}
if (camel_local_store_is_main_store (local_store) && fi->full_name
CamelLocalSettings *local_settings;
CamelSettings *settings;
CamelService *service;
+ CamelFolder *folder = NULL;
gboolean use_dot_folders;
- const gchar *path;
- gchar *name;
struct stat st;
+ gchar *name;
+ gchar *path;
+
+ /* Chain up to parent's get_folder() method. */
+ store_class = CAMEL_STORE_CLASS (camel_mh_store_parent_class);
+ if (store_class->get_folder_sync (
+ store, folder_name, flags, cancellable, error) == NULL)
+ return NULL;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
use_dot_folders = camel_mh_settings_get_use_dot_folders (
CAMEL_MH_SETTINGS (settings));
- /* Chain up to parent's get_folder() method. */
- store_class = CAMEL_STORE_CLASS (camel_mh_store_parent_class);
- if (store_class->get_folder_sync (
- store, folder_name, flags, cancellable, error) == NULL)
- return NULL;
-
name = g_build_filename (path, folder_name, NULL);
if (g_stat (name, &st) == -1) {
g_io_error_from_errno (errno),
_("Cannot get folder '%s': %s"),
folder_name, g_strerror (errno));
- g_free (name);
- return NULL;
+ goto exit;
}
+
if ((flags & CAMEL_STORE_FOLDER_CREATE) == 0) {
g_set_error (
error, CAMEL_STORE_ERROR,
_("Cannot get folder '%s': "
"folder does not exist."),
folder_name);
- g_free (name);
- return NULL;
+ goto exit;
}
if (g_mkdir (name, 0777) != 0) {
g_io_error_from_errno (errno),
_("Could not create folder '%s': %s"),
folder_name, g_strerror (errno));
- g_free (name);
- return NULL;
+ goto exit;
}
/* add to .folders if we are supposed to */
CAMEL_STORE_ERROR_NO_FOLDER,
_("Cannot get folder '%s': not a directory."),
folder_name);
- g_free (name);
- return NULL;
+ goto exit;
} else if (flags & CAMEL_STORE_FOLDER_EXCL) {
g_set_error (
error, CAMEL_ERROR, CAMEL_ERROR_GENERIC,
_("Cannot create folder '%s': folder exists."),
folder_name);
- g_free (name);
- return NULL;
+ goto exit;
}
+ folder = camel_mh_folder_new (
+ store, folder_name, flags, cancellable, error);
+
+exit:
g_free (name);
+ g_free (path);
- return camel_mh_folder_new (
- store, folder_name, flags, cancellable, error);
+ return folder;
}
static CamelFolderInfo *
CamelSettings *settings;
CamelFolderInfo *fi = NULL;
gboolean use_dot_folders;
- const gchar *path;
+ gchar *path;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
use_dot_folders = camel_mh_settings_get_use_dot_folders (
CAMEL_MH_SETTINGS (settings));
g_hash_table_destroy (visited);
}
+ g_free (path);
+
return fi;
}
CamelSettings *settings;
CamelService *service;
gboolean use_dot_folders;
- const gchar *path;
gchar *name;
+ gchar *path;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
use_dot_folders = camel_mh_settings_get_use_dot_folders (
CAMEL_MH_SETTINGS (settings));
_("Could not delete folder '%s': %s"),
folder_name, g_strerror (errno));
g_free (name);
+ g_free (path);
return FALSE;
}
g_free (name);
path, UPDATE_REMOVE, folder_name,
NULL, cancellable);
+ g_free (path);
+
/* Chain up to parent's delete_folder() method. */
store_class = CAMEL_STORE_CLASS (camel_mh_store_parent_class);
return store_class->delete_folder_sync (
CamelSettings *settings;
CamelService *service;
gboolean use_dot_folders;
- const gchar *path;
+ gboolean success;
+ gchar *path;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
use_dot_folders = camel_mh_settings_get_use_dot_folders (
CAMEL_MH_SETTINGS (settings));
/* Chain up to parent's rename_folder() method. */
store_class = CAMEL_STORE_CLASS (camel_mh_store_parent_class);
- if (!store_class->rename_folder_sync (
- store, old, new, cancellable, error))
- return FALSE;
+ success = store_class->rename_folder_sync (
+ store, old, new, cancellable, error);
- if (use_dot_folders) {
+ if (success && use_dot_folders) {
/* yeah this is messy, but so is mh! */
folders_update (
path, UPDATE_RENAME, old, new, cancellable);
}
- return TRUE;
+ g_free (path);
+
+ return success;
}
static void
CamelLocalSettings *local_settings;
CamelSettings *settings;
CamelService *service;
- const gchar *path;
+ camel_spool_store_t type;
struct stat st;
+ gchar *path;
service = CAMEL_SERVICE (spool_store);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
/* Check the path for validity while we have the opportunity. */
CAMEL_STORE_ERROR_NO_FOLDER,
_("Store root %s is not an absolute path"),
(path != NULL) ? path : "(null)");
- return CAMEL_SPOOL_STORE_INVALID;
- }
+ type = CAMEL_SPOOL_STORE_INVALID;
- if (g_stat (path, &st) == -1) {
+ } else if (g_stat (path, &st) == -1) {
g_set_error (
error, G_IO_ERROR,
g_io_error_from_errno (errno),
_("Spool '%s' cannot be opened: %s"),
path, g_strerror (errno));
- return CAMEL_SPOOL_STORE_INVALID;
- }
+ type = CAMEL_SPOOL_STORE_INVALID;
- if (S_ISREG (st.st_mode))
- return CAMEL_SPOOL_STORE_MBOX;
+ } else if (S_ISREG (st.st_mode)) {
+ type = CAMEL_SPOOL_STORE_MBOX;
- if (S_ISDIR (st.st_mode))
- return CAMEL_SPOOL_STORE_ELM;
+ } else if (S_ISDIR (st.st_mode)) {
+ type = CAMEL_SPOOL_STORE_ELM;
- g_set_error (
- error, CAMEL_STORE_ERROR,
- CAMEL_STORE_ERROR_NO_FOLDER,
- _("Spool '%s' is not a regular file or directory"), path);
+ } else {
+ g_set_error (
+ error, CAMEL_STORE_ERROR,
+ CAMEL_STORE_ERROR_NO_FOLDER,
+ _("Spool '%s' is not a regular file or directory"),
+ path);
+ type = CAMEL_SPOOL_STORE_INVALID;
+ }
- return CAMEL_SPOOL_STORE_INVALID;
+ g_free (path);
+
+ return type;
}
/* partially copied from mbox */
CamelService *service;
CamelFolderInfo *fi = NULL;
GHashTable *visited;
- const gchar *path;
-
- visited = g_hash_table_new (inode_hash, inode_equal);
+ gchar *path;
service = CAMEL_SERVICE (store);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
+
+ visited = g_hash_table_new (inode_hash, inode_equal);
- if (scan_dir (store, visited, path, top, flags, NULL, &fi, cancellable, error) == -1 && fi != NULL) {
+ if (scan_dir (
+ store, visited, path, top, flags,
+ NULL, &fi, cancellable, error) == -1 && fi != NULL) {
camel_store_free_folder_info_full (store, fi);
fi = NULL;
}
g_hash_table_foreach (visited, inode_free, NULL);
g_hash_table_destroy (visited);
+ g_free (path);
+
return fi;
}
CamelLocalSettings *local_settings;
CamelSpoolStore *spool_store;
CamelSettings *settings;
- const gchar *path;
gchar *name;
+ gchar *path;
spool_store = CAMEL_SPOOL_STORE (service);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
if (brief)
- return g_strdup (path);
+ return path;
switch (spool_store_get_type (spool_store, NULL)) {
case CAMEL_SPOOL_STORE_MBOX:
break;
}
+ g_free (path);
+
return name;
}
CamelFolder *folder = NULL;
camel_spool_store_t type;
struct stat st;
- const gchar *path;
gchar *name;
+ gchar *path;
d(printf("opening folder %s on path %s\n", folder_name, path));
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
/* we only support an 'INBOX' in mbox mode */
if (type == CAMEL_SPOOL_STORE_MBOX) {
g_free (name);
}
+ g_free (path);
+
return folder;
}
CamelSpoolStore *spool_store;
CamelSettings *settings;
CamelService *service;
- const gchar *path;
gchar *full_path;
+ gchar *path;
service = CAMEL_SERVICE (local_store);
settings = camel_service_get_settings (service);
local_settings = CAMEL_LOCAL_SETTINGS (settings);
- path = camel_local_settings_get_path (local_settings);
+ path = camel_local_settings_dup_path (local_settings);
spool_store = CAMEL_SPOOL_STORE (local_store);
break;
}
+ g_free (path);
+
return full_path;
}
CamelSession *session;
CamelStream *tcp_stream;
const gchar *user_cache_dir;
- const gchar *host;
- const gchar *user;
gboolean retval = FALSE;
guchar *buf;
guint len;
+ gchar *host;
gchar *path;
+ gchar *user;
session = camel_service_get_session (service);
settings = camel_service_get_settings (service);
user_cache_dir = camel_service_get_user_cache_dir (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
- user = camel_network_settings_get_user (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
camel_service_lock (service, CAMEL_SERVICE_REC_CONNECT_LOCK);
g_free (store->current_folder);
store->current_folder = NULL;
- fail:
+fail:
camel_service_unlock (service, CAMEL_SERVICE_REC_CONNECT_LOCK);
+
+ g_free (host);
+ g_free (user);
+
return retval;
}
{
CamelNetworkSettings *network_settings;
CamelSettings *settings;
- const gchar *host;
+ gchar *host;
+ gchar *name;
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
if (brief)
- return g_strdup_printf ("%s", host);
+ name = g_strdup_printf ("%s", host);
else
- return g_strdup_printf (_("USENET News via %s"), host);
+ name = g_strdup_printf (_("USENET News via %s"), host);
+ g_free (host);
+
+ return name;
}
extern CamelServiceAuthType camel_nntp_password_authtype;
CamelNNTPStore *store;
CamelAuthenticationResult result;
const gchar *password;
- const gchar *user;
gchar *line = NULL;
+ gchar *user;
gint status;
store = CAMEL_NNTP_STORE (service);
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- user = camel_network_settings_get_user (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
if (user == NULL) {
g_set_error_literal (
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Cannot authenticate without a username"));
- return CAMEL_AUTHENTICATION_ERROR;
+ result = CAMEL_AUTHENTICATION_ERROR;
+ goto exit;
}
if (password == NULL) {
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Authentication password not available"));
- return CAMEL_AUTHENTICATION_ERROR;
+ result = CAMEL_AUTHENTICATION_ERROR;
+ goto exit;
}
/* XXX Currently only authinfo user/pass is supported. */
break;
}
+exit:
+ g_free (user);
+
return result;
}
CamelFolderSummary *s;
CamelMessageInfoBase *mi;
struct _camel_header_raw *headers = NULL;
- const gchar *host;
gchar *line, *tab;
+ gchar *host;
guint len;
gint ret;
guint n, count, total, size;
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
camel_operation_push_message (
cancellable, _("%s: Scanning new messages"), host);
+ g_free (host);
+
if ((store->capabilities & NNTP_CAPABILITY_OVER) != 0)
ret = camel_nntp_raw_command_auth (store, cancellable, error, &line, "over %r", low, high);
else
guint i, n, count, total;
CamelMessageInfo *mi;
CamelMimeParser *mp;
- const gchar *host;
+ gchar *host;
s = (CamelFolderSummary *) cns;
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
camel_operation_push_message (
cancellable, _("%s: Scanning new messages"), host);
+ g_free (host);
+
count = 0;
total = high - low + 1;
for (i = low; i < high + 1; i++) {
CamelStream *tcp_stream;
CamelPOP3Command *pc;
gboolean disable_extensions;
- const gchar *host;
+ gboolean success = TRUE;
+ gchar *host;
guint32 flags = 0;
gint clean_quit = TRUE;
gint ret;
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
tcp_stream = camel_network_service_connect_sync (
CAMEL_NETWORK_SERVICE (service), cancellable, error);
- if (tcp_stream == NULL)
- return FALSE;
+ if (tcp_stream == NULL) {
+ success = FALSE;
+ goto exit;
+ }
/* parent class connect initialization */
if (CAMEL_SERVICE_CLASS (camel_pop3_store_parent_class)->
connect_sync (service, cancellable, error) == FALSE) {
g_object_unref (tcp_stream);
- return FALSE;
+ success = FALSE;
+ goto exit;
}
disable_extensions = camel_pop3_settings_get_disable_extensions (
_("Failed to read a valid greeting from POP server %s"),
host);
g_object_unref (tcp_stream);
- return FALSE;
+ success = FALSE;
+ goto exit;
}
g_object_get (settings, "security-method", &method, NULL);
if (method != CAMEL_NETWORK_SECURITY_METHOD_STARTTLS_ON_STANDARD_PORT) {
g_object_unref (tcp_stream);
- return TRUE;
+ goto exit;
}
/* as soon as we send a STLS command, all hope is lost of a clean QUIT if problems arise */
* command, the client MUST discard prior CAPA responses */
camel_pop3_engine_reget_capabilities (store->engine, cancellable);
- return TRUE;
+ goto exit;
- stls_exception:
+stls_exception:
if (clean_quit) {
/* try to disconnect cleanly */
pc = camel_pop3_engine_command_new (store->engine, 0, NULL, NULL, cancellable, NULL, "QUIT\r\n");
g_object_unref (tcp_stream);
store->engine = NULL;
- return FALSE;
+ success = FALSE;
+
+exit:
+ g_free (host);
+
+ return success;
}
static CamelAuthenticationResult
CamelSettings *settings;
CamelService *service;
guchar *line, *resp;
- const gchar *host;
- CamelSasl *sasl;
+ CamelSasl *sasl = NULL;
gchar *string;
+ gchar *host;
guint len;
gint ret;
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
sasl = camel_sasl_new ("pop", mechanism, service);
if (sasl == NULL) {
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_URL_INVALID,
_("No support for %s authentication"), mechanism);
- return CAMEL_AUTHENTICATION_ERROR;
+ result = CAMEL_AUTHENTICATION_ERROR;
+ goto exit;
}
string = g_strdup_printf ("AUTH %s\r\n", mechanism);
_("Cannot login to POP server %s: "
"SASL Protocol error"), host);
result = CAMEL_AUTHENTICATION_ERROR;
- goto done;
+ goto exit;
}
string = g_strdup_printf ("%s\r\n", resp);
}
- goto done;
+ goto exit;
ioerror:
g_prefix_error (
error, _("Failed to authenticate on POP server %s: "), host);
result = CAMEL_AUTHENTICATION_ERROR;
-done:
- g_object_unref (sasl);
+exit:
+ if (sasl != NULL)
+ g_object_unref (sasl);
+
+ g_free (host);
return result;
}
{
CamelNetworkSettings *network_settings;
CamelSettings *settings;
- const gchar *host;
- const gchar *user;
+ gchar *host;
+ gchar *user;
+ gchar *name;
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
- user = camel_network_settings_get_user (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
if (brief)
- return g_strdup_printf (
+ name = g_strdup_printf (
_("POP3 server %s"), host);
else
- return g_strdup_printf (
+ name = g_strdup_printf (
_("POP3 server for %s on %s"), user, host);
+
+ g_free (host);
+ g_free (user);
+
+ return name;
}
static gboolean
CamelPOP3Store *store = (CamelPOP3Store *) service;
CamelSettings *settings;
CamelSession *session;
- const gchar *mechanism;
const gchar *user_data_dir;
- gboolean success;
+ gboolean success = TRUE;
+ gchar *mechanism;
session = camel_service_get_session (service);
settings = camel_service_get_settings (service);
user_data_dir = camel_service_get_user_data_dir (service);
+ mechanism = camel_network_settings_dup_auth_mechanism (
+ CAMEL_NETWORK_SETTINGS (settings));
+
if (!camel_session_get_online (session)) {
g_set_error (
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_UNAVAILABLE,
_("You must be working online to complete this operation"));
- return FALSE;
+ success = FALSE;
+ goto exit;
}
- mechanism = camel_network_settings_get_auth_mechanism (
- CAMEL_NETWORK_SETTINGS (settings));
-
if (store->cache == NULL) {
store->cache = camel_data_cache_new (user_data_dir, error);
if (store->cache) {
}
}
- if (!connect_to_server (service, cancellable, error))
- return FALSE;
+ success = connect_to_server (service, cancellable, error);
+
+ if (!success)
+ goto exit;
success = camel_session_authenticate_sync (
session, service, mechanism, cancellable, error);
if (!success) {
camel_service_disconnect_sync (service, TRUE, NULL);
- return FALSE;
+ goto exit;
}
/* Now that we are in the TRANSACTION state,
store->engine->state = CAMEL_POP3_ENGINE_TRANSACTION;
camel_pop3_engine_reget_capabilities (store->engine, cancellable);
- return TRUE;
+exit:
+ g_free (mechanism);
+
+ return success;
}
static gboolean
CamelPOP3Command *pcu = NULL;
CamelPOP3Command *pcp = NULL;
const gchar *password;
- const gchar *host;
- const gchar *user;
+ gchar *host;
+ gchar *user;
gint status;
password = camel_service_get_password (service);
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
- user = camel_network_settings_get_user (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
+ user = camel_network_settings_dup_user (network_settings);
if (mechanism == NULL) {
if (password == NULL) {
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Authentication password not available"));
- return CAMEL_AUTHENTICATION_ERROR;
+ result = CAMEL_AUTHENTICATION_ERROR;
+ goto exit;
}
/* pop engine will take care of pipelining ability */
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("Authentication password not available"));
- return CAMEL_AUTHENTICATION_ERROR;
+ result = CAMEL_AUTHENTICATION_ERROR;
+ goto exit;
}
d = store->engine->apop;
"attack suspected. Please contact your admin."),
host);
- return CAMEL_AUTHENTICATION_ERROR;
+ result = CAMEL_AUTHENTICATION_ERROR;
+ goto exit;
}
d++;
}
while (link != NULL) {
CamelServiceAuthType *auth = link->data;
- if (g_strcmp0 (auth->authproto, mechanism) == 0)
- return try_sasl (
+ if (g_strcmp0 (auth->authproto, mechanism) == 0) {
+ result = try_sasl (
store, mechanism,
cancellable, error);
+ goto exit;
+ }
link = g_list_next (link);
}
error, CAMEL_SERVICE_ERROR,
CAMEL_SERVICE_ERROR_CANT_AUTHENTICATE,
_("No support for %s authentication"), mechanism);
- return CAMEL_AUTHENTICATION_ERROR;
+ result = CAMEL_AUTHENTICATION_ERROR;
+ goto exit;
}
while ((status = camel_pop3_engine_iterate (store->engine, pcp, cancellable, error)) > 0)
if (pcu != NULL)
camel_pop3_engine_command_free (store->engine, pcu);
+exit:
+ g_free (host);
+ g_free (user);
+
return result;
}
CamelNetworkSettings *network_settings;
CamelSettings *settings;
GList *types = NULL;
- const gchar *host;
+ gchar *host;
GError *local_error = NULL;
/* Chain up to parent's query_auth_types() method. */
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
if (connect_to_server (service, cancellable, NULL)) {
types = g_list_concat (types, g_list_copy (store->engine->auth));
_("Could not connect to POP server %s"), host);
}
+ g_free (host);
+
return types;
}
CamelNetworkSecurityMethod method;
CamelSettings *settings;
CamelStream *tcp_stream;
- const gchar *host;
gchar *respbuf = NULL;
+ gboolean success = TRUE;
+ gchar *host;
if (!CAMEL_SERVICE_CLASS (camel_smtp_transport_parent_class)->
connect_sync (service, cancellable, error))
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
method = camel_network_settings_get_security_method (network_settings);
tcp_stream = camel_network_service_connect_sync (
CAMEL_NETWORK_SERVICE (service), cancellable, error);
- if (tcp_stream == NULL)
- return FALSE;
+ if (tcp_stream == NULL) {
+ success = FALSE;
+ goto exit;
+ }
transport->connected = TRUE;
if (respbuf == NULL) {
g_prefix_error (error, _("Welcome response error: "));
transport->connected = FALSE;
- return FALSE;
+ success = FALSE;
+ goto exit;
}
if (strncmp (respbuf, "220", 3)) {
smtp_set_error (
transport, respbuf, cancellable, error);
g_prefix_error (error, _("Welcome response error: "));
g_free (respbuf);
- return FALSE;
+ success = FALSE;
+ goto exit;
}
} while (*(respbuf+3) == '-'); /* if we got "220-" then loop again */
g_free (respbuf);
/* Try sending EHLO */
transport->flags |= CAMEL_SMTP_TRANSPORT_IS_ESMTP;
if (!smtp_helo (transport, cancellable, error)) {
- if (!transport->connected)
- return FALSE;
+ if (!transport->connected) {
+ success = FALSE;
+ goto exit;
+ }
/* Fall back to HELO */
g_clear_error (error);
if (!smtp_helo (transport, cancellable, error)) {
camel_service_disconnect_sync (
(CamelService *) transport, TRUE, NULL);
-
- return FALSE;
+ success = FALSE;
+ goto exit;
}
}
g_clear_error (error);
if (method != CAMEL_NETWORK_SECURITY_METHOD_STARTTLS_ON_STANDARD_PORT)
- return TRUE; /* we're done */
+ goto exit; /* we're done */
if (!(transport->flags & CAMEL_SMTP_TRANSPORT_STARTTLS)) {
g_set_error (
if (!smtp_helo (transport, cancellable, error)) {
camel_service_disconnect_sync (
(CamelService *) transport, TRUE, NULL);
-
- return FALSE;
+ success = FALSE;
}
- return TRUE;
+ goto exit;
- exception_cleanup:
+exception_cleanup:
g_object_unref (transport->istream);
transport->istream = NULL;
+
g_object_unref (transport->ostream);
transport->ostream = NULL;
transport->connected = FALSE;
- return FALSE;
+ success = FALSE;
+
+exit:
+ g_free (host);
+
+ return success;
}
static void
{
CamelNetworkSettings *network_settings;
CamelSettings *settings;
- const gchar *host;
+ gchar *host;
+ gchar *name;
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
if (brief)
- return g_strdup_printf (
+ name = g_strdup_printf (
_("SMTP server %s"), host);
else
- return g_strdup_printf (
+ name = g_strdup_printf (
_("SMTP mail delivery via %s"), host);
+
+ g_free (host);
+
+ return name;
}
static gboolean
CamelSmtpTransport *transport = CAMEL_SMTP_TRANSPORT (service);
CamelNetworkSettings *network_settings;
CamelSettings *settings;
- const gchar *host;
- const gchar *mechanism;
+ gchar *host;
+ gchar *mechanism;
gboolean auth_required;
gboolean success = TRUE;
settings = camel_service_get_settings (service);
network_settings = CAMEL_NETWORK_SETTINGS (settings);
- host = camel_network_settings_get_host (network_settings);
- mechanism = camel_network_settings_get_auth_mechanism (network_settings);
+ host = camel_network_settings_dup_host (network_settings);
+ mechanism = camel_network_settings_dup_auth_mechanism (network_settings);
/* We (probably) need to check popb4smtp before we connect ... */
if (g_strcmp0 (mechanism, "POPB4SMTP") == 0) {
- gint truth;
GByteArray *chal;
CamelSasl *sasl;
sasl = camel_sasl_new ("smtp", "POPB4SMTP", service);
chal = camel_sasl_challenge_sync (sasl, NULL, cancellable, error);
- truth = camel_sasl_get_authenticated (sasl);
- if (chal)
+ if (chal != NULL)
g_byte_array_free (chal, TRUE);
- g_object_unref (sasl);
- if (!truth)
- return FALSE;
+ if (camel_sasl_get_authenticated (sasl))
+ success = connect_to_server (
+ service, cancellable, error);
+ else
+ success = FALSE;
+
+ g_object_unref (sasl);
- return connect_to_server (service, cancellable, error);
+ goto exit;
}
- if (!connect_to_server (service, cancellable, error))
+ success = connect_to_server (service, cancellable, error);
+
+ if (!success)
return FALSE;
/* check to see if AUTH is required, if so...then AUTH ourselves */
camel_service_disconnect_sync (service, TRUE, NULL);
}
+exit:
+ g_free (host);
+ g_free (mechanism);
+
return success;
}
projects / platform / upstream / evolution-data-server.git / commitdiff