Crochets PHP

                                             

Hooks fournis par PHP

PHP et Zend Engine fournissent de nombreux hooks différents pour les extensions qui permettent aux développeurs d'extensions de contrôler le runtime PHP dans une manière que l'espace utilisateur PHP ne peut pas fournir.

Ce chapitre présentera divers hooks et leurs cas d'utilisation courants à partir de hooks d'extension.

Le modèle général pour se connecter aux fonctionnalités PHP consiste à étendre les pointeurs de fonction de remplacement fournis par le noyau PHP. La fonction d'extension effectue alors généralement son propre travail et appelle les fonctions principales de PHP d'origine. En utilisant ce modèle, différentes extensions peuvent remplacer le même hook sans provoquer de conflits.

Recommandations d'apprentissage associées : Programmation PHP de l'entrée à la maîtrise

Accrochage à l'exécution de fonctions

Le hook est défini dans

:Zend/zend_execute.h

ZEND_API extern void (*zend_execute_ex)(zend_execute_data *execute_data);ZEND_API extern void (*zend_execute_internal)(zend_execute_data *execute_data, zval *return_value);

Si vous souhaitez écraser ces pointeurs de fonction, vous devez le faire dans Minit car les autres décisions dans Zend Engine sont basées sur le fait que le pointeur est écrasé. Ce fait est fait à l'avance. Le modèle habituel pour la substitution

est le suivant :

static void (*original_zend_execute_ex) (zend_execute_data *execute_data);static void (*original_zend_execute_internal) (zend_execute_data *execute_data, zval *return_value);void my_execute_internal(zend_execute_data *execute_data, zval *return_value);void my_execute_ex (zend_execute_data *execute_data);PHP_MINIT_FUNCTION(my_extension){
    REGISTER_INI_ENTRIES();

    original_zend_execute_internal = zend_execute_internal;
    zend_execute_internal = my_execute_internal;

    original_zend_execute_ex = zend_execute_ex;
    zend_execute_ex = my_execute_ex;

    return SUCCESS;}PHP_MSHUTDOWN_FUNCTION(my_extension){
    zend_execute_internal = original_zend_execute_internal;
    zend_execute_ex = original_zend_execute_ex;

    return SUCCESS;}

Un inconvénient de la substitution

est qu'elle modifie le comportement du runtime de la machine virtuelle Zend pour utiliser la récursivité au lieu de laisser l'interpréteur gérer les appels. en cas de boucle. De plus, les moteurs PHP qui ne remplacent pas zend_execute_ex peuvent également générer des opcodes d'appel de fonction plus optimisés. zend_execute_ex

Ces hooks sont très sensibles aux performances, en fonction de la complexité du code d'encapsulation de la fonction d'origine.

Remplacer les fonctions internes

Lors du remplacement d'un hook d'exécution, l'extension peut enregistrer

chaque appel de fonction, vous pouvez également remplacer l'espace utilisateur, le noyau et l'individu pointeurs de fonction vers les fonctions d’extension (et méthodes). Il présente de meilleures caractéristiques de performances si l'extension n'a besoin que d'accéder à des appels de fonctions internes spécifiques.

#if PHP_VERSION_ID < 70200typedef void (*zif_handler)(INTERNAL_FUNCTION_PARAMETERS);#endif
zif_handler original_handler_var_dump;ZEND_NAMED_FUNCTION(my_overwrite_var_dump){
    // 如果我们想调用原始函数
    original_handler_var_dump(INTERNAL_FUNCTION_PARAM_PASSTHRU);}PHP_MINIT_FUNCTION(my_extension){
    zend_function *original;

    original = zend_hash_str_find_ptr(EG(function_table), "var_dump", sizeof("var_dump")-1);

    if (original != NULL) {
        original_handler_var_dump = original->internal_function.handler;
        original->internal_function.handler = my_overwrite_var_dump;
    }}

Lors de la substitution d'une méthode de classe, la table des fonctions se trouve sur

 : zend_class_entry

