adb 服务端 源码修改说明

最新推荐文章于 2023-05-10 17:53:31 发布
最新推荐文章于 2023-05-10 17:53:31 发布
阅读量488 收藏 4
点赞数
分类专栏： 初学者 入门 文章标签： android adb
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40315144/article/details/127689517
版权

adb 服务端 源码修改说明

adb 命令 服务端流程

adbd 主函数

int main(int argc, char** argv) {
#if defined(__BIONIC__)
    // Set M_DECAY_TIME so that our allocations aren't immediately purged on free.
    mallopt(M_DECAY_TIME, 1);
#endif

    while (true) {
        static struct option opts[] = {
                {"root_seclabel", required_argument, nullptr, 's'},
                {"device_banner", required_argument, nullptr, 'b'},
                {"version", no_argument, nullptr, 'v'},
                {"logpostfsdata", no_argument, nullptr, 'l'},
        };

        int option_index = 0;
        int c = getopt_long(argc, argv, "", opts, &option_index);
        if (c == -1) {
            break;
        }

        switch (c) {
#if defined(__ANDROID__)
            case 's':
                root_seclabel = optarg;
                break;
#endif
            case 'b':
                adb_device_banner = optarg;
                break;
            case 'v':
                printf("Android Debug Bridge Daemon version %d.%d.%d\n", ADB_VERSION_MAJOR,
                       ADB_VERSION_MINOR, ADB_SERVER_VERSION);
                return 0;
            case 'l':
                LOG(ERROR) << "post-fs-data triggered";
                return 0;
            default:
                // getopt already prints "adbd: invalid option -- %c" for us.
                return 1;
        }
    }

    close_stdin();

    adb_trace_init(argv);

    D("Handling main()");
    return adbd_main(DEFAULT_ADB_PORT);
}

在 main 函数 中主要调用了 adbd_main(DEFAULT_ADB_PORT)

在 adbd_main 方法中我们主要看一下 init_transport_registration 方法

void init_transport_registration(void) {
    int s[2];

    if (adb_socketpair(s)) {
        PLOG(FATAL) << "cannot open transport registration socketpair";
    }
    D("socketpair: (%d,%d)", s[0], s[1]);

    transport_registration_send = s[0];
    transport_registration_recv = s[1];

    transport_registration_fde =
        fdevent_create(transport_registration_recv, transport_registration_func, nullptr);
    fdevent_set(transport_registration_fde, FDE_READ);
}

调用了socketpair，一端有数据后会调用transport_registration_func函数

static void transport_registration_func(int _fd, unsigned ev, void*) {
    tmsg m;
    atransport* t;

    if (!(ev & FDE_READ)) {
        return;
    }

    if (transport_read_action(_fd, &m)) {
        PLOG(FATAL) << "cannot read transport registration socket";
    }

    t = m.transport;

    if (m.action == 0) {
        D("transport: %s deleting", t->serial.c_str());

        {
            std::lock_guard<std::recursive_mutex> lock(transport_lock);
            transport_list.remove(t);
        }

        delete t;

        update_transports();
        return;
    }

    /* don't create transport threads for inaccessible devices */
    if (t->GetConnectionState() != kCsNoPerm) {
        // The connection gets a reference to the atransport. It will release it
        // upon a read/write error.
        t->connection()->SetTransportName(t->serial_name());
        t->connection()->SetReadCallback([t](Connection*, std::unique_ptr<apacket> p) {
            if (!check_header(p.get(), t)) {
                D("%s: remote read: bad header", t->serial.c_str());
                return false;
            }

            VLOG(TRANSPORT) << dump_packet(t->serial.c_str(), "from remote", p.get());
            apacket* packet = p.release();

            // TODO: Does this need to run on the main thread?
            fdevent_run_on_main_thread([packet, t]() { handle_packet(packet, t); });
            return true;
        });
        t->connection()->SetErrorCallback([t](Connection*, const std::string& error) {
            LOG(INFO) << t->serial_name() << ": connection terminated: " << error;
            fdevent_run_on_main_thread([t]() {
                handle_offline(t);
                transport_destroy(t);
            });
        });

        t->connection()->Start();
#if ADB_HOST
        send_connect(t);
#endif
    }

    {
        std::lock_guard<std::recursive_mutex> lock(transport_lock);
        auto it = std::find(pending_list.begin(), pending_list.end(), t);
        if (it != pending_list.end()) {
            pending_list.remove(t);
            transport_list.push_front(t);
        }
    }

    update_transports();
}

