NAME

POSIX::Overview - POSIX in Perl

DESCRIPTION

The specification

The Single UNIX Specification: Authorized Guide to Version 4 published by The Open Group 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 3p.

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!

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 POSIX.pm, which means that it is provided in by the POSIX module distributed with Perl itself. In all cases, when undef is returned it means failure. In that case, $! is set.

A number of references are made to modules in the POSIX::1003 name-space, often abbreviated to the last name-space component. For instance, ::FdIO stands for POSIX::1003::FdIO. Those modules give you access to all the useful POSIX.xs routine. Read POSIX::1003 for more.

Often, the description will refer you to perlfunc, 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 perldoc. For instance:

  perldoc -f write

Another important source for Operating System facts are global variables. Those are described in the perlvar manual. Those variables have extremely short names (like $$ for process-id) but also longer names ($PID and $PROCESS_ID). The latter are only available when you load the English module. Names defined by the awk 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.

The POSIX standard 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.

FUNCTIONS

Asynchronous Input and Output Interfaces

These functions are provided by IO::AIO: aio_cancel, aio_error, aio_fsync, aio_read, aio_return, aio_suspend, aio_write

Not supported: lio_listio

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

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.

Math::Trig provides pure perl implementations for all sine, cosine and tangent functions and their hyperbolic and reverse variants. Math::Complex provides their complex variants. In both modules, the names of the functions sometimes differ slightly from the POSIX names.

The modules Math::BigInt and Math::BigFloat 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 Math::Complex: 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

General ISO C Library Interfaces

convert strings to values and back

All strto*, atof, atoi 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, POSIX::1003::Math does provide a few of those functions, which are sometimes more accurate in number parsing for large numbers.

  strtod                          ::Math
  strtol                          ::Math
  strtoul                         ::Math

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 perlunicode, Encode and encoding.

  strtok      perlfunc/split
  strcat      perlop/.=
  strchr      perlfunc/index
  strcmp      perlop/cmp perlop/eq
  strcpy      perlop/=
  strerror    perlvar/$ERRNO   "$!"
  strlen      perlvar/length
  strstr      perlop/index
  tolower     perlfunc/lc      "\L$str\E"  "\l$str"
  toupper     perlfunc/uc      "\U$str\E"  "\u$str"

The functions strcspn, strpbrk, strrchr, and strspn can best be translated into regular expressions. See perlre.

The functions strncat, strncmp, and strncpy are used for various purposes which let themselves usually translate into various perlfunc/substr features.

POSIX.pm provides functions named tolower and toupper, which simply call lc and uc respectively. Be warned that the latter work on (utf-8 aware) strings, not ascii characters.

sprintf and scanf

The sprintf function is provided by perlfunc, 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

Characters

POSIX.pm 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

\p{PerlSpace} (\s) is close to the ASCII subdomain of \p{Space}. The \p{Word} character class is a Perl specific extension. There are hundreds more character classes and extensions. See perlunicode and perluniprops.

The isascii function is defined by XSI, not POSIX.

Locale

Locales describe national and language specific facts. See perllocale for the details.

  setlocale                       ::Locale
  localeconv                      ::Locale
  strcoll                         POSIX.pm
  strxfrm                         POSIX.pm

The functions strcoll and strxfrm are not useful in Perl, which automatically resolves character set problems.

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 abs, labs, llabs, imaxabs are implemented by "abs" in perfunc. Division via div, ldiv, lldiv, and imaxdiv 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

Time

The POSIX::1003::Time code provides access to all time functions. The result depends on the locale setting of the timezone. See also "Timer Interfaces".

Date::Format 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 Date::Calc may be very userful.

Use Time::HiRes 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  

Sorting

  qsort       perlfunc/sort
  bsearch                         POSIX::bsearch Search::Dict
                                  Tree Tree::Binary

The Quick Sort implemented by qsort was used in "sort" in perlfunc uptil release 5.6. Later, it became more flexible. See the manual page about the sort pragma: sort(3pm).

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: calloc, free, malloc and realloc.

  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

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

Wide-Character ISO C Library Interfaces

The POSIX module does define wide-character functions. Wide 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 iswalnum, all functions which start with tow, wcs, wct or wmem. Additionally, missing are mbsrtowcs, mbsinit, swprintf, swscanf, vswprintf, vswscanf, wcrtomb mbsnrtowcs, wcpcpy, wcpncpy

Also, i18n::Langinfo::Wide and POSIX::Wide offer some extras.

General C Library Extension Interfaces

Function fnmatch can usually be avoided using "glob" in perlfunc 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 Getopt::Std or Getopt::Long, 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

Clock Selection Interfaces

  clock_nanosleep                 Time::HiRes

Device Input and Output Interfaces

File-descriptor based

