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 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 50 bool checkCallingPermission(const String16& permission) 51 { 52 return checkCallingPermission(permission, NULL, NULL); 53 } 54 55 static String16 _permission("permission"); 56 57 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 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: 134 BpServiceManager(const sp<IBinder>& impl) 135 : BpInterface<IServiceManager>(impl) 136 { 137 } 138 139 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 151 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 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 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
