gnunet-communicator-tcp.c File Reference

Transport plugin using TCP. More...

#include "platform.h"
#include "gnunet_util_lib.h"
#include "gnunet_protocols.h"
#include "gnunet_signatures.h"
#include "gnunet_constants.h"
#include "gnunet_nt_lib.h"
#include "gnunet_nat_service.h"
#include "gnunet_statistics_service.h"
#include "gnunet_transport_communication_service.h"

Include dependency graph for gnunet-communicator-tcp.c:

Go to the source code of this file.

Data Structures
struct	TcpHandshakeSignature
	Signature we use to verify that the ephemeral key was really chosen by the specified sender. More...
struct	TCPConfirmation
	Encrypted continuation of TCP initial handshake. More...
struct	TCPBox
	TCP message box. More...
struct	TCPRekey
	TCP rekey message box. More...
struct	TCPFinish
	TCP finish. More...
struct	Queue
	Handle for a queue. More...
struct	ProtoQueue
	Handle for an incoming connection where we do not yet have enough information to setup a full queue. More...

Macros
#define	ADDRESS_VALIDITY_PERIOD   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_HOURS, 4)
	How long do we believe our addresses to remain up (before the other peer should revalidate). More...
#define	DEFAULT_MAX_QUEUE_LENGTH   8
	How many messages do we keep at most in the queue to the transport service before we start to drop (default, can be changed via the configuration file). More...
#define	BUF_SIZE   (2 * 64 * 1024 + sizeof(struct TCPBox))
	Size of our IO buffers for ciphertext data. More...
#define	REKEY_TIME_INTERVAL   GNUNET_TIME_UNIT_DAYS
	How often do we rekey based on time (at least) More...
#define	PROTO_QUEUE_TIMEOUT   GNUNET_TIME_UNIT_MINUTES
	How long do we wait until we must have received the initial KX? More...
#define	REKEY_MAX_BYTES   (1024LLU * 1024 * 1024 * 4LLU)
	How often do we rekey based on number of bytes transmitted? (additionally randomized). More...
#define	INITIAL_KX_SIZE
	Size of the initial key exchange message sent first in both directions. More...
#define	COMMUNICATOR_ADDRESS_PREFIX   "tcp"
	Address prefix used by the communicator. More...
#define	COMMUNICATOR_CONFIG_SECTION   "communicator-tcp"
	Configuration section used by the communicator. More...

Functions
static void	listen_cb (void *cls)
	We have been notified that our listen socket has something to read. More...
static void	queue_destroy (struct Queue *queue)
	Functions with this signature are called whenever we need to close a queue due to a disconnect or failure to establish a connection. More...
static void	calculate_hmac (struct GNUNET_HashCode *hmac_secret, const void *buf, size_t buf_size, struct GNUNET_ShortHashCode *smac)
	Compute mac over buf, and ratched the hmac_secret. More...
static void	queue_finish (struct Queue *queue)
	Append a 'finish' message to the outgoing transmission. More...
static void	reschedule_queue_timeout (struct Queue *queue)
	Increment queue timeout due to activity. More...
static void	queue_read (void *cls)
	Queue read task. More...
static void	core_read_finished_cb (void *cls, int success)
	Core tells us it is done processing a message that transport received on a queue with status success. More...
static void	pass_plaintext_to_core (struct Queue *queue, const void *plaintext, size_t plaintext_len)
	We received plaintext_len bytes of plaintext on queue. More...
static void	setup_cipher (const struct GNUNET_HashCode *dh, const struct GNUNET_PeerIdentity *pid, gcry_cipher_hd_t *cipher, struct GNUNET_HashCode *hmac_key)
	Setup cipher based on shared secret dh and decrypting peer pid. More...
static void	setup_in_cipher (const struct GNUNET_CRYPTO_EcdhePublicKey *ephemeral, struct Queue *queue)
	Setup cipher of queue for decryption. More...
static void	do_rekey (struct Queue *queue, const struct TCPRekey *rekey)
	Handle rekey message on queue. More...
static size_t	try_handle_plaintext (struct Queue *queue)
	Test if we have received a full message in plaintext. More...
static struct sockaddr *	tcp_address_to_sockaddr (const char *bindto, socklen_t *sock_len)
	Convert TCP bind specification to a struct sockaddr * More...
static void	setup_out_cipher (struct Queue *queue)
	Setup cipher for outgoing data stream based on target and our ephemeral private key. More...
static void	inject_rekey (struct Queue *queue)
	Inject a struct TCPRekey message into the queue's plaintext buffer. More...
static void	queue_write (void *cls)
	We have been notified that our socket is ready to write. More...
static void	mq_send (struct GNUNET_MQ_Handle *mq, const struct GNUNET_MessageHeader *msg, void *impl_state)
	Signature of functions implementing the sending functionality of a message queue. More...
