1 /*
2 * Copyright (C) 2005 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/Binder.h>
20
21 #include <assert.h>
22
23 namespace android {
24
25 // ----------------------------------------------------------------------
26
27 class IInterface : public virtual RefBase
28 {
29 public:
30 IInterface();
31 static sp<IBinder> asBinder(const IInterface*);
32 static sp<IBinder> asBinder(const sp<IInterface>&);
33
34 protected:
35 virtual ~IInterface();
36 virtual IBinder* onAsBinder() = 0;
37 };
38
39 // ----------------------------------------------------------------------
40
41 /**
42 * If this is a local object and the descriptor matches, this will return the
43 * actual local object which is implementing the interface. Otherwise, this will
44 * return a proxy to the interface without checking the interface descriptor.
45 * This means that subsequent calls may fail with BAD_TYPE.
46 */
47 template<typename INTERFACE>
interface_cast(const sp<IBinder> & obj)48 inline sp<INTERFACE> interface_cast(const sp<IBinder>& obj)
49 {
50 return INTERFACE::asInterface(obj);
51 }
52
53 /**
54 * This is the same as interface_cast, except that it always checks to make sure
55 * the descriptor matches, and if it doesn't match, it will return nullptr.
56 */
57 template<typename INTERFACE>
checked_interface_cast(const sp<IBinder> & obj)58 inline sp<INTERFACE> checked_interface_cast(const sp<IBinder>& obj)
59 {
60 if (obj->getInterfaceDescriptor() != INTERFACE::descriptor) {
61 return nullptr;
62 }
63
64 return interface_cast<INTERFACE>(obj);
65 }
66
67 // ----------------------------------------------------------------------
68
69 template<typename INTERFACE>
70 class BnInterface : public INTERFACE, public BBinder
71 {
72 public:
73 virtual sp<IInterface> queryLocalInterface(const String16& _descriptor);
74 virtual const String16& getInterfaceDescriptor() const;
75
76 protected:
77 typedef INTERFACE BaseInterface;
78 virtual IBinder* onAsBinder();
79 };
80
81 // ----------------------------------------------------------------------
82
83 template<typename INTERFACE>
84 class BpInterface : public INTERFACE, public BpRefBase
85 {
86 public:
87 explicit BpInterface(const sp<IBinder>& remote);
88
89 protected:
90 typedef INTERFACE BaseInterface;
91 virtual IBinder* onAsBinder();
92 };
93
94 // ----------------------------------------------------------------------
95
96 #define DECLARE_META_INTERFACE(INTERFACE) \
97 public: \
98 static const ::android::String16 descriptor; \
99 static ::android::sp<I##INTERFACE> asInterface(const ::android::sp<::android::IBinder>& obj); \
100 virtual const ::android::String16& getInterfaceDescriptor() const; \
101 I##INTERFACE(); \
102 virtual ~I##INTERFACE(); \
103 static bool setDefaultImpl(::android::sp<I##INTERFACE> impl); \
104 static const ::android::sp<I##INTERFACE>& getDefaultImpl(); \
105 \
106 private: \
107 static ::android::sp<I##INTERFACE> default_impl; \
108 \
109 public:
110
111 #define __IINTF_CONCAT(x, y) (x ## y)
112
113 #ifndef DO_NOT_CHECK_MANUAL_BINDER_INTERFACES
114
115 #define IMPLEMENT_META_INTERFACE(INTERFACE, NAME) \
116 static_assert(internal::allowedManualInterface(NAME), \
117 "b/64223827: Manually written binder interfaces are " \
118 "considered error prone and frequently have bugs. " \
119 "The preferred way to add interfaces is to define " \
120 "an .aidl file to auto-generate the interface. If " \
121 "an interface must be manually written, add its " \
122 "name to the whitelist."); \
123 DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(INTERFACE, NAME) \
124
125 #else
126
127 #define IMPLEMENT_META_INTERFACE(INTERFACE, NAME) \
128 DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(INTERFACE, NAME) \
129
130 #endif
131
132 // Macro to be used by both IMPLEMENT_META_INTERFACE and IMPLEMENT_META_NESTED_INTERFACE
133 #define DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE0(ITYPE, INAME, BPTYPE) \
134 const ::android::String16& ITYPE::getInterfaceDescriptor() const { return ITYPE::descriptor; } \
135 ::android::sp<ITYPE> ITYPE::asInterface(const ::android::sp<::android::IBinder>& obj) { \
136 ::android::sp<ITYPE> intr; \
137 if (obj != nullptr) { \
138 intr = ::android::sp<ITYPE>::cast(obj->queryLocalInterface(ITYPE::descriptor)); \
139 if (intr == nullptr) { \
140 intr = ::android::sp<BPTYPE>::make(obj); \
141 } \
142 } \
143 return intr; \
144 } \
145 ::android::sp<ITYPE> ITYPE::default_impl; \
146 bool ITYPE::setDefaultImpl(::android::sp<ITYPE> impl) { \
147 /* Only one user of this interface can use this function */ \
148 /* at a time. This is a heuristic to detect if two different */ \
149 /* users in the same process use this function. */ \
150 assert(!ITYPE::default_impl); \
151 if (impl) { \
152 ITYPE::default_impl = std::move(impl); \
153 return true; \
154 } \
155 return false; \
156 } \
157 const ::android::sp<ITYPE>& ITYPE::getDefaultImpl() { return ITYPE::default_impl; } \
158 ITYPE::INAME() {} \
159 ITYPE::~INAME() {}
160
161 // Macro for an interface type.
162 #define DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE(INTERFACE, NAME) \
163 const ::android::StaticString16 I##INTERFACE##_descriptor_static_str16( \
164 __IINTF_CONCAT(u, NAME)); \
165 const ::android::String16 I##INTERFACE::descriptor(I##INTERFACE##_descriptor_static_str16); \
166 DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE0(I##INTERFACE, I##INTERFACE, Bp##INTERFACE)
167
168 // Macro for "nested" interface type.
169 // For example,
170 // class Parent .. { class INested .. { }; };
171 // DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(Parent, Nested, "Parent.INested")
172 #define DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_NESTED_INTERFACE(PARENT, INTERFACE, NAME) \
173 const ::android::String16 PARENT::I##INTERFACE::descriptor(NAME); \
174 DO_NOT_DIRECTLY_USE_ME_IMPLEMENT_META_INTERFACE0(PARENT::I##INTERFACE, I##INTERFACE, \
175 PARENT::Bp##INTERFACE)
176
177 #define CHECK_INTERFACE(interface, data, reply) \
178 do { \
179 if (!(data).checkInterface(this)) { return PERMISSION_DENIED; } \
180 } while (false) \
181
182
183 // ----------------------------------------------------------------------
184 // No user-serviceable parts after this...
185
186 template<typename INTERFACE>
queryLocalInterface(const String16 & _descriptor)187 inline sp<IInterface> BnInterface<INTERFACE>::queryLocalInterface(
188 const String16& _descriptor)
189 {
190 if (_descriptor == INTERFACE::descriptor) return sp<IInterface>::fromExisting(this);
191 return nullptr;
192 }
193
194 template<typename INTERFACE>
getInterfaceDescriptor()195 inline const String16& BnInterface<INTERFACE>::getInterfaceDescriptor() const
196 {
197 return INTERFACE::getInterfaceDescriptor();
198 }
199
200 template<typename INTERFACE>
onAsBinder()201 IBinder* BnInterface<INTERFACE>::onAsBinder()
202 {
203 return this;
204 }
205
206 template<typename INTERFACE>
BpInterface(const sp<IBinder> & remote)207 inline BpInterface<INTERFACE>::BpInterface(const sp<IBinder>& remote)
208 : BpRefBase(remote)
209 {
210 }
211
212 template<typename INTERFACE>
onAsBinder()213 inline IBinder* BpInterface<INTERFACE>::onAsBinder()
214 {
215 return remote();
216 }
217
218 // ----------------------------------------------------------------------
219
220 namespace internal {
221 constexpr const char* const kManualInterfaces[] = {
222 "android.app.IActivityManager",
223 "android.app.IUidObserver",
224 "android.drm.IDrm",
225 "android.dvr.IVsyncCallback",
226 "android.dvr.IVsyncService",
227 "android.gfx.tests.ICallback",
228 "android.gfx.tests.IIPCTest",
229 "android.gfx.tests.ISafeInterfaceTest",
230 "android.graphicsenv.IGpuService",
231 "android.gui.IConsumerListener",
232 "android.gui.IGraphicBufferConsumer",
233 "android.gui.ITransactionComposerListener",
234 "android.gui.SensorEventConnection",
235 "android.gui.SensorServer",
236 "android.hardware.ICamera",
237 "android.hardware.ICameraClient",
238 "android.hardware.ICameraRecordingProxy",
239 "android.hardware.ICameraRecordingProxyListener",
240 "android.hardware.ICrypto",
241 "android.hardware.IOMXObserver",
242 "android.hardware.IStreamListener",
243 "android.hardware.IStreamSource",
244 "android.media.IAudioService",
245 "android.media.IDataSource",
246 "android.media.IDrmClient",
247 "android.media.IMediaCodecList",
248 "android.media.IMediaDrmService",
249 "android.media.IMediaExtractor",
250 "android.media.IMediaExtractorService",
251 "android.media.IMediaHTTPConnection",
252 "android.media.IMediaHTTPService",
253 "android.media.IMediaLogService",
254 "android.media.IMediaMetadataRetriever",
255 "android.media.IMediaMetricsService",
256 "android.media.IMediaPlayer",
257 "android.media.IMediaPlayerClient",
258 "android.media.IMediaPlayerService",
259 "android.media.IMediaRecorder",
260 "android.media.IMediaRecorderClient",
261 "android.media.IMediaResourceMonitor",
262 "android.media.IMediaSource",
263 "android.media.IRemoteDisplay",
264 "android.media.IRemoteDisplayClient",
265 "android.media.IResourceManagerClient",
266 "android.media.IResourceManagerService",
267 "android.os.IComplexTypeInterface",
268 "android.os.IPermissionController",
269 "android.os.IPingResponder",
270 "android.os.IProcessInfoService",
271 "android.os.ISchedulingPolicyService",
272 "android.os.IStringConstants",
273 "android.os.storage.IObbActionListener",
274 "android.os.storage.IStorageEventListener",
275 "android.os.storage.IStorageManager",
276 "android.os.storage.IStorageShutdownObserver",
277 "android.service.vr.IPersistentVrStateCallbacks",
278 "android.service.vr.IVrManager",
279 "android.service.vr.IVrStateCallbacks",
280 "android.ui.ISurfaceComposer",
281 "android.ui.ISurfaceComposerClient",
282 "android.utils.IMemory",
283 "android.utils.IMemoryHeap",
284 "com.android.car.procfsinspector.IProcfsInspector",
285 "com.android.internal.app.IAppOpsCallback",
286 "com.android.internal.app.IAppOpsService",
287 "com.android.internal.app.IBatteryStats",
288 "com.android.internal.os.IResultReceiver",
289 "com.android.internal.os.IShellCallback",
290 "drm.IDrmManagerService",
291 "drm.IDrmServiceListener",
292 "IAAudioClient",
293 "IAAudioService",
294 "VtsFuzzer",
295 nullptr,
296 };
297
298 constexpr const char* const kDownstreamManualInterfaces[] = {
299 // Add downstream interfaces here.
300 nullptr,
301 };
302
equals(const char * a,const char * b)303 constexpr bool equals(const char* a, const char* b) {
304 if (*a != *b) return false;
305 if (*a == '\0') return true;
306 return equals(a + 1, b + 1);
307 }
308
inList(const char * a,const char * const * whitelist)309 constexpr bool inList(const char* a, const char* const* whitelist) {
310 if (*whitelist == nullptr) return false;
311 if (equals(a, *whitelist)) return true;
312 return inList(a, whitelist + 1);
313 }
314
allowedManualInterface(const char * name)315 constexpr bool allowedManualInterface(const char* name) {
316 return inList(name, kManualInterfaces) ||
317 inList(name, kDownstreamManualInterfaces);
318 }
319
320 } // namespace internal
321 } // namespace android
322