本文主要分为3个部分
1. PHP内核、.php脚本的执行流程
2. PHP Zend扩展原理及编写方法
3. PHP API Hook技术

但和我们传统意义上写的C程序不同的是，PHP具有很多强大的功能:
　　1) 虚拟机的功能: 和软件加密中的VMP概念类似，PHP的语法可以看成是一种虚拟指令集，我们程序员在编写PHP脚本的时候其实就是在使用这种虚拟指令集进行代码逻辑、功能调用的编程。
　　　　同时PHP则提供了对这些虚拟指令的解析、翻译，并调用相应的底层代码去完成程序员的调用请求

　　2) 内存管理: 这里说的内存管理和操作系统层面的那个内存管理并不是一个概念。操作系统负责的是整个windows / linux 上全部应用的内存管理。而PHP的内存管理负责的是　　　　
　　　　2.1) 在每次请求的脚本的当前"运行空间(针对每个脚本而言都有自己的运行空间)"
　　　　2.2) 以及PHP内核
　　　　2.3) 扩展模块中的永久内存
　　这些方面的内存管理，对于PHP来说，内存管理是一个非常底层、非常重要的部分

　　3) 和服务器通信: PHP作为一个编译(这里的编译指的是编译为opcode的概念)、解释系统、同时提供虚拟运行时环境的C程序，它最重要的方面是能和服务器(WEB容器)进行通信，
　　　　要注意的是，这里所说的"服务器"是一个概念上的意义，PHP对与上层"服务器"的通信进行了抽象，把所有的逻辑都抽象、封装到了SAPI(server application programming 
　　　　interface)，对于上层的服务器来说，它们对PHP的调用就可以通过SAPI来进行，实现了"解耦和"。常见的调用SAPI方式有:
　　　　1) CGI:
　　　　CGI即通用网关接口(Common Gateway Interface)，它是一段程序, 通俗的讲CGI就象是一座桥，把网页和WEB服务器中的执行程序连接起来
　　　　每有一个用户请求，都会先要创建CGI的子进程，然后处理请求，处理完后结束这个子进程，这就是Fork-And-Execute模式
　　　　所以用CGI方式的服务器有多少连接请求就会有多少CGI子进程，子进程反复加载是CGI性能低下的主要原因
　　　　2) Fastcgi模式
　　　　FAST-CGI 是CGI的升级版本，FastCGI 像是一个常驻(Long-Live)型的CGI，它可以一直执行着，只要激活后，不会每次都要花费时间去Fork一次
　　　　(解决了 CGI 最为人诟病的 Fork-And-Execute 模式)
　　　　3) CLI模式
　　　　CLI是PHP的命令行运行模式
　　　　php -f script.php
　　　　4) 模块模式
　　　　模块模式是以mod_php5模块的形式集成，此时mod_php5模块的作用是接收Apache传递过来的PHP文件请求，并处理这些请求，然后将处理后的结果返回给Apache。
　　　　httpd.conf:
　　　　...
　　　　LoadModule php5_module "E:/wamp/bin/php/php5.4.12/php5apache2_4.dll"
　　　　...
　　　　如果我们在Apache启动前在其配置文件中配置好了PHP模块(mod_php5)，PHP模块通过注册apache2的ap_hook_post_config挂钩，在Apache启动的时候启动此模块以接受PHP文件
　　　　的请求。
　　所有这些调用方式，对PHP来说本质上都是一样的，PHP把它们都看成是来自"服务器"的调用。这种架构方式提供了很美丽的解耦和方式，同时，为PHP在不同操作系统、不同服务
　　器(WEB容器)上的跨平台操作提供了支持。

build: 和编译有关的目录
ext: 扩展库代码
例如 Mysql、zlib、iconv 等我们熟悉的扩展库。我们在程序中调用mysql_connect()这个函数就是因为在php.ini加入"extension=php_mysql.dll" 来加载php_mysql.dll这个扩展，
从而使我们在代码空间中可以使用mysql_connect()这个导出函数
main: 主目录，其中包含了:
　　1) php中最重要头文件php.h
　　2) 输入输出函数spprintf.h
　　3) 服务器抽象层SAPI.h
　　4) 内存管理alloca.c
　　5) 流式逻辑的实现\streams\..
　　..
pear: 这里是Pear核心文件。http://pear.php.net/
sapi: 各种服务器的接口调用，例如apache、IIS等，也包含一般的fastcgi、cgi等。PHP通过SAPI来封装对服务器通信的抽象
scripts: Linux 下的脚本目录
tests: 测试脚本目录，官方默认提供了一些基本的测试.php脚本供我们学习之用
win32: Windows 下编译 PHP 有关的脚本。在windows下编译PHP使用了WSH(windows script hosting)
Zend: 核心的引擎，zend是PHP的核心，它主要实现了:
    1) 把人类可以理解的脚本解析成机器可以理解的符号(token), 然后在一个进程空间内执行这些符号。
    2) ZE还负责内存管理
    3) 变量作用域
    4) 以及函数调用的调度

os: RedHat Linux Enterprice 5
kernal: 2.6.18-371.4.1.el5
php-version: php-5.5.9.tar.gz
http://cn2.php.net/downloads.php
make: GNU Make 3.81
gcc: gcc version 4.1.2 20080704 (Red Hat 4.1.2-54)

<?php
    $i = ‘Hello world!‘;
    echo $i;

1) C和汇编的关系(虽然不是很准确)
2) C#和CIL: Common Intermeditate Language中间语言的关系
3) java和JVM字节码的关系

1) 指令集(各种操作符)
2) 指令的格式和规范(由处理器指令规范规定)
3) 操作数
　　3.1) 显示的常量操作数
　　3.2) 保存在寄存器中的操作数
　　3.3) 保存在堆栈中的操作数
　　3.4) 保存在内存中的操作数
　　3.5) 保存在IO端口中的操作数
4) 保存指令、及相关信息的数据结构(struct _zend_op)(PHP这类虚拟机语言特有的)

<?php
　　echo 1;
?>

1) Zend启动引擎"词法"分析，将代码切分为一个个的标记Toekn，你可以用token_get_all()函数来查看PHP在这一步都做了什么
2) 使用"语法"分析器(注意和词法做区分)(PHP使用bison生成语法分析器，规则见$PHP_SRC/Zend/zend_language_parser.y)， bison根据规则进行相应的处理， 如果代码找不到匹配
　　的规则，也就是语法错误时Zend引擎会停止，并输出错误信息。 比如缺少括号，或者不符合语法规则的情况都会在这个环节检查
3) Zend引擎对这些Token进行编译， 将代码编译为opcode，并绑定相应的参数、和函数调用
4) Zend引擎执行这些opcode，在执行opcode的过程中还有可能会继续重复进行编译-执行，例如执行eval，include/require等语句，因为这些语句还会包含或者执行其他文件或者字符串中
　　的脚本
5) 总的来说，我们的脚本代码最终会以opcode的形式在Zend RunTime中出现，我们知道，opcode本质上是一些"虚拟机指令"，所以每一条opcode都对应着Zend中对应的一个函数调用，
　　即"opcode-Zend_Function"
6) Zend_Function就是在底层用C实现的一些代码逻辑，PHP的所有上层功能最终由底层的C来实现

array (size=7)
  0 => 
    array (size=3)
      0 => int 372
      1 => string ‘<?php ‘ (length=6)
      2 => int 1
  1 => 
    array (size=3)
      0 => int 316
      1 => string ‘echo‘ (length=4)
      2 => int 1
  2 => 
    array (size=3)
      0 => int 375
      1 => string ‘ ‘ (length=1)
      2 => int 1
  3 => 
    array (size=3)
      0 => int 305
      1 => string ‘1‘ (length=1)
      2 => int 1
  4 => string ‘;‘ (length=1)
  5 => 
    array (size=3)
      0 => int 375
      1 => string ‘ ‘ (length=1)
      2 => int 1
  6 => 
    array (size=3)
      0 => int 374
      1 => string ‘?>‘ (length=2)
      2 => int 1

struct _zend_op
{
    opcode_handler_t handler; // 执行该opcode时调用的处理函数
    znode result;
    znode op1;
    znode op2;
    ulong extended_value;
    uint lineno;
    zend_uchar opcode;  // opcode代码，我们可以根据这个opcode代码推测出它可能调用的Zend函数
};

void zend_do_echo(const znode *arg TSRMLS_DC)
{
    zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);  //首先通过get_next_op在当前的op_array的最后边"生成"一条opcode
  
    opline->opcode = ZEND_ECHO;  //opcode代码
    opline->op1 = *arg;     //绑定这个opcode需要的参数
    SET_UNUSED(opline->op2);
}

struct _zend_op_array
{
    /* Common elements */
    zend_uchar type;
    char *function_name;  // 如果是用户定义的函数则，这里将保存函数的名字
    zend_class_entry *scope;
    zend_uint fn_flags;
    union _zend_function *prototype;
    zend_uint num_args;
    zend_uint required_num_args;
    zend_arg_info *arg_info;
    zend_bool pass_rest_by_reference;
    unsigned char return_reference;
    /* END of common elements */
 
    zend_bool done_pass_two;
 
    zend_uint *refcount;
 
    zend_op *opcodes;  // opcode数组
 
    zend_uint last，size;
 
    zend_compiled_variable *vars;
    int last_var，size_var;
 
    // ...
}

