�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2F'>php-8.4.5</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fmain%2F'>main</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fmain%2Fstreams%2F'>streams</a>/</p><hr><h3>✏️ Editing: xp_socket.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/*
  +----------------------------------------------------------------------+
  | 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 &lt;wez@thebrainroom.com&gt;                           |
  +----------------------------------------------------------------------+
*/

#include &quot;php.h&quot;
#include &quot;ext/standard/file.h&quot;
#include &quot;streams/php_streams_int.h&quot;
#include &quot;php_network.h&quot;

#if defined(PHP_WIN32) || defined(__riscos__)
# undef AF_UNIX
#endif

#ifdef AF_UNIX
#include &lt;sys/un.h&gt;
#endif

#ifndef MSG_DONTWAIT
# define MSG_DONTWAIT 0
#endif

#ifndef MSG_PEEK
# define MSG_PEEK 0
#endif

#ifdef PHP_WIN32
/* send/recv family on windows expects int */
# define XP_SOCK_BUF_SIZE(sz) (((sz) &gt; INT_MAX) ? INT_MAX : (int)(sz))
#else
# define XP_SOCK_BUF_SIZE(sz) (sz)
#endif

const php_stream_ops php_stream_generic_socket_ops;
PHPAPI const php_stream_ops php_stream_socket_ops;
static const php_stream_ops php_stream_udp_socket_ops;
#ifdef AF_UNIX
static const php_stream_ops php_stream_unix_socket_ops;
static const php_stream_ops php_stream_unixdg_socket_ops;
#endif


static int php_tcp_sockop_set_option(php_stream *stream, int option, int value, void *ptrparam);

/* {{{ Generic socket stream operations */
static ssize_t php_sockop_write(php_stream *stream, const char *buf, size_t count)
{
	php_netstream_data_t *sock = (php_netstream_data_t*)stream-&gt;abstract;
	ssize_t didwrite;
	struct timeval *ptimeout;

	if (!sock || sock-&gt;socket == -1) {
		return 0;
	}

	if (sock-&gt;timeout.tv_sec == -1)
		ptimeout = NULL;
	else
		ptimeout = &amp;sock-&gt;timeout;

retry:
	didwrite = send(sock-&gt;socket, buf, XP_SOCK_BUF_SIZE(count), (sock-&gt;is_blocked &amp;&amp; ptimeout) ? MSG_DONTWAIT : 0);

	if (didwrite &lt;= 0) {
		char *estr;
		int err = php_socket_errno();

		if (PHP_IS_TRANSIENT_ERROR(err)) {
			if (sock-&gt;is_blocked) {
				int retval;

				sock-&gt;timeout_event = 0;

				do {
					retval = php_pollfd_for(sock-&gt;socket, POLLOUT, ptimeout);

					if (retval == 0) {
						sock-&gt;timeout_event = 1;
						break;
					}

					if (retval &gt; 0) {
						/* writable now; retry */
						goto retry;
					}

					err = php_socket_errno();
				} while (err == EINTR);
			} else {
				/* EWOULDBLOCK/EAGAIN is not an error for a non-blocking stream.
				 * Report zero byte write instead. */
				return 0;
			}
		}

		if (!(stream-&gt;flags &amp; PHP_STREAM_FLAG_SUPPRESS_ERRORS)) {
			estr = php_socket_strerror(err, NULL, 0);
			php_error_docref(NULL, E_NOTICE,
				&quot;Send of &quot; ZEND_LONG_FMT &quot; bytes failed with errno=%d %s&quot;,
				(zend_long)count, err, estr);
			efree(estr);
		}
	}

	if (didwrite &gt; 0) {
		php_stream_notify_progress_increment(PHP_STREAM_CONTEXT(stream), didwrite, 0);
	}

	return didwrite;
}

static void php_sock_stream_wait_for_data(php_stream *stream, php_netstream_data_t *sock, bool has_buffered_data)
{
	int retval;
	struct timeval *ptimeout, zero_timeout;

	if (!sock || sock-&gt;socket == -1) {
		return;
	}

	sock-&gt;timeout_event = 0;

	if (has_buffered_data) {
		/* If there is already buffered data, use no timeout. */
		zero_timeout.tv_sec = 0;
		zero_timeout.tv_usec = 0;
		ptimeout = &amp;zero_timeout;
	} else if (sock-&gt;timeout.tv_sec == -1) {
		ptimeout = NULL;
	} else {
		ptimeout = &amp;sock-&gt;timeout;
	}

	while(1) {
		retval = php_pollfd_for(sock-&gt;socket, PHP_POLLREADABLE, ptimeout);

		if (retval == 0)
			sock-&gt;timeout_event = 1;

		if (retval &gt;= 0)
			break;

		if (php_socket_errno() != EINTR)
			break;
	}
}

static ssize_t php_sockop_read(php_stream *stream, char *buf, size_t count)
{
	php_netstream_data_t *sock = (php_netstream_data_t*)stream-&gt;abstract;

	if (!sock || sock-&gt;socket == -1) {
		return -1;
	}

	int recv_flags = 0;
	/* Special handling for blocking read. */
	if (sock-&gt;is_blocked) {
		/* Find out if there is any data buffered from the previous read. */
		bool has_buffered_data = stream-&gt;has_buffered_data;
		/* No need to wait if there is any data buffered or no timeout. */
		bool dont_wait = has_buffered_data ||
				(sock-&gt;timeout.tv_sec == 0 &amp;&amp; sock-&gt;timeout.tv_usec == 0);
		/* Set MSG_DONTWAIT if no wait is needed or there is unlimited timeout which was
		 * added by fix for #41984 committed in 9343c5404. */
		if (dont_wait || sock-&gt;timeout.tv_sec != -1) {
			recv_flags = MSG_DONTWAIT;
		}
		/* If the wait is needed or it is a platform without MSG_DONTWAIT support (e.g. Windows),
		 * then poll for data. */
		if (!dont_wait || MSG_DONTWAIT == 0) {
			php_sock_stream_wait_for_data(stream, sock, has_buffered_data);
			if (sock-&gt;timeout_event) {
				/* It is ok to timeout if there is any data buffered so return 0, otherwise -1. */
				return has_buffered_data ? 0 : -1;
			}
		}
	}

	ssize_t nr_bytes = recv(sock-&gt;socket, buf, XP_SOCK_BUF_SIZE(count), recv_flags);
	int err = php_socket_errno();

	if (nr_bytes &lt; 0) {
		if (PHP_IS_TRANSIENT_ERROR(err)) {
			nr_bytes = 0;
		} else {
			stream-&gt;eof = 1;
		}
	} else if (nr_bytes == 0) {
		stream-&gt;eof = 1;
	}

	if (nr_bytes &gt; 0) {
		php_stream_notify_progress_increment(PHP_STREAM_CONTEXT(stream), nr_bytes, 0);
	}

	return nr_bytes;
}


static int php_sockop_close(php_stream *stream, int close_handle)
{
	php_netstream_data_t *sock = (php_netstream_data_t*)stream-&gt;abstract;
#ifdef PHP_WIN32
	int n;
#endif

	if (!sock) {
		return 0;
	}

	if (close_handle) {

#ifdef PHP_WIN32
		if (sock-&gt;socket == -1)
			sock-&gt;socket = SOCK_ERR;
#endif
		if (sock-&gt;socket != SOCK_ERR) {
#ifdef PHP_WIN32
			/* prevent more data from coming in */
			shutdown(sock-&gt;socket, SHUT_RD);

			/* try to make sure that the OS sends all data before we close the connection.
			 * Essentially, we are waiting for the socket to become writeable, which means
			 * that all pending data has been sent.
			 * We use a small timeout which should encourage the OS to send the data,
			 * but at the same time avoid hanging indefinitely.
			 * */
			do {
				n = php_pollfd_for_ms(sock-&gt;socket, POLLOUT, 500);
			} while (n == -1 &amp;&amp; php_socket_errno() == EINTR);
#endif
			closesocket(sock-&gt;socket);
			sock-&gt;socket = SOCK_ERR;
		}

	}

	pefree(sock, php_stream_is_persistent(stream));

	return 0;
}

static int php_sockop_flush(php_stream *stream)
{
#if 0
	php_netstream_data_t *sock = (php_netstream_data_t*)stream-&gt;abstract;
	return fsync(sock-&gt;socket);
#endif
	return 0;
}

static int php_sockop_stat(php_stream *stream, php_stream_statbuf *ssb)
{
#ifdef ZEND_WIN32
	return 0;
#else
	php_netstream_data_t *sock = (php_netstream_data_t*)stream-&gt;abstract;

	return zend_fstat(sock-&gt;socket, &amp;ssb-&gt;sb);
#endif
}

static inline int sock_sendto(php_netstream_data_t *sock, const char *buf, size_t buflen, int flags,
		struct sockaddr *addr, socklen_t addrlen
		)
{
	int ret;
	if (addr) {
		ret = sendto(sock-&gt;socket, buf, XP_SOCK_BUF_SIZE(buflen), flags, addr, XP_SOCK_BUF_SIZE(addrlen));

		return (ret == SOCK_CONN_ERR) ? -1 : ret;
	}
#ifdef PHP_WIN32
	return ((ret = send(sock-&gt;socket, buf, buflen &gt; INT_MAX ? INT_MAX : (int)buflen, flags)) == SOCK_CONN_ERR) ? -1 : ret;
#else
	return ((ret = send(sock-&gt;socket, buf, buflen, flags)) == SOCK_CONN_ERR) ? -1 : ret;
#endif
}

