CreateProcess 调用Adb 用管道接收结果

android adb源码分析(1)

2016年07月28日 21:31:38

阅读数：9825

ADB是Android debug bridge的缩写，它使用PC机可以通过USB或网络与android设备通讯。

adb的源码位于system/core/adb目录下，先来看下编译脚本Android.mk：

# 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 -ldl -lpthread
  LOCAL_CFLAGS += -DWORKAROUND_BUG6558362
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 ../libcutils/list.c
  EXTRA_STATIC_LIBS := AdbWinApi
  ifneq ($(strip $(USE_CYGWIN)),)
    # Pure cygwin case
    LOCAL_LDLIBS += -lpthread -lgdi32
    LOCAL_C_INCLUDES += /usr/include/w32api/ddk
  endif
  ifneq ($(strip $(USE_MINGW)),)
    # MinGW under Linux case
    LOCAL_LDLIBS += -lws2_32 -lgdi32
    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 \
	adb_auth_host.c \
	sockets.c \
	services.c \
	file_sync_client.c \
	$(EXTRA_SRCS) \
	$(USB_SRCS) \
	usb_vendors.c

LOCAL_C_INCLUDES += external/openssl/include

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_MODULE_TAGS := debug

LOCAL_STATIC_LIBRARIES := libzipfile libunz libcrypto_static $(EXTRA_STATIC_LIBS)
ifeq ($(USE_SYSDEPS_WIN32),)
	LOCAL_STATIC_LIBRARIES += libcutils
endif

include $(BUILD_HOST_EXECUTABLE)

$(call dist-for-goals,dist_files sdk,$(LOCAL_BUILT_MODULE))

ifeq ($(HOST_OS),windows)
$(LOCAL_INSTALLED_MODULE): \
    $(HOST_OUT_EXECUTABLES)/AdbWinApi.dll \
    $(HOST_OUT_EXECUTABLES)/AdbWinUsbApi.dll
endif


# adbd device daemon
# =========================================================

include $(CLEAR_VARS)

LOCAL_SRC_FILES := \
	adb.c \
	backup_service.c \
	fdevent.c \
	transport.c \
	transport_local.c \
	transport_usb.c \
	adb_auth_client.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

LOCAL_CFLAGS := -O2 -g -DADB_HOST=0 -Wall -Wno-unused-parameter
LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE

ifneq (,$(filter userdebug eng,$(TARGET_BUILD_VARIANT)))
LOCAL_CFLAGS += -DALLOW_ADBD_ROOT=1
endif

LOCAL_MODULE := adbd

LOCAL_FORCE_STATIC_EXECUTABLE := true
LOCAL_MODULE_PATH := $(TARGET_ROOT_OUT_SBIN)
LOCAL_UNSTRIPPED_PATH := $(TARGET_ROOT_OUT_SBIN_UNSTRIPPED)

LOCAL_STATIC_LIBRARIES := liblog libcutils libc libmincrypt
include $(BUILD_EXECUTABLE)


# adb host tool for device-as-host
# =========================================================
ifneq ($(SDK_ONLY),true)
include $(CLEAR_VARS)

LOCAL_LDLIBS := -lrt -ldl -lpthread

LOCAL_SRC_FILES := \
	adb.c \
	console.c \
	transport.c \
	transport_local.c \
	transport_usb.c \
	commandline.c \
	adb_client.c \
	adb_auth_host.c \
	sockets.c \
	services.c \
	file_sync_client.c \
	get_my_path_linux.c \
	usb_linux.c \
	usb_vendors.c \
	fdevent.c

LOCAL_CFLAGS := \
	-O2 \
	-g \
	-DADB_HOST=1 \
	-DADB_HOST_ON_TARGET=1 \
	-Wall \
	-Wno-unused-parameter \
	-D_XOPEN_SOURCE \
	-D_GNU_SOURCE

LOCAL_C_INCLUDES += external/openssl/include

LOCAL_MODULE := adb

LOCAL_STATIC_LIBRARIES := libzipfile libunz libcutils

