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 "MtpDevice"
18
19 #include "MtpDebug.h"
20 #include "MtpDevice.h"
21 #include "MtpDeviceInfo.h"
22 #include "MtpObjectInfo.h"
23 #include "MtpProperty.h"
24 #include "MtpStorageInfo.h"
25 #include "MtpStringBuffer.h"
26 #include "MtpUtils.h"
27
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <sys/types.h>
31 #include <sys/ioctl.h>
32 #include <sys/stat.h>
33 #include <fcntl.h>
34 #include <errno.h>
35 #include <endian.h>
36
37 #include <usbhost/usbhost.h>
38
39 namespace android {
40
41 #if 0
42 static bool isMtpDevice(uint16_t vendor, uint16_t product) {
43 // Sandisk Sansa Fuze
44 if (vendor == 0x0781 && product == 0x74c2)
45 return true;
46 // Samsung YP-Z5
47 if (vendor == 0x04e8 && product == 0x503c)
48 return true;
49 return false;
50 }
51 #endif
52
open(const char * deviceName,int fd)53 MtpDevice* MtpDevice::open(const char* deviceName, int fd) {
54 struct usb_device *device = usb_device_new(deviceName, fd);
55 if (!device) {
56 ALOGE("usb_device_new failed for %s", deviceName);
57 return NULL;
58 }
59
60 struct usb_descriptor_header* desc;
61 struct usb_descriptor_iter iter;
62
63 usb_descriptor_iter_init(device, &iter);
64
65 while ((desc = usb_descriptor_iter_next(&iter)) != NULL) {
66 if (desc->bDescriptorType == USB_DT_INTERFACE) {
67 struct usb_interface_descriptor *interface = (struct usb_interface_descriptor *)desc;
68
69 if (interface->bInterfaceClass == USB_CLASS_STILL_IMAGE &&
70 interface->bInterfaceSubClass == 1 && // Still Image Capture
71 interface->bInterfaceProtocol == 1) // Picture Transfer Protocol (PIMA 15470)
72 {
73 char* manufacturerName = usb_device_get_manufacturer_name(device);
74 char* productName = usb_device_get_product_name(device);
75 ALOGD("Found camera: \"%s\" \"%s\"\n", manufacturerName, productName);
76 free(manufacturerName);
77 free(productName);
78 } else if (interface->bInterfaceClass == 0xFF &&
79 interface->bInterfaceSubClass == 0xFF &&
80 interface->bInterfaceProtocol == 0) {
81 char* interfaceName = usb_device_get_string(device, interface->iInterface);
82 if (!interfaceName) {
83 continue;
84 } else if (strcmp(interfaceName, "MTP")) {
85 free(interfaceName);
86 continue;
87 }
88 free(interfaceName);
89
90 // Looks like an android style MTP device
91 char* manufacturerName = usb_device_get_manufacturer_name(device);
92 char* productName = usb_device_get_product_name(device);
93 ALOGD("Found MTP device: \"%s\" \"%s\"\n", manufacturerName, productName);
94 free(manufacturerName);
95 free(productName);
96 }
97 #if 0
98 else {
99 // look for special cased devices based on vendor/product ID
100 // we are doing this mainly for testing purposes
101 uint16_t vendor = usb_device_get_vendor_id(device);
102 uint16_t product = usb_device_get_product_id(device);
103 if (!isMtpDevice(vendor, product)) {
104 // not an MTP or PTP device
105 continue;
106 }
107 // request MTP OS string and descriptor
108 // some music players need to see this before entering MTP mode.
109 char buffer[256];
110 memset(buffer, 0, sizeof(buffer));
111 int ret = usb_device_control_transfer(device,
112 USB_DIR_IN|USB_RECIP_DEVICE|USB_TYPE_STANDARD,
113 USB_REQ_GET_DESCRIPTOR, (USB_DT_STRING << 8) | 0xEE,
114 0, buffer, sizeof(buffer), 0);
115 printf("usb_device_control_transfer returned %d errno: %d\n", ret, errno);
116 if (ret > 0) {
117 printf("got MTP string %s\n", buffer);
118 ret = usb_device_control_transfer(device,
119 USB_DIR_IN|USB_RECIP_DEVICE|USB_TYPE_VENDOR, 1,
120 0, 4, buffer, sizeof(buffer), 0);
121 printf("OS descriptor got %d\n", ret);
122 } else {
123 printf("no MTP string\n");
124 }
125 }
126 #endif
127 // if we got here, then we have a likely MTP or PTP device
128
129 // interface should be followed by three endpoints
130 struct usb_endpoint_descriptor *ep;
131 struct usb_endpoint_descriptor *ep_in_desc = NULL;
132 struct usb_endpoint_descriptor *ep_out_desc = NULL;
133 struct usb_endpoint_descriptor *ep_intr_desc = NULL;
134 for (int i = 0; i < 3; i++) {
135 ep = (struct usb_endpoint_descriptor *)usb_descriptor_iter_next(&iter);
136 if (!ep || ep->bDescriptorType != USB_DT_ENDPOINT) {
137 ALOGE("endpoints not found\n");
138 usb_device_close(device);
139 return NULL;
140 }
141 if (ep->bmAttributes == USB_ENDPOINT_XFER_BULK) {
142 if (ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK)
143 ep_in_desc = ep;
144 else
145 ep_out_desc = ep;
146 } else if (ep->bmAttributes == USB_ENDPOINT_XFER_INT &&
147 ep->bEndpointAddress & USB_ENDPOINT_DIR_MASK) {
148 ep_intr_desc = ep;
149 }
150 }
151 if (!ep_in_desc || !ep_out_desc || !ep_intr_desc) {
152 ALOGE("endpoints not found\n");
153 usb_device_close(device);
154 return NULL;
155 }
156
157 if (usb_device_claim_interface(device, interface->bInterfaceNumber)) {
158 ALOGE("usb_device_claim_interface failed errno: %d\n", errno);
159 usb_device_close(device);
160 return NULL;
161 }
162
163 MtpDevice* mtpDevice = new MtpDevice(device, interface->bInterfaceNumber,
164 ep_in_desc, ep_out_desc, ep_intr_desc);
165 mtpDevice->initialize();
166 return mtpDevice;
167 }
168 }
169
170 usb_device_close(device);
171 ALOGE("device not found");
172 return NULL;
173 }
174
MtpDevice(struct usb_device * device,int interface,const struct usb_endpoint_descriptor * ep_in,const struct usb_endpoint_descriptor * ep_out,const struct usb_endpoint_descriptor * ep_intr)175 MtpDevice::MtpDevice(struct usb_device* device, int interface,
176 const struct usb_endpoint_descriptor *ep_in,
177 const struct usb_endpoint_descriptor *ep_out,
178 const struct usb_endpoint_descriptor *ep_intr)
179 : mDevice(device),
180 mInterface(interface),
181 mRequestIn1(NULL),
182 mRequestIn2(NULL),
183 mRequestOut(NULL),
184 mRequestIntr(NULL),
185 mDeviceInfo(NULL),
186 mSessionID(0),
187 mTransactionID(0),
188 mReceivedResponse(false)
189 {
190 mRequestIn1 = usb_request_new(device, ep_in);
191 mRequestIn2 = usb_request_new(device, ep_in);
192 mRequestOut = usb_request_new(device, ep_out);
193 mRequestIntr = usb_request_new(device, ep_intr);
194 }
195
~MtpDevice()196 MtpDevice::~MtpDevice() {
197 close();
198 for (size_t i = 0; i < mDeviceProperties.size(); i++)
199 delete mDeviceProperties[i];
200 usb_request_free(mRequestIn1);
201 usb_request_free(mRequestIn2);
202 usb_request_free(mRequestOut);
203 usb_request_free(mRequestIntr);
204 }
205
initialize()206 void MtpDevice::initialize() {
207 openSession();
208 mDeviceInfo = getDeviceInfo();
209 if (mDeviceInfo) {
210 if (mDeviceInfo->mDeviceProperties) {
211 int count = mDeviceInfo->mDeviceProperties->size();
212 for (int i = 0; i < count; i++) {
213 MtpDeviceProperty propCode = (*mDeviceInfo->mDeviceProperties)[i];
214 MtpProperty* property = getDevicePropDesc(propCode);
215 if (property)
216 mDeviceProperties.push(property);
217 }
218 }
219 }
220 }
221
close()222 void MtpDevice::close() {
223 if (mDevice) {
224 usb_device_release_interface(mDevice, mInterface);
225 usb_device_close(mDevice);
226 mDevice = NULL;
227 }
228 }
229
print()230 void MtpDevice::print() {
231 if (mDeviceInfo) {
232 mDeviceInfo->print();
233
234 if (mDeviceInfo->mDeviceProperties) {
235 ALOGI("***** DEVICE PROPERTIES *****\n");
236 int count = mDeviceInfo->mDeviceProperties->size();
237 for (int i = 0; i < count; i++) {
238 MtpDeviceProperty propCode = (*mDeviceInfo->mDeviceProperties)[i];
239 MtpProperty* property = getDevicePropDesc(propCode);
240 if (property) {
241 property->print();
242 delete property;
243 }
244 }
245 }
246 }
247
248 if (mDeviceInfo->mPlaybackFormats) {
249 ALOGI("***** OBJECT PROPERTIES *****\n");
250 int count = mDeviceInfo->mPlaybackFormats->size();
251 for (int i = 0; i < count; i++) {
252 MtpObjectFormat format = (*mDeviceInfo->mPlaybackFormats)[i];
253 ALOGI("*** FORMAT: %s\n", MtpDebug::getFormatCodeName(format));
254 MtpObjectPropertyList* props = getObjectPropsSupported(format);
255 if (props) {
256 for (size_t j = 0; j < props->size(); j++) {
257 MtpObjectProperty prop = (*props)[j];
258 MtpProperty* property = getObjectPropDesc(prop, format);
259 if (property) {
260 property->print();
261 delete property;
262 } else {
263 ALOGE("could not fetch property: %s",
264 MtpDebug::getObjectPropCodeName(prop));
265 }
266 }
267 }
268 }
269 }
270 }
271
getDeviceName()272 const char* MtpDevice::getDeviceName() {
273 if (mDevice)
274 return usb_device_get_name(mDevice);
275 else
276 return "???";
277 }
278
openSession()279 bool MtpDevice::openSession() {
280 Mutex::Autolock autoLock(mMutex);
281
282 mSessionID = 0;
283 mTransactionID = 0;
284 MtpSessionID newSession = 1;
285 mRequest.reset();
286 mRequest.setParameter(1, newSession);
287 if (!sendRequest(MTP_OPERATION_OPEN_SESSION))
288 return false;
289 MtpResponseCode ret = readResponse();
290 if (ret == MTP_RESPONSE_SESSION_ALREADY_OPEN)
291 newSession = mResponse.getParameter(1);
292 else if (ret != MTP_RESPONSE_OK)
293 return false;
294
295 mSessionID = newSession;
296 mTransactionID = 1;
297 return true;
298 }
299
closeSession()300 bool MtpDevice::closeSession() {
301 // FIXME
302 return true;
303 }
304
getDeviceInfo()305 MtpDeviceInfo* MtpDevice::getDeviceInfo() {
306 Mutex::Autolock autoLock(mMutex);
307
308 mRequest.reset();
309 if (!sendRequest(MTP_OPERATION_GET_DEVICE_INFO))
310 return NULL;
311 if (!readData())
312 return NULL;
313 MtpResponseCode ret = readResponse();
314 if (ret == MTP_RESPONSE_OK) {
315 MtpDeviceInfo* info = new MtpDeviceInfo;
316 if (info->read(mData))
317 return info;
318 else
319 delete info;
320 }
321 return NULL;
322 }
323
getStorageIDs()324 MtpStorageIDList* MtpDevice::getStorageIDs() {
325 Mutex::Autolock autoLock(mMutex);
326
327 mRequest.reset();
328 if (!sendRequest(MTP_OPERATION_GET_STORAGE_IDS))
329 return NULL;
330 if (!readData())
331 return NULL;
332 MtpResponseCode ret = readResponse();
333 if (ret == MTP_RESPONSE_OK) {
334 return mData.getAUInt32();
335 }
336 return NULL;
337 }
338
getStorageInfo(MtpStorageID storageID)339 MtpStorageInfo* MtpDevice::getStorageInfo(MtpStorageID storageID) {
340 Mutex::Autolock autoLock(mMutex);
341
342 mRequest.reset();
343 mRequest.setParameter(1, storageID);
344 if (!sendRequest(MTP_OPERATION_GET_STORAGE_INFO))
345 return NULL;
346 if (!readData())
347 return NULL;
348 MtpResponseCode ret = readResponse();
349 if (ret == MTP_RESPONSE_OK) {
350 MtpStorageInfo* info = new MtpStorageInfo(storageID);
351 if (info->read(mData))
352 return info;
353 else
354 delete info;
355 }
356 return NULL;
357 }
358
getObjectHandles(MtpStorageID storageID,MtpObjectFormat format,MtpObjectHandle parent)359 MtpObjectHandleList* MtpDevice::getObjectHandles(MtpStorageID storageID,
360 MtpObjectFormat format, MtpObjectHandle parent) {
361 Mutex::Autolock autoLock(mMutex);
362
363 mRequest.reset();
364 mRequest.setParameter(1, storageID);
365 mRequest.setParameter(2, format);
366 mRequest.setParameter(3, parent);
367 if (!sendRequest(MTP_OPERATION_GET_OBJECT_HANDLES))
368 return NULL;
369 if (!readData())
370 return NULL;
371 MtpResponseCode ret = readResponse();
372 if (ret == MTP_RESPONSE_OK) {
373 return mData.getAUInt32();
374 }
375 return NULL;
376 }
377
getObjectInfo(MtpObjectHandle handle)378 MtpObjectInfo* MtpDevice::getObjectInfo(MtpObjectHandle handle) {
379 Mutex::Autolock autoLock(mMutex);
380
381 // FIXME - we might want to add some caching here
382
383 mRequest.reset();
384 mRequest.setParameter(1, handle);
385 if (!sendRequest(MTP_OPERATION_GET_OBJECT_INFO))
386 return NULL;
387 if (!readData())
388 return NULL;
389 MtpResponseCode ret = readResponse();
390 if (ret == MTP_RESPONSE_OK) {
391 MtpObjectInfo* info = new MtpObjectInfo(handle);
392 if (info->read(mData))
393 return info;
394 else
395 delete info;
396 }
397 return NULL;
398 }
399
getThumbnail(MtpObjectHandle handle,int & outLength)400 void* MtpDevice::getThumbnail(MtpObjectHandle handle, int& outLength) {
401 Mutex::Autolock autoLock(mMutex);
402
403 mRequest.reset();
404 mRequest.setParameter(1, handle);
405 if (sendRequest(MTP_OPERATION_GET_THUMB) && readData()) {
406 MtpResponseCode ret = readResponse();
407 if (ret == MTP_RESPONSE_OK) {
408 return mData.getData(outLength);
409 }
410 }
411 outLength = 0;
412 return NULL;
413 }
414
sendObjectInfo(MtpObjectInfo * info)415 MtpObjectHandle MtpDevice::sendObjectInfo(MtpObjectInfo* info) {
416 Mutex::Autolock autoLock(mMutex);
417
418 mRequest.reset();
419 MtpObjectHandle parent = info->mParent;
420 if (parent == 0)
421 parent = MTP_PARENT_ROOT;
422
423 mRequest.setParameter(1, info->mStorageID);
424 mRequest.setParameter(2, info->mParent);
425
426 mData.putUInt32(info->mStorageID);
427 mData.putUInt16(info->mFormat);
428 mData.putUInt16(info->mProtectionStatus);
429 mData.putUInt32(info->mCompressedSize);
430 mData.putUInt16(info->mThumbFormat);
431 mData.putUInt32(info->mThumbCompressedSize);
432 mData.putUInt32(info->mThumbPixWidth);
433 mData.putUInt32(info->mThumbPixHeight);
434 mData.putUInt32(info->mImagePixWidth);
435 mData.putUInt32(info->mImagePixHeight);
436 mData.putUInt32(info->mImagePixDepth);
437 mData.putUInt32(info->mParent);
438 mData.putUInt16(info->mAssociationType);
439 mData.putUInt32(info->mAssociationDesc);
440 mData.putUInt32(info->mSequenceNumber);
441 mData.putString(info->mName);
442
443 char created[100], modified[100];
444 formatDateTime(info->mDateCreated, created, sizeof(created));
445 formatDateTime(info->mDateModified, modified, sizeof(modified));
446
447 mData.putString(created);
448 mData.putString(modified);
449 if (info->mKeywords)
450 mData.putString(info->mKeywords);
451 else
452 mData.putEmptyString();
453
454 if (sendRequest(MTP_OPERATION_SEND_OBJECT_INFO) && sendData()) {
455 MtpResponseCode ret = readResponse();
456 if (ret == MTP_RESPONSE_OK) {
457 info->mStorageID = mResponse.getParameter(1);
458 info->mParent = mResponse.getParameter(2);
459 info->mHandle = mResponse.getParameter(3);
460 return info->mHandle;
461 }
462 }
463 return (MtpObjectHandle)-1;
464 }
465
sendObject(MtpObjectInfo * info,int srcFD)466 bool MtpDevice::sendObject(MtpObjectInfo* info, int srcFD) {
467 Mutex::Autolock autoLock(mMutex);
468
469 int remaining = info->mCompressedSize;
470 mRequest.reset();
471 mRequest.setParameter(1, info->mHandle);
472 if (sendRequest(MTP_OPERATION_SEND_OBJECT)) {
473 // send data header
474 writeDataHeader(MTP_OPERATION_SEND_OBJECT, remaining);
475
476 char buffer[65536];
477 while (remaining > 0) {
478 int count = read(srcFD, buffer, sizeof(buffer));
479 if (count > 0) {
480 int written = mData.write(mRequestOut, buffer, count);
481 // FIXME check error
482 remaining -= count;
483 } else {
484 break;
485 }
486 }
487 }
488 MtpResponseCode ret = readResponse();
489 return (remaining == 0 && ret == MTP_RESPONSE_OK);
490 }
491
deleteObject(MtpObjectHandle handle)492 bool MtpDevice::deleteObject(MtpObjectHandle handle) {
493 Mutex::Autolock autoLock(mMutex);
494
495 mRequest.reset();
496 mRequest.setParameter(1, handle);
497 if (sendRequest(MTP_OPERATION_DELETE_OBJECT)) {
498 MtpResponseCode ret = readResponse();
499 if (ret == MTP_RESPONSE_OK)
500 return true;
501 }
502 return false;
503 }
504
getParent(MtpObjectHandle handle)505 MtpObjectHandle MtpDevice::getParent(MtpObjectHandle handle) {
506 MtpObjectInfo* info = getObjectInfo(handle);
507 if (info) {
508 MtpObjectHandle parent = info->mParent;
509 delete info;
510 return parent;
511 } else {
512 return -1;
513 }
514 }
515
getStorageID(MtpObjectHandle handle)516 MtpObjectHandle MtpDevice::getStorageID(MtpObjectHandle handle) {
517 MtpObjectInfo* info = getObjectInfo(handle);
518 if (info) {
519 MtpObjectHandle storageId = info->mStorageID;
520 delete info;
521 return storageId;
522 } else {
523 return -1;
524 }
525 }
526
getObjectPropsSupported(MtpObjectFormat format)527 MtpObjectPropertyList* MtpDevice::getObjectPropsSupported(MtpObjectFormat format) {
528 Mutex::Autolock autoLock(mMutex);
529
530 mRequest.reset();
531 mRequest.setParameter(1, format);
532 if (!sendRequest(MTP_OPERATION_GET_OBJECT_PROPS_SUPPORTED))
533 return NULL;
534 if (!readData())
535 return NULL;
536 MtpResponseCode ret = readResponse();
537 if (ret == MTP_RESPONSE_OK) {
538 return mData.getAUInt16();
539 }
540 return NULL;
541
542 }
543
getDevicePropDesc(MtpDeviceProperty code)544 MtpProperty* MtpDevice::getDevicePropDesc(MtpDeviceProperty code) {
545 Mutex::Autolock autoLock(mMutex);
546
547 mRequest.reset();
548 mRequest.setParameter(1, code);
549 if (!sendRequest(MTP_OPERATION_GET_DEVICE_PROP_DESC))
550 return NULL;
551 if (!readData())
552 return NULL;
553 MtpResponseCode ret = readResponse();
554 if (ret == MTP_RESPONSE_OK) {
555 MtpProperty* property = new MtpProperty;
556 if (property->read(mData))
557 return property;
558 else
559 delete property;
560 }
561 return NULL;
562 }
563
getObjectPropDesc(MtpObjectProperty code,MtpObjectFormat format)564 MtpProperty* MtpDevice::getObjectPropDesc(MtpObjectProperty code, MtpObjectFormat format) {
565 Mutex::Autolock autoLock(mMutex);
566
567 mRequest.reset();
568 mRequest.setParameter(1, code);
569 mRequest.setParameter(2, format);
570 if (!sendRequest(MTP_OPERATION_GET_OBJECT_PROP_DESC))
571 return NULL;
572 if (!readData())
573 return NULL;
574 MtpResponseCode ret = readResponse();
575 if (ret == MTP_RESPONSE_OK) {
576 MtpProperty* property = new MtpProperty;
577 if (property->read(mData))
578 return property;
579 else
580 delete property;
581 }
582 return NULL;
583 }
584
readObject(MtpObjectHandle handle,bool (* callback)(void * data,int offset,int length,void * clientData),size_t objectSize,void * clientData)585 bool MtpDevice::readObject(MtpObjectHandle handle,
586 bool (* callback)(void* data, int offset, int length, void* clientData),
587 size_t objectSize, void* clientData) {
588 Mutex::Autolock autoLock(mMutex);
589 bool result = false;
590
591 mRequest.reset();
592 mRequest.setParameter(1, handle);
593 if (sendRequest(MTP_OPERATION_GET_OBJECT)
594 && mData.readDataHeader(mRequestIn1)) {
595 uint32_t length = mData.getContainerLength();
596 if (length - MTP_CONTAINER_HEADER_SIZE != objectSize) {
597 ALOGE("readObject error objectSize: %d, length: %d",
598 objectSize, length);
599 goto fail;
600 }
601 length -= MTP_CONTAINER_HEADER_SIZE;
602 uint32_t remaining = length;
603 int offset = 0;
604
605 int initialDataLength = 0;
606 void* initialData = mData.getData(initialDataLength);
607 if (initialData) {
608 if (initialDataLength > 0) {
609 if (!callback(initialData, 0, initialDataLength, clientData))
610 goto fail;
611 remaining -= initialDataLength;
612 offset += initialDataLength;
613 }
614 free(initialData);
615 }
616
617 // USB reads greater than 16K don't work
618 char buffer1[16384], buffer2[16384];
619 mRequestIn1->buffer = buffer1;
620 mRequestIn2->buffer = buffer2;
621 struct usb_request* req = mRequestIn1;
622 void* writeBuffer = NULL;
623 int writeLength = 0;
624
625 while (remaining > 0 || writeBuffer) {
626 if (remaining > 0) {
627 // queue up a read request
628 req->buffer_length = (remaining > sizeof(buffer1) ? sizeof(buffer1) : remaining);
629 if (mData.readDataAsync(req)) {
630 ALOGE("readDataAsync failed");
631 goto fail;
632 }
633 } else {
634 req = NULL;
635 }
636
637 if (writeBuffer) {
638 // write previous buffer
639 if (!callback(writeBuffer, offset, writeLength, clientData)) {
640 ALOGE("write failed");
641 // wait for pending read before failing
642 if (req)
643 mData.readDataWait(mDevice);
644 goto fail;
645 }
646 offset += writeLength;
647 writeBuffer = NULL;
648 }
649
650 // wait for read to complete
651 if (req) {
652 int read = mData.readDataWait(mDevice);
653 if (read < 0)
654 goto fail;
655
656 if (read > 0) {
657 writeBuffer = req->buffer;
658 writeLength = read;
659 remaining -= read;
660 req = (req == mRequestIn1 ? mRequestIn2 : mRequestIn1);
661 } else {
662 writeBuffer = NULL;
663 }
664 }
665 }
666
667 MtpResponseCode response = readResponse();
668 if (response == MTP_RESPONSE_OK)
669 result = true;
670 }
671
672 fail:
673 return result;
674 }
675
676
677 // reads the object's data and writes it to the specified file path
readObject(MtpObjectHandle handle,const char * destPath,int group,int perm)678 bool MtpDevice::readObject(MtpObjectHandle handle, const char* destPath, int group, int perm) {
679 ALOGD("readObject: %s", destPath);
680 int fd = ::open(destPath, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
681 if (fd < 0) {
682 ALOGE("open failed for %s", destPath);
683 return false;
684 }
685
686 fchown(fd, getuid(), group);
687 // set permissions
688 int mask = umask(0);
689 fchmod(fd, perm);
690 umask(mask);
691
692 Mutex::Autolock autoLock(mMutex);
693 bool result = false;
694
695 mRequest.reset();
696 mRequest.setParameter(1, handle);
697 if (sendRequest(MTP_OPERATION_GET_OBJECT)
698 && mData.readDataHeader(mRequestIn1)) {
699 uint32_t length = mData.getContainerLength();
700 if (length < MTP_CONTAINER_HEADER_SIZE)
701 goto fail;
702 length -= MTP_CONTAINER_HEADER_SIZE;
703 uint32_t remaining = length;
704
705 int initialDataLength = 0;
706 void* initialData = mData.getData(initialDataLength);
707 if (initialData) {
708 if (initialDataLength > 0) {
709 if (write(fd, initialData, initialDataLength) != initialDataLength) {
710 free(initialData);
711 goto fail;
712 }
713 remaining -= initialDataLength;
714 }
715 free(initialData);
716 }
717
718 // USB reads greater than 16K don't work
719 char buffer1[16384], buffer2[16384];
720 mRequestIn1->buffer = buffer1;
721 mRequestIn2->buffer = buffer2;
722 struct usb_request* req = mRequestIn1;
723 void* writeBuffer = NULL;
724 int writeLength = 0;
725
726 while (remaining > 0 || writeBuffer) {
727 if (remaining > 0) {
728 // queue up a read request
729 req->buffer_length = (remaining > sizeof(buffer1) ? sizeof(buffer1) : remaining);
730 if (mData.readDataAsync(req)) {
731 ALOGE("readDataAsync failed");
732 goto fail;
733 }
734 } else {
735 req = NULL;
736 }
737
738 if (writeBuffer) {
739 // write previous buffer
740 if (write(fd, writeBuffer, writeLength) != writeLength) {
741 ALOGE("write failed");
742 // wait for pending read before failing
743 if (req)
744 mData.readDataWait(mDevice);
745 goto fail;
746 }
747 writeBuffer = NULL;
748 }
749
750 // wait for read to complete
751 if (req) {
752 int read = mData.readDataWait(mDevice);
753 if (read < 0)
754 goto fail;
755
756 if (read > 0) {
757 writeBuffer = req->buffer;
758 writeLength = read;
759 remaining -= read;
760 req = (req == mRequestIn1 ? mRequestIn2 : mRequestIn1);
761 } else {
762 writeBuffer = NULL;
763 }
764 }
765 }
766
767 MtpResponseCode response = readResponse();
768 if (response == MTP_RESPONSE_OK)
769 result = true;
770 }
771
772 fail:
773 ::close(fd);
774 return result;
775 }
776
sendRequest(MtpOperationCode operation)777 bool MtpDevice::sendRequest(MtpOperationCode operation) {
778 ALOGV("sendRequest: %s\n", MtpDebug::getOperationCodeName(operation));
779 mReceivedResponse = false;
780 mRequest.setOperationCode(operation);
781 if (mTransactionID > 0)
782 mRequest.setTransactionID(mTransactionID++);
783 int ret = mRequest.write(mRequestOut);
784 mRequest.dump();
785 return (ret > 0);
786 }
787
sendData()788 bool MtpDevice::sendData() {
789 ALOGV("sendData\n");
790 mData.setOperationCode(mRequest.getOperationCode());
791 mData.setTransactionID(mRequest.getTransactionID());
792 int ret = mData.write(mRequestOut);
793 mData.dump();
794 return (ret > 0);
795 }
796
readData()797 bool MtpDevice::readData() {
798 mData.reset();
799 int ret = mData.read(mRequestIn1);
800 ALOGV("readData returned %d\n", ret);
801 if (ret >= MTP_CONTAINER_HEADER_SIZE) {
802 if (mData.getContainerType() == MTP_CONTAINER_TYPE_RESPONSE) {
803 ALOGD("got response packet instead of data packet");
804 // we got a response packet rather than data
805 // copy it to mResponse
806 mResponse.copyFrom(mData);
807 mReceivedResponse = true;
808 return false;
809 }
810 mData.dump();
811 return true;
812 }
813 else {
814 ALOGV("readResponse failed\n");
815 return false;
816 }
817 }
818
writeDataHeader(MtpOperationCode operation,int dataLength)819 bool MtpDevice::writeDataHeader(MtpOperationCode operation, int dataLength) {
820 mData.setOperationCode(operation);
821 mData.setTransactionID(mRequest.getTransactionID());
822 return (!mData.writeDataHeader(mRequestOut, dataLength));
823 }
824
readResponse()825 MtpResponseCode MtpDevice::readResponse() {
826 ALOGV("readResponse\n");
827 if (mReceivedResponse) {
828 mReceivedResponse = false;
829 return mResponse.getResponseCode();
830 }
831 int ret = mResponse.read(mRequestIn1);
832 // handle zero length packets, which might occur if the data transfer
833 // ends on a packet boundary
834 if (ret == 0)
835 ret = mResponse.read(mRequestIn1);
836 if (ret >= MTP_CONTAINER_HEADER_SIZE) {
837 mResponse.dump();
838 return mResponse.getResponseCode();
839 } else {
840 ALOGD("readResponse failed\n");
841 return -1;
842 }
843 }
844
845 } // namespace android
846