static inline int sock_recvfrom(php_netstream_data_t *sock, char *buf, size_t buflen, int flags,
		zend_string **textaddr,
		struct sockaddr **addr, socklen_t *addrlen
		)
{
	int ret;
	int want_addr = textaddr || addr;

	if (want_addr) {
		php_sockaddr_storage sa;
		socklen_t sl = sizeof(sa);
		ret = recvfrom(sock-&gt;socket, buf, XP_SOCK_BUF_SIZE(buflen), flags, (struct sockaddr*)&amp;sa, &amp;sl);
		ret = (ret == SOCK_CONN_ERR) ? -1 : ret;
#ifdef PHP_WIN32
		/* POSIX discards excess bytes without signalling failure; emulate this on Windows */
		if (ret == -1 &amp;&amp; WSAGetLastError() == WSAEMSGSIZE) {
			ret = buflen;
		}
#endif
		if (sl) {
			php_network_populate_name_from_sockaddr((struct sockaddr*)&amp;sa, sl,
					textaddr, addr, addrlen);
		} else {
			if (textaddr) {
				*textaddr = ZSTR_EMPTY_ALLOC();
			}
			if (addr) {
				*addr = NULL;
				*addrlen = 0;
			}
		}
	} else {
		ret = recv(sock-&gt;socket, buf, XP_SOCK_BUF_SIZE(buflen), flags);
		ret = (ret == SOCK_CONN_ERR) ? -1 : ret;
	}

	return ret;
}

