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/Log.h>
22 #include <binder/IPCThreadState.h>
23 #include <binder/Parcel.h>
24 #include <utils/String8.h>
25 #include <utils/SystemClock.h>
26
27 #include <private/binder/Static.h>
28
29 #include <unistd.h>
30
31 namespace android {
32
defaultServiceManager()33 sp<IServiceManager> defaultServiceManager()
34 {
35 if (gDefaultServiceManager != NULL) return gDefaultServiceManager;
36
37 {
38 AutoMutex _l(gDefaultServiceManagerLock);
39 while (gDefaultServiceManager == NULL) {
40 gDefaultServiceManager = interface_cast<IServiceManager>(
41 ProcessState::self()->getContextObject(NULL));
42 if (gDefaultServiceManager == NULL)
43 sleep(1);
44 }
45 }
46
47 return gDefaultServiceManager;
48 }
49
checkCallingPermission(const String16 & permission)50 bool checkCallingPermission(const String16& permission)
51 {
52 return checkCallingPermission(permission, NULL, NULL);
53 }
54
55 static String16 _permission("permission");
56
57
checkCallingPermission(const String16 & permission,int32_t * outPid,int32_t * outUid)58 bool checkCallingPermission(const String16& permission, int32_t* outPid, int32_t* outUid)
59 {
60 IPCThreadState* ipcState = IPCThreadState::self();
61 pid_t pid = ipcState->getCallingPid();
62 uid_t uid = ipcState->getCallingUid();
63 if (outPid) *outPid = pid;
64 if (outUid) *outUid = uid;
65 return checkPermission(permission, pid, uid);
66 }
67
checkPermission(const String16 & permission,pid_t pid,uid_t uid)68 bool checkPermission(const String16& permission, pid_t pid, uid_t uid)
69 {
70 #ifdef __BRILLO__
71 // Brillo doesn't currently run ActivityManager or support framework permissions.
72 return true;
73 #endif
74
75 sp<IPermissionController> pc;
76 gDefaultServiceManagerLock.lock();
77 pc = gPermissionController;
78 gDefaultServiceManagerLock.unlock();
79
80 int64_t startTime = 0;
81
82 while (true) {
83 if (pc != NULL) {
84 bool res = pc->checkPermission(permission, pid, uid);
85 if (res) {
86 if (startTime != 0) {
87 ALOGI("Check passed after %d seconds for %s from uid=%d pid=%d",
88 (int)((uptimeMillis()-startTime)/1000),
89 String8(permission).string(), uid, pid);
90 }
91 return res;
92 }
93
94 // Is this a permission failure, or did the controller go away?
95 if (IInterface::asBinder(pc)->isBinderAlive()) {
96 ALOGW("Permission failure: %s from uid=%d pid=%d",
97 String8(permission).string(), uid, pid);
98 return false;
99 }
100
101 // Object is dead!
102 gDefaultServiceManagerLock.lock();
103 if (gPermissionController == pc) {
104 gPermissionController = NULL;
105 }
106 gDefaultServiceManagerLock.unlock();
107 }
108
109 // Need to retrieve the permission controller.
110 sp<IBinder> binder = defaultServiceManager()->checkService(_permission);
111 if (binder == NULL) {
112 // Wait for the permission controller to come back...
113 if (startTime == 0) {
114 startTime = uptimeMillis();
115 ALOGI("Waiting to check permission %s from uid=%d pid=%d",
116 String8(permission).string(), uid, pid);
117 }
118 sleep(1);
119 } else {
120 pc = interface_cast<IPermissionController>(binder);
121 // Install the new permission controller, and try again.
122 gDefaultServiceManagerLock.lock();
123 gPermissionController = pc;
124 gDefaultServiceManagerLock.unlock();
125 }
126 }
127 }
128
129 // ----------------------------------------------------------------------
130
131 class BpServiceManager : public BpInterface<IServiceManager>
132 {
133 public:
BpServiceManager(const sp<IBinder> & impl)134 BpServiceManager(const sp<IBinder>& impl)
135 : BpInterface<IServiceManager>(impl)
136 {
137 }
138
getService(const String16 & name) const139 virtual sp<IBinder> getService(const String16& name) const
140 {
141 unsigned n;
142 for (n = 0; n < 5; n++){
143 sp<IBinder> svc = checkService(name);
144 if (svc != NULL) return svc;
145 ALOGI("Waiting for service %s...\n", String8(name).string());
146 sleep(1);
147 }
148 return NULL;
149 }
150
checkService(const String16 & name) const151 virtual sp<IBinder> checkService( const String16& name) const
152 {
153 Parcel data, reply;
154 data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
155 data.writeString16(name);
156 remote()->transact(CHECK_SERVICE_TRANSACTION, data, &reply);
157 return reply.readStrongBinder();
158 }
159
addService(const String16 & name,const sp<IBinder> & service,bool allowIsolated)160 virtual status_t addService(const String16& name, const sp<IBinder>& service,
161 bool allowIsolated)
162 {
163 Parcel data, reply;
164 data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
165 data.writeString16(name);
166 data.writeStrongBinder(service);
167 data.writeInt32(allowIsolated ? 1 : 0);
168 status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);
169 return err == NO_ERROR ? reply.readExceptionCode() : err;
170 }
171
listServices()172 virtual Vector<String16> listServices()
173 {
174 Vector<String16> res;
175 int n = 0;
176
177 for (;;) {
178 Parcel data, reply;
179 data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
180 data.writeInt32(n++);
181 status_t err = remote()->transact(LIST_SERVICES_TRANSACTION, data, &reply);
182 if (err != NO_ERROR)
183 break;
184 res.add(reply.readString16());
185 }
186 return res;
187 }
188 };
189
190 IMPLEMENT_META_INTERFACE(ServiceManager, "android.os.IServiceManager");
191
192 }; // namespace android
193