Fragmentation library

Library to help fragment messages. More...

Collaboration diagram for Fragmentation library:

Typedefs
typedef void(*	GNUNET_FRAGMENT_MessageProcessor) (void *cls, const struct GNUNET_MessageHeader *msg)
	Function that is called with messages created by the fragmentation module. More...
typedef void(*	GNUNET_DEFRAGMENT_AckProcessor) (void *cls, uint32_t id, const struct GNUNET_MessageHeader *msg)
	Function that is called with acknowledgement messages created by the fragmentation module. More...

Functions
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...
const char *	GNUNET_FRAGMENT_print_ack (const struct GNUNET_MessageHeader *ack)
	Convert an ACK message to a printable format suitable for logging. More...
struct GNUNET_DEFRAGMENT_Context *	GNUNET_DEFRAGMENT_context_create (struct GNUNET_STATISTICS_Handle *stats, uint16_t mtu, unsigned int num_msgs, void *cls, GNUNET_FRAGMENT_MessageProcessor proc, GNUNET_DEFRAGMENT_AckProcessor ackp)
	Create a defragmentation context. More...
void	GNUNET_DEFRAGMENT_context_destroy (struct GNUNET_DEFRAGMENT_Context *dc)
	Destroy the given defragmentation context. More...
int	GNUNET_DEFRAGMENT_process_fragment (struct GNUNET_DEFRAGMENT_Context *dc, const struct GNUNET_MessageHeader *msg)
	We have received a fragment. More...

Detailed Description

Library to help fragment messages.

Todo:

Consider additional flow-control for sending from fragmentation based on continuations.

Typedef Documentation

GNUNET_FRAGMENT_MessageProcessor

typedef void(* GNUNET_FRAGMENT_MessageProcessor) (void *cls, const struct GNUNET_MessageHeader *msg)

Function that is called with messages created by the fragmentation module.

In the case of the 'proc' callback of the GNUNET_FRAGMENT_context_create() function, this function must eventually call GNUNET_FRAGMENT_context_transmission_done().

Parameters

cls	closure
msg	the message that was created

Definition at line 68 of file gnunet_fragmentation_lib.h.

GNUNET_DEFRAGMENT_AckProcessor

typedef void(* GNUNET_DEFRAGMENT_AckProcessor) (void *cls, uint32_t id, const struct GNUNET_MessageHeader *msg)

Function that is called with acknowledgement messages created by the fragmentation module.

Acknowledgements are cumulative, so it is OK to only transmit the 'latest' ack message for the same message ID.

Parameters

cls	closure
id	unique message ID (modulo collisions)
msg	the message that was created

Definition at line 173 of file gnunet_fragmentation_lib.h.

Function Documentation

GNUNET_FRAGMENT_context_create()

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.

Fragments the message into fragments of size mtu or less. Calls proc on each un-acknowledged fragment, using both the expected msg_delay between messages and acknowledgements and the given tracker to guide the frequency of calls to proc.

Parameters

stats	statistics context
mtu	the maximum message size for each fragment
tracker	bandwidth tracker to use for flow control (can be NULL)
msg_delay	initial delay to insert between fragment transmissions based on previous messages
ack_delay	expected delay between fragment transmission and ACK based on previous messages
msg	the message to fragment
proc	function to call for each fragment to transmit
proc_cls	closure for proc

Returns

the fragmentation context

Fragments the message into fragments of size mtu or less. Calls proc on each un-acknowledged fragment, using both the expected msg_delay between messages and acknowledgements and the given tracker to guide the frequency of calls to proc.

Parameters

stats	statistics context
mtu	the maximum message size for each fragment
tracker	bandwidth tracker to use for flow control (can be NULL)
msg_delay	initial delay to insert between fragment transmissions based on previous messages
ack_delay	expected delay between fragment transmission and ACK based on previous messages
msg	the message to fragment
proc	function to call for each fragment to transmit
proc_cls	closure for proc

Returns

the fragmentation context

Definition at line 310 of file fragmentation.c.