static void	mq_destroy (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Signature of functions implementing the destruction of a message queue. More...
static void	mq_cancel (struct GNUNET_MQ_Handle *mq, void *impl_state)
	Implementation function that cancels the currently sent message. More...
static void	mq_error (void *cls, enum GNUNET_MQ_Error error)
	Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue. More...
static void	boot_queue (struct Queue *queue, enum GNUNET_TRANSPORT_ConnectionStatus cs)
	Add the given queue to our internal data structure. More...
static void	transmit_kx (struct Queue *queue, const struct GNUNET_CRYPTO_EcdhePublicKey *epub)
	Generate and transmit our ephemeral key and the signature for the initial KX with the other peer. More...
static void	start_initial_kx_out (struct Queue *queue)
	Initialize our key material for outgoing transmissions and inform the other peer about it. More...
static int	decrypt_and_check_tc (struct Queue *queue, struct TCPConfirmation *tc, char *ibuf)
	We have received the first bytes from the other side on a queue. More...
static void	free_proto_queue (struct ProtoQueue *pq)
	Closes socket and frees memory associated with pq. More...
static void	proto_read_kx (void *cls)
	Read from the socket of the proto queue until we have enough data to upgrade to full queue. More...
static void	queue_read_kx (void *cls)
	Read from the socket of the queue until we have enough data to initialize the decryption logic and can switch to regular reading. More...
static int	mq_init (void *cls, const struct GNUNET_PeerIdentity *peer, const char *address)
	Function called by the transport service to initialize a message queue given address information about another peer. More...
static int	get_queue_delete_it (void *cls, const struct GNUNET_PeerIdentity *target, void *value)
	Iterator over all message queues to clean up. More...
static void	do_shutdown (void *cls)
	Shutdown the UNIX communicator. More...
static void	enc_notify_cb (void *cls, const struct GNUNET_PeerIdentity *sender, const struct GNUNET_MessageHeader *msg)
	Function called when the transport service has received an acknowledgement for this communicator (!) via a different return path. More...
static void	nat_address_cb (void *cls, void **app_ctx, int add_remove, enum GNUNET_NAT_AddressClass ac, const struct sockaddr *addr, socklen_t addrlen)
	Signature of the callback passed to GNUNET_NAT_register() for a function to call whenever our set of 'valid' addresses changes. More...
static void	run (void *cls, char *const *args, const char *cfgfile, const struct GNUNET_CONFIGURATION_Handle *c)
	Setup communicator and launch network interactions. More...
int	main (int argc, char *const *argv)
	The main function for the UNIX communicator. More...

Variables
static struct GNUNET_SCHEDULER_Task *	listen_task
	ID of listen task. More...
static unsigned long long	max_queue_length
	Maximum queue length before we stop reading towards the transport service. More...
static struct GNUNET_STATISTICS_Handle *	stats
	For logging statistics. More...
static struct GNUNET_TRANSPORT_CommunicatorHandle *	ch
	Our environment. More...
static struct GNUNET_CONTAINER_MultiPeerMap *	queue_map
	Queues (map from peer identity to struct Queue) More...
static struct GNUNET_NETWORK_Handle *	listen_sock
	Listen socket. More...
static struct GNUNET_PeerIdentity	my_identity
	Our public key. More...
static struct GNUNET_CRYPTO_EddsaPrivateKey *	my_private_key
	Our private key. More...
static const struct GNUNET_CONFIGURATION_Handle *	cfg
	Our configuration. More...
static struct GNUNET_NT_InterfaceScanner *	is
	Network scanner to determine network types. More...
static struct GNUNET_NAT_Handle *	nat
	Connection to NAT service. More...
static struct ProtoQueue *	proto_head
	Protoqueues DLL head. More...
static struct ProtoQueue *	proto_tail
	Protoqueues DLL tail. More...

Detailed Description

Transport plugin using TCP.

Author

Christian Grothoff

TODO:

• support DNS names in BINDTO option (#5528)
• support NAT connection reversal method (#5529)
• support other TCP-specific NAT traversal methods (#5531)
• add replay protection support to the protocol by adding a nonce in the KX and requiring (!) a nounce ACK to be send within the first X bytes of data (#5530)

Definition in file gnunet-communicator-tcp.c.

Macro Definition Documentation

ADDRESS_VALIDITY_PERIOD

#define ADDRESS_VALIDITY_PERIOD   GNUNET_TIME_relative_multiply(GNUNET_TIME_UNIT_HOURS, 4)

How long do we believe our addresses to remain up (before the other peer should revalidate).

Definition at line 49 of file gnunet-communicator-tcp.c.

Referenced by pass_plaintext_to_core().

DEFAULT_MAX_QUEUE_LENGTH

#define DEFAULT_MAX_QUEUE_LENGTH   8

How many messages do we keep at most in the queue to the transport service before we start to drop (default, can be changed via the configuration file).

Should be below the level of the communicator API, as otherwise we may read messages just to have them dropped by the communicator API.

Definition at line 60 of file gnunet-communicator-tcp.c.

Referenced by run().

BUF_SIZE

#define BUF_SIZE   (2 * 64 * 1024 + sizeof(struct TCPBox))

Size of our IO buffers for ciphertext data.

Must be at least UINT_MAX + sizeof (struct TCPBox).

Definition at line 66 of file gnunet-communicator-tcp.c.

Referenced by queue_read(), queue_read_kx(), and queue_write().

REKEY_TIME_INTERVAL

#define REKEY_TIME_INTERVAL   GNUNET_TIME_UNIT_DAYS

How often do we rekey based on time (at least)

Definition at line 71 of file gnunet-communicator-tcp.c.

Referenced by setup_out_cipher().

PROTO_QUEUE_TIMEOUT

#define PROTO_QUEUE_TIMEOUT   GNUNET_TIME_UNIT_MINUTES

How long do we wait until we must have received the initial KX?

Definition at line 76 of file gnunet-communicator-tcp.c.

Referenced by listen_cb().

REKEY_MAX_BYTES

#define REKEY_MAX_BYTES   (1024LLU * 1024 * 1024 * 4LLU)

How often do we rekey based on number of bytes transmitted? (additionally randomized).

Definition at line 82 of file gnunet-communicator-tcp.c.

Referenced by setup_out_cipher().

INITIAL_KX_SIZE

#define INITIAL_KX_SIZE

Value:

(sizeof(struct GNUNET_CRYPTO_EcdhePublicKey) + \
   sizeof(struct TCPConfirmation))

Size of the initial key exchange message sent first in both directions.

Definition at line 88 of file gnunet-communicator-tcp.c.

Referenced by queue_read_kx().

COMMUNICATOR_ADDRESS_PREFIX

#define COMMUNICATOR_ADDRESS_PREFIX   "tcp"

Address prefix used by the communicator.

Definition at line 96 of file gnunet-communicator-tcp.c.

Referenced by boot_queue(), mq_init(), nat_address_cb(), and run().

COMMUNICATOR_CONFIG_SECTION

#define COMMUNICATOR_CONFIG_SECTION   "communicator-tcp"

Configuration section used by the communicator.

Definition at line 101 of file gnunet-communicator-tcp.c.

Referenced by run(), and tcp_address_to_sockaddr().

Function Documentation

listen_cb()

static void listen_cb ( void *  cls )

static

We have been notified that our listen socket has something to read.

Do the read and reschedule this function to be called again once more is available.

Parameters

cls

NULL

Definition at line 1712 of file gnunet-communicator-tcp.c.

References ProtoQueue::address, ProtoQueue::address_len, GNUNET_assert, GNUNET_CONTAINER_DLL_insert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log_strerror, GNUNET_memdup, GNUNET_NETWORK_socket_accept(), GNUNET_new, GNUNET_SCHEDULER_add_read_net(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_REL, PROTO_QUEUE_TIMEOUT, proto_read_kx(), ProtoQueue::read_task, ProtoQueue::sock, and ProtoQueue::timeout.

Referenced by GNUNET_SET_listen(), queue_destroy(), and run().

{
  struct sockaddr_storage in;
  socklen_t addrlen;
  struct GNUNET_NETWORK_Handle *sock;
  struct ProtoQueue *pq;

  listen_task = NULL;
  GNUNET_assert(NULL != listen_sock);
  addrlen = sizeof(in);
  memset(&in, 0, sizeof(in));
  sock = GNUNET_NETWORK_socket_accept(listen_sock,
                                      (struct sockaddr *)&in,
                                      &addrlen);
  if ((NULL == sock) && ((EMFILE == errno) || (ENFILE == errno)))
    return; /* system limit reached, wait until connection goes down */
  listen_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
                                              listen_sock,
                                              &listen_cb,
                                              NULL);
  if ((NULL == sock) && ((EAGAIN == errno) || (ENOBUFS == errno)))
    return;
  if (NULL == sock)
    {
      GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "accept");
      return;
    }
  pq = GNUNET_new(struct ProtoQueue);
  pq->address_len = addrlen;
  pq->address = GNUNET_memdup(&in, addrlen);
  pq->timeout = GNUNET_TIME_relative_to_absolute(PROTO_QUEUE_TIMEOUT);
  pq->sock = sock;
  pq->read_task = GNUNET_SCHEDULER_add_read_net(PROTO_QUEUE_TIMEOUT,
                                                pq->sock,
                                                &proto_read_kx,
                                                pq);
  GNUNET_CONTAINER_DLL_insert(proto_head, proto_tail, pq);
}

Here is the call graph for this function:

Here is the caller graph for this function:

queue_destroy()

static void queue_destroy ( struct Queue *  queue )

static

Functions with this signature are called whenever we need to close a queue due to a disconnect or failure to establish a connection.

Parameters

queue

queue to close down

Definition at line 567 of file gnunet-communicator-tcp.c.

References Queue::address, Queue::backpressure, Queue::destroyed, GNUNET_assert, GNUNET_CONTAINER_multipeermap_remove(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_free, GNUNET_i2s(), GNUNET_log, GNUNET_MQ_destroy(), GNUNET_NETWORK_socket_close(), GNUNET_NO, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_set(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_communicator_mq_del(), GNUNET_YES, Queue::in_cipher, listen_cb(), mq, Queue::mq, Queue::out_cipher, Queue::qh, Queue::read_task, Queue::sock, Queue::target, and Queue::write_task.

Referenced by get_queue_delete_it(), queue_read_kx(), queue_write(), and try_handle_plaintext().

{
  struct GNUNET_MQ_Handle *mq;

  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Disconnecting queue for peer `%s'\n",
             GNUNET_i2s(&queue->target));
  if (NULL != (mq = queue->mq))
    {
      queue->mq = NULL;
      GNUNET_MQ_destroy(mq);
    }
  if (NULL != queue->qh)
    {
      GNUNET_TRANSPORT_communicator_mq_del(queue->qh);
      queue->qh = NULL;
    }
  GNUNET_assert(
    GNUNET_YES ==
    GNUNET_CONTAINER_multipeermap_remove(queue_map, &queue->target, queue));
  GNUNET_STATISTICS_set(stats,
                        "# queues active",
                        GNUNET_CONTAINER_multipeermap_size(queue_map),
                        GNUNET_NO);
  if (NULL != queue->read_task)
    {
      GNUNET_SCHEDULER_cancel(queue->read_task);
      queue->read_task = NULL;
    }
  if (NULL != queue->write_task)
    {
      GNUNET_SCHEDULER_cancel(queue->write_task);
      queue->write_task = NULL;
    }
  GNUNET_NETWORK_socket_close(queue->sock);
  gcry_cipher_close(queue->in_cipher);
  gcry_cipher_close(queue->out_cipher);
  GNUNET_free(queue->address);
  if (0 != queue->backpressure)
    queue->destroyed = GNUNET_YES;
  else
    GNUNET_free(queue);
  if (NULL == listen_task)
    listen_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
                                                listen_sock,
                                                &listen_cb,
                                                NULL);
}

Here is the call graph for this function:

Here is the caller graph for this function:

calculate_hmac()

static void calculate_hmac ( struct GNUNET_HashCode *  hmac_secret, const void *  buf, size_t  buf_size, struct GNUNET_ShortHashCode *  smac  )

static

Compute mac over buf, and ratched the hmac_secret.

Parameters

[in,out]	hmac_secret	secret for HMAC calculation
	buf	buffer to MAC
	buf_size	number of bytes in buf
	smac[out]	where to write the HMAC

Definition at line 626 of file gnunet-communicator-tcp.c.

References GNUNET_CRYPTO_hash(), and GNUNET_CRYPTO_hmac_raw().

Referenced by inject_rekey(), mq_send(), queue_finish(), and try_handle_plaintext().

{
  struct GNUNET_HashCode mac;

  GNUNET_CRYPTO_hmac_raw(hmac_secret,
                         sizeof(struct GNUNET_HashCode),
                         buf,
                         buf_size,
                         &mac);
  /* truncate to `struct GNUNET_ShortHashCode` */
  memcpy(smac, &mac, sizeof(struct GNUNET_ShortHashCode));
  /* ratchet hmac key */
  GNUNET_CRYPTO_hash(hmac_secret,
                     sizeof(struct GNUNET_HashCode),
                     hmac_secret);
}

Here is the call graph for this function:

Here is the caller graph for this function:

queue_finish()

static void queue_finish ( struct Queue *  queue )

static

Append a 'finish' message to the outgoing transmission.

Once the finish has been transmitted, destroy the queue.

Parameters

queue

queue to shut down nicely

Definition at line 654 of file gnunet-communicator-tcp.c.

References calculate_hmac(), Queue::finishing, GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH, GNUNET_YES, TCPFinish::header, TCPFinish::hmac, Queue::out_hmac, Queue::pwrite_buf, Queue::pwrite_off, GNUNET_MessageHeader::size, and GNUNET_MessageHeader::type.

Referenced by do_rekey(), mq_destroy(), mq_error(), queue_read(), and try_handle_plaintext().

{
  struct TCPFinish fin;

  memset(&fin, 0, sizeof(fin));
  fin.header.size = htons(sizeof(fin));
  fin.header.type = htons(GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH);
  calculate_hmac(&queue->out_hmac, &fin, sizeof(fin), &fin.hmac);
  /* if there is any message left in pwrite_buf, we
     overwrite it (possibly dropping the last message
     from CORE hard here) */
  memcpy(queue->pwrite_buf, &fin, sizeof(fin));
  queue->pwrite_off = sizeof(fin);
  /* This flag will ensure that #queue_write() no longer
     notifies CORE about the possibility of sending
     more data, and that #queue_write() will call
  #queue_destroy() once the @c fin was fully written. */
  queue->finishing = GNUNET_YES;
}

Here is the call graph for this function:

Here is the caller graph for this function:

reschedule_queue_timeout()

static void reschedule_queue_timeout ( struct Queue *  queue )

static

Increment queue timeout due to activity.

We do not immediately notify the monitor here as that might generate excessive signalling.

Parameters

queue

queue for which the timeout should be rescheduled

Definition at line 683 of file gnunet-communicator-tcp.c.

References GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_TIME_relative_to_absolute(), queue_read(), and Queue::timeout.

Referenced by core_read_finished_cb(), queue_read(), queue_read_kx(), and queue_write().

{
  queue->timeout =
    GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
}

Here is the call graph for this function:

Here is the caller graph for this function:

queue_read()

static void queue_read ( void *  cls )

static

Queue read task.

If we hit the timeout, disconnect it

Parameters

cls	the struct Queue * to disconnect

Definition at line 988 of file gnunet-communicator-tcp.c.

References BUF_SIZE, Queue::cread_buf, Queue::cread_off, done(), GNUNET_assert, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_log_strerror, GNUNET_MIN, GNUNET_NETWORK_socket_recv(), GNUNET_NO, GNUNET_SCHEDULER_add_read_net(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get_remaining(), GNUNET_YES, Queue::in_cipher, Queue::pread_buf, Queue::pread_off, queue(), queue_finish(), Queue::read_task, Queue::rekeyed, GNUNET_TIME_Relative::rel_value_us, reschedule_queue_timeout(), Queue::sock, Queue::timeout, and try_handle_plaintext().

Referenced by core_read_finished_cb(), proto_read_kx(), queue_read_kx(), and reschedule_queue_timeout().

{
  struct Queue *queue = cls;
  struct GNUNET_TIME_Relative left;
  ssize_t rcvd;

  queue->read_task = NULL;
  rcvd = GNUNET_NETWORK_socket_recv(queue->sock,
                                    &queue->cread_buf[queue->cread_off],
                                    BUF_SIZE - queue->cread_off);
  if (-1 == rcvd)
    {
      if ((EAGAIN != errno) && (EINTR != errno))
        {
          GNUNET_log_strerror(GNUNET_ERROR_TYPE_DEBUG, "recv");
          queue_finish(queue);
          return;
        }
      /* try again */
      queue->read_task =
        GNUNET_SCHEDULER_add_read_net(left, queue->sock, &queue_read, queue);
      return;
    }
  if (0 != rcvd)
    reschedule_queue_timeout(queue);
  queue->cread_off += rcvd;
  while ((queue->pread_off < sizeof(queue->pread_buf)) &&
         (queue->cread_off > 0))
    {
      size_t max = GNUNET_MIN(sizeof(queue->pread_buf) - queue->pread_off,
                              queue->cread_off);
      size_t done;
      size_t total;

      GNUNET_assert(0 ==
                    gcry_cipher_decrypt(queue->in_cipher,
                                        &queue->pread_buf[queue->pread_off],
                                        max,
                                        queue->cread_buf,
                                        max));
      queue->pread_off += max;
      total = 0;
      while ((GNUNET_NO == queue->rekeyed) &&
             (0 != (done = try_handle_plaintext(queue))))
        {
          /* 'done' bytes of plaintext were used, shift buffer */
          GNUNET_assert(done <= queue->pread_off);
          /* NOTE: this memmove() could possibly sometimes be
             avoided if we pass 'total' into try_handle_plaintext()
             and use it at an offset into the buffer there! */
          memmove(queue->pread_buf,
                  &queue->pread_buf[done],
                  queue->pread_off - done);
          queue->pread_off -= done;
          total += done;
        }
      /* when we encounter a rekey message, the decryption above uses the
         wrong key for everything after the rekey; in that case, we have
         to re-do the decryption at 'total' instead of at 'max'. If there
         is no rekey and the last message is incomplete (max > total),
         it is safe to keep the decryption so we shift by 'max' */
      if (GNUNET_YES == queue->rekeyed)
        {
          max = total;
          queue->rekeyed = GNUNET_NO;
        }
      memmove(queue->cread_buf, &queue->cread_buf[max], queue->cread_off - max);
      queue->cread_off -= max;
    }

  if (BUF_SIZE == queue->cread_off)
    return; /* buffer full, suspend reading */
  left = GNUNET_TIME_absolute_get_remaining(queue->timeout);
  if (0 != left.rel_value_us)
    {
      if (max_queue_length < queue->backpressure)
        {
          /* continue reading */
          queue->read_task =
            GNUNET_SCHEDULER_add_read_net(left, queue->sock, &queue_read, queue);
        }
      return;
    }
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Queue %p was idle for %s, disconnecting\n",
             queue,
             GNUNET_STRINGS_relative_time_to_string(
               GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
               GNUNET_YES));
  queue_finish(queue);
}

Here is the call graph for this function:

Here is the caller graph for this function:

core_read_finished_cb()

static void core_read_finished_cb ( void *  cls, int  success  )

static

Core tells us it is done processing a message that transport received on a queue with status success.

Parameters

cls	a struct Queue * where the message originally came from
success	GNUNET_OK on success

Definition at line 707 of file gnunet-communicator-tcp.c.

References Queue::backpressure, Queue::destroyed, GNUNET_free, GNUNET_NO, GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_STATISTICS_update(), GNUNET_TIME_absolute_get_remaining(), queue(), queue_read(), Queue::read_task, reschedule_queue_timeout(), Queue::sock, and Queue::timeout.

Referenced by pass_plaintext_to_core().

{
  struct Queue *queue = cls;

  if (GNUNET_OK != success)
    GNUNET_STATISTICS_update(stats,
                             "# messages lost in communicator API towards CORE",
                             1,
                             GNUNET_NO);
  queue->backpressure--;
  /* handle deferred queue destruction */
  if ((queue->destroyed) && (0 == queue->backpressure))
    {
      GNUNET_free(queue);
      return;
    }
  reschedule_queue_timeout(queue);
  /* possibly unchoke reading, now that CORE made progress */
  if (NULL == queue->read_task)
    queue->read_task =
      GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_absolute_get_remaining(
                                      queue->timeout),
                                    queue->sock,
                                    &queue_read,
                                    queue);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pass_plaintext_to_core()

static void pass_plaintext_to_core ( struct Queue *  queue, const void *  plaintext, size_t  plaintext_len  )

static

We received plaintext_len bytes of plaintext on queue.

Pass it on to CORE. If transmission is actually happening, increase backpressure counter.

Parameters

queue	the queue that received the plaintext
plaintext	the plaintext that was received
plaintext_len	number of bytes of plaintext received

Definition at line 745 of file gnunet-communicator-tcp.c.

References ADDRESS_VALIDITY_PERIOD, Queue::backpressure, core_read_finished_cb(), GNUNET_break, GNUNET_NO, GNUNET_OK, GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TRANSPORT_communicator_receive(), ret, GNUNET_MessageHeader::size, and Queue::target.

Referenced by try_handle_plaintext().

{
  const struct GNUNET_MessageHeader *hdr = plaintext;
  int ret;

  if (ntohs(hdr->size) != plaintext_len)
    {
      /* NOTE: If we ever allow multiple CORE messages in one
         BOX, this will have to change! */
      GNUNET_break(0);
      return;
    }
  ret = GNUNET_TRANSPORT_communicator_receive(ch,
                                              &queue->target,
                                              hdr,
                                              ADDRESS_VALIDITY_PERIOD,
                                              &core_read_finished_cb,
                                              queue);
  if (GNUNET_OK == ret)
    queue->backpressure++;
  GNUNET_break(GNUNET_NO != ret);  /* backpressure not working!? */
  if (GNUNET_SYSERR == ret)
    GNUNET_STATISTICS_update(stats,
                             "# bytes lost due to CORE not running",
                             plaintext_len,
                             GNUNET_NO);
}

Here is the call graph for this function:

Here is the caller graph for this function:

setup_cipher()

static void setup_cipher ( const struct GNUNET_HashCode *  dh, const struct GNUNET_PeerIdentity *  pid, gcry_cipher_hd_t *  cipher, struct GNUNET_HashCode *  hmac_key  )

static

Setup cipher based on shared secret dh and decrypting peer pid.

Parameters

dh	shared secret
pid	decrypting peer's identity
cipher[out]	cipher to initialize
hmac_key[out]	HMAC key to initialize

Definition at line 786 of file gnunet-communicator-tcp.c.

References GNUNET_assert, GNUNET_CRYPTO_kdf(), GNUNET_YES, and key.

Referenced by setup_in_cipher(), and setup_out_cipher().

{
  char key[256 / 8];
  char ctr[128 / 8];

  gcry_cipher_open(cipher,
                   GCRY_CIPHER_AES256 /* low level: go for speed */,
                   GCRY_CIPHER_MODE_CTR,
                   0 /* flags */);
  GNUNET_assert(GNUNET_YES == GNUNET_CRYPTO_kdf(key,
                                                sizeof(key),
                                                "TCP-key",
                                                strlen("TCP-key"),
                                                dh,
                                                sizeof(*dh),
                                                pid,
                                                sizeof(*pid),
                                                NULL,
                                                0));
  gcry_cipher_setkey(*cipher, key, sizeof(key));
  GNUNET_assert(GNUNET_YES == GNUNET_CRYPTO_kdf(ctr,
                                                sizeof(ctr),
                                                "TCP-ctr",
                                                strlen("TCP-ctr"),
                                                dh,
                                                sizeof(*dh),
                                                pid,
                                                sizeof(*pid),
                                                NULL,
                                                0));
  gcry_cipher_setctr(*cipher, ctr, sizeof(ctr));
  GNUNET_assert(GNUNET_YES ==
                GNUNET_CRYPTO_kdf(hmac_key,
                                  sizeof(struct GNUNET_HashCode),
                                  "TCP-hmac",
                                  strlen("TCP-hmac"),
                                  dh,
                                  sizeof(*dh),
                                  pid,
                                  sizeof(*pid),
                                  NULL,
                                  0));
}

Here is the call graph for this function:

Here is the caller graph for this function:

setup_in_cipher()

static void setup_in_cipher ( const struct GNUNET_CRYPTO_EcdhePublicKey *  ephemeral, struct Queue *  queue  )

static

Setup cipher of queue for decryption.

Parameters

ephemeral	ephemeral key we received from the other peer
queue[in,out]	queue to initialize decryption cipher for

Definition at line 841 of file gnunet-communicator-tcp.c.

References GNUNET_CRYPTO_eddsa_ecdh(), Queue::in_cipher, Queue::in_hmac, my_identity, and setup_cipher().

Referenced by do_rekey(), proto_read_kx(), and queue_read_kx().

{
  struct GNUNET_HashCode dh;

  GNUNET_CRYPTO_eddsa_ecdh(my_private_key, ephemeral, &dh);
  setup_cipher(&dh, &my_identity, &queue->in_cipher, &queue->in_hmac);
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_rekey()

static void do_rekey ( struct Queue *  queue, const struct TCPRekey *  rekey  )

static

Handle rekey message on queue.

The message was already HMAC'ed, but we should additionally still check the signature. Then we need to stop the old cipher and start afresh.

Parameters

queue	the queue rekey was received on
rekey	the rekey message

Definition at line 860 of file gnunet-communicator-tcp.c.

References TcpHandshakeSignature::ephemeral, TCPRekey::ephemeral, GNUNET_break, GNUNET_CRYPTO_eddsa_verify(), GNUNET_OK, GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY, GNUNET_YES, Queue::in_cipher, TcpHandshakeSignature::monotonic_time, TCPRekey::monotonic_time, my_identity, GNUNET_PeerIdentity::public_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, TcpHandshakeSignature::purpose, queue_finish(), TcpHandshakeSignature::receiver, Queue::rekeyed, TcpHandshakeSignature::sender, TCPRekey::sender_sig, setup_in_cipher(), GNUNET_CRYPTO_EccSignaturePurpose::size, and Queue::target.

Referenced by try_handle_plaintext().

{
  struct TcpHandshakeSignature thp;

  thp.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY);
  thp.purpose.size = htonl(sizeof(thp));
  thp.sender = queue->target;
  thp.receiver = my_identity;
  thp.ephemeral = rekey->ephemeral;
  thp.monotonic_time = rekey->monotonic_time;
  /* FIXME: check monotonic time is monotonic... */
  if (GNUNET_OK !=
      GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY,
                                 &thp.purpose,
                                 &rekey->sender_sig,
                                 &queue->target.public_key))
    {
      GNUNET_break(0);
      queue_finish(queue);
      return;
    }
  gcry_cipher_close(queue->in_cipher);
  queue->rekeyed = GNUNET_YES;
  setup_in_cipher(&rekey->ephemeral, queue);
}

Here is the call graph for this function:

Here is the caller graph for this function:

try_handle_plaintext()

static size_t try_handle_plaintext ( struct Queue *  queue )

static

Test if we have received a full message in plaintext.

If so, handle it.

Parameters

queue

queue to process inbound plaintext for

Returns

number of bytes of plaintext handled, 0 for none

Definition at line 895 of file gnunet-communicator-tcp.c.

References calculate_hmac(), do_rekey(), GNUNET_assert, GNUNET_break_op, GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX, GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH, GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY, TCPFinish::hmac, TCPRekey::hmac, Queue::in_hmac, pass_plaintext_to_core(), Queue::pread_buf, Queue::pread_off, queue_destroy(), queue_finish(), size, GNUNET_MessageHeader::size, type, and GNUNET_MessageHeader::type.

Referenced by queue_read().

{
  const struct GNUNET_MessageHeader *hdr =
    (const struct GNUNET_MessageHeader *)queue->pread_buf;
  const struct TCPBox *box = (const struct TCPBox *)queue->pread_buf;
  const struct TCPRekey *rekey = (const struct TCPRekey *)queue->pread_buf;
  const struct TCPFinish *fin = (const struct TCPFinish *)queue->pread_buf;
  struct TCPRekey rekeyz;
  struct TCPFinish finz;
  struct GNUNET_ShortHashCode tmac;
  uint16_t type;
  size_t size = 0; /* make compiler happy */

  if (sizeof(*hdr) > queue->pread_off)
    return 0; /* not even a header */
  type = ntohs(hdr->type);
  switch (type)
    {
    case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX:
      /* Special case: header size excludes box itself! */
      if (ntohs(hdr->size) + sizeof(struct TCPBox) > queue->pread_off)
        return 0;
      calculate_hmac(&queue->in_hmac, &box[1], ntohs(hdr->size), &tmac);
      if (0 != memcmp(&tmac, &box->hmac, sizeof(tmac)))
        {
          GNUNET_break_op(0);
          queue_finish(queue);
          return 0;
        }
      pass_plaintext_to_core(queue, (const void *)&box[1], ntohs(hdr->size));
      size = ntohs(hdr->size) + sizeof(*box);
      break;

    case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY:
      if (sizeof(*rekey) > queue->pread_off)
        return 0;
      if (ntohs(hdr->size) != sizeof(*rekey))
        {
          GNUNET_break_op(0);
          queue_finish(queue);
          return 0;
        }
      rekeyz = *rekey;
      memset(&rekeyz.hmac, 0, sizeof(rekeyz.hmac));
      calculate_hmac(&queue->in_hmac, &rekeyz, sizeof(rekeyz), &tmac);
      if (0 != memcmp(&tmac, &box->hmac, sizeof(tmac)))
        {
          GNUNET_break_op(0);
          queue_finish(queue);
          return 0;
        }
      do_rekey(queue, rekey);
      size = ntohs(hdr->size);
      break;

    case GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_FINISH:
      if (sizeof(*fin) > queue->pread_off)
        return 0;
      if (ntohs(hdr->size) != sizeof(*fin))
        {
          GNUNET_break_op(0);
          queue_finish(queue);
          return 0;
        }
      finz = *fin;
      memset(&finz.hmac, 0, sizeof(finz.hmac));
      calculate_hmac(&queue->in_hmac, &rekeyz, sizeof(rekeyz), &tmac);
      if (0 != memcmp(&tmac, &fin->hmac, sizeof(tmac)))
        {
          GNUNET_break_op(0);
          queue_finish(queue);
          return 0;
        }
      /* handle FINISH by destroying queue */
      queue_destroy(queue);
      break;

    default:
      GNUNET_break_op(0);
      queue_finish(queue);
      return 0;
    }
  GNUNET_assert(0 != size);
  return size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

tcp_address_to_sockaddr()

static struct sockaddr* tcp_address_to_sockaddr ( const char *  bindto, socklen_t *  sock_len  )

static

Convert TCP bind specification to a struct sockaddr *

Parameters

	bindto	bind specification to convert
[out]	sock_len	set to the length of the address

Returns

converted bindto specification

Definition at line 1089 of file gnunet-communicator-tcp.c.

References COMMUNICATOR_CONFIG_SECTION, dummy, GNUNET_CONFIGURATION_get_value_yesno(), GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_malloc, GNUNET_memdup, GNUNET_NETWORK_test_pf(), GNUNET_NO, GNUNET_strdup, GNUNET_YES, port, and start.

Referenced by mq_init(), and run().

{
  struct sockaddr *in;
  unsigned int port;
  char dummy[2];
  char *colon;
  char *cp;

  if (1 == sscanf(bindto, "%u%1s", &port, dummy))
    {
      /* interpreting value as just a PORT number */
      if (port > UINT16_MAX)
        {
          GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                     "BINDTO specification `%s' invalid: value too large for port\n",
                     bindto);
          return NULL;
        }
      if ((GNUNET_NO == GNUNET_NETWORK_test_pf(PF_INET6)) ||
          (GNUNET_YES ==
           GNUNET_CONFIGURATION_get_value_yesno(cfg,
                                                COMMUNICATOR_CONFIG_SECTION,
                                                "DISABLE_V6")))
        {
          struct sockaddr_in *i4;

          i4 = GNUNET_malloc(sizeof(struct sockaddr_in));
          i4->sin_family = AF_INET;
          i4->sin_port = htons((uint16_t)port);
          *sock_len = sizeof(struct sockaddr_in);
          in = (struct sockaddr *)i4;
        }
      else
        {
          struct sockaddr_in6 *i6;

          i6 = GNUNET_malloc(sizeof(struct sockaddr_in6));
          i6->sin6_family = AF_INET6;
          i6->sin6_port = htons((uint16_t)port);
          *sock_len = sizeof(struct sockaddr_in6);
          in = (struct sockaddr *)i6;
        }
      return in;
    }
  cp = GNUNET_strdup(bindto);
  colon = strrchr(cp, ':');
  if (NULL != colon)
    {
      /* interpet value after colon as port */
      *colon = '\0';
      colon++;
      if (1 == sscanf(colon, "%u%1s", &port, dummy))
        {
          /* interpreting value as just a PORT number */
          if (port > UINT16_MAX)
            {
              GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                         "BINDTO specification `%s' invalid: value too large for port\n",
                         bindto);
              GNUNET_free(cp);
              return NULL;
            }
        }
      else
        {
          GNUNET_log(
            GNUNET_ERROR_TYPE_ERROR,
            "BINDTO specification `%s' invalid: last ':' not followed by number\n",
            bindto);
          GNUNET_free(cp);
          return NULL;
        }
    }
  else
    {
      /* interpret missing port as 0, aka pick any free one */
      port = 0;
    }
  {
    /* try IPv4 */
    struct sockaddr_in v4;

    if (1 == inet_pton(AF_INET, cp, &v4))
      {
        v4.sin_port = htons((uint16_t)port);
        in = GNUNET_memdup(&v4, sizeof(v4));
        *sock_len = sizeof(v4);
        GNUNET_free(cp);
        return in;
      }
  }
  {
    /* try IPv6 */
    struct sockaddr_in6 v6;
    const char *start;

    start = cp;
    if (('[' == *cp) && (']' == cp[strlen(cp) - 1]))
      {
        start++; /* skip over '[' */
        cp[strlen(cp) - 1] = '\0'; /* eat ']' */
      }
    if (1 == inet_pton(AF_INET6, start, &v6))
      {
        v6.sin6_port = htons((uint16_t)port);
        in = GNUNET_memdup(&v6, sizeof(v6));
        *sock_len = sizeof(v6);
        GNUNET_free(cp);
        return in;
      }
  }
  /* #5528 FIXME (feature!): maybe also try getnameinfo()? */
  GNUNET_free(cp);
  return NULL;
}

Here is the call graph for this function:

Here is the caller graph for this function:

setup_out_cipher()

static void setup_out_cipher ( struct Queue *  queue )

static

Setup cipher for outgoing data stream based on target and our ephemeral private key.

Parameters

queue

queue to setup outgoing (encryption) cipher for

Definition at line 1213 of file gnunet-communicator-tcp.c.

References Queue::ephemeral, GNUNET_CRYPTO_ecdh_eddsa(), GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u64(), GNUNET_TIME_relative_to_absolute(), Queue::out_cipher, Queue::out_hmac, GNUNET_PeerIdentity::public_key, Queue::rekey_left_bytes, REKEY_MAX_BYTES, Queue::rekey_time, REKEY_TIME_INTERVAL, setup_cipher(), and Queue::target.

Referenced by queue_write(), and start_initial_kx_out().

{
  struct GNUNET_HashCode dh;

  GNUNET_CRYPTO_ecdh_eddsa(&queue->ephemeral, &queue->target.public_key, &dh);
  /* we don't need the private key anymore, drop it! */
  memset(&queue->ephemeral, 0, sizeof(queue->ephemeral));
  setup_cipher(&dh, &queue->target, &queue->out_cipher, &queue->out_hmac);
  queue->rekey_time = GNUNET_TIME_relative_to_absolute(REKEY_TIME_INTERVAL);
  queue->rekey_left_bytes =
    GNUNET_CRYPTO_random_u64(GNUNET_CRYPTO_QUALITY_WEAK, REKEY_MAX_BYTES);
}

Here is the call graph for this function:

Here is the caller graph for this function:

inject_rekey()

static void inject_rekey ( struct Queue *  queue )

static

Inject a struct TCPRekey message into the queue's plaintext buffer.

Parameters

queue

queue to perform rekeying on

Definition at line 1234 of file gnunet-communicator-tcp.c.

References calculate_hmac(), Queue::ephemeral, TCPRekey::ephemeral, TcpHandshakeSignature::ephemeral, GNUNET_assert, GNUNET_CRYPTO_ecdhe_key_create2(), GNUNET_CRYPTO_ecdhe_key_get_public(), GNUNET_CRYPTO_eddsa_sign(), GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY, GNUNET_OK, GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY, GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_absolute_hton(), TCPRekey::header, TCPRekey::hmac, TCPRekey::monotonic_time, TcpHandshakeSignature::monotonic_time, my_identity, Queue::out_hmac, GNUNET_CRYPTO_EccSignaturePurpose::purpose, TcpHandshakeSignature::purpose, Queue::pwrite_buf, Queue::pwrite_off, TcpHandshakeSignature::receiver, TcpHandshakeSignature::sender, TCPRekey::sender_sig, GNUNET_CRYPTO_EccSignaturePurpose::size, GNUNET_MessageHeader::size, Queue::target, and GNUNET_MessageHeader::type.

Referenced by queue_write().

{
  struct TCPRekey rekey;
  struct TcpHandshakeSignature thp;

  GNUNET_assert(0 == queue->pwrite_off);
  memset(&rekey, 0, sizeof(rekey));
  GNUNET_assert(GNUNET_OK ==
                GNUNET_CRYPTO_ecdhe_key_create2(&queue->ephemeral));
  rekey.header.type = ntohs(GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_REKEY);
  rekey.header.size = ntohs(sizeof(rekey));
  GNUNET_CRYPTO_ecdhe_key_get_public(&queue->ephemeral, &rekey.ephemeral);
  rekey.monotonic_time =
    GNUNET_TIME_absolute_hton(GNUNET_TIME_absolute_get_monotonic(cfg));
  thp.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_TCP_REKEY);
  thp.purpose.size = htonl(sizeof(thp));
  thp.sender = my_identity;
  thp.receiver = queue->target;
  thp.ephemeral = rekey.ephemeral;
  thp.monotonic_time = rekey.monotonic_time;
  GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_eddsa_sign(my_private_key,
                                                      &thp.purpose,
                                                      &rekey.sender_sig));
  calculate_hmac(&queue->out_hmac, &rekey, sizeof(rekey), &rekey.hmac);
  memcpy(queue->pwrite_buf, &rekey, sizeof(rekey));
  queue->pwrite_off = sizeof(rekey);
}

