当前位置：Gxlcms > PHP教程 > [翻译][php扩展开发和嵌入式]第15章-php中流的实现

[翻译][php扩展开发和嵌入式]第15章-php中流的实现

时间：2021-07-01 10:21:17 帮助过：4人阅读

实现流

php的流最强力的特性之一是它可以访问众多数据源: 普通文件, 压缩文件, 网络透明通道, 加密网络, 命名管道以及域套接字, 它们对于用户空间以及内部都是统一的API.

php流的表象之下

对于给定的流实例, 比如文件流和网络流, 它们的不同在于上一章你使用的流创建函数返回的php_stream结构体中的ops成员.

  1. typedef struct _php_stream {
  2.     ...
  3.     php_stream_ops *ops;
  4.     ...
  5. } php_stream;

php_stream_ops结构体定义的是一个函数指针集合以及一个描述标记.

  1. typedef struct _php_stream_ops {
  2.     size_t (*write)(php_stream *stream, const char *buf,
  3.                             size_t count TSRMLS_DC);
  4.     size_t (*read)(php_stream *stream, char *buf,
  5.                             size_t count TSRMLS_DC);
  6.     int    (*close)(php_stream *stream, int close_handle
  7.                             TSRMLS_DC);
  8.     int    (*flush)(php_stream *stream TSRMLS_DC);
  9.     const char *label;
  10.     int (*seek)(php_stream *stream, off_t offset, int whence,
  11.                             off_t *newoffset TSRMLS_DC);
  12.     int (*cast)(php_stream *stream, int castas, void **ret
  13.                             TSRMLS_DC);
  14.     int (*stat)(php_stream *stream, php_stream_statbuf *ssb
  15.                             TSRMLS_DC);
  16.     int (*set_option)(php_stream *stream, int option,int value,
  17.                             void *ptrparam TSRMLS_DC);
  18. } php_stream_ops;

当流访问函数比如php_stream_read()被调用时, 流包装层实际上解析调用了stream->ops中对应的函数, 这样实际调用的就是当前流类型特有的read实现. 比如, 普通文件的流ops结构体中的read函数实现如下(实际的该实现比下面的示例复杂一点):

  1. size_t php_stdio_read(php_stream *stream, char *buf,
  2.                                 size_t count TSRMLS_DC)
  3. {
  4.     php_stdio_stream_data *data =
  5.                 (php_stdio_stream_data*)stream->abstract;
  6.     return read(data->fd, buf, count);
  7. }

而compress.zlib流使用的ops结构体中则read则指向的是如下的函数:

  1. size_t php_zlib_read(php_stream *stream, char *buf,
  2.                                 size_t count TSRMLS_DC)
  3. {
  4.     struct php_gz_stream_data_t *data =
  5.             (struct php_gz_stream_data_t *) stream->abstract;
  6.     return gzread(data->gz_file, buf, count);
  7. }

这里第一点需要注意的是ops结构体指向的函数指针常常是对数据源真正的读取函数的一个瘦代理. 在上面两个例子中, 标准I/O流使用posix的read()函数, 而zlib流使用的是libz的gzread()函数.

你可能还注意到了, 这里使用了stream->abstract元素. 这是流实现的一个便利指针, 它可以被用于获取各种相关的捆绑信息. 在上面的例子中, 指向自定义结构体的指针, 用于存储底层read函数要使用的文件描述符.

还有一件你可能注意到的事情是php_stream_ops结构体中的每个函数都期望一个已有的流实例, 但是怎样得到实例呢? abstract成员是怎样设置的以及什么时候流指示使用哪个ops结构体? 答案就在你在上一章使用过的第一个打开流的函数(php_stream_open_wrapper())中.

当这个函数被调用时, php的流包装层尝试基于传递的URL中的scheme://部分确定请求的是什么协议. 这样它就可以在已注册的php包装器中查找对应的php_stream_wrapper项. 每个php_stream_wrapper结构体都可以取到自己的ops元素, 它指向一个php_stream_wrapper_ops结构体:

  1. typedef struct _php_stream_wrapper_ops {
  2.     php_stream *(*stream_opener)(php_stream_wrapper *wrapper,
  3.                         char *filename, char *mode,
  4.                         int options, char **opened_path,
  5.                         php_stream_context *context
  6.                         STREAMS_DC TSRMLS_DC);
  7.     int (*stream_closer)(php_stream_wrapper *wrapper,
  8.                         php_stream *stream TSRMLS_DC);
  9.     int (*stream_stat)(php_stream_wrapper *wrapper,
  10.                         php_stream *stream,
  11.                         php_stream_statbuf *ssb
  12.                         TSRMLS_DC);
  13.     int (*url_stat)(php_stream_wrapper *wrapper,
  14.                         char *url, int flags,
  15.                         php_stream_statbuf *ssb,
  16.                         php_stream_context *context
  17.                         TSRMLS_DC);
  18.     php_stream *(*dir_opener)(php_stream_wrapper *wrapper,
  19.                         char *filename, char *mode,
  20.                         int options, char **opened_path,
  21.                         php_stream_context *context
  22.                         STREAMS_DC TSRMLS_DC);
  23.     const char *label;
  24.     int (*unlink)(php_stream_wrapper *wrapper, char *url,
  25.                         int options,
  26.                         php_stream_context *context
  27.                         TSRMLS_DC);
  28.     int (*rename)(php_stream_wrapper *wrapper,
  29.                         char *url_from, char *url_to,
  30.                         int options,
  31.                         php_stream_context *context
  32.                         TSRMLS_DC);
  33.     int (*stream_mkdir)(php_stream_wrapper *wrapper,
  34.                         char *url, int mode, int options,
  35.                         php_stream_context *context
  36.                         TSRMLS_DC);
  37.     int (*stream_rmdir)(php_stream_wrapper *wrapper, char *url,
  38.                         int options,
  39.                         php_stream_context *context
  40.                         TSRMLS_DC);
  41. } php_stream_wrapper_ops;

