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.
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.
_exit(). It exits the program
immediately which means among other things buffered I/O is not flushed.
abort(). It terminates the
process with a SIGABRT signal unless caught by a signal handler or
if the handler does not return normally (it e.g. does a longjmp).
abs() function, returning
the absolute value of its numerical argument.
Determines the accessibility of a file.
if( POSIX::access( "/", &POSIX::R_OK ) ){
print "have read permission\n";
}
Returns undef on failure. Note: do not use access() for
security purposes. Between the access() call and the operation
you are preparing for the permissions might change: a classic
race condition.
acos(), returning
the arcus cosine of its numerical argument. See also Math::Trig.
alarm() function,
either for arming or disarming the SIGARLM timer.
This is identical to the C function asctime(). It returns
a string of the form
"Fri Jun 2 18:22:13 2000\n\0"
and it is called thusly
$asctime = asctime($sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst);
The $mon is zero-based: January equals 0. The $year is
1900-based: 2001 equals 101. The $wday, $yday, and $isdst
default to zero (and the first two are usually ignored anyway).
asin(), returning
the arcus sine of its numerical argument. See also Math::Trig.
atan(), returning the
arcus tangent of its numerical argument. See also Math::Trig.
atan2() function, returning
the arcus tangent defined by its two numerical arguments, the y
coordinate and the x coordinate. See also Math::Trig.
END {} instead, see perlsub.
ceil(), returning the smallest
integer value greater than or equal to the given numerical argument.
chdir() function, allowing
one to change the working (default) directory, see perlfunc/chdir.
chmod() function, allowing
one to change file and directory permissions, see perlfunc/chmod.
chown() function, allowing one
to change file and directory owners and groups, see perlfunc/chown.
IO::Handle::clearerr() instead, to reset the error
state (if any) and EOF state (if any) of the given stream.
clock(), returning the
amount of spent processor time in microseconds.
Close the file. This uses file descriptors such as those obtained by calling
POSIX::open.
$fd = POSIX::open( "foo", &POSIX::O_RDONLY ); POSIX::close( $fd );
Returns undef on failure.
See also perlfunc/close.
closedir() function for closing
a directory handle, see perlfunc/closedir.
cos() function, for returning
the cosine of its numerical argument, see perlfunc/cos.
See also Math::Trig.
cosh(), for returning
the hyperbolic cosine of its numeric argument. See also Math::Trig.
Create a new file. This returns a file descriptor like the ones returned by
POSIX::open. Use POSIX::close to close the file.
$fd = POSIX::creat( "foo", 0611 ); POSIX::close( $fd );
See also perlfunc/sysopen and its O_CREAT flag.
Generates the path name for the controlling terminal.
$path = POSIX::ctermid();
ctime() and equivalent
to asctime(localtime(...)), see /asctime and /localtime.
Get the login name of the owner of the current process.
$name = POSIX::cuserid();
difftime(), for returning
the time difference (in seconds) between two times (as returned
by time()), see /time.
/ division and
the modulus %.
This is similar to the C function dup(), for duplicating a file
descriptor.
This uses file descriptors such as those obtained by calling
POSIX::open.
Returns undef on failure.
This is similar to the C function dup2(), for duplicating a file
descriptor to an another known file descriptor.
This uses file descriptors such as those obtained by calling
POSIX::open.
Returns undef on failure.
Returns the value of errno.
$errno = POSIX::errno();
This identical to the numerical values of the $!, see perlvar/$ERRNO.
exit() function for exiting the
program, see perlfunc/exit.
exp() function for
returning the exponent (e-based) of the numerical argument,
see perlfunc/exp.
abs() function for returning
the absolute value of the numerical argument, see perlfunc/abs.
IO::Handle::close() instead, or see perlfunc/close.
fcntl() function,
see perlfunc/fcntl.
IO::Handle::new_from_fd() instead, or see perlfunc/open.
IO::Handle::eof() instead, or see perlfunc/eof.
IO::Handle::error() instead.
IO::Handle::flush() instead.
See also perlvar/$OUTPUT_AUTOFLUSH.
IO::Handle::getc() instead, or see perlfunc/read.
IO::Seekable::getpos() instead, or see L/seek.
IO::Handle::gets() instead. Similar to <>, also known
as perlfunc/readline.
IO::Handle::fileno() instead, or see perlfunc/fileno.
floor(), returning the largest
integer value less than or equal to the numerical argument.
This is identical to the C function fmod().
$r = fmod($x, $y);
It returns the remainder $r = $x - $n*$y, where $n = trunc($x/$y).
The $r has the same sign as $x and magnitude (absolute value)
less than the magnitude of $y.
IO::File::open() instead, or see perlfunc/open.
fork() function
for duplicating the current process, see perlfunc/fork
and perlfork if you are in Windows.
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.
$fd = POSIX::open( "/tmp/foo", &POSIX::O_RDONLY ); $path_max = POSIX::fpathconf( $fd, &POSIX::_PC_PATH_MAX );
Returns undef on failure.
Return the mantissa and exponent of a floating-point number.
($mantissa, $exponent) = POSIX::frexp( 1.234e56 );
IO::Seekable::seek() instead, or see perlfunc/seek.
IO::Seekable::setpos() instead, or seek perlfunc/seek.
Get file status. This uses file descriptors such as those obtained by
calling POSIX::open. The data returned is identical to the data from
Perl's builtin stat function.
$fd = POSIX::open( "foo", &POSIX::O_RDONLY ); @stats = POSIX::fstat( $fd );
IO::Seekable::tell() instead, or see perlfunc/tell.
getc() function,
see perlfunc/getc.
getc(),
see perlfunc/getc.
$(, see perlvar/$EGID.
%ENV array.
$>
variable, see perlvar/$EUID.
$), see perlvar/$GID.
getgrgid() function for
returning group entries by group identifiers, see
perlfunc/getgrgid.
getgrnam() function for
returning group entries by group names, see perlfunc/getgrnam.
$), see perlvar/$GID.
getlogin() function for
returning the user name associated with the current session, see
perlfunc/getlogin.
getpgrp() function for
returning the prcess group identifier of the current process, see
perlfunc/getpgrp.
$$, see perlvar/$PID.
getppid() function for
returning the process identifier of the parent process of the current
process , see perlfunc/getppid.
getpwnam() function for
returning user entries by user names, see perlfunc/getpwnam.
getpwuid() function for
returning user entries by user identifiers, see perlfunc/getpwuid.
Returns one line from STDIN, similar to <>, also known
as the readline() function, see perlfunc/readline.
NOTE: if you have C programs that still use gets(), be very
afraid. The gets() function is a source of endless grief because
it has no buffer overrun checks. It should never be used. The
fgets() function should be preferred instead.
$< variable,
see perlvar/$UID.
gmtime() function for
converting seconds since the epoch to a date in Greenwich Mean Time,
see perlfunc/gmtime.
/[[:alnum:]]/ construct instead, or possibly the /\w/ construct.
/[[:alpha:]]/ construct instead.
-t operator, see perlfunc/-X.
/[[:cntrl:]]/ construct instead.
/[[:digit:]]/ construct instead, or the /\d/ construct.
/[[:graph:]]/ construct instead.
/[[:lower:]]/ construct instead. Do not use /[a-z]/.
/[[:print:]]/ construct instead.
/[[:punct:]]/ construct instead.
/[[:space:]]/ construct instead, or the /\s/ construct.
(Note that /\s/ and /[[:space:]]/ are slightly different in that
/[[:space:]]/ can normally match a vertical tab, while /\s/ does
not.)
/[[:upper:]]/ construct instead. Do not use /[A-Z]/.
/[[:xdigit:]]/ construct instead, or simply /[0-9a-f]/i.
kill() function for sending
signals to processes (often to terminate them), see perlfunc/kill.
This is identical to the C function ldexp()
for multiplying floating point numbers with powers of two.
$x_quadrupled = POSIX::ldexp($x, 2);
/ and int() instead.
link() function
for creating hard links into files, see perlfunc/link.
Get numeric formatting information. Returns a reference to a hash containing the current locale formatting values.
Here is how to query 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";
localtime() function for
converting seconds since the epoch to a date see perlfunc/localtime.
log() function,
returning the natural (e-based) logarithm of the numerical argument,
see perlfunc/log.
This is identical to the C function log10(),
returning the 10-base logarithm of the numerical argument.
You can also use
sub log10 { log($_[0]) / log(10) }
or
sub log10 { log($_[0]) / 2.30258509299405 }
or
sub log10 { log($_[0]) * 0.434294481903252 }
Move the file's read/write position. This uses file descriptors such as
those obtained by calling POSIX::open.
$fd = POSIX::open( "foo", &POSIX::O_RDONLY ); $off_t = POSIX::lseek( $fd, 0, &POSIX::SEEK_SET );
Returns undef on failure.
mblen().
Perl does not have any support for the wide and multibyte
characters of the C standards, so this might be a rather
useless function.
mbstowcs().
Perl does not have any support for the wide and multibyte
characters of the C standards, so this might be a rather
useless function.
mbtowc().
Perl does not have any support for the wide and multibyte
characters of the C standards, so this might be a rather
useless function.
eq instead, see perlop.
=, see perlop, or see perlfunc/substr.
=, see perlop, or see perlfunc/substr.
x instead, see perlop.
mkdir() function
for creating directories, see perlfunc/mkdir.
This is similar to the C function mkfifo() for creating
FIFO special files.
if (mkfifo($path, $mode)) { ....
Returns undef on failure. The $mode is similar to the
mode of mkdir(), see perlfunc/mkdir.
Convert date/time info to a calendar time.
Synopsis:
mktime(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 mktime() manpage for details
about these and the other arguments.
Calendar time for December 12, 1995, at 10:30 am.
$time_t = POSIX::mktime( 0, 30, 10, 12, 11, 95 ); print "Date = ", POSIX::ctime($time_t);
Returns undef on failure.
Return the integral and fractional parts of a floating-point number.
($fractional, $integral) = POSIX::modf( 3.14 );
This is similar to the C function nice(), for changing
the scheduling preference of the current process. Positive
arguments mean more polite process, negative values more
needy process. Normal user processes can only be more polite.
Returns undef on failure.
Open a file for reading for writing. This returns file descriptors, not
Perl filehandles. Use POSIX::close to close the file.
Open a file read-only with mode 0666.
$fd = POSIX::open( "foo" );
Open a file for read and write.
$fd = POSIX::open( "foo", &POSIX::O_RDWR );
Open a file for write, with truncation.
$fd = POSIX::open( "foo", &POSIX::O_WRONLY | &POSIX::O_TRUNC );
Create a new file with mode 0640. Set up the file for writing.
$fd = POSIX::open( "foo", &POSIX::O_CREAT | &POSIX::O_WRONLY, 0640 );
Returns undef on failure.
See also perlfunc/sysopen.
Open a directory for reading.
$dir = POSIX::opendir( "/tmp" ); @files = POSIX::readdir( $dir ); POSIX::closedir( $dir );
Returns undef on failure.
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.
$path_max = POSIX::pathconf( "/tmp", &POSIX::_PC_PATH_MAX );
Returns undef on failure.
This is similar to the C function pause(), which suspends
the execution of the current process until a signal is received.
Returns undef on failure.
perror(), which outputs to the
standard error stream the specified message followed by ": " and the
current error string. Use the warn() function and the $!
variable instead, see perlfunc/warn and perlvar/$ERRNO.
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 );
See also perlfunc/pipe.
Computes $x raised to the power $exponent.
$ret = POSIX::pow( $x, $exponent );
You can also use the ** operator, see perlop.
$$ in perlvar/$PID.
rand() is non-portable, see perlfunc/rand instead.
Read from a file. This uses file descriptors such as those obtained by
calling POSIX::open. If the buffer $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 );
Returns undef on failure.
See also perlfunc/sysread.
readdir() function
for reading directory entries, see perlfunc/readdir.
unlink() function
for removing files, see perlfunc/unlink.
rename() function
for renaming files, see perlfunc/rename.
rewinddir() function for
rewinding directory entry streams, see perlfunc/rewinddir.
rmdir() function
for removing (empty) directories, see perlfunc/rmdir.
$) variable, see perlvar/$GID, except that the latter
will change only the real user identifier, and that the setgid()
uses only a single numeric argument, as opposed to a space-separated
list of numbers.
setjmp() is C-specific: use eval {} instead,
see perlfunc/eval.
Modifies and queries program's locale. The following examples assume
use POSIX qw(setlocale LC_ALL LC_CTYPE);
has been issued.
The following will set the traditional UNIX system locale behavior
(the second argument "C").
$loc = setlocale( LC_ALL, "C" );
The following will query the current LC_CTYPE category. (No second argument means 'query'.)
$loc = setlocale( LC_CTYPE );
The following will set the LC_CTYPE behaviour according to the locale
environment variables (the second argument "").
Please see your systems setlocale(3) documentation for the locale
environment variables' meaning or consult perllocale.
$loc = setlocale( LC_CTYPE, "" );
The following will set the LC_COLLATE behaviour to Argentinian Spanish. NOTE: The naming and availability of locales depends on your operating system. Please consult perllocale for how to find out which locales are available in your system.
$loc = setlocale( LC_ALL, "es_AR.ISO8859-1" );
This is similar to the C function setpgid() for
setting the process group identifier of the current process.
Returns undef on failure.
setsid() for
setting the session identifier of the current process.
$< variable, see perlvar/$UID, except that the latter
will change only the real user identifier.
Detailed signal management. This uses POSIX::SigAction objects for the
action and oldaction arguments. Consult your system's sigaction
manpage for details.
Synopsis:
sigaction(sig, action, oldaction = 0)
Returns undef on failure.
Examine signals that are blocked and pending. This uses POSIX::SigSet
objects for the sigset argument. Consult your system's sigpending
manpage for details.
Synopsis:
sigpending(sigset)
Returns undef on failure.
Change and/or examine calling process's signal mask. This uses
POSIX::SigSet objects for the sigset and oldsigset arguments.
Consult your system's sigprocmask manpage for details.
Synopsis:
sigprocmask(how, sigset, oldsigset = 0)
Returns undef on failure.
sigsetjmp() is C-specific: use eval {} instead,
see perlfunc/eval.
Install a signal mask and suspend process until signal arrives. This uses
POSIX::SigSet objects for the signal_mask argument. Consult your
system's sigsuspend manpage for details.
Synopsis:
sigsuspend(signal_mask)
Returns undef on failure.
sin() function
for returning the sine of the numerical argument,
see perlfunc/sin. See also Math::Trig.
sinh()
for returning the hyperbolic sine of the numerical argument.
See also Math::Trig.
sleep() function
for suspending the execution of the current for process for certain
number of seconds, see perlfunc/sleep. There is one signifanct
difference, however: POSIX::sleep() returns the number of
unslept seconds, while the CORE::sleep() returns the
number of slept seconds.
sprintf() function
for returning a string that has the arguments formatted as requested,
see perlfunc/sprintf.
sqrt() function.
for returning the square root of the numerical argument,
see perlfunc/sqrt.
stat() function
for retutning information about files and directories.
.= instead, see perlop.
eq or cmp instead, see perlop.
strcoll()
for collating (comparing) strings transformed using
the strxfrm() function. Not really needed since
Perl can do this transparently, see perllocale.
= instead, see perlop.
$!, see perlvar/$ERRNO.
Convert date and time information to string. Returns the string.
Synopsis:
strftime(fmt, sec, min, hour, mday, mon, year, wday = -1, yday = -1, isdst = -1)
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.
If you want your code to be portable, your format (fmt) argument
should use only the conversion specifiers defined by the ANSI C
standard. These are aAbBcdHIjmMpSUwWxXyYZ%.
The given arguments are made consistent
as though by calling mktime() before calling your system's
strftime() function, except that the isdst value is not affected.
The string for Tuesday, December 12, 1995.
$str = POSIX::strftime( "%A, %B %d, %Y", 0, 0, 0, 12, 11, 95, 2 ); print "$str\n";
length() instead, see perlfunc/length.
.= instead, see perlop.
eq instead, see perlop.
= instead, see perlop.
index() function,
see perlfunc/index.
String to double translation. Returns the parsed number and the number of characters in the unparsed portion of the string. Truly POSIX-compliant systems set $! ($ERRNO) to indicate a translation error, so clear $! before calling strtod. However, non-POSIX systems may not check for overflow, and therefore will never set $!.
strtod should respect any POSIX setlocale() settings.
To parse a string $str as a floating point number use
$! = 0;
($num, $n_unparsed) = POSIX::strtod($str);
The second returned item and $! can be used to check for valid input:
if (($str eq '') || ($n_unparsed != 0) || !$!) {
die "Non-numeric input $str" . $! ? ": $!\n" : "\n";
}
When called in a scalar context strtod returns the parsed number.
String to (long) integer translation. Returns the parsed number and the number of characters in the unparsed portion of the string. Truly POSIX-compliant systems set $! ($ERRNO) to indicate a translation error, so clear $! before calling strtol. However, non-POSIX systems may not check for overflow, and therefore will never set $!.
strtol should respect any POSIX setlocale() settings.
To parse a string $str as a number in some base $base use
$! = 0;
($num, $n_unparsed) = POSIX::strtol($str, $base);
The base should be zero or between 2 and 36, inclusive. When the base is zero or omitted strtol will use the string itself to determine the base: a leading "0x" or "0X" means hexadecimal; a leading "0" means octal; any other leading characters mean decimal. Thus, "1234" is parsed as a decimal number, "01234" as an octal number, and "0x1234" as a hexadecimal number.
The second returned item and $! can be used to check for valid input:
if (($str eq '') || ($n_unparsed != 0) || !$!) {
die "Non-numeric input $str" . $! ? ": $!\n" : "\n";
}
When called in a scalar context strtol returns the parsed number.
String to unsigned (long) integer translation. strtoul() is identical to strtol() except that strtoul() only parses unsigned integers. See /strtol for details.
Note: Some vendors supply strtod() and strtol() but not strtoul(). Other vendors that do supply strtoul() parse "-1" as a valid value.
String transformation. Returns the transformed string.
$dst = POSIX::strxfrm( $src );
Used in conjunction with the strcoll() function, see /strcoll.
Not really needed since Perl can do this transparently, see perllocale.
Retrieves values of system configurable variables.
The following will get the machine's clock speed.
$clock_ticks = POSIX::sysconf( &POSIX::_SC_CLK_TCK );
Returns undef on failure.
system() function, see
perlfunc/system.
tan(), returning the
tangent of the numerical argument. See also Math::Trig.
tanh(), returning the
hyperbolic tangent of the numerical argument. See also Math::Trig.
This is similar to the C function tcdrain() for draining
the output queue of its argument stream.
Returns undef on failure.
This is similar to the C function tcflow() for controlling
the flow of its argument stream.
Returns undef on failure.
This is similar to the C function tcflush() for flushing
the I/O buffers of its argumeny stream.
Returns undef on failure.
tcgetpgrp() for returning the
process group identifier of the foreground process group of the controlling
terminal.
This is similar to the C function tcsendbreak() for sending
a break on its argument stream.
Returns undef on failure.
This is similar to the C function tcsetpgrp() for setting the
process group identifier of the foreground process group of the controlling
terminal.
Returns undef on failure.
time() function
for returning the number of seconds since the epoch
(whatever it is for the system), see perlfunc/time.
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.
IO::File::new_tmpfile() instead, or see File::Temp.
Returns a name for a temporary file.
$tmpfile = POSIX::tmpnam();
For security reasons, which are probably detailed in your system's documentation for the C library tmpnam() function, this interface should not be used; instead see File::Temp.
lc() function,
see perlfunc/lc, or the equivalent \L operator inside doublequotish
strings.
uc() function,
see perlfunc/uc, or the equivalent \U operator inside doublequotish
strings.
ttyname() for returning the
name of the current terminal.
Retrieves the time conversion information from the tzname variable.
POSIX::tzset(); ($std, $dst) = POSIX::tzname();
tzset() for setting
the current timezone based on the environment variable TZ,
to be used by ctime(), localtime(), mktime(), and strftime()
functions.
umask() function
for setting (and querying) the file creation permission mask,
see perlfunc/umask.
Get name of current operating system.
($sysname, $nodename, $release, $version, $machine) = POSIX::uname();
Note that the actual meanings of the various fields are not
that well standardized, do not expect any great portability.
The $sysname might be the name of the operating system,
the $nodename might be the name of the host, the $release
might be the (major) release number of the operating system,
the $version might be the (minor) release number of the
operating system, and the $machine might be a hardware identifier.
Maybe.
IO::Handle::ungetc() instead.
unlink() function
for removing files, see perlfunc/unlink.
utime() function
for changing the time stamps of files and directories,
see perlfunc/utime.
wait() function,
see perlfunc/wait.
Wait for a child process to change state. This is identical to Perl's
builtin waitpid() function, see perlfunc/waitpid.
$pid = POSIX::waitpid( -1, POSIX::WNOHANG ); print "status = ", ($? / 256), "\n";
wcstombs().
Perl does not have any support for the wide and multibyte
characters of the C standards, so this might be a rather
useless function.
wctomb().
Perl does not have any support for the wide and multibyte
characters of the C standards, so this might be a rather
useless function.
Write to a file. This uses file descriptors such as those obtained by
calling POSIX::open.
$fd = POSIX::open( "foo", &POSIX::O_WRONLY ); $buf = "hello"; $bytes = POSIX::write( $b, $buf, 5 );
Returns undef on failure.
See also perlfunc/syswrite.
Creates a new POSIX::SigAction object which corresponds to the C
struct sigaction. This object will be destroyed automatically when it is
no longer needed. The first parameter is the fully-qualified name of a sub
which is a signal-handler. The second parameter is a POSIX::SigSet
object, it defaults to the empty set. The third parameter contains the
sa_flags, it defaults to 0.
$sigset = POSIX::SigSet->new(SIGINT, SIGQUIT); $sigaction = POSIX::SigAction->new( 'main::handler', $sigset, &POSIX::SA_NOCLDSTOP );
This POSIX::SigAction object should be used with the POSIX::sigaction()
function.
accessor functions to get/set the values of a SigAction object.
$sigset = $sigaction->mask; $sigaction->flags(&POSIX::SA_RESTART);
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 );
Add a signal to a SigSet object.
$sigset->addset( &POSIX::SIGUSR2 );
Returns undef on failure.
Remove a signal from the SigSet object.
$sigset->delset( &POSIX::SIGUSR2 );
Returns undef on failure.
Initialize the SigSet object to be empty.
$sigset->emptyset();
Returns undef on failure.
Initialize the SigSet object to include all signals.
$sigset->fillset();
Returns undef on failure.
Tests the SigSet object to see if it contains a specific signal.
if( $sigset->ismember( &POSIX::SIGUSR1 ) ){
print "contains SIGUSR1\n";
}
Create a new Termios object. This object will be destroyed automatically when it is no longer needed. A Termios object corresponds to the termios C struct. new() mallocs a new one, getattr() fills it from a file descriptor, and setattr() sets a file descriptor's parameters to match Termios' contents.
$termios = POSIX::Termios->new;
Get terminal control attributes.
Obtain the attributes for stdin.
$termios->getattr()
Obtain the attributes for stdout.
$termios->getattr( 1 )
Returns undef on failure.
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);
Retrieve the c_cflag field of a termios object.
$c_cflag = $termios->getcflag;
Retrieve the c_iflag field of a termios object.
$c_iflag = $termios->getiflag;
Retrieve the input baud rate.
$ispeed = $termios->getispeed;
Retrieve the c_lflag field of a termios object.
$c_lflag = $termios->getlflag;
Retrieve the c_oflag field of a termios object.
$c_oflag = $termios->getoflag;
Retrieve the output baud rate.
$ospeed = $termios->getospeed;
Set terminal control attributes.
Set attributes immediately for stdout.
$termios->setattr( 1, &POSIX::TCSANOW );
Returns undef on failure.
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( &POSIX::VEOF, 1 );
Set the c_cflag field of a termios object.
$termios->setcflag( $c_cflag | &POSIX::CLOCAL );
Set the c_iflag field of a termios object.
$termios->setiflag( $c_iflag | &POSIX::BRKINT );
Set the input baud rate.
$termios->setispeed( &POSIX::B9600 );
Returns undef on failure.
Set the c_lflag field of a termios object.
$termios->setlflag( $c_lflag | &POSIX::ECHO );
Set the c_oflag field of a termios object.
$termios->setoflag( $c_oflag | &POSIX::OPOST );
Set the output baud rate.
$termios->setospeed( &POSIX::B9600 );
Returns undef on failure.
WNOHANG WUNTRACED
WIFEXITED WEXITSTATUS WIFSIGNALED WTERMSIG WIFSTOPPED WSTOPSIG
exit() or by falling off the end of main())