static int php_sockop_set_option(php_stream *stream, int option, int value, void *ptrparam)
{
	int oldmode, flags;
	php_netstream_data_t *sock = (php_netstream_data_t*)stream-&gt;abstract;
	php_stream_xport_param *xparam;

	if (!sock) {
		return PHP_STREAM_OPTION_RETURN_NOTIMPL;
	}

	switch(option) {
		case PHP_STREAM_OPTION_CHECK_LIVENESS:
			{
				struct timeval tv;
				char buf;
				int alive = 1;

				if (value == -1) {
					if (sock-&gt;timeout.tv_sec == -1) {
						tv.tv_sec = FG(default_socket_timeout);
						tv.tv_usec = 0;
					} else {
						tv = sock-&gt;timeout;
					}
				} else {
					tv.tv_sec = value;
					tv.tv_usec = 0;
				}

				if (sock-&gt;socket == -1) {
					alive = 0;
				} else if (
					(
						value == 0 &amp;&amp;
						!(stream-&gt;flags &amp; PHP_STREAM_FLAG_NO_IO) &amp;&amp;
						((MSG_DONTWAIT != 0) || !sock-&gt;is_blocked)
					) ||
					php_pollfd_for(sock-&gt;socket, PHP_POLLREADABLE|POLLPRI, &amp;tv) &gt; 0
				) {
					/* the poll() call was skipped if the socket is non-blocking (or MSG_DONTWAIT is available) and if the timeout is zero */
#ifdef PHP_WIN32
					int ret;
#else
					ssize_t ret;
#endif

					ret = recv(sock-&gt;socket, &amp;buf, sizeof(buf), MSG_PEEK|MSG_DONTWAIT);
					if (0 == ret) {
						/* the counterpart did properly shutdown */
						alive = 0;
					} else if (0 &gt; ret) {
						int err = php_socket_errno();
						if (err != EWOULDBLOCK &amp;&amp; err != EMSGSIZE &amp;&amp; err != EAGAIN) {
							/* there was an unrecoverable error */
							alive = 0;
						}
					}
				}
				return alive ? PHP_STREAM_OPTION_RETURN_OK : PHP_STREAM_OPTION_RETURN_ERR;
			}

		case PHP_STREAM_OPTION_BLOCKING:
			oldmode = sock-&gt;is_blocked;
			if (SUCCESS == php_set_sock_blocking(sock-&gt;socket, value)) {
				sock-&gt;is_blocked = value;
				return oldmode;
			}
			return PHP_STREAM_OPTION_RETURN_ERR;

		case PHP_STREAM_OPTION_READ_TIMEOUT:
			sock-&gt;timeout = *(struct timeval*)ptrparam;
			sock-&gt;timeout_event = 0;
			return PHP_STREAM_OPTION_RETURN_OK;

		case PHP_STREAM_OPTION_META_DATA_API:
			add_assoc_bool((zval *)ptrparam, &quot;timed_out&quot;, sock-&gt;timeout_event);
			add_assoc_bool((zval *)ptrparam, &quot;blocked&quot;, sock-&gt;is_blocked);
			add_assoc_bool((zval *)ptrparam, &quot;eof&quot;, stream-&gt;eof);
			return PHP_STREAM_OPTION_RETURN_OK;

		case PHP_STREAM_OPTION_XPORT_API:
			xparam = (php_stream_xport_param *)ptrparam;

			switch (xparam-&gt;op) {
				case STREAM_XPORT_OP_LISTEN:
					xparam-&gt;outputs.returncode = (listen(sock-&gt;socket, xparam-&gt;inputs.backlog) == 0) ?  0: -1;
					return PHP_STREAM_OPTION_RETURN_OK;

				case STREAM_XPORT_OP_GET_NAME:
					xparam-&gt;outputs.returncode = php_network_get_sock_name(sock-&gt;socket,
							xparam-&gt;want_textaddr ? &amp;xparam-&gt;outputs.textaddr : NULL,
							xparam-&gt;want_addr ? &amp;xparam-&gt;outputs.addr : NULL,
							xparam-&gt;want_addr ? &amp;xparam-&gt;outputs.addrlen : NULL
							);
					return PHP_STREAM_OPTION_RETURN_OK;

				case STREAM_XPORT_OP_GET_PEER_NAME:
					xparam-&gt;outputs.returncode = php_network_get_peer_name(sock-&gt;socket,
							xparam-&gt;want_textaddr ? &amp;xparam-&gt;outputs.textaddr : NULL,
							xparam-&gt;want_addr ? &amp;xparam-&gt;outputs.addr : NULL,
							xparam-&gt;want_addr ? &amp;xparam-&gt;outputs.addrlen : NULL
							);
					return PHP_STREAM_OPTION_RETURN_OK;

				case STREAM_XPORT_OP_SEND:
					flags = 0;
					if ((xparam-&gt;inputs.flags &amp; STREAM_OOB) == STREAM_OOB) {
						flags |= MSG_OOB;
					}
					xparam-&gt;outputs.returncode = sock_sendto(sock,
							xparam-&gt;inputs.buf, xparam-&gt;inputs.buflen,
							flags,
							xparam-&gt;inputs.addr,
							xparam-&gt;inputs.addrlen);
					if (xparam-&gt;outputs.returncode == -1) {
						char *err = php_socket_strerror(php_socket_errno(), NULL, 0);
						php_error_docref(NULL, E_WARNING,
						   	&quot;%s\n&quot;, err);
						efree(err);
					}
					return PHP_STREAM_OPTION_RETURN_OK;

				case STREAM_XPORT_OP_RECV:
					flags = 0;
					if ((xparam-&gt;inputs.flags &amp; STREAM_OOB) == STREAM_OOB) {
						flags |= MSG_OOB;
					}
					if ((xparam-&gt;inputs.flags &amp; STREAM_PEEK) == STREAM_PEEK) {
						flags |= MSG_PEEK;
					}
					xparam-&gt;outputs.returncode = sock_recvfrom(sock,
							xparam-&gt;inputs.buf, xparam-&gt;inputs.buflen,
							flags,
							xparam-&gt;want_textaddr ? &amp;xparam-&gt;outputs.textaddr : NULL,
							xparam-&gt;want_addr ? &amp;xparam-&gt;outputs.addr : NULL,
							xparam-&gt;want_addr ? &amp;xparam-&gt;outputs.addrlen : NULL
							);
					return PHP_STREAM_OPTION_RETURN_OK;


#ifdef HAVE_SHUTDOWN
# ifndef SHUT_RD
#  define SHUT_RD 0
# endif
# ifndef SHUT_WR
#  define SHUT_WR 1
# endif
# ifndef SHUT_RDWR
#  define SHUT_RDWR 2
# endif
				case STREAM_XPORT_OP_SHUTDOWN: {
					static const int shutdown_how[] = {SHUT_RD, SHUT_WR, SHUT_RDWR};

					xparam-&gt;outputs.returncode = shutdown(sock-&gt;socket, shutdown_how[xparam-&gt;how]);
					return PHP_STREAM_OPTION_RETURN_OK;
				}
#endif

				default:
					break;
			}
	}

	return PHP_STREAM_OPTION_RETURN_NOTIMPL;
}

static int php_sockop_cast(php_stream *stream, int castas, void **ret)
{
	php_netstream_data_t *sock = (php_netstream_data_t*)stream-&gt;abstract;

	if (!sock) {
		return FAILURE;
	}

	switch(castas)	{
		case PHP_STREAM_AS_STDIO:
			if (ret)	{
				*(FILE**)ret = fdopen(sock-&gt;socket, stream-&gt;mode);
				if (*ret)
					return SUCCESS;
				return FAILURE;
			}
			return SUCCESS;
		case PHP_STREAM_AS_FD_FOR_SELECT:
		case PHP_STREAM_AS_FD:
		case PHP_STREAM_AS_SOCKETD:
			if (ret)
				*(php_socket_t *)ret = sock-&gt;socket;
			return SUCCESS;
		default:
			return FAILURE;
	}
}
/* }}} */