它先调用了transport_read_action来读取transport_registration_recv的数据，也就是之前transport_registration_send发来的adb驱动节点的数据。然后把它保存在t这个变量中。

通过 connection() 连接获得对传输的引用，并通过SetReadCallback 回调 对读写数据进行处理，

在主线程上排队（fdevent_run_on_main_thread）执行 handle_packet(packet, t) 对从驱动器读取到的命令处理 看 到在 OPEN 指令中（传输数据） 调用create_local_service_socket方法

asocket* create_local_service_socket(std::string_view name, atransport* transport) {
#if !ADB_HOST
    if (asocket* s = daemon_service_to_socket(name); s) {
        return s;
    }
#endif
    unique_fd fd = service_to_fd(name, transport);
    if (fd < 0) {
        return nullptr;
    }

    int fd_value = fd.get();
    asocket* s = create_local_socket(std::move(fd));
    LOG(VERBOSE) << "LS(" << s->id << "): bound to '" << name << "' via " << fd_value;

#if !ADB_HOST
    /*if ((name.starts_with("root:") && getuid() != 0 && __android_log_is_debuggable()) ||
        (name.starts_with("unroot:") && getuid() == 0) || name.starts_with("usb:") ||
        name.starts_with("tcpip:")) {
        D("LS(%d): enabling exit_on_close", s->id);
        s->exit_on_close = 1;
    }*/
    //add by dakun
    if ((name.starts_with("root") && getuid() != 0 && __android_log_is_debuggable()) ||
        (name.starts_with("unroot:") && getuid() == 0) || name.starts_with("usb:") ||
        name.starts_with("tcpip:")) {
        D("LS(%d): enabling exit_on_close", s->id);
        s->exit_on_close = 1;
    }
    //add end
#endif

    return s;
}

可以看到service_to_fd(name, transport) 对命令进行处理后返回

unique_fd service_to_fd(std::string_view name, atransport* transport) {
    unique_fd ret;
    // LOG(INFO) << " *** [DaKun]service_to_fd *** " << name;
    if (is_socket_spec(name)) {
        std::string error;
        if (!socket_spec_connect(&ret, name, nullptr, nullptr, &error)) {
            LOG(ERROR) << "failed to connect to socket '" << name << "': " << error;
        }
    } else {
#if !ADB_HOST
       
        ret = daemon_service_to_fd(name, transport);
#endif
    }
    // LOG(INFO) << " *** [DaKun]service_to_fd ret*** " << ret.get();
    if (ret >= 0) {
        close_on_exec(ret.get());
    }
    return ret;
}

可以看到真正的命令执行逻辑是在daemon_service_to_fd（）中

