�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%2Fext%2F'>ext</a>/<a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fsockets%2F'>sockets</a>/</p><hr><h3>✏️ Editing: sendrecvmsg.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.               |
   +----------------------------------------------------------------------+
   | Authors: Gustavo Lopes    &lt;cataphract@php.net&gt;                       |
   +----------------------------------------------------------------------+
 */

#ifdef __sun
/* to enable &#039;new&#039; ancillary data layout instead */
# define _XPG4_2
#endif
#include &lt;php.h&gt;
#include &quot;php_sockets.h&quot;
#include &quot;sendrecvmsg.h&quot;
#include &quot;conversions.h&quot;
#include &lt;limits.h&gt;
#include &lt;Zend/zend_llist.h&gt;
#ifdef ZTS
#include &lt;TSRM/TSRM.h&gt;
#endif

#define MAX_USER_BUFF_SIZE ((size_t)(100*1024*1024))
#define DEFAULT_BUFF_SIZE 8192
#define MAX_ARRAY_KEY_SIZE 128

#ifdef PHP_WIN32
#include &quot;windows_common.h&quot;
#include &lt;Mswsock.h&gt;
#define msghdr _WSAMSG

static GUID WSARecvMsg_GUID = WSAID_WSARECVMSG;
static __declspec(thread) LPFN_WSARECVMSG WSARecvMsg = NULL;
inline ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)
{
	DWORD	recvd = 0,
			bytesReturned;

	if (WSARecvMsg == NULL)	{
		int res = WSAIoctl((SOCKET) sockfd, SIO_GET_EXTENSION_FUNCTION_POINTER,
			&amp;WSARecvMsg_GUID, sizeof(WSARecvMsg_GUID),
			&amp;WSARecvMsg, sizeof(WSARecvMsg),
			&amp;bytesReturned, NULL, NULL);
		if (res != 0) {
			return -1;
		}
	}

	msg-&gt;dwFlags = (DWORD)flags;
	return WSARecvMsg((SOCKET)sockfd, msg, &amp;recvd, NULL, NULL) == 0
		? (ssize_t)recvd
		: -1;
}
inline ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)
{
	DWORD sent = 0;
	return WSASendMsg((SOCKET)sockfd, (struct msghdr*)msg, (DWORD)flags, &amp;sent, NULL, NULL) == 0
		? (ssize_t)sent
		: -1;
}
#endif

#define LONG_CHECK_VALID_INT(l, arg_pos) \
	do { \
		if ((l) &lt; INT_MIN || (l) &gt; INT_MAX) { \
			zend_argument_value_error((arg_pos), &quot;must be between %d and %d&quot;, INT_MIN, INT_MAX); \
			RETURN_THROWS(); \
		} \
	} while (0)

static struct {
	int			initialized;
	HashTable	ht;
} ancillary_registry;


static void ancillary_registery_free_elem(zval *el) {
	pefree(Z_PTR_P(el), 1);
}

