++ed by:
2 non-PAUSE users
Author image Mark Overmeer
and 1 contributors


POSIX::1003 - POSIX 1003.1-2008 provisioning


  use POSIX::1003           qw(:termios :pc PATH_MAX);
  # is short for all of these:
  use POSIX::1003::Termios  qw(:all);
  use POSIX::1003::Pathconf qw(:all);
  use POSIX::1003::FS       qw(PATH_MAX);

  # full modules, subsets, constants, functions
  use POSIX::1003           qw(:pathconf :stat R_OK, cos);

  # overview about all exported symbols (by a module)
  show_posix_names 'POSIX::1003::Pathconf';
  show_posix_names ':pc';
  perl -MPOSIX::1003 'show_posix_names'


The POSIX::1003 suite provides access to b<many> POSIX functions. The POSIX module in core (distributed with Perl itself) is ancient, the documentation is usually wrong, and it has too much unusable code in it. POSIX::1003 tries to provide cleaner access to the operating system. More about the choices made can be found in section "Rationale".


The official POSIX standard is large, with over 1200 functions; POSIX::Overview does list them all. This collection of POSIX::1003 extension provides access to quite a number of those functions, when they are not provided by "core". They also define as many system constants as possible. More functions may get added in the future.

Start looking in POSIX::Overview, to discover which module provides certain functionality. You may also guess the location from the module names listed in "DETAILS", below.

Bulk loading

It can be quite some work to work-out which modules define what symbols and then write down all the explicit require lines. Using bulk loading via this POSIX::1003 will be slower during the import (because it needs to load the location of each of the hundreds of symbols into memory), but provides convenience: it loads the right modules automagically.


This module uses nasty export tricks, so is not based in Exporter. Some modules have more than one tag related to them, and one tag may load multiple modules. When you do not specify symbol or tag, then all are loaded into your namespace(!), the same behavior as POSIX has.

