src/utf8_fix.cc

// Copyright 2017 Google Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#include "src/utf8_fix.h"

#include <algorithm>
#include <cassert>

namespace protobuf_mutator {

namespace {

void StoreCode(char* e, char32_t code, uint8_t size, uint8_t prefix) {
  while (--size) {
    *(--e) = 0x80 | (code & 0x3F);
    code >>= 6;
  }
  *(--e) = prefix | code;
}

char* FixCode(char* b, const char* e, RandomEngine* random) {
  const char* start = b;
  assert(b < e);

  e = std::min<const char*>(e, b + 4);
  char32_t c = *b++;
  for (; b < e && (*b & 0xC0) == 0x80; ++b) {
    c = (c << 6) + (*b & 0x3F);
  }
  uint8_t size = b - start;
  switch (size) {
    case 1:
      c &= 0x7F;
      StoreCode(b, c, size, 0);
      break;
    case 2:
      c &= 0x7FF;
      if (c < 0x80) {
        // Use uint32_t because uniform_int_distribution does not support
        // char32_t on Windows.
        c = std::uniform_int_distribution<uint32_t>(0x80, 0x7FF)(*random);
      }
      StoreCode(b, c, size, 0xC0);
      break;
    case 3:
      c &= 0xFFFF;

      // [0xD800, 0xE000) are reserved for UTF-16 surrogate halves.
      if (c < 0x800 || (c >= 0xD800 && c < 0xE000)) {
        uint32_t halves = 0xE000 - 0xD800;
        c = std::uniform_int_distribution<uint32_t>(0x800,
                                                    0xFFFF - halves)(*random);
        if (c >= 0xD800) c += halves;
      }
      StoreCode(b, c, size, 0xE0);
      break;
    case 4:
      c &= 0x1FFFFF;
      if (c < 0x10000 || c > 0x10FFFF) {
        c = std::uniform_int_distribution<uint32_t>(0x10000, 0x10FFFF)(*random);
      }
      StoreCode(b, c, size, 0xF0);
      break;
    default:
      assert(false && "Unexpected size of UTF-8 sequence");
  }
  return b;
}

}  // namespace

void FixUtf8String(std::string* str, RandomEngine* random) {
  if (str->empty()) return;
  char* b = &(*str)[0];
  const char* e = b + str->size();
  while (b < e) {
    b = FixCode(b, e, random);
  }
}

}  // namespace protobuf_mutator