/* These may look identical, but we need them this way so that
 * we can determine which type of socket we are dealing with
 * by inspecting stream-&gt;ops.
 * A &quot;useful&quot; side-effect is that the user&#039;s scripts can then
 * make similar decisions using stream_get_meta_data.
 * */
const php_stream_ops php_stream_generic_socket_ops = {
	php_sockop_write, php_sockop_read,
	php_sockop_close, php_sockop_flush,
	&quot;generic_socket&quot;,
	NULL, /* seek */
	php_sockop_cast,
	php_sockop_stat,
	php_sockop_set_option,
};


const php_stream_ops php_stream_socket_ops = {
	php_sockop_write, php_sockop_read,
	php_sockop_close, php_sockop_flush,
	&quot;tcp_socket&quot;,
	NULL, /* seek */
	php_sockop_cast,
	php_sockop_stat,
	php_tcp_sockop_set_option,
};

static const php_stream_ops php_stream_udp_socket_ops = {
	php_sockop_write, php_sockop_read,
	php_sockop_close, php_sockop_flush,
	&quot;udp_socket&quot;,
	NULL, /* seek */
	php_sockop_cast,
	php_sockop_stat,
	php_tcp_sockop_set_option,
};

#ifdef AF_UNIX
static const php_stream_ops php_stream_unix_socket_ops = {
	php_sockop_write, php_sockop_read,
	php_sockop_close, php_sockop_flush,
	&quot;unix_socket&quot;,
	NULL, /* seek */
	php_sockop_cast,
	php_sockop_stat,
	php_tcp_sockop_set_option,
};
static const php_stream_ops php_stream_unixdg_socket_ops = {
	php_sockop_write, php_sockop_read,
	php_sockop_close, php_sockop_flush,
	&quot;udg_socket&quot;,
	NULL, /* seek */
	php_sockop_cast,
	php_sockop_stat,
	php_tcp_sockop_set_option,
};
#endif


/* network socket operations */

#ifdef AF_UNIX
static inline int parse_unix_address(php_stream_xport_param *xparam, struct sockaddr_un *unix_addr)
{
	memset(unix_addr, 0, sizeof(*unix_addr));
	unix_addr-&gt;sun_family = AF_UNIX;

	/* Abstract namespace does not need to be NUL-terminated, while path-based
	 * sockets should be. */
	bool is_abstract_ns = xparam-&gt;inputs.namelen &gt; 0 &amp;&amp; xparam-&gt;inputs.name[0] == &#039;\0&#039;;
	unsigned long max_length = is_abstract_ns ? sizeof(unix_addr-&gt;sun_path) : sizeof(unix_addr-&gt;sun_path) - 1;

	/* we need to be binary safe on systems that support an abstract
	 * namespace */
	if (xparam-&gt;inputs.namelen &gt; max_length) {
		/* On linux, when the path begins with a NUL byte we are
		 * referring to an abstract namespace.  In theory we should
		 * allow an extra byte below, since we don&#039;t need the NULL.
		 * BUT, to get into this branch of code, the name is too long,
		 * so we don&#039;t care. */
		xparam-&gt;inputs.namelen = max_length;
		php_error_docref(NULL, E_NOTICE,
			&quot;socket path exceeded the maximum allowed length of %lu bytes &quot;
			&quot;and was truncated&quot;, max_length);
	}

	memcpy(unix_addr-&gt;sun_path, xparam-&gt;inputs.name, xparam-&gt;inputs.namelen);

	return 1;
}
#endif

