Annotation of embedaddon/php/ext/sockets/sockets.c, revision 1.1.1.3
1.1 misho 1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
1.1.1.3 ! misho 5: | Copyright (c) 1997-2013 The PHP Group |
1.1 misho 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> |
1.1.1.2 misho 18: | Gustavo Lopes <cataphract@php.net> |
1.1 misho 19: | WinSock: Daniel Beulshausen <daniel@php4win.de> |
20: +----------------------------------------------------------------------+
21: */
22:
1.1.1.2 misho 23: /* $Id$ */
1.1 misho 24:
25: #ifdef HAVE_CONFIG_H
26: #include "config.h"
27: #endif
28:
29: #include "php.h"
30:
31: #if HAVE_SOCKETS
32:
33: #include "php_network.h"
34: #include "ext/standard/file.h"
35: #include "ext/standard/info.h"
36: #include "php_ini.h"
37: #ifdef PHP_WIN32
38: # include "win32/inet.h"
39: # include <winsock2.h>
40: # include <windows.h>
41: # include <Ws2tcpip.h>
42: # include "php_sockets.h"
43: # include "win32/sockets.h"
44: # define IS_INVALID_SOCKET(a) (a->bsd_socket == INVALID_SOCKET)
45: # ifdef EPROTONOSUPPORT
46: # undef EPROTONOSUPPORT
47: # endif
48: # ifdef ECONNRESET
49: # undef ECONNRESET
50: # endif
51: # define EPROTONOSUPPORT WSAEPROTONOSUPPORT
52: # define ECONNRESET WSAECONNRESET
53: # ifdef errno
54: # undef errno
55: # endif
56: # define errno WSAGetLastError()
57: # define h_errno WSAGetLastError()
58: # define set_errno(a) WSASetLastError(a)
59: # define close(a) closesocket(a)
1.1.1.2 misho 60: # if _WIN32_WINNT >= 0x0600 && SOCKETS_ENABLE_VISTA_API
61: # define HAVE_IF_NAMETOINDEX 1
62: # endif
1.1 misho 63: #else
64: # include <sys/types.h>
65: # include <sys/socket.h>
66: # include <netdb.h>
67: # include <netinet/in.h>
68: # include <netinet/tcp.h>
69: # include <sys/un.h>
70: # include <arpa/inet.h>
71: # include <sys/time.h>
72: # include <unistd.h>
73: # include <errno.h>
74: # include <fcntl.h>
75: # include <signal.h>
76: # include <sys/uio.h>
77: # define IS_INVALID_SOCKET(a) (a->bsd_socket < 0)
78: # define set_errno(a) (errno = a)
79: # include "php_sockets.h"
1.1.1.3 ! misho 80: # if defined(_AIX) && !defined(HAVE_SA_SS_FAMILY)
! 81: # define ss_family __ss_family
! 82: # endif
1.1.1.2 misho 83: # if HAVE_IF_NAMETOINDEX
84: # include <net/if.h>
85: # endif
1.1 misho 86: #endif
87:
1.1.1.2 misho 88: #include "multicast.h"
89:
1.1 misho 90: ZEND_DECLARE_MODULE_GLOBALS(sockets)
91: static PHP_GINIT_FUNCTION(sockets);
92:
93: #ifndef MSG_WAITALL
94: #ifdef LINUX
95: #define MSG_WAITALL 0x00000100
96: #else
97: #define MSG_WAITALL 0x00000000
98: #endif
99: #endif
100:
101: #ifndef MSG_EOF
102: #ifdef MSG_FIN
103: #define MSG_EOF MSG_FIN
104: #endif
105: #endif
106:
107: #ifndef SUN_LEN
108: #define SUN_LEN(su) (sizeof(*(su)) - sizeof((su)->sun_path) + strlen((su)->sun_path))
109: #endif
110:
111: #ifndef PF_INET
112: #define PF_INET AF_INET
113: #endif
114:
115: static char *php_strerror(int error TSRMLS_DC);
116:
1.1.1.3 ! misho 117: #define PHP_SOCKET_ERROR(socket, msg, errn) \
! 118: do { \
! 119: int _err = (errn); /* save value to avoid repeated calls to WSAGetLastError() on Windows */ \
! 120: (socket)->error = _err; \
! 121: SOCKETS_G(last_error) = _err; \
! 122: php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s [%d]: %s", msg, _err, php_strerror(_err TSRMLS_CC)); \
! 123: } while (0)
! 124:
1.1 misho 125: #define PHP_NORMAL_READ 0x0001
126: #define PHP_BINARY_READ 0x0002
127:
128: static int le_socket;
129: #define le_socket_name php_sockets_le_socket_name
130:
131: /* {{{ arginfo */
132: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_select, 0, 0, 4)
133: ZEND_ARG_INFO(1, read_fds)
134: ZEND_ARG_INFO(1, write_fds)
135: ZEND_ARG_INFO(1, except_fds)
136: ZEND_ARG_INFO(0, tv_sec)
137: ZEND_ARG_INFO(0, tv_usec)
138: ZEND_END_ARG_INFO()
139:
140: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_create_listen, 0, 0, 1)
141: ZEND_ARG_INFO(0, port)
142: ZEND_ARG_INFO(0, backlog)
143: ZEND_END_ARG_INFO()
144:
145: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_accept, 0, 0, 1)
146: ZEND_ARG_INFO(0, socket)
147: ZEND_END_ARG_INFO()
148:
149: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_set_nonblock, 0, 0, 1)
150: ZEND_ARG_INFO(0, socket)
151: ZEND_END_ARG_INFO()
152:
153: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_set_block, 0, 0, 1)
154: ZEND_ARG_INFO(0, socket)
155: ZEND_END_ARG_INFO()
156:
157: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_listen, 0, 0, 1)
158: ZEND_ARG_INFO(0, socket)
159: ZEND_ARG_INFO(0, backlog)
160: ZEND_END_ARG_INFO()
161:
162: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_close, 0, 0, 1)
163: ZEND_ARG_INFO(0, socket)
164: ZEND_END_ARG_INFO()
165:
166: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_write, 0, 0, 2)
167: ZEND_ARG_INFO(0, socket)
168: ZEND_ARG_INFO(0, buf)
169: ZEND_ARG_INFO(0, length)
170: ZEND_END_ARG_INFO()
171:
172: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_read, 0, 0, 2)
173: ZEND_ARG_INFO(0, socket)
174: ZEND_ARG_INFO(0, length)
175: ZEND_ARG_INFO(0, type)
176: ZEND_END_ARG_INFO()
177:
178: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_getsockname, 0, 0, 2)
179: ZEND_ARG_INFO(0, socket)
180: ZEND_ARG_INFO(1, addr)
181: ZEND_ARG_INFO(1, port)
182: ZEND_END_ARG_INFO()
183:
184: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_getpeername, 0, 0, 2)
185: ZEND_ARG_INFO(0, socket)
186: ZEND_ARG_INFO(1, addr)
187: ZEND_ARG_INFO(1, port)
188: ZEND_END_ARG_INFO()
189:
190: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_create, 0, 0, 3)
191: ZEND_ARG_INFO(0, domain)
192: ZEND_ARG_INFO(0, type)
193: ZEND_ARG_INFO(0, protocol)
194: ZEND_END_ARG_INFO()
195:
196: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_connect, 0, 0, 2)
197: ZEND_ARG_INFO(0, socket)
198: ZEND_ARG_INFO(0, addr)
199: ZEND_ARG_INFO(0, port)
200: ZEND_END_ARG_INFO()
201:
202: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_strerror, 0, 0, 1)
203: ZEND_ARG_INFO(0, errno)
204: ZEND_END_ARG_INFO()
205:
206: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_bind, 0, 0, 2)
207: ZEND_ARG_INFO(0, socket)
208: ZEND_ARG_INFO(0, addr)
209: ZEND_ARG_INFO(0, port)
210: ZEND_END_ARG_INFO()
211:
212: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_recv, 0, 0, 4)
213: ZEND_ARG_INFO(0, socket)
214: ZEND_ARG_INFO(1, buf)
215: ZEND_ARG_INFO(0, len)
216: ZEND_ARG_INFO(0, flags)
217: ZEND_END_ARG_INFO()
218:
219: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_send, 0, 0, 4)
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_END_ARG_INFO()
225:
226: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_recvfrom, 0, 0, 5)
227: ZEND_ARG_INFO(0, socket)
228: ZEND_ARG_INFO(1, buf)
229: ZEND_ARG_INFO(0, len)
230: ZEND_ARG_INFO(0, flags)
231: ZEND_ARG_INFO(1, name)
232: ZEND_ARG_INFO(1, port)
233: ZEND_END_ARG_INFO()
234:
235: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_sendto, 0, 0, 5)
236: ZEND_ARG_INFO(0, socket)
237: ZEND_ARG_INFO(0, buf)
238: ZEND_ARG_INFO(0, len)
239: ZEND_ARG_INFO(0, flags)
240: ZEND_ARG_INFO(0, addr)
241: ZEND_ARG_INFO(0, port)
242: ZEND_END_ARG_INFO()
243:
244: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_get_option, 0, 0, 3)
245: ZEND_ARG_INFO(0, socket)
246: ZEND_ARG_INFO(0, level)
247: ZEND_ARG_INFO(0, optname)
248: ZEND_END_ARG_INFO()
249:
250: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_set_option, 0, 0, 4)
251: ZEND_ARG_INFO(0, socket)
252: ZEND_ARG_INFO(0, level)
253: ZEND_ARG_INFO(0, optname)
254: ZEND_ARG_INFO(0, optval)
255: ZEND_END_ARG_INFO()
256:
257: #ifdef HAVE_SOCKETPAIR
258: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_create_pair, 0, 0, 4)
259: ZEND_ARG_INFO(0, domain)
260: ZEND_ARG_INFO(0, type)
261: ZEND_ARG_INFO(0, protocol)
262: ZEND_ARG_INFO(1, fd)
263: ZEND_END_ARG_INFO()
264: #endif
265:
266: #ifdef HAVE_SHUTDOWN
267: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_shutdown, 0, 0, 1)
268: ZEND_ARG_INFO(0, socket)
269: ZEND_ARG_INFO(0, how)
270: ZEND_END_ARG_INFO()
271: #endif
272:
273: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_last_error, 0, 0, 0)
274: ZEND_ARG_INFO(0, socket)
275: ZEND_END_ARG_INFO()
276:
277: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_clear_error, 0, 0, 0)
278: ZEND_ARG_INFO(0, socket)
279: ZEND_END_ARG_INFO()
1.1.1.2 misho 280:
281: ZEND_BEGIN_ARG_INFO_EX(arginfo_socket_import_stream, 0, 0, 1)
282: ZEND_ARG_INFO(0, stream)
283: ZEND_END_ARG_INFO()
1.1 misho 284: /* }}} */
285:
1.1.1.3 ! misho 286: PHP_MINIT_FUNCTION(sockets);
! 287: PHP_MINFO_FUNCTION(sockets);
! 288: PHP_RSHUTDOWN_FUNCTION(sockets);
! 289:
! 290: PHP_FUNCTION(socket_select);
! 291: PHP_FUNCTION(socket_create_listen);
! 292: #ifdef HAVE_SOCKETPAIR
! 293: PHP_FUNCTION(socket_create_pair);
! 294: #endif
! 295: PHP_FUNCTION(socket_accept);
! 296: PHP_FUNCTION(socket_set_nonblock);
! 297: PHP_FUNCTION(socket_set_block);
! 298: PHP_FUNCTION(socket_listen);
! 299: PHP_FUNCTION(socket_close);
! 300: PHP_FUNCTION(socket_write);
! 301: PHP_FUNCTION(socket_read);
! 302: PHP_FUNCTION(socket_getsockname);
! 303: PHP_FUNCTION(socket_getpeername);
! 304: PHP_FUNCTION(socket_create);
! 305: PHP_FUNCTION(socket_connect);
! 306: PHP_FUNCTION(socket_strerror);
! 307: PHP_FUNCTION(socket_bind);
! 308: PHP_FUNCTION(socket_recv);
! 309: PHP_FUNCTION(socket_send);
! 310: PHP_FUNCTION(socket_recvfrom);
! 311: PHP_FUNCTION(socket_sendto);
! 312: PHP_FUNCTION(socket_get_option);
! 313: PHP_FUNCTION(socket_set_option);
! 314: #ifdef HAVE_SHUTDOWN
! 315: PHP_FUNCTION(socket_shutdown);
! 316: #endif
! 317: PHP_FUNCTION(socket_last_error);
! 318: PHP_FUNCTION(socket_clear_error);
! 319: PHP_FUNCTION(socket_import_stream);
! 320:
1.1 misho 321: /* {{{ sockets_functions[]
322: */
323: const zend_function_entry sockets_functions[] = {
324: PHP_FE(socket_select, arginfo_socket_select)
325: PHP_FE(socket_create, arginfo_socket_create)
326: PHP_FE(socket_create_listen, arginfo_socket_create_listen)
327: #ifdef HAVE_SOCKETPAIR
328: PHP_FE(socket_create_pair, arginfo_socket_create_pair)
329: #endif
330: PHP_FE(socket_accept, arginfo_socket_accept)
331: PHP_FE(socket_set_nonblock, arginfo_socket_set_nonblock)
332: PHP_FE(socket_set_block, arginfo_socket_set_block)
333: PHP_FE(socket_listen, arginfo_socket_listen)
334: PHP_FE(socket_close, arginfo_socket_close)
335: PHP_FE(socket_write, arginfo_socket_write)
336: PHP_FE(socket_read, arginfo_socket_read)
337: PHP_FE(socket_getsockname, arginfo_socket_getsockname)
338: PHP_FE(socket_getpeername, arginfo_socket_getpeername)
339: PHP_FE(socket_connect, arginfo_socket_connect)
340: PHP_FE(socket_strerror, arginfo_socket_strerror)
341: PHP_FE(socket_bind, arginfo_socket_bind)
342: PHP_FE(socket_recv, arginfo_socket_recv)
343: PHP_FE(socket_send, arginfo_socket_send)
344: PHP_FE(socket_recvfrom, arginfo_socket_recvfrom)
345: PHP_FE(socket_sendto, arginfo_socket_sendto)
346: PHP_FE(socket_get_option, arginfo_socket_get_option)
347: PHP_FE(socket_set_option, arginfo_socket_set_option)
348: #ifdef HAVE_SHUTDOWN
349: PHP_FE(socket_shutdown, arginfo_socket_shutdown)
350: #endif
351: PHP_FE(socket_last_error, arginfo_socket_last_error)
352: PHP_FE(socket_clear_error, arginfo_socket_clear_error)
1.1.1.2 misho 353: PHP_FE(socket_import_stream, arginfo_socket_import_stream)
1.1 misho 354:
355: /* for downwards compatability */
356: PHP_FALIAS(socket_getopt, socket_get_option, arginfo_socket_get_option)
357: PHP_FALIAS(socket_setopt, socket_set_option, arginfo_socket_set_option)
358:
359: PHP_FE_END
360: };
361: /* }}} */
362:
363: zend_module_entry sockets_module_entry = {
364: STANDARD_MODULE_HEADER,
365: "sockets",
366: sockets_functions,
367: PHP_MINIT(sockets),
368: NULL,
369: NULL,
370: PHP_RSHUTDOWN(sockets),
371: PHP_MINFO(sockets),
372: NO_VERSION_YET,
373: PHP_MODULE_GLOBALS(sockets),
374: PHP_GINIT(sockets),
375: NULL,
376: NULL,
377: STANDARD_MODULE_PROPERTIES_EX
378: };
379:
380:
381: #ifdef COMPILE_DL_SOCKETS
382: ZEND_GET_MODULE(sockets)
383: #endif
384:
385: /* inet_ntop should be used instead of inet_ntoa */
386: int inet_ntoa_lock = 0;
387:
388: PHP_SOCKETS_API int php_sockets_le_socket(void) /* {{{ */
389: {
390: return le_socket;
391: }
392: /* }}} */
393:
1.1.1.2 misho 394: /* allocating function to make programming errors due to uninitialized fields
395: * less likely */
396: static php_socket *php_create_socket(void) /* {{{ */
397: {
398: php_socket *php_sock = emalloc(sizeof *php_sock);
399:
400: php_sock->bsd_socket = -1; /* invalid socket */
401: php_sock->type = PF_UNSPEC;
402: php_sock->error = 0;
403: php_sock->blocking = 1;
404: php_sock->zstream = NULL;
405:
406: return php_sock;
407: }
408: /* }}} */
409:
1.1 misho 410: static void php_destroy_socket(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
411: {
1.1.1.2 misho 412: php_socket *php_sock = rsrc->ptr;
1.1 misho 413:
1.1.1.2 misho 414: if (php_sock->zstream == NULL) {
415: if (!IS_INVALID_SOCKET(php_sock)) {
416: close(php_sock->bsd_socket);
417: }
418: } else {
419: zval_ptr_dtor(&php_sock->zstream);
420: }
1.1 misho 421: efree(php_sock);
422: }
423: /* }}} */
424:
425: static int php_open_listen_sock(php_socket **php_sock, int port, int backlog TSRMLS_DC) /* {{{ */
426: {
427: struct sockaddr_in la;
428: struct hostent *hp;
1.1.1.2 misho 429: php_socket *sock = php_create_socket();
1.1 misho 430:
431: *php_sock = sock;
432:
433: #ifndef PHP_WIN32
434: if ((hp = gethostbyname("0.0.0.0")) == NULL) {
435: #else
436: if ((hp = gethostbyname("localhost")) == NULL) {
437: #endif
438: efree(sock);
439: return 0;
440: }
441:
442: memcpy((char *) &la.sin_addr, hp->h_addr, hp->h_length);
443: la.sin_family = hp->h_addrtype;
444: la.sin_port = htons((unsigned short) port);
445:
446: sock->bsd_socket = socket(PF_INET, SOCK_STREAM, 0);
447: sock->blocking = 1;
448:
449: if (IS_INVALID_SOCKET(sock)) {
450: PHP_SOCKET_ERROR(sock, "unable to create listening socket", errno);
451: efree(sock);
452: return 0;
453: }
454:
455: sock->type = PF_INET;
456:
457: if (bind(sock->bsd_socket, (struct sockaddr *)&la, sizeof(la)) != 0) {
458: PHP_SOCKET_ERROR(sock, "unable to bind to given address", errno);
459: close(sock->bsd_socket);
460: efree(sock);
461: return 0;
462: }
463:
464: if (listen(sock->bsd_socket, backlog) != 0) {
465: PHP_SOCKET_ERROR(sock, "unable to listen on socket", errno);
466: close(sock->bsd_socket);
467: efree(sock);
468: return 0;
469: }
470:
471: return 1;
472: }
473: /* }}} */
474:
475: static int php_accept_connect(php_socket *in_sock, php_socket **new_sock, struct sockaddr *la, socklen_t *la_len TSRMLS_DC) /* {{{ */
476: {
1.1.1.2 misho 477: php_socket *out_sock = php_create_socket();
1.1 misho 478:
479: *new_sock = out_sock;
480:
481: out_sock->bsd_socket = accept(in_sock->bsd_socket, la, la_len);
482:
483: if (IS_INVALID_SOCKET(out_sock)) {
484: PHP_SOCKET_ERROR(out_sock, "unable to accept incoming connection", errno);
485: efree(out_sock);
486: return 0;
487: }
488:
489: out_sock->error = 0;
490: out_sock->blocking = 1;
491: out_sock->type = la->sa_family;
492:
493: return 1;
494: }
495: /* }}} */
496:
497: /* {{{ php_read -- wrapper around read() so that it only reads to a \r or \n. */
498: static int php_read(php_socket *sock, void *buf, size_t maxlen, int flags)
499: {
500: int m = 0;
501: size_t n = 0;
502: int no_read = 0;
503: int nonblock = 0;
504: char *t = (char *) buf;
505:
506: #ifndef PHP_WIN32
507: m = fcntl(sock->bsd_socket, F_GETFL);
508: if (m < 0) {
509: return m;
510: }
511: nonblock = (m & O_NONBLOCK);
512: m = 0;
513: #else
514: nonblock = !sock->blocking;
515: #endif
516: set_errno(0);
517:
518: *t = '\0';
519: while (*t != '\n' && *t != '\r' && n < maxlen) {
520: if (m > 0) {
521: t++;
522: n++;
523: } else if (m == 0) {
524: no_read++;
525: if (nonblock && no_read >= 2) {
526: return n;
527: /* The first pass, m always is 0, so no_read becomes 1
528: * in the first pass. no_read becomes 2 in the second pass,
529: * and if this is nonblocking, we should return.. */
530: }
531:
532: if (no_read > 200) {
533: set_errno(ECONNRESET);
534: return -1;
535: }
536: }
537:
538: if (n < maxlen) {
539: m = recv(sock->bsd_socket, (void *) t, 1, flags);
540: }
541:
542: if (errno != 0 && errno != ESPIPE && errno != EAGAIN) {
543: return -1;
544: }
545:
546: set_errno(0);
547: }
548:
549: if (n < maxlen) {
550: n++;
551: /* The only reasons it makes it to here is
552: * if '\n' or '\r' are encountered. So, increase
553: * the return by 1 to make up for the lack of the
554: * '\n' or '\r' in the count (since read() takes
555: * place at the end of the loop..) */
556: }
557:
558: return n;
559: }
560: /* }}} */
561:
562: static char *php_strerror(int error TSRMLS_DC) /* {{{ */
563: {
564: const char *buf;
565:
566: #ifndef PHP_WIN32
567: if (error < -10000) {
568: error = -error - 10000;
569:
570: #ifdef HAVE_HSTRERROR
571: buf = hstrerror(error);
572: #else
573: {
574: if (SOCKETS_G(strerror_buf)) {
575: efree(SOCKETS_G(strerror_buf));
576: }
577:
578: spprintf(&(SOCKETS_G(strerror_buf)), 0, "Host lookup error %d", error);
579: buf = SOCKETS_G(strerror_buf);
580: }
581: #endif
582: } else {
583: buf = strerror(error);
584: }
585: #else
586: {
587: LPTSTR tmp = NULL;
588: buf = NULL;
589:
590: if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
591: NULL, error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &tmp, 0, NULL)
592: ) {
593: if (SOCKETS_G(strerror_buf)) {
594: efree(SOCKETS_G(strerror_buf));
595: }
596:
597: SOCKETS_G(strerror_buf) = estrdup(tmp);
598: LocalFree(tmp);
599:
600: buf = SOCKETS_G(strerror_buf);
601: }
602: }
603: #endif
604:
605: return (buf ? (char *) buf : "");
606: }
607: /* }}} */
608:
609: #if HAVE_IPV6
610: /* Sets addr by hostname, or by ip in string form (AF_INET6) */
611: static int php_set_inet6_addr(struct sockaddr_in6 *sin6, char *string, php_socket *php_sock TSRMLS_DC) /* {{{ */
612: {
613: struct in6_addr tmp;
614: #if HAVE_GETADDRINFO
615: struct addrinfo hints;
616: struct addrinfo *addrinfo = NULL;
617: #endif
618:
619: if (inet_pton(AF_INET6, string, &tmp)) {
620: memcpy(&(sin6->sin6_addr.s6_addr), &(tmp.s6_addr), sizeof(struct in6_addr));
621: } else {
622: #if HAVE_GETADDRINFO
623:
624: memset(&hints, 0, sizeof(struct addrinfo));
625: hints.ai_family = PF_INET6;
626: getaddrinfo(string, NULL, &hints, &addrinfo);
627: if (!addrinfo) {
628: #ifdef PHP_WIN32
629: PHP_SOCKET_ERROR(php_sock, "Host lookup failed", WSAGetLastError());
630: #else
631: PHP_SOCKET_ERROR(php_sock, "Host lookup failed", (-10000 - h_errno));
632: #endif
633: return 0;
634: }
635: if (addrinfo->ai_family != PF_INET6 || addrinfo->ai_addrlen != sizeof(struct sockaddr_in6)) {
636: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Host lookup failed: Non AF_INET6 domain returned on AF_INET6 socket");
637: freeaddrinfo(addrinfo);
638: return 0;
639: }
640:
641: memcpy(&(sin6->sin6_addr.s6_addr), ((struct sockaddr_in6*)(addrinfo->ai_addr))->sin6_addr.s6_addr, sizeof(struct in6_addr));
642: freeaddrinfo(addrinfo);
643:
644: #else
645: /* No IPv6 specific hostname resolution is available on this system? */
646: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Host lookup failed: getaddrinfo() not available on this system");
647: return 0;
648: #endif
649:
650: }
651:
652: return 1;
653: }
654: /* }}} */
655: #endif
656:
657: /* Sets addr by hostname, or by ip in string form (AF_INET) */
658: static int php_set_inet_addr(struct sockaddr_in *sin, char *string, php_socket *php_sock TSRMLS_DC) /* {{{ */
659: {
660: struct in_addr tmp;
661: struct hostent *host_entry;
662:
663: if (inet_aton(string, &tmp)) {
664: sin->sin_addr.s_addr = tmp.s_addr;
665: } else {
666: if (! (host_entry = gethostbyname(string))) {
667: /* Note: < -10000 indicates a host lookup error */
668: #ifdef PHP_WIN32
669: PHP_SOCKET_ERROR(php_sock, "Host lookup failed", WSAGetLastError());
670: #else
671: PHP_SOCKET_ERROR(php_sock, "Host lookup failed", (-10000 - h_errno));
672: #endif
673: return 0;
674: }
675: if (host_entry->h_addrtype != AF_INET) {
676: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Host lookup failed: Non AF_INET domain returned on AF_INET socket");
677: return 0;
678: }
679: memcpy(&(sin->sin_addr.s_addr), host_entry->h_addr_list[0], host_entry->h_length);
680: }
681:
682: return 1;
683: }
684: /* }}} */
685:
1.1.1.2 misho 686: /* Sets addr by hostname or by ip in string form (AF_INET or AF_INET6,
687: * depending on the socket) */
688: static int php_set_inet46_addr(php_sockaddr_storage *ss, socklen_t *ss_len, char *string, php_socket *php_sock TSRMLS_DC) /* {{{ */
689: {
690: if (php_sock->type == AF_INET) {
691: struct sockaddr_in t = {0};
692: if (php_set_inet_addr(&t, string, php_sock TSRMLS_CC)) {
693: memcpy(ss, &t, sizeof t);
694: ss->ss_family = AF_INET;
695: *ss_len = sizeof(t);
696: return 1;
697: }
698: }
699: #if HAVE_IPV6
700: else if (php_sock->type == AF_INET6) {
701: struct sockaddr_in6 t = {0};
702: if (php_set_inet6_addr(&t, string, php_sock TSRMLS_CC)) {
703: memcpy(ss, &t, sizeof t);
704: ss->ss_family = AF_INET6;
705: *ss_len = sizeof(t);
706: return 1;
707: }
708: }
709: #endif
710: else {
711: php_error_docref(NULL TSRMLS_CC, E_WARNING,
712: "IP address used in the context of an unexpected type of socket");
713: }
714: return 0;
715: }
716:
717: static int php_get_if_index_from_zval(zval *val, unsigned *out TSRMLS_DC)
718: {
719: int ret;
720:
721: if (Z_TYPE_P(val) == IS_LONG) {
722: if (Z_LVAL_P(val) < 0 || Z_LVAL_P(val) > UINT_MAX) {
723: php_error_docref(NULL TSRMLS_CC, E_WARNING,
724: "the interface index cannot be negative or larger than %u;"
725: " given %ld", UINT_MAX, Z_LVAL_P(val));
726: ret = FAILURE;
727: } else {
728: *out = Z_LVAL_P(val);
729: ret = SUCCESS;
730: }
731: } else {
732: #if HAVE_IF_NAMETOINDEX
733: unsigned int ind;
734: zval_add_ref(&val);
735: convert_to_string_ex(&val);
736: ind = if_nametoindex(Z_STRVAL_P(val));
737: if (ind == 0) {
738: php_error_docref(NULL TSRMLS_CC, E_WARNING,
739: "no interface with name \"%s\" could be found", Z_STRVAL_P(val));
740: ret = FAILURE;
741: } else {
742: *out = ind;
743: ret = SUCCESS;
744: }
745: zval_ptr_dtor(&val);
746: #else
747: php_error_docref(NULL TSRMLS_CC, E_WARNING,
748: "this platform does not support looking up an interface by "
749: "name, an integer interface index must be supplied instead");
750: ret = FAILURE;
751: #endif
752: }
753:
754: return ret;
755: }
756:
757: static int php_get_if_index_from_array(const HashTable *ht, const char *key,
758: php_socket *sock, unsigned int *if_index TSRMLS_DC)
759: {
760: zval **val;
761:
762: if (zend_hash_find(ht, key, strlen(key) + 1, (void **)&val) == FAILURE) {
763: *if_index = 0; /* default: 0 */
764: return SUCCESS;
765: }
766:
767: return php_get_if_index_from_zval(*val, if_index TSRMLS_CC);
768: }
769:
770: static int php_get_address_from_array(const HashTable *ht, const char *key,
771: php_socket *sock, php_sockaddr_storage *ss, socklen_t *ss_len TSRMLS_DC)
772: {
773: zval **val,
774: *valcp;
775:
776: if (zend_hash_find(ht, key, strlen(key) + 1, (void **)&val) == FAILURE) {
777: php_error_docref(NULL TSRMLS_CC, E_WARNING, "no key \"%s\" passed in optval", key);
778: return FAILURE;
779: }
780: valcp = *val;
781: zval_add_ref(&valcp);
782: convert_to_string_ex(val);
783: if (!php_set_inet46_addr(ss, ss_len, Z_STRVAL_P(valcp), sock TSRMLS_CC)) {
784: zval_ptr_dtor(&valcp);
785: return FAILURE;
786: }
787: zval_ptr_dtor(&valcp);
788: return SUCCESS;
789: }
790:
1.1 misho 791: /* {{{ PHP_GINIT_FUNCTION */
792: static PHP_GINIT_FUNCTION(sockets)
793: {
794: sockets_globals->last_error = 0;
795: sockets_globals->strerror_buf = NULL;
796: }
797: /* }}} */
798:
799: /* {{{ PHP_MINIT_FUNCTION
800: */
801: PHP_MINIT_FUNCTION(sockets)
802: {
803: le_socket = zend_register_list_destructors_ex(php_destroy_socket, NULL, le_socket_name, module_number);
804:
805: REGISTER_LONG_CONSTANT("AF_UNIX", AF_UNIX, CONST_CS | CONST_PERSISTENT);
806: REGISTER_LONG_CONSTANT("AF_INET", AF_INET, CONST_CS | CONST_PERSISTENT);
807: #if HAVE_IPV6
808: REGISTER_LONG_CONSTANT("AF_INET6", AF_INET6, CONST_CS | CONST_PERSISTENT);
809: #endif
810: REGISTER_LONG_CONSTANT("SOCK_STREAM", SOCK_STREAM, CONST_CS | CONST_PERSISTENT);
811: REGISTER_LONG_CONSTANT("SOCK_DGRAM", SOCK_DGRAM, CONST_CS | CONST_PERSISTENT);
812: REGISTER_LONG_CONSTANT("SOCK_RAW", SOCK_RAW, CONST_CS | CONST_PERSISTENT);
813: REGISTER_LONG_CONSTANT("SOCK_SEQPACKET",SOCK_SEQPACKET, CONST_CS | CONST_PERSISTENT);
814: REGISTER_LONG_CONSTANT("SOCK_RDM", SOCK_RDM, CONST_CS | CONST_PERSISTENT);
815: REGISTER_LONG_CONSTANT("MSG_OOB", MSG_OOB, CONST_CS | CONST_PERSISTENT);
816: REGISTER_LONG_CONSTANT("MSG_WAITALL", MSG_WAITALL, CONST_CS | CONST_PERSISTENT);
817: #ifdef MSG_DONTWAIT
818: REGISTER_LONG_CONSTANT("MSG_DONTWAIT", MSG_DONTWAIT, CONST_CS | CONST_PERSISTENT);
819: #endif
820: REGISTER_LONG_CONSTANT("MSG_PEEK", MSG_PEEK, CONST_CS | CONST_PERSISTENT);
821: REGISTER_LONG_CONSTANT("MSG_DONTROUTE", MSG_DONTROUTE, CONST_CS | CONST_PERSISTENT);
822: #ifdef MSG_EOR
823: REGISTER_LONG_CONSTANT("MSG_EOR", MSG_EOR, CONST_CS | CONST_PERSISTENT);
824: #endif
825: #ifdef MSG_EOF
826: REGISTER_LONG_CONSTANT("MSG_EOF", MSG_EOF, CONST_CS | CONST_PERSISTENT);
827: #endif
828: REGISTER_LONG_CONSTANT("SO_DEBUG", SO_DEBUG, CONST_CS | CONST_PERSISTENT);
829: REGISTER_LONG_CONSTANT("SO_REUSEADDR", SO_REUSEADDR, CONST_CS | CONST_PERSISTENT);
1.1.1.3 ! misho 830: #ifdef SO_REUSEPORT
! 831: REGISTER_LONG_CONSTANT("SO_REUSEPORT", SO_REUSEPORT, CONST_CS | CONST_PERSISTENT);
! 832: #endif
1.1 misho 833: REGISTER_LONG_CONSTANT("SO_KEEPALIVE", SO_KEEPALIVE, CONST_CS | CONST_PERSISTENT);
834: REGISTER_LONG_CONSTANT("SO_DONTROUTE", SO_DONTROUTE, CONST_CS | CONST_PERSISTENT);
835: REGISTER_LONG_CONSTANT("SO_LINGER", SO_LINGER, CONST_CS | CONST_PERSISTENT);
836: REGISTER_LONG_CONSTANT("SO_BROADCAST", SO_BROADCAST, CONST_CS | CONST_PERSISTENT);
837: REGISTER_LONG_CONSTANT("SO_OOBINLINE", SO_OOBINLINE, CONST_CS | CONST_PERSISTENT);
838: REGISTER_LONG_CONSTANT("SO_SNDBUF", SO_SNDBUF, CONST_CS | CONST_PERSISTENT);
839: REGISTER_LONG_CONSTANT("SO_RCVBUF", SO_RCVBUF, CONST_CS | CONST_PERSISTENT);
840: REGISTER_LONG_CONSTANT("SO_SNDLOWAT", SO_SNDLOWAT, CONST_CS | CONST_PERSISTENT);
841: REGISTER_LONG_CONSTANT("SO_RCVLOWAT", SO_RCVLOWAT, CONST_CS | CONST_PERSISTENT);
842: REGISTER_LONG_CONSTANT("SO_SNDTIMEO", SO_SNDTIMEO, CONST_CS | CONST_PERSISTENT);
843: REGISTER_LONG_CONSTANT("SO_RCVTIMEO", SO_RCVTIMEO, CONST_CS | CONST_PERSISTENT);
844: REGISTER_LONG_CONSTANT("SO_TYPE", SO_TYPE, CONST_CS | CONST_PERSISTENT);
845: REGISTER_LONG_CONSTANT("SO_ERROR", SO_ERROR, CONST_CS | CONST_PERSISTENT);
846: REGISTER_LONG_CONSTANT("SOL_SOCKET", SOL_SOCKET, CONST_CS | CONST_PERSISTENT);
847: REGISTER_LONG_CONSTANT("SOMAXCONN", SOMAXCONN, CONST_CS | CONST_PERSISTENT);
848: #ifdef TCP_NODELAY
849: REGISTER_LONG_CONSTANT("TCP_NODELAY", TCP_NODELAY, CONST_CS | CONST_PERSISTENT);
850: #endif
851: REGISTER_LONG_CONSTANT("PHP_NORMAL_READ", PHP_NORMAL_READ, CONST_CS | CONST_PERSISTENT);
852: REGISTER_LONG_CONSTANT("PHP_BINARY_READ", PHP_BINARY_READ, CONST_CS | CONST_PERSISTENT);
853:
1.1.1.2 misho 854: #ifndef RFC3678_API
855: #define MCAST_JOIN_GROUP IP_ADD_MEMBERSHIP
856: #define MCAST_LEAVE_GROUP IP_DROP_MEMBERSHIP
857: #ifdef HAS_MCAST_EXT
858: #define MCAST_BLOCK_SOURCE IP_BLOCK_SOURCE
859: #define MCAST_UNBLOCK_SOURCE IP_UNBLOCK_SOURCE
860: #define MCAST_JOIN_SOURCE_GROUP IP_ADD_SOURCE_MEMBERSHIP
861: #define MCAST_LEAVE_SOURCE_GROUP IP_DROP_SOURCE_MEMBERSHIP
862: #endif
863: #endif
864:
865: REGISTER_LONG_CONSTANT("MCAST_JOIN_GROUP", MCAST_JOIN_GROUP, CONST_CS | CONST_PERSISTENT);
866: REGISTER_LONG_CONSTANT("MCAST_LEAVE_GROUP", MCAST_LEAVE_GROUP, CONST_CS | CONST_PERSISTENT);
867: #ifdef HAS_MCAST_EXT
868: REGISTER_LONG_CONSTANT("MCAST_BLOCK_SOURCE", MCAST_BLOCK_SOURCE, CONST_CS | CONST_PERSISTENT);
869: REGISTER_LONG_CONSTANT("MCAST_UNBLOCK_SOURCE", MCAST_UNBLOCK_SOURCE, CONST_CS | CONST_PERSISTENT);
870: REGISTER_LONG_CONSTANT("MCAST_JOIN_SOURCE_GROUP", MCAST_JOIN_SOURCE_GROUP, CONST_CS | CONST_PERSISTENT);
871: REGISTER_LONG_CONSTANT("MCAST_LEAVE_SOURCE_GROUP", MCAST_LEAVE_SOURCE_GROUP, CONST_CS | CONST_PERSISTENT);
872: #endif
873:
874: REGISTER_LONG_CONSTANT("IP_MULTICAST_IF", IP_MULTICAST_IF, CONST_CS | CONST_PERSISTENT);
875: REGISTER_LONG_CONSTANT("IP_MULTICAST_TTL", IP_MULTICAST_TTL, CONST_CS | CONST_PERSISTENT);
876: REGISTER_LONG_CONSTANT("IP_MULTICAST_LOOP", IP_MULTICAST_LOOP, CONST_CS | CONST_PERSISTENT);
877: #if HAVE_IPV6
878: REGISTER_LONG_CONSTANT("IPV6_MULTICAST_IF", IPV6_MULTICAST_IF, CONST_CS | CONST_PERSISTENT);
879: REGISTER_LONG_CONSTANT("IPV6_MULTICAST_HOPS", IPV6_MULTICAST_HOPS, CONST_CS | CONST_PERSISTENT);
880: REGISTER_LONG_CONSTANT("IPV6_MULTICAST_LOOP", IPV6_MULTICAST_LOOP, CONST_CS | CONST_PERSISTENT);
881: #endif
882:
1.1 misho 883: #ifndef WIN32
884: # include "unix_socket_constants.h"
885: #else
886: # include "win32_socket_constants.h"
887: #endif
888:
1.1.1.2 misho 889: REGISTER_LONG_CONSTANT("IPPROTO_IP", IPPROTO_IP, CONST_CS | CONST_PERSISTENT);
890: #if HAVE_IPV6
891: REGISTER_LONG_CONSTANT("IPPROTO_IPV6", IPPROTO_IPV6, CONST_CS | CONST_PERSISTENT);
892: #endif
1.1 misho 893:
1.1.1.2 misho 894: REGISTER_LONG_CONSTANT("SOL_TCP", IPPROTO_TCP, CONST_CS | CONST_PERSISTENT);
895: REGISTER_LONG_CONSTANT("SOL_UDP", IPPROTO_UDP, CONST_CS | CONST_PERSISTENT);
1.1 misho 896:
897: return SUCCESS;
898: }
899: /* }}} */
900:
901: /* {{{ PHP_MINFO_FUNCTION
902: */
903: PHP_MINFO_FUNCTION(sockets)
904: {
905: php_info_print_table_start();
906: php_info_print_table_row(2, "Sockets Support", "enabled");
907: php_info_print_table_end();
908: }
909: /* }}} */
910:
911: /* {{{ PHP_RSHUTDOWN_FUNCTION */
912: PHP_RSHUTDOWN_FUNCTION(sockets)
913: {
914: if (SOCKETS_G(strerror_buf)) {
915: efree(SOCKETS_G(strerror_buf));
916: SOCKETS_G(strerror_buf) = NULL;
917: }
918:
919: return SUCCESS;
920: }
921: /* }}} */
922:
923: static int php_sock_array_to_fd_set(zval *sock_array, fd_set *fds, PHP_SOCKET *max_fd TSRMLS_DC) /* {{{ */
924: {
925: zval **element;
926: php_socket *php_sock;
927: int num = 0;
928:
929: if (Z_TYPE_P(sock_array) != IS_ARRAY) return 0;
930:
931: for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(sock_array));
932: zend_hash_get_current_data(Z_ARRVAL_P(sock_array), (void **) &element) == SUCCESS;
933: zend_hash_move_forward(Z_ARRVAL_P(sock_array))) {
934:
935: php_sock = (php_socket*) zend_fetch_resource(element TSRMLS_CC, -1, le_socket_name, NULL, 1, le_socket);
936: if (!php_sock) continue; /* If element is not a resource, skip it */
937:
938: PHP_SAFE_FD_SET(php_sock->bsd_socket, fds);
939: if (php_sock->bsd_socket > *max_fd) {
940: *max_fd = php_sock->bsd_socket;
941: }
942: num++;
943: }
944:
945: return num ? 1 : 0;
946: }
947: /* }}} */
948:
949: static int php_sock_array_from_fd_set(zval *sock_array, fd_set *fds TSRMLS_DC) /* {{{ */
950: {
951: zval **element;
952: zval **dest_element;
953: php_socket *php_sock;
954: HashTable *new_hash;
955: char *key;
956: int num = 0;
957: ulong num_key;
958: uint key_len;
959:
960: if (Z_TYPE_P(sock_array) != IS_ARRAY) return 0;
961:
962: ALLOC_HASHTABLE(new_hash);
963: zend_hash_init(new_hash, zend_hash_num_elements(Z_ARRVAL_P(sock_array)), NULL, ZVAL_PTR_DTOR, 0);
964: for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(sock_array));
965: zend_hash_get_current_data(Z_ARRVAL_P(sock_array), (void **) &element) == SUCCESS;
966: zend_hash_move_forward(Z_ARRVAL_P(sock_array))) {
967:
968: php_sock = (php_socket*) zend_fetch_resource(element TSRMLS_CC, -1, le_socket_name, NULL, 1, le_socket);
969: if (!php_sock) continue; /* If element is not a resource, skip it */
970:
971: if (PHP_SAFE_FD_ISSET(php_sock->bsd_socket, fds)) {
972: /* Add fd to new array */
973: switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(sock_array), &key, &key_len, &num_key, 0, NULL)) {
974: case HASH_KEY_IS_STRING:
975: zend_hash_add(new_hash, key, key_len, (void *)element, sizeof(zval *), (void **)&dest_element);
976: break;
977: case HASH_KEY_IS_LONG:
978: zend_hash_index_update(new_hash, num_key, (void *)element, sizeof(zval *), (void **)&dest_element);
979: break;
980: }
981: if (dest_element) zval_add_ref(dest_element);
982: }
983: num++;
984: }
985:
986: /* Destroy old array, add new one */
987: zend_hash_destroy(Z_ARRVAL_P(sock_array));
988: efree(Z_ARRVAL_P(sock_array));
989:
990: zend_hash_internal_pointer_reset(new_hash);
991: Z_ARRVAL_P(sock_array) = new_hash;
992:
993: return num ? 1 : 0;
994: }
995: /* }}} */
996:
997: /* {{{ proto int socket_select(array &read_fds, array &write_fds, array &except_fds, int tv_sec[, int tv_usec]) U
998: Runs the select() system call on the sets mentioned with a timeout specified by tv_sec and tv_usec */
999: PHP_FUNCTION(socket_select)
1000: {
1001: zval *r_array, *w_array, *e_array, *sec;
1002: struct timeval tv;
1003: struct timeval *tv_p = NULL;
1004: fd_set rfds, wfds, efds;
1005: PHP_SOCKET max_fd = 0;
1006: int retval, sets = 0;
1007: long usec = 0;
1008:
1009: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a!a!a!z!|l", &r_array, &w_array, &e_array, &sec, &usec) == FAILURE) {
1010: return;
1011: }
1012:
1013: FD_ZERO(&rfds);
1014: FD_ZERO(&wfds);
1015: FD_ZERO(&efds);
1016:
1017: if (r_array != NULL) sets += php_sock_array_to_fd_set(r_array, &rfds, &max_fd TSRMLS_CC);
1018: if (w_array != NULL) sets += php_sock_array_to_fd_set(w_array, &wfds, &max_fd TSRMLS_CC);
1019: if (e_array != NULL) sets += php_sock_array_to_fd_set(e_array, &efds, &max_fd TSRMLS_CC);
1020:
1021: if (!sets) {
1022: php_error_docref(NULL TSRMLS_CC, E_WARNING, "no resource arrays were passed to select");
1023: RETURN_FALSE;
1024: }
1025:
1026: PHP_SAFE_MAX_FD(max_fd, 0); /* someone needs to make this look more like stream_socket_select */
1027:
1028: /* If seconds is not set to null, build the timeval, else we wait indefinitely */
1029: if (sec != NULL) {
1030: zval tmp;
1031:
1032: if (Z_TYPE_P(sec) != IS_LONG) {
1033: tmp = *sec;
1034: zval_copy_ctor(&tmp);
1035: convert_to_long(&tmp);
1036: sec = &tmp;
1037: }
1038:
1039: /* Solaris + BSD do not like microsecond values which are >= 1 sec */
1040: if (usec > 999999) {
1041: tv.tv_sec = Z_LVAL_P(sec) + (usec / 1000000);
1042: tv.tv_usec = usec % 1000000;
1043: } else {
1044: tv.tv_sec = Z_LVAL_P(sec);
1045: tv.tv_usec = usec;
1046: }
1047:
1048: tv_p = &tv;
1049:
1050: if (sec == &tmp) {
1051: zval_dtor(&tmp);
1052: }
1053: }
1054:
1055: retval = select(max_fd+1, &rfds, &wfds, &efds, tv_p);
1056:
1057: if (retval == -1) {
1058: SOCKETS_G(last_error) = errno;
1059: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to select [%d]: %s", errno, php_strerror(errno TSRMLS_CC));
1060: RETURN_FALSE;
1061: }
1062:
1063: if (r_array != NULL) php_sock_array_from_fd_set(r_array, &rfds TSRMLS_CC);
1064: if (w_array != NULL) php_sock_array_from_fd_set(w_array, &wfds TSRMLS_CC);
1065: if (e_array != NULL) php_sock_array_from_fd_set(e_array, &efds TSRMLS_CC);
1066:
1067: RETURN_LONG(retval);
1068: }
1069: /* }}} */
1070:
1071: /* {{{ proto resource socket_create_listen(int port[, int backlog]) U
1072: Opens a socket on port to accept connections */
1073: PHP_FUNCTION(socket_create_listen)
1074: {
1075: php_socket *php_sock;
1076: long port, backlog = 128;
1077:
1078: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &port, &backlog) == FAILURE) {
1079: return;
1080: }
1081:
1082: if (!php_open_listen_sock(&php_sock, port, backlog TSRMLS_CC)) {
1083: RETURN_FALSE;
1084: }
1085:
1086: php_sock->error = 0;
1087: php_sock->blocking = 1;
1088:
1089: ZEND_REGISTER_RESOURCE(return_value, php_sock, le_socket);
1090: }
1091: /* }}} */
1092:
1093: /* {{{ proto resource socket_accept(resource socket) U
1094: Accepts a connection on the listening socket fd */
1095: PHP_FUNCTION(socket_accept)
1096: {
1097: zval *arg1;
1098: php_socket *php_sock, *new_sock;
1099: php_sockaddr_storage sa;
1100: socklen_t php_sa_len = sizeof(sa);
1101:
1102: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg1) == FAILURE) {
1103: return;
1104: }
1105:
1106: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
1107:
1108: if (!php_accept_connect(php_sock, &new_sock, (struct sockaddr*)&sa, &php_sa_len TSRMLS_CC)) {
1109: RETURN_FALSE;
1110: }
1111:
1112: ZEND_REGISTER_RESOURCE(return_value, new_sock, le_socket);
1113: }
1114: /* }}} */
1115:
1116: /* {{{ proto bool socket_set_nonblock(resource socket) U
1117: Sets nonblocking mode on a socket resource */
1118: PHP_FUNCTION(socket_set_nonblock)
1119: {
1120: zval *arg1;
1121: php_socket *php_sock;
1122:
1123: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg1) == FAILURE) {
1124: return;
1125: }
1126:
1127: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
1.1.1.2 misho 1128:
1129: if (php_sock->zstream != NULL) {
1130: php_stream *stream;
1131: /* omit notice if resource doesn't exist anymore */
1132: stream = zend_fetch_resource(&php_sock->zstream TSRMLS_CC, -1,
1133: NULL, NULL, 2, php_file_le_stream(), php_file_le_pstream());
1134: if (stream != NULL) {
1135: if (php_stream_set_option(stream, PHP_STREAM_OPTION_BLOCKING, 0,
1136: NULL) != -1) {
1.1.1.3 ! misho 1137: php_sock->blocking = 0;
1.1.1.2 misho 1138: RETURN_TRUE;
1139: }
1140: }
1141: }
1.1 misho 1142:
1143: if (php_set_sock_blocking(php_sock->bsd_socket, 0 TSRMLS_CC) == SUCCESS) {
1144: php_sock->blocking = 0;
1145: RETURN_TRUE;
1146: } else {
1147: PHP_SOCKET_ERROR(php_sock, "unable to set nonblocking mode", errno);
1148: RETURN_FALSE;
1149: }
1150: }
1151: /* }}} */
1152:
1153: /* {{{ proto bool socket_set_block(resource socket) U
1154: Sets blocking mode on a socket resource */
1155: PHP_FUNCTION(socket_set_block)
1156: {
1157: zval *arg1;
1158: php_socket *php_sock;
1159:
1160: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg1) == FAILURE) {
1161: return;
1162: }
1163:
1164: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
1.1.1.2 misho 1165:
1166: /* if socket was created from a stream, give the stream a chance to take
1167: * care of the operation itself, thereby allowing it to update its internal
1168: * state */
1169: if (php_sock->zstream != NULL) {
1170: php_stream *stream;
1171: stream = zend_fetch_resource(&php_sock->zstream TSRMLS_CC, -1,
1172: NULL, NULL, 2, php_file_le_stream(), php_file_le_pstream());
1173: if (stream != NULL) {
1174: if (php_stream_set_option(stream, PHP_STREAM_OPTION_BLOCKING, 1,
1175: NULL) != -1) {
1176: php_sock->blocking = 1;
1177: RETURN_TRUE;
1178: }
1179: }
1180: }
1.1 misho 1181:
1182: if (php_set_sock_blocking(php_sock->bsd_socket, 1 TSRMLS_CC) == SUCCESS) {
1183: php_sock->blocking = 1;
1184: RETURN_TRUE;
1185: } else {
1186: PHP_SOCKET_ERROR(php_sock, "unable to set blocking mode", errno);
1187: RETURN_FALSE;
1188: }
1189: }
1190: /* }}} */
1191:
1192: /* {{{ proto bool socket_listen(resource socket[, int backlog]) U
1193: Sets the maximum number of connections allowed to be waited for on the socket specified by fd */
1194: PHP_FUNCTION(socket_listen)
1195: {
1196: zval *arg1;
1197: php_socket *php_sock;
1198: long backlog = 0;
1199:
1200: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &arg1, &backlog) == FAILURE) {
1201: return;
1202: }
1203:
1204: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
1205:
1206: if (listen(php_sock->bsd_socket, backlog) != 0) {
1207: PHP_SOCKET_ERROR(php_sock, "unable to listen on socket", errno);
1208: RETURN_FALSE;
1209: }
1210: RETURN_TRUE;
1211: }
1212: /* }}} */
1213:
1214: /* {{{ proto void socket_close(resource socket) U
1215: Closes a file descriptor */
1216: PHP_FUNCTION(socket_close)
1217: {
1218: zval *arg1;
1219: php_socket *php_sock;
1220:
1221: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg1) == FAILURE) {
1222: return;
1223: }
1224:
1225: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
1.1.1.2 misho 1226: if (php_sock->zstream != NULL) {
1227: php_stream *stream = NULL;
1228: php_stream_from_zval_no_verify(stream, &php_sock->zstream);
1229: if (stream != NULL) {
1230: /* close & destroy stream, incl. removing it from the rsrc list;
1231: * resource stored in php_sock->zstream will become invalid */
1232: php_stream_free(stream, PHP_STREAM_FREE_CLOSE |
1233: (stream->is_persistent?PHP_STREAM_FREE_CLOSE_PERSISTENT:0));
1234: }
1235: }
1.1 misho 1236: zend_list_delete(Z_RESVAL_P(arg1));
1237: }
1238: /* }}} */
1239:
1240: /* {{{ proto int socket_write(resource socket, string buf[, int length])
1241: Writes the buffer to the socket resource, length is optional */
1242: PHP_FUNCTION(socket_write)
1243: {
1244: zval *arg1;
1245: php_socket *php_sock;
1246: int retval, str_len;
1247: long length = 0;
1248: char *str;
1249:
1250: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &arg1, &str, &str_len, &length) == FAILURE) {
1251: return;
1252: }
1253:
1254: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
1255:
1256: if (ZEND_NUM_ARGS() < 3) {
1257: length = str_len;
1258: }
1259:
1260: #ifndef PHP_WIN32
1261: retval = write(php_sock->bsd_socket, str, MIN(length, str_len));
1262: #else
1263: retval = send(php_sock->bsd_socket, str, min(length, str_len), 0);
1264: #endif
1265:
1266: if (retval < 0) {
1267: PHP_SOCKET_ERROR(php_sock, "unable to write to socket", errno);
1268: RETURN_FALSE;
1269: }
1270:
1271: RETURN_LONG(retval);
1272: }
1273: /* }}} */
1274:
1275: /* {{{ proto string socket_read(resource socket, int length [, int type]) U
1276: Reads a maximum of length bytes from socket */
1277: PHP_FUNCTION(socket_read)
1278: {
1279: zval *arg1;
1280: php_socket *php_sock;
1281: char *tmpbuf;
1282: int retval;
1283: long length, type = PHP_BINARY_READ;
1284:
1285: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|l", &arg1, &length, &type) == FAILURE) {
1286: return;
1287: }
1288:
1289: /* overflow check */
1290: if ((length + 1) < 2) {
1291: RETURN_FALSE;
1292: }
1293:
1294: tmpbuf = emalloc(length + 1);
1295:
1296: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
1297:
1298: if (type == PHP_NORMAL_READ) {
1299: retval = php_read(php_sock, tmpbuf, length, 0);
1300: } else {
1301: retval = recv(php_sock->bsd_socket, tmpbuf, length, 0);
1302: }
1303:
1304: if (retval == -1) {
1305: /* if the socket is in non-blocking mode and there's no data to read,
1306: don't output any error, as this is a normal situation, and not an error */
1307: if (errno == EAGAIN
1308: #ifdef EWOULDBLOCK
1309: || errno == EWOULDBLOCK
1310: #endif
1311: ) {
1312: php_sock->error = errno;
1313: SOCKETS_G(last_error) = errno;
1314: } else {
1315: PHP_SOCKET_ERROR(php_sock, "unable to read from socket", errno);
1316: }
1317:
1318: efree(tmpbuf);
1319: RETURN_FALSE;
1320: } else if (!retval) {
1321: efree(tmpbuf);
1322: RETURN_EMPTY_STRING();
1323: }
1324:
1325: tmpbuf = erealloc(tmpbuf, retval + 1);
1326: tmpbuf[retval] = '\0' ;
1327:
1328: RETURN_STRINGL(tmpbuf, retval, 0);
1329: }
1330: /* }}} */
1331:
1332: /* {{{ proto bool socket_getsockname(resource socket, string &addr[, int &port])
1333: 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. */
1334: PHP_FUNCTION(socket_getsockname)
1335: {
1336: zval *arg1, *addr, *port = NULL;
1337: php_sockaddr_storage sa_storage;
1338: php_socket *php_sock;
1339: struct sockaddr *sa;
1340: struct sockaddr_in *sin;
1341: #if HAVE_IPV6
1342: struct sockaddr_in6 *sin6;
1343: char addr6[INET6_ADDRSTRLEN+1];
1344: #endif
1345: struct sockaddr_un *s_un;
1346: char *addr_string;
1347: socklen_t salen = sizeof(php_sockaddr_storage);
1348:
1349: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz|z", &arg1, &addr, &port) == FAILURE) {
1350: return;
1351: }
1352:
1353: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
1354:
1355: sa = (struct sockaddr *) &sa_storage;
1356:
1357: if (getsockname(php_sock->bsd_socket, sa, &salen) != 0) {
1358: PHP_SOCKET_ERROR(php_sock, "unable to retrieve socket name", errno);
1359: RETURN_FALSE;
1360: }
1361:
1362: switch (sa->sa_family) {
1363: #if HAVE_IPV6
1364: case AF_INET6:
1365: sin6 = (struct sockaddr_in6 *) sa;
1366: inet_ntop(AF_INET6, &sin6->sin6_addr, addr6, INET6_ADDRSTRLEN);
1367: zval_dtor(addr);
1368: ZVAL_STRING(addr, addr6, 1);
1369:
1370: if (port != NULL) {
1371: zval_dtor(port);
1372: ZVAL_LONG(port, htons(sin6->sin6_port));
1373: }
1374: RETURN_TRUE;
1375: break;
1376: #endif
1377: case AF_INET:
1378: sin = (struct sockaddr_in *) sa;
1379: while (inet_ntoa_lock == 1);
1380: inet_ntoa_lock = 1;
1381: addr_string = inet_ntoa(sin->sin_addr);
1382: inet_ntoa_lock = 0;
1383:
1384: zval_dtor(addr);
1385: ZVAL_STRING(addr, addr_string, 1);
1386:
1387: if (port != NULL) {
1388: zval_dtor(port);
1389: ZVAL_LONG(port, htons(sin->sin_port));
1390: }
1391: RETURN_TRUE;
1392: break;
1393:
1394: case AF_UNIX:
1395: s_un = (struct sockaddr_un *) sa;
1396:
1397: zval_dtor(addr);
1398: ZVAL_STRING(addr, s_un->sun_path, 1);
1399: RETURN_TRUE;
1400: break;
1401:
1402: default:
1403: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported address family %d", sa->sa_family);
1404: RETURN_FALSE;
1405: }
1406: }
1407: /* }}} */
1408:
1409: /* {{{ proto bool socket_getpeername(resource socket, string &addr[, int &port])
1410: 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. */
1411: PHP_FUNCTION(socket_getpeername)
1412: {
1413: zval *arg1, *arg2, *arg3 = NULL;
1414: php_sockaddr_storage sa_storage;
1415: php_socket *php_sock;
1416: struct sockaddr *sa;
1417: struct sockaddr_in *sin;
1418: #if HAVE_IPV6
1419: struct sockaddr_in6 *sin6;
1420: char addr6[INET6_ADDRSTRLEN+1];
1421: #endif
1422: struct sockaddr_un *s_un;
1423: char *addr_string;
1424: socklen_t salen = sizeof(php_sockaddr_storage);
1425:
1426: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rz|z", &arg1, &arg2, &arg3) == FAILURE) {
1427: return;
1428: }
1429:
1430: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
1431:
1432: sa = (struct sockaddr *) &sa_storage;
1433:
1434: if (getpeername(php_sock->bsd_socket, sa, &salen) < 0) {
1435: PHP_SOCKET_ERROR(php_sock, "unable to retrieve peer name", errno);
1436: RETURN_FALSE;
1437: }
1438:
1439: switch (sa->sa_family) {
1440: #if HAVE_IPV6
1441: case AF_INET6:
1442: sin6 = (struct sockaddr_in6 *) sa;
1443: inet_ntop(AF_INET6, &sin6->sin6_addr, addr6, INET6_ADDRSTRLEN);
1444: zval_dtor(arg2);
1445: ZVAL_STRING(arg2, addr6, 1);
1446:
1447: if (arg3 != NULL) {
1448: zval_dtor(arg3);
1449: ZVAL_LONG(arg3, htons(sin6->sin6_port));
1450: }
1451:
1452: RETURN_TRUE;
1453: break;
1454: #endif
1455: case AF_INET:
1456: sin = (struct sockaddr_in *) sa;
1457: while (inet_ntoa_lock == 1);
1458: inet_ntoa_lock = 1;
1459: addr_string = inet_ntoa(sin->sin_addr);
1460: inet_ntoa_lock = 0;
1461:
1462: zval_dtor(arg2);
1463: ZVAL_STRING(arg2, addr_string, 1);
1464:
1465: if (arg3 != NULL) {
1466: zval_dtor(arg3);
1467: ZVAL_LONG(arg3, htons(sin->sin_port));
1468: }
1469:
1470: RETURN_TRUE;
1471: break;
1472:
1473: case AF_UNIX:
1474: s_un = (struct sockaddr_un *) sa;
1475:
1476: zval_dtor(arg2);
1477: ZVAL_STRING(arg2, s_un->sun_path, 1);
1478: RETURN_TRUE;
1479: break;
1480:
1481: default:
1482: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported address family %d", sa->sa_family);
1483: RETURN_FALSE;
1484: }
1485: }
1486: /* }}} */
1487:
1488: /* {{{ proto resource socket_create(int domain, int type, int protocol) U
1489: Creates an endpoint for communication in the domain specified by domain, of type specified by type */
1490: PHP_FUNCTION(socket_create)
1491: {
1492: long arg1, arg2, arg3;
1.1.1.2 misho 1493: php_socket *php_sock = php_create_socket();
1.1 misho 1494:
1495: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lll", &arg1, &arg2, &arg3) == FAILURE) {
1496: efree(php_sock);
1497: return;
1498: }
1499:
1500: if (arg1 != AF_UNIX
1501: #if HAVE_IPV6
1502: && arg1 != AF_INET6
1503: #endif
1504: && arg1 != AF_INET) {
1505: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid socket domain [%ld] specified for argument 1, assuming AF_INET", arg1);
1506: arg1 = AF_INET;
1507: }
1508:
1509: if (arg2 > 10) {
1510: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid socket type [%ld] specified for argument 2, assuming SOCK_STREAM", arg2);
1511: arg2 = SOCK_STREAM;
1512: }
1513:
1514: php_sock->bsd_socket = socket(arg1, arg2, arg3);
1515: php_sock->type = arg1;
1516:
1517: if (IS_INVALID_SOCKET(php_sock)) {
1518: SOCKETS_G(last_error) = errno;
1519: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to create socket [%d]: %s", errno, php_strerror(errno TSRMLS_CC));
1520: efree(php_sock);
1521: RETURN_FALSE;
1522: }
1523:
1524: php_sock->error = 0;
1525: php_sock->blocking = 1;
1526:
1527: ZEND_REGISTER_RESOURCE(return_value, php_sock, le_socket);
1528: }
1529: /* }}} */
1530:
1531: /* {{{ proto bool socket_connect(resource socket, string addr [, int port])
1532: Opens a connection to addr:port on the socket specified by socket */
1533: PHP_FUNCTION(socket_connect)
1534: {
1535: zval *arg1;
1536: php_socket *php_sock;
1537: char *addr;
1538: int retval, addr_len;
1539: long port = 0;
1540: int argc = ZEND_NUM_ARGS();
1541:
1542: if (zend_parse_parameters(argc TSRMLS_CC, "rs|l", &arg1, &addr, &addr_len, &port) == FAILURE) {
1543: return;
1544: }
1545:
1546: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
1547:
1548: switch(php_sock->type) {
1549: #if HAVE_IPV6
1.1.1.2 misho 1550: case AF_INET6: {
1551: struct sockaddr_in6 sin6 = {0};
1552:
1.1 misho 1553: if (argc != 3) {
1554: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Socket of type AF_INET6 requires 3 arguments");
1555: RETURN_FALSE;
1556: }
1557:
1558: memset(&sin6, 0, sizeof(struct sockaddr_in6));
1559:
1560: sin6.sin6_family = AF_INET6;
1561: sin6.sin6_port = htons((unsigned short int)port);
1562:
1563: if (! php_set_inet6_addr(&sin6, addr, php_sock TSRMLS_CC)) {
1564: RETURN_FALSE;
1565: }
1566:
1567: retval = connect(php_sock->bsd_socket, (struct sockaddr *)&sin6, sizeof(struct sockaddr_in6));
1568: break;
1.1.1.2 misho 1569: }
1.1 misho 1570: #endif
1.1.1.2 misho 1571: case AF_INET: {
1572: struct sockaddr_in sin = {0};
1573:
1.1 misho 1574: if (argc != 3) {
1575: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Socket of type AF_INET requires 3 arguments");
1576: RETURN_FALSE;
1577: }
1578:
1579: sin.sin_family = AF_INET;
1580: sin.sin_port = htons((unsigned short int)port);
1581:
1582: if (! php_set_inet_addr(&sin, addr, php_sock TSRMLS_CC)) {
1583: RETURN_FALSE;
1584: }
1585:
1586: retval = connect(php_sock->bsd_socket, (struct sockaddr *)&sin, sizeof(struct sockaddr_in));
1587: break;
1.1.1.2 misho 1588: }
1.1 misho 1589:
1.1.1.2 misho 1590: case AF_UNIX: {
1591: struct sockaddr_un s_un = {0};
1592:
1.1 misho 1593: if (addr_len >= sizeof(s_un.sun_path)) {
1594: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Path too long");
1595: RETURN_FALSE;
1596: }
1597:
1598: s_un.sun_family = AF_UNIX;
1599: memcpy(&s_un.sun_path, addr, addr_len);
1.1.1.2 misho 1600: retval = connect(php_sock->bsd_socket, (struct sockaddr *) &s_un,
1601: (socklen_t)(XtOffsetOf(struct sockaddr_un, sun_path) + addr_len));
1.1 misho 1602: break;
1.1.1.2 misho 1603: }
1.1 misho 1604:
1605: default:
1606: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported socket type %d", php_sock->type);
1607: RETURN_FALSE;
1608: }
1609:
1610: if (retval != 0) {
1611: PHP_SOCKET_ERROR(php_sock, "unable to connect", errno);
1612: RETURN_FALSE;
1613: }
1614:
1615: RETURN_TRUE;
1616: }
1617: /* }}} */
1618:
1619: /* {{{ proto string socket_strerror(int errno)
1620: Returns a string describing an error */
1621: PHP_FUNCTION(socket_strerror)
1622: {
1623: long arg1;
1624:
1625: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &arg1) == FAILURE) {
1626: return;
1627: }
1628:
1629: RETURN_STRING(php_strerror(arg1 TSRMLS_CC), 1);
1630: }
1631: /* }}} */
1632:
1633: /* {{{ proto bool socket_bind(resource socket, string addr [, int port])
1634: Binds an open socket to a listening port, port is only specified in AF_INET family. */
1635: PHP_FUNCTION(socket_bind)
1636: {
1637: zval *arg1;
1638: php_sockaddr_storage sa_storage;
1639: struct sockaddr *sock_type = (struct sockaddr*) &sa_storage;
1640: php_socket *php_sock;
1641: char *addr;
1642: int addr_len;
1643: long port = 0;
1644: long retval = 0;
1645:
1646: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|l", &arg1, &addr, &addr_len, &port) == FAILURE) {
1647: return;
1648: }
1649:
1650: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
1651:
1652: switch(php_sock->type) {
1653: case AF_UNIX:
1654: {
1655: struct sockaddr_un *sa = (struct sockaddr_un *) sock_type;
1656: memset(sa, 0, sizeof(sa_storage));
1657: sa->sun_family = AF_UNIX;
1658: snprintf(sa->sun_path, 108, "%s", addr);
1659: retval = bind(php_sock->bsd_socket, (struct sockaddr *) sa, SUN_LEN(sa));
1660: break;
1661: }
1662:
1663: case AF_INET:
1664: {
1665: struct sockaddr_in *sa = (struct sockaddr_in *) sock_type;
1666:
1667: memset(sa, 0, sizeof(sa_storage)); /* Apparently, Mac OSX needs this */
1668:
1669: sa->sin_family = AF_INET;
1670: sa->sin_port = htons((unsigned short) port);
1671:
1672: if (! php_set_inet_addr(sa, addr, php_sock TSRMLS_CC)) {
1673: RETURN_FALSE;
1674: }
1675:
1676: retval = bind(php_sock->bsd_socket, (struct sockaddr *)sa, sizeof(struct sockaddr_in));
1677: break;
1678: }
1679: #if HAVE_IPV6
1680: case AF_INET6:
1681: {
1682: struct sockaddr_in6 *sa = (struct sockaddr_in6 *) sock_type;
1683:
1684: memset(sa, 0, sizeof(sa_storage)); /* Apparently, Mac OSX needs this */
1685:
1686: sa->sin6_family = AF_INET6;
1687: sa->sin6_port = htons((unsigned short) port);
1688:
1689: if (! php_set_inet6_addr(sa, addr, php_sock TSRMLS_CC)) {
1690: RETURN_FALSE;
1691: }
1692:
1693: retval = bind(php_sock->bsd_socket, (struct sockaddr *)sa, sizeof(struct sockaddr_in6));
1694: break;
1695: }
1696: #endif
1697: default:
1698: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unsupported socket type '%d', must be AF_UNIX, AF_INET, or AF_INET6", php_sock->type);
1699: RETURN_FALSE;
1700: }
1701:
1702: if (retval != 0) {
1703: PHP_SOCKET_ERROR(php_sock, "unable to bind address", errno);
1704: RETURN_FALSE;
1705: }
1706:
1707: RETURN_TRUE;
1708: }
1709: /* }}} */
1710:
1711: /* {{{ proto int socket_recv(resource socket, string &buf, int len, int flags)
1712: Receives data from a connected socket */
1713: PHP_FUNCTION(socket_recv)
1714: {
1715: zval *php_sock_res, *buf;
1716: char *recv_buf;
1717: php_socket *php_sock;
1718: int retval;
1719: long len, flags;
1720:
1721: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzll", &php_sock_res, &buf, &len, &flags) == FAILURE) {
1722: return;
1723: }
1724:
1725: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &php_sock_res, -1, le_socket_name, le_socket);
1726:
1727: /* overflow check */
1728: if ((len + 1) < 2) {
1729: RETURN_FALSE;
1730: }
1731:
1732: recv_buf = emalloc(len + 1);
1733: memset(recv_buf, 0, len + 1);
1734:
1735: if ((retval = recv(php_sock->bsd_socket, recv_buf, len, flags)) < 1) {
1736: efree(recv_buf);
1737:
1738: zval_dtor(buf);
1739: Z_TYPE_P(buf) = IS_NULL;
1740: } else {
1741: recv_buf[retval] = '\0';
1742:
1743: /* Rebuild buffer zval */
1744: zval_dtor(buf);
1745:
1746: Z_STRVAL_P(buf) = recv_buf;
1747: Z_STRLEN_P(buf) = retval;
1748: Z_TYPE_P(buf) = IS_STRING;
1749: }
1750:
1751: if (retval == -1) {
1752: PHP_SOCKET_ERROR(php_sock, "unable to read from socket", errno);
1753: RETURN_FALSE;
1754: }
1755:
1756: RETURN_LONG(retval);
1757: }
1758: /* }}} */
1759:
1760: /* {{{ proto int socket_send(resource socket, string buf, int len, int flags)
1761: Sends data to a connected socket */
1762: PHP_FUNCTION(socket_send)
1763: {
1764: zval *arg1;
1765: php_socket *php_sock;
1766: int buf_len, retval;
1767: long len, flags;
1768: char *buf;
1769:
1770: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rsll", &arg1, &buf, &buf_len, &len, &flags) == FAILURE) {
1771: return;
1772: }
1773:
1774: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
1775:
1776: retval = send(php_sock->bsd_socket, buf, (buf_len < len ? buf_len : len), flags);
1777:
1778: if (retval == -1) {
1779: PHP_SOCKET_ERROR(php_sock, "unable to write to socket", errno);
1780: RETURN_FALSE;
1781: }
1782:
1783: RETURN_LONG(retval);
1784: }
1785: /* }}} */
1786:
1787: /* {{{ proto int socket_recvfrom(resource socket, string &buf, int len, int flags, string &name [, int &port])
1788: Receives data from a socket, connected or not */
1789: PHP_FUNCTION(socket_recvfrom)
1790: {
1791: zval *arg1, *arg2, *arg5, *arg6 = NULL;
1792: php_socket *php_sock;
1793: struct sockaddr_un s_un;
1794: struct sockaddr_in sin;
1795: #if HAVE_IPV6
1796: struct sockaddr_in6 sin6;
1797: char addr6[INET6_ADDRSTRLEN];
1798: #endif
1799: socklen_t slen;
1800: int retval;
1801: long arg3, arg4;
1802: char *recv_buf, *address;
1803:
1804: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rzllz|z", &arg1, &arg2, &arg3, &arg4, &arg5, &arg6) == FAILURE) {
1805: return;
1806: }
1807:
1808: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
1809:
1810: /* overflow check */
1811: if ((arg3 + 2) < 3) {
1812: RETURN_FALSE;
1813: }
1814:
1815: recv_buf = emalloc(arg3 + 2);
1816: memset(recv_buf, 0, arg3 + 2);
1817:
1818: switch (php_sock->type) {
1819: case AF_UNIX:
1820: slen = sizeof(s_un);
1821: s_un.sun_family = AF_UNIX;
1822: retval = recvfrom(php_sock->bsd_socket, recv_buf, arg3, arg4, (struct sockaddr *)&s_un, (socklen_t *)&slen);
1823:
1824: if (retval < 0) {
1825: PHP_SOCKET_ERROR(php_sock, "unable to recvfrom", errno);
1.1.1.3 ! misho 1826: efree(recv_buf);
1.1 misho 1827: RETURN_FALSE;
1828: }
1829:
1830: zval_dtor(arg2);
1831: zval_dtor(arg5);
1832:
1833: ZVAL_STRINGL(arg2, recv_buf, retval, 0);
1834: ZVAL_STRING(arg5, s_un.sun_path, 1);
1835: break;
1836:
1837: case AF_INET:
1838: slen = sizeof(sin);
1839: memset(&sin, 0, slen);
1840: sin.sin_family = AF_INET;
1841:
1842: if (arg6 == NULL) {
1843: efree(recv_buf);
1844: WRONG_PARAM_COUNT;
1845: }
1846:
1847: retval = recvfrom(php_sock->bsd_socket, recv_buf, arg3, arg4, (struct sockaddr *)&sin, (socklen_t *)&slen);
1848:
1849: if (retval < 0) {
1850: PHP_SOCKET_ERROR(php_sock, "unable to recvfrom", errno);
1.1.1.3 ! misho 1851: efree(recv_buf);
1.1 misho 1852: RETURN_FALSE;
1853: }
1854:
1855: zval_dtor(arg2);
1856: zval_dtor(arg5);
1857: zval_dtor(arg6);
1858:
1859: address = inet_ntoa(sin.sin_addr);
1860:
1861: ZVAL_STRINGL(arg2, recv_buf, retval, 0);
1862: ZVAL_STRING(arg5, address ? address : "0.0.0.0", 1);
1863: ZVAL_LONG(arg6, ntohs(sin.sin_port));
1864: break;
1865: #if HAVE_IPV6
1866: case AF_INET6:
1867: slen = sizeof(sin6);
1868: memset(&sin6, 0, slen);
1869: sin6.sin6_family = AF_INET6;
1870:
1871: if (arg6 == NULL) {
1872: efree(recv_buf);
1873: WRONG_PARAM_COUNT;
1874: }
1875:
1876: retval = recvfrom(php_sock->bsd_socket, recv_buf, arg3, arg4, (struct sockaddr *)&sin6, (socklen_t *)&slen);
1877:
1878: if (retval < 0) {
1879: PHP_SOCKET_ERROR(php_sock, "unable to recvfrom", errno);
1.1.1.3 ! misho 1880: efree(recv_buf);
1.1 misho 1881: RETURN_FALSE;
1882: }
1883:
1884: zval_dtor(arg2);
1885: zval_dtor(arg5);
1886: zval_dtor(arg6);
1887:
1888: memset(addr6, 0, INET6_ADDRSTRLEN);
1889: inet_ntop(AF_INET6, &sin6.sin6_addr, addr6, INET6_ADDRSTRLEN);
1890:
1891: ZVAL_STRINGL(arg2, recv_buf, retval, 0);
1892: ZVAL_STRING(arg5, addr6[0] ? addr6 : "::", 1);
1893: ZVAL_LONG(arg6, ntohs(sin6.sin6_port));
1894: break;
1895: #endif
1896: default:
1897: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported socket type %d", php_sock->type);
1898: RETURN_FALSE;
1899: }
1900:
1901: RETURN_LONG(retval);
1902: }
1903: /* }}} */
1904:
1905: /* {{{ proto int socket_sendto(resource socket, string buf, int len, int flags, string addr [, int port])
1906: Sends a message to a socket, whether it is connected or not */
1907: PHP_FUNCTION(socket_sendto)
1908: {
1909: zval *arg1;
1910: php_socket *php_sock;
1911: struct sockaddr_un s_un;
1912: struct sockaddr_in sin;
1913: #if HAVE_IPV6
1914: struct sockaddr_in6 sin6;
1915: #endif
1916: int retval, buf_len, addr_len;
1917: long len, flags, port = 0;
1918: char *buf, *addr;
1919: int argc = ZEND_NUM_ARGS();
1920:
1921: if (zend_parse_parameters(argc TSRMLS_CC, "rslls|l", &arg1, &buf, &buf_len, &len, &flags, &addr, &addr_len, &port) == FAILURE) {
1922: return;
1923: }
1924:
1925: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
1926:
1927: switch (php_sock->type) {
1928: case AF_UNIX:
1929: memset(&s_un, 0, sizeof(s_un));
1930: s_un.sun_family = AF_UNIX;
1931: snprintf(s_un.sun_path, 108, "%s", addr);
1932:
1933: retval = sendto(php_sock->bsd_socket, buf, (len > buf_len) ? buf_len : len, flags, (struct sockaddr *) &s_un, SUN_LEN(&s_un));
1934: break;
1935:
1936: case AF_INET:
1937: if (argc != 6) {
1938: WRONG_PARAM_COUNT;
1939: }
1940:
1941: memset(&sin, 0, sizeof(sin));
1942: sin.sin_family = AF_INET;
1943: sin.sin_port = htons((unsigned short) port);
1944:
1945: if (! php_set_inet_addr(&sin, addr, php_sock TSRMLS_CC)) {
1946: RETURN_FALSE;
1947: }
1948:
1949: retval = sendto(php_sock->bsd_socket, buf, (len > buf_len) ? buf_len : len, flags, (struct sockaddr *) &sin, sizeof(sin));
1950: break;
1951: #if HAVE_IPV6
1952: case AF_INET6:
1953: if (argc != 6) {
1954: WRONG_PARAM_COUNT;
1955: }
1956:
1957: memset(&sin6, 0, sizeof(sin6));
1958: sin6.sin6_family = AF_INET6;
1959: sin6.sin6_port = htons((unsigned short) port);
1960:
1961: if (! php_set_inet6_addr(&sin6, addr, php_sock TSRMLS_CC)) {
1962: RETURN_FALSE;
1963: }
1964:
1965: retval = sendto(php_sock->bsd_socket, buf, (len > buf_len) ? buf_len : len, flags, (struct sockaddr *) &sin6, sizeof(sin6));
1966: break;
1967: #endif
1968: default:
1969: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported socket type %d", php_sock->type);
1970: RETURN_FALSE;
1971: }
1972:
1973: if (retval == -1) {
1974: PHP_SOCKET_ERROR(php_sock, "unable to write to socket", errno);
1975: RETURN_FALSE;
1976: }
1977:
1978: RETURN_LONG(retval);
1979: }
1980: /* }}} */
1981:
1982: /* {{{ proto mixed socket_get_option(resource socket, int level, int optname) U
1983: Gets socket options for the socket */
1984: PHP_FUNCTION(socket_get_option)
1985: {
1986: zval *arg1;
1987: struct linger linger_val;
1988: struct timeval tv;
1989: #ifdef PHP_WIN32
1990: int timeout = 0;
1991: #endif
1992: socklen_t optlen;
1993: php_socket *php_sock;
1994: int other_val;
1995: long level, optname;
1996:
1997: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rll", &arg1, &level, &optname) == FAILURE) {
1998: return;
1999: }
2000:
2001: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
2002:
1.1.1.2 misho 2003: if (level == IPPROTO_IP) {
2004: switch (optname) {
2005: case IP_MULTICAST_IF: {
2006: struct in_addr if_addr;
2007: unsigned int if_index;
2008: optlen = sizeof(if_addr);
2009: if (getsockopt(php_sock->bsd_socket, level, optname, (char*)&if_addr, &optlen) != 0) {
2010: PHP_SOCKET_ERROR(php_sock, "unable to retrieve socket option", errno);
2011: RETURN_FALSE;
2012: }
2013: if (php_add4_to_if_index(&if_addr, php_sock, &if_index TSRMLS_CC) == SUCCESS) {
2014: RETURN_LONG((long) if_index);
2015: } else {
2016: RETURN_FALSE;
2017: }
2018: }
2019: }
2020: }
2021:
2022: /* sol_socket options and general case */
1.1 misho 2023: switch(optname) {
2024: case SO_LINGER:
2025: optlen = sizeof(linger_val);
2026:
2027: if (getsockopt(php_sock->bsd_socket, level, optname, (char*)&linger_val, &optlen) != 0) {
2028: PHP_SOCKET_ERROR(php_sock, "unable to retrieve socket option", errno);
2029: RETURN_FALSE;
2030: }
2031:
2032: array_init(return_value);
2033: add_assoc_long(return_value, "l_onoff", linger_val.l_onoff);
2034: add_assoc_long(return_value, "l_linger", linger_val.l_linger);
2035: break;
2036:
2037: case SO_RCVTIMEO:
2038: case SO_SNDTIMEO:
2039: #ifndef PHP_WIN32
2040: optlen = sizeof(tv);
2041:
2042: if (getsockopt(php_sock->bsd_socket, level, optname, (char*)&tv, &optlen) != 0) {
2043: PHP_SOCKET_ERROR(php_sock, "unable to retrieve socket option", errno);
2044: RETURN_FALSE;
2045: }
2046: #else
2047: optlen = sizeof(int);
2048:
2049: if (getsockopt(php_sock->bsd_socket, level, optname, (char*)&timeout, &optlen) != 0) {
2050: PHP_SOCKET_ERROR(php_sock, "unable to retrieve socket option", errno);
2051: RETURN_FALSE;
2052: }
2053:
2054: tv.tv_sec = timeout ? timeout / 1000 : 0;
2055: tv.tv_usec = timeout ? (timeout * 1000) % 1000000 : 0;
2056: #endif
2057:
2058: array_init(return_value);
2059:
2060: add_assoc_long(return_value, "sec", tv.tv_sec);
2061: add_assoc_long(return_value, "usec", tv.tv_usec);
2062: break;
1.1.1.2 misho 2063:
1.1 misho 2064: default:
2065: optlen = sizeof(other_val);
2066:
2067: if (getsockopt(php_sock->bsd_socket, level, optname, (char*)&other_val, &optlen) != 0) {
2068: PHP_SOCKET_ERROR(php_sock, "unable to retrieve socket option", errno);
2069: RETURN_FALSE;
2070: }
1.1.1.2 misho 2071: if (optlen == 1)
2072: other_val = *((unsigned char *)&other_val);
1.1 misho 2073:
2074: RETURN_LONG(other_val);
2075: break;
2076: }
2077: }
2078: /* }}} */
2079:
1.1.1.2 misho 2080: static int php_do_mcast_opt(php_socket *php_sock, int level, int optname, zval **arg4 TSRMLS_DC)
2081: {
2082: HashTable *opt_ht;
2083: unsigned int if_index;
2084: int retval;
2085: int (*mcast_req_fun)(php_socket *, int, struct sockaddr *, socklen_t,
2086: unsigned TSRMLS_DC);
2087: #ifdef HAS_MCAST_EXT
2088: int (*mcast_sreq_fun)(php_socket *, int, struct sockaddr *, socklen_t,
2089: struct sockaddr *, socklen_t, unsigned TSRMLS_DC);
2090: #endif
2091:
2092: switch (optname) {
2093: case MCAST_JOIN_GROUP:
2094: mcast_req_fun = &php_mcast_join;
2095: goto mcast_req_fun;
2096: case MCAST_LEAVE_GROUP:
2097: {
2098: php_sockaddr_storage group = {0};
2099: socklen_t glen;
2100:
2101: mcast_req_fun = &php_mcast_leave;
2102: mcast_req_fun:
2103: convert_to_array_ex(arg4);
2104: opt_ht = HASH_OF(*arg4);
2105:
2106: if (php_get_address_from_array(opt_ht, "group", php_sock, &group,
2107: &glen TSRMLS_CC) == FAILURE) {
2108: return FAILURE;
2109: }
2110: if (php_get_if_index_from_array(opt_ht, "interface", php_sock,
2111: &if_index TSRMLS_CC) == FAILURE) {
2112: return FAILURE;
2113: }
2114:
2115: retval = mcast_req_fun(php_sock, level, (struct sockaddr*)&group,
2116: glen, if_index TSRMLS_CC);
2117: break;
2118: }
2119:
2120: #ifdef HAS_MCAST_EXT
2121: case MCAST_BLOCK_SOURCE:
2122: mcast_sreq_fun = &php_mcast_block_source;
2123: goto mcast_sreq_fun;
2124: case MCAST_UNBLOCK_SOURCE:
2125: mcast_sreq_fun = &php_mcast_unblock_source;
2126: goto mcast_sreq_fun;
2127: case MCAST_JOIN_SOURCE_GROUP:
2128: mcast_sreq_fun = &php_mcast_join_source;
2129: goto mcast_sreq_fun;
2130: case MCAST_LEAVE_SOURCE_GROUP:
2131: {
2132: php_sockaddr_storage group = {0},
2133: source = {0};
2134: socklen_t glen,
2135: slen;
2136:
2137: mcast_sreq_fun = &php_mcast_leave_source;
2138: mcast_sreq_fun:
2139: convert_to_array_ex(arg4);
2140: opt_ht = HASH_OF(*arg4);
2141:
2142: if (php_get_address_from_array(opt_ht, "group", php_sock, &group,
2143: &glen TSRMLS_CC) == FAILURE) {
2144: return FAILURE;
2145: }
2146: if (php_get_address_from_array(opt_ht, "source", php_sock, &source,
2147: &slen TSRMLS_CC) == FAILURE) {
2148: return FAILURE;
2149: }
2150: if (php_get_if_index_from_array(opt_ht, "interface", php_sock,
2151: &if_index TSRMLS_CC) == FAILURE) {
2152: return FAILURE;
2153: }
2154:
2155: retval = mcast_sreq_fun(php_sock, level, (struct sockaddr*)&group,
2156: glen, (struct sockaddr*)&source, slen, if_index TSRMLS_CC);
2157: break;
2158: }
2159: #endif
2160: default:
2161: php_error_docref(NULL TSRMLS_CC, E_WARNING,
2162: "unexpected option in php_do_mcast_opt (level %d, option %d). "
2163: "This is a bug.", level, optname);
2164: return FAILURE;
2165: }
2166:
2167: if (retval != 0) {
2168: if (retval != -2) { /* error, but message already emitted */
2169: PHP_SOCKET_ERROR(php_sock, "unable to set socket option", errno);
2170: }
2171: return FAILURE;
2172: }
2173: return SUCCESS;
2174: }
2175:
1.1 misho 2176: /* {{{ proto bool socket_set_option(resource socket, int level, int optname, int|array optval)
2177: Sets socket options for the socket */
2178: PHP_FUNCTION(socket_set_option)
2179: {
1.1.1.2 misho 2180: zval *arg1, **arg4;
2181: struct linger lv;
2182: php_socket *php_sock;
2183: int ov, optlen, retval;
1.1 misho 2184: #ifdef PHP_WIN32
1.1.1.2 misho 2185: int timeout;
1.1 misho 2186: #else
1.1.1.2 misho 2187: struct timeval tv;
1.1 misho 2188: #endif
1.1.1.2 misho 2189: long level, optname;
2190: void *opt_ptr;
2191: HashTable *opt_ht;
2192: zval **l_onoff, **l_linger;
2193: zval **sec, **usec;
2194:
2195: /* Multicast */
2196: unsigned int if_index;
2197: struct in_addr if_addr;
2198: unsigned char ipv4_mcast_ttl_lback;
2199:
1.1 misho 2200: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rllZ", &arg1, &level, &optname, &arg4) == FAILURE) {
2201: return;
2202: }
2203:
2204: ZEND_FETCH_RESOURCE(php_sock, php_socket *, &arg1, -1, le_socket_name, le_socket);
2205:
2206: set_errno(0);
2207:
1.1.1.2 misho 2208: if (level == IPPROTO_IP) {
2209: switch (optname) {
2210: case MCAST_JOIN_GROUP:
2211: case MCAST_LEAVE_GROUP:
2212: #ifdef HAS_MCAST_EXT
2213: case MCAST_BLOCK_SOURCE:
2214: case MCAST_UNBLOCK_SOURCE:
2215: case MCAST_JOIN_SOURCE_GROUP:
2216: case MCAST_LEAVE_SOURCE_GROUP:
2217: #endif
2218: if (php_do_mcast_opt(php_sock, level, optname, arg4 TSRMLS_CC) == FAILURE) {
2219: RETURN_FALSE;
2220: } else {
2221: RETURN_TRUE;
2222: }
2223:
2224: case IP_MULTICAST_IF:
2225: if (php_get_if_index_from_zval(*arg4, &if_index TSRMLS_CC) == FAILURE) {
2226: RETURN_FALSE;
2227: }
2228:
2229: if (php_if_index_to_addr4(if_index, php_sock, &if_addr TSRMLS_CC) == FAILURE) {
2230: RETURN_FALSE;
2231: }
2232: opt_ptr = &if_addr;
2233: optlen = sizeof(if_addr);
2234: goto dosockopt;
2235:
2236: case IP_MULTICAST_LOOP:
2237: convert_to_boolean_ex(arg4);
2238: goto ipv4_loop_ttl;
2239: case IP_MULTICAST_TTL:
2240: convert_to_long_ex(arg4);
2241: if (Z_LVAL_PP(arg4) < 0L || Z_LVAL_PP(arg4) > 255L) {
2242: php_error_docref(NULL TSRMLS_CC, E_WARNING,
2243: "Expected a value between 0 and 255");
2244: RETURN_FALSE;
2245: }
2246: ipv4_loop_ttl:
2247: ipv4_mcast_ttl_lback = (unsigned char) Z_LVAL_PP(arg4);
2248: opt_ptr = &ipv4_mcast_ttl_lback;
2249: optlen = sizeof(ipv4_mcast_ttl_lback);
2250: goto dosockopt;
2251: }
2252: }
2253:
2254: #if HAVE_IPV6
2255: else if (level == IPPROTO_IPV6) {
2256: switch (optname) {
2257: case MCAST_JOIN_GROUP:
2258: case MCAST_LEAVE_GROUP:
2259: #ifdef HAS_MCAST_EXT
2260: case MCAST_BLOCK_SOURCE:
2261: case MCAST_UNBLOCK_SOURCE:
2262: case MCAST_JOIN_SOURCE_GROUP:
2263: case MCAST_LEAVE_SOURCE_GROUP:
2264: #endif
2265: if (php_do_mcast_opt(php_sock, level, optname, arg4 TSRMLS_CC) == FAILURE) {
2266: RETURN_FALSE;
2267: } else {
2268: RETURN_TRUE;
2269: }
2270:
2271: case IPV6_MULTICAST_IF:
2272: if (php_get_if_index_from_zval(*arg4, &if_index TSRMLS_CC) == FAILURE) {
2273: RETURN_FALSE;
2274: }
2275:
2276: opt_ptr = &if_index;
2277: optlen = sizeof(if_index);
2278: goto dosockopt;
2279:
2280: case IPV6_MULTICAST_LOOP:
2281: convert_to_boolean_ex(arg4);
2282: goto ipv6_loop_hops;
2283: case IPV6_MULTICAST_HOPS:
2284: convert_to_long_ex(arg4);
2285: if (Z_LVAL_PP(arg4) < -1L || Z_LVAL_PP(arg4) > 255L) {
2286: php_error_docref(NULL TSRMLS_CC, E_WARNING,
2287: "Expected a value between -1 and 255");
2288: RETURN_FALSE;
2289: }
2290: ipv6_loop_hops:
2291: ov = (int) Z_LVAL_PP(arg4);
2292: opt_ptr = &ov;
2293: optlen = sizeof(ov);
2294: goto dosockopt;
2295: }
2296: }
2297: #endif
2298:
1.1 misho 2299: switch (optname) {
1.1.1.2 misho 2300: case SO_LINGER: {
2301: const char l_onoff_key[] = "l_onoff";
2302: const char l_linger_key[] = "l_linger";
2303:
1.1 misho 2304: convert_to_array_ex(arg4);
2305: opt_ht = HASH_OF(*arg4);
2306:
1.1.1.2 misho 2307: if (zend_hash_find(opt_ht, l_onoff_key, sizeof(l_onoff_key), (void **)&l_onoff) == FAILURE) {
1.1 misho 2308: php_error_docref(NULL TSRMLS_CC, E_WARNING, "no key \"%s\" passed in optval", l_onoff_key);
2309: RETURN_FALSE;
2310: }
1.1.1.2 misho 2311: if (zend_hash_find(opt_ht, l_linger_key, sizeof(l_linger_key), (void **)&l_linger) == FAILURE) {
1.1 misho 2312: php_error_docref(NULL TSRMLS_CC, E_WARNING, "no key \"%s\" passed in optval", l_linger_key);
2313: RETURN_FALSE;
2314: }
2315:
2316: convert_to_long_ex(l_onoff);
2317: convert_to_long_ex(l_linger);
2318:
2319: lv.l_onoff = (unsigned short)Z_LVAL_PP(l_onoff);
2320: lv.l_linger = (unsigned short)Z_LVAL_PP(l_linger);
2321:
2322: optlen = sizeof(lv);
2323: opt_ptr = &lv;
2324: break;
1.1.1.2 misho 2325: }
1.1 misho 2326:
2327: case SO_RCVTIMEO:
1.1.1.2 misho 2328: case SO_SNDTIMEO: {
2329: const char sec_key[] = "sec";
2330: const char usec_key[] = "usec";
2331:
1.1 misho 2332: convert_to_array_ex(arg4);
2333: opt_ht = HASH_OF(*arg4);
2334:
1.1.1.2 misho 2335: if (zend_hash_find(opt_ht, sec_key, sizeof(sec_key), (void **)&sec) == FAILURE) {
1.1 misho 2336: php_error_docref(NULL TSRMLS_CC, E_WARNING, "no key \"%s\" passed in optval", sec_key);
2337: RETURN_FALSE;
2338: }
1.1.1.2 misho 2339: if (zend_hash_find(opt_ht, usec_key, sizeof(usec_key), (void **)&usec) == FAILURE) {
1.1 misho 2340: php_error_docref(NULL TSRMLS_CC, E_WARNING, "no key \"%s\" passed in optval", usec_key);
2341: RETURN_FALSE;
2342: }
2343:
2344: convert_to_long_ex(sec);
2345: convert_to_long_ex(usec);
2346: #ifndef PHP_WIN32
2347: tv.tv_sec = Z_LVAL_PP(sec);
2348: tv.tv_usec = Z_LVAL_PP(usec);
2349: optlen = sizeof(tv);
2350: opt_ptr = &tv;
2351: #else
2352: timeout = Z_LVAL_PP(sec) * 1000 + Z_LVAL_PP(usec) / 1000;
2353: optlen = sizeof(int);
2354: opt_ptr = &timeout;
2355: #endif
2356: break;
1.1.1.2 misho 2357: }
2358:
1.1 misho 2359: default:
2360: convert_to_long_ex(arg4);
2361: ov = Z_LVAL_PP(arg4);
2362:
2363: optlen = sizeof(ov);
2364: opt_ptr = &ov;
2365: break;
2366: }
2367:
1.1.1.2 misho 2368: dosockopt:
1.1 misho 2369: retval = setsockopt(php_sock->bsd_socket, level, optname, opt_ptr, optlen);
2370: if (retval != 0) {
1.1.1.2 misho 2371: if (retval != -2) { /* error, but message already emitted */
2372: PHP_SOCKET_ERROR(php_sock, "unable to set socket option", errno);
2373: }
1.1 misho 2374: RETURN_FALSE;
2375: }
2376:
2377: RETURN_TRUE;
2378: }
2379: /* }}} */
2380:
2381: #ifdef HAVE_SOCKETPAIR
2382: /* {{{ proto bool socket_create_pair(int domain, int type, int protocol, array &fd) U
2383: Creates a pair of indistinguishable sockets and stores them in fds. */
2384: PHP_FUNCTION(socket_create_pair)
2385: {
2386: zval *retval[2], *fds_array_zval;
2387: php_socket *php_sock[2];
2388: PHP_SOCKET fds_array[2];
2389: long domain, type, protocol;
2390:
2391: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "lllz", &domain, &type, &protocol, &fds_array_zval) == FAILURE) {
2392: return;
2393: }
2394:
1.1.1.2 misho 2395: php_sock[0] = php_create_socket();
2396: php_sock[1] = php_create_socket();
1.1 misho 2397:
2398: if (domain != AF_INET
2399: #if HAVE_IPV6
2400: && domain != AF_INET6
2401: #endif
2402: && domain != AF_UNIX) {
2403: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid socket domain [%ld] specified for argument 1, assuming AF_INET", domain);
2404: domain = AF_INET;
2405: }
2406:
2407: if (type > 10) {
2408: php_error_docref(NULL TSRMLS_CC, E_WARNING, "invalid socket type [%ld] specified for argument 2, assuming SOCK_STREAM", type);
2409: type = SOCK_STREAM;
2410: }
2411:
2412: if (socketpair(domain, type, protocol, fds_array) != 0) {
2413: SOCKETS_G(last_error) = errno;
2414: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to create socket pair [%d]: %s", errno, php_strerror(errno TSRMLS_CC));
2415: efree(php_sock[0]);
2416: efree(php_sock[1]);
2417: RETURN_FALSE;
2418: }
2419:
2420: zval_dtor(fds_array_zval);
2421: array_init(fds_array_zval);
2422:
2423: MAKE_STD_ZVAL(retval[0]);
2424: MAKE_STD_ZVAL(retval[1]);
2425:
2426: php_sock[0]->bsd_socket = fds_array[0];
2427: php_sock[1]->bsd_socket = fds_array[1];
2428: php_sock[0]->type = domain;
2429: php_sock[1]->type = domain;
2430: php_sock[0]->error = 0;
2431: php_sock[1]->error = 0;
2432: php_sock[0]->blocking = 1;
2433: php_sock[1]->blocking = 1;
2434:
2435: ZEND_REGISTER_RESOURCE(retval[0], php_sock[0], le_socket);
2436: ZEND_REGISTER_RESOURCE(retval[1], php_sock[1], le_socket);
2437:
2438: add_index_zval(fds_array_zval, 0, retval[0]);
2439: add_index_zval(fds_array_zval, 1, retval[1]);
2440:
2441: RETURN_TRUE;
2442: }
2443: /* }}} */
2444: #endif
2445:
2446: #ifdef HAVE_SHUTDOWN
2447: /* {{{ proto bool socket_shutdown(resource socket[, int how]) U
2448: Shuts down a socket for receiving, sending, or both. */
2449: PHP_FUNCTION(socket_shutdown)
2450: {
2451: zval *arg1;
2452: long how_shutdown = 2;
2453: php_socket *php_sock;
2454:
2455: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|l", &arg1, &how_shutdown) == FAILURE) {
2456: return;
2457: }
2458:
2459: ZEND_FETCH_RESOURCE(php_sock, php_socket*, &arg1, -1, le_socket_name, le_socket);
2460:
2461: if (shutdown(php_sock->bsd_socket, how_shutdown) != 0) {
2462: PHP_SOCKET_ERROR(php_sock, "unable to shutdown socket", errno);
2463: RETURN_FALSE;
2464: }
2465:
2466: RETURN_TRUE;
2467: }
2468: /* }}} */
2469: #endif
2470:
2471: /* {{{ proto int socket_last_error([resource socket]) U
2472: Returns the last socket error (either the last used or the provided socket resource) */
2473: PHP_FUNCTION(socket_last_error)
2474: {
2475: zval *arg1 = NULL;
2476: php_socket *php_sock;
2477:
2478: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &arg1) == FAILURE) {
2479: return;
2480: }
2481:
2482: if (arg1) {
2483: ZEND_FETCH_RESOURCE(php_sock, php_socket*, &arg1, -1, le_socket_name, le_socket);
2484: RETVAL_LONG(php_sock->error);
2485: } else {
2486: RETVAL_LONG(SOCKETS_G(last_error));
2487: }
2488: }
2489: /* }}} */
2490:
2491: /* {{{ proto void socket_clear_error([resource socket]) U
2492: Clears the error on the socket or the last error code. */
2493: PHP_FUNCTION(socket_clear_error)
2494: {
2495: zval *arg1 = NULL;
2496: php_socket *php_sock;
2497:
2498: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &arg1) == FAILURE) {
2499: return;
2500: }
2501:
2502: if (arg1) {
2503: ZEND_FETCH_RESOURCE(php_sock, php_socket*, &arg1, -1, le_socket_name, le_socket);
2504: php_sock->error = 0;
2505: } else {
2506: SOCKETS_G(last_error) = 0;
2507: }
2508:
2509: return;
2510: }
2511: /* }}} */
2512:
1.1.1.2 misho 2513: /* {{{ proto void socket_import_stream(resource stream)
2514: Imports a stream that encapsulates a socket into a socket extension resource. */
2515: PHP_FUNCTION(socket_import_stream)
2516: {
2517: zval *zstream;
2518: php_stream *stream;
2519: php_socket *retsock = NULL;
2520: PHP_SOCKET socket; /* fd */
2521: php_sockaddr_storage addr;
2522: socklen_t addr_len = sizeof(addr);
2523: #ifndef PHP_WIN32
2524: int t;
2525: #endif
2526:
2527: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zstream) == FAILURE) {
2528: return;
2529: }
2530: php_stream_from_zval(stream, &zstream);
2531:
2532: if (php_stream_cast(stream, PHP_STREAM_AS_SOCKETD, (void**)&socket, 1)) {
2533: /* error supposedly already shown */
2534: RETURN_FALSE;
2535: }
2536:
2537: retsock = php_create_socket();
2538:
2539: retsock->bsd_socket = socket;
2540:
2541: /* determine family */
2542: if (getsockname(socket, (struct sockaddr*)&addr, &addr_len) == 0) {
2543: retsock->type = addr.ss_family;
2544: } else {
2545: PHP_SOCKET_ERROR(retsock, "unable to obtain socket family", errno);
2546: goto error;
2547: }
2548:
2549: /* determine blocking mode */
2550: #ifndef PHP_WIN32
2551: t = fcntl(socket, F_GETFL);
2552: if(t == -1) {
2553: PHP_SOCKET_ERROR(retsock, "unable to obtain blocking state", errno);
2554: goto error;
2555: } else {
2556: retsock->blocking = !(t & O_NONBLOCK);
2557: }
2558: #else
2559: /* on windows, check if the stream is a socket stream and read its
2560: * private data; otherwise assume it's in non-blocking mode */
2561: if (php_stream_is(stream, PHP_STREAM_IS_SOCKET)) {
2562: retsock->blocking =
2563: ((php_netstream_data_t *)stream->abstract)->is_blocked;
2564: } else {
2565: retsock->blocking = 1;
2566: }
2567: #endif
2568:
2569: /* hold a zval reference to the stream (holding a php_stream* directly could
2570: * also be done, but this might be slightly better if in the future we want
2571: * to provide a socket_export_stream) */
2572: MAKE_STD_ZVAL(retsock->zstream);
2573: *retsock->zstream = *zstream;
2574: zval_copy_ctor(retsock->zstream);
2575: Z_UNSET_ISREF_P(retsock->zstream);
2576: Z_SET_REFCOUNT_P(retsock->zstream, 1);
2577:
2578: php_stream_set_option(stream, PHP_STREAM_OPTION_READ_BUFFER,
2579: PHP_STREAM_BUFFER_NONE, NULL);
2580:
2581: ZEND_REGISTER_RESOURCE(return_value, retsock, le_socket);
2582: return;
2583: error:
2584: if (retsock != NULL)
2585: efree(retsock);
2586: RETURN_FALSE;
2587: }
2588: /* }}} */
2589:
1.1 misho 2590: #endif
2591:
2592: /*
2593: * Local variables:
2594: * tab-width: 4
2595: * c-basic-offset: 4
2596: * End:
2597: * vim600: fdm=marker
2598: * vim: noet sw=4 ts=4
2599: */
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