EmBencode.h

Go to the documentation of this file.

/// @file
/// Embedded bencode support, header definitions.
// 2012-09-29 <jc@wippler.nl> http://opensource.org/licenses/mit-license.php

#include <stdint.h>
#include <stdlib.h>
#include <string.h>

/// Encoder class to generate Bencode on the fly (no buffer storage needed).
class EmBencode {
public:
  EmBencode () {}
  
  /// Push a string out in Bencode format.
  /// @param str The zero-terminated string to send out (without trailing \0).
  static void push (const char* str) {
    push(str, strlen(str));
  }

  /// Push arbitrary bytes in Bencode format.
  /// @param ptr Pointer to the data to send out.
  /// @param len Number of data bytes to send out.
  static void push (const void* ptr, uint8_t len) {
    PushCount(len);
    PushChar(':');
    PushData(ptr, len);
  }

  /// Push a signed integer in Bencode format.
  /// @param val The integer to send (this implementation supports 32 bits).
  static void push (long val) {
    PushChar('i');
    if (val < 0) {
      PushChar('-');
      val = -val;
    }
    PushCount(val);
    PushEnd();
  }

  /// Start a new new list. Must be matched with a call to endList().
  /// Entries can be nested with more calls to startList(), startDict(), etc.
  static void startList () {
    PushChar('l');
  }

  /// Terminate a list, started earlier with a call to startList().
  static void endList () {
    PushEnd();
  }

  /// Start a new new dictionary. Must be matched with a call to endDict().
  /// Dictionary entries must consist of a string key plus an arbitrary value.
  /// Entries can be nested with more calls to startList(), startDict(), etc.
  static void startDict () {
    PushChar('d');
  }

  /// Terminate a dictionary, started earlier with a call to startDict().
  static void endDict () {
    PushEnd();
  }

protected:
  static void PushCount (uint32_t num) {
    char buf[11];
    PushData(ultoa(num, buf, 10), strlen(buf));
  }

  static void PushEnd () {
    PushChar('e');
  }

  static void PushData (const void* ptr, uint8_t len) {
    for (const char* p = (const char*) ptr; len-- > 0; ++p)
      PushChar(*p);
  }

  /// This function is not implemented in the library. It must be supplied by
  /// the caller to implement the actual writing of caharacters.
  static void PushChar (char ch);
};

/// Decoder class, needs an external buffer to collect the incoming data.
class EmBdecode {
public:
  /// Types of tokens, as returned by nextToken().
  enum { T_STRING = 0, T_NUMBER = 251, T_DICT, T_LIST, T_POP, T_END };

  /// Initialize a decoder instance with the specified buffer space.
  /// @param buf Pointer to the buffer which will be used by the decoder.
  /// @param len Size of the buffer, must be in the range 50 to 255.
  EmBdecode (char* buf, uint8_t len) 
    : bufPtr (buf), bufLen (len) { reset(); }

  /// Reset the decoder - can be called to prepare for a new round of decoding.
  uint8_t reset ();

  /// Process a single incoming caharacter.
  /// @return Returns a count > 0 when the buffer contains a complete packet.
  uint8_t process (char ch);

  /// Call this after process() is done, to extract each of the data tokens.
  /// @returns Returns one of the T_STRING .. T_END enumeration codes.
  uint8_t nextToken ();
  /// Extract the last token as string (works for T_STRING and T_NUMBER).
  /// @param plen This variable will receive the size, if present.
  /// @return Returns pointer to a zero-terminated string in the decode buffer.
  const char* asString (uint8_t* plen =0);
  /// Extract the last token as number (also works for strings if numeric).
  /// @return Returns the decoded integer, max 32-bit signed in this version.
  long asNumber ();
  
protected:
  void AddToBuf (char ch);

  char level, *bufPtr; 
  uint8_t bufLen, count, next, last, state;
};

// Encoder class for a tightly-packed one-to-one transformation of Bencode.
class EmBenPack {
  enum { PT_EXT, PT_POS, PT_NEG, PT_STR };
  enum { PE_END, PE_LIST, PE_DICT };
public:
  EmBenPack (char* ptr, uint8_t len) : buf (ptr), limit (len) {
    reset ();
  }

  uint8_t fill () const {
    return next;
  }

  void reset () {
    next = 0;
  }

  void push (const char* str) {
    push(str, strlen(str));
  }

  void push (const void* ptr, uint8_t len) {
    PushCount((len << 2) | PT_STR);
    for (const char* p = (const char*) ptr; len-- > 0; ++p)
      PushChar(*p);
  }

  /// @bug this currently only works for longs up to 30 bits
  void push (long val) {
    PushCount(val < 0 ? (~val << 2) | PT_NEG
                      : (val << 2) | PT_POS);
  }

  void startList () {
    PushChar((PE_LIST << 2) | PT_EXT);
  }

  void endList () {
    PushEnd();
  }

  void startDict () {
    PushChar((PE_DICT << 2) | PT_EXT);
  }

  void endDict () {
    PushEnd();
  }

  void pushMarker () {
    PushChar(0); // special value, doesn't match any other valid item
  }

protected:
  void PushCount (uint32_t num, uint8_t flag =0x80) {
    if (num > 0x7F)
      PushCount(num >> 7, 0);
    PushCount(flag | (num & 0x7F));
  }

  void PushEnd () {
    PushChar((PE_END << 2) | PT_EXT);
  }

  void PushChar (char ch) {
    if (next < limit)
      buf[next++] = ch;
  }

  char* buf;
  uint8_t limit, next;
};