plugin_transport_smtp.c File Reference

Implementation of the SMTP transport service. More...

#include "platform.h"
#include "gnunet_util.h"
#include "gnunet_constants.h"
#include "gnunet_protocols.h"
#include "gnunet_transport.h"
#include "gnunet_stats_service.h"
#include <libesmtp.h>
#include <signal.h>

Include dependency graph for plugin_transport_smtp.c:

Go to the source code of this file.

Data Structures
struct	EmailAddress
	Host-Address in a SMTP network. More...
struct	SMTPMessage
	Encapsulation of a GNUnet message in the SMTP mail body (before base64 encoding). More...
struct	GetMessageClosure

Macros
#define	SMTP_MESSAGE_SIZE   65528
	The default maximum size of each outbound SMTP message. More...
#define	DEBUG_SMTP   GNUNET_EXTRA_LOGGING
#define	FILTER_STRING_SIZE   64
#define	MAX_CHAR_PER_LINE   76
#define	EBUF_LEN   128
#define	strAUTOncmp(a, b)   strncmp (a, b, strlen (b))
#define	READLINE(l, limit)
#define	EBUF_LEN   128

Functions
static void *	listenAndDistribute (void *unused)
	Listen to the pipe, decode messages and send to core. More...
static int	api_verify_hello (const GNUNET_MessageHello *hello)
	Verify that a hello-Message is correct (a node is reachable at that address). More...
static GNUNET_MessageHello *	api_create_hello ()
	Create a hello-Message for the current node. More...
static const char *	get_message (void **buf, int *len, void *cls)
static int	api_send (GNUNET_TSession *tsession, const void *msg, const unsigned int size, int important)
	Send a message to the specified remote node. More...
static int	api_connect (const GNUNET_MessageHello *hello, GNUNET_TSession **tsessionPtr, int may_reuse)
	Establish a connection to a remote node. More...
static int	api_disconnect (GNUNET_TSession *tsession)
	Disconnect from a remote node. More...
static int	api_start_transport_server ()
	Start the server process to receive inbound traffic. More...
static int	api_stop_transport_server ()
	Shutdown the server process (stop receiving inbound traffic). More...
static int	api_hello_to_address (const GNUNET_MessageHello *hello, void **sa, unsigned int *sa_len)
	Convert SMTP hello to an IP address (always fails). More...
static int	api_associate (GNUNET_TSession *tsession)
	Always fails. More...
static int	api_test_would_try (GNUNET_TSession *tsession, unsigned int size, int important)
	Always succeeds (for now; we should look at adding frequency limits to SMTP in the future!). More...
GNUNET_TransportAPI *	inittransport_smtp (struct GNUNET_CoreAPIForTransport *core)
	The exported method. More...
void	donetransport_smtp ()

Variables
static GNUNET_NETWORK_STRUCT_END GNUNET_CoreAPIForTransport *	core_api
	apis (our advertised API and the core api ) More...
static struct GNUNET_GE_Context *	ectx
static struct GNUNET_ThreadHandle *	dispatchThread
	Thread that listens for inbound messages. More...
static int	smtp_shutdown = GNUNET_YES
	Flag to indicate that server has been shut down. More...
static char *	smtp_server_name
	Set to the SMTP server hostname (and port) for outgoing messages. More...
static char *	pipename
static struct GNUNET_Mutex *	lock
	Lock for uses of libesmtp (not thread-safe). More...
static struct sigaction	old_handler
	Old handler for SIGPIPE (kept to be able to restore). More...
static char *	email
static GNUNET_TransportAPI	smtpAPI
static GNUNET_Stats_ServiceAPI *	stats
static int	stat_bytesReceived
static int	stat_bytesSent
static int	stat_bytesDropped
static unsigned long long	rate_limit
	How many e-mails are we allowed to send per hour? More...
static GNUNET_CronTime	last_transmission

Detailed Description

Implementation of the SMTP transport service.

Author

Christian Grothoff

Renaldo Ferreira

Definition in file plugin_transport_smtp.c.

Macro Definition Documentation

SMTP_MESSAGE_SIZE

#define SMTP_MESSAGE_SIZE   65528

The default maximum size of each outbound SMTP message.

Definition at line 41 of file plugin_transport_smtp.c.

DEBUG_SMTP

#define DEBUG_SMTP   GNUNET_EXTRA_LOGGING

Definition at line 43 of file plugin_transport_smtp.c.

FILTER_STRING_SIZE

#define FILTER_STRING_SIZE   64

Definition at line 45 of file plugin_transport_smtp.c.

