Back to index

php5  5.3.10
Defines | Typedefs | Functions
php_filestat.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines

#define MAKE_LONG_ZVAL_INCREF(name, val)
#define FS_PERMS   0
#define FS_INODE   1
#define FS_SIZE   2
#define FS_OWNER   3
#define FS_GROUP   4
#define FS_ATIME   5
#define FS_MTIME   6
#define FS_CTIME   7
#define FS_TYPE   8
#define FS_IS_W   9
#define FS_IS_R   10
#define FS_IS_X   11
#define FS_IS_FILE   12
#define FS_IS_DIR   13
#define FS_IS_LINK   14
#define FS_EXISTS   15
#define FS_LSTAT   16
#define FS_STAT   17

Typedefs

typedef int php_stat_len

Functions

 PHP_RINIT_FUNCTION (filestat)
 PHP_RSHUTDOWN_FUNCTION (filestat)
 PHP_FUNCTION (realpath_cache_size)
 PHP_FUNCTION (realpath_cache_get)
 PHP_FUNCTION (clearstatcache)
 PHP_FUNCTION (fileatime)
 PHP_FUNCTION (filectime)
 PHP_FUNCTION (filegroup)
 PHP_FUNCTION (fileinode)
 PHP_FUNCTION (filemtime)
 PHP_FUNCTION (fileowner)
 PHP_FUNCTION (fileperms)
 PHP_FUNCTION (filesize)
 PHP_FUNCTION (filetype)
 PHP_FUNCTION (is_writable)
 PHP_FUNCTION (is_readable)
 PHP_FUNCTION (is_executable)
 PHP_FUNCTION (is_file)
 PHP_FUNCTION (is_dir)
 PHP_FUNCTION (is_link)
 PHP_FUNCTION (file_exists)
 PHP_NAMED_FUNCTION (php_if_stat)
 PHP_NAMED_FUNCTION (php_if_lstat)
 PHP_FUNCTION (disk_total_space)
 PHP_FUNCTION (disk_free_space)
 PHP_FUNCTION (chown)
 PHP_FUNCTION (chgrp)
 PHP_FUNCTION (chmod)
PHPAPI void php_clear_stat_cache (zend_bool clear_realpath_cache, const char *filename, int filename_len TSRMLS_DC)
PHPAPI void php_stat (const char *filename, php_stat_len filename_length, int type, zval *return_value TSRMLS_DC)

Define Documentation

#define FS_ATIME   5

Definition at line 101 of file php_filestat.h.

#define FS_CTIME   7

Definition at line 103 of file php_filestat.h.

#define FS_EXISTS   15

Definition at line 111 of file php_filestat.h.

#define FS_GROUP   4

Definition at line 100 of file php_filestat.h.

#define FS_INODE   1

Definition at line 97 of file php_filestat.h.

#define FS_IS_DIR   13

Definition at line 109 of file php_filestat.h.

#define FS_IS_FILE   12

Definition at line 108 of file php_filestat.h.

#define FS_IS_LINK   14

Definition at line 110 of file php_filestat.h.

#define FS_IS_R   10

Definition at line 106 of file php_filestat.h.

#define FS_IS_W   9

Definition at line 105 of file php_filestat.h.

#define FS_IS_X   11

Definition at line 107 of file php_filestat.h.

#define FS_LSTAT   16

Definition at line 112 of file php_filestat.h.

#define FS_MTIME   6

Definition at line 102 of file php_filestat.h.

#define FS_OWNER   3

Definition at line 99 of file php_filestat.h.

#define FS_PERMS   0

Definition at line 96 of file php_filestat.h.

#define FS_SIZE   2

Definition at line 98 of file php_filestat.h.

#define FS_STAT   17

Definition at line 113 of file php_filestat.h.

#define FS_TYPE   8

Definition at line 104 of file php_filestat.h.

#define MAKE_LONG_ZVAL_INCREF (   name,
  val 
)
Value:
MAKE_STD_ZVAL(name); \
       ZVAL_LONG(name, val); \
       Z_ADDREF_P(name);

Definition at line 64 of file php_filestat.h.


Typedef Documentation

typedef int php_stat_len

Definition at line 89 of file php_filestat.h.


Function Documentation

PHPAPI void php_clear_stat_cache ( zend_bool  clear_realpath_cache,
const char *  filename,
int filename_len  TSRMLS_DC 
)

Definition at line 735 of file filestat.c.

{
       /* always clear CurrentStatFile and CurrentLStatFile even if filename is not NULL
        * as it may contain outdated data (e.g. "nlink" for a directory when deleting a file
        * in this directory, as shown by lstat_stat_variation9.phpt) */

       if (BG(CurrentStatFile)) {
              efree(BG(CurrentStatFile));
              BG(CurrentStatFile) = NULL;
       }
       if (BG(CurrentLStatFile)) {
              efree(BG(CurrentLStatFile));
              BG(CurrentLStatFile) = NULL;
       }
       if (clear_realpath_cache) {
              if (filename != NULL) {
                     realpath_cache_del(filename, filename_len TSRMLS_CC);
              } else {
                     realpath_cache_clean(TSRMLS_C);
              }
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

PHP_FUNCTION ( realpath_cache_get  )

Definition at line 1147 of file filestat.c.

{
       realpath_cache_bucket **buckets = realpath_cache_get_buckets(TSRMLS_C), **end = buckets + realpath_cache_max_buckets(TSRMLS_C);

       if (zend_parse_parameters_none() == FAILURE) {
              return;
       }

       array_init(return_value);
       while(buckets < end) {
              realpath_cache_bucket *bucket = *buckets;
              while(bucket) {
                     zval *entry;
                     MAKE_STD_ZVAL(entry);
                     array_init(entry);

                     add_assoc_long(entry, "key", bucket->key);
                     add_assoc_bool(entry, "is_dir", bucket->is_dir);
                     add_assoc_stringl(entry, "realpath", bucket->realpath, bucket->realpath_len, 1);
                     add_assoc_long(entry, "expires", bucket->expires);
#ifdef PHP_WIN32
                     add_assoc_bool(entry, "is_rvalid", bucket->is_rvalid);
                     add_assoc_bool(entry, "is_wvalid", bucket->is_wvalid);
                     add_assoc_bool(entry, "is_readable", bucket->is_readable);
                     add_assoc_bool(entry, "is_writable", bucket->is_writable);
#endif
                     zend_hash_update(Z_ARRVAL_P(return_value), bucket->path, bucket->path_len+1, &entry, sizeof(zval *), NULL);
                     bucket = bucket->next;
              }
              buckets++;
       }
}

Here is the call graph for this function:

PHP_FUNCTION ( clearstatcache  )

Definition at line 761 of file filestat.c.

{
       zend_bool  clear_realpath_cache = 0;
       char      *filename             = NULL;
       int        filename_len         = 0;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|bs", &clear_realpath_cache, &filename, &filename_len) == FAILURE) {
              return;
       }

       php_clear_stat_cache(clear_realpath_cache, filename, filename_len TSRMLS_CC);
}

Here is the call graph for this function:

PHP_FUNCTION ( fileatime  )
PHP_FUNCTION ( filectime  )
PHP_FUNCTION ( filegroup  )
PHP_FUNCTION ( fileinode  )
PHP_FUNCTION ( filemtime  )
PHP_FUNCTION ( fileowner  )
PHP_FUNCTION ( fileperms  )
PHP_FUNCTION ( filesize  )
PHP_FUNCTION ( filetype  )
PHP_FUNCTION ( is_writable  )
PHP_FUNCTION ( is_readable  )
PHP_FUNCTION ( is_executable  )
PHP_FUNCTION ( is_file  )
PHP_FUNCTION ( is_dir  )
PHP_FUNCTION ( is_link  )
PHP_FUNCTION ( file_exists  )
PHP_FUNCTION ( disk_total_space  )

Definition at line 233 of file filestat.c.

{
       double bytestotal;
       char *path;
       int path_len;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &path_len) == FAILURE) {
              return;
       }

       if (php_check_open_basedir(path TSRMLS_CC)) {
              RETURN_FALSE;
       }

       if (php_disk_total_space(path, &bytestotal TSRMLS_CC) == SUCCESS) {
              RETURN_DOUBLE(bytestotal);
       }
       RETURN_FALSE;
}

Here is the call graph for this function:

PHP_FUNCTION ( disk_free_space  )

Definition at line 368 of file filestat.c.

{
       double bytesfree;
       char *path;
       int path_len;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &path, &path_len) == FAILURE) {
              return;
       }

       if (php_check_open_basedir(path TSRMLS_CC)) {
              RETURN_FALSE;
       }

       if (strlen(path) != path_len) {
              RETURN_FALSE;
       }

       if (php_disk_free_space(path, &bytesfree TSRMLS_CC) == SUCCESS) {
              RETURN_DOUBLE(bytesfree);
       }
       RETURN_FALSE;
}

Here is the call graph for this function:

PHP_FUNCTION ( chown  )

Definition at line 577 of file filestat.c.

{
#if !defined(WINDOWS)
       RETVAL_TRUE;
       php_do_chown(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
#else
       RETURN_FALSE;
#endif
}

Here is the call graph for this function:

PHP_FUNCTION ( chgrp  )

Definition at line 473 of file filestat.c.

{
#if !defined(WINDOWS)
       php_do_chgrp(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
#else
       RETURN_FALSE;
#endif
}

Here is the call graph for this function:

PHP_FUNCTION ( chmod  )

Definition at line 606 of file filestat.c.

{
       char *filename;
       int filename_len;
       long mode;
       int ret;
       mode_t imode;

       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &filename, &filename_len, &mode) == FAILURE) {
              return;
       }

       if (PG(safe_mode) &&(!php_checkuid(filename, NULL, CHECKUID_ALLOW_FILE_NOT_EXISTS))) {
              RETURN_FALSE;
       }

       if (strlen(filename) != filename_len) {
              RETURN_FALSE;
       }

       /* Check the basedir */
       if (php_check_open_basedir(filename TSRMLS_CC)) {
              RETURN_FALSE;
       }

       imode = (mode_t) mode;
       /* In safe mode, do not allow to setuid files.
        * Setuiding files could allow users to gain privileges
        * that safe mode doesn't give them. */

       if (PG(safe_mode)) {
              php_stream_statbuf ssb;
              if (php_stream_stat_path_ex(filename, 0, &ssb, NULL)) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "stat failed for %s", filename);
                     RETURN_FALSE;
              }
              if ((imode & 04000) != 0 && (ssb.sb.st_mode & 04000) == 0) {
                     imode ^= 04000;
              }
              if ((imode & 02000) != 0 && (ssb.sb.st_mode & 02000) == 0) {
                     imode ^= 02000;
              }
              if ((imode & 01000) != 0 && (ssb.sb.st_mode & 01000) == 0) {
                     imode ^= 01000;
              }
       }

       ret = VCWD_CHMOD(filename, imode);
       if (ret == -1) {
              php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
              RETURN_FALSE;
       }
       RETURN_TRUE;
}

Here is the call graph for this function:

PHP_NAMED_FUNCTION ( php_if_stat  )
PHP_NAMED_FUNCTION ( php_if_lstat  )
PHP_RINIT_FUNCTION ( filestat  )

Definition at line 101 of file filestat.c.

{
       BG(CurrentStatFile)=NULL;
       BG(CurrentLStatFile)=NULL;
       return SUCCESS;
}
PHP_RSHUTDOWN_FUNCTION ( filestat  )

Definition at line 109 of file filestat.c.

{
       if (BG(CurrentStatFile)) {
              efree (BG(CurrentStatFile));
              BG(CurrentStatFile) = NULL;
       }
       if (BG(CurrentLStatFile)) {
              efree (BG(CurrentLStatFile));
              BG(CurrentLStatFile) = NULL;
       }
       return SUCCESS;
}
PHPAPI void php_stat ( const char *  filename,
php_stat_len  filename_length,
int  type,
zval *return_value  TSRMLS_DC 
)

Definition at line 782 of file filestat.c.

{
       zval *stat_dev, *stat_ino, *stat_mode, *stat_nlink, *stat_uid, *stat_gid, *stat_rdev,
               *stat_size, *stat_atime, *stat_mtime, *stat_ctime, *stat_blksize, *stat_blocks;
       struct stat *stat_sb;
       php_stream_statbuf ssb;
       int flags = 0, rmask=S_IROTH, wmask=S_IWOTH, xmask=S_IXOTH; /* access rights defaults to other */
       char *stat_sb_names[13] = {
              "dev", "ino", "mode", "nlink", "uid", "gid", "rdev",
              "size", "atime", "mtime", "ctime", "blksize", "blocks"
       };
       char *local;
       php_stream_wrapper *wrapper;
       char safe_mode_buf[MAXPATHLEN];

       if (!filename_length) {
              RETURN_FALSE;
       }

       if (strlen(filename) != filename_length) {
              RETURN_FALSE;
       }

       if ((wrapper = php_stream_locate_url_wrapper(filename, &local, 0 TSRMLS_CC)) == &php_plain_files_wrapper) {
              if (php_check_open_basedir(local TSRMLS_CC)) {
                     RETURN_FALSE;
              } else if (PG(safe_mode)) {
                     if (type == FS_IS_X) {
                            if (strstr(local, "..")) {
                                   RETURN_FALSE;
                            } else {
                                   char *b = strrchr(local, PHP_DIR_SEPARATOR);
                                   snprintf(safe_mode_buf, MAXPATHLEN, "%s%s%s", PG(safe_mode_exec_dir), (b ? "" : "/"), (b ? b : local));
                                   local = (char *)&safe_mode_buf;
                            }
                     } else if (!php_checkuid_ex(local, NULL, CHECKUID_ALLOW_FILE_NOT_EXISTS, CHECKUID_NO_ERRORS)) {
                            RETURN_FALSE;
                     }
              }
       }

       if (IS_ACCESS_CHECK(type)) {
              if (wrapper == &php_plain_files_wrapper) {

                     switch (type) {
#ifdef F_OK
                            case FS_EXISTS:
                                   RETURN_BOOL(VCWD_ACCESS(local, F_OK) == 0);
                                   break;
#endif
#ifdef W_OK
                            case FS_IS_W:
                                   RETURN_BOOL(VCWD_ACCESS(local, W_OK) == 0);
                                   break;
#endif
#ifdef R_OK
                            case FS_IS_R:
                                   RETURN_BOOL(VCWD_ACCESS(local, R_OK) == 0);
                                   break;
#endif
#ifdef X_OK
                            case FS_IS_X:
                                   RETURN_BOOL(VCWD_ACCESS(local, X_OK) == 0);
                                   break;
#endif
                     }
              }
       }

       if (IS_LINK_OPERATION(type)) {
              flags |= PHP_STREAM_URL_STAT_LINK;
       }
       if (IS_EXISTS_CHECK(type)) {
              flags |= PHP_STREAM_URL_STAT_QUIET;
       }

       if (php_stream_stat_path_ex((char *)filename, flags, &ssb, NULL)) {
              /* Error Occured */
              if (!IS_EXISTS_CHECK(type)) {
                     php_error_docref(NULL TSRMLS_CC, E_WARNING, "%sstat failed for %s", IS_LINK_OPERATION(type) ? "L" : "", filename);
              }
              RETURN_FALSE;
       }

       stat_sb = &ssb.sb;


#ifndef NETWARE
       if (type >= FS_IS_W && type <= FS_IS_X) {
              if(ssb.sb.st_uid==getuid()) {
                     rmask=S_IRUSR;
                     wmask=S_IWUSR;
                     xmask=S_IXUSR;
              } else if(ssb.sb.st_gid==getgid()) {
                     rmask=S_IRGRP;
                     wmask=S_IWGRP;
                     xmask=S_IXGRP;
              } else {
                     int   groups, n, i;
                     gid_t *gids;

                     groups = getgroups(0, NULL);
                     if(groups > 0) {
                            gids=(gid_t *)safe_emalloc(groups, sizeof(gid_t), 0);
                            n=getgroups(groups, gids);
                            for(i=0;i<n;i++){
                                   if(ssb.sb.st_gid==gids[i]) {
                                          rmask=S_IRGRP;
                                          wmask=S_IWGRP;
                                          xmask=S_IXGRP;
                                          break;
                                   }
                            }
                            efree(gids);
                     }
              }
       }
#endif

#ifndef NETWARE
       if (IS_ABLE_CHECK(type) && getuid() == 0) {
              /* root has special perms on plain_wrapper
                 But we don't know about root under Netware */
              if (wrapper == &php_plain_files_wrapper) {
                     if (type == FS_IS_X) {
                            xmask = S_IXROOT;
                     } else {
                            RETURN_TRUE;
                     }
              }
       }
#endif

       switch (type) {
       case FS_PERMS:
              RETURN_LONG((long)ssb.sb.st_mode);
       case FS_INODE:
              RETURN_LONG((long)ssb.sb.st_ino);
       case FS_SIZE:
              RETURN_LONG((long)ssb.sb.st_size);
       case FS_OWNER:
              RETURN_LONG((long)ssb.sb.st_uid);
       case FS_GROUP:
              RETURN_LONG((long)ssb.sb.st_gid);
       case FS_ATIME:
              RETURN_LONG((long)ssb.sb.st_atime);
       case FS_MTIME:
              RETURN_LONG((long)ssb.sb.st_mtime);
       case FS_CTIME:
              RETURN_LONG((long)ssb.sb.st_ctime);
       case FS_TYPE:
              if (S_ISLNK(ssb.sb.st_mode)) {
                     RETURN_STRING("link", 1);
              }
              switch(ssb.sb.st_mode & S_IFMT) {
              case S_IFIFO: RETURN_STRING("fifo", 1);
              case S_IFCHR: RETURN_STRING("char", 1);
              case S_IFDIR: RETURN_STRING("dir", 1);
              case S_IFBLK: RETURN_STRING("block", 1);
              case S_IFREG: RETURN_STRING("file", 1);
#if defined(S_IFSOCK) && !defined(ZEND_WIN32)&&!defined(__BEOS__)
              case S_IFSOCK: RETURN_STRING("socket", 1);
#endif
              }
              php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Unknown file type (%d)", ssb.sb.st_mode&S_IFMT);
              RETURN_STRING("unknown", 1);
       case FS_IS_W:
              RETURN_BOOL((ssb.sb.st_mode & wmask) != 0);
       case FS_IS_R:
              RETURN_BOOL((ssb.sb.st_mode&rmask)!=0);
       case FS_IS_X:
              RETURN_BOOL((ssb.sb.st_mode&xmask)!=0 && !S_ISDIR(ssb.sb.st_mode));
       case FS_IS_FILE:
              RETURN_BOOL(S_ISREG(ssb.sb.st_mode));
       case FS_IS_DIR:
              RETURN_BOOL(S_ISDIR(ssb.sb.st_mode));
       case FS_IS_LINK:
              RETURN_BOOL(S_ISLNK(ssb.sb.st_mode));
       case FS_EXISTS:
              RETURN_TRUE; /* the false case was done earlier */
       case FS_LSTAT:
              /* FALLTHROUGH */
       case FS_STAT:
              array_init(return_value);

              MAKE_LONG_ZVAL_INCREF(stat_dev, stat_sb->st_dev);
              MAKE_LONG_ZVAL_INCREF(stat_ino, stat_sb->st_ino);
              MAKE_LONG_ZVAL_INCREF(stat_mode, stat_sb->st_mode);
              MAKE_LONG_ZVAL_INCREF(stat_nlink, stat_sb->st_nlink);
              MAKE_LONG_ZVAL_INCREF(stat_uid, stat_sb->st_uid);
              MAKE_LONG_ZVAL_INCREF(stat_gid, stat_sb->st_gid);
#ifdef HAVE_ST_RDEV
              MAKE_LONG_ZVAL_INCREF(stat_rdev, stat_sb->st_rdev);
#else
              MAKE_LONG_ZVAL_INCREF(stat_rdev, -1);
#endif
              MAKE_LONG_ZVAL_INCREF(stat_size, stat_sb->st_size);
              MAKE_LONG_ZVAL_INCREF(stat_atime, stat_sb->st_atime);
              MAKE_LONG_ZVAL_INCREF(stat_mtime, stat_sb->st_mtime);
              MAKE_LONG_ZVAL_INCREF(stat_ctime, stat_sb->st_ctime);
#ifdef HAVE_ST_BLKSIZE
              MAKE_LONG_ZVAL_INCREF(stat_blksize, stat_sb->st_blksize);
#else
              MAKE_LONG_ZVAL_INCREF(stat_blksize,-1);
#endif
#ifdef HAVE_ST_BLOCKS
              MAKE_LONG_ZVAL_INCREF(stat_blocks, stat_sb->st_blocks);
#else
              MAKE_LONG_ZVAL_INCREF(stat_blocks,-1);
#endif
              /* Store numeric indexes in propper order */
              zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_dev, sizeof(zval *), NULL);
              zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_ino, sizeof(zval *), NULL);
              zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_mode, sizeof(zval *), NULL);
              zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_nlink, sizeof(zval *), NULL);
              zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_uid, sizeof(zval *), NULL);
              zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_gid, sizeof(zval *), NULL);

              zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_rdev, sizeof(zval *), NULL);
              zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_size, sizeof(zval *), NULL);
              zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_atime, sizeof(zval *), NULL);
              zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_mtime, sizeof(zval *), NULL);
              zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_ctime, sizeof(zval *), NULL);
              zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_blksize, sizeof(zval *), NULL);
              zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_blocks, sizeof(zval *), NULL);

              /* Store string indexes referencing the same zval*/
              zend_hash_update(HASH_OF(return_value), stat_sb_names[0], strlen(stat_sb_names[0])+1, (void *) &stat_dev, sizeof(zval *), NULL);
              zend_hash_update(HASH_OF(return_value), stat_sb_names[1], strlen(stat_sb_names[1])+1, (void *) &stat_ino, sizeof(zval *), NULL);
              zend_hash_update(HASH_OF(return_value), stat_sb_names[2], strlen(stat_sb_names[2])+1, (void *) &stat_mode, sizeof(zval *), NULL);
              zend_hash_update(HASH_OF(return_value), stat_sb_names[3], strlen(stat_sb_names[3])+1, (void *) &stat_nlink, sizeof(zval *), NULL);
              zend_hash_update(HASH_OF(return_value), stat_sb_names[4], strlen(stat_sb_names[4])+1, (void *) &stat_uid, sizeof(zval *), NULL);
              zend_hash_update(HASH_OF(return_value), stat_sb_names[5], strlen(stat_sb_names[5])+1, (void *) &stat_gid, sizeof(zval *), NULL);
              zend_hash_update(HASH_OF(return_value), stat_sb_names[6], strlen(stat_sb_names[6])+1, (void *) &stat_rdev, sizeof(zval *), NULL);
              zend_hash_update(HASH_OF(return_value), stat_sb_names[7], strlen(stat_sb_names[7])+1, (void *) &stat_size, sizeof(zval *), NULL);
              zend_hash_update(HASH_OF(return_value), stat_sb_names[8], strlen(stat_sb_names[8])+1, (void *) &stat_atime, sizeof(zval *), NULL);
              zend_hash_update(HASH_OF(return_value), stat_sb_names[9], strlen(stat_sb_names[9])+1, (void *) &stat_mtime, sizeof(zval *), NULL);
              zend_hash_update(HASH_OF(return_value), stat_sb_names[10], strlen(stat_sb_names[10])+1, (void *) &stat_ctime, sizeof(zval *), NULL);
              zend_hash_update(HASH_OF(return_value), stat_sb_names[11], strlen(stat_sb_names[11])+1, (void *) &stat_blksize, sizeof(zval *), NULL);
              zend_hash_update(HASH_OF(return_value), stat_sb_names[12], strlen(stat_sb_names[12])+1, (void *) &stat_blocks, sizeof(zval *), NULL);

              return;
       }
       php_error_docref(NULL TSRMLS_CC, E_WARNING, "Didn't understand stat call");
       RETURN_FALSE;
}

Here is the call graph for this function:

Here is the caller graph for this function: