/* GNU Mailutils -- a suite of utilities for electronic mail
   Copyright (C) 2003, 2004, 2007, 2008, 2009, 2010 Free Software
   Foundation, Inc.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 3 of the License, or (at your option) any later version.

   This library 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General
   Public License along with this library; if not, write to the
   Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301 USA */

#if HAVE_CONFIG_H
# include <config.h>
#endif

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <string.h>

#include <mailutils/error.h>
#include <mailutils/mu_auth.h>
#include <mailutils/tls.h>
#include <mailutils/nls.h>
#include <mailutils/stream.h>
#include <mailutils/errno.h>

struct mu_tls_module_config mu_tls_module_config = { 1, NULL, NULL, NULL };
  
int
mu_tls_module_init (enum mu_gocs_op op, void *data)
{
  switch (op)
    {
    case mu_gocs_op_set:
      if (data)
	memcpy (&mu_tls_module_config, data, sizeof mu_tls_module_config);
      break;
      
    case mu_gocs_op_flush:
#ifdef WITH_TLS
      mu_init_tls_libs ();
#endif    
      break;
    }
  return 0;
}

#ifdef WITH_TLS

#include <gnutls/gnutls.h>
#include <mailutils/sys/tls-stream.h>

#define DH_BITS 768

static gnutls_dh_params dh_params;
static gnutls_certificate_server_credentials x509_cred;

int
mu_check_tls_environment (void)
{
  /* Return: zero means NOT READY, one means READY */

  if (mu_tls_module_config.ssl_cert && mu_tls_module_config.ssl_key)
    {
      struct stat st;

      if (stat (mu_tls_module_config.ssl_cert, &st) == -1)
	{
	  mu_error ("%s: %s.", mu_tls_module_config.ssl_cert, 
		    mu_strerror (errno));
	  return 0;
	}
      if (!(st.st_mode & S_IFREG) || !(st.st_mode & S_IFLNK))
	{
	  mu_error (_("%s is not a regular file or a symbolic link."),
		    mu_tls_module_config.ssl_cert);
	  return 0;
	}

      if (stat (mu_tls_module_config.ssl_key, &st) == -1)
	{
	  mu_error ("%s: %s.", mu_tls_module_config.ssl_key,
		    mu_strerror(errno));
	  return 0;
	}
      if (!(st.st_mode & S_IFREG) || !(st.st_mode & S_IFLNK))
	{
	  mu_error (_("%s is not a regular file or a symbolic link."),
		    mu_tls_module_config.ssl_key);
	  return 0;
	}
      if ((st.st_mode & S_IRWXG) || (st.st_mode & S_IRWXO))
	{
	  mu_error (_("wrong permissions on %s (set 0600)"),
		    mu_tls_module_config.ssl_key);
	  return 0;
	}
    }
  else
    return 0;

  return 1;
}

int mu_tls_enable = 0;

#if 0
void
_mu_gtls_logger(int level, const char *text)
{
  mu_diag_output (MU_DIAG_DEBUG, "GnuTLS(%d): %s", level, text);
}
#endif

int
mu_init_tls_libs (void)
{
  if (mu_tls_module_config.enable && !mu_tls_enable)
    mu_tls_enable = !gnutls_global_init (); /* Returns 1 on success */
#if 0
  gnutls_global_set_log_function (_mu_gtls_logger);
  gnutls_global_set_log_level (110);
#endif
  return mu_tls_enable;
}

void
mu_deinit_tls_libs (void)
{
  if (mu_tls_enable)
    gnutls_global_deinit ();
  mu_tls_enable = 0;
}

static void
generate_dh_params (void)
{
  gnutls_dh_params_init (&dh_params);
  gnutls_dh_params_generate2 (dh_params, DH_BITS);
}

static gnutls_session
initialize_tls_session (void)
{
  gnutls_session session = 0;

  gnutls_init (&session, GNUTLS_SERVER);
  gnutls_set_default_priority (session);
  gnutls_credentials_set (session, GNUTLS_CRD_CERTIFICATE, x509_cred);
  gnutls_certificate_server_set_request (session, GNUTLS_CERT_REQUEST);
  gnutls_dh_set_prime_bits (session, DH_BITS);

  return session;
}

