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