Here is the call graph for this function:

Here is the caller graph for this function:

queue_write()

static void queue_write ( void *  cls )

static

We have been notified that our socket is ready to write.

Then reschedule this function to be called again once more is available.

Parameters

cls	a struct Queue

Definition at line 1270 of file gnunet-communicator-tcp.c.

References BUF_SIZE, Queue::cwrite_buf, Queue::cwrite_off, Queue::finishing, GNUNET_assert, GNUNET_ERROR_TYPE_WARNING, GNUNET_log_strerror, GNUNET_MQ_impl_send_continue(), GNUNET_NETWORK_socket_send(), GNUNET_NO, GNUNET_SCHEDULER_add_write_net(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, inject_rekey(), Queue::mq, Queue::mq_awaits_continue, Queue::out_cipher, Queue::pwrite_buf, Queue::pwrite_off, queue(), queue_destroy(), Queue::rekey_left_bytes, Queue::rekey_time, GNUNET_TIME_Relative::rel_value_us, reschedule_queue_timeout(), setup_out_cipher(), Queue::sock, and Queue::write_task.

Referenced by mq_init(), mq_send(), and proto_read_kx().

{
  struct Queue *queue = cls;
  ssize_t sent;

  queue->write_task = NULL;
  if (0 != queue->cwrite_off)
    {
      sent = GNUNET_NETWORK_socket_send(queue->sock,
                                        queue->cwrite_buf,
                                        queue->cwrite_off);
      if ((-1 == sent) && (EAGAIN != errno) && (EINTR != errno))
        {
          GNUNET_log_strerror(GNUNET_ERROR_TYPE_WARNING, "send");
          queue_destroy(queue);
          return;
        }
      if (sent > 0)
        {
          size_t usent = (size_t)sent;

          memmove(queue->cwrite_buf,
                  &queue->cwrite_buf[usent],
                  queue->cwrite_off - usent);
          reschedule_queue_timeout(queue);
        }
    }
  /* can we encrypt more? (always encrypt full messages, needed
     such that #mq_cancel() can work!) */
  if ((0 < queue->rekey_left_bytes) &&
      (queue->cwrite_off + queue->pwrite_off <= BUF_SIZE))
    {
      GNUNET_assert(0 ==
                    gcry_cipher_encrypt(queue->out_cipher,
                                        &queue->cwrite_buf[queue->cwrite_off],
                                        queue->pwrite_off,
                                        queue->pwrite_buf,
                                        queue->pwrite_off));
      if (queue->rekey_left_bytes > queue->pwrite_off)
        queue->rekey_left_bytes -= queue->pwrite_off;
      else
        queue->rekey_left_bytes = 0;
      queue->cwrite_off += queue->pwrite_off;
      queue->pwrite_off = 0;
    }
  if ((0 == queue->pwrite_off) &&
      ((0 == queue->rekey_left_bytes) ||
       (0 ==
        GNUNET_TIME_absolute_get_remaining(queue->rekey_time).rel_value_us)))
    {
      gcry_cipher_close(queue->out_cipher);
      setup_out_cipher(queue);
      inject_rekey(queue);
    }
  if ((0 == queue->pwrite_off) && (!queue->finishing) &&
      (queue->mq_awaits_continue))
    {
      queue->mq_awaits_continue = GNUNET_NO;
      GNUNET_MQ_impl_send_continue(queue->mq);
    }
  /* did we just finish writing 'finish'? */
  if ((0 == queue->cwrite_off) && (GNUNET_YES == queue->finishing))
    {
      queue_destroy(queue);
      return;
    }
  /* do we care to write more? */
  if ((0 < queue->cwrite_off) || (0 < queue->pwrite_off))
    queue->write_task =
      GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL,
                                     queue->sock,
                                     &queue_write,
                                     queue);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mq_send()

static void mq_send ( struct GNUNET_MQ_Handle *  mq, const struct GNUNET_MessageHeader *  msg, void *  impl_state  )

static

Signature of functions implementing the sending functionality of a message queue.

Parameters

mq	the message queue
msg	the message to send
impl_state	our struct Queue

Definition at line 1355 of file gnunet-communicator-tcp.c.

References calculate_hmac(), Queue::finishing, GNUNET_assert, GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX, GNUNET_SCHEDULER_add_write_net(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_YES, TCPBox::header, TCPBox::hmac, Queue::mq, Queue::out_hmac, Queue::pread_buf, Queue::pread_off, queue(), queue_write(), GNUNET_MessageHeader::size, Queue::sock, GNUNET_MessageHeader::type, and Queue::write_task.

Referenced by boot_queue().

{
  struct Queue *queue = impl_state;
  uint16_t msize = ntohs(msg->size);
  struct TCPBox box;

  GNUNET_assert(mq == queue->mq);
  if (GNUNET_YES == queue->finishing)
    return; /* this queue is dying, drop msg */
  GNUNET_assert(0 == queue->pread_off);
  box.header.type = htons(GNUNET_MESSAGE_TYPE_COMMUNICATOR_TCP_BOX);
  box.header.size = htons(msize);
  calculate_hmac(&queue->out_hmac, msg, msize, &box.hmac);
  memcpy(&queue->pread_buf[queue->pread_off], &box, sizeof(box));
  queue->pread_off += sizeof(box);
  memcpy(&queue->pread_buf[queue->pread_off], msg, msize);
  queue->pread_off += msize;
  GNUNET_assert(NULL != queue->sock);
  if (NULL == queue->write_task)
    queue->write_task =
      GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL,
                                     queue->sock,
                                     &queue_write,
                                     queue);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mq_destroy()

static void mq_destroy ( struct GNUNET_MQ_Handle *  mq, void *  impl_state  )

static

Signature of functions implementing the destruction of a message queue.

Implementations must not free mq, but should take care of impl_state.

Parameters

mq	the message queue to destroy
impl_state	our struct Queue

Definition at line 1393 of file gnunet-communicator-tcp.c.

References Queue::mq, queue(), and queue_finish().

Referenced by boot_queue().

{
  struct Queue *queue = impl_state;

  if (mq == queue->mq)
    {
      queue->mq = NULL;
      queue_finish(queue);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

mq_cancel()

static void mq_cancel ( struct GNUNET_MQ_Handle *  mq, void *  impl_state  )

static

Implementation function that cancels the currently sent message.

Parameters

mq	message queue
impl_state	our struct Queue

Definition at line 1412 of file gnunet-communicator-tcp.c.

References GNUNET_assert, Queue::pwrite_off, and queue().

Referenced by boot_queue().

{
  struct Queue *queue = impl_state;

  GNUNET_assert(0 != queue->pwrite_off);
  queue->pwrite_off = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

mq_error()

static void mq_error ( void *  cls, enum GNUNET_MQ_Error  error  )

static

Generic error handler, called with the appropriate error code and the same closure specified at the creation of the message queue.

Not every message queue implementation supports an error handler.

Parameters

cls	our struct Queue
error	error code

Definition at line 1431 of file gnunet-communicator-tcp.c.

References GNUNET_ERROR_TYPE_ERROR, GNUNET_i2s(), GNUNET_log, queue(), queue_finish(), and Queue::target.

Referenced by boot_queue().

{
  struct Queue *queue = cls;

  GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
             "MQ error in queue to %s: %d\n",
             GNUNET_i2s(&queue->target),
             (int)error);
  queue_finish(queue);
}

Here is the call graph for this function:

Here is the caller graph for this function:

boot_queue()

static void boot_queue ( struct Queue *  queue, enum GNUNET_TRANSPORT_ConnectionStatus  cs  )

static

Add the given queue to our internal data structure.

Setup the MQ processing and inform transport that the queue is ready. Must be called after the KX for outgoing messages has been bootstrapped.

Parameters

queue

queue to boot

Definition at line 1451 of file gnunet-communicator-tcp.c.

References Queue::address, Queue::address_len, COMMUNICATOR_ADDRESS_PREFIX, GNUNET_a2s(), GNUNET_asprintf(), GNUNET_assert, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE, GNUNET_CONTAINER_multipeermap_put(), GNUNET_CONTAINER_multipeermap_size(), GNUNET_free, GNUNET_MQ_queue_for_callbacks(), GNUNET_NO, GNUNET_NT_scanner_get_type(), GNUNET_STATISTICS_set(), GNUNET_TIME_relative_to_absolute(), GNUNET_TRANSPORT_communicator_mq_add(), Queue::mq, mq_cancel(), mq_destroy(), mq_error(), mq_send(), Queue::nt, Queue::qh, Queue::target, and Queue::timeout.

Referenced by mq_init(), and proto_read_kx().

{
  queue->nt =
    GNUNET_NT_scanner_get_type(is, queue->address, queue->address_len);
  (void)GNUNET_CONTAINER_multipeermap_put(
    queue_map,
    &queue->target,
    queue,
    GNUNET_CONTAINER_MULTIHASHMAPOPTION_MULTIPLE);
  GNUNET_STATISTICS_set(stats,
                        "# queues active",
                        GNUNET_CONTAINER_multipeermap_size(queue_map),
                        GNUNET_NO);
  queue->timeout =
    GNUNET_TIME_relative_to_absolute(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT);
  queue->mq = GNUNET_MQ_queue_for_callbacks(&mq_send,
                                            &mq_destroy,
                                            &mq_cancel,
                                            queue,
                                            NULL,
                                            &mq_error,
                                            queue);
  {
    char *foreign_addr;

    switch (queue->address->sa_family)
      {
      case AF_INET:
        GNUNET_asprintf(&foreign_addr,
                        "%s-%s",
                        COMMUNICATOR_ADDRESS_PREFIX,
                        GNUNET_a2s(queue->address, queue->address_len));
        break;

      case AF_INET6:
        GNUNET_asprintf(&foreign_addr,
                        "%s-%s",
                        COMMUNICATOR_ADDRESS_PREFIX,
                        GNUNET_a2s(queue->address, queue->address_len));
        break;

      default:
        GNUNET_assert(0);
      }
    queue->qh = GNUNET_TRANSPORT_communicator_mq_add(ch,
                                                     &queue->target,
                                                     foreign_addr,
                                                     0 /* no MTU */,
                                                     queue->nt,
                                                     cs,
                                                     queue->mq);
    GNUNET_free(foreign_addr);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

transmit_kx()

static void transmit_kx ( struct Queue *  queue, const struct GNUNET_CRYPTO_EcdhePublicKey *  epub  )

static

Generate and transmit our ephemeral key and the signature for the initial KX with the other peer.

Must be called first, before any other bytes are ever written to the output buffer. Note that our cipher must already be initialized when calling this function. Helper function for start_initial_kx_out().

Parameters

queue	queue to do KX for
epub	our public key for the KX

Definition at line 1518 of file gnunet-communicator-tcp.c.

References Queue::cwrite_buf, Queue::cwrite_off, TcpHandshakeSignature::ephemeral, GNUNET_assert, GNUNET_CRYPTO_eddsa_sign(), GNUNET_OK, GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE, GNUNET_TIME_absolute_get_monotonic(), GNUNET_TIME_absolute_hton(), TcpHandshakeSignature::monotonic_time, TCPConfirmation::monotonic_time, my_identity, Queue::out_cipher, GNUNET_CRYPTO_EccSignaturePurpose::purpose, TcpHandshakeSignature::purpose, TcpHandshakeSignature::receiver, TCPConfirmation::sender, TcpHandshakeSignature::sender, TCPConfirmation::sender_sig, GNUNET_CRYPTO_EccSignaturePurpose::size, Queue::target, and tc.

Referenced by start_initial_kx_out().

{
  struct TcpHandshakeSignature ths;
  struct TCPConfirmation tc;

  memcpy(queue->cwrite_buf, epub, sizeof(*epub));
  queue->cwrite_off = sizeof(epub);
  /* compute 'tc' and append in encrypted format to cwrite_buf */
  tc.sender = my_identity;
  tc.monotonic_time =
    GNUNET_TIME_absolute_hton(GNUNET_TIME_absolute_get_monotonic(cfg));
  ths.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE);
  ths.purpose.size = htonl(sizeof(ths));
  ths.sender = my_identity;
  ths.receiver = queue->target;
  ths.ephemeral = *epub;
  ths.monotonic_time = tc.monotonic_time;
  GNUNET_assert(GNUNET_OK == GNUNET_CRYPTO_eddsa_sign(my_private_key,
                                                      &ths.purpose,
                                                      &tc.sender_sig));
  GNUNET_assert(0 ==
                gcry_cipher_encrypt(queue->out_cipher,
                                    &queue->cwrite_buf[queue->cwrite_off],
                                    sizeof(tc),
                                    &tc,
                                    sizeof(tc)));
  queue->cwrite_off += sizeof(tc);
}

Here is the call graph for this function:

Here is the caller graph for this function:

start_initial_kx_out()

static void start_initial_kx_out ( struct Queue *  queue )

static

Initialize our key material for outgoing transmissions and inform the other peer about it.

Must be called first before any data is sent.

Parameters

queue

the queue to setup

Definition at line 1557 of file gnunet-communicator-tcp.c.

References Queue::ephemeral, GNUNET_assert, GNUNET_CRYPTO_ecdhe_key_create2(), GNUNET_CRYPTO_ecdhe_key_get_public(), GNUNET_OK, setup_out_cipher(), and transmit_kx().

Referenced by mq_init(), and proto_read_kx().

{
  struct GNUNET_CRYPTO_EcdhePublicKey epub;

  GNUNET_assert(GNUNET_OK ==
                GNUNET_CRYPTO_ecdhe_key_create2(&queue->ephemeral));
  GNUNET_CRYPTO_ecdhe_key_get_public(&queue->ephemeral, &epub);
  setup_out_cipher(queue);
  transmit_kx(queue, &epub);
}

Here is the call graph for this function:

Here is the caller graph for this function:

decrypt_and_check_tc()

static int decrypt_and_check_tc ( struct Queue *  queue, struct TCPConfirmation *  tc, char *  ibuf  )

static

We have received the first bytes from the other side on a queue.

Decrypt the tc contained in ibuf and check the signature. Note that setup_in_cipher() must have already been called.

Parameters

queue	queue to decrypt initial bytes from other peer for
tc[out]	where to store the result
ibuf	incoming data, of size INITIAL_KX_SIZE

Returns

GNUNET_OK if the signature was OK, GNUNET_SYSERR if not

Definition at line 1581 of file gnunet-communicator-tcp.c.

References TcpHandshakeSignature::ephemeral, GNUNET_assert, GNUNET_CRYPTO_eddsa_verify(), GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE, Queue::in_cipher, TCPConfirmation::monotonic_time, TcpHandshakeSignature::monotonic_time, my_identity, GNUNET_PeerIdentity::public_key, GNUNET_CRYPTO_EccSignaturePurpose::purpose, TcpHandshakeSignature::purpose, TcpHandshakeSignature::receiver, TcpHandshakeSignature::sender, TCPConfirmation::sender, TCPConfirmation::sender_sig, and GNUNET_CRYPTO_EccSignaturePurpose::size.

Referenced by proto_read_kx(), and queue_read_kx().

{
  struct TcpHandshakeSignature ths;

  GNUNET_assert(
    0 ==
    gcry_cipher_decrypt(queue->in_cipher,
                        tc,
                        sizeof(*tc),
                        &ibuf[sizeof(struct GNUNET_CRYPTO_EcdhePublicKey)],
                        sizeof(tc)));
  ths.purpose.purpose = htonl(GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE);
  ths.purpose.size = htonl(sizeof(ths));
  ths.sender = tc->sender;
  ths.receiver = my_identity;
  memcpy(&ths.ephemeral, ibuf, sizeof(struct GNUNET_CRYPTO_EcdhePublicKey));
  ths.monotonic_time = tc->monotonic_time;
  /* FIXME: check monotonic time against previous mono times
     from this sender! */
  return GNUNET_CRYPTO_eddsa_verify(GNUNET_SIGNATURE_COMMUNICATOR_TCP_HANDSHAKE,
                                    &ths.purpose,
                                    &tc->sender_sig,
                                    &tc->sender.public_key);
}

Here is the call graph for this function:

Here is the caller graph for this function:

free_proto_queue()

static void free_proto_queue ( struct ProtoQueue *  pq )

static

Closes socket and frees memory associated with pq.

Parameters

pq	proto queue to free

Definition at line 1615 of file gnunet-communicator-tcp.c.

References ProtoQueue::address, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_NETWORK_socket_close(), and ProtoQueue::sock.

Referenced by do_shutdown(), and proto_read_kx().

{
  GNUNET_NETWORK_socket_close(pq->sock);
  GNUNET_free(pq->address);
  GNUNET_CONTAINER_DLL_remove(proto_head, proto_tail, pq);
  GNUNET_free(pq);
}

Here is the call graph for this function:

Here is the caller graph for this function:

proto_read_kx()

static void proto_read_kx ( void *  cls )

static

Read from the socket of the proto queue until we have enough data to upgrade to full queue.

Parameters

cls	a struct ProtoQueue

Definition at line 1631 of file gnunet-communicator-tcp.c.

References Queue::address, ProtoQueue::address, Queue::address_len, ProtoQueue::address_len, boot_queue(), decrypt_and_check_tc(), free_proto_queue(), GNUNET_a2s(), GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_CONTAINER_DLL_remove, GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_free, GNUNET_log, GNUNET_log_strerror, GNUNET_NETWORK_socket_recv(), GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_add_write_net(), GNUNET_TIME_absolute_get_remaining(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_CS_INBOUND, ProtoQueue::ibuf, ProtoQueue::ibuf_off, Queue::in_cipher, queue(), queue_read(), queue_write(), Queue::read_task, ProtoQueue::read_task, GNUNET_TIME_Relative::rel_value_us, TCPConfirmation::sender, setup_in_cipher(), Queue::sock, ProtoQueue::sock, start_initial_kx_out(), Queue::target, ProtoQueue::timeout, and Queue::write_task.

Referenced by listen_cb().

{
  struct ProtoQueue *pq = cls;
  ssize_t rcvd;
  struct GNUNET_TIME_Relative left;
  struct Queue *queue;
  struct TCPConfirmation tc;

  pq->read_task = NULL;
  left = GNUNET_TIME_absolute_get_remaining(pq->timeout);
  if (0 == left.rel_value_us)
    {
      free_proto_queue(pq);
      return;
    }
  rcvd = GNUNET_NETWORK_socket_recv(pq->sock,
                                    &pq->ibuf[pq->ibuf_off],
                                    sizeof(pq->ibuf) - pq->ibuf_off);
  if (-1 == rcvd)
    {
      if ((EAGAIN != errno) && (EINTR != errno))
        {
          GNUNET_log_strerror(GNUNET_ERROR_TYPE_DEBUG, "recv");
          free_proto_queue(pq);
          return;
        }
      /* try again */
      pq->read_task =
        GNUNET_SCHEDULER_add_read_net(left, pq->sock, &proto_read_kx, pq);
      return;
    }
  pq->ibuf_off += rcvd;
  if (pq->ibuf_off > sizeof(pq->ibuf))
    {
      /* read more */
      pq->read_task =
        GNUNET_SCHEDULER_add_read_net(left, pq->sock, &proto_read_kx, pq);
      return;
    }
  /* we got all the data, let's find out who we are talking to! */
  queue = GNUNET_new(struct Queue);
  setup_in_cipher((const struct GNUNET_CRYPTO_EcdhePublicKey *)pq->ibuf,
                  queue);
  if (GNUNET_OK != decrypt_and_check_tc(queue, &tc, pq->ibuf))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Invalid TCP KX received from %s\n",
                 GNUNET_a2s(queue->address, queue->address_len));
      gcry_cipher_close(queue->in_cipher);
      GNUNET_free(queue);
      free_proto_queue(pq);
      return;
    }
  queue->address = pq->address; /* steals reference */
  queue->address_len = pq->address_len;
  queue->target = tc.sender;
  start_initial_kx_out(queue);
  boot_queue(queue, GNUNET_TRANSPORT_CS_INBOUND);
  queue->read_task =
    GNUNET_SCHEDULER_add_read_net(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
                                  queue->sock,
                                  &queue_read,
                                  queue);
  queue->write_task =
    GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL,
                                   queue->sock,
                                   &queue_write,
                                   queue);
  GNUNET_CONTAINER_DLL_remove(proto_head, proto_tail, pq);
  GNUNET_free(pq);
}

Here is the call graph for this function:

Here is the caller graph for this function:

queue_read_kx()

static void queue_read_kx ( void *  cls )

static

Read from the socket of the queue until we have enough data to initialize the decryption logic and can switch to regular reading.

Parameters

cls	a struct Queue

Definition at line 1760 of file gnunet-communicator-tcp.c.

References Queue::address, Queue::address_len, BUF_SIZE, Queue::cread_buf, Queue::cread_off, decrypt_and_check_tc(), GNUNET_a2s(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_INFO, GNUNET_ERROR_TYPE_WARNING, GNUNET_log, GNUNET_log_strerror, GNUNET_NETWORK_socket_recv(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_add_read_net(), GNUNET_TIME_absolute_get_remaining(), INITIAL_KX_SIZE, queue(), queue_destroy(), queue_read(), Queue::read_task, GNUNET_TIME_Relative::rel_value_us, reschedule_queue_timeout(), TCPConfirmation::sender, setup_in_cipher(), Queue::sock, Queue::target, and Queue::timeout.

Referenced by mq_init().

{
  struct Queue *queue = cls;
  ssize_t rcvd;
  struct GNUNET_TIME_Relative left;
  struct TCPConfirmation tc;

  queue->read_task = NULL;
  left = GNUNET_TIME_absolute_get_remaining(queue->timeout);
  if (0 == left.rel_value_us)
    {
      queue_destroy(queue);
      return;
    }
  rcvd = GNUNET_NETWORK_socket_recv(queue->sock,
                                    &queue->cread_buf[queue->cread_off],
                                    BUF_SIZE - queue->cread_off);
  if (-1 == rcvd)
    {
      if ((EAGAIN != errno) && (EINTR != errno))
        {
          GNUNET_log_strerror(GNUNET_ERROR_TYPE_DEBUG, "recv");
          queue_destroy(queue);
          return;
        }
      queue->read_task =
        GNUNET_SCHEDULER_add_read_net(left, queue->sock, &queue_read_kx, queue);
      return;
    }
  queue->cread_off += rcvd;
  if (queue->cread_off < INITIAL_KX_SIZE)
    {
      /* read more */
      queue->read_task =
        GNUNET_SCHEDULER_add_read_net(left, queue->sock, &queue_read_kx, queue);
      return;
    }
  /* we got all the data, let's find out who we are talking to! */
  setup_in_cipher((const struct GNUNET_CRYPTO_EcdhePublicKey *)
                  queue->cread_buf,
                  queue);
  if (GNUNET_OK != decrypt_and_check_tc(queue, &tc, queue->cread_buf))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_INFO,
                 "Invalid TCP KX received from %s\n",
                 GNUNET_a2s(queue->address, queue->address_len));
      queue_destroy(queue);
      return;
    }
  if (0 !=
      memcmp(&tc.sender, &queue->target, sizeof(struct GNUNET_PeerIdentity)))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 "Invalid sender in TCP KX received from %s\n",
                 GNUNET_a2s(queue->address, queue->address_len));
      queue_destroy(queue);
      return;
    }

  /* update queue timeout */
  reschedule_queue_timeout(queue);
  /* prepare to continue with regular read task immediately */
  memmove(queue->cread_buf,
          &queue->cread_buf[INITIAL_KX_SIZE],
          queue->cread_off - (INITIAL_KX_SIZE));
  queue->cread_off -= INITIAL_KX_SIZE;
  queue->read_task = GNUNET_SCHEDULER_add_now(&queue_read, queue);
}

Here is the call graph for this function:

Here is the caller graph for this function:

mq_init()

static int mq_init ( void *  cls, const struct GNUNET_PeerIdentity *  peer, const char *  address  )

static

Function called by the transport service to initialize a message queue given address information about another peer.

If and when the communication channel is established, the communicator must call GNUNET_TRANSPORT_communicator_mq_add() to notify the service that the channel is now up. It is the responsibility of the communicator to manage sane retries and timeouts for any peer/address combination provided by the transport service. Timeouts and retries do not need to be signalled to the transport service.

Parameters

cls	closure
peer	identity of the other peer
address	where to send the message, human-readable communicator-specific format, 0-terminated, UTF-8

Returns

GNUNET_OK on success, GNUNET_SYSERR if the provided address is invalid

Definition at line 1849 of file gnunet-communicator-tcp.c.

References Queue::address, Queue::address_len, boot_queue(), COMMUNICATOR_ADDRESS_PREFIX, GNUNET_break_op, GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_connect(), GNUNET_NETWORK_socket_create(), GNUNET_new, GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_add_write_net(), GNUNET_SYSERR, GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_CS_OUTBOUND, peer, queue(), queue_read_kx(), queue_write(), Queue::read_task, Queue::sock, start_initial_kx_out(), Queue::target, tcp_address_to_sockaddr(), and Queue::write_task.

Referenced by GNUNET_TRANSPORT_communicator_connect(), and run().

{
  struct Queue *queue;
  const char *path;
  struct sockaddr *in;
  socklen_t in_len;
  struct GNUNET_NETWORK_Handle *sock;

  if (0 != strncmp(address,
                   COMMUNICATOR_ADDRESS_PREFIX "-",
                   strlen(COMMUNICATOR_ADDRESS_PREFIX "-")))
    {
      GNUNET_break_op(0);
      return GNUNET_SYSERR;
    }
  path = &address[strlen(COMMUNICATOR_ADDRESS_PREFIX "-")];
  in = tcp_address_to_sockaddr(path, &in_len);

  sock = GNUNET_NETWORK_socket_create(in->sa_family, SOCK_STREAM, IPPROTO_TCP);
  if (NULL == sock)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 "socket(%d) failed: %s",
                 in->sa_family,
                 strerror(errno));
      GNUNET_free(in);
      return GNUNET_SYSERR;
    }
  if (GNUNET_OK != GNUNET_NETWORK_socket_connect(sock, in, in_len))
    {
      GNUNET_log(GNUNET_ERROR_TYPE_WARNING,
                 "connect to `%s' failed: %s",
                 address,
                 strerror(errno));
      GNUNET_NETWORK_socket_close(sock);
      GNUNET_free(in);
      return GNUNET_SYSERR;
    }

  queue = GNUNET_new(struct Queue);
  queue->target = *peer;
  queue->address = in;
  queue->address_len = in_len;
  queue->sock = sock;
  boot_queue(queue, GNUNET_TRANSPORT_CS_OUTBOUND);
  queue->read_task =
    GNUNET_SCHEDULER_add_read_net(GNUNET_CONSTANTS_IDLE_CONNECTION_TIMEOUT,
                                  queue->sock,
                                  &queue_read_kx,
                                  queue);
  start_initial_kx_out(queue);
  queue->write_task =
    GNUNET_SCHEDULER_add_write_net(GNUNET_TIME_UNIT_FOREVER_REL,
                                   queue->sock,
                                   &queue_write,
                                   queue);
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_queue_delete_it()