LOCAL_SHARED_LIBRARIES := libcrypto

include $(BUILD_EXECUTABLE)
endif

可以看到，最终会有3个执行文件被生成，adbd和两个adb程序。adbd是手机终的守护进程；adb一个是windows、linux、darwin或freebsd运行的程序，另一个是目标机上运行的程序。

    宏ADB_HOST用于区分是PC端程序还是目标机端的程序。宏ADB_HOST_ON_TARGET用于区分adb程序是否是在目标机上运行。这3个程序使用的是同一份源码，在内部，使用这些宏来区别不同的程序。

    程序的入口在adb.c的main()函数：

1. int main(int argc, char **argv)
2. {
3. #if ADB_HOST
4. adb_sysdeps_init();
5. adb_trace_init();
6. D( "Handling commandline()\n");
7. return adb_commandline(argc - 1, argv + 1);
8. #else
9. /* If adbd runs inside the emulator this will enable adb tracing via
10. * adb-debug qemud service in the emulator. */
11. adb_qemu_trace_init();
12. if((argc > 1) && (! strcmp(argv[ 1], "recovery"))) {
13. adb_device_banner = "recovery";
14. recovery_mode = 1;
15. }
17. start_device_log();
18. D( "Handling main()\n");
19. return adb_main( 0, DEFAULT_ADB_PORT);
20. #endif
21. }

先来看adbd程序，此时宏的设置是ADB_HOST=0。上面代码中start_device_log()是log的初始化操作，可以重定向输出的log信息，接着进入adb_main()函数。先来看下它的参数DEFAULT_ADB_PORT：

1. #if ADB_HOST_ON_TARGET
2. /* adb and adbd are coexisting on the target, so use 5038 for adb
3. * to avoid conflicting with adbd's usage of 5037
4. */
5. # define DEFAULT_ADB_PORT 5038
6. #else
7. # define DEFAULT_ADB_PORT 5037
8. #endif

如果是目标机程序，它的值是5038，否则它的值是5037。这里没有定义ADB_HOST_ON_TARGET， 所以它是5037。

adb_main()的源代码如下：