{
  struct GNUNET_FRAGMENT_Context *fc;
  size_t size;
  uint64_t bits;
 
  GNUNET_STATISTICS_update (stats,
                            _ ("# messages fragmented"),
                            1,
                            GNUNET_NO);
  GNUNET_assert (mtu >= 1024 + sizeof(struct FragmentHeader));
  size = ntohs (msg->size);
  GNUNET_STATISTICS_update (stats,
                            _ ("# total size of fragmented messages"),
                            size, GNUNET_NO);
  GNUNET_assert (size >= sizeof(struct GNUNET_MessageHeader));
  fc = GNUNET_malloc (sizeof(struct GNUNET_FRAGMENT_Context) + size);
  fc->stats = stats;
  fc->mtu = mtu;
  fc->tracker = tracker;
  fc->ack_delay = ack_delay;
  fc->msg_delay = msg_delay;
  fc->msg = (const struct GNUNET_MessageHeader *) &fc[1];
  fc->proc = proc;
  fc->proc_cls = proc_cls;
  fc->fragment_id =
    GNUNET_CRYPTO_random_u32 (GNUNET_CRYPTO_QUALITY_WEAK,
                              UINT32_MAX);
  GNUNET_memcpy (&fc[1], msg, size);
  bits =
    (size + mtu - sizeof(struct FragmentHeader) - 1) / (mtu
                                                        - sizeof(struct
                                                                 FragmentHeader));
  GNUNET_assert (bits <= 64);
  if (bits == 64)
    fc->acks_mask = UINT64_MAX; /* set all 64 bit */
  else
    fc->acks_mask = (1LLU << bits) - 1;  /* set lowest 'bits' bit */
  fc->acks = fc->acks_mask;
  fc->task = GNUNET_SCHEDULER_add_now (&transmit_next, fc);
  return fc;
}

References _, GNUNET_FRAGMENT_Context::ack_delay, GNUNET_FRAGMENT_Context::acks, GNUNET_FRAGMENT_Context::acks_mask, GNUNET_FRAGMENT_Context::fragment_id, GNUNET_assert, GNUNET_CRYPTO_QUALITY_WEAK, GNUNET_CRYPTO_random_u32(), GNUNET_malloc, GNUNET_memcpy, GNUNET_NO, GNUNET_SCHEDULER_add_now(), GNUNET_STATISTICS_update(), msg, GNUNET_FRAGMENT_Context::msg, GNUNET_FRAGMENT_Context::msg_delay, GNUNET_FRAGMENT_Context::mtu, GNUNET_FRAGMENT_Context::proc, GNUNET_FRAGMENT_Context::proc_cls, GNUNET_MessageHeader::size, size, stats, GNUNET_FRAGMENT_Context::stats, GNUNET_FRAGMENT_Context::task, GNUNET_FRAGMENT_Context::tracker, and transmit_next().

Referenced by handle_helper_message(), send_with_fragmentation(), and udp_plugin_send().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FRAGMENT_context_transmission_done()

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

Parameters

fc	fragmentation context

Definition at line 369 of file fragmentation.c.

{
  GNUNET_assert (fc->proc_busy == GNUNET_YES);
  fc->proc_busy = GNUNET_NO;
  GNUNET_assert (fc->task == NULL);
  fc->task =
    GNUNET_SCHEDULER_add_at (fc->delay_until,
                             &transmit_next,
                             fc);
}

References GNUNET_FRAGMENT_Context::delay_until, GNUNET_assert, GNUNET_NO, GNUNET_SCHEDULER_add_at(), GNUNET_YES, GNUNET_FRAGMENT_Context::proc_busy, GNUNET_FRAGMENT_Context::task, and transmit_next().

Referenced by fragment_transmission_done(), qc_fragment_sent(), and transmit_fragment().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FRAGMENT_process_ack()

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

Parameters

fc	fragmentation context
msg	acknowledgement message we received

Returns

GNUNET_OK if this ack completes the work of the 'fc' (all fragments have been received); GNUNET_NO if more messages are pending GNUNET_SYSERR if this ack is not valid for this fc

Definition at line 393 of file fragmentation.c.