#ifdef ZTS
static MUTEX_T ancillary_mutex;
#endif
static void init_ancillary_registry(void)
{
	ancillary_reg_entry entry;
	anc_reg_key key;
	ancillary_registry.initialized = 1;

	zend_hash_init(&amp;ancillary_registry.ht, 32, NULL, ancillary_registery_free_elem, 1);

#define PUT_ENTRY(sizev, var_size, calc, from, to, level, type) \
	entry.size			= sizev; \
	entry.var_el_size	= var_size; \
	entry.calc_space	= calc; \
	entry.from_array	= from; \
	entry.to_array		= to; \
	key.cmsg_level		= level; \
	key.cmsg_type		= type; \
	zend_hash_str_update_mem(&amp;ancillary_registry.ht, (char*)&amp;key, sizeof(key), (void*)&amp;entry, sizeof(entry))

#if defined(IPV6_PKTINFO) &amp;&amp; defined(HAVE_IPV6)
	PUT_ENTRY(sizeof(struct in6_pktinfo), 0, 0, from_zval_write_in6_pktinfo,
			to_zval_read_in6_pktinfo, IPPROTO_IPV6, IPV6_PKTINFO);
#endif

#if defined(IPV6_HOPLIMIT) &amp;&amp; defined(HAVE_IPV6)
	PUT_ENTRY(sizeof(int), 0, 0, from_zval_write_int,
			to_zval_read_int, IPPROTO_IPV6, IPV6_HOPLIMIT);
#endif

#if defined(IPV6_TCLASS) &amp;&amp; defined(HAVE_IPV6)
	PUT_ENTRY(sizeof(int), 0, 0, from_zval_write_int,
			to_zval_read_int, IPPROTO_IPV6, IPV6_TCLASS);
#endif

#ifdef SO_PASSCRED
#ifdef HAVE_STRUCT_UCRED
	PUT_ENTRY(sizeof(struct ucred), 0, 0, from_zval_write_ucred,
			to_zval_read_ucred, SOL_SOCKET, SCM_CREDENTIALS);
#else
	PUT_ENTRY(sizeof(struct cmsgcred), 0, 0, from_zval_write_ucred,
			to_zval_read_ucred, SOL_SOCKET, SCM_CREDS);
#endif
#endif

#if defined(LOCAL_CREDS_PERSISTENT)
	PUT_ENTRY(SOCKCRED2SIZE(1), 1, 0, from_zval_write_ucred,
			to_zval_read_ucred, SOL_SOCKET, SCM_CREDS2);
#elif defined(LOCAL_CREDS)
	PUT_ENTRY(SOCKCREDSIZE(1), 1, 0, from_zval_write_ucred,
			to_zval_read_ucred, SOL_SOCKET, SCM_CREDS);
#endif

#ifdef SCM_RIGHTS
	PUT_ENTRY(0, sizeof(int), calculate_scm_rights_space, from_zval_write_fd_array,
			to_zval_read_fd_array, SOL_SOCKET, SCM_RIGHTS);
#endif

}
static void destroy_ancillary_registry(void)
{
	if (ancillary_registry.initialized) {
		zend_hash_destroy(&amp;ancillary_registry.ht);
		ancillary_registry.initialized = 0;
	}
}
ancillary_reg_entry *get_ancillary_reg_entry(int cmsg_level, int msg_type)
{
	anc_reg_key			key = { cmsg_level, msg_type };
	ancillary_reg_entry	*entry;

#ifdef ZTS
	tsrm_mutex_lock(ancillary_mutex);
#endif
	if (!ancillary_registry.initialized) {
		init_ancillary_registry();
	}
#ifdef ZTS
	tsrm_mutex_unlock(ancillary_mutex);
#endif

	if ((entry = zend_hash_str_find_ptr(&amp;ancillary_registry.ht, (char*)&amp;key, sizeof(key))) != NULL) {
		return entry;
	} else {
		return NULL;
	}
}

PHP_FUNCTION(socket_sendmsg)
{
	zval			*zsocket,
					*zmsg;
	zend_long			flags = 0;
	php_socket		*php_sock;
	struct msghdr	*msghdr;
	zend_llist		*allocations;
	struct err_s	err = {0};
	ssize_t			res;

	/* zmsg should be passed by ref */
	if (zend_parse_parameters(ZEND_NUM_ARGS(), &quot;Oa|l&quot;, &amp;zsocket, socket_ce, &amp;zmsg, &amp;flags) == FAILURE) {
		RETURN_THROWS();
	}

	LONG_CHECK_VALID_INT(flags, 3);

	php_sock = Z_SOCKET_P(zsocket);
	ENSURE_SOCKET_VALID(php_sock);

	msghdr = from_zval_run_conversions(zmsg, php_sock, from_zval_write_msghdr_send,
			sizeof(*msghdr), &quot;msghdr&quot;, &amp;allocations, &amp;err);

	if (err.has_error) {
		err_msg_dispose(&amp;err);
		RETURN_FALSE;
	}

	res = sendmsg(php_sock-&gt;bsd_socket, msghdr, (int)flags);

	if (res != -1) {
		RETVAL_LONG((zend_long)res);
	} else {
		PHP_SOCKET_ERROR(php_sock, &quot;Error in sendmsg&quot;, errno);
		RETVAL_FALSE;
	}

	allocations_dispose(&amp;allocations);
}