ZEND_API void execute(zend_op_array *op_array TSRMLS_DC)
{
    // ... 循环执行op_array中的opcode或者执行其他op_array中的opcode
}

static int ZEND_FASTCALL  ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
{
    USE_OPLINE

    zval *z;

    SAVE_OPLINE();
    z = opline->op1.zv; //

    if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) 
    {
        INIT_PZVAL(z);
    }
    zend_print_variable(z);

    CHECK_EXCEPTION();
    ZEND_VM_NEXT_OPCODE();
}

Finding entry points
Branch analysis from position: 0
Return found
filename:       /var/www/html/index.php
function name:  (null)
number of ops:  4
compiled vars:  none
line     # *  op                           fetch          ext  return  operands
---------------------------------------------------------------------------------
   2     0  >   ECHO                                                     1
   5     1      ECHO                                                     ‘%0A‘
         2    > RETURN                                                   1
         3*   > HANDLE_EXCEPTION                                         

branch: #  0; line:     2-    5; sop:     0; eop:     3
path #1: 0, 
1

如果直接google"调试PHP代码"这几个字，搜索到的结果可能会让人产生歧义，这里其实是两个概念:
1) 单步调试脚本语言级别的PHP代码
...

关于对底层C代码的单步调试，我觉得有以下几点需要理解:
1) PHP在底层是用C实现的
2) PHP本质上是一个C程序(php.exe)，负责对脚本进行解释和执行
3) 所有的PHP脚本代码，都会被翻译为opcode，并对应于某个zend_funtion，所有我们对这个相应的zend_function进行下断点，就可以针对执行的PHP脚本代码，单步调试它对应的底层C代码

1) 编译个debug版本的PHP: 编译出的可执行程序会比较大，附带了调试信息
2) 用于单步调试PHP的IDE: 这里选用NetBeans，eclipse也是可以的

./configure --enable-debug

<?php
　　echo 1;
?>

1) 你编写了一个PHP脚本
2) 其中遇到一个PHP的特性不是很理解
3) 使用vld翻译为opcode
4) 根据opcode去推测、寻找(有时候不一定能准确地找到)这个语法对应的zend_function
5) 在指定的zend_function中下断点，从C的层面单步跟踪，帮助我们更好、更深入地理解问题的成因

一切的开始: SAPI接口
命令行程序和Web程序类似, 命令行参数传递给要执行的脚本,相当于通过url 请求一个PHP页面.。
PHP脚本完成执行后返回响应结果,只不过命令行响应的结果是显示在终端上，而WEB服务器的返回结果回传给浏览器。
脚本执行的开始都是通过SAPI接口进行的

1) 启动apache:
当给定的SAPI启动时，例如在对/usr/local/apache/bin/apachectl start的响应中，PHP从初始化其内核子系统开始。
在接近启动例程的末尾，它加载"每个"(逐一调用)扩展的代码并调用其模块初始化例程(MINIT)。这使得:
    1.1) 每个扩展可以初始化内部变量
    1.2) 分配资源
    1.3) 注册资源处理器
    1.4) 以及向ZE注册自己的函数，以便于脚本调用某个函数的时候这个函数的代码的入口地址在哪里

2) 请求初始化处理:
接下来，PHP等待SAPI层请求要处理的页面
    2.1) 对于CGI或CLI这种类型的SAPI来说，这将立刻发生且只发生一次
    2.2) 对于apache、IIS或其他WEB容器来说，每次远程用户请求页面(请求执行脚本)时都将发生，因此重复很多次，也可能并发。
不管请求如何产生，PHP要求ZE建立脚本的运行环境后再开始接受请求(PHP负责和WEB服务器的通信)。
在某个请求到达的时候，PHP会逐个调用"每个"扩展的请求初始化(RINIT)函数。RINIT使得扩展有机会:
    1) 设定特定的环境变量
    2) 根据请求分配资源
    3) 执行其他任务: 如审核
session扩展中有个RINIT作用的典型示例: 如果启用session.auto_start，RINIT将自动触发用户空间的session_start()函数以及"预组装"$_SESSION变量

3) 执行PHP代码:
一旦请求被初始化了，ZE开始接管控制权，将PHP脚本翻译成符号(Token)，最终形成操作码(Opcode)并逐步执行之。如果操作码中有涉及到扩展的调用，ZE将会把参数绑定到该函数，并且临时
交出控制权直到函数运行结束

4) 脚本结束:
每一次的脚本运行结束后，PHP会逐一调用"每个"扩展的请求关闭(RSHUTDOWN)函数以执行最后的清理工作(如将session变量存入磁盘)。接下来，ZE执行清理过程(垃圾收集): 即有效地对之前
的请求期间用到的每个变量执行unset()