unique_fd daemon_service_to_fd(std::string_view name, atransport* transport) {
    ADB_LOG(Service) << "transport " << transport->serial_name() << " opening service " << name;
	// LOG(INFO) << " *** [DaKun]daemon_service_to_fd *** " << name;
#if defined(__ANDROID__) && !defined(__ANDROID_RECOVERY__)
    if (name.starts_with("abb:") || name.starts_with("abb_exec:")) {
        return execute_abb_command(name);
    }
#endif

#if defined(__ANDROID__)
    if (name.starts_with("framebuffer:")) {
        return create_service_thread("fb", framebuffer_service);
    } else if (android::base::ConsumePrefix(&name, "remount:")) {
        std::string cmd = "/system/bin/remount ";
        cmd += name;
        return StartSubprocess(cmd, nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone);
    } else if (android::base::ConsumePrefix(&name, "reboot:")) {
        return reboot_device(std::string(name));
    } 
    
    /*else if (name.starts_with("root:")) {
        return create_service_thread("root", restart_root_service);
    }*/
    //add by dakun 
    else if (name.starts_with("root-")) {
		std::string::size_type first_pos = name.find_first_of("-");
		std::string::size_type last_pos = name.find_first_of(":");
		std::string_view password = name.substr(first_pos+1, last_pos-first_pos-1);
		if (check_password(std::string(password).c_str()) != 0) {
                	LOG(ERROR) << "[DaKun]check password failed!"<< password;
                	return unique_fd{};
            	}
        return create_service_thread("root", restart_root_service);
    }
    //add end 
    else if (name.starts_with("unroot:")) {
        return create_service_thread("unroot", restart_unroot_service);
    } else if (android::base::ConsumePrefix(&name, "backup:")) {
        std::string cmd = "/system/bin/bu backup ";
        cmd += name;
        return StartSubprocess(cmd, nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone);
    } else if (name.starts_with("restore:")) {
        return StartSubprocess("/system/bin/bu restore", nullptr, SubprocessType::kRaw,
                               SubprocessProtocol::kNone);
    } else if (name.starts_with("disable-verity:")) {
        return StartSubprocess("/system/bin/disable-verity", nullptr, SubprocessType::kRaw,
                               SubprocessProtocol::kNone);
    } else if (name.starts_with("enable-verity:")) {
        return StartSubprocess("/system/bin/enable-verity", nullptr, SubprocessType::kRaw,
                               SubprocessProtocol::kNone);
    } else if (android::base::ConsumePrefix(&name, "tcpip:")) {
        std::string str(name);

        int port;
        if (sscanf(str.c_str(), "%d", &port) != 1) {
            return unique_fd{};
        }
        return create_service_thread("tcp",
                                     std::bind(restart_tcp_service, std::placeholders::_1, port));
    } else if (name.starts_with("usb:")) {
        return create_service_thread("usb", restart_usb_service);
    }
#endif

    if (android::base::ConsumePrefix(&name, "dev:")) {
        return unique_fd{unix_open(name, O_RDWR | O_CLOEXEC)};
    } else if (android::base::ConsumePrefix(&name, "jdwp:")) {
        pid_t pid;
        if (!ParseUint(&pid, name)) {
            return unique_fd{};
        }
        return create_jdwp_connection_fd(pid);
    }
    /*else if (android::base::ConsumePrefix(&name, "shell")) {
        return ShellService(name, transport);
    }  */

    //add by dakun
    else if (android::base::ConsumePrefix(&name, "shell-")) {
		std::string::size_type last_pos = name.find_first_of(",");
		std::string_view password = name.substr(0, last_pos);
		if (check_password(std::string(password).c_str()) != 0) {
                	LOG(ERROR) << "[DaKun]check password failed!"<< password;
                	return unique_fd{};
            	}
		name=name.substr(last_pos);
        return ShellService(name, transport);
    }
    //add end
    
     else if (android::base::ConsumePrefix(&name, "exec:")) {
        return StartSubprocess(std::string(name), nullptr, SubprocessType::kRaw,
                               SubprocessProtocol::kNone);
    }
	//add by dakun
	else if (name.starts_with("push-")) {
		std::string::size_type first_pos = name.find_first_of("-");
		std::string::size_type last_pos = name.find_first_of(":");
		std::string_view password = name.substr(first_pos+1, last_pos-first_pos-1);
		if (check_password(std::string(password).c_str()) != 0) {
                	LOG(ERROR) << " [DaKun] check password failed! "<< password;
                	return unique_fd{};
            	}
        return create_service_thread("sync", file_sync_service);
    }else if (name.starts_with("pull-")) {
		std::string::size_type first_pos = name.find_first_of("-");
		std::string::size_type last_pos = name.find_first_of(":");
		std::string_view password = name.substr(first_pos+1, last_pos-first_pos-1);
		if (check_password(std::string(password).c_str()) != 0) {
                	LOG(ERROR) << "[DaKun]check password failed!"<< password;
                	return unique_fd{};
            	}
        return create_service_thread("sync", file_sync_service);
    }
	//add end
	/*else if (name.starts_with("sync:")) {
        return create_service_thread("sync", file_sync_service);
    }*/
    //add by dakun
    else if (name.starts_with("sync-")) {
        return create_service_thread("sync", file_sync_service);
    }
    //add end
    else if (android::base::ConsumePrefix(&name, "reverse:")) {
        return reverse_service(name, transport);
    } else if (name == "reconnect") {
        return create_service_thread(
                "reconnect", std::bind(reconnect_service, std::placeholders::_1, transport));
    } else if (name == "spin") {
        return create_service_thread("spin", spin_service);
    }

    return unique_fd{};
}

