写点什么

动态修改 C 语言函数的实现

  • 2019-12-10
  • 本文字数:9738 字

    阅读完需:约 32 分钟

动态修改 C 语言函数的实现

关注仓库,及时获得更新:iOS-Source-Code-Analyze


Objective-C 作为基于 Runtime 的语言,它有非常强大的动态特性,可以在运行期间自省、进行方法调剂、为类增加属性、修改消息转发链路,在代码运行期间通过 Runtime 几乎可以修改 Objecitve-C 层的一切类、方法以及属性。


真正绝对意义上的动态语言或者静态语言是不存在的。


C 语言往往会给我们留下不可修改的这一印象;在之前的几年时间里,笔者确实也是这么认为的,然而最近接触到的 fishhook 使我对 C 语言的不可修改有了更加深刻的理解。


在文章中涉及到一个比较重要的概念,就是镜像(image);在 Mach-O 文件系统中,所有的可执行文件、dylib 以及 Bundle 都是镜像。

fishhook 简介

到这里,我们该简单介绍一下今天分享的 fishhook;fishhook 是一个由 facebook 开源的第三方框架,其主要作用就是动态修改 C 语言函数实现


这个框架的代码其实非常的简单,只包含两个文件:fishhook.c 以及 fishhook.h;两个文件所有的代码加起来也不超过 300 行。


不过它的实现原理是非常有意思并且精妙的,我们可以从 fishhook 提供的接口中入手。

从接口开始

fishhook 提供非常简单的两个接口以及一个结构体:


C


struct rebinding {  const char *name;  void *replacement;  void **replaced;};
int rebind_symbols(struct rebinding rebindings[], size_t rebindings_nel);
int rebind_symbols_image(void *header, intptr_t slide, struct rebinding rebindings[], size_t rebindings_nel);
复制代码


其中 rebind_symbols 接收一个 rebindings 数组,也就是重新绑定信息,还有就是 rebindings_nel,也就是 rebindings 的个数。

使用 fishhook 修改 C 函数

使用 fishhook 修改 C 函数很容易,我们使用它提供的几个范例来介绍它的使用方法。


这里要修改的是底层的 open 函数的实现,首先在工程中引入 fishhook.h 头文件,然后声明一个与原函数签名相同的函数指针:


C


#import "fishhook.h"
static int (*origianl_open)(const char *, int, ...);
复制代码


然后重新实现 new_open 函数:


C


