PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/fileinfo - fileinfo.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 176 190 92.6 %
Date: 2014-10-22 Functions: 13 13 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :   +----------------------------------------------------------------------+
       3             :   | PHP Version 7                                                        |
       4             :   +----------------------------------------------------------------------+
       5             :   | Copyright (c) 1997-2014 The PHP Group                                |
       6             :   +----------------------------------------------------------------------+
       7             :   | This source file is subject to version 3.0 of the PHP license,       |
       8             :   | that is bundled with this package in the file LICENSE, and is        |
       9             :   | available through the world-wide-web at the following url:           |
      10             :   | http://www.php.net/license/3_0.txt.                                  |
      11             :   | If you did not receive a copy of the PHP license and are unable to   |
      12             :   | obtain it through the world-wide-web, please send a note to          |
      13             :   | license@php.net so we can mail you a copy immediately.               |
      14             :   +----------------------------------------------------------------------+
      15             :   | Author: Ilia Alshanetsky <ilia@php.net>                              |
      16             :   +----------------------------------------------------------------------+
      17             : */
      18             : 
      19             : /* $Id$ */
      20             : 
      21             : #ifdef HAVE_CONFIG_H
      22             : #include "config.h"
      23             : #endif
      24             : #include "php.h"
      25             : 
      26             : #include <magic.h>
      27             : /* 
      28             :  * HOWMANY specifies the maximum offset libmagic will look at
      29             :  * this is currently hardcoded in the libmagic source but not exported
      30             :  */
      31             : #ifndef HOWMANY
      32             : #define HOWMANY 65536
      33             : #endif
      34             : 
      35             : #include "php_ini.h"
      36             : #include "ext/standard/info.h"
      37             : #include "ext/standard/file.h" /* needed for context stuff */
      38             : #include "php_fileinfo.h"
      39             : #include "fopen_wrappers.h" /* needed for is_url */
      40             : 
      41             : #ifndef _S_IFDIR
      42             : # define _S_IFDIR               S_IFDIR
      43             : #endif
      44             : 
      45             : /* {{{ macros and type definitions */
      46             : typedef struct _php_fileinfo {
      47             :         zend_long options;
      48             :         struct magic_set *magic;
      49             : } php_fileinfo;
      50             : 
      51             : static zend_object_handlers finfo_object_handlers;
      52             : zend_class_entry *finfo_class_entry;
      53             : 
      54             : typedef struct _finfo_object {
      55             :         php_fileinfo *ptr;
      56             :         zend_object zo;
      57             : } finfo_object;
      58             : 
      59             : #define FILEINFO_DECLARE_INIT_OBJECT(object) \
      60             :         zval *object = ZEND_IS_METHOD_CALL() ? getThis() : NULL;
      61             : 
      62          38 : static inline finfo_object *php_finfo_fetch_object(zend_object *obj) {
      63          38 :         return (finfo_object *)((char*)(obj) - XtOffsetOf(finfo_object, zo));
      64             : }
      65             : 
      66             : #define Z_FINFO_P(zv) php_finfo_fetch_object(Z_OBJ_P((zv)))
      67             : 
      68             : #define FILEINFO_REGISTER_OBJECT(_object, _ptr) \
      69             : { \
      70             :         finfo_object *obj; \
      71             :     obj = Z_FINFO_P(_object); \
      72             :     obj->ptr = _ptr; \
      73             : }
      74             : 
      75             : #define FILEINFO_FROM_OBJECT(finfo, object) \
      76             : { \
      77             :         finfo_object *obj = Z_FINFO_P(object); \
      78             :         finfo = obj->ptr; \
      79             :         if (!finfo) { \
      80             :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "The invalid fileinfo object."); \
      81             :                 RETURN_FALSE; \
      82             :         } \
      83             : }
      84             : 
      85             : /* {{{ finfo_objects_free
      86             :  */
      87           9 : static void finfo_objects_free(zend_object *object TSRMLS_DC)
      88             : {
      89           9 :         finfo_object *intern = php_finfo_fetch_object(object);
      90             : 
      91           9 :         if (intern->ptr) {
      92           7 :                 magic_close(intern->ptr->magic);
      93           7 :                 efree(intern->ptr);
      94             :         }
      95             : 
      96           9 :         zend_object_std_dtor(&intern->zo TSRMLS_CC);
      97           9 : }
      98             : /* }}} */
      99             : 
     100             : /* {{{ finfo_objects_new
     101             :  */
     102           9 : PHP_FILEINFO_API zend_object *finfo_objects_new(zend_class_entry *class_type TSRMLS_DC)
     103             : {
     104             :         finfo_object *intern;
     105             : 
     106           9 :         intern = ecalloc(1, sizeof(finfo_object) + sizeof(zval) * (class_type->default_properties_count - 1));
     107             : 
     108           9 :         zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
     109           9 :         object_properties_init(&intern->zo, class_type);
     110           9 :         intern->zo.handlers = &finfo_object_handlers;
     111             : 
     112           9 :         return &intern->zo;
     113             : }
     114             : /* }}} */
     115             : 
     116             : /* {{{ arginfo */
     117             : ZEND_BEGIN_ARG_INFO_EX(arginfo_finfo_open, 0, 0, 0)
     118             :         ZEND_ARG_INFO(0, options)
     119             :         ZEND_ARG_INFO(0, arg)
     120             : ZEND_END_ARG_INFO()
     121             : 
     122             : ZEND_BEGIN_ARG_INFO_EX(arginfo_finfo_close, 0, 0, 1)
     123             :         ZEND_ARG_INFO(0, finfo)
     124             : ZEND_END_ARG_INFO()
     125             : 
     126             : ZEND_BEGIN_ARG_INFO_EX(arginfo_finfo_set_flags, 0, 0, 2)
     127             :         ZEND_ARG_INFO(0, finfo)
     128             :         ZEND_ARG_INFO(0, options)
     129             : ZEND_END_ARG_INFO()
     130             : 
     131             : ZEND_BEGIN_ARG_INFO_EX(arginfo_finfo_method_set_flags, 0, 0, 1)
     132             :         ZEND_ARG_INFO(0, options)
     133             : ZEND_END_ARG_INFO()
     134             : 
     135             : ZEND_BEGIN_ARG_INFO_EX(arginfo_finfo_file, 0, 0, 2)
     136             :         ZEND_ARG_INFO(0, finfo)
     137             :         ZEND_ARG_INFO(0, filename)
     138             :         ZEND_ARG_INFO(0, options)
     139             :         ZEND_ARG_INFO(0, context)
     140             : ZEND_END_ARG_INFO()
     141             : 
     142             : ZEND_BEGIN_ARG_INFO_EX(arginfo_finfo_method_file, 0, 0, 1)
     143             :         ZEND_ARG_INFO(0, filename)
     144             :         ZEND_ARG_INFO(0, options)
     145             :         ZEND_ARG_INFO(0, context)
     146             : ZEND_END_ARG_INFO()
     147             : 
     148             : ZEND_BEGIN_ARG_INFO_EX(arginfo_finfo_buffer, 0, 0, 2)
     149             :         ZEND_ARG_INFO(0, finfo)
     150             :         ZEND_ARG_INFO(0, string)
     151             :         ZEND_ARG_INFO(0, options)
     152             :         ZEND_ARG_INFO(0, context)
     153             : ZEND_END_ARG_INFO()
     154             : 
     155             : ZEND_BEGIN_ARG_INFO_EX(arginfo_finfo_method_buffer, 0, 0, 1)
     156             :         ZEND_ARG_INFO(0, string)
     157             :         ZEND_ARG_INFO(0, options)
     158             :         ZEND_ARG_INFO(0, context)
     159             : ZEND_END_ARG_INFO()
     160             : 
     161             : ZEND_BEGIN_ARG_INFO_EX(arginfo_mime_content_type, 0, 0, 1)
     162             :         ZEND_ARG_INFO(0, string)
     163             : ZEND_END_ARG_INFO()
     164             : /* }}} */
     165             : 
     166             : /* {{{ finfo_class_functions
     167             :  */
     168             : zend_function_entry finfo_class_functions[] = {
     169             :         ZEND_ME_MAPPING(finfo,          finfo_open,     arginfo_finfo_open, ZEND_ACC_PUBLIC)
     170             :         ZEND_ME_MAPPING(set_flags,      finfo_set_flags,arginfo_finfo_method_set_flags, ZEND_ACC_PUBLIC)
     171             :         ZEND_ME_MAPPING(file,           finfo_file,     arginfo_finfo_method_file, ZEND_ACC_PUBLIC)
     172             :         ZEND_ME_MAPPING(buffer,         finfo_buffer,   arginfo_finfo_method_buffer, ZEND_ACC_PUBLIC)
     173             :         PHP_FE_END
     174             : };
     175             : /* }}} */
     176             : 
     177             : #define FINFO_SET_OPTION(magic, options) \
     178             :         if (magic_setflags(magic, options) == -1) { \
     179             :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to set option '%pd' %d:%s", \
     180             :                                 options, magic_errno(magic), magic_error(magic)); \
     181             :                 RETURN_FALSE; \
     182             :         }
     183             : 
     184             : /* True global resources - no need for thread safety here */
     185             : static int le_fileinfo;
     186             : /* }}} */
     187             : 
     188          29 : void finfo_resource_destructor(zend_resource *rsrc TSRMLS_DC) /* {{{ */
     189             : {
     190          29 :         if (rsrc->ptr) {
     191          29 :                 php_fileinfo *finfo = (php_fileinfo *) rsrc->ptr;
     192          29 :                 magic_close(finfo->magic);
     193          29 :                 efree(rsrc->ptr);
     194          29 :                 rsrc->ptr = NULL;
     195             :         }
     196          29 : }
     197             : /* }}} */
     198             : 
     199             : 
     200             : /* {{{ fileinfo_functions[]
     201             :  */
     202             : zend_function_entry fileinfo_functions[] = {
     203             :         PHP_FE(finfo_open,              arginfo_finfo_open)
     204             :         PHP_FE(finfo_close,             arginfo_finfo_close)
     205             :         PHP_FE(finfo_set_flags, arginfo_finfo_set_flags)
     206             :         PHP_FE(finfo_file,              arginfo_finfo_file)
     207             :         PHP_FE(finfo_buffer,    arginfo_finfo_buffer)
     208             :         PHP_FE(mime_content_type, arginfo_mime_content_type)
     209             :         {NULL, NULL, NULL}
     210             : };
     211             : /* }}} */
     212             : 
     213             : /* {{{ PHP_MINIT_FUNCTION
     214             :  */
     215       20423 : PHP_MINIT_FUNCTION(finfo)
     216             : {
     217             :         zend_class_entry _finfo_class_entry;
     218       20423 :         INIT_CLASS_ENTRY(_finfo_class_entry, "finfo", finfo_class_functions);
     219       20423 :         _finfo_class_entry.create_object = finfo_objects_new;
     220       20423 :         finfo_class_entry = zend_register_internal_class(&_finfo_class_entry TSRMLS_CC);
     221             : 
     222             :         /* copy the standard object handlers to you handler table */
     223       20423 :         memcpy(&finfo_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
     224       20423 :         finfo_object_handlers.offset = XtOffsetOf(finfo_object, zo);
     225       20423 :         finfo_object_handlers.free_obj = finfo_objects_free;
     226             : 
     227       20423 :         le_fileinfo = zend_register_list_destructors_ex(finfo_resource_destructor, NULL, "file_info", module_number);
     228             : 
     229       20423 :         REGISTER_LONG_CONSTANT("FILEINFO_NONE",                       MAGIC_NONE, CONST_CS|CONST_PERSISTENT);
     230       20423 :         REGISTER_LONG_CONSTANT("FILEINFO_SYMLINK",            MAGIC_SYMLINK, CONST_CS|CONST_PERSISTENT);
     231       20423 :         REGISTER_LONG_CONSTANT("FILEINFO_MIME",                       MAGIC_MIME, CONST_CS|CONST_PERSISTENT);
     232       20423 :         REGISTER_LONG_CONSTANT("FILEINFO_MIME_TYPE",  MAGIC_MIME_TYPE, CONST_CS|CONST_PERSISTENT);
     233       20423 :         REGISTER_LONG_CONSTANT("FILEINFO_MIME_ENCODING",MAGIC_MIME_ENCODING, CONST_CS|CONST_PERSISTENT);
     234             : /*      REGISTER_LONG_CONSTANT("FILEINFO_COMPRESS",           MAGIC_COMPRESS, CONST_CS|CONST_PERSISTENT); disabled, as it does fork now */
     235       20423 :         REGISTER_LONG_CONSTANT("FILEINFO_DEVICES",            MAGIC_DEVICES, CONST_CS|CONST_PERSISTENT);
     236       20423 :         REGISTER_LONG_CONSTANT("FILEINFO_CONTINUE",           MAGIC_CONTINUE, CONST_CS|CONST_PERSISTENT);
     237             : #ifdef MAGIC_PRESERVE_ATIME
     238       20423 :         REGISTER_LONG_CONSTANT("FILEINFO_PRESERVE_ATIME",     MAGIC_PRESERVE_ATIME, CONST_CS|CONST_PERSISTENT);
     239             : #endif
     240             : #ifdef MAGIC_RAW
     241       20423 :         REGISTER_LONG_CONSTANT("FILEINFO_RAW",                        MAGIC_RAW, CONST_CS|CONST_PERSISTENT);
     242             : #endif
     243             : 
     244       20423 :         return SUCCESS;
     245             : }
     246             : /* }}} */
     247             : 
     248             : /* {{{ fileinfo_module_entry
     249             :  */
     250             : zend_module_entry fileinfo_module_entry = {
     251             :         STANDARD_MODULE_HEADER,
     252             :         "fileinfo",
     253             :         fileinfo_functions,
     254             :         PHP_MINIT(finfo),
     255             :         NULL,
     256             :         NULL,   
     257             :         NULL,
     258             :         PHP_MINFO(fileinfo),
     259             :         PHP_FILEINFO_VERSION,
     260             :         STANDARD_MODULE_PROPERTIES
     261             : };
     262             : /* }}} */
     263             : 
     264             : #ifdef COMPILE_DL_FILEINFO
     265             : ZEND_GET_MODULE(fileinfo)
     266             : #endif
     267             : 
     268             : /* {{{ PHP_MINFO_FUNCTION
     269             :  */
     270         143 : PHP_MINFO_FUNCTION(fileinfo)
     271             : {
     272             :         char magic_ver[5];
     273             : 
     274         143 :         (void)snprintf(magic_ver, 4, "%d", magic_version());
     275         143 :         magic_ver[4] = '\0';
     276             : 
     277         143 :         php_info_print_table_start();
     278         143 :         php_info_print_table_row(2, "fileinfo support", "enabled");
     279         143 :         php_info_print_table_row(2, "version", PHP_FILEINFO_VERSION);
     280         143 :         php_info_print_table_row(2, "libmagic", magic_ver);
     281         143 :         php_info_print_table_end();
     282         143 : }
     283             : /* }}} */
     284             : 
     285             : #define FILEINFO_DESTROY_OBJECT(object)                                                                 \
     286             :         do {                                                                                                                            \
     287             :                 if (object) {                                                                                                   \
     288             :                         zend_object_store_ctor_failed(Z_OBJ_P(object) TSRMLS_CC);       \
     289             :                         Z_OBJ_P(object) = NULL;                                                                         \
     290             :                         ZEND_CTOR_MAKE_NULL();                                                                          \
     291             :                 }                                                                                                                               \
     292             :         } while (0)
     293             : 
     294             : /* {{{ proto resource finfo_open([int options [, string arg]])
     295             :    Create a new fileinfo resource. */
     296          50 : PHP_FUNCTION(finfo_open)
     297             : {
     298          50 :         zend_long options = MAGIC_NONE;
     299          50 :         char *file = NULL;
     300          50 :         size_t file_len = 0;
     301             :         php_fileinfo *finfo;
     302          50 :         FILEINFO_DECLARE_INIT_OBJECT(object)
     303             :         char resolved_path[MAXPATHLEN];
     304             : 
     305          50 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lp", &options, &file, &file_len) == FAILURE) {
     306           6 :                 FILEINFO_DESTROY_OBJECT(object);
     307           6 :                 RETURN_FALSE;
     308             :         }
     309             : 
     310          44 :         if (object) {
     311           8 :                 finfo_object *finfo_obj = Z_FINFO_P(object);
     312             : 
     313           8 :                 if (finfo_obj->ptr) {
     314           1 :                         magic_close(finfo_obj->ptr->magic);
     315           1 :                         efree(finfo_obj->ptr);
     316           1 :                         finfo_obj->ptr = NULL;
     317             :                 }
     318             :         }
     319             : 
     320          44 :         if (file_len == 0) {
     321          12 :                 file = NULL;
     322          32 :         } else if (file && *file) { /* user specified file, perform open_basedir checks */
     323             : 
     324          32 :                 if (php_check_open_basedir(file TSRMLS_CC)) {
     325           0 :                         FILEINFO_DESTROY_OBJECT(object);
     326           0 :                         RETURN_FALSE;
     327             :                 }
     328          32 :                 if (!expand_filepath_with_mode(file, resolved_path, NULL, 0, CWD_EXPAND TSRMLS_CC)) {
     329           0 :                         FILEINFO_DESTROY_OBJECT(object);
     330           0 :                         RETURN_FALSE;
     331             :                 }
     332          32 :                 file = resolved_path;
     333             :         }
     334             : 
     335          44 :         finfo = emalloc(sizeof(php_fileinfo));
     336             : 
     337          44 :         finfo->options = options;
     338          44 :         finfo->magic = magic_open(options);
     339             : 
     340          44 :         if (finfo->magic == NULL) {
     341           0 :                 efree(finfo);
     342           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid mode '%pd'.", options);
     343           0 :                 FILEINFO_DESTROY_OBJECT(object);
     344           0 :                 RETURN_FALSE;
     345             :         }
     346             : 
     347          44 :         if (magic_load(finfo->magic, file) == -1) {
     348           7 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to load magic database at '%s'.", file);
     349           7 :                 magic_close(finfo->magic);
     350           7 :                 efree(finfo);
     351           7 :                 FILEINFO_DESTROY_OBJECT(object);
     352           7 :                 RETURN_FALSE;
     353             :         }
     354             : 
     355          37 :         if (object) {
     356           8 :                 FILEINFO_REGISTER_OBJECT(object, finfo);
     357             :         } else {
     358          29 :                 ZEND_REGISTER_RESOURCE(return_value, finfo, le_fileinfo);
     359             :         }
     360             : }
     361             : /* }}} */
     362             : 
     363             : /* {{{ proto resource finfo_close(resource finfo)
     364             :    Close fileinfo resource. */
     365          10 : PHP_FUNCTION(finfo_close)
     366             : {
     367             :         php_fileinfo *finfo;
     368             :         zval *zfinfo;
     369             : 
     370          10 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zfinfo) == FAILURE) {
     371           2 :                 RETURN_FALSE;
     372             :         }
     373           8 :         ZEND_FETCH_RESOURCE(finfo, php_fileinfo *, zfinfo, -1, "file_info", le_fileinfo);
     374             : 
     375           7 :         zend_list_close(Z_RES_P(zfinfo));
     376             : 
     377           7 :         RETURN_TRUE;
     378             : }
     379             : /* }}} */
     380             : 
     381             : /* {{{ proto bool finfo_set_flags(resource finfo, int options)
     382             :    Set libmagic configuration options. */
     383           5 : PHP_FUNCTION(finfo_set_flags)
     384             : {
     385             :         zend_long options;
     386             :         php_fileinfo *finfo;
     387             :         zval *zfinfo;
     388           5 :         FILEINFO_DECLARE_INIT_OBJECT(object)
     389             : 
     390           5 :         if (object) {
     391           2 :                 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &options) == FAILURE) {
     392           1 :                         RETURN_FALSE;
     393             :                 }
     394           1 :                 FILEINFO_FROM_OBJECT(finfo, object);
     395             :         } else {
     396           3 :                 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &zfinfo, &options) == FAILURE) {
     397           1 :                         RETURN_FALSE;
     398             :                 }
     399           2 :                 ZEND_FETCH_RESOURCE(finfo, php_fileinfo *, zfinfo, -1, "file_info", le_fileinfo);
     400             :         }
     401             : 
     402           3 :         FINFO_SET_OPTION(finfo->magic, options)
     403           3 :         finfo->options = options;
     404             : 
     405           3 :         RETURN_TRUE;
     406             : }
     407             : /* }}} */
     408             : 
     409             : #define FILEINFO_MODE_BUFFER 0
     410             : #define FILEINFO_MODE_STREAM 1
     411             : #define FILEINFO_MODE_FILE 2
     412             : 
     413          63 : static void _php_finfo_get_type(INTERNAL_FUNCTION_PARAMETERS, int mode, int mimetype_emu) /* {{{ */
     414             : {
     415          63 :         zend_long options = 0;
     416          63 :         char *ret_val = NULL, *buffer = NULL;
     417             :         size_t buffer_len;
     418          63 :         php_fileinfo *finfo = NULL;
     419          63 :         zval *zfinfo, *zcontext = NULL;
     420             :         zval *what;
     421          63 :         char mime_directory[] = "directory";
     422             : 
     423          63 :         struct magic_set *magic = NULL;
     424          63 :         FILEINFO_DECLARE_INIT_OBJECT(object)
     425             : 
     426          63 :         if (mimetype_emu) {
     427             : 
     428             :                 /* mime_content_type(..) emulation */
     429          11 :                 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &what) == FAILURE) {
     430           0 :                         return;
     431             :                 }
     432             : 
     433          22 :                 switch (Z_TYPE_P(what)) {
     434             :                         case IS_STRING:
     435           6 :                                 buffer = Z_STRVAL_P(what);
     436           6 :                                 buffer_len = Z_STRLEN_P(what);
     437           6 :                                 mode = FILEINFO_MODE_FILE;
     438           6 :                                 break;
     439             : 
     440             :                         case IS_RESOURCE:
     441           1 :                                 mode = FILEINFO_MODE_STREAM;
     442           1 :                                 break;
     443             : 
     444             :                         default:
     445           4 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can only process string or stream arguments");
     446           4 :                                 RETURN_FALSE;
     447             :                 }
     448             : 
     449           7 :                 magic = magic_open(MAGIC_MIME_TYPE);
     450           7 :                 if (magic_load(magic, NULL) == -1) {
     451           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to load magic database.");
     452           0 :                         goto common;
     453             :                 }
     454          52 :         } else if (object) {
     455          12 :                 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lr", &buffer, &buffer_len, &options, &zcontext) == FAILURE) {
     456           0 :                         RETURN_FALSE;
     457             :                 }
     458          12 :                 FILEINFO_FROM_OBJECT(finfo, object);
     459          12 :                 magic = finfo->magic;
     460             :         } else {
     461          40 :                 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|lr", &zfinfo, &buffer, &buffer_len, &options, &zcontext) == FAILURE) {
     462           2 :                         RETURN_FALSE;
     463             :                 }
     464          38 :                 ZEND_FETCH_RESOURCE(finfo, php_fileinfo *, zfinfo, -1, "file_info", le_fileinfo);
     465          38 :                 magic = finfo->magic;
     466             :         }       
     467             : 
     468             :         /* Set options for the current file/buffer. */
     469          57 :         if (options) {
     470          14 :                 FINFO_SET_OPTION(magic, options)
     471             :         }
     472             : 
     473          57 :         switch (mode) {
     474             :                 case FILEINFO_MODE_BUFFER:
     475             :                 {
     476          24 :                         ret_val = (char *) magic_buffer(magic, buffer, buffer_len);
     477          24 :                         break;
     478             :                 }
     479             : 
     480             :                 case FILEINFO_MODE_STREAM:
     481             :                 {
     482             :                                 php_stream *stream;
     483             :                                 zend_off_t streampos;
     484             : 
     485           1 :                                 php_stream_from_zval_no_verify(stream, what);
     486           1 :                                 if (!stream) {
     487           0 :                                         goto common;
     488             :                                 }
     489             : 
     490           1 :                                 streampos = php_stream_tell(stream); /* remember stream position for restoration */
     491           1 :                                 php_stream_seek(stream, 0, SEEK_SET);
     492             : 
     493           1 :                                 ret_val = (char *) magic_stream(magic, stream);
     494             : 
     495           1 :                                 php_stream_seek(stream, streampos, SEEK_SET);
     496           1 :                                 break;
     497             :                 }
     498             : 
     499             :                 case FILEINFO_MODE_FILE:
     500             :                 {
     501             :                         /* determine if the file is a local file or remote URL */
     502             :                         const char *tmp2;
     503             :                         php_stream_wrapper *wrap;
     504             :                         php_stream_statbuf ssb;
     505             : 
     506          32 :                         if (buffer == NULL || !*buffer) {
     507           5 :                                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty filename or path");
     508           5 :                                 RETVAL_FALSE;
     509           5 :                                 goto clean;
     510             :                         }
     511             : 
     512          27 :                         wrap = php_stream_locate_url_wrapper(buffer, &tmp2, 0 TSRMLS_CC);
     513             : 
     514          27 :                         if (wrap) {
     515             :                                 php_stream *stream;
     516          27 :                                 php_stream_context *context = php_stream_context_from_zval(zcontext, 0);
     517             : 
     518             : #ifdef PHP_WIN32
     519             :                                 if (php_stream_stat_path_ex(buffer, 0, &ssb, context) == SUCCESS) {
     520             :                                         if (ssb.sb.st_mode & S_IFDIR) {
     521             :                                                 ret_val = mime_directory;
     522             :                                                 goto common;
     523             :                                         }
     524             :                                 }
     525             : #endif
     526             : 
     527             : #if PHP_API_VERSION < 20100412
     528             :                                 stream = php_stream_open_wrapper_ex(buffer, "rb", ENFORCE_SAFE_MODE | REPORT_ERRORS, NULL, context);
     529             : #else
     530          27 :                                 stream = php_stream_open_wrapper_ex(buffer, "rb", REPORT_ERRORS, NULL, context);
     531             : #endif
     532             : 
     533          27 :                                 if (!stream) {
     534           2 :                                         RETVAL_FALSE;
     535           2 :                                         goto clean;
     536             :                                 }
     537             : 
     538          25 :                                 if (php_stream_stat(stream, &ssb) == SUCCESS) {
     539          25 :                                         if (ssb.sb.st_mode & S_IFDIR) {
     540           4 :                                                 ret_val = mime_directory;
     541             :                                         } else {
     542          21 :                                                 ret_val = (char *)magic_stream(magic, stream);
     543             :                                         }
     544             :                                 }
     545             : 
     546          25 :                                 php_stream_close(stream);
     547             :                         }
     548          25 :                         break;
     549             :                 }
     550             : 
     551             :                 default:
     552           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can only process string or stream arguments");
     553             :         }
     554             : 
     555             : common:
     556          50 :         if (ret_val) {
     557          98 :                 RETVAL_STRING(ret_val);
     558             :         } else {
     559           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed identify data %d:%s", magic_errno(magic), magic_error(magic));
     560           1 :                 RETVAL_FALSE;
     561             :         }
     562             : 
     563             : clean:
     564          57 :         if (mimetype_emu) {
     565           7 :                 magic_close(magic);
     566             :         }
     567             : 
     568             :         /* Restore options */
     569          57 :         if (options) {
     570          14 :                 FINFO_SET_OPTION(magic, finfo->options)
     571             :         }
     572          57 :         return;
     573             : }
     574             : /* }}} */
     575             : 
     576             : /* {{{ proto string finfo_file(resource finfo, char *file_name [, int options [, resource context]])
     577             :    Return information about a file. */
     578          26 : PHP_FUNCTION(finfo_file)
     579             : {
     580          26 :         _php_finfo_get_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, FILEINFO_MODE_FILE, 0);
     581          26 : }
     582             : /* }}} */
     583             : 
     584             : /* {{{ proto string finfo_buffer(resource finfo, char *string [, int options [, resource context]])
     585             :    Return infromation about a string buffer. */
     586          26 : PHP_FUNCTION(finfo_buffer)
     587             : {
     588          26 :         _php_finfo_get_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, FILEINFO_MODE_BUFFER, 0);
     589          26 : }
     590             : /* }}} */
     591             : 
     592             : /* {{{ proto string mime_content_type(string filename|resource stream)
     593             :    Return content-type for file */
     594          11 : PHP_FUNCTION(mime_content_type)
     595             : {
     596          11 :         _php_finfo_get_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, -1, 1);
     597          11 : }
     598             : /* }}} */
     599             : 
     600             : 
     601             : /*
     602             :  * Local variables:
     603             :  * tab-width: 4
     604             :  * c-basic-offset: 4
     605             :  * End:
     606             :  * vim600: noet sw=4 ts=4 fdm=marker
     607             :  * vim<600: noet sw=4 ts=4
     608             :  */

Generated by: LCOV version 1.10

Generated at Wed, 22 Oct 2014 07:24:48 +0000 (28 hours ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.