zend_class_entry *ce = zend_hash_str_find_ptr(CG(class_table), "PDO", sizeof("PDO")-1);if (ce != NULL) {
    original = zend_hash_str_find_ptr(&ce->function_table, "exec", sizeof("exec")-1);

    if (original != NULL) {
        original_handler_pdo_exec = original->internal_function.handler;
        original->internal_function.handler = my_overwrite_pdo_exec;
    }}

Modifier l'arbre de syntaxe abstraite (AST)

Lorsque PHP 7Lorsque le code PHP est compilé, il le convertit d'abord en un arbre de syntaxe abstraite (AST), puis génère enfin des opcodes qui sont conservés dans Opcache.

Le hook est appelé par chaque script compilé et vous permet de modifier l'AST après qu'il ait été analysé et créé. zend_ast_process

C'est l'un des hooks les plus complexes à utiliser car il nécessite une connaissance complète de l'AST. La création d'un AST non valide ici peut provoquer un comportement inattendu ou des plantages.

Mieux vaut jeter un œil à un exemple d'extension qui utilise ce hook :

Extension du débogueur PHP Google Stackdriver
• Une preuve de concept avec AST basée sur Stackdriver

Compilation de scripts/fichiers familiers

Chaque fois qu'un script utilisateur appelle

/include ou son require/include_once correspondant, PHP Le le noyau traitera cette requête au pointeur require_once. Le paramètre est un descripteur de fichier et le résultat est zend_compile_file处调用该函数. zend_op_array

zend_op_array * my_extension_compile_file(zend_file_handle * file_handle，int类型);

Il existe deux extensions dans le noyau PHP qui implémentent ce hook : dtrace et opcache.

-

est utilisé pour USE_ZEND_DTRACE si vous lancez votre script PHP en utilisant la variable d'environnement dtrace_compile_file et que PHP compilé avec le support dtrace. Zend / zend_dtrace.c - Opcache stocke le tableau d'opérations dans la mémoire partagée pour de meilleures performances. Ainsi, chaque fois qu'un script est compilé, son tableau d'opérations final est servi à partir du cache plutôt que recompilé. Vous pouvez trouver cette implémentation dans
. ext / opcache / ZendAccelerator.c - L'implémentation par défaut nommée
fait partie du code du scanner dans compile_file. Zend / zend_language_scanner.l

Les cas d'utilisation pour l'implémentation de ce hook sont l'accélération d'Opcode, le cryptage/déchiffrement de code PHP, le débogage ou le profilage.

Vous pouvez remplacer ce hook à tout moment pendant l'exécution du processus PHP, et tous les scripts PHP compilés après le remplacement seront gérés par l'implémentation du hook.

Il est très important de toujours appeler le pointeur de fonction brut, sinon PHP ne pourra plus compiler le script et Opcache ne fonctionnera plus.

此处的扩展覆盖顺序也很重要，因为您需要知道是要在Opcache之前还是之后注册钩子，因为Opcache如果在其共享内存缓存中找到操作码数组条目，则不会调用原始函数指针。 Opcache将其钩子注册为启动后钩子，该钩子在扩展的minit阶段之后运行，因此默认情况下，缓存脚本时将不再调用该钩子。

调用错误处理程序时的通知

与PHP用户区set_error_handler()函数类似，扩展可以通过实现zend_error_cb钩子将自身注册为错误处理程序：

ZEND_API void(* zend_error_cb)(int类型，const char * error_filename，const uint32_t error_lineno，const char * format，va_list args);

type变量对应于E _ *错误常量，该常量在PHP用户区中也可用。

PHP核心和用户态错误处理程序之间的关系很复杂：

1.如果未注册任何用户级错误处理程序，则始终调用zend_error_cb。
2.如果注册了userland错误处理程序，则对于E_ERROR，E_PARSE，E_CORE_ERROR，E_CORE_WARNING，E_COMPILE_ERROR的所有错误和E_COMPILE_WARNING始终调用zend_error_cb挂钩。
3.对于所有其他错误，仅在用户态处理程序失败或返回false时调用zend_error_cb。

另外，由于Xdebug自身复杂的实现，它以不调用以前注册的内部处理程序的方式覆盖错误处理程序。

因此，覆盖此挂钩不是很可靠。