MAX_CHAR_PER_LINE

#define MAX_CHAR_PER_LINE   76

Definition at line 49 of file plugin_transport_smtp.c.

EBUF_LEN [1/2]

#define EBUF_LEN   128

Definition at line 51 of file plugin_transport_smtp.c.

strAUTOncmp

#define strAUTOncmp	(		a,
			b
	)		strncmp (a, b, strlen (b))

Definition at line 148 of file plugin_transport_smtp.c.

READLINE

#define READLINE	(		l,
			limit
	)

Value:

  do { retl = fgets (l, (limit), fdes);                          \
       if ((retl == NULL) || (smtp_shutdown == GNUNET_YES)) { \
         goto END; \
       } \
       if (core_api->load_monitor != NULL) \
       GNUNET_network_monitor_notify_transmission (core_api->load_monitor, \
                                                   GNUNET_ND_DOWNLOAD, \
                                                   strlen (retl)); \
  } while (0)

EBUF_LEN [2/2]

#define EBUF_LEN   128

Definition at line 51 of file plugin_transport_smtp.c.

Function Documentation

listenAndDistribute()

static void* listenAndDistribute ( void *  unused )

static

Listen to the pipe, decode messages and send to core.

Definition at line 154 of file plugin_transport_smtp.c.

{
  char *line;
  unsigned int linesize;
  SMTPMessage *mp;
  FILE *fdes;
  char *retl;
  char *out;
  unsigned int size;
  GNUNET_TransportPacket *coreMP;
  int fd;
  unsigned int pos;
 
  linesize = ((GNUNET_MAX_BUFFER_SIZE * 4 / 3) + 8) * (MAX_CHAR_PER_LINE + 2)
             / MAX_CHAR_PER_LINE;                                                                       /* maximum size of a line supported */
  line = GNUNET_malloc (linesize + 2);   /* 2 bytes for off-by-one errors, just to be safe... */
 
#define READLINE(l, limit) \
  do { retl = fgets (l, (limit), fdes);                          \
       if ((retl == NULL) || (smtp_shutdown == GNUNET_YES)) { \
         goto END; \
       } \
       if (core_api->load_monitor != NULL) \
       GNUNET_network_monitor_notify_transmission (core_api->load_monitor, \
                                                   GNUNET_ND_DOWNLOAD, \
                                                   strlen (retl)); \
  } while (0)
 
 
  while (smtp_shutdown == GNUNET_NO)
  {
    fd = OPEN (pipename, O_RDONLY | O_ASYNC);
    if (fd == -1)
    {
      if (smtp_shutdown == GNUNET_NO)
        GNUNET_thread_sleep (5 * GNUNET_CRON_SECONDS);
      continue;
    }
    fdes = fdopen (fd, "r");
    while (smtp_shutdown == GNUNET_NO)
    {
      /* skip until end of header */
      do
      {
        READLINE (line, linesize);
      }
      while ((line[0] != '\r') && (line[0] != '\n'));     /* expect newline */
      READLINE (line, linesize);        /* read base64 encoded message; decode, process */
      pos = 0;
      while (1)
      {
        pos = strlen (line) - 1;        /* ignore new line */
        READLINE (&line[pos], linesize - pos);      /* read base64 encoded message; decode, process */
        if ((line[pos] == '\r') || (line[pos] == '\n'))
          break;                /* empty line => end of message! */
      }
      size = GNUNET_STRINGS_base64_decode (line, pos, &out);
      if (size < sizeof(SMTPMessage))
      {
        GNUNET_GE_BREAK (ectx, 0);
        GNUNET_free (out);
        goto END;
      }
 
      mp = (SMTPMessage *) &out[size - sizeof(SMTPMessage)];
      if (ntohs (mp->header.size) != size)
      {
        GNUNET_GE_LOG (ectx,
                       GNUNET_GE_WARNING | GNUNET_GE_BULK | GNUNET_GE_USER,
                       _ ("Received malformed message via %s. Ignored.\n"),
                       "SMTP");
#if DEBUG_SMTP
        GNUNET_GE_LOG (ectx,
                       GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER,
                       "Size returned by base64=%d, in the msg=%d.\n", size,
                       ntohl (mp->size));
#endif
        GNUNET_free (out);
        goto END;
      }
      if (stats != NULL)
        stats->change (stat_bytesReceived, size);
      coreMP = GNUNET_new (GNUNET_TransportPacket);
      coreMP->msg = out;
      coreMP->size = size - sizeof(SMTPMessage);
      coreMP->tsession = NULL;
      coreMP->sender = mp->sender;
#if DEBUG_SMTP
      GNUNET_GE_LOG (ectx, GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER,
                     "SMTP message passed to the core.\n");
#endif
 
      core_api->receive (coreMP);
    }
END:
#if DEBUG_SMTP
    GNUNET_GE_LOG (ectx, GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER,
                   "SMTP message processed.\n");
#endif
    if (fdes != NULL)
      fclose (fdes);
  }
  GNUNET_free (line);
  return NULL;
}

