From e5e0149bb66b663bba92c0eb8dd7dfbe6e33d9fa Mon Sep 17 00:00:00 2001 From: Jeffrey Stedfast Date: Mon, 27 Sep 2004 17:41:16 +0000 Subject: Instead of doing a host-lookup ourselves, get it passed in to us as an 2004-09-22 Jeffrey Stedfast * providers/imap/camel-imap-store.c (connect_to_server): Instead of doing a host-lookup ourselves, get it passed in to us as an argument. Also simplified a bit (try_starttls is no longer an option). (connect_to_server_wrapper): Simplified (we no longer have fallback cases for SSL stuff). Also, perform host lookup here. * providers/imap4/camel-imap4-store.c: Same changes as above. * providers/pop3/camel-pop3-store.c: Same. * providers/smtp/camel-smtp-transport.c: Same. Other changes include making the code consistant with the other providers. * providers/nntp/camel-nntp-store.c: Same as pop/imap. svn path=/trunk/; revision=27398 --- camel/providers/imap/camel-imap-store.c | 167 ++++++++++++-------------------- 1 file changed, 61 insertions(+), 106 deletions(-) (limited to 'camel/providers/imap') diff --git a/camel/providers/imap/camel-imap-store.c b/camel/providers/imap/camel-imap-store.c index 54340ca783..bc89bae55b 100644 --- a/camel/providers/imap/camel-imap-store.c +++ b/camel/providers/imap/camel-imap-store.c @@ -503,76 +503,52 @@ imap_get_capability (CamelService *service, CamelException *ex) } enum { - USE_SSL_NEVER, - USE_SSL_ALWAYS, - USE_SSL_WHEN_POSSIBLE + MODE_CLEAR, + MODE_SSL, + MODE_TLS, }; #define SSL_PORT_FLAGS (CAMEL_TCP_STREAM_SSL_ENABLE_SSL2 | CAMEL_TCP_STREAM_SSL_ENABLE_SSL3) #define STARTTLS_FLAGS (CAMEL_TCP_STREAM_SSL_ENABLE_TLS) static gboolean -connect_to_server (CamelService *service, int ssl_mode, int try_starttls, CamelException *ex) +connect_to_server (CamelService *service, struct addrinfo *ai, int ssl_mode, CamelException *ex) { CamelImapStore *store = (CamelImapStore *) service; CamelImapResponse *response; CamelStream *tcp_stream; CamelSockOptData sockopt; gboolean force_imap4 = FALSE; - int clean_quit; - int ret; + int clean_quit, ret; char *buf; - struct addrinfo *ai, hints = { 0 }; - char *serv; - - /* FIXME: this connect stuff is duplicated everywhere */ - - if (service->url->port) { - serv = g_alloca(16); - sprintf(serv, "%d", service->url->port); - } else - serv = "imap"; - if (ssl_mode != USE_SSL_NEVER) { + if (ssl_mode != MODE_CLEAR) { #ifdef HAVE_SSL - if (try_starttls) { - tcp_stream = camel_tcp_stream_ssl_new_raw (service->session, service->url->host, STARTTLS_FLAGS); + if (ssl_mode == MODE_TLS) { + tcp_stream = camel_tcp_stream_ssl_new (service->session, service->url->host, STARTTLS_FLAGS); } else { - if (service->url->port == 0) - serv = "imaps"; tcp_stream = camel_tcp_stream_ssl_new (service->session, service->url->host, SSL_PORT_FLAGS); } #else - if (!try_starttls && service->url->port == 0) - serv = "imaps"; - camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE, - _("Could not connect to %s (port %s): %s"), - service->url->host, serv, - _("SSL unavailable")); + _("Could not connect to %s: %s"), + service->url->host, _("SSL unavailable")); + return FALSE; #endif /* HAVE_SSL */ } else { tcp_stream = camel_tcp_stream_raw_new (); } - - hints.ai_socktype = SOCK_STREAM; - ai = camel_getaddrinfo(service->url->host, serv, &hints, ex); - if (ai == NULL) { - camel_object_unref(tcp_stream); - return FALSE; - } - ret = camel_tcp_stream_connect(CAMEL_TCP_STREAM(tcp_stream), ai); - camel_freeaddrinfo(ai); - if (ret == -1) { + if ((ret = camel_tcp_stream_connect ((CamelTcpStream *) tcp_stream, ai)) == -1) { if (errno == EINTR) camel_exception_set (ex, CAMEL_EXCEPTION_USER_CANCEL, _("Connection cancelled")); else camel_exception_setv (ex, CAMEL_EXCEPTION_SERVICE_UNAVAILABLE, - _("Could not connect to %s (port %s): %s"), - service->url->host, serv, g_strerror (errno)); + _("Could not connect to %s: %s"), + service->url->host, + g_strerror (errno)); camel_object_unref (tcp_stream); @@ -667,32 +643,18 @@ connect_to_server (CamelService *service, int ssl_mode, int try_starttls, CamelE store->server_level = IMAP_LEVEL_IMAP4; } -#ifdef HAVE_SSL - if (ssl_mode == USE_SSL_WHEN_POSSIBLE) { - if (store->capabilities & IMAP_CAPABILITY_STARTTLS) - goto starttls; - } else if (ssl_mode == USE_SSL_ALWAYS) { - if (try_starttls) { - if (store->capabilities & IMAP_CAPABILITY_STARTTLS) { - /* attempt to toggle STARTTLS mode */ - goto starttls; - } else { - /* server doesn't support STARTTLS, abort */ - camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, - _("Failed to connect to IMAP server %s in secure mode: %s"), - service->url->host, _("SSL/TLS extension not supported.")); - /* we have the possibility of quitting cleanly here */ - clean_quit = TRUE; - goto exception; - } - } + if (ssl_mode != MODE_TLS) { + /* we're done */ + return TRUE; } -#endif /* HAVE_SSL */ - - return TRUE; -#ifdef HAVE_SSL - starttls: + if (!(store->capabilities & IMAP_CAPABILITY_STARTTLS)) { + camel_exception_setv (ex, CAMEL_EXCEPTION_SYSTEM, + _("Failed to connect to IMAP server %s in secure mode: %s"), + service->url->host, _("STARTTLS not supported")); + + goto exception; + } /* as soon as we send a STARTTLS command, all hope is lost of a clean QUIT if problems arise */ clean_quit = FALSE; @@ -757,7 +719,6 @@ connect_to_server (CamelService *service, int ssl_mode, int try_starttls, CamelE store->connected = FALSE; return FALSE; -#endif /* HAVE_SSL */ } static gboolean @@ -905,60 +866,54 @@ connect_to_server_process (CamelService *service, const char *cmd, CamelExceptio static struct { char *value; + char *serv; int mode; } ssl_options[] = { - { "", USE_SSL_ALWAYS }, - { "always", USE_SSL_ALWAYS }, - { "when-possible", USE_SSL_WHEN_POSSIBLE }, - { "never", USE_SSL_NEVER }, - { NULL, USE_SSL_NEVER }, + { "", "imaps", MODE_SSL }, /* really old (1.x) */ + { "always", "imaps", MODE_SSL }, + { "when-possible", "imap", MODE_TLS }, + { "never", "imap", MODE_CLEAR }, + { NULL, "imap", MODE_CLEAR }, }; static gboolean connect_to_server_wrapper (CamelService *service, CamelException *ex) { - const char *command; -#ifdef HAVE_SSL - const char *use_ssl; - int i, ssl_mode; -#endif - command = camel_url_get_param (service->url, "command"); - if (command) + const char *command, *ssl_mode; + struct addrinfo hints, *ai; + int mode, ret, i; + char *serv; + + if ((command = camel_url_get_param (service->url, "command"))) return connect_to_server_process (service, command, ex); - -#ifdef HAVE_SSL - use_ssl = camel_url_get_param (service->url, "use_ssl"); - if (use_ssl) { + + if ((ssl_mode = camel_url_get_param (service->url, "use_ssl"))) { for (i = 0; ssl_options[i].value; i++) - if (!strcmp (ssl_options[i].value, use_ssl)) + if (!strcmp (ssl_options[i].value, ssl_mode)) break; - ssl_mode = ssl_options[i].mode; - } else - ssl_mode = USE_SSL_NEVER; - - if (ssl_mode == USE_SSL_ALWAYS) { - /* First try the ssl port */ - if (!connect_to_server (service, ssl_mode, FALSE, ex)) { - if (camel_exception_get_id (ex) == CAMEL_EXCEPTION_SERVICE_UNAVAILABLE) { - /* The ssl port seems to be unavailable, lets try STARTTLS */ - camel_exception_clear (ex); - return connect_to_server (service, ssl_mode, TRUE, ex); - } else { - return FALSE; - } - } - - return TRUE; - } else if (ssl_mode == USE_SSL_WHEN_POSSIBLE) { - /* If the server supports STARTTLS, use it */ - return connect_to_server (service, ssl_mode, TRUE, ex); + mode = ssl_options[i].mode; + serv = ssl_options[i].serv; } else { - /* User doesn't care about SSL */ - return connect_to_server (service, ssl_mode, FALSE, ex); + mode = MODE_CLEAR; + serv = "imap"; } -#else - return connect_to_server (service, USE_SSL_NEVER, FALSE, ex); -#endif + + if (service->url->port) { + serv = g_alloca (16); + sprintf (serv, "%d", service->url->port); + } + + memset (&hints, 0, sizeof (hints)); + hints.ai_socktype = SOCK_STREAM; + hints.ai_family = PF_UNSPEC; + if (!(ai = camel_getaddrinfo (service->url->host, serv, &hints, ex))) + return FALSE; + + ret = connect_to_server (service, ai, mode, ex); + + camel_freeaddrinfo (ai); + + return ret; } extern CamelServiceAuthType camel_imap_password_authtype; -- cgit