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 (int 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 (int 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 info->read(mData); 317 return info; 318 } 319 return NULL; 320 } 321 getStorageIDs()322 MtpStorageIDList* MtpDevice::getStorageIDs() { 323 Mutex::Autolock autoLock(mMutex); 324 325 mRequest.reset(); 326 if (!sendRequest(MTP_OPERATION_GET_STORAGE_IDS)) 327 return NULL; 328 if (!readData()) 329 return NULL; 330 MtpResponseCode ret = readResponse(); 331 if (ret == MTP_RESPONSE_OK) { 332 return mData.getAUInt32(); 333 } 334 return NULL; 335 } 336 getStorageInfo(MtpStorageID storageID)337 MtpStorageInfo* MtpDevice::getStorageInfo(MtpStorageID storageID) { 338 Mutex::Autolock autoLock(mMutex); 339 340 mRequest.reset(); 341 mRequest.setParameter(1, storageID); 342 if (!sendRequest(MTP_OPERATION_GET_STORAGE_INFO)) 343 return NULL; 344 if (!readData()) 345 return NULL; 346 MtpResponseCode ret = readResponse(); 347 if (ret == MTP_RESPONSE_OK) { 348 MtpStorageInfo* info = new MtpStorageInfo(storageID); 349 info->read(mData); 350 return info; 351 } 352 return NULL; 353 } 354 getObjectHandles(MtpStorageID storageID,MtpObjectFormat format,MtpObjectHandle parent)355 MtpObjectHandleList* MtpDevice::getObjectHandles(MtpStorageID storageID, 356 MtpObjectFormat format, MtpObjectHandle parent) { 357 Mutex::Autolock autoLock(mMutex); 358 359 mRequest.reset(); 360 mRequest.setParameter(1, storageID); 361 mRequest.setParameter(2, format); 362 mRequest.setParameter(3, parent); 363 if (!sendRequest(MTP_OPERATION_GET_OBJECT_HANDLES)) 364 return NULL; 365 if (!readData()) 366 return NULL; 367 MtpResponseCode ret = readResponse(); 368 if (ret == MTP_RESPONSE_OK) { 369 return mData.getAUInt32(); 370 } 371 return NULL; 372 } 373 getObjectInfo(MtpObjectHandle handle)374 MtpObjectInfo* MtpDevice::getObjectInfo(MtpObjectHandle handle) { 375 Mutex::Autolock autoLock(mMutex); 376 377 // FIXME - we might want to add some caching here 378 379 mRequest.reset(); 380 mRequest.setParameter(1, handle); 381 if (!sendRequest(MTP_OPERATION_GET_OBJECT_INFO)) 382 return NULL; 383 if (!readData()) 384 return NULL; 385 MtpResponseCode ret = readResponse(); 386 if (ret == MTP_RESPONSE_OK) { 387 MtpObjectInfo* info = new MtpObjectInfo(handle); 388 info->read(mData); 389 return info; 390 } 391 return NULL; 392 } 393 getThumbnail(MtpObjectHandle handle,int & outLength)394 void* MtpDevice::getThumbnail(MtpObjectHandle handle, int& outLength) { 395 Mutex::Autolock autoLock(mMutex); 396 397 mRequest.reset(); 398 mRequest.setParameter(1, handle); 399 if (sendRequest(MTP_OPERATION_GET_THUMB) && readData()) { 400 MtpResponseCode ret = readResponse(); 401 if (ret == MTP_RESPONSE_OK) { 402 return mData.getData(outLength); 403 } 404 } 405 outLength = 0; 406 return NULL; 407 } 408 sendObjectInfo(MtpObjectInfo * info)409 MtpObjectHandle MtpDevice::sendObjectInfo(MtpObjectInfo* info) { 410 Mutex::Autolock autoLock(mMutex); 411 412 mRequest.reset(); 413 MtpObjectHandle parent = info->mParent; 414 if (parent == 0) 415 parent = MTP_PARENT_ROOT; 416 417 mRequest.setParameter(1, info->mStorageID); 418 mRequest.setParameter(2, info->mParent); 419 420 mData.putUInt32(info->mStorageID); 421 mData.putUInt16(info->mFormat); 422 mData.putUInt16(info->mProtectionStatus); 423 mData.putUInt32(info->mCompressedSize); 424 mData.putUInt16(info->mThumbFormat); 425 mData.putUInt32(info->mThumbCompressedSize); 426 mData.putUInt32(info->mThumbPixWidth); 427 mData.putUInt32(info->mThumbPixHeight); 428 mData.putUInt32(info->mImagePixWidth); 429 mData.putUInt32(info->mImagePixHeight); 430 mData.putUInt32(info->mImagePixDepth); 431 mData.putUInt32(info->mParent); 432 mData.putUInt16(info->mAssociationType); 433 mData.putUInt32(info->mAssociationDesc); 434 mData.putUInt32(info->mSequenceNumber); 435 mData.putString(info->mName); 436 437 char created[100], modified[100]; 438 formatDateTime(info->mDateCreated, created, sizeof(created)); 439 formatDateTime(info->mDateModified, modified, sizeof(modified)); 440 441 mData.putString(created); 442 mData.putString(modified); 443 if (info->mKeywords) 444 mData.putString(info->mKeywords); 445 else 446 mData.putEmptyString(); 447 448 if (sendRequest(MTP_OPERATION_SEND_OBJECT_INFO) && sendData()) { 449 MtpResponseCode ret = readResponse(); 450 if (ret == MTP_RESPONSE_OK) { 451 info->mStorageID = mResponse.getParameter(1); 452 info->mParent = mResponse.getParameter(2); 453 info->mHandle = mResponse.getParameter(3); 454 return info->mHandle; 455 } 456 } 457 return (MtpObjectHandle)-1; 458 } 459 sendObject(MtpObjectInfo * info,int srcFD)460 bool MtpDevice::sendObject(MtpObjectInfo* info, int srcFD) { 461 Mutex::Autolock autoLock(mMutex); 462 463 int remaining = info->mCompressedSize; 464 mRequest.reset(); 465 mRequest.setParameter(1, info->mHandle); 466 if (sendRequest(MTP_OPERATION_SEND_OBJECT)) { 467 // send data header 468 writeDataHeader(MTP_OPERATION_SEND_OBJECT, remaining); 469 470 char buffer[65536]; 471 while (remaining > 0) { 472 int count = read(srcFD, buffer, sizeof(buffer)); 473 if (count > 0) { 474 int written = mData.write(mRequestOut, buffer, count); 475 // FIXME check error 476 remaining -= count; 477 } else { 478 break; 479 } 480 } 481 } 482 MtpResponseCode ret = readResponse(); 483 return (remaining == 0 && ret == MTP_RESPONSE_OK); 484 } 485 deleteObject(MtpObjectHandle handle)486 bool MtpDevice::deleteObject(MtpObjectHandle handle) { 487 Mutex::Autolock autoLock(mMutex); 488 489 mRequest.reset(); 490 mRequest.setParameter(1, handle); 491 if (sendRequest(MTP_OPERATION_DELETE_OBJECT)) { 492 MtpResponseCode ret = readResponse(); 493 if (ret == MTP_RESPONSE_OK) 494 return true; 495 } 496 return false; 497 } 498 getParent(MtpObjectHandle handle)499 MtpObjectHandle MtpDevice::getParent(MtpObjectHandle handle) { 500 MtpObjectInfo* info = getObjectInfo(handle); 501 if (info) { 502 MtpObjectHandle parent = info->mParent; 503 delete info; 504 return parent; 505 } else { 506 return -1; 507 } 508 } 509 getStorageID(MtpObjectHandle handle)510 MtpObjectHandle MtpDevice::getStorageID(MtpObjectHandle handle) { 511 MtpObjectInfo* info = getObjectInfo(handle); 512 if (info) { 513 MtpObjectHandle storageId = info->mStorageID; 514 delete info; 515 return storageId; 516 } else { 517 return -1; 518 } 519 } 520 getObjectPropsSupported(MtpObjectFormat format)521 MtpObjectPropertyList* MtpDevice::getObjectPropsSupported(MtpObjectFormat format) { 522 Mutex::Autolock autoLock(mMutex); 523 524 mRequest.reset(); 525 mRequest.setParameter(1, format); 526 if (!sendRequest(MTP_OPERATION_GET_OBJECT_PROPS_SUPPORTED)) 527 return NULL; 528 if (!readData()) 529 return NULL; 530 MtpResponseCode ret = readResponse(); 531 if (ret == MTP_RESPONSE_OK) { 532 return mData.getAUInt16(); 533 } 534 return NULL; 535 536 } 537 getDevicePropDesc(MtpDeviceProperty code)538 MtpProperty* MtpDevice::getDevicePropDesc(MtpDeviceProperty code) { 539 Mutex::Autolock autoLock(mMutex); 540 541 mRequest.reset(); 542 mRequest.setParameter(1, code); 543 if (!sendRequest(MTP_OPERATION_GET_DEVICE_PROP_DESC)) 544 return NULL; 545 if (!readData()) 546 return NULL; 547 MtpResponseCode ret = readResponse(); 548 if (ret == MTP_RESPONSE_OK) { 549 MtpProperty* property = new MtpProperty; 550 property->read(mData); 551 return property; 552 } 553 return NULL; 554 } 555 getObjectPropDesc(MtpObjectProperty code,MtpObjectFormat format)556 MtpProperty* MtpDevice::getObjectPropDesc(MtpObjectProperty code, MtpObjectFormat format) { 557 Mutex::Autolock autoLock(mMutex); 558 559 mRequest.reset(); 560 mRequest.setParameter(1, code); 561 mRequest.setParameter(2, format); 562 if (!sendRequest(MTP_OPERATION_GET_OBJECT_PROP_DESC)) 563 return NULL; 564 if (!readData()) 565 return NULL; 566 MtpResponseCode ret = readResponse(); 567 if (ret == MTP_RESPONSE_OK) { 568 MtpProperty* property = new MtpProperty; 569 property->read(mData); 570 return property; 571 } 572 return NULL; 573 } 574 readObject(MtpObjectHandle handle,bool (* callback)(void * data,int offset,int length,void * clientData),int objectSize,void * clientData)575 bool MtpDevice::readObject(MtpObjectHandle handle, 576 bool (* callback)(void* data, int offset, int length, void* clientData), 577 int objectSize, void* clientData) { 578 Mutex::Autolock autoLock(mMutex); 579 bool result = false; 580 581 mRequest.reset(); 582 mRequest.setParameter(1, handle); 583 if (sendRequest(MTP_OPERATION_GET_OBJECT) 584 && mData.readDataHeader(mRequestIn1)) { 585 uint32_t length = mData.getContainerLength(); 586 if (length - MTP_CONTAINER_HEADER_SIZE != objectSize) { 587 ALOGE("readObject error objectSize: %d, length: %d", 588 objectSize, length); 589 goto fail; 590 } 591 length -= MTP_CONTAINER_HEADER_SIZE; 592 uint32_t remaining = length; 593 int offset = 0; 594 595 int initialDataLength = 0; 596 void* initialData = mData.getData(initialDataLength); 597 if (initialData) { 598 if (initialDataLength > 0) { 599 if (!callback(initialData, 0, initialDataLength, clientData)) 600 goto fail; 601 remaining -= initialDataLength; 602 offset += initialDataLength; 603 } 604 free(initialData); 605 } 606 607 // USB reads greater than 16K don't work 608 char buffer1[16384], buffer2[16384]; 609 mRequestIn1->buffer = buffer1; 610 mRequestIn2->buffer = buffer2; 611 struct usb_request* req = mRequestIn1; 612 void* writeBuffer = NULL; 613 int writeLength = 0; 614 615 while (remaining > 0 || writeBuffer) { 616 if (remaining > 0) { 617 // queue up a read request 618 req->buffer_length = (remaining > sizeof(buffer1) ? sizeof(buffer1) : remaining); 619 if (mData.readDataAsync(req)) { 620 ALOGE("readDataAsync failed"); 621 goto fail; 622 } 623 } else { 624 req = NULL; 625 } 626 627 if (writeBuffer) { 628 // write previous buffer 629 if (!callback(writeBuffer, offset, writeLength, clientData)) { 630 ALOGE("write failed"); 631 // wait for pending read before failing 632 if (req) 633 mData.readDataWait(mDevice); 634 goto fail; 635 } 636 offset += writeLength; 637 writeBuffer = NULL; 638 } 639 640 // wait for read to complete 641 if (req) { 642 int read = mData.readDataWait(mDevice); 643 if (read < 0) 644 goto fail; 645 646 if (read > 0) { 647 writeBuffer = req->buffer; 648 writeLength = read; 649 remaining -= read; 650 req = (req == mRequestIn1 ? mRequestIn2 : mRequestIn1); 651 } else { 652 writeBuffer = NULL; 653 } 654 } 655 } 656 657 MtpResponseCode response = readResponse(); 658 if (response == MTP_RESPONSE_OK) 659 result = true; 660 } 661 662 fail: 663 return result; 664 } 665 666 667 // reads the object's data and writes it to the specified file path readObject(MtpObjectHandle handle,const char * destPath,int group,int perm)668 bool MtpDevice::readObject(MtpObjectHandle handle, const char* destPath, int group, int perm) { 669 ALOGD("readObject: %s", destPath); 670 int fd = ::open(destPath, O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR); 671 if (fd < 0) { 672 ALOGE("open failed for %s", destPath); 673 return false; 674 } 675 676 fchown(fd, getuid(), group); 677 // set permissions 678 int mask = umask(0); 679 fchmod(fd, perm); 680 umask(mask); 681 682 Mutex::Autolock autoLock(mMutex); 683 bool result = false; 684 685 mRequest.reset(); 686 mRequest.setParameter(1, handle); 687 if (sendRequest(MTP_OPERATION_GET_OBJECT) 688 && mData.readDataHeader(mRequestIn1)) { 689 uint32_t length = mData.getContainerLength(); 690 if (length < MTP_CONTAINER_HEADER_SIZE) 691 goto fail; 692 length -= MTP_CONTAINER_HEADER_SIZE; 693 uint32_t remaining = length; 694 695 int initialDataLength = 0; 696 void* initialData = mData.getData(initialDataLength); 697 if (initialData) { 698 if (initialDataLength > 0) { 699 if (write(fd, initialData, initialDataLength) != initialDataLength) { 700 free(initialData); 701 goto fail; 702 } 703 remaining -= initialDataLength; 704 } 705 free(initialData); 706 } 707 708 // USB reads greater than 16K don't work 709 char buffer1[16384], buffer2[16384]; 710 mRequestIn1->buffer = buffer1; 711 mRequestIn2->buffer = buffer2; 712 struct usb_request* req = mRequestIn1; 713 void* writeBuffer = NULL; 714 int writeLength = 0; 715 716 while (remaining > 0 || writeBuffer) { 717 if (remaining > 0) { 718 // queue up a read request 719 req->buffer_length = (remaining > sizeof(buffer1) ? sizeof(buffer1) : remaining); 720 if (mData.readDataAsync(req)) { 721 ALOGE("readDataAsync failed"); 722 goto fail; 723 } 724 } else { 725 req = NULL; 726 } 727 728 if (writeBuffer) { 729 // write previous buffer 730 if (write(fd, writeBuffer, writeLength) != writeLength) { 731 ALOGE("write failed"); 732 // wait for pending read before failing 733 if (req) 734 mData.readDataWait(mDevice); 735 goto fail; 736 } 737 writeBuffer = NULL; 738 } 739 740 // wait for read to complete 741 if (req) { 742 int read = mData.readDataWait(mDevice); 743 if (read < 0) 744 goto fail; 745 746 if (read > 0) { 747 writeBuffer = req->buffer; 748 writeLength = read; 749 remaining -= read; 750 req = (req == mRequestIn1 ? mRequestIn2 : mRequestIn1); 751 } else { 752 writeBuffer = NULL; 753 } 754 } 755 } 756 757 MtpResponseCode response = readResponse(); 758 if (response == MTP_RESPONSE_OK) 759 result = true; 760 } 761 762 fail: 763 ::close(fd); 764 return result; 765 } 766 sendRequest(MtpOperationCode operation)767 bool MtpDevice::sendRequest(MtpOperationCode operation) { 768 ALOGV("sendRequest: %s\n", MtpDebug::getOperationCodeName(operation)); 769 mReceivedResponse = false; 770 mRequest.setOperationCode(operation); 771 if (mTransactionID > 0) 772 mRequest.setTransactionID(mTransactionID++); 773 int ret = mRequest.write(mRequestOut); 774 mRequest.dump(); 775 return (ret > 0); 776 } 777 sendData()778 bool MtpDevice::sendData() { 779 ALOGV("sendData\n"); 780 mData.setOperationCode(mRequest.getOperationCode()); 781 mData.setTransactionID(mRequest.getTransactionID()); 782 int ret = mData.write(mRequestOut); 783 mData.dump(); 784 return (ret > 0); 785 } 786 readData()787 bool MtpDevice::readData() { 788 mData.reset(); 789 int ret = mData.read(mRequestIn1); 790 ALOGV("readData returned %d\n", ret); 791 if (ret >= MTP_CONTAINER_HEADER_SIZE) { 792 if (mData.getContainerType() == MTP_CONTAINER_TYPE_RESPONSE) { 793 ALOGD("got response packet instead of data packet"); 794 // we got a response packet rather than data 795 // copy it to mResponse 796 mResponse.copyFrom(mData); 797 mReceivedResponse = true; 798 return false; 799 } 800 mData.dump(); 801 return true; 802 } 803 else { 804 ALOGV("readResponse failed\n"); 805 return false; 806 } 807 } 808 writeDataHeader(MtpOperationCode operation,int dataLength)809 bool MtpDevice::writeDataHeader(MtpOperationCode operation, int dataLength) { 810 mData.setOperationCode(operation); 811 mData.setTransactionID(mRequest.getTransactionID()); 812 return (!mData.writeDataHeader(mRequestOut, dataLength)); 813 } 814 readResponse()815 MtpResponseCode MtpDevice::readResponse() { 816 ALOGV("readResponse\n"); 817 if (mReceivedResponse) { 818 mReceivedResponse = false; 819 return mResponse.getResponseCode(); 820 } 821 int ret = mResponse.read(mRequestIn1); 822 // handle zero length packets, which might occur if the data transfer 823 // ends on a packet boundary 824 if (ret == 0) 825 ret = mResponse.read(mRequestIn1); 826 if (ret >= MTP_CONTAINER_HEADER_SIZE) { 827 mResponse.dump(); 828 return mResponse.getResponseCode(); 829 } else { 830 ALOGD("readResponse failed\n"); 831 return -1; 832 } 833 } 834 835 } // namespace android 836