static inline char *parse_ip_address_ex(const char *str, size_t str_len, int *portno, int get_err, zend_string **err)
{
	char *colon;
	char *host = NULL;

#ifdef HAVE_IPV6
	char *p;

	if (*(str) == &#039;[&#039; &amp;&amp; str_len &gt; 1) {
		/* IPV6 notation to specify raw address with port (i.e. [fe80::1]:80) */
		p = memchr(str + 1, &#039;]&#039;, str_len - 2);
		if (!p || *(p + 1) != &#039;:&#039;) {
			if (get_err) {
				*err = strpprintf(0, &quot;Failed to parse IPv6 address \&quot;%s\&quot;&quot;, str);
			}
			return NULL;
		}
		*portno = atoi(p + 2);
		return estrndup(str + 1, p - str - 1);
	}
#endif
	if (str_len) {
		colon = memchr(str, &#039;:&#039;, str_len - 1);
	} else {
		colon = NULL;
	}
	if (colon) {
		*portno = atoi(colon + 1);
		host = estrndup(str, colon - str);
	} else {
		if (get_err) {
			*err = strpprintf(0, &quot;Failed to parse address \&quot;%s\&quot;&quot;, str);
		}
		return NULL;
	}

	return host;
}

static inline char *parse_ip_address(php_stream_xport_param *xparam, int *portno)
{
	return parse_ip_address_ex(xparam-&gt;inputs.name, xparam-&gt;inputs.namelen, portno, xparam-&gt;want_errortext, &amp;xparam-&gt;outputs.error_text);
}

static inline int php_tcp_sockop_bind(php_stream *stream, php_netstream_data_t *sock,
		php_stream_xport_param *xparam)
{
	char *host = NULL;
	int portno, err;
	long sockopts = STREAM_SOCKOP_NONE;
	zval *tmpzval = NULL;

#ifdef AF_UNIX
	if (stream-&gt;ops == &amp;php_stream_unix_socket_ops || stream-&gt;ops == &amp;php_stream_unixdg_socket_ops) {
		struct sockaddr_un unix_addr;

		sock-&gt;socket = socket(PF_UNIX, stream-&gt;ops == &amp;php_stream_unix_socket_ops ? SOCK_STREAM : SOCK_DGRAM, 0);

		if (sock-&gt;socket == SOCK_ERR) {
			if (xparam-&gt;want_errortext) {
				xparam-&gt;outputs.error_text = strpprintf(0, &quot;Failed to create unix%s socket %s&quot;,
						stream-&gt;ops == &amp;php_stream_unix_socket_ops ? &quot;&quot; : &quot;datagram&quot;,
						strerror(errno));
			}
			return -1;
		}

		parse_unix_address(xparam, &amp;unix_addr);

		return bind(sock-&gt;socket, (const struct sockaddr *)&amp;unix_addr,
			(socklen_t) XtOffsetOf(struct sockaddr_un, sun_path) + xparam-&gt;inputs.namelen);
	}
#endif

	host = parse_ip_address(xparam, &amp;portno);

	if (host == NULL) {
		return -1;
	}

#ifdef IPV6_V6ONLY
	if (PHP_STREAM_CONTEXT(stream)
		&amp;&amp; (tmpzval = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream), &quot;socket&quot;, &quot;ipv6_v6only&quot;)) != NULL
		&amp;&amp; Z_TYPE_P(tmpzval) != IS_NULL
	) {
		sockopts |= STREAM_SOCKOP_IPV6_V6ONLY;
		sockopts |= STREAM_SOCKOP_IPV6_V6ONLY_ENABLED * zend_is_true(tmpzval);
	}
#endif

#ifdef SO_REUSEPORT
	if (PHP_STREAM_CONTEXT(stream)
		&amp;&amp; (tmpzval = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream), &quot;socket&quot;, &quot;so_reuseport&quot;)) != NULL
		&amp;&amp; zend_is_true(tmpzval)
	) {
		sockopts |= STREAM_SOCKOP_SO_REUSEPORT;
	}
#endif

#ifdef SO_BROADCAST
	if (stream-&gt;ops == &amp;php_stream_udp_socket_ops /* SO_BROADCAST is only applicable for UDP */
		&amp;&amp; PHP_STREAM_CONTEXT(stream)
		&amp;&amp; (tmpzval = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream), &quot;socket&quot;, &quot;so_broadcast&quot;)) != NULL
		&amp;&amp; zend_is_true(tmpzval)
	) {
		sockopts |= STREAM_SOCKOP_SO_BROADCAST;
	}
#endif

	sock-&gt;socket = php_network_bind_socket_to_local_addr(host, portno,
			stream-&gt;ops == &amp;php_stream_udp_socket_ops ? SOCK_DGRAM : SOCK_STREAM,
			sockopts,
			xparam-&gt;want_errortext ? &amp;xparam-&gt;outputs.error_text : NULL,
			&amp;err
			);

	if (host) {
		efree(host);
	}

	return sock-&gt;socket == -1 ? -1 : 0;
}

