git.m6w6.name Git - m6w6/ext-psi/blob - src/module.c

   1 /*******************************************************************************
   2  Copyright (c) 2016, Michael Wallner <mike@php.net>.
   3  All rights reserved.
   4
   5  Redistribution and use in source and binary forms, with or without
   6  modification, are permitted provided that the following conditions are met:
   7
   8      * Redistributions of source code must retain the above copyright notice,
   9        this list of conditions and the following disclaimer.
  10      * Redistributions in binary form must reproduce the above copyright
  11        notice, this list of conditions and the following disclaimer in the
  12        documentation and/or other materials provided with the distribution.
  13
  14  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  15  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17  DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  18  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  20  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  21  CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  22  OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24 *******************************************************************************/
  25
  26 #include "php_psi_stdinc.h"
  27
  28 #include "php.h"
  29 #include "php_ini.h"
  30 #include "ext/standard/info.h"
  31 #include "zend_constants.h"
  32 #include "zend_operators.h"
  33
  34 #include "php_psi.h"
  35 #include "token.h"
  36 #include "parser.h"
  37
  38 #if HAVE_LIBJIT
  39 # include "libjit.h"
  40 # ifndef HAVE_LIBFFI
  41 #  define PSI_ENGINE "jit"
  42 # endif
  43 #endif
  44 #if HAVE_LIBFFI
  45 # include "libffi.h"
  46 # define PSI_ENGINE "ffi"
  47 #endif
  48
  49 ZEND_DECLARE_MODULE_GLOBALS(psi);
  50
  51 PHP_INI_BEGIN()
  52         STD_PHP_INI_ENTRY("psi.engine", PSI_ENGINE, PHP_INI_SYSTEM, OnUpdateString, engine, zend_psi_globals, psi_globals)
  53         STD_PHP_INI_ENTRY("psi.directory", "psi.d", PHP_INI_SYSTEM, OnUpdateString, directory, zend_psi_globals, psi_globals)
  54 PHP_INI_END();
  55
  56 static zend_object_handlers psi_object_handlers;
  57 static zend_class_entry *psi_class_entry;
  58
  59 zend_class_entry *psi_object_get_class_entry()
  60 {
  61         return psi_class_entry;
  62 }
  63
  64 static void psi_object_free(zend_object *o)
  65 {
  66         psi_object *obj = PSI_OBJ(NULL, o);
  67
  68         if (obj->data) {
  69                 if (obj->dtor) {
  70                         obj->dtor(obj->data);
  71                 }
  72                 obj->data = NULL;
  73         }
  74         zend_object_std_dtor(o);
  75 }
  76
  77 zend_object *psi_object_init_ex(zend_class_entry *ce, void *data, void (*dtor)(void *))
  78 {
  79         psi_object *o;
  80
  81         if (!ce) {
  82                 ce = psi_class_entry;
  83         }
  84
  85         o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
  86
  87         o->data = data;
  88         o->dtor = dtor;
  89
  90         zend_object_std_init(&o->std, ce);
  91         object_properties_init(&o->std, ce);
  92         o->std.handlers = &psi_object_handlers;
  93         return &o->std;
  94 }
  95
  96 zend_object *psi_object_init(zend_class_entry *ce)
  97 {
  98         return psi_object_init_ex(ce, NULL, NULL);
  99 }
 100
 101 ZEND_BEGIN_ARG_INFO_EX(ai_psi_dump, 0, 0, 0)
 102         ZEND_ARG_INFO(0, stream)
 103 ZEND_END_ARG_INFO();
 104 static PHP_FUNCTION(psi_dump)
 105 {
 106         php_stream *s;
 107         zval *r = NULL;
 108         int fd = STDOUT_FILENO;
 109
 110         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "|r!", &r)) {
 111                 return;
 112         }
 113         if (r) {
 114                 php_stream_from_zval(s, r);
 115
 116                 if (SUCCESS != php_stream_cast(s, PHP_STREAM_AS_FD | PHP_STREAM_CAST_INTERNAL, (void **)&fd, 1)) {
 117                         RETURN_FALSE;
 118                 }
 119         }
 120         psi_context_dump(PSI_G(context), fd);
 121 }
 122
 123 ZEND_BEGIN_ARG_INFO_EX(ai_psi_validate, 0, 0, 1)
 124         ZEND_ARG_INFO(0, file)
 125 ZEND_END_ARG_INFO();
 126 static PHP_FUNCTION(psi_validate)
 127 {
 128         zend_string *file;
 129         struct psi_parser P;
 130         struct psi_data D = {0};
 131
 132         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "P", &file)) {
 133                 return;
 134         }
 135
 136         if (!psi_parser_init(&P, psi_error_wrapper, 0)) {
 137                 RETURN_FALSE;
 138         }
 139         if (!psi_parser_open_file(&P, file->val)) {
 140                 psi_parser_dtor(&P);
 141                 RETURN_FALSE;
 142         }
 143
 144         while (0 < psi_parser_scan(&P)) {
 145                 psi_parser_parse(&P, psi_token_alloc(&P));
 146                 if (P.num == PSI_T_EOF) {
 147                         break;
 148                 }
 149         }
 150         psi_parser_parse(&P, NULL);
 151
 152         psi_data_ctor(&D, P.error, P.flags);
 153         RETVAL_BOOL(psi_data_validate(&D, PSI_DATA(&P)) && !P.errors);
 154         psi_data_dtor(&D);
 155
 156         psi_parser_dtor(&P);
 157 }
 158
 159 ZEND_BEGIN_ARG_INFO_EX(ai_psi_validate_string, 0, 0, 1)
 160         ZEND_ARG_INFO(0, string)
 161 ZEND_END_ARG_INFO();
 162 static PHP_FUNCTION(psi_validate_string)
 163 {
 164         zend_string *string;
 165         struct psi_parser P;
 166         struct psi_data D = {0};
 167
 168         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "S", &string)) {
 169                 return;
 170         }
 171
 172         if (!psi_parser_init(&P, psi_error_wrapper, 0)) {
 173                 RETURN_FALSE;
 174         }
 175         if (!psi_parser_open_string(&P, string->val, string->len)) {
 176                 psi_parser_dtor(&P);
 177                 RETURN_FALSE;
 178         }
 179
 180         while (0 < psi_parser_scan(&P)) {
 181                 psi_parser_parse(&P, psi_token_alloc(&P));
 182                 if (P.num == PSI_T_EOF) {
 183                         break;
 184                 }
 185         }
 186         psi_parser_parse(&P, NULL);
 187
 188         psi_data_ctor(&D, P.error, P.flags);
 189         RETVAL_BOOL(psi_data_validate(&D, PSI_DATA(&P)) && !P.errors);
 190         psi_data_dtor(&D);
 191
 192         psi_parser_dtor(&P);
 193 }
 194
 195 static PHP_MINIT_FUNCTION(psi)
 196 {
 197         struct psi_context_ops *ops = NULL;
 198         zend_class_entry ce = {0};
 199         unsigned flags = 0;
 200
 201         if (psi_check_env("PSI_DEBUG")) {
 202                 flags |= PSI_DEBUG;
 203         }
 204         if (psi_check_env("PSI_SILENT")) {
 205                 flags |= PSI_SILENT;
 206         }
 207
 208         REGISTER_INI_ENTRIES();
 209
 210         INIT_NS_CLASS_ENTRY(ce, "psi", "object", NULL);
 211         psi_class_entry = zend_register_internal_class_ex(&ce, NULL);
 212         psi_class_entry->create_object = psi_object_init;
 213
 214         memcpy(&psi_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 215         psi_object_handlers.offset = XtOffsetOf(psi_object, std);
 216         psi_object_handlers.free_obj = psi_object_free;
 217         psi_object_handlers.clone_obj = NULL;
 218
 219 #ifdef HAVE_LIBJIT
 220         if (!strcasecmp(PSI_G(engine), "jit")) {
 221                 ops = psi_libjit_ops();
 222         } else
 223 #endif
 224 #ifdef HAVE_LIBFFI
 225                 ops = psi_libffi_ops();
 226 #endif
 227
 228         if (!ops) {
 229                 php_error(E_WARNING, "No PSI engine found");
 230                 return FAILURE;
 231         }
 232
 233         PSI_G(context) = psi_context_init(NULL, ops, psi_error_wrapper, flags);
 234         psi_context_build(PSI_G(context), PSI_G(directory));
 235
 236         if (psi_check_env("PSI_DUMP")) {
 237                 psi_context_dump(PSI_G(context), STDOUT_FILENO);
 238         }
 239
 240         return SUCCESS;
 241 }
 242
 243 static PHP_MSHUTDOWN_FUNCTION(psi)
 244 {
 245         psi_context_free(&PSI_G(context));
 246
 247         UNREGISTER_INI_ENTRIES();
 248
 249         return SUCCESS;
 250 }
 251
 252 #if defined(COMPILE_DL_PSI) && defined(ZTS)
 253 static PHP_RINIT_FUNCTION(psi)
 254 {
 255         ZEND_TSRMLS_CACHE_UPDATE();
 256         return SUCCESS;
 257 }
 258 #endif
 259
 260 static PHP_MINFO_FUNCTION(psi)
 261 {
 262         php_info_print_table_start();
 263         php_info_print_table_header(2, "PSI Support", "enabled");
 264         php_info_print_table_row(2, "Extension Version", PHP_PSI_VERSION);
 265         php_info_print_table_end();
 266         php_info_print_table_start();
 267         php_info_print_table_header(3, "Used Library", "Compiled", "Linked");
 268         php_info_print_table_row(3, "libffi",
 269 #ifndef PHP_PSI_LIBFFI_VERSION
 270 # define PHP_PSI_LIBFFI_VERSION "unknown"
 271 #endif
 272 #ifdef HAVE_LIBFFI
 273                         PHP_PSI_LIBFFI_VERSION, "unknown"
 274 #else
 275                         "disabled", "disabled"
 276 #endif
 277         );
 278         php_info_print_table_row(3, "libjit",
 279 #ifdef HAVE_LIBJIT
 280                         "unknown", "unknown"
 281 #else
 282                         "disabled", "disabled"
 283 #endif
 284         );
 285
 286         DISPLAY_INI_ENTRIES();
 287 }
 288
 289 static const zend_function_entry psi_functions[] = {
 290         PHP_FE(psi_dump, ai_psi_dump)
 291         PHP_FE(psi_validate, ai_psi_validate)
 292         PHP_FE(psi_validate_string, ai_psi_validate_string)
 293         PHP_FE_END
 294 };
 295
 296 zend_module_entry psi_module_entry = {
 297         STANDARD_MODULE_HEADER,
 298         "psi",
 299         psi_functions,
 300         PHP_MINIT(psi),
 301         PHP_MSHUTDOWN(psi),
 302 #if defined(COMPILE_DL_PSI) && defined(ZTS)
 303         PHP_RINIT(psi),         /* Replace with NULL if there's nothing to do at request start */
 304 #else
 305         NULL,
 306 #endif
 307         NULL,
 308         PHP_MINFO(psi),
 309         PHP_PSI_VERSION,
 310         STANDARD_MODULE_PROPERTIES
 311 };
 312
 313 #ifdef COMPILE_DL_PSI
 314 #ifdef ZTS
 315 ZEND_TSRMLS_CACHE_DEFINE();
 316 #endif
 317 ZEND_GET_MODULE(psi)
 318 #endif
 319
 320 /*
 321  * Local variables:
 322  * tab-width: 4
 323  * c-basic-offset: 4
 324  * End:
 325  * vim600: noet sw=4 ts=4 fdm=marker
 326  * vim<600: noet sw=4 ts=4
 327  */