• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2010 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 "IMountService"
18 
19 #include <storage/IMountService.h>
20 #include <binder/Parcel.h>
21 
22 namespace android {
23 
24 enum {
25     TRANSACTION_registerListener = IBinder::FIRST_CALL_TRANSACTION,
26     TRANSACTION_unregisterListener,
27     TRANSACTION_isUsbMassStorageConnected,
28     TRANSACTION_setUsbMassStorageEnabled,
29     TRANSACTION_isUsbMassStorageEnabled,
30     TRANSACTION_mountVolume,
31     TRANSACTION_unmountVolume,
32     TRANSACTION_formatVolume,
33     TRANSACTION_getStorageUsers,
34     TRANSACTION_getVolumeState,
35     TRANSACTION_createSecureContainer,
36     TRANSACTION_finalizeSecureContainer,
37     TRANSACTION_destroySecureContainer,
38     TRANSACTION_mountSecureContainer,
39     TRANSACTION_unmountSecureContainer,
40     TRANSACTION_isSecureContainerMounted,
41     TRANSACTION_renameSecureContainer,
42     TRANSACTION_getSecureContainerPath,
43     TRANSACTION_getSecureContainerList,
44     TRANSACTION_shutdown,
45     TRANSACTION_finishMediaUpdate,
46     TRANSACTION_mountObb,
47     TRANSACTION_unmountObb,
48     TRANSACTION_isObbMounted,
49     TRANSACTION_getMountedObbPath,
50     TRANSACTION_isExternalStorageEmulated,
51     TRANSACTION_decryptStorage,
52     TRANSACTION_encryptStorage,
53 };
54 
55 class BpMountService: public BpInterface<IMountService>
56 {
57 public:
BpMountService(const sp<IBinder> & impl)58     BpMountService(const sp<IBinder>& impl)
59         : BpInterface<IMountService>(impl)
60     {
61     }
62 
registerListener(const sp<IMountServiceListener> & listener)63     virtual void registerListener(const sp<IMountServiceListener>& listener)
64     {
65         Parcel data, reply;
66         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
67         data.writeStrongBinder(listener->asBinder());
68         if (remote()->transact(TRANSACTION_registerListener, data, &reply) != NO_ERROR) {
69             ALOGD("registerListener could not contact remote\n");
70             return;
71         }
72         int32_t err = reply.readExceptionCode();
73         if (err < 0) {
74             ALOGD("registerListener caught exception %d\n", err);
75             return;
76         }
77     }
78 
unregisterListener(const sp<IMountServiceListener> & listener)79     virtual void unregisterListener(const sp<IMountServiceListener>& listener)
80     {
81         Parcel data, reply;
82         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
83         data.writeStrongBinder(listener->asBinder());
84         if (remote()->transact(TRANSACTION_unregisterListener, data, &reply) != NO_ERROR) {
85             ALOGD("unregisterListener could not contact remote\n");
86             return;
87         }
88         int32_t err = reply.readExceptionCode();
89         if (err < 0) {
90             ALOGD("unregisterListener caught exception %d\n", err);
91             return;
92         }
93     }
94 
isUsbMassStorageConnected()95     virtual bool isUsbMassStorageConnected()
96     {
97         Parcel data, reply;
98         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
99         if (remote()->transact(TRANSACTION_isUsbMassStorageConnected, data, &reply) != NO_ERROR) {
100             ALOGD("isUsbMassStorageConnected could not contact remote\n");
101             return false;
102         }
103         int32_t err = reply.readExceptionCode();
104         if (err < 0) {
105             ALOGD("isUsbMassStorageConnected caught exception %d\n", err);
106             return false;
107         }
108         return reply.readInt32() != 0;
109     }
110 
setUsbMassStorageEnabled(const bool enable)111     virtual void setUsbMassStorageEnabled(const bool enable)
112     {
113         Parcel data, reply;
114         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
115         data.writeInt32(enable != 0);
116         if (remote()->transact(TRANSACTION_setUsbMassStorageEnabled, data, &reply) != NO_ERROR) {
117             ALOGD("setUsbMassStorageEnabled could not contact remote\n");
118             return;
119         }
120         int32_t err = reply.readExceptionCode();
121         if (err < 0) {
122             ALOGD("setUsbMassStorageEnabled caught exception %d\n", err);
123             return;
124         }
125     }
126 
isUsbMassStorageEnabled()127     virtual bool isUsbMassStorageEnabled()
128     {
129         Parcel data, reply;
130         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
131         if (remote()->transact(TRANSACTION_isUsbMassStorageEnabled, data, &reply) != NO_ERROR) {
132             ALOGD("isUsbMassStorageEnabled could not contact remote\n");
133             return false;
134         }
135         int32_t err = reply.readExceptionCode();
136         if (err < 0) {
137             ALOGD("isUsbMassStorageEnabled caught exception %d\n", err);
138             return false;
139         }
140         return reply.readInt32() != 0;
141     }
142 
mountVolume(const String16 & mountPoint)143     int32_t mountVolume(const String16& mountPoint)
144     {
145         Parcel data, reply;
146         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
147         data.writeString16(mountPoint);
148         if (remote()->transact(TRANSACTION_mountVolume, data, &reply) != NO_ERROR) {
149             ALOGD("mountVolume could not contact remote\n");
150             return -1;
151         }
152         int32_t err = reply.readExceptionCode();
153         if (err < 0) {
154             ALOGD("mountVolume caught exception %d\n", err);
155             return err;
156         }
157         return reply.readInt32();
158     }
159 
unmountVolume(const String16 & mountPoint,const bool force,const bool removeEncryption)160     int32_t unmountVolume(const String16& mountPoint, const bool force, const bool removeEncryption)
161     {
162         Parcel data, reply;
163         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
164         data.writeString16(mountPoint);
165         data.writeInt32(force ? 1 : 0);
166         data.writeInt32(removeEncryption ? 1 : 0);
167         if (remote()->transact(TRANSACTION_unmountVolume, data, &reply) != NO_ERROR) {
168             ALOGD("unmountVolume could not contact remote\n");
169             return -1;
170         }
171         int32_t err = reply.readExceptionCode();
172         if (err < 0) {
173             ALOGD("unmountVolume caught exception %d\n", err);
174             return err;
175         }
176         return reply.readInt32();
177     }
178 
formatVolume(const String16 & mountPoint)179     int32_t formatVolume(const String16& mountPoint)
180     {
181         Parcel data, reply;
182         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
183         data.writeString16(mountPoint);
184         if (remote()->transact(TRANSACTION_formatVolume, data, &reply) != NO_ERROR) {
185             ALOGD("formatVolume could not contact remote\n");
186             return -1;
187         }
188         int32_t err = reply.readExceptionCode();
189         if (err < 0) {
190             ALOGD("formatVolume caught exception %d\n", err);
191             return err;
192         }
193         return reply.readInt32();
194     }
195 
getStorageUsers(const String16 & mountPoint,int32_t ** users)196     int32_t getStorageUsers(const String16& mountPoint, int32_t** users)
197     {
198         Parcel data, reply;
199         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
200         data.writeString16(mountPoint);
201         if (remote()->transact(TRANSACTION_getStorageUsers, data, &reply) != NO_ERROR) {
202             ALOGD("getStorageUsers could not contact remote\n");
203             return -1;
204         }
205         int32_t err = reply.readExceptionCode();
206         if (err < 0) {
207             ALOGD("getStorageUsers caught exception %d\n", err);
208             return err;
209         }
210         const int32_t numUsers = reply.readInt32();
211         *users = (int32_t*)malloc(sizeof(int32_t)*numUsers);
212         for (int i = 0; i < numUsers; i++) {
213             **users++ = reply.readInt32();
214         }
215         return numUsers;
216     }
217 
getVolumeState(const String16 & mountPoint)218     int32_t getVolumeState(const String16& mountPoint)
219     {
220         Parcel data, reply;
221         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
222         data.writeString16(mountPoint);
223         if (remote()->transact(TRANSACTION_getVolumeState, data, &reply) != NO_ERROR) {
224             ALOGD("getVolumeState could not contact remote\n");
225             return -1;
226         }
227         int32_t err = reply.readExceptionCode();
228         if (err < 0) {
229             ALOGD("getVolumeState caught exception %d\n", err);
230             return err;
231         }
232         return reply.readInt32();
233     }
234 
createSecureContainer(const String16 & id,const int32_t sizeMb,const String16 & fstype,const String16 & key,const int32_t ownerUid)235     int32_t createSecureContainer(const String16& id, const int32_t sizeMb, const String16& fstype,
236             const String16& key, const int32_t ownerUid)
237     {
238         Parcel data, reply;
239         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
240         data.writeString16(id);
241         data.writeInt32(sizeMb);
242         data.writeString16(fstype);
243         data.writeString16(key);
244         data.writeInt32(ownerUid);
245         if (remote()->transact(TRANSACTION_createSecureContainer, data, &reply) != NO_ERROR) {
246             ALOGD("createSecureContainer could not contact remote\n");
247             return -1;
248         }
249         int32_t err = reply.readExceptionCode();
250         if (err < 0) {
251             ALOGD("createSecureContainer caught exception %d\n", err);
252             return err;
253         }
254         return reply.readInt32();
255     }
256 
finalizeSecureContainer(const String16 & id)257     int32_t finalizeSecureContainer(const String16& id)
258     {
259         Parcel data, reply;
260         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
261         data.writeString16(id);
262         if (remote()->transact(TRANSACTION_finalizeSecureContainer, data, &reply) != NO_ERROR) {
263             ALOGD("finalizeSecureContainer couldn't call remote\n");
264             return -1;
265         }
266         int32_t err = reply.readExceptionCode();
267         if (err < 0) {
268             ALOGD("finalizeSecureContainer caught exception %d\n", err);
269             return err;
270         }
271         return reply.readInt32();
272     }
273 
destroySecureContainer(const String16 & id)274     int32_t destroySecureContainer(const String16& id)
275     {
276         Parcel data, reply;
277         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
278         data.writeString16(id);
279         if (remote()->transact(TRANSACTION_destroySecureContainer, data, &reply) != NO_ERROR) {
280             ALOGD("destroySecureContainer couldn't call remote");
281             return -1;
282         }
283         int32_t err = reply.readExceptionCode();
284         if (err < 0) {
285             ALOGD("destroySecureContainer caught exception %d\n", err);
286             return err;
287         }
288         return reply.readInt32();
289     }
290 
mountSecureContainer(const String16 & id,const String16 & key,const int32_t ownerUid)291     int32_t mountSecureContainer(const String16& id, const String16& key, const int32_t ownerUid)
292     {
293         Parcel data, reply;
294         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
295         data.writeString16(id);
296         data.writeString16(key);
297         data.writeInt32(ownerUid);
298         // Assume read-only
299         data.writeInt32(1);
300         if (remote()->transact(TRANSACTION_mountSecureContainer, data, &reply) != NO_ERROR) {
301             ALOGD("mountSecureContainer couldn't call remote");
302             return -1;
303         }
304         int32_t err = reply.readExceptionCode(); // What to do...
305         if (err < 0) {
306             ALOGD("mountSecureContainer caught exception %d\n", err);
307             return err;
308         }
309         return reply.readInt32();
310     }
311 
unmountSecureContainer(const String16 & id,const bool force)312     int32_t unmountSecureContainer(const String16& id, const bool force)
313     {
314         Parcel data, reply;
315         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
316         data.writeString16(id);
317         data.writeInt32(force ? 1 : 0);
318         if (remote()->transact(TRANSACTION_getSecureContainerPath, data, &reply) != NO_ERROR) {
319             ALOGD("unmountSecureContainer couldn't call remote");
320             return -1;
321         }
322         int32_t err = reply.readExceptionCode(); // What to do...
323         if (err < 0) {
324             ALOGD("unmountSecureContainer caught exception %d\n", err);
325             return err;
326         }
327         return reply.readInt32();
328     }
329 
isSecureContainerMounted(const String16 & id)330     bool isSecureContainerMounted(const String16& id)
331     {
332         Parcel data, reply;
333         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
334         data.writeString16(id);
335         if (remote()->transact(TRANSACTION_isSecureContainerMounted, data, &reply) != NO_ERROR) {
336             ALOGD("isSecureContainerMounted couldn't call remote");
337             return false;
338         }
339         int32_t err = reply.readExceptionCode(); // What to do...
340         if (err < 0) {
341             ALOGD("isSecureContainerMounted caught exception %d\n", err);
342             return false;
343         }
344         return reply.readInt32() != 0;
345     }
346 
renameSecureContainer(const String16 & oldId,const String16 & newId)347     int32_t renameSecureContainer(const String16& oldId, const String16& newId)
348     {
349         Parcel data, reply;
350         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
351         data.writeString16(oldId);
352         data.writeString16(newId);
353         if (remote()->transact(TRANSACTION_renameSecureContainer, data, &reply) != NO_ERROR) {
354             ALOGD("renameSecureContainer couldn't call remote");
355             return -1;
356         }
357         int32_t err = reply.readExceptionCode(); // What to do...
358         if (err < 0) {
359             ALOGD("renameSecureContainer caught exception %d\n", err);
360             return err;
361         }
362         return reply.readInt32();
363     }
364 
getSecureContainerPath(const String16 & id,String16 & path)365     bool getSecureContainerPath(const String16& id, String16& path)
366     {
367         Parcel data, reply;
368         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
369         data.writeString16(id);
370         if (remote()->transact(TRANSACTION_getSecureContainerPath, data, &reply) != NO_ERROR) {
371             ALOGD("getSecureContainerPath couldn't call remote");
372             return false;
373         }
374         int32_t err = reply.readExceptionCode(); // What to do...
375         if (err < 0) {
376             ALOGD("getSecureContainerPath caught exception %d\n", err);
377             return false;
378         }
379         path = reply.readString16();
380         return true;
381     }
382 
getSecureContainerList(const String16 & id,String16 * & containers)383     int32_t getSecureContainerList(const String16& id, String16*& containers)
384     {
385         Parcel data, reply;
386         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
387         data.writeString16(id);
388         if (remote()->transact(TRANSACTION_getSecureContainerList, data, &reply) != NO_ERROR) {
389             ALOGD("getSecureContainerList couldn't call remote");
390             return -1;
391         }
392         int32_t err = reply.readExceptionCode();
393         if (err < 0) {
394             ALOGD("getSecureContainerList caught exception %d\n", err);
395             return err;
396         }
397         const int32_t numStrings = reply.readInt32();
398         containers = new String16[numStrings];
399         for (int i = 0; i < numStrings; i++) {
400             containers[i] = reply.readString16();
401         }
402         return numStrings;
403     }
404 
shutdown(const sp<IMountShutdownObserver> & observer)405     void shutdown(const sp<IMountShutdownObserver>& observer)
406     {
407         Parcel data, reply;
408         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
409         data.writeStrongBinder(observer->asBinder());
410         if (remote()->transact(TRANSACTION_shutdown, data, &reply) != NO_ERROR) {
411             ALOGD("shutdown could not contact remote\n");
412             return;
413         }
414         int32_t err = reply.readExceptionCode();
415         if (err < 0) {
416             ALOGD("shutdown caught exception %d\n", err);
417             return;
418         }
419         reply.readExceptionCode();
420     }
421 
finishMediaUpdate()422     void finishMediaUpdate()
423     {
424         Parcel data, reply;
425         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
426         if (remote()->transact(TRANSACTION_finishMediaUpdate, data, &reply) != NO_ERROR) {
427             ALOGD("finishMediaUpdate could not contact remote\n");
428             return;
429         }
430         int32_t err = reply.readExceptionCode();
431         if (err < 0) {
432             ALOGD("finishMediaUpdate caught exception %d\n", err);
433             return;
434         }
435         reply.readExceptionCode();
436     }
437 
mountObb(const String16 & rawPath,const String16 & canonicalPath,const String16 & key,const sp<IObbActionListener> & token,int32_t nonce)438     void mountObb(const String16& rawPath, const String16& canonicalPath, const String16& key,
439             const sp<IObbActionListener>& token, int32_t nonce)
440     {
441         Parcel data, reply;
442         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
443         data.writeString16(rawPath);
444         data.writeString16(canonicalPath);
445         data.writeString16(key);
446         data.writeStrongBinder(token->asBinder());
447         data.writeInt32(nonce);
448         if (remote()->transact(TRANSACTION_mountObb, data, &reply) != NO_ERROR) {
449             ALOGD("mountObb could not contact remote\n");
450             return;
451         }
452         int32_t err = reply.readExceptionCode();
453         if (err < 0) {
454             ALOGD("mountObb caught exception %d\n", err);
455             return;
456         }
457     }
458 
unmountObb(const String16 & filename,const bool force,const sp<IObbActionListener> & token,const int32_t nonce)459     void unmountObb(const String16& filename, const bool force,
460             const sp<IObbActionListener>& token, const int32_t nonce)
461     {
462         Parcel data, reply;
463         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
464         data.writeString16(filename);
465         data.writeInt32(force ? 1 : 0);
466         data.writeStrongBinder(token->asBinder());
467         data.writeInt32(nonce);
468         if (remote()->transact(TRANSACTION_unmountObb, data, &reply) != NO_ERROR) {
469             ALOGD("unmountObb could not contact remote\n");
470             return;
471         }
472         int32_t err = reply.readExceptionCode();
473         if (err < 0) {
474             ALOGD("unmountObb caught exception %d\n", err);
475             return;
476         }
477     }
478 
isObbMounted(const String16 & filename)479     bool isObbMounted(const String16& filename)
480     {
481         Parcel data, reply;
482         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
483         data.writeString16(filename);
484         if (remote()->transact(TRANSACTION_isObbMounted, data, &reply) != NO_ERROR) {
485             ALOGD("isObbMounted could not contact remote\n");
486             return false;
487         }
488         int32_t err = reply.readExceptionCode();
489         if (err < 0) {
490             ALOGD("isObbMounted caught exception %d\n", err);
491             return false;
492         }
493         return reply.readInt32() != 0;
494     }
495 
getMountedObbPath(const String16 & filename,String16 & path)496     bool getMountedObbPath(const String16& filename, String16& path)
497     {
498         Parcel data, reply;
499         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
500         data.writeString16(filename);
501         if (remote()->transact(TRANSACTION_getMountedObbPath, data, &reply) != NO_ERROR) {
502             ALOGD("getMountedObbPath could not contact remote\n");
503             return false;
504         }
505         int32_t err = reply.readExceptionCode();
506         if (err < 0) {
507             ALOGD("getMountedObbPath caught exception %d\n", err);
508             return false;
509         }
510         path = reply.readString16();
511         return true;
512     }
513 
decryptStorage(const String16 & password)514     int32_t decryptStorage(const String16& password)
515     {
516         Parcel data, reply;
517         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
518         data.writeString16(password);
519         if (remote()->transact(TRANSACTION_decryptStorage, data, &reply) != NO_ERROR) {
520             ALOGD("decryptStorage could not contact remote\n");
521             return -1;
522         }
523         int32_t err = reply.readExceptionCode();
524         if (err < 0) {
525             ALOGD("decryptStorage caught exception %d\n", err);
526             return err;
527         }
528         return reply.readInt32();
529     }
530 
encryptStorage(const String16 & password)531     int32_t encryptStorage(const String16& password)
532     {
533         Parcel data, reply;
534         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
535         data.writeString16(password);
536         if (remote()->transact(TRANSACTION_encryptStorage, data, &reply) != NO_ERROR) {
537             ALOGD("encryptStorage could not contact remote\n");
538             return -1;
539         }
540         int32_t err = reply.readExceptionCode();
541         if (err < 0) {
542             ALOGD("encryptStorage caught exception %d\n", err);
543             return err;
544         }
545         return reply.readInt32();
546     }
547 };
548 
549 IMPLEMENT_META_INTERFACE(MountService, "IMountService");
550 
551 // ----------------------------------------------------------------------
552 
553 };
554