References _, core_api, ectx, END, GNUNET_free, GNUNET_malloc, GNUNET_new, GNUNET_NO, GNUNET_STRINGS_base64_decode(), SMTPMessage::header, line, MAX_CHAR_PER_LINE, pipename, READLINE, SMTPMessage::sender, GNUNET_MessageHeader::size, size, smtp_shutdown, stat_bytesReceived, and stats.

Referenced by api_start_transport_server().

Here is the call graph for this function:

Here is the caller graph for this function:

api_verify_hello()

static int api_verify_hello ( const GNUNET_MessageHello *  hello )

static

Verify that a hello-Message is correct (a node is reachable at that address).

Since the reply will be asynchronous, a method must be called on success.

Parameters

hello

the hello message to verify (the signature/crc have been verified before)

Returns

GNUNET_OK on success, GNUNET_SYSERR on error

Definition at line 273 of file plugin_transport_smtp.c.

{
  const EmailAddress *maddr;
 
  maddr = (const EmailAddress *) &hello[1];
  if ((ntohs (hello->header.size) !=
       sizeof(GNUNET_MessageHello) + ntohs (hello->senderAddressSize)) ||
      (maddr->senderAddress
       [ntohs (hello->senderAddressSize) - 1 - FILTER_STRING_SIZE] != '\0'))
  {
    GNUNET_GE_BREAK (ectx, 0);
    return GNUNET_SYSERR;       /* obviously invalid */
  }
  if (NULL == strstr (maddr->filter, ": "))
    return GNUNET_SYSERR;
  return GNUNET_OK;
}

References ectx, EmailAddress::filter, FILTER_STRING_SIZE, GNUNET_OK, GNUNET_SYSERR, and EmailAddress::senderAddress.

Referenced by api_create_hello(), and inittransport_smtp().

Here is the caller graph for this function:

api_create_hello()

static GNUNET_MessageHello* api_create_hello ( )

static

Create a hello-Message for the current node.

The hello is created without signature and without a timestamp. The GNUnet core will GNUNET_RSA_sign the message and add an expiration time.

Returns

hello on success, NULL on error

Definition at line 300 of file plugin_transport_smtp.c.

{
  GNUNET_MessageHello *msg;
  char *filter;
  EmailAddress *haddr;
  int i;
 
  GNUNET_GC_get_configuration_value_string (core_api->cfg, "SMTP", "FILTER",
                                            "X-mailer: GNUnet", &filter);
  if (NULL == strstr (filter, ": "))
  {
    GNUNET_GE_LOG (ectx, GNUNET_GE_WARNING | GNUNET_GE_BULK | GNUNET_GE_USER,
                   _ ("SMTP filter string to invalid, lacks ': '\n"));
    GNUNET_free (filter);
    return NULL;
  }
 
  if (strlen (filter) > FILTER_STRING_SIZE)
  {
    filter[FILTER_STRING_SIZE] = '\0';
    GNUNET_GE_LOG (ectx, GNUNET_GE_WARNING | GNUNET_GE_BULK | GNUNET_GE_USER,
                   _ ("SMTP filter string to long, capped to `%s'\n"), filter);
  }
  i = (strlen (email) + 8) & (~7);       /* make multiple of 8 */
  msg =
    GNUNET_malloc (sizeof(GNUNET_MessageHello) + sizeof(EmailAddress) + i);
  memset (msg, 0, sizeof(GNUNET_MessageHello) + sizeof(EmailAddress) + i);
  haddr = (EmailAddress *) &msg[1];
  memset (&haddr->filter[0], 0, FILTER_STRING_SIZE);
  strcpy (&haddr->filter[0], filter);
  GNUNET_memcpy (&haddr->senderAddress[0], email, strlen (email) + 1);
  msg->senderAddressSize = htons (strlen (email) + 1 + sizeof(EmailAddress));
  msg->protocol = htons (GNUNET_TRANSPORT_PROTOCOL_NUMBER_SMTP);
  msg->MTU = htonl (smtpAPI.mtu);
  msg->header.size = htons (GNUNET_sizeof_hello (msg));
  if (api_verify_hello (msg) == GNUNET_SYSERR)
    GNUNET_GE_ASSERT (ectx, 0);
  GNUNET_free (filter);
  return msg;
}

References _, api_verify_hello(), core_api, ectx, email, filter, EmailAddress::filter, FILTER_STRING_SIZE, GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_SYSERR, msg, EmailAddress::senderAddress, GNUNET_MessageHeader::size, and smtpAPI.

Referenced by inittransport_smtp().

Here is the call graph for this function:

Here is the caller graph for this function:

get_message()

static const char* get_message ( void **  buf, int *  len, void *  cls  )

static

Definition at line 350 of file plugin_transport_smtp.c.

{
  struct GetMessageClosure *gmc = cls;
 
  *buf = NULL;
  if (len == NULL)
  {
    gmc->pos = 0;
    return NULL;
  }
  if (gmc->pos == gmc->esize)
    return NULL;                /* done */
  *len = gmc->esize;
  gmc->pos = gmc->esize;
  return gmc->ebody;
}

References buf, GetMessageClosure::ebody, GetMessageClosure::esize, len, and GetMessageClosure::pos.

Referenced by api_send().

Here is the caller graph for this function:

api_send()

static int api_send ( GNUNET_TSession *  tsession, const void *  msg, const unsigned int  size, int  important  )

static

Send a message to the specified remote node.

Parameters

tsession	the GNUNET_MessageHello identifying the remote node
msg	what to send
size	the size of the message
important	is this message important enough to override typical limits?

Returns

GNUNET_SYSERR on error, GNUNET_OK on success

Definition at line 378 of file plugin_transport_smtp.c.