1. int adb_main(int is_daemon, int server_port)
2. {
3. #if !ADB_HOST
4. int port;
5. char value[PROPERTY_VALUE_MAX];
7. umask( 000);
8. #endif
10. atexit(adb_cleanup);
11. #ifdef HAVE_WIN32_PROC
12. SetConsoleCtrlHandler( ctrlc_handler, TRUE );
13. #elif defined(HAVE_FORKEXEC)
14. // No SIGCHLD. Let the service subproc handle its children.
15. signal(SIGPIPE, SIG_IGN);
16. #endif
18. init_transport_registration();
20. #if ADB_HOST
21. HOST = 1;
22. usb_vendors_init();
23. usb_init();
24. local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
25. adb_auth_init();
27. char local_name[ 30];
28. build_local_name(local_name, sizeof(local_name), server_port);
29. if(install_listener(local_name, "*smartsocket*", NULL)) {
30. exit( 1);
31. }
32. #else
33. property_get( "ro.adb.secure", value, "0");
34. auth_enabled = ! strcmp(value, "1");
35. if (auth_enabled)
36. adb_auth_init();
38. // Our external storage path may be different than apps, since
39. // we aren't able to bind mount after dropping root.
40. const char* adb_external_storage = getenv( "ADB_EXTERNAL_STORAGE");
41. if ( NULL != adb_external_storage) {
42. setenv( "EXTERNAL_STORAGE", adb_external_storage, 1);
43. } else {
44. D( "Warning: ADB_EXTERNAL_STORAGE is not set. Leaving EXTERNAL_STORAGE"
45. " unchanged.\n");
46. }
48. /* don't listen on a port (default 5037) if running in secure mode */
49. /* don't run as root if we are running in secure mode */
50. if (should_drop_privileges()) {
51. struct __user_cap_header_struct header;
52. struct __user_cap_data_struct cap;
54. if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) != 0) {
55. exit( 1);
56. }
58. /* add extra groups:
59. ** AID_ADB to access the USB driver
60. ** AID_LOG to read system logs (adb logcat)
61. ** AID_INPUT to diagnose input issues (getevent)
62. ** AID_INET to diagnose network issues (netcfg, ping)
63. ** AID_GRAPHICS to access the frame buffer
64. ** AID_NET_BT and AID_NET_BT_ADMIN to diagnose bluetooth (hcidump)
65. ** AID_SDCARD_R to allow reading from the SD card
66. ** AID_SDCARD_RW to allow writing to the SD card
67. ** AID_MOUNT to allow unmounting the SD card before rebooting
68. ** AID_NET_BW_STATS to read out qtaguid statistics
69. */
70. gid_t groups[] = { AID_ADB, AID_LOG, AID_INPUT, AID_INET, AID_GRAPHICS,
71. AID_NET_BT, AID_NET_BT_ADMIN, AID_SDCARD_R, AID_SDCARD_RW,
72. AID_MOUNT, AID_NET_BW_STATS };
73. if (setgroups( sizeof(groups)/ sizeof(groups[ 0]), groups) != 0) {
74. exit( 1);
75. }
77. /* then switch user and group to "shell" */
78. if (setgid(AID_SHELL) != 0) {
79. exit( 1);
80. }
81. if (setuid(AID_SHELL) != 0) {
82. exit( 1);
83. }
85. /* set CAP_SYS_BOOT capability, so "adb reboot" will succeed */
86. header.version = _LINUX_CAPABILITY_VERSION;
87. header.pid = 0;
88. cap.effective = cap.permitted = ( 1 << CAP_SYS_BOOT);
89. cap.inheritable = 0;
90. capset(&header, &cap);
92. D( "Local port disabled\n");
93. } else {
94. char local_name[ 30];
95. build_local_name(local_name, sizeof(local_name), server_port);
96. if(install_listener(local_name, "*smartsocket*", NULL)) {
97. exit( 1);
98. }
99. }
101. int usb = 0;
102. if (access(USB_ADB_PATH, F_OK) == 0 || access(USB_FFS_ADB_EP0, F_OK) == 0) {
103. // listen on USB
104. usb_init();
105. usb = 1;
106. }
108. // If one of these properties is set, also listen on that port
109. // If one of the properties isn't set and we couldn't listen on usb,
110. // listen on the default port.
111. property_get( "service.adb.tcp.port", value, "");
112. if (!value[ 0]) {
113. property_get( "persist.adb.tcp.port", value, "");
114. }
115. if ( sscanf(value, "%d", &port) == 1 && port > 0) {
116. printf( "using port=%d\n", port);
117. // listen on TCP port specified by service.adb.tcp.port property
118. local_init(port);
119. } else if (!usb) {
120. // listen on default port
121. local_init(DEFAULT_ADB_LOCAL_TRANSPORT_PORT);
122. }
124. D( "adb_main(): pre init_jdwp()\n");
125. init_jdwp();
126. D( "adb_main(): post init_jdwp()\n");
127. #endif
129. if (is_daemon)
130. {
131. // inform our parent that we are up and running.
132. #ifdef HAVE_WIN32_PROC
133. DWORD count;
134. WriteFile( GetStdHandle( STD_OUTPUT_HANDLE ), "OK\n", 3, &count, NULL );
135. #elif defined(HAVE_FORKEXEC)
136. fprintf( stderr, "OK\n");
137. #endif
138. start_logging();
139. }
140. D( "Event loop starting\n");
142. fdevent_loop();
144. usb_cleanup();
146. return 0;
147. }

(1) init_transport_registration()初始化fevent transport_registration_fde；

(2) 判断系统属性ro.adb.secure，目标板没有设置这个宏；

(3) 没有定义环境变量adb_external_storage；

(4) should_drop_privileges()根据android编译环境should_drop_privileges返回不同的值，如果它的值是userdebug或eng，宏ALLOW_ADBD_ROOT的值被定义为1，执行install_listener()，否则不会定义，这种情况下，由于adbd运行在root下，为保证它的安全性，它需要降级运行；