{
  const struct FragmentAcknowledgement *fa;
  uint64_t abits;
  struct GNUNET_TIME_Relative ndelay;
  unsigned int ack_cnt;
  unsigned int snd_cnt;
  unsigned int i;
 
  if (sizeof(struct FragmentAcknowledgement) != ntohs (msg->size))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  fa = (const struct FragmentAcknowledgement *) msg;
  if (ntohl (fa->fragment_id) != fc->fragment_id)
    return GNUNET_SYSERR;       /* not our ACK */
  abits = GNUNET_ntohll (fa->bits);
  if ((GNUNET_YES == fc->wack) &&
      (0 != fc->num_transmissions))
  {
    /* normal ACK, can update running average of delay... */
    fc->wack = GNUNET_NO;
    ndelay = GNUNET_TIME_absolute_get_duration (fc->last_round);
    fc->ack_delay.rel_value_us =
      (ndelay.rel_value_us / fc->num_transmissions + 3
       * fc->ack_delay.rel_value_us) / 4;
    /* calculate ratio msg sent vs. msg acked */
    ack_cnt = 0;
    snd_cnt = 0;
    for (i = 0; i < 64; i++)
    {
      if (1 == (fc->acks_mask & (1ULL << i)))
      {
        snd_cnt++;
        if (0 == (abits & (1ULL << i)))
          ack_cnt++;
      }
    }
    if (0 == ack_cnt)
    {
      /* complete loss */
      fc->msg_delay = GNUNET_TIME_relative_saturating_multiply (fc->msg_delay,
                                                                snd_cnt);
    }
    else if (snd_cnt > ack_cnt)
    {
      /* some loss, slow down proportionally */
      fc->msg_delay.rel_value_us = ((fc->msg_delay.rel_value_us * ack_cnt)
                                    / snd_cnt);
    }
    else if (snd_cnt == ack_cnt)
    {
      fc->msg_delay.rel_value_us =
        (ndelay.rel_value_us / fc->num_transmissions + 3
         * fc->msg_delay.rel_value_us) / 5;
    }
    fc->num_transmissions = 0;
    fc->msg_delay = GNUNET_TIME_relative_min (fc->msg_delay,
                                              GNUNET_TIME_UNIT_SECONDS);
    fc->ack_delay = GNUNET_TIME_relative_min (fc->ack_delay,
                                              GNUNET_TIME_UNIT_SECONDS);
  }
  GNUNET_STATISTICS_update (fc->stats,
                            _ ("# fragment acknowledgements received"),
                            1,
                            GNUNET_NO);
  if (abits != (fc->acks & abits))
  {
    /* ID collision or message reordering, count! This should be rare! */
    GNUNET_STATISTICS_update (fc->stats,
                              _ ("# bits removed from fragmentation ACKs"), 1,
                              GNUNET_NO);
  }
  fc->acks = abits & fc->acks_mask;
  if (0 != fc->acks)
  {
    /* more to transmit, do so right now (if tracker permits...) */
    if (fc->task != NULL)
    {
      /* schedule next transmission now, no point in waiting... */
      GNUNET_SCHEDULER_cancel (fc->task);
      fc->task = GNUNET_SCHEDULER_add_now (&transmit_next, fc);
    }
    else
    {
      /* only case where there is no task should be if we're waiting
       * for the right to transmit again (proc_busy set to YES) */
      GNUNET_assert (GNUNET_YES == fc->proc_busy);
    }
    return GNUNET_NO;
  }
 
  /* all done */
  GNUNET_STATISTICS_update (fc->stats,
                            _ ("# fragmentation transmissions completed"),
                            1,
                            GNUNET_NO);
  if (NULL != fc->task)
  {
    GNUNET_SCHEDULER_cancel (fc->task);
    fc->task = NULL;
  }
  return GNUNET_OK;
}

