1// Copyright 2013 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "mojo/public/bindings/lib/bindings_serialization.h"
6
7#include <assert.h>
8
9namespace mojo {
10namespace internal {
11
12size_t Align(size_t size) {
13  const size_t kAlignment = 8;
14  return size + (kAlignment - (size % kAlignment)) % kAlignment;
15}
16
17void EncodePointer(const void* ptr, uint64_t* offset) {
18  if (!ptr) {
19    *offset = 0;
20    return;
21  }
22
23  const char* p_obj = reinterpret_cast<const char*>(ptr);
24  const char* p_slot = reinterpret_cast<const char*>(offset);
25  assert(p_obj > p_slot);
26
27  *offset = static_cast<uint64_t>(p_obj - p_slot);
28}
29
30const void* DecodePointerRaw(const uint64_t* offset) {
31  if (!*offset)
32    return NULL;
33  return reinterpret_cast<const char*>(offset) + *offset;
34}
35
36bool ValidatePointer(const void* ptr, const Message& message) {
37  const uint8_t* data = static_cast<const uint8_t*>(ptr);
38  if (reinterpret_cast<ptrdiff_t>(data) % 8 != 0)
39    return false;
40
41  const uint8_t* data_start = reinterpret_cast<const uint8_t*>(message.data);
42  const uint8_t* data_end = data_start + message.data->header.num_bytes;
43
44  return data >= data_start && data < data_end;
45}
46
47void EncodeHandle(Handle* handle, std::vector<Handle>* handles) {
48  if (handle->is_valid()) {
49    handles->push_back(*handle);
50    handle->set_value(static_cast<MojoHandle>(handles->size() - 1));
51  } else {
52    // Encode -1 to mean the invalid handle.
53    handle->set_value(static_cast<MojoHandle>(-1));
54  }
55}
56
57bool DecodeHandle(Handle* handle, std::vector<Handle>* handles) {
58  // Decode -1 to mean the invalid handle.
59  if (handle->value() == static_cast<MojoHandle>(-1)) {
60    *handle = Handle();
61    return true;
62  }
63  if (handle->value() >= handles->size())
64    return false;
65  // Just leave holes in the vector so we don't screw up other indices.
66  *handle = FetchAndReset(&handles->at(handle->value()));
67  return true;
68}
69
70// static
71void ArrayHelper<Handle>::EncodePointersAndHandles(
72    const ArrayHeader* header,
73    ElementType* elements,
74    std::vector<Handle>* handles) {
75  for (uint32_t i = 0; i < header->num_elements; ++i)
76    EncodeHandle(&elements[i], handles);
77}
78
79// static
80bool ArrayHelper<Handle>::DecodePointersAndHandles(
81    const ArrayHeader* header,
82    ElementType* elements,
83    Message* message) {
84  for (uint32_t i = 0; i < header->num_elements; ++i) {
85    if (!DecodeHandle(&elements[i], &message->handles))
86      return false;
87  }
88  return true;
89}
90
91}  // namespace internal
92}  // namespace mojo
93