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 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 51 bool checkCallingPermission(const String16& permission) 52 { 53 return checkCallingPermission(permission, NULL, NULL); 54 } 55 56 static String16 _permission("permission"); 57 58 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 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: 130 BpServiceManager(const sp<IBinder>& impl) 131 : BpInterface<IServiceManager>(impl) 132 { 133 } 134 135 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 147 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 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 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 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
