Annotation of embedaddon/php/ext/sockets/sockets.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2012 The PHP Group |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 3.01 of the PHP license, |
! 8: | that is bundled with this package in the file LICENSE, and is |
! 9: | available through the world-wide-web at the following url: |
! 10: | http://www.php.net/license/3_01.txt |
! 11: | If you did not receive a copy of the PHP license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@php.net so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Authors: Chris Vandomelen <chrisv@b0rked.dhs.org> |
! 16: | Sterling Hughes <sterling@php.net> |
! 17: | Jason Greene <jason@php.net> |
! 18: | WinSock: Daniel Beulshausen <daniel@php4win.de> |
! 19: +----------------------------------------------------------------------+
! 20: */
! 21:
! 22: /* $Id: sockets.c 321634 2012-01-01 13:15:04Z felipe $ */
! 23:
! 24: #ifdef HAVE_CONFIG_H
! 25: #include "config.h"
! 26: #endif
! 27:
! 28: #include "php.h"
! 29:
! 30: #if HAVE_SOCKETS
! 31:
! 32: #include "php_network.h"
! 33: #include "ext/standard/file.h"
! 34: #include "ext/standard/info.h"
! 35: #include "php_ini.h"
! 36: #ifdef PHP_WIN32
! 37: # include "win32/inet.h"
! 38: # include <winsock2.h>
! 39: # include <windows.h>
! 40: # include <Ws2tcpip.h>
! 41: # include "php_sockets.h"
! 42: # include "win32/sockets.h"
! 43: # define IS_INVALID_SOCKET(a) (a->bsd_socket == INVALID_SOCKET)
! 44: # ifdef EPROTONOSUPPORT
! 45: # undef EPROTONOSUPPORT
! 46: # endif
! 47: # ifdef ECONNRESET
! 48: # undef ECONNRESET
! 49: # endif
! 50: # define EPROTONOSUPPORT WSAEPROTONOSUPPORT
! 51: # define ECONNRESET WSAECONNRESET
! 52: # ifdef errno
! 53: # undef errno
! 54: # endif
! 55: # define errno WSAGetLastError()
! 56: # define h_errno WSAGetLastError()
! 57: # define set_errno(a) WSASetLastError(a)
! 58: # define close(a) closesocket(a)
! 59: #else
! 60: # include <sys/types.h>
! 61: # include <sys/socket.h>
! 62: # include <netdb.h>
! 63: # include <netinet/in.h>
! 64: # include <netinet/tcp.h>
! 65: # include <sys/un.h>
! 66: # include <arpa/inet.h>
! 67: # include <sys/time.h>
! 68: # include <unistd.h>
! 69: # include <errno.h>
! 70: # include <fcntl.h>
! 71: # include <signal.h>
! 72: # include <sys/uio.h>
! 73: # define IS_INVALID_SOCKET(a) (a->bsd_socket < 0)
! 74: # define set_errno(a) (errno = a)
! 75: # include "php_sockets.h"
! 76: #endif
! 77:
! 78: ZEND_DECLARE_MODULE_GLOBALS(sockets)
! 79: static PHP_GINIT_FUNCTION(sockets);
! 80:
! 81: #ifndef MSG_WAITALL
! 82: #ifdef LINUX
! 83: #define MSG_WAITALL 0x00000100
! 84: #else
! 85: #define MSG_WAITALL 0x00000000
! 86: #endif
! 87: #endif
! 88:
! 89: #ifndef MSG_EOF
! 90: #ifdef MSG_FIN
! 91: #define MSG_EOF MSG_FIN
! 92: #endif
! 93: #endif
! 94:
! 95: #ifndef SUN_LEN
! 96: #define SUN_LEN(su) (sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
! 97: #endif
! 98:
! 99: #ifndef PF_INET
! 100: #define PF_INET AF_INET
! 101: #endif
! 102:
! 103: static char *php_strerror(int error TSRMLS_DC);
! 104:
! 105: #define PHP_NORMAL_READ 0x0001
! 106: #define PHP_BINARY_READ 0x0002
! 107:
! 108: #define PHP_SOCKET_ERROR(socket,msg,errn) socket->error = errn; \
! 109: SOCKETS_G(last_error) = errn; \
! 110: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s [%d]: %s", msg, errn, php_strerror(errn TSRMLS_CC))
! 111:
! 112: static int le_socket;
! 113: #define le_socket_name php_sockets_le_socket_name
! 114:
! 115: /* {{{ arginfo */
! 116: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_select, 0, 0, 4)
! 117: ZEND_ARG_INFO(1, read_fds)
! 118: ZEND_ARG_INFO(1, write_fds)
! 119: ZEND_ARG_INFO(1, except_fds)
! 120: ZEND_ARG_INFO(0, tv_sec)
! 121: ZEND_ARG_INFO(0, tv_usec)
! 122: ZEND_END_ARG_INFO()
! 123:
! 124: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_create_listen, 0, 0, 1)
! 125: ZEND_ARG_INFO(0, port)
! 126: ZEND_ARG_INFO(0, backlog)
! 127: ZEND_END_ARG_INFO()
! 128:
! 129: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_accept, 0, 0, 1)
! 130: ZEND_ARG_INFO(0, socket)
! 131: ZEND_END_ARG_INFO()
! 132:
! 133: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_set_nonblock, 0, 0, 1)
! 134: ZEND_ARG_INFO(0, socket)
! 135: ZEND_END_ARG_INFO()
! 136:
! 137: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_set_block, 0, 0, 1)
! 138: ZEND_ARG_INFO(0, socket)
! 139: ZEND_END_ARG_INFO()
! 140:
! 141: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_listen, 0, 0, 1)
! 142: ZEND_ARG_INFO(0, socket)
! 143: ZEND_ARG_INFO(0, backlog)
! 144: ZEND_END_ARG_INFO()
! 145:
! 146: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_close, 0, 0, 1)
! 147: ZEND_ARG_INFO(0, socket)
! 148: ZEND_END_ARG_INFO()
! 149:
! 150: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_write, 0, 0, 2)
! 151: ZEND_ARG_INFO(0, socket)
! 152: ZEND_ARG_INFO(0, buf)
! 153: ZEND_ARG_INFO(0, length)
! 154: ZEND_END_ARG_INFO()
! 155:
! 156: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_read, 0, 0, 2)
! 157: ZEND_ARG_INFO(0, socket)
! 158: ZEND_ARG_INFO(0, length)
! 159: ZEND_ARG_INFO(0, type)
! 160: ZEND_END_ARG_INFO()
! 161:
! 162: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_getsockname, 0, 0, 2)
! 163: ZEND_ARG_INFO(0, socket)
! 164: ZEND_ARG_INFO(1, addr)
! 165: ZEND_ARG_INFO(1, port)
! 166: ZEND_END_ARG_INFO()
! 167:
! 168: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_getpeername, 0, 0, 2)
! 169: ZEND_ARG_INFO(0, socket)
! 170: ZEND_ARG_INFO(1, addr)
! 171: ZEND_ARG_INFO(1, port)
! 172: ZEND_END_ARG_INFO()
! 173:
! 174: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_create, 0, 0, 3)
! 175: ZEND_ARG_INFO(0, domain)
! 176: ZEND_ARG_INFO(0, type)
! 177: ZEND_ARG_INFO(0, protocol)
! 178: ZEND_END_ARG_INFO()
! 179:
! 180: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_connect, 0, 0, 2)
! 181: ZEND_ARG_INFO(0, socket)
! 182: ZEND_ARG_INFO(0, addr)
! 183: ZEND_ARG_INFO(0, port)
! 184: ZEND_END_ARG_INFO()
! 185:
! 186: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_strerror, 0, 0, 1)
! 187: ZEND_ARG_INFO(0, errno)
! 188: ZEND_END_ARG_INFO()
! 189:
! 190: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_bind, 0, 0, 2)
! 191: ZEND_ARG_INFO(0, socket)
! 192: ZEND_ARG_INFO(0, addr)
! 193: ZEND_ARG_INFO(0, port)
! 194: ZEND_END_ARG_INFO()
! 195:
! 196: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_recv, 0, 0, 4)
! 197: ZEND_ARG_INFO(0, socket)
! 198: ZEND_ARG_INFO(1, buf)
! 199: ZEND_ARG_INFO(0, len)
! 200: ZEND_ARG_INFO(0, flags)
! 201: ZEND_END_ARG_INFO()
! 202:
! 203: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_send, 0, 0, 4)
! 204: ZEND_ARG_INFO(0, socket)
! 205: ZEND_ARG_INFO(0, buf)
! 206: ZEND_ARG_INFO(0, len)
! 207: ZEND_ARG_INFO(0, flags)
! 208: ZEND_END_ARG_INFO()
! 209:
! 210: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_recvfrom, 0, 0, 5)
! 211: ZEND_ARG_INFO(0, socket)
! 212: ZEND_ARG_INFO(1, buf)
! 213: ZEND_ARG_INFO(0, len)
! 214: ZEND_ARG_INFO(0, flags)
! 215: ZEND_ARG_INFO(1, name)
! 216: ZEND_ARG_INFO(1, port)
! 217: ZEND_END_ARG_INFO()
! 218:
! 219: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_sendto, 0, 0, 5)
! 220: ZEND_ARG_INFO(0, socket)
! 221: ZEND_ARG_INFO(0, buf)
! 222: ZEND_ARG_INFO(0, len)
! 223: ZEND_ARG_INFO(0, flags)
! 224: ZEND_ARG_INFO(0, addr)
! 225: ZEND_ARG_INFO(0, port)
! 226: ZEND_END_ARG_INFO()
! 227:
! 228: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_get_option, 0, 0, 3)
! 229: ZEND_ARG_INFO(0, socket)
! 230: ZEND_ARG_INFO(0, level)
! 231: ZEND_ARG_INFO(0, optname)
! 232: ZEND_END_ARG_INFO()
! 233:
! 234: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_set_option, 0, 0, 4)
! 235: ZEND_ARG_INFO(0, socket)
! 236: ZEND_ARG_INFO(0, level)
! 237: ZEND_ARG_INFO(0, optname)
! 238: ZEND_ARG_INFO(0, optval)
! 239: ZEND_END_ARG_INFO()
! 240:
! 241: #ifdef HAVE_SOCKETPAIR
! 242: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_create_pair, 0, 0, 4)
! 243: ZEND_ARG_INFO(0, domain)
! 244: ZEND_ARG_INFO(0, type)
! 245: ZEND_ARG_INFO(0, protocol)
! 246: ZEND_ARG_INFO(1, fd)
! 247: ZEND_END_ARG_INFO()
! 248: #endif
! 249:
! 250: #ifdef HAVE_SHUTDOWN
! 251: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_shutdown, 0, 0, 1)
! 252: ZEND_ARG_INFO(0, socket)
! 253: ZEND_ARG_INFO(0, how)
! 254: ZEND_END_ARG_INFO()
! 255: #endif
! 256:
! 257: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_last_error, 0, 0, 0)
! 258: ZEND_ARG_INFO(0, socket)
! 259: ZEND_END_ARG_INFO()
! 260:
! 261: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_clear_error, 0, 0, 0)
! 262: ZEND_ARG_INFO(0, socket)
! 263: ZEND_END_ARG_INFO()
! 264: /* }}} */
! 265:
! 266: /* {{{ sockets_functions[]
! 267: */
! 268: const zend_function_entry sockets_functions[] = {
! 269: PHP_FE(socket_select, arginfo_socket_select)
! 270: PHP_FE(socket_create, arginfo_socket_create)
! 271: PHP_FE(socket_create_listen, arginfo_socket_create_listen)
! 272: #ifdef HAVE_SOCKETPAIR
! 273: PHP_FE(socket_create_pair, arginfo_socket_create_pair)
! 274: #endif
! 275: PHP_FE(socket_accept, arginfo_socket_accept)
! 276: PHP_FE(socket_set_nonblock, arginfo_socket_set_nonblock)
! 277: PHP_FE(socket_set_block, arginfo_socket_set_block)
! 278: PHP_FE(socket_listen, arginfo_socket_listen)
! 279: PHP_FE(socket_close, arginfo_socket_close)
! 280: PHP_FE(socket_write, arginfo_socket_write)
! 281: PHP_FE(socket_read, arginfo_socket_read)
! 282: PHP_FE(socket_getsockname, arginfo_socket_getsockname)
! 283: PHP_FE(socket_getpeername, arginfo_socket_getpeername)
! 284: PHP_FE(socket_connect, arginfo_socket_connect)
! 285: PHP_FE(socket_strerror, arginfo_socket_strerror)
! 286: PHP_FE(socket_bind, arginfo_socket_bind)
! 287: PHP_FE(socket_recv, arginfo_socket_recv)
! 288: PHP_FE(socket_send, arginfo_socket_send)
! 289: PHP_FE(socket_recvfrom, arginfo_socket_recvfrom)
! 290: PHP_FE(socket_sendto, arginfo_socket_sendto)
! 291: PHP_FE(socket_get_option, arginfo_socket_get_option)
! 292: PHP_FE(socket_set_option, arginfo_socket_set_option)
! 293: #ifdef HAVE_SHUTDOWN
! 294: PHP_FE(socket_shutdown, arginfo_socket_shutdown)
! 295: #endif
! 296: PHP_FE(socket_last_error, arginfo_socket_last_error)
! 297: PHP_FE(socket_clear_error, arginfo_socket_clear_error)
! 298:
! 299: /* for downwards compatability */
! 300: PHP_FALIAS(socket_getopt, socket_get_option, arginfo_socket_get_option)
! 301: PHP_FALIAS(socket_setopt, socket_set_option, arginfo_socket_set_option)
! 302:
! 303: PHP_FE_END
! 304: };
! 305: /* }}} */
! 306:
! 307: zend_module_entry sockets_module_entry = {
! 308: STANDARD_MODULE_HEADER,
! 309: "sockets",
! 310: sockets_functions,
! 311: PHP_MINIT(sockets),
! 312: NULL,
! 313: NULL,
! 314: PHP_RSHUTDOWN(sockets),
! 315: PHP_MINFO(sockets),
! 316: NO_VERSION_YET,
! 317: PHP_MODULE_GLOBALS(sockets),
! 318: PHP_GINIT(sockets),
! 319: NULL,
! 320: NULL,
! 321: STANDARD_MODULE_PROPERTIES_EX
! 322: };
! 323:
! 324:
! 325: #ifdef COMPILE_DL_SOCKETS
! 326: ZEND_GET_MODULE(sockets)
! 327: #endif
! 328:
! 329: /* inet_ntop should be used instead of inet_ntoa */
! 330: int inet_ntoa_lock = 0;
! 331:
! 332: PHP_SOCKETS_API int php_sockets_le_socket(void) /* {{{ */
! 333: {
! 334: return le_socket;
! 335: }
! 336: /* }}} */
! 337:
! 338: static void php_destroy_socket(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
! 339: {
! 340: php_socket *php_sock = (php_socket *) rsrc->ptr;
! 341:
! 342: close(php_sock->bsd_socket);
! 343: efree(php_sock);
! 344: }
! 345: /* }}} */
! 346:
! 347: static int php_open_listen_sock(php_socket **php_sock, int port, int backlog TSRMLS_DC) /* {{{ */
! 348: {
! 349: struct sockaddr_in la;
! 350: struct hostent *hp;
! 351: php_socket *sock = (php_socket*)emalloc(sizeof(php_socket));
! 352:
! 353: *php_sock = sock;
! 354:
! 355: #ifndef PHP_WIN32
! 356: if ((hp = gethostbyname("0.0.0.0")) == NULL) {
! 357: #else
! 358: if ((hp = gethostbyname("localhost")) == NULL) {
! 359: #endif
! 360: efree(sock);
! 361: return 0;
! 362: }
! 363:
! 364: memcpy((char *) &la.sin_addr, hp->h_addr, hp->h_length);
! 365: la.sin_family = hp->h_addrtype;
! 366: la.sin_port = htons((unsigned short) port);
! 367:
! 368: sock->bsd_socket = socket(PF_INET, SOCK_STREAM, 0);
! 369: sock->blocking = 1;
! 370:
! 371: if (IS_INVALID_SOCKET(sock)) {
! 372: PHP_SOCKET_ERROR(sock, "unable to create listening socket", errno);
! 373: efree(sock);
! 374: return 0;
! 375: }
! 376:
! 377: sock->type = PF_INET;
! 378:
! 379: if (bind(sock->bsd_socket, (struct sockaddr *)&la, sizeof(la)) != 0) {
! 380: PHP_SOCKET_ERROR(sock, "unable to bind to given address", errno);
! 381: close(sock->bsd_socket);
! 382: efree(sock);
! 383: return 0;
! 384: }
! 385:
! 386: if (listen(sock->bsd_socket, backlog) != 0) {
! 387: PHP_SOCKET_ERROR(sock, "unable to listen on socket", errno);
! 388: close(sock->bsd_socket);
! 389: efree(sock);
! 390: return 0;
! 391: }
! 392:
! 393: return 1;
! 394: }
! 395: /* }}} */
! 396:
! 397: static int php_accept_connect(php_socket *in_sock, php_socket **new_sock, struct sockaddr *la, socklen_t *la_len TSRMLS_DC) /* {{{ */
! 398: {
! 399: php_socket *out_sock = (php_socket*)emalloc(sizeof(php_socket));
! 400:
! 401: *new_sock = out_sock;
! 402:
! 403: out_sock->bsd_socket = accept(in_sock->bsd_socket, la, la_len);
! 404:
! 405: if (IS_INVALID_SOCKET(out_sock)) {
! 406: PHP_SOCKET_ERROR(out_sock, "unable to accept incoming connection", errno);
! 407: efree(out_sock);
! 408: return 0;
! 409: }
! 410:
! 411: out_sock->error = 0;
! 412: out_sock->blocking = 1;
! 413: out_sock->type = la->sa_family;
! 414:
! 415: return 1;
! 416: }
! 417: /* }}} */
! 418:
! 419: /* {{{ php_read -- wrapper around read() so that it only reads to a \r or \n. */
! 420: static int php_read(php_socket *sock, void *buf, size_t maxlen, int flags)
! 421: {
! 422: int m = 0;
! 423: size_t n = 0;
! 424: int no_read = 0;
! 425: int nonblock = 0;
! 426: char *t = (char *) buf;
! 427:
! 428: #ifndef PHP_WIN32
! 429: m = fcntl(sock->bsd_socket, F_GETFL);
! 430: if (m < 0) {
! 431: return m;
! 432: }
! 433: nonblock = (m & O_NONBLOCK);
! 434: m = 0;
! 435: #else
! 436: nonblock = !sock->blocking;
! 437: #endif
! 438: set_errno(0);
! 439:
! 440: *t = '\0';
! 441: while (*t != '\n' && *t != '\r' && n < maxlen) {
! 442: if (m > 0) {
! 443: t++;
! 444: n++;
! 445: } else if (m == 0) {
! 446: no_read++;
! 447: if (nonblock && no_read >= 2) {
! 448: return n;
! 449: /* The first pass, m always is 0, so no_read becomes 1
! 450: * in the first pass. no_read becomes 2 in the second pass,
! 451: * and if this is nonblocking, we should return.. */
! 452: }
! 453:
! 454: if (no_read > 200) {
! 455: set_errno(ECONNRESET);
! 456: return -1;
! 457: }
! 458: }
! 459:
! 460: if (n < maxlen) {
! 461: m = recv(sock->bsd_socket, (void *) t, 1, flags);
! 462: }
! 463:
! 464: if (errno != 0 && errno != ESPIPE && errno != EAGAIN) {
! 465: return -1;
! 466: }
! 467:
! 468: set_errno(0);
! 469: }
! 470:
! 471: if (n < maxlen) {
! 472: n++;
! 473: /* The only reasons it makes it to here is
! 474: * if '\n' or '\r' are encountered. So, increase
! 475: * the return by 1 to make up for the lack of the
! 476: * '\n' or '\r' in the count (since read() takes
! 477: * place at the end of the loop..) */
! 478: }
! 479:
! 480: return n;
! 481: }
! 482: /* }}} */
! 483:
! 484: static char *php_strerror(int error TSRMLS_DC) /* {{{ */
! 485: {
! 486: const char *buf;
! 487:
! 488: #ifndef PHP_WIN32
! 489: if (error < -10000) {
! 490: error = -error - 10000;
! 491:
! 492: #ifdef HAVE_HSTRERROR
! 493: buf = hstrerror(error);
! 494: #else
! 495: {
! 496: if (SOCKETS_G(strerror_buf)) {
! 497: efree(SOCKETS_G(strerror_buf));
! 498: }
! 499:
! 500: spprintf(&(SOCKETS_G(strerror_buf)), 0, "Host lookup error %d", error);
! 501: buf = SOCKETS_G(strerror_buf);
! 502: }
! 503: #endif
! 504: } else {
! 505: buf = strerror(error);
! 506: }
! 507: #else
! 508: {
! 509: LPTSTR tmp = NULL;
! 510: buf = NULL;
! 511:
! 512: if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
! 513: NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &tmp, 0, NULL)
! 514: ) {
! 515: if (SOCKETS_G(strerror_buf)) {
! 516: efree(SOCKETS_G(strerror_buf));
! 517: }
! 518:
! 519: SOCKETS_G(strerror_buf) = estrdup(tmp);
! 520: LocalFree(tmp);
! 521:
! 522: buf = SOCKETS_G(strerror_buf);
! 523: }
! 524: }
! 525: #endif
! 526:
! 527: return (buf ? (char *) buf : "");
! 528: }
! 529: /* }}} */
! 530:
! 531: #if HAVE_IPV6
! 532: /* Sets addr by hostname, or by ip in string form (AF_INET6) */
! 533: static int php_set_inet6_addr(struct sockaddr_in6 *sin6, char *string, php_socket *php_sock TSRMLS_DC) /* {{{ */
! 534: {
! 535: struct in6_addr tmp;
! 536: #if HAVE_GETADDRINFO
! 537: struct addrinfo hints;
! 538: struct addrinfo *addrinfo = NULL;
! 539: #endif
! 540:
! 541: if (inet_pton(AF_INET6, string, &tmp)) {
! 542: memcpy(&(sin6->sin6_addr.s6_addr), &(tmp.s6_addr), sizeof(struct in6_addr));
! 543: } else {
! 544: #if HAVE_GETADDRINFO
! 545:
! 546: memset(&hints, 0, sizeof(struct addrinfo));
! 547: hints.ai_family = PF_INET6;
! 548: getaddrinfo(string, NULL, &hints, &addrinfo);
! 549: if (!addrinfo) {
! 550: #ifdef PHP_WIN32
! 551: PHP_SOCKET_ERROR(php_sock, "Host lookup failed", WSAGetLastError());
! 552: #else
! 553: PHP_SOCKET_ERROR(php_sock, "Host lookup failed", (-10000 - h_errno));
! 554: #endif
! 555: return 0;
! 556: }
! 557: if (addrinfo->ai_family != PF_INET6 || addrinfo->ai_addrlen != sizeof(struct sockaddr_in6)) {
! 558: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Host lookup failed: Non AF_INET6 domain returned on AF_INET6 socket");
! 559: freeaddrinfo(addrinfo);
! 560: return 0;
! 561: }
! 562:
! 563: memcpy(&(sin6->sin6_addr.s6_addr), ((struct sockaddr_in6*)(addrinfo->ai_addr))->sin6_addr.s6_addr, sizeof(struct in6_addr));
! 564: freeaddrinfo(addrinfo);
! 565:
! 566: #else
! 567: /* No IPv6 specific hostname resolution is available on this system? */
! 568: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Host lookup failed: getaddrinfo() not available on this system");
! 569: return 0;
! 570: #endif
! 571:
! 572: }
! 573:
! 574: return 1;
! 575: }
! 576: /* }}} */
! 577: #endif
! 578:
! 579: /* Sets addr by hostname, or by ip in string form (AF_INET) */
! 580: static int php_set_inet_addr(struct sockaddr_in *sin, char *string, php_socket *php_sock TSRMLS_DC) /* {{{ */
! 581: {
! 582: struct in_addr tmp;
! 583: struct hostent *host_entry;
! 584:
! 585: if (inet_aton(string, &tmp)) {
! 586: sin->sin_addr.s_addr = tmp.s_addr;
! 587: } else {
! 588: if (! (host_entry = gethostbyname(string))) {
! 589: /* Note: < -10000 indicates a host lookup error */
! 590: #ifdef PHP_WIN32
! 591: PHP_SOCKET_ERROR(php_sock, "Host lookup failed", WSAGetLastError());
! 592: #else
! 593: PHP_SOCKET_ERROR(php_sock, "Host lookup failed", (-10000 - h_errno));
! 594: #endif
! 595: return 0;
! 596: }
! 597: if (host_entry->h_addrtype != AF_INET) {
! 598: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Host lookup failed: Non AF_INET domain returned on AF_INET socket");
! 599: return 0;
! 600: }
! 601: memcpy(&(sin->sin_addr.s_addr), host_entry->h_addr_list[0], host_entry->h_length);
! 602: }
! 603:
! 604: return 1;
! 605: }
! 606: /* }}} */
! 607:
! 608: /* {{{ PHP_GINIT_FUNCTION */
! 609: static PHP_GINIT_FUNCTION(sockets)
! 610: {
! 611: sockets_globals->last_error = 0;
! 612: sockets_globals->strerror_buf = NULL;
! 613: }
! 614: /* }}} */
! 615:
! 616: /* {{{ PHP_MINIT_FUNCTION
! 617: */
! 618: PHP_MINIT_FUNCTION(sockets)
! 619: {
! 620: struct protoent *pe;
! 621:
! 622: le_socket = zend_register_list_destructors_ex(php_destroy_socket, NULL, le_socket_name, module_number);
! 623:
! 624: REGISTER_LONG_CONSTANT("AF_UNIX", AF_UNIX, CONST_CS | CONST_PERSISTENT);
! 625: REGISTER_LONG_CONSTANT("AF_INET", AF_INET, CONST_CS | CONST_PERSISTENT);
! 626: #if HAVE_IPV6
! 627: REGISTER_LONG_CONSTANT("AF_INET6", AF_INET6, CONST_CS | CONST_PERSISTENT);
! 628: #endif
! 629: REGISTER_LONG_CONSTANT("SOCK_STREAM", SOCK_STREAM, CONST_CS | CONST_PERSISTENT);
! 630: REGISTER_LONG_CONSTANT("SOCK_DGRAM", SOCK_DGRAM, CONST_CS | CONST_PERSISTENT);
! 631: REGISTER_LONG_CONSTANT("SOCK_RAW", SOCK_RAW, CONST_CS | CONST_PERSISTENT);
! 632: REGISTER_LONG_CONSTANT("SOCK_SEQPACKET",SOCK_SEQPACKET, CONST_CS | CONST_PERSISTENT);
! 633: REGISTER_LONG_CONSTANT("SOCK_RDM", SOCK_RDM, CONST_CS | CONST_PERSISTENT);
! 634: REGISTER_LONG_CONSTANT("MSG_OOB", MSG_OOB, CONST_CS | CONST_PERSISTENT);
! 635: REGISTER_LONG_CONSTANT("MSG_WAITALL", MSG_WAITALL, CONST_CS | CONST_PERSISTENT);
! 636: #ifdef MSG_DONTWAIT
! 637: REGISTER_LONG_CONSTANT("MSG_DONTWAIT", MSG_DONTWAIT, CONST_CS | CONST_PERSISTENT);
! 638: #endif
! 639: REGISTER_LONG_CONSTANT("MSG_PEEK", MSG_PEEK, CONST_CS | CONST_PERSISTENT);
! 640: REGISTER_LONG_CONSTANT("MSG_DONTROUTE", MSG_DONTROUTE, CONST_CS | CONST_PERSISTENT);
! 641: #ifdef MSG_EOR
! 642: REGISTER_LONG_CONSTANT("MSG_EOR", MSG_EOR, CONST_CS | CONST_PERSISTENT);
! 643: #endif
! 644: #ifdef MSG_EOF
! 645: REGISTER_LONG_CONSTANT("MSG_EOF", MSG_EOF, CONST_CS | CONST_PERSISTENT);
! 646: #endif
! 647: REGISTER_LONG_CONSTANT("SO_DEBUG", SO_DEBUG, CONST_CS | CONST_PERSISTENT);
! 648: REGISTER_LONG_CONSTANT("SO_REUSEADDR", SO_REUSEADDR, CONST_CS | CONST_PERSISTENT);
! 649: REGISTER_LONG_CONSTANT("SO_KEEPALIVE", SO_KEEPALIVE, CONST_CS | CONST_PERSISTENT);
! 650: REGISTER_LONG_CONSTANT("SO_DONTROUTE", SO_DONTROUTE, CONST_CS | CONST_PERSISTENT);
! 651: REGISTER_LONG_CONSTANT("SO_LINGER", SO_LINGER, CONST_CS | CONST_PERSISTENT);
! 652: REGISTER_LONG_CONSTANT("SO_BROADCAST", SO_BROADCAST, CONST_CS | CONST_PERSISTENT);
! 653: REGISTER_LONG_CONSTANT("SO_OOBINLINE", SO_OOBINLINE, CONST_CS | CONST_PERSISTENT);
! 654: REGISTER_LONG_CONSTANT("SO_SNDBUF", SO_SNDBUF, CONST_CS | CONST_PERSISTENT);
! 655: REGISTER_LONG_CONSTANT("SO_RCVBUF", SO_RCVBUF, CONST_CS | CONST_PERSISTENT);
! 656: REGISTER_LONG_CONSTANT("SO_SNDLOWAT", SO_SNDLOWAT, CONST_CS | CONST_PERSISTENT);
! 657: REGISTER_LONG_CONSTANT("SO_RCVLOWAT", SO_RCVLOWAT, CONST_CS | CONST_PERSISTENT);
! 658: REGISTER_LONG_CONSTANT("SO_SNDTIMEO", SO_SNDTIMEO, CONST_CS | CONST_PERSISTENT);
! 659: REGISTER_LONG_CONSTANT("SO_RCVTIMEO", SO_RCVTIMEO, CONST_CS | CONST_PERSISTENT);
! 660: REGISTER_LONG_CONSTANT("SO_TYPE", SO_TYPE, CONST_CS | CONST_PERSISTENT);
! 661: REGISTER_LONG_CONSTANT("SO_ERROR", SO_ERROR, CONST_CS | CONST_PERSISTENT);
! 662: REGISTER_LONG_CONSTANT("SOL_SOCKET", SOL_SOCKET, CONST_CS | CONST_PERSISTENT);
! 663: REGISTER_LONG_CONSTANT("SOMAXCONN", SOMAXCONN, CONST_CS | CONST_PERSISTENT);
! 664: #ifdef TCP_NODELAY
! 665: REGISTER_LONG_CONSTANT("TCP_NODELAY", TCP_NODELAY, CONST_CS | CONST_PERSISTENT);
! 666: #endif
! 667: REGISTER_LONG_CONSTANT("PHP_NORMAL_READ", PHP_NORMAL_READ, CONST_CS | CONST_PERSISTENT);
! 668: REGISTER_LONG_CONSTANT("PHP_BINARY_READ", PHP_BINARY_READ, CONST_CS | CONST_PERSISTENT);
! 669:
! 670: #ifndef WIN32
! 671: # include "unix_socket_constants.h"
! 672: #else
! 673: # include "win32_socket_constants.h"
! 674: #endif
! 675:
! 676: if ((pe = getprotobyname("tcp"))) {
! 677: REGISTER_LONG_CONSTANT("SOL_TCP", pe->p_proto, CONST_CS | CONST_PERSISTENT);
! 678: }
! 679:
! 680: if ((pe = getprotobyname("udp"))) {
! 681: REGISTER_LONG_CONSTANT("SOL_UDP", pe->p_proto, CONST_CS | CONST_PERSISTENT);
! 682: }
! 683:
! 684: return SUCCESS;
! 685: }
! 686: /* }}} */
! 687:
! 688: /* {{{ PHP_MINFO_FUNCTION
! 689: */
! 690: PHP_MINFO_FUNCTION(sockets)
! 691: {
! 692: php_info_print_table_start();
! 693: php_info_print_table_row(2, "Sockets Support", "enabled");
! 694: php_info_print_table_end();
! 695: }
! 696: /* }}} */
! 697:
! 698: /* {{{ PHP_RSHUTDOWN_FUNCTION */
! 699: PHP_RSHUTDOWN_FUNCTION(sockets)
! 700: {
! 701: if (SOCKETS_G(strerror_buf)) {
! 702: efree(SOCKETS_G(strerror_buf));
! 703: SOCKETS_G(strerror_buf) = NULL;
! 704: }
! 705:
! 706: return SUCCESS;
! 707: }
! 708: /* }}} */
! 709:
! 710: static int php_sock_array_to_fd_set(zval *sock_array, fd_set *fds, PHP_SOCKET *max_fd TSRMLS_DC) /* {{{ */
! 711: {
! 712: zval **element;
! 713: php_socket *php_sock;
! 714: int num = 0;
! 715:
! 716: if (Z_TYPE_P(sock_array) != IS_ARRAY) return 0;
! 717:
! 718: for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(sock_array));
! 719: zend_hash_get_current_data(Z_ARRVAL_P(sock_array), (void **) &element) == SUCCESS;
! 720: zend_hash_move_forward(Z_ARRVAL_P(sock_array))) {
! 721:
! 722: php_sock = (php_socket*) zend_fetch_resource(element TSRMLS_CC, -1, le_socket_name, NULL, 1, le_socket);
! 723: if (!php_sock) continue; /* If element is not a resource, skip it */
! 724:
! 725: PHP_SAFE_FD_SET(php_sock->bsd_socket, fds);
! 726: if (php_sock->bsd_socket > *max_fd) {
! 727: *max_fd = php_sock->bsd_socket;
! 728: }
! 729: num++;
! 730: }
! 731:
! 732: return num ? 1 : 0;
! 733: }
! 734: /* }}} */
! 735:
! 736: static int php_sock_array_from_fd_set(zval *sock_array, fd_set *fds TSRMLS_DC) /* {{{ */
! 737: {
! 738: zval **element;
! 739: zval **dest_element;
! 740: php_socket *php_sock;
! 741: HashTable *new_hash;
! 742: char *key;
! 743: int num = 0;
! 744: ulong num_key;
! 745: uint key_len;
! 746:
! 747: if (Z_TYPE_P(sock_array) != IS_ARRAY) return 0;
! 748:
! 749: ALLOC_HASHTABLE(new_hash);
! 750: zend_hash_init(new_hash, zend_hash_num_elements(Z_ARRVAL_P(sock_array)), NULL, ZVAL_PTR_DTOR, 0);
! 751: for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(sock_array));
! 752: zend_hash_get_current_data(Z_ARRVAL_P(sock_array), (void **) &element) == SUCCESS;
! 753: zend_hash_move_forward(Z_ARRVAL_P(sock_array))) {
! 754:
! 755: php_sock = (php_socket*) zend_fetch_resource(element TSRMLS_CC, -1, le_socket_name, NULL, 1, le_socket);
! 756: if (!php_sock) continue; /* If element is not a resource, skip it */
! 757:
! 758: if (PHP_SAFE_FD_ISSET(php_sock->bsd_socket, fds)) {
! 759: /* Add fd to new array */
! 760: switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(sock_array), &key, &key_len, &num_key, 0, NULL)) {
! 761: case HASH_KEY_IS_STRING:
! 762: zend_hash_add(new_hash, key, key_len, (void *)element, sizeof(zval *), (void **)&dest_element);
! 763: break;
! 764: case HASH_KEY_IS_LONG:
! 765: zend_hash_index_update(new_hash, num_key, (void *)element, sizeof(zval *), (void **)&dest_element);
! 766: break;
! 767: }
! 768: if (dest_element) zval_add_ref(dest_element);
! 769: }
! 770: num++;
! 771: }
! 772:
! 773: /* Destroy old array, add new one */
! 774: zend_hash_destroy(Z_ARRVAL_P(sock_array));
! 775: efree(Z_ARRVAL_P(sock_array));
! 776:
! 777: zend_hash_internal_pointer_reset(new_hash);
! 778: Z_ARRVAL_P(sock_array) = new_hash;
! 779:
! 780: return num ? 1 : 0;
! 781: }
! 782: /* }}} */
! 783:
! 784: /* {{{ proto int socket_select(array &read_fds, array &write_fds, array &except_fds, int tv_sec[, int tv_usec]) U
! 785: Runs the select() system call on the sets mentioned with a timeout specified by tv_sec and tv_usec */
! 786: PHP_FUNCTION(socket_select)
! 787: {
! 788: zval *r_array, *w_array, *e_array, *sec;
! 789: struct timeval tv;
! 790: struct timeval *tv_p = NULL;
! 791: fd_set rfds, wfds, efds;
! 792: PHP_SOCKET max_fd = 0;
! 793: int retval, sets = 0;
! 794: long usec = 0;
! 795:
! 796: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a!a!a!z!|l", &r_array, &w_array, &e_array, &sec, &usec) == FAILURE) {
! 797: return;
! 798: }
! 799:
! 800: FD_ZERO(&rfds);
! 801: FD_ZERO(&wfds);
! 802: FD_ZERO(&efds);
! 803:
! 804: if (r_array != NULL) sets += php_sock_array_to_fd_set(r_array, &rfds, &max_fd TSRMLS_CC);
! 805: if (w_array != NULL) sets += php_sock_array_to_fd_set(w_array, &wfds, &max_fd TSRMLS_CC);
! 806: if (e_array != NULL) sets += php_sock_array_to_fd_set(e_array, &efds, &max_fd TSRMLS_CC);
! 807:
! 808: if (!sets) {
! 809: php_error_docref(NULL TSRMLS_CC, E_WARNING, "no resource arrays were passed to select");
! 810: RETURN_FALSE;
! 811: }
! 812:
! 813: PHP_SAFE_MAX_FD(max_fd, 0); /* someone needs to make this look more like stream_socket_select */
! 814:
! 815: /* If seconds is not set to null, build the timeval, else we wait indefinitely */
! 816: if (sec != NULL) {
! 817: zval tmp;
! 818:
! 819: if (Z_TYPE_P(sec) != IS_LONG) {
! 820: tmp = *sec;
! 821: zval_copy_ctor(&tmp);
! 822: convert_to_long(&tmp);
! 823: sec = &tmp;
! 824: }
! 825:
! 826: /* Solaris + BSD do not like microsecond values which are >= 1 sec */
! 827: if (usec > 999999) {
! 828: tv.tv_sec = Z_LVAL_P(sec) + (usec / 1000000);
! 829: tv.tv_usec = usec % 1000000;
! 830: } else {
! 831: tv.tv_sec = Z_LVAL_P(sec);
! 832: tv.tv_usec = usec;
! 833: }
! 834:
! 835: tv_p = &tv;
! 836:
! 837: if (sec == &tmp) {
! 838: zval_dtor(&tmp);
! 839: }
! 840: }
! 841:
! 842: retval = select(max_fd+1, &rfds, &wfds, &efds, tv_p);
! 843:
! 844: if (retval == -1) {
! 845: SOCKETS_G(last_error) = errno;
! 846: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to select [%d]: %s", errno, php_strerror(errno TSRMLS_CC));
! 847: RETURN_FALSE;
! 848: }
! 849:
! 850: if (r_array != NULL) php_sock_array_from_fd_set(r_array, &rfds TSRMLS_CC);
! 851: if (w_array != NULL) php_sock_array_from_fd_set(w_array, &wfds TSRMLS_CC);
! 852: if (e_array != NULL) php_sock_array_from_fd_set(e_array, &efds TSRMLS_CC);
! 853:
! 854: RETURN_LONG(retval);
! 855: }
! 856: /* }}} */
! 857:
! 858: /* {{{ proto resource socket_create_listen(int port[, int backlog]) U
! 859: Opens a socket on port to accept connections */
! 860: PHP_FUNCTION(socket_create_listen)
! 861: {
! 862: php_socket *php_sock;
! 863: long port, backlog = 128;
! 864:
! 865: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &port, &backlog) == FAILURE) {
! 866: return;
! 867: }
! 868:
! 869: if (!php_open_listen_sock(&php_sock, port, backlog TSRMLS_CC)) {
! 870: RETURN_FALSE;
! 871: }
! 872:
! 873: php_sock->error = 0;
! 874: php_sock->blocking = 1;
! 875:
! 876: ZEND_REGISTER_RESOURCE(return_value, php_sock, le_socket);
! 877: }
! 878: /* }}} */
! 879:
! 880: /* {{{ proto resource socket_accept(resource socket) U
! 881: Accepts a connection on the listening socket fd */
! 882: PHP_FUNCTION(socket_accept)
! 883: {
! 884: zval *arg1;
! 885: php_socket *php_sock, *new_sock;
! 886: php_sockaddr_storage sa;
! 887: socklen_t php_sa_len = sizeof(sa);
! 888:
! 889: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg1) == FAILURE) {
! 890: return;
! 891: }
! 892:
! 893: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 894:
! 895: if (!php_accept_connect(php_sock, &new_sock, (struct sockaddr*)&sa, &php_sa_len TSRMLS_CC)) {
! 896: RETURN_FALSE;
! 897: }
! 898:
! 899: ZEND_REGISTER_RESOURCE(return_value, new_sock, le_socket);
! 900: }
! 901: /* }}} */
! 902:
! 903: /* {{{ proto bool socket_set_nonblock(resource socket) U
! 904: Sets nonblocking mode on a socket resource */
! 905: PHP_FUNCTION(socket_set_nonblock)
! 906: {
! 907: zval *arg1;
! 908: php_socket *php_sock;
! 909:
! 910: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg1) == FAILURE) {
! 911: return;
! 912: }
! 913:
! 914: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 915:
! 916: if (php_set_sock_blocking(php_sock->bsd_socket, 0 TSRMLS_CC) == SUCCESS) {
! 917: php_sock->blocking = 0;
! 918: RETURN_TRUE;
! 919: } else {
! 920: PHP_SOCKET_ERROR(php_sock, "unable to set nonblocking mode", errno);
! 921: RETURN_FALSE;
! 922: }
! 923: }
! 924: /* }}} */
! 925:
! 926: /* {{{ proto bool socket_set_block(resource socket) U
! 927: Sets blocking mode on a socket resource */
! 928: PHP_FUNCTION(socket_set_block)
! 929: {
! 930: zval *arg1;
! 931: php_socket *php_sock;
! 932:
! 933: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg1) == FAILURE) {
! 934: return;
! 935: }
! 936:
! 937: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 938:
! 939: if (php_set_sock_blocking(php_sock->bsd_socket, 1 TSRMLS_CC) == SUCCESS) {
! 940: php_sock->blocking = 1;
! 941: RETURN_TRUE;
! 942: } else {
! 943: PHP_SOCKET_ERROR(php_sock, "unable to set blocking mode", errno);
! 944: RETURN_FALSE;
! 945: }
! 946: }
! 947: /* }}} */
! 948:
! 949: /* {{{ proto bool socket_listen(resource socket[, int backlog]) U
! 950: Sets the maximum number of connections allowed to be waited for on the socket specified by fd */
! 951: PHP_FUNCTION(socket_listen)
! 952: {
! 953: zval *arg1;
! 954: php_socket *php_sock;
! 955: long backlog = 0;
! 956:
! 957: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &arg1, &backlog) == FAILURE) {
! 958: return;
! 959: }
! 960:
! 961: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 962:
! 963: if (listen(php_sock->bsd_socket, backlog) != 0) {
! 964: PHP_SOCKET_ERROR(php_sock, "unable to listen on socket", errno);
! 965: RETURN_FALSE;
! 966: }
! 967: RETURN_TRUE;
! 968: }
! 969: /* }}} */
! 970:
! 971: /* {{{ proto void socket_close(resource socket) U
! 972: Closes a file descriptor */
! 973: PHP_FUNCTION(socket_close)
! 974: {
! 975: zval *arg1;
! 976: php_socket *php_sock;
! 977:
! 978: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg1) == FAILURE) {
! 979: return;
! 980: }
! 981:
! 982: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 983: zend_list_delete(Z_RESVAL_P(arg1));
! 984: }
! 985: /* }}} */
! 986:
! 987: /* {{{ proto int socket_write(resource socket, string buf[, int length])
! 988: Writes the buffer to the socket resource, length is optional */
! 989: PHP_FUNCTION(socket_write)
! 990: {
! 991: zval *arg1;
! 992: php_socket *php_sock;
! 993: int retval, str_len;
! 994: long length = 0;
! 995: char *str;
! 996:
! 997: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &arg1, &str, &str_len, &length) == FAILURE) {
! 998: return;
! 999: }
! 1000:
! 1001: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 1002:
! 1003: if (ZEND_NUM_ARGS() < 3) {
! 1004: length = str_len;
! 1005: }
! 1006:
! 1007: #ifndef PHP_WIN32
! 1008: retval = write(php_sock->bsd_socket, str, MIN(length, str_len));
! 1009: #else
! 1010: retval = send(php_sock->bsd_socket, str, min(length, str_len), 0);
! 1011: #endif
! 1012:
! 1013: if (retval < 0) {
! 1014: PHP_SOCKET_ERROR(php_sock, "unable to write to socket", errno);
! 1015: RETURN_FALSE;
! 1016: }
! 1017:
! 1018: RETURN_LONG(retval);
! 1019: }
! 1020: /* }}} */
! 1021:
! 1022: /* {{{ proto string socket_read(resource socket, int length [, int type]) U
! 1023: Reads a maximum of length bytes from socket */
! 1024: PHP_FUNCTION(socket_read)
! 1025: {
! 1026: zval *arg1;
! 1027: php_socket *php_sock;
! 1028: char *tmpbuf;
! 1029: int retval;
! 1030: long length, type = PHP_BINARY_READ;
! 1031:
! 1032: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|l", &arg1, &length, &type) == FAILURE) {
! 1033: return;
! 1034: }
! 1035:
! 1036: /* overflow check */
! 1037: if ((length + 1) < 2) {
! 1038: RETURN_FALSE;
! 1039: }
! 1040:
! 1041: tmpbuf = emalloc(length + 1);
! 1042:
! 1043: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 1044:
! 1045: if (type == PHP_NORMAL_READ) {
! 1046: retval = php_read(php_sock, tmpbuf, length, 0);
! 1047: } else {
! 1048: retval = recv(php_sock->bsd_socket, tmpbuf, length, 0);
! 1049: }
! 1050:
! 1051: if (retval == -1) {
! 1052: /* if the socket is in non-blocking mode and there's no data to read,
! 1053: don't output any error, as this is a normal situation, and not an error */
! 1054: if (errno == EAGAIN
! 1055: #ifdef EWOULDBLOCK
! 1056: || errno == EWOULDBLOCK
! 1057: #endif
! 1058: ) {
! 1059: php_sock->error = errno;
! 1060: SOCKETS_G(last_error) = errno;
! 1061: } else {
! 1062: PHP_SOCKET_ERROR(php_sock, "unable to read from socket", errno);
! 1063: }
! 1064:
! 1065: efree(tmpbuf);
! 1066: RETURN_FALSE;
! 1067: } else if (!retval) {
! 1068: efree(tmpbuf);
! 1069: RETURN_EMPTY_STRING();
! 1070: }
! 1071:
! 1072: tmpbuf = erealloc(tmpbuf, retval + 1);
! 1073: tmpbuf[retval] = '\0' ;
! 1074:
! 1075: RETURN_STRINGL(tmpbuf, retval, 0);
! 1076: }
! 1077: /* }}} */
! 1078:
! 1079: /* {{{ proto bool socket_getsockname(resource socket, string &addr[, int &port])
! 1080: Queries the remote side of the given socket which may either result in host/port or in a UNIX filesystem path, dependent on its type. */
! 1081: PHP_FUNCTION(socket_getsockname)
! 1082: {
! 1083: zval *arg1, *addr, *port = NULL;
! 1084: php_sockaddr_storage sa_storage;
! 1085: php_socket *php_sock;
! 1086: struct sockaddr *sa;
! 1087: struct sockaddr_in *sin;
! 1088: #if HAVE_IPV6
! 1089: struct sockaddr_in6 *sin6;
! 1090: char addr6[INET6_ADDRSTRLEN+1];
! 1091: #endif
! 1092: struct sockaddr_un *s_un;
! 1093: char *addr_string;
! 1094: socklen_t salen = sizeof(php_sockaddr_storage);
! 1095:
! 1096: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz|z", &arg1, &addr, &port) == FAILURE) {
! 1097: return;
! 1098: }
! 1099:
! 1100: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 1101:
! 1102: sa = (struct sockaddr *) &sa_storage;
! 1103:
! 1104: if (getsockname(php_sock->bsd_socket, sa, &salen) != 0) {
! 1105: PHP_SOCKET_ERROR(php_sock, "unable to retrieve socket name", errno);
! 1106: RETURN_FALSE;
! 1107: }
! 1108:
! 1109: switch (sa->sa_family) {
! 1110: #if HAVE_IPV6
! 1111: case AF_INET6:
! 1112: sin6 = (struct sockaddr_in6 *) sa;
! 1113: inet_ntop(AF_INET6, &sin6->sin6_addr, addr6, INET6_ADDRSTRLEN);
! 1114: zval_dtor(addr);
! 1115: ZVAL_STRING(addr, addr6, 1);
! 1116:
! 1117: if (port != NULL) {
! 1118: zval_dtor(port);
! 1119: ZVAL_LONG(port, htons(sin6->sin6_port));
! 1120: }
! 1121: RETURN_TRUE;
! 1122: break;
! 1123: #endif
! 1124: case AF_INET:
! 1125: sin = (struct sockaddr_in *) sa;
! 1126: while (inet_ntoa_lock == 1);
! 1127: inet_ntoa_lock = 1;
! 1128: addr_string = inet_ntoa(sin->sin_addr);
! 1129: inet_ntoa_lock = 0;
! 1130:
! 1131: zval_dtor(addr);
! 1132: ZVAL_STRING(addr, addr_string, 1);
! 1133:
! 1134: if (port != NULL) {
! 1135: zval_dtor(port);
! 1136: ZVAL_LONG(port, htons(sin->sin_port));
! 1137: }
! 1138: RETURN_TRUE;
! 1139: break;
! 1140:
! 1141: case AF_UNIX:
! 1142: s_un = (struct sockaddr_un *) sa;
! 1143:
! 1144: zval_dtor(addr);
! 1145: ZVAL_STRING(addr, s_un->sun_path, 1);
! 1146: RETURN_TRUE;
! 1147: break;
! 1148:
! 1149: default:
! 1150: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported address family %d", sa->sa_family);
! 1151: RETURN_FALSE;
! 1152: }
! 1153: }
! 1154: /* }}} */
! 1155:
! 1156: /* {{{ proto bool socket_getpeername(resource socket, string &addr[, int &port])
! 1157: Queries the remote side of the given socket which may either result in host/port or in a UNIX filesystem path, dependent on its type. */
! 1158: PHP_FUNCTION(socket_getpeername)
! 1159: {
! 1160: zval *arg1, *arg2, *arg3 = NULL;
! 1161: php_sockaddr_storage sa_storage;
! 1162: php_socket *php_sock;
! 1163: struct sockaddr *sa;
! 1164: struct sockaddr_in *sin;
! 1165: #if HAVE_IPV6
! 1166: struct sockaddr_in6 *sin6;
! 1167: char addr6[INET6_ADDRSTRLEN+1];
! 1168: #endif
! 1169: struct sockaddr_un *s_un;
! 1170: char *addr_string;
! 1171: socklen_t salen = sizeof(php_sockaddr_storage);
! 1172:
! 1173: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz|z", &arg1, &arg2, &arg3) == FAILURE) {
! 1174: return;
! 1175: }
! 1176:
! 1177: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 1178:
! 1179: sa = (struct sockaddr *) &sa_storage;
! 1180:
! 1181: if (getpeername(php_sock->bsd_socket, sa, &salen) < 0) {
! 1182: PHP_SOCKET_ERROR(php_sock, "unable to retrieve peer name", errno);
! 1183: RETURN_FALSE;
! 1184: }
! 1185:
! 1186: switch (sa->sa_family) {
! 1187: #if HAVE_IPV6
! 1188: case AF_INET6:
! 1189: sin6 = (struct sockaddr_in6 *) sa;
! 1190: inet_ntop(AF_INET6, &sin6->sin6_addr, addr6, INET6_ADDRSTRLEN);
! 1191: zval_dtor(arg2);
! 1192: ZVAL_STRING(arg2, addr6, 1);
! 1193:
! 1194: if (arg3 != NULL) {
! 1195: zval_dtor(arg3);
! 1196: ZVAL_LONG(arg3, htons(sin6->sin6_port));
! 1197: }
! 1198:
! 1199: RETURN_TRUE;
! 1200: break;
! 1201: #endif
! 1202: case AF_INET:
! 1203: sin = (struct sockaddr_in *) sa;
! 1204: while (inet_ntoa_lock == 1);
! 1205: inet_ntoa_lock = 1;
! 1206: addr_string = inet_ntoa(sin->sin_addr);
! 1207: inet_ntoa_lock = 0;
! 1208:
! 1209: zval_dtor(arg2);
! 1210: ZVAL_STRING(arg2, addr_string, 1);
! 1211:
! 1212: if (arg3 != NULL) {
! 1213: zval_dtor(arg3);
! 1214: ZVAL_LONG(arg3, htons(sin->sin_port));
! 1215: }
! 1216:
! 1217: RETURN_TRUE;
! 1218: break;
! 1219:
! 1220: case AF_UNIX:
! 1221: s_un = (struct sockaddr_un *) sa;
! 1222:
! 1223: zval_dtor(arg2);
! 1224: ZVAL_STRING(arg2, s_un->sun_path, 1);
! 1225: RETURN_TRUE;
! 1226: break;
! 1227:
! 1228: default:
! 1229: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported address family %d", sa->sa_family);
! 1230: RETURN_FALSE;
! 1231: }
! 1232: }
! 1233: /* }}} */
! 1234:
! 1235: /* {{{ proto resource socket_create(int domain, int type, int protocol) U
! 1236: Creates an endpoint for communication in the domain specified by domain, of type specified by type */
! 1237: PHP_FUNCTION(socket_create)
! 1238: {
! 1239: long arg1, arg2, arg3;
! 1240: php_socket *php_sock = (php_socket*)emalloc(sizeof(php_socket));
! 1241:
! 1242: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &arg1, &arg2, &arg3) == FAILURE) {
! 1243: efree(php_sock);
! 1244: return;
! 1245: }
! 1246:
! 1247: if (arg1 != AF_UNIX
! 1248: #if HAVE_IPV6
! 1249: && arg1 != AF_INET6
! 1250: #endif
! 1251: && arg1 != AF_INET) {
! 1252: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid socket domain [%ld] specified for argument 1, assuming AF_INET", arg1);
! 1253: arg1 = AF_INET;
! 1254: }
! 1255:
! 1256: if (arg2 > 10) {
! 1257: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid socket type [%ld] specified for argument 2, assuming SOCK_STREAM", arg2);
! 1258: arg2 = SOCK_STREAM;
! 1259: }
! 1260:
! 1261: php_sock->bsd_socket = socket(arg1, arg2, arg3);
! 1262: php_sock->type = arg1;
! 1263:
! 1264: if (IS_INVALID_SOCKET(php_sock)) {
! 1265: SOCKETS_G(last_error) = errno;
! 1266: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to create socket [%d]: %s", errno, php_strerror(errno TSRMLS_CC));
! 1267: efree(php_sock);
! 1268: RETURN_FALSE;
! 1269: }
! 1270:
! 1271: php_sock->error = 0;
! 1272: php_sock->blocking = 1;
! 1273:
! 1274: ZEND_REGISTER_RESOURCE(return_value, php_sock, le_socket);
! 1275: }
! 1276: /* }}} */
! 1277:
! 1278: /* {{{ proto bool socket_connect(resource socket, string addr [, int port])
! 1279: Opens a connection to addr:port on the socket specified by socket */
! 1280: PHP_FUNCTION(socket_connect)
! 1281: {
! 1282: zval *arg1;
! 1283: php_socket *php_sock;
! 1284: struct sockaddr_in sin;
! 1285: #if HAVE_IPV6
! 1286: struct sockaddr_in6 sin6;
! 1287: #endif
! 1288: struct sockaddr_un s_un;
! 1289: char *addr;
! 1290: int retval, addr_len;
! 1291: long port = 0;
! 1292: int argc = ZEND_NUM_ARGS();
! 1293:
! 1294: if (zend_parse_parameters(argc TSRMLS_CC, "rs|l", &arg1, &addr, &addr_len, &port) == FAILURE) {
! 1295: return;
! 1296: }
! 1297:
! 1298: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 1299:
! 1300: switch(php_sock->type) {
! 1301: #if HAVE_IPV6
! 1302: case AF_INET6:
! 1303: if (argc != 3) {
! 1304: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Socket of type AF_INET6 requires 3 arguments");
! 1305: RETURN_FALSE;
! 1306: }
! 1307:
! 1308: memset(&sin6, 0, sizeof(struct sockaddr_in6));
! 1309:
! 1310: sin6.sin6_family = AF_INET6;
! 1311: sin6.sin6_port = htons((unsigned short int)port);
! 1312:
! 1313: if (! php_set_inet6_addr(&sin6, addr, php_sock TSRMLS_CC)) {
! 1314: RETURN_FALSE;
! 1315: }
! 1316:
! 1317: retval = connect(php_sock->bsd_socket, (struct sockaddr *)&sin6, sizeof(struct sockaddr_in6));
! 1318: break;
! 1319: #endif
! 1320: case AF_INET:
! 1321: if (argc != 3) {
! 1322: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Socket of type AF_INET requires 3 arguments");
! 1323: RETURN_FALSE;
! 1324: }
! 1325:
! 1326: memset(&sin, 0, sizeof(struct sockaddr_in));
! 1327:
! 1328: sin.sin_family = AF_INET;
! 1329: sin.sin_port = htons((unsigned short int)port);
! 1330:
! 1331: if (! php_set_inet_addr(&sin, addr, php_sock TSRMLS_CC)) {
! 1332: RETURN_FALSE;
! 1333: }
! 1334:
! 1335: retval = connect(php_sock->bsd_socket, (struct sockaddr *)&sin, sizeof(struct sockaddr_in));
! 1336: break;
! 1337:
! 1338: case AF_UNIX:
! 1339: if (addr_len >= sizeof(s_un.sun_path)) {
! 1340: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Path too long");
! 1341: RETURN_FALSE;
! 1342: }
! 1343:
! 1344: memset(&s_un, 0, sizeof(struct sockaddr_un));
! 1345:
! 1346: s_un.sun_family = AF_UNIX;
! 1347: memcpy(&s_un.sun_path, addr, addr_len);
! 1348: retval = connect(php_sock->bsd_socket, (struct sockaddr *) &s_un, (socklen_t) XtOffsetOf(struct sockaddr_un, sun_path) + addr_len);
! 1349: break;
! 1350:
! 1351: default:
! 1352: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported socket type %d", php_sock->type);
! 1353: RETURN_FALSE;
! 1354: }
! 1355:
! 1356: if (retval != 0) {
! 1357: PHP_SOCKET_ERROR(php_sock, "unable to connect", errno);
! 1358: RETURN_FALSE;
! 1359: }
! 1360:
! 1361: RETURN_TRUE;
! 1362: }
! 1363: /* }}} */
! 1364:
! 1365: /* {{{ proto string socket_strerror(int errno)
! 1366: Returns a string describing an error */
! 1367: PHP_FUNCTION(socket_strerror)
! 1368: {
! 1369: long arg1;
! 1370:
! 1371: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &arg1) == FAILURE) {
! 1372: return;
! 1373: }
! 1374:
! 1375: RETURN_STRING(php_strerror(arg1 TSRMLS_CC), 1);
! 1376: }
! 1377: /* }}} */
! 1378:
! 1379: /* {{{ proto bool socket_bind(resource socket, string addr [, int port])
! 1380: Binds an open socket to a listening port, port is only specified in AF_INET family. */
! 1381: PHP_FUNCTION(socket_bind)
! 1382: {
! 1383: zval *arg1;
! 1384: php_sockaddr_storage sa_storage;
! 1385: struct sockaddr *sock_type = (struct sockaddr*) &sa_storage;
! 1386: php_socket *php_sock;
! 1387: char *addr;
! 1388: int addr_len;
! 1389: long port = 0;
! 1390: long retval = 0;
! 1391:
! 1392: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &arg1, &addr, &addr_len, &port) == FAILURE) {
! 1393: return;
! 1394: }
! 1395:
! 1396: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 1397:
! 1398: switch(php_sock->type) {
! 1399: case AF_UNIX:
! 1400: {
! 1401: struct sockaddr_un *sa = (struct sockaddr_un *) sock_type;
! 1402: memset(sa, 0, sizeof(sa_storage));
! 1403: sa->sun_family = AF_UNIX;
! 1404: snprintf(sa->sun_path, 108, "%s", addr);
! 1405: retval = bind(php_sock->bsd_socket, (struct sockaddr *) sa, SUN_LEN(sa));
! 1406: break;
! 1407: }
! 1408:
! 1409: case AF_INET:
! 1410: {
! 1411: struct sockaddr_in *sa = (struct sockaddr_in *) sock_type;
! 1412:
! 1413: memset(sa, 0, sizeof(sa_storage)); /* Apparently, Mac OSX needs this */
! 1414:
! 1415: sa->sin_family = AF_INET;
! 1416: sa->sin_port = htons((unsigned short) port);
! 1417:
! 1418: if (! php_set_inet_addr(sa, addr, php_sock TSRMLS_CC)) {
! 1419: RETURN_FALSE;
! 1420: }
! 1421:
! 1422: retval = bind(php_sock->bsd_socket, (struct sockaddr *)sa, sizeof(struct sockaddr_in));
! 1423: break;
! 1424: }
! 1425: #if HAVE_IPV6
! 1426: case AF_INET6:
! 1427: {
! 1428: struct sockaddr_in6 *sa = (struct sockaddr_in6 *) sock_type;
! 1429:
! 1430: memset(sa, 0, sizeof(sa_storage)); /* Apparently, Mac OSX needs this */
! 1431:
! 1432: sa->sin6_family = AF_INET6;
! 1433: sa->sin6_port = htons((unsigned short) port);
! 1434:
! 1435: if (! php_set_inet6_addr(sa, addr, php_sock TSRMLS_CC)) {
! 1436: RETURN_FALSE;
! 1437: }
! 1438:
! 1439: retval = bind(php_sock->bsd_socket, (struct sockaddr *)sa, sizeof(struct sockaddr_in6));
! 1440: break;
! 1441: }
! 1442: #endif
! 1443: default:
! 1444: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unsupported socket type '%d', must be AF_UNIX, AF_INET, or AF_INET6", php_sock->type);
! 1445: RETURN_FALSE;
! 1446: }
! 1447:
! 1448: if (retval != 0) {
! 1449: PHP_SOCKET_ERROR(php_sock, "unable to bind address", errno);
! 1450: RETURN_FALSE;
! 1451: }
! 1452:
! 1453: RETURN_TRUE;
! 1454: }
! 1455: /* }}} */
! 1456:
! 1457: /* {{{ proto int socket_recv(resource socket, string &buf, int len, int flags)
! 1458: Receives data from a connected socket */
! 1459: PHP_FUNCTION(socket_recv)
! 1460: {
! 1461: zval *php_sock_res, *buf;
! 1462: char *recv_buf;
! 1463: php_socket *php_sock;
! 1464: int retval;
! 1465: long len, flags;
! 1466:
! 1467: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzll", &php_sock_res, &buf, &len, &flags) == FAILURE) {
! 1468: return;
! 1469: }
! 1470:
! 1471: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &php_sock_res, -1, le_socket_name, le_socket);
! 1472:
! 1473: /* overflow check */
! 1474: if ((len + 1) < 2) {
! 1475: RETURN_FALSE;
! 1476: }
! 1477:
! 1478: recv_buf = emalloc(len + 1);
! 1479: memset(recv_buf, 0, len + 1);
! 1480:
! 1481: if ((retval = recv(php_sock->bsd_socket, recv_buf, len, flags)) < 1) {
! 1482: efree(recv_buf);
! 1483:
! 1484: zval_dtor(buf);
! 1485: Z_TYPE_P(buf) = IS_NULL;
! 1486: } else {
! 1487: recv_buf[retval] = '\0';
! 1488:
! 1489: /* Rebuild buffer zval */
! 1490: zval_dtor(buf);
! 1491:
! 1492: Z_STRVAL_P(buf) = recv_buf;
! 1493: Z_STRLEN_P(buf) = retval;
! 1494: Z_TYPE_P(buf) = IS_STRING;
! 1495: }
! 1496:
! 1497: if (retval == -1) {
! 1498: PHP_SOCKET_ERROR(php_sock, "unable to read from socket", errno);
! 1499: RETURN_FALSE;
! 1500: }
! 1501:
! 1502: RETURN_LONG(retval);
! 1503: }
! 1504: /* }}} */
! 1505:
! 1506: /* {{{ proto int socket_send(resource socket, string buf, int len, int flags)
! 1507: Sends data to a connected socket */
! 1508: PHP_FUNCTION(socket_send)
! 1509: {
! 1510: zval *arg1;
! 1511: php_socket *php_sock;
! 1512: int buf_len, retval;
! 1513: long len, flags;
! 1514: char *buf;
! 1515:
! 1516: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsll", &arg1, &buf, &buf_len, &len, &flags) == FAILURE) {
! 1517: return;
! 1518: }
! 1519:
! 1520: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 1521:
! 1522: retval = send(php_sock->bsd_socket, buf, (buf_len < len ? buf_len : len), flags);
! 1523:
! 1524: if (retval == -1) {
! 1525: PHP_SOCKET_ERROR(php_sock, "unable to write to socket", errno);
! 1526: RETURN_FALSE;
! 1527: }
! 1528:
! 1529: RETURN_LONG(retval);
! 1530: }
! 1531: /* }}} */
! 1532:
! 1533: /* {{{ proto int socket_recvfrom(resource socket, string &buf, int len, int flags, string &name [, int &port])
! 1534: Receives data from a socket, connected or not */
! 1535: PHP_FUNCTION(socket_recvfrom)
! 1536: {
! 1537: zval *arg1, *arg2, *arg5, *arg6 = NULL;
! 1538: php_socket *php_sock;
! 1539: struct sockaddr_un s_un;
! 1540: struct sockaddr_in sin;
! 1541: #if HAVE_IPV6
! 1542: struct sockaddr_in6 sin6;
! 1543: char addr6[INET6_ADDRSTRLEN];
! 1544: #endif
! 1545: socklen_t slen;
! 1546: int retval;
! 1547: long arg3, arg4;
! 1548: char *recv_buf, *address;
! 1549:
! 1550: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzllz|z", &arg1, &arg2, &arg3, &arg4, &arg5, &arg6) == FAILURE) {
! 1551: return;
! 1552: }
! 1553:
! 1554: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 1555:
! 1556: /* overflow check */
! 1557: if ((arg3 + 2) < 3) {
! 1558: RETURN_FALSE;
! 1559: }
! 1560:
! 1561: recv_buf = emalloc(arg3 + 2);
! 1562: memset(recv_buf, 0, arg3 + 2);
! 1563:
! 1564: switch (php_sock->type) {
! 1565: case AF_UNIX:
! 1566: slen = sizeof(s_un);
! 1567: s_un.sun_family = AF_UNIX;
! 1568: retval = recvfrom(php_sock->bsd_socket, recv_buf, arg3, arg4, (struct sockaddr *)&s_un, (socklen_t *)&slen);
! 1569:
! 1570: if (retval < 0) {
! 1571: efree(recv_buf);
! 1572: PHP_SOCKET_ERROR(php_sock, "unable to recvfrom", errno);
! 1573: RETURN_FALSE;
! 1574: }
! 1575:
! 1576: zval_dtor(arg2);
! 1577: zval_dtor(arg5);
! 1578:
! 1579: ZVAL_STRINGL(arg2, recv_buf, retval, 0);
! 1580: ZVAL_STRING(arg5, s_un.sun_path, 1);
! 1581: break;
! 1582:
! 1583: case AF_INET:
! 1584: slen = sizeof(sin);
! 1585: memset(&sin, 0, slen);
! 1586: sin.sin_family = AF_INET;
! 1587:
! 1588: if (arg6 == NULL) {
! 1589: efree(recv_buf);
! 1590: WRONG_PARAM_COUNT;
! 1591: }
! 1592:
! 1593: retval = recvfrom(php_sock->bsd_socket, recv_buf, arg3, arg4, (struct sockaddr *)&sin, (socklen_t *)&slen);
! 1594:
! 1595: if (retval < 0) {
! 1596: efree(recv_buf);
! 1597: PHP_SOCKET_ERROR(php_sock, "unable to recvfrom", errno);
! 1598: RETURN_FALSE;
! 1599: }
! 1600:
! 1601: zval_dtor(arg2);
! 1602: zval_dtor(arg5);
! 1603: zval_dtor(arg6);
! 1604:
! 1605: address = inet_ntoa(sin.sin_addr);
! 1606:
! 1607: ZVAL_STRINGL(arg2, recv_buf, retval, 0);
! 1608: ZVAL_STRING(arg5, address ? address : "0.0.0.0", 1);
! 1609: ZVAL_LONG(arg6, ntohs(sin.sin_port));
! 1610: break;
! 1611: #if HAVE_IPV6
! 1612: case AF_INET6:
! 1613: slen = sizeof(sin6);
! 1614: memset(&sin6, 0, slen);
! 1615: sin6.sin6_family = AF_INET6;
! 1616:
! 1617: if (arg6 == NULL) {
! 1618: efree(recv_buf);
! 1619: WRONG_PARAM_COUNT;
! 1620: }
! 1621:
! 1622: retval = recvfrom(php_sock->bsd_socket, recv_buf, arg3, arg4, (struct sockaddr *)&sin6, (socklen_t *)&slen);
! 1623:
! 1624: if (retval < 0) {
! 1625: efree(recv_buf);
! 1626: PHP_SOCKET_ERROR(php_sock, "unable to recvfrom", errno);
! 1627: RETURN_FALSE;
! 1628: }
! 1629:
! 1630: zval_dtor(arg2);
! 1631: zval_dtor(arg5);
! 1632: zval_dtor(arg6);
! 1633:
! 1634: memset(addr6, 0, INET6_ADDRSTRLEN);
! 1635: inet_ntop(AF_INET6, &sin6.sin6_addr, addr6, INET6_ADDRSTRLEN);
! 1636:
! 1637: ZVAL_STRINGL(arg2, recv_buf, retval, 0);
! 1638: ZVAL_STRING(arg5, addr6[0] ? addr6 : "::", 1);
! 1639: ZVAL_LONG(arg6, ntohs(sin6.sin6_port));
! 1640: break;
! 1641: #endif
! 1642: default:
! 1643: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported socket type %d", php_sock->type);
! 1644: RETURN_FALSE;
! 1645: }
! 1646:
! 1647: RETURN_LONG(retval);
! 1648: }
! 1649: /* }}} */
! 1650:
! 1651: /* {{{ proto int socket_sendto(resource socket, string buf, int len, int flags, string addr [, int port])
! 1652: Sends a message to a socket, whether it is connected or not */
! 1653: PHP_FUNCTION(socket_sendto)
! 1654: {
! 1655: zval *arg1;
! 1656: php_socket *php_sock;
! 1657: struct sockaddr_un s_un;
! 1658: struct sockaddr_in sin;
! 1659: #if HAVE_IPV6
! 1660: struct sockaddr_in6 sin6;
! 1661: #endif
! 1662: int retval, buf_len, addr_len;
! 1663: long len, flags, port = 0;
! 1664: char *buf, *addr;
! 1665: int argc = ZEND_NUM_ARGS();
! 1666:
! 1667: if (zend_parse_parameters(argc TSRMLS_CC, "rslls|l", &arg1, &buf, &buf_len, &len, &flags, &addr, &addr_len, &port) == FAILURE) {
! 1668: return;
! 1669: }
! 1670:
! 1671: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 1672:
! 1673: switch (php_sock->type) {
! 1674: case AF_UNIX:
! 1675: memset(&s_un, 0, sizeof(s_un));
! 1676: s_un.sun_family = AF_UNIX;
! 1677: snprintf(s_un.sun_path, 108, "%s", addr);
! 1678:
! 1679: retval = sendto(php_sock->bsd_socket, buf, (len > buf_len) ? buf_len : len, flags, (struct sockaddr *) &s_un, SUN_LEN(&s_un));
! 1680: break;
! 1681:
! 1682: case AF_INET:
! 1683: if (argc != 6) {
! 1684: WRONG_PARAM_COUNT;
! 1685: }
! 1686:
! 1687: memset(&sin, 0, sizeof(sin));
! 1688: sin.sin_family = AF_INET;
! 1689: sin.sin_port = htons((unsigned short) port);
! 1690:
! 1691: if (! php_set_inet_addr(&sin, addr, php_sock TSRMLS_CC)) {
! 1692: RETURN_FALSE;
! 1693: }
! 1694:
! 1695: retval = sendto(php_sock->bsd_socket, buf, (len > buf_len) ? buf_len : len, flags, (struct sockaddr *) &sin, sizeof(sin));
! 1696: break;
! 1697: #if HAVE_IPV6
! 1698: case AF_INET6:
! 1699: if (argc != 6) {
! 1700: WRONG_PARAM_COUNT;
! 1701: }
! 1702:
! 1703: memset(&sin6, 0, sizeof(sin6));
! 1704: sin6.sin6_family = AF_INET6;
! 1705: sin6.sin6_port = htons((unsigned short) port);
! 1706:
! 1707: if (! php_set_inet6_addr(&sin6, addr, php_sock TSRMLS_CC)) {
! 1708: RETURN_FALSE;
! 1709: }
! 1710:
! 1711: retval = sendto(php_sock->bsd_socket, buf, (len > buf_len) ? buf_len : len, flags, (struct sockaddr *) &sin6, sizeof(sin6));
! 1712: break;
! 1713: #endif
! 1714: default:
! 1715: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported socket type %d", php_sock->type);
! 1716: RETURN_FALSE;
! 1717: }
! 1718:
! 1719: if (retval == -1) {
! 1720: PHP_SOCKET_ERROR(php_sock, "unable to write to socket", errno);
! 1721: RETURN_FALSE;
! 1722: }
! 1723:
! 1724: RETURN_LONG(retval);
! 1725: }
! 1726: /* }}} */
! 1727:
! 1728: /* {{{ proto mixed socket_get_option(resource socket, int level, int optname) U
! 1729: Gets socket options for the socket */
! 1730: PHP_FUNCTION(socket_get_option)
! 1731: {
! 1732: zval *arg1;
! 1733: struct linger linger_val;
! 1734: struct timeval tv;
! 1735: #ifdef PHP_WIN32
! 1736: int timeout = 0;
! 1737: #endif
! 1738: socklen_t optlen;
! 1739: php_socket *php_sock;
! 1740: int other_val;
! 1741: long level, optname;
! 1742:
! 1743: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &arg1, &level, &optname) == FAILURE) {
! 1744: return;
! 1745: }
! 1746:
! 1747: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 1748:
! 1749: switch(optname) {
! 1750: case SO_LINGER:
! 1751: optlen = sizeof(linger_val);
! 1752:
! 1753: if (getsockopt(php_sock->bsd_socket, level, optname, (char*)&linger_val, &optlen) != 0) {
! 1754: PHP_SOCKET_ERROR(php_sock, "unable to retrieve socket option", errno);
! 1755: RETURN_FALSE;
! 1756: }
! 1757:
! 1758: array_init(return_value);
! 1759: add_assoc_long(return_value, "l_onoff", linger_val.l_onoff);
! 1760: add_assoc_long(return_value, "l_linger", linger_val.l_linger);
! 1761: break;
! 1762:
! 1763: case SO_RCVTIMEO:
! 1764: case SO_SNDTIMEO:
! 1765: #ifndef PHP_WIN32
! 1766: optlen = sizeof(tv);
! 1767:
! 1768: if (getsockopt(php_sock->bsd_socket, level, optname, (char*)&tv, &optlen) != 0) {
! 1769: PHP_SOCKET_ERROR(php_sock, "unable to retrieve socket option", errno);
! 1770: RETURN_FALSE;
! 1771: }
! 1772: #else
! 1773: optlen = sizeof(int);
! 1774:
! 1775: if (getsockopt(php_sock->bsd_socket, level, optname, (char*)&timeout, &optlen) != 0) {
! 1776: PHP_SOCKET_ERROR(php_sock, "unable to retrieve socket option", errno);
! 1777: RETURN_FALSE;
! 1778: }
! 1779:
! 1780: tv.tv_sec = timeout ? timeout / 1000 : 0;
! 1781: tv.tv_usec = timeout ? (timeout * 1000) % 1000000 : 0;
! 1782: #endif
! 1783:
! 1784: array_init(return_value);
! 1785:
! 1786: add_assoc_long(return_value, "sec", tv.tv_sec);
! 1787: add_assoc_long(return_value, "usec", tv.tv_usec);
! 1788: break;
! 1789:
! 1790: default:
! 1791: optlen = sizeof(other_val);
! 1792:
! 1793: if (getsockopt(php_sock->bsd_socket, level, optname, (char*)&other_val, &optlen) != 0) {
! 1794: PHP_SOCKET_ERROR(php_sock, "unable to retrieve socket option", errno);
! 1795: RETURN_FALSE;
! 1796: }
! 1797:
! 1798: RETURN_LONG(other_val);
! 1799: break;
! 1800: }
! 1801: }
! 1802: /* }}} */
! 1803:
! 1804: /* {{{ proto bool socket_set_option(resource socket, int level, int optname, int|array optval)
! 1805: Sets socket options for the socket */
! 1806: PHP_FUNCTION(socket_set_option)
! 1807: {
! 1808: zval *arg1, **arg4;
! 1809: struct linger lv;
! 1810: php_socket *php_sock;
! 1811: int ov, optlen, retval;
! 1812: #ifdef PHP_WIN32
! 1813: int timeout;
! 1814: #else
! 1815: struct timeval tv;
! 1816: #endif
! 1817: long level, optname;
! 1818: void *opt_ptr;
! 1819: HashTable *opt_ht;
! 1820: zval **l_onoff, **l_linger;
! 1821: zval **sec, **usec;
! 1822: /* key name constants */
! 1823: char *l_onoff_key = "l_onoff";
! 1824: char *l_linger_key = "l_linger";
! 1825: char *sec_key = "sec";
! 1826: char *usec_key = "usec";
! 1827:
! 1828: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllZ", &arg1, &level, &optname, &arg4) == FAILURE) {
! 1829: return;
! 1830: }
! 1831:
! 1832: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
! 1833:
! 1834: set_errno(0);
! 1835:
! 1836: switch (optname) {
! 1837: case SO_LINGER:
! 1838: convert_to_array_ex(arg4);
! 1839: opt_ht = HASH_OF(*arg4);
! 1840:
! 1841: if (zend_hash_find(opt_ht, l_onoff_key, strlen(l_onoff_key) + 1, (void **)&l_onoff) == FAILURE) {
! 1842: php_error_docref(NULL TSRMLS_CC, E_WARNING, "no key \"%s\" passed in optval", l_onoff_key);
! 1843: RETURN_FALSE;
! 1844: }
! 1845: if (zend_hash_find(opt_ht, l_linger_key, strlen(l_linger_key) + 1, (void **)&l_linger) == FAILURE) {
! 1846: php_error_docref(NULL TSRMLS_CC, E_WARNING, "no key \"%s\" passed in optval", l_linger_key);
! 1847: RETURN_FALSE;
! 1848: }
! 1849:
! 1850: convert_to_long_ex(l_onoff);
! 1851: convert_to_long_ex(l_linger);
! 1852:
! 1853: lv.l_onoff = (unsigned short)Z_LVAL_PP(l_onoff);
! 1854: lv.l_linger = (unsigned short)Z_LVAL_PP(l_linger);
! 1855:
! 1856: optlen = sizeof(lv);
! 1857: opt_ptr = &lv;
! 1858: break;
! 1859:
! 1860: case SO_RCVTIMEO:
! 1861: case SO_SNDTIMEO:
! 1862: convert_to_array_ex(arg4);
! 1863: opt_ht = HASH_OF(*arg4);
! 1864:
! 1865: if (zend_hash_find(opt_ht, sec_key, strlen(sec_key) + 1, (void **)&sec) == FAILURE) {
! 1866: php_error_docref(NULL TSRMLS_CC, E_WARNING, "no key \"%s\" passed in optval", sec_key);
! 1867: RETURN_FALSE;
! 1868: }
! 1869: if (zend_hash_find(opt_ht, usec_key, strlen(usec_key) + 1, (void **)&usec) == FAILURE) {
! 1870: php_error_docref(NULL TSRMLS_CC, E_WARNING, "no key \"%s\" passed in optval", usec_key);
! 1871: RETURN_FALSE;
! 1872: }
! 1873:
! 1874: convert_to_long_ex(sec);
! 1875: convert_to_long_ex(usec);
! 1876: #ifndef PHP_WIN32
! 1877: tv.tv_sec = Z_LVAL_PP(sec);
! 1878: tv.tv_usec = Z_LVAL_PP(usec);
! 1879: optlen = sizeof(tv);
! 1880: opt_ptr = &tv;
! 1881: #else
! 1882: timeout = Z_LVAL_PP(sec) * 1000 + Z_LVAL_PP(usec) / 1000;
! 1883: optlen = sizeof(int);
! 1884: opt_ptr = &timeout;
! 1885: #endif
! 1886: break;
! 1887:
! 1888: default:
! 1889: convert_to_long_ex(arg4);
! 1890: ov = Z_LVAL_PP(arg4);
! 1891:
! 1892: optlen = sizeof(ov);
! 1893: opt_ptr = &ov;
! 1894: break;
! 1895: }
! 1896:
! 1897: retval = setsockopt(php_sock->bsd_socket, level, optname, opt_ptr, optlen);
! 1898:
! 1899: if (retval != 0) {
! 1900: PHP_SOCKET_ERROR(php_sock, "unable to set socket option", errno);
! 1901: RETURN_FALSE;
! 1902: }
! 1903:
! 1904: RETURN_TRUE;
! 1905: }
! 1906: /* }}} */
! 1907:
! 1908: #ifdef HAVE_SOCKETPAIR
! 1909: /* {{{ proto bool socket_create_pair(int domain, int type, int protocol, array &fd) U
! 1910: Creates a pair of indistinguishable sockets and stores them in fds. */
! 1911: PHP_FUNCTION(socket_create_pair)
! 1912: {
! 1913: zval *retval[2], *fds_array_zval;
! 1914: php_socket *php_sock[2];
! 1915: PHP_SOCKET fds_array[2];
! 1916: long domain, type, protocol;
! 1917:
! 1918: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lllz", &domain, &type, &protocol, &fds_array_zval) == FAILURE) {
! 1919: return;
! 1920: }
! 1921:
! 1922: php_sock[0] = (php_socket*)emalloc(sizeof(php_socket));
! 1923: php_sock[1] = (php_socket*)emalloc(sizeof(php_socket));
! 1924:
! 1925: if (domain != AF_INET
! 1926: #if HAVE_IPV6
! 1927: && domain != AF_INET6
! 1928: #endif
! 1929: && domain != AF_UNIX) {
! 1930: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid socket domain [%ld] specified for argument 1, assuming AF_INET", domain);
! 1931: domain = AF_INET;
! 1932: }
! 1933:
! 1934: if (type > 10) {
! 1935: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid socket type [%ld] specified for argument 2, assuming SOCK_STREAM", type);
! 1936: type = SOCK_STREAM;
! 1937: }
! 1938:
! 1939: if (socketpair(domain, type, protocol, fds_array) != 0) {
! 1940: SOCKETS_G(last_error) = errno;
! 1941: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to create socket pair [%d]: %s", errno, php_strerror(errno TSRMLS_CC));
! 1942: efree(php_sock[0]);
! 1943: efree(php_sock[1]);
! 1944: RETURN_FALSE;
! 1945: }
! 1946:
! 1947: zval_dtor(fds_array_zval);
! 1948: array_init(fds_array_zval);
! 1949:
! 1950: MAKE_STD_ZVAL(retval[0]);
! 1951: MAKE_STD_ZVAL(retval[1]);
! 1952:
! 1953: php_sock[0]->bsd_socket = fds_array[0];
! 1954: php_sock[1]->bsd_socket = fds_array[1];
! 1955: php_sock[0]->type = domain;
! 1956: php_sock[1]->type = domain;
! 1957: php_sock[0]->error = 0;
! 1958: php_sock[1]->error = 0;
! 1959: php_sock[0]->blocking = 1;
! 1960: php_sock[1]->blocking = 1;
! 1961:
! 1962: ZEND_REGISTER_RESOURCE(retval[0], php_sock[0], le_socket);
! 1963: ZEND_REGISTER_RESOURCE(retval[1], php_sock[1], le_socket);
! 1964:
! 1965: add_index_zval(fds_array_zval, 0, retval[0]);
! 1966: add_index_zval(fds_array_zval, 1, retval[1]);
! 1967:
! 1968: RETURN_TRUE;
! 1969: }
! 1970: /* }}} */
! 1971: #endif
! 1972:
! 1973: #ifdef HAVE_SHUTDOWN
! 1974: /* {{{ proto bool socket_shutdown(resource socket[, int how]) U
! 1975: Shuts down a socket for receiving, sending, or both. */
! 1976: PHP_FUNCTION(socket_shutdown)
! 1977: {
! 1978: zval *arg1;
! 1979: long how_shutdown = 2;
! 1980: php_socket *php_sock;
! 1981:
! 1982: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &arg1, &how_shutdown) == FAILURE) {
! 1983: return;
! 1984: }
! 1985:
! 1986: ZEND_FETCH_RESOURCE(php_sock, php_socket*, &arg1, -1, le_socket_name, le_socket);
! 1987:
! 1988: if (shutdown(php_sock->bsd_socket, how_shutdown) != 0) {
! 1989: PHP_SOCKET_ERROR(php_sock, "unable to shutdown socket", errno);
! 1990: RETURN_FALSE;
! 1991: }
! 1992:
! 1993: RETURN_TRUE;
! 1994: }
! 1995: /* }}} */
! 1996: #endif
! 1997:
! 1998: /* {{{ proto int socket_last_error([resource socket]) U
! 1999: Returns the last socket error (either the last used or the provided socket resource) */
! 2000: PHP_FUNCTION(socket_last_error)
! 2001: {
! 2002: zval *arg1 = NULL;
! 2003: php_socket *php_sock;
! 2004:
! 2005: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &arg1) == FAILURE) {
! 2006: return;
! 2007: }
! 2008:
! 2009: if (arg1) {
! 2010: ZEND_FETCH_RESOURCE(php_sock, php_socket*, &arg1, -1, le_socket_name, le_socket);
! 2011: RETVAL_LONG(php_sock->error);
! 2012: } else {
! 2013: RETVAL_LONG(SOCKETS_G(last_error));
! 2014: }
! 2015: }
! 2016: /* }}} */
! 2017:
! 2018: /* {{{ proto void socket_clear_error([resource socket]) U
! 2019: Clears the error on the socket or the last error code. */
! 2020: PHP_FUNCTION(socket_clear_error)
! 2021: {
! 2022: zval *arg1 = NULL;
! 2023: php_socket *php_sock;
! 2024:
! 2025: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &arg1) == FAILURE) {
! 2026: return;
! 2027: }
! 2028:
! 2029: if (arg1) {
! 2030: ZEND_FETCH_RESOURCE(php_sock, php_socket*, &arg1, -1, le_socket_name, le_socket);
! 2031: php_sock->error = 0;
! 2032: } else {
! 2033: SOCKETS_G(last_error) = 0;
! 2034: }
! 2035:
! 2036: return;
! 2037: }
! 2038: /* }}} */
! 2039:
! 2040: #endif
! 2041:
! 2042: /*
! 2043: * Local variables:
! 2044: * tab-width: 4
! 2045: * c-basic-offset: 4
! 2046: * End:
! 2047: * vim600: fdm=marker
! 2048: * vim: noet sw=4 ts=4
! 2049: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sockets.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / sockets