Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-31 19:25
📄 php_stream_context.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Wez Furlong <wez@thebrainroom.com> \| +----------------------------------------------------------------------+ / / Stream context and status notification related definitions / / callback for status notifications / typedef void (php_stream_notification_func)(php_stream_context context, int notifycode, int severity, char xmsg, int xcode, size_t bytes_sofar, size_t bytes_max, void * ptr); #define PHP_STREAM_NOTIFIER_PROGRESS 1 /* TODO: Remove dependence on ext/standard/file.h for the default context global / #define php_stream_context_get_default(without_context) \ (without_context) ? NULL : FG(default_context) ? FG(default_context) : \ (FG(default_context) = php_stream_context_alloc()) / Attempt to fetch context from the zval passed, If no context was passed, use the default context The default context has not yet been created, do it now. / #define php_stream_context_from_zval(zcontext, nocontext) ( \ (zcontext) ? zend_fetch_resource_ex(zcontext, "Stream-Context", php_le_stream_context()) : \ php_stream_context_get_default(nocontext)) #define php_stream_context_to_zval(context, zval) { ZVAL_RES(zval, (context)->res); GC_ADDREF((context)->res); } typedef struct _php_stream_notifier php_stream_notifier; struct _php_stream_notifier { php_stream_notification_func func; void (dtor)(php_stream_notifier notifier); void ptr; int mask; size_t progress, progress_max; /* position for progress notification / }; struct _php_stream_context { php_stream_notifier notifier; zval options; /* hash keyed by wrapper family or specific wrapper / zend_resource res; /* used for auto-cleanup / }; BEGIN_EXTERN_C() PHPAPI int php_le_stream_context(void); PHPAPI void php_stream_context_free(php_stream_context context); PHPAPI php_stream_context php_stream_context_alloc(void); PHPAPI zval php_stream_context_get_option(const php_stream_context context, const char wrappername, const char optionname); PHPAPI void php_stream_context_set_option(php_stream_context context, const char wrappername, const char optionname, zval optionvalue); void php_stream_context_unset_option(php_stream_context context, const char wrappername, const char optionname); struct php_uri_parser; PHPAPI const struct php_uri_parser php_stream_context_get_uri_parser(const char wrappername, php_stream_context context); PHPAPI php_stream_notifier php_stream_notification_alloc(void); PHPAPI void php_stream_notification_free(php_stream_notifier notifier); END_EXTERN_C() / not all notification codes are implemented / #define PHP_STREAM_NOTIFY_RESOLVE 1 #define PHP_STREAM_NOTIFY_CONNECT 2 #define PHP_STREAM_NOTIFY_AUTH_REQUIRED 3 #define PHP_STREAM_NOTIFY_MIME_TYPE_IS 4 #define PHP_STREAM_NOTIFY_FILE_SIZE_IS 5 #define PHP_STREAM_NOTIFY_REDIRECTED 6 #define PHP_STREAM_NOTIFY_PROGRESS 7 #define PHP_STREAM_NOTIFY_COMPLETED 8 #define PHP_STREAM_NOTIFY_FAILURE 9 #define PHP_STREAM_NOTIFY_AUTH_RESULT 10 #define PHP_STREAM_NOTIFY_SEVERITY_INFO 0 #define PHP_STREAM_NOTIFY_SEVERITY_WARN 1 #define PHP_STREAM_NOTIFY_SEVERITY_ERR 2 BEGIN_EXTERN_C() PHPAPI void php_stream_notification_notify(php_stream_context context, int notifycode, int severity, char xmsg, int xcode, size_t bytes_sofar, size_t bytes_max, void ptr); PHPAPI php_stream_context php_stream_context_set(php_stream stream, php_stream_context *context); END_EXTERN_C() #define php_stream_notify_info(context, code, xmsg, xcode) do { if ((context) && (context)->notifier) { \ php_stream_notification_notify((context), (code), PHP_STREAM_NOTIFY_SEVERITY_INFO, \ (xmsg), (xcode), 0, 0, NULL); } } while (0) #define php_stream_notify_progress(context, bsofar, bmax) do { if ((context) && (context)->notifier) { \ php_stream_notification_notify((context), PHP_STREAM_NOTIFY_PROGRESS, PHP_STREAM_NOTIFY_SEVERITY_INFO, \ NULL, 0, (bsofar), (bmax), NULL); } } while(0) #define php_stream_notify_completed(context) do { if ((context) && (context)->notifier) { \ php_stream_notification_notify((context), PHP_STREAM_NOTIFY_COMPLETED, PHP_STREAM_NOTIFY_SEVERITY_INFO, \ NULL, 0, (context)->notifier->progress, (context)->notifier->progress_max, NULL); } } while(0) #define php_stream_notify_progress_init(context, sofar, bmax) do { if ((context) && (context)->notifier) { \ (context)->notifier->progress = (sofar); \ (context)->notifier->progress_max = (bmax); \ (context)->notifier->mask \|= PHP_STREAM_NOTIFIER_PROGRESS; \ php_stream_notify_progress((context), (sofar), (bmax)); } } while (0) #define php_stream_notify_progress_increment(context, dsofar, dmax) do { if ((context) && (context)->notifier && ((context)->notifier->mask & PHP_STREAM_NOTIFIER_PROGRESS)) { \ (context)->notifier->progress += (dsofar); \ (context)->notifier->progress_max += (dmax); \ php_stream_notify_progress((context), (context)->notifier->progress, (context)->notifier->progress_max); } } while (0) #define php_stream_notify_file_size(context, file_size, xmsg, xcode) do { if ((context) && (context)->notifier) { \ php_stream_notification_notify((context), PHP_STREAM_NOTIFY_FILE_SIZE_IS, PHP_STREAM_NOTIFY_SEVERITY_INFO, \ (xmsg), (xcode), 0, (file_size), NULL); } } while(0) #define php_stream_notify_error(context, code, xmsg, xcode) do { if ((context) && (context)->notifier) {\ php_stream_notification_notify((context), (code), PHP_STREAM_NOTIFY_SEVERITY_ERR, \ (xmsg), (xcode), 0, 0, NULL); } } while(0)	6.19 KB	2026-03-12 17:17
📄 php_stream_filter_api.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Wez Furlong <wez@thebrainroom.com> \| \| With suggestions from: \| \| Moriyoshi Koizumi <moriyoshi@at.wakwak.com> \| \| Sara Golemon <pollita@php.net> \| +----------------------------------------------------------------------+ / / The filter API works on the principle of "Bucket-Brigades". This is * partially inspired by the Apache 2 method of doing things, although * it is intentionally a light-weight implementation. * * Each stream can have a chain of filters for reading and another for writing. * * When data is written to the stream, it is placed into a bucket and placed at * the start of the input brigade. * * The first filter in the chain is invoked on the brigade and (depending on * it's return value), the next filter is invoked and so on. * / #define PHP_STREAM_FILTER_READ 0x0001 #define PHP_STREAM_FILTER_WRITE 0x0002 #define PHP_STREAM_FILTER_ALL (PHP_STREAM_FILTER_READ \| PHP_STREAM_FILTER_WRITE) typedef struct _php_stream_bucket php_stream_bucket; typedef struct _php_stream_bucket_brigade php_stream_bucket_brigade; struct _php_stream_bucket { php_stream_bucket next, prev; php_stream_bucket_brigade brigade; char buf; size_t buflen; / if non-zero, buf should be pefreed when the bucket is destroyed / bool own_buf; bool is_persistent; / destroy this struct when refcount falls to zero / int refcount; }; struct _php_stream_bucket_brigade { php_stream_bucket head, tail; }; typedef enum { PSFS_ERR_FATAL, / error in data stream / PSFS_FEED_ME, / filter needs more data; stop processing chain until more is available / PSFS_PASS_ON / filter generated output buckets; pass them on to next in chain / } php_stream_filter_status_t; / Buckets API. / BEGIN_EXTERN_C() PHPAPI php_stream_bucket php_stream_bucket_new(const php_stream stream, char buf, size_t buflen, uint8_t own_buf, uint8_t buf_persistent); PHPAPI int php_stream_bucket_split(php_stream_bucket in, php_stream_bucket left, php_stream_bucket right, size_t length); PHPAPI void php_stream_bucket_delref(php_stream_bucket bucket); #define php_stream_bucket_addref(bucket) (bucket)->refcount++ PHPAPI void php_stream_bucket_prepend(php_stream_bucket_brigade brigade, php_stream_bucket bucket); PHPAPI void php_stream_bucket_append(php_stream_bucket_brigade brigade, php_stream_bucket bucket); PHPAPI void php_stream_bucket_unlink(php_stream_bucket bucket); PHPAPI php_stream_bucket php_stream_bucket_make_writeable(php_stream_bucket bucket); END_EXTERN_C() #define PSFS_FLAG_NORMAL 0 / regular read/write / #define PSFS_FLAG_FLUSH_INC 1 / an incremental flush / #define PSFS_FLAG_FLUSH_CLOSE 2 / final flush prior to closing / typedef struct _php_stream_filter_ops { php_stream_filter_status_t (filter)( php_stream stream, php_stream_filter thisfilter, php_stream_bucket_brigade buckets_in, php_stream_bucket_brigade buckets_out, size_t bytes_consumed, int flags ); void (dtor)(php_stream_filter thisfilter); const char label; } php_stream_filter_ops; typedef struct _php_stream_filter_chain { php_stream_filter head, tail; /* Owning stream / php_stream stream; } php_stream_filter_chain; struct _php_stream_filter { const php_stream_filter_ops fops; zval abstract; / for use by filter implementation / php_stream_filter next; php_stream_filter prev; int is_persistent; / link into stream and chain / php_stream_filter_chain chain; /* buffered buckets / php_stream_bucket_brigade buffer; / filters are auto_registered when they're applied / zend_resource res; }; /* stack filter onto a stream / BEGIN_EXTERN_C() PHPAPI void _php_stream_filter_prepend(php_stream_filter_chain chain, php_stream_filter filter); PHPAPI void php_stream_filter_prepend_ex(php_stream_filter_chain chain, php_stream_filter filter); PHPAPI void _php_stream_filter_append(php_stream_filter_chain chain, php_stream_filter filter); PHPAPI zend_result php_stream_filter_append_ex(php_stream_filter_chain chain, php_stream_filter filter); PHPAPI zend_result _php_stream_filter_flush(php_stream_filter filter, bool finish); PHPAPI php_stream_filter php_stream_filter_remove(php_stream_filter filter, bool call_dtor); PHPAPI void php_stream_filter_free(php_stream_filter filter); PHPAPI php_stream_filter _php_stream_filter_alloc(const php_stream_filter_ops fops, void abstract, uint8_t persistent STREAMS_DC); END_EXTERN_C() #define php_stream_filter_alloc(fops, thisptr, persistent) _php_stream_filter_alloc((fops), (thisptr), (persistent) STREAMS_CC) #define php_stream_filter_alloc_rel(fops, thisptr, persistent) _php_stream_filter_alloc((fops), (thisptr), (persistent) STREAMS_REL_CC) #define php_stream_filter_prepend(chain, filter) _php_stream_filter_prepend((chain), (filter)) #define php_stream_filter_append(chain, filter) _php_stream_filter_append((chain), (filter)) #define php_stream_filter_flush(filter, finish) _php_stream_filter_flush((filter), (finish)) #define php_stream_is_filtered(stream) ((stream)->readfilters.head \|\| (stream)->writefilters.head) typedef struct _php_stream_filter_factory { php_stream_filter (create_filter)(const char filtername, zval filterparams, uint8_t persistent); } php_stream_filter_factory; BEGIN_EXTERN_C() PHPAPI zend_result php_stream_filter_register_factory(const char filterpattern, const php_stream_filter_factory factory); PHPAPI zend_result php_stream_filter_unregister_factory(const char filterpattern); PHPAPI zend_result php_stream_filter_register_factory_volatile(zend_string filterpattern, const php_stream_filter_factory factory); PHPAPI php_stream_filter php_stream_filter_create(const char filtername, zval filterparams, uint8_t persistent); END_EXTERN_C()	6.59 KB	2026-03-12 17:17
📄 php_stream_glob_wrapper.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Marcus Boerger <helly@php.net> \| +----------------------------------------------------------------------+ / PHPAPI extern const php_stream_wrapper php_glob_stream_wrapper; PHPAPI extern const php_stream_ops php_glob_stream_ops; BEGIN_EXTERN_C() PHPAPI char _php_glob_stream_get_path(php_stream stream, size_t plen STREAMS_DC); #define php_glob_stream_get_path(stream, plen) _php_glob_stream_get_path((stream), (plen) STREAMS_CC) PHPAPI char* _php_glob_stream_get_pattern(php_stream stream, size_t plen STREAMS_DC); #define php_glob_stream_get_pattern(stream, plen) _php_glob_stream_get_pattern((stream), (plen) STREAMS_CC) PHPAPI int _php_glob_stream_get_count(php_stream stream, int pflags STREAMS_DC); #define php_glob_stream_get_count(stream, pflags) _php_glob_stream_get_count((stream), (pflags) STREAMS_CC) END_EXTERN_C()	1.69 KB	2026-03-12 17:17
📄 php_stream_mmap.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Wez Furlong <wez@thebrainroom.com> \| +----------------------------------------------------------------------+ / / Memory Mapping interface for streams. * The intention is to provide a uniform interface over the most common * operations that are used within PHP itself, rather than a complete * API for all memory mapping needs. * * ATM, we support only mmap(), but win32 memory mapping support will * follow soon. * / typedef enum { / Does the stream support mmap ? / PHP_STREAM_MMAP_SUPPORTED, / Request a range and offset to be mapped; * while mapped, you MUST NOT use any read/write functions * on the stream (win9x compatibility) / PHP_STREAM_MMAP_MAP_RANGE, / Unmap the last range that was mapped for the stream / PHP_STREAM_MMAP_UNMAP } php_stream_mmap_operation_t; typedef enum { PHP_STREAM_MAP_MODE_READONLY, PHP_STREAM_MAP_MODE_READWRITE, PHP_STREAM_MAP_MODE_SHARED_READONLY, PHP_STREAM_MAP_MODE_SHARED_READWRITE } php_stream_mmap_access_t; typedef struct { / requested offset and length. * If length is 0, the whole file is mapped / size_t offset; size_t length; php_stream_mmap_access_t mode; / returned mapped address / char mapped; } php_stream_mmap_range; #define PHP_STREAM_MMAP_ALL 0 #define PHP_STREAM_MMAP_MAX (512 * 1024 * 1024) #define php_stream_mmap_supported(stream) (_php_stream_set_option((stream), PHP_STREAM_OPTION_MMAP_API, PHP_STREAM_MMAP_SUPPORTED, NULL) == 0 ? 1 : 0) /* Returns 1 if the stream in its current state can be memory mapped, * 0 otherwise / #define php_stream_mmap_possible(stream) (!php_stream_is_filtered((stream)) && php_stream_mmap_supported((stream))) BEGIN_EXTERN_C() PHPAPI char _php_stream_mmap_range(php_stream stream, size_t offset, size_t length, php_stream_mmap_access_t mode, size_t mapped_len); #define php_stream_mmap_range(stream, offset, length, mode, mapped_len) _php_stream_mmap_range((stream), (offset), (length), (mode), (mapped_len)) /* un-maps the last mapped range / PHPAPI int _php_stream_mmap_unmap(php_stream stream); #define php_stream_mmap_unmap(stream) _php_stream_mmap_unmap((stream)) PHPAPI int _php_stream_mmap_unmap_ex(php_stream *stream, zend_off_t readden); #define php_stream_mmap_unmap_ex(stream, readden) _php_stream_mmap_unmap_ex((stream), (readden)) END_EXTERN_C()	3.11 KB	2026-03-12 17:17
📄 php_stream_plain_wrapper.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Wez Furlong <wez@thebrainroom.com> \| +----------------------------------------------------------------------+ / / definitions for the plain files wrapper / / operations for a plain file; use the php_stream_fopen_XXX funcs below / PHPAPI extern php_stream_ops php_stream_stdio_ops; PHPAPI extern /const/ php_stream_wrapper php_plain_files_wrapper; BEGIN_EXTERN_C() / like fopen, but returns a stream / PHPAPI php_stream _php_stream_fopen(const char filename, const char mode, zend_string *opened_path, int options STREAMS_DC); #define php_stream_fopen(filename, mode, opened) _php_stream_fopen((filename), (mode), (opened), 0 STREAMS_CC) PHPAPI php_stream _php_stream_fopen_with_path(const char filename, const char mode, const char path, zend_string opened_path, int options STREAMS_DC); #define php_stream_fopen_with_path(filename, mode, path, opened) _php_stream_fopen_with_path((filename), (mode), (path), (opened), 0 STREAMS_CC) PHPAPI php_stream _php_stream_fopen_from_file(FILE file, const char mode STREAMS_DC); #define php_stream_fopen_from_file(file, mode) _php_stream_fopen_from_file((file), (mode) STREAMS_CC) PHPAPI php_stream _php_stream_fopen_from_fd(int fd, const char mode, const char persistent_id, bool zero_position STREAMS_DC); #define php_stream_fopen_from_fd(fd, mode, persistent_id) _php_stream_fopen_from_fd((fd), (mode), (persistent_id), false STREAMS_CC) PHPAPI php_stream _php_stream_fopen_from_pipe(FILE file, const char mode STREAMS_DC); #define php_stream_fopen_from_pipe(file, mode) _php_stream_fopen_from_pipe((file), (mode) STREAMS_CC) PHPAPI php_stream _php_stream_fopen_tmpfile(int dummy STREAMS_DC); #define php_stream_fopen_tmpfile() _php_stream_fopen_tmpfile(0 STREAMS_CC) PHPAPI php_stream _php_stream_fopen_temporary_file(const char dir, const char pfx, zend_string *opened_path STREAMS_DC); #define php_stream_fopen_temporary_file(dir, pfx, opened_path) _php_stream_fopen_temporary_file((dir), (pfx), (opened_path) STREAMS_CC) / This is a utility API for extensions that are opening a stream, converting it * to a FILE* and then closing it again. Be warned that fileno() on the result * will most likely fail on systems with fopencookie. / PHPAPI FILE _php_stream_open_wrapper_as_file(char * path, char * mode, int options, zend_string *opened_path STREAMS_DC); #define php_stream_open_wrapper_as_file(path, mode, options, opened_path) _php_stream_open_wrapper_as_file((path), (mode), (options), (opened_path) STREAMS_CC) / parse standard "fopen" modes into open() flags / PHPAPI int php_stream_parse_fopen_modes(const char mode, int *open_flags); END_EXTERN_C()	3.46 KB	2026-03-12 17:17
📄 php_stream_transport.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Wez Furlong <wez@thebrainroom.com> \| +----------------------------------------------------------------------+ / #ifdef PHP_WIN32 #include "config.w32.h" #include <Ws2tcpip.h> #endif #ifdef HAVE_SYS_SOCKET_H # include <sys/socket.h> #endif typedef php_stream (php_stream_transport_factory_func)(const char proto, size_t protolen, const char resourcename, size_t resourcenamelen, const char persistent_id, int options, int flags, struct timeval timeout, php_stream_context context STREAMS_DC); typedef php_stream_transport_factory_func php_stream_transport_factory; BEGIN_EXTERN_C() PHPAPI int php_stream_xport_register(const char protocol, php_stream_transport_factory factory); PHPAPI int php_stream_xport_unregister(const char protocol); #define STREAM_XPORT_CLIENT 0 #define STREAM_XPORT_SERVER 1 #define STREAM_XPORT_CONNECT 2 #define STREAM_XPORT_BIND 4 #define STREAM_XPORT_LISTEN 8 #define STREAM_XPORT_CONNECT_ASYNC 16 /* Open a client or server socket connection / PHPAPI php_stream _php_stream_xport_create(const char name, size_t namelen, int options, int flags, const char persistent_id, struct timeval timeout, php_stream_context context, zend_string *error_string, int error_code STREAMS_DC); #define php_stream_xport_create(name, namelen, options, flags, persistent_id, timeout, context, estr, ecode) \ _php_stream_xport_create(name, namelen, options, flags, persistent_id, timeout, context, estr, ecode STREAMS_CC) /* Bind the stream to a local address / PHPAPI int php_stream_xport_bind(php_stream stream, const char name, size_t namelen, zend_string error_text ); / Connect to a remote address / PHPAPI int php_stream_xport_connect(php_stream stream, const char name, size_t namelen, int asynchronous, struct timeval timeout, zend_string *error_text, int error_code ); /* Prepare to listen / PHPAPI int php_stream_xport_listen(php_stream stream, int backlog, zend_string *error_text ); / Get the next client and their address as a string, or the underlying address * structure. You must efree either of these if you request them / PHPAPI int php_stream_xport_accept(php_stream stream, php_stream client, zend_string textaddr, void *addr, socklen_t addrlen, struct timeval timeout, zend_string error_text ); / Get the name of either the socket or it's peer / PHPAPI int php_stream_xport_get_name(php_stream stream, int want_peer, zend_string textaddr, void addr, socklen_t addrlen ); enum php_stream_xport_send_recv_flags { STREAM_OOB = 1, STREAM_PEEK = 2 }; / Similar to recv() system call; read data from the stream, optionally * peeking, optionally retrieving OOB data / PHPAPI int php_stream_xport_recvfrom(php_stream stream, char buf, size_t buflen, int flags, void addr, socklen_t addrlen, zend_string *textaddr); / Similar to send() system call; send data to the stream, optionally * sending it as OOB data / PHPAPI int php_stream_xport_sendto(php_stream stream, const char buf, size_t buflen, int flags, void addr, socklen_t addrlen); typedef enum { STREAM_SHUT_RD, STREAM_SHUT_WR, STREAM_SHUT_RDWR } stream_shutdown_t; /* Similar to shutdown() system call; shut down part of a full-duplex * connection / PHPAPI int php_stream_xport_shutdown(php_stream stream, stream_shutdown_t how); END_EXTERN_C() /* Structure definition for the set_option interface that the above functions wrap / typedef struct _php_stream_xport_param { enum { STREAM_XPORT_OP_BIND, STREAM_XPORT_OP_CONNECT, STREAM_XPORT_OP_LISTEN, STREAM_XPORT_OP_ACCEPT, STREAM_XPORT_OP_CONNECT_ASYNC, STREAM_XPORT_OP_GET_NAME, STREAM_XPORT_OP_GET_PEER_NAME, STREAM_XPORT_OP_RECV, STREAM_XPORT_OP_SEND, STREAM_XPORT_OP_SHUTDOWN } op; unsigned int want_addr:1; unsigned int want_textaddr:1; unsigned int want_errortext:1; unsigned int how:2; struct { char name; size_t namelen; struct timeval timeout; struct sockaddr addr; char buf; size_t buflen; socklen_t addrlen; int backlog; int flags; } inputs; struct { php_stream client; struct sockaddr addr; socklen_t addrlen; zend_string textaddr; zend_string error_text; int returncode; int error_code; } outputs; } php_stream_xport_param; / Because both client and server streams use the same mechanisms for encryption we use the LSB to denote clients. / typedef enum { STREAM_CRYPTO_METHOD_SSLv2_CLIENT = (1 << 1 \| 1), STREAM_CRYPTO_METHOD_SSLv3_CLIENT = (1 << 2 \| 1), / v23 no longer negotiates SSL2 or SSL3 / STREAM_CRYPTO_METHOD_SSLv23_CLIENT = ((1 << 3) \| (1 << 4) \| (1 << 5) \| 1), STREAM_CRYPTO_METHOD_TLSv1_0_CLIENT = (1 << 3 \| 1), STREAM_CRYPTO_METHOD_TLSv1_1_CLIENT = (1 << 4 \| 1), STREAM_CRYPTO_METHOD_TLSv1_2_CLIENT = (1 << 5 \| 1), STREAM_CRYPTO_METHOD_TLSv1_3_CLIENT = (1 << 6 \| 1), / TLS equates to TLS_ANY as of PHP 7.2 / STREAM_CRYPTO_METHOD_TLS_CLIENT = ((1 << 3) \| (1 << 4) \| (1 << 5) \| (1 << 6) \| 1), STREAM_CRYPTO_METHOD_TLS_ANY_CLIENT = ((1 << 3) \| (1 << 4) \| (1 << 5) \| (1 << 6) \| 1), STREAM_CRYPTO_METHOD_ANY_CLIENT = ((1 << 1) \| (1 << 2) \| (1 << 3) \| (1 << 4) \| (1 << 5) \| (1 << 6) \| 1), STREAM_CRYPTO_METHOD_SSLv2_SERVER = (1 << 1), STREAM_CRYPTO_METHOD_SSLv3_SERVER = (1 << 2), / v23 no longer negotiates SSL2 or SSL3 / STREAM_CRYPTO_METHOD_SSLv23_SERVER = ((1 << 3) \| (1 << 4) \| (1 << 5) \| (1 << 6)), STREAM_CRYPTO_METHOD_TLSv1_0_SERVER = (1 << 3), STREAM_CRYPTO_METHOD_TLSv1_1_SERVER = (1 << 4), STREAM_CRYPTO_METHOD_TLSv1_2_SERVER = (1 << 5), STREAM_CRYPTO_METHOD_TLSv1_3_SERVER = (1 << 6), / TLS equates to TLS_ANY as of PHP 7.2 / STREAM_CRYPTO_METHOD_TLS_SERVER = ((1 << 3) \| (1 << 4) \| (1 << 5) \| (1 << 6)), STREAM_CRYPTO_METHOD_TLS_ANY_SERVER = ((1 << 3) \| (1 << 4) \| (1 << 5) \| (1 << 6)), STREAM_CRYPTO_METHOD_ANY_SERVER = ((1 << 1) \| (1 << 2) \| (1 << 3) \| (1 << 4) \| (1 << 5) \| (1 << 6)) } php_stream_xport_crypt_method_t; / These functions provide crypto support on the underlying transport / BEGIN_EXTERN_C() PHPAPI int php_stream_xport_crypto_setup(php_stream stream, php_stream_xport_crypt_method_t crypto_method, php_stream session_stream); PHPAPI int php_stream_xport_crypto_enable(php_stream stream, int activate); END_EXTERN_C() typedef struct _php_stream_xport_crypto_param { struct { php_stream session; int activate; php_stream_xport_crypt_method_t method; } inputs; struct { int returncode; } outputs; enum { STREAM_XPORT_CRYPTO_OP_SETUP, STREAM_XPORT_CRYPTO_OP_ENABLE } op; } php_stream_xport_crypto_param; BEGIN_EXTERN_C() PHPAPI HashTable php_stream_xport_get_hash(void); PHPAPI php_stream_transport_factory_func php_stream_generic_socket_factory; END_EXTERN_C()	7.44 KB	2026-03-12 17:17
📄 php_stream_userspace.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Wez Furlong <wez@thebrainroom.com> \| +----------------------------------------------------------------------+ / / for user-space streams */ PHPAPI extern const php_stream_ops php_stream_userspace_ops; PHPAPI extern const php_stream_ops php_stream_userspace_dir_ops; #define PHP_STREAM_IS_USERSPACE &php_stream_userspace_ops #define PHP_STREAM_IS_USERSPACE_DIR &php_stream_userspace_dir_ops	1.25 KB	2026-03-12 17:17
📄 php_streams_int.h /* +----------------------------------------------------------------------+ \| Copyright (c) The PHP Group \| +----------------------------------------------------------------------+ \| This source file is subject to version 3.01 of the PHP license, \| \| that is bundled with this package in the file LICENSE, and is \| \| available through the world-wide-web at the following url: \| \| https://www.php.net/license/3_01.txt \| \| If you did not receive a copy of the PHP license and are unable to \| \| obtain it through the world-wide-web, please send a note to \| \| license@php.net so we can mail you a copy immediately. \| +----------------------------------------------------------------------+ \| Author: Wez Furlong <wez@thebrainroom.com> \| +----------------------------------------------------------------------+ / / internal header; not supposed to be installed; FIXME but unfortunately is / #if ZEND_DEBUG #define emalloc_rel_orig(size) \ ( __php_stream_call_depth == 0 \ ? _emalloc((size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_RELAY_CC) \ : _emalloc((size) ZEND_FILE_LINE_CC ZEND_FILE_LINE_ORIG_RELAY_CC) ) #define erealloc_rel_orig(ptr, size) \ ( __php_stream_call_depth == 0 \ ? _erealloc((ptr), (size), 0 ZEND_FILE_LINE_CC ZEND_FILE_LINE_RELAY_CC) \ : _erealloc((ptr), (size), 0 ZEND_FILE_LINE_CC ZEND_FILE_LINE_ORIG_RELAY_CC) ) #define pemalloc_rel_orig(size, persistent) ((persistent) ? malloc((size)) : emalloc_rel_orig((size))) #define perealloc_rel_orig(ptr, size, persistent) ((persistent) ? realloc((ptr), (size)) : erealloc_rel_orig((ptr), (size))) #else # define pemalloc_rel_orig(size, persistent) pemalloc((size), (persistent)) # define perealloc_rel_orig(ptr, size, persistent) perealloc((ptr), (size), (persistent)) # define emalloc_rel_orig(size) emalloc((size)) #endif #define STREAM_DEBUG 0 #define STREAM_WRAPPER_PLAIN_FILES ((php_stream_wrapper)-1) #ifndef MAP_FAILED #define MAP_FAILED ((void ) -1) #endif #define CHUNK_SIZE 8192 #ifdef PHP_WIN32 # ifdef EWOULDBLOCK # undef EWOULDBLOCK # endif # define EWOULDBLOCK WSAEWOULDBLOCK # ifdef EMSGSIZE # undef EMSGSIZE # endif # define EMSGSIZE WSAEMSGSIZE #endif / This functions transforms the first char to 'w' if it's not 'r', 'a' or 'w' * and strips any subsequent chars except '+' and 'b'. * Use this to sanitize stream->mode if you call e.g. fdopen, fopencookie or * any other function that expects standard modes and you allow non-standard * ones. result should be a char[5]. / void php_stream_mode_sanitize_fdopen_fopencookie(php_stream stream, char *result);	2.68 KB	2026-03-12 17:17
📄 userspace_arginfo.h /* This is a generated file, edit the .stub.php file instead. * Stub hash: 9198095c858c95fcb31252ddfa24fe04787d0460 */ static void register_userspace_symbols(int module_number) { REGISTER_LONG_CONSTANT("STREAM_USE_PATH", USE_PATH, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_IGNORE_URL", IGNORE_URL, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_REPORT_ERRORS", REPORT_ERRORS, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_MUST_SEEK", STREAM_MUST_SEEK, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_URL_STAT_LINK", PHP_STREAM_URL_STAT_LINK, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_URL_STAT_QUIET", PHP_STREAM_URL_STAT_QUIET, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_MKDIR_RECURSIVE", PHP_STREAM_MKDIR_RECURSIVE, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_IS_URL", PHP_STREAM_IS_URL, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_OPTION_BLOCKING", PHP_STREAM_OPTION_BLOCKING, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_OPTION_READ_TIMEOUT", PHP_STREAM_OPTION_READ_TIMEOUT, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_OPTION_READ_BUFFER", PHP_STREAM_OPTION_READ_BUFFER, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_OPTION_WRITE_BUFFER", PHP_STREAM_OPTION_WRITE_BUFFER, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_BUFFER_NONE", PHP_STREAM_BUFFER_NONE, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_BUFFER_LINE", PHP_STREAM_BUFFER_LINE, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_BUFFER_FULL", PHP_STREAM_BUFFER_FULL, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_CAST_AS_STREAM", PHP_STREAM_AS_STDIO, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_CAST_FOR_SELECT", PHP_STREAM_AS_FD_FOR_SELECT, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_META_TOUCH", PHP_STREAM_META_TOUCH, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_META_OWNER", PHP_STREAM_META_OWNER, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_META_OWNER_NAME", PHP_STREAM_META_OWNER_NAME, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_META_GROUP", PHP_STREAM_META_GROUP, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_META_GROUP_NAME", PHP_STREAM_META_GROUP_NAME, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("STREAM_META_ACCESS", PHP_STREAM_META_ACCESS, CONST_PERSISTENT); }	2.21 KB	2026-03-12 17:17

Terminal