{
  const GNUNET_MessageHello *hello;
  const EmailAddress *haddr;
  char *m;
  char *filter;
  char *fvalue;
  SMTPMessage *mp;
  struct GetMessageClosure gm_cls;
  smtp_session_t session;
  smtp_message_t message;
  smtp_recipient_t recipient;
 
#define EBUF_LEN 128
  char ebuf[EBUF_LEN];
  GNUNET_CronTime now;
 
  if (smtp_shutdown == GNUNET_YES)
    return GNUNET_SYSERR;
  if ((size == 0) || (size > smtpAPI.mtu))
  {
    GNUNET_GE_BREAK (ectx, 0);
    return GNUNET_SYSERR;
  }
  now = GNUNET_get_time ();
  if ((important != GNUNET_YES) &&
      ( ((now - last_transmission) * rate_limit) < GNUNET_CRON_HOURS) )
    return GNUNET_NO;           /* rate too high */
  last_transmission = now;
 
  hello = (const GNUNET_MessageHello *) tsession->internal;
  if (hello == NULL)
    return GNUNET_SYSERR;
  GNUNET_mutex_lock (lock);
  session = smtp_create_session ();
  if (session == NULL)
  {
    GNUNET_GE_LOG (ectx,
                   GNUNET_GE_ERROR | GNUNET_GE_ADMIN | GNUNET_GE_USER
                   | GNUNET_GE_IMMEDIATE, _ ("SMTP: `%s' failed: %s.\n"),
                   "smtp_create_session", smtp_strerror (smtp_errno (), ebuf,
                                                         EBUF_LEN));
    GNUNET_mutex_unlock (lock);
    return GNUNET_SYSERR;
  }
  if (0 == smtp_set_server (session, smtp_server_name))
  {
    GNUNET_GE_LOG (ectx,
                   GNUNET_GE_ERROR | GNUNET_GE_ADMIN | GNUNET_GE_USER
                   | GNUNET_GE_IMMEDIATE, _ ("SMTP: `%s' failed: %s.\n"),
                   "smtp_set_server", smtp_strerror (smtp_errno (), ebuf,
                                                     EBUF_LEN));
    smtp_destroy_session (session);
    GNUNET_mutex_unlock (lock);
    return GNUNET_SYSERR;
  }
  haddr = (const EmailAddress *) &hello[1];
  message = smtp_add_message (session);
  if (message == NULL)
  {
    GNUNET_GE_LOG (ectx,
                   GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER
                   | GNUNET_GE_BULK, _ ("SMTP: `%s' failed: %s.\n"),
                   "smtp_add_message", smtp_strerror (smtp_errno (), ebuf,
                                                      EBUF_LEN));
    smtp_destroy_session (session);
    GNUNET_mutex_unlock (lock);
    return GNUNET_SYSERR;
  }
  smtp_set_header (message, "To", NULL, haddr->senderAddress);
  smtp_set_header (message, "From", NULL, email);
 
  filter = GNUNET_strdup (haddr->filter);
  fvalue = strstr (filter, ": ");
  GNUNET_GE_ASSERT (NULL, NULL != fvalue);
  fvalue[0] = '\0';
  fvalue += 2;
  if (0 == smtp_set_header (message, filter, fvalue))
  {
    GNUNET_GE_LOG (ectx,
                   GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER
                   | GNUNET_GE_BULK, _ ("SMTP: `%s' failed: %s.\n"),
                   "smtp_set_header", smtp_strerror (smtp_errno (), ebuf,
                                                     EBUF_LEN));
    smtp_destroy_session (session);
    GNUNET_mutex_unlock (lock);
    GNUNET_free (filter);
    return GNUNET_SYSERR;
  }
  GNUNET_free (filter);
  m = GNUNET_malloc (size + sizeof(SMTPMessage));
  GNUNET_memcpy (m, msg, size);
  mp = (SMTPMessage *) &m[size];
  mp->header.size = htons (size + sizeof(SMTPMessage));
  mp->header.type = htons (0);
  mp->sender = *core_api->my_identity;
  gm_cls.ebody = NULL;
  gm_cls.pos = 0;
  gm_cls.esize = GNUNET_STRINGS_base64_encode (m, size + sizeof(SMTPMessage),
                                               &gm_cls.ebody);
  GNUNET_free (m);
  if (0 == smtp_size_set_estimate (message, gm_cls.esize))
  {
    GNUNET_GE_LOG (ectx,
                   GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER
                   | GNUNET_GE_BULK, _ ("SMTP: `%s' failed: %s.\n"),
                   "smtp_size_set_estimate", smtp_strerror (smtp_errno (), ebuf,
                                                            EBUF_LEN));
  }
  if (0 == smtp_set_messagecb (message, &get_message, &gm_cls))
  {
    GNUNET_GE_LOG (ectx,
                   GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER
                   | GNUNET_GE_BULK, _ ("SMTP: `%s' failed: %s.\n"),
                   "smtp_set_messagecb", smtp_strerror (smtp_errno (), ebuf,
                                                        EBUF_LEN));
    smtp_destroy_session (session);
    GNUNET_mutex_unlock (lock);
    GNUNET_free (gm_cls.ebody);
    return GNUNET_SYSERR;
  }
  recipient = smtp_add_recipient (message, haddr->senderAddress);
  if (recipient == NULL)
  {
    GNUNET_GE_LOG (ectx,
                   GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER
                   | GNUNET_GE_BULK, _ ("SMTP: `%s' failed: %s.\n"),
                   "smtp_add_recipient", smtp_strerror (smtp_errno (), ebuf,
                                                        EBUF_LEN));
    smtp_destroy_session (session);
    GNUNET_mutex_unlock (lock);
    return GNUNET_SYSERR;
  }
  if (0 == smtp_start_session (session))
  {
    GNUNET_GE_LOG (ectx,
                   GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER
                   | GNUNET_GE_BULK, _ ("SMTP: `%s' failed: %s.\n"),
                   "smtp_start_session", smtp_strerror (smtp_errno (), ebuf,
                                                        EBUF_LEN));
    smtp_destroy_session (session);
    GNUNET_mutex_unlock (lock);
    GNUNET_free (gm_cls.ebody);
    return GNUNET_SYSERR;
  }
  if (stats != NULL)
    stats->change (stat_bytesSent, size);
  if (core_api->load_monitor != NULL)
    GNUNET_network_monitor_notify_transmission (core_api->load_monitor,
                                                GNUNET_ND_UPLOAD, gm_cls.esize);
  smtp_message_reset_status (message);   /* this is needed to plug a 28-byte/message memory leak in libesmtp */
  smtp_destroy_session (session);
  GNUNET_mutex_unlock (lock);
  GNUNET_free (gm_cls.ebody);
  return GNUNET_OK;
}

References _, core_api, GetMessageClosure::ebody, EBUF_LEN, ectx, email, GetMessageClosure::esize, filter, EmailAddress::filter, get_message(), GNUNET_free, GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_strdup, GNUNET_STRINGS_base64_encode(), GNUNET_SYSERR, GNUNET_YES, SMTPMessage::header, last_transmission, lock, m, msg, GetMessageClosure::pos, rate_limit, SMTPMessage::sender, EmailAddress::senderAddress, GNUNET_MessageHeader::size, size, smtp_server_name, smtp_shutdown, smtpAPI, stat_bytesSent, stats, and GNUNET_MessageHeader::type.