再次覆盖应该以尊重原始处理程序的方式进行，除非您想完全替换它：

void(* original_zend_error_cb)(int类型，const char * error_filename，const uint error_lineno，const char * format，va_list args);void my_error_cb(int类型，const char * error_filename，const uint error_lineno，const char * format，va_list args){
    //我的特殊错误处理

    original_zend_error_cb(type，error_filename，error_lineno，format，args);}PHP_MINIT_FUNCTION(my_extension){
    original_zend_error_cb = zend_error_cb;
    zend_error_cb = my_error_cb;

    return SUCCESS;}PHP_MSHUTDOWN(my_extension){
    zend_error_cb = original_zend_error_cb;}

该挂钩主要用于为异常跟踪或应用程序性能管理软件实施集中式异常跟踪。

引发异常时的通知

每当PHP Core或Userland代码引发异常时，都会调用zend_throw_exception_hook并将异常作为参数。

这个钩子的签名非常简单：

void my_throw_exception_hook(zval * exception){
    if(original_zend_throw_exception_hook！= NULL){
        original_zend_throw_exception_hook(exception);
    }}

该挂钩没有默认实现，如果未被扩展覆盖，则指向NULL。

static void(* original_zend_throw_exception_hook)(zval * ex);void my_throw_exception_hook(zval * exception);PHP_MINIT_FUNCTION(my_extension){
    original_zend_throw_exception_hook = zend_throw_exception_hook;
    zend_throw_exception_hook = my_throw_exception_hook;

    return SUCCESS;}

如果实现此挂钩，请注意无论是否捕获到异常，都会调用此挂钩。将异常临时存储在此处，然后将其与错误处理程序挂钩的实现结合起来以检查异常是否未被捕获并导致脚本停止，仍然有用。

实现此挂钩的用例包括调试，日志记录和异常跟踪。

挂接到eval()

PHPeval不是内部函数，而是一种特殊的语言构造。因此，您无法通过zend_execute_internal或通过覆盖其函数指针来连接它。

挂钩到eval的用例并不多，您可以将其用于概要分析或出于安全目的。如果更改其行为，请注意可能需要评估其他扩展名。一个示例是Xdebug，它使用它执行断点条件。

extern ZEND_API zend_op_array *(* zend_compile_string)(zval * source_string，char * filename);

挂入垃圾收集器

当可收集对象的数量达到一定阈值时，引擎本身会调用gc_collect_cycles()或隐式地触发PHP垃圾收集器。

为了使您了解垃圾收集器的工作方式或分析其性能，可以覆盖执行垃圾收集操作的函数指针挂钩。从理论上讲，您可以在此处实现自己的垃圾收集算法，但是如果有必要对引擎进行其他更改，则这可能实际上并不可行。

int(* original_gc_collect_cycles)(无效);int my_gc_collect_cycles(无效){
    original_gc_collect_cycles();}PHP_MINIT_FUNCTION(my_extension){
    original_gc_collect_cycles = gc_collect_cycles;
    gc_collect_cycles = my_gc_collect_cycles;

    return SUCCESS;}

覆盖中断处理程序

当执行器全局EG(vm_interrupt)设置为1时，将调用一次中断处理程序。在执行用户域代码期间，将在常规检查点对它进行检查。引擎使用此挂钩通过信号处理程序实现PHP执行超时，该信号处理程序在达到超时持续时间后将中断设置为1。

当更安全地清理或实现自己的超时处理时，这有助于将信号处理推迟到运行时执行的后期。通过设置此挂钩，您不会意外禁用PHP的超时检查，因为它具有自定义处理的优先级，该优先级高于对zend_interrupt_function的任何覆盖。

ZEND_API void(* original_interrupt_function)(zend_execute_data * execute_data);void my_interrupt_function(zend_execute_data * execute_data){
    if(original_interrupt_function！= NULL){
        original_interrupt_function(execute_data);
    }}PHP_MINIT_FUNCTION(my_extension){
    original_interrupt_function = zend_interrupt_function;
    zend_interrupt_function = my_interrupt_function;

    return SUCCESS;}

##替换操作码处理程序

TODO

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!