int
mu_tls_begin (void *iodata,
	      mu_tls_readline_fn reader,
	      mu_tls_writeline_fn writer,
	      mu_tls_stream_ctl_fn stream_ctl,
	      char *keywords[])
{
  int i = 0;
  int status;
  mu_stream_t streams[2], newstr;
  
  if (keywords == NULL)
    return EINVAL;

  for (i = 0; keywords[i]; i++)
    {
      switch (i)
	{
        case 0:
          /*
           *  Send STLS/STARTTLS
           */
          status = writer (iodata, keywords[i]);
          if (status != 0)
	    {
	      mu_error ("mu_tls_begin: writer (0): %s", mu_strerror (status));
	      return status;
	    }
          
          status = reader (iodata, i);
          if (status != 0)
	    {
	      mu_error ("mu_tls_begin: reader (0): %s", mu_strerror (status));
	      return status;
	    }

          status = stream_ctl (iodata, MU_TLS_SESS_GET_STREAMS, streams);
	  if (status)
	    return status;
          status = mu_tls_client_stream_create (&newstr,
						streams[0], streams[1], 0);
          if (status != 0)
	    {
	      mu_error ("mu_tls_begin: mu_tls_client_stream_create(0): %s",
			mu_strerror (status));
	      stream_ctl (iodata, MU_TLS_SESS_SET_STREAMS, streams);
	      return status;
	    }

          status = mu_stream_open (newstr);
          if (status != 0)
	    {
	      mu_error ("mu_tls_begin: mu_stream_open (0): %s",
			mu_strerror (status));
	      stream_ctl (iodata, MU_TLS_SESS_SET_STREAMS, streams);
	      return status;
	    }

	  streams[0] = streams[1] = newstr;
	  stream_ctl (iodata, MU_TLS_SESS_SET_STREAMS, streams);
	  /* FIXME: Unref newstr */
          break;

        case 1:
	  /*
	   *  Send CAPABILITIES request
	   */
          status = writer (iodata, keywords[i]);
          if (status != 0)
	    {
	      mu_error ("mu_tls_begin: writer (1): %s", mu_strerror (status));
	      return status;
	    }

          status = reader (iodata, i);
          if (status != 0)
	    {
	      mu_error ("mu_tls_begin: reader (1): %s", mu_strerror (status));
	      return status;
	    }
          break;
          
	default:
	  return 1;
	}
    }
  return 0;
}

/* ************************* TLS Stream Support **************************** */

static int
_tls_io_close (mu_stream_t stream)
{
  struct _mu_tls_io_stream *sp = (struct _mu_tls_io_stream *) stream;
  
  return mu_stream_close (sp->transport);
}

static void
_tls_io_done (struct _mu_stream *stream)
{
  struct _mu_tls_io_stream *sp = (struct _mu_tls_io_stream *) stream;
  mu_stream_unref (sp->transport);
}

static int
_tls_io_flush (struct _mu_stream *stream)
{
  struct _mu_tls_io_stream *sp = (struct _mu_tls_io_stream *) stream;
  return mu_stream_flush (sp->transport);
}

static int
_tls_io_read (struct _mu_stream *stream, char *buf, size_t bufsize,
	      size_t *pnread)
{
  struct _mu_tls_io_stream *sp = (struct _mu_tls_io_stream *) stream;
  int rc;
  
  if (sp->up->state != state_open)
    return EINVAL;
  rc = gnutls_record_recv (sp->up->session, buf, bufsize);
  if (rc >= 0)
    {
      *pnread = rc;
      return 0;
    }
  sp->up->tls_err = rc;
  return EIO;
}

static int
_tls_io_write (struct _mu_stream *stream, const char *buf, size_t bufsize,
	    size_t *pnwrite)
{
  struct _mu_tls_io_stream *sp = (struct _mu_tls_io_stream *) stream;
  int rc;
  
  if (sp->up->state != state_open)
    return EINVAL;

  /* gnutls_record_send() docs say:
       If the EINTR is returned by the internal push function (write())
       then GNUTLS_E_INTERRUPTED, will be returned. If GNUTLS_E_INTERRUPTED or
       GNUTLS_E_AGAIN is returned you must call this function again, with the
       same parameters. Otherwise the write operation will be
       corrupted and the connection will be terminated. */
    
  do
    rc = gnutls_record_send (sp->up->session, buf, bufsize);
  while (rc == GNUTLS_E_INTERRUPTED || rc == GNUTLS_E_AGAIN);

  if (rc < 0)
    {
      sp->up->tls_err = rc;
      return EIO;
    }

  *pnwrite = rc;

  return 0;
}

