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
32namespace android {
33
34sp<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
51bool checkCallingPermission(const String16& permission)
52{
53    return checkCallingPermission(permission, NULL, NULL);
54}
55
56static String16 _permission("permission");
57
58
59bool 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
69bool 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
127class BpServiceManager : public BpInterface<IServiceManager>
128{
129public:
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
186IMPLEMENT_META_INTERFACE(ServiceManager, "android.os.IServiceManager");
187
188// ----------------------------------------------------------------------
189
190status_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