Server library

Library for tokenizing a message stream. More...

Collaboration diagram for Server library:

Typedefs
typedef int(*	GNUNET_MessageTokenizerCallback) (void *cls, const struct GNUNET_MessageHeader *message)
	Functions with this signature are called whenever a complete message is received by the tokenizer.

Functions
struct GNUNET_MessageStreamTokenizer *	GNUNET_MST_create (GNUNET_MessageTokenizerCallback cb, void *cb_cls)
	Create a message stream tokenizer.
enum GNUNET_GenericReturnValue	GNUNET_MST_from_buffer (struct GNUNET_MessageStreamTokenizer *mst, 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.
enum GNUNET_GenericReturnValue	GNUNET_MST_read (struct GNUNET_MessageStreamTokenizer *mst, struct GNUNET_NETWORK_Handle *sock, int purge, int one_shot)
	Add incoming data to the receive buffer and call the callback for all complete messages.
enum GNUNET_GenericReturnValue	GNUNET_MST_next (struct GNUNET_MessageStreamTokenizer *mst, int one_shot)
	Obtain the next message from the mst, assuming that there are more unprocessed messages in the internal buffer of the mst.
void	GNUNET_MST_destroy (struct GNUNET_MessageStreamTokenizer *mst)
	Destroys a tokenizer.

Detailed Description

Library for tokenizing a message stream.

See also

Documentation

Typedef Documentation

GNUNET_MessageTokenizerCallback

typedef int(* GNUNET_MessageTokenizerCallback) (void *cls, const struct GNUNET_MessageHeader *message)

Functions with this signature are called whenever a complete message is received by the tokenizer.

Do not call #GNUNET_mst_destroy from within the scope of this callback.

Parameters

cls	closure
message	the actual message

Returns

GNUNET_OK on success, GNUNET_NO to stop further processing due to disconnect (no error) GNUNET_SYSERR to stop further processing due to error

Definition at line 77 of file gnunet_mst_lib.h.

Function Documentation

GNUNET_MST_create()

struct GNUNET_MessageStreamTokenizer * GNUNET_MST_create	(	GNUNET_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 86 of file mst.c.

{
  struct GNUNET_MessageStreamTokenizer *ret;
 
  ret = GNUNET_new (struct GNUNET_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_MessageStreamTokenizer::cb, GNUNET_MessageStreamTokenizer::cb_cls, GNUNET_malloc, GNUNET_MIN_MESSAGE_SIZE, GNUNET_new, and ret.

Referenced by GCT_create_tunnel(), get_app(), GNUNET_CLIENT_connect(), GNUNET_HELPER_start(), handle_client_send(), handle_transport_notify_connect(), load(), main(), main(), run(), and start_client().

Here is the caller graph for this function:

GNUNET_MST_from_buffer()

enum GNUNET_GenericReturnValue GNUNET_MST_from_buffer	(	struct GNUNET_MessageStreamTokenizer *	mst,
		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
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 101 of file mst.c.

{
  const struct GNUNET_MessageHeader *hdr;
  size_t delta;
  uint16_t want;
  char *ibuf;
  int ret;
  int cbret;
 
  GNUNET_assert (mst->off <= mst->pos);
  GNUNET_assert (mst->pos <= mst->curr_buf);
  LOG (GNUNET_ERROR_TYPE_DEBUG,
       "MST receives %u bytes with %u (%u/%u) bytes already in private buffer\n",
       (unsigned int) size,
       (unsigned int) (mst->pos - mst->off),
       (unsigned int) mst->pos,
       (unsigned int) 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);
    LOG (GNUNET_ERROR_TYPE_DEBUG,
         "We want to read message of size %u\n",
         want);
    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_OK !=
        (cbret = mst->cb (mst->cb_cls,
                          hdr)))
    {
      if (GNUNET_SYSERR == cbret)
        GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                    "Failure processing message of type %u and size %u\n",
                    ntohs (hdr->type),
                    ntohs (hdr->size));
      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)
  {
    unsigned long offset = (unsigned long) buf;
    bool need_align = (0 != (offset % ALIGN_FACTOR));
 
    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;
    if (! 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 (GNUNET_YES == one_shot)
        one_shot = GNUNET_SYSERR;
      if (GNUNET_OK !=
          (cbret = mst->cb (mst->cb_cls,
                            hdr)))
      {
        if (GNUNET_SYSERR == cbret)
          GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                      "Failure processing message of type %u and size %u\n",
                      ntohs (hdr->type),
                      ntohs (hdr->size));
        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 (%u/%u) bytes in private buffer\n",
       (unsigned int) (mst->pos - mst->off),
       (unsigned int) mst->pos,
       (unsigned int) mst->off);
  return ret;
}

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

Referenced by GCT_handle_encrypted(), GNUNET_HELPER_wait(), GNUNET_MST_next(), GNUNET_MST_read(), gnunet_read(), handle_client_send(), handle_encrypted_message(), helper_read(), load(), main(), main(), and read_task().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_MST_read()

enum GNUNET_GenericReturnValue GNUNET_MST_read	(	struct GNUNET_MessageStreamTokenizer *	mst,
		struct GNUNET_NETWORK_Handle *	sock,
		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
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 338 of file mst.c.

{
  ssize_t ret;
  size_t left;
  char *buf;
 
  left = mst->curr_buf - mst->pos;
  buf = (char *) mst->hdr;
  ret = GNUNET_NETWORK_socket_recv (sock,
                                    &buf[mst->pos],
                                    left);
  if (-1 == ret)
  {
    if ((EAGAIN == errno) ||
        (EINTR == errno))
      return GNUNET_OK;
    GNUNET_log_strerror (GNUNET_ERROR_TYPE_INFO,
                         "recv");
    return GNUNET_SYSERR;
  }
  if (0 == ret)
  {
    /* other side closed connection, treat as error */
    return GNUNET_SYSERR;
  }
  mst->pos += ret;
  return GNUNET_MST_from_buffer (mst,
                                 NULL,
                                 0,
                                 purge,
                                 one_shot);
}

References GNUNET_MessageStreamTokenizer::curr_buf, GNUNET_ERROR_TYPE_INFO, GNUNET_log_strerror, GNUNET_MST_from_buffer(), GNUNET_NETWORK_socket_recv(), GNUNET_OK, GNUNET_SYSERR, GNUNET_MessageStreamTokenizer::hdr, GNUNET_MessageStreamTokenizer::pos, and ret.

Referenced by receive_ready(), and service_client_recv().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_MST_next()

enum GNUNET_GenericReturnValue GNUNET_MST_next	(	struct GNUNET_MessageStreamTokenizer *	mst,
		int	one_shot
	)

Obtain the next message from the mst, assuming that there are more unprocessed messages in the internal buffer of the mst.

Parameters

mst	tokenizer to use
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 387 of file mst.c.

{
  return GNUNET_MST_from_buffer (mst,
                                 NULL,
                                 0,
                                 GNUNET_NO,
                                 one_shot);
}

References GNUNET_MST_from_buffer(), and GNUNET_NO.

Referenced by resume_client_receive().

Here is the call graph for this function:

Here is the caller graph for this function:

GNUNET_MST_destroy()

void GNUNET_MST_destroy

(

struct GNUNET_MessageStreamTokenizer *

mst

)

Destroys a tokenizer.

Parameters

mst	tokenizer to destroy

Definition at line 404 of file mst.c.

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

References GNUNET_free, and GNUNET_MessageStreamTokenizer::hdr.

Referenced by connection_client_destroy_impl(), destroy_tunnel(), do_shutdown_later(), finish_client_drop(), GNUNET_HELPER_destroy(), handle_client_send(), handle_transport_notify_disconnect(), load(), main(), and main().

Here is the caller graph for this function: