1 /* 2 * Copyright (C) 2010 Apple Inc. All rights reserved. 3 * 4 * Redistribution and use in source and binary forms, with or without 5 * modification, are permitted provided that the following conditions 6 * are met: 7 * 1. Redistributions of source code must retain the above copyright 8 * notice, this list of conditions and the following disclaimer. 9 * 2. Redistributions in binary form must reproduce the above copyright 10 * notice, this list of conditions and the following disclaimer in the 11 * documentation and/or other materials provided with the distribution. 12 * 13 * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' 14 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 15 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 16 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS 17 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 18 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 19 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 20 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 21 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 22 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF 23 * THE POSSIBILITY OF SUCH DAMAGE. 24 */ 25 26 #include "config.h" 27 #include "ArgumentEncoder.h" 28 29 #include <algorithm> 30 #include <stdio.h> 31 32 namespace CoreIPC { 33 34 PassOwnPtr<ArgumentEncoder> ArgumentEncoder::create(uint64_t destinationID) 35 { 36 return adoptPtr(new ArgumentEncoder(destinationID)); 37 } 38 39 ArgumentEncoder::ArgumentEncoder(uint64_t destinationID) 40 : m_buffer(0) 41 , m_bufferPointer(0) 42 , m_bufferSize(0) 43 , m_bufferCapacity(0) 44 { 45 // Encode the destination ID. 46 encodeUInt64(destinationID); 47 } 48 49 ArgumentEncoder::~ArgumentEncoder() 50 { 51 if (m_buffer) 52 fastFree(m_buffer); 53 #if !PLATFORM(QT) && !PLATFORM(GTK) 54 // FIXME: We need to dispose of the attachments in cases of failure. 55 #else 56 for (int i = 0; i < m_attachments.size(); ++i) 57 m_attachments[i].dispose(); 58 #endif 59 } 60 61 static inline size_t roundUpToAlignment(size_t value, unsigned alignment) 62 { 63 return ((value + alignment - 1) / alignment) * alignment; 64 } 65 66 uint8_t* ArgumentEncoder::grow(unsigned alignment, size_t size) 67 { 68 size_t alignedSize = roundUpToAlignment(m_bufferSize, alignment); 69 70 if (alignedSize + size > m_bufferCapacity) { 71 size_t newCapacity = std::max(alignedSize + size, std::max(static_cast<size_t>(32), m_bufferCapacity + m_bufferCapacity / 4 + 1)); 72 if (!m_buffer) 73 m_buffer = static_cast<uint8_t*>(fastMalloc(newCapacity)); 74 else 75 m_buffer = static_cast<uint8_t*>(fastRealloc(m_buffer, newCapacity)); 76 77 // FIXME: What should we do if allocating memory fails? 78 79 m_bufferCapacity = newCapacity; 80 } 81 82 m_bufferSize = alignedSize + size; 83 m_bufferPointer = m_buffer + alignedSize + size; 84 85 return m_buffer + alignedSize; 86 } 87 88 void ArgumentEncoder::encodeBytes(const uint8_t* bytes, size_t size) 89 { 90 // Encode the size. 91 encodeUInt64(static_cast<uint64_t>(size)); 92 93 uint8_t* buffer = grow(1, size); 94 95 memcpy(buffer, bytes, size); 96 } 97 98 void ArgumentEncoder::encodeBool(bool n) 99 { 100 uint8_t* buffer = grow(sizeof(n), sizeof(n)); 101 102 *reinterpret_cast<bool*>(buffer) = n; 103 } 104 105 void ArgumentEncoder::encodeUInt32(uint32_t n) 106 { 107 uint8_t* buffer = grow(sizeof(n), sizeof(n)); 108 109 *reinterpret_cast<uint32_t*>(buffer) = n; 110 } 111 112 void ArgumentEncoder::encodeUInt64(uint64_t n) 113 { 114 uint8_t* buffer = grow(sizeof(n), sizeof(n)); 115 116 *reinterpret_cast<uint64_t*>(buffer) = n; 117 } 118 119 void ArgumentEncoder::encodeInt32(int32_t n) 120 { 121 uint8_t* buffer = grow(sizeof(n), sizeof(n)); 122 123 *reinterpret_cast<int32_t*>(buffer) = n; 124 } 125 126 void ArgumentEncoder::encodeInt64(int64_t n) 127 { 128 uint8_t* buffer = grow(sizeof(n), sizeof(n)); 129 130 *reinterpret_cast<int64_t*>(buffer) = n; 131 } 132 133 void ArgumentEncoder::encodeFloat(float n) 134 { 135 uint8_t* buffer = grow(sizeof(n), sizeof(n)); 136 137 *reinterpret_cast<float*>(buffer) = n; 138 } 139 140 void ArgumentEncoder::encodeDouble(double n) 141 { 142 uint8_t* buffer = grow(sizeof(n), sizeof(n)); 143 144 *reinterpret_cast<double*>(buffer) = n; 145 } 146 147 void ArgumentEncoder::addAttachment(const Attachment& attachment) 148 { 149 m_attachments.append(attachment); 150 } 151 152 Vector<Attachment> ArgumentEncoder::releaseAttachments() 153 { 154 Vector<Attachment> newList; 155 newList.swap(m_attachments); 156 return newList; 157 } 158 159 #ifndef NDEBUG 160 void ArgumentEncoder::debug() 161 { 162 printf("ArgumentEncoder::debug()\n"); 163 printf("Number of Attachments: %d\n", (int)m_attachments.size()); 164 printf("Size of buffer: %d\n", (int)m_bufferSize); 165 } 166 #endif 167 168 } // namespace CoreIPC 169