References _, GNUNET_FRAGMENT_Context::ack_delay, GNUNET_FRAGMENT_Context::acks, GNUNET_FRAGMENT_Context::acks_mask, FragmentAcknowledgement::bits, GNUNET_FRAGMENT_Context::fragment_id, FragmentAcknowledgement::fragment_id, GNUNET_assert, GNUNET_break_op, GNUNET_NO, GNUNET_ntohll(), GNUNET_OK, GNUNET_SCHEDULER_add_now(), GNUNET_SCHEDULER_cancel(), GNUNET_STATISTICS_update(), GNUNET_SYSERR, GNUNET_TIME_absolute_get_duration(), GNUNET_TIME_relative_min(), GNUNET_TIME_relative_saturating_multiply(), GNUNET_TIME_UNIT_SECONDS, GNUNET_YES, GNUNET_FRAGMENT_Context::last_round, msg, GNUNET_FRAGMENT_Context::msg_delay, GNUNET_FRAGMENT_Context::num_transmissions, GNUNET_FRAGMENT_Context::proc_busy, GNUNET_TIME_Relative::rel_value_us, GNUNET_MessageHeader::size, GNUNET_FRAGMENT_Context::stats, GNUNET_FRAGMENT_Context::task, transmit_next(), and GNUNET_FRAGMENT_Context::wack.

Referenced by process_data(), and read_process_ack().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FRAGMENT_context_destroy()

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

Parameters

fc	fragmentation context
msg_delay	where to store average delay between individual message transmissions the last message (OUT only)
ack_delay	where to store average delay between transmission and ACK for the last message, set to FOREVER if the message was not fully transmitted (OUT only)

Definition at line 512 of file fragmentation.c.

{
  if (fc->task != NULL)
    GNUNET_SCHEDULER_cancel (fc->task);
  if (NULL != ack_delay)
    *ack_delay = fc->ack_delay;
  if (NULL != msg_delay)
    *msg_delay = GNUNET_TIME_relative_saturating_multiply (fc->msg_delay,
                                                           fc->num_rounds);
  GNUNET_free (fc);
}

References GNUNET_FRAGMENT_Context::ack_delay, GNUNET_free, GNUNET_SCHEDULER_cancel(), GNUNET_TIME_relative_saturating_multiply(), GNUNET_FRAGMENT_Context::msg_delay, GNUNET_FRAGMENT_Context::num_rounds, and GNUNET_FRAGMENT_Context::task.

Referenced by fragmented_message_done(), free_fragment_message(), and free_session().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_FRAGMENT_print_ack()

const char* GNUNET_FRAGMENT_print_ack

(

const struct GNUNET_MessageHeader *

ack

)

Convert an ACK message to a printable format suitable for logging.

Parameters

ack	message to print

Returns

ack in human-readable format

Definition at line 147 of file fragmentation.c.

{
  static char buf[128];
  const struct FragmentAcknowledgement *fa;
 
  if (sizeof(struct FragmentAcknowledgement) !=
      htons (ack->size))
    return "<malformed ack>";
  fa = (const struct FragmentAcknowledgement *) ack;
  GNUNET_snprintf (buf,
                   sizeof(buf),
                   "%u-%llX",
                   ntohl (fa->fragment_id),
                   (unsigned long long) GNUNET_ntohll (fa->bits));
  return buf;
}

References FragmentAcknowledgement::bits, buf, FragmentAcknowledgement::fragment_id, GNUNET_ntohll(), GNUNET_snprintf(), and GNUNET_MessageHeader::size.

Referenced by read_process_ack().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DEFRAGMENT_context_create()

struct GNUNET_DEFRAGMENT_Context* GNUNET_DEFRAGMENT_context_create	(	struct GNUNET_STATISTICS_Handle *	stats,
		uint16_t	mtu,
		unsigned int	num_msgs,
		void *	cls,
		GNUNET_FRAGMENT_MessageProcessor	proc,
		GNUNET_DEFRAGMENT_AckProcessor	ackp
	)

Create a defragmentation context.

Parameters

stats	statistics context
mtu	the maximum message size for each fragment
num_msgs	how many fragmented messages to we defragment at most at the same time?
cls	closure for proc and ackp
proc	function to call with defragmented messages
ackp	function to call with acknowledgements (to send back to the other side)

Returns

the defragmentation context

Definition at line 208 of file defragmentation.c.