static inline int php_tcp_sockop_connect(php_stream *stream, php_netstream_data_t *sock,
		php_stream_xport_param *xparam)
{
	char *host = NULL, *bindto = NULL;
	int portno, bindport = 0;
	int err = 0;
	int ret;
	zval *tmpzval = NULL;
	long sockopts = STREAM_SOCKOP_NONE;

#ifdef AF_UNIX
	if (stream-&gt;ops == &amp;php_stream_unix_socket_ops || stream-&gt;ops == &amp;php_stream_unixdg_socket_ops) {
		struct sockaddr_un unix_addr;

		sock-&gt;socket = socket(PF_UNIX, stream-&gt;ops == &amp;php_stream_unix_socket_ops ? SOCK_STREAM : SOCK_DGRAM, 0);

		if (sock-&gt;socket == SOCK_ERR) {
			if (xparam-&gt;want_errortext) {
				xparam-&gt;outputs.error_text = strpprintf(0, &quot;Failed to create unix socket&quot;);
			}
			return -1;
		}

		parse_unix_address(xparam, &amp;unix_addr);

		ret = php_network_connect_socket(sock-&gt;socket,
				(const struct sockaddr *)&amp;unix_addr, (socklen_t) XtOffsetOf(struct sockaddr_un, sun_path) + xparam-&gt;inputs.namelen,
				xparam-&gt;op == STREAM_XPORT_OP_CONNECT_ASYNC, xparam-&gt;inputs.timeout,
				xparam-&gt;want_errortext ? &amp;xparam-&gt;outputs.error_text : NULL,
				&amp;err);

		xparam-&gt;outputs.error_code = err;

		goto out;
	}
#endif

	host = parse_ip_address(xparam, &amp;portno);

	if (host == NULL) {
		return -1;
	}

	if (PHP_STREAM_CONTEXT(stream) &amp;&amp; (tmpzval = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream), &quot;socket&quot;, &quot;bindto&quot;)) != NULL) {
		if (Z_TYPE_P(tmpzval) != IS_STRING) {
			if (xparam-&gt;want_errortext) {
				xparam-&gt;outputs.error_text = strpprintf(0, &quot;local_addr context option is not a string.&quot;);
			}
			efree(host);
			return -1;
		}
		bindto = parse_ip_address_ex(Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval), &amp;bindport, xparam-&gt;want_errortext, &amp;xparam-&gt;outputs.error_text);
	}

#ifdef SO_BROADCAST
	if (stream-&gt;ops == &amp;php_stream_udp_socket_ops /* SO_BROADCAST is only applicable for UDP */
		&amp;&amp; PHP_STREAM_CONTEXT(stream)
		&amp;&amp; (tmpzval = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream), &quot;socket&quot;, &quot;so_broadcast&quot;)) != NULL
		&amp;&amp; zend_is_true(tmpzval)
	) {
		sockopts |= STREAM_SOCKOP_SO_BROADCAST;
	}
#endif

	if (stream-&gt;ops != &amp;php_stream_udp_socket_ops /* TCP_NODELAY is only applicable for TCP */
#ifdef AF_UNIX
		&amp;&amp; stream-&gt;ops != &amp;php_stream_unix_socket_ops
		&amp;&amp; stream-&gt;ops != &amp;php_stream_unixdg_socket_ops
#endif
		&amp;&amp; PHP_STREAM_CONTEXT(stream)
		&amp;&amp; (tmpzval = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream), &quot;socket&quot;, &quot;tcp_nodelay&quot;)) != NULL
		&amp;&amp; zend_is_true(tmpzval)
	) {
		sockopts |= STREAM_SOCKOP_TCP_NODELAY;
	}

	/* Note: the test here for php_stream_udp_socket_ops is important, because we
	 * want the default to be TCP sockets so that the openssl extension can
	 * re-use this code. */

	sock-&gt;socket = php_network_connect_socket_to_host(host, portno,
			stream-&gt;ops == &amp;php_stream_udp_socket_ops ? SOCK_DGRAM : SOCK_STREAM,
			xparam-&gt;op == STREAM_XPORT_OP_CONNECT_ASYNC,
			xparam-&gt;inputs.timeout,
			xparam-&gt;want_errortext ? &amp;xparam-&gt;outputs.error_text : NULL,
			&amp;err,
			bindto,
			bindport,
			sockopts
			);

	ret = sock-&gt;socket == -1 ? -1 : 0;
	xparam-&gt;outputs.error_code = err;

	if (host) {
		efree(host);
	}
	if (bindto) {
		efree(bindto);
	}

#ifdef AF_UNIX
out:
#endif

	if (ret &gt;= 0 &amp;&amp; xparam-&gt;op == STREAM_XPORT_OP_CONNECT_ASYNC &amp;&amp; err == EINPROGRESS) {
		/* indicates pending connection */
		return 1;
	}

	return ret;
}

