C++博客-
一年十二月谁主春秋
关注：基础系统工程密码学人工智能
-随笔分类-System

Windows异常分发与子系统图表集 -- 摘自Windows内核原理与实现

春秋十二月 — Tue, 24 Oct 2023 07:25:00 GMT

春秋十二月 2023-10-24 15:25 发表评论

浅谈Linux共享库库函数挂钩检测

春秋十二月 — Tue, 26 Sep 2023 08:47:00 GMT

Linux共享库库函数挂钩主流两种方法。一是替换函数对应的GOT/PLT条目，GOT/PLT原理类似Windows的IAT；二是inline挂钩，即替换函数序言的几个字节（x86是5或7字节）为jmp/call，若发现稍远处有jmp或call（前提在入口基本块内，若不在入口基本块内要修改分支控制条件，这有点复杂也无必要），则其目标地址可被替换，这样就不用替换序言的几字节了。Windows的IAT挂钩检测很方便，因为dll的baseaddr及size可通过API VirtualQueryEx（https://learn.microsoft.com/zh-cn/windows/win32/api/memoryapi/nf-memoryapi-virtualqueryex）或toolhelp库的Module32First/Module32Next（https://learn.microsoft.com/zh-cn/windows/win32/api/tlhelp32/nf-tlhelp32-module32first）接口来获取。同理linux也可以拿到有两种方法，一种是读/proc/pid/maps（这里pid为实际目标进程号）获取so库代码段的baseaddr和size，另一种用dl_iterate_phdr（https://man7.org/linux/man-pages/man3/dl_iterate_phdr.3.html）拿到代码段（pt_load类型+可执行标志）的baseaddr及size。只要模块(代码段)的baseaddr及size确定了，检测方法同IAT，即看替换函数地址是否不在代码段空间内，若不在或地址不是原函数则认为被挂钩了，否则需进一步用针对inline挂钩法的检测处理，见下文描述。另外dladdr（https://man7.org/linux/man-pages/man3/dladdr.3.html）判断一个地址是否跟一个so库及符号相关，因此也可用于检测挂钩。如果是inline挂钩法，那么分析函数入口基本块内（不管替换序言几字节还是已有jmp/call目标地址，都在入口基本块）jmp/call的目标地址（最好用成熟的反汇编引擎分析，比如llvm的mc库反汇编功能，或https://salsa.debian.org/debian/distorm3），看是否超出so库的代码段空间

春秋十二月 2023-09-26 16:47 发表评论

kretprobe探究思考

春秋十二月 — Tue, 12 Sep 2023 18:26:00 GMT

曾因朋友问到监控，致使我探究了kretprobe的实现，想到编译中的尾调用优化，作个小结

1. kretprobe_trampoline_holder该跳转函数无参是必须的或说最好的通用设计，因为替换返回地址是非正常程序流程，即被探测函数的调用者无感知，不存在为跳转函数准备入参。若要设计传参且只读，则不会破坏被探测函数调用者的上下文，但跳转函数内部流程怎么用参数是个问题，这需要一种约定

2. 跳转函数为调用trampoline_handler准备入参，即在栈上构造一个（不完整的）pt_regs，再把它地址即栈顶赋给rdi，rdi是x86_64上传入第一参数使用的寄存器，同时预留一个栈单元存放原返回地址（为什么要预留？因为被探测函数返回时，其调用者存放返回地址的栈空间被释放了，所以得在跳转函数内造一个）。由于trampoline_handler内调到用户自定义handler而传入pt_regs，因此自定义handler内要注意最好别改动pt_regs，否则会破坏被探测函数调用者的上下文

3. 表面看kretprobe的实现流程有点像尾调用优化，但有本质区别。后者中被调尾函数直接释放父调用者的栈帧，就可恢复到父调用者的返回地址；前者不能这样干，因为被探测函数的返回地址被替换了，所以需要一个时地（时机地点）恢复，而这时地正是跳转函数的收尾序列代码，把原来的返回地址放于上述2所讲的预留栈单元，这样最后的ret指令弹出它并跳到原返回地址执行。为保证恢复后正常执行，还得恢复被探测函数调用者的上下文即寄存器信息（无须恢复栈内容，因为上述1讲到了跳转函数是无参的）

春秋十二月 2023-09-13 02:26 发表评论

基于Rust构建WebAssembly

春秋十二月 — Mon, 13 Dec 2021 07:21:00 GMT

目录

下载：基于Rust构建WebAssembly

春秋十二月 2021-12-13 15:21 发表评论

基于VSS可传输卷影拷贝的备份架构

春秋十二月 — Wed, 06 Nov 2019 10:01:00 GMT

部署图

传统的vss备份架构由于备份应用部署在应用服务器内，因此比较耗应用服务器的CPU和IO，特别是拷贝大量的文件，为了降低对应用服务器的干扰，可采用server-free架构，将耗时的拷贝移到另一机器即备份服务器实现，而应用服务器只负责占用资源及耗时很少的打快照。这种架构运用了vss可传输卷影拷贝的特性，要求快照处于共享存储中，适用于Windows Server 2003 sp1以上版本

协作流程图

VSS快照代理端的SetContext要求设置成VSS_CTX_APP_BACKUP | VSS_VOLSNAP_ATTR_TRANSPORTABLE

春秋十二月 2019-11-06 18:01 发表评论

Shell（11）: 创建和删除so库软链接

春秋十二月 — Tue, 05 Nov 2019 10:17:00 GMT

脚本概述
由于某些sdk或软件依赖众多的第三方库，而从官网下载到windows主机或从linux传到windows时，所依赖的so库往往丢失符号链接，给编译运行带来不便，因此编写了ctlsolink脚本，用于自动为单个so或某目录下的众多so或创建/删除一级/二级符号链接。该脚本的用法如下:
● 第1参数为mk或rm子命令，mk表示创建，rm表示删除
● 第2参数为文件或目录
● 第3参数是可选的-r，且只能是-r，如果指定了，则表示不断递归子目录

脚本实现
考虑到so库带版本一般多为libx.so.1，libx.so.1.2，libx.so.1.2.3这三种形式(x为库名)，对于前一种创建/删除一级符号链接即可，后两种则创建/删除二级符号链接。为了精确地抽出一级和二级链接名称，这里使用awk来匹配，用shell变量的最短匹配模式从尾部逐步删除点号及数字，核心代码如下

1    if [ "$dir" != "$self_dir" ] || [ "$name" != "$self_name" ]; then
2        if echo $name | awk '{if($0~/\.so\.[0-9]{1,}\.[0-9]{1,}\.[0-9]{1,}$/) exit 0; else exit 1}'; then
3            link_name=${name%.[0-9]*}
4            link_name=${link_name%.[0-9]*}
5            link_name=${link_name%.[0-9]*}
6            link_name2=${name%.[0-9]*}
7            link_name2=${link_name2%.[0-9]*}
8        elif echo $name | awk '{if($0~/\.so\.[0-9]{1,}\.[0-9]{1,}$/) exit 0; else exit 1}'; then
9            link_name=${name%.[0-9]*}
10            link_name=${link_name%.[0-9]*}
11            link_name2=${name%.[0-9]*}
12        elif echo $name | awk '{if($0~/\.so\.[0-9]{1,}$/) exit 0; else exit 1}'; then
13            link_name=${name%.[0-9]*}
14        else
15            return
16        fi
17
18        if [ $do_mk = "yes" ]; then
19            #echo "name=$name, link_name=$link_name, link_name2=$link_name2"
20            if [ -n "$link_name2" ]; then
21                ln -sf $name $link_name2
22                ln -sf $link_name2 $link_name
23            else
24                ln -sf $name $link_name
25            fi
26        else
27            if [ -n $link_name2 ]; then
28                rm -f $link_name2
29            fi
30            rm -f $link_name
31        fi
32    fi

   要注意的是，这儿不能使用%%删除最长匹配的尾部来得到link_name，因为它的模式是.[0-9]*，这可能会错误地匹配了so前的部分，比如libx.1.so.2得到libx，而期望的是libx.1.so
   完整脚本下载：ctlsolink