{
  struct GNUNET_DEFRAGMENT_Context *dc;
 
  dc = GNUNET_new (struct GNUNET_DEFRAGMENT_Context);
  dc->stats = stats;
  dc->cls = cls;
  dc->proc = proc;
  dc->ackp = ackp;
  dc->num_msgs = num_msgs;
  dc->mtu = mtu;
  dc->latency = GNUNET_TIME_UNIT_SECONDS;       /* start with likely overestimate */
  return dc;
}

References GNUNET_DEFRAGMENT_Context::ackp, GNUNET_DEFRAGMENT_Context::cls, dc, GNUNET_new, GNUNET_TIME_UNIT_SECONDS, GNUNET_DEFRAGMENT_Context::mtu, GNUNET_DEFRAGMENT_Context::num_msgs, GNUNET_DEFRAGMENT_Context::proc, and stats.

Referenced by create_macendpoint(), and read_process_fragment().

Here is the caller graph for this function:

GNUNET_DEFRAGMENT_context_destroy()

void GNUNET_DEFRAGMENT_context_destroy

(

struct GNUNET_DEFRAGMENT_Context *

dc

)

Destroy the given defragmentation context.

Parameters

dc	defragmentation context

Definition at line 234 of file defragmentation.c.

{
  struct MessageContext *mc;
 
  while (NULL != (mc = dc->head))
  {
    GNUNET_CONTAINER_DLL_remove (dc->head, dc->tail, mc);
    dc->list_size--;
    if (NULL != mc->ack_task)
    {
      GNUNET_SCHEDULER_cancel (mc->ack_task);
      mc->ack_task = NULL;
    }
    GNUNET_free (mc);
  }
  GNUNET_assert (0 == dc->list_size);
  GNUNET_free (dc);
}

References dc, GNUNET_assert, GNUNET_CONTAINER_DLL_remove, GNUNET_free, GNUNET_SCHEDULER_cancel(), and mc.

Referenced by ack_proc(), free_macendpoint(), heap_cleanup_iterator(), read_process_fragment(), and udp_disconnect_session().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_DEFRAGMENT_process_fragment()

int GNUNET_DEFRAGMENT_process_fragment	(	struct GNUNET_DEFRAGMENT_Context *	dc,
		const struct GNUNET_MessageHeader *	msg
	)

We have received a fragment.

Process it.

Parameters

dc	the context
msg	the message that was received

Returns

GNUNET_OK on success, GNUNET_NO if this was a duplicate, GNUNET_SYSERR on error

Definition at line 416 of file defragmentation.c.

