1 /* 2 * Copyright 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #pragma once 18 19 #include <binder/IInterface.h> 20 #include <binder/Parcel.h> 21 #include <cutils/compiler.h> 22 23 // Set to 1 to enable CallStacks when logging errors 24 #define SI_DUMP_CALLSTACKS 0 25 #if SI_DUMP_CALLSTACKS 26 #include <utils/CallStack.h> 27 #endif 28 29 #include <utils/NativeHandle.h> 30 31 #include <functional> 32 #include <type_traits> 33 34 namespace android { 35 namespace SafeInterface { 36 37 // ParcelHandler is responsible for writing/reading various types to/from a Parcel in a generic way 38 class ParcelHandler { 39 public: 40 explicit ParcelHandler(const char* logTag) : mLogTag(logTag) {} 41 42 // Specializations for types with dedicated handling in Parcel 43 status_t read(const Parcel& parcel, bool* b) const { 44 return callParcel("readBool", [&]() { return parcel.readBool(b); }); 45 } 46 status_t write(Parcel* parcel, bool b) const { 47 return callParcel("writeBool", [&]() { return parcel->writeBool(b); }); 48 } 49 template <typename E> 50 typename std::enable_if<std::is_enum<E>::value, status_t>::type read(const Parcel& parcel, 51 E* e) const { 52 typename std::underlying_type<E>::type u{}; 53 status_t result = read(parcel, &u); 54 *e = static_cast<E>(u); 55 return result; 56 } 57 template <typename E> 58 typename std::enable_if<std::is_enum<E>::value, status_t>::type write(Parcel* parcel, 59 E e) const { 60 return write(parcel, static_cast<typename std::underlying_type<E>::type>(e)); 61 } 62 template <typename T> 63 typename std::enable_if<std::is_base_of<Flattenable<T>, T>::value, status_t>::type read( 64 const Parcel& parcel, T* t) const { 65 return callParcel("read(Flattenable)", [&]() { return parcel.read(*t); }); 66 } 67 template <typename T> 68 typename std::enable_if<std::is_base_of<Flattenable<T>, T>::value, status_t>::type write( 69 Parcel* parcel, const T& t) const { 70 return callParcel("write(Flattenable)", [&]() { return parcel->write(t); }); 71 } 72 template <typename T> 73 typename std::enable_if<std::is_base_of<Flattenable<T>, T>::value, status_t>::type read( 74 const Parcel& parcel, sp<T>* t) const { 75 *t = new T{}; 76 return callParcel("read(sp<Flattenable>)", [&]() { return parcel.read(*(t->get())); }); 77 } 78 template <typename T> 79 typename std::enable_if<std::is_base_of<Flattenable<T>, T>::value, status_t>::type write( 80 Parcel* parcel, const sp<T>& t) const { 81 return callParcel("write(sp<Flattenable>)", [&]() { return parcel->write(*(t.get())); }); 82 } 83 template <typename T> 84 typename std::enable_if<std::is_base_of<LightFlattenable<T>, T>::value, status_t>::type read( 85 const Parcel& parcel, T* t) const { 86 return callParcel("read(LightFlattenable)", [&]() { return parcel.read(*t); }); 87 } 88 template <typename T> 89 typename std::enable_if<std::is_base_of<LightFlattenable<T>, T>::value, status_t>::type write( 90 Parcel* parcel, const T& t) const { 91 return callParcel("write(LightFlattenable)", [&]() { return parcel->write(t); }); 92 } 93 template <typename NH> 94 typename std::enable_if<std::is_same<NH, sp<NativeHandle>>::value, status_t>::type read( 95 const Parcel& parcel, NH* nh) { 96 *nh = NativeHandle::create(parcel.readNativeHandle(), true); 97 return NO_ERROR; 98 } 99 template <typename NH> 100 typename std::enable_if<std::is_same<NH, sp<NativeHandle>>::value, status_t>::type write( 101 Parcel* parcel, const NH& nh) { 102 return callParcel("write(sp<NativeHandle>)", 103 [&]() { return parcel->writeNativeHandle(nh->handle()); }); 104 } 105 template <typename T> 106 typename std::enable_if<std::is_base_of<Parcelable, T>::value, status_t>::type read( 107 const Parcel& parcel, T* t) const { 108 return callParcel("readParcelable", [&]() { return parcel.readParcelable(t); }); 109 } 110 template <typename T> 111 typename std::enable_if<std::is_base_of<Parcelable, T>::value, status_t>::type write( 112 Parcel* parcel, const T& t) const { 113 return callParcel("writeParcelable", [&]() { return parcel->writeParcelable(t); }); 114 } 115 status_t read(const Parcel& parcel, String8* str) const { 116 return callParcel("readString8", [&]() { return parcel.readString8(str); }); 117 } 118 status_t write(Parcel* parcel, const String8& str) const { 119 return callParcel("writeString8", [&]() { return parcel->writeString8(str); }); 120 } 121 template <typename T> 122 typename std::enable_if<std::is_same<IBinder, T>::value, status_t>::type read( 123 const Parcel& parcel, sp<T>* pointer) const { 124 return callParcel("readNullableStrongBinder", 125 [&]() { return parcel.readNullableStrongBinder(pointer); }); 126 } 127 template <typename T> 128 typename std::enable_if<std::is_same<IBinder, T>::value, status_t>::type write( 129 Parcel* parcel, const sp<T>& pointer) const { 130 return callParcel("writeStrongBinder", 131 [&]() { return parcel->writeStrongBinder(pointer); }); 132 } 133 template <typename T> 134 typename std::enable_if<std::is_base_of<IInterface, T>::value, status_t>::type read( 135 const Parcel& parcel, sp<T>* pointer) const { 136 return callParcel("readNullableStrongBinder[IInterface]", 137 [&]() { return parcel.readNullableStrongBinder(pointer); }); 138 } 139 template <typename T> 140 typename std::enable_if<std::is_base_of<IInterface, T>::value, status_t>::type write( 141 Parcel* parcel, const sp<T>& interface) const { 142 return write(parcel, IInterface::asBinder(interface)); 143 } 144 template <typename T> 145 typename std::enable_if<std::is_base_of<Parcelable, T>::value, status_t>::type read( 146 const Parcel& parcel, std::vector<T>* v) const { 147 return callParcel("readParcelableVector", [&]() { return parcel.readParcelableVector(v); }); 148 } 149 template <typename T> 150 typename std::enable_if<std::is_base_of<Parcelable, T>::value, status_t>::type write( 151 Parcel* parcel, const std::vector<T>& v) const { 152 return callParcel("writeParcelableVector", 153 [&]() { return parcel->writeParcelableVector(v); }); 154 } 155 156 // Templates to handle integral types. We use a struct template to require that the called 157 // function exactly matches the signedness and size of the argument (e.g., the argument isn't 158 // silently widened). 159 template <bool isSigned, size_t size, typename I> 160 struct HandleInt; 161 template <typename I> 162 struct HandleInt<true, 4, I> { 163 static status_t read(const ParcelHandler& handler, const Parcel& parcel, I* i) { 164 return handler.callParcel("readInt32", [&]() { return parcel.readInt32(i); }); 165 } 166 static status_t write(const ParcelHandler& handler, Parcel* parcel, I i) { 167 return handler.callParcel("writeInt32", [&]() { return parcel->writeInt32(i); }); 168 } 169 }; 170 template <typename I> 171 struct HandleInt<false, 4, I> { 172 static status_t read(const ParcelHandler& handler, const Parcel& parcel, I* i) { 173 return handler.callParcel("readUint32", [&]() { return parcel.readUint32(i); }); 174 } 175 static status_t write(const ParcelHandler& handler, Parcel* parcel, I i) { 176 return handler.callParcel("writeUint32", [&]() { return parcel->writeUint32(i); }); 177 } 178 }; 179 template <typename I> 180 struct HandleInt<true, 8, I> { 181 static status_t read(const ParcelHandler& handler, const Parcel& parcel, I* i) { 182 return handler.callParcel("readInt64", [&]() { return parcel.readInt64(i); }); 183 } 184 static status_t write(const ParcelHandler& handler, Parcel* parcel, I i) { 185 return handler.callParcel("writeInt64", [&]() { return parcel->writeInt64(i); }); 186 } 187 }; 188 template <typename I> 189 struct HandleInt<false, 8, I> { 190 static status_t read(const ParcelHandler& handler, const Parcel& parcel, I* i) { 191 return handler.callParcel("readUint64", [&]() { return parcel.readUint64(i); }); 192 } 193 static status_t write(const ParcelHandler& handler, Parcel* parcel, I i) { 194 return handler.callParcel("writeUint64", [&]() { return parcel->writeUint64(i); }); 195 } 196 }; 197 template <typename I> 198 typename std::enable_if<std::is_integral<I>::value, status_t>::type read(const Parcel& parcel, 199 I* i) const { 200 return HandleInt<std::is_signed<I>::value, sizeof(I), I>::read(*this, parcel, i); 201 } 202 template <typename I> 203 typename std::enable_if<std::is_integral<I>::value, status_t>::type write(Parcel* parcel, 204 I i) const { 205 return HandleInt<std::is_signed<I>::value, sizeof(I), I>::write(*this, parcel, i); 206 } 207 208 private: 209 const char* const mLogTag; 210 211 // Helper to encapsulate error handling while calling the various Parcel methods 212 template <typename Function> 213 status_t callParcel(const char* name, Function f) const { 214 status_t error = f(); 215 if (CC_UNLIKELY(error != NO_ERROR)) { 216 ALOG(LOG_ERROR, mLogTag, "Failed to %s, (%d: %s)", name, error, strerror(-error)); 217 #if SI_DUMP_CALLSTACKS 218 CallStack callStack(mLogTag); 219 #endif 220 } 221 return error; 222 } 223 }; 224 225 // Utility struct template which allows us to retrieve the types of the parameters of a member 226 // function pointer 227 template <typename T> 228 struct ParamExtractor; 229 template <typename Class, typename Return, typename... Params> 230 struct ParamExtractor<Return (Class::*)(Params...)> { 231 using ParamTuple = std::tuple<Params...>; 232 }; 233 template <typename Class, typename Return, typename... Params> 234 struct ParamExtractor<Return (Class::*)(Params...) const> { 235 using ParamTuple = std::tuple<Params...>; 236 }; 237 238 } // namespace SafeInterface 239 240 template <typename Interface> 241 class SafeBpInterface : public BpInterface<Interface> { 242 protected: 243 SafeBpInterface(const sp<IBinder>& impl, const char* logTag) 244 : BpInterface<Interface>(impl), mLogTag(logTag) {} 245 ~SafeBpInterface() override = default; 246 247 // callRemote is used to invoke a synchronous procedure call over Binder 248 template <typename Method, typename TagType, typename... Args> 249 status_t callRemote(TagType tag, Args&&... args) const { 250 static_assert(sizeof(TagType) <= sizeof(uint32_t), "Tag must fit inside uint32_t"); 251 252 // Verify that the arguments are compatible with the parameters 253 using ParamTuple = typename SafeInterface::ParamExtractor<Method>::ParamTuple; 254 static_assert(ArgsMatchParams<std::tuple<Args...>, ParamTuple>::value, 255 "Invalid argument type"); 256 257 // Write the input arguments to the data Parcel 258 Parcel data; 259 data.writeInterfaceToken(this->getInterfaceDescriptor()); 260 261 status_t error = writeInputs(&data, std::forward<Args>(args)...); 262 if (CC_UNLIKELY(error != NO_ERROR)) { 263 // A message will have been logged by writeInputs 264 return error; 265 } 266 267 // Send the data Parcel to the remote and retrieve the reply parcel 268 Parcel reply; 269 error = this->remote()->transact(static_cast<uint32_t>(tag), data, &reply); 270 if (CC_UNLIKELY(error != NO_ERROR)) { 271 ALOG(LOG_ERROR, mLogTag, "Failed to transact (%d)", error); 272 #if SI_DUMP_CALLSTACKS 273 CallStack callStack(mLogTag); 274 #endif 275 return error; 276 } 277 278 // Read the outputs from the reply Parcel into the output arguments 279 error = readOutputs(reply, std::forward<Args>(args)...); 280 if (CC_UNLIKELY(error != NO_ERROR)) { 281 // A message will have been logged by readOutputs 282 return error; 283 } 284 285 // Retrieve the result code from the reply Parcel 286 status_t result = NO_ERROR; 287 error = reply.readInt32(&result); 288 if (CC_UNLIKELY(error != NO_ERROR)) { 289 ALOG(LOG_ERROR, mLogTag, "Failed to obtain result"); 290 #if SI_DUMP_CALLSTACKS 291 CallStack callStack(mLogTag); 292 #endif 293 return error; 294 } 295 return result; 296 } 297 298 // callRemoteAsync is used to invoke an asynchronous procedure call over Binder 299 template <typename Method, typename TagType, typename... Args> 300 void callRemoteAsync(TagType tag, Args&&... args) const { 301 static_assert(sizeof(TagType) <= sizeof(uint32_t), "Tag must fit inside uint32_t"); 302 303 // Verify that the arguments are compatible with the parameters 304 using ParamTuple = typename SafeInterface::ParamExtractor<Method>::ParamTuple; 305 static_assert(ArgsMatchParams<std::tuple<Args...>, ParamTuple>::value, 306 "Invalid argument type"); 307 308 // Write the input arguments to the data Parcel 309 Parcel data; 310 data.writeInterfaceToken(this->getInterfaceDescriptor()); 311 status_t error = writeInputs(&data, std::forward<Args>(args)...); 312 if (CC_UNLIKELY(error != NO_ERROR)) { 313 // A message will have been logged by writeInputs 314 return; 315 } 316 317 // There will be no data in the reply Parcel since the call is one-way 318 Parcel reply; 319 error = this->remote()->transact(static_cast<uint32_t>(tag), data, &reply, 320 IBinder::FLAG_ONEWAY); 321 if (CC_UNLIKELY(error != NO_ERROR)) { 322 ALOG(LOG_ERROR, mLogTag, "Failed to transact (%d)", error); 323 #if SI_DUMP_CALLSTACKS 324 CallStack callStack(mLogTag); 325 #endif 326 } 327 } 328 329 private: 330 const char* const mLogTag; 331 332 // This struct provides information on whether the decayed types of the elements at Index in the 333 // tuple types T and U (that is, the types after stripping cv-qualifiers, removing references, 334 // and a few other less common operations) are the same 335 template <size_t Index, typename T, typename U> 336 struct DecayedElementsMatch { 337 private: 338 using FirstT = typename std::tuple_element<Index, T>::type; 339 using DecayedT = typename std::decay<FirstT>::type; 340 using FirstU = typename std::tuple_element<Index, U>::type; 341 using DecayedU = typename std::decay<FirstU>::type; 342 343 public: 344 static constexpr bool value = std::is_same<DecayedT, DecayedU>::value; 345 }; 346 347 // When comparing whether the argument types match the parameter types, we first decay them (see 348 // DecayedElementsMatch) to avoid falsely flagging, say, T&& against T even though they are 349 // equivalent enough for our purposes 350 template <typename T, typename U> 351 struct ArgsMatchParams {}; 352 template <typename... Args, typename... Params> 353 struct ArgsMatchParams<std::tuple<Args...>, std::tuple<Params...>> { 354 static_assert(sizeof...(Args) <= sizeof...(Params), "Too many arguments"); 355 static_assert(sizeof...(Args) >= sizeof...(Params), "Not enough arguments"); 356 357 private: 358 template <size_t Index> 359 static constexpr typename std::enable_if<(Index < sizeof...(Args)), bool>::type 360 elementsMatch() { 361 if (!DecayedElementsMatch<Index, std::tuple<Args...>, std::tuple<Params...>>::value) { 362 return false; 363 } 364 return elementsMatch<Index + 1>(); 365 } 366 template <size_t Index> 367 static constexpr typename std::enable_if<(Index >= sizeof...(Args)), bool>::type 368 elementsMatch() { 369 return true; 370 } 371 372 public: 373 static constexpr bool value = elementsMatch<0>(); 374 }; 375 376 // Since we assume that pointer arguments are outputs, we can use this template struct to 377 // determine whether or not a given argument is fundamentally a pointer type and thus an output 378 template <typename T> 379 struct IsPointerIfDecayed { 380 private: 381 using Decayed = typename std::decay<T>::type; 382 383 public: 384 static constexpr bool value = std::is_pointer<Decayed>::value; 385 }; 386 387 template <typename T> 388 typename std::enable_if<!IsPointerIfDecayed<T>::value, status_t>::type writeIfInput( 389 Parcel* data, T&& t) const { 390 return SafeInterface::ParcelHandler{mLogTag}.write(data, std::forward<T>(t)); 391 } 392 template <typename T> 393 typename std::enable_if<IsPointerIfDecayed<T>::value, status_t>::type writeIfInput( 394 Parcel* /*data*/, T&& /*t*/) const { 395 return NO_ERROR; 396 } 397 398 // This method iterates through all of the arguments, writing them to the data Parcel if they 399 // are an input (i.e., if they are not a pointer type) 400 template <typename T, typename... Remaining> 401 status_t writeInputs(Parcel* data, T&& t, Remaining&&... remaining) const { 402 status_t error = writeIfInput(data, std::forward<T>(t)); 403 if (CC_UNLIKELY(error != NO_ERROR)) { 404 // A message will have been logged by writeIfInput 405 return error; 406 } 407 return writeInputs(data, std::forward<Remaining>(remaining)...); 408 } 409 static status_t writeInputs(Parcel* /*data*/) { return NO_ERROR; } 410 411 template <typename T> 412 typename std::enable_if<IsPointerIfDecayed<T>::value, status_t>::type readIfOutput( 413 const Parcel& reply, T&& t) const { 414 return SafeInterface::ParcelHandler{mLogTag}.read(reply, std::forward<T>(t)); 415 } 416 template <typename T> 417 static typename std::enable_if<!IsPointerIfDecayed<T>::value, status_t>::type readIfOutput( 418 const Parcel& /*reply*/, T&& /*t*/) { 419 return NO_ERROR; 420 } 421 422 // Similar to writeInputs except that it reads output arguments from the reply Parcel 423 template <typename T, typename... Remaining> 424 status_t readOutputs(const Parcel& reply, T&& t, Remaining&&... remaining) const { 425 status_t error = readIfOutput(reply, std::forward<T>(t)); 426 if (CC_UNLIKELY(error != NO_ERROR)) { 427 // A message will have been logged by readIfOutput 428 return error; 429 } 430 return readOutputs(reply, std::forward<Remaining>(remaining)...); 431 } 432 static status_t readOutputs(const Parcel& /*data*/) { return NO_ERROR; } 433 }; 434 435 template <typename Interface> 436 class SafeBnInterface : public BnInterface<Interface> { 437 public: 438 explicit SafeBnInterface(const char* logTag) : mLogTag(logTag) {} 439 440 protected: 441 template <typename Method> 442 status_t callLocal(const Parcel& data, Parcel* reply, Method method) { 443 CHECK_INTERFACE(this, data, reply); 444 445 // Since we need to both pass inputs into the call as well as retrieve outputs, we create a 446 // "raw" tuple, where the inputs are interleaved with actual, non-pointer versions of the 447 // outputs. When we ultimately call into the method, we will pass the addresses of the 448 // output arguments instead of their tuple members directly, but the storage will live in 449 // the tuple. 450 using ParamTuple = typename SafeInterface::ParamExtractor<Method>::ParamTuple; 451 typename RawConverter<std::tuple<>, ParamTuple>::type rawArgs{}; 452 453 // Read the inputs from the data Parcel into the argument tuple 454 status_t error = InputReader<ParamTuple>{mLogTag}.readInputs(data, &rawArgs); 455 if (CC_UNLIKELY(error != NO_ERROR)) { 456 // A message will have been logged by read 457 return error; 458 } 459 460 // Call the local method 461 status_t result = MethodCaller<ParamTuple>::call(this, method, &rawArgs); 462 463 // Extract the outputs from the argument tuple and write them into the reply Parcel 464 error = OutputWriter<ParamTuple>{mLogTag}.writeOutputs(reply, &rawArgs); 465 if (CC_UNLIKELY(error != NO_ERROR)) { 466 // A message will have been logged by write 467 return error; 468 } 469 470 // Return the result code in the reply Parcel 471 error = reply->writeInt32(result); 472 if (CC_UNLIKELY(error != NO_ERROR)) { 473 ALOG(LOG_ERROR, mLogTag, "Failed to write result"); 474 #if SI_DUMP_CALLSTACKS 475 CallStack callStack(mLogTag); 476 #endif 477 return error; 478 } 479 return NO_ERROR; 480 } 481 482 template <typename Method> 483 status_t callLocalAsync(const Parcel& data, Parcel* /*reply*/, Method method) { 484 // reply is not actually used by CHECK_INTERFACE 485 CHECK_INTERFACE(this, data, reply); 486 487 // Since we need to both pass inputs into the call as well as retrieve outputs, we create a 488 // "raw" tuple, where the inputs are interleaved with actual, non-pointer versions of the 489 // outputs. When we ultimately call into the method, we will pass the addresses of the 490 // output arguments instead of their tuple members directly, but the storage will live in 491 // the tuple. 492 using ParamTuple = typename SafeInterface::ParamExtractor<Method>::ParamTuple; 493 typename RawConverter<std::tuple<>, ParamTuple>::type rawArgs{}; 494 495 // Read the inputs from the data Parcel into the argument tuple 496 status_t error = InputReader<ParamTuple>{mLogTag}.readInputs(data, &rawArgs); 497 if (CC_UNLIKELY(error != NO_ERROR)) { 498 // A message will have been logged by read 499 return error; 500 } 501 502 // Call the local method 503 MethodCaller<ParamTuple>::callVoid(this, method, &rawArgs); 504 505 // After calling, there is nothing more to do since asynchronous calls do not return a value 506 // to the caller 507 return NO_ERROR; 508 } 509 510 private: 511 const char* const mLogTag; 512 513 // RemoveFirst strips the first element from a tuple. 514 // For example, given T = std::tuple<A, B, C>, RemoveFirst<T>::type = std::tuple<B, C> 515 template <typename T, typename... Args> 516 struct RemoveFirst; 517 template <typename T, typename... Args> 518 struct RemoveFirst<std::tuple<T, Args...>> { 519 using type = std::tuple<Args...>; 520 }; 521 522 // RawConverter strips a tuple down to its fundamental types, discarding both pointers and 523 // references. This allows us to allocate storage for both input (non-pointer) arguments and 524 // output (pointer) arguments in one tuple. 525 // For example, given T = std::tuple<const A&, B*>, RawConverter<T>::type = std::tuple<A, B> 526 template <typename Unconverted, typename... Converted> 527 struct RawConverter; 528 template <typename Unconverted, typename... Converted> 529 struct RawConverter<std::tuple<Converted...>, Unconverted> { 530 private: 531 using ElementType = typename std::tuple_element<0, Unconverted>::type; 532 using Decayed = typename std::decay<ElementType>::type; 533 using WithoutPointer = typename std::remove_pointer<Decayed>::type; 534 535 public: 536 using type = typename RawConverter<std::tuple<Converted..., WithoutPointer>, 537 typename RemoveFirst<Unconverted>::type>::type; 538 }; 539 template <typename... Converted> 540 struct RawConverter<std::tuple<Converted...>, std::tuple<>> { 541 using type = std::tuple<Converted...>; 542 }; 543 544 // This provides a simple way to determine whether the indexed element of Args... is a pointer 545 template <size_t I, typename... Args> 546 struct ElementIsPointer { 547 private: 548 using ElementType = typename std::tuple_element<I, std::tuple<Args...>>::type; 549 550 public: 551 static constexpr bool value = std::is_pointer<ElementType>::value; 552 }; 553 554 // This class iterates over the parameter types, and if a given parameter is an input 555 // (i.e., is not a pointer), reads the corresponding argument tuple element from the data Parcel 556 template <typename... Params> 557 class InputReader; 558 template <typename... Params> 559 class InputReader<std::tuple<Params...>> { 560 public: 561 explicit InputReader(const char* logTag) : mLogTag(logTag) {} 562 563 // Note that in this case (as opposed to in SafeBpInterface), we iterate using an explicit 564 // index (starting with 0 here) instead of using recursion and stripping the first element. 565 // This is because in SafeBpInterface we aren't actually operating on a real tuple, but are 566 // instead just using a tuple as a convenient container for variadic types, whereas here we 567 // can't modify the argument tuple without causing unnecessary copies or moves of the data 568 // contained therein. 569 template <typename RawTuple> 570 status_t readInputs(const Parcel& data, RawTuple* args) { 571 return dispatchArg<0>(data, args); 572 } 573 574 private: 575 const char* const mLogTag; 576 577 template <std::size_t I, typename RawTuple> 578 typename std::enable_if<!ElementIsPointer<I, Params...>::value, status_t>::type readIfInput( 579 const Parcel& data, RawTuple* args) { 580 return SafeInterface::ParcelHandler{mLogTag}.read(data, &std::get<I>(*args)); 581 } 582 template <std::size_t I, typename RawTuple> 583 typename std::enable_if<ElementIsPointer<I, Params...>::value, status_t>::type readIfInput( 584 const Parcel& /*data*/, RawTuple* /*args*/) { 585 return NO_ERROR; 586 } 587 588 // Recursively iterate through the arguments 589 template <std::size_t I, typename RawTuple> 590 typename std::enable_if<(I < sizeof...(Params)), status_t>::type dispatchArg( 591 const Parcel& data, RawTuple* args) { 592 status_t error = readIfInput<I>(data, args); 593 if (CC_UNLIKELY(error != NO_ERROR)) { 594 // A message will have been logged in read 595 return error; 596 } 597 return dispatchArg<I + 1>(data, args); 598 } 599 template <std::size_t I, typename RawTuple> 600 typename std::enable_if<(I >= sizeof...(Params)), status_t>::type dispatchArg( 601 const Parcel& /*data*/, RawTuple* /*args*/) { 602 return NO_ERROR; 603 } 604 }; 605 606 // getForCall uses the types of the parameters to determine whether a given element of the 607 // argument tuple is an input, which should be passed directly into the call, or an output, for 608 // which its address should be passed into the call 609 template <size_t I, typename RawTuple, typename... Params> 610 static typename std::enable_if< 611 ElementIsPointer<I, Params...>::value, 612 typename std::tuple_element<I, std::tuple<Params...>>::type>::type 613 getForCall(RawTuple* args) { 614 return &std::get<I>(*args); 615 } 616 template <size_t I, typename RawTuple, typename... Params> 617 static typename std::enable_if< 618 !ElementIsPointer<I, Params...>::value, 619 typename std::tuple_element<I, std::tuple<Params...>>::type>::type& 620 getForCall(RawTuple* args) { 621 return std::get<I>(*args); 622 } 623 624 // This template class uses std::index_sequence and parameter pack expansion to call the given 625 // method using the elements of the argument tuple (after those arguments are passed through 626 // getForCall to get addresses instead of values for output arguments) 627 template <typename... Params> 628 struct MethodCaller; 629 template <typename... Params> 630 struct MethodCaller<std::tuple<Params...>> { 631 public: 632 // The calls through these to the helper methods are necessary to generate the 633 // std::index_sequences used to unpack the argument tuple into the method call 634 template <typename Class, typename MemberFunction, typename RawTuple> 635 static status_t call(Class* instance, MemberFunction function, RawTuple* args) { 636 return callHelper(instance, function, args, std::index_sequence_for<Params...>{}); 637 } 638 template <typename Class, typename MemberFunction, typename RawTuple> 639 static void callVoid(Class* instance, MemberFunction function, RawTuple* args) { 640 callVoidHelper(instance, function, args, std::index_sequence_for<Params...>{}); 641 } 642 643 private: 644 template <typename Class, typename MemberFunction, typename RawTuple, std::size_t... I> 645 static status_t callHelper(Class* instance, MemberFunction function, RawTuple* args, 646 std::index_sequence<I...> /*unused*/) { 647 return (instance->*function)(getForCall<I, RawTuple, Params...>(args)...); 648 } 649 template <typename Class, typename MemberFunction, typename RawTuple, std::size_t... I> 650 static void callVoidHelper(Class* instance, MemberFunction function, RawTuple* args, 651 std::index_sequence<I...> /*unused*/) { 652 (instance->*function)(getForCall<I, RawTuple, Params...>(args)...); 653 } 654 }; 655 656 // This class iterates over the parameter types, and if a given parameter is an output 657 // (i.e., is a pointer), writes the corresponding argument tuple element into the reply Parcel 658 template <typename... Params> 659 struct OutputWriter; 660 template <typename... Params> 661 struct OutputWriter<std::tuple<Params...>> { 662 public: 663 explicit OutputWriter(const char* logTag) : mLogTag(logTag) {} 664 665 // See the note on InputReader::readInputs for why this differs from the arguably simpler 666 // RemoveFirst approach in SafeBpInterface 667 template <typename RawTuple> 668 status_t writeOutputs(Parcel* reply, RawTuple* args) { 669 return dispatchArg<0>(reply, args); 670 } 671 672 private: 673 const char* const mLogTag; 674 675 template <std::size_t I, typename RawTuple> 676 typename std::enable_if<ElementIsPointer<I, Params...>::value, status_t>::type 677 writeIfOutput(Parcel* reply, RawTuple* args) { 678 return SafeInterface::ParcelHandler{mLogTag}.write(reply, std::get<I>(*args)); 679 } 680 template <std::size_t I, typename RawTuple> 681 typename std::enable_if<!ElementIsPointer<I, Params...>::value, status_t>::type 682 writeIfOutput(Parcel* /*reply*/, RawTuple* /*args*/) { 683 return NO_ERROR; 684 } 685 686 // Recursively iterate through the arguments 687 template <std::size_t I, typename RawTuple> 688 typename std::enable_if<(I < sizeof...(Params)), status_t>::type dispatchArg( 689 Parcel* reply, RawTuple* args) { 690 status_t error = writeIfOutput<I>(reply, args); 691 if (CC_UNLIKELY(error != NO_ERROR)) { 692 // A message will have been logged in read 693 return error; 694 } 695 return dispatchArg<I + 1>(reply, args); 696 } 697 template <std::size_t I, typename RawTuple> 698 typename std::enable_if<(I >= sizeof...(Params)), status_t>::type dispatchArg( 699 Parcel* /*reply*/, RawTuple* /*args*/) { 700 return NO_ERROR; 701 } 702 }; 703 }; 704 705 } // namespace android 706
