610 lines
19 KiB
PHP
610 lines
19 KiB
PHP
<?php
|
|
|
|
namespace Safe;
|
|
|
|
use Safe\Exceptions\StreamException;
|
|
|
|
/**
|
|
* Sets parameters on the specified context.
|
|
*
|
|
* @param resource $stream_or_context The stream or context to apply the parameters too.
|
|
* @param array $params An array of parameters to set.
|
|
*
|
|
* params should be an associative array of the structure:
|
|
* $params['paramname'] = "paramvalue";.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_context_set_params($stream_or_context, array $params): void
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_context_set_params($stream_or_context, $params);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Makes a copy of up to maxlength bytes
|
|
* of data from the current position (or from the
|
|
* offset position, if specified) in
|
|
* source to dest. If
|
|
* maxlength is not specified, all remaining content in
|
|
* source will be copied.
|
|
*
|
|
* @param resource $source The source stream
|
|
* @param resource $dest The destination stream
|
|
* @param int $maxlength Maximum bytes to copy
|
|
* @param int $offset The offset where to start to copy data
|
|
* @return int Returns the total count of bytes copied.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_copy_to_stream($source, $dest, int $maxlength = -1, int $offset = 0): int
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_copy_to_stream($source, $dest, $maxlength, $offset);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Adds filtername to the list of filters
|
|
* attached to stream.
|
|
*
|
|
* @param resource $stream The target stream.
|
|
* @param string $filtername The filter name.
|
|
* @param int $read_write By default, stream_filter_append will
|
|
* attach the filter to the read filter chain
|
|
* if the file was opened for reading (i.e. File Mode:
|
|
* r, and/or +). The filter
|
|
* will also be attached to the write filter chain
|
|
* if the file was opened for writing (i.e. File Mode:
|
|
* w, a, and/or +).
|
|
* STREAM_FILTER_READ,
|
|
* STREAM_FILTER_WRITE, and/or
|
|
* STREAM_FILTER_ALL can also be passed to the
|
|
* read_write parameter to override this behavior.
|
|
* @param mixed $params This filter will be added with the specified
|
|
* params to the end of
|
|
* the list and will therefore be called last during stream operations.
|
|
* To add a filter to the beginning of the list, use
|
|
* stream_filter_prepend.
|
|
* @return resource Returns a resource on success. The resource can be
|
|
* used to refer to this filter instance during a call to
|
|
* stream_filter_remove.
|
|
*
|
|
* FALSE is returned if stream is not a resource or
|
|
* if filtername cannot be located.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_filter_append($stream, string $filtername, int $read_write = null, $params = null)
|
|
{
|
|
error_clear_last();
|
|
if ($params !== null) {
|
|
$result = \stream_filter_append($stream, $filtername, $read_write, $params);
|
|
} elseif ($read_write !== null) {
|
|
$result = \stream_filter_append($stream, $filtername, $read_write);
|
|
} else {
|
|
$result = \stream_filter_append($stream, $filtername);
|
|
}
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Adds filtername to the list of filters
|
|
* attached to stream.
|
|
*
|
|
* @param resource $stream The target stream.
|
|
* @param string $filtername The filter name.
|
|
* @param int $read_write By default, stream_filter_prepend will
|
|
* attach the filter to the read filter chain
|
|
* if the file was opened for reading (i.e. File Mode:
|
|
* r, and/or +). The filter
|
|
* will also be attached to the write filter chain
|
|
* if the file was opened for writing (i.e. File Mode:
|
|
* w, a, and/or +).
|
|
* STREAM_FILTER_READ,
|
|
* STREAM_FILTER_WRITE, and/or
|
|
* STREAM_FILTER_ALL can also be passed to the
|
|
* read_write parameter to override this behavior.
|
|
* See stream_filter_append for an example of
|
|
* using this parameter.
|
|
* @param mixed $params This filter will be added with the specified params
|
|
* to the beginning of the list and will therefore be
|
|
* called first during stream operations. To add a filter to the end of the
|
|
* list, use stream_filter_append.
|
|
* @return resource Returns a resource on success. The resource can be
|
|
* used to refer to this filter instance during a call to
|
|
* stream_filter_remove.
|
|
*
|
|
* FALSE is returned if stream is not a resource or
|
|
* if filtername cannot be located.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_filter_prepend($stream, string $filtername, int $read_write = null, $params = null)
|
|
{
|
|
error_clear_last();
|
|
if ($params !== null) {
|
|
$result = \stream_filter_prepend($stream, $filtername, $read_write, $params);
|
|
} elseif ($read_write !== null) {
|
|
$result = \stream_filter_prepend($stream, $filtername, $read_write);
|
|
} else {
|
|
$result = \stream_filter_prepend($stream, $filtername);
|
|
}
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* stream_filter_register allows you to implement
|
|
* your own filter on any registered stream used with all the other
|
|
* filesystem functions (such as fopen,
|
|
* fread etc.).
|
|
*
|
|
* @param string $filtername The filter name to be registered.
|
|
* @param string $classname To implement a filter, you need to define a class as an extension of
|
|
* php_user_filter with a number of member
|
|
* functions. When performing read/write operations on the stream
|
|
* to which your filter is attached, PHP will pass the data through your
|
|
* filter (and any other filters attached to that stream) so that the
|
|
* data may be modified as desired. You must implement the methods
|
|
* exactly as described in php_user_filter - doing
|
|
* otherwise will lead to undefined behaviour.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_filter_register(string $filtername, string $classname): void
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_filter_register($filtername, $classname);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Removes a stream filter previously added to a stream with
|
|
* stream_filter_prepend or
|
|
* stream_filter_append. Any data remaining in the
|
|
* filter's internal buffer will be flushed through to the next filter before
|
|
* removing it.
|
|
*
|
|
* @param resource $stream_filter The stream filter to be removed.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_filter_remove($stream_filter): void
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_filter_remove($stream_filter);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Identical to file_get_contents, except that
|
|
* stream_get_contents operates on an already open
|
|
* stream resource and returns the remaining contents in a string, up to
|
|
* maxlength bytes and starting at the specified
|
|
* offset.
|
|
*
|
|
* @param resource $handle A stream resource (e.g. returned from fopen)
|
|
* @param int $maxlength The maximum bytes to read. Defaults to -1 (read all the remaining
|
|
* buffer).
|
|
* @param int $offset Seek to the specified offset before reading. If this number is negative,
|
|
* no seeking will occur and reading will start from the current position.
|
|
* @return string Returns a string.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_get_contents($handle, int $maxlength = -1, int $offset = -1): string
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_get_contents($handle, $maxlength, $offset);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Determines if stream stream refers to a valid terminal type device.
|
|
* This is a more portable version of posix_isatty, since it works on Windows systems too.
|
|
*
|
|
* @param resource $stream
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_isatty($stream): void
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_isatty($stream);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Resolve filename against the include path according to the same rules as fopen/include.
|
|
*
|
|
* @param string $filename The filename to resolve.
|
|
* @return string Returns a string containing the resolved absolute filename.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_resolve_include_path(string $filename): string
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_resolve_include_path($filename);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets blocking or non-blocking mode on a stream.
|
|
*
|
|
* This function works for any stream that supports non-blocking mode
|
|
* (currently, regular files and socket streams).
|
|
*
|
|
* @param resource $stream The stream.
|
|
* @param bool $mode If mode is FALSE, the given stream
|
|
* will be switched to non-blocking mode, and if TRUE, it
|
|
* will be switched to blocking mode. This affects calls like
|
|
* fgets and fread
|
|
* that read from the stream. In non-blocking mode an
|
|
* fgets call will always return right away
|
|
* while in blocking mode it will wait for data to become available
|
|
* on the stream.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_set_blocking($stream, bool $mode): void
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_set_blocking($stream, $mode);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Sets the timeout value on stream,
|
|
* expressed in the sum of seconds and
|
|
* microseconds.
|
|
*
|
|
* When the stream times out, the 'timed_out' key of the array returned by
|
|
* stream_get_meta_data is set to TRUE, although no
|
|
* error/warning is generated.
|
|
*
|
|
* @param resource $stream The target stream.
|
|
* @param int $seconds The seconds part of the timeout to be set.
|
|
* @param int $microseconds The microseconds part of the timeout to be set.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_set_timeout($stream, int $seconds, int $microseconds = 0): void
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_set_timeout($stream, $seconds, $microseconds);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Accept a connection on a socket previously created by
|
|
* stream_socket_server.
|
|
*
|
|
* @param resource $server_socket The server socket to accept a connection from.
|
|
* @param float $timeout Override the default socket accept timeout. Time should be given in
|
|
* seconds.
|
|
* @param string|null $peername Will be set to the name (address) of the client which connected, if
|
|
* included and available from the selected transport.
|
|
*
|
|
* Can also be determined later using
|
|
* stream_socket_get_name.
|
|
* @return resource Returns a stream to the accepted socket connection.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_socket_accept($server_socket, float $timeout = null, ?string &$peername = null)
|
|
{
|
|
error_clear_last();
|
|
if ($peername !== null) {
|
|
$result = \stream_socket_accept($server_socket, $timeout, $peername);
|
|
} elseif ($timeout !== null) {
|
|
$result = \stream_socket_accept($server_socket, $timeout);
|
|
} else {
|
|
$result = \stream_socket_accept($server_socket);
|
|
}
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Initiates a stream or datagram connection to the destination specified
|
|
* by remote_socket. The type of socket created
|
|
* is determined by the transport specified using standard URL formatting:
|
|
* transport://target. For Internet Domain sockets
|
|
* (AF_INET) such as TCP and UDP, the target portion
|
|
* of the remote_socket parameter should consist of
|
|
* a hostname or IP address followed by a colon and a port number. For Unix
|
|
* domain sockets, the target portion should point
|
|
* to the socket file on the filesystem.
|
|
*
|
|
* @param string $remote_socket Address to the socket to connect to.
|
|
* @param int $errno Will be set to the system level error number if connection fails.
|
|
* @param string $errstr Will be set to the system level error message if the connection fails.
|
|
* @param float $timeout Number of seconds until the connect() system call
|
|
* should timeout.
|
|
*
|
|
*
|
|
* This parameter only applies when not making asynchronous
|
|
* connection attempts.
|
|
*
|
|
*
|
|
*
|
|
*
|
|
* To set a timeout for reading/writing data over the socket, use the
|
|
* stream_set_timeout, as the
|
|
* timeout only applies while making connecting
|
|
* the socket.
|
|
*
|
|
*
|
|
*
|
|
* To set a timeout for reading/writing data over the socket, use the
|
|
* stream_set_timeout, as the
|
|
* timeout only applies while making connecting
|
|
* the socket.
|
|
* @param int $flags Bitmask field which may be set to any combination of connection flags.
|
|
* Currently the select of connection flags is limited to
|
|
* STREAM_CLIENT_CONNECT (default),
|
|
* STREAM_CLIENT_ASYNC_CONNECT and
|
|
* STREAM_CLIENT_PERSISTENT.
|
|
* @param resource $context A valid context resource created with stream_context_create.
|
|
* @return resource On success a stream resource is returned which may
|
|
* be used together with the other file functions (such as
|
|
* fgets, fgetss,
|
|
* fwrite, fclose, and
|
|
* feof), FALSE on failure.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_socket_client(string $remote_socket, int &$errno = null, string &$errstr = null, float $timeout = null, int $flags = STREAM_CLIENT_CONNECT, $context = null)
|
|
{
|
|
error_clear_last();
|
|
if ($context !== null) {
|
|
$result = \stream_socket_client($remote_socket, $errno, $errstr, $timeout, $flags, $context);
|
|
} elseif ($flags !== STREAM_CLIENT_CONNECT) {
|
|
$result = \stream_socket_client($remote_socket, $errno, $errstr, $timeout, $flags);
|
|
} elseif ($timeout !== null) {
|
|
$result = \stream_socket_client($remote_socket, $errno, $errstr, $timeout);
|
|
} else {
|
|
$result = \stream_socket_client($remote_socket, $errno, $errstr);
|
|
}
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* stream_socket_pair creates a pair of connected,
|
|
* indistinguishable socket streams. This function is commonly used in IPC
|
|
* (Inter-Process Communication).
|
|
*
|
|
* @param int $domain The protocol family to be used: STREAM_PF_INET,
|
|
* STREAM_PF_INET6 or
|
|
* STREAM_PF_UNIX
|
|
* @param int $type The type of communication to be used:
|
|
* STREAM_SOCK_DGRAM,
|
|
* STREAM_SOCK_RAW,
|
|
* STREAM_SOCK_RDM,
|
|
* STREAM_SOCK_SEQPACKET or
|
|
* STREAM_SOCK_STREAM
|
|
* @param int $protocol The protocol to be used: STREAM_IPPROTO_ICMP,
|
|
* STREAM_IPPROTO_IP,
|
|
* STREAM_IPPROTO_RAW,
|
|
* STREAM_IPPROTO_TCP or
|
|
* STREAM_IPPROTO_UDP
|
|
* @return resource[] Returns an array with the two socket resources on success.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_socket_pair(int $domain, int $type, int $protocol): iterable
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_socket_pair($domain, $type, $protocol);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Creates a stream or datagram socket on the specified
|
|
* local_socket.
|
|
*
|
|
* This function only creates a socket, to begin accepting connections
|
|
* use stream_socket_accept.
|
|
*
|
|
* @param string $local_socket The type of socket created is determined by the transport specified
|
|
* using standard URL formatting: transport://target.
|
|
*
|
|
* For Internet Domain sockets (AF_INET) such as TCP and UDP, the
|
|
* target portion of the
|
|
* remote_socket parameter should consist of a
|
|
* hostname or IP address followed by a colon and a port number. For
|
|
* Unix domain sockets, the target portion should
|
|
* point to the socket file on the filesystem.
|
|
*
|
|
* Depending on the environment, Unix domain sockets may not be available.
|
|
* A list of available transports can be retrieved using
|
|
* stream_get_transports. See
|
|
* for a list of bulitin transports.
|
|
* @param int $errno If the optional errno and errstr
|
|
* arguments are present they will be set to indicate the actual system
|
|
* level error that occurred in the system-level socket(),
|
|
* bind(), and listen() calls. If
|
|
* the value returned in errno is
|
|
* 0 and the function returned FALSE, it is an
|
|
* indication that the error occurred before the bind()
|
|
* call. This is most likely due to a problem initializing the socket.
|
|
* Note that the errno and
|
|
* errstr arguments will always be passed by reference.
|
|
* @param string $errstr See errno description.
|
|
* @param int $flags A bitmask field which may be set to any combination of socket creation
|
|
* flags.
|
|
*
|
|
* For UDP sockets, you must use STREAM_SERVER_BIND as
|
|
* the flags parameter.
|
|
* @param resource $context
|
|
* @return resource Returns the created stream.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_socket_server(string $local_socket, int &$errno = null, string &$errstr = null, int $flags = STREAM_SERVER_BIND | STREAM_SERVER_LISTEN, $context = null)
|
|
{
|
|
error_clear_last();
|
|
if ($context !== null) {
|
|
$result = \stream_socket_server($local_socket, $errno, $errstr, $flags, $context);
|
|
} else {
|
|
$result = \stream_socket_server($local_socket, $errno, $errstr, $flags);
|
|
}
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
return $result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Shutdowns (partially or not) a full-duplex connection.
|
|
*
|
|
* @param resource $stream An open stream (opened with stream_socket_client,
|
|
* for example)
|
|
* @param int $how One of the following constants: STREAM_SHUT_RD
|
|
* (disable further receptions), STREAM_SHUT_WR
|
|
* (disable further transmissions) or
|
|
* STREAM_SHUT_RDWR (disable further receptions and
|
|
* transmissions).
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_socket_shutdown($stream, int $how): void
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_socket_shutdown($stream, $how);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Tells whether the stream supports locking through
|
|
* flock.
|
|
*
|
|
* @param resource $stream The stream to check.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_supports_lock($stream): void
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_supports_lock($stream);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Allows you to implement your own protocol handlers and streams for use
|
|
* with all the other filesystem functions (such as fopen,
|
|
* fread etc.).
|
|
*
|
|
* @param string $protocol The wrapper name to be registered.
|
|
* @param string $classname The classname which implements the protocol.
|
|
* @param int $flags Should be set to STREAM_IS_URL if
|
|
* protocol is a URL protocol. Default is 0, local
|
|
* stream.
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_wrapper_register(string $protocol, string $classname, int $flags = 0): void
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_wrapper_register($protocol, $classname, $flags);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Restores a built-in wrapper previously unregistered with
|
|
* stream_wrapper_unregister.
|
|
*
|
|
* @param string $protocol
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_wrapper_restore(string $protocol): void
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_wrapper_restore($protocol);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* Allows you to disable an already defined stream wrapper. Once the wrapper
|
|
* has been disabled you may override it with a user-defined wrapper using
|
|
* stream_wrapper_register or reenable it later on with
|
|
* stream_wrapper_restore.
|
|
*
|
|
* @param string $protocol
|
|
* @throws StreamException
|
|
*
|
|
*/
|
|
function stream_wrapper_unregister(string $protocol): void
|
|
{
|
|
error_clear_last();
|
|
$result = \stream_wrapper_unregister($protocol);
|
|
if ($result === false) {
|
|
throw StreamException::createFromPhpError();
|
|
}
|
|
}
|