这里, 流包装层调用wrapper->ops->stream_opener(), 它将执行包装器特有的操作创建流实例, 赋值恰当的php_stream_ops结构体, 绑定相关的抽象数据.

dir_opener()函数和stream_opener()提供相同的基础服务; 不过, 它是对php_stream_opendir()这个API调用的响应, 并且通常会绑定一个不同的php_stream_ops结构体到返回的实例. stat()和close()函数在这一层上是重复的, 这样做是为了给包装器的这些操作增加协议特有的逻辑.

其他的函数则允许执行静态流操作而不用实际的创建流实例. 回顾这些流API调用, 它们并不实际返回php_stream对象, 你马上就会看到它们的细节.

尽管在php 4.3中引入流包装层时, url_stat在内部作为一个包装器的ops函数存在, 但直到php 5.0它才开始被使用. 此外, 最后的3个函数, rename(), stream_mkdir()以及stream_rmdir()一直到php 5.0才引入, 在这个版本之前, 它们并不在包装器的ops结构中.

包装器操作

除了url_stat()函数, 包装器操作中在const char *label元素之前的每个操作都可以用于激活的流实例上. 每个函数的意义如下:

stream_opener()实例化一个流实例. 当某个用户空间的fopen()函数被调用时, 这个函

数将被调用. 这个函数返回的php_stream实例是fopen()函数返回的

文件资源句柄的内部表示. 集成函数比如file(), file_get_contents(),

file_put_contents(), readfile()等等, 在请求包装资源时, 都使用这个包

装器ops.

stream_closer()当一个流实例结束其生命周期时这个函数被调用. stream_opener()时

分配的所有资源都应该在这个函数中被释放.

stream_stat()类似于用户空间的fstat()函数, 这个函数应该填充ssb结构体(实际上

只包含一个struct statbuf sb结构体成员),

dir_opener()和stream_opener()行为一致, 不过它是调用opendir()一族的用户空间

函数时被调用的. 目录流使用的底层流实现和文件流遵循相同的规则;

不过目录流只需要返回包含在打开的目录中找到的文件名的记录, 它

的大小为struct dirent这个结构体的大小.

静态包装器操作

包装器操作函数中的其他函数是在URI路径上执行原子操作, 具体取决于包装器协议. 在php4.3的php_stream_wrapper_ops结构体中只有url_stat()和unlink(); 其他的方式是到php 5.0后才定义的, 编码时应该适时的使用#ifdef块说明.

url_stat()stat()族函数使用, 返回文件元数据, 比如访问授权, 大小, 类型; 以及

访问, 修改,创建时间. 尽管这个函数是在php 4.3引入流包装层时出现

在php_stream_wrapper_ops结构体中的, 但直到php 5.0才被用户空

间的stat()函数使用.

unlink()和posix文件系统的同名函数语义相同, 它执行文件删除. 如果对于当

前的包装器删除没有意义, 比如内建的http://包装器, 这个函数应该被

定义为NULL, 以便内核去引发适当的错误消息.

rename()当用户空间的rename()函数的参数$from和$to参数指向的是相同的

底层包装器实现, php则将这个重命名请求分发到包装器的rename函

数.

mkdir() & rmdir()这两个函数直接映射到对应的用户空间函数.

实现一个包装器

为了演示包装器和流操作的内部工作原理, 我们需要重新实现php手册的stream_wrapper_register()一页示例中的var://包装器.

此刻, 首先从下面功能完整的变量流包装实现开始. 构建他, 并开始检查每一块的工作原理.

译注: 为了方便大家阅读, 对代码的注释进行了适量补充调整, 此外, 由于phpapi的调整, 原著中的代码不能直接在译者使用的php-5.4.10中运行, 进行了适当的修改. 因此下面代码结构可能和原著略有不同, 请参考阅读.(下面opendir的例子也进行了相应的修改)

config.m4

  1. PHP_ARG_ENABLE(varstream,whether to enable varstream support,
  2. [  enable-varstream      Enable varstream support])
  3. if test "$PHP_VARSTREAM" = "yes"; then
  4.   AC_DEFINE(HAVE_VARSTREAM,1,[Whether you want varstream])
  5.   PHP_NEW_EXTENSION(varstream, varstream.c, $ext_shared)
  6. fi