static int
_tls_rd_wait (struct _mu_stream *stream, int *pflags, struct timeval *tvp)
{
  struct _mu_tls_io_stream *sp = (struct _mu_tls_io_stream *) stream;
  int rc = EINVAL;
  
  if (*pflags == MU_STREAM_READY_RD)
    rc = mu_stream_wait (sp->transport, pflags, tvp);
  return rc;
}

static int
_tls_wr_wait (struct _mu_stream *stream, int *pflags, struct timeval *tvp)
{
  struct _mu_tls_io_stream *sp = (struct _mu_tls_io_stream *) stream;
  int rc = EINVAL;
  
  if (*pflags == MU_STREAM_READY_WR)
    rc = mu_stream_wait (sp->transport, pflags, tvp);
  return rc;
}

static int
_tls_io_ioctl (struct _mu_stream *stream, int op, void *arg)
{
  struct _mu_tls_io_stream *sp = (struct _mu_tls_io_stream *) stream;
  mu_transport_t *ptrans;

  switch (op)
    {
    case MU_IOCTL_GET_TRANSPORT:
      if (!arg)
	return EINVAL;
      ptrans = arg;
      ptrans[0] = (mu_transport_t) sp->transport;
      ptrans[1] = NULL;
      break;

    default:
      return EINVAL;
    }
  return 0;
}

static int
_mu_tls_io_stream_create (mu_stream_t *pstream,
			  mu_stream_t transport, int flags,
			  struct _mu_tls_stream *master)
{
  struct _mu_tls_io_stream *sp;

  sp = (struct _mu_tls_io_stream *)
    _mu_stream_create (sizeof (*sp), flags & MU_STREAM_RDWR);
  if (!sp)
    return ENOMEM;

  if (flags & MU_STREAM_READ)
    {
      sp->stream.read = _tls_io_read; 
      sp->stream.wait = _tls_rd_wait;
      mu_stream_set_buffer ((mu_stream_t) sp, mu_buffer_full, 1024);
    }
  else
    {
      sp->stream.write = _tls_io_write;
      sp->stream.wait = _tls_wr_wait;
      mu_stream_set_buffer ((mu_stream_t) sp, mu_buffer_line, 1024);
    }
  sp->stream.flush = _tls_io_flush;
  sp->stream.close = _tls_io_close;
  sp->stream.done = _tls_io_done; 
  sp->stream.ctl = _tls_io_ioctl;
  /* FIXME:
     sp->stream.error_string = _tls_error_string;*/

  if (!(flags & MU_STREAM_AUTOCLOSE))
    mu_stream_ref (transport);
  sp->transport = transport;
  sp->up = master;
  *pstream = (mu_stream_t) sp;
  return 0;
}


static ssize_t
_tls_stream_pull (gnutls_transport_ptr fd, void *buf, size_t size)
{
  mu_stream_t stream = fd;
  int rc;
  size_t rdbytes;
	
  while ((rc = mu_stream_read (stream, buf, size, &rdbytes)) == EAGAIN)
    ;
  
  if (rc)
    return -1;
  return rdbytes;
}

static ssize_t
_tls_stream_push (gnutls_transport_ptr fd, const void *buf, size_t size)
{
  mu_stream_t stream = fd;
  int rc;

  rc = mu_stream_write (stream, buf, size, &size);
  if (rc)
    {
      mu_error ("_tls_stream_push: %s", mu_strerror (rc)); /* FIXME */
      return -1;
    }

  mu_stream_flush (stream);
  return size;
}


static int
_tls_server_open (mu_stream_t stream)
{
  struct _mu_tls_stream *sp = (struct _mu_tls_stream *) stream;
  int rc = 0;
  mu_transport_t transport[2];
  
  if (!stream || sp->state != state_init)
    return EINVAL;

  gnutls_certificate_allocate_credentials (&x509_cred);

  if (mu_tls_module_config.ssl_cafile)
    gnutls_certificate_set_x509_trust_file (x509_cred,
					    mu_tls_module_config.ssl_cafile,
					    GNUTLS_X509_FMT_PEM);
  
  rc = gnutls_certificate_set_x509_key_file (x509_cred,
					     mu_tls_module_config.ssl_cert, 
					     mu_tls_module_config.ssl_key,
					     GNUTLS_X509_FMT_PEM);
  if (rc < 0)
    {
      sp->tls_err = rc;
      return EIO;
    }
  
  generate_dh_params ();
  gnutls_certificate_set_dh_params (x509_cred, dh_params);

  sp->session = initialize_tls_session ();
  mu_stream_ioctl (stream, MU_IOCTL_GET_TRANSPORT, transport);
  gnutls_transport_set_ptr2 (sp->session,
			     (gnutls_transport_ptr) transport[0],
			     (gnutls_transport_ptr) transport[1]);
  gnutls_transport_set_pull_function (sp->session, _tls_stream_pull);
  gnutls_transport_set_push_function (sp->session, _tls_stream_push);
  
  rc = gnutls_handshake (sp->session);
  if (rc < 0)
    {
      gnutls_deinit (sp->session);
      sp->tls_err = rc;
      return EIO;
    }
  sp->state = state_open;
  return 0;
}

static int
prepare_client_session (mu_stream_t stream)
{
  struct _mu_tls_stream *sp = (struct _mu_tls_stream *) stream;
  int rc;
  mu_transport_t transport[2];
  static int protocol_priority[] = {GNUTLS_TLS1, GNUTLS_SSL3, 0};
  static int kx_priority[] = {GNUTLS_KX_RSA, 0};
  static int cipher_priority[] = {GNUTLS_CIPHER_3DES_CBC,
				  GNUTLS_CIPHER_ARCFOUR_128,
				  0};
  static int comp_priority[] = {GNUTLS_COMP_NULL, 0};
  static int mac_priority[] = {GNUTLS_MAC_SHA, GNUTLS_MAC_MD5, 0};

  gnutls_init (&sp->session, GNUTLS_CLIENT);
  gnutls_protocol_set_priority (sp->session, protocol_priority);
  gnutls_cipher_set_priority (sp->session, cipher_priority);
  gnutls_compression_set_priority (sp->session, comp_priority);
  gnutls_kx_set_priority (sp->session, kx_priority);
  gnutls_mac_set_priority (sp->session, mac_priority);

  gnutls_certificate_allocate_credentials (&x509_cred);
  if (mu_tls_module_config.ssl_cafile)
    {
      rc = gnutls_certificate_set_x509_trust_file (x509_cred,
					      mu_tls_module_config.ssl_cafile,
						   GNUTLS_X509_FMT_PEM);
      if (rc < 0)
	{
	  sp->tls_err = rc;
	  return -1;
	}
    }

  gnutls_credentials_set (sp->session, GNUTLS_CRD_CERTIFICATE, x509_cred);

  mu_stream_ioctl (stream, MU_IOCTL_GET_TRANSPORT, transport);
  gnutls_transport_set_ptr2 (sp->session,
			     (gnutls_transport_ptr) transport[0],
			     (gnutls_transport_ptr) transport[1]);
  gnutls_transport_set_pull_function (sp->session, _tls_stream_pull);
  gnutls_transport_set_push_function (sp->session, _tls_stream_push);
      
  return 0;
}

static int
_tls_client_open (mu_stream_t stream)
{
  struct _mu_tls_stream *sp = (struct _mu_tls_stream *) stream;
  int rc = 0;
  
  switch (sp->state)
    {
    case state_closed:
      gnutls_certificate_free_credentials (x509_cred);
      if (sp->session)
	gnutls_deinit (sp->session);
      /* FALLTHROUGH */
      
    case state_init:
      prepare_client_session (stream);
      rc = gnutls_handshake (sp->session);
      if (rc < 0)
	{
	  sp->tls_err = rc;
	  gnutls_deinit (sp->session);
	  sp->state = state_init;
	  return MU_ERR_FAILURE;
	}
      break;

    default:
      return MU_ERR_FAILURE;
    }

  /* FIXME: if (ssl_cafile) verify_certificate (s->session); */
  sp->state = state_open;
  return 0;
}

static int
_tls_read (struct _mu_stream *str, char *buf, size_t bufsize,
	   size_t *pnread)
{
  struct _mu_tls_stream *sp = (struct _mu_tls_stream *)str;
  return mu_stream_read (sp->transport[0], buf, bufsize, pnread);
}

static int
_tls_write (struct _mu_stream *str, const char *buf, size_t bufsize,
	    size_t *pnwrite)
{
  struct _mu_tls_stream *sp = (struct _mu_tls_stream *)str;
  return mu_stream_write (sp->transport[1], buf, bufsize, pnwrite);
}

static int
_tls_ioctl (struct _mu_stream *stream, int op, void *arg)
{
  struct _mu_tls_stream *sp = (struct _mu_tls_stream *) stream;
  mu_transport_t *ptrans, trans[2];

  switch (op)
    {
    case MU_IOCTL_GET_TRANSPORT:
      if (!arg)
	return EINVAL;
      ptrans = arg;
      mu_stream_ioctl (sp->transport[0], MU_IOCTL_GET_TRANSPORT, trans);
      ptrans[0] = trans[0];
      mu_stream_ioctl (sp->transport[1], MU_IOCTL_GET_TRANSPORT, trans);
      ptrans[1] = trans[0];
      break;

    default:
      return EINVAL;
    }
  return 0;
}

static int
_tls_wait (struct _mu_stream *stream, int *pflags, struct timeval *tvp)
{
  struct _mu_tls_stream *sp = (struct _mu_tls_stream *) stream;
  int rc = EINVAL;
  
  if (*pflags == MU_STREAM_READY_RD)
    rc = mu_stream_wait (sp->transport[0], pflags, tvp);
  else if (*pflags == MU_STREAM_READY_WR)
    rc = mu_stream_wait (sp->transport[1], pflags, tvp);
  return rc;
}

static int
_tls_flush (struct _mu_stream *stream)
{
  struct _mu_tls_stream *sp = (struct _mu_tls_stream *) stream;
  return mu_stream_flush (sp->transport[1]);
}

static int
_tls_close (mu_stream_t stream)
{
  struct _mu_tls_stream *sp = (struct _mu_tls_stream *) stream;
  
  if (sp->session && sp->state == state_open)
    {
      gnutls_bye (sp->session, GNUTLS_SHUT_RDWR);
      sp->state = state_closed;
    }
  
  mu_stream_close (sp->transport[0]);
  mu_stream_close (sp->transport[1]);
  return 0;
}

static void
_tls_done (struct _mu_stream *stream)
{
  struct _mu_tls_stream *sp = (struct _mu_tls_stream *) stream;
  
  if (x509_cred)
    gnutls_certificate_free_credentials (x509_cred);
  if (sp->session && sp->state == state_closed)
    {
      gnutls_deinit (sp->session);
      sp->state = state_destroyed;
    }

  mu_stream_destroy (&sp->transport[0]);
  mu_stream_destroy (&sp->transport[1]);
}

static int
_mu_tls_stream_create (mu_stream_t *pstream,
		       int (*openfn) (mu_stream_t stream),
		       mu_stream_t strin, mu_stream_t strout, int flags)
{
  struct _mu_tls_stream *sp;
  int autoclose = flags & MU_STREAM_AUTOCLOSE;
  int rc;
  
  sp = (struct _mu_tls_stream *)
    _mu_stream_create (sizeof (*sp), MU_STREAM_RDWR);
  if (!sp)
    return ENOMEM;

  sp->stream.read = _tls_read; 
  sp->stream.write = _tls_write;
  sp->stream.flush = _tls_flush;
  sp->stream.open = openfn; 
  sp->stream.close = _tls_close;
  sp->stream.done = _tls_done; 
  sp->stream.ctl = _tls_ioctl;
  sp->stream.wait = _tls_wait;
  /* FIXME:
     sp->stream.error_string = _tls_error_string;*/

  mu_stream_set_buffer (strin, mu_buffer_none, 0);
  mu_stream_set_buffer (strout, mu_buffer_none, 0);
  rc = _mu_tls_io_stream_create (&sp->transport[0], strin,
				 MU_STREAM_READ | autoclose, sp);
  if (rc)
    {
      free (sp);
      return rc;
    }
     
  rc = _mu_tls_io_stream_create (&sp->transport[1], strout,
				 MU_STREAM_WRITE | autoclose, sp);
  if (rc)
    {
      free (sp);
      free (sp->transport[0]);
      return rc;
    }

  mu_stream_set_buffer ((mu_stream_t) sp, mu_buffer_line, 1024);
  *pstream = (mu_stream_t) sp;
  return 0;
}

int
mu_tls_server_stream_create (mu_stream_t *pstream,
			     mu_stream_t strin, mu_stream_t strout, int flags)
{
  return _mu_tls_stream_create (pstream,
				_tls_server_open,
				strin, strout, flags);
}

int
mu_tls_client_stream_create (mu_stream_t *pstream,
			     mu_stream_t strin, mu_stream_t strout, int flags)
{
  return _mu_tls_stream_create (pstream,
				_tls_client_open,
				strin, strout, flags);
}


#endif /* WITH_TLS */

/* EOF */