See perlopentut 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

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      <FH>
  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  <STDIN>
  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             ::FdIO            
  stdin       *STDIN              ::FdIO            
  stdout      *STDOUT             ::FdIO            

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 AnyEvent, POE, IO::Multiplex, ...and many more

  poll                            IO::Poll
  pselect                         POSIX::pselect
  select      perlfunc/select     IO::Select

Macros FD_CLR, FD_ISSET, FD_SET, FD_ZERO and not provided. However, they can be simulated easily with "vec" in perlfunc

Where Perl always uses flexible lists, these are not useful: vfprintf, vfscanf, vprintf, vscanf

Extended Device Input and Output Interfaces

Probably not supported: dprintf, vdprintf

The functions fmemopen and open_memstream by opening a scalar as file handle. See "open" in perlfunc open $fh, '>', \$buffer;

General Terminal Interfaces

Most terminal interface functions are provided by the separate POSIX::Termios module. 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

Dynamic Linking Interfaces

The loading of shared libraries in organized by its XS wrapper. The module XSLoader opens both the wrapper and the wrapped library. Therefore, there is no need for dlclose, dlerror, dlopen, dlsym

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 fcntl and seel are provided by Fcntl.

FIFO Interfaces

  mkfifo                          ::FileSystem
  mkfifoat     not supported
  mknodat      not supported

Example: use POSIX::1003::FileSystem 'mkfifo'; mkfifo($path, 0600) or die $!;

File Attribute Interfaces

Perl's chown and chmod 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 chmod are provided by Fcntl (and POSIX.pm)

Thread-Safe Stdio Locking Interfaces

Perl does support the non-portable flock (see "flock" in perlfunc) in core, but the POSIX flockfile mechanism is probably unsupported: flockfile, ftrylockfile, funlockfile, getc_unlocked, getchar_unlocked, putc_unlocked, putchar_unlocked

File System Interfaces

These functions work with filehandles: access filetest ::FileSystem chdir perlfunc closedir perlfunc IO::Dir/close fchdir perlfunc getcwd Cwd/getpwd 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 tmpfile File::Temp IO::File/new_tmpfile tmpnam (insecure!) File::Temp POSIX.pm unlink perlfunc utime perlfunc POSIX.pm (see warning!)

The symbolic constants needed to understand the result of stat are provided by Fcntl.

These work on file descriptors creat perlfunc/sysopen ::FdIO/creatfd fpathconf ::Pathconf fstat perlfunc/stat File::stat POSIX.pm

Working on filenames truncate perlfunc/truncate

Provided by Filesys::statvfs fstatvfs, statvfs

Warning: POSIX::utime($filename, $atime, $mtime); CORE::utime($atime, $mtime, @filenames);

File System Interfaces

  alphasort   perlfunc/sort
  getdelim    perlvar/$INPUT_RECORD_SEPARATOR
  getline     $a = <FH>           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

Internationalization Interfaces

  nl_langinfo                     I18N::Langinfo/langinfo

Access to message categories via Locale::Msgcat. This interface is far to simple to really translate messages into various languages. You may have a look at various implementations of gettext. catclose, catgets, catopen

An Object Oriented wrapper to the iconv interface is provided by Text::Iconv. Better have a look at the Encode first. iconv, iconv_close, iconv_open

Job Control Interfaces

  setpgid                         ::Proc
  tcgetpgrp                       ::Proc
  tcsetpgrp                       ::Proc
  tcgetsid    not supported

Examples: setpgid($pid, $pgid);

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

Multiple Concurrent Locale Interfaces

The functions newlocale, uselocale, duplocale, and freelocale are not supported. Neither are all of the functions which relate to is, all ending on _l, like isalnum_l().

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

Warning, 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();

Warning, different return value for POSIX.pm $slept = CORE::sleep(10); $early = POSIX::sleep(10); # $slept+$early=10

  $pid   = waitpid(-1, WNOHANG);

Networking Interfaces

handling sockets

Most code uses the Object Oriented approach via IO::Socket::INET. 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 IO::Socket::INET you will not need these. Otherwise, you should take a look at "pack" in perlfunc and unpack. htonl, htons, ntohl, ntohs inet_addr, inet_ntoa, inet_ntop, inet_pton

network configuration

Most network configuration functions are provided in CORE. There are also object wrappers in various Net:: 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

Pipe Interfaces

The pipe has an implementation in POSIX.pm, which uses file descriptors. The CORE version of pipe uses file handles.

  pipe        perlfunc            ::FdIO/pipefd

Warning, 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();

Realtime Signal Interfaces

  sigqueue                        Signal::More
  sigtimedwait                    Signal::More
  sigwaitinfo                     Signal::More

Regular Expression Interfaces

Perl's regular expressions are much more powerful. See perlre. regcomp, regerror, regexec, regfree

Semaphore Interfaces

POSIX semaphores are supported by POSIX::RT::Semaphore: sem_close, sem_destroy, sem_getvalue, sem_init, sem_open, sem_post, sem_timedwait, sem_trywait, sem_unlink, sem_wait,

Shell and Utilities Interfaces

  pclose       perlfunc/close
  popen        perlfunc/open ('|-' or '-|')  perlfunc/qx
  system       perlfunc
  wordexp      perlfunc/glob
  wordfree     never needed

Signal Interfaces

Signal handling is provided via POSIX::1003:SigAction and POSIX::SigSet. 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

Warning, parameter order in POSIX.pm CORE::kill($signal, $pid); ::Signals::kill($signal, $pid); POSIX::kill($pid, $signal);

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.

Symbolic Link Interfaces

  lchown                          ::FileSystem
  lstat       perlfunc
  readlinkat  not supported
  readlink    perlfunc
  symlinkat   not supported
  symlink     perlfunc

Warning, POSIX.pm accepts only one filename CORE::chown($uid, $gid, @filename); ::FileSystem::lchown($uid, $gid, @symlinks); POSIX::lchown($uid, $gid, $symlink); # !!!

System Database Interfaces

  getgrgid    perlfunc            User::grent
  getgrnam    perlfunc            User::grent
  getpwnam    perlfunc            User::pwent
  getpwuid    perlfunc            User::pwent

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

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

Warning: The special variables for user- and group-ids try to be smart: they are implemented using getreuid and/or friends. POSIX.pm provides setuid and setgid 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 not use any of these, but UNIX::SavedIDs instead!

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

Process CPU-Time Clocks Interfaces

Probably unsupported: clock_getcpuclockid POSIX::RT::Clock/get_cpuclock

File Synchronization Interfaces

  fsync                           IO::Handle/sync File::Sync

Memory Locking Interfaces

  mlockall                        IO::AIO
  munlockall                      IO::AIO
  mlock                           IO::AIO
  munlock                         IO::AIO

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

Shared Memory Objects Interfaces

  shm_open                        POSIX::RT:SharedMem
  shm_unlink                      POSIX::RT:SharedMem

Synchronized Input and Output Interfaces

  fdatasync                       IO::AIO/aio_fdatasync
  msync                           IO::AIO/aio_msync

Trace Event Filter Interfaces

No tracing support on POSIX level via posix_trace. There are various ways to debug Perl, however. For instance try perl -s script.pl

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 not needed 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 Tree or Tree::Binary, because these are missing: tdelete, tfind, tsearch, twalk

XSI Database Management Interfaces

Some simple database which probably no-one uses anymore. See DBI, for instance DBI::DBM. dbm_clearerr, dbm_close, dbm_delete, dbm_error, dbm_fetch, dbm_firstkey, dbm_nextkey, dbm_open, dbm_store

XSI Device Input and Output Interfaces

  fmtmsg                          Sys::Syslog

Probably not supported: grantpt, posix_openpt, ptsname, readv, unlockpt, write

XSI File System Interfaces

  basename                        File::Basename
  dirname                         File::Basename
  ftw                             File::Find/find
  lockf                           File::lockf
  mknod                           Mknod UNIX::Mknod Sys::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

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

XSI Jump Interfaces

No _longjmp nor _setjmp.

XSI Maths Library Interfaces

No j0, j1, jn, y0, y1, yn

XSI Multiple Process Interfaces

  getpriority  perlfunc           BSD::Resource
  getrlimit                       BSD::Resource
  getrusage                       BSD::Resource
  nice                            ::Proc
  setpgrp      perlfunc
  setpriority  perlfunc           BSD::Resource
  setrlimit                       BSD::Resource
  ulimit       not supported

XSI Signal Interfaces

The XSI signal interface is not supported, so no killpg, sigaltstack, sighold, sigignore, siginterrupt, sigpause, sigrelse, sigset

XSI Single Process Interfaces

  gethostid    not supported
  gettimeofday                    Time::HiRes
  putenv       perlvar/%ENV

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.

XSI Timer Interfaces

  getitimer                       Time::HiRes
  setitimer                       Time::HiRes

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

XSI STREAMS Interfaces

  ioctl        perlfunc

Streams are not supported. So no: fattach, fdetach, getmsg, getpmsg, isastream, putmsg, putpmsg

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 perlthrtut on the thread implementation of Perl.

• functions beginning with posix_ are not supported

• functions beginning with sched_ are not supported

• functions beginning with pthread_ are not supported

• thread-safe functions, ending on _r, are not supported

CONSTANTS

POSIX also defines zillions of constants. They are listed in (and available via) the POSIX::1003 modules. The _POSIX_ constants can be read via POSIX::1003::Properties.

SEE ALSO

This module is part of POSIX-1003 distribution version 0.02, built on December 19, 2011. Website: http://perl.overmeer.net. The code is based on POSIX, which is released with Perl itself.

COPYRIGHTS

Copyrights of the perl code and the related documentation by 2011 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 http://www.perl.com/perl/misc/Artistic.html

cpanm POSIX::1003

perl -MCPAN -e shell
install POSIX::1003