static int get_queue_delete_it ( void *  cls, const struct GNUNET_PeerIdentity *  target, void *  value  )

static

Iterator over all message queues to clean up.

Parameters

cls	NULL
target	unused
value	the queue to destroy

Returns

GNUNET_OK to continue to iterate

Definition at line 1918 of file gnunet-communicator-tcp.c.

References GNUNET_OK, queue(), queue_destroy(), and value.

Referenced by do_shutdown().

{
  struct Queue *queue = value;

  (void)cls;
  (void)target;
  queue_destroy(queue);
  return GNUNET_OK;
}

Here is the call graph for this function:

Here is the caller graph for this function:

do_shutdown()

static void do_shutdown ( void *  cls )

static

Shutdown the UNIX communicator.

Parameters

cls	NULL (always)

Definition at line 1937 of file gnunet-communicator-tcp.c.

References free_proto_queue(), get_queue_delete_it(), GNUNET_break, GNUNET_CONTAINER_multipeermap_destroy(), GNUNET_CONTAINER_multipeermap_iterate(), GNUNET_free, GNUNET_NAT_unregister(), GNUNET_NETWORK_socket_close(), GNUNET_NO, GNUNET_NT_scanner_done(), GNUNET_OK, GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_destroy(), and GNUNET_TRANSPORT_communicator_disconnect().