5) SAPI关闭:
一旦完成，PHP继续等待SAPI的其他文档请求、或者关闭信号(对于CGI和CLI等SAPI，没有"下一个请求"，所以SAPI立刻开始关闭)。
关闭期间，PHP再次遍历每个扩展，调用其模块关闭(MSHUTDOWN)函数，并最终关闭自己的内核子系统

MINIT->RINIT->RSHUTDOWN->MSHUTDOWN

Zend 和PHP的关系
Zend 指的是语言引擎，PHP 指的是我们从外面看到的一套完整的系统。
为了实现一个 WEB 脚本的解释器，你需要完成以下三个部分的工作

1. 解释器部分，负责对输入代码的分析、翻译和执行: 
(zend: 100%)
    1.1 Zend 构成了语言的核心
    1.2 同时也包含了一些最基本的 PHP 预定义函数的实现
    1.3 将PHP脚本代码翻译为Token、以及将opcode翻译为对zend_function的调用
    1.4 提供opcode的虚拟机运行时runtime
    1.5 内存管理
也就是说，zend相当于真个整个程序的大架构，起核心作用

2. 功能性部分，负责具体实现语言的各种功能(比如它的函数等等): 
(zend: 50%、 php: 50%)
    2.1 IO管理
    2.2 流式输入输入Stream的实现

3. 接口部分，负责同 WEB 服务器的会话等功能: (php: 100%)
    3.1 实现SAPI，封装了PHP和上层WEB容器的通信
    3.2 包含了所有创造出语言本身各种显著特性的模块(也就是常说的module模块)
        3.2.1) xml
        3.2.2) mysql模块等
    PHP的"很多"(并不是全部)核心函数功能、代码逻辑的实现都依靠扩展来实现

以上3个部分，他们合起来称之为 PHP 包

HMODULE LoadLibrary(LPCTSTR lpFileName);
FARPROC GetProcAddress(HMODULE hModule, LPCWSTR lpProcName);
BOOL FreeLibrary(HMODULE hModule);

1. 修改php.ini，增加 extension=lib_name.so
2. 在代码中调用dl()函数，去动态地加载外部库文件

config.m4
PHP_ARG_ENABLE(hello, whether to enable Hello World support,
[ --enable-hello Enable Hello World support])

if test "$PHP_HELLO" = "yes"; then
    AC_DEFINE(HAVE_HELLO, 1, [Whether you have Hello World])
    PHP_NEW_EXTENSION(hello, hello.c, $ext_shared)
fi

php_hello.h
#ifndef PHP_HELLO_H
    #define PHP_HELLO_H 1
    #define PHP_HELLO_WORLD_VERSION "1.0"
    #define PHP_HELLO_WORLD_EXTNAME "hello"

    PHP_FUNCTION(hello_world);
    extern zend_module_entry hello_module_entry;
    #define phpext_hello_ptr &hello_module_entry
#endif

hello.c
#ifdef HAVE_CONFIG_H
    #include "config.h"
#endif

#include "php.h"
#include "php_hello.h"

static function_entry hello_functions[] = {
    PHP_FE(hello_world, NULL)
    {NULL, NULL, NULL}
};

zend_module_entry hello_module_entry = {
#if ZEND_MODULE_API_NO >= 20010901
    STANDARD_MODULE_HEADER,
#endif
    PHP_HELLO_WORLD_EXTNAME,
    hello_functions,
    NULL,
    NULL,
    NULL,
    NULL,
    NULL,
#if ZEND_MODULE_API_NO >= 20010901
    PHP_HELLO_WORLD_VERSION,
#endif
    STANDARD_MODULE_PROPERTIES
};

#ifdef COMPILE_DL_HELLO
    ZEND_GET_MODULE(hello)
#endif

PHP_FUNCTION(hello_world)
{
    //RETURN_STRING("Hello World", 1);
    char *arg = NULL;
    int arg_len, len;
    char *strg;
    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arg_len) == FAILURE) {
        return;
    }
    len = spprintf(&strg, 0, "Your input string: %s/n", arg);
    RETURN_STRINGL(strg, len, 0);
}

1) 对PHP中可能产生安全问题的函数进行Hook劫持，在代码执行的之前，先运行我们的"代码安全检测模块"，从而达到动态检测的目的
2) 该怎么实现API Hook的目的呢，我觉得有以下几种思路
　　2.1) 利用zend本身提供的函数回调机制对代码流进行Hook绑定
　　2.2) PHP中一定有一个数据结构存储的是所有函数的入口地址的(类似windows内核中的IDT一样)，我们找到这个"函数调用地址表"，然后修改其中某个函数的入口指针，修改为我们自己
　　　　　　定义的函数，这样，原本的函数调用就会先执行我们自定义的函数，然后我们再把控制权交回原本在这个位置的函数，完成Hook的效果