POSIX - Perl interface to IEEE Std 1003.1
use POSIX; use POSIX qw(setsid); use POSIX qw(:errno_h :fcntl_h); printf "EINTR is %d\n", EINTR; $sess_id = POSIX::setsid(); $fd = POSIX::open($path, O_CREAT|O_EXCL|O_WRONLY, 0644); # note: that's a filedescriptor, *NOT* a filehandle
The POSIX module permits you to access all (or nearly all) the standard POSIX 1003.1 identifiers. Many of these identifiers have been given Perl-ish interfaces. Things which are #defines in C, like EINTR or O_NDELAY, are automatically exported into your namespace. All functions are only exported if you ask for them explicitly. Most likely people will prefer to use the fully-qualified function names.
#defines
This document gives a condensed list of the features available in the POSIX module. Consult your operating system's manpages for general information on most features. Consult perlfunc for functions which are noted as being identical to Perl's builtin functions.
The first section describes POSIX functions from the 1003.1 specification. The second section describes some classes for signal objects, TTY objects, and other miscellaneous objects. The remaining sections list various constants and macros in an organization which roughly follows IEEE Std 1003.1b-1993.
The POSIX module is probably the most complex Perl module supplied with the standard distribution. It incorporates autoloading, namespace games, and dynamic loading of code that's in Perl, C, or both. It's a great source of wisdom.
A few functions are not implemented because they are C specific. If you attempt to call these, they will print a message telling you that they aren't implemented, and suggest using the Perl equivalent should one exist. For example, trying to access the setjmp() call will elicit the message "setjmp() is C-specific: use eval {} instead".
Furthermore, some evil vendors will claim 1003.1 compliance, but in fact are not so: they will not pass the PCTS (POSIX Compliance Test Suites). For example, one vendor may not define EDEADLK, or the semantics of the errno values set by open(2) might not be quite right. Perl does not attempt to verify POSIX compliance. That means you can currently successfully say "use POSIX", and then later in your program you find that your vendor has been lax and there's no usable ICANON macro after all. This could be construed to be a bug.
EOQ
use strict;
my $constants = {}; my $macros = {}; my $packages = []; my $posixpack = Package->new( 'POSIX' ); my $descriptions = Description->new;
get_constants( 'XS', $constants, $macros ); get_functions( 'XS', $packages, $posixpack ); get_PMfunctions( 'PM', $packages, $posixpack, $descriptions );
# It is possible that the matches of setup_*() may depend on # the matches of an earlier setup_*(). If you change the order, # be careful that you're getting only what you want, and no more. # my $termios_flags = setup_termios( $constants ); my $wait_stuff = setup_wait( $constants, $macros ); my $stat = setup_file_char( $constants, $macros ); my $port = setup_pat( $constants, '^_POSIX' ); my $sc = setup_pat( $constants, '^_SC_' ); my $pc = setup_pat( $constants, '^_PC_' ); my $fcntl = setup_pat( $constants, '^([FO]_|FD_)' ); my $sigs = setup_pat( $constants, '^(SIG|SA_)' ); my $float = setup_pat( $constants, '^(L?DBL_|FLT_)' ); my $locale = setup_pat( $constants, '^LC_' ); my $stdio = setup_pat( $constants, '(^BUFSIZ$)|(^L_)|(^_IO...$)|(^EOF$)|(^FILENAME_MAX$)|(^TMP_MAX$)' ); my $stdlib = setup_pat( $constants, '(^EXIT_)|(^MB_CUR_MAX$)|(^RAND_MAX$)' ); my $limits = setup_pat( $constants, '(_MAX$)|(_MIN$)|(_BIT$)|(^MAX_)|(_BUF$)' ); my $math = setup_pat( $constants, '^HUGE_VAL$' ); my $time = setup_pat( $constants, '^CL' ); my $unistd = setup_pat( $constants, '(_FILENO$)|(^SEEK_...$)|(^._OK$)' ); my $errno = setup_pat( $constants, '^E' );
print_posix( $posixpack, $descriptions ); print_classes( $packages, $constants, $termios_flags, $descriptions ); print_misc( 'Pathname Constants', $pc ); print_misc( 'POSIX Constants', $port ); print_misc( 'System Configuration', $sc ); print_misc( 'Errno', $errno ); print_misc( 'Fcntl', $fcntl ); print_misc( 'Float', $float ); print_misc( 'Limits', $limits ); print_misc( 'Locale', $locale ); print_misc( 'Math', $math ); print_misc( 'Signal', $sigs ); print_misc( 'Stat', $stat ); print_misc( 'Stdlib', $stdlib ); print_misc( 'Stdio', $stdio ); print_misc( 'Time', $time ); print_misc( 'Unistd', $unistd ); print_misc( 'Wait', $wait_stuff );
print_vers( $VERS );
dregs( $macros, $constants );
exit(0);
Unimplemented.
sub dregs { my $macros = shift; my $constants = shift;
foreach (keys %$macros){ warn "Unknown macro $_ in the POSIX.xs module.\n"; } foreach (keys %$constants){ warn "Unknown constant $_ in the POSIX.xs module.\n"; } }
sub get_constants { no strict 'refs'; my $fh = shift; my $constants = shift; my $macros = shift; my $v;
while(<$fh>){ last if /^constant/; } while(<$fh>){ # }{{ last if /^}/; if( /return\s+([^;]+)/ ){ $v = $1; # skip non-symbols if( $v !~ /^\d+$/ ){ # remove any C casts $v =~ s,\(.*?\)\s*(\w),$1,; # is it a macro? if( $v =~ s/(\(.*?\))// ){ $macros->{$v} = $1; } else{ $constants->{$v} = 1; } } } } }
Close the file. This uses file descriptors such as those obtained by calling POSIX::open.
POSIX::open
$fd = POSIX::open( "foo", &POSIX::O_RDONLY ); POSIX::close( $fd );
sub get_functions { no strict 'refs'; my $fh = shift; my $packages = shift; my $posixpack = shift; my $header = 0; my $pack = ''; my $prefix = ''; my( $x, $y ); my( $curfuncs, $curpack ); my $ret;
while(<$fh>){ if( /^MODULE.*?PACKAGE\s*=\s*([^\s]+)/ ){ $pack = $1; $prefix = ''; if( /PREFIX\s*=\s*([^\n]+)/ ){ $prefix = $1; } #print "package($pack) prefix($prefix)\n"; if( $pack eq 'POSIX' ){ $curpack = $posixpack; } else{ $curpack = Package->new( $pack ); push @$packages, $curpack; } $curfuncs = $curpack->curfuncs; next; } chop; # find function header if( /^[^\s]/ && ! /^#/ ){ $ret = /^SysRet/ ? 2 : 1; chop($x = <$fh>); next if( $pack eq 'POSIX' and $x =~ /^constant/ ); $x =~ /^(.*?)\s*\((.*?)\)/; ($x,$y) = ($1, $2); # func,sig $x =~ s/^$prefix//; $curfuncs->{$x} = $ret; ++$header } # leave function header else{ $header = 0; } } }
sub get_PMfunctions { no strict 'refs'; my $fh = shift; my $packages = shift; my $posixpack = shift; my $desc = shift; my $pack = ''; my( $curfuncs, $curpack ); my $y; my $x; my $sub = '';
# find the second package statement. while(<$fh>){ if( /^package\s+(.*?);/ ){ $pack = $1; last if $pack ne 'POSIX'; } } # Check if this package is already # being used. $curpack = ''; foreach (@$packages){ if( $_->name eq $pack ){ $curpack = $_; last; } } # maybe start a new package. if( $curpack eq '' ){ $curpack = Package->new( $pack ); push @$packages, $curpack; } $curfuncs = $curpack->curfuncs; # now fetch functions while(<$fh>){ if( /^package\s+(.*?);/ ){ $pack = $1; if( $pack eq 'POSIX' ){ $curpack = $posixpack; } else{ # Check if this package is already # being used. $curpack = ''; foreach (@$packages){ if( $_->name() eq $pack ){ $curpack = $_; last; } } # maybe start a new package. if( $curpack eq '' ){ $curpack = Package->new( $pack ); push @$packages, $curpack; } } $curfuncs = $curpack->curfuncs; next; } if( /^sub\s+(.*?)\s/ ){ $sub = $1; # special cases if( $pack eq 'POSIX::SigAction' and $sub eq 'new' ){ $curfuncs->{$sub} = 1; } elsif( $pack eq 'POSIX' and $sub eq 'perror' ){ $curfuncs->{$sub} = 1; } next; } if( /usage.*?\((.*?)\)/ ){ $y = $1; $curfuncs->{$sub} = 1; next; } if( /^\s+unimpl\s+"(.*?)"/ ){ $y = $1; $y =~ s/, stopped//; $desc->append( $pack, $sub, $y ); $curfuncs->{$sub} = 1; next; } if( /^\s+redef\s+"(.*?)"/ ){ $x = $1; $y = "Use method C<$x> instead"; $desc->append( $pack, $sub, $y ); $curfuncs->{$sub} = 1; next; } } }
Retrieves the value of a configurable limit on a file or directory. This uses file descriptors such as those obtained by calling POSIX::open.
The following will determine the maximum length of the longest allowable pathname on the filesystem which holds /tmp/foo.
/tmp/foo
$fd = POSIX::open( "/tmp/foo", &POSIX::O_RDONLY ); $path_max = POSIX::fpathconf( $fd, &POSIX::_PC_PATH_MAX ); Return the mantissa and exponent of a floating-point number. ($mantissa, $exponent) = POSIX::frexp( 3.14 ); Get file status. This uses file descriptors such as those obtained by calling C<POSIX::open>. The data returned is identical to the data from Perl's builtin C<stat> function. $fd = POSIX::open( "foo", &POSIX::O_RDONLY ); @stats = POSIX::fstat( $fd );
sub print_posix { my $pack = shift; my $desc = shift;
print "=head1 FUNCTIONS\n\n"; print "=over 8\n\n"; dumpfuncs( $pack, $desc ); print "=back\n\n"; }
sub print_classes { my $packages = shift; my $constants = shift; my $termios = shift; my $desc = shift; my $pack; my @pkgs;
print "=head1 CLASSES\n\n"; @pkgs = sort { $main::a->name() cmp $main::b->name() } @$packages; while( @pkgs ){ $pack = shift @pkgs; print "=head2 ", $pack->name(), "\n\n"; print "=over 8\n\n"; dumpfuncs( $pack, $desc ); if( $pack->name() =~ /termios/i ){ dumpflags( $termios ); } print "=back\n\n"; } }
sub setup_termios { my $constants = shift; my $obj;
$obj = { 'c_iflag field' => [qw( BRKINT ICRNL IGNBRK IGNCR IGNPAR INLCR INPCK ISTRIP IXOFF IXON PARMRK )], 'c_oflag field' => [qw( OPOST )], 'c_cflag field' => [qw( CLOCAL CREAD CSIZE CS5 CS6 CS7 CS8 CSTOPB HUPCL PARENB PARODD )], 'c_lflag field' => [qw( ECHO ECHOE ECHOK ECHONL ICANON IEXTEN ISIG NOFLSH TOSTOP )], 'c_cc field' => [qw( VEOF VEOL VERASE VINTR VKILL VQUIT VSUSP VSTART VSTOP VMIN VTIME NCCS )], 'Baud rate' => [], 'Terminal interface' => [], }; # look for baud rates in constants, add to termios foreach (keys %$constants){ if( /^B\d+$/ ){ push @{$obj->{'Baud rate'}}, $_; } } # look for TC* in constants, add to termios foreach (keys %$constants){ if( /^TC/ ){ push @{$obj->{'Terminal interface'}}, $_; } } # trim the constants foreach (keys %$obj){ trim_hash( 'Constant', $obj->{$_}, $constants ); } return $obj; }
sub dumpfuncs { my $pack = shift; my $desc = shift; my $curfuncs = $pack->curfuncs; my $pname = $pack->name; my $func; my @funcs = sort keys %$curfuncs;
if( exists $curfuncs->{'new'} ){ # do new first @funcs = grep( $_ ne 'new', @funcs ); unshift @funcs, 'new'; } while( @funcs ){ $func = shift @funcs; if( $func eq 'DESTROY' ){ next; # don't do DESTROY } print "=item $func\n\n"; if( $desc->print( $pname, $func, $curfuncs->{$func} ) ){ # if it was printed, note that delete $curfuncs->{$func}; } } }
sub dumpflags { my $flags = shift; my $field;
foreach $field (sort keys %$flags){ print "=item $field values\n\n"; print join( ' ', @{$flags->{$field}} ), "\n\n"; } }
sub setup_wait { my $constants = shift; my $macros = shift; my $obj;
$obj = { 'Macros' => [qw( WIFEXITED WEXITSTATUS WIFSIGNALED WTERMSIG WIFSTOPPED WSTOPSIG )], 'Constants' => [qw( WNOHANG WUNTRACED )], }; trim_hash( 'Constant', $obj->{Constants}, $constants ); trim_hash( 'Macro', $obj->{Macros}, $macros ); return $obj; }
sub setup_file_char { my $constants = shift; my $macros = shift; my $obj;
$obj = { 'Macros' => [], 'Constants' => [], }; # find S_* constants and add to object. foreach (sort keys %$constants){ if( /^S_/ ){ push @{$obj->{'Constants'}}, $_; } } # find S_* macros and add to object. foreach (sort keys %$macros){ if( /^S_/ ){ push @{$obj->{'Macros'}}, $_; } } # trim the hashes trim_hash( 'Constant', $obj->{Constants}, $constants ); trim_hash( 'Macro', $obj->{Macros}, $macros ); return $obj; }
sub setup_pat { my $constants = shift; my $pat = shift; my $obj;
$obj = { 'Constants' => [] }; foreach (sort keys %$constants){ if( /$pat/ ){ push @{$obj->{'Constants'}}, $_; } } trim_hash( 'Constant', $obj->{Constants}, $constants ); return $obj; }
Get numeric formatting information. Returns a reference to a hash containing the current locale formatting values.
The database for the de (Deutsch or German) locale.
$loc = POSIX::setlocale( &POSIX::LC_ALL, "de" ); print "Locale = $loc\n"; $lconv = POSIX::localeconv(); print "decimal_point = ", $lconv->{decimal_point}, "\n"; print "thousands_sep = ", $lconv->{thousands_sep}, "\n"; print "grouping = ", $lconv->{grouping}, "\n"; print "int_curr_symbol = ", $lconv->{int_curr_symbol}, "\n"; print "currency_symbol = ", $lconv->{currency_symbol}, "\n"; print "mon_decimal_point = ", $lconv->{mon_decimal_point}, "\n"; print "mon_thousands_sep = ", $lconv->{mon_thousands_sep}, "\n"; print "mon_grouping = ", $lconv->{mon_grouping}, "\n"; print "positive_sign = ", $lconv->{positive_sign}, "\n"; print "negative_sign = ", $lconv->{negative_sign}, "\n"; print "int_frac_digits = ", $lconv->{int_frac_digits}, "\n"; print "frac_digits = ", $lconv->{frac_digits}, "\n"; print "p_cs_precedes = ", $lconv->{p_cs_precedes}, "\n"; print "p_sep_by_space = ", $lconv->{p_sep_by_space}, "\n"; print "n_cs_precedes = ", $lconv->{n_cs_precedes}, "\n"; print "n_sep_by_space = ", $lconv->{n_sep_by_space}, "\n"; print "p_sign_posn = ", $lconv->{p_sign_posn}, "\n"; print "n_sign_posn = ", $lconv->{n_sign_posn}, "\n"; Move the read/write file pointer. This uses file descriptors such as those obtained by calling C<POSIX::open>. $fd = POSIX::open( "foo", &POSIX::O_RDONLY ); $off_t = POSIX::lseek( $fd, 0, &POSIX::SEEK_SET );
sub print_vers { my $vers = shift;
print "=head1 CREATION\n\n"; print "This document generated by $0 version $vers.\n\n"; }
sub print_misc { my $hdr = shift; my $obj = shift; my $item;
print "=head1 ", uc($hdr), "\n\n"; print "=over 8\n\n"; foreach $item (sort keys %$obj){ print "=item $item\n\n"; print join( ' ', @{$obj->{$item}}), "\n\n"; } print "=back\n\n"; }
sub trim_hash { my $name = shift; my $av = shift; my $hv = shift;
foreach (@$av){ if( exists $hv->{$_} ){ delete $hv->{$_}; } else{ warn "$name $_ is not in the POSIX.xs module"; } } }
{ package Package; ## Package package
sub new { my $type = shift; my $pack = shift || die; my $self = [ $pack, {} ]; bless $self, $type; } sub name { my $self = shift; $self->[0]; } sub curfuncs { my $self = shift; $self->[1]; } sub DESTROY { my $self = shift; my $pack = $self->name; foreach (keys %{$self->curfuncs}){ if( $_ eq 'DESTROY' ){ next; # don't expect much on DESTROY } warn "Function ". $pack . "::$_ did not have a description.\n"; } } } { package Description; ## Function description sub new { my $type = shift; my $self = {}; bless $self, $type; $self->fetch; return $self; } sub fetch { my $self = shift; my $pack = ''; my $c; my( $sub, $as ); while(<main::DATA>){ next if /^#/; $sub = $as = ''; if( /^==(.*)/ ){ $pack = $1; next; } if( /^=([^\+]+)\+\+/ ){ $sub = $1; $as = $sub; } elsif( /^=([^\+]+)\+C/ ){ $sub = $1; $as = 'C'; } elsif( /^=([^\+]+)\+(\w+)/ ){ $sub = $1; $as = $2; } elsif( /^=(.*)/ ){ $sub = $1; } if( $sub ne '' ){ $sub = $1; $self->{$pack."::$sub"} = ''; $c = \($self->{$pack."::$sub"}); if( $as eq 'C' ){ $$c .= "This is identical to the C function C<$sub()>.\n"; } elsif( $as ne '' ){ $$c .= "This is identical to Perl's builtin C<$as()> function.\n"; } next; } $$c .= $_; } } sub DESTROY { my $self = shift; foreach (keys %$self){ warn "Function $_ is not in the POSIX.xs module.\n"; } } sub append { my $self = shift; my $pack = shift; my $sub = shift; my $str = shift || die; if( exists $self->{$pack."::$sub"} ){ $self->{$pack."::$sub"} .= "\n$str.\n"; } else{ $self->{$pack."::$sub"} = "$str.\n"; } } sub print { my $self = shift; my $pack = shift; my $sub = shift; my $rtype = shift || die; my $ret = 0; if( exists $self->{$pack."::$sub"} ){ if( $rtype > 1 ){ $self->{$pack."::$sub"} =~ s/identical/similar/; } print $self->{$pack."::$sub"}, "\n"; delete $self->{$pack."::$sub"}; if( $rtype > 1 ){ print "Returns C<undef> on failure.\n\n"; } $ret = 1; } $ret; } }
Create an interprocess channel. This returns file descriptors like those returned by POSIX::open.
($fd0, $fd1) = POSIX::pipe(); POSIX::write( $fd0, "hello", 5 ); POSIX::read( $fd1, $buf, 5 ); Read from a file. This uses file descriptors such as those obtained by calling C<POSIX::open>. If the buffer C<$buf> is not large enough for the read then Perl will extend it to make room for the request. $fd = POSIX::open( "foo", &POSIX::O_RDONLY ); $bytes = POSIX::read( $fd, $buf, 3 ); This is similar to the C function C<setpgid()>. Detailed signal management. This uses C<POSIX::SigAction> objects for the C<action> and C<oldaction> arguments. Consult your system's C<sigaction> manpage for details.
Synopsis:
sigaction(sig, action, oldaction = 0) Install a signal mask and suspend process until signal arrives. This uses C<POSIX::SigSet> objects for the C<signal_mask> argument. Consult your system's C<sigsuspend> manpage for details.
sigsuspend(signal_mask) This is identical to Perl's builtin C<sprintf()> function. Convert date and time information to string. Returns the string.
strftime(fmt, sec, min, hour, mday, mon, year, wday = 0, yday = 0, isdst = 0)
The month (mon), weekday (wday), and yearday (yday) begin at zero. I.e. January is 0, not 1; Sunday is 0, not 1; January 1st is 0, not 1. The year (year) is given in years since 1900. I.e. The year 1995 is 95; the year 2001 is 101. Consult your system's strftime() manpage for details about these and the other arguments.
mon
wday
yday
year
strftime()
The string for Tuesday, December 12, 1995.
$str = POSIX::strftime( "%A, %B %d, %Y", 0, 0, 0, 12, 11, 95, 2 ); print "$str\n"; String transformation. Returns the transformed string. $dst = POSIX::strxfrm( $src ); Get name of current operating system. ($sysname, $nodename, $release, $version, $machine ) = POSIX::uname(); Returns the current file position, in bytes. $pos = $fh->tell; Get terminal control attributes.
Obtain the attributes for stdin.
$termios->getattr()
Obtain the attributes for stdout.
$termios->getattr( 1 ) Set terminal control attributes.
Set attributes immediately for stdout.
$termios->setattr( 1, &POSIX::TCSANOW );
__END__ ########## ==POSIX::SigSet =new Create a new SigSet object. This object will be destroyed automatically when it is no longer needed. Arguments may be supplied to initialize the set.
Create an empty set.
$sigset = POSIX::SigSet->new;
Create a set with SIGUSR1.
$sigset = POSIX::SigSet->new( &POSIX::SIGUSR1 ); =addset Add a signal to a SigSet object. $sigset->addset( &POSIX::SIGUSR2 ); =delset Remove a signal from the SigSet object. $sigset->delset( &POSIX::SIGUSR2 ); =emptyset Initialize the SigSet object to be empty. $sigset->emptyset(); =fillset Initialize the SigSet object to include all signals. $sigset->fillset(); =ismember Tests the SigSet object to see if it contains a specific signal. if( $sigset->ismember( &POSIX::SIGUSR1 ) ){ print "contains SIGUSR1\n"; } ########## ==POSIX::Termios =new Create a new Termios object. This object will be destroyed automatically when it is no longer needed. $termios = POSIX::Termios->new; =getiflag Retrieve the c_iflag field of a termios object. $c_iflag = $termios->getiflag; =getoflag Retrieve the c_oflag field of a termios object. $c_oflag = $termios->getoflag; =getcflag Retrieve the c_cflag field of a termios object. $c_cflag = $termios->getcflag; =getlflag Retrieve the c_lflag field of a termios object. $c_lflag = $termios->getlflag; =getcc Retrieve a value from the c_cc field of a termios object. The c_cc field is an array so an index must be specified. $c_cc[1] = $termios->getcc(1); =getospeed Retrieve the output baud rate. $ospeed = $termios->getospeed; =getispeed Retrieve the input baud rate. $ispeed = $termios->getispeed; =setiflag Set the c_iflag field of a termios object. $termios->setiflag( &POSIX::BRKINT ); =setoflag Set the c_oflag field of a termios object. $termios->setoflag( &POSIX::OPOST ); =setcflag Set the c_cflag field of a termios object. $termios->setcflag( &POSIX::CLOCAL ); =setlflag Set the c_lflag field of a termios object. $termios->setlflag( &POSIX::ECHO ); =setcc Set a value in the c_cc field of a termios object. The c_cc field is an array so an index must be specified. $termios->setcc( 1, &POSIX::VEOF ); =setospeed Set the output baud rate. $termios->setospeed( &POSIX::B9600 ); =setispeed Set the input baud rate. $termios->setispeed( &POSIX::B9600 ); ## =setattr =getattr ########## ==FileHandle =new =new_from_fd =flush =getc =ungetc =seek =setbuf =error =clearerr =tell =getpos =gets =close =new_tmpfile =eof =fileno =setpos =setvbuf ########## ==POSIX =tolower+lc =toupper+uc =remove+unlink =fabs+abs =strstr+index ## =closedir++ =readdir++ =rewinddir++ =fcntl++ =getgrgid++ =getgrnam++ =atan2++ =cos++ =exp++ =abs++ =log++ =sin++ =sqrt++ =getpwnam++ =getpwuid++ =kill++ =getc++ =rename++ =exit++ =system++ =chmod++ =mkdir++ =stat++ =umask++ =gmtime++ =localtime++ =time++ =alarm++ =chdir++ =chown++ =fork++ =getlogin++ =getpgrp++ =getppid++ =link++ =rmdir++ =sleep++ =unlink++ =utime++ ## =perror+C =pause+C =tzset+C =difftime+C =ctime+C =clock+C =asctime+C =strcoll+C =abort+C =tcgetpgrp+C =setsid+C =_exit+C =tanh+C =tan+C =sinh+C =log10+C =ldexp+C =fmod+C =floor+C =cosh+C =ceil+C =atan+C =asin+C =acos+C ## =isatty Returns a boolean indicating whether the specified filehandle is connected to a tty. =setuid Sets the real user id for this process. =setgid Sets the real group id for this process. =getpid Returns the process's id. =getuid Returns the user's id. =getegid Returns the effective group id. =geteuid Returns the effective user id. =getgid Returns the user's real group id. =getgroups Returns the ids of the user's supplementary groups. =getcwd Returns the name of the current working directory. =strerror Returns the error string for the specified errno. =getenv Returns the value of the specified enironment variable. =getchar Returns one character from STDIN. =raise Sends the specified signal to the current process. =gets Returns one line from STDIN. =printf Prints the specified arguments to STDOUT. =rewind Seeks to the beginning of the file. ## =tmpnam Returns a name for a temporary file. $tmpfile = POSIX::tmpnam(); =cuserid Get the character login name of the user. $name = POSIX::cuserid(); =ctermid Generates the path name for controlling terminal. $path = POSIX::ctermid(); =times The times() function returns elapsed realtime since some point in the past (such as system startup), user and system times for this process, and user and system times used by child processes. All times are returned in clock ticks. ($realtime, $user, $system, $cuser, $csystem) = POSIX::times();
Note: Perl's builtin times() function returns four values, measured in seconds. =pow Computes $x raised to the power $exponent.
times()
$ret = POSIX::pow( $x, $exponent ); =errno Returns the value of errno. $errno = POSIX::errno(); =sysconf Retrieves values of system configurable variables.
The following will get the machine's clock speed.
$clock_ticks = POSIX::sysconf( &POSIX::_SC_CLK_TCK ); =pathconf Retrieves the value of a configurable limit on a file or directory.
The following will determine the maximum length of the longest allowable pathname on the filesystem which holds /tmp.
/tmp
$path_max = POSIX::pathconf( "/tmp", &POSIX::_PC_PATH_MAX ); =access Determines the accessibility of a file. if( POSIX::access( "/", &POSIX::R_OK ) ){ print "have read permission\n"; } =setlocale Modifies and queries program's locale.
The following will set the traditional UNIX system locale behavior.
This document generated by ./mkposixman.PL version 19951212. ## =waitpid =wait =fstat =sprintf =opendir =creat =ttyname =tzname =fpathconf =mktime =tcsendbreak =tcflush =tcflow =tcdrain =tcsetpgrp =mkfifo =strxfrm =wctomb =wcstombs =mbtowc =mbstowcs =mblen =write =uname =setpgid =read =pipe =nice =lseek =dup2 =dup =close =sigsuspend =sigprocmask =sigpending =sigaction =modf =frexp =localeconv =open =isxdigit =isupper =isspace =ispunct =isprint =isgraph =isdigit =iscntrl =isalpha =isalnum =islower =assert =strftime ########## ==POSIX::SigAction =new Creates a new SigAction object. This object will be destroyed automatically when it is no longer needed.
To install lib, copy and paste the appropriate command in to your terminal.
cpanm
cpanm lib
CPAN shell
perl -MCPAN -e shell install lib
For more information on module installation, please visit the detailed CPAN module installation guide.