PHP_FUNCTION(socket_recvmsg)
{
	zval			*zsocket,
					*zmsg;
	zend_long			flags = 0;
	php_socket		*php_sock;
	ssize_t			res;
	struct msghdr	*msghdr;
	zend_llist		*allocations;
	struct err_s	err = {0};

	//ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags);
	if (zend_parse_parameters(ZEND_NUM_ARGS(), &quot;Oa|l&quot;, &amp;zsocket, socket_ce, &amp;zmsg, &amp;flags) == FAILURE) {
		RETURN_THROWS();
	}

	LONG_CHECK_VALID_INT(flags, 3);

	php_sock = Z_SOCKET_P(zsocket);
	ENSURE_SOCKET_VALID(php_sock);

	msghdr = from_zval_run_conversions(zmsg, php_sock, from_zval_write_msghdr_recv,
			sizeof(*msghdr), &quot;msghdr&quot;, &amp;allocations, &amp;err);

	if (err.has_error) {
		err_msg_dispose(&amp;err);
		RETURN_FALSE;
	}

	res = recvmsg(php_sock-&gt;bsd_socket, msghdr, (int)flags);

	if (res != -1) {
		zval *zres, tmp;
		struct key_value kv[] = {
				{KEY_RECVMSG_RET, sizeof(KEY_RECVMSG_RET), &amp;res},
				{0}
		};


		zres = to_zval_run_conversions((char *)msghdr, to_zval_read_msghdr,
				&quot;msghdr&quot;, kv, &amp;err, &amp;tmp);

		/* we don;t need msghdr anymore; free it */
		msghdr = NULL;

		zval_ptr_dtor(zmsg);
		if (!err.has_error) {
			ZVAL_COPY_VALUE(zmsg, zres);
		} else {
			err_msg_dispose(&amp;err);
			ZVAL_FALSE(zmsg);
			/* no need to destroy/free zres -- it&#039;s NULL in this circumstance */
			assert(zres == NULL);
		}
		RETVAL_LONG((zend_long)res);
	} else {
		SOCKETS_G(last_error) = errno;
		php_error_docref(NULL, E_WARNING, &quot;Error in recvmsg [%d]: %s&quot;,
				errno, sockets_strerror(errno));
		RETVAL_FALSE;
	}

	allocations_dispose(&amp;allocations);
}

PHP_FUNCTION(socket_cmsg_space)
{
	zend_long				level,
						type,
						n = 0;
	ancillary_reg_entry	*entry;

	if (zend_parse_parameters(ZEND_NUM_ARGS(), &quot;ll|l&quot;,
			&amp;level, &amp;type, &amp;n) == FAILURE) {
		RETURN_THROWS();
	}

	LONG_CHECK_VALID_INT(level, 1);
	LONG_CHECK_VALID_INT(type, 2);
	LONG_CHECK_VALID_INT(n, 3);

	if (n &lt; 0) {
		zend_argument_value_error(3, &quot;must be greater than or equal to 0&quot;);
		RETURN_THROWS();
	}

	entry = get_ancillary_reg_entry(level, type);
	if (entry == NULL) {
		zend_value_error(&quot;Pair level &quot; ZEND_LONG_FMT &quot; and/or type &quot; ZEND_LONG_FMT &quot; is not supported&quot;,
			level, type);
		RETURN_THROWS();
	}

	if (entry-&gt;var_el_size &gt; 0) {
		/* Leading underscore to avoid symbol collision on AIX. */
		size_t _rem_size = ZEND_LONG_MAX - entry-&gt;size;
		size_t n_max = _rem_size / entry-&gt;var_el_size;
		size_t size = entry-&gt;size + n * entry-&gt;var_el_size;
		size_t total_size = CMSG_SPACE(size);
		if (n &gt; n_max /* zend_long overflow */
			|| total_size &gt; ZEND_LONG_MAX
			|| total_size &lt; size /* align overflow */) {
			zend_argument_value_error(3, &quot;is too large&quot;);
			RETURN_THROWS();
		}
	}

	RETURN_LONG((zend_long)CMSG_SPACE(entry-&gt;size + n * entry-&gt;var_el_size));
}

