1  // Copyright 2016 Wladimir J. van der Laan
  2  // Distributed under the MIT software license, see the accompanying
  3  // file COPYING or https://opensource.org/licenses/mit-license.php.
  4  #ifndef BITCOIN_UNIVALUE_INCLUDE_UNIVALUE_UTFFILTER_H
  5  #define BITCOIN_UNIVALUE_INCLUDE_UNIVALUE_UTFFILTER_H
  6  
  7  #include <string>
  8  
  9  /**
 10   * Filter that generates and validates UTF-8, as well as collates UTF-16
 11   * surrogate pairs as specified in RFC4627.
 12   */
 13  class JSONUTF8StringFilter
 14  {
 15  public:
 16      explicit JSONUTF8StringFilter(std::string& s)
 17          : str(s)
 18      {
 19      }
 20      // Write single 8-bit char (may be part of UTF-8 sequence)
 21      void push_back(unsigned char ch)
 22      {
 23          if (state == 0) {
 24              if (ch < 0x80) // 7-bit ASCII, fast direct pass-through
 25                  str.push_back(ch);
 26              else if (ch < 0xc0) // Mid-sequence character, invalid in this state
 27                  is_valid = false;
 28              else if (ch < 0xe0) { // Start of 2-byte sequence
 29                  codepoint = (ch & 0x1f) << 6;
 30                  state = 6;
 31              } else if (ch < 0xf0) { // Start of 3-byte sequence
 32                  codepoint = (ch & 0x0f) << 12;
 33                  state = 12;
 34              } else if (ch < 0xf8) { // Start of 4-byte sequence
 35                  codepoint = (ch & 0x07) << 18;
 36                  state = 18;
 37              } else // Reserved, invalid
 38                  is_valid = false;
 39          } else {
 40              if ((ch & 0xc0) != 0x80) // Not a continuation, invalid
 41                  is_valid = false;
 42              state -= 6;
 43              codepoint |= (ch & 0x3f) << state;
 44              if (state == 0)
 45                  push_back_u(codepoint);
 46          }
 47      }
 48      // Write codepoint directly, possibly collating surrogate pairs
 49      void push_back_u(unsigned int codepoint_)
 50      {
 51          if (state) // Only accept full codepoints in open state
 52              is_valid = false;
 53          if (codepoint_ >= 0xD800 && codepoint_ < 0xDC00) { // First half of surrogate pair
 54              if (surpair) // Two subsequent surrogate pair openers - fail
 55                  is_valid = false;
 56              else
 57                  surpair = codepoint_;
 58          } else if (codepoint_ >= 0xDC00 && codepoint_ < 0xE000) { // Second half of surrogate pair
 59              if (surpair) { // Open surrogate pair, expect second half
 60                  // Compute code point from UTF-16 surrogate pair
 61                  append_codepoint(0x10000 | ((surpair - 0xD800)<<10) | (codepoint_ - 0xDC00));
 62                  surpair = 0;
 63              } else // Second half doesn't follow a first half - fail
 64                  is_valid = false;
 65          } else {
 66              if (surpair) // First half of surrogate pair not followed by second - fail
 67                  is_valid = false;
 68              else
 69                  append_codepoint(codepoint_);
 70          }
 71      }
 72      // Check that we're in a state where the string can be ended
 73      // No open sequences, no open surrogate pairs, etc
 74      bool finalize()
 75      {
 76          if (state || surpair)
 77              is_valid = false;
 78          return is_valid;
 79      }
 80  private:
 81      std::string &str;
 82      bool is_valid{true};
 83      // Current UTF-8 decoding state
 84      unsigned int codepoint{0};
 85      int state{0}; // Top bit to be filled in for next UTF-8 byte, or 0
 86  
 87      // Keep track of the following state to handle the following section of
 88      // RFC4627:
 89      //
 90      //    To escape an extended character that is not in the Basic Multilingual
 91      //    Plane, the character is represented as a twelve-character sequence,
 92      //    encoding the UTF-16 surrogate pair.  So, for example, a string
 93      //    containing only the G clef character (U+1D11E) may be represented as
 94      //    "\uD834\uDD1E".
 95      //
 96      //  Two subsequent \u.... may have to be replaced with one actual codepoint.
 97      unsigned int surpair{0}; // First half of open UTF-16 surrogate pair, or 0
 98  
 99      void append_codepoint(unsigned int codepoint_)
100      {
101          if (codepoint_ <= 0x7f)
102              str.push_back((char)codepoint_);
103          else if (codepoint_ <= 0x7FF) {
104              str.push_back((char)(0xC0 | (codepoint_ >> 6)));
105              str.push_back((char)(0x80 | (codepoint_ & 0x3F)));
106          } else if (codepoint_ <= 0xFFFF) {
107              str.push_back((char)(0xE0 | (codepoint_ >> 12)));
108              str.push_back((char)(0x80 | ((codepoint_ >> 6) & 0x3F)));
109              str.push_back((char)(0x80 | (codepoint_ & 0x3F)));
110          } else if (codepoint_ <= 0x1FFFFF) {
111              str.push_back((char)(0xF0 | (codepoint_ >> 18)));
112              str.push_back((char)(0x80 | ((codepoint_ >> 12) & 0x3F)));
113              str.push_back((char)(0x80 | ((codepoint_ >> 6) & 0x3F)));
114              str.push_back((char)(0x80 | (codepoint_ & 0x3F)));
115          }
116      }
117  };
118  
119  #endif // BITCOIN_UNIVALUE_INCLUDE_UNIVALUE_UTFFILTER_H