=head1 NAME POSIX::Overview - POSIX in Perl =head1 DESCRIPTION The I defines access to the operating system. Most operating systems (not limited to the UNIX family) provide at least a part of this standard, sometimes as optional or commercial extension package. POSIX describes how C-programmers can access the operation system. Perl's core and additional modules on CPAN together, offer most of the POSIX functionality, although usually in a more powerful way. This manual-page tries to explain where you can find POSIX features in the Perl language. =head2 The specification The I published by I is a huge specification. Issue 7 (March 2010) lists nearly 1200 functions. A large part of these functions are defined by POSIX 1003.1-2008, which gives the name to this module. This manual page does not explain what the functions do in detail, because the official POSIX manuals do a much better job. On UNIX, those manuals are usually available as set C<3p>. =head2 WARNINGS POSIX is a standard with a long history, deeply tied into the Operating System. This means that you will encounter (sometimes large, often small) differences when used on different platforms. Perl's core and modules often attempt to hide differences, but is not always succesful. Be warned that we refer to many modules which are not distributed with Perl's CORE, so are maintained by separate people which have their own responsibility, programming practices, and choice of license. This manual-page attempts to be correct and complete, but might contain mistakes or lack some references. Please contribute! =head2 How to use this manual page For each of the POSIX functions, we try to direct you to the best documentation on how to get related functionality in Perl. Even the most simple functions will have differences. We do not explain the POSIX functions because the standard POSIX manuals do a much better job. And, of course, we do not attempt to explain core functionality or CPAN modules. Some references are to F, which means that it is provided in by the POSIX module distributed with Perl itself. In all cases, when C is returned it means failure. In that case, C<$!> is set. A number of references are made to modules in the L name-space, often abbreviated to the last name-space component. For instance, C<::FdIO> stands for L. Those modules give you access to all the useful POSIX.xs routine. Read L for more. Often, the description will refer you to L, which means that there is a perl core function which does similar things as the POSIX function. On most platforms you can easily find the perlfunc descriptions via L. For instance: perldoc -f write Another important source for Operating System facts are global variables. Those are described in the L manual. Those variables have extremely short names (like C<< $$ >> for process-id) but also longer names (C<$PID> and C<$PROCESS_ID>). The latter are only available when you load the C module. Names defined by the L programming language are amongst the long alternative names. Finally, the tables often refer to modules which implement comparable functionality. In most cases, they offer a pure Perl (so portable) alternative. =head1 FUNCTIONS The functions are categorized as listed in chapter 3.3 of the book of the Open Group, with the exception of those sections which only list unsupported features. Nothing related to threads, scheduling and tracing control is provided by Perl. See L on the thread implementation of Perl. =over 4 =item * functions beginning with C are not supported =item * functions beginning with C are not supported =item * functions beginning with C< pthread_> are not supported =item * thread-safe functions, ending on C<_r>, are not supported =back =head2 Asynchronous Input and Output Interfaces These functions are provided by L: aio_cancel, aio_error, aio_fsync, aio_read, aio_return, aio_suspend, aio_write Not supported: lio_listio =head2 Jump Interfaces These functions are used to handle error conditions. In Perl, you cannot handle these errors at such a low level. longjmp perlfunc/die setjmp perlfunc/eval =head2 Maths Library Interfaces The accuracy of floating point numbers depends on compilation flags of Perl. At the C level, there are many versions of these functions, but only one is listed in this section. L provides pure perl implementations for all sine, cosine and tangent functions and their hyperbolic and reverse variants. L provides their complex variants. In both modules, the names of the functions sometimes differ slightly from the POSIX names. The modules L and L offer a wide range of mathematical functions with flexible precission. These are specified in POSIX: acosh Math::Trig acos ::Math asinh Math::Trig asin ::Math atan2 perlfunc ::Math atanh Math::Trig atan ::Math ceil ::Math cosh ::Math cos perlfunc ::Math exp perlfunc ::Math fabs perlfunc/abs ::Math/abs floor ::Math fmax List::Util/min fmin List::Util/max fmod ::Math frexp ::Math isgreaterequal perlop/>= isgreater perlop/> islessequal perlop/<= islessgreater perlop/!= isless perlop/< ldexp ::Math log10 ::Math log perlfunc ::Math modf ::Math pow perlop/** ::Math rint ::Math sinh ::Math sin perlfunc ::Math sqrt perlfunc ::Math tanh ::Math tan ::Math Complex numbers only in Perl with L: cabs, cacos, cacosh, carg, casin, casinh, catan, catanh, cbrt, ccos, ccosh, cexp, cimag, clog, conj, cpow, cproj, creal, csin, csinh, csqrt, ctan, ctanh Probably not supported: copysign, erf, erfc, exp2, expm1, fdim, fma, fpclassify, hypot, ilogb, isfinite, isinf, isnan, isnormal, isunordered, lgamma, llround, log1p, log2, logb, lround, nan, nearbyint, nextafter, nexttoward, remainder, remquo, round, scalbln, scalbn, signbit, tgamma, trunc =head2 General ISO C Library Interfaces =head3 convert strings to values and back All C, C, C and friends functions are usually not needed in Perl programs: the integer and float types are at their largest size, so when a string is used in numeric context it will get converted automatically. Still, L does provide a few of those functions, which are sometimes more accurate in number parsing for large numbers. strtod ::Math strtol ::Math strtoul ::Math =head3 String handling Perl knows about latin1 strings are utf-8 strings. Most complications of character-sets are hidden for the user, as long as the user provides encoding details at all entry and exit points of the program. See L, L and L. strcat perlop/.= strchr perlfunc/index strcmp perlop/cmp perlop/eq strcpy perlop/= strcspn $a =~ m/^([^$b]*)/ && length $1 strerror perlvar/$ERRNO "$!" strlen perlvar/length strncat $a .= substr $b, 0, $n; strncmp (substr $a, 0, $n) eq (substr $b, 0, $n) strncpy $a = substr $b, 0, $n; strpbrk $a =~ m/(.*?)[$b]/ && length $1 strrchr $a =~ m/(.*)$b/ && length $1 strspn $a =~ m/^([$b]*)/ && length $1 strstr perlop/index strtok perlfunc/split tolower perlfunc/lc "\L$str\E" "\l$str" toupper perlfunc/uc "\U$str\E" "\u$str" B C provides functions named C and C, which simply call C and C respectively. They take their parameter as string, maybe even ut8-string, not raw ascii bytes. =head3 sprintf and scanf The C function is provided by L, with many extensions to the POSIX format specification. Perl has powerful string interpolation features which reduce the need for sprintf. snprintf not needed sprintf perlfunc/sprintf sscanf use regular expressions or perlfunc/unpack vsnprintf not needed vsprintf not needed vsscanf not needed =head3 Characters C provides handlers of property groups, which are affected by the locale setting as long as all the characters are only single bytes. We recommend that you use regular expressions, which are more flexible. This table shows the alternative expressions. isalnum [[:alnum:]] \p{Alnum} isalpha [[:alpha:]] \p{Alpha} \pL isascii [[:ascii:]] \p{Ascii} isblank [[:blank:]] \p{Blank} \h iscntrl [[:cntrl:]] \p{Control} \p{Cc} isdigit [[:digit:]] \p{Digit} \p{Nd} \d isgraph [[:graph:]] \p{Graph} islower [[:lower:]] \p{Lower} \p{Ll} isprint [[:print:]] \p{Print} ispunct [[:punct:]] \p{Punct} \pP isspace [[:space:]] \p{Space} isupper [[:upper:]] \p{Upper} \p{Lu} isxdigit [[:xdigit:]] \p{XDigit} \p{Hex} [0-9a-fA-F] [[:word:]] \p{Word} \w C<\p{PerlSpace}> (C<\s>) is close to the ASCII subdomain of C<\p{Space}>. The C<\p{Word}> character class is a Perl specific extension. There are hundreds more character classes and extensions. See L and L. The C function is defined by XSI, not POSIX. =head3 Locale Locales describe national and language specific facts. See L for the details. setlocale ::Locale localeconv ::Locale strcoll POSIX.pm strxfrm POSIX.pm The functions C and C are not useful in Perl, which automatically resolves character set problems. =head3 Math abs perlfunc/abs ::Math/abs div ::Math rand perlfunc/rand ::Math srand perlfunc/srand ::Math Integers which overflow will automatically upgrade into floats, so all C, C, C, C are implemented by L. Division via C
, C, C, and C are also equivalent. The following functions where first defined by C99, and describe the handling of floating-point rounding and exceptions. They are not supported: feclearexcept, fegetenv, fegetexceptflag, fegetround, feholdexcept, feraiseexcept, fesetenv, fesetexceptflag, fesetround, fetestexcept, feupdateenv =head3 Time The L code provides access to all time functions. The result depends on the locale setting of the timezone. See also L. L contains pure Perl implementations for the other functions of this section. Those are fully portable, which cannot always be said for POSIX library implementations. Also L may be very userful. Use L if you need to handle timestamps with better resolution than seconds. asctime ::Time Date::Format ctime ::Time Date::Format difftime ::Time Time::HiRes/tv_interval gmtime perlfunc ::Time Date::Calc/Gmtime localtime perlfunc ::Time Date::Calc/Localtime mktime ::Time Date::Calc/Mktime strftime ::Time Date::Format tzname ::Time tzset ::Time =head3 Sorting qsort perlfunc/sort bsearch POSIX::bsearch Search::Dict Tree Tree::Binary The Quick Sort implemented by C was used in L uptil release 5.6. Later, it became more flexible. See the manual page about the sort pragma: sort(3pm). =head3 Memory management Perl uses its own reference counting memory management (of course based on the POSIX interface). Only when you write XS code, you will use abstractions of these: C, C, C and C. memchr perlfunc/index memcmp perlop/cmp perlop/eq memcpy perlop/= memmove perlop/substr memset perlop/x $a = 'A' x 100; offsetof perlfunc/unpack # removed from POSIX standard =head3 Var-args All functions in Perl can handle a variable list of arguments, so va_arg not needed va_copy not needed va_end not needed va_start not needed =head2 Wide-Character ISO C Library Interfaces The L module does define wide-character functions. I refers to multiples bytes per character: strings able to use more than 256 different characters in an unspecified encoding. Perl itself has both single byte Latin1 and utf-8 strings, covering all needs: pick compact or powerful. One may need to use wide-characters to implement certain interface specifications, but that is getting rare. btowc POSIX.pm mblen POSIX.pm mbrlen POSIX.pm mbrtowc POSIX.pm mbstowcs POSIX.pm mbtowc POSIX.pm wcstombs POSIX.pm wctomb POSIX.pm Not provided are all function wide versions of character classes, like C, all functions which start with C, C, C or C. Additionally, missing are mbsrtowcs, mbsinit, swprintf, swscanf, vswprintf, vswscanf, wcrtomb mbsnrtowcs, wcpcpy, wcpncpy Also, L and L offer some extras. =head2 General C Library Extension Interfaces Function C can usually be avoided using L for collecting filenames in the file system. When you already have a filename in a string, you need to rewrite the pattern into a regular expression. my @scripts = glob "*.pl"; my @scripts = grep /\.pl$/, @filenames; Process your command-line options with C or C, which are more platform indepent and more flexible than the POSIX version (therefore they are missing) getopt, getsubopt, optarg, opterr, optind, optopt Some string functions have simple Perl work-arounds: strcasecmp lc($a) cmp lc($b) strdup $b = $a strncasecmp substr($a,$n) cmp substr($b,$n) strndup $b = substr($a, $n) strnlen length substr($a, $n) stpcpy perlop/= stpncpy $b = substr $a, 0, $l strfmon PAB3::Utils =head2 Clock Selection Interfaces clock_nanosleep Time::HiRes =head2 Device Input and Output Interfaces =head3 File-descriptor based See C section "Open a la C". close perlfunc/close (!) ::FdIO/closefd open perlfunc/sysopen ::FdIO/openfd read perlfunc/sysread ::FdIO/readfd write perlfunc/syswrite ::FdIO/writefd pread not supported pwrite not supported =head3 File-handle based clearerr IO::Handle fclose perlfunc/close IO::Handle/close fdopen perlfunc/open IO::Handle/new_from_fd feof perlfunc/eof IO::Handle/eof ferror perlvar/$ERRNO IO::Handle/error $!+0 fflush IO::Handle/flush fgetc perlfunc/getc IO::Handle/getc perlfunc/read fgets perlfunc/readline IO::Handle/gets fileno perlfunc IO::Handle fopen perlfunc/open IO::Handle/open fprintf perlfunc/printf IO::Handle/printf fputc perlfunc/print IO::Handle/print fputs perlfunc/print perlfunc/say IO::Handle/say fread perlfunc/read freopen perlopentut/Re-Opening Files fscanf use regular expressions fwrite perlfunc/syswrite IO::Handle/write getchar perlfunc/getc IO::Handle/getc getc perlfunc IO::Handle gets perlfunc/readline IO::Handle/readline printf perlfunc putchar perlfunc/print putc perlfunc/print puts perlfunc/print perlfunc/say scanf use regular expressions setbuf IO::Handle setvbuf IO::Handle ungetc IO::Handle perror perlfunc/warn perlvar/$ERRNO POSIX.pm "$!" stderr *STDERR POSIX.pm stdin *STDIN POSIX.pm stdout *STDOUT POSIX.pm =head3 Event driven Event loops require a considerable amount of file handle administration. Therefore, there are a large number of module available to support the basic calls. For instance L, L, L, ...and many more poll IO::Poll pselect POSIX::pselect select perlfunc ::Events IO::Select FD_CLR ::Events FD_ISSET ::Events FD_SET ::Events FD_ZERO ::Events =head2 Extended Device Input and Output Interfaces Where Perl always uses flexible lists, the followin are not adding anything. See L vfprintf perlfunc/printf vprintf (same) vfscanf use regex vscanf (same) dprintf write $fd, sprintf $fmt, @data vdprint (same) fmemopen open $fh, '>', \$buffer; open_memstream (same) =head2 General Terminal Interfaces Most terminal interface functions are provided by the separate L module, which is the same as the C component in C See its manpage for the usage. cfgetispeed ::Termios cfgetospeed ::Termios cfsetispeed ::Termios cfsetospeed ::Termios ctermid ::Proc isatty perlfunc/-X flag -t tcdrain ::Termios tcflow ::Termios tcflush ::Termios tcgetattr ::Termios/getattr tcsendbreak ::Termios tcsetattr ::Termios/setattr ttyname ::Termios =head2 Dynamic Linking Interfaces The loading of shared libraries in organized by its XS wrapper. The module L opens both the wrapper and the wrapped library. Therefore, there is no need for dlclose, dlerror, dlopen, dlsym =head2 File Descriptor Management Interfaces Although the name of this section suggests differently, actually most of these functions use a file handle, not a descriptor. On file handles: fcntl perlfunc IO::Handle fgetpos perlfunc/tell IO::Seekable/getpos fseek perlfunc/seek IO::Seekable/seek fseeko perlfunc/seek IO::Seekable/seek fsetpos perlfunc/seek IO::Seekable/setpos ftell perlfunc/tell IO::Seekable/tell ftello perlfunc/tell IO::Seekable/tell ftruncate perlfunc/truncate IO::Handle/truncate rewind POSIX.pm Using file-descriptors dup perlopentut/<&= ::FdIO/dupfd dup2 ::FdIO/dup2fd lseek ::FdIO/seekfd The symbolic constants for C and C are provided by L. =head2 FIFO Interfaces mkfifo ::FS mkfifoat not supported mknodat not supported =head2 File Attribute Interfaces Perl's C and C accept both file names and file handles. Be warned that the order of the parameters is different! chmod perlfunc chown perlfunc fchmod perlfunc/chmod fchown perlfunc/chown umask perlfunc fchmodat not supported fchownat not supported The symbolic constants for C are provided by L (and POSIX.pm) =head2 Thread-Safe Stdio Locking Interfaces Perl does support the non-portable flock (see L) in core, but the POSIX C mechanism is probably unsupported: flockfile, ftrylockfile, funlockfile, getc_unlocked, getchar_unlocked, putc_unlocked, putchar_unlocked =head2 File System Interfaces access filetest ::FS chdir perlfunc closedir perlfunc IO::Dir/close creat perlfunc/sysopen ::FdIO/creatfd fchdir perlfunc fpathconf ::Pathconf fstat perlfunc/stat File::stat POSIX.pm fstatvfs Filesys::statvfs getcwd Cwd/getcwd link perlfunc mkdir perlfunc mkstemp File::Temp/mkstemp opendir perlfunc IO::Dir/open pathconf ::Pathconf readdir perlfunc IO::Dir/read remove File::Remove POSIX.pm rename perlfunc rewinddir perlfunc IO::Dir/rewind rmdir perlfunc stat perlfunc File::stat statvfs Filesys::statvfs tmpfile File::Temp IO::File/new_tmpfile tmpnam (insecure!) File::Temp POSIX.pm truncate perlfunc unlink perlfunc utime perlfunc ::FS POSIX.pm B POSIX::utime($filename, $atime, $mtime); CORE::utime($atime, $mtime, @filenames); The symbolic constants needed to understand the result of C are provided by L. =head2 File System Extension Interfaces alphasort perlfunc/sort getdelim perlvar/$INPUT_RECORD_SEPARATOR getline $a = IO::Handle glob perlfunc/glob globfree never needed mkdtemp File::Temp/mkdtemp scandir perlfunc/glob dirfd not supported fdopendir not supported None of the functions of the 'at' interface is supported: they provide a way to use paths relative to a file-descriptor. This POSIX module only supports their absolute brothers: faccessat, fstatat, linkat, mkdirat, openat, renameat, unlinkat, utimensat =head2 Internationalization Interfaces nl_langinfo I18N::Langinfo/langinfo This interface is far to simple to really translate messages into various languages. You may have a look at various implementations of C. catclose Locale::Msgcat catgets Locale::Msgcat catopen Locale::Msgcat An Object Oriented wrapper to the iconv interface is provided by L. Better have a look at the L first. iconv Text::Iconv/convert iconv_open Text::Iconv/new iconv_close Text::Iconv/DESTROY =head2 Job Control Interfaces setpgid ::Proc tcgetpgrp ::Proc tcsetpgrp ::Proc tcgetsid not supported =head2 Memory Interfaces Memory management is done by the language. It is difficult to allocate data structures on specific locations, although there are various mmap interfaces. mmap Sys::Mmap Mmap munmap Sys::Mmap Mmap mprotect IO::AIO/aio_mprotect =head2 Multiple Concurrent Locale Interfaces The functions C, C, C, and C are not supported. Neither are all of the functions which relate to is, all ending on C<_l>, like C. =head2 Multiple Process Interfaces _Exit ::Proc/_exit _exit ::Proc assert Carp/croak POSIX.pm atexit perlsub/END{} block clock ::Time Time::HiRes exec* perlfunc exit perlfunc fork perlfunc Windows::perlfork getpgrp perlfunc getpgid ::Proc getpid perlvar/$PID $$ getppid perlvar/$PPID getsid not supported setsid ::Proc sleep perlfunc POSIX.pm (see warning) times perlfunc ::Proc/times5 wait perlfunc ::Proc waitid not supported waitpid perlfunc ::Proc fexecve not supported B different return parameters for POSIX.pm ($user, $sys, $cuser, $csys) = CORE::times(); ($elapse, $user, $sys, $cuser, $csys) = POSIX::times(); ($elapse, $user, $sys, $cuser, $csys) = ::Proc::times5(); B different return value for POSIX.pm $slept = CORE::sleep(10); $early = POSIX::sleep(10); # $slept+$early=10 $pid = waitpid(-1, WNOHANG); =head2 Networking Interfaces =head3 handling sockets Most code uses the Object Oriented approach via L. accept perlfunc IO::Socket bind perlfunc IO::Socket connect perlfunc IO::Socket::INET getsockname perlfunc IO::Socket/sockname getpeername perlfunc IO::Socket/peername getsockopt perlfunc IO::Socket/sockopt setsockopt perlfunc IO::Socket/sockopt shutdown perlfunc IO::Socket socket perlfunc IO::Socket sockatmark IO::Socket/atmark socketpair perlfunc IO::Socket listen perlfunc IO::Socket recv perlfunc IO::Socket recvfrom perlfunc/rev IO::Socket/recv recvmsg not supported send perlfunc IO::Socket sendmsg not supported sendto perlfunc/send IO::Socket/send If you use the right functions of L you will not need these. Otherwise, you should take a look at L and C. htonl, htons, ntohl, ntohs inet_addr, inet_ntoa, inet_ntop, inet_pton =head3 network configuration Most network configuration functions are provided in CORE. There are also object wrappers in various C modules. getaddrinfo perlfunc Net::addrinfo gethostbyaddr perlfunc Net::hostent gethostbyname perlfunc Net::hostent gethostent perlfunc Net::hostent gethostname Sys::Hostname getnameinfo perlfunc getnetbyaddr perlfunc Net::netent getnetbyname perlfunc Net::netent getnetent perlfunc Net::netent getprotobyname perlfunc Net::protoent getprotobynumber perlfunc Net::protoent getprotoent perlfunc Net::protoent getservbyname perlfunc Net::servent getservbyport perlfunc Net::servent getservent perlfunc Net::servent sethostent perlfunc Net::hostent setnetent perlfunc Net::netent setprotoent perlfunc Net::protoent setservent perlfunc Net::servent Never needed, memory automatically freed: endhostent, endnetent, endprotoent, endservent, freeaddrinfo, if_freenameindex Not supported: gai_strerror, if_indextoname, if_nameindex, if_nametoindex =head2 Pipe Interfaces The C has an implementation in POSIX.pm, which uses file descriptors. The CORE version of pipe uses file handles. pipe perlfunc ::FdIO/pipefd B different return parameters for POSIX.pm my ($r_fh, $w_fh) = CORE::pipe(); my ($r_fd, $w_fd) = POSIX::pipe(); my ($r_fd, $w_fd) = ::FdIO::pipefd(); =head2 Realtime Signal Interfaces sigqueue POSIX::RT::Signal sigtimedwait POSIX::RT::Signal sigwaitinfo POSIX::RT::Signal =head2 Regular Expression Interfaces Perl's regular expressions are much more powerful. See L. regcomp qr// regerror not needed regexec perlop/=~ regfree not needed =head2 Semaphore Interfaces POSIX semaphores are supported by L: sem_close POSIX::RT::Semaphore/close sem_destroy POSIX::RT::Semaphore/destroy sem_getvalue POSIX::RT::Semaphore/getvalue sem_init POSIX::RT::Semaphore/init sem_open POSIX::RT::Semaphore/open sem_post POSIX::RT::Semaphore/post sem_timedwait POSIX::RT::Semaphore/timedwait sem_trywait POSIX::RT::Semaphore/trywait sem_unlink POSIX::RT::Semaphore/unlink sem_wait POSIX::RT::Semaphore/wait =head2 Shell and Utilities Interfaces pclose perlfunc/close popen perlfunc/open ('|-' or '-|') perlfunc/qx system perlfunc wordexp perlfunc/glob wordfree never needed =head2 Signal Interfaces Signal handling is provided via L and L. Take a look at those manuals. abort perlvar/%SIG alarm perlfunc kill perlfunc ::Signals pause ::Signals psiginfo not supported psignal not supported raise ::Signals sigaction ::Signals sigaddset ::Signals sigdelset ::Signals sigemptyset ::Signals sigfillset ::Signals sigismember ::Signals signal perlvar/%SIG ::Signals sigpending ::Signals sigprocmask ::Signals sigsuspend ::Signals sigwait not supported strsignal not supported B, parameter order in POSIX.pm CORE::kill($signal, $pid); ::Signals::kill($signal, $pid); POSIX::kill($pid, $signal); =head2 Single Process Interfaces confstr ::Confstr environ perlvar/%ENV errno perlvar/$ERRNO $!+0 getenv perlvar/%ENV $ENV{PATH} setenv perlvar/%ENV $ENV{HOME} = '/tmp' sysconf ::Sysconf uname ::OS unsetenv perlvar/%ENV delete $ENV{PS1} The error constants are provided by Errno. =head2 Symbolic Link Interfaces lchown ::FS lstat perlfunc readlinkat not supported readlink perlfunc symlinkat not supported symlink perlfunc B POSIX.pm accepts only one filename CORE::chown($uid, $gid, @filename); ::FS::lchown($uid, $gid, @symlinks); POSIX::lchown($uid, $gid, $symlink); # !!! =head2 System Database Interfaces getgrgid perlfunc User::grent getgrnam perlfunc User::grent getpwnam perlfunc User::pwent getpwuid perlfunc User::pwent =head2 Timer Interfaces clock_getres Time::HiRes POSIX::RT::Clock clock_gettime Time::HiRes POSIX::RT::Clock clock_settime Time::HiRes POSIX::RT::Clock nanosleep Time::HiRes POSIX::RT::Clock timer_create POSIX::RT::Timer timer_delete POSIX::RT::Timer timer_getoverrun POSIX::RT::Timer timer_gettime POSIX::RT::Timer timer_settime POSIX::RT::Timer =head2 User and Group Interfaces cuserid ::Proc getegid perlvar/$EGID $) geteuid perlvar/$EUID $> getgid perlvar/$GID $( (split ' ', $GID)[0] getgroups perlvar/$GID $( split ' ', $GID getlogin perlfunc getuid perlvar/$UID $< # warning setegid perlvar/$EGID $) # warning seteuid perlvar/$EUID $> # warning setgid perlvar/$GID $( POSIX.pm # warning setuid perlvar/$UID $< POSIX.pm # warning B The special variables for user- and group-ids try to be smart: they are implemented using C and/or friends. POSIX.pm provides C and C which simply call the special variables. So: both do not offer access to the system functions with that name. Expect portability issues on this subject. Better B, but L instead! =head2 Wide Character Device Input and Output Interfaces No useful support for wide characters, so no fgetwc, fgetws, fputwc, fputws, fwide, fwprintf, fwscanf, getwc, getwchar, putwc, putwchar, ungetwc, vfwprintf, vfwscanf, vwprintf, vwscanf, wprintf, wscanf =head2 Process CPU-Time Clocks Interfaces Probably unsupported: clock_getcpuclockid POSIX::RT::Clock/get_cpuclock =head2 File Synchronization Interfaces fsync IO::Handle/sync File::Sync =head2 Memory Locking Interfaces mlockall IO::AIO munlockall IO::AIO mlock IO::AIO munlock IO::AIO =head2 Message Passing Interfaces mq_close POSIX::RT::MQ mq_getattr POSIX::RT::MQ mq_notify POSIX::RT::MQ mq_open POSIX::RT::MQ mq_receive POSIX::RT::MQ mq_send POSIX::RT::MQ mq_setattr POSIX::RT::MQ mq_timedreceive POSIX::RT::MQ mq_timedsend POSIX::RT::MQ mq_unlink POSIX::RT::MQ =head2 Shared Memory Objects Interfaces shm_open POSIX::RT:SharedMem shm_unlink POSIX::RT:SharedMem =head2 Synchronized Input and Output Interfaces fdatasync IO::AIO/aio_fdatasync msync IO::AIO/aio_msync =head2 Trace Event Filter Interfaces No tracing support on POSIX level via C. There are various ways to debug Perl, however. For instance try perl -s script.pl =head2 XSI General C Library Interfaces Comparible functionality for functions which never made it into POSIX: a64l MIME::Base64/encode daylight ::Time/tzname ffs perlfunc/vec getdate ::Time/strftime isascii perlre/ [[:ascii:]] \p{Ascii} l64a MIME::Base64/decode memccpy $b = $1 if $a =~ m/(.*{,n}?)(?:c|$)/ signgam math, probably not supported strptime POSIX::strptime swab ($b,$a) = ($a,$b) timezone ::Time/tzname toascii $c & 0x7f _tolower perlfunc/lc _toupper perlfunc/lu No support for alternative random generators drand48, erand48, jrand48, lcong48, lrand48, mrand48, nrand48, seed48, srand48, initstate, random, setstate, srandom Perl supports HASHes by itself, so no need for hcreate, hdestroy, hsearch No need for double linked lists and table management insque, remque, lfind, lsearch Binary trees are less efficient than HASHes, which are much simpler to use as well. You may take a look at L or L, because these are missing: tdelete, tfind, tsearch, twalk =head2 XSI Database Management Interfaces Some simple database which probably no-one uses anymore. See C, for instance L. dbm_clearerr, dbm_close, dbm_delete, dbm_error, dbm_fetch, dbm_firstkey, dbm_nextkey, dbm_open, dbm_store =head2 XSI Device Input and Output Interfaces fmtmsg Sys::Syslog Probably not supported: grantpt, posix_openpt, ptsname, readv, unlockpt, write =head2 XSI File System Interfaces basename File::Basename dirname File::Basename ftw File::Find/find lockf File::lockf mknod ::FS Unix::Mknod Mknod nftw File::Find/find realpath File::Spec/canonpath seekdir perlfunc IO::Dir/seek sync File::Sync telldir perlfunc IO::Dir/tell tempnam (insecure!) File::Temp =head2 XSI Interprocess Communication Interfaces ftok IPC::SysV IPC::SharedMem msgctl IPC::Msg msgget IPC::Msg msgrcv IPC::Msg msgsnd IPC::Msg semctl IPC::Semaphore semget IPC::Semaphore semop IPC::Semaphore shmat IPC::SysV IPC::SharedMem shmctl IPC::SysV IPC::SharedMem shmdt IPC::SysV IPC::SharedMem shmget IPC::SysV IPC::SharedMem =head2 XSI Jump Interfaces No C<_longjmp> nor C<_setjmp>. =head2 XSI Maths Library Interfaces No C, C1, C, C0, C1, C =head2 XSI Multiple Process Interfaces getpriority perlfunc BSD::Resource getrlimit ::Limit BSD::Resource getrusage Unix::Getrusage BSD::Resource nice ::Proc setpgrp perlfunc ::Proc setpriority perlfunc BSD::Resource setrlimit ::Limit BSD::Resource ulimit ::Limit =head2 XSI Signal Interfaces The XSI signal interface is not supported, so no killpg, sigaltstack, sighold, sigignore, siginterrupt, sigpause, sigrelse, sigset =head2 XSI Single Process Interfaces gethostid not supported gettimeofday Time::HiRes putenv perlvar/%ENV =head2 XSI System Logging Interfaces closelog Sys::Syslog openlog Sys::Syslog setlogmask Sys::Syslog syslog Sys::Syslog See also the many logging frameworks, like Log::Log4perl, Log::Dispatch, or Log::Report. =head2 XSI Timer Interfaces getitimer Time::HiRes setitimer Time::HiRes =head2 XSI User and Group Interfaces endgrent not needed endpwent not needed endutxent User::Utmp getgrent perlfunc User::grent getpwent perlfunc User::pwent getutxent User::Utmp getutxid User::Utmp getutxline User::Utmp pututxline User::Utmp setgrent perlfunc User::grent setpwent perlfunc User::pwent setregid perlvar/$GID and $EGID setreuid perlvar/$UID and $EUID setutxent User::Utmp =head2 XSI STREAMS Interfaces ioctl perlfunc Streams are not supported. So no: fattach, fdetach, getmsg, getpmsg, isastream, putmsg, putpmsg =head1 CONSTANTS POSIX also defines zillions of constants. They are listed in (and available via) the C modules. The C<_POSIX_> constants can be read via L. =back =head1 SEE ALSO This module is part of POSIX-1003 distribution version 0.13, built on July 26, 2012. Website: F. The code is based on L, which is released with Perl itself. See also M for additional functionality. =head1 COPYRIGHTS Copyrights of the perl code and the related documentation by 2011-2012 by [Mark Overmeer]. For other contributors see ChangeLog. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See F