PHP  
 PHP: Test and Code Coverage Analysis
downloads | QA | documentation | faq | getting help | mailing lists | reporting bugs | php.net sites | links | my php.net 
 

LCOV - code coverage report
Current view: top level - ext/posix - posix.c (source / functions) Hit Total Coverage
Test: PHP Code Coverage Lines: 243 321 75.7 %
Date: 2014-07-27 Functions: 38 42 90.5 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    +----------------------------------------------------------------------+
       3             :    | PHP Version 5                                                        |
       4             :    +----------------------------------------------------------------------+
       5             :    | Copyright (c) 1997-2013 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: 5a2da3946b96c5afbf3aff8db8a8681f8bedee85 $ */
      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         148 : static PHP_MINFO_FUNCTION(posix)
     311             : {
     312         148 :         php_info_print_table_start();
     313         148 :         php_info_print_table_row(2, "Revision", "$Id: 5a2da3946b96c5afbf3aff8db8a8681f8bedee85 $");
     314         148 :         php_info_print_table_end();
     315         148 : }
     316             : /* }}} */
     317             : 
     318       19341 : static PHP_GINIT_FUNCTION(posix) /* {{{ */
     319             : {
     320       19341 :         posix_globals->last_error = 0;
     321       19341 : }
     322             : /* }}} */
     323             : 
     324             : /* {{{ PHP_MINIT_FUNCTION(posix)
     325             :  */
     326       19341 : static PHP_MINIT_FUNCTION(posix)
     327             : {
     328       19341 :         REGISTER_LONG_CONSTANT("POSIX_F_OK", F_OK, CONST_CS | CONST_PERSISTENT);
     329       19341 :         REGISTER_LONG_CONSTANT("POSIX_X_OK", X_OK, CONST_CS | CONST_PERSISTENT);
     330       19341 :         REGISTER_LONG_CONSTANT("POSIX_W_OK", W_OK, CONST_CS | CONST_PERSISTENT);
     331       19341 :         REGISTER_LONG_CONSTANT("POSIX_R_OK", R_OK, CONST_CS | CONST_PERSISTENT);
     332             : #ifdef S_IFREG
     333       19341 :         REGISTER_LONG_CONSTANT("POSIX_S_IFREG", S_IFREG, CONST_CS | CONST_PERSISTENT);
     334             : #endif
     335             : #ifdef S_IFCHR
     336       19341 :         REGISTER_LONG_CONSTANT("POSIX_S_IFCHR", S_IFCHR, CONST_CS | CONST_PERSISTENT);
     337             : #endif
     338             : #ifdef S_IFBLK
     339       19341 :         REGISTER_LONG_CONSTANT("POSIX_S_IFBLK", S_IFBLK, CONST_CS | CONST_PERSISTENT);
     340             : #endif
     341             : #ifdef S_IFIFO
     342       19341 :         REGISTER_LONG_CONSTANT("POSIX_S_IFIFO", S_IFIFO, CONST_CS | CONST_PERSISTENT);
     343             : #endif
     344             : #ifdef S_IFSOCK
     345       19341 :         REGISTER_LONG_CONSTANT("POSIX_S_IFSOCK", S_IFSOCK, CONST_CS | CONST_PERSISTENT);
     346             : #endif
     347             : 
     348       19341 :         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          77 : PHP_FUNCTION(posix_kill)
     395             : {
     396             :         long pid, sig;
     397             : 
     398          77 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &pid, &sig) == FAILURE) {
     399          20 :                 RETURN_FALSE;
     400             :         }
     401             :                 
     402          57 :         if (kill(pid, sig) < 0) {
     403          30 :                 POSIX_G(last_error) = errno;
     404          30 :                 RETURN_FALSE;
     405             :         }
     406             :         
     407          27 :         RETURN_TRUE;
     408             : }
     409             : /* }}} */
     410             : 
     411             : /* {{{ proto int posix_getpid(void)
     412             :    Get the current process id (POSIX.1, 4.1.1) */
     413          16 : PHP_FUNCTION(posix_getpid)
     414             : {
     415          16 :         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           3 : PHP_FUNCTION(posix_getppid)
     422             : {
     423           3 :         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          10 : PHP_FUNCTION(posix_getuid)
     430             : {
     431          10 :         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           5 : PHP_FUNCTION(posix_getgid)
     438             : {
     439           5 :         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          27 : PHP_FUNCTION(posix_geteuid)
     446             : {
     447          27 :         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           1 : PHP_FUNCTION(posix_getegid)
     454             : {
     455           1 :         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          32 : PHP_FUNCTION(posix_setuid)
     462             : {
     463          32 :         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          31 : PHP_FUNCTION(posix_setgid)
     470             : {
     471          31 :         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          31 : PHP_FUNCTION(posix_seteuid)
     479             : {
     480          31 :         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           0 : PHP_FUNCTION(posix_setegid)
     489             : {
     490           0 :         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           1 : PHP_FUNCTION(posix_getgroups)
     499             : {
     500             :         gid_t  gidlist[NGROUPS_MAX];
     501             :         int    result;
     502             :         int    i;
     503             : 
     504           1 :         PHP_POSIX_NO_ARGS;
     505             :         
     506           1 :         if ((result = getgroups(NGROUPS_MAX, gidlist)) < 0) {
     507           0 :                 POSIX_G(last_error) = errno;
     508           0 :                 RETURN_FALSE;
     509             :         }
     510             : 
     511           1 :         array_init(return_value);
     512             : 
     513           3 :         for (i=0; i<result; i++) {
     514           2 :                 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           0 : PHP_FUNCTION(posix_getlogin)
     524             : {
     525             :         char *p;
     526             :         
     527           0 :         PHP_POSIX_NO_ARGS;
     528             :         
     529           0 :         if (NULL == (p = getlogin())) {
     530           0 :                 POSIX_G(last_error) = errno;
     531           0 :                 RETURN_FALSE;
     532             :         }
     533             :         
     534           0 :         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           2 : PHP_FUNCTION(posix_getpgrp)
     542             : {
     543           2 :         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           0 : PHP_FUNCTION(posix_setsid)
     551             : {
     552           0 :         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           0 : PHP_FUNCTION(posix_setpgid)
     560             : {
     561             :         long pid, pgid;
     562             : 
     563           0 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ll", &pid, &pgid) == FAILURE) {
     564           0 :                 RETURN_FALSE;
     565             :         }
     566             :         
     567           0 :         if (setpgid(pid, pgid) < 0) {
     568           0 :                 POSIX_G(last_error) = errno;
     569           0 :                 RETURN_FALSE;
     570             :         }
     571             :         
     572           0 :         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          26 : PHP_FUNCTION(posix_getpgid)
     580             : {
     581             :         long val;
     582          26 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &val) == FAILURE) {
     583          11 :                 RETURN_FALSE;
     584             :         }
     585             :         
     586          15 :         if ((val = getpgid(val)) < 0) {
     587           3 :                 POSIX_G(last_error) = errno;
     588           3 :                 RETURN_FALSE;
     589             :         }
     590          12 :         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           5 : PHP_FUNCTION(posix_getsid)
     599             : {
     600             :         long val;
     601           5 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &val) == FAILURE) {
     602           2 :                 RETURN_FALSE;
     603             :         }
     604             :         
     605           3 :         if ((val = getsid(val)) < 0) {
     606           1 :                 POSIX_G(last_error) = errno;
     607           1 :                 RETURN_FALSE;
     608             :         }
     609           2 :         RETURN_LONG(val);
     610             : }
     611             : #endif
     612             : /* }}} */
     613             : 
     614             : /* {{{ proto array posix_uname(void)
     615             :    Get system name (POSIX.1, 4.4.1) */
     616           2 : PHP_FUNCTION(posix_uname)
     617             : {
     618             :         struct utsname u;
     619             : 
     620           2 :         PHP_POSIX_NO_ARGS;
     621             : 
     622           1 :         if (uname(&u) < 0) {
     623           0 :                 POSIX_G(last_error) = errno;
     624           0 :                 RETURN_FALSE;
     625             :         }
     626             : 
     627           1 :         array_init(return_value);
     628             : 
     629           1 :         add_assoc_string(return_value, "sysname",  u.sysname,  1);
     630           1 :         add_assoc_string(return_value, "nodename", u.nodename, 1);
     631           1 :         add_assoc_string(return_value, "release",  u.release,  1);
     632           1 :         add_assoc_string(return_value, "version",  u.version,  1);
     633           1 :         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           3 : PHP_FUNCTION(posix_times)
     648             : {
     649             :         struct tms t;
     650             :         clock_t    ticks;
     651             : 
     652           3 :         PHP_POSIX_NO_ARGS;
     653             : 
     654           2 :         if ((ticks = times(&t)) == -1) {
     655           0 :                 POSIX_G(last_error) = errno;
     656           0 :                 RETURN_FALSE;
     657             :         }
     658             : 
     659           2 :         array_init(return_value);
     660             : 
     661           2 :         add_assoc_long(return_value, "ticks", ticks);                 /* clock ticks */
     662           2 :         add_assoc_long(return_value, "utime", t.tms_utime);   /* user time */
     663           2 :         add_assoc_long(return_value, "stime", t.tms_stime);   /* system time */
     664           2 :         add_assoc_long(return_value, "cutime",        t.tms_cutime);  /* user time of children */
     665           2 :         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           3 : PHP_FUNCTION(posix_ctermid)
     677             : {
     678             :         char  buffer[L_ctermid];
     679             :         
     680           3 :         PHP_POSIX_NO_ARGS;
     681             : 
     682           2 :         if (NULL == ctermid(buffer)) {
     683             :                 /* Found no documentation how the defined behaviour is when this
     684             :                  * function fails
     685             :                  */
     686           0 :                 POSIX_G(last_error) = errno;
     687           0 :                 RETURN_FALSE;
     688             :         }
     689             :         
     690           2 :         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           4 : static int php_posix_stream_get_fd(zval *zfp, int *fd TSRMLS_DC) /* {{{ */
     697             : {
     698             :         php_stream *stream;
     699             : 
     700           4 :         php_stream_from_zval_no_verify(stream, &zfp);
     701             : 
     702           4 :         if (stream == NULL) {
     703           1 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "expects argument 1 to be a valid stream resource");
     704           1 :                 return 0;
     705             :         }
     706           3 :         if (php_stream_can_cast(stream, PHP_STREAM_AS_FD_FOR_SELECT) == SUCCESS) {
     707           3 :                 php_stream_cast(stream, PHP_STREAM_AS_FD_FOR_SELECT, (void*)fd, 0);
     708           0 :         } else if (php_stream_can_cast(stream, PHP_STREAM_AS_FD) == SUCCESS) {
     709           0 :                 php_stream_cast(stream, PHP_STREAM_AS_FD, (void*)fd, 0);
     710             :         } else {
     711           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "could not use stream of type '%s'", 
     712           0 :                                 stream->ops->label);
     713           0 :                 return 0;
     714             :         }
     715           3 :         return 1;
     716             : }
     717             : /* }}} */
     718             : 
     719             : /* {{{ proto string posix_ttyname(int fd)
     720             :    Determine terminal device name (POSIX.1, 4.7.2) */
     721          35 : 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          35 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &z_fd) == FAILURE) {
     731           3 :                 RETURN_FALSE;
     732             :         }
     733             : 
     734          32 :         switch (Z_TYPE_PP(z_fd)) {
     735             :                 case IS_RESOURCE:
     736           4 :                         if (!php_posix_stream_get_fd(*z_fd, &fd TSRMLS_CC)) {
     737           1 :                                 RETURN_FALSE;
     738             :                         }
     739           3 :                         break;
     740             :                 default:
     741         149 :                         convert_to_long_ex(z_fd);
     742          28 :                         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          31 :         if (NULL == (p = ttyname(fd))) {
     759          31 :                 POSIX_G(last_error) = errno;
     760          31 :                 RETURN_FALSE;
     761             :         }
     762             : #endif  
     763           0 :         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           1 : PHP_FUNCTION(posix_isatty)
     770             : {
     771             :         zval **z_fd;
     772             :         int fd;
     773             :         
     774           1 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &z_fd) == FAILURE) {
     775           0 :                 RETURN_FALSE;
     776             :         }
     777             :         
     778           1 :         switch (Z_TYPE_PP(z_fd)) {
     779             :                 case IS_RESOURCE:
     780           0 :                         if (!php_posix_stream_get_fd(*z_fd, &fd TSRMLS_CC)) {
     781           0 :                                 RETURN_FALSE;
     782             :                         }
     783           0 :                         break;
     784             :                 default:
     785           1 :                         convert_to_long_ex(z_fd);
     786           1 :                         fd = Z_LVAL_PP(z_fd);
     787             :         }
     788             : 
     789           1 :         if (isatty(fd)) {
     790           0 :                 RETURN_TRUE;
     791             :         } else {
     792           1 :                 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           4 : PHP_FUNCTION(posix_getcwd)
     809             : {
     810             :         char  buffer[MAXPATHLEN];
     811             :         char *p;
     812             : 
     813           4 :         PHP_POSIX_NO_ARGS;
     814             : 
     815           2 :         p = VCWD_GETCWD(buffer, MAXPATHLEN);
     816           2 :         if (!p) {
     817           0 :                 POSIX_G(last_error) = errno;
     818           0 :                 RETURN_FALSE;
     819             :         }
     820             : 
     821           2 :         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           5 : PHP_FUNCTION(posix_mkfifo)
     835             : {
     836             :         char *path;
     837             :         int path_len;
     838             :         long mode;
     839             :         int     result;
     840             :         
     841           5 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &path, &path_len, &mode) == FAILURE) {
     842           1 :                 RETURN_FALSE;
     843             :         }
     844             : 
     845           4 :         if (strlen(path) != path_len) {
     846           0 :                 RETURN_FALSE;
     847             :         }
     848             : 
     849          10 :         if (php_check_open_basedir_ex(path, 0 TSRMLS_CC) ||
     850           6 :                         (PG(safe_mode) && (!php_checkuid(path, NULL, CHECKUID_ALLOW_ONLY_DIR)))) {
     851           1 :                 RETURN_FALSE;
     852             :         }
     853             : 
     854           3 :         result = mkfifo(path, mode);
     855           3 :         if (result < 0) {
     856           1 :                 POSIX_G(last_error) = errno;
     857           1 :                 RETURN_FALSE;
     858             :         }
     859             : 
     860           2 :         RETURN_TRUE;
     861             : }
     862             : #endif
     863             : /* }}} */
     864             : 
     865             : /* {{{ proto bool posix_mknod(string pathname, int mode [, int major [, int minor]])
     866             :    Make a special or ordinary file (POSIX.1) */
     867             : #ifdef HAVE_MKNOD
     868           2 : PHP_FUNCTION(posix_mknod)
     869             : {
     870             :         char *path;
     871             :         int path_len;
     872             :         long mode;
     873           2 :         long major = 0, minor = 0;
     874             :         int result;
     875             :         dev_t php_dev;
     876             : 
     877           2 :         php_dev = 0;
     878             : 
     879           2 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|ll", &path, &path_len,
     880             :                         &mode, &major, &minor) == FAILURE) {
     881           0 :                 RETURN_FALSE;
     882             :         }
     883             : 
     884           2 :         if (strlen(path) != path_len) {
     885           0 :                 RETURN_FALSE;
     886             :         }
     887             : 
     888           4 :         if (php_check_open_basedir_ex(path, 0 TSRMLS_CC) ||
     889           2 :                         (PG(safe_mode) && (!php_checkuid(path, NULL, CHECKUID_ALLOW_ONLY_DIR)))) {
     890           0 :                 RETURN_FALSE;
     891             :         }
     892             : 
     893           2 :         if ((mode & S_IFCHR) || (mode & S_IFBLK)) {
     894           0 :                 if (ZEND_NUM_ARGS() == 2) {
     895           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "For S_IFCHR and S_IFBLK you need to pass a major device kernel identifier");
     896           0 :                         RETURN_FALSE;
     897             :                 }
     898           0 :                 if (major == 0) {
     899           0 :                         php_error_docref(NULL TSRMLS_CC, E_WARNING,
     900             :                                 "Expects argument 3 to be non-zero for POSIX_S_IFCHR and POSIX_S_IFBLK");
     901           0 :                         RETURN_FALSE;
     902             :                 } else {
     903             : #if defined(HAVE_MAKEDEV) || defined(makedev)
     904           0 :                         php_dev = makedev(major, minor);
     905             : #else
     906             :                         php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot create a block or character device, creating a normal file instead");
     907             : #endif
     908             :                 }
     909             :         }
     910             : 
     911           2 :         result = mknod(path, mode, php_dev);
     912           2 :         if (result < 0) {
     913           2 :                 POSIX_G(last_error) = errno;
     914           2 :                 RETURN_FALSE;
     915             :         }
     916             : 
     917           0 :         RETURN_TRUE;
     918             : }
     919             : #endif
     920             : /* }}} */
     921             : 
     922             : /* Takes a pointer to posix group and a pointer to an already initialized ZVAL
     923             :  * array container and fills the array with the posix group member data. */
     924          13 : int php_posix_group_to_array(struct group *g, zval *array_group) /* {{{ */
     925             : {
     926             :         zval *array_members;
     927             :         int count;
     928             : 
     929          13 :         if (NULL == g)
     930           0 :                 return 0;
     931             : 
     932          13 :         if (array_group == NULL || Z_TYPE_P(array_group) != IS_ARRAY)
     933           0 :                 return 0;
     934             : 
     935          13 :         MAKE_STD_ZVAL(array_members);
     936          13 :         array_init(array_members);
     937             :         
     938          13 :         add_assoc_string(array_group, "name", g->gr_name, 1);
     939          13 :         add_assoc_string(array_group, "passwd", g->gr_passwd, 1);
     940          33 :         for (count=0; g->gr_mem[count] != NULL; count++) {
     941          20 :                 add_next_index_string(array_members, g->gr_mem[count], 1);
     942             :         }
     943          13 :         zend_hash_update(Z_ARRVAL_P(array_group), "members", sizeof("members"), (void*)&array_members, sizeof(zval*), NULL);
     944          13 :         add_assoc_long(array_group, "gid", g->gr_gid);
     945          13 :         return 1;
     946             : }
     947             : /* }}} */
     948             : 
     949             : /*
     950             :         POSIX.1, 5.5.1 unlink()
     951             :         POSIX.1, 5.5.2 rmdir()
     952             :         POSIX.1, 5.5.3 rename()
     953             :         POSIX.1, 5.6.x stat(), chmod(), utime() already supported by PHP.
     954             : */
     955             : 
     956             : /* {{{ proto bool posix_access(string file [, int mode])
     957             :    Determine accessibility of a file (POSIX.1 5.6.3) */
     958          15 : PHP_FUNCTION(posix_access)
     959             : {
     960          15 :         long mode = 0;
     961             :         int filename_len, ret;
     962             :         char *filename, *path;
     963             : 
     964          15 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &filename, &filename_len, &mode) == FAILURE) {
     965           3 :                 RETURN_FALSE;
     966             :         }
     967             : 
     968          12 :         if (strlen(filename) != filename_len) {
     969           0 :                 RETURN_FALSE;
     970             :         }
     971             : 
     972          12 :         path = expand_filepath(filename, NULL TSRMLS_CC);
     973          12 :         if (!path) {
     974           2 :                 POSIX_G(last_error) = EIO;
     975           2 :                 RETURN_FALSE;
     976             :         }
     977             : 
     978          30 :         if (php_check_open_basedir_ex(path, 0 TSRMLS_CC) ||
     979          20 :                         (PG(safe_mode) && (!php_checkuid_ex(filename, NULL, CHECKUID_CHECK_FILE_AND_DIR, CHECKUID_NO_ERRORS)))) {
     980           1 :                 efree(path);
     981           1 :                 POSIX_G(last_error) = EPERM;
     982           1 :                 RETURN_FALSE;
     983             :         }
     984             : 
     985           9 :         ret = access(path, mode);
     986           9 :         efree(path);
     987             : 
     988           9 :         if (ret) {
     989           5 :                 POSIX_G(last_error) = errno;
     990           5 :                 RETURN_FALSE;
     991             :         }
     992             : 
     993           4 :         RETURN_TRUE;
     994             : }
     995             : /* }}} */
     996             : 
     997             : /*
     998             :         POSIX.1, 6.x most I/O functions already supported by PHP.
     999             :         POSIX.1, 7.x tty functions, TODO
    1000             :         POSIX.1, 8.x interactions with other C language functions
    1001             :         POSIX.1, 9.x system database access
    1002             : */
    1003             : 
    1004             : /* {{{ proto array posix_getgrnam(string groupname)
    1005             :    Group database access (POSIX.1, 9.2.1) */
    1006           6 : PHP_FUNCTION(posix_getgrnam)
    1007             : {
    1008             :         char *name;
    1009             :         struct group *g;
    1010             :         int name_len;
    1011             : #if defined(ZTS) && defined(HAVE_GETGRNAM_R) && defined(_SC_GETGR_R_SIZE_MAX)
    1012             :         struct group gbuf;
    1013             :         long buflen;
    1014             :         char *buf;
    1015             : #endif
    1016             :         
    1017           6 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
    1018           0 :                 RETURN_FALSE;
    1019             :         }
    1020             : 
    1021             : #if defined(ZTS) && defined(HAVE_GETGRNAM_R) && defined(_SC_GETGR_R_SIZE_MAX)
    1022             :         buflen = sysconf(_SC_GETGR_R_SIZE_MAX);
    1023             :         if (buflen < 1) {
    1024             :                 RETURN_FALSE;
    1025             :         }
    1026             :         buf = emalloc(buflen);
    1027             :         g = &gbuf;
    1028             : 
    1029             :         if (getgrnam_r(name, g, buf, buflen, &g) || g == NULL) {
    1030             :                 POSIX_G(last_error) = errno;
    1031             :                 efree(buf);
    1032             :                 RETURN_FALSE;
    1033             :         }
    1034             : #else
    1035           6 :         if (NULL == (g = getgrnam(name))) {
    1036           6 :                 POSIX_G(last_error) = errno;
    1037           6 :                 RETURN_FALSE;
    1038             :         }
    1039             : #endif
    1040           0 :         array_init(return_value);
    1041             : 
    1042           0 :         if (!php_posix_group_to_array(g, return_value)) {
    1043           0 :                 zval_dtor(return_value);
    1044           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to convert posix group to array");
    1045           0 :                 RETVAL_FALSE;
    1046             :         }
    1047             : #if defined(ZTS) && defined(HAVE_GETGRNAM_R) && defined(_SC_GETGR_R_SIZE_MAX)
    1048             :         efree(buf);
    1049             : #endif
    1050             : }
    1051             : /* }}} */
    1052             : 
    1053             : /* {{{ proto array posix_getgrgid(long gid) 
    1054             :    Group database access (POSIX.1, 9.2.1) */
    1055          30 : PHP_FUNCTION(posix_getgrgid)
    1056             : {
    1057             :         long gid;
    1058             : #if defined(ZTS) && defined(HAVE_GETGRGID_R) && defined(_SC_GETGR_R_SIZE_MAX)
    1059             :         int ret;
    1060             :         struct group _g;
    1061             :         struct group *retgrptr = NULL;
    1062             :         long grbuflen;
    1063             :         char *grbuf;
    1064             : #endif
    1065             :         struct group *g;
    1066             :         
    1067          30 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &gid) == FAILURE) {
    1068          12 :                 RETURN_FALSE;
    1069             :         }
    1070             : #if defined(ZTS) && defined(HAVE_GETGRGID_R) && defined(_SC_GETGR_R_SIZE_MAX)
    1071             :         
    1072             :         grbuflen = sysconf(_SC_GETGR_R_SIZE_MAX);
    1073             :         if (grbuflen < 1) {
    1074             :                 RETURN_FALSE;
    1075             :         }
    1076             : 
    1077             :         grbuf = emalloc(grbuflen);
    1078             : 
    1079             :         ret = getgrgid_r(gid, &_g, grbuf, grbuflen, &retgrptr);
    1080             :         if (ret || retgrptr == NULL) {
    1081             :                 POSIX_G(last_error) = ret;
    1082             :                 efree(grbuf);
    1083             :                 RETURN_FALSE;
    1084             :         }
    1085             :         g = &_g;
    1086             : #else
    1087          18 :         if (NULL == (g = getgrgid(gid))) {
    1088           5 :                 POSIX_G(last_error) = errno;
    1089           5 :                 RETURN_FALSE;
    1090             :         }
    1091             : #endif
    1092          13 :         array_init(return_value);
    1093             : 
    1094          13 :         if (!php_posix_group_to_array(g, return_value)) {
    1095           0 :                 zval_dtor(return_value);
    1096           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to convert posix group struct to array");
    1097           0 :                 RETVAL_FALSE;
    1098             :         }
    1099             : #if defined(ZTS) && defined(HAVE_GETGRGID_R) && defined(_SC_GETGR_R_SIZE_MAX)
    1100             :         efree(grbuf);
    1101             : #endif
    1102             : }
    1103             : /* }}} */
    1104             : 
    1105          12 : int php_posix_passwd_to_array(struct passwd *pw, zval *return_value) /* {{{ */
    1106             : {
    1107          12 :         if (NULL == pw)
    1108           0 :                 return 0;
    1109          12 :         if (NULL == return_value || Z_TYPE_P(return_value) != IS_ARRAY)
    1110           0 :                 return 0;
    1111             : 
    1112          12 :         add_assoc_string(return_value, "name",      pw->pw_name, 1);
    1113          12 :         add_assoc_string(return_value, "passwd",    pw->pw_passwd, 1);
    1114          12 :         add_assoc_long  (return_value, "uid",       pw->pw_uid);
    1115          12 :         add_assoc_long  (return_value, "gid",         pw->pw_gid);
    1116          12 :         add_assoc_string(return_value, "gecos",     pw->pw_gecos, 1);
    1117          12 :         add_assoc_string(return_value, "dir",       pw->pw_dir, 1);
    1118          12 :         add_assoc_string(return_value, "shell",     pw->pw_shell, 1);
    1119          12 :         return 1;
    1120             : }
    1121             : /* }}} */
    1122             : 
    1123             : /* {{{ proto array posix_getpwnam(string groupname) 
    1124             :    User database access (POSIX.1, 9.2.2) */
    1125           6 : PHP_FUNCTION(posix_getpwnam)
    1126             : {
    1127             :         struct passwd *pw;
    1128             :         char *name;
    1129             :         int name_len;
    1130             : #if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWNAM_R)
    1131             :         struct passwd pwbuf;
    1132             :         long buflen;
    1133             :         char *buf;
    1134             : #endif
    1135             : 
    1136           6 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
    1137           0 :                 RETURN_FALSE;
    1138             :         }
    1139             : 
    1140             : #if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWNAM_R)
    1141             :         buflen = sysconf(_SC_GETPW_R_SIZE_MAX);
    1142             :         if (buflen < 1) {
    1143             :                 RETURN_FALSE;
    1144             :         }
    1145             :         buf = emalloc(buflen);
    1146             :         pw = &pwbuf;
    1147             : 
    1148             :         if (getpwnam_r(name, pw, buf, buflen, &pw) || pw == NULL) {
    1149             :                 efree(buf);
    1150             :                 POSIX_G(last_error) = errno;
    1151             :                 RETURN_FALSE;
    1152             :         }
    1153             : #else
    1154           6 :         if (NULL == (pw = getpwnam(name))) {
    1155           6 :                 POSIX_G(last_error) = errno;
    1156           6 :                 RETURN_FALSE;
    1157             :         }
    1158             : #endif  
    1159           0 :         array_init(return_value);
    1160             : 
    1161           0 :         if (!php_posix_passwd_to_array(pw, return_value)) {
    1162           0 :                 zval_dtor(return_value);
    1163           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to convert posix passwd struct to array");
    1164           0 :                 RETVAL_FALSE;
    1165             :         }
    1166             : #if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWNAM_R)
    1167             :         efree(buf);
    1168             : #endif
    1169             : }
    1170             : /* }}} */
    1171             : 
    1172             : /* {{{ proto array posix_getpwuid(long uid) 
    1173             :    User database access (POSIX.1, 9.2.2) */
    1174          26 : PHP_FUNCTION(posix_getpwuid)
    1175             : {
    1176             :         long uid;
    1177             : #if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWUID_R)
    1178             :         struct passwd _pw;
    1179             :         struct passwd *retpwptr = NULL;
    1180             :         long pwbuflen;
    1181             :         char *pwbuf;
    1182             :         int ret;
    1183             : #endif
    1184             :         struct passwd *pw;
    1185             : 
    1186          26 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &uid) == FAILURE) {
    1187          11 :                 RETURN_FALSE;
    1188             :         }
    1189             : #if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWUID_R)
    1190             :         pwbuflen = sysconf(_SC_GETPW_R_SIZE_MAX);
    1191             :         if (pwbuflen < 1) {
    1192             :                 RETURN_FALSE;
    1193             :         }
    1194             :         pwbuf = emalloc(pwbuflen);
    1195             : 
    1196             :         ret = getpwuid_r(uid, &_pw, pwbuf, pwbuflen, &retpwptr);
    1197             :         if (ret || retpwptr == NULL) {
    1198             :                 POSIX_G(last_error) = ret;
    1199             :                 efree(pwbuf);
    1200             :                 RETURN_FALSE;
    1201             :         }
    1202             :         pw = &_pw;
    1203             : #else
    1204          15 :         if (NULL == (pw = getpwuid(uid))) {
    1205           3 :                 POSIX_G(last_error) = errno;
    1206           3 :                 RETURN_FALSE;
    1207             :         }
    1208             : #endif
    1209          12 :         array_init(return_value);
    1210             : 
    1211          12 :         if (!php_posix_passwd_to_array(pw, return_value)) {
    1212           0 :                 zval_dtor(return_value);
    1213           0 :                 php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to convert posix passwd struct to array");
    1214           0 :                 RETVAL_FALSE;
    1215             :         }
    1216             : #if defined(ZTS) && defined(_SC_GETPW_R_SIZE_MAX) && defined(HAVE_GETPWUID_R)
    1217             :         efree(pwbuf);
    1218             : #endif
    1219             : }
    1220             : /* }}} */
    1221             : 
    1222             : 
    1223             : #ifdef HAVE_GETRLIMIT
    1224             : 
    1225             : #define UNLIMITED_STRING "unlimited"
    1226             : 
    1227             : /* {{{ posix_addlimit
    1228             :  */
    1229          22 : static int posix_addlimit(int limit, char *name, zval *return_value TSRMLS_DC) {
    1230             :         int result;
    1231             :         struct rlimit rl;
    1232             :         char hard[80];
    1233             :         char soft[80];
    1234             : 
    1235          22 :         snprintf(hard, 80, "hard %s", name);
    1236          22 :         snprintf(soft, 80, "soft %s", name);
    1237             : 
    1238          22 :         result = getrlimit(limit, &rl);
    1239          22 :         if (result < 0) {
    1240           0 :                 POSIX_G(last_error) = errno;
    1241           0 :                 return FAILURE;
    1242             :         }
    1243             : 
    1244          22 :         if (rl.rlim_cur == RLIM_INFINITY) {
    1245          10 :                 add_assoc_stringl(return_value, soft, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1, 1);
    1246             :         } else {
    1247          12 :                 add_assoc_long(return_value, soft, rl.rlim_cur);
    1248             :         }
    1249             : 
    1250          22 :         if (rl.rlim_max == RLIM_INFINITY) {
    1251          14 :                 add_assoc_stringl(return_value, hard, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1, 1);
    1252             :         } else {
    1253           8 :                 add_assoc_long(return_value, hard, rl.rlim_max);
    1254             :         }
    1255             : 
    1256          22 :         return SUCCESS;
    1257             : }
    1258             : /* }}} */
    1259             : 
    1260             : /* {{{ limits[]
    1261             :  */
    1262             : struct limitlist {
    1263             :         int limit;
    1264             :         char *name;
    1265             : } limits[] = {
    1266             : #ifdef RLIMIT_CORE
    1267             :         { RLIMIT_CORE,  "core" },
    1268             : #endif
    1269             : 
    1270             : #ifdef RLIMIT_DATA
    1271             :         { RLIMIT_DATA,  "data" },
    1272             : #endif
    1273             : 
    1274             : #ifdef RLIMIT_STACK
    1275             :         { RLIMIT_STACK, "stack" },
    1276             : #endif
    1277             : 
    1278             : #ifdef RLIMIT_VMEM
    1279             :         { RLIMIT_VMEM, "virtualmem" },
    1280             : #endif
    1281             : 
    1282             : #ifdef RLIMIT_AS
    1283             :         { RLIMIT_AS, "totalmem" },
    1284             : #endif
    1285             : 
    1286             : #ifdef RLIMIT_RSS
    1287             :         { RLIMIT_RSS, "rss" },
    1288             : #endif
    1289             : 
    1290             : #ifdef RLIMIT_NPROC
    1291             :         { RLIMIT_NPROC, "maxproc" },
    1292             : #endif
    1293             : 
    1294             : #ifdef RLIMIT_MEMLOCK
    1295             :         { RLIMIT_MEMLOCK, "memlock" },
    1296             : #endif
    1297             : 
    1298             : #ifdef RLIMIT_CPU
    1299             :         { RLIMIT_CPU,   "cpu" },
    1300             : #endif
    1301             : 
    1302             : #ifdef RLIMIT_FSIZE
    1303             :         { RLIMIT_FSIZE, "filesize" },
    1304             : #endif
    1305             : 
    1306             : #ifdef RLIMIT_NOFILE
    1307             :         { RLIMIT_NOFILE, "openfiles" },
    1308             : #endif
    1309             : 
    1310             : #ifdef RLIMIT_OFILE
    1311             :         { RLIMIT_OFILE, "openfiles" },
    1312             : #endif
    1313             : 
    1314             :         { 0, NULL }
    1315             : };
    1316             : /* }}} */
    1317             : 
    1318             : 
    1319             : /* {{{ proto array posix_getrlimit(void)
    1320             :    Get system resource consumption limits (This is not a POSIX function, but a BSDism and a SVR4ism. We compile conditionally) */
    1321           2 : PHP_FUNCTION(posix_getrlimit)
    1322             : {
    1323           2 :         struct limitlist *l = NULL;
    1324             : 
    1325           2 :         PHP_POSIX_NO_ARGS;
    1326             : 
    1327           2 :         array_init(return_value);
    1328             : 
    1329          24 :         for (l=limits; l->name; l++) {
    1330          22 :                 if (posix_addlimit(l->limit, l->name, return_value TSRMLS_CC) == FAILURE) {
    1331           0 :                         zval_dtor(return_value);
    1332           0 :                         RETURN_FALSE;
    1333             :                 }
    1334             :         }
    1335             : }
    1336             : /* }}} */
    1337             : 
    1338             : #endif /* HAVE_GETRLIMIT */
    1339             : 
    1340             : /* {{{ proto int posix_get_last_error(void)
    1341             :    Retrieve the error number set by the last posix function which failed. */
    1342           7 : PHP_FUNCTION(posix_get_last_error)
    1343             : {
    1344           7 :         PHP_POSIX_NO_ARGS;      
    1345             : 
    1346           5 :         RETURN_LONG(POSIX_G(last_error));
    1347             : }
    1348             : /* }}} */
    1349             : 
    1350             : /* {{{ proto string posix_strerror(int errno)
    1351             :    Retrieve the system error message associated with the given errno. */
    1352          26 : PHP_FUNCTION(posix_strerror)
    1353             : {
    1354             :         long error;
    1355             : 
    1356          26 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &error) == FAILURE) {
    1357          11 :                 RETURN_FALSE;
    1358             :         }
    1359             : 
    1360          15 :         RETURN_STRING(strerror(error), 1);
    1361             : }
    1362             : /* }}} */
    1363             : 
    1364             : #endif
    1365             : 
    1366             : #ifdef HAVE_INITGROUPS
    1367             : /* {{{ proto bool posix_initgroups(string name, int base_group_id)
    1368             :    Calculate the group access list for the user specified in name. */
    1369           4 : PHP_FUNCTION(posix_initgroups)
    1370             : {
    1371             :         long basegid;
    1372             :         char *name;
    1373             :         int name_len;
    1374             : 
    1375           4 :         if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &name, &name_len, &basegid) == FAILURE) {
    1376           2 :                 RETURN_FALSE;
    1377             :         }
    1378             : 
    1379           2 :         if (name_len == 0) {
    1380           2 :                 RETURN_FALSE;
    1381             :         }
    1382             : 
    1383           0 :         RETURN_BOOL(!initgroups((const char *)name, basegid));
    1384             : }
    1385             : /* }}} */
    1386             : #endif
    1387             : 
    1388             : /*
    1389             :  * Local variables:
    1390             :  * tab-width: 4
    1391             :  * c-basic-offset: 4
    1392             :  * End:
    1393             :  * vim600: sw=4 ts=4 fdm=marker
    1394             :  * vim<600: sw=4 ts=4
    1395             :  */

Generated by: LCOV version 1.10

Generated at Sun, 27 Jul 2014 12:58:34 +0000 (4 days ago)

Copyright © 2005-2014 The PHP Group
All rights reserved.