Referenced by run().

{
  while (NULL != proto_head)
    free_proto_queue(proto_head);
  if (NULL != nat)
    {
      GNUNET_NAT_unregister(nat);
      nat = NULL;
    }
  if (NULL != listen_task)
    {
      GNUNET_SCHEDULER_cancel(listen_task);
      listen_task = NULL;
    }
  if (NULL != listen_sock)
    {
      GNUNET_break(GNUNET_OK == GNUNET_NETWORK_socket_close(listen_sock));
      listen_sock = NULL;
    }
  GNUNET_CONTAINER_multipeermap_iterate(queue_map, &get_queue_delete_it, NULL);
  GNUNET_CONTAINER_multipeermap_destroy(queue_map);
  if (NULL != ch)
    {
      GNUNET_TRANSPORT_communicator_disconnect(ch);
      ch = NULL;
    }
  if (NULL != stats)
    {
      GNUNET_STATISTICS_destroy(stats, GNUNET_NO);
      stats = NULL;
    }
  if (NULL != my_private_key)
    {
      GNUNET_free(my_private_key);
      my_private_key = NULL;
    }
  if (NULL != is)
    {
      GNUNET_NT_scanner_done(is);
      is = NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

enc_notify_cb()

static void enc_notify_cb ( void *  cls, const struct GNUNET_PeerIdentity *  sender, const struct GNUNET_MessageHeader *  msg  )

static

Function called when the transport service has received an acknowledgement for this communicator (!) via a different return path.

Not applicable for TCP.

Parameters

cls	closure
sender	which peer sent the notification
msg	payload

Definition at line 1993 of file gnunet-communicator-tcp.c.

References GNUNET_break_op.

Referenced by run().

{
  (void)cls;
  (void)sender;
  (void)msg;
  GNUNET_break_op(0);
}

Here is the caller graph for this function:

nat_address_cb()

static void nat_address_cb ( void *  cls, void **  app_ctx, int  add_remove, enum GNUNET_NAT_AddressClass  ac, const struct sockaddr *  addr, socklen_t  addrlen  )

static

Signature of the callback passed to GNUNET_NAT_register() for a function to call whenever our set of 'valid' addresses changes.

Parameters

cls	closure
app_ctx[in,out]	location where the app can store stuff on add and retrieve it on remove
add_remove	GNUNET_YES to add a new public IP address, GNUNET_NO to remove a previous (now invalid) one
ac	address class the address belongs to
addr	either the previous or the new public IP address
addrlen	actual length of the addr

Definition at line 2018 of file gnunet-communicator-tcp.c.

References ai, COMMUNICATOR_ADDRESS_PREFIX, GNUNET_a2s(), GNUNET_asprintf(), GNUNET_free, GNUNET_NT_scanner_get_type(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_communicator_address_add(), GNUNET_TRANSPORT_communicator_address_remove(), GNUNET_YES, and nt.

Referenced by run().

{
  char *my_addr;
  struct GNUNET_TRANSPORT_AddressIdentifier *ai;

  if (GNUNET_YES == add_remove)
    {
      enum GNUNET_NetworkType nt;

      GNUNET_asprintf(&my_addr,
                      "%s-%s",
                      COMMUNICATOR_ADDRESS_PREFIX,
                      GNUNET_a2s(addr, addrlen));
      nt = GNUNET_NT_scanner_get_type(is, addr, addrlen);
      ai =
        GNUNET_TRANSPORT_communicator_address_add(ch,
                                                  my_addr,
                                                  nt,
                                                  GNUNET_TIME_UNIT_FOREVER_REL);
      GNUNET_free(my_addr);
      *app_ctx = ai;
    }
  else
    {
      ai = *app_ctx;
      GNUNET_TRANSPORT_communicator_address_remove(ai);
      *app_ctx = NULL;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

run()

static void run ( void *  cls, char *const *  args, const char *  cfgfile, const struct GNUNET_CONFIGURATION_Handle *  c  )

static

Setup communicator and launch network interactions.

Parameters

cls	NULL (always)
args	remaining command-line arguments
cfgfile	name of the configuration file used (for saving, can be NULL!)
c	configuration

Definition at line 2063 of file gnunet-communicator-tcp.c.

References _, COMMUNICATOR_ADDRESS_PREFIX, COMMUNICATOR_CONFIG_SECTION, DEFAULT_MAX_QUEUE_LENGTH, do_shutdown(), enc_notify_cb(), GNUNET_a2s(), GNUNET_break, GNUNET_CONFIGURATION_get_value_filename(), GNUNET_CONFIGURATION_get_value_number(), GNUNET_CONTAINER_multipeermap_create(), GNUNET_CRYPTO_eddsa_key_create_from_configuration(), GNUNET_CRYPTO_eddsa_key_get_public(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_ERROR_TYPE_ERROR, GNUNET_free, GNUNET_log, GNUNET_log_config_missing(), GNUNET_log_strerror, GNUNET_log_strerror_file, GNUNET_NAT_register(), GNUNET_NETWORK_get_fd(), GNUNET_NETWORK_socket_bind(), GNUNET_NETWORK_socket_close(), GNUNET_NETWORK_socket_create(), GNUNET_NO, GNUNET_NT_scanner_init(), GNUNET_OK, GNUNET_SCHEDULER_add_read_net(), GNUNET_SCHEDULER_add_shutdown(), GNUNET_SCHEDULER_shutdown(), GNUNET_STATISTICS_create(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TRANSPORT_CC_RELIABLE, GNUNET_TRANSPORT_communicator_connect(), listen_cb(), max_queue_length, mq_init(), my_identity, nat_address_cb(), GNUNET_PeerIdentity::public_key, and tcp_address_to_sockaddr().

Referenced by main().

{
  char *bindto;
  struct sockaddr *in;
  socklen_t in_len;
  struct sockaddr_storage in_sto;
  socklen_t sto_len;

  (void)cls;
  cfg = c;
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_filename(cfg,
                                              COMMUNICATOR_CONFIG_SECTION,
                                              "BINDTO",
                                              &bindto))
    {
      GNUNET_log_config_missing(GNUNET_ERROR_TYPE_ERROR,
                                COMMUNICATOR_CONFIG_SECTION,
                                "BINDTO");
      return;
    }
  if (GNUNET_OK !=
      GNUNET_CONFIGURATION_get_value_number(cfg,
                                            COMMUNICATOR_CONFIG_SECTION,
                                            "MAX_QUEUE_LENGTH",
                                            &max_queue_length))
    max_queue_length = DEFAULT_MAX_QUEUE_LENGTH;

  in = tcp_address_to_sockaddr(bindto, &in_len);
  if (NULL == in)
    {
      GNUNET_log(GNUNET_ERROR_TYPE_ERROR,
                 "Failed to setup TCP socket address with path `%s'\n",
                 bindto);
      GNUNET_free(bindto);
      return;
    }
  listen_sock =
    GNUNET_NETWORK_socket_create(in->sa_family, SOCK_STREAM, IPPROTO_TCP);
  if (NULL == listen_sock)
    {
      GNUNET_log_strerror(GNUNET_ERROR_TYPE_ERROR, "socket");
      GNUNET_free(in);
      GNUNET_free(bindto);
      return;
    }
  if (GNUNET_OK != GNUNET_NETWORK_socket_bind(listen_sock, in, in_len))
    {
      GNUNET_log_strerror_file(GNUNET_ERROR_TYPE_ERROR, "bind", bindto);
      GNUNET_NETWORK_socket_close(listen_sock);
      listen_sock = NULL;
      GNUNET_free(in);
      GNUNET_free(bindto);
      return;
    }
  /* We might have bound to port 0, allowing the OS to figure it out;
     thus, get the real IN-address from the socket */
  sto_len = sizeof(in_sto);
  if (0 != getsockname(GNUNET_NETWORK_get_fd(listen_sock),
                       (struct sockaddr *)&in_sto,
                       &sto_len))
    {
      memcpy(&in_sto, in, in_len);
      sto_len = in_len;
    }
  GNUNET_free(in);
  GNUNET_free(bindto);
  in = (struct sockaddr *)&in_sto;
  in_len = sto_len;
  GNUNET_log(GNUNET_ERROR_TYPE_DEBUG,
             "Bound to `%s'\n",
             GNUNET_a2s((const struct sockaddr *)&in_sto, sto_len));
  stats = GNUNET_STATISTICS_create("C-TCP", cfg);
  GNUNET_SCHEDULER_add_shutdown(&do_shutdown, NULL);
  is = GNUNET_NT_scanner_init();
  my_private_key = GNUNET_CRYPTO_eddsa_key_create_from_configuration(cfg);
  if (NULL == my_private_key)
    {
      GNUNET_log(
        GNUNET_ERROR_TYPE_ERROR,
        _(
          "Transport service is lacking key configuration settings. Exiting.\n"));
      GNUNET_SCHEDULER_shutdown();
      return;
    }
  GNUNET_CRYPTO_eddsa_key_get_public(my_private_key, &my_identity.public_key);
  /* start listening */
  listen_task = GNUNET_SCHEDULER_add_read_net(GNUNET_TIME_UNIT_FOREVER_REL,
                                              listen_sock,
                                              &listen_cb,
                                              NULL);
  queue_map = GNUNET_CONTAINER_multipeermap_create(10, GNUNET_NO);
  ch = GNUNET_TRANSPORT_communicator_connect(cfg,
                                             COMMUNICATOR_CONFIG_SECTION,
                                             COMMUNICATOR_ADDRESS_PREFIX,
                                             GNUNET_TRANSPORT_CC_RELIABLE,
                                             &mq_init,
                                             NULL,
                                             &enc_notify_cb,
                                             NULL);
  if (NULL == ch)
    {
      GNUNET_break(0);
      GNUNET_SCHEDULER_shutdown();
      return;
    }
  nat = GNUNET_NAT_register(cfg,
                            COMMUNICATOR_CONFIG_SECTION,
                            IPPROTO_TCP,
                            1 /* one address */,
                            (const struct sockaddr **)&in,
                            &in_len,
                            &nat_address_cb,
                            NULL /* FIXME: support reversal: #5529 */,
                            NULL /* closure */);
}

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *const *	argv
	)

The main function for the UNIX communicator.

Parameters

argc	number of arguments from the command line
argv	command line arguments

Returns

0 ok, 1 on error

Definition at line 2192 of file gnunet-communicator-tcp.c.

References _, GNUNET_free, GNUNET_GETOPT_OPTION_END, GNUNET_OK, GNUNET_PROGRAM_run(), GNUNET_STRINGS_get_utf8_args(), ret, and run().

{
  static const struct GNUNET_GETOPT_CommandLineOption options[] = {
    GNUNET_GETOPT_OPTION_END
  };
  int ret;

  if (GNUNET_OK != GNUNET_STRINGS_get_utf8_args(argc, argv, &argc, &argv))
    return 2;

  ret = (GNUNET_OK == GNUNET_PROGRAM_run(argc,
                                         argv,
                                         "gnunet-communicator-tcp",
                                         _("GNUnet TCP communicator"),
                                         options,
                                         &run,
                                         NULL))
        ? 0
        : 1;
  GNUNET_free((void *)argv);
  return ret;
}

Here is the call graph for this function:

Variable Documentation

listen_task

struct GNUNET_SCHEDULER_Task* listen_task

static

ID of listen task.

Definition at line 485 of file gnunet-communicator-tcp.c.

max_queue_length

unsigned long long max_queue_length

static

Maximum queue length before we stop reading towards the transport service.

Definition at line 490 of file gnunet-communicator-tcp.c.

Referenced by run().

stats

struct GNUNET_STATISTICS_Handle* stats

static

For logging statistics.

Definition at line 495 of file gnunet-communicator-tcp.c.

ch

struct GNUNET_TRANSPORT_CommunicatorHandle* ch

static

Our environment.

Definition at line 500 of file gnunet-communicator-tcp.c.

queue_map

struct GNUNET_CONTAINER_MultiPeerMap* queue_map

static

Queues (map from peer identity to struct Queue)

Definition at line 505 of file gnunet-communicator-tcp.c.

listen_sock

struct GNUNET_NETWORK_Handle* listen_sock

static

Listen socket.

Definition at line 510 of file gnunet-communicator-tcp.c.

my_identity

struct GNUNET_PeerIdentity my_identity

static

Our public key.

Definition at line 515 of file gnunet-communicator-tcp.c.

Referenced by decrypt_and_check_tc(), do_rekey(), inject_rekey(), run(), setup_in_cipher(), and transmit_kx().

my_private_key

struct GNUNET_CRYPTO_EddsaPrivateKey* my_private_key

static

Our private key.

Definition at line 520 of file gnunet-communicator-tcp.c.

cfg

const struct GNUNET_CONFIGURATION_Handle* cfg

static

Our configuration.

Definition at line 525 of file gnunet-communicator-tcp.c.

is

struct GNUNET_NT_InterfaceScanner* is

static

Network scanner to determine network types.

Definition at line 530 of file gnunet-communicator-tcp.c.

Referenced by check_backchannel_encapsulation(), check_communicator_backchannel(), get_addresses(), GNUNET_NT_scanner_init(), handle_communicator_backchannel(), and interface_proc().

nat

struct GNUNET_NAT_Handle* nat

static

Connection to NAT service.

Definition at line 535 of file gnunet-communicator-tcp.c.

proto_head

struct ProtoQueue* proto_head

static

Protoqueues DLL head.

Definition at line 540 of file gnunet-communicator-tcp.c.

proto_tail

struct ProtoQueue* proto_tail

static

Protoqueues DLL tail.

Definition at line 545 of file gnunet-communicator-tcp.c.