php_varstream.h

  1. #ifndef PHP_VARSTREAM_H
  2. #define PHP_VARSTREAM_H
  3. extern zend_module_entry varstream_module_entry;
  4. #define phpext_varstream_ptr &varstream_module_entry
  5. #ifdef PHP_WIN32
  6. #   define PHP_VARSTREAM_API __declspec(dllexport)
  7. #elif defined(__GNUC__) && __GNUC__ >= 4
  8. #   define PHP_VARSTREAM_API __attribute__ ((visibility("default")))
  9. #else
  10. #   define PHP_VARSTREAM_API
  11. #endif
  12. #ifdef ZTS
  13. #include "TSRM.h"
  14. #endif
  15. PHP_MINIT_FUNCTION(varstream);
  16. PHP_MSHUTDOWN_FUNCTION(varstream);
  17. #define PHP_VARSTREAM_WRAPPER       "var"
  18. #define PHP_VARSTREAM_STREAMTYPE    "varstream"
  19. /* 变量流的抽象数据结构 */
  20. typedef struct _php_varstream_data {
  21.     off_t   position;
  22.     char    *varname;
  23.     int     varname_len;
  24. } php_varstream_data;
  25. #ifdef ZTS
  26. #define VARSTREAM_G(v) TSRMG(varstream_globals_id, zend_varstream_globals *, v)
  27. #else
  28. #define VARSTREAM_G(v) (varstream_globals.v)
  29. #endif
  30. #endif

varstream.c

  1. #ifdef HAVE_CONFIG_H
  2. #include "config.h"
  3. #endif
  4. #include "php.h"
  5. #include "php_ini.h"
  6. #include "ext/standard/info.h"
  7. #include "ext/standard/url.h"
  8. #include "php_varstream.h"
  9. static size_t php_varstream_write(php_stream *stream,
  10.                 const char *buf, size_t count TSRMLS_DC)
  11. {
  12.     php_varstream_data *data = stream->abstract;
  13.     zval **var;
  14.     size_t newlen;
  15.     /* 查找变量 */
  16.     if (zend_hash_find(&EG(symbol_table), data->varname,
  17.             data->varname_len + 1,(void**)&var) == FAILURE) {
  18.         /* 变量不存在, 直接创建一个字符串类型的变量, 并保存新传递进来的内容 */
  19.        zval *newval;
  20.        MAKE_STD_ZVAL(newval);
  21.        ZVAL_STRINGL(newval, buf, count, 1); 
  22.        /* 将新的zval *放到变量中 */
  23.        zend_hash_add(&EG(symbol_table), data->varname,
  24.            data->varname_len + 1, (void*)&newval,
  25.            sizeof(zval*), NULL);
  26.        return count;
  27.     }   
  28.     /* 如果需要, 让变量可写. 这里实际上处理的是写时复制 */
  29.     SEPARATE_ZVAL_IF_NOT_REF(var);
  30.     /* 转换为字符串类型 */
  31.     convert_to_string_ex(var);
  32.     /* 重置偏移量(译注: 相比于正常的文件系统, 这里的处理实际上不支持文件末尾的空洞创建, 读者如果熟悉*nix文件系统, 应该了解译者所说, 否则请略过) */
  33.     if (data->position > Z_STRLEN_PP(var)) {
  34.         data->position = Z_STRLEN_PP(var);
  35.     }   
  36.     /* 计算新的字符串长度 */
  37.     newlen = data->position + count;
  38.     if (newlen < Z_STRLEN_PP(var)) {
  39.         /* 总长度不变 */
  40.         newlen = Z_STRLEN_PP(var);
  41.     } else if (newlen > Z_STRLEN_PP(var)) {
  42.         /* 重新调整缓冲区大小以保存新内容 */
  43.         Z_STRVAL_PP(var) =erealloc(Z_STRVAL_PP(var),newlen+1);
  44.         /* 更新字符串长度 */
  45.         Z_STRLEN_PP(var) = newlen;
  46.         /* 确保字符串NULL终止 */
  47.         Z_STRVAL_PP(var)[newlen] = 0;
  48.     }   
  49.     /* 将数据写入到变量中 */
  50.     memcpy(Z_STRVAL_PP(var) + data->position, buf, count);
  51.     data->position += count;
  52.     return count;
  53. }
  54. static size_t php_varstream_read(php_stream *stream,
  55.                 char *buf, size_t count TSRMLS_DC)
  56. {
  57.     php_varstream_data *data = stream->abstract;
  58.     zval **var, copyval;
  59.     int got_copied = 0;
  60.     size_t toread = count;
  61.     if (zend_hash_find(&EG(symbol_table), data->varname,
  62.         data->varname_len + 1, (void**)&var) == FAILURE) {
  63.         /* 变量不存在, 读不到数据, 返回0字节长度 */
  64.         return 0;
  65.     }   
  66.     copyval = **var;
  67.     if (Z_TYPE(copyval) != IS_STRING) {
  68.         /* 对于非字符串类型变量, 创建一个副本进行读, 这样对于只读的变量, 就不会改变其原始类型 */
  69.         zval_copy_ctor(©val);
  70.         INIT_PZVAL(©val);
  71.         got_copied = 1;
  72.     }   
  73.     if (data->position > Z_STRLEN(copyval)) {
  74.         data->position = Z_STRLEN(copyval);
  75.     }   
  76.     if ((Z_STRLEN(copyval) - data->position) < toread) {
  77.         /* 防止读取到变量可用缓冲区外的内容 */
  78.         toread = Z_STRLEN(copyval) - data->position;
  79.     }   
  80.     /* 设置缓冲区 */
  81.     memcpy(buf, Z_STRVAL(copyval) + data->position, toread);
  82.     data->position += toread;
  83.     /* 如果创建了副本, 则释放副本 */
  84.     if (got_copied) {
  85.         zval_dtor(©val);
  86.     }   
  87.     /* 返回设置到缓冲区的字节数 */
  88.     return toread;
  89. }
  90. static int php_varstream_closer(php_stream *stream,
  91.                             int close_handle TSRMLS_DC)
  92. {
  93.     php_varstream_data *data = stream->abstract;
  94.     /* 释放内部结构避免泄露 */
  95.     efree(data->varname);
  96.     efree(data);
  97.     return 0;
  98. }
  99. static int php_varstream_flush(php_stream *stream TSRMLS_DC)
  100. {
  101.     php_varstream_data *data = stream->abstract;
  102.     zval **var;
  103.     /* 根据不同情况, 重置偏移量 */
  104.     if (zend_hash_find(&EG(symbol_table), data->varname,
  105.                     data->varname_len + 1, (void**)&var)
  106.                     == SUCCESS) {
  107.         if (Z_TYPE_PP(var) == IS_STRING) {
  108.             data->position = Z_STRLEN_PP(var);
  109.         } else {
  110.             zval copyval = **var;
  111.             zval_copy_ctor(©val);
  112.             convert_to_string(©val);
  113.             data->position = Z_STRLEN(copyval);
  114.             zval_dtor(©val);
  115.         }
  116.     } else {
  117.         data->position = 0;
  118.     }
  119.     return 0;
  120. }
  121. static int php_varstream_seek(php_stream *stream, off_t offset,
  122.                     int whence, off_t *newoffset TSRMLS_DC)
  123. {
  124.     php_varstream_data *data = stream->abstract;
  125.     switch (whence) {
  126.         case SEEK_SET:
  127.             data->position = offset;
  128.             break;
  129.         case SEEK_CUR:
  130.             data->position += offset;
  131.             break;
  132.         case SEEK_END:
  133.         {
  134.             zval **var;
  135.            size_t curlen = 0;
  136.            if (zend_hash_find(&EG(symbol_table),
  137.                    data->varname,    data->varname_len + 1,
  138.                    (void**)&var) == SUCCESS) {
  139.               if (Z_TYPE_PP(var) == IS_STRING) {
  140.                   curlen = Z_STRLEN_PP(var);
  141.               } else {
  142.                   zval copyval = **var;
  143.                   zval_copy_ctor(©val);
  144.                   convert_to_string(©val);
  145.                   curlen = Z_STRLEN(copyval);
  146.                   zval_dtor(©val);
  147.               }
  148.            }
  149.            data->position = curlen + offset;
  150.            break;
  151.        }
  152.     }
  153.     /* 防止随机访问指针移动到缓冲区开始位置之前 */
  154.     if (data->position < 0) {
  155.         data->position = 0;
  156.     }
  157.     if (newoffset) {
  158.         *newoffset = data->position;
  159.     }
  160.     return 0;
  161. }
  162. static php_stream_ops php_varstream_ops = {
  163.     php_varstream_write,
  164.     php_varstream_read,
  165.     php_varstream_closer,
  166.     php_varstream_flush,
  167.     PHP_VARSTREAM_STREAMTYPE,
  168.     php_varstream_seek,
  169.     NULL, /* cast */
  170.     NULL, /* stat */
  171.     NULL, /* set_option */
  172. };
  173. /* Define the wrapper operations */
  174. static php_stream *php_varstream_opener(
  175.             php_stream_wrapper *wrapper,
  176.             char *filename, char *mode, int options,
  177.             char **opened_path, php_stream_context *context
  178.             STREAMS_DC TSRMLS_DC)
  179. {
  180.     php_varstream_data *data;
  181.     php_url *url;
  182.     if (options & STREAM_OPEN_PERSISTENT) {
  183.         /* 按照变量流的定义, 是不能持久化的
  184.          * 因为变量在请求结束后将被释放
  185.          */
  186.         php_stream_wrapper_log_error(wrapper, options
  187.             TSRMLS_CC, "Unable to open %s persistently",
  188.                                         filename);
  189.         return NULL;
  190.     }
  191.     /* 标准URL解析: scheme://user:pass@host:port/path?query#fragment */
  192.     url = php_url_parse(filename);
  193.     if (!url) {
  194.         php_stream_wrapper_log_error(wrapper, options
  195.             TSRMLS_CC, "Unexpected error parsing URL");
  196.         return NULL;
  197.     }
  198.     /* 检查是否有变量流URL必须的元素host, 以及scheme是否是var */
  199.     if (!url->host || (url->host[0] == 0) ||
  200.         strcasecmp("var", url->scheme) != 0) {
  201.         /* Bad URL or wrong wrapper */
  202.         php_stream_wrapper_log_error(wrapper, options
  203.             TSRMLS_CC, "Invalid URL, must be in the form: "
  204.                      "var://variablename");
  205.         php_url_free(url);
  206.         return NULL;
  207.     }
  208.     /* 创建一个数据结构保存协议信息(变量流协议重要是变量名, 变量名长度, 当前偏移量) */
  209.     data = emalloc(sizeof(php_varstream_data));
  210.     data->position = 0;
  211.     data->varname_len = strlen(url->host);
  212.     data->varname = estrndup(url->host, data->varname_len + 1);
  213.     /* 释放前面解析出来的url占用的内存 */
  214.     php_url_free(url);
  215.     /* 实例化一个流, 为其赋予恰当的流ops, 绑定抽象数据 */
  216.     return php_stream_alloc(&php_varstream_ops, data, 0, mode);
  217. }
  218. static php_stream_wrapper_ops php_varstream_wrapper_ops = {
  219.     php_varstream_opener, /* 调用php_stream_open_wrapper(sprintf("%s://xxx", PHP_VARSTREAM_WRAPPER))时执行 */
  220.     NULL, /* stream_close */
  221.     NULL, /* stream_stat */
  222.     NULL, /* url_stat */
  223.     NULL, /* dir_opener */
  224.     PHP_VARSTREAM_WRAPPER,
  225.     NULL, /* unlink */
  226. #if PHP_MAJOR_VERSION >= 5
  227.     /* PHP >= 5.0 only */
  228.     NULL, /* rename */
  229.     NULL, /* mkdir */
  230.     NULL, /* rmdir */
  231. #endif
  232. };
  233. static php_stream_wrapper php_varstream_wrapper = {
  234.     &php_varstream_wrapper_ops,
  235.     NULL, /* abstract */
  236.     0, /* is_url */
  237. };
  238. PHP_MINIT_FUNCTION(varstream)
  239. {
  240.     /* 注册流包装器:
  241.      * 1. 检查流包装器名字是否正确(符合这个正则: /^[a-zA-Z0-9+.-]+$/)
  242.      * 2. 将传入的php_varstream_wrapper增加到url_stream_wrappers_hash这个HashTable中, key为PHP_VARSTREAM_WRAPPER
  243.      */
  244.     if (php_register_url_stream_wrapper(PHP_VARSTREAM_WRAPPER,
  245.             &php_varstream_wrapper TSRMLS_CC)==FAILURE) {
  246.         return FAILURE;
  247.     }
  248.     return SUCCESS;
  249. }
  250. PHP_MSHUTDOWN_FUNCTION(varstream)
  251. {
  252.     /* 卸载流包装器: 从url_stream_wrappers_hash中删除 */
  253.     if (php_unregister_url_stream_wrapper(PHP_VARSTREAM_WRAPPER
  254.                                 TSRMLS_CC) == FAILURE) {
  255.         return FAILURE;
  256.     }
  257.     return SUCCESS;
  258. }
  259. zend_module_entry varstream_module_entry = {
  260. #if ZEND_MODULE_API_NO >= 20010901
  261.     STANDARD_MODULE_HEADER,
  262. #endif
  263.     "varstream",
  264.     NULL,
  265.     PHP_MINIT(varstream),
  266.     PHP_MSHUTDOWN(varstream),
  267.     NULL,
  268.     NULL,
  269.     NULL,
  270. #if ZEND_MODULE_API_NO >= 20010901
  271.     "0.1",
  272. #endif
  273.     STANDARD_MODULE_PROPERTIES
  274. };
  275. #ifdef COMPILE_DL_VARSTREAM
  276. ZEND_GET_MODULE(varstream)
  277. #endif

在构建加载扩展后, php就可以处理以var://开始的URL的请求, 它的行为和手册中用户空间实现的行为一致.

内部实现

首先你注意到的可能是这个扩展完全没有暴露用户空间函数. 它所做的只是在MINIT函数中调用了一个核心PHPAPI的钩子, 将var协议和我们定义的包装器关联起来:

  1. static php_stream_wrapper php_varstream_wrapper = {
  2.     &php_varstream_wrapper_ops,
  3.     NULL, /* abstract */
  4.     0, /* is_url */
  5. }

很明显, 最重要的元素就是ops, 它提供了访问特定流包装器的创建以及检查函数. 你可以安全的忽略abstract属性, 它仅在运行时使用, 在初始化定义时, 它只是作为一个占位符. 第三个元素is_url, 它告诉php在使用这个包装器时是否考虑php.ini中的allow_url_fopen选项. 如果这个值非0, 并且将allow_url_fopen设置为false, 则这个包装器不能被脚本使用.

在本章前面你已经知道, 调用用户空间函数比如fopen将通过这个包装器的ops元素得到php_varstream_wrapper_ops, 这样去调用流的打开函数php_varstream_opener.

这个函数的第一块代码检查是否请求持久化的流:

  1. if (options & STREAM_OPEN_PERSISTENT) {

对于很多包装器这样的请求是合法的. 然而目前的情况这个行为没有意义. 一方面用户空间变量的定义就是临时的, 另一方面, varstream的实例化代价很低, 这就使得持久化的优势很小.

像流包装层报告错误很简单, 只需要返回一个NULL值而不是流实例即可. 流包装层透出到用户空间的失败消息并不会说明具体的错误, 只是说明不能打开URL. 要想给开发者暴露更多的错误信息, 可以在返回之前使用php_stream_wrapper_log_error()函数.

  1. php_stream_wrapper_log_error(wrapper, options
  2.     TSRMLS_CC, "Unable to open %s persistently",
  3.                                 filename);
  4. return NULL;

URL解析

实例化varstream的下一步需要一个人类可读的URL, 将它分块放入到一个易管理的结构体中. 幸运的是它使用了和用户空间url_parse()函数相同的机制. 如果URL成功解析, 将会分配一个php_url结构体并设置合适的值. 如果在URL中没有某些值, 在返回的php_url中对应的将被设置为NULL. 这个结构体必须在离开php_varstream_opener函数之前被显式释放, 否则它的内存将会泄露:

  1. typedef struct php_url {
  2.     /* scheme://user:pass@host:port/path?query#fragment */
  3.     char *scheme;
  4.     char *user;
  5.     char *pass;
  6.     char *host;
  7.     unsigned short port;
  8.     char *path;
  9.     char *query;
  10.     char *fragment;
  11. } php_url;

最后, varstream包装器创建了一个数据结构, 保存了流指向的变量名, 读取时的当前位置. 这个结构体将在流的读取和写入函数中用于获取变量, 并且将在流结束使用时由php_varstream_close函数释放.

opendir()

读写变量内容的实现可以再次进行扩展. 这里可以加入一个新的特性, 允许使用目录函数读取数组中的key. 在你的php_varstream_wrapper_ops结构体之前增加下面的代码:

  1. static size_t php_varstream_readdir(php_stream *stream,
  2.                 char *buf, size_t count TSRMLS_DC)
  3. {
  4.     php_stream_dirent *ent = (php_stream_dirent*)buf;
  5.     php_varstream_dirdata *data = stream->abstract;
  6.     char *key;
  7.     int type, key_len;
  8.     long idx;
  9.     /* 查找数组中的key */
  10.     type = zend_hash_get_current_key_ex(Z_ARRVAL_P(data->arr),
  11.                     &key, &key_len, &idx, 0, &(data->pos));
  12.     /* 字符串key */
  13.     if (type == HASH_KEY_IS_STRING) {
  14.         if (key_len >= sizeof(ent->d_name)) {
  15.             /* truncate long keys to maximum length */
  16.             key_len = sizeof(ent->d_name) - 1;
  17.         }
  18.         /* 设置到目录结构上 */
  19.         memcpy(ent->d_name, key, key_len);
  20.         ent->d_name[key_len] = 0;
  21.     /* 数值key */
  22.     } else if (type == HASH_KEY_IS_LONG) {
  23.         /* 设置到目录结构上 */
  24.         snprintf(ent->d_name, sizeof(ent->d_name), "%ld",idx);
  25.     } else {
  26.         /* 迭代结束 */
  27.         return 0;
  28.     }
  29.     /* 移动数组指针(位置记录到流的抽象结构中) */
  30.     zend_hash_move_forward_ex(Z_ARRVAL_P(data->arr),
  31.                                         &data->pos);
  32.     return sizeof(php_stream_dirent);
  33. }
  34. static int php_varstream_closedir(php_stream *stream,
  35.                             int close_handle TSRMLS_DC)
  36. {
  37.     php_varstream_dirdata *data = stream->abstract;
  38.     zval_ptr_dtor(&(data->arr));
  39.     efree(data);
  40.     return 0;
  41. }
  42. static int php_varstream_dirseek(php_stream *stream,
  43.                     off_t offset, int whence,
  44.                     off_t *newoffset TSRMLS_DC)
  45. {
  46.     php_varstream_dirdata *data = stream->abstract;
  47.     if (whence == SEEK_SET && offset == 0) {
  48.         /* 重置数组指针 */
  49.         zend_hash_internal_pointer_reset_ex(
  50.                     Z_ARRVAL_P(data->arr), &(data->pos));
  51.         if (newoffset) {
  52.             *newoffset = 0;
  53.         }
  54.         return 0;
  55.     }
  56.     /* 不支持其他类型的随机访问 */
  57.     return -1;
  58. }
  59. static php_stream_ops php_varstream_dirops = {
  60.     NULL, /* write */
  61.     php_varstream_readdir,
  62.     php_varstream_closedir,
  63.     NULL, /* flush */
  64.     PHP_VARSTREAM_DIRSTREAMTYPE,
  65.     php_varstream_dirseek,
  66.     NULL, /* cast */
  67.     NULL, /* stat */
  68.     NULL, /* set_option */
  69. };
  70. static php_stream *php_varstream_opendir(
  71.             php_stream_wrapper *wrapper,
  72.             char *filename, char *mode, int options,
  73.             char **opened_path, php_stream_context *context
  74.             STREAMS_DC TSRMLS_DC)
  75. {
  76.     php_varstream_dirdata *data;
  77.     php_url *url;
  78.     zval **var;
  79.     /* 不支持持久化流 */
  80.     if (options & STREAM_OPEN_PERSISTENT) {
  81.         php_stream_wrapper_log_error(wrapper, options
  82.                 TSRMLS_CC, "Unable to open %s persistently",
  83.                 filename);
  84.         return NULL;
  85.     }
  86.     /* 解析URL */
  87.     url = php_url_parse(filename);
  88.     if (!url) {
  89.         php_stream_wrapper_log_error(wrapper, options
  90.                 TSRMLS_CC, "Unexpected error parsing URL");
  91.         return NULL;
  92.     }
  93.     /* 检查请求URL的正确性 */
  94.     if (!url->host || (url->host[0] == 0) ||
  95.             strcasecmp("var", url->scheme) != 0) {
  96.         /* Bad URL or wrong wrapper */
  97.         php_stream_wrapper_log_error(wrapper, options
  98.                 TSRMLS_CC, "Invalid URL, must be in the form: "
  99.                 "var://variablename");
  100.         php_url_free(url);
  101.         return NULL;
  102.     }
  103.     /* 查找变量 */
  104.     if (zend_hash_find(&EG(symbol_table), url->host,
  105.                 strlen(url->host) + 1, (void**)&var) == FAILURE) {
  106.         php_stream_wrapper_log_error(wrapper, options
  107.                 TSRMLS_CC, "Variable $%s not found", url->host);
  108.         php_url_free(url);
  109.         return NULL;
  110.     }
  111.     /* 检查变量类型 */
  112.     if (Z_TYPE_PP(var) != IS_ARRAY) {
  113.         php_stream_wrapper_log_error(wrapper, options
  114.                 TSRMLS_CC, "$%s is not an array", url->host);
  115.         php_url_free(url);
  116.         return NULL;
  117.     }
  118.     /* 释放前面分配的URL结构 */
  119.     php_url_free(url);
  120.     /* 分配抽象数据结构 */
  121.     data = emalloc(sizeof(php_varstream_dirdata));
  122.     if ( Z_ISREF_PP(var) && Z_REFCOUNT_PP(var) > 1) {
  123.         /* 全拷贝 */
  124.         MAKE_STD_ZVAL(data->arr);
  125.         *(data->arr) = **var;
  126.         zval_copy_ctor(data->arr);
  127.         INIT_PZVAL(data->arr);
  128.     } else {
  129.         /* 写时拷贝 */
  130.         data->arr = *var;
  131.         Z_SET_REFCOUNT_P(data->arr, Z_REFCOUNT_P(data->arr) + 1);
  132.     }
  133.     /* 重置数组指针 */
  134.     zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(data->arr),
  135.             &data->pos);
  136.     return php_stream_alloc(&php_varstream_dirops,data,0,mode);
  137. }

现在, 将你的php_varstream_wrapper_ops结构体中的dir_opener的NULL替换成你的php_varstream_opendir函数. 最后, 将下面新定义的类型放入到你的php_varstream.h文件的php_varstream_data定义下面:

  1. #define PHP_VARSTREAM_DIRSTREAMTYPE    "varstream directory"
  2. typedef struct _php_varstream_dirdata {
  3.     zval *arr;
  4.     HashPosition pos;
  5. } php_varstream_dirdata;

在你基于fopen()实现的varstream包装器中, 你直接使用持久变量名, 每次执行读写操作时从符号表中获取变量. 而这里, opendir()的实现中获取变量时处理了变量不存在或者类型错误的异常. 你还有一个数组变量的拷贝, 这就说明原数组的改变并不会影响后续的readdir()调用的结果. 原来存储变量名的方式也可以正常工作, 这里只是给出另外一种选择作为演示示例.

由于目录访问是基于成块的目录条目, 而不是字符, 因此这里需要一套独立的流操作. 这个版本中, write没有意义, 因此保持它为NULL. read的实现使用zend_hash_get_current_key_ex()函数将数组映射到目录名. 而随机访问也只是对SEEK_SET有效, 用来响应rewinddir()跳转到数组开始位置.

实际上, 目录流并没有使用SEEK_CUR, SEEK_END, 或者除了0之外的偏移量. 在实现目录流操作时, 最好还是涉及你的函数能以某种方式处理这些情况, 以使得在流包装层变化时能够适应其目录随机访问.

操纵

5个静态包装器操作中的4个用来处理不是基于I/O的流资源操作. 你已经看到过它们并了解它们的原型; 现在我们看看varstream包装器框架中它们的实现:

unlink

在你的wrapper_ops结构体中增加下面的函数, 它可以让unlink()通过varstream包装器, 拥有和unset()一样的行为:

  1. static int php_varstream_unlink(php_stream_wrapper *wrapper,
  2.                         char *filename, int options,
  3.                         php_stream_context *context
  4.                         TSRMLS_DC)
  5. {               
  6.     php_url *url;   
  7.                         
  8.     url = php_url_parse(filename);
  9.     if (!url) {         
  10.         php_stream_wrapper_log_error(wrapper, options
  11.             TSRMLS_CC, "Unexpected error parsing URL");
  12.         return -1;   
  13.     }       
  14.     if (!url->host || (url->host[0] == 0) ||
  15.         strcasecmp("var", url->scheme) != 0) {
  16.         /* URL不合法 */
  17.         php_stream_wrapper_log_error(wrapper, options
  18.             TSRMLS_CC, "Invalid URL, must be in the form: "
  19.                      "var://variablename");
  20.         php_url_free(url);
  21.         return -1;
  22.     }
  23.     
  24.     /* 从符号表删除变量 */
  25.     //zend_hash_del(&EG(symbol_table), url->host, strlen(url->host) + 1);
  26.     zend_delete_global_variable(url->host, strlen(url->host) + 1 TSRMLS_CC);
  27.     
  28.     php_url_free(url);                                      
  29.     return 0;
  30. }

这个函数的编码量和php_varstream_opener差不多. 唯一的不同在于这里你需要传递变量名给zend_hash_del()去删除变量.

译注: 译者的php-5.4.10环境中, 使用unlink()删除变量后, 在用户空间再次读取该变量名的值会导致core dump. 因此上面代码中译者进行了修正, 删除变量时使用了zend_delete_global_variable(), 请读者参考阅读zend_delete_global_variable()函数源代码, 考虑为什么直接用zend_hash_del()删除, 会导致core dump. 下面是译者测试用的用户空间代码:

  1. <?php
  2. $fp = fopen('var://hello', 'r');
  3. fwrite($fp, 'world');
  4. var_dump($hello);
  5. unlink('var://hello');
  6. $a  = $hello;

这个函数的代码量应该和php_varstream_opener差不多. 唯一的不同是这里是传递变量名给zend_hash_del()去删除变量.

rename, mkdir, rmdir

