GNUnet  0.11.x
Data Structures | Macros | Functions | Variables
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.

Referenced by inittransport_smtp().

◆ 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.

Referenced by api_create_hello(), and api_verify_hello().

◆ MAX_CHAR_PER_LINE

#define MAX_CHAR_PER_LINE   76

Definition at line 49 of file plugin_transport_smtp.c.

Referenced by listenAndDistribute().

◆ EBUF_LEN [1/2]

#define EBUF_LEN   128

Definition at line 51 of file plugin_transport_smtp.c.

Referenced by api_send().

◆ strAUTOncmp

#define strAUTOncmp (   a,
 
)    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)
We&#39;re done processing.
static GNUNET_NETWORK_STRUCT_END GNUNET_CoreAPIForTransport * core_api
apis (our advertised API and the core api )
static struct LoggingHandle * l
static int smtp_shutdown
Flag to indicate that server has been shut down.
#define GNUNET_YES
Definition: gnunet_common.h:77

Referenced by listenAndDistribute().

◆ 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.

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, size, GNUNET_MessageHeader::size, smtp_shutdown, stat_bytesReceived, and stats.

Referenced by api_start_transport_server().

155 {
156  char *line;
157  unsigned int linesize;
158  SMTPMessage *mp;
159  FILE *fdes;
160  char *retl;
161  char *out;
162  unsigned int size;
163  GNUNET_TransportPacket *coreMP;
164  int fd;
165  unsigned int pos;
166 
167  linesize = ((GNUNET_MAX_BUFFER_SIZE * 4 / 3) + 8) * (MAX_CHAR_PER_LINE + 2)
168  / MAX_CHAR_PER_LINE; /* maximum size of a line supported */
169  line = GNUNET_malloc (linesize + 2); /* 2 bytes for off-by-one errors, just to be safe... */
170 
171 #define READLINE(l, limit) \
172  do { retl = fgets (l, (limit), fdes); \
173  if ((retl == NULL) || (smtp_shutdown == GNUNET_YES)) { \
174  goto END; \
175  } \
176  if (core_api->load_monitor != NULL) \
177  GNUNET_network_monitor_notify_transmission (core_api->load_monitor, \
178  GNUNET_ND_DOWNLOAD, \
179  strlen (retl)); \
180  } while (0)
181 
182 
183  while (smtp_shutdown == GNUNET_NO)
184  {
185  fd = OPEN (pipename, O_RDONLY | O_ASYNC);
186  if (fd == -1)
187  {
188  if (smtp_shutdown == GNUNET_NO)
189  GNUNET_thread_sleep (5 * GNUNET_CRON_SECONDS);
190  continue;
191  }
192  fdes = fdopen (fd, "r");
193  while (smtp_shutdown == GNUNET_NO)
194  {
195  /* skip until end of header */
196  do
197  {
198  READLINE (line, linesize);
199  }
200  while ((line[0] != '\r') && (line[0] != '\n')); /* expect newline */
201  READLINE (line, linesize); /* read base64 encoded message; decode, process */
202  pos = 0;
203  while (1)
204  {
205  pos = strlen (line) - 1; /* ignore new line */
206  READLINE (&line[pos], linesize - pos); /* read base64 encoded message; decode, process */
207  if ((line[pos] == '\r') || (line[pos] == '\n'))
208  break; /* empty line => end of message! */
209  }
210  size = GNUNET_STRINGS_base64_decode (line, pos, &out);
211  if (size < sizeof(SMTPMessage))
212  {
213  GNUNET_GE_BREAK (ectx, 0);
214  GNUNET_free (out);
215  goto END;
216  }
217 
218  mp = (SMTPMessage *) &out[size - sizeof(SMTPMessage)];
219  if (ntohs (mp->header.size) != size)
220  {
221  GNUNET_GE_LOG (ectx,
222  GNUNET_GE_WARNING | GNUNET_GE_BULK | GNUNET_GE_USER,
223  _ ("Received malformed message via %s. Ignored.\n"),
224  "SMTP");
225 #if DEBUG_SMTP
226  GNUNET_GE_LOG (ectx,
227  GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER,
228  "Size returned by base64=%d, in the msg=%d.\n", size,
229  ntohl (mp->size));
230 #endif
231  GNUNET_free (out);
232  goto END;
233  }
234  if (stats != NULL)
235  stats->change (stat_bytesReceived, size);
236  coreMP = GNUNET_new (GNUNET_TransportPacket);
237  coreMP->msg = out;
238  coreMP->size = size - sizeof(SMTPMessage);
239  coreMP->tsession = NULL;
240  coreMP->sender = mp->sender;
241 #if DEBUG_SMTP
242  GNUNET_GE_LOG (ectx, GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER,
243  "SMTP message passed to the core.\n");
244 #endif
245 
246  core_api->receive (coreMP);
247  }
248 END:
249 #if DEBUG_SMTP
250  GNUNET_GE_LOG (ectx, GNUNET_GE_DEBUG | GNUNET_GE_REQUEST | GNUNET_GE_USER,
251  "SMTP message processed.\n");
252 #endif
253  if (fdes != NULL)
254  fclose (fdes);
255  }
256  GNUNET_free (line);
257  return NULL;
258 }
static char * pipename
static GNUNET_Stats_ServiceAPI * stats
We&#39;re done processing.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_new(type)
Allocate a struct or union of the given type.
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static GNUNET_NETWORK_STRUCT_END GNUNET_CoreAPIForTransport * core_api
apis (our advertised API and the core api )
#define READLINE(l, limit)
static char * line
Desired phone line (string to be converted to a hash).
static struct GNUNET_GE_Context * ectx
size_t GNUNET_STRINGS_base64_decode(const char *data, size_t len, void **output)
Decode from Base64.
Definition: strings.c:1920
static unsigned int size
Size of the "table".
Definition: peer.c:67
static int smtp_shutdown
Flag to indicate that server has been shut down.
GNUNET_MessageHeader header
GNUNET_PeerIdentity sender
What is the identity of the sender (GNUNET_hash of public key)
Encapsulation of a GNUnet message in the SMTP mail body (before base64 encoding). ...
static int stat_bytesReceived
#define MAX_CHAR_PER_LINE
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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
hellothe 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.

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