{
  struct MessageContext *mc;
  const struct FragmentHeader *fh;
  uint16_t msize;
  uint16_t foff;
  uint32_t fid;
  char *mbuf;
  unsigned int bit;
  struct GNUNET_TIME_Absolute now;
  struct GNUNET_TIME_Relative delay;
  unsigned int bc;
  unsigned int b;
  unsigned int n;
  unsigned int num_fragments;
  int duplicate;
  int last;
 
  if (ntohs (msg->size) < sizeof(struct FragmentHeader))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (ntohs (msg->size) > dc->mtu)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  fh = (const struct FragmentHeader *) msg;
  msize = ntohs (fh->total_size);
  if (msize < sizeof(struct GNUNET_MessageHeader))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  fid = ntohl (fh->fragment_id);
  foff = ntohs (fh->offset);
  if (foff >= msize)
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if (0 != (foff % (dc->mtu - sizeof(struct FragmentHeader))))
  {
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  GNUNET_STATISTICS_update (dc->stats,
                            _ ("# fragments received"),
                            1,
                            GNUNET_NO);
  num_fragments = (ntohs (msg->size) + dc->mtu - sizeof(struct FragmentHeader)
                   - 1) / (dc->mtu - sizeof(struct FragmentHeader));
  last = 0;
  for (mc = dc->head; NULL != mc; mc = mc->next)
    if (mc->fragment_id > fid)
      last++;
 
  mc = dc->head;
  while ((NULL != mc) && (fid != mc->fragment_id))
    mc = mc->next;
  bit = foff / (dc->mtu - sizeof(struct FragmentHeader));
  if (bit * (dc->mtu - sizeof(struct FragmentHeader)) + ntohs (msg->size)
      - sizeof(struct FragmentHeader) > msize)
  {
    /* payload extends past total message size */
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  if ((NULL != mc) && (msize != mc->total_size))
  {
    /* inconsistent message size */
    GNUNET_break_op (0);
    return GNUNET_SYSERR;
  }
  now = GNUNET_TIME_absolute_get ();
  if (NULL == mc)
  {
    mc = GNUNET_malloc (sizeof(struct MessageContext) + msize);
    mc->msg = (const struct GNUNET_MessageHeader *) &mc[1];
    mc->dc = dc;
    mc->total_size = msize;
    mc->fragment_id = fid;
    mc->last_update = now;
    n = (msize + dc->mtu - sizeof(struct FragmentHeader) - 1) / (dc->mtu
                                                                 - sizeof(struct
                                                                          FragmentHeader));
    if (n == 64)
      mc->bits = UINT64_MAX;    /* set all 64 bit */
    else
      mc->bits = (1LLU << n) - 1;        /* set lowest 'bits' bit */
    if (dc->list_size >= dc->num_msgs)
      discard_oldest_mc (dc);
    GNUNET_CONTAINER_DLL_insert (dc->head,
                                 dc->tail,
                                 mc);
    dc->list_size++;
  }
 
  /* copy data to 'mc' */
  if (0 != (mc->bits & (1LLU << bit)))
  {
    mc->bits -= 1LLU << bit;
    mbuf = (char *) &mc[1];
    GNUNET_memcpy (&mbuf[bit * (dc->mtu - sizeof(struct FragmentHeader))],
                   &fh[1],
                   ntohs (msg->size) - sizeof(struct FragmentHeader));
    mc->last_update = now;
    if (bit < mc->last_bit)
      mc->frag_times_start_offset = mc->frag_times_write_offset;
    mc->last_bit = bit;
    mc->frag_times[mc->frag_times_write_offset].time = now;
    mc->frag_times[mc->frag_times_write_offset].bit = bit;
    mc->frag_times_write_offset++;
    duplicate = GNUNET_NO;
  }
  else
  {
    duplicate = GNUNET_YES;
    GNUNET_STATISTICS_update (dc->stats,
                              _ ("# duplicate fragments received"),
                              1,
                              GNUNET_NO);
  }
 
  /* count number of missing fragments after the current one */
  bc = 0;
  for (b = bit; b < 64; b++)
    if (0 != (mc->bits & (1LLU << b)))
      bc++;
    else
      bc = 0;
 
  /* notify about complete message */
  if ((GNUNET_NO == duplicate) &&
      (0 == mc->bits))
  {
    GNUNET_STATISTICS_update (dc->stats,
                              _ ("# messages defragmented"),
                              1,
                              GNUNET_NO);
    /* message complete, notify! */
    dc->proc (dc->cls, mc->msg);
  }
  /* send ACK */
  if (mc->frag_times_write_offset - mc->frag_times_start_offset > 1)
  {
    dc->latency = estimate_latency (mc);
  }
  delay = GNUNET_TIME_relative_saturating_multiply (dc->latency,
                                                    bc + 1);
  if ((last + fid == num_fragments) ||
      (0 == mc->bits) ||
      (GNUNET_YES == duplicate))
  {
    /* message complete or duplicate or last missing fragment in
       linear sequence; ACK now! */
    delay = GNUNET_TIME_UNIT_ZERO;
  }
  if (NULL != mc->ack_task)
    GNUNET_SCHEDULER_cancel (mc->ack_task);
  mc->ack_task = GNUNET_SCHEDULER_add_delayed (delay,
                                               &send_ack,
                                               mc);
  if (GNUNET_YES == duplicate)
  {
    mc->last_duplicate = GNUNET_YES;
    return GNUNET_NO;
  }
  return GNUNET_YES;
}

Referenced by process_data(), and read_process_fragment().

Here is the caller graph for this function: