1: /*
2: +----------------------------------------------------------------------+
3: | PHP Version 5 |
4: +----------------------------------------------------------------------+
5: | Copyright (c) 1997-2014 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: | Author: Kristian Koehntopp <kris@koehntopp.de> |
16: +----------------------------------------------------------------------+
17: */
18:
19: /* $Id: posix.c,v 1.1.1.4 2014/06/15 20:03:54 misho Exp $ */
20:
21: #ifdef HAVE_CONFIG_H
22: #include "config.h"
23: #endif
24:
25: #include "php.h"
26: #include <unistd.h>
27: #include "ext/standard/info.h"
28: #include "ext/standard/php_string.h"
29: #include "php_posix.h"
30:
31:
32: #if HAVE_POSIX
33:
34: #ifdef HAVE_SYS_TIME_H
35: #include <sys/time.h>
36: #endif
37:
38: #include <sys/resource.h>
39:
40: #if defined(_GNU_SOURCE) && !defined(__USE_GNU)
41: # define __USE_GNU
42: #endif
43:
44: #include <sys/utsname.h>
45: #include <sys/types.h>
46: #include <sys/stat.h>
47: #include <signal.h>
48: #include <sys/times.h>
49: #include <errno.h>
50: #include <grp.h>
51: #include <pwd.h>
52: #if HAVE_SYS_MKDEV_H
53: # include <sys/mkdev.h>
54: #endif
55:
56: ZEND_DECLARE_MODULE_GLOBALS(posix)
57: static PHP_MINFO_FUNCTION(posix);
58:
59: /* {{{ arginfo */
60: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_kill, 0, 0, 2)
61: ZEND_ARG_INFO(0, pid)
62: ZEND_ARG_INFO(0, sig)
63: ZEND_END_ARG_INFO()
64:
65: ZEND_BEGIN_ARG_INFO(arginfo_posix_getpid, 0)
66: ZEND_END_ARG_INFO()
67:
68: ZEND_BEGIN_ARG_INFO(arginfo_posix_getppid, 0)
69: ZEND_END_ARG_INFO()
70:
71: ZEND_BEGIN_ARG_INFO(arginfo_posix_getuid, 0)
72: ZEND_END_ARG_INFO()
73:
74: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_setuid, 0, 0, 1)
75: ZEND_ARG_INFO(0, uid)
76: ZEND_END_ARG_INFO()
77:
78: ZEND_BEGIN_ARG_INFO(arginfo_posix_geteuid, 0)
79: ZEND_END_ARG_INFO()
80:
81: #ifdef HAVE_SETEUID
82: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_seteuid, 0, 0, 1)
83: ZEND_ARG_INFO(0, uid)
84: ZEND_END_ARG_INFO()
85: #endif
86:
87: ZEND_BEGIN_ARG_INFO(arginfo_posix_getgid, 0)
88: ZEND_END_ARG_INFO()
89:
90: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_setgid, 0, 0, 1)
91: ZEND_ARG_INFO(0, gid)
92: ZEND_END_ARG_INFO()
93:
94: ZEND_BEGIN_ARG_INFO(arginfo_posix_getegid, 0)
95: ZEND_END_ARG_INFO()
96:
97: #ifdef HAVE_SETEGID
98: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_setegid, 0, 0, 1)
99: ZEND_ARG_INFO(0, gid)
100: ZEND_END_ARG_INFO()
101: #endif
102:
103: #ifdef HAVE_GETGROUPS
104: ZEND_BEGIN_ARG_INFO(arginfo_posix_getgroups, 0)
105: ZEND_END_ARG_INFO()
106: #endif
107:
108: #ifdef HAVE_GETLOGIN
109: ZEND_BEGIN_ARG_INFO(arginfo_posix_getlogin, 0)
110: ZEND_END_ARG_INFO()
111: #endif
112:
113: ZEND_BEGIN_ARG_INFO(arginfo_posix_getpgrp, 0)
114: ZEND_END_ARG_INFO()
115:
116: #ifdef HAVE_SETSID
117: ZEND_BEGIN_ARG_INFO(arginfo_posix_setsid, 0)
118: ZEND_END_ARG_INFO()
119: #endif
120:
121: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_setpgid, 0, 0, 2)
122: ZEND_ARG_INFO(0, pid)
123: ZEND_ARG_INFO(0, pgid)
124: ZEND_END_ARG_INFO()
125:
126: #ifdef HAVE_GETPGID
127: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_getpgid, 0, 0, 1)
128: ZEND_ARG_INFO(0, pid)
129: ZEND_END_ARG_INFO()
130: #endif
131:
132: #ifdef HAVE_GETSID
133: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_getsid, 0, 0, 1)
134: ZEND_ARG_INFO(0, pid)
135: ZEND_END_ARG_INFO()
136: #endif
137:
138: ZEND_BEGIN_ARG_INFO(arginfo_posix_uname, 0)
139: ZEND_END_ARG_INFO()
140:
141: ZEND_BEGIN_ARG_INFO(arginfo_posix_times, 0)
142: ZEND_END_ARG_INFO()
143:
144: #ifdef HAVE_CTERMID
145: ZEND_BEGIN_ARG_INFO(arginfo_posix_ctermid, 0)
146: ZEND_END_ARG_INFO()
147: #endif
148:
149: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_ttyname, 0, 0, 1)
150: ZEND_ARG_INFO(0, fd)
151: ZEND_END_ARG_INFO()
152:
153: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_isatty, 0, 0, 1)
154: ZEND_ARG_INFO(0, fd)
155: ZEND_END_ARG_INFO()
156:
157: ZEND_BEGIN_ARG_INFO(arginfo_posix_getcwd, 0)
158: ZEND_END_ARG_INFO()
159:
160: #ifdef HAVE_MKFIFO
161: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_mkfifo, 0, 0, 2)
162: ZEND_ARG_INFO(0, pathname)
163: ZEND_ARG_INFO(0, mode)
164: ZEND_END_ARG_INFO()
165: #endif
166:
167: #ifdef HAVE_MKNOD
168: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_mknod, 0, 0, 2)
169: ZEND_ARG_INFO(0, pathname)
170: ZEND_ARG_INFO(0, mode)
171: ZEND_ARG_INFO(0, major)
172: ZEND_ARG_INFO(0, minor)
173: ZEND_END_ARG_INFO()
174: #endif
175:
176: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_access, 0, 0, 1)
177: ZEND_ARG_INFO(0, file)
178: ZEND_ARG_INFO(0, mode)
179: ZEND_END_ARG_INFO()
180:
181: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_getgrnam, 0, 0, 1)
182: ZEND_ARG_INFO(0, name)
183: ZEND_END_ARG_INFO()
184:
185: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_getgrgid, 0, 0, 1)
186: ZEND_ARG_INFO(0, gid)
187: ZEND_END_ARG_INFO()
188:
189: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_getpwnam, 0, 0, 1)
190: ZEND_ARG_INFO(0, username)
191: ZEND_END_ARG_INFO()
192:
193: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_getpwuid, 0, 0, 1)
194: ZEND_ARG_INFO(0, uid)
195: ZEND_END_ARG_INFO()
196:
197: #ifdef HAVE_GETRLIMIT
198: ZEND_BEGIN_ARG_INFO(arginfo_posix_getrlimit, 0)
199: ZEND_END_ARG_INFO()
200: #endif
201:
202: ZEND_BEGIN_ARG_INFO(arginfo_posix_get_last_error, 0)
203: ZEND_END_ARG_INFO()
204:
205: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_strerror, 0, 0, 1)
206: ZEND_ARG_INFO(0, errno)
207: ZEND_END_ARG_INFO()
208:
209: #ifdef HAVE_INITGROUPS
210: ZEND_BEGIN_ARG_INFO_EX(arginfo_posix_initgroups, 0, 0, 2)
211: ZEND_ARG_INFO(0, name)
212: ZEND_ARG_INFO(0, base_group_id)
213: ZEND_END_ARG_INFO()
214: #endif
215: /* }}} */
216:
217: /* {{{ posix_functions[]
218: */
219: const zend_function_entry posix_functions[] = {
220: /* POSIX.1, 3.3 */
221: PHP_FE(posix_kill, arginfo_posix_kill)
222:
223: /* POSIX.1, 4.1 */
224: PHP_FE(posix_getpid, arginfo_posix_getpid)
225: PHP_FE(posix_getppid, arginfo_posix_getppid)
226:
227: /* POSIX.1, 4.2 */
228: PHP_FE(posix_getuid, arginfo_posix_getuid)
229: PHP_FE(posix_setuid, arginfo_posix_setuid)
230: PHP_FE(posix_geteuid, arginfo_posix_geteuid)
231: #ifdef HAVE_SETEUID
232: PHP_FE(posix_seteuid, arginfo_posix_seteuid)
233: #endif
234: PHP_FE(posix_getgid, arginfo_posix_getgid)
235: PHP_FE(posix_setgid, arginfo_posix_setgid)
236: PHP_FE(posix_getegid, arginfo_posix_getegid)
237: #ifdef HAVE_SETEGID
238: PHP_FE(posix_setegid, arginfo_posix_setegid)
239: #endif
240: #ifdef HAVE_GETGROUPS
241: PHP_FE(posix_getgroups, arginfo_posix_getgroups)
242: #endif
243: #ifdef HAVE_GETLOGIN
244: PHP_FE(posix_getlogin, arginfo_posix_getlogin)
245: #endif
246:
247: /* POSIX.1, 4.3 */
248: PHP_FE(posix_getpgrp, arginfo_posix_getpgrp)
249: #ifdef HAVE_SETSID
250: PHP_FE(posix_setsid, arginfo_posix_setsid)
251: #endif
252: PHP_FE(posix_setpgid, arginfo_posix_setpgid)
253: /* Non-Posix functions which are common */
254: #ifdef HAVE_GETPGID
255: PHP_FE(posix_getpgid, arginfo_posix_getpgid)
256: #endif /* HAVE_GETPGID */
257: #ifdef HAVE_GETSID
258: PHP_FE(posix_getsid, arginfo_posix_getsid)
259: #endif /* HAVE_GETSID */
260:
261: /* POSIX.1, 4.4 */
262: PHP_FE(posix_uname, arginfo_posix_uname)
263:
264: /* POSIX.1, 4.5 */
265: PHP_FE(posix_times, arginfo_posix_times)
266:
267: /* POSIX.1, 4.7 */
268: #ifdef HAVE_CTERMID
269: PHP_FE(posix_ctermid, arginfo_posix_ctermid)
270: #endif
271: PHP_FE(posix_ttyname, arginfo_posix_ttyname)
272: PHP_FE(posix_isatty, arginfo_posix_isatty)
273:
274: /* POSIX.1, 5.2 */
275: PHP_FE(posix_getcwd, arginfo_posix_getcwd)
276:
277: /* POSIX.1, 5.4 */
278: #ifdef HAVE_MKFIFO
279: PHP_FE(posix_mkfifo, arginfo_posix_mkfifo)
280: #endif
281: #ifdef HAVE_MKNOD
282: PHP_FE(posix_mknod, arginfo_posix_mknod)
283: #endif
284:
285: /* POSIX.1, 5.6 */
286: PHP_FE(posix_access, arginfo_posix_access)
287: /* POSIX.1, 9.2 */
288: PHP_FE(posix_getgrnam, arginfo_posix_getgrnam)
289: PHP_FE(posix_getgrgid, arginfo_posix_getgrgid)
290: PHP_FE(posix_getpwnam, arginfo_posix_getpwnam)
291: PHP_FE(posix_getpwuid, arginfo_posix_getpwuid)
292:
293: #ifdef HAVE_GETRLIMIT
294: PHP_FE(posix_getrlimit, arginfo_posix_getrlimit)
295: #endif
296:
297: PHP_FE(posix_get_last_error, arginfo_posix_get_last_error)
298: PHP_FALIAS(posix_errno, posix_get_last_error, arginfo_posix_get_last_error)
299: PHP_FE(posix_strerror, arginfo_posix_strerror)
300: #ifdef HAVE_INITGROUPS
301: PHP_FE(posix_initgroups, arginfo_posix_initgroups)
302: #endif
303:
304: PHP_FE_END
305: };
306: /* }}} */
307:
308: /* {{{ PHP_MINFO_FUNCTION
309: */
310: static PHP_MINFO_FUNCTION(posix)
311: {
312: php_info_print_table_start();
313: php_info_print_table_row(2, "Revision", "$Id: posix.c,v 1.1.1.4 2014/06/15 20:03:54 misho Exp $");
314: php_info_print_table_end();
315: }
316: /* }}} */
317:
318: static PHP_GINIT_FUNCTION(posix) /* {{{ */
319: {
320: posix_globals->last_error = 0;
321: }
322: /* }}} */
323:
324: /* {{{ PHP_MINIT_FUNCTION(posix)
325: */
326: static PHP_MINIT_FUNCTION(posix)
327: {
328: REGISTER_LONG_CONSTANT("POSIX_F_OK", F_OK, CONST_CS | CONST_PERSISTENT);
329: REGISTER_LONG_CONSTANT("POSIX_X_OK", X_OK, CONST_CS | CONST_PERSISTENT);
330: REGISTER_LONG_CONSTANT("POSIX_W_OK", W_OK, CONST_CS | CONST_PERSISTENT);
331: REGISTER_LONG_CONSTANT("POSIX_R_OK", R_OK, CONST_CS | CONST_PERSISTENT);
332: #ifdef S_IFREG
333: REGISTER_LONG_CONSTANT("POSIX_S_IFREG", S_IFREG, CONST_CS | CONST_PERSISTENT);
334: #endif
335: #ifdef S_IFCHR
336: REGISTER_LONG_CONSTANT("POSIX_S_IFCHR", S_IFCHR, CONST_CS | CONST_PERSISTENT);
337: #endif
338: #ifdef S_IFBLK
339: REGISTER_LONG_CONSTANT("POSIX_S_IFBLK", S_IFBLK, CONST_CS | CONST_PERSISTENT);
340: #endif
341: #ifdef S_IFIFO
342: REGISTER_LONG_CONSTANT("POSIX_S_IFIFO", S_IFIFO, CONST_CS | CONST_PERSISTENT);
343: #endif
344: #ifdef S_IFSOCK
345: REGISTER_LONG_CONSTANT("POSIX_S_IFSOCK", S_IFSOCK, CONST_CS | CONST_PERSISTENT);
346: #endif
347:
348: return SUCCESS;
349: }
350: /* }}} */
351:
352: /* {{{ posix_module_entry
353: */
354: zend_module_entry posix_module_entry = {
355: STANDARD_MODULE_HEADER,
356: "posix",
357: posix_functions,
358: PHP_MINIT(posix),
359: NULL,
360: NULL,
361: NULL,
362: PHP_MINFO(posix),
363: NO_VERSION_YET,
364: PHP_MODULE_GLOBALS(posix),
365: PHP_GINIT(posix),
366: NULL,
367: NULL,
368: STANDARD_MODULE_PROPERTIES_EX
369: };
370: /* }}} */
371:
372: #ifdef COMPILE_DL_POSIX
373: ZEND_GET_MODULE(posix)
374: #endif
375:
376: #define PHP_POSIX_NO_ARGS if (zend_parse_parameters_none() == FAILURE) return;
377:
378: #define PHP_POSIX_RETURN_LONG_FUNC(func_name) \
379: PHP_POSIX_NO_ARGS \
380: RETURN_LONG(func_name());
381:
382: #define PHP_POSIX_SINGLE_ARG_FUNC(func_name) \
383: long val; \
384: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &val) == FAILURE) RETURN_FALSE; \
385: if (func_name(val) < 0) { \
386: POSIX_G(last_error) = errno; \
387: RETURN_FALSE; \
388: } \
389: RETURN_TRUE;
390:
391: /* {{{ proto bool posix_kill(int pid, int sig)
392: Send a signal to a process (POSIX.1, 3.3.2) */
393:
394: PHP_FUNCTION(posix_kill)
395: {
396: long pid, sig;
397:
398: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &pid, &sig) == FAILURE) {
399: RETURN_FALSE;
400: }
401:
402: if (kill(pid, sig) < 0) {
403: POSIX_G(last_error) = errno;
404: RETURN_FALSE;
405: }
406:
407: RETURN_TRUE;
408: }
409: /* }}} */
410:
411: /* {{{ proto int posix_getpid(void)
412: Get the current process id (POSIX.1, 4.1.1) */
413: PHP_FUNCTION(posix_getpid)
414: {
415: PHP_POSIX_RETURN_LONG_FUNC(getpid);
416: }
417: /* }}} */
418:
419: /* {{{ proto int posix_getppid(void)
420: Get the parent process id (POSIX.1, 4.1.1) */
421: PHP_FUNCTION(posix_getppid)
422: {
423: PHP_POSIX_RETURN_LONG_FUNC(getppid);
424: }
425: /* }}} */
426:
427: /* {{{ proto int posix_getuid(void)
428: Get the current user id (POSIX.1, 4.2.1) */
429: PHP_FUNCTION(posix_getuid)
430: {
431: PHP_POSIX_RETURN_LONG_FUNC(getuid);
432: }
433: /* }}} */
434:
435: /* {{{ proto int posix_getgid(void)
436: Get the current group id (POSIX.1, 4.2.1) */
437: PHP_FUNCTION(posix_getgid)
438: {
439: PHP_POSIX_RETURN_LONG_FUNC(getgid);
440: }
441: /* }}} */
442:
443: /* {{{ proto int posix_geteuid(void)
444: Get the current effective user id (POSIX.1, 4.2.1) */
445: PHP_FUNCTION(posix_geteuid)
446: {
447: PHP_POSIX_RETURN_LONG_FUNC(geteuid);
448: }
449: /* }}} */
450:
451: /* {{{ proto int posix_getegid(void)
452: Get the current effective group id (POSIX.1, 4.2.1) */
453: PHP_FUNCTION(posix_getegid)
454: {
455: PHP_POSIX_RETURN_LONG_FUNC(getegid);
456: }
457: /* }}} */
458:
459: /* {{{ proto bool posix_setuid(long uid)
460: Set user id (POSIX.1, 4.2.2) */
461: PHP_FUNCTION(posix_setuid)
462: {
463: PHP_POSIX_SINGLE_ARG_FUNC(setuid);
464: }
465: /* }}} */
466:
467: /* {{{ proto bool posix_setgid(int uid)
468: Set group id (POSIX.1, 4.2.2) */
469: PHP_FUNCTION(posix_setgid)
470: {
471: PHP_POSIX_SINGLE_ARG_FUNC(setgid);
472: }
473: /* }}} */
474:
475: /* {{{ proto bool posix_seteuid(long uid)
476: Set effective user id */
477: #ifdef HAVE_SETEUID
478: PHP_FUNCTION(posix_seteuid)
479: {
480: PHP_POSIX_SINGLE_ARG_FUNC(seteuid);
481: }
482: #endif
483: /* }}} */
484:
485: /* {{{ proto bool posix_setegid(long uid)
486: Set effective group id */
487: #ifdef HAVE_SETEGID
488: PHP_FUNCTION(posix_setegid)
489: {
490: PHP_POSIX_SINGLE_ARG_FUNC(setegid);
491: }
492: #endif
493: /* }}} */
494:
495: /* {{{ proto array posix_getgroups(void)
496: Get supplementary group id's (POSIX.1, 4.2.3) */
497: #ifdef HAVE_GETGROUPS
498: PHP_FUNCTION(posix_getgroups)
499: {
500: gid_t gidlist[NGROUPS_MAX];
501: int result;
502: int i;
503:
504: PHP_POSIX_NO_ARGS;
505:
506: if ((result = getgroups(NGROUPS_MAX, gidlist)) < 0) {
507: POSIX_G(last_error) = errno;
508: RETURN_FALSE;
509: }
510:
511: array_init(return_value);
512:
513: for (i=0; i<result; i++) {
514: add_next_index_long(return_value, gidlist[i]);
515: }
516: }
517: #endif
518: /* }}} */
519:
520: /* {{{ proto string posix_getlogin(void)
521: Get user name (POSIX.1, 4.2.4) */
522: #ifdef HAVE_GETLOGIN
523: PHP_FUNCTION(posix_getlogin)
524: {
525: char *p;
526:
527: PHP_POSIX_NO_ARGS;
528:
529: if (NULL == (p = getlogin())) {
530: POSIX_G(last_error) = errno;
531: RETURN_FALSE;
532: }
533:
534: RETURN_STRING(p, 1);
535: }
536: #endif
537: /* }}} */
538:
539: /* {{{ proto int posix_getpgrp(void)
540: Get current process group id (POSIX.1, 4.3.1) */
541: PHP_FUNCTION(posix_getpgrp)
542: {
543: PHP_POSIX_RETURN_LONG_FUNC(getpgrp);
544: }
545: /* }}} */
546:
547: /* {{{ proto int posix_setsid(void)
548: Create session and set process group id (POSIX.1, 4.3.2) */
549: #ifdef HAVE_SETSID
550: PHP_FUNCTION(posix_setsid)
551: {
552: PHP_POSIX_RETURN_LONG_FUNC(setsid);
553: }
554: #endif
555: /* }}} */
556:
557: /* {{{ proto bool posix_setpgid(int pid, int pgid)
558: Set process group id for job control (POSIX.1, 4.3.3) */
559: PHP_FUNCTION(posix_setpgid)
560: {
561: long pid, pgid;
562:
563: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &pid, &pgid) == FAILURE) {
564: RETURN_FALSE;
565: }
566:
567: if (setpgid(pid, pgid) < 0) {
568: POSIX_G(last_error) = errno;
569: RETURN_FALSE;
570: }
571:
572: RETURN_TRUE;
573: }
574: /* }}} */
575:
576: /* {{{ proto int posix_getpgid(void)
577: Get the process group id of the specified process (This is not a POSIX function, but a SVR4ism, so we compile conditionally) */
578: #ifdef HAVE_GETPGID
579: PHP_FUNCTION(posix_getpgid)
580: {
581: long val;
582: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &val) == FAILURE) {
583: RETURN_FALSE;
584: }
585:
586: if ((val = getpgid(val)) < 0) {
587: POSIX_G(last_error) = errno;
588: RETURN_FALSE;
589: }
590: RETURN_LONG(val);
591: }
592: #endif
593: /* }}} */
594:
595: /* {{{ proto int posix_getsid(void)
596: Get process group id of session leader (This is not a POSIX function, but a SVR4ism, so be compile conditionally) */
597: #ifdef HAVE_GETSID
598: PHP_FUNCTION(posix_getsid)
599: {
600: long val;
601: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &val) == FAILURE) {
602: RETURN_FALSE;
603: }
604:
605: if ((val = getsid(val)) < 0) {
606: POSIX_G(last_error) = errno;
607: RETURN_FALSE;
608: }
609: RETURN_LONG(val);
610: }
611: #endif
612: /* }}} */
613:
614: /* {{{ proto array posix_uname(void)
615: Get system name (POSIX.1, 4.4.1) */
616: PHP_FUNCTION(posix_uname)
617: {
618: struct utsname u;
619:
620: PHP_POSIX_NO_ARGS;
621:
622: if (uname(&u) < 0) {
623: POSIX_G(last_error) = errno;
624: RETURN_FALSE;
625: }
626:
627: array_init(return_value);
628:
629: add_assoc_string(return_value, "sysname", u.sysname, 1);
630: add_assoc_string(return_value, "nodename", u.nodename, 1);
631: add_assoc_string(return_value, "release", u.release, 1);
632: add_assoc_string(return_value, "version", u.version, 1);
633: add_assoc_string(return_value, "machine", u.machine, 1);
634:
635: #if defined(_GNU_SOURCE) && !defined(DARWIN) && defined(HAVE_UTSNAME_DOMAINNAME)
636: add_assoc_string(return_value, "domainname", u.domainname, 1);
637: #endif
638: }
639: /* }}} */
640:
641: /* POSIX.1, 4.5.1 time() - Get System Time
642: already covered by PHP
643: */
644:
645: /* {{{ proto array posix_times(void)
646: Get process times (POSIX.1, 4.5.2) */
647: PHP_FUNCTION(posix_times)
648: {
649: struct tms t;
650: clock_t ticks;
651:
652: PHP_POSIX_NO_ARGS;
653:
654: if ((ticks = times(&t)) == -1) {
655: POSIX_G(last_error) = errno;
656: RETURN_FALSE;
657: }
658:
659: array_init(return_value);
660:
661: add_assoc_long(return_value, "ticks", ticks); /* clock ticks */
662: add_assoc_long(return_value, "utime", t.tms_utime); /* user time */
663: add_assoc_long(return_value, "stime", t.tms_stime); /* system time */
664: add_assoc_long(return_value, "cutime", t.tms_cutime); /* user time of children */
665: add_assoc_long(return_value, "cstime", t.tms_cstime); /* system time of children */
666: }
667: /* }}} */
668:
669: /* POSIX.1, 4.6.1 getenv() - Environment Access
670: already covered by PHP
671: */
672:
673: /* {{{ proto string posix_ctermid(void)
674: Generate terminal path name (POSIX.1, 4.7.1) */
675: #ifdef HAVE_CTERMID
676: PHP_FUNCTION(posix_ctermid)
677: {
678: char buffer[L_ctermid];
679:
680: PHP_POSIX_NO_ARGS;
681:
682: if (NULL == ctermid(buffer)) {
683: /* Found no documentation how the defined behaviour is when this
684: * function fails
685: */
686: POSIX_G(last_error) = errno;
687: RETURN_FALSE;
688: }
689:
690: RETURN_STRING(buffer, 1);
691: }
692: #endif
693: /* }}} */
694:
695: /* Checks if the provides resource is a stream and if it provides a file descriptor */
696: static int php_posix_stream_get_fd(zval *zfp, int *fd TSRMLS_DC) /* {{{ */
697: {
698: php_stream *stream;
699:
700: php_stream_from_zval_no_verify(stream, &zfp);
701:
702: if (stream == NULL) {
703: php_error_docref(NULL TSRMLS_CC, E_WARNING, "expects argument 1 to be a valid stream resource");
704: return 0;
705: }
706: if (php_stream_can_cast(stream, PHP_STREAM_AS_FD_FOR_SELECT) == SUCCESS) {
707: php_stream_cast(stream, PHP_STREAM_AS_FD_FOR_SELECT, (void*)fd, 0);
708: } else if (php_stream_can_cast(stream, PHP_STREAM_AS_FD) == SUCCESS) {
709: php_stream_cast(stream, PHP_STREAM_AS_FD, (void*)fd, 0);
710: } else {
711: php_error_docref(NULL TSRMLS_CC, E_WARNING, "could not use stream of type '%s'",
712: stream->ops->label);
713: return 0;
714: }
715: return 1;
716: }
717: /* }}} */
718:
719: /* {{{ proto string posix_ttyname(int fd)
720: Determine terminal device name (POSIX.1, 4.7.2) */
721: PHP_FUNCTION(posix_ttyname)
722: {
723: zval **z_fd;
724: char *p;
725: int fd;
726: #if defined(ZTS) && defined(HAVE_TTYNAME_R) && defined(_SC_TTY_NAME_MAX)
727: long buflen;
728: #endif
729:
730: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &z_fd) == FAILURE) {
731: RETURN_FALSE;
732: }
733:
734: switch (Z_TYPE_PP(z_fd)) {
735: case IS_RESOURCE:
736: if (!php_posix_stream_get_fd(*z_fd, &fd TSRMLS_CC)) {
737: RETURN_FALSE;
738: }
739: break;
740: default:
741: convert_to_long_ex(z_fd);
742: fd = Z_LVAL_PP(z_fd);
743: }
744: #if defined(ZTS) && defined(HAVE_TTYNAME_R) && defined(_SC_TTY_NAME_MAX)
745: buflen = sysconf(_SC_TTY_NAME_MAX);
746: if (buflen < 1) {
747: RETURN_FALSE;
748: }
749: p = emalloc(buflen);
750:
751: if (ttyname_r(fd, p, buflen)) {
752: POSIX_G(last_error) = errno;
753: efree(p);
754: RETURN_FALSE;
755: }
756: RETURN_STRING(p, 0);
757: #else
758: if (NULL == (p = ttyname(fd))) {
759: POSIX_G(last_error) = errno;
760: RETURN_FALSE;
761: }
762: #endif
763: RETURN_STRING(p, 1);
764: }
765: /* }}} */
766:
767: /* {{{ proto bool posix_isatty(int fd)
768: Determine if filedesc is a tty (POSIX.1, 4.7.1) */
769: PHP_FUNCTION(posix_isatty)
770: {
771: zval **z_fd;
772: int fd;
773:
774: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &z_fd) == FAILURE) {
775: RETURN_FALSE;
776: }
777:
778: switch (Z_TYPE_PP(z_fd)) {
779: case IS_RESOURCE:
780: if (!php_posix_stream_get_fd(*z_fd, &fd TSRMLS_CC)) {
781: RETURN_FALSE;
782: }
783: break;
784: default:
785: convert_to_long_ex(z_fd);
786: fd = Z_LVAL_PP(z_fd);
787: }
788:
789: if (isatty(fd)) {
790: RETURN_TRUE;
791: } else {
792: RETURN_FALSE;
793: }
794: }
795: /* }}} */
796:
797: /*
798: POSIX.1, 4.8.1 sysconf() - TODO
799: POSIX.1, 5.7.1 pathconf(), fpathconf() - TODO
800:
801: POSIX.1, 5.1.2 opendir(), readdir(), rewinddir(), closedir()
802: POSIX.1, 5.2.1 chdir()
803: already supported by PHP
804: */
805:
806: /* {{{ proto string posix_getcwd(void)
807: Get working directory pathname (POSIX.1, 5.2.2) */
808: PHP_FUNCTION(posix_getcwd)
809: {
810: char buffer[MAXPATHLEN];
811: char *p;
812:
813: PHP_POSIX_NO_ARGS;
814:
815: p = VCWD_GETCWD(buffer, MAXPATHLEN);
816: if (!p) {
817: POSIX_G(last_error) = errno;
818: RETURN_FALSE;
819: }
820:
821: RETURN_STRING(buffer, 1);
822: }
823: /* }}} */
824:
825: /*
826: POSIX.1, 5.3.x open(), creat(), umask()
827: POSIX.1, 5.4.1 link()
828: already supported by PHP.
829: */
830:
831: /* {{{ proto bool posix_mkfifo(string pathname, int mode)
832: Make a FIFO special file (POSIX.1, 5.4.2) */
833: #ifdef HAVE_MKFIFO
834: PHP_FUNCTION(posix_mkfifo)
835: {
836: char *path;
837: int path_len;
838: long mode;
839: int result;
840:
841: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "pl", &path, &path_len, &mode) == FAILURE) {
842: RETURN_FALSE;
843: }
844:
845: if (php_check_open_basedir_ex(path, 0 TSRMLS_CC)) {
846: RETURN_FALSE;
847: }
848:
849: result = mkfifo(path, mode);
850: if (result < 0) {
851: POSIX_G(last_error) = errno;
852: RETURN_FALSE;
853: }
854:
855: RETURN_TRUE;
856: }
857: #endif
858: /* }}} */
859:
860: /* {{{ proto bool posix_mknod(string pathname, int mode [, int major [, int minor]])
861: Make a special or ordinary file (POSIX.1) */
862: #ifdef HAVE_MKNOD
863: PHP_FUNCTION(posix_mknod)
864: {
865: char *path;
866: int path_len;
867: long mode;
868: long major = 0, minor = 0;
869: int result;
870: dev_t php_dev;
871:
872: php_dev = 0;
873:
874: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "pl|ll", &path, &path_len,
875: &mode, &major, &minor) == FAILURE) {
876: RETURN_FALSE;
877: }
878:
879: if (php_check_open_basedir_ex(path, 0 TSRMLS_CC)) {
880: RETURN_FALSE;
881: }
882:
883: if ((mode & S_IFCHR) || (mode & S_IFBLK)) {
884: if (ZEND_NUM_ARGS() == 2) {
885: php_error_docref(NULL TSRMLS_CC, E_WARNING, "For S_IFCHR and S_IFBLK you need to pass a major device kernel identifier");
886: RETURN_FALSE;
887: }
888: if (major == 0) {
889: php_error_docref(NULL TSRMLS_CC, E_WARNING,
890: "Expects argument 3 to be non-zero for POSIX_S_IFCHR and POSIX_S_IFBLK");
891: RETURN_FALSE;
892: } else {
893: #if defined(HAVE_MAKEDEV) || defined(makedev)
894: php_dev = makedev(major, minor);
895: #else
896: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot create a block or character device, creating a normal file instead");
897: #endif
898: }
899: }
900:
901: result = mknod(path, mode, php_dev);
902: if (result < 0) {
903: POSIX_G(last_error) = errno;
904: RETURN_FALSE;
905: }
906:
907: RETURN_TRUE;
908: }
909: #endif
910: /* }}} */
911:
912: /* Takes a pointer to posix group and a pointer to an already initialized ZVAL
913: * array container and fills the array with the posix group member data. */
914: int php_posix_group_to_array(struct group *g, zval *array_group) /* {{{ */
915: {
916: zval *array_members;
917: int count;
918:
919: if (NULL == g)
920: return 0;
921:
922: if (array_group == NULL || Z_TYPE_P(array_group) != IS_ARRAY)
923: return 0;
924:
925: MAKE_STD_ZVAL(array_members);
926: array_init(array_members);
927:
928: add_assoc_string(array_group, "name", g->gr_name, 1);
929: add_assoc_string(array_group, "passwd", g->gr_passwd, 1);
930: for (count=0; g->gr_mem[count] != NULL; count++) {
931: add_next_index_string(array_members, g->gr_mem[count], 1);
932: }
933: zend_hash_update(Z_ARRVAL_P(array_group), "members", sizeof("members"), (void*)&array_members, sizeof(zval*), NULL);
934: add_assoc_long(array_group, "gid", g->gr_gid);
935: return 1;
936: }
937: /* }}} */
938:
939: /*
940: POSIX.1, 5.5.1 unlink()
941: POSIX.1, 5.5.2 rmdir()
942: POSIX.1, 5.5.3 rename()
943: POSIX.1, 5.6.x stat(), chmod(), utime() already supported by PHP.
944: */
945:
946: /* {{{ proto bool posix_access(string file [, int mode])
947: Determine accessibility of a file (POSIX.1 5.6.3) */
948: PHP_FUNCTION(posix_access)
949: {
950: long mode = 0;
951: int filename_len, ret;
952: char *filename, *path;
953:
954: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|l", &filename, &filename_len, &mode) == FAILURE) {
955: RETURN_FALSE;
956: }
957:
958: path = expand_filepath(filename, NULL TSRMLS_CC);
959: if (!path) {
960: POSIX_G(last_error) = EIO;
961: RETURN_FALSE;
962: }
963:
964: if (php_check_open_basedir_ex(path, 0 TSRMLS_CC)) {
965: efree(path);
966: POSIX_G(last_error) = EPERM;
967: RETURN_FALSE;
968: }
969:
970: ret = access(path, mode);
971: efree(path);
972:
973: if (ret) {
974: POSIX_G(last_error) = errno;
975: RETURN_FALSE;
976: }
977:
978: RETURN_TRUE;
979: }
980: /* }}} */
981:
982: /*
983: POSIX.1, 6.x most I/O functions already supported by PHP.
984: POSIX.1, 7.x tty functions, TODO
985: POSIX.1, 8.x interactions with other C language functions
986: POSIX.1, 9.x system database access
987: */
988:
989: /* {{{ proto array posix_getgrnam(string groupname)
990: Group database access (POSIX.1, 9.2.1) */
991: PHP_FUNCTION(posix_getgrnam)
992: {
993: char *name;
994: struct group *g;
995: int name_len;
996: #if defined(ZTS) && defined(HAVE_GETGRNAM_R) && defined(_SC_GETGR_R_SIZE_MAX)
997: struct group gbuf;
998: long buflen;
999: char *buf;
1000: #endif
1001:
1002: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
1003: RETURN_FALSE;
1004: }
1005:
1006: #if defined(ZTS) && defined(HAVE_GETGRNAM_R) && defined(_SC_GETGR_R_SIZE_MAX)
1007: buflen = sysconf(_SC_GETGR_R_SIZE_MAX);
1008: if (buflen < 1) {
1009: RETURN_FALSE;
1010: }
1011: buf = emalloc(buflen);
1012: g = &gbuf;
1013:
1014: if (getgrnam_r(name, g, buf, buflen, &g) || g == NULL) {
1015: POSIX_G(last_error) = errno;
1016: efree(buf);
1017: RETURN_FALSE;
1018: }
1019: #else
1020: if (NULL == (g = getgrnam(name))) {
1021: POSIX_G(last_error) = errno;
1022: RETURN_FALSE;
1023: }
1024: #endif
1025: array_init(return_value);
1026:
1027: if (!php_posix_group_to_array(g, return_value)) {
1028: zval_dtor(return_value);
1029: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to convert posix group to array");
1030: RETVAL_FALSE;
1031: }
1032: #if defined(ZTS) && defined(HAVE_GETGRNAM_R) && defined(_SC_GETGR_R_SIZE_MAX)
1033: efree(buf);
1034: #endif
1035: }
1036: /* }}} */
1037:
1038: /* {{{ proto array posix_getgrgid(long gid)
1039: Group database access (POSIX.1, 9.2.1) */
1040: PHP_FUNCTION(posix_getgrgid)
1041: {
1042: long gid;
1043: #if defined(ZTS) && defined(HAVE_GETGRGID_R) && defined(_SC_GETGR_R_SIZE_MAX)
1044: int ret;
1045: struct group _g;
1046: struct group *retgrptr = NULL;
1047: long grbuflen;
1048: char *grbuf;
1049: #endif
1050: struct group *g;
1051:
1052: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &gid) == FAILURE) {
1053: RETURN_FALSE;
1054: }
1055: #if defined(ZTS) && defined(HAVE_GETGRGID_R) && defined(_SC_GETGR_R_SIZE_MAX)
1056:
1057: grbuflen = sysconf(_SC_GETGR_R_SIZE_MAX);
1058: if (grbuflen < 1) {
1059: RETURN_FALSE;
1060: }
1061:
1062: grbuf = emalloc(grbuflen);
1063:
1064: ret = getgrgid_r(gid, &_g, grbuf, grbuflen, &retgrptr);
1065: if (ret || retgrptr == NULL) {
1066: POSIX_G(last_error) = ret;
1067: efree(grbuf);
1068: RETURN_FALSE;
1069: }
1070: g = &_g;
1071: #else
1072: if (NULL == (g = getgrgid(gid))) {
1073: POSIX_G(last_error) = errno;
1074: RETURN_FALSE;
1075: }
1076: #endif
1077: array_init(return_value);
1078:
1079: if (!php_posix_group_to_array(g, return_value)) {
1080: zval_dtor(return_value);
1081: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to convert posix group struct to array");
1082: RETVAL_FALSE;
1083: }
1084: #if defined(ZTS) && defined(HAVE_GETGRGID_R) && defined(_SC_GETGR_R_SIZE_MAX)
1085: efree(grbuf);
1086: #endif
1087: }
1088: /* }}} */
1089:
1090: int php_posix_passwd_to_array(struct passwd *pw, zval *return_value) /* {{{ */
1091: {
1092: if (NULL == pw)
1093: return 0;
1094: if (NULL == return_value || Z_TYPE_P(return_value) != IS_ARRAY)
1095: return 0;
1096:
1097: add_assoc_string(return_value, "name", pw->pw_name, 1);
1098: add_assoc_string(return_value, "passwd", pw->pw_passwd, 1);
1099: add_assoc_long (return_value, "uid", pw->pw_uid);
1100: add_assoc_long (return_value, "gid", pw->pw_gid);
1101: add_assoc_string(return_value, "gecos", pw->pw_gecos, 1);
1102: add_assoc_string(return_value, "dir", pw->pw_dir, 1);
1103: add_assoc_string(return_value, "shell", pw->pw_shell, 1);
1104: return 1;
1105: }
1106: /* }}} */
1107:
1108: /* {{{ proto array posix_getpwnam(string groupname)
1109: User database access (POSIX.1, 9.2.2) */
1110: PHP_FUNCTION(posix_getpwnam)
1111: {
1112: struct passwd *pw;
1113: char *name;
1114: int name_len;
1115: #if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWNAM_R)
1116: struct passwd pwbuf;
1117: long buflen;
1118: char *buf;
1119: #endif
1120:
1121: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
1122: RETURN_FALSE;
1123: }
1124:
1125: #if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWNAM_R)
1126: buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
1127: if (buflen < 1) {
1128: RETURN_FALSE;
1129: }
1130: buf = emalloc(buflen);
1131: pw = &pwbuf;
1132:
1133: if (getpwnam_r(name, pw, buf, buflen, &pw) || pw == NULL) {
1134: efree(buf);
1135: POSIX_G(last_error) = errno;
1136: RETURN_FALSE;
1137: }
1138: #else
1139: if (NULL == (pw = getpwnam(name))) {
1140: POSIX_G(last_error) = errno;
1141: RETURN_FALSE;
1142: }
1143: #endif
1144: array_init(return_value);
1145:
1146: if (!php_posix_passwd_to_array(pw, return_value)) {
1147: zval_dtor(return_value);
1148: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to convert posix passwd struct to array");
1149: RETVAL_FALSE;
1150: }
1151: #if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWNAM_R)
1152: efree(buf);
1153: #endif
1154: }
1155: /* }}} */
1156:
1157: /* {{{ proto array posix_getpwuid(long uid)
1158: User database access (POSIX.1, 9.2.2) */
1159: PHP_FUNCTION(posix_getpwuid)
1160: {
1161: long uid;
1162: #if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWUID_R)
1163: struct passwd _pw;
1164: struct passwd *retpwptr = NULL;
1165: long pwbuflen;
1166: char *pwbuf;
1167: int ret;
1168: #endif
1169: struct passwd *pw;
1170:
1171: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &uid) == FAILURE) {
1172: RETURN_FALSE;
1173: }
1174: #if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWUID_R)
1175: pwbuflen = sysconf(_SC_GETPW_R_SIZE_MAX);
1176: if (pwbuflen < 1) {
1177: RETURN_FALSE;
1178: }
1179: pwbuf = emalloc(pwbuflen);
1180:
1181: ret = getpwuid_r(uid, &_pw, pwbuf, pwbuflen, &retpwptr);
1182: if (ret || retpwptr == NULL) {
1183: POSIX_G(last_error) = ret;
1184: efree(pwbuf);
1185: RETURN_FALSE;
1186: }
1187: pw = &_pw;
1188: #else
1189: if (NULL == (pw = getpwuid(uid))) {
1190: POSIX_G(last_error) = errno;
1191: RETURN_FALSE;
1192: }
1193: #endif
1194: array_init(return_value);
1195:
1196: if (!php_posix_passwd_to_array(pw, return_value)) {
1197: zval_dtor(return_value);
1198: php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to convert posix passwd struct to array");
1199: RETVAL_FALSE;
1200: }
1201: #if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWUID_R)
1202: efree(pwbuf);
1203: #endif
1204: }
1205: /* }}} */
1206:
1207:
1208: #ifdef HAVE_GETRLIMIT
1209:
1210: #define UNLIMITED_STRING "unlimited"
1211:
1212: /* {{{ posix_addlimit
1213: */
1214: static int posix_addlimit(int limit, char *name, zval *return_value TSRMLS_DC) {
1215: int result;
1216: struct rlimit rl;
1217: char hard[80];
1218: char soft[80];
1219:
1220: snprintf(hard, 80, "hard %s", name);
1221: snprintf(soft, 80, "soft %s", name);
1222:
1223: result = getrlimit(limit, &rl);
1224: if (result < 0) {
1225: POSIX_G(last_error) = errno;
1226: return FAILURE;
1227: }
1228:
1229: if (rl.rlim_cur == RLIM_INFINITY) {
1230: add_assoc_stringl(return_value, soft, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1, 1);
1231: } else {
1232: add_assoc_long(return_value, soft, rl.rlim_cur);
1233: }
1234:
1235: if (rl.rlim_max == RLIM_INFINITY) {
1236: add_assoc_stringl(return_value, hard, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1, 1);
1237: } else {
1238: add_assoc_long(return_value, hard, rl.rlim_max);
1239: }
1240:
1241: return SUCCESS;
1242: }
1243: /* }}} */
1244:
1245: /* {{{ limits[]
1246: */
1247: struct limitlist {
1248: int limit;
1249: char *name;
1250: } limits[] = {
1251: #ifdef RLIMIT_CORE
1252: { RLIMIT_CORE, "core" },
1253: #endif
1254:
1255: #ifdef RLIMIT_DATA
1256: { RLIMIT_DATA, "data" },
1257: #endif
1258:
1259: #ifdef RLIMIT_STACK
1260: { RLIMIT_STACK, "stack" },
1261: #endif
1262:
1263: #ifdef RLIMIT_VMEM
1264: { RLIMIT_VMEM, "virtualmem" },
1265: #endif
1266:
1267: #ifdef RLIMIT_AS
1268: { RLIMIT_AS, "totalmem" },
1269: #endif
1270:
1271: #ifdef RLIMIT_RSS
1272: { RLIMIT_RSS, "rss" },
1273: #endif
1274:
1275: #ifdef RLIMIT_NPROC
1276: { RLIMIT_NPROC, "maxproc" },
1277: #endif
1278:
1279: #ifdef RLIMIT_MEMLOCK
1280: { RLIMIT_MEMLOCK, "memlock" },
1281: #endif
1282:
1283: #ifdef RLIMIT_CPU
1284: { RLIMIT_CPU, "cpu" },
1285: #endif
1286:
1287: #ifdef RLIMIT_FSIZE
1288: { RLIMIT_FSIZE, "filesize" },
1289: #endif
1290:
1291: #ifdef RLIMIT_NOFILE
1292: { RLIMIT_NOFILE, "openfiles" },
1293: #endif
1294:
1295: #ifdef RLIMIT_OFILE
1296: { RLIMIT_OFILE, "openfiles" },
1297: #endif
1298:
1299: { 0, NULL }
1300: };
1301: /* }}} */
1302:
1303:
1304: /* {{{ proto array posix_getrlimit(void)
1305: Get system resource consumption limits (This is not a POSIX function, but a BSDism and a SVR4ism. We compile conditionally) */
1306: PHP_FUNCTION(posix_getrlimit)
1307: {
1308: struct limitlist *l = NULL;
1309:
1310: PHP_POSIX_NO_ARGS;
1311:
1312: array_init(return_value);
1313:
1314: for (l=limits; l->name; l++) {
1315: if (posix_addlimit(l->limit, l->name, return_value TSRMLS_CC) == FAILURE) {
1316: zval_dtor(return_value);
1317: RETURN_FALSE;
1318: }
1319: }
1320: }
1321: /* }}} */
1322:
1323: #endif /* HAVE_GETRLIMIT */
1324:
1325: /* {{{ proto int posix_get_last_error(void)
1326: Retrieve the error number set by the last posix function which failed. */
1327: PHP_FUNCTION(posix_get_last_error)
1328: {
1329: PHP_POSIX_NO_ARGS;
1330:
1331: RETURN_LONG(POSIX_G(last_error));
1332: }
1333: /* }}} */
1334:
1335: /* {{{ proto string posix_strerror(int errno)
1336: Retrieve the system error message associated with the given errno. */
1337: PHP_FUNCTION(posix_strerror)
1338: {
1339: long error;
1340:
1341: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &error) == FAILURE) {
1342: RETURN_FALSE;
1343: }
1344:
1345: RETURN_STRING(strerror(error), 1);
1346: }
1347: /* }}} */
1348:
1349: #endif
1350:
1351: #ifdef HAVE_INITGROUPS
1352: /* {{{ proto bool posix_initgroups(string name, int base_group_id)
1353: Calculate the group access list for the user specified in name. */
1354: PHP_FUNCTION(posix_initgroups)
1355: {
1356: long basegid;
1357: char *name;
1358: int name_len;
1359:
1360: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &name, &name_len, &basegid) == FAILURE) {
1361: RETURN_FALSE;
1362: }
1363:
1364: if (name_len == 0) {
1365: RETURN_FALSE;
1366: }
1367:
1368: RETURN_BOOL(!initgroups((const char *)name, basegid));
1369: }
1370: /* }}} */
1371: #endif
1372:
1373: /*
1374: * Local variables:
1375: * tab-width: 4
1376: * c-basic-offset: 4
1377: * End:
1378: * vim600: sw=4 ts=4 fdm=marker
1379: * vim<600: sw=4 ts=4
1380: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to posix.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 / posix