tcp_server_mst_legacy.c File Reference

#include "platform.h"
#include "gnunet_util_lib.h"

Include dependency graph for tcp_server_mst_legacy.c:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	GNUNET_SERVER_MessageStreamTokenizer
	Handle to a message stream tokenizer. More...

Macros
#define	ALIGN_FACTOR   8

Functions
struct GNUNET_SERVER_MessageStreamTokenizer *	GNUNET_SERVER_mst_create (GNUNET_SERVER_MessageTokenizerCallback cb, void *cb_cls)
	Create a message stream tokenizer. More...
int	GNUNET_SERVER_mst_receive (struct GNUNET_SERVER_MessageStreamTokenizer *mst, void *client_identity, const char *buf, size_t size, int purge, int one_shot)
	Add incoming data to the receive buffer and call the callback for all complete messages. More...
void	GNUNET_SERVER_mst_destroy (struct GNUNET_SERVER_MessageStreamTokenizer *mst)
	Destroys a tokenizer. More...

Macro Definition Documentation

ALIGN_FACTOR

#define ALIGN_FACTOR   8

Definition at line 34 of file tcp_server_mst_legacy.c.

Function Documentation

GNUNET_SERVER_mst_create()

struct GNUNET_SERVER_MessageStreamTokenizer* GNUNET_SERVER_mst_create	(	GNUNET_SERVER_MessageTokenizerCallback	cb,
		void *	cb_cls
	)

Create a message stream tokenizer.

Parameters

cb	function to call on completed messages
cb_cls	closure for cb

Returns

handle to tokenizer

Definition at line 83 of file tcp_server_mst_legacy.c.

{
  struct GNUNET_SERVER_MessageStreamTokenizer *ret;
 
  ret = GNUNET_new (struct GNUNET_SERVER_MessageStreamTokenizer);
  ret->hdr = GNUNET_malloc (GNUNET_MIN_MESSAGE_SIZE);
  ret->curr_buf = GNUNET_MIN_MESSAGE_SIZE;
  ret->cb = cb;
  ret->cb_cls = cb_cls;
  return ret;
}

References GNUNET_SERVER_MessageStreamTokenizer::cb, GNUNET_SERVER_MessageStreamTokenizer::cb_cls, GNUNET_malloc, GNUNET_MIN_MESSAGE_SIZE, GNUNET_new, and ret.

Referenced by GNUNET_SERVER_connect_socket().

Here is the caller graph for this function:

GNUNET_SERVER_mst_receive()

int GNUNET_SERVER_mst_receive	(	struct GNUNET_SERVER_MessageStreamTokenizer *	mst,
		void *	client_identity,
		const char *	buf,
		size_t	size,
		int	purge,
		int	one_shot
	)

Add incoming data to the receive buffer and call the callback for all complete messages.

Parameters

mst	tokenizer to use
client_identity	ID of client for which this is a buffer
buf	input data to add
size	number of bytes in buf
purge	should any excess bytes in the buffer be discarded (i.e. for packet-based services like UDP)
one_shot	only call callback once, keep rest of message in buffer

Returns

GNUNET_OK if we are done processing (need more data) GNUNET_NO if one_shot was set and we have another message ready GNUNET_SYSERR if the data stream is corrupt

Definition at line 113 of file tcp_server_mst_legacy.c.

