.gitignore0100644 0000000 0000000 00000000011 12767234553 011603 0ustar000000000 0000000 *~ *.pyc Android.mk0100644 0000000 0000000 00000001251 12767234553 011533 0ustar000000000 0000000 # # Copyright (C) 2008 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # LOCAL_PATH := $(my-dir) include $(call first-makefiles-under,$(LOCAL_PATH)) CleanSpec.mk0100644 0000000 0000000 00000005441 12767234553 012015 0ustar000000000 0000000 # Copyright (C) 2007 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # # If you don't need to do a full clean build but would like to touch # a file or delete some intermediate files, add a clean step to the end # of the list. These steps will only be run once, if they haven't been # run before. # # E.g.: # $(call add-clean-step, touch -c external/sqlite/sqlite3.h) # $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/STATIC_LIBRARIES/libz_intermediates) # # Always use "touch -c" and "rm -f" or "rm -rf" to gracefully deal with # files that are missing or have been moved. # # Use $(PRODUCT_OUT) to get to the "out/target/product/blah/" directory. # Use $(OUT_DIR) to refer to the "out" directory. # # If you need to re-do something that's already mentioned, just copy # the command and add it to the bottom of the list. E.g., if a change # that you made last week required touching a file and a change you # made today requires touching the same file, just copy the old # touch step and add it to the end of the list. # # ************************************************ # NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST # ************************************************ # For example: #$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/APPS/AndroidTests_intermediates) #$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/core_intermediates) #$(call add-clean-step, find $(OUT_DIR) -type f -name "IGTalkSession*" -print0 | xargs -0 rm -f) #$(call add-clean-step, rm -rf $(PRODUCT_OUT)/data/*) # ************************************************ # NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST # ************************************************ $(call add-clean-step, rm -rf $(PRODUCT_OUT)/root/init.rc) $(call add-clean-step, rm -rf $(PRODUCT_OUT)/root/init.rc) $(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/bin/reboot) $(call add-clean-step, rm -rf $(PRODUCT_OUT)/root/default.prop) $(call add-clean-step, rm -rf $(PRODUCT_OUT)/recovery/root/default.prop) $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/EXECUTABLES/lmkd_intermediates/import_includes) $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/SHARED_LIBRARIES/libsysutils_intermediates/import_includes) $(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/bin/grep $(PRODUCT_OUT)/system/bin/toolbox) MODULE_LICENSE_APACHE20100644 0000000 0000000 00000000000 12767234553 012746 0ustar000000000 0000000 NOTICE0100644 0000000 0000000 00000042420 12767234553 010531 0ustar000000000 0000000 ========================================================================= == NOTICE file corresponding to the section 4 d of == == the Apache License, Version 2.0, == == in this case for the Android-specific code. == ========================================================================= Android Code Copyright 2005-2008 The Android Open Source Project This product includes software developed as part of The Android Open Source Project (http://source.android.com). ========================================================================= == NOTICE file corresponding to the section 4 d of == == the Apache License, Version 2.0, == == in this case for Apache Commons code. == ========================================================================= Apache Commons Copyright 1999-2006 The Apache Software Foundation This product includes software developed at The Apache Software Foundation (http://www.apache.org/). ========================================================================= == NOTICE file corresponding to the section 4 d of == == the Apache License, Version 2.0, == == in this case for Jakarta Commons Logging. == ========================================================================= Jakarta Commons Logging (JCL) Copyright 2005,2006 The Apache Software Foundation. This product includes software developed at The Apache Software Foundation (http://www.apache.org/). ========================================================================= == NOTICE file corresponding to the section 4 d of == == the Apache License, Version 2.0, == == in this case for the Nuance code. == ========================================================================= These files are Copyright 2007 Nuance Communications, but released under the Apache2 License. ========================================================================= == NOTICE file corresponding to the section 4 d of == == the Apache License, Version 2.0, == == in this case for the Media Codecs code. == ========================================================================= Media Codecs These files are Copyright 1998 - 2009 PacketVideo, but released under the Apache2 License. ========================================================================= == NOTICE file corresponding to the section 4 d of == == the Apache License, Version 2.0, == == in this case for the TagSoup code. == ========================================================================= This file is part of TagSoup and is Copyright 2002-2008 by John Cowan. TagSoup is licensed under the Apache License, Version 2.0. You may obtain a copy of this license at http://www.apache.org/licenses/LICENSE-2.0 . You may also have additional legal rights not granted by this license. TagSoup is distributed in the hope that it will be useful, but unless required by applicable law or agreed to in writing, TagSoup is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied; not even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ========================================================================= == NOTICE file corresponding to the section 4 d of == == the Apache License, Version 2.0, == == in this case for Additional Codecs code. == ========================================================================= Additional Codecs These files are Copyright 2003-2010 VisualOn, but released under the Apache2 License. ========================================================================= == NOTICE file corresponding to the section 4 d of == == the Apache License, Version 2.0, == == in this case for the Audio Effects code. == ========================================================================= Audio Effects These files are Copyright (C) 2004-2010 NXP Software and Copyright (C) 2010 The Android Open Source Project, but released under the Apache2 License. Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS UNICODE, INC. LICENSE AGREEMENT - DATA FILES AND SOFTWARE Unicode Data Files include all data files under the directories http://www.unicode.org/Public/, http://www.unicode.org/reports/, and http://www.unicode.org/cldr/data/ . Unicode Software includes any source code published in the Unicode Standard or under the directories http://www.unicode.org/Public/, http://www.unicode.org/reports/, and http://www.unicode.org/cldr/data/. NOTICE TO USER: Carefully read the following legal agreement. BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"), YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE TERMS AND CONDITIONS OF THIS AGREEMENT. IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE THE DATA FILES OR SOFTWARE. COPYRIGHT AND PERMISSION NOTICE Copyright © 1991-2008 Unicode, Inc. All rights reserved. Distributed under the Terms of Use in http://www.unicode.org/copyright.html. Permission is hereby granted, free of charge, to any person obtaining a copy of the Unicode data files and any associated documentation (the "Data Files") or Unicode software and any associated documentation (the "Software") to deal in the Data Files or Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, and/or sell copies of the Data Files or Software, and to permit persons to whom the Data Files or Software are furnished to do so, provided that (a) the above copyright notice(s) and this permission notice appear with all copies of the Data Files or Software, (b) both the above copyright notice(s) and this permission notice appear in associated documentation, and (c) there is clear notice in each modified Data File or in the Software as well as in the documentation associated with the Data File(s) or Software that the data or software has been modified. THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THE DATA FILES OR SOFTWARE. Except as contained in this notice, the name of a copyright holder shall not be used in advertising or otherwise to promote the sale, use or other dealings in these Data Files or Software without prior written authorization of the copyright holder. adb/0040755 0000000 0000000 00000000000 12767234553 010354 5ustar000000000 0000000 adb/.clang-format0100644 0000000 0000000 00000000440 12767234553 012722 0ustar000000000 0000000 BasedOnStyle: Google AllowShortBlocksOnASingleLine: false AllowShortFunctionsOnASingleLine: false AccessModifierOffset: -2 ColumnLimit: 100 CommentPragmas: NOLINT:.* DerivePointerAlignment: false IndentWidth: 4 PointerAlignment: Left TabWidth: 4 UseTab: Never PenaltyExcessCharacter: 32 adb/Android.mk0100644 0000000 0000000 00000023003 12767234553 012260 0ustar000000000 0000000 # Copyright 2005 The Android Open Source Project # # Android.mk for adb # LOCAL_PATH:= $(call my-dir) adb_host_sanitize := adb_target_sanitize := adb_version := $(shell git -C $(LOCAL_PATH) rev-parse --short=12 HEAD 2>/dev/null)-android ADB_COMMON_CFLAGS := \ -Wall -Wextra -Werror \ -Wno-unused-parameter \ -Wno-missing-field-initializers \ -Wvla \ -DADB_REVISION='"$(adb_version)"' \ ADB_COMMON_linux_CFLAGS := \ -std=c++14 \ -Wexit-time-destructors \ ADB_COMMON_darwin_CFLAGS := \ -std=c++14 \ -Wexit-time-destructors \ # Define windows.h and tchar.h Unicode preprocessor symbols so that # CreateFile(), _tfopen(), etc. map to versions that take wchar_t*, breaking the # build if you accidentally pass char*. Fix by calling like: # std::wstring path_wide; # if (!android::base::UTF8ToWide(path_utf8, &path_wide)) { /* error handling */ } # CreateFileW(path_wide.c_str()); ADB_COMMON_windows_CFLAGS := \ -DUNICODE=1 -D_UNICODE=1 \ # libadb # ========================================================= # Much of adb is duplicated in bootable/recovery/minadb and fastboot. Changes # made to adb rarely get ported to the other two, so the trees have diverged a # bit. We'd like to stop this because it is a maintenance nightmare, but the # divergence makes this difficult to do all at once. For now, we will start # small by moving common files into a static library. Hopefully some day we can # get enough of adb in here that we no longer need minadb. https://b/17626262 LIBADB_SRC_FILES := \ adb.cpp \ adb_auth.cpp \ adb_io.cpp \ adb_listeners.cpp \ adb_trace.cpp \ adb_utils.cpp \ fdevent.cpp \ sockets.cpp \ transport.cpp \ transport_local.cpp \ transport_usb.cpp \ LIBADB_TEST_SRCS := \ adb_io_test.cpp \ adb_utils_test.cpp \ fdevent_test.cpp \ socket_test.cpp \ sysdeps_test.cpp \ transport_test.cpp \ LIBADB_CFLAGS := \ $(ADB_COMMON_CFLAGS) \ -fvisibility=hidden \ LIBADB_linux_CFLAGS := \ $(ADB_COMMON_linux_CFLAGS) \ LIBADB_darwin_CFLAGS := \ $(ADB_COMMON_darwin_CFLAGS) \ LIBADB_windows_CFLAGS := \ $(ADB_COMMON_windows_CFLAGS) \ LIBADB_darwin_SRC_FILES := \ get_my_path_darwin.cpp \ sysdeps_unix.cpp \ usb_osx.cpp \ LIBADB_linux_SRC_FILES := \ get_my_path_linux.cpp \ sysdeps_unix.cpp \ usb_linux.cpp \ LIBADB_windows_SRC_FILES := \ sysdeps_win32.cpp \ usb_windows.cpp \ LIBADB_TEST_windows_SRCS := \ sysdeps_win32_test.cpp \ include $(CLEAR_VARS) LOCAL_CLANG := true LOCAL_MODULE := libadbd LOCAL_CFLAGS := $(LIBADB_CFLAGS) -DADB_HOST=0 LOCAL_SRC_FILES := \ $(LIBADB_SRC_FILES) \ adb_auth_client.cpp \ jdwp_service.cpp \ usb_linux_client.cpp \ LOCAL_SANITIZE := $(adb_target_sanitize) # Even though we're building a static library (and thus there's no link step for # this to take effect), this adds the includes to our path. LOCAL_STATIC_LIBRARIES := libbase include $(BUILD_STATIC_LIBRARY) include $(CLEAR_VARS) LOCAL_MODULE := libadb LOCAL_MODULE_HOST_OS := darwin linux windows LOCAL_CFLAGS := $(LIBADB_CFLAGS) -DADB_HOST=1 LOCAL_CFLAGS_windows := $(LIBADB_windows_CFLAGS) LOCAL_CFLAGS_linux := $(LIBADB_linux_CFLAGS) LOCAL_CFLAGS_darwin := $(LIBADB_darwin_CFLAGS) LOCAL_SRC_FILES := \ $(LIBADB_SRC_FILES) \ adb_auth_host.cpp \ LOCAL_SRC_FILES_darwin := $(LIBADB_darwin_SRC_FILES) LOCAL_SRC_FILES_linux := $(LIBADB_linux_SRC_FILES) LOCAL_SRC_FILES_windows := $(LIBADB_windows_SRC_FILES) LOCAL_SANITIZE := $(adb_host_sanitize) # Even though we're building a static library (and thus there's no link step for # this to take effect), this adds the includes to our path. LOCAL_STATIC_LIBRARIES := libcrypto_static libbase LOCAL_C_INCLUDES_windows := development/host/windows/usb/api/ LOCAL_MULTILIB := first include $(BUILD_HOST_STATIC_LIBRARY) include $(CLEAR_VARS) LOCAL_CLANG := true LOCAL_MODULE := adbd_test LOCAL_CFLAGS := -DADB_HOST=0 $(LIBADB_CFLAGS) LOCAL_SRC_FILES := \ $(LIBADB_TEST_SRCS) \ $(LIBADB_TEST_linux_SRCS) \ shell_service.cpp \ shell_service_protocol.cpp \ shell_service_protocol_test.cpp \ shell_service_test.cpp \ LOCAL_SANITIZE := $(adb_target_sanitize) LOCAL_STATIC_LIBRARIES := libadbd LOCAL_SHARED_LIBRARIES := liblog libbase libcutils include $(BUILD_NATIVE_TEST) # libdiagnose_usb # ========================================================= include $(CLEAR_VARS) LOCAL_MODULE := libdiagnose_usb LOCAL_MODULE_HOST_OS := darwin linux windows LOCAL_CFLAGS := $(LIBADB_CFLAGS) LOCAL_SRC_FILES := diagnose_usb.cpp # Even though we're building a static library (and thus there's no link step for # this to take effect), this adds the includes to our path. LOCAL_STATIC_LIBRARIES := libbase include $(BUILD_HOST_STATIC_LIBRARY) # adb_test # ========================================================= include $(CLEAR_VARS) LOCAL_MODULE := adb_test LOCAL_MODULE_HOST_OS := darwin linux windows LOCAL_CFLAGS := -DADB_HOST=1 $(LIBADB_CFLAGS) LOCAL_CFLAGS_windows := $(LIBADB_windows_CFLAGS) LOCAL_CFLAGS_linux := $(LIBADB_linux_CFLAGS) LOCAL_CFLAGS_darwin := $(LIBADB_darwin_CFLAGS) LOCAL_SRC_FILES := \ $(LIBADB_TEST_SRCS) \ services.cpp \ shell_service_protocol.cpp \ shell_service_protocol_test.cpp \ LOCAL_SRC_FILES_linux := $(LIBADB_TEST_linux_SRCS) LOCAL_SRC_FILES_darwin := $(LIBADB_TEST_darwin_SRCS) LOCAL_SRC_FILES_windows := $(LIBADB_TEST_windows_SRCS) LOCAL_SANITIZE := $(adb_host_sanitize) LOCAL_SHARED_LIBRARIES := libbase LOCAL_STATIC_LIBRARIES := \ libadb \ libcrypto_static \ libcutils \ libdiagnose_usb \ # Set entrypoint to wmain from sysdeps_win32.cpp instead of main LOCAL_LDFLAGS_windows := -municode LOCAL_LDLIBS_linux := -lrt -ldl -lpthread LOCAL_LDLIBS_darwin := -framework CoreFoundation -framework IOKit LOCAL_LDLIBS_windows := -lws2_32 -luserenv LOCAL_STATIC_LIBRARIES_windows := AdbWinApi LOCAL_MULTILIB := first include $(BUILD_HOST_NATIVE_TEST) # adb device tracker (used by ddms) test tool # ========================================================= ifeq ($(HOST_OS),linux) include $(CLEAR_VARS) LOCAL_MODULE := adb_device_tracker_test LOCAL_CFLAGS := -DADB_HOST=1 $(LIBADB_CFLAGS) LOCAL_CFLAGS_windows := $(LIBADB_windows_CFLAGS) LOCAL_CFLAGS_linux := $(LIBADB_linux_CFLAGS) LOCAL_CFLAGS_darwin := $(LIBADB_darwin_CFLAGS) LOCAL_SRC_FILES := test_track_devices.cpp LOCAL_SANITIZE := $(adb_host_sanitize) LOCAL_SHARED_LIBRARIES := libbase LOCAL_STATIC_LIBRARIES := libadb libcrypto_static libcutils LOCAL_LDLIBS += -lrt -ldl -lpthread include $(BUILD_HOST_EXECUTABLE) endif # adb host tool # ========================================================= include $(CLEAR_VARS) LOCAL_LDLIBS_linux := -lrt -ldl -lpthread LOCAL_LDLIBS_darwin := -lpthread -framework CoreFoundation -framework IOKit -framework Carbon # Use wmain instead of main LOCAL_LDFLAGS_windows := -municode LOCAL_LDLIBS_windows := -lws2_32 -lgdi32 LOCAL_STATIC_LIBRARIES_windows := AdbWinApi LOCAL_REQUIRED_MODULES_windows := AdbWinApi AdbWinUsbApi LOCAL_SRC_FILES := \ adb_client.cpp \ client/main.cpp \ console.cpp \ commandline.cpp \ file_sync_client.cpp \ line_printer.cpp \ services.cpp \ shell_service_protocol.cpp \ LOCAL_CFLAGS += \ $(ADB_COMMON_CFLAGS) \ -D_GNU_SOURCE \ -DADB_HOST=1 \ LOCAL_CFLAGS_windows := \ $(ADB_COMMON_windows_CFLAGS) LOCAL_CFLAGS_linux := \ $(ADB_COMMON_linux_CFLAGS) \ LOCAL_CFLAGS_darwin := \ $(ADB_COMMON_darwin_CFLAGS) \ -Wno-sizeof-pointer-memaccess -Wno-unused-parameter \ LOCAL_MODULE := adb LOCAL_MODULE_TAGS := debug LOCAL_MODULE_HOST_OS := darwin linux windows LOCAL_SANITIZE := $(adb_host_sanitize) LOCAL_STATIC_LIBRARIES := \ libadb \ libbase \ libcrypto_static \ libdiagnose_usb \ liblog \ # Don't use libcutils on Windows. LOCAL_STATIC_LIBRARIES_darwin := libcutils LOCAL_STATIC_LIBRARIES_linux := libcutils LOCAL_CXX_STL := libc++_static # Don't add anything here, we don't want additional shared dependencies # on the host adb tool, and shared libraries that link against libc++ # will violate ODR LOCAL_SHARED_LIBRARIES := include $(BUILD_HOST_EXECUTABLE) $(call dist-for-goals,dist_files sdk win_sdk,$(LOCAL_BUILT_MODULE)) ifdef HOST_CROSS_OS # Archive adb.exe for win_sdk build. $(call dist-for-goals,win_sdk,$(ALL_MODULES.host_cross_adb.BUILT)) endif # adbd device daemon # ========================================================= include $(CLEAR_VARS) LOCAL_CLANG := true LOCAL_SRC_FILES := \ daemon/main.cpp \ services.cpp \ file_sync_service.cpp \ framebuffer_service.cpp \ remount_service.cpp \ set_verity_enable_state_service.cpp \ shell_service.cpp \ shell_service_protocol.cpp \ LOCAL_CFLAGS := \ $(ADB_COMMON_CFLAGS) \ $(ADB_COMMON_linux_CFLAGS) \ -DADB_HOST=0 \ -D_GNU_SOURCE \ -Wno-deprecated-declarations \ LOCAL_CFLAGS += -DALLOW_ADBD_NO_AUTH=$(if $(filter userdebug eng,$(TARGET_BUILD_VARIANT)),1,0) ifneq (,$(filter userdebug eng,$(TARGET_BUILD_VARIANT))) LOCAL_CFLAGS += -DALLOW_ADBD_DISABLE_VERITY=1 LOCAL_CFLAGS += -DALLOW_ADBD_ROOT=1 endif LOCAL_MODULE := adbd LOCAL_FORCE_STATIC_EXECUTABLE := true LOCAL_MODULE_PATH := $(TARGET_ROOT_OUT_SBIN) LOCAL_UNSTRIPPED_PATH := $(TARGET_ROOT_OUT_SBIN_UNSTRIPPED) LOCAL_C_INCLUDES += system/extras/ext4_utils LOCAL_SANITIZE := $(adb_target_sanitize) LOCAL_STATIC_LIBRARIES := \ libadbd \ libbase \ libfs_mgr \ libfec \ libfec_rs \ libselinux \ liblog \ libmincrypt \ libext4_utils_static \ libsquashfs_utils \ libcutils \ libbase \ libcrypto_static \ libminijail include $(BUILD_EXECUTABLE) adb/CPPLINT.cfg0100644 0000000 0000000 00000000140 12767234553 012136 0ustar000000000 0000000 set noparent filter=-build/header_guard,-build/include,-readability/function,-whitespace/indent adb/MODULE_LICENSE_APACHE20100644 0000000 0000000 00000000000 12767234553 013474 0ustar000000000 0000000 adb/NOTICE0100644 0000000 0000000 00000024776 12767234553 011275 0ustar000000000 0000000 Copyright (c) 2006-2009, The Android Open Source Project Copyright 2006, Brian Swetland Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS adb/OVERVIEW.TXT0100644 0000000 0000000 00000012625 12767234553 012226 0ustar000000000 0000000 Implementation notes regarding ADB. I. General Overview: The Android Debug Bridge (ADB) is used to: - keep track of all Android devices and emulators instances connected to or running on a given host developer machine - implement various control commands (e.g. "adb shell", "adb pull", etc..) for the benefit of clients (command-line users, or helper programs like DDMS). These commands are what is called a 'service' in ADB. As a whole, everything works through the following components: 1. The ADB server This is a background process that runs on the host machine. Its purpose if to sense the USB ports to know when devices are attached/removed, as well as when emulator instances start/stop. It thus maintains a list of "connected devices" and assigns a 'state' to each one of them: OFFLINE, BOOTLOADER, RECOVERY or ONLINE (more on this below). The ADB server is really one giant multiplexing loop whose purpose is to orchestrate the exchange of data (packets, really) between clients, services and devices. 2. The ADB daemon (adbd) The 'adbd' program runs as a background process within an Android device or emulated system. Its purpose is to connect to the ADB server (through USB for devices, through TCP for emulators) and provide a few services for clients that run on the host. The ADB server considers that a device is ONLINE when it has successfully connected to the adbd program within it. Otherwise, the device is OFFLINE, meaning that the ADB server detected a new device/emulator, but could not connect to the adbd daemon. the BOOTLOADER and RECOVERY states correspond to alternate states of devices when they are in the bootloader or recovery mode. 3. The ADB command-line client The 'adb' command-line program is used to run adb commands from a shell or a script. It first tries to locate the ADB server on the host machine, and will start one automatically if none is found. then, the client sends its service requests to the ADB server. It doesn't need to know. Currently, a single 'adb' binary is used for both the server and client. this makes distribution and starting the server easier. 4. Services There are essentially two kinds of services that a client can talk to. Host Services: these services run within the ADB Server and thus do not need to communicate with a device at all. A typical example is "adb devices" which is used to return the list of currently known devices and their state. They are a few couple other services though. Local Services: these services either run within the adbd daemon, or are started by it on the device. The ADB server is used to multiplex streams between the client and the service running in adbd. In this case its role is to initiate the connection, then of being a pass-through for the data. II. Protocol details: 1. Client <-> Server protocol: This details the protocol used between ADB clients and the ADB server itself. The ADB server listens on TCP:localhost:5037. A client sends a request using the following format: 1. A 4-byte hexadecimal string giving the length of the payload 2. Followed by the payload itself. For example, to query the ADB server for its internal version number, the client will do the following: 1. Connect to tcp:localhost:5037 2. Send the string "000Chost:version" to the corresponding socket The 'host:' prefix is used to indicate that the request is addressed to the server itself (we will talk about other kinds of requests later). The content length is encoded in ASCII for easier debugging. The server should answer a request with one of the following: 1. For success, the 4-byte "OKAY" string 2. For failure, the 4-byte "FAIL" string, followed by a 4-byte hex length, followed by a string giving the reason for failure. 3. As a special exception, for 'host:version', a 4-byte hex string corresponding to the server's internal version number Note that the connection is still alive after an OKAY, which allows the client to make other requests. But in certain cases, an OKAY will even change the state of the connection. For example, the case of the 'host:transport:' request, where '' is used to identify a given device/emulator; after the "OKAY" answer, all further requests made by the client will go directly to the corresponding adbd daemon. The file SERVICES.TXT lists all services currently implemented by ADB. 2. Transports: An ADB transport models a connection between the ADB server and one device or emulator. There are currently two kinds of transports: - USB transports, for physical devices through USB - Local transports, for emulators running on the host, connected to the server through TCP In theory, it should be possible to write a local transport that proxies a connection between an ADB server and a device/emulator connected to/ running on another machine. This hasn't been done yet though. Each transport can carry one or more multiplexed streams between clients and the device/emulator they point to. The ADB server must handle unexpected transport disconnections (e.g. when a device is physically unplugged) properly. adb/SERVICES.TXT0100644 0000000 0000000 00000023322 12767234553 012177 0ustar000000000 0000000 This file tries to document all requests a client can make to the ADB server of an adbd daemon. See the OVERVIEW.TXT document to understand what's going on here. HOST SERVICES: host:version Ask the ADB server for its internal version number. As a special exception, the server will respond with a 4-byte hex string corresponding to its internal version number, without any OKAY or FAIL. host:kill Ask the ADB server to quit immediately. This is used when the ADB client detects that an obsolete server is running after an upgrade. host:devices host:devices-l Ask to return the list of available Android devices and their state. devices-l includes the device paths in the state. After the OKAY, this is followed by a 4-byte hex len, and a string that will be dumped as-is by the client, then the connection is closed host:track-devices This is a variant of host:devices which doesn't close the connection. Instead, a new device list description is sent each time a device is added/removed or the state of a given device changes (hex4 + content). This allows tools like DDMS to track the state of connected devices in real-time without polling the server repeatedly. host:emulator: This is a special query that is sent to the ADB server when a new emulator starts up. is a decimal number corresponding to the emulator's ADB control port, i.e. the TCP port that the emulator will forward automatically to the adbd daemon running in the emulator system. This mechanism allows the ADB server to know when new emulator instances start. host:transport: Ask to switch the connection to the device/emulator identified by . After the OKAY response, every client request will be sent directly to the adbd daemon running on the device. (Used to implement the -s option) host:transport-usb Ask to switch the connection to one device connected through USB to the host machine. This will fail if there are more than one such devices. (Used to implement the -d convenience option) host:transport-local Ask to switch the connection to one emulator connected through TCP. This will fail if there is more than one such emulator instance running. (Used to implement the -e convenience option) host:transport-any Another host:transport variant. Ask to switch the connection to either the device or emulator connect to/running on the host. Will fail if there is more than one such device/emulator available. (Used when neither -s, -d or -e are provided) host-serial:: This is a special form of query, where the 'host-serial::' prefix can be used to indicate that the client is asking the ADB server for information related to a specific device. can be in one of the format described below. host-usb: A variant of host-serial used to target the single USB device connected to the host. This will fail if there is none or more than one. host-local: A variant of host-serial used to target the single emulator instance running on the host. This will fail if there is none or more than one. host: When asking for information related to a device, 'host:' can also be interpreted as 'any single device or emulator connected to/running on the host'. :get-product XXX :get-serialno Returns the serial number of the corresponding device/emulator. Note that emulator serial numbers are of the form "emulator-5554" :get-devpath Returns the device path of the corresponding device/emulator. :get-state Returns the state of a given device as a string. :forward:; Asks the ADB server to forward local connections from to the address on a given device. There, can be one of the host-serial/host-usb/host-local/host prefixes as described previously and indicates which device/emulator to target. the format of is one of: tcp: -> TCP connection on localhost: local: -> Unix local domain socket on the format of is one of: tcp: -> TCP localhost: on device local: -> Unix local domain socket on device jdwp: -> JDWP thread on VM process or even any one of the local services described below. :forward:norebind:; Same as :forward:; except that it will fail it there is already a forward connection from . Used to implement 'adb forward --no-rebind ' :killforward: Remove any existing forward local connection from . This is used to implement 'adb forward --remove ' :killforward-all Remove all forward network connections. This is used to implement 'adb forward --remove-all'. :list-forward List all existing forward connections from this server. This returns something that looks like the following: : The length of the payload, as 4 hexadecimal chars. : A series of lines of the following format: " " " " "\n" Where is a device serial number. is the host-specific endpoint (e.g. tcp:9000). is the device-specific endpoint. Used to implement 'adb forward --list'. LOCAL SERVICES: All the queries below assumed that you already switched the transport to a real device, or that you have used a query prefix as described above. shell:command arg1 arg2 ... Run 'command arg1 arg2 ...' in a shell on the device, and return its output and error streams. Note that arguments must be separated by spaces. If an argument contains a space, it must be quoted with double-quotes. Arguments cannot contain double quotes or things will go very wrong. Note that this is the non-interactive version of "adb shell" shell: Start an interactive shell session on the device. Redirect stdin/stdout/stderr as appropriate. Note that the ADB server uses this to implement "adb shell", but will also cook the input before sending it to the device (see interactive_shell() in commandline.c) remount: Ask adbd to remount the device's filesystem in read-write mode, instead of read-only. This is usually necessary before performing an "adb sync" or "adb push" request. This request may not succeed on certain builds which do not allow that. dev: Opens a device file and connects the client directly to it for read/write purposes. Useful for debugging, but may require special privileges and thus may not run on all devices. is a full path from the root of the filesystem. tcp: Tries to connect to tcp port on localhost. tcp:: Tries to connect to tcp port on machine from the device. This can be useful to debug some networking/proxy issues that can only be revealed on the device itself. local: Tries to connect to a Unix domain socket on the device localreserved: localabstract: localfilesystem: Variants of local: that are used to access other Android socket namespaces. framebuffer: This service is used to send snapshots of the framebuffer to a client. It requires sufficient privileges but works as follow: After the OKAY, the service sends 16-byte binary structure containing the following fields (little-endian format): depth: uint32_t: framebuffer depth size: uint32_t: framebuffer size in bytes width: uint32_t: framebuffer width in pixels height: uint32_t: framebuffer height in pixels With the current implementation, depth is always 16, and size is always width*height*2 Then, each time the client wants a snapshot, it should send one byte through the channel, which will trigger the service to send it 'size' bytes of framebuffer data. If the adbd daemon doesn't have sufficient privileges to open the framebuffer device, the connection is simply closed immediately. jdwp: Connects to the JDWP thread running in the VM of process . track-jdwp This is used to send the list of JDWP pids periodically to the client. The format of the returned data is the following: : the length of all content as a 4-char hexadecimal string : a series of ASCII lines of the following format: "\n" This service is used by DDMS to know which debuggable processes are running on the device/emulator. Note that there is no single-shot service to retrieve the list only once. sync: This starts the file synchronization service, used to implement "adb push" and "adb pull". Since this service is pretty complex, it will be detailed in a companion document named SYNC.TXT reverse: This implements the 'adb reverse' feature, i.e. the ability to reverse socket connections from a device to the host. is one of the forwarding commands that are described above, as in: list-forward forward:; forward:norebind:; killforward-all killforward: Note that in this case, corresponds to the socket on the device and corresponds to the socket on the host. The output of reverse:list-forward is the same as host:list-forward except that will be just 'host'. adb/SYNC.TXT0100644 0000000 0000000 00000006664 12767234553 011542 0ustar000000000 0000000 This file tries to document file related requests a client can make to the ADB server of an adbd daemon. See the OVERVIEW.TXT document to understand what's going on here. See the SERVICES.TXT to learn more about the other requests that are possible. SYNC SERVICES: Requesting the sync service ("sync:") using the protocol as described in SERVICES.TXT sets the connection in sync mode. This mode is a binary mode that differ from the regular adb protocol. The connection stays in sync mode until explicitly terminated (see below). After the initial "sync:" command is sent the server must respond with either "OKAY" or "FAIL" as per usual. In sync mode both the server and the client will frequently use eight-byte packets to communicate in this document called sync request and sync responses. The first four bytes is an id and specifies sync request is represented by four utf-8 characters. The last four bytes is a Little-Endian integer, with various uses. This number will be called "length" below. In fact all binary integers are Little-Endian in the sync mode. Sync mode is implicitly exited after each sync request, and normal adb communication follows as described in SERVICES.TXT. The following sync requests are accepted: LIST - List the files in a folder RECV - Retrieve a file from device SEND - Send a file to device STAT - Stat a file For all of the sync request above the must be followed by length number of bytes containing an utf-8 string with a remote filename. LIST: Lists files in the directory specified by the remote filename. The server will respond with zero or more directory entries or "dents". The directory entries will be returned in the following form 1. A four-byte sync response id "DENT" 2. A four-byte integer representing file mode. 3. A four-byte integer representing file size. 4. A four-byte integer representing last modified time. 5. A four-byte integer representing file name length. 6. length number of bytes containing an utf-8 string representing the file name. When an sync response "DONE" is received the listing is done. SEND: The remote file name is split into two parts separated by the last comma (","). The first part is the actual path, while the second is a decimal encoded file mode containing the permissions of the file on device. Note that some file types will be deleted before the copying starts, and if the transfer fails. Some file types will not be deleted, which allows adb push disk_image /some_block_device to work. After this the actual file is sent in chunks. Each chunk has the following format. A sync request with id "DATA" and length equal to the chunk size. After follows chunk size number of bytes. This is repeated until the file is transferred. Each chunk must not be larger than 64k. When the file is transferred a sync request "DONE" is sent, where length is set to the last modified time for the file. The server responds to this last request (but not to chuck requests) with an "OKAY" sync response (length can be ignored). RECV: Retrieves a file from device to a local file. The remote path is the path to the file that will be returned. Just as for the SEND sync request the file received is split up into chunks. The sync response id is "DATA" and length is the chuck size. After follows chunk size number of bytes. This is repeated until the file is transferred. Each chuck will not be larger than 64k. When the file is transferred a sync response "DONE" is retrieved where the length can be ignored. adb/adb.cpp0100644 0000000 0000000 00000122554 12767234553 011614 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG ADB #include "sysdeps.h" #include "adb.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "adb_auth.h" #include "adb_io.h" #include "adb_listeners.h" #include "adb_utils.h" #include "transport.h" #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0])) #if !ADB_HOST #include #include #include #endif std::string adb_version() { // Don't change the format of this --- it's parsed by ddmlib. return android::base::StringPrintf("Android Debug Bridge version %d.%d.%d\n" "Revision %s\n", ADB_VERSION_MAJOR, ADB_VERSION_MINOR, ADB_SERVER_VERSION, ADB_REVISION); } void fatal(const char *fmt, ...) { va_list ap; va_start(ap, fmt); fprintf(stderr, "error: "); vfprintf(stderr, fmt, ap); fprintf(stderr, "\n"); va_end(ap); exit(-1); } void fatal_errno(const char* fmt, ...) { va_list ap; va_start(ap, fmt); fprintf(stderr, "error: %s: ", strerror(errno)); vfprintf(stderr, fmt, ap); fprintf(stderr, "\n"); va_end(ap); exit(-1); } apacket* get_apacket(void) { apacket* p = reinterpret_cast(malloc(sizeof(apacket))); if (p == nullptr) { fatal("failed to allocate an apacket"); } memset(p, 0, sizeof(apacket) - MAX_PAYLOAD); return p; } void put_apacket(apacket *p) { free(p); } void handle_online(atransport *t) { D("adb: online"); t->online = 1; } void handle_offline(atransport *t) { D("adb: offline"); //Close the associated usb t->online = 0; // This is necessary to avoid a race condition that occurred when a transport closes // while a client socket is still active. close_all_sockets(t); t->RunDisconnects(); } #if DEBUG_PACKETS #define DUMPMAX 32 void print_packet(const char *label, apacket *p) { char *tag; char *x; unsigned count; switch(p->msg.command){ case A_SYNC: tag = "SYNC"; break; case A_CNXN: tag = "CNXN" ; break; case A_OPEN: tag = "OPEN"; break; case A_OKAY: tag = "OKAY"; break; case A_CLSE: tag = "CLSE"; break; case A_WRTE: tag = "WRTE"; break; case A_AUTH: tag = "AUTH"; break; default: tag = "????"; break; } fprintf(stderr, "%s: %s %08x %08x %04x \"", label, tag, p->msg.arg0, p->msg.arg1, p->msg.data_length); count = p->msg.data_length; x = (char*) p->data; if(count > DUMPMAX) { count = DUMPMAX; tag = "\n"; } else { tag = "\"\n"; } while(count-- > 0){ if((*x >= ' ') && (*x < 127)) { fputc(*x, stderr); } else { fputc('.', stderr); } x++; } fputs(tag, stderr); } #endif static void send_ready(unsigned local, unsigned remote, atransport *t) { D("Calling send_ready"); apacket *p = get_apacket(); p->msg.command = A_OKAY; p->msg.arg0 = local; p->msg.arg1 = remote; send_packet(p, t); } static void send_close(unsigned local, unsigned remote, atransport *t) { D("Calling send_close"); apacket *p = get_apacket(); p->msg.command = A_CLSE; p->msg.arg0 = local; p->msg.arg1 = remote; send_packet(p, t); } std::string get_connection_string() { std::vector connection_properties; #if !ADB_HOST static const char* cnxn_props[] = { "ro.product.name", "ro.product.model", "ro.product.device", }; for (const auto& prop_name : cnxn_props) { char value[PROPERTY_VALUE_MAX]; property_get(prop_name, value, ""); connection_properties.push_back( android::base::StringPrintf("%s=%s", prop_name, value)); } #endif connection_properties.push_back(android::base::StringPrintf( "features=%s", FeatureSetToString(supported_features()).c_str())); return android::base::StringPrintf( "%s::%s", adb_device_banner, android::base::Join(connection_properties, ';').c_str()); } void send_connect(atransport* t) { D("Calling send_connect"); apacket* cp = get_apacket(); cp->msg.command = A_CNXN; cp->msg.arg0 = t->get_protocol_version(); cp->msg.arg1 = t->get_max_payload(); std::string connection_str = get_connection_string(); // Connect and auth packets are limited to MAX_PAYLOAD_V1 because we don't // yet know how much data the other size is willing to accept. if (connection_str.length() > MAX_PAYLOAD_V1) { LOG(FATAL) << "Connection banner is too long (length = " << connection_str.length() << ")"; } memcpy(cp->data, connection_str.c_str(), connection_str.length()); cp->msg.data_length = connection_str.length(); send_packet(cp, t); } // qual_overwrite is used to overwrite a qualifier string. dst is a // pointer to a char pointer. It is assumed that if *dst is non-NULL, it // was malloc'ed and needs to freed. *dst will be set to a dup of src. // TODO: switch to std::string for these atransport fields instead. static void qual_overwrite(char** dst, const std::string& src) { free(*dst); *dst = strdup(src.c_str()); } void parse_banner(const std::string& banner, atransport* t) { D("parse_banner: %s", banner.c_str()); // The format is something like: // "device::ro.product.name=x;ro.product.model=y;ro.product.device=z;". std::vector pieces = android::base::Split(banner, ":"); // Reset the features list or else if the server sends no features we may // keep the existing feature set (http://b/24405971). t->SetFeatures(""); if (pieces.size() > 2) { const std::string& props = pieces[2]; for (const auto& prop : android::base::Split(props, ";")) { // The list of properties was traditionally ;-terminated rather than ;-separated. if (prop.empty()) continue; std::vector key_value = android::base::Split(prop, "="); if (key_value.size() != 2) continue; const std::string& key = key_value[0]; const std::string& value = key_value[1]; if (key == "ro.product.name") { qual_overwrite(&t->product, value); } else if (key == "ro.product.model") { qual_overwrite(&t->model, value); } else if (key == "ro.product.device") { qual_overwrite(&t->device, value); } else if (key == "features") { t->SetFeatures(value); } } } const std::string& type = pieces[0]; if (type == "bootloader") { D("setting connection_state to kCsBootloader"); t->connection_state = kCsBootloader; update_transports(); } else if (type == "device") { D("setting connection_state to kCsDevice"); t->connection_state = kCsDevice; update_transports(); } else if (type == "recovery") { D("setting connection_state to kCsRecovery"); t->connection_state = kCsRecovery; update_transports(); } else if (type == "sideload") { D("setting connection_state to kCsSideload"); t->connection_state = kCsSideload; update_transports(); } else { D("setting connection_state to kCsHost"); t->connection_state = kCsHost; } } static void handle_new_connection(atransport* t, apacket* p) { if (t->connection_state != kCsOffline) { t->connection_state = kCsOffline; handle_offline(t); } t->update_version(p->msg.arg0, p->msg.arg1); std::string banner(reinterpret_cast(p->data), p->msg.data_length); parse_banner(banner, t); #if ADB_HOST handle_online(t); #else if (!auth_required) { handle_online(t); send_connect(t); } else { send_auth_request(t); } #endif } void handle_packet(apacket *p, atransport *t) { asocket *s; D("handle_packet() %c%c%c%c", ((char*) (&(p->msg.command)))[0], ((char*) (&(p->msg.command)))[1], ((char*) (&(p->msg.command)))[2], ((char*) (&(p->msg.command)))[3]); print_packet("recv", p); switch(p->msg.command){ case A_SYNC: if(p->msg.arg0){ send_packet(p, t); #if ADB_HOST send_connect(t); #endif } else { t->connection_state = kCsOffline; handle_offline(t); send_packet(p, t); } return; case A_CNXN: // CONNECT(version, maxdata, "system-id-string") handle_new_connection(t, p); break; case A_AUTH: if (p->msg.arg0 == ADB_AUTH_TOKEN) { t->connection_state = kCsUnauthorized; t->key = adb_auth_nextkey(t->key); if (t->key) { send_auth_response(p->data, p->msg.data_length, t); } else { /* No more private keys to try, send the public key */ send_auth_publickey(t); } } else if (p->msg.arg0 == ADB_AUTH_SIGNATURE) { if (adb_auth_verify(t->token, p->data, p->msg.data_length)) { adb_auth_verified(t); t->failed_auth_attempts = 0; } else { if (t->failed_auth_attempts++ > 10) adb_sleep_ms(1000); send_auth_request(t); } } else if (p->msg.arg0 == ADB_AUTH_RSAPUBLICKEY) { adb_auth_confirm_key(p->data, p->msg.data_length, t); } break; case A_OPEN: /* OPEN(local-id, 0, "destination") */ if (t->online && p->msg.arg0 != 0 && p->msg.arg1 == 0) { char *name = (char*) p->data; name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] = 0; s = create_local_service_socket(name, t); if(s == 0) { send_close(0, p->msg.arg0, t); } else { s->peer = create_remote_socket(p->msg.arg0, t); s->peer->peer = s; send_ready(s->id, s->peer->id, t); s->ready(s); } } break; case A_OKAY: /* READY(local-id, remote-id, "") */ if (t->online && p->msg.arg0 != 0 && p->msg.arg1 != 0) { if((s = find_local_socket(p->msg.arg1, 0))) { if(s->peer == 0) { /* On first READY message, create the connection. */ s->peer = create_remote_socket(p->msg.arg0, t); s->peer->peer = s; s->ready(s); } else if (s->peer->id == p->msg.arg0) { /* Other READY messages must use the same local-id */ s->ready(s); } else { D("Invalid A_OKAY(%d,%d), expected A_OKAY(%d,%d) on transport %s", p->msg.arg0, p->msg.arg1, s->peer->id, p->msg.arg1, t->serial); } } else { // When receiving A_OKAY from device for A_OPEN request, the host server may // have closed the local socket because of client disconnection. Then we need // to send A_CLSE back to device to close the service on device. send_close(p->msg.arg1, p->msg.arg0, t); } } break; case A_CLSE: /* CLOSE(local-id, remote-id, "") or CLOSE(0, remote-id, "") */ if (t->online && p->msg.arg1 != 0) { if((s = find_local_socket(p->msg.arg1, p->msg.arg0))) { /* According to protocol.txt, p->msg.arg0 might be 0 to indicate * a failed OPEN only. However, due to a bug in previous ADB * versions, CLOSE(0, remote-id, "") was also used for normal * CLOSE() operations. * * This is bad because it means a compromised adbd could * send packets to close connections between the host and * other devices. To avoid this, only allow this if the local * socket has a peer on the same transport. */ if (p->msg.arg0 == 0 && s->peer && s->peer->transport != t) { D("Invalid A_CLSE(0, %u) from transport %s, expected transport %s", p->msg.arg1, t->serial, s->peer->transport->serial); } else { s->close(s); } } } break; case A_WRTE: /* WRITE(local-id, remote-id, ) */ if (t->online && p->msg.arg0 != 0 && p->msg.arg1 != 0) { if((s = find_local_socket(p->msg.arg1, p->msg.arg0))) { unsigned rid = p->msg.arg0; p->len = p->msg.data_length; if(s->enqueue(s, p) == 0) { D("Enqueue the socket"); send_ready(s->id, rid, t); } return; } } break; default: printf("handle_packet: what is %08x?!\n", p->msg.command); } put_apacket(p); } #if ADB_HOST #ifdef _WIN32 // Try to make a handle non-inheritable and if there is an error, don't output // any error info, but leave GetLastError() for the caller to read. This is // convenient if the caller is expecting that this may fail and they'd like to // ignore such a failure. static bool _try_make_handle_noninheritable(HANDLE h) { if (h != INVALID_HANDLE_VALUE && h != NULL) { return SetHandleInformation(h, HANDLE_FLAG_INHERIT, 0) ? true : false; } return true; } // Try to make a handle non-inheritable with the expectation that this should // succeed, so if this fails, output error info. static bool _make_handle_noninheritable(HANDLE h) { if (!_try_make_handle_noninheritable(h)) { // Show the handle value to give us a clue in case we have problems // with pseudo-handle values. fprintf(stderr, "Cannot make handle 0x%p non-inheritable: %s\n", h, android::base::SystemErrorCodeToString(GetLastError()).c_str()); return false; } return true; } // Create anonymous pipe, preventing inheritance of the read pipe and setting // security of the write pipe to sa. static bool _create_anonymous_pipe(unique_handle* pipe_read_out, unique_handle* pipe_write_out, SECURITY_ATTRIBUTES* sa) { HANDLE pipe_read_raw = NULL; HANDLE pipe_write_raw = NULL; if (!CreatePipe(&pipe_read_raw, &pipe_write_raw, sa, 0)) { fprintf(stderr, "Cannot create pipe: %s\n", android::base::SystemErrorCodeToString(GetLastError()).c_str()); return false; } unique_handle pipe_read(pipe_read_raw); pipe_read_raw = NULL; unique_handle pipe_write(pipe_write_raw); pipe_write_raw = NULL; if (!_make_handle_noninheritable(pipe_read.get())) { return false; } *pipe_read_out = std::move(pipe_read); *pipe_write_out = std::move(pipe_write); return true; } // Read from a pipe (that we take ownership of) and write the result to stdout/stderr. Return on // error or when the pipe is closed. Internally makes inheritable handles, so this should not be // called if subprocesses may be started concurrently. static unsigned _redirect_pipe_thread(HANDLE h, DWORD nStdHandle) { // Take ownership of the HANDLE and close when we're done. unique_handle read_pipe(h); const char* output_name = nStdHandle == STD_OUTPUT_HANDLE ? "stdout" : "stderr"; const int original_fd = fileno(nStdHandle == STD_OUTPUT_HANDLE ? stdout : stderr); std::unique_ptr stream(nullptr, fclose); if (original_fd == -1) { fprintf(stderr, "Failed to get file descriptor for %s: %s\n", output_name, strerror(errno)); return EXIT_FAILURE; } // If fileno() is -2, stdout/stderr is not associated with an output stream, so we should read, // but don't write. Otherwise, make a FILE* identical to stdout/stderr except that it is in // binary mode with no CR/LR translation since we're reading raw. if (original_fd >= 0) { // This internally makes a duplicate file handle that is inheritable, so callers should not // call this function if subprocesses may be started concurrently. const int fd = dup(original_fd); if (fd == -1) { fprintf(stderr, "Failed to duplicate file descriptor for %s: %s\n", output_name, strerror(errno)); return EXIT_FAILURE; } // Note that although we call fdopen() below with a binary flag, it may not adhere to that // flag, so we have to set the mode manually. if (_setmode(fd, _O_BINARY) == -1) { fprintf(stderr, "Failed to set binary mode for duplicate of %s: %s\n", output_name, strerror(errno)); unix_close(fd); return EXIT_FAILURE; } stream.reset(fdopen(fd, "wb")); if (stream.get() == nullptr) { fprintf(stderr, "Failed to open duplicate stream for %s: %s\n", output_name, strerror(errno)); unix_close(fd); return EXIT_FAILURE; } // Unbuffer the stream because it will be buffered by default and we want subprocess output // to be shown immediately. if (setvbuf(stream.get(), NULL, _IONBF, 0) == -1) { fprintf(stderr, "Failed to unbuffer %s: %s\n", output_name, strerror(errno)); return EXIT_FAILURE; } // fd will be closed when stream is closed. } while (true) { char buf[64 * 1024]; DWORD bytes_read = 0; if (!ReadFile(read_pipe.get(), buf, sizeof(buf), &bytes_read, NULL)) { const DWORD err = GetLastError(); // ERROR_BROKEN_PIPE is expected when the subprocess closes // the other end of the pipe. if (err == ERROR_BROKEN_PIPE) { return EXIT_SUCCESS; } else { fprintf(stderr, "Failed to read from %s: %s\n", output_name, android::base::SystemErrorCodeToString(err).c_str()); return EXIT_FAILURE; } } // Don't try to write if our stdout/stderr was not setup by the parent process. if (stream) { // fwrite() actually calls adb_fwrite() which can write UTF-8 to the console. const size_t bytes_written = fwrite(buf, 1, bytes_read, stream.get()); if (bytes_written != bytes_read) { fprintf(stderr, "Only wrote %zu of %lu bytes to %s\n", bytes_written, bytes_read, output_name); return EXIT_FAILURE; } } } } static unsigned __stdcall _redirect_stdout_thread(HANDLE h) { adb_thread_setname("stdout redirect"); return _redirect_pipe_thread(h, STD_OUTPUT_HANDLE); } static unsigned __stdcall _redirect_stderr_thread(HANDLE h) { adb_thread_setname("stderr redirect"); return _redirect_pipe_thread(h, STD_ERROR_HANDLE); } #endif int launch_server(int server_port) { #if defined(_WIN32) /* we need to start the server in the background */ /* we create a PIPE that will be used to wait for the server's "OK" */ /* message since the pipe handles must be inheritable, we use a */ /* security attribute */ SECURITY_ATTRIBUTES sa; sa.nLength = sizeof(sa); sa.lpSecurityDescriptor = NULL; sa.bInheritHandle = TRUE; // Redirect stdin to Windows /dev/null. If we instead pass an original // stdin/stdout/stderr handle and it is a console handle, when the adb // server starts up, the C Runtime will see a console handle for a process // that isn't connected to a console and it will configure // stdin/stdout/stderr to be closed. At that point, freopen() could be used // to reopen stderr/out, but it would take more massaging to fixup the file // descriptor number that freopen() uses. It's simplest to avoid all of this // complexity by just redirecting stdin to `nul' and then the C Runtime acts // as expected. unique_handle nul_read(CreateFileW(L"nul", GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, &sa, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)); if (nul_read.get() == INVALID_HANDLE_VALUE) { fprintf(stderr, "Cannot open 'nul': %s\n", android::base::SystemErrorCodeToString(GetLastError()).c_str()); return -1; } // Create pipes with non-inheritable read handle, inheritable write handle. We need to connect // the subprocess to pipes instead of just letting the subprocess inherit our existing // stdout/stderr handles because a DETACHED_PROCESS cannot write to a console that it is not // attached to. unique_handle ack_read, ack_write; if (!_create_anonymous_pipe(&ack_read, &ack_write, &sa)) { return -1; } unique_handle stdout_read, stdout_write; if (!_create_anonymous_pipe(&stdout_read, &stdout_write, &sa)) { return -1; } unique_handle stderr_read, stderr_write; if (!_create_anonymous_pipe(&stderr_read, &stderr_write, &sa)) { return -1; } /* Some programs want to launch an adb command and collect its output by * calling CreateProcess with inheritable stdout/stderr handles, then * using read() to get its output. When this happens, the stdout/stderr * handles passed to the adb client process will also be inheritable. * When starting the adb server here, care must be taken to reset them * to non-inheritable. * Otherwise, something bad happens: even if the adb command completes, * the calling process is stuck while read()-ing from the stdout/stderr * descriptors, because they're connected to corresponding handles in the * adb server process (even if the latter never uses/writes to them). * Note that even if we don't pass these handles in the STARTUPINFO struct, * if they're marked inheritable, they're still inherited, requiring us to * deal with this. * * If we're still having problems with inheriting random handles in the * future, consider using PROC_THREAD_ATTRIBUTE_HANDLE_LIST to explicitly * specify which handles should be inherited: http://blogs.msdn.com/b/oldnewthing/archive/2011/12/16/10248328.aspx * * Older versions of Windows return console pseudo-handles that cannot be * made non-inheritable, so ignore those failures. */ _try_make_handle_noninheritable(GetStdHandle(STD_INPUT_HANDLE)); _try_make_handle_noninheritable(GetStdHandle(STD_OUTPUT_HANDLE)); _try_make_handle_noninheritable(GetStdHandle(STD_ERROR_HANDLE)); STARTUPINFOW startup; ZeroMemory( &startup, sizeof(startup) ); startup.cb = sizeof(startup); startup.hStdInput = nul_read.get(); startup.hStdOutput = stdout_write.get(); startup.hStdError = stderr_write.get(); startup.dwFlags = STARTF_USESTDHANDLES; // Verify that the pipe_write handle value can be passed on the command line // as %d and that the rest of adb code can pass it around in an int. const int ack_write_as_int = cast_handle_to_int(ack_write.get()); if (cast_int_to_handle(ack_write_as_int) != ack_write.get()) { // If this fires, either handle values are larger than 32-bits or else // there is a bug in our casting. // https://msdn.microsoft.com/en-us/library/windows/desktop/aa384203%28v=vs.85%29.aspx fprintf(stderr, "Cannot fit pipe handle value into 32-bits: 0x%p\n", ack_write.get()); return -1; } // get path of current program WCHAR program_path[MAX_PATH]; const DWORD module_result = GetModuleFileNameW(NULL, program_path, arraysize(program_path)); if ((module_result >= arraysize(program_path)) || (module_result == 0)) { // String truncation or some other error. fprintf(stderr, "Cannot get executable path: %s\n", android::base::SystemErrorCodeToString(GetLastError()).c_str()); return -1; } WCHAR args[64]; snwprintf(args, arraysize(args), L"adb -P %d fork-server server --reply-fd %d", server_port, ack_write_as_int); PROCESS_INFORMATION pinfo; ZeroMemory(&pinfo, sizeof(pinfo)); if (!CreateProcessW( program_path, /* program path */ args, /* the fork-server argument will set the debug = 2 in the child */ NULL, /* process handle is not inheritable */ NULL, /* thread handle is not inheritable */ TRUE, /* yes, inherit some handles */ DETACHED_PROCESS, /* the new process doesn't have a console */ NULL, /* use parent's environment block */ NULL, /* use parent's starting directory */ &startup, /* startup info, i.e. std handles */ &pinfo )) { fprintf(stderr, "Cannot create process: %s\n", android::base::SystemErrorCodeToString(GetLastError()).c_str()); return -1; } unique_handle process_handle(pinfo.hProcess); pinfo.hProcess = NULL; // Close handles that we no longer need to complete the rest. CloseHandle(pinfo.hThread); pinfo.hThread = NULL; nul_read.reset(); ack_write.reset(); stdout_write.reset(); stderr_write.reset(); // Start threads to read from subprocess stdout/stderr and write to ours to make subprocess // errors easier to diagnose. Note that the threads internally create inheritable handles, but // that is ok because we've already spawned the subprocess. // In the past, reading from a pipe before the child process's C Runtime // started up and called GetFileType() caused a hang: http://blogs.msdn.com/b/oldnewthing/archive/2011/12/02/10243553.aspx#10244216 // This is reportedly fixed in Windows Vista: https://support.microsoft.com/en-us/kb/2009703 // I was unable to reproduce the problem on Windows XP. It sounds like a // Windows Update may have fixed this: https://www.duckware.com/tech/peeknamedpipe.html unique_handle stdout_thread(reinterpret_cast( _beginthreadex(NULL, 0, _redirect_stdout_thread, stdout_read.get(), 0, NULL))); if (stdout_thread.get() == nullptr) { fprintf(stderr, "Cannot create thread: %s\n", strerror(errno)); return -1; } stdout_read.release(); // Transfer ownership to new thread unique_handle stderr_thread(reinterpret_cast( _beginthreadex(NULL, 0, _redirect_stderr_thread, stderr_read.get(), 0, NULL))); if (stderr_thread.get() == nullptr) { fprintf(stderr, "Cannot create thread: %s\n", strerror(errno)); return -1; } stderr_read.release(); // Transfer ownership to new thread bool got_ack = false; // Wait for the "OK\n" message, for the pipe to be closed, or other error. { char temp[3]; DWORD count = 0; if (ReadFile(ack_read.get(), temp, sizeof(temp), &count, NULL)) { const CHAR expected[] = "OK\n"; const DWORD expected_length = arraysize(expected) - 1; if (count == expected_length && memcmp(temp, expected, expected_length) == 0) { got_ack = true; } else { fprintf(stderr, "ADB server didn't ACK\n"); } } else { const DWORD err = GetLastError(); // If the ACK was not written and the process exited, GetLastError() // is probably ERROR_BROKEN_PIPE, in which case that info is not // useful to the user. fprintf(stderr, "could not read ok from ADB Server%s\n", err == ERROR_BROKEN_PIPE ? "" : android::base::StringPrintf(": %s", android::base::SystemErrorCodeToString(err).c_str()).c_str()); } } // Always try to wait a bit for threads reading stdout/stderr to finish. // If the process started ok, it should close the pipes causing the threads // to finish. If the process had an error, it should exit, also causing // the pipes to be closed. In that case we want to read all of the output // and write it out so that the user can diagnose failures. const DWORD thread_timeout_ms = 15 * 1000; const HANDLE threads[] = { stdout_thread.get(), stderr_thread.get() }; const DWORD wait_result = WaitForMultipleObjects(arraysize(threads), threads, TRUE, thread_timeout_ms); if (wait_result == WAIT_TIMEOUT) { // Threads did not finish after waiting a little while. Perhaps the // server didn't close pipes, or it is hung. fprintf(stderr, "Timed-out waiting for threads to finish reading from " "ADB Server\n"); // Process handles are signaled when the process exits, so if we wait // on the handle for 0 seconds and it returns 'timeout', that means that // the process is still running. if (WaitForSingleObject(process_handle.get(), 0) == WAIT_TIMEOUT) { // We could TerminateProcess(), but that seems somewhat presumptive. fprintf(stderr, "ADB Server is running: process id %lu\n", pinfo.dwProcessId); } return -1; } if (wait_result != WAIT_OBJECT_0) { fprintf(stderr, "Unexpected result waiting for threads: %lu: %s\n", wait_result, android::base::SystemErrorCodeToString(GetLastError()).c_str()); return -1; } // For now ignore the thread exit codes and assume they worked properly. if (!got_ack) { return -1; } #else /* !defined(_WIN32) */ char path[PATH_MAX]; int fd[2]; // set up a pipe so the child can tell us when it is ready. // fd[0] will be parent's end, and the child will write on fd[1] if (pipe(fd)) { fprintf(stderr, "pipe failed in launch_server, errno: %d\n", errno); return -1; } get_my_path(path, PATH_MAX); pid_t pid = fork(); if(pid < 0) return -1; if (pid == 0) { // child side of the fork adb_close(fd[0]); char str_port[30]; snprintf(str_port, sizeof(str_port), "%d", server_port); char reply_fd[30]; snprintf(reply_fd, sizeof(reply_fd), "%d", fd[1]); // child process int result = execl(path, "adb", "-P", str_port, "fork-server", "server", "--reply-fd", reply_fd, NULL); // this should not return fprintf(stderr, "OOPS! execl returned %d, errno: %d\n", result, errno); } else { // parent side of the fork char temp[3]; temp[0] = 'A'; temp[1] = 'B'; temp[2] = 'C'; // wait for the "OK\n" message adb_close(fd[1]); int ret = adb_read(fd[0], temp, 3); int saved_errno = errno; adb_close(fd[0]); if (ret < 0) { fprintf(stderr, "could not read ok from ADB Server, errno = %d\n", saved_errno); return -1; } if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') { fprintf(stderr, "ADB server didn't ACK\n" ); return -1; } } #endif /* !defined(_WIN32) */ return 0; } #endif /* ADB_HOST */ // Try to handle a network forwarding request. // This returns 1 on success, 0 on failure, and -1 to indicate this is not // a forwarding-related request. int handle_forward_request(const char* service, TransportType type, const char* serial, int reply_fd) { if (!strcmp(service, "list-forward")) { // Create the list of forward redirections. std::string listeners = format_listeners(); #if ADB_HOST SendOkay(reply_fd); #endif return SendProtocolString(reply_fd, listeners); } if (!strcmp(service, "killforward-all")) { remove_all_listeners(); #if ADB_HOST /* On the host: 1st OKAY is connect, 2nd OKAY is status */ SendOkay(reply_fd); #endif SendOkay(reply_fd); return 1; } if (!strncmp(service, "forward:", 8) || !strncmp(service, "killforward:", 12)) { // killforward:local // forward:(norebind:)?local;remote bool kill_forward = false; bool no_rebind = false; if (android::base::StartsWith(service, "killforward:")) { kill_forward = true; service += 12; } else { service += 8; // skip past "forward:" if (android::base::StartsWith(service, "norebind:")) { no_rebind = true; service += 9; } } std::vector pieces = android::base::Split(service, ";"); if (kill_forward) { // Check killforward: parameter format: '' if (pieces.size() != 1 || pieces[0].empty()) { SendFail(reply_fd, android::base::StringPrintf("bad killforward: %s", service)); return 1; } } else { // Check forward: parameter format: ';' if (pieces.size() != 2 || pieces[0].empty() || pieces[1].empty() || pieces[1][0] == '*') { SendFail(reply_fd, android::base::StringPrintf("bad forward: %s", service)); return 1; } } std::string error_msg; atransport* transport = acquire_one_transport(type, serial, nullptr, &error_msg); if (!transport) { SendFail(reply_fd, error_msg); return 1; } std::string error; InstallStatus r; if (kill_forward) { r = remove_listener(pieces[0].c_str(), transport); } else { r = install_listener(pieces[0], pieces[1].c_str(), transport, no_rebind, &error); } if (r == INSTALL_STATUS_OK) { #if ADB_HOST /* On the host: 1st OKAY is connect, 2nd OKAY is status */ SendOkay(reply_fd); #endif SendOkay(reply_fd); return 1; } std::string message; switch (r) { case INSTALL_STATUS_OK: message = "success (!)"; break; case INSTALL_STATUS_INTERNAL_ERROR: message = "internal error"; break; case INSTALL_STATUS_CANNOT_BIND: message = android::base::StringPrintf("cannot bind listener: %s", error.c_str()); break; case INSTALL_STATUS_CANNOT_REBIND: message = android::base::StringPrintf("cannot rebind existing socket"); break; case INSTALL_STATUS_LISTENER_NOT_FOUND: message = android::base::StringPrintf("listener '%s' not found", service); break; } SendFail(reply_fd, message); return 1; } return 0; } #if ADB_HOST static int SendOkay(int fd, const std::string& s) { SendOkay(fd); SendProtocolString(fd, s); return 0; } #endif int handle_host_request(const char* service, TransportType type, const char* serial, int reply_fd, asocket* s) { if (strcmp(service, "kill") == 0) { fprintf(stderr, "adb server killed by remote request\n"); fflush(stdout); SendOkay(reply_fd); // On Windows, if the process exits with open sockets that // shutdown(SD_SEND) has not been called on, TCP RST segments will be // sent to the peers which will cause their next recv() to error-out // with WSAECONNRESET. In the case of this code, that means the client // may not read the OKAY sent above. adb_shutdown(reply_fd); exit(0); } #if ADB_HOST // "transport:" is used for switching transport with a specified serial number // "transport-usb:" is used for switching transport to the only USB transport // "transport-local:" is used for switching transport to the only local transport // "transport-any:" is used for switching transport to the only transport if (!strncmp(service, "transport", strlen("transport"))) { TransportType type = kTransportAny; if (!strncmp(service, "transport-usb", strlen("transport-usb"))) { type = kTransportUsb; } else if (!strncmp(service, "transport-local", strlen("transport-local"))) { type = kTransportLocal; } else if (!strncmp(service, "transport-any", strlen("transport-any"))) { type = kTransportAny; } else if (!strncmp(service, "transport:", strlen("transport:"))) { service += strlen("transport:"); serial = service; } std::string error; atransport* t = acquire_one_transport(type, serial, nullptr, &error); if (t != nullptr) { s->transport = t; SendOkay(reply_fd); } else { SendFail(reply_fd, error); } return 1; } // return a list of all connected devices if (!strncmp(service, "devices", 7)) { bool long_listing = (strcmp(service+7, "-l") == 0); if (long_listing || service[7] == 0) { D("Getting device list..."); std::string device_list = list_transports(long_listing); D("Sending device list..."); return SendOkay(reply_fd, device_list); } return 1; } if (!strcmp(service, "features")) { std::string error; atransport* t = acquire_one_transport(type, serial, nullptr, &error); if (t != nullptr) { SendOkay(reply_fd, FeatureSetToString(t->features())); } else { SendFail(reply_fd, error); } return 0; } // remove TCP transport if (!strncmp(service, "disconnect:", 11)) { const std::string address(service + 11); if (address.empty()) { kick_all_tcp_devices(); return SendOkay(reply_fd, "disconnected everything"); } std::string serial; std::string host; int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT; std::string error; if (!android::base::ParseNetAddress(address, &host, &port, &serial, &error)) { return SendFail(reply_fd, android::base::StringPrintf("couldn't parse '%s': %s", address.c_str(), error.c_str())); } atransport* t = find_transport(serial.c_str()); if (t == nullptr) { return SendFail(reply_fd, android::base::StringPrintf("no such device '%s'", serial.c_str())); } kick_transport(t); return SendOkay(reply_fd, android::base::StringPrintf("disconnected %s", address.c_str())); } // Returns our value for ADB_SERVER_VERSION. if (!strcmp(service, "version")) { return SendOkay(reply_fd, android::base::StringPrintf("%04x", ADB_SERVER_VERSION)); } // These always report "unknown" rather than the actual error, for scripts. if (!strcmp(service, "get-serialno")) { std::string error; atransport* t = acquire_one_transport(type, serial, nullptr, &error); if (t) { return SendOkay(reply_fd, t->serial ? t->serial : "unknown"); } else { return SendFail(reply_fd, error); } } if (!strcmp(service, "get-devpath")) { std::string error; atransport* t = acquire_one_transport(type, serial, nullptr, &error); if (t) { return SendOkay(reply_fd, t->devpath ? t->devpath : "unknown"); } else { return SendFail(reply_fd, error); } } if (!strcmp(service, "get-state")) { std::string error; atransport* t = acquire_one_transport(type, serial, nullptr, &error); if (t) { return SendOkay(reply_fd, t->connection_state_name()); } else { return SendFail(reply_fd, error); } } // Indicates a new emulator instance has started. if (!strncmp(service, "emulator:", 9)) { int port = atoi(service+9); local_connect(port); /* we don't even need to send a reply */ return 0; } if (!strcmp(service, "reconnect")) { if (s->transport != nullptr) { kick_transport(s->transport); } return SendOkay(reply_fd, "done"); } #endif // ADB_HOST int ret = handle_forward_request(service, type, serial, reply_fd); if (ret >= 0) return ret - 1; return -1; } adb/adb.h0100644 0000000 0000000 00000016002 12767234553 011247 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __ADB_H #define __ADB_H #include #include #include #include #include "adb_trace.h" #include "fdevent.h" #include "socket.h" constexpr size_t MAX_PAYLOAD_V1 = 4 * 1024; constexpr size_t MAX_PAYLOAD_V2 = 256 * 1024; constexpr size_t MAX_PAYLOAD = MAX_PAYLOAD_V2; #define A_SYNC 0x434e5953 #define A_CNXN 0x4e584e43 #define A_OPEN 0x4e45504f #define A_OKAY 0x59414b4f #define A_CLSE 0x45534c43 #define A_WRTE 0x45545257 #define A_AUTH 0x48545541 // ADB protocol version. #define A_VERSION 0x01000000 // Used for help/version information. #define ADB_VERSION_MAJOR 1 #define ADB_VERSION_MINOR 0 std::string adb_version(); // Increment this when we want to force users to start a new adb server. #define ADB_SERVER_VERSION 36 class atransport; struct usb_handle; struct amessage { unsigned command; /* command identifier constant */ unsigned arg0; /* first argument */ unsigned arg1; /* second argument */ unsigned data_length; /* length of payload (0 is allowed) */ unsigned data_check; /* checksum of data payload */ unsigned magic; /* command ^ 0xffffffff */ }; struct apacket { apacket *next; unsigned len; unsigned char *ptr; amessage msg; unsigned char data[MAX_PAYLOAD]; }; /* the adisconnect structure is used to record a callback that ** will be called whenever a transport is disconnected (e.g. by the user) ** this should be used to cleanup objects that depend on the ** transport (e.g. remote sockets, listeners, etc...) */ struct adisconnect { void (*func)(void* opaque, atransport* t); void* opaque; }; // A transport object models the connection to a remote device or emulator there // is one transport per connected device/emulator. A "local transport" connects // through TCP (for the emulator), while a "usb transport" through USB (for real // devices). // // Note that kTransportHost doesn't really correspond to a real transport // object, it's a special value used to indicate that a client wants to connect // to a service implemented within the ADB server itself. enum TransportType { kTransportUsb, kTransportLocal, kTransportAny, kTransportHost, }; #define TOKEN_SIZE 20 enum ConnectionState { kCsAny = -1, kCsOffline = 0, kCsBootloader, kCsDevice, kCsHost, kCsRecovery, kCsNoPerm, // Insufficient permissions to communicate with the device. kCsSideload, kCsUnauthorized, }; /* A listener is an entity which binds to a local port ** and, upon receiving a connection on that port, creates ** an asocket to connect the new local connection to a ** specific remote service. ** ** TODO: some listeners read from the new connection to ** determine what exact service to connect to on the far ** side. */ struct alistener { alistener *next; alistener *prev; fdevent fde; int fd; char *local_name; char *connect_to; atransport *transport; adisconnect disconnect; }; void print_packet(const char *label, apacket *p); // These use the system (v)fprintf, not the adb prefixed ones defined in sysdeps.h, so they // shouldn't be tagged with ADB_FORMAT_ARCHETYPE. void fatal(const char* fmt, ...) __attribute__((noreturn, format(__printf__, 1, 2))); void fatal_errno(const char* fmt, ...) __attribute__((noreturn, format(__printf__, 1, 2))); void handle_packet(apacket *p, atransport *t); void get_my_path(char *s, size_t maxLen); int launch_server(int server_port); int adb_server_main(int is_daemon, int server_port, int ack_reply_fd); /* initialize a transport object's func pointers and state */ #if ADB_HOST int get_available_local_transport_index(); #endif int init_socket_transport(atransport *t, int s, int port, int local); void init_usb_transport(atransport *t, usb_handle *usb, ConnectionState state); #if ADB_HOST atransport* find_emulator_transport_by_adb_port(int adb_port); #endif int service_to_fd(const char* name, const atransport* transport); #if ADB_HOST asocket *host_service_to_socket(const char* name, const char *serial); #endif #if !ADB_HOST int init_jdwp(void); asocket* create_jdwp_service_socket(); asocket* create_jdwp_tracker_service_socket(); int create_jdwp_connection_fd(int jdwp_pid); #endif int handle_forward_request(const char* service, TransportType type, const char* serial, int reply_fd); #if !ADB_HOST void framebuffer_service(int fd, void *cookie); void set_verity_enabled_state_service(int fd, void* cookie); #endif /* packet allocator */ apacket *get_apacket(void); void put_apacket(apacket *p); // Define it if you want to dump packets. #define DEBUG_PACKETS 0 #if !DEBUG_PACKETS #define print_packet(tag,p) do {} while (0) #endif #if ADB_HOST_ON_TARGET /* adb and adbd are coexisting on the target, so use 5038 for adb * to avoid conflicting with adbd's usage of 5037 */ # define DEFAULT_ADB_PORT 5038 #else # define DEFAULT_ADB_PORT 5037 #endif #define DEFAULT_ADB_LOCAL_TRANSPORT_PORT 5555 #define ADB_CLASS 0xff #define ADB_SUBCLASS 0x42 #define ADB_PROTOCOL 0x1 void local_init(int port); void local_connect(int port); int local_connect_arbitrary_ports(int console_port, int adb_port, std::string* error); // USB host/client interface. void usb_init(); int usb_write(usb_handle *h, const void *data, int len); int usb_read(usb_handle *h, void *data, int len); int usb_close(usb_handle *h); void usb_kick(usb_handle *h); // USB device detection. #if ADB_HOST int is_adb_interface(int vid, int pid, int usb_class, int usb_subclass, int usb_protocol); #endif int adb_commandline(int argc, const char **argv); ConnectionState connection_state(atransport *t); extern const char* adb_device_banner; #if !ADB_HOST extern int SHELL_EXIT_NOTIFY_FD; #endif // !ADB_HOST #define CHUNK_SIZE (64*1024) #if !ADB_HOST #define USB_ADB_PATH "/dev/android_adb" #define USB_FFS_ADB_PATH "/dev/usb-ffs/adb/" #define USB_FFS_ADB_EP(x) USB_FFS_ADB_PATH#x #define USB_FFS_ADB_EP0 USB_FFS_ADB_EP(ep0) #define USB_FFS_ADB_OUT USB_FFS_ADB_EP(ep1) #define USB_FFS_ADB_IN USB_FFS_ADB_EP(ep2) #endif int handle_host_request(const char* service, TransportType type, const char* serial, int reply_fd, asocket *s); void handle_online(atransport *t); void handle_offline(atransport *t); void send_connect(atransport *t); void parse_banner(const std::string&, atransport* t); #endif adb/adb_auth.cpp0100644 0000000 0000000 00000004322 12767234553 012625 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG ADB #include "sysdeps.h" #include "adb_auth.h" #include #include #include #include #include #include "adb.h" #include "transport.h" bool auth_required = true; void send_auth_request(atransport *t) { D("Calling send_auth_request"); apacket *p; int ret; ret = adb_auth_generate_token(t->token, sizeof(t->token)); if (ret != sizeof(t->token)) { D("Error generating token ret=%d", ret); return; } p = get_apacket(); memcpy(p->data, t->token, ret); p->msg.command = A_AUTH; p->msg.arg0 = ADB_AUTH_TOKEN; p->msg.data_length = ret; send_packet(p, t); } void send_auth_response(uint8_t *token, size_t token_size, atransport *t) { D("Calling send_auth_response"); apacket *p = get_apacket(); int ret; ret = adb_auth_sign(t->key, token, token_size, p->data); if (!ret) { D("Error signing the token"); put_apacket(p); return; } p->msg.command = A_AUTH; p->msg.arg0 = ADB_AUTH_SIGNATURE; p->msg.data_length = ret; send_packet(p, t); } void send_auth_publickey(atransport *t) { D("Calling send_auth_publickey"); apacket *p = get_apacket(); int ret; ret = adb_auth_get_userkey(p->data, MAX_PAYLOAD_V1); if (!ret) { D("Failed to get user public key"); put_apacket(p); return; } p->msg.command = A_AUTH; p->msg.arg0 = ADB_AUTH_RSAPUBLICKEY; p->msg.data_length = ret; send_packet(p, t); } void adb_auth_verified(atransport *t) { handle_online(t); send_connect(t); } adb/adb_auth.h0100644 0000000 0000000 00000004336 12767234553 012277 0ustar000000000 0000000 /* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __ADB_AUTH_H #define __ADB_AUTH_H #include "adb.h" extern bool auth_required; int adb_auth_keygen(const char* filename); void adb_auth_verified(atransport *t); void send_auth_request(atransport *t); void send_auth_response(uint8_t *token, size_t token_size, atransport *t); void send_auth_publickey(atransport *t); /* AUTH packets first argument */ /* Request */ #define ADB_AUTH_TOKEN 1 /* Response */ #define ADB_AUTH_SIGNATURE 2 #define ADB_AUTH_RSAPUBLICKEY 3 #if ADB_HOST void adb_auth_init(void); int adb_auth_sign(void *key, const unsigned char* token, size_t token_size, unsigned char* sig); void *adb_auth_nextkey(void *current); int adb_auth_get_userkey(unsigned char *data, size_t len); static inline int adb_auth_generate_token(void *token, size_t token_size) { return 0; } static inline int adb_auth_verify(void *token, void *sig, int siglen) { return 0; } static inline void adb_auth_confirm_key(unsigned char *data, size_t len, atransport *t) { } #else // !ADB_HOST static inline int adb_auth_sign(void* key, const unsigned char* token, size_t token_size, unsigned char* sig) { return 0; } static inline void *adb_auth_nextkey(void *current) { return NULL; } static inline int adb_auth_get_userkey(unsigned char *data, size_t len) { return 0; } void adbd_auth_init(void); void adbd_cloexec_auth_socket(); int adb_auth_generate_token(void *token, size_t token_size); int adb_auth_verify(uint8_t* token, uint8_t* sig, int siglen); void adb_auth_confirm_key(unsigned char *data, size_t len, atransport *t); #endif // ADB_HOST #endif // __ADB_AUTH_H adb/adb_auth_client.cpp0100644 0000000 0000000 00000014553 12767234553 014172 0ustar000000000 0000000 /* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG AUTH #include "sysdeps.h" #include "adb_auth.h" #include #include #include #include "cutils/list.h" #include "cutils/sockets.h" #include "mincrypt/rsa.h" #include "mincrypt/sha.h" #include "adb.h" #include "fdevent.h" #include "transport.h" struct adb_public_key { struct listnode node; RSAPublicKey key; }; static const char *key_paths[] = { "/adb_keys", "/data/misc/adb/adb_keys", NULL }; static fdevent listener_fde; static fdevent framework_fde; static int framework_fd = -1; static void usb_disconnected(void* unused, atransport* t); static struct adisconnect usb_disconnect = { usb_disconnected, nullptr}; static atransport* usb_transport; static bool needs_retry = false; static void read_keys(const char *file, struct listnode *list) { FILE *f; char buf[MAX_PAYLOAD_V1]; char *sep; int ret; f = fopen(file, "re"); if (!f) { D("Can't open '%s'", file); return; } while (fgets(buf, sizeof(buf), f)) { /* Allocate 4 extra bytes to decode the base64 data in-place */ auto key = reinterpret_cast( calloc(1, sizeof(adb_public_key) + 4)); if (key == nullptr) { D("Can't malloc key"); break; } sep = strpbrk(buf, " \t"); if (sep) *sep = '\0'; ret = __b64_pton(buf, (u_char *)&key->key, sizeof(key->key) + 4); if (ret != sizeof(key->key)) { D("%s: Invalid base64 data ret=%d", file, ret); free(key); continue; } if (key->key.len != RSANUMWORDS) { D("%s: Invalid key len %d", file, key->key.len); free(key); continue; } list_add_tail(list, &key->node); } fclose(f); } static void free_keys(struct listnode *list) { struct listnode *item; while (!list_empty(list)) { item = list_head(list); list_remove(item); free(node_to_item(item, struct adb_public_key, node)); } } static void load_keys(struct listnode *list) { const char* path; const char** paths = key_paths; struct stat buf; list_init(list); while ((path = *paths++)) { if (!stat(path, &buf)) { D("Loading keys from '%s'", path); read_keys(path, list); } } } int adb_auth_generate_token(void *token, size_t token_size) { FILE *f; int ret; f = fopen("/dev/urandom", "re"); if (!f) return 0; ret = fread(token, token_size, 1, f); fclose(f); return ret * token_size; } int adb_auth_verify(uint8_t* token, uint8_t* sig, int siglen) { struct listnode *item; struct listnode key_list; int ret = 0; if (siglen != RSANUMBYTES) return 0; load_keys(&key_list); list_for_each(item, &key_list) { adb_public_key* key = node_to_item(item, struct adb_public_key, node); ret = RSA_verify(&key->key, sig, siglen, token, SHA_DIGEST_SIZE); if (ret) break; } free_keys(&key_list); return ret; } static void usb_disconnected(void* unused, atransport* t) { D("USB disconnect"); usb_transport = NULL; needs_retry = false; } static void framework_disconnected() { D("Framework disconnect"); fdevent_remove(&framework_fde); framework_fd = -1; } static void adb_auth_event(int fd, unsigned events, void*) { char response[2]; int ret; if (events & FDE_READ) { ret = unix_read(fd, response, sizeof(response)); if (ret <= 0) { framework_disconnected(); } else if (ret == 2 && response[0] == 'O' && response[1] == 'K') { if (usb_transport) { adb_auth_verified(usb_transport); } } } } void adb_auth_confirm_key(unsigned char *key, size_t len, atransport *t) { char msg[MAX_PAYLOAD_V1]; int ret; if (!usb_transport) { usb_transport = t; t->AddDisconnect(&usb_disconnect); } if (framework_fd < 0) { D("Client not connected"); needs_retry = true; return; } if (key[len - 1] != '\0') { D("Key must be a null-terminated string"); return; } ret = snprintf(msg, sizeof(msg), "PK%s", key); if (ret >= (signed)sizeof(msg)) { D("Key too long. ret=%d", ret); return; } D("Sending '%s'", msg); ret = unix_write(framework_fd, msg, ret); if (ret < 0) { D("Failed to write PK, errno=%d", errno); return; } } static void adb_auth_listener(int fd, unsigned events, void* data) { sockaddr_storage addr; socklen_t alen; int s; alen = sizeof(addr); s = adb_socket_accept(fd, reinterpret_cast(&addr), &alen); if (s < 0) { D("Failed to accept: errno=%d", errno); return; } if (framework_fd >= 0) { LOG(WARNING) << "adb received framework auth socket connection again"; framework_disconnected(); } framework_fd = s; fdevent_install(&framework_fde, framework_fd, adb_auth_event, nullptr); fdevent_add(&framework_fde, FDE_READ); if (needs_retry) { needs_retry = false; send_auth_request(usb_transport); } } void adbd_cloexec_auth_socket() { int fd = android_get_control_socket("adbd"); if (fd == -1) { D("Failed to get adbd socket"); return; } fcntl(fd, F_SETFD, FD_CLOEXEC); } void adbd_auth_init(void) { int fd = android_get_control_socket("adbd"); if (fd == -1) { D("Failed to get adbd socket"); return; } if (listen(fd, 4) == -1) { D("Failed to listen on '%d'", fd); return; } fdevent_install(&listener_fde, fd, adb_auth_listener, NULL); fdevent_add(&listener_fde, FDE_READ); } adb/adb_auth_host.cpp0100644 0000000 0000000 00000024430 12767234553 013664 0ustar000000000 0000000 /* * Copyright (C) 2012 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG AUTH #include "sysdeps.h" #include "adb_auth.h" #include "adb_utils.h" #include #include #include #include "adb.h" /* HACK: we need the RSAPublicKey struct * but RSA_verify conflits with openssl */ #define RSA_verify RSA_verify_mincrypt #include "mincrypt/rsa.h" #undef RSA_verify #include #include #include #include #include #include #include #include #include #if defined(OPENSSL_IS_BORINGSSL) #include #endif #define ANDROID_PATH ".android" #define ADB_KEY_FILE "adbkey" struct adb_private_key { struct listnode node; RSA *rsa; }; static struct listnode key_list; /* Convert OpenSSL RSA private key to android pre-computed RSAPublicKey format */ static int RSA_to_RSAPublicKey(RSA *rsa, RSAPublicKey *pkey) { int ret = 1; unsigned int i; BN_CTX* ctx = BN_CTX_new(); BIGNUM* r32 = BN_new(); BIGNUM* rr = BN_new(); BIGNUM* r = BN_new(); BIGNUM* rem = BN_new(); BIGNUM* n = BN_new(); BIGNUM* n0inv = BN_new(); if (RSA_size(rsa) != RSANUMBYTES) { ret = 0; goto out; } BN_set_bit(r32, 32); BN_copy(n, rsa->n); BN_set_bit(r, RSANUMWORDS * 32); BN_mod_sqr(rr, r, n, ctx); BN_div(NULL, rem, n, r32, ctx); BN_mod_inverse(n0inv, rem, r32, ctx); pkey->len = RSANUMWORDS; pkey->n0inv = 0 - BN_get_word(n0inv); for (i = 0; i < RSANUMWORDS; i++) { BN_div(rr, rem, rr, r32, ctx); pkey->rr[i] = BN_get_word(rem); BN_div(n, rem, n, r32, ctx); pkey->n[i] = BN_get_word(rem); } pkey->exponent = BN_get_word(rsa->e); out: BN_free(n0inv); BN_free(n); BN_free(rem); BN_free(r); BN_free(rr); BN_free(r32); BN_CTX_free(ctx); return ret; } static void get_user_info(char *buf, size_t len) { char hostname[1024], username[1024]; int ret = -1; if (getenv("HOSTNAME") != NULL) { strncpy(hostname, getenv("HOSTNAME"), sizeof(hostname)); hostname[sizeof(hostname)-1] = '\0'; ret = 0; } #ifndef _WIN32 if (ret < 0) ret = gethostname(hostname, sizeof(hostname)); #endif if (ret < 0) strcpy(hostname, "unknown"); ret = -1; if (getenv("LOGNAME") != NULL) { strncpy(username, getenv("LOGNAME"), sizeof(username)); username[sizeof(username)-1] = '\0'; ret = 0; } #if !defined _WIN32 && !defined ADB_HOST_ON_TARGET if (ret < 0) ret = getlogin_r(username, sizeof(username)); #endif if (ret < 0) strcpy(username, "unknown"); ret = snprintf(buf, len, " %s@%s", username, hostname); if (ret >= (signed)len) buf[len - 1] = '\0'; } static int write_public_keyfile(RSA *private_key, const char *private_key_path) { RSAPublicKey pkey; FILE *outfile = NULL; char path[PATH_MAX], info[MAX_PAYLOAD_V1]; uint8_t* encoded = nullptr; size_t encoded_length; int ret = 0; if (snprintf(path, sizeof(path), "%s.pub", private_key_path) >= (int)sizeof(path)) { D("Path too long while writing public key"); return 0; } if (!RSA_to_RSAPublicKey(private_key, &pkey)) { D("Failed to convert to publickey"); return 0; } outfile = fopen(path, "w"); if (!outfile) { D("Failed to open '%s'", path); return 0; } D("Writing public key to '%s'", path); #if defined(OPENSSL_IS_BORINGSSL) if (!EVP_EncodedLength(&encoded_length, sizeof(pkey))) { D("Public key too large to base64 encode"); goto out; } #else /* While we switch from OpenSSL to BoringSSL we have to implement * |EVP_EncodedLength| here. */ encoded_length = 1 + ((sizeof(pkey) + 2) / 3 * 4); #endif encoded = new uint8_t[encoded_length]; if (encoded == nullptr) { D("Allocation failure"); goto out; } encoded_length = EVP_EncodeBlock(encoded, (uint8_t*) &pkey, sizeof(pkey)); get_user_info(info, sizeof(info)); if (fwrite(encoded, encoded_length, 1, outfile) != 1 || fwrite(info, strlen(info), 1, outfile) != 1) { D("Write error while writing public key"); goto out; } ret = 1; out: if (outfile != NULL) { fclose(outfile); } delete[] encoded; return ret; } static int generate_key(const char *file) { EVP_PKEY* pkey = EVP_PKEY_new(); BIGNUM* exponent = BN_new(); RSA* rsa = RSA_new(); mode_t old_mask; FILE *f = NULL; int ret = 0; D("generate_key '%s'", file); if (!pkey || !exponent || !rsa) { D("Failed to allocate key"); goto out; } BN_set_word(exponent, RSA_F4); RSA_generate_key_ex(rsa, 2048, exponent, NULL); EVP_PKEY_set1_RSA(pkey, rsa); old_mask = umask(077); f = fopen(file, "w"); if (!f) { D("Failed to open '%s'", file); umask(old_mask); goto out; } umask(old_mask); if (!PEM_write_PrivateKey(f, pkey, NULL, NULL, 0, NULL, NULL)) { D("Failed to write key"); goto out; } if (!write_public_keyfile(rsa, file)) { D("Failed to write public key"); goto out; } ret = 1; out: if (f) fclose(f); EVP_PKEY_free(pkey); RSA_free(rsa); BN_free(exponent); return ret; } static int read_key(const char *file, struct listnode *list) { D("read_key '%s'", file); FILE* fp = fopen(file, "r"); if (!fp) { D("Failed to open '%s': %s", file, strerror(errno)); return 0; } adb_private_key* key = new adb_private_key; key->rsa = RSA_new(); if (!PEM_read_RSAPrivateKey(fp, &key->rsa, NULL, NULL)) { D("Failed to read key"); fclose(fp); RSA_free(key->rsa); delete key; return 0; } fclose(fp); list_add_tail(list, &key->node); return 1; } static int get_user_keyfilepath(char *filename, size_t len) { const std::string home = adb_get_homedir_path(true); D("home '%s'", home.c_str()); const std::string android_dir = android::base::StringPrintf("%s%c%s", home.c_str(), OS_PATH_SEPARATOR, ANDROID_PATH); struct stat buf; if (stat(android_dir.c_str(), &buf)) { if (adb_mkdir(android_dir.c_str(), 0750) < 0) { D("Cannot mkdir '%s'", android_dir.c_str()); return -1; } } return snprintf(filename, len, "%s%c%s", android_dir.c_str(), OS_PATH_SEPARATOR, ADB_KEY_FILE); } static int get_user_key(struct listnode *list) { struct stat buf; char path[PATH_MAX]; int ret; ret = get_user_keyfilepath(path, sizeof(path)); if (ret < 0 || ret >= (signed)sizeof(path)) { D("Error getting user key filename"); return 0; } D("user key '%s'", path); if (stat(path, &buf) == -1) { if (!generate_key(path)) { D("Failed to generate new key"); return 0; } } return read_key(path, list); } static void get_vendor_keys(struct listnode* key_list) { const char* adb_keys_path = getenv("ADB_VENDOR_KEYS"); if (adb_keys_path == nullptr) { return; } for (const auto& path : android::base::Split(adb_keys_path, ENV_PATH_SEPARATOR_STR)) { if (!read_key(path.c_str(), key_list)) { D("Failed to read '%s'", path.c_str()); } } } int adb_auth_sign(void *node, const unsigned char* token, size_t token_size, unsigned char* sig) { unsigned int len; struct adb_private_key *key = node_to_item(node, struct adb_private_key, node); if (token_size != TOKEN_SIZE) { D("Unexpected token size %zd", token_size); return 0; } if (!RSA_sign(NID_sha1, token, token_size, sig, &len, key->rsa)) { return 0; } D("adb_auth_sign len=%d", len); return (int)len; } void *adb_auth_nextkey(void *current) { struct listnode *item; if (list_empty(&key_list)) return NULL; if (!current) return list_head(&key_list); list_for_each(item, &key_list) { if (item == current) { /* current is the last item, we tried all the keys */ if (item->next == &key_list) return NULL; return item->next; } } return NULL; } int adb_auth_get_userkey(unsigned char *data, size_t len) { char path[PATH_MAX]; int ret = get_user_keyfilepath(path, sizeof(path) - 4); if (ret < 0 || ret >= (signed)(sizeof(path) - 4)) { D("Error getting user key filename"); return 0; } strcat(path, ".pub"); // TODO(danalbert): ReadFileToString // Note that on Windows, load_file() does not do CR/LF translation, but // ReadFileToString() uses the C Runtime which uses CR/LF translation by // default (by is overridable with _setmode()). unsigned size; char* file_data = reinterpret_cast(load_file(path, &size)); if (file_data == nullptr) { D("Can't load '%s'", path); return 0; } if (len < (size_t)(size + 1)) { D("%s: Content too large ret=%d", path, size); free(file_data); return 0; } memcpy(data, file_data, size); free(file_data); file_data = nullptr; data[size] = '\0'; return size + 1; } int adb_auth_keygen(const char* filename) { return (generate_key(filename) == 0); } void adb_auth_init(void) { int ret; D("adb_auth_init"); list_init(&key_list); ret = get_user_key(&key_list); if (!ret) { D("Failed to get user key"); return; } get_vendor_keys(&key_list); } adb/adb_client.cpp0100644 0000000 0000000 00000023306 12767234553 013145 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG ADB #include "sysdeps.h" #include "adb_client.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include "adb_io.h" #include "adb_utils.h" static TransportType __adb_transport = kTransportAny; static const char* __adb_serial = NULL; static int __adb_server_port = DEFAULT_ADB_PORT; static const char* __adb_server_name = NULL; void adb_set_transport(TransportType type, const char* serial) { __adb_transport = type; __adb_serial = serial; } void adb_get_transport(TransportType* type, const char** serial) { if (type) { *type = __adb_transport; } if (serial) { *serial = __adb_serial; } } void adb_set_tcp_specifics(int server_port) { __adb_server_port = server_port; } void adb_set_tcp_name(const char* hostname) { __adb_server_name = hostname; } static int switch_socket_transport(int fd, std::string* error) { std::string service; if (__adb_serial) { service += "host:transport:"; service += __adb_serial; } else { const char* transport_type = "???"; switch (__adb_transport) { case kTransportUsb: transport_type = "transport-usb"; break; case kTransportLocal: transport_type = "transport-local"; break; case kTransportAny: transport_type = "transport-any"; break; case kTransportHost: // no switch necessary return 0; } service += "host:"; service += transport_type; } if (!SendProtocolString(fd, service)) { *error = perror_str("write failure during connection"); adb_close(fd); return -1; } D("Switch transport in progress"); if (!adb_status(fd, error)) { adb_close(fd); D("Switch transport failed: %s", error->c_str()); return -1; } D("Switch transport success"); return 0; } bool adb_status(int fd, std::string* error) { char buf[5]; if (!ReadFdExactly(fd, buf, 4)) { *error = perror_str("protocol fault (couldn't read status)"); return false; } if (!memcmp(buf, "OKAY", 4)) { return true; } if (memcmp(buf, "FAIL", 4)) { *error = android::base::StringPrintf("protocol fault (status %02x %02x %02x %02x?!)", buf[0], buf[1], buf[2], buf[3]); return false; } ReadProtocolString(fd, error, error); return false; } int _adb_connect(const std::string& service, std::string* error) { D("_adb_connect: %s", service.c_str()); if (service.empty() || service.size() > MAX_PAYLOAD_V1) { *error = android::base::StringPrintf("bad service name length (%zd)", service.size()); return -1; } int fd; std::string reason; if (__adb_server_name) { fd = network_connect(__adb_server_name, __adb_server_port, SOCK_STREAM, 0, &reason); if (fd == -1) { *error = android::base::StringPrintf("can't connect to %s:%d: %s", __adb_server_name, __adb_server_port, reason.c_str()); return -2; } } else { fd = network_loopback_client(__adb_server_port, SOCK_STREAM, &reason); if (fd == -1) { *error = android::base::StringPrintf("cannot connect to daemon: %s", reason.c_str()); return -2; } } if ((memcmp(&service[0],"host",4) != 0 || service == "host:reconnect") && switch_socket_transport(fd, error)) { return -1; } if (!SendProtocolString(fd, service)) { *error = perror_str("write failure during connection"); adb_close(fd); return -1; } if (service != "reconnect") { if (!adb_status(fd, error)) { adb_close(fd); return -1; } } D("_adb_connect: return fd %d", fd); return fd; } int adb_connect(const std::string& service, std::string* error) { // first query the adb server's version int fd = _adb_connect("host:version", error); D("adb_connect: service %s", service.c_str()); if (fd == -2 && __adb_server_name) { fprintf(stderr,"** Cannot start server on remote host\n"); // error is the original network connection error return fd; } else if (fd == -2) { fprintf(stdout,"* daemon not running. starting it now on port %d *\n", __adb_server_port); start_server: if (launch_server(__adb_server_port)) { fprintf(stderr,"* failed to start daemon *\n"); // launch_server() has already printed detailed error info, so just // return a generic error string about the overall adb_connect() // that the caller requested. *error = "cannot connect to daemon"; return -1; } else { fprintf(stdout,"* daemon started successfully *\n"); } /* give the server some time to start properly and detect devices */ adb_sleep_ms(3000); // fall through to _adb_connect } else { // If a server is already running, check its version matches. int version = ADB_SERVER_VERSION - 1; // If we have a file descriptor, then parse version result. if (fd >= 0) { std::string version_string; if (!ReadProtocolString(fd, &version_string, error)) { adb_close(fd); return -1; } ReadOrderlyShutdown(fd); adb_close(fd); if (sscanf(&version_string[0], "%04x", &version) != 1) { *error = android::base::StringPrintf("cannot parse version string: %s", version_string.c_str()); return -1; } } else { // If fd is -1 check for "unknown host service" which would // indicate a version of adb that does not support the // version command, in which case we should fall-through to kill it. if (*error != "unknown host service") { return fd; } } if (version != ADB_SERVER_VERSION) { printf("adb server version (%d) doesn't match this client (%d); killing...\n", version, ADB_SERVER_VERSION); fd = _adb_connect("host:kill", error); if (fd >= 0) { ReadOrderlyShutdown(fd); adb_close(fd); } else { // If we couldn't connect to the server or had some other error, // report it, but still try to start the server. fprintf(stderr, "error: %s\n", error->c_str()); } /* XXX can we better detect its death? */ adb_sleep_ms(2000); goto start_server; } } // if the command is start-server, we are done. if (service == "host:start-server") { return 0; } fd = _adb_connect(service, error); if (fd == -1) { D("_adb_connect error: %s", error->c_str()); } else if(fd == -2) { fprintf(stderr,"** daemon still not running\n"); } D("adb_connect: return fd %d", fd); return fd; } bool adb_command(const std::string& service) { std::string error; int fd = adb_connect(service, &error); if (fd < 0) { fprintf(stderr, "error: %s\n", error.c_str()); return false; } if (!adb_status(fd, &error)) { fprintf(stderr, "error: %s\n", error.c_str()); adb_close(fd); return false; } ReadOrderlyShutdown(fd); adb_close(fd); return true; } bool adb_query(const std::string& service, std::string* result, std::string* error) { D("adb_query: %s", service.c_str()); int fd = adb_connect(service, error); if (fd < 0) { return false; } result->clear(); if (!ReadProtocolString(fd, result, error)) { adb_close(fd); return false; } ReadOrderlyShutdown(fd); adb_close(fd); return true; } std::string format_host_command(const char* command, TransportType type, const char* serial) { if (serial) { return android::base::StringPrintf("host-serial:%s:%s", serial, command); } const char* prefix = "host"; if (type == kTransportUsb) { prefix = "host-usb"; } else if (type == kTransportLocal) { prefix = "host-local"; } return android::base::StringPrintf("%s:%s", prefix, command); } bool adb_get_feature_set(FeatureSet* feature_set, std::string* error) { std::string result; if (adb_query(format_host_command("features", __adb_transport, __adb_serial), &result, error)) { *feature_set = StringToFeatureSet(result); return true; } feature_set->clear(); return false; } adb/adb_client.h0100644 0000000 0000000 00000005465 12767234553 012620 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _ADB_CLIENT_H_ #define _ADB_CLIENT_H_ #include "adb.h" #include "transport.h" #include // Connect to adb, connect to the named service, and return a valid fd for // interacting with that service upon success or a negative number on failure. int adb_connect(const std::string& service, std::string* _Nonnull error); int _adb_connect(const std::string& service, std::string* _Nonnull error); // Connect to adb, connect to the named service, returns true if the connection // succeeded AND the service returned OKAY. Outputs any returned error otherwise. bool adb_command(const std::string& service); // Connects to the named adb service and fills 'result' with the response. // Returns true on success; returns false and fills 'error' on failure. bool adb_query(const std::string& service, std::string* _Nonnull result, std::string* _Nonnull error); // Set the preferred transport to connect to. void adb_set_transport(TransportType type, const char* _Nullable serial); // Get the preferred transport to connect to. void adb_get_transport(TransportType* _Nullable type, const char* _Nullable* _Nullable serial); // Set TCP specifics of the transport to use. void adb_set_tcp_specifics(int server_port); // Set TCP Hostname of the transport to use. void adb_set_tcp_name(const char* _Nullable hostname); // Send commands to the current emulator instance. Will fail if there is not // exactly one emulator connected (or if you use -s with a // that does not designate an emulator). int adb_send_emulator_command(int argc, const char* _Nonnull* _Nonnull argv, const char* _Nullable serial); // Reads a standard adb status response (OKAY|FAIL) and returns true in the // event of OKAY, false in the event of FAIL or protocol error. bool adb_status(int fd, std::string* _Nonnull error); // Create a host command corresponding to selected transport type/serial. std::string format_host_command(const char* _Nonnull command, TransportType type, const char* _Nullable serial); // Get the feature set of the current preferred transport. bool adb_get_feature_set(FeatureSet* _Nonnull feature_set, std::string* _Nonnull error); #endif adb/adb_io.cpp0100644 0000000 0000000 00000013250 12767234553 012273 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG RWX #include "adb_io.h" #include #include #include "adb.h" #include "adb_trace.h" #include "adb_utils.h" #include "sysdeps.h" bool SendProtocolString(int fd, const std::string& s) { unsigned int length = s.size(); if (length > MAX_PAYLOAD_V1 - 4) { errno = EMSGSIZE; return false; } // The cost of sending two strings outweighs the cost of formatting. // "adb sync" performance is affected by this. return WriteFdFmt(fd, "%04x%.*s", length, length, s.c_str()); } bool ReadProtocolString(int fd, std::string* s, std::string* error) { char buf[5]; if (!ReadFdExactly(fd, buf, 4)) { *error = perror_str("protocol fault (couldn't read status length)"); return false; } buf[4] = 0; unsigned long len = strtoul(buf, 0, 16); s->resize(len, '\0'); if (!ReadFdExactly(fd, &(*s)[0], len)) { *error = perror_str("protocol fault (couldn't read status message)"); return false; } return true; } bool SendOkay(int fd) { return WriteFdExactly(fd, "OKAY", 4); } bool SendFail(int fd, const std::string& reason) { return WriteFdExactly(fd, "FAIL", 4) && SendProtocolString(fd, reason); } bool ReadFdExactly(int fd, void* buf, size_t len) { char* p = reinterpret_cast(buf); size_t len0 = len; D("readx: fd=%d wanted=%zu", fd, len); while (len > 0) { int r = adb_read(fd, p, len); if (r > 0) { len -= r; p += r; } else if (r == -1) { D("readx: fd=%d error %d: %s", fd, errno, strerror(errno)); return false; } else { D("readx: fd=%d disconnected", fd); errno = 0; return false; } } VLOG(RWX) << "readx: fd=" << fd << " wanted=" << len0 << " got=" << (len0 - len) << " " << dump_hex(reinterpret_cast(buf), len0); return true; } bool WriteFdExactly(int fd, const void* buf, size_t len) { const char* p = reinterpret_cast(buf); int r; VLOG(RWX) << "writex: fd=" << fd << " len=" << len << " " << dump_hex(reinterpret_cast(buf), len); while (len > 0) { r = adb_write(fd, p, len); if (r == -1) { D("writex: fd=%d error %d: %s", fd, errno, strerror(errno)); if (errno == EAGAIN) { adb_sleep_ms(1); // just yield some cpu time continue; } else if (errno == EPIPE) { D("writex: fd=%d disconnected", fd); errno = 0; return false; } else { return false; } } else { len -= r; p += r; } } return true; } bool WriteFdExactly(int fd, const char* str) { return WriteFdExactly(fd, str, strlen(str)); } bool WriteFdExactly(int fd, const std::string& str) { return WriteFdExactly(fd, str.c_str(), str.size()); } bool WriteFdFmt(int fd, const char* fmt, ...) { std::string str; va_list ap; va_start(ap, fmt); android::base::StringAppendV(&str, fmt, ap); va_end(ap); return WriteFdExactly(fd, str); } bool ReadOrderlyShutdown(int fd) { char buf[16]; // Only call this function if you're sure that the peer does // orderly/graceful shutdown of the socket, closing the socket so that // adb_read() will return 0. If the peer keeps the socket open, adb_read() // will never return. int result = adb_read(fd, buf, sizeof(buf)); if (result == -1) { // If errno is EAGAIN, that means this function was called on a // nonblocking socket and it would have blocked (which would be bad // because we'd probably block the main thread where nonblocking IO is // done). Don't do that. If you have a nonblocking socket, use the // fdevent APIs to get called on FDE_READ, and then call this function // if you really need to, but it shouldn't be needed for server sockets. CHECK_NE(errno, EAGAIN); // Note that on Windows, orderly shutdown sometimes causes // recv() == SOCKET_ERROR && WSAGetLastError() == WSAECONNRESET. That // can be ignored. return false; } else if (result == 0) { // Peer has performed an orderly/graceful shutdown. return true; } else { // Unexpectedly received data. This is essentially a protocol error // because you should not call this function unless you expect no more // data. We don't repeatedly call adb_read() until we get zero because // we don't know how long that would take, but we do know that the // caller wants to close the socket soon. VLOG(RWX) << "ReadOrderlyShutdown(" << fd << ") unexpectedly read " << dump_hex(buf, result); // Shutdown the socket to prevent the caller from reading or writing to // it which doesn't make sense if we just read and discarded some data. adb_shutdown(fd); errno = EINVAL; return false; } } adb/adb_io.h0100644 0000000 0000000 00000005772 12767234553 011752 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef ADB_IO_H #define ADB_IO_H #include #include // Sends the protocol "OKAY" message. bool SendOkay(int fd); // Sends the protocol "FAIL" message, with the given failure reason. bool SendFail(int fd, const std::string& reason); // Writes a protocol-format string; a four hex digit length followed by the string data. bool SendProtocolString(int fd, const std::string& s); // Reads a protocol-format string; a four hex digit length followed by the string data. bool ReadProtocolString(int fd, std::string* s, std::string* error); // Reads exactly len bytes from fd into buf. // // Returns false if there is an error or if EOF was reached before len bytes // were read. If EOF was found, errno will be set to 0. // // If this function fails, the contents of buf are undefined. bool ReadFdExactly(int fd, void* buf, size_t len); // Given a client socket, wait for orderly/graceful shutdown. Call this: // // * Before closing a client socket. // * Only when no more data is expected to come in. // * Only when the server is not waiting for data from the client (because then // the client and server will deadlock waiting for each other). // * Only when the server is expected to close its socket right now. // * Don't call shutdown(SHUT_WR) before calling this because that will shutdown // the client socket early, defeating the purpose of calling this. // // Waiting for orderly/graceful shutdown of the server socket will cause the // server socket to close before the client socket. That prevents the client // socket from staying in TIME_WAIT which eventually causes subsequent // connect()s from the client to fail with WSAEADDRINUSE on Windows. // Returns true if it is sure that orderly/graceful shutdown has occurred with // no additional data read from the server. bool ReadOrderlyShutdown(int fd); // Writes exactly len bytes from buf to fd. // // Returns false if there is an error or if the fd was closed before the write // completed. If the other end of the fd (such as in a socket, pipe, or fifo), // is closed, errno will be set to 0. bool WriteFdExactly(int fd, const void* buf, size_t len); // Same as above, but for strings. bool WriteFdExactly(int fd, const char* s); bool WriteFdExactly(int fd, const std::string& s); // Same as above, but formats the string to send. bool WriteFdFmt(int fd, const char* fmt, ...) __attribute__((__format__(__printf__, 2, 3))); #endif /* ADB_IO_H */ adb/adb_io_test.cpp0100644 0000000 0000000 00000010467 12767234553 013341 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "adb_io.h" #include #include #include #include #include #include #include #include #include #include // All of these tests fail on Windows because they use the C Runtime open(), // but the adb_io APIs expect file descriptors from adb_open(). This could // theoretically be fixed by making adb_read()/adb_write() fallback to using // read()/write() if an unrecognized fd is used, and by making adb_open() return // fds far from the range that open() returns. But all of that might defeat the // purpose of the tests. TEST(io, ReadFdExactly_whole) { const char expected[] = "Foobar"; TemporaryFile tf; ASSERT_NE(-1, tf.fd); ASSERT_TRUE(android::base::WriteStringToFd(expected, tf.fd)) << strerror(errno); ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)); // Test reading the whole file. char buf[sizeof(expected)] = {}; ASSERT_TRUE(ReadFdExactly(tf.fd, buf, sizeof(buf) - 1)) << strerror(errno); EXPECT_STREQ(expected, buf); } TEST(io, ReadFdExactly_eof) { const char expected[] = "Foobar"; TemporaryFile tf; ASSERT_NE(-1, tf.fd); ASSERT_TRUE(android::base::WriteStringToFd(expected, tf.fd)) << strerror(errno); ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)); // Test that not having enough data will fail. char buf[sizeof(expected) + 1] = {}; ASSERT_FALSE(ReadFdExactly(tf.fd, buf, sizeof(buf))); EXPECT_EQ(0, errno) << strerror(errno); } TEST(io, ReadFdExactly_partial) { const char input[] = "Foobar"; TemporaryFile tf; ASSERT_NE(-1, tf.fd); ASSERT_TRUE(android::base::WriteStringToFd(input, tf.fd)) << strerror(errno); ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)); // Test reading a partial file. char buf[sizeof(input) - 1] = {}; ASSERT_TRUE(ReadFdExactly(tf.fd, buf, sizeof(buf) - 1)); std::string expected(input); expected.pop_back(); EXPECT_STREQ(expected.c_str(), buf); } TEST(io, WriteFdExactly_whole) { const char expected[] = "Foobar"; TemporaryFile tf; ASSERT_NE(-1, tf.fd); // Test writing the whole string to the file. ASSERT_TRUE(WriteFdExactly(tf.fd, expected, sizeof(expected))) << strerror(errno); ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)); std::string s; ASSERT_TRUE(android::base::ReadFdToString(tf.fd, &s)); EXPECT_STREQ(expected, s.c_str()); } TEST(io, WriteFdExactly_partial) { const char buf[] = "Foobar"; TemporaryFile tf; ASSERT_NE(-1, tf.fd); // Test writing a partial string to the file. ASSERT_TRUE(WriteFdExactly(tf.fd, buf, sizeof(buf) - 2)) << strerror(errno); ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)); std::string expected(buf); expected.pop_back(); std::string s; ASSERT_TRUE(android::base::ReadFdToString(tf.fd, &s)); EXPECT_EQ(expected, s); } TEST(io, WriteFdExactly_ENOSPC) { int fd = open("/dev/full", O_WRONLY); ASSERT_NE(-1, fd); char buf[] = "foo"; ASSERT_FALSE(WriteFdExactly(fd, buf, sizeof(buf))); ASSERT_EQ(ENOSPC, errno); } TEST(io, WriteFdExactly_string) { const char str[] = "Foobar"; TemporaryFile tf; ASSERT_NE(-1, tf.fd); // Test writing a partial string to the file. ASSERT_TRUE(WriteFdExactly(tf.fd, str)) << strerror(errno); ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)); std::string s; ASSERT_TRUE(android::base::ReadFdToString(tf.fd, &s)); EXPECT_STREQ(str, s.c_str()); } TEST(io, WriteFdFmt) { TemporaryFile tf; ASSERT_NE(-1, tf.fd); // Test writing a partial string to the file. ASSERT_TRUE(WriteFdFmt(tf.fd, "Foo%s%d", "bar", 123)) << strerror(errno); ASSERT_EQ(0, lseek(tf.fd, 0, SEEK_SET)); std::string s; ASSERT_TRUE(android::base::ReadFdToString(tf.fd, &s)); EXPECT_STREQ("Foobar123", s.c_str()); } adb/adb_listeners.cpp0100644 0000000 0000000 00000020045 12767234553 013674 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "adb_listeners.h" #include #include #include #include #include "sysdeps.h" #include "transport.h" int gListenAll = 0; /* Not static because it is used in commandline.c. */ static alistener listener_list = { .next = &listener_list, .prev = &listener_list, }; static void ss_listener_event_func(int _fd, unsigned ev, void *_l) { if (ev & FDE_READ) { sockaddr_storage ss; sockaddr* addrp = reinterpret_cast(&ss); socklen_t alen = sizeof(ss); int fd = adb_socket_accept(_fd, addrp, &alen); if (fd < 0) return; int rcv_buf_size = CHUNK_SIZE; adb_setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &rcv_buf_size, sizeof(rcv_buf_size)); asocket* s = create_local_socket(fd); if (s) { connect_to_smartsocket(s); return; } adb_close(fd); } } static void listener_event_func(int _fd, unsigned ev, void* _l) { alistener* listener = reinterpret_cast(_l); asocket *s; if (ev & FDE_READ) { sockaddr_storage ss; sockaddr* addrp = reinterpret_cast(&ss); socklen_t alen; int fd; alen = sizeof(ss); fd = adb_socket_accept(_fd, addrp, &alen); if (fd < 0) { return; } s = create_local_socket(fd); if (s) { s->transport = listener->transport; connect_to_remote(s, listener->connect_to); return; } adb_close(fd); } } static void free_listener(alistener* l) { if (l->next) { l->next->prev = l->prev; l->prev->next = l->next; l->next = l->prev = l; } // closes the corresponding fd fdevent_remove(&l->fde); if (l->local_name) free((char*)l->local_name); if (l->connect_to) free((char*)l->connect_to); if (l->transport) { l->transport->RemoveDisconnect(&l->disconnect); } free(l); } static void listener_disconnect(void* arg, atransport*) { alistener* listener = reinterpret_cast(arg); listener->transport = nullptr; free_listener(listener); } static int local_name_to_fd(const char* name, std::string* error) { if (!strncmp("tcp:", name, 4)) { int port = atoi(name + 4); if (gListenAll > 0) { return network_inaddr_any_server(port, SOCK_STREAM, error); } else { return network_loopback_server(port, SOCK_STREAM, error); } } #if !defined(_WIN32) // No Unix-domain sockets on Windows. // It's nonsensical to support the "reserved" space on the adb host side if (!strncmp(name, "local:", 6)) { return network_local_server(name + 6, ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM, error); } else if (!strncmp(name, "localabstract:", 14)) { return network_local_server(name + 14, ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM, error); } else if (!strncmp(name, "localfilesystem:", 16)) { return network_local_server(name + 16, ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM, error); } #endif *error = android::base::StringPrintf("unknown local portname '%s'", name); return -1; } // Write the list of current listeners (network redirections) into a string. std::string format_listeners() { std::string result; for (alistener* l = listener_list.next; l != &listener_list; l = l->next) { // Ignore special listeners like those for *smartsocket* if (l->connect_to[0] == '*') { continue; } // " " " " "\n" // Entries from "adb reverse" have no serial. android::base::StringAppendF(&result, "%s %s %s\n", l->transport->serial ? l->transport->serial : "(reverse)", l->local_name, l->connect_to); } return result; } InstallStatus remove_listener(const char *local_name, atransport* transport) { alistener *l; for (l = listener_list.next; l != &listener_list; l = l->next) { if (!strcmp(local_name, l->local_name)) { free_listener(l); return INSTALL_STATUS_OK; } } return INSTALL_STATUS_LISTENER_NOT_FOUND; } void remove_all_listeners(void) { alistener *l, *l_next; for (l = listener_list.next; l != &listener_list; l = l_next) { l_next = l->next; // Never remove smart sockets. if (l->connect_to[0] == '*') continue; free_listener(l); } } InstallStatus install_listener(const std::string& local_name, const char *connect_to, atransport* transport, int no_rebind, std::string* error) { for (alistener* l = listener_list.next; l != &listener_list; l = l->next) { if (local_name == l->local_name) { char* cto; /* can't repurpose a smartsocket */ if(l->connect_to[0] == '*') { *error = "cannot repurpose smartsocket"; return INSTALL_STATUS_INTERNAL_ERROR; } /* can't repurpose a listener if 'no_rebind' is true */ if (no_rebind) { *error = "cannot rebind"; return INSTALL_STATUS_CANNOT_REBIND; } cto = strdup(connect_to); if(cto == 0) { *error = "cannot duplicate string"; return INSTALL_STATUS_INTERNAL_ERROR; } free((void*) l->connect_to); l->connect_to = cto; if (l->transport != transport) { l->transport->RemoveDisconnect(&l->disconnect); l->transport = transport; l->transport->AddDisconnect(&l->disconnect); } return INSTALL_STATUS_OK; } } alistener* listener = reinterpret_cast( calloc(1, sizeof(alistener))); if (listener == nullptr) { goto nomem; } listener->local_name = strdup(local_name.c_str()); if (listener->local_name == nullptr) { goto nomem; } listener->connect_to = strdup(connect_to); if (listener->connect_to == nullptr) { goto nomem; } listener->fd = local_name_to_fd(listener->local_name, error); if (listener->fd < 0) { free(listener->local_name); free(listener->connect_to); free(listener); return INSTALL_STATUS_CANNOT_BIND; } close_on_exec(listener->fd); if (!strcmp(listener->connect_to, "*smartsocket*")) { fdevent_install(&listener->fde, listener->fd, ss_listener_event_func, listener); } else { fdevent_install(&listener->fde, listener->fd, listener_event_func, listener); } fdevent_set(&listener->fde, FDE_READ); listener->next = &listener_list; listener->prev = listener_list.prev; listener->next->prev = listener; listener->prev->next = listener; listener->transport = transport; if (transport) { listener->disconnect.opaque = listener; listener->disconnect.func = listener_disconnect; transport->AddDisconnect(&listener->disconnect); } return INSTALL_STATUS_OK; nomem: fatal("cannot allocate listener"); return INSTALL_STATUS_INTERNAL_ERROR; } adb/adb_listeners.h0100644 0000000 0000000 00000002573 12767234553 013347 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __ADB_LISTENERS_H #define __ADB_LISTENERS_H #include "adb.h" #include // error/status codes for install_listener. enum InstallStatus { INSTALL_STATUS_OK = 0, INSTALL_STATUS_INTERNAL_ERROR = -1, INSTALL_STATUS_CANNOT_BIND = -2, INSTALL_STATUS_CANNOT_REBIND = -3, INSTALL_STATUS_LISTENER_NOT_FOUND = -4, }; InstallStatus install_listener(const std::string& local_name, const char* connect_to, atransport* transport, int no_rebind, std::string* error); std::string format_listeners(); InstallStatus remove_listener(const char* local_name, atransport* transport); void remove_all_listeners(void); #endif /* __ADB_LISTENERS_H */ adb/adb_trace.cpp0100644 0000000 0000000 00000011050 12767234553 012756 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "sysdeps.h" #include "adb_trace.h" #include #include #include #include #include #include "adb.h" #if !ADB_HOST #include #endif #if !ADB_HOST const char* adb_device_banner = "device"; static android::base::LogdLogger gLogdLogger; #else const char* adb_device_banner = "host"; #endif void AdbLogger(android::base::LogId id, android::base::LogSeverity severity, const char* tag, const char* file, unsigned int line, const char* message) { android::base::StderrLogger(id, severity, tag, file, line, message); #if !ADB_HOST gLogdLogger(id, severity, tag, file, line, message); #endif } #if !ADB_HOST static std::string get_log_file_name() { struct tm now; time_t t; tzset(); time(&t); localtime_r(&t, &now); char timestamp[PATH_MAX]; strftime(timestamp, sizeof(timestamp), "%Y-%m-%d-%H-%M-%S", &now); return android::base::StringPrintf("/data/adb/adb-%s-%d", timestamp, getpid()); } void start_device_log(void) { int fd = unix_open(get_log_file_name().c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC, 0640); if (fd == -1) { return; } // Redirect stdout and stderr to the log file. dup2(fd, STDOUT_FILENO); dup2(fd, STDERR_FILENO); fprintf(stderr, "--- adb starting (pid %d) ---\n", getpid()); unix_close(fd); } #endif int adb_trace_mask; std::string get_trace_setting_from_env() { const char* setting = getenv("ADB_TRACE"); if (setting == nullptr) { setting = ""; } return std::string(setting); } #if !ADB_HOST std::string get_trace_setting_from_prop() { char buf[PROPERTY_VALUE_MAX]; property_get("persist.adb.trace_mask", buf, ""); return std::string(buf); } #endif std::string get_trace_setting() { #if ADB_HOST return get_trace_setting_from_env(); #else return get_trace_setting_from_prop(); #endif } // Split the space separated list of tags from the trace setting and build the // trace mask from it. note that '1' and 'all' are special cases to enable all // tracing. // // adb's trace setting comes from the ADB_TRACE environment variable, whereas // adbd's comes from the system property persist.adb.trace_mask. static void setup_trace_mask() { const std::string trace_setting = get_trace_setting(); if (trace_setting.empty()) { return; } std::unordered_map trace_flags = { {"1", 0}, {"all", 0}, {"adb", ADB}, {"sockets", SOCKETS}, {"packets", PACKETS}, {"rwx", RWX}, {"usb", USB}, {"sync", SYNC}, {"sysdeps", SYSDEPS}, {"transport", TRANSPORT}, {"jdwp", JDWP}, {"services", SERVICES}, {"auth", AUTH}, {"fdevent", FDEVENT}, {"shell", SHELL}}; std::vector elements = android::base::Split(trace_setting, " "); for (const auto& elem : elements) { const auto& flag = trace_flags.find(elem); if (flag == trace_flags.end()) { LOG(ERROR) << "Unknown trace flag: " << elem; continue; } if (flag->second == 0) { // 0 is used for the special values "1" and "all" that enable all // tracing. adb_trace_mask = ~0; return; } else { adb_trace_mask |= 1 << flag->second; } } } void adb_trace_init(char** argv) { #if !ADB_HOST // Don't open log file if no tracing, since this will block // the crypto unmount of /data if (!get_trace_setting().empty()) { if (unix_isatty(STDOUT_FILENO) == 0) { start_device_log(); } } #endif android::base::InitLogging(argv, &AdbLogger); setup_trace_mask(); VLOG(ADB) << adb_version(); } void adb_trace_enable(AdbTrace trace_tag) { adb_trace_mask |= (1 << trace_tag); } adb/adb_trace.h0100644 0000000 0000000 00000003107 12767234553 012427 0ustar000000000 0000000 /* * Copyright (C) 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __ADB_TRACE_H #define __ADB_TRACE_H #include #include /* IMPORTANT: if you change the following list, don't * forget to update the corresponding 'tags' table in * the adb_trace_init() function implemented in adb_trace.cpp. */ enum AdbTrace { ADB = 0, /* 0x001 */ SOCKETS, PACKETS, TRANSPORT, RWX, /* 0x010 */ USB, SYNC, SYSDEPS, JDWP, /* 0x100 */ SERVICES, AUTH, FDEVENT, SHELL }; #define VLOG_IS_ON(TAG) \ ((adb_trace_mask & (1 << TAG)) != 0) #define VLOG(TAG) \ if (LIKELY(!VLOG_IS_ON(TAG))) \ ; \ else \ LOG(INFO) // You must define TRACE_TAG before using this macro. #define D(...) \ VLOG(TRACE_TAG) << android::base::StringPrintf(__VA_ARGS__) extern int adb_trace_mask; void adb_trace_init(char**); void adb_trace_enable(AdbTrace trace_tag); #endif /* __ADB_TRACE_H */ adb/adb_utils.cpp0100644 0000000 0000000 00000017412 12767234553 013030 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG ADB #include "adb_utils.h" #include #include #include #include #include #include #include #include #include #include "adb.h" #include "adb_trace.h" #include "sysdeps.h" #ifdef _WIN32 # ifndef WIN32_LEAN_AND_MEAN # define WIN32_LEAN_AND_MEAN # endif # include "windows.h" # include "shlobj.h" #endif ADB_MUTEX_DEFINE(basename_lock); ADB_MUTEX_DEFINE(dirname_lock); #if defined(_WIN32) constexpr char kNullFileName[] = "NUL"; #else constexpr char kNullFileName[] = "/dev/null"; #endif void close_stdin() { int fd = unix_open(kNullFileName, O_RDONLY); if (fd == -1) { fatal_errno("failed to open %s", kNullFileName); } if (TEMP_FAILURE_RETRY(dup2(fd, STDIN_FILENO)) == -1) { fatal_errno("failed to redirect stdin to %s", kNullFileName); } unix_close(fd); } bool getcwd(std::string* s) { char* cwd = getcwd(nullptr, 0); if (cwd != nullptr) *s = cwd; free(cwd); return (cwd != nullptr); } bool directory_exists(const std::string& path) { struct stat sb; return lstat(path.c_str(), &sb) != -1 && S_ISDIR(sb.st_mode); } std::string escape_arg(const std::string& s) { std::string result = s; // Escape any ' in the string (before we single-quote the whole thing). // The correct way to do this for the shell is to replace ' with '\'' --- that is, // close the existing single-quoted string, escape a single single-quote, and start // a new single-quoted string. Like the C preprocessor, the shell will concatenate // these pieces into one string. for (size_t i = 0; i < s.size(); ++i) { if (s[i] == '\'') { result.insert(i, "'\\'"); i += 2; } } // Prefix and suffix the whole string with '. result.insert(result.begin(), '\''); result.push_back('\''); return result; } std::string adb_basename(const std::string& path) { // Copy path because basename may modify the string passed in. std::string result(path); // Use lock because basename() may write to a process global and return a // pointer to that. Note that this locking strategy only works if all other // callers to dirname in the process also grab this same lock. adb_mutex_lock(&basename_lock); // Note that if std::string uses copy-on-write strings, &str[0] will cause // the copy to be made, so there is no chance of us accidentally writing to // the storage for 'path'. char* name = basename(&result[0]); // In case dirname returned a pointer to a process global, copy that string // before leaving the lock. result.assign(name); adb_mutex_unlock(&basename_lock); return result; } std::string adb_dirname(const std::string& path) { // Copy path because dirname may modify the string passed in. std::string result(path); // Use lock because dirname() may write to a process global and return a // pointer to that. Note that this locking strategy only works if all other // callers to dirname in the process also grab this same lock. adb_mutex_lock(&dirname_lock); // Note that if std::string uses copy-on-write strings, &str[0] will cause // the copy to be made, so there is no chance of us accidentally writing to // the storage for 'path'. char* parent = dirname(&result[0]); // In case dirname returned a pointer to a process global, copy that string // before leaving the lock. result.assign(parent); adb_mutex_unlock(&dirname_lock); return result; } // Given a relative or absolute filepath, create the directory hierarchy // as needed. Returns true if the hierarchy is/was setup. bool mkdirs(const std::string& path) { // TODO: all the callers do unlink && mkdirs && adb_creat --- // that's probably the operation we should expose. // Implementation Notes: // // Pros: // - Uses dirname, so does not need to deal with OS_PATH_SEPARATOR. // - On Windows, uses mingw dirname which accepts '/' and '\\', drive letters // (C:\foo), UNC paths (\\server\share\dir\dir\file), and Unicode (when // combined with our adb_mkdir() which takes UTF-8). // - Is optimistic wrt thinking that a deep directory hierarchy will exist. // So it does as few stat()s as possible before doing mkdir()s. // Cons: // - Recursive, so it uses stack space relative to number of directory // components. // If path points to a symlink to a directory, that's fine. struct stat sb; if (stat(path.c_str(), &sb) != -1 && S_ISDIR(sb.st_mode)) { return true; } const std::string parent(adb_dirname(path)); // If dirname returned the same path as what we passed in, don't go recursive. // This can happen on Windows when walking up the directory hierarchy and not // finding anything that already exists (unlike POSIX that will eventually // find . or /). if (parent == path) { errno = ENOENT; return false; } // Recursively make parent directories of 'path'. if (!mkdirs(parent)) { return false; } // Now that the parent directory hierarchy of 'path' has been ensured, // create path itself. if (adb_mkdir(path, 0775) == -1) { const int saved_errno = errno; // If someone else created the directory, that is ok. if (directory_exists(path)) { return true; } // There might be a pre-existing file at 'path', or there might have been some other error. errno = saved_errno; return false; } return true; } std::string dump_hex(const void* data, size_t byte_count) { byte_count = std::min(byte_count, size_t(16)); const uint8_t* p = reinterpret_cast(data); std::string line; for (size_t i = 0; i < byte_count; ++i) { android::base::StringAppendF(&line, "%02x", p[i]); } line.push_back(' '); for (size_t i = 0; i < byte_count; ++i) { int ch = p[i]; line.push_back(isprint(ch) ? ch : '.'); } return line; } std::string perror_str(const char* msg) { return android::base::StringPrintf("%s: %s", msg, strerror(errno)); } #if !defined(_WIN32) // Windows version provided in sysdeps_win32.cpp bool set_file_block_mode(int fd, bool block) { int flags = fcntl(fd, F_GETFL, 0); if (flags == -1) { PLOG(ERROR) << "failed to fcntl(F_GETFL) for fd " << fd; return false; } flags = block ? (flags & ~O_NONBLOCK) : (flags | O_NONBLOCK); if (fcntl(fd, F_SETFL, flags) != 0) { PLOG(ERROR) << "failed to fcntl(F_SETFL) for fd " << fd << ", flags " << flags; return false; } return true; } #endif std::string adb_get_homedir_path(bool check_env_first) { #ifdef _WIN32 if (check_env_first) { if (const char* const home = getenv("ANDROID_SDK_HOME")) { return home; } } WCHAR path[MAX_PATH]; const HRESULT hr = SHGetFolderPathW(NULL, CSIDL_PROFILE, NULL, 0, path); if (FAILED(hr)) { D("SHGetFolderPathW failed: %s", android::base::SystemErrorCodeToString(hr).c_str()); return {}; } std::string home_str; if (!android::base::WideToUTF8(path, &home_str)) { return {}; } return home_str; #else if (const char* const home = getenv("HOME")) { return home; } return {}; #endif } adb/adb_utils.h0100644 0000000 0000000 00000004506 12767234553 012475 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _ADB_UTILS_H_ #define _ADB_UTILS_H_ #include #include #include void close_stdin(); bool getcwd(std::string* cwd); bool directory_exists(const std::string& path); // Like the regular basename and dirname, but thread-safe on all // platforms and capable of correctly handling exotic Windows paths. std::string adb_basename(const std::string& path); std::string adb_dirname(const std::string& path); // Return the user's home directory. // |check_env_first| - if true, on Windows check the ANDROID_SDK_HOME // environment variable before trying the WinAPI call (useful when looking for // the .android directory) std::string adb_get_homedir_path(bool check_env_first); bool mkdirs(const std::string& path); std::string escape_arg(const std::string& s); std::string dump_hex(const void* ptr, size_t byte_count); std::string perror_str(const char* msg); bool set_file_block_mode(int fd, bool block); extern int adb_close(int fd); // Helper to automatically close an FD when it goes out of scope. struct AdbCloser { static void Close(int fd) { adb_close(fd); } }; using unique_fd = android::base::unique_fd_impl; class ScopedFd { public: ScopedFd() { } ~ScopedFd() { Reset(); } void Reset(int fd = -1) { if (fd != fd_) { if (valid()) { adb_close(fd_); } fd_ = fd; } } int Release() { int temp = fd_; fd_ = -1; return temp; } bool valid() const { return fd_ >= 0; } int fd() const { return fd_; } private: int fd_ = -1; DISALLOW_COPY_AND_ASSIGN(ScopedFd); }; #endif adb/adb_utils_test.cpp0100644 0000000 0000000 00000011366 12767234553 014071 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "adb_utils.h" #ifdef _WIN32 #include #include #endif #include #include #include #include #include "sysdeps.h" #include #include #ifdef _WIN32 static std::string subdir(const char* parent, const char* child) { std::string str(parent); str += OS_PATH_SEPARATOR; str += child; return str; } #endif TEST(adb_utils, directory_exists) { #ifdef _WIN32 char profiles_dir[MAX_PATH]; DWORD cch = arraysize(profiles_dir); // On typical Windows 7, returns C:\Users ASSERT_TRUE(GetProfilesDirectoryA(profiles_dir, &cch)); ASSERT_TRUE(directory_exists(profiles_dir)); // On modern (English?) Windows, this is a directory symbolic link to // C:\ProgramData. Symbolic links are rare on Windows and the user requires // a special permission (by default granted to Administrative users) to // create symbolic links. ASSERT_FALSE(directory_exists(subdir(profiles_dir, "All Users"))); // On modern (English?) Windows, this is a directory junction to // C:\Users\Default. Junctions are used throughout user profile directories // for backwards compatibility and they don't require any special permissions // to create. ASSERT_FALSE(directory_exists(subdir(profiles_dir, "Default User"))); ASSERT_FALSE(directory_exists(subdir(profiles_dir, "does-not-exist"))); #else ASSERT_TRUE(directory_exists("/proc")); ASSERT_FALSE(directory_exists("/proc/self")); // Symbolic link. ASSERT_FALSE(directory_exists("/proc/does-not-exist")); #endif } TEST(adb_utils, escape_arg) { ASSERT_EQ(R"('')", escape_arg("")); ASSERT_EQ(R"('abc')", escape_arg("abc")); ASSERT_EQ(R"(' abc')", escape_arg(" abc")); ASSERT_EQ(R"(''\''abc')", escape_arg("'abc")); ASSERT_EQ(R"('"abc')", escape_arg("\"abc")); ASSERT_EQ(R"('\abc')", escape_arg("\\abc")); ASSERT_EQ(R"('(abc')", escape_arg("(abc")); ASSERT_EQ(R"(')abc')", escape_arg(")abc")); ASSERT_EQ(R"('abc abc')", escape_arg("abc abc")); ASSERT_EQ(R"('abc'\''abc')", escape_arg("abc'abc")); ASSERT_EQ(R"('abc"abc')", escape_arg("abc\"abc")); ASSERT_EQ(R"('abc\abc')", escape_arg("abc\\abc")); ASSERT_EQ(R"('abc(abc')", escape_arg("abc(abc")); ASSERT_EQ(R"('abc)abc')", escape_arg("abc)abc")); ASSERT_EQ(R"('abc ')", escape_arg("abc ")); ASSERT_EQ(R"('abc'\''')", escape_arg("abc'")); ASSERT_EQ(R"('abc"')", escape_arg("abc\"")); ASSERT_EQ(R"('abc\')", escape_arg("abc\\")); ASSERT_EQ(R"('abc(')", escape_arg("abc(")); ASSERT_EQ(R"('abc)')", escape_arg("abc)")); } TEST(adb_utils, adb_basename) { EXPECT_EQ("sh", adb_basename("/system/bin/sh")); EXPECT_EQ("sh", adb_basename("sh")); EXPECT_EQ("sh", adb_basename("/system/bin/sh/")); } TEST(adb_utils, adb_dirname) { EXPECT_EQ("/system/bin", adb_dirname("/system/bin/sh")); EXPECT_EQ(".", adb_dirname("sh")); EXPECT_EQ("/system/bin", adb_dirname("/system/bin/sh/")); } void test_mkdirs(const std::string basepath) { // Test creating a directory hierarchy. EXPECT_TRUE(mkdirs(basepath)); // Test finding an existing directory hierarchy. EXPECT_TRUE(mkdirs(basepath)); const std::string filepath = basepath + "/file"; // Verify that the hierarchy was created by trying to create a file in it. EXPECT_NE(-1, adb_creat(filepath.c_str(), 0600)); // If a file exists where we want a directory, the operation should fail. EXPECT_FALSE(mkdirs(filepath)); } TEST(adb_utils, mkdirs) { TemporaryDir td; // Absolute paths. test_mkdirs(std::string(td.path) + "/dir/subdir"); // Relative paths. ASSERT_EQ(0, chdir(td.path)) << strerror(errno); test_mkdirs(std::string("relative/subrel")); } #if !defined(_WIN32) TEST(adb_utils, set_file_block_mode) { int fd = adb_open("/dev/null", O_RDWR | O_APPEND); ASSERT_GE(fd, 0); int flags = fcntl(fd, F_GETFL, 0); ASSERT_EQ(O_RDWR | O_APPEND, (flags & (O_RDWR | O_APPEND))); ASSERT_TRUE(set_file_block_mode(fd, false)); int new_flags = fcntl(fd, F_GETFL, 0); ASSERT_EQ(flags | O_NONBLOCK, new_flags); ASSERT_TRUE(set_file_block_mode(fd, true)); new_flags = fcntl(fd, F_GETFL, 0); ASSERT_EQ(flags, new_flags); ASSERT_EQ(0, adb_close(fd)); } #endif adb/client/0040755 0000000 0000000 00000000000 12767234553 011632 5ustar000000000 0000000 adb/client/main.cpp0100644 0000000 0000000 00000013527 12767234553 013267 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG ADB #include "sysdeps.h" #include #include #include #include #include #include #include #include #include "adb.h" #include "adb_auth.h" #include "adb_listeners.h" #include "adb_utils.h" #include "transport.h" static std::string GetLogFilePath() { #if defined(_WIN32) const char log_name[] = "adb.log"; WCHAR temp_path[MAX_PATH]; // https://msdn.microsoft.com/en-us/library/windows/desktop/aa364992%28v=vs.85%29.aspx DWORD nchars = GetTempPathW(arraysize(temp_path), temp_path); if (nchars >= arraysize(temp_path) || nchars == 0) { // If string truncation or some other error. fatal("cannot retrieve temporary file path: %s\n", android::base::SystemErrorCodeToString(GetLastError()).c_str()); } std::string temp_path_utf8; if (!android::base::WideToUTF8(temp_path, &temp_path_utf8)) { fatal_errno("cannot convert temporary file path from UTF-16 to UTF-8"); } return temp_path_utf8 + log_name; #else const char* tmp_dir = getenv("TMPDIR"); if (tmp_dir == nullptr) tmp_dir = "/tmp"; return android::base::StringPrintf("%s/adb.%u.log", tmp_dir, getuid()); #endif } static void setup_daemon_logging(void) { const std::string log_file_path(GetLogFilePath()); int fd = unix_open(log_file_path.c_str(), O_WRONLY | O_CREAT | O_APPEND, 0640); if (fd == -1) { fatal("cannot open '%s': %s", log_file_path.c_str(), strerror(errno)); } if (dup2(fd, STDOUT_FILENO) == -1) { fatal("cannot redirect stdout: %s", strerror(errno)); } if (dup2(fd, STDERR_FILENO) == -1) { fatal("cannot redirect stderr: %s", strerror(errno)); } unix_close(fd); fprintf(stderr, "--- adb starting (pid %d) ---\n", getpid()); LOG(INFO) << adb_version(); } #if defined(_WIN32) static BOOL WINAPI ctrlc_handler(DWORD type) { // TODO: Consider trying to kill a starting up adb server (if we're in // launch_server) by calling GenerateConsoleCtrlEvent(). exit(STATUS_CONTROL_C_EXIT); return TRUE; } #endif int adb_server_main(int is_daemon, int server_port, int ack_reply_fd) { #if defined(_WIN32) // adb start-server starts us up with stdout and stderr hooked up to // anonymous pipes. When the C Runtime sees this, it makes stderr and // stdout buffered, but to improve the chance that error output is seen, // unbuffer stdout and stderr just like if we were run at the console. // This also keeps stderr unbuffered when it is redirected to adb.log. if (is_daemon) { if (setvbuf(stdout, NULL, _IONBF, 0) == -1) { fatal("cannot make stdout unbuffered: %s", strerror(errno)); } if (setvbuf(stderr, NULL, _IONBF, 0) == -1) { fatal("cannot make stderr unbuffered: %s", strerror(errno)); } } SetConsoleCtrlHandler(ctrlc_handler, TRUE); #endif init_transport_registration(); usb_init(); local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT); adb_auth_init(); std::string error; std::string local_name = android::base::StringPrintf("tcp:%d", server_port); if (install_listener(local_name, "*smartsocket*", nullptr, 0, &error)) { fatal("could not install *smartsocket* listener: %s", error.c_str()); } // Inform our parent that we are up and running. if (is_daemon) { close_stdin(); setup_daemon_logging(); #if !defined(_WIN32) // Start a new session for the daemon. Do this here instead of after the fork so // that a ctrl-c between the "starting server" and "done starting server" messages // gets a chance to terminate the server. if (setsid() == -1) { fatal("setsid() failed: %s", strerror(errno)); } #endif // Any error output written to stderr now goes to adb.log. We could // keep around a copy of the stderr fd and use that to write any errors // encountered by the following code, but that is probably overkill. #if defined(_WIN32) const HANDLE ack_reply_handle = cast_int_to_handle(ack_reply_fd); const CHAR ack[] = "OK\n"; const DWORD bytes_to_write = arraysize(ack) - 1; DWORD written = 0; if (!WriteFile(ack_reply_handle, ack, bytes_to_write, &written, NULL)) { fatal("adb: cannot write ACK to handle 0x%p: %s", ack_reply_handle, android::base::SystemErrorCodeToString(GetLastError()).c_str()); } if (written != bytes_to_write) { fatal("adb: cannot write %lu bytes of ACK: only wrote %lu bytes", bytes_to_write, written); } CloseHandle(ack_reply_handle); #else // TODO(danalbert): Can't use SendOkay because we're sending "OK\n", not // "OKAY". if (!android::base::WriteStringToFd("OK\n", ack_reply_fd)) { fatal_errno("error writing ACK to fd %d", ack_reply_fd); } unix_close(ack_reply_fd); #endif } D("Event loop starting"); fdevent_loop(); return 0; } int main(int argc, char** argv) { adb_sysdeps_init(); adb_trace_init(argv); return adb_commandline(argc - 1, const_cast(argv + 1)); } adb/commandline.cpp0100644 0000000 0000000 00000241217 12767234553 013352 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG ADB #include "sysdeps.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #if !defined(_WIN32) #include #include #include #include #endif #include "adb.h" #include "adb_auth.h" #include "adb_client.h" #include "adb_io.h" #include "adb_utils.h" #include "file_sync_service.h" #include "services.h" #include "shell_service.h" #include "transport.h" static int install_app(TransportType t, const char* serial, int argc, const char** argv); static int install_multiple_app(TransportType t, const char* serial, int argc, const char** argv); static int uninstall_app(TransportType t, const char* serial, int argc, const char** argv); static int install_app_legacy(TransportType t, const char* serial, int argc, const char** argv); static int uninstall_app_legacy(TransportType t, const char* serial, int argc, const char** argv); static auto& gProductOutPath = *new std::string(); extern int gListenAll; static constexpr char BUGZ_OK_PREFIX[] = "OK:"; static constexpr char BUGZ_FAIL_PREFIX[] = "FAIL:"; static std::string product_file(const char *extra) { if (gProductOutPath.empty()) { fprintf(stderr, "adb: Product directory not specified; " "use -p or define ANDROID_PRODUCT_OUT\n"); exit(1); } return android::base::StringPrintf("%s%s%s", gProductOutPath.c_str(), OS_PATH_SEPARATOR_STR, extra); } static void help() { fprintf(stderr, "%s\n", adb_version().c_str()); fprintf(stderr, " -a - directs adb to listen on all interfaces for a connection\n" " -d - directs command to the only connected USB device\n" " returns an error if more than one USB device is present.\n" " -e - directs command to the only running emulator.\n" " returns an error if more than one emulator is running.\n" " -s - directs command to the device or emulator with the given\n" " serial number or qualifier. Overrides ANDROID_SERIAL\n" " environment variable.\n" " -p - simple product name like 'sooner', or\n" " a relative/absolute path to a product\n" " out directory like 'out/target/product/sooner'.\n" " If -p is not specified, the ANDROID_PRODUCT_OUT\n" " environment variable is used, which must\n" " be an absolute path.\n" " -H - Name of adb server host (default: localhost)\n" " -P - Port of adb server (default: 5037)\n" " devices [-l] - list all connected devices\n" " ('-l' will also list device qualifiers)\n" " connect [:] - connect to a device via TCP/IP\n" " Port 5555 is used by default if no port number is specified.\n" " disconnect [[:]] - disconnect from a TCP/IP device.\n" " Port 5555 is used by default if no port number is specified.\n" " Using this command with no additional arguments\n" " will disconnect from all connected TCP/IP devices.\n" "\n" "device commands:\n" " adb push ... \n" " - copy files/dirs to device\n" " adb pull [-a] ... \n" " - copy files/dirs from device\n" " (-a preserves file timestamp and mode)\n" " adb sync [ ] - copy host->device only if changed\n" " (-l means list but don't copy)\n" " adb shell [-e escape] [-n] [-Tt] [-x] [command]\n" " - run remote shell command (interactive shell if no command given)\n" " (-e: choose escape character, or \"none\"; default '~')\n" " (-n: don't read from stdin)\n" " (-T: disable PTY allocation)\n" " (-t: force PTY allocation)\n" " (-x: disable remote exit codes and stdout/stderr separation)\n" " adb emu - run emulator console command\n" " adb logcat [ ] - View device log\n" " adb forward --list - list all forward socket connections.\n" " the format is a list of lines with the following format:\n" " \" \" \" \" \"\\n\"\n" " adb forward - forward socket connections\n" " forward specs are one of: \n" " tcp:\n" " localabstract:\n" " localreserved:\n" " localfilesystem:\n" " dev:\n" " jdwp: (remote only)\n" " adb forward --no-rebind \n" " - same as 'adb forward ' but fails\n" " if is already forwarded\n" " adb forward --remove - remove a specific forward socket connection\n" " adb forward --remove-all - remove all forward socket connections\n" " adb reverse --list - list all reverse socket connections from device\n" " adb reverse - reverse socket connections\n" " reverse specs are one of:\n" " tcp:\n" " localabstract:\n" " localreserved:\n" " localfilesystem:\n" " adb reverse --no-rebind \n" " - same as 'adb reverse ' but fails\n" " if is already reversed.\n" " adb reverse --remove \n" " - remove a specific reversed socket connection\n" " adb reverse --remove-all - remove all reversed socket connections from device\n" " adb jdwp - list PIDs of processes hosting a JDWP transport\n" " adb install [-lrtsdg] \n" " - push this package file to the device and install it\n" " (-l: forward lock application)\n" " (-r: replace existing application)\n" " (-t: allow test packages)\n" " (-s: install application on sdcard)\n" " (-d: allow version code downgrade (debuggable packages only))\n" " (-g: grant all runtime permissions)\n" " adb install-multiple [-lrtsdpg] \n" " - push this package file to the device and install it\n" " (-l: forward lock application)\n" " (-r: replace existing application)\n" " (-t: allow test packages)\n" " (-s: install application on sdcard)\n" " (-d: allow version code downgrade (debuggable packages only))\n" " (-p: partial application install)\n" " (-g: grant all runtime permissions)\n" " adb uninstall [-k] - remove this app package from the device\n" " ('-k' means keep the data and cache directories)\n" " adb bugreport [] - return all information from the device\n" " that should be included in a bug report.\n" "\n" " adb backup [-f ] [-apk|-noapk] [-obb|-noobb] [-shared|-noshared] [-all] [-system|-nosystem] []\n" " - write an archive of the device's data to .\n" " If no -f option is supplied then the data is written\n" " to \"backup.ab\" in the current directory.\n" " (-apk|-noapk enable/disable backup of the .apks themselves\n" " in the archive; the default is noapk.)\n" " (-obb|-noobb enable/disable backup of any installed apk expansion\n" " (aka .obb) files associated with each application; the default\n" " is noobb.)\n" " (-shared|-noshared enable/disable backup of the device's\n" " shared storage / SD card contents; the default is noshared.)\n" " (-all means to back up all installed applications)\n" " (-system|-nosystem toggles whether -all automatically includes\n" " system applications; the default is to include system apps)\n" " ( is the list of applications to be backed up. If\n" " the -all or -shared flags are passed, then the package\n" " list is optional. Applications explicitly given on the\n" " command line will be included even if -nosystem would\n" " ordinarily cause them to be omitted.)\n" "\n" " adb restore - restore device contents from the backup archive\n" "\n" " adb disable-verity - disable dm-verity checking on USERDEBUG builds\n" " adb enable-verity - re-enable dm-verity checking on USERDEBUG builds\n" " adb keygen - generate adb public/private key. The private key is stored in ,\n" " and the public key is stored in .pub. Any existing files\n" " are overwritten.\n" " adb help - show this help message\n" " adb version - show version num\n" "\n" "scripting:\n" " adb wait-for[-]-\n" " - wait for device to be in the given state:\n" " device, recovery, sideload, or bootloader\n" " Transport is: usb, local or any [default=any]\n" " adb start-server - ensure that there is a server running\n" " adb kill-server - kill the server if it is running\n" " adb get-state - prints: offline | bootloader | device\n" " adb get-serialno - prints: \n" " adb get-devpath - prints: \n" " adb remount - remounts the /system, /vendor (if present) and /oem (if present) partitions on the device read-write\n" " adb reboot [bootloader|recovery]\n" " - reboots the device, optionally into the bootloader or recovery program.\n" " adb reboot sideload - reboots the device into the sideload mode in recovery program (adb root required).\n" " adb reboot sideload-auto-reboot\n" " - reboots into the sideload mode, then reboots automatically after the sideload regardless of the result.\n" " adb sideload - sideloads the given package\n" " adb root - restarts the adbd daemon with root permissions\n" " adb unroot - restarts the adbd daemon without root permissions\n" " adb usb - restarts the adbd daemon listening on USB\n" " adb tcpip - restarts the adbd daemon listening on TCP on the specified port\n" "\n" "networking:\n" " adb ppp [parameters] - Run PPP over USB.\n" " Note: you should not automatically start a PPP connection.\n" " refers to the tty for PPP stream. Eg. dev:/dev/omap_csmi_tty1\n" " [parameters] - Eg. defaultroute debug dump local notty usepeerdns\n" "\n" "adb sync notes: adb sync [ ]\n" " can be interpreted in several ways:\n" "\n" " - If is not specified, /system, /vendor (if present), /oem (if present) and /data partitions will be updated.\n" "\n" " - If it is \"system\", \"vendor\", \"oem\" or \"data\", only the corresponding partition\n" " is updated.\n" "\n" "internal debugging:\n" " adb reconnect Kick current connection from host side and make it reconnect.\n" " adb reconnect device Kick current connection from device side and make it reconnect.\n" "environment variables:\n" " ADB_TRACE - Print debug information. A comma separated list of the following values\n" " 1 or all, adb, sockets, packets, rwx, usb, sync, sysdeps, transport, jdwp\n" " ANDROID_SERIAL - The serial number to connect to. -s takes priority over this if given.\n" " ANDROID_LOG_TAGS - When used with the logcat option, only these debug tags are printed.\n" ); } static int usage() { help(); return 1; } #if defined(_WIN32) // Implemented in sysdeps_win32.cpp. void stdin_raw_init(); void stdin_raw_restore(); #else static termios g_saved_terminal_state; static void stdin_raw_init() { if (tcgetattr(STDIN_FILENO, &g_saved_terminal_state)) return; termios tio; if (tcgetattr(STDIN_FILENO, &tio)) return; cfmakeraw(&tio); // No timeout but request at least one character per read. tio.c_cc[VTIME] = 0; tio.c_cc[VMIN] = 1; tcsetattr(STDIN_FILENO, TCSAFLUSH, &tio); } static void stdin_raw_restore() { tcsetattr(STDIN_FILENO, TCSAFLUSH, &g_saved_terminal_state); } #endif // Reads from |fd| and prints received data. If |use_shell_protocol| is true // this expects that incoming data will use the shell protocol, in which case // stdout/stderr are routed independently and the remote exit code will be // returned. // if |output| is non-null, stdout will be appended to it instead. // if |err| is non-null, stderr will be appended to it instead. static int read_and_dump(int fd, bool use_shell_protocol=false, std::string* output=nullptr, std::string* err=nullptr) { int exit_code = 0; if (fd < 0) return exit_code; std::unique_ptr protocol; int length = 0; FILE* outfile = stdout; std::string* outstring = output; char raw_buffer[BUFSIZ]; char* buffer_ptr = raw_buffer; if (use_shell_protocol) { protocol.reset(new ShellProtocol(fd)); if (!protocol) { LOG(ERROR) << "failed to allocate memory for ShellProtocol object"; return 1; } buffer_ptr = protocol->data(); } while (true) { if (use_shell_protocol) { if (!protocol->Read()) { break; } switch (protocol->id()) { case ShellProtocol::kIdStdout: outfile = stdout; outstring = output; break; case ShellProtocol::kIdStderr: outfile = stderr; outstring = err; break; case ShellProtocol::kIdExit: exit_code = protocol->data()[0]; continue; default: continue; } length = protocol->data_length(); } else { D("read_and_dump(): pre adb_read(fd=%d)", fd); length = adb_read(fd, raw_buffer, sizeof(raw_buffer)); D("read_and_dump(): post adb_read(fd=%d): length=%d", fd, length); if (length <= 0) { break; } } if (outstring == nullptr) { fwrite(buffer_ptr, 1, length, outfile); fflush(outfile); } else { outstring->append(buffer_ptr, length); } } return exit_code; } static void read_status_line(int fd, char* buf, size_t count) { count--; while (count > 0) { int len = adb_read(fd, buf, count); if (len <= 0) { break; } buf += len; count -= len; } *buf = '\0'; } static void copy_to_file(int inFd, int outFd) { const size_t BUFSIZE = 32 * 1024; char* buf = (char*) malloc(BUFSIZE); if (buf == nullptr) fatal("couldn't allocate buffer for copy_to_file"); int len; long total = 0; #ifdef _WIN32 int old_stdin_mode = -1; int old_stdout_mode = -1; #endif D("copy_to_file(%d -> %d)", inFd, outFd); if (inFd == STDIN_FILENO) { stdin_raw_init(); #ifdef _WIN32 old_stdin_mode = _setmode(STDIN_FILENO, _O_BINARY); if (old_stdin_mode == -1) { fatal_errno("could not set stdin to binary"); } #endif } #ifdef _WIN32 if (outFd == STDOUT_FILENO) { old_stdout_mode = _setmode(STDOUT_FILENO, _O_BINARY); if (old_stdout_mode == -1) { fatal_errno("could not set stdout to binary"); } } #endif while (true) { if (inFd == STDIN_FILENO) { len = unix_read(inFd, buf, BUFSIZE); } else { len = adb_read(inFd, buf, BUFSIZE); } if (len == 0) { D("copy_to_file() : read 0 bytes; exiting"); break; } if (len < 0) { D("copy_to_file(): read failed: %s", strerror(errno)); break; } if (outFd == STDOUT_FILENO) { fwrite(buf, 1, len, stdout); fflush(stdout); } else { adb_write(outFd, buf, len); } total += len; } if (inFd == STDIN_FILENO) { stdin_raw_restore(); #ifdef _WIN32 if (_setmode(STDIN_FILENO, old_stdin_mode) == -1) { fatal_errno("could not restore stdin mode"); } #endif } #ifdef _WIN32 if (outFd == STDOUT_FILENO) { if (_setmode(STDOUT_FILENO, old_stdout_mode) == -1) { fatal_errno("could not restore stdout mode"); } } #endif D("copy_to_file() finished after %lu bytes", total); free(buf); } static void send_window_size_change(int fd, std::unique_ptr& shell) { // Old devices can't handle window size changes. if (shell == nullptr) return; #if defined(_WIN32) struct winsize { unsigned short ws_row; unsigned short ws_col; unsigned short ws_xpixel; unsigned short ws_ypixel; }; #endif winsize ws; #if defined(_WIN32) // If stdout is redirected to a non-console, we won't be able to get the // console size, but that makes sense. const intptr_t intptr_handle = _get_osfhandle(STDOUT_FILENO); if (intptr_handle == -1) return; const HANDLE handle = reinterpret_cast(intptr_handle); CONSOLE_SCREEN_BUFFER_INFO info; memset(&info, 0, sizeof(info)); if (!GetConsoleScreenBufferInfo(handle, &info)) return; memset(&ws, 0, sizeof(ws)); // The number of visible rows, excluding offscreen scroll-back rows which are in info.dwSize.Y. ws.ws_row = info.srWindow.Bottom - info.srWindow.Top + 1; // If the user has disabled "Wrap text output on resize", they can make the screen buffer wider // than the window, in which case we should use the width of the buffer. ws.ws_col = info.dwSize.X; #else if (ioctl(fd, TIOCGWINSZ, &ws) == -1) return; #endif // Send the new window size as human-readable ASCII for debugging convenience. size_t l = snprintf(shell->data(), shell->data_capacity(), "%dx%d,%dx%d", ws.ws_row, ws.ws_col, ws.ws_xpixel, ws.ws_ypixel); shell->Write(ShellProtocol::kIdWindowSizeChange, l + 1); } // Used to pass multiple values to the stdin read thread. struct StdinReadArgs { int stdin_fd, write_fd; bool raw_stdin; std::unique_ptr protocol; char escape_char; }; // Loops to read from stdin and push the data to the given FD. // The argument should be a pointer to a StdinReadArgs object. This function // will take ownership of the object and delete it when finished. static void stdin_read_thread_loop(void* x) { std::unique_ptr args(reinterpret_cast(x)); #if !defined(_WIN32) // Mask SIGTTIN in case we're in a backgrounded process. sigset_t sigset; sigemptyset(&sigset); sigaddset(&sigset, SIGTTIN); pthread_sigmask(SIG_BLOCK, &sigset, nullptr); #endif #if defined(_WIN32) // _get_interesting_input_record_uncached() causes unix_read_interruptible() // to return -1 with errno == EINTR if the window size changes. #else // Unblock SIGWINCH for this thread, so our read(2) below will be // interrupted if the window size changes. sigset_t mask; sigemptyset(&mask); sigaddset(&mask, SIGWINCH); pthread_sigmask(SIG_UNBLOCK, &mask, nullptr); #endif // Set up the initial window size. send_window_size_change(args->stdin_fd, args->protocol); char raw_buffer[BUFSIZ]; char* buffer_ptr = raw_buffer; size_t buffer_size = sizeof(raw_buffer); if (args->protocol != nullptr) { buffer_ptr = args->protocol->data(); buffer_size = args->protocol->data_capacity(); } // If we need to parse escape sequences, make life easy. if (args->raw_stdin && args->escape_char != '\0') { buffer_size = 1; } enum EscapeState { kMidFlow, kStartOfLine, kInEscape }; EscapeState state = kStartOfLine; while (true) { // Use unix_read_interruptible() rather than adb_read() for stdin. D("stdin_read_thread_loop(): pre unix_read_interruptible(fdi=%d,...)", args->stdin_fd); int r = unix_read_interruptible(args->stdin_fd, buffer_ptr, buffer_size); if (r == -1 && errno == EINTR) { send_window_size_change(args->stdin_fd, args->protocol); continue; } D("stdin_read_thread_loop(): post unix_read_interruptible(fdi=%d,...)", args->stdin_fd); if (r <= 0) { // Only devices using the shell protocol know to close subprocess // stdin. For older devices we want to just leave the connection // open, otherwise an unpredictable amount of return data could // be lost due to the FD closing before all data has been received. if (args->protocol) { args->protocol->Write(ShellProtocol::kIdCloseStdin, 0); } break; } // If we made stdin raw, check input for escape sequences. In // this situation signals like Ctrl+C are sent remotely rather than // interpreted locally so this provides an emergency out if the remote // process starts ignoring the signal. SSH also does this, see the // "escape characters" section on the ssh man page for more info. if (args->raw_stdin && args->escape_char != '\0') { char ch = buffer_ptr[0]; if (ch == args->escape_char) { if (state == kStartOfLine) { state = kInEscape; // Swallow the escape character. continue; } else { state = kMidFlow; } } else { if (state == kInEscape) { if (ch == '.') { fprintf(stderr,"\r\n[ disconnected ]\r\n"); stdin_raw_restore(); exit(0); } else { // We swallowed an escape character that wasn't part of // a valid escape sequence; time to cough it up. buffer_ptr[0] = args->escape_char; buffer_ptr[1] = ch; ++r; } } state = (ch == '\n' || ch == '\r') ? kStartOfLine : kMidFlow; } } if (args->protocol) { if (!args->protocol->Write(ShellProtocol::kIdStdin, r)) { break; } } else { if (!WriteFdExactly(args->write_fd, buffer_ptr, r)) { break; } } } } // Returns a shell service string with the indicated arguments and command. static std::string ShellServiceString(bool use_shell_protocol, const std::string& type_arg, const std::string& command) { std::vector args; if (use_shell_protocol) { args.push_back(kShellServiceArgShellProtocol); const char* terminal_type = getenv("TERM"); if (terminal_type != nullptr) { args.push_back(std::string("TERM=") + terminal_type); } } if (!type_arg.empty()) { args.push_back(type_arg); } // Shell service string can look like: shell[,arg1,arg2,...]:[command]. return android::base::StringPrintf("shell%s%s:%s", args.empty() ? "" : ",", android::base::Join(args, ',').c_str(), command.c_str()); } // Connects to a shell on the device and read/writes data. // // Note: currently this function doesn't properly clean up resources; the // FD connected to the adb server is never closed and the stdin read thread // may never exit. // // On success returns the remote exit code if |use_shell_protocol| is true, // 0 otherwise. On failure returns 1. static int RemoteShell(bool use_shell_protocol, const std::string& type_arg, char escape_char, const std::string& command) { std::string service_string = ShellServiceString(use_shell_protocol, type_arg, command); // Make local stdin raw if the device allocates a PTY, which happens if: // 1. We are explicitly asking for a PTY shell, or // 2. We don't specify shell type and are starting an interactive session. bool raw_stdin = (type_arg == kShellServiceArgPty || (type_arg.empty() && command.empty())); std::string error; int fd = adb_connect(service_string, &error); if (fd < 0) { fprintf(stderr,"error: %s\n", error.c_str()); return 1; } StdinReadArgs* args = new StdinReadArgs; if (!args) { LOG(ERROR) << "couldn't allocate StdinReadArgs object"; return 1; } args->stdin_fd = STDIN_FILENO; args->write_fd = fd; args->raw_stdin = raw_stdin; args->escape_char = escape_char; if (use_shell_protocol) { args->protocol.reset(new ShellProtocol(args->write_fd)); } if (raw_stdin) stdin_raw_init(); #if !defined(_WIN32) // Ensure our process is notified if the local window size changes. // We use sigaction(2) to ensure that the SA_RESTART flag is not set, // because the whole reason we're sending signals is to unblock the read(2)! // That also means we don't need to do anything in the signal handler: // the side effect of delivering the signal is all we need. struct sigaction sa; memset(&sa, 0, sizeof(sa)); sa.sa_handler = [](int) {}; sa.sa_flags = 0; sigaction(SIGWINCH, &sa, nullptr); // Now block SIGWINCH in this thread (the main thread) and all threads spawned // from it. The stdin read thread will unblock this signal to ensure that it's // the thread that receives the signal. sigset_t mask; sigemptyset(&mask); sigaddset(&mask, SIGWINCH); pthread_sigmask(SIG_BLOCK, &mask, nullptr); #endif // TODO: combine read_and_dump with stdin_read_thread to make life simpler? int exit_code = 1; if (!adb_thread_create(stdin_read_thread_loop, args)) { PLOG(ERROR) << "error starting stdin read thread"; delete args; } else { exit_code = read_and_dump(fd, use_shell_protocol); } // TODO: properly exit stdin_read_thread_loop and close |fd|. // TODO: we should probably install signal handlers for this. // TODO: can we use atexit? even on Windows? if (raw_stdin) stdin_raw_restore(); return exit_code; } static int adb_shell(int argc, const char** argv) { FeatureSet features; std::string error; if (!adb_get_feature_set(&features, &error)) { fprintf(stderr, "error: %s\n", error.c_str()); return 1; } bool use_shell_protocol = CanUseFeature(features, kFeatureShell2); if (!use_shell_protocol) { D("shell protocol not supported, using raw data transfer"); } else { D("using shell protocol"); } // Parse shell-specific command-line options. // argv[0] is always "shell". --argc; ++argv; int t_arg_count = 0; char escape_char = '~'; while (argc) { if (!strcmp(argv[0], "-e")) { if (argc < 2 || !(strlen(argv[1]) == 1 || strcmp(argv[1], "none") == 0)) { fprintf(stderr, "error: -e requires a single-character argument or 'none'\n"); return 1; } escape_char = (strcmp(argv[1], "none") == 0) ? 0 : argv[1][0]; argc -= 2; argv += 2; } else if (!strcmp(argv[0], "-T") || !strcmp(argv[0], "-t")) { // Like ssh, -t arguments are cumulative so that multiple -t's // are needed to force a PTY. if (argv[0][1] == 't') { ++t_arg_count; } else { t_arg_count = -1; } --argc; ++argv; } else if (!strcmp(argv[0], "-x")) { use_shell_protocol = false; --argc; ++argv; } else if (!strcmp(argv[0], "-n")) { close_stdin(); --argc; ++argv; } else { break; } } // Legacy shell protocol requires a remote PTY to close the subprocess properly which creates // some weird interactions with -tT. if (!use_shell_protocol && t_arg_count != 0) { if (!CanUseFeature(features, kFeatureShell2)) { fprintf(stderr, "error: target doesn't support PTY args -Tt\n"); } else { fprintf(stderr, "error: PTY args -Tt cannot be used with -x\n"); } return 1; } std::string shell_type_arg; if (CanUseFeature(features, kFeatureShell2)) { if (t_arg_count < 0) { shell_type_arg = kShellServiceArgRaw; } else if (t_arg_count == 0) { // If stdin isn't a TTY, default to a raw shell; this lets // things like `adb shell < my_script.sh` work as expected. // Otherwise leave |shell_type_arg| blank which uses PTY for // interactive shells and raw for non-interactive. if (!unix_isatty(STDIN_FILENO)) { shell_type_arg = kShellServiceArgRaw; } } else if (t_arg_count == 1) { // A single -t arg isn't enough to override implicit -T. if (!unix_isatty(STDIN_FILENO)) { fprintf(stderr, "Remote PTY will not be allocated because stdin is not a terminal.\n" "Use multiple -t options to force remote PTY allocation.\n"); shell_type_arg = kShellServiceArgRaw; } else { shell_type_arg = kShellServiceArgPty; } } else { shell_type_arg = kShellServiceArgPty; } } std::string command; if (argc) { // We don't escape here, just like ssh(1). http://b/20564385. command = android::base::Join(std::vector(argv, argv + argc), ' '); } return RemoteShell(use_shell_protocol, shell_type_arg, escape_char, command); } static int adb_download_buffer(const char *service, const char *fn, const void* data, unsigned sz, bool show_progress) { std::string error; int fd = adb_connect(android::base::StringPrintf("%s:%d", service, sz), &error); if (fd < 0) { fprintf(stderr,"error: %s\n", error.c_str()); return -1; } int opt = CHUNK_SIZE; opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); unsigned total = sz; const uint8_t* ptr = reinterpret_cast(data); if (show_progress) { const char* x = strrchr(service, ':'); if (x) service = x + 1; } while (sz > 0) { unsigned xfer = (sz > CHUNK_SIZE) ? CHUNK_SIZE : sz; if (!WriteFdExactly(fd, ptr, xfer)) { std::string error; adb_status(fd, &error); fprintf(stderr,"* failed to write data '%s' *\n", error.c_str()); adb_close(fd); return -1; } sz -= xfer; ptr += xfer; if (show_progress) { printf("sending: '%s' %4d%% \r", fn, (int)(100LL - ((100LL * sz) / (total)))); fflush(stdout); } } if (show_progress) { printf("\n"); } if (!adb_status(fd, &error)) { fprintf(stderr,"* error response '%s' *\n", error.c_str()); adb_close(fd); return -1; } adb_close(fd); return 0; } #define SIDELOAD_HOST_BLOCK_SIZE (CHUNK_SIZE) /* * The sideload-host protocol serves the data in a file (given on the * command line) to the client, using a simple protocol: * * - The connect message includes the total number of bytes in the * file and a block size chosen by us. * * - The other side sends the desired block number as eight decimal * digits (eg "00000023" for block 23). Blocks are numbered from * zero. * * - We send back the data of the requested block. The last block is * likely to be partial; when the last block is requested we only * send the part of the block that exists, it's not padded up to the * block size. * * - When the other side sends "DONEDONE" instead of a block number, * we hang up. */ static int adb_sideload_host(const char* fn) { unsigned sz; size_t xfer = 0; int status; int last_percent = -1; int opt = SIDELOAD_HOST_BLOCK_SIZE; printf("loading: '%s'", fn); fflush(stdout); uint8_t* data = reinterpret_cast(load_file(fn, &sz)); if (data == 0) { printf("\n"); fprintf(stderr, "* cannot read '%s' *\n", fn); return -1; } std::string service = android::base::StringPrintf("sideload-host:%d:%d", sz, SIDELOAD_HOST_BLOCK_SIZE); std::string error; int fd = adb_connect(service, &error); if (fd < 0) { // Try falling back to the older sideload method. Maybe this // is an older device that doesn't support sideload-host. printf("\n"); status = adb_download_buffer("sideload", fn, data, sz, true); goto done; } opt = adb_setsockopt(fd, SOL_SOCKET, SO_SNDBUF, (const void *) &opt, sizeof(opt)); while (true) { char buf[9]; if (!ReadFdExactly(fd, buf, 8)) { fprintf(stderr, "* failed to read command: %s\n", strerror(errno)); status = -1; goto done; } buf[8] = '\0'; if (strcmp("DONEDONE", buf) == 0) { status = 0; break; } int block = strtol(buf, NULL, 10); size_t offset = block * SIDELOAD_HOST_BLOCK_SIZE; if (offset >= sz) { fprintf(stderr, "* attempt to read block %d past end\n", block); status = -1; goto done; } uint8_t* start = data + offset; size_t offset_end = offset + SIDELOAD_HOST_BLOCK_SIZE; size_t to_write = SIDELOAD_HOST_BLOCK_SIZE; if (offset_end > sz) { to_write = sz - offset; } if(!WriteFdExactly(fd, start, to_write)) { adb_status(fd, &error); fprintf(stderr,"* failed to write data '%s' *\n", error.c_str()); status = -1; goto done; } xfer += to_write; // For normal OTA packages, we expect to transfer every byte // twice, plus a bit of overhead (one read during // verification, one read of each byte for installation, plus // extra access to things like the zip central directory). // This estimate of the completion becomes 100% when we've // transferred ~2.13 (=100/47) times the package size. int percent = (int)(xfer * 47LL / (sz ? sz : 1)); if (percent != last_percent) { printf("\rserving: '%s' (~%d%%) ", fn, percent); fflush(stdout); last_percent = percent; } } printf("\rTotal xfer: %.2fx%*s\n", (double)xfer / (sz ? sz : 1), (int)strlen(fn)+10, ""); done: if (fd >= 0) adb_close(fd); free(data); return status; } /** * Run ppp in "notty" mode against a resource listed as the first parameter * eg: * * ppp dev:/dev/omap_csmi_tty0 * */ static int ppp(int argc, const char** argv) { #if defined(_WIN32) fprintf(stderr, "error: adb %s not implemented on Win32\n", argv[0]); return -1; #else if (argc < 2) { fprintf(stderr, "usage: adb %s [ppp opts]\n", argv[0]); return 1; } const char* adb_service_name = argv[1]; std::string error; int fd = adb_connect(adb_service_name, &error); if (fd < 0) { fprintf(stderr,"Error: Could not open adb service: %s. Error: %s\n", adb_service_name, error.c_str()); return 1; } pid_t pid = fork(); if (pid < 0) { perror("from fork()"); return 1; } else if (pid == 0) { int err; int i; const char **ppp_args; // copy args ppp_args = (const char **) alloca(sizeof(char *) * argc + 1); ppp_args[0] = "pppd"; for (i = 2 ; i < argc ; i++) { //argv[2] and beyond become ppp_args[1] and beyond ppp_args[i - 1] = argv[i]; } ppp_args[i-1] = NULL; // child side dup2(fd, STDIN_FILENO); dup2(fd, STDOUT_FILENO); adb_close(STDERR_FILENO); adb_close(fd); err = execvp("pppd", (char * const *)ppp_args); if (err < 0) { perror("execing pppd"); } exit(-1); } else { // parent side adb_close(fd); return 0; } #endif /* !defined(_WIN32) */ } static bool wait_for_device(const char* service, TransportType t, const char* serial) { std::vector components = android::base::Split(service, "-"); if (components.size() < 3 || components.size() > 4) { fprintf(stderr, "adb: couldn't parse 'wait-for' command: %s\n", service); return false; } // Was the caller vague about what they'd like us to wait for? // If so, check they weren't more specific in their choice of transport type. if (components.size() == 3) { auto it = components.begin() + 2; if (t == kTransportUsb) { components.insert(it, "usb"); } else if (t == kTransportLocal) { components.insert(it, "local"); } else { components.insert(it, "any"); } } else if (components[2] != "any" && components[2] != "local" && components[2] != "usb") { fprintf(stderr, "adb: unknown type %s; expected 'any', 'local', or 'usb'\n", components[2].c_str()); return false; } if (components[3] != "any" && components[3] != "bootloader" && components[3] != "device" && components[3] != "recovery" && components[3] != "sideload") { fprintf(stderr, "adb: unknown state %s; " "expected 'any', 'bootloader', 'device', 'recovery', or 'sideload'\n", components[3].c_str()); return false; } std::string cmd = format_host_command(android::base::Join(components, "-").c_str(), t, serial); return adb_command(cmd); } static bool adb_root(const char* command) { std::string error; ScopedFd fd; fd.Reset(adb_connect(android::base::StringPrintf("%s:", command), &error)); if (!fd.valid()) { fprintf(stderr, "adb: unable to connect for %s: %s\n", command, error.c_str()); return false; } // Figure out whether we actually did anything. char buf[256]; char* cur = buf; ssize_t bytes_left = sizeof(buf); while (bytes_left > 0) { ssize_t bytes_read = adb_read(fd.fd(), cur, bytes_left); if (bytes_read == 0) { break; } else if (bytes_read < 0) { fprintf(stderr, "adb: error while reading for %s: %s\n", command, strerror(errno)); return false; } cur += bytes_read; bytes_left -= bytes_read; } if (bytes_left == 0) { fprintf(stderr, "adb: unexpected output length for %s\n", command); return false; } fflush(stdout); WriteFdExactly(STDOUT_FILENO, buf, sizeof(buf) - bytes_left); if (cur != buf && strstr(buf, "restarting") == nullptr) { return true; } // Give adbd 500ms to kill itself, then wait-for-device for it to come back up. adb_sleep_ms(500); TransportType type; const char* serial; adb_get_transport(&type, &serial); return wait_for_device("wait-for-any", type, serial); } // Connects to the device "shell" service with |command| and prints the // resulting output. static int send_shell_command(TransportType transport_type, const char* serial, const std::string& command, bool disable_shell_protocol, std::string* output=nullptr, std::string* err=nullptr) { int fd; bool use_shell_protocol = false; while (true) { bool attempt_connection = true; // Use shell protocol if it's supported and the caller doesn't explicitly disable it. if (!disable_shell_protocol) { FeatureSet features; std::string error; if (adb_get_feature_set(&features, &error)) { use_shell_protocol = CanUseFeature(features, kFeatureShell2); } else { // Device was unreachable. attempt_connection = false; } } if (attempt_connection) { std::string error; std::string service_string = ShellServiceString(use_shell_protocol, "", command); fd = adb_connect(service_string, &error); if (fd >= 0) { break; } } fprintf(stderr,"- waiting for device -\n"); if (!wait_for_device("wait-for-device", transport_type, serial)) { return 1; } } int exit_code = read_and_dump(fd, use_shell_protocol, output, err); if (adb_close(fd) < 0) { PLOG(ERROR) << "failure closing FD " << fd; } return exit_code; } static int bugreport(TransportType transport_type, const char* serial, int argc, const char** argv) { if (argc == 1) return send_shell_command(transport_type, serial, "bugreport", false); if (argc != 2) return usage(); // Zipped bugreport option - will call 'bugreportz', which prints the location of the generated // file, then pull it to the destination file provided by the user. std::string dest_file = argv[1]; if (!android::base::EndsWith(argv[1], ".zip")) { // TODO: use a case-insensitive comparison (like EndsWithIgnoreCase dest_file += ".zip"; } std::string output; fprintf(stderr, "Bugreport is in progress and it could take minutes to complete.\n" "Please be patient and do not cancel or disconnect your device until it completes.\n"); int status = send_shell_command(transport_type, serial, "bugreportz", false, &output, nullptr); if (status != 0 || output.empty()) return status; output = android::base::Trim(output); if (android::base::StartsWith(output, BUGZ_OK_PREFIX)) { const char* zip_file = &output[strlen(BUGZ_OK_PREFIX)]; std::vector srcs{zip_file}; status = do_sync_pull(srcs, dest_file.c_str(), true, dest_file.c_str()) ? 0 : 1; if (status != 0) { fprintf(stderr, "Could not copy file '%s' to '%s'\n", zip_file, dest_file.c_str()); } return status; } if (android::base::StartsWith(output, BUGZ_FAIL_PREFIX)) { const char* error_message = &output[strlen(BUGZ_FAIL_PREFIX)]; fprintf(stderr, "Device failed to take a zipped bugreport: %s\n", error_message); return -1; } fprintf(stderr, "Unexpected string (%s) returned by bugreportz, " "device probably does not support -z option\n", output.c_str()); return -1; } static int logcat(TransportType transport, const char* serial, int argc, const char** argv) { char* log_tags = getenv("ANDROID_LOG_TAGS"); std::string quoted = escape_arg(log_tags == nullptr ? "" : log_tags); std::string cmd = "export ANDROID_LOG_TAGS=\"" + quoted + "\"; exec logcat"; if (!strcmp(argv[0], "longcat")) { cmd += " -v long"; } --argc; ++argv; while (argc-- > 0) { cmd += " " + escape_arg(*argv++); } // No need for shell protocol with logcat, always disable for simplicity. return send_shell_command(transport, serial, cmd, true); } static int backup(int argc, const char** argv) { const char* filename = "backup.ab"; /* find, extract, and use any -f argument */ for (int i = 1; i < argc; i++) { if (!strcmp("-f", argv[i])) { if (i == argc-1) { fprintf(stderr, "adb: backup -f passed with no filename.\n"); return EXIT_FAILURE; } filename = argv[i+1]; for (int j = i+2; j <= argc; ) { argv[i++] = argv[j++]; } argc -= 2; argv[argc] = NULL; } } // Bare "adb backup" or "adb backup -f filename" are not valid invocations --- // a list of packages is required. if (argc < 2) { fprintf(stderr, "adb: backup either needs a list of packages or -all/-shared.\n"); return EXIT_FAILURE; } adb_unlink(filename); int outFd = adb_creat(filename, 0640); if (outFd < 0) { fprintf(stderr, "adb: backup unable to create file '%s': %s\n", filename, strerror(errno)); return EXIT_FAILURE; } std::string cmd = "backup:"; --argc; ++argv; while (argc-- > 0) { cmd += " " + escape_arg(*argv++); } D("backup. filename=%s cmd=%s", filename, cmd.c_str()); std::string error; int fd = adb_connect(cmd, &error); if (fd < 0) { fprintf(stderr, "adb: unable to connect for backup: %s\n", error.c_str()); adb_close(outFd); return EXIT_FAILURE; } printf("Now unlock your device and confirm the backup operation...\n"); fflush(stdout); copy_to_file(fd, outFd); adb_close(fd); adb_close(outFd); return EXIT_SUCCESS; } static int restore(int argc, const char** argv) { if (argc != 2) return usage(); const char* filename = argv[1]; int tarFd = adb_open(filename, O_RDONLY); if (tarFd < 0) { fprintf(stderr, "adb: unable to open file %s: %s\n", filename, strerror(errno)); return -1; } std::string error; int fd = adb_connect("restore:", &error); if (fd < 0) { fprintf(stderr, "adb: unable to connect for restore: %s\n", error.c_str()); adb_close(tarFd); return -1; } printf("Now unlock your device and confirm the restore operation.\n"); copy_to_file(tarFd, fd); // Wait until the other side finishes, or it'll get sent SIGHUP. copy_to_file(fd, STDOUT_FILENO); adb_close(fd); adb_close(tarFd); return 0; } /* may be: * - A simple product name * e.g., "sooner" * - A relative path from the CWD to the ANDROID_PRODUCT_OUT dir * e.g., "out/target/product/sooner" * - An absolute path to the PRODUCT_OUT dir * e.g., "/src/device/out/target/product/sooner" * * Given , try to construct an absolute path to the * ANDROID_PRODUCT_OUT dir. */ static std::string find_product_out_path(const std::string& hint) { if (hint.empty()) { return ""; } // If it's already absolute, don't bother doing any work. if (adb_is_absolute_host_path(hint.c_str())) { return hint; } // If there are any slashes in it, assume it's a relative path; // make it absolute. if (hint.find_first_of(OS_PATH_SEPARATORS) != std::string::npos) { std::string cwd; if (!getcwd(&cwd)) { fprintf(stderr, "adb: getcwd failed: %s\n", strerror(errno)); return ""; } return android::base::StringPrintf("%s%c%s", cwd.c_str(), OS_PATH_SEPARATOR, hint.c_str()); } // It's a string without any slashes. Try to do something with it. // // Try to find the root of the build tree, and build a PRODUCT_OUT // path from there. char* top = getenv("ANDROID_BUILD_TOP"); if (top == nullptr) { fprintf(stderr, "adb: ANDROID_BUILD_TOP not set!\n"); return ""; } std::string path = top; path += OS_PATH_SEPARATOR_STR; path += "out"; path += OS_PATH_SEPARATOR_STR; path += "target"; path += OS_PATH_SEPARATOR_STR; path += "product"; path += OS_PATH_SEPARATOR_STR; path += hint; if (!directory_exists(path)) { fprintf(stderr, "adb: Couldn't find a product dir based on -p %s; " "\"%s\" doesn't exist\n", hint.c_str(), path.c_str()); return ""; } return path; } static void parse_push_pull_args(const char** arg, int narg, std::vector* srcs, const char** dst, bool* copy_attrs) { *copy_attrs = false; srcs->clear(); bool ignore_flags = false; while (narg > 0) { if (ignore_flags || *arg[0] != '-') { srcs->push_back(*arg); } else { if (!strcmp(*arg, "-p")) { // Silently ignore for backwards compatibility. } else if (!strcmp(*arg, "-a")) { *copy_attrs = true; } else if (!strcmp(*arg, "--")) { ignore_flags = true; } else { fprintf(stderr, "adb: unrecognized option '%s'\n", *arg); exit(1); } } ++arg; --narg; } if (srcs->size() > 1) { *dst = srcs->back(); srcs->pop_back(); } } static int adb_connect_command(const std::string& command) { std::string error; int fd = adb_connect(command, &error); if (fd < 0) { fprintf(stderr, "error: %s\n", error.c_str()); return 1; } read_and_dump(fd); adb_close(fd); return 0; } static int adb_query_command(const std::string& command) { std::string result; std::string error; if (!adb_query(command, &result, &error)) { fprintf(stderr, "error: %s\n", error.c_str()); return 1; } printf("%s\n", result.c_str()); return 0; } // Disallow stdin, stdout, and stderr. static bool _is_valid_ack_reply_fd(const int ack_reply_fd) { #ifdef _WIN32 const HANDLE ack_reply_handle = cast_int_to_handle(ack_reply_fd); return (GetStdHandle(STD_INPUT_HANDLE) != ack_reply_handle) && (GetStdHandle(STD_OUTPUT_HANDLE) != ack_reply_handle) && (GetStdHandle(STD_ERROR_HANDLE) != ack_reply_handle); #else return ack_reply_fd > 2; #endif } int adb_commandline(int argc, const char **argv) { int no_daemon = 0; int is_daemon = 0; int is_server = 0; int r; TransportType transport_type = kTransportAny; int ack_reply_fd = -1; #if !defined(_WIN32) // We'd rather have EPIPE than SIGPIPE. signal(SIGPIPE, SIG_IGN); #endif // If defined, this should be an absolute path to // the directory containing all of the various system images // for a particular product. If not defined, and the adb // command requires this information, then the user must // specify the path using "-p". char* ANDROID_PRODUCT_OUT = getenv("ANDROID_PRODUCT_OUT"); if (ANDROID_PRODUCT_OUT != nullptr) { gProductOutPath = ANDROID_PRODUCT_OUT; } // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint /* Validate and assign the server port */ const char* server_port_str = getenv("ANDROID_ADB_SERVER_PORT"); int server_port = DEFAULT_ADB_PORT; if (server_port_str && strlen(server_port_str) > 0) { server_port = strtol(server_port_str, nullptr, 0); if (server_port <= 0 || server_port > 65535) { fprintf(stderr, "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number less than 65536. Got \"%s\"\n", server_port_str); return usage(); } } // We need to check for -d and -e before we look at $ANDROID_SERIAL. const char* serial = nullptr; while (argc > 0) { if (!strcmp(argv[0],"server")) { is_server = 1; } else if (!strcmp(argv[0],"nodaemon")) { no_daemon = 1; } else if (!strcmp(argv[0], "fork-server")) { /* this is a special flag used only when the ADB client launches the ADB Server */ is_daemon = 1; } else if (!strcmp(argv[0], "--reply-fd")) { if (argc < 2) return usage(); const char* reply_fd_str = argv[1]; argc--; argv++; ack_reply_fd = strtol(reply_fd_str, nullptr, 10); if (!_is_valid_ack_reply_fd(ack_reply_fd)) { fprintf(stderr, "adb: invalid reply fd \"%s\"\n", reply_fd_str); return usage(); } } else if (!strncmp(argv[0], "-p", 2)) { const char* product = nullptr; if (argv[0][2] == '\0') { if (argc < 2) return usage(); product = argv[1]; argc--; argv++; } else { product = argv[0] + 2; } gProductOutPath = find_product_out_path(product); if (gProductOutPath.empty()) { fprintf(stderr, "adb: could not resolve \"-p %s\"\n", product); return usage(); } } else if (argv[0][0]=='-' && argv[0][1]=='s') { if (isdigit(argv[0][2])) { serial = argv[0] + 2; } else { if (argc < 2 || argv[0][2] != '\0') return usage(); serial = argv[1]; argc--; argv++; } } else if (!strcmp(argv[0],"-d")) { transport_type = kTransportUsb; } else if (!strcmp(argv[0],"-e")) { transport_type = kTransportLocal; } else if (!strcmp(argv[0],"-a")) { gListenAll = 1; } else if (!strncmp(argv[0], "-H", 2)) { const char *hostname = NULL; if (argv[0][2] == '\0') { if (argc < 2) return usage(); hostname = argv[1]; argc--; argv++; } else { hostname = argv[0] + 2; } adb_set_tcp_name(hostname); } else if (!strncmp(argv[0], "-P", 2)) { if (argv[0][2] == '\0') { if (argc < 2) return usage(); server_port_str = argv[1]; argc--; argv++; } else { server_port_str = argv[0] + 2; } if (strlen(server_port_str) > 0) { server_port = (int) strtol(server_port_str, NULL, 0); if (server_port <= 0 || server_port > 65535) { fprintf(stderr, "adb: port number must be a positive number less than 65536. Got \"%s\"\n", server_port_str); return usage(); } } else { fprintf(stderr, "adb: port number must be a positive number less than 65536. Got empty string.\n"); return usage(); } } else { /* out of recognized modifiers and flags */ break; } argc--; argv++; } // If none of -d, -e, or -s were specified, try $ANDROID_SERIAL. if (transport_type == kTransportAny && serial == nullptr) { serial = getenv("ANDROID_SERIAL"); } adb_set_transport(transport_type, serial); adb_set_tcp_specifics(server_port); if (is_server) { if (no_daemon || is_daemon) { if (is_daemon && (ack_reply_fd == -1)) { fprintf(stderr, "reply fd for adb server to client communication not specified.\n"); return usage(); } r = adb_server_main(is_daemon, server_port, ack_reply_fd); } else { r = launch_server(server_port); } if (r) { fprintf(stderr,"* could not start server *\n"); } return r; } if (argc == 0) { return usage(); } /* handle wait-for-* prefix */ if (!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { const char* service = argv[0]; if (!wait_for_device(service, transport_type, serial)) { return 1; } // Allow a command to be run after wait-for-device, // e.g. 'adb wait-for-device shell'. if (argc == 1) { return 0; } /* Fall through */ argc--; argv++; } /* adb_connect() commands */ if (!strcmp(argv[0], "devices")) { const char *listopt; if (argc < 2) { listopt = ""; } else if (argc == 2 && !strcmp(argv[1], "-l")) { listopt = argv[1]; } else { fprintf(stderr, "Usage: adb devices [-l]\n"); return 1; } std::string query = android::base::StringPrintf("host:%s%s", argv[0], listopt); printf("List of devices attached\n"); return adb_query_command(query); } else if (!strcmp(argv[0], "connect")) { if (argc != 2) { fprintf(stderr, "Usage: adb connect [:]\n"); return 1; } std::string query = android::base::StringPrintf("host:connect:%s", argv[1]); return adb_query_command(query); } else if (!strcmp(argv[0], "disconnect")) { if (argc > 2) { fprintf(stderr, "Usage: adb disconnect [[:]]\n"); return 1; } std::string query = android::base::StringPrintf("host:disconnect:%s", (argc == 2) ? argv[1] : ""); return adb_query_command(query); } else if (!strcmp(argv[0], "emu")) { return adb_send_emulator_command(argc, argv, serial); } else if (!strcmp(argv[0], "shell")) { return adb_shell(argc, argv); } else if (!strcmp(argv[0], "exec-in") || !strcmp(argv[0], "exec-out")) { int exec_in = !strcmp(argv[0], "exec-in"); std::string cmd = "exec:"; cmd += argv[1]; argc -= 2; argv += 2; while (argc-- > 0) { cmd += " " + escape_arg(*argv++); } std::string error; int fd = adb_connect(cmd, &error); if (fd < 0) { fprintf(stderr, "error: %s\n", error.c_str()); return -1; } if (exec_in) { copy_to_file(STDIN_FILENO, fd); } else { copy_to_file(fd, STDOUT_FILENO); } adb_close(fd); return 0; } else if (!strcmp(argv[0], "kill-server")) { std::string error; int fd = _adb_connect("host:kill", &error); if (fd == -2) { // Failed to make network connection to server. Don't output the // network error since that is expected. fprintf(stderr,"* server not running *\n"); // Successful exit code because the server is already "killed". return 0; } else if (fd == -1) { // Some other error. fprintf(stderr, "error: %s\n", error.c_str()); return 1; } else { // Successfully connected, kill command sent, okay status came back. // Server should exit() in a moment, if not already. ReadOrderlyShutdown(fd); adb_close(fd); return 0; } } else if (!strcmp(argv[0], "sideload")) { if (argc != 2) return usage(); if (adb_sideload_host(argv[1])) { return 1; } else { return 0; } } else if (!strcmp(argv[0], "tcpip") && argc > 1) { return adb_connect_command(android::base::StringPrintf("tcpip:%s", argv[1])); } else if (!strcmp(argv[0], "remount") || !strcmp(argv[0], "reboot") || !strcmp(argv[0], "reboot-bootloader") || !strcmp(argv[0], "usb") || !strcmp(argv[0], "disable-verity") || !strcmp(argv[0], "enable-verity")) { std::string command; if (!strcmp(argv[0], "reboot-bootloader")) { command = "reboot:bootloader"; } else if (argc > 1) { command = android::base::StringPrintf("%s:%s", argv[0], argv[1]); } else { command = android::base::StringPrintf("%s:", argv[0]); } return adb_connect_command(command); } else if (!strcmp(argv[0], "root") || !strcmp(argv[0], "unroot")) { return adb_root(argv[0]) ? 0 : 1; } else if (!strcmp(argv[0], "bugreport")) { return bugreport(transport_type, serial, argc, argv); } else if (!strcmp(argv[0], "forward") || !strcmp(argv[0], "reverse")) { bool reverse = !strcmp(argv[0], "reverse"); ++argv; --argc; if (argc < 1) return usage(); // Determine the for this command. std::string host_prefix; if (reverse) { host_prefix = "reverse"; } else { if (serial) { host_prefix = android::base::StringPrintf("host-serial:%s", serial); } else if (transport_type == kTransportUsb) { host_prefix = "host-usb"; } else if (transport_type == kTransportLocal) { host_prefix = "host-local"; } else { host_prefix = "host"; } } std::string cmd; if (strcmp(argv[0], "--list") == 0) { if (argc != 1) return usage(); return adb_query_command(host_prefix + ":list-forward"); } else if (strcmp(argv[0], "--remove-all") == 0) { if (argc != 1) return usage(); cmd = host_prefix + ":killforward-all"; } else if (strcmp(argv[0], "--remove") == 0) { // forward --remove if (argc != 2) return usage(); cmd = host_prefix + ":killforward:" + argv[1]; } else if (strcmp(argv[0], "--no-rebind") == 0) { // forward --no-rebind if (argc != 3) return usage(); cmd = host_prefix + ":forward:norebind:" + argv[1] + ";" + argv[2]; } else { // forward if (argc != 2) return usage(); cmd = host_prefix + ":forward:" + argv[0] + ";" + argv[1]; } return adb_command(cmd) ? 0 : 1; } /* do_sync_*() commands */ else if (!strcmp(argv[0], "ls")) { if (argc != 2) return usage(); return do_sync_ls(argv[1]) ? 0 : 1; } else if (!strcmp(argv[0], "push")) { bool copy_attrs = false; std::vector srcs; const char* dst = nullptr; parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, ©_attrs); if (srcs.empty() || !dst) return usage(); return do_sync_push(srcs, dst) ? 0 : 1; } else if (!strcmp(argv[0], "pull")) { bool copy_attrs = false; std::vector srcs; const char* dst = "."; parse_push_pull_args(&argv[1], argc - 1, &srcs, &dst, ©_attrs); if (srcs.empty()) return usage(); return do_sync_pull(srcs, dst, copy_attrs) ? 0 : 1; } else if (!strcmp(argv[0], "install")) { if (argc < 2) return usage(); FeatureSet features; std::string error; if (!adb_get_feature_set(&features, &error)) { fprintf(stderr, "error: %s\n", error.c_str()); return 1; } if (CanUseFeature(features, kFeatureCmd)) { return install_app(transport_type, serial, argc, argv); } return install_app_legacy(transport_type, serial, argc, argv); } else if (!strcmp(argv[0], "install-multiple")) { if (argc < 2) return usage(); return install_multiple_app(transport_type, serial, argc, argv); } else if (!strcmp(argv[0], "uninstall")) { if (argc < 2) return usage(); FeatureSet features; std::string error; if (!adb_get_feature_set(&features, &error)) { fprintf(stderr, "error: %s\n", error.c_str()); return 1; } if (CanUseFeature(features, kFeatureCmd)) { return uninstall_app(transport_type, serial, argc, argv); } return uninstall_app_legacy(transport_type, serial, argc, argv); } else if (!strcmp(argv[0], "sync")) { std::string src; bool list_only = false; if (argc < 2) { // No local path was specified. src = ""; } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { list_only = true; if (argc == 3) { src = argv[2]; } else { src = ""; } } else if (argc == 2) { // A local path or "android"/"data" arg was specified. src = argv[1]; } else { return usage(); } if (src != "" && src != "system" && src != "data" && src != "vendor" && src != "oem") { return usage(); } std::string system_src_path = product_file("system"); std::string data_src_path = product_file("data"); std::string vendor_src_path = product_file("vendor"); std::string oem_src_path = product_file("oem"); bool okay = true; if (okay && (src.empty() || src == "system")) { okay = do_sync_sync(system_src_path, "/system", list_only); } if (okay && (src.empty() || src == "vendor") && directory_exists(vendor_src_path)) { okay = do_sync_sync(vendor_src_path, "/vendor", list_only); } if (okay && (src.empty() || src == "oem") && directory_exists(oem_src_path)) { okay = do_sync_sync(oem_src_path, "/oem", list_only); } if (okay && (src.empty() || src == "data")) { okay = do_sync_sync(data_src_path, "/data", list_only); } return okay ? 0 : 1; } /* passthrough commands */ else if (!strcmp(argv[0],"get-state") || !strcmp(argv[0],"get-serialno") || !strcmp(argv[0],"get-devpath")) { return adb_query_command(format_host_command(argv[0], transport_type, serial)); } /* other commands */ else if (!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) { return logcat(transport_type, serial, argc, argv); } else if (!strcmp(argv[0],"ppp")) { return ppp(argc, argv); } else if (!strcmp(argv[0], "start-server")) { std::string error; const int result = adb_connect("host:start-server", &error); if (result < 0) { fprintf(stderr, "error: %s\n", error.c_str()); } return result; } else if (!strcmp(argv[0], "backup")) { return backup(argc, argv); } else if (!strcmp(argv[0], "restore")) { return restore(argc, argv); } else if (!strcmp(argv[0], "keygen")) { if (argc < 2) return usage(); // Always print key generation information for keygen command. adb_trace_enable(AUTH); return adb_auth_keygen(argv[1]); } else if (!strcmp(argv[0], "jdwp")) { return adb_connect_command("jdwp"); } /* "adb /?" is a common idiom under Windows */ else if (!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) { help(); return 0; } else if (!strcmp(argv[0], "version")) { fprintf(stdout, "%s", adb_version().c_str()); return 0; } else if (!strcmp(argv[0], "features")) { // Only list the features common to both the adb client and the device. FeatureSet features; std::string error; if (!adb_get_feature_set(&features, &error)) { fprintf(stderr, "error: %s\n", error.c_str()); return 1; } for (const std::string& name : features) { if (CanUseFeature(features, name)) { printf("%s\n", name.c_str()); } } return 0; } else if (!strcmp(argv[0], "reconnect")) { if (argc == 1) { return adb_query_command("host:reconnect"); } else if (argc == 2 && !strcmp(argv[1], "device")) { std::string err; adb_connect("reconnect", &err); return 0; } } usage(); return 1; } static int uninstall_app(TransportType transport, const char* serial, int argc, const char** argv) { // 'adb uninstall' takes the same arguments as 'cmd package uninstall' on device std::string cmd = "cmd package"; while (argc-- > 0) { // deny the '-k' option until the remaining data/cache can be removed with adb/UI if (strcmp(*argv, "-k") == 0) { printf( "The -k option uninstalls the application while retaining the data/cache.\n" "At the moment, there is no way to remove the remaining data.\n" "You will have to reinstall the application with the same signature, and fully uninstall it.\n" "If you truly wish to continue, execute 'adb shell cmd package uninstall -k'.\n"); return EXIT_FAILURE; } cmd += " " + escape_arg(*argv++); } return send_shell_command(transport, serial, cmd, false); } static int install_app(TransportType transport, const char* serial, int argc, const char** argv) { // The last argument must be the APK file const char* file = argv[argc - 1]; const char* dot = strrchr(file, '.'); bool found_apk = false; struct stat sb; if (dot && !strcasecmp(dot, ".apk")) { if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { fprintf(stderr, "Invalid APK file: %s\n", file); return EXIT_FAILURE; } found_apk = true; } if (!found_apk) { fprintf(stderr, "Missing APK file\n"); return EXIT_FAILURE; } int localFd = adb_open(file, O_RDONLY); if (localFd < 0) { fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); return 1; } std::string error; std::string cmd = "exec:cmd package"; // don't copy the APK name, but, copy the rest of the arguments as-is while (argc-- > 1) { cmd += " " + escape_arg(std::string(*argv++)); } // add size parameter [required for streaming installs] // do last to override any user specified value cmd += " " + android::base::StringPrintf("-S %" PRIu64, static_cast(sb.st_size)); int remoteFd = adb_connect(cmd, &error); if (remoteFd < 0) { fprintf(stderr, "Connect error for write: %s\n", error.c_str()); adb_close(localFd); return 1; } char buf[BUFSIZ]; copy_to_file(localFd, remoteFd); read_status_line(remoteFd, buf, sizeof(buf)); adb_close(localFd); adb_close(remoteFd); if (strncmp("Success", buf, 7)) { fprintf(stderr, "Failed to install %s: %s", file, buf); return 1; } fputs(buf, stderr); return 0; } static int install_multiple_app(TransportType transport, const char* serial, int argc, const char** argv) { int i; struct stat sb; uint64_t total_size = 0; // Find all APK arguments starting at end. // All other arguments passed through verbatim. int first_apk = -1; for (i = argc - 1; i >= 0; i--) { const char* file = argv[i]; const char* dot = strrchr(file, '.'); if (dot && !strcasecmp(dot, ".apk")) { if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { fprintf(stderr, "Invalid APK file: %s\n", file); return EXIT_FAILURE; } total_size += sb.st_size; first_apk = i; } else { break; } } if (first_apk == -1) { fprintf(stderr, "Missing APK file\n"); return 1; } std::string cmd = android::base::StringPrintf("exec:pm install-create -S %" PRIu64, total_size); for (i = 1; i < first_apk; i++) { cmd += " " + escape_arg(argv[i]); } // Create install session std::string error; int fd = adb_connect(cmd, &error); if (fd < 0) { fprintf(stderr, "Connect error for create: %s\n", error.c_str()); return EXIT_FAILURE; } char buf[BUFSIZ]; read_status_line(fd, buf, sizeof(buf)); adb_close(fd); int session_id = -1; if (!strncmp("Success", buf, 7)) { char* start = strrchr(buf, '['); char* end = strrchr(buf, ']'); if (start && end) { *end = '\0'; session_id = strtol(start + 1, NULL, 10); } } if (session_id < 0) { fprintf(stderr, "Failed to create session\n"); fputs(buf, stderr); return EXIT_FAILURE; } // Valid session, now stream the APKs int success = 1; for (i = first_apk; i < argc; i++) { const char* file = argv[i]; if (stat(file, &sb) == -1) { fprintf(stderr, "Failed to stat %s\n", file); success = 0; goto finalize_session; } std::string cmd = android::base::StringPrintf( "exec:pm install-write -S %" PRIu64 " %d %d_%s -", static_cast(sb.st_size), session_id, i, adb_basename(file).c_str()); int localFd = adb_open(file, O_RDONLY); if (localFd < 0) { fprintf(stderr, "Failed to open %s: %s\n", file, strerror(errno)); success = 0; goto finalize_session; } std::string error; int remoteFd = adb_connect(cmd, &error); if (remoteFd < 0) { fprintf(stderr, "Connect error for write: %s\n", error.c_str()); adb_close(localFd); success = 0; goto finalize_session; } copy_to_file(localFd, remoteFd); read_status_line(remoteFd, buf, sizeof(buf)); adb_close(localFd); adb_close(remoteFd); if (strncmp("Success", buf, 7)) { fprintf(stderr, "Failed to write %s\n", file); fputs(buf, stderr); success = 0; goto finalize_session; } } finalize_session: // Commit session if we streamed everything okay; otherwise abandon std::string service = android::base::StringPrintf("exec:pm install-%s %d", success ? "commit" : "abandon", session_id); fd = adb_connect(service, &error); if (fd < 0) { fprintf(stderr, "Connect error for finalize: %s\n", error.c_str()); return EXIT_FAILURE; } read_status_line(fd, buf, sizeof(buf)); adb_close(fd); if (!strncmp("Success", buf, 7)) { fputs(buf, stderr); return 0; } else { fprintf(stderr, "Failed to finalize session\n"); fputs(buf, stderr); return EXIT_FAILURE; } } static int pm_command(TransportType transport, const char* serial, int argc, const char** argv) { std::string cmd = "pm"; while (argc-- > 0) { cmd += " " + escape_arg(*argv++); } return send_shell_command(transport, serial, cmd, false); } static int uninstall_app_legacy(TransportType transport, const char* serial, int argc, const char** argv) { /* if the user choose the -k option, we refuse to do it until devices are out with the option to uninstall the remaining data somehow (adb/ui) */ int i; for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-k")) { printf( "The -k option uninstalls the application while retaining the data/cache.\n" "At the moment, there is no way to remove the remaining data.\n" "You will have to reinstall the application with the same signature, and fully uninstall it.\n" "If you truly wish to continue, execute 'adb shell pm uninstall -k'\n."); return EXIT_FAILURE; } } /* 'adb uninstall' takes the same arguments as 'pm uninstall' on device */ return pm_command(transport, serial, argc, argv); } static int delete_file(TransportType transport, const char* serial, const std::string& filename) { std::string cmd = "rm -f " + escape_arg(filename); return send_shell_command(transport, serial, cmd, false); } static int install_app_legacy(TransportType transport, const char* serial, int argc, const char** argv) { static const char *const DATA_DEST = "/data/local/tmp/%s"; static const char *const SD_DEST = "/sdcard/tmp/%s"; const char* where = DATA_DEST; int i; struct stat sb; for (i = 1; i < argc; i++) { if (!strcmp(argv[i], "-s")) { where = SD_DEST; } } // Find last APK argument. // All other arguments passed through verbatim. int last_apk = -1; for (i = argc - 1; i >= 0; i--) { const char* file = argv[i]; const char* dot = strrchr(file, '.'); if (dot && !strcasecmp(dot, ".apk")) { if (stat(file, &sb) == -1 || !S_ISREG(sb.st_mode)) { fprintf(stderr, "Invalid APK file: %s\n", file); return EXIT_FAILURE; } last_apk = i; break; } } if (last_apk == -1) { fprintf(stderr, "Missing APK file\n"); return EXIT_FAILURE; } int result = -1; std::vector apk_file = {argv[last_apk]}; std::string apk_dest = android::base::StringPrintf( where, adb_basename(argv[last_apk]).c_str()); if (!do_sync_push(apk_file, apk_dest.c_str())) goto cleanup_apk; argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */ result = pm_command(transport, serial, argc, argv); cleanup_apk: delete_file(transport, serial, apk_dest); return result; } adb/console.cpp0100644 0000000 0000000 00000011750 12767234553 012523 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "sysdeps.h" #include #include #include #include #include #include "adb.h" #include "adb_client.h" #include "adb_io.h" #include "adb_utils.h" // Return the console authentication command for the emulator, if needed static std::string adb_construct_auth_command() { static const char auth_token_filename[] = ".emulator_console_auth_token"; std::string auth_token_path = adb_get_homedir_path(false); auth_token_path += OS_PATH_SEPARATOR; auth_token_path += auth_token_filename; // read the token std::string token; if (!android::base::ReadFileToString(auth_token_path, &token) || token.empty()) { // we either can't read the file, or it doesn't exist, or it's empty - // either way we won't add any authentication command. return {}; } // now construct and return the actual command: "auth \n" std::string command = "auth "; command += token; command += '\n'; return command; } // Return the console port of the currently connected emulator (if any) or -1 if // there is no emulator, and -2 if there is more than one. static int adb_get_emulator_console_port(const char* serial) { if (serial) { // The user specified a serial number; is it an emulator? int port; return (sscanf(serial, "emulator-%d", &port) == 1) ? port : -1; } // No specific device was given, so get the list of connected devices and // search for emulators. If there's one, we'll take it. If there are more // than one, that's an error. std::string devices; std::string error; if (!adb_query("host:devices", &devices, &error)) { fprintf(stderr, "error: no emulator connected: %s\n", error.c_str()); return -1; } int port; size_t emulator_count = 0; for (const auto& device : android::base::Split(devices, "\n")) { if (sscanf(device.c_str(), "emulator-%d", &port) == 1) { if (++emulator_count > 1) { fprintf( stderr, "error: more than one emulator detected; use -s\n"); return -1; } } } if (emulator_count == 0) { fprintf(stderr, "error: no emulator detected\n"); return -1; } return port; } static int connect_to_console(const char* serial) { int port = adb_get_emulator_console_port(serial); if (port == -1) { return -1; } std::string error; int fd = network_loopback_client(port, SOCK_STREAM, &error); if (fd == -1) { fprintf(stderr, "error: could not connect to TCP port %d: %s\n", port, error.c_str()); return -1; } return fd; } int adb_send_emulator_command(int argc, const char** argv, const char* serial) { int fd = connect_to_console(serial); if (fd == -1) { return 1; } std::string commands = adb_construct_auth_command(); for (int i = 1; i < argc; i++) { commands.append(argv[i]); commands.push_back(i == argc - 1 ? '\n' : ' '); } commands.append("quit\n"); if (!WriteFdExactly(fd, commands)) { fprintf(stderr, "error: cannot write to emulator: %s\n", strerror(errno)); adb_close(fd); return 1; } // Drain output that the emulator console has sent us to prevent a problem // on Windows where if adb closes the socket without reading all the data, // the emulator's next call to recv() will have an ECONNABORTED error, // preventing the emulator from reading the command that adb has sent. // https://code.google.com/p/android/issues/detail?id=21021 int result; do { char buf[BUFSIZ]; result = adb_read(fd, buf, sizeof(buf)); // Keep reading until zero bytes (orderly/graceful shutdown) or an // error. If 'adb emu kill' is executed, the emulator calls exit() with // the socket open (and shutdown(SD_SEND) was not called), which causes // Windows to send a TCP RST segment which causes adb to get ECONNRESET. // Any other emu command is followed by the quit command that we // appended above, and that causes the emulator to close the socket // which should cause zero bytes (orderly/graceful shutdown) to be // returned. } while (result > 0); adb_close(fd); return 0; } adb/daemon/0040755 0000000 0000000 00000000000 12767234553 011617 5ustar000000000 0000000 adb/daemon/main.cpp0100644 0000000 0000000 00000020152 12767234553 013244 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG ADB #include "sysdeps.h" #include #include #include #include #include #include #include #include #include #include #include "cutils/properties.h" #include "private/android_filesystem_config.h" #include "selinux/android.h" #include "adb.h" #include "adb_auth.h" #include "adb_listeners.h" #include "adb_utils.h" #include "transport.h" static const char* root_seclabel = nullptr; static void drop_capabilities_bounding_set_if_needed() { #ifdef ALLOW_ADBD_ROOT char value[PROPERTY_VALUE_MAX]; property_get("ro.debuggable", value, ""); if (strcmp(value, "1") == 0) { return; } #endif for (int i = 0; prctl(PR_CAPBSET_READ, i, 0, 0, 0) >= 0; i++) { if (i == CAP_SETUID || i == CAP_SETGID) { // CAP_SETUID CAP_SETGID needed by /system/bin/run-as continue; } if (prctl(PR_CAPBSET_DROP, i, 0, 0, 0) == -1) { PLOG(FATAL) << "Could not drop capabilities"; } } } static bool should_drop_privileges() { #if defined(ALLOW_ADBD_ROOT) char value[PROPERTY_VALUE_MAX]; // The properties that affect `adb root` and `adb unroot` are ro.secure and // ro.debuggable. In this context the names don't make the expected behavior // particularly obvious. // // ro.debuggable: // Allowed to become root, but not necessarily the default. Set to 1 on // eng and userdebug builds. // // ro.secure: // Drop privileges by default. Set to 1 on userdebug and user builds. property_get("ro.secure", value, "1"); bool ro_secure = (strcmp(value, "1") == 0); property_get("ro.debuggable", value, ""); bool ro_debuggable = (strcmp(value, "1") == 0); // Drop privileges if ro.secure is set... bool drop = ro_secure; property_get("service.adb.root", value, ""); bool adb_root = (strcmp(value, "1") == 0); bool adb_unroot = (strcmp(value, "0") == 0); // ... except "adb root" lets you keep privileges in a debuggable build. if (ro_debuggable && adb_root) { drop = false; } // ... and "adb unroot" lets you explicitly drop privileges. if (adb_unroot) { drop = true; } return drop; #else return true; // "adb root" not allowed, always drop privileges. #endif // ALLOW_ADBD_ROOT } static void drop_privileges(int server_port) { std::unique_ptr jail(minijail_new(), &minijail_destroy); // Add extra groups: // AID_ADB to access the USB driver // AID_LOG to read system logs (adb logcat) // AID_INPUT to diagnose input issues (getevent) // AID_INET to diagnose network issues (ping) // AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump) // AID_SDCARD_R to allow reading from the SD card // AID_SDCARD_RW to allow writing to the SD card // AID_NET_BW_STATS to read out qtaguid statistics // AID_READPROC for reading /proc entries across UID boundaries gid_t groups[] = {AID_ADB, AID_LOG, AID_INPUT, AID_INET, AID_NET_BT, AID_NET_BT_ADMIN, AID_SDCARD_R, AID_SDCARD_RW, AID_NET_BW_STATS, AID_READPROC}; minijail_set_supplementary_gids(jail.get(), sizeof(groups) / sizeof(groups[0]), groups); // Don't listen on a port (default 5037) if running in secure mode. // Don't run as root if running in secure mode. if (should_drop_privileges()) { drop_capabilities_bounding_set_if_needed(); minijail_change_gid(jail.get(), AID_SHELL); minijail_change_uid(jail.get(), AID_SHELL); // minijail_enter() will abort if any priv-dropping step fails. minijail_enter(jail.get()); D("Local port disabled"); } else { // minijail_enter() will abort if any priv-dropping step fails. minijail_enter(jail.get()); if (root_seclabel != nullptr) { if (selinux_android_setcon(root_seclabel) < 0) { LOG(FATAL) << "Could not set SELinux context"; } } std::string error; std::string local_name = android::base::StringPrintf("tcp:%d", server_port); if (install_listener(local_name, "*smartsocket*", nullptr, 0, &error)) { LOG(FATAL) << "Could not install *smartsocket* listener: " << error; } } } int adbd_main(int server_port) { umask(0); signal(SIGPIPE, SIG_IGN); init_transport_registration(); // We need to call this even if auth isn't enabled because the file // descriptor will always be open. adbd_cloexec_auth_socket(); if (ALLOW_ADBD_NO_AUTH && property_get_bool("ro.adb.secure", 0) == 0) { auth_required = false; } adbd_auth_init(); // Our external storage path may be different than apps, since // we aren't able to bind mount after dropping root. const char* adb_external_storage = getenv("ADB_EXTERNAL_STORAGE"); if (adb_external_storage != nullptr) { setenv("EXTERNAL_STORAGE", adb_external_storage, 1); } else { D("Warning: ADB_EXTERNAL_STORAGE is not set. Leaving EXTERNAL_STORAGE" " unchanged.\n"); } drop_privileges(server_port); bool is_usb = false; if (access(USB_ADB_PATH, F_OK) == 0 || access(USB_FFS_ADB_EP0, F_OK) == 0) { // Listen on USB. usb_init(); is_usb = true; } // If one of these properties is set, also listen on that port. // If one of the properties isn't set and we couldn't listen on usb, listen // on the default port. char prop_port[PROPERTY_VALUE_MAX]; property_get("service.adb.tcp.port", prop_port, ""); if (prop_port[0] == '\0') { property_get("persist.adb.tcp.port", prop_port, ""); } int port; if (sscanf(prop_port, "%d", &port) == 1 && port > 0) { D("using port=%d", port); // Listen on TCP port specified by service.adb.tcp.port property. local_init(port); } else if (!is_usb) { // Listen on default port. local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT); } D("adbd_main(): pre init_jdwp()"); init_jdwp(); D("adbd_main(): post init_jdwp()"); D("Event loop starting"); fdevent_loop(); return 0; } int main(int argc, char** argv) { while (true) { static struct option opts[] = { {"root_seclabel", required_argument, nullptr, 's'}, {"device_banner", required_argument, nullptr, 'b'}, {"version", no_argument, nullptr, 'v'}, }; int option_index = 0; int c = getopt_long(argc, argv, "", opts, &option_index); if (c == -1) { break; } switch (c) { case 's': root_seclabel = optarg; break; case 'b': adb_device_banner = optarg; break; case 'v': printf("Android Debug Bridge Daemon version %d.%d.%d %s\n", ADB_VERSION_MAJOR, ADB_VERSION_MINOR, ADB_SERVER_VERSION, ADB_REVISION); return 0; default: // getopt already prints "adbd: invalid option -- %c" for us. return 1; } } close_stdin(); adb_trace_init(argv); D("Handling main()"); return adbd_main(DEFAULT_ADB_PORT); } adb/diagnose_usb.cpp0100644 0000000 0000000 00000005365 12767234553 013530 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "diagnose_usb.h" #include #include #include #include #if defined(__linux__) #include #endif static const char kPermissionsHelpUrl[] = "http://developer.android.com/tools/device.html"; // Returns a message describing any potential problems we find with udev, or nullptr if we can't // find plugdev information (i.e. udev is not installed). static const char* GetUdevProblem() { #if defined(__linux__) errno = 0; group* plugdev_group = getgrnam("plugdev"); if (plugdev_group == nullptr) { if (errno != 0) { perror("failed to read plugdev group info"); } // We can't give any generally useful advice here, just let the caller print the help URL. return nullptr; } // getgroups(2) indicates that the group_member() may not check the egid so we check it // additionally just to be sure. if (group_member(plugdev_group->gr_gid) || getegid() == plugdev_group->gr_gid) { // The user is in plugdev so the problem is likely with the udev rules. return "verify udev rules"; } return "udev requires plugdev group membership"; #else return nullptr; #endif } // Short help text must be a single line, and will look something like: // no permissions (reason); see std::string UsbNoPermissionsShortHelpText() { std::string help_text = "no permissions"; const char* problem = GetUdevProblem(); if (problem != nullptr) { help_text += android::base::StringPrintf(" (%s)", problem); } return android::base::StringPrintf("%s; see [%s]", help_text.c_str(), kPermissionsHelpUrl); } // Long help text can span multiple lines and should provide more detailed information. std::string UsbNoPermissionsLongHelpText() { std::string header = "insufficient permissions for device"; const char* problem = GetUdevProblem(); if (problem != nullptr) { header += android::base::StringPrintf(": %s", problem); } return android::base::StringPrintf("%s.\nSee [%s] for more information.", header.c_str(), kPermissionsHelpUrl); } adb/diagnose_usb.h0100644 0000000 0000000 00000001727 12767234553 013173 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __DIAGNOSE_LINUX_USB_H #define __DIAGNOSE_LINUX_USB_H #include // USB permission error help text. The short version will be one line, long may be multi-line. // Returns a string message to print, or an empty string if no problems could be found. std::string UsbNoPermissionsShortHelpText(); std::string UsbNoPermissionsLongHelpText(); #endif adb/fdevent.cpp0100644 0000000 0000000 00000025706 12767234553 012522 0ustar000000000 0000000 /* http://frotznet.googlecode.com/svn/trunk/utils/fdevent.c ** ** Copyright 2006, Brian Swetland ** ** Licensed under the Apache License, Version 2.0 (the "License"); ** you may not use this file except in compliance with the License. ** You may obtain a copy of the License at ** ** http://www.apache.org/licenses/LICENSE-2.0 ** ** Unless required by applicable law or agreed to in writing, software ** distributed under the License is distributed on an "AS IS" BASIS, ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. ** See the License for the specific language governing permissions and ** limitations under the License. */ #define TRACE_TAG FDEVENT #include "sysdeps.h" #include "fdevent.h" #include #include #include #include #include #include #include #include #include #include #include "adb_io.h" #include "adb_trace.h" #include "adb_utils.h" #if !ADB_HOST // This socket is used when a subproc shell service exists. // It wakes up the fdevent_loop() and cause the correct handling // of the shell's pseudo-tty master. I.e. force close it. int SHELL_EXIT_NOTIFY_FD = -1; #endif // !ADB_HOST #define FDE_EVENTMASK 0x00ff #define FDE_STATEMASK 0xff00 #define FDE_ACTIVE 0x0100 #define FDE_PENDING 0x0200 #define FDE_CREATED 0x0400 struct PollNode { fdevent* fde; adb_pollfd pollfd; PollNode(fdevent* fde) : fde(fde) { memset(&pollfd, 0, sizeof(pollfd)); pollfd.fd = fde->fd; #if defined(__linux__) // Always enable POLLRDHUP, so the host server can take action when some clients disconnect. // Then we can avoid leaving many sockets in CLOSE_WAIT state. See http://b/23314034. pollfd.events = POLLRDHUP; #endif } }; // All operations to fdevent should happen only in the main thread. // That's why we don't need a lock for fdevent. static auto& g_poll_node_map = *new std::unordered_map(); static auto& g_pending_list = *new std::list(); static std::atomic terminate_loop(false); static bool main_thread_valid; static unsigned long main_thread_id; static void check_main_thread() { if (main_thread_valid) { CHECK_EQ(main_thread_id, adb_thread_id()); } } static void set_main_thread() { main_thread_valid = true; main_thread_id = adb_thread_id(); } static std::string dump_fde(const fdevent* fde) { std::string state; if (fde->state & FDE_ACTIVE) { state += "A"; } if (fde->state & FDE_PENDING) { state += "P"; } if (fde->state & FDE_CREATED) { state += "C"; } if (fde->state & FDE_READ) { state += "R"; } if (fde->state & FDE_WRITE) { state += "W"; } if (fde->state & FDE_ERROR) { state += "E"; } if (fde->state & FDE_DONT_CLOSE) { state += "D"; } return android::base::StringPrintf("(fdevent %d %s)", fde->fd, state.c_str()); } fdevent *fdevent_create(int fd, fd_func func, void *arg) { check_main_thread(); fdevent *fde = (fdevent*) malloc(sizeof(fdevent)); if(fde == 0) return 0; fdevent_install(fde, fd, func, arg); fde->state |= FDE_CREATED; return fde; } void fdevent_destroy(fdevent *fde) { check_main_thread(); if(fde == 0) return; if(!(fde->state & FDE_CREATED)) { LOG(FATAL) << "destroying fde not created by fdevent_create(): " << dump_fde(fde); } fdevent_remove(fde); free(fde); } void fdevent_install(fdevent* fde, int fd, fd_func func, void* arg) { check_main_thread(); CHECK_GE(fd, 0); memset(fde, 0, sizeof(fdevent)); fde->state = FDE_ACTIVE; fde->fd = fd; fde->func = func; fde->arg = arg; if (!set_file_block_mode(fd, false)) { // Here is not proper to handle the error. If it fails here, some error is // likely to be detected by poll(), then we can let the callback function // to handle it. LOG(ERROR) << "failed to set non-blocking mode for fd " << fd; } auto pair = g_poll_node_map.emplace(fde->fd, PollNode(fde)); CHECK(pair.second) << "install existing fd " << fd; D("fdevent_install %s", dump_fde(fde).c_str()); } void fdevent_remove(fdevent* fde) { check_main_thread(); D("fdevent_remove %s", dump_fde(fde).c_str()); if (fde->state & FDE_ACTIVE) { g_poll_node_map.erase(fde->fd); if (fde->state & FDE_PENDING) { g_pending_list.remove(fde); } if (!(fde->state & FDE_DONT_CLOSE)) { adb_close(fde->fd); fde->fd = -1; } fde->state = 0; fde->events = 0; } } static void fdevent_update(fdevent* fde, unsigned events) { auto it = g_poll_node_map.find(fde->fd); CHECK(it != g_poll_node_map.end()); PollNode& node = it->second; if (events & FDE_READ) { node.pollfd.events |= POLLIN; } else { node.pollfd.events &= ~POLLIN; } if (events & FDE_WRITE) { node.pollfd.events |= POLLOUT; } else { node.pollfd.events &= ~POLLOUT; } fde->state = (fde->state & FDE_STATEMASK) | events; } void fdevent_set(fdevent* fde, unsigned events) { check_main_thread(); events &= FDE_EVENTMASK; if ((fde->state & FDE_EVENTMASK) == events) { return; } CHECK(fde->state & FDE_ACTIVE); fdevent_update(fde, events); D("fdevent_set: %s, events = %u", dump_fde(fde).c_str(), events); if (fde->state & FDE_PENDING) { // If we are pending, make sure we don't signal an event that is no longer wanted. fde->events &= events; if (fde->events == 0) { g_pending_list.remove(fde); fde->state &= ~FDE_PENDING; } } } void fdevent_add(fdevent* fde, unsigned events) { check_main_thread(); fdevent_set(fde, (fde->state & FDE_EVENTMASK) | events); } void fdevent_del(fdevent* fde, unsigned events) { check_main_thread(); fdevent_set(fde, (fde->state & FDE_EVENTMASK) & ~events); } static std::string dump_pollfds(const std::vector& pollfds) { std::string result; for (const auto& pollfd : pollfds) { std::string op; if (pollfd.events & POLLIN) { op += "R"; } if (pollfd.events & POLLOUT) { op += "W"; } android::base::StringAppendF(&result, " %d(%s)", pollfd.fd, op.c_str()); } return result; } static void fdevent_process() { std::vector pollfds; for (const auto& pair : g_poll_node_map) { pollfds.push_back(pair.second.pollfd); } CHECK_GT(pollfds.size(), 0u); D("poll(), pollfds = %s", dump_pollfds(pollfds).c_str()); int ret = adb_poll(&pollfds[0], pollfds.size(), -1); if (ret == -1) { PLOG(ERROR) << "poll(), ret = " << ret; return; } for (const auto& pollfd : pollfds) { if (pollfd.revents != 0) { D("for fd %d, revents = %x", pollfd.fd, pollfd.revents); } unsigned events = 0; if (pollfd.revents & POLLIN) { events |= FDE_READ; } if (pollfd.revents & POLLOUT) { events |= FDE_WRITE; } if (pollfd.revents & (POLLERR | POLLHUP | POLLNVAL)) { // We fake a read, as the rest of the code assumes that errors will // be detected at that point. events |= FDE_READ | FDE_ERROR; } #if defined(__linux__) if (pollfd.revents & POLLRDHUP) { events |= FDE_READ | FDE_ERROR; } #endif if (events != 0) { auto it = g_poll_node_map.find(pollfd.fd); CHECK(it != g_poll_node_map.end()); fdevent* fde = it->second.fde; CHECK_EQ(fde->fd, pollfd.fd); fde->events |= events; D("%s got events %x", dump_fde(fde).c_str(), events); fde->state |= FDE_PENDING; g_pending_list.push_back(fde); } } } static void fdevent_call_fdfunc(fdevent* fde) { unsigned events = fde->events; fde->events = 0; CHECK(fde->state & FDE_PENDING); fde->state &= (~FDE_PENDING); D("fdevent_call_fdfunc %s", dump_fde(fde).c_str()); fde->func(fde->fd, events, fde->arg); } #if !ADB_HOST #include static void fdevent_subproc_event_func(int fd, unsigned ev, void* /* userdata */) { D("subproc handling on fd = %d, ev = %x", fd, ev); CHECK_GE(fd, 0); if (ev & FDE_READ) { int subproc_fd; if(!ReadFdExactly(fd, &subproc_fd, sizeof(subproc_fd))) { LOG(FATAL) << "Failed to read the subproc's fd from " << fd; } auto it = g_poll_node_map.find(subproc_fd); if (it == g_poll_node_map.end()) { D("subproc_fd %d cleared from fd_table", subproc_fd); adb_close(subproc_fd); return; } fdevent* subproc_fde = it->second.fde; if(subproc_fde->fd != subproc_fd) { // Already reallocated? LOG(FATAL) << "subproc_fd(" << subproc_fd << ") != subproc_fde->fd(" << subproc_fde->fd << ")"; return; } subproc_fde->force_eof = 1; int rcount = 0; ioctl(subproc_fd, FIONREAD, &rcount); D("subproc with fd %d has rcount=%d, err=%d", subproc_fd, rcount, errno); if (rcount != 0) { // If there is data left, it will show up in the select(). // This works because there is no other thread reading that // data when in this fd_func(). return; } D("subproc_fde %s", dump_fde(subproc_fde).c_str()); subproc_fde->events |= FDE_READ; if(subproc_fde->state & FDE_PENDING) { return; } subproc_fde->state |= FDE_PENDING; fdevent_call_fdfunc(subproc_fde); } } void fdevent_subproc_setup() { int s[2]; if(adb_socketpair(s)) { PLOG(FATAL) << "cannot create shell-exit socket-pair"; } D("fdevent_subproc: socket pair (%d, %d)", s[0], s[1]); SHELL_EXIT_NOTIFY_FD = s[0]; fdevent *fde = fdevent_create(s[1], fdevent_subproc_event_func, NULL); CHECK(fde != nullptr) << "cannot create fdevent for shell-exit handler"; fdevent_add(fde, FDE_READ); } #endif // !ADB_HOST void fdevent_loop() { set_main_thread(); #if !ADB_HOST fdevent_subproc_setup(); #endif // !ADB_HOST while (true) { if (terminate_loop) { return; } D("--- --- waiting for events"); fdevent_process(); while (!g_pending_list.empty()) { fdevent* fde = g_pending_list.front(); g_pending_list.pop_front(); fdevent_call_fdfunc(fde); } } } void fdevent_terminate_loop() { terminate_loop = true; } size_t fdevent_installed_count() { return g_poll_node_map.size(); } void fdevent_reset() { g_poll_node_map.clear(); g_pending_list.clear(); main_thread_valid = false; terminate_loop = false; } adb/fdevent.h0100644 0000000 0000000 00000004324 12767234553 012160 0ustar000000000 0000000 /* * Copyright (C) 2006 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __FDEVENT_H #define __FDEVENT_H #include #include /* for int64_t */ /* events that may be observed */ #define FDE_READ 0x0001 #define FDE_WRITE 0x0002 #define FDE_ERROR 0x0004 /* features that may be set (via the events set/add/del interface) */ #define FDE_DONT_CLOSE 0x0080 typedef void (*fd_func)(int fd, unsigned events, void *userdata); struct fdevent { fdevent *next; fdevent *prev; int fd; int force_eof; uint16_t state; uint16_t events; fd_func func; void *arg; }; /* Allocate and initialize a new fdevent object * Note: use FD_TIMER as 'fd' to create a fd-less object * (used to implement timers). */ fdevent *fdevent_create(int fd, fd_func func, void *arg); /* Uninitialize and deallocate an fdevent object that was ** created by fdevent_create() */ void fdevent_destroy(fdevent *fde); /* Initialize an fdevent object that was externally allocated */ void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg); /* Uninitialize an fdevent object that was initialized by ** fdevent_install() */ void fdevent_remove(fdevent *item); /* Change which events should cause notifications */ void fdevent_set(fdevent *fde, unsigned events); void fdevent_add(fdevent *fde, unsigned events); void fdevent_del(fdevent *fde, unsigned events); void fdevent_set_timeout(fdevent *fde, int64_t timeout_ms); /* loop forever, handling events. */ void fdevent_loop(); // The following functions are used only for tests. void fdevent_terminate_loop(); size_t fdevent_installed_count(); void fdevent_reset(); #endif adb/fdevent_test.cpp0100644 0000000 0000000 00000013140 12767234553 013546 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "fdevent.h" #include #include #include #include #include #include "adb_io.h" #include "fdevent_test.h" class FdHandler { public: FdHandler(int read_fd, int write_fd) : read_fd_(read_fd), write_fd_(write_fd) { fdevent_install(&read_fde_, read_fd_, FdEventCallback, this); fdevent_add(&read_fde_, FDE_READ); fdevent_install(&write_fde_, write_fd_, FdEventCallback, this); } ~FdHandler() { fdevent_remove(&read_fde_); fdevent_remove(&write_fde_); } private: static void FdEventCallback(int fd, unsigned events, void* userdata) { FdHandler* handler = reinterpret_cast(userdata); ASSERT_EQ(0u, (events & ~(FDE_READ | FDE_WRITE))) << "unexpected events: " << events; if (events & FDE_READ) { ASSERT_EQ(fd, handler->read_fd_); char c; ASSERT_EQ(1, adb_read(fd, &c, 1)); handler->queue_.push(c); fdevent_add(&handler->write_fde_, FDE_WRITE); } if (events & FDE_WRITE) { ASSERT_EQ(fd, handler->write_fd_); ASSERT_FALSE(handler->queue_.empty()); char c = handler->queue_.front(); handler->queue_.pop(); ASSERT_EQ(1, adb_write(fd, &c, 1)); if (handler->queue_.empty()) { fdevent_del(&handler->write_fde_, FDE_WRITE); } } } private: const int read_fd_; const int write_fd_; fdevent read_fde_; fdevent write_fde_; std::queue queue_; }; struct ThreadArg { int first_read_fd; int last_write_fd; size_t middle_pipe_count; }; TEST_F(FdeventTest, fdevent_terminate) { adb_thread_t thread; PrepareThread(); ASSERT_TRUE(adb_thread_create([](void*) { fdevent_loop(); }, nullptr, &thread)); TerminateThread(thread); } static void FdEventThreadFunc(ThreadArg* arg) { std::vector read_fds; std::vector write_fds; read_fds.push_back(arg->first_read_fd); for (size_t i = 0; i < arg->middle_pipe_count; ++i) { int fds[2]; ASSERT_EQ(0, adb_socketpair(fds)); read_fds.push_back(fds[0]); write_fds.push_back(fds[1]); } write_fds.push_back(arg->last_write_fd); std::vector> fd_handlers; for (size_t i = 0; i < read_fds.size(); ++i) { fd_handlers.push_back(std::unique_ptr(new FdHandler(read_fds[i], write_fds[i]))); } fdevent_loop(); } TEST_F(FdeventTest, smoke) { const size_t PIPE_COUNT = 10; const size_t MESSAGE_LOOP_COUNT = 100; const std::string MESSAGE = "fdevent_test"; int fd_pair1[2]; int fd_pair2[2]; ASSERT_EQ(0, adb_socketpair(fd_pair1)); ASSERT_EQ(0, adb_socketpair(fd_pair2)); adb_thread_t thread; ThreadArg thread_arg; thread_arg.first_read_fd = fd_pair1[0]; thread_arg.last_write_fd = fd_pair2[1]; thread_arg.middle_pipe_count = PIPE_COUNT; int writer = fd_pair1[1]; int reader = fd_pair2[0]; PrepareThread(); ASSERT_TRUE(adb_thread_create(reinterpret_cast(FdEventThreadFunc), &thread_arg, &thread)); for (size_t i = 0; i < MESSAGE_LOOP_COUNT; ++i) { std::string read_buffer = MESSAGE; std::string write_buffer(MESSAGE.size(), 'a'); ASSERT_TRUE(WriteFdExactly(writer, read_buffer.c_str(), read_buffer.size())); ASSERT_TRUE(ReadFdExactly(reader, &write_buffer[0], write_buffer.size())); ASSERT_EQ(read_buffer, write_buffer); } TerminateThread(thread); ASSERT_EQ(0, adb_close(writer)); ASSERT_EQ(0, adb_close(reader)); } struct InvalidFdArg { fdevent fde; unsigned expected_events; size_t* happened_event_count; }; static void InvalidFdEventCallback(int fd, unsigned events, void* userdata) { InvalidFdArg* arg = reinterpret_cast(userdata); ASSERT_EQ(arg->expected_events, events); fdevent_remove(&arg->fde); if (++*(arg->happened_event_count) == 2) { fdevent_terminate_loop(); } } static void InvalidFdThreadFunc(void*) { const int INVALID_READ_FD = std::numeric_limits::max() - 1; size_t happened_event_count = 0; InvalidFdArg read_arg; read_arg.expected_events = FDE_READ | FDE_ERROR; read_arg.happened_event_count = &happened_event_count; fdevent_install(&read_arg.fde, INVALID_READ_FD, InvalidFdEventCallback, &read_arg); fdevent_add(&read_arg.fde, FDE_READ); const int INVALID_WRITE_FD = std::numeric_limits::max(); InvalidFdArg write_arg; write_arg.expected_events = FDE_READ | FDE_ERROR; write_arg.happened_event_count = &happened_event_count; fdevent_install(&write_arg.fde, INVALID_WRITE_FD, InvalidFdEventCallback, &write_arg); fdevent_add(&write_arg.fde, FDE_WRITE); fdevent_loop(); } TEST_F(FdeventTest, invalid_fd) { adb_thread_t thread; ASSERT_TRUE(adb_thread_create(InvalidFdThreadFunc, nullptr, &thread)); ASSERT_TRUE(adb_thread_join(thread)); } adb/fdevent_test.h0100644 0000000 0000000 00000003336 12767234553 013221 0ustar000000000 0000000 /* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include "socket.h" #include "sysdeps.h" class FdeventTest : public ::testing::Test { protected: int dummy = -1; static void SetUpTestCase() { #if !defined(_WIN32) ASSERT_NE(SIG_ERR, signal(SIGPIPE, SIG_IGN)); #endif } void SetUp() override { fdevent_reset(); ASSERT_EQ(0u, fdevent_installed_count()); } // Register a dummy socket used to wake up the fdevent loop to tell it to die. void PrepareThread() { int dummy_fds[2]; if (adb_socketpair(dummy_fds) != 0) { FAIL() << "failed to create socketpair: " << strerror(errno); } asocket* dummy_socket = create_local_socket(dummy_fds[1]); if (!dummy_socket) { FAIL() << "failed to create local socket: " << strerror(errno); } dummy_socket->ready(dummy_socket); dummy = dummy_fds[0]; } void TerminateThread(adb_thread_t thread) { fdevent_terminate_loop(); ASSERT_TRUE(WriteFdExactly(dummy, "", 1)); ASSERT_TRUE(adb_thread_join(thread)); ASSERT_EQ(0, adb_close(dummy)); } }; adb/file_sync_client.cpp0100644 0000000 0000000 00000104025 12767234553 014370 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "sysdeps.h" #include "adb.h" #include "adb_client.h" #include "adb_io.h" #include "adb_utils.h" #include "file_sync_service.h" #include "line_printer.h" #include #include #include struct syncsendbuf { unsigned id; unsigned size; char data[SYNC_DATA_MAX]; }; static void ensure_trailing_separators(std::string& local_path, std::string& remote_path) { if (!adb_is_separator(local_path.back())) { local_path.push_back(OS_PATH_SEPARATOR); } if (remote_path.back() != '/') { remote_path.push_back('/'); } } static bool should_pull_file(mode_t mode) { return mode & (S_IFREG | S_IFBLK | S_IFCHR); } static bool should_push_file(mode_t mode) { mode_t mask = S_IFREG; #if !defined(_WIN32) mask |= S_IFLNK; #endif return mode & mask; } struct copyinfo { std::string lpath; std::string rpath; unsigned int time = 0; unsigned int mode; uint64_t size = 0; bool skip = false; copyinfo(const std::string& local_path, const std::string& remote_path, const std::string& name, unsigned int mode) : lpath(local_path), rpath(remote_path), mode(mode) { ensure_trailing_separators(lpath, rpath); lpath.append(name); rpath.append(name); if (S_ISDIR(mode)) { ensure_trailing_separators(lpath, rpath); } } }; class SyncConnection { public: SyncConnection() : total_bytes_(0), start_time_ms_(CurrentTimeMs()), expected_total_bytes_(0), expect_multiple_files_(false), expect_done_(false) { max = SYNC_DATA_MAX; // TODO: decide at runtime. std::string error; fd = adb_connect("sync:", &error); if (fd < 0) { Error("connect failed: %s", error.c_str()); } } ~SyncConnection() { if (!IsValid()) return; if (SendQuit()) { // We sent a quit command, so the server should be doing orderly // shutdown soon. But if we encountered an error while we were using // the connection, the server might still be sending data (before // doing orderly shutdown), in which case we won't wait for all of // the data nor the coming orderly shutdown. In the common success // case, this will wait for the server to do orderly shutdown. ReadOrderlyShutdown(fd); } adb_close(fd); line_printer_.KeepInfoLine(); } bool IsValid() { return fd >= 0; } bool ReceivedError(const char* from, const char* to) { adb_pollfd pfd = {.fd = fd, .events = POLLIN}; int rc = adb_poll(&pfd, 1, 0); if (rc < 0) { Error("failed to poll: %s", strerror(errno)); return true; } return rc != 0; } bool SendRequest(int id, const char* path_and_mode) { size_t path_length = strlen(path_and_mode); if (path_length > 1024) { Error("SendRequest failed: path too long: %zu", path_length); errno = ENAMETOOLONG; return false; } // Sending header and payload in a single write makes a noticeable // difference to "adb sync" performance. std::vector buf(sizeof(SyncRequest) + path_length); SyncRequest* req = reinterpret_cast(&buf[0]); req->id = id; req->path_length = path_length; char* data = reinterpret_cast(req + 1); memcpy(data, path_and_mode, path_length); return WriteFdExactly(fd, &buf[0], buf.size()); } // Sending header, payload, and footer in a single write makes a huge // difference to "adb sync" performance. bool SendSmallFile(const char* path_and_mode, const char* lpath, const char* rpath, unsigned mtime, const char* data, size_t data_length) { size_t path_length = strlen(path_and_mode); if (path_length > 1024) { Error("SendSmallFile failed: path too long: %zu", path_length); errno = ENAMETOOLONG; return false; } std::vector buf(sizeof(SyncRequest) + path_length + sizeof(SyncRequest) + data_length + sizeof(SyncRequest)); char* p = &buf[0]; SyncRequest* req_send = reinterpret_cast(p); req_send->id = ID_SEND; req_send->path_length = path_length; p += sizeof(SyncRequest); memcpy(p, path_and_mode, path_length); p += path_length; SyncRequest* req_data = reinterpret_cast(p); req_data->id = ID_DATA; req_data->path_length = data_length; p += sizeof(SyncRequest); memcpy(p, data, data_length); p += data_length; SyncRequest* req_done = reinterpret_cast(p); req_done->id = ID_DONE; req_done->path_length = mtime; p += sizeof(SyncRequest); WriteOrDie(lpath, rpath, &buf[0], (p - &buf[0])); expect_done_ = true; total_bytes_ += data_length; ReportProgress(rpath, data_length, data_length); return true; } bool SendLargeFile(const char* path_and_mode, const char* lpath, const char* rpath, unsigned mtime) { if (!SendRequest(ID_SEND, path_and_mode)) { Error("failed to send ID_SEND message '%s': %s", path_and_mode, strerror(errno)); return false; } struct stat st; if (stat(lpath, &st) == -1) { Error("cannot stat '%s': %s", lpath, strerror(errno)); return false; } uint64_t total_size = st.st_size; uint64_t bytes_copied = 0; int lfd = adb_open(lpath, O_RDONLY); if (lfd < 0) { Error("opening '%s' locally failed: %s", lpath, strerror(errno)); return false; } syncsendbuf sbuf; sbuf.id = ID_DATA; while (true) { int bytes_read = adb_read(lfd, sbuf.data, max); if (bytes_read == -1) { Error("reading '%s' locally failed: %s", lpath, strerror(errno)); adb_close(lfd); return false; } else if (bytes_read == 0) { break; } sbuf.size = bytes_read; WriteOrDie(lpath, rpath, &sbuf, sizeof(SyncRequest) + bytes_read); total_bytes_ += bytes_read; bytes_copied += bytes_read; // Check to see if we've received an error from the other side. if (ReceivedError(lpath, rpath)) { break; } ReportProgress(rpath, bytes_copied, total_size); } adb_close(lfd); syncmsg msg; msg.data.id = ID_DONE; msg.data.size = mtime; expect_done_ = true; return WriteOrDie(lpath, rpath, &msg.data, sizeof(msg.data)); } bool CopyDone(const char* from, const char* to) { syncmsg msg; if (!ReadFdExactly(fd, &msg.status, sizeof(msg.status))) { Error("failed to copy '%s' to '%s': couldn't read from device", from, to); return false; } if (msg.status.id == ID_OKAY) { if (expect_done_) { expect_done_ = false; return true; } else { Error("failed to copy '%s' to '%s': received premature success", from, to); return true; } } if (msg.status.id != ID_FAIL) { Error("failed to copy '%s' to '%s': unknown reason %d", from, to, msg.status.id); return false; } return ReportCopyFailure(from, to, msg); } bool ReportCopyFailure(const char* from, const char* to, const syncmsg& msg) { std::vector buf(msg.status.msglen + 1); if (!ReadFdExactly(fd, &buf[0], msg.status.msglen)) { Error("failed to copy '%s' to '%s'; failed to read reason (!): %s", from, to, strerror(errno)); return false; } buf[msg.status.msglen] = 0; Error("failed to copy '%s' to '%s': %s", from, to, &buf[0]); return false; } std::string TransferRate() { uint64_t ms = CurrentTimeMs() - start_time_ms_; if (total_bytes_ == 0 || ms == 0) return ""; double s = static_cast(ms) / 1000LL; double rate = (static_cast(total_bytes_) / s) / (1024*1024); return android::base::StringPrintf(" %.1f MB/s (%" PRId64 " bytes in %.3fs)", rate, total_bytes_, s); } void ReportProgress(const char* file, uint64_t file_copied_bytes, uint64_t file_total_bytes) { char overall_percentage_str[5] = "?"; if (expected_total_bytes_ != 0) { int overall_percentage = static_cast(total_bytes_ * 100 / expected_total_bytes_); // If we're pulling symbolic links, we'll pull the target of the link rather than // just create a local link, and that will cause us to go over 100%. if (overall_percentage <= 100) { snprintf(overall_percentage_str, sizeof(overall_percentage_str), "%d%%", overall_percentage); } } if (file_copied_bytes > file_total_bytes || file_total_bytes == 0) { // This case can happen if we're racing against something that wrote to the file // between our stat and our read, or if we're reading a magic file that lies about // its size. Just show how much we've copied. Printf("[%4s] %s: %" PRId64 "/?", overall_percentage_str, file, file_copied_bytes); } else { // If we're transferring multiple files, we want to know how far through the current // file we are, as well as the overall percentage. if (expect_multiple_files_) { int file_percentage = static_cast(file_copied_bytes * 100 / file_total_bytes); Printf("[%4s] %s: %d%%", overall_percentage_str, file, file_percentage); } else { Printf("[%4s] %s", overall_percentage_str, file); } } } void Printf(const char* fmt, ...) __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 2, 3))) { std::string s; va_list ap; va_start(ap, fmt); android::base::StringAppendV(&s, fmt, ap); va_end(ap); line_printer_.Print(s, LinePrinter::INFO); } void Error(const char* fmt, ...) __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 2, 3))) { std::string s = "adb: error: "; va_list ap; va_start(ap, fmt); android::base::StringAppendV(&s, fmt, ap); va_end(ap); line_printer_.Print(s, LinePrinter::ERROR); } void Warning(const char* fmt, ...) __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 2, 3))) { std::string s = "adb: warning: "; va_list ap; va_start(ap, fmt); android::base::StringAppendV(&s, fmt, ap); va_end(ap); line_printer_.Print(s, LinePrinter::WARNING); } void ComputeExpectedTotalBytes(const std::vector& file_list) { expected_total_bytes_ = 0; for (const copyinfo& ci : file_list) { // Unfortunately, this doesn't work for symbolic links, because we'll copy the // target of the link rather than just creating a link. (But ci.size is the link size.) if (!ci.skip) expected_total_bytes_ += ci.size; } expect_multiple_files_ = true; } void SetExpectedTotalBytes(uint64_t expected_total_bytes) { expected_total_bytes_ = expected_total_bytes; expect_multiple_files_ = false; } uint64_t total_bytes_; // TODO: add a char[max] buffer here, to replace syncsendbuf... int fd; size_t max; private: uint64_t start_time_ms_; uint64_t expected_total_bytes_; bool expect_multiple_files_; bool expect_done_; LinePrinter line_printer_; bool SendQuit() { return SendRequest(ID_QUIT, ""); // TODO: add a SendResponse? } bool WriteOrDie(const char* from, const char* to, const void* data, size_t data_length) { if (!WriteFdExactly(fd, data, data_length)) { if (errno == ECONNRESET) { // Assume adbd told us why it was closing the connection, and // try to read failure reason from adbd. syncmsg msg; if (!ReadFdExactly(fd, &msg.status, sizeof(msg.status))) { Error("failed to copy '%s' to '%s': no response: %s", from, to, strerror(errno)); } else if (msg.status.id != ID_FAIL) { Error("failed to copy '%s' to '%s': not ID_FAIL: %d", from, to, msg.status.id); } else { ReportCopyFailure(from, to, msg); } } else { Error("%zu-byte write failed: %s", data_length, strerror(errno)); } _exit(1); } return true; } static uint64_t CurrentTimeMs() { struct timeval tv; gettimeofday(&tv, 0); // (Not clock_gettime because of Mac/Windows.) return static_cast(tv.tv_sec) * 1000 + tv.tv_usec / 1000; } }; typedef void (sync_ls_cb)(unsigned mode, unsigned size, unsigned time, const char* name); static bool sync_ls(SyncConnection& sc, const char* path, std::function func) { if (!sc.SendRequest(ID_LIST, path)) return false; while (true) { syncmsg msg; if (!ReadFdExactly(sc.fd, &msg.dent, sizeof(msg.dent))) return false; if (msg.dent.id == ID_DONE) return true; if (msg.dent.id != ID_DENT) return false; size_t len = msg.dent.namelen; if (len > 256) return false; // TODO: resize buffer? continue? char buf[257]; if (!ReadFdExactly(sc.fd, buf, len)) return false; buf[len] = 0; func(msg.dent.mode, msg.dent.size, msg.dent.time, buf); } } static bool sync_finish_stat(SyncConnection& sc, unsigned int* timestamp, unsigned int* mode, unsigned int* size) { syncmsg msg; if (!ReadFdExactly(sc.fd, &msg.stat, sizeof(msg.stat)) || msg.stat.id != ID_STAT) { return false; } if (timestamp) *timestamp = msg.stat.time; if (mode) *mode = msg.stat.mode; if (size) *size = msg.stat.size; return true; } static bool sync_stat(SyncConnection& sc, const char* path, unsigned int* timestamp, unsigned int* mode, unsigned int* size) { return sc.SendRequest(ID_STAT, path) && sync_finish_stat(sc, timestamp, mode, size); } static bool sync_send(SyncConnection& sc, const char* lpath, const char* rpath, unsigned mtime, mode_t mode) { std::string path_and_mode = android::base::StringPrintf("%s,%d", rpath, mode); if (S_ISLNK(mode)) { #if !defined(_WIN32) char buf[PATH_MAX]; ssize_t data_length = readlink(lpath, buf, PATH_MAX - 1); if (data_length == -1) { sc.Error("readlink '%s' failed: %s", lpath, strerror(errno)); return false; } buf[data_length++] = '\0'; if (!sc.SendSmallFile(path_and_mode.c_str(), lpath, rpath, mtime, buf, data_length)) { return false; } return sc.CopyDone(lpath, rpath); #endif } struct stat st; if (stat(lpath, &st) == -1) { sc.Error("failed to stat local file '%s': %s", lpath, strerror(errno)); return false; } if (st.st_size < SYNC_DATA_MAX) { std::string data; if (!android::base::ReadFileToString(lpath, &data)) { sc.Error("failed to read all of '%s': %s", lpath, strerror(errno)); return false; } if (!sc.SendSmallFile(path_and_mode.c_str(), lpath, rpath, mtime, data.data(), data.size())) { return false; } } else { if (!sc.SendLargeFile(path_and_mode.c_str(), lpath, rpath, mtime)) { return false; } } return sc.CopyDone(lpath, rpath); } static bool sync_recv(SyncConnection& sc, const char* rpath, const char* lpath, const char* name=nullptr) { unsigned size = 0; if (!sync_stat(sc, rpath, nullptr, nullptr, &size)) return false; if (!sc.SendRequest(ID_RECV, rpath)) return false; adb_unlink(lpath); int lfd = adb_creat(lpath, 0644); if (lfd < 0) { sc.Error("cannot create '%s': %s", lpath, strerror(errno)); return false; } uint64_t bytes_copied = 0; while (true) { syncmsg msg; if (!ReadFdExactly(sc.fd, &msg.data, sizeof(msg.data))) { adb_close(lfd); adb_unlink(lpath); return false; } if (msg.data.id == ID_DONE) break; if (msg.data.id != ID_DATA) { adb_close(lfd); adb_unlink(lpath); sc.ReportCopyFailure(rpath, lpath, msg); return false; } if (msg.data.size > sc.max) { sc.Error("msg.data.size too large: %u (max %zu)", msg.data.size, sc.max); adb_close(lfd); adb_unlink(lpath); return false; } char buffer[SYNC_DATA_MAX]; if (!ReadFdExactly(sc.fd, buffer, msg.data.size)) { adb_close(lfd); adb_unlink(lpath); return false; } if (!WriteFdExactly(lfd, buffer, msg.data.size)) { sc.Error("cannot write '%s': %s", lpath, strerror(errno)); adb_close(lfd); adb_unlink(lpath); return false; } sc.total_bytes_ += msg.data.size; bytes_copied += msg.data.size; sc.ReportProgress(name != nullptr ? name : rpath, bytes_copied, size); } adb_close(lfd); return true; } bool do_sync_ls(const char* path) { SyncConnection sc; if (!sc.IsValid()) return false; return sync_ls(sc, path, [](unsigned mode, unsigned size, unsigned time, const char* name) { printf("%08x %08x %08x %s\n", mode, size, time, name); }); } static bool IsDotOrDotDot(const char* name) { return name[0] == '.' && (name[1] == '\0' || (name[1] == '.' && name[2] == '\0')); } static bool local_build_list(SyncConnection& sc, std::vector* file_list, const std::string& lpath, const std::string& rpath) { std::vector dirlist; std::unique_ptr dir(opendir(lpath.c_str()), closedir); if (!dir) { sc.Error("cannot open '%s': %s", lpath.c_str(), strerror(errno)); return false; } bool empty_dir = true; dirent* de; while ((de = readdir(dir.get()))) { if (IsDotOrDotDot(de->d_name)) { continue; } empty_dir = false; std::string stat_path = lpath + de->d_name; struct stat st; if (lstat(stat_path.c_str(), &st) == -1) { sc.Error("cannot lstat '%s': %s", stat_path.c_str(), strerror(errno)); continue; } copyinfo ci(lpath, rpath, de->d_name, st.st_mode); if (S_ISDIR(st.st_mode)) { dirlist.push_back(ci); } else { if (!should_push_file(st.st_mode)) { sc.Warning("skipping special file '%s' (mode = 0o%o)", lpath.c_str(), st.st_mode); ci.skip = true; } ci.time = st.st_mtime; ci.size = st.st_size; file_list->push_back(ci); } } // Close this directory and recurse. dir.reset(); // Add the current directory to the list if it was empty, to ensure that // it gets created. if (empty_dir) { // TODO(b/25566053): Make pushing empty directories work. // TODO(b/25457350): We don't preserve permissions on directories. sc.Warning("skipping empty directory '%s'", lpath.c_str()); copyinfo ci(adb_dirname(lpath), adb_dirname(rpath), adb_basename(lpath), S_IFDIR); ci.skip = true; file_list->push_back(ci); return true; } for (const copyinfo& ci : dirlist) { local_build_list(sc, file_list, ci.lpath, ci.rpath); } return true; } static bool copy_local_dir_remote(SyncConnection& sc, std::string lpath, std::string rpath, bool check_timestamps, bool list_only) { // Make sure that both directory paths end in a slash. // Both paths are known to be nonempty, so we don't need to check. ensure_trailing_separators(lpath, rpath); // Recursively build the list of files to copy. std::vector file_list; int pushed = 0; int skipped = 0; if (!local_build_list(sc, &file_list, lpath, rpath)) { return false; } if (check_timestamps) { for (const copyinfo& ci : file_list) { if (!sc.SendRequest(ID_STAT, ci.rpath.c_str())) { return false; } } for (copyinfo& ci : file_list) { unsigned int timestamp, mode, size; if (!sync_finish_stat(sc, ×tamp, &mode, &size)) { return false; } if (size == ci.size) { // For links, we cannot update the atime/mtime. if ((S_ISREG(ci.mode & mode) && timestamp == ci.time) || (S_ISLNK(ci.mode & mode) && timestamp >= ci.time)) { ci.skip = true; } } } } sc.ComputeExpectedTotalBytes(file_list); for (const copyinfo& ci : file_list) { if (!ci.skip) { if (list_only) { sc.Error("would push: %s -> %s", ci.lpath.c_str(), ci.rpath.c_str()); } else { if (!sync_send(sc, ci.lpath.c_str(), ci.rpath.c_str(), ci.time, ci.mode)) { return false; } } pushed++; } else { skipped++; } } sc.Printf("%s: %d file%s pushed. %d file%s skipped.%s", rpath.c_str(), pushed, (pushed == 1) ? "" : "s", skipped, (skipped == 1) ? "" : "s", sc.TransferRate().c_str()); return true; } bool do_sync_push(const std::vector& srcs, const char* dst) { SyncConnection sc; if (!sc.IsValid()) return false; bool success = true; unsigned dst_mode; if (!sync_stat(sc, dst, nullptr, &dst_mode, nullptr)) return false; bool dst_exists = (dst_mode != 0); bool dst_isdir = S_ISDIR(dst_mode); if (!dst_isdir) { if (srcs.size() > 1) { sc.Error("target '%s' is not a directory", dst); return false; } else { size_t dst_len = strlen(dst); // A path that ends with a slash doesn't have to be a directory if // it doesn't exist yet. if (dst[dst_len - 1] == '/' && dst_exists) { sc.Error("failed to access '%s': Not a directory", dst); return false; } } } for (const char* src_path : srcs) { const char* dst_path = dst; struct stat st; if (stat(src_path, &st) == -1) { sc.Error("cannot stat '%s': %s", src_path, strerror(errno)); success = false; continue; } if (S_ISDIR(st.st_mode)) { std::string dst_dir = dst; // If the destination path existed originally, the source directory // should be copied as a child of the destination. if (dst_exists) { if (!dst_isdir) { sc.Error("target '%s' is not a directory", dst); return false; } // dst is a POSIX path, so we don't want to use the sysdeps // helpers here. if (dst_dir.back() != '/') { dst_dir.push_back('/'); } dst_dir.append(adb_basename(src_path)); } success &= copy_local_dir_remote(sc, src_path, dst_dir.c_str(), false, false); continue; } else if (!should_push_file(st.st_mode)) { sc.Warning("skipping special file '%s' (mode = 0o%o)", src_path, st.st_mode); continue; } std::string path_holder; if (dst_isdir) { // If we're copying a local file to a remote directory, // we really want to copy to remote_dir + "/" + local_filename. path_holder = dst_path; if (path_holder.back() != '/') { path_holder.push_back('/'); } path_holder += adb_basename(src_path); dst_path = path_holder.c_str(); } sc.SetExpectedTotalBytes(st.st_size); success &= sync_send(sc, src_path, dst_path, st.st_mtime, st.st_mode); } return success; } static bool remote_symlink_isdir(SyncConnection& sc, const std::string& rpath) { unsigned mode; std::string dir_path = rpath; dir_path.push_back('/'); if (!sync_stat(sc, dir_path.c_str(), nullptr, &mode, nullptr)) { sc.Error("failed to stat remote symlink '%s'", dir_path.c_str()); return false; } return S_ISDIR(mode); } static bool remote_build_list(SyncConnection& sc, std::vector* file_list, const std::string& rpath, const std::string& lpath) { std::vector dirlist; std::vector linklist; // Add an entry for the current directory to ensure it gets created before pulling its contents. copyinfo ci(adb_dirname(lpath), adb_dirname(rpath), adb_basename(lpath), S_IFDIR); file_list->push_back(ci); // Put the files/dirs in rpath on the lists. auto callback = [&](unsigned mode, unsigned size, unsigned time, const char* name) { if (IsDotOrDotDot(name)) { return; } copyinfo ci(lpath, rpath, name, mode); if (S_ISDIR(mode)) { dirlist.push_back(ci); } else if (S_ISLNK(mode)) { linklist.push_back(ci); } else { if (!should_pull_file(ci.mode)) { sc.Warning("skipping special file '%s' (mode = 0o%o)", ci.rpath.c_str(), ci.mode); ci.skip = true; } ci.time = time; ci.size = size; file_list->push_back(ci); } }; if (!sync_ls(sc, rpath.c_str(), callback)) { return false; } // Check each symlink we found to see whether it's a file or directory. for (copyinfo& link_ci : linklist) { if (remote_symlink_isdir(sc, link_ci.rpath)) { dirlist.emplace_back(std::move(link_ci)); } else { file_list->emplace_back(std::move(link_ci)); } } // Recurse into each directory we found. while (!dirlist.empty()) { copyinfo current = dirlist.back(); dirlist.pop_back(); if (!remote_build_list(sc, file_list, current.rpath, current.lpath)) { return false; } } return true; } static int set_time_and_mode(const std::string& lpath, time_t time, unsigned int mode) { struct utimbuf times = { time, time }; int r1 = utime(lpath.c_str(), ×); /* use umask for permissions */ mode_t mask = umask(0000); umask(mask); int r2 = chmod(lpath.c_str(), mode & ~mask); return r1 ? r1 : r2; } static bool copy_remote_dir_local(SyncConnection& sc, std::string rpath, std::string lpath, bool copy_attrs) { // Make sure that both directory paths end in a slash. // Both paths are known to be nonempty, so we don't need to check. ensure_trailing_separators(lpath, rpath); // Recursively build the list of files to copy. sc.Printf("pull: building file list..."); std::vector file_list; if (!remote_build_list(sc, &file_list, rpath.c_str(), lpath.c_str())) { return false; } sc.ComputeExpectedTotalBytes(file_list); int pulled = 0; int skipped = 0; for (const copyinfo &ci : file_list) { if (!ci.skip) { if (S_ISDIR(ci.mode)) { // Entry is for an empty directory, create it and continue. // TODO(b/25457350): We don't preserve permissions on directories. if (!mkdirs(ci.lpath)) { sc.Error("failed to create directory '%s': %s", ci.lpath.c_str(), strerror(errno)); return false; } pulled++; continue; } if (!sync_recv(sc, ci.rpath.c_str(), ci.lpath.c_str())) { return false; } if (copy_attrs && set_time_and_mode(ci.lpath, ci.time, ci.mode)) { return false; } pulled++; } else { skipped++; } } sc.Printf("%s: %d file%s pulled. %d file%s skipped.%s", rpath.c_str(), pulled, (pulled == 1) ? "" : "s", skipped, (skipped == 1) ? "" : "s", sc.TransferRate().c_str()); return true; } bool do_sync_pull(const std::vector& srcs, const char* dst, bool copy_attrs, const char* name) { SyncConnection sc; if (!sc.IsValid()) return false; bool success = true; struct stat st; bool dst_exists = true; if (stat(dst, &st) == -1) { dst_exists = false; // If we're only pulling one path, the destination path might point to // a path that doesn't exist yet. if (srcs.size() == 1 && errno == ENOENT) { // However, its parent must exist. struct stat parent_st; if (stat(adb_dirname(dst).c_str(), &parent_st) == -1) { sc.Error("cannot create file/directory '%s': %s", dst, strerror(errno)); return false; } } else { sc.Error("failed to access '%s': %s", dst, strerror(errno)); return false; } } bool dst_isdir = dst_exists && S_ISDIR(st.st_mode); if (!dst_isdir) { if (srcs.size() > 1) { sc.Error("target '%s' is not a directory", dst); return false; } else { size_t dst_len = strlen(dst); // A path that ends with a slash doesn't have to be a directory if // it doesn't exist yet. if (adb_is_separator(dst[dst_len - 1]) && dst_exists) { sc.Error("failed to access '%s': Not a directory", dst); return false; } } } for (const char* src_path : srcs) { const char* dst_path = dst; unsigned src_mode, src_time, src_size; if (!sync_stat(sc, src_path, &src_time, &src_mode, &src_size)) { sc.Error("failed to stat remote object '%s'", src_path); return false; } if (src_mode == 0) { sc.Error("remote object '%s' does not exist", src_path); success = false; continue; } bool src_isdir = S_ISDIR(src_mode); if (S_ISLNK(src_mode)) { src_isdir = remote_symlink_isdir(sc, src_path); } if (src_isdir) { std::string dst_dir = dst; // If the destination path existed originally, the source directory // should be copied as a child of the destination. if (dst_exists) { if (!dst_isdir) { sc.Error("target '%s' is not a directory", dst); return false; } if (!adb_is_separator(dst_dir.back())) { dst_dir.push_back(OS_PATH_SEPARATOR); } dst_dir.append(adb_basename(src_path)); } success &= copy_remote_dir_local(sc, src_path, dst_dir.c_str(), copy_attrs); continue; } else if (!should_pull_file(src_mode)) { sc.Warning("skipping special file '%s' (mode = 0o%o)", src_path, src_mode); continue; } std::string path_holder; if (dst_isdir) { // If we're copying a remote file to a local directory, we // really want to copy to local_dir + OS_PATH_SEPARATOR + // basename(remote). path_holder = android::base::StringPrintf("%s%c%s", dst_path, OS_PATH_SEPARATOR, adb_basename(src_path).c_str()); dst_path = path_holder.c_str(); } sc.SetExpectedTotalBytes(src_size); if (!sync_recv(sc, src_path, dst_path, name)) { success = false; continue; } if (copy_attrs && set_time_and_mode(dst_path, src_time, src_mode) != 0) { success = false; continue; } } return success; } bool do_sync_sync(const std::string& lpath, const std::string& rpath, bool list_only) { SyncConnection sc; if (!sc.IsValid()) return false; return copy_local_dir_remote(sc, lpath, rpath, true, list_only); } adb/file_sync_service.cpp0100644 0000000 0000000 00000031610 12767234553 014551 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG SYNC #include "sysdeps.h" #include "file_sync_service.h" #include #include #include #include #include #include #include #include #include #include #include #include "adb.h" #include "adb_io.h" #include "adb_utils.h" #include "private/android_filesystem_config.h" #include "security_log_tags.h" #include #include static bool should_use_fs_config(const std::string& path) { // TODO: use fs_config to configure permissions on /data. return android::base::StartsWith(path, "/system/") || android::base::StartsWith(path, "/vendor/") || android::base::StartsWith(path, "/oem/"); } static bool secure_mkdirs(const std::string& path) { uid_t uid = -1; gid_t gid = -1; unsigned int mode = 0775; uint64_t cap = 0; if (path[0] != '/') return false; std::vector path_components = android::base::Split(path, "/"); std::string partial_path; for (const auto& path_component : path_components) { if (partial_path.back() != OS_PATH_SEPARATOR) partial_path += OS_PATH_SEPARATOR; partial_path += path_component; if (should_use_fs_config(partial_path)) { fs_config(partial_path.c_str(), 1, nullptr, &uid, &gid, &mode, &cap); } if (adb_mkdir(partial_path.c_str(), mode) == -1) { if (errno != EEXIST) { return false; } } else { if (chown(partial_path.c_str(), uid, gid) == -1) { return false; } // Not all filesystems support setting SELinux labels. http://b/23530370. selinux_android_restorecon(partial_path.c_str(), 0); } } return true; } static bool do_stat(int s, const char* path) { syncmsg msg; msg.stat.id = ID_STAT; struct stat st; memset(&st, 0, sizeof(st)); // TODO: add a way to report that the stat failed! lstat(path, &st); msg.stat.mode = st.st_mode; msg.stat.size = st.st_size; msg.stat.time = st.st_mtime; return WriteFdExactly(s, &msg.stat, sizeof(msg.stat)); } static bool do_list(int s, const char* path) { dirent* de; syncmsg msg; msg.dent.id = ID_DENT; std::unique_ptr d(opendir(path), closedir); if (!d) goto done; while ((de = readdir(d.get()))) { std::string filename(android::base::StringPrintf("%s/%s", path, de->d_name)); struct stat st; if (lstat(filename.c_str(), &st) == 0) { size_t d_name_length = strlen(de->d_name); msg.dent.mode = st.st_mode; msg.dent.size = st.st_size; msg.dent.time = st.st_mtime; msg.dent.namelen = d_name_length; if (!WriteFdExactly(s, &msg.dent, sizeof(msg.dent)) || !WriteFdExactly(s, de->d_name, d_name_length)) { return false; } } } done: msg.dent.id = ID_DONE; msg.dent.mode = 0; msg.dent.size = 0; msg.dent.time = 0; msg.dent.namelen = 0; return WriteFdExactly(s, &msg.dent, sizeof(msg.dent)); } // Make sure that SendFail from adb_io.cpp isn't accidentally used in this file. #pragma GCC poison SendFail static bool SendSyncFail(int fd, const std::string& reason) { D("sync: failure: %s", reason.c_str()); syncmsg msg; msg.data.id = ID_FAIL; msg.data.size = reason.size(); return WriteFdExactly(fd, &msg.data, sizeof(msg.data)) && WriteFdExactly(fd, reason); } static bool SendSyncFailErrno(int fd, const std::string& reason) { return SendSyncFail(fd, android::base::StringPrintf("%s: %s", reason.c_str(), strerror(errno))); } static bool handle_send_file(int s, const char* path, uid_t uid, gid_t gid, mode_t mode, std::vector& buffer, bool do_unlink) { syncmsg msg; unsigned int timestamp = 0; __android_log_security_bswrite(SEC_TAG_ADB_SEND_FILE, path); int fd = adb_open_mode(path, O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, mode); if (fd < 0 && errno == ENOENT) { if (!secure_mkdirs(adb_dirname(path))) { SendSyncFailErrno(s, "secure_mkdirs failed"); goto fail; } fd = adb_open_mode(path, O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC, mode); } if (fd < 0 && errno == EEXIST) { fd = adb_open_mode(path, O_WRONLY | O_CLOEXEC, mode); } if (fd < 0) { SendSyncFailErrno(s, "couldn't create file"); goto fail; } else { if (fchown(fd, uid, gid) == -1) { SendSyncFailErrno(s, "fchown failed"); goto fail; } // Not all filesystems support setting SELinux labels. http://b/23530370. selinux_android_restorecon(path, 0); // fchown clears the setuid bit - restore it if present. // Ignore the result of calling fchmod. It's not supported // by all filesystems. b/12441485 fchmod(fd, mode); } while (true) { if (!ReadFdExactly(s, &msg.data, sizeof(msg.data))) goto fail; if (msg.data.id != ID_DATA) { if (msg.data.id == ID_DONE) { timestamp = msg.data.size; break; } SendSyncFail(s, "invalid data message"); goto abort; } if (msg.data.size > buffer.size()) { // TODO: resize buffer? SendSyncFail(s, "oversize data message"); goto abort; } if (!ReadFdExactly(s, &buffer[0], msg.data.size)) goto abort; if (!WriteFdExactly(fd, &buffer[0], msg.data.size)) { SendSyncFailErrno(s, "write failed"); goto fail; } } adb_close(fd); utimbuf u; u.actime = timestamp; u.modtime = timestamp; utime(path, &u); msg.status.id = ID_OKAY; msg.status.msglen = 0; return WriteFdExactly(s, &msg.status, sizeof(msg.status)); fail: // If there's a problem on the device, we'll send an ID_FAIL message and // close the socket. Unfortunately the kernel will sometimes throw that // data away if the other end keeps writing without reading (which is // the case with old versions of adb). To maintain compatibility, keep // reading and throwing away ID_DATA packets until the other side notices // that we've reported an error. while (true) { if (!ReadFdExactly(s, &msg.data, sizeof(msg.data))) goto fail; if (msg.data.id == ID_DONE) { goto abort; } else if (msg.data.id != ID_DATA) { char id[5]; memcpy(id, &msg.data.id, sizeof(msg.data.id)); id[4] = '\0'; D("handle_send_fail received unexpected id '%s' during failure", id); goto abort; } if (msg.data.size > buffer.size()) { D("handle_send_fail received oversized packet of length '%u' during failure", msg.data.size); goto abort; } if (!ReadFdExactly(s, &buffer[0], msg.data.size)) goto abort; } abort: if (fd >= 0) adb_close(fd); if (do_unlink) adb_unlink(path); return false; } #if defined(_WIN32) extern bool handle_send_link(int s, const std::string& path, std::vector& buffer) __attribute__((error("no symlinks on Windows"))); #else static bool handle_send_link(int s, const std::string& path, std::vector& buffer) { syncmsg msg; unsigned int len; int ret; if (!ReadFdExactly(s, &msg.data, sizeof(msg.data))) return false; if (msg.data.id != ID_DATA) { SendSyncFail(s, "invalid data message: expected ID_DATA"); return false; } len = msg.data.size; if (len > buffer.size()) { // TODO: resize buffer? SendSyncFail(s, "oversize data message"); return false; } if (!ReadFdExactly(s, &buffer[0], len)) return false; ret = symlink(&buffer[0], path.c_str()); if (ret && errno == ENOENT) { if (!secure_mkdirs(adb_dirname(path))) { SendSyncFailErrno(s, "secure_mkdirs failed"); return false; } ret = symlink(&buffer[0], path.c_str()); } if (ret) { SendSyncFailErrno(s, "symlink failed"); return false; } if (!ReadFdExactly(s, &msg.data, sizeof(msg.data))) return false; if (msg.data.id == ID_DONE) { msg.status.id = ID_OKAY; msg.status.msglen = 0; if (!WriteFdExactly(s, &msg.status, sizeof(msg.status))) return false; } else { SendSyncFail(s, "invalid data message: expected ID_DONE"); return false; } return true; } #endif static bool do_send(int s, const std::string& spec, std::vector& buffer) { // 'spec' is of the form "/some/path,0755". Break it up. size_t comma = spec.find_last_of(','); if (comma == std::string::npos) { SendSyncFail(s, "missing , in ID_SEND"); return false; } std::string path = spec.substr(0, comma); errno = 0; mode_t mode = strtoul(spec.substr(comma + 1).c_str(), nullptr, 0); if (errno != 0) { SendSyncFail(s, "bad mode"); return false; } // Don't delete files before copying if they are not "regular" or symlinks. struct stat st; bool do_unlink = (lstat(path.c_str(), &st) == -1) || S_ISREG(st.st_mode) || S_ISLNK(st.st_mode); if (do_unlink) { adb_unlink(path.c_str()); } if (S_ISLNK(mode)) { return handle_send_link(s, path.c_str(), buffer); } // Copy user permission bits to "group" and "other" permissions. mode &= 0777; mode |= ((mode >> 3) & 0070); mode |= ((mode >> 3) & 0007); uid_t uid = -1; gid_t gid = -1; uint64_t cap = 0; if (should_use_fs_config(path)) { unsigned int broken_api_hack = mode; fs_config(path.c_str(), 0, nullptr, &uid, &gid, &broken_api_hack, &cap); mode = broken_api_hack; } return handle_send_file(s, path.c_str(), uid, gid, mode, buffer, do_unlink); } static bool do_recv(int s, const char* path, std::vector& buffer) { __android_log_security_bswrite(SEC_TAG_ADB_RECV_FILE, path); int fd = adb_open(path, O_RDONLY | O_CLOEXEC); if (fd < 0) { SendSyncFailErrno(s, "open failed"); return false; } syncmsg msg; msg.data.id = ID_DATA; while (true) { int r = adb_read(fd, &buffer[0], buffer.size()); if (r <= 0) { if (r == 0) break; SendSyncFailErrno(s, "read failed"); adb_close(fd); return false; } msg.data.size = r; if (!WriteFdExactly(s, &msg.data, sizeof(msg.data)) || !WriteFdExactly(s, &buffer[0], r)) { adb_close(fd); return false; } } adb_close(fd); msg.data.id = ID_DONE; msg.data.size = 0; return WriteFdExactly(s, &msg.data, sizeof(msg.data)); } static bool handle_sync_command(int fd, std::vector& buffer) { D("sync: waiting for request"); SyncRequest request; if (!ReadFdExactly(fd, &request, sizeof(request))) { SendSyncFail(fd, "command read failure"); return false; } size_t path_length = request.path_length; if (path_length > 1024) { SendSyncFail(fd, "path too long"); return false; } char name[1025]; if (!ReadFdExactly(fd, name, path_length)) { SendSyncFail(fd, "filename read failure"); return false; } name[path_length] = 0; const char* id = reinterpret_cast(&request.id); D("sync: '%.4s' '%s'", id, name); switch (request.id) { case ID_STAT: if (!do_stat(fd, name)) return false; break; case ID_LIST: if (!do_list(fd, name)) return false; break; case ID_SEND: if (!do_send(fd, name, buffer)) return false; break; case ID_RECV: if (!do_recv(fd, name, buffer)) return false; break; case ID_QUIT: return false; default: SendSyncFail(fd, android::base::StringPrintf("unknown command '%.4s' (%08x)", id, request.id)); return false; } return true; } void file_sync_service(int fd, void* cookie) { std::vector buffer(SYNC_DATA_MAX); while (handle_sync_command(fd, buffer)) { } D("sync: done"); adb_close(fd); } adb/file_sync_service.h0100644 0000000 0000000 00000004375 12767234553 014226 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _FILE_SYNC_SERVICE_H_ #define _FILE_SYNC_SERVICE_H_ #include #include #define MKID(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((d) << 24)) #define ID_STAT MKID('S','T','A','T') #define ID_LIST MKID('L','I','S','T') #define ID_SEND MKID('S','E','N','D') #define ID_RECV MKID('R','E','C','V') #define ID_DENT MKID('D','E','N','T') #define ID_DONE MKID('D','O','N','E') #define ID_DATA MKID('D','A','T','A') #define ID_OKAY MKID('O','K','A','Y') #define ID_FAIL MKID('F','A','I','L') #define ID_QUIT MKID('Q','U','I','T') struct SyncRequest { uint32_t id; // ID_STAT, et cetera. uint32_t path_length; // <= 1024 // Followed by 'path_length' bytes of path (not NUL-terminated). } __attribute__((packed)) ; union syncmsg { struct __attribute__((packed)) { uint32_t id; uint32_t mode; uint32_t size; uint32_t time; } stat; struct __attribute__((packed)) { uint32_t id; uint32_t mode; uint32_t size; uint32_t time; uint32_t namelen; } dent; struct __attribute__((packed)) { uint32_t id; uint32_t size; } data; struct __attribute__((packed)) { uint32_t id; uint32_t msglen; } status; }; void file_sync_service(int fd, void* cookie); bool do_sync_ls(const char* path); bool do_sync_push(const std::vector& srcs, const char* dst); bool do_sync_pull(const std::vector& srcs, const char* dst, bool copy_attrs, const char* name=nullptr); bool do_sync_sync(const std::string& lpath, const std::string& rpath, bool list_only); #define SYNC_DATA_MAX (64*1024) #endif adb/framebuffer_service.cpp0100644 0000000 0000000 00000012306 12767234553 015063 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include #include #include #include "sysdeps.h" #include "adb.h" #include "adb_io.h" #include "fdevent.h" /* TODO: ** - sync with vsync to avoid tearing */ /* This version number defines the format of the fbinfo struct. It must match versioning in ddms where this data is consumed. */ #define DDMS_RAWIMAGE_VERSION 1 struct fbinfo { unsigned int version; unsigned int bpp; unsigned int size; unsigned int width; unsigned int height; unsigned int red_offset; unsigned int red_length; unsigned int blue_offset; unsigned int blue_length; unsigned int green_offset; unsigned int green_length; unsigned int alpha_offset; unsigned int alpha_length; } __attribute__((packed)); void framebuffer_service(int fd, void *cookie) { struct fbinfo fbinfo; unsigned int i, bsize; char buf[640]; int fd_screencap; int w, h, f; int fds[2]; pid_t pid; if (pipe2(fds, O_CLOEXEC) < 0) goto pipefail; pid = fork(); if (pid < 0) goto done; if (pid == 0) { dup2(fds[1], STDOUT_FILENO); adb_close(fds[0]); adb_close(fds[1]); const char* command = "screencap"; const char *args[2] = {command, NULL}; execvp(command, (char**)args); exit(1); } adb_close(fds[1]); fd_screencap = fds[0]; /* read w, h & format */ if(!ReadFdExactly(fd_screencap, &w, 4)) goto done; if(!ReadFdExactly(fd_screencap, &h, 4)) goto done; if(!ReadFdExactly(fd_screencap, &f, 4)) goto done; fbinfo.version = DDMS_RAWIMAGE_VERSION; /* see hardware/hardware.h */ switch (f) { case 1: /* RGBA_8888 */ fbinfo.bpp = 32; fbinfo.size = w * h * 4; fbinfo.width = w; fbinfo.height = h; fbinfo.red_offset = 0; fbinfo.red_length = 8; fbinfo.green_offset = 8; fbinfo.green_length = 8; fbinfo.blue_offset = 16; fbinfo.blue_length = 8; fbinfo.alpha_offset = 24; fbinfo.alpha_length = 8; break; case 2: /* RGBX_8888 */ fbinfo.bpp = 32; fbinfo.size = w * h * 4; fbinfo.width = w; fbinfo.height = h; fbinfo.red_offset = 0; fbinfo.red_length = 8; fbinfo.green_offset = 8; fbinfo.green_length = 8; fbinfo.blue_offset = 16; fbinfo.blue_length = 8; fbinfo.alpha_offset = 24; fbinfo.alpha_length = 0; break; case 3: /* RGB_888 */ fbinfo.bpp = 24; fbinfo.size = w * h * 3; fbinfo.width = w; fbinfo.height = h; fbinfo.red_offset = 0; fbinfo.red_length = 8; fbinfo.green_offset = 8; fbinfo.green_length = 8; fbinfo.blue_offset = 16; fbinfo.blue_length = 8; fbinfo.alpha_offset = 24; fbinfo.alpha_length = 0; break; case 4: /* RGB_565 */ fbinfo.bpp = 16; fbinfo.size = w * h * 2; fbinfo.width = w; fbinfo.height = h; fbinfo.red_offset = 11; fbinfo.red_length = 5; fbinfo.green_offset = 5; fbinfo.green_length = 6; fbinfo.blue_offset = 0; fbinfo.blue_length = 5; fbinfo.alpha_offset = 0; fbinfo.alpha_length = 0; break; case 5: /* BGRA_8888 */ fbinfo.bpp = 32; fbinfo.size = w * h * 4; fbinfo.width = w; fbinfo.height = h; fbinfo.red_offset = 16; fbinfo.red_length = 8; fbinfo.green_offset = 8; fbinfo.green_length = 8; fbinfo.blue_offset = 0; fbinfo.blue_length = 8; fbinfo.alpha_offset = 24; fbinfo.alpha_length = 8; break; default: goto done; } /* write header */ if(!WriteFdExactly(fd, &fbinfo, sizeof(fbinfo))) goto done; /* write data */ for(i = 0; i < fbinfo.size; i += bsize) { bsize = sizeof(buf); if (i + bsize > fbinfo.size) bsize = fbinfo.size - i; if(!ReadFdExactly(fd_screencap, buf, bsize)) goto done; if(!WriteFdExactly(fd, buf, bsize)) goto done; } done: adb_close(fds[0]); TEMP_FAILURE_RETRY(waitpid(pid, NULL, 0)); pipefail: adb_close(fd); } adb/get_my_path_darwin.cpp0100644 0000000 0000000 00000002111 12767234553 014714 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #import #include #include "adb.h" void get_my_path(char *s, size_t maxLen) { CFBundleRef mainBundle = CFBundleGetMainBundle(); CFURLRef executableURL = CFBundleCopyExecutableURL(mainBundle); CFStringRef executablePathString = CFURLCopyFileSystemPath(executableURL, kCFURLPOSIXPathStyle); CFRelease(executableURL); CFStringGetFileSystemRepresentation(executablePathString, s, maxLen); CFRelease(executablePathString); } adb/get_my_path_linux.cpp0100644 0000000 0000000 00000001724 12767234553 014600 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include "adb.h" void get_my_path(char *exe, size_t maxLen) { char proc[64]; snprintf(proc, sizeof proc, "/proc/%d/exe", getpid()); int err = readlink(proc, exe, maxLen - 1); if(err > 0) { exe[err] = '\0'; } else { exe[0] = '\0'; } } adb/jdwp_service.cpp0100644 0000000 0000000 00000050150 12767234553 013542 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ /* implement the "debug-ports" and "track-debug-ports" device services */ #define TRACE_TAG JDWP #include "sysdeps.h" #include #include #include #include #include #include "adb.h" #include "adb_utils.h" /* here's how these things work. when adbd starts, it creates a unix server socket named @vm-debug-control (@ is a shortcut for "first byte is zero" to use the private namespace instead of the file system) when a new JDWP daemon thread starts in a new VM process, it creates a connection to @vm-debug-control to announce its availability. JDWP thread @vm-debug-control | | |-------------------------------> | | hello I'm in process | | | | | the connection is kept alive. it will be closed automatically if the JDWP process terminates (this allows adbd to detect dead processes). adbd thus maintains a list of "active" JDWP processes. it can send its content to clients through the "device:debug-ports" service, or even updates through the "device:track-debug-ports" service. when a debugger wants to connect, it simply runs the command equivalent to "adb forward tcp: jdwp:" "jdwp:" is a new forward destination format used to target a given JDWP process on the device. when sutch a request arrives, adbd does the following: - first, it calls socketpair() to create a pair of equivalent sockets. - it attaches the first socket in the pair to a local socket which is itself attached to the transport's remote socket: - it sends the file descriptor of the second socket directly to the JDWP process with the help of sendmsg() JDWP thread @vm-debug-control | | | <----------------------| | OK, try this file descriptor | | | | | then, the JDWP thread uses this new socket descriptor as its pass-through connection to the debugger (and receives the JDWP-Handshake message, answers to it, etc...) this gives the following graphics: ____________________________________ | | | ADB Server (host) | | | Debugger <---> LocalSocket <----> RemoteSocket | | ^^ | |___________________________||_______| || Transport || (TCP for emulator - USB for device) || || ___________________________||_______ | || | | ADBD (device) || | | VV | JDWP <======> LocalSocket <----> RemoteSocket | | | |____________________________________| due to the way adb works, this doesn't need a special socket type or fancy handling of socket termination if either the debugger or the JDWP process closes the connection. THIS IS THE SIMPLEST IMPLEMENTATION I COULD FIND, IF YOU HAPPEN TO HAVE A BETTER IDEA, LET ME KNOW - Digit **********************************************************************/ /** JDWP PID List Support Code ** for each JDWP process, we record its pid and its connected socket **/ #define MAX_OUT_FDS 4 #if !ADB_HOST #include #include struct JdwpProcess { JdwpProcess* next; JdwpProcess* prev; int pid; int socket; fdevent* fde; char in_buff[4]; /* input character to read PID */ int in_len; /* number from JDWP process */ int out_fds[MAX_OUT_FDS]; /* output array of file descriptors */ int out_count; /* to send to the JDWP process */ }; static JdwpProcess _jdwp_list; static int jdwp_process_list( char* buffer, int bufferlen ) { char* end = buffer + bufferlen; char* p = buffer; JdwpProcess* proc = _jdwp_list.next; for ( ; proc != &_jdwp_list; proc = proc->next ) { int len; /* skip transient connections */ if (proc->pid < 0) continue; len = snprintf(p, end-p, "%d\n", proc->pid); if (p + len >= end) break; p += len; } p[0] = 0; return (p - buffer); } static int jdwp_process_list_msg( char* buffer, int bufferlen ) { char head[5]; int len = jdwp_process_list( buffer+4, bufferlen-4 ); snprintf(head, sizeof head, "%04x", len); memcpy(buffer, head, 4); return len + 4; } static void jdwp_process_list_updated(void); static void jdwp_process_free( JdwpProcess* proc ) { if (proc) { int n; proc->prev->next = proc->next; proc->next->prev = proc->prev; if (proc->socket >= 0) { adb_shutdown(proc->socket); adb_close(proc->socket); proc->socket = -1; } if (proc->fde != NULL) { fdevent_destroy(proc->fde); proc->fde = NULL; } proc->pid = -1; for (n = 0; n < proc->out_count; n++) { adb_close(proc->out_fds[n]); } proc->out_count = 0; free(proc); jdwp_process_list_updated(); } } static void jdwp_process_event(int, unsigned, void*); /* forward */ static JdwpProcess* jdwp_process_alloc( int socket ) { JdwpProcess* proc = reinterpret_cast( calloc(1, sizeof(*proc))); if (proc == NULL) { D("not enough memory to create new JDWP process"); return NULL; } proc->socket = socket; proc->pid = -1; proc->next = proc; proc->prev = proc; proc->fde = fdevent_create( socket, jdwp_process_event, proc ); if (proc->fde == NULL) { D("could not create fdevent for new JDWP process" ); free(proc); return NULL; } proc->fde->state |= FDE_DONT_CLOSE; proc->in_len = 0; proc->out_count = 0; /* append to list */ proc->next = &_jdwp_list; proc->prev = proc->next->prev; proc->prev->next = proc; proc->next->prev = proc; /* start by waiting for the PID */ fdevent_add(proc->fde, FDE_READ); return proc; } static void jdwp_process_event( int socket, unsigned events, void* _proc ) { JdwpProcess* proc = reinterpret_cast(_proc); if (events & FDE_READ) { if (proc->pid < 0) { /* read the PID as a 4-hexchar string */ char* p = proc->in_buff + proc->in_len; int size = 4 - proc->in_len; char temp[5]; while (size > 0) { int len = recv( socket, p, size, 0 ); if (len < 0) { if (errno == EINTR) continue; if (errno == EAGAIN) return; /* this can fail here if the JDWP process crashes very fast */ D("weird unknown JDWP process failure: %s", strerror(errno)); goto CloseProcess; } if (len == 0) { /* end of stream ? */ D("weird end-of-stream from unknown JDWP process"); goto CloseProcess; } p += len; proc->in_len += len; size -= len; } /* we have read 4 characters, now decode the pid */ memcpy(temp, proc->in_buff, 4); temp[4] = 0; if (sscanf( temp, "%04x", &proc->pid ) != 1) { D("could not decode JDWP %p PID number: '%s'", proc, temp); goto CloseProcess; } /* all is well, keep reading to detect connection closure */ D("Adding pid %d to jdwp process list", proc->pid); jdwp_process_list_updated(); } else { /* the pid was read, if we get there it's probably because the connection * was closed (e.g. the JDWP process exited or crashed) */ char buf[32]; for (;;) { int len = recv(socket, buf, sizeof(buf), 0); if (len <= 0) { if (len < 0 && errno == EINTR) continue; if (len < 0 && errno == EAGAIN) return; else { D("terminating JDWP %d connection: %s", proc->pid, strerror(errno)); break; } } else { D( "ignoring unexpected JDWP %d control socket activity (%d bytes)", proc->pid, len ); } } CloseProcess: if (proc->pid >= 0) { D( "remove pid %d to jdwp process list", proc->pid ); } jdwp_process_free(proc); return; } } if (events & FDE_WRITE) { D("trying to write to JDWP pid controli (count=%d first=%d) %d", proc->pid, proc->out_count, proc->out_fds[0]); if (proc->out_count > 0) { int fd = proc->out_fds[0]; int n, ret; struct cmsghdr* cmsg; struct msghdr msg; struct iovec iov; char dummy = '!'; char buffer[sizeof(struct cmsghdr) + sizeof(int)]; iov.iov_base = &dummy; iov.iov_len = 1; msg.msg_name = NULL; msg.msg_namelen = 0; msg.msg_iov = &iov; msg.msg_iovlen = 1; msg.msg_flags = 0; msg.msg_control = buffer; msg.msg_controllen = sizeof(buffer); cmsg = CMSG_FIRSTHDR(&msg); cmsg->cmsg_len = msg.msg_controllen; cmsg->cmsg_level = SOL_SOCKET; cmsg->cmsg_type = SCM_RIGHTS; ((int*)CMSG_DATA(cmsg))[0] = fd; if (!set_file_block_mode(proc->socket, true)) { VLOG(JDWP) << "failed to set blocking mode for fd " << proc->socket; goto CloseProcess; } for (;;) { ret = sendmsg(proc->socket, &msg, 0); if (ret >= 0) { adb_close(fd); break; } if (errno == EINTR) continue; D("sending new file descriptor to JDWP %d failed: %s", proc->pid, strerror(errno)); goto CloseProcess; } D("sent file descriptor %d to JDWP process %d", fd, proc->pid); for (n = 1; n < proc->out_count; n++) proc->out_fds[n-1] = proc->out_fds[n]; if (!set_file_block_mode(proc->socket, false)) { VLOG(JDWP) << "failed to set non-blocking mode for fd " << proc->socket; goto CloseProcess; } if (--proc->out_count == 0) fdevent_del( proc->fde, FDE_WRITE ); } } } int create_jdwp_connection_fd(int pid) { JdwpProcess* proc = _jdwp_list.next; D("looking for pid %d in JDWP process list", pid); for ( ; proc != &_jdwp_list; proc = proc->next ) { if (proc->pid == pid) { goto FoundIt; } } D("search failed !!"); return -1; FoundIt: { int fds[2]; if (proc->out_count >= MAX_OUT_FDS) { D("%s: too many pending JDWP connection for pid %d", __FUNCTION__, pid); return -1; } if (adb_socketpair(fds) < 0) { D("%s: socket pair creation failed: %s", __FUNCTION__, strerror(errno)); return -1; } D("socketpair: (%d,%d)", fds[0], fds[1]); proc->out_fds[ proc->out_count ] = fds[1]; if (++proc->out_count == 1) fdevent_add( proc->fde, FDE_WRITE ); return fds[0]; } } /** VM DEBUG CONTROL SOCKET ** ** we do implement a custom asocket to receive the data **/ /* name of the debug control Unix socket */ #define JDWP_CONTROL_NAME "\0jdwp-control" #define JDWP_CONTROL_NAME_LEN (sizeof(JDWP_CONTROL_NAME)-1) struct JdwpControl { int listen_socket; fdevent* fde; }; static void jdwp_control_event(int s, unsigned events, void* user); static int jdwp_control_init( JdwpControl* control, const char* sockname, int socknamelen ) { sockaddr_un addr; socklen_t addrlen; int s; int maxpath = sizeof(addr.sun_path); int pathlen = socknamelen; if (pathlen >= maxpath) { D( "vm debug control socket name too long (%d extra chars)", pathlen+1-maxpath ); return -1; } memset(&addr, 0, sizeof(addr)); addr.sun_family = AF_UNIX; memcpy(addr.sun_path, sockname, socknamelen); s = socket( AF_UNIX, SOCK_STREAM, 0 ); if (s < 0) { D( "could not create vm debug control socket. %d: %s", errno, strerror(errno)); return -1; } addrlen = (pathlen + sizeof(addr.sun_family)); if (bind(s, reinterpret_cast(&addr), addrlen) < 0) { D( "could not bind vm debug control socket: %d: %s", errno, strerror(errno) ); adb_close(s); return -1; } if ( listen(s, 4) < 0 ) { D("listen failed in jdwp control socket: %d: %s", errno, strerror(errno)); adb_close(s); return -1; } control->listen_socket = s; control->fde = fdevent_create(s, jdwp_control_event, control); if (control->fde == NULL) { D( "could not create fdevent for jdwp control socket" ); adb_close(s); return -1; } /* only wait for incoming connections */ fdevent_add(control->fde, FDE_READ); close_on_exec(s); D("jdwp control socket started (%d)", control->listen_socket); return 0; } static void jdwp_control_event( int s, unsigned events, void* _control ) { JdwpControl* control = (JdwpControl*) _control; if (events & FDE_READ) { sockaddr_storage ss; sockaddr* addrp = reinterpret_cast(&ss); socklen_t addrlen = sizeof(ss); int s = -1; JdwpProcess* proc; do { s = adb_socket_accept(control->listen_socket, addrp, &addrlen); if (s < 0) { if (errno == EINTR) continue; if (errno == ECONNABORTED) { /* oops, the JDWP process died really quick */ D("oops, the JDWP process died really quick"); return; } /* the socket is probably closed ? */ D( "weird accept() failed on jdwp control socket: %s", strerror(errno) ); return; } } while (s < 0); proc = jdwp_process_alloc( s ); if (proc == NULL) return; } } static JdwpControl _jdwp_control; /** "jdwp" local service implementation ** this simply returns the list of known JDWP process pids **/ struct JdwpSocket { asocket socket; int pass; }; static void jdwp_socket_close( asocket* s ) { asocket* peer = s->peer; remove_socket(s); if (peer) { peer->peer = NULL; peer->close(peer); } free(s); } static int jdwp_socket_enqueue( asocket* s, apacket* p ) { /* you can't write to this asocket */ put_apacket(p); s->peer->close(s->peer); return -1; } static void jdwp_socket_ready( asocket* s ) { JdwpSocket* jdwp = (JdwpSocket*)s; asocket* peer = jdwp->socket.peer; /* on the first call, send the list of pids, * on the second one, close the connection */ if (jdwp->pass == 0) { apacket* p = get_apacket(); p->len = jdwp_process_list((char*)p->data, s->get_max_payload()); peer->enqueue(peer, p); jdwp->pass = 1; } else { peer->close(peer); } } asocket* create_jdwp_service_socket( void ) { JdwpSocket* s = reinterpret_cast(calloc(sizeof(*s), 1)); if (s == NULL) return NULL; install_local_socket(&s->socket); s->socket.ready = jdwp_socket_ready; s->socket.enqueue = jdwp_socket_enqueue; s->socket.close = jdwp_socket_close; s->pass = 0; return &s->socket; } /** "track-jdwp" local service implementation ** this periodically sends the list of known JDWP process pids ** to the client... **/ struct JdwpTracker { asocket socket; JdwpTracker* next; JdwpTracker* prev; int need_update; }; static JdwpTracker _jdwp_trackers_list; static void jdwp_process_list_updated(void) { char buffer[1024]; int len; JdwpTracker* t = _jdwp_trackers_list.next; len = jdwp_process_list_msg(buffer, sizeof(buffer)); for ( ; t != &_jdwp_trackers_list; t = t->next ) { apacket* p = get_apacket(); asocket* peer = t->socket.peer; memcpy(p->data, buffer, len); p->len = len; peer->enqueue( peer, p ); } } static void jdwp_tracker_close( asocket* s ) { JdwpTracker* tracker = (JdwpTracker*) s; asocket* peer = s->peer; if (peer) { peer->peer = NULL; peer->close(peer); } remove_socket(s); tracker->prev->next = tracker->next; tracker->next->prev = tracker->prev; free(s); } static void jdwp_tracker_ready( asocket* s ) { JdwpTracker* t = (JdwpTracker*) s; if (t->need_update) { apacket* p = get_apacket(); t->need_update = 0; p->len = jdwp_process_list_msg((char*)p->data, s->get_max_payload()); s->peer->enqueue(s->peer, p); } } static int jdwp_tracker_enqueue( asocket* s, apacket* p ) { /* you can't write to this socket */ put_apacket(p); s->peer->close(s->peer); return -1; } asocket* create_jdwp_tracker_service_socket( void ) { JdwpTracker* t = reinterpret_cast(calloc(sizeof(*t), 1)); if (t == NULL) return NULL; t->next = &_jdwp_trackers_list; t->prev = t->next->prev; t->next->prev = t; t->prev->next = t; install_local_socket(&t->socket); t->socket.ready = jdwp_tracker_ready; t->socket.enqueue = jdwp_tracker_enqueue; t->socket.close = jdwp_tracker_close; t->need_update = 1; return &t->socket; } int init_jdwp(void) { _jdwp_list.next = &_jdwp_list; _jdwp_list.prev = &_jdwp_list; _jdwp_trackers_list.next = &_jdwp_trackers_list; _jdwp_trackers_list.prev = &_jdwp_trackers_list; return jdwp_control_init( &_jdwp_control, JDWP_CONTROL_NAME, JDWP_CONTROL_NAME_LEN ); } #endif /* !ADB_HOST */ adb/line_printer.cpp0100644 0000000 0000000 00000010200 12767234553 013540 0ustar000000000 0000000 // Copyright 2013 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #include "line_printer.h" #include #include #ifdef _WIN32 #include #else #include #include #include #include #endif // Make sure printf is really adb_printf which works for UTF-8 on Windows. #include // Stuff from ninja's util.h that's needed below. #include using namespace std; string ElideMiddle(const string& str, size_t width) { const int kMargin = 3; // Space for "...". string result = str; if (result.size() + kMargin > width) { size_t elide_size = (width - kMargin) / 2; result = result.substr(0, elide_size) + "..." + result.substr(result.size() - elide_size, elide_size); } return result; } LinePrinter::LinePrinter() : have_blank_line_(true) { #ifndef _WIN32 const char* term = getenv("TERM"); smart_terminal_ = unix_isatty(1) && term && string(term) != "dumb"; #else // Disable output buffer. It'd be nice to use line buffering but // MSDN says: "For some systems, [_IOLBF] provides line // buffering. However, for Win32, the behavior is the same as _IOFBF // - Full Buffering." setvbuf(stdout, NULL, _IONBF, 0); console_ = GetStdHandle(STD_OUTPUT_HANDLE); CONSOLE_SCREEN_BUFFER_INFO csbi; smart_terminal_ = GetConsoleScreenBufferInfo(console_, &csbi); #endif } static void Out(const std::string& s) { // Avoid printf and C strings, since the actual output might contain null // bytes like UTF-16 does (yuck). fwrite(s.data(), 1, s.size(), stdout); } void LinePrinter::Print(string to_print, LineType type) { if (!smart_terminal_) { Out(to_print + "\n"); return; } // Print over previous line, if any. // On Windows, calling a C library function writing to stdout also handles // pausing the executable when the "Pause" key or Ctrl-S is pressed. printf("\r"); if (type == INFO) { #ifdef _WIN32 CONSOLE_SCREEN_BUFFER_INFO csbi; GetConsoleScreenBufferInfo(console_, &csbi); // TODO: std::wstring to_print_wide; if (!android::base::UTF8ToWide(to_print, &to_print_wide)... // TODO: wstring ElideMiddle. to_print = ElideMiddle(to_print, static_cast(csbi.dwSize.X)); // We don't want to have the cursor spamming back and forth, so instead of // printf use WriteConsoleOutput which updates the contents of the buffer, // but doesn't move the cursor position. COORD buf_size = { csbi.dwSize.X, 1 }; COORD zero_zero = { 0, 0 }; SMALL_RECT target = { csbi.dwCursorPosition.X, csbi.dwCursorPosition.Y, static_cast(csbi.dwCursorPosition.X + csbi.dwSize.X - 1), csbi.dwCursorPosition.Y }; vector char_data(csbi.dwSize.X); for (size_t i = 0; i < static_cast(csbi.dwSize.X); ++i) { // TODO: UnicodeChar instead of AsciiChar, to_print_wide[i]. char_data[i].Char.AsciiChar = i < to_print.size() ? to_print[i] : ' '; char_data[i].Attributes = csbi.wAttributes; } // TODO: WriteConsoleOutputW. WriteConsoleOutput(console_, &char_data[0], buf_size, zero_zero, &target); #else // Limit output to width of the terminal if provided so we don't cause // line-wrapping. winsize size; if ((ioctl(0, TIOCGWINSZ, &size) == 0) && size.ws_col) { to_print = ElideMiddle(to_print, size.ws_col); } Out(to_print); printf("\x1B[K"); // Clear to end of line. fflush(stdout); #endif have_blank_line_ = false; } else { Out(to_print); Out("\n"); have_blank_line_ = true; } } void LinePrinter::KeepInfoLine() { if (!have_blank_line_) Out("\n"); } adb/line_printer.h0100644 0000000 0000000 00000002776 12767234553 013230 0ustar000000000 0000000 // Copyright 2013 Google Inc. All Rights Reserved. // // Licensed under the Apache License, Version 2.0 (the "License"); // you may not use this file except in compliance with the License. // You may obtain a copy of the License at // // http://www.apache.org/licenses/LICENSE-2.0 // // Unless required by applicable law or agreed to in writing, software // distributed under the License is distributed on an "AS IS" BASIS, // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. // See the License for the specific language governing permissions and // limitations under the License. #ifndef NINJA_LINE_PRINTER_H_ #define NINJA_LINE_PRINTER_H_ #include #include /// Prints lines of text, possibly overprinting previously printed lines /// if the terminal supports it. struct LinePrinter { LinePrinter(); bool is_smart_terminal() const { return smart_terminal_; } void set_smart_terminal(bool smart) { smart_terminal_ = smart; } enum LineType { INFO, WARNING, ERROR }; /// Outputs the given line. INFO output will be overwritten. /// WARNING and ERROR appear on a line to themselves. void Print(std::string to_print, LineType type); /// If there's an INFO line, keep it. If not, do nothing. void KeepInfoLine(); private: /// Whether we can do fancy terminal control codes. bool smart_terminal_; /// Whether the caret is at the beginning of a blank line. bool have_blank_line_; #ifdef _WIN32 void* console_; #endif }; #endif // NINJA_LINE_PRINTER_H_ adb/mutex_list.h0100644 0000000 0000000 00000000711 12767234553 012716 0ustar000000000 0000000 /* the list of mutexes used by adb */ /* #ifndef __MUTEX_LIST_H * Do not use an include-guard. This file is included once to declare the locks * and once in win32 to actually do the runtime initialization. */ #ifndef ADB_MUTEX #error ADB_MUTEX not defined when including this file #endif ADB_MUTEX(basename_lock) ADB_MUTEX(dirname_lock) ADB_MUTEX(transport_lock) #if ADB_HOST ADB_MUTEX(local_transports_lock) #endif ADB_MUTEX(usb_lock) #undef ADB_MUTEX adb/protocol.txt0100644 0000000 0000000 00000026620 12767234553 012761 0ustar000000000 0000000 --- a replacement for aproto ------------------------------------------- When it comes down to it, aproto's primary purpose is to forward various streams between the host computer and client device (in either direction). This replacement further simplifies the concept, reducing the protocol to an extremely straightforward model optimized to accomplish the forwarding of these streams and removing additional state or complexity. The host side becomes a simple comms bridge with no "UI", which will be used by either commandline or interactive tools to communicate with a device or emulator that is connected to the bridge. The protocol is designed to be straightforward and well-defined enough that if it needs to be reimplemented in another environment (Java perhaps), there should not problems ensuring perfect interoperability. The protocol discards the layering aproto has and should allow the implementation to be much more robust. --- protocol overview and basics --------------------------------------- The transport layer deals in "messages", which consist of a 24 byte header followed (optionally) by a payload. The header consists of 6 32 bit words which are sent across the wire in little endian format. struct message { unsigned command; /* command identifier constant */ unsigned arg0; /* first argument */ unsigned arg1; /* second argument */ unsigned data_length; /* length of payload (0 is allowed) */ unsigned data_crc32; /* crc32 of data payload */ unsigned magic; /* command ^ 0xffffffff */ }; Receipt of an invalid message header, corrupt message payload, or an unrecognized command MUST result in the closing of the remote connection. The protocol depends on shared state and any break in the message stream will result in state getting out of sync. The following sections describe the six defined message types in detail. Their format is COMMAND(arg0, arg1, payload) where the payload is represented by a quoted string or an empty string if none should be sent. The identifiers "local-id" and "remote-id" are always relative to the *sender* of the message, so for a receiver, the meanings are effectively reversed. --- CONNECT(version, maxdata, "system-identity-string") ---------------- The CONNECT message establishes the presence of a remote system. The version is used to ensure protocol compatibility and maxdata declares the maximum message body size that the remote system is willing to accept. Currently, version=0x01000000 and maxdata=256*1024. Older versions of adb hard-coded maxdata=4096, so CONNECT and AUTH packets sent to a device must not be larger than that because they're sent before the CONNECT from the device that tells the adb server what maxdata the device can support. Both sides send a CONNECT message when the connection between them is established. Until a CONNECT message is received no other messages may be sent. Any messages received before a CONNECT message MUST be ignored. If a CONNECT message is received with an unknown version or insufficiently large maxdata value, the connection with the other side must be closed. The system identity string should be "::" where systemtype is "bootloader", "device", or "host", serialno is some kind of unique ID (or empty), and banner is a human-readable version or identifier string. The banner is used to transmit useful properties. --- AUTH(type, 0, "data") ---------------------------------------------- The AUTH message informs the recipient that authentication is required to connect to the sender. If type is TOKEN(1), data is a random token that the recipient can sign with a private key. The recipient replies with an AUTH packet where type is SIGNATURE(2) and data is the signature. If the signature verification succeeds, the sender replies with a CONNECT packet. If the signature verification fails, the sender replies with a new AUTH packet and a new random token, so that the recipient can retry signing with a different private key. Once the recipient has tried all its private keys, it can reply with an AUTH packet where type is RSAPUBLICKEY(3) and data is the public key. If possible, an on-screen confirmation may be displayed for the user to confirm they want to install the public key on the device. --- OPEN(local-id, 0, "destination") ----------------------------------- The OPEN message informs the recipient that the sender has a stream identified by local-id that it wishes to connect to the named destination in the message payload. The local-id may not be zero. The OPEN message MUST result in either a READY message indicating that the connection has been established (and identifying the other end) or a CLOSE message, indicating failure. An OPEN message also implies a READY message sent at the same time. Common destination naming conventions include: * "tcp::" - host may be omitted to indicate localhost * "udp::" - host may be omitted to indicate localhost * "local-dgram:" * "local-stream:" * "shell" - local shell service * "upload" - service for pushing files across (like aproto's /sync) * "fs-bridge" - FUSE protocol filesystem bridge --- READY(local-id, remote-id, "") ------------------------------------- The READY message informs the recipient that the sender's stream identified by local-id is ready for write messages and that it is connected to the recipient's stream identified by remote-id. Neither the local-id nor the remote-id may be zero. A READY message containing a remote-id which does not map to an open stream on the recipient's side is ignored. The stream may have been closed while this message was in-flight. The local-id is ignored on all but the first READY message (where it is used to establish the connection). Nonetheless, the local-id MUST not change on later READY messages sent to the same stream. --- WRITE(local-id, remote-id, "data") --------------------------------- The WRITE message sends data to the recipient's stream identified by remote-id. The payload MUST be <= maxdata in length. A WRITE message containing a remote-id which does not map to an open stream on the recipient's side is ignored. The stream may have been closed while this message was in-flight. A WRITE message may not be sent until a READY message is received. Once a WRITE message is sent, an additional WRITE message may not be sent until another READY message has been received. Recipients of a WRITE message that is in violation of this requirement will CLOSE the connection. --- CLOSE(local-id, remote-id, "") ------------------------------------- The CLOSE message informs recipient that the connection between the sender's stream (local-id) and the recipient's stream (remote-id) is broken. The remote-id MUST not be zero, but the local-id MAY be zero if this CLOSE indicates a failed OPEN. A CLOSE message containing a remote-id which does not map to an open stream on the recipient's side is ignored. The stream may have already been closed by the recipient while this message was in-flight. The recipient should not respond to a CLOSE message in any way. The recipient should cancel pending WRITEs or CLOSEs, but this is not a requirement, since they will be ignored. --- SYNC(online, sequence, "") ----------------------------------------- The SYNC message is used by the io pump to make sure that stale outbound messages are discarded when the connection to the remote side is broken. It is only used internally to the bridge and never valid to send across the wire. * when the connection to the remote side goes offline, the io pump sends a SYNC(0, 0) and starts discarding all messages * when the connection to the remote side is established, the io pump sends a SYNC(1, token) and continues to discard messages * when the io pump receives a matching SYNC(1, token), it once again starts accepting messages to forward to the remote side --- message command constants ------------------------------------------ #define A_SYNC 0x434e5953 #define A_CNXN 0x4e584e43 #define A_AUTH 0x48545541 #define A_OPEN 0x4e45504f #define A_OKAY 0x59414b4f #define A_CLSE 0x45534c43 #define A_WRTE 0x45545257 --- implementation details --------------------------------------------- The core of the bridge program will use three threads. One thread will be a select/epoll loop to handle io between various inbound and outbound connections and the connection to the remote side. The remote side connection will be implemented as two threads (one for reading, one for writing) and a datagram socketpair to provide the channel between the main select/epoll thread and the remote connection threadpair. The reason for this is that for usb connections, the kernel interface on linux and osx does not allow you to do meaningful nonblocking IO. The endian swapping for the message headers will happen (as needed) in the remote connection threadpair and that the rest of the program will always treat message header values as native-endian. The bridge program will be able to have a number of mini-servers compiled in. They will be published under known names (examples "shell", "fs-bridge", etc) and upon receiving an OPEN() to such a service, the bridge program will create a stream socketpair and spawn a thread or subprocess to handle the io. --- simplified / embedded implementation ------------------------------- For limited environments, like the bootloader, it is allowable to support a smaller, fixed number of channels using pre-assigned channel ID numbers such that only one stream may be connected to a bootloader endpoint at any given time. The protocol remains unchanged, but the "embedded" version of it is less dynamic. The bootloader will support two streams. A "bootloader:debug" stream, which may be opened to get debug messages from the bootloader and a "bootloader:control", stream which will support the set of basic bootloader commands. Example command stream dialogues: "flash_kernel,2515049,........\n" "okay\n" "flash_ramdisk,5038,........\n" "fail,flash write error\n" "bogus_command......" --- future expansion --------------------------------------------------- I plan on providing either a message or a special control stream so that the client device could ask the host computer to setup inbound socket translations on the fly on behalf of the client device. The initial design does handshaking to provide flow control, with a message flow that looks like: >OPEN WRITE WRITE WRITE server: "OKAY" client: server: "FAIL" adb/remount_service.cpp0100644 0000000 0000000 00000011224 12767234553 014266 0ustar000000000 0000000 /* * Copyright (C) 2008 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG ADB #include "sysdeps.h" #include #include #include #include #include #include #include #include #include #include "adb.h" #include "adb_io.h" #include "adb_utils.h" #include "cutils/properties.h" #include "fs_mgr.h" // Returns the device used to mount a directory in /proc/mounts. static std::string find_proc_mount(const char* dir) { std::unique_ptr fp(setmntent("/proc/mounts", "r"), endmntent); if (!fp) { return ""; } mntent* e; while ((e = getmntent(fp.get())) != nullptr) { if (strcmp(dir, e->mnt_dir) == 0) { return e->mnt_fsname; } } return ""; } // Returns the device used to mount a directory in the fstab. static std::string find_fstab_mount(const char* dir) { char propbuf[PROPERTY_VALUE_MAX]; property_get("ro.hardware", propbuf, ""); std::string fstab_filename = std::string("/fstab.") + propbuf; struct fstab* fstab = fs_mgr_read_fstab(fstab_filename.c_str()); struct fstab_rec* rec = fs_mgr_get_entry_for_mount_point(fstab, dir); std::string dev = rec ? std::string(rec->blk_device) : ""; fs_mgr_free_fstab(fstab); return dev; } // The proc entry for / is full of lies, so check fstab instead. // /proc/mounts lists rootfs and /dev/root, neither of which is what we want. static std::string find_mount(const char* dir) { if (strcmp(dir, "/") == 0) { return find_fstab_mount(dir); } else { return find_proc_mount(dir); } } bool make_block_device_writable(const std::string& dev) { int fd = unix_open(dev.c_str(), O_RDONLY | O_CLOEXEC); if (fd == -1) { return false; } int OFF = 0; bool result = (ioctl(fd, BLKROSET, &OFF) != -1); unix_close(fd); return result; } static bool remount_partition(int fd, const char* dir) { if (!directory_exists(dir)) { return true; } std::string dev = find_mount(dir); if (dev.empty()) { return true; } if (!make_block_device_writable(dev)) { WriteFdFmt(fd, "remount of %s failed; couldn't make block device %s writable: %s\n", dir, dev.c_str(), strerror(errno)); return false; } if (mount(dev.c_str(), dir, "none", MS_REMOUNT, nullptr) == -1) { WriteFdFmt(fd, "remount of %s failed: %s\n", dir, strerror(errno)); return false; } return true; } void remount_service(int fd, void* cookie) { if (getuid() != 0) { WriteFdExactly(fd, "Not running as root. Try \"adb root\" first.\n"); adb_close(fd); return; } char prop_buf[PROPERTY_VALUE_MAX]; property_get("partition.system.verified", prop_buf, ""); bool system_verified = (strlen(prop_buf) > 0); property_get("partition.vendor.verified", prop_buf, ""); bool vendor_verified = (strlen(prop_buf) > 0); if (system_verified || vendor_verified) { // Allow remount but warn of likely bad effects bool both = system_verified && vendor_verified; WriteFdFmt(fd, "dm_verity is enabled on the %s%s%s partition%s.\n", system_verified ? "system" : "", both ? " and " : "", vendor_verified ? "vendor" : "", both ? "s" : ""); WriteFdExactly(fd, "Use \"adb disable-verity\" to disable verity.\n" "If you do not, remount may succeed, however, you will still " "not be able to write to these volumes.\n"); } bool success = true; property_get("ro.build.system_root_image", prop_buf, ""); bool system_root = !strcmp(prop_buf, "true"); if (system_root) { success &= remount_partition(fd, "/"); } else { success &= remount_partition(fd, "/system"); } success &= remount_partition(fd, "/vendor"); success &= remount_partition(fd, "/oem"); WriteFdExactly(fd, success ? "remount succeeded\n" : "remount failed\n"); adb_close(fd); } adb/remount_service.h0100644 0000000 0000000 00000001430 12767234553 013731 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _REMOUNT_SERVICE_H_ #define _REMOUNT_SERVICE_H_ #include bool make_block_device_writable(const std::string&); void remount_service(int, void*); #endif adb/security_log_tags.h0100644 0000000 0000000 00000002040 12767234553 014244 0ustar000000000 0000000 /* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __SECURITY_LOG_TAGS_H #define __SECURITY_LOG_TAGS_H /* TODO: Automatically generate this file from the logtags file when build * infrastructure is in place. * Defined in frameworks/base/core/java/android/auditing/SecurityLog.logtags */ #define SEC_TAG_ADB_SHELL_INTERACTIVE 210001 #define SEC_TAG_ADB_SHELL_CMD 210002 #define SEC_TAG_ADB_RECV_FILE 210003 #define SEC_TAG_ADB_SEND_FILE 210004 #endif adb/services.cpp0100644 0000000 0000000 00000045260 12767234553 012707 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG SERVICES #include "sysdeps.h" #include #include #include #include #include #ifndef _WIN32 #include #include #include #include #endif #include #include #include #include #include #if !ADB_HOST #include "cutils/android_reboot.h" #include "cutils/properties.h" #endif #include "adb.h" #include "adb_io.h" #include "adb_utils.h" #include "file_sync_service.h" #include "remount_service.h" #include "services.h" #include "shell_service.h" #include "sysdeps.h" #include "transport.h" struct stinfo { void (*func)(int fd, void *cookie); int fd; void *cookie; }; static void service_bootstrap_func(void* x) { stinfo* sti = reinterpret_cast(x); adb_thread_setname(android::base::StringPrintf("service %d", sti->fd)); sti->func(sti->fd, sti->cookie); free(sti); } #if !ADB_HOST void restart_root_service(int fd, void *cookie) { if (getuid() == 0) { WriteFdExactly(fd, "adbd is already running as root\n"); adb_close(fd); } else { char value[PROPERTY_VALUE_MAX]; property_get("ro.debuggable", value, ""); if (strcmp(value, "1") != 0) { WriteFdExactly(fd, "adbd cannot run as root in production builds\n"); adb_close(fd); return; } property_set("service.adb.root", "1"); WriteFdExactly(fd, "restarting adbd as root\n"); adb_close(fd); } } void restart_unroot_service(int fd, void *cookie) { if (getuid() != 0) { WriteFdExactly(fd, "adbd not running as root\n"); adb_close(fd); } else { property_set("service.adb.root", "0"); WriteFdExactly(fd, "restarting adbd as non root\n"); adb_close(fd); } } void restart_tcp_service(int fd, void *cookie) { int port = (int) (uintptr_t) cookie; if (port <= 0) { WriteFdFmt(fd, "invalid port %d\n", port); adb_close(fd); return; } char value[PROPERTY_VALUE_MAX]; snprintf(value, sizeof(value), "%d", port); property_set("service.adb.tcp.port", value); WriteFdFmt(fd, "restarting in TCP mode port: %d\n", port); adb_close(fd); } void restart_usb_service(int fd, void *cookie) { property_set("service.adb.tcp.port", "0"); WriteFdExactly(fd, "restarting in USB mode\n"); adb_close(fd); } static bool reboot_service_impl(int fd, const char* arg) { const char* reboot_arg = arg; bool auto_reboot = false; if (strcmp(reboot_arg, "sideload-auto-reboot") == 0) { auto_reboot = true; reboot_arg = "sideload"; } // It reboots into sideload mode by setting "--sideload" or "--sideload_auto_reboot" // in the command file. if (strcmp(reboot_arg, "sideload") == 0) { if (getuid() != 0) { WriteFdExactly(fd, "'adb root' is required for 'adb reboot sideload'.\n"); return false; } const char* const recovery_dir = "/cache/recovery"; const char* const command_file = "/cache/recovery/command"; // Ensure /cache/recovery exists. if (adb_mkdir(recovery_dir, 0770) == -1 && errno != EEXIST) { D("Failed to create directory '%s': %s", recovery_dir, strerror(errno)); return false; } bool write_status = android::base::WriteStringToFile( auto_reboot ? "--sideload_auto_reboot" : "--sideload", command_file); if (!write_status) { return false; } reboot_arg = "recovery"; } sync(); char property_val[PROPERTY_VALUE_MAX]; int ret = snprintf(property_val, sizeof(property_val), "reboot,%s", reboot_arg); if (ret >= static_cast(sizeof(property_val))) { WriteFdFmt(fd, "reboot string too long: %d\n", ret); return false; } ret = property_set(ANDROID_RB_PROPERTY, property_val); if (ret < 0) { WriteFdFmt(fd, "reboot failed: %d\n", ret); return false; } return true; } void reboot_service(int fd, void* arg) { if (reboot_service_impl(fd, static_cast(arg))) { // Don't return early. Give the reboot command time to take effect // to avoid messing up scripts which do "adb reboot && adb wait-for-device" while (true) { pause(); } } free(arg); adb_close(fd); } static void reconnect_service(int fd, void* arg) { WriteFdExactly(fd, "done"); adb_close(fd); atransport* t = static_cast(arg); kick_transport(t); } int reverse_service(const char* command) { int s[2]; if (adb_socketpair(s)) { PLOG(ERROR) << "cannot create service socket pair."; return -1; } VLOG(SERVICES) << "service socketpair: " << s[0] << ", " << s[1]; if (handle_forward_request(command, kTransportAny, nullptr, s[1]) < 0) { SendFail(s[1], "not a reverse forwarding command"); } adb_close(s[1]); return s[0]; } // Shell service string can look like: // shell[,arg1,arg2,...]:[command] static int ShellService(const std::string& args, const atransport* transport) { size_t delimiter_index = args.find(':'); if (delimiter_index == std::string::npos) { LOG(ERROR) << "No ':' found in shell service arguments: " << args; return -1; } const std::string service_args = args.substr(0, delimiter_index); const std::string command = args.substr(delimiter_index + 1); // Defaults: // PTY for interactive, raw for non-interactive. // No protocol. // $TERM set to "dumb". SubprocessType type(command.empty() ? SubprocessType::kPty : SubprocessType::kRaw); SubprocessProtocol protocol = SubprocessProtocol::kNone; std::string terminal_type = "dumb"; for (const std::string& arg : android::base::Split(service_args, ",")) { if (arg == kShellServiceArgRaw) { type = SubprocessType::kRaw; } else if (arg == kShellServiceArgPty) { type = SubprocessType::kPty; } else if (arg == kShellServiceArgShellProtocol) { protocol = SubprocessProtocol::kShell; } else if (android::base::StartsWith(arg, "TERM=")) { terminal_type = arg.substr(5); } else if (!arg.empty()) { // This is not an error to allow for future expansion. LOG(WARNING) << "Ignoring unknown shell service argument: " << arg; } } return StartSubprocess(command.c_str(), terminal_type.c_str(), type, protocol); } #endif // !ADB_HOST static int create_service_thread(void (*func)(int, void *), void *cookie) { int s[2]; if (adb_socketpair(s)) { printf("cannot create service socket pair\n"); return -1; } D("socketpair: (%d,%d)", s[0], s[1]); stinfo* sti = reinterpret_cast(malloc(sizeof(stinfo))); if (sti == nullptr) { fatal("cannot allocate stinfo"); } sti->func = func; sti->cookie = cookie; sti->fd = s[1]; if (!adb_thread_create(service_bootstrap_func, sti)) { free(sti); adb_close(s[0]); adb_close(s[1]); printf("cannot create service thread\n"); return -1; } D("service thread started, %d:%d",s[0], s[1]); return s[0]; } int service_to_fd(const char* name, const atransport* transport) { int ret = -1; if(!strncmp(name, "tcp:", 4)) { int port = atoi(name + 4); name = strchr(name + 4, ':'); if(name == 0) { std::string error; ret = network_loopback_client(port, SOCK_STREAM, &error); if (ret >= 0) disable_tcp_nagle(ret); } else { #if ADB_HOST std::string error; ret = network_connect(name + 1, port, SOCK_STREAM, 0, &error); #else return -1; #endif } #if !defined(_WIN32) /* winsock doesn't implement unix domain sockets */ } else if(!strncmp(name, "local:", 6)) { ret = socket_local_client(name + 6, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM); } else if(!strncmp(name, "localreserved:", 14)) { ret = socket_local_client(name + 14, ANDROID_SOCKET_NAMESPACE_RESERVED, SOCK_STREAM); } else if(!strncmp(name, "localabstract:", 14)) { ret = socket_local_client(name + 14, ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM); } else if(!strncmp(name, "localfilesystem:", 16)) { ret = socket_local_client(name + 16, ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM); #endif #if !ADB_HOST } else if(!strncmp("dev:", name, 4)) { ret = unix_open(name + 4, O_RDWR | O_CLOEXEC); } else if(!strncmp(name, "framebuffer:", 12)) { ret = create_service_thread(framebuffer_service, 0); } else if (!strncmp(name, "jdwp:", 5)) { ret = create_jdwp_connection_fd(atoi(name+5)); } else if(!strncmp(name, "shell", 5)) { ret = ShellService(name + 5, transport); } else if(!strncmp(name, "exec:", 5)) { ret = StartSubprocess(name + 5, nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone); } else if(!strncmp(name, "sync:", 5)) { ret = create_service_thread(file_sync_service, NULL); } else if(!strncmp(name, "remount:", 8)) { ret = create_service_thread(remount_service, NULL); } else if(!strncmp(name, "reboot:", 7)) { void* arg = strdup(name + 7); if (arg == NULL) return -1; ret = create_service_thread(reboot_service, arg); } else if(!strncmp(name, "root:", 5)) { ret = create_service_thread(restart_root_service, NULL); } else if(!strncmp(name, "unroot:", 7)) { ret = create_service_thread(restart_unroot_service, NULL); } else if(!strncmp(name, "backup:", 7)) { ret = StartSubprocess(android::base::StringPrintf("/system/bin/bu backup %s", (name + 7)).c_str(), nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone); } else if(!strncmp(name, "restore:", 8)) { ret = StartSubprocess("/system/bin/bu restore", nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone); } else if(!strncmp(name, "tcpip:", 6)) { int port; if (sscanf(name + 6, "%d", &port) != 1) { return -1; } ret = create_service_thread(restart_tcp_service, (void *) (uintptr_t) port); } else if(!strncmp(name, "usb:", 4)) { ret = create_service_thread(restart_usb_service, NULL); } else if (!strncmp(name, "reverse:", 8)) { ret = reverse_service(name + 8); } else if(!strncmp(name, "disable-verity:", 15)) { ret = create_service_thread(set_verity_enabled_state_service, (void*)0); } else if(!strncmp(name, "enable-verity:", 15)) { ret = create_service_thread(set_verity_enabled_state_service, (void*)1); } else if (!strcmp(name, "reconnect")) { ret = create_service_thread(reconnect_service, const_cast(transport)); #endif } if (ret >= 0) { close_on_exec(ret); } return ret; } #if ADB_HOST struct state_info { TransportType transport_type; std::string serial; ConnectionState state; }; static void wait_for_state(int fd, void* data) { std::unique_ptr sinfo(reinterpret_cast(data)); D("wait_for_state %d", sinfo->state); while (true) { bool is_ambiguous = false; std::string error = "unknown error"; const char* serial = sinfo->serial.length() ? sinfo->serial.c_str() : NULL; atransport* t = acquire_one_transport(sinfo->transport_type, serial, &is_ambiguous, &error); if (t != nullptr && (sinfo->state == kCsAny || sinfo->state == t->connection_state)) { SendOkay(fd); break; } else if (!is_ambiguous) { adb_pollfd pfd = {.fd = fd, .events = POLLIN }; int rc = adb_poll(&pfd, 1, 1000); if (rc < 0) { SendFail(fd, error); break; } else if (rc > 0 && (pfd.revents & POLLHUP) != 0) { // The other end of the socket is closed, probably because the other side was // terminated, bail out. break; } // Try again... } else { SendFail(fd, error); break; } } adb_close(fd); D("wait_for_state is done"); } static void connect_device(const std::string& address, std::string* response) { if (address.empty()) { *response = "empty address"; return; } std::string serial; std::string host; int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT; if (!android::base::ParseNetAddress(address, &host, &port, &serial, response)) { return; } std::string error; int fd = network_connect(host.c_str(), port, SOCK_STREAM, 10, &error); if (fd == -1) { *response = android::base::StringPrintf("unable to connect to %s: %s", serial.c_str(), error.c_str()); return; } D("client: connected %s remote on fd %d", serial.c_str(), fd); close_on_exec(fd); disable_tcp_nagle(fd); // Send a TCP keepalive ping to the device every second so we can detect disconnects. if (!set_tcp_keepalive(fd, 1)) { D("warning: failed to configure TCP keepalives (%s)", strerror(errno)); } int ret = register_socket_transport(fd, serial.c_str(), port, 0); if (ret < 0) { adb_close(fd); *response = android::base::StringPrintf("already connected to %s", serial.c_str()); } else { *response = android::base::StringPrintf("connected to %s", serial.c_str()); } } void connect_emulator(const std::string& port_spec, std::string* response) { std::vector pieces = android::base::Split(port_spec, ","); if (pieces.size() != 2) { *response = android::base::StringPrintf("unable to parse '%s' as ,", port_spec.c_str()); return; } int console_port = strtol(pieces[0].c_str(), NULL, 0); int adb_port = strtol(pieces[1].c_str(), NULL, 0); if (console_port <= 0 || adb_port <= 0) { *response = android::base::StringPrintf("Invalid port numbers: %s", port_spec.c_str()); return; } // Check if the emulator is already known. // Note: There's a small but harmless race condition here: An emulator not // present just yet could be registered by another invocation right // after doing this check here. However, local_connect protects // against double-registration too. From here, a better error message // can be produced. In the case of the race condition, the very specific // error message won't be shown, but the data doesn't get corrupted. atransport* known_emulator = find_emulator_transport_by_adb_port(adb_port); if (known_emulator != nullptr) { *response = android::base::StringPrintf("Emulator already registered on port %d", adb_port); return; } // Check if more emulators can be registered. Similar unproblematic // race condition as above. int candidate_slot = get_available_local_transport_index(); if (candidate_slot < 0) { *response = "Cannot accept more emulators"; return; } // Preconditions met, try to connect to the emulator. std::string error; if (!local_connect_arbitrary_ports(console_port, adb_port, &error)) { *response = android::base::StringPrintf("Connected to emulator on ports %d,%d", console_port, adb_port); } else { *response = android::base::StringPrintf("Could not connect to emulator on ports %d,%d: %s", console_port, adb_port, error.c_str()); } } static void connect_service(int fd, void* data) { char* host = reinterpret_cast(data); std::string response; if (!strncmp(host, "emu:", 4)) { connect_emulator(host + 4, &response); } else { connect_device(host, &response); } free(host); // Send response for emulator and device SendProtocolString(fd, response); adb_close(fd); } #endif #if ADB_HOST asocket* host_service_to_socket(const char* name, const char* serial) { if (!strcmp(name,"track-devices")) { return create_device_tracker(); } else if (android::base::StartsWith(name, "wait-for-")) { name += strlen("wait-for-"); std::unique_ptr sinfo(new state_info); if (sinfo == nullptr) { fprintf(stderr, "couldn't allocate state_info: %s", strerror(errno)); return nullptr; } if (serial) sinfo->serial = serial; if (android::base::StartsWith(name, "local")) { name += strlen("local"); sinfo->transport_type = kTransportLocal; } else if (android::base::StartsWith(name, "usb")) { name += strlen("usb"); sinfo->transport_type = kTransportUsb; } else if (android::base::StartsWith(name, "any")) { name += strlen("any"); sinfo->transport_type = kTransportAny; } else { return nullptr; } if (!strcmp(name, "-device")) { sinfo->state = kCsDevice; } else if (!strcmp(name, "-recovery")) { sinfo->state = kCsRecovery; } else if (!strcmp(name, "-sideload")) { sinfo->state = kCsSideload; } else if (!strcmp(name, "-bootloader")) { sinfo->state = kCsBootloader; } else if (!strcmp(name, "-any")) { sinfo->state = kCsAny; } else { return nullptr; } int fd = create_service_thread(wait_for_state, sinfo.release()); return create_local_socket(fd); } else if (!strncmp(name, "connect:", 8)) { char* host = strdup(name + 8); int fd = create_service_thread(connect_service, host); return create_local_socket(fd); } return NULL; } #endif /* ADB_HOST */ adb/services.h0100644 0000000 0000000 00000001501 12767234553 012342 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef SERVICES_H_ #define SERVICES_H_ constexpr char kShellServiceArgRaw[] = "raw"; constexpr char kShellServiceArgPty[] = "pty"; constexpr char kShellServiceArgShellProtocol[] = "v2"; #endif // SERVICES_H_ adb/set_verity_enable_state_service.cpp0100644 0000000 0000000 00000010303 12767234553 017475 0ustar000000000 0000000 /* * Copyright (C) 2014 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG ADB #include "sysdeps.h" #include #include #include #include #include #include "cutils/properties.h" #include "adb.h" #include "adb_io.h" #include "fs_mgr.h" #include "remount_service.h" #include "fec/io.h" #define FSTAB_PREFIX "/fstab." struct fstab *fstab; #ifdef ALLOW_ADBD_DISABLE_VERITY static const bool kAllowDisableVerity = true; #else static const bool kAllowDisableVerity = false; #endif /* Turn verity on/off */ static int set_verity_enabled_state(int fd, const char *block_device, const char* mount_point, bool enable) { if (!make_block_device_writable(block_device)) { WriteFdFmt(fd, "Could not make block device %s writable (%s).\n", block_device, strerror(errno)); return -1; } fec::io fh(block_device, O_RDWR); if (!fh) { WriteFdFmt(fd, "Could not open block device %s (%s).\n", block_device, strerror(errno)); WriteFdFmt(fd, "Maybe run adb root?\n"); return -1; } fec_verity_metadata metadata; if (!fh.get_verity_metadata(metadata)) { WriteFdFmt(fd, "Couldn't find verity metadata!\n"); return -1; } if (!enable && metadata.disabled) { WriteFdFmt(fd, "Verity already disabled on %s\n", mount_point); return -1; } if (enable && !metadata.disabled) { WriteFdFmt(fd, "Verity already enabled on %s\n", mount_point); return -1; } if (!fh.set_verity_status(enable)) { WriteFdFmt(fd, "Could not set verity %s flag on device %s with error %s\n", enable ? "enabled" : "disabled", block_device, strerror(errno)); return -1; } WriteFdFmt(fd, "Verity %s on %s\n", enable ? "enabled" : "disabled", mount_point); return 0; } void set_verity_enabled_state_service(int fd, void* cookie) { bool enable = (cookie != NULL); if (kAllowDisableVerity) { char fstab_filename[PROPERTY_VALUE_MAX + sizeof(FSTAB_PREFIX)]; char propbuf[PROPERTY_VALUE_MAX]; int i; bool any_changed = false; property_get("ro.secure", propbuf, "0"); if (strcmp(propbuf, "1")) { WriteFdFmt(fd, "verity not enabled - ENG build\n"); goto errout; } property_get("ro.debuggable", propbuf, "0"); if (strcmp(propbuf, "1")) { WriteFdFmt(fd, "verity cannot be disabled/enabled - USER build\n"); goto errout; } property_get("ro.hardware", propbuf, ""); snprintf(fstab_filename, sizeof(fstab_filename), FSTAB_PREFIX"%s", propbuf); fstab = fs_mgr_read_fstab(fstab_filename); if (!fstab) { WriteFdFmt(fd, "Failed to open %s\nMaybe run adb root?\n", fstab_filename); goto errout; } /* Loop through entries looking for ones that vold manages */ for (i = 0; i < fstab->num_entries; i++) { if(fs_mgr_is_verified(&fstab->recs[i])) { if (!set_verity_enabled_state(fd, fstab->recs[i].blk_device, fstab->recs[i].mount_point, enable)) { any_changed = true; } } } if (any_changed) { WriteFdFmt(fd, "Now reboot your device for settings to take effect\n"); } } else { WriteFdFmt(fd, "%s-verity only works for userdebug builds\n", enable ? "enable" : "disable"); } errout: adb_close(fd); } adb/shell_service.cpp0100644 0000000 0000000 00000070552 12767234553 013715 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ // Functionality for launching and managing shell subprocesses. // // There are two types of subprocesses, PTY or raw. PTY is typically used for // an interactive session, raw for non-interactive. There are also two methods // of communication with the subprocess, passing raw data or using a simple // protocol to wrap packets. The protocol allows separating stdout/stderr and // passing the exit code back, but is not backwards compatible. // ----------------+-------------------------------------- // Type Protocol | Exit code? Separate stdout/stderr? // ----------------+-------------------------------------- // PTY No | No No // Raw No | No No // PTY Yes | Yes No // Raw Yes | Yes Yes // ----------------+-------------------------------------- // // Non-protocol subprocesses work by passing subprocess stdin/out/err through // a single pipe which is registered with a local socket in adbd. The local // socket uses the fdevent loop to pass raw data between this pipe and the // transport, which then passes data back to the adb client. Cleanup is done by // waiting in a separate thread for the subprocesses to exit and then signaling // a separate fdevent to close out the local socket from the main loop. // // ------------------+-------------------------+------------------------------ // Subprocess | adbd subprocess thread | adbd main fdevent loop // ------------------+-------------------------+------------------------------ // | | // stdin/out/err <-----------------------------> LocalSocket // | | | // | | Block on exit | // | | * | // v | * | // Exit ---> Unblock | // | | | // | v | // | Notify shell exit FD ---> Close LocalSocket // ------------------+-------------------------+------------------------------ // // The protocol requires the thread to intercept stdin/out/err in order to // wrap/unwrap data with shell protocol packets. // // ------------------+-------------------------+------------------------------ // Subprocess | adbd subprocess thread | adbd main fdevent loop // ------------------+-------------------------+------------------------------ // | | // stdin/out <---> Protocol <---> LocalSocket // stderr ---> Protocol ---> LocalSocket // | | | // v | | // Exit ---> Exit code protocol ---> LocalSocket // | | | // | v | // | Notify shell exit FD ---> Close LocalSocket // ------------------+-------------------------+------------------------------ // // An alternate approach is to put the protocol wrapping/unwrapping in the main // fdevent loop, which has the advantage of being able to re-use the existing // select() code for handling data streams. However, implementation turned out // to be more complex due to partial reads and non-blocking I/O so this model // was chosen instead. #define TRACE_TAG SHELL #include "sysdeps.h" #include "shell_service.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include "adb.h" #include "adb_io.h" #include "adb_trace.h" #include "adb_utils.h" #include "security_log_tags.h" namespace { void init_subproc_child() { setsid(); // Set OOM score adjustment to prevent killing int fd = adb_open("/proc/self/oom_score_adj", O_WRONLY | O_CLOEXEC); if (fd >= 0) { adb_write(fd, "0", 1); adb_close(fd); } else { D("adb: unable to update oom_score_adj"); } } // Reads from |fd| until close or failure. std::string ReadAll(int fd) { char buffer[512]; std::string received; while (1) { int bytes = adb_read(fd, buffer, sizeof(buffer)); if (bytes <= 0) { break; } received.append(buffer, bytes); } return received; } // Creates a socketpair and saves the endpoints to |fd1| and |fd2|. bool CreateSocketpair(ScopedFd* fd1, ScopedFd* fd2) { int sockets[2]; if (adb_socketpair(sockets) < 0) { PLOG(ERROR) << "cannot create socket pair"; return false; } fd1->Reset(sockets[0]); fd2->Reset(sockets[1]); return true; } class Subprocess { public: Subprocess(const std::string& command, const char* terminal_type, SubprocessType type, SubprocessProtocol protocol); ~Subprocess(); const std::string& command() const { return command_; } int ReleaseLocalSocket() { return local_socket_sfd_.Release(); } pid_t pid() const { return pid_; } // Sets up FDs, forks a subprocess, starts the subprocess manager thread, // and exec's the child. Returns false and sets error on failure. bool ForkAndExec(std::string* _Nonnull error); // Start the subprocess manager thread. Consumes the subprocess, regardless of success. // Returns false and sets error on failure. static bool StartThread(std::unique_ptr subprocess, std::string* _Nonnull error); private: // Opens the file at |pts_name|. int OpenPtyChildFd(const char* pts_name, ScopedFd* error_sfd); static void ThreadHandler(void* userdata); void PassDataStreams(); void WaitForExit(); ScopedFd* SelectLoop(fd_set* master_read_set_ptr, fd_set* master_write_set_ptr); // Input/output stream handlers. Success returns nullptr, failure returns // a pointer to the failed FD. ScopedFd* PassInput(); ScopedFd* PassOutput(ScopedFd* sfd, ShellProtocol::Id id); const std::string command_; const std::string terminal_type_; bool make_pty_raw_ = false; SubprocessType type_; SubprocessProtocol protocol_; pid_t pid_ = -1; ScopedFd local_socket_sfd_; // Shell protocol variables. ScopedFd stdinout_sfd_, stderr_sfd_, protocol_sfd_; std::unique_ptr input_, output_; size_t input_bytes_left_ = 0; DISALLOW_COPY_AND_ASSIGN(Subprocess); }; Subprocess::Subprocess(const std::string& command, const char* terminal_type, SubprocessType type, SubprocessProtocol protocol) : command_(command), terminal_type_(terminal_type ? terminal_type : ""), type_(type), protocol_(protocol) { // If we aren't using the shell protocol we must allocate a PTY to properly close the // subprocess. PTYs automatically send SIGHUP to the slave-side process when the master side // of the PTY closes, which we rely on. If we use a raw pipe, processes that don't read/write, // e.g. screenrecord, will never notice the broken pipe and terminate. // The shell protocol doesn't require a PTY because it's always monitoring the local socket FD // with select() and will send SIGHUP manually to the child process. if (protocol_ == SubprocessProtocol::kNone && type_ == SubprocessType::kRaw) { // Disable PTY input/output processing since the client is expecting raw data. D("Can't create raw subprocess without shell protocol, using PTY in raw mode instead"); type_ = SubprocessType::kPty; make_pty_raw_ = true; } } Subprocess::~Subprocess() { WaitForExit(); } bool Subprocess::ForkAndExec(std::string* error) { ScopedFd child_stdinout_sfd, child_stderr_sfd; ScopedFd parent_error_sfd, child_error_sfd; char pts_name[PATH_MAX]; if (command_.empty()) { __android_log_security_bswrite(SEC_TAG_ADB_SHELL_INTERACTIVE, ""); } else { __android_log_security_bswrite(SEC_TAG_ADB_SHELL_CMD, command_.c_str()); } // Create a socketpair for the fork() child to report any errors back to the parent. Since we // use threads, logging directly from the child might deadlock due to locks held in another // thread during the fork. if (!CreateSocketpair(&parent_error_sfd, &child_error_sfd)) { *error = android::base::StringPrintf( "failed to create pipe for subprocess error reporting: %s", strerror(errno)); return false; } // Construct the environment for the child before we fork. passwd* pw = getpwuid(getuid()); std::unordered_map env; if (environ) { char** current = environ; while (char* env_cstr = *current++) { std::string env_string = env_cstr; char* delimiter = strchr(env_string.c_str(), '='); // Drop any values that don't contain '='. if (delimiter) { *delimiter++ = '\0'; env[env_string.c_str()] = delimiter; } } } if (pw != nullptr) { // TODO: $HOSTNAME? Normally bash automatically sets that, but mksh doesn't. env["HOME"] = pw->pw_dir; env["LOGNAME"] = pw->pw_name; env["USER"] = pw->pw_name; env["SHELL"] = pw->pw_shell; } if (!terminal_type_.empty()) { env["TERM"] = terminal_type_; } std::vector joined_env; for (auto it : env) { const char* key = it.first.c_str(); const char* value = it.second.c_str(); joined_env.push_back(android::base::StringPrintf("%s=%s", key, value)); } std::vector cenv; for (const std::string& str : joined_env) { cenv.push_back(str.c_str()); } cenv.push_back(nullptr); if (type_ == SubprocessType::kPty) { int fd; pid_ = forkpty(&fd, pts_name, nullptr, nullptr); if (pid_ > 0) { stdinout_sfd_.Reset(fd); } } else { if (!CreateSocketpair(&stdinout_sfd_, &child_stdinout_sfd)) { *error = android::base::StringPrintf("failed to create socketpair for stdin/out: %s", strerror(errno)); return false; } // Raw subprocess + shell protocol allows for splitting stderr. if (protocol_ == SubprocessProtocol::kShell && !CreateSocketpair(&stderr_sfd_, &child_stderr_sfd)) { *error = android::base::StringPrintf("failed to create socketpair for stderr: %s", strerror(errno)); return false; } pid_ = fork(); } if (pid_ == -1) { *error = android::base::StringPrintf("fork failed: %s", strerror(errno)); return false; } if (pid_ == 0) { // Subprocess child. init_subproc_child(); if (type_ == SubprocessType::kPty) { child_stdinout_sfd.Reset(OpenPtyChildFd(pts_name, &child_error_sfd)); } dup2(child_stdinout_sfd.fd(), STDIN_FILENO); dup2(child_stdinout_sfd.fd(), STDOUT_FILENO); dup2(child_stderr_sfd.valid() ? child_stderr_sfd.fd() : child_stdinout_sfd.fd(), STDERR_FILENO); // exec doesn't trigger destructors, close the FDs manually. stdinout_sfd_.Reset(); stderr_sfd_.Reset(); child_stdinout_sfd.Reset(); child_stderr_sfd.Reset(); parent_error_sfd.Reset(); close_on_exec(child_error_sfd.fd()); if (command_.empty()) { execle(_PATH_BSHELL, _PATH_BSHELL, "-", nullptr, cenv.data()); } else { execle(_PATH_BSHELL, _PATH_BSHELL, "-c", command_.c_str(), nullptr, cenv.data()); } WriteFdExactly(child_error_sfd.fd(), "exec '" _PATH_BSHELL "' failed: "); WriteFdExactly(child_error_sfd.fd(), strerror(errno)); child_error_sfd.Reset(); _Exit(1); } // Subprocess parent. D("subprocess parent: stdin/stdout FD = %d, stderr FD = %d", stdinout_sfd_.fd(), stderr_sfd_.fd()); // Wait to make sure the subprocess exec'd without error. child_error_sfd.Reset(); std::string error_message = ReadAll(parent_error_sfd.fd()); if (!error_message.empty()) { *error = error_message; return false; } D("subprocess parent: exec completed"); if (protocol_ == SubprocessProtocol::kNone) { // No protocol: all streams pass through the stdinout FD and hook // directly into the local socket for raw data transfer. local_socket_sfd_.Reset(stdinout_sfd_.Release()); } else { // Shell protocol: create another socketpair to intercept data. if (!CreateSocketpair(&protocol_sfd_, &local_socket_sfd_)) { *error = android::base::StringPrintf( "failed to create socketpair to intercept data: %s", strerror(errno)); kill(pid_, SIGKILL); return false; } D("protocol FD = %d", protocol_sfd_.fd()); input_.reset(new ShellProtocol(protocol_sfd_.fd())); output_.reset(new ShellProtocol(protocol_sfd_.fd())); if (!input_ || !output_) { *error = "failed to allocate shell protocol objects"; kill(pid_, SIGKILL); return false; } // Don't let reads/writes to the subprocess block our thread. This isn't // likely but could happen under unusual circumstances, such as if we // write a ton of data to stdin but the subprocess never reads it and // the pipe fills up. for (int fd : {stdinout_sfd_.fd(), stderr_sfd_.fd()}) { if (fd >= 0) { if (!set_file_block_mode(fd, false)) { *error = android::base::StringPrintf( "failed to set non-blocking mode for fd %d", fd); kill(pid_, SIGKILL); return false; } } } } D("subprocess parent: completed"); return true; } bool Subprocess::StartThread(std::unique_ptr subprocess, std::string* error) { Subprocess* raw = subprocess.release(); if (!adb_thread_create(ThreadHandler, raw)) { *error = android::base::StringPrintf("failed to create subprocess thread: %s", strerror(errno)); kill(raw->pid_, SIGKILL); return false; } return true; } int Subprocess::OpenPtyChildFd(const char* pts_name, ScopedFd* error_sfd) { int child_fd = adb_open(pts_name, O_RDWR | O_CLOEXEC); if (child_fd == -1) { // Don't use WriteFdFmt; since we're in the fork() child we don't want // to allocate any heap memory to avoid race conditions. const char* messages[] = {"child failed to open pseudo-term slave ", pts_name, ": ", strerror(errno)}; for (const char* message : messages) { WriteFdExactly(error_sfd->fd(), message); } exit(-1); } if (make_pty_raw_) { termios tattr; if (tcgetattr(child_fd, &tattr) == -1) { int saved_errno = errno; WriteFdExactly(error_sfd->fd(), "tcgetattr failed: "); WriteFdExactly(error_sfd->fd(), strerror(saved_errno)); exit(-1); } cfmakeraw(&tattr); if (tcsetattr(child_fd, TCSADRAIN, &tattr) == -1) { int saved_errno = errno; WriteFdExactly(error_sfd->fd(), "tcsetattr failed: "); WriteFdExactly(error_sfd->fd(), strerror(saved_errno)); exit(-1); } } return child_fd; } void Subprocess::ThreadHandler(void* userdata) { Subprocess* subprocess = reinterpret_cast(userdata); adb_thread_setname(android::base::StringPrintf( "shell srvc %d", subprocess->pid())); D("passing data streams for PID %d", subprocess->pid()); subprocess->PassDataStreams(); D("deleting Subprocess for PID %d", subprocess->pid()); delete subprocess; } void Subprocess::PassDataStreams() { if (!protocol_sfd_.valid()) { return; } // Start by trying to read from the protocol FD, stdout, and stderr. fd_set master_read_set, master_write_set; FD_ZERO(&master_read_set); FD_ZERO(&master_write_set); for (ScopedFd* sfd : {&protocol_sfd_, &stdinout_sfd_, &stderr_sfd_}) { if (sfd->valid()) { FD_SET(sfd->fd(), &master_read_set); } } // Pass data until the protocol FD or both the subprocess pipes die, at // which point we can't pass any more data. while (protocol_sfd_.valid() && (stdinout_sfd_.valid() || stderr_sfd_.valid())) { ScopedFd* dead_sfd = SelectLoop(&master_read_set, &master_write_set); if (dead_sfd) { D("closing FD %d", dead_sfd->fd()); FD_CLR(dead_sfd->fd(), &master_read_set); FD_CLR(dead_sfd->fd(), &master_write_set); if (dead_sfd == &protocol_sfd_) { // Using SIGHUP is a decent general way to indicate that the // controlling process is going away. If specific signals are // needed (e.g. SIGINT), pass those through the shell protocol // and only fall back on this for unexpected closures. D("protocol FD died, sending SIGHUP to pid %d", pid_); kill(pid_, SIGHUP); // We also need to close the pipes connected to the child process // so that if it ignores SIGHUP and continues to write data it // won't fill up the pipe and block. stdinout_sfd_.Reset(); stderr_sfd_.Reset(); } dead_sfd->Reset(); } } } namespace { inline bool ValidAndInSet(const ScopedFd& sfd, fd_set* set) { return sfd.valid() && FD_ISSET(sfd.fd(), set); } } // namespace ScopedFd* Subprocess::SelectLoop(fd_set* master_read_set_ptr, fd_set* master_write_set_ptr) { fd_set read_set, write_set; int select_n = std::max(std::max(protocol_sfd_.fd(), stdinout_sfd_.fd()), stderr_sfd_.fd()) + 1; ScopedFd* dead_sfd = nullptr; // Keep calling select() and passing data until an FD closes/errors. while (!dead_sfd) { memcpy(&read_set, master_read_set_ptr, sizeof(read_set)); memcpy(&write_set, master_write_set_ptr, sizeof(write_set)); if (select(select_n, &read_set, &write_set, nullptr, nullptr) < 0) { if (errno == EINTR) { continue; } else { PLOG(ERROR) << "select failed, closing subprocess pipes"; stdinout_sfd_.Reset(); stderr_sfd_.Reset(); return nullptr; } } // Read stdout, write to protocol FD. if (ValidAndInSet(stdinout_sfd_, &read_set)) { dead_sfd = PassOutput(&stdinout_sfd_, ShellProtocol::kIdStdout); } // Read stderr, write to protocol FD. if (!dead_sfd && ValidAndInSet(stderr_sfd_, &read_set)) { dead_sfd = PassOutput(&stderr_sfd_, ShellProtocol::kIdStderr); } // Read protocol FD, write to stdin. if (!dead_sfd && ValidAndInSet(protocol_sfd_, &read_set)) { dead_sfd = PassInput(); // If we didn't finish writing, block on stdin write. if (input_bytes_left_) { FD_CLR(protocol_sfd_.fd(), master_read_set_ptr); FD_SET(stdinout_sfd_.fd(), master_write_set_ptr); } } // Continue writing to stdin; only happens if a previous write blocked. if (!dead_sfd && ValidAndInSet(stdinout_sfd_, &write_set)) { dead_sfd = PassInput(); // If we finished writing, go back to blocking on protocol read. if (!input_bytes_left_) { FD_SET(protocol_sfd_.fd(), master_read_set_ptr); FD_CLR(stdinout_sfd_.fd(), master_write_set_ptr); } } } // while (!dead_sfd) return dead_sfd; } ScopedFd* Subprocess::PassInput() { // Only read a new packet if we've finished writing the last one. if (!input_bytes_left_) { if (!input_->Read()) { // Read() uses ReadFdExactly() which sets errno to 0 on EOF. if (errno != 0) { PLOG(ERROR) << "error reading protocol FD " << protocol_sfd_.fd(); } return &protocol_sfd_; } if (stdinout_sfd_.valid()) { switch (input_->id()) { case ShellProtocol::kIdWindowSizeChange: int rows, cols, x_pixels, y_pixels; if (sscanf(input_->data(), "%dx%d,%dx%d", &rows, &cols, &x_pixels, &y_pixels) == 4) { winsize ws; ws.ws_row = rows; ws.ws_col = cols; ws.ws_xpixel = x_pixels; ws.ws_ypixel = y_pixels; ioctl(stdinout_sfd_.fd(), TIOCSWINSZ, &ws); } break; case ShellProtocol::kIdStdin: input_bytes_left_ = input_->data_length(); break; case ShellProtocol::kIdCloseStdin: if (type_ == SubprocessType::kRaw) { if (adb_shutdown(stdinout_sfd_.fd(), SHUT_WR) == 0) { return nullptr; } PLOG(ERROR) << "failed to shutdown writes to FD " << stdinout_sfd_.fd(); return &stdinout_sfd_; } else { // PTYs can't close just input, so rather than close the // FD and risk losing subprocess output, leave it open. // This only happens if the client starts a PTY shell // non-interactively which is rare and unsupported. // If necessary, the client can manually close the shell // with `exit` or by killing the adb client process. D("can't close input for PTY FD %d", stdinout_sfd_.fd()); } break; } } } if (input_bytes_left_ > 0) { int index = input_->data_length() - input_bytes_left_; int bytes = adb_write(stdinout_sfd_.fd(), input_->data() + index, input_bytes_left_); if (bytes == 0 || (bytes < 0 && errno != EAGAIN)) { if (bytes < 0) { PLOG(ERROR) << "error reading stdin FD " << stdinout_sfd_.fd(); } // stdin is done, mark this packet as finished and we'll just start // dumping any further data received from the protocol FD. input_bytes_left_ = 0; return &stdinout_sfd_; } else if (bytes > 0) { input_bytes_left_ -= bytes; } } return nullptr; } ScopedFd* Subprocess::PassOutput(ScopedFd* sfd, ShellProtocol::Id id) { int bytes = adb_read(sfd->fd(), output_->data(), output_->data_capacity()); if (bytes == 0 || (bytes < 0 && errno != EAGAIN)) { // read() returns EIO if a PTY closes; don't report this as an error, // it just means the subprocess completed. if (bytes < 0 && !(type_ == SubprocessType::kPty && errno == EIO)) { PLOG(ERROR) << "error reading output FD " << sfd->fd(); } return sfd; } if (bytes > 0 && !output_->Write(id, bytes)) { if (errno != 0) { PLOG(ERROR) << "error reading protocol FD " << protocol_sfd_.fd(); } return &protocol_sfd_; } return nullptr; } void Subprocess::WaitForExit() { int exit_code = 1; D("waiting for pid %d", pid_); while (true) { int status; if (pid_ == waitpid(pid_, &status, 0)) { D("post waitpid (pid=%d) status=%04x", pid_, status); if (WIFSIGNALED(status)) { exit_code = 0x80 | WTERMSIG(status); D("subprocess killed by signal %d", WTERMSIG(status)); break; } else if (!WIFEXITED(status)) { D("subprocess didn't exit"); break; } else if (WEXITSTATUS(status) >= 0) { exit_code = WEXITSTATUS(status); D("subprocess exit code = %d", WEXITSTATUS(status)); break; } } } // If we have an open protocol FD send an exit packet. if (protocol_sfd_.valid()) { output_->data()[0] = exit_code; if (output_->Write(ShellProtocol::kIdExit, 1)) { D("wrote the exit code packet: %d", exit_code); } else { PLOG(ERROR) << "failed to write the exit code packet"; } protocol_sfd_.Reset(); } // Pass the local socket FD to the shell cleanup fdevent. if (SHELL_EXIT_NOTIFY_FD >= 0) { int fd = local_socket_sfd_.fd(); if (WriteFdExactly(SHELL_EXIT_NOTIFY_FD, &fd, sizeof(fd))) { D("passed fd %d to SHELL_EXIT_NOTIFY_FD (%d) for pid %d", fd, SHELL_EXIT_NOTIFY_FD, pid_); // The shell exit fdevent now owns the FD and will close it once // the last bit of data flushes through. local_socket_sfd_.Release(); } else { PLOG(ERROR) << "failed to write fd " << fd << " to SHELL_EXIT_NOTIFY_FD (" << SHELL_EXIT_NOTIFY_FD << ") for pid " << pid_; } } } } // namespace // Create a pipe containing the error. static int ReportError(SubprocessProtocol protocol, const std::string& message) { int pipefd[2]; if (pipe(pipefd) != 0) { LOG(ERROR) << "failed to create pipe to report error"; return -1; } std::string buf = android::base::StringPrintf("error: %s\n", message.c_str()); if (protocol == SubprocessProtocol::kShell) { ShellProtocol::Id id = ShellProtocol::kIdStderr; uint32_t length = buf.length(); WriteFdExactly(pipefd[1], &id, sizeof(id)); WriteFdExactly(pipefd[1], &length, sizeof(length)); } WriteFdExactly(pipefd[1], buf.data(), buf.length()); if (protocol == SubprocessProtocol::kShell) { ShellProtocol::Id id = ShellProtocol::kIdExit; uint32_t length = 1; char exit_code = 126; WriteFdExactly(pipefd[1], &id, sizeof(id)); WriteFdExactly(pipefd[1], &length, sizeof(length)); WriteFdExactly(pipefd[1], &exit_code, sizeof(exit_code)); } adb_close(pipefd[1]); return pipefd[0]; } int StartSubprocess(const char* name, const char* terminal_type, SubprocessType type, SubprocessProtocol protocol) { D("starting %s subprocess (protocol=%s, TERM=%s): '%s'", type == SubprocessType::kRaw ? "raw" : "PTY", protocol == SubprocessProtocol::kNone ? "none" : "shell", terminal_type, name); auto subprocess = std::make_unique(name, terminal_type, type, protocol); if (!subprocess) { LOG(ERROR) << "failed to allocate new subprocess"; return ReportError(protocol, "failed to allocate new subprocess"); } std::string error; if (!subprocess->ForkAndExec(&error)) { LOG(ERROR) << "failed to start subprocess: " << error; return ReportError(protocol, error); } int local_socket = subprocess->ReleaseLocalSocket(); D("subprocess creation successful: local_socket_fd=%d, pid=%d", local_socket, subprocess->pid()); if (!Subprocess::StartThread(std::move(subprocess), &error)) { LOG(ERROR) << "failed to start subprocess management thread: " << error; return ReportError(protocol, error); } return local_socket; } adb/shell_service.h0100644 0000000 0000000 00000011357 12767234553 013360 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ // This file contains classes and functionality to launch shell subprocesses // in adbd and communicate between those subprocesses and the adb client. // // The main features exposed here are: // 1. A ShellPacket class to wrap data in a simple protocol. Both adbd and // the adb client use this class to transmit data between them. // 2. Functions to launch a subprocess on the adbd side. #ifndef SHELL_SERVICE_H_ #define SHELL_SERVICE_H_ #include #include #include "adb.h" // Class to send and receive shell protocol packets. // // To keep things simple and predictable, reads and writes block until an entire // packet is complete. // // Example: read raw data from |fd| and send it in a packet. // ShellProtocol* p = new ShellProtocol(protocol_fd); // int len = adb_read(stdout_fd, p->data(), p->data_capacity()); // packet->WritePacket(ShellProtocol::kIdStdout, len); // // Example: read a packet and print it to |stdout|. // ShellProtocol* p = new ShellProtocol(protocol_fd); // if (p->ReadPacket() && p->id() == kIdStdout) { // fwrite(p->data(), 1, p->data_length(), stdout); // } class ShellProtocol { public: // This is an unscoped enum to make it easier to compare against raw bytes. enum Id : uint8_t { kIdStdin = 0, kIdStdout = 1, kIdStderr = 2, kIdExit = 3, // Close subprocess stdin if possible. kIdCloseStdin = 4, // Window size change (an ASCII version of struct winsize). kIdWindowSizeChange = 5, // Indicates an invalid or unknown packet. kIdInvalid = 255, }; // ShellPackets will probably be too large to allocate on the stack so they // should be dynamically allocated on the heap instead. // // |fd| is an open file descriptor to be used to send or receive packets. explicit ShellProtocol(int fd); virtual ~ShellProtocol(); // Returns a pointer to the data buffer. const char* data() const { return buffer_ + kHeaderSize; } char* data() { return buffer_ + kHeaderSize; } // Returns the total capacity of the data buffer. size_t data_capacity() const { return buffer_end_ - data(); } // Reads a packet from the FD. // // If a packet is too big to fit in the buffer then Read() will split the // packet across multiple calls. For example, reading a 50-byte packet into // a 20-byte buffer would read 20 bytes, 20 bytes, then 10 bytes. // // Returns false if the FD closed or errored. bool Read(); // Returns the ID of the packet in the buffer. int id() const { return buffer_[0]; } // Returns the number of bytes that have been read into the data buffer. size_t data_length() const { return data_length_; } // Writes the packet currently in the buffer to the FD. // // Returns false if the FD closed or errored. bool Write(Id id, size_t length); private: // Packets support 4-byte lengths. typedef uint32_t length_t; enum { // It's OK if MAX_PAYLOAD doesn't match on the sending and receiving // end, reading will split larger packets into multiple smaller ones. kBufferSize = MAX_PAYLOAD, // Header is 1 byte ID + 4 bytes length. kHeaderSize = sizeof(Id) + sizeof(length_t) }; int fd_; char buffer_[kBufferSize]; size_t data_length_ = 0, bytes_left_ = 0; // We need to be able to modify this value for testing purposes, but it // will stay constant during actual program use. char* buffer_end_ = buffer_ + sizeof(buffer_); friend class ShellProtocolTest; DISALLOW_COPY_AND_ASSIGN(ShellProtocol); }; #if !ADB_HOST enum class SubprocessType { kPty, kRaw, }; enum class SubprocessProtocol { kNone, kShell, }; // Forks and starts a new shell subprocess. If |name| is empty an interactive // shell is started, otherwise |name| is executed non-interactively. // // Returns an open FD connected to the subprocess or -1 on failure. int StartSubprocess(const char* name, const char* terminal_type, SubprocessType type, SubprocessProtocol protocol); #endif // !ADB_HOST #endif // SHELL_SERVICE_H_ adb/shell_service_protocol.cpp0100644 0000000 0000000 00000003236 12767234553 015631 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "shell_service.h" #include #include #include "adb_io.h" ShellProtocol::ShellProtocol(int fd) : fd_(fd) { buffer_[0] = kIdInvalid; } ShellProtocol::~ShellProtocol() { } bool ShellProtocol::Read() { // Only read a new header if we've finished the last packet. if (!bytes_left_) { if (!ReadFdExactly(fd_, buffer_, kHeaderSize)) { return false; } length_t packet_length; memcpy(&packet_length, &buffer_[1], sizeof(packet_length)); bytes_left_ = packet_length; data_length_ = 0; } size_t read_length = std::min(bytes_left_, data_capacity()); if (read_length && !ReadFdExactly(fd_, data(), read_length)) { return false; } bytes_left_ -= read_length; data_length_ = read_length; return true; } bool ShellProtocol::Write(Id id, size_t length) { buffer_[0] = id; length_t typed_length = length; memcpy(&buffer_[1], &typed_length, sizeof(typed_length)); return WriteFdExactly(fd_, buffer_, kHeaderSize + length); } adb/shell_service_protocol_test.cpp0100644 0000000 0000000 00000013502 12767234553 016665 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "shell_service.h" #include #include #include #include "sysdeps.h" class ShellProtocolTest : public ::testing::Test { public: static void SetUpTestCase() { #if !defined(_WIN32) // This is normally done in main.cpp. saved_sigpipe_handler_ = signal(SIGPIPE, SIG_IGN); #endif } static void TearDownTestCase() { #if !defined(_WIN32) signal(SIGPIPE, saved_sigpipe_handler_); #endif } // Initializes the socketpair and ShellProtocols needed for testing. void SetUp() { int fds[2]; ASSERT_EQ(0, adb_socketpair(fds)); read_fd_ = fds[0]; write_fd_ = fds[1]; write_protocol_ = new ShellProtocol(write_fd_); ASSERT_TRUE(write_protocol_ != nullptr); read_protocol_ = new ShellProtocol(read_fd_); ASSERT_TRUE(read_protocol_ != nullptr); } // Cleans up FDs and ShellProtocols. If an FD is closed manually during a // test, set it to -1 to prevent TearDown() trying to close it again. void TearDown() { for (int fd : {read_fd_, write_fd_}) { if (fd >= 0) { adb_close(fd); } } for (ShellProtocol* protocol : {read_protocol_, write_protocol_}) { if (protocol) { delete protocol; } } } // Fakes the buffer size so we can test filling buffers. void SetReadDataCapacity(size_t size) { read_protocol_->buffer_end_ = read_protocol_->data() + size; } #if !defined(_WIN32) static sig_t saved_sigpipe_handler_; #endif int read_fd_ = -1, write_fd_ = -1; ShellProtocol *read_protocol_ = nullptr, *write_protocol_ = nullptr; }; #if !defined(_WIN32) sig_t ShellProtocolTest::saved_sigpipe_handler_ = nullptr; #endif namespace { // Returns true if the packet contains the given values. bool PacketEquals(const ShellProtocol* protocol, ShellProtocol::Id id, const void* data, size_t data_length) { return (protocol->id() == id && protocol->data_length() == data_length && !memcmp(data, protocol->data(), data_length)); } } // namespace // Tests data that can fit in a single packet. TEST_F(ShellProtocolTest, FullPacket) { ShellProtocol::Id id = ShellProtocol::kIdStdout; char data[] = "abc 123 \0\r\n"; memcpy(write_protocol_->data(), data, sizeof(data)); ASSERT_TRUE(write_protocol_->Write(id, sizeof(data))); ASSERT_TRUE(read_protocol_->Read()); ASSERT_TRUE(PacketEquals(read_protocol_, id, data, sizeof(data))); } // Tests data that has to be read multiple times due to smaller read buffer. TEST_F(ShellProtocolTest, ReadBufferOverflow) { ShellProtocol::Id id = ShellProtocol::kIdStdin; memcpy(write_protocol_->data(), "1234567890", 10); ASSERT_TRUE(write_protocol_->Write(id, 10)); SetReadDataCapacity(4); ASSERT_TRUE(read_protocol_->Read()); ASSERT_TRUE(PacketEquals(read_protocol_, id, "1234", 4)); ASSERT_TRUE(read_protocol_->Read()); ASSERT_TRUE(PacketEquals(read_protocol_, id, "5678", 4)); ASSERT_TRUE(read_protocol_->Read()); ASSERT_TRUE(PacketEquals(read_protocol_, id, "90", 2)); } // Tests a zero length packet. TEST_F(ShellProtocolTest, ZeroLengthPacket) { ShellProtocol::Id id = ShellProtocol::kIdStderr; ASSERT_TRUE(write_protocol_->Write(id, 0)); ASSERT_TRUE(read_protocol_->Read()); ASSERT_TRUE(PacketEquals(read_protocol_, id, nullptr, 0)); } // Tests exit code packets. TEST_F(ShellProtocolTest, ExitCodePacket) { write_protocol_->data()[0] = 20; ASSERT_TRUE(write_protocol_->Write(ShellProtocol::kIdExit, 1)); ASSERT_TRUE(read_protocol_->Read()); ASSERT_EQ(ShellProtocol::kIdExit, read_protocol_->id()); ASSERT_EQ(20, read_protocol_->data()[0]); } // Tests writing to a closed pipe. TEST_F(ShellProtocolTest, WriteToClosedPipeFail) { adb_close(read_fd_); read_fd_ = -1; ASSERT_FALSE(write_protocol_->Write(ShellProtocol::kIdStdout, 0)); } // Tests writing to a closed FD. TEST_F(ShellProtocolTest, WriteToClosedFdFail) { adb_close(write_fd_); write_fd_ = -1; ASSERT_FALSE(write_protocol_->Write(ShellProtocol::kIdStdout, 0)); } // Tests reading from a closed pipe. TEST_F(ShellProtocolTest, ReadFromClosedPipeFail) { adb_close(write_fd_); write_fd_ = -1; ASSERT_FALSE(read_protocol_->Read()); } // Tests reading from a closed FD. TEST_F(ShellProtocolTest, ReadFromClosedFdFail) { adb_close(read_fd_); read_fd_ = -1; ASSERT_FALSE(read_protocol_->Read()); } // Tests reading from a closed pipe that has a packet waiting. This checks that // even if the pipe closes before we can fully read its contents we will still // be able to access the last packets. TEST_F(ShellProtocolTest, ReadPacketFromClosedPipe) { ShellProtocol::Id id = ShellProtocol::kIdStdout; char data[] = "foo bar"; memcpy(write_protocol_->data(), data, sizeof(data)); ASSERT_TRUE(write_protocol_->Write(id, sizeof(data))); adb_close(write_fd_); write_fd_ = -1; // First read should grab the packet. ASSERT_TRUE(read_protocol_->Read()); ASSERT_TRUE(PacketEquals(read_protocol_, id, data, sizeof(data))); // Second read should fail. ASSERT_FALSE(read_protocol_->Read()); } adb/shell_service_test.cpp0100644 0000000 0000000 00000024141 12767234553 014745 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "shell_service.h" #include #include #include #include #include #include "adb.h" #include "adb_io.h" #include "sysdeps.h" class ShellServiceTest : public ::testing::Test { public: static void SetUpTestCase() { // This is normally done in main.cpp. saved_sigpipe_handler_ = signal(SIGPIPE, SIG_IGN); } static void TearDownTestCase() { signal(SIGPIPE, saved_sigpipe_handler_); } // Helpers to start and cleanup a subprocess. Cleanup normally does not // need to be called manually unless multiple subprocesses are run from // a single test. void StartTestSubprocess(const char* command, SubprocessType type, SubprocessProtocol protocol); void CleanupTestSubprocess(); virtual void TearDown() override { void CleanupTestSubprocess(); } static sighandler_t saved_sigpipe_handler_; int subprocess_fd_ = -1; int shell_exit_receiver_fd_ = -1, saved_shell_exit_fd_; }; sighandler_t ShellServiceTest::saved_sigpipe_handler_ = nullptr; void ShellServiceTest::StartTestSubprocess( const char* command, SubprocessType type, SubprocessProtocol protocol) { // We want to intercept the shell exit message to make sure it's sent. saved_shell_exit_fd_ = SHELL_EXIT_NOTIFY_FD; int fd[2]; ASSERT_TRUE(adb_socketpair(fd) >= 0); SHELL_EXIT_NOTIFY_FD = fd[0]; shell_exit_receiver_fd_ = fd[1]; subprocess_fd_ = StartSubprocess(command, nullptr, type, protocol); ASSERT_TRUE(subprocess_fd_ >= 0); } void ShellServiceTest::CleanupTestSubprocess() { if (subprocess_fd_ >= 0) { // Subprocess should send its FD to SHELL_EXIT_NOTIFY_FD for cleanup. int notified_fd = -1; ASSERT_TRUE(ReadFdExactly(shell_exit_receiver_fd_, ¬ified_fd, sizeof(notified_fd))); ASSERT_EQ(notified_fd, subprocess_fd_); adb_close(subprocess_fd_); subprocess_fd_ = -1; // Restore SHELL_EXIT_NOTIFY_FD. adb_close(SHELL_EXIT_NOTIFY_FD); adb_close(shell_exit_receiver_fd_); shell_exit_receiver_fd_ = -1; SHELL_EXIT_NOTIFY_FD = saved_shell_exit_fd_; } } namespace { // Reads raw data from |fd| until it closes or errors. std::string ReadRaw(int fd) { char buffer[1024]; char *cur_ptr = buffer, *end_ptr = buffer + sizeof(buffer); while (1) { int bytes = adb_read(fd, cur_ptr, end_ptr - cur_ptr); if (bytes <= 0) { return std::string(buffer, cur_ptr); } cur_ptr += bytes; } } // Reads shell protocol data from |fd| until it closes or errors. Fills // |stdout| and |stderr| with their respective data, and returns the exit code // read from the protocol or -1 if an exit code packet was not received. int ReadShellProtocol(int fd, std::string* stdout, std::string* stderr) { int exit_code = -1; stdout->clear(); stderr->clear(); ShellProtocol* protocol = new ShellProtocol(fd); while (protocol->Read()) { switch (protocol->id()) { case ShellProtocol::kIdStdout: stdout->append(protocol->data(), protocol->data_length()); break; case ShellProtocol::kIdStderr: stderr->append(protocol->data(), protocol->data_length()); break; case ShellProtocol::kIdExit: EXPECT_EQ(-1, exit_code) << "Multiple exit packets received"; EXPECT_EQ(1u, protocol->data_length()); exit_code = protocol->data()[0]; break; default: ADD_FAILURE() << "Unidentified packet ID: " << protocol->id(); } } delete protocol; return exit_code; } // Checks if each line in |lines| exists in the same order in |output|. Blank // lines in |output| are ignored for simplicity. bool ExpectLinesEqual(const std::string& output, const std::vector& lines) { auto output_lines = android::base::Split(output, "\r\n"); size_t i = 0; for (const std::string& line : lines) { // Skip empty lines in output. while (i < output_lines.size() && output_lines[i].empty()) { ++i; } if (i >= output_lines.size()) { ADD_FAILURE() << "Ran out of output lines"; return false; } EXPECT_EQ(line, output_lines[i]); ++i; } while (i < output_lines.size() && output_lines[i].empty()) { ++i; } EXPECT_EQ(i, output_lines.size()) << "Found unmatched output lines"; return true; } } // namespace // Tests a raw subprocess with no protocol. TEST_F(ShellServiceTest, RawNoProtocolSubprocess) { // [ -t 0 ] checks if stdin is connected to a terminal. ASSERT_NO_FATAL_FAILURE(StartTestSubprocess( "echo foo; echo bar >&2; [ -t 0 ]; echo $?", SubprocessType::kRaw, SubprocessProtocol::kNone)); // [ -t 0 ] == 0 means we have a terminal (PTY). Even when requesting a raw subprocess, without // the shell protocol we should always force a PTY to ensure proper cleanup. ExpectLinesEqual(ReadRaw(subprocess_fd_), {"foo", "bar", "0"}); } // Tests a PTY subprocess with no protocol. TEST_F(ShellServiceTest, PtyNoProtocolSubprocess) { // [ -t 0 ] checks if stdin is connected to a terminal. ASSERT_NO_FATAL_FAILURE(StartTestSubprocess( "echo foo; echo bar >&2; [ -t 0 ]; echo $?", SubprocessType::kPty, SubprocessProtocol::kNone)); // [ -t 0 ] == 0 means we have a terminal (PTY). ExpectLinesEqual(ReadRaw(subprocess_fd_), {"foo", "bar", "0"}); } // Tests a raw subprocess with the shell protocol. TEST_F(ShellServiceTest, RawShellProtocolSubprocess) { ASSERT_NO_FATAL_FAILURE(StartTestSubprocess( "echo foo; echo bar >&2; echo baz; exit 24", SubprocessType::kRaw, SubprocessProtocol::kShell)); std::string stdout, stderr; EXPECT_EQ(24, ReadShellProtocol(subprocess_fd_, &stdout, &stderr)); ExpectLinesEqual(stdout, {"foo", "baz"}); ExpectLinesEqual(stderr, {"bar"}); } // Tests a PTY subprocess with the shell protocol. TEST_F(ShellServiceTest, PtyShellProtocolSubprocess) { ASSERT_NO_FATAL_FAILURE(StartTestSubprocess( "echo foo; echo bar >&2; echo baz; exit 50", SubprocessType::kPty, SubprocessProtocol::kShell)); // PTY always combines stdout and stderr but the shell protocol should // still give us an exit code. std::string stdout, stderr; EXPECT_EQ(50, ReadShellProtocol(subprocess_fd_, &stdout, &stderr)); ExpectLinesEqual(stdout, {"foo", "bar", "baz"}); ExpectLinesEqual(stderr, {}); } // Tests an interactive PTY session. TEST_F(ShellServiceTest, InteractivePtySubprocess) { ASSERT_NO_FATAL_FAILURE(StartTestSubprocess( "", SubprocessType::kPty, SubprocessProtocol::kShell)); // Use variable substitution so echoed input is different from output. const char* commands[] = {"TEST_STR=abc123", "echo --${TEST_STR}--", "exit"}; ShellProtocol* protocol = new ShellProtocol(subprocess_fd_); for (std::string command : commands) { // Interactive shell requires a newline to complete each command. command.push_back('\n'); memcpy(protocol->data(), command.data(), command.length()); ASSERT_TRUE(protocol->Write(ShellProtocol::kIdStdin, command.length())); } delete protocol; std::string stdout, stderr; EXPECT_EQ(0, ReadShellProtocol(subprocess_fd_, &stdout, &stderr)); // An unpredictable command prompt makes parsing exact output difficult but // it should at least contain echoed input and the expected output. for (const char* command : commands) { EXPECT_FALSE(stdout.find(command) == std::string::npos); } EXPECT_FALSE(stdout.find("--abc123--") == std::string::npos); } // Tests closing raw subprocess stdin. TEST_F(ShellServiceTest, CloseClientStdin) { ASSERT_NO_FATAL_FAILURE(StartTestSubprocess( "cat; echo TEST_DONE", SubprocessType::kRaw, SubprocessProtocol::kShell)); std::string input = "foo\nbar"; ShellProtocol* protocol = new ShellProtocol(subprocess_fd_); memcpy(protocol->data(), input.data(), input.length()); ASSERT_TRUE(protocol->Write(ShellProtocol::kIdStdin, input.length())); ASSERT_TRUE(protocol->Write(ShellProtocol::kIdCloseStdin, 0)); delete protocol; std::string stdout, stderr; EXPECT_EQ(0, ReadShellProtocol(subprocess_fd_, &stdout, &stderr)); ExpectLinesEqual(stdout, {"foo", "barTEST_DONE"}); ExpectLinesEqual(stderr, {}); } // Tests that nothing breaks when the stdin/stdout pipe closes. TEST_F(ShellServiceTest, CloseStdinStdoutSubprocess) { ASSERT_NO_FATAL_FAILURE(StartTestSubprocess( "exec 0<&-; exec 1>&-; echo bar >&2", SubprocessType::kRaw, SubprocessProtocol::kShell)); std::string stdout, stderr; EXPECT_EQ(0, ReadShellProtocol(subprocess_fd_, &stdout, &stderr)); ExpectLinesEqual(stdout, {}); ExpectLinesEqual(stderr, {"bar"}); } // Tests that nothing breaks when the stderr pipe closes. TEST_F(ShellServiceTest, CloseStderrSubprocess) { ASSERT_NO_FATAL_FAILURE(StartTestSubprocess( "exec 2>&-; echo foo", SubprocessType::kRaw, SubprocessProtocol::kShell)); std::string stdout, stderr; EXPECT_EQ(0, ReadShellProtocol(subprocess_fd_, &stdout, &stderr)); ExpectLinesEqual(stdout, {"foo"}); ExpectLinesEqual(stderr, {}); } adb/socket.h0100644 0000000 0000000 00000007246 12767234553 012023 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __ADB_SOCKET_H #define __ADB_SOCKET_H #include #include "fdevent.h" struct apacket; class atransport; /* An asocket represents one half of a connection between a local and ** remote entity. A local asocket is bound to a file descriptor. A ** remote asocket is bound to the protocol engine. */ struct asocket { /* chain pointers for the local/remote list of ** asockets that this asocket lives in */ asocket *next; asocket *prev; /* the unique identifier for this asocket */ unsigned id; /* flag: set when the socket's peer has closed ** but packets are still queued for delivery */ int closing; // flag: set when the socket failed to write, so the socket will not wait to // write packets and close directly. bool has_write_error; /* flag: quit adbd when both ends close the ** local service socket */ int exit_on_close; /* the asocket we are connected to */ asocket *peer; /* For local asockets, the fde is used to bind ** us to our fd event system. For remote asockets ** these fields are not used. */ fdevent fde; int fd; /* queue of apackets waiting to be written */ apacket *pkt_first; apacket *pkt_last; /* enqueue is called by our peer when it has data ** for us. It should return 0 if we can accept more ** data or 1 if not. If we return 1, we must call ** peer->ready() when we once again are ready to ** receive data. */ int (*enqueue)(asocket *s, apacket *pkt); /* ready is called by the peer when it is ready for ** us to send data via enqueue again */ void (*ready)(asocket *s); /* shutdown is called by the peer before it goes away. ** the socket should not do any further calls on its peer. ** Always followed by a call to close. Optional, i.e. can be NULL. */ void (*shutdown)(asocket *s); /* close is called by the peer when it has gone away. ** we are not allowed to make any further calls on the ** peer once our close method is called. */ void (*close)(asocket *s); /* A socket is bound to atransport */ atransport *transport; size_t get_max_payload() const; }; asocket *find_local_socket(unsigned local_id, unsigned remote_id); void install_local_socket(asocket *s); void remove_socket(asocket *s); void close_all_sockets(atransport *t); asocket *create_local_socket(int fd); asocket *create_local_service_socket(const char* destination, const atransport* transport); asocket *create_remote_socket(unsigned id, atransport *t); void connect_to_remote(asocket *s, const char *destination); void connect_to_smartsocket(asocket *s); // Internal functions that are only made available here for testing purposes. namespace internal { #if ADB_HOST char* skip_host_serial(const char* service); #endif } // namespace internal #endif // __ADB_SOCKET_H adb/socket_test.cpp0100644 0000000 0000000 00000023606 12767234553 013413 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "fdevent.h" #include #include #include #include #include #include #include #include "adb.h" #include "adb_io.h" #include "fdevent_test.h" #include "socket.h" #include "sysdeps.h" struct ThreadArg { int first_read_fd; int last_write_fd; size_t middle_pipe_count; }; class LocalSocketTest : public FdeventTest {}; static void FdEventThreadFunc(void*) { fdevent_loop(); } TEST_F(LocalSocketTest, smoke) { // Join two socketpairs with a chain of intermediate socketpairs. int first[2]; std::vector> intermediates; int last[2]; constexpr size_t INTERMEDIATE_COUNT = 50; constexpr size_t MESSAGE_LOOP_COUNT = 100; const std::string MESSAGE = "socket_test"; intermediates.resize(INTERMEDIATE_COUNT); ASSERT_EQ(0, adb_socketpair(first)) << strerror(errno); ASSERT_EQ(0, adb_socketpair(last)) << strerror(errno); asocket* prev_tail = create_local_socket(first[1]); ASSERT_NE(nullptr, prev_tail); auto connect = [](asocket* tail, asocket* head) { tail->peer = head; head->peer = tail; tail->ready(tail); }; for (auto& intermediate : intermediates) { ASSERT_EQ(0, adb_socketpair(intermediate.data())) << strerror(errno); asocket* head = create_local_socket(intermediate[0]); ASSERT_NE(nullptr, head); asocket* tail = create_local_socket(intermediate[1]); ASSERT_NE(nullptr, tail); connect(prev_tail, head); prev_tail = tail; } asocket* end = create_local_socket(last[0]); ASSERT_NE(nullptr, end); connect(prev_tail, end); PrepareThread(); adb_thread_t thread; ASSERT_TRUE(adb_thread_create(FdEventThreadFunc, nullptr, &thread)); for (size_t i = 0; i < MESSAGE_LOOP_COUNT; ++i) { std::string read_buffer = MESSAGE; std::string write_buffer(MESSAGE.size(), 'a'); ASSERT_TRUE(WriteFdExactly(first[0], &read_buffer[0], read_buffer.size())); ASSERT_TRUE(ReadFdExactly(last[1], &write_buffer[0], write_buffer.size())); ASSERT_EQ(read_buffer, write_buffer); } ASSERT_EQ(0, adb_close(first[0])); ASSERT_EQ(0, adb_close(last[1])); // Wait until the local sockets are closed. adb_sleep_ms(100); TerminateThread(thread); } struct CloseWithPacketArg { int socket_fd; size_t bytes_written; int cause_close_fd; }; static void CloseWithPacketThreadFunc(CloseWithPacketArg* arg) { asocket* s = create_local_socket(arg->socket_fd); ASSERT_TRUE(s != nullptr); arg->bytes_written = 0; while (true) { apacket* p = get_apacket(); p->len = sizeof(p->data); arg->bytes_written += p->len; int ret = s->enqueue(s, p); if (ret == 1) { // The writer has one packet waiting to send. break; } } asocket* cause_close_s = create_local_socket(arg->cause_close_fd); ASSERT_TRUE(cause_close_s != nullptr); cause_close_s->peer = s; s->peer = cause_close_s; cause_close_s->ready(cause_close_s); fdevent_loop(); } // This test checks if we can close local socket in the following situation: // The socket is closing but having some packets, so it is not closed. Then // some write error happens in the socket's file handler, e.g., the file // handler is closed. TEST_F(LocalSocketTest, close_socket_with_packet) { int socket_fd[2]; ASSERT_EQ(0, adb_socketpair(socket_fd)); int cause_close_fd[2]; ASSERT_EQ(0, adb_socketpair(cause_close_fd)); CloseWithPacketArg arg; arg.socket_fd = socket_fd[1]; arg.cause_close_fd = cause_close_fd[1]; PrepareThread(); adb_thread_t thread; ASSERT_TRUE(adb_thread_create(reinterpret_cast(CloseWithPacketThreadFunc), &arg, &thread)); // Wait until the fdevent_loop() starts. adb_sleep_ms(100); ASSERT_EQ(0, adb_close(cause_close_fd[0])); adb_sleep_ms(100); EXPECT_EQ(2u, fdevent_installed_count()); ASSERT_EQ(0, adb_close(socket_fd[0])); TerminateThread(thread); } // This test checks if we can read packets from a closing local socket. TEST_F(LocalSocketTest, read_from_closing_socket) { int socket_fd[2]; ASSERT_EQ(0, adb_socketpair(socket_fd)); int cause_close_fd[2]; ASSERT_EQ(0, adb_socketpair(cause_close_fd)); CloseWithPacketArg arg; arg.socket_fd = socket_fd[1]; arg.cause_close_fd = cause_close_fd[1]; PrepareThread(); adb_thread_t thread; ASSERT_TRUE(adb_thread_create(reinterpret_cast(CloseWithPacketThreadFunc), &arg, &thread)); // Wait until the fdevent_loop() starts. adb_sleep_ms(100); ASSERT_EQ(0, adb_close(cause_close_fd[0])); adb_sleep_ms(100); EXPECT_EQ(2u, fdevent_installed_count()); // Verify if we can read successfully. std::vector buf(arg.bytes_written); ASSERT_NE(0u, arg.bytes_written); ASSERT_EQ(true, ReadFdExactly(socket_fd[0], buf.data(), buf.size())); ASSERT_EQ(0, adb_close(socket_fd[0])); TerminateThread(thread); } // This test checks if we can close local socket in the following situation: // The socket is not closed and has some packets. When it fails to write to // the socket's file handler because the other end is closed, we check if the // socket is closed. TEST_F(LocalSocketTest, write_error_when_having_packets) { int socket_fd[2]; ASSERT_EQ(0, adb_socketpair(socket_fd)); int cause_close_fd[2]; ASSERT_EQ(0, adb_socketpair(cause_close_fd)); CloseWithPacketArg arg; arg.socket_fd = socket_fd[1]; arg.cause_close_fd = cause_close_fd[1]; PrepareThread(); adb_thread_t thread; ASSERT_TRUE(adb_thread_create(reinterpret_cast(CloseWithPacketThreadFunc), &arg, &thread)); // Wait until the fdevent_loop() starts. adb_sleep_ms(100); EXPECT_EQ(3u, fdevent_installed_count()); ASSERT_EQ(0, adb_close(socket_fd[0])); TerminateThread(thread); } #if defined(__linux__) static void ClientThreadFunc() { std::string error; int fd = network_loopback_client(5038, SOCK_STREAM, &error); ASSERT_GE(fd, 0) << error; adb_sleep_ms(200); ASSERT_EQ(0, adb_close(fd)); } struct CloseRdHupSocketArg { int socket_fd; }; static void CloseRdHupSocketThreadFunc(CloseRdHupSocketArg* arg) { asocket* s = create_local_socket(arg->socket_fd); ASSERT_TRUE(s != nullptr); fdevent_loop(); } // This test checks if we can close sockets in CLOSE_WAIT state. TEST_F(LocalSocketTest, close_socket_in_CLOSE_WAIT_state) { std::string error; int listen_fd = network_inaddr_any_server(5038, SOCK_STREAM, &error); ASSERT_GE(listen_fd, 0); adb_thread_t client_thread; ASSERT_TRUE(adb_thread_create(reinterpret_cast(ClientThreadFunc), nullptr, &client_thread)); struct sockaddr addr; socklen_t alen; alen = sizeof(addr); int accept_fd = adb_socket_accept(listen_fd, &addr, &alen); ASSERT_GE(accept_fd, 0); CloseRdHupSocketArg arg; arg.socket_fd = accept_fd; PrepareThread(); adb_thread_t thread; ASSERT_TRUE(adb_thread_create(reinterpret_cast(CloseRdHupSocketThreadFunc), &arg, &thread)); // Wait until the fdevent_loop() starts. adb_sleep_ms(100); EXPECT_EQ(2u, fdevent_installed_count()); // Wait until the client closes its socket. ASSERT_TRUE(adb_thread_join(client_thread)); TerminateThread(thread); } #endif // defined(__linux__) #if ADB_HOST // Checks that skip_host_serial(serial) returns a pointer to the part of |serial| which matches // |expected|, otherwise logs the failure to gtest. void VerifySkipHostSerial(const std::string& serial, const char* expected) { const char* result = internal::skip_host_serial(serial.c_str()); if (expected == nullptr) { EXPECT_EQ(nullptr, result); } else { EXPECT_STREQ(expected, result); } } // Check [tcp:|udp:][:]: format. TEST(socket_test, test_skip_host_serial) { for (const std::string& protocol : {"", "tcp:", "udp:"}) { VerifySkipHostSerial(protocol, nullptr); VerifySkipHostSerial(protocol + "foo", nullptr); VerifySkipHostSerial(protocol + "foo:bar", ":bar"); VerifySkipHostSerial(protocol + "foo:bar:baz", ":bar:baz"); VerifySkipHostSerial(protocol + "foo:123:bar", ":bar"); VerifySkipHostSerial(protocol + "foo:123:456", ":456"); VerifySkipHostSerial(protocol + "foo:123:bar:baz", ":bar:baz"); // Don't register a port unless it's all numbers and ends with ':'. VerifySkipHostSerial(protocol + "foo:123", ":123"); VerifySkipHostSerial(protocol + "foo:123bar:baz", ":123bar:baz"); } } // Check :: format. TEST(socket_test, test_skip_host_serial_prefix) { for (const std::string& prefix : {"usb:", "product:", "model:", "device:"}) { VerifySkipHostSerial(prefix, nullptr); VerifySkipHostSerial(prefix + "foo", nullptr); VerifySkipHostSerial(prefix + "foo:bar", ":bar"); VerifySkipHostSerial(prefix + "foo:bar:baz", ":bar:baz"); VerifySkipHostSerial(prefix + "foo:123:bar", ":123:bar"); } } #endif // ADB_HOST adb/sockets.cpp0100644 0000000 0000000 00000061234 12767234553 012536 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG SOCKETS #include "sysdeps.h" #include #include #include #include #include #include #include #include #include #include #if !ADB_HOST #include "cutils/properties.h" #endif #include "adb.h" #include "adb_io.h" #include "sysdeps/mutex.h" #include "transport.h" static std::recursive_mutex& local_socket_list_lock = *new std::recursive_mutex(); static unsigned local_socket_next_id = 1; static asocket local_socket_list = { .next = &local_socket_list, .prev = &local_socket_list, }; /* the the list of currently closing local sockets. ** these have no peer anymore, but still packets to ** write to their fd. */ static asocket local_socket_closing_list = { .next = &local_socket_closing_list, .prev = &local_socket_closing_list, }; // Parse the global list of sockets to find one with id |local_id|. // If |peer_id| is not 0, also check that it is connected to a peer // with id |peer_id|. Returns an asocket handle on success, NULL on failure. asocket* find_local_socket(unsigned local_id, unsigned peer_id) { asocket* s; asocket* result = NULL; std::lock_guard lock(local_socket_list_lock); for (s = local_socket_list.next; s != &local_socket_list; s = s->next) { if (s->id != local_id) { continue; } if (peer_id == 0 || (s->peer && s->peer->id == peer_id)) { result = s; } break; } return result; } static void insert_local_socket(asocket* s, asocket* list) { s->next = list; s->prev = s->next->prev; s->prev->next = s; s->next->prev = s; } void install_local_socket(asocket* s) { std::lock_guard lock(local_socket_list_lock); s->id = local_socket_next_id++; // Socket ids should never be 0. if (local_socket_next_id == 0) { fatal("local socket id overflow"); } insert_local_socket(s, &local_socket_list); } void remove_socket(asocket* s) { // socket_list_lock should already be held if (s->prev && s->next) { s->prev->next = s->next; s->next->prev = s->prev; s->next = 0; s->prev = 0; s->id = 0; } } void close_all_sockets(atransport* t) { asocket* s; /* this is a little gross, but since s->close() *will* modify ** the list out from under you, your options are limited. */ std::lock_guard lock(local_socket_list_lock); restart: for (s = local_socket_list.next; s != &local_socket_list; s = s->next) { if (s->transport == t || (s->peer && s->peer->transport == t)) { s->close(s); goto restart; } } } static int local_socket_enqueue(asocket* s, apacket* p) { D("LS(%d): enqueue %d", s->id, p->len); p->ptr = p->data; /* if there is already data queue'd, we will receive ** events when it's time to write. just add this to ** the tail */ if (s->pkt_first) { goto enqueue; } /* write as much as we can, until we ** would block or there is an error/eof */ while (p->len > 0) { int r = adb_write(s->fd, p->ptr, p->len); if (r > 0) { p->len -= r; p->ptr += r; continue; } if ((r == 0) || (errno != EAGAIN)) { D("LS(%d): not ready, errno=%d: %s", s->id, errno, strerror(errno)); put_apacket(p); s->has_write_error = true; s->close(s); return 1; /* not ready (error) */ } else { break; } } if (p->len == 0) { put_apacket(p); return 0; /* ready for more data */ } enqueue: p->next = 0; if (s->pkt_first) { s->pkt_last->next = p; } else { s->pkt_first = p; } s->pkt_last = p; /* make sure we are notified when we can drain the queue */ fdevent_add(&s->fde, FDE_WRITE); return 1; /* not ready (backlog) */ } static void local_socket_ready(asocket* s) { /* far side is ready for data, pay attention to readable events */ fdevent_add(&s->fde, FDE_READ); } // be sure to hold the socket list lock when calling this static void local_socket_destroy(asocket* s) { apacket *p, *n; int exit_on_close = s->exit_on_close; D("LS(%d): destroying fde.fd=%d", s->id, s->fde.fd); /* IMPORTANT: the remove closes the fd ** that belongs to this socket */ fdevent_remove(&s->fde); /* dispose of any unwritten data */ for (p = s->pkt_first; p; p = n) { D("LS(%d): discarding %d bytes", s->id, p->len); n = p->next; put_apacket(p); } remove_socket(s); free(s); if (exit_on_close) { D("local_socket_destroy: exiting"); exit(1); } } static void local_socket_close(asocket* s) { D("entered local_socket_close. LS(%d) fd=%d", s->id, s->fd); std::lock_guard lock(local_socket_list_lock); if (s->peer) { D("LS(%d): closing peer. peer->id=%d peer->fd=%d", s->id, s->peer->id, s->peer->fd); /* Note: it's important to call shutdown before disconnecting from * the peer, this ensures that remote sockets can still get the id * of the local socket they're connected to, to send a CLOSE() * protocol event. */ if (s->peer->shutdown) { s->peer->shutdown(s->peer); } s->peer->peer = nullptr; s->peer->close(s->peer); s->peer = nullptr; } /* If we are already closing, or if there are no ** pending packets, destroy immediately */ if (s->closing || s->has_write_error || s->pkt_first == NULL) { int id = s->id; local_socket_destroy(s); D("LS(%d): closed", id); return; } /* otherwise, put on the closing list */ D("LS(%d): closing", s->id); s->closing = 1; fdevent_del(&s->fde, FDE_READ); remove_socket(s); D("LS(%d): put on socket_closing_list fd=%d", s->id, s->fd); insert_local_socket(s, &local_socket_closing_list); CHECK_EQ(FDE_WRITE, s->fde.state & FDE_WRITE); } static void local_socket_event_func(int fd, unsigned ev, void* _s) { asocket* s = reinterpret_cast(_s); D("LS(%d): event_func(fd=%d(==%d), ev=%04x)", s->id, s->fd, fd, ev); /* put the FDE_WRITE processing before the FDE_READ ** in order to simplify the code. */ if (ev & FDE_WRITE) { apacket* p; while ((p = s->pkt_first) != nullptr) { while (p->len > 0) { int r = adb_write(fd, p->ptr, p->len); if (r == -1) { /* returning here is ok because FDE_READ will ** be processed in the next iteration loop */ if (errno == EAGAIN) { return; } } else if (r > 0) { p->ptr += r; p->len -= r; continue; } D(" closing after write because r=%d and errno is %d", r, errno); s->has_write_error = true; s->close(s); return; } if (p->len == 0) { s->pkt_first = p->next; if (s->pkt_first == 0) { s->pkt_last = 0; } put_apacket(p); } } /* if we sent the last packet of a closing socket, ** we can now destroy it. */ if (s->closing) { D(" closing because 'closing' is set after write"); s->close(s); return; } /* no more packets queued, so we can ignore ** writable events again and tell our peer ** to resume writing */ fdevent_del(&s->fde, FDE_WRITE); s->peer->ready(s->peer); } if (ev & FDE_READ) { apacket* p = get_apacket(); unsigned char* x = p->data; const size_t max_payload = s->get_max_payload(); size_t avail = max_payload; int r = 0; int is_eof = 0; while (avail > 0) { r = adb_read(fd, x, avail); D("LS(%d): post adb_read(fd=%d,...) r=%d (errno=%d) avail=%zu", s->id, s->fd, r, r < 0 ? errno : 0, avail); if (r == -1) { if (errno == EAGAIN) { break; } } else if (r > 0) { avail -= r; x += r; continue; } /* r = 0 or unhandled error */ is_eof = 1; break; } D("LS(%d): fd=%d post avail loop. r=%d is_eof=%d forced_eof=%d", s->id, s->fd, r, is_eof, s->fde.force_eof); if ((avail == max_payload) || (s->peer == 0)) { put_apacket(p); } else { p->len = max_payload - avail; // s->peer->enqueue() may call s->close() and free s, // so save variables for debug printing below. unsigned saved_id = s->id; int saved_fd = s->fd; r = s->peer->enqueue(s->peer, p); D("LS(%u): fd=%d post peer->enqueue(). r=%d", saved_id, saved_fd, r); if (r < 0) { /* error return means they closed us as a side-effect ** and we must return immediately. ** ** note that if we still have buffered packets, the ** socket will be placed on the closing socket list. ** this handler function will be called again ** to process FDE_WRITE events. */ return; } if (r > 0) { /* if the remote cannot accept further events, ** we disable notification of READs. They'll ** be enabled again when we get a call to ready() */ fdevent_del(&s->fde, FDE_READ); } } /* Don't allow a forced eof if data is still there */ if ((s->fde.force_eof && !r) || is_eof) { D(" closing because is_eof=%d r=%d s->fde.force_eof=%d", is_eof, r, s->fde.force_eof); s->close(s); return; } } if (ev & FDE_ERROR) { /* this should be caught be the next read or write ** catching it here means we may skip the last few ** bytes of readable data. */ D("LS(%d): FDE_ERROR (fd=%d)", s->id, s->fd); return; } } asocket* create_local_socket(int fd) { asocket* s = reinterpret_cast(calloc(1, sizeof(asocket))); if (s == NULL) { fatal("cannot allocate socket"); } s->fd = fd; s->enqueue = local_socket_enqueue; s->ready = local_socket_ready; s->shutdown = NULL; s->close = local_socket_close; install_local_socket(s); fdevent_install(&s->fde, fd, local_socket_event_func, s); D("LS(%d): created (fd=%d)", s->id, s->fd); return s; } asocket* create_local_service_socket(const char* name, const atransport* transport) { #if !ADB_HOST if (!strcmp(name, "jdwp")) { return create_jdwp_service_socket(); } if (!strcmp(name, "track-jdwp")) { return create_jdwp_tracker_service_socket(); } #endif int fd = service_to_fd(name, transport); if (fd < 0) { return 0; } asocket* s = create_local_socket(fd); D("LS(%d): bound to '%s' via %d", s->id, name, fd); #if !ADB_HOST char debug[PROPERTY_VALUE_MAX]; if (!strncmp(name, "root:", 5)) { property_get("ro.debuggable", debug, ""); } if ((!strncmp(name, "root:", 5) && getuid() != 0 && strcmp(debug, "1") == 0) || (!strncmp(name, "unroot:", 7) && getuid() == 0) || !strncmp(name, "usb:", 4) || !strncmp(name, "tcpip:", 6)) { D("LS(%d): enabling exit_on_close", s->id); s->exit_on_close = 1; } #endif return s; } #if ADB_HOST static asocket* create_host_service_socket(const char* name, const char* serial) { asocket* s; s = host_service_to_socket(name, serial); if (s != NULL) { D("LS(%d) bound to '%s'", s->id, name); return s; } return s; } #endif /* ADB_HOST */ static int remote_socket_enqueue(asocket* s, apacket* p) { D("entered remote_socket_enqueue RS(%d) WRITE fd=%d peer.fd=%d", s->id, s->fd, s->peer->fd); p->msg.command = A_WRTE; p->msg.arg0 = s->peer->id; p->msg.arg1 = s->id; p->msg.data_length = p->len; send_packet(p, s->transport); return 1; } static void remote_socket_ready(asocket* s) { D("entered remote_socket_ready RS(%d) OKAY fd=%d peer.fd=%d", s->id, s->fd, s->peer->fd); apacket* p = get_apacket(); p->msg.command = A_OKAY; p->msg.arg0 = s->peer->id; p->msg.arg1 = s->id; send_packet(p, s->transport); } static void remote_socket_shutdown(asocket* s) { D("entered remote_socket_shutdown RS(%d) CLOSE fd=%d peer->fd=%d", s->id, s->fd, s->peer ? s->peer->fd : -1); apacket* p = get_apacket(); p->msg.command = A_CLSE; if (s->peer) { p->msg.arg0 = s->peer->id; } p->msg.arg1 = s->id; send_packet(p, s->transport); } static void remote_socket_close(asocket* s) { if (s->peer) { s->peer->peer = 0; D("RS(%d) peer->close()ing peer->id=%d peer->fd=%d", s->id, s->peer->id, s->peer->fd); s->peer->close(s->peer); } D("entered remote_socket_close RS(%d) CLOSE fd=%d peer->fd=%d", s->id, s->fd, s->peer ? s->peer->fd : -1); D("RS(%d): closed", s->id); free(s); } // Create a remote socket to exchange packets with a remote service through transport // |t|. Where |id| is the socket id of the corresponding service on the other // side of the transport (it is allocated by the remote side and _cannot_ be 0). // Returns a new non-NULL asocket handle. asocket* create_remote_socket(unsigned id, atransport* t) { if (id == 0) { fatal("invalid remote socket id (0)"); } asocket* s = reinterpret_cast(calloc(1, sizeof(asocket))); if (s == NULL) { fatal("cannot allocate socket"); } s->id = id; s->enqueue = remote_socket_enqueue; s->ready = remote_socket_ready; s->shutdown = remote_socket_shutdown; s->close = remote_socket_close; s->transport = t; D("RS(%d): created", s->id); return s; } void connect_to_remote(asocket* s, const char* destination) { D("Connect_to_remote call RS(%d) fd=%d", s->id, s->fd); apacket* p = get_apacket(); size_t len = strlen(destination) + 1; if (len > (s->get_max_payload() - 1)) { fatal("destination oversized"); } D("LS(%d): connect('%s')", s->id, destination); p->msg.command = A_OPEN; p->msg.arg0 = s->id; p->msg.data_length = len; strcpy((char*)p->data, destination); send_packet(p, s->transport); } /* this is used by magic sockets to rig local sockets to send the go-ahead message when they connect */ static void local_socket_ready_notify(asocket* s) { s->ready = local_socket_ready; s->shutdown = NULL; s->close = local_socket_close; SendOkay(s->fd); s->ready(s); } /* this is used by magic sockets to rig local sockets to send the failure message if they are closed before connected (to avoid closing them without a status message) */ static void local_socket_close_notify(asocket* s) { s->ready = local_socket_ready; s->shutdown = NULL; s->close = local_socket_close; SendFail(s->fd, "closed"); s->close(s); } static unsigned unhex(unsigned char* s, int len) { unsigned n = 0, c; while (len-- > 0) { switch ((c = *s++)) { case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': c -= '0'; break; case 'a': case 'b': case 'c': case 'd': case 'e': case 'f': c = c - 'a' + 10; break; case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': c = c - 'A' + 10; break; default: return 0xffffffff; } n = (n << 4) | c; } return n; } #if ADB_HOST namespace internal { // Returns the position in |service| following the target serial parameter. Serial format can be // any of: // * [tcp:|udp:][:]: // * :: // Where must be a base-10 number and may be any of {usb,product,model,device}. // // The returned pointer will point to the ':' just before , or nullptr if not found. char* skip_host_serial(const char* service) { static const std::vector& prefixes = *(new std::vector{"usb:", "product:", "model:", "device:"}); for (const std::string& prefix : prefixes) { if (!strncmp(service, prefix.c_str(), prefix.length())) { return strchr(service + prefix.length(), ':'); } } // For fastboot compatibility, ignore protocol prefixes. if (!strncmp(service, "tcp:", 4) || !strncmp(service, "udp:", 4)) { service += 4; } char* first_colon = strchr(service, ':'); if (!first_colon) { // No colon in service string. return nullptr; } char* serial_end = first_colon; if (isdigit(serial_end[1])) { serial_end++; while (*serial_end && isdigit(*serial_end)) { serial_end++; } if (*serial_end != ':') { // Something other than numbers was found, reset the end. serial_end = first_colon; } } return serial_end; } } // namespace internal #endif // ADB_HOST static int smart_socket_enqueue(asocket* s, apacket* p) { unsigned len; #if ADB_HOST char* service = nullptr; char* serial = nullptr; TransportType type = kTransportAny; #endif D("SS(%d): enqueue %d", s->id, p->len); if (s->pkt_first == 0) { s->pkt_first = p; s->pkt_last = p; } else { if ((s->pkt_first->len + p->len) > s->get_max_payload()) { D("SS(%d): overflow", s->id); put_apacket(p); goto fail; } memcpy(s->pkt_first->data + s->pkt_first->len, p->data, p->len); s->pkt_first->len += p->len; put_apacket(p); p = s->pkt_first; } /* don't bother if we can't decode the length */ if (p->len < 4) { return 0; } len = unhex(p->data, 4); if ((len < 1) || (len > MAX_PAYLOAD_V1)) { D("SS(%d): bad size (%d)", s->id, len); goto fail; } D("SS(%d): len is %d", s->id, len); /* can't do anything until we have the full header */ if ((len + 4) > p->len) { D("SS(%d): waiting for %d more bytes", s->id, len + 4 - p->len); return 0; } p->data[len + 4] = 0; D("SS(%d): '%s'", s->id, (char*)(p->data + 4)); #if ADB_HOST service = (char*)p->data + 4; if (!strncmp(service, "host-serial:", strlen("host-serial:"))) { char* serial_end; service += strlen("host-serial:"); // serial number should follow "host:" and could be a host:port string. serial_end = internal::skip_host_serial(service); if (serial_end) { *serial_end = 0; // terminate string serial = service; service = serial_end + 1; } } else if (!strncmp(service, "host-usb:", strlen("host-usb:"))) { type = kTransportUsb; service += strlen("host-usb:"); } else if (!strncmp(service, "host-local:", strlen("host-local:"))) { type = kTransportLocal; service += strlen("host-local:"); } else if (!strncmp(service, "host:", strlen("host:"))) { type = kTransportAny; service += strlen("host:"); } else { service = nullptr; } if (service) { asocket* s2; /* some requests are handled immediately -- in that ** case the handle_host_request() routine has sent ** the OKAY or FAIL message and all we have to do ** is clean up. */ if (handle_host_request(service, type, serial, s->peer->fd, s) == 0) { /* XXX fail message? */ D("SS(%d): handled host service '%s'", s->id, service); goto fail; } if (!strncmp(service, "transport", strlen("transport"))) { D("SS(%d): okay transport", s->id); p->len = 0; return 0; } /* try to find a local service with this name. ** if no such service exists, we'll fail out ** and tear down here. */ s2 = create_host_service_socket(service, serial); if (s2 == 0) { D("SS(%d): couldn't create host service '%s'", s->id, service); SendFail(s->peer->fd, "unknown host service"); goto fail; } /* we've connected to a local host service, ** so we make our peer back into a regular ** local socket and bind it to the new local ** service socket, acknowledge the successful ** connection, and close this smart socket now ** that its work is done. */ SendOkay(s->peer->fd); s->peer->ready = local_socket_ready; s->peer->shutdown = nullptr; s->peer->close = local_socket_close; s->peer->peer = s2; s2->peer = s->peer; s->peer = 0; D("SS(%d): okay", s->id); s->close(s); /* initial state is "ready" */ s2->ready(s2); return 0; } #else /* !ADB_HOST */ if (s->transport == nullptr) { std::string error_msg = "unknown failure"; s->transport = acquire_one_transport(kTransportAny, nullptr, nullptr, &error_msg); if (s->transport == nullptr) { SendFail(s->peer->fd, error_msg); goto fail; } } #endif if (!(s->transport) || (s->transport->connection_state == kCsOffline)) { /* if there's no remote we fail the connection ** right here and terminate it */ SendFail(s->peer->fd, "device offline (x)"); goto fail; } /* instrument our peer to pass the success or fail ** message back once it connects or closes, then ** detach from it, request the connection, and ** tear down */ s->peer->ready = local_socket_ready_notify; s->peer->shutdown = nullptr; s->peer->close = local_socket_close_notify; s->peer->peer = 0; /* give him our transport and upref it */ s->peer->transport = s->transport; connect_to_remote(s->peer, (char*)(p->data + 4)); s->peer = 0; s->close(s); return 1; fail: /* we're going to close our peer as a side-effect, so ** return -1 to signal that state to the local socket ** who is enqueueing against us */ s->close(s); return -1; } static void smart_socket_ready(asocket* s) { D("SS(%d): ready", s->id); } static void smart_socket_close(asocket* s) { D("SS(%d): closed", s->id); if (s->pkt_first) { put_apacket(s->pkt_first); } if (s->peer) { s->peer->peer = 0; s->peer->close(s->peer); s->peer = 0; } free(s); } static asocket* create_smart_socket(void) { D("Creating smart socket"); asocket* s = reinterpret_cast(calloc(1, sizeof(asocket))); if (s == NULL) fatal("cannot allocate socket"); s->enqueue = smart_socket_enqueue; s->ready = smart_socket_ready; s->shutdown = NULL; s->close = smart_socket_close; D("SS(%d)", s->id); return s; } void connect_to_smartsocket(asocket* s) { D("Connecting to smart socket"); asocket* ss = create_smart_socket(); s->peer = ss; ss->peer = s; s->ready(s); } size_t asocket::get_max_payload() const { size_t max_payload = MAX_PAYLOAD; if (transport) { max_payload = std::min(max_payload, transport->get_max_payload()); } if (peer && peer->transport) { max_payload = std::min(max_payload, peer->transport->get_max_payload()); } return max_payload; } adb/sockets.dia0100644 0000000 0000000 00000004435 12767234553 012511 0ustar000000000 0000000 ]K6ϯ<@"etHE!K.mӶvdKK~Rw^^dz>>S #/tw54,J)Q2#{v7Y՗h=ɬr0hx7yI_i̴΅t˖/M}>0QnvqLP1ih'Mn+h{iWw@rO6X¬3zu ^.a"r-&3 W\!<k|aT;lwr`ϓ+lE#V~ZJ E}>k_/;tyhۣW~]F٬o6qn7a <}4_lm&P(Y3?ȎlQSonf6rrю@hM005[U,JKGAԙŲsqQeʴ~ ."Vl Acϱ<`DP*.r ]E= V@XaV@XaV@XaXak+&PR@I%PR@IiF˚3Ih*d$MCVMed]{ }%.nzݷ V>r ^.qoJ"]e?z\,,uhBf "d>f"{(5ŠGDITT ;Ej|,rMcVu^$2kwDޭwLV8fLfU-ZW8[47X\NA e >2dl=\d'C wM { eU u@IB,72Ki(i(i(i(٤ #include #include // Include this before open/close/unlink are defined as macros below. #include #include #include /* * TEMP_FAILURE_RETRY is defined by some, but not all, versions of * . (Alas, it is not as standard as we'd hoped!) So, if it's * not already defined, then define it here. */ #ifndef TEMP_FAILURE_RETRY /* Used to retry syscalls that can return EINTR. */ #define TEMP_FAILURE_RETRY(exp) ({ \ typeof (exp) _rc; \ do { \ _rc = (exp); \ } while (_rc == -1 && errno == EINTR); \ _rc; }) #endif // Some printf-like functions are implemented in terms of // android::base::StringAppendV, so they should use the same attribute for // compile-time format string checking. On Windows, if the mingw version of // vsnprintf is used in StringAppendV, use `gnu_printf' which allows z in %zd // and PRIu64 (and related) to be recognized by the compile-time checking. #define ADB_FORMAT_ARCHETYPE __printf__ #ifdef __USE_MINGW_ANSI_STDIO #if __USE_MINGW_ANSI_STDIO #undef ADB_FORMAT_ARCHETYPE #define ADB_FORMAT_ARCHETYPE gnu_printf #endif #endif #ifdef _WIN32 // Clang-only nullability specifiers #define _Nonnull #define _Nullable #include #include #include #include #include #include #include #include #include #include #include #include #include // unique_ptr #include #include "fdevent.h" #define OS_PATH_SEPARATORS "\\/" #define OS_PATH_SEPARATOR '\\' #define OS_PATH_SEPARATOR_STR "\\" #define ENV_PATH_SEPARATOR_STR ";" static __inline__ bool adb_is_separator(char c) { return c == '\\' || c == '/'; } typedef CRITICAL_SECTION adb_mutex_t; #define ADB_MUTEX_DEFINE(x) adb_mutex_t x /* declare all mutexes */ /* For win32, adb_sysdeps_init() will do the mutex runtime initialization. */ #define ADB_MUTEX(x) extern adb_mutex_t x; #include "mutex_list.h" extern void adb_sysdeps_init(void); static __inline__ void adb_mutex_lock( adb_mutex_t* lock ) { EnterCriticalSection( lock ); } static __inline__ void adb_mutex_unlock( adb_mutex_t* lock ) { LeaveCriticalSection( lock ); } typedef void (*adb_thread_func_t)(void* arg); typedef HANDLE adb_thread_t; struct adb_winthread_args { adb_thread_func_t func; void* arg; }; static unsigned __stdcall adb_winthread_wrapper(void* heap_args) { // Move the arguments from the heap onto the thread's stack. adb_winthread_args thread_args = *static_cast(heap_args); delete static_cast(heap_args); thread_args.func(thread_args.arg); return 0; } static __inline__ bool adb_thread_create(adb_thread_func_t func, void* arg, adb_thread_t* thread = nullptr) { adb_winthread_args* args = new adb_winthread_args{.func = func, .arg = arg}; uintptr_t handle = _beginthreadex(nullptr, 0, adb_winthread_wrapper, args, 0, nullptr); if (handle != static_cast(0)) { if (thread) { *thread = reinterpret_cast(handle); } else { CloseHandle(thread); } return true; } return false; } static __inline__ bool adb_thread_join(adb_thread_t thread) { switch (WaitForSingleObject(thread, INFINITE)) { case WAIT_OBJECT_0: CloseHandle(thread); return true; case WAIT_FAILED: fprintf(stderr, "adb_thread_join failed: %s\n", android::base::SystemErrorCodeToString(GetLastError()).c_str()); break; default: abort(); } return false; } static __inline__ bool adb_thread_detach(adb_thread_t thread) { CloseHandle(thread); return true; } static __inline__ void __attribute__((noreturn)) adb_thread_exit() { _endthreadex(0); } static __inline__ int adb_thread_setname(const std::string& name) { // TODO: See https://msdn.microsoft.com/en-us/library/xcb2z8hs.aspx for how to set // the thread name in Windows. Unfortunately, it only works during debugging, but // our build process doesn't generate PDB files needed for debugging. return 0; } static __inline__ adb_thread_t adb_thread_self() { return GetCurrentThread(); } static __inline__ bool adb_thread_equal(adb_thread_t lhs, adb_thread_t rhs) { return GetThreadId(lhs) == GetThreadId(rhs); } static __inline__ unsigned long adb_thread_id() { return GetCurrentThreadId(); } static __inline__ void close_on_exec(int fd) { /* nothing really */ } #define lstat stat /* no symlinks on Win32 */ #define S_ISLNK(m) 0 /* no symlinks on Win32 */ extern int adb_unlink(const char* path); #undef unlink #define unlink ___xxx_unlink extern int adb_mkdir(const std::string& path, int mode); #undef mkdir #define mkdir ___xxx_mkdir // See the comments for the !defined(_WIN32) versions of adb_*(). extern int adb_open(const char* path, int options); extern int adb_creat(const char* path, int mode); extern int adb_read(int fd, void* buf, int len); extern int adb_write(int fd, const void* buf, int len); extern int adb_lseek(int fd, int pos, int where); extern int adb_shutdown(int fd); extern int adb_close(int fd); // See the comments for the !defined(_WIN32) version of unix_close(). static __inline__ int unix_close(int fd) { return close(fd); } #undef close #define close ____xxx_close // Like unix_read(), but may return EINTR. extern int unix_read_interruptible(int fd, void* buf, size_t len); // See the comments for the !defined(_WIN32) version of unix_read(). static __inline__ int unix_read(int fd, void* buf, size_t len) { return TEMP_FAILURE_RETRY(unix_read_interruptible(fd, buf, len)); } #undef read #define read ___xxx_read // See the comments for the !defined(_WIN32) version of unix_write(). static __inline__ int unix_write(int fd, const void* buf, size_t len) { return write(fd, buf, len); } #undef write #define write ___xxx_write // See the comments for the !defined(_WIN32) version of adb_open_mode(). static __inline__ int adb_open_mode(const char* path, int options, int mode) { return adb_open(path, options); } // See the comments for the !defined(_WIN32) version of unix_open(). extern int unix_open(const char* path, int options, ...); #define open ___xxx_unix_open // Checks if |fd| corresponds to a console. // Standard Windows isatty() returns 1 for both console FDs and character // devices like NUL. unix_isatty() performs some extra checking to only match // console FDs. // |fd| must be a real file descriptor, meaning STDxx_FILENO or unix_open() FDs // will work but adb_open() FDs will not. Additionally the OS handle associated // with |fd| must have GENERIC_READ access (which console FDs have by default). // Returns 1 if |fd| is a console FD, 0 otherwise. The value of errno after // calling this function is unreliable and should not be used. int unix_isatty(int fd); #define isatty ___xxx_isatty /* normally provided by */ extern void* load_file(const char* pathname, unsigned* psize); static __inline__ void adb_sleep_ms( int mseconds ) { Sleep( mseconds ); } int network_loopback_client(int port, int type, std::string* error); int network_loopback_server(int port, int type, std::string* error); int network_inaddr_any_server(int port, int type, std::string* error); int network_connect(const std::string& host, int port, int type, int timeout, std::string* error); extern int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen); #undef accept #define accept ___xxx_accept extern int adb_setsockopt(int fd, int level, int optname, const void* optval, socklen_t optlen); #undef setsockopt #define setsockopt ___xxx_setsockopt extern int adb_socketpair( int sv[2] ); struct adb_pollfd { int fd; short events; short revents; }; extern int adb_poll(adb_pollfd* fds, size_t nfds, int timeout); #define poll ___xxx_poll static __inline__ int adb_is_absolute_host_path(const char* path) { return isalpha(path[0]) && path[1] == ':' && path[2] == '\\'; } // We later define a macro mapping 'stat' to 'adb_stat'. This causes: // struct stat s; // stat(filename, &s); // To turn into the following: // struct adb_stat s; // adb_stat(filename, &s); // To get this to work, we need to make 'struct adb_stat' the same as // 'struct stat'. Note that this definition of 'struct adb_stat' uses the // *current* macro definition of stat, so it may actually be inheriting from // struct _stat32i64 (or some other remapping). struct adb_stat : public stat {}; static_assert(sizeof(struct adb_stat) == sizeof(struct stat), "structures should be the same"); extern int adb_stat(const char* f, struct adb_stat* s); // stat is already a macro, undefine it so we can redefine it. #undef stat #define stat adb_stat // UTF-8 versions of POSIX APIs. extern DIR* adb_opendir(const char* dirname); extern struct dirent* adb_readdir(DIR* dir); extern int adb_closedir(DIR* dir); extern int adb_utime(const char *, struct utimbuf *); extern int adb_chmod(const char *, int); extern int adb_vfprintf(FILE *stream, const char *format, va_list ap) __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 2, 0))); extern int adb_vprintf(const char *format, va_list ap) __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 1, 0))); extern int adb_fprintf(FILE *stream, const char *format, ...) __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 2, 3))); extern int adb_printf(const char *format, ...) __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 1, 2))); extern int adb_fputs(const char* buf, FILE* stream); extern int adb_fputc(int ch, FILE* stream); extern int adb_putchar(int ch); extern int adb_puts(const char* buf); extern size_t adb_fwrite(const void* ptr, size_t size, size_t nmemb, FILE* stream); extern FILE* adb_fopen(const char* f, const char* m); extern char* adb_getenv(const char* name); extern char* adb_getcwd(char* buf, int size); // Remap calls to POSIX APIs to our UTF-8 versions. #define opendir adb_opendir #define readdir adb_readdir #define closedir adb_closedir #define rewinddir rewinddir_utf8_not_yet_implemented #define telldir telldir_utf8_not_yet_implemented // Some compiler's C++ headers have members named seekdir, so we can't do the // macro technique and instead cause a link error if seekdir is called. inline void seekdir(DIR*, long) { extern int seekdir_utf8_not_yet_implemented; seekdir_utf8_not_yet_implemented = 1; } #define utime adb_utime #define chmod adb_chmod #define vfprintf adb_vfprintf #define vprintf adb_vprintf #define fprintf adb_fprintf #define printf adb_printf #define fputs adb_fputs #define fputc adb_fputc // putc may be a macro, so if so, undefine it, so that we can redefine it. #undef putc #define putc(c, s) adb_fputc(c, s) #define putchar adb_putchar #define puts adb_puts #define fwrite adb_fwrite #define fopen adb_fopen #define freopen freopen_utf8_not_yet_implemented #define getenv adb_getenv #define putenv putenv_utf8_not_yet_implemented #define setenv setenv_utf8_not_yet_implemented #define unsetenv unsetenv_utf8_not_yet_implemented #define getcwd adb_getcwd char* adb_strerror(int err); #define strerror adb_strerror // Helper class to convert UTF-16 argv from wmain() to UTF-8 args that can be // passed to main(). class NarrowArgs { public: NarrowArgs(int argc, wchar_t** argv); ~NarrowArgs(); inline char** data() { return narrow_args; } private: char** narrow_args; }; // Windows HANDLE values only use 32-bits of the type, even on 64-bit machines, // so they can fit in an int. To convert back, we just need to sign-extend. // https://msdn.microsoft.com/en-us/library/windows/desktop/aa384203%28v=vs.85%29.aspx // Note that this does not make a HANDLE value work with APIs like open(), nor // does this make a value from open() passable to APIs taking a HANDLE. This // just lets you take a HANDLE, pass it around as an int, and then use it again // as a HANDLE. inline int cast_handle_to_int(const HANDLE h) { // truncate return static_cast(reinterpret_cast(h)); } inline HANDLE cast_int_to_handle(const int fd) { // sign-extend return reinterpret_cast(static_cast(fd)); } // Deleter for unique_handle. Adapted from many sources, including: // http://stackoverflow.com/questions/14841396/stdunique-ptr-deleters-and-the-win32-api // https://visualstudiomagazine.com/articles/2013/09/01/get-a-handle-on-the-windows-api.aspx class handle_deleter { public: typedef HANDLE pointer; void operator()(HANDLE h); }; // Like std::unique_ptr, but for Windows HANDLE objects that should be // CloseHandle()'d. Operator bool() only checks if the handle != nullptr, // but does not check if the handle != INVALID_HANDLE_VALUE. typedef std::unique_ptr unique_handle; namespace internal { size_t ParseCompleteUTF8(const char* first, const char* last, std::vector* remaining_bytes); } #else /* !_WIN32 a.k.a. Unix */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define OS_PATH_SEPARATORS "/" #define OS_PATH_SEPARATOR '/' #define OS_PATH_SEPARATOR_STR "/" #define ENV_PATH_SEPARATOR_STR ":" static __inline__ bool adb_is_separator(char c) { return c == '/'; } typedef pthread_mutex_t adb_mutex_t; #define ADB_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER #define adb_mutex_init pthread_mutex_init #define adb_mutex_lock pthread_mutex_lock #define adb_mutex_unlock pthread_mutex_unlock #define adb_mutex_destroy pthread_mutex_destroy #define ADB_MUTEX_DEFINE(m) adb_mutex_t m = PTHREAD_MUTEX_INITIALIZER #define adb_cond_t pthread_cond_t #define adb_cond_init pthread_cond_init #define adb_cond_wait pthread_cond_wait #define adb_cond_broadcast pthread_cond_broadcast #define adb_cond_signal pthread_cond_signal #define adb_cond_destroy pthread_cond_destroy /* declare all mutexes */ #define ADB_MUTEX(x) extern adb_mutex_t x; #include "mutex_list.h" static __inline__ void close_on_exec(int fd) { fcntl( fd, F_SETFD, FD_CLOEXEC ); } // Open a file and return a file descriptor that may be used with unix_read(), // unix_write(), unix_close(), but not adb_read(), adb_write(), adb_close(). // // On Unix, this is based on open(), so the file descriptor is a real OS file // descriptor, but the Windows implementation (in sysdeps_win32.cpp) returns a // file descriptor that can only be used with C Runtime APIs (which are wrapped // by unix_read(), unix_write(), unix_close()). Also, the C Runtime has // configurable CR/LF translation which defaults to text mode, but is settable // with _setmode(). static __inline__ int unix_open(const char* path, int options,...) { if ((options & O_CREAT) == 0) { return TEMP_FAILURE_RETRY( open(path, options) ); } else { int mode; va_list args; va_start( args, options ); mode = va_arg( args, int ); va_end( args ); return TEMP_FAILURE_RETRY( open( path, options, mode ) ); } } // Similar to the two-argument adb_open(), but takes a mode parameter for file // creation. See adb_open() for more info. static __inline__ int adb_open_mode( const char* pathname, int options, int mode ) { return TEMP_FAILURE_RETRY( open( pathname, options, mode ) ); } // Open a file and return a file descriptor that may be used with adb_read(), // adb_write(), adb_close(), but not unix_read(), unix_write(), unix_close(). // // On Unix, this is based on open(), but the Windows implementation (in // sysdeps_win32.cpp) uses Windows native file I/O and bypasses the C Runtime // and its CR/LF translation. The returned file descriptor should be used with // adb_read(), adb_write(), adb_close(), etc. static __inline__ int adb_open( const char* pathname, int options ) { int fd = TEMP_FAILURE_RETRY( open( pathname, options ) ); if (fd < 0) return -1; close_on_exec( fd ); return fd; } #undef open #define open ___xxx_open static __inline__ int adb_shutdown(int fd) { return shutdown(fd, SHUT_RDWR); } static __inline__ int adb_shutdown(int fd, int direction) { return shutdown(fd, direction); } #undef shutdown #define shutdown ____xxx_shutdown // Closes a file descriptor that came from adb_open() or adb_open_mode(), but // not designed to take a file descriptor from unix_open(). See the comments // for adb_open() for more info. __inline__ int adb_close(int fd) { return close(fd); } #undef close #define close ____xxx_close static __inline__ int adb_read(int fd, void* buf, size_t len) { return TEMP_FAILURE_RETRY( read( fd, buf, len ) ); } // Like unix_read(), but does not handle EINTR. static __inline__ int unix_read_interruptible(int fd, void* buf, size_t len) { return read(fd, buf, len); } #undef read #define read ___xxx_read static __inline__ int adb_write(int fd, const void* buf, size_t len) { return TEMP_FAILURE_RETRY( write( fd, buf, len ) ); } #undef write #define write ___xxx_write static __inline__ int adb_lseek(int fd, int pos, int where) { return lseek(fd, pos, where); } #undef lseek #define lseek ___xxx_lseek static __inline__ int adb_unlink(const char* path) { return unlink(path); } #undef unlink #define unlink ___xxx_unlink static __inline__ int adb_creat(const char* path, int mode) { int fd = TEMP_FAILURE_RETRY( creat( path, mode ) ); if ( fd < 0 ) return -1; close_on_exec(fd); return fd; } #undef creat #define creat ___xxx_creat static __inline__ int unix_isatty(int fd) { return isatty(fd); } #define isatty ___xxx_isatty // Helper for network_* functions. inline int _fd_set_error_str(int fd, std::string* error) { if (fd == -1) { *error = strerror(errno); } return fd; } inline int network_loopback_client(int port, int type, std::string* error) { return _fd_set_error_str(socket_loopback_client(port, type), error); } inline int network_loopback_server(int port, int type, std::string* error) { return _fd_set_error_str(socket_loopback_server(port, type), error); } inline int network_inaddr_any_server(int port, int type, std::string* error) { return _fd_set_error_str(socket_inaddr_any_server(port, type), error); } inline int network_local_server(const char *name, int namespace_id, int type, std::string* error) { return _fd_set_error_str(socket_local_server(name, namespace_id, type), error); } inline int network_connect(const std::string& host, int port, int type, int timeout, std::string* error) { int getaddrinfo_error = 0; int fd = socket_network_client_timeout(host.c_str(), port, type, timeout, &getaddrinfo_error); if (fd != -1) { return fd; } if (getaddrinfo_error != 0) { *error = gai_strerror(getaddrinfo_error); } else { *error = strerror(errno); } return -1; } static __inline__ int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen) { int fd; fd = TEMP_FAILURE_RETRY( accept( serverfd, addr, addrlen ) ); if (fd >= 0) close_on_exec(fd); return fd; } #undef accept #define accept ___xxx_accept // Operate on a file descriptor returned from unix_open() or a well-known file // descriptor such as STDIN_FILENO, STDOUT_FILENO, STDERR_FILENO. // // On Unix, unix_read(), unix_write(), unix_close() map to adb_read(), // adb_write(), adb_close() (which all map to Unix system calls), but the // Windows implementations (in the ifdef above and in sysdeps_win32.cpp) call // into the C Runtime and its configurable CR/LF translation (which is settable // via _setmode()). #define unix_read adb_read #define unix_write adb_write #define unix_close adb_close // Win32 is limited to DWORDs for thread return values; limit the POSIX systems to this as well to // ensure compatibility. typedef void (*adb_thread_func_t)(void* arg); typedef pthread_t adb_thread_t; struct adb_pthread_args { adb_thread_func_t func; void* arg; }; static void* adb_pthread_wrapper(void* heap_args) { // Move the arguments from the heap onto the thread's stack. adb_pthread_args thread_args = *reinterpret_cast(heap_args); delete static_cast(heap_args); thread_args.func(thread_args.arg); return nullptr; } static __inline__ bool adb_thread_create(adb_thread_func_t start, void* arg, adb_thread_t* thread = nullptr) { pthread_t temp; pthread_attr_t attr; pthread_attr_init(&attr); pthread_attr_setdetachstate(&attr, thread ? PTHREAD_CREATE_JOINABLE : PTHREAD_CREATE_DETACHED); auto* pthread_args = new adb_pthread_args{.func = start, .arg = arg}; errno = pthread_create(&temp, &attr, adb_pthread_wrapper, pthread_args); if (errno == 0) { if (thread) { *thread = temp; } return true; } return false; } static __inline__ bool adb_thread_join(adb_thread_t thread) { errno = pthread_join(thread, nullptr); return errno == 0; } static __inline__ bool adb_thread_detach(adb_thread_t thread) { errno = pthread_detach(thread); return errno == 0; } static __inline__ void __attribute__((noreturn)) adb_thread_exit() { pthread_exit(nullptr); } static __inline__ int adb_thread_setname(const std::string& name) { #ifdef __APPLE__ return pthread_setname_np(name.c_str()); #else const char *s = name.c_str(); // pthread_setname_np fails rather than truncating long strings. const int max_task_comm_len = 16; // including the null terminator if (name.length() > (max_task_comm_len - 1)) { char buf[max_task_comm_len]; strncpy(buf, name.c_str(), sizeof(buf) - 1); buf[sizeof(buf) - 1] = '\0'; s = buf; } return pthread_setname_np(pthread_self(), s) ; #endif } static __inline__ int adb_setsockopt( int fd, int level, int optname, const void* optval, socklen_t optlen ) { return setsockopt( fd, level, optname, optval, optlen ); } #undef setsockopt #define setsockopt ___xxx_setsockopt static __inline__ int unix_socketpair( int d, int type, int protocol, int sv[2] ) { return socketpair( d, type, protocol, sv ); } static __inline__ int adb_socketpair( int sv[2] ) { int rc; rc = unix_socketpair( AF_UNIX, SOCK_STREAM, 0, sv ); if (rc < 0) return -1; close_on_exec( sv[0] ); close_on_exec( sv[1] ); return 0; } #undef socketpair #define socketpair ___xxx_socketpair typedef struct pollfd adb_pollfd; static __inline__ int adb_poll(adb_pollfd* fds, size_t nfds, int timeout) { return TEMP_FAILURE_RETRY(poll(fds, nfds, timeout)); } #define poll ___xxx_poll static __inline__ void adb_sleep_ms( int mseconds ) { usleep( mseconds*1000 ); } static __inline__ int adb_mkdir(const std::string& path, int mode) { return mkdir(path.c_str(), mode); } #undef mkdir #define mkdir ___xxx_mkdir static __inline__ void adb_sysdeps_init(void) { } static __inline__ int adb_is_absolute_host_path(const char* path) { return path[0] == '/'; } static __inline__ unsigned long adb_thread_id() { return (unsigned long)gettid(); } #endif /* !_WIN32 */ static inline void disable_tcp_nagle(int fd) { int off = 1; adb_setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &off, sizeof(off)); } // Sets TCP socket |fd| to send a keepalive TCP message every |interval_sec| seconds. Set // |interval_sec| to 0 to disable keepalives. If keepalives are enabled, the connection will be // configured to drop after 10 missed keepalives. Returns true on success. bool set_tcp_keepalive(int fd, int interval_sec); #endif /* _ADB_SYSDEPS_H */ adb/sysdeps/0040755 0000000 0000000 00000000000 12767234553 012046 5ustar000000000 0000000 adb/sysdeps/mutex.h0100644 0000000 0000000 00000004441 12767234553 013361 0ustar000000000 0000000 #pragma once /* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #if defined(_WIN32) #include #include #include "adb.h" // The prebuilt version of mingw we use doesn't support mutex or recursive_mutex. // Therefore, implement our own using the Windows primitives. // Put them directly into the std namespace, so that when they're actually available, the build // breaks until they're removed. #include namespace std { // CRITICAL_SECTION is recursive, so just wrap it in a Mutex-compatible class. class recursive_mutex { public: recursive_mutex() { InitializeCriticalSection(&mutex_); } ~recursive_mutex() { DeleteCriticalSection(&mutex_); } void lock() { EnterCriticalSection(&mutex_); } bool try_lock() { return TryEnterCriticalSection(&mutex_); } void unlock() { LeaveCriticalSection(&mutex_); } private: CRITICAL_SECTION mutex_; DISALLOW_COPY_AND_ASSIGN(recursive_mutex); }; class mutex { public: mutex() { } ~mutex() { } void lock() { mutex_.lock(); if (++lock_count_ != 1) { fatal("non-recursive mutex locked reentrantly"); } } void unlock() { if (--lock_count_ != 0) { fatal("non-recursive mutex unlock resulted in unexpected lock count: %d", lock_count_); } mutex_.unlock(); } bool try_lock() { if (!mutex_.try_lock()) { return false; } if (lock_count_ != 0) { mutex_.unlock(); return false; } ++lock_count_; return true; } private: recursive_mutex mutex_; size_t lock_count_ = 0; }; } #endif adb/sysdeps_test.cpp0100644 0000000 0000000 00000017730 12767234553 013616 0ustar000000000 0000000 /* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include "adb_io.h" #include "sysdeps.h" static void increment_atomic_int(void* c) { sleep(1); reinterpret_cast*>(c)->fetch_add(1); } TEST(sysdeps_thread, smoke) { std::atomic counter(0); for (int i = 0; i < 100; ++i) { ASSERT_TRUE(adb_thread_create(increment_atomic_int, &counter)); } sleep(2); ASSERT_EQ(100, counter.load()); } TEST(sysdeps_thread, join) { std::atomic counter(0); std::vector threads(500); for (size_t i = 0; i < threads.size(); ++i) { ASSERT_TRUE(adb_thread_create(increment_atomic_int, &counter, &threads[i])); } int current = counter.load(); ASSERT_GE(current, 0); // Make sure that adb_thread_create actually creates threads, and doesn't do something silly // like synchronously run the function passed in. The sleep in increment_atomic_int should be // enough to keep this from being flakey. ASSERT_LT(current, 500); for (const auto& thread : threads) { ASSERT_TRUE(adb_thread_join(thread)); } ASSERT_EQ(500, counter.load()); } TEST(sysdeps_thread, exit) { adb_thread_t thread; ASSERT_TRUE(adb_thread_create( [](void*) { adb_thread_exit(); for (;;) continue; }, nullptr, &thread)); ASSERT_TRUE(adb_thread_join(thread)); } TEST(sysdeps_socketpair, smoke) { int fds[2]; ASSERT_EQ(0, adb_socketpair(fds)) << strerror(errno); ASSERT_TRUE(WriteFdExactly(fds[0], "foo", 4)); ASSERT_TRUE(WriteFdExactly(fds[1], "bar", 4)); char buf[4]; ASSERT_TRUE(ReadFdExactly(fds[1], buf, 4)); ASSERT_STREQ(buf, "foo"); ASSERT_TRUE(ReadFdExactly(fds[0], buf, 4)); ASSERT_STREQ(buf, "bar"); ASSERT_EQ(0, adb_close(fds[0])); ASSERT_EQ(0, adb_close(fds[1])); } TEST(sysdeps_fd, exhaustion) { std::vector fds; int socketpair[2]; while (adb_socketpair(socketpair) == 0) { fds.push_back(socketpair[0]); fds.push_back(socketpair[1]); } ASSERT_EQ(EMFILE, errno) << strerror(errno); for (int fd : fds) { ASSERT_EQ(0, adb_close(fd)); } ASSERT_EQ(0, adb_socketpair(socketpair)); ASSERT_EQ(socketpair[0], fds[0]); ASSERT_EQ(socketpair[1], fds[1]); ASSERT_EQ(0, adb_close(socketpair[0])); ASSERT_EQ(0, adb_close(socketpair[1])); } class sysdeps_poll : public ::testing::Test { protected: int fds[2]; void SetUp() override { ASSERT_EQ(0, adb_socketpair(fds)) << strerror(errno); } void TearDown() override { if (fds[0] >= 0) { ASSERT_EQ(0, adb_close(fds[0])); } if (fds[1] >= 0) { ASSERT_EQ(0, adb_close(fds[1])); } } }; TEST_F(sysdeps_poll, smoke) { adb_pollfd pfd[2] = {}; pfd[0].fd = fds[0]; pfd[0].events = POLLRDNORM; pfd[1].fd = fds[1]; pfd[1].events = POLLWRNORM; pfd[0].revents = -1; pfd[1].revents = -1; EXPECT_EQ(1, adb_poll(pfd, 2, 0)); EXPECT_EQ(0, pfd[0].revents); EXPECT_EQ(POLLWRNORM, pfd[1].revents); ASSERT_TRUE(WriteFdExactly(fds[1], "foo", 4)); // Wait for the socketpair to be flushed. pfd[0].revents = -1; EXPECT_EQ(1, adb_poll(pfd, 1, 100)); EXPECT_EQ(POLLRDNORM, pfd[0].revents); pfd[0].revents = -1; pfd[1].revents = -1; EXPECT_EQ(2, adb_poll(pfd, 2, 0)); EXPECT_EQ(POLLRDNORM, pfd[0].revents); EXPECT_EQ(POLLWRNORM, pfd[1].revents); } TEST_F(sysdeps_poll, timeout) { adb_pollfd pfd = {}; pfd.fd = fds[0]; pfd.events = POLLRDNORM; EXPECT_EQ(0, adb_poll(&pfd, 1, 100)); EXPECT_EQ(0, pfd.revents); ASSERT_TRUE(WriteFdExactly(fds[1], "foo", 4)); EXPECT_EQ(1, adb_poll(&pfd, 1, 100)); EXPECT_EQ(POLLRDNORM, pfd.revents); } TEST_F(sysdeps_poll, invalid_fd) { adb_pollfd pfd[3] = {}; pfd[0].fd = fds[0]; pfd[0].events = POLLRDNORM; pfd[1].fd = INT_MAX; pfd[1].events = POLLRDNORM; pfd[2].fd = fds[1]; pfd[2].events = POLLWRNORM; ASSERT_TRUE(WriteFdExactly(fds[1], "foo", 4)); // Wait for the socketpair to be flushed. EXPECT_EQ(1, adb_poll(pfd, 1, 100)); EXPECT_EQ(POLLRDNORM, pfd[0].revents); EXPECT_EQ(3, adb_poll(pfd, 3, 0)); EXPECT_EQ(POLLRDNORM, pfd[0].revents); EXPECT_EQ(POLLNVAL, pfd[1].revents); EXPECT_EQ(POLLWRNORM, pfd[2].revents); } TEST_F(sysdeps_poll, duplicate_fd) { adb_pollfd pfd[2] = {}; pfd[0].fd = fds[0]; pfd[0].events = POLLRDNORM; pfd[1] = pfd[0]; EXPECT_EQ(0, adb_poll(pfd, 2, 0)); EXPECT_EQ(0, pfd[0].revents); EXPECT_EQ(0, pfd[1].revents); ASSERT_TRUE(WriteFdExactly(fds[1], "foo", 4)); EXPECT_EQ(2, adb_poll(pfd, 2, 100)); EXPECT_EQ(POLLRDNORM, pfd[0].revents); EXPECT_EQ(POLLRDNORM, pfd[1].revents); } TEST_F(sysdeps_poll, disconnect) { adb_pollfd pfd = {}; pfd.fd = fds[0]; pfd.events = POLLIN; EXPECT_EQ(0, adb_poll(&pfd, 1, 0)); EXPECT_EQ(0, pfd.revents); EXPECT_EQ(0, adb_close(fds[1])); fds[1] = -1; EXPECT_EQ(1, adb_poll(&pfd, 1, 100)); // Linux returns POLLIN | POLLHUP, Windows returns just POLLHUP. EXPECT_EQ(POLLHUP, pfd.revents & POLLHUP); } TEST_F(sysdeps_poll, fd_count) { // https://code.google.com/p/android/issues/detail?id=12141 static constexpr int num_sockets = 512; std::vector sockets; std::vector pfds; sockets.resize(num_sockets * 2); for (int32_t i = 0; i < num_sockets; ++i) { ASSERT_EQ(0, adb_socketpair(&sockets[i * 2])) << strerror(errno); ASSERT_TRUE(WriteFdExactly(sockets[i * 2], &i, sizeof(i))); adb_pollfd pfd; pfd.events = POLLIN; pfd.fd = sockets[i * 2 + 1]; pfds.push_back(pfd); } ASSERT_EQ(num_sockets, adb_poll(pfds.data(), pfds.size(), 0)); for (int i = 0; i < num_sockets; ++i) { ASSERT_NE(0, pfds[i].revents & POLLIN); int32_t buf[2] = { -1, -1 }; ASSERT_EQ(adb_read(pfds[i].fd, buf, sizeof(buf)), static_cast(sizeof(int32_t))); ASSERT_EQ(i, buf[0]); } for (int fd : sockets) { adb_close(fd); } } #include "sysdeps/mutex.h" TEST(sysdeps_mutex, mutex_smoke) { static std::atomic finished(false); static std::mutex &m = *new std::mutex(); m.lock(); ASSERT_FALSE(m.try_lock()); adb_thread_create([](void*) { ASSERT_FALSE(m.try_lock()); m.lock(); finished.store(true); adb_sleep_ms(200); m.unlock(); }, nullptr); ASSERT_FALSE(finished.load()); adb_sleep_ms(100); ASSERT_FALSE(finished.load()); m.unlock(); adb_sleep_ms(100); m.lock(); ASSERT_TRUE(finished.load()); m.unlock(); } // Our implementation on Windows aborts on double lock. #if defined(_WIN32) TEST(sysdeps_mutex, mutex_reentrant_lock) { std::mutex &m = *new std::mutex(); m.lock(); ASSERT_FALSE(m.try_lock()); EXPECT_DEATH(m.lock(), "non-recursive mutex locked reentrantly"); } #endif TEST(sysdeps_mutex, recursive_mutex_smoke) { static std::recursive_mutex &m = *new std::recursive_mutex(); m.lock(); ASSERT_TRUE(m.try_lock()); m.unlock(); adb_thread_create([](void*) { ASSERT_FALSE(m.try_lock()); m.lock(); adb_sleep_ms(500); m.unlock(); }, nullptr); adb_sleep_ms(100); m.unlock(); adb_sleep_ms(100); ASSERT_FALSE(m.try_lock()); m.lock(); m.unlock(); } adb/sysdeps_unix.cpp0100644 0000000 0000000 00000003706 12767234553 013620 0ustar000000000 0000000 /* * Copyright (C) 2016 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "sysdeps.h" bool set_tcp_keepalive(int fd, int interval_sec) { int enable = (interval_sec > 0); if (adb_setsockopt(fd, SOL_SOCKET, SO_KEEPALIVE, &enable, sizeof(enable))) { return false; } if (!enable) { return true; } // Idle time before sending the first keepalive is TCP_KEEPIDLE on Linux, TCP_KEEPALIVE on Mac. #if defined(TCP_KEEPIDLE) if (adb_setsockopt(fd, IPPROTO_TCP, TCP_KEEPIDLE, &interval_sec, sizeof(interval_sec))) { return false; } #elif defined(TCP_KEEPALIVE) if (adb_setsockopt(fd, IPPROTO_TCP, TCP_KEEPALIVE, &interval_sec, sizeof(interval_sec))) { return false; } #endif // TCP_KEEPINTVL and TCP_KEEPCNT are available on Linux 2.4+ and OS X 10.8+ (Mountain Lion). #if defined(TCP_KEEPINTVL) if (adb_setsockopt(fd, IPPROTO_TCP, TCP_KEEPINTVL, &interval_sec, sizeof(interval_sec))) { return false; } #endif #if defined(TCP_KEEPCNT) // On Windows this value is hardcoded to 10. This is a reasonable value, so we do the same here // to match behavior. See SO_KEEPALIVE documentation at // https://msdn.microsoft.com/en-us/library/windows/desktop/ee470551(v=vs.85).aspx. const int keepcnt = 10; if (adb_setsockopt(fd, IPPROTO_TCP, TCP_KEEPCNT, &keepcnt, sizeof(keepcnt))) { return false; } #endif return true; } adb/sysdeps_win32.cpp0100644 0000000 0000000 00000312426 12767234553 013601 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG SYSDEPS #include "sysdeps.h" #include /* winsock.h *must* be included before windows.h. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "adb.h" #include "adb_utils.h" extern void fatal(const char *fmt, ...); /* forward declarations */ typedef const struct FHClassRec_* FHClass; typedef struct FHRec_* FH; typedef struct EventHookRec_* EventHook; typedef struct FHClassRec_ { void (*_fh_init)(FH); int (*_fh_close)(FH); int (*_fh_lseek)(FH, int, int); int (*_fh_read)(FH, void*, int); int (*_fh_write)(FH, const void*, int); } FHClassRec; static void _fh_file_init(FH); static int _fh_file_close(FH); static int _fh_file_lseek(FH, int, int); static int _fh_file_read(FH, void*, int); static int _fh_file_write(FH, const void*, int); static const FHClassRec _fh_file_class = { _fh_file_init, _fh_file_close, _fh_file_lseek, _fh_file_read, _fh_file_write, }; static void _fh_socket_init(FH); static int _fh_socket_close(FH); static int _fh_socket_lseek(FH, int, int); static int _fh_socket_read(FH, void*, int); static int _fh_socket_write(FH, const void*, int); static const FHClassRec _fh_socket_class = { _fh_socket_init, _fh_socket_close, _fh_socket_lseek, _fh_socket_read, _fh_socket_write, }; #define assert(cond) \ do { \ if (!(cond)) fatal("assertion failed '%s' on %s:%d\n", #cond, __FILE__, __LINE__); \ } while (0) void handle_deleter::operator()(HANDLE h) { // CreateFile() is documented to return INVALID_HANDLE_FILE on error, // implying that NULL is a valid handle, but this is probably impossible. // Other APIs like CreateEvent() are documented to return NULL on error, // implying that INVALID_HANDLE_VALUE is a valid handle, but this is also // probably impossible. Thus, consider both NULL and INVALID_HANDLE_VALUE // as invalid handles. std::unique_ptr won't call a deleter with NULL, so we // only need to check for INVALID_HANDLE_VALUE. if (h != INVALID_HANDLE_VALUE) { if (!CloseHandle(h)) { D("CloseHandle(%p) failed: %s", h, android::base::SystemErrorCodeToString(GetLastError()).c_str()); } } } /**************************************************************************/ /**************************************************************************/ /***** *****/ /***** replaces libs/cutils/load_file.c *****/ /***** *****/ /**************************************************************************/ /**************************************************************************/ void *load_file(const char *fn, unsigned *_sz) { HANDLE file; char *data; DWORD file_size; std::wstring fn_wide; if (!android::base::UTF8ToWide(fn, &fn_wide)) return NULL; file = CreateFileW( fn_wide.c_str(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL ); if (file == INVALID_HANDLE_VALUE) return NULL; file_size = GetFileSize( file, NULL ); data = NULL; if (file_size > 0) { data = (char*) malloc( file_size + 1 ); if (data == NULL) { D("load_file: could not allocate %ld bytes", file_size ); file_size = 0; } else { DWORD out_bytes; if ( !ReadFile( file, data, file_size, &out_bytes, NULL ) || out_bytes != file_size ) { D("load_file: could not read %ld bytes from '%s'", file_size, fn); free(data); data = NULL; file_size = 0; } } } CloseHandle( file ); *_sz = (unsigned) file_size; return data; } /**************************************************************************/ /**************************************************************************/ /***** *****/ /***** common file descriptor handling *****/ /***** *****/ /**************************************************************************/ /**************************************************************************/ typedef struct FHRec_ { FHClass clazz; int used; int eof; union { HANDLE handle; SOCKET socket; } u; int mask; char name[32]; } FHRec; #define fh_handle u.handle #define fh_socket u.socket #define WIN32_FH_BASE 2048 #define WIN32_MAX_FHS 2048 static adb_mutex_t _win32_lock; static FHRec _win32_fhs[ WIN32_MAX_FHS ]; static int _win32_fh_next; // where to start search for free FHRec static FH _fh_from_int( int fd, const char* func ) { FH f; fd -= WIN32_FH_BASE; if (fd < 0 || fd >= WIN32_MAX_FHS) { D( "_fh_from_int: invalid fd %d passed to %s", fd + WIN32_FH_BASE, func ); errno = EBADF; return NULL; } f = &_win32_fhs[fd]; if (f->used == 0) { D( "_fh_from_int: invalid fd %d passed to %s", fd + WIN32_FH_BASE, func ); errno = EBADF; return NULL; } return f; } static int _fh_to_int( FH f ) { if (f && f->used && f >= _win32_fhs && f < _win32_fhs + WIN32_MAX_FHS) return (int)(f - _win32_fhs) + WIN32_FH_BASE; return -1; } static FH _fh_alloc( FHClass clazz ) { FH f = NULL; adb_mutex_lock( &_win32_lock ); for (int i = _win32_fh_next; i < WIN32_MAX_FHS; ++i) { if (_win32_fhs[i].clazz == NULL) { f = &_win32_fhs[i]; _win32_fh_next = i + 1; goto Exit; } } D( "_fh_alloc: no more free file descriptors" ); errno = EMFILE; // Too many open files Exit: if (f) { f->clazz = clazz; f->used = 1; f->eof = 0; f->name[0] = '\0'; clazz->_fh_init(f); } adb_mutex_unlock( &_win32_lock ); return f; } static int _fh_close( FH f ) { // Use lock so that closing only happens once and so that _fh_alloc can't // allocate a FH that we're in the middle of closing. adb_mutex_lock(&_win32_lock); int offset = f - _win32_fhs; if (_win32_fh_next > offset) { _win32_fh_next = offset; } if (f->used) { f->clazz->_fh_close( f ); f->name[0] = '\0'; f->eof = 0; f->used = 0; f->clazz = NULL; } adb_mutex_unlock(&_win32_lock); return 0; } // Deleter for unique_fh. class fh_deleter { public: void operator()(struct FHRec_* fh) { // We're called from a destructor and destructors should not overwrite // errno because callers may do: // errno = EBLAH; // return -1; // calls destructor, which should not overwrite errno const int saved_errno = errno; _fh_close(fh); errno = saved_errno; } }; // Like std::unique_ptr, but calls _fh_close() instead of operator delete(). typedef std::unique_ptr unique_fh; /**************************************************************************/ /**************************************************************************/ /***** *****/ /***** file-based descriptor handling *****/ /***** *****/ /**************************************************************************/ /**************************************************************************/ static void _fh_file_init( FH f ) { f->fh_handle = INVALID_HANDLE_VALUE; } static int _fh_file_close( FH f ) { CloseHandle( f->fh_handle ); f->fh_handle = INVALID_HANDLE_VALUE; return 0; } static int _fh_file_read( FH f, void* buf, int len ) { DWORD read_bytes; if ( !ReadFile( f->fh_handle, buf, (DWORD)len, &read_bytes, NULL ) ) { D( "adb_read: could not read %d bytes from %s", len, f->name ); errno = EIO; return -1; } else if (read_bytes < (DWORD)len) { f->eof = 1; } return (int)read_bytes; } static int _fh_file_write( FH f, const void* buf, int len ) { DWORD wrote_bytes; if ( !WriteFile( f->fh_handle, buf, (DWORD)len, &wrote_bytes, NULL ) ) { D( "adb_file_write: could not write %d bytes from %s", len, f->name ); errno = EIO; return -1; } else if (wrote_bytes < (DWORD)len) { f->eof = 1; } return (int)wrote_bytes; } static int _fh_file_lseek( FH f, int pos, int origin ) { DWORD method; DWORD result; switch (origin) { case SEEK_SET: method = FILE_BEGIN; break; case SEEK_CUR: method = FILE_CURRENT; break; case SEEK_END: method = FILE_END; break; default: errno = EINVAL; return -1; } result = SetFilePointer( f->fh_handle, pos, NULL, method ); if (result == INVALID_SET_FILE_POINTER) { errno = EIO; return -1; } else { f->eof = 0; } return (int)result; } /**************************************************************************/ /**************************************************************************/ /***** *****/ /***** file-based descriptor handling *****/ /***** *****/ /**************************************************************************/ /**************************************************************************/ int adb_open(const char* path, int options) { FH f; DWORD desiredAccess = 0; DWORD shareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; switch (options) { case O_RDONLY: desiredAccess = GENERIC_READ; break; case O_WRONLY: desiredAccess = GENERIC_WRITE; break; case O_RDWR: desiredAccess = GENERIC_READ | GENERIC_WRITE; break; default: D("adb_open: invalid options (0x%0x)", options); errno = EINVAL; return -1; } f = _fh_alloc( &_fh_file_class ); if ( !f ) { return -1; } std::wstring path_wide; if (!android::base::UTF8ToWide(path, &path_wide)) { return -1; } f->fh_handle = CreateFileW( path_wide.c_str(), desiredAccess, shareMode, NULL, OPEN_EXISTING, 0, NULL ); if ( f->fh_handle == INVALID_HANDLE_VALUE ) { const DWORD err = GetLastError(); _fh_close(f); D( "adb_open: could not open '%s': ", path ); switch (err) { case ERROR_FILE_NOT_FOUND: D( "file not found" ); errno = ENOENT; return -1; case ERROR_PATH_NOT_FOUND: D( "path not found" ); errno = ENOTDIR; return -1; default: D("unknown error: %s", android::base::SystemErrorCodeToString(err).c_str()); errno = ENOENT; return -1; } } snprintf( f->name, sizeof(f->name), "%d(%s)", _fh_to_int(f), path ); D( "adb_open: '%s' => fd %d", path, _fh_to_int(f) ); return _fh_to_int(f); } /* ignore mode on Win32 */ int adb_creat(const char* path, int mode) { FH f; f = _fh_alloc( &_fh_file_class ); if ( !f ) { return -1; } std::wstring path_wide; if (!android::base::UTF8ToWide(path, &path_wide)) { return -1; } f->fh_handle = CreateFileW( path_wide.c_str(), GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL ); if ( f->fh_handle == INVALID_HANDLE_VALUE ) { const DWORD err = GetLastError(); _fh_close(f); D( "adb_creat: could not open '%s': ", path ); switch (err) { case ERROR_FILE_NOT_FOUND: D( "file not found" ); errno = ENOENT; return -1; case ERROR_PATH_NOT_FOUND: D( "path not found" ); errno = ENOTDIR; return -1; default: D("unknown error: %s", android::base::SystemErrorCodeToString(err).c_str()); errno = ENOENT; return -1; } } snprintf( f->name, sizeof(f->name), "%d(%s)", _fh_to_int(f), path ); D( "adb_creat: '%s' => fd %d", path, _fh_to_int(f) ); return _fh_to_int(f); } int adb_read(int fd, void* buf, int len) { FH f = _fh_from_int(fd, __func__); if (f == NULL) { return -1; } return f->clazz->_fh_read( f, buf, len ); } int adb_write(int fd, const void* buf, int len) { FH f = _fh_from_int(fd, __func__); if (f == NULL) { return -1; } return f->clazz->_fh_write(f, buf, len); } int adb_lseek(int fd, int pos, int where) { FH f = _fh_from_int(fd, __func__); if (!f) { return -1; } return f->clazz->_fh_lseek(f, pos, where); } int adb_close(int fd) { FH f = _fh_from_int(fd, __func__); if (!f) { return -1; } D( "adb_close: %s", f->name); _fh_close(f); return 0; } // Overrides strerror() to handle error codes not supported by the Windows C // Runtime (MSVCRT.DLL). char* adb_strerror(int err) { // sysdeps.h defines strerror to adb_strerror, but in this function, we // want to call the real C Runtime strerror(). #pragma push_macro("strerror") #undef strerror const int saved_err = errno; // Save because we overwrite it later. // Lookup the string for an unknown error. char* errmsg = strerror(-1); const std::string unknown_error = (errmsg == nullptr) ? "" : errmsg; // Lookup the string for this error to see if the C Runtime has it. errmsg = strerror(err); if (errmsg != nullptr && unknown_error != errmsg) { // The CRT returned an error message and it is different than the error // message for an unknown error, so it is probably valid, so use it. } else { // Check if we have a string for this error code. const char* custom_msg = nullptr; switch (err) { #pragma push_macro("ERR") #undef ERR #define ERR(errnum, desc) case errnum: custom_msg = desc; break // These error strings are from AOSP bionic/libc/include/sys/_errdefs.h. // Note that these cannot be longer than 94 characters because we // pass this to _strerror() which has that requirement. ERR(ECONNRESET, "Connection reset by peer"); ERR(EHOSTUNREACH, "No route to host"); ERR(ENETDOWN, "Network is down"); ERR(ENETRESET, "Network dropped connection because of reset"); ERR(ENOBUFS, "No buffer space available"); ERR(ENOPROTOOPT, "Protocol not available"); ERR(ENOTCONN, "Transport endpoint is not connected"); ERR(ENOTSOCK, "Socket operation on non-socket"); ERR(EOPNOTSUPP, "Operation not supported on transport endpoint"); #pragma pop_macro("ERR") } if (custom_msg != nullptr) { // Use _strerror() to write our string into the writable per-thread // buffer used by strerror()/_strerror(). _strerror() appends the // msg for the current value of errno, so set errno to a consistent // value for every call so that our code-path is always the same. errno = 0; errmsg = _strerror(custom_msg); const size_t custom_msg_len = strlen(custom_msg); // Just in case _strerror() returned a read-only string, check if // the returned string starts with our custom message because that // implies that the string is not read-only. if ((errmsg != nullptr) && !strncmp(custom_msg, errmsg, custom_msg_len)) { // _strerror() puts other text after our custom message, so // remove that by terminating after our message. errmsg[custom_msg_len] = '\0'; } else { // For some reason nullptr was returned or a pointer to a // read-only string was returned, so fallback to whatever // strerror() can muster (probably "Unknown error" or some // generic CRT error string). errmsg = strerror(err); } } else { // We don't have a custom message, so use whatever strerror(err) // returned earlier. } } errno = saved_err; // restore return errmsg; #pragma pop_macro("strerror") } /**************************************************************************/ /**************************************************************************/ /***** *****/ /***** socket-based file descriptors *****/ /***** *****/ /**************************************************************************/ /**************************************************************************/ #undef setsockopt static void _socket_set_errno( const DWORD err ) { // Because the Windows C Runtime (MSVCRT.DLL) strerror() does not support a // lot of POSIX and socket error codes, some of the resulting error codes // are mapped to strings by adb_strerror() above. switch ( err ) { case 0: errno = 0; break; // Don't map WSAEINTR since that is only for Winsock 1.1 which we don't use. // case WSAEINTR: errno = EINTR; break; case WSAEFAULT: errno = EFAULT; break; case WSAEINVAL: errno = EINVAL; break; case WSAEMFILE: errno = EMFILE; break; // Mapping WSAEWOULDBLOCK to EAGAIN is absolutely critical because // non-blocking sockets can cause an error code of WSAEWOULDBLOCK and // callers check specifically for EAGAIN. case WSAEWOULDBLOCK: errno = EAGAIN; break; case WSAENOTSOCK: errno = ENOTSOCK; break; case WSAENOPROTOOPT: errno = ENOPROTOOPT; break; case WSAEOPNOTSUPP: errno = EOPNOTSUPP; break; case WSAENETDOWN: errno = ENETDOWN; break; case WSAENETRESET: errno = ENETRESET; break; // Map WSAECONNABORTED to EPIPE instead of ECONNABORTED because POSIX seems // to use EPIPE for these situations and there are some callers that look // for EPIPE. case WSAECONNABORTED: errno = EPIPE; break; case WSAECONNRESET: errno = ECONNRESET; break; case WSAENOBUFS: errno = ENOBUFS; break; case WSAENOTCONN: errno = ENOTCONN; break; // Don't map WSAETIMEDOUT because we don't currently use SO_RCVTIMEO or // SO_SNDTIMEO which would cause WSAETIMEDOUT to be returned. Future // considerations: Reportedly send() can return zero on timeout, and POSIX // code may expect EAGAIN instead of ETIMEDOUT on timeout. // case WSAETIMEDOUT: errno = ETIMEDOUT; break; case WSAEHOSTUNREACH: errno = EHOSTUNREACH; break; default: errno = EINVAL; D( "_socket_set_errno: mapping Windows error code %lu to errno %d", err, errno ); } } extern int adb_poll(adb_pollfd* fds, size_t nfds, int timeout) { // WSAPoll doesn't handle invalid/non-socket handles, so we need to handle them ourselves. int skipped = 0; std::vector sockets; std::vector original; for (size_t i = 0; i < nfds; ++i) { FH fh = _fh_from_int(fds[i].fd, __func__); if (!fh || !fh->used || fh->clazz != &_fh_socket_class) { D("adb_poll received bad FD %d", fds[i].fd); fds[i].revents = POLLNVAL; ++skipped; } else { WSAPOLLFD wsapollfd = { .fd = fh->u.socket, .events = static_cast(fds[i].events) }; sockets.push_back(wsapollfd); original.push_back(&fds[i]); } } if (sockets.empty()) { return skipped; } int result = WSAPoll(sockets.data(), sockets.size(), timeout); if (result == SOCKET_ERROR) { _socket_set_errno(WSAGetLastError()); return -1; } // Map the results back onto the original set. for (size_t i = 0; i < sockets.size(); ++i) { original[i]->revents = sockets[i].revents; } // WSAPoll appears to return the number of unique FDs with avaiable events, instead of how many // of the pollfd elements have a non-zero revents field, which is what it and poll are specified // to do. Ignore its result and calculate the proper return value. result = 0; for (size_t i = 0; i < nfds; ++i) { if (fds[i].revents != 0) { ++result; } } return result; } static void _fh_socket_init(FH f) { f->fh_socket = INVALID_SOCKET; f->mask = 0; } static int _fh_socket_close( FH f ) { if (f->fh_socket != INVALID_SOCKET) { /* gently tell any peer that we're closing the socket */ if (shutdown(f->fh_socket, SD_BOTH) == SOCKET_ERROR) { // If the socket is not connected, this returns an error. We want to // minimize logging spam, so don't log these errors for now. #if 0 D("socket shutdown failed: %s", android::base::SystemErrorCodeToString(WSAGetLastError()).c_str()); #endif } if (closesocket(f->fh_socket) == SOCKET_ERROR) { // Don't set errno here, since adb_close will ignore it. const DWORD err = WSAGetLastError(); D("closesocket failed: %s", android::base::SystemErrorCodeToString(err).c_str()); } f->fh_socket = INVALID_SOCKET; } f->mask = 0; return 0; } static int _fh_socket_lseek( FH f, int pos, int origin ) { errno = EPIPE; return -1; } static int _fh_socket_read(FH f, void* buf, int len) { int result = recv(f->fh_socket, reinterpret_cast(buf), len, 0); if (result == SOCKET_ERROR) { const DWORD err = WSAGetLastError(); // WSAEWOULDBLOCK is normal with a non-blocking socket, so don't trace // that to reduce spam and confusion. if (err != WSAEWOULDBLOCK) { D("recv fd %d failed: %s", _fh_to_int(f), android::base::SystemErrorCodeToString(err).c_str()); } _socket_set_errno(err); result = -1; } return result; } static int _fh_socket_write(FH f, const void* buf, int len) { int result = send(f->fh_socket, reinterpret_cast(buf), len, 0); if (result == SOCKET_ERROR) { const DWORD err = WSAGetLastError(); // WSAEWOULDBLOCK is normal with a non-blocking socket, so don't trace // that to reduce spam and confusion. if (err != WSAEWOULDBLOCK) { D("send fd %d failed: %s", _fh_to_int(f), android::base::SystemErrorCodeToString(err).c_str()); } _socket_set_errno(err); result = -1; } else { // According to https://code.google.com/p/chromium/issues/detail?id=27870 // Winsock Layered Service Providers may cause this. CHECK_LE(result, len) << "Tried to write " << len << " bytes to " << f->name << ", but " << result << " bytes reportedly written"; } return result; } /**************************************************************************/ /**************************************************************************/ /***** *****/ /***** replacement for libs/cutils/socket_xxxx.c *****/ /***** *****/ /**************************************************************************/ /**************************************************************************/ #include static int _winsock_init; static void _init_winsock( void ) { // TODO: Multiple threads calling this may potentially cause multiple calls // to WSAStartup() which offers no real benefit. if (!_winsock_init) { WSADATA wsaData; int rc = WSAStartup( MAKEWORD(2,2), &wsaData); if (rc != 0) { fatal("adb: could not initialize Winsock: %s", android::base::SystemErrorCodeToString(rc).c_str()); } _winsock_init = 1; // Note that we do not call atexit() to register WSACleanup to be called // at normal process termination because: // 1) When exit() is called, there are still threads actively using // Winsock because we don't cleanly shutdown all threads, so it // doesn't make sense to call WSACleanup() and may cause problems // with those threads. // 2) A deadlock can occur when exit() holds a C Runtime lock, then it // calls WSACleanup() which tries to unload a DLL, which tries to // grab the LoaderLock. This conflicts with the device_poll_thread // which holds the LoaderLock because AdbWinApi.dll calls // setupapi.dll which tries to load wintrust.dll which tries to load // crypt32.dll which calls atexit() which tries to acquire the C // Runtime lock that the other thread holds. } } // Map a socket type to an explicit socket protocol instead of using the socket // protocol of 0. Explicit socket protocols are used by most apps and we should // do the same to reduce the chance of exercising uncommon code-paths that might // have problems or that might load different Winsock service providers that // have problems. static int GetSocketProtocolFromSocketType(int type) { switch (type) { case SOCK_STREAM: return IPPROTO_TCP; case SOCK_DGRAM: return IPPROTO_UDP; default: LOG(FATAL) << "Unknown socket type: " << type; return 0; } } int network_loopback_client(int port, int type, std::string* error) { struct sockaddr_in addr; SOCKET s; unique_fh f(_fh_alloc(&_fh_socket_class)); if (!f) { *error = strerror(errno); return -1; } if (!_winsock_init) _init_winsock(); memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); s = socket(AF_INET, type, GetSocketProtocolFromSocketType(type)); if (s == INVALID_SOCKET) { const DWORD err = WSAGetLastError(); *error = android::base::StringPrintf("cannot create socket: %s", android::base::SystemErrorCodeToString(err).c_str()); D("%s", error->c_str()); _socket_set_errno(err); return -1; } f->fh_socket = s; if (connect(s, (struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) { // Save err just in case inet_ntoa() or ntohs() changes the last error. const DWORD err = WSAGetLastError(); *error = android::base::StringPrintf("cannot connect to %s:%u: %s", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port), android::base::SystemErrorCodeToString(err).c_str()); D("could not connect to %s:%d: %s", type != SOCK_STREAM ? "udp" : "tcp", port, error->c_str()); _socket_set_errno(err); return -1; } const int fd = _fh_to_int(f.get()); snprintf(f->name, sizeof(f->name), "%d(lo-client:%s%d)", fd, type != SOCK_STREAM ? "udp:" : "", port); D("port %d type %s => fd %d", port, type != SOCK_STREAM ? "udp" : "tcp", fd); f.release(); return fd; } #define LISTEN_BACKLOG 4 // interface_address is INADDR_LOOPBACK or INADDR_ANY. static int _network_server(int port, int type, u_long interface_address, std::string* error) { struct sockaddr_in addr; SOCKET s; int n; unique_fh f(_fh_alloc(&_fh_socket_class)); if (!f) { *error = strerror(errno); return -1; } if (!_winsock_init) _init_winsock(); memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(port); addr.sin_addr.s_addr = htonl(interface_address); // TODO: Consider using dual-stack socket that can simultaneously listen on // IPv4 and IPv6. s = socket(AF_INET, type, GetSocketProtocolFromSocketType(type)); if (s == INVALID_SOCKET) { const DWORD err = WSAGetLastError(); *error = android::base::StringPrintf("cannot create socket: %s", android::base::SystemErrorCodeToString(err).c_str()); D("%s", error->c_str()); _socket_set_errno(err); return -1; } f->fh_socket = s; // Note: SO_REUSEADDR on Windows allows multiple processes to bind to the // same port, so instead use SO_EXCLUSIVEADDRUSE. n = 1; if (setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (const char*)&n, sizeof(n)) == SOCKET_ERROR) { const DWORD err = WSAGetLastError(); *error = android::base::StringPrintf("cannot set socket option SO_EXCLUSIVEADDRUSE: %s", android::base::SystemErrorCodeToString(err).c_str()); D("%s", error->c_str()); _socket_set_errno(err); return -1; } if (bind(s, (struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) { // Save err just in case inet_ntoa() or ntohs() changes the last error. const DWORD err = WSAGetLastError(); *error = android::base::StringPrintf("cannot bind to %s:%u: %s", inet_ntoa(addr.sin_addr), ntohs(addr.sin_port), android::base::SystemErrorCodeToString(err).c_str()); D("could not bind to %s:%d: %s", type != SOCK_STREAM ? "udp" : "tcp", port, error->c_str()); _socket_set_errno(err); return -1; } if (type == SOCK_STREAM) { if (listen(s, LISTEN_BACKLOG) == SOCKET_ERROR) { const DWORD err = WSAGetLastError(); *error = android::base::StringPrintf( "cannot listen on socket: %s", android::base::SystemErrorCodeToString(err).c_str()); D("could not listen on %s:%d: %s", type != SOCK_STREAM ? "udp" : "tcp", port, error->c_str()); _socket_set_errno(err); return -1; } } const int fd = _fh_to_int(f.get()); snprintf(f->name, sizeof(f->name), "%d(%s-server:%s%d)", fd, interface_address == INADDR_LOOPBACK ? "lo" : "any", type != SOCK_STREAM ? "udp:" : "", port); D("port %d type %s => fd %d", port, type != SOCK_STREAM ? "udp" : "tcp", fd); f.release(); return fd; } int network_loopback_server(int port, int type, std::string* error) { return _network_server(port, type, INADDR_LOOPBACK, error); } int network_inaddr_any_server(int port, int type, std::string* error) { return _network_server(port, type, INADDR_ANY, error); } int network_connect(const std::string& host, int port, int type, int timeout, std::string* error) { unique_fh f(_fh_alloc(&_fh_socket_class)); if (!f) { *error = strerror(errno); return -1; } if (!_winsock_init) _init_winsock(); struct addrinfo hints; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; hints.ai_socktype = type; hints.ai_protocol = GetSocketProtocolFromSocketType(type); char port_str[16]; snprintf(port_str, sizeof(port_str), "%d", port); struct addrinfo* addrinfo_ptr = nullptr; #if (NTDDI_VERSION >= NTDDI_WINXPSP2) || (_WIN32_WINNT >= _WIN32_WINNT_WS03) // TODO: When the Android SDK tools increases the Windows system // requirements >= WinXP SP2, switch to android::base::UTF8ToWide() + GetAddrInfoW(). #else // Otherwise, keep using getaddrinfo(), or do runtime API detection // with GetProcAddress("GetAddrInfoW"). #endif if (getaddrinfo(host.c_str(), port_str, &hints, &addrinfo_ptr) != 0) { const DWORD err = WSAGetLastError(); *error = android::base::StringPrintf("cannot resolve host '%s' and port %s: %s", host.c_str(), port_str, android::base::SystemErrorCodeToString(err).c_str()); D("%s", error->c_str()); _socket_set_errno(err); return -1; } std::unique_ptr addrinfo(addrinfo_ptr, freeaddrinfo); addrinfo_ptr = nullptr; // TODO: Try all the addresses if there's more than one? This just uses // the first. Or, could call WSAConnectByName() (Windows Vista and newer) // which tries all addresses, takes a timeout and more. SOCKET s = socket(addrinfo->ai_family, addrinfo->ai_socktype, addrinfo->ai_protocol); if (s == INVALID_SOCKET) { const DWORD err = WSAGetLastError(); *error = android::base::StringPrintf("cannot create socket: %s", android::base::SystemErrorCodeToString(err).c_str()); D("%s", error->c_str()); _socket_set_errno(err); return -1; } f->fh_socket = s; // TODO: Implement timeouts for Windows. Seems like the default in theory // (according to http://serverfault.com/a/671453) and in practice is 21 sec. if (connect(s, addrinfo->ai_addr, addrinfo->ai_addrlen) == SOCKET_ERROR) { // TODO: Use WSAAddressToString or inet_ntop on address. const DWORD err = WSAGetLastError(); *error = android::base::StringPrintf("cannot connect to %s:%s: %s", host.c_str(), port_str, android::base::SystemErrorCodeToString(err).c_str()); D("could not connect to %s:%s:%s: %s", type != SOCK_STREAM ? "udp" : "tcp", host.c_str(), port_str, error->c_str()); _socket_set_errno(err); return -1; } const int fd = _fh_to_int(f.get()); snprintf(f->name, sizeof(f->name), "%d(net-client:%s%d)", fd, type != SOCK_STREAM ? "udp:" : "", port); D("host '%s' port %d type %s => fd %d", host.c_str(), port, type != SOCK_STREAM ? "udp" : "tcp", fd); f.release(); return fd; } #undef accept int adb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen) { FH serverfh = _fh_from_int(serverfd, __func__); if ( !serverfh || serverfh->clazz != &_fh_socket_class ) { D("adb_socket_accept: invalid fd %d", serverfd); errno = EBADF; return -1; } unique_fh fh(_fh_alloc( &_fh_socket_class )); if (!fh) { PLOG(ERROR) << "adb_socket_accept: failed to allocate accepted socket " "descriptor"; return -1; } fh->fh_socket = accept( serverfh->fh_socket, addr, addrlen ); if (fh->fh_socket == INVALID_SOCKET) { const DWORD err = WSAGetLastError(); LOG(ERROR) << "adb_socket_accept: accept on fd " << serverfd << " failed: " + android::base::SystemErrorCodeToString(err); _socket_set_errno( err ); return -1; } const int fd = _fh_to_int(fh.get()); snprintf( fh->name, sizeof(fh->name), "%d(accept:%s)", fd, serverfh->name ); D( "adb_socket_accept on fd %d returns fd %d", serverfd, fd ); fh.release(); return fd; } int adb_setsockopt( int fd, int level, int optname, const void* optval, socklen_t optlen ) { FH fh = _fh_from_int(fd, __func__); if ( !fh || fh->clazz != &_fh_socket_class ) { D("adb_setsockopt: invalid fd %d", fd); errno = EBADF; return -1; } // TODO: Once we can assume Windows Vista or later, if the caller is trying // to set SOL_SOCKET, SO_SNDBUF/SO_RCVBUF, ignore it since the OS has // auto-tuning. int result = setsockopt( fh->fh_socket, level, optname, reinterpret_cast(optval), optlen ); if ( result == SOCKET_ERROR ) { const DWORD err = WSAGetLastError(); D("adb_setsockopt: setsockopt on fd %d level %d optname %d failed: %s\n", fd, level, optname, android::base::SystemErrorCodeToString(err).c_str()); _socket_set_errno( err ); result = -1; } return result; } int adb_getsockname(int fd, struct sockaddr* sockaddr, socklen_t* optlen) { FH fh = _fh_from_int(fd, __func__); if (!fh || fh->clazz != &_fh_socket_class) { D("adb_getsockname: invalid fd %d", fd); errno = EBADF; return -1; } int result = getsockname(fh->fh_socket, sockaddr, optlen); if (result == SOCKET_ERROR) { const DWORD err = WSAGetLastError(); D("adb_getsockname: setsockopt on fd %d failed: %s\n", fd, android::base::SystemErrorCodeToString(err).c_str()); _socket_set_errno(err); result = -1; } return result; } int adb_shutdown(int fd) { FH f = _fh_from_int(fd, __func__); if (!f || f->clazz != &_fh_socket_class) { D("adb_shutdown: invalid fd %d", fd); errno = EBADF; return -1; } D( "adb_shutdown: %s", f->name); if (shutdown(f->fh_socket, SD_BOTH) == SOCKET_ERROR) { const DWORD err = WSAGetLastError(); D("socket shutdown fd %d failed: %s", fd, android::base::SystemErrorCodeToString(err).c_str()); _socket_set_errno(err); return -1; } return 0; } // Emulate socketpair(2) by binding and connecting to a socket. int adb_socketpair(int sv[2]) { int server = -1; int client = -1; int accepted = -1; sockaddr_storage addr_storage; socklen_t addr_len = sizeof(addr_storage); sockaddr_in* addr = nullptr; std::string error; server = network_loopback_server(0, SOCK_STREAM, &error); if (server < 0) { D("adb_socketpair: failed to create server: %s", error.c_str()); goto fail; } if (adb_getsockname(server, reinterpret_cast(&addr_storage), &addr_len) < 0) { D("adb_socketpair: adb_getsockname failed: %s", strerror(errno)); goto fail; } if (addr_storage.ss_family != AF_INET) { D("adb_socketpair: unknown address family received: %d", addr_storage.ss_family); errno = ECONNABORTED; goto fail; } addr = reinterpret_cast(&addr_storage); D("adb_socketpair: bound on port %d", ntohs(addr->sin_port)); client = network_loopback_client(ntohs(addr->sin_port), SOCK_STREAM, &error); if (client < 0) { D("adb_socketpair: failed to connect client: %s", error.c_str()); goto fail; } accepted = adb_socket_accept(server, nullptr, nullptr); if (accepted < 0) { D("adb_socketpair: failed to accept: %s", strerror(errno)); goto fail; } adb_close(server); sv[0] = client; sv[1] = accepted; return 0; fail: if (server >= 0) { adb_close(server); } if (client >= 0) { adb_close(client); } if (accepted >= 0) { adb_close(accepted); } return -1; } bool set_file_block_mode(int fd, bool block) { FH fh = _fh_from_int(fd, __func__); if (!fh || !fh->used) { errno = EBADF; return false; } if (fh->clazz == &_fh_socket_class) { u_long x = !block; if (ioctlsocket(fh->u.socket, FIONBIO, &x) != 0) { _socket_set_errno(WSAGetLastError()); return false; } return true; } else { errno = ENOTSOCK; return false; } } bool set_tcp_keepalive(int fd, int interval_sec) { FH fh = _fh_from_int(fd, __func__); if (!fh || fh->clazz != &_fh_socket_class) { D("set_tcp_keepalive(%d) failed: invalid fd", fd); errno = EBADF; return false; } tcp_keepalive keepalive; keepalive.onoff = (interval_sec > 0); keepalive.keepalivetime = interval_sec * 1000; keepalive.keepaliveinterval = interval_sec * 1000; DWORD bytes_returned = 0; if (WSAIoctl(fh->fh_socket, SIO_KEEPALIVE_VALS, &keepalive, sizeof(keepalive), nullptr, 0, &bytes_returned, nullptr, nullptr) != 0) { const DWORD err = WSAGetLastError(); D("set_tcp_keepalive(%d) failed: %s", fd, android::base::SystemErrorCodeToString(err).c_str()); _socket_set_errno(err); return false; } return true; } static adb_mutex_t g_console_output_buffer_lock; void adb_sysdeps_init( void ) { #define ADB_MUTEX(x) InitializeCriticalSection( & x ); #include "mutex_list.h" InitializeCriticalSection( &_win32_lock ); InitializeCriticalSection( &g_console_output_buffer_lock ); } /**************************************************************************/ /**************************************************************************/ /***** *****/ /***** Console Window Terminal Emulation *****/ /***** *****/ /**************************************************************************/ /**************************************************************************/ // This reads input from a Win32 console window and translates it into Unix // terminal-style sequences. This emulates mostly Gnome Terminal (in Normal // mode, not Application mode), which itself emulates xterm. Gnome Terminal // is emulated instead of xterm because it is probably more popular than xterm: // Ubuntu's default Ctrl-Alt-T shortcut opens Gnome Terminal, Gnome Terminal // supports modern fonts, etc. It seems best to emulate the terminal that most // Android developers use because they'll fix apps (the shell, etc.) to keep // working with that terminal's emulation. // // The point of this emulation is not to be perfect or to solve all issues with // console windows on Windows, but to be better than the original code which // just called read() (which called ReadFile(), which called ReadConsoleA()) // which did not support Ctrl-C, tab completion, shell input line editing // keys, server echo, and more. // // This implementation reconfigures the console with SetConsoleMode(), then // calls ReadConsoleInput() to get raw input which it remaps to Unix // terminal-style sequences which is returned via unix_read() which is used // by the 'adb shell' command. // // Code organization: // // * _get_console_handle() and unix_isatty() provide console information. // * stdin_raw_init() and stdin_raw_restore() reconfigure the console. // * unix_read() detects console windows (as opposed to pipes, files, etc.). // * _console_read() is the main code of the emulation. // Returns a console HANDLE if |fd| is a console, otherwise returns nullptr. // If a valid HANDLE is returned and |mode| is not null, |mode| is also filled // with the console mode. Requires GENERIC_READ access to the underlying HANDLE. static HANDLE _get_console_handle(int fd, DWORD* mode=nullptr) { // First check isatty(); this is very fast and eliminates most non-console // FDs, but returns 1 for both consoles and character devices like NUL. #pragma push_macro("isatty") #undef isatty if (!isatty(fd)) { return nullptr; } #pragma pop_macro("isatty") // To differentiate between character devices and consoles we need to get // the underlying HANDLE and use GetConsoleMode(), which is what requires // GENERIC_READ permissions. const intptr_t intptr_handle = _get_osfhandle(fd); if (intptr_handle == -1) { return nullptr; } const HANDLE handle = reinterpret_cast(intptr_handle); DWORD temp_mode = 0; if (!GetConsoleMode(handle, mode ? mode : &temp_mode)) { return nullptr; } return handle; } // Returns a console handle if |stream| is a console, otherwise returns nullptr. static HANDLE _get_console_handle(FILE* const stream) { // Save and restore errno to make it easier for callers to prevent from overwriting errno. android::base::ErrnoRestorer er; const int fd = fileno(stream); if (fd < 0) { return nullptr; } return _get_console_handle(fd); } int unix_isatty(int fd) { return _get_console_handle(fd) ? 1 : 0; } // Get the next KEY_EVENT_RECORD that should be processed. static bool _get_key_event_record(const HANDLE console, INPUT_RECORD* const input_record) { for (;;) { DWORD read_count = 0; memset(input_record, 0, sizeof(*input_record)); if (!ReadConsoleInputA(console, input_record, 1, &read_count)) { D("_get_key_event_record: ReadConsoleInputA() failed: %s\n", android::base::SystemErrorCodeToString(GetLastError()).c_str()); errno = EIO; return false; } if (read_count == 0) { // should be impossible fatal("ReadConsoleInputA returned 0"); } if (read_count != 1) { // should be impossible fatal("ReadConsoleInputA did not return one input record"); } // If the console window is resized, emulate SIGWINCH by breaking out // of read() with errno == EINTR. Note that there is no event on // vertical resize because we don't give the console our own custom // screen buffer (with CreateConsoleScreenBuffer() + // SetConsoleActiveScreenBuffer()). Instead, we use the default which // supports scrollback, but doesn't seem to raise an event for vertical // window resize. if (input_record->EventType == WINDOW_BUFFER_SIZE_EVENT) { errno = EINTR; return false; } if ((input_record->EventType == KEY_EVENT) && (input_record->Event.KeyEvent.bKeyDown)) { if (input_record->Event.KeyEvent.wRepeatCount == 0) { fatal("ReadConsoleInputA returned a key event with zero repeat" " count"); } // Got an interesting INPUT_RECORD, so return return true; } } } static __inline__ bool _is_shift_pressed(const DWORD control_key_state) { return (control_key_state & SHIFT_PRESSED) != 0; } static __inline__ bool _is_ctrl_pressed(const DWORD control_key_state) { return (control_key_state & (LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED)) != 0; } static __inline__ bool _is_alt_pressed(const DWORD control_key_state) { return (control_key_state & (LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED)) != 0; } static __inline__ bool _is_numlock_on(const DWORD control_key_state) { return (control_key_state & NUMLOCK_ON) != 0; } static __inline__ bool _is_capslock_on(const DWORD control_key_state) { return (control_key_state & CAPSLOCK_ON) != 0; } static __inline__ bool _is_enhanced_key(const DWORD control_key_state) { return (control_key_state & ENHANCED_KEY) != 0; } // Constants from MSDN for ToAscii(). static const BYTE TOASCII_KEY_OFF = 0x00; static const BYTE TOASCII_KEY_DOWN = 0x80; static const BYTE TOASCII_KEY_TOGGLED_ON = 0x01; // for CapsLock // Given a key event, ignore a modifier key and return the character that was // entered without the modifier. Writes to *ch and returns the number of bytes // written. static size_t _get_char_ignoring_modifier(char* const ch, const KEY_EVENT_RECORD* const key_event, const DWORD control_key_state, const WORD modifier) { // If there is no character from Windows, try ignoring the specified // modifier and look for a character. Note that if AltGr is being used, // there will be a character from Windows. if (key_event->uChar.AsciiChar == '\0') { // Note that we read the control key state from the passed in argument // instead of from key_event since the argument has been normalized. if (((modifier == VK_SHIFT) && _is_shift_pressed(control_key_state)) || ((modifier == VK_CONTROL) && _is_ctrl_pressed(control_key_state)) || ((modifier == VK_MENU) && _is_alt_pressed(control_key_state))) { BYTE key_state[256] = {0}; key_state[VK_SHIFT] = _is_shift_pressed(control_key_state) ? TOASCII_KEY_DOWN : TOASCII_KEY_OFF; key_state[VK_CONTROL] = _is_ctrl_pressed(control_key_state) ? TOASCII_KEY_DOWN : TOASCII_KEY_OFF; key_state[VK_MENU] = _is_alt_pressed(control_key_state) ? TOASCII_KEY_DOWN : TOASCII_KEY_OFF; key_state[VK_CAPITAL] = _is_capslock_on(control_key_state) ? TOASCII_KEY_TOGGLED_ON : TOASCII_KEY_OFF; // cause this modifier to be ignored key_state[modifier] = TOASCII_KEY_OFF; WORD translated = 0; if (ToAscii(key_event->wVirtualKeyCode, key_event->wVirtualScanCode, key_state, &translated, 0) == 1) { // Ignoring the modifier, we found a character. *ch = (CHAR)translated; return 1; } } } // Just use whatever Windows told us originally. *ch = key_event->uChar.AsciiChar; // If the character from Windows is NULL, return a size of zero. return (*ch == '\0') ? 0 : 1; } // If a Ctrl key is pressed, lookup the character, ignoring the Ctrl key, // but taking into account the shift key. This is because for a sequence like // Ctrl-Alt-0, we want to find the character '0' and for Ctrl-Alt-Shift-0, // we want to find the character ')'. // // Note that Windows doesn't seem to pass bKeyDown for Ctrl-Shift-NoAlt-0 // because it is the default key-sequence to switch the input language. // This is configurable in the Region and Language control panel. static __inline__ size_t _get_non_control_char(char* const ch, const KEY_EVENT_RECORD* const key_event, const DWORD control_key_state) { return _get_char_ignoring_modifier(ch, key_event, control_key_state, VK_CONTROL); } // Get without Alt. static __inline__ size_t _get_non_alt_char(char* const ch, const KEY_EVENT_RECORD* const key_event, const DWORD control_key_state) { return _get_char_ignoring_modifier(ch, key_event, control_key_state, VK_MENU); } // Ignore the control key, find the character from Windows, and apply any // Control key mappings (for example, Ctrl-2 is a NULL character). Writes to // *pch and returns number of bytes written. static size_t _get_control_character(char* const pch, const KEY_EVENT_RECORD* const key_event, const DWORD control_key_state) { const size_t len = _get_non_control_char(pch, key_event, control_key_state); if ((len == 1) && _is_ctrl_pressed(control_key_state)) { char ch = *pch; switch (ch) { case '2': case '@': case '`': ch = '\0'; break; case '3': case '[': case '{': ch = '\x1b'; break; case '4': case '\\': case '|': ch = '\x1c'; break; case '5': case ']': case '}': ch = '\x1d'; break; case '6': case '^': case '~': ch = '\x1e'; break; case '7': case '-': case '_': ch = '\x1f'; break; case '8': ch = '\x7f'; break; case '/': if (!_is_alt_pressed(control_key_state)) { ch = '\x1f'; } break; case '?': if (!_is_alt_pressed(control_key_state)) { ch = '\x7f'; } break; } *pch = ch; } return len; } static DWORD _normalize_altgr_control_key_state( const KEY_EVENT_RECORD* const key_event) { DWORD control_key_state = key_event->dwControlKeyState; // If we're in an AltGr situation where the AltGr key is down (depending on // the keyboard layout, that might be the physical right alt key which // produces a control_key_state where Right-Alt and Left-Ctrl are down) or // AltGr-equivalent keys are down (any Ctrl key + any Alt key), and we have // a character (which indicates that there was an AltGr mapping), then act // as if alt and control are not really down for the purposes of modifiers. // This makes it so that if the user with, say, a German keyboard layout // presses AltGr-] (which we see as Right-Alt + Left-Ctrl + key), we just // output the key and we don't see the Alt and Ctrl keys. if (_is_ctrl_pressed(control_key_state) && _is_alt_pressed(control_key_state) && (key_event->uChar.AsciiChar != '\0')) { // Try to remove as few bits as possible to improve our chances of // detecting combinations like Left-Alt + AltGr, Right-Ctrl + AltGr, or // Left-Alt + Right-Ctrl + AltGr. if ((control_key_state & RIGHT_ALT_PRESSED) != 0) { // Remove Right-Alt. control_key_state &= ~RIGHT_ALT_PRESSED; // If uChar is set, a Ctrl key is pressed, and Right-Alt is // pressed, Left-Ctrl is almost always set, except if the user // presses Right-Ctrl, then AltGr (in that specific order) for // whatever reason. At any rate, make sure the bit is not set. control_key_state &= ~LEFT_CTRL_PRESSED; } else if ((control_key_state & LEFT_ALT_PRESSED) != 0) { // Remove Left-Alt. control_key_state &= ~LEFT_ALT_PRESSED; // Whichever Ctrl key is down, remove it from the state. We only // remove one key, to improve our chances of detecting the // corner-case of Left-Ctrl + Left-Alt + Right-Ctrl. if ((control_key_state & LEFT_CTRL_PRESSED) != 0) { // Remove Left-Ctrl. control_key_state &= ~LEFT_CTRL_PRESSED; } else if ((control_key_state & RIGHT_CTRL_PRESSED) != 0) { // Remove Right-Ctrl. control_key_state &= ~RIGHT_CTRL_PRESSED; } } // Note that this logic isn't 100% perfect because Windows doesn't // allow us to detect all combinations because a physical AltGr key // press shows up as two bits, plus some combinations are ambiguous // about what is actually physically pressed. } return control_key_state; } // If NumLock is on and Shift is pressed, SHIFT_PRESSED is not set in // dwControlKeyState for the following keypad keys: period, 0-9. If we detect // this scenario, set the SHIFT_PRESSED bit so we can add modifiers // appropriately. static DWORD _normalize_keypad_control_key_state(const WORD vk, const DWORD control_key_state) { if (!_is_numlock_on(control_key_state)) { return control_key_state; } if (!_is_enhanced_key(control_key_state)) { switch (vk) { case VK_INSERT: // 0 case VK_DELETE: // . case VK_END: // 1 case VK_DOWN: // 2 case VK_NEXT: // 3 case VK_LEFT: // 4 case VK_CLEAR: // 5 case VK_RIGHT: // 6 case VK_HOME: // 7 case VK_UP: // 8 case VK_PRIOR: // 9 return control_key_state | SHIFT_PRESSED; } } return control_key_state; } static const char* _get_keypad_sequence(const DWORD control_key_state, const char* const normal, const char* const shifted) { if (_is_shift_pressed(control_key_state)) { // Shift is pressed and NumLock is off return shifted; } else { // Shift is not pressed and NumLock is off, or, // Shift is pressed and NumLock is on, in which case we want the // NumLock and Shift to neutralize each other, thus, we want the normal // sequence. return normal; } // If Shift is not pressed and NumLock is on, a different virtual key code // is returned by Windows, which can be taken care of by a different case // statement in _console_read(). } // Write sequence to buf and return the number of bytes written. static size_t _get_modifier_sequence(char* const buf, const WORD vk, DWORD control_key_state, const char* const normal) { // Copy the base sequence into buf. const size_t len = strlen(normal); memcpy(buf, normal, len); int code = 0; control_key_state = _normalize_keypad_control_key_state(vk, control_key_state); if (_is_shift_pressed(control_key_state)) { code |= 0x1; } if (_is_alt_pressed(control_key_state)) { // any alt key pressed code |= 0x2; } if (_is_ctrl_pressed(control_key_state)) { // any control key pressed code |= 0x4; } // If some modifier was held down, then we need to insert the modifier code if (code != 0) { if (len == 0) { // Should be impossible because caller should pass a string of // non-zero length. return 0; } size_t index = len - 1; const char lastChar = buf[index]; if (lastChar != '~') { buf[index++] = '1'; } buf[index++] = ';'; // modifier separator // 2 = shift, 3 = alt, 4 = shift & alt, 5 = control, // 6 = shift & control, 7 = alt & control, 8 = shift & alt & control buf[index++] = '1' + code; buf[index++] = lastChar; // move ~ (or other last char) to the end return index; } return len; } // Write sequence to buf and return the number of bytes written. static size_t _get_modifier_keypad_sequence(char* const buf, const WORD vk, const DWORD control_key_state, const char* const normal, const char shifted) { if (_is_shift_pressed(control_key_state)) { // Shift is pressed and NumLock is off if (shifted != '\0') { buf[0] = shifted; return sizeof(buf[0]); } else { return 0; } } else { // Shift is not pressed and NumLock is off, or, // Shift is pressed and NumLock is on, in which case we want the // NumLock and Shift to neutralize each other, thus, we want the normal // sequence. return _get_modifier_sequence(buf, vk, control_key_state, normal); } // If Shift is not pressed and NumLock is on, a different virtual key code // is returned by Windows, which can be taken care of by a different case // statement in _console_read(). } // The decimal key on the keypad produces a '.' for U.S. English and a ',' for // Standard German. Figure this out at runtime so we know what to output for // Shift-VK_DELETE. static char _get_decimal_char() { return (char)MapVirtualKeyA(VK_DECIMAL, MAPVK_VK_TO_CHAR); } // Prefix the len bytes in buf with the escape character, and then return the // new buffer length. size_t _escape_prefix(char* const buf, const size_t len) { // If nothing to prefix, don't do anything. We might be called with // len == 0, if alt was held down with a dead key which produced nothing. if (len == 0) { return 0; } memmove(&buf[1], buf, len); buf[0] = '\x1b'; return len + 1; } // Internal buffer to satisfy future _console_read() calls. static auto& g_console_input_buffer = *new std::vector(); // Writes to buffer buf (of length len), returning number of bytes written or -1 on error. Never // returns zero on console closure because Win32 consoles are never 'closed' (as far as I can tell). static int _console_read(const HANDLE console, void* buf, size_t len) { for (;;) { // Read of zero bytes should not block waiting for something from the console. if (len == 0) { return 0; } // Flush as much as possible from input buffer. if (!g_console_input_buffer.empty()) { const int bytes_read = std::min(len, g_console_input_buffer.size()); memcpy(buf, g_console_input_buffer.data(), bytes_read); const auto begin = g_console_input_buffer.begin(); g_console_input_buffer.erase(begin, begin + bytes_read); return bytes_read; } // Read from the actual console. This may block until input. INPUT_RECORD input_record; if (!_get_key_event_record(console, &input_record)) { return -1; } KEY_EVENT_RECORD* const key_event = &input_record.Event.KeyEvent; const WORD vk = key_event->wVirtualKeyCode; const CHAR ch = key_event->uChar.AsciiChar; const DWORD control_key_state = _normalize_altgr_control_key_state( key_event); // The following emulation code should write the output sequence to // either seqstr or to seqbuf and seqbuflen. const char* seqstr = NULL; // NULL terminated C-string // Enough space for max sequence string below, plus modifiers and/or // escape prefix. char seqbuf[16]; size_t seqbuflen = 0; // Space used in seqbuf. #define MATCH(vk, normal) \ case (vk): \ { \ seqstr = (normal); \ } \ break; // Modifier keys should affect the output sequence. #define MATCH_MODIFIER(vk, normal) \ case (vk): \ { \ seqbuflen = _get_modifier_sequence(seqbuf, (vk), \ control_key_state, (normal)); \ } \ break; // The shift key should affect the output sequence. #define MATCH_KEYPAD(vk, normal, shifted) \ case (vk): \ { \ seqstr = _get_keypad_sequence(control_key_state, (normal), \ (shifted)); \ } \ break; // The shift key and other modifier keys should affect the output // sequence. #define MATCH_MODIFIER_KEYPAD(vk, normal, shifted) \ case (vk): \ { \ seqbuflen = _get_modifier_keypad_sequence(seqbuf, (vk), \ control_key_state, (normal), (shifted)); \ } \ break; #define ESC "\x1b" #define CSI ESC "[" #define SS3 ESC "O" // Only support normal mode, not application mode. // Enhanced keys: // * 6-pack: insert, delete, home, end, page up, page down // * cursor keys: up, down, right, left // * keypad: divide, enter // * Undocumented: VK_PAUSE (Ctrl-NumLock), VK_SNAPSHOT, // VK_CANCEL (Ctrl-Pause/Break), VK_NUMLOCK if (_is_enhanced_key(control_key_state)) { switch (vk) { case VK_RETURN: // Enter key on keypad if (_is_ctrl_pressed(control_key_state)) { seqstr = "\n"; } else { seqstr = "\r"; } break; MATCH_MODIFIER(VK_PRIOR, CSI "5~"); // Page Up MATCH_MODIFIER(VK_NEXT, CSI "6~"); // Page Down // gnome-terminal currently sends SS3 "F" and SS3 "H", but that // will be fixed soon to match xterm which sends CSI "F" and // CSI "H". https://bugzilla.redhat.com/show_bug.cgi?id=1119764 MATCH(VK_END, CSI "F"); MATCH(VK_HOME, CSI "H"); MATCH_MODIFIER(VK_LEFT, CSI "D"); MATCH_MODIFIER(VK_UP, CSI "A"); MATCH_MODIFIER(VK_RIGHT, CSI "C"); MATCH_MODIFIER(VK_DOWN, CSI "B"); MATCH_MODIFIER(VK_INSERT, CSI "2~"); MATCH_MODIFIER(VK_DELETE, CSI "3~"); MATCH(VK_DIVIDE, "/"); } } else { // Non-enhanced keys: switch (vk) { case VK_BACK: // backspace if (_is_alt_pressed(control_key_state)) { seqstr = ESC "\x7f"; } else { seqstr = "\x7f"; } break; case VK_TAB: if (_is_shift_pressed(control_key_state)) { seqstr = CSI "Z"; } else { seqstr = "\t"; } break; // Number 5 key in keypad when NumLock is off, or if NumLock is // on and Shift is down. MATCH_KEYPAD(VK_CLEAR, CSI "E", "5"); case VK_RETURN: // Enter key on main keyboard if (_is_alt_pressed(control_key_state)) { seqstr = ESC "\n"; } else if (_is_ctrl_pressed(control_key_state)) { seqstr = "\n"; } else { seqstr = "\r"; } break; // VK_ESCAPE: Don't do any special handling. The OS uses many // of the sequences with Escape and many of the remaining // sequences don't produce bKeyDown messages, only !bKeyDown // for whatever reason. case VK_SPACE: if (_is_alt_pressed(control_key_state)) { seqstr = ESC " "; } else if (_is_ctrl_pressed(control_key_state)) { seqbuf[0] = '\0'; // NULL char seqbuflen = 1; } else { seqstr = " "; } break; MATCH_MODIFIER_KEYPAD(VK_PRIOR, CSI "5~", '9'); // Page Up MATCH_MODIFIER_KEYPAD(VK_NEXT, CSI "6~", '3'); // Page Down MATCH_KEYPAD(VK_END, CSI "4~", "1"); MATCH_KEYPAD(VK_HOME, CSI "1~", "7"); MATCH_MODIFIER_KEYPAD(VK_LEFT, CSI "D", '4'); MATCH_MODIFIER_KEYPAD(VK_UP, CSI "A", '8'); MATCH_MODIFIER_KEYPAD(VK_RIGHT, CSI "C", '6'); MATCH_MODIFIER_KEYPAD(VK_DOWN, CSI "B", '2'); MATCH_MODIFIER_KEYPAD(VK_INSERT, CSI "2~", '0'); MATCH_MODIFIER_KEYPAD(VK_DELETE, CSI "3~", _get_decimal_char()); case 0x30: // 0 case 0x31: // 1 case 0x39: // 9 case VK_OEM_1: // ;: case VK_OEM_PLUS: // =+ case VK_OEM_COMMA: // ,< case VK_OEM_PERIOD: // .> case VK_OEM_7: // '" case VK_OEM_102: // depends on keyboard, could be <> or \| case VK_OEM_2: // /? case VK_OEM_3: // `~ case VK_OEM_4: // [{ case VK_OEM_5: // \| case VK_OEM_6: // ]} { seqbuflen = _get_control_character(seqbuf, key_event, control_key_state); if (_is_alt_pressed(control_key_state)) { seqbuflen = _escape_prefix(seqbuf, seqbuflen); } } break; case 0x32: // 2 case 0x33: // 3 case 0x34: // 4 case 0x35: // 5 case 0x36: // 6 case 0x37: // 7 case 0x38: // 8 case VK_OEM_MINUS: // -_ { seqbuflen = _get_control_character(seqbuf, key_event, control_key_state); // If Alt is pressed and it isn't Ctrl-Alt-ShiftUp, then // prefix with escape. if (_is_alt_pressed(control_key_state) && !(_is_ctrl_pressed(control_key_state) && !_is_shift_pressed(control_key_state))) { seqbuflen = _escape_prefix(seqbuf, seqbuflen); } } break; case 0x41: // a case 0x42: // b case 0x43: // c case 0x44: // d case 0x45: // e case 0x46: // f case 0x47: // g case 0x48: // h case 0x49: // i case 0x4a: // j case 0x4b: // k case 0x4c: // l case 0x4d: // m case 0x4e: // n case 0x4f: // o case 0x50: // p case 0x51: // q case 0x52: // r case 0x53: // s case 0x54: // t case 0x55: // u case 0x56: // v case 0x57: // w case 0x58: // x case 0x59: // y case 0x5a: // z { seqbuflen = _get_non_alt_char(seqbuf, key_event, control_key_state); // If Alt is pressed, then prefix with escape. if (_is_alt_pressed(control_key_state)) { seqbuflen = _escape_prefix(seqbuf, seqbuflen); } } break; // These virtual key codes are generated by the keys on the // keypad *when NumLock is on* and *Shift is up*. MATCH(VK_NUMPAD0, "0"); MATCH(VK_NUMPAD1, "1"); MATCH(VK_NUMPAD2, "2"); MATCH(VK_NUMPAD3, "3"); MATCH(VK_NUMPAD4, "4"); MATCH(VK_NUMPAD5, "5"); MATCH(VK_NUMPAD6, "6"); MATCH(VK_NUMPAD7, "7"); MATCH(VK_NUMPAD8, "8"); MATCH(VK_NUMPAD9, "9"); MATCH(VK_MULTIPLY, "*"); MATCH(VK_ADD, "+"); MATCH(VK_SUBTRACT, "-"); // VK_DECIMAL is generated by the . key on the keypad *when // NumLock is on* and *Shift is up* and the sequence is not // Ctrl-Alt-NoShift-. (which causes Ctrl-Alt-Del and the // Windows Security screen to come up). case VK_DECIMAL: // U.S. English uses '.', Germany German uses ','. seqbuflen = _get_non_control_char(seqbuf, key_event, control_key_state); break; MATCH_MODIFIER(VK_F1, SS3 "P"); MATCH_MODIFIER(VK_F2, SS3 "Q"); MATCH_MODIFIER(VK_F3, SS3 "R"); MATCH_MODIFIER(VK_F4, SS3 "S"); MATCH_MODIFIER(VK_F5, CSI "15~"); MATCH_MODIFIER(VK_F6, CSI "17~"); MATCH_MODIFIER(VK_F7, CSI "18~"); MATCH_MODIFIER(VK_F8, CSI "19~"); MATCH_MODIFIER(VK_F9, CSI "20~"); MATCH_MODIFIER(VK_F10, CSI "21~"); MATCH_MODIFIER(VK_F11, CSI "23~"); MATCH_MODIFIER(VK_F12, CSI "24~"); MATCH_MODIFIER(VK_F13, CSI "25~"); MATCH_MODIFIER(VK_F14, CSI "26~"); MATCH_MODIFIER(VK_F15, CSI "28~"); MATCH_MODIFIER(VK_F16, CSI "29~"); MATCH_MODIFIER(VK_F17, CSI "31~"); MATCH_MODIFIER(VK_F18, CSI "32~"); MATCH_MODIFIER(VK_F19, CSI "33~"); MATCH_MODIFIER(VK_F20, CSI "34~"); // MATCH_MODIFIER(VK_F21, ???); // MATCH_MODIFIER(VK_F22, ???); // MATCH_MODIFIER(VK_F23, ???); // MATCH_MODIFIER(VK_F24, ???); } } #undef MATCH #undef MATCH_MODIFIER #undef MATCH_KEYPAD #undef MATCH_MODIFIER_KEYPAD #undef ESC #undef CSI #undef SS3 const char* out; size_t outlen; // Check for output in any of: // * seqstr is set (and strlen can be used to determine the length). // * seqbuf and seqbuflen are set // Fallback to ch from Windows. if (seqstr != NULL) { out = seqstr; outlen = strlen(seqstr); } else if (seqbuflen > 0) { out = seqbuf; outlen = seqbuflen; } else if (ch != '\0') { // Use whatever Windows told us it is. seqbuf[0] = ch; seqbuflen = 1; out = seqbuf; outlen = seqbuflen; } else { // No special handling for the virtual key code and Windows isn't // telling us a character code, then we don't know how to translate // the key press. // // Consume the input and 'continue' to cause us to get a new key // event. D("_console_read: unknown virtual key code: %d, enhanced: %s", vk, _is_enhanced_key(control_key_state) ? "true" : "false"); continue; } // put output wRepeatCount times into g_console_input_buffer while (key_event->wRepeatCount-- > 0) { g_console_input_buffer.insert(g_console_input_buffer.end(), out, out + outlen); } // Loop around and try to flush g_console_input_buffer } } static DWORD _old_console_mode; // previous GetConsoleMode() result static HANDLE _console_handle; // when set, console mode should be restored void stdin_raw_init() { const HANDLE in = _get_console_handle(STDIN_FILENO, &_old_console_mode); if (in == nullptr) { return; } // Disable ENABLE_PROCESSED_INPUT so that Ctrl-C is read instead of // calling the process Ctrl-C routine (configured by // SetConsoleCtrlHandler()). // Disable ENABLE_LINE_INPUT so that input is immediately sent. // Disable ENABLE_ECHO_INPUT to disable local echo. Disabling this // flag also seems necessary to have proper line-ending processing. DWORD new_console_mode = _old_console_mode & ~(ENABLE_PROCESSED_INPUT | ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT); // Enable ENABLE_WINDOW_INPUT to get window resizes. new_console_mode |= ENABLE_WINDOW_INPUT; if (!SetConsoleMode(in, new_console_mode)) { // This really should not fail. D("stdin_raw_init: SetConsoleMode() failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); } // Once this is set, it means that stdin has been configured for // reading from and that the old console mode should be restored later. _console_handle = in; // Note that we don't need to configure C Runtime line-ending // translation because _console_read() does not call the C Runtime to // read from the console. } void stdin_raw_restore() { if (_console_handle != NULL) { const HANDLE in = _console_handle; _console_handle = NULL; // clear state if (!SetConsoleMode(in, _old_console_mode)) { // This really should not fail. D("stdin_raw_restore: SetConsoleMode() failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); } } } // Called by 'adb shell' and 'adb exec-in' (via unix_read()) to read from stdin. int unix_read_interruptible(int fd, void* buf, size_t len) { if ((fd == STDIN_FILENO) && (_console_handle != NULL)) { // If it is a request to read from stdin, and stdin_raw_init() has been // called, and it successfully configured the console, then read from // the console using Win32 console APIs and partially emulate a unix // terminal. return _console_read(_console_handle, buf, len); } else { // On older versions of Windows (definitely 7, definitely not 10), // ReadConsole() with a size >= 31367 fails, so if |fd| is a console // we need to limit the read size. if (len > 4096 && unix_isatty(fd)) { len = 4096; } // Just call into C Runtime which can read from pipes/files and which // can do LF/CR translation (which is overridable with _setmode()). // Undefine the macro that is set in sysdeps.h which bans calls to // plain read() in favor of unix_read() or adb_read(). #pragma push_macro("read") #undef read return read(fd, buf, len); #pragma pop_macro("read") } } /**************************************************************************/ /**************************************************************************/ /***** *****/ /***** Unicode support *****/ /***** *****/ /**************************************************************************/ /**************************************************************************/ // This implements support for using files with Unicode filenames and for // outputting Unicode text to a Win32 console window. This is inspired from // http://utf8everywhere.org/. // // Background // ---------- // // On POSIX systems, to deal with files with Unicode filenames, just pass UTF-8 // filenames to APIs such as open(). This works because filenames are largely // opaque 'cookies' (perhaps excluding path separators). // // On Windows, the native file APIs such as CreateFileW() take 2-byte wchar_t // UTF-16 strings. There is an API, CreateFileA() that takes 1-byte char // strings, but the strings are in the ANSI codepage and not UTF-8. (The // CreateFile() API is really just a macro that adds the W/A based on whether // the UNICODE preprocessor symbol is defined). // // Options // ------- // // Thus, to write a portable program, there are a few options: // // 1. Write the program with wchar_t filenames (wchar_t path[256];). // For Windows, just call CreateFileW(). For POSIX, write a wrapper openW() // that takes a wchar_t string, converts it to UTF-8 and then calls the real // open() API. // // 2. Write the program with a TCHAR typedef that is 2 bytes on Windows and // 1 byte on POSIX. Make T-* wrappers for various OS APIs and call those, // potentially touching a lot of code. // // 3. Write the program with a 1-byte char filenames (char path[256];) that are // UTF-8. For POSIX, just call open(). For Windows, write a wrapper that // takes a UTF-8 string, converts it to UTF-16 and then calls the real OS // or C Runtime API. // // The Choice // ---------- // // The code below chooses option 3, the UTF-8 everywhere strategy. It uses // android::base::WideToUTF8() which converts UTF-16 to UTF-8. This is used by the // NarrowArgs helper class that is used to convert wmain() args into UTF-8 // args that are passed to main() at the beginning of program startup. We also use // android::base::UTF8ToWide() which converts from UTF-8 to UTF-16. This is used to // implement wrappers below that call UTF-16 OS and C Runtime APIs. // // Unicode console output // ---------------------- // // The way to output Unicode to a Win32 console window is to call // WriteConsoleW() with UTF-16 text. (The user must also choose a proper font // such as Lucida Console or Consolas, and in the case of East Asian languages // (such as Chinese, Japanese, Korean), the user must go to the Control Panel // and change the "system locale" to Chinese, etc., which allows a Chinese, etc. // font to be used in console windows.) // // The problem is getting the C Runtime to make fprintf and related APIs call // WriteConsoleW() under the covers. The C Runtime API, _setmode() sounds // promising, but the various modes have issues: // // 1. _setmode(_O_TEXT) (the default) does not use WriteConsoleW() so UTF-8 and // UTF-16 do not display properly. // 2. _setmode(_O_BINARY) does not use WriteConsoleW() and the text comes out // totally wrong. // 3. _setmode(_O_U8TEXT) seems to cause the C Runtime _invalid_parameter // handler to be called (upon a later I/O call), aborting the process. // 4. _setmode(_O_U16TEXT) and _setmode(_O_WTEXT) cause non-wide printf/fprintf // to output nothing. // // So the only solution is to write our own adb_fprintf() that converts UTF-8 // to UTF-16 and then calls WriteConsoleW(). // Constructor for helper class to convert wmain() UTF-16 args to UTF-8 to // be passed to main(). NarrowArgs::NarrowArgs(const int argc, wchar_t** const argv) { narrow_args = new char*[argc + 1]; for (int i = 0; i < argc; ++i) { std::string arg_narrow; if (!android::base::WideToUTF8(argv[i], &arg_narrow)) { fatal_errno("cannot convert argument from UTF-16 to UTF-8"); } narrow_args[i] = strdup(arg_narrow.c_str()); } narrow_args[argc] = nullptr; // terminate } NarrowArgs::~NarrowArgs() { if (narrow_args != nullptr) { for (char** argp = narrow_args; *argp != nullptr; ++argp) { free(*argp); } delete[] narrow_args; narrow_args = nullptr; } } int unix_open(const char* path, int options, ...) { std::wstring path_wide; if (!android::base::UTF8ToWide(path, &path_wide)) { return -1; } if ((options & O_CREAT) == 0) { return _wopen(path_wide.c_str(), options); } else { int mode; va_list args; va_start(args, options); mode = va_arg(args, int); va_end(args); return _wopen(path_wide.c_str(), options, mode); } } // Version of stat() that takes a UTF-8 path. int adb_stat(const char* path, struct adb_stat* s) { #pragma push_macro("wstat") // This definition of wstat seems to be missing from . #if defined(_FILE_OFFSET_BITS) && (_FILE_OFFSET_BITS == 64) #ifdef _USE_32BIT_TIME_T #define wstat _wstat32i64 #else #define wstat _wstat64 #endif #else // has a function prototype for wstat() that should be available. #endif std::wstring path_wide; if (!android::base::UTF8ToWide(path, &path_wide)) { return -1; } return wstat(path_wide.c_str(), s); #pragma pop_macro("wstat") } // Version of opendir() that takes a UTF-8 path. DIR* adb_opendir(const char* path) { std::wstring path_wide; if (!android::base::UTF8ToWide(path, &path_wide)) { return nullptr; } // Just cast _WDIR* to DIR*. This doesn't work if the caller reads any of // the fields, but right now all the callers treat the structure as // opaque. return reinterpret_cast(_wopendir(path_wide.c_str())); } // Version of readdir() that returns UTF-8 paths. struct dirent* adb_readdir(DIR* dir) { _WDIR* const wdir = reinterpret_cast<_WDIR*>(dir); struct _wdirent* const went = _wreaddir(wdir); if (went == nullptr) { return nullptr; } // Convert from UTF-16 to UTF-8. std::string name_utf8; if (!android::base::WideToUTF8(went->d_name, &name_utf8)) { return nullptr; } // Cast the _wdirent* to dirent* and overwrite the d_name field (which has // space for UTF-16 wchar_t's) with UTF-8 char's. struct dirent* ent = reinterpret_cast(went); if (name_utf8.length() + 1 > sizeof(went->d_name)) { // Name too big to fit in existing buffer. errno = ENOMEM; return nullptr; } // Note that sizeof(_wdirent::d_name) is bigger than sizeof(dirent::d_name) // because _wdirent contains wchar_t instead of char. So even if name_utf8 // can fit in _wdirent::d_name, the resulting dirent::d_name field may be // bigger than the caller expects because they expect a dirent structure // which has a smaller d_name field. Ignore this since the caller should be // resilient. // Rewrite the UTF-16 d_name field to UTF-8. strcpy(ent->d_name, name_utf8.c_str()); return ent; } // Version of closedir() to go with our version of adb_opendir(). int adb_closedir(DIR* dir) { return _wclosedir(reinterpret_cast<_WDIR*>(dir)); } // Version of unlink() that takes a UTF-8 path. int adb_unlink(const char* path) { std::wstring wpath; if (!android::base::UTF8ToWide(path, &wpath)) { return -1; } int rc = _wunlink(wpath.c_str()); if (rc == -1 && errno == EACCES) { /* unlink returns EACCES when the file is read-only, so we first */ /* try to make it writable, then unlink again... */ rc = _wchmod(wpath.c_str(), _S_IREAD | _S_IWRITE); if (rc == 0) rc = _wunlink(wpath.c_str()); } return rc; } // Version of mkdir() that takes a UTF-8 path. int adb_mkdir(const std::string& path, int mode) { std::wstring path_wide; if (!android::base::UTF8ToWide(path, &path_wide)) { return -1; } return _wmkdir(path_wide.c_str()); } // Version of utime() that takes a UTF-8 path. int adb_utime(const char* path, struct utimbuf* u) { std::wstring path_wide; if (!android::base::UTF8ToWide(path, &path_wide)) { return -1; } static_assert(sizeof(struct utimbuf) == sizeof(struct _utimbuf), "utimbuf and _utimbuf should be the same size because they both " "contain the same types, namely time_t"); return _wutime(path_wide.c_str(), reinterpret_cast(u)); } // Version of chmod() that takes a UTF-8 path. int adb_chmod(const char* path, int mode) { std::wstring path_wide; if (!android::base::UTF8ToWide(path, &path_wide)) { return -1; } return _wchmod(path_wide.c_str(), mode); } // From libutils/Unicode.cpp, get the length of a UTF-8 sequence given the lead byte. static inline size_t utf8_codepoint_len(uint8_t ch) { return ((0xe5000000 >> ((ch >> 3) & 0x1e)) & 3) + 1; } namespace internal { // Given a sequence of UTF-8 bytes (denoted by the range [first, last)), return the number of bytes // (from the beginning) that are complete UTF-8 sequences and append the remaining bytes to // remaining_bytes. size_t ParseCompleteUTF8(const char* const first, const char* const last, std::vector* const remaining_bytes) { // Walk backwards from the end of the sequence looking for the beginning of a UTF-8 sequence. // Current_after points one byte past the current byte to be examined. for (const char* current_after = last; current_after != first; --current_after) { const char* const current = current_after - 1; const char ch = *current; const char kHighBit = 0x80u; const char kTwoHighestBits = 0xC0u; if ((ch & kHighBit) == 0) { // high bit not set // The buffer ends with a one-byte UTF-8 sequence, possibly followed by invalid trailing // bytes with no leading byte, so return the entire buffer. break; } else if ((ch & kTwoHighestBits) == kTwoHighestBits) { // top two highest bits set // Lead byte in UTF-8 sequence, so check if we have all the bytes in the sequence. const size_t bytes_available = last - current; if (bytes_available < utf8_codepoint_len(ch)) { // We don't have all the bytes in the UTF-8 sequence, so return all the bytes // preceding the current incomplete UTF-8 sequence and append the remaining bytes // to remaining_bytes. remaining_bytes->insert(remaining_bytes->end(), current, last); return current - first; } else { // The buffer ends with a complete UTF-8 sequence, possibly followed by invalid // trailing bytes with no lead byte, so return the entire buffer. break; } } else { // Trailing byte, so keep going backwards looking for the lead byte. } } // Return the size of the entire buffer. It is possible that we walked backward past invalid // trailing bytes with no lead byte, in which case we want to return all those invalid bytes // so that they can be processed. return last - first; } } // Bytes that have not yet been output to the console because they are incomplete UTF-8 sequences. // Note that we use only one buffer even though stderr and stdout are logically separate streams. // This matches the behavior of Linux. // Protected by g_console_output_buffer_lock. static auto& g_console_output_buffer = *new std::vector(); // Internal helper function to write UTF-8 bytes to a console. Returns -1 on error. static int _console_write_utf8(const char* const buf, const size_t buf_size, FILE* stream, HANDLE console) { const int saved_errno = errno; std::vector combined_buffer; // Complete UTF-8 sequences that should be immediately written to the console. const char* utf8; size_t utf8_size; adb_mutex_lock(&g_console_output_buffer_lock); if (g_console_output_buffer.empty()) { // If g_console_output_buffer doesn't have a buffered up incomplete UTF-8 sequence (the // common case with plain ASCII), parse buf directly. utf8 = buf; utf8_size = internal::ParseCompleteUTF8(buf, buf + buf_size, &g_console_output_buffer); } else { // If g_console_output_buffer has a buffered up incomplete UTF-8 sequence, move it to // combined_buffer (and effectively clear g_console_output_buffer) and append buf to // combined_buffer, then parse it all together. combined_buffer.swap(g_console_output_buffer); combined_buffer.insert(combined_buffer.end(), buf, buf + buf_size); utf8 = combined_buffer.data(); utf8_size = internal::ParseCompleteUTF8(utf8, utf8 + combined_buffer.size(), &g_console_output_buffer); } adb_mutex_unlock(&g_console_output_buffer_lock); std::wstring utf16; // Try to convert from data that might be UTF-8 to UTF-16, ignoring errors (just like Linux // which does not return an error on bad UTF-8). Data might not be UTF-8 if the user cat's // random data, runs dmesg (which might have non-UTF-8), etc. // This could throw std::bad_alloc. (void)android::base::UTF8ToWide(utf8, utf8_size, &utf16); // Note that this does not do \n => \r\n translation because that // doesn't seem necessary for the Windows console. For the Windows // console \r moves to the beginning of the line and \n moves to a new // line. // Flush any stream buffering so that our output is afterwards which // makes sense because our call is afterwards. (void)fflush(stream); // Write UTF-16 to the console. DWORD written = 0; if (!WriteConsoleW(console, utf16.c_str(), utf16.length(), &written, NULL)) { errno = EIO; return -1; } // Return the size of the original buffer passed in, signifying that we consumed it all, even // if nothing was displayed, in the case of being passed an incomplete UTF-8 sequence. This // matches the Linux behavior. errno = saved_errno; return buf_size; } // Function prototype because attributes cannot be placed on func definitions. static int _console_vfprintf(const HANDLE console, FILE* stream, const char *format, va_list ap) __attribute__((__format__(ADB_FORMAT_ARCHETYPE, 3, 0))); // Internal function to format a UTF-8 string and write it to a Win32 console. // Returns -1 on error. static int _console_vfprintf(const HANDLE console, FILE* stream, const char *format, va_list ap) { const int saved_errno = errno; std::string output_utf8; // Format the string. // This could throw std::bad_alloc. android::base::StringAppendV(&output_utf8, format, ap); const int result = _console_write_utf8(output_utf8.c_str(), output_utf8.length(), stream, console); if (result != -1) { errno = saved_errno; } else { // If -1 was returned, errno has been set. } return result; } // Version of vfprintf() that takes UTF-8 and can write Unicode to a // Windows console. int adb_vfprintf(FILE *stream, const char *format, va_list ap) { const HANDLE console = _get_console_handle(stream); // If there is an associated Win32 console, write to it specially, // otherwise defer to the regular C Runtime, passing it UTF-8. if (console != NULL) { return _console_vfprintf(console, stream, format, ap); } else { // If vfprintf is a macro, undefine it, so we can call the real // C Runtime API. #pragma push_macro("vfprintf") #undef vfprintf return vfprintf(stream, format, ap); #pragma pop_macro("vfprintf") } } // Version of vprintf() that takes UTF-8 and can write Unicode to a Windows console. int adb_vprintf(const char *format, va_list ap) { return adb_vfprintf(stdout, format, ap); } // Version of fprintf() that takes UTF-8 and can write Unicode to a // Windows console. int adb_fprintf(FILE *stream, const char *format, ...) { va_list ap; va_start(ap, format); const int result = adb_vfprintf(stream, format, ap); va_end(ap); return result; } // Version of printf() that takes UTF-8 and can write Unicode to a // Windows console. int adb_printf(const char *format, ...) { va_list ap; va_start(ap, format); const int result = adb_vfprintf(stdout, format, ap); va_end(ap); return result; } // Version of fputs() that takes UTF-8 and can write Unicode to a // Windows console. int adb_fputs(const char* buf, FILE* stream) { // adb_fprintf returns -1 on error, which is conveniently the same as EOF // which fputs (and hence adb_fputs) should return on error. static_assert(EOF == -1, "EOF is not -1, so this code needs to be fixed"); return adb_fprintf(stream, "%s", buf); } // Version of fputc() that takes UTF-8 and can write Unicode to a // Windows console. int adb_fputc(int ch, FILE* stream) { const int result = adb_fprintf(stream, "%c", ch); if (result == -1) { return EOF; } // For success, fputc returns the char, cast to unsigned char, then to int. return static_cast(ch); } // Version of putchar() that takes UTF-8 and can write Unicode to a Windows console. int adb_putchar(int ch) { return adb_fputc(ch, stdout); } // Version of puts() that takes UTF-8 and can write Unicode to a Windows console. int adb_puts(const char* buf) { // adb_printf returns -1 on error, which is conveniently the same as EOF // which puts (and hence adb_puts) should return on error. static_assert(EOF == -1, "EOF is not -1, so this code needs to be fixed"); return adb_printf("%s\n", buf); } // Internal function to write UTF-8 to a Win32 console. Returns the number of // items (of length size) written. On error, returns a short item count or 0. static size_t _console_fwrite(const void* ptr, size_t size, size_t nmemb, FILE* stream, HANDLE console) { const int result = _console_write_utf8(reinterpret_cast(ptr), size * nmemb, stream, console); if (result == -1) { return 0; } return result / size; } // Version of fwrite() that takes UTF-8 and can write Unicode to a // Windows console. size_t adb_fwrite(const void* ptr, size_t size, size_t nmemb, FILE* stream) { const HANDLE console = _get_console_handle(stream); // If there is an associated Win32 console, write to it specially, // otherwise defer to the regular C Runtime, passing it UTF-8. if (console != NULL) { return _console_fwrite(ptr, size, nmemb, stream, console); } else { // If fwrite is a macro, undefine it, so we can call the real // C Runtime API. #pragma push_macro("fwrite") #undef fwrite return fwrite(ptr, size, nmemb, stream); #pragma pop_macro("fwrite") } } // Version of fopen() that takes a UTF-8 filename and can access a file with // a Unicode filename. FILE* adb_fopen(const char* path, const char* mode) { std::wstring path_wide; if (!android::base::UTF8ToWide(path, &path_wide)) { return nullptr; } std::wstring mode_wide; if (!android::base::UTF8ToWide(mode, &mode_wide)) { return nullptr; } return _wfopen(path_wide.c_str(), mode_wide.c_str()); } // Return a lowercase version of the argument. Uses C Runtime tolower() on // each byte which is not UTF-8 aware, and theoretically uses the current C // Runtime locale (which in practice is not changed, so this becomes a ASCII // conversion). static std::string ToLower(const std::string& anycase) { // copy string std::string str(anycase); // transform the copy std::transform(str.begin(), str.end(), str.begin(), tolower); return str; } extern "C" int main(int argc, char** argv); // Link with -municode to cause this wmain() to be used as the program // entrypoint. It will convert the args from UTF-16 to UTF-8 and call the // regular main() with UTF-8 args. extern "C" int wmain(int argc, wchar_t **argv) { // Convert args from UTF-16 to UTF-8 and pass that to main(). NarrowArgs narrow_args(argc, argv); return main(argc, narrow_args.data()); } // Shadow UTF-8 environment variable name/value pairs that are created from // _wenviron the first time that adb_getenv() is called. Note that this is not // currently updated if putenv, setenv, unsetenv are called. Note that no // thread synchronization is done, but we're called early enough in // single-threaded startup that things work ok. static auto& g_environ_utf8 = *new std::unordered_map(); // Make sure that shadow UTF-8 environment variables are setup. static void _ensure_env_setup() { // If some name/value pairs exist, then we've already done the setup below. if (g_environ_utf8.size() != 0) { return; } if (_wenviron == nullptr) { // If _wenviron is null, then -municode probably wasn't used. That // linker flag will cause the entry point to setup _wenviron. It will // also require an implementation of wmain() (which we provide above). fatal("_wenviron is not set, did you link with -municode?"); } // Read name/value pairs from UTF-16 _wenviron and write new name/value // pairs to UTF-8 g_environ_utf8. Note that it probably does not make sense // to use the D() macro here because that tracing only works if the // ADB_TRACE environment variable is setup, but that env var can't be read // until this code completes. for (wchar_t** env = _wenviron; *env != nullptr; ++env) { wchar_t* const equal = wcschr(*env, L'='); if (equal == nullptr) { // Malformed environment variable with no equal sign. Shouldn't // really happen, but we should be resilient to this. continue; } // If we encounter an error converting UTF-16, don't error-out on account of a single env // var because the program might never even read this particular variable. std::string name_utf8; if (!android::base::WideToUTF8(*env, equal - *env, &name_utf8)) { continue; } // Store lowercase name so that we can do case-insensitive searches. name_utf8 = ToLower(name_utf8); std::string value_utf8; if (!android::base::WideToUTF8(equal + 1, &value_utf8)) { continue; } char* const value_dup = strdup(value_utf8.c_str()); // Don't overwrite a previus env var with the same name. In reality, // the system probably won't let two env vars with the same name exist // in _wenviron. g_environ_utf8.insert({name_utf8, value_dup}); } } // Version of getenv() that takes a UTF-8 environment variable name and // retrieves a UTF-8 value. Case-insensitive to match getenv() on Windows. char* adb_getenv(const char* name) { _ensure_env_setup(); // Case-insensitive search by searching for lowercase name in a map of // lowercase names. const auto it = g_environ_utf8.find(ToLower(std::string(name))); if (it == g_environ_utf8.end()) { return nullptr; } return it->second; } // Version of getcwd() that returns the current working directory in UTF-8. char* adb_getcwd(char* buf, int size) { wchar_t* wbuf = _wgetcwd(nullptr, 0); if (wbuf == nullptr) { return nullptr; } std::string buf_utf8; const bool narrow_result = android::base::WideToUTF8(wbuf, &buf_utf8); free(wbuf); wbuf = nullptr; if (!narrow_result) { return nullptr; } // If size was specified, make sure all the chars will fit. if (size != 0) { if (size < static_cast(buf_utf8.length() + 1)) { errno = ERANGE; return nullptr; } } // If buf was not specified, allocate storage. if (buf == nullptr) { if (size == 0) { size = buf_utf8.length() + 1; } buf = reinterpret_cast(malloc(size)); if (buf == nullptr) { return nullptr; } } // Destination buffer was allocated with enough space, or we've already // checked an existing buffer size for enough space. strcpy(buf, buf_utf8.c_str()); return buf; } adb/sysdeps_win32_test.cpp0100755 0000000 0000000 00000020436 12767234553 014640 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include "sysdeps.h" #include TEST(sysdeps_win32, adb_getenv) { // Insert all test env vars before first call to adb_getenv() which will // read the env var block only once. ASSERT_EQ(0, _putenv("SYSDEPS_WIN32_TEST_UPPERCASE=1")); ASSERT_EQ(0, _putenv("sysdeps_win32_test_lowercase=2")); ASSERT_EQ(0, _putenv("Sysdeps_Win32_Test_MixedCase=3")); // UTF-16 value ASSERT_EQ(0, _wputenv(L"SYSDEPS_WIN32_TEST_UNICODE=\u00a1\u0048\u006f\u006c" L"\u0061\u0021\u03b1\u03b2\u03b3\u0061\u006d\u0062" L"\u0075\u006c\u014d\u043f\u0440\u0438\u0432\u0435" L"\u0442")); // Search for non-existant env vars. EXPECT_STREQ(nullptr, adb_getenv("SYSDEPS_WIN32_TEST_NONEXISTANT")); // Search for existing env vars. // There is no test for an env var with a value of a zero-length string // because _putenv() does not support inserting such an env var. // Search for env var that is uppercase. EXPECT_STREQ("1", adb_getenv("SYSDEPS_WIN32_TEST_UPPERCASE")); EXPECT_STREQ("1", adb_getenv("sysdeps_win32_test_uppercase")); EXPECT_STREQ("1", adb_getenv("Sysdeps_Win32_Test_Uppercase")); // Search for env var that is lowercase. EXPECT_STREQ("2", adb_getenv("SYSDEPS_WIN32_TEST_LOWERCASE")); EXPECT_STREQ("2", adb_getenv("sysdeps_win32_test_lowercase")); EXPECT_STREQ("2", adb_getenv("Sysdeps_Win32_Test_Lowercase")); // Search for env var that is mixed-case. EXPECT_STREQ("3", adb_getenv("SYSDEPS_WIN32_TEST_MIXEDCASE")); EXPECT_STREQ("3", adb_getenv("sysdeps_win32_test_mixedcase")); EXPECT_STREQ("3", adb_getenv("Sysdeps_Win32_Test_MixedCase")); // Check that UTF-16 was converted to UTF-8. EXPECT_STREQ("\xc2\xa1\x48\x6f\x6c\x61\x21\xce\xb1\xce\xb2\xce\xb3\x61\x6d" "\x62\x75\x6c\xc5\x8d\xd0\xbf\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5" "\xd1\x82", adb_getenv("SYSDEPS_WIN32_TEST_UNICODE")); // Check an env var that should always be set. const char* path_val = adb_getenv("PATH"); EXPECT_NE(nullptr, path_val); if (path_val != nullptr) { EXPECT_GT(strlen(path_val), 0U); } } void TestAdbStrError(int err, const char* expected) { errno = 12345; const char* result = adb_strerror(err); // Check that errno is not overwritten. EXPECT_EQ(12345, errno); EXPECT_STREQ(expected, result); } TEST(sysdeps_win32, adb_strerror) { // Test an error code that should not have a mapped string. Use an error // code that is not used by the internal implementation of adb_strerror(). TestAdbStrError(-2, "Unknown error"); // adb_strerror() uses -1 internally, so test that it can still be passed // as a parameter. TestAdbStrError(-1, "Unknown error"); // Test very big, positive unknown error. TestAdbStrError(1000000, "Unknown error"); // Test success case. // Wine returns "Success" for strerror(0), Windows returns "No error", so accept both. std::string success = adb_strerror(0); EXPECT_TRUE(success == "Success" || success == "No error") << "strerror(0) = " << success; // Test error that regular strerror() should have a string for. TestAdbStrError(EPERM, "Operation not permitted"); // Test error that regular strerror() doesn't have a string for, but that // adb_strerror() returns. TestAdbStrError(ECONNRESET, "Connection reset by peer"); } TEST(sysdeps_win32, unix_isatty) { // stdin and stdout should be consoles. Use CONIN$ and CONOUT$ special files // so that we can test this even if stdin/stdout have been redirected. Read // permissions are required for unix_isatty(). int conin_fd = unix_open("CONIN$", O_RDONLY); int conout_fd = unix_open("CONOUT$", O_RDWR); for (const int fd : {conin_fd, conout_fd}) { EXPECT_TRUE(fd >= 0); EXPECT_EQ(1, unix_isatty(fd)); EXPECT_EQ(0, unix_close(fd)); } // nul returns 1 from isatty(), make sure unix_isatty() corrects that. for (auto flags : {O_RDONLY, O_RDWR}) { int nul_fd = unix_open("nul", flags); EXPECT_TRUE(nul_fd >= 0); EXPECT_EQ(0, unix_isatty(nul_fd)); EXPECT_EQ(0, unix_close(nul_fd)); } // Check a real file, both read-write and read-only. TemporaryFile temp_file; EXPECT_TRUE(temp_file.fd >= 0); EXPECT_EQ(0, unix_isatty(temp_file.fd)); int temp_file_ro_fd = unix_open(temp_file.path, O_RDONLY); EXPECT_TRUE(temp_file_ro_fd >= 0); EXPECT_EQ(0, unix_isatty(temp_file_ro_fd)); EXPECT_EQ(0, unix_close(temp_file_ro_fd)); // Check a real OS pipe. int pipe_fds[2]; EXPECT_EQ(0, _pipe(pipe_fds, 64, _O_BINARY)); EXPECT_EQ(0, unix_isatty(pipe_fds[0])); EXPECT_EQ(0, unix_isatty(pipe_fds[1])); EXPECT_EQ(0, _close(pipe_fds[0])); EXPECT_EQ(0, _close(pipe_fds[1])); // Make sure an invalid FD is handled correctly. EXPECT_EQ(0, unix_isatty(-1)); } void TestParseCompleteUTF8(const char* buf, const size_t buf_size, const size_t expected_complete_bytes, const std::vector& expected_remaining_bytes) { std::vector remaining_bytes; const size_t complete_bytes = internal::ParseCompleteUTF8(buf, buf + buf_size, &remaining_bytes); EXPECT_EQ(expected_complete_bytes, complete_bytes); EXPECT_EQ(expected_remaining_bytes, remaining_bytes); } TEST(sysdeps_win32, ParseCompleteUTF8) { const std::vector> multi_byte_sequences = { { '\xc2', '\xa9' }, // 2 byte UTF-8 sequence { '\xe1', '\xb4', '\xa8' }, // 3 byte UTF-8 sequence { '\xf0', '\x9f', '\x98', '\x80' }, // 4 byte UTF-8 sequence }; std::vector> all_sequences = { {}, // 0 bytes { '\0' }, // NULL byte { 'a' }, // 1 byte UTF-8 sequence }; all_sequences.insert(all_sequences.end(), multi_byte_sequences.begin(), multi_byte_sequences.end()); // Vary a prefix of bytes in front of the sequence that we're actually interested in parsing. for (const auto& prefix : all_sequences) { // Parse (prefix + one byte of the sequence at a time) for (const auto& seq : multi_byte_sequences) { std::vector buffer(prefix); // For every byte of the sequence except the last for (size_t i = 0; i < seq.size() - 1; ++i) { buffer.push_back(seq[i]); // When parsing an incomplete UTF-8 sequence, the amount of the buffer preceding // the start of the incomplete UTF-8 sequence is valid. The remaining bytes are the // bytes of the incomplete UTF-8 sequence. TestParseCompleteUTF8(buffer.data(), buffer.size(), prefix.size(), std::vector(seq.begin(), seq.begin() + i + 1)); } // For the last byte of the sequence buffer.push_back(seq.back()); TestParseCompleteUTF8(buffer.data(), buffer.size(), buffer.size(), std::vector()); } // Parse (prefix (aka sequence) + invalid trailing bytes) to verify that the invalid // trailing bytes are immediately "returned" to prevent them from being stuck in some // buffer. std::vector buffer(prefix); for (size_t i = 0; i < 8; ++i) { buffer.push_back(0x80); // trailing byte TestParseCompleteUTF8(buffer.data(), buffer.size(), buffer.size(), std::vector()); } } } adb/test_adb.py0100644 0000000 0000000 00000022566 12767234553 012523 0ustar000000000 0000000 #!/usr/bin/env python # # Copyright (C) 2015 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # """Tests for the adb program itself. This differs from things in test_device.py in that there is no API for these things. Most of these tests involve specific error messages or the help text. """ from __future__ import print_function import contextlib import os import random import socket import struct import subprocess import threading import unittest import adb class NonApiTest(unittest.TestCase): """Tests for ADB that aren't a part of the AndroidDevice API.""" def test_help(self): """Make sure we get _something_ out of help.""" out = subprocess.check_output( ['adb', 'help'], stderr=subprocess.STDOUT) self.assertGreater(len(out), 0) def test_version(self): """Get a version number out of the output of adb.""" lines = subprocess.check_output(['adb', 'version']).splitlines() version_line = lines[0] self.assertRegexpMatches( version_line, r'^Android Debug Bridge version \d+\.\d+\.\d+$') if len(lines) == 2: # Newer versions of ADB have a second line of output for the # version that includes a specific revision (git SHA). revision_line = lines[1] self.assertRegexpMatches( revision_line, r'^Revision [0-9a-f]{12}-android$') def test_tcpip_error_messages(self): p = subprocess.Popen(['adb', 'tcpip'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) out, _ = p.communicate() self.assertEqual(1, p.returncode) self.assertIn('help message', out) p = subprocess.Popen(['adb', 'tcpip', 'foo'], stdout=subprocess.PIPE, stderr=subprocess.STDOUT) out, _ = p.communicate() self.assertEqual(1, p.returncode) self.assertIn('error', out) # Helper method that reads a pipe until it is closed, then sets the event. def _read_pipe_and_set_event(self, pipe, event): x = pipe.read() event.set() # Test that launch_server() does not let the adb server inherit # stdin/stdout/stderr handles which can cause callers of adb.exe to hang. # This test also runs fine on unix even though the impetus is an issue # unique to Windows. def test_handle_inheritance(self): # This test takes 5 seconds to run on Windows: if there is no adb server # running on the the port used below, adb kill-server tries to make a # TCP connection to a closed port and that takes 1 second on Windows; # adb start-server does the same TCP connection which takes another # second, and it waits 3 seconds after starting the server. # Start adb client with redirected stdin/stdout/stderr to check if it # passes those redirections to the adb server that it starts. To do # this, run an instance of the adb server on a non-default port so we # don't conflict with a pre-existing adb server that may already be # setup with adb TCP/emulator connections. If there is a pre-existing # adb server, this also tests whether multiple instances of the adb # server conflict on adb.log. port = 5038 # Kill any existing server on this non-default port. subprocess.check_output(['adb', '-P', str(port), 'kill-server'], stderr=subprocess.STDOUT) try: # Run the adb client and have it start the adb server. p = subprocess.Popen(['adb', '-P', str(port), 'start-server'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # Start threads that set events when stdout/stderr are closed. stdout_event = threading.Event() stdout_thread = threading.Thread( target=self._read_pipe_and_set_event, args=(p.stdout, stdout_event)) stdout_thread.daemon = True stdout_thread.start() stderr_event = threading.Event() stderr_thread = threading.Thread( target=self._read_pipe_and_set_event, args=(p.stderr, stderr_event)) stderr_thread.daemon = True stderr_thread.start() # Wait for the adb client to finish. Once that has occurred, if # stdin/stderr/stdout are still open, it must be open in the adb # server. p.wait() # Try to write to stdin which we expect is closed. If it isn't # closed, we should get an IOError. If we don't get an IOError, # stdin must still be open in the adb server. The adb client is # probably letting the adb server inherit stdin which would be # wrong. with self.assertRaises(IOError): p.stdin.write('x') # Wait a few seconds for stdout/stderr to be closed (in the success # case, this won't wait at all). If there is a timeout, that means # stdout/stderr were not closed and and they must be open in the adb # server, suggesting that the adb client is letting the adb server # inherit stdout/stderr which would be wrong. self.assertTrue(stdout_event.wait(5), "adb stdout not closed") self.assertTrue(stderr_event.wait(5), "adb stderr not closed") finally: # If we started a server, kill it. subprocess.check_output(['adb', '-P', str(port), 'kill-server'], stderr=subprocess.STDOUT) # Use SO_LINGER to cause TCP RST segment to be sent on socket close. def _reset_socket_on_close(self, sock): # The linger structure is two shorts on Windows, but two ints on Unix. linger_format = 'hh' if os.name == 'nt' else 'ii' l_onoff = 1 l_linger = 0 sock.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, struct.pack(linger_format, l_onoff, l_linger)) # Verify that we set the linger structure properly by retrieving it. linger = sock.getsockopt(socket.SOL_SOCKET, socket.SO_LINGER, 16) self.assertEqual((l_onoff, l_linger), struct.unpack_from(linger_format, linger)) def test_emu_kill(self): """Ensure that adb emu kill works. Bug: https://code.google.com/p/android/issues/detail?id=21021 """ port = 12345 with contextlib.closing( socket.socket(socket.AF_INET, socket.SOCK_STREAM)) as listener: # Use SO_REUSEADDR so subsequent runs of the test can grab the port # even if it is in TIME_WAIT. listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) listener.bind(('127.0.0.1', port)) listener.listen(4) # Now that listening has started, start adb emu kill, telling it to # connect to our mock emulator. p = subprocess.Popen( ['adb', '-s', 'emulator-' + str(port), 'emu', 'kill'], stderr=subprocess.STDOUT) accepted_connection, addr = listener.accept() with contextlib.closing(accepted_connection) as conn: # If WSAECONNABORTED (10053) is raised by any socket calls, # then adb probably isn't reading the data that we sent it. conn.sendall('Android Console: type \'help\' for a list ' + 'of commands\r\n') conn.sendall('OK\r\n') with contextlib.closing(conn.makefile()) as f: self.assertEqual('kill\n', f.readline()) self.assertEqual('quit\n', f.readline()) conn.sendall('OK: killing emulator, bye bye\r\n') # Use SO_LINGER to send TCP RST segment to test whether adb # ignores WSAECONNRESET on Windows. This happens with the # real emulator because it just calls exit() without closing # the socket or calling shutdown(SD_SEND). At process # termination, Windows sends a TCP RST segment for every # open socket that shutdown(SD_SEND) wasn't used on. self._reset_socket_on_close(conn) # Wait for adb to finish, so we can check return code. p.communicate() # If this fails, adb probably isn't ignoring WSAECONNRESET when # reading the response from the adb emu kill command (on Windows). self.assertEqual(0, p.returncode) def main(): random.seed(0) if len(adb.get_devices()) > 0: suite = unittest.TestLoader().loadTestsFromName(__name__) unittest.TextTestRunner(verbosity=3).run(suite) else: print('Test suite must be run with attached devices') if __name__ == '__main__': main() adb/test_device.py0100644 0000000 0000000 00000121703 12767234553 013225 0ustar000000000 0000000 #!/usr/bin/env python # -*- coding: utf-8 -*- # # Copyright (C) 2015 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from __future__ import print_function import contextlib import hashlib import os import posixpath import random import re import shlex import shutil import signal import socket import string import subprocess import sys import tempfile import unittest import mock import adb def requires_root(func): def wrapper(self, *args): if self.device.get_prop('ro.debuggable') != '1': raise unittest.SkipTest('requires rootable build') was_root = self.device.shell(['id', '-un'])[0].strip() == 'root' if not was_root: self.device.root() self.device.wait() try: func(self, *args) finally: if not was_root: self.device.unroot() self.device.wait() return wrapper def requires_non_root(func): def wrapper(self, *args): was_root = self.device.shell(['id', '-un'])[0].strip() == 'root' if was_root: self.device.unroot() self.device.wait() try: func(self, *args) finally: if was_root: self.device.root() self.device.wait() return wrapper class GetDeviceTest(unittest.TestCase): def setUp(self): self.android_serial = os.getenv('ANDROID_SERIAL') if 'ANDROID_SERIAL' in os.environ: del os.environ['ANDROID_SERIAL'] def tearDown(self): if self.android_serial is not None: os.environ['ANDROID_SERIAL'] = self.android_serial else: if 'ANDROID_SERIAL' in os.environ: del os.environ['ANDROID_SERIAL'] @mock.patch('adb.device.get_devices') def test_explicit(self, mock_get_devices): mock_get_devices.return_value = ['foo', 'bar'] device = adb.get_device('foo') self.assertEqual(device.serial, 'foo') @mock.patch('adb.device.get_devices') def test_from_env(self, mock_get_devices): mock_get_devices.return_value = ['foo', 'bar'] os.environ['ANDROID_SERIAL'] = 'foo' device = adb.get_device() self.assertEqual(device.serial, 'foo') @mock.patch('adb.device.get_devices') def test_arg_beats_env(self, mock_get_devices): mock_get_devices.return_value = ['foo', 'bar'] os.environ['ANDROID_SERIAL'] = 'bar' device = adb.get_device('foo') self.assertEqual(device.serial, 'foo') @mock.patch('adb.device.get_devices') def test_no_such_device(self, mock_get_devices): mock_get_devices.return_value = ['foo', 'bar'] self.assertRaises(adb.DeviceNotFoundError, adb.get_device, ['baz']) os.environ['ANDROID_SERIAL'] = 'baz' self.assertRaises(adb.DeviceNotFoundError, adb.get_device) @mock.patch('adb.device.get_devices') def test_unique_device(self, mock_get_devices): mock_get_devices.return_value = ['foo'] device = adb.get_device() self.assertEqual(device.serial, 'foo') @mock.patch('adb.device.get_devices') def test_no_unique_device(self, mock_get_devices): mock_get_devices.return_value = ['foo', 'bar'] self.assertRaises(adb.NoUniqueDeviceError, adb.get_device) class DeviceTest(unittest.TestCase): def setUp(self): self.device = adb.get_device() class ForwardReverseTest(DeviceTest): def _test_no_rebind(self, description, direction_list, direction, direction_no_rebind, direction_remove_all): msg = direction_list() self.assertEqual('', msg.strip(), description + ' list must be empty to run this test.') # Use --no-rebind with no existing binding direction_no_rebind('tcp:5566', 'tcp:6655') msg = direction_list() self.assertTrue(re.search(r'tcp:5566.+tcp:6655', msg)) # Use --no-rebind with existing binding with self.assertRaises(subprocess.CalledProcessError): direction_no_rebind('tcp:5566', 'tcp:6677') msg = direction_list() self.assertFalse(re.search(r'tcp:5566.+tcp:6677', msg)) self.assertTrue(re.search(r'tcp:5566.+tcp:6655', msg)) # Use the absence of --no-rebind with existing binding direction('tcp:5566', 'tcp:6677') msg = direction_list() self.assertFalse(re.search(r'tcp:5566.+tcp:6655', msg)) self.assertTrue(re.search(r'tcp:5566.+tcp:6677', msg)) direction_remove_all() msg = direction_list() self.assertEqual('', msg.strip()) def test_forward_no_rebind(self): self._test_no_rebind('forward', self.device.forward_list, self.device.forward, self.device.forward_no_rebind, self.device.forward_remove_all) def test_reverse_no_rebind(self): self._test_no_rebind('reverse', self.device.reverse_list, self.device.reverse, self.device.reverse_no_rebind, self.device.reverse_remove_all) def test_forward(self): msg = self.device.forward_list() self.assertEqual('', msg.strip(), 'Forwarding list must be empty to run this test.') self.device.forward('tcp:5566', 'tcp:6655') msg = self.device.forward_list() self.assertTrue(re.search(r'tcp:5566.+tcp:6655', msg)) self.device.forward('tcp:7788', 'tcp:8877') msg = self.device.forward_list() self.assertTrue(re.search(r'tcp:5566.+tcp:6655', msg)) self.assertTrue(re.search(r'tcp:7788.+tcp:8877', msg)) self.device.forward_remove('tcp:5566') msg = self.device.forward_list() self.assertFalse(re.search(r'tcp:5566.+tcp:6655', msg)) self.assertTrue(re.search(r'tcp:7788.+tcp:8877', msg)) self.device.forward_remove_all() msg = self.device.forward_list() self.assertEqual('', msg.strip()) def test_reverse(self): msg = self.device.reverse_list() self.assertEqual('', msg.strip(), 'Reverse forwarding list must be empty to run this test.') self.device.reverse('tcp:5566', 'tcp:6655') msg = self.device.reverse_list() self.assertTrue(re.search(r'tcp:5566.+tcp:6655', msg)) self.device.reverse('tcp:7788', 'tcp:8877') msg = self.device.reverse_list() self.assertTrue(re.search(r'tcp:5566.+tcp:6655', msg)) self.assertTrue(re.search(r'tcp:7788.+tcp:8877', msg)) self.device.reverse_remove('tcp:5566') msg = self.device.reverse_list() self.assertFalse(re.search(r'tcp:5566.+tcp:6655', msg)) self.assertTrue(re.search(r'tcp:7788.+tcp:8877', msg)) self.device.reverse_remove_all() msg = self.device.reverse_list() self.assertEqual('', msg.strip()) # Note: If you run this test when adb connect'd to a physical device over # TCP, it will fail in adb reverse due to https://code.google.com/p/android/issues/detail?id=189821 def test_forward_reverse_echo(self): """Send data through adb forward and read it back via adb reverse""" forward_port = 12345 reverse_port = forward_port + 1 forward_spec = 'tcp:' + str(forward_port) reverse_spec = 'tcp:' + str(reverse_port) forward_setup = False reverse_setup = False try: # listen on localhost:forward_port, connect to remote:forward_port self.device.forward(forward_spec, forward_spec) forward_setup = True # listen on remote:forward_port, connect to localhost:reverse_port self.device.reverse(forward_spec, reverse_spec) reverse_setup = True listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM) with contextlib.closing(listener): # Use SO_REUSEADDR so that subsequent runs of the test can grab # the port even if it is in TIME_WAIT. listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # Listen on localhost:reverse_port before connecting to # localhost:forward_port because that will cause adb to connect # back to localhost:reverse_port. listener.bind(('127.0.0.1', reverse_port)) listener.listen(4) client = socket.socket(socket.AF_INET, socket.SOCK_STREAM) with contextlib.closing(client): # Connect to the listener. client.connect(('127.0.0.1', forward_port)) # Accept the client connection. accepted_connection, addr = listener.accept() with contextlib.closing(accepted_connection) as server: data = 'hello' # Send data into the port setup by adb forward. client.sendall(data) # Explicitly close() so that server gets EOF. client.close() # Verify that the data came back via adb reverse. self.assertEqual(data, server.makefile().read()) finally: if reverse_setup: self.device.reverse_remove(forward_spec) if forward_setup: self.device.forward_remove(forward_spec) class ShellTest(DeviceTest): def _interactive_shell(self, shell_args, input): """Runs an interactive adb shell. Args: shell_args: List of string arguments to `adb shell`. input: String input to send to the interactive shell. Returns: The remote exit code. Raises: unittest.SkipTest: The device doesn't support exit codes. """ if self.device.SHELL_PROTOCOL_FEATURE not in self.device.features: raise unittest.SkipTest('exit codes are unavailable on this device') proc = subprocess.Popen( self.device.adb_cmd + ['shell'] + shell_args, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) # Closing host-side stdin doesn't trigger a PTY shell to exit so we need # to explicitly add an exit command to close the session from the device # side, plus the necessary newline to complete the interactive command. proc.communicate(input + '; exit\n') return proc.returncode def test_cat(self): """Check that we can at least cat a file.""" out = self.device.shell(['cat', '/proc/uptime'])[0].strip() elements = out.split() self.assertEqual(len(elements), 2) uptime, idle = elements self.assertGreater(float(uptime), 0.0) self.assertGreater(float(idle), 0.0) def test_throws_on_failure(self): self.assertRaises(adb.ShellError, self.device.shell, ['false']) def test_output_not_stripped(self): out = self.device.shell(['echo', 'foo'])[0] self.assertEqual(out, 'foo' + self.device.linesep) def test_shell_nocheck_failure(self): rc, out, _ = self.device.shell_nocheck(['false']) self.assertNotEqual(rc, 0) self.assertEqual(out, '') def test_shell_nocheck_output_not_stripped(self): rc, out, _ = self.device.shell_nocheck(['echo', 'foo']) self.assertEqual(rc, 0) self.assertEqual(out, 'foo' + self.device.linesep) def test_can_distinguish_tricky_results(self): # If result checking on ADB shell is naively implemented as # `adb shell ; echo $?`, we would be unable to distinguish the # output from the result for a cmd of `echo -n 1`. rc, out, _ = self.device.shell_nocheck(['echo', '-n', '1']) self.assertEqual(rc, 0) self.assertEqual(out, '1') def test_line_endings(self): """Ensure that line ending translation is not happening in the pty. Bug: http://b/19735063 """ output = self.device.shell(['uname'])[0] self.assertEqual(output, 'Linux' + self.device.linesep) def test_pty_logic(self): """Tests that a PTY is allocated when it should be. PTY allocation behavior should match ssh; some behavior requires a terminal stdin to test so this test will be skipped if stdin is not a terminal. """ if self.device.SHELL_PROTOCOL_FEATURE not in self.device.features: raise unittest.SkipTest('PTY arguments unsupported on this device') if not os.isatty(sys.stdin.fileno()): raise unittest.SkipTest('PTY tests require stdin terminal') def check_pty(args): """Checks adb shell PTY allocation. Tests |args| for terminal and non-terminal stdin. Args: args: -Tt args in a list (e.g. ['-t', '-t']). Returns: A tuple (, ). True indicates the corresponding shell allocated a remote PTY. """ test_cmd = self.device.adb_cmd + ['shell'] + args + ['[ -t 0 ]'] terminal = subprocess.Popen( test_cmd, stdin=None, stdout=subprocess.PIPE, stderr=subprocess.PIPE) terminal.communicate() non_terminal = subprocess.Popen( test_cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) non_terminal.communicate() return (terminal.returncode == 0, non_terminal.returncode == 0) # -T: never allocate PTY. self.assertEqual((False, False), check_pty(['-T'])) # No args: PTY only if stdin is a terminal and shell is interactive, # which is difficult to reliably test from a script. self.assertEqual((False, False), check_pty([])) # -t: PTY if stdin is a terminal. self.assertEqual((True, False), check_pty(['-t'])) # -t -t: always allocate PTY. self.assertEqual((True, True), check_pty(['-t', '-t'])) def test_shell_protocol(self): """Tests the shell protocol on the device. If the device supports shell protocol, this gives us the ability to separate stdout/stderr and return the exit code directly. Bug: http://b/19734861 """ if self.device.SHELL_PROTOCOL_FEATURE not in self.device.features: raise unittest.SkipTest('shell protocol unsupported on this device') # Shell protocol should be used by default. result = self.device.shell_nocheck( shlex.split('echo foo; echo bar >&2; exit 17')) self.assertEqual(17, result[0]) self.assertEqual('foo' + self.device.linesep, result[1]) self.assertEqual('bar' + self.device.linesep, result[2]) self.assertEqual(17, self._interactive_shell([], 'exit 17')) # -x flag should disable shell protocol. result = self.device.shell_nocheck( shlex.split('-x echo foo; echo bar >&2; exit 17')) self.assertEqual(0, result[0]) self.assertEqual('foo{0}bar{0}'.format(self.device.linesep), result[1]) self.assertEqual('', result[2]) self.assertEqual(0, self._interactive_shell(['-x'], 'exit 17')) def test_non_interactive_sigint(self): """Tests that SIGINT in a non-interactive shell kills the process. This requires the shell protocol in order to detect the broken pipe; raw data transfer mode will only see the break once the subprocess tries to read or write. Bug: http://b/23825725 """ if self.device.SHELL_PROTOCOL_FEATURE not in self.device.features: raise unittest.SkipTest('shell protocol unsupported on this device') # Start a long-running process. sleep_proc = subprocess.Popen( self.device.adb_cmd + shlex.split('shell echo $$; sleep 60'), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT) remote_pid = sleep_proc.stdout.readline().strip() self.assertIsNone(sleep_proc.returncode, 'subprocess terminated early') proc_query = shlex.split('ps {0} | grep {0}'.format(remote_pid)) # Verify that the process is running, send signal, verify it stopped. self.device.shell(proc_query) os.kill(sleep_proc.pid, signal.SIGINT) sleep_proc.communicate() self.assertEqual(1, self.device.shell_nocheck(proc_query)[0], 'subprocess failed to terminate') def test_non_interactive_stdin(self): """Tests that non-interactive shells send stdin.""" if self.device.SHELL_PROTOCOL_FEATURE not in self.device.features: raise unittest.SkipTest('non-interactive stdin unsupported ' 'on this device') # Test both small and large inputs. small_input = 'foo' large_input = '\n'.join(c * 100 for c in (string.ascii_letters + string.digits)) for input in (small_input, large_input): proc = subprocess.Popen(self.device.adb_cmd + ['shell', 'cat'], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) stdout, stderr = proc.communicate(input) self.assertEqual(input.splitlines(), stdout.splitlines()) self.assertEqual('', stderr) class ArgumentEscapingTest(DeviceTest): def test_shell_escaping(self): """Make sure that argument escaping is somewhat sane.""" # http://b/19734868 # Note that this actually matches ssh(1)'s behavior --- it's # converted to `sh -c echo hello; echo world` which sh interprets # as `sh -c echo` (with an argument to that shell of "hello"), # and then `echo world` back in the first shell. result = self.device.shell( shlex.split("sh -c 'echo hello; echo world'"))[0] result = result.splitlines() self.assertEqual(['', 'world'], result) # If you really wanted "hello" and "world", here's what you'd do: result = self.device.shell( shlex.split(r'echo hello\;echo world'))[0].splitlines() self.assertEqual(['hello', 'world'], result) # http://b/15479704 result = self.device.shell(shlex.split("'true && echo t'"))[0].strip() self.assertEqual('t', result) result = self.device.shell( shlex.split("sh -c 'true && echo t'"))[0].strip() self.assertEqual('t', result) # http://b/20564385 result = self.device.shell(shlex.split('FOO=a BAR=b echo t'))[0].strip() self.assertEqual('t', result) result = self.device.shell( shlex.split(r'echo -n 123\;uname'))[0].strip() self.assertEqual('123Linux', result) def test_install_argument_escaping(self): """Make sure that install argument escaping works.""" # http://b/20323053, http://b/3090932. for file_suffix in ('-text;ls;1.apk', "-Live Hold'em.apk"): tf = tempfile.NamedTemporaryFile('wb', suffix=file_suffix, delete=False) tf.close() # Installing bogus .apks fails if the device supports exit codes. try: output = self.device.install(tf.name) except subprocess.CalledProcessError as e: output = e.output self.assertIn(file_suffix, output) os.remove(tf.name) class RootUnrootTest(DeviceTest): def _test_root(self): message = self.device.root() if 'adbd cannot run as root in production builds' in message: return self.device.wait() self.assertEqual('root', self.device.shell(['id', '-un'])[0].strip()) def _test_unroot(self): self.device.unroot() self.device.wait() self.assertEqual('shell', self.device.shell(['id', '-un'])[0].strip()) def test_root_unroot(self): """Make sure that adb root and adb unroot work, using id(1).""" if self.device.get_prop('ro.debuggable') != '1': raise unittest.SkipTest('requires rootable build') original_user = self.device.shell(['id', '-un'])[0].strip() try: if original_user == 'root': self._test_unroot() self._test_root() elif original_user == 'shell': self._test_root() self._test_unroot() finally: if original_user == 'root': self.device.root() else: self.device.unroot() self.device.wait() class TcpIpTest(DeviceTest): def test_tcpip_failure_raises(self): """adb tcpip requires a port. Bug: http://b/22636927 """ self.assertRaises( subprocess.CalledProcessError, self.device.tcpip, '') self.assertRaises( subprocess.CalledProcessError, self.device.tcpip, 'foo') class SystemPropertiesTest(DeviceTest): def test_get_prop(self): self.assertEqual(self.device.get_prop('init.svc.adbd'), 'running') @requires_root def test_set_prop(self): prop_name = 'foo.bar' self.device.shell(['setprop', prop_name, '""']) self.device.set_prop(prop_name, 'qux') self.assertEqual( self.device.shell(['getprop', prop_name])[0].strip(), 'qux') def compute_md5(string): hsh = hashlib.md5() hsh.update(string) return hsh.hexdigest() def get_md5_prog(device): """Older platforms (pre-L) had the name md5 rather than md5sum.""" try: device.shell(['md5sum', '/proc/uptime']) return 'md5sum' except adb.ShellError: return 'md5' class HostFile(object): def __init__(self, handle, checksum): self.handle = handle self.checksum = checksum self.full_path = handle.name self.base_name = os.path.basename(self.full_path) class DeviceFile(object): def __init__(self, checksum, full_path): self.checksum = checksum self.full_path = full_path self.base_name = posixpath.basename(self.full_path) def make_random_host_files(in_dir, num_files): min_size = 1 * (1 << 10) max_size = 16 * (1 << 10) files = [] for _ in xrange(num_files): file_handle = tempfile.NamedTemporaryFile(dir=in_dir, delete=False) size = random.randrange(min_size, max_size, 1024) rand_str = os.urandom(size) file_handle.write(rand_str) file_handle.flush() file_handle.close() md5 = compute_md5(rand_str) files.append(HostFile(file_handle, md5)) return files def make_random_device_files(device, in_dir, num_files, prefix='device_tmpfile'): min_size = 1 * (1 << 10) max_size = 16 * (1 << 10) files = [] for file_num in xrange(num_files): size = random.randrange(min_size, max_size, 1024) base_name = prefix + str(file_num) full_path = posixpath.join(in_dir, base_name) device.shell(['dd', 'if=/dev/urandom', 'of={}'.format(full_path), 'bs={}'.format(size), 'count=1']) dev_md5, _ = device.shell([get_md5_prog(device), full_path])[0].split() files.append(DeviceFile(dev_md5, full_path)) return files class FileOperationsTest(DeviceTest): SCRATCH_DIR = '/data/local/tmp' DEVICE_TEMP_FILE = SCRATCH_DIR + '/adb_test_file' DEVICE_TEMP_DIR = SCRATCH_DIR + '/adb_test_dir' def _verify_remote(self, checksum, remote_path): dev_md5, _ = self.device.shell([get_md5_prog(self.device), remote_path])[0].split() self.assertEqual(checksum, dev_md5) def _verify_local(self, checksum, local_path): with open(local_path, 'rb') as host_file: host_md5 = compute_md5(host_file.read()) self.assertEqual(host_md5, checksum) def test_push(self): """Push a randomly generated file to specified device.""" kbytes = 512 tmp = tempfile.NamedTemporaryFile(mode='wb', delete=False) rand_str = os.urandom(1024 * kbytes) tmp.write(rand_str) tmp.close() self.device.shell(['rm', '-rf', self.DEVICE_TEMP_FILE]) self.device.push(local=tmp.name, remote=self.DEVICE_TEMP_FILE) self._verify_remote(compute_md5(rand_str), self.DEVICE_TEMP_FILE) self.device.shell(['rm', '-f', self.DEVICE_TEMP_FILE]) os.remove(tmp.name) def test_push_dir(self): """Push a randomly generated directory of files to the device.""" self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) self.device.shell(['mkdir', self.DEVICE_TEMP_DIR]) try: host_dir = tempfile.mkdtemp() # Make sure the temp directory isn't setuid, or else adb will complain. os.chmod(host_dir, 0o700) # Create 32 random files. temp_files = make_random_host_files(in_dir=host_dir, num_files=32) self.device.push(host_dir, self.DEVICE_TEMP_DIR) for temp_file in temp_files: remote_path = posixpath.join(self.DEVICE_TEMP_DIR, os.path.basename(host_dir), temp_file.base_name) self._verify_remote(temp_file.checksum, remote_path) self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) finally: if host_dir is not None: shutil.rmtree(host_dir) @unittest.expectedFailure # b/25566053 def test_push_empty(self): """Push a directory containing an empty directory to the device.""" self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) self.device.shell(['mkdir', self.DEVICE_TEMP_DIR]) try: host_dir = tempfile.mkdtemp() # Make sure the temp directory isn't setuid, or else adb will complain. os.chmod(host_dir, 0o700) # Create an empty directory. os.mkdir(os.path.join(host_dir, 'empty')) self.device.push(host_dir, self.DEVICE_TEMP_DIR) test_empty_cmd = ['[', '-d', os.path.join(self.DEVICE_TEMP_DIR, 'empty')] rc, _, _ = self.device.shell_nocheck(test_empty_cmd) self.assertEqual(rc, 0) self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) finally: if host_dir is not None: shutil.rmtree(host_dir) def test_multiple_push(self): """Push multiple files to the device in one adb push command. Bug: http://b/25324823 """ self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) self.device.shell(['mkdir', self.DEVICE_TEMP_DIR]) try: host_dir = tempfile.mkdtemp() # Create some random files and a subdirectory containing more files. temp_files = make_random_host_files(in_dir=host_dir, num_files=4) subdir = os.path.join(host_dir, 'subdir') os.mkdir(subdir) subdir_temp_files = make_random_host_files(in_dir=subdir, num_files=4) paths = map(lambda temp_file: temp_file.full_path, temp_files) paths.append(subdir) self.device._simple_call(['push'] + paths + [self.DEVICE_TEMP_DIR]) for temp_file in temp_files: remote_path = posixpath.join(self.DEVICE_TEMP_DIR, temp_file.base_name) self._verify_remote(temp_file.checksum, remote_path) for subdir_temp_file in subdir_temp_files: remote_path = posixpath.join(self.DEVICE_TEMP_DIR, # BROKEN: http://b/25394682 # 'subdir'; temp_file.base_name) self._verify_remote(temp_file.checksum, remote_path) self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) finally: if host_dir is not None: shutil.rmtree(host_dir) @requires_non_root def test_push_error_reporting(self): """Make sure that errors that occur while pushing a file get reported Bug: http://b/26816782 """ with tempfile.NamedTemporaryFile() as tmp_file: tmp_file.write('\0' * 1024 * 1024) tmp_file.flush() try: self.device.push(local=tmp_file.name, remote='/system/') self.fail('push should not have succeeded') except subprocess.CalledProcessError as e: output = e.output self.assertIn('Permission denied', output) def _test_pull(self, remote_file, checksum): tmp_write = tempfile.NamedTemporaryFile(mode='wb', delete=False) tmp_write.close() self.device.pull(remote=remote_file, local=tmp_write.name) with open(tmp_write.name, 'rb') as tmp_read: host_contents = tmp_read.read() host_md5 = compute_md5(host_contents) self.assertEqual(checksum, host_md5) os.remove(tmp_write.name) @requires_non_root def test_pull_error_reporting(self): self.device.shell(['touch', self.DEVICE_TEMP_FILE]) self.device.shell(['chmod', 'a-rwx', self.DEVICE_TEMP_FILE]) try: output = self.device.pull(remote=self.DEVICE_TEMP_FILE, local='x') except subprocess.CalledProcessError as e: output = e.output self.assertIn('Permission denied', output) self.device.shell(['rm', '-f', self.DEVICE_TEMP_FILE]) def test_pull(self): """Pull a randomly generated file from specified device.""" kbytes = 512 self.device.shell(['rm', '-rf', self.DEVICE_TEMP_FILE]) cmd = ['dd', 'if=/dev/urandom', 'of={}'.format(self.DEVICE_TEMP_FILE), 'bs=1024', 'count={}'.format(kbytes)] self.device.shell(cmd) dev_md5, _ = self.device.shell( [get_md5_prog(self.device), self.DEVICE_TEMP_FILE])[0].split() self._test_pull(self.DEVICE_TEMP_FILE, dev_md5) self.device.shell_nocheck(['rm', self.DEVICE_TEMP_FILE]) def test_pull_dir(self): """Pull a randomly generated directory of files from the device.""" try: host_dir = tempfile.mkdtemp() self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) self.device.shell(['mkdir', '-p', self.DEVICE_TEMP_DIR]) # Populate device directory with random files. temp_files = make_random_device_files( self.device, in_dir=self.DEVICE_TEMP_DIR, num_files=32) self.device.pull(remote=self.DEVICE_TEMP_DIR, local=host_dir) for temp_file in temp_files: host_path = os.path.join( host_dir, posixpath.basename(self.DEVICE_TEMP_DIR), temp_file.base_name) self._verify_local(temp_file.checksum, host_path) self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) finally: if host_dir is not None: shutil.rmtree(host_dir) def test_pull_dir_symlink(self): """Pull a directory into a symlink to a directory. Bug: http://b/27362811 """ if os.name != 'posix': raise unittest.SkipTest('requires POSIX') try: host_dir = tempfile.mkdtemp() real_dir = os.path.join(host_dir, 'dir') symlink = os.path.join(host_dir, 'symlink') os.mkdir(real_dir) os.symlink(real_dir, symlink) self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) self.device.shell(['mkdir', '-p', self.DEVICE_TEMP_DIR]) # Populate device directory with random files. temp_files = make_random_device_files( self.device, in_dir=self.DEVICE_TEMP_DIR, num_files=32) self.device.pull(remote=self.DEVICE_TEMP_DIR, local=symlink) for temp_file in temp_files: host_path = os.path.join( real_dir, posixpath.basename(self.DEVICE_TEMP_DIR), temp_file.base_name) self._verify_local(temp_file.checksum, host_path) self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) finally: if host_dir is not None: shutil.rmtree(host_dir) def test_pull_dir_symlink_collision(self): """Pull a directory into a colliding symlink to directory.""" if os.name != 'posix': raise unittest.SkipTest('requires POSIX') try: host_dir = tempfile.mkdtemp() real_dir = os.path.join(host_dir, 'real') tmp_dirname = os.path.basename(self.DEVICE_TEMP_DIR) symlink = os.path.join(host_dir, tmp_dirname) os.mkdir(real_dir) os.symlink(real_dir, symlink) self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) self.device.shell(['mkdir', '-p', self.DEVICE_TEMP_DIR]) # Populate device directory with random files. temp_files = make_random_device_files( self.device, in_dir=self.DEVICE_TEMP_DIR, num_files=32) self.device.pull(remote=self.DEVICE_TEMP_DIR, local=host_dir) for temp_file in temp_files: host_path = os.path.join(real_dir, temp_file.base_name) self._verify_local(temp_file.checksum, host_path) self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) finally: if host_dir is not None: shutil.rmtree(host_dir) def test_pull_dir_nonexistent(self): """Pull a directory of files from the device to a nonexistent path.""" try: host_dir = tempfile.mkdtemp() dest_dir = os.path.join(host_dir, 'dest') self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) self.device.shell(['mkdir', '-p', self.DEVICE_TEMP_DIR]) # Populate device directory with random files. temp_files = make_random_device_files( self.device, in_dir=self.DEVICE_TEMP_DIR, num_files=32) self.device.pull(remote=self.DEVICE_TEMP_DIR, local=dest_dir) for temp_file in temp_files: host_path = os.path.join(dest_dir, temp_file.base_name) self._verify_local(temp_file.checksum, host_path) self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) finally: if host_dir is not None: shutil.rmtree(host_dir) def test_pull_symlink_dir(self): """Pull a symlink to a directory of symlinks to files.""" try: host_dir = tempfile.mkdtemp() remote_dir = posixpath.join(self.DEVICE_TEMP_DIR, 'contents') remote_links = posixpath.join(self.DEVICE_TEMP_DIR, 'links') remote_symlink = posixpath.join(self.DEVICE_TEMP_DIR, 'symlink') self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) self.device.shell(['mkdir', '-p', remote_dir, remote_links]) self.device.shell(['ln', '-s', remote_links, remote_symlink]) # Populate device directory with random files. temp_files = make_random_device_files( self.device, in_dir=remote_dir, num_files=32) for temp_file in temp_files: self.device.shell( ['ln', '-s', '../contents/{}'.format(temp_file.base_name), posixpath.join(remote_links, temp_file.base_name)]) self.device.pull(remote=remote_symlink, local=host_dir) for temp_file in temp_files: host_path = os.path.join( host_dir, 'symlink', temp_file.base_name) self._verify_local(temp_file.checksum, host_path) self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) finally: if host_dir is not None: shutil.rmtree(host_dir) def test_pull_empty(self): """Pull a directory containing an empty directory from the device.""" try: host_dir = tempfile.mkdtemp() remote_empty_path = posixpath.join(self.DEVICE_TEMP_DIR, 'empty') self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) self.device.shell(['mkdir', '-p', remote_empty_path]) self.device.pull(remote=remote_empty_path, local=host_dir) self.assertTrue(os.path.isdir(os.path.join(host_dir, 'empty'))) finally: if host_dir is not None: shutil.rmtree(host_dir) def test_multiple_pull(self): """Pull a randomly generated directory of files from the device.""" try: host_dir = tempfile.mkdtemp() subdir = posixpath.join(self.DEVICE_TEMP_DIR, 'subdir') self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) self.device.shell(['mkdir', '-p', subdir]) # Create some random files and a subdirectory containing more files. temp_files = make_random_device_files( self.device, in_dir=self.DEVICE_TEMP_DIR, num_files=4) subdir_temp_files = make_random_device_files( self.device, in_dir=subdir, num_files=4, prefix='subdir_') paths = map(lambda temp_file: temp_file.full_path, temp_files) paths.append(subdir) self.device._simple_call(['pull'] + paths + [host_dir]) for temp_file in temp_files: local_path = os.path.join(host_dir, temp_file.base_name) self._verify_local(temp_file.checksum, local_path) for subdir_temp_file in subdir_temp_files: local_path = os.path.join(host_dir, 'subdir', subdir_temp_file.base_name) self._verify_local(subdir_temp_file.checksum, local_path) self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) finally: if host_dir is not None: shutil.rmtree(host_dir) def test_sync(self): """Sync a randomly generated directory of files to specified device.""" try: base_dir = tempfile.mkdtemp() # Create mirror device directory hierarchy within base_dir. full_dir_path = base_dir + self.DEVICE_TEMP_DIR os.makedirs(full_dir_path) # Create 32 random files within the host mirror. temp_files = make_random_host_files(in_dir=full_dir_path, num_files=32) # Clean up any trash on the device. device = adb.get_device(product=base_dir) device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) device.sync('data') # Confirm that every file on the device mirrors that on the host. for temp_file in temp_files: device_full_path = posixpath.join(self.DEVICE_TEMP_DIR, temp_file.base_name) dev_md5, _ = device.shell( [get_md5_prog(self.device), device_full_path])[0].split() self.assertEqual(temp_file.checksum, dev_md5) self.device.shell(['rm', '-rf', self.DEVICE_TEMP_DIR]) finally: if base_dir is not None: shutil.rmtree(base_dir) def test_unicode_paths(self): """Ensure that we can support non-ASCII paths, even on Windows.""" name = u'로보카 폴리' self.device.shell(['rm', '-f', '/data/local/tmp/adb-test-*']) remote_path = u'/data/local/tmp/adb-test-{}'.format(name) ## push. tf = tempfile.NamedTemporaryFile('wb', suffix=name, delete=False) tf.close() self.device.push(tf.name, remote_path) os.remove(tf.name) self.assertFalse(os.path.exists(tf.name)) # Verify that the device ended up with the expected UTF-8 path output = self.device.shell( ['ls', '/data/local/tmp/adb-test-*'])[0].strip() self.assertEqual(remote_path.encode('utf-8'), output) # pull. self.device.pull(remote_path, tf.name) self.assertTrue(os.path.exists(tf.name)) os.remove(tf.name) self.device.shell(['rm', '-f', '/data/local/tmp/adb-test-*']) def main(): random.seed(0) if len(adb.get_devices()) > 0: suite = unittest.TestLoader().loadTestsFromName(__name__) unittest.TextTestRunner(verbosity=3).run(suite) else: print('Test suite must be run with attached devices') if __name__ == '__main__': main() adb/test_track_devices.cpp0100644 0000000 0000000 00000003613 12767234553 014725 0ustar000000000 0000000 // TODO: replace this with a shell/python script. /* a simple test program, connects to ADB server, and opens a track-devices session */ #include #include #include #include #include #include #include #include static void panic( const char* msg ) { fprintf(stderr, "PANIC: %s: %s\n", msg, strerror(errno)); exit(1); } int main(int argc, char* argv[]) { const char* request = "host:track-devices"; if (argv[1] && strcmp(argv[1], "--jdwp") == 0) { request = "track-jdwp"; } int ret; struct sockaddr_in server; char buffer[1024]; memset( &server, 0, sizeof(server) ); server.sin_family = AF_INET; server.sin_port = htons(5037); server.sin_addr.s_addr = htonl(INADDR_LOOPBACK); int s = socket( PF_INET, SOCK_STREAM, 0 ); ret = connect( s, (struct sockaddr*) &server, sizeof(server) ); if (ret < 0) panic( "could not connect to server" ); /* send the request */ int len = snprintf(buffer, sizeof(buffer), "%04zx%s", strlen(request), request); if (!android::base::WriteFully(s, buffer, len)) panic( "could not send request" ); /* read the OKAY answer */ if (!android::base::ReadFully(s, buffer, 4)) panic( "could not read request" ); printf( "server answer: %.*s\n", 4, buffer ); /* now loop */ while (true) { char head[5] = "0000"; if (!android::base::ReadFully(s, head, 4)) panic("could not read length"); int len; if (sscanf(head, "%04x", &len) != 1 ) panic("could not decode length"); if (!android::base::ReadFully(s, buffer, len)) panic("could not read data"); printf( "received header %.*s (%d bytes):\n%.*s----\n", 4, head, len, len, buffer ); } close(s); } adb/transport.cpp0100644 0000000 0000000 00000074565 12767234553 013132 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG TRANSPORT #include "sysdeps.h" #include "transport.h" #include #include #include #include #include #include #include #include #include #include #include #include #include "adb.h" #include "adb_utils.h" #include "diagnose_usb.h" static void transport_unref(atransport *t); static auto& transport_list = *new std::list(); static auto& pending_list = *new std::list(); ADB_MUTEX_DEFINE( transport_lock ); const char* const kFeatureShell2 = "shell_v2"; const char* const kFeatureCmd = "cmd"; static std::string dump_packet(const char* name, const char* func, apacket* p) { unsigned command = p->msg.command; int len = p->msg.data_length; char cmd[9]; char arg0[12], arg1[12]; int n; for (n = 0; n < 4; n++) { int b = (command >> (n*8)) & 255; if (b < 32 || b >= 127) break; cmd[n] = (char)b; } if (n == 4) { cmd[4] = 0; } else { /* There is some non-ASCII name in the command, so dump * the hexadecimal value instead */ snprintf(cmd, sizeof cmd, "%08x", command); } if (p->msg.arg0 < 256U) snprintf(arg0, sizeof arg0, "%d", p->msg.arg0); else snprintf(arg0, sizeof arg0, "0x%x", p->msg.arg0); if (p->msg.arg1 < 256U) snprintf(arg1, sizeof arg1, "%d", p->msg.arg1); else snprintf(arg1, sizeof arg1, "0x%x", p->msg.arg1); std::string result = android::base::StringPrintf("%s: %s: [%s] arg0=%s arg1=%s (len=%d) ", name, func, cmd, arg0, arg1, len); result += dump_hex(p->data, len); return result; } static int read_packet(int fd, const char* name, apacket** ppacket) { char buff[8]; if (!name) { snprintf(buff, sizeof buff, "fd=%d", fd); name = buff; } char* p = reinterpret_cast(ppacket); /* really read a packet address */ int len = sizeof(apacket*); while(len > 0) { int r = adb_read(fd, p, len); if(r > 0) { len -= r; p += r; } else { D("%s: read_packet (fd=%d), error ret=%d: %s", name, fd, r, strerror(errno)); return -1; } } VLOG(TRANSPORT) << dump_packet(name, "from remote", *ppacket); return 0; } static int write_packet(int fd, const char* name, apacket** ppacket) { char buff[8]; if (!name) { snprintf(buff, sizeof buff, "fd=%d", fd); name = buff; } VLOG(TRANSPORT) << dump_packet(name, "to remote", *ppacket); char* p = reinterpret_cast(ppacket); /* we really write the packet address */ int len = sizeof(apacket*); while(len > 0) { int r = adb_write(fd, p, len); if(r > 0) { len -= r; p += r; } else { D("%s: write_packet (fd=%d) error ret=%d: %s", name, fd, r, strerror(errno)); return -1; } } return 0; } static void transport_socket_events(int fd, unsigned events, void *_t) { atransport *t = reinterpret_cast(_t); D("transport_socket_events(fd=%d, events=%04x,...)", fd, events); if(events & FDE_READ){ apacket *p = 0; if(read_packet(fd, t->serial, &p)){ D("%s: failed to read packet from transport socket on fd %d", t->serial, fd); } else { handle_packet(p, (atransport *) _t); } } } void send_packet(apacket *p, atransport *t) { unsigned char *x; unsigned sum; unsigned count; p->msg.magic = p->msg.command ^ 0xffffffff; count = p->msg.data_length; x = (unsigned char *) p->data; sum = 0; while(count-- > 0){ sum += *x++; } p->msg.data_check = sum; print_packet("send", p); if (t == NULL) { D("Transport is null"); // Zap errno because print_packet() and other stuff have errno effect. errno = 0; fatal_errno("Transport is null"); } if(write_packet(t->transport_socket, t->serial, &p)){ fatal_errno("cannot enqueue packet on transport socket"); } } // The transport is opened by transport_register_func before // the read_transport and write_transport threads are started. // // The read_transport thread issues a SYNC(1, token) message to let // the write_transport thread know to start things up. In the event // of transport IO failure, the read_transport thread will post a // SYNC(0,0) message to ensure shutdown. // // The transport will not actually be closed until both threads exit, but the threads // will kick the transport on their way out to disconnect the underlying device. // // read_transport thread reads data from a transport (representing a usb/tcp connection), // and makes the main thread call handle_packet(). static void read_transport_thread(void* _t) { atransport *t = reinterpret_cast(_t); apacket *p; adb_thread_setname(android::base::StringPrintf("<-%s", (t->serial != nullptr ? t->serial : "transport"))); D("%s: starting read_transport thread on fd %d, SYNC online (%d)", t->serial, t->fd, t->sync_token + 1); p = get_apacket(); p->msg.command = A_SYNC; p->msg.arg0 = 1; p->msg.arg1 = ++(t->sync_token); p->msg.magic = A_SYNC ^ 0xffffffff; if(write_packet(t->fd, t->serial, &p)) { put_apacket(p); D("%s: failed to write SYNC packet", t->serial); goto oops; } D("%s: data pump started", t->serial); for(;;) { p = get_apacket(); if(t->read_from_remote(p, t) == 0){ D("%s: received remote packet, sending to transport", t->serial); if(write_packet(t->fd, t->serial, &p)){ put_apacket(p); D("%s: failed to write apacket to transport", t->serial); goto oops; } } else { D("%s: remote read failed for transport", t->serial); put_apacket(p); break; } } D("%s: SYNC offline for transport", t->serial); p = get_apacket(); p->msg.command = A_SYNC; p->msg.arg0 = 0; p->msg.arg1 = 0; p->msg.magic = A_SYNC ^ 0xffffffff; if(write_packet(t->fd, t->serial, &p)) { put_apacket(p); D("%s: failed to write SYNC apacket to transport", t->serial); } oops: D("%s: read_transport thread is exiting", t->serial); kick_transport(t); transport_unref(t); } // write_transport thread gets packets sent by the main thread (through send_packet()), // and writes to a transport (representing a usb/tcp connection). static void write_transport_thread(void* _t) { atransport *t = reinterpret_cast(_t); apacket *p; int active = 0; adb_thread_setname(android::base::StringPrintf("->%s", (t->serial != nullptr ? t->serial : "transport"))); D("%s: starting write_transport thread, reading from fd %d", t->serial, t->fd); for(;;){ if(read_packet(t->fd, t->serial, &p)) { D("%s: failed to read apacket from transport on fd %d", t->serial, t->fd ); break; } if(p->msg.command == A_SYNC){ if(p->msg.arg0 == 0) { D("%s: transport SYNC offline", t->serial); put_apacket(p); break; } else { if(p->msg.arg1 == t->sync_token) { D("%s: transport SYNC online", t->serial); active = 1; } else { D("%s: transport ignoring SYNC %d != %d", t->serial, p->msg.arg1, t->sync_token); } } } else { if(active) { D("%s: transport got packet, sending to remote", t->serial); t->write_to_remote(p, t); } else { D("%s: transport ignoring packet while offline", t->serial); } } put_apacket(p); } D("%s: write_transport thread is exiting, fd %d", t->serial, t->fd); kick_transport(t); transport_unref(t); } void kick_transport(atransport* t) { adb_mutex_lock(&transport_lock); // As kick_transport() can be called from threads without guarantee that t is valid, // check if the transport is in transport_list first. if (std::find(transport_list.begin(), transport_list.end(), t) != transport_list.end()) { t->Kick(); } adb_mutex_unlock(&transport_lock); } static int transport_registration_send = -1; static int transport_registration_recv = -1; static fdevent transport_registration_fde; #if ADB_HOST /* this adds support required by the 'track-devices' service. * this is used to send the content of "list_transport" to any * number of client connections that want it through a single * live TCP connection */ struct device_tracker { asocket socket; int update_needed; device_tracker* next; }; /* linked list of all device trackers */ static device_tracker* device_tracker_list; static void device_tracker_remove( device_tracker* tracker ) { device_tracker** pnode = &device_tracker_list; device_tracker* node = *pnode; adb_mutex_lock( &transport_lock ); while (node) { if (node == tracker) { *pnode = node->next; break; } pnode = &node->next; node = *pnode; } adb_mutex_unlock( &transport_lock ); } static void device_tracker_close( asocket* socket ) { device_tracker* tracker = (device_tracker*) socket; asocket* peer = socket->peer; D( "device tracker %p removed", tracker); if (peer) { peer->peer = NULL; peer->close(peer); } device_tracker_remove(tracker); free(tracker); } static int device_tracker_enqueue( asocket* socket, apacket* p ) { /* you can't read from a device tracker, close immediately */ put_apacket(p); device_tracker_close(socket); return -1; } static int device_tracker_send(device_tracker* tracker, const std::string& string) { apacket* p = get_apacket(); asocket* peer = tracker->socket.peer; snprintf(reinterpret_cast(p->data), 5, "%04x", static_cast(string.size())); memcpy(&p->data[4], string.data(), string.size()); p->len = 4 + string.size(); return peer->enqueue(peer, p); } static void device_tracker_ready(asocket* socket) { device_tracker* tracker = reinterpret_cast(socket); // We want to send the device list when the tracker connects // for the first time, even if no update occurred. if (tracker->update_needed > 0) { tracker->update_needed = 0; std::string transports = list_transports(false); device_tracker_send(tracker, transports); } } asocket* create_device_tracker(void) { device_tracker* tracker = reinterpret_cast(calloc(1, sizeof(*tracker))); if (tracker == nullptr) fatal("cannot allocate device tracker"); D( "device tracker %p created", tracker); tracker->socket.enqueue = device_tracker_enqueue; tracker->socket.ready = device_tracker_ready; tracker->socket.close = device_tracker_close; tracker->update_needed = 1; tracker->next = device_tracker_list; device_tracker_list = tracker; return &tracker->socket; } // Call this function each time the transport list has changed. void update_transports() { std::string transports = list_transports(false); device_tracker* tracker = device_tracker_list; while (tracker != nullptr) { device_tracker* next = tracker->next; // This may destroy the tracker if the connection is closed. device_tracker_send(tracker, transports); tracker = next; } } #else void update_transports() { // Nothing to do on the device side. } #endif // ADB_HOST struct tmsg { atransport *transport; int action; }; static int transport_read_action(int fd, struct tmsg* m) { char *p = (char*)m; int len = sizeof(*m); int r; while(len > 0) { r = adb_read(fd, p, len); if(r > 0) { len -= r; p += r; } else { D("transport_read_action: on fd %d: %s", fd, strerror(errno)); return -1; } } return 0; } static int transport_write_action(int fd, struct tmsg* m) { char *p = (char*)m; int len = sizeof(*m); int r; while(len > 0) { r = adb_write(fd, p, len); if(r > 0) { len -= r; p += r; } else { D("transport_write_action: on fd %d: %s", fd, strerror(errno)); return -1; } } return 0; } static void transport_registration_func(int _fd, unsigned ev, void *data) { tmsg m; int s[2]; atransport *t; if(!(ev & FDE_READ)) { return; } if(transport_read_action(_fd, &m)) { fatal_errno("cannot read transport registration socket"); } t = m.transport; if (m.action == 0) { D("transport: %s removing and free'ing %d", t->serial, t->transport_socket); /* IMPORTANT: the remove closes one half of the ** socket pair. The close closes the other half. */ fdevent_remove(&(t->transport_fde)); adb_close(t->fd); adb_mutex_lock(&transport_lock); transport_list.remove(t); adb_mutex_unlock(&transport_lock); if (t->product) free(t->product); if (t->serial) free(t->serial); if (t->model) free(t->model); if (t->device) free(t->device); if (t->devpath) free(t->devpath); delete t; update_transports(); return; } /* don't create transport threads for inaccessible devices */ if (t->connection_state != kCsNoPerm) { /* initial references are the two threads */ t->ref_count = 2; if (adb_socketpair(s)) { fatal_errno("cannot open transport socketpair"); } D("transport: %s socketpair: (%d,%d) starting", t->serial, s[0], s[1]); t->transport_socket = s[0]; t->fd = s[1]; fdevent_install(&(t->transport_fde), t->transport_socket, transport_socket_events, t); fdevent_set(&(t->transport_fde), FDE_READ); if (!adb_thread_create(write_transport_thread, t)) { fatal_errno("cannot create write_transport thread"); } if (!adb_thread_create(read_transport_thread, t)) { fatal_errno("cannot create read_transport thread"); } } adb_mutex_lock(&transport_lock); pending_list.remove(t); transport_list.push_front(t); adb_mutex_unlock(&transport_lock); update_transports(); } void init_transport_registration(void) { int s[2]; if(adb_socketpair(s)){ fatal_errno("cannot open transport registration socketpair"); } D("socketpair: (%d,%d)", s[0], s[1]); transport_registration_send = s[0]; transport_registration_recv = s[1]; fdevent_install(&transport_registration_fde, transport_registration_recv, transport_registration_func, 0); fdevent_set(&transport_registration_fde, FDE_READ); } /* the fdevent select pump is single threaded */ static void register_transport(atransport *transport) { tmsg m; m.transport = transport; m.action = 1; D("transport: %s registered", transport->serial); if(transport_write_action(transport_registration_send, &m)) { fatal_errno("cannot write transport registration socket\n"); } } static void remove_transport(atransport *transport) { tmsg m; m.transport = transport; m.action = 0; D("transport: %s removed", transport->serial); if(transport_write_action(transport_registration_send, &m)) { fatal_errno("cannot write transport registration socket\n"); } } static void transport_unref(atransport* t) { CHECK(t != nullptr); adb_mutex_lock(&transport_lock); CHECK_GT(t->ref_count, 0u); t->ref_count--; if (t->ref_count == 0) { D("transport: %s unref (kicking and closing)", t->serial); t->close(t); remove_transport(t); } else { D("transport: %s unref (count=%zu)", t->serial, t->ref_count); } adb_mutex_unlock(&transport_lock); } static int qual_match(const char *to_test, const char *prefix, const char *qual, bool sanitize_qual) { if (!to_test || !*to_test) /* Return true if both the qual and to_test are null strings. */ return !qual || !*qual; if (!qual) return 0; if (prefix) { while (*prefix) { if (*prefix++ != *to_test++) return 0; } } while (*qual) { char ch = *qual++; if (sanitize_qual && !isalnum(ch)) ch = '_'; if (ch != *to_test++) return 0; } /* Everything matched so far. Return true if *to_test is a NUL. */ return !*to_test; } atransport* acquire_one_transport(TransportType type, const char* serial, bool* is_ambiguous, std::string* error_out) { atransport* result = nullptr; if (serial) { *error_out = android::base::StringPrintf("device '%s' not found", serial); } else if (type == kTransportLocal) { *error_out = "no emulators found"; } else if (type == kTransportAny) { *error_out = "no devices/emulators found"; } else { *error_out = "no devices found"; } adb_mutex_lock(&transport_lock); for (const auto& t : transport_list) { if (t->connection_state == kCsNoPerm) { #if ADB_HOST *error_out = UsbNoPermissionsLongHelpText(); #endif continue; } // Check for matching serial number. if (serial) { if (t->MatchesTarget(serial)) { if (result) { *error_out = "more than one device"; if (is_ambiguous) *is_ambiguous = true; result = nullptr; break; } result = t; } } else { if (type == kTransportUsb && t->type == kTransportUsb) { if (result) { *error_out = "more than one device"; if (is_ambiguous) *is_ambiguous = true; result = nullptr; break; } result = t; } else if (type == kTransportLocal && t->type == kTransportLocal) { if (result) { *error_out = "more than one emulator"; if (is_ambiguous) *is_ambiguous = true; result = nullptr; break; } result = t; } else if (type == kTransportAny) { if (result) { *error_out = "more than one device/emulator"; if (is_ambiguous) *is_ambiguous = true; result = nullptr; break; } result = t; } } } adb_mutex_unlock(&transport_lock); // Don't return unauthorized devices; the caller can't do anything with them. if (result && result->connection_state == kCsUnauthorized) { *error_out = "device unauthorized.\n"; char* ADB_VENDOR_KEYS = getenv("ADB_VENDOR_KEYS"); *error_out += "This adb server's $ADB_VENDOR_KEYS is "; *error_out += ADB_VENDOR_KEYS ? ADB_VENDOR_KEYS : "not set"; *error_out += "\n"; *error_out += "Try 'adb kill-server' if that seems wrong.\n"; *error_out += "Otherwise check for a confirmation dialog on your device."; result = nullptr; } // Don't return offline devices; the caller can't do anything with them. if (result && result->connection_state == kCsOffline) { *error_out = "device offline"; result = nullptr; } if (result) { *error_out = "success"; } return result; } void atransport::Kick() { if (!kicked_) { kicked_ = true; CHECK(kick_func_ != nullptr); kick_func_(this); } } const std::string atransport::connection_state_name() const { switch (connection_state) { case kCsOffline: return "offline"; case kCsBootloader: return "bootloader"; case kCsDevice: return "device"; case kCsHost: return "host"; case kCsRecovery: return "recovery"; case kCsNoPerm: return UsbNoPermissionsShortHelpText(); case kCsSideload: return "sideload"; case kCsUnauthorized: return "unauthorized"; default: return "unknown"; } } void atransport::update_version(int version, size_t payload) { protocol_version = std::min(version, A_VERSION); max_payload = std::min(payload, MAX_PAYLOAD); } int atransport::get_protocol_version() const { return protocol_version; } size_t atransport::get_max_payload() const { return max_payload; } namespace { constexpr char kFeatureStringDelimiter = ','; } // namespace const FeatureSet& supported_features() { // Local static allocation to avoid global non-POD variables. static const FeatureSet* features = new FeatureSet{ kFeatureShell2, kFeatureCmd // Increment ADB_SERVER_VERSION whenever the feature list changes to // make sure that the adb client and server features stay in sync // (http://b/24370690). }; return *features; } std::string FeatureSetToString(const FeatureSet& features) { return android::base::Join(features, kFeatureStringDelimiter); } FeatureSet StringToFeatureSet(const std::string& features_string) { if (features_string.empty()) { return FeatureSet(); } auto names = android::base::Split(features_string, {kFeatureStringDelimiter}); return FeatureSet(names.begin(), names.end()); } bool CanUseFeature(const FeatureSet& feature_set, const std::string& feature) { return feature_set.count(feature) > 0 && supported_features().count(feature) > 0; } bool atransport::has_feature(const std::string& feature) const { return features_.count(feature) > 0; } void atransport::SetFeatures(const std::string& features_string) { features_ = StringToFeatureSet(features_string); } void atransport::AddDisconnect(adisconnect* disconnect) { disconnects_.push_back(disconnect); } void atransport::RemoveDisconnect(adisconnect* disconnect) { disconnects_.remove(disconnect); } void atransport::RunDisconnects() { for (const auto& disconnect : disconnects_) { disconnect->func(disconnect->opaque, this); } disconnects_.clear(); } bool atransport::MatchesTarget(const std::string& target) const { if (serial) { if (target == serial) { return true; } else if (type == kTransportLocal) { // Local transports can match [tcp:|udp:][:port]. const char* local_target_ptr = target.c_str(); // For fastboot compatibility, ignore protocol prefixes. if (android::base::StartsWith(target, "tcp:") || android::base::StartsWith(target, "udp:")) { local_target_ptr += 4; } // Parse our |serial| and the given |target| to check if the hostnames and ports match. std::string serial_host, error; int serial_port = -1; if (android::base::ParseNetAddress(serial, &serial_host, &serial_port, nullptr, &error)) { // |target| may omit the port to default to ours. std::string target_host; int target_port = serial_port; if (android::base::ParseNetAddress(local_target_ptr, &target_host, &target_port, nullptr, &error) && serial_host == target_host && serial_port == target_port) { return true; } } } } return (devpath && target == devpath) || qual_match(target.c_str(), "product:", product, false) || qual_match(target.c_str(), "model:", model, true) || qual_match(target.c_str(), "device:", device, false); } #if ADB_HOST static void append_transport_info(std::string* result, const char* key, const char* value, bool sanitize) { if (value == nullptr || *value == '\0') { return; } *result += ' '; *result += key; for (const char* p = value; *p; ++p) { result->push_back((!sanitize || isalnum(*p)) ? *p : '_'); } } static void append_transport(const atransport* t, std::string* result, bool long_listing) { const char* serial = t->serial; if (!serial || !serial[0]) { serial = "(no serial number)"; } if (!long_listing) { *result += serial; *result += '\t'; *result += t->connection_state_name(); } else { android::base::StringAppendF(result, "%-22s %s", serial, t->connection_state_name().c_str()); append_transport_info(result, "", t->devpath, false); append_transport_info(result, "product:", t->product, false); append_transport_info(result, "model:", t->model, true); append_transport_info(result, "device:", t->device, false); } *result += '\n'; } std::string list_transports(bool long_listing) { std::string result; adb_mutex_lock(&transport_lock); for (const auto& t : transport_list) { append_transport(t, &result, long_listing); } adb_mutex_unlock(&transport_lock); return result; } /* hack for osx */ void close_usb_devices() { adb_mutex_lock(&transport_lock); for (const auto& t : transport_list) { t->Kick(); } adb_mutex_unlock(&transport_lock); } #endif // ADB_HOST int register_socket_transport(int s, const char *serial, int port, int local) { atransport* t = new atransport(); if (!serial) { char buf[32]; snprintf(buf, sizeof(buf), "T-%p", t); serial = buf; } D("transport: %s init'ing for socket %d, on port %d", serial, s, port); if (init_socket_transport(t, s, port, local) < 0) { delete t; return -1; } adb_mutex_lock(&transport_lock); for (const auto& transport : pending_list) { if (transport->serial && strcmp(serial, transport->serial) == 0) { adb_mutex_unlock(&transport_lock); delete t; return -1; } } for (const auto& transport : transport_list) { if (transport->serial && strcmp(serial, transport->serial) == 0) { adb_mutex_unlock(&transport_lock); delete t; return -1; } } pending_list.push_front(t); t->serial = strdup(serial); adb_mutex_unlock(&transport_lock); register_transport(t); return 0; } #if ADB_HOST atransport *find_transport(const char *serial) { atransport* result = nullptr; adb_mutex_lock(&transport_lock); for (auto& t : transport_list) { if (t->serial && strcmp(serial, t->serial) == 0) { result = t; break; } } adb_mutex_unlock(&transport_lock); return result; } void kick_all_tcp_devices() { adb_mutex_lock(&transport_lock); for (auto& t : transport_list) { // TCP/IP devices have adb_port == 0. if (t->type == kTransportLocal && t->adb_port == 0) { // Kicking breaks the read_transport thread of this transport out of any read, then // the read_transport thread will notify the main thread to make this transport // offline. Then the main thread will notify the write_transport thread to exit. // Finally, this transport will be closed and freed in the main thread. t->Kick(); } } adb_mutex_unlock(&transport_lock); } #endif void register_usb_transport(usb_handle* usb, const char* serial, const char* devpath, unsigned writeable) { atransport* t = new atransport(); D("transport: %p init'ing for usb_handle %p (sn='%s')", t, usb, serial ? serial : ""); init_usb_transport(t, usb, (writeable ? kCsOffline : kCsNoPerm)); if(serial) { t->serial = strdup(serial); } if (devpath) { t->devpath = strdup(devpath); } adb_mutex_lock(&transport_lock); pending_list.push_front(t); adb_mutex_unlock(&transport_lock); register_transport(t); } // This should only be used for transports with connection_state == kCsNoPerm. void unregister_usb_transport(usb_handle *usb) { adb_mutex_lock(&transport_lock); transport_list.remove_if([usb](atransport* t) { return t->usb == usb && t->connection_state == kCsNoPerm; }); adb_mutex_unlock(&transport_lock); } int check_header(apacket *p, atransport *t) { if(p->msg.magic != (p->msg.command ^ 0xffffffff)) { VLOG(RWX) << "check_header(): invalid magic"; return -1; } if(p->msg.data_length > t->get_max_payload()) { VLOG(RWX) << "check_header(): " << p->msg.data_length << " atransport::max_payload = " << t->get_max_payload(); return -1; } return 0; } int check_data(apacket *p) { unsigned count, sum; unsigned char *x; count = p->msg.data_length; x = p->data; sum = 0; while(count-- > 0) { sum += *x++; } if(sum != p->msg.data_check) { return -1; } else { return 0; } } adb/transport.h0100644 0000000 0000000 00000013520 12767234553 012557 0ustar000000000 0000000 /* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef __TRANSPORT_H #define __TRANSPORT_H #include #include #include #include #include "adb.h" typedef std::unordered_set FeatureSet; const FeatureSet& supported_features(); // Encodes and decodes FeatureSet objects into human-readable strings. std::string FeatureSetToString(const FeatureSet& features); FeatureSet StringToFeatureSet(const std::string& features_string); // Returns true if both local features and |feature_set| support |feature|. bool CanUseFeature(const FeatureSet& feature_set, const std::string& feature); // Do not use any of [:;=,] in feature strings, they have special meaning // in the connection banner. extern const char* const kFeatureShell2; // The 'cmd' command is available extern const char* const kFeatureCmd; class atransport { public: // TODO(danalbert): We expose waaaaaaay too much stuff because this was // historically just a struct, but making the whole thing a more idiomatic // class in one go is a very large change. Given how bad our testing is, // it's better to do this piece by piece. atransport() { transport_fde = {}; protocol_version = A_VERSION; max_payload = MAX_PAYLOAD; } virtual ~atransport() {} int (*read_from_remote)(apacket* p, atransport* t) = nullptr; int (*write_to_remote)(apacket* p, atransport* t) = nullptr; void (*close)(atransport* t) = nullptr; void SetKickFunction(void (*kick_func)(atransport*)) { kick_func_ = kick_func; } bool IsKicked() { return kicked_; } void Kick(); int fd = -1; int transport_socket = -1; fdevent transport_fde; size_t ref_count = 0; uint32_t sync_token = 0; ConnectionState connection_state = kCsOffline; bool online = false; TransportType type = kTransportAny; // USB handle or socket fd as needed. usb_handle* usb = nullptr; int sfd = -1; // Used to identify transports for clients. char* serial = nullptr; char* product = nullptr; char* model = nullptr; char* device = nullptr; char* devpath = nullptr; int adb_port = -1; // Use for emulators (local transport) void* key = nullptr; unsigned char token[TOKEN_SIZE] = {}; size_t failed_auth_attempts = 0; const std::string connection_state_name() const; void update_version(int version, size_t payload); int get_protocol_version() const; size_t get_max_payload() const; const FeatureSet& features() const { return features_; } bool has_feature(const std::string& feature) const; // Loads the transport's feature set from the given string. void SetFeatures(const std::string& features_string); void AddDisconnect(adisconnect* disconnect); void RemoveDisconnect(adisconnect* disconnect); void RunDisconnects(); // Returns true if |target| matches this transport. A matching |target| can be any of: // * // * // * product: // * model: // * device: // // If this is a local transport, serial will also match [tcp:|udp:][:port] targets. // For example, serial "100.100.100.100:5555" would match any of: // * 100.100.100.100 // * tcp:100.100.100.100 // * udp:100.100.100.100:5555 // This is to make it easier to use the same network target for both fastboot and adb. bool MatchesTarget(const std::string& target) const; private: bool kicked_ = false; void (*kick_func_)(atransport*) = nullptr; // A set of features transmitted in the banner with the initial connection. // This is stored in the banner as 'features=feature0,feature1,etc'. FeatureSet features_; int protocol_version; size_t max_payload; // A list of adisconnect callbacks called when the transport is kicked. std::list disconnects_; DISALLOW_COPY_AND_ASSIGN(atransport); }; /* * Obtain a transport from the available transports. * If serial is non-null then only the device with that serial will be chosen. * If multiple devices/emulators would match, *is_ambiguous (if non-null) * is set to true and nullptr returned. * If no suitable transport is found, error is set and nullptr returned. */ atransport* acquire_one_transport(TransportType type, const char* serial, bool* is_ambiguous, std::string* error_out); void kick_transport(atransport* t); void update_transports(void); void init_transport_registration(void); std::string list_transports(bool long_listing); atransport* find_transport(const char* serial); void kick_all_tcp_devices(); void register_usb_transport(usb_handle* h, const char* serial, const char* devpath, unsigned writeable); /* cause new transports to be init'd and added to the list */ int register_socket_transport(int s, const char* serial, int port, int local); // This should only be used for transports with connection_state == kCsNoPerm. void unregister_usb_transport(usb_handle* usb); int check_header(apacket* p, atransport* t); int check_data(apacket* p); /* for MacOS X cleanup */ void close_usb_devices(); void send_packet(apacket* p, atransport* t); asocket* create_device_tracker(void); #endif /* __TRANSPORT_H */ adb/transport_local.cpp0100644 0000000 0000000 00000032356 12767234553 014274 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG TRANSPORT #include "sysdeps.h" #include "transport.h" #include #include #include #include #include #include #include #if !ADB_HOST #include "cutils/properties.h" #endif #include "adb.h" #include "adb_io.h" #include "adb_utils.h" #if ADB_HOST // Android Wear has been using port 5601 in all of its documentation/tooling, // but we search for emulators on ports [5554, 5555 + ADB_LOCAL_TRANSPORT_MAX]. // Avoid stomping on their port by limiting the number of emulators that can be // connected. #define ADB_LOCAL_TRANSPORT_MAX 16 ADB_MUTEX_DEFINE(local_transports_lock); /* we keep a list of opened transports. The atransport struct knows to which * local transport it is connected. The list is used to detect when we're * trying to connect twice to a given local transport. */ static atransport* local_transports[ ADB_LOCAL_TRANSPORT_MAX ]; #endif /* ADB_HOST */ static int remote_read(apacket *p, atransport *t) { if(!ReadFdExactly(t->sfd, &p->msg, sizeof(amessage))){ D("remote local: read terminated (message)"); return -1; } if(check_header(p, t)) { D("bad header: terminated (data)"); return -1; } if(!ReadFdExactly(t->sfd, p->data, p->msg.data_length)){ D("remote local: terminated (data)"); return -1; } if(check_data(p)) { D("bad data: terminated (data)"); return -1; } return 0; } static int remote_write(apacket *p, atransport *t) { int length = p->msg.data_length; if(!WriteFdExactly(t->sfd, &p->msg, sizeof(amessage) + length)) { D("remote local: write terminated"); return -1; } return 0; } void local_connect(int port) { std::string dummy; local_connect_arbitrary_ports(port-1, port, &dummy); } int local_connect_arbitrary_ports(int console_port, int adb_port, std::string* error) { int fd = -1; #if ADB_HOST if (find_emulator_transport_by_adb_port(adb_port) != nullptr) { return -1; } const char *host = getenv("ADBHOST"); if (host) { fd = network_connect(host, adb_port, SOCK_STREAM, 0, error); } #endif if (fd < 0) { fd = network_loopback_client(adb_port, SOCK_STREAM, error); } if (fd >= 0) { D("client: connected on remote on fd %d", fd); close_on_exec(fd); disable_tcp_nagle(fd); std::string serial = android::base::StringPrintf("emulator-%d", console_port); if (register_socket_transport(fd, serial.c_str(), adb_port, 1) == 0) { return 0; } adb_close(fd); } return -1; } #if ADB_HOST static void client_socket_thread(void* x) { adb_thread_setname("client_socket_thread"); D("transport: client_socket_thread() starting"); while (true) { int port = DEFAULT_ADB_LOCAL_TRANSPORT_PORT; int count = ADB_LOCAL_TRANSPORT_MAX; // Try to connect to any number of running emulator instances. for ( ; count > 0; count--, port += 2 ) { local_connect(port); } sleep(1); } } #else // ADB_HOST static void server_socket_thread(void* arg) { int serverfd, fd; sockaddr_storage ss; sockaddr *addrp = reinterpret_cast(&ss); socklen_t alen; int port = (int) (uintptr_t) arg; adb_thread_setname("server socket"); D("transport: server_socket_thread() starting"); serverfd = -1; for(;;) { if(serverfd == -1) { std::string error; serverfd = network_inaddr_any_server(port, SOCK_STREAM, &error); if(serverfd < 0) { D("server: cannot bind socket yet: %s", error.c_str()); adb_sleep_ms(1000); continue; } close_on_exec(serverfd); } alen = sizeof(ss); D("server: trying to get new connection from %d", port); fd = adb_socket_accept(serverfd, addrp, &alen); if(fd >= 0) { D("server: new connection on fd %d", fd); close_on_exec(fd); disable_tcp_nagle(fd); register_socket_transport(fd, "host", port, 1); } } D("transport: server_socket_thread() exiting"); } /* This is relevant only for ADB daemon running inside the emulator. */ /* * Redefine open and write for qemu_pipe.h that contains inlined references * to those routines. We will redifine them back after qemu_pipe.h inclusion. */ #undef open #undef write #define open adb_open #define write adb_write #include #undef open #undef write #define open ___xxx_open #define write ___xxx_write /* A worker thread that monitors host connections, and registers a transport for * every new host connection. This thread replaces server_socket_thread on * condition that adbd daemon runs inside the emulator, and emulator uses QEMUD * pipe to communicate with adbd daemon inside the guest. This is done in order * to provide more robust communication channel between ADB host and guest. The * main issue with server_socket_thread approach is that it runs on top of TCP, * and thus is sensitive to network disruptions. For instance, the * ConnectionManager may decide to reset all network connections, in which case * the connection between ADB host and guest will be lost. To make ADB traffic * independent from the network, we use here 'adb' QEMUD service to transfer data * between the host, and the guest. See external/qemu/android/adb-*.* that * implements the emulator's side of the protocol. Another advantage of using * QEMUD approach is that ADB will be up much sooner, since it doesn't depend * anymore on network being set up. * The guest side of the protocol contains the following phases: * - Connect with adb QEMUD service. In this phase a handle to 'adb' QEMUD service * is opened, and it becomes clear whether or not emulator supports that * protocol. * - Wait for the ADB host to create connection with the guest. This is done by * sending an 'accept' request to the adb QEMUD service, and waiting on * response. * - When new ADB host connection is accepted, the connection with adb QEMUD * service is registered as the transport, and a 'start' request is sent to the * adb QEMUD service, indicating that the guest is ready to receive messages. * Note that the guest will ignore messages sent down from the emulator before * the transport registration is completed. That's why we need to send the * 'start' request after the transport is registered. */ static void qemu_socket_thread(void* arg) { /* 'accept' request to the adb QEMUD service. */ static const char _accept_req[] = "accept"; /* 'start' request to the adb QEMUD service. */ static const char _start_req[] = "start"; /* 'ok' reply from the adb QEMUD service. */ static const char _ok_resp[] = "ok"; const int port = (int) (uintptr_t) arg; int fd; char tmp[256]; char con_name[32]; adb_thread_setname("qemu socket"); D("transport: qemu_socket_thread() starting"); /* adb QEMUD service connection request. */ snprintf(con_name, sizeof(con_name), "qemud:adb:%d", port); /* Connect to the adb QEMUD service. */ fd = qemu_pipe_open(con_name); if (fd < 0) { /* This could be an older version of the emulator, that doesn't * implement adb QEMUD service. Fall back to the old TCP way. */ D("adb service is not available. Falling back to TCP socket."); adb_thread_create(server_socket_thread, arg); return; } for(;;) { /* * Wait till the host creates a new connection. */ /* Send the 'accept' request. */ if (WriteFdExactly(fd, _accept_req, strlen(_accept_req))) { /* Wait for the response. In the response we expect 'ok' on success, * or 'ko' on failure. */ if (!ReadFdExactly(fd, tmp, 2) || memcmp(tmp, _ok_resp, 2)) { D("Accepting ADB host connection has failed."); adb_close(fd); } else { /* Host is connected. Register the transport, and start the * exchange. */ std::string serial = android::base::StringPrintf("host-%d", fd); register_socket_transport(fd, serial.c_str(), port, 1); if (!WriteFdExactly(fd, _start_req, strlen(_start_req))) { adb_close(fd); } } /* Prepare for accepting of the next ADB host connection. */ fd = qemu_pipe_open(con_name); if (fd < 0) { D("adb service become unavailable."); return; } } else { D("Unable to send the '%s' request to ADB service.", _accept_req); return; } } D("transport: qemu_socket_thread() exiting"); return; } #endif // !ADB_HOST void local_init(int port) { adb_thread_func_t func; const char* debug_name = ""; #if ADB_HOST func = client_socket_thread; debug_name = "client"; #else /* For the adbd daemon in the system image we need to distinguish * between the device, and the emulator. */ char is_qemu[PROPERTY_VALUE_MAX]; property_get("ro.kernel.qemu", is_qemu, ""); if (!strcmp(is_qemu, "1")) { /* Running inside the emulator: use QEMUD pipe as the transport. */ func = qemu_socket_thread; } else { /* Running inside the device: use TCP socket as the transport. */ func = server_socket_thread; } debug_name = "server"; #endif // !ADB_HOST D("transport: local %s init", debug_name); if (!adb_thread_create(func, (void *) (uintptr_t) port)) { fatal_errno("cannot create local socket %s thread", debug_name); } } static void remote_kick(atransport *t) { int fd = t->sfd; t->sfd = -1; adb_shutdown(fd); adb_close(fd); #if ADB_HOST int nn; adb_mutex_lock( &local_transports_lock ); for (nn = 0; nn < ADB_LOCAL_TRANSPORT_MAX; nn++) { if (local_transports[nn] == t) { local_transports[nn] = NULL; break; } } adb_mutex_unlock( &local_transports_lock ); #endif } static void remote_close(atransport *t) { int fd = t->sfd; if (fd != -1) { t->sfd = -1; adb_close(fd); } } #if ADB_HOST /* Only call this function if you already hold local_transports_lock. */ atransport* find_emulator_transport_by_adb_port_locked(int adb_port) { int i; for (i = 0; i < ADB_LOCAL_TRANSPORT_MAX; i++) { if (local_transports[i] && local_transports[i]->adb_port == adb_port) { return local_transports[i]; } } return NULL; } atransport* find_emulator_transport_by_adb_port(int adb_port) { adb_mutex_lock( &local_transports_lock ); atransport* result = find_emulator_transport_by_adb_port_locked(adb_port); adb_mutex_unlock( &local_transports_lock ); return result; } /* Only call this function if you already hold local_transports_lock. */ int get_available_local_transport_index_locked() { int i; for (i = 0; i < ADB_LOCAL_TRANSPORT_MAX; i++) { if (local_transports[i] == NULL) { return i; } } return -1; } int get_available_local_transport_index() { adb_mutex_lock( &local_transports_lock ); int result = get_available_local_transport_index_locked(); adb_mutex_unlock( &local_transports_lock ); return result; } #endif int init_socket_transport(atransport *t, int s, int adb_port, int local) { int fail = 0; t->SetKickFunction(remote_kick); t->close = remote_close; t->read_from_remote = remote_read; t->write_to_remote = remote_write; t->sfd = s; t->sync_token = 1; t->connection_state = kCsOffline; t->type = kTransportLocal; t->adb_port = 0; #if ADB_HOST if (local) { adb_mutex_lock( &local_transports_lock ); { t->adb_port = adb_port; atransport* existing_transport = find_emulator_transport_by_adb_port_locked(adb_port); int index = get_available_local_transport_index_locked(); if (existing_transport != NULL) { D("local transport for port %d already registered (%p)?", adb_port, existing_transport); fail = -1; } else if (index < 0) { // Too many emulators. D("cannot register more emulators. Maximum is %d", ADB_LOCAL_TRANSPORT_MAX); fail = -1; } else { local_transports[index] = t; } } adb_mutex_unlock( &local_transports_lock ); } #endif return fail; } adb/transport_test.cpp0100644 0000000 0000000 00000015373 12767234553 014161 0ustar000000000 0000000 /* * Copyright (C) 2015 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "transport.h" #include #include "adb.h" class TransportSetup { public: TransportSetup() { #ifdef _WIN32 // Use extern instead of including sysdeps.h which brings in various macros // that conflict with APIs used in this file. extern void adb_sysdeps_init(void); adb_sysdeps_init(); #else // adb_sysdeps_init() is an inline function that we cannot link against. #endif } }; // Static initializer will call adb_sysdeps_init() before main() to initialize // the transport mutex before it is used in the tests. Alternatives would be to // use __attribute__((constructor)) here or to use that or a static initializer // for adb_sysdeps_init() itself in sysdeps_win32.cpp (caveats of unclear // init order), or to use a test fixture whose SetUp() could do the init once. static TransportSetup g_TransportSetup; TEST(transport, kick_transport) { atransport t; static size_t kick_count; kick_count = 0; // Mutate some member so we can test that the function is run. t.SetKickFunction([](atransport* trans) { kick_count++; }); ASSERT_FALSE(t.IsKicked()); t.Kick(); ASSERT_TRUE(t.IsKicked()); ASSERT_EQ(1u, kick_count); // A transport can only be kicked once. t.Kick(); ASSERT_TRUE(t.IsKicked()); ASSERT_EQ(1u, kick_count); } static void DisconnectFunc(void* arg, atransport*) { int* count = reinterpret_cast(arg); ++*count; } TEST(transport, RunDisconnects) { atransport t; // RunDisconnects() can be called with an empty atransport. t.RunDisconnects(); int count = 0; adisconnect disconnect; disconnect.func = DisconnectFunc; disconnect.opaque = &count; t.AddDisconnect(&disconnect); t.RunDisconnects(); ASSERT_EQ(1, count); // disconnect should have been removed automatically. t.RunDisconnects(); ASSERT_EQ(1, count); count = 0; t.AddDisconnect(&disconnect); t.RemoveDisconnect(&disconnect); t.RunDisconnects(); ASSERT_EQ(0, count); } TEST(transport, SetFeatures) { atransport t; ASSERT_EQ(0U, t.features().size()); t.SetFeatures(FeatureSetToString(FeatureSet{"foo"})); ASSERT_EQ(1U, t.features().size()); ASSERT_TRUE(t.has_feature("foo")); t.SetFeatures(FeatureSetToString(FeatureSet{"foo", "bar"})); ASSERT_EQ(2U, t.features().size()); ASSERT_TRUE(t.has_feature("foo")); ASSERT_TRUE(t.has_feature("bar")); t.SetFeatures(FeatureSetToString(FeatureSet{"foo", "bar", "foo"})); ASSERT_EQ(2U, t.features().size()); ASSERT_TRUE(t.has_feature("foo")); ASSERT_TRUE(t.has_feature("bar")); t.SetFeatures(FeatureSetToString(FeatureSet{"bar", "baz"})); ASSERT_EQ(2U, t.features().size()); ASSERT_FALSE(t.has_feature("foo")); ASSERT_TRUE(t.has_feature("bar")); ASSERT_TRUE(t.has_feature("baz")); t.SetFeatures(""); ASSERT_EQ(0U, t.features().size()); } TEST(transport, parse_banner_no_features) { atransport t; parse_banner("host::", &t); ASSERT_EQ(0U, t.features().size()); ASSERT_EQ(kCsHost, t.connection_state); ASSERT_EQ(nullptr, t.product); ASSERT_EQ(nullptr, t.model); ASSERT_EQ(nullptr, t.device); } TEST(transport, parse_banner_product_features) { atransport t; const char banner[] = "host::ro.product.name=foo;ro.product.model=bar;ro.product.device=baz;"; parse_banner(banner, &t); ASSERT_EQ(kCsHost, t.connection_state); ASSERT_EQ(0U, t.features().size()); ASSERT_EQ(std::string("foo"), t.product); ASSERT_EQ(std::string("bar"), t.model); ASSERT_EQ(std::string("baz"), t.device); } TEST(transport, parse_banner_features) { atransport t; const char banner[] = "host::ro.product.name=foo;ro.product.model=bar;ro.product.device=baz;" "features=woodly,doodly"; parse_banner(banner, &t); ASSERT_EQ(kCsHost, t.connection_state); ASSERT_EQ(2U, t.features().size()); ASSERT_TRUE(t.has_feature("woodly")); ASSERT_TRUE(t.has_feature("doodly")); ASSERT_EQ(std::string("foo"), t.product); ASSERT_EQ(std::string("bar"), t.model); ASSERT_EQ(std::string("baz"), t.device); } TEST(transport, test_matches_target) { std::string serial = "foo"; std::string devpath = "/path/to/bar"; std::string product = "test_product"; std::string model = "test_model"; std::string device = "test_device"; atransport t; t.serial = &serial[0]; t.devpath = &devpath[0]; t.product = &product[0]; t.model = &model[0]; t.device = &device[0]; // These tests should not be affected by the transport type. for (TransportType type : {kTransportAny, kTransportLocal}) { t.type = type; EXPECT_TRUE(t.MatchesTarget(serial)); EXPECT_TRUE(t.MatchesTarget(devpath)); EXPECT_TRUE(t.MatchesTarget("product:" + product)); EXPECT_TRUE(t.MatchesTarget("model:" + model)); EXPECT_TRUE(t.MatchesTarget("device:" + device)); // Product, model, and device don't match without the prefix. EXPECT_FALSE(t.MatchesTarget(product)); EXPECT_FALSE(t.MatchesTarget(model)); EXPECT_FALSE(t.MatchesTarget(device)); } } TEST(transport, test_matches_target_local) { std::string serial = "100.100.100.100:5555"; atransport t; t.serial = &serial[0]; // Network address matching should only be used for local transports. for (TransportType type : {kTransportAny, kTransportLocal}) { t.type = type; bool should_match = (type == kTransportLocal); EXPECT_EQ(should_match, t.MatchesTarget("100.100.100.100")); EXPECT_EQ(should_match, t.MatchesTarget("tcp:100.100.100.100")); EXPECT_EQ(should_match, t.MatchesTarget("tcp:100.100.100.100:5555")); EXPECT_EQ(should_match, t.MatchesTarget("udp:100.100.100.100")); EXPECT_EQ(should_match, t.MatchesTarget("udp:100.100.100.100:5555")); // Wrong protocol, hostname, or port should never match. EXPECT_FALSE(t.MatchesTarget("100.100.100")); EXPECT_FALSE(t.MatchesTarget("100.100.100.100:")); EXPECT_FALSE(t.MatchesTarget("100.100.100.100:-1")); EXPECT_FALSE(t.MatchesTarget("100.100.100.100:5554")); EXPECT_FALSE(t.MatchesTarget("abc:100.100.100.100")); } } adb/transport_usb.cpp0100644 0000000 0000000 00000004632 12767234553 013767 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG TRANSPORT #include "sysdeps.h" #include "transport.h" #include #include #include #include "adb.h" static int remote_read(apacket *p, atransport *t) { if(usb_read(t->usb, &p->msg, sizeof(amessage))){ D("remote usb: read terminated (message)"); return -1; } if(check_header(p, t)) { D("remote usb: check_header failed"); return -1; } if(p->msg.data_length) { if(usb_read(t->usb, p->data, p->msg.data_length)){ D("remote usb: terminated (data)"); return -1; } } if(check_data(p)) { D("remote usb: check_data failed"); return -1; } return 0; } static int remote_write(apacket *p, atransport *t) { unsigned size = p->msg.data_length; if(usb_write(t->usb, &p->msg, sizeof(amessage))) { D("remote usb: 1 - write terminated"); return -1; } if(p->msg.data_length == 0) return 0; if(usb_write(t->usb, &p->data, size)) { D("remote usb: 2 - write terminated"); return -1; } return 0; } static void remote_close(atransport *t) { usb_close(t->usb); t->usb = 0; } static void remote_kick(atransport *t) { usb_kick(t->usb); } void init_usb_transport(atransport *t, usb_handle *h, ConnectionState state) { D("transport: usb"); t->close = remote_close; t->SetKickFunction(remote_kick); t->read_from_remote = remote_read; t->write_to_remote = remote_write; t->sync_token = 1; t->connection_state = state; t->type = kTransportUsb; t->usb = h; } #if ADB_HOST int is_adb_interface(int vid, int pid, int usb_class, int usb_subclass, int usb_protocol) { return (usb_class == ADB_CLASS && usb_subclass == ADB_SUBCLASS && usb_protocol == ADB_PROTOCOL); } #endif adb/usb_linux.cpp0100644 0000000 0000000 00000046463 12767234553 013102 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG USB #include "sysdeps.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "adb.h" #include "transport.h" using namespace std::literals; /* usb scan debugging is waaaay too verbose */ #define DBGX(x...) struct usb_handle { ~usb_handle() { if (fd != -1) unix_close(fd); } std::string path; int fd = -1; unsigned char ep_in; unsigned char ep_out; unsigned zero_mask; unsigned writeable = 1; usbdevfs_urb urb_in; usbdevfs_urb urb_out; bool urb_in_busy = false; bool urb_out_busy = false; bool dead = false; std::condition_variable cv; std::mutex mutex; // for garbage collecting disconnected devices bool mark; // ID of thread currently in REAPURB pthread_t reaper_thread = 0; }; static auto& g_usb_handles_mutex = *new std::mutex(); static auto& g_usb_handles = *new std::list(); static int is_known_device(const char* dev_name) { std::lock_guard lock(g_usb_handles_mutex); for (usb_handle* usb : g_usb_handles) { if (usb->path == dev_name) { // set mark flag to indicate this device is still alive usb->mark = true; return 1; } } return 0; } static void kick_disconnected_devices() { std::lock_guard lock(g_usb_handles_mutex); // kick any devices in the device list that were not found in the device scan for (usb_handle* usb : g_usb_handles) { if (!usb->mark) { usb_kick(usb); } else { usb->mark = false; } } } static inline bool contains_non_digit(const char* name) { while (*name) { if (!isdigit(*name++)) return true; } return false; } static void find_usb_device(const std::string& base, void (*register_device_callback) (const char*, const char*, unsigned char, unsigned char, int, int, unsigned)) { std::unique_ptr bus_dir(opendir(base.c_str()), closedir); if (!bus_dir) return; dirent* de; while ((de = readdir(bus_dir.get())) != 0) { if (contains_non_digit(de->d_name)) continue; std::string bus_name = base + "/" + de->d_name; std::unique_ptr dev_dir(opendir(bus_name.c_str()), closedir); if (!dev_dir) continue; while ((de = readdir(dev_dir.get()))) { unsigned char devdesc[4096]; unsigned char* bufptr = devdesc; unsigned char* bufend; struct usb_device_descriptor* device; struct usb_config_descriptor* config; struct usb_interface_descriptor* interface; struct usb_endpoint_descriptor *ep1, *ep2; unsigned zero_mask = 0; unsigned vid, pid; if (contains_non_digit(de->d_name)) continue; std::string dev_name = bus_name + "/" + de->d_name; if (is_known_device(dev_name.c_str())) { continue; } int fd = unix_open(dev_name.c_str(), O_RDONLY | O_CLOEXEC); if (fd == -1) { continue; } size_t desclength = unix_read(fd, devdesc, sizeof(devdesc)); bufend = bufptr + desclength; // should have device and configuration descriptors, and atleast two endpoints if (desclength < USB_DT_DEVICE_SIZE + USB_DT_CONFIG_SIZE) { D("desclength %zu is too small", desclength); unix_close(fd); continue; } device = (struct usb_device_descriptor*)bufptr; bufptr += USB_DT_DEVICE_SIZE; if((device->bLength != USB_DT_DEVICE_SIZE) || (device->bDescriptorType != USB_DT_DEVICE)) { unix_close(fd); continue; } vid = device->idVendor; pid = device->idProduct; DBGX("[ %s is V:%04x P:%04x ]\n", dev_name.c_str(), vid, pid); // should have config descriptor next config = (struct usb_config_descriptor *)bufptr; bufptr += USB_DT_CONFIG_SIZE; if (config->bLength != USB_DT_CONFIG_SIZE || config->bDescriptorType != USB_DT_CONFIG) { D("usb_config_descriptor not found"); unix_close(fd); continue; } // loop through all the descriptors and look for the ADB interface while (bufptr < bufend) { unsigned char length = bufptr[0]; unsigned char type = bufptr[1]; if (type == USB_DT_INTERFACE) { interface = (struct usb_interface_descriptor *)bufptr; bufptr += length; if (length != USB_DT_INTERFACE_SIZE) { D("interface descriptor has wrong size"); break; } DBGX("bInterfaceClass: %d, bInterfaceSubClass: %d," "bInterfaceProtocol: %d, bNumEndpoints: %d\n", interface->bInterfaceClass, interface->bInterfaceSubClass, interface->bInterfaceProtocol, interface->bNumEndpoints); if (interface->bNumEndpoints == 2 && is_adb_interface(vid, pid, interface->bInterfaceClass, interface->bInterfaceSubClass, interface->bInterfaceProtocol)) { struct stat st; char pathbuf[128]; char link[256]; char *devpath = nullptr; DBGX("looking for bulk endpoints\n"); // looks like ADB... ep1 = (struct usb_endpoint_descriptor *)bufptr; bufptr += USB_DT_ENDPOINT_SIZE; // For USB 3.0 SuperSpeed devices, skip potential // USB 3.0 SuperSpeed Endpoint Companion descriptor if (bufptr+2 <= devdesc + desclength && bufptr[0] == USB_DT_SS_EP_COMP_SIZE && bufptr[1] == USB_DT_SS_ENDPOINT_COMP) { bufptr += USB_DT_SS_EP_COMP_SIZE; } ep2 = (struct usb_endpoint_descriptor *)bufptr; bufptr += USB_DT_ENDPOINT_SIZE; if (bufptr+2 <= devdesc + desclength && bufptr[0] == USB_DT_SS_EP_COMP_SIZE && bufptr[1] == USB_DT_SS_ENDPOINT_COMP) { bufptr += USB_DT_SS_EP_COMP_SIZE; } if (bufptr > devdesc + desclength || ep1->bLength != USB_DT_ENDPOINT_SIZE || ep1->bDescriptorType != USB_DT_ENDPOINT || ep2->bLength != USB_DT_ENDPOINT_SIZE || ep2->bDescriptorType != USB_DT_ENDPOINT) { D("endpoints not found"); break; } // both endpoints should be bulk if (ep1->bmAttributes != USB_ENDPOINT_XFER_BULK || ep2->bmAttributes != USB_ENDPOINT_XFER_BULK) { D("bulk endpoints not found"); continue; } /* aproto 01 needs 0 termination */ if(interface->bInterfaceProtocol == 0x01) { zero_mask = ep1->wMaxPacketSize - 1; } // we have a match. now we just need to figure out which is in and which is out. unsigned char local_ep_in, local_ep_out; if (ep1->bEndpointAddress & USB_ENDPOINT_DIR_MASK) { local_ep_in = ep1->bEndpointAddress; local_ep_out = ep2->bEndpointAddress; } else { local_ep_in = ep2->bEndpointAddress; local_ep_out = ep1->bEndpointAddress; } // Determine the device path if (!fstat(fd, &st) && S_ISCHR(st.st_mode)) { snprintf(pathbuf, sizeof(pathbuf), "/sys/dev/char/%d:%d", major(st.st_rdev), minor(st.st_rdev)); ssize_t link_len = readlink(pathbuf, link, sizeof(link) - 1); if (link_len > 0) { link[link_len] = '\0'; const char* slash = strrchr(link, '/'); if (slash) { snprintf(pathbuf, sizeof(pathbuf), "usb:%s", slash + 1); devpath = pathbuf; } } } register_device_callback(dev_name.c_str(), devpath, local_ep_in, local_ep_out, interface->bInterfaceNumber, device->iSerialNumber, zero_mask); break; } } else { bufptr += length; } } // end of while unix_close(fd); } } } static int usb_bulk_write(usb_handle* h, const void* data, int len) { std::unique_lock lock(h->mutex); D("++ usb_bulk_write ++"); usbdevfs_urb* urb = &h->urb_out; memset(urb, 0, sizeof(*urb)); urb->type = USBDEVFS_URB_TYPE_BULK; urb->endpoint = h->ep_out; urb->status = -1; urb->buffer = const_cast(data); urb->buffer_length = len; if (h->dead) { errno = EINVAL; return -1; } if (TEMP_FAILURE_RETRY(ioctl(h->fd, USBDEVFS_SUBMITURB, urb)) == -1) { return -1; } h->urb_out_busy = true; while (true) { auto now = std::chrono::system_clock::now(); if (h->cv.wait_until(lock, now + 5s) == std::cv_status::timeout || h->dead) { // TODO: call USBDEVFS_DISCARDURB? errno = ETIMEDOUT; return -1; } if (!h->urb_out_busy) { if (urb->status != 0) { errno = -urb->status; return -1; } return urb->actual_length; } } } static int usb_bulk_read(usb_handle* h, void* data, int len) { std::unique_lock lock(h->mutex); D("++ usb_bulk_read ++"); usbdevfs_urb* urb = &h->urb_in; memset(urb, 0, sizeof(*urb)); urb->type = USBDEVFS_URB_TYPE_BULK; urb->endpoint = h->ep_in; urb->status = -1; urb->buffer = data; urb->buffer_length = len; if (h->dead) { errno = EINVAL; return -1; } if (TEMP_FAILURE_RETRY(ioctl(h->fd, USBDEVFS_SUBMITURB, urb)) == -1) { return -1; } h->urb_in_busy = true; while (true) { D("[ reap urb - wait ]"); h->reaper_thread = pthread_self(); int fd = h->fd; lock.unlock(); // This ioctl must not have TEMP_FAILURE_RETRY because we send SIGALRM to break out. usbdevfs_urb* out = nullptr; int res = ioctl(fd, USBDEVFS_REAPURB, &out); int saved_errno = errno; lock.lock(); h->reaper_thread = 0; if (h->dead) { errno = EINVAL; return -1; } if (res < 0) { if (saved_errno == EINTR) { continue; } D("[ reap urb - error ]"); errno = saved_errno; return -1; } D("[ urb @%p status = %d, actual = %d ]", out, out->status, out->actual_length); if (out == &h->urb_in) { D("[ reap urb - IN complete ]"); h->urb_in_busy = false; if (urb->status != 0) { errno = -urb->status; return -1; } return urb->actual_length; } if (out == &h->urb_out) { D("[ reap urb - OUT compelete ]"); h->urb_out_busy = false; h->cv.notify_all(); } } } int usb_write(usb_handle *h, const void *_data, int len) { D("++ usb_write ++"); unsigned char *data = (unsigned char*) _data; int n = usb_bulk_write(h, data, len); if (n != len) { D("ERROR: n = %d, errno = %d (%s)", n, errno, strerror(errno)); return -1; } if (h->zero_mask && !(len & h->zero_mask)) { // If we need 0-markers and our transfer is an even multiple of the packet size, // then send a zero marker. return usb_bulk_write(h, _data, 0); } D("-- usb_write --"); return 0; } int usb_read(usb_handle *h, void *_data, int len) { unsigned char *data = (unsigned char*) _data; int n; D("++ usb_read ++"); while(len > 0) { int xfer = len; D("[ usb read %d fd = %d], path=%s", xfer, h->fd, h->path.c_str()); n = usb_bulk_read(h, data, xfer); D("[ usb read %d ] = %d, path=%s", xfer, n, h->path.c_str()); if(n != xfer) { if((errno == ETIMEDOUT) && (h->fd != -1)) { D("[ timeout ]"); if(n > 0){ data += n; len -= n; } continue; } D("ERROR: n = %d, errno = %d (%s)", n, errno, strerror(errno)); return -1; } len -= xfer; data += xfer; } D("-- usb_read --"); return 0; } void usb_kick(usb_handle* h) { std::lock_guard lock(h->mutex); D("[ kicking %p (fd = %d) ]", h, h->fd); if (!h->dead) { h->dead = true; if (h->writeable) { /* HACK ALERT! ** Sometimes we get stuck in ioctl(USBDEVFS_REAPURB). ** This is a workaround for that problem. */ if (h->reaper_thread) { pthread_kill(h->reaper_thread, SIGALRM); } /* cancel any pending transactions ** these will quietly fail if the txns are not active, ** but this ensures that a reader blocked on REAPURB ** will get unblocked */ ioctl(h->fd, USBDEVFS_DISCARDURB, &h->urb_in); ioctl(h->fd, USBDEVFS_DISCARDURB, &h->urb_out); h->urb_in.status = -ENODEV; h->urb_out.status = -ENODEV; h->urb_in_busy = false; h->urb_out_busy = false; h->cv.notify_all(); } else { unregister_usb_transport(h); } } } int usb_close(usb_handle* h) { std::lock_guard lock(g_usb_handles_mutex); g_usb_handles.remove(h); D("-- usb close %p (fd = %d) --", h, h->fd); delete h; return 0; } static void register_device(const char* dev_name, const char* dev_path, unsigned char ep_in, unsigned char ep_out, int interface, int serial_index, unsigned zero_mask) { // Since Linux will not reassign the device ID (and dev_name) as long as the // device is open, we can add to the list here once we open it and remove // from the list when we're finally closed and everything will work out // fine. // // If we have a usb_handle on the list of handles with a matching name, we // have no further work to do. { std::lock_guard lock(g_usb_handles_mutex); for (usb_handle* usb: g_usb_handles) { if (usb->path == dev_name) { return; } } } D("[ usb located new device %s (%d/%d/%d) ]", dev_name, ep_in, ep_out, interface); std::unique_ptr usb(new usb_handle); usb->path = dev_name; usb->ep_in = ep_in; usb->ep_out = ep_out; usb->zero_mask = zero_mask; // Initialize mark so we don't get garbage collected after the device scan. usb->mark = true; usb->fd = unix_open(usb->path.c_str(), O_RDWR | O_CLOEXEC); if (usb->fd == -1) { // Opening RW failed, so see if we have RO access. usb->fd = unix_open(usb->path.c_str(), O_RDONLY | O_CLOEXEC); if (usb->fd == -1) { D("[ usb open %s failed: %s]", usb->path.c_str(), strerror(errno)); return; } usb->writeable = 0; } D("[ usb opened %s%s, fd=%d]", usb->path.c_str(), (usb->writeable ? "" : " (read-only)"), usb->fd); if (usb->writeable) { if (ioctl(usb->fd, USBDEVFS_CLAIMINTERFACE, &interface) != 0) { D("[ usb ioctl(%d, USBDEVFS_CLAIMINTERFACE) failed: %s]", usb->fd, strerror(errno)); return; } } // Read the device's serial number. std::string serial_path = android::base::StringPrintf( "/sys/bus/usb/devices/%s/serial", dev_path + 4); std::string serial; if (!android::base::ReadFileToString(serial_path, &serial)) { D("[ usb read %s failed: %s ]", serial_path.c_str(), strerror(errno)); // We don't actually want to treat an unknown serial as an error because // devices aren't able to communicate a serial number in early bringup. // http://b/20883914 serial = ""; } serial = android::base::Trim(serial); // Add to the end of the active handles. usb_handle* done_usb = usb.release(); { std::lock_guard lock(g_usb_handles_mutex); g_usb_handles.push_back(done_usb); } register_usb_transport(done_usb, serial.c_str(), dev_path, done_usb->writeable); } static void device_poll_thread(void*) { adb_thread_setname("device poll"); D("Created device thread"); while (true) { // TODO: Use inotify. find_usb_device("/dev/bus/usb", register_device); kick_disconnected_devices(); sleep(1); } } void usb_init() { struct sigaction actions; memset(&actions, 0, sizeof(actions)); sigemptyset(&actions.sa_mask); actions.sa_flags = 0; actions.sa_handler = [](int) {}; sigaction(SIGALRM, &actions, nullptr); if (!adb_thread_create(device_poll_thread, nullptr)) { fatal_errno("cannot create device_poll thread"); } } adb/usb_linux_client.cpp0100644 0000000 0000000 00000043764 12767234553 014441 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG USB #include "sysdeps.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "adb.h" #include "transport.h" #define MAX_PACKET_SIZE_FS 64 #define MAX_PACKET_SIZE_HS 512 #define MAX_PACKET_SIZE_SS 1024 // Writes larger than 16k fail on some devices (seed with 3.10.49-g209ea2f in particular). #define USB_FFS_MAX_WRITE 16384 // The kernel allocates a contiguous buffer for reads, which can fail for large ones due to // fragmentation. 16k chosen arbitrarily to match the write limit. #define USB_FFS_MAX_READ 16384 #define cpu_to_le16(x) htole16(x) #define cpu_to_le32(x) htole32(x) static int dummy_fd = -1; struct usb_handle { adb_cond_t notify; adb_mutex_t lock; bool open_new_connection; std::atomic kicked; int (*write)(usb_handle *h, const void *data, int len); int (*read)(usb_handle *h, void *data, int len); void (*kick)(usb_handle *h); void (*close)(usb_handle *h); // Legacy f_adb int fd; // FunctionFS int control; int bulk_out; /* "out" from the host's perspective => source for adbd */ int bulk_in; /* "in" from the host's perspective => sink for adbd */ }; struct func_desc { struct usb_interface_descriptor intf; struct usb_endpoint_descriptor_no_audio source; struct usb_endpoint_descriptor_no_audio sink; } __attribute__((packed)); struct ss_func_desc { struct usb_interface_descriptor intf; struct usb_endpoint_descriptor_no_audio source; struct usb_ss_ep_comp_descriptor source_comp; struct usb_endpoint_descriptor_no_audio sink; struct usb_ss_ep_comp_descriptor sink_comp; } __attribute__((packed)); struct desc_v1 { struct usb_functionfs_descs_head_v1 { __le32 magic; __le32 length; __le32 fs_count; __le32 hs_count; } __attribute__((packed)) header; struct func_desc fs_descs, hs_descs; } __attribute__((packed)); struct desc_v2 { struct usb_functionfs_descs_head_v2 header; // The rest of the structure depends on the flags in the header. __le32 fs_count; __le32 hs_count; __le32 ss_count; __le32 os_count; struct func_desc fs_descs, hs_descs; struct ss_func_desc ss_descs; struct usb_os_desc_header os_header; struct usb_ext_compat_desc os_desc; } __attribute__((packed)); static struct func_desc fs_descriptors = { .intf = { .bLength = sizeof(fs_descriptors.intf), .bDescriptorType = USB_DT_INTERFACE, .bInterfaceNumber = 0, .bNumEndpoints = 2, .bInterfaceClass = ADB_CLASS, .bInterfaceSubClass = ADB_SUBCLASS, .bInterfaceProtocol = ADB_PROTOCOL, .iInterface = 1, /* first string from the provided table */ }, .source = { .bLength = sizeof(fs_descriptors.source), .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = 1 | USB_DIR_OUT, .bmAttributes = USB_ENDPOINT_XFER_BULK, .wMaxPacketSize = MAX_PACKET_SIZE_FS, }, .sink = { .bLength = sizeof(fs_descriptors.sink), .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = 2 | USB_DIR_IN, .bmAttributes = USB_ENDPOINT_XFER_BULK, .wMaxPacketSize = MAX_PACKET_SIZE_FS, }, }; static struct func_desc hs_descriptors = { .intf = { .bLength = sizeof(hs_descriptors.intf), .bDescriptorType = USB_DT_INTERFACE, .bInterfaceNumber = 0, .bNumEndpoints = 2, .bInterfaceClass = ADB_CLASS, .bInterfaceSubClass = ADB_SUBCLASS, .bInterfaceProtocol = ADB_PROTOCOL, .iInterface = 1, /* first string from the provided table */ }, .source = { .bLength = sizeof(hs_descriptors.source), .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = 1 | USB_DIR_OUT, .bmAttributes = USB_ENDPOINT_XFER_BULK, .wMaxPacketSize = MAX_PACKET_SIZE_HS, }, .sink = { .bLength = sizeof(hs_descriptors.sink), .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = 2 | USB_DIR_IN, .bmAttributes = USB_ENDPOINT_XFER_BULK, .wMaxPacketSize = MAX_PACKET_SIZE_HS, }, }; static struct ss_func_desc ss_descriptors = { .intf = { .bLength = sizeof(ss_descriptors.intf), .bDescriptorType = USB_DT_INTERFACE, .bInterfaceNumber = 0, .bNumEndpoints = 2, .bInterfaceClass = ADB_CLASS, .bInterfaceSubClass = ADB_SUBCLASS, .bInterfaceProtocol = ADB_PROTOCOL, .iInterface = 1, /* first string from the provided table */ }, .source = { .bLength = sizeof(ss_descriptors.source), .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = 1 | USB_DIR_OUT, .bmAttributes = USB_ENDPOINT_XFER_BULK, .wMaxPacketSize = MAX_PACKET_SIZE_SS, }, .source_comp = { .bLength = sizeof(ss_descriptors.source_comp), .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, }, .sink = { .bLength = sizeof(ss_descriptors.sink), .bDescriptorType = USB_DT_ENDPOINT, .bEndpointAddress = 2 | USB_DIR_IN, .bmAttributes = USB_ENDPOINT_XFER_BULK, .wMaxPacketSize = MAX_PACKET_SIZE_SS, }, .sink_comp = { .bLength = sizeof(ss_descriptors.sink_comp), .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, }, }; struct usb_ext_compat_desc os_desc_compat = { .bFirstInterfaceNumber = 0, .Reserved1 = cpu_to_le32(1), .CompatibleID = {0}, .SubCompatibleID = {0}, .Reserved2 = {0}, }; static struct usb_os_desc_header os_desc_header = { .interface = cpu_to_le32(1), .dwLength = cpu_to_le32(sizeof(os_desc_header) + sizeof(os_desc_compat)), .bcdVersion = cpu_to_le32(1), .wIndex = cpu_to_le32(4), .bCount = cpu_to_le32(1), .Reserved = cpu_to_le32(0), }; #define STR_INTERFACE_ "ADB Interface" static const struct { struct usb_functionfs_strings_head header; struct { __le16 code; const char str1[sizeof(STR_INTERFACE_)]; } __attribute__((packed)) lang0; } __attribute__((packed)) strings = { .header = { .magic = cpu_to_le32(FUNCTIONFS_STRINGS_MAGIC), .length = cpu_to_le32(sizeof(strings)), .str_count = cpu_to_le32(1), .lang_count = cpu_to_le32(1), }, .lang0 = { cpu_to_le16(0x0409), /* en-us */ STR_INTERFACE_, }, }; static void usb_adb_open_thread(void* x) { struct usb_handle *usb = (struct usb_handle *)x; int fd; adb_thread_setname("usb open"); while (true) { // wait until the USB device needs opening adb_mutex_lock(&usb->lock); while (!usb->open_new_connection) { adb_cond_wait(&usb->notify, &usb->lock); } usb->open_new_connection = false; adb_mutex_unlock(&usb->lock); D("[ usb_thread - opening device ]"); do { /* XXX use inotify? */ fd = unix_open("/dev/android_adb", O_RDWR); if (fd < 0) { // to support older kernels fd = unix_open("/dev/android", O_RDWR); } if (fd < 0) { adb_sleep_ms(1000); } } while (fd < 0); D("[ opening device succeeded ]"); close_on_exec(fd); usb->fd = fd; D("[ usb_thread - registering device ]"); register_usb_transport(usb, 0, 0, 1); } // never gets here abort(); } static int usb_adb_write(usb_handle *h, const void *data, int len) { int n; D("about to write (fd=%d, len=%d)", h->fd, len); n = unix_write(h->fd, data, len); if(n != len) { D("ERROR: fd = %d, n = %d, errno = %d (%s)", h->fd, n, errno, strerror(errno)); return -1; } if (h->kicked) { D("usb_adb_write finished due to kicked"); return -1; } D("[ done fd=%d ]", h->fd); return 0; } static int usb_adb_read(usb_handle *h, void *data, int len) { D("about to read (fd=%d, len=%d)", h->fd, len); while (len > 0) { // The kernel implementation of adb_read in f_adb.c doesn't support // reads larger then 4096 bytes. Read the data in 4096 byte chunks to // avoid the issue. (The ffs implementation doesn't have this limit.) int bytes_to_read = len < 4096 ? len : 4096; int n = unix_read(h->fd, data, bytes_to_read); if (n != bytes_to_read) { D("ERROR: fd = %d, n = %d, errno = %d (%s)", h->fd, n, errno, strerror(errno)); return -1; } if (h->kicked) { D("usb_adb_read finished due to kicked"); return -1; } len -= n; data = ((char*)data) + n; } D("[ done fd=%d ]", h->fd); return 0; } static void usb_adb_kick(usb_handle *h) { D("usb_kick"); // Other threads may be calling usb_adb_read/usb_adb_write at the same time. // If we close h->fd, the file descriptor will be reused to open other files, // and the read/write thread may operate on the wrong file. So instead // we set the kicked flag and reopen h->fd to a dummy file here. After read/write // threads finish, we close h->fd in usb_adb_close(). h->kicked = true; TEMP_FAILURE_RETRY(dup2(dummy_fd, h->fd)); } static void usb_adb_close(usb_handle *h) { h->kicked = false; adb_close(h->fd); // Notify usb_adb_open_thread to open a new connection. adb_mutex_lock(&h->lock); h->open_new_connection = true; adb_cond_signal(&h->notify); adb_mutex_unlock(&h->lock); } static void usb_adb_init() { usb_handle* h = reinterpret_cast(calloc(1, sizeof(usb_handle))); if (h == nullptr) fatal("couldn't allocate usb_handle"); h->write = usb_adb_write; h->read = usb_adb_read; h->kick = usb_adb_kick; h->close = usb_adb_close; h->kicked = false; h->fd = -1; h->open_new_connection = true; adb_cond_init(&h->notify, 0); adb_mutex_init(&h->lock, 0); // Open the file /dev/android_adb_enable to trigger // the enabling of the adb USB function in the kernel. // We never touch this file again - just leave it open // indefinitely so the kernel will know when we are running // and when we are not. int fd = unix_open("/dev/android_adb_enable", O_RDWR); if (fd < 0) { D("failed to open /dev/android_adb_enable"); } else { close_on_exec(fd); } D("[ usb_init - starting thread ]"); if (!adb_thread_create(usb_adb_open_thread, h)) { fatal_errno("cannot create usb thread"); } } static bool init_functionfs(struct usb_handle *h) { ssize_t ret; struct desc_v1 v1_descriptor; struct desc_v2 v2_descriptor; v2_descriptor.header.magic = cpu_to_le32(FUNCTIONFS_DESCRIPTORS_MAGIC_V2); v2_descriptor.header.length = cpu_to_le32(sizeof(v2_descriptor)); v2_descriptor.header.flags = FUNCTIONFS_HAS_FS_DESC | FUNCTIONFS_HAS_HS_DESC | FUNCTIONFS_HAS_SS_DESC | FUNCTIONFS_HAS_MS_OS_DESC; v2_descriptor.fs_count = 3; v2_descriptor.hs_count = 3; v2_descriptor.ss_count = 5; v2_descriptor.os_count = 1; v2_descriptor.fs_descs = fs_descriptors; v2_descriptor.hs_descs = hs_descriptors; v2_descriptor.ss_descs = ss_descriptors; v2_descriptor.os_header = os_desc_header; v2_descriptor.os_desc = os_desc_compat; if (h->control < 0) { // might have already done this before D("OPENING %s", USB_FFS_ADB_EP0); h->control = adb_open(USB_FFS_ADB_EP0, O_RDWR); if (h->control < 0) { D("[ %s: cannot open control endpoint: errno=%d]", USB_FFS_ADB_EP0, errno); goto err; } ret = adb_write(h->control, &v2_descriptor, sizeof(v2_descriptor)); if (ret < 0) { v1_descriptor.header.magic = cpu_to_le32(FUNCTIONFS_DESCRIPTORS_MAGIC); v1_descriptor.header.length = cpu_to_le32(sizeof(v1_descriptor)); v1_descriptor.header.fs_count = 3; v1_descriptor.header.hs_count = 3; v1_descriptor.fs_descs = fs_descriptors; v1_descriptor.hs_descs = hs_descriptors; D("[ %s: Switching to V1_descriptor format errno=%d ]", USB_FFS_ADB_EP0, errno); ret = adb_write(h->control, &v1_descriptor, sizeof(v1_descriptor)); if (ret < 0) { D("[ %s: write descriptors failed: errno=%d ]", USB_FFS_ADB_EP0, errno); goto err; } } ret = adb_write(h->control, &strings, sizeof(strings)); if (ret < 0) { D("[ %s: writing strings failed: errno=%d]", USB_FFS_ADB_EP0, errno); goto err; } } h->bulk_out = adb_open(USB_FFS_ADB_OUT, O_RDWR); if (h->bulk_out < 0) { D("[ %s: cannot open bulk-out ep: errno=%d ]", USB_FFS_ADB_OUT, errno); goto err; } h->bulk_in = adb_open(USB_FFS_ADB_IN, O_RDWR); if (h->bulk_in < 0) { D("[ %s: cannot open bulk-in ep: errno=%d ]", USB_FFS_ADB_IN, errno); goto err; } return true; err: if (h->bulk_in > 0) { adb_close(h->bulk_in); h->bulk_in = -1; } if (h->bulk_out > 0) { adb_close(h->bulk_out); h->bulk_out = -1; } if (h->control > 0) { adb_close(h->control); h->control = -1; } return false; } static void usb_ffs_open_thread(void* x) { struct usb_handle *usb = (struct usb_handle *)x; adb_thread_setname("usb ffs open"); while (true) { // wait until the USB device needs opening adb_mutex_lock(&usb->lock); while (!usb->open_new_connection) { adb_cond_wait(&usb->notify, &usb->lock); } usb->open_new_connection = false; adb_mutex_unlock(&usb->lock); while (true) { if (init_functionfs(usb)) { break; } adb_sleep_ms(1000); } property_set("sys.usb.ffs.ready", "1"); D("[ usb_thread - registering device ]"); register_usb_transport(usb, 0, 0, 1); } // never gets here abort(); } static int usb_ffs_write(usb_handle* h, const void* data, int len) { D("about to write (fd=%d, len=%d)", h->bulk_in, len); const char* buf = static_cast(data); while (len > 0) { int write_len = std::min(USB_FFS_MAX_WRITE, len); int n = adb_write(h->bulk_in, buf, write_len); if (n < 0) { D("ERROR: fd = %d, n = %d: %s", h->bulk_in, n, strerror(errno)); return -1; } buf += n; len -= n; } D("[ done fd=%d ]", h->bulk_in); return 0; } static int usb_ffs_read(usb_handle* h, void* data, int len) { D("about to read (fd=%d, len=%d)", h->bulk_out, len); char* buf = static_cast(data); while (len > 0) { int read_len = std::min(USB_FFS_MAX_READ, len); int n = adb_read(h->bulk_out, buf, read_len); if (n < 0) { D("ERROR: fd = %d, n = %d: %s", h->bulk_out, n, strerror(errno)); return -1; } buf += n; len -= n; } D("[ done fd=%d ]", h->bulk_out); return 0; } static void usb_ffs_kick(usb_handle *h) { int err; err = ioctl(h->bulk_in, FUNCTIONFS_CLEAR_HALT); if (err < 0) { D("[ kick: source (fd=%d) clear halt failed (%d) ]", h->bulk_in, errno); } err = ioctl(h->bulk_out, FUNCTIONFS_CLEAR_HALT); if (err < 0) { D("[ kick: sink (fd=%d) clear halt failed (%d) ]", h->bulk_out, errno); } // don't close ep0 here, since we may not need to reinitialize it with // the same descriptors again. if however ep1/ep2 fail to re-open in // init_functionfs, only then would we close and open ep0 again. // Ditto the comment in usb_adb_kick. h->kicked = true; TEMP_FAILURE_RETRY(dup2(dummy_fd, h->bulk_out)); TEMP_FAILURE_RETRY(dup2(dummy_fd, h->bulk_in)); } static void usb_ffs_close(usb_handle *h) { h->kicked = false; adb_close(h->bulk_out); adb_close(h->bulk_in); // Notify usb_adb_open_thread to open a new connection. adb_mutex_lock(&h->lock); h->open_new_connection = true; adb_cond_signal(&h->notify); adb_mutex_unlock(&h->lock); } static void usb_ffs_init() { D("[ usb_init - using FunctionFS ]"); usb_handle* h = reinterpret_cast(calloc(1, sizeof(usb_handle))); if (h == nullptr) fatal("couldn't allocate usb_handle"); h->write = usb_ffs_write; h->read = usb_ffs_read; h->kick = usb_ffs_kick; h->close = usb_ffs_close; h->kicked = false; h->control = -1; h->bulk_out = -1; h->bulk_out = -1; h->open_new_connection = true; adb_cond_init(&h->notify, 0); adb_mutex_init(&h->lock, 0); D("[ usb_init - starting thread ]"); if (!adb_thread_create(usb_ffs_open_thread, h)) { fatal_errno("[ cannot create usb thread ]\n"); } } void usb_init() { dummy_fd = adb_open("/dev/null", O_WRONLY); CHECK_NE(dummy_fd, -1); if (access(USB_FFS_ADB_EP0, F_OK) == 0) usb_ffs_init(); else usb_adb_init(); } int usb_write(usb_handle *h, const void *data, int len) { return h->write(h, data, len); } int usb_read(usb_handle *h, void *data, int len) { return h->read(h, data, len); } int usb_close(usb_handle *h) { h->close(h); return 0; } void usb_kick(usb_handle *h) { h->kick(h); } adb/usb_osx.cpp0100644 0000000 0000000 00000044004 12767234553 012541 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG USB #include "sysdeps.h" #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "adb.h" #include "transport.h" struct usb_handle { UInt8 bulkIn; UInt8 bulkOut; IOUSBInterfaceInterface190** interface; unsigned int zero_mask; // For garbage collecting disconnected devices. bool mark; std::string devpath; std::atomic dead; usb_handle() : bulkIn(0), bulkOut(0), interface(nullptr), zero_mask(0), mark(false), dead(false) { } }; static std::atomic usb_inited_flag; static auto& g_usb_handles_mutex = *new std::mutex(); static auto& g_usb_handles = *new std::vector>(); static bool IsKnownDevice(const std::string& devpath) { std::lock_guard lock_guard(g_usb_handles_mutex); for (auto& usb : g_usb_handles) { if (usb->devpath == devpath) { // Set mark flag to indicate this device is still alive. usb->mark = true; return true; } } return false; } static void usb_kick_locked(usb_handle* handle); static void KickDisconnectedDevices() { std::lock_guard lock_guard(g_usb_handles_mutex); for (auto& usb : g_usb_handles) { if (!usb->mark) { usb_kick_locked(usb.get()); } else { usb->mark = false; } } } static void AddDevice(std::unique_ptr handle) { handle->mark = true; std::lock_guard lock(g_usb_handles_mutex); g_usb_handles.push_back(std::move(handle)); } static void AndroidInterfaceAdded(io_iterator_t iterator); static std::unique_ptr CheckInterface(IOUSBInterfaceInterface190 **iface, UInt16 vendor, UInt16 product); static bool FindUSBDevices() { // Create the matching dictionary to find the Android device's adb interface. CFMutableDictionaryRef matchingDict = IOServiceMatching(kIOUSBInterfaceClassName); if (!matchingDict) { LOG(ERROR) << "couldn't create USB matching dictionary"; return false; } // Create an iterator for all I/O Registry objects that match the dictionary. io_iterator_t iter = 0; kern_return_t kr = IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, &iter); if (kr != KERN_SUCCESS) { LOG(ERROR) << "failed to get matching services"; return false; } // Iterate over all matching objects. AndroidInterfaceAdded(iter); IOObjectRelease(iter); return true; } static void AndroidInterfaceAdded(io_iterator_t iterator) { kern_return_t kr; io_service_t usbDevice; io_service_t usbInterface; IOCFPlugInInterface **plugInInterface = NULL; IOUSBInterfaceInterface220 **iface = NULL; IOUSBDeviceInterface197 **dev = NULL; HRESULT result; SInt32 score; uint32_t locationId; UInt8 if_class, subclass, protocol; UInt16 vendor; UInt16 product; UInt8 serialIndex; char serial[256]; std::string devpath; while ((usbInterface = IOIteratorNext(iterator))) { //* Create an intermediate interface plugin kr = IOCreatePlugInInterfaceForService(usbInterface, kIOUSBInterfaceUserClientTypeID, kIOCFPlugInInterfaceID, &plugInInterface, &score); IOObjectRelease(usbInterface); if ((kIOReturnSuccess != kr) || (!plugInInterface)) { LOG(ERROR) << "Unable to create an interface plug-in (" << std::hex << kr << ")"; continue; } //* This gets us the interface object result = (*plugInInterface)->QueryInterface( plugInInterface, CFUUIDGetUUIDBytes(kIOUSBInterfaceInterfaceID), (LPVOID*)&iface); //* We only needed the plugin to get the interface, so discard it (*plugInInterface)->Release(plugInInterface); if (result || !iface) { LOG(ERROR) << "Couldn't query the interface (" << std::hex << result << ")"; continue; } kr = (*iface)->GetInterfaceClass(iface, &if_class); kr = (*iface)->GetInterfaceSubClass(iface, &subclass); kr = (*iface)->GetInterfaceProtocol(iface, &protocol); if(if_class != ADB_CLASS || subclass != ADB_SUBCLASS || protocol != ADB_PROTOCOL) { // Ignore non-ADB devices. LOG(DEBUG) << "Ignoring interface with incorrect class/subclass/protocol - " << if_class << ", " << subclass << ", " << protocol; (*iface)->Release(iface); continue; } //* this gets us an ioservice, with which we will find the actual //* device; after getting a plugin, and querying the interface, of //* course. //* Gotta love OS X kr = (*iface)->GetDevice(iface, &usbDevice); if (kIOReturnSuccess != kr || !usbDevice) { LOG(ERROR) << "Couldn't grab device from interface (" << std::hex << kr << ")"; continue; } plugInInterface = NULL; score = 0; //* create an intermediate device plugin kr = IOCreatePlugInInterfaceForService(usbDevice, kIOUSBDeviceUserClientTypeID, kIOCFPlugInInterfaceID, &plugInInterface, &score); //* only needed this to find the plugin (void)IOObjectRelease(usbDevice); if ((kIOReturnSuccess != kr) || (!plugInInterface)) { LOG(ERROR) << "Unable to create a device plug-in (" << std::hex << kr << ")"; continue; } result = (*plugInInterface)->QueryInterface(plugInInterface, CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID), (LPVOID*)&dev); //* only needed this to query the plugin (*plugInInterface)->Release(plugInInterface); if (result || !dev) { LOG(ERROR) << "Couldn't create a device interface (" << std::hex << result << ")"; continue; } //* Now after all that, we actually have a ref to the device and //* the interface that matched our criteria kr = (*dev)->GetDeviceVendor(dev, &vendor); kr = (*dev)->GetDeviceProduct(dev, &product); kr = (*dev)->GetLocationID(dev, &locationId); if (kr == KERN_SUCCESS) { devpath = android::base::StringPrintf("usb:%" PRIu32 "X", locationId); if (IsKnownDevice(devpath)) { continue; } } kr = (*dev)->USBGetSerialNumberStringIndex(dev, &serialIndex); if (serialIndex > 0) { IOUSBDevRequest req; UInt16 buffer[256]; UInt16 languages[128]; memset(languages, 0, sizeof(languages)); req.bmRequestType = USBmakebmRequestType(kUSBIn, kUSBStandard, kUSBDevice); req.bRequest = kUSBRqGetDescriptor; req.wValue = (kUSBStringDesc << 8) | 0; req.wIndex = 0; req.pData = languages; req.wLength = sizeof(languages); kr = (*dev)->DeviceRequest(dev, &req); if (kr == kIOReturnSuccess && req.wLenDone > 0) { int langCount = (req.wLenDone - 2) / 2, lang; for (lang = 1; lang <= langCount; lang++) { memset(buffer, 0, sizeof(buffer)); memset(&req, 0, sizeof(req)); req.bmRequestType = USBmakebmRequestType(kUSBIn, kUSBStandard, kUSBDevice); req.bRequest = kUSBRqGetDescriptor; req.wValue = (kUSBStringDesc << 8) | serialIndex; req.wIndex = languages[lang]; req.pData = buffer; req.wLength = sizeof(buffer); kr = (*dev)->DeviceRequest(dev, &req); if (kr == kIOReturnSuccess && req.wLenDone > 0) { int i, count; // skip first word, and copy the rest to the serial string, // changing shorts to bytes. count = (req.wLenDone - 1) / 2; for (i = 0; i < count; i++) serial[i] = buffer[i + 1]; serial[i] = 0; break; } } } } (*dev)->Release(dev); VLOG(USB) << android::base::StringPrintf("Found vid=%04x pid=%04x serial=%s\n", vendor, product, serial); if (devpath.empty()) { devpath = serial; } if (IsKnownDevice(devpath)) { (*iface)->USBInterfaceClose(iface); (*iface)->Release(iface); continue; } std::unique_ptr handle = CheckInterface((IOUSBInterfaceInterface190**)iface, vendor, product); if (handle == nullptr) { LOG(ERROR) << "Could not find device interface"; (*iface)->Release(iface); continue; } handle->devpath = devpath; usb_handle* handle_p = handle.get(); VLOG(USB) << "Add usb device " << serial; AddDevice(std::move(handle)); register_usb_transport(handle_p, serial, devpath.c_str(), 1); } } // Used to clear both the endpoints before starting. // When adb quits, we might clear the host endpoint but not the device. // So we make sure both sides are clear before starting up. static bool ClearPipeStallBothEnds(IOUSBInterfaceInterface190** interface, UInt8 bulkEp) { IOReturn rc = (*interface)->ClearPipeStallBothEnds(interface, bulkEp); if (rc != kIOReturnSuccess) { LOG(ERROR) << "Could not clear pipe stall both ends: " << std::hex << rc; return false; } return true; } //* TODO: simplify this further since we only register to get ADB interface //* subclass+protocol events static std::unique_ptr CheckInterface(IOUSBInterfaceInterface190 **interface, UInt16 vendor, UInt16 product) { std::unique_ptr handle; IOReturn kr; UInt8 interfaceNumEndpoints, interfaceClass, interfaceSubClass, interfaceProtocol; UInt8 endpoint; //* Now open the interface. This will cause the pipes associated with //* the endpoints in the interface descriptor to be instantiated kr = (*interface)->USBInterfaceOpen(interface); if (kr != kIOReturnSuccess) { LOG(ERROR) << "Could not open interface: " << std::hex << kr; return NULL; } //* Get the number of endpoints associated with this interface kr = (*interface)->GetNumEndpoints(interface, &interfaceNumEndpoints); if (kr != kIOReturnSuccess) { LOG(ERROR) << "Unable to get number of endpoints: " << std::hex << kr; goto err_get_num_ep; } //* Get interface class, subclass and protocol if ((*interface)->GetInterfaceClass(interface, &interfaceClass) != kIOReturnSuccess || (*interface)->GetInterfaceSubClass(interface, &interfaceSubClass) != kIOReturnSuccess || (*interface)->GetInterfaceProtocol(interface, &interfaceProtocol) != kIOReturnSuccess) { LOG(ERROR) << "Unable to get interface class, subclass and protocol"; goto err_get_interface_class; } //* check to make sure interface class, subclass and protocol match ADB //* avoid opening mass storage endpoints if (!is_adb_interface(vendor, product, interfaceClass, interfaceSubClass, interfaceProtocol)) { goto err_bad_adb_interface; } handle.reset(new usb_handle); if (handle == nullptr) { goto err_bad_adb_interface; } //* Iterate over the endpoints for this interface and find the first //* bulk in/out pipes available. These will be our read/write pipes. for (endpoint = 1; endpoint <= interfaceNumEndpoints; endpoint++) { UInt8 transferType; UInt16 maxPacketSize; UInt8 interval; UInt8 number; UInt8 direction; kr = (*interface)->GetPipeProperties(interface, endpoint, &direction, &number, &transferType, &maxPacketSize, &interval); if (kr != kIOReturnSuccess) { LOG(ERROR) << "FindDeviceInterface - could not get pipe properties: " << std::hex << kr; goto err_get_pipe_props; } if (kUSBBulk != transferType) continue; if (kUSBIn == direction) { handle->bulkIn = endpoint; if (!ClearPipeStallBothEnds(interface, handle->bulkIn)) goto err_get_pipe_props; } if (kUSBOut == direction) { handle->bulkOut = endpoint; if (!ClearPipeStallBothEnds(interface, handle->bulkOut)) goto err_get_pipe_props; } handle->zero_mask = maxPacketSize - 1; } handle->interface = interface; return handle; err_get_pipe_props: err_bad_adb_interface: err_get_interface_class: err_get_num_ep: (*interface)->USBInterfaceClose(interface); return nullptr; } std::mutex& operate_device_lock = *new std::mutex(); static void RunLoopThread(void* unused) { adb_thread_setname("RunLoop"); VLOG(USB) << "RunLoopThread started"; while (true) { { std::lock_guard lock_guard(operate_device_lock); FindUSBDevices(); KickDisconnectedDevices(); } // Signal the parent that we are running usb_inited_flag = true; adb_sleep_ms(1000); } VLOG(USB) << "RunLoopThread done"; } static void usb_cleanup() { VLOG(USB) << "usb_cleanup"; // Wait until usb operations in RunLoopThread finish, and prevent further operations. operate_device_lock.lock(); close_usb_devices(); } void usb_init() { static bool initialized = false; if (!initialized) { atexit(usb_cleanup); usb_inited_flag = false; if (!adb_thread_create(RunLoopThread, nullptr)) { fatal_errno("cannot create RunLoop thread"); } // Wait for initialization to finish while (!usb_inited_flag) { adb_sleep_ms(100); } initialized = true; } } int usb_write(usb_handle *handle, const void *buf, int len) { IOReturn result; if (!len) return 0; if (!handle || handle->dead) return -1; if (NULL == handle->interface) { LOG(ERROR) << "usb_write interface was null"; return -1; } if (0 == handle->bulkOut) { LOG(ERROR) << "bulkOut endpoint not assigned"; return -1; } result = (*handle->interface)->WritePipe(handle->interface, handle->bulkOut, (void *)buf, len); if ((result == 0) && (handle->zero_mask)) { /* we need 0-markers and our transfer */ if(!(len & handle->zero_mask)) { result = (*handle->interface)->WritePipe( handle->interface, handle->bulkOut, (void *)buf, 0); } } if (0 == result) return 0; LOG(ERROR) << "usb_write failed with status: " << std::hex << result; return -1; } int usb_read(usb_handle *handle, void *buf, int len) { IOReturn result; UInt32 numBytes = len; if (!len) { return 0; } if (!handle || handle->dead) { return -1; } if (NULL == handle->interface) { LOG(ERROR) << "usb_read interface was null"; return -1; } if (0 == handle->bulkIn) { LOG(ERROR) << "bulkIn endpoint not assigned"; return -1; } result = (*handle->interface)->ReadPipe(handle->interface, handle->bulkIn, buf, &numBytes); if (kIOUSBPipeStalled == result) { LOG(ERROR) << "Pipe stalled, clearing stall.\n"; (*handle->interface)->ClearPipeStall(handle->interface, handle->bulkIn); result = (*handle->interface)->ReadPipe(handle->interface, handle->bulkIn, buf, &numBytes); } if (kIOReturnSuccess == result) return 0; else { LOG(ERROR) << "usb_read failed with status: " << std::hex << result; } return -1; } int usb_close(usb_handle *handle) { std::lock_guard lock(g_usb_handles_mutex); for (auto it = g_usb_handles.begin(); it != g_usb_handles.end(); ++it) { if ((*it).get() == handle) { g_usb_handles.erase(it); break; } } return 0; } static void usb_kick_locked(usb_handle *handle) { LOG(INFO) << "Kicking handle"; /* release the interface */ if (!handle) return; if (!handle->dead) { handle->dead = true; (*handle->interface)->USBInterfaceClose(handle->interface); (*handle->interface)->Release(handle->interface); } } void usb_kick(usb_handle *handle) { // Use the lock to avoid multiple thread kicking the device at the same time. std::lock_guard lock_guard(g_usb_handles_mutex); usb_kick_locked(handle); } adb/usb_windows.cpp0100644 0000000 0000000 00000047367 12767234553 013441 0ustar000000000 0000000 /* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #define TRACE_TAG USB #include "sysdeps.h" #include // winsock.h *must* be included before windows.h. #include #include #include #include #include #include #include #include #include "adb.h" #include "transport.h" /** Structure usb_handle describes our connection to the usb device via AdbWinApi.dll. This structure is returned from usb_open() routine and is expected in each subsequent call that is accessing the device. Most members are protected by usb_lock, except for adb_{read,write}_pipe which rely on AdbWinApi.dll's handle validation and AdbCloseHandle(endpoint)'s ability to break a thread out of pipe IO. */ struct usb_handle { /// Previous entry in the list of opened usb handles usb_handle *prev; /// Next entry in the list of opened usb handles usb_handle *next; /// Handle to USB interface ADBAPIHANDLE adb_interface; /// Handle to USB read pipe (endpoint) ADBAPIHANDLE adb_read_pipe; /// Handle to USB write pipe (endpoint) ADBAPIHANDLE adb_write_pipe; /// Interface name wchar_t* interface_name; /// Mask for determining when to use zero length packets unsigned zero_mask; }; /// Class ID assigned to the device by androidusb.sys static const GUID usb_class_id = ANDROID_USB_CLASS_ID; /// List of opened usb handles static usb_handle handle_list = { .prev = &handle_list, .next = &handle_list, }; /// Locker for the list of opened usb handles ADB_MUTEX_DEFINE( usb_lock ); /// Checks if there is opened usb handle in handle_list for this device. int known_device(const wchar_t* dev_name); /// Checks if there is opened usb handle in handle_list for this device. /// usb_lock mutex must be held before calling this routine. int known_device_locked(const wchar_t* dev_name); /// Registers opened usb handle (adds it to handle_list). int register_new_device(usb_handle* handle); /// Checks if interface (device) matches certain criteria int recognized_device(usb_handle* handle); /// Enumerates present and available interfaces (devices), opens new ones and /// registers usb transport for them. void find_devices(); /// Kicks all USB devices static void kick_devices(); /// Entry point for thread that polls (every second) for new usb interfaces. /// This routine calls find_devices in infinite loop. static void device_poll_thread(void*); /// Initializes this module void usb_init(); /// Opens usb interface (device) by interface (device) name. usb_handle* do_usb_open(const wchar_t* interface_name); /// Writes data to the opened usb handle int usb_write(usb_handle* handle, const void* data, int len); /// Reads data using the opened usb handle int usb_read(usb_handle *handle, void* data, int len); /// Cleans up opened usb handle void usb_cleanup_handle(usb_handle* handle); /// Cleans up (but don't close) opened usb handle void usb_kick(usb_handle* handle); /// Closes opened usb handle int usb_close(usb_handle* handle); int known_device_locked(const wchar_t* dev_name) { usb_handle* usb; if (NULL != dev_name) { // Iterate through the list looking for the name match. for(usb = handle_list.next; usb != &handle_list; usb = usb->next) { // In Windows names are not case sensetive! if((NULL != usb->interface_name) && (0 == wcsicmp(usb->interface_name, dev_name))) { return 1; } } } return 0; } int known_device(const wchar_t* dev_name) { int ret = 0; if (NULL != dev_name) { adb_mutex_lock(&usb_lock); ret = known_device_locked(dev_name); adb_mutex_unlock(&usb_lock); } return ret; } int register_new_device(usb_handle* handle) { if (NULL == handle) return 0; adb_mutex_lock(&usb_lock); // Check if device is already in the list if (known_device_locked(handle->interface_name)) { adb_mutex_unlock(&usb_lock); return 0; } // Not in the list. Add this handle to the list. handle->next = &handle_list; handle->prev = handle_list.prev; handle->prev->next = handle; handle->next->prev = handle; adb_mutex_unlock(&usb_lock); return 1; } void device_poll_thread(void*) { adb_thread_setname("Device Poll"); D("Created device thread"); while(1) { find_devices(); adb_sleep_ms(1000); } } static LRESULT CALLBACK _power_window_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) { switch (uMsg) { case WM_POWERBROADCAST: switch (wParam) { case PBT_APMRESUMEAUTOMATIC: // Resuming from sleep or hibernation, so kick all existing USB devices // and then allow the device_poll_thread to redetect USB devices from // scratch. If we don't do this, existing USB devices will never respond // to us because they'll be waiting for the connect/auth handshake. D("Received (WM_POWERBROADCAST, PBT_APMRESUMEAUTOMATIC) notification, " "so kicking all USB devices\n"); kick_devices(); return TRUE; } } return DefWindowProcW(hwnd, uMsg, wParam, lParam); } static void _power_notification_thread(void*) { // This uses a thread with its own window message pump to get power // notifications. If adb runs from a non-interactive service account, this // might not work (not sure). If that happens to not work, we could use // heavyweight WMI APIs to get power notifications. But for the common case // of a developer's interactive session, a window message pump is more // appropriate. D("Created power notification thread"); adb_thread_setname("Power Notifier"); // Window class names are process specific. static const WCHAR kPowerNotificationWindowClassName[] = L"PowerNotificationWindow"; // Get the HINSTANCE corresponding to the module that _power_window_proc // is in (the main module). const HINSTANCE instance = GetModuleHandleW(NULL); if (!instance) { // This is such a common API call that this should never fail. fatal("GetModuleHandleW failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); } WNDCLASSEXW wndclass; memset(&wndclass, 0, sizeof(wndclass)); wndclass.cbSize = sizeof(wndclass); wndclass.lpfnWndProc = _power_window_proc; wndclass.hInstance = instance; wndclass.lpszClassName = kPowerNotificationWindowClassName; if (!RegisterClassExW(&wndclass)) { fatal("RegisterClassExW failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); } if (!CreateWindowExW(WS_EX_NOACTIVATE, kPowerNotificationWindowClassName, L"ADB Power Notification Window", WS_POPUP, 0, 0, 0, 0, NULL, NULL, instance, NULL)) { fatal("CreateWindowExW failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); } MSG msg; while (GetMessageW(&msg, NULL, 0, 0)) { TranslateMessage(&msg); DispatchMessageW(&msg); } // GetMessageW() will return false if a quit message is posted. We don't // do that, but it might be possible for that to occur when logging off or // shutting down. Not a big deal since the whole process will be going away // soon anyway. D("Power notification thread exiting"); } void usb_init() { if (!adb_thread_create(device_poll_thread, nullptr)) { fatal_errno("cannot create device poll thread"); } if (!adb_thread_create(_power_notification_thread, nullptr)) { fatal_errno("cannot create power notification thread"); } } usb_handle* do_usb_open(const wchar_t* interface_name) { unsigned long name_len = 0; // Allocate our handle usb_handle* ret = (usb_handle*)calloc(1, sizeof(usb_handle)); if (NULL == ret) { D("Could not allocate %u bytes for usb_handle: %s", sizeof(usb_handle), strerror(errno)); goto fail; } // Set linkers back to the handle ret->next = ret; ret->prev = ret; // Create interface. ret->adb_interface = AdbCreateInterfaceByName(interface_name); if (NULL == ret->adb_interface) { D("AdbCreateInterfaceByName failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); goto fail; } // Open read pipe (endpoint) ret->adb_read_pipe = AdbOpenDefaultBulkReadEndpoint(ret->adb_interface, AdbOpenAccessTypeReadWrite, AdbOpenSharingModeReadWrite); if (NULL == ret->adb_read_pipe) { D("AdbOpenDefaultBulkReadEndpoint failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); goto fail; } // Open write pipe (endpoint) ret->adb_write_pipe = AdbOpenDefaultBulkWriteEndpoint(ret->adb_interface, AdbOpenAccessTypeReadWrite, AdbOpenSharingModeReadWrite); if (NULL == ret->adb_write_pipe) { D("AdbOpenDefaultBulkWriteEndpoint failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); goto fail; } // Save interface name // First get expected name length AdbGetInterfaceName(ret->adb_interface, NULL, &name_len, false); if (0 == name_len) { D("AdbGetInterfaceName returned name length of zero: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); goto fail; } ret->interface_name = (wchar_t*)malloc(name_len * sizeof(ret->interface_name[0])); if (NULL == ret->interface_name) { D("Could not allocate %lu characters for interface_name: %s", name_len, strerror(errno)); goto fail; } // Now save the name if (!AdbGetInterfaceName(ret->adb_interface, ret->interface_name, &name_len, false)) { D("AdbGetInterfaceName failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); goto fail; } // We're done at this point return ret; fail: if (NULL != ret) { usb_cleanup_handle(ret); free(ret); } return NULL; } int usb_write(usb_handle* handle, const void* data, int len) { unsigned long time_out = 5000; unsigned long written = 0; int err = 0; D("usb_write %d", len); if (NULL == handle) { D("usb_write was passed NULL handle"); err = EINVAL; goto fail; } // Perform write if (!AdbWriteEndpointSync(handle->adb_write_pipe, (void*)data, (unsigned long)len, &written, time_out)) { D("AdbWriteEndpointSync failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); err = EIO; goto fail; } // Make sure that we've written what we were asked to write D("usb_write got: %ld, expected: %d", written, len); if (written != (unsigned long)len) { // If this occurs, this code should be changed to repeatedly call // AdbWriteEndpointSync() until all bytes are written. D("AdbWriteEndpointSync was supposed to write %d, but only wrote %ld", len, written); err = EIO; goto fail; } if (handle->zero_mask && (len & handle->zero_mask) == 0) { // Send a zero length packet if (!AdbWriteEndpointSync(handle->adb_write_pipe, (void*)data, 0, &written, time_out)) { D("AdbWriteEndpointSync of zero length packet failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); err = EIO; goto fail; } } return 0; fail: // Any failure should cause us to kick the device instead of leaving it a // zombie state with potential to hang. if (NULL != handle) { D("Kicking device due to error in usb_write"); usb_kick(handle); } D("usb_write failed"); errno = err; return -1; } int usb_read(usb_handle *handle, void* data, int len) { unsigned long time_out = 0; unsigned long read = 0; int err = 0; D("usb_read %d", len); if (NULL == handle) { D("usb_read was passed NULL handle"); err = EINVAL; goto fail; } while (len > 0) { if (!AdbReadEndpointSync(handle->adb_read_pipe, data, len, &read, time_out)) { D("AdbReadEndpointSync failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); err = EIO; goto fail; } D("usb_read got: %ld, expected: %d", read, len); data = (char *)data + read; len -= read; } return 0; fail: // Any failure should cause us to kick the device instead of leaving it a // zombie state with potential to hang. if (NULL != handle) { D("Kicking device due to error in usb_read"); usb_kick(handle); } D("usb_read failed"); errno = err; return -1; } // Wrapper around AdbCloseHandle() that logs diagnostics. static void _adb_close_handle(ADBAPIHANDLE adb_handle) { if (!AdbCloseHandle(adb_handle)) { D("AdbCloseHandle(%p) failed: %s", adb_handle, android::base::SystemErrorCodeToString(GetLastError()).c_str()); } } void usb_cleanup_handle(usb_handle* handle) { D("usb_cleanup_handle"); if (NULL != handle) { if (NULL != handle->interface_name) free(handle->interface_name); // AdbCloseHandle(pipe) will break any threads out of pending IO calls and // wait until the pipe no longer uses the interface. Then we can // AdbCloseHandle() the interface. if (NULL != handle->adb_write_pipe) _adb_close_handle(handle->adb_write_pipe); if (NULL != handle->adb_read_pipe) _adb_close_handle(handle->adb_read_pipe); if (NULL != handle->adb_interface) _adb_close_handle(handle->adb_interface); handle->interface_name = NULL; handle->adb_write_pipe = NULL; handle->adb_read_pipe = NULL; handle->adb_interface = NULL; } } static void usb_kick_locked(usb_handle* handle) { // The reason the lock must be acquired before calling this function is in // case multiple threads are trying to kick the same device at the same time. usb_cleanup_handle(handle); } void usb_kick(usb_handle* handle) { D("usb_kick"); if (NULL != handle) { adb_mutex_lock(&usb_lock); usb_kick_locked(handle); adb_mutex_unlock(&usb_lock); } else { errno = EINVAL; } } int usb_close(usb_handle* handle) { D("usb_close"); if (NULL != handle) { // Remove handle from the list adb_mutex_lock(&usb_lock); if ((handle->next != handle) && (handle->prev != handle)) { handle->next->prev = handle->prev; handle->prev->next = handle->next; handle->prev = handle; handle->next = handle; } adb_mutex_unlock(&usb_lock); // Cleanup handle usb_cleanup_handle(handle); free(handle); } return 0; } int recognized_device(usb_handle* handle) { if (NULL == handle) return 0; // Check vendor and product id first USB_DEVICE_DESCRIPTOR device_desc; if (!AdbGetUsbDeviceDescriptor(handle->adb_interface, &device_desc)) { D("AdbGetUsbDeviceDescriptor failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); return 0; } // Then check interface properties USB_INTERFACE_DESCRIPTOR interf_desc; if (!AdbGetUsbInterfaceDescriptor(handle->adb_interface, &interf_desc)) { D("AdbGetUsbInterfaceDescriptor failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); return 0; } // Must have two endpoints if (2 != interf_desc.bNumEndpoints) { return 0; } if (is_adb_interface(device_desc.idVendor, device_desc.idProduct, interf_desc.bInterfaceClass, interf_desc.bInterfaceSubClass, interf_desc.bInterfaceProtocol)) { if(interf_desc.bInterfaceProtocol == 0x01) { AdbEndpointInformation endpoint_info; // assuming zero is a valid bulk endpoint ID if (AdbGetEndpointInformation(handle->adb_interface, 0, &endpoint_info)) { handle->zero_mask = endpoint_info.max_packet_size - 1; D("device zero_mask: 0x%x", handle->zero_mask); } else { D("AdbGetEndpointInformation failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); } } return 1; } return 0; } void find_devices() { usb_handle* handle = NULL; char entry_buffer[2048]; AdbInterfaceInfo* next_interface = (AdbInterfaceInfo*)(&entry_buffer[0]); unsigned long entry_buffer_size = sizeof(entry_buffer); // Enumerate all present and active interfaces. ADBAPIHANDLE enum_handle = AdbEnumInterfaces(usb_class_id, true, true, true); if (NULL == enum_handle) { D("AdbEnumInterfaces failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); return; } while (AdbNextInterface(enum_handle, next_interface, &entry_buffer_size)) { // Lets see if we already have this device in the list if (!known_device(next_interface->device_name)) { // This seems to be a new device. Open it! handle = do_usb_open(next_interface->device_name); if (NULL != handle) { // Lets see if this interface (device) belongs to us if (recognized_device(handle)) { D("adding a new device %ls", next_interface->device_name); // We don't request a wchar_t string from AdbGetSerialNumber() because of a bug in // adb_winusb_interface.cpp:CopyMemory(buffer, ser_num->bString, bytes_written) where the // last parameter should be (str_len * sizeof(wchar_t)). The bug reads 2 bytes past the // end of a stack buffer in the best case, and in the unlikely case of a long serial // number, it will read 2 bytes past the end of a heap allocation. This doesn't affect the // resulting string, but we should avoid the bad reads in the first place. char serial_number[512]; unsigned long serial_number_len = sizeof(serial_number); if (AdbGetSerialNumber(handle->adb_interface, serial_number, &serial_number_len, true)) { // Lets make sure that we don't duplicate this device if (register_new_device(handle)) { register_usb_transport(handle, serial_number, NULL, 1); } else { D("register_new_device failed for %ls", next_interface->device_name); usb_cleanup_handle(handle); free(handle); } } else { D("cannot get serial number: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); usb_cleanup_handle(handle); free(handle); } } else { usb_cleanup_handle(handle); free(handle); } } } entry_buffer_size = sizeof(entry_buffer); } if (GetLastError() != ERROR_NO_MORE_ITEMS) { // Only ERROR_NO_MORE_ITEMS is expected at the end of enumeration. D("AdbNextInterface failed: %s", android::base::SystemErrorCodeToString(GetLastError()).c_str()); } _adb_close_handle(enum_handle); } static void kick_devices() { // Need to acquire lock to safely walk the list which might be modified // by another thread. adb_mutex_lock(&usb_lock); for (usb_handle* usb = handle_list.next; usb != &handle_list; usb = usb->next) { usb_kick_locked(usb); } adb_mutex_unlock(&usb_lock); } adf/0040755 0000000 0000000 00000000000 12767234553 010360 5ustar000000000 0000000 adf/Android.mk0100644 0000000 0000000 00000001251 12767234553 012265 0ustar000000000 0000000 # # Copyright (C) 2013 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # LOCAL_PATH := $(my-dir) include $(call first-makefiles-under,$(LOCAL_PATH)) adf/libadf/0040755 0000000 0000000 00000000000 12767234553 011601 5ustar000000000 0000000 adf/libadf/Android.mk0100644 0000000 0000000 00000001572 12767234553 013514 0ustar000000000 0000000 # Copyright (C) 2013 The Android Open Source Project # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. LOCAL_PATH:= $(call my-dir) include $(CLEAR_VARS) LOCAL_SRC_FILES := adf.c LOCAL_MODULE := libadf LOCAL_MODULE_TAGS := optional LOCAL_CFLAGS += -Werror LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include LOCAL_C_INCLUDES += $(LOCAL_EXPORT_C_INCLUDE_DIRS) include $(BUILD_STATIC_LIBRARY) adf/libadf/adf.c0100644 0000000 0000000 00000045556 12767234553 012513 0ustar000000000 0000000 /* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include #include #include #include #include #include #include #include #include #include #include #define ADF_BASE_PATH "/dev/" static ssize_t adf_find_nodes(const char *pattern, adf_id_t **ids) { DIR *dir; struct dirent *dirent; size_t n = 0; ssize_t ret; adf_id_t *ids_ret = NULL; dir = opendir(ADF_BASE_PATH); if (!dir) return -errno; errno = 0; while ((dirent = readdir(dir))) { adf_id_t id; int matched = sscanf(dirent->d_name, pattern, &id); if (matched < 0) { ret = -errno; goto done; } else if (matched != 1) { continue; } adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0])); if (!new_ids) { ret = -ENOMEM; goto done; } ids_ret = new_ids; ids_ret[n] = id; n++; } if (errno) ret = -errno; else ret = n; done: closedir(dir); if (ret < 0) free(ids_ret); else *ids = ids_ret; return ret; } ssize_t adf_devices(adf_id_t **ids) { return adf_find_nodes("adf%u", ids); } int adf_device_open(adf_id_t id, int flags, struct adf_device *dev) { char filename[64]; dev->id = id; snprintf(filename, sizeof(filename), ADF_BASE_PATH "adf%u", id); dev->fd = open(filename, flags); if (dev->fd < 0) return -errno; return 0; } void adf_device_close(struct adf_device *dev) { if (dev->fd >= 0) close(dev->fd); } int adf_get_device_data(struct adf_device *dev, struct adf_device_data *data) { int err; int ret = 0; memset(data, 0, sizeof(*data)); err = ioctl(dev->fd, ADF_GET_DEVICE_DATA, data); if (err < 0) return -ENOMEM; if (data->n_attachments) { data->attachments = malloc(sizeof(data->attachments[0]) * data->n_attachments); if (!data->attachments) return -ENOMEM; } if (data->n_allowed_attachments) { data->allowed_attachments = malloc(sizeof(data->allowed_attachments[0]) * data->n_allowed_attachments); if (!data->allowed_attachments) { ret = -ENOMEM; goto done; } } if (data->custom_data_size) { data->custom_data = malloc(data->custom_data_size); if (!data->custom_data) { ret = -ENOMEM; goto done; } } err = ioctl(dev->fd, ADF_GET_DEVICE_DATA, data); if (err < 0) ret = -errno; done: if (ret < 0) adf_free_device_data(data); return ret; } void adf_free_device_data(struct adf_device_data *data) { free(data->attachments); free(data->allowed_attachments); free(data->custom_data); } int adf_device_post(struct adf_device *dev, adf_id_t *interfaces, size_t n_interfaces, struct adf_buffer_config *bufs, size_t n_bufs, void *custom_data, size_t custom_data_size) { int err; struct adf_post_config data; memset(&data, 0, sizeof(data)); data.interfaces = interfaces; data.n_interfaces = n_interfaces; data.bufs = bufs; data.n_bufs = n_bufs; data.custom_data = custom_data; data.custom_data_size = custom_data_size; err = ioctl(dev->fd, ADF_POST_CONFIG, &data); if (err < 0) return -errno; return (int)data.complete_fence; } static int adf_device_attachment(struct adf_device *dev, adf_id_t overlay_engine, adf_id_t interface, bool attach) { int err; struct adf_attachment_config data; memset(&data, 0, sizeof(data)); data.overlay_engine = overlay_engine; data.interface = interface; err = ioctl(dev->fd, attach ? ADF_ATTACH : ADF_DETACH, &data); if (err < 0) return -errno; return 0; } int adf_device_attach(struct adf_device *dev, adf_id_t overlay_engine, adf_id_t interface) { return adf_device_attachment(dev, overlay_engine, interface, true); } int adf_device_detach(struct adf_device *dev, adf_id_t overlay_engine, adf_id_t interface) { return adf_device_attachment(dev, overlay_engine, interface, false); } ssize_t adf_interfaces(struct adf_device *dev, adf_id_t **interfaces) { char pattern[64]; snprintf(pattern, sizeof(pattern), "adf-interface%u.%%u", dev->id); return adf_find_nodes(pattern, interfaces); } ssize_t adf_interfaces_for_overlay_engine(struct adf_device *dev, adf_id_t overlay_engine, adf_id_t **interfaces) { struct adf_device_data data; ssize_t n = 0; ssize_t ret; adf_id_t *ids_ret = NULL; ret = adf_get_device_data(dev, &data); if (ret < 0) return ret; size_t i; for (i = 0; i < data.n_allowed_attachments; i++) { if (data.allowed_attachments[i].overlay_engine != overlay_engine) continue; adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0])); if (!new_ids) { ret = -ENOMEM; goto done; } ids_ret = new_ids; ids_ret[n] = data.allowed_attachments[i].interface; n++; } ret = n; done: adf_free_device_data(&data); if (ret < 0) free(ids_ret); else *interfaces = ids_ret; return ret; } static ssize_t adf_interfaces_filter(struct adf_device *dev, adf_id_t *in, size_t n_in, adf_id_t **out, bool (*filter)(struct adf_interface_data *data, __u32 match), __u32 match) { size_t n = 0; ssize_t ret; adf_id_t *ids_ret = NULL; size_t i; for (i = 0; i < n_in; i++) { int fd = adf_interface_open(dev, in[i], O_RDONLY); if (fd < 0) { ret = fd; goto done; } struct adf_interface_data data; ret = adf_get_interface_data(fd, &data); close(fd); if (ret < 0) goto done; if (!filter(&data, match)) continue; adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0])); if (!new_ids) { ret = -ENOMEM; goto done; } ids_ret = new_ids; ids_ret[n] = in[i]; n++; } ret = n; done: if (ret < 0) free(ids_ret); else *out = ids_ret; return ret; } static bool adf_interface_type_filter(struct adf_interface_data *data, __u32 type) { return data->type == (enum adf_interface_type)type; } ssize_t adf_interfaces_filter_by_type(struct adf_device *dev, enum adf_interface_type type, adf_id_t *in, size_t n_in, adf_id_t **out) { return adf_interfaces_filter(dev, in, n_in, out, adf_interface_type_filter, type); } static bool adf_interface_flags_filter(struct adf_interface_data *data, __u32 flag) { return !!(data->flags & flag); } ssize_t adf_interfaces_filter_by_flag(struct adf_device *dev, __u32 flag, adf_id_t *in, size_t n_in, adf_id_t **out) { return adf_interfaces_filter(dev, in, n_in, out, adf_interface_flags_filter, flag); } int adf_interface_open(struct adf_device *dev, adf_id_t id, int flags) { char filename[64]; snprintf(filename, sizeof(filename), ADF_BASE_PATH "adf-interface%u.%u", dev->id, id); int fd = open(filename, flags); if (fd < 0) return -errno; return fd; } int adf_get_interface_data(int fd, struct adf_interface_data *data) { int err; int ret = 0; memset(data, 0, sizeof(*data)); err = ioctl(fd, ADF_GET_INTERFACE_DATA, data); if (err < 0) return -errno; if (data->n_available_modes) { data->available_modes = malloc(sizeof(data->available_modes[0]) * data->n_available_modes); if (!data->available_modes) return -ENOMEM; } if (data->custom_data_size) { data->custom_data = malloc(data->custom_data_size); if (!data->custom_data) { ret = -ENOMEM; goto done; } } err = ioctl(fd, ADF_GET_INTERFACE_DATA, data); if (err < 0) ret = -errno; done: if (ret < 0) adf_free_interface_data(data); return ret; } void adf_free_interface_data(struct adf_interface_data *data) { free(data->available_modes); free(data->custom_data); } int adf_interface_blank(int fd, __u8 mode) { int err = ioctl(fd, ADF_BLANK, mode); if (err < 0) return -errno; return 0; } int adf_interface_set_mode(int fd, struct drm_mode_modeinfo *mode) { int err = ioctl(fd, ADF_SET_MODE, mode); if (err < 0) return -errno; return 0; } int adf_interface_simple_buffer_alloc(int fd, __u32 w, __u32 h, __u32 format, __u32 *offset, __u32 *pitch) { int err; struct adf_simple_buffer_alloc data; memset(&data, 0, sizeof(data)); data.w = w; data.h = h; data.format = format; err = ioctl(fd, ADF_SIMPLE_BUFFER_ALLOC, &data); if (err < 0) return -errno; *offset = data.offset; *pitch = data.pitch; return (int)data.fd; } int adf_interface_simple_post(int fd, __u32 overlay_engine, __u32 w, __u32 h, __u32 format, int buf_fd, __u32 offset, __u32 pitch, int acquire_fence) { int ret; struct adf_simple_post_config data; memset(&data, 0, sizeof(data)); data.buf.overlay_engine = overlay_engine; data.buf.w = w; data.buf.h = h; data.buf.format = format; data.buf.fd[0] = buf_fd; data.buf.offset[0] = offset; data.buf.pitch[0] = pitch; data.buf.n_planes = 1; data.buf.acquire_fence = acquire_fence; ret = ioctl(fd, ADF_SIMPLE_POST_CONFIG, &data); if (ret < 0) return -errno; return (int)data.complete_fence; } ssize_t adf_overlay_engines(struct adf_device *dev, adf_id_t **overlay_engines) { char pattern[64]; snprintf(pattern, sizeof(pattern), "adf-overlay-engine%u.%%u", dev->id); return adf_find_nodes(pattern, overlay_engines); } ssize_t adf_overlay_engines_for_interface(struct adf_device *dev, adf_id_t interface, adf_id_t **overlay_engines) { struct adf_device_data data; ssize_t n = 0; ssize_t ret; adf_id_t *ids_ret = NULL; ret = adf_get_device_data(dev, &data); if (ret < 0) return ret; size_t i; for (i = 0; i < data.n_allowed_attachments; i++) { if (data.allowed_attachments[i].interface != interface) continue; adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0])); if (!new_ids) { ret = -ENOMEM; goto done; } ids_ret = new_ids; ids_ret[n] = data.allowed_attachments[i].overlay_engine; n++; } ret = n; done: adf_free_device_data(&data); if (ret < 0) free(ids_ret); else *overlay_engines = ids_ret; return ret; } static ssize_t adf_overlay_engines_filter(struct adf_device *dev, adf_id_t *in, size_t n_in, adf_id_t **out, bool (*filter)(struct adf_overlay_engine_data *data, void *cookie), void *cookie) { size_t n = 0; ssize_t ret; adf_id_t *ids_ret = NULL; size_t i; for (i = 0; i < n_in; i++) { int fd = adf_overlay_engine_open(dev, in[i], O_RDONLY); if (fd < 0) { ret = fd; goto done; } struct adf_overlay_engine_data data; ret = adf_get_overlay_engine_data(fd, &data); close(fd); if (ret < 0) goto done; if (!filter(&data, cookie)) continue; adf_id_t *new_ids = realloc(ids_ret, (n + 1) * sizeof(ids_ret[0])); if (!new_ids) { ret = -ENOMEM; goto done; } ids_ret = new_ids; ids_ret[n] = in[i]; n++; } ret = n; done: if (ret < 0) free(ids_ret); else *out = ids_ret; return ret; } struct format_filter_cookie { const __u32 *formats; size_t n_formats; }; static bool adf_overlay_engine_format_filter( struct adf_overlay_engine_data *data, void *cookie) { struct format_filter_cookie *c = cookie; size_t i; for (i = 0; i < data->n_supported_formats; i++) { size_t j; for (j = 0; j < c->n_formats; j++) if (data->supported_formats[i] == c->formats[j]) return true; } return false; } ssize_t adf_overlay_engines_filter_by_format(struct adf_device *dev, const __u32 *formats, size_t n_formats, adf_id_t *in, size_t n_in, adf_id_t **out) { struct format_filter_cookie cookie = { formats, n_formats }; return adf_overlay_engines_filter(dev, in, n_in, out, adf_overlay_engine_format_filter, &cookie); } int adf_overlay_engine_open(struct adf_device *dev, adf_id_t id, int flags) { char filename[64]; snprintf(filename, sizeof(filename), ADF_BASE_PATH "adf-overlay-engine%u.%u", dev->id, id); int fd = open(filename, flags); if (fd < 0) return -errno; return fd; } int adf_get_overlay_engine_data(int fd, struct adf_overlay_engine_data *data) { int err; int ret = 0; memset(data, 0, sizeof(*data)); err = ioctl(fd, ADF_GET_OVERLAY_ENGINE_DATA, data); if (err < 0) return -errno; if (data->n_supported_formats) { data->supported_formats = malloc(sizeof(data->supported_formats[0]) * data->n_supported_formats); if (!data->supported_formats) return -ENOMEM; } if (data->custom_data_size) { data->custom_data = malloc(data->custom_data_size); if (!data->custom_data) { ret = -ENOMEM; goto done; } } err = ioctl(fd, ADF_GET_OVERLAY_ENGINE_DATA, data); if (err < 0) ret = -errno; done: if (ret < 0) adf_free_overlay_engine_data(data); return ret; } void adf_free_overlay_engine_data(struct adf_overlay_engine_data *data) { free(data->supported_formats); free(data->custom_data); } bool adf_overlay_engine_supports_format(int fd, __u32 format) { struct adf_overlay_engine_data data; bool ret = false; size_t i; int err = adf_get_overlay_engine_data(fd, &data); if (err < 0) return false; for (i = 0; i < data.n_supported_formats; i++) { if (data.supported_formats[i] == format) { ret = true; break; } } adf_free_overlay_engine_data(&data); return ret; } int adf_set_event(int fd, enum adf_event_type type, bool enabled) { struct adf_set_event data; data.type = type; data.enabled = enabled; int err = ioctl(fd, ADF_SET_EVENT, &data); if (err < 0) return -errno; return 0; } int adf_read_event(int fd, struct adf_event **event) { struct adf_event header; struct { struct adf_event base; uint8_t data[0]; } *event_ret; size_t data_size; int ret = 0; int err = read(fd, &header, sizeof(header)); if (err < 0) return -errno; if ((size_t)err < sizeof(header)) return -EIO; if (header.length < sizeof(header)) return -EIO; event_ret = malloc(header.length); if (!event_ret) return -ENOMEM; data_size = header.length - sizeof(header); memcpy(event_ret, &header, sizeof(header)); ssize_t read_size = read(fd, &event_ret->data, data_size); if (read_size < 0) { ret = -errno; goto done; } if ((size_t)read_size < data_size) { ret = -EIO; goto done; } *event = &event_ret->base; done: if (ret < 0) free(event_ret); return ret; } void adf_format_str(__u32 format, char buf[ADF_FORMAT_STR_SIZE]) { buf[0] = format & 0xFF; buf[1] = (format >> 8) & 0xFF; buf[2] = (format >> 16) & 0xFF; buf[3] = (format >> 24) & 0xFF; buf[4] = '\0'; } static bool adf_find_simple_post_overlay_engine(struct adf_device *dev, const __u32 *formats, size_t n_formats, adf_id_t interface, adf_id_t *overlay_engine) { adf_id_t *engs; ssize_t n_engs = adf_overlay_engines_for_interface(dev, interface, &engs); if (n_engs <= 0) return false; adf_id_t *filtered_engs; ssize_t n_filtered_engs = adf_overlay_engines_filter_by_format(dev, formats, n_formats, engs, n_engs, &filtered_engs); free(engs); if (n_filtered_engs <= 0) return false; *overlay_engine = filtered_engs[0]; free(filtered_engs); return true; } static const __u32 any_rgb_format[] = { DRM_FORMAT_C8, DRM_FORMAT_RGB332, DRM_FORMAT_BGR233, DRM_FORMAT_XRGB1555, DRM_FORMAT_XBGR1555, DRM_FORMAT_RGBX5551, DRM_FORMAT_BGRX5551, DRM_FORMAT_ARGB1555, DRM_FORMAT_ABGR1555, DRM_FORMAT_RGBA5551, DRM_FORMAT_BGRA5551, DRM_FORMAT_RGB565, DRM_FORMAT_BGR565, DRM_FORMAT_RGB888, DRM_FORMAT_BGR888, DRM_FORMAT_XRGB8888, DRM_FORMAT_XBGR8888, DRM_FORMAT_RGBX8888, DRM_FORMAT_BGRX8888, DRM_FORMAT_XRGB2101010, DRM_FORMAT_XBGR2101010, DRM_FORMAT_RGBX1010102, DRM_FORMAT_BGRX1010102, DRM_FORMAT_ARGB2101010, DRM_FORMAT_ABGR2101010, DRM_FORMAT_RGBA1010102, DRM_FORMAT_BGRA1010102, DRM_FORMAT_ARGB8888, DRM_FORMAT_ABGR8888, DRM_FORMAT_RGBA8888, DRM_FORMAT_BGRA8888, }; int adf_find_simple_post_configuration(struct adf_device *dev, const __u32 *formats, size_t n_formats, adf_id_t *interface, adf_id_t *overlay_engine) { adf_id_t *intfs = NULL; ssize_t n_intfs = adf_interfaces(dev, &intfs); if (n_intfs < 0) return n_intfs; else if (!n_intfs) return -ENODEV; adf_id_t *primary_intfs; ssize_t n_primary_intfs = adf_interfaces_filter_by_flag(dev, ADF_INTF_FLAG_PRIMARY, intfs, n_intfs, &primary_intfs); free(intfs); if (n_primary_intfs < 0) return n_primary_intfs; else if (!n_primary_intfs) return -ENODEV; if (!formats) { formats = any_rgb_format; n_formats = sizeof(any_rgb_format) / sizeof(any_rgb_format[0]); } bool found = false; ssize_t i = 0; for (i = 0; i < n_primary_intfs; i++) { found = adf_find_simple_post_overlay_engine(dev, formats, n_formats, primary_intfs[i], overlay_engine); if (found) { *interface = primary_intfs[i]; break; } } free(primary_intfs); if (!found) return -ENODEV; return 0; } adf/libadf/include/0040755 0000000 0000000 00000000000 12767234553 013224 5ustar000000000 0000000 adf/libadf/include/adf/0040755 0000000 0000000 00000000000 12767234553 013756 5ustar000000000 0000000 adf/libadf/include/adf/adf.h0100644 0000000 0000000 00000017302 12767234553 014661 0ustar000000000 0000000 /* * Copyright (C) 2013 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifndef _LIBADF_ADF_H_ #define _LIBADF_ADF_H_ #include #include #include #include #include