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 #define PSI_CPP_SEARCH
  39 #include "php_psi_cpp.h"
  40
  41 #if HAVE_LIBJIT
  42 # include "libjit.h"
  43 # ifndef HAVE_LIBFFI
  44 #  define PSI_ENGINE "jit"
  45 # endif
  46 #endif
  47 #if HAVE_LIBFFI
  48 # include "libffi.h"
  49 # define PSI_ENGINE "ffi"
  50 #endif
  51
  52 ZEND_DECLARE_MODULE_GLOBALS(psi);
  53
  54 PHP_INI_BEGIN()
  55         STD_PHP_INI_ENTRY("psi.engine", PSI_ENGINE, PHP_INI_SYSTEM, OnUpdateString, engine, zend_psi_globals, psi_globals)
  56         STD_PHP_INI_ENTRY("psi.directory", "psi.d", PHP_INI_SYSTEM, OnUpdateString, directory, zend_psi_globals, psi_globals)
  57 PHP_INI_END();
  58
  59 static zend_object_handlers psi_object_handlers;
  60 static zend_class_entry *psi_class_entry;
  61
  62 zend_class_entry *psi_object_get_class_entry()
  63 {
  64         return psi_class_entry;
  65 }
  66
  67 static void psi_object_free(zend_object *o)
  68 {
  69         psi_object *obj = PSI_OBJ(NULL, o);
  70
  71         if (obj->data) {
  72                 if (obj->dtor) {
  73                         obj->dtor(obj->data);
  74                 }
  75                 obj->data = NULL;
  76         }
  77         zend_object_std_dtor(o);
  78 }
  79
  80 zend_object *psi_object_init_ex(zend_class_entry *ce, void *data, void (*dtor)(void *))
  81 {
  82         psi_object *o;
  83
  84         if (!ce) {
  85                 ce = psi_class_entry;
  86         }
  87
  88         o = ecalloc(1, sizeof(*o) + zend_object_properties_size(ce));
  89
  90         o->data = data;
  91         o->dtor = dtor;
  92
  93         zend_object_std_init(&o->std, ce);
  94         object_properties_init(&o->std, ce);
  95         o->std.handlers = &psi_object_handlers;
  96         return &o->std;
  97 }
  98
  99 zend_object *psi_object_init(zend_class_entry *ce)
 100 {
 101         return psi_object_init_ex(ce, NULL, NULL);
 102 }
 103
 104 ZEND_BEGIN_ARG_INFO_EX(ai_psi_dump, 0, 0, 0)
 105         ZEND_ARG_INFO(0, stream)
 106 ZEND_END_ARG_INFO();
 107 static PHP_FUNCTION(psi_dump)
 108 {
 109         php_stream *s;
 110         zval *r = NULL;
 111         int fd = STDOUT_FILENO;
 112
 113         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "|r!", &r)) {
 114                 return;
 115         }
 116         if (r) {
 117                 php_stream_from_zval(s, r);
 118
 119                 if (SUCCESS != php_stream_cast(s, PHP_STREAM_AS_FD | PHP_STREAM_CAST_INTERNAL, (void **)&fd, 1)) {
 120                         RETURN_FALSE;
 121                 }
 122         }
 123         psi_context_dump(PSI_G(context), fd);
 124 }
 125
 126 ZEND_BEGIN_ARG_INFO_EX(ai_psi_validate, 0, 0, 1)
 127         ZEND_ARG_INFO(0, file)
 128         ZEND_ARG_INFO(0, flags)
 129 ZEND_END_ARG_INFO();
 130 static PHP_FUNCTION(psi_validate)
 131 {
 132         zend_string *file;
 133         struct psi_parser_input *I;
 134         struct psi_parser P;
 135         struct psi_data D = {0};
 136         zend_long flags = 0;
 137
 138 #if PHP_DEBUG
 139         if (psi_check_env("PSI_DEBUG")) {
 140                 flags |= PSI_DEBUG;
 141         }
 142 #endif
 143
 144         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "P|l", &file, &flags)) {
 145                 return;
 146         }
 147
 148         if (!psi_parser_init(&P, psi_error_wrapper, flags)) {
 149                 RETURN_FALSE;
 150         }
 151         if (!(I = psi_parser_open_file(&P, file->val, true))) {
 152                 psi_parser_dtor(&P);
 153                 RETURN_FALSE;
 154         }
 155
 156         psi_parser_parse(&P, I);
 157         psi_data_ctor(&D, P.error, P.flags);
 158         RETVAL_BOOL(psi_data_validate(&D, PSI_DATA(&P)) && !P.errors);
 159         psi_data_dtor(&D);
 160         psi_parser_dtor(&P);
 161         free(I);
 162 }
 163
 164 ZEND_BEGIN_ARG_INFO_EX(ai_psi_validate_string, 0, 0, 1)
 165         ZEND_ARG_INFO(0, string)
 166 ZEND_END_ARG_INFO();
 167 static PHP_FUNCTION(psi_validate_string)
 168 {
 169         zend_string *string;
 170         struct psi_parser_input *I;
 171         struct psi_parser P;
 172         struct psi_data D = {0};
 173         zend_long flags = 0;
 174
 175 #if PHP_DEBUG
 176         if (psi_check_env("PSI_DEBUG")) {
 177                 flags |= PSI_DEBUG;
 178         }
 179 #endif
 180
 181         if (SUCCESS != zend_parse_parameters(ZEND_NUM_ARGS(), "S|l", &string, &flags)) {
 182                 return;
 183         }
 184
 185         if (!psi_parser_init(&P, psi_error_wrapper, flags)) {
 186                 RETURN_FALSE;
 187         }
 188         if (!(I = psi_parser_open_string(&P, string->val, string->len))) {
 189                 psi_parser_dtor(&P);
 190                 RETURN_FALSE;
 191         }
 192
 193         psi_parser_parse(&P, I);
 194         psi_data_ctor(&D, P.error, P.flags);
 195         RETVAL_BOOL(psi_data_validate(&D, PSI_DATA(&P)) && !P.errors);
 196         psi_data_dtor(&D);
 197         psi_parser_dtor(&P);
 198         free(I);
 199 }
 200
 201 static PHP_MINIT_FUNCTION(psi)
 202 {
 203         struct psi_context_ops *ops = NULL;
 204         zend_class_entry ce = {0};
 205         unsigned flags = 0;
 206
 207         REGISTER_INI_ENTRIES();
 208
 209         zend_register_long_constant(ZEND_STRL("PSI_DEBUG"), PSI_DEBUG, CONST_CS|CONST_PERSISTENT, module_number);
 210         zend_register_long_constant(ZEND_STRL("PSI_SILENT"), PSI_SILENT, CONST_CS|CONST_PERSISTENT, module_number);
 211
 212         INIT_NS_CLASS_ENTRY(ce, "psi", "object", NULL);
 213         psi_class_entry = zend_register_internal_class_ex(&ce, NULL);
 214         psi_class_entry->create_object = psi_object_init;
 215
 216         memcpy(&psi_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 217         psi_object_handlers.offset = XtOffsetOf(psi_object, std);
 218         psi_object_handlers.free_obj = psi_object_free;
 219         psi_object_handlers.clone_obj = NULL;
 220
 221 #ifdef HAVE_LIBJIT
 222         if (!strcasecmp(PSI_G(engine), "jit")) {
 223                 ops = psi_libjit_ops();
 224         } else
 225 #endif
 226 #ifdef HAVE_LIBFFI
 227                 ops = psi_libffi_ops();
 228 #endif
 229
 230         if (!ops) {
 231                 php_error(E_WARNING, "No PSI engine found");
 232                 return FAILURE;
 233         }
 234
 235         if (psi_check_env("PSI_DEBUG")) {
 236                 flags |= PSI_DEBUG;
 237         }
 238         if (psi_check_env("PSI_SILENT")) {
 239                 flags |= PSI_SILENT;
 240         }
 241
 242         PSI_G(search_path) = pemalloc(strlen(PSI_G(directory)) + strlen(psi_cpp_search) + 1 + 1, 1);
 243         sprintf(PSI_G(search_path), "%s:%s", PSI_G(directory), psi_cpp_search);
 244
 245         PSI_G(context) = psi_context_init(NULL, ops, psi_error_wrapper, flags);
 246         psi_context_build(PSI_G(context), PSI_G(directory));
 247
 248         return SUCCESS;
 249 }
 250
 251 static PHP_MSHUTDOWN_FUNCTION(psi)
 252 {
 253         if (psi_check_env("PSI_DUMP")) {
 254                 psi_context_dump(PSI_G(context), STDOUT_FILENO);
 255         }
 256
 257         psi_context_free(&PSI_G(context));
 258
 259         UNREGISTER_INI_ENTRIES();
 260
 261         return SUCCESS;
 262 }
 263
 264 #if defined(COMPILE_DL_PSI) && defined(ZTS)
 265 static PHP_RINIT_FUNCTION(psi)
 266 {
 267         ZEND_TSRMLS_CACHE_UPDATE();
 268         return SUCCESS;
 269 }
 270 #endif
 271
 272 static PHP_MINFO_FUNCTION(psi)
 273 {
 274         php_info_print_table_start();
 275         php_info_print_table_header(2, "PSI Support", "enabled");
 276         php_info_print_table_row(2, "Extension Version", PHP_PSI_VERSION);
 277         php_info_print_table_row(2, "Search Path", PSI_G(search_path));
 278         php_info_print_table_end();
 279
 280         php_info_print_table_start();
 281         php_info_print_table_header(3, "Used Library", "Compiled", "Linked");
 282         php_info_print_table_row(3, "libffi",
 283 #ifndef PHP_PSI_LIBFFI_VERSION
 284 # define PHP_PSI_LIBFFI_VERSION "unknown"
 285 #endif
 286 #ifdef HAVE_LIBFFI
 287                         PHP_PSI_LIBFFI_VERSION, "unknown"
 288 #else
 289                         "disabled", "disabled"
 290 #endif
 291         );
 292         php_info_print_table_row(3, "libjit",
 293 #ifdef HAVE_LIBJIT
 294                         "unknown", "unknown"
 295 #else
 296                         "disabled", "disabled"
 297 #endif
 298         );
 299
 300         DISPLAY_INI_ENTRIES();
 301 }
 302
 303 static const zend_function_entry psi_functions[] = {
 304         PHP_FE(psi_dump, ai_psi_dump)
 305         PHP_FE(psi_validate, ai_psi_validate)
 306         PHP_FE(psi_validate_string, ai_psi_validate_string)
 307         PHP_FE_END
 308 };
 309
 310 zend_module_entry psi_module_entry = {
 311         STANDARD_MODULE_HEADER,
 312         "psi",
 313         psi_functions,
 314         PHP_MINIT(psi),
 315         PHP_MSHUTDOWN(psi),
 316 #if defined(COMPILE_DL_PSI) && defined(ZTS)
 317         PHP_RINIT(psi),         /* Replace with NULL if there's nothing to do at request start */
 318 #else
 319         NULL,
 320 #endif
 321         NULL,
 322         PHP_MINFO(psi),
 323         PHP_PSI_VERSION,
 324         STANDARD_MODULE_PROPERTIES
 325 };
 326
 327 #ifdef COMPILE_DL_PSI
 328 #ifdef ZTS
 329 ZEND_TSRMLS_CACHE_DEFINE();
 330 #endif
 331 ZEND_GET_MODULE(psi)
 332 #endif
 333
 334 /*
 335  * Local variables:
 336  * tab-width: 4
 337  * c-basic-offset: 4
 338  * End:
 339  * vim600: noet sw=4 ts=4 fdm=marker
 340  * vim<600: noet sw=4 ts=4
 341  */