(5) 判断是否存在设备文件USB_ADB_PATH或USB_FFS_ADB_EP0，存在则执行usb_init()；

(6) 读取属性service.adb.tcp.port或persist.adb.tcp.port（目标板均未定义），执行local_init()，它内部会创建adb thread；

(7) 执行init_jdwp()，jdwp是java调试体系中的一种，具体可百度；

(8) 调用fdevent_loop()监听fdevent并处理；

(9) 程序结束。

再来看adb程序的执行：

在main()中调用return adb_commandline(argc - 1, argv + 1)：

1. int adb_commandline(int argc, char **argv)
2. {
3. char buf[ 4096];
4. int no_daemon = 0;
5. int is_daemon = 0;
6. int is_server = 0;
7. int persist = 0;
8. int r;
9. int quote;
10. transport_type ttype = kTransportAny;
11. char* serial = NULL;
12. char* server_port_str = NULL;
14. /* If defined, this should be an absolute path to
15. * the directory containing all of the various system images
16. * for a particular product. If not defined, and the adb
17. * command requires this information, then the user must
18. * specify the path using "-p".
19. */
20. gProductOutPath = getenv( "ANDROID_PRODUCT_OUT");
21. if (gProductOutPath == NULL || gProductOutPath[ 0] == '\0') {
22. gProductOutPath = NULL;
23. }
24. // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint
26. serial = getenv( "ANDROID_SERIAL");
28. /* Validate and assign the server port */
29. server_port_str = getenv( "ANDROID_ADB_SERVER_PORT");
30. int server_port = DEFAULT_ADB_PORT;
31. if (server_port_str && strlen(server_port_str) > 0) {
32. server_port = ( int) strtol(server_port_str, NULL, 0);
33. if (server_port <= 0) {
34. fprintf( stderr,
35. "adb: Env var ANDROID_ADB_SERVER_PORT must be a positive number. Got \"%s\"\n",
36. server_port_str);
37. return usage();
38. }
39. }
41. /* modifiers and flags */
42. while(argc > 0) {
43. if(! strcmp(argv[ 0], "server")) {
44. is_server = 1;
45. } else if(! strcmp(argv[ 0], "nodaemon")) {
46. no_daemon = 1;
47. } else if (! strcmp(argv[ 0], "fork-server")) {
48. /* this is a special flag used only when the ADB client launches the ADB Server */
49. is_daemon = 1;
50. } else if(! strcmp(argv[ 0], "persist")) {
51. persist = 1;
52. } else if(! strncmp(argv[ 0], "-p", 2)) {
53. const char *product = NULL;
54. if (argv[ 0][ 2] == '\0') {
55. if (argc < 2) return usage();
56. product = argv[ 1];
57. argc--;
58. argv++;
59. } else {
60. product = argv[ 0] + 2;
61. }
62. gProductOutPath = find_product_out_path(product);
63. if (gProductOutPath == NULL) {
64. fprintf( stderr, "adb: could not resolve \"-p %s\"\n",
65. product);
66. return usage();
67. }
68. } else if (argv[ 0][ 0]== '-' && argv[ 0][ 1]== 's') {
69. if ( isdigit(argv[ 0][ 2])) {
70. serial = argv[ 0] + 2;
71. } else {
72. if(argc < 2 || argv[ 0][ 2] != '\0') return usage();
73. serial = argv[ 1];
74. argc--;
75. argv++;
76. }
77. } else if (! strcmp(argv[ 0], "-d")) {
78. ttype = kTransportUsb;
79. } else if (! strcmp(argv[ 0], "-e")) {
80. ttype = kTransportLocal;
81. } else {
82. /* out of recognized modifiers and flags */
83. break;
84. }
85. argc--;
86. argv++;
87. }
89. adb_set_transport(ttype, serial);
90. adb_set_tcp_specifics(server_port);
92. if (is_server) {
93. if (no_daemon || is_daemon) {
94. r = adb_main(is_daemon, server_port);
95. } else {
96. r = launch_server(server_port);
97. }
98. if(r) {
99. fprintf( stderr, "* could not start server *\n");
100. }
101. return r;
102. }
104. top:
105. if(argc == 0) {
106. return usage();
107. }
109. /* adb_connect() commands */
111. if(! strcmp(argv[ 0], "devices")) {
112. char *tmp;
113. char *listopt;
114. if (argc < 2)
115. listopt = "";
116. else if (argc == 2 && ! strcmp(argv[ 1], "-l"))
117. listopt = argv[ 1];
118. else {
119. fprintf( stderr, "Usage: adb devices [-l]\n");
120. return 1;
121. }
122. snprintf(buf, sizeof buf, "host:%s%s", argv[ 0], listopt);
123. tmp = adb_query(buf);
124. if(tmp) {
125. printf( "List of devices attached \n");
126. printf( "%s\n", tmp);
127. return 0;
128. } else {
129. return 1;
130. }
131. }
133. if(! strcmp(argv[ 0], "connect")) {
134. char *tmp;
135. if (argc != 2) {
136. fprintf( stderr, "Usage: adb connect <host>[:<port>]\n");
137. return 1;
138. }
139. snprintf(buf, sizeof buf, "host:connect:%s", argv[ 1]);
140. tmp = adb_query(buf);
141. if(tmp) {
142. printf( "%s\n", tmp);
143. return 0;
144. } else {
145. return 1;
146. }
147. }
149. if(! strcmp(argv[ 0], "disconnect")) {
150. char *tmp;
151. if (argc > 2) {
152. fprintf( stderr, "Usage: adb disconnect [<host>[:<port>]]\n");
153. return 1;
154. }
155. if (argc == 2) {
156. snprintf(buf, sizeof buf, "host:disconnect:%s", argv[ 1]);
157. } else {
158. snprintf(buf, sizeof buf, "host:disconnect:");
159. }
160. tmp = adb_query(buf);
161. if(tmp) {
162. printf( "%s\n", tmp);
163. return 0;
164. } else {
165. return 1;
166. }
167. }
169. if (! strcmp(argv[ 0], "emu")) {
170. return adb_send_emulator_command(argc, argv);
171. }
173. if(! strcmp(argv[ 0], "shell") || ! strcmp(argv[ 0], "hell")) {
174. int r;
175. int fd;
177. char h = (argv[ 0][ 0] == 'h');
179. if (h) {
180. printf( "\x1b[41;33m");
181. fflush( stdout);
182. }
184. if(argc < 2) {
185. D( "starting interactive shell\n");
186. r = interactive_shell();
187. if (h) {
188. printf( "\x1b[0m");
189. fflush( stdout);
190. }
191. return r;
192. }
194. snprintf(buf, sizeof buf, "shell:%s", argv[ 1]);
195. argc -= 2;
196. argv += 2;
197. while(argc-- > 0) {
198. strcat(buf, " ");
200. /* quote empty strings and strings with spaces */
201. quote = (**argv == 0 || strchr(*argv, ' '));
202. if (quote)
203. strcat(buf, "\"");
204. strcat(buf, *argv++);
205. if (quote)
206. strcat(buf, "\"");
207. }
209. for(;;) {
210. D( "interactive shell loop. buff=%s\n", buf);
211. fd = adb_connect(buf);
212. if(fd >= 0) {
213. D( "about to read_and_dump(fd=%d)\n", fd);
214. read_and_dump(fd);
215. D( "read_and_dump() done.\n");
216. adb_close(fd);
217. r = 0;
218. } else {
219. fprintf( stderr, "error: %s\n", adb_error());
220. r = -1;
221. }
223. if(persist) {
224. fprintf( stderr, "\n- waiting for device -\n");
225. adb_sleep_ms( 1000);
226. do_cmd(ttype, serial, "wait-for-device", 0);
227. } else {
228. if (h) {
229. printf( "\x1b[0m");
230. fflush( stdout);
231. }
232. D( "interactive shell loop. return r=%d\n", r);
233. return r;
234. }
235. }
236. }
238. if(! strcmp(argv[ 0], "kill-server")) {
239. int fd;
240. fd = _adb_connect( "host:kill");
241. if(fd == -1) {
242. fprintf( stderr, "* server not running *\n");
243. return 1;
244. }
245. return 0;
246. }
248. if(! strcmp(argv[ 0], "sideload")) {
249. if(argc != 2) return usage();
250. if(adb_download( "sideload", argv[ 1], 1)) {
251. return 1;
252. } else {
253. return 0;
254. }
255. }
257. if(! strcmp(argv[ 0], "remount") || ! strcmp(argv[ 0], "reboot")
258. || ! strcmp(argv[ 0], "reboot-bootloader")
259. || ! strcmp(argv[ 0], "tcpip") || ! strcmp(argv[ 0], "usb")
260. || ! strcmp(argv[ 0], "root")) {
261. char command[ 100];
262. if (! strcmp(argv[ 0], "reboot-bootloader"))
263. snprintf(command, sizeof(command), "reboot:bootloader");
264. else if (argc > 1)
265. snprintf(command, sizeof(command), "%s:%s", argv[ 0], argv[ 1]);
266. else
267. snprintf(command, sizeof(command), "%s:", argv[ 0]);
268. int fd = adb_connect(command);
269. if(fd >= 0) {
270. read_and_dump(fd);
271. adb_close(fd);
272. return 0;
273. }
274. fprintf( stderr, "error: %s\n", adb_error());
275. return 1;
276. }
278. if(! strcmp(argv[ 0], "bugreport")) {
279. if (argc != 1) return usage();
280. do_cmd(ttype, serial, "shell", "bugreport", 0);
281. return 0;
282. }
284. /* adb_command() wrapper commands */
286. if(! strncmp(argv[ 0], "wait-for-", strlen( "wait-for-"))) {
287. char* service = argv[ 0];
288. if (! strncmp(service, "wait-for-device", strlen( "wait-for-device"))) {
289. if (ttype == kTransportUsb) {
290. service = "wait-for-usb";
291. } else if (ttype == kTransportLocal) {
292. service = "wait-for-local";
293. } else {
294. service = "wait-for-any";
295. }
296. }
298. format_host_command(buf, sizeof buf, service, ttype, serial);
300. if (adb_command(buf)) {
301. D( "failure: %s *\n",adb_error());
302. fprintf( stderr, "error: %s\n", adb_error());
303. return 1;
304. }
306. /* Allow a command to be run after wait-for-device,
307. * e.g. 'adb wait-for-device shell'.
308. */
309. if(argc > 1) {
310. argc--;
311. argv++;
312. goto top;
313. }
314. return 0;
315. }
317. if(! strcmp(argv[ 0], "forward")) {
318. if(argc != 3) return usage();
319. if (serial) {
320. snprintf(buf, sizeof buf, "host-serial:%s:forward:%s;%s",serial, argv[ 1], argv[ 2]);
321. } else if (ttype == kTransportUsb) {
322. snprintf(buf, sizeof buf, "host-usb:forward:%s;%s", argv[ 1], argv[ 2]);
323. } else if (ttype == kTransportLocal) {
324. snprintf(buf, sizeof buf, "host-local:forward:%s;%s", argv[ 1], argv[ 2]);
325. } else {
326. snprintf(buf, sizeof buf, "host:forward:%s;%s", argv[ 1], argv[ 2]);
327. }
328. if(adb_command(buf)) {
329. fprintf( stderr, "error: %s\n", adb_error());
330. return 1;
331. }
332. return 0;
333. }
335. /* do_sync_*() commands */
337. if(! strcmp(argv[ 0], "ls")) {
338. if(argc != 2) return usage();
339. return do_sync_ls(argv[ 1]);
340. }
342. if(! strcmp(argv[ 0], "push")) {
343. if(argc != 3) return usage();
344. return do_sync_push(argv[ 1], argv[ 2], 0 /* no verify APK */);
345. }
347. if(! strcmp(argv[ 0], "pull")) {
348. if (argc == 2) {
349. return do_sync_pull(argv[ 1], ".");
350. } else if (argc == 3) {
351. return do_sync_pull(argv[ 1], argv[ 2]);
352. } else {
353. return usage();
354. }
355. }
357. if(! strcmp(argv[ 0], "install")) {
358. if (argc < 2) return usage();
359. return install_app(ttype, serial, argc, argv);
360. }
362. if(! strcmp(argv[ 0], "uninstall")) {
363. if (argc < 2) return usage();
364. return uninstall_app(ttype, serial, argc, argv);
365. }
367. if(! strcmp(argv[ 0], "sync")) {
368. char *srcarg, *android_srcpath, *data_srcpath;
369. int listonly = 0;
371. int ret;
372. if(argc < 2) {
373. /* No local path was specified. */
374. srcarg = NULL;
375. } else if (argc >= 2 && strcmp(argv[ 1], "-l") == 0) {
376. listonly = 1;
377. if (argc == 3) {
378. srcarg = argv[ 2];
379. } else {
380. srcarg = NULL;
381. }
382. } else if(argc == 2) {
383. /* A local path or "android"/"data" arg was specified. */
384. srcarg = argv[ 1];
385. } else {
386. return usage();
387. }
388. ret = find_sync_dirs(srcarg, &android_srcpath, &data_srcpath);
389. if(ret != 0) return usage();
391. if(android_srcpath != NULL)
392. ret = do_sync_sync(android_srcpath, "/system", listonly);
393. if(ret == 0 && data_srcpath != NULL)
394. ret = do_sync_sync(data_srcpath, "/data", listonly);
396. free(android_srcpath);
397. free(data_srcpath);
398. return ret;
399. }
401. /* passthrough commands */
403. if(! strcmp(argv[ 0], "get-state") ||
404. ! strcmp(argv[ 0], "get-serialno") ||
405. ! strcmp(argv[ 0], "get-devpath"))
406. {
407. char *tmp;
409. format_host_command(buf, sizeof buf, argv[ 0], ttype, serial);
410. tmp = adb_query(buf);
411. if(tmp) {
412. printf( "%s\n", tmp);
413. return 0;
414. } else {
415. return 1;
416. }
417. }
419. /* other commands */
421. if(! strcmp(argv[ 0], "status-window")) {
422. status_window(ttype, serial);
423. return 0;
424. }
426. if(! strcmp(argv[ 0], "logcat") || ! strcmp(argv[ 0], "lolcat") || ! strcmp(argv[ 0], "longcat")) {
427. return logcat(ttype, serial, argc, argv);
428. }
430. if(! strcmp(argv[ 0], "ppp")) {
431. return ppp(argc, argv);
432. }
434. if (! strcmp(argv[ 0], "start-server")) {
435. return adb_connect( "host:start-server");
436. }
438. if (! strcmp(argv[ 0], "backup")) {
439. return backup(argc, argv);
440. }
442. if (! strcmp(argv[ 0], "restore")) {
443. return restore(argc, argv);
444. }
446. if (! strcmp(argv[ 0], "jdwp")) {
447. int fd = adb_connect( "jdwp");
448. if (fd >= 0) {
449. read_and_dump(fd);
450. adb_close(fd);
451. return 0;
452. } else {
453. fprintf( stderr, "error: %s\n", adb_error());
454. return -1;
455. }
456. }
458. /* "adb /?" is a common idiom under Windows */
459. if(! strcmp(argv[ 0], "help") || ! strcmp(argv[ 0], "/?")) {
460. help();
461. return 0;
462. }
464. if(! strcmp(argv[ 0], "version")) {
465. version( stdout);
466. return 0;
467. }
469. usage();
470. return 1;
471. }

它的代码有点长，但可以很容易看明白它根据命令的参数执行不同的功能。adb程序可能以服务的方式或命令行客户端的方式运行。

－－－－－－－－－－

以上就是main()函数的执行过程，后续将分析其中的细节内容。