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 #define LOG_TAG "ServiceManager"
18
19 #include <binder/IServiceManager.h>
20
21 #include <utils/Debug.h>
22 #include <utils/Log.h>
23 #include <binder/IPCThreadState.h>
24 #include <binder/Parcel.h>
25 #include <utils/String8.h>
26 #include <utils/SystemClock.h>
27
28 #include <private/binder/Static.h>
29
30 #include <unistd.h>
31
32 namespace android {
33
defaultServiceManager()34 sp<IServiceManager> defaultServiceManager()
35 {
36 if (gDefaultServiceManager != NULL) return gDefaultServiceManager;
37
38 {
39 AutoMutex _l(gDefaultServiceManagerLock);
40 if (gDefaultServiceManager == NULL) {
41 gDefaultServiceManager = interface_cast<IServiceManager>(
42 ProcessState::self()->getContextObject(NULL));
43 }
44 }
45
46 return gDefaultServiceManager;
47 }
48
checkCallingPermission(const String16 & permission)49 bool checkCallingPermission(const String16& permission)
50 {
51 return checkCallingPermission(permission, NULL, NULL);
52 }
53
54 static String16 _permission("permission");
55
56
checkCallingPermission(const String16 & permission,int32_t * outPid,int32_t * outUid)57 bool checkCallingPermission(const String16& permission, int32_t* outPid, int32_t* outUid)
58 {
59 IPCThreadState* ipcState = IPCThreadState::self();
60 pid_t pid = ipcState->getCallingPid();
61 uid_t uid = ipcState->getCallingUid();
62 if (outPid) *outPid = pid;
63 if (outUid) *outUid = uid;
64 return checkPermission(permission, pid, uid);
65 }
66
checkPermission(const String16 & permission,pid_t pid,uid_t uid)67 bool checkPermission(const String16& permission, pid_t pid, uid_t uid)
68 {
69 sp<IPermissionController> pc;
70 gDefaultServiceManagerLock.lock();
71 pc = gPermissionController;
72 gDefaultServiceManagerLock.unlock();
73
74 int64_t startTime = 0;
75
76 while (true) {
77 if (pc != NULL) {
78 bool res = pc->checkPermission(permission, pid, uid);
79 if (res) {
80 if (startTime != 0) {
81 ALOGI("Check passed after %d seconds for %s from uid=%d pid=%d",
82 (int)((uptimeMillis()-startTime)/1000),
83 String8(permission).string(), uid, pid);
84 }
85 return res;
86 }
87
88 // Is this a permission failure, or did the controller go away?
89 if (pc->asBinder()->isBinderAlive()) {
90 ALOGW("Permission failure: %s from uid=%d pid=%d",
91 String8(permission).string(), uid, pid);
92 return false;
93 }
94
95 // Object is dead!
96 gDefaultServiceManagerLock.lock();
97 if (gPermissionController == pc) {
98 gPermissionController = NULL;
99 }
100 gDefaultServiceManagerLock.unlock();
101 }
102
103 // Need to retrieve the permission controller.
104 sp<IBinder> binder = defaultServiceManager()->checkService(_permission);
105 if (binder == NULL) {
106 // Wait for the permission controller to come back...
107 if (startTime == 0) {
108 startTime = uptimeMillis();
109 ALOGI("Waiting to check permission %s from uid=%d pid=%d",
110 String8(permission).string(), uid, pid);
111 }
112 sleep(1);
113 } else {
114 pc = interface_cast<IPermissionController>(binder);
115 // Install the new permission controller, and try again.
116 gDefaultServiceManagerLock.lock();
117 gPermissionController = pc;
118 gDefaultServiceManagerLock.unlock();
119 }
120 }
121 }
122
123 // ----------------------------------------------------------------------
124
125 class BpServiceManager : public BpInterface<IServiceManager>
126 {
127 public:
BpServiceManager(const sp<IBinder> & impl)128 BpServiceManager(const sp<IBinder>& impl)
129 : BpInterface<IServiceManager>(impl)
130 {
131 }
132
getService(const String16 & name) const133 virtual sp<IBinder> getService(const String16& name) const
134 {
135 unsigned n;
136 for (n = 0; n < 5; n++){
137 sp<IBinder> svc = checkService(name);
138 if (svc != NULL) return svc;
139 ALOGI("Waiting for service %s...\n", String8(name).string());
140 sleep(1);
141 }
142 return NULL;
143 }
144
checkService(const String16 & name) const145 virtual sp<IBinder> checkService( const String16& name) const
146 {
147 Parcel data, reply;
148 data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
149 data.writeString16(name);
150 remote()->transact(CHECK_SERVICE_TRANSACTION, data, &reply);
151 return reply.readStrongBinder();
152 }
153
addService(const String16 & name,const sp<IBinder> & service,bool allowIsolated)154 virtual status_t addService(const String16& name, const sp<IBinder>& service,
155 bool allowIsolated)
156 {
157 Parcel data, reply;
158 data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
159 data.writeString16(name);
160 data.writeStrongBinder(service);
161 data.writeInt32(allowIsolated ? 1 : 0);
162 status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);
163 return err == NO_ERROR ? reply.readExceptionCode() : err;
164 }
165
listServices()166 virtual Vector<String16> listServices()
167 {
168 Vector<String16> res;
169 int n = 0;
170
171 for (;;) {
172 Parcel data, reply;
173 data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
174 data.writeInt32(n++);
175 status_t err = remote()->transact(LIST_SERVICES_TRANSACTION, data, &reply);
176 if (err != NO_ERROR)
177 break;
178 res.add(reply.readString16());
179 }
180 return res;
181 }
182 };
183
184 IMPLEMENT_META_INTERFACE(ServiceManager, "android.os.IServiceManager");
185
186 // ----------------------------------------------------------------------
187
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)188 status_t BnServiceManager::onTransact(
189 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
190 {
191 //printf("ServiceManager received: "); data.print();
192 switch(code) {
193 case GET_SERVICE_TRANSACTION: {
194 CHECK_INTERFACE(IServiceManager, data, reply);
195 String16 which = data.readString16();
196 sp<IBinder> b = const_cast<BnServiceManager*>(this)->getService(which);
197 reply->writeStrongBinder(b);
198 return NO_ERROR;
199 } break;
200 case CHECK_SERVICE_TRANSACTION: {
201 CHECK_INTERFACE(IServiceManager, data, reply);
202 String16 which = data.readString16();
203 sp<IBinder> b = const_cast<BnServiceManager*>(this)->checkService(which);
204 reply->writeStrongBinder(b);
205 return NO_ERROR;
206 } break;
207 case ADD_SERVICE_TRANSACTION: {
208 CHECK_INTERFACE(IServiceManager, data, reply);
209 String16 which = data.readString16();
210 sp<IBinder> b = data.readStrongBinder();
211 status_t err = addService(which, b);
212 reply->writeInt32(err);
213 return NO_ERROR;
214 } break;
215 case LIST_SERVICES_TRANSACTION: {
216 CHECK_INTERFACE(IServiceManager, data, reply);
217 Vector<String16> list = listServices();
218 const size_t N = list.size();
219 reply->writeInt32(N);
220 for (size_t i=0; i<N; i++) {
221 reply->writeString16(list[i]);
222 }
223 return NO_ERROR;
224 } break;
225 default:
226 return BBinder::onTransact(code, data, reply, flags);
227 }
228 }
229
230 }; // namespace android
231