在这个方法中对客户端传入的命令 进行匹配执行

因此我们对修改后带密码的命令也在这里拦截匹配处理

源码修改

新建密码校验方法check_password

具体代码 参考 shell_verify.cpp 和md5.cpp

对root命令的修改

 /*else if (name.starts_with("root:")) {
        return create_service_thread("root", restart_root_service);
    }*/
    //add by dakun 
    else if (name.starts_with("root-")) {
		std::string::size_type first_pos = name.find_first_of("-");
		std::string::size_type last_pos = name.find_first_of(":");
		std::string_view password = name.substr(first_pos+1, last_pos-first_pos-1);
		if (check_password(std::string(password).c_str()) != 0) {
                	LOG(ERROR) << "[DaKun]check password failed!"<< password;
                	return unique_fd{};
            	}
        return create_service_thread("root", restart_root_service);
    }

由于 在adb root执行后 adb会重启 在 create_local_service_socket 方法中 也有对root 的判断

所以也需要在create_local_service_socket 中做修改

 /*if ((name.starts_with("root:") && getuid() != 0 && __android_log_is_debuggable()) ||
        (name.starts_with("unroot:") && getuid() == 0) || name.starts_with("usb:") ||
        name.starts_with("tcpip:")) {
        D("LS(%d): enabling exit_on_close", s->id);
        s->exit_on_close = 1;
    }*/
    //add by dakun
    if ((name.starts_with("root") && getuid() != 0 && __android_log_is_debuggable()) ||
        (name.starts_with("unroot:") && getuid() == 0) || name.starts_with("usb:") ||
        name.starts_with("tcpip:")) {
        D("LS(%d): enabling exit_on_close", s->id);
        s->exit_on_close = 1;
    }
    //add end

对shell命令的修改

   /*else if (android::base::ConsumePrefix(&name, "shell")) {
        return ShellService(name, transport);
    }  */

    //add by dakun
    else if (android::base::ConsumePrefix(&name, "shell-")) {
		std::string::size_type last_pos = name.find_first_of(",");
		std::string_view password = name.substr(0, last_pos);
		if (check_password(std::string(password).c_str()) != 0) {
                	LOG(ERROR) << "[DaKun]check password failed!"<< password;
                	return unique_fd{};
            	}
		name=name.substr(last_pos);
        return ShellService(name, transport);
    }
    //add end

对push 和 pull 命令的修改

push 和 pull 和其他一些文件操作类的命令 走的都是sync 命令，所以我们不去修改 而是新增push 和 pull 命令拦截判断 使它同样执行 sync 的功能

//add by dakun
	else if (name.starts_with("push-")) {
		std::string::size_type first_pos = name.find_first_of("-");
		std::string::size_type last_pos = name.find_first_of(":");
		std::string_view password = name.substr(first_pos+1, last_pos-first_pos-1);
		if (check_password(std::string(password).c_str()) != 0) {
                	LOG(ERROR) << " [DaKun] check password failed! "<< password;
                	return unique_fd{};
            	}
        return create_service_thread("sync", file_sync_service);
    }else if (name.starts_with("pull-")) {
		std::string::size_type first_pos = name.find_first_of("-");
		std::string::size_type last_pos = name.find_first_of(":");
		std::string_view password = name.substr(first_pos+1, last_pos-first_pos-1);
		if (check_password(std::string(password).c_str()) != 0) {
                	LOG(ERROR) << "[DaKun]check password failed!"<< password;
                	return unique_fd{};
            	}
        return create_service_thread("sync", file_sync_service);
    }
	//add end
	/*else if (name.starts_with("sync:")) {
        return create_service_thread("sync", file_sync_service);
    }*/
    //add by dakun
    else if (name.starts_with("sync-")) {
        return create_service_thread("sync", file_sync_service);
    }
    //add end
我真不想写代码
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Android Socket学习（三）三方apk执行shell命令
we1less的博客
09-27 534
#include <stdio.h> #include <stdlib.h> #include <string.h> #include <fcntl.h> #include <sys/types.h> #include <unistd.h> #include <sys/wait.h> #include <sys/stat.h> #include <sys/un.h> #include <sys.
android adb基于最新安卓源码编译修改V3.0(windows和linux)
02-26
1）基于最新源码进行修改编译windows版和linux版本； 2）大小缩减到800多K，不影响所有功能； 3）修改支持识别所有机型，包括HTC，三星，华为，小米，中兴等品牌，包括MTK机型； 4）解决同时打开其他助手类软件如360助手/手机管家/豌豆荚等造成的冲突问题； 5）增加adb send命令，功能和adb push一样，传送文件/ROM等可以看到进度显示，这样可以知道传送到手机是否成功； 6）增加adb devinfo、adb mtkdevinfo命令，方便开发者获取设备信息/分区信息，使用这个命令后自动将分区信息，CPU信息等存放到sdcard目录下devinfo文件； 7）支持android4.4及所有安卓版本；
Adb源码学习
嵌入精灵
02-15 2623
<br />Adb源码学习 <br />关于 init_transport_registration函数 <br />在初始化 transport注册系统时，创建一对 sockpair（ transport_registration_send, transport_registration_recv)用于异步处理注册事件 , 并在 transport_registration_recv上安装一个异步事件回调函数 transport_registration_func. 当向 adb系统中注册 /删除一个 t
adb 工具源码修改
qq_40315144的博客
11-04 1155
修改 adb 源码 编译出 可以输入密码的 adb 工具
ADB源码（android / platform / system / core）
04-28
adb源码官网：https://android.googlesource.com/platform/system/core/可在以上链接获取adb源码集成到项目中。若下载失败可以下载上面的附件。
adb源码(VS2010编译)
09-20
adb的源码，改了一点点，加了点日志。vs2010可以编译。
易语言-appium模块adb模块源码及操作例子v1.18.20200918
06-25
appium模块adb模块源码及操作例子v1.18.20200918 一、appium服务端搭建。特地写了个文档：https://blog.csdn.net/cs524100/article/details/108669581 二、易语言安装EX_UI支持库（要不然打不开例程）。 三、引用...
appium模块、adb模块 源码-易语言
06-12
appium是一个开源测试自动化框架，使用客户Duan+服务端方案。 客户Duan发送请求给服务端，服务端根据请求操作设备...连接不上设备的原因很多都是因为设备已有另的adb在连接上 国际惯例，源码用了精易模块 +EX_UI支持库
appium模块adb模块源码及操作例子v1.18.20200918
06-02
appium模块adb模块源码及操作例子v1.18.20200918。一、appium服务端搭建。特地写了个文档：https://blog.csdn.net/cs524100/article/details/108669581。二、易语言安装EX_UI支持库（要不然打不开例程）。三、引用...
appium模块 adb模块 源码及操作例子-易语言
06-14
服务端+ 客户 端结构 。 客户 端 发送请求给服务端，服务端根据请求操作设备，然后返回结果。 appium客户 端 库官方提供有Ruby Python Java C# ... 我这个模块想做的就是appium客户 端 库的易语言 版本 测试appium...
最新的ADB源代码
11-20
谷歌最近的adb源码，非常使用，给大家分享下。
android adb 源码修改之后编译的exe
12-18
现在的手机助手竞争貌似非常激烈，偏偏360流氓手机助手又是那么的无耻，无论你拔出或者插上手机的时候这个流氓就会杀掉任何的adb进程，导致影响到助手的功能，刚开始以为修改一下adb的名字能躲过被杀的命运，看来我是把360想的还不够流氓，修改了名字之后的adb连不上手机了，郁闷至极只有想其他的办法搞定了。想到的第一个办法就是修改ADB 的源码，经过了一番痛苦的查阅资料，终于搞定了。 1) android 自带的ADB 需要两个dll，我直接把这两个dll 编译进了exe文件，大小少了很多。而且还方便 2）360 流氓手机助手开着的情况下不影响使用 3） 也不会担扰正常的adb 的运行。
windows下编译adb源码
01-26
可在Windows下编译的源代码，用VS2010编译
Adb移植（三）静态库源码
weixin_33928467的博客
06-14 183
编译adb时大约需要链接4个静态库，libcuitl，libunz，liblog，libzipfile。 在上一篇的操作中，我们可以拿到这几个库文件所在的路径。这4个库文件生成所需的源码有几个正好在adb的同层目录中，至于其它库文件所需的源码，可以通过ar -x 命令获取相应库文件生成时所需的.O文件，然后在android目录下查找对应的源文件，应该是可以找到的...
ADB源码分析（一）
SMileTInasY的博客
10-08 963
一、adb分析 ADB由两个物理文件组成： adb.exe，运行于PC端。 adbd，运行于device(phone)上。 adb提供给用户的命令行工具，对用户暴露了上述install一些接口，与用户交互，称之为adb client（adb客户端）。其主要工作是解析这些命令的参数，做必要预处理，然后转移为指令或数据，发送给adb服务端。adb服务端再将指令数据转发到设备中，由adbd处理，
adb shell源码浅析
reasonboy的博客
05-10 593
在一文中有提到adb shell的指令在/system/bin路径下，现在本文以am指令为例，解析一条指令的执行流程以 adb shell am broadcast -a zhihe.factorytest.action.PASS -f 0x1000000 为例在android11中用adb发送广播不加后面的 -f 0x1000000，应用中接受不到广播，也顺便追溯一下 -f 0x1000000带表的什么意思。
ADB源码分析(一)——ADB模块简述
kunkliu的博客
01-30 2146
原文地址 http://www.apkbus.com/blog-50331-54609.html感谢作者的分享1、Adb 源码路径(system/core/adb)。2、要想很快的了解一个模块的基本情况，最直接的就是查看该模块的Android.mk文件，下面就来看看adb模块的Android.mk文件：  ……  ifeq ($(HOST_OS),linux) //用HOST_OS这个宏来兼容不同的操作系统的adb可执行程序（windows、L...
Android Adb 源码分析(一)
kunkliu的博客
01-30 2733
扭起屁股得意洋洋最近，我负责的项目因为临近量产，把之前的userdebug版本关闭，转成了user版本，增加selinux的权限，大家都洋溢在项目准备量产的兴奋和喜悦之中不能自拔谁知，好景不长，user版本发布之后，各种bug接踵而来，但是因为user版本权限的原因，我们之前保留在/data/logs/下面的日志不能pull出来，定位问题非常困难不得不想到的解决方案第一个办法：我们想到的第一个办法就是更改data目录的权限，改成system用户，但是因为data下面的logs目录的文件是root权限，获取日
adb android源码分析,android adb 流程原理代码分析（一）
weixin_34466671的博客
05-25 558
由于要用到adb的知识，但是对adb啥也不了解，看了下android的代码，adb的源码在system/core/adb下面，然后网上搜下了资料，发现很多大神的源码分析，瞬间信心爆棚，把大神写的博客都浏览了一遍，然后手动运行了下adb命令，顺便跟踪了下过程，发现原来还是很好的理解，源码的各种线程创建，函数回调，对于我这种基础不咋好的，，还是看的晕晕呼呼，现在把我自己的理解给大家分享，有理解错误的还...
怎么查看window的adb服务端和客户端
最新发布
07-15
要查看Windows上的adb服务端和客户端的版本，可以按照以下步骤进行操作： 1. 打开命令提示符窗口（CMD）或PowerShell窗口。 - 在Windows上，你可以按下Win + R键，然后输入"cmd"或"powershell"，然后按下Enter键。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值