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