static inline int php_tcp_sockop_accept(php_stream *stream, php_netstream_data_t *sock,
		php_stream_xport_param *xparam STREAMS_DC)
{
	int clisock;
	bool nodelay = 0;
	zval *tmpzval = NULL;

	xparam-&gt;outputs.client = NULL;

	if ((NULL != PHP_STREAM_CONTEXT(stream)) &amp;&amp;
		(tmpzval = php_stream_context_get_option(PHP_STREAM_CONTEXT(stream), &quot;socket&quot;, &quot;tcp_nodelay&quot;)) != NULL &amp;&amp;
		zend_is_true(tmpzval)) {
		nodelay = 1;
	}

	clisock = php_network_accept_incoming(sock-&gt;socket,
		xparam-&gt;want_textaddr ? &amp;xparam-&gt;outputs.textaddr : NULL,
		xparam-&gt;want_addr ? &amp;xparam-&gt;outputs.addr : NULL,
		xparam-&gt;want_addr ? &amp;xparam-&gt;outputs.addrlen : NULL,
		xparam-&gt;inputs.timeout,
		xparam-&gt;want_errortext ? &amp;xparam-&gt;outputs.error_text : NULL,
		&amp;xparam-&gt;outputs.error_code,
		nodelay);

	if (clisock &gt;= 0) {
		php_netstream_data_t *clisockdata = (php_netstream_data_t*) emalloc(sizeof(*clisockdata));

		memcpy(clisockdata, sock, sizeof(*clisockdata));
		clisockdata-&gt;socket = clisock;
#ifdef __linux__
		/* O_NONBLOCK is not inherited on Linux */
		clisockdata-&gt;is_blocked = 1;
#endif

		xparam-&gt;outputs.client = php_stream_alloc_rel(stream-&gt;ops, clisockdata, NULL, &quot;r+&quot;);
		if (xparam-&gt;outputs.client) {
			xparam-&gt;outputs.client-&gt;ctx = stream-&gt;ctx;
			if (stream-&gt;ctx) {
				GC_ADDREF(stream-&gt;ctx);
			}
		}
	}

	return xparam-&gt;outputs.client == NULL ? -1 : 0;
}

static int php_tcp_sockop_set_option(php_stream *stream, int option, int value, void *ptrparam)
{
	php_netstream_data_t *sock = (php_netstream_data_t*)stream-&gt;abstract;
	php_stream_xport_param *xparam;

	switch(option) {
		case PHP_STREAM_OPTION_XPORT_API:
			xparam = (php_stream_xport_param *)ptrparam;

			switch(xparam-&gt;op) {
				case STREAM_XPORT_OP_CONNECT:
				case STREAM_XPORT_OP_CONNECT_ASYNC:
					xparam-&gt;outputs.returncode = php_tcp_sockop_connect(stream, sock, xparam);
					return PHP_STREAM_OPTION_RETURN_OK;

				case STREAM_XPORT_OP_BIND:
					xparam-&gt;outputs.returncode = php_tcp_sockop_bind(stream, sock, xparam);
					return PHP_STREAM_OPTION_RETURN_OK;


				case STREAM_XPORT_OP_ACCEPT:
					xparam-&gt;outputs.returncode = php_tcp_sockop_accept(stream, sock, xparam STREAMS_CC);
					return PHP_STREAM_OPTION_RETURN_OK;
				default:
					/* fall through */
					;
			}
	}
	return php_sockop_set_option(stream, option, value, ptrparam);
}


PHPAPI php_stream *php_stream_generic_socket_factory(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)
{
	php_stream *stream = NULL;
	php_netstream_data_t *sock;
	const php_stream_ops *ops;

	/* which type of socket ? */
	if (strncmp(proto, &quot;tcp&quot;, protolen) == 0) {
		ops = &amp;php_stream_socket_ops;
	} else if (strncmp(proto, &quot;udp&quot;, protolen) == 0) {
		ops = &amp;php_stream_udp_socket_ops;
	}
#ifdef AF_UNIX
	else if (strncmp(proto, &quot;unix&quot;, protolen) == 0) {
		ops = &amp;php_stream_unix_socket_ops;
	} else if (strncmp(proto, &quot;udg&quot;, protolen) == 0) {
		ops = &amp;php_stream_unixdg_socket_ops;
	}
#endif
	else {
		/* should never happen */
		return NULL;
	}

	sock = pemalloc(sizeof(php_netstream_data_t), persistent_id ? 1 : 0);
	memset(sock, 0, sizeof(php_netstream_data_t));

	sock-&gt;is_blocked = 1;
	sock-&gt;timeout.tv_sec = FG(default_socket_timeout);
	sock-&gt;timeout.tv_usec = 0;

	/* we don&#039;t know the socket until we have determined if we are binding or
	 * connecting */
	sock-&gt;socket = -1;

	stream = php_stream_alloc_rel(ops, sock, persistent_id, &quot;r+&quot;);

	if (stream == NULL)	{
		pefree(sock, persistent_id ? 1 : 0);
		return NULL;
	}

	return stream;
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fmain%2Fstreams'>🔙 Back</a></p>