IServiceManager.cpp revision 6456e4488d59c0568a1f29dc93b7beb472236086 
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
31namespace android {
32
33sp<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
50bool checkCallingPermission(const String16& permission)
51{
52    return checkCallingPermission(permission, NULL, NULL);
53}
54
55static String16 _permission("permission");
56
57
58bool 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
68bool checkPermission(const String16& permission, pid_t pid, uid_t uid)
69{
70    sp<IPermissionController> pc;
71    gDefaultServiceManagerLock.lock();
72    pc = gPermissionController;
73    gDefaultServiceManagerLock.unlock();
74
75    int64_t startTime = 0;
76
77    while (true) {
78        if (pc != NULL) {
79            bool res = pc->checkPermission(permission, pid, uid);
80            if (res) {
81                if (startTime != 0) {
82                    ALOGI("Check passed after %d seconds for %s from uid=%d pid=%d",
83                            (int)((uptimeMillis()-startTime)/1000),
84                            String8(permission).string(), uid, pid);
85                }
86                return res;
87            }
88
89            // Is this a permission failure, or did the controller go away?
90            if (IInterface::asBinder(pc)->isBinderAlive()) {
91                ALOGW("Permission failure: %s from uid=%d pid=%d",
92                        String8(permission).string(), uid, pid);
93                return false;
94            }
95
96            // Object is dead!
97            gDefaultServiceManagerLock.lock();
98            if (gPermissionController == pc) {
99                gPermissionController = NULL;
100            }
101            gDefaultServiceManagerLock.unlock();
102        }
103
104        // Need to retrieve the permission controller.
105        sp<IBinder> binder = defaultServiceManager()->checkService(_permission);
106        if (binder == NULL) {
107            // Wait for the permission controller to come back...
108            if (startTime == 0) {
109                startTime = uptimeMillis();
110                ALOGI("Waiting to check permission %s from uid=%d pid=%d",
111                        String8(permission).string(), uid, pid);
112            }
113            sleep(1);
114        } else {
115            pc = interface_cast<IPermissionController>(binder);
116            // Install the new permission controller, and try again.
117            gDefaultServiceManagerLock.lock();
118            gPermissionController = pc;
119            gDefaultServiceManagerLock.unlock();
120        }
121    }
122}
123
124// ----------------------------------------------------------------------
125
126class BpServiceManager : public BpInterface<IServiceManager>
127{
128public:
129    explicit BpServiceManager(const sp<IBinder>& impl)
130        : BpInterface<IServiceManager>(impl)
131    {
132    }
133
134    virtual sp<IBinder> getService(const String16& name) const
135    {
136        unsigned n;
137        for (n = 0; n < 5; n++){
138            if (n > 0) {
139                ALOGI("Waiting for service %s...", String8(name).string());
140                sleep(1);
141            }
142            sp<IBinder> svc = checkService(name);
143            if (svc != NULL) return svc;
144        }
145        return NULL;
146    }
147
148    virtual sp<IBinder> checkService( const String16& name) const
149    {
150        Parcel data, reply;
151        data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
152        data.writeString16(name);
153        remote()->transact(CHECK_SERVICE_TRANSACTION, data, &reply);
154        return reply.readStrongBinder();
155    }
156
157    virtual status_t addService(const String16& name, const sp<IBinder>& service,
158            bool allowIsolated)
159    {
160        Parcel data, reply;
161        data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
162        data.writeString16(name);
163        data.writeStrongBinder(service);
164        data.writeInt32(allowIsolated ? 1 : 0);
165        status_t err = remote()->transact(ADD_SERVICE_TRANSACTION, data, &reply);
166        return err == NO_ERROR ? reply.readExceptionCode() : err;
167    }
168
169    virtual Vector<String16> listServices()
170    {
171        Vector<String16> res;
172        int n = 0;
173
174        for (;;) {
175            Parcel data, reply;
176            data.writeInterfaceToken(IServiceManager::getInterfaceDescriptor());
177            data.writeInt32(n++);
178            status_t err = remote()->transact(LIST_SERVICES_TRANSACTION, data, &reply);
179            if (err != NO_ERROR)
180                break;
181            res.add(reply.readString16());
182        }
183        return res;
184    }
185};
186
187IMPLEMENT_META_INTERFACE(ServiceManager, "android.os.IServiceManager");
188
189}; // namespace android
190