运行效果
初始状态

运行ctlsolink创建软链接后

运行ctlsolink删除软链接后

春秋十二月 2019-11-05 18:17 发表评论

关于make依赖文件的自动生成

春秋十二月 — Fri, 16 Nov 2018 04:08:00 GMT

在GNU make中文手册这本书中，3.14节讲到了依赖文件的自动生成，如下图

图中的规则对C源文件和Makefile在同一目录，是正确的。但是不在同一目录的又希望依赖文件在对应的目录下，比如src/log/log_file.c，希望依赖文件log_file.d生成在src/log/下。因为gcc（aix平台xlc编译器亦如此）生成的依赖文件内容中目标文件名没有带路径，例如下所示

log_file.o: src/log/log_file.c src/log/log_file.h src/log/log_type.h \
src/log/../base/io_ext.h

所以sed就找不到src/log/log_file.o而替换了，改正后的规则如下

%.d: %.c
    $(CC) $(CFLAGS) $(INCS) $< $(MFLAGS) $@.$$$$;\
    sed 's,$(*F).o[ :]*,$*.o $@: ,g' < $@.$$$$ > $@;\
    $(RM) $@.$$$$

该规则对C源文件和Makefile在同一目录也适合，生成后的依赖文件内容如下

src/log/log_file.o src/log/log_file.d: src/log/log_file.c src/log/log_file.h src/log/log_type.h \
src/log/../base/io_ext.h

春秋十二月 2018-11-16 12:08 发表评论

Shell应用（10）：支持开源库编译的Makefile

春秋十二月 — Wed, 19 Oct 2016 07:11:00 GMT

脚本源码
由于很多应用项目依赖诸多第三方开源库，这些开源库各有不同的核心目录、库目标和输出位置，这里的核心目录是指仅产生so库的工程目录，库目标是指仅产生so库的make目标，输出位置是相对于核心目录的，但不必是子目录，可用..来回溯到父目录的某位置，更高层目录的位置，依次类推。为了统一支持它们，使用了一些技巧，详见示例脚本如下

