1 2 /* 3 * Copyright (C) 2017 The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18 #ifndef CHRE_HOST_HOST_PROTOCOL_HOST_H_ 19 #define CHRE_HOST_HOST_PROTOCOL_HOST_H_ 20 21 #include <stdint.h> 22 23 #include "chre/platform/shared/host_protocol_common.h" 24 #include "chre_host/fragmented_load_transaction.h" 25 #include "chre_host/host_messages_generated.h" 26 #include "flatbuffers/flatbuffers.h" 27 28 #include <vector> 29 30 namespace android { 31 namespace chre { 32 33 /** 34 * Checks that a string encapsulated as a byte vector is null-terminated, and 35 * if it is, returns a pointer to the vector's data. Otherwise returns null. 36 * 37 * This is similar to getStringFromByteVector in host_protocol_chre.h. Ensure 38 * that method's implementation is kept in sync with this. 39 * 40 * @param vec Target vector, can be null 41 * 42 * @return Pointer to the vector's data, or null 43 */ 44 const char *getStringFromByteVector(const std::vector<int8_t>& vec); 45 46 /** 47 * Calling code should provide an implementation of this interface to handle 48 * parsed results from decodeMessageFromChre(). 49 */ 50 class IChreMessageHandlers { 51 public: 52 virtual ~IChreMessageHandlers() = default; 53 handleNanoappMessage(const::chre::fbs::NanoappMessageT &)54 virtual void handleNanoappMessage( 55 const ::chre::fbs::NanoappMessageT& /*message*/) {}; 56 handleHubInfoResponse(const::chre::fbs::HubInfoResponseT &)57 virtual void handleHubInfoResponse( 58 const ::chre::fbs::HubInfoResponseT& /*response*/) {}; 59 handleNanoappListResponse(const::chre::fbs::NanoappListResponseT &)60 virtual void handleNanoappListResponse( 61 const ::chre::fbs::NanoappListResponseT& /*response*/) {}; 62 handleLoadNanoappResponse(const::chre::fbs::LoadNanoappResponseT &)63 virtual void handleLoadNanoappResponse( 64 const ::chre::fbs::LoadNanoappResponseT& /*response*/) {}; 65 handleUnloadNanoappResponse(const::chre::fbs::UnloadNanoappResponseT &)66 virtual void handleUnloadNanoappResponse( 67 const ::chre::fbs::UnloadNanoappResponseT& /*response*/) {}; 68 handleDebugDumpData(const::chre::fbs::DebugDumpDataT &)69 virtual void handleDebugDumpData( 70 const ::chre::fbs::DebugDumpDataT& /*data*/) {}; 71 handleDebugDumpResponse(const::chre::fbs::DebugDumpResponseT &)72 virtual void handleDebugDumpResponse( 73 const ::chre::fbs::DebugDumpResponseT& /*response*/) {}; 74 }; 75 76 /** 77 * A set of helper methods that simplify the encode/decode of FlatBuffers 78 * messages used in communication with CHRE from the host. 79 */ 80 class HostProtocolHost : public ::chre::HostProtocolCommon { 81 public: 82 /** 83 * Decodes a message sent from CHRE and invokes the appropriate handler 84 * function in the provided interface implementation to handle the parsed 85 * result. 86 * 87 * @param message Buffer containing a complete FlatBuffers CHRE message 88 * @param messageLen Size of the message, in bytes 89 * @param handlers Set of callbacks to handle the parsed message. If this 90 * function returns success, then exactly one of these functions was 91 * called. 92 * 93 * @return true if the message was parsed successfully and passed to a handler 94 */ 95 static bool decodeMessageFromChre(const void *message, size_t messageLen, 96 IChreMessageHandlers& handlers); 97 98 /** 99 * Encodes a message requesting hub information from CHRE 100 * 101 * @param builder A newly constructed FlatBufferBuilder that will be used to 102 * construct the message 103 */ 104 static void encodeHubInfoRequest(flatbuffers::FlatBufferBuilder& builder); 105 106 /** 107 * Encodes a message requesting to load a nanoapp specified by the included 108 * (possibly fragmented) binary payload and metadata. 109 * 110 * @param builder A newly constructed FlatBufferBuilder that will be used to 111 * construct the message 112 * @param request The FragmentedLoadRequest object with the binary and the 113 * metadata 114 */ 115 static void encodeFragmentedLoadNanoappRequest( 116 flatbuffers::FlatBufferBuilder& builder, 117 const FragmentedLoadRequest& request); 118 119 /** 120 * Encodes a message requesting the list of loaded nanoapps from CHRE 121 * 122 * @param builder A newly constructed FlatBufferBuilder that will be used to 123 * construct the message 124 */ 125 static void encodeNanoappListRequest(flatbuffers::FlatBufferBuilder& builder); 126 127 /** 128 * Encodes a message requesting to unload a nanoapp specified by app ID. 129 * 130 * @param builder A newly constructed FlatBufferBuilder that will be used to 131 * construct the message 132 * @param transactionId A transaction identifier to tie the subsequent 133 * response to this request 134 * @param appId Identifier for the app to unload 135 * @param allowSystemNanoappUnload Whether this request should be allowed to 136 * result in unloading a system nanoapp (e.g. requests from the context 137 * hub HAL should have set this to false, as system nanoapps are not 138 * expected to be managed through that HAL) 139 */ 140 static void encodeUnloadNanoappRequest( 141 flatbuffers::FlatBufferBuilder& builder, uint32_t transactionId, 142 uint64_t appId, bool allowSystemNanoappUnload); 143 144 /** 145 * Encodes a message to send the AP timestamp to CHRE 146 * 147 * @param builder A newly constructed FlatBufferBuilder that will be used to 148 * construct the message 149 * @param offset The AP to SLPI offset in nanoseconds 150 */ 151 static void encodeTimeSyncMessage(flatbuffers::FlatBufferBuilder& builder, 152 int64_t offset); 153 154 /** 155 * Encodes a message requesting debugging information from CHRE 156 * 157 * @param builder A newly constructed FlatBufferBuilder that will be used to 158 * construct the message 159 */ 160 static void encodeDebugDumpRequest(flatbuffers::FlatBufferBuilder& builder); 161 162 /** 163 * Decodes the host client ID included in the message container 164 * 165 * @param message Buffer containing a complete FlatBuffers CHRE message 166 * @param messageLen Size of the message, in bytes 167 * @param hostClientId Output parameter that will be populated with the client 168 * ID included in the message on success 169 * 170 * @return true if the host client ID was successfully decoded from the 171 * message 172 */ 173 static bool extractHostClientIdAndType( 174 const void *message, size_t messageLen, uint16_t *hostClientId, 175 ::chre::fbs::ChreMessage *messageType); 176 177 /** 178 * Update the host client ID field in the MessageContainer. 179 * 180 * @param message Buffer containing a complete FlatBuffers CHRE message 181 * @param messageLen Size of the message, in bytes 182 * @param hostClientId The value to set the host client ID to 183 * 184 * @return true if the message was verified successfully, and we were able to 185 * modify the host client ID field 186 */ 187 static bool mutateHostClientId(void *message, size_t messageLen, 188 uint16_t hostClientId); 189 190 /** 191 * Encodes a message requesting to load a nanoapp specified by the included 192 * binary payload and metadata. 193 * 194 * @param builder A newly constructed FlatBufferBuilder that will be used to 195 * construct the message 196 */ 197 static void encodeLoadNanoappRequestForBinary( 198 flatbuffers::FlatBufferBuilder& builder, uint32_t transactionId, 199 uint64_t appId, uint32_t appVersion, uint32_t targetApiVersion, 200 const std::vector<uint8_t>& nanoappBinary, uint32_t fragmentId, 201 size_t appTotalSizeBytes); 202 203 /** 204 * Encodes a message requesting to load a nanoapp specified by the included 205 * binary filename and metadata. 206 * 207 * @param builder A newly constructed FlatBufferBuilder that will be used to 208 * construct the message 209 */ 210 static void encodeLoadNanoappRequestForFile( 211 flatbuffers::FlatBufferBuilder& builder, uint32_t transactionId, 212 uint64_t appId, uint32_t appVersion, uint32_t targetApiVersion, 213 const char *nanoappBinaryName); 214 }; 215 216 } // namespace chre 217 } // namespace android 218 219 #endif // CHRE_HOST_HOST_PROTOCOL_HOST_H_ 220