From b7954d2a3c580003aadc589d2a5082a87ac5af0f Mon Sep 17 00:00:00 2001 From: Jenkins Date: Tue, 18 Sep 2012 13:31:47 +0900 Subject: [PATCH] Merge sources from S-Core's RSA git (release) Change-Id: Id3d9702ba6c2d0c88295dfb32b8d1eb85937dc60 --- AUTHORS | 4 + LICENSE | 204 ++ Makefile | 137 ++ Makefile.win | 48 + NOTICE | 1 + SdbWinApi.bat | 10 + ansicon/.gitignore | 3 + ansicon/ANSI-LLW.c | 22 + ansicon/ANSI.c | 1825 ++++++++++++++++++ ansicon/COPYING.MinGW-w64-runtime.txt | 240 +++ ansicon/G1.bat | 18 + ansicon/G1.txt | Bin 0 -> 404 bytes ansicon/ansi.rc | 42 + ansicon/ansicon.c | 686 +++++++ ansicon/ansicon.h | 47 + ansicon/ansicon.rc | 36 + ansicon/injdll32.c | 123 ++ ansicon/injdll64.c | 96 + ansicon/makefile | 82 + ansicon/makefile.vc | 88 + ansicon/proctype.c | 105 ++ ansicon/readme.txt | 439 +++++ ansicon/util.c | 128 ++ ansicon/version.h | 9 + ansicon/wow64.h | 88 + debian/changelog | 7 + debian/compat | 1 + debian/control | 10 + debian/rules | 44 + debian/sdbd.install | 3 + package/build.linux | 80 + package/build.macos-64 | 39 + package/build.windows | 55 + package/pkginfo.manifest | 38 + package/sdb-run.bat | 25 + package/sdb.install.darwin | 18 + package/sdb.install.linux | 18 + package/sdb.remove.darwin | 22 + package/sdb.remove.linux | 22 + package/sdb.remove.windows | 10 + package/usb-connection-for-ssh.install.linux | 8 + script/S06sdbd | 2 + script/sdbd | 39 + src/Android.mk | 154 ++ src/MODULE_LICENSE_APACHE2 | 0 src/NOTICE | 191 ++ src/OVERVIEW.TXT | 139 ++ src/SERVICES.TXT | 236 +++ src/TizenConfig.h | 336 ++++ src/clear_vars.mk | 107 ++ src/commandline.c | 1229 ++++++++++++ src/console.c | 45 + src/fdevent.c | 508 +++++ src/fdevent.h | 81 + src/file_sync_client.c | 1025 ++++++++++ src/file_sync_service.c | 412 ++++ src/file_sync_service.h | 87 + src/framebuffer_service.c | 106 ++ src/get_my_path_darwin.c | 30 + src/get_my_path_freebsd.c | 36 + src/get_my_path_linux.c | 33 + src/get_my_path_windows.c | 34 + src/jdwp_service.c | 709 +++++++ src/mutex_list.h | 14 + src/protocol.txt | 252 +++ src/remount_service.c | 111 ++ src/sdb.c | 1302 +++++++++++++ src/sdb.h | 431 +++++ src/sdb_client.c | 326 ++++ src/sdb_client.h | 53 + src/sdbwinapi/BUILDME.TXT | 19 + src/sdbwinapi/MAKEFILE | 22 + src/sdbwinapi/MAKEFILE.org | 22 + src/sdbwinapi/Resource.h | 34 + src/sdbwinapi/SOURCES | 96 + src/sdbwinapi/SdbWinApi.cpp | 112 ++ src/sdbwinapi/SdbWinApi.def | 18 + src/sdbwinapi/SdbWinApi.rc | 111 ++ src/sdbwinapi/sdb_api.cpp | 537 ++++++ src/sdbwinapi/sdb_api.h | 622 +++++++ src/sdbwinapi/sdb_api_instance.cpp | 47 + src/sdbwinapi/sdb_api_instance.h | 113 ++ src/sdbwinapi/sdb_api_legacy.h | 190 ++ src/sdbwinapi/sdb_api_private_defines.h | 114 ++ src/sdbwinapi/sdb_endpoint_object.cpp | 96 + src/sdbwinapi/sdb_endpoint_object.h | 222 +++ src/sdbwinapi/sdb_helper_routines.cpp | 276 +++ src/sdbwinapi/sdb_helper_routines.h | 137 ++ src/sdbwinapi/sdb_interface.cpp | 117 ++ src/sdbwinapi/sdb_interface.h | 203 ++ src/sdbwinapi/sdb_interface_enum.cpp | 103 + src/sdbwinapi/sdb_interface_enum.h | 98 + src/sdbwinapi/sdb_io_completion.cpp | 50 + src/sdbwinapi/sdb_io_completion.h | 133 ++ src/sdbwinapi/sdb_legacy_endpoint_object.cpp | 237 +++ src/sdbwinapi/sdb_legacy_endpoint_object.h | 142 ++ src/sdbwinapi/sdb_legacy_interface.cpp | 324 ++++ src/sdbwinapi/sdb_legacy_interface.h | 190 ++ src/sdbwinapi/sdb_legacy_io_completion.cpp | 90 + src/sdbwinapi/sdb_legacy_io_completion.h | 115 ++ src/sdbwinapi/sdb_object_handle.cpp | 167 ++ src/sdbwinapi/sdb_object_handle.h | 212 +++ src/sdbwinapi/sdb_winusb_api.h | 48 + src/sdbwinapi/stdafx.cpp | 21 + src/sdbwinapi/stdafx.h | 79 + src/sdbwinusbapi/BUILDME.TXT | 7 + src/sdbwinusbapi/MAKEFILE | 22 + src/sdbwinusbapi/Resource.h | 34 + src/sdbwinusbapi/SOURCES | 91 + src/sdbwinusbapi/SdbWinUsbApi.cpp | 62 + src/sdbwinusbapi/SdbWinUsbApi.def | 5 + src/sdbwinusbapi/SdbWinUsbApi.rc | 111 ++ src/sdbwinusbapi/sdb_winusb_endpoint_object.cpp | 169 ++ src/sdbwinusbapi/sdb_winusb_endpoint_object.h | 155 ++ src/sdbwinusbapi/sdb_winusb_interface.cpp | 340 ++++ src/sdbwinusbapi/sdb_winusb_interface.h | 205 ++ src/sdbwinusbapi/sdb_winusb_io_completion.cpp | 98 + src/sdbwinusbapi/sdb_winusb_io_completion.h | 118 ++ src/sdbwinusbapi/stdafx.cpp | 21 + src/sdbwinusbapi/stdafx.h | 78 + src/services.c | 503 +++++ src/socket_inaddr_any_server.c | 69 + src/socket_local.h | 39 + src/socket_local_client.c | 166 ++ src/socket_local_server.c | 124 ++ src/socket_loopback_client.c | 58 + src/socket_loopback_server.c | 135 ++ src/socket_network_client.c | 64 + src/sockets.c | 787 ++++++++ src/sockets.dia | Bin 0 -> 2333 bytes src/sockets.h | 100 + src/sysdeps.h | 479 +++++ src/sysdeps_win32.c | 1967 ++++++++++++++++++++ src/test_track_devices.c | 97 + src/test_track_jdwp.c | 97 + src/transport.c | 1104 +++++++++++ src/transport_local.c | 439 +++++ src/transport_usb.c | 149 ++ src/usb_libusb.c | 657 +++++++ src/usb_linux.c | 700 +++++++ src/usb_linux_client.c | 161 ++ src/usb_osx.c | 537 ++++++ src/usb_vendors.c | 201 ++ src/usb_vendors.h | 25 + src/usb_windows.c | 513 +++++ src/utils.c | 106 ++ src/utils.h | 68 + .../linux/data/tools/ssh/99-samsung-device.rules | 25 + .../packager/linux/data/tools/ssh/config_device.sh | 59 + 149 files changed, 28971 insertions(+) create mode 100644 AUTHORS create mode 100644 LICENSE create mode 100644 Makefile create mode 100644 Makefile.win create mode 100644 NOTICE create mode 100644 SdbWinApi.bat create mode 100755 ansicon/.gitignore create mode 100755 ansicon/ANSI-LLW.c create mode 100755 ansicon/ANSI.c create mode 100755 ansicon/COPYING.MinGW-w64-runtime.txt create mode 100755 ansicon/G1.bat create mode 100755 ansicon/G1.txt create mode 100755 ansicon/ansi.rc create mode 100755 ansicon/ansicon.c create mode 100755 ansicon/ansicon.h create mode 100755 ansicon/ansicon.rc create mode 100755 ansicon/injdll32.c create mode 100755 ansicon/injdll64.c create mode 100755 ansicon/makefile create mode 100755 ansicon/makefile.vc create mode 100755 ansicon/proctype.c create mode 100755 ansicon/readme.txt create mode 100755 ansicon/util.c create mode 100755 ansicon/version.h create mode 100755 ansicon/wow64.h create mode 100644 debian/changelog create mode 100644 debian/compat create mode 100644 debian/control create mode 100755 debian/rules create mode 100644 debian/sdbd.install create mode 100755 package/build.linux create mode 100755 package/build.macos-64 create mode 100644 package/build.windows create mode 100644 package/pkginfo.manifest create mode 100755 package/sdb-run.bat create mode 100755 package/sdb.install.darwin create mode 100755 package/sdb.install.linux create mode 100755 package/sdb.remove.darwin create mode 100755 package/sdb.remove.linux create mode 100644 package/sdb.remove.windows create mode 100755 package/usb-connection-for-ssh.install.linux create mode 100755 script/S06sdbd create mode 100755 script/sdbd create mode 100644 src/Android.mk create mode 100644 src/MODULE_LICENSE_APACHE2 create mode 100644 src/NOTICE create mode 100644 src/OVERVIEW.TXT create mode 100644 src/SERVICES.TXT create mode 100644 src/TizenConfig.h create mode 100644 src/clear_vars.mk create mode 100644 src/commandline.c create mode 100644 src/console.c create mode 100644 src/fdevent.c create mode 100644 src/fdevent.h create mode 100644 src/file_sync_client.c create mode 100644 src/file_sync_service.c create mode 100644 src/file_sync_service.h create mode 100644 src/framebuffer_service.c create mode 100644 src/get_my_path_darwin.c create mode 100644 src/get_my_path_freebsd.c create mode 100644 src/get_my_path_linux.c create mode 100644 src/get_my_path_windows.c create mode 100644 src/jdwp_service.c create mode 100644 src/mutex_list.h create mode 100644 src/protocol.txt create mode 100644 src/remount_service.c create mode 100644 src/sdb.c create mode 100644 src/sdb.h create mode 100644 src/sdb_client.c create mode 100644 src/sdb_client.h create mode 100644 src/sdbwinapi/BUILDME.TXT create mode 100644 src/sdbwinapi/MAKEFILE create mode 100644 src/sdbwinapi/MAKEFILE.org create mode 100644 src/sdbwinapi/Resource.h create mode 100644 src/sdbwinapi/SOURCES create mode 100644 src/sdbwinapi/SdbWinApi.cpp create mode 100644 src/sdbwinapi/SdbWinApi.def create mode 100644 src/sdbwinapi/SdbWinApi.rc create mode 100644 src/sdbwinapi/sdb_api.cpp create mode 100644 src/sdbwinapi/sdb_api.h create mode 100644 src/sdbwinapi/sdb_api_instance.cpp create mode 100644 src/sdbwinapi/sdb_api_instance.h create mode 100644 src/sdbwinapi/sdb_api_legacy.h create mode 100644 src/sdbwinapi/sdb_api_private_defines.h create mode 100644 src/sdbwinapi/sdb_endpoint_object.cpp create mode 100644 src/sdbwinapi/sdb_endpoint_object.h create mode 100644 src/sdbwinapi/sdb_helper_routines.cpp create mode 100644 src/sdbwinapi/sdb_helper_routines.h create mode 100644 src/sdbwinapi/sdb_interface.cpp create mode 100644 src/sdbwinapi/sdb_interface.h create mode 100644 src/sdbwinapi/sdb_interface_enum.cpp create mode 100644 src/sdbwinapi/sdb_interface_enum.h create mode 100644 src/sdbwinapi/sdb_io_completion.cpp create mode 100644 src/sdbwinapi/sdb_io_completion.h create mode 100644 src/sdbwinapi/sdb_legacy_endpoint_object.cpp create mode 100644 src/sdbwinapi/sdb_legacy_endpoint_object.h create mode 100644 src/sdbwinapi/sdb_legacy_interface.cpp create mode 100644 src/sdbwinapi/sdb_legacy_interface.h create mode 100644 src/sdbwinapi/sdb_legacy_io_completion.cpp create mode 100644 src/sdbwinapi/sdb_legacy_io_completion.h create mode 100644 src/sdbwinapi/sdb_object_handle.cpp create mode 100644 src/sdbwinapi/sdb_object_handle.h create mode 100644 src/sdbwinapi/sdb_winusb_api.h create mode 100644 src/sdbwinapi/stdafx.cpp create mode 100644 src/sdbwinapi/stdafx.h create mode 100644 src/sdbwinusbapi/BUILDME.TXT create mode 100644 src/sdbwinusbapi/MAKEFILE create mode 100644 src/sdbwinusbapi/Resource.h create mode 100644 src/sdbwinusbapi/SOURCES create mode 100644 src/sdbwinusbapi/SdbWinUsbApi.cpp create mode 100644 src/sdbwinusbapi/SdbWinUsbApi.def create mode 100644 src/sdbwinusbapi/SdbWinUsbApi.rc create mode 100644 src/sdbwinusbapi/sdb_winusb_endpoint_object.cpp create mode 100644 src/sdbwinusbapi/sdb_winusb_endpoint_object.h create mode 100644 src/sdbwinusbapi/sdb_winusb_interface.cpp create mode 100644 src/sdbwinusbapi/sdb_winusb_interface.h create mode 100644 src/sdbwinusbapi/sdb_winusb_io_completion.cpp create mode 100644 src/sdbwinusbapi/sdb_winusb_io_completion.h create mode 100644 src/sdbwinusbapi/stdafx.cpp create mode 100644 src/sdbwinusbapi/stdafx.h create mode 100644 src/services.c create mode 100644 src/socket_inaddr_any_server.c create mode 100644 src/socket_local.h create mode 100644 src/socket_local_client.c create mode 100644 src/socket_local_server.c create mode 100644 src/socket_loopback_client.c create mode 100644 src/socket_loopback_server.c create mode 100644 src/socket_network_client.c create mode 100644 src/sockets.c create mode 100644 src/sockets.dia create mode 100644 src/sockets.h create mode 100644 src/sysdeps.h create mode 100644 src/sysdeps_win32.c create mode 100644 src/test_track_devices.c create mode 100644 src/test_track_jdwp.c create mode 100644 src/transport.c create mode 100644 src/transport_local.c create mode 100644 src/transport_usb.c create mode 100644 src/usb_libusb.c create mode 100644 src/usb_linux.c create mode 100644 src/usb_linux_client.c create mode 100644 src/usb_osx.c create mode 100644 src/usb_vendors.c create mode 100644 src/usb_vendors.h create mode 100644 src/usb_windows.c create mode 100644 src/utils.c create mode 100644 src/utils.h create mode 100644 usb-connection-for-ssh/packager/linux/data/tools/ssh/99-samsung-device.rules create mode 100755 usb-connection-for-ssh/packager/linux/data/tools/ssh/config_device.sh diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 0000000..9e88574 --- /dev/null +++ b/AUTHORS @@ -0,0 +1,4 @@ +Kangho Kim +Ho Namkoong +Yoonki Park +HyunGoo Kang diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..a06208b --- /dev/null +++ b/LICENSE @@ -0,0 +1,204 @@ +Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. + + 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 + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + 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. + diff --git a/Makefile b/Makefile new file mode 100644 index 0000000..43f6483 --- /dev/null +++ b/Makefile @@ -0,0 +1,137 @@ +# +# Makefile for sdb +# + +HOST_OS := $(shell uname -s | tr A-Z a-z) + +# sdb host tool +# ========================================================= + +# Default to a virtual (sockets) usb interface +USB_SRCS := +EXTRA_SRCS := + +ifeq ($(HOST_OS),linux) + USB_SRCS := usb_linux.c + EXTRA_SRCS := get_my_path_linux.c + LOCAL_LDLIBS += -lrt -lncurses -lpthread +endif + +ifeq ($(HOST_OS),darwin) + USB_SRCS := usb_osx.c + EXTRA_SRCS := get_my_path_darwin.c + LOCAL_LDLIBS += -lpthread -framework CoreFoundation -framework IOKit -framework Carbon +endif + +ifeq ($(HOST_OS),freebsd) + USB_SRCS := usb_libusb.c + EXTRA_SRCS := get_my_path_freebsd.c + LOCAL_LDLIBS += -lpthread -lusb +endif + + + +SDB_SRC_FILES := \ + src/sdb.c \ + src/console.c \ + src/transport.c \ + src/transport_local.c \ + src/transport_usb.c \ + src/commandline.c \ + src/sdb_client.c \ + src/sockets.c \ + src/services.c \ + src/file_sync_client.c \ + src/$(EXTRA_SRCS) \ + src/$(USB_SRCS) \ + src/utils.c \ + src/usb_vendors.c \ + src/fdevent.c \ + src/socket_inaddr_any_server.c \ + src/socket_local_client.c \ + src/socket_local_server.c \ + src/socket_loopback_client.c \ + src/socket_loopback_server.c \ + src/socket_network_client.c + +SDB_CFLAGS := -O2 -g -DSDB_HOST=1 -Wall -Wno-unused-parameter +SDB_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE +SDB_CFLAGS += -DHAVE_FORKEXEC -DHAVE_TERMIO_H -DHAVE_SYMLINKS +SDB_LFLAGS := $(LOCAL_LDLIBS) + +SDBD_SRC_FILES := \ + src/sdb.c \ + src/fdevent.c \ + src/transport.c \ + src/transport_local.c \ + src/transport_usb.c \ + src/sockets.c \ + src/services.c \ + src/file_sync_service.c \ + src/jdwp_service.c \ + src/framebuffer_service.c \ + src/remount_service.c \ + src/usb_linux_client.c \ + src/utils.c \ + src/socket_inaddr_any_server.c \ + src/socket_local_client.c \ + src/socket_local_server.c \ + src/socket_loopback_client.c \ + src/socket_loopback_server.c \ + src/socket_network_client.c + +SDBD_CFLAGS := -O2 -g -DSDB_HOST=0 -Wall -Wno-unused-parameter +SDBD_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE +SDBD_CFLAGS += -DHAVE_FORKEXEC -fPIE + +IFLAGS := -Iinclude -Isrc +OBJDIR := bin +INSTALLDIR := usr/sbin +INITSCRIPTDIR := etc/init.d +RCSCRIPTDIR := etc/rc.d/rc3.d + +UNAME := $(shell uname -sm) +ifneq (,$(findstring 86,$(UNAME))) + HOST_ARCH := x86 +endif + +TARGET_ARCH = $(HOST_ARCH) +ifeq ($(TARGET_ARCH),) + TARGET_ARCH := arm +endif + +ifeq ($(TARGET_ARCH),arm) + MODULE := sdbd + SDBD_CFLAGS += -DANDROID_GADGET=1 +else +ifeq ($(TARGET_HOST),true) + MODULE := sdb +else + MODULE := sdbd +endif +endif + +all : $(MODULE) + +sdb : $(SDB_SRC_FILES) + mkdir -p $(OBJDIR) + $(CC) -pthread -o $(OBJDIR)/$(MODULE) $(SDB_CFLAGS) $(SDB_LFLAGS) $(IFLAGS) $(SDB_SRC_FILES) + +sdbd : $(SDBD_SRC_FILES) + mkdir -p $(OBJDIR) + $(CC) -pthread -o $(OBJDIR)/$(MODULE) $(SDBD_CFLAGS) $(IFLAGS) $(SDBD_SRC_FILES) + +install : + mkdir -p $(DESTDIR)/$(INSTALLDIR) + install $(OBJDIR)/$(MODULE) $(DESTDIR)/$(INSTALLDIR)/$(MODULE) +ifeq ($(MODULE),sdbd) + mkdir -p $(DESTDIR)/$(INITSCRIPTDIR) + install script/sdbd $(DESTDIR)/$(INITSCRIPTDIR)/sdbd +endif +ifeq ($(TARGET_ARCH),x86) + mkdir -p $(DESTDIR)/$(RCSCRIPTDIR) + install script/S06sdbd $(DESTDIR)/$(RCSCRIPTDIR)/S06sdbd +endif + +clean : + rm -rf $(OBJDIR)/* diff --git a/Makefile.win b/Makefile.win new file mode 100644 index 0000000..99de9ca --- /dev/null +++ b/Makefile.win @@ -0,0 +1,48 @@ +CC := gcc +SRC_FILES := \ + src/sdb.c \ + src/console.c \ + src/transport.c \ + src/transport_local.c \ + src/transport_usb.c \ + src/commandline.c \ + src/sdb_client.c \ + src/sockets.c \ + src/services.c \ + src/file_sync_client.c \ + src/get_my_path_windows.c \ + src/usb_windows.c \ + src/utils.c \ + src/usb_vendors.c \ + src/socket_local_client.c \ + src/sysdeps_win32.c +INCS := \ + -I/mingw/include/ddk \ + -Isrc/sdbwinapi \ + -Isrc + +DIRECT_INCS := \ + -include src/TizenConfig.h + +LIB_PATH := \ + -Lprebuilt + +LIBS := -lws2_32 \ + prebuilt/SdbWinApi.a + +CFLAGS := \ + -O2 -DSDB_HOST=1 -Wall -Wno-unused-parameter \ + -D_XOPEN_SOURCE -D_GNU_SOURCE + +OBJDIR := bin +PREBUILTDIR := prebuilt + +all : sdb + +sdb : $(SRC_FILES) + rm -rf $(OBJDIR) + mkdir $(OBJDIR) + $(CC) $(CFLAGS) $(INCS) -o $(OBJDIR)/$@ $(SRC_FILES) $(DIRECT_INCS) $(LIB_PATH) $(LIBS) + cp $(PREBUILTDIR)/SdbWinApi.dll $(OBJDIR) + cp $(PREBUILTDIR)/SdbWinUsbApi.dll $(OBJDIR) + diff --git a/NOTICE b/NOTICE new file mode 100644 index 0000000..4297ee3 --- /dev/null +++ b/NOTICE @@ -0,0 +1 @@ +Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved. diff --git a/SdbWinApi.bat b/SdbWinApi.bat new file mode 100644 index 0000000..3bc86c2 --- /dev/null +++ b/SdbWinApi.bat @@ -0,0 +1,10 @@ +md prebuilt +cd src\sdbwinapi +build -cbeEIFZ +copy objfre_win7_x86\i386\SdbWinApi.dll ..\..\prebuilt\ +copy SdbWinApi.def ..\..\prebuilt\ +cd ..\..\prebuilt +dlltool --def SdbWInApi.def --dllname SdbWinApi.dll --output-lib SdbWinApi.a +cd ..\src\sdbwinusbapi +build -cbeEIFZ +copy objfre_win7_x86\i386\SdbWinUsbApi.dll ..\..\prebuilt\ diff --git a/ansicon/.gitignore b/ansicon/.gitignore new file mode 100755 index 0000000..a45c74f --- /dev/null +++ b/ansicon/.gitignore @@ -0,0 +1,3 @@ +*.zip +/x86 +/x64 diff --git a/ansicon/ANSI-LLW.c b/ansicon/ANSI-LLW.c new file mode 100755 index 0000000..28991f0 --- /dev/null +++ b/ansicon/ANSI-LLW.c @@ -0,0 +1,22 @@ +/* + ANSI-LLW.c - Output the 32-bit address of LoadLibraryW. + + Jason Hood, 13 November, 2010 (LLA version 5 September, 2010). + + I don't know of a method to retrieve the 32-bit address of a function in + 64-bit code, so this is a simple workaround. + + 18 December, 2010: Initially I used GetProcAddress, but then I thought that + was silly, why don't I just return LoadLibraryW directly? That worked fine + for TDM64 and VC, but MinGW32 would return the address of the jump to the + function, not the function itself. Not so silly after all. +*/ + +#define WIN32_LEAN_AND_MEAN +#include + +int main( void ) +{ + return (DWORD)GetProcAddress( GetModuleHandle( "kernel32.dll" ), + "LoadLibraryW" ); +} diff --git a/ansicon/ANSI.c b/ansicon/ANSI.c new file mode 100755 index 0000000..3907252 --- /dev/null +++ b/ansicon/ANSI.c @@ -0,0 +1,1825 @@ +/* + ANSI.c - ANSI escape sequence console driver. + + Jason Hood, 21 & 22 October, 2005. + + Derived from ANSI.xs by Jean-Louis Morel, from his Perl package + Win32::Console::ANSI. I removed the codepage conversion ("\e(") and added + WriteConsole hooking. + + v1.01, 11 & 12 March, 2006: + disable when console has disabled processed output; + \e[5m (blink) is the same as \e[4m (underline); + do not conceal control characters (0 to 31); + \e[m will restore original color. + + v1.10, 22 February, 2009: + fix MyWriteConsoleW for strings longer than the buffer; + initialise attributes to current; + hook into child processes. + + v1.11, 28 February, 2009: + fix hooking into child processes (only do console executables). + + v1.12, 9 March, 2009: + really fix hooking (I didn't realise MinGW didn't generate relocations). + + v1.13, 21 & 27 March, 2009: + alternate injection method, to work with DEP; + use Unicode and the current output code page (not OEMCP). + + v1.14, 3 April, 2009: + fix test for empty import section. + + v1.15, 17 May, 2009: + properly update lpNumberOfCharsWritten in MyWriteConsoleA. + + v1.20, 26 & 29 May, 17 to 21 June, 2009: + create an ANSICON environment variable; + hook GetEnvironmentVariable to create ANSICON dynamically; + use another injection method. + + v1.22, 5 October, 2009: + hook LoadLibrary to intercept the newly loaded functions. + + v1.23, 11 November, 2009: + unload gracefully; + conceal characters by making foreground same as background; + reverse the bold/underline attributes, too. + + v1.25, 15, 20 & 21 July, 2010: + hook LoadLibraryEx (now cscript works); + Win7 support. + + v1.30, 3 August to 7 September, 2010: + x64 support. + + v1.31, 13 & 19 November, 2010: + fix multibyte conversion problems. + + v1.32, 4 to 22 December, 2010: + test for lpNumberOfCharsWritten/lpNumberOfBytesWritten being NULL; + recognise DSR and xterm window title; + ignore sequences starting with \e[? & \e[>; + close the handles opened by CreateProcess. + + v1.40, 25 & 26 February, 1 March, 2011: + hook GetProcAddress, addresses issues with .NET (work with PowerShell); + implement SO & SI to use the DEC Special Graphics Character Set (enables + line drawing via ASCII); ignore \e(X & \e)X (where X is any character); + add \e[?25h & \e[?25l to show/hide the cursor (DECTCEM). + + v1.50, 7 to 14 December, 2011: + added dynamic environment variable ANSICON_VER to return version; + read ANSICON_EXC environment variable to exclude selected modules; + read ANSICON_GUI environment variable to hook selected GUI programs; + read ANSICON_DEF environment variable to set the default GR; + transfer current GR to child, read it on exit. + + v1.51, 15 January, 5, 22 & 24 February, 2012: + added log mask 16 to log all the imported modules of imported modules; + ignore the version within the core API DLL names; + fix 32-bit process trying to identify 64-bit process; + hook _lwrite & _hwrite. + + v1.52, 10 April, 1 & 2 June, 2012: + use ansicon.exe to enable 32-bit to inject into 64-bit; + implement \e[39m & \e[49m (only setting color, nothing else); + added the character/line equivalents (keaj`) of the cursor movement + sequences (ABCDG), as well as vertical absolute (d) and erase characters + (X). + + v1.53, 12 June, 2012: + fixed Update_GRM when running multiple processes (e.g. "cl /MP"). +*/ + +#include "ansicon.h" +#include "version.h" +#include + +#define isdigit(c) ('0' <= (c) && (c) <= '9') + +#ifdef __GNUC__ +#define SHARED __attribute__((shared, section(".share"))) +#else +#pragma section(".shared", read,write,shared) +#define SHARED __declspec(allocate(".shared")) +#endif + + +// ========== Global variables and constants + +HANDLE hConOut; // handle to CONOUT$ + +#define ESC '\x1B' // ESCape character +#define BEL '\x07' +#define SO '\x0E' // Shift Out +#define SI '\x0F' // Shift In + +#define MAX_ARG 16 // max number of args in an escape sequence +int state; // automata state +TCHAR prefix; // escape sequence prefix ( '[', ']' or '(' ); +TCHAR prefix2; // secondary prefix ( '?' or '>' ); +TCHAR suffix; // escape sequence suffix +int es_argc; // escape sequence args count +int es_argv[MAX_ARG]; // escape sequence args +TCHAR Pt_arg[MAX_PATH*2]; // text parameter for Operating System Command +int Pt_len; +BOOL shifted; + + +// DEC Special Graphics Character Set from +// http://vt100.net/docs/vt220-rm/table2-4.html +// Some of these may not look right, depending on the font and code page (in +// particular, the Control Pictures probably won't work at all). +const WCHAR G1[] = +{ + ' ', // _ - blank + L'\x2666', // ` - Black Diamond Suit + L'\x2592', // a - Medium Shade + L'\x2409', // b - HT + L'\x240c', // c - FF + L'\x240d', // d - CR + L'\x240a', // e - LF + L'\x00b0', // f - Degree Sign + L'\x00b1', // g - Plus-Minus Sign + L'\x2424', // h - NL + L'\x240b', // i - VT + L'\x2518', // j - Box Drawings Light Up And Left + L'\x2510', // k - Box Drawings Light Down And Left + L'\x250c', // l - Box Drawings Light Down And Right + L'\x2514', // m - Box Drawings Light Up And Right + L'\x253c', // n - Box Drawings Light Vertical And Horizontal + L'\x00af', // o - SCAN 1 - Macron + L'\x25ac', // p - SCAN 3 - Black Rectangle + L'\x2500', // q - SCAN 5 - Box Drawings Light Horizontal + L'_', // r - SCAN 7 - Low Line + L'_', // s - SCAN 9 - Low Line + L'\x251c', // t - Box Drawings Light Vertical And Right + L'\x2524', // u - Box Drawings Light Vertical And Left + L'\x2534', // v - Box Drawings Light Up And Horizontal + L'\x252c', // w - Box Drawings Light Down And Horizontal + L'\x2502', // x - Box Drawings Light Vertical + L'\x2264', // y - Less-Than Or Equal To + L'\x2265', // z - Greater-Than Or Equal To + L'\x03c0', // { - Greek Small Letter Pi + L'\x2260', // | - Not Equal To + L'\x00a3', // } - Pound Sign + L'\x00b7', // ~ - Middle Dot +}; + +#define FIRST_G1 '_' +#define LAST_G1 '~' + + +// color constants + +#define FOREGROUND_BLACK 0 +#define FOREGROUND_WHITE FOREGROUND_RED|FOREGROUND_GREEN|FOREGROUND_BLUE + +#define BACKGROUND_BLACK 0 +#define BACKGROUND_WHITE BACKGROUND_RED|BACKGROUND_GREEN|BACKGROUND_BLUE + +const BYTE foregroundcolor[8] = +{ + FOREGROUND_BLACK, // black foreground + FOREGROUND_RED, // red foreground + FOREGROUND_GREEN, // green foreground + FOREGROUND_RED | FOREGROUND_GREEN, // yellow foreground + FOREGROUND_BLUE, // blue foreground + FOREGROUND_BLUE | FOREGROUND_RED, // magenta foreground + FOREGROUND_BLUE | FOREGROUND_GREEN, // cyan foreground + FOREGROUND_WHITE // white foreground +}; + +const BYTE backgroundcolor[8] = +{ + BACKGROUND_BLACK, // black background + BACKGROUND_RED, // red background + BACKGROUND_GREEN, // green background + BACKGROUND_RED | BACKGROUND_GREEN, // yellow background + BACKGROUND_BLUE, // blue background + BACKGROUND_BLUE | BACKGROUND_RED, // magenta background + BACKGROUND_BLUE | BACKGROUND_GREEN, // cyan background + BACKGROUND_WHITE, // white background +}; + +const BYTE attr2ansi[8] = // map console attribute to ANSI number +{ + 0, // black + 4, // blue + 2, // green + 6, // cyan + 1, // red + 5, // magenta + 3, // yellow + 7 // white +}; + +GRM grm; + +// saved cursor position +COORD SavePos; + +// Variables to enable copying attributes between processes. +SHARED DWORD s_pid; +SHARED GRM s_grm; +SHARED DWORD s_flag; +#define GRM_INIT 1 +#define GRM_EXIT 2 + + + +// Wait for the child process to finish, then update our GRM to the child's. +DWORD WINAPI UpdateGRM( LPVOID child_pi ) +{ + DWORD pid = ((LPPROCESS_INFORMATION)child_pi)->dwProcessId; + HANDLE proc = ((LPPROCESS_INFORMATION)child_pi)->hProcess; + free( child_pi ); + + WaitForSingleObject( proc, INFINITE ); + CloseHandle( proc ); + + if (s_flag == GRM_EXIT && s_pid == pid) + { + s_flag = 0; + grm = s_grm; + } + + return 0; +} + + +// Search an environment variable for a string. +BOOL search_env( LPCTSTR var, LPCTSTR val ) +{ + static LPTSTR env; + static DWORD env_len; + DWORD len; + BOOL not; + + len = GetEnvironmentVariable( var, env, env_len ); + if (len == 0) + return FALSE; + + if (len > env_len) + { + LPTSTR tmp = realloc( env, TSIZE(len) ); + if (tmp == NULL) + return FALSE; + env = tmp; + env_len = len; + GetEnvironmentVariable( var, env, env_len ); + } + + not = (*env == '!'); + if (not && env[1] == '\0') + return TRUE; + + for (var = wcstok( env + not, L";" ); var; var = wcstok( NULL, L";" )) + if (_wcsicmp( val, var ) == 0) + return !not; + + return not; +} + + +// ========== Print Buffer functions + +#define BUFFER_SIZE 2048 + +int nCharInBuffer; +WCHAR ChBuffer[BUFFER_SIZE]; + +//----------------------------------------------------------------------------- +// FlushBuffer() +// Writes the buffer to the console and empties it. +//----------------------------------------------------------------------------- + +void FlushBuffer( void ) +{ + DWORD nWritten; + if (nCharInBuffer <= 0) return; + WriteConsole( hConOut, ChBuffer, nCharInBuffer, &nWritten, NULL ); + nCharInBuffer = 0; +} + +//----------------------------------------------------------------------------- +// PushBuffer( WCHAR c ) +// Adds a character in the buffer. +//----------------------------------------------------------------------------- + +void PushBuffer( WCHAR c ) +{ + if (shifted && c >= FIRST_G1 && c <= LAST_G1) + c = G1[c-FIRST_G1]; + ChBuffer[nCharInBuffer] = c; + if (++nCharInBuffer == BUFFER_SIZE) + FlushBuffer(); +} + +//----------------------------------------------------------------------------- +// SendSequence( LPTSTR seq ) +// Send the string to the input buffer. +//----------------------------------------------------------------------------- + +void SendSequence( LPTSTR seq ) +{ + DWORD out; + INPUT_RECORD in; + HANDLE hStdIn = GetStdHandle( STD_INPUT_HANDLE ); + + in.EventType = KEY_EVENT; + in.Event.KeyEvent.bKeyDown = TRUE; + in.Event.KeyEvent.wRepeatCount = 1; + in.Event.KeyEvent.wVirtualKeyCode = 0; + in.Event.KeyEvent.wVirtualScanCode = 0; + in.Event.KeyEvent.dwControlKeyState = 0; + for (; *seq; ++seq) + { + in.Event.KeyEvent.uChar.UnicodeChar = *seq; + WriteConsoleInput( hStdIn, &in, 1, &out ); + } +} + +// ========== Print functions + +//----------------------------------------------------------------------------- +// InterpretEscSeq() +// Interprets the last escape sequence scanned by ParseAndPrintString +// prefix escape sequence prefix +// es_argc escape sequence args count +// es_argv[] escape sequence args array +// suffix escape sequence suffix +// +// for instance, with \e[33;45;1m we have +// prefix = '[', +// es_argc = 3, es_argv[0] = 33, es_argv[1] = 45, es_argv[2] = 1 +// suffix = 'm' +//----------------------------------------------------------------------------- + +void InterpretEscSeq( void ) +{ + int i; + WORD attribut; + CONSOLE_SCREEN_BUFFER_INFO Info; + CONSOLE_CURSOR_INFO CursInfo; + DWORD len, NumberOfCharsWritten; + COORD Pos; + SMALL_RECT Rect; + CHAR_INFO CharInfo; + + if (prefix == '[') + { + if (prefix2 == '?' && (suffix == 'h' || suffix == 'l')) + { + if (es_argc == 1 && es_argv[0] == 25) + { + GetConsoleCursorInfo( hConOut, &CursInfo ); + CursInfo.bVisible = (suffix == 'h'); + SetConsoleCursorInfo( hConOut, &CursInfo ); + return; + } + } + // Ignore any other \e[? or \e[> sequences. + if (prefix2 != 0) + return; + + GetConsoleScreenBufferInfo( hConOut, &Info ); + switch (suffix) + { + case 'm': + if (es_argc == 0) es_argv[es_argc++] = 0; + for (i = 0; i < es_argc; i++) + { + if (30 <= es_argv[i] && es_argv[i] <= 37) + grm.foreground = es_argv[i] - 30; + else if (40 <= es_argv[i] && es_argv[i] <= 47) + grm.background = es_argv[i] - 40; + else switch (es_argv[i]) + { + case 0: + case 39: + case 49: + { + TCHAR def[4]; + int a; + *def = '7'; def[1] = '\0'; + GetEnvironmentVariable( L"ANSICON_DEF", def, lenof(def) ); + a = wcstol( def, NULL, 16 ); + grm.reverse = FALSE; + if (a < 0) + { + grm.reverse = TRUE; + a = -a; + } + if (es_argv[i] != 49) + grm.foreground = attr2ansi[a & 7]; + if (es_argv[i] != 39) + grm.background = attr2ansi[(a >> 4) & 7]; + if (es_argv[i] == 0) + { + if (es_argc == 1) + { + grm.bold = a & FOREGROUND_INTENSITY; + grm.underline = a & BACKGROUND_INTENSITY; + } + else + { + grm.bold = 0; + grm.underline = 0; + } + grm.rvideo = 0; + grm.concealed = 0; + } + } + break; + + case 1: grm.bold = FOREGROUND_INTENSITY; break; + case 5: // blink + case 4: grm.underline = BACKGROUND_INTENSITY; break; + case 7: grm.rvideo = 1; break; + case 8: grm.concealed = 1; break; + case 21: // oops, this actually turns on double underline + case 22: grm.bold = 0; break; + case 25: + case 24: grm.underline = 0; break; + case 27: grm.rvideo = 0; break; + case 28: grm.concealed = 0; break; + } + } + if (grm.concealed) + { + if (grm.rvideo) + { + attribut = foregroundcolor[grm.foreground] + | backgroundcolor[grm.foreground]; + if (grm.bold) + attribut |= FOREGROUND_INTENSITY | BACKGROUND_INTENSITY; + } + else + { + attribut = foregroundcolor[grm.background] + | backgroundcolor[grm.background]; + if (grm.underline) + attribut |= FOREGROUND_INTENSITY | BACKGROUND_INTENSITY; + } + } + else if (grm.rvideo) + { + attribut = foregroundcolor[grm.background] + | backgroundcolor[grm.foreground]; + if (grm.bold) + attribut |= BACKGROUND_INTENSITY; + if (grm.underline) + attribut |= FOREGROUND_INTENSITY; + } + else + attribut = foregroundcolor[grm.foreground] | grm.bold + | backgroundcolor[grm.background] | grm.underline; + if (grm.reverse) + attribut = ((attribut >> 4) & 15) | ((attribut & 15) << 4); + SetConsoleTextAttribute( hConOut, attribut ); + return; + + case 'J': + if (es_argc == 0) es_argv[es_argc++] = 0; // ESC[J == ESC[0J + if (es_argc != 1) return; + switch (es_argv[0]) + { + case 0: // ESC[0J erase from cursor to end of display + len = (Info.dwSize.Y - Info.dwCursorPosition.Y - 1) * Info.dwSize.X + + Info.dwSize.X - Info.dwCursorPosition.X - 1; + FillConsoleOutputCharacter( hConOut, ' ', len, + Info.dwCursorPosition, + &NumberOfCharsWritten ); + FillConsoleOutputAttribute( hConOut, Info.wAttributes, len, + Info.dwCursorPosition, + &NumberOfCharsWritten ); + return; + + case 1: // ESC[1J erase from start to cursor. + Pos.X = 0; + Pos.Y = 0; + len = Info.dwCursorPosition.Y * Info.dwSize.X + + Info.dwCursorPosition.X + 1; + FillConsoleOutputCharacter( hConOut, ' ', len, Pos, + &NumberOfCharsWritten ); + FillConsoleOutputAttribute( hConOut, Info.wAttributes, len, Pos, + &NumberOfCharsWritten ); + return; + + case 2: // ESC[2J Clear screen and home cursor + Pos.X = 0; + Pos.Y = 0; + len = Info.dwSize.X * Info.dwSize.Y; + FillConsoleOutputCharacter( hConOut, ' ', len, Pos, + &NumberOfCharsWritten ); + FillConsoleOutputAttribute( hConOut, Info.wAttributes, len, Pos, + &NumberOfCharsWritten ); + SetConsoleCursorPosition( hConOut, Pos ); + return; + + default: + return; + } + + case 'K': + if (es_argc == 0) es_argv[es_argc++] = 0; // ESC[K == ESC[0K + if (es_argc != 1) return; + switch (es_argv[0]) + { + case 0: // ESC[0K Clear to end of line + len = Info.srWindow.Right - Info.dwCursorPosition.X + 1; + FillConsoleOutputCharacter( hConOut, ' ', len, + Info.dwCursorPosition, + &NumberOfCharsWritten ); + FillConsoleOutputAttribute( hConOut, Info.wAttributes, len, + Info.dwCursorPosition, + &NumberOfCharsWritten ); + return; + + case 1: // ESC[1K Clear from start of line to cursor + Pos.X = 0; + Pos.Y = Info.dwCursorPosition.Y; + FillConsoleOutputCharacter( hConOut, ' ', + Info.dwCursorPosition.X + 1, Pos, + &NumberOfCharsWritten ); + FillConsoleOutputAttribute( hConOut, Info.wAttributes, + Info.dwCursorPosition.X + 1, Pos, + &NumberOfCharsWritten ); + return; + + case 2: // ESC[2K Clear whole line. + Pos.X = 0; + Pos.Y = Info.dwCursorPosition.Y; + FillConsoleOutputCharacter( hConOut, ' ', Info.dwSize.X, Pos, + &NumberOfCharsWritten ); + FillConsoleOutputAttribute( hConOut, Info.wAttributes, + Info.dwSize.X, Pos, + &NumberOfCharsWritten ); + return; + + default: + return; + } + + case 'X': // ESC[#X Erase # characters. + if (es_argc == 0) es_argv[es_argc++] = 1; // ESC[X == ESC[1X + if (es_argc != 1) return; + FillConsoleOutputCharacter( hConOut, ' ', es_argv[0], + Info.dwCursorPosition, + &NumberOfCharsWritten ); + FillConsoleOutputAttribute( hConOut, Info.wAttributes, es_argv[0], + Info.dwCursorPosition, + &NumberOfCharsWritten ); + return; + + case 'L': // ESC[#L Insert # blank lines. + if (es_argc == 0) es_argv[es_argc++] = 1; // ESC[L == ESC[1L + if (es_argc != 1) return; + Rect.Left = 0; + Rect.Top = Info.dwCursorPosition.Y; + Rect.Right = Info.dwSize.X - 1; + Rect.Bottom = Info.dwSize.Y - 1; + Pos.X = 0; + Pos.Y = Info.dwCursorPosition.Y + es_argv[0]; + CharInfo.Char.UnicodeChar = ' '; + CharInfo.Attributes = Info.wAttributes; + ScrollConsoleScreenBuffer( hConOut, &Rect, NULL, Pos, &CharInfo ); + return; + + case 'M': // ESC[#M Delete # lines. + if (es_argc == 0) es_argv[es_argc++] = 1; // ESC[M == ESC[1M + if (es_argc != 1) return; + if (es_argv[0] > Info.dwSize.Y - Info.dwCursorPosition.Y) + es_argv[0] = Info.dwSize.Y - Info.dwCursorPosition.Y; + Rect.Left = 0; + Rect.Top = Info.dwCursorPosition.Y + es_argv[0]; + Rect.Right = Info.dwSize.X - 1; + Rect.Bottom = Info.dwSize.Y - 1; + Pos.X = 0; + Pos.Y = Info.dwCursorPosition.Y; + CharInfo.Char.UnicodeChar = ' '; + CharInfo.Attributes = Info.wAttributes; + ScrollConsoleScreenBuffer( hConOut, &Rect, NULL, Pos, &CharInfo ); + return; + + case 'P': // ESC[#P Delete # characters. + if (es_argc == 0) es_argv[es_argc++] = 1; // ESC[P == ESC[1P + if (es_argc != 1) return; + if (Info.dwCursorPosition.X + es_argv[0] > Info.dwSize.X - 1) + es_argv[0] = Info.dwSize.X - Info.dwCursorPosition.X; + Rect.Left = Info.dwCursorPosition.X + es_argv[0]; + Rect.Top = Info.dwCursorPosition.Y; + Rect.Right = Info.dwSize.X - 1; + Rect.Bottom = Info.dwCursorPosition.Y; + CharInfo.Char.UnicodeChar = ' '; + CharInfo.Attributes = Info.wAttributes; + ScrollConsoleScreenBuffer( hConOut, &Rect, NULL, Info.dwCursorPosition, + &CharInfo ); + return; + + case '@': // ESC[#@ Insert # blank characters. + if (es_argc == 0) es_argv[es_argc++] = 1; // ESC[@ == ESC[1@ + if (es_argc != 1) return; + if (Info.dwCursorPosition.X + es_argv[0] > Info.dwSize.X - 1) + es_argv[0] = Info.dwSize.X - Info.dwCursorPosition.X; + Rect.Left = Info.dwCursorPosition.X; + Rect.Top = Info.dwCursorPosition.Y; + Rect.Right = Info.dwSize.X - 1 - es_argv[0]; + Rect.Bottom = Info.dwCursorPosition.Y; + Pos.X = Info.dwCursorPosition.X + es_argv[0]; + Pos.Y = Info.dwCursorPosition.Y; + CharInfo.Char.UnicodeChar = ' '; + CharInfo.Attributes = Info.wAttributes; + ScrollConsoleScreenBuffer( hConOut, &Rect, NULL, Pos, &CharInfo ); + return; + + case 'k': // ESC[#k + case 'A': // ESC[#A Moves cursor up # lines + if (es_argc == 0) es_argv[es_argc++] = 1; // ESC[A == ESC[1A + if (es_argc != 1) return; + Pos.Y = Info.dwCursorPosition.Y - es_argv[0]; + if (Pos.Y < 0) Pos.Y = 0; + Pos.X = Info.dwCursorPosition.X; + SetConsoleCursorPosition( hConOut, Pos ); + return; + + case 'e': // ESC[#e + case 'B': // ESC[#B Moves cursor down # lines + if (es_argc == 0) es_argv[es_argc++] = 1; // ESC[B == ESC[1B + if (es_argc != 1) return; + Pos.Y = Info.dwCursorPosition.Y + es_argv[0]; + if (Pos.Y >= Info.dwSize.Y) Pos.Y = Info.dwSize.Y - 1; + Pos.X = Info.dwCursorPosition.X; + SetConsoleCursorPosition( hConOut, Pos ); + return; + + case 'a': // ESC[#a + case 'C': // ESC[#C Moves cursor forward # spaces + if (es_argc == 0) es_argv[es_argc++] = 1; // ESC[C == ESC[1C + if (es_argc != 1) return; + Pos.X = Info.dwCursorPosition.X + es_argv[0]; + if (Pos.X >= Info.dwSize.X) Pos.X = Info.dwSize.X - 1; + Pos.Y = Info.dwCursorPosition.Y; + SetConsoleCursorPosition( hConOut, Pos ); + return; + + case 'j': // ESC[#j + case 'D': // ESC[#D Moves cursor back # spaces + if (es_argc == 0) es_argv[es_argc++] = 1; // ESC[D == ESC[1D + if (es_argc != 1) return; + Pos.X = Info.dwCursorPosition.X - es_argv[0]; + if (Pos.X < 0) Pos.X = 0; + Pos.Y = Info.dwCursorPosition.Y; + SetConsoleCursorPosition( hConOut, Pos ); + return; + + case 'E': // ESC[#E Moves cursor down # lines, column 1. + if (es_argc == 0) es_argv[es_argc++] = 1; // ESC[E == ESC[1E + if (es_argc != 1) return; + Pos.Y = Info.dwCursorPosition.Y + es_argv[0]; + if (Pos.Y >= Info.dwSize.Y) Pos.Y = Info.dwSize.Y - 1; + Pos.X = 0; + SetConsoleCursorPosition( hConOut, Pos ); + return; + + case 'F': // ESC[#F Moves cursor up # lines, column 1. + if (es_argc == 0) es_argv[es_argc++] = 1; // ESC[F == ESC[1F + if (es_argc != 1) return; + Pos.Y = Info.dwCursorPosition.Y - es_argv[0]; + if (Pos.Y < 0) Pos.Y = 0; + Pos.X = 0; + SetConsoleCursorPosition( hConOut, Pos ); + return; + + case '`': // ESC[#` + case 'G': // ESC[#G Moves cursor column # in current row. + if (es_argc == 0) es_argv[es_argc++] = 1; // ESC[G == ESC[1G + if (es_argc != 1) return; + Pos.X = es_argv[0] - 1; + if (Pos.X >= Info.dwSize.X) Pos.X = Info.dwSize.X - 1; + if (Pos.X < 0) Pos.X = 0; + Pos.Y = Info.dwCursorPosition.Y; + SetConsoleCursorPosition( hConOut, Pos ); + return; + + case 'd': // ESC[#d Moves cursor row #, current column. + if (es_argc == 0) es_argv[es_argc++] = 1; // ESC[d == ESC[1d + if (es_argc != 1) return; + Pos.Y = es_argv[0] - 1; + if (Pos.Y < 0) Pos.Y = 0; + if (Pos.Y >= Info.dwSize.Y) Pos.Y = Info.dwSize.Y - 1; + SetConsoleCursorPosition( hConOut, Pos ); + return; + + case 'f': // ESC[#;#f + case 'H': // ESC[#;#H Moves cursor to line #, column # + if (es_argc == 0) + es_argv[es_argc++] = 1; // ESC[H == ESC[1;1H + if (es_argc == 1) + es_argv[es_argc++] = 1; // ESC[#H == ESC[#;1H + if (es_argc > 2) return; + Pos.X = es_argv[1] - 1; + if (Pos.X < 0) Pos.X = 0; + if (Pos.X >= Info.dwSize.X) Pos.X = Info.dwSize.X - 1; + Pos.Y = es_argv[0] - 1; + if (Pos.Y < 0) Pos.Y = 0; + if (Pos.Y >= Info.dwSize.Y) Pos.Y = Info.dwSize.Y - 1; + SetConsoleCursorPosition( hConOut, Pos ); + return; + + case 's': // ESC[s Saves cursor position for recall later + if (es_argc != 0) return; + SavePos = Info.dwCursorPosition; + return; + + case 'u': // ESC[u Return to saved cursor position + if (es_argc != 0) return; + SetConsoleCursorPosition( hConOut, SavePos ); + return; + + case 'n': // ESC[#n Device status report + if (es_argc != 1) return; // ESC[n == ESC[0n -> ignored + switch (es_argv[0]) + { + case 5: // ESC[5n Report status + SendSequence( L"\33[0n" ); // "OK" + return; + + case 6: // ESC[6n Report cursor position + { + TCHAR buf[32]; + wsprintf( buf, L"\33[%d;%dR", Info.dwCursorPosition.Y + 1, + Info.dwCursorPosition.X + 1 ); + SendSequence( buf ); + } + return; + + default: + return; + } + + case 't': // ESC[#t Window manipulation + if (es_argc != 1) return; + if (es_argv[0] == 21) // ESC[21t Report xterm window's title + { + TCHAR buf[MAX_PATH*2]; + DWORD len = GetConsoleTitle( buf+3, lenof(buf)-3-2 ); + // Too bad if it's too big or fails. + buf[0] = ESC; + buf[1] = ']'; + buf[2] = 'l'; + buf[3+len] = ESC; + buf[3+len+1] = '\\'; + buf[3+len+2] = '\0'; + SendSequence( buf ); + } + return; + + default: + return; + } + } + else // (prefix == ']') + { + // Ignore any \e]? or \e]> sequences. + if (prefix2 != 0) + return; + + if (es_argc == 1 && es_argv[0] == 0) // ESC]0;titleST + { + SetConsoleTitle( Pt_arg ); + } + } +} + +//----------------------------------------------------------------------------- +// ParseAndPrintString(hDev, lpBuffer, nNumberOfBytesToWrite) +// Parses the string lpBuffer, interprets the escapes sequences and prints the +// characters in the device hDev (console). +// The lexer is a three states automata. +// If the number of arguments es_argc > MAX_ARG, only the MAX_ARG-1 firsts and +// the last arguments are processed (no es_argv[] overflow). +//----------------------------------------------------------------------------- + +BOOL +ParseAndPrintString( HANDLE hDev, + LPCVOID lpBuffer, + DWORD nNumberOfBytesToWrite, + LPDWORD lpNumberOfBytesWritten + ) +{ + DWORD i; + LPCTSTR s; + + if (hDev != hConOut) // reinit if device has changed + { + hConOut = hDev; + state = 1; + shifted = FALSE; + } + for (i = nNumberOfBytesToWrite, s = (LPCTSTR)lpBuffer; i > 0; i--, s++) + { + if (state == 1) + { + if (*s == ESC) state = 2; + else if (*s == SO) shifted = TRUE; + else if (*s == SI) shifted = FALSE; + else PushBuffer( *s ); + } + else if (state == 2) + { + if (*s == ESC) ; // \e\e...\e == \e + else if ((*s == '[') || (*s == ']')) + { + FlushBuffer(); + prefix = *s; + prefix2 = 0; + state = 3; + Pt_len = 0; + *Pt_arg = '\0'; + } + else if (*s == ')' || *s == '(') state = 6; + else state = 1; + } + else if (state == 3) + { + if (isdigit( *s )) + { + es_argc = 0; + es_argv[0] = *s - '0'; + state = 4; + } + else if (*s == ';') + { + es_argc = 1; + es_argv[0] = 0; + es_argv[1] = 0; + state = 4; + } + else if (*s == '?' || *s == '>') + { + prefix2 = *s; + } + else + { + es_argc = 0; + suffix = *s; + InterpretEscSeq(); + state = 1; + } + } + else if (state == 4) + { + if (isdigit( *s )) + { + es_argv[es_argc] = 10 * es_argv[es_argc] + (*s - '0'); + } + else if (*s == ';') + { + if (es_argc < MAX_ARG-1) es_argc++; + es_argv[es_argc] = 0; + if (prefix == ']') + state = 5; + } + else + { + es_argc++; + suffix = *s; + InterpretEscSeq(); + state = 1; + } + } + else if (state == 5) + { + if (*s == BEL) + { + Pt_arg[Pt_len] = '\0'; + InterpretEscSeq(); + state = 1; + } + else if (*s == '\\' && Pt_len > 0 && Pt_arg[Pt_len-1] == ESC) + { + Pt_arg[--Pt_len] = '\0'; + InterpretEscSeq(); + state = 1; + } + else if (Pt_len < lenof(Pt_arg)-1) + Pt_arg[Pt_len++] = *s; + } + else if (state == 6) + { + // Ignore it (ESC ) 0 is implicit; nothing else is supported). + state = 1; + } + } + FlushBuffer(); + if (lpNumberOfBytesWritten != NULL) + *lpNumberOfBytesWritten = nNumberOfBytesToWrite - i; + return (i == 0); +} + + +// ========== Hooking API functions +// +// References about API hooking (and dll injection): +// - Matt Pietrek ~ Windows 95 System Programming Secrets. +// - Jeffrey Richter ~ Programming Applications for Microsoft Windows 4th ed. + +// Macro for adding pointers/DWORDs together without C arithmetic interfering +#define MakeVA( cast, offset ) (cast)((DWORD_PTR)(pDosHeader)+(DWORD)(offset)) + + +const char APIKernel[] = "kernel32.dll"; +const char APIConsole[] = "API-MS-Win-Core-Console-"; +const char APIProcessThreads[] = "API-MS-Win-Core-ProcessThreads-"; +const char APIProcessEnvironment[] = "API-MS-Win-Core-ProcessEnvironment-"; +const char APILibraryLoader[] = "API-MS-Win-Core-LibraryLoader-"; +const char APIFile[] = "API-MS-Win-Core-File-"; + +typedef struct +{ + PCSTR name; + DWORD len; + HMODULE base; +} API_DATA, *PAPI_DATA; + +API_DATA APIs[] = +{ + { APIConsole, sizeof(APIConsole) - 1, NULL }, + { APIProcessThreads, sizeof(APIProcessThreads) - 1, NULL }, + { APIProcessEnvironment, sizeof(APIProcessEnvironment) - 1, NULL }, + { APILibraryLoader, sizeof(APILibraryLoader) - 1, NULL }, + { APIFile, sizeof(APIFile) - 1, NULL }, + { NULL, 0, NULL } +}; + + +HMODULE hKernel; // Kernel32 module handle +HINSTANCE hDllInstance; // Dll instance handle +TCHAR hDllName[MAX_PATH]; // Dll file name +#if defined(_WIN64) || defined(W32ON64) +LPTSTR hDllNameType; // pointer to process type within above +#endif + +typedef struct +{ + PCSTR lib; + PSTR name; + PROC newfunc; + PROC oldfunc; + PROC apifunc; +} HookFn, *PHookFn; + +HookFn Hooks[]; + +const WCHAR zIgnoring[] = L"Ignoring"; +const WCHAR zHooking[] = L"Hooking"; +const WCHAR zUnhooking[] = L"Unhooking"; + + +//----------------------------------------------------------------------------- +// HookAPIOneMod +// Substitute a new function in the Import Address Table (IAT) of the +// specified module. +// Return FALSE on error and TRUE on success. +//----------------------------------------------------------------------------- + +BOOL HookAPIOneMod( + HMODULE hFromModule, // Handle of the module to intercept calls from + PHookFn Hooks, // Functions to replace + BOOL restore // Restore the original functions + ) +{ + PIMAGE_DOS_HEADER pDosHeader; + PIMAGE_NT_HEADERS pNTHeader; + PIMAGE_IMPORT_DESCRIPTOR pImportDesc; + PIMAGE_THUNK_DATA pThunk; + PHookFn hook; + + // Tests to make sure we're looking at a module image (the 'MZ' header) + pDosHeader = (PIMAGE_DOS_HEADER)hFromModule; + if (pDosHeader->e_magic != IMAGE_DOS_SIGNATURE) + { + DEBUGSTR( 1, L"Image has no DOS header!" ); + return FALSE; + } + + // The MZ header has a pointer to the PE header + pNTHeader = MakeVA( PIMAGE_NT_HEADERS, pDosHeader->e_lfanew ); + + // One more test to make sure we're looking at a "PE" image + if (pNTHeader->Signature != IMAGE_NT_SIGNATURE) + { + DEBUGSTR( 1, L"Image has no NT header!" ); + return FALSE; + } + + // We now have a valid pointer to the module's PE header. + // Get a pointer to its imports section. + pImportDesc = MakeVA( PIMAGE_IMPORT_DESCRIPTOR, + pNTHeader->OptionalHeader. + DataDirectory[IMAGE_DIRECTORY_ENTRY_IMPORT]. + VirtualAddress ); + + // Bail out if the RVA of the imports section is 0 (it doesn't exist) + if (pImportDesc == (PIMAGE_IMPORT_DESCRIPTOR)pDosHeader) + return TRUE; + + // Iterate through the array of imported module descriptors, looking + // for the module whose name matches the pszFunctionModule parameter. + for (; pImportDesc->Name; pImportDesc++) + { + BOOL kernel = TRUE; + PSTR pszModName = MakeVA( PSTR, pImportDesc->Name ); + if (_stricmp( pszModName, APIKernel ) != 0) + { + PAPI_DATA lib; + for (lib = APIs; lib->name; ++lib) + { + if (_strnicmp( pszModName, lib->name, lib->len ) == 0) + { + if (lib->base == NULL) + { + lib->base = GetModuleHandleA( pszModName ); + for (hook = Hooks; hook->name; ++hook) + if (hook->lib == lib->name) + hook->apifunc = GetProcAddress( lib->base, hook->name ); + } + break; + } + } + if (lib->name == NULL) + { + if (log_level & 16) + DEBUGSTR( 2, L" %s %S", zIgnoring, pszModName ); + continue; + } + kernel = FALSE; + } + if (log_level & 16) + DEBUGSTR( 2, L" Scanning %S", pszModName ); + + // Get a pointer to the found module's import address table (IAT). + pThunk = MakeVA( PIMAGE_THUNK_DATA, pImportDesc->FirstThunk ); + + // Blast through the table of import addresses, looking for the ones + // that match the original addresses. + while (pThunk->u1.Function) + { + for (hook = Hooks; hook->name; ++hook) + { + PROC patch = 0; + if (restore) + { + if ((PROC)pThunk->u1.Function == hook->newfunc) + patch = (kernel) ? hook->oldfunc : hook->apifunc; + } + else if ((PROC)pThunk->u1.Function == hook->oldfunc || + (PROC)pThunk->u1.Function == hook->apifunc) + { + patch = hook->newfunc; + } + if (patch) + { + DWORD flOldProtect, flNewProtect, flDummy; + MEMORY_BASIC_INFORMATION mbi; + + DEBUGSTR( 3, L" %S", hook->name ); + // Get the current protection attributes. + VirtualQuery( &pThunk->u1.Function, &mbi, sizeof(mbi) ); + // Take the access protection flags. + flNewProtect = mbi.Protect; + // Remove ReadOnly and ExecuteRead flags. + flNewProtect &= ~(PAGE_READONLY | PAGE_EXECUTE_READ); + // Add on ReadWrite flag + flNewProtect |= (PAGE_READWRITE); + // Change the access protection on the region of committed pages in the + // virtual address space of the current process. + VirtualProtect( &pThunk->u1.Function, sizeof(PVOID), + flNewProtect, &flOldProtect ); + + // Overwrite the original address with the address of the new function. + if (!WriteProcessMemory( GetCurrentProcess(), + &pThunk->u1.Function, + &patch, sizeof(patch), NULL )) + { + DEBUGSTR( 1, L"Could not patch!" ); + return FALSE; + } + + // Put the page attributes back the way they were. + VirtualProtect( &pThunk->u1.Function, sizeof(PVOID), + flOldProtect, &flDummy ); + } + } + pThunk++; // Advance to next imported function address + } + } + + return TRUE; // Function not found +} + +//----------------------------------------------------------------------------- +// HookAPIAllMod +// Substitute a new function in the Import Address Table (IAT) of all +// the modules in the current process. +// Return FALSE on error and TRUE on success. +//----------------------------------------------------------------------------- + +BOOL HookAPIAllMod( PHookFn Hooks, BOOL restore ) +{ + HANDLE hModuleSnap; + MODULEENTRY32 me; + BOOL fOk; + + // Take a snapshot of all modules in the current process. + hModuleSnap = CreateToolhelp32Snapshot( TH32CS_SNAPMODULE, + GetCurrentProcessId() ); + + if (hModuleSnap == INVALID_HANDLE_VALUE) + { + DEBUGSTR( 1, L"Failed to create snapshot!" ); + return FALSE; + } + + // Fill the size of the structure before using it. + me.dwSize = sizeof(MODULEENTRY32); + + // Walk the module list of the modules. + for (fOk = Module32First( hModuleSnap, &me ); fOk; + fOk = Module32Next( hModuleSnap, &me )) + { + // We don't hook functions in our own module. + if (me.hModule != hDllInstance && me.hModule != hKernel) + { + if (search_env( L"ANSICON_EXC", me.szModule )) + { + DEBUGSTR( 2, L"%s %s", zIgnoring, me.szModule ); + continue; + } + DEBUGSTR( 2, L"%s %s", (restore) ? zUnhooking : zHooking, me.szModule ); + // Hook this function in this module. + if (!HookAPIOneMod( me.hModule, Hooks, restore )) + { + CloseHandle( hModuleSnap ); + return FALSE; + } + } + } + CloseHandle( hModuleSnap ); + DEBUGSTR( 2, L"%s completed", (restore) ? zUnhooking : zHooking ); + return TRUE; +} + + +// ========== Child process injection + +// Inject code into the target process to load our DLL. +void Inject( DWORD dwCreationFlags, LPPROCESS_INFORMATION lpi, + LPPROCESS_INFORMATION child_pi, + BOOL wide, LPCVOID lpApp, LPCVOID lpCmd ) +{ + int type; + BOOL gui; + + type = ProcessType( child_pi, &gui ); + if (gui) + { + TCHAR app[MAX_PATH]; + LPTSTR name; + LPCTSTR term = L" \t"; + + app[MAX_PATH-1] = '\0'; + if (lpApp == NULL) + { + // Extract the program from the command line. I would use + // GetModuleFileNameEx, but it doesn't work when a process is created + // suspended and setting up a delay until it does work sometimes + // prevents the process running at all. GetProcessImageFileName works, + // but it's not supported in 2K. + if (wide) + { + LPCTSTR pos; + for (pos = lpCmd; *pos == ' ' || *pos == '\t'; ++pos) ; + if (*pos == '"') + { + term = L"\""; + ++pos; + } + wcsncpy( app, pos, MAX_PATH-1 ); + } + else + { + LPCSTR pos; + for (pos = lpCmd; *pos == ' ' || *pos == '\t'; ++pos) ; + if (*pos == '"') + { + term = L"\""; + ++pos; + } + MultiByteToWideChar( CP_ACP, 0, pos, -1, app, MAX_PATH ); + } + // CreateProcess only works with surrounding quotes ('"a name"' works, but + // 'a" "name' fails), so that's all I'll test, too. However, it also + // tests for a file at each separator ('a name' tries "a.exe" before + // "a name.exe") which I won't do. + name = wcspbrk( app, term ); + if (name) + *name = '\0'; + } + else + { + if (wide) + wcsncpy( app, lpApp, MAX_PATH-1 ); + else + MultiByteToWideChar( CP_ACP, 0, lpApp, -1, app, MAX_PATH ); + } + name = get_program_name( app ); + if (!search_env( L"ANSICON_GUI", name )) + { + DEBUGSTR( 1, L" %s", zIgnoring ); + type = 0; + } + } + if (type != 0) + { +#ifdef _WIN64 + if (type == 32) + { + hDllNameType[0] = '3'; + hDllNameType[1] = '2'; + InjectDLL32( child_pi, hDllName ); + } + else + { + hDllNameType[0] = '6'; + hDllNameType[1] = '4'; + InjectDLL64( child_pi, hDllName ); + } +#else +#ifdef W32ON64 + if (type == 64) + { + TCHAR args[64]; + STARTUPINFO si; + PROCESS_INFORMATION pi; + wcscpy( hDllNameType, L"CON.exe" ); + wsprintf( args, L"ansicon -P%lu:%lu", + child_pi->dwProcessId, child_pi->dwThreadId ); + ZeroMemory( &si, sizeof(si) ); + si.cb = sizeof(si); + if (CreateProcess( hDllName, args, NULL, NULL, FALSE, 0, NULL, NULL, + &si, &pi )) + { + WaitForSingleObject( pi.hProcess, INFINITE ); + CloseHandle( pi.hProcess ); + CloseHandle( pi.hThread ); + } + else + DEBUGSTR( 1, L"Could not execute \"%s\"", hDllName ); + wcscpy( hDllNameType, L"32.dll" ); + } + else +#endif + InjectDLL32( child_pi, hDllName ); +#endif + if (!gui && !(dwCreationFlags & (CREATE_NEW_CONSOLE | DETACHED_PROCESS))) + { + LPPROCESS_INFORMATION cpi; + s_pid = child_pi->dwProcessId; + s_grm = grm; + s_flag = GRM_INIT; + cpi = malloc( sizeof(*cpi) ); + cpi->dwProcessId = child_pi->dwProcessId; + DuplicateHandle( GetCurrentProcess(), child_pi->hProcess, + GetCurrentProcess(), &cpi->hProcess, 0, FALSE, + DUPLICATE_SAME_ACCESS ); + CloseHandle( CreateThread( NULL, 4096, UpdateGRM, cpi, 0, NULL ) ); + } + } + + if (!(dwCreationFlags & CREATE_SUSPENDED)) + ResumeThread( child_pi->hThread ); + + if (lpi) + { + memcpy( lpi, child_pi, sizeof(PROCESS_INFORMATION) ); + } + else + { + CloseHandle( child_pi->hThread ); + CloseHandle( child_pi->hProcess ); + } +} + + +BOOL WINAPI MyCreateProcessA( LPCSTR lpApplicationName, + LPSTR lpCommandLine, + LPSECURITY_ATTRIBUTES lpThreadAttributes, + LPSECURITY_ATTRIBUTES lpProcessAttributes, + BOOL bInheritHandles, + DWORD dwCreationFlags, + LPVOID lpEnvironment, + LPCSTR lpCurrentDirectory, + LPSTARTUPINFOA lpStartupInfo, + LPPROCESS_INFORMATION lpProcessInformation ) +{ + PROCESS_INFORMATION child_pi; + + if (!CreateProcessA( lpApplicationName, + lpCommandLine, + lpThreadAttributes, + lpProcessAttributes, + bInheritHandles, + dwCreationFlags | CREATE_SUSPENDED, + lpEnvironment, + lpCurrentDirectory, + lpStartupInfo, + &child_pi )) + return FALSE; + + DEBUGSTR( 1, L"CreateProcessA: (%lu) \"%S\", \"%S\"", + child_pi.dwProcessId, + (lpApplicationName == NULL) ? "" : lpApplicationName, + (lpCommandLine == NULL) ? "" : lpCommandLine ); + Inject( dwCreationFlags, lpProcessInformation, &child_pi, + FALSE, lpApplicationName, lpCommandLine ); + + return TRUE; +} + + +BOOL WINAPI MyCreateProcessW( LPCWSTR lpApplicationName, + LPWSTR lpCommandLine, + LPSECURITY_ATTRIBUTES lpThreadAttributes, + LPSECURITY_ATTRIBUTES lpProcessAttributes, + BOOL bInheritHandles, + DWORD dwCreationFlags, + LPVOID lpEnvironment, + LPCWSTR lpCurrentDirectory, + LPSTARTUPINFOW lpStartupInfo, + LPPROCESS_INFORMATION lpProcessInformation ) +{ + PROCESS_INFORMATION child_pi; + + if (!CreateProcessW( lpApplicationName, + lpCommandLine, + lpThreadAttributes, + lpProcessAttributes, + bInheritHandles, + dwCreationFlags | CREATE_SUSPENDED, + lpEnvironment, + lpCurrentDirectory, + lpStartupInfo, + &child_pi )) + return FALSE; + + DEBUGSTR( 1, L"CreateProcessW: (%lu) \"%s\", \"%s\"", + child_pi.dwProcessId, + (lpApplicationName == NULL) ? L"" : lpApplicationName, + (lpCommandLine == NULL) ? L"" : lpCommandLine ); + Inject( dwCreationFlags, lpProcessInformation, &child_pi, + TRUE, lpApplicationName, lpCommandLine ); + + return TRUE; +} + + +FARPROC WINAPI MyGetProcAddress( HMODULE hModule, LPCSTR lpProcName ) +{ + PHookFn hook; + FARPROC proc; + + proc = GetProcAddress( hModule, lpProcName ); + + if (proc) + { + if (hModule == hKernel) + { + // Ignore LoadLibrary so other hooks continue to work (our version + // might end up at a different address). + if (proc == Hooks[0].oldfunc || proc == Hooks[1].oldfunc) + { + DEBUGSTR( 3, L"GetProcAddress: %S (ignoring)", lpProcName ); + return proc; + } + for (hook = Hooks + 2; hook->name; ++hook) + { + if (proc == hook->oldfunc) + { + DEBUGSTR( 3, L"GetProcAddress: %S", lpProcName ); + return hook->newfunc; + } + } + } + else + { + PAPI_DATA api; + for (api = APIs; api->name; ++api) + { + if (hModule == api->base) + { + if (proc == Hooks[0].apifunc || proc == Hooks[1].apifunc) + { + DEBUGSTR( 3, L"GetProcAddress: %S (ignoring)", lpProcName ); + return proc; + } + for (hook = Hooks + 2; hook->name; ++hook) + { + if (proc == hook->apifunc) + { + DEBUGSTR( 3, L"GetProcAddress: %S", lpProcName ); + return hook->newfunc; + } + } + break; + } + } + } + } + + return proc; +} + + +void HookLibrary( HMODULE hMod, LPCVOID lpFileName, BOOL wide, LPCSTR funcName ) +{ + LPCWSTR name; + WCHAR wname[MAX_PATH]; + + if (hMod && hMod != hKernel) + { + if (!wide) + { + MultiByteToWideChar( AreFileApisANSI() ? CP_ACP : CP_OEMCP, 0, + lpFileName, -1, wname, MAX_PATH ); + lpFileName = wname; + } + name = wcsrchr( lpFileName, '\\' ); + if (name == NULL) + name = lpFileName; + else + ++name; + if (search_env( L"ANSICON_EXC", name )) + DEBUGSTR( 2, L"%s %s (%S)", zIgnoring, lpFileName, funcName ); + else + { + DEBUGSTR( 2, L"%s %s (%S)", zHooking, lpFileName, funcName ); + HookAPIOneMod( hMod, Hooks, FALSE ); + } + } +} + + +HMODULE WINAPI MyLoadLibraryA( LPCSTR lpFileName ) +{ + HMODULE hMod = LoadLibraryA( lpFileName ); + HookLibrary( hMod, lpFileName, FALSE, "LoadLibraryA" ); + return hMod; +} + + +HMODULE WINAPI MyLoadLibraryW( LPCWSTR lpFileName ) +{ + HMODULE hMod = LoadLibraryW( lpFileName ); + HookLibrary( hMod, lpFileName, TRUE, "LoadLibraryW" ); + return hMod; +} + + +HMODULE WINAPI MyLoadLibraryExA( LPCSTR lpFileName, HANDLE hFile, + DWORD dwFlags ) +{ + HMODULE hMod = LoadLibraryExA( lpFileName, hFile, dwFlags ); + if (!(dwFlags & LOAD_LIBRARY_AS_DATAFILE)) + HookLibrary( hMod, lpFileName, FALSE, "LoadLibraryExA" ); + return hMod; +} + + +HMODULE WINAPI MyLoadLibraryExW( LPCWSTR lpFileName, HANDLE hFile, + DWORD dwFlags ) +{ + HMODULE hMod = LoadLibraryExW( lpFileName, hFile, dwFlags ); + if (!(dwFlags & LOAD_LIBRARY_AS_DATAFILE)) + HookLibrary( hMod, lpFileName, TRUE, "LoadLibraryExW" ); + return hMod; +} + + +//----------------------------------------------------------------------------- +// MyWrite... +// It is the new function that must replace the original Write... function. +// This function have exactly the same signature as the original one. +//----------------------------------------------------------------------------- + +BOOL +WINAPI MyWriteConsoleA( HANDLE hCon, LPCVOID lpBuffer, + DWORD nNumberOfCharsToWrite, + LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved ) +{ + DWORD Mode; + LPWSTR buf; + DWORD len; + BOOL rc = TRUE; + + // if we write in a console buffer with processed output + if (GetConsoleMode( hCon, &Mode ) && (Mode & ENABLE_PROCESSED_OUTPUT)) + { + UINT cp = GetConsoleOutputCP(); + DEBUGSTR( 4, L"\33WriteConsoleA: %lu \"%.*S\"", + nNumberOfCharsToWrite, nNumberOfCharsToWrite, lpBuffer ); + len = MultiByteToWideChar( cp, 0, lpBuffer, nNumberOfCharsToWrite, NULL,0 ); + buf = malloc( TSIZE(len) ); + if (buf == NULL) + { + if (lpNumberOfCharsWritten != NULL) + *lpNumberOfCharsWritten = 0; + return (nNumberOfCharsToWrite == 0); + } + MultiByteToWideChar( cp, 0, lpBuffer, nNumberOfCharsToWrite, buf, len ); + rc = ParseAndPrintString( hCon, buf, len, lpNumberOfCharsWritten ); + free( buf ); + if (rc && lpNumberOfCharsWritten != NULL && + *lpNumberOfCharsWritten != nNumberOfCharsToWrite) + { + // Converting a multibyte character to Unicode results in a different + // "character" count. This causes some programs to think not everything + // was written, so the difference is sent again. Fudge the (presumably) + // correct count. + if (search_env( L"ANSICON_API", prog )) + *lpNumberOfCharsWritten = nNumberOfCharsToWrite; + } + return rc; + } + + return WriteConsoleA( hCon, lpBuffer, nNumberOfCharsToWrite, + lpNumberOfCharsWritten, lpReserved ); + +} + +BOOL +WINAPI MyWriteConsoleW( HANDLE hCon, LPCVOID lpBuffer, + DWORD nNumberOfCharsToWrite, + LPDWORD lpNumberOfCharsWritten, LPVOID lpReserved ) +{ + DWORD Mode; + if (GetConsoleMode( hCon, &Mode ) && (Mode & ENABLE_PROCESSED_OUTPUT)) + { + DEBUGSTR( 4, L"\33WriteConsoleW: %lu \"%.*s\"", + nNumberOfCharsToWrite, nNumberOfCharsToWrite, lpBuffer ); + return ParseAndPrintString( hCon, lpBuffer, + nNumberOfCharsToWrite, + lpNumberOfCharsWritten ); + } + + return WriteConsoleW( hCon, lpBuffer, nNumberOfCharsToWrite, + lpNumberOfCharsWritten, lpReserved ); +} + +BOOL +WINAPI MyWriteFile( HANDLE hFile, LPCVOID lpBuffer, DWORD nNumberOfBytesToWrite, + LPDWORD lpNumberOfBytesWritten, LPOVERLAPPED lpOverlapped ) +{ + DWORD Mode; + if (GetConsoleMode( hFile, &Mode ) && (Mode & ENABLE_PROCESSED_OUTPUT)) + { + DEBUGSTR( 4, L"WriteFile->" ); + return MyWriteConsoleA( hFile, lpBuffer, + nNumberOfBytesToWrite, + lpNumberOfBytesWritten, + lpOverlapped ); + } + + // here, WriteFile is the old function (this module is not hooked) + return WriteFile( hFile, lpBuffer, nNumberOfBytesToWrite, + lpNumberOfBytesWritten, lpOverlapped ); +} + + +#define HHFILE (HANDLE)(DWORD_PTR) + +UINT +WINAPI My_lwrite( HFILE hFile, LPCSTR lpBuffer, UINT uBytes ) +{ + DWORD Mode, written; + if (GetConsoleMode( HHFILE hFile, &Mode ) && (Mode & ENABLE_PROCESSED_OUTPUT)) + { + DEBUGSTR( 4, L"_lwrite->" ); + MyWriteConsoleA( HHFILE hFile, lpBuffer, uBytes, &written, NULL ); + return written; + } + + return _lwrite( hFile, lpBuffer, uBytes ); +} + +long +WINAPI My_hwrite( HFILE hFile, LPCSTR lpBuffer, long lBytes ) +{ + DWORD Mode, written; + if (GetConsoleMode( HHFILE hFile, &Mode ) && (Mode & ENABLE_PROCESSED_OUTPUT)) + { + DEBUGSTR( 4, L"_hwrite->" ); + MyWriteConsoleA( HHFILE hFile, lpBuffer, lBytes, &written, NULL ); + return written; + } + + return _hwrite( hFile, lpBuffer, lBytes ); +} + + +// ========== Environment variable + +void set_ansicon( PCONSOLE_SCREEN_BUFFER_INFO pcsbi ) +{ + CONSOLE_SCREEN_BUFFER_INFO csbi; + TCHAR buf[64]; + + if (pcsbi == NULL) + { + HANDLE hConOut; + hConOut = CreateFile( L"CONOUT$", GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, OPEN_EXISTING, 0, 0 ); + GetConsoleScreenBufferInfo( hConOut, &csbi ); + CloseHandle( hConOut ); + pcsbi = &csbi; + } + + wsprintf( buf, L"%dx%d (%dx%d)", + pcsbi->dwSize.X, pcsbi->dwSize.Y, + pcsbi->srWindow.Right - pcsbi->srWindow.Left + 1, + pcsbi->srWindow.Bottom - pcsbi->srWindow.Top + 1 ); + SetEnvironmentVariable( L"ANSICON", buf ); +} + +DWORD +WINAPI MyGetEnvironmentVariableA( LPCSTR lpName, LPSTR lpBuffer, DWORD nSize ) +{ + if (lstrcmpiA( lpName, "ANSICON_VER" ) == 0) + { + if (nSize < sizeof(PVEREA)) + return sizeof(PVEREA); + memcpy( lpBuffer, PVEREA, sizeof(PVEREA) ); + return sizeof(PVEREA) - 1; + } + + if (lstrcmpiA( lpName, "ANSICON" ) == 0) + set_ansicon( NULL ); + + return GetEnvironmentVariableA( lpName, lpBuffer, nSize ); +} + +DWORD +WINAPI MyGetEnvironmentVariableW( LPCWSTR lpName, LPWSTR lpBuffer, DWORD nSize ) +{ + if (lstrcmpi( lpName, L"ANSICON_VER" ) == 0) + { + if (nSize < lenof(PVERE)) + return lenof(PVERE); + memcpy( lpBuffer, PVERE, sizeof(PVERE) ); + return lenof(PVERE) - 1; + } + + if (lstrcmpi( lpName, L"ANSICON" ) == 0) + set_ansicon( NULL ); + + return GetEnvironmentVariableW( lpName, lpBuffer, nSize ); +} + + +// ========== Initialisation + +HookFn Hooks[] = { + // These two are expected first! + { APILibraryLoader, "LoadLibraryA", (PROC)MyLoadLibraryA, NULL, NULL }, + { APILibraryLoader, "LoadLibraryW", (PROC)MyLoadLibraryW, NULL, NULL }, + { APIProcessThreads, "CreateProcessA", (PROC)MyCreateProcessA, NULL, NULL }, + { APIProcessThreads, "CreateProcessW", (PROC)MyCreateProcessW, NULL, NULL }, + { APIProcessEnvironment, "GetEnvironmentVariableA", (PROC)MyGetEnvironmentVariableA, NULL, NULL }, + { APIProcessEnvironment, "GetEnvironmentVariableW", (PROC)MyGetEnvironmentVariableW, NULL, NULL }, + { APILibraryLoader, "GetProcAddress", (PROC)MyGetProcAddress, NULL, NULL }, + { APILibraryLoader, "LoadLibraryExA", (PROC)MyLoadLibraryExA, NULL, NULL }, + { APILibraryLoader, "LoadLibraryExW", (PROC)MyLoadLibraryExW, NULL, NULL }, + { APIConsole, "WriteConsoleA", (PROC)MyWriteConsoleA, NULL, NULL }, + { APIConsole, "WriteConsoleW", (PROC)MyWriteConsoleW, NULL, NULL }, + { APIFile, "WriteFile", (PROC)MyWriteFile, NULL, NULL }, + { APIKernel, "_lwrite", (PROC)My_lwrite, NULL, NULL }, + { APIKernel, "_hwrite", (PROC)My_hwrite, NULL, NULL }, + { NULL, NULL, NULL, NULL, NULL } +}; + +//----------------------------------------------------------------------------- +// OriginalAttr() +// Determine the original attributes for use by \e[m. +//----------------------------------------------------------------------------- +void OriginalAttr( void ) +{ + HANDLE hConOut; + CONSOLE_SCREEN_BUFFER_INFO csbi; + + hConOut = CreateFile( L"CONOUT$", GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, OPEN_EXISTING, 0, 0 ); + if (!GetConsoleScreenBufferInfo( hConOut, &csbi )) + csbi.wAttributes = 7; + CloseHandle( hConOut ); + + if (s_flag == GRM_INIT && s_pid == GetCurrentProcessId()) + { + s_flag = 0; + grm = s_grm; + } + else + { + if (GetEnvironmentVariable( L"ANSICON_REVERSE", NULL, 0 )) + { + SetEnvironmentVariable( L"ANSICON_REVERSE", NULL ); + grm.reverse = TRUE; + grm.foreground = attr2ansi[(csbi.wAttributes >> 4) & 7]; + grm.background = attr2ansi[csbi.wAttributes & 7]; + grm.bold = (csbi.wAttributes & BACKGROUND_INTENSITY) >> 4; + grm.underline = (csbi.wAttributes & FOREGROUND_INTENSITY) << 4; + } + else + { + grm.foreground = attr2ansi[csbi.wAttributes & 7]; + grm.background = attr2ansi[(csbi.wAttributes >> 4) & 7]; + grm.bold = csbi.wAttributes & FOREGROUND_INTENSITY; + grm.underline = csbi.wAttributes & BACKGROUND_INTENSITY; + } + } + if (!GetEnvironmentVariable( L"ANSICON_DEF", NULL, 0 )) + { + TCHAR def[4]; + LPTSTR a = def; + if (grm.reverse) + { + *a++ = '-'; + csbi.wAttributes = ((csbi.wAttributes >> 4) & 15) + | ((csbi.wAttributes & 15) << 4); + } + wsprintf( a, L"%X", csbi.wAttributes & 255 ); + SetEnvironmentVariable( L"ANSICON_DEF", def ); + } + set_ansicon( &csbi ); +} + + +//----------------------------------------------------------------------------- +// DllMain() +// Function called by the system when processes and threads are initialized +// and terminated. +//----------------------------------------------------------------------------- + +__declspec(dllexport) // to stop MinGW exporting everything +BOOL WINAPI DllMain( HINSTANCE hInstance, DWORD dwReason, LPVOID lpReserved ) +{ + BOOL bResult = TRUE; + PHookFn hook; + TCHAR logstr[4]; + + if (dwReason == DLL_PROCESS_ATTACH) + { + *logstr = '\0'; + GetEnvironmentVariable( L"ANSICON_LOG", logstr, lenof(logstr) ); + log_level = _wtoi( logstr ); + prog = get_program_name( NULL ); +#if defined(_WIN64) || defined(W32ON64) + hDllNameType = hDllName - 6 + +#endif + GetModuleFileName( hInstance, hDllName, lenof(hDllName) ); + + hDllInstance = hInstance; // save Dll instance handle + DEBUGSTR( 1, L"hDllInstance = %p", hDllInstance ); + + // Get the entry points to the original functions. + hKernel = GetModuleHandleA( APIKernel ); + for (hook = Hooks; hook->name; ++hook) + hook->oldfunc = GetProcAddress( hKernel, hook->name ); + + bResult = HookAPIAllMod( Hooks, FALSE ); + OriginalAttr(); + DisableThreadLibraryCalls( hInstance ); + } + else if (dwReason == DLL_PROCESS_DETACH) + { + if (lpReserved == NULL) + { + DEBUGSTR( 1, L"Unloading" ); + HookAPIAllMod( Hooks, TRUE ); + } + else + { + DEBUGSTR( 1, L"Terminating" ); + s_pid = GetCurrentProcessId(); + s_grm = grm; + s_flag = GRM_EXIT; + } + } + + return bResult; +} diff --git a/ansicon/COPYING.MinGW-w64-runtime.txt b/ansicon/COPYING.MinGW-w64-runtime.txt new file mode 100755 index 0000000..3d11e87 --- /dev/null +++ b/ansicon/COPYING.MinGW-w64-runtime.txt @@ -0,0 +1,240 @@ +MinGW-w64 runtime licensing +*************************** + +This program or library was built using MinGW-w64 and statically +linked against the MinGW-w64 runtime. Some parts of the runtime +are under licenses which require that the copyright and license +notices are included when distributing the code in binary form. +These notices are listed below. + + +======================== +Overall copyright notice +======================== + +Copyright (c) 2009, 2010 by the mingw-w64 project + +This license has been certified as open source. It has also been designated +as GPL compatible by the Free Software Foundation (FSF). + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + + 1. Redistributions in source code must retain the accompanying copyright + notice, this list of conditions, and the following disclaimer. + 2. Redistributions in binary form must reproduce the accompanying + copyright notice, this list of conditions, and the following disclaimer + in the documentation and/or other materials provided with the + distribution. + 3. Names of the copyright holders must not be used to endorse or promote + products derived from this software without prior written permission + from the copyright holders. + 4. The right to distribute this software or to use it for any purpose does + not give you the right to use Servicemarks (sm) or Trademarks (tm) of + the copyright holders. Use of them is covered by separate agreement + with the copyright holders. + 5. If any files are modified, you must cause the modified files to carry + prominent notices stating that you changed the files and the date of + any change. + +Disclaimer + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY EXPRESSED +OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES +OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO +EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, +OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, +EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +======================================== +getopt, getopt_long, and getop_long_only +======================================== + +Copyright (c) 2002 Todd C. Miller + +Permission to use, copy, modify, and distribute this software for any +purpose with or without fee is hereby granted, provided that the above +copyright notice and this permission notice appear in all copies. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES +WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR +ANY SPECIAL, DIRECT, 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 THIS SOFTWARE. + +Sponsored in part by the Defense Advanced Research Projects +Agency (DARPA) and Air Force Research Laboratory, Air Force +Materiel Command, USAF, under agreement number F39502-99-1-0512. + + * * * * * * * + +Copyright (c) 2000 The NetBSD Foundation, Inc. +All rights reserved. + +This code is derived from software contributed to The NetBSD Foundation +by Dieter Baron and Thomas Klausner. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + 1. Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + 2. Redistributions in binary form must reproduce the above copyright + notice, this list of conditions and the following disclaimer in the + documentation and/or other materials provided with the distribution. + +THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS +``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS +BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR +CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF +SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN +CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) +ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. + + +=============================================================== +gdtoa: Converting between IEEE floating point numbers and ASCII +=============================================================== + +The author of this software is David M. Gay. + +Copyright (C) 1997, 1998, 1999, 2000, 2001 by Lucent Technologies +All Rights Reserved + +Permission to use, copy, modify, and distribute this software and +its documentation for any purpose and without fee is hereby +granted, provided that the above copyright notice appear in all +copies and that both that the copyright notice and this +permission notice and warranty disclaimer appear in supporting +documentation, and that the name of Lucent or any of its entities +not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior +permission. + +LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. +IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR 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 +THIS SOFTWARE. + + * * * * * * * + +The author of this software is David M. Gay. + +Copyright (C) 2005 by David M. Gay +All Rights Reserved + +Permission to use, copy, modify, and distribute this software and its +documentation for any purpose and without fee is hereby granted, +provided that the above copyright notice appear in all copies and that +both that the copyright notice and this permission notice and warranty +disclaimer appear in supporting documentation, and that the name of +the author or any of his current or former employers not be used in +advertising or publicity pertaining to distribution of the software +without specific, written prior permission. + +THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN +NO EVENT SHALL THE AUTHOR OR ANY OF HIS CURRENT OR FORMER EMPLOYERS BE +LIABLE FOR 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 THIS +SOFTWARE. + + * * * * * * * + +The author of this software is David M. Gay. + +Copyright (C) 2004 by David M. Gay. +All Rights Reserved +Based on material in the rest of /netlib/fp/gdota.tar.gz, +which is copyright (C) 1998, 2000 by Lucent Technologies. + +Permission to use, copy, modify, and distribute this software and +its documentation for any purpose and without fee is hereby +granted, provided that the above copyright notice appear in all +copies and that both that the copyright notice and this +permission notice and warranty disclaimer appear in supporting +documentation, and that the name of Lucent or any of its entities +not be used in advertising or publicity pertaining to +distribution of the software without specific, written prior +permission. + +LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, +INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. +IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR 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 +THIS SOFTWARE. + + +========================= +Parts of the math library +========================= + +Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + +Developed at SunSoft, a Sun Microsystems, Inc. business. +Permission to use, copy, modify, and distribute this +software is freely granted, provided that this notice +is preserved. + + * * * * * * * + +Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. + +Developed at SunPro, a Sun Microsystems, Inc. business. +Permission to use, copy, modify, and distribute this +software is freely granted, provided that this notice +is preserved. + + * * * * * * * + +FIXME: Cephes math lib +Copyright (C) 1984-1998 Stephen L. Moshier + +It sounds vague, but as to be found at +, it gives an +impression that the author could be willing to give an explicit +permission to distribute those files e.g. under a BSD style license. So +probably there is no problem here, although it could be good to get a +permission from the author and then add a license into the Cephes files +in MinGW runtime. At least on follow-up it is marked that debian sees the +version a-like BSD one. As MinGW.org (where those cephes parts are coming +from) distributes them now over 6 years, it should be fine. + +=================================== +Headers and IDLs imported from Wine +=================================== + +Some header and IDL files were imported from the Wine project. These files +are prominent maked in source. Their copyright belongs to contributors and +they are distributed under LGPL license. + +Disclaimer + +This library is free software; you can redistribute it and/or +modify it under the terms of the GNU Lesser General Public +License as published by the Free Software Foundation; either +version 2.1 of the License, or (at your option) any later version. + +This library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Lesser General Public License for more details. diff --git a/ansicon/G1.bat b/ansicon/G1.bat new file mode 100755 index 0000000..37a6bb8 --- /dev/null +++ b/ansicon/G1.bat @@ -0,0 +1,18 @@ +@echo off & setlocal + +::Extract the current code page. Hopefully this method will work with other +::languages. CHCP outputs: "Active code page: #". Take the last five +::characters (the longest code) and delete up to and including the space. +for /f "delims=" %%j in ('chcp') do set CP=%%j +set CP=%CP:~-5% +set CP=%CP:* =% + +x86\ansicon -e The DEC Special Graphics Character Set according to code page %CP%:^ + +^ + + _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { ^| } ~^ + +^ + + _ ` a b c d e f g h i j k l m n o p q r s t u v w x y z { ^| } ~ diff --git a/ansicon/G1.txt b/ansicon/G1.txt new file mode 100755 index 0000000000000000000000000000000000000000..a007b91e24d684cc82dab589848ecb5d6e349b03 GIT binary patch literal 404 zcmZ|LxlRI66vpu{Qn4iz6c!dYWUx{b6JkZj_5ffl;{Y2~32AVQEj^FB1 zJNh+bEmJOQ_^$FAd3`!INQRbPUDoB95TqGj1A{&R>5v)&Zs?< VaDfwa3fvU?1b>0`o4H+_>K9G0Hk<$e literal 0 HcmV?d00001 diff --git a/ansicon/ansi.rc b/ansicon/ansi.rc new file mode 100755 index 0000000..16a4585 --- /dev/null +++ b/ansicon/ansi.rc @@ -0,0 +1,42 @@ +/* + ansi.rc - Version resource for ANSI{32,64}.dll. + + Jason Hood, 11 November, 2009. +*/ + +#include +#include "version.h" + +#ifdef _WIN64 +# define BITS "64" +#else +# define BITS "32" +#endif + +1 VERSIONINFO +FILEVERSION PVERB +PRODUCTVERSION PVERB +FILEOS VOS_NT +FILETYPE VFT_DLL +{ + BLOCK "StringFileInfo" + { + BLOCK "040904B0" + { + VALUE "Comments", "http://ansicon.adoxa.cjb.net/" + VALUE "CompanyName", "Jason Hood" + VALUE "FileDescription", "ANSI Console" + VALUE "FileVersion", PVERSA + VALUE "InternalName", "ANSI" BITS + VALUE "LegalCopyright", "Freeware" + VALUE "OriginalFilename", "ANSI" BITS ".dll" + VALUE "ProductName", "ANSICON" + VALUE "ProductVersion", PVERSA + } + } + + BLOCK "VarFileInfo" + { + VALUE "Translation", 0x0409, 0x04B0 + } +} diff --git a/ansicon/ansicon.c b/ansicon/ansicon.c new file mode 100755 index 0000000..2b87abe --- /dev/null +++ b/ansicon/ansicon.c @@ -0,0 +1,686 @@ +/* + ANSICON.c - ANSI escape sequence console driver. + + Jason Hood, 21 to 23 October, 2005. + + Original injection code was derived from Console Manager by Sergey Oblomov + (hoopoepg). Use of FlushInstructionCache came from www.catch22.net. + Additional information came from "Process-wide API spying - an ultimate hack", + Anton Bassov's article in "The Code Project" (use of OpenThread). + + v1.01, 11 & 12 March, 2006: + -m option to set "monochrome" (grey on black); + restore original color on exit. + + v1.10, 22 February, 2009: + ignore Ctrl+C/Ctrl+Break. + + v1.13, 21 & 27 March, 2009: + alternate injection method, to work with DEP; + use Unicode. + + v1.20, 17 to 21 June, 2009: + use a combination of the two injection methods; + test if ANSICON is already installed; + added -e (and -E) option to echo the command line (without newline); + added -t (and -T) option to type (display) files (with file name). + + v1.21, 23 September, 2009: + added -i (and -u) to add (remove) ANSICON to AutoRun. + + v1.24, 6 & 7 January, 2010: + no arguments to -t, or using "-" for the name, will read from stdin; + fix -t and -e when ANSICON was already loaded. + + v1.25, 22 July, 2010: + added -IU for HKLM. + + v1.30, 3 August to 7 September, 2010: + x64 support. + + v1.31, 13 & 15 November, 2010: + use LLW to fix potential Unicode path problems; + VC compatibility (2008 Express for 32-bit, PSDK 2003 R2 for 64-bit); + explicitly use wide characters (stick with TCHAR, but not ). + + v1.32, 4 to 22 December, 2010: + make -p more robust; + inject into GUI processes; + -i implies -p. + + v1.50, 7 to 14 December, 2011: + -u does not imply -p; + add the PID to the debugging output; + use ANSICON_VER to test if already installed; + always place first in AutoRun; + logging is always available, controlled by ANSICON_LOG environment variable; + only restore the original color after program/echo/type; + return program's exit code. + + 7 January, 2012: + fixed installing into a piped CMD.EXE; + added a log message indicating all imports have been processed. + + v1.52, 10 April, 2012: + fixed running "cmd" if "ComSpec" is not defined; + pass process & thread identifiers on the command line (for x86->x64). +*/ + +#define PDATE L"12 June, 2012" + +#include "ansicon.h" +#include "version.h" +#include +#include +#include + +#ifdef __MINGW32__ +int _CRT_glob = 0; +#endif + + +#ifdef _WIN64 +# define BITS L"64" +#else +# define BITS L"32" +#endif + + +#define CMDKEY L"Software\\Microsoft\\Command Processor" +#define AUTORUN L"AutoRun" + + +void help( void ); + +void display( LPCTSTR, BOOL ); +void print_error( LPCTSTR, ... ); +LPTSTR skip_spaces( LPTSTR ); +void get_arg( LPTSTR, LPTSTR*, LPTSTR* ); + +void process_autorun( TCHAR ); + +BOOL find_proc_id( HANDLE snap, DWORD id, LPPROCESSENTRY32 ppe ); +BOOL GetParentProcessInfo( LPPROCESS_INFORMATION ppi, LPTSTR ); + + +// Find the name of the DLL and inject it. +BOOL Inject( LPPROCESS_INFORMATION ppi, BOOL* gui, LPCTSTR app ) +{ + DWORD len; + WCHAR dll[MAX_PATH]; + int type; + + DEBUGSTR( 1, L"%s (%lu)", app, ppi->dwProcessId ); + type = ProcessType( ppi, gui ); + if (type == 0) + { + fwprintf( stderr, L"ANSICON: %s: unsupported process.\n", app ); + return FALSE; + } + + len = (DWORD)(prog - prog_path); + memcpy( dll, prog_path, TSIZE(len) ); +#ifdef _WIN64 + wsprintf( dll + len, L"ANSI%d.dll", type ); + if (type == 32) + InjectDLL32( ppi, dll ); + else + InjectDLL64( ppi, dll ); +#else + wcscpy( dll + len, L"ANSI32.dll" ); + InjectDLL32( ppi, dll ); +#endif + return TRUE; +} + + +static HANDLE hConOut; +static CONSOLE_SCREEN_BUFFER_INFO csbi; + +void get_original_attr( void ) +{ + hConOut = CreateFile( L"CONOUT$", GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, OPEN_EXISTING, 0, 0 ); + GetConsoleScreenBufferInfo( hConOut, &csbi ); +} + + +void set_original_attr( void ) +{ + SetConsoleTextAttribute( hConOut, csbi.wAttributes ); + CloseHandle( hConOut ); +} + + +DWORD CtrlHandler( DWORD event ) +{ + return (event == CTRL_C_EVENT || event == CTRL_BREAK_EVENT); +} + + +int main( void ) +{ + STARTUPINFO si; + PROCESS_INFORMATION pi; + LPTSTR argv, arg, cmd; + TCHAR logstr[4]; + BOOL installed; + BOOL shell, run, gui; + HMODULE ansi; + DWORD len; + int rc = 0; + + argv = GetCommandLine(); + len = (DWORD)wcslen( argv ) + 1; + if (len < MAX_PATH) + len = MAX_PATH; + arg = malloc( TSIZE(len) ); + get_arg( arg, &argv, &cmd ); // skip the program name + get_arg( arg, &argv, &cmd ); + + if (*arg) + { + if (wcscmp( arg, L"/?" ) == 0 || + wcscmp( arg, L"--help" ) == 0) + { + help(); + return rc; + } + if (wcscmp( arg, L"--version" ) == 0) + { + _putws( L"ANSICON (" BITS L"-bit) version " PVERS L" (" PDATE L")." ); + return rc; + } + } + + prog = get_program_name( NULL ); + *logstr = '\0'; + GetEnvironmentVariable( L"ANSICON_LOG", logstr, lenof(logstr) ); + log_level = _wtoi( logstr ); + +#ifdef _WIN64 + if (*arg == '-' && arg[1] == 'P') + { + swscanf( arg + 2, L"%u:%u", &pi.dwProcessId, &pi.dwThreadId ); + pi.hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pi.dwProcessId); + pi.hThread = OpenThread( THREAD_ALL_ACCESS, FALSE, pi.dwThreadId ); + Inject( &pi, &gui, arg ); + CloseHandle( pi.hThread ); + CloseHandle( pi.hProcess ); + return 0; + } +#endif + + if (log_level && !(log_level & 8)) + DEBUGSTR( 1, NULL ); // create a new file + + installed = (GetEnvironmentVariable( L"ANSICON_VER", NULL, 0 ) != 0); + // If it's already installed, remove it. This serves two purposes: preserves + // the parent's GRM; and unconditionally injects into GUI, without having to + // worry about ANSICON_GUI. + if (installed) + { + fputws( L"\33[m", stdout ); + FreeLibrary( GetModuleHandle( L"ANSI" BITS L".dll" ) ); + } + + shell = run = TRUE; + get_original_attr(); + + while (*arg == '-') + { + switch (arg[1]) + { + case 'l': + SetEnvironmentVariable( L"ANSICON_LOG", arg + 2 ); + log_level = _wtoi( arg + 2 ); + if (!(log_level & 8)) // unless told otherwise + DEBUGSTR( 1, NULL ); // create a new file + break; + + case 'i': + case 'I': + case 'u': + case 'U': + shell = FALSE; + process_autorun( arg[1] ); + if (arg[1] == 'u' || arg[1] == 'U') + break; + // else fall through + + case 'p': + shell = FALSE; + // If it's already installed, there's no need to do anything. + if (installed) + { + DEBUGSTR( 1, L"Already installed" ); + } + else if (GetParentProcessInfo( &pi, arg )) + { + pi.hProcess = OpenProcess(PROCESS_ALL_ACCESS, FALSE, pi.dwProcessId); + pi.hThread = OpenThread( THREAD_ALL_ACCESS, FALSE, pi.dwThreadId ); + SuspendThread( pi.hThread ); + if (!Inject( &pi, &gui, arg )) + rc = 1; + ResumeThread( pi.hThread ); + CloseHandle( pi.hThread ); + CloseHandle( pi.hProcess ); + } + else + { + fputws( L"ANSICON: could not obtain the parent process.\n", stderr ); + rc = 1; + } + break; + + case 'm': + { + int a = wcstol( arg + 2, NULL, 16 ); + if (a == 0) + a = (arg[2] == '-') ? -7 : 7; + if (a < 0) + { + SetEnvironmentVariable( L"ANSICON_REVERSE", L"1" ); + a = -a; + a = ((a >> 4) & 15) | ((a & 15) << 4); + } + SetConsoleTextAttribute( hConOut, a ); + SetEnvironmentVariable( L"ANSICON_DEF", NULL ); + break; + } + + case 'e': + case 'E': + case 't': + case 'T': + run = FALSE; + ++arg; + goto arg_out; + } + get_arg( arg, &argv, &cmd ); + } +arg_out: + if (run && *cmd == '\0') + { + if (!shell) + run = FALSE; + else if (!_isatty( 0 )) + { + *arg = 't'; + run = FALSE; + } + } + + if (run) + { + if (*cmd == '\0') + { + cmd = _wgetenv( L"ComSpec" ); + if (cmd == NULL) + { + // CreateProcessW writes to the string, so can't simply point to "cmd". + static TCHAR cmdstr[] = L"cmd"; + cmd = cmdstr; + } + arg = cmd; + } + + ZeroMemory( &si, sizeof(si) ); + si.cb = sizeof(si); + if (CreateProcess( NULL, cmd, NULL, NULL, TRUE, CREATE_SUSPENDED, + NULL, NULL, &si, &pi )) + { + Inject( &pi, &gui, arg ); + ResumeThread( pi.hThread ); + if (!gui) + { + SetConsoleCtrlHandler( (PHANDLER_ROUTINE)CtrlHandler, TRUE ); + WaitForSingleObject( pi.hProcess, INFINITE ); + GetExitCodeProcess( pi.hProcess, (LPDWORD)(LPVOID)&rc ); + } + CloseHandle( pi.hProcess ); + CloseHandle( pi.hThread ); + } + else + { + print_error( arg, arg ); + rc = 1; + } + } + else if (*arg) + { + ansi = LoadLibrary( L"ANSI" BITS L".dll" ); + if (ansi == NULL) + { + print_error( L"ANSI" BITS L".dll" ); + rc = 1; + } + + if (*arg == 'e' || *arg == 'E') + { + cmd += 2; + if (*cmd == ' ' || *cmd == '\t') + ++cmd; + fputws( cmd, stdout ); + if (*arg == 'e') + putwchar( '\n' ); + } + else // (*arg == 't' || *arg == 'T') + { + BOOL title = (*arg == 'T'); + get_arg( arg, &argv, &cmd ); + if (*arg == '\0') + wcscpy( arg, L"-" ); + do + { + if (title) + { + wprintf( L"==> %s <==\n", arg ); + display( arg, title ); + putwchar( '\n' ); + } + else + display( arg, title ); + get_arg( arg, &argv, &cmd ); + } while (*arg); + } + + FreeLibrary( ansi ); + } + + if (run || *arg) + set_original_attr(); + else + CloseHandle( hConOut ); + + return rc; +} + + +// Display a file. +void display( LPCTSTR name, BOOL title ) +{ + HANDLE in, out; + BOOL pipe; + char buf[8192]; + DWORD len; + + if (*name == '-' && name[1] == '\0') + { + pipe = TRUE; + in = GetStdHandle( STD_INPUT_HANDLE ); + } + else + { + pipe = FALSE; + in = CreateFile( name, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, OPEN_EXISTING, 0, NULL ); + if (in == INVALID_HANDLE_VALUE) + { + print_error( name ); + return; + } + } + if (title) + { + putwchar( '\n' ); + // Need to flush, otherwise it's written *after* STD_OUTPUT_HANDLE should + // it be redirected. + fflush( stdout ); + } + out = GetStdHandle( STD_OUTPUT_HANDLE ); + for (;;) + { + if (!ReadFile( in, buf, sizeof(buf), &len, NULL )) + { + if (GetLastError() != ERROR_BROKEN_PIPE) + print_error( name ); + break; + } + if (len == 0) + break; + WriteFile( out, buf, len, &len, NULL ); + } + if (!pipe) + CloseHandle( in ); +} + + +void print_error( LPCTSTR name, ... ) +{ + LPTSTR errmsg = NULL; + DWORD err = GetLastError(); + va_list arg; + + if (err == ERROR_BAD_EXE_FORMAT) + { + // This error requires an argument, which is a duplicate of name. + va_start( arg, name ); + FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, + NULL, err, 0, (LPTSTR)(LPVOID)&errmsg, 0, &arg ); + va_end( arg ); + fwprintf( stderr, L"ANSICON: %s", errmsg ); + } + else + { + FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, + NULL, err, 0, (LPTSTR)(LPVOID)&errmsg, 0, NULL ); + // Just in case there are other messages requiring args... + if (errmsg == NULL) + fwprintf( stderr, L"ANSICON: %s: Error %lu.\n", name, err ); + else + fwprintf( stderr, L"ANSICON: %s: %s", name, errmsg ); + } + LocalFree( errmsg ); +} + + +// Add or remove ANSICON to AutoRun. +void process_autorun( TCHAR cmd ) +{ + HKEY cmdkey; + TCHAR ansicon[MAX_PATH+80]; + TCHAR logstr[80]; + LPTSTR autorun, ansirun; + DWORD len, type, exist; + BOOL inst; + + if (log_level) + _snwprintf( logstr, lenof(logstr), L"set ANSICON_LOG=%d&", log_level ); + else + *logstr = '\0'; + len = TSIZE(_snwprintf( ansicon, lenof(ansicon), + L"(if %%ANSICON_VER%%==^%%ANSICON_VER^%% %s\"%s\" -p)", + logstr, prog_path ) + 1); + + inst = (towlower( cmd ) == 'i'); + RegCreateKeyEx( (iswlower( cmd )) ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE, + CMDKEY, 0, NULL, + REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, + &cmdkey, &exist ); + exist = 0; + RegQueryValueEx( cmdkey, AUTORUN, NULL, NULL, NULL, &exist ); + if (exist == 0) + { + if (inst) + RegSetValueEx( cmdkey, AUTORUN, 0, REG_SZ, (PBYTE)ansicon, len ); + } + else + { + // Let's assume there's sufficient memory. + autorun = malloc( exist + len ); + RegQueryValueEx( cmdkey, AUTORUN, NULL, &type, (PBYTE)autorun, &exist ); + // Remove the existing command, if present. + ansirun = wcsstr( autorun, L"(if %ANSICON_VER%" ); + if (ansirun != NULL) + { + LPTSTR tmp = wcschr( ansirun, '"' ); // opening quote + tmp = wcschr( tmp + 1, '"' ); // closing quote + tmp = wcschr( tmp + 1, ')' ); // closing bracket + if (*++tmp == '&') + ++tmp; + if (*tmp == '&') + ++tmp; + if (*tmp == '\0') + { + if (ansirun > autorun && ansirun[-1] == '&') + --ansirun; + if (ansirun > autorun && ansirun[-1] == '&') + --ansirun; + } + wcscpy( ansirun, tmp ); + exist = TSIZE((DWORD)wcslen( autorun ) + 1); + } + if (inst) + { + if (exist == sizeof(TCHAR)) + RegSetValueEx( cmdkey, AUTORUN, 0, REG_SZ, (PBYTE)ansicon, len ); + else + { + memmove( (PBYTE)autorun + len, autorun, exist ); + memcpy( autorun, ansicon, len ); + ((PBYTE)autorun)[len-sizeof(TCHAR)] = '&'; + RegSetValueEx( cmdkey, AUTORUN, 0, type, (PBYTE)autorun, exist+len ); + } + } + else + { + if (exist == sizeof(TCHAR)) + RegDeleteValue( cmdkey, AUTORUN ); + else + RegSetValueEx( cmdkey, AUTORUN, 0, type, (PBYTE)autorun, exist ); + } + free( autorun ); + } + RegCloseKey( cmdkey ); +} + + +// Search each process in the snapshot for id. +BOOL find_proc_id( HANDLE snap, DWORD id, LPPROCESSENTRY32 ppe ) +{ + BOOL fOk; + + ppe->dwSize = sizeof(PROCESSENTRY32); + for (fOk = Process32First( snap, ppe ); fOk; fOk = Process32Next( snap, ppe )) + if (ppe->th32ProcessID == id) + break; + + return fOk; +} + + +// Obtain the process and thread identifiers of the parent process. +BOOL GetParentProcessInfo( LPPROCESS_INFORMATION ppi, LPTSTR name ) +{ + HANDLE hSnap; + PROCESSENTRY32 pe; + THREADENTRY32 te; + BOOL fOk; + + hSnap = CreateToolhelp32Snapshot( TH32CS_SNAPPROCESS|TH32CS_SNAPTHREAD, 0 ); + + if (hSnap == INVALID_HANDLE_VALUE) + return FALSE; + + find_proc_id( hSnap, GetCurrentProcessId(), &pe ); + if (!find_proc_id( hSnap, pe.th32ParentProcessID, &pe )) + { + CloseHandle( hSnap ); + return FALSE; + } + + te.dwSize = sizeof(te); + for (fOk = Thread32First( hSnap, &te ); fOk; fOk = Thread32Next( hSnap, &te )) + if (te.th32OwnerProcessID == pe.th32ProcessID) + break; + + CloseHandle( hSnap ); + + ppi->dwProcessId = pe.th32ProcessID; + ppi->dwThreadId = te.th32ThreadID; + wcscpy( name, pe.szExeFile ); + + return fOk; +} + + +// Return the first non-space character from arg. +LPTSTR skip_spaces( LPTSTR arg ) +{ + while (*arg == ' ' || *arg == '\t') + ++arg; + + return arg; +} + + +// Retrieve an argument from the command line. cmd gets the existing argv; argv +// is ready for the next argument. +void get_arg( LPTSTR arg, LPTSTR* argv, LPTSTR* cmd ) +{ + LPTSTR line; + + line = *cmd = skip_spaces( *argv ); + while (*line != '\0') + { + if (*line == ' ' || *line == '\t') + { + ++line; + break; + } + if (*line == '"') + { + while (*++line != '\0') + { + if (*line == '"') + { + ++line; + break; + } + *arg++ = *line; + } + } + else + *arg++ = *line++; + } + *arg = '\0'; + *argv = line; +} + + +void help( void ) +{ + _putws( +L"ANSICON by Jason Hood .\n" +L"Version " PVERS L" (" PDATE L"). Freeware.\n" +L"http://ansicon.adoxa.cjb.net/\n" +L"\n" +#ifdef _WIN64 +L"Process ANSI escape sequences in Windows console programs.\n" +#else +L"Process ANSI escape sequences in Win32 console programs.\n" +#endif +L"\n" +L"ansicon [-l] [-i] [-I] [-u] [-U] [-m[]] [-p]\n" +L" [-e|E string | -t|T [file(s)] | program [args]]\n" +L"\n" +L" -l\t\tset the logging level (1=process, 2=module, 3=function,\n" +L" \t\t +4=output, +8=append) for program (-p is unaffected)\n" +L" -i\t\tinstall - add ANSICON to the AutoRun entry (also implies -p)\n" +L" -u\t\tuninstall - remove ANSICON from the AutoRun entry\n" +L" -I -U\t\tuse local machine instead of current user\n" +L" -m\t\tuse grey on black (\"monochrome\") or as default color\n" +L" -p\t\thook into the parent process\n" +L" -e\t\techo string\n" +L" -E\t\techo string, don't append newline\n" +L" -t\t\tdisplay files (\"-\" for stdin), combined as a single stream\n" +L" -T\t\tdisplay files, name first, blank line before and after\n" +L" program\trun the specified program\n" +L" nothing\trun a new command processor, or display stdin if redirected\n" +L"\n" +L" is one or two hexadecimal digits; please use \"COLOR /?\" for details.\n" +L"It may start with '-' to reverse foreground and background (but not for -p)." + ); +} diff --git a/ansicon/ansicon.h b/ansicon/ansicon.h new file mode 100755 index 0000000..8819186 --- /dev/null +++ b/ansicon/ansicon.h @@ -0,0 +1,47 @@ +/* + ansicon.h - Header file for common definitions. + + Jason Hood, 12 December, 2010 (originally injdll.h, 20 June, 2009). +*/ + +#ifndef ANSICON_H +#define ANSICON_H + +#ifndef UNICODE +# define UNICODE +#endif + +#define WIN32_LEAN_AND_MEAN +#define _WIN32_WINNT 0x0500 // MinGW wants this defined for OpenThread +#include +#include +#include + +#define lenof(array) (sizeof(array)/sizeof(*(array))) +#define TSIZE(size) ((size) * sizeof(TCHAR)) + + +typedef struct +{ + BYTE foreground; // ANSI base color (0 to 7; add 30) + BYTE background; // ANSI base color (0 to 7; add 40) + BYTE bold; // console FOREGROUND_INTENSITY bit + BYTE underline; // console BACKGROUND_INTENSITY bit + BYTE rvideo; // swap foreground/bold & background/underline + BYTE concealed; // set foreground/bold to background/underline + BYTE reverse; // swap console foreground & background attributes +} GRM, *PGRM; // Graphic Rendition Mode + + +int ProcessType( LPPROCESS_INFORMATION, BOOL* ); +void InjectDLL32( LPPROCESS_INFORMATION, LPCTSTR ); +void InjectDLL64( LPPROCESS_INFORMATION, LPCTSTR ); + +extern TCHAR prog_path[MAX_PATH]; +extern LPTSTR prog; +LPTSTR get_program_name( LPTSTR ); + +extern int log_level; +void DEBUGSTR( int level, LPTSTR szFormat, ... ); + +#endif diff --git a/ansicon/ansicon.rc b/ansicon/ansicon.rc new file mode 100755 index 0000000..09b03c1 --- /dev/null +++ b/ansicon/ansicon.rc @@ -0,0 +1,36 @@ +/* + ansicon.rc - Version resource for ansicon.exe. + + Jason Hood, 11 November, 2009. +*/ + +#include +#include "version.h" + +1 VERSIONINFO +FILEVERSION PVERB +PRODUCTVERSION PVERB +FILEOS VOS_NT +FILETYPE VFT_APP +{ + BLOCK "StringFileInfo" + { + BLOCK "040904B0" + { + VALUE "Comments", "http://ansicon.adoxa.cjb.net/" + VALUE "CompanyName", "Jason Hood" + VALUE "FileDescription", "ANSI Console" + VALUE "FileVersion", PVERSA + VALUE "InternalName", "ansicon" + VALUE "LegalCopyright", "Freeware" + VALUE "OriginalFilename", "ansicon.exe" + VALUE "ProductName", "ANSICON" + VALUE "ProductVersion", PVERSA + } + } + + BLOCK "VarFileInfo" + { + VALUE "Translation", 0x0409, 0x04B0 + } +} diff --git a/ansicon/injdll32.c b/ansicon/injdll32.c new file mode 100755 index 0000000..25ed7ae --- /dev/null +++ b/ansicon/injdll32.c @@ -0,0 +1,123 @@ +/* + Inject code into the target process to load our DLL. The target thread + should be suspended on entry; it remains suspended on exit. + + Initially I used the "stack" method of injection. However, this fails + when DEP is active, since that doesn't allow code to execute in the stack. + To overcome this I used the "CreateRemoteThread" method. However, this + would fail with Wselect, a program to assist batch files. Wselect runs, + but it has no output. As it turns out, removing the suspended flag would + make Wselect work, but it caused problems with everything else. So now I + allocate a section of memory and change the context to run from there. At + first I had an event to signal when the library was loaded, then the memory + was released. However, that wouldn't work with -p and CMD.EXE (4NT v8 + worked fine). Since it's possible the DLL might start a process suspended, + I've decided to simply keep the memory. +*/ + +#include "ansicon.h" + +#ifdef _WIN64 +#if defined(__MINGW64__) || (defined(_MSC_VER) && _MSC_VER <= 1400) +#include "wow64.h" + +TWow64GetThreadContext Wow64GetThreadContext; +TWow64SetThreadContext Wow64SetThreadContext; +#endif + +#define CONTEXT WOW64_CONTEXT +#undef CONTEXT_CONTROL +#define CONTEXT_CONTROL WOW64_CONTEXT_CONTROL +#define GetThreadContext Wow64GetThreadContext +#define SetThreadContext Wow64SetThreadContext +#endif + + +DWORD LLW; + + +void InjectDLL32( LPPROCESS_INFORMATION ppi, LPCTSTR dll ) +{ + CONTEXT context; + DWORD len; + LPVOID mem; + DWORD mem32; + #define CODESIZE 20 + BYTE code[CODESIZE+TSIZE(MAX_PATH)]; + union + { + PBYTE pB; + PDWORD pL; + } ip; + + len = TSIZE(lstrlen( dll ) + 1); + if (len > TSIZE(MAX_PATH)) + return; + + if (LLW == 0) + { + HMODULE hKernel = GetModuleHandleA( "kernel32.dll" ); +#ifdef _WIN64 +#ifdef __MINGW64__ + #define GETPROC( proc ) proc = (T##proc)GetProcAddress( hKernel, #proc ) + GETPROC( Wow64GetThreadContext ); + GETPROC( Wow64SetThreadContext ); + // Assume if one is defined, so is the other. + if (Wow64GetThreadContext == 0) + { + DEBUGSTR( 1, L"Failed to get pointer to Wow64GetThreadContext.\n" ); + return; + } +#endif + + STARTUPINFO si; + PROCESS_INFORMATION pi; + ZeroMemory( &si, sizeof(si) ); + si.cb = sizeof(si); + // ...ANSI32.dll\0 + CopyMemory( code, dll, len - TSIZE(7) ); + // ...ANSI-LLW.exe\0 + CopyMemory( code + len - TSIZE(7), L"-LLW.exe", TSIZE(9) ); + if (!CreateProcess( (LPCTSTR)code, NULL, NULL, NULL, FALSE, 0, NULL, NULL, + &si, &pi )) + { + DEBUGSTR( 1, L"Failed to execute \"%s\".\n", (LPCTSTR)code ); + return; + } + WaitForSingleObject( pi.hProcess, INFINITE ); + GetExitCodeProcess( pi.hProcess, &LLW ); + CloseHandle( pi.hProcess ); + CloseHandle( pi.hThread ); +#else + LLW = (DWORD)GetProcAddress( hKernel, "LoadLibraryW" ); +#endif + } + + CopyMemory( code + CODESIZE, dll, len ); + len += CODESIZE; + + context.ContextFlags = CONTEXT_CONTROL; + GetThreadContext( ppi->hThread, &context ); + mem = VirtualAllocEx( ppi->hProcess, NULL, len, MEM_COMMIT, + PAGE_EXECUTE_READWRITE ); + mem32 = (DWORD)(DWORD_PTR)mem; + + ip.pB = code; + + *ip.pB++ = 0x68; // push eip + *ip.pL++ = context.Eip; + *ip.pB++ = 0x9c; // pushf + *ip.pB++ = 0x60; // pusha + *ip.pB++ = 0x68; // push L"path\to\ANSI32.dll" + *ip.pL++ = mem32 + CODESIZE; + *ip.pB++ = 0xe8; // call LoadLibraryW + *ip.pL++ = LLW - (mem32 + (DWORD)(ip.pB+4 - code)); + *ip.pB++ = 0x61; // popa + *ip.pB++ = 0x9d; // popf + *ip.pB++ = 0xc3; // ret + + WriteProcessMemory( ppi->hProcess, mem, code, len, NULL ); + FlushInstructionCache( ppi->hProcess, mem, len ); + context.Eip = mem32; + SetThreadContext( ppi->hThread, &context ); +} diff --git a/ansicon/injdll64.c b/ansicon/injdll64.c new file mode 100755 index 0000000..c46bd46 --- /dev/null +++ b/ansicon/injdll64.c @@ -0,0 +1,96 @@ +/* + Inject code into the target process to load our DLL. The target thread + should be suspended on entry; it remains suspended on exit. + + Initially I used the "stack" method of injection. However, this fails + when DEP is active, since that doesn't allow code to execute in the stack. + To overcome this I used the "CreateRemoteThread" method. However, this + would fail with Wselect, a program to assist batch files. Wselect runs, + but it has no output. As it turns out, removing the suspended flag would + make Wselect work, but it caused problems with everything else. So now I + allocate a section of memory and change the context to run from there. At + first I had an event to signal when the library was loaded, then the memory + was released. However, that wouldn't work with -p and CMD.EXE (4NT v8 + worked fine). Since it's possible the DLL might start a process suspended, + I've decided to simply keep the memory. +*/ + +#include "ansicon.h" + +void InjectDLL64( LPPROCESS_INFORMATION ppi, LPCTSTR dll ) +{ + CONTEXT context; + DWORD len; + LPVOID mem; + DWORD64 LLW; + union + { + PBYTE pB; + PDWORD64 pL; + } ip; + #define CODESIZE 92 + static BYTE code[CODESIZE+TSIZE(MAX_PATH)] = { + 0,0,0,0,0,0,0,0, // original rip + 0,0,0,0,0,0,0,0, // LoadLibraryW + 0x9C, // pushfq + 0x50, // push rax + 0x51, // push rcx + 0x52, // push rdx + 0x53, // push rbx + 0x55, // push rbp + 0x56, // push rsi + 0x57, // push rdi + 0x41,0x50, // push r8 + 0x41,0x51, // push r9 + 0x41,0x52, // push r10 + 0x41,0x53, // push r11 + 0x41,0x54, // push r12 + 0x41,0x55, // push r13 + 0x41,0x56, // push r14 + 0x41,0x57, // push r15 + 0x48,0x83,0xEC,0x28, // sub rsp, 40 + 0x48,0x8D,0x0D,41,0,0,0, // lea ecx, L"path\to\ANSI64.dll" + 0xFF,0x15,-49,-1,-1,-1, // call LoadLibraryW + 0x48,0x83,0xC4,0x28, // add rsp, 40 + 0x41,0x5F, // pop r15 + 0x41,0x5E, // pop r14 + 0x41,0x5D, // pop r13 + 0x41,0x5C, // pop r12 + 0x41,0x5B, // pop r11 + 0x41,0x5A, // pop r10 + 0x41,0x59, // pop r9 + 0x41,0x58, // pop r8 + 0x5F, // pop rdi + 0x5E, // pop rsi + 0x5D, // pop rbp + 0x5B, // pop rbx + 0x5A, // pop rdx + 0x59, // pop rcx + 0x58, // pop rax + 0x9D, // popfq + 0xFF,0x25,-91,-1,-1,-1, // jmp original Rip + 0, // dword alignment for LLW, fwiw + }; + + len = TSIZE(lstrlen( dll ) + 1); + if (len > TSIZE(MAX_PATH)) + return; + CopyMemory( code + CODESIZE, dll, len ); + len += CODESIZE; + + context.ContextFlags = CONTEXT_CONTROL; + GetThreadContext( ppi->hThread, &context ); + mem = VirtualAllocEx( ppi->hProcess, NULL, len, MEM_COMMIT, + PAGE_EXECUTE_READWRITE ); + LLW = (DWORD64)LoadLibraryW; + + ip.pB = code; + + *ip.pL++ = context.Rip; + *ip.pL++ = LLW; + + WriteProcessMemory( ppi->hProcess, mem, code, len, NULL ); + FlushInstructionCache( ppi->hProcess, mem, len ); + context.Rip = (DWORD64)mem + 16; + SetThreadContext( ppi->hThread, &context ); +} diff --git a/ansicon/makefile b/ansicon/makefile new file mode 100755 index 0000000..0007bee --- /dev/null +++ b/ansicon/makefile @@ -0,0 +1,82 @@ +# Makefile for ANSICON. +# Jason Hood, 11 March, 2006. Updated 20 June, 2009. + +# I've used TDM64 (gcc 4.6.1), building the 32-bit version in the x86 directory +# and the 64-bit version in the x64 directory. MinGW32 (gcc 3.4.5) will also +# build the 32-bit version. + +# 19 November, 2010: +# explicitly use 64-bit flags, in case the compiler isn't. +# +# 13 December, 2011: +# use CMD for file operations, not programs from fileutils. + +CC = gcc +CFLAGS = -O2 -Wall + +X86OBJS = x86/proctype.o x86/injdll32.o x86/util.o +X64OBJS = x64/proctype.o x64/injdll64.o x64/injdll32.o x64/util.o + +x86/%.o: %.c ansicon.h + $(CC) -m32 -c $(CFLAGS) $< -o $@ + +x86/%v.o: %.rc version.h + windres -U _WIN64 -F pe-i386 $< $@ + +x64/%.o: %.c ansicon.h + $(CC) -m64 -c $(CFLAGS) $< -o $@ + +x64/%v.o: %.rc version.h + windres -F pe-x86-64 $< $@ + +all: ansicon32 ansicon64 + +ansicon32: x86 x86/ansicon.exe x86/ANSI32.dll + +ansicon64: x64 x64/ansicon.exe x64/ANSI64.dll x64/ANSI32.dll x64/ANSI-LLW.exe + +x86: + cmd /c "mkdir x86" + +x86/ansicon.exe: x86/ansicon.o $(X86OBJS) x86/ansiconv.o + $(CC) -m32 $+ -s -o $@ + +x86/ANSI32.dll: x86/ANSI.o $(X86OBJS) x86/ansiv.o + $(CC) -m32 $+ -s -o $@ -mdll -Wl,-shared + +x64: + cmd /c "mkdir x64" + +x64/ansicon.exe: x64/ansicon.o $(X64OBJS) x64/ansiconv.o + $(CC) -m64 $+ -s -o $@ + +x64/ANSI64.dll: x64/ANSI.o $(X64OBJS) x64/ansiv.o + $(CC) -m64 $+ -s -o $@ -mdll -Wl,-shared + +x64/ANSI32.dll: x64/ANSI32.o x64/proctype32.o x86/injdll32.o x86/util.o x86/ansiv.o + $(CC) -m32 $+ -s -o $@ -mdll -Wl,-shared + +x64/ANSI-LLW.exe: ANSI-LLW.c + $(CC) -m32 $(CFLAGS) $< -s -o $@ + +x86/ansicon.o: version.h +x86/ANSI.o: version.h +x64/ansicon.o: version.h +x64/ANSI.o: version.h +x86/util.o: version.h +x64/util.o: version.h +x86/ansiconv.o: ansicon.rc +x86/ansiv.o: ansi.rc +x64/ansiconv.o: ansicon.rc +x64/ansiv.o: ansi.rc + +x64/ANSI32.o: ANSI.c + $(CC) -m32 -DW32ON64 $(CFLAGS) $< -c -o $@ +x64/proctype32.o: proctype.c + $(CC) -m32 -DW32ON64 $(CFLAGS) $< -c -o $@ + +# Need two commands, because if the directory doesn't exist, it won't delete +# anything at all. +clean: + -cmd /c "del x86\*.o 2>nul" + -cmd /c "del x64\*.o 2>nul" diff --git a/ansicon/makefile.vc b/ansicon/makefile.vc new file mode 100755 index 0000000..da71872 --- /dev/null +++ b/ansicon/makefile.vc @@ -0,0 +1,88 @@ +# VC makefile for ANSICON. +# Jason Hood, 15 November, 2010. + +# I've used Visual C++ 2008 Express for the 32-bit version and the 2003 R2 +# Platform SDK for the 64-bit version. Since these are entirely separate +# environments, define BITS to decide which should be built. Note that the +# 64-bit version still requires the 32-bit ANSI32.dll, so both environments +# are required and you should build the 32-bit version before the 64-bit. + +#BITS = 32 +#BITS = 64 + +!IFNDEF BITS +BITS = 32 +!ENDIF + +!IF $(BITS) == 32 +DIR = x86 +!ELSE +!IF $(BITS) == 64 +DIR = x64 +!ELSE +!ERROR BITS should be defined to 32 or 64. +!ENDIF +!ENDIF + +CC = cl +CFLAGS = /nologo /W3 /Ox /GF /D_CRT_SECURE_NO_WARNINGS +LIBS = advapi32.lib user32.lib + +# This is required for the 2003 Platform SDK, but not for Visual Studio 2010. +#LIBS64 = bufferoverflowu.lib + +X86OBJS = x86\proctype.obj x86\injdll32.obj x86\util.obj +X64OBJS = x64\proctype.obj x64\injdll64.obj x64\injdll32.obj x64\util.obj + +{}.c{$(DIR)}.obj: + $(CC) /c $(CFLAGS) /Fo$@ $< + +{}.rc{$(DIR)}.res: + rc /fo$@ $< + +all: ansicon$(BITS) + +ansicon32: x86 x86\ansicon.exe x86\ANSI32.dll x64\ANSI32.dll + +ansicon64: x64 x64\ansicon.exe x64\ANSI64.dll x64\ANSI-LLW.exe + +x86: + mkdir x86 + +x86\ansicon.exe: x86\ansicon.obj $(X86OBJS) x86\ansicon.res + $(CC) /nologo /Fe$@ $** $(LIBS) + +x86\ANSI32.dll: x86\ANSI.obj $(X86OBJS) x86\ansi.res + $(CC) /nologo /LD /Fe$@ $** $(LIBS) + +x64: + mkdir x64 + +x64\ansicon.exe: x64\ansicon.obj $(X64OBJS) x64\ansicon.res + $(CC) /nologo /Fe$@ $** $(LIBS) $(LIBS64) + +x64\ANSI64.dll: x64\ANSI.obj $(X64OBJS) x64\ansi.res + $(CC) /nologo /LD /Fe$@ $** $(LIBS) $(LIBS64) + +x64\ANSI32.dll: x64\ANSI32.obj x64\proctype32.obj x86\injdll32.obj x86\util.obj x86\ansi.res + $(CC) /nologo /LD /Fe$@ $** $(LIBS) + +x64\ANSI-LLW.exe: ANSI-LLW.c + $(CC) $(CFLAGS) /Fe$@ /Fo$*.obj $? $(LIBS64) + +ansicon.c: ansicon.h version.h +ansicon.rc: version.h +ANSI.c: ansicon.h version.h +ANSI.rc: version.h +util.c: ansicon.h version.h +injdll32.c: ansicon.h +injdll64.c: ansicon.h +proctype.c: ansicon.h + +x64\ANSI32.obj: ANSI.c + $(CC) /DW32ON64 /c $(CFLAGS) /Fo$@ $? +x64\proctype32.obj: proctype.c + $(CC) /DW32ON64 /c $(CFLAGS) /Fo$@ $? + +clean: + -del $(DIR)\*.obj $(DIR)\*.res $(DIR)\*.lib $(DIR)\*.exp diff --git a/ansicon/proctype.c b/ansicon/proctype.c new file mode 100755 index 0000000..27399cd --- /dev/null +++ b/ansicon/proctype.c @@ -0,0 +1,105 @@ +/* + Test for a valid process. This may sometimes detect GUI, even for a console + process. I think this is due to a DLL being loaded in the address space + before the main image. Ideally I could just use the base address directly, + but that doesn't seem easy to do for another process - there doesn't seem to + be a GetModuleHandle for another process. The CreateRemoteThread trick won't + work with 64-bit (exit code is DWORD) and setting it up to make it work + hardly seems worth it. There's GetModuleInformation, but passing in NULL just + returns a base of NULL, so that's no help. Since 64/32 is sufficient, let + ansicon.exe handle the difference between console/GUI. + + Update: ignore images characterised as DLL. +*/ + +#include "ansicon.h" + + +int ProcessType( LPPROCESS_INFORMATION pinfo, BOOL* gui ) +{ + char* ptr; + MEMORY_BASIC_INFORMATION minfo; + IMAGE_DOS_HEADER dos_header; + IMAGE_NT_HEADERS nt_header; + SIZE_T read; + + *gui = FALSE; + for (ptr = NULL; + VirtualQueryEx( pinfo->hProcess, ptr, &minfo, sizeof(minfo) ); + ptr += minfo.RegionSize) + { + if (minfo.BaseAddress == minfo.AllocationBase && + ReadProcessMemory( pinfo->hProcess, minfo.AllocationBase, + &dos_header, sizeof(dos_header), &read )) + { + if (dos_header.e_magic == IMAGE_DOS_SIGNATURE) + { + if (ReadProcessMemory( pinfo->hProcess, (char*)minfo.AllocationBase + + dos_header.e_lfanew, &nt_header, + sizeof(nt_header), &read )) + { + if (nt_header.Signature == IMAGE_NT_SIGNATURE && + (nt_header.FileHeader.Characteristics & + (IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_DLL)) + == IMAGE_FILE_EXECUTABLE_IMAGE) + { + *gui = (nt_header.OptionalHeader.Subsystem + == IMAGE_SUBSYSTEM_WINDOWS_GUI); + if (nt_header.OptionalHeader.Subsystem == + IMAGE_SUBSYSTEM_WINDOWS_CUI || *gui) + { + if (nt_header.FileHeader.Machine == IMAGE_FILE_MACHINE_I386) + { + // Microsoft ignores precision on %p. + DEBUGSTR( 1, L" 32-bit %s (base = %.8X)", + (*gui) ? L"GUI" : L"console", + (DWORD)(DWORD_PTR)minfo.AllocationBase ); + return 32; + } +#ifdef _WIN64 + if (nt_header.FileHeader.Machine == IMAGE_FILE_MACHINE_AMD64) + { + DEBUGSTR( 1, L" 64-bit %s (base = %p)", + (*gui) ? L"GUI" : L"console", minfo.AllocationBase ); + return 64; + } +#elif defined(W32ON64) + if (nt_header.FileHeader.Machine == IMAGE_FILE_MACHINE_AMD64) + { + DEBUGSTR( 1, L" 64-bit %s", + (*gui) ? L"GUI" : L"console" ); + return 64; + } +#endif + DEBUGSTR( 1, L" Ignoring unsupported machine (0x%X)", + nt_header.FileHeader.Machine ); + } + else + { + DEBUGSTR( 1, L" Ignoring unsupported subsystem (%u)", + nt_header.OptionalHeader.Subsystem ); + } + return 0; + } + } + } + } +#ifdef _WIN32 + // If a 32-bit process manages to load a 64-bit one, we may miss the base + // address. If the pointer overflows, assume 64-bit and abort. + if (ptr > ptr + minfo.RegionSize) + { +#ifdef W32ON64 + DEBUGSTR( 1, L" Pointer overflow: assuming 64-bit console" ); + return 64; +#else + DEBUGSTR( 1, L" Ignoring apparent 64-bit process" ); + return 0; +#endif + } +#endif + } + + DEBUGSTR( 1, L" Ignoring non-Windows process" ); + return 0; +} diff --git a/ansicon/readme.txt b/ansicon/readme.txt new file mode 100755 index 0000000..78f00eb --- /dev/null +++ b/ansicon/readme.txt @@ -0,0 +1,439 @@ + + ANSICON + + Copyright 2005-2012 Jason Hood + + Version 1.53. Freeware + + + =========== + Description + =========== + + ANSICON provides ANSI escape sequences for Windows console programs. It + provides much the same functionality as `ANSI.SYS' does for MS-DOS. + + + ============ + Requirements + ============ + + Windows 2000 Professional and later (it won't work with NT or 9X). + + + ============ + Installation + ============ + + Add x86 (if your OS is 32-bit) or x64 (if 64-bit) to your PATH, or copy + the relevant files to a directory already on the PATH. Alternatively, + use option `-i' (or `-I') to install it permanently, by adding an entry + to CMD.EXE's AutoRun registry value (current user or local machine, + respectively). Uninstall simply involves closing any programs that are + currently using it, running with `-u' (and/or `-U') to remove the Auto- + Run entry/ies, then removing the directory from PATH or deleting the + files. No other changes are made. + + --------- + Upgrading + --------- + + Delete ANSI.dll, it has been replaced with ANSI32.dll. + Delete ANSI-LLA.dll, it has been replaced with ANSI-LLW.dll. + Uninstall a pre-1.50 version and reinstall with this version. + + + ===== + Usage + ===== + + Options (case sensitive): + + -l Log to %temp%\ansicon.log. + + -p Enable the parent process (i.e. the command shell used to + run ANSICON) to recognise escapes. + + -m Set the current (and default) attribute to grey on black + ("monochrome"), or the attribute following the `m' (please + use `COLOR /?' for attribute values). + + -e Echo the command line - a space or tab after the `e' is + ignored, the remainder is displayed verbatim. + + -E As above, but no newline is added. + + -t Display ("type") each file (or standard input if none or the + name is "-") as though they are a single file. + + -T Display "==> FILE NAME <==", a blank line (or an error + message), the file and another blank line. + + Running ANSICON with no arguments will start a new instance of the com- + mand processor (the program defined by the `ComSpec' environment var- + iable, typically `CMD.EXE'), or display standard input if it is redir- + ected. Any argument will be treated as a program and its arguments. + + Eg: `ansicon -m30 -t file.ans' will display `file.ans' using black on + cyan as the default color. + + The attribute may start with "-" to permanently reverse the foreground + and background colors (but not when using `-p'). Eg: `ansicon -m-f0 -t + file.log' will use reversed black on white as the default (i.e. white on + black, with foreground sequences changing the background). + + If you experience trouble with certain programs, the log may help in + finding the cause; it can be found at "%TEMP%\ansicon.log". A number + should follow the `l': + + 0 No logging + 1 Log process start and end + 2 Above, plus log modules used by the process + 3 Above, plus log functions that are hooked + 4 Log console output (add to any of the above) + 8 Append to the existing file (add to any of the above) + 16 Log all imported modules (add to any of the above) + + The log option will not work with `-p'; set the environment variable + ANSICON_LOG instead. The variable is only read once when a new process + is started; changing it won't affect running processes. If you identify + a module that causes problems (one known is "nvd3d9wrap.dll") add it to + the ANSICON_EXC environment variable (see ANSICON_API below, but the + extension is required). + + Once installed, the ANSICON environment variable will be created. This + variable is of the form "WxH (wxh)", where W & H are the width and + height of the buffer and w & h are the width and height of the window. + The variable is updated whenever a program reads it directly (i.e. as + an individual request, not as part of the entire environment block). + For example, "set an" will not update it, but "echo %ansicon%" will. + Also created is ANSICON_VER, which contains the version without the + point (1.50 becomes "150"). This variable does not exist as part of the + environment block ("set an" will not show it). + + If installed, GUI programs will not be hooked. Either start the program + directly with `ansicon', or add it to the ANSICON_GUI variable (see + ANSICON_API below). + + Using `ansicon' after install will always start with the default attrib- + utes, restoring the originals on exit; all other programs will use the + current attributes. The shift state is always reset for a new process. + + The Windows API WriteFile and WriteConsoleA functions will set the num- + ber of characters written, not the number of bytes. When using a multi- + byte character set, this results in a smaller number (since multiple + bytes are used to represent a single character). Some programs recog- + nise this as a reduced write and will inadvertently repeat previous + characters. If you discover such a program, use the ANSICON_API envir- + onment variable to record it and override the API, returning the origin- + al byte count. Ruby is an example of such a program (at least, up till + 1.9.2p0), so use "set ANSICON_API=ruby" to avoid the repitition. The + full syntax of the variable is: + + ANSICON_API=[!]program;program;program... + + PROGRAM is the name of the program, with no path and extension. The + leading exclamation inverts the usage, meaning the API will always be + overridden, unless the program is in the list. The variable can be made + permanent by going to System Properties, selecting the Advanced tab and + clicking Environment Variables (using XP; Vista/7 may be different). + + + ==================== + Sequences Recognised + ==================== + + The following escape sequences are recognised. + + \e]0;titleBEL Set (xterm) window's title (and icon) + \e[21t Report (xterm) window's title + \e[s Save Cursor + \e[u Restore Cursor + \e[#G CHA Cursor Character Absolute + \e[#E CNL Cursor Next Line + \e[#F CPL Cursor Preceding Line + \e[#D CUB Cursor Left + \e[#B CUD Cursor Down + \e[#C CUF Cursor Right + \e[#;#H CUP Cursor Position + \e[#A CUU Cursor Up + \e[#P DCH Delete Character + \e[?25h DECTCEM DEC Text Cursor Enable Mode (show cursor) + \e[?25l DECTCEM DEC Text Cursor Enable Mode (hide cursor) + \e[#M DL Delete Line + \e[#n DSR Device Status Report + \e[#X ECH Erase Character + \e[#J ED Erase In Page + \e[#K EL Erase In Line + \e[#` HPA Character Position Absolute + \e[#j HPB Character Position Backward + \e[#a HPR Character Position Forward + \e[#;#f HVP Character And Line Position + \e[#@ ICH Insert Character + \e[#L IL Insert Line + SI LS0 Locking-shift Zero (see below) + SO LS1 Locking-shift One + \e[#;#;#m SGR Select Graphic Rendition + \e[#d VPA Line Position Absolute + \e[#k VPB Line Position Backward + \e[#e VPR Line Position Forward + + `\e' represents the escape character (ASCII 27); `#' represents a + decimal number (optional, in most cases defaulting to 1); BEL, SO and + SI are ASCII 7, 14 and 15. Regarding SGR: bold will set the foreground + intensity; underline and blink will set the background intensity; + conceal uses background as foreground. + + I make a distinction between "\e[m" and "\e[0;...m". Both will restore + the original foreground/background colors (and so "0" should be the + first parameter); the former will also restore the original bold and + underline attributes, whilst the latter will explicitly reset them. The + environment variable ANSICON_DEF can be used to change the default col- + ors (same value as `-m'; setting the variable does not change the cur- + rent colors). + + + ================= + Sequences Ignored + ================= + + The following escape sequences are explicitly ignored. + + \e(? Designate G0 character set (`?' is anything). + \e)? Designate G1 character set (`?' is anything). + \e[?... Private sequence + \e[>... Private sequence + + The G0 character set is always ASCII; the G1 character set is always + the DEC Special Graphics Character Set. + + + ================================== + DEC Special Graphics Character Set + ================================== + + This is my interpretation of the set, as shown by + http://vt100.net/docs/vt220-rm/table2-4.html. + + + Char Unicode Code Point & Name + ---- ------------------------- + _ U+0020 Space (blank) + ` U+2666 Black Diamond Suit + a U+2592 Medium Shade + b U+2409 Symbol For Horizontal Tabulation + c U+240C Symbol For Form Feed + d U+240D Symbol For Carriage Return + e U+240A Symbol For Line Feed + f U+00B0 Degree Sign + g U+00B1 Plus-Minus Sign + h U+2424 Symbol For Newline + i U+240B Symbol For Vertical Tabulation + j U+2518 Box Drawings Light Up And Left + k U+2510 Box Drawings Light Down And Left + l U+250C Box Drawings Light Down And Right + m U+2514 Box Drawings Light Up And Right + n U+253C Box Drawings Light Vertical And Horizontal + o U+00AF Macron (SCAN 1) + p U+25AC Black Rectangle (SCAN 3) + q U+2500 Box Drawings Light Horizontal (SCAN 5) + r U+005F Low Line (SCAN 7) + s U+005F Low Line (SCAN 9) + t U+251C Box Drawings Light Vertical And Right + u U+2524 Box Drawings Light Vertical And Left + v U+2534 Box Drawings Light Up And Horizontal + w U+252C Box Drawings Light Down And Horizontal + x U+2502 Box Drawings Light Vertical + y U+2264 Less-Than Or Equal To + z U+2265 Greater-Than Or Equal To + { U+03C0 Greek Small Letter Pi + | U+2260 Not Equal To + } U+00A3 Pound Sign + ~ U+00B7 Middle Dot + + + G1.txt is a Unicode file to view the glyphs "externally". G1.bat is a + batch file (using `x86\ansicon') to show the glyphs in the console. The + characters will appear as they should using Lucida (other than the Sym- + bols), but code page will influence them when using a raster font (but + of particular interest, 437 and 850 both show the Box Drawings). + + + =========== + Limitations + =========== + + The entire console buffer is used, not just the visible window. + + Building rubyinstaller on Win7 crashes (XP is fine). + + + =============== + Version History + =============== + + Legend: + added, - bug-fixed, * changed. + + 1.53 - 12 June, 2012: + - fix for multiple simultaneous process creation (e.g. "cl /MP ..."). + + 1.52 - 2 June, 2012: + + 32-bit processes can inject into 64-bit processes; + + implemented \e[39m & \e[49m (set default foreground/background color); + + added \e[#X, \e[#`, \e[#a, \e[#d, \e[#e, \[e#j and \e[#k; + * changed sequence descriptions to those in ECMA-48, ordered by acronym. + + 1.51 - 24 February, 2012: + - fixed installing into a piped/redirected CMD.EXE; + - fixed 32-bit process trying to identify a 64-bit process; + - ignore version within core API DLL names (now Win8 works); + + hook _lwrite & _hwrite (now Silverfrost FTN95 v6.20 works). + + 1.50 - 14 December, 2011: + - -u does not imply -p; + - return the program's exit code; + - -p by itself will not restore original color; + - output error messages to stderr; + * logging is always available, with various levels; include the pid; + * don't automatically hook GUI programs, use `ansicon' or ANSICON_GUI; + * always place first in AutoRun; don't run if already installed; + + global reverse video capability; + + added ANSICON_VER to provide version/install test; + + added ANSICON_EXC to exclude selected modules; + + added ANSICON_DEF to explicitly set the default SGM. + + 1.40 - 1 March, 2011: + - hook GetProcAddress (now PowerShell works); + + add SO/SI, using the DEC Special Graphics Character Set for G1; + + add DECTCEM to show/hide the cursor. + + 1.32 - 22 December, 2010: + - fixed crash due to NULL lpNumberOfBytesWritten/lpNumberOfCharsWritten; + - -p will test the parent process for validity; + * hook into GUI processes; + + recognise DSR and xterm window title sequences; + - fixed MinGW32 binaries (LLW was wrong). + + 1.31 - 19 November, 2010: + - fixed multibyte support (no extra junk with UTF-8 files); + * provide workaround for API byte/character differences; + * fixed potential problem if install path uses Unicode. + + 1.30 - 7 September, 2010: + + x64 version. + + 1.25 - 22 July, 2010: + - hook LoadLibraryEx (now CScript works); + - fixed -i when AutoRun existed, but was empty; + + support for Windows 7; + + -I (and -U) use HKEY_LOCAL_MACHINE. + + 1.24 - 7 January, 2010: + - fix -t and -e when ANSICON was already running; + + read standard input if redirected with no arguments, if -t has no + files, or if the name is "-" (which also serves as a workaround for + programs that don't get hooked, such as CScript). + + 1.23 - 11 November, 2009: + - restore hooked functions when unloading; + - reverse the "bold" and "underline" settings; + * conceal characters by making foreground color same as background. + + 1.22 - 5 October, 2009: + - hook LoadLibrary to inject into applications started via association. + + 1.21 - 23 September, 2009: + + -i (and -u) option to add (remove) entry to AutoRun value. + + 1.20 - 21 June, 2009: + * use another injection method; + + create ANSICON environment variable; + + -e (and -E) option to echo the command line (without newline); + + -t (and -T) option to type (display) files (with file name). + + 1.15 - 17 May, 2009: + - fix output corruption for long (over 8192 characters) ANSI strings. + + 1.14 - 3 April, 2009: + - fix the test for an empty import section (eg. XCOPY now works). + + 1.13 - 21 & 27 March, 2009: + * use a new injection method (to work with DEP); + * use Unicode. + + 1.12 - 9 March, 2009: + - fix processing child programs (generate a relocatable DLL). + + 1.11 - 28 February, 2009: + - fix processing child programs (only use for console executables). + + 1.10 - 22 February, 2009: + - fix output corruption (buffer overflow in MyConsoleWriteW); + - recognise current screen attributes as current ANSI atrributes; + - ignore Ctrl+C and Ctrl+Break; + + process child programs. + + 1.01 - 12 March, 2006: + * \e[m will restore original color, not set grey on black; + + -m option to set default (and initial) color; + - restore original color on exit; + - disable escape processing when console has disabled processed output; + + \e[5m (blink) is the same as \e[4m (underline); + - do not conceal control characters (0 to 31). + + 1.00 - 23 October, 2005: + + initial release. + + + =============== + Acknowledgments + =============== + + Jean-Louis Morel, for his Perl package Win32::Console::ANSI. It + provided the basis of `ANSI.dll'. + + Sergey Oblomov (hoopoepg), for Console Manager. It provided the basis + of `ansicon.exe'. + + Anton Bassov's article "Process-wide API spying - an ultimate hack" in + "The Code Project". + + Richard Quadling - his persistence in finding bugs has made ANSICON + what it is today. + + Dmitry Menshikov, Marko Bozikovic and Philippe Villiers, for their + assistance in making the 64-bit version a reality. + + Luis Lavena and the Ruby people for additional improvements. + + Leigh Hebblethwaite for documentation tweaks. + + + ======= + Contact + ======= + + mailto:jadoxa@yahoo.com.au + http://ansicon.adoxa.cjb.net/ + https://github.com/adoxa/ansicon + + Jason Hood + 11 Buckle Street + North Rockhampton + Qld 4701 + Australia + + + ============ + Distribution + ============ + + The original zipfile can be freely distributed, by any means. However, + I would like to be informed if it is placed on a CD-ROM (other than an + archive compilation; permission is granted, I'd just like to know). + Modified versions may be distributed, provided it is indicated as such + in the version text and a source diff is included. + + + ========================== + Jason Hood, 12 June, 2012. diff --git a/ansicon/util.c b/ansicon/util.c new file mode 100755 index 0000000..461b7b6 --- /dev/null +++ b/ansicon/util.c @@ -0,0 +1,128 @@ +/* + util.c - Utility functions. +*/ + +#include "ansicon.h" +#include "version.h" + + +TCHAR prog_path[MAX_PATH]; +LPTSTR prog; +int log_level; +char tempfile[MAX_PATH]; +DWORD pid; + + +// Get just the name of the program: "C:\path\program.exe" -> "program". +// Returns a pointer within program; it is modified to remove the extension. +LPTSTR get_program_name( LPTSTR program ) +{ + LPTSTR name, ext; + + if (program == NULL) + { + GetModuleFileName( NULL, prog_path, lenof(prog_path) ); + program = prog_path; + } + name = wcsrchr( program, '\\' ); + if (name != NULL) + ++name; + else + name = program; + ext = wcsrchr( name, '.' ); + if (ext != NULL && ext != name) + *ext = '\0'; + + return name; +} + + +void DEBUGSTR( int level, LPTSTR szFormat, ... ) +{ + TCHAR szBuffer[1024], szEscape[1024]; + va_list pArgList; + HANDLE mutex; + DWORD wait; + FILE* file; + + if ((log_level & 3) < level && !(level & 4 & log_level)) + return; + + if (*tempfile == '\0') + { + _snprintf( tempfile, MAX_PATH, "%s\\ansicon.log", getenv( "TEMP" ) ); + pid = GetCurrentProcessId(); + } + if (szFormat == NULL) + { + file = fopen( tempfile, "wt" ); + if (file != NULL) + { + SYSTEMTIME now; + GetLocalTime( &now ); + fprintf( file, "ANSICON v" PVERSA " log (%d) started " + "%d-%.2d-%.2d %d:%.2d:%.2d\n", + log_level, + now.wYear, now.wMonth, now.wDay, + now.wHour, now.wMinute, now.wSecond ); + fclose( file ); + } + return; + } + + va_start( pArgList, szFormat ); + _vsnwprintf( szBuffer, lenof(szBuffer), szFormat, pArgList ); + va_end( pArgList ); + + szFormat = szBuffer; + if (*szFormat == '\33') + { + BOOL first = TRUE; + LPTSTR pos = szEscape; + while (*++szFormat != '\0' && pos < szEscape + lenof(szEscape) - 4) + { + if (*szFormat < 32) + { + *pos++ = '\\'; + switch (*szFormat) + { + case '\a': *pos++ = 'a'; break; + case '\b': *pos++ = 'b'; break; + case '\t': *pos++ = 't'; break; + case '\r': *pos++ = 'r'; break; + case '\n': *pos++ = 'n'; break; + case 27 : *pos++ = 'e'; break; + default: + pos += _snwprintf( pos, 32, L"%.*o", + (szFormat[1] >= '0' && szFormat[1] <= '7') ? 3 : 1, + *szFormat ); + } + } + else + { + if (*szFormat == '"') + { + if (first) + first = FALSE; + else if (szFormat[1] != '\0') + *pos++ = '\\'; + } + *pos++ = *szFormat; + } + } + *pos = '\0'; + szFormat = szEscape; + } + + mutex = CreateMutex( NULL, FALSE, L"ANSICON_debug_file" ); + wait = WaitForSingleObject( mutex, 500 ); + file = fopen( tempfile, "at" ); // _fmode might be binary + if (file != NULL) + { + fwprintf( file, L"%s (%lu): %s\n", prog, pid, szFormat ); + fclose( file ); + } + if (wait == WAIT_OBJECT_0) + ReleaseMutex( mutex ); + CloseHandle( mutex ); +} diff --git a/ansicon/version.h b/ansicon/version.h new file mode 100755 index 0000000..ff76004 --- /dev/null +++ b/ansicon/version.h @@ -0,0 +1,9 @@ +/* + version.h - Version defines. +*/ + +#define PVERS L"1.53" // wide string +#define PVERSA "1.53" // ANSI string (windres 2.16.91 didn't like L) +#define PVERE L"153" // wide environment string +#define PVEREA "153" // ANSI environment string +#define PVERB 1,5,3,0 // binary (resource) diff --git a/ansicon/wow64.h b/ansicon/wow64.h new file mode 100755 index 0000000..33e0444 --- /dev/null +++ b/ansicon/wow64.h @@ -0,0 +1,88 @@ +/* + wow64.h - Definitions for Wow64. + + Mingw64/TDM does not include these Wow64 definitions. +*/ + +#ifndef WOW64_H +#define WOW64_H + +#define WIN32_LEAN_AND_MEAN +#include + +#define WOW64_CONTEXT_i386 0x00010000 + +#define WOW64_CONTEXT_CONTROL (WOW64_CONTEXT_i386 | 0x00000001L) +#define WOW64_CONTEXT_INTEGER (WOW64_CONTEXT_i386 | 0x00000002L) +#define WOW64_CONTEXT_SEGMENTS (WOW64_CONTEXT_i386 | 0x00000004L) +#define WOW64_CONTEXT_FLOATING_POINT (WOW64_CONTEXT_i386 | 0x00000008L) +#define WOW64_CONTEXT_DEBUG_REGISTERS (WOW64_CONTEXT_i386 | 0x00000010L) +#define WOW64_CONTEXT_EXTENDED_REGISTERS (WOW64_CONTEXT_i386 | 0x00000020L) + +#define WOW64_CONTEXT_FULL (WOW64_CONTEXT_CONTROL | WOW64_CONTEXT_INTEGER | WOW64_CONTEXT_SEGMENTS) + +#define WOW64_CONTEXT_ALL (WOW64_CONTEXT_CONTROL | WOW64_CONTEXT_INTEGER | WOW64_CONTEXT_SEGMENTS | \ + WOW64_CONTEXT_FLOATING_POINT | WOW64_CONTEXT_DEBUG_REGISTERS | \ + WOW64_CONTEXT_EXTENDED_REGISTERS) + +#define WOW64_SIZE_OF_80387_REGISTERS 80 + +#define WOW64_MAXIMUM_SUPPORTED_EXTENSION 512 + +typedef struct _WOW64_FLOATING_SAVE_AREA { + DWORD ControlWord; + DWORD StatusWord; + DWORD TagWord; + DWORD ErrorOffset; + DWORD ErrorSelector; + DWORD DataOffset; + DWORD DataSelector; + BYTE RegisterArea[WOW64_SIZE_OF_80387_REGISTERS]; + DWORD Cr0NpxState; +} WOW64_FLOATING_SAVE_AREA; + +typedef WOW64_FLOATING_SAVE_AREA *PWOW64_FLOATING_SAVE_AREA; + +typedef struct _WOW64_CONTEXT { + + DWORD ContextFlags; + + DWORD Dr0; + DWORD Dr1; + DWORD Dr2; + DWORD Dr3; + DWORD Dr6; + DWORD Dr7; + + WOW64_FLOATING_SAVE_AREA FloatSave; + + DWORD SegGs; + DWORD SegFs; + DWORD SegEs; + DWORD SegDs; + + DWORD Edi; + DWORD Esi; + DWORD Ebx; + DWORD Edx; + DWORD Ecx; + DWORD Eax; + + DWORD Ebp; + DWORD Eip; + DWORD SegCs; + DWORD EFlags; + DWORD Esp; + DWORD SegSs; + + BYTE ExtendedRegisters[WOW64_MAXIMUM_SUPPORTED_EXTENSION]; + +} WOW64_CONTEXT; + +typedef WOW64_CONTEXT *PWOW64_CONTEXT; + + +typedef BOOL (WINAPI *TWow64GetThreadContext)( HANDLE hThread, PWOW64_CONTEXT lpContext ); +typedef BOOL (WINAPI *TWow64SetThreadContext)( HANDLE hThread, CONST WOW64_CONTEXT *lpContext ); + +#endif diff --git a/debian/changelog b/debian/changelog new file mode 100644 index 0000000..5d47358 --- /dev/null +++ b/debian/changelog @@ -0,0 +1,7 @@ +sdbd (0.0.1-1) unstable; urgency=low + + * Initial upload + * Git: 165.213.180.234:slp/pkgs/s/sdbd + * Tag: sdbd_0.0.1-1 + + -- Joogwan Kim Sat, 26 Sep 2011 15:00:56 +0900 diff --git a/debian/compat b/debian/compat new file mode 100644 index 0000000..7813681 --- /dev/null +++ b/debian/compat @@ -0,0 +1 @@ +5 \ No newline at end of file diff --git a/debian/control b/debian/control new file mode 100644 index 0000000..aa3ba16 --- /dev/null +++ b/debian/control @@ -0,0 +1,10 @@ +Source: sdbd +Section: net +Priority: extra +Maintainer: Kangho Kim , Yoonki Park , Ho Namkoong +Build-Depends: debhelper (>= 5), libc6-dev +Standards-Version: 0.0.1 + +Package: sdbd +Architecture: any +Description: SDB daemon diff --git a/debian/rules b/debian/rules new file mode 100755 index 0000000..6ebe31f --- /dev/null +++ b/debian/rules @@ -0,0 +1,44 @@ +#!/usr/bin/make -f + +UNAME := $(shell uname -sm) +ifneq (,$(findstring 86,$(UNAME))) + HOST_ARCH := x86 +endif + +configure: configure-stamp + +configure-stamp: + dh_testdir + touch configure-stamp + +build: build-stamp + +build-stamp: configure-stamp + dh_testdir + $(MAKE) + touch build-stamp + +install: build + dh_testdir + dh_testroot + $(MAKE) DESTDIR=$(CURDIR)/debian/tmp install + +binary: build install + dh_testdir + dh_testroot +ifeq ($(HOST_ARCH),x86) + dh_install --sourcedir=debian/tmp +else + dh_install --sourcedir=debian/tmp -XS06sdbd +endif + dh_strip + dh_gencontrol + dh_md5sums + dh_builddeb + +clean: + dh_testdir + rm -f build-stamp configure-stamp + $(MAKE) clean + dh_clean + diff --git a/debian/sdbd.install b/debian/sdbd.install new file mode 100644 index 0000000..5ac7294 --- /dev/null +++ b/debian/sdbd.install @@ -0,0 +1,3 @@ +usr/sbin/sdbd +etc/init.d/sdbd +etc/rc.d/rc3.d/S06sdbd diff --git a/package/build.linux b/package/build.linux new file mode 100755 index 0000000..800284f --- /dev/null +++ b/package/build.linux @@ -0,0 +1,80 @@ +#!/bin/bash +# clean +clean() +{ + echo "=========================================CLEAN============================================" + make clean + rm -rf ${SRCDIR}/*.zip + rm -rf ${SRCDIR}/*.tar.gz +} + +# build +build() +{ + pkgname_and_platform_list=`awk 'BEGIN{RS="\n\n"; FS="\n"} /Package:/{for(i=1;i, Yoonki Park, Hyunsik Noh, Gun Kim, Ho Namkoong, Taeyoung Son + +Package:sdb +OS:ubuntu-32 +Build-host-os:ubuntu-32 +Description:Smart Development Bridge for device management + +Package:sdb +OS:windows-32 +Build-host-os:windows-32 +Description:Smart Development Bridge for device management + +Package:sdb +OS:ubuntu-64 +Build-host-os:ubuntu-64 +Description:Smart Development Bridge for device management + +Package:sdb +OS:windows-64 +Build-host-os:windows-64 +Description:Smart Development Bridge for device management + +Package:sdb +OS:macos-64 +Build-host-os:macos-64 +Description:Smart Development Bridge for device management + +Package:usb-connection-for-ssh +OS:ubuntu-32 +Build-host-os:ubuntu-32 +Description: udev setting package for usb connection. + +Package:usb-connection-for-ssh +OS:ubuntu-64 +Build-host-os:ubuntu-64 +Description: udev setting package for usb connection. diff --git a/package/sdb-run.bat b/package/sdb-run.bat new file mode 100755 index 0000000..7dc6f60 --- /dev/null +++ b/package/sdb-run.bat @@ -0,0 +1,25 @@ +@echo off +set SCRIPT=%0 + +:: delims is a TAB followed by a space +set KEY=TIZEN_SDK_INSTALLED_PATH + +REM find sdk path +set rkey="HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders" +set rval="Local AppData" +FOR /f "tokens=3*" %%a IN ('reg query %rkey% /v %rval%') DO ( + set sdk_conf_path=%%b +) + +REM find cli path +FOR /f "tokens=1,2 delims==" %%i IN ('type "%sdk_conf_path%\tizen-sdk-data\tizensdkpath"') DO IF %%i==%KEY% (set SDK_PATH=%%j) +set TOOLS_HOME=%SDK_PATH%\tools + +if "%1" == "-s" ( +title sdb - %2 +) else ( +title sdb +) + +set EXEC=%TOOLS_HOME%\ansicon.exe %TOOLS_HOME%\sdb.exe %* +%EXEC% diff --git a/package/sdb.install.darwin b/package/sdb.install.darwin new file mode 100755 index 0000000..76df931 --- /dev/null +++ b/package/sdb.install.darwin @@ -0,0 +1,18 @@ +#!/bin/bash -x + +## Set sdb's environment path +s=`cat ${HOME}/.bashrc | grep -n "## Tizen SDK configuration" | cut -f1 -d":"` + +if [ "x${s}" = "x" ] ; then + cat >> ${HOME}/.bashrc << END +## Tizen SDK configuration +# This is generated by Tizen SDK. Please do not modify by yourself. +# Set sdb environment path +export PATH=\$PATH:${INSTALLED_PATH}/tools +## End Tizen SDK configuration +END +fi + +source ${HOME}/.bashrc + +exit 0 diff --git a/package/sdb.install.linux b/package/sdb.install.linux new file mode 100755 index 0000000..76df931 --- /dev/null +++ b/package/sdb.install.linux @@ -0,0 +1,18 @@ +#!/bin/bash -x + +## Set sdb's environment path +s=`cat ${HOME}/.bashrc | grep -n "## Tizen SDK configuration" | cut -f1 -d":"` + +if [ "x${s}" = "x" ] ; then + cat >> ${HOME}/.bashrc << END +## Tizen SDK configuration +# This is generated by Tizen SDK. Please do not modify by yourself. +# Set sdb environment path +export PATH=\$PATH:${INSTALLED_PATH}/tools +## End Tizen SDK configuration +END +fi + +source ${HOME}/.bashrc + +exit 0 diff --git a/package/sdb.remove.darwin b/package/sdb.remove.darwin new file mode 100755 index 0000000..7d0ea0f --- /dev/null +++ b/package/sdb.remove.darwin @@ -0,0 +1,22 @@ +#!/bin/sh +SDB_PATH=tools/sdb +${INSTALLED_PATH}/${SDB_PATH} kill-server +rm -rf ${INSTALLED_PATH}/${SDB_PATH} +## remove sdb environment path +s=`cat ${HOME}/.bashrc | grep -n "## Tizen SDK configuration" | cut -f1 -d":"` + +if [ "x${s}" = "x" ] ; then + exit 1 +fi + +if [ ${s} -ge 0 ] ; then + e=`cat ${HOME}/.bashrc | grep -n "## End Tizen SDK configuration" | cut -f1 -d":"` + if [ $e -ge $s ] ; then + cp ${HOME}/.bashrc ${HOME}/.bashrc.tizen + sed "${s},${e}d" ${HOME}/.bashrc > ${HOME}/.bashrc.swap + mv ${HOME}/.bashrc.swap ${HOME}/.bashrc + source ${HOME}/.bashrc + fi +fi + +exit 0 diff --git a/package/sdb.remove.linux b/package/sdb.remove.linux new file mode 100755 index 0000000..7d0ea0f --- /dev/null +++ b/package/sdb.remove.linux @@ -0,0 +1,22 @@ +#!/bin/sh +SDB_PATH=tools/sdb +${INSTALLED_PATH}/${SDB_PATH} kill-server +rm -rf ${INSTALLED_PATH}/${SDB_PATH} +## remove sdb environment path +s=`cat ${HOME}/.bashrc | grep -n "## Tizen SDK configuration" | cut -f1 -d":"` + +if [ "x${s}" = "x" ] ; then + exit 1 +fi + +if [ ${s} -ge 0 ] ; then + e=`cat ${HOME}/.bashrc | grep -n "## End Tizen SDK configuration" | cut -f1 -d":"` + if [ $e -ge $s ] ; then + cp ${HOME}/.bashrc ${HOME}/.bashrc.tizen + sed "${s},${e}d" ${HOME}/.bashrc > ${HOME}/.bashrc.swap + mv ${HOME}/.bashrc.swap ${HOME}/.bashrc + source ${HOME}/.bashrc + fi +fi + +exit 0 diff --git a/package/sdb.remove.windows b/package/sdb.remove.windows new file mode 100644 index 0000000..88ae1bc --- /dev/null +++ b/package/sdb.remove.windows @@ -0,0 +1,10 @@ +@echo off + +set execute_path=tools +%INSTALLED_PATH%\%execute_path%\sdb.exe kill-server +del %INSTALLED_PATH%\%execute_path%\sdb.exe +del %INSTALLED_PATH%\%execute_path%\SdbWinApi.dll +del %INSTALLED_PATH%\%execute_path%\SdbWinUsbApi.dll +del %INSTALLED_PATH%\%execute_path%\ansicon.exe +del %INSTALLED_PATH%\%execute_path%\ANSI32.dll +exit 0 diff --git a/package/usb-connection-for-ssh.install.linux b/package/usb-connection-for-ssh.install.linux new file mode 100755 index 0000000..b314d9d --- /dev/null +++ b/package/usb-connection-for-ssh.install.linux @@ -0,0 +1,8 @@ +#!/bin/bash + +samsung_udev="99-samsung-device.rules" +rules_dir=${INSTALLED_PATH}/tools/ssh +rules_path=${rules_dir}/${samsung_udev} + +sed "s|TIZEN_SDK_SSH_PATH|${rules_dir}|g" ${rules_path} > ${rules_path}.mod +mv ${rules_path}.mod ${rules_path} diff --git a/script/S06sdbd b/script/S06sdbd new file mode 100755 index 0000000..6a05d55 --- /dev/null +++ b/script/S06sdbd @@ -0,0 +1,2 @@ +#!/bin/sh +/etc/init.d/sdbd start diff --git a/script/sdbd b/script/sdbd new file mode 100755 index 0000000..85a868c --- /dev/null +++ b/script/sdbd @@ -0,0 +1,39 @@ +#! /bin/sh + +. /lib/lsb/init-functions + +export PATH="${PATH:+$PATH:}/usr/sbin:/sbin" + +case "$1" in + start) + log_daemon_msg "Starting SDB Daemon..." "sdbd" + if start-stop-daemon --start --quiet --background --make-pidfile --pidfile /var/run/sdbd.pid --exec /usr/sbin/sdbd; then + log_end_msg 0 + else + log_end_msg 1 + fi + ;; + stop) + log_daemon_msg "Stopping SDB Daemon..." "sdbd" + if start-stop-daemon --stop --quiet --oknodo --pidfile /var/run/sdbd.pid; then + log_end_msg 0 + else + log_end_msg 1 + fi + ;; + restart) + log_daemon_msg "Restarting SDB Daemon..." "sdbd" + start-stop-daemon --stop --quiet --oknodo --retry 30 --pidfile /var/run/sdbd.pid + sleep 1 + if start-stop-daemon --start --quiet --background --make-pidfile --pidfile /var/run/sdbd.pid --exec /usr/sbin/sdbd; then + log_end_msg 0 + else + log_end_msg 1 + fi + ;; + *) + log_action_msg "Usage: /etc/init.d/sdbd {start|stop|restart}" + exit 1 +esac + +exit 0 diff --git a/src/Android.mk b/src/Android.mk new file mode 100644 index 0000000..7faca9b --- /dev/null +++ b/src/Android.mk @@ -0,0 +1,154 @@ +# Copyright 2005 The Android Open Source Project +# +# Android.mk for adb +# + +LOCAL_PATH:= $(call my-dir) + +# adb host tool +# ========================================================= +include $(CLEAR_VARS) + +# Default to a virtual (sockets) usb interface +USB_SRCS := +EXTRA_SRCS := + +ifeq ($(HOST_OS),linux) + USB_SRCS := usb_linux.c + EXTRA_SRCS := get_my_path_linux.c + LOCAL_LDLIBS += -lrt -lncurses -lpthread +endif + +ifeq ($(HOST_OS),darwin) + USB_SRCS := usb_osx.c + EXTRA_SRCS := get_my_path_darwin.c + LOCAL_LDLIBS += -lpthread -framework CoreFoundation -framework IOKit -framework Carbon +endif + +ifeq ($(HOST_OS),freebsd) + USB_SRCS := usb_libusb.c + EXTRA_SRCS := get_my_path_freebsd.c + LOCAL_LDLIBS += -lpthread -lusb +endif + +ifeq ($(HOST_OS),windows) + USB_SRCS := usb_windows.c + EXTRA_SRCS := get_my_path_windows.c + EXTRA_STATIC_LIBS := AdbWinApi + ifneq ($(strip $(USE_CYGWIN)),) + # Pure cygwin case + LOCAL_LDLIBS += -lpthread + LOCAL_C_INCLUDES += /usr/include/w32api/ddk + endif + ifneq ($(strip $(USE_MINGW)),) + # MinGW under Linux case + LOCAL_LDLIBS += -lws2_32 + USE_SYSDEPS_WIN32 := 1 + LOCAL_C_INCLUDES += /usr/i586-mingw32msvc/include/ddk + endif + LOCAL_C_INCLUDES += development/host/windows/usb/api/ +endif + +LOCAL_SRC_FILES := \ + adb.c \ + console.c \ + transport.c \ + transport_local.c \ + transport_usb.c \ + commandline.c \ + adb_client.c \ + sockets.c \ + services.c \ + file_sync_client.c \ + $(EXTRA_SRCS) \ + $(USB_SRCS) \ + utils.c \ + usb_vendors.c + + +ifneq ($(USE_SYSDEPS_WIN32),) + LOCAL_SRC_FILES += sysdeps_win32.c +else + LOCAL_SRC_FILES += fdevent.c +endif + +LOCAL_CFLAGS += -O2 -g -DADB_HOST=1 -Wall -Wno-unused-parameter +LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE +LOCAL_MODULE := adb + +LOCAL_STATIC_LIBRARIES := libzipfile libunz $(EXTRA_STATIC_LIBS) +ifeq ($(USE_SYSDEPS_WIN32),) + LOCAL_STATIC_LIBRARIES += libcutils +endif + +include $(BUILD_HOST_EXECUTABLE) + +$(call dist-for-goals,droid,$(LOCAL_BUILT_MODULE)) + +ifeq ($(HOST_OS),windows) +$(LOCAL_INSTALLED_MODULE): \ + $(HOST_OUT_EXECUTABLES)/AdbWinApi.dll \ + $(HOST_OUT_EXECUTABLES)/AdbWinUsbApi.dll +endif + + +# adbd device daemon +# ========================================================= + +# build adbd in all non-simulator builds +BUILD_ADBD := false +ifneq ($(TARGET_SIMULATOR),true) + BUILD_ADBD := true +endif + +# build adbd for the Linux simulator build +# so we can use it to test the adb USB gadget driver on x86 +#ifeq ($(HOST_OS),linux) +# BUILD_ADBD := true +#endif + + +ifeq ($(BUILD_ADBD),true) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES := \ + adb.c \ + fdevent.c \ + transport.c \ + transport_local.c \ + transport_usb.c \ + sockets.c \ + services.c \ + file_sync_service.c \ + jdwp_service.c \ + framebuffer_service.c \ + remount_service.c \ + usb_linux_client.c \ + log_service.c \ + utils.c + +LOCAL_CFLAGS := -O2 -g -DADB_HOST=0 -Wall -Wno-unused-parameter +LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE + +# TODO: This should probably be board specific, whether or not the kernel has +# the gadget driver; rather than relying on the architecture type. +ifeq ($(TARGET_ARCH),arm) +LOCAL_CFLAGS += -DANDROID_GADGET=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) + +ifeq ($(TARGET_SIMULATOR),true) + LOCAL_STATIC_LIBRARIES := libcutils + LOCAL_LDLIBS += -lpthread + include $(BUILD_HOST_EXECUTABLE) +else + LOCAL_STATIC_LIBRARIES := libcutils libc + include $(BUILD_EXECUTABLE) +endif + +endif diff --git a/src/MODULE_LICENSE_APACHE2 b/src/MODULE_LICENSE_APACHE2 new file mode 100644 index 0000000..e69de29 diff --git a/src/NOTICE b/src/NOTICE new file mode 100644 index 0000000..9ffcc08 --- /dev/null +++ b/src/NOTICE @@ -0,0 +1,191 @@ + + 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 + diff --git a/src/OVERVIEW.TXT b/src/OVERVIEW.TXT new file mode 100644 index 0000000..0d9784a --- /dev/null +++ b/src/OVERVIEW.TXT @@ -0,0 +1,139 @@ +Implementation notes regarding SDB. + +I. General Overview: + +The Android Debug Bridge (SDB) 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. "sdb shell", "sdb pull", etc..) + for the benefit of clients (command-line users, or helper programs like + DDMS). These commands are what is called a 'service' in SDB. + +As a whole, everything works through the following components: + + 1. The SDB 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 SDB 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 SDB daemon (sdbd) + + The 'sdbd' program runs as a background process within an Android device + or emulated system. Its purpose is to connect to the SDB server + (through USB for devices, through TCP for emulators) and provide a + few services for clients that run on the host. + + The SDB server considers that a device is ONLINE when it has successfully + connected to the sdbd program within it. Otherwise, the device is OFFLINE, + meaning that the SDB server detected a new device/emulator, but could not + connect to the sdbd daemon. + + the BOOTLOADER and RECOVERY states correspond to alternate states of + devices when they are in the bootloader or recovery mode. + + 3. The SDB command-line client + + The 'sdb' command-line program is used to run sdb commands from a shell + or a script. It first tries to locate the SDB server on the host machine, + and will start one automatically if none is found. + + then, the client sends its service requests to the SDB server. It doesn't + need to know. + + Currently, a single 'sdb' 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 SDB Server and thus do not need to + communicate with a device at all. A typical example is "sdb 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 sdbd daemon, or are started by + it on the device. The SDB server is used to multiplex streams + between the client and the service running in sdbd. 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 SDB clients and the SDB + server itself. The SDB 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 SDB 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 sdbd daemon. + + The file SERVICES.TXT lists all services currently implemented by SDB. + + + 2. Transports: + + An SDB transport models a connection between the SDB 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 SDB 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 SDB server must handle + unexpected transport disconnections (e.g. when a device is physically + unplugged) properly. diff --git a/src/SERVICES.TXT b/src/SERVICES.TXT new file mode 100644 index 0000000..3bfbe37 --- /dev/null +++ b/src/SERVICES.TXT @@ -0,0 +1,236 @@ +This file tries to document all requests a client can make +to the SDB server of an sdbd daemon. See the OVERVIEW.TXT document +to understand what's going on here. + +HOST SERVICES: + +host:version + Ask the SDB 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 SDB server to quit immediately. This is used when the + SDB client detects that an obsolete server is running after an + upgrade. + +host:devices + Ask to return the list of available Android devices and their + 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 SDB server when a + new emulator starts up. is a decimal number corresponding + to the emulator's SDB control port, i.e. the TCP port that the + emulator will forward automatically to the sdbd daemon running + in the emulator system. + + This mechanism allows the SDB 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 sdbd 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 SDB 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-state + Returns the state of a given device as a string. + +:forward:; + Asks the SDB 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. + + + +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 "sdb shell" + +shell: + Start an interactive shell session on the device. Redirect + stdin/stdout/stderr as appropriate. Note that the SDB server uses + this to implement "sdb shell", but will also cook the input before + sending it to the device (see interactive_shell() in commandline.c) + +remount: + Ask sdbd to remount the device's filesystem in read-write mode, + instead of read-only. This is usually necessary before performing + an "sdb sync" or "sdb 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. + +log: + Opens one of the system logs (/dev/log/) and allows the client + to read them directly. Used to implement 'sdb logcat'. The stream + will be read-only for the client. + +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 sdbd daemon doesn't have sufficient privileges to open + the framebuffer device, the connection is simply closed immediately. + +dns: + This service is an exception because it only runs within the SDB server. + It is used to implement USB networking, i.e. to provide a network connection + to the device through the host machine (note: this is the exact opposite of + network tethering). + + It is used to perform a gethostbyname(
) on the host and return + the corresponding IP address as a 4-byte string. + +recover: + This service is used to upload a recovery image to the device. + must be a number corresponding to the size of the file. The service works + by: + + - creating a file named /tmp/update + - reading 'size' bytes from the client and writing them to /tmp/update + - when everything is read successfully, create a file named /tmp/update.start + + This service can only work when the device is in recovery mode. Otherwise, + the /tmp directory doesn't exist and the connection will be 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 synchronisation service, used to implement "sdb push" + and "sdb pull". Since this service is pretty complex, it will be detailed + in a companion document named SYNC.TXT diff --git a/src/TizenConfig.h b/src/TizenConfig.h new file mode 100644 index 0000000..f0bf56f --- /dev/null +++ b/src/TizenConfig.h @@ -0,0 +1,336 @@ +/* + * Copyright (C) 2005 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. + */ + +/* + * Android config -- "CYGWIN_NT-5.1". + * + * Cygwin has pthreads, but GDB seems to get confused if you use it to + * create threads. By "confused", I mean it freezes up the first time the + * debugged process creates a thread, even if you use CreateThread. The + * mere presence of pthreads linkage seems to cause problems. + */ +#ifndef _ANDROID_CONFIG_H +#define _ANDROID_CONFIG_H + +/* + * =========================================================================== + * !!! IMPORTANT !!! + * =========================================================================== + * + * This file is included by ALL C/C++ source files. Don't put anything in + * here unless you are absolutely certain it can't go anywhere else. + * + * Any C++ stuff must be wrapped with "#ifdef __cplusplus". Do not use "//" + * comments. + */ + +/* + * Threading model. Choose one: + * + * HAVE_PTHREADS - use the pthreads library. + * HAVE_WIN32_THREADS - use Win32 thread primitives. + */ +#define HAVE_WIN32_THREADS + +/* + * Do we have the futex syscall? + */ + +/* #define HAVE_FUTEX */ + + +/* + * Process creation model. Choose one: + * + * HAVE_FORKEXEC - use fork() and exec() + * HAVE_WIN32_PROC - use CreateProcess() + */ +#ifdef __CYGWIN__ +# define HAVE_FORKEXEC +#else +# define HAVE_WIN32_PROC +#endif + +/* + * Process out-of-memory adjustment. Set if running on Linux, + * where we can write to /proc//oom_adj to modify the out-of-memory + * badness adjustment. + */ +/* #define HAVE_OOM_ADJ */ + +/* + * IPC model. Choose one: + * + * HAVE_SYSV_IPC - use the classic SysV IPC mechanisms (semget, shmget). + * HAVE_MACOSX_IPC - use Macintosh IPC mechanisms (sem_open, mmap). + * HAVE_WIN32_IPC - use Win32 IPC (CreateSemaphore, CreateFileMapping). + * HAVE_ANDROID_IPC - use Android versions (?, mmap). + */ +#define HAVE_WIN32_IPC + +/* + * Memory-mapping model. Choose one: + * + * HAVE_POSIX_FILEMAP - use the Posix sys/mmap.h + * HAVE_WIN32_FILEMAP - use Win32 filemaps + */ +#ifdef __CYGWIN__ +#define HAVE_POSIX_FILEMAP +#else +#define HAVE_WIN32_FILEMAP +#endif + +/* + * Define this if you have + */ +#ifdef __CYGWIN__ +# define HAVE_TERMIO_H +#endif + +/* + * Define this if you have + */ +#ifdef __CYGWIN__ +# define HAVE_SYS_SENDFILE_H 1 +#endif + +/* + * Define this if you build against MSVCRT.DLL + */ +#ifndef __CYGWIN__ +# define HAVE_MS_C_RUNTIME +#endif + +/* + * Define this if you have sys/uio.h + */ +#ifdef __CYGWIN__ +#define HAVE_SYS_UIO_H +#endif + + +/* + * Define this if we have localtime_r(). + */ +/* #define HAVE_LOCALTIME_R */ + +/* + * Define this if we have gethostbyname_r(). + */ +/* #define HAVE_GETHOSTBYNAME_R */ + +/* + * Define this if we have ioctl(). + */ +/* #define HAVE_IOCTL */ + +/* + * Define this if we want to use WinSock. + */ +#ifndef __CYGWIN__ +#define HAVE_WINSOCK +#endif + +/* + * Define this if your platforms implements symbolic links + * in its filesystems + */ +/* #define HAVE_SYMLINKS */ + +/* + * Define this if have clock_gettime() and friends + */ +/* #define HAVE_POSIX_CLOCKS */ + +/* + * Endianness of the target machine. Choose one: + * + * HAVE_ENDIAN_H -- have endian.h header we can include. + * HAVE_LITTLE_ENDIAN -- we are little endian. + * HAVE_BIG_ENDIAN -- we are big endian. + */ +#ifdef __CYGWIN__ +#define HAVE_ENDIAN_H +#endif + +#define HAVE_LITTLE_ENDIAN + +/* + * We need to choose between 32-bit and 64-bit off_t. All of our code should + * agree on the same size. For desktop systems, use 64-bit values, + * because some of our libraries (e.g. wxWidgets) expect to be built that way. + */ +#define _FILE_OFFSET_BITS 64 +#define _LARGEFILE_SOURCE 1 + +/* + * Defined if we have the backtrace() call for retrieving a stack trace. + * Needed for CallStack to operate; if not defined, CallStack is + * non-functional. + */ +#define HAVE_BACKTRACE 0 + +/* + * Defined if we have the dladdr() call for retrieving the symbol associated + * with a memory address. If not defined, stack crawls will not have symbolic + * information. + */ +#define HAVE_DLADDR 0 + +/* + * Defined if we have the cxxabi.h header for demangling C++ symbols. If + * not defined, stack crawls will be displayed with raw mangled symbols + */ +#define HAVE_CXXABI 0 + +/* + * Define if tm struct has tm_gmtoff field + */ +/* #define HAVE_TM_GMTOFF 1 */ + +/* + * Define if dirent struct has d_type field + */ +/* #define HAVE_DIRENT_D_TYPE 1 */ + +/* + * Define if libc includes Android system properties implementation. + */ +/* #define HAVE_LIBC_SYSTEM_PROPERTIES */ + +/* + * Define if system provides a system property server (should be + * mutually exclusive with HAVE_LIBC_SYSTEM_PROPERTIES). + */ +/* #define HAVE_SYSTEM_PROPERTY_SERVER */ + +/* + * Define if we have madvise() in + */ +/*#define HAVE_MADVISE 1*/ + +/* + * Add any extra platform-specific defines here. + */ +#define WIN32 1 /* stock Cygwin doesn't define these */ +#define _WIN32 1 +#define _WIN32_WINNT 0x0500 /* admit to using >= Win2K */ + +#define HAVE_WINDOWS_PATHS /* needed by simulator */ + +/* + * What CPU architecture does this platform use? + */ +#define ARCH_X86 + +/* + * sprintf() format string for shared library naming. + */ +#define OS_SHARED_LIB_FORMAT_STR "lib%s.dll" + +/* + * type for the third argument to mincore(). + */ +#define MINCORE_POINTER_TYPE unsigned char * + +/* + * The default path separator for the platform + */ +#define OS_PATH_SEPARATOR '\\' + +/* + * Is the filesystem case sensitive? + */ +/* #define OS_CASE_SENSITIVE */ + +/* + * Define if exists. + * Cygwin has it, but not MinGW. + */ +#ifdef USE_MINGW +/* #define HAVE_SYS_SOCKET_H */ +#else +#define HAVE_SYS_SOCKET_H 1 +#endif + +/* + * Define if the strlcpy() function exists on the system. + */ +/* #define HAVE_STRLCPY 1 */ + +/* + * Define if the open_memstream() function exists on the system. + */ +/* #define HAVE_OPEN_MEMSTREAM 1 */ + +/* + * Define if the BSD funopen() function exists on the system. + */ +/* #define HAVE_FUNOPEN 1 */ + +/* + * Define if exists. + * Only MinGW has it. + */ +#ifdef USE_MINGW +#define HAVE_WINSOCK2_H 1 +#else +/* #define HAVE_WINSOCK2_H */ +#endif + +/* + * Various definitions missing in MinGW + */ +#ifdef USE_MINGW +#define S_IRGRP 0 +#endif + +/* + * Define if writev() exists. + */ +/* #define HAVE_WRITEV */ + +/* + * Define if exists. + */ +/* #define HAVE_STDINT_H */ + +/* + * Define if exists. + */ +#define HAVE_STDBOOL_H + +/* + * Define if exists. + */ +/* #define HAVE_SCHED_H */ + +/* + * Define if pread() exists + */ +/* #define HAVE_PREAD 1 */ + +/* + * Define if we have st_mtim in struct stat + */ +/* #define HAVE_STAT_ST_MTIM 1 */ + +/* + * Define if printf() supports %zd for size_t arguments + */ +/* #define HAVE_PRINTF_ZD 1 */ + +#endif /*_ANDROID_CONFIG_H*/ diff --git a/src/clear_vars.mk b/src/clear_vars.mk new file mode 100644 index 0000000..ee28f21 --- /dev/null +++ b/src/clear_vars.mk @@ -0,0 +1,107 @@ +########################################################### +## Clear out values of all variables used by rule templates. +########################################################### + +LOCAL_MODULE:= +LOCAL_MODULE_PATH:= +LOCAL_MODULE_STEM:= +LOCAL_DONT_CHECK_MODULE:= +LOCAL_CHECKED_MODULE:= +LOCAL_BUILT_MODULE:= +LOCAL_BUILT_MODULE_STEM:= +OVERRIDE_BUILT_MODULE_PATH:= +LOCAL_INSTALLED_MODULE:= +LOCAL_UNINSTALLABLE_MODULE:= +LOCAL_INTERMEDIATE_TARGETS:= +LOCAL_UNSTRIPPED_PATH:= +LOCAL_MODULE_CLASS:= +LOCAL_MODULE_SUFFIX:= +LOCAL_PACKAGE_NAME:= +LOCAL_OVERRIDES_PACKAGES:= +LOCAL_EXPORT_PACKAGE_RESOURCES:= +LOCAL_MANIFEST_PACKAGE_NAME:= +LOCAL_REQUIRED_MODULES:= +LOCAL_ACP_UNAVAILABLE:= +LOCAL_MODULE_TAGS:= +LOCAL_SRC_FILES:= +LOCAL_PREBUILT_OBJ_FILES:= +LOCAL_STATIC_JAVA_LIBRARIES:= +LOCAL_STATIC_LIBRARIES:= +LOCAL_WHOLE_STATIC_LIBRARIES:= +LOCAL_SHARED_LIBRARIES:= +LOCAL_IS_HOST_MODULE:= +LOCAL_CC:= +LOCAL_CXX:= +LOCAL_CPP_EXTENSION:= +LOCAL_NO_DEFAULT_COMPILER_FLAGS:= +LOCAL_NO_FDO_SUPPORT := +LOCAL_ARM_MODE:= +LOCAL_YACCFLAGS:= +LOCAL_ASFLAGS:= +LOCAL_CFLAGS:= +LOCAL_CPPFLAGS:= +LOCAL_C_INCLUDES:= +LOCAL_LDFLAGS:= +LOCAL_LDLIBS:= +LOCAL_AAPT_FLAGS:= +LOCAL_SYSTEM_SHARED_LIBRARIES:=none +LOCAL_PREBUILT_LIBS:= +LOCAL_PREBUILT_EXECUTABLES:= +LOCAL_PREBUILT_JAVA_LIBRARIES:= +LOCAL_PREBUILT_STATIC_JAVA_LIBRARIES:= +LOCAL_PREBUILT_STRIP_COMMENTS:= +LOCAL_INTERMEDIATE_SOURCES:= +LOCAL_INTERMEDIATE_SOURCE_DIR:= +LOCAL_JAVACFLAGS:= +LOCAL_JAVA_LIBRARIES:= +LOCAL_NO_STANDARD_LIBRARIES:= +LOCAL_CLASSPATH:= +LOCAL_DROIDDOC_USE_STANDARD_DOCLET:= +LOCAL_DROIDDOC_SOURCE_PATH:= +LOCAL_DROIDDOC_TEMPLATE_DIR:= +LOCAL_DROIDDOC_CUSTOM_TEMPLATE_DIR:= +LOCAL_DROIDDOC_ASSET_DIR:= +LOCAL_DROIDDOC_CUSTOM_ASSET_DIR:= +LOCAL_DROIDDOC_OPTIONS:= +LOCAL_DROIDDOC_HTML_DIR:= +LOCAL_ASSET_FILES:= +LOCAL_ASSET_DIR:= +LOCAL_RESOURCE_DIR:= +LOCAL_JAVA_RESOURCE_DIRS:= +LOCAL_JAVA_RESOURCE_FILES:= +LOCAL_GENERATED_SOURCES:= +LOCAL_COPY_HEADERS_TO:= +LOCAL_COPY_HEADERS:= +LOCAL_FORCE_STATIC_EXECUTABLE:= +LOCAL_ADDITIONAL_DEPENDENCIES:= +LOCAL_PRELINK_MODULE:= +LOCAL_COMPRESS_MODULE_SYMBOLS:= +LOCAL_STRIP_MODULE:= +LOCAL_POST_PROCESS_COMMAND:=true +LOCAL_JNI_SHARED_LIBRARIES:= +LOCAL_JAR_MANIFEST:= +LOCAL_INSTRUMENTATION_FOR:= +LOCAL_MANIFEST_INSTRUMENTATION_FOR:= +LOCAL_AIDL_INCLUDES:= +LOCAL_JARJAR_RULES:= +LOCAL_ADDITIONAL_JAVA_DIR:= +LOCAL_ALLOW_UNDEFINED_SYMBOLS:= +LOCAL_DX_FLAGS:= +LOCAL_CERTIFICATE:= +LOCAL_SDK_VERSION:= +LOCAL_NDK_VERSION:= +LOCAL_NO_EMMA_INSTRUMENT:= +LOCAL_NO_EMMA_COMPILE:= +LOCAL_PROGUARD_ENABLED:= # '',optonly,full,custom +LOCAL_PROGUARD_FLAGS:= +LOCAL_PROGUARD_FLAG_FILES:= +LOCAL_EMMA_COVERAGE_FILTER:= +LOCAL_MANIFEST_FILE:= +LOCAL_BUILD_HOST_DEX:= +LOCAL_DEX_PREOPT:= + +# Trim MAKEFILE_LIST so that $(call my-dir) doesn't need to +# iterate over thousands of entries every time. +# Leave the current makefile to make sure we don't break anything +# that expects to be able to find the name of the current makefile. +MAKEFILE_LIST := $(lastword $(MAKEFILE_LIST)) diff --git a/src/commandline.c b/src/commandline.c new file mode 100644 index 0000000..cdb46ef --- /dev/null +++ b/src/commandline.c @@ -0,0 +1,1229 @@ +/* + * 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" + +#ifdef HAVE_TERMIO_H +#include +#endif + +#define TRACE_TAG TRACE_SDB +#include "sdb.h" +#include "sdb_client.h" +#include "file_sync_service.h" + +enum { + IGNORE_DATA, + WIPE_DATA, + FLASH_DATA +}; +#if 0 //eric +static int do_cmd(transport_type ttype, char* serial, char *cmd, ...); + +void get_my_path(char *s, size_t maxLen); + +int find_sync_dirs(const char *srcarg, + char **android_srcdir_out, char **data_srcdir_out); + +int install_app(transport_type transport, char* serial, int argc, char** argv); eric +int uninstall_app(transport_type transport, char* serial, int argc, char** argv); + +static const char *gProductOutPath = NULL; + +static char *product_file(const char *extra) +{ + int n; + char *x; + + if (gProductOutPath == NULL) { + fprintf(stderr, "sdb: Product directory not specified; " + "use -p or define ANDROID_PRODUCT_OUT\n"); + exit(1); + } + + n = strlen(gProductOutPath) + strlen(extra) + 2; + x = malloc(n); + if (x == 0) { + fprintf(stderr, "sdb: Out of memory (product_file())\n"); + exit(1); + } + + snprintf(x, (size_t)n, "%s" OS_PATH_SEPARATOR_STR "%s", gProductOutPath, extra); + return x; +} +#endif +void version(FILE * out) { + fprintf(out, "Smart Development Bridge version %d.%d.%d\n", + SDB_VERSION_MAJOR, SDB_VERSION_MINOR, SDB_SERVER_VERSION); +} + +void help() +{ + version(stderr); + + fprintf(stderr, + "\n" + " Usage : sdb [option] [parameters]\n" + "\n" + " options:\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 USB device or emulator with\n" + " the given serial number.\n" + " devices - list all connected devices\n" + "\n" + " commands:\n" + " sdb push - copy file/dir to device\n" + " sdb pull [] - copy file/dir from device\n" + " sdb shell - run remote shell interactively\n" + " sdb shell - run remote shell command\n" + " sdb dlog [ ] - view device log\n" + " sdb forward - forward socket connections\n" + " forward spec is : \n" + " tcp:\n" + " sdb help - show this help message\n" + " sdb version - show version num\n" + "\n" + " sdb start-server - ensure that there is a server running\n" + " sdb kill-server - kill the server if it is running\n" + " sdb get-state - prints: offline | bootloader | device\n" + " sdb get-serialno - prints: \n" + " sdb status-window - continuously print device status for a specified device\n" + "\n" + ); +} + +int usage() +{ + help(); + return 1; +} + +#ifdef HAVE_TERMIO_H +static struct termios tio_save; + +static void stdin_raw_init(int fd) +{ + struct termios tio; + + if(tcgetattr(fd, &tio)) return; + if(tcgetattr(fd, &tio_save)) return; + + tio.c_lflag = 0; /* disable CANON, ECHO*, etc */ + + /* no timeout but request at least one character per read */ + tio.c_cc[VTIME] = 0; + tio.c_cc[VMIN] = 1; + + tcsetattr(fd, TCSANOW, &tio); + tcflush(fd, TCIFLUSH); +} + +static void stdin_raw_restore(int fd) +{ + tcsetattr(fd, TCSANOW, &tio_save); + tcflush(fd, TCIFLUSH); +} +#endif + +static void read_and_dump(int fd) +{ + char buf[4096]; + int len; + + while(fd >= 0) { + len = sdb_read(fd, buf, 4096); + if(len == 0) { + break; + } + + if(len < 0) { + if(errno == EINTR) continue; + break; + } + fwrite(buf, 1, len, stdout); + fflush(stdout); + } +} + +static void *stdin_read_thread(void *x) +{ + int fd, fdi; + unsigned char buf[1024]; + int r, n; + int state = 0; + + int *fds = (int*) x; + fd = fds[0]; + fdi = fds[1]; + free(fds); + + for(;;) { + /* fdi is really the client's stdin, so use read, not sdb_read here */ + r = unix_read(fdi, buf, 1024); + if(r == 0) break; + if(r < 0) { + if(errno == EINTR) continue; + break; + } + for(n = 0; n < r; n++){ + switch(buf[n]) { + case '\n': + state = 1; + break; + case '\r': + state = 1; + break; + case '~': + if(state == 1) state++; + break; + case '.': + if(state == 2) { + fprintf(stderr,"\n* disconnect *\n"); +#ifdef HAVE_TERMIO_H + stdin_raw_restore(fdi); +#endif + exit(0); + } + default: + state = 0; + } + } + r = sdb_write(fd, buf, r); + if(r <= 0) { + break; + } + } + return 0; +} + +int interactive_shell(void) +{ + sdb_thread_t thr; + int fdi, fd; + int *fds; + + fd = sdb_connect("shell:"); + if(fd < 0) { + fprintf(stderr,"error: %s\n", sdb_error()); + return 1; + } + fdi = 0; //dup(0); + + fds = malloc(sizeof(int) * 2); + fds[0] = fd; + fds[1] = fdi; + +#ifdef HAVE_TERMIO_H + stdin_raw_init(fdi); +#endif + sdb_thread_create(&thr, stdin_read_thread, fds); + read_and_dump(fd); +#ifdef HAVE_TERMIO_H + stdin_raw_restore(fdi); +#endif + return 0; +} + + +static void format_host_command(char* buffer, size_t buflen, const char* command, transport_type ttype, const char* serial) +{ + if (serial) { + snprintf(buffer, buflen, "host-serial:%s:%s", serial, command); + } else { + const char* prefix = "host"; + if (ttype == kTransportUsb) + prefix = "host-usb"; + else if (ttype == kTransportLocal) + prefix = "host-local"; + + snprintf(buffer, buflen, "%s:%s", prefix, command); + } +} + +static void status_window(transport_type ttype, const char* serial) +{ + char command[4096]; + char *state = 0; + char *laststate = 0; + + /* silence stderr */ +#ifdef _WIN32 + /* XXX: TODO */ +#else + int fd; + fd = unix_open("/dev/null", O_WRONLY); + dup2(fd, 2); + sdb_close(fd); +#endif + + format_host_command(command, sizeof command, "get-state", ttype, serial); + + for(;;) { + sdb_sleep_ms(250); + + if(state) { + free(state); + state = 0; + } + + state = sdb_query(command); + + if(state) { + if(laststate && !strcmp(state,laststate)){ + continue; + } else { + if(laststate) free(laststate); + laststate = strdup(state); + } + } + + printf("%c[2J%c[2H", 27, 27); + printf("Samsung Development Bridge\n"); + printf("State: %s\n", state ? state : "offline"); + fflush(stdout); + } +} + +/** duplicate string and quote all \ " ( ) chars + space character. */ +static char * +dupAndQuote(const char *s) +{ + const char *ts; + size_t alloc_len; + char *ret; + char *dest; + + ts = s; + + alloc_len = 0; + + for( ;*ts != '\0'; ts++) { + alloc_len++; + if (*ts == ' ' || *ts == '"' || *ts == '\\' || *ts == '(' || *ts == ')') { + alloc_len++; + } + } + + ret = (char *)malloc(alloc_len + 1); + + ts = s; + dest = ret; + + for ( ;*ts != '\0'; ts++) { + if (*ts == ' ' || *ts == '"' || *ts == '\\' || *ts == '(' || *ts == ')') { + *dest++ = '\\'; + } + + *dest++ = *ts; + } + + *dest++ = '\0'; + + return ret; +} +#if 0 //eric +/** + * Run ppp in "notty" mode against a resource listed as the first parameter + * eg: + * + * ppp dev:/dev/omap_csmi_tty0 + * + */ +int ppp(int argc, char **argv) +{ +#ifdef HAVE_WIN32_PROC + fprintf(stderr, "error: sdb %s not implemented on Win32\n", argv[0]); + return -1; +#else + char *sdb_service_name; + pid_t pid; + int fd; + + if (argc < 2) { + fprintf(stderr, "usage: sdb %s [ppp opts]\n", + argv[0]); + + return 1; + } + + sdb_service_name = argv[1]; + + fd = sdb_connect(sdb_service_name); + + if(fd < 0) { + fprintf(stderr,"Error: Could not open sdb service: %s. Error: %s\n", + sdb_service_name, sdb_error()); + return 1; + } + + 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); + sdb_close(STDERR_FILENO); + sdb_close(fd); + + err = execvp("pppd", (char * const *)ppp_args); + + if (err < 0) { + perror("execing pppd"); + } + exit(-1); + } else { + // parent side + + sdb_close(fd); + return 0; + } +#endif /* !HAVE_WIN32_PROC */ +} +#endif +static int send_shellcommand(transport_type transport, char* serial, char* buf) +{ + int fd, ret; + + for(;;) { + fd = sdb_connect(buf); + if(fd >= 0) + break; + fprintf(stderr,"- waiting for device -\n"); + sdb_sleep_ms(1000); +// do_cmd(transport, serial, "wait-for-device", 0); + } + + read_and_dump(fd); + ret = sdb_close(fd); + if (ret) + perror("close"); + + return ret; +} + +static int logcat(transport_type transport, char* serial, int argc, char **argv) +{ + char buf[4096]; + + char *log_tags; + char *quoted_log_tags; + + log_tags = getenv("ANDROID_LOG_TAGS"); + quoted_log_tags = dupAndQuote(log_tags == NULL ? "" : log_tags); + + snprintf(buf, sizeof(buf), + "shell:export ANDROID_LOG_TAGS=\"\%s\" ; exec dlogutil", + //"shell:export ANDROID_LOG_TAGS=\"\%s\" ; exec logcat", + quoted_log_tags); + + free(quoted_log_tags); + + argc -= 1; + argv += 1; + while(argc-- > 0) { + char *quoted; + + quoted = dupAndQuote (*argv++); + + strncat(buf, " ", sizeof(buf)-1); + strncat(buf, quoted, sizeof(buf)-1); + free(quoted); + } + + send_shellcommand(transport, serial, buf); + return 0; +} +#if 0 //eric +#define SENTINEL_FILE "config" OS_PATH_SEPARATOR_STR "envsetup.make" +static int top_works(const char *top) +{ + if (top != NULL && sdb_is_absolute_host_path(top)) { + char path_buf[PATH_MAX]; + snprintf(path_buf, sizeof(path_buf), + "%s" OS_PATH_SEPARATOR_STR SENTINEL_FILE, top); + return access(path_buf, F_OK) == 0; + } + return 0; +} + +static char *find_top_from(const char *indir, char path_buf[PATH_MAX]) +{ + strcpy(path_buf, indir); + while (1) { + if (top_works(path_buf)) { + return path_buf; + } + char *s = sdb_dirstop(path_buf); + if (s != NULL) { + *s = '\0'; + } else { + path_buf[0] = '\0'; + return NULL; + } + } +} + +static char *find_top(char path_buf[PATH_MAX]) +{ + char *top = getenv("ANDROID_BUILD_TOP"); + if (top != NULL && top[0] != '\0') { + if (!top_works(top)) { + fprintf(stderr, "sdb: bad ANDROID_BUILD_TOP value \"%s\"\n", top); + return NULL; + } + } else { + top = getenv("TOP"); + if (top != NULL && top[0] != '\0') { + if (!top_works(top)) { + fprintf(stderr, "sdb: bad TOP value \"%s\"\n", top); + return NULL; + } + } else { + top = NULL; + } + } + + if (top != NULL) { + /* The environment pointed to a top directory that works. + */ + strcpy(path_buf, top); + return path_buf; + } + + /* The environment didn't help. Walk up the tree from the CWD + * to see if we can find the top. + */ + char dir[PATH_MAX]; + top = find_top_from(getcwd(dir, sizeof(dir)), path_buf); + if (top == NULL) { + /* If the CWD isn't under a good-looking top, see if the + * executable is. + */ + get_my_path(dir, PATH_MAX); + top = find_top_from(dir, path_buf); + } + return top; +} + +/* may be: + * - A simple product name + * e.g., "sooner" +TODO: debug? sooner-debug, sooner:debug? + * - 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 const char *find_product_out_path(const char *hint) +{ + static char path_buf[PATH_MAX]; + + if (hint == NULL || hint[0] == '\0') { + return NULL; + } + + /* If it's already absolute, don't bother doing any work. + */ + if (sdb_is_absolute_host_path(hint)) { + strcpy(path_buf, hint); + return path_buf; + } + + /* If there are any slashes in it, assume it's a relative path; + * make it absolute. + */ + if (sdb_dirstart(hint) != NULL) { + if (getcwd(path_buf, sizeof(path_buf)) == NULL) { + fprintf(stderr, "sdb: Couldn't get CWD: %s\n", strerror(errno)); + return NULL; + } + if (strlen(path_buf) + 1 + strlen(hint) >= sizeof(path_buf)) { + fprintf(stderr, "sdb: Couldn't assemble path\n"); + return NULL; + } + strcat(path_buf, OS_PATH_SEPARATOR_STR); + strcat(path_buf, hint); + return path_buf; + } + + /* 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_buf[PATH_MAX]; + const char *top = find_top(top_buf); + if (top == NULL) { + fprintf(stderr, "sdb: Couldn't find top of build tree\n"); + return NULL; + } +//TODO: if we have a way to indicate debug, look in out/debug/target/... + snprintf(path_buf, sizeof(path_buf), + "%s" OS_PATH_SEPARATOR_STR + "out" OS_PATH_SEPARATOR_STR + "target" OS_PATH_SEPARATOR_STR + "product" OS_PATH_SEPARATOR_STR + "%s", top_buf, hint); + if (access(path_buf, F_OK) < 0) { + fprintf(stderr, "sdb: Couldn't find a product dir " + "based on \"-p %s\"; \"%s\" doesn't exist\n", hint, path_buf); + return NULL; + } + return path_buf; +} +#endif +int sdb_commandline(int argc, char **argv) +{ + char buf[4096]; + int is_daemon = 0; +#if 0 //eric + int no_daemon = 0; + int persist = 0; + char* server_port_str = NULL; +#endif + int r; + int quote; + transport_type ttype = kTransportAny; + char* serial = NULL; + +#if 0 //eric + /* 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 sdb + * command requires this information, then the user must + * specify the path using "-p". + */ + gProductOutPath = getenv("ANDROID_PRODUCT_OUT"); + if (gProductOutPath == NULL || gProductOutPath[0] == '\0') { + gProductOutPath = NULL; + } + // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint + + serial = getenv("ANDROID_SERIAL"); +#endif + /* Validate and assign the server port */ + int server_port = DEFAULT_SDB_PORT; +#if 0 //eric + server_port_str = getenv("ANDROID_SDB_SERVER_PORT"); + if (server_port_str && strlen(server_port_str) > 0) { + server_port = (int) strtol(server_port_str, NULL, 0); + if (server_port <= 0) { + fprintf(stderr, + "sdb: Env var ANDROID_SDB_SERVER_PORT must be a positive number. Got \"%s\"\n", + server_port_str); + return usage(); + } + } +#endif + /* modifiers and flags */ + while(argc > 0) { +#if 0 //eric + if(!strcmp(argv[0],"nodaemon")) { + no_daemon = 1; + } else +#endif + if (!strcmp(argv[0], "fork-server")) { + /* this is a special flag used only when the SDB client launches the SDB Server */ + is_daemon = 1; +#if 0 //eric + } else if(!strcmp(argv[0],"persist")) { + persist = 1; + } else if(!strncmp(argv[0], "-p", 2)) { + const char *product = NULL; + if (argv[0][2] == '\0') { + if (argc < 2) return usage(); + product = argv[1]; + argc--; + argv++; + } else { + product = argv[1] + 2; + } + gProductOutPath = find_product_out_path(product); + if (gProductOutPath == NULL) { + fprintf(stderr, "sdb: could not resolve \"-p %s\"\n", + product); + return usage(); + } +#endif + } 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")) { + ttype = kTransportUsb; + } else if (!strcmp(argv[0],"-e")) { + ttype = kTransportLocal; + } else { + /* out of recognized modifiers and flags */ + break; + } + argc--; + argv++; + } + + sdb_set_transport(ttype, serial); + sdb_set_tcp_specifics(server_port); + + if ((argc > 0) && (!strcmp(argv[0],"server"))) { +// if (no_daemon || is_daemon) { + if (is_daemon) { + r = sdb_main(is_daemon, server_port); + } else { + r = launch_server(server_port); + } + if(r) { + fprintf(stderr,"* could not start server *\n"); + } + return r; + } + +//top: + if(argc == 0) { + return usage(); + } + + /* sdb_connect() commands */ + + if(!strcmp(argv[0], "devices")) { + char *tmp; + snprintf(buf, sizeof buf, "host:%s", argv[0]); + tmp = sdb_query(buf); + if(tmp) { + printf("List of devices attached \n"); + printf("%s\n", tmp); + return 0; + } else { + return 1; + } + } + + if(!strcmp(argv[0], "connect")) { + char *tmp; + if (argc != 2) { + fprintf(stderr, "Usage: sdb connect [:]\n"); + return 1; + } + snprintf(buf, sizeof buf, "host:connect:%s", argv[1]); + tmp = sdb_query(buf); + if(tmp) { + printf("%s\n", tmp); + return 0; + } else { + return 1; + } + } + + if(!strcmp(argv[0], "disconnect")) { + char *tmp; + if (argc > 2) { + fprintf(stderr, "Usage: sdb disconnect [[:]]\n"); + return 1; + } + if (argc == 2) { + snprintf(buf, sizeof buf, "host:disconnect:%s", argv[1]); + } else { + snprintf(buf, sizeof buf, "host:disconnect:"); + } + tmp = sdb_query(buf); + if(tmp) { + printf("%s\n", tmp); + return 0; + } else { + return 1; + } + } + + if (!strcmp(argv[0], "emu")) { + return sdb_send_emulator_command(argc, argv); + } + + if(!strcmp(argv[0], "shell")) { + int r; + int fd; + + if(argc < 2) { + return interactive_shell(); + } + + snprintf(buf, sizeof buf, "shell:%s", argv[1]); + argc -= 2; + argv += 2; + while(argc-- > 0) { + strcat(buf, " "); + + /* quote empty strings and strings with spaces */ + quote = (**argv == 0 || strchr(*argv, ' ')); + if (quote) + strcat(buf, "\""); + strcat(buf, *argv++); + if (quote) + strcat(buf, "\""); + } + + for(;;) { + fd = sdb_connect(buf); + if(fd >= 0) { + read_and_dump(fd); + sdb_close(fd); + r = 0; + } else { + fprintf(stderr,"error: %s\n", sdb_error()); + r = -1; + } +#if 0 //eric + if(persist) { + fprintf(stderr,"\n- waiting for device -\n"); + sdb_sleep_ms(1000); + do_cmd(ttype, serial, "wait-for-device", 0); + } else { +#endif + return r; +#if 0 //eric + } +#endif + } + } + + if(!strcmp(argv[0], "kill-server")) { + int fd; + fd = _sdb_connect("host:kill"); + if(fd == -1) { + fprintf(stderr,"* server not running *\n"); + return 1; + } + return 0; + } + +// if(!strcmp(argv[0], "remount") || !strcmp(argv[0], "reboot") +// || !strcmp(argv[0], "reboot-bootloader") +// || !strcmp(argv[0], "tcpip") || !strcmp(argv[0], "usb") +// || !strcmp(argv[0], "root")) { +// char command[100]; +// if (!strcmp(argv[0], "reboot-bootloader")) +// snprintf(command, sizeof(command), "reboot:bootloader"); +// else if (argc > 1) +// snprintf(command, sizeof(command), "%s:%s", argv[0], argv[1]); +// else +// snprintf(command, sizeof(command), "%s:", argv[0]); +// int fd = sdb_connect(command); +// if(fd >= 0) { +// read_and_dump(fd); +// sdb_close(fd); +// return 0; +// } +// fprintf(stderr,"error: %s\n", sdb_error()); +// return 1; +// } + +// if(!strcmp(argv[0], "bugreport")) { +// if (argc != 1) return usage(); +// do_cmd(ttype, serial, "shell", "bugreport", 0); +// return 0; +// } + + /* sdb_command() wrapper commands */ + +// if(!strncmp(argv[0], "wait-for-", strlen("wait-for-"))) { +// char* service = argv[0]; +// if (!strncmp(service, "wait-for-device", strlen("wait-for-device"))) { +// if (ttype == kTransportUsb) { +// service = "wait-for-usb"; +// } else if (ttype == kTransportLocal) { +// service = "wait-for-local"; +// } else { +// service = "wait-for-any"; +// } +// } +// +// format_host_command(buf, sizeof buf, service, ttype, serial); +// +// if (sdb_command(buf)) { +// D("failure: %s *\n",sdb_error()); +// fprintf(stderr,"error: %s\n", sdb_error()); +// return 1; +// } +// +// /* Allow a command to be run after wait-for-device, +// * e.g. 'sdb wait-for-device shell'. +// */ +// if(argc > 1) { +// argc--; +// argv++; +// goto top; +// } +// return 0; +// } + + if(!strcmp(argv[0], "forward")) { + if(argc != 3) return usage(); + if (serial) { + snprintf(buf, sizeof buf, "host-serial:%s:forward:%s;%s",serial, argv[1], argv[2]); + } else if (ttype == kTransportUsb) { + snprintf(buf, sizeof buf, "host-usb:forward:%s;%s", argv[1], argv[2]); + } else if (ttype == kTransportLocal) { + snprintf(buf, sizeof buf, "host-local:forward:%s;%s", argv[1], argv[2]); + } else { + snprintf(buf, sizeof buf, "host:forward:%s;%s", argv[1], argv[2]); + } + if(sdb_command(buf)) { + fprintf(stderr,"error: %s\n", sdb_error()); + return 1; + } + return 0; + } + + /* do_sync_*() commands */ +#if 0 //eric + if(!strcmp(argv[0], "ls")) { + if(argc != 2) return usage(); + return do_sync_ls(argv[1]); + } +#endif + if(!strcmp(argv[0], "push")) { + if(argc != 3) return usage(); + return do_sync_push(argv[1], argv[2], 0 /* no verify APK */); + } + + if(!strcmp(argv[0], "pull")) { + if (argc == 2) { + return do_sync_pull(argv[1], "."); + } else if (argc == 3) { + return do_sync_pull(argv[1], argv[2]); + } else { + return usage(); + } + } + +// if(!strcmp(argv[0], "install")) { +// if (argc < 2) return usage(); +// return install_app(ttype, serial, argc, argv); +// } +// +// if(!strcmp(argv[0], "uninstall")) { +// if (argc < 2) return usage(); +// return uninstall_app(ttype, serial, argc, argv); +// } + +// if(!strcmp(argv[0], "sync")) { +// char *srcarg, *android_srcpath, *data_srcpath; +// int listonly = 0; +// +// int ret; +// if(argc < 2) { +// /* No local path was specified. */ +// srcarg = NULL; +// } else if (argc >= 2 && strcmp(argv[1], "-l") == 0) { +// listonly = 1; +// if (argc == 3) { +// srcarg = argv[2]; +// } else { +// srcarg = NULL; +// } +// } else if(argc == 2) { +// /* A local path or "android"/"data" arg was specified. */ +// srcarg = argv[1]; +// } else { +// return usage(); +// } +// ret = find_sync_dirs(srcarg, &android_srcpath, &data_srcpath); +// if(ret != 0) return usage(); +// +// if(android_srcpath != NULL) +// ret = do_sync_sync(android_srcpath, "/system", listonly); +// if(ret == 0 && data_srcpath != NULL) +// ret = do_sync_sync(data_srcpath, "/data", listonly); +// +// free(android_srcpath); +// free(data_srcpath); +// return ret; +// } + + /* passthrough commands */ + + if(!strcmp(argv[0],"get-state") || + !strcmp(argv[0],"get-serialno")) + { + char *tmp; + + format_host_command(buf, sizeof buf, argv[0], ttype, serial); + tmp = sdb_query(buf); + if(tmp) { + printf("%s\n", tmp); + return 0; + } else { + return 1; + } + } + + /* other commands */ + + if(!strcmp(argv[0],"status-window")) { + status_window(ttype, serial); + return 0; + } + + if(!strcmp(argv[0],"dlog")) { + return logcat(ttype, serial, argc, argv); + } + +// if(!strcmp(argv[0],"ppp")) { +// return ppp(argc, argv); +// } + + if (!strcmp(argv[0], "start-server")) { + return sdb_connect("host:start-server"); + } + +// if (!strcmp(argv[0], "jdwp")) { +// int fd = sdb_connect("jdwp"); +// if (fd >= 0) { +// read_and_dump(fd); +// sdb_close(fd); +// return 0; +// } else { +// fprintf(stderr, "error: %s\n", sdb_error()); +// return -1; +// } +// } + + /* "sdb /?" is a common idiom under Windows */ + if(!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) { + help(); + return 0; + } + + if(!strcmp(argv[0], "version")) { + version(stdout); + return 0; + } + + usage(); + return 1; +} +#if 0 //eric +static int do_cmd(transport_type ttype, char* serial, char *cmd, ...) +{ + char *argv[16]; + int argc; + va_list ap; + + va_start(ap, cmd); + argc = 0; + + if (serial) { + argv[argc++] = "-s"; + argv[argc++] = serial; + } else if (ttype == kTransportUsb) { + argv[argc++] = "-d"; + } else if (ttype == kTransportLocal) { + argv[argc++] = "-e"; + } + + argv[argc++] = cmd; + while((argv[argc] = va_arg(ap, char*)) != 0) argc++; + va_end(ap); + +#if 0 + int n; + fprintf(stderr,"argc = %d\n",argc); + for(n = 0; n < argc; n++) { + fprintf(stderr,"argv[%d] = \"%s\"\n", n, argv[n]); + } +#endif + + return sdb_commandline(argc, argv); +} + +int find_sync_dirs(const char *srcarg, + char **android_srcdir_out, char **data_srcdir_out) +{ + char *android_srcdir, *data_srcdir; + + if(srcarg == NULL) { + android_srcdir = product_file("system"); + data_srcdir = product_file("data"); + } else { + /* srcarg may be "data", "system" or NULL. + * if srcarg is NULL, then both data and system are synced + */ + if(strcmp(srcarg, "system") == 0) { + android_srcdir = product_file("system"); + data_srcdir = NULL; + } else if(strcmp(srcarg, "data") == 0) { + android_srcdir = NULL; + data_srcdir = product_file("data"); + } else { + /* It's not "system" or "data". + */ + return 1; + } + } + + if(android_srcdir_out != NULL) + *android_srcdir_out = android_srcdir; + else + free(android_srcdir); + + if(data_srcdir_out != NULL) + *data_srcdir_out = data_srcdir; + else + free(data_srcdir); + + return 0; +} +#endif +static int pm_command(transport_type transport, char* serial, + int argc, char** argv) +{ + char buf[4096]; + + snprintf(buf, sizeof(buf), "shell:pm"); + + while(argc-- > 0) { + char *quoted; + + quoted = dupAndQuote(*argv++); + + strncat(buf, " ", sizeof(buf)-1); + strncat(buf, quoted, sizeof(buf)-1); + free(quoted); + } + + send_shellcommand(transport, serial, buf); + return 0; +} + +int uninstall_app(transport_type transport, char* serial, int argc, 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 (sdb/ui) */ + if (argc == 3 && strcmp(argv[1], "-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 'sdb shell pm uninstall -k %s'\n", argv[2]); + return -1; + } + + /* 'sdb uninstall' takes the same arguments as 'pm uninstall' on device */ + return pm_command(transport, serial, argc, argv); +} + +#if 0 //eric +static int delete_file(transport_type transport, char* serial, char* filename) +{ + char buf[4096]; + char* quoted; + + snprintf(buf, sizeof(buf), "shell:rm "); + quoted = dupAndQuote(filename); + strncat(buf, quoted, sizeof(buf)-1); + free(quoted); + + send_shellcommand(transport, serial, buf); + return 0; +} + +int install_app(transport_type transport, char* serial, int argc, char** argv) +{ + struct stat st; + int err; + const char *const DATA_DEST = "/data/local/tmp/%s"; + const char *const SD_DEST = "/sdcard/tmp/%s"; + const char* where = DATA_DEST; + char to[PATH_MAX]; + char* filename = argv[argc - 1]; + const char* p; + int i; + + for (i = 0; i < argc; i++) { + if (!strcmp(argv[i], "-s")) + where = SD_DEST; + } + + p = sdb_dirstop(filename); + if (p) { + p++; + snprintf(to, sizeof to, where, p); + } else { + snprintf(to, sizeof to, where, filename); + } + if (p[0] == '\0') { + } + + err = stat(filename, &st); + if (err != 0) { + fprintf(stderr, "can't find '%s' to install\n", filename); + return 1; + } + if (!S_ISREG(st.st_mode)) { + fprintf(stderr, "can't install '%s' because it's not a file\n", + filename); + return 1; + } + + if (!(err = do_sync_push(filename, to, 1 /* verify APK */))) { + /* file in place; tell the Package Manager to install it */ + argv[argc - 1] = to; /* destination name, not source location */ + pm_command(transport, serial, argc, argv); + delete_file(transport, serial, to); + } + + return err; +} +#endif diff --git a/src/console.c b/src/console.c new file mode 100644 index 0000000..fb7ad7b --- /dev/null +++ b/src/console.c @@ -0,0 +1,45 @@ +#include "sysdeps.h" +#include "sdb.h" +#include "sdb_client.h" +#include + +static int connect_to_console(void) +{ + int fd, port; + + port = sdb_get_emulator_console_port(); + if (port < 0) { + if (port == -2) + fprintf(stderr, "error: more than one emulator detected. use -s option\n"); + else + fprintf(stderr, "error: no emulator detected\n"); + return -1; + } + fd = socket_loopback_client( port, SOCK_STREAM ); + if (fd < 0) { + fprintf(stderr, "error: could not connect to TCP port %d\n", port); + return -1; + } + return fd; +} + + +int sdb_send_emulator_command(int argc, char** argv) +{ + int fd, nn; + + fd = connect_to_console(); + if (fd < 0) + return 1; + +#define QUIT "quit\n" + + for (nn = 1; nn < argc; nn++) { + sdb_write( fd, argv[nn], strlen(argv[nn]) ); + sdb_write( fd, (nn == argc-1) ? "\n" : " ", 1 ); + } + sdb_write( fd, QUIT, sizeof(QUIT)-1 ); + sdb_close(fd); + + return 0; +} diff --git a/src/fdevent.c b/src/fdevent.c new file mode 100644 index 0000000..188da86 --- /dev/null +++ b/src/fdevent.c @@ -0,0 +1,508 @@ +/* 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. +*/ + +#include +#include +#include +#include +#include + +#include + +#include +#include + +#include "fdevent.h" + +#define TRACE(x...) fprintf(stderr,x) + +#define DEBUG 0 + +static void fatal(const char *fn, const char *fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + fprintf(stderr, "%s:", fn); + vfprintf(stderr, fmt, ap); + va_end(ap); + abort(); +} + +#define FATAL(x...) fatal(__FUNCTION__, x) + +#if DEBUG +static void dump_fde(fdevent *fde, const char *info) +{ + fprintf(stderr,"FDE #%03d %c%c%c %s\n", fde->fd, + fde->state & FDE_READ ? 'R' : ' ', + fde->state & FDE_WRITE ? 'W' : ' ', + fde->state & FDE_ERROR ? 'E' : ' ', + info); +} +#else +#define dump_fde(fde, info) do { } while(0) +#endif + +#define FDE_EVENTMASK 0x00ff +#define FDE_STATEMASK 0xff00 + +#define FDE_ACTIVE 0x0100 +#define FDE_PENDING 0x0200 +#define FDE_CREATED 0x0400 + +static void fdevent_plist_enqueue(fdevent *node); +static void fdevent_plist_remove(fdevent *node); +static fdevent *fdevent_plist_dequeue(void); + +static fdevent list_pending = { + .next = &list_pending, + .prev = &list_pending, +}; + +static fdevent **fd_table = 0; +static int fd_table_max = 0; + +#ifdef CRAPTASTIC +//HAVE_EPOLL + +#include + +static int epoll_fd = -1; + +static void fdevent_init() +{ + /* XXX: what's a good size for the passed in hint? */ + epoll_fd = epoll_create(256); + + if(epoll_fd < 0) { + perror("epoll_create() failed"); + exit(1); + } + + /* mark for close-on-exec */ + fcntl(epoll_fd, F_SETFD, FD_CLOEXEC); +} + +static void fdevent_connect(fdevent *fde) +{ + struct epoll_event ev; + + memset(&ev, 0, sizeof(ev)); + ev.events = 0; + ev.data.ptr = fde; + +#if 0 + if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fde->fd, &ev)) { + perror("epoll_ctl() failed\n"); + exit(1); + } +#endif +} + +static void fdevent_disconnect(fdevent *fde) +{ + struct epoll_event ev; + + memset(&ev, 0, sizeof(ev)); + ev.events = 0; + ev.data.ptr = fde; + + /* technically we only need to delete if we + ** were actively monitoring events, but let's + ** be aggressive and do it anyway, just in case + ** something's out of sync + */ + epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fde->fd, &ev); +} + +static void fdevent_update(fdevent *fde, unsigned events) +{ + struct epoll_event ev; + int active; + + active = (fde->state & FDE_EVENTMASK) != 0; + + memset(&ev, 0, sizeof(ev)); + ev.events = 0; + ev.data.ptr = fde; + + if(events & FDE_READ) ev.events |= EPOLLIN; + if(events & FDE_WRITE) ev.events |= EPOLLOUT; + if(events & FDE_ERROR) ev.events |= (EPOLLERR | EPOLLHUP); + + fde->state = (fde->state & FDE_STATEMASK) | events; + + if(active) { + /* we're already active. if we're changing to *no* + ** events being monitored, we need to delete, otherwise + ** we need to just modify + */ + if(ev.events) { + if(epoll_ctl(epoll_fd, EPOLL_CTL_MOD, fde->fd, &ev)) { + perror("epoll_ctl() failed\n"); + exit(1); + } + } else { + if(epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fde->fd, &ev)) { + perror("epoll_ctl() failed\n"); + exit(1); + } + } + } else { + /* we're not active. if we're watching events, we need + ** to add, otherwise we can just do nothing + */ + if(ev.events) { + if(epoll_ctl(epoll_fd, EPOLL_CTL_ADD, fde->fd, &ev)) { + perror("epoll_ctl() failed\n"); + exit(1); + } + } + } +} + +static void fdevent_process() +{ + struct epoll_event events[256]; + fdevent *fde; + int i, n; + + n = epoll_wait(epoll_fd, events, 256, -1); + + if(n < 0) { + if(errno == EINTR) return; + perror("epoll_wait"); + exit(1); + } + + for(i = 0; i < n; i++) { + struct epoll_event *ev = events + i; + fde = ev->data.ptr; + + if(ev->events & EPOLLIN) { + fde->events |= FDE_READ; + } + if(ev->events & EPOLLOUT) { + fde->events |= FDE_WRITE; + } + if(ev->events & (EPOLLERR | EPOLLHUP)) { + fde->events |= FDE_ERROR; + } + if(fde->events) { + if(fde->state & FDE_PENDING) continue; + fde->state |= FDE_PENDING; + fdevent_plist_enqueue(fde); + } + } +} + +#else /* USE_SELECT */ + +#ifdef HAVE_WINSOCK +#include +#else +#include +#endif + +static fd_set read_fds; +static fd_set write_fds; +static fd_set error_fds; + +static int select_n = 0; + +static void fdevent_init(void) +{ + FD_ZERO(&read_fds); + FD_ZERO(&write_fds); + FD_ZERO(&error_fds); +} + +static void fdevent_connect(fdevent *fde) +{ + if(fde->fd >= select_n) { + select_n = fde->fd + 1; + } +} + +static void fdevent_disconnect(fdevent *fde) +{ + int i, n; + + FD_CLR(fde->fd, &read_fds); + FD_CLR(fde->fd, &write_fds); + FD_CLR(fde->fd, &error_fds); + + for(n = 0, i = 0; i < select_n; i++) { + if(fd_table[i] != 0) n = i; + } + select_n = n + 1; +} + +static void fdevent_update(fdevent *fde, unsigned events) +{ + if(events & FDE_READ) { + FD_SET(fde->fd, &read_fds); + } else { + FD_CLR(fde->fd, &read_fds); + } + if(events & FDE_WRITE) { + FD_SET(fde->fd, &write_fds); + } else { + FD_CLR(fde->fd, &write_fds); + } + if(events & FDE_ERROR) { + FD_SET(fde->fd, &error_fds); + } else { + FD_CLR(fde->fd, &error_fds); + } + + fde->state = (fde->state & FDE_STATEMASK) | events; +} + +static int fdevent_process() +{ + int i, n; + fdevent *fde; + unsigned events; + fd_set rfd, wfd, efd; + + memcpy(&rfd, &read_fds, sizeof(fd_set)); + memcpy(&wfd, &write_fds, sizeof(fd_set)); + memcpy(&efd, &error_fds, sizeof(fd_set)); + + n = select(select_n, &rfd, &wfd, &efd, 0); + + if(n < 0) { + if(errno == EINTR) return -1; + perror("select"); + return -1; + } + + for(i = 0; (i < select_n) && (n > 0); i++) { + events = 0; + if(FD_ISSET(i, &rfd)) events |= FDE_READ; + if(FD_ISSET(i, &wfd)) events |= FDE_WRITE; + if(FD_ISSET(i, &efd)) events |= FDE_ERROR; + + if(events) { + n--; + + fde = fd_table[i]; + if(fde == 0) FATAL("missing fde for fd %d\n", i); + + fde->events |= events; + + if(fde->state & FDE_PENDING) continue; + fde->state |= FDE_PENDING; + fdevent_plist_enqueue(fde); + } + } + return 0; +} + +#endif + +static void fdevent_register(fdevent *fde) +{ + if(fde->fd < 0) { + FATAL("bogus negative fd (%d)\n", fde->fd); + } + + if(fde->fd >= fd_table_max) { + int oldmax = fd_table_max; + if(fde->fd > 32000) { + FATAL("bogus huuuuge fd (%d)\n", fde->fd); + } + if(fd_table_max == 0) { + fdevent_init(); + fd_table_max = 256; + } + while(fd_table_max <= fde->fd) { + fd_table_max *= 2; + } + fd_table = realloc(fd_table, sizeof(fdevent*) * fd_table_max); + if(fd_table == 0) { + FATAL("could not expand fd_table to %d entries\n", fd_table_max); + } + memset(fd_table + oldmax, 0, sizeof(int) * (fd_table_max - oldmax)); + } + + fd_table[fde->fd] = fde; +} + +static void fdevent_unregister(fdevent *fde) +{ + if((fde->fd < 0) || (fde->fd >= fd_table_max)) { + FATAL("fd out of range (%d)\n", fde->fd); + } + + if(fd_table[fde->fd] != fde) { + FATAL("fd_table out of sync"); + } + + fd_table[fde->fd] = 0; + + if(!(fde->state & FDE_DONT_CLOSE)) { + dump_fde(fde, "close"); + close(fde->fd); + } +} + +static void fdevent_plist_enqueue(fdevent *node) +{ + fdevent *list = &list_pending; + + node->next = list; + node->prev = list->prev; + node->prev->next = node; + list->prev = node; +} + +static void fdevent_plist_remove(fdevent *node) +{ + node->prev->next = node->next; + node->next->prev = node->prev; + node->next = 0; + node->prev = 0; +} + +static fdevent *fdevent_plist_dequeue(void) +{ + fdevent *list = &list_pending; + fdevent *node = list->next; + + if(node == list) return 0; + + list->next = node->next; + list->next->prev = list; + node->next = 0; + node->prev = 0; + + return node; +} + +fdevent *fdevent_create(int fd, fd_func func, void *arg) +{ + 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) +{ + if(fde == 0) return; + if(!(fde->state & FDE_CREATED)) { + FATAL("fde %p not created by fdevent_create()\n", fde); + } + fdevent_remove(fde); +} + +void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg) +{ + memset(fde, 0, sizeof(fdevent)); + fde->state = FDE_ACTIVE; + fde->fd = fd; + fde->func = func; + fde->arg = arg; + +#ifndef HAVE_WINSOCK + fcntl(fd, F_SETFL, O_NONBLOCK); +#endif + fdevent_register(fde); + dump_fde(fde, "connect"); + fdevent_connect(fde); + fde->state |= FDE_ACTIVE; +} + +void fdevent_remove(fdevent *fde) +{ + if(fde->state & FDE_PENDING) { + fdevent_plist_remove(fde); + } + + if(fde->state & FDE_ACTIVE) { + fdevent_disconnect(fde); + dump_fde(fde, "disconnect"); + fdevent_unregister(fde); + } + + fde->state = 0; + fde->events = 0; +} + + +void fdevent_set(fdevent *fde, unsigned events) +{ + events &= FDE_EVENTMASK; + + if((fde->state & FDE_EVENTMASK) == events) return; + + if(fde->state & FDE_ACTIVE) { + fdevent_update(fde, events); + dump_fde(fde, "update"); + } + + fde->state = (fde->state & FDE_STATEMASK) | events; + + if(fde->state & FDE_PENDING) { + /* if we're pending, make sure + ** we don't signal an event that + ** is no longer wanted. + */ + fde->events &= (~events); + if(fde->events == 0) { + fdevent_plist_remove(fde); + fde->state &= (~FDE_PENDING); + } + } +} + +void fdevent_add(fdevent *fde, unsigned events) +{ + fdevent_set( + fde, (fde->state & FDE_EVENTMASK) | (events & FDE_EVENTMASK)); +} + +void fdevent_del(fdevent *fde, unsigned events) +{ + fdevent_set( + fde, (fde->state & FDE_EVENTMASK) & (~(events & FDE_EVENTMASK))); +} + +void fdevent_loop() +{ + fdevent *fde; + + for(;;) { +#if DEBUG + fprintf(stderr,"--- ---- waiting for events\n"); +#endif + if (fdevent_process() < 0) + return; + + while((fde = fdevent_plist_dequeue())) { + unsigned events = fde->events; + fde->events = 0; + fde->state &= (~FDE_PENDING); + dump_fde(fde, "callback"); + fde->func(fde->fd, events, fde->arg); + } + } +} + diff --git a/src/fdevent.h b/src/fdevent.h new file mode 100644 index 0000000..6b7e7ec --- /dev/null +++ b/src/fdevent.h @@ -0,0 +1,81 @@ +/* + * 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 /* for int64_t */ + +/* events that may be observed */ +#define FDE_READ 0x0001 +#define FDE_WRITE 0x0002 +#define FDE_ERROR 0x0004 +#define FDE_TIMEOUT 0x0008 + +/* features that may be set (via the events set/add/del interface) */ +#define FDE_DONT_CLOSE 0x0080 + +typedef struct fdevent fdevent; + +typedef void (*fd_func)(int fd, unsigned events, void *userdata); + +/* 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(); + +struct fdevent +{ + fdevent *next; + fdevent *prev; + + int fd; + unsigned short state; + unsigned short events; + + fd_func func; + void *arg; +}; + + +#endif diff --git a/src/file_sync_client.c b/src/file_sync_client.c new file mode 100644 index 0000000..90f1dd1 --- /dev/null +++ b/src/file_sync_client.c @@ -0,0 +1,1025 @@ +/* + * 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 +#if 0 //eric +#include +#endif +#include "sysdeps.h" +#include "sdb.h" +#include "sdb_client.h" +#include "file_sync_service.h" + +static unsigned total_bytes; +static long long start_time; + +static long long NOW() +{ + struct timeval tv; + gettimeofday(&tv, 0); + return ((long long) tv.tv_usec) + + 1000000LL * ((long long) tv.tv_sec); +} + +static void BEGIN() +{ + total_bytes = 0; + start_time = NOW(); +} + +static void END() +{ + long long t = NOW() - start_time; + if(total_bytes == 0) return; + + if (t == 0) /* prevent division by 0 :-) */ + t = 1000000; + + fprintf(stderr,"%lld KB/s (%d bytes in %lld.%03llds)\n", + ((((long long) total_bytes) * 1000000LL) / t) / 1024LL, + total_bytes, (t / 1000000LL), (t % 1000000LL) / 1000LL); +} + +void sync_quit(int fd) +{ + syncmsg msg; + + msg.req.id = ID_QUIT; + msg.req.namelen = 0; + + writex(fd, &msg.req, sizeof(msg.req)); +} + +typedef void (*sync_ls_cb)(unsigned mode, unsigned size, unsigned time, const char *name, void *cookie); + +int sync_ls(int fd, const char *path, sync_ls_cb func, void *cookie) +{ + syncmsg msg; + char buf[257]; + int len; + + len = strlen(path); + if(len > 1024) goto fail; + + msg.req.id = ID_LIST; + msg.req.namelen = htoll(len); + + if(writex(fd, &msg.req, sizeof(msg.req)) || + writex(fd, path, len)) { + goto fail; + } + + for(;;) { + if(readx(fd, &msg.dent, sizeof(msg.dent))) break; + if(msg.dent.id == ID_DONE) return 0; + if(msg.dent.id != ID_DENT) break; + + len = ltohl(msg.dent.namelen); + if(len > 256) break; + + if(readx(fd, buf, len)) break; + buf[len] = 0; + + func(ltohl(msg.dent.mode), + ltohl(msg.dent.size), + ltohl(msg.dent.time), + buf, cookie); + } + +fail: + sdb_close(fd); + return -1; +} + +typedef struct syncsendbuf syncsendbuf; + +struct syncsendbuf { + unsigned id; + unsigned size; + char data[SYNC_DATA_MAX]; +}; + +static syncsendbuf send_buffer; + +int sync_readtime(int fd, const char *path, unsigned *timestamp) +{ + syncmsg msg; + int len = strlen(path); + + msg.req.id = ID_STAT; + msg.req.namelen = htoll(len); + + if(writex(fd, &msg.req, sizeof(msg.req)) || + writex(fd, path, len)) { + return -1; + } + + if(readx(fd, &msg.stat, sizeof(msg.stat))) { + return -1; + } + + if(msg.stat.id != ID_STAT) { + return -1; + } + + *timestamp = ltohl(msg.stat.time); + return 0; +} + +static int sync_start_readtime(int fd, const char *path) +{ + syncmsg msg; + int len = strlen(path); + + msg.req.id = ID_STAT; + msg.req.namelen = htoll(len); + + if(writex(fd, &msg.req, sizeof(msg.req)) || + writex(fd, path, len)) { + return -1; + } + + return 0; +} + +static int sync_finish_readtime(int fd, unsigned int *timestamp, + unsigned int *mode, unsigned int *size) +{ + syncmsg msg; + + if(readx(fd, &msg.stat, sizeof(msg.stat))) + return -1; + + if(msg.stat.id != ID_STAT) + return -1; + + *timestamp = ltohl(msg.stat.time); + *mode = ltohl(msg.stat.mode); + *size = ltohl(msg.stat.size); + + return 0; +} + +int sync_readmode(int fd, const char *path, unsigned *mode) +{ + syncmsg msg; + int len = strlen(path); + + msg.req.id = ID_STAT; + msg.req.namelen = htoll(len); + + if(writex(fd, &msg.req, sizeof(msg.req)) || + writex(fd, path, len)) { + return -1; + } + + if(readx(fd, &msg.stat, sizeof(msg.stat))) { + return -1; + } + + if(msg.stat.id != ID_STAT) { + return -1; + } + + *mode = ltohl(msg.stat.mode); + return 0; +} + +static int write_data_file(int fd, const char *path, syncsendbuf *sbuf) +{ + int lfd, err = 0; + + lfd = sdb_open(path, O_RDONLY); + if(lfd < 0) { + fprintf(stderr,"cannot open '%s': %s\n", path, strerror(errno)); + return -1; + } + + sbuf->id = ID_DATA; + for(;;) { + int ret; + + ret = sdb_read(lfd, sbuf->data, SYNC_DATA_MAX); + if(!ret) + break; + + if(ret < 0) { + if(errno == EINTR) + continue; + fprintf(stderr,"cannot read '%s': %s\n", path, strerror(errno)); + break; + } + + sbuf->size = htoll(ret); + if(writex(fd, sbuf, sizeof(unsigned) * 2 + ret)){ + err = -1; + break; + } + total_bytes += ret; + } + + sdb_close(lfd); + return err; +} + +static int write_data_buffer(int fd, char* file_buffer, int size, syncsendbuf *sbuf) +{ + int err = 0; + int total = 0; + + sbuf->id = ID_DATA; + while (total < size) { + int count = size - total; + if (count > SYNC_DATA_MAX) { + count = SYNC_DATA_MAX; + } + + memcpy(sbuf->data, &file_buffer[total], count); + sbuf->size = htoll(count); + if(writex(fd, sbuf, sizeof(unsigned) * 2 + count)){ + err = -1; + break; + } + total += count; + total_bytes += count; + } + + return err; +} + +#ifdef HAVE_SYMLINKS +static int write_data_link(int fd, const char *path, syncsendbuf *sbuf) +{ + int len, ret; + + len = readlink(path, sbuf->data, SYNC_DATA_MAX-1); + if(len < 0) { + fprintf(stderr, "error reading link '%s': %s\n", path, strerror(errno)); + return -1; + } + sbuf->data[len] = '\0'; + + sbuf->size = htoll(len + 1); + sbuf->id = ID_DATA; + + ret = writex(fd, sbuf, sizeof(unsigned) * 2 + len + 1); + if(ret) + return -1; + + total_bytes += len + 1; + + return 0; +} +#endif + +static int sync_send(int fd, const char *lpath, const char *rpath, + unsigned mtime, mode_t mode, int verifyApk) +{ + syncmsg msg; + int len, r; + syncsendbuf *sbuf = &send_buffer; + char* file_buffer = NULL; + int size = 0; + char tmp[64]; + + len = strlen(rpath); + if(len > 1024) goto fail; + + snprintf(tmp, sizeof(tmp), ",%d", mode); + r = strlen(tmp); + + if (verifyApk) { +#if 0 //eric + int lfd; + zipfile_t zip; + zipentry_t entry; + int amt; + + // if we are transferring an APK file, then sanity check to make sure + // we have a real zip file that contains an AndroidManifest.xml + // this requires that we read the entire file into memory. + lfd = sdb_open(lpath, O_RDONLY); + if(lfd < 0) { + fprintf(stderr,"cannot open '%s': %s\n", lpath, strerror(errno)); + return -1; + } + + size = sdb_lseek(lfd, 0, SEEK_END); + if (size == -1 || -1 == sdb_lseek(lfd, 0, SEEK_SET)) { + fprintf(stderr, "error seeking in file '%s'\n", lpath); + sdb_close(lfd); + return 1; + } + + file_buffer = (char *)malloc(size); + if (file_buffer == NULL) { + fprintf(stderr, "could not allocate buffer for '%s'\n", + lpath); + sdb_close(lfd); + return 1; + } + amt = sdb_read(lfd, file_buffer, size); + if (amt != size) { + fprintf(stderr, "error reading from file: '%s'\n", lpath); + sdb_close(lfd); + free(file_buffer); + return 1; + } + + sdb_close(lfd); + + zip = init_zipfile(file_buffer, size); + if (zip == NULL) { + fprintf(stderr, "file '%s' is not a valid zip file\n", + lpath); + free(file_buffer); + return 1; + } + + entry = lookup_zipentry(zip, "AndroidManifest.xml"); + release_zipfile(zip); + if (entry == NULL) { + fprintf(stderr, "file '%s' does not contain AndroidManifest.xml\n", + lpath); + free(file_buffer); + return 1; + } +#endif + } + + msg.req.id = ID_SEND; + msg.req.namelen = htoll(len + r); + + if(writex(fd, &msg.req, sizeof(msg.req)) || + writex(fd, rpath, len) || writex(fd, tmp, r)) { + free(file_buffer); + goto fail; + } + + if (file_buffer) { + write_data_buffer(fd, file_buffer, size, sbuf); + free(file_buffer); + } else if (S_ISREG(mode)) + write_data_file(fd, lpath, sbuf); +#ifdef HAVE_SYMLINKS + else if (S_ISLNK(mode)) + write_data_link(fd, lpath, sbuf); +#endif + else + goto fail; + + msg.data.id = ID_DONE; + msg.data.size = htoll(mtime); + if(writex(fd, &msg.data, sizeof(msg.data))) + goto fail; + + if(readx(fd, &msg.status, sizeof(msg.status))) + return -1; + + if(msg.status.id != ID_OKAY) { + if(msg.status.id == ID_FAIL) { + len = ltohl(msg.status.msglen); + if(len > 256) len = 256; + if(readx(fd, sbuf->data, len)) { + return -1; + } + sbuf->data[len] = 0; + } else + strcpy(sbuf->data, "unknown reason"); + + fprintf(stderr,"failed to copy '%s' to '%s': %s\n", lpath, rpath, sbuf->data); + return -1; + } + + return 0; + +fail: + fprintf(stderr,"protocol failure\n"); + sdb_close(fd); + return -1; +} + +static int mkdirs(char *name) +{ + int ret; + char *x = name + 1; + + for(;;) { + x = sdb_dirstart(x); + if(x == 0) return 0; + *x = 0; + ret = sdb_mkdir(name, 0775); + *x = OS_PATH_SEPARATOR; + if((ret < 0) && (errno != EEXIST)) { + return ret; + } + x++; + } + return 0; +} + +int sync_recv(int fd, const char *rpath, const char *lpath) +{ + syncmsg msg; + int len; + int lfd = -1; + char *buffer = send_buffer.data; + unsigned id; + + len = strlen(rpath); + if(len > 1024) return -1; + + msg.req.id = ID_RECV; + msg.req.namelen = htoll(len); + if(writex(fd, &msg.req, sizeof(msg.req)) || + writex(fd, rpath, len)) { + return -1; + } + + if(readx(fd, &msg.data, sizeof(msg.data))) { + return -1; + } + id = msg.data.id; + + if((id == ID_DATA) || (id == ID_DONE)) { + sdb_unlink(lpath); + mkdirs((char *)lpath); + lfd = sdb_creat(lpath, 0644); + if(lfd < 0) { + fprintf(stderr,"cannot create '%s': %s\n", lpath, strerror(errno)); + return -1; + } + goto handle_data; + } else { + goto remote_error; + } + + for(;;) { + if(readx(fd, &msg.data, sizeof(msg.data))) { + return -1; + } + id = msg.data.id; + + handle_data: + len = ltohl(msg.data.size); + if(id == ID_DONE) break; + if(id != ID_DATA) goto remote_error; + if(len > SYNC_DATA_MAX) { + fprintf(stderr,"data overrun\n"); + sdb_close(lfd); + return -1; + } + + if(readx(fd, buffer, len)) { + sdb_close(lfd); + return -1; + } + + if(writex(lfd, buffer, len)) { + fprintf(stderr,"cannot write '%s': %s\n", rpath, strerror(errno)); + sdb_close(lfd); + return -1; + } + + total_bytes += len; + } + + sdb_close(lfd); + return 0; + +remote_error: + sdb_close(lfd); + sdb_unlink(lpath); + + if(id == ID_FAIL) { + len = ltohl(msg.data.size); + if(len > 256) len = 256; + if(readx(fd, buffer, len)) { + return -1; + } + buffer[len] = 0; + } else { + memcpy(buffer, &id, 4); + buffer[4] = 0; +// strcpy(buffer,"unknown reason"); + } + fprintf(stderr,"failed to copy '%s' to '%s': %s\n", rpath, lpath, buffer); + return 0; +} + + + +/* --- */ + + +static void do_sync_ls_cb(unsigned mode, unsigned size, unsigned time, + const char *name, void *cookie) +{ + printf("%08x %08x %08x %s\n", mode, size, time, name); +} + +int do_sync_ls(const char *path) +{ + int fd = sdb_connect("sync:"); + if(fd < 0) { + fprintf(stderr,"error: %s\n", sdb_error()); + return 1; + } + + if(sync_ls(fd, path, do_sync_ls_cb, 0)) { + return 1; + } else { + sync_quit(fd); + return 0; + } +} + +typedef struct copyinfo copyinfo; + +struct copyinfo +{ + copyinfo *next; + const char *src; + const char *dst; + unsigned int time; + unsigned int mode; + unsigned int size; + int flag; + //char data[0]; +}; + +copyinfo *mkcopyinfo(const char *spath, const char *dpath, + const char *name, int isdir) +{ + int slen = strlen(spath); + int dlen = strlen(dpath); + int nlen = strlen(name); + int ssize = slen + nlen + 2; + int dsize = dlen + nlen + 2; + + copyinfo *ci = malloc(sizeof(copyinfo) + ssize + dsize); + if(ci == 0) { + fprintf(stderr,"out of memory\n"); + abort(); + } + + ci->next = 0; + ci->time = 0; + ci->mode = 0; + ci->size = 0; + ci->flag = 0; + ci->src = (const char*)(ci + 1); + ci->dst = ci->src + ssize; + snprintf((char*) ci->src, ssize, isdir ? "%s%s/" : "%s%s", spath, name); + snprintf((char*) ci->dst, dsize, isdir ? "%s%s/" : "%s%s", dpath, name); + +// fprintf(stderr,"mkcopyinfo('%s','%s')\n", ci->src, ci->dst); + return ci; +} + + +static int local_build_list(copyinfo **filelist, + const char *lpath, const char *rpath) +{ + DIR *d; + struct dirent *de; + struct stat st; + copyinfo *dirlist = 0; + copyinfo *ci, *next; + +// fprintf(stderr,"local_build_list('%s','%s')\n", lpath, rpath); + + d = opendir(lpath); + if(d == 0) { + fprintf(stderr,"cannot open '%s': %s\n", lpath, strerror(errno)); + return -1; + } + + while((de = readdir(d))) { + char stat_path[PATH_MAX]; + char *name = de->d_name; + + if(name[0] == '.') { + if(name[1] == 0) continue; + if((name[1] == '.') && (name[2] == 0)) continue; + } + + /* + * We could use d_type if HAVE_DIRENT_D_TYPE is defined, but reiserfs + * always returns DT_UNKNOWN, so we just use stat() for all cases. + */ + if (strlen(lpath) + strlen(de->d_name) + 1 > sizeof(stat_path)) + continue; + strcpy(stat_path, lpath); + strcat(stat_path, de->d_name); + stat(stat_path, &st); + + if (S_ISDIR(st.st_mode)) { + ci = mkcopyinfo(lpath, rpath, name, 1); + ci->next = dirlist; + dirlist = ci; + } else { + ci = mkcopyinfo(lpath, rpath, name, 0); + if(lstat(ci->src, &st)) { + closedir(d); + fprintf(stderr,"cannot stat '%s': %s\n", ci->src, strerror(errno)); + return -1; + } + if(!S_ISREG(st.st_mode) && !S_ISLNK(st.st_mode)) { + fprintf(stderr, "skipping special file '%s'\n", ci->src); + free(ci); + } else { + ci->time = st.st_mtime; + ci->mode = st.st_mode; + ci->size = st.st_size; + ci->next = *filelist; + *filelist = ci; + } + } + } + + closedir(d); + + for(ci = dirlist; ci != 0; ci = next) { + next = ci->next; + local_build_list(filelist, ci->src, ci->dst); + free(ci); + } + + return 0; +} + + +static int copy_local_dir_remote(int fd, const char *lpath, const char *rpath, int checktimestamps, int listonly) +{ + copyinfo *filelist = 0; + copyinfo *ci, *next; + int pushed = 0; + int skipped = 0; + + if((lpath[0] == 0) || (rpath[0] == 0)) return -1; + if(lpath[strlen(lpath) - 1] != '/') { + int tmplen = strlen(lpath)+2; + char *tmp = malloc(tmplen); + if(tmp == 0) return -1; + snprintf(tmp, tmplen, "%s/",lpath); + lpath = tmp; + } + if(rpath[strlen(rpath) - 1] != '/') { + int tmplen = strlen(rpath)+2; + char *tmp = malloc(tmplen); + if(tmp == 0) return -1; + snprintf(tmp, tmplen, "%s/",rpath); + rpath = tmp; + } + + if(local_build_list(&filelist, lpath, rpath)) { + return -1; + } + + if(checktimestamps){ + for(ci = filelist; ci != 0; ci = ci->next) { + if(sync_start_readtime(fd, ci->dst)) { + return 1; + } + } + for(ci = filelist; ci != 0; ci = ci->next) { + unsigned int timestamp, mode, size; + if(sync_finish_readtime(fd, ×tamp, &mode, &size)) + return 1; + 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->flag = 1; + } + } + } + for(ci = filelist; ci != 0; ci = next) { + next = ci->next; + if(ci->flag == 0) { + fprintf(stderr,"%spush: %s -> %s\n", listonly ? "would " : "", ci->src, ci->dst); + if(!listonly && + sync_send(fd, ci->src, ci->dst, ci->time, ci->mode, 0 /* no verify APK */)){ + return 1; + } + pushed++; + } else { + skipped++; + } + free(ci); + } + + fprintf(stderr,"%d file%s pushed. %d file%s skipped.\n", + pushed, (pushed == 1) ? "" : "s", + skipped, (skipped == 1) ? "" : "s"); + + return 0; +} + + +int do_sync_push(const char *lpath, const char *rpath, int verifyApk) +{ + struct stat st; + unsigned mode; + int fd; + + fd = sdb_connect("sync:"); + if(fd < 0) { + fprintf(stderr,"error: %s\n", sdb_error()); + return 1; + } + + if(stat(lpath, &st)) { + fprintf(stderr,"cannot stat '%s': %s\n", lpath, strerror(errno)); + sync_quit(fd); + return 1; + } + + if(S_ISDIR(st.st_mode)) { + BEGIN(); + if(copy_local_dir_remote(fd, lpath, rpath, 0, 0)) { + return 1; + } else { + END(); + sync_quit(fd); + } + } else { + if(sync_readmode(fd, rpath, &mode)) { + return 1; + } + if((mode != 0) && S_ISDIR(mode)) { + /* if we're copying a local file to a remote directory, + ** we *really* want to copy to remotedir + "/" + localfilename + */ + const char *name = sdb_dirstop(lpath); + if(name == 0) { + name = lpath; + } else { + name++; + } + int tmplen = strlen(name) + strlen(rpath) + 2; + char *tmp = malloc(strlen(name) + strlen(rpath) + 2); + if(tmp == 0) return 1; + snprintf(tmp, tmplen, "%s/%s", rpath, name); + rpath = tmp; + } + BEGIN(); + if(sync_send(fd, lpath, rpath, st.st_mtime, st.st_mode, verifyApk)) { + return 1; + } else { + END(); + sync_quit(fd); + return 0; + } + } + + return 0; +} + + +typedef struct { + copyinfo **filelist; + copyinfo **dirlist; + const char *rpath; + const char *lpath; +} sync_ls_build_list_cb_args; + +void +sync_ls_build_list_cb(unsigned mode, unsigned size, unsigned time, + const char *name, void *cookie) +{ + sync_ls_build_list_cb_args *args = (sync_ls_build_list_cb_args *)cookie; + copyinfo *ci; + + if (S_ISDIR(mode)) { + copyinfo **dirlist = args->dirlist; + + /* Don't try recursing down "." or ".." */ + if (name[0] == '.') { + if (name[1] == '\0') return; + if ((name[1] == '.') && (name[2] == '\0')) return; + } + + ci = mkcopyinfo(args->rpath, args->lpath, name, 1); + ci->next = *dirlist; + *dirlist = ci; + } else if (S_ISREG(mode) || S_ISLNK(mode)) { + copyinfo **filelist = args->filelist; + + ci = mkcopyinfo(args->rpath, args->lpath, name, 0); + ci->time = time; + ci->mode = mode; + ci->size = size; + ci->next = *filelist; + *filelist = ci; + } else { + fprintf(stderr, "skipping special file '%s'\n", name); + } +} + +static int remote_build_list(int syncfd, copyinfo **filelist, + const char *rpath, const char *lpath) +{ + copyinfo *dirlist = NULL; + sync_ls_build_list_cb_args args; + + args.filelist = filelist; + args.dirlist = &dirlist; + args.rpath = rpath; + args.lpath = lpath; + + /* Put the files/dirs in rpath on the lists. */ + if (sync_ls(syncfd, rpath, sync_ls_build_list_cb, (void *)&args)) { + return 1; + } + + /* Recurse into each directory we found. */ + while (dirlist != NULL) { + copyinfo *next = dirlist->next; + if (remote_build_list(syncfd, filelist, dirlist->src, dirlist->dst)) { + return 1; + } + free(dirlist); + dirlist = next; + } + + return 0; +} + +static int copy_remote_dir_local(int fd, const char *rpath, const char *lpath, + int checktimestamps) +{ + copyinfo *filelist = 0; + copyinfo *ci, *next; + int pulled = 0; + int skipped = 0; + + /* Make sure that both directory paths end in a slash. */ + if (rpath[0] == 0 || lpath[0] == 0) return -1; + if (rpath[strlen(rpath) - 1] != '/') { + int tmplen = strlen(rpath) + 2; + char *tmp = malloc(tmplen); + if (tmp == 0) return -1; + snprintf(tmp, tmplen, "%s/", rpath); + rpath = tmp; + } + if (lpath[strlen(lpath) - 1] != '/') { + int tmplen = strlen(lpath) + 2; + char *tmp = malloc(tmplen); + if (tmp == 0) return -1; + snprintf(tmp, tmplen, "%s/", lpath); + lpath = tmp; + } + + fprintf(stderr, "pull: building file list...\n"); + /* Recursively build the list of files to copy. */ + if (remote_build_list(fd, &filelist, rpath, lpath)) { + return -1; + } + +#if 0 + if (checktimestamps) { + for (ci = filelist; ci != 0; ci = ci->next) { + if (sync_start_readtime(fd, ci->dst)) { + return 1; + } + } + for (ci = filelist; ci != 0; ci = ci->next) { + unsigned int timestamp, mode, size; + if (sync_finish_readtime(fd, ×tamp, &mode, &size)) + return 1; + 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->flag = 1; + } + } + } +#endif + for (ci = filelist; ci != 0; ci = next) { + next = ci->next; + if (ci->flag == 0) { + fprintf(stderr, "pull: %s -> %s\n", ci->src, ci->dst); + if (sync_recv(fd, ci->src, ci->dst)) { + return 1; + } + pulled++; + } else { + skipped++; + } + free(ci); + } + + fprintf(stderr, "%d file%s pulled. %d file%s skipped.\n", + pulled, (pulled == 1) ? "" : "s", + skipped, (skipped == 1) ? "" : "s"); + + return 0; +} + +int do_sync_pull(const char *rpath, const char *lpath) +{ + unsigned mode; + struct stat st; + + int fd; + + fd = sdb_connect("sync:"); + if(fd < 0) { + fprintf(stderr,"error: %s\n", sdb_error()); + return 1; + } + + if(sync_readmode(fd, rpath, &mode)) { + return 1; + } + if(mode == 0) { + fprintf(stderr,"remote object '%s' does not exist\n", rpath); + return 1; + } + + if(S_ISREG(mode) || S_ISLNK(mode) || S_ISCHR(mode) || S_ISBLK(mode)) { + if(stat(lpath, &st) == 0) { + if(S_ISDIR(st.st_mode)) { + /* if we're copying a remote file to a local directory, + ** we *really* want to copy to localdir + "/" + remotefilename + */ + const char *name = sdb_dirstop(rpath); + if(name == 0) { + name = rpath; + } else { + name++; + } + int tmplen = strlen(name) + strlen(lpath) + 2; + char *tmp = malloc(tmplen); + if(tmp == 0) return 1; + snprintf(tmp, tmplen, "%s/%s", lpath, name); + lpath = tmp; + } + } + BEGIN(); + if(sync_recv(fd, rpath, lpath)) { + return 1; + } else { + END(); + sync_quit(fd); + return 0; + } + } else if(S_ISDIR(mode)) { + BEGIN(); + if (copy_remote_dir_local(fd, rpath, lpath, 0)) { + return 1; + } else { + END(); + sync_quit(fd); + return 0; + } + } else { + fprintf(stderr,"remote object '%s' not a file or directory\n", rpath); + return 1; + } +} + +int do_sync_sync(const char *lpath, const char *rpath, int listonly) +{ + fprintf(stderr,"syncing %s...\n",rpath); + + int fd = sdb_connect("sync:"); + if(fd < 0) { + fprintf(stderr,"error: %s\n", sdb_error()); + return 1; + } + + BEGIN(); + if(copy_local_dir_remote(fd, lpath, rpath, 1, listonly)){ + return 1; + } else { + END(); + sync_quit(fd); + return 0; + } +} diff --git a/src/file_sync_service.c b/src/file_sync_service.c new file mode 100644 index 0000000..8043d7e --- /dev/null +++ b/src/file_sync_service.c @@ -0,0 +1,412 @@ +/* + * 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 "sysdeps.h" + +#define TRACE_TAG TRACE_SYNC +#include "sdb.h" +#include "file_sync_service.h" + +static int mkdirs(char *name) +{ + int ret; + char *x = name + 1; + + if(name[0] != '/') return -1; + + for(;;) { + x = sdb_dirstart(x); + if(x == 0) return 0; + *x = 0; + ret = sdb_mkdir(name, 0775); + if((ret < 0) && (errno != EEXIST)) { + D("mkdir(\"%s\") -> %s\n", name, strerror(errno)); + *x = '/'; + return ret; + } + *x++ = '/'; + } + return 0; +} + +static int do_stat(int s, const char *path) +{ + syncmsg msg; + struct stat st; + + msg.stat.id = ID_STAT; + + if(lstat(path, &st)) { + msg.stat.mode = 0; + msg.stat.size = 0; + msg.stat.time = 0; + } else { + msg.stat.mode = htoll(st.st_mode); + msg.stat.size = htoll(st.st_size); + msg.stat.time = htoll(st.st_mtime); + } + + return writex(s, &msg.stat, sizeof(msg.stat)); +} + +static int do_list(int s, const char *path) +{ + DIR *d; + struct dirent *de; + struct stat st; + syncmsg msg; + int len; + + char tmp[1024 + 256 + 1]; + char *fname; + + len = strlen(path); + memcpy(tmp, path, len); + tmp[len] = '/'; + fname = tmp + len + 1; + + msg.dent.id = ID_DENT; + + d = opendir(path); + if(d == 0) goto done; + + while((de = readdir(d))) { + int len = strlen(de->d_name); + + /* not supposed to be possible, but + if it does happen, let's not buffer overrun */ + if(len > 256) continue; + + strcpy(fname, de->d_name); + if(lstat(tmp, &st) == 0) { + msg.dent.mode = htoll(st.st_mode); + msg.dent.size = htoll(st.st_size); + msg.dent.time = htoll(st.st_mtime); + msg.dent.namelen = htoll(len); + + if(writex(s, &msg.dent, sizeof(msg.dent)) || + writex(s, de->d_name, len)) { + return -1; + } + } + } + + closedir(d); + +done: + msg.dent.id = ID_DONE; + msg.dent.mode = 0; + msg.dent.size = 0; + msg.dent.time = 0; + msg.dent.namelen = 0; + return writex(s, &msg.dent, sizeof(msg.dent)); +} + +static int fail_message(int s, const char *reason) +{ + syncmsg msg; + int len = strlen(reason); + + D("sync: failure: %s\n", reason); + + msg.data.id = ID_FAIL; + msg.data.size = htoll(len); + if(writex(s, &msg.data, sizeof(msg.data)) || + writex(s, reason, len)) { + return -1; + } else { + return 0; + } +} + +static int fail_errno(int s) +{ + return fail_message(s, strerror(errno)); +} + +static int handle_send_file(int s, char *path, mode_t mode, char *buffer) +{ + syncmsg msg; + unsigned int timestamp = 0; + int fd; + + fd = sdb_open_mode(path, O_WRONLY | O_CREAT | O_EXCL, mode); + if(fd < 0 && errno == ENOENT) { + mkdirs(path); + fd = sdb_open_mode(path, O_WRONLY | O_CREAT | O_EXCL, mode); + } + if(fd < 0 && errno == EEXIST) { + fd = sdb_open_mode(path, O_WRONLY, mode); + } + if(fd < 0) { + if(fail_errno(s)) + return -1; + fd = -1; + } + + for(;;) { + unsigned int len; + + if(readx(s, &msg.data, sizeof(msg.data))) + goto fail; + + if(msg.data.id != ID_DATA) { + if(msg.data.id == ID_DONE) { + timestamp = ltohl(msg.data.size); + break; + } + fail_message(s, "invalid data message"); + goto fail; + } + len = ltohl(msg.data.size); + if(len > SYNC_DATA_MAX) { + fail_message(s, "oversize data message"); + goto fail; + } + if(readx(s, buffer, len)) + goto fail; + + if(fd < 0) + continue; + if(writex(fd, buffer, len)) { + sdb_close(fd); + sdb_unlink(path); + fd = -1; + if(fail_errno(s)) return -1; + } + } + + if(fd >= 0) { + struct utimbuf u; + sdb_close(fd); + u.actime = timestamp; + u.modtime = timestamp; + utime(path, &u); + + msg.status.id = ID_OKAY; + msg.status.msglen = 0; + if(writex(s, &msg.status, sizeof(msg.status))) + return -1; + } + return 0; + +fail: + if(fd >= 0) + sdb_close(fd); + sdb_unlink(path); + return -1; +} + +#ifdef HAVE_SYMLINKS +static int handle_send_link(int s, char *path, char *buffer) +{ + syncmsg msg; + unsigned int len; + int ret; + + if(readx(s, &msg.data, sizeof(msg.data))) + return -1; + + if(msg.data.id != ID_DATA) { + fail_message(s, "invalid data message: expected ID_DATA"); + return -1; + } + + len = ltohl(msg.data.size); + if(len > SYNC_DATA_MAX) { + fail_message(s, "oversize data message"); + return -1; + } + if(readx(s, buffer, len)) + return -1; + + ret = symlink(buffer, path); + if(ret && errno == ENOENT) { + mkdirs(path); + ret = symlink(buffer, path); + } + if(ret) { + fail_errno(s); + return -1; + } + + if(readx(s, &msg.data, sizeof(msg.data))) + return -1; + + if(msg.data.id == ID_DONE) { + msg.status.id = ID_OKAY; + msg.status.msglen = 0; + if(writex(s, &msg.status, sizeof(msg.status))) + return -1; + } else { + fail_message(s, "invalid data message: expected ID_DONE"); + return -1; + } + + return 0; +} +#endif /* HAVE_SYMLINKS */ + +static int do_send(int s, char *path, char *buffer) +{ + char *tmp; + mode_t mode; + int is_link, ret; + + tmp = strrchr(path,','); + if(tmp) { + *tmp = 0; + errno = 0; + mode = strtoul(tmp + 1, NULL, 0); +#ifndef HAVE_SYMLINKS + is_link = 0; +#else + is_link = S_ISLNK(mode); +#endif + mode &= 0777; + } + if(!tmp || errno) { + mode = 0644; + is_link = 0; + } + + sdb_unlink(path); + + +#ifdef HAVE_SYMLINKS + if(is_link) + ret = handle_send_link(s, path, buffer); + else { +#else + { +#endif + /* copy user permission bits to "group" and "other" permissions */ + mode |= ((mode >> 3) & 0070); + mode |= ((mode >> 3) & 0007); + + ret = handle_send_file(s, path, mode, buffer); + } + + return ret; +} + +static int do_recv(int s, const char *path, char *buffer) +{ + syncmsg msg; + int fd, r; + + fd = sdb_open(path, O_RDONLY); + if(fd < 0) { + if(fail_errno(s)) return -1; + return 0; + } + + msg.data.id = ID_DATA; + for(;;) { + r = sdb_read(fd, buffer, SYNC_DATA_MAX); + if(r <= 0) { + if(r == 0) break; + if(errno == EINTR) continue; + r = fail_errno(s); + sdb_close(fd); + return r; + } + msg.data.size = htoll(r); + if(writex(s, &msg.data, sizeof(msg.data)) || + writex(s, buffer, r)) { + sdb_close(fd); + return -1; + } + } + + sdb_close(fd); + + msg.data.id = ID_DONE; + msg.data.size = 0; + if(writex(s, &msg.data, sizeof(msg.data))) { + return -1; + } + + return 0; +} + +void file_sync_service(int fd, void *cookie) +{ + syncmsg msg; + char name[1025]; + unsigned namelen; + + char *buffer = malloc(SYNC_DATA_MAX); + if(buffer == 0) goto fail; + + for(;;) { + D("sync: waiting for command\n"); + + if(readx(fd, &msg.req, sizeof(msg.req))) { + fail_message(fd, "command read failure"); + break; + } + namelen = ltohl(msg.req.namelen); + if(namelen > 1024) { + fail_message(fd, "invalid namelen"); + break; + } + if(readx(fd, name, namelen)) { + fail_message(fd, "filename read failure"); + break; + } + name[namelen] = 0; + + msg.req.namelen = 0; + D("sync: '%s' '%s'\n", (char*) &msg.req, name); + + switch(msg.req.id) { + case ID_STAT: + if(do_stat(fd, name)) goto fail; + break; + case ID_LIST: + if(do_list(fd, name)) goto fail; + break; + case ID_SEND: + if(do_send(fd, name, buffer)) goto fail; + break; + case ID_RECV: + if(do_recv(fd, name, buffer)) goto fail; + break; + case ID_QUIT: + goto fail; + default: + fail_message(fd, "unknown command"); + goto fail; + } + } + +fail: + if(buffer != 0) free(buffer); + D("sync: done\n"); + sdb_close(fd); +} diff --git a/src/file_sync_service.h b/src/file_sync_service.h new file mode 100644 index 0000000..11ea06b --- /dev/null +++ b/src/file_sync_service.h @@ -0,0 +1,87 @@ +/* + * 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_ + +#ifdef __ppc__ +static inline unsigned __swap_uint32(unsigned x) +{ + return (((x) & 0xFF000000) >> 24) + | (((x) & 0x00FF0000) >> 8) + | (((x) & 0x0000FF00) << 8) + | (((x) & 0x000000FF) << 24); +} +#define htoll(x) __swap_uint32(x) +#define ltohl(x) __swap_uint32(x) +#define MKID(a,b,c,d) ((d) | ((c) << 8) | ((b) << 16) | ((a) << 24)) +#else +#define htoll(x) (x) +#define ltohl(x) (x) +#define MKID(a,b,c,d) ((a) | ((b) << 8) | ((c) << 16) | ((d) << 24)) +#endif + +#define ID_STAT MKID('S','T','A','T') +#define ID_LIST MKID('L','I','S','T') +#define ID_ULNK MKID('U','L','N','K') +#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') + +typedef union { + unsigned id; + struct { + unsigned id; + unsigned namelen; + } req; + struct { + unsigned id; + unsigned mode; + unsigned size; + unsigned time; + } stat; + struct { + unsigned id; + unsigned mode; + unsigned size; + unsigned time; + unsigned namelen; + } dent; + struct { + unsigned id; + unsigned size; + } data; + struct { + unsigned id; + unsigned msglen; + } status; +} syncmsg; + + +void file_sync_service(int fd, void *cookie); +int do_sync_ls(const char *path); +int do_sync_push(const char *lpath, const char *rpath, int verifyApk); +int do_sync_sync(const char *lpath, const char *rpath, int listonly); +int do_sync_pull(const char *rpath, const char *lpath); + +#define SYNC_DATA_MAX (64*1024) + +#endif diff --git a/src/framebuffer_service.c b/src/framebuffer_service.c new file mode 100644 index 0000000..acf8173 --- /dev/null +++ b/src/framebuffer_service.c @@ -0,0 +1,106 @@ +/* + * 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 "fdevent.h" +#include "sdb.h" + +#include +#include +#include + +/* 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 fb_var_screeninfo vinfo; + int fb, offset; + char x[256]; + + struct fbinfo fbinfo; + unsigned i, bytespp; + + fb = open("/dev/graphics/fb0", O_RDONLY); + if(fb < 0) goto done; + + if(ioctl(fb, FBIOGET_VSCREENINFO, &vinfo) < 0) goto done; + fcntl(fb, F_SETFD, FD_CLOEXEC); + + bytespp = vinfo.bits_per_pixel / 8; + + fbinfo.version = DDMS_RAWIMAGE_VERSION; + fbinfo.bpp = vinfo.bits_per_pixel; + fbinfo.size = vinfo.xres * vinfo.yres * bytespp; + fbinfo.width = vinfo.xres; + fbinfo.height = vinfo.yres; + fbinfo.red_offset = vinfo.red.offset; + fbinfo.red_length = vinfo.red.length; + fbinfo.green_offset = vinfo.green.offset; + fbinfo.green_length = vinfo.green.length; + fbinfo.blue_offset = vinfo.blue.offset; + fbinfo.blue_length = vinfo.blue.length; + fbinfo.alpha_offset = vinfo.transp.offset; + fbinfo.alpha_length = vinfo.transp.length; + + /* HACK: for several of our 3d cores a specific alignment + * is required so the start of the fb may not be an integer number of lines + * from the base. As a result we are storing the additional offset in + * xoffset. This is not the correct usage for xoffset, it should be added + * to each line, not just once at the beginning */ + offset = vinfo.xoffset * bytespp; + + offset += vinfo.xres * vinfo.yoffset * bytespp; + + if(writex(fd, &fbinfo, sizeof(fbinfo))) goto done; + + lseek(fb, offset, SEEK_SET); + for(i = 0; i < fbinfo.size; i += 256) { + if(readx(fb, &x, 256)) goto done; + if(writex(fd, &x, 256)) goto done; + } + + if(readx(fb, &x, fbinfo.size % 256)) goto done; + if(writex(fd, &x, fbinfo.size % 256)) goto done; + +done: + if(fb >= 0) close(fb); + close(fd); +} diff --git a/src/get_my_path_darwin.c b/src/get_my_path_darwin.c new file mode 100644 index 0000000..5b95d15 --- /dev/null +++ b/src/get_my_path_darwin.c @@ -0,0 +1,30 @@ +/* + * 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 + +void get_my_path(char *s, size_t maxLen) +{ + ProcessSerialNumber psn; + GetCurrentProcess(&psn); + CFDictionaryRef dict; + dict = ProcessInformationCopyDictionary(&psn, 0xffffffff); + CFStringRef value = (CFStringRef)CFDictionaryGetValue(dict, + CFSTR("CFBundleExecutable")); + CFStringGetCString(value, s, maxLen, kCFStringEncodingUTF8); +} + diff --git a/src/get_my_path_freebsd.c b/src/get_my_path_freebsd.c new file mode 100644 index 0000000..b06ec66 --- /dev/null +++ b/src/get_my_path_freebsd.c @@ -0,0 +1,36 @@ +/* + * Copyright (C) 2009 bsdroid project + * Alexey Tarasov + * + * 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 + +void +get_my_path(char *exe, size_t maxLen) +{ + char proc[64]; + + snprintf(proc, sizeof(proc), "/proc/%d/file", getpid()); + + int err = readlink(proc, exe, maxLen - 1); + + exe[err > 0 ? err : 0] = '\0'; +} + diff --git a/src/get_my_path_linux.c b/src/get_my_path_linux.c new file mode 100644 index 0000000..179c3dd --- /dev/null +++ b/src/get_my_path_linux.c @@ -0,0 +1,33 @@ +/* + * 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 + +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'; + } +} + diff --git a/src/get_my_path_windows.c b/src/get_my_path_windows.c new file mode 100644 index 0000000..ddf2816 --- /dev/null +++ b/src/get_my_path_windows.c @@ -0,0 +1,34 @@ +/* + * 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 + +void get_my_path(char *exe, size_t maxLen) +{ + char *r; + + /* XXX: should be GetModuleFileNameA */ + if (GetModuleFileName(NULL, exe, maxLen) > 0) { + r = strrchr(exe, '\\'); + if (r != NULL) + *r = '\0'; + } else { + exe[0] = '\0'; + } +} + diff --git a/src/jdwp_service.c b/src/jdwp_service.c new file mode 100644 index 0000000..6f22cdb --- /dev/null +++ b/src/jdwp_service.c @@ -0,0 +1,709 @@ +/* implement the "debug-ports" and "track-debug-ports" device services */ +#include "sysdeps.h" +#define TRACE_TAG TRACE_JDWP +#include "sdb.h" +#include +#include +#include + +/* here's how these things work. + + when sdbd 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 sdbd to detect dead + processes). + + sdbd 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 "sdb 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, + sdbd 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: + ____________________________________ + | | + | SDB Server (host) | + | | + Debugger <---> LocalSocket <----> RemoteSocket | + | ^^ | + |___________________________||_______| + || + Transport || + (TCP for emulator - USB for device) || + || + ___________________________||_______ + | || | + | SDBD (device) || | + | VV | + JDWP <======> LocalSocket <----> RemoteSocket | + | | + |____________________________________| + + due to the way sdb 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 !SDB_HOST + +#include +#include + +typedef struct JdwpProcess JdwpProcess; +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) { + sdb_shutdown(proc->socket); + sdb_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++) { + sdb_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 = calloc(1,sizeof(*proc)); + + if (proc == NULL) { + D("not enough memory to create new JDWP process\n"); + 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\n" ); + 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 = _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\n", + strerror(errno)); + + goto CloseProcess; + } + if (len == 0) { /* end of stream ? */ + D("weird end-of-stream from unknown JDWP process\n"); + 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'\n", proc, temp); + goto CloseProcess; + } + + /* all is well, keep reading to detect connection closure */ + D("Adding pid %d to jdwp process list\n", 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\n", proc->pid, + strerror(errno)); + break; + } + } + else { + D( "ignoring unexpected JDWP %d control socket activity (%d bytes)\n", + proc->pid, len ); + } + } + + CloseProcess: + if (proc->pid >= 0) + D( "remove pid %d to jdwp process list\n", proc->pid ); + jdwp_process_free(proc); + return; + } + } + + if (events & FDE_WRITE) { + D("trying to write to JDWP pid controli (count=%d first=%d) %d\n", + 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; + + for (;;) { + ret = sendmsg(proc->socket, &msg, 0); + if (ret >= 0) + break; + if (errno == EINTR) + continue; + D("sending new file descriptor to JDWP %d failed: %s\n", + proc->pid, strerror(errno)); + goto CloseProcess; + } + + D("sent file descriptor %d to JDWP process %d\n", + fd, proc->pid); + + for (n = 1; n < proc->out_count; n++) + proc->out_fds[n-1] = proc->out_fds[n]; + + 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\n", pid); + for ( ; proc != &_jdwp_list; proc = proc->next ) { + if (proc->pid == pid) { + goto FoundIt; + } + } + D("search failed !!\n"); + return -1; + +FoundIt: + { + int fds[2]; + + if (proc->out_count >= MAX_OUT_FDS) { + D("%s: too many pending JDWP connection for pid %d\n", + __FUNCTION__, pid); + return -1; + } + + if (sdb_socketpair(fds) < 0) { + D("%s: socket pair creation failed: %s\n", + __FUNCTION__, strerror(errno)); + return -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) + +typedef struct { + int listen_socket; + fdevent* fde; + +} JdwpControl; + + +static void +jdwp_control_event(int s, unsigned events, void* user); + + +static int +jdwp_control_init( JdwpControl* control, + const char* sockname, + int socknamelen ) +{ + struct 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)\n", + 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\n", + errno, strerror(errno)); + return -1; + } + + addrlen = (pathlen + sizeof(addr.sun_family)); + + if (bind(s, (struct sockaddr*)&addr, addrlen) < 0) { + D( "could not bind vm debug control socket: %d: %s\n", + errno, strerror(errno) ); + sdb_close(s); + return -1; + } + + if ( listen(s, 4) < 0 ) { + D("listen failed in jdwp control socket: %d: %s\n", + errno, strerror(errno)); + sdb_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\n" ); + sdb_close(s); + return -1; + } + + /* only wait for incoming connections */ + fdevent_add(control->fde, FDE_READ); + + D("jdwp control socket started (%d)\n", control->listen_socket); + return 0; +} + + +static void +jdwp_control_event( int s, unsigned events, void* _control ) +{ + JdwpControl* control = (JdwpControl*) _control; + + if (events & FDE_READ) { + struct sockaddr addr; + socklen_t addrlen = sizeof(addr); + int s = -1; + JdwpProcess* proc; + + do { + s = sdb_socket_accept( control->listen_socket, &addr, &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\n"); + return; + } + /* the socket is probably closed ? */ + D( "weird accept() failed on jdwp control socket: %s\n", + 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 + **/ + +typedef struct { + asocket socket; + int pass; +} JdwpSocket; + +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, MAX_PAYLOAD); + peer->enqueue(peer, p); + jdwp->pass = 1; + } + else { + peer->close(peer); + } +} + +asocket* +create_jdwp_service_socket( void ) +{ + JdwpSocket* s = 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... + **/ + +typedef struct JdwpTracker JdwpTracker; + +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, sizeof(p->data)); + 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 = 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 /* !SDB_HOST */ + diff --git a/src/mutex_list.h b/src/mutex_list.h new file mode 100644 index 0000000..8b62206 --- /dev/null +++ b/src/mutex_list.h @@ -0,0 +1,14 @@ +/* the list of mutexes used by addb */ +#ifndef SDB_MUTEX +#error SDB_MUTEX not defined when including this file +#endif + +SDB_MUTEX(dns_lock) +SDB_MUTEX(socket_list_lock) +SDB_MUTEX(transport_lock) +#if SDB_HOST +SDB_MUTEX(local_transports_lock) +#endif +SDB_MUTEX(usb_lock) + +#undef SDB_MUTEX diff --git a/src/protocol.txt b/src/protocol.txt new file mode 100644 index 0000000..e1e84d0 --- /dev/null +++ b/src/protocol.txt @@ -0,0 +1,252 @@ + +--- 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=4096 + +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 (informational only). + + +--- 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(0, 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_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" + diff --git a/src/remount_service.c b/src/remount_service.c new file mode 100644 index 0000000..c6332cd --- /dev/null +++ b/src/remount_service.c @@ -0,0 +1,111 @@ +/* + * 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. + */ + +#include +#include +#include +#include +#include +#include +#include + +#include "sysdeps.h" + +#define TRACE_TAG TRACE_SDB +#include "sdb.h" + + +static int system_ro = 1; + +/* Returns the device used to mount a directory in /proc/mounts */ +static char *find_mount(const char *dir) +{ + int fd; + int res; + int size; + char *token = NULL; + const char delims[] = "\n"; + char buf[4096]; + + fd = unix_open("/proc/mounts", O_RDONLY); + if (fd < 0) + return NULL; + + buf[sizeof(buf) - 1] = '\0'; + size = sdb_read(fd, buf, sizeof(buf) - 1); + sdb_close(fd); + + token = strtok(buf, delims); + + while (token) { + char mount_dev[256]; + char mount_dir[256]; + int mount_freq; + int mount_passno; + + res = sscanf(token, "%255s %255s %*s %*s %d %d\n", + mount_dev, mount_dir, &mount_freq, &mount_passno); + mount_dev[255] = 0; + mount_dir[255] = 0; + if (res == 4 && (strcmp(dir, mount_dir) == 0)) + return strdup(mount_dev); + + token = strtok(NULL, delims); + } + return NULL; +} + +/* Init mounts /system as read only, remount to enable writes. */ +static int remount_system() +{ + char *dev; + + if (system_ro == 0) { + return 0; + } + + dev = find_mount("/system"); + + if (!dev) + return -1; + + system_ro = mount(dev, "/system", "none", MS_REMOUNT, NULL); + + free(dev); + + return system_ro; +} + +static void write_string(int fd, const char* str) +{ + writex(fd, str, strlen(str)); +} + +void remount_service(int fd, void *cookie) +{ + int ret = remount_system(); + + if (!ret) + write_string(fd, "remount succeeded\n"); + else { + char buffer[200]; + snprintf(buffer, sizeof(buffer), "remount failed: %s\n", strerror(errno)); + write_string(fd, buffer); + } + + sdb_close(fd); +} + diff --git a/src/sdb.c b/src/sdb.c new file mode 100644 index 0000000..8fb3e28 --- /dev/null +++ b/src/sdb.c @@ -0,0 +1,1302 @@ +/* + * 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 TRACE_SDB + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "sysdeps.h" +#include "sdb.h" + +#if !SDB_HOST +//#include eric +#include +#include +#else +#include "usb_vendors.h" +#endif + + +int HOST = 0; + +void handle_sig_term(int sig) { + if (access("/dev/samsung_sdb", F_OK) == 0) { + exit(0); + } else { + // do nothing on a emulator + } +} + +static const char *sdb_device_banner = "device"; + +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); +} + +int sdb_trace_mask; + +/* read a comma/space/colum/semi-column separated list of tags + * from the SDB_TRACE environment variable and build the trace + * mask from it. note that '1' and 'all' are special cases to + * enable all tracing + */ +void sdb_trace_init(void) +{ + const char* p = getenv("SDB_TRACE"); + const char* q; + + static const struct { + const char* tag; + int flag; + } tags[] = { + { "1", 0 }, + { "all", 0 }, + { "sdb", TRACE_SDB }, + { "sockets", TRACE_SOCKETS }, + { "packets", TRACE_PACKETS }, + { "rwx", TRACE_RWX }, + { "usb", TRACE_USB }, + { "sync", TRACE_SYNC }, + { "sysdeps", TRACE_SYSDEPS }, + { "transport", TRACE_TRANSPORT }, + { "jdwp", TRACE_JDWP }, + { NULL, 0 } + }; + + if (p == NULL) + return; + + /* use a comma/column/semi-colum/space separated list */ + while (*p) { + int len, tagn; + + q = strpbrk(p, " ,:;"); + if (q == NULL) { + q = p + strlen(p); + } + len = q - p; + + for (tagn = 0; tags[tagn].tag != NULL; tagn++) + { + int taglen = strlen(tags[tagn].tag); + + if (len == taglen && !memcmp(tags[tagn].tag, p, len) ) + { + int flag = tags[tagn].flag; + if (flag == 0) { + sdb_trace_mask = ~0; + return; + } + sdb_trace_mask |= (1 << flag); + break; + } + } + p = q; + if (*p) + p++; + } +} + + +apacket *get_apacket(void) +{ + apacket *p = malloc(sizeof(apacket)); + if(p == 0) 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(void) +{ + D("sdb: online\n"); +} + +void handle_offline(atransport *t) +{ + D("sdb: offline\n"); + //Close the associated usb + run_transport_disconnects(t); +} + +#if TRACE_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; + 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++; + } + fprintf(stderr, tag); +} +#endif + +static void send_ready(unsigned local, unsigned remote, atransport *t) +{ + D("Calling send_ready \n"); + 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 \n"); + apacket *p = get_apacket(); + p->msg.command = A_CLSE; + p->msg.arg0 = local; + p->msg.arg1 = remote; + send_packet(p, t); +} + +static void send_connect(atransport *t) +{ + D("Calling send_connect \n"); + apacket *cp = get_apacket(); + cp->msg.command = A_CNXN; + cp->msg.arg0 = A_VERSION; + cp->msg.arg1 = MAX_PAYLOAD; + snprintf((char*) cp->data, sizeof cp->data, "%s::", + HOST ? "host" : sdb_device_banner); + cp->msg.data_length = strlen((char*) cp->data) + 1; + send_packet(cp, t); +#if SDB_HOST + /* XXX why sleep here? */ + // allow the device some time to respond to the connect message + sdb_sleep_ms(1000); +#endif +} + +static char *connection_state_name(atransport *t) +{ + if (t == NULL) { + return "unknown"; + } + + switch(t->connection_state) { + case CS_BOOTLOADER: + return "bootloader"; + case CS_DEVICE: + return "device"; + case CS_OFFLINE: + return "offline"; + default: + return "unknown"; + } +} + +void parse_banner(char *banner, atransport *t) +{ + char *type, *product, *end; + + D("parse_banner: %s\n", banner); + type = banner; + product = strchr(type, ':'); + if(product) { + *product++ = 0; + } else { + product = ""; + } + + /* remove trailing ':' */ + end = strchr(product, ':'); + if(end) *end = 0; + + /* save product name in device structure */ + if (t->product == NULL) { + t->product = strdup(product); + } else if (strcmp(product, t->product) != 0) { + free(t->product); + t->product = strdup(product); + } + + if(!strcmp(type, "bootloader")){ + D("setting connection_state to CS_BOOTLOADER\n"); + t->connection_state = CS_BOOTLOADER; + update_transports(); + return; + } + + if(!strcmp(type, "device")) { + D("setting connection_state to CS_DEVICE\n"); + t->connection_state = CS_DEVICE; + update_transports(); + return; + } + + if(!strcmp(type, "recovery")) { + D("setting connection_state to CS_RECOVERY\n"); + t->connection_state = CS_RECOVERY; + update_transports(); + return; + } + + t->connection_state = CS_HOST; +} + +void handle_packet(apacket *p, atransport *t) +{ + asocket *s; + + D("handle_packet() %d\n", p->msg.command); + + print_packet("recv", p); + + switch(p->msg.command){ + case A_SYNC: + if(p->msg.arg0){ + send_packet(p, t); + if(HOST) send_connect(t); + } else { + t->connection_state = CS_OFFLINE; + handle_offline(t); + send_packet(p, t); + } + return; + + case A_CNXN: /* CONNECT(version, maxdata, "system-id-string") */ + /* XXX verify version, etc */ + if(t->connection_state != CS_OFFLINE) { + t->connection_state = CS_OFFLINE; + handle_offline(t); + } + parse_banner((char*) p->data, t); + handle_online(); + if(!HOST) send_connect(t); + break; + + case A_OPEN: /* OPEN(local-id, 0, "destination") */ + if(t->connection_state != CS_OFFLINE) { + char *name = (char*) p->data; + name[p->msg.data_length > 0 ? p->msg.data_length - 1 : 0] = 0; + s = create_local_service_socket(name); + 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->connection_state != CS_OFFLINE) { + if((s = find_local_socket(p->msg.arg1))) { + if(s->peer == 0) { + s->peer = create_remote_socket(p->msg.arg0, t); + s->peer->peer = s; + } + s->ready(s); + } + } + break; + + case A_CLSE: /* CLOSE(local-id, remote-id, "") */ + if(t->connection_state != CS_OFFLINE) { + if((s = find_local_socket(p->msg.arg1))) { + s->close(s); + } + } + break; + + case A_WRTE: + if(t->connection_state != CS_OFFLINE) { + if((s = find_local_socket(p->msg.arg1))) { + unsigned rid = p->msg.arg0; + p->len = p->msg.data_length; + + if(s->enqueue(s, p) == 0) { + D("Enqueue the socket\n"); + send_ready(s->id, rid, t); + } + return; + } + } + break; + + default: + printf("handle_packet: what is %08x?!\n", p->msg.command); + } + + put_apacket(p); +} + +alistener listener_list = { + .next = &listener_list, + .prev = &listener_list, +}; + +static void ss_listener_event_func(int _fd, unsigned ev, void *_l) +{ + asocket *s; + + if(ev & FDE_READ) { + struct sockaddr addr; + socklen_t alen; + int fd; + + alen = sizeof(addr); + fd = sdb_socket_accept(_fd, &addr, &alen); + if(fd < 0) return; + + sdb_socket_setbufsize(fd, CHUNK_SIZE); + + s = create_local_socket(fd); + if(s) { + connect_to_smartsocket(s); + return; + } + + sdb_close(fd); + } +} + +static void listener_event_func(int _fd, unsigned ev, void *_l) +{ + alistener *l = _l; + asocket *s; + + if(ev & FDE_READ) { + struct sockaddr addr; + socklen_t alen; + int fd; + + alen = sizeof(addr); + fd = sdb_socket_accept(_fd, &addr, &alen); + if(fd < 0) return; + + s = create_local_socket(fd); + if(s) { + s->transport = l->transport; + connect_to_remote(s, l->connect_to); + return; + } + + sdb_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) { + remove_transport_disconnect(l->transport, &l->disconnect); + } + free(l); +} + +static void listener_disconnect(void* _l, atransport* t) +{ + alistener* l = _l; + + free_listener(l); +} + +int local_name_to_fd(const char *name) +{ + int port; + + if(!strncmp("tcp:", name, 4)){ + int ret; + port = atoi(name + 4); + ret = socket_loopback_server(port, SOCK_STREAM); + return ret; + } +#ifndef HAVE_WIN32_IPC /* no Unix-domain sockets on Win32 */ + // It's non-sensical to support the "reserved" space on the sdb host side + if(!strncmp(name, "local:", 6)) { + return socket_local_server(name + 6, + ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM); + } else if(!strncmp(name, "localabstract:", 14)) { + return socket_local_server(name + 14, + ANDROID_SOCKET_NAMESPACE_ABSTRACT, SOCK_STREAM); + } else if(!strncmp(name, "localfilesystem:", 16)) { + return socket_local_server(name + 16, + ANDROID_SOCKET_NAMESPACE_FILESYSTEM, SOCK_STREAM); + } + +#endif + printf("unknown local portname '%s'\n", name); + return -1; +} + +static int remove_listener(const char *local_name, const char *connect_to, atransport* transport) +{ + alistener *l; + + for (l = listener_list.next; l != &listener_list; l = l->next) { + if (!strcmp(local_name, l->local_name) && + !strcmp(connect_to, l->connect_to) && + l->transport && l->transport == transport) { + + listener_disconnect(l, transport); + return 0; + } + } + + return -1; +} + +static int install_listener(const char *local_name, const char *connect_to, atransport* transport) +{ + alistener *l; + + //printf("install_listener('%s','%s')\n", local_name, connect_to); + + for(l = listener_list.next; l != &listener_list; l = l->next){ + if(strcmp(local_name, l->local_name) == 0) { + char *cto; + + /* can't repurpose a smartsocket */ + if(l->connect_to[0] == '*') { + return -1; + } + + cto = strdup(connect_to); + if(cto == 0) { + return -1; + } + + //printf("rebinding '%s' to '%s'\n", local_name, connect_to); + free((void*) l->connect_to); + l->connect_to = cto; + if (l->transport != transport) { + remove_transport_disconnect(l->transport, &l->disconnect); + l->transport = transport; + add_transport_disconnect(l->transport, &l->disconnect); + } + return 0; + } + } + + if((l = calloc(1, sizeof(alistener))) == 0) goto nomem; + if((l->local_name = strdup(local_name)) == 0) goto nomem; + if((l->connect_to = strdup(connect_to)) == 0) goto nomem; + + + l->fd = local_name_to_fd(local_name); + if(l->fd < 0) { + free((void*) l->local_name); + free((void*) l->connect_to); + free(l); + printf("cannot bind '%s'\n", local_name); + return -2; + } + + close_on_exec(l->fd); + if(!strcmp(l->connect_to, "*smartsocket*")) { + fdevent_install(&l->fde, l->fd, ss_listener_event_func, l); + } else { + fdevent_install(&l->fde, l->fd, listener_event_func, l); + } + fdevent_set(&l->fde, FDE_READ); + + l->next = &listener_list; + l->prev = listener_list.prev; + l->next->prev = l; + l->prev->next = l; + l->transport = transport; + + if (transport) { + l->disconnect.opaque = l; + l->disconnect.func = listener_disconnect; + add_transport_disconnect(transport, &l->disconnect); + } + return 0; + +nomem: + fatal("cannot allocate listener"); + return 0; +} + +#ifdef HAVE_FORKEXEC +static void sigchld_handler(int n) +{ + int status; + while(waitpid(-1, &status, WNOHANG) > 0) ; +} +#endif + +#ifdef HAVE_WIN32_PROC +static BOOL WINAPI ctrlc_handler(DWORD type) +{ + exit(STATUS_CONTROL_C_EXIT); + return TRUE; +} +#endif + +static void sdb_cleanup(void) +{ + usb_cleanup(); +} + +void start_logging(void) +{ +#ifdef HAVE_WIN32_PROC + char temp[ MAX_PATH ]; + FILE* fnul; + FILE* flog; + + GetTempPath( sizeof(temp) - 8, temp ); + strcat( temp, "sdb.log" ); + + /* Win32 specific redirections */ + fnul = fopen( "NUL", "rt" ); + if (fnul != NULL) + stdin[0] = fnul[0]; + + flog = fopen( temp, "at" ); + if (flog == NULL) + flog = fnul; + + setvbuf( flog, NULL, _IONBF, 0 ); + + stdout[0] = flog[0]; + stderr[0] = flog[0]; + fprintf(stderr,"--- sdb starting (pid %d) ---\n", getpid()); +#else + int fd; + + fd = unix_open("/dev/null", O_RDONLY); + dup2(fd, 0); + + fd = unix_open("/tmp/sdb.log", O_WRONLY | O_CREAT | O_APPEND, 0640); + if(fd < 0) { + fd = unix_open("/dev/null", O_WRONLY); + } + dup2(fd, 1); + dup2(fd, 2); + fprintf(stderr,"--- sdb starting (pid %d) ---\n", getpid()); +#endif +} + +#if !SDB_HOST +void start_device_log(void) +{ + int fd; + char path[PATH_MAX]; + struct tm now; + time_t t; + + tzset(); + time(&t); + localtime_r(&t, &now); + strftime(path, sizeof(path), + "/tmp/sdb-%Y-%m-%d-%H-%M-%S.txt", + &now); + fd = unix_open(path, O_WRONLY | O_CREAT | O_TRUNC, 0640); + if (fd < 0) + return; + + // redirect stdout and stderr to the log file + dup2(fd, 1); + dup2(fd, 2); + fprintf(stderr,"--- sdb starting (pid %d) ---\n", getpid()); + + fd = unix_open("/dev/null", O_RDONLY); + dup2(fd, 0); +} +#endif + +#if SDB_HOST +int launch_server(int server_port) +{ +#ifdef HAVE_WIN32_PROC + /* 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 */ + HANDLE pipe_read, pipe_write; + SECURITY_ATTRIBUTES sa; + STARTUPINFO startup; + PROCESS_INFORMATION pinfo; + char program_path[ MAX_PATH ]; + int ret; + + sa.nLength = sizeof(sa); + sa.lpSecurityDescriptor = NULL; + sa.bInheritHandle = TRUE; + + /* create pipe, and ensure its read handle isn't inheritable */ + ret = CreatePipe( &pipe_read, &pipe_write, &sa, 0 ); + if (!ret) { + fprintf(stderr, "CreatePipe() failure, error %ld\n", GetLastError() ); + return -1; + } + + SetHandleInformation( pipe_read, HANDLE_FLAG_INHERIT, 0 ); + + ZeroMemory( &startup, sizeof(startup) ); + startup.cb = sizeof(startup); + startup.hStdInput = GetStdHandle( STD_INPUT_HANDLE ); + startup.hStdOutput = pipe_write; + startup.hStdError = GetStdHandle( STD_ERROR_HANDLE ); + startup.dwFlags = STARTF_USESTDHANDLES; + + ZeroMemory( &pinfo, sizeof(pinfo) ); + + /* get path of current program */ + GetModuleFileName( NULL, program_path, sizeof(program_path) ); + + ret = CreateProcess( + program_path, /* program path */ + "sdb fork-server server", + /* 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 ); + + CloseHandle( pipe_write ); + + if (!ret) { + fprintf(stderr, "CreateProcess failure, error %ld\n", GetLastError() ); + CloseHandle( pipe_read ); + return -1; + } + + CloseHandle( pinfo.hProcess ); + CloseHandle( pinfo.hThread ); + + /* wait for the "OK\n" message */ + { + char temp[3]; + DWORD count; + + ret = ReadFile( pipe_read, temp, 3, &count, NULL ); + CloseHandle( pipe_read ); + if ( !ret ) { + fprintf(stderr, "could not read ok from SDB Server, error = %ld\n", GetLastError() ); + return -1; + } + if (count != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') { + fprintf(stderr, "SDB server didn't ACK\n" ); + return -1; + } + } +#elif defined(HAVE_FORKEXEC) + 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 fd[1] will get mapped to stderr in the child. + 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 + + // redirect stderr to the pipe + // we use stderr instead of stdout due to stdout's buffering behavior. + sdb_close(fd[0]); + dup2(fd[1], STDERR_FILENO); + sdb_close(fd[1]); + + // child process + int result = execl(path, "sdb", "fork-server", "server", 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 + sdb_close(fd[1]); + int ret = sdb_read(fd[0], temp, 3); + sdb_close(fd[0]); + if (ret < 0) { + fprintf(stderr, "could not read ok from SDB Server, errno = %d\n", errno); + return -1; + } + if (ret != 3 || temp[0] != 'O' || temp[1] != 'K' || temp[2] != '\n') { + fprintf(stderr, "SDB server didn't ACK\n" ); + return -1; + } + + setsid(); + } +#else +#error "cannot implement background server start on this platform" +#endif + return 0; +} +#endif + +/* Constructs a local name of form tcp:port. + * target_str points to the target string, it's content will be overwritten. + * target_size is the capacity of the target string. + * server_port is the port number to use for the local name. + */ +void build_local_name(char* target_str, size_t target_size, int server_port) +{ + snprintf(target_str, target_size, "tcp:%d", server_port); +} + +int sdb_main(int is_daemon, int server_port) +{ +#if 0 //!SDB_HOST eric + int secure = 0; + int port; + char value[PROPERTY_VALUE_MAX]; +#endif + + atexit(sdb_cleanup); +#ifdef HAVE_WIN32_PROC + SetConsoleCtrlHandler( ctrlc_handler, TRUE ); +#elif defined(HAVE_FORKEXEC) + signal(SIGCHLD, sigchld_handler); + signal(SIGPIPE, SIG_IGN); +#endif + + init_transport_registration(); + + +#if SDB_HOST + HOST = 1; + usb_vendors_init(); + usb_init(); + local_init(DEFAULT_SDB_LOCAL_TRANSPORT_PORT); + + char local_name[30]; + build_local_name(local_name, sizeof(local_name), server_port); + if(install_listener(local_name, "*smartsocket*", NULL)) { + exit(1); + } +#else + /* run sdbd in secure mode if ro.secure is set and + ** we are not in the emulator + */ +#if 0 //eric + property_get("ro.kernel.qemu", value, ""); + if (strcmp(value, "1") != 0) { + property_get("ro.secure", value, ""); + if (strcmp(value, "1") == 0) { + // don't run as root if ro.secure is set... + secure = 1; + + // ... except we allow running as root in userdebug builds if the + // service.sdb.root property has been set by the "sdb root" command + property_get("ro.debuggable", value, ""); + if (strcmp(value, "1") == 0) { + property_get("service.sdb.root", value, ""); + if (strcmp(value, "1") == 0) { + secure = 0; + } + } + } + } + + /* don't listen on a port (default 5037) if running in secure mode */ + /* don't run as root if we are running in secure mode */ + if (secure) { + struct __user_cap_header_struct header; + struct __user_cap_data_struct cap; + + if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) != 0) { + exit(1); + } + + /* add extra groups: + ** AID_SDB to access the USB driver + ** AID_LOG to read system logs (sdb logcat) + ** AID_INPUT to diagnose input issues (getevent) + ** AID_INET to diagnose network issues (netcfg, ping) + ** AID_GRAPHICS to access the frame buffer + ** AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump) + ** AID_SDCARD_RW to allow writing to the SD card + ** AID_MOUNT to allow unmounting the SD card before rebooting + */ + gid_t groups[] = { AID_SDB, AID_LOG, AID_INPUT, AID_INET, AID_GRAPHICS, + AID_NET_BT, AID_NET_BT_ADMIN, AID_SDCARD_RW, AID_MOUNT }; + if (setgroups(sizeof(groups)/sizeof(groups[0]), groups) != 0) { + exit(1); + } + + /* then switch user and group to "shell" */ + if (setgid(AID_SHELL) != 0) { + exit(1); + } + if (setuid(AID_SHELL) != 0) { + exit(1); + } + + /* set CAP_SYS_BOOT capability, so "sdb reboot" will succeed */ + header.version = _LINUX_CAPABILITY_VERSION; + header.pid = 0; + cap.effective = cap.permitted = (1 << CAP_SYS_BOOT); + cap.inheritable = 0; + capset(&header, &cap); + + D("Local port disabled\n"); + } else { +#endif + char local_name[30]; + build_local_name(local_name, sizeof(local_name), server_port); + if(install_listener(local_name, "*smartsocket*", NULL)) { + exit(1); + } +#if 0 //eric + } +#endif + /* for the device, start the usb transport if the + ** android usb device exists and the "service.sdb.tcp.port" and + ** "persist.sdb.tcp.port" properties are not set. + ** Otherwise start the network transport. + */ +#if 0 //eric + property_get("service.sdb.tcp.port", value, ""); + if (!value[0]) + property_get("persist.sdb.tcp.port", value, ""); + if (sscanf(value, "%d", &port) == 1 && port > 0) { + // listen on TCP port specified by service.sdb.tcp.port property + local_init(port); + } else +#endif + if (access("/dev/samsung_sdb", F_OK) == 0) { + // listen on USB + usb_init(); + } else { + // listen on default port + local_init(DEFAULT_SDB_LOCAL_TRANSPORT_PORT); + } + init_jdwp(); +#endif + + if (is_daemon) + { + // inform our parent that we are up and running. +#ifdef HAVE_WIN32_PROC + DWORD count; + WriteFile( GetStdHandle( STD_OUTPUT_HANDLE ), "OK\n", 3, &count, NULL ); +#elif defined(HAVE_FORKEXEC) + fprintf(stderr, "OK\n"); +#endif + start_logging(); + } + + fdevent_loop(); + + usb_cleanup(); + + return 0; +} + +#if SDB_HOST +void connect_device(char* host, char* buffer, int buffer_size) +{ + int port, fd; + char* portstr = strchr(host, ':'); + char hostbuf[100]; + char serial[100]; + + strncpy(hostbuf, host, sizeof(hostbuf) - 1); + if (portstr) { + if (portstr - host >= sizeof(hostbuf)) { + snprintf(buffer, buffer_size, "bad host name %s", host); + return; + } + // zero terminate the host at the point we found the colon + hostbuf[portstr - host] = 0; + if (sscanf(portstr + 1, "%d", &port) == 0) { + snprintf(buffer, buffer_size, "bad port number %s", portstr); + return; + } + } else { + port = DEFAULT_SDB_LOCAL_TRANSPORT_PORT; + } + + snprintf(serial, sizeof(serial), "%s:%d", hostbuf, port); + if (find_transport(serial)) { + snprintf(buffer, buffer_size, "already connected to %s", serial); + return; + } + + fd = socket_network_client(hostbuf, port, SOCK_STREAM); + if (fd < 0) { + snprintf(buffer, buffer_size, "unable to connect to %s:%d", host, port); + return; + } + + D("client: connected on remote on fd %d\n", fd); + close_on_exec(fd); + disable_tcp_nagle(fd); + register_socket_transport(fd, serial, port, 0, NULL); + snprintf(buffer, buffer_size, "connected to %s", serial); +} + +void connect_emulator(char* port_spec, char* buffer, int buffer_size) +{ + char* port_separator = strchr(port_spec, ','); + if (!port_separator) { + snprintf(buffer, buffer_size, + "unable to parse '%s' as ,", + port_spec); + return; + } + + // Zero-terminate console port and make port_separator point to 2nd port. + *port_separator++ = 0; + int console_port = strtol(port_spec, NULL, 0); + int sdb_port = strtol(port_separator, NULL, 0); + if (!(console_port > 0 && sdb_port > 0)) { + *(port_separator - 1) = ','; + snprintf(buffer, buffer_size, + "Invalid port numbers: Expected positive numbers, got '%s'", + port_spec); + 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_sdb_port(sdb_port); + if (known_emulator != NULL) { + snprintf(buffer, buffer_size, + "Emulator on port %d already registered.", sdb_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) { + snprintf(buffer, buffer_size, "Cannot accept more emulators."); + return; + } + + /* Preconditions met, try to connect to the emulator. */ + if (!local_connect_arbitrary_ports(console_port, sdb_port, NULL)) { + snprintf(buffer, buffer_size, + "Connected to emulator on ports %d,%d", console_port, sdb_port); + } else { + snprintf(buffer, buffer_size, + "Could not connect to emulator on ports %d,%d", + console_port, sdb_port); + } +} +#endif + +int handle_host_request(char *service, transport_type ttype, char* serial, int reply_fd, asocket *s) +{ + atransport *transport = NULL; + char buf[4096]; + + if(!strcmp(service, "kill")) { + fprintf(stderr,"sdb server killed by remote request\n"); + fflush(stdout); + sdb_write(reply_fd, "OKAY", 4); + usb_cleanup(); + exit(0); + } + +#if SDB_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"))) { + char* error_string = "unknown failure"; + transport_type 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 = strdup(service); + } + + transport = acquire_one_transport(CS_ANY, type, serial, &error_string); + + if (transport) { + s->transport = transport; + sdb_write(reply_fd, "OKAY", 4); + } else { + sendfailmsg(reply_fd, error_string); + } + return 1; + } + + // return a list of all connected devices + if (!strcmp(service, "devices")) { + char buffer[4096]; + memset(buf, 0, sizeof(buf)); + memset(buffer, 0, sizeof(buffer)); + D("Getting device list \n"); + list_transports(buffer, sizeof(buffer)); + snprintf(buf, sizeof(buf), "OKAY%04x%s",(unsigned)strlen(buffer),buffer); + D("Wrote device list \n"); + writex(reply_fd, buf, strlen(buf)); + return 0; + } + + // add a new TCP transport, device or emulator + if (!strncmp(service, "connect:", 8)) { + char buffer[4096]; + char* host = service + 8; + if (!strncmp(host, "emu:", 4)) { + connect_emulator(host + 4, buffer, sizeof(buffer)); + } else { + connect_device(host, buffer, sizeof(buffer)); + } + // Send response for emulator and device + snprintf(buf, sizeof(buf), "OKAY%04x%s",(unsigned)strlen(buffer), buffer); + writex(reply_fd, buf, strlen(buf)); + return 0; + } + + // remove TCP transport + if (!strncmp(service, "disconnect:", 11)) { + char buffer[4096]; + memset(buffer, 0, sizeof(buffer)); + char* serial = service + 11; + if (serial[0] == 0) { + // disconnect from all TCP devices + unregister_all_tcp_transports(); + } else { + char hostbuf[100]; + // assume port 5555 if no port is specified + if (!strchr(serial, ':')) { + snprintf(hostbuf, sizeof(hostbuf) - 1, "%s:5555", serial); + serial = hostbuf; + } + atransport *t = find_transport(serial); + + if (t) { + unregister_transport(t); + } else { + snprintf(buffer, sizeof(buffer), "No such device %s", serial); + } + } + + snprintf(buf, sizeof(buf), "OKAY%04x%s",(unsigned)strlen(buffer), buffer); + writex(reply_fd, buf, strlen(buf)); + return 0; + } + + // returns our value for SDB_SERVER_VERSION + if (!strcmp(service, "version")) { + char version[12]; + snprintf(version, sizeof version, "%04x", SDB_SERVER_VERSION); + snprintf(buf, sizeof buf, "OKAY%04x%s", (unsigned)strlen(version), version); + writex(reply_fd, buf, strlen(buf)); + return 0; + } + + if(!strncmp(service,"get-serialno",strlen("get-serialno"))) { + char *out = "unknown"; + transport = acquire_one_transport(CS_ANY, ttype, serial, NULL); + if (transport && transport->serial) { + out = transport->serial; + } + snprintf(buf, sizeof buf, "OKAY%04x%s",(unsigned)strlen(out),out); + writex(reply_fd, buf, strlen(buf)); + return 0; + } + // indicates a new emulator instance has started + if (!strncmp(service,"emulator:",9)) { /* tizen specific */ + char *tmp = strtok(service+9, DEVICEMAP_SEPARATOR); + int port = 0; + + if (tmp == NULL) + port = atoi(service+9); + else { + port = atoi(tmp); + tmp = strtok(NULL, DEVICEMAP_SEPARATOR); + if (tmp != NULL) { + local_connect(port, tmp); + } + } + local_connect(port, NULL); + /* we don't even need to send a reply */ + return 0; + } +#endif // SDB_HOST + + if(!strncmp(service,"forward:",8) || !strncmp(service,"killforward:",12)) { + char *local, *remote, *err; + int r; + atransport *transport; + + int createForward = strncmp(service,"kill",4); + + local = service + (createForward ? 8 : 12); + remote = strchr(local,';'); + if(remote == 0) { + sendfailmsg(reply_fd, "malformed forward spec"); + return 0; + } + + *remote++ = 0; + if((local[0] == 0) || (remote[0] == 0) || (remote[0] == '*')){ + sendfailmsg(reply_fd, "malformed forward spec"); + return 0; + } + + transport = acquire_one_transport(CS_ANY, ttype, serial, &err); + if (!transport) { + sendfailmsg(reply_fd, err); + return 0; + } + + if (createForward) { + r = install_listener(local, remote, transport); + } else { + r = remove_listener(local, remote, transport); + } + if(r == 0) { + /* 1st OKAY is connect, 2nd OKAY is status */ + writex(reply_fd, "OKAYOKAY", 8); + return 0; + } + + if (createForward) { + sendfailmsg(reply_fd, (r == -1) ? "cannot rebind smartsocket" : "cannot bind socket"); + } else { + sendfailmsg(reply_fd, "cannot remove listener"); + } + return 0; + } + + if(!strncmp(service,"get-state",strlen("get-state"))) { + transport = acquire_one_transport(CS_ANY, ttype, serial, NULL); + char *state = connection_state_name(transport); + snprintf(buf, sizeof buf, "OKAY%04x%s",(unsigned)strlen(state),state); + writex(reply_fd, buf, strlen(buf)); + return 0; + } + return -1; +} + +#if !SDB_HOST +int recovery_mode = 0; +#endif + +int main(int argc, char **argv) +{ + sdb_trace_init(); +#if SDB_HOST + sdb_sysdeps_init(); + return sdb_commandline(argc - 1, argv + 1); +#else + if((argc > 1) && (!strcmp(argv[1],"recovery"))) { + sdb_device_banner = "recovery"; + recovery_mode = 1; + } + + //sdbd will never die on emulator! + signal(SIGTERM, handle_sig_term); +#if !SDB_HOST + start_device_log(); +#endif + return sdb_main(0, DEFAULT_SDB_PORT); +#endif +} diff --git a/src/sdb.h b/src/sdb.h new file mode 100644 index 0000000..f4d875e --- /dev/null +++ b/src/sdb.h @@ -0,0 +1,431 @@ +/* + * 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 __SDB_H +#define __SDB_H + +#include + +#define MAX_PAYLOAD 4096 + +#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_VERSION 0x01000000 // SDB protocol version + +#define SDB_VERSION_MAJOR 1 // Used for help/version information +#define SDB_VERSION_MINOR 0 // Used for help/version information + +#define SDB_SERVER_VERSION 0 // Increment this when we want to force users to start a new sdb server + +typedef struct amessage amessage; +typedef struct apacket apacket; +typedef struct asocket asocket; +typedef struct alistener alistener; +typedef struct aservice aservice; +typedef struct atransport atransport; +typedef struct adisconnect adisconnect; +typedef struct usb_handle 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]; +}; + +/* 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; + + /* 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); + + /* 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); + + /* socket-type-specific extradata */ + void *extra; + + /* A socket is bound to atransport */ + atransport *transport; +}; + + +/* 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; + adisconnect* next; + adisconnect* prev; +}; + + +/* 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 SDB server itself. +*/ +typedef enum transport_type { + kTransportUsb, + kTransportLocal, + kTransportAny, + kTransportHost, +} transport_type; + +struct atransport +{ + atransport *next; + atransport *prev; + + int (*read_from_remote)(apacket *p, atransport *t); + int (*write_to_remote)(apacket *p, atransport *t); + void (*close)(atransport *t); + void (*kick)(atransport *t); + + int fd; + int transport_socket; + fdevent transport_fde; + int ref_count; + unsigned sync_token; + int connection_state; + transport_type type; + + /* usb handle or socket fd as needed */ + usb_handle *usb; + int sfd; + + /* used to identify transports for clients */ + char *serial; + char *product; + int sdb_port; // Use for emulators (local transport) + char *device_name; // for connection explorer + + /* a list of adisconnect callbacks called when the transport is kicked */ + int kicked; + adisconnect disconnects; +}; + + +/* 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; + + const char *local_name; + const char *connect_to; + atransport *transport; + adisconnect disconnect; +}; + + +void print_packet(const char *label, apacket *p); + +asocket *find_local_socket(unsigned id); +void install_local_socket(asocket *s); +void remove_socket(asocket *s); +void close_all_sockets(atransport *t); + +#define LOCAL_CLIENT_PREFIX "emulator-" + +asocket *create_local_socket(int fd); +asocket *create_local_service_socket(const char *destination); + +asocket *create_remote_socket(unsigned id, atransport *t); +void connect_to_remote(asocket *s, const char *destination); +void connect_to_smartsocket(asocket *s); + +void fatal(const char *fmt, ...); +void fatal_errno(const char *fmt, ...); + +void handle_packet(apacket *p, atransport *t); +void send_packet(apacket *p, atransport *t); + +void get_my_path(char *s, size_t maxLen); +int launch_server(int server_port); +int sdb_main(int is_daemon, int server_port); + + +/* transports are ref-counted +** get_device_transport does an acquire on your behalf before returning +*/ +void init_transport_registration(void); +int list_transports(char *buf, size_t bufsize); +void update_transports(void); + +asocket* create_device_tracker(void); + +/* Obtain a transport from the available transports. +** If state is != CS_ANY, only transports in that state are considered. +** If serial is non-NULL then only the device with that serial will be chosen. +** If no suitable transport is found, error is set. +*/ +atransport *acquire_one_transport(int state, transport_type ttype, const char* serial, char **error_out); +void add_transport_disconnect( atransport* t, adisconnect* dis ); +void remove_transport_disconnect( atransport* t, adisconnect* dis ); +void run_transport_disconnects( atransport* t ); +void kick_transport( atransport* t ); + +/* initialize a transport object's func pointers and state */ +#if SDB_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, int state); + +/* for MacOS X cleanup */ +void close_usb_devices(); + +/* cause new transports to be init'd and added to the list */ +void register_socket_transport(int s, const char *serial, int port, int local, const char *device_name); + +/* these should only be used for the "sdb disconnect" command */ +void unregister_transport(atransport *t); +void unregister_all_tcp_transports(); + +void register_usb_transport(usb_handle *h, const char *serial, unsigned writeable); + +/* this should only be used for transports with connection_state == CS_NOPERM */ +void unregister_usb_transport(usb_handle *usb); + +atransport *find_transport(const char *serial); +#if SDB_HOST +atransport* find_emulator_transport_by_sdb_port(int sdb_port); +#endif + +int service_to_fd(const char *name); +#if SDB_HOST +asocket *host_service_to_socket(const char* name, const char *serial); +#endif + +#if !SDB_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 + +#if !SDB_HOST +void framebuffer_service(int fd, void *cookie); +#if 0 //eric +void log_service(int fd, void *cookie); +void remount_service(int fd, void *cookie); +char * get_log_file_path(const char * log_name); +#endif +#endif + +/* packet allocator */ +apacket *get_apacket(void); +void put_apacket(apacket *p); + +int check_header(apacket *p); +int check_data(apacket *p); + +/* convenience wrappers around read/write that will retry on +** EINTR and/or short read/write. Returns 0 on success, -1 +** on error or EOF. +*/ +int readx(int fd, void *ptr, size_t len); +int writex(int fd, const void *ptr, size_t len); + +/* define SDB_TRACE to 1 to enable tracing support, or 0 to disable it */ + +#define SDB_TRACE 1 + +/* IMPORTANT: if you change the following list, don't + * forget to update the corresponding 'tags' table in + * the sdb_trace_init() function implemented in sdb.c + */ +typedef enum { + TRACE_SDB = 0, + TRACE_SOCKETS, + TRACE_PACKETS, + TRACE_TRANSPORT, + TRACE_RWX, + TRACE_USB, + TRACE_SYNC, + TRACE_SYSDEPS, + TRACE_JDWP, +} AdbTrace; + +#if SDB_TRACE + + int sdb_trace_mask; + + void sdb_trace_init(void); + +# define SDB_TRACING ((sdb_trace_mask & (1 << TRACE_TAG)) != 0) + + /* you must define TRACE_TAG before using this macro */ + #define D(...) \ + do { \ + if (SDB_TRACING) \ + fprintf(stderr, __VA_ARGS__ ); \ + } while (0) +#else +//# define D(...) ((void)0) + #define D(...) \ + do { \ + fprintf(stderr, __VA_ARGS__ ); \ + } while (0) +# define SDB_TRACING 0 +#endif + + +#if !TRACE_PACKETS +#define print_packet(tag,p) do {} while (0) +#endif + +#define DEFAULT_SDB_PORT 26099 +#define DEFAULT_SDB_LOCAL_TRANSPORT_PORT 26101 + +#define SDB_CLASS 0xFF +#define SDB_SUBCLASS 0x20 +#define SDB_PROTOCOL 0x02 + + +void local_init(int port); +int local_connect(int port, const char *device_name); +int local_connect_arbitrary_ports(int console_port, int sdb_port, const char *device_name); + +/* usb host/client interface */ +void usb_init(); +void usb_cleanup(); +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); + +/* used for USB device detection */ +#if SDB_HOST +int is_sdb_interface(int vid, int pid, int usb_class, int usb_subclass, int usb_protocol); +#endif + +unsigned host_to_le32(unsigned n); +int sdb_commandline(int argc, char **argv); + +int connection_state(atransport *t); + +#define CS_ANY -1 +#define CS_OFFLINE 0 +#define CS_BOOTLOADER 1 +#define CS_DEVICE 2 +#define CS_HOST 3 +#define CS_RECOVERY 4 +#define CS_NOPERM 5 /* Insufficient permissions to communicate with the device */ + +extern int HOST; + +#define CHUNK_SIZE (64*1024) + +int sendfailmsg(int fd, const char *reason); +int handle_host_request(char *service, transport_type ttype, char* serial, int reply_fd, asocket *s); + +#if SDB_HOST /* tizen-specific */ +#define DEVICEMAP_SEPARATOR ":" +#define DEVICEMAP_FILENAME ".sdb.devicemap" +#define DEVICENAME_MAX 256 +#define VMS_PATH OS_PATH_SEPARATOR_STR "vms" OS_PATH_SEPARATOR_STR // should include sysdeps.h above +#define DEFAULT_DEVICENAME "" +void register_device_name(const char *device_type, const char *device_name, int port); +int get_devicename_from_shdmem(int port, char *device_name); +int read_line(const int fd, char* ptr, const size_t maxlen); +#endif +#endif diff --git a/src/sdb_client.c b/src/sdb_client.c new file mode 100644 index 0000000..78b2f14 --- /dev/null +++ b/src/sdb_client.c @@ -0,0 +1,326 @@ +#include +#include +#include +#include +#include +#include +#if 0 //eric +#include +#endif +#include +#include + +#include "sysdeps.h" + +#define TRACE_TAG TRACE_SDB +#include "sdb_client.h" + +static transport_type __sdb_transport = kTransportAny; +static const char* __sdb_serial = NULL; + +static int __sdb_server_port = DEFAULT_SDB_PORT; + +void sdb_set_transport(transport_type type, const char* serial) +{ + __sdb_transport = type; + __sdb_serial = serial; +} + +void sdb_set_tcp_specifics(int server_port) +{ + __sdb_server_port = server_port; +} + +int sdb_get_emulator_console_port(void) +{ + const char* serial = __sdb_serial; + int port; + + if (serial == NULL) { + /* if no specific device was specified, we need to look at */ + /* the list of connected devices, and extract an emulator */ + /* name from it. two emulators is an error */ + char* tmp = sdb_query("host:devices"); + char* p = tmp; + if(!tmp) { + printf("no emulator connected\n"); + return -1; + } + while (*p) { + char* q = strchr(p, '\n'); + if (q != NULL) + *q++ = 0; + else + q = p + strlen(p); + + if (!memcmp(p, LOCAL_CLIENT_PREFIX, sizeof(LOCAL_CLIENT_PREFIX)-1)) { + if (serial != NULL) { /* more than one emulator listed */ + free(tmp); + return -2; + } + serial = p; + } + + p = q; + } + free(tmp); + + if (serial == NULL) + return -1; /* no emulator found */ + } + else { + if (memcmp(serial, LOCAL_CLIENT_PREFIX, sizeof(LOCAL_CLIENT_PREFIX)-1) != 0) + return -1; /* not an emulator */ + } + + serial += sizeof(LOCAL_CLIENT_PREFIX)-1; + port = strtol(serial, NULL, 10); + return port; +} + +static char __sdb_error[256] = { 0 }; + +const char *sdb_error(void) +{ + return __sdb_error; +} + +static int switch_socket_transport(int fd) +{ + char service[64]; + char tmp[5]; + int len; + + if (__sdb_serial) + snprintf(service, sizeof service, "host:transport:%s", __sdb_serial); + else { + char* transport_type = "???"; + + switch (__sdb_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; + break; + } + + snprintf(service, sizeof service, "host:%s", transport_type); + } + len = strlen(service); + snprintf(tmp, sizeof tmp, "%04x", len); + + if(writex(fd, tmp, 4) || writex(fd, service, len)) { + strcpy(__sdb_error, "write failure during connection"); + sdb_close(fd); + return -1; + } + D("Switch transport in progress\n"); + + if(sdb_status(fd)) { + sdb_close(fd); + D("Switch transport failed\n"); + return -1; + } + D("Switch transport success\n"); + return 0; +} + +int sdb_status(int fd) +{ + unsigned char buf[5]; + unsigned len; + + if(readx(fd, buf, 4)) { + strcpy(__sdb_error, "protocol fault (no status)"); + return -1; + } + + if(!memcmp(buf, "OKAY", 4)) { + return 0; + } + + if(memcmp(buf, "FAIL", 4)) { + sprintf(__sdb_error, + "protocol fault (status %02x %02x %02x %02x?!)", + buf[0], buf[1], buf[2], buf[3]); + return -1; + } + + if(readx(fd, buf, 4)) { + strcpy(__sdb_error, "protocol fault (status len)"); + return -1; + } + buf[4] = 0; + len = strtoul((char*)buf, 0, 16); + if(len > 255) len = 255; + if(readx(fd, __sdb_error, len)) { + strcpy(__sdb_error, "protocol fault (status read)"); + return -1; + } + __sdb_error[len] = 0; + return -1; +} + +int _sdb_connect(const char *service) +{ + char tmp[5]; + int len; + int fd; + + D("_sdb_connect: %s\n", service); + len = strlen(service); + if((len < 1) || (len > 1024)) { + strcpy(__sdb_error, "service name too long"); + return -1; + } + snprintf(tmp, sizeof tmp, "%04x", len); + + fd = socket_loopback_client(__sdb_server_port, SOCK_STREAM); + if(fd < 0) { + strcpy(__sdb_error, "cannot connect to daemon"); + return -2; + } + + if (memcmp(service,"host",4) != 0 && switch_socket_transport(fd)) { + return -1; + } + + if(writex(fd, tmp, 4) || writex(fd, service, len)) { + strcpy(__sdb_error, "write failure during connection"); + sdb_close(fd); + return -1; + } + + if(sdb_status(fd)) { + sdb_close(fd); + return -1; + } + + return fd; +} + +int sdb_connect(const char *service) +{ + // first query the sdb server's version + int fd = _sdb_connect("host:version"); + + if(fd == -2) { + fprintf(stdout,"* daemon not running. starting it now on port %d *\n", + __sdb_server_port); + start_server: + if(launch_server(__sdb_server_port)) { + fprintf(stderr,"* failed to start daemon *\n"); + return -1; + } else { + fprintf(stdout,"* daemon started successfully *\n"); + } + /* give the server some time to start properly and detect devices */ + sdb_sleep_ms(3000); + // fall through to _sdb_connect + } else { + // if server was running, check its version to make sure it is not out of date + char buf[100]; + int n; + int version = SDB_SERVER_VERSION - 1; + + // if we have a file descriptor, then parse version result + if(fd >= 0) { + if(readx(fd, buf, 4)) goto error; + + buf[4] = 0; + n = strtoul(buf, 0, 16); + if(n > (int)sizeof(buf)) goto error; + if(readx(fd, buf, n)) goto error; + sdb_close(fd); + + if (sscanf(buf, "%04x", &version) != 1) goto error; + } else { + // if fd is -1, then check for "unknown host service", + // which would indicate a version of sdb that does not support the version command + if (strcmp(__sdb_error, "unknown host service") != 0) + return fd; + } + + if(version != SDB_SERVER_VERSION) { + printf("sdb server is out of date. killing...\n"); + fd = _sdb_connect("host:kill"); + sdb_close(fd); + + /* XXX can we better detect its death? */ + sdb_sleep_ms(2000); + goto start_server; + } + } + + // if the command is start-server, we are done. + if (!strcmp(service, "host:start-server")) + return 0; + + fd = _sdb_connect(service); + if(fd == -2) { + fprintf(stderr,"** daemon still not running"); + } + + return fd; +error: + sdb_close(fd); + return -1; +} + + +int sdb_command(const char *service) +{ + int fd = sdb_connect(service); + if(fd < 0) { + return -1; + } + + if(sdb_status(fd)) { + sdb_close(fd); + return -1; + } + + return 0; +} + +char *sdb_query(const char *service) +{ + char buf[5]; + unsigned n; + char *tmp; + + D("sdb_query: %s\n", service); + int fd = sdb_connect(service); + if(fd < 0) { + fprintf(stderr,"error: %s\n", __sdb_error); + return 0; + } + + if(readx(fd, buf, 4)) goto oops; + + buf[4] = 0; + n = strtoul(buf, 0, 16); + if(n > 1024) goto oops; + + tmp = malloc(n + 1); + if(tmp == 0) goto oops; + + if(readx(fd, tmp, n) == 0) { + tmp[n] = 0; + sdb_close(fd); + return tmp; + } + free(tmp); + +oops: + sdb_close(fd); + return 0; +} diff --git a/src/sdb_client.h b/src/sdb_client.h new file mode 100644 index 0000000..4cfdfbe --- /dev/null +++ b/src/sdb_client.h @@ -0,0 +1,53 @@ +#ifndef _SDB_CLIENT_H_ +#define _SDB_CLIENT_H_ + +#include "sdb.h" + +/* connect to sdb, connect to the named service, and return +** a valid fd for interacting with that service upon success +** or a negative number on failure +*/ +int sdb_connect(const char *service); +int _sdb_connect(const char *service); + +/* connect to sdb, connect to the named service, return 0 if +** the connection succeeded AND the service returned OKAY +*/ +int sdb_command(const char *service); + +/* connect to sdb, connect to the named service, return +** a malloc'd string of its response upon success or NULL +** on failure. +*/ +char *sdb_query(const char *service); + +/* Set the preferred transport to connect to. +*/ +void sdb_set_transport(transport_type type, const char* serial); + +/* Set TCP specifics of the transport to use +*/ +void sdb_set_tcp_specifics(int server_port); + +/* Return the console port of the currently connected emulator (if any) + * of -1 if there is no emulator, and -2 if there is more than one. + * assumes sdb_set_transport() was alled previously... + */ +int sdb_get_emulator_console_port(void); + +/* send commands to the current emulator instance. will fail if there + * is zero, or more than one emulator connected (or if you use -s + * with a that does not designate an emulator) + */ +int sdb_send_emulator_command(int argc, char** argv); + +/* return verbose error string from last operation */ +const char *sdb_error(void); + +/* read a standard sdb status response (OKAY|FAIL) and +** return 0 in the event of OKAY, -1 in the event of FAIL +** or protocol error +*/ +int sdb_status(int fd); + +#endif diff --git a/src/sdbwinapi/BUILDME.TXT b/src/sdbwinapi/BUILDME.TXT new file mode 100644 index 0000000..a8a2ca2 --- /dev/null +++ b/src/sdbwinapi/BUILDME.TXT @@ -0,0 +1,19 @@ +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. + +In order to build SdbWinApi.dll you will need to install Windows Driver Kit, +which can be obtained from Microsoft. Assuming that WDK is installed, you +need to set one of the WDK's build environments, "cd" back into this directory, +and execute "build -cbeEIFZ" to clean and rebuild this project, or you can +execute "build -befEIF" to do a minimal build. diff --git a/src/sdbwinapi/MAKEFILE b/src/sdbwinapi/MAKEFILE new file mode 100644 index 0000000..c38c73f --- /dev/null +++ b/src/sdbwinapi/MAKEFILE @@ -0,0 +1,22 @@ +# +# 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. +# + +# +# DO NOT EDIT THIS FILE!!! Edit .\sources. if you want to add a new source +# file to this component. This file merely indirects to the real make file +# that is shared by all the components of NT OS/2 +# +!INCLUDE $(NTMAKEENV)\makefile.def diff --git a/src/sdbwinapi/MAKEFILE.org b/src/sdbwinapi/MAKEFILE.org new file mode 100644 index 0000000..c38c73f --- /dev/null +++ b/src/sdbwinapi/MAKEFILE.org @@ -0,0 +1,22 @@ +# +# 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. +# + +# +# DO NOT EDIT THIS FILE!!! Edit .\sources. if you want to add a new source +# file to this component. This file merely indirects to the real make file +# that is shared by all the components of NT OS/2 +# +!INCLUDE $(NTMAKEENV)\makefile.def diff --git a/src/sdbwinapi/Resource.h b/src/sdbwinapi/Resource.h new file mode 100644 index 0000000..4a394fd --- /dev/null +++ b/src/sdbwinapi/Resource.h @@ -0,0 +1,34 @@ +/* + * 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. + */ + +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by SdbWinApi.rc +// + +#define IDS_PROJNAME 100 +#define IDR_SDBWINAPI 101 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 201 +#define _APS_NEXT_COMMAND_VALUE 32768 +#define _APS_NEXT_CONTROL_VALUE 201 +#define _APS_NEXT_SYMED_VALUE 102 +#endif +#endif diff --git a/src/sdbwinapi/SOURCES b/src/sdbwinapi/SOURCES new file mode 100644 index 0000000..6b3e319 --- /dev/null +++ b/src/sdbwinapi/SOURCES @@ -0,0 +1,96 @@ +# +# 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. +# + +TARGETNAME = SdbWinApi +TARGETPATH = obj +TARGETTYPE = DYNLINK + +UMTYPE = windows +DLLDEF = SdbWinApi.def + +# Use statically linked atl libraries: +# - atls.lib for free build +# - atlsd.lib for checked build +USE_STATIC_ATL = 1 +# Use ATL v. 7.1 +ATL_VER = 71 +# Use STL v. 6.0 +USE_STL = 1 +STL_VER = 60 +# Use multithreaded libraries +USE_LIBCMT = 1 + +# Include directories +INCLUDES = $(DDK_INC_PATH); \ + $(SDK_INC_PATH); \ + $(CRT_INC_PATH); \ + $(SDK_INC_PATH)\crt; \ + $(CRT_INC_PATH)\atl71; \ + $(SDK_INC_PATH)\crt\stl60 + +# Common target libraries +TARGETLIBS = $(SDK_LIB_PATH)\ole32.lib \ + $(SDK_LIB_PATH)\Advapi32.lib \ + $(SDK_LIB_PATH)\Kernel32.lib \ + $(SDK_LIB_PATH)\User32.lib \ + $(SDK_LIB_PATH)\oleaut32.lib \ + $(SDK_LIB_PATH)\wbemuuid.lib \ + $(SDK_LIB_PATH)\uuid.lib \ + $(SDK_LIB_PATH)\setupapi.lib \ + $(SDK_LIB_PATH)\usbd.lib + +!IF "$(DDKBUILDENV)" == "fre" +# Libraries for release (free) builds +TARGETLIBS = $(TARGETLIBS) $(ATL_LIB_PATH)\atls.lib +!ELSE +# Libraries for debug (checked) builds +TARGETLIBS = $(TARGETLIBS) $(ATL_LIB_PATH)\atlsd.lib +!ENDIF + +# Common C defines +C_DEFINES= $(C_DEFINES) -DSDBWIN_EXPORTS -D_UNICODE \ + -DUNICODE -DWIN32 -D_WINDOWS -D_USRDLL -D_WINDLL + +!IF "$(DDKBUILDENV)" == "fre" +# C defines for release (free) builds +C_DEFINES = $(C_DEFINES) -DNDEBUG +!ELSE +# C defines for debug (checked) builds +C_DEFINES = $(C_DEFINES) -D_DEBUG +!ENDIF + +# Turn on all warnings, and treat warnings as errors +MSC_WARNING_LEVEL = /W4 /Wp64 /WX +# Common C defines +USER_C_FLAGS = $(USER_C_FLAGS) /FD /EHsc /wd4100 /wd4200 /wd4702 /nologo +# Set precompiled header information +PRECOMPILED_CXX = 1 +PRECOMPILED_INCLUDE = stdafx.h +PRECOMPILED_SOURCEFILE = stdafx.cpp + +# Define source files for SdbWinApi.dll +SOURCES = sdb_api.cpp \ + sdb_endpoint_object.cpp \ + sdb_legacy_endpoint_object.cpp \ + sdb_helper_routines.cpp \ + sdb_interface.cpp \ + sdb_legacy_interface.cpp \ + sdb_interface_enum.cpp \ + sdb_io_completion.cpp \ + sdb_legacy_io_completion.cpp \ + sdb_object_handle.cpp \ + SdbWinApi.cpp \ + SdbWinApi.rc diff --git a/src/sdbwinapi/SdbWinApi.cpp b/src/sdbwinapi/SdbWinApi.cpp new file mode 100644 index 0000000..6892496 --- /dev/null +++ b/src/sdbwinapi/SdbWinApi.cpp @@ -0,0 +1,112 @@ +/* + * 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. + */ + +// SdbWinApi.cpp : Implementation of DLL Exports. + +#include "stdafx.h" +#include "sdb_api.h" +#include "sdb_winusb_api.h" + +extern "C" { +int _forceCRTManifest; +int _forceMFCManifest; +int _forceAtlDllManifest; +}; + +/// References InstantiateWinUsbInterface declared in sdb_api.cpp +extern PFN_INSTSDBWINUSBINTERFACE InstantiateSdbWinUsbInterface; + +class CSdbWinApiModule : public CAtlDllModuleT< CSdbWinApiModule > { + public: + CSdbWinApiModule() + : CAtlDllModuleT< CSdbWinApiModule >(), + sdbwinusbapi_handle_(NULL), + is_initialized_(false) { + } + + ~CSdbWinApiModule() { + // Unload SdbWinUsbApi.dll before we exit + if (NULL != sdbwinusbapi_handle_) { + FreeLibrary(sdbwinusbapi_handle_); + } + } + + /** \brief Loads SdbWinUsbApi.dll and caches its InstantiateWinUsbInterface + export. + + This method is called from DllMain on DLL_PROCESS_ATTACH event. In this + method we will check if WINUSB.DLL required by SdbWinUsbApi.dll is + installed, and if it is we will load SdbWinUsbApi.dll and cache address of + InstantiateWinUsbInterface routine exported from SdbWinUsbApi.dll + */ + void AttachToSdbWinUsbApi() { + // We only need to run this only once. + if (is_initialized_) { + return; + } + + // Just mark that we have ran initialization. + is_initialized_ = true; + + // Before we can load SdbWinUsbApi.dll we must make sure that WINUSB.DLL + // has been installed. Build path to the file. + wchar_t path_to_winusb_dll[MAX_PATH+1]; + if (!GetSystemDirectory(path_to_winusb_dll, MAX_PATH)) { + return; + } + wcscat(path_to_winusb_dll, L"\\WINUSB.DLL"); + + if (0xFFFFFFFF == GetFileAttributes(path_to_winusb_dll)) { + // WINUSB.DLL is not installed. We don't (in fact, can't) load + // SdbWinUsbApi.dll + return; + } + + // WINUSB.DLL is installed. Lets load SdbWinUsbApi.dll and cache its + // InstantiateWinUsbInterface export. + // We require that SdbWinUsbApi.dll is located in the same folder + // where SdbWinApi.dll and sdb.exe are located, so by Windows + // conventions we can pass just module name, and not the full path. + sdbwinusbapi_handle_ = LoadLibrary(L"SdbWinUsbApi.dll"); + if (NULL != sdbwinusbapi_handle_) { + InstantiateSdbWinUsbInterface = reinterpret_cast + (GetProcAddress(sdbwinusbapi_handle_, "InstantiateSdbWinUsbInterface")); + } + } + + protected: + /// Handle to the loaded SdbWinUsbApi.dll + HINSTANCE sdbwinusbapi_handle_; + + /// Flags whether or not this module has been initialized. + bool is_initialized_; +}; + +CSdbWinApiModule _AtlModule; + +// DLL Entry Point +extern "C" BOOL WINAPI DllMain(HINSTANCE instance, + DWORD reason, + LPVOID reserved) { + // Lets see if we need to initialize InstantiateWinUsbInterface + // variable. We do that only once, on condition that this DLL is + // being attached to the process and InstantiateWinUsbInterface + // address has not been calculated yet. + if (DLL_PROCESS_ATTACH == reason) { + _AtlModule.AttachToSdbWinUsbApi(); + } + return _AtlModule.DllMain(reason, reserved); +} diff --git a/src/sdbwinapi/SdbWinApi.def b/src/sdbwinapi/SdbWinApi.def new file mode 100644 index 0000000..e2dbec2 --- /dev/null +++ b/src/sdbwinapi/SdbWinApi.def @@ -0,0 +1,18 @@ +; SdbWinApi.def : Declares the module parameters. + +LIBRARY "SdbWinApi.DLL" + +EXPORTS +SdbEnumInterfaces +SdbNextInterface +SdbCreateInterfaceByName +SdbOpenDefaultBulkReadEndpoint +SdbOpenDefaultBulkWriteEndpoint +SdbCloseHandle +SdbGetInterfaceName +SdbWriteEndpointSync +SdbReadEndpointSync +SdbGetSerialNumber +SdbGetUsbInterfaceDescriptor +SdbGetUsbDeviceDescriptor +SdbGetEndpointInformation diff --git a/src/sdbwinapi/SdbWinApi.rc b/src/sdbwinapi/SdbWinApi.rc new file mode 100644 index 0000000..c5b19a4 --- /dev/null +++ b/src/sdbwinapi/SdbWinApi.rc @@ -0,0 +1,111 @@ +/* + * 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. + */ + +//Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "winres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +LANGUAGE 9, 1 +#pragma code_page(1252) +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""winres.h""\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + +#ifndef _MAC +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 2,0,0,0 + PRODUCTVERSION 2,0,0,0 + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904e4" + BEGIN + VALUE "CompanyName", "Google, inc" + VALUE "FileDescription", "Android SDB API" + VALUE "FileVersion", "2.0.0.0" + VALUE "LegalCopyright", "Copyright (C) 2006 The Android Open Source Project" + VALUE "InternalName", "SdbWinApi.dll" + VALUE "OriginalFilename", "SdbWinApi.dll" + VALUE "ProductName", "Android SDK" + VALUE "ProductVersion", "2.0.0.0" + VALUE "OLESelfRegister", "" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x0409, 1252 + END +END + +#endif // !_MAC + +///////////////////////////////////////////////////////////////////////////// +// +// String Table +// + +STRINGTABLE +BEGIN + IDS_PROJNAME "SdbWinApi" +END + +//////////////////////////////////////////////////////////////////////////// + + +#endif + +#ifndef APSTUDIO_INVOKED +#endif // not APSTUDIO_INVOKED diff --git a/src/sdbwinapi/sdb_api.cpp b/src/sdbwinapi/sdb_api.cpp new file mode 100644 index 0000000..f2c80c5 --- /dev/null +++ b/src/sdbwinapi/sdb_api.cpp @@ -0,0 +1,537 @@ +/* + * 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. + */ + +/** \file + This file consists of implementation of rotines that are exported + from this DLL. +*/ + +#include "stdafx.h" +#include "sdb_api.h" +#include "sdb_object_handle.h" +#include "sdb_interface_enum.h" +#include "sdb_interface.h" +#include "sdb_legacy_interface.h" +#include "sdb_endpoint_object.h" +#include "sdb_io_completion.h" +#include "sdb_helper_routines.h" +#include "sdb_winusb_api.h" + +/** \brief Points to InstantiateWinUsbInterface exported from SdbWinUsbApi.dll. + + This variable is initialized with the actual address in DllMain routine for + this DLL on DLL_PROCESS_ATTACH event. + @see PFN_INSTWINUSBINTERFACE for more information. +*/ +PFN_INSTSDBWINUSBINTERFACE InstantiateSdbWinUsbInterface = NULL; + +SDBAPIHANDLE __cdecl SdbEnumInterfaces(GUID class_id, + bool exclude_not_present, + bool exclude_removed, + bool active_only) { + SdbInterfaceEnumObject* enum_obj = NULL; + SDBAPIHANDLE ret = NULL; + + try { + // Instantiate and initialize enum object + enum_obj = new SdbInterfaceEnumObject(); + + if (enum_obj->InitializeEnum(class_id, + exclude_not_present, + exclude_removed, + active_only)) { + // After successful initialization we can create handle. + ret = enum_obj->CreateHandle(); + } + } catch (...) { + SetLastError(ERROR_OUTOFMEMORY); + } + + if (NULL != enum_obj) + enum_obj->Release(); + + return ret; +} + +bool __cdecl SdbNextInterface(SDBAPIHANDLE sdb_handle, + SdbInterfaceInfo* info, + unsigned long* size) { + if (NULL == size) { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + // Lookup SdbInterfaceEnumObject object for the handle + SdbInterfaceEnumObject* sdb_ienum_object = + LookupObject(sdb_handle); + if (NULL == sdb_ienum_object) + return false; + + // Everything is verified. Pass it down to the object + bool ret = sdb_ienum_object->Next(info, size); + + sdb_ienum_object->Release(); + + return ret; +} + +bool __cdecl SdbResetInterfaceEnum(SDBAPIHANDLE sdb_handle) { + // Lookup SdbInterfaceEnumObject object for the handle + SdbInterfaceEnumObject* sdb_ienum_object = + LookupObject(sdb_handle); + if (NULL == sdb_ienum_object) + return false; + + // Everything is verified. Pass it down to the object + bool ret = sdb_ienum_object->Reset(); + + sdb_ienum_object->Release(); + + return ret; +} + +SDBAPIHANDLE __cdecl SdbCreateInterfaceByName( + const wchar_t* interface_name) { + SdbInterfaceObject* obj = NULL; + SDBAPIHANDLE ret = NULL; + + try { + // Instantiate interface object, depending on the USB driver type. + if (IsLegacyInterface(interface_name)) { + // We have legacy USB driver underneath us. + obj = new SdbLegacyInterfaceObject(interface_name); + } else { + printf("IsLegacyInterface failed\n"); + // We have WinUsb driver underneath us. Make sure that SdbWinUsbApi.dll + // is loaded and its InstantiateWinUsbInterface routine address has + // been cached. + if (NULL != InstantiateSdbWinUsbInterface) { + printf("NULL != InstantiateSdbWinUsbInterface\n"); + obj = InstantiateSdbWinUsbInterface(interface_name); + if (NULL == obj) { + printf("NULL == obj\n"); + return NULL; + } + } else { + printf("NULL != InstantiateWinUsbInterface\n"); + return NULL; + } + } + + // Create handle for it + ret = obj->CreateHandle(); + } catch (...) { + SetLastError(ERROR_OUTOFMEMORY); + } + + if (NULL != obj) + obj->Release(); + + return ret; +} + +SDBAPIHANDLE __cdecl SdbCreateInterface(GUID class_id, + unsigned short vendor_id, + unsigned short product_id, + unsigned char interface_id) { + // Enumerate all active interfaces for the given class + SdbEnumInterfaceArray interfaces; + + if (!EnumerateDeviceInterfaces(class_id, + DIGCF_DEVICEINTERFACE | DIGCF_PRESENT, + true, + true, + &interfaces)) { + return NULL; + } + + if (interfaces.empty()) { + SetLastError(ERROR_DEVICE_NOT_AVAILABLE); + return NULL; + } + + // Now iterate over active interfaces looking for the name match. + // The name is formatted as such: + // "\\\\?\\usb#vid_xxxx&pid_xxxx&mi_xx#123456789abcdef#{XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}" + // where + // vid_xxxx is for the vendor id (xxxx are hex for the given vendor id), + // pid_xxxx is for the product id (xxxx are hex for the given product id) + // mi_xx is for the interface id (xx are hex for the given interface id) + // EnumerateDeviceInterfaces will guarantee that returned interface names + // will have our class id at the end of the name (those last XXXes in the + // format). So, we only need to match the beginning of the name + wchar_t match_name[64]; + if (0xFF == interface_id) { + // No interface id for the name. + swprintf(match_name, L"\\\\?\\usb#vid_%04x&pid_%04x#", + vendor_id, product_id); + } else { + // With interface id for the name. + swprintf(match_name, L"\\\\?\\usb#vid_%04x&pid_%04x&mi_%02x#", + vendor_id, product_id, interface_id); + } + size_t match_len = wcslen(match_name); + + for (SdbEnumInterfaceArray::iterator it = interfaces.begin(); + it != interfaces.end(); it++) { + const SdbInstanceEnumEntry& next_interface = *it; + if (0 == _wcsnicmp(match_name, + next_interface.device_name().c_str(), + match_len)) { + // Found requested interface among active interfaces. + return SdbCreateInterfaceByName(next_interface.device_name().c_str()); + } + } + + SetLastError(ERROR_DEVICE_NOT_AVAILABLE); + return NULL; +} + +bool __cdecl SdbGetInterfaceName(SDBAPIHANDLE sdb_interface, + void* buffer, + unsigned long* buffer_char_size, + bool ansi) { + // Lookup interface object for the handle + SdbInterfaceObject* sdb_object = + LookupObject(sdb_interface); + + if (NULL != sdb_object) { + // Dispatch call to the found object + bool ret = sdb_object->GetInterfaceName(buffer, buffer_char_size, ansi); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool __cdecl SdbGetSerialNumber(SDBAPIHANDLE sdb_interface, + void* buffer, + unsigned long* buffer_char_size, + bool ansi) { + // Lookup interface object for the handle + SdbInterfaceObject* sdb_object = + LookupObject(sdb_interface); + + if (NULL != sdb_object) { + // Dispatch call to the found object + bool ret = sdb_object->GetSerialNumber(buffer, buffer_char_size, ansi); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool __cdecl SdbGetUsbDeviceDescriptor(SDBAPIHANDLE sdb_interface, + USB_DEVICE_DESCRIPTOR* desc) { + // Lookup interface object for the handle + SdbInterfaceObject* sdb_object = + LookupObject(sdb_interface); + + if (NULL != sdb_object) { + // Dispatch close to the found object + bool ret = sdb_object->GetUsbDeviceDescriptor(desc); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool __cdecl SdbGetUsbConfigurationDescriptor(SDBAPIHANDLE sdb_interface, + USB_CONFIGURATION_DESCRIPTOR* desc) { + // Lookup interface object for the handle + SdbInterfaceObject* sdb_object = + LookupObject(sdb_interface); + + if (NULL != sdb_object) { + // Dispatch close to the found object + bool ret = sdb_object->GetUsbConfigurationDescriptor(desc); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool __cdecl SdbGetUsbInterfaceDescriptor(SDBAPIHANDLE sdb_interface, + USB_INTERFACE_DESCRIPTOR* desc) { + // Lookup interface object for the handle + SdbInterfaceObject* sdb_object = + LookupObject(sdb_interface); + + if (NULL != sdb_object) { + // Dispatch close to the found object + bool ret = sdb_object->GetUsbInterfaceDescriptor(desc); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool __cdecl SdbGetEndpointInformation(SDBAPIHANDLE sdb_interface, + UCHAR endpoint_index, + SdbEndpointInformation* info) { + // Lookup interface object for the handle + SdbInterfaceObject* sdb_object = + LookupObject(sdb_interface); + + if (NULL != sdb_object) { + // Dispatch close to the found object + bool ret = sdb_object->GetEndpointInformation(endpoint_index, info); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool __cdecl SdbGetDefaultBulkReadEndpointInformation(SDBAPIHANDLE sdb_interface, + SdbEndpointInformation* info) { + return SdbGetEndpointInformation(sdb_interface, + SDB_QUERY_BULK_READ_ENDPOINT_INDEX, + info); +} + +bool __cdecl SdbGetDefaultBulkWriteEndpointInformation(SDBAPIHANDLE sdb_interface, + SdbEndpointInformation* info) { + return SdbGetEndpointInformation(sdb_interface, + SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX, + info); +} + +SDBAPIHANDLE __cdecl SdbOpenEndpoint(SDBAPIHANDLE sdb_interface, + unsigned char endpoint_index, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode) { + // Lookup interface object for the handle + SdbInterfaceObject* sdb_object = + LookupObject(sdb_interface); + + if (NULL != sdb_object) { + // Dispatch close to the found object + SDBAPIHANDLE ret = + sdb_object->OpenEndpoint(endpoint_index, access_type, sharing_mode); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return NULL; + } +} + +SDBAPIHANDLE __cdecl SdbOpenDefaultBulkReadEndpoint(SDBAPIHANDLE sdb_interface, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode) { + return SdbOpenEndpoint(sdb_interface, + SDB_QUERY_BULK_READ_ENDPOINT_INDEX, + access_type, + sharing_mode); +} + +SDBAPIHANDLE __cdecl SdbOpenDefaultBulkWriteEndpoint(SDBAPIHANDLE sdb_interface, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode) { + return SdbOpenEndpoint(sdb_interface, + SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX, + access_type, + sharing_mode); +} + +SDBAPIHANDLE __cdecl SdbGetEndpointInterface(SDBAPIHANDLE sdb_endpoint) { + // Lookup endpoint object for the handle + SdbEndpointObject* sdb_object = + LookupObject(sdb_endpoint); + + if (NULL != sdb_object) { + // Dispatch the call to the found object + SDBAPIHANDLE ret = sdb_object->GetParentInterfaceHandle(); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return NULL; + } +} + +bool __cdecl SdbQueryInformationEndpoint(SDBAPIHANDLE sdb_endpoint, + SdbEndpointInformation* info) { + // Lookup endpoint object for the handle + SdbEndpointObject* sdb_object = + LookupObject(sdb_endpoint); + + if (NULL != sdb_object) { + // Dispatch the call to the found object + bool ret = sdb_object->GetEndpointInformation(info); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +SDBAPIHANDLE __cdecl SdbReadEndpointAsync(SDBAPIHANDLE sdb_endpoint, + void* buffer, + unsigned long bytes_to_read, + unsigned long* bytes_read, + unsigned long time_out, + HANDLE event_handle) { + // Lookup endpoint object for the handle + SdbEndpointObject* sdb_object = + LookupObject(sdb_endpoint); + + if (NULL != sdb_object) { + // Dispatch the call to the found object + SDBAPIHANDLE ret = sdb_object->AsyncRead(buffer, + bytes_to_read, + bytes_read, + event_handle, + time_out); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return NULL; + } +} + +SDBAPIHANDLE __cdecl SdbWriteEndpointAsync(SDBAPIHANDLE sdb_endpoint, + void* buffer, + unsigned long bytes_to_write, + unsigned long* bytes_written, + unsigned long time_out, + HANDLE event_handle) { + // Lookup endpoint object for the handle + SdbEndpointObject* sdb_object = + LookupObject(sdb_endpoint); + + if (NULL != sdb_object) { + // Dispatch the call to the found object + SDBAPIHANDLE ret = sdb_object->AsyncWrite(buffer, + bytes_to_write, + bytes_written, + event_handle, + time_out); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool __cdecl SdbReadEndpointSync(SDBAPIHANDLE sdb_endpoint, + void* buffer, + unsigned long bytes_to_read, + unsigned long* bytes_read, + unsigned long time_out) { + // Lookup endpoint object for the handle + SdbEndpointObject* sdb_object = + LookupObject(sdb_endpoint); + + if (NULL != sdb_object) { + // Dispatch the call to the found object + bool ret = + sdb_object->SyncRead(buffer, bytes_to_read, bytes_read, time_out); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return NULL; + } +} + +bool __cdecl SdbWriteEndpointSync(SDBAPIHANDLE sdb_endpoint, + void* buffer, + unsigned long bytes_to_write, + unsigned long* bytes_written, + unsigned long time_out) { + // Lookup endpoint object for the handle + SdbEndpointObject* sdb_object = + LookupObject(sdb_endpoint); + + if (NULL != sdb_object) { + // Dispatch the call to the found object + bool ret = + sdb_object->SyncWrite(buffer, bytes_to_write, bytes_written, time_out); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool __cdecl SdbGetOvelappedIoResult(SDBAPIHANDLE sdb_io_completion, + LPOVERLAPPED overlapped, + unsigned long* bytes_transferred, + bool wait) { + // Lookup endpoint object for the handle + SdbIOCompletion* sdb_object = + LookupObject(sdb_io_completion); + + if (NULL != sdb_object) { + // Dispatch the call to the found object + bool ret = + sdb_object->GetOvelappedIoResult(overlapped, bytes_transferred, wait); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} + +bool __cdecl SdbHasOvelappedIoComplated(SDBAPIHANDLE sdb_io_completion) { + // Lookup endpoint object for the handle + SdbIOCompletion* sdb_object = + LookupObject(sdb_io_completion); + + if (NULL != sdb_object) { + // Dispatch the call to the found object + bool ret = + sdb_object->IsCompleted(); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return true; + } +} + +bool __cdecl SdbCloseHandle(SDBAPIHANDLE sdb_handle) { + // Lookup object for the handle + SdbObjectHandle* sdb_object = SdbObjectHandle::Lookup(sdb_handle); + + if (NULL != sdb_object) { + // Dispatch close to the found object + bool ret = sdb_object->CloseHandle(); + sdb_object->Release(); + return ret; + } else { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } +} diff --git a/src/sdbwinapi/sdb_api.h b/src/sdbwinapi/sdb_api.h new file mode 100644 index 0000000..2ae7aa6 --- /dev/null +++ b/src/sdbwinapi/sdb_api.h @@ -0,0 +1,622 @@ +/* + * 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 ANDROID_USB_API_SDBWINAPI_H__ +#define ANDROID_USB_API_SDBWINAPI_H__ + +/** \file + This file consists of declarations of routines exported by the API as well + as types, structures, and constants definitions used in the API. +*/ + +// Enables compillation for "straight" C +#ifdef __cplusplus + #define EXTERN_C extern "C" +#else + #define EXTERN_C extern + typedef int bool; + #define true 1 + #define false 0 +#endif + +/** \brief Enumerates SDB endpoint types. + + This enum is taken from WDF_USB_PIPE_TYPE enum found in WDK. +*/ +typedef enum _SdbEndpointType { + /// Unknown (invalid, or not initialized) endpoint type. + SdbEndpointTypeInvalid = 0, + + /// Endpoint is device control pipe. + SdbEndpointTypeControl, + + /// Endpoint is isochronous r/w pipe. + SdbEndpointTypeIsochronous, + + /// Endpoint is a bulk r/w pipe. + SdbEndpointTypeBulk, + + /// Endpoint is an interrupt r/w pipe. + SdbEndpointTypeInterrupt, +} SdbEndpointType; + +/** \brief Endpoint desriptor. + + This structure is based on WDF_USB_PIPE_INFORMATION structure found in WDK. +*/ +typedef struct _SdbEndpointInformation { + /// Maximum packet size this endpoint is capable of. + unsigned long max_packet_size; + + /// Maximum size of one transfer which should be sent to the host controller. + unsigned long max_transfer_size; + + /// SDB endpoint type. + SdbEndpointType endpoint_type; + + /// Raw endpoint address on the device as described by its descriptor. + unsigned char endpoint_address; + + /// Polling interval. + unsigned char polling_interval; + + /// Which alternate setting this structure is relevant for. + unsigned char setting_index; +} SdbEndpointInformation; + +/// Shortcut to default write bulk endpoint in zero-based endpoint index API. +#define SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX 0xFC + +/// Shortcut to default read bulk endpoint in zero-based endpoint index API. +#define SDB_QUERY_BULK_READ_ENDPOINT_INDEX 0xFE + +// {F72FE0D4-CBCB-407d-8814-9ED673D0DD6B} +/// Our USB class id that driver uses to register our device. +#define ANDROID_USB_CLASS_ID {0x9ca29f37, 0xdd62, 0x4aad, {0x82, 0x65, 0xcf, 0xf7, 0x88, 0xc8, 0xba, 0x89}}; +//{0xf72fe0d4, 0xcbcb, 0x407d, {0x88, 0x14, 0x9e, 0xd6, 0x73, 0xd0, 0xdd, 0x6b}}; + +/// Defines vendor ID for HCT devices. +#define DEVICE_VENDOR_ID 0x0BB4 + +/// Defines product ID for the device with single interface. +#define DEVICE_SINGLE_PRODUCT_ID 0x0C01 + +/// Defines product ID for the Dream composite device. +#define DEVICE_COMPOSITE_PRODUCT_ID 0x0C02 + +/// Defines product ID for the Magic composite device. +#define DEVICE_MAGIC_COMPOSITE_PRODUCT_ID 0x0C03 + +/// Defines interface ID for the device. +#define DEVICE_INTERFACE_ID 0x01 + +/// Defines vendor ID for the device +#define DEVICE_EMULATOR_VENDOR_ID 0x18D1 + +/// Defines product ID for a SoftUSB device simulator that is used to test +/// the driver in isolation from hardware. +#define DEVICE_EMULATOR_PROD_ID 0xDDDD + +// The following ifdef block is the standard way of creating macros which make +// exporting from a DLL simpler. All files within this DLL are compiled with +// the SDBWIN_EXPORTS symbol defined on the command line. this symbol should +// not be defined on any project that uses this DLL. This way any other project +// whose source files include this file see SDBWIN_API functions as being +// imported from a DLL, whereas this DLL sees symbols defined with this macro +// as being exported. +#ifdef SDBWIN_EXPORTS +#define SDBWIN_API EXTERN_C __declspec(dllexport) +#define SDBWIN_API_CLASS __declspec(dllexport) +#else +#define SDBWIN_API EXTERN_C __declspec(dllimport) +#define SDBWIN_API_CLASS __declspec(dllimport) +#endif + +/** \brief Handle to an API object. + + To access USB interface and its components clients must first obtain a + handle to the required object. API Objects that are represented by a + handle are: + 1. Interface enumerator that provides access to a list of interfaces that + match certain criterias that were specified when interface enumerator + has been created. This handle is created in SdbEnumInterfaces routine. + 2. Interface that is the major object this API deals with. In Windows + model of the USB stack each USB device (that is physical device, + attached to a USB port) exposes one or more interfaces that become the + major entities through which that device gets accessed. Each of these + interfaces are represented as Windows Device Objects on the USB stack. + So, to this extent, at least as this API is concerned, terms "interface" + and "device" are interchangeable, since each interface is represented by + a device object on the Windows USB stack. This handle is created in + either SdbCreateInterface or SdbCreateInterfaceByName routines. + 3. Endpoint object (also called a pipe) represents an endpoint on interface + through which all I/O operations are performed. This handle is created in + one of these routines: SdbOpenEndpoint, SdbOpenDefaultBulkReadEndpoint, + or SdbOpenDefaultBulkWriteEndpoint. + 4. I/O completion object that tracks completion information of asynchronous + I/O performed on an endpoint. When an endpoint object gets opened through + this API it is opened for asynchronous (or overlapped) I/O. And each time + an asynchronous I/O is performed by this API an I/O completion object is + created to track the result of that I/O when it gets completed. Clients + of the API can then use a handle to I/O completion object to query for + the status and result of asynchronous I/O as well as wait for this I/O + completion. This handle is created in one of these routines: + SdbReadEndpointAsync, or SdbWriteEndpointAsync. + After object is no longer needed by the client, its handle must be closed + using SdbCloseHandle routine. +*/ +typedef void* SDBAPIHANDLE; + +/** \brief Defines access type with which an I/O object (endpoint) + should be opened. +*/ +typedef enum _SdbOpenAccessType { + /// Opens for read and write access. + SdbOpenAccessTypeReadWrite, + + /// Opens for read only access. + SdbOpenAccessTypeRead, + + /// Opens for write only access. + SdbOpenAccessTypeWrite, + + /// Opens for querying information. + SdbOpenAccessTypeQueryInfo, +} SdbOpenAccessType; + +/** \brief Defines sharing mode with which an I/O object (endpoint) + should be opened. +*/ +typedef enum _SdbOpenSharingMode { + /// Shares read and write. + SdbOpenSharingModeReadWrite, + + /// Shares only read. + SdbOpenSharingModeRead, + + /// Shares only write. + SdbOpenSharingModeWrite, + + /// Opens exclusive. + SdbOpenSharingModeExclusive, +} SdbOpenSharingMode; + +/** \brief Provides information about an interface. +*/ +typedef struct _SdbInterfaceInfo { + /// Inteface's class id (see SP_DEVICE_INTERFACE_DATA for details) + GUID class_id; + + /// Interface flags (see SP_DEVICE_INTERFACE_DATA for details) + unsigned long flags; + + /// Device name for the interface (see SP_DEVICE_INTERFACE_DETAIL_DATA + /// for details) + wchar_t device_name[1]; +} SdbInterfaceInfo; + +/** \brief Creates USB interface enumerator + + This routine enumerates all USB interfaces that match provided class ID. + This routine uses SetupDiGetClassDevs SDK routine to enumerate devices that + match class ID and then SetupDiEnumDeviceInterfaces SDK routine is called + to enumerate interfaces on the devices. + @param[in] class_id Device class ID, assigned by the driver. + @param[in] exclude_not_present If true enumation will include only those + devices that are currently present. + @param[in] exclude_removed If true interfaces with SPINT_REMOVED flag set + will be not included in the enumeration. + @param[in] active_only If true only active interfaces (with flag + SPINT_ACTIVE set) will be included in the enumeration. + @return Handle to the enumerator object or NULL on failure. If NULL is + returned GetLastError() provides extended error information. +*/ +SDBWIN_API SDBAPIHANDLE __cdecl SdbEnumInterfaces(GUID class_id, + bool exclude_not_present, + bool exclude_removed, + bool active_only); + +/** \brief Gets next interface information + + @param[in] sdb_handle Handle to interface enumerator object obtained via + SdbEnumInterfaces call. + @param[out] info Upon successful completion will receive interface + information. Can be NULL. If it is NULL, upon return from this + routine size parameter will contain memory size required for the + next entry. + @param[in,out] size On the way in provides size of the memory buffer + addressed by info parameter. On the way out (only if buffer was not + big enough) will provide memory size required for the next entry. + @return true on success, false on error. If false is returned + GetLastError() provides extended error information. + ERROR_INSUFFICIENT_BUFFER indicates that buffer provided in info + parameter was not big enough and size parameter contains memory size + required for the next entry. ERROR_NO_MORE_ITEMS indicates that + enumeration is over and there are no more entries to return. +*/ +SDBWIN_API bool __cdecl SdbNextInterface(SDBAPIHANDLE sdb_handle, + SdbInterfaceInfo* info, + unsigned long* size); + +/** \brief Resets enumerator so next call to SdbNextInterface will start + from the beginning. + + @param[in] sdb_handle Handle to interface enumerator object obtained via + SdbEnumInterfaces call. + @return true on success, false on error. If false is returned GetLastError() + provides extended error information. +*/ +SDBWIN_API bool __cdecl SdbResetInterfaceEnum(SDBAPIHANDLE sdb_handle); + +/** \brief Creates USB interface object + + This routine creates an object that represents a USB interface. + @param[in] interface_name Name of the interface. + @return Handle to the interface object or NULL on failure. If NULL is + returned GetLastError() provides extended error information. +*/ +SDBWIN_API SDBAPIHANDLE __cdecl SdbCreateInterfaceByName(const wchar_t* interface_name); + +/** \brief Creates USB interface object based on vendor, product and + interface IDs. + + This routine creates and object that represents a USB interface on our + device. It uses SdbCreateInterfaceByName to actually do the create. + @param[in] class_id Device class ID, assigned by the driver. + @param[in] vendor_id Device vendor ID + @param[in] product_id Device product ID + @param[in] interface_id Device interface ID. This parameter is optional. + Value 0xFF indicates that interface should be addressed by vendor + and product IDs only. + @return Handle to the interface object or NULL on failure. If NULL is + returned GetLastError() provides extended error information. +*/ +SDBWIN_API SDBAPIHANDLE __cdecl SdbCreateInterface(GUID class_id, + unsigned short vendor_id, + unsigned short product_id, + unsigned char interface_id); + +/** \brief Gets interface name. + + @param[in] sdb_interface A handle to interface object created with + SdbCreateInterface call. + @param[out] buffer Buffer for the name. Can be NULL in which case + buffer_char_size will contain number of characters required for + the name. + @param[in,out] buffer_char_size On the way in supplies size (in characters) + of the buffer. On the way out, if method failed and GetLastError + reports ERROR_INSUFFICIENT_BUFFER, will contain number of characters + required for the name. + @param[in] ansi If true the name will be returned as single character + string. Otherwise name will be returned as wide character string. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. +*/ +SDBWIN_API bool __cdecl SdbGetInterfaceName(SDBAPIHANDLE sdb_interface, + void* buffer, + unsigned long* buffer_char_size, + bool ansi); + +/** \brief Gets serial number for interface's device. + + @param[in] sdb_interface A handle to interface object created with + SdbCreateInterface call. + @param[out] buffer Buffer for the serail number string. Can be NULL in which + case buffer_char_size will contain number of characters required for + the string. + @param[in,out] buffer_char_size On the way in supplies size (in characters) + of the buffer. On the way out, if method failed and GetLastError + reports ERROR_INSUFFICIENT_BUFFER, will contain number of characters + required for the name. + @param[in] ansi If true the name will be returned as single character + string. Otherwise name will be returned as wide character string. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. +*/ +SDBWIN_API bool __cdecl SdbGetSerialNumber(SDBAPIHANDLE sdb_interface, + void* buffer, + unsigned long* buffer_char_size, + bool ansi); + +/** \brief Gets device descriptor for the USB device associated with + the given interface. + + @param[in] sdb_interface A handle to interface object created with + SdbCreateInterface call. + @param[out] desc Upon successful completion will have usb device + descriptor. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. +*/ +SDBWIN_API bool __cdecl SdbGetUsbDeviceDescriptor(SDBAPIHANDLE sdb_interface, + USB_DEVICE_DESCRIPTOR* desc); + +/** \brief Gets descriptor for the selected USB device configuration. + + @param[in] sdb_interface A handle to interface object created with + SdbCreateInterface call. + @param[out] desc Upon successful completion will have usb device + configuration descriptor. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. +*/ +SDBWIN_API bool __cdecl SdbGetUsbConfigurationDescriptor( + SDBAPIHANDLE sdb_interface, + USB_CONFIGURATION_DESCRIPTOR* desc); + +/** \brief Gets descriptor for the given interface. + + @param[in] sdb_interface A handle to interface object created with + SdbCreateInterface call. + @param[out] desc Upon successful completion will have usb device + configuration descriptor. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. +*/ +SDBWIN_API bool __cdecl SdbGetUsbInterfaceDescriptor(SDBAPIHANDLE sdb_interface, + USB_INTERFACE_DESCRIPTOR* desc); + +/** \brief Gets information about an endpoint on the given interface. + + @param[in] sdb_interface A handle to interface object created with + SdbCreateInterface call. + @param[in] endpoint_index Zero-based endpoint index. There are two + shortcuts for this parameter: SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX + and SDB_QUERY_BULK_READ_ENDPOINT_INDEX that provide information + about bulk write and bulk read endpoints respectively. + @param[out] info Upon successful completion will have endpoint information. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. +*/ +SDBWIN_API bool __cdecl SdbGetEndpointInformation(SDBAPIHANDLE sdb_interface, + unsigned char endpoint_index, + SdbEndpointInformation* info); + +/** \brief Gets information about default bulk read endpoint on the given + interface. + + @param[in] sdb_interface A handle to interface object created with + SdbCreateInterface call. + @param[out] info Upon successful completion will have endpoint information. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. +*/ +SDBWIN_API bool __cdecl SdbGetDefaultBulkReadEndpointInformation( + SDBAPIHANDLE sdb_interface, + SdbEndpointInformation* info); + +/** \brief Gets information about default bulk write endpoint on the given + interface. + + @param[in] sdb_interface A handle to interface object created with + SdbCreateInterface call. + @param[out] info Upon successful completion will have endpoint information. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. +*/ +SDBWIN_API bool __cdecl SdbGetDefaultBulkWriteEndpointInformation( + SDBAPIHANDLE sdb_interface, + SdbEndpointInformation* info); + +/** \brief Opens an endpoint on the given interface. + + Endpoints are always opened for overlapped I/O. + @param[in] sdb_interface A handle to interface object created with + SdbCreateInterface call. + @param[in] endpoint_index Zero-based endpoint index. There are two + shortcuts for this parameter: SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX + and SDB_QUERY_BULK_READ_ENDPOINT_INDEX that provide information + about bulk write and bulk read endpoints respectively. + @param[in] access_type Desired access type. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always read / write access. + @param[in] sharing_mode Desired share mode. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always shared for read / write. + @return Handle to the opened endpoint object or NULL on failure. If NULL is + returned GetLastError() provides extended error information. +*/ +SDBWIN_API SDBAPIHANDLE __cdecl SdbOpenEndpoint(SDBAPIHANDLE sdb_interface, + unsigned char endpoint_index, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode); + +/** \brief Opens default bulk read endpoint on the given interface. + + Endpoints are always opened for overlapped I/O. + @param[in] sdb_interface A handle to interface object created with + SdbCreateInterface call. + @param[in] access_type Desired access type. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always read / write access. + @param[in] sharing_mode Desired share mode. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always shared for read / write. + @return Handle to the opened endpoint object or NULL on failure. If NULL is + returned GetLastError() provides extended error information. +*/ +SDBWIN_API SDBAPIHANDLE __cdecl SdbOpenDefaultBulkReadEndpoint( + SDBAPIHANDLE sdb_interface, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode); + +/** \brief Opens default bulk write endpoint on the given interface. + + Endpoints are always opened for overlapped I/O. + @param[in] sdb_interface A handle to interface object created with + SdbCreateInterface call. + @param[in] access_type Desired access type. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always read / write access. + @param[in] sharing_mode Desired share mode. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always shared for read / write. + @return Handle to the opened endpoint object or NULL on failure. If NULL is + returned GetLastError() provides extended error information. +*/ +SDBWIN_API SDBAPIHANDLE __cdecl SdbOpenDefaultBulkWriteEndpoint( + SDBAPIHANDLE sdb_interface, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode); + +/** \brief Gets handle to interface object for the given endpoint + + @param[in] sdb_endpoint A handle to opened endpoint object, obtained via one + of the SdbOpenXxxEndpoint calls. + @return Handle to the interface for this endpoint or NULL on failure. If NULL + is returned GetLastError() provides extended error information. +*/ +SDBWIN_API SDBAPIHANDLE __cdecl SdbGetEndpointInterface(SDBAPIHANDLE sdb_endpoint); + +/** \brief Gets information about the given endpoint. + + @param[in] sdb_endpoint A handle to opened endpoint object, obtained via one + of the SdbOpenXxxEndpoint calls. + @param[out] info Upon successful completion will have endpoint information. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. +*/ +SDBWIN_API bool __cdecl SdbQueryInformationEndpoint(SDBAPIHANDLE sdb_endpoint, + SdbEndpointInformation* info); + +/** \brief Asynchronously reads from the given endpoint. + + @param[in] sdb_endpoint A handle to opened endpoint object, obtained via one + of the SdbOpenXxxEndpoint calls. + @param[out] buffer Pointer to the buffer that receives the data. + @param[in] bytes_to_read Number of bytes to be read. + @param[out] bytes_read Number of bytes read. Can be NULL. + @param[in] event_handle Event handle that should be signaled when async I/O + completes. Can be NULL. If it's not NULL this handle will be used to + initialize OVERLAPPED structure for this I/O. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value for this parameter means that there is no + timeout for this I/O. + @return A handle to IO completion object or NULL on failure. If NULL is + returned GetLastError() provides extended error information. +*/ +SDBWIN_API SDBAPIHANDLE __cdecl SdbReadEndpointAsync(SDBAPIHANDLE sdb_endpoint, + void* buffer, + unsigned long bytes_to_read, + unsigned long* bytes_read, + unsigned long time_out, + HANDLE event_handle); + +/** \brief Asynchronously writes to the given endpoint. + + @param[in] sdb_endpoint A handle to opened endpoint object, obtained via one + of the SdbOpenXxxEndpoint calls. + @param[in] buffer Pointer to the buffer containing the data to be written. + @param[in] bytes_to_write Number of bytes to be written. + @param[out] bytes_written Number of bytes written. Can be NULL. + @param[in] event_handle Event handle that should be signaled when async I/O + completes. Can be NULL. If it's not NULL this handle will be used to + initialize OVERLAPPED structure for this I/O. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value for this parameter means that there is no + timeout for this I/O. + @return A handle to IO completion object or NULL on failure. If NULL is + returned GetLastError() provides extended error information. +*/ +SDBWIN_API SDBAPIHANDLE __cdecl SdbWriteEndpointAsync(SDBAPIHANDLE sdb_endpoint, + void* buffer, + unsigned long bytes_to_write, + unsigned long* bytes_written, + unsigned long time_out, + HANDLE event_handle); + +/** \brief Synchronously reads from the given endpoint. + + @param[in] sdb_endpoint A handle to opened endpoint object, obtained via one + of the SdbOpenXxxEndpoint calls. + @param[out] buffer Pointer to the buffer that receives the data. + @param[in] bytes_to_read Number of bytes to be read. + @param[out] bytes_read Number of bytes read. Can be NULL. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value for this parameter means that there is no + timeout for this I/O. + @return true on success and false on failure. If false is + returned GetLastError() provides extended error information. +*/ +SDBWIN_API bool __cdecl SdbReadEndpointSync(SDBAPIHANDLE sdb_endpoint, + void* buffer, + unsigned long bytes_to_read, + unsigned long* bytes_read, + unsigned long time_out); + +/** \brief Synchronously writes to the given endpoint. + + @param[in] sdb_endpoint A handle to opened endpoint object, obtained via one + of the SdbOpenXxxEndpoint calls. + @param[in] buffer Pointer to the buffer containing the data to be written. + @param[in] bytes_to_write Number of bytes to be written. + @param[out] bytes_written Number of bytes written. Can be NULL. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value for this parameter means that there is no + timeout for this I/O. + @return true on success and false on failure. If false is + returned GetLastError() provides extended error information. +*/ +SDBWIN_API bool __cdecl SdbWriteEndpointSync(SDBAPIHANDLE sdb_endpoint, + void* buffer, + unsigned long bytes_to_write, + unsigned long* bytes_written, + unsigned long time_out); + +/** \brief Gets overlapped I/O result for async I/O performed on the + given endpoint. + + @param[in] sdb_io_completion A handle to an I/O completion object returned + from SdbRead/WriteAsync routines. + @param[out] ovl_data Buffer for the copy of this object's OVERLAPPED + structure. Can be NULL. + @param[out] bytes_transferred Pointer to a variable that receives the + number of bytes that were actually transferred by a read or write + operation. See SDK doc on GetOvelappedResult for more information. + Unlike regular GetOvelappedResult call this parameter can be NULL. + @param[in] wait If this parameter is true, the method does not return + until the operation has been completed. If this parameter is false + and the operation is still pending, the method returns false and + the GetLastError function returns ERROR_IO_INCOMPLETE. + @return true if I/O has been completed or false on failure or if request + is not yet completed. If false is returned GetLastError() provides + extended error information. If GetLastError returns + ERROR_IO_INCOMPLETE it means that I/O is not yet completed. +*/ +SDBWIN_API bool __cdecl SdbGetOvelappedIoResult(SDBAPIHANDLE sdb_io_completion, + LPOVERLAPPED overlapped, + unsigned long* bytes_transferred, + bool wait); + +/** \brief Checks if overlapped I/O has been completed. + + @param[in] sdb_io_completion A handle to an I/O completion object returned + from SdbRead/WriteAsync routines. + @return true if I/O has been completed or false if it's still + incomplete. Regardless of the returned value, caller should + check GetLastError to validate that handle was OK. +*/ +SDBWIN_API bool __cdecl SdbHasOvelappedIoComplated(SDBAPIHANDLE sdb_io_completion); + +/** \brief Closes handle previously opened with one of the API calls + + @param[in] sdb_handle SDB handle previously opened with one of the API calls + @return true on success or false on failure. If false is returned + GetLastError() provides extended error information. +*/ +SDBWIN_API bool __cdecl SdbCloseHandle(SDBAPIHANDLE sdb_handle); + +#endif // ANDROID_USB_API_SDBWINAPI_H__ diff --git a/src/sdbwinapi/sdb_api_instance.cpp b/src/sdbwinapi/sdb_api_instance.cpp new file mode 100644 index 0000000..085f2c7 --- /dev/null +++ b/src/sdbwinapi/sdb_api_instance.cpp @@ -0,0 +1,47 @@ +/* + * 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. + */ + +/** \file + This file consists of implementation of class SdbApiInstance that is a main + API object representing a device interface that is in the interest of + the API client. All device (interface) related operations go through this + class first. +*/ + +#include "stdafx.h" +#include "sdb_api_instance.h" +#include "sdb_helper_routines.h" + +/// Map that holds all instances of this object +SdbApiInstanceMap sdb_app_instance_map; +ULONG_PTR sdb_app_instance_id = 0; +CComAutoCriticalSection sdb_app_instance_map_locker; + +SdbApiInstance::SdbApiInstance() + : ref_count_(1) { + // Generate inteface handle + sdb_app_instance_map_locker.Lock(); + sdb_app_instance_id++; + sdb_app_instance_map_locker.Unlock(); + instance_handle_ = + reinterpret_cast(sdb_app_instance_id); +} + +SdbApiInstance::~SdbApiInstance() { +} + +void SdbApiInstance::LastReferenceReleased() { +} diff --git a/src/sdbwinapi/sdb_api_instance.h b/src/sdbwinapi/sdb_api_instance.h new file mode 100644 index 0000000..50a5568 --- /dev/null +++ b/src/sdbwinapi/sdb_api_instance.h @@ -0,0 +1,113 @@ +/* + * 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 ANDROID_USB_API_SDB_API_INSTANCE_H__ +#define ANDROID_USB_API_SDB_API_INSTANCE_H__ +/** \file + This file consists of declaration of class SdbApiInstance that is a main + API object representing a device interface that is in the interest of + the API client. All device (interface) related operations go through this + class first. +*/ + +#include "sdb_api.h" +#include "sdb_api_private_defines.h" + +/** Class SdbApiInstance is the main API interbal object representing a device + interface that is in the interest of the API client. All device (interface) + related operations go through this class first. So, before doing anything + meaningfull with the API a client must first create instance of the API + via CreateSdbApiInstance, select a device interface for that instance and + then do everything else. + Objects of this class are globally stored in the map that matches + SDBAPIINSTANCEHANDLE to the corresponded object. + This class is self-referenced with the following reference model: + 1. When object of this class is created and added to the map, its recount + is set to 1. + 2. Every time the client makes an API call that uses SDBAPIINSTANCEHANDLE + a corresponded SdbApiInstance object is looked up in the table and its + refcount is incremented. Upon return from the API call that incremented + the refcount refcount gets decremented. + 3. When the client closes SDBAPIINSTANCEHANDLE via DeleteSdbApiInstance call + corresponded object gets deleted from the map and its refcount is + decremented. + So, at the end, this object destroys itself when refcount drops to zero. +*/ +class SdbApiInstance { + public: + /** \brief Constructs the object + + @param handle[in] Instance handle associated with this object + */ + SdbApiInstance(); + + private: + /// Destructs the object + ~SdbApiInstance(); + + /** \brief + This method is called when last reference to this object has been released + + In this method object is uninitialized and deleted (that is "delete this" + is called). + */ + void LastReferenceReleased(); + + public: + /// Gets name of the USB interface (device name) for this instance + const std::wstring& interface_name() const { + return interface_name_; + } + + /// References the object and returns number of references + LONG AddRef() { + return InterlockedIncrement(&ref_count_); + } + + /** \brief Dereferences the object and returns number of references + + Object may be deleted in this method, so you cannot touch it after + this method returns, even if returned value is not zero, because object + can be deleted in another thread. + */ + LONG Release() { + LONG ret = InterlockedDecrement(&ref_count_); + if (0 == ret) + LastReferenceReleased(); + + return ret; + } + + /// Checks if instance has been initialized + bool IsInitialized() const { + return !interface_name_.empty(); + } + +private: + /// Name of the USB interface (device name) for this instance + std::wstring interface_name_; + + /// Instance handle for this object + SDBAPIINSTANCEHANDLE instance_handle_; + + /// Reference counter for this instance + LONG ref_count_; +}; + +/// Defines map that matches SDBAPIINSTANCEHANDLE with SdbApiInstance object +typedef std::map< SDBAPIINSTANCEHANDLE, SdbApiInstance* > SdbApiInstanceMap; + +#endif // ANDROID_USB_API_SDB_API_INSTANCE_H__ diff --git a/src/sdbwinapi/sdb_api_legacy.h b/src/sdbwinapi/sdb_api_legacy.h new file mode 100644 index 0000000..552d951 --- /dev/null +++ b/src/sdbwinapi/sdb_api_legacy.h @@ -0,0 +1,190 @@ +/* + * Copyright (C) 2009 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 ANDROID_USB_API_SDB_API_LEGACY_H_ +#define ANDROID_USB_API_SDB_API_LEGACY_H_ +/** \file + This file consists of declarations of constants and structures required + for supporting communications of this API with a legacy (custom) USB + driver. +*/ + +// Enables compillation for "straight" C +#ifdef __cplusplus + #define EXTERN_C extern "C" +#else + #define EXTERN_C extern + typedef int bool; + #define true 1 + #define false 0 +#endif + +/// Name for the default bulk read pipe +#define DEVICE_BULK_READ_PIPE_NAME L"BulkRead" + +/// Name for the default bulk write pipe +#define DEVICE_BULK_WRITE_PIPE_NAME L"BulkWrite" + +/// Prefix for an index-based pipe name +#define DEVICE_PIPE_NAME_PREFIX L"PIPE_" + +/** \name IOCTL codes for the driver +*/ +///@{ + +/// Control code for IOCTL that gets USB_DEVICE_DESCRIPTOR +#define SDB_CTL_GET_USB_DEVICE_DESCRIPTOR 10 + +/// Control code for IOCTL that gets USB_CONFIGURATION_DESCRIPTOR +#define SDB_CTL_GET_USB_CONFIGURATION_DESCRIPTOR 11 + +/// Control code for IOCTL that gets USB_INTERFACE_DESCRIPTOR +#define SDB_CTL_GET_USB_INTERFACE_DESCRIPTOR 12 + +/// Control code for IOCTL that gets endpoint information +#define SDB_CTL_GET_ENDPOINT_INFORMATION 13 + +/// Control code for bulk read IOCTL +#define SDB_CTL_BULK_READ 14 + +/// Control code for bulk write IOCTL +#define SDB_CTL_BULK_WRITE 15 + +/// Control code for IOCTL that gets device serial number +#define SDB_CTL_GET_SERIAL_NUMBER 16 + +/// IOCTL that gets USB_DEVICE_DESCRIPTOR +#define SDB_IOCTL_GET_USB_DEVICE_DESCRIPTOR \ + CTL_CODE(FILE_DEVICE_UNKNOWN, \ + SDB_CTL_GET_USB_DEVICE_DESCRIPTOR, \ + METHOD_BUFFERED, \ + FILE_READ_ACCESS) + +/// IOCTL that gets USB_CONFIGURATION_DESCRIPTOR +#define SDB_IOCTL_GET_USB_CONFIGURATION_DESCRIPTOR \ + CTL_CODE(FILE_DEVICE_UNKNOWN, \ + SDB_CTL_GET_USB_CONFIGURATION_DESCRIPTOR, \ + METHOD_BUFFERED, \ + FILE_READ_ACCESS) + +/// IOCTL that gets USB_INTERFACE_DESCRIPTOR +#define SDB_IOCTL_GET_USB_INTERFACE_DESCRIPTOR \ + CTL_CODE(FILE_DEVICE_UNKNOWN, \ + SDB_CTL_GET_USB_INTERFACE_DESCRIPTOR, \ + METHOD_BUFFERED, \ + FILE_READ_ACCESS) + +/// IOCTL that gets endpoint information +#define SDB_IOCTL_GET_ENDPOINT_INFORMATION \ + CTL_CODE(FILE_DEVICE_UNKNOWN, \ + SDB_CTL_GET_ENDPOINT_INFORMATION, \ + METHOD_BUFFERED, \ + FILE_READ_ACCESS) + +/// Bulk read IOCTL +#define SDB_IOCTL_BULK_READ \ + CTL_CODE(FILE_DEVICE_UNKNOWN, \ + SDB_CTL_BULK_READ, \ + METHOD_OUT_DIRECT, \ + FILE_READ_ACCESS) + +// For bulk write IOCTL we send request data in the form of SdbBulkTransfer +// structure and output buffer is just ULONG that receives number of bytes +// actually written. Since both of these are tiny we can use buffered I/O +// for this IOCTL. +/// Bulk write IOCTL +#define SDB_IOCTL_BULK_WRITE \ + CTL_CODE(FILE_DEVICE_UNKNOWN, \ + SDB_CTL_BULK_WRITE, \ + METHOD_BUFFERED, \ + FILE_WRITE_ACCESS) + +/// IOCTL that gets device serial number +#define SDB_IOCTL_GET_SERIAL_NUMBER \ + CTL_CODE(FILE_DEVICE_UNKNOWN, \ + SDB_CTL_GET_SERIAL_NUMBER, \ + METHOD_BUFFERED, \ + FILE_READ_ACCESS) + +///@} + +/** Structure SdbQueryEndpointInformation formats input for + SDB_IOCTL_GET_ENDPOINT_INFORMATION IOCTL request +*/ +struct SdbQueryEndpointInformation { + /// Zero-based endpoint index for which information is queried. + /// See SDB_QUERY_BULK_xxx_ENDPOINT_INDEX for shortcuts. + UCHAR endpoint_index; +}; + +/** Structure SdbBulkTransfer formats parameters for SDB_CTL_BULK_READ and + SDB_CTL_BULK_WRITE IOCTL requests. +*/ +struct SdbBulkTransfer { + /// Time in milliseconds to complete this request + ULONG time_out; + + /// Size of the data to transfer. This parameter is used only for + /// SDB_CTL_BULK_WRITE request. For SDB_CTL_BULK_READ requests transfer + /// size is defined by the output buffer size. + ULONG transfer_size; + + /// Initializes statically allocated structure + __forceinline SdbBulkTransfer() { + time_out = 0; + transfer_size = 0; + for_x64 = 0; + } + + /// Provides access to protected write_buffer field + void* GetWriteBuffer() { + return write_buffer; + } + + /// Provides access to protected write_buffer field + const void* GetWriteBuffer() const { + return write_buffer; + } + + /// Sets write_buffer field. + void SetWriteBuffer(void* buffer) { + // For 32-bit we must zero out high 32 bit of the address, so 64-bit + // driver will see valid address when accessing 64-bit write_buffer. + for_x64 = 0; + write_buffer = buffer; + } + +protected: + /// Pointer to the actual buffer for SDB_CTL_BULK_WRITE request. This field + /// is not used in SDB_CTL_BULK_READ request. Note that in order to support + /// compatibility between 32-bit and 64-bit versions of both, driver and + /// application we must sizeof this field to the max pointer sizeof (which + /// is 64 bit in our case). The idea is that if IOCTL was issued by a 64-bit + /// process to a 64-bit driver, write_buffer will be valid 64-bit pointer to + /// the write buffer. Same is true for 32-bit app talking to 32-bit driver. + /// If, however, a 32-bit app is talking to 64-bit driver, then write_buffer + /// initialized by 32-bit app will contain 32-bit address, which will be + /// correctly picked up ("extended") by 64-bit driver. Since when setting + /// this field by a 32-bit app requires some extra work (see SetWriteBuffer) + /// we hide this field, making it accessible only throug the accessor + /// methods (Get/SetWriteBuffer). + union { + void* write_buffer; + __int64 for_x64; + }; +}; + +#endif // ANDROID_USB_API_SDB_API_LEGACY_H_ diff --git a/src/sdbwinapi/sdb_api_private_defines.h b/src/sdbwinapi/sdb_api_private_defines.h new file mode 100644 index 0000000..ce3f1c9 --- /dev/null +++ b/src/sdbwinapi/sdb_api_private_defines.h @@ -0,0 +1,114 @@ +/* + * 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 ANDROID_USB_SDB_API_PRIVATE_DEFINES_H__ +#define ANDROID_USB_SDB_API_PRIVATE_DEFINES_H__ +/** \file + This file consists of private definitions used inside the API +*/ + +#include "sdb_api.h" + +/** \brief Encapsulates an entry in the array of enumerated interfaces. +*/ +class SdbInstanceEnumEntry { + public: + /** \brief Constructs an empty object. + */ + SdbInstanceEnumEntry() + : flags_(0) { + ZeroMemory(&class_id_, sizeof(class_id_)); + } + + /** \brief Copy constructor + */ + SdbInstanceEnumEntry(const SdbInstanceEnumEntry& proto) { + Set(proto.device_name().c_str(), proto.class_id(), proto.flags()); + } + + /** \brief Constructs the object with parameters. + */ + SdbInstanceEnumEntry(const wchar_t* dev_name, GUID cls_id, DWORD flgs) { + Set(dev_name, cls_id, flgs); + } + + /** \brief Destructs the object. + */ + ~SdbInstanceEnumEntry() { + } + + /// Operator = + SdbInstanceEnumEntry& operator=(const SdbInstanceEnumEntry& proto) { + Set(proto.device_name().c_str(), proto.class_id(), proto.flags()); + return *this; + } + + /// Initializes instance with parameters + void Set(const wchar_t* dev_name, GUID cls_id, DWORD flgs) { + device_name_ = dev_name; + class_id_ = cls_id; + flags_ = flgs; + } + + /// Calculates memory size needed to save this entry into SdbInterfaceInfo + /// structure + ULONG GetFlatSize() const { + return static_cast(FIELD_OFFSET(SdbInterfaceInfo, device_name) + + (device_name_.length() + 1) * sizeof(wchar_t)); + } + + /** \brief Saves this entry into SdbInterfaceInfo structure. + + @param[in] info Buffer to save this entry to. Must be big enough to fit it. + Use GetFlatSize() method to get buffer size needed for that. + + */ + void Save(SdbInterfaceInfo* info) const { + info->class_id = class_id(); + info->flags = flags(); + wcscpy(info->device_name, device_name().c_str()); + } + + /// Gets interface's device name + const std::wstring& device_name() const { + return device_name_; + } + + /// Gets inteface's class id + GUID class_id() const { + return class_id_; + } + + /// Gets interface flags + DWORD flags() const { + return flags_; + } + + private: + /// Inteface's class id (see SP_DEVICE_INTERFACE_DATA) + GUID class_id_; + + /// Interface's device name + std::wstring device_name_; + + /// Interface flags (see SP_DEVICE_INTERFACE_DATA) + DWORD flags_; +}; + +/// Defines array of enumerated interface entries +typedef std::vector< SdbInstanceEnumEntry > SdbEnumInterfaceArray; + +#endif // ANDROID_USB_SDB_API_PRIVATE_DEFINES_H__ diff --git a/src/sdbwinapi/sdb_endpoint_object.cpp b/src/sdbwinapi/sdb_endpoint_object.cpp new file mode 100644 index 0000000..f099ab5 --- /dev/null +++ b/src/sdbwinapi/sdb_endpoint_object.cpp @@ -0,0 +1,96 @@ +/* + * 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. + */ + +/** \file + This file consists of implementation of class SdbEndpointObject that + encapsulates a handle opened to an endpoint on our device. +*/ + +#include "stdafx.h" +#include "sdb_endpoint_object.h" + +SdbEndpointObject::SdbEndpointObject(SdbInterfaceObject* parent_interf, + UCHAR endpoint_id, + UCHAR endpoint_index) + : SdbObjectHandle(SdbObjectTypeEndpoint), + parent_interface_(parent_interf), + endpoint_id_(endpoint_id), + endpoint_index_(endpoint_index) { + if (NULL != parent_interface_) + parent_interface_->AddRef(); +} + +SdbEndpointObject::~SdbEndpointObject() { + if (NULL != parent_interface_) + parent_interface_->Release(); +} + +bool SdbEndpointObject::GetEndpointInformation(SdbEndpointInformation* info) { + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + return parent_interface()->GetEndpointInformation(endpoint_index(), info); +} + +SDBAPIHANDLE SdbEndpointObject::AsyncRead(void* buffer, + ULONG bytes_to_read, + ULONG* bytes_read, + HANDLE event_handle, + ULONG time_out) { + return CommonAsyncReadWrite(true, + buffer, + bytes_to_read, + bytes_read, + event_handle, + time_out); +} + +SDBAPIHANDLE SdbEndpointObject::AsyncWrite(void* buffer, + ULONG bytes_to_write, + ULONG* bytes_written, + HANDLE event_handle, + ULONG time_out) { + return CommonAsyncReadWrite(false, + buffer, + bytes_to_write, + bytes_written, + event_handle, + time_out); +} + +bool SdbEndpointObject::SyncRead(void* buffer, + ULONG bytes_to_read, + ULONG* bytes_read, + ULONG time_out) { + return CommonSyncReadWrite(true, + buffer, + bytes_to_read, + bytes_read, + time_out); +} + +bool SdbEndpointObject::SyncWrite(void* buffer, + ULONG bytes_to_write, + ULONG* bytes_written, + ULONG time_out) { + return CommonSyncReadWrite(false, + buffer, + bytes_to_write, + bytes_written, + time_out); +} diff --git a/src/sdbwinapi/sdb_endpoint_object.h b/src/sdbwinapi/sdb_endpoint_object.h new file mode 100644 index 0000000..f670ebe --- /dev/null +++ b/src/sdbwinapi/sdb_endpoint_object.h @@ -0,0 +1,222 @@ +/* + * 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 ANDROID_USB_API_SDB_ENDPOINT_OBJECT_H__ +#define ANDROID_USB_API_SDB_ENDPOINT_OBJECT_H__ +/** \file + This file consists of declaration of class SdbEndpointObject that + encapsulates a handle opened to an endpoint on our device. +*/ + +#include "sdb_interface.h" + +/** Class SdbEndpointObject encapsulates a handle opened to an endpoint on + our device. + + This class implement functionality that is common for both, WinUsb and + legacy APIs. +*/ +class SDBWIN_API_CLASS SdbEndpointObject : public SdbObjectHandle { + public: + /** \brief Constructs the object + + @param[in] interface Parent interface for this object. Interface will be + referenced in this object's constructur and released in the + destructor. + @param[in] endpoint_id Endpoint ID (endpoint address) on the device. + @param[in] endpoint_index Zero-based endpoint index in the interface's + array of endpoints. + */ + SdbEndpointObject(SdbInterfaceObject* parent_interf, + UCHAR endpoint_id, + UCHAR endpoint_index); + + protected: + /** \brief Destructs the object. + + We hide destructor in order to prevent ourseves from accidentaly allocating + instances on the stack. If such attemp occur, compiler will error. + */ + virtual ~SdbEndpointObject(); + + // + // Abstract + // + + protected: + /** \brief Common code for async read / write + + @param[in] is_read Read or write selector. + @param[in,out] buffer Pointer to the buffer for read / write. + @param[in] bytes_to_transfer Number of bytes to be read / written. + @param[out] bytes_transferred Number of bytes read / written. Can be NULL. + @param[in] event_handle Event handle that should be signaled when async I/O + completes. Can be NULL. If it's not NULL this handle will be used to + initialize OVERLAPPED structure for this I/O. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value in this parameter means that there is no + timeout set for this I/O. + @return A handle to IO completion object or NULL on failure. If NULL is + returned GetLastError() provides extended error information. + */ + virtual SDBAPIHANDLE CommonAsyncReadWrite(bool is_read, + void* buffer, + ULONG bytes_to_transfer, + ULONG* bytes_transferred, + HANDLE event_handle, + ULONG time_out) = 0; + + /** \brief Common code for sync read / write + + @param[in] is_read Read or write selector. + @param[in,out] buffer Pointer to the buffer for read / write. + @param[in] bytes_to_transfer Number of bytes to be read / written. + @param[out] bytes_transferred Number of bytes read / written. Can be NULL. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value in this parameter means that there is no + timeout set for this I/O. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool CommonSyncReadWrite(bool is_read, + void* buffer, + ULONG bytes_to_transfer, + ULONG* bytes_transferred, + ULONG time_out) = 0; + + // + // Operations + // + + public: + /** \brief Gets information about this endpoint. + + @param[out] info Upon successful completion will have endpoint information. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool GetEndpointInformation(SdbEndpointInformation* info); + + /** \brief Reads from opened I/O object asynchronously + + @param[out] buffer Pointer to the buffer that receives the data. + @param[in] bytes_to_read Number of bytes to be read. + @param[out] bytes_read Number of bytes read. Can be NULL. + @param[in] event_handle Event handle that should be signaled when async I/O + completes. Can be NULL. If it's not NULL this handle will be used to + initialize OVERLAPPED structure for this I/O. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value in this parameter means that there is no + timeout set for this I/O. + @return A handle to IO completion object or NULL on failure. If NULL is + returned GetLastError() provides extended error information. + */ + virtual SDBAPIHANDLE AsyncRead(void* buffer, + ULONG bytes_to_read, + ULONG* bytes_read, + HANDLE event_handle, + ULONG time_out); + + /** \brief Writes to opened I/O object asynchronously + + @param[in] buffer Pointer to the buffer containing the data to be written. + @param[in] bytes_to_write Number of bytes to be written. + @param[out] bytes_written Number of bytes written. Can be NULL. + @param[in] event_handle Event handle that should be signaled when async I/O + completes. Can be NULL. If it's not NULL this handle will be used to + initialize OVERLAPPED structure for this I/O. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value in this parameter means that there is no + timeout set for this I/O. + @return A handle to IO completion object or NULL on failure. If NULL is + returned GetLastError() provides extended error information. + */ + virtual SDBAPIHANDLE AsyncWrite(void* buffer, + ULONG bytes_to_write, + ULONG* bytes_written, + HANDLE event_handle, + ULONG time_out); + + /** \brief Reads from opened I/O object synchronously + + @param[out] buffer Pointer to the buffer that receives the data. + @param[in] bytes_to_read Number of bytes to be read. + @param[out] bytes_read Number of bytes read. Can be NULL. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value in this parameter means that there is no + timeout set for this I/O. + @return true on success and false on failure. If false is + returned GetLastError() provides extended error information. + */ + virtual bool SyncRead(void* buffer, + ULONG bytes_to_read, + ULONG* bytes_read, + ULONG time_out); + + /** \brief Writes to opened I/O object synchronously + + @param[in] buffer Pointer to the buffer containing the data to be written. + @param[in] bytes_to_write Number of bytes to be written. + @param[out] bytes_written Number of bytes written. Can be NULL. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value in this parameter means that there is no + timeout set for this I/O. + @return true on success and false on failure. If false is + returned GetLastError() provides extended error information. + */ + virtual bool SyncWrite(void* buffer, + ULONG bytes_to_write, + ULONG* bytes_written, + ULONG time_out); + + public: + /// This is a helper for extracting object from the SdbObjectHandleMap + static SdbObjectType Type() { + return SdbObjectTypeEndpoint; + } + + /// Gets parent interface + SdbInterfaceObject* parent_interface() const { + return parent_interface_; + } + /// Gets this endpoint ID + UCHAR endpoint_id() const { + return endpoint_id_; + } + + /// Gets this endpoint index on the interface + UCHAR endpoint_index() const { + return endpoint_index_; + } + + /// Gets parent interface handle + SDBAPIHANDLE GetParentInterfaceHandle() const { + return (NULL != parent_interface()) ? parent_interface()->sdb_handle() : + NULL; + } + + protected: + /// Parent interface + SdbInterfaceObject* parent_interface_; + + /// This endpoint id + UCHAR endpoint_id_; + + /// This endpoint index on the interface + UCHAR endpoint_index_; +}; + +#endif // ANDROID_USB_API_SDB_ENDPOINT_OBJECT_H__ diff --git a/src/sdbwinapi/sdb_helper_routines.cpp b/src/sdbwinapi/sdb_helper_routines.cpp new file mode 100644 index 0000000..4dbff40 --- /dev/null +++ b/src/sdbwinapi/sdb_helper_routines.cpp @@ -0,0 +1,276 @@ +/* + * Copyright (C) 2009 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. + */ + +/** \file + This file consists of implementation of helper routines used + in the API. +*/ + +#include "stdafx.h" +#include "sdb_api.h" +#include "sdb_api_legacy.h" +#include "sdb_helper_routines.h" +#include "sdb_interface_enum.h" + +bool GetSDKComplientParam(SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode, + ULONG* desired_access, + ULONG* desired_sharing) { + if (NULL != desired_access) { + switch (access_type) { + case SdbOpenAccessTypeReadWrite: + *desired_access = GENERIC_READ | GENERIC_WRITE; + break; + + case SdbOpenAccessTypeRead: + *desired_access = GENERIC_READ; + break; + + case SdbOpenAccessTypeWrite: + *desired_access = GENERIC_WRITE; + break; + + case SdbOpenAccessTypeQueryInfo: + *desired_access = FILE_READ_ATTRIBUTES | FILE_READ_EA; + break; + + default: + SetLastError(ERROR_INVALID_ACCESS); + return false; + } + } + + if (NULL != desired_sharing) { + switch (sharing_mode) { + case SdbOpenSharingModeReadWrite: + *desired_sharing = FILE_SHARE_READ | FILE_SHARE_WRITE; + break; + + case SdbOpenSharingModeRead: + *desired_sharing = FILE_SHARE_READ; + break; + + case SdbOpenSharingModeWrite: + *desired_sharing = FILE_SHARE_WRITE; + break; + + case SdbOpenSharingModeExclusive: + *desired_sharing = 0; + break; + + default: + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + } + + return true; +} + +bool EnumerateDeviceInterfaces(HDEVINFO hardware_dev_info, + GUID class_id, + bool exclude_removed, + bool active_only, + SdbEnumInterfaceArray* interfaces) { + SdbEnumInterfaceArray tmp; + bool ret = false; + + // Enumerate interfaces on this device + for (ULONG index = 0; ; index++) { + SP_DEVICE_INTERFACE_DATA interface_data; + interface_data.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA); + + // SetupDiEnumDeviceInterfaces() returns information about device + // interfaces exposed by one or more devices defined by our interface + // class. Each call returns information about one interface. The routine + // can be called repeatedly to get information about several interfaces + // exposed by one or more devices. + if (SetupDiEnumDeviceInterfaces(hardware_dev_info, + 0, + &class_id, + index, + &interface_data)) { + // Satisfy "exclude removed" and "active only" filters. + if ((!exclude_removed || (0 == (interface_data.Flags & SPINT_REMOVED))) && + (!active_only || (interface_data.Flags & SPINT_ACTIVE))) { + std::wstring dev_name; + + if (GetUsbDeviceName(hardware_dev_info, &interface_data, &dev_name)) { + try { + // Add new entry to the array + tmp.push_back(SdbInstanceEnumEntry(dev_name.c_str(), + interface_data.InterfaceClassGuid, + interface_data.Flags)); + } catch (... ) { + SetLastError(ERROR_OUTOFMEMORY); + break; + } + } else { + // Something went wrong in getting device name + break; + } + } + } else { + if (ERROR_NO_MORE_ITEMS == GetLastError()) { + // There are no more items in the list. Enum is completed. + ret = true; + break; + } else { + // Something went wrong in SDK enum + break; + } + } + } + + // On success, swap temp array with the returning one + if (ret) + interfaces->swap(tmp); + + return ret; +} + +bool EnumerateDeviceInterfaces(GUID class_id, + ULONG flags, + bool exclude_removed, + bool active_only, + SdbEnumInterfaceArray* interfaces) { + // Open a handle to the plug and play dev node. + // SetupDiGetClassDevs() returns a device information set that + // contains info on all installed devices of a specified class. + HDEVINFO hardware_dev_info = + SetupDiGetClassDevs(&class_id, NULL, NULL, flags); + + bool ret = false; + + if (INVALID_HANDLE_VALUE != hardware_dev_info) { + // Do the enum + ret = EnumerateDeviceInterfaces(hardware_dev_info, + class_id, + exclude_removed, + active_only, + interfaces); + + // Preserve last error accross hardware_dev_info destruction + ULONG error_to_report = ret ? NO_ERROR : GetLastError(); + + SetupDiDestroyDeviceInfoList(hardware_dev_info); + + if (NO_ERROR != error_to_report) + SetLastError(error_to_report); + } + + return ret; +} + +bool GetUsbDeviceDetails( + HDEVINFO hardware_dev_info, + PSP_DEVICE_INTERFACE_DATA dev_info_data, + PSP_DEVICE_INTERFACE_DETAIL_DATA* dev_info_detail_data) { + ULONG required_len = 0; + + // First query for the structure size. At this point we expect this call + // to fail with ERROR_INSUFFICIENT_BUFFER error code. + if (SetupDiGetDeviceInterfaceDetail(hardware_dev_info, + dev_info_data, + NULL, + 0, + &required_len, + NULL)) { + return false; + } + + if (ERROR_INSUFFICIENT_BUFFER != GetLastError()) + return false; + + // Allocate buffer for the structure + PSP_DEVICE_INTERFACE_DETAIL_DATA buffer = + reinterpret_cast(malloc(required_len)); + + if (NULL == buffer) { + SetLastError(ERROR_OUTOFMEMORY); + return false; + } + + buffer->cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA); + + // Retrieve the information from Plug and Play. + if (SetupDiGetDeviceInterfaceDetail(hardware_dev_info, + dev_info_data, + buffer, + required_len, + &required_len, + NULL)) { + *dev_info_detail_data = buffer; + return true; + } else { + // Free the buffer if this call failed + free(buffer); + + return false; + } +} + +bool GetUsbDeviceName(HDEVINFO hardware_dev_info, + PSP_DEVICE_INTERFACE_DATA dev_info_data, + std::wstring* name) { + PSP_DEVICE_INTERFACE_DETAIL_DATA func_class_dev_data = NULL; + if (!GetUsbDeviceDetails(hardware_dev_info, + dev_info_data, + &func_class_dev_data)) { + return false; + } + + try { + *name = func_class_dev_data->DevicePath; + } catch (...) { + SetLastError(ERROR_OUTOFMEMORY); + } + + free(func_class_dev_data); + + return !name->empty(); +} + +bool IsLegacyInterface(const wchar_t* interface_name) { + // Open USB device for this intefface + HANDLE usb_device_handle = CreateFile(interface_name, + GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, + OPEN_EXISTING, + 0, + NULL); + if (INVALID_HANDLE_VALUE == usb_device_handle) { + printf("INVALID_HANDLE_VALUE == usb_device_handle\n"); + return NULL; + } + printf("INVALID_HANDLE_VALUE != usb_device_handle\n"); + // Try to issue SDB_IOCTL_GET_USB_DEVICE_DESCRIPTOR IOCTL that is supported + // by the legacy driver, but is not implemented in the WinUsb driver. + DWORD ret_bytes = 0; + USB_DEVICE_DESCRIPTOR descriptor; + BOOL ret = DeviceIoControl(usb_device_handle, + SDB_IOCTL_GET_USB_DEVICE_DESCRIPTOR, + NULL, 0, + &descriptor, + sizeof(descriptor), + &ret_bytes, + NULL); + ::CloseHandle(usb_device_handle); + + // If IOCTL succeeded we've got legacy driver underneath. + return ret ? true : false; +} diff --git a/src/sdbwinapi/sdb_helper_routines.h b/src/sdbwinapi/sdb_helper_routines.h new file mode 100644 index 0000000..37580d3 --- /dev/null +++ b/src/sdbwinapi/sdb_helper_routines.h @@ -0,0 +1,137 @@ +/* + * Copyright (C) 2009 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 ANDROID_USB_API_SDB_HELPER_ROUTINES_H__ +#define ANDROID_USB_API_SDB_HELPER_ROUTINES_H__ +/** \file + This file consists of declarations of helper routines used + in the API. +*/ + +#include "sdb_api_private_defines.h" + +/** \brief Converts access type and share mode from our enum into + SDK - complient values. + + @param[in] access_type Enumerated access type + @param[in] sharing_mode Enumerated share mode + @param[out] desired_access Will receive SDK - complient desired access + flags. This parameter can be NULL. + @param[out] desired_sharing Will receive SDK - complient share mode. + This parameter can be NULL. + @return True on success, false on failure, in which case GetLastError() + provides extended information about the error that occurred. +*/ +bool GetSDKComplientParam(SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode, + ULONG* desired_access, + ULONG* desired_sharing); + +/** \brief Given the hardware device information enumerates interfaces for + this device. + + @param[in] hardware_dev_info A handle to hardware device information obtained + from PnP manager via SetupDiGetClassDevs() + @param[in] class_id Device class ID how it is specified by our USB driver. + @param[in] exclude_removed If true interfaces with SPINT_REMOVED flag set + will be not included in the enumeration. + @param[in] active_only If true only active interfaces (with flag + SPINT_ACTIVE set) will be included in the enumeration. + @param[out] interfaces Upon successfull completion will consist of array of + all interfaces found for this device (matching all filters). + @return True on success, false on failure, in which case GetLastError() + provides extended information about the error that occurred. +*/ +bool EnumerateDeviceInterfaces(HDEVINFO hardware_dev_info, + GUID class_id, + bool exclude_removed, + bool active_only, + SdbEnumInterfaceArray* interfaces); + +/** \brief Enumerates all interfaces for our device class. + + This routine uses SetupDiGetClassDevs to get our device info and calls + EnumerateDeviceInterfaces to perform the enumeration. + @param[in] class_id Device class ID how it is specified by our USB driver + @param[in] flags Flags to pass to SetupDiGetClassDevs to filter devices. See + SetupDiGetClassDevs() in SDK for more info on these flags. + @param[in] exclude_removed If true interfaces with SPINT_REMOVED flag set + will be not included in the enumeration. + @param[in] active_only If true only active interfaces (with flag + SPINT_ACTIVE set) will be included in the enumeration. + @param[out] interfaces Upon successfull completion will consist of array of + all interfaces found for this device (matching all filters). + @return True on success, false on failure, in which case GetLastError() + provides extended information about the error that occurred. +*/ +bool EnumerateDeviceInterfaces(GUID class_id, + ULONG flags, + bool exclude_removed, + bool active_only, + SdbEnumInterfaceArray* interfaces); + +/** \brief Given the hardware device information and data gets data details. + + Given the hardware_dev_info, representing a handle to the plug and + play information, and dev_info_data, representing a specific usb device, + gets detailed data about the device (interface). + @param[in] hardware_dev_info A handle to hardware device information obtained + from PnP manager via SetupDiGetClassDevs() + @param[in] dev_info_data Device information data obtained via call to + SetupDiEnumDeviceInterfaces() + @param[out] dev_info_detail_data Upon successfull completion will consist of + the detailed data about device interface. This routine always + allocates memory for the output structure so content of this pointer + doesn't matter and will be overwritten by this routine. The caller + of this method is responsible for freeing allocated data using free() + routine. + @return True on success, false on failure, in which case GetLastError() + provides extended information about the error that occurred. +*/ +bool GetUsbDeviceDetails(HDEVINFO hardware_dev_info, + PSP_DEVICE_INTERFACE_DATA dev_info_data, + PSP_DEVICE_INTERFACE_DETAIL_DATA* dev_info_detail_data); + +/** \brief Given the hardware device information and data gets device name. + + Given the hardware_dev_info, representing a handle to the plug and + play information, and dev_info_data, representing a specific usb device, + gets device name. This routine uses GetUsbDeviceDetails to extract device + name. + @param[in] hardware_dev_info A handle to hardware device information obtained + from PnP manager via SetupDiGetClassDevs() + @param[in] dev_info_data Device information data obtained via call to + SetupDiEnumDeviceInterfaces() + @param[out] name Upon successfull completion will have name for the device. + @return True on success, false on failure, in which case GetLastError() + provides extended information about the error that occurred. +*/ +bool GetUsbDeviceName(HDEVINFO hardware_dev_info, + PSP_DEVICE_INTERFACE_DATA dev_info_data, + std::wstring* name); + +/** \brief Checks if given interface is available via custom USB driver. + + In this routine we will query the given interface with an IOCTL that should + be supported by the custom driver. If IOCTL fails, we make a conclusion that + this interface is available via WinUsb, and not via custom USB driver. + @param[in] interface_name Name of the interface to check. + @return true if interface is available via custom USB driver, or false + otherwise. +*/ +bool IsLegacyInterface(const wchar_t* interface_name); + +#endif // ANDROID_USB_API_SDB_HELPER_ROUTINES_H__ diff --git a/src/sdbwinapi/sdb_interface.cpp b/src/sdbwinapi/sdb_interface.cpp new file mode 100644 index 0000000..08baa3c --- /dev/null +++ b/src/sdbwinapi/sdb_interface.cpp @@ -0,0 +1,117 @@ +/* + * 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. + */ + +/** \file + This file consists of implementation of class SdbInterfaceObject that + encapsulates a generic interface on our USB device. +*/ + +#include "stdafx.h" +#include "sdb_interface.h" + +SdbInterfaceObject::SdbInterfaceObject(const wchar_t* interf_name) + : SdbObjectHandle(SdbObjectTypeInterface), + interface_name_(interf_name) { + ATLASSERT(NULL != interf_name); +} + +SdbInterfaceObject::~SdbInterfaceObject() { +} + +bool SdbInterfaceObject::GetInterfaceName(void* buffer, + unsigned long* buffer_char_size, + bool ansi) { + if (NULL == buffer_char_size) { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + // Lets see if buffer is big enough + ULONG name_len = static_cast(interface_name_.length() + 1); + if ((NULL == buffer) || (*buffer_char_size < name_len)) { + *buffer_char_size = name_len; + SetLastError(ERROR_INSUFFICIENT_BUFFER); + return false; + } + + if (!ansi) { + // If user asked for wide char name just return it + wcscpy(reinterpret_cast(buffer), interface_name().c_str()); + return true; + } + + // We need to convert name from wide char to ansi string + int res = WideCharToMultiByte(CP_ACP, + 0, + interface_name().c_str(), + static_cast(name_len), + reinterpret_cast(buffer), + static_cast(*buffer_char_size), + NULL, + NULL); + return (res != 0); +} + +bool SdbInterfaceObject::GetUsbDeviceDescriptor(USB_DEVICE_DESCRIPTOR* desc) { + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + if (NULL == desc) { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + CopyMemory(desc, usb_device_descriptor(), sizeof(USB_DEVICE_DESCRIPTOR)); + + return true; +} + +bool SdbInterfaceObject::GetUsbConfigurationDescriptor( + USB_CONFIGURATION_DESCRIPTOR* desc) { + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + if (NULL == desc) { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + CopyMemory(desc, usb_config_descriptor(), + sizeof(USB_CONFIGURATION_DESCRIPTOR)); + + return true; +} + +bool SdbInterfaceObject::GetUsbInterfaceDescriptor( + USB_INTERFACE_DESCRIPTOR* desc) { + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + if (NULL == desc) { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + CopyMemory(desc, usb_interface_descriptor(), sizeof(USB_INTERFACE_DESCRIPTOR)); + + return true; +} diff --git a/src/sdbwinapi/sdb_interface.h b/src/sdbwinapi/sdb_interface.h new file mode 100644 index 0000000..2937d4a --- /dev/null +++ b/src/sdbwinapi/sdb_interface.h @@ -0,0 +1,203 @@ +/* + * 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 ANDROID_USB_API_SDB_INTERFACE_H__ +#define ANDROID_USB_API_SDB_INTERFACE_H__ +/** \file + This file consists of declaration of class SdbInterfaceObject that + encapsulates a generic interface on our USB device. +*/ + +#include "sdb_object_handle.h" + +// 'SdbInterfaceObject::interface_name_' : class 'std::basic_string<_E,_Tr,_A>' +// needs to have dll-interface to be used by clients of class +// 'SdbInterfaceObject' We're ok with that, since interface_name_ will not +// be referenced by name from outside of this class. +#pragma warning(disable: 4251) +/** \brief Encapsulates an interface on our USB device. + + This is an abstract class that implements functionality common for both, + legacy, and WinUsb based interfaces. +*/ +class SDBWIN_API_CLASS SdbInterfaceObject : public SdbObjectHandle { + public: + /** \brief Constructs the object. + + @param[in] interf_name Name of the interface + */ + explicit SdbInterfaceObject(const wchar_t* interf_name); + + protected: + /** \brief Destructs the object. + + We hide destructor in order to prevent ourseves from accidentaly allocating + instances on the stack. If such attemp occur, compiler will error. + */ + virtual ~SdbInterfaceObject(); + + // + // Abstract + // + + public: + /** \brief Gets serial number for interface's device. + + @param[out] buffer Buffer for the serail number string. Can be NULL in + which case buffer_char_size will contain number of characters + required for the string. + @param[in,out] buffer_char_size On the way in supplies size (in characters) + of the buffer. On the way out, if method failed and GetLastError + reports ERROR_INSUFFICIENT_BUFFER, will contain number of characters + required for the name. + @param[in] ansi If true the name will be returned as single character + string. Otherwise name will be returned as wide character string. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool GetSerialNumber(void* buffer, + unsigned long* buffer_char_size, + bool ansi) = 0; + + + /** \brief Gets information about an endpoint on this interface. + + @param[in] endpoint_index Zero-based endpoint index. There are two + shortcuts for this parameter: SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX + and SDB_QUERY_BULK_READ_ENDPOINT_INDEX that provide infor about + (default?) bulk write and read endpoints respectively. + @param[out] info Upon successful completion will have endpoint information. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool GetEndpointInformation(UCHAR endpoint_index, + SdbEndpointInformation* info) = 0; + + /** \brief Opens an endpoint on this interface. + + @param[in] endpoint_index Zero-based endpoint index. There are two + shortcuts for this parameter: SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX + and SDB_QUERY_BULK_READ_ENDPOINT_INDEX that provide infor about + (default?) bulk write and read endpoints respectively. + @param[in] access_type Desired access type. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always read / write access. + @param[in] sharing_mode Desired share mode. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always shared for read / write. + @return Handle to the opened endpoint object or NULL on failure. + If NULL is returned GetLastError() provides extended information + about the error that occurred. + */ + virtual SDBAPIHANDLE OpenEndpoint(UCHAR endpoint_index, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode) = 0; + + // + // Operations + // + + public: + /** \brief Gets interface device name. + + @param[out] buffer Buffer for the name. Can be NULL in which case + buffer_char_size will contain number of characters required to fit + the name. + @param[in,out] buffer_char_size On the way in supplies size (in characters) + of the buffer. On the way out if method failed and GetLastError + reports ERROR_INSUFFICIENT_BUFFER will contain number of characters + required to fit the name. + @param[in] ansi If true the name will be returned as single character + string. Otherwise name will be returned as wide character string. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool GetInterfaceName(void* buffer, + unsigned long* buffer_char_size, + bool ansi); + + /** \brief Gets device descriptor for the USB device associated with + this interface. + + @param[out] desc Upon successful completion will have usb device + descriptor. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool GetUsbDeviceDescriptor(USB_DEVICE_DESCRIPTOR* desc); + + /** \brief Gets descriptor for the selected USB device configuration. + + @param[out] desc Upon successful completion will have usb device + configuration descriptor. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool GetUsbConfigurationDescriptor( + USB_CONFIGURATION_DESCRIPTOR* desc); + + /** \brief Gets descriptor for this interface. + + @param[out] desc Upon successful completion will have interface + descriptor. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool GetUsbInterfaceDescriptor(USB_INTERFACE_DESCRIPTOR* desc); + + public: + /// Gets name of the USB interface (device name) for this object + const std::wstring& interface_name() const { + return interface_name_; + } + + /// This is a helper for extracting object from the SdbObjectHandleMap + static SdbObjectType Type() { + return SdbObjectTypeInterface; + } + + /// Gets cached usb device descriptor + const USB_DEVICE_DESCRIPTOR* usb_device_descriptor() const { + return &usb_device_descriptor_; + } + + /// Gets cached usb configuration descriptor + const USB_CONFIGURATION_DESCRIPTOR* usb_config_descriptor() const { + return &usb_config_descriptor_; + } + + /// Gets cached usb interface descriptor + const USB_INTERFACE_DESCRIPTOR* usb_interface_descriptor() const { + return &usb_interface_descriptor_; + } + + protected: + /// Cached usb device descriptor + USB_DEVICE_DESCRIPTOR usb_device_descriptor_; + + /// Cached usb configuration descriptor + USB_CONFIGURATION_DESCRIPTOR usb_config_descriptor_; + + /// Cached usb interface descriptor + USB_INTERFACE_DESCRIPTOR usb_interface_descriptor_; + + private: + /// Name of the USB interface (device name) for this object + std::wstring interface_name_; +}; +#pragma warning(default: 4251) + +#endif // ANDROID_USB_API_SDB_INTERFACE_H__ diff --git a/src/sdbwinapi/sdb_interface_enum.cpp b/src/sdbwinapi/sdb_interface_enum.cpp new file mode 100644 index 0000000..693ae20 --- /dev/null +++ b/src/sdbwinapi/sdb_interface_enum.cpp @@ -0,0 +1,103 @@ +/* + * 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. + */ + +/** \file + This file consists of implementation of SdbInterfaceEnumObject class that + encapsulates enumerator of USB interfaces available through this API. +*/ + +#include "stdafx.h" +#include "sdb_api.h" +#include "sdb_interface_enum.h" +#include "sdb_helper_routines.h" + +SdbInterfaceEnumObject::SdbInterfaceEnumObject() + : SdbObjectHandle(SdbObjectTypeInterfaceEnumerator) { + current_interface_ = interfaces_.begin(); +} + +SdbInterfaceEnumObject::~SdbInterfaceEnumObject() { +} + +bool SdbInterfaceEnumObject::InitializeEnum(GUID class_id, + bool exclude_not_present, + bool exclude_removed, + bool active_only) { + // Calc flags for SetupDiGetClassDevs + DWORD flags = DIGCF_DEVICEINTERFACE; + if (exclude_not_present) + flags |= DIGCF_PRESENT; + + // Do the enum + bool ret = EnumerateDeviceInterfaces(class_id, + flags, + exclude_removed, + active_only, + &interfaces_); + + // If enum was successfull set current enum pointer + // to the beginning of the array + if (ret) + current_interface_ = interfaces_.begin(); + + return ret; +} + +bool SdbInterfaceEnumObject::Next(SdbInterfaceInfo* info, ULONG* size) { + // Make sure that it's opened + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + ATLASSERT(NULL != size); + if (NULL == size) { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + // Lets see if enum is over + if (interfaces_.end() == current_interface_) { + SetLastError(ERROR_NO_MORE_ITEMS); + return false; + } + + SdbInstanceEnumEntry& entry = *current_interface_; + + // Big enough? + if ((NULL == info) || (*size < entry.GetFlatSize())) { + *size = entry.GetFlatSize(); + SetLastError(ERROR_INSUFFICIENT_BUFFER); + return false; + } + + // All checks passed + entry.Save(info); + current_interface_++; + return true; +} + +bool SdbInterfaceEnumObject::Reset() { + // Make sure that it's opened + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + current_interface_ = interfaces_.begin(); + + return true; +} diff --git a/src/sdbwinapi/sdb_interface_enum.h b/src/sdbwinapi/sdb_interface_enum.h new file mode 100644 index 0000000..4d2d634 --- /dev/null +++ b/src/sdbwinapi/sdb_interface_enum.h @@ -0,0 +1,98 @@ +/* + * 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 ANDROID_USB_API_SDB_INTERFACE_ENUM_H__ +#define ANDROID_USB_API_SDB_INTERFACE_ENUM_H__ +/** \file + This file consists of declaration of SdbInterfaceEnumObject class that + encapsulates enumerator of USB interfaces available through this API. +*/ + +#include "sdb_object_handle.h" + +/** \brief Enumerator of USB interfaces available through this API. +*/ +class SdbInterfaceEnumObject : public SdbObjectHandle { + public: + /** \brief Constructs the object. + */ + SdbInterfaceEnumObject(); + + protected: + /** \brief Destructs the object. + + We hide destructor in order to prevent ourseves from accidentaly allocating + instances on the stack. If such attemp occur, compiler will error. + */ + virtual ~SdbInterfaceEnumObject(); + + public: + /** \brief Enumerates all interfaces for the given device class. + + This routine uses SetupDiGetClassDevs to get our device info and calls + EnumerateDeviceInterfaces to perform the enumeration. + @param[in] class_id Device class ID that is specified by our USB driver + @param[in] exclude_not_present If set include only those devices that are + currently present. + @param[in] exclude_removed If true interfaces with SPINT_REMOVED flag set + will be not included in the enumeration. + @param[in] active_only If true only active interfaces (with flag + SPINT_ACTIVE set) will be included in the enumeration. + @return True on success, false on failure, in which case GetLastError() + provides extended information about the error that occurred. + */ + bool InitializeEnum(GUID class_id, + bool exclude_not_present, + bool exclude_removed, + bool active_only); + + /** \brief Gets next enumerated interface information + @param[out] info Upon successful completion will receive interface + information. Can be NULL. If it is NULL, upon return from this + method *size will have memory size required to fit this entry. + @param[in,out] size On the way in provides size of the memory buffer + addressed by info param. On the way out (only if buffer is not + big enough) will provide memory size required to fit this entry. + @return true on success, false on error. If false is returned + GetLastError() provides extended information about the error that + occurred. ERROR_INSUFFICIENT_BUFFER indicates that buffer provided + in info param was not big enough and *size specifies memory size + required to fit this entry. ERROR_NO_MORE_ITEMS indicates that + enumeration is over and there are no more entries to return. + */ + bool Next(SdbInterfaceInfo* info, ULONG* size); + + /** \brief Makes enumerator to start from the beginning. + @return true on success, false on error. If false is returned + GetLastError() provides extended information about the error that + occurred. + */ + bool Reset(); + + // This is a helper for extracting object from the SdbObjectHandleMap + static SdbObjectType Type() { + return SdbObjectTypeInterfaceEnumerator; + } + + protected: + /// Array of interfaces enumerated with this object + SdbEnumInterfaceArray interfaces_; + + /// Current enumerator + SdbEnumInterfaceArray::iterator current_interface_; +}; + +#endif // ANDROID_USB_API_SDB_INTERFACE_ENUM_H__ diff --git a/src/sdbwinapi/sdb_io_completion.cpp b/src/sdbwinapi/sdb_io_completion.cpp new file mode 100644 index 0000000..b8b62d4 --- /dev/null +++ b/src/sdbwinapi/sdb_io_completion.cpp @@ -0,0 +1,50 @@ +/* + * Copyright (C) 2009 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. + */ + +/** \file + This file consists of implementation of class SdbIOCompletion that + encapsulates a generic wrapper around OVERLAPPED Win32 structure + returned from asynchronous I/O requests. +*/ + +#include "stdafx.h" +#include "sdb_io_completion.h" + +SdbIOCompletion::SdbIOCompletion(SdbEndpointObject* parent_io_obj, + ULONG expected_trans_size, + HANDLE event_hndl) + : SdbObjectHandle(SdbObjectTypeIoCompletion), + expected_transfer_size_(expected_trans_size), + parent_io_object_(parent_io_obj) { + ATLASSERT(NULL != parent_io_obj); + parent_io_obj->AddRef(); + ZeroMemory(&overlapped_, sizeof(overlapped_)); + overlapped_.hEvent = event_hndl; +} + +SdbIOCompletion::~SdbIOCompletion() { + parent_io_object_->Release(); +} + +bool SdbIOCompletion::IsCompleted() { + SetLastError(NO_ERROR); + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return true; + } + + return HasOverlappedIoCompleted(overlapped()) ? true : false; +} diff --git a/src/sdbwinapi/sdb_io_completion.h b/src/sdbwinapi/sdb_io_completion.h new file mode 100644 index 0000000..954789a --- /dev/null +++ b/src/sdbwinapi/sdb_io_completion.h @@ -0,0 +1,133 @@ +/* + * Copyright (C) 2009 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 ANDROID_USB_API_SDB_IO_COMPLETION_H__ +#define ANDROID_USB_API_SDB_IO_COMPLETION_H__ +/** \file + This file consists of declaration of class SdbIOCompletion that encapsulates + a generic wrapper around OVERLAPPED Win32 structure returned from + asynchronous I/O requests. +*/ + +#include "sdb_endpoint_object.h" + +/** \brief Encapsulates encapsulates a generic wrapper around OVERLAPPED Win32 + structure returned from asynchronous I/O requests. + + This is an abstract class that implements functionality common for I/O + performed via WinUsb as well as legacy driver APIs. A handle to this object + is returned to the caller of each successful asynchronous I/O request. Just + like all other handles this handle must be closed after it's no longer + needed. +*/ +class SDBWIN_API_CLASS SdbIOCompletion : public SdbObjectHandle { + public: + /** \brief Constructs the object + + @param[in] parent_io_obj Parent I/O object that created this instance. + Parent object will be referenced in this object's constructor and + released in the destructor. + @param[in] expected_trans_size Number of bytes expected to be transferred + with the I/O. + @param[in] event_hndl Event handle that should be signaled when I/O + completes. Can be NULL. If it's not NULL this handle will be + used to initialize OVERLAPPED structure for this object. + */ + SdbIOCompletion(SdbEndpointObject* parent_io_obj, + ULONG expected_trans_size, + HANDLE event_hndl); + + protected: + /** \brief Destructs the object. + + We hide destructor in order to prevent ourseves from accidentaly allocating + instances on the stack. If such attemp occur, compiler will error. + */ + virtual ~SdbIOCompletion(); + + // + // Abstract + // + + public: + /** \brief Gets overlapped I/O result + + @param[out] ovl_data Buffer for the copy of this object's OVERLAPPED + structure. Can be NULL. + @param[out] bytes_transferred Pointer to a variable that receives the + number of bytes that were actually transferred by a read or write + operation. See SDK doc on GetOvelappedResult for more information. + Unlike regular GetOvelappedResult call this parameter can be NULL. + @param[in] wait If this parameter is true, the method does not return + until the operation has been completed. If this parameter is false + and the operation is still pending, the method returns false and + the GetLastError function returns ERROR_IO_INCOMPLETE. + @return true if I/O has been completed or false on failure or if request + is not yet completed. If false is returned GetLastError() provides + extended error information. If GetLastError returns + ERROR_IO_INCOMPLETE it means that I/O is not yet completed. + */ + virtual bool GetOvelappedIoResult(LPOVERLAPPED ovl_data, + ULONG* bytes_transferred, + bool wait) = 0; + + // + // Operations + // + + public: + /** \brief Checks if I/O that this object represents has completed. + + @return true if I/O has been completed or false if it's still + incomplete. Regardless of the returned value, caller should + check GetLastError to validate that handle was OK. + */ + virtual bool IsCompleted(); + + public: + /// Gets overlapped structure for this I/O + LPOVERLAPPED overlapped() { + return &overlapped_; + } + + /// Gets parent object + SdbEndpointObject* parent_io_object() const { + return parent_io_object_; + } + + /// Gets parent object handle + SDBAPIHANDLE GetParentObjectHandle() const { + return (NULL != parent_io_object()) ? parent_io_object()->sdb_handle() : + NULL; + } + + // This is a helper for extracting object from the SdbObjectHandleMap + static SdbObjectType Type() { + return SdbObjectTypeIoCompletion; + } + + protected: + /// Overlapped structure for this I/O + OVERLAPPED overlapped_; + + /// Parent I/O object + SdbEndpointObject* parent_io_object_; + + /// Expected number of bytes transferred in thi I/O + ULONG expected_transfer_size_; +}; + +#endif // ANDROID_USB_API_SDB_IO_COMPLETION_H__ diff --git a/src/sdbwinapi/sdb_legacy_endpoint_object.cpp b/src/sdbwinapi/sdb_legacy_endpoint_object.cpp new file mode 100644 index 0000000..8f7d16a --- /dev/null +++ b/src/sdbwinapi/sdb_legacy_endpoint_object.cpp @@ -0,0 +1,237 @@ +/* + * Copyright (C) 2009 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. + */ + +/** \file + This file consists of implementation of class SdbLegacyEndpointObject that + encapsulates a handle opened to an endpoint on our device controlled by + a custom (legacy) USB driver. +*/ + +#include "stdafx.h" +#include "sdb_api_legacy.h" +#include "sdb_legacy_endpoint_object.h" +#include "sdb_legacy_io_completion.h" +#include "sdb_helper_routines.h" + +SdbLegacyEndpointObject::SdbLegacyEndpointObject( + SdbLegacyInterfaceObject* parent_interf, + UCHAR endpoint_id, + UCHAR endpoint_index) + : SdbEndpointObject(parent_interf, endpoint_id, endpoint_index), + usb_handle_(INVALID_HANDLE_VALUE) { +} + +SdbLegacyEndpointObject::~SdbLegacyEndpointObject() { + if (INVALID_HANDLE_VALUE != usb_handle_) { + ::CloseHandle(usb_handle_); + } +} + +SDBAPIHANDLE SdbLegacyEndpointObject::CommonAsyncReadWrite( + bool is_read, + void* buffer, + ULONG bytes_to_transfer, + ULONG* bytes_transferred, + HANDLE event_handle, + ULONG time_out) { + if (NULL != bytes_transferred) { + *bytes_transferred = 0; + } + + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + bool is_ioctl_write = is_read ? false : (0 != time_out); + + // Create completion i/o object + SdbLegacyIOCompletion* sdb_io_completion = NULL; + + try { + sdb_io_completion = new SdbLegacyIOCompletion(this, + bytes_to_transfer, + event_handle, + is_ioctl_write); + } catch (... ) { + // We don't expect exceptions other than OOM thrown here. + SetLastError(ERROR_OUTOFMEMORY); + return NULL; + } + + // Create a handle for it + SDBAPIHANDLE ret = sdb_io_completion->CreateHandle(); + ULONG transferred = 0; + if (NULL != ret) { + BOOL res = TRUE; + if (0 == time_out) { + // Go the read / write file way + res = is_read ? ReadFile(usb_handle(), + buffer, + bytes_to_transfer, + &transferred, + sdb_io_completion->overlapped()) : + WriteFile(usb_handle(), + buffer, + bytes_to_transfer, + &transferred, + sdb_io_completion->overlapped()); + } else { + // Go IOCTL way + SdbBulkTransfer transfer_param; + transfer_param.time_out = time_out; + transfer_param.transfer_size = is_read ? 0 : bytes_to_transfer; + transfer_param.SetWriteBuffer(is_read ? NULL : buffer); + + res = DeviceIoControl(usb_handle(), + is_read ? SDB_IOCTL_BULK_READ : SDB_IOCTL_BULK_WRITE, + &transfer_param, sizeof(transfer_param), + is_read ? buffer : sdb_io_completion->transferred_bytes_ptr(), + is_read ? bytes_to_transfer : sizeof(ULONG), + &transferred, + sdb_io_completion->overlapped()); + } + + if (NULL != bytes_transferred) { + *bytes_transferred = transferred; + } + + ULONG error = GetLastError(); + if (!res && (ERROR_IO_PENDING != error)) { + // I/O failed immediatelly. We need to close i/o completion object + // before we return NULL to the caller. + sdb_io_completion->CloseHandle(); + ret = NULL; + SetLastError(error); + } + } + + // Offseting 'new' + sdb_io_completion->Release(); + + return ret; +} + +bool SdbLegacyEndpointObject::CommonSyncReadWrite(bool is_read, + void* buffer, + ULONG bytes_to_transfer, + ULONG* bytes_transferred, + ULONG time_out) { + if (NULL != bytes_transferred) { + *bytes_transferred = 0; + } + + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + bool is_ioctl_write = is_read ? false : (0 != time_out); + + // This is synchronous I/O. Since we always open I/O items for + // overlapped I/O we're obligated to always provide OVERLAPPED + // structure to read / write routines. Prepare it now. + OVERLAPPED overlapped; + ZeroMemory(&overlapped, sizeof(overlapped)); + + BOOL ret = TRUE; + ULONG ioctl_write_transferred = 0; + if (0 == time_out) { + // Go the read / write file way + ret = is_read ? + ReadFile(usb_handle(), buffer, bytes_to_transfer, bytes_transferred, &overlapped) : + WriteFile(usb_handle(), buffer, bytes_to_transfer, bytes_transferred, &overlapped); + } else { + // Go IOCTL way + SdbBulkTransfer transfer_param; + transfer_param.time_out = time_out; + transfer_param.transfer_size = is_read ? 0 : bytes_to_transfer; + transfer_param.SetWriteBuffer(is_read ? NULL : buffer); + + ULONG tmp; + ret = DeviceIoControl(usb_handle(), + is_read ? SDB_IOCTL_BULK_READ : SDB_IOCTL_BULK_WRITE, + &transfer_param, sizeof(transfer_param), + is_read ? buffer : &ioctl_write_transferred, + is_read ? bytes_to_transfer : sizeof(ULONG), + &tmp, + &overlapped); + } + + // Lets see the result + if (!ret && (ERROR_IO_PENDING != GetLastError())) { + // I/O failed. + return false; + } + + // Lets wait till I/O completes + ULONG transferred = 0; + ret = GetOverlappedResult(usb_handle(), &overlapped, &transferred, TRUE); + if (ret && (NULL != bytes_transferred)) { + *bytes_transferred = is_ioctl_write ? ioctl_write_transferred : + transferred; + } + + return ret ? true : false; +} + +SDBAPIHANDLE SdbLegacyEndpointObject::CreateHandle( + const wchar_t* item_path, + SdbOpenAccessType access_type, + SdbOpenSharingMode share_mode) { + // Convert access / share parameters into CreateFile - compatible + ULONG desired_access; + ULONG desired_sharing; + + if (!GetSDKComplientParam(access_type, share_mode, + &desired_access, &desired_sharing)) { + return NULL; + } + + // Open USB handle + usb_handle_ = CreateFile(item_path, + desired_access, + share_mode, + NULL, + OPEN_EXISTING, + FILE_FLAG_OVERLAPPED, // Always overlapped! + NULL); + if (INVALID_HANDLE_VALUE == usb_handle_) { + return NULL; + } + + // Create SDB handle + SDBAPIHANDLE ret = SdbObjectHandle::CreateHandle(); + + if (NULL == ret) { + // If creation of SDB handle failed we have to close USB handle too. + ULONG error = GetLastError(); + ::CloseHandle(usb_handle()); + usb_handle_ = INVALID_HANDLE_VALUE; + SetLastError(error); + } + + return ret; +} + +bool SdbLegacyEndpointObject::CloseHandle() { + if (INVALID_HANDLE_VALUE != usb_handle_) { + ::CloseHandle(usb_handle_); + usb_handle_ = INVALID_HANDLE_VALUE; + } + + return SdbEndpointObject::CloseHandle(); +} diff --git a/src/sdbwinapi/sdb_legacy_endpoint_object.h b/src/sdbwinapi/sdb_legacy_endpoint_object.h new file mode 100644 index 0000000..5ae8290 --- /dev/null +++ b/src/sdbwinapi/sdb_legacy_endpoint_object.h @@ -0,0 +1,142 @@ +/* + * Copyright (C) 2009 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 ANDROID_USB_API_SDB_LEGACY_ENDPOINT_OBJECT_H__ +#define ANDROID_USB_API_SDB_LEGACY_ENDPOINT_OBJECT_H__ +/** \file + This file consists of declaration of class SdbLegacyEndpointObject that + encapsulates a handle opened to an endpoint on our device controlled by + a custom (legacy) USB driver. +*/ + +#include "sdb_endpoint_object.h" +#include "sdb_legacy_interface.h" + +/** Encapsulates a handle opened to an endpoint on our device controlled by + a custom (legacy) USB driver. +*/ +class SdbLegacyEndpointObject : public SdbEndpointObject { + public: + /** \brief Constructs the object + + @param[in] interface Parent legacy USB interface for this object. + @param[in] endpoint_id Endpoint ID (endpoint address) on the device. + @param[in] endpoint_index Zero-based endpoint index in the interface's + array of endpoints. + */ + SdbLegacyEndpointObject(SdbLegacyInterfaceObject* parent_interf, + UCHAR endpoint_id, + UCHAR endpoint_index); + + protected: + /** \brief Destructs the object. + + We hide destructor in order to prevent ourseves from accidentaly allocating + instances on the stack. If such attemp occur, compiler will error. + */ + virtual ~SdbLegacyEndpointObject(); + + // + // Abstract overrides + // + + protected: + /** \brief Common code for async read / write + + @param[in] is_read Read or write selector. + @param[in,out] buffer Pointer to the buffer for read / write. + @param[in] bytes_to_transfer Number of bytes to be read / written. + @param[out] bytes_transferred Number of bytes read / written. Can be NULL. + @param[in] event_handle Event handle that should be signaled when async I/O + completes. Can be NULL. If it's not NULL this handle will be used to + initialize OVERLAPPED structure for this I/O. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value in this parameter means that there is no + timeout set for this I/O. + @return A handle to IO completion object or NULL on failure. If NULL is + returned GetLastError() provides extended error information. + */ + virtual SDBAPIHANDLE CommonAsyncReadWrite(bool is_read, + void* buffer, + ULONG bytes_to_transfer, + ULONG* bytes_transferred, + HANDLE event_handle, + ULONG time_out); + + /** \brief Common code for sync read / write + + @param[in] is_read Read or write selector. + @param[in,out] buffer Pointer to the buffer for read / write. + @param[in] bytes_to_transfer Number of bytes to be read / written. + @param[out] bytes_transferred Number of bytes read / written. Can be NULL. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value in this parameter means that there is no + timeout set for this I/O. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool CommonSyncReadWrite(bool is_read, + void* buffer, + ULONG bytes_to_transfer, + ULONG* bytes_transferred, + ULONG time_out); + + // + // Operations + // + + public: + /** \brief Opens endpoint and creates a handle to this object + + @param item_path[in] Path to the endpoint on our USB device. + @param access_type[in] Desired access type. In the current implementation + this parameter has no effect on the way item is opened. It's + always read / write access. + @param sharing_mode[in] Desired share mode. In the current implementation + this parameter has no effect on the way item is opened. It's + always shared for read / write. + @return A handle to this object on success or NULL on an error. + If NULL is returned GetLastError() provides extended error + information. ERROR_GEN_FAILURE is set if an attempt was + made to create already opened object. + */ + virtual SDBAPIHANDLE CreateHandle(const wchar_t* item_path, + SdbOpenAccessType access_type, + SdbOpenSharingMode share_mode); + + + /** \brief This method is called when handle to this object gets closed. + + We override this method in order to close handle to the endpoint opened + in CreateHandle method of this class. + @return true on success or false if object is already closed. If + false is returned GetLastError() provides extended error + information. + */ + virtual bool CloseHandle(); + + public: + /// Gets handle to the endpoint opened on our USB device. + HANDLE usb_handle() const { + return usb_handle_; + } + + protected: + /// Handle to the endpoint opened on our USB device. + HANDLE usb_handle_; +}; + +#endif // ANDROID_USB_API_SDB_LEGACY_ENDPOINT_OBJECT_H__ diff --git a/src/sdbwinapi/sdb_legacy_interface.cpp b/src/sdbwinapi/sdb_legacy_interface.cpp new file mode 100644 index 0000000..3011bf7 --- /dev/null +++ b/src/sdbwinapi/sdb_legacy_interface.cpp @@ -0,0 +1,324 @@ +/* + * Copyright (C) 2009 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. + */ + +/** \file + This file consists of implementation of class SdbLegacyInterfaceObject + that encapsulates an interface on our USB device that is accessible +*/ + +#include "stdafx.h" +#include "sdb_api_legacy.h" +#include "sdb_legacy_interface.h" +#include "sdb_legacy_endpoint_object.h" + +SdbLegacyInterfaceObject::SdbLegacyInterfaceObject(const wchar_t* interf_name) + : SdbInterfaceObject(interf_name), + def_read_endpoint_(0xFF), + read_endpoint_id_(0xFF), + def_write_endpoint_(0xFF), + write_endpoint_id_(0xFF) { +} + +SdbLegacyInterfaceObject::~SdbLegacyInterfaceObject() { +} + +SDBAPIHANDLE SdbLegacyInterfaceObject::CreateHandle() { + // Open USB device for this intefface + HANDLE usb_device_handle = CreateFile(interface_name().c_str(), + GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, + OPEN_EXISTING, + 0, + NULL); + if (INVALID_HANDLE_VALUE == usb_device_handle) { + return NULL; + } + + // Now, we ensured that our usb device / interface is up and running. + // Lets collect device, interface and pipe information + bool ok = true; + if (!CacheUsbDeviceDescriptor(usb_device_handle) || + !CacheUsbConfigurationDescriptor(usb_device_handle) || + !CacheUsbInterfaceDescriptor(usb_device_handle)) { + ok = false; + } + + // Preserve error accross handle close + ULONG error = ok ? NO_ERROR : GetLastError(); + + ::CloseHandle(usb_device_handle); + + if (NO_ERROR != error) { + SetLastError(error); + } + + if (!ok) { + return false; + } + + // Save indexes and IDs for bulk read / write endpoints. We will use them to + // convert SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX and + // SDB_QUERY_BULK_READ_ENDPOINT_INDEX into actual endpoint indexes and IDs. + for (UCHAR endpoint = 0; endpoint < usb_interface_descriptor_.bNumEndpoints; + endpoint++) { + // Get endpoint information + SdbEndpointInformation pipe_info; + if (!GetEndpointInformation(endpoint, &pipe_info)) { + return false; + } + + if (SdbEndpointTypeBulk == pipe_info.endpoint_type) { + // This is a bulk endpoint. Cache its index and ID. + if (0 != (pipe_info.endpoint_address & USB_ENDPOINT_DIRECTION_MASK)) { + // Use this endpoint as default bulk read endpoint + ATLASSERT(0xFF == def_read_endpoint_); + def_read_endpoint_ = endpoint; + read_endpoint_id_ = pipe_info.endpoint_address; + } else { + // Use this endpoint as default bulk write endpoint + ATLASSERT(0xFF == def_write_endpoint_); + def_write_endpoint_ = endpoint; + write_endpoint_id_ = pipe_info.endpoint_address; + } + } + } + + return SdbObjectHandle::CreateHandle(); +} + +bool SdbLegacyInterfaceObject::GetSerialNumber(void* buffer, + unsigned long* buffer_char_size, + bool ansi) { + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + // Open USB device for this intefface + HANDLE usb_device_handle = CreateFile(interface_name().c_str(), + GENERIC_READ, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, + OPEN_EXISTING, + 0, + NULL); + if (INVALID_HANDLE_VALUE == usb_device_handle) { + return NULL; + } + + WCHAR serial_number[512]; + + // Send IOCTL + DWORD ret_bytes = 0; + BOOL ret = DeviceIoControl(usb_device_handle, + SDB_IOCTL_GET_SERIAL_NUMBER, + NULL, 0, + serial_number, sizeof(serial_number), + &ret_bytes, + NULL); + + // Preserve error accross CloseHandle + ULONG error = ret ? NO_ERROR : GetLastError(); + + ::CloseHandle(usb_device_handle); + + if (NO_ERROR != error) { + SetLastError(error); + return false; + } + + unsigned long str_len = + static_cast(wcslen(serial_number) + 1); + + if ((NULL == buffer) || (*buffer_char_size < str_len)) { + *buffer_char_size = str_len; + SetLastError(ERROR_INSUFFICIENT_BUFFER); + return false; + } + + if (!ansi) { + // If user asked for wide char name just return it + wcscpy(reinterpret_cast(buffer), serial_number); + return true; + } + + // We need to convert name from wide char to ansi string + int res = WideCharToMultiByte(CP_ACP, + 0, + serial_number, + static_cast(str_len), + reinterpret_cast(buffer), + static_cast(*buffer_char_size), + NULL, + NULL); + return (res != 0); +} + +bool SdbLegacyInterfaceObject::GetEndpointInformation( + UCHAR endpoint_index, + SdbEndpointInformation* info) { + // Open USB device for this intefface + HANDLE usb_device_handle = CreateFile(interface_name().c_str(), + GENERIC_READ, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, + OPEN_EXISTING, + 0, + NULL); + if (INVALID_HANDLE_VALUE == usb_device_handle) { + return NULL; + } + + // Init ICTL param + SdbQueryEndpointInformation param; + param.endpoint_index = endpoint_index; + + // Send IOCTL + DWORD ret_bytes = 0; + BOOL ret = DeviceIoControl(usb_device_handle, + SDB_IOCTL_GET_ENDPOINT_INFORMATION, + ¶m, sizeof(param), + info, sizeof(SdbEndpointInformation), + &ret_bytes, + NULL); + ATLASSERT(!ret || (sizeof(SdbEndpointInformation) == ret_bytes)); + + // Preserve error accross CloseHandle + ULONG error = ret ? NO_ERROR : GetLastError(); + + ::CloseHandle(usb_device_handle); + + if (NO_ERROR != error) { + SetLastError(error); + } + + return ret ? true : false; +} + +SDBAPIHANDLE SdbLegacyInterfaceObject::OpenEndpoint( + UCHAR endpoint_index, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode) { + // Convert index into name and ID. + std::wstring endpoint_name; + UCHAR endpoint_id; + + try { + if ((SDB_QUERY_BULK_READ_ENDPOINT_INDEX == endpoint_index) || + (def_read_endpoint_ == endpoint_index)) { + endpoint_name = DEVICE_BULK_READ_PIPE_NAME; + endpoint_id = read_endpoint_id_; + endpoint_index = def_read_endpoint_; + } else if ((SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX == endpoint_index) || + (def_write_endpoint_ == endpoint_index)) { + endpoint_name = DEVICE_BULK_WRITE_PIPE_NAME; + endpoint_id = write_endpoint_id_; + endpoint_index = def_write_endpoint_; + } else { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + } catch (...) { + // We don't expect exceptions other than OOM thrown here. + SetLastError(ERROR_OUTOFMEMORY); + return NULL; + } + + return OpenEndpoint(endpoint_name.c_str(), endpoint_id, endpoint_index, + access_type, sharing_mode); +} + +SDBAPIHANDLE SdbLegacyInterfaceObject::OpenEndpoint( + const wchar_t* endpoint_name, + UCHAR endpoint_id, + UCHAR endpoint_index, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode) { + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + SdbLegacyEndpointObject* sdb_endpoint = NULL; + + try { + sdb_endpoint = + new SdbLegacyEndpointObject(this, endpoint_id, endpoint_index); + } catch (...) { + // We don't expect exceptions other than OOM thrown here. + SetLastError(ERROR_OUTOFMEMORY); + return NULL; + } + + // Build full path to the object + std::wstring endpoint_path = interface_name(); + endpoint_path += L"\\"; + endpoint_path += endpoint_name; + + SDBAPIHANDLE ret = sdb_endpoint->CreateHandle(endpoint_path.c_str(), + access_type, + sharing_mode); + + sdb_endpoint->Release(); + + return ret; +} + +bool SdbLegacyInterfaceObject::CacheUsbDeviceDescriptor( + HANDLE usb_device_handle) { + DWORD ret_bytes = 0; + BOOL ret = DeviceIoControl(usb_device_handle, + SDB_IOCTL_GET_USB_DEVICE_DESCRIPTOR, + NULL, 0, + &usb_device_descriptor_, + sizeof(usb_device_descriptor_), + &ret_bytes, + NULL); + ATLASSERT(!ret || (sizeof(USB_DEVICE_DESCRIPTOR) == ret_bytes)); + + return ret ? true : false; +} + +bool SdbLegacyInterfaceObject::CacheUsbConfigurationDescriptor( + HANDLE usb_device_handle) { + DWORD ret_bytes = 0; + BOOL ret = DeviceIoControl(usb_device_handle, + SDB_IOCTL_GET_USB_CONFIGURATION_DESCRIPTOR, + NULL, 0, + &usb_config_descriptor_, + sizeof(usb_config_descriptor_), + &ret_bytes, + NULL); + ATLASSERT(!ret || (sizeof(USB_CONFIGURATION_DESCRIPTOR) == ret_bytes)); + + return ret ? true : false; +} + +bool SdbLegacyInterfaceObject::CacheUsbInterfaceDescriptor( + HANDLE usb_device_handle) { + DWORD ret_bytes = 0; + BOOL ret = DeviceIoControl(usb_device_handle, + SDB_IOCTL_GET_USB_INTERFACE_DESCRIPTOR, + NULL, 0, + &usb_interface_descriptor_, + sizeof(usb_interface_descriptor_), + &ret_bytes, + NULL); + ATLASSERT(!ret || (sizeof(USB_INTERFACE_DESCRIPTOR) == ret_bytes)); + + return ret ? true : false; +} diff --git a/src/sdbwinapi/sdb_legacy_interface.h b/src/sdbwinapi/sdb_legacy_interface.h new file mode 100644 index 0000000..6f88669 --- /dev/null +++ b/src/sdbwinapi/sdb_legacy_interface.h @@ -0,0 +1,190 @@ +/* + * Copyright (C) 2009 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 ANDROID_USB_API_SDB_LEGACY_INTERFACE_H__ +#define ANDROID_USB_API_SDB_LEGACY_INTERFACE_H__ +/** \file + This file consists of declaration of class SdbLegacyInterfaceObject + that encapsulates an interface on our USB device that is accessible + via custom USB driver. +*/ + +#include "sdb_interface.h" + +/** \brief Encapsulates an interface on our USB device that is accessible + via custom USB driver. +*/ +class SdbLegacyInterfaceObject : public SdbInterfaceObject { + public: + /** \brief Constructs the object. + + @param[in] interf_name Name of the interface + */ + explicit SdbLegacyInterfaceObject(const wchar_t* interf_name); + + protected: + /** \brief Destructs the object. + + We hide destructor in order to prevent ourseves from accidentaly allocating + instances on the stack. If such attemp occur, compiler will error. + */ + virtual ~SdbLegacyInterfaceObject(); + + // + // Virtual overrides + // + + public: + /** \brief Creates handle to this object. + + In this call a handle for this object is generated and object is added + to the SdbObjectHandleMap. We override this method in order to initialize + access to the custom driver. + @return A handle to this object on success or NULL on an error. + If NULL is returned GetLastError() provides extended error + information. ERROR_GEN_FAILURE is set if an attempt was + made to create already opened object. + */ + virtual SDBAPIHANDLE CreateHandle(); + + // + // Abstract overrides + // + + public: + /** \brief Gets serial number for interface's device. + + @param[out] buffer Buffer for the serail number string. Can be NULL in + which case buffer_char_size will contain number of characters + required for the string. + @param[in,out] buffer_char_size On the way in supplies size (in characters) + of the buffer. On the way out, if method failed and GetLastError + reports ERROR_INSUFFICIENT_BUFFER, will contain number of characters + required for the name. + @param[in] ansi If true the name will be returned as single character + string. Otherwise name will be returned as wide character string. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool GetSerialNumber(void* buffer, + unsigned long* buffer_char_size, + bool ansi); + + /** \brief Gets information about an endpoint on this interface. + + @param[in] endpoint_index Zero-based endpoint index. There are two + shortcuts for this parameter: SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX + and SDB_QUERY_BULK_READ_ENDPOINT_INDEX that provide infor about + (default?) bulk write and read endpoints respectively. + @param[out] info Upon successful completion will have endpoint information. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool GetEndpointInformation(UCHAR endpoint_index, + SdbEndpointInformation* info); + + /** \brief Opens an endpoint on this interface. + + @param[in] endpoint_index Zero-based endpoint index. There are two + shortcuts for this parameter: SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX + and SDB_QUERY_BULK_READ_ENDPOINT_INDEX that provide infor about + (default?) bulk write and read endpoints respectively. + @param[in] access_type Desired access type. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always read / write access. + @param[in] sharing_mode Desired share mode. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always shared for read / write. + @return Handle to the opened endpoint object or NULL on failure. + If NULL is returned GetLastError() provides extended information + about the error that occurred. + */ + virtual SDBAPIHANDLE OpenEndpoint(UCHAR endpoint_index, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode); + + // + // Internal operations + // + + protected: + /** \brief Opens an endpoint on this interface. + + @param[in] endpoint_name Endpoint file name. + @param[in] endpoint_id Endpoint (pipe) address on the device. + @param[in] endpoint_index Zero-based endpoint index. + @param[in] access_type Desired access type. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always read / write access. + @param[in] sharing_mode Desired share mode. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always shared for read / write. + @return Handle to the opened endpoint object or NULL on failure. + If NULL is returned GetLastError() provides extended information + about the error that occurred. + */ + SDBAPIHANDLE OpenEndpoint(const wchar_t* endpoint_name, + UCHAR endpoint_id, + UCHAR endpoint_index, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode); + + /** \brief Caches device descriptor for the USB device associated with + this interface. + + This method is called from CreateHandle method to cache some interface + information. + @param[in] usb_device_handle Handle to USB device. + @return 'true' on success, 'false' on failure. If 'false' is returned + GetLastError() provides extended error information. + */ + bool CacheUsbDeviceDescriptor(HANDLE usb_device_handle); + + /** \brief Caches descriptor for the selected USB device configuration. + + This method is called from CreateHandle method to cache some interface + information. + @param[in] usb_device_handle Handle to USB device. + @return 'true' on success, 'false' on failure. If 'false' is returned + GetLastError() provides extended error information. + */ + bool CacheUsbConfigurationDescriptor(HANDLE usb_device_handle); + + /** \brief Caches descriptor for this interface. + + This method is called from CreateHandle method to cache some interface + information. + @param[in] usb_device_handle Handle to USB device. + @return 'true' on success, 'false' on failure. If 'false' is returned + GetLastError() provides extended error information. + */ + bool CacheUsbInterfaceDescriptor(HANDLE usb_device_handle); + + protected: + /// Index for the default bulk read endpoint + UCHAR def_read_endpoint_; + + /// ID for the default bulk read endpoint + UCHAR read_endpoint_id_; + + /// Index for the default bulk write endpoint + UCHAR def_write_endpoint_; + + /// ID for the default bulk write endpoint + UCHAR write_endpoint_id_; +}; + +#endif // ANDROID_USB_API_SDB_LEGACY_INTERFACE_H__ diff --git a/src/sdbwinapi/sdb_legacy_io_completion.cpp b/src/sdbwinapi/sdb_legacy_io_completion.cpp new file mode 100644 index 0000000..1cf1f8a --- /dev/null +++ b/src/sdbwinapi/sdb_legacy_io_completion.cpp @@ -0,0 +1,90 @@ +/* + * Copyright (C) 2009 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. + */ + +/** \file + This file consists of implementation of class SdbLegacyIOCompletion that + encapsulates a wrapper around OVERLAPPED Win32 structure returned from + asynchronous I/O requests issued via legacy USB API. +*/ + +#include "stdafx.h" +#include "sdb_legacy_io_completion.h" + +SdbLegacyIOCompletion::SdbLegacyIOCompletion( + SdbLegacyEndpointObject* parent_io_obj, + ULONG expected_trans_size, + HANDLE event_hndl, + bool is_write_ctl) + : SdbIOCompletion(parent_io_obj, expected_trans_size, event_hndl), + transferred_bytes_(0), + is_write_ioctl_(is_write_ctl) { +} + +SdbLegacyIOCompletion::~SdbLegacyIOCompletion() { +} + +bool SdbLegacyIOCompletion::GetOvelappedIoResult(LPOVERLAPPED ovl_data, + ULONG* bytes_transferred, + bool wait) { + if (NULL != bytes_transferred) { + *bytes_transferred = 0; + } + + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + ULONG transfer; + bool ret = GetOverlappedResult(parent_legacy_io_object()->usb_handle(), + overlapped(), + &transfer, + wait) ? true : + false; + + // TODO: This is bizzare but I've seen it happening + // that GetOverlappedResult with wait set to true returns "prematurely", + // with wrong transferred bytes value and GetLastError reporting + // ERROR_IO_PENDING. So, lets give it an up to a 20 ms loop! + ULONG error = GetLastError(); + + if (wait && ret && (0 == transfer) && (0 != expected_transfer_size_) && + ((ERROR_IO_INCOMPLETE == error) || (ERROR_IO_PENDING == error))) { + for (int trying = 0; trying < 10; trying++) { + Sleep(2); + ret = GetOverlappedResult(parent_legacy_io_object()->usb_handle(), + overlapped(), + &transfer, + wait) ? true : + false; + error = GetLastError(); + if (!ret || (0 != transfer) || + ((ERROR_IO_INCOMPLETE != error) && (ERROR_IO_PENDING != error))) { + break; + } + } + } + + if (NULL != ovl_data) { + CopyMemory(ovl_data, overlapped(), sizeof(OVERLAPPED)); + } + + if (NULL != bytes_transferred) { + *bytes_transferred = is_write_ioctl() ? transferred_bytes_ : transfer; + } + + return ret; +} diff --git a/src/sdbwinapi/sdb_legacy_io_completion.h b/src/sdbwinapi/sdb_legacy_io_completion.h new file mode 100644 index 0000000..f51e5b8 --- /dev/null +++ b/src/sdbwinapi/sdb_legacy_io_completion.h @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2009 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 ANDROID_USB_API_SDB_LEGACY_IO_COMPLETION_H__ +#define ANDROID_USB_API_SDB_LEGACY_IO_COMPLETION_H__ +/** \file + This file consists of declaration of class SdbLegacyIOCompletion that + encapsulates a wrapper around OVERLAPPED Win32 structure returned from + asynchronous I/O requests issued via legacy USB API. +*/ + +#include "sdb_io_completion.h" +#include "sdb_legacy_endpoint_object.h" + +/** \brief Encapsulates a wrapper around OVERLAPPED Win32 structure returned + from asynchronous I/O requests issued via legacy USB API. + + A handle to this object is returned to the caller of each successful + asynchronous I/O request. Just like all other handles this handle + must be closed after it's no longer needed. +*/ +class SdbLegacyIOCompletion : public SdbIOCompletion { + public: + /** \brief Constructs the object. + + @param[in] parent_io_obj Parent legacy endpoint that created this + instance. + @param[in] expected_trans_size Number of bytes expected to be transferred + with the I/O. + @param[in] event_hndl Event handle that should be signaled when I/O + completes. Can be NULL. If it's not NULL this handle will be + used to initialize OVERLAPPED structure for this object. + @param[in] is_write_ctl Flag indicating whether or not this completion + object is created for SDB_IOCTL_BULK_WRITE I/O. + */ + SdbLegacyIOCompletion(SdbLegacyEndpointObject* parent_io_obj, + ULONG expected_trans_size, + HANDLE event_hndl, + bool is_write_ctl); + + protected: + /** \brief Destructs the object. + + We hide destructor in order to prevent ourseves from accidentaly allocating + instances on the stack. If such attemp occur, compiler will error. + */ + virtual ~SdbLegacyIOCompletion(); + + // + // Abstract overrides + // + + public: + /** \brief Gets overlapped I/O result + + This method uses GetOverlappedResult to get results of the overlapped I/O + operation. + @param[out] ovl_data Buffer for the copy of this object's OVERLAPPED + structure. Can be NULL. + @param[out] bytes_transferred Pointer to a variable that receives the + number of bytes that were actually transferred by a read or write + operation. See SDK doc on GetOvelappedResult for more information. + Unlike regular GetOvelappedResult call this parameter can be NULL. + @param[in] wait If this parameter is true, the method does not return + until the operation has been completed. If this parameter is false + and the operation is still pending, the method returns false and + the GetLastError function returns ERROR_IO_INCOMPLETE. + @return true if I/O has been completed or false on failure or if request + is not yet completed. If false is returned GetLastError() provides + extended error information. If GetLastError returns + ERROR_IO_INCOMPLETE it means that I/O is not yet completed. + */ + virtual bool GetOvelappedIoResult(LPOVERLAPPED ovl_data, + ULONG* bytes_transferred, + bool wait); + + public: + /// Gets parent legacy endpoint. + SdbLegacyEndpointObject* parent_legacy_io_object() const { + return reinterpret_cast(parent_io_object()); + } + + /// Gets write IOCTL flag. + bool is_write_ioctl() const { + return is_write_ioctl_; + } + + /// Gets address for SDB_IOCTL_BULK_WRITE output buffer. + ULONG* transferred_bytes_ptr() { + ATLASSERT(is_write_ioctl()); + return &transferred_bytes_; + } + + protected: + /// Recepient for number of transferred bytes in write IOCTL. + ULONG transferred_bytes_; + + /// Write IOCTL flag. + bool is_write_ioctl_; +}; + +#endif // ANDROID_USB_API_SDB_LEGACY_IO_COMPLETION_H__ diff --git a/src/sdbwinapi/sdb_object_handle.cpp b/src/sdbwinapi/sdb_object_handle.cpp new file mode 100644 index 0000000..256a5be --- /dev/null +++ b/src/sdbwinapi/sdb_object_handle.cpp @@ -0,0 +1,167 @@ +/* + * 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. + */ + +/** \file + This file consists of implementation of a class SdbObjectHandle that + encapsulates an internal API object that is visible to the outside + of the API through a handle. +*/ + +#include "stdafx.h" +#include "sdb_api.h" +#include "sdb_object_handle.h" + +/// Global SDBAPIHANDLE -> SdbObjectHandle* map +SdbObjectHandleMap the_map; + +/// Locker for the SdbObjectHandleMap instance +CComAutoCriticalSection the_map_locker; + +/// Next sdb handle value generator +ULONG_PTR next_sdb_handle_value = 0; + +SdbObjectHandle::SdbObjectHandle(SdbObjectType obj_type) + : sdb_handle_(NULL), + object_type_(obj_type), + ref_count_(1) { + ATLASSERT(obj_type < SdbObjectTypeMax); +} + +SdbObjectHandle::~SdbObjectHandle() { + ATLASSERT(0 == ref_count_); + ATLASSERT(NULL == sdb_handle_); +} + +LONG SdbObjectHandle::AddRef() { + ATLASSERT(ref_count_ > 0); + return InterlockedIncrement(&ref_count_); +} + +LONG SdbObjectHandle::Release() { + ATLASSERT(ref_count_ > 0); + LONG ret = InterlockedDecrement(&ref_count_); + ATLASSERT(ret >= 0); + if (0 == ret) { + LastReferenceReleased(); + delete this; + } + return ret; +} + +SDBAPIHANDLE SdbObjectHandle::CreateHandle() { + SDBAPIHANDLE ret = NULL; + + // We have to hold this lock while we're dealing with the handle + // and the table + the_map_locker.Lock(); + + ATLASSERT(!IsOpened()); + + if (!IsOpened()) { + try { + // Generate next handle value + next_sdb_handle_value++; + ret = reinterpret_cast(next_sdb_handle_value); + + // Add ourselves to the map + the_map[ret] = this; + + // Save handle, addref and return + sdb_handle_ = ret; + AddRef(); + } catch (...) { + ret = NULL; + SetLastError(ERROR_OUTOFMEMORY); + } + } else { + // Signaling that this object is already opened + SetLastError(ERROR_GEN_FAILURE); + } + + the_map_locker.Unlock(); + + return ret; +} + +bool SdbObjectHandle::CloseHandle() { + bool ret = false; + + // Addref just in case that last reference to this object is being + // held in the map + AddRef(); + + the_map_locker.Lock(); + + ATLASSERT(IsOpened()); + + if (IsOpened()) { + try { + // Look us up in the map. + SdbObjectHandleMap::iterator found = the_map.find(sdb_handle()); + ATLASSERT((found != the_map.end()) && (this == found->second)); + + if ((found != the_map.end()) && (this == found->second)) { + // Remove ourselves from the map, close and release the object + the_map.erase(found); + sdb_handle_ = NULL; + Release(); + ret = true; + } else { + SetLastError(ERROR_INVALID_HANDLE); + } + } catch (...) { + ret = false; + SetLastError(ERROR_OUTOFMEMORY); + } + } else { + SetLastError(ERROR_INVALID_HANDLE); + } + + the_map_locker.Unlock(); + + Release(); + + return ret; +} + +bool SdbObjectHandle::IsObjectOfType(SdbObjectType obj_type) const { + return (obj_type == object_type()); +} + +void SdbObjectHandle::LastReferenceReleased() { + ATLASSERT(!IsOpened()); +} + +SdbObjectHandle* SdbObjectHandle::Lookup(SDBAPIHANDLE sdb_hndl) { + SdbObjectHandle* ret = NULL; + + the_map_locker.Lock(); + + try { + // Look us up in the map. + SdbObjectHandleMap::iterator found = the_map.find(sdb_hndl); + if (found != the_map.end()) { + ret = found->second; + ret->AddRef(); + } + } catch (...) { + SetLastError(ERROR_OUTOFMEMORY); + } + + the_map_locker.Unlock(); + + return ret; +} diff --git a/src/sdbwinapi/sdb_object_handle.h b/src/sdbwinapi/sdb_object_handle.h new file mode 100644 index 0000000..c46690d --- /dev/null +++ b/src/sdbwinapi/sdb_object_handle.h @@ -0,0 +1,212 @@ +/* + * 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 ANDROID_USB_API_SDB_OBJECT_HANDLE_H__ +#define ANDROID_USB_API_SDB_OBJECT_HANDLE_H__ +/** \file + This file consists of declaration of a class SdbObjectHandle that + encapsulates an internal API object that is visible to the outside + of the API through a handle. +*/ + +#include "sdb_api.h" +#include "sdb_api_private_defines.h" + +/** \brief Defines types of internal API objects +*/ +enum SdbObjectType { + /// Object is SdbInterfaceEnumObject. + SdbObjectTypeInterfaceEnumerator, + + /// Object is SdbInterfaceObject. + SdbObjectTypeInterface, + + /// Object is SdbEndpointObject. + SdbObjectTypeEndpoint, + + /// Object is SdbIOCompletion. + SdbObjectTypeIoCompletion, + + SdbObjectTypeMax +}; + +/** \brief Encapsulates an internal API basic object that is visible to the + outside of the API through a handle. + + In order to prevent crashes when API client tries to access an object through + an invalid or already closed handle, we keep track of all opened handles in + SdbObjectHandleMap that maps association between valid SDBAPIHANDLE and + an object that this handle represents. All objects that are exposed to the + outside of API via SDBAPIHANDLE are self-destructing referenced objects. + The reference model for these objects is as such: + 1. When CreateHandle() method is called on an object, a handle (SDBAPIHANDLE + that is) is assigned to it, a pair is added to the global + SdbObjectHandleMap instance, object is referenced and then handle is + returned to the API client. + 2. Every time API is called with a handle, a lookup is performed in + SdbObjectHandleMap to find an object that is associated with the handle. + If object is not found then ERROR_INVALID_HANDLE is immediatelly returned + (via SetLastError() call). If object is found then it is referenced and + API call is dispatched to appropriate method of the found object. Upon + return from this method, just before returning from the API call, object + is dereferenced back to match lookup reference. + 3. When object handle gets closed, assuming object is found in the map, that + pair is deleted from the map and object's refcount is + decremented to match refcount increment performed when object has been + added to the map. + 4. When object's refcount drops to zero, the object commits suicide by + calling "delete this". + All API objects that have handles that are sent back to API client must be + derived from this class. +*/ +class SDBWIN_API_CLASS SdbObjectHandle { + public: + /** \brief Constructs the object + + Refernce counter is set to 1 in the constructor. + @param[in] obj_type Object type from SdbObjectType enum + */ + explicit SdbObjectHandle(SdbObjectType obj_type); + + protected: + /** \brief Destructs the object. + + We hide destructor in order to prevent ourseves from accidentaly allocating + instances on the stack. If such attempt occurs, compiler will error. + */ + virtual ~SdbObjectHandle(); + + public: + /** \brief References the object. + + @return Value of the reference counter after object is referenced in this + method. + */ + virtual LONG AddRef(); + + /** \brief Releases the object. + + If refcount drops to zero as the result of this release, the object is + destroyed in this method. As a general rule, objects must not be touched + after this method returns even if returned value is not zero. + @return Value of the reference counter after object is released in this + method. + */ + virtual LONG Release(); + + /** \brief Creates handle to this object. + + In this call a handle for this object is generated and object is added + to the SdbObjectHandleMap. + @return A handle to this object on success or NULL on an error. + If NULL is returned GetLastError() provides extended error + information. ERROR_GEN_FAILURE is set if an attempt was + made to create already opened object. + */ + virtual SDBAPIHANDLE CreateHandle(); + + /** \brief This method is called when handle to this object gets closed. + + In this call object is deleted from the SdbObjectHandleMap. + @return true on success or false if object is already closed. If + false is returned GetLastError() provides extended error + information. + */ + virtual bool CloseHandle(); + + /** \brief Checks if this object is of the given type. + + @param[in] obj_type One of the SdbObjectType types to check + @return true is this object type matches obj_type, or false otherwise. + */ + virtual bool IsObjectOfType(SdbObjectType obj_type) const; + + /** \brief Looks up SdbObjectHandle instance associated with the given handle + in the SdbObjectHandleMap. + + This method increments reference counter for the returned found object. + @param[in] sdb_handle SDB handle to the object + @return API object associated with the handle or NULL if object is not + found. If NULL is returned GetLastError() provides extended error + information. + */ + static SdbObjectHandle* Lookup(SDBAPIHANDLE sdb_handle); + + protected: + /** \brief Called when last reference to this object is released. + + Derived object should override this method to perform cleanup that is not + suitable for destructors. + */ + virtual void LastReferenceReleased(); + + public: + /// Gets SDB handle associated with this object + SDBAPIHANDLE sdb_handle() const { + return sdb_handle_; + } + + /// Gets type of this object + SdbObjectType object_type() const { + return object_type_; + } + + /// Checks if object is still opened. Note that it is not guaranteed that + /// object remains opened when this method returns. + bool IsOpened() const { + return (NULL != sdb_handle()); + } + + protected: + /// API handle associated with this object + SDBAPIHANDLE sdb_handle_; + + /// Type of this object + SdbObjectType object_type_; + + /// This object's reference counter + LONG ref_count_; +}; + +/// Maps SDBAPIHANDLE to associated SdbObjectHandle object +typedef std::map< SDBAPIHANDLE, SdbObjectHandle* > SdbObjectHandleMap; + +/** \brief Template routine that unifies extracting of objects of different + types from the SdbObjectHandleMap + + @param[in] sdb_handle API handle for the object + @return Object associated with the handle or NULL on error. If NULL is + returned GetLastError() provides extended error information. +*/ +template +obj_class* LookupObject(SDBAPIHANDLE sdb_handle) { + // Lookup object for the handle in the map + SdbObjectHandle* sdb_object = SdbObjectHandle::Lookup(sdb_handle); + if (NULL != sdb_object) { + // Make sure it's of the correct type + if (!sdb_object->IsObjectOfType(obj_class::Type())) { + sdb_object->Release(); + sdb_object = NULL; + SetLastError(ERROR_INVALID_HANDLE); + } + } else { + SetLastError(ERROR_INVALID_HANDLE); + } + return (sdb_object != NULL) ? reinterpret_cast(sdb_object) : + NULL; +} + +#endif // ANDROID_USB_API_SDB_OBJECT_HANDLE_H__ diff --git a/src/sdbwinapi/sdb_winusb_api.h b/src/sdbwinapi/sdb_winusb_api.h new file mode 100644 index 0000000..d3b2525 --- /dev/null +++ b/src/sdbwinapi/sdb_winusb_api.h @@ -0,0 +1,48 @@ +/* + * 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 ANDROID_USB_API_SDBWINUSBAPI_H__ +#define ANDROID_USB_API_SDBWINUSBAPI_H__ + +/** \file + Contains declarations required to link SdbWinApi and SdbWinUsbApi DLLs. +*/ + +/** \brief Function prototype for InstantiateWinUsbInterface routine exported + from SdbWinUsbApi.dll + + In order to provide backward compatibility with the systems that still run + legacy (custom) USB drivers, and have not installed WINUSB.DLL we need to + split functionality of our SDB API on Windows between two DLLs: SdbWinApi, + and SdbWinUsbApi. SdbWinApi is fully capable of working on top of the legacy + driver, but has no traces to WinUsb. SdbWinUsbApi is capable of working on + top of WinUsb API. We are forced to do this split, because we can have + dependency on WINUSB.DLL in the DLL that implements legacy API. The problem + is that customers may have a legacy driver that they don't want to upgrade + to WinUsb, so they may not have WINUSB.DLL installed on their machines, but + they still must be able to use SDB. So, the idea behind the split is as + such. When SdbWinApi.dll is loaded into a process, it will check WINUSB.DLL + installation (by checking existance of C:\Windows\System32\winusb.dll). If + WINUSB.DLL is installed, SdbWinApi will also load SdbWinUsbApi.dll (by + calling LoadLibrary), and will extract address of InstantiateWinUsbInterface + routine exported from SdbWinUsbApi.dll. Then this routine will be used to + instantiate SdbInterfaceObject instance on condition that it is confirmed + that USB driver underneath us is in deed WinUsb. +*/ +typedef class SdbInterfaceObject* \ + (__cdecl *PFN_INSTSDBWINUSBINTERFACE)(const wchar_t*); + +#endif // ANDROID_USB_API_SDBWINUSBAPI_H__ diff --git a/src/sdbwinapi/stdafx.cpp b/src/sdbwinapi/stdafx.cpp new file mode 100644 index 0000000..a2701f6 --- /dev/null +++ b/src/sdbwinapi/stdafx.cpp @@ -0,0 +1,21 @@ +/* + * 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. + */ + +// stdafx.cpp : source file that includes just the standard includes +// SdbWinApi.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" diff --git a/src/sdbwinapi/stdafx.h b/src/sdbwinapi/stdafx.h new file mode 100644 index 0000000..d57bec7 --- /dev/null +++ b/src/sdbwinapi/stdafx.h @@ -0,0 +1,79 @@ +/* + * 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. + */ + +/** \file + Visual Studio generated include file for standard system include files, or + project specific include files that are used frequently, but are changed + infrequently. +*/ + +#pragma once + +#ifndef STRICT +#define STRICT +#endif + +// Modify the following defines if you have to target a platform prior to the ones specified below. +// Refer to MSDN for the latest info on corresponding values for different platforms. +#ifndef WINVER // Allow use of features specific to Windows 95 and Windows NT 4 or later. +#define WINVER 0x0500 // Change this to the appropriate value to target Windows 98 and Windows 2000 or later. +#endif + +#ifndef _WIN32_WINNT // Allow use of features specific to Windows NT 4 or later. +#define _WIN32_WINNT 0x0500 // Change this to the appropriate value to target Windows 2000 or later. +#endif + +#ifndef _WIN32_WINDOWS // Allow use of features specific to Windows 98 or later. +#define _WIN32_WINDOWS 0x0500 // Change this to the appropriate value to target Windows Me or later. +#endif + +#ifndef _WIN32_IE // Allow use of features specific to IE 4.0 or later. +#define _WIN32_IE 0x0501 // Change this to the appropriate value to target IE 5.0 or later. +#endif + +// These defines prevent the MS header files from ejecting #pragma comment +// statements with the manifest information of the used ATL, STL, and CRT +#define _ATL_NOFORCE_MANIFEST +#define _STL_NOFORCE_MANIFEST +#define _CRT_NOFORCE_MANIFEST + +#define _ATL_APARTMENT_THREADED +#define _ATL_NO_AUTOMATIC_NAMESPACE + +#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // some CString constructors will be explicit + +// turns off ATL's hiding of some common and often safely ignored warning messages +#define _ATL_ALL_WARNINGS + +// #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#include +#pragma warning(disable: 4702) +#pragma warning(disable: 4201) +#include +#include +#include +#include +#include +#include +#pragma warning(default: 4201) +#pragma warning(disable: 4200) +#include +#include + +#include "resource.h" + +using namespace ATL; diff --git a/src/sdbwinusbapi/BUILDME.TXT b/src/sdbwinusbapi/BUILDME.TXT new file mode 100644 index 0000000..b130472 --- /dev/null +++ b/src/sdbwinusbapi/BUILDME.TXT @@ -0,0 +1,7 @@ +In order to build SdbWinUsbApi.dll you will need to install Windows Driver Kit, +which can be obtained from Microsoft. Assuming that WDK is installed, you +need to set one of the WDK's build environments, "cd" back into this directory, +and execute "build -cbeEIFZ" to clean and rebuild this project, or you can +execute "build -befEIF" to do a minimal build. +Note that you need to build SdbWinApi.dll (..\api) before you build +SdbWinUsbApi.dll, as it depends on SdbWinApi.lib library. diff --git a/src/sdbwinusbapi/MAKEFILE b/src/sdbwinusbapi/MAKEFILE new file mode 100644 index 0000000..87a1295 --- /dev/null +++ b/src/sdbwinusbapi/MAKEFILE @@ -0,0 +1,22 @@ +# +# Copyright (C) 2009 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. +# + +# +# DO NOT EDIT THIS FILE!!! Edit .\sources. if you want to add a new source +# file to this component. This file merely indirects to the real make file +# that is shared by all the components of NT OS/2 +# +!INCLUDE $(NTMAKEENV)\makefile.def diff --git a/src/sdbwinusbapi/Resource.h b/src/sdbwinusbapi/Resource.h new file mode 100644 index 0000000..7d883c7 --- /dev/null +++ b/src/sdbwinusbapi/Resource.h @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2009 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. + */ + +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by SdbWinApi.rc +// + +#define IDS_PROJNAME 100 +#define IDR_SDBWINAPI 101 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 201 +#define _APS_NEXT_COMMAND_VALUE 32768 +#define _APS_NEXT_CONTROL_VALUE 201 +#define _APS_NEXT_SYMED_VALUE 102 +#endif +#endif diff --git a/src/sdbwinusbapi/SOURCES b/src/sdbwinusbapi/SOURCES new file mode 100644 index 0000000..90be2c1 --- /dev/null +++ b/src/sdbwinusbapi/SOURCES @@ -0,0 +1,91 @@ +# +# Copyright (C) 2009 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. +# + +TARGETNAME = SdbWinUsbApi +TARGETPATH = obj +TARGETTYPE = DYNLINK + +UMTYPE = windows +DLLDEF = SdbWinUsbApi.def + +# Use statically linked atl libraries: +# - atls.lib for free build +# - atlsd.lib for checked build +USE_STATIC_ATL = 1 +# Use ATL v. 7.1 +ATL_VER = 71 +# Use STL v. 6.0 +USE_STL = 1 +STL_VER = 60 +# Use multithreaded libraries +USE_LIBCMT = 1 + +# Include directories +INCLUDES = $(DDK_INC_PATH); \ + $(SDK_INC_PATH); \ + $(CRT_INC_PATH); \ + $(SDK_INC_PATH)\crt; \ + $(CRT_INC_PATH)\atl71; \ + $(SDK_INC_PATH)\crt\stl60 + +# Common target libraries +TARGETLIBS = $(SDK_LIB_PATH)\ole32.lib \ + $(SDK_LIB_PATH)\Advapi32.lib \ + $(SDK_LIB_PATH)\Kernel32.lib \ + $(SDK_LIB_PATH)\User32.lib \ + $(SDK_LIB_PATH)\oleaut32.lib \ + $(SDK_LIB_PATH)\wbemuuid.lib \ + $(SDK_LIB_PATH)\uuid.lib \ + $(SDK_LIB_PATH)\setupapi.lib \ + $(SDK_LIB_PATH)\usbd.lib \ + $(SDK_LIB_PATH)\winusb.lib \ + ..\sdbwinapi\obj$(BUILD_ALT_DIR)\i386\SdbWinApi.lib + +!IF "$(DDKBUILDENV)" == "fre" +# Libraries for release (free) builds +TARGETLIBS = $(TARGETLIBS) $(ATL_LIB_PATH)\atls.lib +!ELSE +# Libraries for debug (checked) builds +TARGETLIBS = $(TARGETLIBS) $(ATL_LIB_PATH)\atlsd.lib +!ENDIF + +# Common C defines +C_DEFINES= $(C_DEFINES) -DSDBWINUSB_EXPORTS -D_UNICODE \ + -DUNICODE -DWIN32 -D_WINDOWS -D_USRDLL -D_WINDLL + +!IF "$(DDKBUILDENV)" == "fre" +# C defines for release (free) builds +C_DEFINES = $(C_DEFINES) -DNDEBUG +!ELSE +# C defines for debug (checked) builds +C_DEFINES = $(C_DEFINES) -D_DEBUG +!ENDIF + +# Turn on all warnings, and treat warnings as errors +MSC_WARNING_LEVEL = /W4 /Wp64 /WX +# Common C defines +USER_C_FLAGS = $(USER_C_FLAGS) /FD /EHsc /wd4100 /wd4200 /wd4702 /nologo +# Set precompiled header information +PRECOMPILED_CXX = 1 +PRECOMPILED_INCLUDE = stdafx.h +PRECOMPILED_SOURCEFILE = stdafx.cpp + +# Define source files for SdbWinUsbApi.dll +SOURCES = sdb_winusb_endpoint_object.cpp \ + sdb_winusb_interface.cpp \ + sdb_winusb_io_completion.cpp \ + SdbWinUsbApi.cpp \ + SdbWinUsbApi.rc diff --git a/src/sdbwinusbapi/SdbWinUsbApi.cpp b/src/sdbwinusbapi/SdbWinUsbApi.cpp new file mode 100644 index 0000000..e656e94 --- /dev/null +++ b/src/sdbwinusbapi/SdbWinUsbApi.cpp @@ -0,0 +1,62 @@ +/* + * Copyright (C) 2009 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. + */ + +// SdbWinUsbApi.cpp : Implementation of DLL Exports. + +#include "stdafx.h" +#include "sdb_winusb_interface.h" + +class CSdbWinApiModule : public CAtlDllModuleT< CSdbWinApiModule > { +public: +}; + +CSdbWinApiModule _AtlModule; + +// DLL Entry Point +extern "C" BOOL WINAPI DllMain(HINSTANCE instance, + DWORD reason, + LPVOID reserved) { + return _AtlModule.DllMain(reason, reserved); +} + +/** \brief Instantiates interface instance that uses WinUsb API to communicate + with USB driver. + + This is the only exported routine from this DLL. This routine instantiates an + object of SdbWinUsbInterfaceObject on request from SdbWinApi.dll when it is + detected that underlying USB driver is WinUsb.sys. + @param[in] interface_name Name of the interface. + @return SdbInterfaceObject - casted instance of SdbWinUsbInterfaceObject + object on success, or NULL on failure with GetLastError providing + information on an error that occurred. +*/ +extern "C" __declspec(dllexport) +SdbInterfaceObject* __cdecl InstantiateSdbWinUsbInterface( + const wchar_t* interface_name) { + // Validate parameter. + if (NULL == interface_name) { + return NULL; + } + + // Instantiate requested object. + try { + return new SdbWinUsbInterfaceObject(interface_name); + } catch (...) { + // We expect only OOM exceptions here. + SetLastError(ERROR_OUTOFMEMORY); + return NULL; + } +} diff --git a/src/sdbwinusbapi/SdbWinUsbApi.def b/src/sdbwinusbapi/SdbWinUsbApi.def new file mode 100644 index 0000000..06aac0b --- /dev/null +++ b/src/sdbwinusbapi/SdbWinUsbApi.def @@ -0,0 +1,5 @@ +; SdbWinUsbApi.def : Declares the module parameters. + +LIBRARY "SdbWinUsbApi.DLL" + +EXPORTS diff --git a/src/sdbwinusbapi/SdbWinUsbApi.rc b/src/sdbwinusbapi/SdbWinUsbApi.rc new file mode 100644 index 0000000..d19be52 --- /dev/null +++ b/src/sdbwinusbapi/SdbWinUsbApi.rc @@ -0,0 +1,111 @@ +/* + * Copyright (C) 2009 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. + */ + +//Microsoft Visual C++ generated resource script. +// +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "winres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +LANGUAGE 9, 1 +#pragma code_page(1252) +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""winres.h""\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + +#ifndef _MAC +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +VS_VERSION_INFO VERSIONINFO + FILEVERSION 2,0,0,0 + PRODUCTVERSION 2,0,0,0 + FILEFLAGSMASK 0x3fL +#ifdef _DEBUG + FILEFLAGS 0x1L +#else + FILEFLAGS 0x0L +#endif + FILEOS 0x4L + FILETYPE 0x2L + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904e4" + BEGIN + VALUE "CompanyName", "Google, inc" + VALUE "FileDescription", "Android SDB API (WinUsb)" + VALUE "FileVersion", "2.0.0.0" + VALUE "LegalCopyright", "Copyright (C) 2006 The Android Open Source Project" + VALUE "InternalName", "SdbWinUsbApi.dll" + VALUE "OriginalFilename", "SdbWinUsbApi.dll" + VALUE "ProductName", "Android SDK" + VALUE "ProductVersion", "2.0.0.0" + VALUE "OLESelfRegister", "" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x0409, 1252 + END +END + +#endif // !_MAC + +///////////////////////////////////////////////////////////////////////////// +// +// String Table +// + +STRINGTABLE +BEGIN + IDS_PROJNAME "SdbWinUsbApi" +END + +//////////////////////////////////////////////////////////////////////////// + + +#endif + +#ifndef APSTUDIO_INVOKED +#endif // not APSTUDIO_INVOKED diff --git a/src/sdbwinusbapi/sdb_winusb_endpoint_object.cpp b/src/sdbwinusbapi/sdb_winusb_endpoint_object.cpp new file mode 100644 index 0000000..8b5e891 --- /dev/null +++ b/src/sdbwinusbapi/sdb_winusb_endpoint_object.cpp @@ -0,0 +1,169 @@ +/* + * Copyright (C) 2009 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. + */ + +/** \file + This file consists of implementation of class SdbWinUsbEndpointObject that + encapsulates a handle opened to a WinUsb endpoint on our device. +*/ + +#include "stdafx.h" +#include "sdb_winusb_endpoint_object.h" +#include "sdb_winusb_io_completion.h" + +SdbWinUsbEndpointObject::SdbWinUsbEndpointObject( + SdbWinUsbInterfaceObject* parent_interf, + UCHAR endpoint_id, + UCHAR endpoint_index) + : SdbEndpointObject(parent_interf, endpoint_id, endpoint_index) { +} + +SdbWinUsbEndpointObject::~SdbWinUsbEndpointObject() { +} + +LONG SdbWinUsbEndpointObject::Release() { + ATLASSERT(ref_count_ > 0); + LONG ret = InterlockedDecrement(&ref_count_); + ATLASSERT(ret >= 0); + if (0 == ret) { + LastReferenceReleased(); + delete this; + } + return ret; +} + +SDBAPIHANDLE SdbWinUsbEndpointObject::CommonAsyncReadWrite( + bool is_read, + void* buffer, + ULONG bytes_to_transfer, + ULONG* bytes_transferred, + HANDLE event_handle, + ULONG time_out) { + if (!SetTimeout(time_out)) + return false; + + // Create completion i/o object + SdbIOCompletion* sdb_io_completion = NULL; + + try { + sdb_io_completion = new SdbWinUsbIOCompletion(this, + bytes_to_transfer, + event_handle); + } catch (... ) { + SetLastError(ERROR_OUTOFMEMORY); + return NULL; + } + + // Create a handle for it + SDBAPIHANDLE ret = sdb_io_completion->CreateHandle(); + ULONG transferred = 0; + if (NULL != ret) { + BOOL res = TRUE; + // Go the read / write file way + res = is_read ? + WinUsb_ReadPipe(parent_winusb_interface()->winusb_handle(), + endpoint_id(), + reinterpret_cast(buffer), + bytes_to_transfer, + &transferred, + sdb_io_completion->overlapped()) : + WinUsb_WritePipe(parent_winusb_interface()->winusb_handle(), + endpoint_id(), + reinterpret_cast(buffer), + bytes_to_transfer, + &transferred, + sdb_io_completion->overlapped()); + + if (NULL != bytes_transferred) + *bytes_transferred = transferred; + + ULONG error = GetLastError(); + if (!res && (ERROR_IO_PENDING != error)) { + // I/O failed immediatelly. We need to close i/o completion object + // before we return NULL to the caller. + sdb_io_completion->CloseHandle(); + ret = NULL; + SetLastError(error); + } + } + + // Offseting 'new' + sdb_io_completion->Release(); + + return ret; +} + +bool SdbWinUsbEndpointObject::CommonSyncReadWrite(bool is_read, + void* buffer, + ULONG bytes_to_transfer, + ULONG* bytes_transferred, + ULONG time_out) { + if (!SetTimeout(time_out)) + return false; + + // This is synchronous I/O. Since we always open I/O items for + // overlapped I/O we're obligated to always provide OVERLAPPED + // structure to read / write routines. Prepare it now. + OVERLAPPED overlapped; + ZeroMemory(&overlapped, sizeof(overlapped)); + overlapped.hEvent = CreateEvent(NULL, TRUE, FALSE, NULL); + + BOOL ret = TRUE; + ULONG transferred = 0; + // Go the read / write file way + ret = is_read ? + WinUsb_ReadPipe(parent_winusb_interface()->winusb_handle(), + endpoint_id(), + reinterpret_cast(buffer), + bytes_to_transfer, + &transferred, + &overlapped) : + WinUsb_WritePipe(parent_winusb_interface()->winusb_handle(), + endpoint_id(), + reinterpret_cast(buffer), + bytes_to_transfer, + &transferred, + &overlapped); + + // Lets see the result + if (!ret && (ERROR_IO_PENDING != GetLastError())) { + // I/O failed. + if (NULL != overlapped.hEvent) + ::CloseHandle(overlapped.hEvent); + return false; + } + + // Lets wait till I/O completes + ret = WinUsb_GetOverlappedResult(parent_winusb_interface()->winusb_handle(), &overlapped, + &transferred, TRUE); + if (ret && (NULL != bytes_transferred)) { + *bytes_transferred = transferred; + } + + if (NULL != overlapped.hEvent) + ::CloseHandle(overlapped.hEvent); + + return ret ? true : false; +} + +bool SdbWinUsbEndpointObject::SetTimeout(ULONG timeout) { + if (!WinUsb_SetPipePolicy(parent_winusb_interface()->winusb_handle(), + endpoint_id(), PIPE_TRANSFER_TIMEOUT, + sizeof(ULONG), &timeout)) { + return false; + } + + return true; +} diff --git a/src/sdbwinusbapi/sdb_winusb_endpoint_object.h b/src/sdbwinusbapi/sdb_winusb_endpoint_object.h new file mode 100644 index 0000000..bd7b38b --- /dev/null +++ b/src/sdbwinusbapi/sdb_winusb_endpoint_object.h @@ -0,0 +1,155 @@ +/* + * Copyright (C) 2009 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 ANDROID_USB_API_SDB_WINUSB_ENDPOINT_OBJECT_H__ +#define ANDROID_USB_API_SDB_WINUSB_ENDPOINT_OBJECT_H__ +/** \file + This file consists of declaration of class SdbWinUsbEndpointObject that + encapsulates a handle opened to a WinUsb endpoint on our device. +*/ + +#include "..\sdbwinapi\sdb_endpoint_object.h" +#include "sdb_winusb_interface.h" + +/** Class SdbWinUsbEndpointObject encapsulates a handle opened to an endpoint on + our device. +*/ +class SdbWinUsbEndpointObject : public SdbEndpointObject { + public: + /** \brief Constructs the object + + @param[in] interface Parent WinUsb interface for this object. + @param[in] endpoint_id Endpoint ID (endpoint address) on the device. + @param[in] endpoint_index Zero-based endpoint index in the interface's + array of endpoints. + */ + SdbWinUsbEndpointObject(SdbWinUsbInterfaceObject* parent_interf, + UCHAR endpoint_id, + UCHAR endpoint_index); + + protected: + /** \brief Destructs the object. + + We hide destructor in order to prevent ourseves from accidentaly allocating + instances on the stack. If such attemp occur, compiler will error. + */ + virtual ~SdbWinUsbEndpointObject(); + + // + // Virtual overrides + // + + public: + /** \brief Releases the object. + + If refcount drops to zero as the result of this release, the object is + destroyed in this method. As a general rule, objects must not be touched + after this method returns even if returned value is not zero. We override + this method in order to make sure that objects of this class are deleted + in contect of the DLL they were created in. The problem is that since + objects of this class were created in context of SdbWinUsbApi module, they + are allocated from the heap assigned to that module. Now, if these objects + are deleted outside of SdbWinUsbApi module, this will lead to the heap + corruption in the module that deleted these objects. Since all objects of + this class are deleted in the Release method only, by overriding it we make + sure that we free memory in the context of the module where it was + allocated. + @return Value of the reference counter after object is released in this + method. + */ + virtual LONG Release(); + + // + // Abstract overrides + // + + protected: + /** \brief Common code for async read / write + + @param[in] is_read Read or write selector. + @param[in,out] buffer Pointer to the buffer for read / write. + @param[in] bytes_to_transfer Number of bytes to be read / written. + @param[out] bytes_transferred Number of bytes read / written. Can be NULL. + @param[in] event_handle Event handle that should be signaled when async I/O + completes. Can be NULL. If it's not NULL this handle will be used to + initialize OVERLAPPED structure for this I/O. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value in this parameter means that there is no + timeout set for this I/O. + @return A handle to IO completion object or NULL on failure. If NULL is + returned GetLastError() provides extended error information. + */ + virtual SDBAPIHANDLE CommonAsyncReadWrite(bool is_read, + void* buffer, + ULONG bytes_to_transfer, + ULONG* bytes_transferred, + HANDLE event_handle, + ULONG time_out); + + /** \brief Common code for sync read / write + + @param[in] is_read Read or write selector. + @param[in,out] buffer Pointer to the buffer for read / write. + @param[in] bytes_to_transfer Number of bytes to be read / written. + @param[out] bytes_transferred Number of bytes read / written. Can be NULL. + @param[in] time_out A timeout (in milliseconds) required for this I/O to + complete. Zero value in this parameter means that there is no + timeout set for this I/O. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool CommonSyncReadWrite(bool is_read, + void* buffer, + ULONG bytes_to_transfer, + ULONG* bytes_transferred, + ULONG time_out); + + // + // Operations + // + + protected: + /** \brief Sets read / write operation timeout. + + @param[in] timeout Timeout value in milliseconds to use for current read + or write operation. Zero value passed in this parameters indicate + not timeout at all. Note that timeout that is set with this method is + global per endpoint (pipe). I.e. once set, it will be used against + all read / write operations performed on this endpoint, untill + another call to this method modifies it. This is a WinUsb design + flaw. Microsoft is aware of this and (hopefuly) future versions of + WinUsb framework will accept a timeout parameter in WinUsb_Read/Write + routines. For the purposes of SDB this flaw doesn't apperar to be an + issue, since we use single-threaded synchronous read / writes, so + there is no conflict in setting per-endpoint timeouts. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool SetTimeout(ULONG timeout); + + public: + /// Gets parent WinUsb interface + SdbWinUsbInterfaceObject* parent_winusb_interface() const { + return reinterpret_cast(parent_interface()); + } + + /// Gets parent interface WinUsb handle + WINUSB_INTERFACE_HANDLE winusb_handle() const { + return parent_winusb_interface()->winusb_handle(); + } +}; + +#endif // ANDROID_USB_API_SDB_WINUSB_ENDPOINT_OBJECT_H__ diff --git a/src/sdbwinusbapi/sdb_winusb_interface.cpp b/src/sdbwinusbapi/sdb_winusb_interface.cpp new file mode 100644 index 0000000..3fcdce7 --- /dev/null +++ b/src/sdbwinusbapi/sdb_winusb_interface.cpp @@ -0,0 +1,340 @@ +/* + * Copyright (C) 2009 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. + */ + +/** \file + This file consists of implementation of class SdbWinUsbInterfaceObject + that encapsulates an interface on our USB device that is accessible + via WinUsb API. +*/ + +#include "stdafx.h" +#include "sdb_winusb_interface.h" +#include "sdb_winusb_endpoint_object.h" + +SdbWinUsbInterfaceObject::SdbWinUsbInterfaceObject(const wchar_t* interf_name) + : SdbInterfaceObject(interf_name), + usb_device_handle_(INVALID_HANDLE_VALUE), + winusb_handle_(NULL), + interface_number_(0xFF), + def_read_endpoint_(0xFF), + read_endpoint_id_(0xFF), + def_write_endpoint_(0xFF), + write_endpoint_id_(0xFF) { +} + +SdbWinUsbInterfaceObject::~SdbWinUsbInterfaceObject() { + ATLASSERT(NULL == winusb_handle_); + ATLASSERT(INVALID_HANDLE_VALUE == usb_device_handle_); +} + +LONG SdbWinUsbInterfaceObject::Release() { + ATLASSERT(ref_count_ > 0); + LONG ret = InterlockedDecrement(&ref_count_); + ATLASSERT(ret >= 0); + if (0 == ret) { + LastReferenceReleased(); + delete this; + } + return ret; +} + +SDBAPIHANDLE SdbWinUsbInterfaceObject::CreateHandle() { + // Open USB device for this inteface Note that WinUsb API + // requires the handle to be opened for overlapped I/O. + usb_device_handle_ = CreateFile(interface_name().c_str(), + GENERIC_READ | GENERIC_WRITE, + FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, OPEN_EXISTING, + FILE_FLAG_OVERLAPPED, NULL); + if (INVALID_HANDLE_VALUE == usb_device_handle_) + return NULL; + + // Initialize WinUSB API for this interface + if (!WinUsb_Initialize(usb_device_handle_, &winusb_handle_)) + return NULL; + + // Cache current interface number that will be used in + // WinUsb_Xxx calls performed on this interface. + if (!WinUsb_GetCurrentAlternateSetting(winusb_handle(), &interface_number_)) + return false; + + // Cache interface properties + unsigned long bytes_written; + + // Cache USB device descriptor + if (!WinUsb_GetDescriptor(winusb_handle(), USB_DEVICE_DESCRIPTOR_TYPE, 0, 0, + reinterpret_cast(&usb_device_descriptor_), + sizeof(usb_device_descriptor_), &bytes_written)) { + return false; + } + + // Cache USB configuration descriptor + if (!WinUsb_GetDescriptor(winusb_handle(), USB_CONFIGURATION_DESCRIPTOR_TYPE, + 0, 0, + reinterpret_cast(&usb_config_descriptor_), + sizeof(usb_config_descriptor_), &bytes_written)) { + return false; + } + + // Cache USB interface descriptor + if (!WinUsb_QueryInterfaceSettings(winusb_handle(), interface_number(), + &usb_interface_descriptor_)) { + return false; + } + + // Save indexes and IDs for bulk read / write endpoints. We will use them to + // convert SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX and + // SDB_QUERY_BULK_READ_ENDPOINT_INDEX into actual endpoint indexes and IDs. + for (UCHAR endpoint = 0; endpoint < usb_interface_descriptor_.bNumEndpoints; + endpoint++) { + // Get endpoint information + WINUSB_PIPE_INFORMATION pipe_info; + if (!WinUsb_QueryPipe(winusb_handle(), interface_number(), endpoint, + &pipe_info)) { + return false; + } + + if (UsbdPipeTypeBulk == pipe_info.PipeType) { + // This is a bulk endpoint. Cache its index and ID. + if (0 != (pipe_info.PipeId & USB_ENDPOINT_DIRECTION_MASK)) { + // Use this endpoint as default bulk read endpoint + ATLASSERT(0xFF == def_read_endpoint_); + def_read_endpoint_ = endpoint; + read_endpoint_id_ = pipe_info.PipeId; + } else { + // Use this endpoint as default bulk write endpoint + ATLASSERT(0xFF == def_write_endpoint_); + def_write_endpoint_ = endpoint; + write_endpoint_id_ = pipe_info.PipeId; + } + } + } + + return SdbInterfaceObject::CreateHandle(); +} + +bool SdbWinUsbInterfaceObject::CloseHandle() { + if (NULL != winusb_handle_) { + WinUsb_Free(winusb_handle_); + winusb_handle_ = NULL; + } + if (INVALID_HANDLE_VALUE != usb_device_handle_) { + ::CloseHandle(usb_device_handle_); + usb_device_handle_ = INVALID_HANDLE_VALUE; + } + + return SdbInterfaceObject::CloseHandle(); +} + +bool SdbWinUsbInterfaceObject::GetSerialNumber(void* buffer, + unsigned long* buffer_char_size, + bool ansi) { + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + if (NULL == buffer_char_size) { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + // Calculate serial number string size. Note that WinUsb_GetDescriptor + // API will not return number of bytes needed to store serial number + // string. So we will have to start with a reasonably large preallocated + // buffer and then loop through WinUsb_GetDescriptor calls, doubling up + // string buffer size every time ERROR_INSUFFICIENT_BUFFER is returned. + union { + // Preallocate reasonably sized buffer on the stack. + char small_buffer[64]; + USB_STRING_DESCRIPTOR initial_ser_num; + }; + USB_STRING_DESCRIPTOR* ser_num = &initial_ser_num; + // Buffer byte size + unsigned long ser_num_size = sizeof(small_buffer); + // After successful call to WinUsb_GetDescriptor will contain serial + // number descriptor size. + unsigned long bytes_written; + while (!WinUsb_GetDescriptor(winusb_handle(), USB_STRING_DESCRIPTOR_TYPE, + usb_device_descriptor_.iSerialNumber, + 0x0409, // English (US) + reinterpret_cast(ser_num), + ser_num_size, &bytes_written)) { + // Any error other than ERROR_INSUFFICIENT_BUFFER is terminal here. + if (ERROR_INSUFFICIENT_BUFFER != GetLastError()) { + if (ser_num != &initial_ser_num) + delete[] reinterpret_cast(ser_num); + return false; + } + + // Double up buffer size and reallocate string buffer + ser_num_size *= 2; + if (ser_num != &initial_ser_num) + delete[] reinterpret_cast(ser_num); + try { + ser_num = + reinterpret_cast(new char[ser_num_size]); + } catch (...) { + SetLastError(ERROR_OUTOFMEMORY); + return false; + } + } + + // Serial number string length + unsigned long str_len = (ser_num->bLength - + FIELD_OFFSET(USB_STRING_DESCRIPTOR, bString)) / + sizeof(wchar_t); + + // Lets see if requested buffer is big enough to fit the string + if ((NULL == buffer) || (*buffer_char_size < (str_len + 1))) { + // Requested buffer is too small. + if (ser_num != &initial_ser_num) + delete[] reinterpret_cast(ser_num); + *buffer_char_size = str_len + 1; + SetLastError(ERROR_INSUFFICIENT_BUFFER); + return false; + } + + bool ret = true; + if (ansi) { + // We need to convert name from wide char to ansi string + if (0 != WideCharToMultiByte(CP_ACP, 0, ser_num->bString, + static_cast(str_len), + reinterpret_cast(buffer), + static_cast(*buffer_char_size), + NULL, NULL)) { + // Zero-terminate output string. + reinterpret_cast(buffer)[str_len] = '\0'; + } else { + ret = false; + } + } else { + // For wide char output just copy string buffer, + // and zero-terminate output string. + CopyMemory(buffer, ser_num->bString, bytes_written); + reinterpret_cast(buffer)[str_len] = L'\0'; + } + + if (ser_num != &initial_ser_num) + delete[] reinterpret_cast(ser_num); + + return ret; +} + +bool SdbWinUsbInterfaceObject::GetEndpointInformation( + UCHAR endpoint_index, + SdbEndpointInformation* info) { + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + if (NULL == info) { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + // Get actual endpoint index for predefined read / write endpoints. + if (SDB_QUERY_BULK_READ_ENDPOINT_INDEX == endpoint_index) { + endpoint_index = def_read_endpoint_; + } else if (SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX == endpoint_index) { + endpoint_index = def_write_endpoint_; + } + + // Query endpoint information + WINUSB_PIPE_INFORMATION pipe_info; + if (!WinUsb_QueryPipe(winusb_handle(), interface_number(), endpoint_index, + &pipe_info)) { + return false; + } + + // Save endpoint information into output. + info->max_packet_size = pipe_info.MaximumPacketSize; + info->max_transfer_size = 0xFFFFFFFF; + info->endpoint_address = pipe_info.PipeId; + info->polling_interval = pipe_info.Interval; + info->setting_index = interface_number(); + switch (pipe_info.PipeType) { + case UsbdPipeTypeControl: + info->endpoint_type = SdbEndpointTypeControl; + break; + + case UsbdPipeTypeIsochronous: + info->endpoint_type = SdbEndpointTypeIsochronous; + break; + + case UsbdPipeTypeBulk: + info->endpoint_type = SdbEndpointTypeBulk; + break; + + case UsbdPipeTypeInterrupt: + info->endpoint_type = SdbEndpointTypeInterrupt; + break; + + default: + info->endpoint_type = SdbEndpointTypeInvalid; + break; + } + + return true; +} + +SDBAPIHANDLE SdbWinUsbInterfaceObject::OpenEndpoint( + UCHAR endpoint_index, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode) { + // Convert index into id + UCHAR endpoint_id; + + if ((SDB_QUERY_BULK_READ_ENDPOINT_INDEX == endpoint_index) || + (def_read_endpoint_ == endpoint_index)) { + endpoint_id = read_endpoint_id_; + endpoint_index = def_read_endpoint_; + } else if ((SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX == endpoint_index) || + (def_write_endpoint_ == endpoint_index)) { + endpoint_id = write_endpoint_id_; + endpoint_index = def_write_endpoint_; + } else { + SetLastError(ERROR_INVALID_PARAMETER); + return false; + } + + return OpenEndpoint(endpoint_id, endpoint_index); +} + +SDBAPIHANDLE SdbWinUsbInterfaceObject::OpenEndpoint(UCHAR endpoint_id, + UCHAR endpoint_index) { + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + SdbEndpointObject* sdb_endpoint = NULL; + + try { + sdb_endpoint = + new SdbWinUsbEndpointObject(this, endpoint_id, endpoint_index); + } catch (...) { + SetLastError(ERROR_OUTOFMEMORY); + return NULL; + } + + SDBAPIHANDLE ret = sdb_endpoint->CreateHandle(); + + sdb_endpoint->Release(); + + return ret; +} diff --git a/src/sdbwinusbapi/sdb_winusb_interface.h b/src/sdbwinusbapi/sdb_winusb_interface.h new file mode 100644 index 0000000..6a37996 --- /dev/null +++ b/src/sdbwinusbapi/sdb_winusb_interface.h @@ -0,0 +1,205 @@ +/* + * Copyright (C) 2009 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 ANDROID_USB_API_SDB_WINUSB_INTERFACE_H__ +#define ANDROID_USB_API_SDB_WINUSB_INTERFACE_H__ +/** \file + This file consists of declaration of class SdbWinUsbInterfaceObject + that encapsulates an interface on our USB device that is accessible + via WinUsb API. +*/ + +#include "..\sdbwinapi\sdb_interface.h" + +/** \brief Encapsulates an interface on our USB device that is accessible + via WinUsb API. +*/ +class SdbWinUsbInterfaceObject : public SdbInterfaceObject { + public: + /** \brief Constructs the object. + + @param[in] interf_name Name of the interface + */ + explicit SdbWinUsbInterfaceObject(const wchar_t* interf_name); + + protected: + /** \brief Destructs the object. + + We hide destructor in order to prevent ourseves from accidentaly allocating + instances on the stack. If such attemp occur, compiler will error. + */ + virtual ~SdbWinUsbInterfaceObject(); + + // + // Virtual overrides + // + + public: + /** \brief Releases the object. + + If refcount drops to zero as the result of this release, the object is + destroyed in this method. As a general rule, objects must not be touched + after this method returns even if returned value is not zero. We override + this method in order to make sure that objects of this class are deleted + in contect of the DLL they were created in. The problem is that since + objects of this class were created in context of SdbWinUsbApi module, they + are allocated from the heap assigned to that module. Now, if these objects + are deleted outside of SdbWinUsbApi module, this will lead to the heap + corruption in the module that deleted these objects. Since all objects of + this class are deleted in the Release method only, by overriding it we make + sure that we free memory in the context of the module where it was + allocated. + @return Value of the reference counter after object is released in this + method. + */ + virtual LONG Release(); + + /** \brief Creates handle to this object. + + In this call a handle for this object is generated and object is added + to the SdbObjectHandleMap. We override this method in order to initialize + WinUsb API for the given interface. + @return A handle to this object on success or NULL on an error. + If NULL is returned GetLastError() provides extended error + information. ERROR_GEN_FAILURE is set if an attempt was + made to create already opened object. + */ + virtual SDBAPIHANDLE CreateHandle(); + + /** \brief This method is called when handle to this object gets closed. + + In this call object is deleted from the SdbObjectHandleMap. We override + this method in order close WinUsb handle created in CreateHandle method + of this class. + @return true on success or false if object is already closed. If + false is returned GetLastError() provides extended error + information. + */ + virtual bool CloseHandle(); + + // + // Abstract overrides + // + + public: + /** \brief Gets serial number for interface's device. + + @param[out] buffer Buffer for the serail number string. Can be NULL in + which case buffer_char_size will contain number of characters + required for the string. + @param[in,out] buffer_char_size On the way in supplies size (in characters) + of the buffer. On the way out, if method failed and GetLastError + reports ERROR_INSUFFICIENT_BUFFER, will contain number of characters + required for the name. + @param[in] ansi If true the name will be returned as single character + string. Otherwise name will be returned as wide character string. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool GetSerialNumber(void* buffer, + unsigned long* buffer_char_size, + bool ansi); + + /** \brief Gets information about an endpoint on this interface. + + @param[in] endpoint_index Zero-based endpoint index. There are two + shortcuts for this parameter: SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX + and SDB_QUERY_BULK_READ_ENDPOINT_INDEX that provide infor about + (default?) bulk write and read endpoints respectively. + @param[out] info Upon successful completion will have endpoint information. + @return true on success, false on failure. If false is returned + GetLastError() provides extended error information. + */ + virtual bool GetEndpointInformation(UCHAR endpoint_index, + SdbEndpointInformation* info); + + /** \brief Opens an endpoint on this interface. + + @param[in] endpoint_index Zero-based endpoint index. There are two + shortcuts for this parameter: SDB_QUERY_BULK_WRITE_ENDPOINT_INDEX + and SDB_QUERY_BULK_READ_ENDPOINT_INDEX that provide infor about + (default?) bulk write and read endpoints respectively. + @param[in] access_type Desired access type. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always read / write access. + @param[in] sharing_mode Desired share mode. In the current implementation + this parameter has no effect on the way endpoint is opened. It's + always shared for read / write. + @return Handle to the opened endpoint object or NULL on failure. + If NULL is returned GetLastError() provides extended information + about the error that occurred. + */ + virtual SDBAPIHANDLE OpenEndpoint(UCHAR endpoint_index, + SdbOpenAccessType access_type, + SdbOpenSharingMode sharing_mode); + + // + // Operations + // + + protected: + /** \brief Opens an endpoint on this interface. + + @param[in] endpoint_id Endpoint (pipe) address on the device. + @param[in] endpoint_index Zero-based endpoint index. + @return Handle to the opened endpoint object or NULL on failure. + If NULL is returned GetLastError() provides extended information + about the error that occurred. + */ + SDBAPIHANDLE OpenEndpoint(UCHAR endpoint_id, UCHAR endpoint_index); + + public: + /// Gets handle to the USB device + HANDLE usb_device_handle() const { + return usb_device_handle_; + } + + /// Gets interface handle used by WinUSB API + WINUSB_INTERFACE_HANDLE winusb_handle() const { + return winusb_handle_; + } + + /// Gets current interface number. + UCHAR interface_number() const { + return interface_number_; + } + + protected: + /// Handle to the USB device + HANDLE usb_device_handle_; + + /// Interface handle used by WinUSB API + WINUSB_INTERFACE_HANDLE winusb_handle_; + + /// Current interface number. This value is obtained via call to + /// WinUsb_GetCurrentAlternateSetting and is used in WinUsb_Xxx + /// calls that require interface number. + UCHAR interface_number_; + + /// Index for the default bulk read endpoint + UCHAR def_read_endpoint_; + + /// ID for the default bulk read endpoint + UCHAR read_endpoint_id_; + + /// Index for the default bulk write endpoint + UCHAR def_write_endpoint_; + + /// ID for the default bulk write endpoint + UCHAR write_endpoint_id_; +}; + +#endif // ANDROID_USB_API_SDB_WINUSB_INTERFACE_H__ diff --git a/src/sdbwinusbapi/sdb_winusb_io_completion.cpp b/src/sdbwinusbapi/sdb_winusb_io_completion.cpp new file mode 100644 index 0000000..283f689 --- /dev/null +++ b/src/sdbwinusbapi/sdb_winusb_io_completion.cpp @@ -0,0 +1,98 @@ +/* + * Copyright (C) 2009 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. + */ + +/** \file + This file consists of implementation of class SdbWinUsbIOCompletion that + encapsulates a wrapper around OVERLAPPED Win32 structure returned from + asynchronous I/O requests issued via WinUsb API. +*/ + +#include "stdafx.h" +#include "sdb_winusb_io_completion.h" + +SdbWinUsbIOCompletion::SdbWinUsbIOCompletion( + SdbWinUsbEndpointObject* parent_io_obj, + ULONG expected_trans_size, + HANDLE event_hndl) + : SdbIOCompletion(parent_io_obj, expected_trans_size, event_hndl) { +} + +SdbWinUsbIOCompletion::~SdbWinUsbIOCompletion() { +} + +LONG SdbWinUsbIOCompletion::Release() { + ATLASSERT(ref_count_ > 0); + LONG ret = InterlockedDecrement(&ref_count_); + ATLASSERT(ret >= 0); + if (0 == ret) { + LastReferenceReleased(); + delete this; + } + return ret; +} + +bool SdbWinUsbIOCompletion::GetOvelappedIoResult(LPOVERLAPPED ovl_data, + ULONG* bytes_transferred, + bool wait) { + if (NULL != bytes_transferred) { + *bytes_transferred = 0; + } + + if (!IsOpened()) { + SetLastError(ERROR_INVALID_HANDLE); + return false; + } + + ULONG transfer; + bool ret = WinUsb_GetOverlappedResult( + parent_winusb_io_object()->winusb_handle(), + overlapped(), + &transfer, + wait ? TRUE : FALSE) ? true : false; + + // TODO: This is bizzare but I've seen it happening + // that GetOverlappedResult with wait set to true returns "prematurely", + // with wrong transferred bytes value and GetLastError reporting + // ERROR_IO_PENDING. So, lets give it an up to a 20 ms loop! + ULONG error = GetLastError(); + + if (wait && ret && (0 == transfer) && (0 != expected_transfer_size_) && + ((ERROR_IO_INCOMPLETE == error) || (ERROR_IO_PENDING == error))) { + for (int trying = 0; trying < 10; trying++) { + Sleep(2); + ret = WinUsb_GetOverlappedResult( + parent_winusb_io_object()->winusb_handle(), + overlapped(), + &transfer, + wait ? TRUE : FALSE) ? true : false; + error = GetLastError(); + if (!ret || (0 != transfer) || + ((ERROR_IO_INCOMPLETE != error) && (ERROR_IO_PENDING != error))) { + break; + } + } + } + + if (NULL != ovl_data) { + CopyMemory(ovl_data, overlapped(), sizeof(OVERLAPPED)); + } + + if (NULL != bytes_transferred) { + *bytes_transferred = transfer; + } + + return ret; +} diff --git a/src/sdbwinusbapi/sdb_winusb_io_completion.h b/src/sdbwinusbapi/sdb_winusb_io_completion.h new file mode 100644 index 0000000..e75a7b2 --- /dev/null +++ b/src/sdbwinusbapi/sdb_winusb_io_completion.h @@ -0,0 +1,118 @@ +/* + * Copyright (C) 2009 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 ANDROID_USB_API_SDB_WINUSB_IO_COMPLETION_H__ +#define ANDROID_USB_API_SDB_WINUSB_IO_COMPLETION_H__ +/** \file + This file consists of declaration of class SdbWinUsbIOCompletion that + encapsulates a wrapper around OVERLAPPED Win32 structure returned from + asynchronous I/O requests issued via WinUsb API. +*/ + +#include "..\sdbwinapi\sdb_io_completion.h" +#include "sdb_winusb_endpoint_object.h" + +/** \brief Encapsulates encapsulates a wrapper around OVERLAPPED Win32 + structure returned from asynchronous I/O requests issued via WinUsb API. + + A handle to this object is returned to the caller of each successful + asynchronous I/O request. Just like all other handles this handle + must be closed after it's no longer needed. +*/ +class SdbWinUsbIOCompletion : public SdbIOCompletion { + public: + /** \brief Constructs the object + + @param[in] parent_io_obj Parent WinUsb I/O object that created this + instance. + @param[in] expected_trans_size Number of bytes expected to be transferred + with the I/O. + @param[in] event_hndl Event handle that should be signaled when I/O + completes. Can be NULL. If it's not NULL this handle will be + used to initialize OVERLAPPED structure for this object. + */ + SdbWinUsbIOCompletion(SdbWinUsbEndpointObject* parent_io_obj, + ULONG expected_trans_size, + HANDLE event_hndl); + + protected: + /** \brief Destructs the object. + + We hide destructor in order to prevent ourseves from accidentaly allocating + instances on the stack. If such attemp occur, compiler will error. + */ + virtual ~SdbWinUsbIOCompletion(); + + // + // Virtual overrides + // + + public: + /** \brief Releases the object. + + If refcount drops to zero as the result of this release, the object is + destroyed in this method. As a general rule, objects must not be touched + after this method returns even if returned value is not zero. We override + this method in order to make sure that objects of this class are deleted + in contect of the DLL they were created in. The problem is that since + objects of this class were created in context of SdbWinUsbApi module, they + are allocated from the heap assigned to that module. Now, if these objects + are deleted outside of SdbWinUsbApi module, this will lead to the heap + corruption in the module that deleted these objects. Since all objects of + this class are deleted in the Release method only, by overriding it we make + sure that we free memory in the context of the module where it was + allocated. + @return Value of the reference counter after object is released in this + method. + */ + virtual LONG Release(); + + // + // Abstract overrides + // + + public: + /** \brief Gets overlapped I/O result + + This method uses WinUsb_GetOverlappedResult to get results of the + overlapped I/O operation. + @param[out] ovl_data Buffer for the copy of this object's OVERLAPPED + structure. Can be NULL. + @param[out] bytes_transferred Pointer to a variable that receives the + number of bytes that were actually transferred by a read or write + operation. See SDK doc on GetOvelappedResult for more information. + Unlike regular GetOvelappedResult call this parameter can be NULL. + @param[in] wait If this parameter is true, the method does not return + until the operation has been completed. If this parameter is false + and the operation is still pending, the method returns false and + the GetLastError function returns ERROR_IO_INCOMPLETE. + @return true if I/O has been completed or false on failure or if request + is not yet completed. If false is returned GetLastError() provides + extended error information. If GetLastError returns + ERROR_IO_INCOMPLETE it means that I/O is not yet completed. + */ + virtual bool GetOvelappedIoResult(LPOVERLAPPED ovl_data, + ULONG* bytes_transferred, + bool wait); + + public: + /// Gets WinUsb parent object + SdbWinUsbEndpointObject* parent_winusb_io_object() const { + return reinterpret_cast(parent_io_object()); + } +}; + +#endif // ANDROID_USB_API_SDB_WINUSB_IO_COMPLETION_H__ diff --git a/src/sdbwinusbapi/stdafx.cpp b/src/sdbwinusbapi/stdafx.cpp new file mode 100644 index 0000000..83c6e13 --- /dev/null +++ b/src/sdbwinusbapi/stdafx.cpp @@ -0,0 +1,21 @@ +/* + * Copyright (C) 2009 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. + */ + +// stdafx.cpp : source file that includes just the standard includes +// SdbWinUsbApi.pch will be the pre-compiled header +// stdafx.obj will contain the pre-compiled type information + +#include "stdafx.h" diff --git a/src/sdbwinusbapi/stdafx.h b/src/sdbwinusbapi/stdafx.h new file mode 100644 index 0000000..88cd963 --- /dev/null +++ b/src/sdbwinusbapi/stdafx.h @@ -0,0 +1,78 @@ +/* + * Copyright (C) 2009 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. + */ + +/** \file + Visual Studio generated include file for standard system include files, or + project specific include files that are used frequently, but are changed + infrequently. +*/ + +#pragma once + +#ifndef STRICT +#define STRICT +#endif + +// Modify the following defines if you have to target a platform prior to the ones specified below. +// Refer to MSDN for the latest info on corresponding values for different platforms. +#ifndef WINVER // Allow use of features specific to Windows 95 and Windows NT 4 or later. +#define WINVER 0x0500 // Change this to the appropriate value to target Windows 98 and Windows 2000 or later. +#endif + +#ifndef _WIN32_WINNT // Allow use of features specific to Windows NT 4 or later. +#define _WIN32_WINNT 0x0500 // Change this to the appropriate value to target Windows 2000 or later. +#endif + +#ifndef _WIN32_WINDOWS // Allow use of features specific to Windows 98 or later. +#define _WIN32_WINDOWS 0x0500 // Change this to the appropriate value to target Windows Me or later. +#endif + +#ifndef _WIN32_IE // Allow use of features specific to IE 4.0 or later. +#define _WIN32_IE 0x0501 // Change this to the appropriate value to target IE 5.0 or later. +#endif + +// These defines prevent the MS header files from ejecting #pragma comment +// statements with the manifest information of the used ATL, STL, and CRT +#define _ATL_NOFORCE_MANIFEST +#define _STL_NOFORCE_MANIFEST +#define _CRT_NOFORCE_MANIFEST + +#define _ATL_APARTMENT_THREADED +#define _ATL_NO_AUTOMATIC_NAMESPACE + +#define _ATL_CSTRING_EXPLICIT_CONSTRUCTORS // some CString constructors will be explicit + +// turns off ATL's hiding of some common and often safely ignored warning messages +#define _ATL_ALL_WARNINGS + +// #define WIN32_LEAN_AND_MEAN // Exclude rarely-used stuff from Windows headers + +#include +#pragma warning(disable: 4702) +#pragma warning(disable: 4201) +#include +#include +#include +#include +#include +#include +#pragma warning(default: 4201) +#pragma warning(disable: 4200) +#include + +#include "resource.h" + +using namespace ATL; diff --git a/src/services.c b/src/services.c new file mode 100644 index 0000000..53a3eec --- /dev/null +++ b/src/services.c @@ -0,0 +1,503 @@ +/* + * 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 "sysdeps.h" + +#define TRACE_TAG TRACE_SDB +#include "sdb.h" +#include "file_sync_service.h" + +#if SDB_HOST +# ifndef HAVE_WINSOCK +# include +# include +# endif +#else +//# include eric +#endif + +#define PROCESS_WORKING_DIRECTORY "/" + +typedef struct stinfo stinfo; + +struct stinfo { + void (*func)(int fd, void *cookie); + int fd; + void *cookie; +}; + + +void *service_bootstrap_func(void *x) +{ + stinfo *sti = x; + sti->func(sti->fd, sti->cookie); + free(sti); + return 0; +} + +#if SDB_HOST +SDB_MUTEX_DEFINE( dns_lock ); + +static void dns_service(int fd, void *cookie) +{ + char *hostname = cookie; + struct hostent *hp; + unsigned zero = 0; + + sdb_mutex_lock(&dns_lock); + hp = gethostbyname(hostname); + free(cookie); + if(hp == 0) { + writex(fd, &zero, 4); + } else { + writex(fd, hp->h_addr, 4); + } + sdb_mutex_unlock(&dns_lock); + sdb_close(fd); +} +#else +extern int recovery_mode; + +static void recover_service(int s, void *cookie) +{ + unsigned char buf[4096]; + unsigned count = (unsigned) cookie; + int fd; + + fd = sdb_creat("/tmp/update", 0644); + if(fd < 0) { + sdb_close(s); + return; + } + + while(count > 0) { + unsigned xfer = (count > 4096) ? 4096 : count; + if(readx(s, buf, xfer)) break; + if(writex(fd, buf, xfer)) break; + count -= xfer; + } + + if(count == 0) { + writex(s, "OKAY", 4); + } else { + writex(s, "FAIL", 4); + } + sdb_close(fd); + sdb_close(s); + + fd = sdb_creat("/tmp/update.begin", 0644); + sdb_close(fd); +} +#if 0 //eric +void restart_root_service(int fd, void *cookie) +{ + char buf[100]; + char value[PROPERTY_VALUE_MAX]; + + if (getuid() == 0) { + snprintf(buf, sizeof(buf), "sdbd is already running as root\n"); + writex(fd, buf, strlen(buf)); + sdb_close(fd); + } else { + property_get("ro.debuggable", value, ""); + if (strcmp(value, "1") != 0) { + snprintf(buf, sizeof(buf), "sdbd cannot run as root in production builds\n"); + writex(fd, buf, strlen(buf)); + sdb_close(fd); + return; + } + + property_set("service.sdb.root", "1"); + snprintf(buf, sizeof(buf), "restarting sdbd as root\n"); + writex(fd, buf, strlen(buf)); + sdb_close(fd); + + // quit, and init will restart us as root + sleep(1); + exit(1); + } +} + +void restart_tcp_service(int fd, void *cookie) +{ + char buf[100]; + char value[PROPERTY_VALUE_MAX]; + int port = (int)cookie; + + if (port <= 0) { + snprintf(buf, sizeof(buf), "invalid port\n"); + writex(fd, buf, strlen(buf)); + sdb_close(fd); + return; + } + + snprintf(value, sizeof(value), "%d", port); + property_set("service.sdb.tcp.port", value); + snprintf(buf, sizeof(buf), "restarting in TCP mode port: %d\n", port); + writex(fd, buf, strlen(buf)); + sdb_close(fd); + + // quit, and init will restart us in TCP mode + sleep(1); + exit(1); +} + +void restart_usb_service(int fd, void *cookie) +{ + char buf[100]; + + property_set("service.sdb.tcp.port", "0"); + snprintf(buf, sizeof(buf), "restarting in USB mode\n"); + writex(fd, buf, strlen(buf)); + sdb_close(fd); + + // quit, and init will restart us in USB mode + sleep(1); + exit(1); +} + +#endif +void reboot_service(int fd, void *arg) +{ + char buf[100]; + int pid, ret; + + sync(); + + /* Attempt to unmount the SD card first. + * No need to bother checking for errors. + */ + pid = fork(); + if (pid == 0) { + /* ask vdc to unmount it */ + execl("/system/bin/vdc", "/system/bin/vdc", "volume", "unmount", + getenv("EXTERNAL_STORAGE"), "force", NULL); + } else if (pid > 0) { + /* wait until vdc succeeds or fails */ + waitpid(pid, &ret, 0); + } + +// ret = __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, +// LINUX_REBOOT_CMD_RESTART2, (char *)arg); + if (ret < 0) { + snprintf(buf, sizeof(buf), "reboot failed: %s\n", strerror(errno)); + writex(fd, buf, strlen(buf)); + } + free(arg); + sdb_close(fd); +} + +#endif + +#if 0 +static void echo_service(int fd, void *cookie) +{ + char buf[4096]; + int r; + char *p; + int c; + + for(;;) { + r = read(fd, buf, 4096); + if(r == 0) goto done; + if(r < 0) { + if(errno == EINTR) continue; + else goto done; + } + + c = r; + p = buf; + while(c > 0) { + r = write(fd, p, c); + if(r > 0) { + c -= r; + p += r; + continue; + } + if((r < 0) && (errno == EINTR)) continue; + goto done; + } + } +done: + close(fd); +} +#endif + +static int create_service_thread(void (*func)(int, void *), void *cookie) +{ + stinfo *sti; + sdb_thread_t t; + int s[2]; + + if(sdb_socketpair(s)) { + printf("cannot create service socket pair\n"); + return -1; + } + + sti = malloc(sizeof(stinfo)); + if(sti == 0) fatal("cannot allocate stinfo"); + sti->func = func; + sti->cookie = cookie; + sti->fd = s[1]; + + if(sdb_thread_create( &t, service_bootstrap_func, sti)){ + free(sti); + sdb_close(s[0]); + sdb_close(s[1]); + printf("cannot create service thread\n"); + return -1; + } + + D("service thread started, %d:%d\n",s[0], s[1]); + return s[0]; +} + +static int create_subprocess(const char *cmd, const char *arg0, const char *arg1) +{ +#ifdef HAVE_WIN32_PROC + fprintf(stderr, "error: create_subprocess not implemented on Win32 (%s %s %s)\n", cmd, arg0, arg1); + return -1; +#else /* !HAVE_WIN32_PROC */ + char *devname; + int ptm; + pid_t pid; + + ptm = unix_open("/dev/ptmx", O_RDWR); // | O_NOCTTY); + if(ptm < 0){ + printf("[ cannot open /dev/ptmx - %s ]\n",strerror(errno)); + return -1; + } + fcntl(ptm, F_SETFD, FD_CLOEXEC); + + if(grantpt(ptm) || unlockpt(ptm) || + ((devname = (char*) ptsname(ptm)) == 0)){ + printf("[ trouble with /dev/ptmx - %s ]\n", strerror(errno)); + return -1; + } + + pid = fork(); + if(pid < 0) { + printf("- fork failed: %s -\n", strerror(errno)); + return -1; + } + + if(pid == 0){ + int pts; + + setsid(); + chdir(PROCESS_WORKING_DIRECTORY); + + pts = unix_open(devname, O_RDWR); + if(pts < 0) exit(-1); + + dup2(pts, 0); + dup2(pts, 1); + dup2(pts, 2); + + sdb_close(ptm); + + execl(cmd, cmd, arg0, arg1, NULL); + fprintf(stderr, "- exec '%s' failed: %s (%d) -\n", + cmd, strerror(errno), errno); + exit(-1); + } else { +#if !SDB_HOST + // set child's OOM adjustment to zero + char text[64]; + snprintf(text, sizeof text, "/proc/%d/oom_adj", pid); + int fd = sdb_open(text, O_WRONLY); + if (fd >= 0) { + sdb_write(fd, "0", 1); + sdb_close(fd); + } else { + D("sdb: unable to open %s\n", text); + } +#endif + return ptm; + } +#endif /* !HAVE_WIN32_PROC */ +} + +//#if SDB_HOST +#define SHELL_COMMAND "/bin/sh" +//#else +//#define SHELL_COMMAND "/system/bin/sh" +//#endif + +int service_to_fd(const char *name) +{ + int ret = -1; + + if(!strncmp(name, "tcp:", 4)) { + int port = atoi(name + 4); + name = strchr(name + 4, ':'); + if(name == 0) { + ret = socket_loopback_client(port, SOCK_STREAM); + if (ret >= 0) + disable_tcp_nagle(ret); + } else { +#if SDB_HOST + sdb_mutex_lock(&dns_lock); + ret = socket_network_client(name + 1, port, SOCK_STREAM); + sdb_mutex_unlock(&dns_lock); +#else + return -1; +#endif + } +#ifndef HAVE_WINSOCK /* 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 SDB_HOST + } else if(!strncmp("dns:", name, 4)){ + char *n = strdup(name + 4); + if(n == 0) return -1; + ret = create_service_thread(dns_service, n); +#else /* !SDB_HOST */ + } else if(!strncmp("dev:", name, 4)) { + ret = unix_open(name + 4, O_RDWR); + } else if(!strncmp(name, "framebuffer:", 12)) { + ret = create_service_thread(framebuffer_service, 0); + } else if(recovery_mode && !strncmp(name, "recover:", 8)) { + ret = create_service_thread(recover_service, (void*) atoi(name + 8)); + } else if (!strncmp(name, "jdwp:", 5)) { + ret = create_jdwp_connection_fd(atoi(name+5)); +#if 0 // eric + } else if (!strncmp(name, "log:", 4)) { + ret = create_service_thread(log_service, get_log_file_path(name + 4)); +#endif +#endif + } else if(!HOST && !strncmp(name, "shell:", 6)) { + if(name[6]) { + ret = create_subprocess(SHELL_COMMAND, "-c", name + 6); + } else { + ret = create_subprocess(SHELL_COMMAND, "-", 0); + } +#if !SDB_HOST + } else if(!strncmp(name, "sync:", 5)) { + ret = create_service_thread(file_sync_service, NULL); +#if 0 //eric + } else if(!strncmp(name, "remount:", 8)) { + ret = create_service_thread(remount_service, NULL); +#endif + } else if(!strncmp(name, "reboot:", 7)) { + void* arg = strdup(name + 7); + if(arg == 0) return -1; + ret = create_service_thread(reboot_service, arg); +#if 0 //eric + } else if(!strncmp(name, "root:", 5)) { + ret = create_service_thread(restart_root_service, NULL); + } else if(!strncmp(name, "tcpip:", 6)) { + int port; + if (sscanf(name + 6, "%d", &port) == 0) { + port = 0; + } + ret = create_service_thread(restart_tcp_service, (void *)port); + } else if(!strncmp(name, "usb:", 4)) { + ret = create_service_thread(restart_usb_service, NULL); +#endif +#endif +#if 0 + } else if(!strncmp(name, "echo:", 5)){ + ret = create_service_thread(echo_service, 0); +#endif + } + if (ret >= 0) { + close_on_exec(ret); + } + return ret; +} + +#if SDB_HOST +struct state_info { + transport_type transport; + char* serial; + int state; +}; + +static void wait_for_state(int fd, void* cookie) +{ + struct state_info* sinfo = cookie; + char* err = "unknown error"; + + D("wait_for_state %d\n", sinfo->state); + + atransport *t = acquire_one_transport(sinfo->state, sinfo->transport, sinfo->serial, &err); + if(t != 0) { + writex(fd, "OKAY", 4); + } else { + sendfailmsg(fd, err); + } + + if (sinfo->serial) + free(sinfo->serial); + free(sinfo); + sdb_close(fd); + D("wait_for_state is done\n"); +} +#endif + +#if SDB_HOST +asocket* host_service_to_socket(const char* name, const char *serial) +{ + if (!strcmp(name,"track-devices")) { + return create_device_tracker(); + } else if (!strncmp(name, "wait-for-", strlen("wait-for-"))) { + struct state_info* sinfo = malloc(sizeof(struct state_info)); + + if (serial) + sinfo->serial = strdup(serial); + else + sinfo->serial = NULL; + + name += strlen("wait-for-"); + + if (!strncmp(name, "local", strlen("local"))) { + sinfo->transport = kTransportLocal; + sinfo->state = CS_DEVICE; + } else if (!strncmp(name, "usb", strlen("usb"))) { + sinfo->transport = kTransportUsb; + sinfo->state = CS_DEVICE; + } else if (!strncmp(name, "any", strlen("any"))) { + sinfo->transport = kTransportAny; + sinfo->state = CS_DEVICE; + } else { + free(sinfo); + return NULL; + } + + int fd = create_service_thread(wait_for_state, sinfo); + return create_local_socket(fd); + } + return NULL; +} +#endif /* SDB_HOST */ diff --git a/src/socket_inaddr_any_server.c b/src/socket_inaddr_any_server.c new file mode 100644 index 0000000..1879822 --- /dev/null +++ b/src/socket_inaddr_any_server.c @@ -0,0 +1,69 @@ +/* libs/cutils/socket_inaddr_any_server.c +** +** Copyright 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. +*/ + +#include "sockets.h" + +#include +#include +#include +#include +#include + +#ifndef HAVE_WINSOCK +#include +#include +#include +#include +#endif + +#define LISTEN_BACKLOG 4 + +/* open listen() port on any interface */ +int socket_inaddr_any_server(int port, int type) +{ + struct sockaddr_in addr; + int s, n; + + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + addr.sin_addr.s_addr = htonl(INADDR_ANY); + + s = socket(AF_INET, type, 0); + if(s < 0) return -1; + + n = 1; + setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(n)); + + if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) { + close(s); + return -1; + } + + if (type == SOCK_STREAM) { + int ret; + + ret = listen(s, LISTEN_BACKLOG); + + if (ret < 0) { + close(s); + return -1; + } + } + + return s; +} diff --git a/src/socket_local.h b/src/socket_local.h new file mode 100644 index 0000000..45b9856 --- /dev/null +++ b/src/socket_local.h @@ -0,0 +1,39 @@ +/* + * 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 __SOCKET_LOCAL_H +#define __SOCKET_LOCAL_H + +#define FILESYSTEM_SOCKET_PREFIX "/tmp/" +#define ANDROID_RESERVED_SOCKET_PREFIX "/dev/socket/" + +/* + * Set up a given sockaddr_un, to have it refer to the given + * name in the given namespace. The namespace must be one + * of ANDROID_SOCKET_NAMESPACE_ABSTRACT, + * ANDROID_SOCKET_NAMESPACE_RESERVED, or + * ANDROID_SOCKET_NAMESPACE_FILESYSTEM. Upon success, + * the pointed at sockaddr_un is filled in and the pointed at + * socklen_t is set to indicate the final length. This function + * will fail if the namespace is invalid (not one of the indicated + * constants) or if the name is too long. + * + * @return 0 on success or -1 on failure + */ +int socket_make_sockaddr_un(const char *name, int namespaceId, + struct sockaddr_un *p_addr, socklen_t *alen); + +#endif diff --git a/src/socket_local_client.c b/src/socket_local_client.c new file mode 100644 index 0000000..a104062 --- /dev/null +++ b/src/socket_local_client.c @@ -0,0 +1,166 @@ +/* + * 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. + */ + +#include "sockets.h" + +#include +#include +#include +#include +#include + +#ifdef HAVE_WINSOCK + +int socket_local_client(const char *name, int namespaceId, int type) +{ + errno = ENOSYS; + return -1; +} + +#else /* !HAVE_WINSOCK */ + +#include +#include +#include +#include + +#include "socket_local.h" + +#define LISTEN_BACKLOG 4 + +/* Documented in header file. */ +int socket_make_sockaddr_un(const char *name, int namespaceId, + struct sockaddr_un *p_addr, socklen_t *alen) +{ + memset (p_addr, 0, sizeof (*p_addr)); + size_t namelen; + + switch (namespaceId) { + case ANDROID_SOCKET_NAMESPACE_ABSTRACT: +#ifdef HAVE_LINUX_LOCAL_SOCKET_NAMESPACE + namelen = strlen(name); + + // Test with length +1 for the *initial* '\0'. + if ((namelen + 1) > sizeof(p_addr->sun_path)) { + goto error; + } + + /* + * Note: The path in this case is *not* supposed to be + * '\0'-terminated. ("man 7 unix" for the gory details.) + */ + + p_addr->sun_path[0] = 0; + memcpy(p_addr->sun_path + 1, name, namelen); +#else /*HAVE_LINUX_LOCAL_SOCKET_NAMESPACE*/ + /* this OS doesn't have the Linux abstract namespace */ + + namelen = strlen(name) + strlen(FILESYSTEM_SOCKET_PREFIX); + /* unix_path_max appears to be missing on linux */ + if (namelen > sizeof(*p_addr) + - offsetof(struct sockaddr_un, sun_path) - 1) { + goto error; + } + + strcpy(p_addr->sun_path, FILESYSTEM_SOCKET_PREFIX); + strcat(p_addr->sun_path, name); +#endif /*HAVE_LINUX_LOCAL_SOCKET_NAMESPACE*/ + break; + + case ANDROID_SOCKET_NAMESPACE_RESERVED: + namelen = strlen(name) + strlen(ANDROID_RESERVED_SOCKET_PREFIX); + /* unix_path_max appears to be missing on linux */ + if (namelen > sizeof(*p_addr) + - offsetof(struct sockaddr_un, sun_path) - 1) { + goto error; + } + + strcpy(p_addr->sun_path, ANDROID_RESERVED_SOCKET_PREFIX); + strcat(p_addr->sun_path, name); + break; + + case ANDROID_SOCKET_NAMESPACE_FILESYSTEM: + namelen = strlen(name); + /* unix_path_max appears to be missing on linux */ + if (namelen > sizeof(*p_addr) + - offsetof(struct sockaddr_un, sun_path) - 1) { + goto error; + } + + strcpy(p_addr->sun_path, name); + break; + default: + // invalid namespace id + return -1; + } + + p_addr->sun_family = AF_LOCAL; + *alen = namelen + offsetof(struct sockaddr_un, sun_path) + 1; + return 0; +error: + return -1; +} + +/** + * connect to peer named "name" on fd + * returns same fd or -1 on error. + * fd is not closed on error. that's your job. + * + * Used by AndroidSocketImpl + */ +int socket_local_client_connect(int fd, const char *name, int namespaceId, + int type) +{ + struct sockaddr_un addr; + socklen_t alen; + int err; + + err = socket_make_sockaddr_un(name, namespaceId, &addr, &alen); + + if (err < 0) { + goto error; + } + + if(connect(fd, (struct sockaddr *) &addr, alen) < 0) { + goto error; + } + + return fd; + +error: + return -1; +} + +/** + * connect to peer named "name" + * returns fd or -1 on error + */ +int socket_local_client(const char *name, int namespaceId, int type) +{ + int s; + + s = socket(AF_LOCAL, type, 0); + if(s < 0) return -1; + + if ( 0 > socket_local_client_connect(s, name, namespaceId, type)) { + close(s); + return -1; + } + + return s; +} + +#endif /* !HAVE_WINSOCK */ diff --git a/src/socket_local_server.c b/src/socket_local_server.c new file mode 100644 index 0000000..8c4a93f --- /dev/null +++ b/src/socket_local_server.c @@ -0,0 +1,124 @@ +/* libs/cutils/socket_local_server.c +** +** Copyright 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. +*/ + +#include "sockets.h" + +#include +#include +#include +#include +#include + +#ifdef HAVE_WINSOCK + +int socket_local_server(const char *name, int namespaceId, int type) +{ + errno = ENOSYS; + return -1; +} + +#else /* !HAVE_WINSOCK */ + +#include +#include +#include +#include +#include + +#include "socket_local.h" + +#define LISTEN_BACKLOG 4 + + +/** + * Binds a pre-created socket(AF_LOCAL) 's' to 'name' + * returns 's' on success, -1 on fail + * + * Does not call listen() + */ +int socket_local_server_bind(int s, const char *name, int namespaceId) +{ + struct sockaddr_un addr; + socklen_t alen; + int n; + int err; + + err = socket_make_sockaddr_un(name, namespaceId, &addr, &alen); + + if (err < 0) { + return -1; + } + + /* basically: if this is a filesystem path, unlink first */ +#ifndef HAVE_LINUX_LOCAL_SOCKET_NAMESPACE + if (1) { +#else + if (namespaceId == ANDROID_SOCKET_NAMESPACE_RESERVED + || namespaceId == ANDROID_SOCKET_NAMESPACE_FILESYSTEM) { +#endif + /*ignore ENOENT*/ + unlink(addr.sun_path); + } + + n = 1; + setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(n)); + + if(bind(s, (struct sockaddr *) &addr, alen) < 0) { + return -1; + } + + return s; + +} + + +/** Open a server-side UNIX domain datagram socket in the Linux non-filesystem + * namespace + * + * Returns fd on success, -1 on fail + */ + +int socket_local_server(const char *name, int namespace, int type) +{ + int err; + int s; + + s = socket(AF_LOCAL, type, 0); + if (s < 0) return -1; + + err = socket_local_server_bind(s, name, namespace); + + if (err < 0) { + close(s); + return -1; + } + + if (type == SOCK_STREAM) { + int ret; + + ret = listen(s, LISTEN_BACKLOG); + + if (ret < 0) { + close(s); + return -1; + } + } + + return s; +} + +#endif /* !HAVE_WINSOCK */ diff --git a/src/socket_loopback_client.c b/src/socket_loopback_client.c new file mode 100644 index 0000000..563caae --- /dev/null +++ b/src/socket_loopback_client.c @@ -0,0 +1,58 @@ +/* libs/cutils/socket_loopback_client.c +** +** Copyright 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. +*/ + +#include "sockets.h" + +#include +#include +#include +#include +#include + +#ifndef HAVE_WINSOCK +#include +#include +#include +#include +#endif + +/* Connect to port on the loopback IP interface. type is + * SOCK_STREAM or SOCK_DGRAM. + * return is a file descriptor or -1 on error + */ +int socket_loopback_client(int port, int type) +{ + struct sockaddr_in addr; + int s; + + 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, 0); + if(s < 0) return -1; + + if(connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) { + close(s); + return -1; + } + + return s; + +} + diff --git a/src/socket_loopback_server.c b/src/socket_loopback_server.c new file mode 100644 index 0000000..827fd4a --- /dev/null +++ b/src/socket_loopback_server.c @@ -0,0 +1,135 @@ +/* libs/cutils/socket_loopback_server.c +** +** Copyright 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. +*/ + +#include "sockets.h" + +#include +#include +#include +#include +#include +#include + +#define LISTEN_BACKLOG 4 +#define LOOPBACK_UP 1 +#define LOOPBACK_DOWN 0 + +#ifndef HAVE_WINSOCK +#include +#include +#include +#include +#include +#include +#include +#endif +#include "sysdeps.h" + +int get_loopback_status(void) { + + int s; + struct ifconf ifc; + struct ifreq *ifr; + int ifcnt; + char buf[1024]; + int i; + + s = socket(AF_INET, SOCK_DGRAM, 0); + if(s < 0) + { + perror("socket"); + return LOOPBACK_DOWN; + } + + // query available interfaces + ifc.ifc_len = sizeof(buf); + ifc.ifc_buf = buf; + if(ioctl(s, SIOCGIFCONF, &ifc) < 0) + { + perror("ioctl(SIOCGIFCONF)"); + return LOOPBACK_DOWN; + } + + // iterate the list of interfaces + ifr = ifc.ifc_req; + ifcnt = ifc.ifc_len / sizeof(struct ifreq); + for(i = 0; i < ifcnt; i++) + { + struct sockaddr_in *addr; + addr = (struct sockaddr_in *)&ifr->ifr_addr; + + if (ntohl(addr->sin_addr.s_addr) == INADDR_LOOPBACK) + { + return LOOPBACK_UP; + } + } + return LOOPBACK_DOWN; +} + +/* open listen() port on loopback interface */ +int socket_loopback_server(int port, int type) +{ + struct sockaddr_in addr; + int s, n; + int cnt_max = 30; + + // check the loopback interface has been up in 30 sec + while(cnt_max > 0) { + if(get_loopback_status() == LOOPBACK_DOWN) { + cnt_max--; + sdb_sleep_ms(1000); + } + else { + break; + } + } + + memset(&addr, 0, sizeof(addr)); + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + + if(cnt_max ==0) + addr.sin_addr.s_addr = htonl(INADDR_ANY); + else + addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + + s = socket(AF_INET, type, 0); + if(s < 0) return -1; + + n = 1; + setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &n, sizeof(n)); + + + + if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) { + sdb_close(s); + return -1; + } + + if (type == SOCK_STREAM) { + int ret; + + ret = listen(s, LISTEN_BACKLOG); + + if (ret < 0) { + sdb_close(s); + return -1; + } + } + + return s; +} diff --git a/src/socket_network_client.c b/src/socket_network_client.c new file mode 100644 index 0000000..b0c5a0f --- /dev/null +++ b/src/socket_network_client.c @@ -0,0 +1,64 @@ +/* libs/cutils/socket_network_client.c +** +** Copyright 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. +*/ + +#include "sockets.h" + +#include +#include +#include +#include +#include + +#ifndef HAVE_WINSOCK +#include +#include +#include +#include +#include +#endif + + +/* Connect to port on the IP interface. type is + * SOCK_STREAM or SOCK_DGRAM. + * return is a file descriptor or -1 on error + */ +int socket_network_client(const char *host, int port, int type) +{ + struct hostent *hp; + struct sockaddr_in addr; + int s; + + hp = gethostbyname(host); + if(hp == 0) return -1; + + memset(&addr, 0, sizeof(addr)); + addr.sin_family = hp->h_addrtype; + addr.sin_port = htons(port); + memcpy(&addr.sin_addr, hp->h_addr, hp->h_length); + + s = socket(hp->h_addrtype, type, 0); + if(s < 0) return -1; + + if(connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) { + close(s); + return -1; + } + + return s; + +} + diff --git a/src/sockets.c b/src/sockets.c new file mode 100644 index 0000000..b4a7a19 --- /dev/null +++ b/src/sockets.c @@ -0,0 +1,787 @@ +/* + * 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 "sysdeps.h" + +#define TRACE_TAG TRACE_SOCKETS +#include "sdb.h" + +SDB_MUTEX_DEFINE( socket_list_lock ); + +static void local_socket_close_locked(asocket *s); + +int sendfailmsg(int fd, const char *reason) +{ + char buf[9]; + int len; + len = strlen(reason); + if(len > 0xffff) len = 0xffff; + snprintf(buf, sizeof buf, "FAIL%04x", len); + if(writex(fd, buf, 8)) return -1; + return writex(fd, reason, len); +} + +//extern int online; + +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, +}; + +asocket *find_local_socket(unsigned id) +{ + asocket *s; + asocket *result = NULL; + + sdb_mutex_lock(&socket_list_lock); + for(s = local_socket_list.next; s != &local_socket_list && !result; s = s->next) { + if(s->id == id) result = s; + } + sdb_mutex_unlock(&socket_list_lock); + + 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) +{ + sdb_mutex_lock(&socket_list_lock); + + s->id = local_socket_next_id++; + insert_local_socket(s, &local_socket_list); + + sdb_mutex_unlock(&socket_list_lock); +} + +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. + */ + sdb_mutex_lock(&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)) { + local_socket_close_locked(s); + goto restart; + } + } + sdb_mutex_unlock(&socket_list_lock); +} + +static int local_socket_enqueue(asocket *s, apacket *p) +{ + D("LS(%d): enqueue %d\n", 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 = sdb_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\n", s->id, errno, strerror(errno) ); + 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); +// D("LS(%d): ready()\n", s->id); +} + +static void local_socket_close(asocket *s) +{ + sdb_mutex_lock(&socket_list_lock); + local_socket_close_locked(s); + sdb_mutex_unlock(&socket_list_lock); +} + +// be sure to hold the socket list lock when calling this +static void local_socket_destroy(asocket *s) +{ + apacket *p, *n; + + /* 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\n", s->id, p->len); + n = p->next; + put_apacket(p); + } + remove_socket(s); + free(s); +} + + +static void local_socket_close_locked(asocket *s) +{ + if(s->peer) { + s->peer->peer = 0; + // tweak to avoid deadlock + if (s->peer->close == local_socket_close) + local_socket_close_locked(s->peer); + else + s->peer->close(s->peer); + } + + /* If we are already closing, or if there are no + ** pending packets, destroy immediately + */ + if (s->closing || s->pkt_first == NULL) { + int id = s->id; + local_socket_destroy(s); + D("LS(%d): closed\n", id); + return; + } + + /* otherwise, put on the closing list + */ + D("LS(%d): closing\n", s->id); + s->closing = 1; + fdevent_del(&s->fde, FDE_READ); + remove_socket(s); + insert_local_socket(s, &local_socket_closing_list); +} + +static void local_socket_event_func(int fd, unsigned ev, void *_s) +{ + asocket *s = _s; + + /* 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) != 0) { + while(p->len > 0) { + int r = sdb_write(fd, p->ptr, p->len); + if(r > 0) { + p->ptr += r; + p->len -= r; + continue; + } + if(r < 0) { + /* returning here is ok because FDE_READ will + ** be processed in the next iteration loop + */ + if(errno == EAGAIN) return; + if(errno == EINTR) continue; + } + 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) { + 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; + size_t avail = MAX_PAYLOAD; + int r; + int is_eof = 0; + + while(avail > 0) { + r = sdb_read(fd, x, avail); + if(r > 0) { + avail -= r; + x += r; + continue; + } + if(r < 0) { + if(errno == EAGAIN) break; + if(errno == EINTR) continue; + } + + /* r = 0 or unhandled error */ + is_eof = 1; + break; + } + + if((avail == MAX_PAYLOAD) || (s->peer == 0)) { + put_apacket(p); + } else { + p->len = MAX_PAYLOAD - avail; + + r = s->peer->enqueue(s->peer, p); + + 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); + } + } + + if(is_eof) { + s->close(s); + } + } + + 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. + */ +// s->close(s); + return; + } +} + +asocket *create_local_socket(int fd) +{ + asocket *s = calloc(1, sizeof(asocket)); + if(s == 0) fatal("cannot allocate socket"); + install_local_socket(s); + s->fd = fd; + s->enqueue = local_socket_enqueue; + s->ready = local_socket_ready; + s->close = local_socket_close; + + fdevent_install(&s->fde, fd, local_socket_event_func, s); +/* fdevent_add(&s->fde, FDE_ERROR); */ + //fprintf(stderr, "Created local socket in create_local_socket \n"); + D("LS(%d): created (fd=%d)\n", s->id, s->fd); + return s; +} + +asocket *create_local_service_socket(const char *name) +{ + asocket *s; + int fd; + +#if !SDB_HOST + if (!strcmp(name,"jdwp")) { + return create_jdwp_service_socket(); + } + if (!strcmp(name,"track-jdwp")) { + return create_jdwp_tracker_service_socket(); + } +#endif + fd = service_to_fd(name); + if(fd < 0) return 0; + + s = create_local_socket(fd); + D("LS(%d): bound to '%s'\n", s->id, name); + return s; +} + +#if SDB_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'\n", s->id, name); + return s; + } + + return s; +} +#endif /* SDB_HOST */ + +/* a Remote socket is used to send/receive data to/from a given transport object +** it needs to be closed when the transport is forcibly destroyed by the user +*/ +typedef struct aremotesocket { + asocket socket; + adisconnect disconnect; +} aremotesocket; + +static int remote_socket_enqueue(asocket *s, apacket *p) +{ + D("Calling remote_socket_enqueue\n"); + 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("Calling remote_socket_ready\n"); + 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_close(asocket *s) +{ + D("Calling remote_socket_close\n"); + apacket *p = get_apacket(); + p->msg.command = A_CLSE; + if(s->peer) { + p->msg.arg0 = s->peer->id; + s->peer->peer = 0; + s->peer->close(s->peer); + } + p->msg.arg1 = s->id; + send_packet(p, s->transport); + D("RS(%d): closed\n", s->id); + remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect ); + free(s); +} + +static void remote_socket_disconnect(void* _s, atransport* t) +{ + asocket* s = _s; + asocket* peer = s->peer; + + D("remote_socket_disconnect RS(%d)\n", s->id); + if (peer) { + peer->peer = NULL; + peer->close(peer); + } + remove_transport_disconnect( s->transport, &((aremotesocket*)s)->disconnect ); + free(s); +} + +asocket *create_remote_socket(unsigned id, atransport *t) +{ + asocket *s = calloc(1, sizeof(aremotesocket)); + adisconnect* dis = &((aremotesocket*)s)->disconnect; + + if(s == 0) fatal("cannot allocate socket"); + s->id = id; + s->enqueue = remote_socket_enqueue; + s->ready = remote_socket_ready; + s->close = remote_socket_close; + s->transport = t; + + dis->func = remote_socket_disconnect; + dis->opaque = s; + add_transport_disconnect( t, dis ); + D("RS(%d): created\n", s->id); + return s; +} + +void connect_to_remote(asocket *s, const char *destination) +{ + D("Connect_to_remote call \n"); + apacket *p = get_apacket(); + int len = strlen(destination) + 1; + + if(len > (MAX_PAYLOAD-1)) { + fatal("destination oversized"); + } + + D("LS(%d): connect('%s')\n", 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->close = local_socket_close; + sdb_write(s->fd, "OKAY", 4); + 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->close = local_socket_close; + sendfailmsg(s->fd, "closed"); + s->close(s); +} + +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; +} + +static int smart_socket_enqueue(asocket *s, apacket *p) +{ + unsigned len; +#if SDB_HOST + char *service = NULL; + char* serial = NULL; + transport_type ttype = kTransportAny; +#endif + + D("SS(%d): enqueue %d\n", 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) > MAX_PAYLOAD) { + D("SS(%d): overflow\n", 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 > 1024)) { + D("SS(%d): bad size (%d)\n", s->id, len); + goto fail; + } + + D("SS(%d): len is %d\n", 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\n", s->id, len+4 - p->len); + return 0; + } + + p->data[len + 4] = 0; + + D("SS(%d): '%s'\n", s->id, (char*) (p->data + 4)); + +#if SDB_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:" + serial_end = strchr(service, ':'); + if (serial_end) { + *serial_end = 0; // terminate string + serial = service; + service = serial_end + 1; + } + } else if (!strncmp(service, "host-usb:", strlen("host-usb:"))) { + ttype = kTransportUsb; + service += strlen("host-usb:"); + } else if (!strncmp(service, "host-local:", strlen("host-local:"))) { + ttype = kTransportLocal; + service += strlen("host-local:"); + } else if (!strncmp(service, "host:", strlen("host:"))) { + ttype = kTransportAny; + service += strlen("host:"); + } else { + service = NULL; + } + + 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, ttype, serial, s->peer->fd, s) == 0) { + /* XXX fail message? */ + D( "SS(%d): handled host service '%s'\n", s->id, service ); + goto fail; + } + if (!strncmp(service, "transport", strlen("transport"))) { + D( "SS(%d): okay transport\n", 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'\n", s->id, service ); + sendfailmsg(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. + */ + sdb_write(s->peer->fd, "OKAY", 4); + + s->peer->ready = local_socket_ready; + s->peer->close = local_socket_close; + s->peer->peer = s2; + s2->peer = s->peer; + s->peer = 0; + D( "SS(%d): okay\n", s->id ); + s->close(s); + + /* initial state is "ready" */ + s2->ready(s2); + return 0; + } +#else /* !SDB_HOST */ + if (s->transport == NULL) { + char* error_string = "unknown failure"; + s->transport = acquire_one_transport (CS_ANY, + kTransportAny, NULL, &error_string); + + if (s->transport == NULL) { + sendfailmsg(s->peer->fd, error_string); + goto fail; + } + } +#endif + + if(!(s->transport) || (s->transport->connection_state == CS_OFFLINE)) { + /* if there's no remote we fail the connection + ** right here and terminate it + */ + sendfailmsg(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->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\n", s->id); +} + +static void smart_socket_close(asocket *s) +{ + D("SS(%d): closed\n", s->id); + if(s->pkt_first){ + put_apacket(s->pkt_first); + } + if(s->peer) { + s->peer->peer = 0; + s->peer->close(s->peer); + } + free(s); +} + +asocket *create_smart_socket(void (*action_cb)(asocket *s, const char *act)) +{ + D("Creating smart socket \n"); + asocket *s = calloc(1, sizeof(asocket)); + if(s == 0) fatal("cannot allocate socket"); + s->id = 0; + s->enqueue = smart_socket_enqueue; + s->ready = smart_socket_ready; + s->close = smart_socket_close; + s->extra = action_cb; + + D("SS(%d): created %p\n", s->id, action_cb); + return s; +} + +void smart_socket_action(asocket *s, const char *act) +{ + +} + +void connect_to_smartsocket(asocket *s) +{ + D("Connecting to smart socket \n"); + asocket *ss = create_smart_socket(smart_socket_action); + s->peer = ss; + ss->peer = s; + s->ready(s); +} diff --git a/src/sockets.dia b/src/sockets.dia new file mode 100644 index 0000000000000000000000000000000000000000..c626f20f0aa3ba846658cd95bb60d1792128afc5 GIT binary patch literal 2333 zcmV+&3F7u2iwFP!000001MOW)kK;BHzR#}^JV3A;%+Mlbz2bBSNPtBSv&bQnOD+a& z)3$bG(M!?Y?Mr_9QV(~xUbbHJWO~cMJZzWvsVMSOiC?k&<4;ff(0E`X4tR7o!N{B# zEL!n(5N+=!e|-MeM{n}e{ktF60sTS!*$TQh)Dcmfyt|w1q&)mEojyK3qVN<`$ps37 zBZ}GdFB*n)s*I+S`*()%x`8#7H2Ez5lu9XrDLKJ;|(cyA=<) zFdk@lH+jEFUz2Ix%(T$Xg|-iL%a(%CFU?Jx>gD@=nm#a5Zgzj*aiC1(=}<9gXeasm zl}&CHE2C(8|Naw`l8N`(Y2_cjv{!esjX-iw#WsklSgL=*tTXVr8@ji?)Y^KewRNGj z^&nmxxR8PdvWl?eJY+P=KsGdtS%08-MME_{F1cYM7Zb;FEz>5p@0v5)?~k_$q~upz zlH$k)Av^|axvPQ%ksN$sRO>qyYSIo7vs(R@-B+X7QC_RbK zc=8efsrV;Y-%Wlqi+xk}Mzy3^ywW)b{yc&lL@=>G_{g+fyXMl{jO$gJ5yIc>W^R4#ichPo?4%ZBXa?SWBmhp;sTEmM#qk%Ez0wo_iGZpx>Jm zg>KaJT&#AqLZ#0{Iy3vVuY&uet6s+k4bQV?PlQbnhSw2_598esBzuy2eTcYvoC_Bl zUgfXkGh;*dL3p~G?0LlF16{F+5zA8&J*ZG1YvLDv6af?c@Xy@V=L|e=lv6nH@U-XR zunShb&SI34SS5j0^55&H5K}cLpV6N$!>=rSU@}v5v$Fm#xSP*V0zq#&&Jhf_^S)5rRep* z8W&VAJo-1?&x&DqQ}F-&Xn?B6j~5X~L#jRm=)+0_!5|FesSb`s$9+C)UoSg!hpBn) zXt@&Gqx+JHx`a09QL#{2-G{#6q!u1ZUT$VamMLEY4uuEnx*`*Bfa%CwYz;tC!vu9%6);UW|3 z)K+Zdy9&lZzGKg^g*^3+U_>0v!pczR+UP1SatpGG@4XdWMX)`W41^UBRzO$*VFiR0 z5LQ4~0bvD%6%bZHSOH-LgcVp924UrE2rDMc7*J9`NdYAVloU`>KuKw-r2MW%%bJR{ z@zMA**#1ekpMr?hXewkRO~pgLR!wDw%w*FDv0Z!aAmZeheI*qxj0k8%5N07{(WBB+rF8mPAP9lr2g&t*S)lw9zmEbc5Fb)K+jy`Vzy$7ZJq z8QAn9WYPALK4v0&D8v;7t~J7nN0FLDNmNt`iq78{J4F-u;;Q7S#%jELn=EoouOEx^ zW6k2RR&~=}>4e54GHaxrci2R}-mQ1DOdeJ^W`WEI)=Xyg{#7mQjP_a^y2!;>IIYg^ zTcv!J-1wBCyYaog|()j40oFX(*6}0%<6ah5~6QkcI+j zD4?bH*`$~}Y#eAHV3Q&wqd*=Pq@}>zxkXya^zBN>_Ruv^AK8|h79S*fl@}k)vh~SS zM#iaZJ41Rk8nGoLlJ4Ed?0RqCp#K(1x4=TJ-FuTC_8q z5q*;F8OD0~(93iolBh%$az79YVZCfv=UAhirAX|OnL20E(kk)N`I{3Qkl33~sOdyv zv&Lh!3Eb{b>cVcC-r^&ymAVobl1t5VqJp6;#=(+Ngf2 zwdmY>*XUu5shw>K?qKRGr!E_wx6XJN%38xNyc_Sr^9Gceb-!j=Yiy3RArE8Czj}s*srQex(E6&8}mgdI$;23*OeXre#hg1Rn1io;0J z84!%!wyp~%BaouwWw~@j?_*|yWRa&GqM23(Q?XEjF}M7rmYs)Ot-oC|$e}hl$CiUgA?MiDm~)Ir$~lgA zYIZH@>dRI!QM4YK)7WwJer8XyZuk!V86Fk6s{v(c9K8vGi`;oqZ1RKGyU1jc$#_i+ zEZH=Qa-w)6sYzL359ZR5cMq#Uw z*iSJmrn +#include +#include + +#ifdef HAVE_WINSOCK +#include +typedef int socklen_t; +#elif HAVE_SYS_SOCKET_H +#include +#endif + +#define ANDROID_SOCKET_ENV_PREFIX "ANDROID_SOCKET_" +#define ANDROID_SOCKET_DIR "/dev/socket" + +#ifdef __cplusplus +extern "C" { +#endif + +/* + * android_get_control_socket - simple helper function to get the file + * descriptor of our init-managed Unix domain socket. `name' is the name of the + * socket, as given in init.rc. Returns -1 on error. + * + * This is inline and not in libcutils proper because we want to use this in + * third-party daemons with minimal modification. + */ +static inline int android_get_control_socket(const char *name) +{ + char key[64] = ANDROID_SOCKET_ENV_PREFIX; + const char *val; + int fd; + + /* build our environment variable, counting cycles like a wolf ... */ +#if HAVE_STRLCPY + strlcpy(key + sizeof(ANDROID_SOCKET_ENV_PREFIX) - 1, + name, + sizeof(key) - sizeof(ANDROID_SOCKET_ENV_PREFIX)); +#else /* for the host, which may lack the almightly strncpy ... */ + strncpy(key + sizeof(ANDROID_SOCKET_ENV_PREFIX) - 1, + name, + sizeof(key) - sizeof(ANDROID_SOCKET_ENV_PREFIX)); + key[sizeof(key)-1] = '\0'; +#endif + + val = getenv(key); + if (!val) + return -1; + + errno = 0; + fd = strtol(val, NULL, 10); + if (errno) + return -1; + + return fd; +} + +/* + * See also android.os.LocalSocketAddress.Namespace + */ +// Linux "abstract" (non-filesystem) namespace +#define ANDROID_SOCKET_NAMESPACE_ABSTRACT 0 +// Android "reserved" (/dev/socket) namespace +#define ANDROID_SOCKET_NAMESPACE_RESERVED 1 +// Normal filesystem namespace +#define ANDROID_SOCKET_NAMESPACE_FILESYSTEM 2 + +extern int socket_loopback_client(int port, int type); +extern int socket_network_client(const char *host, int port, int type); +extern int socket_loopback_server(int port, int type); +extern int socket_local_server(const char *name, int namespaceId, int type); +extern int socket_local_server_bind(int s, const char *name, int namespaceId); +extern int socket_local_client_connect(int fd, + const char *name, int namespaceId, int type); +extern int socket_local_client(const char *name, int namespaceId, int type); +extern int socket_inaddr_any_server(int port, int type); + +#ifdef __cplusplus +} +#endif + +#endif /* __CUTILS_SOCKETS_H */ diff --git a/src/sysdeps.h b/src/sysdeps.h new file mode 100644 index 0000000..33cb1b2 --- /dev/null +++ b/src/sysdeps.h @@ -0,0 +1,479 @@ +/* + * 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. + */ + +/* this file contains system-dependent definitions used by SDB + * they're related to threads, sockets and file descriptors + */ +#ifndef _SDB_SYSDEPS_H +#define _SDB_SYSDEPS_H + +#ifdef __CYGWIN__ +# undef _WIN32 +#endif + +#ifdef _WIN32 + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#define OS_PATH_SEPARATOR '\\' +#define OS_PATH_SEPARATOR_STR "\\" + +typedef CRITICAL_SECTION sdb_mutex_t; + +#define SDB_MUTEX_DEFINE(x) sdb_mutex_t x + +/* declare all mutexes */ +#define SDB_MUTEX(x) extern sdb_mutex_t x; +#include "mutex_list.h" + +extern void sdb_sysdeps_init(void); + +static __inline__ void sdb_mutex_lock( sdb_mutex_t* lock ) +{ + EnterCriticalSection( lock ); +} + +static __inline__ void sdb_mutex_unlock( sdb_mutex_t* lock ) +{ + LeaveCriticalSection( lock ); +} + +typedef struct { unsigned tid; } sdb_thread_t; + +typedef void* (*sdb_thread_func_t)(void* arg); + +typedef void (*win_thread_func_t)(void* arg); + +static __inline__ int sdb_thread_create( sdb_thread_t *thread, sdb_thread_func_t func, void* arg) +{ + thread->tid = _beginthread( (win_thread_func_t)func, 0, arg ); + if (thread->tid == (unsigned)-1L) { + return -1; + } + return 0; +} + +static __inline__ void close_on_exec(int fd) +{ + /* nothing really */ +} + +extern void disable_tcp_nagle(int fd); + +#define lstat stat /* no symlinks on Win32 */ + +#define S_ISLNK(m) 0 /* no symlinks on Win32 */ + +static __inline__ int sdb_unlink(const char* path) +{ + int rc = unlink(path); + + 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 = chmod(path, _S_IREAD|_S_IWRITE ); + if (rc == 0) + rc = unlink(path); + } + return rc; +} +#undef unlink +#define unlink ___xxx_unlink + +static __inline__ int sdb_mkdir(const char* path, int mode) +{ + return _mkdir(path); +} +#undef mkdir +#define mkdir ___xxx_mkdir + +extern int sdb_open(const char* path, int options); +extern int sdb_creat(const char* path, int mode); +extern int sdb_read(int fd, void* buf, int len); +extern int sdb_write(int fd, const void* buf, int len); +extern int sdb_lseek(int fd, int pos, int where); +extern int sdb_shutdown(int fd); +extern int sdb_close(int fd); + +static __inline__ int unix_close(int fd) +{ + return close(fd); +} +#undef close +#define close ____xxx_close + +static __inline__ int unix_read(int fd, void* buf, size_t len) +{ + return read(fd, buf, len); +} +#undef read +#define read ___xxx_read + +static __inline__ int unix_write(int fd, const void* buf, size_t len) +{ + return write(fd, buf, len); +} +#undef write +#define write ___xxx_write + +static __inline__ int sdb_open_mode(const char* path, int options, int mode) +{ + return sdb_open(path, options); +} + +static __inline__ int unix_open(const char* path, int options,...) +{ + if ((options & O_CREAT) == 0) + { + return open(path, options); + } + else + { + int mode; + va_list args; + va_start( args, options ); + mode = va_arg( args, int ); + va_end( args ); + return open(path, options, mode); + } +} +#define open ___xxx_unix_open + + +/* normally provided by */ +extern void* load_file(const char* pathname, unsigned* psize); + +/* normally provided by */ +extern int socket_loopback_client(int port, int type); +extern int socket_network_client(const char *host, int port, int type); +extern int socket_loopback_server(int port, int type); +extern int socket_inaddr_any_server(int port, int type); + +/* normally provided by "fdevent.h" */ + +#define FDE_READ 0x0001 +#define FDE_WRITE 0x0002 +#define FDE_ERROR 0x0004 +#define FDE_DONT_CLOSE 0x0080 + +typedef struct fdevent fdevent; + +typedef void (*fd_func)(int fd, unsigned events, void *userdata); + +fdevent *fdevent_create(int fd, fd_func func, void *arg); +void fdevent_destroy(fdevent *fde); +void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg); +void fdevent_remove(fdevent *item); +void fdevent_set(fdevent *fde, unsigned events); +void fdevent_add(fdevent *fde, unsigned events); +void fdevent_del(fdevent *fde, unsigned events); +void fdevent_loop(); + +struct fdevent { + fdevent *next; + fdevent *prev; + + int fd; + unsigned short state; + unsigned short events; + + fd_func func; + void *arg; +}; + +static __inline__ void sdb_sleep_ms( int mseconds ) +{ + Sleep( mseconds ); +} + +extern int sdb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen); + +#undef accept +#define accept ___xxx_accept + +static __inline__ int sdb_socket_setbufsize( int fd, int bufsize ) +{ + int opt = bufsize; + return setsockopt(fd, SOL_SOCKET, SO_RCVBUF, (const char*)&opt, sizeof(opt)); +} + +extern int sdb_socketpair( int sv[2] ); + +static __inline__ char* sdb_dirstart( const char* path ) +{ + char* p = strchr(path, '/'); + char* p2 = strchr(path, '\\'); + + if ( !p ) + p = p2; + else if ( p2 && p2 > p ) + p = p2; + + return p; +} + +static __inline__ char* sdb_dirstop( const char* path ) +{ + char* p = strrchr(path, '/'); + char* p2 = strrchr(path, '\\'); + + if ( !p ) + p = p2; + else if ( p2 && p2 > p ) + p = p2; + + return p; +} + +static __inline__ int sdb_is_absolute_host_path( const char* path ) +{ + return isalpha(path[0]) && path[1] == ':' && path[2] == '\\'; +} + +#else /* !_WIN32 a.k.a. Unix */ + +#include "fdevent.h" +#include "sockets.h" +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include + +#define OS_PATH_SEPARATOR '/' +#define OS_PATH_SEPARATOR_STR "/" + +typedef pthread_mutex_t sdb_mutex_t; +#define SDB_MUTEX_INITIALIZER PTHREAD_MUTEX_INITIALIZER +#define sdb_mutex_init pthread_mutex_init +#define sdb_mutex_lock pthread_mutex_lock +#define sdb_mutex_unlock pthread_mutex_unlock +#define sdb_mutex_destroy pthread_mutex_destroy + +#define SDB_MUTEX_DEFINE(m) static sdb_mutex_t m = PTHREAD_MUTEX_INITIALIZER + +#define sdb_cond_t pthread_cond_t +#define sdb_cond_init pthread_cond_init +#define sdb_cond_wait pthread_cond_wait +#define sdb_cond_broadcast pthread_cond_broadcast +#define sdb_cond_signal pthread_cond_signal +#define sdb_cond_destroy pthread_cond_destroy + +static __inline__ void close_on_exec(int fd) +{ + fcntl( fd, F_SETFD, FD_CLOEXEC ); +} + +static __inline__ int unix_open(const char* path, int options,...) +{ + if ((options & O_CREAT) == 0) + { + return open(path, options); + } + else + { + int mode; + va_list args; + va_start( args, options ); + mode = va_arg( args, int ); + va_end( args ); + return open(path, options, mode); + } +} + +static __inline__ int sdb_open_mode( const char* pathname, int options, int mode ) +{ + return open( pathname, options, mode ); +} + + +static __inline__ int sdb_open( const char* pathname, int options ) +{ + int fd = open( pathname, options ); + if (fd < 0) + return -1; + close_on_exec( fd ); + return fd; +} +#undef open +#define open ___xxx_open + +static __inline__ int sdb_shutdown(int fd) +{ + return shutdown(fd, SHUT_RDWR); +} +#undef shutdown +#define shutdown ____xxx_shutdown + +static __inline__ int sdb_close(int fd) +{ + return close(fd); +} +#undef close +#define close ____xxx_close + + +static __inline__ int sdb_read(int fd, void* buf, size_t len) +{ + return read(fd, buf, len); +} + +#undef read +#define read ___xxx_read + +static __inline__ int sdb_write(int fd, const void* buf, size_t len) +{ + return write(fd, buf, len); +} +#undef write +#define write ___xxx_write + +static __inline__ int sdb_lseek(int fd, int pos, int where) +{ + return lseek(fd, pos, where); +} +#undef lseek +#define lseek ___xxx_lseek + +static __inline__ int sdb_unlink(const char* path) +{ + return unlink(path); +} +#undef unlink +#define unlink ___xxx_unlink + +static __inline__ int sdb_creat(const char* path, int mode) +{ + int fd = creat(path, mode); + + if ( fd < 0 ) + return -1; + + close_on_exec(fd); + return fd; +} +#undef creat +#define creat ___xxx_creat + +static __inline__ int sdb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen) +{ + return accept( serverfd, addr, addrlen ); +} + +#undef accept +#define accept ___xxx_accept + +#define unix_read sdb_read +#define unix_write sdb_write +#define unix_close sdb_close + +typedef pthread_t sdb_thread_t; + +typedef void* (*sdb_thread_func_t)( void* arg ); + +static __inline__ int sdb_thread_create( sdb_thread_t *pthread, sdb_thread_func_t start, void* arg ) +{ + pthread_attr_t attr; + + pthread_attr_init (&attr); + pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_DETACHED); + + return pthread_create( pthread, &attr, start, arg ); +} + +static __inline__ int sdb_socket_setbufsize( int fd, int bufsize ) +{ + int opt = bufsize; + return setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &opt, sizeof(opt)); +} + +static __inline__ void disable_tcp_nagle(int fd) +{ + int on = 1; + setsockopt( fd, IPPROTO_TCP, TCP_NODELAY, (void*)&on, sizeof(on) ); +} + + +static __inline__ int unix_socketpair( int d, int type, int protocol, int sv[2] ) +{ + return socketpair( d, type, protocol, sv ); +} + +static __inline__ int sdb_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 + +static __inline__ void sdb_sleep_ms( int mseconds ) +{ + usleep( mseconds*1000 ); +} + +static __inline__ int sdb_mkdir(const char* path, int mode) +{ + return mkdir(path, mode); +} +#undef mkdir +#define mkdir ___xxx_mkdir + +static __inline__ void sdb_sysdeps_init(void) +{ +} + +static __inline__ char* sdb_dirstart(const char* path) +{ + return strchr(path, '/'); +} + +static __inline__ char* sdb_dirstop(const char* path) +{ + return strrchr(path, '/'); +} + +static __inline__ int sdb_is_absolute_host_path( const char* path ) +{ + return path[0] == '/'; +} + +#endif /* !_WIN32 */ + +#endif /* _SDB_SYSDEPS_H */ diff --git a/src/sysdeps_win32.c b/src/sysdeps_win32.c new file mode 100644 index 0000000..5538600 --- /dev/null +++ b/src/sysdeps_win32.c @@ -0,0 +1,1967 @@ +#include "sysdeps.h" +#include +#include +#include +#include +#define TRACE_TAG TRACE_SYSDEPS +#include "sdb.h" + +extern void fatal(const char *fmt, ...); + +#define assert(cond) do { if (!(cond)) fatal( "assertion failed '%s' on %s:%ld\n", #cond, __FILE__, __LINE__ ); } while (0) + +/**************************************************************************/ +/**************************************************************************/ +/***** *****/ +/***** replaces libs/cutils/load_file.c *****/ +/***** *****/ +/**************************************************************************/ +/**************************************************************************/ + +void *load_file(const char *fn, unsigned *_sz) +{ + HANDLE file; + char *data; + DWORD file_size; + + file = CreateFile( fn, + 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\n", 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'\n", file_size, fn); + free(data); + data = NULL; + file_size = 0; + } + } + } + CloseHandle( file ); + + *_sz = (unsigned) file_size; + return data; +} + +/**************************************************************************/ +/**************************************************************************/ +/***** *****/ +/***** common file descriptor handling *****/ +/***** *****/ +/**************************************************************************/ +/**************************************************************************/ + +typedef const struct FHClassRec_* FHClass; + +typedef struct FHRec_* FH; + +typedef struct EventHookRec_* EventHook; + +typedef struct FHClassRec_ +{ + void (*_fh_init) ( FH f ); + int (*_fh_close)( FH f ); + int (*_fh_lseek)( FH f, int pos, int origin ); + int (*_fh_read) ( FH f, void* buf, int len ); + int (*_fh_write)( FH f, const void* buf, int len ); + void (*_fh_hook) ( FH f, int events, EventHook hook ); + +} FHClassRec; + +/* used to emulate unix-domain socket pairs */ +typedef struct SocketPairRec_* SocketPair; + +typedef struct FHRec_ +{ + FHClass clazz; + int used; + int eof; + union { + HANDLE handle; + SOCKET socket; + SocketPair pair; + } u; + + HANDLE event; + int mask; + + char name[32]; + +} FHRec; + +#define fh_handle u.handle +#define fh_socket u.socket +#define fh_pair u.pair + +#define WIN32_FH_BASE 100 + +#define WIN32_MAX_FHS 128 + +static sdb_mutex_t _win32_lock; +static FHRec _win32_fhs[ WIN32_MAX_FHS ]; +static int _win32_fh_count; + +static FH +_fh_from_int( int fd ) +{ + FH f; + + fd -= WIN32_FH_BASE; + + if (fd < 0 || fd >= _win32_fh_count) { + D( "_fh_from_int: invalid fd %d\n", fd + WIN32_FH_BASE ); + errno = EBADF; + return NULL; + } + + f = &_win32_fhs[fd]; + + if (f->used == 0) { + D( "_fh_from_int: invalid fd %d\n", fd + WIN32_FH_BASE ); + 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 ) +{ + int nn; + FH f = NULL; + + sdb_mutex_lock( &_win32_lock ); + + if (_win32_fh_count < WIN32_MAX_FHS) { + f = &_win32_fhs[ _win32_fh_count++ ]; + goto Exit; + } + + for (nn = 0; nn < WIN32_MAX_FHS; nn++) { + if ( _win32_fhs[nn].clazz == NULL) { + f = &_win32_fhs[nn]; + goto Exit; + } + } + D( "_fh_alloc: no more free file descriptors\n" ); +Exit: + if (f) { + f->clazz = clazz; + f->used = 1; + f->eof = 0; + clazz->_fh_init(f); + } + sdb_mutex_unlock( &_win32_lock ); + return f; +} + + +static int +_fh_close( FH f ) +{ + if ( f->used ) { + f->clazz->_fh_close( f ); + f->used = 0; + f->eof = 0; + f->clazz = NULL; + } + return 0; +} + +/* forward definitions */ +static const FHClassRec _fh_file_class; +static const FHClassRec _fh_socket_class; + +/**************************************************************************/ +/**************************************************************************/ +/***** *****/ +/***** 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( "sdb_read: could not read %d bytes from %s\n", 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( "sdb_file_write: could not write %d bytes from %s\n", 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; +} + +static void _fh_file_hook( FH f, int event, EventHook eventhook ); /* forward */ + +static const FHClassRec _fh_file_class = +{ + _fh_file_init, + _fh_file_close, + _fh_file_lseek, + _fh_file_read, + _fh_file_write, + _fh_file_hook +}; + +/**************************************************************************/ +/**************************************************************************/ +/***** *****/ +/***** file-based descriptor handling *****/ +/***** *****/ +/**************************************************************************/ +/**************************************************************************/ + +int sdb_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("sdb_open: invalid options (0x%0x)\n", options); + errno = EINVAL; + return -1; + } + + f = _fh_alloc( &_fh_file_class ); + if ( !f ) { + errno = ENOMEM; + return -1; + } + + f->fh_handle = CreateFile( path, desiredAccess, shareMode, NULL, OPEN_EXISTING, + 0, NULL ); + + if ( f->fh_handle == INVALID_HANDLE_VALUE ) { + _fh_close(f); + D( "sdb_open: could not open '%s':", path ); + switch (GetLastError()) { + case ERROR_FILE_NOT_FOUND: + D( "file not found\n" ); + errno = ENOENT; + return -1; + + case ERROR_PATH_NOT_FOUND: + D( "path not found\n" ); + errno = ENOTDIR; + return -1; + + default: + D( "unknown error\n" ); + errno = ENOENT; + return -1; + } + } + + snprintf( f->name, sizeof(f->name), "%d(%s)", _fh_to_int(f), path ); + D( "sdb_open: '%s' => fd %d\n", path, _fh_to_int(f) ); + return _fh_to_int(f); +} + +/* ignore mode on Win32 */ +int sdb_creat(const char* path, int mode) +{ + FH f; + + f = _fh_alloc( &_fh_file_class ); + if ( !f ) { + errno = ENOMEM; + return -1; + } + + f->fh_handle = CreateFile( path, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, + NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, + NULL ); + + if ( f->fh_handle == INVALID_HANDLE_VALUE ) { + _fh_close(f); + D( "sdb_creat: could not open '%s':", path ); + switch (GetLastError()) { + case ERROR_FILE_NOT_FOUND: + D( "file not found\n" ); + errno = ENOENT; + return -1; + + case ERROR_PATH_NOT_FOUND: + D( "path not found\n" ); + errno = ENOTDIR; + return -1; + + default: + D( "unknown error\n" ); + errno = ENOENT; + return -1; + } + } + snprintf( f->name, sizeof(f->name), "%d(%s)", _fh_to_int(f), path ); + D( "sdb_creat: '%s' => fd %d\n", path, _fh_to_int(f) ); + return _fh_to_int(f); +} + + +int sdb_read(int fd, void* buf, int len) +{ + FH f = _fh_from_int(fd); + + if (f == NULL) { + return -1; + } + + return f->clazz->_fh_read( f, buf, len ); +} + + +int sdb_write(int fd, const void* buf, int len) +{ + FH f = _fh_from_int(fd); + + if (f == NULL) { + return -1; + } + + return f->clazz->_fh_write(f, buf, len); +} + + +int sdb_lseek(int fd, int pos, int where) +{ + FH f = _fh_from_int(fd); + + if (!f) { + return -1; + } + + return f->clazz->_fh_lseek(f, pos, where); +} + + +int sdb_shutdown(int fd) +{ + FH f = _fh_from_int(fd); + + if (!f) { + return -1; + } + + D( "sdb_shutdown: %s\n", f->name); + shutdown( f->fh_socket, SD_BOTH ); + return 0; +} + + +int sdb_close(int fd) +{ + FH f = _fh_from_int(fd); + + if (!f) { + return -1; + } + + D( "sdb_close: %s\n", f->name); + _fh_close(f); + return 0; +} + +/**************************************************************************/ +/**************************************************************************/ +/***** *****/ +/***** socket-based file descriptors *****/ +/***** *****/ +/**************************************************************************/ +/**************************************************************************/ + +static void +_socket_set_errno( void ) +{ + switch (WSAGetLastError()) { + case 0: errno = 0; break; + case WSAEWOULDBLOCK: errno = EAGAIN; break; + case WSAEINTR: errno = EINTR; break; + default: + D( "_socket_set_errno: unhandled value %d\n", WSAGetLastError() ); + errno = EINVAL; + } +} + +static void +_fh_socket_init( FH f ) +{ + f->fh_socket = INVALID_SOCKET; + f->event = WSACreateEvent(); + f->mask = 0; +} + +static int +_fh_socket_close( FH f ) +{ + /* gently tell any peer that we're closing the socket */ + shutdown( f->fh_socket, SD_BOTH ); + closesocket( f->fh_socket ); + f->fh_socket = INVALID_SOCKET; + CloseHandle( f->event ); + 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, buf, len, 0 ); + if (result == SOCKET_ERROR) { + _socket_set_errno(); + result = -1; + } + return result; +} + +static int +_fh_socket_write( FH f, const void* buf, int len ) +{ + int result = send( f->fh_socket, buf, len, 0 ); + if (result == SOCKET_ERROR) { + _socket_set_errno(); + result = -1; + } + return result; +} + +static void _fh_socket_hook( FH f, int event, EventHook hook ); /* forward */ + +static const FHClassRec _fh_socket_class = +{ + _fh_socket_init, + _fh_socket_close, + _fh_socket_lseek, + _fh_socket_read, + _fh_socket_write, + _fh_socket_hook +}; + +/**************************************************************************/ +/**************************************************************************/ +/***** *****/ +/***** replacement for libs/cutils/socket_xxxx.c *****/ +/***** *****/ +/**************************************************************************/ +/**************************************************************************/ + +#include + +static int _winsock_init; + +static void +_cleanup_winsock( void ) +{ + WSACleanup(); +} + +static void +_init_winsock( void ) +{ + if (!_winsock_init) { + WSADATA wsaData; + int rc = WSAStartup( MAKEWORD(2,2), &wsaData); + if (rc != 0) { + fatal( "sdb: could not initialize Winsock\n" ); + } + atexit( _cleanup_winsock ); + _winsock_init = 1; + } +} + +int socket_loopback_client(int port, int type) +{ + FH f = _fh_alloc( &_fh_socket_class ); + struct sockaddr_in addr; + SOCKET s; + + if (!f) + 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, 0); + if(s == INVALID_SOCKET) { + D("socket_loopback_client: could not create socket\n" ); + _fh_close(f); + return -1; + } + + f->fh_socket = s; + if(connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) { + D("socket_loopback_client: could not connect to %s:%d\n", type != SOCK_STREAM ? "udp" : "tcp", port ); + _fh_close(f); + return -1; + } + snprintf( f->name, sizeof(f->name), "%d(lo-client:%s%d)", _fh_to_int(f), type != SOCK_STREAM ? "udp:" : "", port ); + D( "socket_loopback_client: port %d type %s => fd %d\n", port, type != SOCK_STREAM ? "udp" : "tcp", _fh_to_int(f) ); + return _fh_to_int(f); +} + +#define LISTEN_BACKLOG 4 + +int socket_loopback_server(int port, int type) +{ + FH f = _fh_alloc( &_fh_socket_class ); + struct sockaddr_in addr; + SOCKET s; + int n; + + if (!f) { + 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, 0); + if(s == INVALID_SOCKET) return -1; + + f->fh_socket = s; + + n = 1; + setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (const char*)&n, sizeof(n)); + + if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) { + _fh_close(f); + return -1; + } + if (type == SOCK_STREAM) { + int ret; + + ret = listen(s, LISTEN_BACKLOG); + if (ret < 0) { + _fh_close(f); + return -1; + } + } + snprintf( f->name, sizeof(f->name), "%d(lo-server:%s%d)", _fh_to_int(f), type != SOCK_STREAM ? "udp:" : "", port ); + D( "socket_loopback_server: port %d type %s => fd %d\n", port, type != SOCK_STREAM ? "udp" : "tcp", _fh_to_int(f) ); + return _fh_to_int(f); +} + + +int socket_network_client(const char *host, int port, int type) +{ + FH f = _fh_alloc( &_fh_socket_class ); + struct hostent *hp; + struct sockaddr_in addr; + SOCKET s; + + if (!f) + return -1; + + if (!_winsock_init) + _init_winsock(); + + hp = gethostbyname(host); + if(hp == 0) { + _fh_close(f); + return -1; + } + + memset(&addr, 0, sizeof(addr)); + addr.sin_family = hp->h_addrtype; + addr.sin_port = htons(port); + memcpy(&addr.sin_addr, hp->h_addr, hp->h_length); + + s = socket(hp->h_addrtype, type, 0); + if(s == INVALID_SOCKET) { + _fh_close(f); + return -1; + } + f->fh_socket = s; + + if(connect(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) { + _fh_close(f); + return -1; + } + + snprintf( f->name, sizeof(f->name), "%d(net-client:%s%d)", _fh_to_int(f), type != SOCK_STREAM ? "udp:" : "", port ); + D( "socket_network_client: host '%s' port %d type %s => fd %d\n", host, port, type != SOCK_STREAM ? "udp" : "tcp", _fh_to_int(f) ); + return _fh_to_int(f); +} + + +int socket_inaddr_any_server(int port, int type) +{ + FH f = _fh_alloc( &_fh_socket_class ); + struct sockaddr_in addr; + SOCKET s; + int n; + + if (!f) + 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_ANY); + + s = socket(AF_INET, type, 0); + if(s == INVALID_SOCKET) { + _fh_close(f); + return -1; + } + + f->fh_socket = s; + n = 1; + setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (const char*)&n, sizeof(n)); + + if(bind(s, (struct sockaddr *) &addr, sizeof(addr)) < 0) { + _fh_close(f); + return -1; + } + + if (type == SOCK_STREAM) { + int ret; + + ret = listen(s, LISTEN_BACKLOG); + if (ret < 0) { + _fh_close(f); + return -1; + } + } + snprintf( f->name, sizeof(f->name), "%d(any-server:%s%d)", _fh_to_int(f), type != SOCK_STREAM ? "udp:" : "", port ); + D( "socket_inaddr_server: port %d type %s => fd %d\n", port, type != SOCK_STREAM ? "udp" : "tcp", _fh_to_int(f) ); + return _fh_to_int(f); +} + +#undef accept +int sdb_socket_accept(int serverfd, struct sockaddr* addr, socklen_t *addrlen) +{ + FH serverfh = _fh_from_int(serverfd); + FH fh; + + if ( !serverfh || serverfh->clazz != &_fh_socket_class ) { + D( "sdb_socket_accept: invalid fd %d\n", serverfd ); + return -1; + } + + fh = _fh_alloc( &_fh_socket_class ); + if (!fh) { + D( "sdb_socket_accept: not enough memory to allocate accepted socket descriptor\n" ); + return -1; + } + + fh->fh_socket = accept( serverfh->fh_socket, addr, addrlen ); + if (fh->fh_socket == INVALID_SOCKET) { + _fh_close( fh ); + D( "sdb_socket_accept: accept on fd %d return error %ld\n", serverfd, GetLastError() ); + return -1; + } + + snprintf( fh->name, sizeof(fh->name), "%d(accept:%s)", _fh_to_int(fh), serverfh->name ); + D( "sdb_socket_accept on fd %d returns fd %d\n", serverfd, _fh_to_int(fh) ); + return _fh_to_int(fh); +} + + +void disable_tcp_nagle(int fd) +{ + FH fh = _fh_from_int(fd); + int on; + + if ( !fh || fh->clazz != &_fh_socket_class ) + return; + + setsockopt( fh->fh_socket, IPPROTO_TCP, TCP_NODELAY, (const char*)&on, sizeof(on) ); +} + +/**************************************************************************/ +/**************************************************************************/ +/***** *****/ +/***** emulated socketpairs *****/ +/***** *****/ +/**************************************************************************/ +/**************************************************************************/ + +/* we implement socketpairs directly in use space for the following reasons: + * - it avoids copying data from/to the Nt kernel + * - it allows us to implement fdevent hooks easily and cheaply, something + * that is not possible with standard Win32 pipes !! + * + * basically, we use two circular buffers, each one corresponding to a given + * direction. + * + * each buffer is implemented as two regions: + * + * region A which is (a_start,a_end) + * region B which is (0, b_end) with b_end <= a_start + * + * an empty buffer has: a_start = a_end = b_end = 0 + * + * a_start is the pointer where we start reading data + * a_end is the pointer where we start writing data, unless it is BUFFER_SIZE, + * then you start writing at b_end + * + * the buffer is full when b_end == a_start && a_end == BUFFER_SIZE + * + * there is room when b_end < a_start || a_end < BUFER_SIZE + * + * when reading, a_start is incremented, it a_start meets a_end, then + * we do: a_start = 0, a_end = b_end, b_end = 0, and keep going on.. + */ + +#define BIP_BUFFER_SIZE 4096 + +#if 0 +#include +# define BIPD(x) D x +# define BIPDUMP bip_dump_hex + +static void bip_dump_hex( const unsigned char* ptr, size_t len ) +{ + int nn, len2 = len; + + if (len2 > 8) len2 = 8; + + for (nn = 0; nn < len2; nn++) + printf("%02x", ptr[nn]); + printf(" "); + + for (nn = 0; nn < len2; nn++) { + int c = ptr[nn]; + if (c < 32 || c > 127) + c = '.'; + printf("%c", c); + } + printf("\n"); + fflush(stdout); +} + +#else +# define BIPD(x) do {} while (0) +# define BIPDUMP(p,l) BIPD(p) +#endif + +typedef struct BipBufferRec_ +{ + int a_start; + int a_end; + int b_end; + int fdin; + int fdout; + int closed; + int can_write; /* boolean */ + HANDLE evt_write; /* event signaled when one can write to a buffer */ + int can_read; /* boolean */ + HANDLE evt_read; /* event signaled when one can read from a buffer */ + CRITICAL_SECTION lock; + unsigned char buff[ BIP_BUFFER_SIZE ]; + +} BipBufferRec, *BipBuffer; + +static void +bip_buffer_init( BipBuffer buffer ) +{ + D( "bit_buffer_init %p\n", buffer ); + buffer->a_start = 0; + buffer->a_end = 0; + buffer->b_end = 0; + buffer->can_write = 1; + buffer->can_read = 0; + buffer->fdin = 0; + buffer->fdout = 0; + buffer->closed = 0; + buffer->evt_write = CreateEvent( NULL, TRUE, TRUE, NULL ); + buffer->evt_read = CreateEvent( NULL, TRUE, FALSE, NULL ); + InitializeCriticalSection( &buffer->lock ); +} + +static void +bip_buffer_close( BipBuffer bip ) +{ + bip->closed = 1; + + if (!bip->can_read) { + SetEvent( bip->evt_read ); + } + if (!bip->can_write) { + SetEvent( bip->evt_write ); + } +} + +static void +bip_buffer_done( BipBuffer bip ) +{ + BIPD(( "bip_buffer_done: %d->%d\n", bip->fdin, bip->fdout )); + CloseHandle( bip->evt_read ); + CloseHandle( bip->evt_write ); + DeleteCriticalSection( &bip->lock ); +} + +static int +bip_buffer_write( BipBuffer bip, const void* src, int len ) +{ + int avail, count = 0; + + if (len <= 0) + return 0; + + BIPD(( "bip_buffer_write: enter %d->%d len %d\n", bip->fdin, bip->fdout, len )); + BIPDUMP( src, len ); + + EnterCriticalSection( &bip->lock ); + + while (!bip->can_write) { + int ret; + LeaveCriticalSection( &bip->lock ); + + if (bip->closed) { + errno = EPIPE; + return -1; + } + /* spinlocking here is probably unfair, but let's live with it */ + ret = WaitForSingleObject( bip->evt_write, INFINITE ); + if (ret != WAIT_OBJECT_0) { /* buffer probably closed */ + D( "bip_buffer_write: error %d->%d WaitForSingleObject returned %d, error %ld\n", bip->fdin, bip->fdout, ret, GetLastError() ); + return 0; + } + if (bip->closed) { + errno = EPIPE; + return -1; + } + EnterCriticalSection( &bip->lock ); + } + + BIPD(( "bip_buffer_write: exec %d->%d len %d\n", bip->fdin, bip->fdout, len )); + + avail = BIP_BUFFER_SIZE - bip->a_end; + if (avail > 0) + { + /* we can append to region A */ + if (avail > len) + avail = len; + + memcpy( bip->buff + bip->a_end, src, avail ); + src += avail; + count += avail; + len -= avail; + + bip->a_end += avail; + if (bip->a_end == BIP_BUFFER_SIZE && bip->a_start == 0) { + bip->can_write = 0; + ResetEvent( bip->evt_write ); + goto Exit; + } + } + + if (len == 0) + goto Exit; + + avail = bip->a_start - bip->b_end; + assert( avail > 0 ); /* since can_write is TRUE */ + + if (avail > len) + avail = len; + + memcpy( bip->buff + bip->b_end, src, avail ); + count += avail; + bip->b_end += avail; + + if (bip->b_end == bip->a_start) { + bip->can_write = 0; + ResetEvent( bip->evt_write ); + } + +Exit: + assert( count > 0 ); + + if ( !bip->can_read ) { + bip->can_read = 1; + SetEvent( bip->evt_read ); + } + + BIPD(( "bip_buffer_write: exit %d->%d count %d (as=%d ae=%d be=%d cw=%d cr=%d\n", + bip->fdin, bip->fdout, count, bip->a_start, bip->a_end, bip->b_end, bip->can_write, bip->can_read )); + LeaveCriticalSection( &bip->lock ); + + return count; + } + +static int +bip_buffer_read( BipBuffer bip, void* dst, int len ) +{ + int avail, count = 0; + + if (len <= 0) + return 0; + + BIPD(( "bip_buffer_read: enter %d->%d len %d\n", bip->fdin, bip->fdout, len )); + + EnterCriticalSection( &bip->lock ); + while ( !bip->can_read ) + { +#if 0 + LeaveCriticalSection( &bip->lock ); + errno = EAGAIN; + return -1; +#else + int ret; + LeaveCriticalSection( &bip->lock ); + + if (bip->closed) { + errno = EPIPE; + return -1; + } + + ret = WaitForSingleObject( bip->evt_read, INFINITE ); + if (ret != WAIT_OBJECT_0) { /* probably closed buffer */ + D( "bip_buffer_read: error %d->%d WaitForSingleObject returned %d, error %ld\n", bip->fdin, bip->fdout, ret, GetLastError()); + return 0; + } + if (bip->closed) { + errno = EPIPE; + return -1; + } + EnterCriticalSection( &bip->lock ); +#endif + } + + BIPD(( "bip_buffer_read: exec %d->%d len %d\n", bip->fdin, bip->fdout, len )); + + avail = bip->a_end - bip->a_start; + assert( avail > 0 ); /* since can_read is TRUE */ + + if (avail > len) + avail = len; + + memcpy( dst, bip->buff + bip->a_start, avail ); + dst += avail; + count += avail; + len -= avail; + + bip->a_start += avail; + if (bip->a_start < bip->a_end) + goto Exit; + + bip->a_start = 0; + bip->a_end = bip->b_end; + bip->b_end = 0; + + avail = bip->a_end; + if (avail > 0) { + if (avail > len) + avail = len; + memcpy( dst, bip->buff, avail ); + count += avail; + bip->a_start += avail; + + if ( bip->a_start < bip->a_end ) + goto Exit; + + bip->a_start = bip->a_end = 0; + } + + bip->can_read = 0; + ResetEvent( bip->evt_read ); + +Exit: + assert( count > 0 ); + + if (!bip->can_write ) { + bip->can_write = 1; + SetEvent( bip->evt_write ); + } + + BIPDUMP( (const unsigned char*)dst - count, count ); + BIPD(( "bip_buffer_read: exit %d->%d count %d (as=%d ae=%d be=%d cw=%d cr=%d\n", + bip->fdin, bip->fdout, count, bip->a_start, bip->a_end, bip->b_end, bip->can_write, bip->can_read )); + LeaveCriticalSection( &bip->lock ); + + return count; +} + +typedef struct SocketPairRec_ +{ + BipBufferRec a2b_bip; + BipBufferRec b2a_bip; + FH a_fd; + int used; + +} SocketPairRec; + +void _fh_socketpair_init( FH f ) +{ + f->fh_pair = NULL; +} + +static int +_fh_socketpair_close( FH f ) +{ + if ( f->fh_pair ) { + SocketPair pair = f->fh_pair; + + if ( f == pair->a_fd ) { + pair->a_fd = NULL; + } + + bip_buffer_close( &pair->b2a_bip ); + bip_buffer_close( &pair->a2b_bip ); + + if ( --pair->used == 0 ) { + bip_buffer_done( &pair->b2a_bip ); + bip_buffer_done( &pair->a2b_bip ); + free( pair ); + } + f->fh_pair = NULL; + } + return 0; +} + +static int +_fh_socketpair_lseek( FH f, int pos, int origin ) +{ + errno = ESPIPE; + return -1; +} + +static int +_fh_socketpair_read( FH f, void* buf, int len ) +{ + SocketPair pair = f->fh_pair; + BipBuffer bip; + + if (!pair) + return -1; + + if ( f == pair->a_fd ) + bip = &pair->b2a_bip; + else + bip = &pair->a2b_bip; + + return bip_buffer_read( bip, buf, len ); +} + +static int +_fh_socketpair_write( FH f, const void* buf, int len ) +{ + SocketPair pair = f->fh_pair; + BipBuffer bip; + + if (!pair) + return -1; + + if ( f == pair->a_fd ) + bip = &pair->a2b_bip; + else + bip = &pair->b2a_bip; + + return bip_buffer_write( bip, buf, len ); +} + + +static void _fh_socketpair_hook( FH f, int event, EventHook hook ); /* forward */ + +static const FHClassRec _fh_socketpair_class = +{ + _fh_socketpair_init, + _fh_socketpair_close, + _fh_socketpair_lseek, + _fh_socketpair_read, + _fh_socketpair_write, + _fh_socketpair_hook +}; + + +int sdb_socketpair( int sv[2] ) +{ + FH fa, fb; + SocketPair pair; + + fa = _fh_alloc( &_fh_socketpair_class ); + fb = _fh_alloc( &_fh_socketpair_class ); + + if (!fa || !fb) + goto Fail; + + pair = malloc( sizeof(*pair) ); + if (pair == NULL) { + D("sdb_socketpair: not enough memory to allocate pipes\n" ); + goto Fail; + } + + bip_buffer_init( &pair->a2b_bip ); + bip_buffer_init( &pair->b2a_bip ); + + fa->fh_pair = pair; + fb->fh_pair = pair; + pair->used = 2; + pair->a_fd = fa; + + sv[0] = _fh_to_int(fa); + sv[1] = _fh_to_int(fb); + + pair->a2b_bip.fdin = sv[0]; + pair->a2b_bip.fdout = sv[1]; + pair->b2a_bip.fdin = sv[1]; + pair->b2a_bip.fdout = sv[0]; + + snprintf( fa->name, sizeof(fa->name), "%d(pair:%d)", sv[0], sv[1] ); + snprintf( fb->name, sizeof(fb->name), "%d(pair:%d)", sv[1], sv[0] ); + D( "sdb_socketpair: returns (%d, %d)\n", sv[0], sv[1] ); + return 0; + +Fail: + _fh_close(fb); + _fh_close(fa); + return -1; +} + +/**************************************************************************/ +/**************************************************************************/ +/***** *****/ +/***** fdevents emulation *****/ +/***** *****/ +/***** this is a very simple implementation, we rely on the fact *****/ +/***** that SDB doesn't use FDE_ERROR. *****/ +/***** *****/ +/**************************************************************************/ +/**************************************************************************/ + +#define FATAL(x...) fatal(__FUNCTION__, x) + +#if DEBUG +static void dump_fde(fdevent *fde, const char *info) +{ + fprintf(stderr,"FDE #%03d %c%c%c %s\n", fde->fd, + fde->state & FDE_READ ? 'R' : ' ', + fde->state & FDE_WRITE ? 'W' : ' ', + fde->state & FDE_ERROR ? 'E' : ' ', + info); +} +#else +#define dump_fde(fde, info) do { } while(0) +#endif + +#define FDE_EVENTMASK 0x00ff +#define FDE_STATEMASK 0xff00 + +#define FDE_ACTIVE 0x0100 +#define FDE_PENDING 0x0200 +#define FDE_CREATED 0x0400 + +static void fdevent_plist_enqueue(fdevent *node); +static void fdevent_plist_remove(fdevent *node); +static fdevent *fdevent_plist_dequeue(void); + +static fdevent list_pending = { + .next = &list_pending, + .prev = &list_pending, +}; + +static fdevent **fd_table = 0; +static int fd_table_max = 0; + +typedef struct EventLooperRec_* EventLooper; + +typedef struct EventHookRec_ +{ + EventHook next; + FH fh; + HANDLE h; + int wanted; /* wanted event flags */ + int ready; /* ready event flags */ + void* aux; + void (*prepare)( EventHook hook ); + int (*start) ( EventHook hook ); + void (*stop) ( EventHook hook ); + int (*check) ( EventHook hook ); + int (*peek) ( EventHook hook ); +} EventHookRec; + +static EventHook _free_hooks; + +static EventHook +event_hook_alloc( FH fh ) +{ + EventHook hook = _free_hooks; + if (hook != NULL) + _free_hooks = hook->next; + else { + hook = malloc( sizeof(*hook) ); + if (hook == NULL) + fatal( "could not allocate event hook\n" ); + } + hook->next = NULL; + hook->fh = fh; + hook->wanted = 0; + hook->ready = 0; + hook->h = INVALID_HANDLE_VALUE; + hook->aux = NULL; + + hook->prepare = NULL; + hook->start = NULL; + hook->stop = NULL; + hook->check = NULL; + hook->peek = NULL; + + return hook; +} + +static void +event_hook_free( EventHook hook ) +{ + hook->fh = NULL; + hook->wanted = 0; + hook->ready = 0; + hook->next = _free_hooks; + _free_hooks = hook; +} + + +static void +event_hook_signal( EventHook hook ) +{ + FH f = hook->fh; + int fd = _fh_to_int(f); + fdevent* fde = fd_table[ fd - WIN32_FH_BASE ]; + + if (fde != NULL && fde->fd == fd) { + if ((fde->state & FDE_PENDING) == 0) { + fde->state |= FDE_PENDING; + fdevent_plist_enqueue( fde ); + } + fde->events |= hook->wanted; + } +} + + +#define MAX_LOOPER_HANDLES WIN32_MAX_FHS + +typedef struct EventLooperRec_ +{ + EventHook hooks; + HANDLE htab[ MAX_LOOPER_HANDLES ]; + int htab_count; + +} EventLooperRec; + +static EventHook* +event_looper_find_p( EventLooper looper, FH fh ) +{ + EventHook *pnode = &looper->hooks; + EventHook node = *pnode; + for (;;) { + if ( node == NULL || node->fh == fh ) + break; + pnode = &node->next; + node = *pnode; + } + return pnode; +} + +static void +event_looper_hook( EventLooper looper, int fd, int events ) +{ + FH f = _fh_from_int(fd); + EventHook *pnode; + EventHook node; + + if (f == NULL) /* invalid arg */ { + D("event_looper_hook: invalid fd=%d\n", fd); + return; + } + + pnode = event_looper_find_p( looper, f ); + node = *pnode; + if ( node == NULL ) { + node = event_hook_alloc( f ); + node->next = *pnode; + *pnode = node; + } + + if ( (node->wanted & events) != events ) { + /* this should update start/stop/check/peek */ + D("event_looper_hook: call hook for %d (new=%x, old=%x)\n", + fd, node->wanted, events); + f->clazz->_fh_hook( f, events & ~node->wanted, node ); + node->wanted |= events; + } else { + D("event_looper_hook: ignoring events %x for %d wanted=%x)\n", + events, fd, node->wanted); + } +} + +static void +event_looper_unhook( EventLooper looper, int fd, int events ) +{ + FH fh = _fh_from_int(fd); + EventHook *pnode = event_looper_find_p( looper, fh ); + EventHook node = *pnode; + + if (node != NULL) { + int events2 = events & node->wanted; + if ( events2 == 0 ) { + D( "event_looper_unhook: events %x not registered for fd %d\n", events, fd ); + return; + } + node->wanted &= ~events2; + if (!node->wanted) { + *pnode = node->next; + event_hook_free( node ); + } + } +} + +static EventLooperRec win32_looper; + +static void fdevent_init(void) +{ + win32_looper.htab_count = 0; + win32_looper.hooks = NULL; +} + +static void fdevent_connect(fdevent *fde) +{ + EventLooper looper = &win32_looper; + int events = fde->state & FDE_EVENTMASK; + + if (events != 0) + event_looper_hook( looper, fde->fd, events ); +} + +static void fdevent_disconnect(fdevent *fde) +{ + EventLooper looper = &win32_looper; + int events = fde->state & FDE_EVENTMASK; + + if (events != 0) + event_looper_unhook( looper, fde->fd, events ); +} + +static void fdevent_update(fdevent *fde, unsigned events) +{ + EventLooper looper = &win32_looper; + unsigned events0 = fde->state & FDE_EVENTMASK; + + if (events != events0) { + int removes = events0 & ~events; + int adds = events & ~events0; + if (removes) { + D("fdevent_update: remove %x from %d\n", removes, fde->fd); + event_looper_unhook( looper, fde->fd, removes ); + } + if (adds) { + D("fdevent_update: add %x to %d\n", adds, fde->fd); + event_looper_hook ( looper, fde->fd, adds ); + } + } +} + +static void fdevent_process() +{ + EventLooper looper = &win32_looper; + EventHook hook; + int gotone = 0; + + /* if we have at least one ready hook, execute it/them */ + for (hook = looper->hooks; hook; hook = hook->next) { + hook->ready = 0; + if (hook->prepare) { + hook->prepare(hook); + if (hook->ready != 0) { + event_hook_signal( hook ); + gotone = 1; + } + } + } + + /* nothing's ready yet, so wait for something to happen */ + if (!gotone) + { + looper->htab_count = 0; + + for (hook = looper->hooks; hook; hook = hook->next) + { + if (hook->start && !hook->start(hook)) { + D( "fdevent_process: error when starting a hook\n" ); + return; + } + if (hook->h != INVALID_HANDLE_VALUE) { + int nn; + + for (nn = 0; nn < looper->htab_count; nn++) + { + if ( looper->htab[nn] == hook->h ) + goto DontAdd; + } + looper->htab[ looper->htab_count++ ] = hook->h; + DontAdd: + ; + } + } + + if (looper->htab_count == 0) { + D( "fdevent_process: nothing to wait for !!\n" ); + return; + } + + do + { + int wait_ret; + + D( "sdb_win32: waiting for %d events\n", looper->htab_count ); + if (looper->htab_count > MAXIMUM_WAIT_OBJECTS) { + D("handle count %d exceeds MAXIMUM_WAIT_OBJECTS, aborting!\n", looper->htab_count); + abort(); + } + wait_ret = WaitForMultipleObjects( looper->htab_count, looper->htab, FALSE, INFINITE ); + if (wait_ret == (int)WAIT_FAILED) { + D( "sdb_win32: wait failed, error %ld\n", GetLastError() ); + } else { + D( "sdb_win32: got one (index %d)\n", wait_ret ); + + /* according to Cygwin, some objects like consoles wake up on "inappropriate" events + * like mouse movements. we need to filter these with the "check" function + */ + if ((unsigned)wait_ret < (unsigned)looper->htab_count) + { + for (hook = looper->hooks; hook; hook = hook->next) + { + if ( looper->htab[wait_ret] == hook->h && + (!hook->check || hook->check(hook)) ) + { + D( "sdb_win32: signaling %s for %x\n", hook->fh->name, hook->ready ); + event_hook_signal( hook ); + gotone = 1; + break; + } + } + } + } + } + while (!gotone); + + for (hook = looper->hooks; hook; hook = hook->next) { + if (hook->stop) + hook->stop( hook ); + } + } + + for (hook = looper->hooks; hook; hook = hook->next) { + if (hook->peek && hook->peek(hook)) + event_hook_signal( hook ); + } +} + + +static void fdevent_register(fdevent *fde) +{ + int fd = fde->fd - WIN32_FH_BASE; + + if(fd < 0) { + FATAL("bogus negative fd (%d)\n", fde->fd); + } + + if(fd >= fd_table_max) { + int oldmax = fd_table_max; + if(fde->fd > 32000) { + FATAL("bogus huuuuge fd (%d)\n", fde->fd); + } + if(fd_table_max == 0) { + fdevent_init(); + fd_table_max = 256; + } + while(fd_table_max <= fd) { + fd_table_max *= 2; + } + fd_table = realloc(fd_table, sizeof(fdevent*) * fd_table_max); + if(fd_table == 0) { + FATAL("could not expand fd_table to %d entries\n", fd_table_max); + } + memset(fd_table + oldmax, 0, sizeof(int) * (fd_table_max - oldmax)); + } + + fd_table[fd] = fde; +} + +static void fdevent_unregister(fdevent *fde) +{ + int fd = fde->fd - WIN32_FH_BASE; + + if((fd < 0) || (fd >= fd_table_max)) { + FATAL("fd out of range (%d)\n", fde->fd); + } + + if(fd_table[fd] != fde) { + FATAL("fd_table out of sync"); + } + + fd_table[fd] = 0; + + if(!(fde->state & FDE_DONT_CLOSE)) { + dump_fde(fde, "close"); + sdb_close(fde->fd); + } +} + +static void fdevent_plist_enqueue(fdevent *node) +{ + fdevent *list = &list_pending; + + node->next = list; + node->prev = list->prev; + node->prev->next = node; + list->prev = node; +} + +static void fdevent_plist_remove(fdevent *node) +{ + node->prev->next = node->next; + node->next->prev = node->prev; + node->next = 0; + node->prev = 0; +} + +static fdevent *fdevent_plist_dequeue(void) +{ + fdevent *list = &list_pending; + fdevent *node = list->next; + + if(node == list) return 0; + + list->next = node->next; + list->next->prev = list; + node->next = 0; + node->prev = 0; + + return node; +} + +fdevent *fdevent_create(int fd, fd_func func, void *arg) +{ + 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) +{ + if(fde == 0) return; + if(!(fde->state & FDE_CREATED)) { + FATAL("fde %p not created by fdevent_create()\n", fde); + } + fdevent_remove(fde); +} + +void fdevent_install(fdevent *fde, int fd, fd_func func, void *arg) +{ + memset(fde, 0, sizeof(fdevent)); + fde->state = FDE_ACTIVE; + fde->fd = fd; + fde->func = func; + fde->arg = arg; + + fdevent_register(fde); + dump_fde(fde, "connect"); + fdevent_connect(fde); + fde->state |= FDE_ACTIVE; +} + +void fdevent_remove(fdevent *fde) +{ + if(fde->state & FDE_PENDING) { + fdevent_plist_remove(fde); + } + + if(fde->state & FDE_ACTIVE) { + fdevent_disconnect(fde); + dump_fde(fde, "disconnect"); + fdevent_unregister(fde); + } + + fde->state = 0; + fde->events = 0; +} + + +void fdevent_set(fdevent *fde, unsigned events) +{ + events &= FDE_EVENTMASK; + + if((fde->state & FDE_EVENTMASK) == (int)events) return; + + if(fde->state & FDE_ACTIVE) { + fdevent_update(fde, events); + dump_fde(fde, "update"); + } + + fde->state = (fde->state & FDE_STATEMASK) | events; + + if(fde->state & FDE_PENDING) { + /* if we're pending, make sure + ** we don't signal an event that + ** is no longer wanted. + */ + fde->events &= (~events); + if(fde->events == 0) { + fdevent_plist_remove(fde); + fde->state &= (~FDE_PENDING); + } + } +} + +void fdevent_add(fdevent *fde, unsigned events) +{ + fdevent_set( + fde, (fde->state & FDE_EVENTMASK) | (events & FDE_EVENTMASK)); +} + +void fdevent_del(fdevent *fde, unsigned events) +{ + fdevent_set( + fde, (fde->state & FDE_EVENTMASK) & (~(events & FDE_EVENTMASK))); +} + +void fdevent_loop() +{ + fdevent *fde; + + for(;;) { +#if DEBUG + fprintf(stderr,"--- ---- waiting for events\n"); +#endif + fdevent_process(); + + while((fde = fdevent_plist_dequeue())) { + unsigned events = fde->events; + fde->events = 0; + fde->state &= (~FDE_PENDING); + dump_fde(fde, "callback"); + fde->func(fde->fd, events, fde->arg); + } + } +} + +/** FILE EVENT HOOKS + **/ + +static void _event_file_prepare( EventHook hook ) +{ + if (hook->wanted & (FDE_READ|FDE_WRITE)) { + /* we can always read/write */ + hook->ready |= hook->wanted & (FDE_READ|FDE_WRITE); + } +} + +static int _event_file_peek( EventHook hook ) +{ + return (hook->wanted & (FDE_READ|FDE_WRITE)); +} + +static void _fh_file_hook( FH f, int events, EventHook hook ) +{ + hook->h = f->fh_handle; + hook->prepare = _event_file_prepare; + hook->peek = _event_file_peek; +} + +/** SOCKET EVENT HOOKS + **/ + +static void _event_socket_verify( EventHook hook, WSANETWORKEVENTS* evts ) +{ + if ( evts->lNetworkEvents & (FD_READ|FD_ACCEPT|FD_CLOSE) ) { + if (hook->wanted & FDE_READ) + hook->ready |= FDE_READ; + if ((evts->iErrorCode[FD_READ] != 0) && hook->wanted & FDE_ERROR) + hook->ready |= FDE_ERROR; + } + if ( evts->lNetworkEvents & (FD_WRITE|FD_CONNECT|FD_CLOSE) ) { + if (hook->wanted & FDE_WRITE) + hook->ready |= FDE_WRITE; + if ((evts->iErrorCode[FD_WRITE] != 0) && hook->wanted & FDE_ERROR) + hook->ready |= FDE_ERROR; + } + if ( evts->lNetworkEvents & FD_OOB ) { + if (hook->wanted & FDE_ERROR) + hook->ready |= FDE_ERROR; + } +} + +static void _event_socket_prepare( EventHook hook ) +{ + WSANETWORKEVENTS evts; + + /* look if some of the events we want already happened ? */ + if (!WSAEnumNetworkEvents( hook->fh->fh_socket, NULL, &evts )) + _event_socket_verify( hook, &evts ); +} + +static int _socket_wanted_to_flags( int wanted ) +{ + int flags = 0; + if (wanted & FDE_READ) + flags |= FD_READ | FD_ACCEPT | FD_CLOSE; + + if (wanted & FDE_WRITE) + flags |= FD_WRITE | FD_CONNECT | FD_CLOSE; + + if (wanted & FDE_ERROR) + flags |= FD_OOB; + + return flags; +} + +static int _event_socket_start( EventHook hook ) +{ + /* create an event which we're going to wait for */ + FH fh = hook->fh; + long flags = _socket_wanted_to_flags( hook->wanted ); + + hook->h = fh->event; + if (hook->h == INVALID_HANDLE_VALUE) { + D( "_event_socket_start: no event for %s\n", fh->name ); + return 0; + } + + if ( flags != fh->mask ) { + D( "_event_socket_start: hooking %s for %x (flags %ld)\n", hook->fh->name, hook->wanted, flags ); + if ( WSAEventSelect( fh->fh_socket, hook->h, flags ) ) { + D( "_event_socket_start: WSAEventSelect() for %s failed, error %d\n", hook->fh->name, WSAGetLastError() ); + CloseHandle( hook->h ); + hook->h = INVALID_HANDLE_VALUE; + exit(1); + return 0; + } + fh->mask = flags; + } + return 1; +} + +static void _event_socket_stop( EventHook hook ) +{ + hook->h = INVALID_HANDLE_VALUE; +} + +static int _event_socket_check( EventHook hook ) +{ + int result = 0; + FH fh = hook->fh; + WSANETWORKEVENTS evts; + + if (!WSAEnumNetworkEvents( fh->fh_socket, hook->h, &evts ) ) { + _event_socket_verify( hook, &evts ); + result = (hook->ready != 0); + if (result) { + ResetEvent( hook->h ); + } + } + D( "_event_socket_check %s returns %d\n", fh->name, result ); + return result; +} + +static int _event_socket_peek( EventHook hook ) +{ + WSANETWORKEVENTS evts; + FH fh = hook->fh; + + /* look if some of the events we want already happened ? */ + if (!WSAEnumNetworkEvents( fh->fh_socket, NULL, &evts )) { + _event_socket_verify( hook, &evts ); + if (hook->ready) + ResetEvent( hook->h ); + } + + return hook->ready != 0; +} + + + +static void _fh_socket_hook( FH f, int events, EventHook hook ) +{ + hook->prepare = _event_socket_prepare; + hook->start = _event_socket_start; + hook->stop = _event_socket_stop; + hook->check = _event_socket_check; + hook->peek = _event_socket_peek; + + _event_socket_start( hook ); +} + +/** SOCKETPAIR EVENT HOOKS + **/ + +static void _event_socketpair_prepare( EventHook hook ) +{ + FH fh = hook->fh; + SocketPair pair = fh->fh_pair; + BipBuffer rbip = (pair->a_fd == fh) ? &pair->b2a_bip : &pair->a2b_bip; + BipBuffer wbip = (pair->a_fd == fh) ? &pair->a2b_bip : &pair->b2a_bip; + + if (hook->wanted & FDE_READ && rbip->can_read) + hook->ready |= FDE_READ; + + if (hook->wanted & FDE_WRITE && wbip->can_write) + hook->ready |= FDE_WRITE; + } + + static int _event_socketpair_start( EventHook hook ) + { + FH fh = hook->fh; + SocketPair pair = fh->fh_pair; + BipBuffer rbip = (pair->a_fd == fh) ? &pair->b2a_bip : &pair->a2b_bip; + BipBuffer wbip = (pair->a_fd == fh) ? &pair->a2b_bip : &pair->b2a_bip; + + if (hook->wanted == FDE_READ) + hook->h = rbip->evt_read; + + else if (hook->wanted == FDE_WRITE) + hook->h = wbip->evt_write; + + else { + D("_event_socketpair_start: can't handle FDE_READ+FDE_WRITE\n" ); + return 0; + } + D( "_event_socketpair_start: hook %s for %x wanted=%x\n", + hook->fh->name, _fh_to_int(fh), hook->wanted); + return 1; +} + +static int _event_socketpair_peek( EventHook hook ) +{ + _event_socketpair_prepare( hook ); + return hook->ready != 0; +} + +static void _fh_socketpair_hook( FH fh, int events, EventHook hook ) +{ + hook->prepare = _event_socketpair_prepare; + hook->start = _event_socketpair_start; + hook->peek = _event_socketpair_peek; +} + + +void +sdb_sysdeps_init( void ) +{ +#define SDB_MUTEX(x) InitializeCriticalSection( & x ); +#include "mutex_list.h" + InitializeCriticalSection( &_win32_lock ); +} + diff --git a/src/test_track_devices.c b/src/test_track_devices.c new file mode 100644 index 0000000..d157011 --- /dev/null +++ b/src/test_track_devices.c @@ -0,0 +1,97 @@ +/* a simple test program, connects to SDB server, and opens a track-devices session */ +#include +#include +#include +#include +#include +#include + +static void +panic( const char* msg ) +{ + fprintf(stderr, "PANIC: %s: %s\n", msg, strerror(errno)); + exit(1); +} + +static int +unix_write( int fd, const char* buf, int len ) +{ + int result = 0; + while (len > 0) { + int len2 = write(fd, buf, len); + if (len2 < 0) { + if (errno == EINTR || errno == EAGAIN) + continue; + return -1; + } + result += len2; + len -= len2; + buf += len2; + } + return result; +} + +static int +unix_read( int fd, char* buf, int len ) +{ + int result = 0; + while (len > 0) { + int len2 = read(fd, buf, len); + if (len2 < 0) { + if (errno == EINTR || errno == EAGAIN) + continue; + return -1; + } + result += len2; + len -= len2; + buf += len2; + } + return result; +} + + +int main( void ) +{ + int ret, s; + struct sockaddr_in server; + char buffer[1024]; + const char* request = "host:track-devices"; + int len; + + memset( &server, 0, sizeof(server) ); + server.sin_family = AF_INET; + server.sin_port = htons(5037); + server.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + + 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 */ + len = snprintf( buffer, sizeof buffer, "%04x%s", strlen(request), request ); + if (unix_write(s, buffer, len) < 0) + panic( "could not send request" ); + + /* read the OKAY answer */ + if (unix_read(s, buffer, 4) != 4) + panic( "could not read request" ); + + printf( "server answer: %.*s\n", 4, buffer ); + + /* now loop */ + for (;;) { + char head[5] = "0000"; + + if (unix_read(s, head, 4) < 0) + panic("could not read length"); + + if ( sscanf( head, "%04x", &len ) != 1 ) + panic("could not decode length"); + + if (unix_read(s, buffer, len) != len) + panic("could not read data"); + + printf( "received header %.*s (%d bytes):\n%.*s", 4, head, len, len, buffer ); + } + close(s); +} diff --git a/src/test_track_jdwp.c b/src/test_track_jdwp.c new file mode 100644 index 0000000..8ecc6b8 --- /dev/null +++ b/src/test_track_jdwp.c @@ -0,0 +1,97 @@ +/* a simple test program, connects to ADB server, and opens a track-devices session */ +#include +#include +#include +#include +#include +#include + +static void +panic( const char* msg ) +{ + fprintf(stderr, "PANIC: %s: %s\n", msg, strerror(errno)); + exit(1); +} + +static int +unix_write( int fd, const char* buf, int len ) +{ + int result = 0; + while (len > 0) { + int len2 = write(fd, buf, len); + if (len2 < 0) { + if (errno == EINTR || errno == EAGAIN) + continue; + return -1; + } + result += len2; + len -= len2; + buf += len2; + } + return result; +} + +static int +unix_read( int fd, char* buf, int len ) +{ + int result = 0; + while (len > 0) { + int len2 = read(fd, buf, len); + if (len2 < 0) { + if (errno == EINTR || errno == EAGAIN) + continue; + return -1; + } + result += len2; + len -= len2; + buf += len2; + } + return result; +} + + +int main( void ) +{ + int ret, s; + struct sockaddr_in server; + char buffer[1024]; + const char* request = "track-jdwp"; + int len; + + memset( &server, 0, sizeof(server) ); + server.sin_family = AF_INET; + server.sin_port = htons(5037); + server.sin_addr.s_addr = htonl(INADDR_LOOPBACK); + + 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 */ + len = snprintf( buffer, sizeof buffer, "%04x%s", strlen(request), request ); + if (unix_write(s, buffer, len) < 0) + panic( "could not send request" ); + + /* read the OKAY answer */ + if (unix_read(s, buffer, 4) != 4) + panic( "could not read request" ); + + printf( "server answer: %.*s\n", 4, buffer ); + + /* now loop */ + for (;;) { + char head[5] = "0000"; + + if (unix_read(s, head, 4) < 0) + panic("could not read length"); + + if ( sscanf( head, "%04x", &len ) != 1 ) + panic("could not decode length"); + + if (unix_read(s, buffer, len) != len) + panic("could not read data"); + + printf( "received header %.*s (%d bytes):\n%.*s", 4, head, len, len, buffer ); + } + close(s); +} diff --git a/src/transport.c b/src/transport.c new file mode 100644 index 0000000..e605029 --- /dev/null +++ b/src/transport.c @@ -0,0 +1,1104 @@ +/* + * 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 "sysdeps.h" + +#define TRACE_TAG TRACE_TRANSPORT +#include "sdb.h" + +static void transport_unref(atransport *t); + +static atransport transport_list = { + .next = &transport_list, + .prev = &transport_list, +}; + +SDB_MUTEX_DEFINE( transport_lock ); + +#if SDB_TRACE +static void dump_hex( const unsigned char* ptr, size_t len ) +{ + int nn, len2 = len; + + if (len2 > 16) len2 = 16; + + for (nn = 0; nn < len2; nn++) + D("%02x", ptr[nn]); + D(" "); + + for (nn = 0; nn < len2; nn++) { + int c = ptr[nn]; + if (c < 32 || c > 127) + c = '.'; + D("%c", c); + } + D("\n"); + fflush(stdout); +} +#endif + +void +kick_transport(atransport* t) +{ + if (t && !t->kicked) + { + int kicked; + + sdb_mutex_lock(&transport_lock); + kicked = t->kicked; + if (!kicked) + t->kicked = 1; + sdb_mutex_unlock(&transport_lock); + + if (!kicked) + t->kick(t); + } +} + +void +run_transport_disconnects(atransport* t) +{ + adisconnect* dis = t->disconnects.next; + + D("run_transport_disconnects: %p (%s)\n", t, t->serial ? t->serial : "unknown" ); + while (dis != &t->disconnects) { + adisconnect* next = dis->next; + dis->func( dis->opaque, t ); + dis = next; + } +} + +static int +read_packet(int fd, apacket** ppacket) +{ + char *p = (char*)ppacket; /* really read a packet address */ + int r; + int len = sizeof(*ppacket); + while(len > 0) { + r = sdb_read(fd, p, len); + if(r > 0) { + len -= r; + p += r; + } else { + D("read_packet: %d error %d %d\n", fd, r, errno); + if((r < 0) && (errno == EINTR)) continue; + return -1; + } + } + +#if SDB_TRACE + if (SDB_TRACING) + { + unsigned command = (*ppacket)->msg.command; + int len = (*ppacket)->msg.data_length; + char cmd[5]; + int n; + + for (n = 0; n < 4; n++) { + int b = (command >> (n*8)) & 255; + if (b >= 32 && b < 127) + cmd[n] = (char)b; + else + cmd[n] = '.'; + } + cmd[4] = 0; + + D("read_packet: %d ok: [%08x %s] %08x %08x (%d) ", + fd, command, cmd, (*ppacket)->msg.arg0, (*ppacket)->msg.arg1, len); + dump_hex((*ppacket)->data, len); + } +#endif + return 0; +} + +static int +write_packet(int fd, apacket** ppacket) +{ + char *p = (char*) ppacket; /* we really write the packet address */ + int r, len = sizeof(ppacket); + +#if SDB_TRACE + if (SDB_TRACING) + { + unsigned command = (*ppacket)->msg.command; + int len = (*ppacket)->msg.data_length; + char cmd[5]; + int n; + + for (n = 0; n < 4; n++) { + int b = (command >> (n*8)) & 255; + if (b >= 32 && b < 127) + cmd[n] = (char)b; + else + cmd[n] = '.'; + } + cmd[4] = 0; + + D("write_packet: %d [%08x %s] %08x %08x (%d) ", + fd, command, cmd, (*ppacket)->msg.arg0, (*ppacket)->msg.arg1, len); + dump_hex((*ppacket)->data, len); + } +#endif + len = sizeof(ppacket); + while(len > 0) { + r = sdb_write(fd, p, len); + if(r > 0) { + len -= r; + p += r; + } else { + D("write_packet: %d error %d %d\n", fd, r, errno); + if((r < 0) && (errno == EINTR)) continue; + return -1; + } + } + return 0; +} + +static void transport_socket_events(int fd, unsigned events, void *_t) +{ + if(events & FDE_READ){ + apacket *p = 0; + if(read_packet(fd, &p)){ + D("failed to read packet from transport socket on fd %d\n", 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) { + fatal_errno("Transport is null"); + D("Transport is null \n"); + } + + if(write_packet(t->transport_socket, &p)){ + fatal_errno("cannot enqueue packet on transport socket"); + } +} + +/* The transport is opened by transport_register_func before +** the input and output threads are started. +** +** The output thread issues a SYNC(1, token) message to let +** the input thread know to start things up. In the event +** of transport IO failure, the output thread will post a +** SYNC(0,0) message to ensure shutdown. +** +** The transport will not actually be closed until both +** threads exit, but the input thread will kick the transport +** on its way out to disconnect the underlying device. +*/ + +static void *output_thread(void *_t) +{ + atransport *t = _t; + apacket *p; + + D("from_remote: starting thread for transport %p, on fd %d\n", t, t->fd ); + + D("from_remote: transport %p SYNC online (%d)\n", t, 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, &p)) { + put_apacket(p); + D("from_remote: failed to write SYNC apacket to transport %p", t); + goto oops; + } + + D("from_remote: data pump for transport %p\n", t); + for(;;) { + p = get_apacket(); + + if(t->read_from_remote(p, t) == 0){ + D("from_remote: received remote packet, sending to transport %p\n", + t); + if(write_packet(t->fd, &p)){ + put_apacket(p); + D("from_remote: failed to write apacket to transport %p", t); + goto oops; + } + } else { + D("from_remote: remote read failed for transport %p\n", p); + put_apacket(p); + break; + } + } + + D("from_remote: SYNC offline for transport %p\n", t); + 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, &p)) { + put_apacket(p); + D("from_remote: failed to write SYNC apacket to transport %p", t); + } + +oops: + D("from_remote: thread is exiting for transport %p\n", t); + kick_transport(t); + transport_unref(t); + return 0; +} + +static void *input_thread(void *_t) +{ + atransport *t = _t; + apacket *p; + int active = 0; + + D("to_remote: starting input_thread for %p, reading from fd %d\n", + t, t->fd); + + for(;;){ + if(read_packet(t->fd, &p)) { + D("to_remote: failed to read apacket from transport %p on fd %d\n", + t, t->fd ); + break; + } + if(p->msg.command == A_SYNC){ + if(p->msg.arg0 == 0) { + D("to_remote: transport %p SYNC offline\n", t); + put_apacket(p); + break; + } else { + if(p->msg.arg1 == t->sync_token) { + D("to_remote: transport %p SYNC online\n", t); + active = 1; + } else { + D("to_remote: trandport %p ignoring SYNC %d != %d\n", + t, p->msg.arg1, t->sync_token); + } + } + } else { + if(active) { + D("to_remote: transport %p got packet, sending to remote\n", t); + t->write_to_remote(p, t); + } else { + D("to_remote: transport %p ignoring packet while offline\n", t); + } + } + + put_apacket(p); + } + + // this is necessary to avoid a race condition that occured when a transport closes + // while a client socket is still active. + close_all_sockets(t); + + D("to_remote: thread is exiting for transport %p, fd %d\n", t, t->fd); + kick_transport(t); + transport_unref(t); + return 0; +} + + +static int transport_registration_send = -1; +static int transport_registration_recv = -1; +static fdevent transport_registration_fde; + + +#if SDB_HOST +static int list_transports_msg(char* buffer, size_t bufferlen) +{ + char head[5]; + int len; + + len = list_transports(buffer+4, bufferlen-4); + snprintf(head, sizeof(head), "%04x", len); + memcpy(buffer, head, 4); + len += 4; + return len; +} + +/* 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 + */ +typedef struct device_tracker device_tracker; +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; + + sdb_mutex_lock( &transport_lock ); + while (node) { + if (node == tracker) { + *pnode = node->next; + break; + } + pnode = &node->next; + node = *pnode; + } + sdb_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\n", 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 char* buffer, + int len ) +{ + apacket* p = get_apacket(); + asocket* peer = tracker->socket.peer; + + memcpy(p->data, buffer, len); + p->len = len; + return peer->enqueue( peer, p ); +} + + +static void +device_tracker_ready( asocket* socket ) +{ + device_tracker* tracker = (device_tracker*) socket; + + /* we want to send the device list when the tracker connects + * for the first time, even if no update occured */ + if (tracker->update_needed > 0) { + char buffer[1024]; + int len; + + tracker->update_needed = 0; + + len = list_transports_msg(buffer, sizeof(buffer)); + device_tracker_send(tracker, buffer, len); + } +} + + +asocket* +create_device_tracker(void) +{ + device_tracker* tracker = calloc(1,sizeof(*tracker)); + + if(tracker == 0) fatal("cannot allocate device tracker"); + + D( "device tracker %p created\n", 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; +} + +void save_devicename(void) +{ + int fd; + char buffer[MAX_PAYLOAD]; + atransport *t; + + sdb_mutex_lock(&transport_lock); + if (access(DEVICEMAP_FILENAME, F_OK) == 0) // if exist + sdb_unlink(DEVICEMAP_FILENAME); + fd = unix_open(DEVICEMAP_FILENAME, O_WRONLY | O_CREAT, 0640); + + if (fd <0 ) { + D("failed to save devicename to %s\n",DEVICEMAP_FILENAME); + sdb_mutex_unlock(&transport_lock); + return; + } + + for(t = transport_list.next; t != &transport_list; t = t->next) { + sprintf(buffer,"%s%s%d\n", t->device_name, DEVICEMAP_SEPARATOR, t->sdb_port); + sdb_write(fd, buffer, strlen(buffer)); + } + sdb_mutex_unlock(&transport_lock); + sdb_close(fd); +} + +/* call this function each time the transport list has changed */ +void update_transports(void) +{ + char buffer[1024]; + int len; + device_tracker* tracker; + + len = list_transports_msg(buffer, sizeof(buffer)); + + tracker = device_tracker_list; + while (tracker != NULL) { + device_tracker* next = tracker->next; + /* note: this may destroy the tracker if the connection is closed */ + device_tracker_send(tracker, buffer, len); + tracker = next; + } + save_devicename(); +} +#else +void update_transports(void) +{ + // nothing to do on the device side +} +#endif // SDB_HOST + +typedef struct tmsg tmsg; +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 = sdb_read(fd, p, len); + if(r > 0) { + len -= r; + p += r; + } else { + if((r < 0) && (errno == EINTR)) continue; + D("transport_read_action: on fd %d, error %d: %s\n", + fd, errno, 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 = sdb_write(fd, p, len); + if(r > 0) { + len -= r; + p += r; + } else { + if((r < 0) && (errno == EINTR)) continue; + D("transport_write_action: on fd %d, error %d: %s\n", + fd, errno, strerror(errno)); + return -1; + } + } + return 0; +} + +static void transport_registration_func(int _fd, unsigned ev, void *data) +{ + tmsg m; + sdb_thread_t output_thread_ptr; + sdb_thread_t input_thread_ptr; + 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: %p removing and free'ing %d\n", t, t->transport_socket); + + /* IMPORTANT: the remove closes one half of the + ** socket pair. The close closes the other half. + */ + fdevent_remove(&(t->transport_fde)); + sdb_close(t->fd); + + sdb_mutex_lock(&transport_lock); + t->next->prev = t->prev; + t->prev->next = t->next; + sdb_mutex_unlock(&transport_lock); + + run_transport_disconnects(t); + + if (t->product) + free(t->product); + if (t->serial) + free(t->serial); + if (t->device_name) + free(t->device_name); + memset(t,0xee,sizeof(atransport)); + free(t); + + update_transports(); + return; + } + + /* don't create transport threads for inaccessible devices */ + if (t->connection_state != CS_NOPERM) { + /* initial references are the two threads */ + t->ref_count = 2; + + if(sdb_socketpair(s)) { + fatal_errno("cannot open transport socketpair"); + } + + D("transport: %p (%d,%d) starting\n", t, s[0], s[1]); + + t->transport_socket = s[0]; + t->fd = s[1]; + + D("transport: %p install %d\n", t, t->transport_socket ); + fdevent_install(&(t->transport_fde), + t->transport_socket, + transport_socket_events, + t); + + fdevent_set(&(t->transport_fde), FDE_READ); + + if(sdb_thread_create(&input_thread_ptr, input_thread, t)){ + fatal_errno("cannot create input thread"); + } + + if(sdb_thread_create(&output_thread_ptr, output_thread, t)){ + fatal_errno("cannot create output thread"); + } + } + + /* put us on the master device list */ + sdb_mutex_lock(&transport_lock); + t->next = &transport_list; + t->prev = transport_list.prev; + t->next->prev = t; + t->prev->next = t; + sdb_mutex_unlock(&transport_lock); + + t->disconnects.next = t->disconnects.prev = &t->disconnects; + + update_transports(); +} + +void init_transport_registration(void) +{ + int s[2]; + + if(sdb_socketpair(s)){ + fatal_errno("cannot open transport registration socketpair"); + } + + 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: %p registered\n", transport); + 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: %p removed\n", transport); + if(transport_write_action(transport_registration_send, &m)) { + fatal_errno("cannot write transport registration socket\n"); + } +} + + +static void transport_unref_locked(atransport *t) +{ + t->ref_count--; + D("transport: %p R- (ref=%d)\n", t, t->ref_count); + if (t->ref_count == 0) { + D("transport: %p kicking and closing\n", t); + if (!t->kicked) { + t->kicked = 1; + t->kick(t); + } + t->close(t); + remove_transport(t); + } +} + +static void transport_unref(atransport *t) +{ + if (t) { + sdb_mutex_lock(&transport_lock); + transport_unref_locked(t); + sdb_mutex_unlock(&transport_lock); + } +} + +void add_transport_disconnect(atransport* t, adisconnect* dis) +{ + sdb_mutex_lock(&transport_lock); + dis->next = &t->disconnects; + dis->prev = dis->next->prev; + dis->prev->next = dis; + dis->next->prev = dis; + sdb_mutex_unlock(&transport_lock); +} + +void remove_transport_disconnect(atransport* t, adisconnect* dis) +{ + dis->prev->next = dis->next; + dis->next->prev = dis->prev; + dis->next = dis->prev = dis; +} + + +atransport *acquire_one_transport(int state, transport_type ttype, const char* serial, char** error_out) +{ + atransport *t; + atransport *result = NULL; + int ambiguous = 0; + +retry: + if (error_out) + *error_out = "device not found"; + + sdb_mutex_lock(&transport_lock); + for (t = transport_list.next; t != &transport_list; t = t->next) { + if (t->connection_state == CS_NOPERM) { + if (error_out) + *error_out = "insufficient permissions for device"; + continue; + } + + /* check for matching serial number */ + if (serial) { + if (t->serial && !strcmp(serial, t->serial)) { + result = t; + break; + } + } else { + if (ttype == kTransportUsb && t->type == kTransportUsb) { + if (result) { + if (error_out) + *error_out = "more than one device"; + ambiguous = 1; + result = NULL; + break; + } + result = t; + } else if (ttype == kTransportLocal && t->type == kTransportLocal) { + if (result) { + if (error_out) + *error_out = "more than one emulator"; + ambiguous = 1; + result = NULL; + break; + } + result = t; + } else if (ttype == kTransportAny) { + if (result) { + if (error_out) + *error_out = "more than one device and emulator"; + ambiguous = 1; + result = NULL; + break; + } + result = t; + } + } + } + sdb_mutex_unlock(&transport_lock); + + if (result) { + /* offline devices are ignored -- they are either being born or dying */ + if (result && result->connection_state == CS_OFFLINE) { + if (error_out) + *error_out = "device offline"; + result = NULL; + } + /* check for required connection state */ + if (result && state != CS_ANY && result->connection_state != state) { + if (error_out) + *error_out = "invalid device state"; + result = NULL; + } + } + + if (result) { + /* found one that we can take */ + if (error_out) + *error_out = NULL; + } else if (state != CS_ANY && (serial || !ambiguous)) { + sdb_sleep_ms(1000); + goto retry; + } + + return result; +} + +#if SDB_HOST +static const char *statename(atransport *t) +{ + switch(t->connection_state){ + case CS_OFFLINE: return "offline"; + case CS_BOOTLOADER: return "bootloader"; + case CS_DEVICE: return "device"; + case CS_HOST: return "host"; + case CS_RECOVERY: return "recovery"; + case CS_NOPERM: return "no permissions"; + default: return "unknown"; + } +} + +int list_transports(char *buf, size_t bufsize) +{ + char* p = buf; + char* end = buf + bufsize; + int len; + atransport *t; + + /* XXX OVERRUN PROBLEMS XXX */ + sdb_mutex_lock(&transport_lock); + for(t = transport_list.next; t != &transport_list; t = t->next) { + const char* serial = t->serial; + const char* devicename = (t->device_name == NULL) ? DEFAULT_DEVICENAME : t->device_name; /* tizen specific */ + if (!serial || !serial[0]) + serial = "????????????"; + len = snprintf(p, end - p, "%s\t%s\t%s\n", serial, statename(t), devicename); + + if (p + len >= end) { + /* discard last line if buffer is too short */ + break; + } + p += len; + } + p[0] = 0; + sdb_mutex_unlock(&transport_lock); + return p - buf; +} + + +/* hack for osx */ +void close_usb_devices() +{ + atransport *t; + + sdb_mutex_lock(&transport_lock); + for(t = transport_list.next; t != &transport_list; t = t->next) { + if ( !t->kicked ) { + t->kicked = 1; + t->kick(t); + } + } + sdb_mutex_unlock(&transport_lock); +} +#endif // SDB_HOST + +void register_socket_transport(int s, const char *serial, int port, int local, const char *device_name) +{ + atransport *t = calloc(1, sizeof(atransport)); + D("transport: %p init'ing for socket %d, on port %d (%s)\n", t, s, port, device_name); + if ( init_socket_transport(t, s, port, local) < 0 ) { + sdb_close(s); + free(t); +#if SDB_HOST /* tizen specific */ + atransport *old_t = find_transport(serial); + if (old_t) { + unregister_transport(old_t); + } else { + D("No such device %s", serial); + } +#endif + return; + } + if(serial) { + t->serial = strdup(serial); + } +#if SDB_HOST + if (device_name) /* tizen specific */ + t->device_name = strdup(device_name); + else { // device_name could be null when sdb server was forked before qemu has sent the connect message. + char device_name[DEVICENAME_MAX]; + if (get_devicename_from_shdmem(port, device_name) == 0) + t->device_name = strdup(device_name); + } +#endif + register_transport(t); +} + +#if SDB_HOST +atransport *find_transport(const char *serial) +{ + atransport *t; + + sdb_mutex_lock(&transport_lock); + for(t = transport_list.next; t != &transport_list; t = t->next) { + if (t->serial && !strcmp(serial, t->serial)) { + break; + } + } + sdb_mutex_unlock(&transport_lock); + + if (t != &transport_list) + return t; + else + return 0; +} + +void unregister_transport(atransport *t) +{ + sdb_mutex_lock(&transport_lock); + t->next->prev = t->prev; + t->prev->next = t->next; + sdb_mutex_unlock(&transport_lock); + + kick_transport(t); + transport_unref(t); +} + +// unregisters all non-emulator TCP transports +void unregister_all_tcp_transports() +{ + atransport *t, *next; + sdb_mutex_lock(&transport_lock); + for (t = transport_list.next; t != &transport_list; t = next) { + next = t->next; + if (t->type == kTransportLocal && t->sdb_port == 0) { + t->next->prev = t->prev; + t->prev->next = next; + // we cannot call kick_transport when holding transport_lock + if (!t->kicked) + { + t->kicked = 1; + t->kick(t); + } + transport_unref_locked(t); + } + } + + sdb_mutex_unlock(&transport_lock); +} + +#endif +int get_connected_device_count(transport_type type) /* tizen specific */ +{ + int cnt = 0; + atransport *t; + sdb_mutex_lock(&transport_lock); + for(t = transport_list.next; t != &transport_list; t = t->next) { + if (type == kTransportUsb && t->type == kTransportUsb) + cnt++; + } + sdb_mutex_unlock(&transport_lock); + D("connected device count:%d\n",cnt); + return cnt; +} + +void register_usb_transport(usb_handle *usb, const char *serial, unsigned writeable) +{ + atransport *t = calloc(1, sizeof(atransport)); + char device_name[256]; + + D("transport: %p init'ing for usb_handle %p (sn='%s')\n", t, usb, + serial ? serial : ""); + init_usb_transport(t, usb, (writeable ? CS_OFFLINE : CS_NOPERM)); + if(serial) { + t->serial = strdup(serial); + } + /* tizen specific */ + sprintf(device_name, "device-%d",get_connected_device_count(kTransportUsb)+1); + t->device_name = strdup(device_name); + register_transport(t); +} + +/* this should only be used for transports with connection_state == CS_NOPERM */ +void unregister_usb_transport(usb_handle *usb) +{ + atransport *t; + sdb_mutex_lock(&transport_lock); + for(t = transport_list.next; t != &transport_list; t = t->next) { + if (t->usb == usb && t->connection_state == CS_NOPERM) { + t->next->prev = t->prev; + t->prev->next = t->next; + break; + } + } + sdb_mutex_unlock(&transport_lock); +} + +#undef TRACE_TAG +#define TRACE_TAG TRACE_RWX + +int readx(int fd, void *ptr, size_t len) +{ + char *p = ptr; + int r; +#if SDB_TRACE + int len0 = len; +#endif + D("readx: %d %p %d\n", fd, ptr, (int)len); + while(len > 0) { + r = sdb_read(fd, p, len); + if(r > 0) { + len -= r; + p += r; + } else { + D("readx: %d %d %s\n", fd, r, strerror(errno)); + if((r < 0) && (errno == EINTR)) continue; + return -1; + } + } + +#if SDB_TRACE + D("readx: %d ok: ", fd); + dump_hex( ptr, len0 ); +#endif + return 0; +} + +int writex(int fd, const void *ptr, size_t len) +{ + char *p = (char*) ptr; + int r; + +#if SDB_TRACE + D("writex: %d %p %d: ", fd, ptr, (int)len); + dump_hex( ptr, len ); +#endif + while(len > 0) { + r = sdb_write(fd, p, len); + if(r > 0) { + len -= r; + p += r; + } else { + D("writex: %d %d %s\n", fd, r, strerror(errno)); + if((r < 0) && (errno == EINTR)) continue; + return -1; + } + } + + D("writex: %d ok\n", fd); + return 0; +} + +int check_header(apacket *p) +{ + if(p->msg.magic != (p->msg.command ^ 0xffffffff)) { + D("check_header(): invalid magic\n"); + return -1; + } + + if(p->msg.data_length > MAX_PAYLOAD) { + D("check_header(): %d > MAX_PAYLOAD\n", p->msg.data_length); + 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; + } +} + diff --git a/src/transport_local.c b/src/transport_local.c new file mode 100644 index 0000000..9530c8f --- /dev/null +++ b/src/transport_local.c @@ -0,0 +1,439 @@ +/* + * 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 "sysdeps.h" +#include + +#ifndef HAVE_WIN32_IPC +#include +#include +#include +#endif + +#define TRACE_TAG TRACE_TRANSPORT +#include "sdb.h" + +#ifdef __ppc__ +#define H4(x) (((x) & 0xFF000000) >> 24) | (((x) & 0x00FF0000) >> 8) | (((x) & 0x0000FF00) << 8) | (((x) & 0x000000FF) << 24) +static inline void fix_endians(apacket *p) +{ + p->msg.command = H4(p->msg.command); + p->msg.arg0 = H4(p->msg.arg0); + p->msg.arg1 = H4(p->msg.arg1); + p->msg.data_length = H4(p->msg.data_length); + p->msg.data_check = H4(p->msg.data_check); + p->msg.magic = H4(p->msg.magic); +} +#else +#define fix_endians(p) do {} while (0) +#endif + +#if SDB_HOST +/* 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. + */ +#define SDB_LOCAL_TRANSPORT_MAX 16 + +SDB_MUTEX_DEFINE( local_transports_lock ); + +static atransport* local_transports[ SDB_LOCAL_TRANSPORT_MAX ]; +#endif /* SDB_HOST */ + +static int remote_read(apacket *p, atransport *t) +{ + if(readx(t->sfd, &p->msg, sizeof(amessage))){ + D("remote local: read terminated (message)\n"); + return -1; + } + + fix_endians(p); + +#if 0 && defined __ppc__ + D("read remote packet: %04x arg0=%0x arg1=%0x data_length=%0x data_check=%0x magic=%0x\n", + p->msg.command, p->msg.arg0, p->msg.arg1, p->msg.data_length, p->msg.data_check, p->msg.magic); +#endif + if(check_header(p)) { + D("bad header: terminated (data)\n"); + return -1; + } + + if(readx(t->sfd, p->data, p->msg.data_length)){ + D("remote local: terminated (data)\n"); + return -1; + } + + if(check_data(p)) { + D("bad data: terminated (data)\n"); + return -1; + } + + return 0; +} + +static int remote_write(apacket *p, atransport *t) +{ + int length = p->msg.data_length; + + fix_endians(p); + +#if 0 && defined __ppc__ + D("write remote packet: %04x arg0=%0x arg1=%0x data_length=%0x data_check=%0x magic=%0x\n", + p->msg.command, p->msg.arg0, p->msg.arg1, p->msg.data_length, p->msg.data_check, p->msg.magic); +#endif + if(writex(t->sfd, &p->msg, sizeof(amessage) + length)) { + D("remote local: write terminated\n"); + return -1; + } + + return 0; +} + + +int local_connect(int port, const char *device_name) { + return local_connect_arbitrary_ports(port-1, port, device_name); +} + +int local_connect_arbitrary_ports(int console_port, int sdb_port, const char *device_name) +{ + char buf[64]; + int fd = -1; + +#if SDB_HOST + const char *host = getenv("SDBHOST"); + if (host) { + fd = socket_network_client(host, sdb_port, SOCK_STREAM); + } +#endif + if (fd < 0) { + fd = socket_loopback_client(sdb_port, SOCK_STREAM); + } + + if (fd >= 0) { + D("client: connected on remote on fd %d\n", fd); + close_on_exec(fd); + disable_tcp_nagle(fd); + snprintf(buf, sizeof buf, "%s%d", LOCAL_CLIENT_PREFIX, console_port); + register_socket_transport(fd, buf, sdb_port, 1, device_name); + return 0; + } + return -1; +} + +#if SDB_HOST /* tizen specific */ +int get_devicename(int port, char *device_name) +{ + int fd; + char buffer[MAX_PAYLOAD]; + char *tok = NULL; + int found = 0; + + fd = unix_open(DEVICEMAP_FILENAME, O_RDONLY); + if (fd > 0) { + for(;;) { + if(read_line(fd, buffer, MAX_PAYLOAD) < 0) + break; + tok = strtok(buffer, DEVICEMAP_SEPARATOR); + if (tok != NULL) { + strncpy(device_name, tok, DEVICENAME_MAX); + tok = strtok(NULL, DEVICEMAP_SEPARATOR); + if (tok != NULL) { + if (port == atoi(tok)) { + found = 1; + break; + } + } + } + } + sdb_close(fd); + } + if (found != 1) + strncpy(device_name, DEFAULT_DEVICENAME, DEVICENAME_MAX); + D("init device name %s on port %d\n", device_name, port); + + return found; +} + +int get_devicename_from_shdmem(int port, char *device_name) +{ + char *vms = NULL; +#ifndef HAVE_WIN32_IPC + int shm_id; + void *shared_memory = (void *)0; + + shm_id = shmget( (key_t)port-1, 0, 0); + if (shm_id == -1) + return -1; + + shared_memory = shmat(shm_id, (void *)0, SHM_RDONLY); + + if (shared_memory == (void *)-1) + { + D("faild to get shdmem key (%d) : %s\n", port, strerror(errno)); + return -1; + } + + vms = strstr((char*)shared_memory, VMS_PATH); + if (vms != NULL) + strncpy(device_name, vms+strlen(VMS_PATH), DEVICENAME_MAX); + else + strncpy(device_name, DEFAULT_DEVICENAME, DEVICENAME_MAX); + +#else /* _WIN32*/ + HANDLE hMapFile; + char s_port[5]; + char* pBuf; + + sprintf(s_port, "%d", port-1); + hMapFile = OpenFileMapping(FILE_MAP_READ, TRUE, s_port); + + if(hMapFile == NULL) { + D("faild to get shdmem key (%ld) : %s\n", port, GetLastError() ); + return -1; + } + pBuf = (char*)MapViewOfFile(hMapFile, + FILE_MAP_READ, + 0, + 0, + 50); + if (pBuf == NULL) { + D("Could not map view of file (%ld)\n", GetLastError()); + CloseHandle(hMapFile); + return -1; + } + + vms = strstr((char*)pBuf, VMS_PATH); + if (vms != NULL) + strncpy(device_name, vms+strlen(VMS_PATH), DEVICENAME_MAX); + else + strncpy(device_name, DEFAULT_DEVICENAME, DEVICENAME_MAX); + CloseHandle(hMapFile); +#endif + D("init device name %s on port %d\n", device_name, port); + + return 0; +} + +int read_line(const int fd, char* ptr, size_t maxlen) +{ + unsigned int n = 0; + char c[2]; + int rc; + + while(n != maxlen) { + if((rc = sdb_read(fd, c, 1)) != 1) + return -1; // eof or read err + + if(*c == '\n') { + ptr[n] = 0; + return n; + } + ptr[n++] = *c; + } + return -1; // no space +} +#endif + +static void *client_socket_thread(void *x) +{ +#if SDB_HOST +// for (;;){ + int port = DEFAULT_SDB_LOCAL_TRANSPORT_PORT; + int count = SDB_LOCAL_TRANSPORT_MAX; + + D("transport: client_socket_thread() starting\n"); + + /* try to connect to any number of running emulator instances */ + /* this is only done when SDB starts up. later, each new emulator */ + /* will send a message to SDB to indicate that is is starting up */ + for (; count > 0; count--, port += 10 ) { + (void) local_connect(port, NULL); + } + +// sdb_sleep_ms(1000); +// } +#endif + return 0; +} + +static void *server_socket_thread(void * arg) +{ + int serverfd, fd; + struct sockaddr addr; + socklen_t alen; + int port = (int)arg; + + D("transport: server_socket_thread() starting\n"); + serverfd = -1; + for(;;) { + if(serverfd == -1) { + serverfd = socket_inaddr_any_server(port, SOCK_STREAM); + if(serverfd < 0) { + D("server: cannot bind socket yet\n"); + sdb_sleep_ms(1000); + continue; + } + close_on_exec(serverfd); + } + + alen = sizeof(addr); + D("server: trying to get new connection from %d\n", port); + fd = sdb_socket_accept(serverfd, &addr, &alen); + if(fd >= 0) { + D("server: new connection on fd %d\n", fd); + close_on_exec(fd); + disable_tcp_nagle(fd); + register_socket_transport(fd, "host", port, 1, NULL); + } + } + D("transport: server_socket_thread() exiting\n"); + return 0; +} + +void local_init(int port) +{ + sdb_thread_t thr; + void* (*func)(void *); + + if(HOST) { + func = client_socket_thread; + } else { + func = server_socket_thread; + } + + D("transport: local %s init\n", HOST ? "client" : "server"); + + if(sdb_thread_create(&thr, func, (void *)port)) { + fatal_errno("cannot create local socket %s thread", + HOST ? "client" : "server"); + } +} + +static void remote_kick(atransport *t) +{ + int fd = t->sfd; + t->sfd = -1; + sdb_shutdown(fd); + sdb_close(fd); + +#if SDB_HOST + if(HOST) { + int nn; + sdb_mutex_lock( &local_transports_lock ); + for (nn = 0; nn < SDB_LOCAL_TRANSPORT_MAX; nn++) { + if (local_transports[nn] == t) { + local_transports[nn] = NULL; + break; + } + } + sdb_mutex_unlock( &local_transports_lock ); + } +#endif +} + +static void remote_close(atransport *t) +{ + sdb_close(t->fd); +} + + +#if SDB_HOST +/* Only call this function if you already hold local_transports_lock. */ +atransport* find_emulator_transport_by_sdb_port_locked(int sdb_port) +{ + int i; + for (i = 0; i < SDB_LOCAL_TRANSPORT_MAX; i++) { + if (local_transports[i] && local_transports[i]->sdb_port == sdb_port) { + return local_transports[i]; + } + } + return NULL; +} + +atransport* find_emulator_transport_by_sdb_port(int sdb_port) +{ + sdb_mutex_lock( &local_transports_lock ); + atransport* result = find_emulator_transport_by_sdb_port_locked(sdb_port); + sdb_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 < SDB_LOCAL_TRANSPORT_MAX; i++) { + if (local_transports[i] == NULL) { + return i; + } + } + return -1; +} + +int get_available_local_transport_index() +{ + sdb_mutex_lock( &local_transports_lock ); + int result = get_available_local_transport_index_locked(); + sdb_mutex_unlock( &local_transports_lock ); + return result; +} +#endif + +int init_socket_transport(atransport *t, int s, int sdb_port, int local) +{ + int fail = 0; + + t->kick = 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 = CS_OFFLINE; + t->type = kTransportLocal; + t->sdb_port = 0; + +#if SDB_HOST + if (HOST && local) { + sdb_mutex_lock( &local_transports_lock ); + { + t->sdb_port = sdb_port; + atransport* existing_transport = + find_emulator_transport_by_sdb_port_locked(sdb_port); + int index = get_available_local_transport_index_locked(); + if (existing_transport != NULL) { + D("local transport for port %d already registered (%p)?\n", + sdb_port, existing_transport); + fail = -1; + } else if (index < 0) { + // Too many emulators. + D("cannot register more emulators. Maximum is %d\n", + SDB_LOCAL_TRANSPORT_MAX); + fail = -1; + } else { + local_transports[index] = t; + } + } + sdb_mutex_unlock( &local_transports_lock ); + } +#endif + return fail; +} diff --git a/src/transport_usb.c b/src/transport_usb.c new file mode 100644 index 0000000..4233111 --- /dev/null +++ b/src/transport_usb.c @@ -0,0 +1,149 @@ +/* + * 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 + +#define TRACE_TAG TRACE_TRANSPORT +#include "sdb.h" + +#if SDB_HOST +#include "usb_vendors.h" +#endif + +/* XXX better define? */ +#ifdef __ppc__ +#define H4(x) (((x) & 0xFF000000) >> 24) | (((x) & 0x00FF0000) >> 8) | (((x) & 0x0000FF00) << 8) | (((x) & 0x000000FF) << 24) +static inline void fix_endians(apacket *p) +{ + p->msg.command = H4(p->msg.command); + p->msg.arg0 = H4(p->msg.arg0); + p->msg.arg1 = H4(p->msg.arg1); + p->msg.data_length = H4(p->msg.data_length); + p->msg.data_check = H4(p->msg.data_check); + p->msg.magic = H4(p->msg.magic); +} +unsigned host_to_le32(unsigned n) +{ + return H4(n); +} +#else +#define fix_endians(p) do {} while (0) +unsigned host_to_le32(unsigned n) +{ + return n; +} +#endif + +static int remote_read(apacket *p, atransport *t) +{ + if(usb_read(t->usb, &p->msg, sizeof(amessage))){ + D("remote usb: read terminated (message)\n"); + return -1; + } + + fix_endians(p); + + if(check_header(p)) { + D("remote usb: check_header failed\n"); + return -1; + } + + if(p->msg.data_length) { + if(usb_read(t->usb, p->data, p->msg.data_length)){ + D("remote usb: terminated (data)\n"); + return -1; + } + } + + if(check_data(p)) { + D("remote usb: check_data failed\n"); + return -1; + } + + return 0; +} + +static int remote_write(apacket *p, atransport *t) +{ + unsigned size = p->msg.data_length; + + fix_endians(p); + + if(usb_write(t->usb, &p->msg, sizeof(amessage))) { + D("remote usb: 1 - write terminated\n"); + return -1; + } + if(p->msg.data_length == 0) return 0; + if(usb_write(t->usb, &p->data, size)) { + D("remote usb: 2 - write terminated\n"); + 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, int state) +{ + D("transport: usb\n"); + t->close = remote_close; + t->kick = 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 SDB_HOST + HOST = 1; +#else + HOST = 0; +#endif +} + +#if SDB_HOST +int is_sdb_interface(int vid, int pid, int usb_class, int usb_subclass, int usb_protocol) +{ + unsigned i; + for (i = 0; i < vendorIdCount; i++) { + if (vid == vendorIds[i]) { + if (usb_class == SDB_CLASS && usb_subclass == SDB_SUBCLASS && + usb_protocol == SDB_PROTOCOL) { + return 1; + } + + return 0; + } + } + + return 0; +} +#endif diff --git a/src/usb_libusb.c b/src/usb_libusb.c new file mode 100644 index 0000000..c9247ae --- /dev/null +++ b/src/usb_libusb.c @@ -0,0 +1,657 @@ +/* + * Copyright (C) 2009 bsdroid project + * Alexey Tarasov + * + * 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 "sysdeps.h" + +#define TRACE_TAG TRACE_USB +#include "sdb.h" + +static sdb_mutex_t usb_lock = SDB_MUTEX_INITIALIZER; +static libusb_context *ctx = NULL; + +struct usb_handle +{ + usb_handle *prev; + usb_handle *next; + + libusb_device *dev; + libusb_device_handle *devh; + int interface; + uint8_t dev_bus; + uint8_t dev_addr; + + int zero_mask; + unsigned char end_point_address[2]; + char serial[128]; + + sdb_cond_t notify; + sdb_mutex_t lock; +}; + +static struct usb_handle handle_list = { + .prev = &handle_list, + .next = &handle_list, +}; + +void +usb_cleanup() +{ + libusb_exit(ctx); +} + +void +report_bulk_libusb_error(int r) +{ + switch (r) { + case LIBUSB_ERROR_TIMEOUT: + D("Transfer timeout\n"); + break; + + case LIBUSB_ERROR_PIPE: + D("Control request is not supported\n"); + break; + + case LIBUSB_ERROR_OVERFLOW: + D("Device offered more data\n"); + break; + + case LIBUSB_ERROR_NO_DEVICE : + D("Device was disconnected\n"); + break; + + default: + D("Error %d during transfer\n", r); + break; + }; +} + +static int +usb_bulk_write(usb_handle *uh, const void *data, int len) +{ + int r = 0; + int transferred = 0; + + r = libusb_bulk_transfer(uh->devh, uh->end_point_address[1], (void *)data, len, + &transferred, 0); + + if (r != 0) { + D("usb_bulk_write(): "); + report_bulk_libusb_error(r); + return r; + } + + return (transferred); +} + +static int +usb_bulk_read(usb_handle *uh, void *data, int len) +{ + int r = 0; + int transferred = 0; + + r = libusb_bulk_transfer(uh->devh, uh->end_point_address[0], data, len, + &transferred, 0); + + if (r != 0) { + D("usb_bulk_read(): "); + report_bulk_libusb_error(r); + return r; + } + + return (transferred); +} + +int +usb_write(struct usb_handle *uh, const void *_data, int len) +{ + unsigned char *data = (unsigned char*) _data; + int n; + int need_zero = 0; + + if (uh->zero_mask == 1) { + if (!(len & uh->zero_mask)) { + need_zero = 1; + } + } + + D("usb_write(): %p:%d -> transport %p\n", _data, len, uh); + + while (len > 0) { + int xfer = (len > 4096) ? 4096 : len; + + n = usb_bulk_write(uh, data, xfer); + + if (n != xfer) { + D("usb_write(): failed for transport %p (%d bytes left)\n", uh, len); + return -1; + } + + len -= xfer; + data += xfer; + } + + if (need_zero){ + n = usb_bulk_write(uh, _data, 0); + + if (n < 0) { + D("usb_write(): failed to finish operation for transport %p\n", uh); + } + return n; + } + + return 0; +} + +int +usb_read(struct usb_handle *uh, void *_data, int len) +{ + unsigned char *data = (unsigned char*) _data; + int n; + + D("usb_read(): %p:%d <- transport %p\n", _data, len, uh); + + while (len > 0) { + int xfer = (len > 4096) ? 4096 : len; + + n = usb_bulk_read(uh, data, xfer); + + if (n != xfer) { + if (n > 0) { + data += n; + len -= n; + continue; + } + + D("usb_read(): failed for transport %p (%d bytes left)\n", uh, len); + return -1; + } + + len -= xfer; + data += xfer; + } + + return 0; + } + +int +usb_close(struct usb_handle *h) +{ + D("usb_close(): closing transport %p\n", h); + sdb_mutex_lock(&usb_lock); + + h->next->prev = h->prev; + h->prev->next = h->next; + h->prev = NULL; + h->next = NULL; + + libusb_release_interface(h->devh, h->interface); + libusb_close(h->devh); + libusb_unref_device(h->dev); + + sdb_mutex_unlock(&usb_lock); + + free(h); + + return (0); +} + +void usb_kick(struct usb_handle *h) +{ + D("usb_cick(): kicking transport %p\n", h); + + sdb_mutex_lock(&h->lock); + unregister_usb_transport(h); + sdb_mutex_unlock(&h->lock); + + h->next->prev = h->prev; + h->prev->next = h->next; + h->prev = NULL; + h->next = NULL; + + libusb_release_interface(h->devh, h->interface); + libusb_close(h->devh); + libusb_unref_device(h->dev); + free(h); +} + +int +check_usb_interface(libusb_interface *interface, + libusb_device_descriptor *desc, + struct usb_handle *uh) +{ + int e; + + if (interface->num_altsetting == 0) { + D("check_usb_interface(): No interface settings\n"); + return -1; + } + + libusb_interface_descriptor *idesc = &interface->altsetting[0]; + + if (idesc->bNumEndpoints != 2) { + D("check_usb_interface(): Interface have not 2 endpoints, ignoring\n"); + return -1; + } + + for (e = 0; e < idesc->bNumEndpoints; e++) { + libusb_endpoint_descriptor *edesc = &idesc->endpoint[e]; + + if (edesc->bmAttributes != LIBUSB_TRANSFER_TYPE_BULK) { + D("check_usb_interface(): Endpoint (%u) is not bulk (%u), ignoring\n", + edesc->bmAttributes, LIBUSB_TRANSFER_TYPE_BULK); + return -1; + } + + if (edesc->bEndpointAddress & LIBUSB_ENDPOINT_IN) + uh->end_point_address[0] = edesc->bEndpointAddress; + else + uh->end_point_address[1] = edesc->bEndpointAddress; + + /* aproto 01 needs 0 termination */ + if (idesc->bInterfaceProtocol == 0x01) { + uh->zero_mask = edesc->wMaxPacketSize - 1; + D("check_usb_interface(): Forced Android interface protocol v.1\n"); + } + } + + D("check_usb_interface(): Device: %04x:%04x " + "iclass: %x, isclass: %x, iproto: %x ep: %x/%x-> ", + desc->idVendor, desc->idProduct, idesc->bInterfaceClass, + idesc->bInterfaceSubClass, idesc->bInterfaceProtocol, + uh->end_point_address[0], uh->end_point_address[1]); + + if (!is_sdb_interface(desc->idVendor, desc->idProduct, + idesc->bInterfaceClass, idesc->bInterfaceSubClass, + idesc->bInterfaceProtocol)) + { + D("not matches\n"); + return -1; + } + + D("matches\n"); + return 1; +} + +int +check_usb_interfaces(libusb_config_descriptor *config, + libusb_device_descriptor *desc, struct usb_handle *uh) +{ + int i; + + for (i = 0; i < config->bNumInterfaces; ++i) { + if (check_usb_interface(&config->interface[i], desc, uh) != -1) { + /* found some interface and saved information about it */ + D("check_usb_interfaces(): Interface %d of %04x:%04x " + "matches Android device\n", i, desc->idVendor, + desc->idProduct); + + return i; + } + } + + return -1; +} + +int +register_device(struct usb_handle *uh, const char *serial) +{ + D("register_device(): Registering %p [%s] as USB transport\n", + uh, serial); + + struct usb_handle *usb= NULL; + + usb = calloc(1, sizeof(struct usb_handle)); + memcpy(usb, uh, sizeof(struct usb_handle)); + strcpy(usb->serial, uh->serial); + + sdb_cond_init(&usb->notify, 0); + sdb_mutex_init(&usb->lock, 0); + + sdb_mutex_lock(&usb_lock); + + usb->next = &handle_list; + usb->prev = handle_list.prev; + usb->prev->next = usb; + usb->next->prev = usb; + + sdb_mutex_unlock(&usb_lock); + + register_usb_transport(usb, serial, 1); + + return (1); +} + +int +already_registered(usb_handle *uh) +{ + struct usb_handle *usb= NULL; + int exists = 0; + + sdb_mutex_lock(&usb_lock); + + for (usb = handle_list.next; usb != &handle_list; usb = usb->next) { + if ((usb->dev_bus == uh->dev_bus) && + (usb->dev_addr == uh->dev_addr)) + { + exists = 1; + break; + } + } + + sdb_mutex_unlock(&usb_lock); + + return exists; +} + +void +check_device(libusb_device *dev) +{ + struct usb_handle uh; + int i = 0; + int found = -1; + char serial[256] = {0}; + + libusb_device_descriptor desc; + libusb_config_descriptor *config = NULL; + + int r = libusb_get_device_descriptor(dev, &desc); + + if (r != LIBUSB_SUCCESS) { + D("check_device(): Failed to get device descriptor\n"); + return; + } + + if ((desc.idVendor == 0) && (desc.idProduct == 0)) + return; + + D("check_device(): Probing usb device %04x:%04x\n", + desc.idVendor, desc.idProduct); + + if (!is_sdb_interface (desc.idVendor, desc.idProduct, + SDB_CLASS, SDB_SUBCLASS, SDB_PROTOCOL)) + { + D("check_device(): Ignored due unknown vendor id\n"); + return; + } + + uh.dev_bus = libusb_get_bus_number(dev); + uh.dev_addr = libusb_get_device_address(dev); + + if (already_registered(&uh)) { + D("check_device(): Device (bus: %d, address: %d) " + "is already registered\n", uh.dev_bus, uh.dev_addr); + return; + } + + D("check_device(): Device bus: %d, address: %d\n", + uh.dev_bus, uh.dev_addr); + + r = libusb_get_active_config_descriptor(dev, &config); + + if (r != 0) { + if (r == LIBUSB_ERROR_NOT_FOUND) { + D("check_device(): Device %4x:%4x is unconfigured\n", + desc.idVendor, desc.idProduct); + return; + } + + D("check_device(): Failed to get configuration for %4x:%4x\n", + desc.idVendor, desc.idProduct); + return; + } + + if (config == NULL) { + D("check_device(): Sanity check failed after " + "getting active config\n"); + return; + } + + if (config->interface != NULL) { + found = check_usb_interfaces(config, &desc, &uh); + } + + /* not needed anymore */ + libusb_free_config_descriptor(config); + + r = libusb_open(dev, &uh.devh); + uh.dev = dev; + + if (r != 0) { + switch (r) { + case LIBUSB_ERROR_NO_MEM: + D("check_device(): Memory allocation problem\n"); + break; + + case LIBUSB_ERROR_ACCESS: + D("check_device(): Permissions problem, " + "current user priveleges are messed up?\n"); + break; + + case LIBUSB_ERROR_NO_DEVICE: + D("check_device(): Device disconected, bad cable?\n"); + break; + + default: + D("check_device(): libusb triggered error %d\n", r); + } + // skip rest + found = -1; + } + + if (found >= 0) { + D("check_device(): Device matches Android interface\n"); + // read the device's serial number + memset(serial, 0, sizeof(serial)); + uh.interface = found; + + r = libusb_claim_interface(uh.devh, uh.interface); + + if (r < 0) { + D("check_device(): Failed to claim interface %d\n", + uh.interface); + + goto fail; + } + + if (desc.iSerialNumber) { + // reading serial + uint16_t buffer[128] = {0}; + uint16_t languages[128] = {0}; + int languageCount = 0; + + memset(languages, 0, sizeof(languages)); + r = libusb_control_transfer(uh.devh, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE, + LIBUSB_REQUEST_GET_DESCRIPTOR, LIBUSB_DT_STRING << 8, + 0, (uint8_t *)languages, sizeof(languages), 0); + + if (r <= 0) { + D("check_device(): Failed to get languages count\n"); + goto fail; + } + + languageCount = (r - 2) / 2; + + for (i = 1; i <= languageCount; ++i) { + memset(buffer, 0, sizeof(buffer)); + + r = libusb_control_transfer(uh.devh, + LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_STANDARD | LIBUSB_RECIPIENT_DEVICE, + LIBUSB_REQUEST_GET_DESCRIPTOR, (LIBUSB_DT_STRING << 8) | desc.iSerialNumber, + languages[i], (uint8_t *)buffer, sizeof(buffer), 0); + + if (r > 0) { /* converting serial */ + int j = 0; + r /= 2; + + for (j = 1; j < r; ++j) + serial[j - 1] = buffer[j]; + + serial[j - 1] = '\0'; + break; /* languagesCount cycle */ + } + } + + if (register_device(&uh, serial) == 0) { + D("check_device(): Failed to register device\n"); + goto fail_interface; + } + + libusb_ref_device(dev); + } + } + + return; + +fail_interface: + libusb_release_interface(uh.devh, uh.interface); + +fail: + libusb_close(uh.devh); + uh.devh = NULL; +} + +int +check_device_connected(struct usb_handle *uh) +{ + int r = libusb_kernel_driver_active(uh->devh, uh->interface); + + if (r == LIBUSB_ERROR_NO_DEVICE) + return 0; + + if (r < 0) + return -1; + + return 1; +} + +void +kick_disconnected() +{ + struct usb_handle *usb= NULL; + + sdb_mutex_lock(&usb_lock); + + for (usb = handle_list.next; usb != &handle_list; usb = usb->next) { + + if (check_device_connected(usb) == 0) { + D("kick_disconnected(): Transport %p is not online anymore\n", + usb); + + usb_kick(usb); + } + } + + sdb_mutex_unlock(&usb_lock); +} + +void +scan_usb_devices() +{ + D("scan_usb_devices(): started\n"); + + libusb_device **devs= NULL; + libusb_device *dev= NULL; + ssize_t cnt = libusb_get_device_list(ctx, &devs); + + if (cnt < 0) { + D("scan_usb_devices(): Failed to get device list (error: %d)\n", + cnt); + + return; + } + + int i = 0; + + while ((dev = devs[i++]) != NULL) { + check_device(dev); + } + + libusb_free_device_list(devs, 1); +} + +void * +device_poll_thread(void* unused) +{ + D("device_poll_thread(): Created USB scan thread\n"); + + for (;;) { + sleep(5); + kick_disconnected(); + scan_usb_devices(); + } + + /* never reaching this point */ + return (NULL); +} + +static void +sigalrm_handler(int signo) +{ + /* nothing */ +} + +void +usb_init() +{ + D("usb_init(): started\n"); + sdb_thread_t tid; + struct sigaction actions; + + int r = libusb_init(&ctx); + + if (r != LIBUSB_SUCCESS) { + err(EX_IOERR, "Failed to init libusb\n"); + } + + memset(&actions, 0, sizeof(actions)); + + sigemptyset(&actions.sa_mask); + + actions.sa_flags = 0; + actions.sa_handler = sigalrm_handler; + + sigaction(SIGALRM, &actions, NULL); + + /* initial device scan */ + scan_usb_devices(); + + /* starting USB event polling thread */ + if (sdb_thread_create(&tid, device_poll_thread, NULL)) { + err(EX_IOERR, "cannot create USB scan thread\n"); + } + + D("usb_init(): finished\n"); +} + diff --git a/src/usb_linux.c b/src/usb_linux.c new file mode 100644 index 0000000..db412e8 --- /dev/null +++ b/src/usb_linux.c @@ -0,0 +1,700 @@ +/* + * 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 +#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 20) +#include +#else +#include +#endif +#include + +#include "sysdeps.h" + +#define TRACE_TAG TRACE_USB +#include "sdb.h" + + +/* usb scan debugging is waaaay too verbose */ +#define DBGX(x...) + +static sdb_mutex_t usb_lock = SDB_MUTEX_INITIALIZER; + +struct usb_handle +{ + usb_handle *prev; + usb_handle *next; + + char fname[64]; + int desc; + unsigned char ep_in; + unsigned char ep_out; + + unsigned zero_mask; + unsigned writeable; + + struct usbdevfs_urb urb_in; + struct usbdevfs_urb urb_out; + + int urb_in_busy; + int urb_out_busy; + int dead; + + sdb_cond_t notify; + sdb_mutex_t lock; + + // for garbage collecting disconnected devices + int mark; + + // ID of thread currently in REAPURB + pthread_t reaper_thread; +}; + +static usb_handle handle_list = { + .prev = &handle_list, + .next = &handle_list, +}; + +static int known_device(const char *dev_name) +{ + usb_handle *usb; + + sdb_mutex_lock(&usb_lock); + for(usb = handle_list.next; usb != &handle_list; usb = usb->next){ + if(!strcmp(usb->fname, dev_name)) { + // set mark flag to indicate this device is still alive + usb->mark = 1; + sdb_mutex_unlock(&usb_lock); + return 1; + } + } + sdb_mutex_unlock(&usb_lock); + return 0; +} + +static void kick_disconnected_devices() +{ + usb_handle *usb; + + sdb_mutex_lock(&usb_lock); + // kick any devices in the device list that were not found in the device scan + for(usb = handle_list.next; usb != &handle_list; usb = usb->next){ + if (usb->mark == 0) { + usb_kick(usb); + } else { + usb->mark = 0; + } + } + sdb_mutex_unlock(&usb_lock); + +} + +static void register_device(const char *dev_name, unsigned char ep_in, unsigned char ep_out, + int ifc, int serial_index, unsigned zero_mask); + +static inline int badname(const char *name) +{ + while(*name) { + if(!isdigit(*name++)) return 1; + } + return 0; +} + +static void find_usb_device(const char *base, + void (*register_device_callback) + (const char *, unsigned char, unsigned char, int, int, unsigned)) +{ + char busname[32], devname[32]; + unsigned char local_ep_in, local_ep_out; + DIR *busdir , *devdir ; + struct dirent *de; + int fd ; + + busdir = opendir(base); + if(busdir == 0) return; + + while((de = readdir(busdir)) != 0) { + if(badname(de->d_name)) continue; + + snprintf(busname, sizeof busname, "%s/%s", base, de->d_name); + devdir = opendir(busname); + if(devdir == 0) continue; + +// DBGX("[ scanning %s ]\n", busname); + while((de = readdir(devdir))) { + unsigned char devdesc[256]; + 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; + unsigned int desclength; + + if(badname(de->d_name)) continue; + snprintf(devname, sizeof devname, "%s/%s", busname, de->d_name); + + if(known_device(devname)) { + DBGX("skipping %s\n", devname); + continue; + } + +// DBGX("[ scanning %s ]\n", devname); + if((fd = unix_open(devname, O_RDONLY)) < 0) { + continue; + } + + desclength = sdb_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 %d is too small\n", desclength); + sdb_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)) { + sdb_close(fd); + continue; + } + + vid = __le16_to_cpu(device->idVendor); + pid = __le16_to_cpu(device->idProduct); + pid = devdesc[10] | (devdesc[11] << 8); + DBGX("[ %s is V:%04x P:%04x ]\n", devname, vid, pid); + + // should have config descriptor next + config = (struct usb_config_descriptor *)bufptr; + // sdb needs 2nd configuration + if (device->bNumConfigurations > 1) { + bufptr += config->wTotalLength; + config = (struct usb_config_descriptor *)bufptr; + bufend = bufptr + config->wTotalLength; + } + bufptr += USB_DT_CONFIG_SIZE; + + if (config->bLength != USB_DT_CONFIG_SIZE || config->bDescriptorType != USB_DT_CONFIG) { + D("usb_config_descriptor not found\n"); + sdb_close(fd); + continue; + } + + // loop through all the descriptors and look for the SDB 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\n"); + break; + } + + DBGX("bInterfaceClass: %d, bInterfaceSubClass: %d," + "bInterfaceProtocol: %d, bNumEndpoints: %d\n", + interface->bInterfaceClass, interface->bInterfaceSubClass, + interface->bInterfaceProtocol, interface->bNumEndpoints); + + if (interface->bNumEndpoints == 2 && + is_sdb_interface(vid, pid, interface->bInterfaceClass, + interface->bInterfaceSubClass, interface->bInterfaceProtocol)) { + + DBGX("looking for bulk endpoints\n"); + // looks like SDB... + ep1 = (struct usb_endpoint_descriptor *)bufptr; + bufptr += USB_DT_ENDPOINT_SIZE; + ep2 = (struct usb_endpoint_descriptor *)bufptr; + bufptr += USB_DT_ENDPOINT_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\n"); + break; + } + + // both endpoints should be bulk + if (ep1->bmAttributes != USB_ENDPOINT_XFER_BULK || + ep2->bmAttributes != USB_ENDPOINT_XFER_BULK) { + D("bulk endpoints not found\n"); + continue; + } + /* aproto 01 needs 0 termination */ + if(interface->bInterfaceProtocol == 0x02) { + zero_mask = ep1->wMaxPacketSize - 1; + } + + // we have a match. now we just need to figure out which is in and which is 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; + } + + register_device_callback(devname, local_ep_in, local_ep_out, + interface->bInterfaceNumber, device->iSerialNumber, zero_mask); + break; + } + } else { + bufptr += length; + } + } // end of while + + sdb_close(fd); + } // end of devdir while + closedir(devdir); + } //end of busdir while + closedir(busdir); +} + +void usb_cleanup() +{ +} + +static int usb_bulk_write(usb_handle *h, const void *data, int len) +{ + struct usbdevfs_urb *urb = &h->urb_out; + int res; + struct timeval tv; + struct timespec ts; + + memset(urb, 0, sizeof(*urb)); + urb->type = USBDEVFS_URB_TYPE_BULK; + urb->endpoint = h->ep_out; + urb->status = -1; + urb->buffer = (void*) data; + urb->buffer_length = len; + + D("++ write ++\n"); + + sdb_mutex_lock(&h->lock); + if(h->dead) { + res = -1; + goto fail; + } + do { + res = ioctl(h->desc, USBDEVFS_SUBMITURB, urb); + } while((res < 0) && (errno == EINTR)); + + if(res < 0) { + goto fail; + } + + res = -1; + h->urb_out_busy = 1; + for(;;) { + /* time out after five seconds */ + gettimeofday(&tv, NULL); + ts.tv_sec = tv.tv_sec + 5; + ts.tv_nsec = tv.tv_usec * 1000L; + res = pthread_cond_timedwait(&h->notify, &h->lock, &ts); + if(res < 0 || h->dead) { + break; + } + if(h->urb_out_busy == 0) { + if(urb->status == 0) { + res = urb->actual_length; + } + break; + } + } +fail: + sdb_mutex_unlock(&h->lock); + D("-- write --\n"); + return res; +} + +static int usb_bulk_read(usb_handle *h, void *data, int len) +{ + struct usbdevfs_urb *urb = &h->urb_in; + struct usbdevfs_urb *out = NULL; + int res; + + 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; + + + sdb_mutex_lock(&h->lock); + if(h->dead) { + res = -1; + goto fail; + } + do { + res = ioctl(h->desc, USBDEVFS_SUBMITURB, urb); + } while((res < 0) && (errno == EINTR)); + + if(res < 0) { + goto fail; + } + + h->urb_in_busy = 1; + for(;;) { + D("[ reap urb - wait ]\n"); + h->reaper_thread = pthread_self(); + sdb_mutex_unlock(&h->lock); + res = ioctl(h->desc, USBDEVFS_REAPURB, &out); + sdb_mutex_lock(&h->lock); + h->reaper_thread = 0; + if(h->dead) { + res = -1; + break; + } + if(res < 0) { + if(errno == EINTR) { + continue; + } + D("[ reap urb - error ]\n"); + break; + } + D("[ urb @%p status = %d, actual = %d ]\n", + out, out->status, out->actual_length); + + if(out == &h->urb_in) { + D("[ reap urb - IN complete ]\n"); + h->urb_in_busy = 0; + if(urb->status == 0) { + res = urb->actual_length; + } else { + res = -1; + } + break; + } + if(out == &h->urb_out) { + D("[ reap urb - OUT compelete ]\n"); + h->urb_out_busy = 0; + sdb_cond_broadcast(&h->notify); + } + } +fail: + sdb_mutex_unlock(&h->lock); + return res; +} + + +int usb_write(usb_handle *h, const void *_data, int len) +{ + unsigned char *data = (unsigned char*) _data; + int n; + int need_zero = 0; + + if(h->zero_mask) { + /* if we need 0-markers and our transfer + ** is an even multiple of the packet size, + ** we make note of it + */ + if(!(len & h->zero_mask)) { + need_zero = 1; + } + } + + while(len > 0) { + int xfer = (len > 4096) ? 4096 : len; + + n = usb_bulk_write(h, data, xfer); + if(n != xfer) { + D("ERROR: n = %d, errno = %d (%s)\n", + n, errno, strerror(errno)); + return -1; + } + + len -= xfer; + data += xfer; + } + + if(need_zero){ + n = usb_bulk_write(h, _data, 0); + return n; + } + + return 0; +} + +int usb_read(usb_handle *h, void *_data, int len) +{ + unsigned char *data = (unsigned char*) _data; + int n; + + D("++ usb_read ++\n"); + while(len > 0) { + int xfer = (len > 4096) ? 4096 : len; + + D("[ usb read %d fd = %d], fname=%s\n", xfer, h->desc, h->fname); + n = usb_bulk_read(h, data, xfer); + D("[ usb read %d ] = %d, fname=%s\n", xfer, n, h->fname); + if(n != xfer) { + if((errno == ETIMEDOUT) && (h->desc != -1)) { + D("[ timeout ]\n"); + if(n > 0){ + data += n; + len -= n; + } + continue; + } + D("ERROR: n = %d, errno = %d (%s)\n", + n, errno, strerror(errno)); + return -1; + } + + len -= xfer; + data += xfer; + } + + D("-- usb_read --\n"); + return 0; +} + +void usb_kick(usb_handle *h) +{ + D("[ kicking %p (fd = %d) ]\n", h, h->desc); + sdb_mutex_lock(&h->lock); + if(h->dead == 0) { + h->dead = 1; + + 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->desc, USBDEVFS_DISCARDURB, &h->urb_in); + ioctl(h->desc, USBDEVFS_DISCARDURB, &h->urb_out); + h->urb_in.status = -ENODEV; + h->urb_out.status = -ENODEV; + h->urb_in_busy = 0; + h->urb_out_busy = 0; + sdb_cond_broadcast(&h->notify); + } else { + unregister_usb_transport(h); + } + } + sdb_mutex_unlock(&h->lock); +} + +int usb_close(usb_handle *h) +{ + D("[ usb close ... ]\n"); + sdb_mutex_lock(&usb_lock); + h->next->prev = h->prev; + h->prev->next = h->next; + h->prev = 0; + h->next = 0; + + sdb_close(h->desc); + D("[ usb closed %p (fd = %d) ]\n", h, h->desc); + sdb_mutex_unlock(&usb_lock); + + free(h); + return 0; +} + +static void register_device(const char *dev_name, + unsigned char ep_in, unsigned char ep_out, + int interface, int serial_index, unsigned zero_mask) +{ + usb_handle* usb = 0; + int n = 0; + char serial[256]; + int bConfigurationValue = 2; /* sdb needs 2nd configruation */ + + /* 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 'o handles with a matching + ** name, we have no further work to do. + */ + sdb_mutex_lock(&usb_lock); + for(usb = handle_list.next; usb != &handle_list; usb = usb->next){ + if(!strcmp(usb->fname, dev_name)) { + sdb_mutex_unlock(&usb_lock); + return; + } + } + sdb_mutex_unlock(&usb_lock); + + D("[ usb located new device %s (%d/%d/%d) ]\n", + dev_name, ep_in, ep_out, interface); + usb = calloc(1, sizeof(usb_handle)); + strcpy(usb->fname, dev_name); + usb->ep_in = ep_in; + usb->ep_out = ep_out; + usb->zero_mask = zero_mask; + usb->writeable = 1; + + sdb_cond_init(&usb->notify, 0); + sdb_mutex_init(&usb->lock, 0); + /* initialize mark to 1 so we don't get garbage collected after the device scan */ + usb->mark = 1; + usb->reaper_thread = 0; + + usb->desc = unix_open(usb->fname, O_RDWR); + if(usb->desc < 0) { + /* if we fail, see if have read-only access */ + usb->desc = unix_open(usb->fname, O_RDONLY); + if(usb->desc < 0) goto fail; + usb->writeable = 0; + D("[ usb open read-only %s fd = %d]\n", usb->fname, usb->desc); + } else { + D("[ usb open %s fd = %d]\n", usb->fname, usb->desc); + n = ioctl(usb->desc, USBDEVFS_RESET); + if(n != 0) goto fail; + ioctl(usb->desc, USBDEVFS_SETCONFIGURATION, &bConfigurationValue); + n = ioctl(usb->desc, USBDEVFS_CLAIMINTERFACE, &interface); + if(n != 0) goto fail; + } + + /* read the device's serial number */ + serial[0] = 0; + memset(serial, 0, sizeof(serial)); + if (serial_index) { + struct usbdevfs_ctrltransfer ctrl; + __u16 buffer[128]; + __u16 languages[128]; + int i, result; + int languageCount = 0; + + memset(languages, 0, sizeof(languages)); + memset(&ctrl, 0, sizeof(ctrl)); + + // read list of supported languages + ctrl.bRequestType = USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE; + ctrl.bRequest = USB_REQ_GET_DESCRIPTOR; + ctrl.wValue = (USB_DT_STRING << 8) | 0; + ctrl.wIndex = 0; + ctrl.wLength = sizeof(languages); + ctrl.data = languages; + + result = ioctl(usb->desc, USBDEVFS_CONTROL, &ctrl); + if (result > 0) + languageCount = (result - 2) / 2; + + for (i = 1; i <= languageCount; i++) { + memset(buffer, 0, sizeof(buffer)); + memset(&ctrl, 0, sizeof(ctrl)); + + ctrl.bRequestType = USB_DIR_IN|USB_TYPE_STANDARD|USB_RECIP_DEVICE; + ctrl.bRequest = USB_REQ_GET_DESCRIPTOR; + ctrl.wValue = (USB_DT_STRING << 8) | serial_index; + ctrl.wIndex = languages[i]; + ctrl.wLength = sizeof(buffer); + ctrl.data = buffer; + + result = ioctl(usb->desc, USBDEVFS_CONTROL, &ctrl); + if (result > 0) { + int i; + // skip first word, and copy the rest to the serial string, changing shorts to bytes. + result /= 2; + for (i = 1; i < result; i++) + serial[i - 1] = buffer[i]; + serial[i - 1] = 0; + break; + } + } + } + + /* add to the end of the active handles */ + sdb_mutex_lock(&usb_lock); + usb->next = &handle_list; + usb->prev = handle_list.prev; + usb->prev->next = usb; + usb->next->prev = usb; + sdb_mutex_unlock(&usb_lock); + + register_usb_transport(usb, serial, usb->writeable); + return; + +fail: + D("[ usb open %s error=%d, err_str = %s]\n", + usb->fname, errno, strerror(errno)); + if(usb->desc >= 0) { + sdb_close(usb->desc); + } + free(usb); +} + +void* device_poll_thread(void* unused) +{ + D("Created device thread\n"); + for(;;) { + /* XXX use inotify */ + find_usb_device("/dev/bus/usb", register_device); + kick_disconnected_devices(); + sleep(1); + } + return NULL; +} + +static void sigalrm_handler(int signo) +{ + // don't need to do anything here +} + +void usb_init() +{ + sdb_thread_t tid; + struct sigaction actions; + + memset(&actions, 0, sizeof(actions)); + sigemptyset(&actions.sa_mask); + actions.sa_flags = 0; + actions.sa_handler = sigalrm_handler; + sigaction(SIGALRM,& actions, NULL); + + if(sdb_thread_create(&tid, device_poll_thread, NULL)){ + fatal_errno("cannot create input thread"); + } +} + diff --git a/src/usb_linux_client.c b/src/usb_linux_client.c new file mode 100644 index 0000000..1a605fb --- /dev/null +++ b/src/usb_linux_client.c @@ -0,0 +1,161 @@ +/* + * 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 "sysdeps.h" + +#define TRACE_TAG TRACE_USB +#include "sdb.h" + + +struct usb_handle +{ + int fd; + sdb_cond_t notify; + sdb_mutex_t lock; +}; + +void usb_cleanup() +{ + // nothing to do here +} + +static void *usb_open_thread(void *x) +{ + struct usb_handle *usb = (struct usb_handle *)x; + int fd; + + while (1) { + // wait until the USB device needs opening + sdb_mutex_lock(&usb->lock); + while (usb->fd != -1) { + sdb_cond_wait(&usb->notify, &usb->lock); + } + sdb_mutex_unlock(&usb->lock); + + D("[ usb_thread - opening device ]\n"); + do { + /* XXX use inotify? */ + fd = unix_open("/dev/samsung_sdb", O_RDWR); +#if 0 + if (fd < 0) { + // to support older kernels + fd = unix_open("/dev/android", O_RDWR); + } +#endif + if (fd < 0) { + sdb_sleep_ms(1000); + } + } while (fd < 0); + D("[ opening device succeeded ]\n"); + + close_on_exec(fd); + usb->fd = fd; + + D("[ usb_thread - registering device ]\n"); + register_usb_transport(usb, 0, 1); + } + + // never gets here + return 0; +} + +int usb_write(usb_handle *h, const void *data, int len) +{ + int n; + + D("[ write %d ]\n", len); + n = sdb_write(h->fd, data, len); + if(n != len) { + D("ERROR: n = %d, errno = %d (%s)\n", + n, errno, strerror(errno)); + return -1; + } + D("[ done ]\n"); + return 0; +} + +int usb_read(usb_handle *h, void *data, int len) +{ + int n; + + D("[ read %d ]\n", len); + n = sdb_read(h->fd, data, len); + if(n != len) { + D("ERROR: n = %d, errno = %d (%s)\n", + n, errno, strerror(errno)); + return -1; + } + return 0; +} + +void usb_init() +{ + usb_handle *h; + sdb_thread_t tid; +#if 0 //eric + int fd; +#endif + h = calloc(1, sizeof(usb_handle)); + h->fd = -1; + sdb_cond_init(&h->notify, 0); + sdb_mutex_init(&h->lock, 0); + + // Open the file /dev/android_sdb_enable to trigger + // the enabling of the sdb 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. +#if 0 //eric + fd = unix_open("/dev/android_sdb_enable", O_RDWR); + if (fd < 0) { + D("failed to open /dev/android_sdb_enable\n"); + } else { + close_on_exec(fd); + } +#endif + D("[ usb_init - starting thread ]\n"); + if(sdb_thread_create(&tid, usb_open_thread, h)){ + fatal_errno("cannot create usb thread"); + } +} + +void usb_kick(usb_handle *h) +{ + D("usb_kick\n"); + sdb_mutex_lock(&h->lock); + sdb_close(h->fd); + h->fd = -1; + + // notify usb_open_thread that we are disconnected + sdb_cond_signal(&h->notify); + sdb_mutex_unlock(&h->lock); +} + +int usb_close(usb_handle *h) +{ + // nothing to do here + return 0; +} diff --git a/src/usb_osx.c b/src/usb_osx.c new file mode 100644 index 0000000..5961619 --- /dev/null +++ b/src/usb_osx.c @@ -0,0 +1,537 @@ +/* + * 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 "sysdeps.h" + +#include + +#define TRACE_TAG TRACE_USB +#include "sdb.h" +#include "usb_vendors.h" + +#define DBG D + +static IONotificationPortRef notificationPort = 0; +static io_iterator_t* notificationIterators; + +struct usb_handle +{ + UInt8 bulkIn; + UInt8 bulkOut; + IOUSBInterfaceInterface **interface; + io_object_t usbNotification; + unsigned int zero_mask; +}; + +static CFRunLoopRef currentRunLoop = 0; +static pthread_mutex_t start_lock; +static pthread_cond_t start_cond; + + +static void AndroidInterfaceAdded(void *refCon, io_iterator_t iterator); +static void AndroidInterfaceNotify(void *refCon, io_iterator_t iterator, + natural_t messageType, + void *messageArgument); +static usb_handle* CheckInterface(IOUSBInterfaceInterface **iface, + UInt16 vendor, UInt16 product); + +static int +InitUSB() +{ + CFMutableDictionaryRef matchingDict; + CFRunLoopSourceRef runLoopSource; + SInt32 vendor, if_subclass, if_protocol; + unsigned i; + + //* To set up asynchronous notifications, create a notification port and + //* add its run loop event source to the program's run loop + notificationPort = IONotificationPortCreate(kIOMasterPortDefault); + runLoopSource = IONotificationPortGetRunLoopSource(notificationPort); + CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopDefaultMode); + + memset(notificationIterators, 0, sizeof(notificationIterators)); + + //* loop through all supported vendors + for (i = 0; i < vendorIdCount; i++) { + //* Create our matching dictionary to find the Android device's + //* sdb interface + //* IOServiceAddMatchingNotification consumes the reference, so we do + //* not need to release this + matchingDict = IOServiceMatching(kIOUSBInterfaceClassName); + + if (!matchingDict) { + DBG("ERR: Couldn't create USB matching dictionary.\n"); + return -1; + } + + //* Match based on vendor id, interface subclass and protocol + vendor = vendorIds[i]; + if_subclass = SDB_SUBCLASS; + if_protocol = SDB_PROTOCOL; + CFDictionarySetValue(matchingDict, CFSTR(kUSBVendorID), + CFNumberCreate(kCFAllocatorDefault, + kCFNumberSInt32Type, &vendor)); + CFDictionarySetValue(matchingDict, CFSTR(kUSBInterfaceSubClass), + CFNumberCreate(kCFAllocatorDefault, + kCFNumberSInt32Type, &if_subclass)); + CFDictionarySetValue(matchingDict, CFSTR(kUSBInterfaceProtocol), + CFNumberCreate(kCFAllocatorDefault, + kCFNumberSInt32Type, &if_protocol)); + IOServiceAddMatchingNotification( + notificationPort, + kIOFirstMatchNotification, + matchingDict, + AndroidInterfaceAdded, + NULL, + ¬ificationIterators[i]); + + //* Iterate over set of matching interfaces to access already-present + //* devices and to arm the notification + AndroidInterfaceAdded(NULL, notificationIterators[i]); + } + + return 0; +} + +static void +AndroidInterfaceAdded(void *refCon, 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; + UInt16 vendor; + UInt16 product; + UInt8 serialIndex; + char serial[256]; + + while ((usbInterface = IOIteratorNext(iterator))) { + //* Create an intermediate interface plugin + kr = IOCreatePlugInInterfaceForService(usbInterface, + kIOUSBInterfaceUserClientTypeID, + kIOCFPlugInInterfaceID, + &plugInInterface, &score); + IOObjectRelease(usbInterface); + if ((kIOReturnSuccess != kr) || (!plugInInterface)) { + DBG("ERR: Unable to create an interface plug-in (%08x)\n", 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) { + DBG("ERR: Couldn't query the interface (%08x)\n", (int) result); + 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) { + DBG("ERR: Couldn't grab device from interface (%08x)\n", 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)) { + DBG("ERR: Unable to create a device plug-in (%08x)\n", kr); + continue; + } + + result = (*plugInInterface)->QueryInterface(plugInInterface, + CFUUIDGetUUIDBytes(kIOUSBDeviceInterfaceID), (LPVOID) &dev); + //* only needed this to query the plugin + (*plugInInterface)->Release(plugInInterface); + if (result || !dev) { + DBG("ERR: Couldn't create a device interface (%08x)\n", + (int) 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)->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); + + DBG("INFO: Found vid=%04x pid=%04x serial=%s\n", vendor, product, + serial); + + usb_handle* handle = CheckInterface((IOUSBInterfaceInterface**)iface, + vendor, product); + if (handle == NULL) { + DBG("ERR: Could not find device interface: %08x\n", kr); + (*iface)->Release(iface); + continue; + } + + DBG("AndroidDeviceAdded calling register_usb_transport\n"); + register_usb_transport(handle, (serial[0] ? serial : NULL), 1); + + // Register for an interest notification of this device being removed. + // Pass the reference to our private data as the refCon for the + // notification. + kr = IOServiceAddInterestNotification(notificationPort, + usbInterface, + kIOGeneralInterest, + AndroidInterfaceNotify, + handle, + &handle->usbNotification); + + if (kIOReturnSuccess != kr) { + DBG("ERR: Unable to create interest notification (%08x)\n", kr); + } + } +} + +static void +AndroidInterfaceNotify(void *refCon, io_service_t service, natural_t messageType, void *messageArgument) +{ + usb_handle *handle = (usb_handle *)refCon; + + if (messageType == kIOMessageServiceIsTerminated) { + if (!handle) { + DBG("ERR: NULL handle\n"); + return; + } + DBG("AndroidInterfaceNotify\n"); + IOObjectRelease(handle->usbNotification); + usb_kick(handle); + } +} + +//* TODO: simplify this further since we only register to get SDB interface +//* subclass+protocol events +static usb_handle* +CheckInterface(IOUSBInterfaceInterface **interface, UInt16 vendor, UInt16 product) +{ + usb_handle* handle = NULL; + 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) { + DBG("ERR: Could not open interface: (%08x)\n", kr); + return NULL; + } + + //* Get the number of endpoints associated with this interface + kr = (*interface)->GetNumEndpoints(interface, &interfaceNumEndpoints); + if (kr != kIOReturnSuccess) { + DBG("ERR: Unable to get number of endpoints: (%08x)\n", 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) { + DBG("ERR: Unable to get interface class, subclass and protocol\n"); + goto err_get_interface_class; + } + + //* check to make sure interface class, subclass and protocol match SDB + //* avoid opening mass storage endpoints + if (!is_sdb_interface(vendor, product, interfaceClass, + interfaceSubClass, interfaceProtocol)) + goto err_bad_sdb_interface; + + handle = calloc(1, sizeof(usb_handle)); + + //* 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 = 0; endpoint <= interfaceNumEndpoints; endpoint++) { + UInt8 transferType; + UInt16 maxPacketSize; + UInt8 interval; + UInt8 number; + UInt8 direction; + + kr = (*interface)->GetPipeProperties(interface, endpoint, &direction, + &number, &transferType, &maxPacketSize, &interval); + + if (kIOReturnSuccess == kr) { + if (kUSBBulk != transferType) + continue; + + if (kUSBIn == direction) + handle->bulkIn = endpoint; + + if (kUSBOut == direction) + handle->bulkOut = endpoint; + + handle->zero_mask = maxPacketSize - 1; + } else { + DBG("ERR: FindDeviceInterface - could not get pipe properties\n"); + goto err_get_pipe_props; + } + } + + handle->interface = interface; + return handle; + +err_get_pipe_props: + free(handle); +err_bad_sdb_interface: +err_get_interface_class: +err_get_num_ep: + (*interface)->USBInterfaceClose(interface); + return NULL; +} + + +void* RunLoopThread(void* unused) +{ + unsigned i; + + InitUSB(); + + currentRunLoop = CFRunLoopGetCurrent(); + + // Signal the parent that we are running + sdb_mutex_lock(&start_lock); + sdb_cond_signal(&start_cond); + sdb_mutex_unlock(&start_lock); + + CFRunLoopRun(); + currentRunLoop = 0; + + for (i = 0; i < vendorIdCount; i++) { + IOObjectRelease(notificationIterators[i]); + } + IONotificationPortDestroy(notificationPort); + + DBG("RunLoopThread done\n"); + return NULL; +} + + +static int initialized = 0; +void usb_init() +{ + if (!initialized) + { + sdb_thread_t tid; + + notificationIterators = (io_iterator_t*)malloc( + vendorIdCount * sizeof(io_iterator_t)); + + sdb_mutex_init(&start_lock, NULL); + sdb_cond_init(&start_cond, NULL); + + if(sdb_thread_create(&tid, RunLoopThread, NULL)) + fatal_errno("cannot create input thread"); + + // Wait for initialization to finish + sdb_mutex_lock(&start_lock); + sdb_cond_wait(&start_cond, &start_lock); + sdb_mutex_unlock(&start_lock); + + sdb_mutex_destroy(&start_lock); + sdb_cond_destroy(&start_cond); + + initialized = 1; + } +} + +void usb_cleanup() +{ + DBG("usb_cleanup\n"); + close_usb_devices(); + if (currentRunLoop) + CFRunLoopStop(currentRunLoop); + + if (notificationIterators != NULL) { + free(notificationIterators); + notificationIterators = NULL; + } +} + +int usb_write(usb_handle *handle, const void *buf, int len) +{ + IOReturn result; + + if (!len) + return 0; + + if (!handle) + return -1; + + if (NULL == handle->interface) { + DBG("ERR: usb_write interface was null\n"); + return -1; + } + + if (0 == handle->bulkOut) { + DBG("ERR: bulkOut endpoint not assigned\n"); + 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; + + DBG("ERR: usb_write failed with status %d\n", result); + return -1; +} + +int usb_read(usb_handle *handle, void *buf, int len) +{ + IOReturn result; + UInt32 numBytes = len; + + if (!len) { + return 0; + } + + if (!handle) { + return -1; + } + + if (NULL == handle->interface) { + DBG("ERR: usb_read interface was null\n"); + return -1; + } + + if (0 == handle->bulkIn) { + DBG("ERR: bulkIn endpoint not assigned\n"); + return -1; + } + + result = + (*handle->interface)->ReadPipe(handle->interface, + handle->bulkIn, buf, &numBytes); + + if (0 == result) + return 0; + else { + DBG("ERR: usb_read failed with status %d\n", result); + } + + return -1; +} + +int usb_close(usb_handle *handle) +{ + return 0; +} + +void usb_kick(usb_handle *handle) +{ + /* release the interface */ + if (!handle) + return; + + if (handle->interface) + { + (*handle->interface)->USBInterfaceClose(handle->interface); + (*handle->interface)->Release(handle->interface); + handle->interface = 0; + } +} diff --git a/src/usb_vendors.c b/src/usb_vendors.c new file mode 100644 index 0000000..2c95e78 --- /dev/null +++ b/src/usb_vendors.c @@ -0,0 +1,201 @@ +/* + * Copyright (C) 2009 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 "usb_vendors.h" + +#include + +#ifdef _WIN32 +# define WIN32_LEAN_AND_MEAN +# include "windows.h" +# include "shlobj.h" +#else +# include +# include +#endif + +#include "sysdeps.h" +#include "sdb.h" + +#define ANDROID_PATH ".android" +#define ANDROID_SDB_INI "sdb_usb.ini" + +#define TRACE_TAG TRACE_USB + +// Google's USB Vendor ID +#define VENDOR_ID_GOOGLE 0x18d1 +// HTC's USB Vendor ID +#define VENDOR_ID_HTC 0x0bb4 +// Samsung's USB Vendor ID +#define VENDOR_ID_SAMSUNG 0x04e8 +// Motorola's USB Vendor ID +#define VENDOR_ID_MOTOROLA 0x22b8 +// LG's USB Vendor ID +#define VENDOR_ID_LGE 0x1004 +// Huawei's USB Vendor ID +#define VENDOR_ID_HUAWEI 0x12D1 +// Acer's USB Vendor ID +#define VENDOR_ID_ACER 0x0502 +// Sony Ericsson's USB Vendor ID +#define VENDOR_ID_SONY_ERICSSON 0x0FCE +// Foxconn's USB Vendor ID +#define VENDOR_ID_FOXCONN 0x0489 +// Dell's USB Vendor ID +#define VENDOR_ID_DELL 0x413c +// Nvidia's USB Vendor ID +#define VENDOR_ID_NVIDIA 0x0955 +// Garmin-Asus's USB Vendor ID +#define VENDOR_ID_GARMIN_ASUS 0x091E +// Sharp's USB Vendor ID +#define VENDOR_ID_SHARP 0x04dd +// ZTE's USB Vendor ID +#define VENDOR_ID_ZTE 0x19D2 +// Kyocera's USB Vendor ID +#define VENDOR_ID_KYOCERA 0x0482 +// Pantech's USB Vendor ID +#define VENDOR_ID_PANTECH 0x10A9 +// Qualcomm's USB Vendor ID +#define VENDOR_ID_QUALCOMM 0x05c6 +// NEC's USB Vendor ID +#define VENDOR_ID_NEC 0x0409 +// Panasonic Mobile Communication's USB Vendor ID +#define VENDOR_ID_PMC 0x04DA +// Toshiba's USB Vendor ID +#define VENDOR_ID_TOSHIBA 0x0930 +// SK Telesys's USB Vendor ID +#define VENDOR_ID_SK_TELESYS 0x1F53 +// KT Tech's USB Vendor ID +#define VENDOR_ID_KT_TECH 0x2116 +// Asus's USB Vendor ID +#define VENDOR_ID_ASUS 0x0b05 +// Philips's USB Vendor ID +#define VENDOR_ID_PHILIPS 0x0471 + + +/** built-in vendor list */ +int builtInVendorIds[] = { + VENDOR_ID_GOOGLE, + VENDOR_ID_HTC, + VENDOR_ID_SAMSUNG, + VENDOR_ID_MOTOROLA, + VENDOR_ID_LGE, + VENDOR_ID_HUAWEI, + VENDOR_ID_ACER, + VENDOR_ID_SONY_ERICSSON, + VENDOR_ID_FOXCONN, + VENDOR_ID_DELL, + VENDOR_ID_NVIDIA, + VENDOR_ID_GARMIN_ASUS, + VENDOR_ID_SHARP, + VENDOR_ID_ZTE, + VENDOR_ID_KYOCERA, + VENDOR_ID_PANTECH, + VENDOR_ID_QUALCOMM, + VENDOR_ID_NEC, + VENDOR_ID_PMC, + VENDOR_ID_TOSHIBA, + VENDOR_ID_SK_TELESYS, + VENDOR_ID_KT_TECH, + VENDOR_ID_ASUS, + VENDOR_ID_PHILIPS, +}; + +#define BUILT_IN_VENDOR_COUNT (sizeof(builtInVendorIds)/sizeof(builtInVendorIds[0])) + +/* max number of supported vendor ids (built-in + 3rd party). increase as needed */ +#define VENDOR_COUNT_MAX 128 + +int vendorIds[VENDOR_COUNT_MAX]; +unsigned vendorIdCount = 0; + +int get_sdb_usb_ini(char* buff, size_t len); + +void usb_vendors_init(void) +{ + if (VENDOR_COUNT_MAX < BUILT_IN_VENDOR_COUNT) { + fprintf(stderr, "VENDOR_COUNT_MAX not big enough for built-in vendor list.\n"); + exit(2); + } + + /* add the built-in vendors at the beginning of the array */ + memcpy(vendorIds, builtInVendorIds, sizeof(builtInVendorIds)); + + /* default array size is the number of built-in vendors */ + vendorIdCount = BUILT_IN_VENDOR_COUNT; + + if (VENDOR_COUNT_MAX == BUILT_IN_VENDOR_COUNT) + return; + + char temp[PATH_MAX]; + if (get_sdb_usb_ini(temp, sizeof(temp)) == 0) { + FILE * f = fopen(temp, "rt"); + + if (f != NULL) { + /* The vendor id file is pretty basic. 1 vendor id per line. + Lines starting with # are comments */ + while (fgets(temp, sizeof(temp), f) != NULL) { + if (temp[0] == '#') + continue; + + long value = strtol(temp, NULL, 0); + if (errno == EINVAL || errno == ERANGE || value > INT_MAX || value < 0) { + fprintf(stderr, "Invalid content in %s. Quitting.\n", ANDROID_SDB_INI); + exit(2); + } + + vendorIds[vendorIdCount++] = (int)value; + + /* make sure we don't go beyond the array */ + if (vendorIdCount == VENDOR_COUNT_MAX) { + break; + } + } + } + } +} + +/* Utils methods */ + +/* builds the path to the sdb vendor id file. returns 0 if success */ +int build_path(char* buff, size_t len, const char* format, const char* home) +{ + if (snprintf(buff, len, format, home, ANDROID_PATH, ANDROID_SDB_INI) >= len) { + return 1; + } + + return 0; +} + +/* fills buff with the path to the sdb vendor id file. returns 0 if success */ +int get_sdb_usb_ini(char* buff, size_t len) +{ +#ifdef _WIN32 + const char* home = getenv("ANDROID_SDK_HOME"); + if (home != NULL) { + return build_path(buff, len, "%s\\%s\\%s", home); + } else { + char path[MAX_PATH]; + SHGetFolderPath( NULL, CSIDL_PROFILE, NULL, 0, path); + return build_path(buff, len, "%s\\%s\\%s", path); + } +#else + const char* home = getenv("HOME"); + if (home == NULL) + home = "/tmp"; + + return build_path(buff, len, "%s/%s/%s", home); +#endif +} diff --git a/src/usb_vendors.h b/src/usb_vendors.h new file mode 100644 index 0000000..43790b9 --- /dev/null +++ b/src/usb_vendors.h @@ -0,0 +1,25 @@ +/* + * Copyright (C) 2009 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 __USB_VENDORS_H +#define __USB_VENDORS_H + +extern int vendorIds[]; +extern unsigned vendorIdCount; + +void usb_vendors_init(void); + +#endif \ No newline at end of file diff --git a/src/usb_windows.c b/src/usb_windows.c new file mode 100644 index 0000000..d5c728d --- /dev/null +++ b/src/usb_windows.c @@ -0,0 +1,513 @@ +/* + * 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 "sysdeps.h" + +#define TRACE_TAG TRACE_USB +#include "sdb.h" + +/** Structure usb_handle describes our connection to the usb device via + SdbWinApi.dll. This structure is returned from usb_open() routine and + is expected in each subsequent call that is accessing the device. +*/ +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 + SDBAPIHANDLE sdb_interface; + + /// Handle to USB read pipe (endpoint) + SDBAPIHANDLE sdb_read_pipe; + + /// Handle to USB write pipe (endpoint) + SDBAPIHANDLE sdb_write_pipe; + + /// Interface name + char* 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 +SDB_MUTEX_DEFINE( usb_lock ); + +/// Checks if there is opened usb handle in handle_list for this device. +int known_device(const char* 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 char* 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(); + +/// Entry point for thread that polls (every second) for new usb interfaces. +/// This routine calls find_devices in infinite loop. +void* device_poll_thread(void* unused); + +/// Initializes this module +void usb_init(); + +/// Cleans up this module +void usb_cleanup(); + +/// 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); + +/// Gets interface (device) name for an opened usb handle +const char *usb_name(usb_handle* handle); + +int known_device_locked(const char* 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 == stricmp(usb->interface_name, dev_name))) { + return 1; + } + } + } + + return 0; +} + +int known_device(const char* dev_name) { + int ret = 0; + + if (NULL != dev_name) { + sdb_mutex_lock(&usb_lock); + ret = known_device_locked(dev_name); + sdb_mutex_unlock(&usb_lock); + } + + return ret; +} + +int register_new_device(usb_handle* handle) { + if (NULL == handle) + return 0; + + sdb_mutex_lock(&usb_lock); + + // Check if device is already in the list + if (known_device_locked(handle->interface_name)) { + sdb_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; + + sdb_mutex_unlock(&usb_lock); + + return 1; +} + +void* device_poll_thread(void* unused) { + D("Created device thread\n"); + + while(1) { + find_devices(); + sdb_sleep_ms(1000); + } + + return NULL; +} + +void usb_init() { + sdb_thread_t tid; + + if(sdb_thread_create(&tid, device_poll_thread, NULL)) { + fatal_errno("cannot create input thread"); + } +} + +void usb_cleanup() { +} + +usb_handle* do_usb_open(const wchar_t* interface_name) { + // Allocate our handle + usb_handle* ret = (usb_handle*)malloc(sizeof(usb_handle)); + if (NULL == ret) + return NULL; + + // Set linkers back to the handle + ret->next = ret; + ret->prev = ret; + + // Create interface. + ret->sdb_interface = SdbCreateInterfaceByName(interface_name); + + if (NULL == ret->sdb_interface) { + free(ret); + errno = GetLastError(); + return NULL; + } + + // Open read pipe (endpoint) + ret->sdb_read_pipe = + SdbOpenDefaultBulkReadEndpoint(ret->sdb_interface, + SdbOpenAccessTypeReadWrite, + SdbOpenSharingModeReadWrite); + if (NULL != ret->sdb_read_pipe) { + // Open write pipe (endpoint) + ret->sdb_write_pipe = + SdbOpenDefaultBulkWriteEndpoint(ret->sdb_interface, + SdbOpenAccessTypeReadWrite, + SdbOpenSharingModeReadWrite); + if (NULL != ret->sdb_write_pipe) { + // Save interface name + unsigned long name_len = 0; + + // First get expected name length + SdbGetInterfaceName(ret->sdb_interface, + NULL, + &name_len, + true); + if (0 != name_len) { + ret->interface_name = (char*)malloc(name_len); + + if (NULL != ret->interface_name) { + // Now save the name + if (SdbGetInterfaceName(ret->sdb_interface, + ret->interface_name, + &name_len, + true)) { + // We're done at this point + return ret; + } + } else { + SetLastError(ERROR_OUTOFMEMORY); + } + } + } + } + + // Something went wrong. + errno = GetLastError(); + usb_cleanup_handle(ret); + free(ret); + SetLastError(errno); + + return NULL; +} + +int usb_write(usb_handle* handle, const void* data, int len) { + unsigned long time_out = 500 + len * 8; + unsigned long written = 0; + int ret; + + D("usb_write %d\n", len); + if (NULL != handle) { + // Perform write + ret = SdbWriteEndpointSync(handle->sdb_write_pipe, + (void*)data, + (unsigned long)len, + &written, + time_out); + errno = GetLastError(); + + if (ret) { + // Make sure that we've written what we were asked to write + D("usb_write got: %ld, expected: %d\n", written, len); + if (written == (unsigned long)len) { + if(handle->zero_mask && (len & handle->zero_mask) == 0) { + // Send a zero length packet + SdbWriteEndpointSync(handle->sdb_write_pipe, + (void*)data, + 0, + &written, + time_out); + } + return 0; + } + } else { + // assume ERROR_INVALID_HANDLE indicates we are disconnected + if (errno == ERROR_INVALID_HANDLE) + usb_kick(handle); + } + } else { + D("usb_write NULL handle\n"); + SetLastError(ERROR_INVALID_HANDLE); + } + + D("usb_write failed: %d\n", errno); + + return -1; +} + +int usb_read(usb_handle *handle, void* data, int len) { + unsigned long time_out = 500 + len * 8; + unsigned long read = 0; + int ret; + + D("usb_read %d\n", len); + if (NULL != handle) { + while (len > 0) { + int xfer = (len > 4096) ? 4096 : len; + + ret = SdbReadEndpointSync(handle->sdb_read_pipe, + (void*)data, + (unsigned long)xfer, + &read, + time_out); + errno = GetLastError(); + D("usb_write got: %ld, expected: %d, errno: %d\n", read, xfer, errno); + if (ret) { + data += read; + len -= read; + + if (len == 0) + return 0; + } else if (errno != ERROR_SEM_TIMEOUT) { + // assume ERROR_INVALID_HANDLE indicates we are disconnected + if (errno == ERROR_INVALID_HANDLE) + usb_kick(handle); + break; + } + } + } else { + D("usb_read NULL handle\n"); + SetLastError(ERROR_INVALID_HANDLE); + } + + D("usb_read failed: %d\n", errno); + + return -1; +} + +void usb_cleanup_handle(usb_handle* handle) { + if (NULL != handle) { + if (NULL != handle->interface_name) + free(handle->interface_name); + if (NULL != handle->sdb_write_pipe) + SdbCloseHandle(handle->sdb_write_pipe); + if (NULL != handle->sdb_read_pipe) + SdbCloseHandle(handle->sdb_read_pipe); + if (NULL != handle->sdb_interface) + SdbCloseHandle(handle->sdb_interface); + + handle->interface_name = NULL; + handle->sdb_write_pipe = NULL; + handle->sdb_read_pipe = NULL; + handle->sdb_interface = NULL; + } +} + +void usb_kick(usb_handle* handle) { + if (NULL != handle) { + sdb_mutex_lock(&usb_lock); + + usb_cleanup_handle(handle); + + sdb_mutex_unlock(&usb_lock); + } else { + SetLastError(ERROR_INVALID_HANDLE); + errno = ERROR_INVALID_HANDLE; + } +} + +int usb_close(usb_handle* handle) { + D("usb_close\n"); + + if (NULL != handle) { + // Remove handle from the list + sdb_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; + } + + sdb_mutex_unlock(&usb_lock); + + // Cleanup handle + usb_cleanup_handle(handle); + free(handle); + } + + return 0; +} + +const char *usb_name(usb_handle* handle) { + if (NULL == handle) { + SetLastError(ERROR_INVALID_HANDLE); + errno = ERROR_INVALID_HANDLE; + return NULL; + } + + return (const char*)handle->interface_name; +} + +int recognized_device(usb_handle* handle) { + if (NULL == handle) + return 0; + + // Check vendor and product id first + USB_DEVICE_DESCRIPTOR device_desc; + + if (!SdbGetUsbDeviceDescriptor(handle->sdb_interface, + &device_desc)) { + return 0; + } + + // Then check interface properties + USB_INTERFACE_DESCRIPTOR interf_desc; + + if (!SdbGetUsbInterfaceDescriptor(handle->sdb_interface, + &interf_desc)) { + return 0; + } + + // Must have two endpoints + if (2 != interf_desc.bNumEndpoints) { + return 0; + } + + if (is_sdb_interface(device_desc.idVendor, device_desc.idProduct, + interf_desc.bInterfaceClass, interf_desc.bInterfaceSubClass, interf_desc.bInterfaceProtocol)) { + + if(interf_desc.bInterfaceProtocol == 0x01) { + SdbEndpointInformation endpoint_info; + // assuming zero is a valid bulk endpoint ID + if (SdbGetEndpointInformation(handle->sdb_interface, 0, &endpoint_info)) { + handle->zero_mask = endpoint_info.max_packet_size - 1; + } + } + + return 1; + } + + return 0; +} + +void find_devices() { + usb_handle* handle = NULL; + char entry_buffer[2048]; + char interf_name[2048]; + SdbInterfaceInfo* next_interface = (SdbInterfaceInfo*)(&entry_buffer[0]); + unsigned long entry_buffer_size = sizeof(entry_buffer); + char* copy_name; + + // Enumerate all present and active interfaces. + SDBAPIHANDLE enum_handle = + SdbEnumInterfaces(usb_class_id, true, true, true); + + if (NULL == enum_handle) + return; + + while (SdbNextInterface(enum_handle, next_interface, &entry_buffer_size)) { + // TODO: FIXME - temp hack converting wchar_t into char. + // It would be better to change SdbNextInterface so it will return + // interface name as single char string. + const wchar_t* wchar_name = next_interface->device_name; + for(copy_name = interf_name; + L'\0' != *wchar_name; + wchar_name++, copy_name++) { + *copy_name = (char)(*wchar_name); + } + *copy_name = '\0'; + + // Lets see if we already have this device in the list + if (!known_device(interf_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 %s\n", interf_name); + char serial_number[512]; + unsigned long serial_number_len = sizeof(serial_number); + if (SdbGetSerialNumber(handle->sdb_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, 1); + } else { + D("register_new_device failed for %s\n", interf_name); + usb_cleanup_handle(handle); + free(handle); + } + } else { + D("cannot get serial number\n"); + usb_cleanup_handle(handle); + free(handle); + } + } else { + usb_cleanup_handle(handle); + free(handle); + } + } + } + + entry_buffer_size = sizeof(entry_buffer); + } + + SdbCloseHandle(enum_handle); +} diff --git a/src/utils.c b/src/utils.c new file mode 100644 index 0000000..bd31e20 --- /dev/null +++ b/src/utils.c @@ -0,0 +1,106 @@ +/* + * 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. + */ +#include "utils.h" +#include +#include +#include + +char* +buff_addc (char* buff, char* buffEnd, int c) +{ + int avail = buffEnd - buff; + + if (avail <= 0) /* already in overflow mode */ + return buff; + + if (avail == 1) { /* overflowing, the last byte is reserved for zero */ + buff[0] = 0; + return buff + 1; + } + + buff[0] = (char) c; /* add char and terminating zero */ + buff[1] = 0; + return buff + 1; +} + +char* +buff_adds (char* buff, char* buffEnd, const char* s) +{ + int slen = strlen(s); + + return buff_addb(buff, buffEnd, s, slen); +} + +char* +buff_addb (char* buff, char* buffEnd, const void* data, int len) +{ + int avail = (buffEnd - buff); + + if (avail <= 0 || len <= 0) /* already overflowing */ + return buff; + + if (len > avail) + len = avail; + + memcpy(buff, data, len); + + buff += len; + + /* ensure there is a terminating zero */ + if (buff >= buffEnd) { /* overflow */ + buff[-1] = 0; + } else + buff[0] = 0; + + return buff; +} + +char* +buff_add (char* buff, char* buffEnd, const char* format, ... ) +{ + int avail; + + avail = (buffEnd - buff); + + if (avail > 0) { + va_list args; + int nn; + + va_start(args, format); + nn = vsnprintf( buff, avail, format, args); + va_end(args); + + if (nn < 0) { + /* some C libraries return -1 in case of overflow, + * but they will also do that if the format spec is + * invalid. We assume SDB is not buggy enough to + * trigger that last case. */ + nn = avail; + } + else if (nn > avail) { + nn = avail; + } + + buff += nn; + + /* ensure that there is a terminating zero */ + if (buff >= buffEnd) + buff[-1] = 0; + else + buff[0] = 0; + } + return buff; +} diff --git a/src/utils.h b/src/utils.h new file mode 100644 index 0000000..2f2d2d8 --- /dev/null +++ b/src/utils.h @@ -0,0 +1,68 @@ +/* + * 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. + */ +#ifndef _SDB_UTILS_H +#define _SDB_UTILS_H + +/* bounded buffer functions */ + +/* all these functions are used to append data to a bounded buffer. + * + * after each operation, the buffer is guaranteed to be zero-terminated, + * even in the case of an overflow. they all return the new buffer position + * which allows one to use them in succession, only checking for overflows + * at the end. For example: + * + * BUFF_DECL(temp,p,end,1024); + * char* p; + * + * p = buff_addc(temp, end, '"'); + * p = buff_adds(temp, end, string); + * p = buff_addc(temp, end, '"'); + * + * if (p >= end) { + * overflow detected. note that 'temp' is + * zero-terminated for safety. + * } + * return strdup(temp); + */ + +/* tries to add a character to the buffer, in case of overflow + * this will only write a terminating zero and return buffEnd. + */ +char* buff_addc (char* buff, char* buffEnd, int c); + +/* tries to add a string to the buffer */ +char* buff_adds (char* buff, char* buffEnd, const char* s); + +/* tries to add a bytes to the buffer. the input can contain zero bytes, + * but a terminating zero will always be appended at the end anyway + */ +char* buff_addb (char* buff, char* buffEnd, const void* data, int len); + +/* tries to add a formatted string to a bounded buffer */ +char* buff_add (char* buff, char* buffEnd, const char* format, ... ); + +/* convenience macro used to define a bounded buffer, as well as + * a 'cursor' and 'end' variables all in one go. + * + * note: this doesn't place an initial terminating zero in the buffer, + * you need to use one of the buff_ functions for this. or simply + * do _cursor[0] = 0 manually. + */ +#define BUFF_DECL(_buff,_cursor,_end,_size) \ + char _buff[_size], *_cursor=_buff, *_end = _cursor + (_size) + +#endif /* _SDB_UTILS_H */ diff --git a/usb-connection-for-ssh/packager/linux/data/tools/ssh/99-samsung-device.rules b/usb-connection-for-ssh/packager/linux/data/tools/ssh/99-samsung-device.rules new file mode 100644 index 0000000..6874374 --- /dev/null +++ b/usb-connection-for-ssh/packager/linux/data/tools/ssh/99-samsung-device.rules @@ -0,0 +1,25 @@ +# This file causes network devices to be brought up or down as a result +# of hardware being added or removed, including that which isn't ordinarily +# removable. +# See udev(7) for syntax. + +SUBSYSTEM=="net", GOTO="net_start" +GOTO="net_end" + +LABEL="net_start" + +# Bring devices up and down only if they're marked auto. +# Use start-stop-daemon so we don't wait on dhcp +ACTION=="add", RUN+="/sbin/start-stop-daemon --start --background --pidfile /var/run/network/bogus --startas /sbin/ifup -- --allow auto $env{INTERFACE}" +ACTION=="add", DRIVERS=="cdc_ether", RUN+="/bin/sh -c 'echo 1 > /var/run/udev-usbnet'" +ACTION=="remove", RUN+="/sbin/start-stop-daemon --start --background --pidfile /var/run/network/bogus --startas /sbin/ifdown -- --allow auto $env{INTERFACE}" +ACTION=="remove", RUN+="/bin/sh -c 'echo 0 > /var/run/udev-usbnet'" + +LABEL="net_end" + +ACTION=="add", SUBSYSTEM=="net", ATTRS{idVendor}=="0525", NAME="samsung_device" +ACTION=="add", SUBSYSTEM=="net", ATTRS{idVendor}=="0525", RUN+="/bin/sh -c 'TIZEN_SDK_SSH_PATH/config_device.sh samsung_device'" +ACTION=="add", SUBSYSTEM=="net", ATTRS{idVendor}=="04e8", NAME="samsung_device" +ACTION=="add", SUBSYSTEM=="net", ATTRS{idVendor}=="04e8", RUN+="/bin/sh -c 'TIZEN_SDK_SSH_PATH/config_device.sh samsung_device'" +ACTION=="remove", KERNEL=="samsung_device", RUN+="/bin/sh -c 'TIZEN_SDK_SSH_PATH/config_device.sh stop'" + diff --git a/usb-connection-for-ssh/packager/linux/data/tools/ssh/config_device.sh b/usb-connection-for-ssh/packager/linux/data/tools/ssh/config_device.sh new file mode 100755 index 0000000..d845c65 --- /dev/null +++ b/usb-connection-for-ssh/packager/linux/data/tools/ssh/config_device.sh @@ -0,0 +1,59 @@ +#!/bin/sh + +if [ $# -ne 1 ];then + echo "Usage: $0 [device]" + exit 1 +fi + +UBUNTU_VER=`awk 'BEGIN {FS="="}; /DISTRIB_RELEASE.*/ {print $2}' /etc/lsb-release` +IPADDR=192.168.129.1 + +case $UBUNTU_VER in + 8.04) + NETMGR="/etc/dbus-1/event.d/25NetworkManager" + echo "8.04" + ;; + *) + NETMGR="service network-manager" + echo "${UBUNTU_VER}" + ;; +esac + +getDevState() { + DEV_CONF_STATE=-1 + until [ $DEV_CONF_STATE -eq 1 ]; do + DEV_CONF_STATE=`ifconfig | awk -v intRecNum=-1 '/samsung_device/ {intRecNum=NR;} /inet addr/ {if(intRecNum==NR-1) {intRecNum=-2; exit}} END {if(intRecNum==-1) print 0; else if(intRecNum==-2) print 2; else if(intRecNum > 0) print 1;}'` + echo $DEV_CONF_STATE + sleep 1 + done +} + +case "$1" in + stop) + echo 0 > /var/run/udev-usbnet + echo 0 > /proc/sys/net/ipv4/ip_forward + iptables -t nat -D POSTROUTING -s 192.168.129.3 -j MASQUERADE + if [ $UBUNTU_VER != "8.04" ] && [ $UBUNTU_VER != "8.10" ] && [ $UBUNTU_VER != "9.04" ]; then + ${NETMGR} start + fi + exit 0 + ;; + *) + if [ $UBUNTU_VER != "8.10" ] && [ $UBUNTU_VER != "9.04" ] && [ $UBUNTU_VER != "8.04" ]; then + ${NETMGR} stop + else + getDevState + fi + /sbin/ifconfig $1 $IPADDR netmask 255.255.255.0 broadcast 192.168.129.255 up + if [ $UBUNTU_VER == "8.10" ] || [ $UBUNTU_VER == "9.04" ] || [ $UBUNTU_VER == "8.04" ]; then + getDevState + /sbin/ifconfig $1 $IPADDR netmask 255.255.255.0 broadcast 192.168.129.255 up + fi + echo 1 > /proc/sys/net/ipv4/ip_forward + iptables -t nat -A POSTROUTING -s 192.168.129.3 -j MASQUERADE + echo 1 > /var/run/udev-usbnet + + exit 0 + ;; +esac + -- 2.7.4