Referenced by inittransport_smtp().

Here is the call graph for this function:

Here is the caller graph for this function:

api_connect()

static int api_connect ( const GNUNET_MessageHello *  hello, GNUNET_TSession **  tsessionPtr, int  may_reuse  )

static

Establish a connection to a remote node.

Parameters

hello	the hello-Message for the target node
tsessionPtr	the session handle that is to be set
may_reuse	can we re-use an existing connection?

Returns

GNUNET_OK on success, GNUNET_SYSERR if the operation failed

Definition at line 545 of file plugin_transport_smtp.c.

{
  GNUNET_TSession *tsession;
 
  tsession = GNUNET_new (GNUNET_TSession);
  tsession->internal = GNUNET_malloc (GNUNET_sizeof_hello (hello));
  tsession->peer = hello->senderIdentity;
  GNUNET_memcpy (tsession->internal, hello, GNUNET_sizeof_hello (hello));
  tsession->ttype = smtpAPI.protocol_number;
  (*tsessionPtr) = tsession;
  return GNUNET_OK;
}

References GNUNET_malloc, GNUNET_memcpy, GNUNET_new, GNUNET_OK, and smtpAPI.

Referenced by inittransport_smtp().

Here is the caller graph for this function:

api_disconnect()

static int api_disconnect ( GNUNET_TSession *  tsession )

static

Disconnect from a remote node.

Parameters

tsession

the session that is closed

Returns

GNUNET_OK on success, GNUNET_SYSERR if the operation failed

Definition at line 567 of file plugin_transport_smtp.c.

{
  if (tsession != NULL)
  {
    if (tsession->internal != NULL)
      GNUNET_free (tsession->internal);
    GNUNET_free (tsession);
  }
  return GNUNET_OK;
}

References GNUNET_free, and GNUNET_OK.

Referenced by inittransport_smtp().

Here is the caller graph for this function:

api_start_transport_server()

static int api_start_transport_server ( )

static

Start the server process to receive inbound traffic.

Returns

GNUNET_OK on success, GNUNET_SYSERR if the operation failed

Definition at line 584 of file plugin_transport_smtp.c.

{
  smtp_shutdown = GNUNET_NO;
  /* initialize SMTP network */
  dispatchThread = GNUNET_thread_create (&listenAndDistribute, NULL, 1024 * 4);
  if (dispatchThread == NULL)
  {
    GNUNET_GE_DIE_STRERROR (ectx,
                            GNUNET_GE_ADMIN | GNUNET_GE_BULK | GNUNET_GE_FATAL,
                            "pthread_create");
    return GNUNET_SYSERR;
  }
  return GNUNET_OK;
}

References dispatchThread, ectx, GNUNET_NO, GNUNET_OK, GNUNET_SYSERR, listenAndDistribute(), and smtp_shutdown.

Referenced by inittransport_smtp().

Here is the call graph for this function:

Here is the caller graph for this function:

api_stop_transport_server()

static int api_stop_transport_server ( )

static

Shutdown the server process (stop receiving inbound traffic).

Maybe restarted later!

Definition at line 605 of file plugin_transport_smtp.c.

{
  void *unused;
 
  smtp_shutdown = GNUNET_YES;
  GNUNET_thread_stop_sleep (dispatchThread);
  GNUNET_thread_join (dispatchThread, &unused);
  return GNUNET_OK;
}

References dispatchThread, GNUNET_OK, GNUNET_YES, and smtp_shutdown.

Referenced by inittransport_smtp().

Here is the caller graph for this function:

api_hello_to_address()

static int api_hello_to_address ( const GNUNET_MessageHello *  hello, void **  sa, unsigned int *  sa_len  )

static

Convert SMTP hello to an IP address (always fails).

Definition at line 620 of file plugin_transport_smtp.c.

{
  return GNUNET_SYSERR;
}

References GNUNET_SYSERR.

Referenced by inittransport_smtp().

Here is the caller graph for this function:

api_associate()

static int api_associate ( GNUNET_TSession *  tsession )

static

Always fails.

Definition at line 631 of file plugin_transport_smtp.c.

{
  return GNUNET_SYSERR;         /* SMTP connections can never be associated */
}

References GNUNET_SYSERR.

Referenced by inittransport_smtp().

Here is the caller graph for this function:

api_test_would_try()

static int api_test_would_try ( GNUNET_TSession *  tsession, unsigned int  size, int  important  )

