php_network.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: Stig Venaas <venaas@uninett.no> |
 +----------------------------------------------------------------------+
 */

#ifndef_PHP_NETWORK_H
#define_PHP_NETWORK_H

#include<php.h>

#ifndefPHP_WIN32
# undef closesocket
# defineclosesocket close
# include<netinet/tcp.h>
#endif

#ifndefHAVE_SHUTDOWN
#undef shutdown
#defineshutdown(s,n) /* nothing */
#endif

#ifdefPHP_WIN32
# ifdefEWOULDBLOCK
# undef EWOULDBLOCK
# endif
# ifdefEINPROGRESS
# undef EINPROGRESS
# endif
# defineEWOULDBLOCK WSAEWOULDBLOCK
# defineEINPROGRESS WSAEWOULDBLOCK
# definefsync _commit
# defineftruncate(a, b) chsize(a, b)
#endif/* defined(PHP_WIN32) */

#ifndefEWOULDBLOCK
# defineEWOULDBLOCK EAGAIN
#endif

/* This is a workaround for GCC bug 69602: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=69602 */
#ifEAGAIN!=EWOULDBLOCK
# definePHP_IS_TRANSIENT_ERROR(err) (err == EAGAIN || err == EWOULDBLOCK)
#else
# definePHP_IS_TRANSIENT_ERROR(err) (err == EAGAIN)
#endif

#ifdefPHP_WIN32
#definephp_socket_errno() WSAGetLastError()
#else
#definephp_socket_errno() errno
#endif

/* like strerror, but caller must efree the returned string,
 * unless buf is not NULL.
 * Also works sensibly for win32 */
BEGIN_EXTERN_C()
PHPAPIchar*php_socket_strerror(longerr, char*buf, size_tbufsize);
PHPAPIzend_string*php_socket_error_str(longerr);
END_EXTERN_C()

#ifdefHAVE_NETINET_IN_H
# include<netinet/in.h>
#endif

#ifdefHAVE_SYS_SOCKET_H
#include<sys/socket.h>
#endif

#ifdefHAVE_GETHOSTBYNAME_R
#include<netdb.h>
#endif

/* These are here, rather than with the win32 counterparts above,
 * since <sys/socket.h> defines them. */
#ifndefSHUT_RD
# defineSHUT_RD 0
# defineSHUT_WR 1
# defineSHUT_RDWR 2
#endif

#ifdefHAVE_SYS_TIME_H
#include<sys/time.h>
#endif

#include<stddef.h>

#ifdefPHP_WIN32
typedefSOCKETphp_socket_t;
#definePHP_SOCKET_FMT "%" PRIxPTR
#else
typedefintphp_socket_t;
#definePHP_SOCKET_FMT "%d"
#endif

#ifdefPHP_WIN32
# defineSOCK_ERR INVALID_SOCKET
# defineSOCK_CONN_ERR SOCKET_ERROR
# defineSOCK_RECV_ERR SOCKET_ERROR
#else
# defineSOCK_ERR -1
# defineSOCK_CONN_ERR -1
# defineSOCK_RECV_ERR -1
#endif

#defineSTREAM_SOCKOP_NONE (1 << 0)
#defineSTREAM_SOCKOP_SO_REUSEPORT (1 << 1)
#defineSTREAM_SOCKOP_SO_BROADCAST (1 << 2)
#defineSTREAM_SOCKOP_IPV6_V6ONLY (1 << 3)
#defineSTREAM_SOCKOP_IPV6_V6ONLY_ENABLED (1 << 4)
#defineSTREAM_SOCKOP_TCP_NODELAY (1 << 5)


/* uncomment this to debug poll(2) emulation on systems that have poll(2) */
/* #define PHP_USE_POLL_2_EMULATION 1 */

#if defined(HAVE_POLL)
# if defined(HAVE_POLL_H)
# include<poll.h>
# elif defined(HAVE_SYS_POLL_H)
# include<sys/poll.h>
# endif
typedefstructpollfdphp_pollfd;
#else
typedefstruct_php_pollfd {
php_socket_tfd;
shortevents;
shortrevents;
} php_pollfd;

PHPAPIintphp_poll2(php_pollfd*ufds, unsigned intnfds, inttimeout);

#ifndefPOLLIN
# definePOLLIN 0x0001 /* There is data to read */
# definePOLLPRI 0x0002 /* There is urgent data to read */
# definePOLLOUT 0x0004 /* Writing now will not block */
# definePOLLERR 0x0008 /* Error condition */
# definePOLLHUP 0x0010 /* Hung up */
# definePOLLNVAL 0x0020 /* Invalid request: fd not open */
#endif

# ifndefPHP_USE_POLL_2_EMULATION
# definePHP_USE_POLL_2_EMULATION 1
# endif
#endif

#definePHP_POLLREADABLE (POLLIN|POLLERR|POLLHUP)

#ifndefPHP_USE_POLL_2_EMULATION
# definephp_poll2(ufds, nfds, timeout) poll(ufds, nfds, timeout)
#endif

/* timeval-to-timeout (for poll(2)) */
staticinlineintphp_tvtoto(structtimeval*timeouttv)
{
if (timeouttv&&timeouttv->tv_sec >= 0&&timeouttv->tv_sec <= ((INT_MAX-1000) / 1000)) {
return (timeouttv->tv_sec*1000) + (timeouttv->tv_usec / 1000);
 }
return-1;
}

/* hybrid select(2)/poll(2) for a single descriptor.
 * timeouttv follows same rules as select(2), but is reduced to millisecond accuracy.
 * Returns 0 on timeout, -1 on error, or the event mask (ala poll(2)).
 */
staticinlineintphp_pollfd_for(php_socket_tfd, intevents, structtimeval*timeouttv)
{
php_pollfdp;
intn;

p.fd=fd;
p.events=events;
p.revents=0;

n=php_poll2(&p, 1, php_tvtoto(timeouttv));

if (n>0) {
returnp.revents;
 }

returnn;
}

staticinlineintphp_pollfd_for_ms(php_socket_tfd, intevents, inttimeout)
{
php_pollfdp;
intn;

p.fd=fd;
p.events=events;
p.revents=0;

n=php_poll2(&p, 1, timeout);

if (n>0) {
returnp.revents;
 }

returnn;
}

/* emit warning and suggestion for unsafe select(2) usage */
PHPAPIvoid_php_emit_fd_setsize_warning(intmax_fd);

staticinlinebool_php_check_fd_setsize(php_socket_t*max_fd, intsetsize)
{
#ifdefPHP_WIN32
 (void)(max_fd); // Unused
if (setsize+1 >= FD_SETSIZE) {
_php_emit_fd_setsize_warning(setsize);
return false;
 }
#else
 (void)(setsize); // Unused
if (*max_fd >= FD_SETSIZE) {
_php_emit_fd_setsize_warning(*max_fd);
*max_fd=FD_SETSIZE-1;
return false;
 }
#endif
return true;
}

#ifdefPHP_WIN32
/* it is safe to FD_SET too many fd's under win32; the macro will simply ignore
 * descriptors that go beyond the default FD_SETSIZE */
# definePHP_SAFE_FD_SET(fd, set) FD_SET(fd, set)
# definePHP_SAFE_FD_CLR(fd, set) FD_CLR(fd, set)
# definePHP_SAFE_FD_ISSET(fd, set) FD_ISSET(fd, set)
# definePHP_SAFE_MAX_FD(m, n) _php_check_fd_setsize(&m, n)
#else
# definePHP_SAFE_FD_SET(fd, set) do { if (fd < FD_SETSIZE) FD_SET(fd, set); } while(0)
# definePHP_SAFE_FD_CLR(fd, set) do { if (fd < FD_SETSIZE) FD_CLR(fd, set); } while(0)
# definePHP_SAFE_FD_ISSET(fd, set) ((fd < FD_SETSIZE) && FD_ISSET(fd, set))
# definePHP_SAFE_MAX_FD(m, n) _php_check_fd_setsize(&m, n)
#endif


#definePHP_SOCK_CHUNK_SIZE 8192

#ifdefHAVE_STRUCT_SOCKADDR_STORAGE
typedefstructsockaddr_storagephp_sockaddr_storage;
#else
typedefstruct {
#ifdefHAVE_STRUCT_SOCKADDR_SA_LEN
unsigned charss_len;
unsigned charss_family;
#else
unsigned shortss_family;
#endif
charinfo[126];
} php_sockaddr_storage;
#endif

BEGIN_EXTERN_C()
PHPAPIintphp_network_getaddresses(constchar*host, intsocktype, structsockaddr***sal, zend_string**error_string);
PHPAPIvoidphp_network_freeaddresses(structsockaddr**sal);

PHPAPIphp_socket_tphp_network_connect_socket_to_host(constchar*host, unsigned shortport,
intsocktype, intasynchronous, structtimeval*timeout, zend_string**error_string,
int*error_code, constchar*bindto, unsigned shortbindport, longsockopts
 );

PHPAPIintphp_network_connect_socket(php_socket_tsockfd,
conststructsockaddr*addr,
socklen_taddrlen,
intasynchronous,
structtimeval*timeout,
zend_string**error_string,
int*error_code);

#definephp_connect_nonb(sock, addr, addrlen, timeout) \
 php_network_connect_socket((sock), (addr), (addrlen), 0, (timeout), NULL, NULL)

PHPAPIphp_socket_tphp_network_bind_socket_to_local_addr(constchar*host, unsignedport,
intsocktype, longsockopts, zend_string**error_string, int*error_code
 );

PHPAPIphp_socket_tphp_network_accept_incoming(php_socket_tsrvsock,
zend_string**textaddr,
structsockaddr**addr,
socklen_t*addrlen,
structtimeval*timeout,
zend_string**error_string,
int*error_code,
inttcp_nodelay
 );

PHPAPIintphp_network_get_sock_name(php_socket_tsock,
zend_string**textaddr,
structsockaddr**addr,
socklen_t*addrlen
 );

PHPAPIintphp_network_get_peer_name(php_socket_tsock,
zend_string**textaddr,
structsockaddr**addr,
socklen_t*addrlen
 );

PHPAPIvoidphp_any_addr(intfamily, php_sockaddr_storage*addr, unsigned shortport);
PHPAPIsocklen_tphp_sockaddr_size(php_sockaddr_storage*addr);
END_EXTERN_C()

struct_php_netstream_data_t {
php_socket_tsocket;
charis_blocked;
structtimevaltimeout;
chartimeout_event;
size_townsize;
};
typedefstruct_php_netstream_data_tphp_netstream_data_t;
PHPAPIexternconstphp_stream_opsphp_stream_socket_ops;
externconstphp_stream_opsphp_stream_generic_socket_ops;
#definePHP_STREAM_IS_SOCKET (&php_stream_socket_ops)

BEGIN_EXTERN_C()
PHPAPIphp_stream*_php_stream_sock_open_from_socket(php_socket_tsocket, constchar*persistent_idSTREAMS_DC );
/* open a connection to a host using php_hostconnect and return a stream */
PHPAPIphp_stream*_php_stream_sock_open_host(constchar*host, unsigned shortport,
intsocktype, structtimeval*timeout, constchar*persistent_idSTREAMS_DC);
PHPAPIvoidphp_network_populate_name_from_sockaddr(
/* input address */
structsockaddr*sa, socklen_tsl,
/* output readable address */
zend_string**textaddr,
/* output address */
structsockaddr**addr,
socklen_t*addrlen
 );

PHPAPIzend_resultphp_network_parse_network_address_with_port(constchar*addr,
size_taddrlen, structsockaddr*sa, socklen_t*sl);

PHPAPIstructhostent*php_network_gethostbyname(constchar*name);

PHPAPIzend_resultphp_set_sock_blocking(php_socket_tsocketd, boolblock);
END_EXTERN_C()

#definephp_stream_sock_open_from_socket(socket, persistent) _php_stream_sock_open_from_socket((socket), (persistent) STREAMS_CC)
#definephp_stream_sock_open_host(host, port, socktype, timeout, persistent) _php_stream_sock_open_host((host), (port), (socktype), (timeout), (persistent) STREAMS_CC)

/* {{{ memory debug */
#definephp_stream_sock_open_from_socket_rel(socket, persistent) _php_stream_sock_open_from_socket((socket), (persistent) STREAMS_REL_CC)
#definephp_stream_sock_open_host_rel(host, port, socktype, timeout, persistent) _php_stream_sock_open_host((host), (port), (socktype), (timeout), (persistent) STREAMS_REL_CC)
#definephp_stream_sock_open_unix_rel(path, pathlen, persistent, timeval) _php_stream_sock_open_unix((path), (pathlen), (persistent), (timeval) STREAMS_REL_CC)

/* }}} */

#ifndefMAXFQDNLEN
#defineMAXFQDNLEN 255
#endif

#endif/* _PHP_NETWORK_H */