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 - main/streams - plain_wrapper.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 372 567 65.6 %
Date: 2014-10-22 Functions: 28 30 93.3 %
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.01 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_01.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             :    | Authors: Wez Furlong <wez@thebrainroom.com>                          |
      16             :    +----------------------------------------------------------------------+
      17             :  */
      18             : 
      19             : /* $Id$ */
      20             : 
      21             : #include "php.h"
      22             : #include "php_globals.h"
      23             : #include "php_network.h"
      24             : #include "php_open_temporary_file.h"
      25             : #include "ext/standard/file.h"
      26             : #include "ext/standard/flock_compat.h"
      27             : #include "ext/standard/php_filestat.h"
      28             : #include <stddef.h>
      29             : #include <fcntl.h>
      30             : #if HAVE_SYS_WAIT_H
      31             : #include <sys/wait.h>
      32             : #endif
      33             : #if HAVE_SYS_FILE_H
      34             : #include <sys/file.h>
      35             : #endif
      36             : #ifdef HAVE_SYS_MMAN_H
      37             : #include <sys/mman.h>
      38             : #endif
      39             : #include "SAPI.h"
      40             : 
      41             : #include "php_streams_int.h"
      42             : #ifdef PHP_WIN32
      43             : # include "win32/winutil.h"
      44             : #endif
      45             : 
      46             : #define php_stream_fopen_from_fd_int(fd, mode, persistent_id)   _php_stream_fopen_from_fd_int((fd), (mode), (persistent_id) STREAMS_CC TSRMLS_CC)
      47             : #define php_stream_fopen_from_fd_int_rel(fd, mode, persistent_id)        _php_stream_fopen_from_fd_int((fd), (mode), (persistent_id) STREAMS_REL_CC TSRMLS_CC)
      48             : #define php_stream_fopen_from_file_int(file, mode)      _php_stream_fopen_from_file_int((file), (mode) STREAMS_CC TSRMLS_CC)
      49             : #define php_stream_fopen_from_file_int_rel(file, mode)   _php_stream_fopen_from_file_int((file), (mode) STREAMS_REL_CC TSRMLS_CC)
      50             : 
      51             : #if !defined(WINDOWS) && !defined(NETWARE)
      52             : extern int php_get_uid_by_name(const char *name, uid_t *uid TSRMLS_DC);
      53             : extern int php_get_gid_by_name(const char *name, gid_t *gid TSRMLS_DC);
      54             : #endif
      55             : 
      56             : #if defined(PHP_WIN32)
      57             : # define PLAIN_WRAP_BUF_SIZE(st) (((st) > UINT_MAX) ? UINT_MAX : (unsigned int)(st))
      58             : #else
      59             : # define PLAIN_WRAP_BUF_SIZE(st) (st)
      60             : #endif
      61             : 
      62             : /* parse standard "fopen" modes into open() flags */
      63       77618 : PHPAPI int php_stream_parse_fopen_modes(const char *mode, int *open_flags)
      64             : {
      65             :         int flags;
      66             : 
      67       77618 :         switch (mode[0]) {
      68             :                 case 'r':
      69       37504 :                         flags = 0;
      70       37504 :                         break;
      71             :                 case 'w':
      72       37068 :                         flags = O_TRUNC|O_CREAT;
      73       37068 :                         break;
      74             :                 case 'a':
      75        1591 :                         flags = O_CREAT|O_APPEND;
      76        1591 :                         break;
      77             :                 case 'x':
      78        1431 :                         flags = O_CREAT|O_EXCL;
      79        1431 :                         break;
      80             :                 case 'c':
      81           1 :                         flags = O_CREAT;
      82           1 :                         break;
      83             :                 default:
      84             :                         /* unknown mode */
      85          23 :                         return FAILURE;
      86             :         }
      87             : 
      88       77595 :         if (strchr(mode, '+')) {
      89        9535 :                 flags |= O_RDWR;
      90       68060 :         } else if (flags) {
      91       31237 :                 flags |= O_WRONLY;
      92             :         } else {
      93       36823 :                 flags |= O_RDONLY;
      94             :         }
      95             : 
      96             : #if defined(O_NONBLOCK)
      97       77595 :         if (strchr(mode, 'n')) {
      98           0 :                 flags |= O_NONBLOCK;
      99             :         }
     100             : #endif
     101             : 
     102             : #if defined(_O_TEXT) && defined(O_BINARY)
     103             :         if (strchr(mode, 't')) {
     104             :                 flags |= _O_TEXT;
     105             :         } else {
     106             :                 flags |= O_BINARY;
     107             :         }
     108             : #endif
     109             : 
     110       77595 :         *open_flags = flags;
     111       77595 :         return SUCCESS;
     112             : }
     113             : 
     114             : 
     115             : /* {{{ ------- STDIO stream implementation -------*/
     116             : 
     117             : typedef struct {
     118             :         FILE *file;
     119             :         int fd;                                 /* underlying file descriptor */
     120             :         unsigned is_process_pipe:1;     /* use pclose instead of fclose */
     121             :         unsigned is_pipe:1;                     /* don't try and seek */
     122             :         unsigned cached_fstat:1;        /* sb is valid */
     123             :         unsigned _reserved:29;
     124             :         
     125             :         int lock_flag;                  /* stores the lock state */
     126             :         char *temp_file_name;   /* if non-null, this is the path to a temporary file that
     127             :                                                          * is to be deleted when the stream is closed */
     128             : #if HAVE_FLUSHIO
     129             :         char last_op;
     130             : #endif
     131             : 
     132             : #if HAVE_MMAP
     133             :         char *last_mapped_addr;
     134             :         size_t last_mapped_len;
     135             : #endif
     136             : #ifdef PHP_WIN32
     137             :         char *last_mapped_addr;
     138             :         HANDLE file_mapping;
     139             : #endif
     140             : 
     141             :         zend_stat_t sb;
     142             : } php_stdio_stream_data;
     143             : #define PHP_STDIOP_GET_FD(anfd, data)   anfd = (data)->file ? fileno((data)->file) : (data)->fd
     144             : 
     145      267438 : static int do_fstat(php_stdio_stream_data *d, int force)
     146             : {
     147      267438 :         if (!d->cached_fstat || force) {
     148             :                 int fd;
     149             :                 int r;
     150             :            
     151      267438 :                 PHP_STDIOP_GET_FD(fd, d);
     152      267438 :                 r = zend_fstat(fd, &d->sb);
     153      267438 :                 d->cached_fstat = r == 0;
     154             : 
     155      267438 :                 return r;
     156             :         }
     157           0 :         return 0;
     158             : }
     159             : 
     160      151963 : static php_stream *_php_stream_fopen_from_fd_int(int fd, const char *mode, const char *persistent_id STREAMS_DC TSRMLS_DC)
     161             : {
     162             :         php_stdio_stream_data *self;
     163             :         
     164      303926 :         self = pemalloc_rel_orig(sizeof(*self), persistent_id);
     165      151963 :         memset(self, 0, sizeof(*self));
     166      151963 :         self->file = NULL;
     167      151963 :         self->is_pipe = 0;
     168      151963 :         self->lock_flag = LOCK_UN;
     169      151963 :         self->is_process_pipe = 0;
     170      151963 :         self->temp_file_name = NULL;
     171      151963 :         self->fd = fd;
     172             :         
     173      151963 :         return php_stream_alloc_rel(&php_stream_stdio_ops, self, persistent_id, mode);
     174             : }
     175             : 
     176       59850 : static php_stream *_php_stream_fopen_from_file_int(FILE *file, const char *mode STREAMS_DC TSRMLS_DC)
     177             : {
     178             :         php_stdio_stream_data *self;
     179             :         
     180       59850 :         self = emalloc_rel_orig(sizeof(*self));
     181       59850 :         memset(self, 0, sizeof(*self));
     182       59850 :         self->file = file;
     183       59850 :         self->is_pipe = 0;
     184       59850 :         self->lock_flag = LOCK_UN;
     185       59850 :         self->is_process_pipe = 0;
     186       59850 :         self->temp_file_name = NULL;
     187       59850 :         self->fd = fileno(file);
     188             : 
     189       59850 :         return php_stream_alloc_rel(&php_stream_stdio_ops, self, 0, mode);
     190             : }
     191             : 
     192       14088 : PHPAPI php_stream *_php_stream_fopen_temporary_file(const char *dir, const char *pfx, char **opened_path_ptr STREAMS_DC TSRMLS_DC)
     193             : {
     194       14088 :         char *opened_path = NULL;
     195             :         int fd;
     196             : 
     197       14088 :         fd = php_open_temporary_fd(dir, pfx, &opened_path TSRMLS_CC);
     198       14088 :         if (fd != -1)   {
     199             :                 php_stream *stream;
     200             : 
     201       14088 :                 if (opened_path_ptr) {
     202           0 :                         *opened_path_ptr = opened_path;
     203             :                 }
     204             : 
     205       14088 :                 stream = php_stream_fopen_from_fd_int_rel(fd, "r+b", NULL);
     206       14088 :                 if (stream) {
     207       14088 :                         php_stdio_stream_data *self = (php_stdio_stream_data*)stream->abstract;
     208       14088 :                         stream->wrapper = &php_plain_files_wrapper;
     209       14088 :                         stream->orig_path = estrdup(opened_path);
     210             : 
     211       14088 :                         self->temp_file_name = opened_path;
     212       14088 :                         self->lock_flag = LOCK_UN;
     213             :                         
     214       14088 :                         return stream;
     215             :                 }
     216           0 :                 close(fd);
     217             : 
     218           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to allocate stream");
     219             : 
     220           0 :                 return NULL;
     221             :         }
     222           0 :         return NULL;
     223             : }
     224             : 
     225       14087 : PHPAPI php_stream *_php_stream_fopen_tmpfile(int dummy STREAMS_DC TSRMLS_DC)
     226             : {
     227       14087 :         return php_stream_fopen_temporary_file(NULL, "php", NULL);
     228             : }
     229             : 
     230      129537 : PHPAPI php_stream *_php_stream_fopen_from_fd(int fd, const char *mode, const char *persistent_id STREAMS_DC TSRMLS_DC)
     231             : {
     232      129537 :         php_stream *stream = php_stream_fopen_from_fd_int_rel(fd, mode, persistent_id);
     233             : 
     234      129537 :         if (stream) {
     235      129537 :                 php_stdio_stream_data *self = (php_stdio_stream_data*)stream->abstract;
     236             : 
     237             : #ifdef S_ISFIFO
     238             :                 /* detect if this is a pipe */
     239      129537 :                 if (self->fd >= 0) {
     240      129537 :                         self->is_pipe = (do_fstat(self, 0) == 0 && S_ISFIFO(self->sb.st_mode)) ? 1 : 0;
     241             :                 }
     242             : #elif defined(PHP_WIN32)
     243             :                 {
     244             :                         zend_uintptr_t handle = _get_osfhandle(self->fd);
     245             : 
     246             :                         if (handle != (zend_uintptr_t)INVALID_HANDLE_VALUE) {
     247             :                                 self->is_pipe = GetFileType((HANDLE)handle) == FILE_TYPE_PIPE;
     248             :                         }
     249             :                 }
     250             : #endif
     251             :         
     252      129537 :                 if (self->is_pipe) {
     253       60908 :                         stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
     254             :                 } else {
     255       68629 :                         stream->position = zend_lseek(self->fd, 0, SEEK_CUR);
     256             : #ifdef ESPIPE
     257       68629 :                         if (stream->position == (zend_off_t)-1 && errno == ESPIPE) {
     258           0 :                                 stream->position = 0;
     259           0 :                                 stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
     260           0 :                                 self->is_pipe = 1;
     261             :                         }
     262             : #endif
     263             :                 }
     264             :         }
     265             : 
     266      129537 :         return stream;
     267             : }
     268             : 
     269       59850 : PHPAPI php_stream *_php_stream_fopen_from_file(FILE *file, const char *mode STREAMS_DC TSRMLS_DC)
     270             : {
     271       59850 :         php_stream *stream = php_stream_fopen_from_file_int_rel(file, mode);
     272             : 
     273       59850 :         if (stream) {
     274       59850 :                 php_stdio_stream_data *self = (php_stdio_stream_data*)stream->abstract;
     275             : 
     276             : #ifdef S_ISFIFO
     277             :                 /* detect if this is a pipe */
     278       59850 :                 if (self->fd >= 0) {
     279       59850 :                         self->is_pipe = (do_fstat(self, 0) == 0 && S_ISFIFO(self->sb.st_mode)) ? 1 : 0;
     280             :                 }
     281             : #elif defined(PHP_WIN32)
     282             :                 {
     283             :                         zend_uintptr_t handle = _get_osfhandle(self->fd);
     284             : 
     285             :                         if (handle != (zend_uintptr_t)INVALID_HANDLE_VALUE) {
     286             :                                 self->is_pipe = GetFileType((HANDLE)handle) == FILE_TYPE_PIPE;
     287             :                         }
     288             :                 }
     289             : #endif
     290             :         
     291       59850 :                 if (self->is_pipe) {
     292       59842 :                         stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
     293             :                 } else {
     294           8 :                         stream->position = zend_ftell(file);
     295             :                 }
     296             :         }
     297             : 
     298       59850 :         return stream;
     299             : }
     300             : 
     301         158 : PHPAPI php_stream *_php_stream_fopen_from_pipe(FILE *file, const char *mode STREAMS_DC TSRMLS_DC)
     302             : {
     303             :         php_stdio_stream_data *self;
     304             :         php_stream *stream;
     305             : 
     306         158 :         self = emalloc_rel_orig(sizeof(*self));
     307         158 :         memset(self, 0, sizeof(*self));
     308         158 :         self->file = file;
     309         158 :         self->is_pipe = 1;
     310         158 :         self->lock_flag = LOCK_UN;
     311         158 :         self->is_process_pipe = 1;
     312         158 :         self->fd = fileno(file);
     313         158 :         self->temp_file_name = NULL;
     314             : 
     315         158 :         stream = php_stream_alloc_rel(&php_stream_stdio_ops, self, 0, mode);
     316         158 :         stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
     317         158 :         return stream;
     318             : }
     319             : 
     320      202955 : static size_t php_stdiop_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
     321             : {
     322      202955 :         php_stdio_stream_data *data = (php_stdio_stream_data*)stream->abstract;
     323             : 
     324             :         assert(data != NULL);
     325             : 
     326      202955 :         if (data->fd >= 0) {
     327      202955 :                 int bytes_written = write(data->fd, buf, count);
     328      202955 :                 if (bytes_written < 0) return 0;
     329      202900 :                 return (size_t) bytes_written;
     330             :         } else {
     331             : 
     332             : #if HAVE_FLUSHIO
     333             :                 if (!data->is_pipe && data->last_op == 'r') {
     334             :                         fseek(data->file, 0, SEEK_CUR);
     335             :                 }
     336             :                 data->last_op = 'w';
     337             : #endif
     338             : 
     339           0 :                 return fwrite(buf, 1, count, data->file);
     340             :         }
     341             : }
     342             : 
     343      966820 : static size_t php_stdiop_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
     344             : {
     345      966820 :         php_stdio_stream_data *data = (php_stdio_stream_data*)stream->abstract;
     346             :         size_t ret;
     347             : 
     348             :         assert(data != NULL);
     349             : 
     350      966820 :         if (data->fd >= 0) {
     351             : #ifdef PHP_WIN32
     352             :                 php_stdio_stream_data *self = (php_stdio_stream_data*)stream->abstract;
     353             : 
     354             :                 if (self->is_pipe || self->is_process_pipe) {
     355             :                         HANDLE ph = (HANDLE)_get_osfhandle(data->fd);
     356             :                         int retry = 0;
     357             :                         DWORD avail_read = 0;
     358             : 
     359             :                         do {
     360             :                                 /* Look ahead to get the available data amount to read. Do the same
     361             :                                         as read() does, however not blocking forever. In case it failed,
     362             :                                         no data will be read (better than block). */
     363             :                                 if (!PeekNamedPipe(ph, NULL, 0, NULL, &avail_read, NULL)) {
     364             :                                         break;
     365             :                                 }
     366             :                                 /* If there's nothing to read, wait in 100ms periods. */
     367             :                                 if (0 == avail_read) {
     368             :                                         usleep(100000);
     369             :                                 }
     370             :                         } while (0 == avail_read && retry++ < 320);
     371             : 
     372             :                         /* Reduce the required data amount to what is available, otherwise read()
     373             :                                 will block.*/
     374             :                         if (avail_read < count) {
     375             :                                 count = avail_read;
     376             :                         }
     377             :                 }
     378             : #endif
     379      966817 :                 ret = read(data->fd, buf,  PLAIN_WRAP_BUF_SIZE(count));
     380             : 
     381      966817 :                 if (ret == (size_t)-1 && errno == EINTR) {
     382             :                         /* Read was interrupted, retry once,
     383             :                            If read still fails, giveup with feof==0
     384             :                            so script can retry if desired */
     385           0 :                         ret = read(data->fd, buf,  PLAIN_WRAP_BUF_SIZE(count));
     386             :                 }
     387             :                 
     388      966817 :                 stream->eof = (ret == 0 || (ret == (size_t)-1 && errno != EWOULDBLOCK && errno != EINTR && errno != EBADF));
     389             :                                 
     390             :         } else {
     391             : #if HAVE_FLUSHIO
     392             :                 if (!data->is_pipe && data->last_op == 'w')
     393             :                         zend_fseek(data->file, 0, SEEK_CUR);
     394             :                 data->last_op = 'r';
     395             : #endif
     396             : 
     397           3 :                 ret = fread(buf, 1, count, data->file);
     398             : 
     399           3 :                 stream->eof = feof(data->file);
     400             :         }
     401      966820 :         return ret;
     402             : }
     403             : 
     404      212088 : static int php_stdiop_close(php_stream *stream, int close_handle TSRMLS_DC)
     405             : {
     406             :         int ret;
     407      212088 :         php_stdio_stream_data *data = (php_stdio_stream_data*)stream->abstract;
     408             : 
     409             :         assert(data != NULL);
     410             : 
     411             : #if HAVE_MMAP
     412      212088 :         if (data->last_mapped_addr) {
     413          33 :                 munmap(data->last_mapped_addr, data->last_mapped_len);
     414          33 :                 data->last_mapped_addr = NULL;
     415             :         }
     416             : #elif defined(PHP_WIN32)
     417             :         if (data->last_mapped_addr) {
     418             :                 UnmapViewOfFile(data->last_mapped_addr);
     419             :                 data->last_mapped_addr = NULL;
     420             :         }
     421             :         if (data->file_mapping) {
     422             :                 CloseHandle(data->file_mapping);
     423             :                 data->file_mapping = NULL;
     424             :         }
     425             : #endif
     426             :         
     427      212088 :         if (close_handle) {
     428      212088 :                 if (data->file) {
     429       60211 :                         if (data->is_process_pipe) {
     430         158 :                                 errno = 0;
     431         158 :                                 ret = pclose(data->file);
     432             : 
     433             : #if HAVE_SYS_WAIT_H
     434         158 :                                 if (WIFEXITED(ret)) {
     435         158 :                                         ret = WEXITSTATUS(ret);
     436             :                                 }
     437             : #endif
     438             :                         } else {
     439       60053 :                                 ret = fclose(data->file);
     440       60053 :                                 data->file = NULL;
     441             :                         }
     442      151877 :                 } else if (data->fd != -1) {
     443      151877 :                         ret = close(data->fd);
     444      151877 :                         data->fd = -1;
     445             :                 } else {
     446           0 :                         return 0; /* everything should be closed already -> success */
     447             :                 }
     448      212088 :                 if (data->temp_file_name) {
     449       14088 :                         unlink(data->temp_file_name);
     450             :                         /* temporary streams are never persistent */
     451       14088 :                         efree(data->temp_file_name);
     452       14088 :                         data->temp_file_name = NULL;
     453             :                 }
     454             :         } else {
     455           0 :                 ret = 0;
     456           0 :                 data->file = NULL;
     457           0 :                 data->fd = -1;
     458             :         }
     459             : 
     460      212088 :         pefree(data, stream->is_persistent);
     461             : 
     462      212088 :         return ret;
     463             : }
     464             : 
     465      214176 : static int php_stdiop_flush(php_stream *stream TSRMLS_DC)
     466             : {
     467      214176 :         php_stdio_stream_data *data = (php_stdio_stream_data*)stream->abstract;
     468             : 
     469             :         assert(data != NULL);
     470             : 
     471             :         /*
     472             :          * stdio buffers data in user land. By calling fflush(3), this
     473             :          * data is send to the kernel using write(2). fsync'ing is
     474             :          * something completely different.
     475             :          */
     476      214176 :         if (data->file) {
     477       61357 :                 return fflush(data->file);
     478             :         }
     479      152819 :         return 0;
     480             : }
     481             : 
     482       79207 : static int php_stdiop_seek(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffset TSRMLS_DC)
     483             : {
     484       79207 :         php_stdio_stream_data *data = (php_stdio_stream_data*)stream->abstract;
     485             :         int ret;
     486             : 
     487             :         assert(data != NULL);
     488             : 
     489       79207 :         if (data->is_pipe) {
     490           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "cannot seek on a pipe");
     491           0 :                 return -1;
     492             :         }
     493             : 
     494       79207 :         if (data->fd >= 0) {
     495             :                 zend_off_t result;
     496             :                 
     497       78180 :                 result = zend_lseek(data->fd, offset, whence);
     498       78180 :                 if (result == (zend_off_t)-1)
     499         189 :                         return -1;
     500             : 
     501       77991 :                 *newoffset = result;
     502       77991 :                 return 0;
     503             :                 
     504             :         } else {
     505        1027 :                 ret = zend_fseek(data->file, offset, whence);
     506        1027 :                 *newoffset = zend_ftell(data->file);
     507        1027 :                 return ret;
     508             :         }
     509             : }
     510             : 
     511     3378467 : static int php_stdiop_cast(php_stream *stream, int castas, void **ret TSRMLS_DC)
     512             : {
     513             :         php_socket_t fd;
     514     3378467 :         php_stdio_stream_data *data = (php_stdio_stream_data*) stream->abstract;
     515             : 
     516             :         assert(data != NULL);
     517             :         
     518             :         /* as soon as someone touches the stdio layer, buffering may ensue,
     519             :          * so we need to stop using the fd directly in that case */
     520             : 
     521     3378467 :         switch (castas) {
     522             :                 case PHP_STREAM_AS_STDIO:
     523          87 :                         if (ret) {
     524             : 
     525          87 :                                 if (data->file == NULL) {
     526             :                                         /* we were opened as a plain file descriptor, so we
     527             :                                          * need fdopen now */
     528             :                                         char fixed_mode[5];
     529          86 :                                         php_stream_mode_sanitize_fdopen_fopencookie(stream, fixed_mode);
     530          86 :                                         data->file = fdopen(data->fd, fixed_mode);
     531          86 :                                         if (data->file == NULL) {
     532           0 :                                                 return FAILURE;
     533             :                                         }
     534             :                                 }
     535             :                                 
     536          87 :                                 *(FILE**)ret = data->file;
     537          87 :                                 data->fd = SOCK_ERR;
     538             :                         }
     539          87 :                         return SUCCESS;
     540             : 
     541             :                 case PHP_STREAM_AS_FD_FOR_SELECT:
     542     3377984 :                         PHP_STDIOP_GET_FD(fd, data);
     543     3377984 :                         if (SOCK_ERR == fd) {
     544           0 :                                 return FAILURE;
     545             :                         }
     546     3377984 :                         if (ret) {
     547     3377981 :                                 *(php_socket_t *)ret = fd;
     548             :                         }
     549     3377984 :                         return SUCCESS;
     550             : 
     551             :                 case PHP_STREAM_AS_FD:
     552         395 :                         PHP_STDIOP_GET_FD(fd, data);
     553             : 
     554         395 :                         if (SOCK_ERR == fd) {
     555           0 :                                 return FAILURE;
     556             :                         }
     557         395 :                         if (data->file) {
     558         116 :                                 fflush(data->file);
     559             :                         }
     560         395 :                         if (ret) {
     561         395 :                                 *(php_socket_t *)ret = fd;
     562             :                         }
     563         395 :                         return SUCCESS;
     564             :                 default:
     565           1 :                         return FAILURE;
     566             :         }
     567             : }
     568             : 
     569       42159 : static int php_stdiop_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC)
     570             : {
     571             :         int ret;
     572       42159 :         php_stdio_stream_data *data = (php_stdio_stream_data*) stream->abstract;
     573             : 
     574             :         assert(data != NULL);
     575             : 
     576       42159 :         ret = do_fstat(data, 1);
     577       42159 :         memcpy(&ssb->sb, &data->sb, sizeof(ssb->sb));
     578       42159 :         return ret;
     579             : }
     580             : 
     581      111710 : static int php_stdiop_set_option(php_stream *stream, int option, int value, void *ptrparam TSRMLS_DC)
     582             : {
     583      111710 :         php_stdio_stream_data *data = (php_stdio_stream_data*) stream->abstract;
     584             :         size_t size;
     585             :         int fd;
     586             : #ifdef O_NONBLOCK
     587             :         /* FIXME: make this work for win32 */
     588             :         int flags;
     589             :         int oldval;
     590             : #endif
     591             :         
     592      111710 :         PHP_STDIOP_GET_FD(fd, data);
     593             :         
     594      111710 :         switch(option) {
     595             :                 case PHP_STREAM_OPTION_BLOCKING:
     596          10 :                         if (fd == -1)
     597           0 :                                 return -1;
     598             : #ifdef O_NONBLOCK
     599          10 :                         flags = fcntl(fd, F_GETFL, 0);
     600          10 :                         oldval = (flags & O_NONBLOCK) ? 0 : 1;
     601          10 :                         if (value)
     602           0 :                                 flags &= ~O_NONBLOCK;
     603             :                         else
     604          10 :                                 flags |= O_NONBLOCK;
     605             :                         
     606          10 :                         if (-1 == fcntl(fd, F_SETFL, flags))
     607           0 :                                 return -1;
     608          10 :                         return oldval;
     609             : #else
     610             :                         return -1; /* not yet implemented */
     611             : #endif
     612             :                         
     613             :                 case PHP_STREAM_OPTION_WRITE_BUFFER:
     614             : 
     615           1 :                         if (data->file == NULL) {
     616           1 :                                 return -1;
     617             :                         }
     618             :                         
     619           0 :                         if (ptrparam)
     620           0 :                                 size = *(size_t *)ptrparam;
     621             :                         else
     622           0 :                                 size = BUFSIZ;
     623             : 
     624           0 :                         switch(value) {
     625             :                                 case PHP_STREAM_BUFFER_NONE:
     626           0 :                                         return setvbuf(data->file, NULL, _IONBF, 0);
     627             :                                         
     628             :                                 case PHP_STREAM_BUFFER_LINE:
     629           0 :                                         return setvbuf(data->file, NULL, _IOLBF, size);
     630             :                                         
     631             :                                 case PHP_STREAM_BUFFER_FULL:
     632           0 :                                         return setvbuf(data->file, NULL, _IOFBF, size);
     633             : 
     634             :                                 default:
     635           0 :                                         return -1;
     636             :                         }
     637             :                         break;
     638             :                 
     639             :                 case PHP_STREAM_OPTION_LOCKING:
     640         329 :                         if (fd == -1) {
     641           0 :                                 return -1;
     642             :                         }
     643             : 
     644         329 :                         if ((zend_uintptr_t) ptrparam == PHP_STREAM_LOCK_SUPPORTED) {
     645          84 :                                 return 0;
     646             :                         }
     647             : 
     648         245 :                         if (!flock(fd, value)) {
     649         245 :                                 data->lock_flag = value;
     650         245 :                                 return 0;
     651             :                         } else {
     652           0 :                                 return -1;
     653             :                         }
     654             :                         break;
     655             : 
     656             :                 case PHP_STREAM_OPTION_MMAP_API:
     657             : #if HAVE_MMAP
     658             :                         {
     659       77960 :                                 php_stream_mmap_range *range = (php_stream_mmap_range*)ptrparam;
     660             :                                 int prot, flags;
     661             :                                 
     662       77960 :                                 switch (value) {
     663             :                                         case PHP_STREAM_MMAP_SUPPORTED:
     664       27554 :                                                 return fd == -1 ? PHP_STREAM_OPTION_RETURN_ERR : PHP_STREAM_OPTION_RETURN_OK;
     665             : 
     666             :                                         case PHP_STREAM_MMAP_MAP_RANGE:
     667       27554 :                                                 do_fstat(data, 1);
     668       27554 :                                                 if (range->length == 0 && range->offset > 0 && range->offset < data->sb.st_size) {
     669          17 :                                                         range->length = data->sb.st_size - range->offset;
     670             :                                                 }
     671       27554 :                                                 if (range->length == 0 || range->length > data->sb.st_size) {
     672        8815 :                                                         range->length = data->sb.st_size;
     673             :                                                 }
     674       27554 :                                                 if (range->offset >= data->sb.st_size) {
     675          89 :                                                         range->offset = data->sb.st_size;
     676          89 :                                                         range->length = 0;
     677             :                                                 }
     678       27554 :                                                 switch (range->mode) {
     679             :                                                         case PHP_STREAM_MAP_MODE_READONLY:
     680           0 :                                                                 prot = PROT_READ;
     681           0 :                                                                 flags = MAP_PRIVATE;
     682           0 :                                                                 break;
     683             :                                                         case PHP_STREAM_MAP_MODE_READWRITE:
     684           0 :                                                                 prot = PROT_READ | PROT_WRITE;
     685           0 :                                                                 flags = MAP_PRIVATE;
     686           0 :                                                                 break;
     687             :                                                         case PHP_STREAM_MAP_MODE_SHARED_READONLY:
     688       27554 :                                                                 prot = PROT_READ;
     689       27554 :                                                                 flags = MAP_SHARED;
     690       27554 :                                                                 break;
     691             :                                                         case PHP_STREAM_MAP_MODE_SHARED_READWRITE:
     692           0 :                                                                 prot = PROT_READ | PROT_WRITE;
     693           0 :                                                                 flags = MAP_SHARED;
     694           0 :                                                                 break;
     695             :                                                         default:
     696           0 :                                                                 return PHP_STREAM_OPTION_RETURN_ERR;
     697             :                                                 }
     698       27554 :                                                 range->mapped = (char*)mmap(NULL, range->length, prot, flags, fd, range->offset);
     699       27554 :                                                 if (range->mapped == (char*)MAP_FAILED) {
     700        4669 :                                                         range->mapped = NULL;
     701        4669 :                                                         return PHP_STREAM_OPTION_RETURN_ERR;
     702             :                                                 }
     703             :                                                 /* remember the mapping */
     704       22885 :                                                 data->last_mapped_addr = range->mapped;
     705       22885 :                                                 data->last_mapped_len = range->length;
     706       22885 :                                                 return PHP_STREAM_OPTION_RETURN_OK;
     707             : 
     708             :                                         case PHP_STREAM_MMAP_UNMAP:
     709       22852 :                                                 if (data->last_mapped_addr) {
     710       22852 :                                                         munmap(data->last_mapped_addr, data->last_mapped_len);
     711       22852 :                                                         data->last_mapped_addr = NULL;
     712             : 
     713       22852 :                                                         return PHP_STREAM_OPTION_RETURN_OK;
     714             :                                                 }
     715           0 :                                                 return PHP_STREAM_OPTION_RETURN_ERR;
     716             :                                 }
     717             :                         }
     718             : #elif defined(PHP_WIN32)
     719             :                         {
     720             :                                 php_stream_mmap_range *range = (php_stream_mmap_range*)ptrparam;
     721             :                                 HANDLE hfile = (HANDLE)_get_osfhandle(fd);
     722             :                                 DWORD prot, acc, loffs = 0, delta = 0;
     723             : 
     724             :                                 switch (value) {
     725             :                                         case PHP_STREAM_MMAP_SUPPORTED:
     726             :                                                 return hfile == INVALID_HANDLE_VALUE ? PHP_STREAM_OPTION_RETURN_ERR : PHP_STREAM_OPTION_RETURN_OK;
     727             : 
     728             :                                         case PHP_STREAM_MMAP_MAP_RANGE:
     729             :                                                 switch (range->mode) {
     730             :                                                         case PHP_STREAM_MAP_MODE_READONLY:
     731             :                                                                 prot = PAGE_READONLY;
     732             :                                                                 acc = FILE_MAP_READ;
     733             :                                                                 break;
     734             :                                                         case PHP_STREAM_MAP_MODE_READWRITE:
     735             :                                                                 prot = PAGE_READWRITE;
     736             :                                                                 acc = FILE_MAP_READ | FILE_MAP_WRITE;
     737             :                                                                 break;
     738             :                                                         case PHP_STREAM_MAP_MODE_SHARED_READONLY:
     739             :                                                                 prot = PAGE_READONLY;
     740             :                                                                 acc = FILE_MAP_READ;
     741             :                                                                 /* TODO: we should assign a name for the mapping */
     742             :                                                                 break;
     743             :                                                         case PHP_STREAM_MAP_MODE_SHARED_READWRITE:
     744             :                                                                 prot = PAGE_READWRITE;
     745             :                                                                 acc = FILE_MAP_READ | FILE_MAP_WRITE;
     746             :                                                                 /* TODO: we should assign a name for the mapping */
     747             :                                                                 break;
     748             :                                                         default:
     749             :                                                                 return PHP_STREAM_OPTION_RETURN_ERR;
     750             :                                                 }
     751             : 
     752             :                                                 /* create a mapping capable of viewing the whole file (this costs no real resources) */
     753             :                                                 data->file_mapping = CreateFileMapping(hfile, NULL, prot, 0, 0, NULL);
     754             : 
     755             :                                                 if (data->file_mapping == NULL) {
     756             :                                                         return PHP_STREAM_OPTION_RETURN_ERR;
     757             :                                                 }
     758             : 
     759             :                                                 size = GetFileSize(hfile, NULL);
     760             :                                                 if (range->length == 0 && range->offset > 0 && range->offset < size) {
     761             :                                                         range->length = size - range->offset;
     762             :                                                 }
     763             :                                                 if (range->length == 0 || range->length > size) {
     764             :                                                         range->length = size;
     765             :                                                 }
     766             :                                                 if (range->offset >= size) {
     767             :                                                         range->offset = size;
     768             :                                                         range->length = 0;
     769             :                                                 }
     770             : 
     771             :                                                 /* figure out how big a chunk to map to be able to view the part that we need */
     772             :                                                 if (range->offset != 0) {
     773             :                                                         SYSTEM_INFO info;
     774             :                                                         DWORD gran;
     775             : 
     776             :                                                         GetSystemInfo(&info);
     777             :                                                         gran = info.dwAllocationGranularity;
     778             :                                                         loffs = (range->offset / gran) * gran;
     779             :                                                         delta = range->offset - loffs;
     780             :                                                 }
     781             : 
     782             :                                                 data->last_mapped_addr = MapViewOfFile(data->file_mapping, acc, 0, loffs, range->length + delta);
     783             : 
     784             :                                                 if (data->last_mapped_addr) {
     785             :                                                         /* give them back the address of the start offset they requested */
     786             :                                                         range->mapped = data->last_mapped_addr + delta;
     787             :                                                         return PHP_STREAM_OPTION_RETURN_OK;
     788             :                                                 }
     789             : 
     790             :                                                 CloseHandle(data->file_mapping);
     791             :                                                 data->file_mapping = NULL;
     792             : 
     793             :                                                 return PHP_STREAM_OPTION_RETURN_ERR;
     794             : 
     795             :                                         case PHP_STREAM_MMAP_UNMAP:
     796             :                                                 if (data->last_mapped_addr) {
     797             :                                                         UnmapViewOfFile(data->last_mapped_addr);
     798             :                                                         data->last_mapped_addr = NULL;
     799             :                                                         CloseHandle(data->file_mapping);
     800             :                                                         data->file_mapping = NULL;
     801             :                                                         return PHP_STREAM_OPTION_RETURN_OK;
     802             :                                                 }
     803             :                                                 return PHP_STREAM_OPTION_RETURN_ERR;
     804             : 
     805             :                                         default:
     806             :                                                 return PHP_STREAM_OPTION_RETURN_ERR;
     807             :                                 }
     808             :                         }
     809             : 
     810             : #endif
     811           0 :                         return PHP_STREAM_OPTION_RETURN_NOTIMPL;
     812             : 
     813             :                 case PHP_STREAM_OPTION_TRUNCATE_API:
     814         782 :                         switch (value) {
     815             :                                 case PHP_STREAM_TRUNCATE_SUPPORTED:
     816         379 :                                         return fd == -1 ? PHP_STREAM_OPTION_RETURN_ERR : PHP_STREAM_OPTION_RETURN_OK;
     817             : 
     818             :                                 case PHP_STREAM_TRUNCATE_SET_SIZE: {
     819         403 :                                         ptrdiff_t new_size = *(ptrdiff_t*)ptrparam;
     820         403 :                                         if (new_size < 0) {
     821          50 :                                                 return PHP_STREAM_OPTION_RETURN_ERR;
     822             :                                         }
     823         353 :                                         return ftruncate(fd, new_size) == 0 ? PHP_STREAM_OPTION_RETURN_OK : PHP_STREAM_OPTION_RETURN_ERR;
     824             :                                 }
     825             :                         }
     826             :                         
     827             :                 default:
     828       32628 :                         return PHP_STREAM_OPTION_RETURN_NOTIMPL;
     829             :         }
     830             : }
     831             : 
     832             : PHPAPI php_stream_ops   php_stream_stdio_ops = {
     833             :         php_stdiop_write, php_stdiop_read,
     834             :         php_stdiop_close, php_stdiop_flush,
     835             :         "STDIO",
     836             :         php_stdiop_seek,
     837             :         php_stdiop_cast,
     838             :         php_stdiop_stat,
     839             :         php_stdiop_set_option
     840             : };
     841             : /* }}} */
     842             : 
     843             : /* {{{ plain files opendir/readdir implementation */
     844       36637 : static size_t php_plain_files_dirstream_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
     845             : {
     846       36637 :         DIR *dir = (DIR*)stream->abstract;
     847             :         /* avoid libc5 readdir problems */
     848             :         char entry[sizeof(struct dirent)+MAXPATHLEN];
     849       36637 :         struct dirent *result = (struct dirent *)&entry;
     850       36637 :         php_stream_dirent *ent = (php_stream_dirent*)buf;
     851             : 
     852             :         /* avoid problems if someone mis-uses the stream */
     853       36637 :         if (count != sizeof(php_stream_dirent))
     854           0 :                 return 0;
     855             : 
     856       36637 :         if (php_readdir_r(dir, (struct dirent *)entry, &result) == 0 && result) {
     857       35937 :                 PHP_STRLCPY(ent->d_name, result->d_name, sizeof(ent->d_name), strlen(result->d_name));
     858       35937 :                 return sizeof(php_stream_dirent);
     859             :         }
     860         700 :         return 0;
     861             : }
     862             : 
     863         835 : static int php_plain_files_dirstream_close(php_stream *stream, int close_handle TSRMLS_DC)
     864             : {
     865         835 :         return closedir((DIR *)stream->abstract);
     866             : }
     867             : 
     868          53 : static int php_plain_files_dirstream_rewind(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffs TSRMLS_DC)
     869             : {
     870          53 :         rewinddir((DIR *)stream->abstract);
     871          53 :         return 0;
     872             : }
     873             : 
     874             : static php_stream_ops   php_plain_files_dirstream_ops = {
     875             :         NULL, php_plain_files_dirstream_read,
     876             :         php_plain_files_dirstream_close, NULL,
     877             :         "dir",
     878             :         php_plain_files_dirstream_rewind,
     879             :         NULL, /* cast */
     880             :         NULL, /* stat */
     881             :         NULL  /* set_option */
     882             : };
     883             : 
     884         920 : static php_stream *php_plain_files_dir_opener(php_stream_wrapper *wrapper, const char *path, const char *mode,
     885             :                 int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC)
     886             : {
     887         920 :         DIR *dir = NULL;
     888         920 :         php_stream *stream = NULL;
     889             : 
     890             : #ifdef HAVE_GLOB
     891         920 :         if (options & STREAM_USE_GLOB_DIR_OPEN) {
     892           0 :                 return php_glob_stream_wrapper.wops->dir_opener(&php_glob_stream_wrapper, path, mode, options, opened_path, context STREAMS_REL_CC TSRMLS_CC);
     893             :         }
     894             : #endif
     895             : 
     896         920 :         if (((options & STREAM_DISABLE_OPEN_BASEDIR) == 0) && php_check_open_basedir(path TSRMLS_CC)) {
     897          24 :                 return NULL;
     898             :         }
     899             :         
     900         896 :         dir = VCWD_OPENDIR(path);
     901             : 
     902             : #ifdef PHP_WIN32
     903             :         if (!dir) {
     904             :                 php_win32_docref2_from_error(GetLastError(), path, path TSRMLS_CC);
     905             :         }
     906             : 
     907             :         if (dir && dir->finished) {
     908             :                 closedir(dir);
     909             :                 dir = NULL;
     910             :         }
     911             : #endif
     912         896 :         if (dir) {
     913         835 :                 stream = php_stream_alloc(&php_plain_files_dirstream_ops, dir, 0, mode);
     914         835 :                 if (stream == NULL)
     915           0 :                         closedir(dir);
     916             :         }
     917             :                 
     918         896 :         return stream;
     919             : }
     920             : /* }}} */
     921             : 
     922             : /* {{{ php_stream_fopen */
     923       77618 : PHPAPI php_stream *_php_stream_fopen(const char *filename, const char *mode, char **opened_path, int options STREAMS_DC TSRMLS_DC)
     924             : {
     925       77618 :         char *realpath = NULL;
     926             :         int open_flags;
     927             :         int fd;
     928             :         php_stream *ret;
     929       77618 :         int persistent = options & STREAM_OPEN_PERSISTENT;
     930       77618 :         char *persistent_id = NULL;
     931             : 
     932       77618 :         if (FAILURE == php_stream_parse_fopen_modes(mode, &open_flags)) {
     933          23 :                 if (options & REPORT_ERRORS) {
     934           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "`%s' is not a valid mode for fopen", mode);
     935             :                 }
     936          23 :                 return NULL;
     937             :         }
     938             : 
     939       77595 :         if (options & STREAM_ASSUME_REALPATH) {
     940        8491 :                 realpath = estrdup(filename);
     941             :         } else {
     942       69104 :                 if ((realpath = expand_filepath(filename, NULL TSRMLS_CC)) == NULL) {
     943           0 :                         return NULL;
     944             :                 }
     945             :         }
     946             : 
     947       77595 :         if (persistent) {
     948          23 :                 spprintf(&persistent_id, 0, "streams_stdio_%d_%s", open_flags, realpath);
     949          23 :                 switch (php_stream_from_persistent_id(persistent_id, &ret TSRMLS_CC)) {
     950             :                         case PHP_STREAM_PERSISTENT_SUCCESS:
     951           0 :                                 if (opened_path) {
     952           0 :                                         *opened_path = realpath;
     953           0 :                                         realpath = NULL;
     954             :                                 }
     955             :                                 /* fall through */
     956             : 
     957             :                         case PHP_STREAM_PERSISTENT_FAILURE:
     958           0 :                                 if (realpath) {
     959           0 :                                         efree(realpath);
     960             :                                 }
     961           0 :                                 efree(persistent_id);;
     962           0 :                                 return ret;
     963             :                 }
     964             :         }
     965             :         
     966       77595 :         fd = open(realpath, open_flags, 0666);
     967             : 
     968       77595 :         if (fd != -1)   {
     969             : 
     970       76967 :                 if (options & STREAM_OPEN_FOR_INCLUDE) {
     971        8338 :                         ret = php_stream_fopen_from_fd_int_rel(fd, mode, persistent_id);
     972             :                 } else {
     973       68629 :                         ret = php_stream_fopen_from_fd_rel(fd, mode, persistent_id);
     974             :                 }
     975             : 
     976       76967 :                 if (ret)        {
     977       76967 :                         if (opened_path) {
     978       12079 :                                 *opened_path = realpath;
     979       12079 :                                 realpath = NULL;
     980             :                         }
     981       76967 :                         if (realpath) {
     982       64888 :                                 efree(realpath);
     983             :                         }
     984       76967 :                         if (persistent_id) {
     985          22 :                                 efree(persistent_id);
     986             :                         }
     987             : 
     988             :                         /* WIN32 always set ISREG flag */
     989             : #ifndef PHP_WIN32
     990             :                         /* sanity checks for include/require.
     991             :                          * We check these after opening the stream, so that we save
     992             :                          * on fstat() syscalls */
     993       76967 :                         if (options & STREAM_OPEN_FOR_INCLUDE) {
     994        8338 :                                 php_stdio_stream_data *self = (php_stdio_stream_data*)ret->abstract;
     995             :                                 int r;
     996             : 
     997        8338 :                                 r = do_fstat(self, 0);
     998        8338 :                                 if ((r == 0 && !S_ISREG(self->sb.st_mode))) {
     999           1 :                                         if (opened_path) {
    1000           1 :                                                 efree(*opened_path);
    1001           1 :                                                 *opened_path = NULL;
    1002             :                                         }
    1003           1 :                                         php_stream_close(ret);
    1004           1 :                                         return NULL;
    1005             :                                 }
    1006             :                         }
    1007             : #endif
    1008             : 
    1009       76966 :                         return ret;
    1010             :                 }
    1011           0 :                 close(fd);
    1012             :         }
    1013         628 :         efree(realpath);
    1014         628 :         if (persistent_id) {
    1015           1 :                 efree(persistent_id);
    1016             :         }
    1017         628 :         return NULL;
    1018             : }
    1019             : /* }}} */
    1020             : 
    1021             : 
    1022       77659 : static php_stream *php_plain_files_stream_opener(php_stream_wrapper *wrapper, const char *path, const char *mode,
    1023             :                 int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC)
    1024             : {
    1025       77659 :         if (((options & STREAM_DISABLE_OPEN_BASEDIR) == 0) && php_check_open_basedir(path TSRMLS_CC)) {
    1026          41 :                 return NULL;
    1027             :         }
    1028             : 
    1029       77618 :         return php_stream_fopen_rel(path, mode, opened_path, options);
    1030             : }
    1031             : 
    1032       54093 : static int php_plain_files_url_stater(php_stream_wrapper *wrapper, const char *url, int flags, php_stream_statbuf *ssb, php_stream_context *context TSRMLS_DC)
    1033             : {
    1034             :         char *p;
    1035             : 
    1036       54093 :         if ((p = strstr(url, "://")) != NULL) {
    1037           1 :                 if (p < strchr(url, '/')) {
    1038           1 :                         url = p + 3;
    1039             :                 }
    1040             :         }
    1041             : 
    1042       54093 :         if (php_check_open_basedir_ex(url, (flags & PHP_STREAM_URL_STAT_QUIET) ? 0 : 1 TSRMLS_CC)) {
    1043           9 :                 return -1;
    1044             :         }
    1045             : 
    1046             : #ifdef PHP_WIN32
    1047             :         if (EG(windows_version_info).dwMajorVersion >= 5) {
    1048             :                 if (flags & PHP_STREAM_URL_STAT_LINK) {
    1049             :                         return VCWD_LSTAT(url, &ssb->sb);
    1050             :                 }
    1051             :         }
    1052             : #else
    1053             : # ifdef HAVE_SYMLINK
    1054       54084 :         if (flags & PHP_STREAM_URL_STAT_LINK) {
    1055        2514 :                 return VCWD_LSTAT(url, &ssb->sb);
    1056             :         } else
    1057             : # endif
    1058             : #endif
    1059       51570 :                 return VCWD_STAT(url, &ssb->sb);
    1060             : }
    1061             : 
    1062      210966 : static int php_plain_files_unlink(php_stream_wrapper *wrapper, const char *url, int options, php_stream_context *context TSRMLS_DC)
    1063             : {
    1064             :         char *p;
    1065             :         int ret;
    1066             : 
    1067      210966 :         if ((p = strstr(url, "://")) != NULL) {
    1068           0 :                 if (p < strchr(url, '/')) {
    1069           0 :                         url = p + 3;
    1070             :                 }
    1071             :         }
    1072             : 
    1073      210966 :         if (php_check_open_basedir(url TSRMLS_CC)) {
    1074           6 :                 return 0;
    1075             :         }
    1076             : 
    1077      210960 :         ret = VCWD_UNLINK(url);
    1078      210960 :         if (ret == -1) {
    1079      184625 :                 if (options & REPORT_ERRORS) {
    1080      184625 :                         php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "%s", strerror(errno));
    1081             :                 }
    1082      184625 :                 return 0;
    1083             :         }
    1084             : 
    1085             :         /* Clear stat cache (and realpath cache) */
    1086       26335 :         php_clear_stat_cache(1, NULL, 0 TSRMLS_CC);
    1087             : 
    1088       26335 :         return 1;
    1089             : }
    1090             : 
    1091          79 : static int php_plain_files_rename(php_stream_wrapper *wrapper, const char *url_from, const char *url_to, int options, php_stream_context *context TSRMLS_DC)
    1092             : {
    1093             :         char *p;
    1094             :         int ret;
    1095             : 
    1096          79 :         if (!url_from || !url_to) {
    1097           0 :                 return 0;
    1098             :         }
    1099             : 
    1100             : #ifdef PHP_WIN32
    1101             :         if (!php_win32_check_trailing_space(url_from, strlen(url_from))) {
    1102             :                 php_win32_docref2_from_error(ERROR_INVALID_NAME, url_from, url_to TSRMLS_CC);
    1103             :                 return 0;
    1104             :         }
    1105             :         if (!php_win32_check_trailing_space(url_to, strlen(url_to))) {
    1106             :                 php_win32_docref2_from_error(ERROR_INVALID_NAME, url_from, url_to TSRMLS_CC);
    1107             :                 return 0;
    1108             :         }
    1109             : #endif
    1110             : 
    1111          79 :         if ((p = strstr(url_from, "://")) != NULL) {
    1112           0 :                 if (p < strchr(url_from, '/')) {
    1113           0 :                         url_from = p + 3;
    1114             :                 }
    1115             :         }
    1116             : 
    1117          79 :         if ((p = strstr(url_to, "://")) != NULL) {
    1118           0 :                 if (p < strchr(url_to, '/')) {
    1119           0 :                         url_to = p + 3;
    1120             :                 }
    1121             :         }
    1122             : 
    1123          79 :         if (php_check_open_basedir(url_from TSRMLS_CC) || php_check_open_basedir(url_to TSRMLS_CC)) {
    1124           5 :                 return 0;
    1125             :         }
    1126             : 
    1127          74 :         ret = VCWD_RENAME(url_from, url_to);
    1128             : 
    1129          74 :         if (ret == -1) {
    1130             : #ifndef PHP_WIN32
    1131             : # ifdef EXDEV
    1132          24 :                 if (errno == EXDEV) {
    1133             :                         zend_stat_t sb;
    1134           0 :                         if (php_copy_file(url_from, url_to TSRMLS_CC) == SUCCESS) {
    1135           0 :                                 if (VCWD_STAT(url_from, &sb) == 0) {
    1136             : #  if !defined(TSRM_WIN32) && !defined(NETWARE)
    1137           0 :                                         if (VCWD_CHMOD(url_to, sb.st_mode)) {
    1138           0 :                                                 if (errno == EPERM) {
    1139           0 :                                                         php_error_docref2(NULL TSRMLS_CC, url_from, url_to, E_WARNING, "%s", strerror(errno));
    1140           0 :                                                         VCWD_UNLINK(url_from);
    1141           0 :                                                         return 1;
    1142             :                                                 }
    1143           0 :                                                 php_error_docref2(NULL TSRMLS_CC, url_from, url_to, E_WARNING, "%s", strerror(errno));
    1144           0 :                                                 return 0;
    1145             :                                         }
    1146           0 :                                         if (VCWD_CHOWN(url_to, sb.st_uid, sb.st_gid)) {
    1147           0 :                                                 if (errno == EPERM) {
    1148           0 :                                                         php_error_docref2(NULL TSRMLS_CC, url_from, url_to, E_WARNING, "%s", strerror(errno));
    1149           0 :                                                         VCWD_UNLINK(url_from);
    1150           0 :                                                         return 1;
    1151             :                                                 }
    1152           0 :                                                 php_error_docref2(NULL TSRMLS_CC, url_from, url_to, E_WARNING, "%s", strerror(errno));
    1153           0 :                                                 return 0;
    1154             :                                         }
    1155             : #  endif
    1156           0 :                                         VCWD_UNLINK(url_from);
    1157           0 :                                         return 1;
    1158             :                                 }
    1159             :                         }
    1160           0 :                         php_error_docref2(NULL TSRMLS_CC, url_from, url_to, E_WARNING, "%s", strerror(errno));
    1161           0 :                         return 0;
    1162             :                 }
    1163             : # endif
    1164             : #endif
    1165             : 
    1166             : #ifdef PHP_WIN32
    1167             :                 php_win32_docref2_from_error(GetLastError(), url_from, url_to TSRMLS_CC);
    1168             : #else
    1169          24 :                 php_error_docref2(NULL TSRMLS_CC, url_from, url_to, E_WARNING, "%s", strerror(errno));
    1170             : #endif
    1171          24 :                 return 0;
    1172             :         }
    1173             : 
    1174             :         /* Clear stat cache (and realpath cache) */
    1175          50 :         php_clear_stat_cache(1, NULL, 0 TSRMLS_CC);
    1176             : 
    1177          50 :         return 1;
    1178             : }
    1179             : 
    1180        1675 : static int php_plain_files_mkdir(php_stream_wrapper *wrapper, const char *dir, int mode, int options, php_stream_context *context TSRMLS_DC)
    1181             : {
    1182        1675 :         int ret, recursive = options & PHP_STREAM_MKDIR_RECURSIVE;
    1183             :         char *p;
    1184             : 
    1185        1675 :         if ((p = strstr(dir, "://")) != NULL) {
    1186           0 :                 if (p < strchr(dir, '/')) {
    1187           0 :                         dir = p + 3;
    1188             :                 }
    1189             :         }
    1190             : 
    1191        1675 :         if (!recursive) {
    1192        1112 :                 ret = php_mkdir(dir, mode TSRMLS_CC);
    1193             :         } else {
    1194             :                 /* we look for directory separator from the end of string, thus hopefuly reducing our work load */
    1195             :                 char *e;
    1196             :                 zend_stat_t sb;
    1197         563 :                 int dir_len = strlen(dir);
    1198         563 :                 int offset = 0;
    1199             :                 char buf[MAXPATHLEN];
    1200             : 
    1201         563 :                 if (!expand_filepath_with_mode(dir, buf, NULL, 0, CWD_EXPAND  TSRMLS_CC)) {
    1202           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid path");
    1203           0 :                         return 0;
    1204             :                 }
    1205             : 
    1206         563 :                 e = buf +  strlen(buf);
    1207             : 
    1208         563 :                 if ((p = memchr(buf, DEFAULT_SLASH, dir_len))) {
    1209         563 :                         offset = p - buf + 1;
    1210             :                 }
    1211             : 
    1212         563 :                 if (p && dir_len == 1) {
    1213             :                         /* buf == "DEFAULT_SLASH" */  
    1214             :                 }
    1215             :                 else {
    1216             :                         /* find a top level directory we need to create */
    1217        1683 :                         while ( (p = strrchr(buf + offset, DEFAULT_SLASH)) || (offset != 1 && (p = strrchr(buf, DEFAULT_SLASH))) ) {
    1218        1120 :                                 int n = 0;
    1219             : 
    1220        1120 :                                 *p = '\0';
    1221        2240 :                                 while (p > buf && *(p-1) == DEFAULT_SLASH) {
    1222           0 :                                         ++n;
    1223           0 :                                         --p;
    1224           0 :                                         *p = '\0';
    1225             :                                 }
    1226        1120 :                                 if (VCWD_STAT(buf, &sb) == 0) {
    1227             :                                         while (1) {
    1228         563 :                                                 *p = DEFAULT_SLASH;
    1229         563 :                                                 if (!n) break;
    1230           0 :                                                 --n;
    1231           0 :                                                 ++p;
    1232           0 :                                         }
    1233         563 :                                         break;
    1234             :                                 }
    1235             :                         }
    1236             :                 }
    1237             : 
    1238         563 :                 if (p == buf) {
    1239           0 :                         ret = php_mkdir(dir, mode TSRMLS_CC);
    1240         563 :                 } else if (!(ret = php_mkdir(buf, mode TSRMLS_CC))) {
    1241         562 :                         if (!p) {
    1242           0 :                                 p = buf;
    1243             :                         }
    1244             :                         /* create any needed directories if the creation of the 1st directory worked */
    1245       10635 :                         while (++p != e) {
    1246        9511 :                                 if (*p == '\0') {
    1247         557 :                                         *p = DEFAULT_SLASH;
    1248         592 :                                         if ((*(p+1) != '\0') &&
    1249          35 :                                                 (ret = VCWD_MKDIR(buf, (mode_t)mode)) < 0) {
    1250           0 :                                                 if (options & REPORT_ERRORS) {
    1251           0 :                                                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
    1252             :                                                 }
    1253           0 :                                                 break;
    1254             :                                         }
    1255             :                                 }
    1256             :                         }
    1257             :                 }
    1258             :         }
    1259        1675 :         if (ret < 0) {
    1260             :                 /* Failure */
    1261          50 :                 return 0;
    1262             :         } else {
    1263             :                 /* Success */
    1264        1625 :                 return 1;
    1265             :         }
    1266             : }
    1267             : 
    1268        1694 : static int php_plain_files_rmdir(php_stream_wrapper *wrapper, const char *url, int options, php_stream_context *context TSRMLS_DC)
    1269             : {
    1270             : #if PHP_WIN32
    1271             :         int url_len = strlen(url);
    1272             : #endif
    1273        1694 :         if (php_check_open_basedir(url TSRMLS_CC)) {
    1274           5 :                 return 0;
    1275             :         }
    1276             : 
    1277             : #if PHP_WIN32
    1278             :         if (!php_win32_check_trailing_space(url, url_len)) {
    1279             :                 php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "%s", strerror(ENOENT));
    1280             :                 return 0;
    1281             :         }
    1282             : #endif
    1283             : 
    1284        1689 :         if (VCWD_RMDIR(url) < 0) {
    1285          29 :                 php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "%s", strerror(errno));
    1286          29 :                 return 0;
    1287             :         }
    1288             : 
    1289             :         /* Clear stat cache (and realpath cache) */
    1290        1660 :         php_clear_stat_cache(1, NULL, 0 TSRMLS_CC);
    1291             : 
    1292        1660 :         return 1;
    1293             : }
    1294             : 
    1295           0 : static int php_plain_files_metadata(php_stream_wrapper *wrapper, const char *url, int option, void *value, php_stream_context *context TSRMLS_DC)
    1296             : {
    1297             :         struct utimbuf *newtime;
    1298             :         char *p;
    1299             : #if !defined(WINDOWS) && !defined(NETWARE)
    1300             :         uid_t uid;
    1301             :         gid_t gid;
    1302             : #endif
    1303             :         mode_t mode;
    1304           0 :         int ret = 0;
    1305             : #if PHP_WIN32
    1306             :         int url_len = strlen(url);
    1307             : #endif
    1308             : 
    1309             : #if PHP_WIN32
    1310             :         if (!php_win32_check_trailing_space(url, url_len)) {
    1311             :                 php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "%s", strerror(ENOENT));
    1312             :                 return 0;
    1313             :         }
    1314             : #endif
    1315             : 
    1316           0 :         if ((p = strstr(url, "://")) != NULL) {
    1317           0 :                 if (p < strchr(url, '/')) {
    1318           0 :                         url = p + 3;
    1319             :                 }
    1320             :         }
    1321             : 
    1322           0 :         if (php_check_open_basedir(url TSRMLS_CC)) {
    1323           0 :                 return 0;
    1324             :         }
    1325             : 
    1326           0 :         switch(option) {
    1327             :                 case PHP_STREAM_META_TOUCH:
    1328           0 :                         newtime = (struct utimbuf *)value;
    1329           0 :                         if (VCWD_ACCESS(url, F_OK) != 0) {
    1330           0 :                                 FILE *file = VCWD_FOPEN(url, "w");
    1331           0 :                                 if (file == NULL) {
    1332           0 :                                         php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "Unable to create file %s because %s", url, strerror(errno));
    1333           0 :                                         return 0;
    1334             :                                 }
    1335           0 :                                 fclose(file);
    1336             :                         }
    1337             : 
    1338           0 :                         ret = VCWD_UTIME(url, newtime);
    1339           0 :                         break;
    1340             : #if !defined(WINDOWS) && !defined(NETWARE)
    1341             :                 case PHP_STREAM_META_OWNER_NAME:
    1342             :                 case PHP_STREAM_META_OWNER:
    1343           0 :                         if(option == PHP_STREAM_META_OWNER_NAME) {
    1344           0 :                                 if(php_get_uid_by_name((char *)value, &uid TSRMLS_CC) != SUCCESS) {
    1345           0 :                                         php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "Unable to find uid for %s", (char *)value);
    1346           0 :                                         return 0;
    1347             :                                 }
    1348             :                         } else {
    1349           0 :                                 uid = (uid_t)*(long *)value;
    1350             :                         }
    1351           0 :                         ret = VCWD_CHOWN(url, uid, -1);
    1352           0 :                         break;
    1353             :                 case PHP_STREAM_META_GROUP:
    1354             :                 case PHP_STREAM_META_GROUP_NAME:
    1355           0 :                         if(option == PHP_STREAM_META_OWNER_NAME) {
    1356           0 :                                 if(php_get_gid_by_name((char *)value, &gid TSRMLS_CC) != SUCCESS) {
    1357           0 :                                         php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "Unable to find gid for %s", (char *)value);
    1358           0 :                                         return 0;
    1359             :                                 }
    1360             :                         } else {
    1361           0 :                                 gid = (gid_t)*(long *)value;
    1362             :                         }
    1363           0 :                         ret = VCWD_CHOWN(url, -1, gid);
    1364           0 :                         break;
    1365             : #endif
    1366             :                 case PHP_STREAM_META_ACCESS:
    1367           0 :                         mode = (mode_t)*(zend_long *)value;
    1368           0 :                         ret = VCWD_CHMOD(url, mode);
    1369           0 :                         break;
    1370             :                 default:
    1371           0 :                         php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "Unknown option %d for stream_metadata", option);
    1372           0 :                         return 0;
    1373             :         }
    1374           0 :         if (ret == -1) {
    1375           0 :                 php_error_docref1(NULL TSRMLS_CC, url, E_WARNING, "Operation failed: %s", strerror(errno));
    1376           0 :                 return 0;
    1377             :         }
    1378           0 :         php_clear_stat_cache(0, NULL, 0 TSRMLS_CC);
    1379           0 :         return 1;
    1380             : }
    1381             : 
    1382             : 
    1383             : static php_stream_wrapper_ops php_plain_files_wrapper_ops = {
    1384             :         php_plain_files_stream_opener,
    1385             :         NULL,
    1386             :         NULL,
    1387             :         php_plain_files_url_stater,
    1388             :         php_plain_files_dir_opener,
    1389             :         "plainfile",
    1390             :         php_plain_files_unlink,
    1391             :         php_plain_files_rename,
    1392             :         php_plain_files_mkdir,
    1393             :         php_plain_files_rmdir,
    1394             :         php_plain_files_metadata
    1395             : };
    1396             : 
    1397             : php_stream_wrapper php_plain_files_wrapper = {
    1398             :         &php_plain_files_wrapper_ops,
    1399             :         NULL,
    1400             :         0
    1401             : };
    1402             : 
    1403             : /* {{{ php_stream_fopen_with_path */
    1404           0 : PHPAPI php_stream *_php_stream_fopen_with_path(const char *filename, const char *mode, const char *path, char **opened_path, int options STREAMS_DC TSRMLS_DC)
    1405             : {
    1406             :         /* code ripped off from fopen_wrappers.c */
    1407             :         char *pathbuf, *end;
    1408             :         const char *ptr;
    1409             :         const char *exec_fname;
    1410             :         char trypath[MAXPATHLEN];
    1411             :         php_stream *stream;
    1412             :         int path_length;
    1413             :         int filename_length;
    1414             :         int exec_fname_length;
    1415             : 
    1416           0 :         if (opened_path) {
    1417           0 :                 *opened_path = NULL;
    1418             :         }
    1419             : 
    1420           0 :         if(!filename) {
    1421           0 :                 return NULL;
    1422             :         }
    1423             : 
    1424           0 :         filename_length = strlen(filename);
    1425             : 
    1426             :         /* Relative path open */
    1427           0 :         if (*filename == '.' && (IS_SLASH(filename[1]) || filename[1] == '.')) {
    1428             :                 /* further checks, we could have ....... filenames */
    1429           0 :                 ptr = filename + 1;
    1430           0 :                 if (*ptr == '.') {
    1431           0 :                         while (*(++ptr) == '.');
    1432           0 :                         if (!IS_SLASH(*ptr)) { /* not a relative path after all */
    1433           0 :                                 goto not_relative_path;
    1434             :                         }
    1435             :                 }
    1436             : 
    1437             : 
    1438           0 :                 if (((options & STREAM_DISABLE_OPEN_BASEDIR) == 0) && php_check_open_basedir(filename TSRMLS_CC)) {
    1439           0 :                         return NULL;
    1440             :                 }
    1441             : 
    1442           0 :                 return php_stream_fopen_rel(filename, mode, opened_path, options);
    1443             :         }
    1444             : 
    1445             : not_relative_path:
    1446             : 
    1447             :         /* Absolute path open */
    1448           0 :         if (IS_ABSOLUTE_PATH(filename, filename_length)) {
    1449             : 
    1450           0 :                 if (((options & STREAM_DISABLE_OPEN_BASEDIR) == 0) && php_check_open_basedir(filename TSRMLS_CC)) {
    1451           0 :                         return NULL;
    1452             :                 }
    1453             : 
    1454           0 :                 return php_stream_fopen_rel(filename, mode, opened_path, options);
    1455             :         }
    1456             :         
    1457             : #ifdef PHP_WIN32
    1458             :         if (IS_SLASH(filename[0])) {
    1459             :                 size_t cwd_len;
    1460             :                 char *cwd;
    1461             :                 cwd = virtual_getcwd_ex(&cwd_len TSRMLS_CC);
    1462             :                 /* getcwd() will return always return [DRIVE_LETTER]:/) on windows. */
    1463             :                 *(cwd+3) = '\0';
    1464             :         
    1465             :                 if (snprintf(trypath, MAXPATHLEN, "%s%s", cwd, filename) >= MAXPATHLEN) {
    1466             :                         php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s/%s path was truncated to %d", cwd, filename, MAXPATHLEN);
    1467             :                 }
    1468             :                 
    1469             :                 efree(cwd);
    1470             :                 
    1471             :                 if (((options & STREAM_DISABLE_OPEN_BASEDIR) == 0) && php_check_open_basedir(trypath TSRMLS_CC)) {
    1472             :                         return NULL;
    1473             :                 }
    1474             :                 
    1475             :                 return php_stream_fopen_rel(trypath, mode, opened_path, options);
    1476             :         }
    1477             : #endif
    1478             : 
    1479           0 :         if (!path || (path && !*path)) {
    1480           0 :                 return php_stream_fopen_rel(filename, mode, opened_path, options);
    1481             :         }
    1482             : 
    1483             :         /* check in provided path */
    1484             :         /* append the calling scripts' current working directory
    1485             :          * as a fall back case
    1486             :          */
    1487           0 :         if (zend_is_executing(TSRMLS_C)) {
    1488           0 :                 exec_fname = zend_get_executed_filename(TSRMLS_C);
    1489           0 :                 exec_fname_length = strlen(exec_fname);
    1490           0 :                 path_length = strlen(path);
    1491             : 
    1492           0 :                 while ((--exec_fname_length >= 0) && !IS_SLASH(exec_fname[exec_fname_length]));
    1493           0 :                 if ((exec_fname && exec_fname[0] == '[')
    1494             :                                 || exec_fname_length<=0) {
    1495             :                         /* [no active file] or no path */
    1496           0 :                         pathbuf = estrdup(path);
    1497             :                 } else {
    1498           0 :                         pathbuf = (char *) emalloc(exec_fname_length + path_length +1 +1);
    1499           0 :                         memcpy(pathbuf, path, path_length);
    1500           0 :                         pathbuf[path_length] = DEFAULT_DIR_SEPARATOR;
    1501           0 :                         memcpy(pathbuf+path_length+1, exec_fname, exec_fname_length);
    1502           0 :                         pathbuf[path_length + exec_fname_length +1] = '\0';
    1503             :                 }
    1504             :         } else {
    1505           0 :                 pathbuf = estrdup(path);
    1506             :         }
    1507             : 
    1508           0 :         ptr = pathbuf;
    1509             : 
    1510           0 :         while (ptr && *ptr) {
    1511           0 :                 end = strchr(ptr, DEFAULT_DIR_SEPARATOR);
    1512           0 :                 if (end != NULL) {
    1513           0 :                         *end = '\0';
    1514           0 :                         end++;
    1515             :                 }
    1516           0 :                 if (*ptr == '\0') {
    1517           0 :                         goto stream_skip;
    1518             :                 }
    1519           0 :                 if (snprintf(trypath, MAXPATHLEN, "%s/%s", ptr, filename) >= MAXPATHLEN) {
    1520           0 :                         php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s/%s path was truncated to %d", ptr, filename, MAXPATHLEN);
    1521             :                 }
    1522             : 
    1523           0 :                 if (((options & STREAM_DISABLE_OPEN_BASEDIR) == 0) && php_check_open_basedir_ex(trypath, 0 TSRMLS_CC)) {
    1524           0 :                         goto stream_skip;
    1525             :                 }
    1526             :                 
    1527           0 :                 stream = php_stream_fopen_rel(trypath, mode, opened_path, options);
    1528           0 :                 if (stream) {
    1529           0 :                         efree(pathbuf);
    1530           0 :                         return stream;
    1531             :                 }
    1532             : stream_skip:
    1533           0 :                 ptr = end;
    1534             :         } /* end provided path */
    1535             : 
    1536           0 :         efree(pathbuf);
    1537           0 :         return NULL;
    1538             : 
    1539             : }
    1540             : /* }}} */
    1541             : 
    1542             : /*
    1543             :  * Local variables:
    1544             :  * tab-width: 4
    1545             :  * c-basic-offset: 4
    1546             :  * End:
    1547             :  * vim600: noet sw=4 ts=4 fdm=marker
    1548             :  * vim<600: noet sw=4 ts=4
    1549             :  */

Generated by: LCOV version 1.10

Generated at Wed, 22 Oct 2014 07:25:04 +0000 (3 days ago)

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