Referenced by api_create_hello(), and inittransport_smtp().

274 {
275  const EmailAddress *maddr;
276 
277  maddr = (const EmailAddress *) &hello[1];
278  if ((ntohs (hello->header.size) !=
279  sizeof(GNUNET_MessageHello) + ntohs (hello->senderAddressSize)) ||
280  (maddr->senderAddress
281  [ntohs (hello->senderAddressSize) - 1 - FILTER_STRING_SIZE] != '\0'))
282  {
283  GNUNET_GE_BREAK (ectx, 0);
284  return GNUNET_SYSERR; /* obviously invalid */
285  }
286  if (NULL == strstr (maddr->filter, ": "))
287  return GNUNET_SYSERR;
288  return GNUNET_OK;
289 }
char filter[64]
Filter line that every sender must include in the E-mails such that the receiver can effectively filt...
char senderAddress[0]
Claimed E-mail address of the sender.
Host-Address in a SMTP network.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static struct GNUNET_GE_Context * ectx
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define FILTER_STRING_SIZE
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.

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

Referenced by inittransport_smtp().

301 {
302  GNUNET_MessageHello *msg;
303  char *filter;
304  EmailAddress *haddr;
305  int i;
306 
307  GNUNET_GC_get_configuration_value_string (core_api->cfg, "SMTP", "FILTER",
308  "X-mailer: GNUnet", &filter);
309  if (NULL == strstr (filter, ": "))
310  {
311  GNUNET_GE_LOG (ectx, GNUNET_GE_WARNING | GNUNET_GE_BULK | GNUNET_GE_USER,
312  _ ("SMTP filter string to invalid, lacks ': '\n"));
313  GNUNET_free (filter);
314  return NULL;
315  }
316 
317  if (strlen (filter) > FILTER_STRING_SIZE)
318  {
319  filter[FILTER_STRING_SIZE] = '\0';
320  GNUNET_GE_LOG (ectx, GNUNET_GE_WARNING | GNUNET_GE_BULK | GNUNET_GE_USER,
321  _ ("SMTP filter string to long, capped to `%s'\n"), filter);
322  }
323  i = (strlen (email) + 8) & (~7); /* make multiple of 8 */
324  msg =
325  GNUNET_malloc (sizeof(GNUNET_MessageHello) + sizeof(EmailAddress) + i);
326  memset (msg, 0, sizeof(GNUNET_MessageHello) + sizeof(EmailAddress) + i);
327  haddr = (EmailAddress *) &msg[1];
328  memset (&haddr->filter[0], 0, FILTER_STRING_SIZE);
329  strcpy (&haddr->filter[0], filter);
330  GNUNET_memcpy (&haddr->senderAddress[0], email, strlen (email) + 1);
331  msg->senderAddressSize = htons (strlen (email) + 1 + sizeof(EmailAddress));
332  msg->protocol = htons (GNUNET_TRANSPORT_PROTOCOL_NUMBER_SMTP);
333  msg->MTU = htonl (smtpAPI.mtu);
334  msg->header.size = htons (GNUNET_sizeof_hello (msg));
335  if (api_verify_hello (msg) == GNUNET_SYSERR)
336  GNUNET_GE_ASSERT (ectx, 0);
337  GNUNET_free (filter);
338  return msg;
339 }
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
char filter[64]
Filter line that every sender must include in the E-mails such that the receiver can effectively filt...
char senderAddress[0]
Claimed E-mail address of the sender.
Host-Address in a SMTP network.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static GNUNET_NETWORK_STRUCT_END GNUNET_CoreAPIForTransport * core_api
apis (our advertised API and the core api )
static GNUNET_TransportAPI smtpAPI
static char * email
static struct GNUNET_GE_Context * ectx
static struct GNUNET_CONTAINER_BloomFilter * filter
Bloomfilter to quickly tell if we don&#39;t have the content.
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
#define FILTER_STRING_SIZE
static int api_verify_hello(const GNUNET_MessageHello *hello)
Verify that a hello-Message is correct (a node is reachable at that address).
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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.

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

Referenced by api_send().

351 {
352  struct GetMessageClosure *gmc = cls;
353 
354  *buf = NULL;
355  if (len == NULL)
356  {
357  gmc->pos = 0;
358  return NULL;
359  }
360  if (gmc->pos == gmc->esize)
361  return NULL; /* done */
362  *len = gmc->esize;
363  gmc->pos = gmc->esize;
364  return gmc->ebody;
365 }
static char buf[2048]
uint16_t len
length of data (which is always a uint32_t, but presumably this can be used to specify that fewer byt...
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
tsessionthe GNUNET_MessageHello identifying the remote node
msgwhat to send
sizethe size of the message
importantis 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.

References _, core_api, GetMessageClosure::ebody, EBUF_LEN, ectx, email, GetMessageClosure::esize, EmailAddress::filter, 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, GetMessageClosure::pos, rate_limit, SMTPMessage::sender, EmailAddress::senderAddress, GNUNET_MessageHeader::size, smtp_server_name, smtp_shutdown, smtpAPI, stat_bytesSent, stats, and GNUNET_MessageHeader::type.

Referenced by inittransport_smtp().

380 {
381  const GNUNET_MessageHello *hello;
382  const EmailAddress *haddr;
383  char *m;
384  char *filter;
385  char *fvalue;
386  SMTPMessage *mp;
387  struct GetMessageClosure gm_cls;
388  smtp_session_t session;
389  smtp_message_t message;
390  smtp_recipient_t recipient;
391 
392 #define EBUF_LEN 128
393  char ebuf[EBUF_LEN];
394  GNUNET_CronTime now;
395 
396  if (smtp_shutdown == GNUNET_YES)
397  return GNUNET_SYSERR;
398  if ((size == 0) || (size > smtpAPI.mtu))
399  {
400  GNUNET_GE_BREAK (ectx, 0);
401  return GNUNET_SYSERR;
402  }
403  now = GNUNET_get_time ();
404  if ((important != GNUNET_YES) &&
405  ( ((now - last_transmission) * rate_limit) < GNUNET_CRON_HOURS) )
406  return GNUNET_NO; /* rate too high */
407  last_transmission = now;
408 
409  hello = (const GNUNET_MessageHello *) tsession->internal;
410  if (hello == NULL)
411  return GNUNET_SYSERR;
412  GNUNET_mutex_lock (lock);
413  session = smtp_create_session ();
414  if (session == NULL)
415  {
416  GNUNET_GE_LOG (ectx,
417  GNUNET_GE_ERROR | GNUNET_GE_ADMIN | GNUNET_GE_USER
418  | GNUNET_GE_IMMEDIATE, _ ("SMTP: `%s' failed: %s.\n"),
419  "smtp_create_session", smtp_strerror (smtp_errno (), ebuf,
420  EBUF_LEN));
421  GNUNET_mutex_unlock (lock);
422  return GNUNET_SYSERR;
423  }
424  if (0 == smtp_set_server (session, smtp_server_name))
425  {
426  GNUNET_GE_LOG (ectx,
427  GNUNET_GE_ERROR | GNUNET_GE_ADMIN | GNUNET_GE_USER
428  | GNUNET_GE_IMMEDIATE, _ ("SMTP: `%s' failed: %s.\n"),
429  "smtp_set_server", smtp_strerror (smtp_errno (), ebuf,
430  EBUF_LEN));
431  smtp_destroy_session (session);
432  GNUNET_mutex_unlock (lock);
433  return GNUNET_SYSERR;
434  }
435  haddr = (const EmailAddress *) &hello[1];
436  message = smtp_add_message (session);
437  if (message == NULL)
438  {
439  GNUNET_GE_LOG (ectx,
440  GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER
441  | GNUNET_GE_BULK, _ ("SMTP: `%s' failed: %s.\n"),
442  "smtp_add_message", smtp_strerror (smtp_errno (), ebuf,
443  EBUF_LEN));
444  smtp_destroy_session (session);
445  GNUNET_mutex_unlock (lock);
446  return GNUNET_SYSERR;
447  }
448  smtp_set_header (message, "To", NULL, haddr->senderAddress);
449  smtp_set_header (message, "From", NULL, email);
450 
451  filter = GNUNET_strdup (haddr->filter);
452  fvalue = strstr (filter, ": ");
453  GNUNET_GE_ASSERT (NULL, NULL != fvalue);
454  fvalue[0] = '\0';
455  fvalue += 2;
456  if (0 == smtp_set_header (message, filter, fvalue))
457  {
458  GNUNET_GE_LOG (ectx,
459  GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER
460  | GNUNET_GE_BULK, _ ("SMTP: `%s' failed: %s.\n"),
461  "smtp_set_header", smtp_strerror (smtp_errno (), ebuf,
462  EBUF_LEN));
463  smtp_destroy_session (session);
464  GNUNET_mutex_unlock (lock);
465  GNUNET_free (filter);
466  return GNUNET_SYSERR;
467  }
468  GNUNET_free (filter);
469  m = GNUNET_malloc (size + sizeof(SMTPMessage));
470  GNUNET_memcpy (m, msg, size);
471  mp = (SMTPMessage *) &m[size];
472  mp->header.size = htons (size + sizeof(SMTPMessage));
473  mp->header.type = htons (0);
474  mp->sender = *core_api->my_identity;
475  gm_cls.ebody = NULL;
476  gm_cls.pos = 0;
477  gm_cls.esize = GNUNET_STRINGS_base64_encode (m, size + sizeof(SMTPMessage),
478  &gm_cls.ebody);
479  GNUNET_free (m);
480  if (0 == smtp_size_set_estimate (message, gm_cls.esize))
481  {
482  GNUNET_GE_LOG (ectx,
483  GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER
484  | GNUNET_GE_BULK, _ ("SMTP: `%s' failed: %s.\n"),
485  "smtp_size_set_estimate", smtp_strerror (smtp_errno (), ebuf,
486  EBUF_LEN));
487  }
488  if (0 == smtp_set_messagecb (message, &get_message, &gm_cls))
489  {
490  GNUNET_GE_LOG (ectx,
491  GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER
492  | GNUNET_GE_BULK, _ ("SMTP: `%s' failed: %s.\n"),
493  "smtp_set_messagecb", smtp_strerror (smtp_errno (), ebuf,
494  EBUF_LEN));
495  smtp_destroy_session (session);
496  GNUNET_mutex_unlock (lock);
497  GNUNET_free (gm_cls.ebody);
498  return GNUNET_SYSERR;
499  }
500  recipient = smtp_add_recipient (message, haddr->senderAddress);
501  if (recipient == NULL)
502  {
503  GNUNET_GE_LOG (ectx,
504  GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER
505  | GNUNET_GE_BULK, _ ("SMTP: `%s' failed: %s.\n"),
506  "smtp_add_recipient", smtp_strerror (smtp_errno (), ebuf,
507  EBUF_LEN));
508  smtp_destroy_session (session);
509  GNUNET_mutex_unlock (lock);
510  return GNUNET_SYSERR;
511  }
512  if (0 == smtp_start_session (session))
513  {
514  GNUNET_GE_LOG (ectx,
515  GNUNET_GE_WARNING | GNUNET_GE_ADMIN | GNUNET_GE_USER
516  | GNUNET_GE_BULK, _ ("SMTP: `%s' failed: %s.\n"),
517  "smtp_start_session", smtp_strerror (smtp_errno (), ebuf,
518  EBUF_LEN));
519  smtp_destroy_session (session);
520  GNUNET_mutex_unlock (lock);
521  GNUNET_free (gm_cls.ebody);
522  return GNUNET_SYSERR;
523  }
524  if (stats != NULL)
525  stats->change (stat_bytesSent, size);
526  if (core_api->load_monitor != NULL)
527  GNUNET_network_monitor_notify_transmission (core_api->load_monitor,
528  GNUNET_ND_UPLOAD, gm_cls.esize);
529  smtp_message_reset_status (message); /* this is needed to plug a 28-byte/message memory leak in libesmtp */
530  smtp_destroy_session (session);
531  GNUNET_mutex_unlock (lock);
532  GNUNET_free (gm_cls.ebody);
533  return GNUNET_OK;
534 }
static unsigned long long rate_limit
How many e-mails are we allowed to send per hour?
struct GNUNET_MessageHeader * msg
Definition: 005.c:2
char filter[64]
Filter line that every sender must include in the E-mails such that the receiver can effectively filt...
char senderAddress[0]
Claimed E-mail address of the sender.
static GNUNET_Stats_ServiceAPI * stats
static GNUNET_CronTime last_transmission
static char * smtp_server_name
Set to the SMTP server hostname (and port) for outgoing messages.
Host-Address in a SMTP network.
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
uint16_t size
The length of the struct (in bytes, including the length field itself), in big-endian format...
#define GNUNET_strdup(a)
Wrapper around GNUNET_xstrdup_.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static GNUNET_NETWORK_STRUCT_END GNUNET_CoreAPIForTransport * core_api
apis (our advertised API and the core api )
static GNUNET_TransportAPI smtpAPI
static struct GNUNET_ARM_MonitorHandle * m
Monitor connection with ARM.
Definition: gnunet-arm.c:104
static char * email
uint16_t type
The type of the message (GNUNET_MESSAGE_TYPE_XXXX), in big-endian format.
static struct GNUNET_GE_Context * ectx
static struct GNUNET_CONTAINER_BloomFilter * filter
Bloomfilter to quickly tell if we don&#39;t have the content.
size_t GNUNET_STRINGS_base64_encode(const void *in, size_t len, char **output)
Encode into Base64.
Definition: strings.c:1855
#define EBUF_LEN
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static const char * get_message(void **buf, int *len, void *cls)
static unsigned int size
Size of the "table".
Definition: peer.c:67
static struct GNUNET_Mutex * lock
Lock for uses of libesmtp (not thread-safe).
static int smtp_shutdown
Flag to indicate that server has been shut down.
GNUNET_MessageHeader header
#define GNUNET_YES
Definition: gnunet_common.h:77
GNUNET_PeerIdentity sender
What is the identity of the sender (GNUNET_hash of public key)
Encapsulation of a GNUnet message in the SMTP mail body (before base64 encoding). ...
static int stat_bytesSent
#define GNUNET_malloc(size)
Wrapper around malloc.
#define GNUNET_free(ptr)
Wrapper around free.
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
hellothe hello-Message for the target node
tsessionPtrthe session handle that is to be set
may_reusecan 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.

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

Referenced by inittransport_smtp().

547 {
548  GNUNET_TSession *tsession;
549 
550  tsession = GNUNET_new (GNUNET_TSession);
551  tsession->internal = GNUNET_malloc (GNUNET_sizeof_hello (hello));
552  tsession->peer = hello->senderIdentity;
553  GNUNET_memcpy (tsession->internal, hello, GNUNET_sizeof_hello (hello));
554  tsession->ttype = smtpAPI.protocol_number;
555  (*tsessionPtr) = tsession;
556  return GNUNET_OK;
557 }
#define GNUNET_memcpy(dst, src, n)
Call memcpy() but check for n being 0 first.
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_new(type)
Allocate a struct or union of the given type.
static GNUNET_TransportAPI smtpAPI
#define GNUNET_malloc(size)
Wrapper around malloc.
Here is the caller graph for this function:

◆ api_disconnect()

static int api_disconnect ( GNUNET_TSession *  tsession)
static

Disconnect from a remote node.

Parameters
tsessionthe 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.

References GNUNET_free, and GNUNET_OK.

Referenced by inittransport_smtp().

568 {
569  if (tsession != NULL)
570  {
571  if (tsession->internal != NULL)
572  GNUNET_free (tsession->internal);
573  GNUNET_free (tsession);
574  }
575  return GNUNET_OK;
576 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
#define GNUNET_free(ptr)
Wrapper around free.
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.

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

Referenced by inittransport_smtp().

585 {
587  /* initialize SMTP network */
588  dispatchThread = GNUNET_thread_create (&listenAndDistribute, NULL, 1024 * 4);
589  if (dispatchThread == NULL)
590  {
591  GNUNET_GE_DIE_STRERROR (ectx,
592  GNUNET_GE_ADMIN | GNUNET_GE_BULK | GNUNET_GE_FATAL,
593  "pthread_create");
594  return GNUNET_SYSERR;
595  }
596  return GNUNET_OK;
597 }
static void * listenAndDistribute(void *unused)
Listen to the pipe, decode messages and send to core.
#define GNUNET_NO
Definition: gnunet_common.h:78
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static struct GNUNET_GE_Context * ectx
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
static int smtp_shutdown
Flag to indicate that server has been shut down.
static struct GNUNET_ThreadHandle * dispatchThread
Thread that listens for inbound messages.
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.

References dispatchThread, GNUNET_OK, GNUNET_YES, and smtp_shutdown.

Referenced by inittransport_smtp().

606 {
607  void *unused;
608 
610  GNUNET_thread_stop_sleep (dispatchThread);
611  GNUNET_thread_join (dispatchThread, &unused);
612  return GNUNET_OK;
613 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
static int smtp_shutdown
Flag to indicate that server has been shut down.
static struct GNUNET_ThreadHandle * dispatchThread
Thread that listens for inbound messages.
#define GNUNET_YES
Definition: gnunet_common.h:77
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.

References GNUNET_SYSERR.

Referenced by inittransport_smtp().

622 {
623  return GNUNET_SYSERR;
624 }
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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.

References GNUNET_SYSERR.

Referenced by inittransport_smtp().

632 {
633  return GNUNET_SYSERR; /* SMTP connections can never be associated */
634 }
#define GNUNET_SYSERR
Definition: gnunet_common.h:76
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.

References GNUNET_OK.

Referenced by inittransport_smtp().

644 {
645  return GNUNET_OK; /* we always try... */
646 }
#define GNUNET_OK
Named constants for return values.
Definition: gnunet_common.h:75
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.

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.

655 {
656  unsigned long long mtu;
657  struct sigaction sa;
658 
659  core_api = core;
660  ectx = core->ectx;
661  if (! GNUNET_GC_have_configuration_value (core_api->cfg, "SMTP", "EMAIL"))
662  {
663  GNUNET_GE_LOG (ectx, GNUNET_GE_ERROR | GNUNET_GE_BULK | GNUNET_GE_USER,
664  _
665  (
666  "No email-address specified, can not start SMTP transport.\n"));
667  return NULL;
668  }
669  GNUNET_GC_get_configuration_value_number (core_api->cfg, "SMTP", "MTU", 1200,
671  SMTP_MESSAGE_SIZE, &mtu);
672  GNUNET_GC_get_configuration_value_number (core_api->cfg, "SMTP", "RATELIMIT",
673  0, 0, 1024 * 1024, &rate_limit);
674  stats = core_api->service_request ("stats");
675  if (stats != NULL)
676  {
678  stats->create (gettext_noop ("# bytes received via SMTP"));
679  stat_bytesSent = stats->create (gettext_noop ("# bytes sent via SMTP"));
681  stats->create (gettext_noop ("# bytes dropped by SMTP (outgoing)"));
682  }
683  GNUNET_GC_get_configuration_value_filename (core_api->cfg, "SMTP", "PIPE",
684  &pipename);
685  unlink (pipename);
686  if (0 != mkfifo (pipename, S_IWUSR | S_IRUSR | S_IWGRP | S_IWOTH))
687  {
688  GNUNET_GE_LOG_STRERROR (ectx,
689  GNUNET_GE_ADMIN | GNUNET_GE_BULK | GNUNET_GE_FATAL,
690  "mkfifo");
692  core_api->service_release (stats);
693  stats = NULL;
694  return NULL;
695  }
696  /* we need to allow the mailer program to send us messages;
697  * easiest done by giving it write permissions (see Mantis #1142) */
698  if (0 != chmod (pipename, S_IWUSR | S_IRUSR | S_IWGRP | S_IWOTH))
699  GNUNET_GE_LOG_STRERROR (ectx,
700  GNUNET_GE_ADMIN | GNUNET_GE_BULK
701  | GNUNET_GE_WARNING, "chmod");
702  GNUNET_GC_get_configuration_value_string (core_api->cfg, "SMTP", "EMAIL",
703  NULL,
704  &email);
705  lock = GNUNET_mutex_create (GNUNET_NO);
706  GNUNET_GC_get_configuration_value_string (core_api->cfg, "SMTP", "SERVER",
707  "localhost:25", &smtp_server_name);
708  sa.sa_handler = SIG_IGN;
709  sigemptyset (&sa.sa_mask);
710  sa.sa_flags = 0;
711  sigaction (SIGPIPE, &sa, &old_handler);
712 
713  smtpAPI.protocol_number = GNUNET_TRANSPORT_PROTOCOL_NUMBER_SMTP;
714  smtpAPI.mtu = mtu - sizeof(SMTPMessage);
715  smtpAPI.cost = 50;
716  smtpAPI.hello_verify = &api_verify_hello;
717  smtpAPI.hello_create = &api_create_hello;
718  smtpAPI.connect = &api_connect;
719  smtpAPI.send = &api_send;
720  smtpAPI.associate = &api_associate;
721  smtpAPI.disconnect = &api_disconnect;
722  smtpAPI.server_start = &api_start_transport_server;
723  smtpAPI.server_stop = &api_stop_transport_server;
724  smtpAPI.hello_to_address = &api_hello_to_address;
725  smtpAPI.send_now_test = &api_test_would_try;
726  return &smtpAPI;
727 }
static unsigned long long rate_limit
How many e-mails are we allowed to send per hour?
static char * pipename
static GNUNET_Stats_ServiceAPI * stats
static char * smtp_server_name
Set to the SMTP server hostname (and port) for outgoing messages.
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!)...
static int api_stop_transport_server()
Shutdown the server process (stop receiving inbound traffic).
static int stat_bytesDropped
#define GNUNET_NO
Definition: gnunet_common.h:78
static int api_disconnect(GNUNET_TSession *tsession)
Disconnect from a remote node.
#define _(String)
GNU gettext support macro.
Definition: platform.h:181
static GNUNET_NETWORK_STRUCT_END GNUNET_CoreAPIForTransport * core_api
apis (our advertised API and the core api )
static int api_associate(GNUNET_TSession *tsession)
Always fails.
static GNUNET_TransportAPI smtpAPI
static char * email
static struct sigaction old_handler
Old handler for SIGPIPE (kept to be able to restore).
static struct GNUNET_GE_Context * ectx
static int api_start_transport_server()
Start the server process to receive inbound traffic.
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).
static int api_send(GNUNET_TSession *tsession, const void *msg, const unsigned int size, int important)
Send a message to the specified remote node.
#define SMTP_MESSAGE_SIZE
The default maximum size of each outbound SMTP message.
static int api_connect(const GNUNET_MessageHello *hello, GNUNET_TSession **tsessionPtr, int may_reuse)
Establish a connection to a remote node.
static struct GNUNET_Mutex * lock
Lock for uses of libesmtp (not thread-safe).
static int api_verify_hello(const GNUNET_MessageHello *hello)
Verify that a hello-Message is correct (a node is reachable at that address).
Encapsulation of a GNUnet message in the SMTP mail body (before base64 encoding). ...
static int stat_bytesReceived
static GNUNET_MessageHello * api_create_hello()
Create a hello-Message for the current node.
static int stat_bytesSent
static struct GNUNET_CORE_Handle * core
Handle to the CORE service.
#define GNUNET_free(ptr)
Wrapper around free.
#define gettext_noop(String)
Definition: gettext.h:69
Here is the call graph for this function:

◆ donetransport_smtp()

void donetransport_smtp ( )

Definition at line 731 of file plugin_transport_smtp.c.

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

732 {
733  sigaction (SIGPIPE, &old_handler, NULL);
735  if (stats != NULL)
736  {
737  core_api->service_release (stats);
738  stats = NULL;
739  }
740  GNUNET_mutex_destroy (lock);
741  lock = NULL;
742  unlink (pipename);
744  pipename = NULL;
745  GNUNET_free (email);
746  email = NULL;
747 }
static char * pipename
static GNUNET_Stats_ServiceAPI * stats
static char * smtp_server_name
Set to the SMTP server hostname (and port) for outgoing messages.
static GNUNET_NETWORK_STRUCT_END GNUNET_CoreAPIForTransport * core_api
apis (our advertised API and the core api )
static char * email
static struct sigaction old_handler
Old handler for SIGPIPE (kept to be able to restore).
static struct GNUNET_Mutex * lock
Lock for uses of libesmtp (not thread-safe).
#define GNUNET_free(ptr)
Wrapper around free.

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

◆ 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

◆ 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 124 of file plugin_transport_smtp.c.

Referenced by donetransport_smtp(), and inittransport_smtp().

◆ email

char* email
static

◆ smtpAPI

GNUNET_TransportAPI smtpAPI
static

◆ stats

GNUNET_Stats_ServiceAPI* stats
static

◆ 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().