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 LOGI("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 LOGW("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 LOGI("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 LOGI("Waiting for sevice %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)154 virtual status_t addService(const String16& name, const sp<IBinder>& service)
155 {
156 Parcel data, reply;
157 data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
158 data.writeString16(name);
159 data.writeStrongBinder(service);
160 status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);
161 return err == NO_ERROR ? reply.readInt32() : err;
162 }
163
listServices()164 virtual Vector<String16> listServices()
165 {
166 Vector<String16> res;
167 int n = 0;
168
169 for (;;) {
170 Parcel data, reply;
171 data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
172 data.writeInt32(n++);
173 status_t err = remote()->transact(LIST_SERVICES_TRANSACTION, data, &reply);
174 if (err != NO_ERROR)
175 break;
176 res.add(reply.readString16());
177 }
178 return res;
179 }
180 };
181
182 IMPLEMENT_META_INTERFACE(ServiceManager, "android.os.IServiceManager");
183
184 // ----------------------------------------------------------------------
185
onTransact(uint32_t code,const Parcel & data,Parcel * reply,uint32_t flags)186 status_t BnServiceManager::onTransact(
187 uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
188 {
189 //printf("ServiceManager received: "); data.print();
190 switch(code) {
191 case GET_SERVICE_TRANSACTION: {
192 CHECK_INTERFACE(IServiceManager, data, reply);
193 String16 which = data.readString16();
194 sp<IBinder> b = const_cast<BnServiceManager*>(this)->getService(which);
195 reply->writeStrongBinder(b);
196 return NO_ERROR;
197 } break;
198 case CHECK_SERVICE_TRANSACTION: {
199 CHECK_INTERFACE(IServiceManager, data, reply);
200 String16 which = data.readString16();
201 sp<IBinder> b = const_cast<BnServiceManager*>(this)->checkService(which);
202 reply->writeStrongBinder(b);
203 return NO_ERROR;
204 } break;
205 case ADD_SERVICE_TRANSACTION: {
206 CHECK_INTERFACE(IServiceManager, data, reply);
207 String16 which = data.readString16();
208 sp<IBinder> b = data.readStrongBinder();
209 status_t err = addService(which, b);
210 reply->writeInt32(err);
211 return NO_ERROR;
212 } break;
213 case LIST_SERVICES_TRANSACTION: {
214 CHECK_INTERFACE(IServiceManager, data, reply);
215 Vector<String16> list = listServices();
216 const size_t N = list.size();
217 reply->writeInt32(N);
218 for (size_t i=0; i<N; i++) {
219 reply->writeString16(list[i]);
220 }
221 return NO_ERROR;
222 } break;
223 default:
224 return BBinder::onTransact(code, data, reply, flags);
225 }
226 }
227
228 }; // namespace android
229
230