• 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             LOGD("registerListener could not contact remote\n");
70             return;
71         }
72         int32_t err = reply.readExceptionCode();
73         if (err < 0) {
74             LOGD("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             LOGD("unregisterListener could not contact remote\n");
86             return;
87         }
88         int32_t err = reply.readExceptionCode();
89         if (err < 0) {
90             LOGD("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             LOGD("isUsbMassStorageConnected could not contact remote\n");
101             return false;
102         }
103         int32_t err = reply.readExceptionCode();
104         if (err < 0) {
105             LOGD("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             LOGD("setUsbMassStorageEnabled could not contact remote\n");
118             return;
119         }
120         int32_t err = reply.readExceptionCode();
121         if (err < 0) {
122             LOGD("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             LOGD("isUsbMassStorageEnabled could not contact remote\n");
133             return false;
134         }
135         int32_t err = reply.readExceptionCode();
136         if (err < 0) {
137             LOGD("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             LOGD("mountVolume could not contact remote\n");
150             return -1;
151         }
152         int32_t err = reply.readExceptionCode();
153         if (err < 0) {
154             LOGD("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             LOGD("unmountVolume could not contact remote\n");
169             return -1;
170         }
171         int32_t err = reply.readExceptionCode();
172         if (err < 0) {
173             LOGD("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             LOGD("formatVolume could not contact remote\n");
186             return -1;
187         }
188         int32_t err = reply.readExceptionCode();
189         if (err < 0) {
190             LOGD("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             LOGD("getStorageUsers could not contact remote\n");
203             return -1;
204         }
205         int32_t err = reply.readExceptionCode();
206         if (err < 0) {
207             LOGD("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             LOGD("getVolumeState could not contact remote\n");
225             return -1;
226         }
227         int32_t err = reply.readExceptionCode();
228         if (err < 0) {
229             LOGD("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             LOGD("createSecureContainer could not contact remote\n");
247             return -1;
248         }
249         int32_t err = reply.readExceptionCode();
250         if (err < 0) {
251             LOGD("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             LOGD("finalizeSecureContainer couldn't call remote\n");
264             return -1;
265         }
266         int32_t err = reply.readExceptionCode();
267         if (err < 0) {
268             LOGD("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             LOGD("destroySecureContainer couldn't call remote");
281             return -1;
282         }
283         int32_t err = reply.readExceptionCode();
284         if (err < 0) {
285             LOGD("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         if (remote()->transact(TRANSACTION_mountSecureContainer, data, &reply) != NO_ERROR) {
299             LOGD("mountSecureContainer couldn't call remote");
300             return -1;
301         }
302         int32_t err = reply.readExceptionCode(); // What to do...
303         if (err < 0) {
304             LOGD("mountSecureContainer caught exception %d\n", err);
305             return err;
306         }
307         return reply.readInt32();
308     }
309 
unmountSecureContainer(const String16 & id,const bool force)310     int32_t unmountSecureContainer(const String16& id, const bool force)
311     {
312         Parcel data, reply;
313         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
314         data.writeString16(id);
315         data.writeInt32(force ? 1 : 0);
316         if (remote()->transact(TRANSACTION_getSecureContainerPath, data, &reply) != NO_ERROR) {
317             LOGD("unmountSecureContainer couldn't call remote");
318             return -1;
319         }
320         int32_t err = reply.readExceptionCode(); // What to do...
321         if (err < 0) {
322             LOGD("unmountSecureContainer caught exception %d\n", err);
323             return err;
324         }
325         return reply.readInt32();
326     }
327 
isSecureContainerMounted(const String16 & id)328     bool isSecureContainerMounted(const String16& id)
329     {
330         Parcel data, reply;
331         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
332         data.writeString16(id);
333         if (remote()->transact(TRANSACTION_isSecureContainerMounted, data, &reply) != NO_ERROR) {
334             LOGD("isSecureContainerMounted couldn't call remote");
335             return false;
336         }
337         int32_t err = reply.readExceptionCode(); // What to do...
338         if (err < 0) {
339             LOGD("isSecureContainerMounted caught exception %d\n", err);
340             return false;
341         }
342         return reply.readInt32() != 0;
343     }
344 
renameSecureContainer(const String16 & oldId,const String16 & newId)345     int32_t renameSecureContainer(const String16& oldId, const String16& newId)
346     {
347         Parcel data, reply;
348         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
349         data.writeString16(oldId);
350         data.writeString16(newId);
351         if (remote()->transact(TRANSACTION_renameSecureContainer, data, &reply) != NO_ERROR) {
352             LOGD("renameSecureContainer couldn't call remote");
353             return -1;
354         }
355         int32_t err = reply.readExceptionCode(); // What to do...
356         if (err < 0) {
357             LOGD("renameSecureContainer caught exception %d\n", err);
358             return err;
359         }
360         return reply.readInt32();
361     }
362 
getSecureContainerPath(const String16 & id,String16 & path)363     bool getSecureContainerPath(const String16& id, String16& path)
364     {
365         Parcel data, reply;
366         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
367         data.writeString16(id);
368         if (remote()->transact(TRANSACTION_getSecureContainerPath, data, &reply) != NO_ERROR) {
369             LOGD("getSecureContainerPath couldn't call remote");
370             return false;
371         }
372         int32_t err = reply.readExceptionCode(); // What to do...
373         if (err < 0) {
374             LOGD("getSecureContainerPath caught exception %d\n", err);
375             return false;
376         }
377         path = reply.readString16();
378         return true;
379     }
380 
getSecureContainerList(const String16 & id,String16 * & containers)381     int32_t getSecureContainerList(const String16& id, String16*& containers)
382     {
383         Parcel data, reply;
384         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
385         data.writeString16(id);
386         if (remote()->transact(TRANSACTION_getSecureContainerList, data, &reply) != NO_ERROR) {
387             LOGD("getSecureContainerList couldn't call remote");
388             return -1;
389         }
390         int32_t err = reply.readExceptionCode();
391         if (err < 0) {
392             LOGD("getSecureContainerList caught exception %d\n", err);
393             return err;
394         }
395         const int32_t numStrings = reply.readInt32();
396         containers = new String16[numStrings];
397         for (int i = 0; i < numStrings; i++) {
398             containers[i] = reply.readString16();
399         }
400         return numStrings;
401     }
402 
shutdown(const sp<IMountShutdownObserver> & observer)403     void shutdown(const sp<IMountShutdownObserver>& observer)
404     {
405         Parcel data, reply;
406         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
407         data.writeStrongBinder(observer->asBinder());
408         if (remote()->transact(TRANSACTION_shutdown, data, &reply) != NO_ERROR) {
409             LOGD("shutdown could not contact remote\n");
410             return;
411         }
412         int32_t err = reply.readExceptionCode();
413         if (err < 0) {
414             LOGD("shutdown caught exception %d\n", err);
415             return;
416         }
417         reply.readExceptionCode();
418     }
419 
finishMediaUpdate()420     void finishMediaUpdate()
421     {
422         Parcel data, reply;
423         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
424         if (remote()->transact(TRANSACTION_finishMediaUpdate, data, &reply) != NO_ERROR) {
425             LOGD("finishMediaUpdate could not contact remote\n");
426             return;
427         }
428         int32_t err = reply.readExceptionCode();
429         if (err < 0) {
430             LOGD("finishMediaUpdate caught exception %d\n", err);
431             return;
432         }
433         reply.readExceptionCode();
434     }
435 
mountObb(const String16 & filename,const String16 & key,const sp<IObbActionListener> & token,int32_t nonce)436     void mountObb(const String16& filename, const String16& key,
437             const sp<IObbActionListener>& token, int32_t nonce)
438     {
439         Parcel data, reply;
440         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
441         data.writeString16(filename);
442         data.writeString16(key);
443         data.writeStrongBinder(token->asBinder());
444         data.writeInt32(nonce);
445         if (remote()->transact(TRANSACTION_mountObb, data, &reply) != NO_ERROR) {
446             LOGD("mountObb could not contact remote\n");
447             return;
448         }
449         int32_t err = reply.readExceptionCode();
450         if (err < 0) {
451             LOGD("mountObb caught exception %d\n", err);
452             return;
453         }
454     }
455 
unmountObb(const String16 & filename,const bool force,const sp<IObbActionListener> & token,const int32_t nonce)456     void unmountObb(const String16& filename, const bool force,
457             const sp<IObbActionListener>& token, const int32_t nonce)
458     {
459         Parcel data, reply;
460         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
461         data.writeString16(filename);
462         data.writeInt32(force ? 1 : 0);
463         data.writeStrongBinder(token->asBinder());
464         data.writeInt32(nonce);
465         if (remote()->transact(TRANSACTION_unmountObb, data, &reply) != NO_ERROR) {
466             LOGD("unmountObb could not contact remote\n");
467             return;
468         }
469         int32_t err = reply.readExceptionCode();
470         if (err < 0) {
471             LOGD("unmountObb caught exception %d\n", err);
472             return;
473         }
474     }
475 
isObbMounted(const String16 & filename)476     bool isObbMounted(const String16& filename)
477     {
478         Parcel data, reply;
479         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
480         data.writeString16(filename);
481         if (remote()->transact(TRANSACTION_isObbMounted, data, &reply) != NO_ERROR) {
482             LOGD("isObbMounted could not contact remote\n");
483             return false;
484         }
485         int32_t err = reply.readExceptionCode();
486         if (err < 0) {
487             LOGD("isObbMounted caught exception %d\n", err);
488             return false;
489         }
490         return reply.readInt32() != 0;
491     }
492 
getMountedObbPath(const String16 & filename,String16 & path)493     bool getMountedObbPath(const String16& filename, String16& path)
494     {
495         Parcel data, reply;
496         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
497         data.writeString16(filename);
498         if (remote()->transact(TRANSACTION_getMountedObbPath, data, &reply) != NO_ERROR) {
499             LOGD("getMountedObbPath could not contact remote\n");
500             return false;
501         }
502         int32_t err = reply.readExceptionCode();
503         if (err < 0) {
504             LOGD("getMountedObbPath caught exception %d\n", err);
505             return false;
506         }
507         path = reply.readString16();
508         return true;
509     }
510 
decryptStorage(const String16 & password)511     int32_t decryptStorage(const String16& password)
512     {
513         Parcel data, reply;
514         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
515         data.writeString16(password);
516         if (remote()->transact(TRANSACTION_decryptStorage, data, &reply) != NO_ERROR) {
517             LOGD("decryptStorage could not contact remote\n");
518             return -1;
519         }
520         int32_t err = reply.readExceptionCode();
521         if (err < 0) {
522             LOGD("decryptStorage caught exception %d\n", err);
523             return err;
524         }
525         return reply.readInt32();
526     }
527 
encryptStorage(const String16 & password)528     int32_t encryptStorage(const String16& password)
529     {
530         Parcel data, reply;
531         data.writeInterfaceToken(IMountService::getInterfaceDescriptor());
532         data.writeString16(password);
533         if (remote()->transact(TRANSACTION_encryptStorage, data, &reply) != NO_ERROR) {
534             LOGD("encryptStorage could not contact remote\n");
535             return -1;
536         }
537         int32_t err = reply.readExceptionCode();
538         if (err < 0) {
539             LOGD("encryptStorage caught exception %d\n", err);
540             return err;
541         }
542         return reply.readInt32();
543     }
544 };
545 
546 IMPLEMENT_META_INTERFACE(MountService, "IMountService");
547 
548 // ----------------------------------------------------------------------
549 
550 };
551