为了一致性, 下面给出rename, mkdir, rmdir函数的实现:

  1. static int php_varstream_rename(php_stream_wrapper *wrapper,
  2.         char *url_from, char *url_to, int options,
  3.         php_stream_context *context TSRMLS_DC)
  4. {
  5.     php_url *from, *to;
  6.     zval **var;
  7.     /* 来源URL解析 */
  8.     from = php_url_parse(url_from);
  9.     if (!from) {
  10.         php_stream_wrapper_log_error(wrapper, options
  11.             TSRMLS_CC, "Unexpected error parsing source");
  12.         return -1;
  13.     }
  14.     /* 查找变量 */
  15.     if (zend_hash_find(&EG(symbol_table), from->host,
  16.                 strlen(from->host) + 1,
  17.                 (void**)&var) == FAILURE) {
  18.         php_stream_wrapper_log_error(wrapper, options
  19.             TSRMLS_CC, "$%s does not exist", from->host);
  20.         php_url_free(from);
  21.         return -1;
  22.     }
  23.     /* 目标URL解析 */
  24.     to = php_url_parse(url_to);
  25.     if (!to) {
  26.         php_stream_wrapper_log_error(wrapper, options
  27.             TSRMLS_CC, "Unexpected error parsing dest");
  28.         php_url_free(from);
  29.         return -1;
  30.     }
  31.     /* 变量的改名 */
  32.     Z_SET_REFCOUNT_PP(var, Z_REFCOUNT_PP(var) + 1);
  33.     zend_hash_update(&EG(symbol_table), to->host,
  34.                 strlen(to->host) + 1, (void*)var,
  35.                 sizeof(zval*), NULL);
  36.     zend_hash_del(&EG(symbol_table), from->host,
  37.                 strlen(from->host) + 1);
  38.     php_url_free(from);
  39.     php_url_free(to);
  40.     return 0;
  41. }
  42. static int php_varstream_mkdir(php_stream_wrapper *wrapper,
  43.                 char *url_from, int mode, int options,
  44.                 php_stream_context *context TSRMLS_DC)
  45. {
  46.     php_url *url;
  47.     /* URL解析 */
  48.     url = php_url_parse(url_from);
  49.     if (!url) {
  50.        php_stream_wrapper_log_error(wrapper, options
  51.            TSRMLS_CC, "Unexpected error parsing URL");
  52.        return -1;
  53.     }
  54.     /* 检查变量是否存在 */
  55.     if (zend_hash_exists(&EG(symbol_table), url->host,
  56.                     strlen(url->host) + 1)) {
  57.         php_stream_wrapper_log_error(wrapper, options
  58.             TSRMLS_CC, "$%s already exists", url->host);
  59.         php_url_free(url);
  60.         return -1;
  61.     }
  62.     /* EG(uninitialized_zval_ptr)通常是IS_NULL的zval *, 引用计数无限大 */
  63.     zend_hash_add(&EG(symbol_table), url->host,
  64.             strlen(url->host) + 1,
  65.             (void*)&EG(uninitialized_zval_ptr),
  66.             sizeof(zval*), NULL);
  67.     php_url_free(url);
  68.     return 0;
  69. }
  70. static int php_varstream_rmdir(php_stream_wrapper *wrapper,
  71.                 char *url, int options,
  72.                 php_stream_context *context TSRMLS_DC)
  73. {
  74.     /* 行为等价于unlink() */
  75.     wrapper->wops->unlink(wrapper, url, options,
  76.                                 context TSRMLS_CC);
  77. }

检查

并不是所有的流操作都涉及到资源的操纵. 有时候也需要查看活动的流在某个时刻的状态, 或检查潜在可打开的资源的状态.

这一节流和包装器的ops函数都是在相同的数据结构php_stream_statbuf上工作的, 它只有一个元素: posix标准的struct statbuf. 当本节的某个函数被调用时, 将尝试填充尽可能多的statbuf元素的成员.

stat

如果设置, 当请求激活流实例的信息时, 将会调用wrapper->ops->stream_stat(). 如果没有设置, 则对应的stream->ops->stat()将会被调用. 无论哪个函数被调用, 都应该尽可能多的向返回的statbuf结构体ssb->sb中填充尽可能多流实例的有用信息. 在普通文件I/O的用法中, 它对应fstat()的标准I/O调用.

url_stat

在流实例外部调用wrapper->ops->url_stat()取到流资源的元数据. 通常来说, 符号链接和重定向都应该被解析, 直到找到一个真正的资源, 对其通过stat()系统调用这样的机制读取统计信息. url_stat的flags参数允许是下面PHP_STREAM_URL_STAT_*系列的常量值(省略PHP_STREAM_URL_STAT_前缀):

LINK不解析符号链接和重定向. 而是报告它碰到的第一个节点的信息, 无论是连

接还是真正的资源.

QUIET不报告错误. 注意, 这和许多其他流函数中的REPORT_ERRORS逻辑恰恰

相反.

小结

无论是暴露远程网络I/O还是本地数据源的流资源, 都允许你的扩展在核心数据上挂在操纵函数的钩子, 避免重新实现单调的描述符管理和I/O缓冲区工作. 这使得它在用户空间环境中更加有用, 更加强大.

下一章将通过对过滤器和上下文的学习结束流包装层的学习, 过滤器和上下文可以用于选择默认的流行为, 甚至过程中修改数据.

以上就是[翻译][php扩展开发和嵌入式]第15章-php中流的实现的内容，更多相关内容请关注PHP中文网（www.gxlcms.com）！

人气教程排行

本站所有资源全部来源于网络，若本站发布的内容侵害到您的隐私或者利益，请联系我们删除！