int new_open(const char *path, int oflag, ...) {  va_list ap = {0};  mode_t mode = 0;
if ((oflag & O_CREAT) != 0) { // mode only applies to O_CREAT va_start(ap, oflag); mode = va_arg(ap, int); va_end(ap); printf("Calling real open('%s', %d, %d)\n", path, oflag, mode); return orig_open(path, oflag, mode); } else { printf("Calling real open('%s', %d)\n", path, oflag); return orig_open(path, oflag, mode); }}
复制代码


这里调用的 original_open 其实相当于执行原 open;最后,在 main 函数中使用 rebind_symbols 对符号进行重绑定:


C


// 初始化一个 rebinding 结构体struct rebinding open_rebinding = { "open", new_open, (void *)&original_open };
// 将结构体包装成数组,并传入数组的大小,对原符号 open 进行重绑定rebind_symbols((struct rebinding[1]){open_rebinding}, 1);
// 调用 open 函数__unused int fd = open(argv[0], O_RDONLY);
复制代码


在对符号进行重绑定之后,所有调用 open 函数的地方实际上都会执行 new_open 的实现,也就完成了对 open 的修改。



程序运行之后打印了 Calling real open('/Users/apple/Library/Developer/Xcode/DerivedData/Demo-cdnoozusghmqtubdnbzedzdwaagp/Build/Products/Debug/Demo', 0) 说明我们的对 open 函数的修改达到了预期的效果。


整个 main.m 文件中的代码在文章的最后面 main.m

fishhook 的原理以及实现

在介绍 fishhook 具体实现原理之前,有几个非常重要的知识需要我们了解,那就是 dyld、动态链接以及 Mach-O 文件系统。

dyld 与动态链接

dyld 是 the dynamic link editor 的缩写~~(笔者并不知道为什么要这么缩写)~~。至于它的作用,简单一点说,就是负责将各种各样程序需要的镜像加载到程序运行的内存空间中,这个过程发生的时间非常早 — 在 objc 运行时初始化之前


在 dyld 加载镜像时,会执行注册过的回调函数;当然,我们也可以使用下面的方法注册自定义的回调函数,同时也会为所有已经加载的镜像执行回调


C


extern void _dyld_register_func_for_add_image(  void (*func)(const struct mach_header* mh, intptr_t vmaddr_slide));
复制代码


对于每一个已经存在的镜像,当它被动态链接时,都会执行回调 void (*func)(const struct mach_header* mh, intptr_t vmaddr_slide),传入文件的 mach_header 以及一个虚拟内存地址 intptr_t


以一个最简单的 Hello World 程序为例:


C


#include <stdio.h>
int main(int argc, const char * argv[]) { printf("Hello, World!\n"); return 0;}
复制代码


代码中只引用了一个 stdio 库中的函数 printf;我们如果 Build 这段代码,生成可执行文件之后,使用下面的命令 nm


$ nm -nm HelloWorld
复制代码


nm 命令可以查看可执行文件中的符号(对 nm 不熟悉的读者可以在终端中使用 man nm 查看手册):


C


(undefined) external _printf (from libSystem)         (undefined) external dyld_stub_binder (from libSystem)0000000100000000 (__TEXT,__text) [referenced dynamically] external __mh_execute_header0000000100000f50 (__TEXT,__text) external _main
复制代码


在可执行文件中的符号列表中,_printf 这个符号是未定义(undefined)的,换句话说,编译器还不知道这个符号对应什么东西。


但是,如果在文件中加入一个 C 函数 hello_world


C


#include <stdio.h>
void hello_world() { printf("Hello, World!\n");}
int main(int argc, const char * argv[]) { printf("Hello, World!\n"); return 0;}
复制代码


在构建之后,同样使用 nm 查看其中的符号:


C


(undefined) external _printf (from libSystem)         (undefined) external dyld_stub_binder (from libSystem)0000000100000000 (__TEXT,__text) [referenced dynamically] external __mh_execute_header0000000100000f30 (__TEXT,__text) external _hello_world0000000100000f50 (__TEXT,__text) external _main
复制代码


我们的符号 _hello_world 并不是未定义的(undefined),它包含一个内存地址以及 __TEXT 段。也就是说手写的一些函数,在编译之后,其地址并不是未定义的,这一点对于之后分析 fishhook 有所帮助。


使用 nm 打印出的另一个符号 dyld_stub_binder 对应另一个同名函数。dyld_stub_binder 会在目标符号(例如 printf)被调用时,将其链接到指定的动态链接库 libSystem,再执行 printf 的实现(printf 符号位于 __DATA 端中的 lazy 符号表中):



每一个镜像中的 __DATA 端都包含两个与动态链接有关的表,其中一个是 __nl_symbol_ptr,另一个是 __la_symbol_ptr


  • __nl_symbol_ptr 中的 non-lazy 符号是在动态链接库绑定的时候进行加载的

  • __la_symbol_ptr 中的符号会在该符号被第一次调用时,通过 dyld 中的 dyld_stub_binder 过程来进行加载


C


0000000100001010    dq  0x0000000100000f9c  ; XREF=0x1000002f8, imp___stubs__printf
复制代码


地址 0x0000000100000f9c 就是 printf 函数打印字符串实现的位置:



在上述代码调用 printf 时,由于符号是没有被加载的,就会通过 dyld_stub_binder 动态绑定符号。

Mach-O

由于文章中会涉及一些关于 Mach-O 文件格式的知识,所以在这里会简单介绍一下 Mach-O 文件格式的结构。


每一个 Mach-O 文件都会被分为不同的 Segments,比如 __TEXT, __DATA, __LINKEDIT



这也就是 Mach-O 中的 segment_command(32 位与 64 位不同):


C


struct segment_command_64 { /* for 64-bit architectures */  uint32_t  cmd;    /* LC_SEGMENT_64 */  uint32_t  cmdsize;  /* includes sizeof section_64 structs */  char    segname[16];  /* segment name */  uint64_t  vmaddr;    /* memory address of this segment */  uint64_t  vmsize;    /* memory size of this segment */  uint64_t  fileoff;  /* file offset of this segment */  uint64_t  filesize;  /* amount to map from the file */  vm_prot_t  maxprot;  /* maximum VM protection */  vm_prot_t  initprot;  /* initial VM protection */  uint32_t  nsects;    /* number of sections in segment */  uint32_t  flags;    /* flags */};
复制代码


而每一个 segment_command 中又包含了不同的 section


C


struct section_64 { /* for 64-bit architectures */  char    sectname[16];  /* name of this section */  char    segname[16];  /* segment this section goes in */  uint64_t  addr;    /* memory address of this section */  uint64_t  size;    /* size in bytes of this section */  uint32_t  offset;    /* file offset of this section */  uint32_t  align;    /* section alignment (power of 2) */  uint32_t  reloff;    /* file offset of relocation entries */  uint32_t  nreloc;    /* number of relocation entries */  uint32_t  flags;    /* flags (section type and attributes)*/  uint32_t  reserved1;  /* reserved (for offset or index) */  uint32_t  reserved2;  /* reserved (for count or sizeof) */  uint32_t  reserved3;  /* reserved */};
复制代码


你只需要对这几个概念有一个简单的了解,知道它们有怎样的包含关系,当文章中挑出这个名字时,对它不是一无所知就足够了,这里并不会涉及太多相关的知识。

fishhook 的原理

到目前为止,我们对 dyld 以及 Mach-O 有了一个初步的了解,而 fishhook 使用了前面章节提到的 _dyld_register_func_for_add_image 注册了一个回调,在每次加载镜像到程序中执行回调,动态修改 C 函数实现。


在具体分析其源代码之前,先为各位读者详细地介绍它的实现原理:


dyld 通过更新 Mach-O 二进制文件 __DATA 段中的一些指针来绑定 lazy 和 non-lazy 的符号;而 fishhook 先确定某一个符号在 __DATA 段中的位置,然后保存原符号对应的函数指针,并使用新的函数指针覆盖原有符号的函数指针,实现重绑定。


整个过程可以用这么一张图来表示:



原理看起来还是很简单的,其中最复杂的部分就是从二进制文件中寻找某个符号的位置,在 fishhook 的 README 中,有这样一张图:



这张图初看很复杂,不过它演示的是寻找符号的过程,我们根据这张图来分析一下这个过程:


  1. __DATA 段中的 lazy 符号指针表中查找某个符号,获得这个符号的偏移量 1061,然后在每一个 section_64 中查找 reserved1,通过这两个值找到 Indirect Symbol Table 中符号对应的条目

  2. 在 Indirect Symbol Table 找到符号表指针以及对应的索引 16343 之后,就需要访问符号表

  3. 然后通过符号表中的偏移量,获取字符串表中的符号 _close

fishhook 的实现

上面梳理了寻找符号的过程,现在,我们终于要开始分析 fishhook 的源代码,看它是如何一步一步替换原有函数实现的。


对实现的分析会 rebind_symbols 函数为入口,首先看一下函数的调用栈:


C


int rebind_symbols(struct rebinding rebindings[], size_t rebindings_nel);└── extern void _dyld_register_func_for_add_image(void (*func)(const struct mach_header* mh, intptr_t vmaddr_slide));
static void _rebind_symbols_for_image(const struct mach_header *header, intptr_t slide)└── static void rebind_symbols_for_image(struct rebindings_entry *rebindings, const struct mach_header *header, intptr_t slide) └── static void perform_rebinding_with_section(struct rebindings_entry *rebindings, section_t *section, intptr_t slide, nlist_t *symtab, char *strtab, uint32_t *indirect_symtab)
复制代码


其实函数调用栈非常简单,因为整个库中也没有几个函数,rebind_symbols 作为接口,其主要作用就是注册一个函数并在镜像加载时回调:


C


int rebind_symbols(struct rebinding rebindings[], size_t rebindings_nel) {  int retval = prepend_rebindings(&_rebindings_head, rebindings, rebindings_nel);  if (retval < 0) return retval;
if (!_rebindings_head->next) { _dyld_register_func_for_add_image(_rebind_symbols_for_image); } else { uint32_t c = _dyld_image_count(); for (uint32_t i = 0; i < c; i++) { _rebind_symbols_for_image(_dyld_get_image_header(i), _dyld_get_image_vmaddr_slide(i)); } } return retval;}
复制代码


rebind_symbols 最开始执行时,会先调用一个 prepend_rebindings 的函数,将整个 rebindings 数组添加到 _rebindings_head 这个私有数据结构的头部:


C


static int prepend_rebindings(struct rebindings_entry **rebindings_head,                struct rebinding rebindings[],                size_t nel) {  struct rebindings_entry *new_entry = malloc(sizeof(struct rebindings_entry));  if (!new_entry) {    return -1;  }  new_entry->rebindings = malloc(sizeof(struct rebinding) * nel);  if (!new_entry->rebindings) {    free(new_entry);    return -1;  }  memcpy(new_entry->rebindings, rebindings, sizeof(struct rebinding) * nel);  new_entry->rebindings_nel = nel;  new_entry->next = *rebindings_head;  *rebindings_head = new_entry;  return 0;}
复制代码


也就是说每次调用的 rebind_symbols 方法传入的 rebindings 数组以及数组的长度都会以 rebindings_entry 的形式添加到 _rebindings_head 这个私有链表的首部:


C


struct rebindings_entry {  struct rebinding *rebindings;  size_t rebindings_nel;  struct rebindings_entry *next;};
static struct rebindings_entry *_rebindings_head;
复制代码


这样可以通过判断 _rebindings_head->next 的值来判断是否为第一次调用,然后使用 _dyld_register_func_for_add_image_rebind_symbols_for_image 注册为回调或者为所有存在的镜像单独调用 _rebind_symbols_for_image


C


static void _rebind_symbols_for_image(const struct mach_header *header, intptr_t slide) {  rebind_symbols_for_image(_rebindings_head, header, slide);}
复制代码


_rebind_symbols_for_image 只是对另一个名字非常相似的函数 rebind_symbols_for_image 的封装,从这个函数开始,就到了重绑定符号的过程;不过由于这个方法的实现比较长,具体分析会分成三个部分并省略一些不影响理解的代码:


C


static void rebind_symbols_for_image(struct rebindings_entry *rebindings,                   const struct mach_header *header,                   intptr_t slide) {  segment_command_t *cur_seg_cmd;  segment_command_t *linkedit_segment = NULL;  struct symtab_command* symtab_cmd = NULL;  struct dysymtab_command* dysymtab_cmd = NULL;
uintptr_t cur = (uintptr_t)header + sizeof(mach_header_t); for (uint i = 0; i < header->ncmds; i++, cur += cur_seg_cmd->cmdsize) { cur_seg_cmd = (segment_command_t *)cur; if (cur_seg_cmd->cmd == LC_SEGMENT_ARCH_DEPENDENT) { if (strcmp(cur_seg_cmd->segname, SEG_LINKEDIT) == 0) { linkedit_segment = cur_seg_cmd; } } else if (cur_seg_cmd->cmd == LC_SYMTAB) { symtab_cmd = (struct symtab_command*)cur_seg_cmd; } else if (cur_seg_cmd->cmd == LC_DYSYMTAB) { dysymtab_cmd = (struct dysymtab_command*)cur_seg_cmd; } }
...}
复制代码


这部分的代码主要功能是从镜像中查找 linkedit_segment symtab_commanddysymtab_command;在开始查找之前,要先跳过 mach_header_t 长度的位置,然后将当前指针强转成 segment_command_t,通过对比 cmd 的值,来找到需要的 segment_command_t


在查找了几个关键的 segment 之后,我们可以根据几个 segment 获取对应表的内存地址:


C


static void rebind_symbols_for_image(struct rebindings_entry *rebindings, const struct mach_header *header, intptr_t slide) {  ...
uintptr_t linkedit_base = (uintptr_t)slide + linkedit_segment->vmaddr - linkedit_segment->fileoff; nlist_t *symtab = (nlist_t *)(linkedit_base + symtab_cmd->symoff); char *strtab = (char *)(linkedit_base + symtab_cmd->stroff);
uint32_t *indirect_symtab = (uint32_t *)(linkedit_base + dysymtab_cmd->indirectsymoff);
...}
复制代码


linkedit_segment 结构体中获得其虚拟地址以及文件偏移量,然后通过一下公式来计算当前 __LINKEDIT 段的位置:


slide + vmaffr - fileoff
复制代码


类似地,在 symtab_command 中获取符号表偏移量和字符串表偏移量,从 dysymtab_command 中获取间接符号表(indirect symbol table)偏移量,就能够获得_符号表_、_字符串表_以及_间接符号表_的引用了。


  • 间接符号表中的元素都是 uint32_t *,指针的值是对应条目 n_list 在符号表中的位置

  • 符号表中的元素都是 nlist_t 结构体,其中包含了当前符号在字符串表中的下标


   struct nlist_64 {         union {           uint32_t  n_strx; /* index into the string table */       } n_un;       uint8_t n_type;        /* type flag, see below */       uint8_t n_sect;        /* section number or NO_SECT */       uint16_t n_desc;       /* see <mach-o/stab.h> */       uint64_t n_value;      /* value of this symbol (or stab offset) */     };
复制代码


  • 字符串表中的元素是 char 字符


该函数的最后一部分就开启了遍历模式,查找整个镜像中的 SECTION_TYPES_LAZY_SYMBOL_POINTERS 或者 S_NON_LAZY_SYMBOL_POINTERS 的 section,然后调用下一个函数 perform_rebinding_with_section 来对 section 中的符号进行处理:


C


static void perform_rebinding_with_section(struct rebindings_entry *rebindings, section_t *section, intptr_t slide, nlist_t *symtab, char *strtab, uint32_t *indirect_symtab) {  uint32_t *indirect_symbol_indices = indirect_symtab + section->reserved1;  void **indirect_symbol_bindings = (void **)((uintptr_t)slide + section->addr);  for (uint i = 0; i < section->size / sizeof(void *); i++) {    uint32_t symtab_index = indirect_symbol_indices[i];    uint32_t strtab_offset = symtab[symtab_index].n_un.n_strx;    char *symbol_name = strtab + strtab_offset;
struct rebindings_entry *cur = rebindings; while (cur) { for (uint j = 0; j < cur->rebindings_nel; j++) { if (strcmp(&symbol_name[1], cur->rebindings[j].name) == 0) { if (cur->rebindings[j].replaced != NULL && indirect_symbol_bindings[i] != cur->rebindings[j].replacement) { *(cur->rebindings[j].replaced) = indirect_symbol_bindings[i]; } indirect_symbol_bindings[i] = cur->rebindings[j].replacement; goto symbol_loop; } } cur = cur->next; } symbol_loop:; }}
复制代码


该函数的实现的核心内容就是将符号表中的 symbol_namerebinding 中的名字 name 进行比较,如果出现了匹配,就会将原函数的实现传入 origian_open 函数指针的地址,并使用新的函数实现 new_open 代替原实现:


C


if (cur->rebindings[j].replaced != NULL &&  indirect_symbol_bindings[i] != cur->rebindings[j].replacement) {  *(cur->rebindings[j].replaced) = indirect_symbol_bindings[i]; // 将原函数的实现传入 original_open 函数指针的地址}indirect_symbol_bindings[i] = cur->rebindings[j].replacement; // 使用新的函数实现 new_open 替换原实现
复制代码


如果你理解了上面的实现代码,该函数的其它代码就很好理解了:


  1. 通过 indirect_symtab + section->reserved1 获取 indirect_symbol_indices *,也就是符号表的数组

  2. 通过 (void **)((uintptr_t)slide + section->addr) 获取函数指针列表 indirect_symbol_bindings

  3. 遍历符号表数组 indirect_symbol_indices * 中的所有符号表中,获取其中的符号表索引 symtab_index

  4. 通过符号表索引 symtab_index 获取符号表中某一个 n_list 结构体,得到字符串表中的索引 symtab[symtab_index].n_un.n_strx

  5. 最后在字符串表中获得符号的名字 char *symbol_name


到这里比较前的准备工作就完成了,剩下的代码会遍历整个 rebindings_entry 数组,在其中查找匹配的符号,完成函数实现的替换:


C


while (cur) {  for (uint j = 0; j < cur->rebindings_nel; j++) {    if (strcmp(&symbol_name[1], cur->rebindings[j].name) == 0) {      if (cur->rebindings[j].replaced != NULL &&        indirect_symbol_bindings[i] != cur->rebindings[j].replacement) {        *(cur->rebindings[j].replaced) = indirect_symbol_bindings[i];      }      indirect_symbol_bindings[i] = cur->rebindings[j].replacement;      goto symbol_loop;    }  }  cur = cur->next;}
复制代码


在之后对某一函数的调用(例如 open),当查找其函数实现时,都会查找到 new_open 的函数指针;在 new_open 调用 origianl_open 时,同样也会执行原有的函数实现,因为我们通过 *(cur->rebindings[j].replaced) = indirect_symbol_bindings[i] 将原函数实现绑定到了新的函数指针上。

实验

fishhook 在 dyld 加载镜像时,插入了一个回调函数,交换了原有函数的实现;但是 fishhook 能否修改非动态链接库,比如开发人员自己手写的函数呢?我们可以做一个非常简单的小实验,下面是我们的 main.m 文件:


C


#import <Foundation/Foundation.h>#import "fishhook.h"
void hello() { printf("hello\n");}
static void (*original_hello)();
void new_hello() { printf("New_hello\n"); original_hello();}
int main(int argc, const char * argv[]) { @autoreleasepool { struct rebinding open_rebinding = { "hello", new_hello, (void *)&original_hello }; rebind_symbols((struct rebinding[1]){open_rebinding}, 1); hello(); } return 0;}
复制代码


这里的函数实现非常的简单,相信也不需要笔者过多解释了,我们直接运行这份代码:



代码中只打印了 hello,说明 fishhook 对这种手写的函数是没有作用的,如果在下面这里打一个断点:



代码并不会进这里,因为 hello 这个函数是包含在当前镜像的,它只是从其它代码地址跳转到了当前函数实现,这与我们调用外部库时有很大的不同,当调用外部库时,我们需要 dyld 解决函数地址的问题,但是函数在当前镜像中却并不需要 issue #25

小结

fishhook 的实现非常的巧妙,但是它的使用也有一定的局限性,在接触到 fishhook 之前,从没有想到过可以通过一种方式修改 C 函数的实现。

Reference

其它

main.m

C


#import <Foundation/Foundation.h>
#import "fishhook.h"
static int (*original_open)(const char *, int, ...);
int new_open(const char *path, int oflag, ...) { va_list ap = {0}; mode_t mode = 0;
if ((oflag & O_CREAT) != 0) { // mode only applies to O_CREAT va_start(ap, oflag); mode = va_arg(ap, int); va_end(ap); printf("Calling real open('%s', %d, %d)\n", path, oflag, mode); return original_open(path, oflag, mode); } else { printf("Calling real open('%s', %d)\n", path, oflag); return original_open(path, oflag, mode); }}
int main(int argc, const char * argv[]) { @autoreleasepool { struct rebinding open_rebinding = { "open", new_open, (void *)&original_open }; rebind_symbols((struct rebinding[1]){open_rebinding}, 1); __unused int fd = open(argv[0], O_RDONLY); } return 0;}
复制代码


关注仓库,及时获得更新:iOS-Source-Code-Analyze


本文转载自 Draveness 技术博客。


原文链接:https://draveness.me/fishhook


2019-12-10 17:571335

评论

发布
暂无评论
发现更多内容

架构师训练营第一周作业

Mark

鸟枪换炮,利用python3对球员做大数据降维(因子分析得分),为C罗找到合格僚机

刘悦的技术博客

Python 数据分析 特征选择 降维

为了搞清楚类加载,竟然手撸JVM!

小傅哥

JVM 小傅哥 类加载 生命周期 加载机制

散布消极言论被开除的总监 | 法庭上的CTO(25)

赵新龙

CTO 法庭上的CTO

智慧社区综合应用平台搭建,社区管理解决方案

t13823115967

智慧社区管理平台开发 智慧平安社区平台建设

Spring cloud Gateway(二) 一个Http请求的流程解析

Java 网关

CKLC挖矿矿机系统开发案例介绍

系统开发咨询1357O98O718

CKLC挖矿矿机系统软件开发 CKLC挖矿矿机系统开发 CKLC挖矿矿机APP系统开发

AAAI 2021论文:利用深度元学习对城市销量进行预测(附论文下载)

京东科技开发者

数据库 大数据 时序预测

阿里面试:Mybatis中方法和SQL是怎么关联起来的呢?

田维常

mybatis

Java多线程编程核心技术

田维常

多线程

开设赌场的CTO | 法庭上的CTO(23)

赵新龙

CTO 法庭上的CTO

侵犯著作权、判刑两年半的 CTO |法庭上的CTO(22)

赵新龙

CTO 法庭上的CTO

10次面试,2份offer —— 大龄程序员 2020 求职记录

escray

面试 架构师训练营第 1 期

5G与4G的差别及应用

anyRTC开发者

人工智能 android AI 5G WebRTC

犯”集资诈骗罪“、二审判6年的CTO | 法庭上的CTO(21)

赵新龙

CTO 法庭上的CTO

生产环境全链路压测建设历程 23:FAQ 3、4 适配改造,目标压力

数列科技杨德华

全链路压测 七日更

总结2020:5个月出版两本书,日更公众号是一种怎样的体验?

冰河

程序员 程序人生 年终总结

MySQL为Null会导致5个问题,个个致命!

王磊

MySQL MySQL使用

盘点2020 | 2021,Begin Again !

double U

大前端 盘点2020

互联网大厂有哪些分库分表的思路和技巧?

冰河

分布式数据库 分库分表 分布式存储 数据一致性 数据同步

母鸡下蛋实例:多线程通信生产者和消费者wait/notify和condition/await/signal条件队列

叫练

多线程与高并发 Wait lock 线程互斥 await

SpringCloudGateway(一) 概览

Java SpringcloudGateway

IPFS云算力挖矿系统开发详解案例及源码

系统开发咨询1357O98O718

云算力挖矿系统开发详解 云算力APP系统软件开发 云算力模式系统开发源码 云算力软件系统开发定制

公安警务报警系统,二维码一键定位报警

t13823115967

二维码定位报警系统开发 微警务 二维码定位

分享一个普通程序员的“沪漂”六年的历程以及感想

程序员老猫

回忆录 经历 年终总结 沪漂 上海买房

时空大数据与智能技术的时代共舞,百度地图给2020的答案

脑极体

IPFS挖矿矿机系统开发方案丨IPFS挖矿矿机源码案例

系统开发咨询1357O98O718

IPFS云算力挖矿系统开发 IPFS算力挖矿系统开发搭建

盘点2020 | YourBatman 2020年感悟关键词:科比、裁员、管理层、活着

YourBatman

裁员 盘点2020 科比 管理层 活着

IPFS挖矿系统开发详情案例

系统开发咨询1357O98O718

IPFS云算力挖矿系统开发 IPFS算力挖矿软件系统开发

NoahTenet诺亚信条软件系统APP开发

系统开发

被砍伤的技术VP | 法庭上的CTO(24)

赵新龙

CTO 法庭上的CTO

动态修改 C 语言函数的实现_语言 & 开发_Draveness_InfoQ精选文章