text: // Copyright (c) 2011 The LevelDB Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file. See the AUTHORS file for names of contributors.
  
  #include "table/format.h"
  
  #include "leveldb/env.h"
  #include "port/port.h"
  #include "table/block.h"
  #include "util/coding.h"
  #include "util/crc32c.h"
  
  namespace leveldb {
  
  void BlockHandle::EncodeTo(std::string* dst) const {
    // Sanity check that all fields have been set
    assert(offset_ != ~static_cast<uint64_t>(0));
    assert(size_ != ~static_cast<uint64_t>(0));
    PutVarint64(dst, offset_);
    PutVarint64(dst, size_);
  }
  
  Status BlockHandle::DecodeFrom(Slice* input) {
    if (GetVarint64(input, &offset_) &&
        GetVarint64(input, &size_)) {
      return Status::OK();
    } else {
      return Status::Corruption("bad block handle");
    }
  }
  
  void Footer::EncodeTo(std::string* dst) const {
  #ifndef NDEBUG
    const size_t original_size = dst->size();
  #endif
    metaindex_handle_.EncodeTo(dst);
    index_handle_.EncodeTo(dst);
    dst->resize(2 * BlockHandle::kMaxEncodedLength);  // Padding
    PutFixed32(dst, static_cast<uint32_t>(kTableMagicNumber & 0xffffffffu));
    PutFixed32(dst, static_cast<uint32_t>(kTableMagicNumber >> 32));
    assert(dst->size() == original_size + kEncodedLength);
  }
  
  Status Footer::DecodeFrom(Slice* input) {
    const char* magic_ptr = input->data() + kEncodedLength - 8;
    const uint32_t magic_lo = DecodeFixed32(magic_ptr);
    const uint32_t magic_hi = DecodeFixed32(magic_ptr + 4);
    const uint64_t magic = ((static_cast<uint64_t>(magic_hi) << 32) |
                            (static_cast<uint64_t>(magic_lo)));
    if (magic != kTableMagicNumber) {
      return Status::Corruption("not an sstable (bad magic number)");
    }
  
    Status result = metaindex_handle_.DecodeFrom(input);
    if (result.ok()) {
      result = index_handle_.DecodeFrom(input);
    }
    if (result.ok()) {
      // We skip over any leftover data (just padding for now) in "input"
      const char* end = magic_ptr + 8;
      *input = Slice(end, input->data() + input->size() - end);
    }
    return result;
  }
  
  Status ReadBlock(RandomAccessFile* file,
                   const ReadOptions& options,
                   const BlockHandle& handle,
                   BlockContents* result) {
    result->data = Slice();
    result->cachable = false;
    result->heap_allocated = false;
  
    // Read the block contents as well as the type/crc footer.
    // See table_builder.cc for the code that built this structure.
    size_t n = static_cast<size_t>(handle.size());
    char* buf = new char[n + kBlockTrailerSize];
    Slice contents;
    Status s = file->Read(handle.offset(), n + kBlockTrailerSize, &contents, buf);
    if (!s.ok()) {
      delete[] buf;
      return s;
    }
    if (contents.size() != n + kBlockTrailerSize) {
      delete[] buf;
      return Status::Corruption("truncated block read");
    }
  
    // Check the crc of the type and the block contents
    const char* data = contents.data();    // Pointer to where Read put the data
    if (options.verify_checksums) {
      const uint32_t crc = crc32c::Unmask(DecodeFixed32(data + n + 1));
      const uint32_t actual = crc32c::Value(data, n + 1);
      if (actual != crc) {
        delete[] buf;
        s = Status::Corruption("block checksum mismatch");
        return s;
      }
    }
  
    switch (data[n]) {
      case kNoCompression:
        if (data != buf) {
          // File implementation gave us pointer to some other data.
          // Use it directly under the assumption that it will be live
          // while the file is open.
          delete[] buf;
          result->data = Slice(data, n);
          result->heap_allocated = false;
          result->cachable = false;  // Do not double-cache
        } else {
          result->data = Slice(buf, n);
          result->heap_allocated = true;
          result->cachable = true;
        }
  
        // Ok
        break;
      case kSnappyCompression: {
        size_t ulength = 0;
        if (!port::Snappy_GetUncompressedLength(data, n, &ulength)) {
          delete[] buf;
          return Status::Corruption("corrupted compressed block contents");
        }
        char* ubuf = new char[ulength];
        if (!port::Snappy_Uncompress(data, n, ubuf)) {
          delete[] buf;
          delete[] ubuf;
          return Status::Corruption("corrupted compressed block contents");
        }
        delete[] buf;
        result->data = Slice(ubuf, ulength);
        result->heap_allocated = true;
        result->cachable = true;
        break;
      }
      default:
        delete[] buf;
        return Status::Corruption("bad block type");
    }
  
    return Status::OK();
  }
  
  }  // namespace leveldb
  