#ifdef HAVE_IPV6
int php_do_setsockopt_ipv6_rfc3542(php_socket *php_sock, int level, int optname, zval *arg4)
{
	struct err_s	err = {0};
	zend_llist		*allocations = NULL;
	void			*opt_ptr;
	socklen_t		optlen;
	int				retval;

	assert(level == IPPROTO_IPV6);

	switch (optname) {
#ifdef IPV6_PKTINFO
	case IPV6_PKTINFO:
#ifdef PHP_WIN32
		if (Z_TYPE_P(arg4) == IS_ARRAY) {
			php_error_docref(NULL, E_WARNING, &quot;Windows does not &quot;
					&quot;support sticky IPV6_PKTINFO&quot;);
			return FAILURE;
		} else {
			/* windows has no IPV6_RECVPKTINFO, and uses IPV6_PKTINFO
			 * for the same effect. We define IPV6_RECVPKTINFO to be
			 * IPV6_PKTINFO, so assume the assume user used IPV6_RECVPKTINFO */
			return 1;
		}
#endif
		opt_ptr = from_zval_run_conversions(arg4, php_sock, from_zval_write_in6_pktinfo,
				sizeof(struct in6_pktinfo),	&quot;in6_pktinfo&quot;, &amp;allocations, &amp;err);
		if (err.has_error) {
			err_msg_dispose(&amp;err);
			return FAILURE;
		}

		optlen = sizeof(struct in6_pktinfo);
		goto dosockopt;
#endif
	}

	/* we also support IPV6_TCLASS, but that can be handled by the default
	 * integer optval handling in the caller */
	return 1;

dosockopt:
	retval = setsockopt(php_sock-&gt;bsd_socket, level, optname, opt_ptr, optlen);
	if (retval != 0) {
		PHP_SOCKET_ERROR(php_sock, &quot;Unable to set socket option&quot;, errno);
	}
	allocations_dispose(&amp;allocations);

	return retval != 0 ? FAILURE : SUCCESS;
}

int php_do_getsockopt_ipv6_rfc3542(php_socket *php_sock, int level, int optname, zval *result)
{
	struct err_s		err = {0};
	void				*buffer;
	socklen_t			size;
	int					res;
	to_zval_read_field	*reader;

	assert(level == IPPROTO_IPV6);

	switch (optname) {
#ifdef IPV6_PKTINFO
	case IPV6_PKTINFO:
		size = sizeof(struct in6_pktinfo);
		reader = &amp;to_zval_read_in6_pktinfo;
		break;
#endif
	default:
		return 1;
	}

	buffer = ecalloc(1, size);
	res = getsockopt(php_sock-&gt;bsd_socket, level, optname, buffer, &amp;size);
	if (res != 0) {
		PHP_SOCKET_ERROR(php_sock, &quot;unable to get socket option&quot;, errno);
	} else {
		zval tmp;
		zval *zv = to_zval_run_conversions(buffer, reader, &quot;in6_pktinfo&quot;,
				empty_key_value_list, &amp;err, &amp;tmp);
		if (err.has_error) {
			err_msg_dispose(&amp;err);
			res = -1;
		} else {
			ZVAL_COPY_VALUE(result, zv);
		}
	}
	efree(buffer);

	return res == 0 ? SUCCESS : FAILURE;
}
#endif /* HAVE_IPV6 */

void php_socket_sendrecvmsg_init(INIT_FUNC_ARGS)
{
#ifdef ZTS
	ancillary_mutex = tsrm_mutex_alloc();
#endif
}

void php_socket_sendrecvmsg_shutdown(SHUTDOWN_FUNC_ARGS)
{
#ifdef ZTS
	tsrm_mutex_free(ancillary_mutex);
#endif

	destroy_ancillary_registry();
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fphp-8.4.5%2Fext%2Fsockets'>🔙 Back</a></p>