static

Always succeeds (for now; we should look at adding frequency limits to SMTP in the future!).

Definition at line 642 of file plugin_transport_smtp.c.

{
  return GNUNET_OK;             /* we always try... */
}

References GNUNET_OK.

Referenced by inittransport_smtp().

Here is the caller graph for this function:

inittransport_smtp()

GNUNET_TransportAPI* inittransport_smtp

(

struct GNUNET_CoreAPIForTransport *

core

)

The exported method.

Makes the core api available via a global and returns the smtp transport API.

Definition at line 654 of file plugin_transport_smtp.c.

{
  unsigned long long mtu;
  struct sigaction sa;
 
  core_api = core;
  ectx = core->ectx;
  if (! GNUNET_GC_have_configuration_value (core_api->cfg, "SMTP", "EMAIL"))
  {
    GNUNET_GE_LOG (ectx, GNUNET_GE_ERROR | GNUNET_GE_BULK | GNUNET_GE_USER,
                   _
                   (
                     "No email-address specified, can not start SMTP transport.\n"));
    return NULL;
  }
  GNUNET_GC_get_configuration_value_number (core_api->cfg, "SMTP", "MTU", 1200,
                                            SMTP_MESSAGE_SIZE,
                                            SMTP_MESSAGE_SIZE, &mtu);
  GNUNET_GC_get_configuration_value_number (core_api->cfg, "SMTP", "RATELIMIT",
                                            0, 0, 1024 * 1024, &rate_limit);
  stats = core_api->service_request ("stats");
  if (stats != NULL)
  {
    stat_bytesReceived =
      stats->create (gettext_noop ("# bytes received via SMTP"));
    stat_bytesSent = stats->create (gettext_noop ("# bytes sent via SMTP"));
    stat_bytesDropped =
      stats->create (gettext_noop ("# bytes dropped by SMTP (outgoing)"));
  }
  GNUNET_GC_get_configuration_value_filename (core_api->cfg, "SMTP", "PIPE",
                                              &pipename);
  unlink (pipename);
  if (0 != mkfifo (pipename, S_IWUSR | S_IRUSR | S_IWGRP | S_IWOTH))
  {
    GNUNET_GE_LOG_STRERROR (ectx,
                            GNUNET_GE_ADMIN | GNUNET_GE_BULK | GNUNET_GE_FATAL,
                            "mkfifo");
    GNUNET_free (pipename);
    core_api->service_release (stats);
    stats = NULL;
    return NULL;
  }
  /* we need to allow the mailer program to send us messages;
   * easiest done by giving it write permissions (see Mantis #1142) */
  if (0 != chmod (pipename, S_IWUSR | S_IRUSR | S_IWGRP | S_IWOTH))
    GNUNET_GE_LOG_STRERROR (ectx,
                            GNUNET_GE_ADMIN | GNUNET_GE_BULK
                            | GNUNET_GE_WARNING, "chmod");
  GNUNET_GC_get_configuration_value_string (core_api->cfg, "SMTP", "EMAIL",
                                            NULL,
                                            &email);
  lock = GNUNET_mutex_create (GNUNET_NO);
  GNUNET_GC_get_configuration_value_string (core_api->cfg, "SMTP", "SERVER",
                                            "localhost:25", &smtp_server_name);
  sa.sa_handler = SIG_IGN;
  sigemptyset (&sa.sa_mask);
  sa.sa_flags = 0;
  sigaction (SIGPIPE, &sa, &old_handler);
 
  smtpAPI.protocol_number = GNUNET_TRANSPORT_PROTOCOL_NUMBER_SMTP;
  smtpAPI.mtu = mtu - sizeof(SMTPMessage);
  smtpAPI.cost = 50;
  smtpAPI.hello_verify = &api_verify_hello;
  smtpAPI.hello_create = &api_create_hello;
  smtpAPI.connect = &api_connect;
  smtpAPI.send = &api_send;
  smtpAPI.associate = &api_associate;
  smtpAPI.disconnect = &api_disconnect;
  smtpAPI.server_start = &api_start_transport_server;
  smtpAPI.server_stop = &api_stop_transport_server;
  smtpAPI.hello_to_address = &api_hello_to_address;
  smtpAPI.send_now_test = &api_test_would_try;
  return &smtpAPI;
}

References _, api_associate(), api_connect(), api_create_hello(), api_disconnect(), api_hello_to_address(), api_send(), api_start_transport_server(), api_stop_transport_server(), api_test_would_try(), api_verify_hello(), core, core_api, ectx, email, gettext_noop, GNUNET_free, GNUNET_NO, lock, old_handler, pipename, rate_limit, SMTP_MESSAGE_SIZE, smtp_server_name, smtpAPI, stat_bytesDropped, stat_bytesReceived, stat_bytesSent, and stats.

Here is the call graph for this function:

donetransport_smtp()

void donetransport_smtp

(

)

Definition at line 731 of file plugin_transport_smtp.c.

{
  sigaction (SIGPIPE, &old_handler, NULL);
  GNUNET_free (smtp_server_name);
  if (stats != NULL)
  {
    core_api->service_release (stats);
    stats = NULL;
  }
  GNUNET_mutex_destroy (lock);
  lock = NULL;
  unlink (pipename);
  GNUNET_free (pipename);
  pipename = NULL;
  GNUNET_free (email);
  email = NULL;
}

References core_api, email, GNUNET_free, lock, old_handler, pipename, smtp_server_name, and stats.

Variable Documentation

core_api

GNUNET_NETWORK_STRUCT_END GNUNET_CoreAPIForTransport* core_api

static

apis (our advertised API and the core api )

Definition at line 95 of file plugin_transport_smtp.c.

Referenced by api_create_hello(), api_send(), donetransport_smtp(), inittransport_smtp(), and listenAndDistribute().

ectx

struct GNUNET_GE_Context* ectx

static

Definition at line 97 of file plugin_transport_smtp.c.

Referenced by api_create_hello(), api_send(), api_start_transport_server(), api_verify_hello(), inittransport_smtp(), and listenAndDistribute().

dispatchThread

struct GNUNET_ThreadHandle* dispatchThread

static

Thread that listens for inbound messages.

Definition at line 102 of file plugin_transport_smtp.c.

Referenced by api_start_transport_server(), and api_stop_transport_server().

smtp_shutdown

int smtp_shutdown = GNUNET_YES

static

Flag to indicate that server has been shut down.

Definition at line 107 of file plugin_transport_smtp.c.

Referenced by api_send(), api_start_transport_server(), api_stop_transport_server(), and listenAndDistribute().

smtp_server_name

char* smtp_server_name

static

Set to the SMTP server hostname (and port) for outgoing messages.

Definition at line 112 of file plugin_transport_smtp.c.

Referenced by api_send(), donetransport_smtp(), and inittransport_smtp().

pipename

char* pipename

static

Definition at line 114 of file plugin_transport_smtp.c.

Referenced by donetransport_smtp(), inittransport_smtp(), and listenAndDistribute().

lock

struct GNUNET_Mutex* lock

static

Lock for uses of libesmtp (not thread-safe).

Definition at line 119 of file plugin_transport_smtp.c.

Referenced by api_send(), donetransport_smtp(), and inittransport_smtp().

old_handler

struct sigaction old_handler

static

Old handler for SIGPIPE (kept to be able to restore).

Definition at line 119 of file plugin_transport_smtp.c.

Referenced by donetransport_smtp(), and inittransport_smtp().

email

char* email

static

Definition at line 126 of file plugin_transport_smtp.c.

Referenced by api_create_hello(), api_send(), donetransport_smtp(), and inittransport_smtp().

smtpAPI

GNUNET_TransportAPI smtpAPI

static

Definition at line 128 of file plugin_transport_smtp.c.

Referenced by api_connect(), api_create_hello(), api_send(), and inittransport_smtp().

stats

GNUNET_Stats_ServiceAPI* stats

static

Definition at line 130 of file plugin_transport_smtp.c.

Referenced by api_send(), donetransport_smtp(), inittransport_smtp(), and listenAndDistribute().

stat_bytesReceived

int stat_bytesReceived

static

Definition at line 132 of file plugin_transport_smtp.c.

Referenced by inittransport_smtp(), and listenAndDistribute().

stat_bytesSent

int stat_bytesSent

static

Definition at line 134 of file plugin_transport_smtp.c.

Referenced by api_send(), and inittransport_smtp().

stat_bytesDropped

int stat_bytesDropped

static

Definition at line 136 of file plugin_transport_smtp.c.

Referenced by inittransport_smtp().

rate_limit

unsigned long long rate_limit

static

How many e-mails are we allowed to send per hour?

Definition at line 141 of file plugin_transport_smtp.c.

Referenced by api_send(), and inittransport_smtp().

last_transmission

GNUNET_CronTime last_transmission

static

Definition at line 143 of file plugin_transport_smtp.c.

Referenced by api_send(), and client_response_handler().