2011-01-23 12:43:00 +00:00
|
|
|
/*
|
|
|
|
* mbsync - mailbox synchronizer
|
|
|
|
* Copyright (C) 2000-2002 Michael R. Elkins <me@mutt.org>
|
2013-04-20 14:57:16 +00:00
|
|
|
* Copyright (C) 2002-2006,2008,2010,2011, 2013 Oswald Buddenhagen <ossi@users.sf.net>
|
2011-01-23 12:43:00 +00:00
|
|
|
* Copyright (C) 2004 Theodore Y. Ts'o <tytso@mit.edu>
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
2011-04-10 17:34:36 +00:00
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2011-01-23 12:43:00 +00:00
|
|
|
*
|
|
|
|
* As a special exception, mbsync may be linked with the OpenSSL library,
|
|
|
|
* despite that library's more restrictive license.
|
|
|
|
*/
|
|
|
|
|
2013-12-08 19:46:40 +00:00
|
|
|
#include "socket.h"
|
2011-01-23 12:43:00 +00:00
|
|
|
|
|
|
|
#include <assert.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <stdlib.h>
|
2012-08-25 16:26:23 +00:00
|
|
|
#include <stddef.h>
|
2011-01-23 12:43:00 +00:00
|
|
|
#include <errno.h>
|
|
|
|
#include <string.h>
|
2012-08-25 16:26:23 +00:00
|
|
|
#include <fcntl.h>
|
2011-01-23 12:43:00 +00:00
|
|
|
#include <sys/socket.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <netinet/in.h>
|
|
|
|
#include <netinet/tcp.h>
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
#include <netdb.h>
|
2013-12-08 19:46:40 +00:00
|
|
|
#ifdef HAVE_LIBSSL
|
|
|
|
# include <openssl/ssl.h>
|
|
|
|
# include <openssl/err.h>
|
|
|
|
# include <openssl/hmac.h>
|
|
|
|
# include <openssl/x509v3.h>
|
|
|
|
#endif
|
2011-01-23 12:43:00 +00:00
|
|
|
|
2012-08-25 16:26:23 +00:00
|
|
|
enum {
|
|
|
|
SCK_CONNECTING,
|
|
|
|
#ifdef HAVE_LIBSSL
|
|
|
|
SCK_STARTTLS,
|
|
|
|
#endif
|
|
|
|
SCK_READY
|
|
|
|
};
|
|
|
|
|
2011-03-27 14:50:32 +00:00
|
|
|
static void
|
|
|
|
socket_fail( conn_t *conn )
|
|
|
|
{
|
|
|
|
conn->bad_callback( conn->callback_aux );
|
|
|
|
}
|
|
|
|
|
2011-01-23 12:43:00 +00:00
|
|
|
#ifdef HAVE_LIBSSL
|
2012-08-25 16:26:23 +00:00
|
|
|
static int
|
|
|
|
ssl_return( const char *func, conn_t *conn, int ret )
|
|
|
|
{
|
2011-01-23 12:43:00 +00:00
|
|
|
int err;
|
|
|
|
|
2012-08-25 16:26:23 +00:00
|
|
|
switch ((err = SSL_get_error( conn->ssl, ret ))) {
|
|
|
|
case SSL_ERROR_NONE:
|
|
|
|
return ret;
|
|
|
|
case SSL_ERROR_WANT_WRITE:
|
2014-11-29 18:15:50 +00:00
|
|
|
conf_notifier( &conn->notify, POLLIN, POLLOUT );
|
2012-08-25 16:26:23 +00:00
|
|
|
/* fallthrough */
|
|
|
|
case SSL_ERROR_WANT_READ:
|
|
|
|
return 0;
|
|
|
|
case SSL_ERROR_SYSCALL:
|
|
|
|
case SSL_ERROR_SSL:
|
|
|
|
if (!(err = ERR_get_error())) {
|
|
|
|
if (ret == 0)
|
2011-04-10 13:32:25 +00:00
|
|
|
error( "Socket error: secure %s %s: unexpected EOF\n", func, conn->name );
|
2012-08-25 16:26:23 +00:00
|
|
|
else
|
2011-04-10 13:32:25 +00:00
|
|
|
sys_error( "Socket error: secure %s %s", func, conn->name );
|
2012-08-25 16:26:23 +00:00
|
|
|
} else {
|
2011-04-10 13:32:25 +00:00
|
|
|
error( "Socket error: secure %s %s: %s\n", func, conn->name, ERR_error_string( err, 0 ) );
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
2012-08-25 16:26:23 +00:00
|
|
|
break;
|
|
|
|
default:
|
2011-04-10 13:32:25 +00:00
|
|
|
error( "Socket error: secure %s %s: unhandled SSL error %d\n", func, conn->name, err );
|
2012-08-25 16:26:23 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (conn->state == SCK_STARTTLS)
|
|
|
|
conn->callbacks.starttls( 0, conn->callback_aux );
|
2011-01-23 12:43:00 +00:00
|
|
|
else
|
2012-08-25 16:26:23 +00:00
|
|
|
socket_fail( conn );
|
|
|
|
return -1;
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Some of this code is inspired by / lifted from mutt. */
|
|
|
|
|
2013-02-03 16:34:15 +00:00
|
|
|
static int
|
|
|
|
host_matches( const char *host, const char *pattern )
|
|
|
|
{
|
|
|
|
if (pattern[0] == '*' && pattern[1] == '.') {
|
|
|
|
pattern += 2;
|
|
|
|
if (!(host = strchr( host, '.' )))
|
|
|
|
return 0;
|
|
|
|
host++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return *host && *pattern && !strcasecmp( host, pattern );
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
verify_hostname( X509 *cert, const char *hostname )
|
|
|
|
{
|
|
|
|
int i, len, found;
|
|
|
|
X509_NAME *subj;
|
|
|
|
STACK_OF(GENERAL_NAME) *subj_alt_names;
|
|
|
|
char cname[1000];
|
|
|
|
|
|
|
|
/* try the DNS subjectAltNames */
|
|
|
|
found = 0;
|
|
|
|
if ((subj_alt_names = X509_get_ext_d2i( cert, NID_subject_alt_name, NULL, NULL ))) {
|
|
|
|
int num_subj_alt_names = sk_GENERAL_NAME_num( subj_alt_names );
|
|
|
|
for (i = 0; i < num_subj_alt_names; i++) {
|
|
|
|
GENERAL_NAME *subj_alt_name = sk_GENERAL_NAME_value( subj_alt_names, i );
|
|
|
|
if (subj_alt_name->type == GEN_DNS &&
|
|
|
|
strlen( (const char *)subj_alt_name->d.ia5->data ) == (size_t)subj_alt_name->d.ia5->length &&
|
|
|
|
host_matches( hostname, (const char *)(subj_alt_name->d.ia5->data) ))
|
|
|
|
{
|
|
|
|
found = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
sk_GENERAL_NAME_pop_free( subj_alt_names, GENERAL_NAME_free );
|
|
|
|
}
|
|
|
|
if (found)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* try the common name */
|
|
|
|
if (!(subj = X509_get_subject_name( cert ))) {
|
|
|
|
error( "Error, cannot get certificate subject\n" );
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if ((len = X509_NAME_get_text_by_NID( subj, NID_commonName, cname, sizeof(cname) )) < 0) {
|
|
|
|
error( "Error, cannot get certificate common name\n" );
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
if (strlen( cname ) == (size_t)len && host_matches( hostname, cname ))
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error( "Error, certificate owner does not match hostname %s\n", hostname );
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2011-01-23 12:43:00 +00:00
|
|
|
static int
|
2013-03-17 11:41:47 +00:00
|
|
|
verify_cert_host( const server_conf_t *conf, conn_t *sock )
|
2011-01-23 12:43:00 +00:00
|
|
|
{
|
2015-01-11 13:32:15 +00:00
|
|
|
int i;
|
2014-07-27 13:12:37 +00:00
|
|
|
long err;
|
2013-03-17 11:41:47 +00:00
|
|
|
X509 *cert;
|
2014-07-27 13:12:37 +00:00
|
|
|
STACK_OF(X509_OBJECT) *trusted;
|
2011-01-23 12:43:00 +00:00
|
|
|
|
2013-03-17 11:41:47 +00:00
|
|
|
cert = SSL_get_peer_certificate( sock->ssl );
|
2011-01-23 12:43:00 +00:00
|
|
|
if (!cert) {
|
|
|
|
error( "Error, no server certificate\n" );
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2015-01-11 13:32:15 +00:00
|
|
|
trusted = (STACK_OF(X509_OBJECT) *)sock->conf->trusted_certs;
|
|
|
|
for (i = 0; i < sk_X509_OBJECT_num( trusted ); i++) {
|
2014-07-27 13:12:37 +00:00
|
|
|
if (!X509_cmp( cert, sk_X509_OBJECT_value( trusted, i )->data.x509 ))
|
|
|
|
return 0;
|
|
|
|
}
|
2013-02-03 16:34:15 +00:00
|
|
|
|
2014-07-27 13:12:37 +00:00
|
|
|
err = SSL_get_verify_result( sock->ssl );
|
|
|
|
if (err != X509_V_OK) {
|
|
|
|
error( "SSL error connecting %s: %s\n", sock->name, ERR_error_string( err, NULL ) );
|
|
|
|
return -1;
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
2014-07-27 13:12:37 +00:00
|
|
|
|
2014-07-27 16:10:26 +00:00
|
|
|
if (!conf->host) {
|
|
|
|
error( "SSL error connecting %s: Neither host nor matching certificate specified\n", sock->name );
|
|
|
|
return -1;
|
|
|
|
}
|
2014-07-27 13:12:37 +00:00
|
|
|
|
|
|
|
return verify_hostname( cert, conf->host );
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
init_ssl_ctx( const server_conf_t *conf )
|
|
|
|
{
|
|
|
|
server_conf_t *mconf = (server_conf_t *)conf;
|
|
|
|
int options = 0;
|
|
|
|
|
2013-03-17 11:41:47 +00:00
|
|
|
if (conf->SSLContext)
|
|
|
|
return conf->ssl_ctx_valid;
|
|
|
|
|
2013-02-03 16:47:05 +00:00
|
|
|
mconf->SSLContext = SSL_CTX_new( SSLv23_client_method() );
|
2011-01-23 12:43:00 +00:00
|
|
|
|
2014-07-12 18:35:55 +00:00
|
|
|
if (!(conf->ssl_versions & SSLv2))
|
2011-01-23 12:43:00 +00:00
|
|
|
options |= SSL_OP_NO_SSLv2;
|
2014-07-12 18:35:55 +00:00
|
|
|
if (!(conf->ssl_versions & SSLv3))
|
2011-01-23 12:43:00 +00:00
|
|
|
options |= SSL_OP_NO_SSLv3;
|
2014-07-12 18:35:55 +00:00
|
|
|
if (!(conf->ssl_versions & TLSv1))
|
2011-01-23 12:43:00 +00:00
|
|
|
options |= SSL_OP_NO_TLSv1;
|
2013-02-03 16:47:05 +00:00
|
|
|
#ifdef SSL_OP_NO_TLSv1_1
|
2014-07-12 18:35:55 +00:00
|
|
|
if (!(conf->ssl_versions & TLSv1_1))
|
2013-02-03 16:47:05 +00:00
|
|
|
options |= SSL_OP_NO_TLSv1_1;
|
|
|
|
#endif
|
|
|
|
#ifdef SSL_OP_NO_TLSv1_2
|
2014-07-12 18:35:55 +00:00
|
|
|
if (!(conf->ssl_versions & TLSv1_2))
|
2013-02-03 16:47:05 +00:00
|
|
|
options |= SSL_OP_NO_TLSv1_2;
|
|
|
|
#endif
|
2011-01-23 12:43:00 +00:00
|
|
|
|
|
|
|
SSL_CTX_set_options( mconf->SSLContext, options );
|
|
|
|
|
2013-03-17 11:41:47 +00:00
|
|
|
if (conf->cert_file && !SSL_CTX_load_verify_locations( mconf->SSLContext, conf->cert_file, 0 )) {
|
|
|
|
error( "Error while loading certificate file '%s': %s\n",
|
|
|
|
conf->cert_file, ERR_error_string( ERR_get_error(), 0 ) );
|
|
|
|
return 0;
|
|
|
|
}
|
2014-11-08 12:50:59 +00:00
|
|
|
mconf->trusted_certs = (_STACK *)sk_X509_OBJECT_dup( SSL_CTX_get_cert_store( mconf->SSLContext )->objs );
|
2014-07-27 13:42:33 +00:00
|
|
|
if (mconf->system_certs && !SSL_CTX_set_default_verify_paths( mconf->SSLContext ))
|
2013-03-17 11:41:47 +00:00
|
|
|
warn( "Warning: Unable to load default certificate files: %s\n",
|
|
|
|
ERR_error_string( ERR_get_error(), 0 ) );
|
|
|
|
|
2014-07-27 13:12:37 +00:00
|
|
|
SSL_CTX_set_verify( mconf->SSLContext, SSL_VERIFY_NONE, NULL );
|
2013-03-17 11:41:47 +00:00
|
|
|
|
|
|
|
mconf->ssl_ctx_valid = 1;
|
|
|
|
return 1;
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
|
|
|
|
2012-08-25 16:26:23 +00:00
|
|
|
static void start_tls_p2( conn_t * );
|
|
|
|
static void start_tls_p3( conn_t *, int );
|
2014-11-30 18:44:41 +00:00
|
|
|
static void ssl_fake_cb( void * );
|
2012-08-25 16:26:23 +00:00
|
|
|
|
|
|
|
void
|
|
|
|
socket_start_tls( conn_t *conn, void (*cb)( int ok, void *aux ) )
|
2011-01-23 12:43:00 +00:00
|
|
|
{
|
|
|
|
static int ssl_inited;
|
|
|
|
|
2012-08-25 16:26:23 +00:00
|
|
|
conn->callbacks.starttls = cb;
|
|
|
|
|
2011-01-23 12:43:00 +00:00
|
|
|
if (!ssl_inited) {
|
|
|
|
SSL_library_init();
|
|
|
|
SSL_load_error_strings();
|
|
|
|
ssl_inited = 1;
|
|
|
|
}
|
|
|
|
|
2013-03-17 11:41:47 +00:00
|
|
|
if (!init_ssl_ctx( conn->conf )) {
|
2012-08-25 16:26:23 +00:00
|
|
|
start_tls_p3( conn, 0 );
|
|
|
|
return;
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
|
|
|
|
2014-11-30 18:44:41 +00:00
|
|
|
init_wakeup( &conn->ssl_fake, ssl_fake_cb, conn );
|
2012-08-25 16:26:23 +00:00
|
|
|
conn->ssl = SSL_new( ((server_conf_t *)conn->conf)->SSLContext );
|
|
|
|
SSL_set_fd( conn->ssl, conn->fd );
|
|
|
|
SSL_set_mode( conn->ssl, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER );
|
2012-09-02 15:35:08 +00:00
|
|
|
conn->state = SCK_STARTTLS;
|
2012-08-25 16:26:23 +00:00
|
|
|
start_tls_p2( conn );
|
|
|
|
}
|
2011-01-23 12:43:00 +00:00
|
|
|
|
2012-08-25 16:26:23 +00:00
|
|
|
static void
|
|
|
|
start_tls_p2( conn_t *conn )
|
|
|
|
{
|
2013-03-17 13:32:06 +00:00
|
|
|
if (ssl_return( "connect to", conn, SSL_connect( conn->ssl ) ) > 0) {
|
2013-03-17 11:41:47 +00:00
|
|
|
if (verify_cert_host( conn->conf, conn )) {
|
2012-08-25 16:26:23 +00:00
|
|
|
start_tls_p3( conn, 0 );
|
|
|
|
} else {
|
|
|
|
info( "Connection is now encrypted\n" );
|
|
|
|
start_tls_p3( conn, 1 );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void start_tls_p3( conn_t *conn, int ok )
|
|
|
|
{
|
|
|
|
conn->state = SCK_READY;
|
|
|
|
conn->callbacks.starttls( ok, conn->callback_aux );
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#endif /* HAVE_LIBSSL */
|
|
|
|
|
2012-08-25 16:26:23 +00:00
|
|
|
static void socket_fd_cb( int, void * );
|
|
|
|
|
2013-09-01 14:32:45 +00:00
|
|
|
static void socket_connect_one( conn_t * );
|
2013-03-29 16:51:50 +00:00
|
|
|
static void socket_connect_failed( conn_t * );
|
2013-03-29 17:22:40 +00:00
|
|
|
static void socket_connected( conn_t * );
|
2012-08-25 16:26:23 +00:00
|
|
|
static void socket_connect_bail( conn_t * );
|
|
|
|
|
2014-12-07 11:51:01 +00:00
|
|
|
static void
|
|
|
|
socket_open_internal( conn_t *sock, int fd )
|
|
|
|
{
|
|
|
|
sock->fd = fd;
|
|
|
|
fcntl( fd, F_SETFL, O_NONBLOCK );
|
2014-11-29 18:15:50 +00:00
|
|
|
init_notifier( &sock->notify, fd, socket_fd_cb, sock );
|
2014-12-07 11:51:01 +00:00
|
|
|
}
|
|
|
|
|
2012-08-25 16:26:23 +00:00
|
|
|
static void
|
|
|
|
socket_close_internal( conn_t *sock )
|
|
|
|
{
|
2014-11-29 18:15:50 +00:00
|
|
|
wipe_notifier( &sock->notify );
|
2012-08-25 16:26:23 +00:00
|
|
|
close( sock->fd );
|
|
|
|
sock->fd = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
|
|
|
socket_connect( conn_t *sock, void (*cb)( int ok, void *aux ) )
|
2011-01-23 12:43:00 +00:00
|
|
|
{
|
2012-08-25 16:26:23 +00:00
|
|
|
const server_conf_t *conf = sock->conf;
|
2011-01-23 12:43:00 +00:00
|
|
|
|
2012-08-25 16:26:23 +00:00
|
|
|
sock->callbacks.connect = cb;
|
|
|
|
|
2014-07-06 08:06:40 +00:00
|
|
|
/* open connection to server */
|
2011-01-23 12:43:00 +00:00
|
|
|
if (conf->tunnel) {
|
2013-09-01 14:32:45 +00:00
|
|
|
int a[2];
|
|
|
|
|
2011-04-10 13:32:25 +00:00
|
|
|
nfasprintf( &sock->name, "tunnel '%s'", conf->tunnel );
|
|
|
|
infon( "Starting %s... ", sock->name );
|
2011-01-23 12:43:00 +00:00
|
|
|
|
|
|
|
if (socketpair( PF_UNIX, SOCK_STREAM, 0, a )) {
|
|
|
|
perror( "socketpair" );
|
|
|
|
exit( 1 );
|
|
|
|
}
|
|
|
|
|
|
|
|
if (fork() == 0) {
|
|
|
|
if (dup2( a[0], 0 ) == -1 || dup2( a[0], 1 ) == -1)
|
|
|
|
_exit( 127 );
|
|
|
|
close( a[0] );
|
|
|
|
close( a[1] );
|
|
|
|
execl( "/bin/sh", "sh", "-c", conf->tunnel, (char *)0 );
|
|
|
|
_exit( 127 );
|
|
|
|
}
|
|
|
|
|
|
|
|
close( a[0] );
|
2014-12-07 11:51:01 +00:00
|
|
|
socket_open_internal( sock, a[1] );
|
2012-08-25 16:26:23 +00:00
|
|
|
|
2013-09-01 14:32:45 +00:00
|
|
|
info( "\vok\n" );
|
|
|
|
socket_connected( sock );
|
2011-01-23 12:43:00 +00:00
|
|
|
} else {
|
2013-09-01 15:35:31 +00:00
|
|
|
#ifdef HAVE_IPV6
|
|
|
|
int gaierr;
|
|
|
|
struct addrinfo hints;
|
|
|
|
|
|
|
|
memset( &hints, 0, sizeof(hints) );
|
|
|
|
hints.ai_family = AF_UNSPEC;
|
|
|
|
hints.ai_socktype = SOCK_STREAM;
|
2014-02-02 11:24:34 +00:00
|
|
|
hints.ai_flags = AI_ADDRCONFIG;
|
2013-09-01 15:35:31 +00:00
|
|
|
infon( "Resolving %s... ", conf->host );
|
|
|
|
if ((gaierr = getaddrinfo( conf->host, NULL, &hints, &sock->addrs ))) {
|
2014-07-06 08:06:40 +00:00
|
|
|
error( "Error: Cannot resolve server '%s': %s\n", conf->host, gai_strerror( gaierr ) );
|
2013-09-01 15:35:31 +00:00
|
|
|
socket_connect_bail( sock );
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
info( "\vok\n" );
|
|
|
|
|
|
|
|
sock->curr_addr = sock->addrs;
|
|
|
|
#else
|
2013-09-01 14:32:45 +00:00
|
|
|
struct hostent *he;
|
2011-01-23 12:43:00 +00:00
|
|
|
|
|
|
|
infon( "Resolving %s... ", conf->host );
|
|
|
|
he = gethostbyname( conf->host );
|
|
|
|
if (!he) {
|
2014-07-06 08:06:40 +00:00
|
|
|
error( "Error: Cannot resolve server '%s': %s\n", conf->host, hstrerror( h_errno ) );
|
2013-03-29 16:51:50 +00:00
|
|
|
socket_connect_bail( sock );
|
|
|
|
return;
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
2012-09-01 15:21:32 +00:00
|
|
|
info( "\vok\n" );
|
2011-01-23 12:43:00 +00:00
|
|
|
|
2013-09-01 14:32:45 +00:00
|
|
|
sock->curr_addr = he->h_addr_list;
|
2013-09-01 15:35:31 +00:00
|
|
|
#endif
|
2013-09-01 14:32:45 +00:00
|
|
|
socket_connect_one( sock );
|
|
|
|
}
|
|
|
|
}
|
2011-01-23 12:43:00 +00:00
|
|
|
|
2013-09-01 14:32:45 +00:00
|
|
|
static void
|
|
|
|
socket_connect_one( conn_t *sock )
|
|
|
|
{
|
|
|
|
int s;
|
2013-09-01 15:35:31 +00:00
|
|
|
#ifdef HAVE_IPV6
|
|
|
|
struct addrinfo *ai;
|
|
|
|
#else
|
2013-09-01 14:32:45 +00:00
|
|
|
struct {
|
|
|
|
struct sockaddr_in ai_addr[1];
|
|
|
|
} ai[1];
|
2013-09-01 15:35:31 +00:00
|
|
|
#endif
|
2013-09-01 14:32:45 +00:00
|
|
|
|
2013-09-01 15:35:31 +00:00
|
|
|
#ifdef HAVE_IPV6
|
|
|
|
if (!(ai = sock->curr_addr)) {
|
|
|
|
#else
|
2013-09-01 14:32:45 +00:00
|
|
|
if (!*sock->curr_addr) {
|
2013-09-01 15:35:31 +00:00
|
|
|
#endif
|
2013-09-01 14:32:45 +00:00
|
|
|
error( "No working address found for %s\n", sock->conf->host );
|
|
|
|
socket_connect_bail( sock );
|
|
|
|
return;
|
|
|
|
}
|
2011-01-23 12:43:00 +00:00
|
|
|
|
2013-09-01 15:35:31 +00:00
|
|
|
#ifdef HAVE_IPV6
|
|
|
|
if (ai->ai_family == AF_INET6) {
|
|
|
|
struct sockaddr_in6 *in6 = ((struct sockaddr_in6 *)ai->ai_addr);
|
|
|
|
char sockname[64];
|
2014-07-06 08:06:40 +00:00
|
|
|
in6->sin6_port = htons( sock->conf->port );
|
2013-09-01 15:35:31 +00:00
|
|
|
nfasprintf( &sock->name, "%s ([%s]:%hu)",
|
2014-07-06 08:06:40 +00:00
|
|
|
sock->conf->host, inet_ntop( AF_INET6, &in6->sin6_addr, sockname, sizeof(sockname) ), sock->conf->port );
|
2013-09-01 15:35:31 +00:00
|
|
|
} else
|
|
|
|
#endif
|
2013-09-01 14:32:45 +00:00
|
|
|
{
|
|
|
|
struct sockaddr_in *in = ((struct sockaddr_in *)ai->ai_addr);
|
2013-09-01 15:35:31 +00:00
|
|
|
#ifndef HAVE_IPV6
|
2013-09-01 14:32:45 +00:00
|
|
|
memset( in, 0, sizeof(*in) );
|
|
|
|
in->sin_family = AF_INET;
|
|
|
|
in->sin_addr.s_addr = *((int *)*sock->curr_addr);
|
2013-09-01 15:35:31 +00:00
|
|
|
#endif
|
2014-07-06 08:06:40 +00:00
|
|
|
in->sin_port = htons( sock->conf->port );
|
2011-04-10 13:32:25 +00:00
|
|
|
nfasprintf( &sock->name, "%s (%s:%hu)",
|
2014-07-06 08:06:40 +00:00
|
|
|
sock->conf->host, inet_ntoa( in->sin_addr ), sock->conf->port );
|
2013-09-01 14:32:45 +00:00
|
|
|
}
|
|
|
|
|
2013-09-01 15:35:31 +00:00
|
|
|
#ifdef HAVE_IPV6
|
|
|
|
s = socket( ai->ai_family, SOCK_STREAM, 0 );
|
|
|
|
#else
|
2013-09-01 14:32:45 +00:00
|
|
|
s = socket( PF_INET, SOCK_STREAM, 0 );
|
2013-09-01 15:35:31 +00:00
|
|
|
#endif
|
2013-09-01 14:32:45 +00:00
|
|
|
if (s < 0) {
|
|
|
|
perror( "socket" );
|
|
|
|
exit( 1 );
|
|
|
|
}
|
2014-12-07 11:51:01 +00:00
|
|
|
socket_open_internal( sock, s );
|
2013-09-01 14:32:45 +00:00
|
|
|
|
|
|
|
infon( "Connecting to %s... ", sock->name );
|
2013-09-01 15:35:31 +00:00
|
|
|
#ifdef HAVE_IPV6
|
|
|
|
if (connect( s, ai->ai_addr, ai->ai_addrlen )) {
|
|
|
|
#else
|
2013-09-01 14:32:45 +00:00
|
|
|
if (connect( s, ai->ai_addr, sizeof(*ai->ai_addr) )) {
|
2013-09-01 15:35:31 +00:00
|
|
|
#endif
|
2013-09-01 14:32:45 +00:00
|
|
|
if (errno != EINPROGRESS) {
|
|
|
|
socket_connect_failed( sock );
|
2012-08-25 16:26:23 +00:00
|
|
|
return;
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
2014-11-29 18:15:50 +00:00
|
|
|
conf_notifier( &sock->notify, 0, POLLOUT );
|
2013-09-01 14:32:45 +00:00
|
|
|
sock->state = SCK_CONNECTING;
|
|
|
|
info( "\v\n" );
|
|
|
|
return;
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
2012-09-01 15:21:32 +00:00
|
|
|
info( "\vok\n" );
|
2013-03-29 17:22:40 +00:00
|
|
|
socket_connected( sock );
|
2013-03-29 16:51:50 +00:00
|
|
|
}
|
2012-08-25 16:26:23 +00:00
|
|
|
|
2013-03-29 16:51:50 +00:00
|
|
|
static void
|
|
|
|
socket_connect_failed( conn_t *conn )
|
|
|
|
{
|
|
|
|
sys_error( "Cannot connect to %s", conn->name );
|
|
|
|
socket_close_internal( conn );
|
2013-09-01 14:32:45 +00:00
|
|
|
free( conn->name );
|
|
|
|
conn->name = 0;
|
2013-09-01 15:35:31 +00:00
|
|
|
#ifdef HAVE_IPV6
|
|
|
|
conn->curr_addr = conn->curr_addr->ai_next;
|
|
|
|
#else
|
2013-09-01 14:32:45 +00:00
|
|
|
conn->curr_addr++;
|
2013-09-01 15:35:31 +00:00
|
|
|
#endif
|
2013-09-01 14:32:45 +00:00
|
|
|
socket_connect_one( conn );
|
2012-08-25 16:26:23 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
socket_connected( conn_t *conn )
|
|
|
|
{
|
2013-09-01 15:35:31 +00:00
|
|
|
#ifdef HAVE_IPV6
|
|
|
|
freeaddrinfo( conn->addrs );
|
|
|
|
#endif
|
2014-11-29 18:15:50 +00:00
|
|
|
conf_notifier( &conn->notify, 0, POLLIN );
|
2012-08-25 16:26:23 +00:00
|
|
|
conn->state = SCK_READY;
|
|
|
|
conn->callbacks.connect( 1, conn->callback_aux );
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
|
|
|
|
2012-08-25 16:26:23 +00:00
|
|
|
static void
|
|
|
|
socket_connect_bail( conn_t *conn )
|
|
|
|
{
|
2013-09-01 15:35:31 +00:00
|
|
|
#ifdef HAVE_IPV6
|
|
|
|
freeaddrinfo( conn->addrs );
|
|
|
|
#endif
|
2011-04-10 13:32:25 +00:00
|
|
|
free( conn->name );
|
|
|
|
conn->name = 0;
|
2012-08-25 16:26:23 +00:00
|
|
|
conn->callbacks.connect( 0, conn->callback_aux );
|
|
|
|
}
|
|
|
|
|
|
|
|
static void dispose_chunk( conn_t *conn );
|
|
|
|
|
2011-01-23 12:43:00 +00:00
|
|
|
void
|
2011-01-23 13:06:03 +00:00
|
|
|
socket_close( conn_t *sock )
|
2011-01-23 12:43:00 +00:00
|
|
|
{
|
2012-08-25 16:26:23 +00:00
|
|
|
if (sock->fd >= 0)
|
|
|
|
socket_close_internal( sock );
|
2011-04-10 13:32:25 +00:00
|
|
|
free( sock->name );
|
|
|
|
sock->name = 0;
|
2011-01-23 12:43:00 +00:00
|
|
|
#ifdef HAVE_LIBSSL
|
|
|
|
if (sock->ssl) {
|
|
|
|
SSL_free( sock->ssl );
|
|
|
|
sock->ssl = 0;
|
2014-11-30 18:44:41 +00:00
|
|
|
wipe_wakeup( &sock->ssl_fake );
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
|
|
|
#endif
|
2012-08-25 16:26:23 +00:00
|
|
|
while (sock->write_buf)
|
|
|
|
dispose_chunk( sock );
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
|
|
|
|
2012-08-25 16:26:23 +00:00
|
|
|
static void
|
2011-04-03 16:47:37 +00:00
|
|
|
socket_fill( conn_t *sock )
|
2011-01-23 12:43:00 +00:00
|
|
|
{
|
2011-04-03 16:47:37 +00:00
|
|
|
char *buf;
|
|
|
|
int n = sock->offset + sock->bytes;
|
|
|
|
int len = sizeof(sock->buf) - n;
|
|
|
|
if (!len) {
|
|
|
|
error( "Socket error: receive buffer full. Probably protocol error.\n" );
|
2011-03-27 14:50:32 +00:00
|
|
|
socket_fail( sock );
|
2012-08-25 16:26:23 +00:00
|
|
|
return;
|
2011-04-03 16:47:37 +00:00
|
|
|
}
|
2011-01-23 12:43:00 +00:00
|
|
|
assert( sock->fd >= 0 );
|
2011-04-03 16:47:37 +00:00
|
|
|
buf = sock->buf + n;
|
2011-01-23 12:43:00 +00:00
|
|
|
#ifdef HAVE_LIBSSL
|
2012-08-25 16:26:23 +00:00
|
|
|
if (sock->ssl) {
|
2011-04-10 13:32:25 +00:00
|
|
|
if ((n = ssl_return( "read from", sock, SSL_read( sock->ssl, buf, len ) )) <= 0)
|
2012-08-25 16:26:23 +00:00
|
|
|
return;
|
|
|
|
if (n == len && SSL_pending( sock->ssl ))
|
2014-11-30 18:44:41 +00:00
|
|
|
conf_wakeup( &sock->ssl_fake, 0 );
|
2012-08-25 16:26:23 +00:00
|
|
|
} else
|
2011-01-23 12:43:00 +00:00
|
|
|
#endif
|
2012-08-25 16:26:23 +00:00
|
|
|
{
|
|
|
|
if ((n = read( sock->fd, buf, len )) < 0) {
|
2011-04-10 13:32:25 +00:00
|
|
|
sys_error( "Socket error: read from %s", sock->name );
|
2012-08-25 16:26:23 +00:00
|
|
|
socket_fail( sock );
|
|
|
|
return;
|
|
|
|
} else if (!n) {
|
2011-04-10 13:32:25 +00:00
|
|
|
error( "Socket error: read from %s: unexpected EOF\n", sock->name );
|
2012-08-25 16:26:23 +00:00
|
|
|
socket_fail( sock );
|
|
|
|
return;
|
|
|
|
}
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
2012-08-25 16:26:23 +00:00
|
|
|
sock->bytes += n;
|
|
|
|
sock->read_callback( sock->callback_aux );
|
2011-04-03 16:47:37 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
socket_read( conn_t *conn, char *buf, int len )
|
|
|
|
{
|
|
|
|
int n = conn->bytes;
|
|
|
|
if (n > len)
|
|
|
|
n = len;
|
|
|
|
memcpy( buf, conn->buf + conn->offset, n );
|
|
|
|
if (!(conn->bytes -= n))
|
|
|
|
conn->offset = 0;
|
|
|
|
else
|
|
|
|
conn->offset += n;
|
2011-01-23 12:43:00 +00:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
2011-04-03 16:47:37 +00:00
|
|
|
char *
|
|
|
|
socket_read_line( conn_t *b )
|
|
|
|
{
|
|
|
|
char *p, *s;
|
|
|
|
int n;
|
|
|
|
|
|
|
|
s = b->buf + b->offset;
|
|
|
|
p = memchr( s + b->scanoff, '\n', b->bytes - b->scanoff );
|
|
|
|
if (!p) {
|
|
|
|
b->scanoff = b->bytes;
|
|
|
|
if (b->offset + b->bytes == sizeof(b->buf)) {
|
|
|
|
memmove( b->buf, b->buf + b->offset, b->bytes );
|
|
|
|
b->offset = 0;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
n = p + 1 - s;
|
|
|
|
b->offset += n;
|
|
|
|
b->bytes -= n;
|
|
|
|
b->scanoff = 0;
|
|
|
|
if (p != s && p[-1] == '\r')
|
|
|
|
p--;
|
|
|
|
*p = 0;
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2012-08-25 16:26:23 +00:00
|
|
|
static int
|
|
|
|
do_write( conn_t *sock, char *buf, int len )
|
2011-01-23 12:43:00 +00:00
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
assert( sock->fd >= 0 );
|
|
|
|
#ifdef HAVE_LIBSSL
|
2012-08-25 16:26:23 +00:00
|
|
|
if (sock->ssl)
|
2011-04-10 13:32:25 +00:00
|
|
|
return ssl_return( "write to", sock, SSL_write( sock->ssl, buf, len ) );
|
2011-01-23 12:43:00 +00:00
|
|
|
#endif
|
2012-08-25 16:26:23 +00:00
|
|
|
n = write( sock->fd, buf, len );
|
|
|
|
if (n < 0) {
|
|
|
|
if (errno != EAGAIN && errno != EWOULDBLOCK) {
|
2011-04-10 13:32:25 +00:00
|
|
|
sys_error( "Socket error: write to %s", sock->name );
|
2012-08-25 16:26:23 +00:00
|
|
|
socket_fail( sock );
|
|
|
|
} else {
|
|
|
|
n = 0;
|
2014-11-29 18:15:50 +00:00
|
|
|
conf_notifier( &sock->notify, POLLIN, POLLOUT );
|
2012-08-25 16:26:23 +00:00
|
|
|
}
|
|
|
|
} else if (n != len) {
|
2014-11-29 18:15:50 +00:00
|
|
|
conf_notifier( &sock->notify, POLLIN, POLLOUT );
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
2012-08-25 16:26:23 +00:00
|
|
|
return n;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
dispose_chunk( conn_t *conn )
|
|
|
|
{
|
|
|
|
buff_chunk_t *bc = conn->write_buf;
|
|
|
|
if (!(conn->write_buf = bc->next))
|
|
|
|
conn->write_buf_append = &conn->write_buf;
|
|
|
|
if (bc->data != bc->buf)
|
|
|
|
free( bc->data );
|
|
|
|
free( bc );
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
do_queued_write( conn_t *conn )
|
|
|
|
{
|
|
|
|
buff_chunk_t *bc;
|
|
|
|
|
|
|
|
if (!conn->write_buf)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
while ((bc = conn->write_buf)) {
|
|
|
|
int n, len = bc->len - conn->write_offset;
|
|
|
|
if ((n = do_write( conn, bc->data + conn->write_offset, len )) < 0)
|
|
|
|
return -1;
|
|
|
|
if (n != len) {
|
|
|
|
conn->write_offset += n;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
conn->write_offset = 0;
|
|
|
|
dispose_chunk( conn );
|
|
|
|
}
|
|
|
|
#ifdef HAVE_LIBSSL
|
|
|
|
if (conn->ssl && SSL_pending( conn->ssl ))
|
2014-11-30 18:44:41 +00:00
|
|
|
conf_wakeup( &conn->ssl_fake, 0 );
|
2012-08-25 16:26:23 +00:00
|
|
|
#endif
|
|
|
|
return conn->write_callback( conn->callback_aux );
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
do_append( conn_t *conn, char *buf, int len, ownership_t takeOwn )
|
|
|
|
{
|
|
|
|
buff_chunk_t *bc;
|
|
|
|
|
|
|
|
if (takeOwn == GiveOwn) {
|
|
|
|
bc = nfmalloc( offsetof(buff_chunk_t, buf) );
|
|
|
|
bc->data = buf;
|
|
|
|
} else {
|
|
|
|
bc = nfmalloc( offsetof(buff_chunk_t, buf) + len );
|
|
|
|
bc->data = bc->buf;
|
|
|
|
memcpy( bc->data, buf, len );
|
|
|
|
}
|
|
|
|
bc->len = len;
|
|
|
|
bc->next = 0;
|
|
|
|
*conn->write_buf_append = bc;
|
|
|
|
conn->write_buf_append = &bc->next;
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2012-08-25 16:26:23 +00:00
|
|
|
socket_write( conn_t *conn, char *buf, int len, ownership_t takeOwn )
|
|
|
|
{
|
|
|
|
if (conn->write_buf) {
|
|
|
|
do_append( conn, buf, len, takeOwn );
|
|
|
|
return len;
|
|
|
|
} else {
|
|
|
|
int n = do_write( conn, buf, len );
|
|
|
|
if (n != len && n >= 0) {
|
|
|
|
conn->write_offset = n;
|
|
|
|
do_append( conn, buf, len, takeOwn );
|
|
|
|
} else if (takeOwn) {
|
|
|
|
free( buf );
|
|
|
|
}
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
socket_fd_cb( int events, void *aux )
|
2011-01-23 12:43:00 +00:00
|
|
|
{
|
2012-08-25 16:26:23 +00:00
|
|
|
conn_t *conn = (conn_t *)aux;
|
|
|
|
|
2013-03-29 17:22:40 +00:00
|
|
|
if ((events & POLLERR) || conn->state == SCK_CONNECTING) {
|
|
|
|
int soerr;
|
|
|
|
socklen_t selen = sizeof(soerr);
|
|
|
|
if (getsockopt( conn->fd, SOL_SOCKET, SO_ERROR, &soerr, &selen )) {
|
|
|
|
perror( "getsockopt" );
|
|
|
|
exit( 1 );
|
|
|
|
}
|
|
|
|
errno = soerr;
|
|
|
|
if (conn->state == SCK_CONNECTING) {
|
|
|
|
if (errno)
|
|
|
|
socket_connect_failed( conn );
|
|
|
|
else
|
|
|
|
socket_connected( conn );
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
sys_error( "Socket error from %s", conn->name );
|
2013-03-29 17:11:57 +00:00
|
|
|
socket_fail( conn );
|
2012-08-25 16:26:23 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (events & POLLOUT)
|
2014-11-29 18:15:50 +00:00
|
|
|
conf_notifier( &conn->notify, POLLIN, 0 );
|
2011-01-23 12:43:00 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_LIBSSL
|
2012-08-25 16:26:23 +00:00
|
|
|
if (conn->state == SCK_STARTTLS) {
|
|
|
|
start_tls_p2( conn );
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (conn->ssl) {
|
|
|
|
if (do_queued_write( conn ) < 0)
|
|
|
|
return;
|
|
|
|
socket_fill( conn );
|
|
|
|
return;
|
|
|
|
}
|
2011-01-23 12:43:00 +00:00
|
|
|
#endif
|
2012-08-25 16:26:23 +00:00
|
|
|
|
|
|
|
if ((events & POLLOUT) && do_queued_write( conn ) < 0)
|
|
|
|
return;
|
|
|
|
if (events & POLLIN)
|
|
|
|
socket_fill( conn );
|
2011-01-23 12:43:00 +00:00
|
|
|
}
|
2014-11-30 18:44:41 +00:00
|
|
|
|
|
|
|
#ifdef HAVE_LIBSSL
|
|
|
|
static void
|
|
|
|
ssl_fake_cb( void *aux )
|
|
|
|
{
|
|
|
|
conn_t *conn = (conn_t *)aux;
|
|
|
|
|
|
|
|
socket_fill( conn );
|
|
|
|
}
|
|
|
|
#endif
|