fragmentation.c File Reference

library to help fragment messages More...

#include "platform.h"
#include "gnunet_protocols.h"
#include "fragmentation.h"

Include dependency graph for fragmentation.c:

Go to the source code of this file.

Data Structures
struct	GNUNET_FRAGMENT_Context
	Fragmentation context. More...

Macros
#define	MIN_ACK_DELAY
	Absolute minimum delay we impose between sending and expecting ACK to arrive. More...

Functions
const char *	GNUNET_FRAGMENT_print_ack (const struct GNUNET_MessageHeader *ack)
	Convert an ACK message to a printable format suitable for logging. More...
static void	transmit_next (void *cls)
	Transmit the next fragment to the other peer. More...
struct GNUNET_FRAGMENT_Context *	GNUNET_FRAGMENT_context_create (struct GNUNET_STATISTICS_Handle *stats, uint16_t mtu, struct GNUNET_BANDWIDTH_Tracker *tracker, struct GNUNET_TIME_Relative msg_delay, struct GNUNET_TIME_Relative ack_delay, const struct GNUNET_MessageHeader *msg, GNUNET_FRAGMENT_MessageProcessor proc, void *proc_cls)
	Create a fragmentation context for the given message. More...
void	GNUNET_FRAGMENT_context_transmission_done (struct GNUNET_FRAGMENT_Context *fc)
	Continuation to call from the 'proc' function after the fragment has been transmitted (and hence the next fragment can now be given to proc). More...
int	GNUNET_FRAGMENT_process_ack (struct GNUNET_FRAGMENT_Context *fc, const struct GNUNET_MessageHeader *msg)
	Process an acknowledgement message we got from the other side (to control re-transmits). More...
void	GNUNET_FRAGMENT_context_destroy (struct GNUNET_FRAGMENT_Context *fc, struct GNUNET_TIME_Relative *msg_delay, struct GNUNET_TIME_Relative *ack_delay)
	Destroy the given fragmentation context (stop calling 'proc', free resources). More...

Detailed Description

library to help fragment messages

Author

Christian Grothoff

Definition in file fragmentation.c.

Macro Definition Documentation

MIN_ACK_DELAY

#define MIN_ACK_DELAY

Value:

    GNUNET_TIME_relative_multiply ( \
    GNUNET_TIME_UNIT_MILLISECONDS, 1)

Absolute minimum delay we impose between sending and expecting ACK to arrive.

Definition at line 33 of file fragmentation.c.

Function Documentation

transmit_next()

static void transmit_next ( void *  cls )

static

Transmit the next fragment to the other peer.

Parameters

cls	the struct GNUNET_FRAGMENT_Context

Definition at line 171 of file fragmentation.c.

{
  struct GNUNET_FRAGMENT_Context *fc = cls;
  char msg[fc->mtu];
  const char *mbuf;
  struct FragmentHeader *fh;
  struct GNUNET_TIME_Relative delay;
  unsigned int bit;
  size_t size;
  size_t fsize;
  int wrap;
 
  fc->task = NULL;
  GNUNET_assert (GNUNET_NO == fc->proc_busy);
  if (0 == fc->acks)
    return;                     /* all done */
  /* calculate delay */
  wrap = 0;
  while (0 == (fc->acks & (1LLU << fc->next_transmission)))
  {
    fc->next_transmission = (fc->next_transmission + 1) % 64;
    wrap |= (0 == fc->next_transmission);
  }
  bit = fc->next_transmission;
  size = ntohs (fc->msg->size);
  if (bit == size / (fc->mtu - sizeof(struct FragmentHeader)))
    fsize =
      (size % (fc->mtu - sizeof(struct FragmentHeader)))
      + sizeof(struct FragmentHeader);
  else
    fsize = fc->mtu;
  if (NULL != fc->tracker)
    delay = GNUNET_BANDWIDTH_tracker_get_delay (fc->tracker,
                                                fsize);
  else
    delay = GNUNET_TIME_UNIT_ZERO;
  if (delay.rel_value_us > 0)
  {
    GNUNET_log (GNUNET_ERROR_TYPE_DEBUG,
                "Fragmentation logic delays transmission of next fragment by %s\n",
                GNUNET_STRINGS_relative_time_to_string (delay,
                                                        GNUNET_YES));
    fc->task = GNUNET_SCHEDULER_add_delayed (delay,
                                             &transmit_next,
                                             fc);
    return;
  }
  fc->next_transmission = (fc->next_transmission + 1) % 64;
  wrap |= (0 == fc->next_transmission);
  while (0 == (fc->acks & (1LLU << fc->next_transmission)))
  {
    fc->next_transmission = (fc->next_transmission + 1) % 64;
    wrap |= (0 == fc->next_transmission);
  }
 
  /* assemble fragmentation message */
  mbuf = (const char *) &fc[1];
  fh = (struct FragmentHeader *) msg;
  fh->header.size = htons (fsize);
  fh->header.type = htons (GNUNET_MESSAGE_TYPE_FRAGMENT);
  fh->fragment_id = htonl (fc->fragment_id);
  fh->total_size = fc->msg->size;       /* already in big-endian */
  fh->offset = htons ((fc->mtu - sizeof(struct FragmentHeader)) * bit);
  GNUNET_memcpy (&fh[1], &mbuf[bit * (fc->mtu - sizeof(struct FragmentHeader))],
                 fsize - sizeof(struct FragmentHeader));
  if (NULL != fc->tracker)
    GNUNET_BANDWIDTH_tracker_consume (fc->tracker, fsize);
  GNUNET_STATISTICS_update (fc->stats,
                            _ ("# fragments transmitted"),
                            1,
                            GNUNET_NO);
  if (0 != fc->last_round.abs_value_us)
    GNUNET_STATISTICS_update (fc->stats,
                              _ ("# fragments retransmitted"),
                              1,
                              GNUNET_NO);
 
  /* select next message to calculate delay */
  bit = fc->next_transmission;
  size = ntohs (fc->msg->size);
  if (bit == size / (fc->mtu - sizeof(struct FragmentHeader)))
    fsize = size % (fc->mtu - sizeof(struct FragmentHeader));
  else
    fsize = fc->mtu;
  if (NULL != fc->tracker)
    delay = GNUNET_BANDWIDTH_tracker_get_delay (fc->tracker,
                                                fsize);
  else
    delay = GNUNET_TIME_UNIT_ZERO;
  if (fc->num_rounds < 64)
    delay = GNUNET_TIME_relative_max (delay,
                                      GNUNET_TIME_relative_saturating_multiply
                                        (fc->msg_delay,
                                        (1ULL << fc->num_rounds)));
  else
    delay = GNUNET_TIME_UNIT_FOREVER_REL;
  if (wrap)
  {
    /* full round transmitted wait 2x delay for ACK before going again */
    fc->num_rounds++;
    delay = GNUNET_TIME_relative_saturating_multiply (fc->ack_delay, 2);
    /* never use zero, need some time for ACK always */
    delay = GNUNET_TIME_relative_max (MIN_ACK_DELAY, delay);
    fc->wack = GNUNET_YES;
    fc->last_round = GNUNET_TIME_absolute_get ();
    GNUNET_STATISTICS_update (fc->stats,
                              _ ("# fragments wrap arounds"),
                              1,
                              GNUNET_NO);
  }
  fc->proc_busy = GNUNET_YES;
  fc->delay_until = GNUNET_TIME_relative_to_absolute (delay);
  fc->num_transmissions++;
  fc->proc (fc->proc_cls,
            &fh->header);
}

References _, GNUNET_TIME_Absolute::abs_value_us, GNUNET_FRAGMENT_Context::ack_delay, GNUNET_FRAGMENT_Context::acks, delay, GNUNET_FRAGMENT_Context::delay_until, fh, GNUNET_FRAGMENT_Context::fragment_id, GNUNET_assert, GNUNET_BANDWIDTH_tracker_consume(), GNUNET_BANDWIDTH_tracker_get_delay(), GNUNET_ERROR_TYPE_DEBUG, GNUNET_log, GNUNET_memcpy, GNUNET_MESSAGE_TYPE_FRAGMENT, GNUNET_NO, GNUNET_SCHEDULER_add_delayed(), GNUNET_STATISTICS_update(), GNUNET_STRINGS_relative_time_to_string(), GNUNET_TIME_absolute_get(), GNUNET_TIME_relative_max(), GNUNET_TIME_relative_saturating_multiply(), GNUNET_TIME_relative_to_absolute(), GNUNET_TIME_UNIT_FOREVER_REL, GNUNET_TIME_UNIT_ZERO, GNUNET_YES, GNUNET_FRAGMENT_Context::last_round, MIN_ACK_DELAY, msg, GNUNET_FRAGMENT_Context::msg, GNUNET_FRAGMENT_Context::msg_delay, GNUNET_FRAGMENT_Context::mtu, GNUNET_FRAGMENT_Context::next_transmission, GNUNET_FRAGMENT_Context::num_rounds, GNUNET_FRAGMENT_Context::num_transmissions, GNUNET_FRAGMENT_Context::proc, GNUNET_FRAGMENT_Context::proc_busy, GNUNET_FRAGMENT_Context::proc_cls, GNUNET_TIME_Relative::rel_value_us, GNUNET_MessageHeader::size, size, GNUNET_FRAGMENT_Context::stats, GNUNET_FRAGMENT_Context::task, GNUNET_FRAGMENT_Context::tracker, and GNUNET_FRAGMENT_Context::wack.

Referenced by GNUNET_FRAGMENT_context_create(), GNUNET_FRAGMENT_context_transmission_done(), and GNUNET_FRAGMENT_process_ack().

Here is the call graph for this function:

Here is the caller graph for this function: