frameworks/base/libs/binder/IServiceManager.cpp

   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         if (gDefaultServiceManager == NULL) {
  41             gDefaultServiceManager = interface_cast<IServiceManager>(
  42                 ProcessState::self()->getContextObject(NULL));
  43         }
  44     }
  45
  46     return gDefaultServiceManager;
  47 }
  48
  49 bool checkCallingPermission(const String16& permission)
  50 {
  51     return checkCallingPermission(permission, NULL, NULL);
  52 }
  53
  54 static String16 _permission("permission");
  55
  56
  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
  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:
 128     BpServiceManager(const sp<IBinder>& impl)
 129         : BpInterface<IServiceManager>(impl)
 130     {
 131     }
 132
 133     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 service %s...\n", String8(name).string());
 140             sleep(1);
 141         }
 142         return NULL;
 143     }
 144
 145     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
 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.readExceptionCode() : err;
 162     }
 163
 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
 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