zoukankan      html  css  js  c++  java

  • android adb源码分析(1)

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

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

    [plain] view plain copy
    1. # Copyright 2005 The Android Open Source Project  
    2. #  
    3. # Android.mk for adb  
    4. #  
    5.   
    6. LOCAL_PATH:= $(call my-dir)  
    7.   
    8. # adb host tool  
    9. # =========================================================  
    10. include $(CLEAR_VARS)  
    11.   
    12. # Default to a virtual (sockets) usb interface  
    13. USB_SRCS :=  
    14. EXTRA_SRCS :=  
    15.   
    16. ifeq ($(HOST_OS),linux)  
    17.   USB_SRCS := usb_linux.c  
    18.   EXTRA_SRCS := get_my_path_linux.c  
    19.   LOCAL_LDLIBS += -lrt -ldl -lpthread  
    20.   LOCAL_CFLAGS += -DWORKAROUND_BUG6558362  
    21. endif  
    22.   
    23. ifeq ($(HOST_OS),darwin)  
    24.   USB_SRCS := usb_osx.c  
    25.   EXTRA_SRCS := get_my_path_darwin.c  
    26.   LOCAL_LDLIBS += -lpthread -framework CoreFoundation -framework IOKit -framework Carbon  
    27. endif  
    28.   
    29. ifeq ($(HOST_OS),freebsd)  
    30.   USB_SRCS := usb_libusb.c  
    31.   EXTRA_SRCS := get_my_path_freebsd.c  
    32.   LOCAL_LDLIBS += -lpthread -lusb  
    33. endif  
    34.   
    35. ifeq ($(HOST_OS),windows)  
    36.   USB_SRCS := usb_windows.c  
    37.   EXTRA_SRCS := get_my_path_windows.c ../libcutils/list.c  
    38.   EXTRA_STATIC_LIBS := AdbWinApi  
    39.   ifneq ($(strip $(USE_CYGWIN)),)  
    40.     # Pure cygwin case  
    41.     LOCAL_LDLIBS += -lpthread -lgdi32  
    42.     LOCAL_C_INCLUDES += /usr/include/w32api/ddk  
    43.   endif  
    44.   ifneq ($(strip $(USE_MINGW)),)  
    45.     # MinGW under Linux case  
    46.     LOCAL_LDLIBS += -lws2_32 -lgdi32  
    47.     USE_SYSDEPS_WIN32 := 1  
    48.     LOCAL_C_INCLUDES += /usr/i586-mingw32msvc/include/ddk  
    49.   endif  
    50.   LOCAL_C_INCLUDES += development/host/windows/usb/api/  
    51. endif  
    52.   
    53. LOCAL_SRC_FILES :=   
    54.     adb.c   
    55.     console.c   
    56.     transport.c   
    57.     transport_local.c   
    58.     transport_usb.c   
    59.     commandline.c   
    60.     adb_client.c   
    61.     adb_auth_host.c   
    62.     sockets.c   
    63.     services.c   
    64.     file_sync_client.c   
    65.     $(EXTRA_SRCS)   
    66.     $(USB_SRCS)   
    67.     usb_vendors.c  
    68.   
    69. LOCAL_C_INCLUDES += external/openssl/include  
    70.   
    71. ifneq ($(USE_SYSDEPS_WIN32),)  
    72.   LOCAL_SRC_FILES += sysdeps_win32.c  
    73. else  
    74.   LOCAL_SRC_FILES += fdevent.c  
    75. endif  
    76.   
    77. LOCAL_CFLAGS += -O2 -g -DADB_HOST=1  -Wall -Wno-unused-parameter  
    78. LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE  
    79. LOCAL_MODULE := adb  
    80. LOCAL_MODULE_TAGS := debug  
    81.   
    82. LOCAL_STATIC_LIBRARIES := libzipfile libunz libcrypto_static $(EXTRA_STATIC_LIBS)  
    83. ifeq ($(USE_SYSDEPS_WIN32),)  
    84.     LOCAL_STATIC_LIBRARIES += libcutils  
    85. endif  
    86.   
    87. include $(BUILD_HOST_EXECUTABLE)  
    88.   
    89. $(call dist-for-goals,dist_files sdk,$(LOCAL_BUILT_MODULE))  
    90.   
    91. ifeq ($(HOST_OS),windows)  
    92. $(LOCAL_INSTALLED_MODULE):   
    93.     $(HOST_OUT_EXECUTABLES)/AdbWinApi.dll   
    94.     $(HOST_OUT_EXECUTABLES)/AdbWinUsbApi.dll  
    95. endif  
    96.   
    97.   
    98. # adbd device daemon  
    99. # =========================================================  
    100.   
    101. include $(CLEAR_VARS)  
    102.   
    103. LOCAL_SRC_FILES :=   
    104.     adb.c   
    105.     backup_service.c   
    106.     fdevent.c   
    107.     transport.c   
    108.     transport_local.c   
    109.     transport_usb.c   
    110.     adb_auth_client.c   
    111.     sockets.c   
    112.     services.c   
    113.     file_sync_service.c   
    114.     jdwp_service.c   
    115.     framebuffer_service.c   
    116.     remount_service.c   
    117.     usb_linux_client.c   
    118.     log_service.c  
    119.   
    120. LOCAL_CFLAGS := -O2 -g -DADB_HOST=0 -Wall -Wno-unused-parameter  
    121. LOCAL_CFLAGS += -D_XOPEN_SOURCE -D_GNU_SOURCE  
    122.   
    123. ifneq (,$(filter userdebug eng,$(TARGET_BUILD_VARIANT)))  
    124. LOCAL_CFLAGS += -DALLOW_ADBD_ROOT=1  
    125. endif  
    126.   
    127. LOCAL_MODULE := adbd  
    128.   
    129. LOCAL_FORCE_STATIC_EXECUTABLE := true  
    130. LOCAL_MODULE_PATH := $(TARGET_ROOT_OUT_SBIN)  
    131. LOCAL_UNSTRIPPED_PATH := $(TARGET_ROOT_OUT_SBIN_UNSTRIPPED)  
    132.   
    133. LOCAL_STATIC_LIBRARIES := liblog libcutils libc libmincrypt  
    134. include $(BUILD_EXECUTABLE)  
    135.   
    136.   
    137. # adb host tool for device-as-host  
    138. # =========================================================  
    139. ifneq ($(SDK_ONLY),true)  
    140. include $(CLEAR_VARS)  
    141.   
    142. LOCAL_LDLIBS := -lrt -ldl -lpthread  
    143.   
    144. LOCAL_SRC_FILES :=   
    145.     adb.c   
    146.     console.c   
    147.     transport.c   
    148.     transport_local.c   
    149.     transport_usb.c   
    150.     commandline.c   
    151.     adb_client.c   
    152.     adb_auth_host.c   
    153.     sockets.c   
    154.     services.c   
    155.     file_sync_client.c   
    156.     get_my_path_linux.c   
    157.     usb_linux.c   
    158.     usb_vendors.c   
    159.     fdevent.c  
    160.   
    161. LOCAL_CFLAGS :=   
    162.     -O2   
    163.     -g   
    164.     -DADB_HOST=1   
    165.     -DADB_HOST_ON_TARGET=1   
    166.     -Wall   
    167.     -Wno-unused-parameter   
    168.     -D_XOPEN_SOURCE   
    169.     -D_GNU_SOURCE  
    170.   
    171. LOCAL_C_INCLUDES += external/openssl/include  
    172.   
    173. LOCAL_MODULE := adb  
    174.   
    175. LOCAL_STATIC_LIBRARIES := libzipfile libunz libcutils  
    176.   
    177. LOCAL_SHARED_LIBRARIES := libcrypto  
    178.   
    179. include $(BUILD_EXECUTABLE)  
    180. endif  


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

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

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

    [cpp] view plain copy
    1. int main(int argc, char **argv)  
    2. {  
    3. #if ADB_HOST  
    4.     adb_sysdeps_init();  
    5.     adb_trace_init();  
    6.     D("Handling commandline() ");  
    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.     }  
    16.   
    17.     start_device_log();  
    18.     D("Handling main() ");  
    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：

    [cpp] view plain copy
    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()的源代码如下：

    [cpp] view plain copy
    1. int adb_main(int is_daemon, int server_port)  
    2. {  
    3. #if !ADB_HOST  
    4.     int port;  
    5.     char value[PROPERTY_VALUE_MAX];  
    6.   
    7.     umask(000);  
    8. #endif  
    9.   
    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  
    17.   
    18.     init_transport_registration();  
    19.   
    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();  
    26.   
    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();  
    37.   
    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. ");  
    46.     }  
    47.   
    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;  
    53.   
    54.         if (prctl(PR_SET_KEEPCAPS, 1, 0, 0, 0) != 0) {  
    55.             exit(1);  
    56.         }  
    57.   
    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.         }  
    76.   
    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.         }  
    84.   
    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);  
    91.   
    92.         D("Local port disabled ");  
    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.     }  
    100.   
    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.     }  
    107.   
    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 ", 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.     }  
    123.   
    124.     D("adb_main(): pre init_jdwp() ");  
    125.     init_jdwp();  
    126.     D("adb_main(): post init_jdwp() ");  
    127. #endif  
    128.   
    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 ", 3, &count, NULL );  
    135. #elif defined(HAVE_FORKEXEC)  
    136.         fprintf(stderr, "OK ");  
    137. #endif  
    138.         start_logging();  
    139.     }  
    140.     D("Event loop starting ");  
    141.   
    142.     fdevent_loop();  
    143.   
    144.     usb_cleanup();  
    145.   
    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)：

    [cpp] view plain copy
    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;  
    13.   
    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] == '') {  
    22.         gProductOutPath = NULL;  
    23.     }  
    24.     // TODO: also try TARGET_PRODUCT/TARGET_DEVICE as a hint  
    25.   
    26.     serial = getenv("ANDROID_SERIAL");  
    27.   
    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" ",  
    36.                     server_port_str);  
    37.             return usage();  
    38.         }  
    39.     }  
    40.   
    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] == '') {  
    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" ",  
    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] != '') 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.     }  
    88.   
    89.     adb_set_transport(ttype, serial);  
    90.     adb_set_tcp_specifics(server_port);  
    91.   
    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 * ");  
    100.         }  
    101.         return r;  
    102.     }  
    103.   
    104. top:  
    105.     if(argc == 0) {  
    106.         return usage();  
    107.     }  
    108.   
    109.     /* adb_connect() commands */  
    110.   
    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] ");  
    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  ");  
    126.             printf("%s ", tmp);  
    127.             return 0;  
    128.         } else {  
    129.             return 1;  
    130.         }  
    131.     }  
    132.   
    133.     if(!strcmp(argv[0], "connect")) {  
    134.         char *tmp;  
    135.         if (argc != 2) {  
    136.             fprintf(stderr, "Usage: adb connect <host>[:<port>] ");  
    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 ", tmp);  
    143.             return 0;  
    144.         } else {  
    145.             return 1;  
    146.         }  
    147.     }  
    148.   
    149.     if(!strcmp(argv[0], "disconnect")) {  
    150.         char *tmp;  
    151.         if (argc > 2) {  
    152.             fprintf(stderr, "Usage: adb disconnect [<host>[:<port>]] ");  
    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 ", tmp);  
    163.             return 0;  
    164.         } else {  
    165.             return 1;  
    166.         }  
    167.     }  
    168.   
    169.     if (!strcmp(argv[0], "emu")) {  
    170.         return adb_send_emulator_command(argc, argv);  
    171.     }  
    172.   
    173.     if(!strcmp(argv[0], "shell") || !strcmp(argv[0], "hell")) {  
    174.         int r;  
    175.         int fd;  
    176.   
    177.         char h = (argv[0][0] == 'h');  
    178.   
    179.         if (h) {  
    180.             printf("x1b[41;33m");  
    181.             fflush(stdout);  
    182.         }  
    183.   
    184.         if(argc < 2) {  
    185.             D("starting interactive shell ");  
    186.             r = interactive_shell();  
    187.             if (h) {  
    188.                 printf("x1b[0m");  
    189.                 fflush(stdout);  
    190.             }  
    191.             return r;  
    192.         }  
    193.   
    194.         snprintf(buf, sizeof buf, "shell:%s", argv[1]);  
    195.         argc -= 2;  
    196.         argv += 2;  
    197.         while(argc-- > 0) {  
    198.             strcat(buf, " ");  
    199.   
    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.         }  
    208.   
    209.         for(;;) {  
    210.             D("interactive shell loop. buff=%s ", buf);  
    211.             fd = adb_connect(buf);  
    212.             if(fd >= 0) {  
    213.                 D("about to read_and_dump(fd=%d) ", fd);  
    214.                 read_and_dump(fd);  
    215.                 D("read_and_dump() done. ");  
    216.                 adb_close(fd);  
    217.                 r = 0;  
    218.             } else {  
    219.                 fprintf(stderr,"error: %s ", adb_error());  
    220.                 r = -1;  
    221.             }  
    222.   
    223.             if(persist) {  
    224.                 fprintf(stderr," - waiting for device - ");  
    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 ", r);  
    233.                 return r;  
    234.             }  
    235.         }  
    236.     }  
    237.   
    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 * ");  
    243.             return 1;  
    244.         }  
    245.         return 0;  
    246.     }  
    247.   
    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.     }  
    256.   
    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 ", adb_error());  
    275.         return 1;  
    276.     }  
    277.   
    278.     if(!strcmp(argv[0], "bugreport")) {  
    279.         if (argc != 1) return usage();  
    280.         do_cmd(ttype, serial, "shell", "bugreport", 0);  
    281.         return 0;  
    282.     }  
    283.   
    284.     /* adb_command() wrapper commands */  
    285.   
    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.         }  
    297.   
    298.         format_host_command(buf, sizeof buf, service, ttype, serial);  
    299.   
    300.         if (adb_command(buf)) {  
    301.             D("failure: %s * ",adb_error());  
    302.             fprintf(stderr,"error: %s ", adb_error());  
    303.             return 1;  
    304.         }  
    305.   
    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.     }  
    316.   
    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 ", adb_error());  
    330.             return 1;  
    331.         }  
    332.         return 0;  
    333.     }  
    334.   
    335.     /* do_sync_*() commands */  
    336.   
    337.     if(!strcmp(argv[0], "ls")) {  
    338.         if(argc != 2) return usage();  
    339.         return do_sync_ls(argv[1]);  
    340.     }  
    341.   
    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.     }  
    346.   
    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.     }  
    356.   
    357.     if(!strcmp(argv[0], "install")) {  
    358.         if (argc < 2) return usage();  
    359.         return install_app(ttype, serial, argc, argv);  
    360.     }  
    361.   
    362.     if(!strcmp(argv[0], "uninstall")) {  
    363.         if (argc < 2) return usage();  
    364.         return uninstall_app(ttype, serial, argc, argv);  
    365.     }  
    366.   
    367.     if(!strcmp(argv[0], "sync")) {  
    368.         char *srcarg, *android_srcpath, *data_srcpath;  
    369.         int listonly = 0;  
    370.   
    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();  
    390.   
    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);  
    395.   
    396.         free(android_srcpath);  
    397.         free(data_srcpath);  
    398.         return ret;  
    399.     }  
    400.   
    401.     /* passthrough commands */  
    402.   
    403.     if(!strcmp(argv[0],"get-state") ||  
    404.         !strcmp(argv[0],"get-serialno") ||  
    405.         !strcmp(argv[0],"get-devpath"))  
    406.     {  
    407.         char *tmp;  
    408.   
    409.         format_host_command(buf, sizeof buf, argv[0], ttype, serial);  
    410.         tmp = adb_query(buf);  
    411.         if(tmp) {  
    412.             printf("%s ", tmp);  
    413.             return 0;  
    414.         } else {  
    415.             return 1;  
    416.         }  
    417.     }  
    418.   
    419.     /* other commands */  
    420.   
    421.     if(!strcmp(argv[0],"status-window")) {  
    422.         status_window(ttype, serial);  
    423.         return 0;  
    424.     }  
    425.   
    426.     if(!strcmp(argv[0],"logcat") || !strcmp(argv[0],"lolcat") || !strcmp(argv[0],"longcat")) {  
    427.         return logcat(ttype, serial, argc, argv);  
    428.     }  
    429.   
    430.     if(!strcmp(argv[0],"ppp")) {  
    431.         return ppp(argc, argv);  
    432.     }  
    433.   
    434.     if (!strcmp(argv[0], "start-server")) {  
    435.         return adb_connect("host:start-server");  
    436.     }  
    437.   
    438.     if (!strcmp(argv[0], "backup")) {  
    439.         return backup(argc, argv);  
    440.     }  
    441.   
    442.     if (!strcmp(argv[0], "restore")) {  
    443.         return restore(argc, argv);  
    444.     }  
    445.   
    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 ", adb_error());  
    454.             return -1;  
    455.         }  
    456.     }  
    457.   
    458.     /* "adb /?" is a common idiom under Windows */  
    459.     if(!strcmp(argv[0], "help") || !strcmp(argv[0], "/?")) {  
    460.         help();  
    461.         return 0;  
    462.     }  
    463.   
    464.     if(!strcmp(argv[0], "version")) {  
    465.         version(stdout);  
    466.         return 0;  
    467.     }  
    468.   
    469.     usage();  
    470.     return 1;  
    471. }  


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

    －－－－－－－－－－

    以上就是main()函数的执行过程，后续将分析其中的细节内容。
  • 相关阅读:
    正则表达式
    数组去重
    [WOJ4354] 蜀石经
    [NOI2002] 银河英雄传说
    [洛谷P2186] 小Z的栈函数
    [洛谷P2756]飞行员配对方案问题
    [洛谷P2071] 座位安排
    [洛谷P2417]课程
    [洛谷P1640] [SCOI2010]连续攻击游戏
    [洛谷P3512 [POI2010]PIL-Pilots]
  • 原文地址：https://www.cnblogs.com/wanghuaijun/p/8490343.html
Copyright © 2011-2022 走看看