{
  const struct GNUNET_MessageHeader *hdr;
  size_t delta;
  uint16_t want;
  char *ibuf;
  int need_align;
  unsigned long offset;
  int ret;
 
  GNUNET_assert (mst->off <= mst->pos);
  GNUNET_assert (mst->pos <= mst->curr_buf);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Server-mst receives %u bytes with %u bytes already in private buffer\n",
       (unsigned int) size, (unsigned int) (mst->pos - mst->off));
  ret = GNUNET_OK;
  ibuf = (char *) mst->hdr;
  while (mst->pos > 0)
  {
do_align:
    GNUNET_assert (mst->pos >= mst->off);
    if ((mst->curr_buf - mst->off < sizeof(struct GNUNET_MessageHeader)) ||
        (0 != (mst->off % ALIGN_FACTOR)))
    {
      /* need to align or need more space */
      mst->pos -= mst->off;
      memmove (ibuf, &ibuf[mst->off], mst->pos);
      mst->off = 0;
    }
    if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader))
    {
      delta =
        GNUNET_MIN (sizeof(struct GNUNET_MessageHeader)
                    - (mst->pos - mst->off), size);
      GNUNET_memcpy (&ibuf[mst->pos], buf, delta);
      mst->pos += delta;
      buf += delta;
      size -= delta;
    }
    if (mst->pos - mst->off < sizeof(struct GNUNET_MessageHeader))
    {
      if (purge)
      {
        mst->off = 0;
        mst->pos = 0;
      }
      return GNUNET_OK;
    }
    hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
    want = ntohs (hdr->size);
    if (want < sizeof(struct GNUNET_MessageHeader))
    {
      GNUNET_break_op (0);
      return GNUNET_SYSERR;
    }
    if ((mst->curr_buf - mst->off < want) &&
        (mst->off > 0))
    {
      /* can get more space by moving */
      mst->pos -= mst->off;
      memmove (ibuf, &ibuf[mst->off], mst->pos);
      mst->off = 0;
    }
    if (mst->curr_buf < want)
    {
      /* need to get more space by growing buffer */
      GNUNET_assert (0 == mst->off);
      mst->hdr = GNUNET_realloc (mst->hdr, want);
      ibuf = (char *) mst->hdr;
      mst->curr_buf = want;
    }
    hdr = (const struct GNUNET_MessageHeader *) &ibuf[mst->off];
    if (mst->pos - mst->off < want)
    {
      delta = GNUNET_MIN (want - (mst->pos - mst->off), size);
      GNUNET_assert (mst->pos + delta <= mst->curr_buf);
      GNUNET_memcpy (&ibuf[mst->pos], buf, delta);
      mst->pos += delta;
      buf += delta;
      size -= delta;
    }
    if (mst->pos - mst->off < want)
    {
      if (purge)
      {
        mst->off = 0;
        mst->pos = 0;
      }
      return GNUNET_OK;
    }
    if (one_shot == GNUNET_SYSERR)
    {
      /* cannot call callback again, but return value saying that
       * we have another full message in the buffer */
      ret = GNUNET_NO;
      goto copy;
    }
    if (one_shot == GNUNET_YES)
      one_shot = GNUNET_SYSERR;
    mst->off += want;
    if (GNUNET_SYSERR == mst->cb (mst->cb_cls, client_identity, hdr))
      return GNUNET_SYSERR;
    if (mst->off == mst->pos)
    {
      /* reset to beginning of buffer, it's free right now! */
      mst->off = 0;
      mst->pos = 0;
    }
  }
  GNUNET_assert (0 == mst->pos);
  while (size > 0)
  {
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "Server-mst has %u bytes left in inbound buffer\n",
         (unsigned int) size);
    if (size < sizeof(struct GNUNET_MessageHeader))
      break;
    offset = (unsigned long) buf;
    need_align = (0 != (offset % ALIGN_FACTOR)) ? GNUNET_YES : GNUNET_NO;
    if (GNUNET_NO == need_align)
    {
      /* can try to do zero-copy and process directly from original buffer */
      hdr = (const struct GNUNET_MessageHeader *) buf;
      want = ntohs (hdr->size);
      if (want < sizeof(struct GNUNET_MessageHeader))
      {
        GNUNET_break_op (0);
        mst->off = 0;
        return GNUNET_SYSERR;
      }
      if (size < want)
        break;                  /* or not: buffer incomplete, so copy to private buffer... */
      if (one_shot == GNUNET_SYSERR)
      {
        /* cannot call callback again, but return value saying that
         * we have another full message in the buffer */
        ret = GNUNET_NO;
        goto copy;
      }
      if (one_shot == GNUNET_YES)
        one_shot = GNUNET_SYSERR;
      if (GNUNET_SYSERR == mst->cb (mst->cb_cls, client_identity, hdr))
        return GNUNET_SYSERR;
      buf += want;
      size -= want;
    }
    else
    {
      /* need to copy to private buffer to align;
       * yes, we go a bit more spaghetti than usual here */
      goto do_align;
    }
  }
copy:
  if ((size > 0) && (! purge))
  {
    if (size + mst->pos > mst->curr_buf)
    {
      mst->hdr = GNUNET_realloc (mst->hdr, size + mst->pos);
      ibuf = (char *) mst->hdr;
      mst->curr_buf = size + mst->pos;
    }
    GNUNET_assert (size + mst->pos <= mst->curr_buf);
    GNUNET_memcpy (&ibuf[mst->pos], buf, size);
    mst->pos += size;
  }
  if (purge)
  {
    mst->off = 0;
    mst->pos = 0;
  }
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "Server-mst leaves %u bytes in private buffer\n",
       (unsigned int) (mst->pos - mst->off));
  return ret;
}

References ALIGN_FACTOR, buf, GNUNET_SERVER_MessageStreamTokenizer::cb, GNUNET_SERVER_MessageStreamTokenizer::cb_cls, GNUNET_SERVER_MessageStreamTokenizer::curr_buf, delta, do_align(), GNUNET_assert, GNUNET_break_op, GNUNET_ERROR_TYPE_DEBUG, GNUNET_memcpy, GNUNET_MIN, GNUNET_NO, GNUNET_OK, GNUNET_realloc, GNUNET_SYSERR, GNUNET_YES, GNUNET_SERVER_MessageStreamTokenizer::hdr, LOG, GNUNET_SERVER_MessageStreamTokenizer::off, GNUNET_SERVER_MessageStreamTokenizer::pos, ret, GNUNET_MessageHeader::size, and size.

Referenced by handle_helper_message(), process_data(), process_incoming(), process_mst(), and wlan_data_message_handler().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_SERVER_mst_destroy()

void GNUNET_SERVER_mst_destroy

(

struct GNUNET_SERVER_MessageStreamTokenizer *

mst

)

Destroys a tokenizer.

Parameters

mst	tokenizer to destroy

Definition at line 300 of file tcp_server_mst_legacy.c.

{
  GNUNET_free (mst->hdr);
  GNUNET_free (mst);
}

References GNUNET_free, and GNUNET_SERVER_MessageStreamTokenizer::hdr.

Referenced by GNUNET_SERVER_client_disconnect(), and LIBGNUNET_PLUGIN_TRANSPORT_DONE().

Here is the caller graph for this function: