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
9 namespace mojo {
10 namespace internal {
11
Align(size_t size)12 size_t Align(size_t size) {
13 const size_t kAlignment = 8;
14 return size + (kAlignment - (size % kAlignment)) % kAlignment;
15 }
16
EncodePointer(const void * ptr,uint64_t * offset)17 void 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
DecodePointerRaw(const uint64_t * offset)30 const void* DecodePointerRaw(const uint64_t* offset) {
31 if (!*offset)
32 return NULL;
33 return reinterpret_cast<const char*>(offset) + *offset;
34 }
35
ValidatePointer(const void * ptr,const Message & message)36 bool 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
EncodeHandle(Handle * handle,std::vector<Handle> * handles)47 void 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
DecodeHandle(Handle * handle,std::vector<Handle> * handles)57 bool 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
EncodePointersAndHandles(const ArrayHeader * header,ElementType * elements,std::vector<Handle> * handles)71 void 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
DecodePointersAndHandles(const ArrayHeader * header,ElementType * elements,Message * message)80 bool 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