1.PHONY: all clean lib core
2
3thirdlib=openssl-1.0.1u?build_ssl ACE_wrappers/ace json ncurses-6.0??lib
4coremod=main
5
6dir = `echo $@ | awk -F? '{print $$1}'`
7aim = `echo $@ | awk -F? '{print $$2}'`
8out = `echo $@ | awk -F? '{print $$3}'`
9
10copy=\cp -Pf ${dir}/${out}/*.so* output
11
12define MAKE_SUBDIR
13echo "${dir},${aim},${out}"; \
14if [ "$(MAKECMDGOALS)" != "clean" ]; then \
15$(MAKE) ${aim} -C ${dir}; \
16if [ "$$is_cp" -eq "1" ]; then \
17$(copy); \
18fi \
19else \
20$(MAKE) clean -C ${dir}; \
21fi
22endef
23
24all: lib core
25
26lib: $(thirdlib)
27
28$(thirdlib)::
29 @is_cp=1; $(MAKE_SUBDIR)
30
31core: $(coremod)
32
33$(coremod)::
34 @is_cp=0; $(MAKE_SUBDIR)
35
36clean: $(thirdlib) $(coremod)

实现技巧
   1）使用?作为分隔符，所分隔的3个域依次为核心目录、库目标、输出位置；使用awk来获取各域，分别为dir、aim和out；在运行过程中，值dir一定非空，而aim为空则表示默认目标，out为空表示输出位置即为dir目录。
   2）copy为命令变量，功能为每当一个库编译完成后，将输出的so库拷贝到output下，并保持软链接；对于有的开源库，需在编译前，使用对应的选项来调用configure，使其生成so库。
   3）为了重用代码，定义了MAKE_SUBDIR命令包，参数变量为is_cp，当is_cp为1时，表示当前编译的是依赖库，否则是主程序。
   4）thirdlib和coremod为依赖文件，使用了双冒号规则，这样一来，只要在thirdlib中加入新的依赖库，指定核心目录、库目标和输出位置即可，其它地方不用改。

春秋十二月 2016-10-19 15:11 发表评论

Shell应用（9）：自动化批量编译

春秋十二月 — Wed, 28 Sep 2016 03:04:00 GMT

脚本概述
   当需要在很多（比如几十至几百）台机器上编译同一程序时，如果一个个地手工拷贝源码、再编译，那么效率就很低，为了能大量节省手工、并行地编译，因此写了一个脚本，该脚本基于自动化脚本语言expect（expect基于tcl）实现，基本原理是针对每个远程主机，创建一个子进程，在该子进程内先调用scp拷贝源码到远程主机，再用ssh登录到远程主机、发送cd、configure和make命令，交互期间的命令输出多用正则分析，最终的编译输出保存到当前目录output子目录下。其命令行参数说明如下：
   ● 第1参数为远程主机配置文件：一个多行文本文件，每行格式为IP 用户名密码，空格符分隔，支持#注释。
   ● 第2参数为本地主机源码目录：要求该目录存在Makefile和configure文件。
   ● 第3参数为远程主机目标目录：用于存放源码的位置。

脚本实现
   拷贝源码

1proc copy_file {host user srcdir dstdir passwd {to 10} } {
2    if [catch "spawn scp -rq $srcdir $user@$host:$dstdir" msg] {
3        send_error "failed to spawn scp: $msg\n"
4        exit 1
5    }
6
7    set timeout $to
8    expect_after eof {
9        send_error "$host scp died unexpectedly\n"
10        exit 1
11    }
12    expect {
13        "(yes/no)?" { send "yes\r"; exp_continue }
14        -re "(?:P|p)assword:" { send "$passwd\r" }
15        timeout { do_timeout "$host scp" }
16    }
17
18    expect {
19        full_buffer { exp_continue }
20        timeout { exp_continue }
21        eof
22    }
23}

第2行调用spawn命令执行scp命令，并用catch捕捉错误；当执行成功后，第12行用expect等待远端输出（超时默认为10秒），第13、14行自动输入用户名和密码，当过程中网络连接断开时，会匹配到第8行的eof；当输出完成连接关闭时，会匹配到第21行的eof；如果输出太多超过expect内部的buffer时，会匹配到第19行的full_buffer，这里由于为了提高效率，使用了静默方式的scp，因些实际会匹配到第20行的timeout，不管匹配到哪种情况，都要继续直到eof。

执行编译

1proc do_make {host user passwd subdir {to 10} } {
2    if [catch {spawn ssh $user@$host} msg ] {
3        send_error "failed to spawn ssh: $msg\n"
4        exit 1
5    }
6
7    set timeout $to
8    expect_after eof {
9        send_error "$host ssh died unexpectedly\n"
10        exit 1
11    }
12
13    expect {
14        "*yes/no" { send "yes\r"; exp_continue }
15        -re "(?:P|p)assword:" { send "$passwd\r" }
16        timeout { do_timeout "$host ssh" }
17    }
18    wait_cmd $spawn_id passwd
19
20    send "cd $subdir\r"
21    wait_cmd $spawn_id cd
22
23    send "source configure\r"
24    wait_cmd $spawn_id configure
25
26    send "make\r"
27    wait_cmd $spawn_id make
28
29    send "exit\r"
30    expect eof
31}

   关于spawn和expect的解释与上节拷贝源码相同，不同的是依次发送命令cd、source configure、make，每个命令须等到命令提示符后（调用自定义函数wait_cmd）再发下一个，最后发送exit退出ssh、导致连接关闭，匹配到最后一行的eof。对于有的项目源码，可能没有或不用配置，那么configure文件可以不存在或内容为空，如果不存在导致报错也没关系，不影响make；如果configure出错，那么make也会出错。这里使用source是为了使配置在当前shell中生效。

   主循环

1set f [open $file r]
2set curtime [clock seconds]
3
4log_user 0
5set s {[:blank:]}
6set pattern "^(\[^#$s]+)\[$s]+(\[^$s]+)\[$s]+(\[^$s]+)"
7
8while { [gets $f line] != -1 } {
9    if { ![regexp $pattern [string trimleft $line] ? host user passwd] } {
10        continue
11    }
12    send_user "$host $user $passwd\n"
13    if { ![fork] } {
14
15        set filename output/${host}_[clock format $curtime -format %y.%m.%d_%H.%M.%S].log
16        log_file -noappend -a $filename
17
18        copy_file $host $user $srcdir $dstdir $passwd 30
19        do_make $host $user $passwd $subdir 30
20
21        send_user "$host finish\n"
22        exit
23    }
24}

   打开远程主机配置文件，读取每一行直到文件尾，忽略注释行，用正则提取IP、用户名和密码，创建子进程，按IP和当前时间命名log文件（由于前面调用log_user 0关闭了控制台输出，因此为了能记录输出到日志文件，一定要加-a选项），最后调用函数copy_file和do_make。

   完整脚本下载：autobuild.zip

春秋十二月 2016-09-28 11:04 发表评论

一种拦截Linux动态库API的方法及装置

春秋十二月 — Thu, 25 Aug 2016 03:10:00 GMT

描述
   拦截Linux动态库API的常规方法，是基于动态符号链接覆盖技术实现的，基本步骤是
1. 重命名要拦截的目标动态库。
2. 创建新的同名动态库，定义要拦截的同名API，在API内部调用原动态库对应的API。这里的同名是指与重命名前动态库前的名称相同。
   显而易见，如果要拦截多个不同动态库中的API，那么必须创建多个对应的同名动态库，这样一来不仅繁琐低效，还必须被优先链接到客户二进制程序中（根据动态库链接原理，对重复ABI符号的处理是选择优先链接的那个动态库）。另外在钩子函数的实现中，若某调用链调用到了原API，则会引起死循环而崩溃。本方法通过直接修改ELF文件中的动态库API入口表项，解决了常规方法的上述问题。

特点
   1. 不依赖于动态库链接顺序。
   2. 能拦截多个不同动态库中的多个API。
   3. 支持运行时动态链接的拦截。
   4. 钩子函数内的实现体，若调用到原API，则不会死循环。

实现
拦截映射表
为了支持特点2和3，建立了一个拦截映射表，这个映射表有2级。第1级为ELF文件到它的API钩子映射表，键为ELF文件句柄，值为API钩子映射表；第2级为API到它的钩子函数映射表，键为API名称，值为包含最老原函数地址和最新钩子函数地址的结构体，如下图

      当最先打开ELF文件成功时，会在第1级映射表中插入记录；反之当最后关闭同一ELF文件时，就会从中移除对应的记录。当第一次挂钩动态库API时，就会在第2级映射表插入记录；反之卸钩同一API时，就会从中删除对应的记录。

   计算ELF文件的映像基地址
      计算映像基地址是为了得到ELF中动态符号表和重定位链接过程表的内容，因为这些表的位置都是相对于基地址的偏移量，该算法在打开ELF文件时执行，如下图

      EXE文件为可执行文件，DYN文件为动态库。对于可执行文件，映射基地址为可执行装载段的虚拟地址；对于动态库，可通过任一API的地址减去它的偏移量得到，任一API的地址可通过调用libdl.so库API dlsym得到，偏移量通过查询动态链接符号表得到。

   打开ELF文件
      为了支持特点2即拦截不同动态库的多个API，节省每次挂钩API前要打开并读文件的开销，独立提供了打开ELF文件的接口操作，流程如下图

      若输入ELF文件名为空，则表示打开当前进程的可执行文件，此时要从伪文件系统/proc/self/exe读取文件路径名，以正确调用系统调用open。当同一ELF文件被多次打开时，只须递增结构elf的引用计数。

   挂钩API
      当打开ELF文件后，就可挂钩API了，流程如下图

      当第一次挂钩时，需要保存原函数以供后面卸钩；第二次以后继续挂钩同一API时，更新钩子函数，但原函数不变。

   卸钩API
      当打开ELF文件后，就可卸钩API了，流程如下图

关闭ELF文件
因为提供了打开ELF文件的接口操作，所以得配有关闭ELF文件的接口操作。当不需要挂钩API的时候，就可以关闭ELF文件了，流程如下图

运行时动态拦截装置

在初始化模块中打开当前可执行文件，挂钩libdl.so库的API dlopen和dlsym；在转换模块中，按动态库句柄和API名称在拦截映射表中查找钩子函数，若找到则返回钩子函数，否则返回调用dlsym的结果；在销毁模块中，卸钩dlopen和dlsym。
当动态库被进程加载的时候，会调用初始化模块；当被进程卸载或进程退出的时候，会调用销毁模块；当通过dlsym调用API时，则会在dlsym的钩子函数中调用转换模块。通过环境变量LD_PRELOAD将动态库libhookapi.so设为预加载库，这样就能拦截到所有进程对dlopen及dlsym的调用，进而拦截到已挂钩动态库API的调用。

春秋十二月 2016-08-25 11:10 发表评论

一种根据dentry获取绝对路径名的实现方法

春秋十二月 — Wed, 24 Aug 2016 11:22:00 GMT

本方法适用于linux 2.6.x内核。

1. 先获取dentry所属文件系统对应的挂载点，基本原理是遍历文件系统vfsmount树，找到与dentry有相同超级块的vfsmount，实现如下

1extern spinlock_t *vfsmnt_lock;
2
3static struct vfsmount* next_mnt(struct vfsmount *p, struct vfsmount *root)
4{
5    struct list_head *next = p->mnt_mounts.next;
6    if (next == &p->mnt_mounts) {
7        while (1) {
8            if (p == root)
9                return NULL;
10            next = p->mnt_child.next;
11            if (next != &p->mnt_parent->mnt_mounts)
12                break;
13            p = p->mnt_parent;
14        }
15    }
16    return list_entry(next, struct vfsmount, mnt_child);
17}
18
19static struct vfsmount* get_dentry_mnt(struct dentry *dentry)
20{
21    struct vfsmount *p, *root;
22    struct fs_struct *fs = current->fs;
23
24    read_lock(&fs->lock);
25    root = fs->root.mnt;
26    mntget(root);
27    read_unlock(&fs->lock);
28
29    spin_lock(vfsmnt_lock);
30    for(p = root; p; p = next_mnt(p,root)){
31        if(p->mnt_sb == dentry->d_sb){
32            mntget(p);
33            break;
34        }
35    }
36    spin_unlock(vfsmnt_lock);
37
38    mntput(root);
39
40    return p;
41}

next_mnt函数实现了先根遍历法，遍历以root为根的文件系统挂载点，p为遍历过程中的当前结点，返回p的下一个挂载点；vfsmnt_lock可通过内核函数kallsyms_on_each_symbol或kallsyms_lookup_name查找获得。

2. 再调用内核函数d_path，接口封装如下

1char* get_dentry_path(struct dentry *dentry,char *buf,int len)
2{
3    char *p = "";
4    struct vfsmount *mnt = get_dentry_mnt(dentry);
5
6    if(mnt){
7        struct path ph = {.dentry = dentry, .mnt = mnt};
8        p = d_path(&ph,buf,len);
9        if(IS_ERR(p))
10            p = "";
11        mntput(mnt);
12    }
13
14    return p;
15}

春秋十二月 2016-08-24 19:22 发表评论

一种动态跟踪TCP连接与进程相关性的方法

春秋十二月 — Wed, 13 Jul 2016 03:24:00 GMT

描述
   TCP连接跟踪是网络流控和防火墙中的一项重要的基础技术，当运用于主机时，连接必与进程相关联，要么是主动发出的，要么是被动接受的，当后代进程被动态创建时，由于文件描述符的继承，一个连接就会被这个进程树中的所有进程共享；当一个进程发出或接受多个连接时，就拥有了多个连接。本方法可用于网络安全产品中，监控TCP连接及所属进程，能准确并动态地知道一个连接被哪些进程共享，一个进程拥有哪些连接。

特点
   操作系统自带的netstat工具只是关联到了一个根进程，无法看到拥有该连接的所有进程，查看进程拥有的全部连接也不方便。该方法的特点是实时跟踪、查看连接与进程相关信息方便、支持连接的管控。

实现
   本方法通过内核安全的十字链表实现了连接与进程的相关性，连接信息结构体含有一个所属进程链表头，进程信息结构体含有一个拥有连接链表头，通过十字链表结点链接，x方向链接到进程的连接链表，y方向链接到连接的进程链表，如下图所示

   进程1为根进程，进程2，...，进程n为进程1的后代进程；连接1，连接2，...，连接n为进程1产生的连接。node(x,y)为十字链表结点，用于关联连接与进程，x对应进程编号，y对应连接编号，每个node包含了所属的连接和进程指针，每行和每列都是一个双向循环链表（循环未画出），每个链表用一个自旋锁同步操作。
   动态跟踪的过程包括4个方面：进程创建、进程退出、连接产生、连接销毁。在Linux下，可通过拦截内核函数do_fork挂钩进程创建，拦截do_exit挂钩进程退出；可通过拦截inet_stream_ops的成员函数connect和accept挂钩连接产生，拦截成员函数release挂钩连接销毁。下面为4个方面对应的流程图，由于所有外层加锁前已禁止本地中断和内核抢占，因此内层加锁前就不必再禁止本地中断和内核抢占了。

   进程创建

将copy_node插入到c的进程链表末尾，即为y方向增加（下同）；插入到p的连接链表末尾，为x方向增加（下同）。

进程退出

从c的进程链表中移除node，即为y方向移除（下同）；再从p的连接链表中移除node，即为x方向移除（下同）。

连接产生
当进程发出连接或接受连接时，调用此流程。

连接销毁
当某个进程销毁连接时，调用此流程。

春秋十二月 2016-07-13 11:24 发表评论

Shell应用（8）：使用awk定位反汇编输出

春秋十二月 — Tue, 27 Oct 2015 07:36:00 GMT

脚本概述
   由于使用objdump反汇编linux内核的输出太多（2.6.32-220.el6.x86_64统计结果为1457706行），而很多时候只是想查看特定部分的机器码与汇编指令，例如函数的入口、堆栈、调用了哪个函数等，为了高效和通用，因此编写了一个简单的awk脚本，其命令行参数说明如下：
   ● SLINE表示匹配的起始行号（不小于1），SPAT表示匹配的起始行模式，这两个只能有一个生效，当都有效时，以SLINE为准。
   ● NUM表示从起始行开始的连续输出行数（不小于1，含起始行），EPAT表示匹配的结束行模式，这两个只能有一个生效，当都有效时，以NUM为准。

脚本实现
   检查传值
   由于向脚本传入的值在BEGIN块内没生效，在动作块{}和END块内有效，但若在{}内进行检查则太低效，因为处理每条记录都要判断，所以为了避免在{}内进行多余的判断，就在BEGIN块内解析命令行参数来间接获得传值，当传值无效时，给出提示并退出。

1for(k=1;k<ARGC;++k){
2        str=ARGV[k]
3        if(1==match(str,"SLINE=")){
4            SLINE = substr(str,7)
5        }else if(1==match(str,"SPAT=")){
6            SPAT = substr(str,6)
7        }else if(1==match(str,"NUM=")){
8            NUM = substr(str,5)
9        }else if(1==match(str,"EPAT=")){
10            EPAT = substr(str,6)
11        }
12    }
13
14 if(SLINE<=0 && SPAT==""){
15      print "Usage: rangeshow must specifies valid SLINE which must be greater than 0, or SPAT which can't be empty"
16      exit 1
17 }
18
19 if(NUM<=0 && EPAT==""){
20      print "Usage: rangeshow must specifies valid NUM which must be greater than 0, or EPAT which can't be empty"
21    exit 1
22}

结束处理
当处理了NUM条记录或匹配了结束行模式时，应退出动作块{}。

1if(0==start_nr){
2
3}else{
4    if(NUM>0) {
5        if(NR<start_nr+NUM) {
6            ++matched_nr
7            print $0
8        }else
9            exit 0
10
11    }else{
12        ++matched_nr
13        print $0
14        if(0!=match($0,EPAT))
15            exit 0
16    }
17}

   完整脚本下载：rangeshow。

脚本示例
   查看linux内核第10000行开始的10条指令，如下图


   查看linux内核函数do_fork入口开始的10条指令，如下图


   查看linux内核第10000行开始到callq的一段指令，如下图


   查看linux内核函数do_exit入口到调用profile_task_exit的一段指令，如下图

春秋十二月 2015-10-27 15:36 发表评论

Shell应用（7）：nginx升级与恢复

春秋十二月 — Sun, 18 Jan 2015 16:36:00 GMT

摘要: 脚本概述 nginx是一款著名的开源web服务器，为方便升级与恢复，编写了一个简单的脚本，因为升级备份了可执行文件和配置文件（后缀名为old），所以可用于恢复。当升级时，若nginx正在运行，则不中断服务进行平滑升级，否则直接拷贝覆盖；当恢复时，若nginx正在运行，则不中断服务进行平滑恢复，否则直接拷贝覆盖。是否正在运行根据pid来判断，而pid从pid文件读取... 阅读全文

春秋十二月 2015-01-19 00:36 发表评论

基于TLS FIFO的进程间通信模型

春秋十二月 — Sun, 30 Nov 2014 16:13:00 GMT

众所周知，TLS是指线程局部存储，FIFO是Unix中的命名管道，可用于无关进程间的通信，而本文描述的TLS FIFO是指这样一种机制：如果一个线程在每次IO操作时，若没有连接，则先连接到FIFO服务端，再将连接关联到这个线程的TLS中，这里的连接即创建并打开唯一的FIFO，之后的读写就在这个FIFO连接上进行；当FIFO连接断开时，在下次IO操作时会自动重连。这样一来，用户程序就只要调用相关的IO操作，而不必管理连接，极大地简化了程序。使用FIFO通信前先要创建FIFO再打开它，其中创建是最重要的操作，结果有3种情况：成功、失败和已存在。

结构定义

typedef struct
{
int fd;
char *name;
}ipc_fifo_t;

fd存储FIFO文件描述符，name存储FIFO文件系统路径名。

接口函数
● 创建FIFO

ipc_fifo_t* ipc_fifo_make(const char *path,mode_t mode);

path指定FIFO路径，可以是绝对路径或相对路径，mode指定访问权限，若成功则返回一个FIFO结构，否则为NULL；通常被ipc_fifo_open调用。

● 打开FIFO

int ipc_fifo_open(ipc_fifo_t **f,const char *path,int flag,mode_t mode);

flag指定打开标志，如果包含了O_CREAT标志，那么调用ipc_fifo_make创建新的FIFO对象并在打开成功后替换*f，否则如果*f为空，就分配并初始化一个fifo结构；mode指定访问权限，仅当创建时生效。虽然f为输入输出参数，但操作失败时不会影响它，也就是说没有副作用。

● 发送数据

ssize_t ipc_fifo_write(ipc_fifo_t *f,const void *data,size_t size);

如果成功则返回已发送的字节数，否则返回-1，errno表示出错代码。

● 接收数据

ssize_t ipc_fifo_read(ipc_fifo_t *f,void *data,size_t size);

如果成功则返回已发送的字节数，否则返回-1，errno表示出错代码。

● 关闭FIFO

void ipc_fifo_close(ipc_fifo_t *f);

当通信结束的时候，应该调用此函数来关闭FIFO，它会先删除FIFO文件和关闭文件描述符，最后释放fifo结构。

● 获取TLS FIFO

ipc_fifo_t* ipc_fifo_tls_get();

该函数一般被发送数据接口调用，若成功则返回一个FIFO结构，否则为NULL；每个线程对应一个FIFO对象，对于同一线程，获取的是同一个FIFO对象，而后便可调用ipc_fifo_write来发送数据。

工作流程

创建FIFO

适用于FIFO客户端和服务端，但服务端由于要异步处理众多FIFO客户端，因此要注意以下2个问题，这也是使用FIFO技术通信的一些细节。

1）必须以非阻塞读写方式打开知名FIFO，即以O_CREAT|O_RDWR|O_NONBLOCK标志来调用ipc_fifo_open，这样才不会阻塞等待某个客户端以同步写方式打开知名FIFO而返回，因为它使用O_RDWR标志，这样自己既读又写，加上O_NONBLOCK，就立即返回了。

2）必须以非阻塞只读方式打开对应客户端FIFO，即以O_RDONLY|O_NONBLOCK标志调用ipc_fifo_open，这样就不会阻塞接受客户端建立连接而返回。

建立FIFO连接

适用于FIFO客户端，被发送数据接口调用，考虑到服务端可能事先没有打开知名FIFO来监听连接，所以这里先以异步方式写打开知名FIFO，如果成功则改以阻塞方式发送唯一路径名到服务端，如果发送完全后，接着以同步方式写打开唯一FIFO，这是为了等待服务端打开了对应的唯一FIFO。

发送数据

适用于FIFO客户端，当TLS中没有关联对应的FIFO时，则先调用fifo_tls_get进入建立FIFO连接流程，而后再发数据。

春秋十二月 2014-12-01 00:13 发表评论

Shell应用（6）: TCP内核调优与转储设置

春秋十二月 — Mon, 24 Mar 2014 10:44:00 GMT

为了方便更改系统tcp内核的一些参数，编写ktcpopt脚本如下

1#! /bin/bash
2# ktcpopt
3
4sed -i '/net.ipv4.tcp_syncookies\|net.ipv4.tcp_tw_reuse\|net.ipv4.tcp_tw_recycle\|net.ipv4.tcp_fin_timeout\|net.ipv4.tcp_max_syn_backlog\|net.ipv4.tcp_max_tw_buckets\|net.ipv4.ip_local_port_range/d' /etc/sysctl.conf
5
6sed -i '$a\net.ipv4.tcp_syncookies=1\nnet.ipv4.tcp_tw_reuse=1\nnet.ipv4.tcp_tw_recycle=1\nnet.ipv4.tcp_fin_timeout=30\nnet.ipv4.tcp_max_syn_backlog=8192\nnet.ipv4.tcp_max_tw_buckets=5000\nnet.ipv4.ip_local_port_range=10000 65000' /etc/sysctl.conf

为了方便配置程序的崩溃调试，编写coredump脚本如下

1#! /bin/bash
2# coredump
3
4sed -i '/ulimit -c unlimited\|export core_path=\/tmp\/corefiles\|mkdir -p $core_path\|echo "0" > \/proc\/sys\/kernel\/core_uses_pid\|echo "$core_path\/%e" > \/proc\/sys\/kernel\/core_pattern/d' ~/.bashrc
5
6sed -i '$a\ulimit -c unlimited\nexport core_path=/tmp/corefiles\nmkdir -p $core_path\necho "0" > /proc/sys/kernel/core_uses_pid\necho "$core_path/%e" > /proc/sys/kernel/core_pattern' ~/.bashrc

从以上2个脚本可以看出，为避免每次调用脚本时增加重复行以致配置文件逐渐变大，先删除已经存在的相关配置，再在末尾增加。这里使用了sed来实现直接在文件中删除和增加，其中由于删除操作的匹配模式有多个，因此使用了|符号并用\转义，并且第2个脚本模式文本中含有/符号，这与sed本身的模式限定符/存在歧义，因此也用了\转义；增加使用$a\命令来实现在文件末尾增加配置，并用\n换行。

春秋十二月 2014-03-24 18:44 发表评论

Shell应用（5）: 自动生成并安装服务脚本

春秋十二月 — Fri, 03 Jan 2014 09:11:00 GMT

脚本概述
   一般地，当在目标机器编译安装某个服务程序后，为了使服务能开机自启动和关机自停止，则需要将其添加为系统服务。但不同的Linux系统管理服务的方法不同，如Ubuntu使用update-rc.d命令，而RedHat则使用chkconfig命令。因此为了能自动识别系统的类型，减少人工控制，编写了一个简单的autosrv脚本，要求至少1个最多2个参数，特点如下：
   ● 第1个参数只能为install或uninstall，表示安装或卸载服务。
   ● 第2参数是可选的，表示系统名称，如果没有指定，那么会自动识别，若出现提示错误，则表示应该要显式指定系统名称了。

脚本实现

  1#! /bin/bash
  2# autosrv
  3
  4if [ $# -lt 1 ]; then
  5    echo "Usage: $(basename "$0") install | uninstall [sysname]"
  6    exit
  7elif [ "$1" != "install" -a "$1" != "uninstall" ]; then
  8    echo "The first parameter must be install or uninstall"
  9    exit
10fi
11
12action=$1
13sysname=$2
14srv_path=/etc/init.d/srv_name
15
16if [ -z "$sysname" ]; then
17    sysname=`lsb_release -a | sed -n '2p' | awk '{if($0~/[Uu][Bb][Uu][Nn][Tt][Uu]/) print "ubuntu"; else if($0~/[Dd][Ee][Bb][Ii][Aa][Nn]/) print "debian"; else if($0~/[Rr][Ee][Dd][Hh][Aa][Tt]/) print "redhat"; else if($0~/[Cc][Ee][Nn][Tt][Oo][Ss]/) print "centos"; else print ""}'`
18    if [ -z "$sysname" ]; then
19        echo "Unknown system, please manual special it with the second parameter"
20        exit
21    fi
22    echo "Current system is $sysname"
23fi
24
25create_file_ubuntu_debian()
26{
27cat << END > $srv_path
28#! /bin/bash
29. /lib/lsb/init-functions
30
31END
32cat srv_name.body >> $srv_path
33}
34
35create_file_redhat_centos()
36{
37cat << END > $srv_path
38#! /bin/bash
39#chkconfig:2345 90 10
40#description: srv name
41
42. /etc/rc.d/init.d/functions
43
44END
45cat srv_name.body >> $srv_path
46}
47
48chmod_file()
49{
50    chmod u+x $srv_path
51}
52
53remove_file()
54{
55    rm -f $srv_path
56}
57
58install_ubuntu_debian()
59{
60    create_file_ubuntu_debian
61    chmod_file
62    update-rc.d srv_name defaults 90 10
63}
64
65uninstall_ubuntu_debian()
66{
67    update-rc.d -f srv_name remove
68    remove_file
69}
70
71install_redhat_centos()
72{
73    create_file_redhat_centos
74    chmod_file
75    chkconfig --add srv_name
76}
77
78uninstall_redhat_centos()
79{
80    chkconfig --del srv_name
81    remove_file
82}
83
84case "$sysname" in
85    ubuntu|debian)
86    if [ "$action" = "install" ]; then
87        install_ubuntu_debian
88    else
89        uninstall_ubuntu_debian
90    fi
91    ;;
92
93    redhat|centos)
94    if [ "$action" = "install" ]; then
95        install_redhat_centos
96    else
97        uninstall_redhat_centos
98    fi
99    ;;
100
101    *)
102    echo "Currently only support ubuntu, debian, redhat and centos system"
103    exit
104    ;;
105esac

   从上可知，自动识别的方法是获取lsb_release -a返回的文本再使用awk来匹配ubuntu,redhat,debian,centos这几个子串(忽略大小写)。要注意的是，返回的文本可能有所不同。

   当系统安装了LSB模块时，返回结果如下


   没有安装时，返回结果如下

无论哪种情况，要提取分析的都是第2行文本，因此使用了sed -n '2p'。srv_name.body是不同系统相同的用于生成最终服务脚本的部分代码文件，通常包含了start,stop,status,restart几个函数，只是没有包含前面的一部分，而这部分则由autosrv脚本来根据不同的系统生成不同的代码。

春秋十二月 2014-01-03 17:11 发表评论

Shell应用（4）: 使用sed删除行尾的^M字符

春秋十二月 — Thu, 08 Aug 2013 11:06:00 GMT

由于从其它平台如windows传输文件到类unix平台时，用vim等编辑工具打开时，有时会发现行尾有^M，其实这就是控制字符CR，ASCII码为13。为方便删除这个字符，编写了一个简单的dos2unix脚本，最多带2个参数，特点如下：
● 第1个参数表示目标文件或目录，当为文件时则处理非脚本本身的文件，当为目录时则根据第2个参数是否递归处理子目录。

● 第2个参数当且仅当第1个参数为目录时有效，表示是否递归处理子目录，当为空时则不处理，为-r时则处理。

1#! /bin/bash
2# dos2unix
3
4self_name=$(basename "$0")
5self_dir=$(cd "$(dirname "$0")";pwd)
6
7transform_file()
8{
9    name=$(basename "$1")
10    dir=$(dirname "$1")
11
12    if [ "$dir" = "." ]; then
13        dir=$(pwd)
14    fi
15
16    if [ "$dir" != "$self_dir" ] || [ "$name" != "$self_name" ]; then
17        mv $1 $1.old
18        sed 's/^M$//g' $1.old > $1
19        rm $1.old
20    fi
21}
22
23transform_dir()
24{
25    local pdir=$(pwd)
26    cd $1
27
28    for s in `ls`
29    do
30        if [ -f "$s" ]; then
31           transform_file "$s"
32        else
33           if [ -d "$s" ] && [ "$2" -eq "1" ]; then
34               transform_dir "$s" "1"
35           fi
36        fi
37    done
38
39    cd $pdir
40}
41
42transform()
43{
44    if [ -f "$1" ]; then
45        transform_file "$1"
46    else
47        if [ -z "$2" ]; then
48            is_r=0
49        else
50            if [ "$2" = "-r" ]; then
51                is_r=1
52            else
53                echo "Usage: $(basename $0) directory -r"
54                return 1
55            fi
56        fi
57
58        if [ -d "$1" ]; then
59            transform_dir "$1" "$is_r"
60        else
61            echo "$1 is neither file nor directory"
62            return 1
63        fi
64    fi
65}
66
67if [ -n "$1" ]; then
68    transform $1 $2
69else
70    echo "Usage: $(basename $0) file or directory [-r]"
71    exit 1
72fi

春秋十二月 2013-08-08 19:06 发表评论

基于Linux平台的高级IO扩展函数

春秋十二月 — Fri, 02 Aug 2013 11:44:00 GMT

摘要: 由于read、readv、write和writev函数一次读或写有时并不能满足所要求的数据，因此需要多次调用直到要求的字节数或者出错。针对这4个系统调用，编写了对应的xxxn版本，实现如下 Code highlighting produced by Actipro CodeHighlighter (freeware)http:... 阅读全文

春秋十二月 2013-08-02 19:44 发表评论

计算Linux系统和进程CPU及内存使用率

春秋十二月 — Fri, 31 May 2013 11:04:00 GMT

摘要: 基本原理 1）系统CPU使用率等于两个时间点的CPU非空闲时间差除以CPU时间总量差得到的百分比，这两者可从/proc/stat文件获得。 2）系统内存使用率等于系统物理内存消耗量除以系统物理内存总量(memtotal，以KB为单位)得到的百分比，这两者可从/proc/meminfo文件获得。 3... 阅读全文

春秋十二月 2013-05-31 19:04 发表评论

Shell应用（3）: 使用awk统计磁盘空间

春秋十二月 — Thu, 01 Nov 2012 09:47:00 GMT

本文以统计磁盘文件系统已用空间为例说明awk的用法，使用命令df可获得磁盘文件系统的相关信息，如下图所示

第3列Used便是已用空间的数据，这是正常的情形。当第1列Filesystem文本过长时，就有可能换行输出，这是特殊的情形，如下图所示

针对这两种情形，如何写出有效的命令脚本来统计Used列的数据和呢？从上面两图观察对比显然可得，以空白符开头的文本行便是特殊情形，需要计算的是第2列；而正常情形的文本行，便是第3列。因此可得出awk脚本: awk '{ if($0~/^ /) s+=$2; else s+=$3;} END{ print "Used total is: "s }'。

用于正常情形，输出如下

而特殊情形，则输出如下

春秋十二月 2012-11-01 17:47 发表评论

Shell应用（2）: 查看TCP服务器的性能

春秋十二月 — Tue, 04 Sep 2012 08:35:00 GMT

   为方便查看特定TCP服务器进程的CPU、内存和网络连接情况，编写了一个简单的脚本perf.sh，其原理是指定--tcp或-t选项来调用netstat命令，指定aux -T选项参数调用ps命令，对输出结果根据进程名称或PID调用grep过滤；为了输出结果的可读性，先调用ps和netstat，用head取出保存大多是说明描述性的头几行。这里的实现具有如下特点：
   ● 支持单独查看CPU和内存利用率，或网络连接情况，或两者皆可，name表示进程名，address表示网络地址
   ● 支持输出重定向，使用exec实现将标准输出重定向到file文件，当没指定-o file选项参数时，则为标准输出
   ● 支持设置刷新时间，当没指定-t seconds选项参数时，则默认为3秒
   ● 支持显示多线程，当指定-m选项时，则显示多个线程的情况，默认不显示

  1#! /bin/bash
  2#perf.sh
  3
  4name=
  5address=
  6file=
  7seconds=
  8show_mthread=0
  9is_count=0
10
11while getopts :p:n:o:t:mv opt
12do
13    case $opt in
14    p)  name=$OPTARG
15        ;;
16    n)  address=$OPTARG
17        ;;
18    o)  file=$OPTARG
19        ;;
20    t)  seconds=$OPTARG
21        ;;
22    m)  show_mthread=1
23        ;;
24    v)  is_count=1
25        ;;
26    '?')    echo "$0: invalid option -$OPTARG" >&2
27            echo "Usage: $0 [-p name] [-n address] [-o file] [-t seconds] [-m]" >&2
28            exit 1
29            ;;
30    esac
31done
32
33shift $((OPTIND-1))
34
35if [ -z "$name" -a -z "$address" ]; then
36    printf "Usage $(basename "$0") [-p name] [-n address] [-o file] [-t seconds] [-m]\nname or address must not be null\n"
37    exit 1
38fi
39
40if [ -z "$seconds" ]; then
41    seconds=3
42fi
43
44psflag="aux"
45if [ "$show_mthread" = 1 ]; then
46    psflag="$psflag -T"
47fi
48
49psheader="`ps $psflag | head -n 1`"
50sortflag="-k3nr -k4nr" #sort by descend order according to cpu and mem
51
52netflag="-an --tcp --inet"
53netheader="`netstat $netflag | head -n 2`"
54is_exist=
55
56show_process_info()
57{
58    if [ -z "$1" ]; then
59        return 255
60    fi
61
62    result=`ps $psflag | grep -E "$1" | grep -E -v "gdb|grep|$0" | sort $sortflag`
63    if [ -z "$result" ]; then
64        is_exist=0
65    else
66        is_exist=1
67        uptime
68        echo "$psheader"
69        echo "$result"
70    fi
71    echo ""
72}
73
74show_net_connection()
75{
76    if [ -z "$1" ]; then
77        return 255
78    fi
79
80    result=`netstat  $netflag | grep -E $1`
81    if [ -n "$result" ]; then
82        echo "$netheader"
83        if [ "$is_count" = 1 ]; then
84            echo "$result" | awk '/^tcp/ { ++S[$NF] } END{ for(a in S) print a, S[a] }'
85        fi
86    fi
87    echo ""
88}
89
90tmpfile=`mktemp /tmp/per.XXXXXXXXXXXX`
91
92while true
93do
94    if [ -n "$file" ]; then
95        exec 1> $tmpfile
96    fi
97
98    show_process_info $name
99    show_net_connection $address
100    echo ""
101
102    sleep $seconds
103
104    if [ -n "$file" ]; then
105        exec 1>&-
106
107        if [ "$is_exist" = 1 ]; then
108            cat $tmpfile >> $file
109        fi
110
111        size=`ls -l $file | awk '{print $5}'`
112        if [ $size -ge $(expr 1024 \* 1024 \* 1) ]; then
113            cat  /dev/null > $file
114        fi
115    else
116        clear
117    fi
118done

最后顺便提下，上面是查看某单个服务器进程的性能，若要查看整体服务器系统的性能，可以运用vmstat、iostat和free等命令。

春秋十二月 2012-09-04 16:35 发表评论

通用Makefile文件及应用

春秋十二月 — Thu, 16 Aug 2012 11:29:00 GMT

原理
在linux平台下编译由多个源码文件或目录组成的项目工程时，需要编写make脚本即Makefile文件来编译，当项目工程宠大时，这种方式比单纯地使用gcc命令行方便快捷，且易于维护。由于具体工程的源码文件数量的多少及名称的不同，因此编写一个较为通用的Makefile文件，来实现编译各种不同的工程，具有重要的参考意义和价值。本文展示了通用Makefile.in文件及其应用示例。Makefile.in文件，顾名思义，内部实现用的，应由外部具体的Makefile文件提供具体的命令行参数来调用，它包括exe,static,share三个规则目标，因此支持可执行文件、动态库和静态库三种工程的编译，而每种工程又支持debug和release两种版本，默认为release版本，在编译时会自动创建debug或release目录来存放所有中间文件*.o和*.d。在其脚本源码中，详见下面实现，小写变量为内部所有，大写变量为make命令行提供的参数，目前支持以下几种命令行参数：
     1）输出名称：OUT_NAME，对于库工程，内部自动添加lib前缀
     2）输出路径：OUT_PATH，末尾反斜杠/可有可无
3）源码路径：SRC_PATH，末尾反斜杠/可有可无
     4）依赖动态库路径：SHARE_PATH，不带库名称的路径，末尾反斜杠/可有可无
5）依赖动态库名称：SHARE_LIB，不带库路径的名称，内部自动添加-l前缀
     6）依赖静态库路径：STATIC_PATH，不带库名称的路径，末尾反斜杠/可有可无
     7）依赖静态库路径：STATIC_LIB，不带库路径的名称
     8）预定义宏：MACROS，内部自动添加-D前缀
     9）编译模式：MODE，表示编译成debug或release版本
     关于头文件包含的支持，这里没有提供命令行参数，在内部它固定为SRC_PATH、/usr/include和/usr/local/include三个路径，对于大多数的工程，应该够用了。

实现

1#Makefile.in
2
3inc_path := $(SRC_PATH) /usr/include /usr/local/include
4inc_path := $(addprefix -I,$(inc_path))
5override SHARE_PATH += /usr/lib /usr/local/lib
6override SHARE_PATH  := $(addprefix -L,$(SHARE_PATH))
7override SHARE_LIB  := $(if $(SHARE_LIB),$(addprefix -l,$(SHARE_LIB)))
8override STATIC_PATH := $(patsubst %/,%,$(STATIC_PATH))
9override STATIC_LIB := $(if $(STATIC_PATH),$(if $(STATIC_LIB),$(addprefix $(STATIC_PATH)/,$(STATIC_LIB))))
10override SRC_PATH := $(patsubst %/,%,$(SRC_PATH))
11override MACROS := $(addprefix -D,$(MACROS))
12
13cxxflags := -Wall $(MACROS)
14
15ifeq ($(MODE),debug)
16  cxxflags += -g
17  tmp_path := $(SRC_PATH)/debug
18else
19  cxxflags += -O2 -DNDEBUG
20  tmp_path := $(SRC_PATH)/release
21endif
22
23lib_name := $(addprefix lib,$(OUT_NAME))
24
25srcs := $(wildcard $(SRC_PATH)/*.c) $(wildcard $(SRC_PATH)/*.cpp)
26deps := $(patsubst %.c,%.d,$(patsubst %.cpp,%.d,$(srcs)))
27deps := $(foreach dep,$(deps),$(notdir $(dep)))
28deps := $(addprefix $(tmp_path)/,$(deps))
29
30objs := $(patsubst %.c,%.o,$(patsubst %.cpp,%.o,$(srcs)))
31objs := $(foreach obj,$(objs),$(notdir $(obj)))
32objs := $(addprefix $(tmp_path)/,$(objs))
33
34share_name  := $(tmp_path)/$(lib_name).so
35static_name := $(tmp_path)/$(lib_name).a
36exe_name    := $(tmp_path)/$(OUT_NAME)
37
38override MACROS := $(if $(MACROS),$(addprefix -D,$(MACROS)))
39
40.PHONY: exe lib static share clean config
41
42arflags    := -rc
43
44define MKDIR
45if [ ! -d $(tmp_path) ]; then \
46mkdir $(tmp_path);\
47fi
48endef
49
50config:
51    @$(MKDIR)
52
53exe: config $(exe_name)
54
55lib: config static share
56
57static: $(static_name)
58
59share: $(share_name)
60
61$(exe_name): $(objs)
62    @echo "Linking to execute ($@ : $(objs))."
63    $(CXX) -o $@ $(objs) $(SHARE_PATH) $(SHARE_LIB) $(STATIC_LIB)
64    @cp $(exe_name) $(OUT_PATH)
65
66$(static_name): $(objs)
67    @echo "Archive to static library ($@ [$(objs)])."
68    $(AR) $(arflags) $@ $(objs)
69    @cp $(static_name) $(OUT_PATH)
70
71$(share_name): $(objs)
72    @echo "Linking to shared library ($@ [$(objs)])."
73    $(CXX) $(cxxflags) -o $@ $(objs) -fPIC -shared
74    @cp $(share_name) $(OUT_PATH)
75
76$(tmp_path)/%.o: $(SRC_PATH)/%.cpp $(tmp_path)/%.d
77    @echo "Compile $@ ($<)."
78    $(CXX) $(cxxflags) $(inc_path) -c $< -o $@
79
80$(tmp_path)/%.d: $(SRC_PATH)/%.cpp
81    @echo "Compile $@ ($<)."
82    $(CXX) $(cxxflags) -MM $< -o $@.$$$$; \
83    sed 's,$$*$\.o[ :]*,\1.o $@:, g' < $@.$$$$ > $@; \
84    rm -f $@.$$$$
85
86-include $(deps)
87
88clean:
89    $(RM) $(objs) $(deps) $(share_name) $(static_name) $(exe_name)

应用
这里假设有两个源码子目录netcomm和server，前者为动态库netcomm工程，后者为主程序server工程，它依赖netcomm库，每个目录下都有其自己的Makefile，这个用于编译单个模块或主程序，它们的父目录为src，在这个目录下有两个Makefile文件，一个是Makefile.in，这个就是上面讲到的通用内部Makefile；另一个是Makefile，这个用来联编所有的模块和主程序。
先来看下netcomm的Makefile文件内容，如下所示

1path := SRC_PATH=. OUT_PATH=../../output
2
3.PHONY: all debug release clean
4
5all: debug release
6
7debug:
8    $(MAKE) -f ../Makefile.in lib MODE=debug OUT_NAME=netcommd $(path)
9
10release:
11    $(MAKE) -f ../Makefile.in lib MODE=release OUT_NAME=netcomm $(path)
12
13clean:
14    $(MAKE) -f ../Makefile.in clean MODE=debug OUT_NAME=netcommd $(path)
15    $(MAKE) -f ../Makefile.in clean MODE=release OUT_NAME=netcomm $(path)

再看下server的Makefile文件内容，如下所示

1macros := MACROS="_USE_MEM_POOL=1"
2
3path := SRC_PATH=. OUT_PATH=../../output SHARE_PATH=../../output
4
5.PHONY: all debug release clean
6
7all: debug release
8
9debug:
10    $(MAKE) -f ../Makefile.in exe MODE=debug OUT_NAME=serverd SHARE_LIB="netcommd" $(macros) $(path)
11
12release:
13    $(MAKE) -f ../Makefile.in exe MODE=release OUT_NAME=server SHARE_LIB="netcomm" $(macros) $(path)
14
15clean:
16    $(MAKE) -f ../Makefile.in clean MODE=debug OUT_NAME=serverd $(path)
17    $(MAKE) -f ../Makefile.in clean MODE=release OUT_NAME=server $(path)

最后看下src的Makefile文件内容，如下所示

1.PHONY: all release debug clean
2
3all: debug release
4
5debug:
6    $(MAKE) debug -C netcomm
7    $(MAKE) debug -C server
8
9release:
10    $(MAKE) release -C netcomm
11    $(MAKE) release -C server
12
13clean:
14    $(MAKE) clean -C netcomm
15    $(MAKE) clean -C server

以上所有脚本代码，在make 3.81下测试通过。

春秋十二月 2012-08-16 19:29 发表评论

Shell应用（1）: 搜索文本的几种方法

春秋十二月 — Sat, 20 Aug 2011 11:46:00 GMT

方法1：使用find和xargs命令
     find dir | xargs grep str，dir是指某个目录
     find file | xargs grep str，file是指某个文件
   注意：这种方法，会递归搜索子目录

方法2：直接使用grep命令
     grep str dir/*，dir是指某个目录，但不递归搜索其子目录
     grep -r str dir/*，使用-r选项，递归搜索其子目录
     grep str file，file是指某个文件

方法3：综合以上两种，写一个shell脚本，代码如下

1#! /bin/bash
2# findstr.sh
3
4if [ $# -lt "2" ]; then
5   echo "Usage: `basename $0` path name [option]"
6   exit 1
7fi
8
9path=$1
10name=$2
11shift
12shift
13
14for option in "$@"
15do
16   case $option in
17   -r) dir_op="-r"
18   ;;
19   -i) lu_op="-i"
20   ;;
21   *) if [ -n "$option" ]; then
22         echo "invalid option"
23         exit 1
24       fi
25   ;;
26  esac
27done
28
29grep_str_of_file()
30{
31     file=$1
32     str=$2
33     out=$(grep -n $lu_op "$str" "$file")
34     if [ -n "$out" -a "$file" != "$0" ]; then
35        echo "$file: $out"
36     fi
37}
38
39find_str()
40{
41  if [ -d "$1" ]; then
42     for file in $1/*
43      do
44        if [ "$dir_op" = "-r" -a -d "$file" ]; then
45            find_str $file $2
46        elif [ -f "$file" ]; then
47           grep_str_of_file $file $2
48        fi
49     done
50 elif [ -f "$1" ]; then
51   grep_str_of_file $1 $2
52 fi
53}
54
55find_str $path $name

  这样一来，不管$1参数是目录还是文件，都能处理，使用示例如下：
    findstr /usr/include main          不递归搜索子目录，大小写敏感
    findstr /usr/include main -i       不递归搜索子目录，忽略大小写
    findstr /usr/include main -r       递归搜索子目录，大小写敏感
    findstr /usr/include main -r  -i   递归搜索子目录，忽略大小写
    findstr main.cpp main              在文件中搜索，大小写敏感
    findstr main.cpp main -i           在文件中搜索，忽略大小写

  上面所述的示例中，str不限于特定的文本，可以是带正则表达式的匹配模式。而第3种方法，也可以用sed替换grep来显示文本行，在此基础上能作更多的处理，比如格式化显示、统计匹配的文本个数、搜索策略等，在此就不详究了。

春秋十二月 2011-08-20 19:46 发表评论

C++博客-一年十二月 谁主春秋关注：基础系统工程 密码学 人工智能-随笔分类-System