If your import list starts with +1, the symbols will not get into your own namespace, but that of your caller. Just like $Exporter::ExportLevel (but a simpler syntax).

  use POSIX::1003 ':pathconf';
  use POSIX::1003 ':pc';       # same, abbreviated name
  use POSIX::1003 ':stat';     # subset from :filesystem

  use POSIX::1003 qw(PATH_MAX :math sin);

  sub MyModule::import(@)      # your own tricky exporter
  {   POSIX::1003->import('+1', @_);

EXPORT_TAGS including whole modules

  (export tag)          (module)
  :all                  <all symbols, default>
  :cs      :confstr     POSIX::1003::Confstr
  :errno   :errors      POSIX::1003::Errno
  :ev      :events      POSIX::1003::Events
           :fcntl       POSIX::1003::Fcntl
  :fd      :fdio        POSIX::1003::FdIO
  :fs      :filesystem  POSIX::1003::FS
  :limit   :limits      POSIX::1003::Limit
  :locale               POSIX::1003::Locale
  :math                 POSIX::1003::Math
  :none                 (nothing)
  :os      :opsys       POSIX::1003::OS
  :pc      :pathconf    POSIX::1003::Pathconf
  :proc    :processes   POSIX::1003::Proc
  :props   :properties  POSIX::1003::Properties
  :posix   :property    POSIX::1003::Properties
  :sc      :sysconf     POSIX::1003::Sysconf
  :signals              POSIX::1003::Signals
  :signals :sigaction   POSIX::SigAction
  :signals :sigset      POSIX::SigSet
  :socket               POSIX::1003::Socket
  :termio  :termios     POSIX::1003::Termios
  :time                 POSIX::1003::Time
  :user                 POSIX::1003::User

EXPORT_TAGS including subsets

[0.96] Besides loading all the symbols of a module, you can also include a subset for some of the modules

   (module)       (export tags for subsets)
   :fcntl         :flock   :lockf
   :fdio          :mode    :seek
   :filesystem    :access  :stat    :glob
   :limits        :rlimit  :ulimit
   :signals       :status  :signals
   :termios       :flush   :flags   :speed
   :socket        :sock    :sol     :so     :af    :pf



Returns the names of all modules in the current release of POSIX::1003.

posix_1003_names( [$modules|$tags] )

Returns all the names, when in LIST content. In SCALAR context, it returns (a reference to) an HASH which contains exported names to modules mappings. If no explicit $modules are specified, then all available modules are taken.

show_posix_names( [$modules|$tags] )

Print all names defined by the POSIX::1003 suite in alphabetical (case-insensitive) order. If no explicit $modules are specified, then all available modules are taken.


Modules in this distribution


Provide access to the _CS_* constants.


Provide access to the E* constants, for error numbers, and strerror().


Provides unbuffered IO handling; based on file-descriptors.


Some generic file-system information. See also POSIX::1003::Pathconf for more precise info.


Locales, see also perllocale.


Standard math functions of unknown precission.


A few ways to get Operating system information. See also POSIX::1003::Sysconf, POSIX::1003::Confstr, and POSIX::1003::Properties,


Provide access to the pathconf() and its trillion _PC_* constants.


Provide access to the _POSIX_* constants.


With helper modules POSIX::SigSet and POSIX::SigAction.


Provide access to many socket related constants.


Provide access to the sysconf and its zillion _SC_* constants.


Terminal IO


Time-stamp processing


Change active user and group.


For getting and setting resource limits.

Other modules


Provides an OO interface around getpw*()


Provides an OO interface around getgr*()


The POSIX module as distributed with Perl itself is ancient (it dates before Perl5) Although it proclaims that it provides access to all POSIX functions, it only lists about 200 out of 1200. From that subset, half of the functions will croak when you use them, complaining that they cannot get implemented in Perl for some reason.

Many other functions provided by POSIX-in-Core simply forward the caller to a function with the same name which is in basic perl (see perldoc). With a few serious complications: the functions in POSIX do not use prototypes, sometimes expect different arguments and sometimes return different values.

Back to the basics: the POSIX::1003 provides access to the POSIX libraries where they can be made compatible with Perl's way of doing things. For instance, setuid of POSIX is implemented with $), whose exact behavior depends on compile-flags and OS: it's not the pure setuid() of the standard hence left-out. There is no isalpha() either: not compatible with Perl strings and implemented very different interface from POSIX. And there is also no own exit(), because we have a CORE::exit() with the same functionality.

POSIX::1003 compared to POSIX.pm

This distribution uses POSIX.xs (which is always available and ported to all platforms) where it can, but adds much, much more.

When you are used to POSIX.pm but want to move to POSIX::1003, you must be aware about the following differences:

  • the constants and functions are spread over many separate modules, based on their purpose, where POSIX uses a header filename as tag to group provided functionality.

  • functions provided by CORE are usually not exported again by POSIX::1003 (unless to avoid confusion, for instance: is atan2() in core or ::Math?) Importing those is therefore a silent no-op.

  • constants which are already provided via Fcntl or Errno are not provided by this module as well. This should reduce the chance for confusion.

  • functions which are also in CORE can be imported, but will silently be ignored. In POSIX, functions with the same name get exported without prototype, which does have consequences for interpretation of your program. This module uses prototypes on all exported functions, like CORE does.

  • hundreds of E*, _SC_*, _CS_*, _PC_*, _POSIX_*, UL_*, and RLIMIT_* constants were collected from various sources, not just a minimal subset. You get access to all defined on your system.

  • when an user program addresses a constant which is not defined by the system, POSIX will croak. Modules in POSIX::1003 on the other hand, will return undef.

    This simplifies code like this:

      use POSIX::1003::FS         'PATH_MAX';
      use POSIX::1003::PathConfig '_PC_PATH_MAX';
      my $max_fn = _PC_PATH_MAX($fn) // PATH_MAX // 1024;

    With the tranditional POSIX, you have to eval() each use of a constant.


This module is part of POSIX-1003 distribution version 1.02, built on November 10, 2020. Website: http://perl.overmeer.net/CPAN. The code is based on POSIX, which is released with Perl itself. See also POSIX::Util for additional functionality.


Copyrights 2011-2020 on the perl code and the related documentation 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://dev.perl.org/licenses/